(***** GENERATED FILE -- DO NOT EDIT ****)
functor TracLrValsFun(structure Token : TOKEN)
 : sig structure ParserData : PARSER_DATA
       structure Tokens : Trac_TOKENS
   end
 = 
struct
structure ParserData=
struct
structure Header = 
struct
(*
(C) Copyright Andreas Viktor Hess, DTU, 2020
(C) Copyright Sebastian A. Mödersheim, DTU, 2020
(C) Copyright Achim D. Brucker, University of Exeter, 2020
(C) Copyright Anders Schlichtkrull, DTU, 2020

All Rights Reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:

- Redistributions of source code must retain the above copyright
  notice, this list of conditions and the following disclaimer.

- Redistributions in binary form must reproduce the above copyright
  notice, this list of conditions and the following disclaimer in the
  documentation and/or other materials provided with the distribution.

- Neither the name of the copyright holder nor the names of its
  contributors may be used to endorse or promote products
  derived from this software without specific prior written
  permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*)

open Trac_Term

exception NotYetSupported of string 



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\003\000\013\000\009\000\012\000\010\000\011\000\012\000\010\000\
\\013\000\009\000\000\000\
\\001\000\005\000\038\000\000\000\
\\001\000\005\000\047\000\000\000\
\\001\000\007\000\036\000\000\000\
\\001\000\008\000\028\000\012\000\010\000\013\000\009\000\014\000\027\000\
\\015\000\026\000\016\000\025\000\000\000\
\\001\000\008\000\032\000\012\000\010\000\000\000\
\\001\000\009\000\012\000\010\000\011\000\012\000\010\000\013\000\009\000\000\000\
\\001\000\010\000\019\000\000\000\
\\001\000\012\000\010\000\013\000\009\000\000\000\
\\001\000\012\000\010\000\013\000\009\000\017\000\018\000\000\000\
\\001\000\014\000\027\000\015\000\026\000\016\000\025\000\000\000\
\\051\000\000\000\
\\052\000\000\000\
\\053\000\000\000\
\\054\000\009\000\012\000\010\000\011\000\012\000\010\000\013\000\009\000\000\000\
\\055\000\000\000\
\\056\000\000\000\
\\057\000\000\000\
\\058\000\000\000\
\\059\000\000\000\
\\060\000\004\000\015\000\000\000\
\\061\000\004\000\033\000\000\000\
\\062\000\004\000\042\000\000\000\
\\063\000\000\000\
\\064\000\006\000\014\000\000\000\
\\065\000\000\000\
\\066\000\002\000\035\000\000\000\
\\067\000\000\000\
\\068\000\000\000\
\\069\000\000\000\
\\070\000\000\000\
\\071\000\008\000\032\000\012\000\010\000\000\000\
\\072\000\000\000\
\\073\000\000\000\
\\074\000\000\000\
\\075\000\000\000\
\\076\000\000\000\
\\077\000\000\000\
\\078\000\000\000\
\\079\000\000\000\
\\080\000\000\000\
\\081\000\000\000\
\"
val actionRowNumbers =
"\001\000\025\000\024\000\021\000\
\\015\000\014\000\012\000\037\000\
\\036\000\010\000\008\000\007\000\
\\005\000\006\000\016\000\022\000\
\\017\000\009\000\013\000\031\000\
\\027\000\004\000\029\000\041\000\
\\042\000\040\000\011\000\002\000\
\\032\000\018\000\011\000\006\000\
\\023\000\005\000\026\000\030\000\
\\009\000\033\000\003\000\019\000\
\\006\000\028\000\039\000\038\000\
\\035\000\009\000\020\000\034\000\
\\000\000"
val gotoT =
"\
\\001\000\048\000\002\000\006\000\003\000\005\000\004\000\004\000\
\\005\000\003\000\011\000\002\000\012\000\001\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\003\000\014\000\004\000\004\000\005\000\003\000\011\000\002\000\
\\012\000\001\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\005\000\015\000\011\000\002\000\012\000\001\000\000\000\
\\000\000\
\\003\000\018\000\004\000\004\000\005\000\003\000\011\000\002\000\
\\012\000\001\000\000\000\
\\005\000\022\000\006\000\021\000\007\000\020\000\011\000\002\000\
\\012\000\001\000\013\000\019\000\000\000\
\\008\000\029\000\009\000\028\000\011\000\027\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\005\000\032\000\011\000\002\000\012\000\001\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\013\000\035\000\000\000\
\\000\000\
\\008\000\037\000\009\000\028\000\011\000\027\000\000\000\
\\000\000\
\\013\000\038\000\000\000\
\\008\000\039\000\009\000\028\000\011\000\027\000\000\000\
\\000\000\
\\005\000\022\000\006\000\041\000\007\000\020\000\011\000\002\000\
\\012\000\001\000\013\000\019\000\000\000\
\\000\000\
\\000\000\
\\010\000\044\000\011\000\043\000\012\000\042\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\008\000\046\000\009\000\028\000\011\000\027\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\010\000\047\000\011\000\043\000\012\000\042\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\"
val numstates = 49
val numrules = 31
val s = Unsynchronized.ref "" and index = Unsynchronized.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 General.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(List.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 =  ( int * int * int ) 
type arg = unit
structure MlyValue = 
struct
datatype svalue = VOID | ntVOID of unit ->  unit
 | ATTACK of unit ->  (string) | ZERO of unit ->  (string)
 | ONE of unit ->  (string) | INTEGER_LITERAL of unit ->  (string)
 | LOWER_STRING_LITERAL of unit ->  (string)
 | UPPER_STRING_LITERAL of unit ->  (string)
 | STRING_LITERAL of unit ->  (string)
 | DOUBLE_RARROW of unit ->  (string)
 | DOUBLE_ASTERISK of unit ->  (string)
 | ASTERISK of unit ->  (string) | PAREN_CLOSE of unit ->  (string)
 | PAREN_OPEN of unit ->  (string) | COLON of unit ->  (string)
 | WHERE of unit ->  (string) | FIXEDPOINT of unit ->  (string)
 | COMMA of unit ->  (string) | int_literal of unit ->  (string)
 | lower_literal of unit ->  (string)
 | upper_literal of unit ->  (string)
 | string_literal of unit ->  (string)
 | type_exp of unit ->  (TypeDecl)
 | type_list_exp of unit ->  (TypeDecl list)
 | arg_exp of unit ->  (Msg) | arg_list_exp of unit ->  (Msg list)
 | rule_exp of unit ->  (Msg)
 | symfact_exp of unit ->  (Msg*TypeDecl list)
 | symfact_list_exp of unit ->  ( ( Msg * TypeDecl list )  list)
 | trac_file of unit ->  ( ( Msg * TypeDecl list )  list)
 | START of unit ->  ( ( Msg * TypeDecl list )  list)
end
type svalue = MlyValue.svalue
type result =  ( Msg * TypeDecl list )  list
end
structure EC=
struct
open LrTable
infix 5 $$
fun x $$ y = y::x
val is_keyword =
fn _ => 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) => "COMMA"
  | (T 2) => "FIXEDPOINT"
  | (T 3) => "WHERE"
  | (T 4) => "COLON"
  | (T 5) => "PAREN_OPEN"
  | (T 6) => "PAREN_CLOSE"
  | (T 7) => "ASTERISK"
  | (T 8) => "DOUBLE_ASTERISK"
  | (T 9) => "DOUBLE_RARROW"
  | (T 10) => "STRING_LITERAL"
  | (T 11) => "UPPER_STRING_LITERAL"
  | (T 12) => "LOWER_STRING_LITERAL"
  | (T 13) => "INTEGER_LITERAL"
  | (T 14) => "ONE"
  | (T 15) => "ZERO"
  | (T 16) => "ATTACK"
  | _ => "bogus-term"
local open Header in
val errtermvalue=
fn _ => MlyValue.VOID
end
val terms : term list = nil
 $$ (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.trac_file trac_file1, trac_file1left, 
trac_file1right)) :: rest671)) => let val  result = MlyValue.START (fn
 _ => let val  (trac_file as trac_file1) = trac_file1 ()
 in (trac_file)
end)
 in ( LrTable.NT 0, ( result, trac_file1left, trac_file1right), 
rest671)
end
|  ( 1, ( ( _, ( MlyValue.symfact_list_exp symfact_list_exp1, _, 
symfact_list_exp1right)) :: ( _, ( MlyValue.FIXEDPOINT FIXEDPOINT1, 
FIXEDPOINT1left, _)) :: rest671)) => let val  result = 
MlyValue.trac_file (fn _ => let val  FIXEDPOINT1 = FIXEDPOINT1 ()
 val  (symfact_list_exp as symfact_list_exp1) = symfact_list_exp1 ()
 in (symfact_list_exp)
end)
 in ( LrTable.NT 1, ( result, FIXEDPOINT1left, symfact_list_exp1right)
, rest671)
end
|  ( 2, ( ( _, ( MlyValue.symfact_list_exp symfact_list_exp1, 
symfact_list_exp1left, symfact_list_exp1right)) :: rest671)) => let
 val  result = MlyValue.trac_file (fn _ => let val  (symfact_list_exp
 as symfact_list_exp1) = symfact_list_exp1 ()
 in (symfact_list_exp)
end)
 in ( LrTable.NT 1, ( result, symfact_list_exp1left, 
symfact_list_exp1right), rest671)
end
|  ( 3, ( ( _, ( MlyValue.symfact_exp symfact_exp1, symfact_exp1left, 
symfact_exp1right)) :: rest671)) => let val  result = 
MlyValue.symfact_list_exp (fn _ => let val  (symfact_exp as 
symfact_exp1) = symfact_exp1 ()
 in ([symfact_exp])
end)
 in ( LrTable.NT 2, ( result, symfact_exp1left, symfact_exp1right), 
rest671)
end
|  ( 4, ( ( _, ( MlyValue.symfact_list_exp symfact_list_exp1, _, 
symfact_list_exp1right)) :: ( _, ( MlyValue.symfact_exp symfact_exp1, 
symfact_exp1left, _)) :: rest671)) => let val  result = 
MlyValue.symfact_list_exp (fn _ => let val  (symfact_exp as 
symfact_exp1) = symfact_exp1 ()
 val  (symfact_list_exp as symfact_list_exp1) = symfact_list_exp1 ()
 in ([symfact_exp]@symfact_list_exp)
end)
 in ( LrTable.NT 2, ( result, symfact_exp1left, symfact_list_exp1right
), rest671)
end
|  ( 5, ( ( _, ( MlyValue.ATTACK ATTACK1, _, ATTACK1right)) :: ( _, ( 
MlyValue.DOUBLE_RARROW DOUBLE_RARROW1, DOUBLE_RARROW1left, _)) :: 
rest671)) => let val  result = MlyValue.symfact_exp (fn _ => let val  
DOUBLE_RARROW1 = DOUBLE_RARROW1 ()
 val  ATTACK1 = ATTACK1 ()
 in ((Attack,[]))
end)
 in ( LrTable.NT 3, ( result, DOUBLE_RARROW1left, ATTACK1right), 
rest671)
end
|  ( 6, ( ( _, ( MlyValue.type_list_exp type_list_exp1, _, 
type_list_exp1right)) :: ( _, ( MlyValue.WHERE WHERE1, _, _)) :: ( _, 
( MlyValue.rule_exp rule_exp1, rule_exp1left, _)) :: rest671)) => let
 val  result = MlyValue.symfact_exp (fn _ => let val  (rule_exp as 
rule_exp1) = rule_exp1 ()
 val  WHERE1 = WHERE1 ()
 val  (type_list_exp as type_list_exp1) = type_list_exp1 ()
 in ((rule_exp,type_list_exp))
end)
 in ( LrTable.NT 3, ( result, rule_exp1left, type_list_exp1right), 
rest671)
end
|  ( 7, ( ( _, ( MlyValue.type_list_exp type_list_exp1, _, 
type_list_exp1right)) :: ( _, ( MlyValue.WHERE WHERE1, _, _)) :: ( _, 
( MlyValue.rule_exp rule_exp1, _, _)) :: ( _, ( MlyValue.DOUBLE_RARROW
 DOUBLE_RARROW1, DOUBLE_RARROW1left, _)) :: rest671)) => let val  
result = MlyValue.symfact_exp (fn _ => let val  DOUBLE_RARROW1 = 
DOUBLE_RARROW1 ()
 val  (rule_exp as rule_exp1) = rule_exp1 ()
 val  WHERE1 = WHERE1 ()
 val  (type_list_exp as type_list_exp1) = type_list_exp1 ()
 in ((rule_exp,type_list_exp))
end)
 in ( LrTable.NT 3, ( result, DOUBLE_RARROW1left, type_list_exp1right)
, rest671)
end
|  ( 8, ( ( _, ( MlyValue.type_list_exp type_list_exp1, _, 
type_list_exp1right)) :: ( _, ( MlyValue.WHERE WHERE1, _, _)) :: ( _, 
( MlyValue.rule_exp rule_exp1, _, _)) :: ( _, ( MlyValue.DOUBLE_RARROW
 DOUBLE_RARROW1, _, _)) :: ( _, ( MlyValue.DOUBLE_ASTERISK 
DOUBLE_ASTERISK1, DOUBLE_ASTERISK1left, _)) :: rest671)) => let val  
result = MlyValue.symfact_exp (fn _ => let val  DOUBLE_ASTERISK1 = 
DOUBLE_ASTERISK1 ()
 val  DOUBLE_RARROW1 = DOUBLE_RARROW1 ()
 val  (rule_exp as rule_exp1) = rule_exp1 ()
 val  WHERE1 = WHERE1 ()
 val  (type_list_exp as type_list_exp1) = type_list_exp1 ()
 in ((rule_exp,type_list_exp))
end)
 in ( LrTable.NT 3, ( result, DOUBLE_ASTERISK1left, 
type_list_exp1right), rest671)
end
|  ( 9, ( ( _, ( MlyValue.rule_exp rule_exp1, rule_exp1left, 
rule_exp1right)) :: rest671)) => let val  result = 
MlyValue.symfact_exp (fn _ => let val  (rule_exp as rule_exp1) = 
rule_exp1 ()
 in ((rule_exp,[]))
end)
 in ( LrTable.NT 3, ( result, rule_exp1left, rule_exp1right), rest671)

end
|  ( 10, ( ( _, ( MlyValue.rule_exp rule_exp1, _, rule_exp1right)) :: 
( _, ( MlyValue.DOUBLE_RARROW DOUBLE_RARROW1, DOUBLE_RARROW1left, _))
 :: rest671)) => let val  result = MlyValue.symfact_exp (fn _ => let
 val  DOUBLE_RARROW1 = DOUBLE_RARROW1 ()
 val  (rule_exp as rule_exp1) = rule_exp1 ()
 in ((rule_exp,[]))
end)
 in ( LrTable.NT 3, ( result, DOUBLE_RARROW1left, rule_exp1right), 
rest671)
end
|  ( 11, ( ( _, ( MlyValue.rule_exp rule_exp1, _, rule_exp1right)) :: 
( _, ( MlyValue.DOUBLE_RARROW DOUBLE_RARROW1, _, _)) :: ( _, ( 
MlyValue.DOUBLE_ASTERISK DOUBLE_ASTERISK1, DOUBLE_ASTERISK1left, _))
 :: rest671)) => let val  result = MlyValue.symfact_exp (fn _ => let
 val  DOUBLE_ASTERISK1 = DOUBLE_ASTERISK1 ()
 val  DOUBLE_RARROW1 = DOUBLE_RARROW1 ()
 val  (rule_exp as rule_exp1) = rule_exp1 ()
 in ((rule_exp,[]))
end)
 in ( LrTable.NT 3, ( result, DOUBLE_ASTERISK1left, rule_exp1right), 
rest671)
end
|  ( 12, ( ( _, ( MlyValue.upper_literal upper_literal1, 
upper_literal1left, upper_literal1right)) :: rest671)) => let val  
result = MlyValue.rule_exp (fn _ => let val  (upper_literal as 
upper_literal1) = upper_literal1 ()
 in (Var (upper_literal))
end)
 in ( LrTable.NT 4, ( result, upper_literal1left, upper_literal1right)
, rest671)
end
|  ( 13, ( ( _, ( MlyValue.lower_literal lower_literal1, 
lower_literal1left, lower_literal1right)) :: rest671)) => let val  
result = MlyValue.rule_exp (fn _ => let val  (lower_literal as 
lower_literal1) = lower_literal1 ()
 in (Fun (lower_literal,[]))
end)
 in ( LrTable.NT 4, ( result, lower_literal1left, lower_literal1right)
, rest671)
end
|  ( 14, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, 
PAREN_CLOSE1right)) :: ( _, ( MlyValue.arg_list_exp arg_list_exp1, _,
 _)) :: ( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1, _, _)) :: ( _, ( 
MlyValue.lower_literal lower_literal1, lower_literal1left, _)) :: 
rest671)) => let val  result = MlyValue.rule_exp (fn _ => let val  (
lower_literal as lower_literal1) = lower_literal1 ()
 val  PAREN_OPEN1 = PAREN_OPEN1 ()
 val  (arg_list_exp as arg_list_exp1) = arg_list_exp1 ()
 val  PAREN_CLOSE1 = PAREN_CLOSE1 ()
 in (Fun (lower_literal,arg_list_exp))
end)
 in ( LrTable.NT 4, ( result, lower_literal1left, PAREN_CLOSE1right), 
rest671)
end
|  ( 15, ( ( _, ( MlyValue.arg_exp arg_exp1, arg_exp1left, 
arg_exp1right)) :: rest671)) => let val  result = 
MlyValue.arg_list_exp (fn _ => let val  (arg_exp as arg_exp1) = 
arg_exp1 ()
 in ([arg_exp])
end)
 in ( LrTable.NT 5, ( result, arg_exp1left, arg_exp1right), rest671)

end
|  ( 16, ( ( _, ( MlyValue.arg_list_exp arg_list_exp1, _, 
arg_list_exp1right)) :: ( _, ( MlyValue.COMMA COMMA1, _, _)) :: ( _, (
 MlyValue.arg_exp arg_exp1, arg_exp1left, _)) :: rest671)) => let val 
 result = MlyValue.arg_list_exp (fn _ => let val  (arg_exp as arg_exp1
) = arg_exp1 ()
 val  COMMA1 = COMMA1 ()
 val  (arg_list_exp as arg_list_exp1) = arg_list_exp1 ()
 in ([arg_exp]@arg_list_exp)
end)
 in ( LrTable.NT 5, ( result, arg_exp1left, arg_list_exp1right), 
rest671)
end
|  ( 17, ( ( _, ( MlyValue.rule_exp rule_exp1, rule_exp1left, 
rule_exp1right)) :: rest671)) => let val  result = MlyValue.arg_exp
 (fn _ => let val  (rule_exp as rule_exp1) = rule_exp1 ()
 in (rule_exp)
end)
 in ( LrTable.NT 6, ( result, rule_exp1left, rule_exp1right), rest671)

end
|  ( 18, ( ( _, ( MlyValue.int_literal int_literal1, _, 
int_literal1right)) :: ( _, ( MlyValue.ASTERISK ASTERISK1, 
ASTERISK1left, _)) :: rest671)) => let val  result = MlyValue.arg_exp
 (fn _ => let val  ASTERISK1 = ASTERISK1 ()
 val  (int_literal as int_literal1) = int_literal1 ()
 in (Var (int_literal))
end)
 in ( LrTable.NT 6, ( result, ASTERISK1left, int_literal1right), 
rest671)
end
|  ( 19, ( ( _, ( MlyValue.int_literal int_literal1, int_literal1left,
 int_literal1right)) :: rest671)) => let val  result = 
MlyValue.arg_exp (fn _ => let val  (int_literal as int_literal1) = 
int_literal1 ()
 in (Const (int_literal))
end)
 in ( LrTable.NT 6, ( result, int_literal1left, int_literal1right), 
rest671)
end
|  ( 20, ( ( _, ( MlyValue.type_exp type_exp1, type_exp1left, 
type_exp1right)) :: rest671)) => let val  result = 
MlyValue.type_list_exp (fn _ => let val  (type_exp as type_exp1) = 
type_exp1 ()
 in ([type_exp])
end)
 in ( LrTable.NT 7, ( result, type_exp1left, type_exp1right), rest671)

end
|  ( 21, ( ( _, ( MlyValue.type_list_exp type_list_exp1, _, 
type_list_exp1right)) :: ( _, ( MlyValue.type_exp type_exp1, 
type_exp1left, _)) :: rest671)) => let val  result = 
MlyValue.type_list_exp (fn _ => let val  (type_exp as type_exp1) = 
type_exp1 ()
 val  (type_list_exp as type_list_exp1) = type_list_exp1 ()
 in ([type_exp]@type_list_exp)
end)
 in ( LrTable.NT 7, ( result, type_exp1left, type_list_exp1right), 
rest671)
end
|  ( 22, ( ( _, ( MlyValue.string_literal string_literal1, _, 
string_literal1right)) :: ( _, ( MlyValue.COLON COLON1, _, _)) :: ( _,
 ( MlyValue.int_literal int_literal1, _, _)) :: ( _, ( 
MlyValue.ASTERISK ASTERISK1, ASTERISK1left, _)) :: rest671)) => let
 val  result = MlyValue.type_exp (fn _ => let val  ASTERISK1 = 
ASTERISK1 ()
 val  (int_literal as int_literal1) = int_literal1 ()
 val  COLON1 = COLON1 ()
 val  (string_literal as string_literal1) = string_literal1 ()
 in ((int_literal,string_literal))
end)
 in ( LrTable.NT 8, ( result, ASTERISK1left, string_literal1right), 
rest671)
end
|  ( 23, ( ( _, ( MlyValue.string_literal string_literal1, _, 
string_literal1right)) :: ( _, ( MlyValue.COLON COLON1, _, _)) :: ( _,
 ( MlyValue.upper_literal upper_literal1, upper_literal1left, _)) :: 
rest671)) => let val  result = MlyValue.type_exp (fn _ => let val  (
upper_literal as upper_literal1) = upper_literal1 ()
 val  COLON1 = COLON1 ()
 val  (string_literal as string_literal1) = string_literal1 ()
 in ((upper_literal,string_literal))
end)
 in ( LrTable.NT 8, ( result, upper_literal1left, string_literal1right
), rest671)
end
|  ( 24, ( ( _, ( MlyValue.UPPER_STRING_LITERAL UPPER_STRING_LITERAL1,
 UPPER_STRING_LITERAL1left, UPPER_STRING_LITERAL1right)) :: rest671))
 => let val  result = MlyValue.upper_literal (fn _ => let val  (
UPPER_STRING_LITERAL as UPPER_STRING_LITERAL1) = UPPER_STRING_LITERAL1
 ()
 in (UPPER_STRING_LITERAL)
end)
 in ( LrTable.NT 10, ( result, UPPER_STRING_LITERAL1left, 
UPPER_STRING_LITERAL1right), rest671)
end
|  ( 25, ( ( _, ( MlyValue.LOWER_STRING_LITERAL LOWER_STRING_LITERAL1,
 LOWER_STRING_LITERAL1left, LOWER_STRING_LITERAL1right)) :: rest671))
 => let val  result = MlyValue.lower_literal (fn _ => let val  (
LOWER_STRING_LITERAL as LOWER_STRING_LITERAL1) = LOWER_STRING_LITERAL1
 ()
 in (LOWER_STRING_LITERAL)
end)
 in ( LrTable.NT 11, ( result, LOWER_STRING_LITERAL1left, 
LOWER_STRING_LITERAL1right), rest671)
end
|  ( 26, ( ( _, ( MlyValue.upper_literal upper_literal1, 
upper_literal1left, upper_literal1right)) :: rest671)) => let val  
result = MlyValue.string_literal (fn _ => let val  (upper_literal as 
upper_literal1) = upper_literal1 ()
 in (upper_literal)
end)
 in ( LrTable.NT 9, ( result, upper_literal1left, upper_literal1right)
, rest671)
end
|  ( 27, ( ( _, ( MlyValue.lower_literal lower_literal1, 
lower_literal1left, lower_literal1right)) :: rest671)) => let val  
result = MlyValue.string_literal (fn _ => let val  (lower_literal as 
lower_literal1) = lower_literal1 ()
 in (lower_literal)
end)
 in ( LrTable.NT 9, ( result, lower_literal1left, lower_literal1right)
, rest671)
end
|  ( 28, ( ( _, ( MlyValue.INTEGER_LITERAL INTEGER_LITERAL1, 
INTEGER_LITERAL1left, INTEGER_LITERAL1right)) :: rest671)) => let val 
 result = MlyValue.int_literal (fn _ => let val  (INTEGER_LITERAL as 
INTEGER_LITERAL1) = INTEGER_LITERAL1 ()
 in (INTEGER_LITERAL)
end)
 in ( LrTable.NT 12, ( result, INTEGER_LITERAL1left, 
INTEGER_LITERAL1right), rest671)
end
|  ( 29, ( ( _, ( MlyValue.ZERO ZERO1, ZERO1left, ZERO1right)) :: 
rest671)) => let val  result = MlyValue.int_literal (fn _ => let val  
ZERO1 = ZERO1 ()
 in ("0")
end)
 in ( LrTable.NT 12, ( result, ZERO1left, ZERO1right), rest671)
end
|  ( 30, ( ( _, ( MlyValue.ONE ONE1, ONE1left, ONE1right)) :: rest671)
) => let val  result = MlyValue.int_literal (fn _ => let val  ONE1 = 
ONE1 ()
 in ("1")
end)
 in ( LrTable.NT 12, ( result, ONE1left, ONE1right), rest671)
end
| _ => raise (mlyAction i392)
end
val void = MlyValue.VOID
val extract = fn a => (fn MlyValue.START x => x
| _ => let exception ParseInternal
	in raise ParseInternal end) a ()
end
end
structure Tokens : Trac_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 COMMA (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 1,(
ParserData.MlyValue.COMMA (fn () => i),p1,p2))
fun FIXEDPOINT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 2,(
ParserData.MlyValue.FIXEDPOINT (fn () => i),p1,p2))
fun WHERE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 3,(
ParserData.MlyValue.WHERE (fn () => i),p1,p2))
fun COLON (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 4,(
ParserData.MlyValue.COLON (fn () => i),p1,p2))
fun PAREN_OPEN (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 5,(
ParserData.MlyValue.PAREN_OPEN (fn () => i),p1,p2))
fun PAREN_CLOSE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 6,(
ParserData.MlyValue.PAREN_CLOSE (fn () => i),p1,p2))
fun ASTERISK (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 7,(
ParserData.MlyValue.ASTERISK (fn () => i),p1,p2))
fun DOUBLE_ASTERISK (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 8,(
ParserData.MlyValue.DOUBLE_ASTERISK (fn () => i),p1,p2))
fun DOUBLE_RARROW (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 9,(
ParserData.MlyValue.DOUBLE_RARROW (fn () => i),p1,p2))
fun STRING_LITERAL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 10,(
ParserData.MlyValue.STRING_LITERAL (fn () => i),p1,p2))
fun UPPER_STRING_LITERAL (i,p1,p2) = Token.TOKEN (
ParserData.LrTable.T 11,(ParserData.MlyValue.UPPER_STRING_LITERAL
 (fn () => i),p1,p2))
fun LOWER_STRING_LITERAL (i,p1,p2) = Token.TOKEN (
ParserData.LrTable.T 12,(ParserData.MlyValue.LOWER_STRING_LITERAL
 (fn () => i),p1,p2))
fun INTEGER_LITERAL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 13,(
ParserData.MlyValue.INTEGER_LITERAL (fn () => i),p1,p2))
fun ONE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 14,(
ParserData.MlyValue.ONE (fn () => i),p1,p2))
fun ZERO (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 15,(
ParserData.MlyValue.ZERO (fn () => i),p1,p2))
fun ATTACK (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 16,(
ParserData.MlyValue.ATTACK (fn () => i),p1,p2))
end
end