Import Upstream version 20180207

[hcoop/debian/mlton.git] / benchmark / tests / hamlet.sml

(*
 * 2001-2-14.
 * Stephen Weeks (sweeks@sweeks.com) generated this file from the hamlet SML
 * interpreter written by Andreas Rossberg.
 * The sources are from http://www.ps.uni-sb.de/~rossberg/hamlet/hamlet.tar
 *
 * The file consists of the concatenation of all of the source code (plus SML/NJ
 * library code) in the correct order, with a simple test case to test the
 * interpreter at the end.
 *
 * I also removed uses of the nonstandard Unsafe structure.
 *
 * I also made a minor change so that it could read in from a file instead of
 * from stdIn.
 *)

val ins = ref TextIO.stdIn

(* start of STAMP.sml *)
(*
 * Stamp generator.
 *)


signature STAMP =
  sig

    eqtype stamp

    val stamp:    unit  -> stamp
    val toString: stamp -> string

    val reset:    unit -> unit

    val compare:  stamp * stamp -> order

  end
(* stop of STAMP.sml *)
(* start of Stamp.sml *)
(*
 * Stamp generator.
 *)


structure Stamp :> STAMP =
  struct

    type stamp = int

    val r = ref 0

    fun reset()  =  r := 0
    fun stamp()  = (r := !r + 1; !r)

    val toString = Int.toString
    val compare  = Int.compare

  end
(* stop of Stamp.sml *)
(* start of smlnj-lib/Util/ord-key-sig.sml *)
(* ord-key-sig.sml
 *
 * COPYRIGHT (c) 1993 by AT&T Bell Laboratories.  See COPYRIGHT file for details.
 *
 * Abstract linearly ordered keys.
 *
 *)

signature ORD_KEY =
  sig
    type ord_key

    val compare : ord_key * ord_key -> order

  end (* ORD_KEY *)
(* stop of smlnj-lib/Util/ord-key-sig.sml *)
(* start of smlnj-lib/Util/lib-base-sig.sml *)
(* lib-base-sig.sml
 *
 * COPYRIGHT (c) 1993 by AT&T Bell Laboratories.  See COPYRIGHT file for details.
 *)

signature LIB_BASE =
  sig

    exception Unimplemented of string
        (* raised to report unimplemented features *)
    exception Impossible of string
        (* raised to report internal errors *)

    exception NotFound
        (* raised by searching operations *)

    val failure : {module : string, func : string, msg : string} -> 'a
        (* raise the exception Fail with a standard format message. *)

    val version : {date : string, system : string, version_id : int list}
    val banner : string

  end (* LIB_BASE *)

(* stop of smlnj-lib/Util/lib-base-sig.sml *)
(* start of smlnj-lib/Util/lib-base.sml *)
(* lib-base.sml
 *
 * COPYRIGHT (c) 1993 by AT&T Bell Laboratories.  See COPYRIGHT file for details.
 *)

structure LibBase : LIB_BASE =
  struct

  (* raised to report unimplemented features *)
    exception Unimplemented of string

  (* raised to report internal errors *)
    exception Impossible of string

  (* raised by searching operations *)
    exception NotFound

  (* raise the exception Fail with a standard format message. *)
    fun failure {module, func, msg} =
          raise (Fail(concat[module, ".", func, ": ", msg]))

    val version = {
            date = "June 1, 1996", 
            system = "SML/NJ Library",
            version_id = [1, 0]
          }

    fun f ([], l) = l
      | f ([x : int], l) = (Int.toString x)::l
      | f (x::r, l) = (Int.toString x) :: "." :: f(r, l)

    val banner = concat (
            #system version :: ", Version " ::
            f (#version_id version, [", ", #date version]))

  end (* LibBase *)

(* stop of smlnj-lib/Util/lib-base.sml *)
(* start of smlnj-lib/Util/ord-map-sig.sml *)
(* ord-map-sig.sml
 *
 * COPYRIGHT (c) 1996 by AT&T Research.  See COPYRIGHT file for details.
 *
 * Abstract signature of an applicative-style finite maps (dictionaries)
 * structure over ordered monomorphic keys.
 *)

signature ORD_MAP =
  sig

    structure Key : ORD_KEY

    type 'a map

    val empty : 'a map
        (* The empty map *)

    val isEmpty : 'a map -> bool
        (* Return true if and only if the map is empty *)

    val singleton : (Key.ord_key * 'a) -> 'a map
        (* return the specified singleton map *)

    val insert  : 'a map * Key.ord_key * 'a -> 'a map
    val insert' : ((Key.ord_key * 'a) * 'a map) -> 'a map
        (* Insert an item. *)

    val find : 'a map * Key.ord_key -> 'a option
        (* Look for an item, return NONE if the item doesn't exist *)

    val inDomain : ('a map * Key.ord_key) -> bool
        (* return true, if the key is in the domain of the map *)

    val remove : 'a map * Key.ord_key -> 'a map * 'a
        (* Remove an item, returning new map and value removed.
         * Raises LibBase.NotFound if not found.
         *)

    val first : 'a map -> 'a option
    val firsti : 'a map -> (Key.ord_key * 'a) option
        (* return the first item in the map (or NONE if it is empty) *)

    val numItems : 'a map ->  int
        (* Return the number of items in the map *)

    val listItems  : 'a map -> 'a list
    val listItemsi : 'a map -> (Key.ord_key * 'a) list
        (* Return an ordered list of the items (and their keys) in the map. *)

    val listKeys : 'a map -> Key.ord_key list
        (* return an ordered list of the keys in the map. *)

    val collate : ('a * 'a -> order) -> ('a map * 'a map) -> order
        (* given an ordering on the map's range, return an ordering
         * on the map.
         *)

    val unionWith  : ('a * 'a -> 'a) -> ('a map * 'a map) -> 'a map
    val unionWithi : (Key.ord_key * 'a * 'a -> 'a) -> ('a map * 'a map) -> 'a map
        (* return a map whose domain is the union of the domains of the two input
         * maps, using the supplied function to define the map on elements that
         * are in both domains.
         *)

    val intersectWith  : ('a * 'b -> 'c) -> ('a map * 'b map) -> 'c map
    val intersectWithi : (Key.ord_key * 'a * 'b -> 'c) -> ('a map * 'b map) -> 'c map
        (* return a map whose domain is the intersection of the domains of the
         * two input maps, using the supplied function to define the range.
         *)

    val app  : ('a -> unit) -> 'a map -> unit
    val appi : ((Key.ord_key * 'a) -> unit) -> 'a map -> unit
        (* Apply a function to the entries of the map in map order. *)

    val map  : ('a -> 'b) -> 'a map -> 'b map
    val mapi : (Key.ord_key * 'a -> 'b) -> 'a map -> 'b map
        (* Create a new map by applying a map function to the
         * name/value pairs in the map.
         *)

    val foldl  : ('a * 'b -> 'b) -> 'b -> 'a map -> 'b
    val foldli : (Key.ord_key * 'a * 'b -> 'b) -> 'b -> 'a map -> 'b
        (* Apply a folding function to the entries of the map
         * in increasing map order.
         *)

    val foldr  : ('a * 'b -> 'b) -> 'b -> 'a map -> 'b
    val foldri : (Key.ord_key * 'a * 'b -> 'b) -> 'b -> 'a map -> 'b
        (* Apply a folding function to the entries of the map
         * in decreasing map order.
         *)

    val filter  : ('a -> bool) -> 'a map -> 'a map
    val filteri : (Key.ord_key * 'a -> bool) -> 'a map -> 'a map
        (* Filter out those elements of the map that do not satisfy the
         * predicate.  The filtering is done in increasing map order.
         *)

    val mapPartial  : ('a -> 'b option) -> 'a map -> 'b map
    val mapPartiali : (Key.ord_key * 'a -> 'b option) -> 'a map -> 'b map
        (* map a partial function over the elements of a map in increasing
         * map order.
         *)

  end (* ORD_MAP *)
(* stop of smlnj-lib/Util/ord-map-sig.sml *)
(* start of smlnj-lib/Util/binary-map-fn.sml *)
(* binary-map-fn.sml
 *
 * COPYRIGHT (c) 1993 by AT&T Bell Laboratories.  See COPYRIGHT file for details.
 *
 * This code was adapted from Stephen Adams' binary tree implementation
 * of applicative integer sets.
 *
 *   Copyright 1992 Stephen Adams.
 *
 *    This software may be used freely provided that:
 *      1. This copyright notice is attached to any copy, derived work,
 *         or work including all or part of this software.
 *      2. Any derived work must contain a prominent notice stating that
 *         it has been altered from the original.
 *
 *
 *   Name(s): Stephen Adams.
 *   Department, Institution: Electronics & Computer Science,
 *      University of Southampton
 *   Address:  Electronics & Computer Science
 *             University of Southampton
 *           Southampton  SO9 5NH
 *           Great Britian
 *   E-mail:   sra@ecs.soton.ac.uk
 *
 *   Comments:
 *
 *     1.  The implementation is based on Binary search trees of Bounded
 *         Balance, similar to Nievergelt & Reingold, SIAM J. Computing
 *         2(1), March 1973.  The main advantage of these trees is that
 *         they keep the size of the tree in the node, giving a constant
 *         time size operation.
 *
 *     2.  The bounded balance criterion is simpler than N&R's alpha.
 *         Simply, one subtree must not have more than `weight' times as
 *         many elements as the opposite subtree.  Rebalancing is
 *         guaranteed to reinstate the criterion for weight>2.23, but
 *         the occasional incorrect behaviour for weight=2 is not
 *         detrimental to performance.
 *
 *)

functor BinaryMapFn (K : ORD_KEY) : ORD_MAP =
  struct

    structure Key = K

    (*
    **  val weight = 3
    **  fun wt i = weight * i
    *)
    fun wt (i : int) = i + i + i

    datatype 'a map
      = E 
      | T of {
          key : K.ord_key, 
          value : 'a, 
          cnt : int, 
          left : 'a map, 
          right : 'a map
        }

    val empty = E

    fun isEmpty E = true
      | isEmpty _ = false

    fun numItems E = 0
      | numItems (T{cnt,...}) = cnt

  (* return the first item in the map (or NONE if it is empty) *)
    fun first E = NONE
      | first (T{value, left=E, ...}) = SOME value
      | first (T{left, ...}) = first left

  (* return the first item in the map and its key (or NONE if it is empty) *)
    fun firsti E = NONE
      | firsti (T{key, value, left=E, ...}) = SOME(key, value)
      | firsti (T{left, ...}) = firsti left

local
    fun N(k,v,E,E) = T{key=k,value=v,cnt=1,left=E,right=E}
      | N(k,v,E,r as T n) = T{key=k,value=v,cnt=1+(#cnt n),left=E,right=r}
      | N(k,v,l as T n,E) = T{key=k,value=v,cnt=1+(#cnt n),left=l,right=E}
      | N(k,v,l as T n,r as T n') = 
          T{key=k,value=v,cnt=1+(#cnt n)+(#cnt n'),left=l,right=r}

    fun single_L (a,av,x,T{key=b,value=bv,left=y,right=z,...}) = 
          N(b,bv,N(a,av,x,y),z)
      | single_L _ = raise Match
    fun single_R (b,bv,T{key=a,value=av,left=x,right=y,...},z) = 
          N(a,av,x,N(b,bv,y,z))
      | single_R _ = raise Match
    fun double_L (a,av,w,T{key=c,value=cv,left=T{key=b,value=bv,left=x,right=y,...},right=z,...}) =
          N(b,bv,N(a,av,w,x),N(c,cv,y,z))
      | double_L _ = raise Match
    fun double_R (c,cv,T{key=a,value=av,left=w,right=T{key=b,value=bv,left=x,right=y,...},...},z) = 
          N(b,bv,N(a,av,w,x),N(c,cv,y,z))
      | double_R _ = raise Match

    fun T' (k,v,E,E) = T{key=k,value=v,cnt=1,left=E,right=E}
      | T' (k,v,E,r as T{right=E,left=E,...}) =
          T{key=k,value=v,cnt=2,left=E,right=r}
      | T' (k,v,l as T{right=E,left=E,...},E) =
          T{key=k,value=v,cnt=2,left=l,right=E}

      | T' (p as (_,_,E,T{left=T _,right=E,...})) = double_L p
      | T' (p as (_,_,T{left=E,right=T _,...},E)) = double_R p

        (* these cases almost never happen with small weight*)
      | T' (p as (_,_,E,T{left=T{cnt=ln,...},right=T{cnt=rn,...},...})) =
          if ln < rn then single_L p else double_L p
      | T' (p as (_,_,T{left=T{cnt=ln,...},right=T{cnt=rn,...},...},E)) =
          if ln > rn then single_R p else double_R p

      | T' (p as (_,_,E,T{left=E,...})) = single_L p
      | T' (p as (_,_,T{right=E,...},E)) = single_R p

      | T' (p as (k,v,l as T{cnt=ln,left=ll,right=lr,...},
                      r as T{cnt=rn,left=rl,right=rr,...})) =
          if rn >= wt ln then (*right is too big*)
            let val rln = numItems rl
                val rrn = numItems rr
            in
              if rln < rrn then  single_L p  else  double_L p
            end
        
          else if ln >= wt rn then  (*left is too big*)
            let val lln = numItems ll
                val lrn = numItems lr
            in
              if lrn < lln then  single_R p  else  double_R p
            end
    
          else T{key=k,value=v,cnt=ln+rn+1,left=l,right=r}

    local
      fun min (T{left=E,key,value,...}) = (key,value)
        | min (T{left,...}) = min left
        | min _ = raise Match
  
      fun delmin (T{left=E,right,...}) = right
        | delmin (T{key,value,left,right,...}) = T'(key,value,delmin left,right)
        | delmin _ = raise Match
    in
      fun delete' (E,r) = r
        | delete' (l,E) = l
        | delete' (l,r) = let val (mink,minv) = min r in
            T'(mink,minv,l,delmin r)
          end
    end
in
    fun mkDict () = E
    
    fun singleton (x,v) = T{key=x,value=v,cnt=1,left=E,right=E}

    fun insert (E,x,v) = T{key=x,value=v,cnt=1,left=E,right=E}
      | insert (T(set as {key,left,right,value,...}),x,v) =
          case K.compare (key,x) of
            GREATER => T'(key,value,insert(left,x,v),right)
          | LESS => T'(key,value,left,insert(right,x,v))
          | _ => T{key=x,value=v,left=left,right=right,cnt= #cnt set}
    fun insert' ((k, x), m) = insert(m, k, x)

    fun inDomain (set, x) = let 
          fun mem E = false
            | mem (T(n as {key,left,right,...})) = (case K.compare (x,key)
                 of GREATER => mem right
                  | EQUAL => true
                  | LESS => mem left
                (* end case *))
          in
            mem set
          end

    fun find (set, x) = let 
          fun mem E = NONE
            | mem (T(n as {key,left,right,...})) = (case K.compare (x,key)
                 of GREATER => mem right
                  | EQUAL => SOME(#value n)
                  | LESS => mem left
                (* end case *))
          in
            mem set
          end

    fun remove (E,x) = raise LibBase.NotFound
      | remove (set as T{key,left,right,value,...},x) = (
          case K.compare (key,x)
           of GREATER => let
                val (left', v) = remove(left, x)
                in
                  (T'(key, value, left', right), v)
                end
            | LESS => let
                val (right', v) = remove (right, x)
                in
                  (T'(key, value, left, right'), v)
                end
            | _ => (delete'(left,right),value)
          (* end case *))

    fun listItems d = let
          fun d2l (E, l) = l
            | d2l (T{key,value,left,right,...}, l) =
                d2l(left, value::(d2l(right,l)))
          in
            d2l (d,[])
          end

    fun listItemsi d = let
          fun d2l (E, l) = l
            | d2l (T{key,value,left,right,...}, l) =
                d2l(left, (key,value)::(d2l(right,l)))
          in
            d2l (d,[])
          end

    fun listKeys d = let
          fun d2l (E, l) = l
            | d2l (T{key,left,right,...}, l) = d2l(left, key::(d2l(right,l)))
          in
            d2l (d,[])
          end

    local
      fun next ((t as T{right, ...})::rest) = (t, left(right, rest))
        | next _ = (E, [])
      and left (E, rest) = rest
        | left (t as T{left=l, ...}, rest) = left(l, t::rest)
    in
    fun collate cmpRng (s1, s2) = let
          fun cmp (t1, t2) = (case (next t1, next t2)
                 of ((E, _), (E, _)) => EQUAL
                  | ((E, _), _) => LESS
                  | (_, (E, _)) => GREATER
                  | ((T{key=x1, value=y1, ...}, r1), (T{key=x2, value=y2, ...}, r2)) => (
                      case Key.compare(x1, x2)
                       of EQUAL => (case cmpRng(y1, y2)
                             of EQUAL => cmp (r1, r2)
                              | order => order
                            (* end case *))
                        | order => order
                      (* end case *))
                (* end case *))
          in
            cmp (left(s1, []), left(s2, []))
          end
    end (* local *)

    fun appi f d = let
          fun app' E = ()
            | app' (T{key,value,left,right,...}) = (
                app' left; f(key, value); app' right)
          in
            app' d
          end
    fun app f d = let
          fun app' E = ()
            | app' (T{value,left,right,...}) = (
                app' left; f value; app' right)
          in
            app' d
          end

    fun mapi f d = let
          fun map' E = E
            | map' (T{key,value,left,right,cnt}) = let
                val left' = map' left
                val value' = f(key, value)
                val right' = map' right
                in
                  T{cnt=cnt, key=key, value=value', left = left', right = right'}
                end
          in
            map' d
          end
    fun map f d = mapi (fn (_, x) => f x) d

    fun foldli f init d = let
          fun fold (E, v) = v
            | fold (T{key,value,left,right,...}, v) =
                fold (right, f(key, value, fold(left, v)))
          in
            fold (d, init)
          end
    fun foldl f init d = foldli (fn (_, v, accum) => f (v, accum)) init d

    fun foldri f init d = let
          fun fold (E,v) = v
            | fold (T{key,value,left,right,...},v) =
                fold (left, f(key, value, fold(right, v)))
          in
            fold (d, init)
          end
    fun foldr f init d = foldri (fn (_, v, accum) => f (v, accum)) init d

(** To be implemented **
    val filter  : ('a -> bool) -> 'a map -> 'a map
    val filteri : (Key.ord_key * 'a -> bool) -> 'a map -> 'a map
**)

    end (* local *)

(* the following are generic implementations of the unionWith and intersectWith
 * operetions.  These should be specialized for the internal representations
 * at some point.
 *)
    fun unionWith f (m1, m2) = let
          fun ins  f (key, x, m) = (case find(m, key)
                 of NONE => insert(m, key, x)
                  | (SOME x') => insert(m, key, f(x, x'))
                (* end case *))
          in
            if (numItems m1 > numItems m2)
              then foldli (ins (fn (a, b) => f (b, a))) m1 m2
              else foldli (ins f) m2 m1
          end
    fun unionWithi f (m1, m2) = let
          fun ins f (key, x, m) = (case find(m, key)
                 of NONE => insert(m, key, x)
                  | (SOME x') => insert(m, key, f(key, x, x'))
                (* end case *))
          in
            if (numItems m1 > numItems m2)
              then foldli (ins (fn (k, a, b) => f (k, b, a))) m1 m2
              else foldli (ins f) m2 m1
          end

    fun intersectWith f (m1, m2) = let
        (* iterate over the elements of m1, checking for membership in m2 *)
          fun intersect f (m1, m2) = let
                fun ins (key, x, m) = (case find(m2, key)
                       of NONE => m
                        | (SOME x') => insert(m, key, f(x, x'))
                      (* end case *))
                in
                  foldli ins empty m1
                end
          in
            if (numItems m1 > numItems m2)
              then intersect f (m1, m2)
              else intersect (fn (a, b) => f(b, a)) (m2, m1)
          end
    fun intersectWithi f (m1, m2) = let
        (* iterate over the elements of m1, checking for membership in m2 *)
          fun intersect f (m1, m2) = let
                fun ins (key, x, m) = (case find(m2, key)
                       of NONE => m
                        | (SOME x') => insert(m, key, f(key, x, x'))
                      (* end case *))
                in
                  foldli ins empty m1
                end
          in
            if (numItems m1 > numItems m2)
              then intersect f (m1, m2)
              else intersect (fn (k, a, b) => f(k, b, a)) (m2, m1)
          end

  (* this is a generic implementation of filter.  It should
   * be specialized to the data-structure at some point.
   *)
    fun filter predFn m = let
          fun f (key, item, m) = if predFn item
                then insert(m, key, item)
                else m
          in
            foldli f empty m
          end
    fun filteri predFn m = let
          fun f (key, item, m) = if predFn(key, item)
                then insert(m, key, item)
                else m
          in
            foldli f empty m
          end

  (* this is a generic implementation of mapPartial.  It should
   * be specialized to the data-structure at some point.
   *)
    fun mapPartial f m = let
          fun g (key, item, m) = (case f item
                 of NONE => m
                  | (SOME item') => insert(m, key, item')
                (* end case *))
          in
            foldli g empty m
          end
    fun mapPartiali f m = let
          fun g (key, item, m) = (case f(key, item)
                 of NONE => m
                  | (SOME item') => insert(m, key, item')
                (* end case *))
          in
            foldli g empty m
          end

  end (* functor BinaryMapFn *)
(* stop of smlnj-lib/Util/binary-map-fn.sml *)
(* start of FIN_MAP.sml *)
(*
 * Standard ML finite maps
 *
 * Definition, section 4.2
 *
 * Note:
 *     This signature just extends the one available in the SML/NJ lib.
 *     Actually, the operation added here would be general purpose and useful enough
 *     (and more efficient) to be in the lib. Also see FIN_SET.
 *)

signature FIN_MAP =
  sig

    include ORD_MAP

    val fromList:       (Key.ord_key * 'a) list -> 'a map

    val all:            ('a -> bool) -> 'a map -> bool
    val exists:         ('a -> bool) -> 'a map -> bool
    val alli:           (Key.ord_key * 'a -> bool) -> 'a map -> bool
    val existsi:        (Key.ord_key * 'a -> bool) -> 'a map -> bool

    val disjoint:       'a map * 'a map -> bool

  end
(* stop of FIN_MAP.sml *)
(* start of FinMapFn.sml *)
(*
 * Standard ML finite maps
 *
 * Definition, section 4.2
 *
 * Note:
 *     This functor just extends the one available in the SML/NJ lib.
 *     Actually, the operation added here would be general purpose and useful enough
 *     (and more efficient) to be in the lib. Also see FinSetFn.
 *)

functor FinMapFn(Key: ORD_KEY) :> FIN_MAP where type Key.ord_key = Key.ord_key =
  struct

    structure BinaryMap = BinaryMapFn(Key)

    open BinaryMap

    fun fromList kvs    = List.foldl (fn((k, v),m) => insert(m, k, v)) empty kvs

    fun all p           = foldl (fn(v, b) => b andalso p v) true
    fun exists p        = foldl (fn(v, b) => b orelse p v) false
    fun alli p          = foldli (fn(k, v, b) => b andalso p(k, v)) true
    fun existsi p       = foldli (fn(k, v, b) => b orelse p(k, v)) false

    fun disjoint(m1,m2) = isEmpty(intersectWith #2 (m1, m2))

  end
(* stop of FinMapFn.sml *)
(* start of ID.sml *)
(*
 * Standard ML identifiers
 *
 * Definition, section 2.4
 *
 * Note:
 *   This is a generic signature to represent all kinds of identifiers (except
 *   for labels and tyvars).
 *)


signature ID =
  sig

    (* Type [Section 2.4] *)

    eqtype Id                                   (* [id] *)

    (* Operations *)

    val invent:         unit -> Id

    val fromString:     string -> Id
    val toString:       Id -> string

    val compare:        Id * Id -> order

  end
(* stop of ID.sml *)
(* start of IdFn.sml *)
(*
 * Standard ML identifiers
 *
 * Definition, section 2.4
 *
 * Note:
 *   This is a generic functor to represent all kinds of identifiers (except
 *   for labels tyvars).
 *)


functor IdFn() :> ID =
  struct

    (* Type [Section 2.4] *)

    type Id = string                            (* [id] *)


    (* Creation *)

    fun invent()     = "_id" ^ Stamp.toString(Stamp.stamp())

    fun fromString s = s
    fun toString s   = s


    (* Ordering *)

    val compare = String.compare

  end
(* stop of IdFn.sml *)
(* start of IdsModule.sml *)
(*
 * Standard ML identifiers for modules
 *
 * Definition, section 3.2
 *)


structure SigId = IdFn()
structure FunId = IdFn()
(* stop of IdsModule.sml *)
(* start of AssembliesModule.sml *)
(*
 * Standard ML sets and maps for the module semantics
 *
 * Definition, sections 5.1 and 7.2
 *)

structure SigIdMap   = FinMapFn(type ord_key = SigId.Id
                                val  compare = SigId.compare)

structure FunIdMap   = FinMapFn(type ord_key = FunId.Id
                                val  compare = FunId.compare)
(* stop of AssembliesModule.sml *)
(* start of LONGID.sml *)
(*
 * Standard ML long identifiers
 *
 * Definition, section 2.4
 *
 * Note:
 *   This is a generic signature to represent all kinds of long identifiers.
 *)


signature LONGID =
  sig

    (* Import *)

    structure Id:    ID
    structure StrId: ID

    type Id    = Id.Id
    type StrId = StrId.Id


    (* Type [Section 2.4] *)

    eqtype longId                               (* [longid] *)


    (* Operations *)

    val invent:         unit   -> longId
    val fromId:         Id     -> longId
    val toId:           longId -> Id
    val toString:       longId -> string

    val strengthen:     StrId * longId -> longId
    val implode:        StrId list * Id -> longId
    val explode:        longId -> StrId list * Id

    val isUnqualified:  longId -> bool

    val compare:        longId * longId -> order

  end
(* stop of LONGID.sml *)
(* start of LongIdFn.sml *)
(*
 * Standard ML long identifiers
 *
 * Definition, section 2.4
 *
 * Note:
 *   This is a generic functor that generates a long identifier type from a
 *   given identifier type and the StrId type.
 *)


functor LongIdFn(structure Id:    ID
                 structure StrId: ID
                ) :> LONGID where type Id.Id    = Id.Id
                            and   type StrId.Id = StrId.Id
                  =
  struct

    (* Import *)

    structure Id    = Id
    structure StrId = StrId

    type Id         = Id.Id
    type StrId      = StrId.Id


    (* Type [Section 2.4] *)

    type longId = StrId list * Id                       (* [longid] *)


    (* Conversions *)

    fun toId(strid, id) = id
    fun fromId id       = ([],id)
    fun invent()        = ([],Id.invent())

    fun toString(strids, id) =
        let
            fun prefix   []     = Id.toString id
              | prefix(id::ids) = StrId.toString id ^ "." ^ prefix ids
        in
            prefix strids
        end

    fun strengthen(strid, (strids, id)) = (strid::strids, id)

    fun implode longid = longid
    fun explode longid = longid

    fun isUnqualified (strids,id) = List.null strids


    (* Ordering *)

    fun compare(longid1, longid2) =
            String.compare(toString longid1, toString longid2)

  end
(* stop of LongIdFn.sml *)
(* start of IdsCore.sml *)
(*
 * Standard ML identifiers for the core
 *
 * Definition, section 2.4
 *)


structure VId       = IdFn()
structure TyCon     = IdFn()
structure StrId     = IdFn()

structure LongVId   = LongIdFn(structure Id    = VId
                               structure StrId = StrId)
structure LongTyCon = LongIdFn(structure Id    = TyCon
                               structure StrId = StrId)
structure LongStrId = LongIdFn(structure Id    = StrId
                               structure StrId = StrId)
(* stop of IdsCore.sml *)
(* start of smlnj-lib/Util/ord-set-sig.sml *)
(* ordset-sig.sml
 *
 * COPYRIGHT (c) 1993 by AT&T Bell Laboratories.  See COPYRIGHT file for details.
 *
 * Signature for a set of values with an order relation.
 *)

signature ORD_SET =
  sig

    structure Key : ORD_KEY

    type item = Key.ord_key
    type set

    val empty : set
        (* The empty set *)

    val singleton : item -> set
        (* Create a singleton set *)

    val add  : set * item -> set
    val add' : (item * set) -> set
        (* Insert an item. *)

    val addList : set * item list -> set
        (* Insert items from list. *)

    val delete : set * item -> set
        (* Remove an item. Raise NotFound if not found. *)

    val member : set * item -> bool
        (* Return true if and only if item is an element in the set *)

    val isEmpty : set -> bool
        (* Return true if and only if the set is empty *)

    val equal : (set * set) -> bool
        (* Return true if and only if the two sets are equal *)

    val compare : (set * set) -> order
        (* does a lexical comparison of two sets *)

    val isSubset : (set * set) -> bool
        (* Return true if and only if the first set is a subset of the second *)

    val numItems : set ->  int
        (* Return the number of items in the table *)

    val listItems : set -> item list
        (* Return an ordered list of the items in the set *)

    val union : set * set -> set
        (* Union *)

    val intersection : set * set -> set
        (* Intersection *)

    val difference : set * set -> set
        (* Difference *)

    val map : (item -> item) -> set -> set
        (* Create a new set by applying a map function to the elements
         * of the set.
         *)
     
    val app : (item -> unit) -> set -> unit
        (* Apply a function to the entries of the set 
         * in decreasing order
         *)

    val foldl : (item * 'b -> 'b) -> 'b -> set -> 'b
        (* Apply a folding function to the entries of the set 
         * in increasing order
         *)

    val foldr : (item * 'b -> 'b) -> 'b -> set -> 'b
        (* Apply a folding function to the entries of the set 
         * in decreasing order
         *)

    val filter : (item -> bool) -> set -> set

    val exists : (item -> bool) -> set -> bool

    val find : (item -> bool) -> set -> item option

  end (* ORD_SET *)
(* stop of smlnj-lib/Util/ord-set-sig.sml *)
(* start of smlnj-lib/Util/binary-set-fn.sml *)
(* binary-set-fn.sml
 *
 * COPYRIGHT (c) 1993 by AT&T Bell Laboratories.  See COPYRIGHT file for details.
 *
 * This code was adapted from Stephen Adams' binary tree implementation
 * of applicative integer sets.
 *
 *    Copyright 1992 Stephen Adams.
 *
 *    This software may be used freely provided that:
 *      1. This copyright notice is attached to any copy, derived work,
 *         or work including all or part of this software.
 *      2. Any derived work must contain a prominent notice stating that
 *         it has been altered from the original.
 *
 *   Name(s): Stephen Adams.
 *   Department, Institution: Electronics & Computer Science,
 *      University of Southampton
 *   Address:  Electronics & Computer Science
 *             University of Southampton
 *         Southampton  SO9 5NH
 *         Great Britian
 *   E-mail:   sra@ecs.soton.ac.uk
 *
 *   Comments:
 *
 *     1.  The implementation is based on Binary search trees of Bounded
 *         Balance, similar to Nievergelt & Reingold, SIAM J. Computing
 *         2(1), March 1973.  The main advantage of these trees is that
 *         they keep the size of the tree in the node, giving a constant
 *         time size operation.
 *
 *     2.  The bounded balance criterion is simpler than N&R's alpha.
 *         Simply, one subtree must not have more than `weight' times as
 *         many elements as the opposite subtree.  Rebalancing is
 *         guaranteed to reinstate the criterion for weight>2.23, but
 *         the occasional incorrect behaviour for weight=2 is not
 *         detrimental to performance.
 *
 *     3.  There are two implementations of union.  The default,
 *         hedge_union, is much more complex and usually 20% faster.  I
 *         am not sure that the performance increase warrants the
 *         complexity (and time it took to write), but I am leaving it
 *         in for the competition.  It is derived from the original
 *         union by replacing the split_lt(gt) operations with a lazy
 *         version. The `obvious' version is called old_union.
 *
 *     4.  Most time is spent in T', the rebalancing constructor.  If my
 *         understanding of the output of *<file> in the sml batch
 *         compiler is correct then the code produced by NJSML 0.75
 *         (sparc) for the final case is very disappointing.  Most
 *         invocations fall through to this case and most of these cases
 *         fall to the else part, i.e. the plain contructor,
 *         T(v,ln+rn+1,l,r).  The poor code allocates a 16 word vector
 *         and saves lots of registers into it.  In the common case it
 *         then retrieves a few of the registers and allocates the 5
 *         word T node.  The values that it retrieves were live in
 *         registers before the massive save.
 *
 *   Modified to functor to support general ordered values
 *)

functor BinarySetFn (K : ORD_KEY) : ORD_SET =
  struct

    structure Key = K

    type item = K.ord_key

    datatype set
      = E 
      | T of {
          elt : item, 
          cnt : int, 
          left : set,
          right : set
        }

    fun numItems E = 0
      | numItems (T{cnt,...}) = cnt
        
    fun isEmpty E = true
      | isEmpty _ = false

    fun mkT(v,n,l,r) = T{elt=v,cnt=n,left=l,right=r}

      (* N(v,l,r) = T(v,1+numItems(l)+numItems(r),l,r) *)
    fun N(v,E,E) = mkT(v,1,E,E)
      | N(v,E,r as T{cnt=n,...}) = mkT(v,n+1,E,r)
      | N(v,l as T{cnt=n,...}, E) = mkT(v,n+1,l,E)
      | N(v,l as T{cnt=n,...}, r as T{cnt=m,...}) = mkT(v,n+m+1,l,r)

    fun single_L (a,x,T{elt=b,left=y,right=z,...}) = N(b,N(a,x,y),z)
      | single_L _ = raise Match
    fun single_R (b,T{elt=a,left=x,right=y,...},z) = N(a,x,N(b,y,z))
      | single_R _ = raise Match
    fun double_L (a,w,T{elt=c,left=T{elt=b,left=x,right=y,...},right=z,...}) =
          N(b,N(a,w,x),N(c,y,z))
      | double_L _ = raise Match
    fun double_R (c,T{elt=a,left=w,right=T{elt=b,left=x,right=y,...},...},z) =
          N(b,N(a,w,x),N(c,y,z))
      | double_R _ = raise Match

    (*
    **  val weight = 3
    **  fun wt i = weight * i
    *)
    fun wt (i : int) = i + i + i

    fun T' (v,E,E) = mkT(v,1,E,E)
      | T' (v,E,r as T{left=E,right=E,...}) = mkT(v,2,E,r)
      | T' (v,l as T{left=E,right=E,...},E) = mkT(v,2,l,E)

      | T' (p as (_,E,T{left=T _,right=E,...})) = double_L p
      | T' (p as (_,T{left=E,right=T _,...},E)) = double_R p

        (* these cases almost never happen with small weight*)
      | T' (p as (_,E,T{left=T{cnt=ln,...},right=T{cnt=rn,...},...})) =
            if ln<rn then single_L p else double_L p
      | T' (p as (_,T{left=T{cnt=ln,...},right=T{cnt=rn,...},...},E)) =
            if ln>rn then single_R p else double_R p

      | T' (p as (_,E,T{left=E,...})) = single_L p
      | T' (p as (_,T{right=E,...},E)) = single_R p

      | T' (p as (v,l as T{elt=lv,cnt=ln,left=ll,right=lr},
              r as T{elt=rv,cnt=rn,left=rl,right=rr})) =
          if rn >= wt ln (*right is too big*)
            then
              let val rln = numItems rl
                  val rrn = numItems rr
              in
                if rln < rrn then single_L p else double_L p
              end
          else if ln >= wt rn (*left is too big*)
            then
              let val lln = numItems ll
                  val lrn = numItems lr
              in
                if lrn < lln then single_R p else double_R p
              end
          else mkT(v,ln+rn+1,l,r)

    fun add (E,x) = mkT(x,1,E,E)
      | add (set as T{elt=v,left=l,right=r,cnt},x) =
          case K.compare(x,v) of
            LESS => T'(v,add(l,x),r)
          | GREATER => T'(v,l,add(r,x))
          | EQUAL => mkT(x,cnt,l,r)
    fun add' (s, x) = add(x, s)

    fun concat3 (E,v,r) = add(r,v)
      | concat3 (l,v,E) = add(l,v)
      | concat3 (l as T{elt=v1,cnt=n1,left=l1,right=r1}, v, 
                  r as T{elt=v2,cnt=n2,left=l2,right=r2}) =
        if wt n1 < n2 then T'(v2,concat3(l,v,l2),r2)
        else if wt n2 < n1 then T'(v1,l1,concat3(r1,v,r))
        else N(v,l,r)

    fun split_lt (E,x) = E
      | split_lt (T{elt=v,left=l,right=r,...},x) =
          case K.compare(v,x) of
            GREATER => split_lt(l,x)
          | LESS => concat3(l,v,split_lt(r,x))
          | _ => l

    fun split_gt (E,x) = E
      | split_gt (T{elt=v,left=l,right=r,...},x) =
          case K.compare(v,x) of
            LESS => split_gt(r,x)
          | GREATER => concat3(split_gt(l,x),v,r)
          | _ => r

    fun min (T{elt=v,left=E,...}) = v
      | min (T{left=l,...}) = min l
      | min _ = raise Match
        
    fun delmin (T{left=E,right=r,...}) = r
      | delmin (T{elt=v,left=l,right=r,...}) = T'(v,delmin l,r)
      | delmin _ = raise Match

    fun delete' (E,r) = r
      | delete' (l,E) = l
      | delete' (l,r) = T'(min r,l,delmin r)

    fun concat (E, s) = s
      | concat (s, E) = s
      | concat (t1 as T{elt=v1,cnt=n1,left=l1,right=r1}, 
                  t2 as T{elt=v2,cnt=n2,left=l2,right=r2}) =
          if wt n1 < n2 then T'(v2,concat(t1,l2),r2)
          else if wt n2 < n1 then T'(v1,l1,concat(r1,t2))
          else T'(min t2,t1, delmin t2)


    local
      fun trim (lo,hi,E) = E
        | trim (lo,hi,s as T{elt=v,left=l,right=r,...}) =
            if K.compare(v,lo) = GREATER
              then if K.compare(v,hi) = LESS then s else trim(lo,hi,l)
              else trim(lo,hi,r)
                
      fun uni_bd (s,E,_,_) = s
        | uni_bd (E,T{elt=v,left=l,right=r,...},lo,hi) = 
             concat3(split_gt(l,lo),v,split_lt(r,hi))
        | uni_bd (T{elt=v,left=l1,right=r1,...}, 
                   s2 as T{elt=v2,left=l2,right=r2,...},lo,hi) =
            concat3(uni_bd(l1,trim(lo,v,s2),lo,v),
                v, 
                uni_bd(r1,trim(v,hi,s2),v,hi))
              (* inv:  lo < v < hi *)

        (* all the other versions of uni and trim are
         * specializations of the above two functions with
         *     lo=-infinity and/or hi=+infinity 
         *)

      fun trim_lo (_, E) = E
        | trim_lo (lo,s as T{elt=v,right=r,...}) =
            case K.compare(v,lo) of
              GREATER => s
            | _ => trim_lo(lo,r)

      fun trim_hi (_, E) = E
        | trim_hi (hi,s as T{elt=v,left=l,...}) =
            case K.compare(v,hi) of
              LESS => s
            | _ => trim_hi(hi,l)
                
      fun uni_hi (s,E,_) = s
        | uni_hi (E,T{elt=v,left=l,right=r,...},hi) = 
             concat3(l,v,split_lt(r,hi))
        | uni_hi (T{elt=v,left=l1,right=r1,...}, 
                   s2 as T{elt=v2,left=l2,right=r2,...},hi) =
            concat3(uni_hi(l1,trim_hi(v,s2),v),v,uni_bd(r1,trim(v,hi,s2),v,hi))

      fun uni_lo (s,E,_) = s
        | uni_lo (E,T{elt=v,left=l,right=r,...},lo) = 
             concat3(split_gt(l,lo),v,r)
        | uni_lo (T{elt=v,left=l1,right=r1,...}, 
                   s2 as T{elt=v2,left=l2,right=r2,...},lo) =
            concat3(uni_bd(l1,trim(lo,v,s2),lo,v),v,uni_lo(r1,trim_lo(v,s2),v))

      fun uni (s,E) = s
        | uni (E,s) = s
        | uni (T{elt=v,left=l1,right=r1,...}, 
                s2 as T{elt=v2,left=l2,right=r2,...}) =
            concat3(uni_hi(l1,trim_hi(v,s2),v), v, uni_lo(r1,trim_lo(v,s2),v))

    in
      val hedge_union = uni
    end

      (* The old_union version is about 20% slower than
       *  hedge_union in most cases 
       *)
    fun old_union (E,s2)  = s2
      | old_union (s1,E)  = s1
      | old_union (T{elt=v,left=l,right=r,...},s2) = 
          let val l2 = split_lt(s2,v)
              val r2 = split_gt(s2,v)
          in
            concat3(old_union(l,l2),v,old_union(r,r2))
          end

    val empty = E
    fun singleton x = T{elt=x,cnt=1,left=E,right=E}

    fun addList (s,l) = List.foldl (fn (i,s) => add(s,i)) s l

    val add = add

    fun member (set, x) = let
          fun pk E = false
            | pk (T{elt=v, left=l, right=r, ...}) = (
                case K.compare(x,v)
                 of LESS => pk l
                  | EQUAL => true
                  | GREATER => pk r
                (* end case *))
          in
            pk set
          end

    local
        (* true if every item in t is in t' *)
      fun treeIn (t,t') = let
            fun isIn E = true
              | isIn (T{elt,left=E,right=E,...}) = member(t',elt)
              | isIn (T{elt,left,right=E,...}) = 
                  member(t',elt) andalso isIn left
              | isIn (T{elt,left=E,right,...}) = 
                  member(t',elt) andalso isIn right
              | isIn (T{elt,left,right,...}) = 
                  member(t',elt) andalso isIn left andalso isIn right
            in
              isIn t
            end
    in
    fun isSubset (E,_) = true
      | isSubset (_,E) = false
      | isSubset (t as T{cnt=n,...},t' as T{cnt=n',...}) =
          (n<=n') andalso treeIn (t,t')

    fun equal (E,E) = true
      | equal (t as T{cnt=n,...},t' as T{cnt=n',...}) =
          (n=n') andalso treeIn (t,t')
      | equal _ = false
    end

    local
      fun next ((t as T{right, ...})::rest) = (t, left(right, rest))
        | next _ = (E, [])
      and left (E, rest) = rest
        | left (t as T{left=l, ...}, rest) = left(l, t::rest)
    in
    fun compare (s1, s2) = let
          fun cmp (t1, t2) = (case (next t1, next t2)
                 of ((E, _), (E, _)) => EQUAL
                  | ((E, _), _) => LESS
                  | (_, (E, _)) => GREATER
                  | ((T{elt=e1, ...}, r1), (T{elt=e2, ...}, r2)) => (
                      case Key.compare(e1, e2)
                       of EQUAL => cmp (r1, r2)
                        | order => order
                      (* end case *))
                (* end case *))
          in
            cmp (left(s1, []), left(s2, []))
          end
    end

    fun delete (E,x) = raise LibBase.NotFound
      | delete (set as T{elt=v,left=l,right=r,...},x) =
          case K.compare(x,v) of
            LESS => T'(v,delete(l,x),r)
          | GREATER => T'(v,l,delete(r,x))
          | _ => delete'(l,r)

    val union = hedge_union

    fun intersection (E, _) = E
      | intersection (_, E) = E
      | intersection (s, T{elt=v,left=l,right=r,...}) = let
          val l2 = split_lt(s,v)
          val r2 = split_gt(s,v)
          in
            if member(s,v)
              then concat3(intersection(l2,l),v,intersection(r2,r))
              else concat(intersection(l2,l),intersection(r2,r))
          end

    fun difference (E,s) = E
      | difference (s,E)  = s
      | difference (s, T{elt=v,left=l,right=r,...}) =
          let val l2 = split_lt(s,v)
              val r2 = split_gt(s,v)
          in
            concat(difference(l2,l),difference(r2,r))
          end

    fun map f set = let
          fun map'(acc, E) = acc
            | map'(acc, T{elt,left,right,...}) =
                map' (add (map' (acc, left), f elt), right)
          in 
            map' (E, set)
          end

    fun app apf =
         let fun apply E = ()
               | apply (T{elt,left,right,...}) = 
                   (apply left;apf elt; apply right)
         in
           apply
         end

    fun foldl f b set = let
          fun foldf (E, b) = b
            | foldf (T{elt,left,right,...}, b) = 
                foldf (right, f(elt, foldf (left, b)))
          in
            foldf (set, b)
          end

    fun foldr f b set = let
          fun foldf (E, b) = b
            | foldf (T{elt,left,right,...}, b) = 
                foldf (left, f(elt, foldf (right, b)))
          in
            foldf (set, b)
          end

    fun listItems set = foldr (op::) [] set

    fun filter pred set =
          foldl (fn (item, s) => if (pred item) then add(s, item) else s)
            empty set

    fun find p E = NONE
      | find p (T{elt,left,right,...}) = (case find p left
           of NONE => if (p elt)
                then SOME elt
                else find p right
            | a => a
          (* end case *))

    fun exists p E = false
      | exists p (T{elt, left, right,...}) =
          (exists p left) orelse (p elt) orelse (exists p right)

  end (* BinarySetFn *)
(* stop of smlnj-lib/Util/binary-set-fn.sml *)
(* start of FIN_SET.sml *)
(*
 * Standard ML finite sets
 *
 * Definition, section 4.2
 *
 * Note:
 *     This signature just extends the one available in the SML/NJ lib.
 *     Actually, the operation added here would be general purpose and useful enough
 *     to be in the lib. Also see FIN_MAP.
 *)

signature FIN_SET =
  sig

    include ORD_SET

    val fromList:  item list -> set

  end
(* stop of FIN_SET.sml *)
(* start of FinSetFn.sml *)
(*
 * Standard ML finite sets
 *
 * Definition, section 4.2
 *
 * Note:
 *     This functor just extends the one available in the SML/NJ lib.
 *     Actually, the operation added here would be general purpose and useful enough
 *     to be in the lib. Also see FinMapFn.
 *)

functor FinSetFn(Key: ORD_KEY) :> FIN_SET where type Key.ord_key = Key.ord_key =
  struct

    structure BinarySet = BinarySetFn(Key)

    open BinarySet

    fun fromList xs = addList(empty, xs)

  end
(* stop of FinSetFn.sml *)
(* start of TYVAR.sml *)
(*
 * Standard ML type variables
 *
 * Definition, sections 2.4 and 4.1
 *)


signature TYVAR =
  sig

    (* Type [Sections 2.4 and 4.1]*)

    eqtype TyVar                        (* [alpha] or [tyvar] *)


    (* Operations *)

    val invent:         bool -> TyVar
    val fromIndex:      bool -> int -> TyVar
    val fromString:     string -> TyVar
    val toString:       TyVar -> string

    val admitsEquality: TyVar -> bool
    val isExplicit:     TyVar -> bool

    val instance:       TyVar -> TyVar
    val normalise:      TyVar * int -> TyVar

    val compare:        TyVar * TyVar -> order

  end
(* stop of TYVAR.sml *)
(* start of TyVar.sml *)
(*
 * Standard ML type variables
 *
 * Definition, sections 2.4 and 4.1
 *
 * Note:
 *  - Internally generated tyvars get names '#xxx, where xxx is a stamp number.
 *  - Tyvars generated from integers are mapped to 'a,'b,..,'z,'aa,'bb,..,'zz,
 *    'aaa,...
 *)


structure TyVar :> TYVAR =
  struct

    (* Type [Sections 2.4 and 4.1]*)

    type TyVar = { name: string, equality: bool }       (* [alpha] or [tyvar] *)


    (* Creation *)

    fun invent equality =
        { name="'#" ^ Stamp.toString(Stamp.stamp()),
          equality=equality }

    fun fromIndex equality n =
        let
            fun rep(0,c) = c
              | rep(n,c) = c ^ rep(n-1,c)

            val c    = String.str(Char.chr(Char.ord #"a" + n mod 26))
            val name = (if equality then "''" else "'") ^ rep(n div 26, c)
        in
            { name=name, equality=equality }
        end

    fun fromString s =
        { name = s,
          equality = String.size(s) > 1 andalso String.sub(s,1) = #"'" }

    fun toString{name,equality}       = name


    (* Attributes [Section 4.1] *)

    fun admitsEquality{name,equality} = equality

    fun isExplicit{name,equality} =
        String.size name = 1 orelse String.sub(name,1) <> #"#"


    (* Small helpers *)

    fun normalise({name,equality}, n) = fromIndex equality n

    fun instance{name,equality}       = invent equality


    (* Ordering *)

    fun compare(alpha1: TyVar, alpha2: TyVar) =
        String.compare(#name alpha1, #name alpha2)

  end
(* stop of TyVar.sml *)
(* start of TYNAME.sml *)
(*
 * Standard ML type names
 *
 * Definition, section 4.1
 *
 * Notes:
 * - Equality is not a boolean attribute. We distinguish a 3rd kind of special
 *   type names which have equality regardless of the types applied. This
 *   implements ref, array, and equivalent types.
 * - For easy checking of pattern exhaustiveness we add an attribute
 *   `span' counting the number of constructors of the type.
 *)


signature TYNAME =
  sig

    (* Import *)

    type TyCon = TyCon.Id


    (* Type [Section 4.1] *)

    eqtype TyName                                       (* [t] *)

    datatype Equality = NOEQ | EQ | SPECIALEQ


    (* Operations *)

    val tyname:         TyCon * int * Equality * int -> TyName
    val invent:         int * Equality -> TyName
    val rename:         TyName -> TyName
    val removeEquality: TyName -> TyName
    val Abs:            TyName -> TyName

    val arity:          TyName -> int
    val equality:       TyName -> Equality
    val span:           TyName -> int
    val tycon:          TyName -> TyCon
    val toString:       TyName -> string

    val compare:        TyName * TyName -> order

  end
(* stop of TYNAME.sml *)
(* start of TyName.sml *)
(*
 * Standard ML type names
 *
 * Definition, section 4.1
 *
 * Notes:
 * - Equality is not a boolean attribute. We distinguish a 3rd kind of special
 *   type names which have equality regardless of the types applied. This
 *   implements ref, array, and equivalent types.
 * - For easy checking of pattern exhaustiveness we add an attribute
 *   `span' counting the number of constructors of the type.
 *)


structure TyName :> TYNAME =
  struct

    (* Import *)

    type TyCon = TyCon.Id
    type stamp = Stamp.stamp


    (* Type [Section 4.1] *)

    datatype Equality = NOEQ | EQ | SPECIALEQ

    type TyName =                                     (* [t] *)
         { tycon:       TyCon
         , stamp:       stamp
         , arity:       int
         , equality:    Equality
         , span:        int
         }


    (* Creation *)

    fun tyname(tycon, arity, equality, span) =
        { tycon    = tycon
        , stamp    = Stamp.stamp()
        , arity    = arity
        , equality = equality
        , span     = span
        }

    fun invent(arity, equality) = tyname(TyCon.invent(), arity, equality, 0)


    (* Creation from existing *)

    fun rename{tycon, stamp, arity, equality, span} =
            tyname(tycon, arity, equality, span)

    fun removeEquality{tycon, stamp, arity, equality, span} =
            tyname(tycon, arity, NOEQ, span)

    fun Abs{tycon, stamp, arity, equality, span} =
            tyname(tycon, arity, NOEQ, 0)


    (* Attributes [Section 4.1] *)

    fun arity   {tycon, stamp, arity, equality, span} = arity
    fun equality{tycon, stamp, arity, equality, span} = equality
    fun span    {tycon, stamp, arity, equality, span} = span
    fun tycon   {tycon, stamp, arity, equality, span} = tycon

    fun toString{tycon, stamp, arity, equality, span} = TyCon.toString tycon


    (* Ordering *)

    fun compare(t1: TyName, t2: TyName) = Stamp.compare(#stamp t1, #stamp t2)

  end
(* stop of TyName.sml *)
(* start of SCON.sml *)
(*
 * Standard ML special constants
 *
 * Definition, section 2.2
 *)


signature SCON =
  sig

    (* Type [Section 2.2] *)

    datatype SCon =                             (* [scon] *)
          INT    of int
        | WORD   of word
        | STRING of string
        | CHAR   of char
        | REAL   of real

    (* Operations *)

    val fromInt:    int    -> SCon
    val fromWord:   word   -> SCon
    val fromString: string -> SCon
    val fromChar:   char   -> SCon
    val fromReal:   real   -> SCon

    val toString:   SCon   -> string

    val compare:    SCon * SCon -> order

  end
(* stop of SCON.sml *)
(* start of SCon.sml *)
(*
 * Standard ML special constants
 *
 * Definition, section 2.2
 *)


structure SCon :> SCON =
  struct

    (* Type [Section 2.2] *)

    datatype SCon =                             (* [scon] *)
          INT    of int
        | WORD   of word
        | STRING of string
        | CHAR   of char
        | REAL   of real


    (* Conversions *)

    val fromInt    = INT
    val fromWord   = WORD
    val fromString = STRING
    val fromChar   = CHAR
    val fromReal   = REAL

    fun toString(INT i)    = Int.toString i
      | toString(WORD w)   = "0wx" ^ Word.toString w
      | toString(STRING s) = "\""  ^ String.toCString s ^ "\""
      | toString(CHAR c)   = "\"#" ^ Char.toCString c   ^ "\""
      | toString(REAL r)   = Real.toString r


    (* Ordering *)

    fun compare(INT n1,    INT n2)    = Int.compare(n1, n2)
      | compare(WORD w1,   WORD w2)   = Word.compare(w1, w2)
      | compare(STRING s1, STRING s2) = String.compare(s1, s2)
      | compare(CHAR c1,   CHAR c2)   = Char.compare(c1, c2)
      | compare(REAL x1,   REAL x2)   = Real.compare(x1, x2)
      | compare  _                    = raise Domain

  end
(* stop of SCon.sml *)
(* start of LAB.sml *)
(*
 * Standard ML label identifiers
 *
 * Definition, section 2.4
 *)


signature LAB =
  sig

    (* Type [Section 2.4] *)

    eqtype Lab                                  (* [lab] *)


    (* Operations *)

    val fromString:     string -> Lab
    val fromInt:        int    -> Lab
    val toString:       Lab    -> string

    val compare:        Lab * Lab -> order

  end
(* stop of LAB.sml *)
(* start of Lab.sml *)
(*
 * Standard ML label identifiers
 *
 * Definition, section 2.4
 *)


structure Lab :> LAB =
  struct

    (* Type [Section 2.4] *)

    type Lab = string                                   (* [lab] *)


    (* Conversions *)

    fun fromString s = s
    val fromInt      = Int.toString
    fun toString s   = s


    (* Ordering *)

    fun compare(lab1,lab2) =
      case (Int.fromString lab1, Int.fromString lab2)
        of (SOME i1, SOME i2) => Int.compare(i1,i2)
         |     _              => String.compare(lab1,lab2)

  end
(* stop of Lab.sml *)
(* start of AssembliesCoreStatic.sml *)
(*
 * Standard ML sets and maps for the static semantics of the core
 *
 * Definition, section 4.2
 *)

structure TyVarSet   = FinSetFn(type ord_key = TyVar.TyVar
                                val  compare = TyVar.compare)

structure TyNameSet  = FinSetFn(type ord_key = TyName.TyName
                                val  compare = TyName.compare)

structure SConSet    = FinSetFn(type ord_key = SCon.SCon
                                val  compare = SCon.compare)

structure VIdSet     = FinSetFn(type ord_key = VId.Id
                                val  compare = VId.compare)

structure LongVIdSet = FinSetFn(type ord_key = LongVId.longId
                                val  compare = LongVId.compare)


structure LabMap     = FinMapFn(type ord_key = Lab.Lab
                                val  compare = Lab.compare)

structure VIdMap     = FinMapFn(type ord_key = VId.Id
                                val  compare = VId.compare)

structure TyConMap   = FinMapFn(type ord_key = TyCon.Id
                                val  compare = TyCon.compare)

structure TyVarMap   = FinMapFn(type ord_key = TyVar.TyVar
                                val  compare = TyVar.compare)

structure TyNameMap  = FinMapFn(type ord_key = TyName.TyName
                                val  compare = TyName.compare)

structure StrIdMap   = FinMapFn(type ord_key = StrId.Id
                                val  compare = StrId.compare)
(* stop of AssembliesCoreStatic.sml *)
(* start of OVERLOADINGCLASS.sml *)
(*
 * Standard ML overloading classes
 *
 * Definition, appendix E
 *
 * Note:
 *  Overloading -- and defaulting in particular -- is not well formalised in
 *  the Definition. We describe an overloading class as a pair (T,t) of a set
 *  of type names (like the definition does), plus the default type name t.
 *  For overloading to be sound some well-formedness properties have to be
 *  enforced for all existing overloading classes (T,t):
 *  (1) t elem T
 *  (2) Eq T = 0  \/  t admits equality
 *  (3) forall (T',t') . (  TT' = 0  \/  t = t' )
 *  where Eq T = { t elem T | t admits equality } and we write TT' for the
 *  T intersect T' and 0 for the empty set.
 *  The reason for (1) is obvious. (2) guarantees that we do not loose the
 *  default if we enforce equality. (3) ensures the same if we have to unify
 *  two overloading classes. (2) and (3) also allow the resulting set to become
 *  empty which will cause a type error.
 *)

signature OVERLOADINGCLASS =
  sig

    (* Import types *)

    type TyName    = TyName.TyName
    type TyNameSet = TyNameSet.set


    (* Type *)

    type OverloadingClass                               (* [O] *)


    (* Operations *)

    val make:           TyNameSet * TyName -> OverloadingClass

    val isEmpty:        OverloadingClass -> bool
    val isSingular:     OverloadingClass -> bool
    val default:        OverloadingClass -> TyName
    val set:            OverloadingClass -> TyNameSet
    val member:         OverloadingClass * TyName -> bool
    val getItem:        OverloadingClass -> TyName

    val makeEquality:   OverloadingClass -> OverloadingClass option
    val intersection:   OverloadingClass * OverloadingClass ->
                                           OverloadingClass option
    val union:          OverloadingClass * OverloadingClass ->
                                           OverloadingClass

  end
(* stop of OVERLOADINGCLASS.sml *)
(* start of OverloadingClass.sml *)
(*
 * Standard ML overloading classes
 *
 * Definition, appendix E
 *
 * Note:
 *  Overloading -- and defaulting in particular -- is not well formalised in
 *  the Definition. We describe an overloading class as a pair (T,t) of a set
 *  of type names (like the definition does), plus the default type name t.
 *  For overloading to be sound some well-formedness properties have to be
 *  enforced for all existing overloading classes (T,t):
 *  (1) t elem T
 *  (2) Eq T = 0  \/  t admits equality
 *  (3) forall (T',t') . (  TT' = 0  \/  t = t' )
 *  where Eq T = { t elem T | t admits equality } and we write TT' for the
 *  T intersect T' and 0 for the empty set.
 *  The reason for (1) is obvious. (2) guarantees that we do not loose the
 *  default if we enforce equality. (3) ensures the same if we have to unify
 *  two overloading classes. (2) and (3) also allow the resulting set to become
 *  empty which will cause a type error.
 *)

structure OverloadingClass :> OVERLOADINGCLASS =
  struct

    (* Import types *)

    type TyName    = TyName.TyName
    type TyNameSet = TyNameSet.set


    (* Type *)

    type OverloadingClass = TyNameSet * TyName          (* [O] *)


    (* Simple operations *)

    fun make O            = O

    fun isEmpty (T,t)     = TyNameSet.isEmpty T
    fun isSingular (T,t)  = TyNameSet.numItems T = 1
    fun default (T,t)     = t
    fun set (T,t)         = T
    fun member((T,t), t') = TyNameSet.member(T, t')
    fun getItem (T,t)     = valOf(TyNameSet.find (fn _ => true) T)


    (* Filter equality types *)

    fun makeEquality (T,t) =
        let
            val T' = TyNameSet.filter (fn t => TyName.equality t = TyName.EQ) T
        in
            if TyNameSet.isEmpty T' then
                NONE
            else if TyName.equality t <> TyName.NOEQ then
                SOME(T',t)
            else
                raise Fail "OverloadingClass.makeEquality: \
                           \inconsistent overloading classes"
        end


    (* Intersection and union *)

    fun intersection((T1,t1), (T2,t2)) =
        let
            val T' = TyNameSet.intersection(T1,T2)
        in
            if TyNameSet.isEmpty T' then
                NONE
            else if t1 = t2 then
                SOME(T',t1)
            else
                raise Fail "OverloadingClass.intersect: \
                           \inconsistent overloading classes"
        end


    fun union((T1,t1), (T2,t2)) = ( TyNameSet.union(T1,T2), t2 )

  end
(* stop of OverloadingClass.sml *)
(* start of TYPE.sml *)
(*
 * Standard ML types
 *
 * Definition, section 4.2 and 4.4
 *
 * Notes:
 *   - Types are references so that unification can work via side effects.
 *     We need links (forwards) to unify two type variables.
 *   - Types built bottom-up have to be `normalised' to induce the required
 *     sharing on type variables.
 *   - Care has to be taken to clone types at the proper places.
 *   - Substitution creates a clone, but shares free type variables.
 *   - To represent overloaded type (variables), we add a special type.
 *   - Record types may contain a row variable to represent open record types
 *     (which appear during type inference). Flexible rows have to carry an
 *     equality flag to properly propagate equality enforced by unification
 *     when extending a row.
 *)

signature TYPE =
  sig

    (* Import types *)

    type Lab              = Lab.Lab
    type TyVar            = TyVar.TyVar
    type TyVarSet         = TyVarSet.set
    type TyName           = TyName.TyName
    type TyNameSet        = TyNameSet.set
    type OverloadingClass = OverloadingClass.OverloadingClass
    type 'a LabMap        = 'a LabMap.map
    type 'a TyVarMap      = 'a TyVarMap.map
    type 'a TyNameMap     = 'a TyNameMap.map
 

    (* Types [Section 4.2] *)

    datatype RowVar = CLOSEDRow | FLEXRow of bool               (* [r] *)

    datatype Type' =                                            (* [tau] *)
          TyVar      of TyVar
        | RowType    of (*RowType*) (Type' ref LabMap * RowVar)
        | FunType    of (*FunType*) (Type' ref * Type' ref)
        | ConsType   of (*ConsType*)(Type' ref list * TyName)
        | Overloaded of OverloadingClass
        | Link       of (*Type*) Type' ref

    type Type         = Type' ref

    type RowType      = Type LabMap * RowVar                    (* [rho] *)
    type FunType      = Type * Type
    type ConsType     = Type list * TyName

    type TypeFcn      = TyVar list * Type                       (* [theta] *)

    type Substitution = Type TyVarMap                           (* [mu] *)
    type Realisation  = TypeFcn TyNameMap                       (* [phi] *)


    (* Operations *)

    val invent:                 unit -> Type
    val fromTyVar:              TyVar -> Type
    val fromRowType:            RowType -> Type
    val fromFunType:            FunType -> Type
    val fromConsType:           ConsType -> Type
    val fromOverloadingClass:   OverloadingClass -> Type

    val range:                  Type -> Type
    val tyname:                 Type -> TyName

    val normalise:              Type -> Type
    val substitute:             Substitution -> Type -> Type
    val realise:                Realisation  -> Type -> Type

    val tyvars:                 Type -> TyVarSet
    val tynames:                Type -> TyNameSet
    val admitsEquality:         Type -> bool
    val isFlexible:             Type -> bool

    exception Unify
    val unify:                  Type * Type -> unit (* Unify *)
    val unifyRestricted:        TyVarSet -> Type * Type -> unit (* Unify *)
    val makeEquality:           Type -> unit (* Unify *)

    val defaultOverloaded:      Type -> unit


    (* Operations on rows *)

    val emptyRho:               RowType
    val singletonRho:           Lab * Type -> RowType
    val insertRho:              RowType * Lab * Type -> RowType
    val inventRho:              unit -> RowType
    val findLab:                RowType * Lab -> Type option

  end
(* stop of TYPE.sml *)
(* start of Type.sml *)
(*
 * Standard ML types
 *
 * Definition, section 4.2 and 4.4
 *
 * Notes:
 *   - Types are references so that unification can work via side effects.
 *     We need links (forwards) to unify two type variables.
 *   - Types built bottom-up have to be `normalised' to induce the required
 *     sharing on type variables.
 *   - Care has to be taken to clone types at the proper places.
 *   - Substitution creates a clone, but shares free type variables.
 *   - To represent overloaded type (variables), we add a special type.
 *   - Record types may contain a row variable to represent open record types
 *     (which appear during type inference). Flexible rows have to carry an
 *     equality flag to properly propagate equality enforced by unification
 *     when extending a row.
 *)

structure Type :> TYPE =
  struct

    (* Import types *)

    type Lab              = Lab.Lab
    type TyVar            = TyVar.TyVar
    type TyVarSet         = TyVarSet.set
    type TyName           = TyName.TyName
    type TyNameSet        = TyNameSet.set
    type OverloadingClass = OverloadingClass.OverloadingClass
    type 'a LabMap        = 'a LabMap.map
    type 'a TyVarMap      = 'a TyVarMap.map
    type 'a TyNameMap     = 'a TyNameMap.map


    (* Types [Section 4.2] *)

    datatype RowVar = CLOSEDRow | FLEXRow of bool       (* [r] *)

    datatype Type' =                                    (* [tau] *)
          TyVar      of TyVar
        | RowType    of RowType
        | FunType    of FunType
        | ConsType   of ConsType
        | Overloaded of OverloadingClass
        | Link       of Type

    withtype Type     = Type' ref

    and RowType       = Type' ref LabMap * RowVar       (* [rho] *)
    and FunType       = Type' ref * Type' ref
    and ConsType      = Type' ref list * TyName

    type TypeFcn      = TyVar list * Type               (* [theta] *)

    type Substitution = Type TyVarMap                   (* [mu] *)
    type Realisation  = TypeFcn TyNameMap               (* [phi] *)


    (* Creation *)

    fun invent() = ref(TyVar(TyVar.invent false))

    fun fromTyVar alpha        = ref(TyVar alpha)
    fun fromRowType rho        = ref(RowType rho)
    fun fromFunType x          = ref(FunType x)
    fun fromConsType x         = ref(ConsType x)
    fun fromOverloadingClass O = ref(Overloaded O)


    (* Projections *)

    fun range(ref(FunType(tau1,tau2))) = tau2
      | range tau                      = tau

    fun tyname(ref(ConsType(taus,t)))  = t
      | tyname  _                      =
            raise Fail "Type.tyname: non-constructed type"


    (* Induce sharing on equal type variables in a type *)

    fun normalise tau =
        let
            (* Note that Overloaded nodes also have to be shared.
             * But since such types are always pre-built rather than
             * infered, we just take care that we construct them with
             * proper sharing and ignore Overloaded nodes here.
             *)

            val alphas = ref []

            fun normalise(tau as ref(TyVar(alpha))) =
                (case List.find (fn(alpha1,_) => alpha1 = alpha) (!alphas)
                   of SOME(_,tau1) => tau1
                    | NONE         => ( alphas := (alpha,tau) :: !alphas
                                      ; tau
                                      )
                )
              | normalise(ref(Link(tau)))  = normalise tau
              | normalise(tau as ref tau') = ( tau := normalise' tau' ; tau )

            and normalise'(RowType(Rho,r)) =
                    RowType(LabMap.map normalise Rho, r)

              | normalise'(FunType(tau1,tau2)) =
                    FunType(normalise tau1, normalise tau2)

              | normalise'(ConsType(taus,t)) =
                    ConsType(List.map normalise taus, t)

              | normalise'(Overloaded(O)) =
                    Overloaded(O)

              | normalise' _ =
                    raise Fail "Type.normalise: bypassed type variable or link"
        in
            normalise tau
        end



    (* Cloning under a substitution and a type realisation *)

    fun clone (mu,phi) tau =
        let
            (* Cloning must respect sharing, so an association list is used
             * to remember nodes already visited together with their copy.
             *)

            val mu'    = ref mu
            val cloned = ref []

            fun clone tau =
                case List.find (fn(tau1,_) => tau1 = tau) (!cloned)
                  of SOME(_,tau2) => tau2
                   | NONE         => let val tau2 = clone' tau in
                                         cloned := (tau,tau2) :: !cloned
                                        ; tau2
                                     end

            and clone'(tau as ref(TyVar(alpha))) =
                (case TyVarMap.find(!mu', alpha)
                   of NONE     => tau
                    | SOME tau => tau
                )
              | clone'(ref(RowType(Rho,r))) =
                    ref(RowType(LabMap.map clone Rho, r))

              | clone'(ref(FunType(tau1,tau2))) =
                    ref(FunType(clone tau1, clone tau2))

              | clone'(tau as ref(ConsType(taus,t))) =
                let
                    val taus2 = List.map clone taus
                in
                    case TyNameMap.find(phi, t)
                      of NONE              => ref(ConsType(taus2,t))
                       | SOME(alphas,tau1) =>
                         let
                            val cloned' = !cloned
                         in
                            mu' := ListPair.foldl
                                    (fn(alpha,tau2,mu) =>
                                        TyVarMap.insert(mu,alpha,tau2))
                                    (!mu') (alphas,taus2)
                            ; clone' tau1
                            before cloned := cloned'
                         end
                end

              | clone'(ref(Overloaded(O))) =
                    ref(Overloaded(O))

              | clone'(ref(Link(tau))) =
                    clone tau
        in
            clone tau
        end


    (* Substitution, and realisation [Section 5.2] *)

    fun substitute mu = clone(mu,TyNameMap.empty)
    fun realise phi   = clone(TyVarMap.empty,phi)


    (* Type variable and type name extraction [Section 4.2] *)

    fun tyvars(ref tau') = tyvars' tau'

    and tyvars'(TyVar(alpha)) = TyVarSet.singleton alpha

      | tyvars'(RowType(Rho,r)) =
            LabMap.foldl (fn(tau,U) => TyVarSet.union(U, tyvars tau))
                         TyVarSet.empty Rho

      | tyvars'(FunType(tau1,tau2)) =
            TyVarSet.union(tyvars tau1, tyvars tau2)
 
      | tyvars'(ConsType(taus,t)) =
            List.foldl (fn(tau,U) => TyVarSet.union(U, tyvars tau))
                       TyVarSet.empty taus

      | tyvars'(Overloaded(O)) =
            TyVarSet.empty

      | tyvars'(Link(tau)) =
            tyvars tau


    fun tynames(ref tau') = tynames' tau'

    and tynames'(TyVar(alpha)) = TyNameSet.empty

      | tynames'(RowType(Rho,r)) =
            LabMap.foldl (fn(tau,T) =>
                          TyNameSet.union(T, tynames tau)) TyNameSet.empty Rho

      | tynames'(FunType(tau1,tau2)) =
            TyNameSet.union(tynames tau1, tynames tau2)
 
      | tynames'(ConsType(taus,t)) =
        let
            val T = List.foldl (fn(tau,T) => TyNameSet.union(T, tynames tau))
                               TyNameSet.empty taus
        in
            TyNameSet.add(T, t)
        end

      | tynames'(Overloaded(O)) =
            (* Conservative approximation *)
            OverloadingClass.set O

      | tynames'(Link(tau)) =
            tynames tau



    (* Check for equality type [Section 4.4] *)

    fun admitsEquality(ref tau') = admitsEquality' tau'

    and admitsEquality'(TyVar alpha) =
            TyVar.admitsEquality alpha orelse
            not(TyVar.isExplicit alpha)

      | admitsEquality'(RowType(Rho,CLOSEDRow)) =
            LabMap.all admitsEquality Rho

      | admitsEquality'(RowType(Rho,FLEXRow _)) =
            raise Fail "Type.admitsEquality: flexible row"

      | admitsEquality'(FunType _) = false

      | admitsEquality'(ConsType(taus,t)) =
        (case TyName.equality t
           of TyName.SPECIALEQ => true
            | TyName.EQ        => List.all admitsEquality taus
            | TyName.NOEQ      => false
        )

      | admitsEquality'(Overloaded(O)) =
            raise Fail "Type.admitsEquality: overloaded type"

      | admitsEquality'(Link(tau)) =
            admitsEquality tau



    (* Look for flexible records *)

    fun isFlexible(ref tau') = isFlexible' tau'

    and isFlexible'(TyVar(alpha')) = false

      | isFlexible'(RowType(Rho,r)) =
            r <> CLOSEDRow orelse LabMap.exists isFlexible Rho

      | isFlexible'(FunType(tau1,tau2)) =
            isFlexible tau1 orelse isFlexible tau2

      | isFlexible'(ConsType(taus,t)) =
            List.exists isFlexible taus

      | isFlexible'(Overloaded(O)) = false

      | isFlexible'(Link(tau)) = isFlexible tau



    (* Unification *)

    exception Unify


    fun occurs(alpha, ref tau') = occurs'(alpha, tau')

    and occurs'(alpha, TyVar(alpha')) =
            alpha = alpha'

      | occurs'(alpha, RowType(Rho,r)) =
            LabMap.exists (fn tau => occurs(alpha, tau)) Rho

      | occurs'(alpha, FunType(tau1,tau2)) =
            occurs(alpha, tau1) orelse occurs(alpha, tau2)

      | occurs'(alpha, ConsType(taus,t)) =
            List.exists (fn tau => occurs(alpha, tau)) taus

      | occurs'(alpha, Overloaded(O)) =
            false

      | occurs'(alpha, Link(tau)) =
            occurs(alpha, tau)


    fun unify(ref(Link(tau1)), tau2) = unify(tau1, tau2)
      | unify(tau1, ref(Link(tau2))) = unify(tau1, tau2)

      | unify(tau1 as ref tau1', tau2 as ref tau2') =
        if tau1 = tau2 then () else
        let
            val tau' = Link(ref(unify'(tau1',tau2')))
        in
            tau1 := tau' ; tau2 := tau'
        end

    and unify'(TyVar(alpha), tau')  = unifyTyVar(alpha, tau')
      | unify'(tau', TyVar(alpha))  = unifyTyVar(alpha, tau')
      | unify'(Overloaded(O), tau') = unifyOverloaded(O, tau')
      | unify'(tau', Overloaded(O)) = unifyOverloaded(O, tau')

      | unify'(tau' as FunType(tau11,tau12), FunType(tau21,tau22)) =
          ( unify(tau11,tau21)
          ; unify(tau12,tau22)
          ; tau'
          )

      | unify'(RowType(Rho1,r1), RowType(Rho2,r2)) =
        let
            fun unifyField r (lab, tau1, Rho) =
                case LabMap.find(Rho, lab)
                  of SOME tau2  => ( unify(tau1,tau2)
                                   ; #1(LabMap.remove(Rho,lab))
                                   )
                   | NONE =>
                case r
                  of CLOSEDRow  => raise Unify
                   | FLEXRow eq => ( if eq then makeEquality tau1 else ()
                                   ; Rho
                                   )

            val Rho1'  = LabMap.foldli (unifyField r1) Rho1 Rho2
            val _      = LabMap.foldli (unifyField r2) Rho2 Rho1'
            val r      = case (r1,r2)
                           of (CLOSEDRow, _) => CLOSEDRow
                            | (_, CLOSEDRow) => CLOSEDRow
                            | (FLEXRow eq1, FLEXRow eq2) =>
                                  FLEXRow(eq1 orelse eq2)
        in
            RowType(LabMap.unionWith #2 (Rho2,Rho1'), r)
        end


      | unify'(tau' as ConsType(taus1,t1), ConsType(taus2,t2)) =
        if t1 = t2 then
            ( ListPair.app unify (taus1,taus2)
            ; tau'
            )
        else
            raise Unify

      | unify' _ = raise Unify


    and unifyTyVar(alpha1, TyVar(alpha2)) =
        if alpha1 = alpha2 then
            TyVar(alpha2)
        else if not(TyVar.isExplicit alpha1) then
            bindTyVar(alpha1, TyVar(alpha2))
        else if not(TyVar.isExplicit alpha2) then
            bindTyVar(alpha2, TyVar(alpha1))
        else
            raise Unify

      | unifyTyVar(alpha, tau') =
        if TyVar.isExplicit alpha orelse occurs'(alpha, tau') then
            raise Unify
        else
            bindTyVar(alpha, tau')

    and bindTyVar(alpha, tau') =
        if TyVar.admitsEquality alpha then
            makeEquality' tau'
        else
            tau'


    and unifyOverloaded(O, TyVar(alpha2)) =
            unifyTyVar(alpha2, Overloaded(O))

      | unifyOverloaded(O, tau' as ConsType([],t)) =
        if OverloadingClass.member(O, t) then
            tau'
        else
            raise Unify

      | unifyOverloaded(O1, Overloaded(O2)) =
        (case OverloadingClass.intersection(O1,O2)
           of NONE   => raise Unify
            | SOME O => Overloaded(O)
        )

      | unifyOverloaded(O, _) =
            raise Unify


    and makeEquality(tau as ref tau') = tau := makeEquality' tau'

    and makeEquality'(TyVar(alpha)) =
        if TyVar.admitsEquality alpha then
            TyVar(alpha)
        else if TyVar.isExplicit alpha then
            raise Unify
        else
            TyVar(TyVar.invent true)

      | makeEquality'(RowType(Rho,r)) =
            ( LabMap.app makeEquality Rho
            ; RowType(Rho, case r of CLOSEDRow => CLOSEDRow
                                   | FLEXRow _ => FLEXRow true)
            )

      | makeEquality'(FunType _) =
            raise Unify

      | makeEquality'(tau' as ConsType(taus,t)) =
        (case TyName.equality t
           of TyName.SPECIALEQ => tau'
            | TyName.EQ        => ( List.app makeEquality taus ; tau' )
            | TyName.NOEQ      => raise Unify
        )

      | makeEquality'(Overloaded(O)) =
        (case OverloadingClass.makeEquality O
           of NONE    => raise Unify
            | SOME O' => Overloaded(O')
        )
      | makeEquality'(Link(tau)) =
            ( makeEquality tau ; Link(tau) )



    fun unifyRestricted U (tau1,tau2) =
        let
            fun skolemise(alpha, mu) =
                let
                   val equality = if TyVar.admitsEquality alpha then TyName.EQ
                                                                else TyName.NOEQ
                   val tau'     = ConsType([], TyName.invent(0,equality))
                in
                   TyVarMap.insert(mu, alpha, ref tau')
                end

            val mu = TyVarSet.foldl skolemise TyVarMap.empty U
        in
            unify(substitute mu tau1, substitute mu tau2)
        end



    (* Assign default type to overloaded type components [Appendix E] *)

    fun defaultOverloaded(tau as ref(Overloaded(O))) =
            tau := ConsType([], OverloadingClass.default O)

      | defaultOverloaded(ref tau') = defaultOverloaded' tau'

    and defaultOverloaded'(TyVar(alpha')) = ()

      | defaultOverloaded'(RowType(Rho,r)) =
            LabMap.app defaultOverloaded Rho

      | defaultOverloaded'(FunType(tau1,tau2)) =
            ( defaultOverloaded tau1 ; defaultOverloaded tau2 )

      | defaultOverloaded'(ConsType(taus,t)) =
            List.app defaultOverloaded taus

      | defaultOverloaded'(Overloaded(O)) =
            raise Fail "Type.defaultOverloaded: bypassed overloaded type"

      | defaultOverloaded'(Link(tau)) =
            defaultOverloaded tau



    (* Operations on rows *)

    val emptyRho                     = ( LabMap.empty, CLOSEDRow )
    fun singletonRho(lab,tau)        = ( LabMap.singleton(lab,tau), CLOSEDRow )
    fun inventRho()                  = ( LabMap.empty, FLEXRow false )
    fun insertRho((Rho,r), lab, tau) = ( LabMap.insert(Rho, lab, tau), r )
    fun findLab((Rho,r), lab)        = LabMap.find(Rho, lab)

  end
(* stop of Type.sml *)
(* start of TYPESCHEME.sml *)
(*
 * Standard ML type schemes
 *
 * Definition, section 4.2, 4.5, and 4.8
 *
 * Note:
 *    Instantiation copies a type (except free type variables).
 *    Closure does not!
 *)

signature TYPESCHEME =
  sig

    (* Import types *)

    type Type         = Type.Type
    type TyVar        = TyVar.TyVar
    type TyVarSet     = TyVarSet.set
    type TyName       = TyName.TyName
    type TyNameSet    = TyNameSet.set
    type Substitution = Type.Substitution
    type Realisation  = Type.Realisation
    type 'a TyNameMap = 'a TyNameMap.map


    (* Type [Section 4.2] *)

    type TypeScheme = TyVar list * Type                 (* [sigma] *)


    (* Operations *)

    val instance:       TypeScheme -> Type
    val instance':      TypeScheme -> TyVar list * Type
    val Clos:           Type -> TypeScheme
    val ClosRestricted: TyVarSet -> Type -> TypeScheme
    val isClosed:       TypeScheme -> bool

    val tyvars:         TypeScheme -> TyVarSet
    val tynames:        TypeScheme -> TyNameSet
    val normalise:      TypeScheme -> TypeScheme

    val generalises:    TypeScheme * TypeScheme -> bool
    val equals:         TypeScheme * TypeScheme -> bool

    val substitute:     Substitution -> TypeScheme -> TypeScheme
    val realise:        Realisation  -> TypeScheme -> TypeScheme

  end
(* stop of TYPESCHEME.sml *)
(* start of TypeScheme.sml *)
(*
 * Standard ML type schemes
 *
 * Definition, section 4.2, 4.5, and 4.8
 *
 * Note:
 *    Instantiation copies a type (except free type variables).
 *    Closure does not!
 *)

structure TypeScheme :> TYPESCHEME =
  struct

    (* Import types *)

    type Type         = Type.Type
    type TyVar        = TyVar.TyVar
    type TyVarSet     = TyVarSet.set
    type TyName       = TyName.TyName
    type TyNameSet    = TyNameSet.set
    type Substitution = Type.Substitution
    type Realisation  = Type.Realisation
    type 'a TyNameMap = 'a TyNameMap.map


    (* Type [Section 4.2] *)

    type TypeScheme = TyVar list * Type                 (* [sigma] *)


    (* Some helper (this should be in the library...) *)

    fun List_foldri f y0 xs =
        let
            fun fold(n,  [])   = y0
              | fold(n, x::xs) = f(n, x, fold(n+1,xs))
        in
            fold(0,xs)
        end



    (* Type variable and type name extraction [Section 4.2] *)

    fun tyvars (alphas,tau) =
        let
            val U = Type.tyvars tau
        in
            List.foldl
                (fn(alpha,U) => TyVarSet.delete(U,alpha)
                                handle LibBase.NotFound => U)
                U alphas
        end

    fun tynames (alphas,tau) = Type.tynames tau



    (* Instantiation *)

    fun instance' (alphas,tau) =
        let
            val alphas' = List.map TyVar.instance alphas
            val mu      = ListPair.foldl
                             (fn(alpha, alpha', mu) =>
                              TyVarMap.insert(mu, alpha, Type.fromTyVar alpha'))
                             TyVarMap.empty (alphas, alphas')
        in
            ( alphas', Type.substitute mu tau )
        end

    fun instance sigma = #2(instance' sigma)



    (* Generalisation [Section 4.5] *)

    fun generalisesType(sigma, tau) =
        let
            val U = Type.tyvars tau
        in
            ( Type.unifyRestricted U (instance sigma, tau) ; true )
            handle Type.Unify => false
        end

    fun generalises(sigma1, sigma2) =
            generalisesType(sigma1, instance sigma2)



    (* Closure [Section 4.8] *)

    fun Clos tau =
            (* Does not copy! *)
            ( TyVarSet.listItems(Type.tyvars tau), tau )

    fun ClosRestricted U tau =
            ( TyVarSet.listItems(TyVarSet.difference(Type.tyvars tau, U)), tau )

    fun isClosed (alphas,tau) =
        TyVarSet.isSubset(Type.tyvars tau, TyVarSet.fromList alphas)


    (* Comparison [Section 4.5] *)

    fun equals((alphas1,tau1), (alphas2,tau2)) =
        List.length alphas1 = List.length alphas2 andalso
        let
            fun insert(alpha1, alpha2, mu) =
                TyVarMap.insert(mu, alpha1, Type.fromTyVar alpha2)

            val (alphas2',tau2') = instance' (alphas2,tau2)
            val mu    = ListPair.foldl insert TyVarMap.empty (alphas1,alphas2')
            val tau1' = Type.substitute mu tau1
            val U     = TyVarSet.fromList alphas2'
        in
            ( Type.unifyRestricted U (tau1',tau2') ; true )
            handle Type.Unify => false
        end


    (* Normalisation (for output) *)

    fun normalise (alphas,tau) =
        let
            fun insert(n, alpha, (alphas',mu)) =
                let
                    val alpha' = TyVar.normalise(alpha, n)
                    val tau    = Type.fromTyVar alpha'
                in
                    ( alpha'::alphas', TyVarMap.insert(mu, alpha,tau) )
                end

            val (alphas',mu) = List_foldri insert (nil,TyVarMap.empty) alphas
        in
            ( alphas', Type.substitute mu tau )
        end


    (* Substitution *)

    fun substitute mu (alphas,tau) =
        let
            val mu' = List.foldl (fn(alpha,mu) =>
                                    #1(TyVarMap.remove(mu,alpha))
                                    handle LibBase.NotFound => mu) mu alphas
        in
            ( alphas, Type.substitute mu' tau )
        end


    (* Realisation [Section 5.2] *)

    fun realise phi (alphas,tau) = (alphas, Type.realise phi tau)

  end
(* stop of TypeScheme.sml *)
(* start of TYPEFCN.sml *)
(*
 * Standard ML type functions
 *
 * Definition, section 4.2, 4.4, and 4.8
 *
 * Note:
 *    Application copies the type (except free type variables).
 *)

signature TYPEFCN =
  sig

    (* Import types *)

    type Type         = Type.Type
    type TyVar        = TyVar.TyVar
    type TyVarSet     = TyVarSet.set
    type TyName       = TyName.TyName
    type TyNameSet    = TyNameSet.set
    type Realisation  = Type.TypeFcn TyNameMap.map


    (* Type [Section 4.2] *)

    type TypeFcn = Type.TypeFcn                 (* [theta] *)


    (* Operations *)

    val fromTyName:     TyName  -> TypeFcn
    val toTyName:       TypeFcn -> TyName option
    val isClosed:       TypeFcn -> bool

    val arity:          TypeFcn -> int
    val admitsEquality: TypeFcn -> bool

    val tyvars:         TypeFcn -> TyVarSet
    val tynames:        TypeFcn -> TyNameSet
    val normalise:      TypeFcn -> TypeFcn
    val rename:         TypeFcn -> TypeFcn

    val equals:         TypeFcn * TypeFcn -> bool

    exception Apply
    val apply:          Type list * TypeFcn -> Type     (* may raise Apply *)

    val realise:        Realisation -> TypeFcn -> TypeFcn

    val makeEquality:   TypeFcn -> unit

  end
(* stop of TYPEFCN.sml *)
(* start of TypeFcn.sml *)
(*
 * Standard ML type functions
 *
 * Definition, section 4.2, 4.4, and 4.8
 *
 * Note:
 *    Application copies the type (except free type variables).
 *)

structure TypeFcn :> TYPEFCN =
  struct

    (* Import types *)

    type Type         = Type.Type
    type TyVar        = TyVar.TyVar
    type TyVarSet     = TyVarSet.set
    type TyName       = TyName.TyName
    type TyNameSet    = TyNameSet.set
    type Realisation  = Type.TypeFcn TyNameMap.map


    (* Type [Section 4.2] *)

    type TypeFcn = Type.TypeFcn                         (* [theta] *)


    (* Operations *)

    val tyvars    = TypeScheme.tyvars           (* same type ;-) *)
    val tynames   = TypeScheme.tynames
    val equals    = TypeScheme.equals
    val isClosed  = TypeScheme.isClosed
    val realise   = TypeScheme.realise
    val rename    = TypeScheme.instance'
    val normalise = TypeScheme.normalise


    (* Arity [Section 4.4] *)

    fun arity (alphas,tau) = List.length alphas


    (* Equality [Section 4.4] *)

    fun admitsEquality (alphas,tau) =
        let
            fun insert(alpha, mu) =
                TyVarMap.insert(mu, alpha, Type.fromTyVar(TyVar.invent true))

            val mu = List.foldl insert TyVarMap.empty alphas
        in
            Type.admitsEquality(Type.substitute mu tau)
        end
    

    (* Eta-conversion [Section 4.4] *)

    fun fromTyName t =
        let
            val alphas = List.tabulate(TyName.arity t, TyVar.fromIndex false)
        in
            ( alphas, Type.fromConsType(List.map Type.fromTyVar alphas, t) )
        end

    fun toTyName(alphas, ref(Type.ConsType(taus,t))) = t
      | toTyName _ = raise Fail "TypeFcn.toTyName: invalid type function"

    fun toTyName(alphas, ref(Type.ConsType(taus,t))) =
        let
            fun isSame(alpha, ref(Type.TyVar alpha')) = alpha = alpha'
              | isSame(alpha,            _          ) = false
        in
            if List.length alphas = List.length taus
            andalso ListPair.all isSame (alphas, taus) then
                SOME t
            else
                NONE
        end

      | toTyName _ = NONE


    (* Application [Section 4.4] *)

    exception Apply

    fun apply(taus, (alphas,tau)) =
        if List.length taus <> List.length alphas then raise Apply else
        let
            fun insert(alpha, tau, mu) = TyVarMap.insert(mu, alpha, tau)
            val mu = ListPair.foldl insert TyVarMap.empty (alphas, taus)
        in
            Type.substitute mu tau
        end


    (* Make it an equality type *)

    fun makeEquality (alphas,tau) = Type.makeEquality tau

  end
(* stop of TypeFcn.sml *)
(* start of IDSTATUS.sml *)
(*
 * Standard ML identifier status
 *
 * Definition, sections 4.1 and 5.5
 *)


signature IDSTATUS =
  sig

    (* Type [Section 4.1] *)

    datatype IdStatus = c | e | v                       (* [is] *)


    (* Operations *)

    val generalises: IdStatus * IdStatus -> bool

  end
(* stop of IDSTATUS.sml *)
(* start of IdStatus.sml *)
(*
 * Standard ML identifier status
 *
 * Definition, sections 4.1 and 5.5
 *)


structure IdStatus :> IDSTATUS =
  struct

    (* Type [Section 4.1] *)

    datatype IdStatus = c | e | v                       (* [is] *)


    (* Generalisation [Section 5.5] *)

    fun generalises(is1,is2) = is1 = is2 orelse is2 = v

  end
(* stop of IdStatus.sml *)
(* start of GENERIC_ENV.sml *)
(*
 * Standard ML generic core environment
 *
 * Definition, sections 4.2, 4.3, 6.3 and 7.2
 *
 * Notes:
 *   - A datatype Str is necessary to break the recursion
 *     between Env and StrEnv.
 *   - Also, all types are parameterised over the range of value and type
 *     environments. This is because of the recursion between values and
 *     the dynamic environment (via function closures) -- we cannot make them
 *     into functor parameters as this would require recursive structures.
 *)

signature GENERIC_ENV =
  sig

    (* Import types *)

    type VId         = VId.Id
    type TyCon       = TyCon.Id
    type StrId       = StrId.Id
    type longVId     = LongVId.longId
    type longTyCon   = LongTyCon.longId
    type longStrId   = LongStrId.longId
    type IdStatus    = IdStatus.IdStatus

    type 'a VIdMap   = 'a VIdMap.map
    type 'a TyConMap = 'a TyConMap.map
    type 'a StrIdMap = 'a StrIdMap.map


    (* Export types [Section 4.2 and 6.3] *)

    datatype ('a,'b) Str' = Str of (*Env*)
                            ('a,'b) Str' StrIdMap * 'b TyConMap * 'a VIdMap

    type 'a ValEnv'       = 'a VIdMap
    type 'b TyEnv'        = 'b TyConMap
    type ('a,'b) StrEnv'  = ('a,'b) Str' StrIdMap

    type ('a,'b) Env'     = ('a,'b) StrEnv' * 'b TyEnv' * 'a ValEnv'


    (* Operations *)

    val empty:          ('a,'b) Env'

    val fromSE:         ('a,'b) StrEnv'         -> ('a,'b) Env'
    val fromTE:         'b TyEnv'               -> ('a,'b) Env'
    val fromVE:         'a ValEnv'              -> ('a,'b) Env'
    val fromVEandTE:    'a ValEnv' * 'b TyEnv'  -> ('a,'b) Env'

    val plus:           ('a,'b) Env' * ('a,'b) Env'    -> ('a,'b) Env'
    val plusVE:         ('a,'b) Env' * 'a ValEnv'      -> ('a,'b) Env'
    val plusTE:         ('a,'b) Env' * 'b TyEnv'       -> ('a,'b) Env'
    val plusSE:         ('a,'b) Env' * ('a,'b) StrEnv' -> ('a,'b) Env'
    val plusVEandTE:    ('a,'b) Env' * ('a ValEnv' * 'b TyEnv') -> ('a,'b) Env'

    val findVId:        ('a,'b) Env' * VId       -> 'a option
    val findTyCon:      ('a,'b) Env' * TyCon     -> 'b option
    val findStrId:      ('a,'b) Env' * StrId     -> ('a,'b) Str' option
    val findLongVId:    ('a,'b) Env' * longVId   -> 'a option
    val findLongTyCon:  ('a,'b) Env' * longTyCon -> 'b option
    val findLongStrId:  ('a,'b) Env' * longStrId -> ('a,'b) Str' option

    val disjoint:       ('a,'b) Env' * ('a,'b) Env' -> bool

  end
(* stop of GENERIC_ENV.sml *)
(* start of GenericEnvFn.sml *)
(*
 * Standard ML generic core environment
 *
 * Definition, sections 4.2, 4.3, 6.3 and 7.2
 *
 * Notes:
 *   - A datatype Str is necessary to break the recursion
 *     between Env and StrEnv.
 *   - Also, all types are parameterised over the range of value and type
 *     environments. This is because of the recursion between values and
 *     the dynamic environment (via function closures) -- we cannot make them
 *     into functor parameters as this would require recursive structures.
 *)

functor GenericEnvFn() :> GENERIC_ENV =
  struct

    (* Import types *)

    type VId         = VId.Id
    type TyCon       = TyCon.Id
    type StrId       = StrId.Id
    type longVId     = LongVId.longId
    type longTyCon   = LongTyCon.longId
    type longStrId   = LongStrId.longId
    type IdStatus    = IdStatus.IdStatus

    type 'a VIdMap   = 'a VIdMap.map
    type 'a TyConMap = 'a TyConMap.map
    type 'a StrIdMap = 'a StrIdMap.map


    (* Export types [Section 4.2 and 6.3] *)

    datatype ('a,'b) Str' = Str of (*Env*)
                           ('a,'b) Str' StrIdMap * 'b TyConMap * 'a VIdMap

    type 'a ValEnv'       = 'a VIdMap                           (* [VE] *)
    type 'b TyEnv'        = 'b TyConMap                         (* [TE] *)
    type ('a,'b) StrEnv'  = ('a,'b) Str' StrIdMap               (* [SE] *)

    type ('a,'b) Env'     = ('a,'b) StrEnv' * 'b TyEnv' * 'a ValEnv' (* [E] *)


    (* Injections [Section 4.3] *)

    val empty              = ( StrIdMap.empty, TyConMap.empty, VIdMap.empty )

    fun fromSE SE          = ( SE,             TyConMap.empty, VIdMap.empty )
    fun fromTE TE          = ( StrIdMap.empty, TE,             VIdMap.empty )
    fun fromVE VE          = ( StrIdMap.empty, TyConMap.empty, VE           )
    fun fromVEandTE(VE,TE) = ( StrIdMap.empty, TE,             VE           )


    (* Modifications [Section 4.3] *)

    infix plus plusVE plusTE plusSE plusVEandTE

    fun (SE,TE,VE) plus (SE',TE',VE') =
        ( StrIdMap.unionWith #2 (SE,SE')
        , TyConMap.unionWith #2 (TE,TE')
        , VIdMap.unionWith   #2 (VE,VE')
        )

    fun (SE,TE,VE) plusVE VE' = ( SE, TE, VIdMap.unionWith #2 (VE,VE') )
    fun (SE,TE,VE) plusTE TE' = ( SE, TyConMap.unionWith #2 (TE,TE'), VE )
    fun (SE,TE,VE) plusSE SE' = ( StrIdMap.unionWith #2 (SE,SE'), TE, VE )
    fun (SE,TE,VE) plusVEandTE (VE',TE') =
        ( SE
        , TyConMap.unionWith #2 (TE,TE')
        , VIdMap.unionWith   #2 (VE,VE')
        )


    (* Application (lookup) [Section 4.3] *)

    fun findVId  ((SE,TE,VE), vid)   = VIdMap.find(VE, vid)
    fun findTyCon((SE,TE,VE), tycon) = TyConMap.find(TE, tycon)
    fun findStrId((SE,TE,VE), strid) = StrIdMap.find(SE, strid)

    fun findLongX'(E, findX,      [],       x) = findX(E, x)
      | findLongX'(E, findX, strid::strids, x) =
            Option.mapPartial (fn E => findLongX'(E, findX, strids, x))
                              (Option.map (fn Str E => E) (findStrId(E, strid)))

    fun findLongX (explodeLongX, findX) (E, longX) =
        let
            val (strids,x) = explodeLongX longX
        in
            findLongX'(E, findX, strids, x)
        end

    fun findLongVId   x = findLongX (LongVId.explode,   findVId) x
    fun findLongTyCon x = findLongX (LongTyCon.explode, findTyCon) x
    fun findLongStrId x = findLongX (LongStrId.explode, findStrId) x


    (* Disjointness *)

    fun disjoint((SE1,TE1,VE1), (SE2,TE2,VE2)) =
            StrIdMap.disjoint(SE1,SE2) andalso
            TyConMap.disjoint(TE1,TE2) andalso
            VIdMap.disjoint(VE1,VE2)

  end
(* stop of GenericEnvFn.sml *)
(* start of STATIC_ENV.sml *)
(*
 * Standard ML environments of the static semantics of the core
 *
 * Definition, sections 4.2, 4.3, 4.8, 4.9, and 5.5
 *
 * Note:
 *     We call the domain type of value environments ValStr.
 *)

signature STATIC_ENV =
  sig

    (* Inheritance *)

    include GENERIC_ENV


    (* Import types *)

    type TypeScheme   = TypeScheme.TypeScheme
    type TypeFcn      = TypeFcn.TypeFcn
    type TyVar        = TyVar.TyVar
    type TyVarSet     = TyVarSet.set
    type TyName       = TyName.TyName
    type TyNameSet    = TyNameSet.set
    type Realisation  = Type.Realisation


    (* Export types [Section 4.2] *)

    type ValStr = TypeScheme * IdStatus
    type ValEnv = ValStr VIdMap                                 (* [VE] *)

    type TyStr  = TypeFcn * ValEnv
    type TyEnv  = TyStr TyConMap                                (* [TE] *)

    type Str    = (ValStr, TyStr) Str'
    type StrEnv = Str StrIdMap                                  (* [SE] *)
 
    type Env    = StrEnv * TyEnv * ValEnv                       (* [E] *)


    (* Operations *)

    val tyvarsVE:               ValEnv -> TyVarSet
    val tyvars:                 Env    -> TyVarSet
    val tynamesTE:              TyEnv  -> TyNameSet
    val tynamesSE:              StrEnv -> TyNameSet
    val tynames:                Env    -> TyNameSet

    val isWellFormed:           Env -> bool

    val Clos:                   ValEnv -> ValEnv
    val containsFlexibleType:   ValEnv -> bool
    val defaultOverloaded:      ValEnv -> unit
    val makeEquality:           TyEnv  -> unit
    val maximiseEquality:       TyEnv * ValEnv -> TyEnv * ValEnv
    val Abs:                    TyEnv * Env -> Env
    val realise:                Realisation -> Env -> Env

    val enriches:               Env * Env -> bool

  end
(* stop of STATIC_ENV.sml *)
(* start of StaticEnv.sml *)
(*
 * Standard ML environments of the static semantics of the core
 *
 * Definition, sections 4.2, 4.3, 4.8, 4.9, and 5.5
 *
 * Note:
 *     We call the domain type of value environments ValStr.
 *)

structure StaticEnv :> STATIC_ENV =
  struct

    (* Inheritance *)

    structure GenericEnv = GenericEnvFn()

    open GenericEnv


    (* Import types *)

    type TypeScheme   = TypeScheme.TypeScheme
    type TypeFcn      = TypeFcn.TypeFcn
    type TyVar        = TyVar.TyVar
    type TyVarSet     = TyVarSet.set
    type TyName       = TyName.TyName
    type TyNameSet    = TyNameSet.set
    type Realisation  = Type.Realisation


    (* Export types [Section 4.2] *)

    type ValStr = TypeScheme * IdStatus
    type ValEnv = ValStr VIdMap                                 (* [VE] *)

    type TyStr  = TypeFcn * ValEnv
    type TyEnv  = TyStr TyConMap                                (* [TE] *)

    type Str    = (ValStr, TyStr) Str'
    type StrEnv = Str StrIdMap                                  (* [SE] *)
 
    type Env    = StrEnv * TyEnv * ValEnv                       (* [E] *)


    (* Further modifications [Section 4.3] *)

    infix TEplus

    fun TE' TEplus (SE,TE,VE) = ( SE, TyConMap.unionWith #2 (TE',TE), VE )


    (* Type variable and type name set [Section 4.2] *)

    fun tyvarsVE VE =
        VIdMap.foldl
            (fn((sigma,is), U) => TyVarSet.union(U, TypeScheme.tyvars sigma))
            TyVarSet.empty VE

    fun tyvarsTE TE =
        TyConMap.foldl
            (fn((theta,VE), U) => TyVarSet.union(TyVarSet.union
                                (U, TypeFcn.tyvars theta), tyvarsVE VE))
            TyVarSet.empty TE

    fun tyvarsSE SE =
        StrIdMap.foldl
            (fn(Str E, U) => TyVarSet.union(U, tyvars E))
            TyVarSet.empty SE

    and tyvars (SE,TE,VE) =
        TyVarSet.union(TyVarSet.union(tyvarsSE SE, tyvarsTE TE), tyvarsVE VE)


    fun tynamesVE VE =
        VIdMap.foldl
            (fn((sigma,is), T) => TyNameSet.union(T, TypeScheme.tynames sigma))
            TyNameSet.empty VE

    fun tynamesTE TE =
        TyConMap.foldl
            (fn((theta,VE), T) => TyNameSet.union(TyNameSet.union
                                (T, TypeFcn.tynames theta), tynamesVE VE))
            TyNameSet.empty TE

    fun tynamesSE SE =
        StrIdMap.foldl
            (fn(Str E, T) => TyNameSet.union(T, tynames E))
            TyNameSet.empty SE

    and tynames (SE,TE,VE) =
        TyNameSet.union(TyNameSet.union(tynamesSE SE, tynamesTE TE),
                                        tynamesVE VE)


    (* Well-formedness [Section 4.9] *)

    fun isWellFormedTyStr (theta,VE) =
        VIdMap.isEmpty VE orelse isSome(TypeFcn.toTyName theta)

    fun isWellFormedTE TE =
        TyConMap.all isWellFormedTyStr TE

    fun isWellFormedSE SE =
        StrIdMap.all (fn Str E => isWellFormed E) SE

    and isWellFormed (SE,TE,VE) =
        isWellFormedTE TE andalso isWellFormedSE SE



    (* Closure [Section 4.8] *)

    fun Clos VE =
            VIdMap.map (fn((_,tau), is) => (TypeScheme.Clos tau, is)) VE


    (* Check for unresolved flexible record types [Section 4.11, item 1] *)

    fun containsFlexibleType VE =
            VIdMap.exists (fn((_,tau), is) => Type.isFlexible tau) VE


    (* Assign default types to overloaded types [Appendix E] *)

    fun defaultOverloaded VE =
            VIdMap.app (fn((_,tau), is) => Type.defaultOverloaded tau) VE


    (* Realisation [Section 5.2] *)

    fun realiseVE phi VE =
        VIdMap.map (fn(sigma,is) => ( TypeScheme.realise phi sigma, is )) VE

    and realiseTE phi TE =
        TyConMap.map (fn(theta,VE) => ( TypeFcn.realise phi theta
                                      , realiseVE phi VE
                                      )) TE
    and realiseSE phi SE =
        StrIdMap.map (fn(Str E) => Str(realise phi E)) SE

    and realise phi (SE,TE,VE) =
        ( realiseSE phi SE
        , realiseTE phi TE
        , realiseVE phi VE
        )


    (* Make all type names bound in a type environment equality types *)

    (* Assumes abstract types, i.e. no constructors. *)

    fun makeEquality TE =
        TyConMap.app (fn(theta,VE) => TypeFcn.makeEquality theta) TE



    (* Maximise equality of a type environment [Section 4.9],
     * together with its appendant value envrionment
     *)

    fun admitsEqualityValStr ((_,tau),_) = Type.admitsEquality tau

    fun maximiseEquality(TE,VE) =
        let
            fun checkTyStr((theta,VE), (phi,changed)) = 
                let
                    val t = valOf(TypeFcn.toTyName theta)
                in
                    if TyName.equality t = TyName.EQ
                    andalso not(VIdMap.all admitsEqualityValStr VE) then
                        ( TyNameMap.insert(phi,
                                           t,
                                           TypeFcn.fromTyName
                                                (TyName.removeEquality t)
                                          )
                        , true
                        )
                    else
                        ( phi, changed )
                end

            fun checkTE(TE, phi) =
                let
                    val (phi',change) = TyConMap.foldl checkTyStr (phi,false) TE
                    val TE'           = realiseTE phi' TE
                in
                    if change then checkTE(TE', phi')
                              else (TE', phi')
                end

            val (TE',phi) = checkTE(TE, TyNameMap.empty)
        in
            ( TE', realiseVE phi VE )
        end



    (* Abstraction of a type environment [Section 4.9] *)

    fun AbsTE(TE) = TyConMap.map (fn(theta,_) => (theta,VIdMap.empty)) TE

    fun Abs(TE,E) =
        let
            val ts  = tynamesTE TE
            val phi = TyNameSet.foldl
                        (fn(t,phi) => TyNameMap.insert(phi, t,
                                        TypeFcn.fromTyName(TyName.Abs t)))
                        TyNameMap.empty ts
        in
            realise phi (AbsTE(TE) TEplus E)
        end


    (* Disjointness *)

    fun disjoint((SE1,TE1,VE1), (SE2,TE2,VE2)) =
            StrIdMap.disjoint(SE1,SE2) andalso
            TyConMap.disjoint(TE1,TE2) andalso
            VIdMap.disjoint(VE1,VE2)


    (* Enrichment [Section 5.5] *)

    fun equalsVE(VE1,VE2) =
        VIdMap.numItems VE1 = VIdMap.numItems VE2 andalso
        VIdMap.alli
            (fn(vid, (sigma1,is1)) =>
                case VIdMap.find(VE2, vid)
                  of NONE             => false
                   | SOME(sigma2,is2) =>
                        TypeScheme.equals(sigma1,sigma2) andalso is1 = is2
            )
            VE1


    fun enriches((SE1,TE1,VE1), (SE2,TE2,VE2)) =
            enrichesSE(SE1,SE2) andalso
            enrichesTE(TE1,TE2) andalso
            enrichesVE(VE1,VE2)

    and enrichesSE(SE1,SE2) =
        StrIdMap.alli
            (fn(strid, Str E2) =>
                case StrIdMap.find(SE1, strid)
                  of NONE         => false
                   | SOME(Str E1) => enriches(E1,E2)
            )
            SE2

    and enrichesTE(TE1,TE2) =
        TyConMap.alli
            (fn(tycon, tystr2) =>
                case TyConMap.find(TE1, tycon)
                  of NONE        => false
                   | SOME tystr1 => enrichesTyStr(tystr1,tystr2)
            )
            TE2

    and enrichesVE(VE1,VE2) =
        VIdMap.alli
            (fn(vid, valstr2) =>
                case VIdMap.find(VE1, vid)
                  of NONE         => false
                   | SOME valstr1 => enrichesValStr(valstr1,valstr2)
            )
            VE2

    and enrichesTyStr((theta1,VE1), (theta2,VE2)) =
            TypeFcn.equals(theta1,theta2) andalso
            ( VIdMap.isEmpty VE2 orelse equalsVE(VE1,VE2) )

    and enrichesValStr((sigma1,is1), (sigma2,is2)) =
            TypeScheme.generalises(sigma1,sigma2) andalso
            IdStatus.generalises(is1,is2)

  end
(* stop of StaticEnv.sml *)
(* start of SIG.sml *)
(*
 * Standard ML signatures
 *
 * Definition, sections 5.1, 5.3, and 5.6
 *)


signature SIG =
  sig

    (* Import types *)

    type Env         = StaticEnv.Env
    type TyVarSet    = TyVarSet.set
    type TyNameSet   = TyNameSet.set
    type Realisation = Type.Realisation


    (* Type [Section 5.1] *)

    type Sig = TyNameSet * Env                          (* [Sigma] *)


    (* Operations *)

    val tyvars:         Sig -> TyVarSet
    val tynames:        Sig -> TyNameSet

    val rename:         Sig -> Sig

    exception Match
    val match:          Env * Sig -> Env * Realisation (* Matching *)

  end
(* stop of SIG.sml *)
(* start of Sig.sml *)
(*
 * Standard ML signatures
 *
 * Definition, sections 5.1, 5.3, and 5.6
 *)


structure Sig :> SIG =
  struct

    (* Import types *)

    type Env         = StaticEnv.Env
    type TyVarSet    = TyVarSet.set
    type TyNameSet   = TyNameSet.set
    type Realisation = Type.Realisation


    (* Type [Section 5.1] *)

    type Sig = TyNameSet * Env                          (* [Sigma] *)


    (* Type variable and type name extraction [Section 4.2] *)

    fun tyvars  (T,E) = StaticEnv.tyvars E
    fun tynames (T,E) = TyNameSet.difference(StaticEnv.tynames E, T)


    (* Alpha Renaming *)

    fun rename (T,E) =
        let
            val phi' = TyNameSet.foldl
                         (fn(t,phi')=> TyNameMap.insert(phi',t,TyName.rename t))
                         TyNameMap.empty T
            val phi = TyNameMap.map TypeFcn.fromTyName phi'
            val T'  = TyNameSet.map (fn t => valOf(TyNameMap.find(phi',t))) T
            val E'  = StaticEnv.realise phi E
        in
            (T',E')
        end


    (* Matching [Section 5.6] *)

    exception Match

    fun matchTypeFcn(theta', theta, phi, T) =
        if TypeFcn.arity theta <> TypeFcn.arity theta' then
            raise Match
        else
        case TypeFcn.toTyName theta
          of NONE   => phi
           | SOME t =>
                if isSome(TyNameMap.find(phi, t))
                orelse not(TyNameSet.member(T, t)) then
                    phi
                else
                let
                    val phi' = TyNameMap.insert(phi, t, TypeFcn.rename theta')
                in
                    TyNameMap.map (TypeFcn.realise phi') phi'
                end

    fun matchTE(TE', TE, phi, T) =
        let
            fun matchTyStr(tycon, (theta,VE), phi) =
                case TyConMap.find(TE', tycon)
                  of NONE             => raise Match
                   | SOME(theta',VE') => matchTypeFcn(theta', theta, phi, T)
        in
            TyConMap.foldli matchTyStr phi TE
        end

    fun matchSE(SE', SE, phi, T) =
        let
            fun matchStr(strid, StaticEnv.Str E, phi) =
                case StrIdMap.find(SE', strid)
                  of NONE                   => raise Match
                   | SOME(StaticEnv.Str E') => matchE(E', E, phi, T)
        in
            StrIdMap.foldli matchStr phi SE
        end

    and matchE((SE',TE',VE'), (SE,TE,VE), phi, T) =
        let
            val phi1 = matchTE(TE', TE, phi, T)
            val phi2 = matchSE(SE', SE, phi1, T)
        in
            phi2
        end

    fun match(E', (T,E)) =
        let
            val phi = matchE(E', E, TyNameMap.empty, T)
            val E'' = StaticEnv.realise phi E
        in
            if StaticEnv.enriches(E',E'') then
                (E'', phi)
            else
                raise Match
        end

  end
(* stop of Sig.sml *)
(* start of FUNSIG.sml *)
(*
 * Standard ML functor signatures
 *
 * Definition, sections 5.1 and 5.4
 *)


signature FUNSIG =
  sig

    (* Import types *)

    type Env       = StaticEnv.Env
    type Sig       = Sig.Sig
    type TyVarSet  = TyVarSet.set
    type TyNameSet = TyNameSet.set


    (* Type [Section 5.1] *)

    type FunSig = TyNameSet * (Env * Sig)               (* [Phi] *)


    (* Operations *)

    val tyvars:         FunSig -> TyVarSet
    val tynames:        FunSig -> TyNameSet

  end
(* stop of FUNSIG.sml *)
(* start of FunSig.sml *)
(*
 * Standard ML functor signatures
 *
 * Definition, sections 5.1 and 5.4
 *)


structure FunSig :> FUNSIG =
  struct

    (* Import types *)

    type Env       = StaticEnv.Env
    type Sig       = Sig.Sig
    type TyVarSet  = TyVarSet.set
    type TyNameSet = TyNameSet.set


    (* Type [Section 5.1] *)

    type FunSig = TyNameSet * (Env * Sig)               (* [Phi] *)


    (* Type variable and type name extraction [Section 4.2] *)

    fun tyvars (T,(E,Sigma)) =
        TyVarSet.union(StaticEnv.tyvars E, Sig.tyvars Sigma)

    fun tynames (T,(E,Sigma)) =
        TyNameSet.difference(TyNameSet.union(StaticEnv.tynames E,
                                             Sig.tynames Sigma), T)

  end
(* stop of FunSig.sml *)
(* start of CONTEXT.sml *)
(*
 * Standard ML contexts
 *
 * Definition, sections 4.2, 4.3, 4.7, and 4.9
 *)

signature CONTEXT =
  sig

    (* Import types *)

    type VId        = VId.Id
    type TyCon      = TyCon.Id
    type StrId      = StrId.Id
    type longVId    = LongVId.longId
    type longTyCon  = LongTyCon.longId
    type longStrId  = LongStrId.longId
    type TyName     = TyName.TyName
    type TyNameSet  = TyNameSet.set
    type TyVar      = TyVar.TyVar
    type TyVarSet   = TyVarSet.set
    type IdStatus   = IdStatus.IdStatus
    type TypeScheme = TypeScheme.TypeScheme
    type StrEnv     = StaticEnv.StrEnv
    type Str        = StaticEnv.Str
    type TyStr      = StaticEnv.TyStr
    type TyEnv      = StaticEnv.TyEnv
    type ValStr     = StaticEnv.ValStr
    type ValEnv     = StaticEnv.ValEnv
    type Env        = StaticEnv.Env


    (* Type [Section 4.2] *)

    type Context = TyNameSet * TyVarSet * Env           (* [C] *)


    (* Operations *)

    val Tof:            Context -> TyNameSet
    val Uof:            Context -> TyVarSet
    val Eof:            Context -> Env

    val plusVE:         Context * ValEnv   -> Context
    val plusU:          Context * TyVarSet -> Context
    val oplusE:         Context * Env      -> Context
    val oplusTE:        Context * TyEnv    -> Context
    val oplusVEandTE:   Context * (ValEnv * TyEnv) -> Context

    val findVId:        Context * VId       -> ValStr option
    val findTyCon:      Context * TyCon     -> TyStr option
    val findStrId:      Context * StrId     -> Str option
    val findLongVId:    Context * longVId   -> ValStr option
    val findLongTyCon:  Context * longTyCon -> TyStr option
    val findLongStrId:  Context * longStrId -> Str option

    val tyvars:         Context -> TyVarSet

  end
(* stop of CONTEXT.sml *)
(* start of Context.sml *)
(*
 * Standard ML contexts
 *
 * Definition, sections 4.2, 4.3, 4.7, and 4.9
 *)

structure Context :> CONTEXT =
  struct

    (* Import types *)

    type VId        = VId.Id
    type TyCon      = TyCon.Id
    type StrId      = StrId.Id
    type longVId    = LongVId.longId
    type longTyCon  = LongTyCon.longId
    type longStrId  = LongStrId.longId
    type TyName     = TyName.TyName
    type TyNameSet  = TyNameSet.set
    type TyVar      = TyVar.TyVar
    type TyVarSet   = TyVarSet.set
    type IdStatus   = IdStatus.IdStatus
    type TypeScheme = TypeScheme.TypeScheme
    type StrEnv     = StaticEnv.StrEnv
    type Str        = StaticEnv.Str
    type TyStr      = StaticEnv.TyStr
    type TyEnv      = StaticEnv.TyEnv
    type ValStr     = StaticEnv.ValStr
    type ValEnv     = StaticEnv.ValEnv
    type Env        = StaticEnv.Env


    (* Type [Section 4.2] *)

    type Context = TyNameSet * TyVarSet * Env           (* [C] *)


    (* Projections [Section 4.3] *)

    fun Tof (T,U,E) = T
    fun Uof (T,U,E) = U
    fun Eof (T,U,E) = E


    (* Modification [Section 4.3] *)

    infix plusVE plusU oplusE oplusTE oplusVEandTE

    fun (T,U,E) plusVE VE = ( T, U, StaticEnv.plusVE(E,VE) )
    fun (T,U,E) plusU  U' = ( T, TyVarSet.union(U,U'), E )

    fun (T,U,E) oplusE E' =
        ( TyNameSet.union(T, StaticEnv.tynames E)
        , U
        , StaticEnv.plus(E,E')
        )

    fun (T,U,E) oplusTE TE =
        ( TyNameSet.union(T, StaticEnv.tynamesTE TE)
        , U
        , StaticEnv.plusTE(E,TE)
        )

    fun (T,U,E) oplusVEandTE (VE,TE) =
        ( TyNameSet.union(T, StaticEnv.tynamesTE TE)
        , U
        , StaticEnv.plusVEandTE(E, (VE,TE))
        )


    (* Application (lookup) [Section 4.3] *)

    fun findVId  ((T,U,E), vid)   = StaticEnv.findVId(E, vid)
    fun findTyCon((T,U,E), tycon) = StaticEnv.findTyCon(E, tycon)
    fun findStrId((T,U,E), strid) = StaticEnv.findStrId(E, strid)

    fun findLongVId  ((T,U,E), longvid)   = StaticEnv.findLongVId(E,longvid)
    fun findLongTyCon((T,U,E), longtycon) = StaticEnv.findLongTyCon(E,longtycon)
    fun findLongStrId((T,U,E), longstrid) = StaticEnv.findLongStrId(E,longstrid)


    (* Calculation of tyvars [Section 4.2] *)

    fun tyvars (T,U,E) = TyVarSet.union(U, StaticEnv.tyvars E)

  end
(* stop of Context.sml *)
(* start of STATIC_BASIS.sml *)
(*
 * Standard ML static basis and environments of modules
 *
 * Definition, section 5.1
 *)

signature STATIC_BASIS =
  sig

    (* Import types *)

    type StrId       = StrId.Id
    type SigId       = SigId.Id
    type FunId       = FunId.Id
    type longStrId   = LongStrId.longId
    type longTyCon   = LongTyCon.longId
    type Env         = StaticEnv.Env
    type StrEnv      = StaticEnv.StrEnv
    type Str         = StaticEnv.Str
    type TyStr       = StaticEnv.TyStr
    type Context     = Context.Context
    type Sig         = Sig.Sig
    type FunSig      = FunSig.FunSig
    type TyVarSet    = TyVarSet.set
    type TyNameSet   = TyNameSet.set
    type 'a SigIdMap = 'a SigIdMap.map
    type 'a FunIdMap = 'a FunIdMap.map


    (* Types [Section 5.1] *)

    type SigEnv = Sig SigIdMap                                  (* [G] *)
    type FunEnv = FunSig FunIdMap                               (* [F] *)

    type Basis  = TyNameSet * FunEnv * SigEnv * Env             (* [B] *)


    (* Operations *)

    val empty:          Basis
    val fromTandE:      TyNameSet * Env    -> Basis
    val fromTandF:      TyNameSet * FunEnv -> Basis
    val fromTandG:      TyNameSet * SigEnv -> Basis

    val Tof:            Basis -> TyNameSet
    val Cof:            Basis -> Context

    val plus:           Basis * Basis     -> Basis
    val plusT:          Basis * TyNameSet -> Basis
    val oplusSE:        Basis * StrEnv    -> Basis
    val oplusG:         Basis * SigEnv    -> Basis
    val oplusF:         Basis * FunEnv    -> Basis
    val oplusE:         Basis * Env       -> Basis

    val findStrId:      Basis * StrId     -> Str option
    val findSigId:      Basis * SigId     -> Sig option
    val findFunId:      Basis * FunId     -> FunSig option
    val findLongStrId:  Basis * longStrId -> Str option
    val findLongTyCon:  Basis * longTyCon -> TyStr option

    val tyvars:         Basis  -> TyVarSet
    val tynamesF:       FunEnv -> TyNameSet
    val tynamesG:       SigEnv -> TyNameSet
 
  end
(* stop of STATIC_BASIS.sml *)
(* start of StaticBasis.sml *)
(*
 * Standard ML static basis and environments of modules
 *
 * Definition, section 5.1
 *)

structure StaticBasis :> STATIC_BASIS =
  struct

    (* Import types *)

    type StrId       = StrId.Id
    type SigId       = SigId.Id
    type FunId       = FunId.Id
    type longStrId   = LongStrId.longId
    type longTyCon   = LongTyCon.longId
    type Env         = StaticEnv.Env
    type StrEnv      = StaticEnv.StrEnv
    type Str         = StaticEnv.Str
    type TyStr       = StaticEnv.TyStr
    type Context     = Context.Context
    type Sig         = Sig.Sig
    type FunSig      = FunSig.FunSig
    type TyVarSet    = TyVarSet.set
    type TyNameSet   = TyNameSet.set
    type 'a SigIdMap = 'a SigIdMap.map
    type 'a FunIdMap = 'a FunIdMap.map


    (* Types [Section 5.1] *)

    type SigEnv = Sig SigIdMap                                  (* [G] *)
    type FunEnv = FunSig FunIdMap                               (* [F] *)

    type Basis  = TyNameSet * FunEnv * SigEnv * Env             (* [B] *)



    (* Calculation of type variable and type name sets [Section 4.2] *)

    fun tyvarsG G =
        SigIdMap.foldl
            (fn(Sigma, U) => TyVarSet.union(U, Sig.tyvars Sigma))
            TyVarSet.empty G

    fun tyvarsF F =
        FunIdMap.foldl
            (fn(Phi, U) => TyVarSet.union(U, FunSig.tyvars Phi))
            TyVarSet.empty F

    fun tyvars (T,F,G,E) = TyVarSet.union(TyVarSet.union(
                                tyvarsF F, tyvarsG G), StaticEnv.tyvars E)
    


    fun tynamesG G =
        SigIdMap.foldl
            (fn(Sigma, T) => TyNameSet.union(T, Sig.tynames Sigma))
            TyNameSet.empty G

    fun tynamesF F =
        FunIdMap.foldl
            (fn(Phi, T) => TyNameSet.union(T, FunSig.tynames Phi))
            TyNameSet.empty F



    (* Injection [Sections 4.3 and 5.1] *)

    val empty =
        ( TyNameSet.empty, FunIdMap.empty, SigIdMap.empty, StaticEnv.empty )

    fun fromTandE(T,E) = ( T, FunIdMap.empty, SigIdMap.empty, E )
    fun fromTandF(T,F) = ( T, F, SigIdMap.empty, StaticEnv.empty )
    fun fromTandG(T,G) = ( T, FunIdMap.empty, G, StaticEnv.empty )


    (* Projections [Sections 4.3 and 5.1] *)

    fun Tof (T,F,G,E) = T
    fun Cof (T,F,G,E) = (T, TyVarSet.empty, E)


    (* Modifications [Sections 4.3 and 5.1] *)

    infix plus plusT oplusG oplusF oplusE oplusSE

    fun (T,F,G,E) plus (T',F',G',E') =
        ( TyNameSet.union(T,T')
        , FunIdMap.unionWith #2 (F,F')
        , SigIdMap.unionWith #2 (G,G')
        , StaticEnv.plus(E,E')
        )

    fun (T,F,G,E) plusT T' = ( TyNameSet.union(T,T'), F, G, E )

    fun (T,F,G,E) oplusG G' =
        ( TyNameSet.union(T, tynamesG G')
        , F
        , SigIdMap.unionWith #2 (G,G')
        , E
        )

    fun (T,F,G,E) oplusF F' =
        ( TyNameSet.union(T, tynamesF F')
        , FunIdMap.unionWith #2 (F,F')
        , G
        , E
        )

    fun (T,F,G,E) oplusE E' =
        ( TyNameSet.union(T, StaticEnv.tynames E')
        , F
        , G
        , StaticEnv.plus(E,E')
        )

    fun (T,F,G,E) oplusSE SE =
        ( TyNameSet.union(T, StaticEnv.tynamesSE SE)
        , F
        , G
        , StaticEnv.plusSE(E,SE)
        )

    (* Application (lookup) [Sections 5.1 and 4.3] *)

    fun findStrId((T,F,G,E), strid) = StaticEnv.findStrId(E, strid)
    fun findSigId((T,F,G,E), sigid) = SigIdMap.find(G, sigid)
    fun findFunId((T,F,G,E), funid) = FunIdMap.find(F, funid)
    fun findLongStrId((T,F,G,E), longstrid) =
        StaticEnv.findLongStrId(E, longstrid)
    fun findLongTyCon((T,F,G,E), longtycon) =
        StaticEnv.findLongTyCon(E, longtycon)

  end
(* stop of StaticBasis.sml *)
(* start of INITIAL_STATIC_ENV.sml *)
(*
 * Standard ML core view of the initial static basis
 *
 * Definition, appendices C and E
 *)

signature INITIAL_STATIC_ENV =
  sig

    (* Import types *)

    type Type             = Type.Type
    type TyNameSet        = TyNameSet.set
    type OverloadingClass = OverloadingClass.OverloadingClass
    type Env              = StaticEnv.Env


    (* Predefined monomorphic types [Figure 24] *)

    val tauBool:        Type
    val tauInt:         Type
    val tauWord:        Type
    val tauReal:        Type
    val tauString:      Type
    val tauChar:        Type
    val tauExn:         Type

    (* Overloading classes [Appendix E.1] *)

    val Int:            OverloadingClass
    val Real:           OverloadingClass
    val Word:           OverloadingClass
    val String:         OverloadingClass
    val Char:           OverloadingClass
    val WordInt:        OverloadingClass
    val RealInt:        OverloadingClass
    val Num:            OverloadingClass
    val NumTxt:         OverloadingClass

    (* Initial environment [Appendix C] *)

    val T0:             TyNameSet
    val E0:             Env

  end
(* stop of INITIAL_STATIC_ENV.sml *)
(* start of InitialStaticEnv.sml *)
(*
 * Standard ML core view of the initial static basis
 *
 * Definition, appendices C and E
 *)

structure InitialStaticEnv :> INITIAL_STATIC_ENV =
  struct

    (* Import *)

    type Type             = Type.Type
    type TyNameSet        = TyNameSet.set
    type Overloadingclass = OverloadingClass.OverloadingClass
    type VIdSet           = VIdSet.set
    type Env              = StaticEnv.Env
    type ValEnv           = StaticEnv.ValEnv


    open Type
    open IdStatus


    (* Helpers *)

    fun pairType(tau1,tau2) =
        let
            val Rho = LabMap.insert(LabMap.insert(LabMap.empty,
                                                  Lab.fromInt 1, tau1),
                                                  Lab.fromInt 2, tau2)
        in
            fromRowType (Rho,CLOSEDRow)
        end


    (* VIds [Figure 25] *)

    val vidEq     = VId.fromString "="
    val vidAssign = VId.fromString ":="

    val vidFalse  = VId.fromString "false"
    val vidTrue   = VId.fromString "true"
    val vidNil    = VId.fromString "nil"
    val vidCons   = VId.fromString "::"
    val vidRef    = VId.fromString "ref"

    val vidMatch  = VId.fromString "Match"
    val vidBind   = VId.fromString "Bind"


    (* TyCons [Figure 24] *)

    val tyconUnit   = TyCon.fromString "unit"
    val tyconBool   = TyCon.fromString "bool"
    val tyconInt    = TyCon.fromString "int"
    val tyconWord   = TyCon.fromString "word"
    val tyconReal   = TyCon.fromString "real"
    val tyconString = TyCon.fromString "string"
    val tyconChar   = TyCon.fromString "char"
    val tyconList   = TyCon.fromString "list"
    val tyconRef    = TyCon.fromString "ref"
    val tyconExn    = TyCon.fromString "exn"


    (* TyNames [Appendix C] *)

    val tBool   = TyName.tyname(tyconBool,   0, TyName.EQ, 2)
    val tInt    = TyName.tyname(tyconInt,    0, TyName.EQ, 0)
    val tWord   = TyName.tyname(tyconWord,   0, TyName.EQ, 0)
    val tReal   = TyName.tyname(tyconReal,   0, TyName.NOEQ, 0)
    val tString = TyName.tyname(tyconString, 0, TyName.EQ, 0)
    val tChar   = TyName.tyname(tyconChar,   0, TyName.EQ, 0)
    val tList   = TyName.tyname(tyconList,   1, TyName.EQ, 2)
    val tRef    = TyName.tyname(tyconRef,    1, TyName.SPECIALEQ, 1)
    val tExn    = TyName.tyname(tyconExn,    0, TyName.NOEQ, 0)

    val T0      = TyNameSet.fromList[tBool, tInt, tWord, tReal, tString, tChar,
                                     tList, tRef, tExn]


    (* Types *)

    val alpha      = TyVar.fromString "'a"
    val alphaEq    = TyVar.fromString "''a"
    val tauAlpha   = fromTyVar alpha
    val tauAlphaEq = fromTyVar alphaEq

    val tauUnit      = fromRowType emptyRho
    val tauBool      = fromConsType([], tBool)
    val tauInt       = fromConsType([], tInt)
    val tauWord      = fromConsType([], tWord)
    val tauReal      = fromConsType([], tReal)
    val tauString    = fromConsType([], tString)
    val tauChar      = fromConsType([], tChar)
    val tauExn       = fromConsType([], tExn)
    val tauAlphaList = fromConsType([tauAlpha], tList)
    val tauAlphaRef  = fromConsType([tauAlpha], tRef)


    (* TypeSchemes [Figure 25] *)

    val sigmaEq     = ([alphaEq], fromFunType(pairType(tauAlphaEq,tauAlphaEq),
                                              tauBool))
    val sigmaAssign = ([alpha],   fromFunType(pairType(tauAlphaRef,tauAlpha),
                                              tauUnit))
    val sigmaFalse  = ([], tauBool)
    val sigmaTrue   = ([], tauBool)
    val sigmaNil    = ([alpha], tauAlphaList)
    val sigmaCons   = ([alpha], fromFunType(pairType(tauAlpha, tauAlphaList),
                                            tauAlphaList))
    val sigmaRef    = ([alpha], fromFunType(tauAlpha, tauAlphaRef))

    val sigmaMatch  = ([], tauExn)
    val sigmaBind   = ([], tauExn)


    (* Value entries [Figure 25] *)

    val valstrEq     = (sigmaEq,     v)
    val valstrAssign = (sigmaAssign, v)

    val valstrFalse  = (sigmaFalse,  c)
    val valstrTrue   = (sigmaTrue,   c)
    val valstrNil    = (sigmaNil,    c)
    val valstrCons   = (sigmaCons,   c)
    val valstrRef    = (sigmaRef,    c)

    val valstrMatch  = (sigmaMatch,  e)
    val valstrBind   = (sigmaBind,   e)


    (* TypeFcns [Figure 24] *)

    val thetaUnit   = ([], tauUnit)
    val thetaBool   = ([], tauBool)
    val thetaInt    = ([], tauInt)
    val thetaWord   = ([], tauWord)
    val thetaReal   = ([], tauReal)
    val thetaString = ([], tauString)
    val thetaChar   = ([], tauChar)
    val thetaExn    = ([], tauExn)
    val thetaList   = ([alpha], tauAlphaList)
    val thetaRef    = ([alpha], tauAlphaRef)


    (* TyStrs [Figure 25] *)

    val VEEmpty = VIdMap.empty
    val VEBool  = VIdMap.fromList[(vidFalse, valstrFalse),
                                  (vidTrue,  valstrTrue)] : ValEnv
    val VEList  = VIdMap.fromList[(vidNil,   valstrNil),
                                  (vidCons,  valstrCons)]
    val VERef   = VIdMap.fromList[(vidRef,   valstrRef)]

    val tystrUnit   = (thetaUnit,   VEEmpty)
    val tystrBool   = (thetaBool,   VEBool )
    val tystrInt    = (thetaInt,    VEEmpty)
    val tystrWord   = (thetaWord,   VEEmpty)
    val tystrReal   = (thetaReal,   VEEmpty)
    val tystrString = (thetaString, VEEmpty)
    val tystrChar   = (thetaChar,   VEEmpty)
    val tystrList   = (thetaList,   VEList )
    val tystrRef    = (thetaRef,    VERef  )
    val tystrExn    = (thetaExn,    VEEmpty)


    (* Environments [Appendix C] *)

    val SE0 = StrIdMap.empty

    val TE0 = TyConMap.fromList[(tyconUnit,   tystrUnit),
                                (tyconBool,   tystrBool),
                                (tyconInt,    tystrInt),
                                (tyconWord,   tystrWord),
                                (tyconReal,   tystrReal),
                                (tyconString, tystrString),
                                (tyconChar,   tystrChar),
                                (tyconList,   tystrList),
                                (tyconRef,    tystrRef),
                                (tyconExn,    tystrExn)]

    val VE0 = VIdMap.fromList  [(vidEq,     valstrEq),
                                (vidAssign, valstrAssign),
                                (vidRef,    valstrRef),
                                (vidNil,    valstrNil),
                                (vidCons,   valstrCons),
                                (vidFalse,  valstrFalse),
                                (vidTrue,   valstrTrue),
                                (vidMatch,  valstrMatch),
                                (vidBind,   valstrBind)]

    val E0 = (SE0,TE0,VE0)


    (* Overloading classes [Section E.1] *)

    val Int     = OverloadingClass.make(TyNameSet.singleton tInt,    tInt)
    val Real    = OverloadingClass.make(TyNameSet.singleton tReal,   tReal)
    val Word    = OverloadingClass.make(TyNameSet.singleton tWord,   tWord)
    val String  = OverloadingClass.make(TyNameSet.singleton tString, tString)
    val Char    = OverloadingClass.make(TyNameSet.singleton tChar,   tChar)
    val WordInt = OverloadingClass.union(Word, Int)     (* default is 2nd *)
    val RealInt = OverloadingClass.union(Real, Int)
    val Num     = OverloadingClass.union(Word, RealInt)
    val Txt     = OverloadingClass.union(String, Char)
    val NumTxt  = OverloadingClass.union(Txt, Num)

  end
(* stop of InitialStaticEnv.sml *)
(* start of INITIAL_STATIC_BASIS.sml *)
(*
 * Standard ML initial static basis
 *
 * Definition, appendices C and E
 *)

signature INITIAL_STATIC_BASIS =
  sig

    (* Import *)

    type Basis = StaticBasis.Basis


    (* Export *)

    val B0: Basis

  end
(* stop of INITIAL_STATIC_BASIS.sml *)
(* start of InitialStaticBasis.sml *)
(*
 * Standard ML initial static basis
 *
 * Definition, appendices C and E
 *)

structure InitialStaticBasis :> INITIAL_STATIC_BASIS =
  struct

    (* Import *)

    type Basis = StaticBasis.Basis


    (* Enviornments *)

    val T0 = InitialStaticEnv.T0
    val F0 = FunIdMap.empty
    val G0 = SigIdMap.empty
    val E0 = InitialStaticEnv.E0

    val B0 = (T0,F0,G0,E0)

  end
(* stop of InitialStaticBasis.sml *)
(* start of EXNAME.sml *)
(*
 * Standard ML exception names
 *
 * Definition, section 6.2
 *)

signature EXNAME =
  sig

    (* Import *)

    type VId = VId.Id


    (* Type [Section 6.2] *)

    eqtype ExName                                       (* [en] *)


    (* Operations *)

    val exname:   VId -> ExName
    val toString: ExName -> string

    val compare:  ExName * ExName -> order

  end
(* stop of EXNAME.sml *)
(* start of ExName.sml *)
(*
 * Standard ML exception names
 *
 * Definition, section 6.2
 *)


structure ExName :> EXNAME =
  struct

    (* Import *)

    type VId   = VId.Id
    type stamp = Stamp.stamp


    (* Type [Section 6.2] *)

    type ExName =                                     (* [en] *)
         { vid:   VId
         , stamp: stamp
         }


    (* Creation *)

    fun exname vid = { vid = vid, stamp = Stamp.stamp() }


    (* Conversion *)

    fun toString{vid, stamp} = VId.toString vid


    (* Ordering *)

    fun compare(en1: ExName, en2: ExName) =
            Stamp.compare(#stamp en1, #stamp en2)

  end
(* stop of ExName.sml *)
(* start of ADDR.sml *)
(*
 * Standard ML addresses
 *
 * Definition, section 6.2
 *)

signature ADDR =
  sig

    (* Type [Section 6.2] *)

    eqtype Addr                                 (* [a] *)


    (* Operations *)

    val addr:    unit -> Addr
    val compare: Addr * Addr -> order

  end
(* stop of ADDR.sml *)
(* start of Addr.sml *)
(*
 * Standard ML addresses
 *
 * Definition, section 6.2
 *)


structure Addr :> ADDR =
  struct

    (* Type [Section 6.2] *)

    type Addr = Stamp.stamp                             (* [a] *)


    (* Operations *)

    val addr    = Stamp.stamp
    val compare = Stamp.compare

  end
(* stop of Addr.sml *)
(* start of AssembliesCoreDynamic.sml *)
(*
 * Standard ML additional sets and maps for the dynamic semantics of the core
 *
 * Definition, section 6.3
 *)

structure ExNameSet  = FinSetFn(type ord_key = ExName.ExName
                                val  compare = ExName.compare)

structure AddrMap    = FinMapFn(type ord_key = Addr.Addr
                                val  compare = Addr.compare)
(* stop of AssembliesCoreDynamic.sml *)
(* start of SVAL.sml *)
(*
 * Standard ML special values
 *
 * Definition, section 6.2
 *)


signature SVAL =
  sig 

    (* Type [Section 6.2] *)

    datatype SVal =                             (* [sv] *)
          INT    of int
        | WORD   of word
        | STRING of string
        | CHAR   of char
        | REAL   of real

    (* Operations *)

    val toString:  SVal -> string
    val equal:     SVal * SVal -> bool

  end
(* stop of SVAL.sml *)
(* start of SVal.sml *)
(*
 * Standard ML special values
 *
 * Definition, section 6.2
 *)


structure SVal :> SVAL =
  struct

    (* Type [Section 6.2] *)

    datatype SVal =                             (* [sv] *)
          INT    of int
        | WORD   of word
        | STRING of string
        | CHAR   of char
        | REAL   of real


    (* Conversions *)

    fun toString(INT i)    = Int.toString i
      | toString(WORD w)   = "0wx" ^ Word.toString w
      | toString(STRING s) = "\""  ^ String.toString s ^ "\""
      | toString(CHAR c)   = "\"#" ^ Char.toString c   ^ "\""
      | toString(REAL r)   = Real.toString r

    (* Equality *)

    fun equal(INT n1,    INT n2   ) = n1 = n2
      | equal(WORD w1,   WORD w2  ) = w1 = w2
      | equal(STRING s1, STRING s2) = s1 = s2
      | equal(CHAR c1,   CHAR c2  ) = c1 = c2
      | equal _ = raise Fail "type error: equality type expected"

  end
(* stop of SVal.sml *)
(* start of VAL.sml *)
(*
 * Standard ML values
 *
 * Definition, sections 6.2, 6.3, and 6.4
 *
 * Note:
 *   - All value types are parameterised over the representation of function
 *     closures to break up the recursion between values and environments.
 *   - The basic values are just strings.
 *)


signature VAL =
  sig 

    (* Import *)

    type Addr      = Addr.Addr
    type ExName    = ExName.ExName
    type SVal      = SVal.SVal
    type VId       = VId.Id
    type 'a LabMap = 'a LabMap.map


    (* Types [Sections 6.2 and 6.3] *)

    type BasVal = string                        (* [b] *)

    datatype 'a Val =                           (* [v] *)
          :=
        | SVal   of SVal
        | BasVal of BasVal
        | VId    of VId
        | VIdVal of VId * 'a Val
        | ExVal  of 'a ExVal
        | Record of (*Record*) 'a Val LabMap
        | Addr   of Addr
        | FcnClosure of 'a

    and 'a ExVal =                              (* [e] *)
          ExName    of ExName
        | ExNameVal of ExName * 'a Val

    type 'a Record = 'a Val LabMap              (* [r] *)


    (* Operations *)

    val equal:      'a Val * 'a Val -> bool

    val toBoolVal:  bool -> 'a Val 
    val unpair:     'a Val -> ('a Val * 'a Val) option

  end
(* stop of VAL.sml *)
(* start of Val.sml *)
(*
 * Standard ML values
 *
 * Definition, sections 6.2, 6.3, and 6.4
 *
 * Note:
 *   - All value types are parameterised over the representation of function
 *     closures to break up the recursion between values and environments.
 *   - The basic values are just strings.
 *)


structure Val :> VAL =
  struct

    (* Import *)

    type Addr      = Addr.Addr
    type ExName    = ExName.ExName
    type SVal      = SVal.SVal
    type VId       = VId.Id
    type 'a LabMap = 'a LabMap.map


    (* Types [Sections 6.2 and 6.3] *)

    type BasVal = string                        (* [b] *)


    datatype 'a Val =                           (* [v] *)
          op:=
        | SVal   of SVal
        | BasVal of BasVal
        | VId    of VId
        | VIdVal of VId * 'a Val
        | ExVal  of 'a ExVal
        | Record of 'a Record
        | Addr   of Addr
        | FcnClosure of 'a

    and 'a ExVal =                              (* [e] *)
          ExName    of ExName
        | ExNameVal of ExName * 'a Val

    withtype 'a Record = 'a Val LabMap          (* [r] *)


    (* Operations *)

    fun toBoolVal b = VId(VId.fromString(if b then "true" else "false"))


    fun unpair(Record r) =
        (case (LabMap.find(r, Lab.fromInt 1), LabMap.find(r, Lab.fromInt 2))
           of (SOME v1, SOME v2) => SOME(v1, v2)
            | _ => NONE
        )
      | unpair _ = NONE



    (* Implementation of polymorphic equality *)

    fun equal(SVal sv1,          SVal sv2         ) = SVal.equal(sv1, sv2)
      | equal(VId vid1,          VId vid2         ) = vid1 = vid2
      | equal(ExVal(ExName en1), ExVal(ExName en2)) = en1 = en2
      | equal(Addr a1,           Addr a2          ) = a1 = a2

      | equal(VIdVal(vid1, v1), VIdVal(vid2, v2)) =
            vid1 = vid2 andalso equal(v1, v2)

      | equal(ExVal(ExNameVal(en1,v1)), ExVal(ExNameVal(en2,v2))) =
            en1 = en2 andalso equal(v1, v2)

      | equal(Record r1, Record r2) =
            LabMap.numItems r1 = LabMap.numItems r2 andalso
            LabMap.alli (fn(lab, v1) =>
                           case LabMap.find(r2, lab)
                             of SOME v2 => equal(v1, v2)
                              | NONE    => false
                        ) r1

      | equal _ = false

  end
(* stop of Val.sml *)
(* start of STATE.sml *)
(*
 * Standard ML state
 *
 * Definition, section 6.3
 *
 * Notes:
 *   - Memory gets represented by references. This avoids expanding out all
 *     occurances of the state convention in the inference rules.
 *   - Since exception names are generated by stamps we do not really need the
 *     exception name set. We maintain it anyway.
 *)

signature STATE =
  sig

    (* Import *)

    type Addr       = Addr.Addr
    type ExName     = ExName.ExName
    type ExNameSet  = ExNameSet.set
    type 'a Val     = 'a Val.Val
    type 'a AddrMap = 'a AddrMap.map


    (* Types [Section 6.3] *)

    type 'a Mem   = 'a Val AddrMap                      (* [mem] *)

    type 'a State = 'a Mem * ExNameSet                  (* [s] *)


    (* Operations *)

    val insertAddr:     'a State * Addr * 'a Val -> 'a State
    val insertExName:   'a State * ExName        -> 'a State

    val findAddr:       'a State * Addr -> 'a Val option

  end
(* stop of STATE.sml *)
(* start of State.sml *)
(*
 * Standard ML state
 *
 * Definition, section 6.3
 *
 * Notes:
 *   - Memory gets represented by references. This avoids expanding out all
 *     occurances of the state convention in the inference rules.
 *   - Since exception names are generated by stamps we do not really need the
 *     exception name set. We maintain it anyway.
 *)

structure State :> STATE =
  struct

    (* Import *)

    type Addr       = Addr.Addr
    type ExName     = ExName.ExName
    type ExNameSet  = ExNameSet.set
    type 'a Val     = 'a Val.Val
    type 'a AddrMap = 'a AddrMap.map


    (* Types [Section 6.3] *)

    type 'a Mem   = 'a Val AddrMap                      (* [mem] *)

    type 'a State = 'a Mem * ExNameSet                  (* [s] *)


    (* Operations *)

    fun insertAddr  ((mem,ens), a, v) = ( AddrMap.insert(mem, a, v), ens )
    fun insertExName((mem,ens), en)   = ( mem, ExNameSet.add(ens, en) )

    fun findAddr((mem,ens), a) = AddrMap.find(mem, a)

  end
(* stop of State.sml *)
(* start of GRAMMAR_CORE.sml *)
(*
 * Standard ML abstract core grammar
 *
 * Definition, section 2.8
 *
 * Note:
 *   This is the syntax used in the inference rules for the core [Definition,
 *   sections 4.10 and 6.7]. It omits almost anything having to do with infixed
 *   identifiers:
 *     - fixity directives
 *     - infixed application
 *     - infixed value construction
 *   However, op prefixes are kept, since they are required for rebuilding the
 *   syntax tree during fixity resolution.
 *   Optional semicolons are also omitted.
 *)

signature GRAMMAR_CORE =
  sig

    (* Import *)

    type Info

    type SCon           = SCon.SCon
    type Lab            = Lab.Lab
    type VId            = VId.Id
    type TyCon          = TyCon.Id
    type TyVar          = TyVar.TyVar
    type StrId          = StrId.Id
    type longVId        = LongVId.longId
    type longTyCon      = LongTyCon.longId
    type longStrId      = LongStrId.longId


    (* Optional keyword `op' *)

    datatype Op = SANSOp | WITHOp


    (* Expressions [Figures 2 and 4] *)

    datatype AtExp =
          SCONAtExp      of Info * SCon
        | LONGVIDAtExp   of Info * Op * longVId
        | RECORDAtExp    of Info * ExpRow option
        | LETAtExp       of Info * Dec * Exp
        | PARAtExp       of Info * Exp

    and ExpRow =
          ExpRow         of Info * Lab * Exp * ExpRow option

    and Exp =
          ATEXPExp       of Info * AtExp
        | APPExp         of Info * Exp * AtExp
        | TYPEDExp       of Info * Exp * Ty
        | HANDLEExp      of Info * Exp * Match
        | RAISEExp       of Info * Exp
        | FNExp          of Info * Match

    (* Matches [Figures 2 and 4] *)

    and Match =
          Match          of Info * Mrule * Match option

    and Mrule =
          Mrule          of Info * Pat * Exp

    (* Declarations [Figures 2 and 4] *)

    and Dec =
          VALDec         of Info * TyVarseq * ValBind
        | TYPEDec        of Info * TypBind
        | DATATYPEDec    of Info * DatBind
        | REPLICATIONDec of Info * TyCon * longTyCon
        | ABSTYPEDec     of Info * DatBind * Dec
        | EXCEPTIONDec   of Info * ExBind
        | LOCALDec       of Info * Dec * Dec
        | OPENDec        of Info * longStrId list
        | EMPTYDec       of Info
        | SEQDec         of Info * Dec * Dec

    (* Bindings [Figures 2 and 4] *)

    and ValBind =
          PLAINValBind   of Info * Pat * Exp * ValBind option
        | RECValBind     of Info * ValBind

    and TypBind =
          TypBind        of Info * TyVarseq * TyCon * Ty * TypBind option

    and DatBind =
          DatBind        of Info * TyVarseq * TyCon * ConBind * DatBind option

    and ConBind =
          ConBind        of Info * Op * VId * Ty option * ConBind option

    and ExBind =
          NEWExBind      of Info * Op * VId * Ty option * ExBind option
        | EQUALExBind    of Info * Op * VId * Op * longVId * ExBind option

    (* Patterns [Figures 2 and 3] *)

    and AtPat =
          WILDCARDAtPat  of Info
        | SCONAtPat      of Info * SCon
        | LONGVIDAtPat   of Info * Op * longVId
        | RECORDAtPat    of Info * PatRow option
        | PARAtPat       of Info * Pat

    and PatRow =
          WILDCARDPatRow of Info
        | ROWPatRow      of Info * Lab * Pat * PatRow option

    and Pat =
          ATPATPat       of Info * AtPat
        | CONPat         of Info * Op * longVId * AtPat
        | TYPEDPat       of Info * Pat * Ty
        | ASPat          of Info * Op * VId * Ty option * Pat

    (* Type expressions [Figures 2 and 3] *)

    and Ty =
          TYVARTy        of Info * TyVar
        | RECORDTy       of Info * TyRow option
        | TYCONTy        of Info * Tyseq * longTyCon
        | ARROWTy        of Info * Ty * Ty
        | PARTy          of Info * Ty

    and TyRow =
          TyRow          of Info * Lab * Ty * TyRow option

    (* Sequences [Section 2.8] *)

    and Tyseq =
          Tyseq          of Info * Ty list

    and TyVarseq =
          TyVarseq       of Info * TyVar list


    (* Operations *)

    val infoAtExp:      AtExp   -> Info
    val infoExpRow:     ExpRow  -> Info
    val infoExp:        Exp     -> Info
    val infoMatch:      Match   -> Info
    val infoMrule:      Mrule   -> Info
    val infoDec:        Dec     -> Info
    val infoValBind:    ValBind -> Info
    val infoTypBind:    TypBind -> Info
    val infoDatBind:    DatBind -> Info
    val infoConBind:    ConBind -> Info
    val infoExBind:     ExBind  -> Info
    val infoAtPat:      AtPat   -> Info
    val infoPatRow:     PatRow  -> Info
    val infoPat:        Pat     -> Info
    val infoTy:         Ty      -> Info
    val infoTyRow:      TyRow   -> Info
    val infoTyseq:      Tyseq   -> Info
    val infoTyVarseq:   TyVarseq -> Info

  end
(* stop of GRAMMAR_CORE.sml *)
(* start of GrammarCoreFn.sml *)
(*
 * Standard ML abstract core grammar
 *
 * Definition, section 2.8
 *
 * Note:
 *   This is the syntax used in the inference rules for the core [Definition,
 *   sections 4.10 and 6.7]. It omits almost anything having to do with infixed
 *   identifiers:
 *     - fixity directives
 *     - infixed application
 *     - infixed value construction
 *   However, op prefixes are kept, since they are required for rebuilding the
 *   syntax tree during fixity resolution.
 *   Optional semicolons are also omitted.
 *)

functor GrammarCoreFn(type Info) : GRAMMAR_CORE =
  struct

    (* Import *)

    type Info           = Info

    type SCon           = SCon.SCon
    type Lab            = Lab.Lab
    type VId            = VId.Id
    type TyCon          = TyCon.Id
    type TyVar          = TyVar.TyVar
    type StrId          = StrId.Id
    type longVId        = LongVId.longId
    type longTyCon      = LongTyCon.longId
    type longStrId      = LongStrId.longId


    (* Optional keyword `op' *)

    datatype Op = SANSOp | WITHOp


    (* Expressions [Figures 2 and 4] *)

    datatype AtExp =
          SCONAtExp      of Info * SCon
        | LONGVIDAtExp   of Info * Op * longVId
        | RECORDAtExp    of Info * ExpRow option
        | LETAtExp       of Info * Dec * Exp
        | PARAtExp       of Info * Exp

    and ExpRow =
          ExpRow         of Info * Lab * Exp * ExpRow option

    and Exp =
          ATEXPExp       of Info * AtExp
        | APPExp         of Info * Exp * AtExp
        | TYPEDExp       of Info * Exp * Ty
        | HANDLEExp      of Info * Exp * Match
        | RAISEExp       of Info * Exp
        | FNExp          of Info * Match

    (* Matches [Figures 2 and 4] *)

    and Match =
          Match          of Info * Mrule * Match option

    and Mrule =
          Mrule          of Info * Pat * Exp

    (* Declarations [Figures 2 and 4] *)

    and Dec =
          VALDec         of Info * TyVarseq * ValBind
        | TYPEDec        of Info * TypBind
        | DATATYPEDec    of Info * DatBind
        | REPLICATIONDec of Info * TyCon * longTyCon
        | ABSTYPEDec     of Info * DatBind * Dec
        | EXCEPTIONDec   of Info * ExBind
        | LOCALDec       of Info * Dec * Dec
        | OPENDec        of Info * longStrId list
        | EMPTYDec       of Info
        | SEQDec         of Info * Dec * Dec

    (* Bindings [Figures 2 and 4] *)

    and ValBind =
          PLAINValBind   of Info * Pat * Exp * ValBind option
        | RECValBind     of Info * ValBind

    and TypBind =
          TypBind        of Info * TyVarseq * TyCon * Ty * TypBind option

    and DatBind =
          DatBind        of Info * TyVarseq * TyCon * ConBind * DatBind option

    and ConBind =
          ConBind        of Info * Op * VId * Ty option * ConBind option

    and ExBind =
          NEWExBind      of Info * Op * VId * Ty option * ExBind option
        | EQUALExBind    of Info * Op * VId * Op * longVId * ExBind option

    (* Patterns [Figures 2 and 3] *)

    and AtPat =
          WILDCARDAtPat  of Info
        | SCONAtPat      of Info * SCon
        | LONGVIDAtPat   of Info * Op * longVId
        | RECORDAtPat    of Info * PatRow option
        | PARAtPat       of Info * Pat

    and PatRow =
          WILDCARDPatRow of Info
        | ROWPatRow      of Info * Lab * Pat * PatRow option

    and Pat =
          ATPATPat       of Info * AtPat
        | CONPat         of Info * Op * longVId * AtPat
        | TYPEDPat       of Info * Pat * Ty
        | ASPat          of Info * Op * VId * Ty option * Pat

    (* Type expressions [Figures 2 and 3] *)

    and Ty =
          TYVARTy        of Info * TyVar
        | RECORDTy       of Info * TyRow option
        | TYCONTy        of Info * Tyseq * longTyCon
        | ARROWTy        of Info * Ty * Ty
        | PARTy          of Info * Ty

    and TyRow =
          TyRow          of Info * Lab * Ty * TyRow option

    (* Sequences [Section 2.8] *)

    and Tyseq =
          Tyseq          of Info * Ty list

    and TyVarseq =
          TyVarseq       of Info * TyVar list



    (* Extracting info fields *)

    fun infoAtExp(SCONAtExp(I,_))               = I
      | infoAtExp(LONGVIDAtExp(I,_,_))          = I
      | infoAtExp(RECORDAtExp(I,_))             = I
      | infoAtExp(LETAtExp(I,_,_))              = I
      | infoAtExp(PARAtExp(I,_))                = I

    fun infoExpRow(ExpRow(I,_,_,_))             = I

    fun infoExp(ATEXPExp(I,_))                  = I
      | infoExp(APPExp(I,_,_))                  = I
      | infoExp(TYPEDExp(I,_,_))                = I
      | infoExp(HANDLEExp(I,_,_))               = I
      | infoExp(RAISEExp(I,_))                  = I
      | infoExp(FNExp(I,_))                     = I

    fun infoMatch(Match(I,_,_))                 = I

    fun infoMrule(Mrule(I,_,_))                 = I

    fun infoDec(VALDec(I,_,_))                  = I
      | infoDec(TYPEDec(I,_))                   = I
      | infoDec(DATATYPEDec(I,_))               = I
      | infoDec(REPLICATIONDec(I,_,_))          = I
      | infoDec(ABSTYPEDec(I,_,_))              = I
      | infoDec(EXCEPTIONDec(I,_))              = I
      | infoDec(LOCALDec(I,_,_))                = I
      | infoDec(OPENDec(I,_))                   = I
      | infoDec(EMPTYDec(I))                    = I
      | infoDec(SEQDec(I,_,_))                  = I

    fun infoValBind(PLAINValBind(I,_,_,_))      = I
      | infoValBind(RECValBind(I,_))            = I

    fun infoTypBind(TypBind(I,_,_,_,_))         = I

    fun infoDatBind(DatBind(I,_,_,_,_))         = I

    fun infoConBind(ConBind(I,_,_,_,_))         = I

    fun infoExBind(NEWExBind(I,_,_,_,_))        = I
      | infoExBind(EQUALExBind(I,_,_,_,_,_))    = I

    fun infoAtPat(WILDCARDAtPat(I))             = I
      | infoAtPat(SCONAtPat(I,_))               = I
      | infoAtPat(LONGVIDAtPat(I,_,_))          = I
      | infoAtPat(RECORDAtPat(I,_))             = I
      | infoAtPat(PARAtPat(I,_))                = I

    fun infoPatRow(WILDCARDPatRow(I))           = I
      | infoPatRow(ROWPatRow(I,_,_,_))          = I

    fun infoPat(ATPATPat(I,_))                  = I
      | infoPat(CONPat(I,_,_,_))                = I
      | infoPat(TYPEDPat(I,_,_))                = I
      | infoPat(ASPat(I,_,_,_,_))               = I

    fun infoTy(TYVARTy(I,_))                    = I
      | infoTy(RECORDTy(I,_))                   = I
      | infoTy(TYCONTy(I,_,_))                  = I
      | infoTy(ARROWTy(I,_,_))                  = I
      | infoTy(PARTy(I,_))                      = I

    fun infoTyRow(TyRow(I,_,_,_))               = I

    fun infoTyseq(Tyseq(I,_))                   = I
    fun infoTyVarseq(TyVarseq(I,_))             = I

  end
(* stop of GrammarCoreFn.sml *)
(* start of SOURCE.sml *)
(*
 * Helpers for handling source strings
 *)

signature SOURCE =
  sig

    type source = string
    type region = int * int

    val over:     region * region -> region
    val between:  region * region -> region

    val compare:  region * region -> order

  end
(* stop of SOURCE.sml *)
(* start of Source.sml *)
(*
 * Helpers for handling source strings
 *)

structure Source :> SOURCE =
  struct

    type source = string
    type region = int * int

    fun over(r1: region, r2: region)    = (#1 r1, #2 r2)
    fun between(r1: region, r2: region) = (#2 r1, #1 r2)

    fun compare((m1,n1), (m2,n2)) =
        case Int.compare(m1, m2)
          of EQUAL => Int.compare(n1, n2)
           | order => order

  end
(* stop of Source.sml *)
(* start of GRAMMAR_MODULE.sml *)
(*
 * Standard ML abstract module grammar
 *
 * Definition, section 3.4
 *
 * Notes:
 *   This is the syntax used in the inference rules for modules [Definition,
 *   sections 5.7 and 7.3]. Optional semicolons are omitted.
 *   The structure sharing derived form [Definition, Appendix A] has been added,
 *   because it cannot be derived purely syntactically.
 *)


signature GRAMMAR_MODULE =
  sig

    (* Import *)

    structure Core: GRAMMAR_CORE

    type Info

    type VId            = Core.VId
    type TyCon          = Core.TyCon
    type TyVar          = Core.TyVar
    type StrId          = Core.StrId
    type longVId        = Core.longVId
    type longTyCon      = Core.longTyCon
    type longStrId      = Core.longStrId
    type Dec            = Core.Dec
    type Ty             = Core.Ty
    type TyVarseq       = Core.TyVarseq

    type SigId          = SigId.Id
    type FunId          = FunId.Id


    (* Structures [Figures 5 and 6] *)

    datatype StrExp =
          STRUCTStrExp    of Info * StrDec
        | LONGSTRIDStrExp of Info * longStrId
        | TRANSStrExp     of Info * StrExp * SigExp
        | OPAQStrExp      of Info * StrExp * SigExp
        | APPStrExp       of Info * FunId * StrExp
        | LETStrExp       of Info * StrDec * StrExp

    and StrDec =
          DECStrDec       of Info * Dec
        | STRUCTUREStrDec of Info * StrBind
        | LOCALStrDec     of Info * StrDec * StrDec
        | EMPTYStrDec     of Info
        | SEQStrDec       of Info * StrDec * StrDec

    and StrBind =
          StrBind         of Info * StrId * StrExp * StrBind option

    (* Signatures [Figures 5 and 6] *)

    and SigExp =
          SIGSigExp       of Info * Spec
        | SIGIDSigExp     of Info * SigId
        | WHERETYPESigExp of Info * SigExp * TyVarseq * longTyCon * Ty

    and SigDec =
          SigDec          of Info * SigBind

    and SigBind =
          SigBind         of Info * SigId * SigExp * SigBind option

    (* Specifications [Figures 5 and 7] *)

    and Spec =
          VALSpec         of Info * ValDesc
        | TYPESpec        of Info * TypDesc
        | EQTYPESpec      of Info * TypDesc
        | DATATYPESpec    of Info * DatDesc
        | REPLICATIONSpec of Info * TyCon * longTyCon
        | EXCEPTIONSpec   of Info * ExDesc
        | STRUCTURESpec   of Info * StrDesc
        | INCLUDESpec     of Info * SigExp
        | EMPTYSpec       of Info
        | SEQSpec         of Info * Spec * Spec
        | SHARINGTYPESpec of Info * Spec * longTyCon list
        | SHARINGSpec     of Info * Spec * longStrId list

    and ValDesc =
          ValDesc         of Info * VId * Ty * ValDesc option

    and TypDesc =
          TypDesc         of Info * TyVarseq * TyCon * TypDesc option

    and DatDesc =
          DatDesc         of Info * TyVarseq * TyCon * ConDesc * DatDesc option

    and ConDesc =
          ConDesc         of Info * VId * Ty option * ConDesc option

    and ExDesc =
          ExDesc          of Info * VId * Ty option * ExDesc option

    and StrDesc =
          StrDesc         of Info * StrId * SigExp * StrDesc option

    (* Functors [Figures 5 and 8] *)

    and FunDec =
          FunDec          of Info * FunBind

    and FunBind =
          FunBind         of Info * FunId * StrId * SigExp * StrExp
                                  * FunBind option

    (* Top-level declarations [Figures 5 and 8] *)

    and TopDec =
          STRDECTopDec    of Info * StrDec * TopDec option
        | SIGDECTopDec    of Info * SigDec * TopDec option
        | FUNDECTopDec    of Info * FunDec * TopDec option


    (* Operations *)

    val infoStrExp:     StrExp  -> Info
    val infoStrDec:     StrDec  -> Info
    val infoStrBind:    StrBind -> Info
    val infoSigExp:     SigExp  -> Info
    val infoSigBind:    SigBind -> Info
    val infoSpec:       Spec    -> Info
    val infoValDesc:    ValDesc -> Info
    val infoTypDesc:    TypDesc -> Info
    val infoDatDesc:    DatDesc -> Info
    val infoConDesc:    ConDesc -> Info
    val infoExDesc:     ExDesc  -> Info
    val infoStrDesc:    StrDesc -> Info
    val infoFunDec:     FunDec  -> Info
    val infoFunBind:    FunBind -> Info
    val infoTopDec:     TopDec  -> Info

  end
(* stop of GRAMMAR_MODULE.sml *)
(* start of GrammarModuleFn.sml *)
(*
 * Standard ML abstract module grammar
 *
 * Definition, section 3.4
 *
 * Notes:
 *   This is the syntax used in the inference rules for modules [Definition,
 *   sections 5.7 and 7.3]. Optional semicolons are omitted.
 *   The structure sharing derived form [Definition, Appendix A] has been added,
 *   because it cannot be derived purely syntactically.
 *)


functor GrammarModuleFn(type Info
                        structure Core: GRAMMAR_CORE
                       ) : GRAMMAR_MODULE =
  struct

    (* Import *)

    structure Core = Core
    type      Info = Info

    open Core

    type SigId = SigId.Id
    type FunId = FunId.Id


    (* Structures [Figures 5 and 6] *)

    datatype StrExp =
          STRUCTStrExp    of Info * StrDec
        | LONGSTRIDStrExp of Info * longStrId
        | TRANSStrExp     of Info * StrExp * SigExp
        | OPAQStrExp      of Info * StrExp * SigExp
        | APPStrExp       of Info * FunId * StrExp
        | LETStrExp       of Info * StrDec * StrExp

    and StrDec =
          DECStrDec       of Info * Dec
        | STRUCTUREStrDec of Info * StrBind
        | LOCALStrDec     of Info * StrDec * StrDec
        | EMPTYStrDec     of Info
        | SEQStrDec       of Info * StrDec * StrDec

    and StrBind =
          StrBind         of Info * StrId * StrExp * StrBind option

    (* Signatures [Figures 5 and 6] *)

    and SigExp =
          SIGSigExp       of Info * Spec
        | SIGIDSigExp     of Info * SigId
        | WHERETYPESigExp of Info * SigExp * TyVarseq * longTyCon * Ty

    and SigDec =
          SigDec          of Info * SigBind

    and SigBind =
          SigBind         of Info * SigId * SigExp * SigBind option

    (* Specifications [Figures 5 and 7] *)

    and Spec =
          VALSpec         of Info * ValDesc
        | TYPESpec        of Info * TypDesc
        | EQTYPESpec      of Info * TypDesc
        | DATATYPESpec    of Info * DatDesc
        | REPLICATIONSpec of Info * TyCon * longTyCon
        | EXCEPTIONSpec   of Info * ExDesc
        | STRUCTURESpec   of Info * StrDesc
        | INCLUDESpec     of Info * SigExp
        | EMPTYSpec       of Info
        | SEQSpec         of Info * Spec * Spec
        | SHARINGTYPESpec of Info * Spec * longTyCon list
        | SHARINGSpec     of Info * Spec * longStrId list

    and ValDesc =
          ValDesc         of Info * VId * Ty * ValDesc option

    and TypDesc =
          TypDesc         of Info * TyVarseq * TyCon * TypDesc option

    and DatDesc =
          DatDesc         of Info * TyVarseq * TyCon * ConDesc * DatDesc option

    and ConDesc =
          ConDesc         of Info * VId * Ty option * ConDesc option

    and ExDesc =
          ExDesc          of Info * VId * Ty option * ExDesc option

    and StrDesc =
          StrDesc         of Info * StrId * SigExp * StrDesc option

    (* Functors [Figures 5 and 8] *)

    and FunDec =
          FunDec          of Info * FunBind

    and FunBind =
          FunBind         of Info * FunId * StrId * SigExp * StrExp
                                  * FunBind option

    (* Top-level declarations [Figures 5 and 8] *)

    and TopDec =
          STRDECTopDec    of Info * StrDec * TopDec option
        | SIGDECTopDec    of Info * SigDec * TopDec option
        | FUNDECTopDec    of Info * FunDec * TopDec option


    (* Extracting info fields *)

    fun infoStrExp(STRUCTStrExp(I,_))           = I
      | infoStrExp(LONGSTRIDStrExp(I,_))        = I
      | infoStrExp(TRANSStrExp(I,_,_))          = I
      | infoStrExp(OPAQStrExp(I,_,_))           = I
      | infoStrExp(APPStrExp(I,_,_))            = I
      | infoStrExp(LETStrExp(I,_,_))            = I

    fun infoStrDec(DECStrDec(I,_))              = I
      | infoStrDec(STRUCTUREStrDec(I,_))        = I
      | infoStrDec(LOCALStrDec(I,_,_))          = I
      | infoStrDec(EMPTYStrDec(I))              = I
      | infoStrDec(SEQStrDec(I,_,_))            = I

    fun infoStrBind(StrBind(I,_,_,_))           = I

    fun infoSigExp(SIGSigExp(I,_))              = I
      | infoSigExp(SIGIDSigExp(I,_))            = I
      | infoSigExp(WHERETYPESigExp(I,_,_,_,_))  = I

    fun infoSigDec(SigDec(I,_))                 = I

    fun infoSigBind(SigBind(I,_,_,_))           = I

    fun infoSpec(VALSpec(I,_))                  = I
      | infoSpec(TYPESpec(I,_))                 = I
      | infoSpec(EQTYPESpec(I,_))               = I
      | infoSpec(DATATYPESpec(I,_))             = I
      | infoSpec(REPLICATIONSpec(I,_,_))        = I
      | infoSpec(EXCEPTIONSpec(I,_))            = I
      | infoSpec(STRUCTURESpec(I,_))            = I
      | infoSpec(INCLUDESpec(I,_))              = I
      | infoSpec(EMPTYSpec(I))                  = I
      | infoSpec(SEQSpec(I,_,_))                = I
      | infoSpec(SHARINGTYPESpec(I,_,_))        = I
      | infoSpec(SHARINGSpec(I,_,_))            = I

    fun infoValDesc(ValDesc(I,_,_,_))           = I
    fun infoTypDesc(TypDesc(I,_,_,_))           = I
    fun infoDatDesc(DatDesc(I,_,_,_,_))         = I
    fun infoConDesc(ConDesc(I,_,_,_))           = I
    fun infoExDesc(ExDesc(I,_,_,_))             = I
    fun infoStrDesc(StrDesc(I,_,_,_))           = I

    fun infoFunDec(FunDec(I,_))                 = I

    fun infoFunBind(FunBind(I,_,_,_,_,_))       = I

    fun infoTopDec(STRDECTopDec(I,_,_))         = I
      | infoTopDec(SIGDECTopDec(I,_,_))         = I
      | infoTopDec(FUNDECTopDec(I,_,_))         = I

  end
(* stop of GrammarModuleFn.sml *)
(* start of GRAMMAR_PROGRAM.sml *)
(*
 * Standard ML abstract program grammar
 *
 * Definition, section 8
 *)


signature GRAMMAR_PROGRAM =
  sig

    (* Import *)

    structure Module: GRAMMAR_MODULE

    type Info   = Module.Info

    type TopDec = Module.TopDec


    (* Programs *)

    datatype Program = Program of Info * TopDec * Program option


    (* Extracting the info field *)

    val infoProgram: Program -> Info

  end
(* stop of GRAMMAR_PROGRAM.sml *)
(* start of GrammarProgramFn.sml *)
(*
 * Standard ML abstract program grammar
 *
 * Definition, section 8
 *)


functor GrammarProgramFn(type Info
                         structure Module: GRAMMAR_MODULE
                        ) : GRAMMAR_PROGRAM =
  struct

    (* Import *)

    structure Module = Module
    type      Info   = Info

    open Module


    (* Programs *)

    datatype Program = Program of Info * TopDec * Program option


    (* Extracting the info field *)

    fun infoProgram(Program(I,_,_)) = I

  end
(* stop of GrammarProgramFn.sml *)
(* start of Grammars.sml *)
structure GrammarCore    = GrammarCoreFn(type Info = Source.region)

structure GrammarModule  = GrammarModuleFn(type Info = Source.region
                                           structure Core = GrammarCore)

structure GrammarProgram = GrammarProgramFn(type Info = Source.region
                                            structure Module = GrammarModule)
(* stop of Grammars.sml *)
(* start of DYNAMIC_ENV.sml *)
(*
 * Standard ML environments of the dynamic semantics of the core
 *
 * Definition, sections 6.3 and 6.6
 *
 * Notes:
 *   - We call the domain type of value environments ValStr.
 *   - The type definitions here are heavily recursive and it is really stupid
 *     that SML allows no withtype in signatures...
 *)

signature DYNAMIC_ENV =
  sig

    (* Inheritance *)

    include GENERIC_ENV


    (* Import types *)

    type 'a Val = 'a Val.Val
    type Match  = GrammarCore.Match


    (* Export types [Section 6.6] *)

    datatype FcnClosure =
             FcnClosure of Match
                        * ( (*Env*)
                            ( FcnClosure Val * IdStatus
                            , (FcnClosure Val * IdStatus) VIdMap
                            ) Str' StrIdMap
                          * (FcnClosure Val * IdStatus) VIdMap TyConMap 
                          * (FcnClosure Val * IdStatus) VIdMap
                          )
                        * (*ValEnv*) (FcnClosure Val * IdStatus) VIdMap

    type ValStr = FcnClosure Val * IdStatus
    type ValEnv = ValStr VIdMap                         (* [VE] *)

    type TyStr  = ValEnv
    type TyEnv  = TyStr TyConMap                        (* [TE] *)

    type Str    = (ValStr, TyStr) Str'
    type StrEnv = Str StrIdMap                          (* [SE] *)

    type Env    = StrEnv * TyEnv * ValEnv               (* [E] *)


    (* Operations *)

    val Rec:    ValEnv -> ValEnv

  end
(* stop of DYNAMIC_ENV.sml *)
(* start of DynamicEnv.sml *)
(*
 * Standard ML environments of the dynamic semantics of the core
 *
 * Definition, sections 6.3 and 6.6
 *
 * Notes:
 *   - We call the domain type of value environments ValStr.
 *   - The type definitions here are heavily recursive. It would be easier if
 *     SML would define withtype sequentially (as SML/NJ implements it).
 *     However, it is still better than inside the signature...
 *)

structure DynamicEnv :> DYNAMIC_ENV =
  struct

    (* Inheritance *)

    structure GenericEnv = GenericEnvFn()

    open GenericEnv


    (* Import types *)

    type 'a Val = 'a Val.Val
    type Match  = GrammarCore.Match


    (* Export types [Section 6.6] *)

    datatype FcnClosure =
             FcnClosure of Match * ((*Env*) StrEnv * TyEnv * ValEnv) * ValEnv

    withtype ValEnv = (FcnClosure Val * IdStatus) VIdMap          (* [VE] *)
    and      TyEnv  = (FcnClosure Val * IdStatus) VIdMap TyConMap (* [TE] *)
    and      StrEnv = (FcnClosure Val * IdStatus,
                       (FcnClosure Val * IdStatus) VIdMap) Str' StrIdMap
                                                                  (* [SE] *)
    type ValStr = FcnClosure Val * IdStatus
    type TyStr  = ValEnv
    type Str    = (ValStr, TyStr) Str'

    type Env    = StrEnv * TyEnv * ValEnv                         (* [E] *)


    (* Unrolling [Section 6.6] *)

    fun Rec VE =
            VIdMap.map
                (fn (Val.FcnClosure(FcnClosure(match',E',VE')), IdStatus.v) =>
                    (Val.FcnClosure(FcnClosure(match',E',VE)), IdStatus.v)
                  | valstr => valstr
                ) VE

  end
(* stop of DynamicEnv.sml *)
(* start of INITIAL_DYNAMIC_ENV.sml *)
(*
 * Standard ML core view of the initial dynamic basis
 *
 * Definition, appendix D and section 6.5
 *
 * Note:
 *     The Definition does not specify what the initial state has to contain.
 *     This is a bug as it must at least contain the exception names Match
 *     and Bind. We put the state associated with the initial environment in
 *     here, too.
 *)

signature INITIAL_DYNAMIC_ENV =
  sig

    (* Import types *)

    type Env    = DynamicEnv.Env
    type ExName = ExName.ExName
    type State  = DynamicEnv.FcnClosure State.State


    (* Basic exception names [Section 6.5] *)

    val enMatch: ExName
    val enBind:  ExName

    (* Initial environment [Appendix D] *)

    val E0: Env

    (* Associated state *)

    val s: State

  end
(* stop of INITIAL_DYNAMIC_ENV.sml *)
(* start of InitialDynamicEnv.sml *)
(*
 * Standard ML core view of the initial dynamic basis
 *
 * Definition, appendix D and section 6.5
 *
 * Note:
 *     The Definition does not specify what the initial state has to contain.
 *     This is a bug as it must at least contain the exception names Match
 *     and Bind. We put the state associated with the initial environment in
 *     here, too.
 *)

structure InitialDynamicEnv :> INITIAL_DYNAMIC_ENV =
  struct

    (* Import *)

    type Env    = DynamicEnv.Env
    type ValEnv = DynamicEnv.ValEnv
    type ExName = ExName.ExName
    type State  = DynamicEnv.FcnClosure State.State


    open Val
    open IdStatus


    (* VIds [Appendix D] *)

    val vidEq     = VId.fromString "="
    val vidAssign = VId.fromString ":="

    val vidFalse  = VId.fromString "false"
    val vidTrue   = VId.fromString "true"
    val vidNil    = VId.fromString "nil"
    val vidCons   = VId.fromString "::"
    val vidRef    = VId.fromString "ref"

    val vidMatch  = VId.fromString "Match"
    val vidBind   = VId.fromString "Bind"


    (* Basic exception names [Section 6.5] *)

    val enMatch = ExName.exname vidMatch
    val enBind  = ExName.exname vidBind


    (* Value entries [Appendix D] *)

    val valstrEq     = (BasVal "=", v)
    val valstrAssign = (op:=,       v)

    val valstrFalse  = (VId vidFalse, c)
    val valstrTrue   = (VId vidTrue,  c)
    val valstrNil    = (VId vidNil,   c)
    val valstrCons   = (VId vidCons,  c)
    val valstrRef    = (VId vidRef,   c)

    val valstrMatch  = (ExVal(ExName enMatch), e)
    val valstrBind   = (ExVal(ExName enBind),  e)


    (* TyCons [Figure 26] *)

    val tyconUnit   = TyCon.fromString "unit"
    val tyconBool   = TyCon.fromString "bool"
    val tyconInt    = TyCon.fromString "int"
    val tyconWord   = TyCon.fromString "word"
    val tyconReal   = TyCon.fromString "real"
    val tyconString = TyCon.fromString "string"
    val tyconChar   = TyCon.fromString "char"
    val tyconList   = TyCon.fromString "list"
    val tyconRef    = TyCon.fromString "ref"
    val tyconExn    = TyCon.fromString "exn"


    (* Type ValEnvs [Figure 26] *)

    val VEUnit   = VIdMap.empty
    val VEBool   = VIdMap.fromList[(vidFalse, valstrFalse),
                                   (vidTrue,  valstrTrue)] : ValEnv
    val VEInt    = VIdMap.empty
    val VEWord   = VIdMap.empty
    val VEReal   = VIdMap.empty
    val VEString = VIdMap.empty
    val VEChar   = VIdMap.empty
    val VEList   = VIdMap.fromList[(vidNil,   valstrNil),
                                   (vidCons,  valstrCons)] : ValEnv
    val VERef    = VIdMap.fromList[(vidRef,   valstrRef)] : ValEnv
    val VEExn    = VIdMap.empty


    (* Environments [Appendix D] *)

    val SE0 = StrIdMap.empty

    val TE0 = TyConMap.fromList[(tyconUnit,   VEUnit),
                                (tyconBool,   VEBool),
                                (tyconInt,    VEInt),
                                (tyconWord,   VEWord),
                                (tyconReal,   VEReal),
                                (tyconString, VEString),
                                (tyconChar,   VEChar),
                                (tyconList,   VEList),
                                (tyconRef,    VERef),
                                (tyconExn,    VEExn)]

    val VE0 = VIdMap.fromList  [(vidEq,     valstrEq),
                                (vidAssign, valstrAssign),
                                (vidRef,    valstrRef),
                                (vidNil,    valstrNil),
                                (vidCons,   valstrCons),
                                (vidFalse,  valstrFalse),
                                (vidTrue,   valstrTrue),
                                (vidMatch,  valstrMatch),
                                (vidBind,   valstrBind)] : ValEnv

    val E0 = (SE0,TE0,VE0)


    (* Associated state *)

    val mem = AddrMap.empty
    val ens = ExNameSet.fromList[enMatch, enBind]

    val s = (mem, ens)

  end
(* stop of InitialDynamicEnv.sml *)
(* start of INTERFACE.sml *)
(*
 * Standard ML interfaces
 *
 * Definition, section 7.2
 *)

signature INTERFACE =
  sig

    (* Inheritance *)

    include GENERIC_ENV


    (* Import *)

    type Env = DynamicEnv.Env


    (* Export types [Section 7.2] *)

    type ValInt = IdStatus VIdMap                               (* [VI] *)
    type TyInt  = ValInt TyConMap                               (* [TI] *)

    type Str    = (IdStatus, ValInt) Str'
    type StrInt = Str StrIdMap                                  (* [SI] *)
 
    type Int    = StrInt * TyInt * ValInt                       (* [I] *)


    (* Operations *)

    val fromSI:         StrInt -> Int
    val fromTI:         TyInt  -> Int
    val fromVI:         ValInt -> Int
    val fromVIandTI:    ValInt * TyInt -> Int

    val Inter:          Env -> Int
    val cutdown:        Env * Int -> Env

  end
(* stop of INTERFACE.sml *)
(* start of Interface.sml *)
(*
 * Standard ML interfaces
 *
 * Definition, section 7.2
 *)


structure Interface :> INTERFACE =
  struct

    (* Inheritance *)

    structure GenericEnv = GenericEnvFn()

    open GenericEnv


    (* Import *)

    type Env = DynamicEnv.Env


    (* Export types [Section 7.2] *)

    type ValInt = IdStatus VIdMap                               (* [VI] *)
    type TyInt  = ValInt TyConMap                               (* [TI] *)

    type Str    = (IdStatus, ValInt) Str'
    type StrInt = Str StrIdMap                                  (* [SI] *)
 
    type Int    = StrInt * TyInt * ValInt                       (* [I] *)


    (* Injections [Section 4.3] *)

    val fromSI      = fromSE
    val fromTI      = fromTE
    val fromVI      = fromVE
    val fromVIandTI = fromVEandTE


    (* Extracting interfaces from environments [Section 7.2] *)

    fun InterVE VE = VIdMap.map (fn(v,is) => is) VE
    fun InterTE TE = TyConMap.map (fn VE => InterVE VE) TE
    fun InterSE SE = StrIdMap.map (fn DynamicEnv.Str E => Str(Inter E)) SE

    and Inter (SE,TE,VE) = (InterSE SE, InterTE TE, InterVE VE)


    (* Cutting down environments [Section 7.2] *)

    fun cutdownVE(VE, VI) =
        VIdMap.foldli
            (fn(vid, is, VE') =>
                case VIdMap.find(VE, vid)
                  of SOME(v,is') => VIdMap.insert(VE', vid, (v,is))
                   | NONE        => VE'
            ) VIdMap.empty VI

    fun cutdownTE(TE, TI) =
        TyConMap.foldli
            (fn(tycon, VI', TE') =>
                case TyConMap.find(TE, tycon)
                  of SOME VE' => TyConMap.insert(TE', tycon, cutdownVE(VE',VI'))
                   | NONE     => TE'
            ) TyConMap.empty TI

    fun cutdownSE(SE, SI) =
        StrIdMap.foldli
            (fn(strid, Str I, SE') =>
                case StrIdMap.find(SE, strid)
                  of SOME(DynamicEnv.Str E) =>
                       StrIdMap.insert(SE', strid, DynamicEnv.Str(cutdown(E,I)))
                   | NONE => SE'
            ) StrIdMap.empty SI

    and cutdown((SE,TE,VE), (SI,TI,VI)) =
        ( cutdownSE(SE, SI), cutdownTE(TE, TI), cutdownVE(VE, VI) )

  end
(* stop of Interface.sml *)
(* start of DYNAMIC_BASIS.sml *)
(*
 * Standard ML dynamic basis and environments of modules
 *
 * Definition, section 7.2
 *)

signature DYNAMIC_BASIS =
  sig

    (* Import types *)

    type StrId       = StrId.Id
    type SigId       = SigId.Id
    type FunId       = FunId.Id
    type longStrId   = LongStrId.longId
    type longTyCon   = LongTyCon.longId
    type Env         = DynamicEnv.Env
    type ValEnv      = DynamicEnv.ValEnv
    type StrEnv      = DynamicEnv.StrEnv
    type Str         = DynamicEnv.Str
    type Int         = Interface.Int
    type StrExp      = GrammarModule.StrExp

    type 'a SigIdMap = 'a SigIdMap.map
    type 'a FunIdMap = 'a FunIdMap.map


    (* Types [Section 7.2] *)

    datatype FunctorClosure =
        FunctorClosure of (StrId * Int) * StrExp *
                        (*Basis*) (FunctorClosure FunIdMap * Int SigIdMap * Env)

    type SigEnv   = Int SigIdMap                                (* [G] *)
    type FunEnv   = FunctorClosure FunIdMap                     (* [F] *)

    type Basis    = FunEnv * SigEnv * Env                       (* [B] *)


    (* Operations *)

    val empty:          Basis
    val fromE:          Env    -> Basis
    val fromF:          FunEnv -> Basis
    val fromG:          SigEnv -> Basis

    val Eof:            Basis    -> Env

    val plus:           Basis * Basis     -> Basis
    val plusSE:         Basis * StrEnv    -> Basis
    val plusG:          Basis * SigEnv    -> Basis
    val plusF:          Basis * FunEnv    -> Basis
    val plusE:          Basis * Env       -> Basis

    val findStrId:      Basis * StrId     -> Str option
    val findSigId:      Basis * SigId     -> Int option
    val findFunId:      Basis * FunId     -> FunctorClosure option
    val findLongStrId:  Basis * longStrId -> Str option
    val findLongTyCon:  Basis * longTyCon -> ValEnv option
 
  end
(* stop of DYNAMIC_BASIS.sml *)
(* start of DynamicBasis.sml *)
(*
 * Standard ML dynamic basis and environments of modules
 *
 * Definition, section 7.2
 *)


structure DynamicBasis :> DYNAMIC_BASIS =
  struct

    (* Import types *)

    type StrId       = StrId.Id
    type SigId       = SigId.Id
    type FunId       = FunId.Id
    type longStrId   = LongStrId.longId
    type longTyCon   = LongTyCon.longId
    type Env         = DynamicEnv.Env
    type ValEnv      = DynamicEnv.ValEnv
    type StrEnv      = DynamicEnv.StrEnv
    type Str         = DynamicEnv.Str
    type Int         = Interface.Int
    type StrExp      = GrammarModule.StrExp

    type 'a SigIdMap = 'a SigIdMap.map
    type 'a FunIdMap = 'a FunIdMap.map


    (* Types [Section 7.2] *)

    datatype FunctorClosure =
        FunctorClosure of (StrId * Int) * StrExp *
                          (*Basis*) (FunEnv * SigEnv * Env)

    withtype SigEnv   = Int SigIdMap                            (* [G] *)
    and      FunEnv   = FunctorClosure FunIdMap                 (* [F] *)

    type     Basis    = FunEnv * SigEnv * Env                   (* [B] *)



    (* Injections [Sections 4.3 and 7.2] *)

    val empty = ( FunIdMap.empty, SigIdMap.empty, DynamicEnv.empty )

    fun fromE E = ( FunIdMap.empty, SigIdMap.empty, E )
    fun fromF F = ( F, SigIdMap.empty, DynamicEnv.empty )
    fun fromG G = ( FunIdMap.empty, G, DynamicEnv.empty )


    (* Injections [Sections 4.3 and 7.2] *)

    fun Eof (F,G,E) = E


    (* Modifications [Sections 4.3 and 7.2] *)

    infix plus plusG plusF plusE plusSE IBplusI

    fun (F,G,E) plus (F',G',E') =
        ( FunIdMap.unionWith #2 (F,F')
        , SigIdMap.unionWith #2 (G,G')
        , DynamicEnv.plus(E,E')
        )

    fun (F,G,E) plusG  G' = ( F, SigIdMap.unionWith #2 (G,G'), E )
    fun (F,G,E) plusF  F' = ( FunIdMap.unionWith #2 (F,F'), G, E )
    fun (F,G,E) plusE  E' = ( F, G, DynamicEnv.plus(E,E') )
    fun (F,G,E) plusSE SE = ( F, G, DynamicEnv.plusSE(E,SE) )


    (* Application (lookup) [Sections 7.2 and 4.3] *)

    fun findStrId((F,G,E), strid) = DynamicEnv.findStrId(E, strid)
    fun findSigId((F,G,E), sigid) = SigIdMap.find(G, sigid)
    fun findFunId((F,G,E), funid) = FunIdMap.find(F, funid)
    fun findLongStrId((F,G,E), longstrid) =
        DynamicEnv.findLongStrId(E, longstrid)
    fun findLongTyCon((F,G,E), longtycon) =
        DynamicEnv.findLongTyCon(E, longtycon)

  end
(* stop of DynamicBasis.sml *)
(* start of INITIAL_DYNAMIC_BASIS.sml *)
(*
 * Standard ML initial dynamic basis
 *
 * Definition, appendix D
 *
 * Note:
 *     The Definition does not specify what the initial state has to contain.
 *     This is a bug as it must at least contain the exception names Match
 *     and Bind. We put the state associated with the initial basis in
 *     here, too.
 *)

signature INITIAL_DYNAMIC_BASIS =
  sig

    (* Import *)

    type Basis = DynamicBasis.Basis
    type State = InitialDynamicEnv.State


    (* Export *)

    val B0: Basis
    val s:  State

  end
(* stop of INITIAL_DYNAMIC_BASIS.sml *)
(* start of InitialDynamicBasis.sml *)
(*
 * Standard ML initial dynamic basis
 *
 * Definition, appendix D
 *
 * Note:
 *     The Definition does not specify what the initial state has to contain.
 *     This is a bug as it must at least contain the exception names Match
 *     and Bind. We put the state associated with the initial basis in
 *     here, too.
 *)

structure InitialDynamicBasis :> INITIAL_DYNAMIC_BASIS =
  struct

    (* Import *)

    type Basis = DynamicBasis.Basis
    type State = InitialDynamicEnv.State


    (* Enviornments *)

    val F0 = FunIdMap.empty
    val G0 = SigIdMap.empty
    val E0 = InitialDynamicEnv.E0

    val B0 = (F0,G0,E0)


    (* Associated state *)

    val s = InitialDynamicEnv.s

  end
(* stop of InitialDynamicBasis.sml *)
(* start of ERROR.sml *)
(*
 * Error handling.
 *)


signature ERROR =
  sig

    (* Import *)

    type position = Source.region


    (* Export *)

    exception Error of position * string

    val error:    position * string -> 'a
    val warning:  position * string -> unit

  end
(* stop of ERROR.sml *)
(* start of Error.sml *)
(*
 * Error handling.
 *)


structure Error :> ERROR =
  struct

    (* Import *)

    type position = Source.region


    (* Helper *)

    fun print((pos1,pos2), message) =
        let
            val a = Int.toString pos1
            val b = Int.toString pos2
        in
            TextIO.output(TextIO.stdErr, a ^ "-" ^ b ^ ": " ^ message ^ "\n")
          ; TextIO.flushOut TextIO.stdErr
        end


    (* Export *)

    exception Error of position * string

    fun error(pos, message) =
        ( print(pos, message)
        ; raise Error(pos, message)
        )

    fun warning(pos, message) =
        print(pos, "warning: " ^ message)

  end
(* stop of Error.sml *)
(* start of INFIX.sml *)
(*
 * Standard ML infix resolution
 *
 * Definition, section 2.6
 *)


signature INFIX =
  sig

    (* Import *)

    type Info    = GrammarCore.Info

    type Op      = GrammarCore.Op
    type VId     = GrammarCore.VId
    type longVId = GrammarCore.longVId
    type Exp     = GrammarCore.Exp
    type Pat     = GrammarCore.Pat
    type AtExp   = GrammarCore.AtExp
    type AtPat   = GrammarCore.AtPat


    (* Modifying fixity status *)

    datatype Assoc = LEFT | RIGHT

    type InfStatus = Assoc * int
    type InfEnv    = InfStatus VIdMap.map       (* [J] *)

    val empty:          InfEnv
    val assign:         InfEnv * VId list * InfStatus -> InfEnv
    val cancel:         InfEnv * VId list -> InfEnv


    (* Resolving phrases containing infixed identifiers *)

    val parseExp:       InfEnv * AtExp list -> Exp
    val parsePat:       InfEnv * AtPat list -> Pat
    val parseFmrule:    InfEnv * AtPat list -> Op * VId * AtPat list

  end
(* stop of INFIX.sml *)
(* start of Infix.sml *)
(*
 * Standard ML infix resolution
 *
 * Definition, section 2.6
 *)


structure Infix :> INFIX =
  struct

    (* Import *)

    open GrammarCore


    (* Type definitions *)

    datatype Assoc = LEFT | RIGHT

    type InfStatus = Assoc * int

    type InfEnv    = InfStatus VIdMap.map               (* [J] *)



    (* Modifying infix environments *)

    val empty = VIdMap.empty

    fun assign(J, vids, infstatus) =
        let
            fun insert(vid, J) = VIdMap.insert(J, vid, infstatus)
        in
            List.foldl insert J vids
        end

    fun cancel(J, vids) =
        let
            fun remove(vid, J) = #1(VIdMap.remove(J, vid))
        in
            List.foldl remove J vids
        end



    (* Helpers for error messages *)

    val error                           = Error.error
    fun errorVId(I, s, vid)             = error(I, s ^ VId.toString vid)
    fun errorLongVId(I, s, longvid)     = error(I, s ^ LongVId.toString longvid)



    (* Categorisation of atomic expressions and patterns *)

    datatype 'a FixityCategory = NONFIX of 'a
                               | INFIX  of InfStatus * VId * Info

    fun isInfix J (longvid) =
        LongVId.isUnqualified longvid andalso
        VIdMap.find(J, LongVId.toId longvid) <> NONE

    fun categoriseLongVId J (atomic, I, longvid) =
        if LongVId.isUnqualified longvid then
            let
                val vid = LongVId.toId longvid
            in
                case VIdMap.find(J, vid)
                  of NONE           => NONFIX(atomic)
                   | SOME infstatus => INFIX(infstatus, vid, I)
            end
        else
            NONFIX(atomic)

    fun categoriseAtExp J (atexp as LONGVIDAtExp(I, SANSOp, longvid)) =
            categoriseLongVId J (atexp, I, longvid)
      | categoriseAtExp J (atexp) = NONFIX(atexp)

    fun categoriseAtPat J (atpat as LONGVIDAtPat(I, SANSOp, longvid)) =
            categoriseLongVId J (atpat, I, longvid)
      | categoriseAtPat J (atpat) = NONFIX(atpat)



    (* Resolving infixing [Section 2.6] *)

    fun parse(app, infapp, es) =
        let
            fun loop(NONFIX(e)::[], []) = e

              | loop(NONFIX(e2)::NONFIX(e1)::s', i) =
                    (* reduce nonfix application *)
                    loop(NONFIX(app(e1, e2))::s', i)

              | loop(s, NONFIX(e)::i') =
                    (* shift *)
                    loop(NONFIX(e)::s, i')

              | loop(s as NONFIX(e)::[], INFIX(x)::i') =
                    (* shift *)
                    loop(INFIX(x)::s, i')

              | loop(NONFIX(e2)::INFIX(_,vid,_)::NONFIX(e1)::s', []) =
                    (* reduce infix application *)
                    loop(NONFIX(infapp(e1, vid, e2))::s', [])

              | loop(s as NONFIX(e2)::INFIX((a1,p1),vid1,I1)::NONFIX(e1)::s',
                       i as INFIX(x2 as ((a2,p2),vid2,I2))::i') =
                if p1 > p2 then
                    (* reduce infix application *)
                    loop(NONFIX(infapp(e1, vid1, e2))::s', i)
                else if p1 < p2 then
                    (* shift *)
                    loop(INFIX(x2)::s, i')
                else if a1 <> a2 then
                    error(Source.over(I1,I2), "conflicting infix associativity")
                else if a1 = LEFT then
                    (* reduce infix application *)
                    loop(NONFIX(infapp(e1, vid1, e2))::s', i)
                else (* a1 = RIGHT *)
                    (* shift *)
                    loop(INFIX(x2)::s, i')

              | loop(INFIX(_, vid, I)::s, []) =
                    errorVId(I, "misplaced infix identifier ", vid)

              | loop(INFIX(x)::s, INFIX(_, vid, I)::i) =
                    errorVId(I, "misplaced infix identifier ", vid)

              | loop([], INFIX(_, vid, I)::i) =
                    errorVId(I, "misplaced infix identifier ", vid)

              | loop _ = raise Fail "Infix.parse: inconsistency"
        in
            loop([], es)
        end


    (* Resolving infixed expressions [Section 2.6] *)

    fun atexpExp(PARAtExp(_, exp)) = exp
      | atexpExp atexp             = ATEXPExp(infoAtExp atexp, atexp)

    fun appExp(atexp1, atexp2) =
        let
            val I1 = infoAtExp atexp1
            val I2 = infoAtExp atexp2
            val I  = Source.over(I1, I2)
        in
            PARAtExp(I, APPExp(I, atexpExp atexp1, atexp2))
        end

    fun pairExp(atexp1, atexp2) =
        let
            val I1      = infoAtExp atexp1
            val I2      = infoAtExp atexp2
            val lab1    = Lab.fromInt 1
            val lab2    = Lab.fromInt 2
            val exprow2 = ExpRow(I2, lab2, atexpExp atexp2, NONE)
            val exprow1 = ExpRow(I1, lab1, atexpExp atexp1, SOME exprow2)
        in
            RECORDAtExp(Source.over(I1,I2), SOME exprow1)
        end

    fun infappExp(atexp1, vid, atexp2) =
        let
            val Ivid    = Source.between(infoAtExp atexp1, infoAtExp atexp2)
            val longvid = LongVId.fromId vid
            val atexp1' = LONGVIDAtExp(Ivid, SANSOp, longvid)
            val atexp2' = pairExp(atexp1, atexp2)
        in
            appExp(atexp1', atexp2')
        end


    fun parseExp(J, atexps) =
        let
            val atexp = parse(appExp, infappExp,
                              List.map (categoriseAtExp J) atexps)
        in
            atexpExp atexp
        end


    (* Resolving infixed patterns [Section 2.6] *)

    fun atpatPat(PARAtPat(_, pat)) = pat
      | atpatPat atpat             = ATPATPat(infoAtPat atpat, atpat)

    fun conPat(LONGVIDAtPat(I1, op_opt, longvid), atpat) =
        let
            val I2 = infoAtPat atpat
            val I  = Source.over(I1, I2)
        in
            PARAtPat(I, CONPat(I, op_opt, longvid, atpat))
        end

      | conPat(_, atpat) =
            error(infoAtPat atpat, "misplaced atomic pattern")

    fun pairPat(atpat1, atpat2) =
        let
            val I1      = infoAtPat atpat1
            val I2      = infoAtPat atpat2
            val lab1    = Lab.fromInt 1
            val lab2    = Lab.fromInt 2
            val patrow2 = ROWPatRow(I2, lab2, atpatPat atpat2, NONE)
            val patrow1 = ROWPatRow(I1, lab1, atpatPat atpat1, SOME patrow2)
        in
            RECORDAtPat(Source.over(I1,I2), SOME patrow1)
        end

    fun infconPat(atpat1, vid, atpat2) =
        let
            val Ivid    = Source.between(infoAtPat atpat1, infoAtPat atpat2)
            val longvid = LongVId.fromId vid
            val atpat1' = LONGVIDAtPat(Ivid, SANSOp, longvid)
            val atpat2' = pairPat(atpat1, atpat2)
        in
            conPat(atpat1', atpat2')
        end


    fun parsePat(J, atpats) =
        let
            val atpat = parse(conPat, infconPat,
                              List.map (categoriseAtPat J) atpats)
        in
            atpatPat atpat
        end


    (* Resolving fun match rules [Figure 21, note] *)

    fun parseFmrule(J, atpats) =
        (*
         * Allowed is the following:
         * (1) <op> vid atpat+
         * (2) (atpat infix_vid atpat) atpat*
         * (3) atpat infix_vid atpat
         *)
        let
            fun checkNonfixity []           = true
              | checkNonfixity(NONFIX _::t) = checkNonfixity t
              | checkNonfixity(INFIX(_, vid, I)::t) =
                    errorVId(I, "misplaced infix identifier ", vid)

            fun maybeNonfixClause(ps) =
                case List.hd atpats
                  of LONGVIDAtPat(I, op_opt, longvid) =>
                        if not(LongVId.isUnqualified longvid) then
                            errorLongVId(I, "misplaced long identifier ",
                                         longvid)
                        else if List.length atpats < 2 then
                            error(I, "missing function arguments")
                        else
                            ( checkNonfixity ps (* including 1st *)
                            ; ( op_opt, LongVId.toId longvid, List.tl atpats )
                            )
                   | WILDCARDAtPat(I) =>
                        error(I, "misplaced wildcard pattern")
                   | SCONAtPat(I, _) =>
                        error(I, "misplaced constant pattern")
                   | RECORDAtPat(I, _) =>
                        error(I, "misplaced record or tuple pattern")
                   | PARAtPat(I, _) =>
                        error(I, "misplaced parenthesised pattern")

            fun maybeParenthesisedInfixClause(ps) =
                case List.hd ps
                  of NONFIX(PARAtPat(_, CONPat(I, SANSOp, longvid, atpat))) =>
                        if not(LongVId.isUnqualified longvid) then
                            errorLongVId(I, "misplaced long identifier ",
                                         longvid)
                        else if not(isInfix J longvid) then
                            error(I, "misplaced non-infix pattern")
                        else
                            (* Now, longvid has infix status but is sans `op',
                               so it can only result from resolving an
                               appropriate infix construction. *)
                            ( checkNonfixity(List.tl ps)
                            ; ( SANSOp, LongVId.toId longvid,
                                atpat::List.tl atpats )
                            )

                   | NONFIX(PARAtPat(_, pat)) =>
                        error(infoPat pat, "misplaced non-infix pattern")

                   | _ => maybeNonfixClause(ps)

            fun maybePlainInfixClause(ps) =
                case ps
                  of [NONFIX atpat1, INFIX(_, vid, I), NONFIX atpat2] =>
                         ( SANSOp, vid, pairPat(atpat1, atpat2)::[] )

                   | _ => maybeParenthesisedInfixClause(ps)
        in
            maybePlainInfixClause(List.map (categoriseAtPat J) atpats)
        end

  end
(* stop of Infix.sml *)
(* start of INITIAL_INFIX_ENV.sml *)
(*
 * Standard ML initial infix environment
 *
 * Definition, Appendix C
 *)

signature INITIAL_INFIX_ENV =
  sig

    (* Import type *)

    type InfEnv = Infix.InfEnv

    (* Export *)

    val J0:  InfEnv

  end
(* stop of INITIAL_INFIX_ENV.sml *)
(* start of InitialInfixEnv.sml *)
(*
 * Standard ML initial infix environment
 *
 * Definition, Appendix C
 *)

structure InitialInfixEnv :> INITIAL_INFIX_ENV =
  struct

    (* Import type *)

    type InfEnv = Infix.InfEnv

    (* Value identifiers *)

    val vidCons   = VId.fromString "::"
    val vidEqual  = VId.fromString "="
    val vidAssign = VId.fromString ":="

    (* Export *)

    val J0 = VIdMap.fromList[(vidCons,   (Infix.RIGHT, 5)),
                             (vidEqual,  (Infix.LEFT,  4)),
                             (vidAssign, (Infix.LEFT,  3))]
  end
(* stop of InitialInfixEnv.sml *)
(* start of BASIS.sml *)
(*
 * Standard ML combined basis
 *
 * Definition, section 8
 *)

signature BASIS =
  sig

    (* Import types *)

    type StaticBasis  = StaticBasis.Basis               (* [B_STAT] *)
    type DynamicBasis = DynamicBasis.Basis              (* [B_DYN] *)

    (* Type [Section 8] *)

    type Basis = StaticBasis * DynamicBasis             (* [B] *)


    (* Operations *)

    val B_STATof:       Basis -> StaticBasis
    val B_DYNof:        Basis -> DynamicBasis

    val oplus:          Basis * Basis -> Basis

  end
(* stop of BASIS.sml *)
(* start of Basis.sml *)
(*
 * Standard ML combined basis
 *
 * Definition, section 8
 *)

structure Basis :> BASIS =
  struct

    (* Import types *)

    type StaticBasis  = StaticBasis.Basis               (* [B_STAT] *)
    type DynamicBasis = DynamicBasis.Basis              (* [B_DYN] *)

    (* Type [Section 8] *)

    type Basis = StaticBasis * DynamicBasis             (* [B] *)


    (* Projections *)

    fun B_STATof (B_STAT,B_DYN) = B_STAT
    fun B_DYNof  (B_STAT,B_DYN) = B_DYN


    (* Modification [Section 4.3] *)

    infix oplus

    fun (B_STAT,B_DYN) oplus (B_STAT',B_DYN') =
            ( StaticBasis.plus(B_STAT, B_STAT')
            , DynamicBasis.plus(B_DYN, B_DYN')
            )

  end
(* stop of Basis.sml *)
(* start of PACK.sml *)
(*
 * Standard ML exception packets
 *
 * Definition, section 6.2
 *)


signature PACK =
  sig

    (* Import *)

    type 'a ExVal   = 'a Val.ExVal
    type FcnClosure = DynamicEnv.FcnClosure


    (* Definitions [Section 6.2] *)

    type Pack = FcnClosure ExVal                        (* [p] *)

    exception Pack of Pack

  end
(* stop of PACK.sml *)
(* start of Pack.sml *)
(*
 * Standard ML exception packets
 *
 * Definition, section 6.2
 *)


structure Pack :> PACK =
  struct

    (* Import *)

    type 'a ExVal   = 'a Val.ExVal
    type FcnClosure = DynamicEnv.FcnClosure


    (* Definitions [Section 6.2] *)

    type Pack = FcnClosure ExVal                        (* [p] *)

    exception Pack of Pack

  end
(* stop of Pack.sml *)
(* start of BASVAL.sml *)
(*
 * Standard ML basic values
 *
 * Definition, section 6.4
 *)


signature BASVAL =
  sig 

    (* Import *)

    type BasVal = Val.BasVal
    type 'a Val = 'a Val.Val

    exception Pack of Pack.Pack (* = Pack.Pack *)


    (* Operations *)

    exception TypeError

    val APPLY:     BasVal * 'a Val -> 'a Val (* / Pack *)

    val toString:  BasVal -> string

  end
(* stop of BASVAL.sml *)
(* start of BasVal.sml *)
(*
 * Standard ML basic values
 *
 * Definition, section 6.4
 *)


structure BasVal :> BASVAL =
  struct

    (* Import *)

    type BasVal = Val.BasVal
    type 'a Val = 'a Val.Val

    exception Pack = Pack.Pack


    (* Conversions *)

    fun toString b = b


    (* Application of basic values *)

    exception TypeError

    fun APPLY("=", v) =
        (case Val.unpair v
           of SOME vv => Val.toBoolVal(Val.equal vv)
            | NONE    => raise TypeError
        )
      | APPLY _ = raise Fail "BasVal.APPLY: unknown basic value"

  end
(* stop of BasVal.sml *)
(* start of EVAL_CORE.sml *)
(*
 * Standard ML core evaluation
 *
 * Definition, section 6.7
 *
 * Notes:
 *   - State is passed as reference and modified via side effects. This way
 *     expanding out of the state and exception convention in the inference
 *     rules can be avoided (would really be a pain). Note that the state
 *     therefore never is returned.
 *   - Doing so, we can model the exception convention using exceptions.
 *)


signature EVAL_CORE =
  sig

    (* Import types *)

    type Dec   = GrammarCore.Dec
    type Env   = DynamicEnv.Env
    type State = DynamicEnv.FcnClosure State.State

    (* Export *)

    val evalDec: State ref * Env * Dec -> Env

  end
(* stop of EVAL_CORE.sml *)
(* start of EvalCore.sml *)
(*
 * Standard ML core evaluation
 *
 * Definition, sections 6.7 and 6.2
 *
 * Notes:
 *   - State is passed as reference and modified via side effects. This way
 *     expanding out the state and exception convention in the inference rules
 *     can be avoided (would really be a pain). Note that the state therefore
 *     never is returned.
 *   - Doing so, we can model the exception convention using exceptions.
 *     Rules of the form A |- phrase => A'/p therefore turn into
 *     A |- phrase => A'.
 *   - We only pass the state where necessary.
 *   - Special constants have already been evaluated inside the Lexer.
 *)

structure EvalCore :> EVAL_CORE =
  struct

    (* Import *)

    type Dec   = GrammarCore.Dec
    type Env   = DynamicEnv.Env
    type State = DynamicEnv.FcnClosure State.State

    exception Pack = Pack.Pack

    open GrammarCore


    (* Some helpers for error messages *)

    val error = Error.error

    fun errorLab(I, s, lab)         = error(I, s ^ Lab.toString lab)
    fun errorLongVId(I, s, longvid) = error(I, s ^ LongVId.toString longvid)
    fun errorLongTyCon(I, s, longtycon) =
            error(I, s ^ LongTyCon.toString longtycon)
    fun errorLongStrId(I, s, longstrid) =
            error(I, s ^ LongStrId.toString longstrid)


    (* Helpers for environment modification *)

    val plus        = DynamicEnv.plus
    val plusVE      = DynamicEnv.plusVE
    val plusTE      = DynamicEnv.plusTE
    val plusVEandTE = DynamicEnv.plusVEandTE

    infix plus plusVE plusTE plusVEandTE



    (* Evaluating special constants [Section 6.2] *)

    fun valSCon(SCon.INT n)    = Val.SVal(SVal.INT n)
      | valSCon(SCon.WORD w)   = Val.SVal(SVal.WORD w)
      | valSCon(SCon.CHAR c)   = Val.SVal(SVal.CHAR c)
      | valSCon(SCon.REAL x)   = Val.SVal(SVal.REAL x)
      | valSCon(SCon.STRING s) = Val.SVal(SVal.STRING s)


    (* Inference rules [Section 6.7] *)

    exception FAIL


    (* Atomic Expressions *)

    fun evalAtExp(s,E, SCONAtExp(I, scon)) =
        (* [Rule 90] *)
        valSCon scon

      | evalAtExp(s,E, LONGVIDAtExp(I, _, longvid)) =
        (* [Rule 91] *)
        let
            val (v,is) = case DynamicEnv.findLongVId(E, longvid)
                           of SOME valstr => valstr
                            | NONE =>
                              errorLongVId(I, "runtime error: \
                                              \unknown identifier ", longvid)
        in
            v
        end

      | evalAtExp(s,E, RECORDAtExp(I, exprow_opt)) =
        (* [Rule 92] *)
        let
            val r = case exprow_opt
                      of NONE        => LabMap.empty
                       | SOME exprow => evalExpRow(s,E, exprow)
        in
            Val.Record r
        end

      | evalAtExp(s,E, LETAtExp(I, dec, exp)) =
        (* [Rule 93] *)
        let
            val E' = evalDec(s,E, dec)
            val v  = evalExp(s,E plus E', exp)
        in
            v
        end

      | evalAtExp(s,E, PARAtExp(I, exp)) =
        (* [Rule 94] *)
        let
            val v = evalExp(s,E, exp)
        in
            v
        end


    (* Expression Rows *)

    and evalExpRow(s,E, ExpRow(I, lab, exp, exprow_opt)) =
        (* [Rule 95] *)
        let
            val v = evalExp(s,E, exp)
            val r = case exprow_opt
                      of NONE        => LabMap.empty
                       | SOME exprow => evalExpRow(s,E, exprow)
        in
            LabMap.insert(r, lab, v)
        end


    (* Expressions *)

    and evalExp(s,E, ATEXPExp(I, atexp)) =
        (* [Rule 96] *)
        let
            val v = evalAtExp(s,E, atexp)
        in
            v
        end

      | evalExp(s,E, APPExp(I, exp, atexp)) =
        (* [Rules 97 to 103] *)
        let
            val v1 = evalExp(s,E, exp)
            val v  = evalAtExp(s,E, atexp)
        in
            case v1
              of Val.VId vid =>
                 if vid = VId.fromString "ref" then
                     (* [Rule 99] *)
                     let
                         val a = Addr.addr()
                     in
                          s := State.insertAddr(!s, a, v)
                        ; Val.Addr a
                     end
                 else
                     (* [Rule 97] *)
                     Val.VIdVal (vid,v)

               | Val.ExVal(Val.ExName en) =>
                 (* [Rule 98] *)
                 Val.ExVal(Val.ExNameVal(en,v))

               | Val.:= =>
                 (* [Rule 100] *)
                 (case Val.unpair v
                    of SOME(Val.Addr a, v) =>
                        ( s := State.insertAddr(!s, a, v)
                        ; Val.Record LabMap.empty
                        )
                     | _ => error(I, "runtime type error: address expected")
                 )

               | Val.BasVal b =>
                 (* [Rule 101] *)
                 BasVal.APPLY(b, v)

               | Val.FcnClosure(DynamicEnv.FcnClosure(match,E',VE)) =>
                 (* [Rule 102] *)
                 (let
                     val v' = evalMatch(s,E' plusVE DynamicEnv.Rec VE, v, match)
                  in
                     v'
                  end
                  handle FAIL =>
                     (* [Rule 103] *)
                     raise Pack(Val.ExName InitialDynamicEnv.enMatch)
                 )
               | _ =>
                 error(I, "runtime type error: applicative value expected")
        end

      | evalExp(s,E, TYPEDExp(I, exp, _)) =
        (* Omitted [Section 6.1] *)
        evalExp(s,E, exp)

      | evalExp(s,E, HANDLEExp(I, exp, match)) =
        (* [Rule 104 to 106] *)
        (let
            val v = evalExp(s,E, exp)
         in
            (* [Rule 104] *)
            v
         end
         handle Pack.Pack e =>
            let
                val v = evalMatch(s,E,Val.ExVal e, match)
            in
                (* [Rule 105] *)
                v
            end
            handle FAIL =>
                (* [Rule 106] *)
                raise Pack.Pack e
        )

      | evalExp(s,E, RAISEExp(I, exp)) =
        (* [Rule 107] *)
        let
            val e = case evalExp(s,E, exp)
                      of Val.ExVal e => e
                       | _ => error(I, "runtime type error: \
                                       \exception value expected")
        in
            raise Pack.Pack e
        end

      | evalExp(s,E, FNExp(I, match)) =
        (* [Rule 108] *)
        Val.FcnClosure(DynamicEnv.FcnClosure(match,E,VIdMap.empty))


    (* Matches *)

    and evalMatch(s,E,v, Match(I, mrule, match_opt)) =
        (* [Rules 109 to 111] *)
        let
            val v' = evalMrule(s,E,v, mrule)
        in
            (* [Rule 109] *)
            v'
        end
        handle FAIL =>
            case match_opt
              of NONE =>
                 (* [Rule 110] *)
                 raise FAIL

               | SOME match =>
                 (* [Rule 111] *)
                 let
                     val v' = evalMatch(s,E,v, match)
                 in
                     v'
                 end


    (* Match rules *)

    and evalMrule(s,E,v, Mrule(I, pat, exp)) =
        (* [Rules 112 and 113] *)
        let
            val VE = evalPat(s,E,v, pat)
            (* [Rule 112] *)
            val v' = evalExp(s,E plusVE VE, exp)
        in
            v'
        end
        (* FAIL on evalPat propagates through [Rule 113] *)


    (* Declarations *)

    and evalDec(s,E, VALDec(I, tyvarseq, valbind)) =
        (* [Rule 114] *)
        let
            val VE = evalValBind(s,E, valbind)
        in
            DynamicEnv.fromVE VE
        end

      | evalDec(s,E, TYPEDec(I, typbind)) =
        (* [Rule 115] *)
        let
            val TE = evalTypBind(typbind)
        in
            DynamicEnv.fromTE TE
        end

      | evalDec(s,E, DATATYPEDec(I, datbind)) =
        (* [Rule 116] *)
        let
            val (VE,TE) = evalDatBind(datbind)
        in
            DynamicEnv.fromVEandTE(VE,TE)
        end

      | evalDec(s,E, REPLICATIONDec(I, tycon, longtycon)) =
        (* [Rule 117] *)
        let
            val VE = case DynamicEnv.findLongTyCon(E, longtycon)
                       of SOME VE => VE
                        | NONE =>
                          errorLongTyCon(I, "runtime error: unknown type ",
                                            longtycon)
        in
            DynamicEnv.fromVEandTE(VE, TyConMap.singleton(tycon, VE))
        end

      | evalDec(s,E, ABSTYPEDec(I, datbind, dec)) =
        (* [Rule 118] *)
        let
            val (VE,TE) = evalDatBind(datbind)
            val    E'   = evalDec(s,E plusVEandTE (VE,TE), dec)
        in
            E'
        end

      | evalDec(s,E, EXCEPTIONDec(I, exbind)) =
        (* [Rule 119] *)
        let
            val VE = evalExBind(s,E, exbind)
        in
            DynamicEnv.fromVE VE
        end

      | evalDec(s,E, LOCALDec(I, dec1, dec2)) =
        (* [Rule 120] *)
        let
            val E1 = evalDec(s,E, dec1)
            val E2 = evalDec(s,E plus E1, dec2)
        in
            E2
        end

      | evalDec(s,E, OPENDec(I, longstrids)) =
        (* [Rule 121] *)
        let
            val Es =
                List.map
                    (fn longstrid =>
                        case DynamicEnv.findLongStrId(E, longstrid)
                          of SOME(DynamicEnv.Str E) => E
                           | NONE =>
                             errorLongStrId(I, "runtime error: unknown \
                                               \structure ", longstrid) )
                    longstrids
        in
            List.foldl DynamicEnv.plus DynamicEnv.empty Es
        end

      | evalDec(s,E, EMPTYDec(I)) =
        (* [Rule 122] *)
        DynamicEnv.empty

      | evalDec(s,E, SEQDec(I, dec1, dec2)) =
        (* [Rule 123] *)
        let
            val E1 = evalDec(s,E, dec1)
            val E2 = evalDec(s,E plus E1, dec2)
        in
            E1 plus E2
        end


    (* Value Bindings *)

    and evalValBind(s,E, PLAINValBind(I, pat, exp, valbind_opt)) =
        (* [Rule 124 and 125] *)
        (let
            val v   = evalExp(s,E, exp)
            val VE  = evalPat(s,E,v, pat)
            (* [Rule 124] *)
            val VE' = case valbind_opt
                        of NONE         => VIdMap.empty
                         | SOME valbind => evalValBind(s,E, valbind)
         in
            VIdMap.unionWith #2 (VE, VE')
         end
         handle FAIL =>
            (* [Rule 125] *)
            raise Pack.Pack(Val.ExName InitialDynamicEnv.enBind)
        )

      | evalValBind(s,E, RECValBind(I, valbind)) =
        (* [Rule 126] *)
        let
            val VE = evalValBind(s,E, valbind)
        in
            DynamicEnv.Rec VE
        end


    (* Type Bindings *)

    and evalTypBind(TypBind(I, tyvarseq, tycon, ty, typbind_opt)) =
        (* [Rule 127] *)
        let
            val TE = case typbind_opt
                       of NONE         => TyConMap.empty
                        | SOME typbind => evalTypBind(typbind)
        in
            TyConMap.insert(TE, tycon, VIdMap.empty)
        end


    (* Datatype Bindings *)

    and evalDatBind(DatBind(I, tyvarseq, tycon, conbind, datbind_opt)) =
        (* [Rule 128] *)
        let
            val  VE       = evalConBind(conbind)
            val (VE',TE') = case datbind_opt
                              of NONE          => ( VIdMap.empty, TyConMap.empty )
                               | SOME datbind' => evalDatBind(datbind')
        in
            ( VIdMap.unionWith #2 (VE, VE')
            , TyConMap.insert(TE', tycon, VE)
            )
        end


    (* Constructor Bindings *)

    and evalConBind(ConBind(I, _, vid, _, conbind_opt)) =
        (* [Rule 129] *)
        let
            val VE = case conbind_opt
                       of NONE         => VIdMap.empty
                        | SOME conbind => evalConBind(conbind)
        in
            VIdMap.insert(VE, vid, (Val.VId vid,IdStatus.c))
        end


    (* Exception Bindings *)

    and evalExBind(s,E, NEWExBind(I, _, vid, _, exbind_opt)) =
        (* [Rule 130] *)
        let
            val en = ExName.exname vid
            val VE = case exbind_opt
                       of NONE        => VIdMap.empty
                        | SOME exbind => evalExBind(s,E, exbind)
        in
            s := State.insertExName(!s, en)
          ; VIdMap.insert(VE, vid, (Val.ExVal(Val.ExName en),IdStatus.e))
        end

      | evalExBind(s,E, EQUALExBind(I, _, vid, _, longvid, exbind_opt)) =
        (* [Rule 131] *)
        let
            val en = case DynamicEnv.findLongVId(E, longvid)
                       of SOME(en,IdStatus.e) => en
                        | SOME _ =>
                          errorLongVId(I, "runtime error: non-exception \
                                          \identifier ", longvid)
                        | NONE =>
                          errorLongVId(I, "runtime error: unknown identifier ",
                                          longvid)
            val VE = case exbind_opt
                       of NONE        => VIdMap.empty
                        | SOME exbind => evalExBind(s,E, exbind)
        in
            VIdMap.insert(VE, vid, (en,IdStatus.e))
        end


    (* Atomic Patterns *)

    and evalAtPat(s,E,v, WILDCARDAtPat(I)) =
        (* [Rule 132] *)
        VIdMap.empty

      | evalAtPat(s,E,v, SCONAtPat(I, scon)) =
        (* [Rule 133 and 134] *)
        (case v
           of Val.SVal sv =>
              if Val.equal(v, valSCon(scon)) then
                 (* [Rule 133] *)
                 VIdMap.empty
              else
                 (* [Rule 134] *)
                 raise FAIL

            | _ => error(I, "runtime type error: special constant expected")
        )

      | evalAtPat(s,E,v, LONGVIDAtPat(I, _, longvid)) =
        (* [Rule 135 to 137] *)
        let
            val (strids,vid) = LongVId.explode longvid
        in
            if List.null strids andalso
               ( case DynamicEnv.findVId(E, vid)
                   of NONE       => true
                    | SOME(_,is) => is = IdStatus.v ) then
                (* [Rule 135] *)
                VIdMap.singleton(vid, (v,IdStatus.v))
            else
                let
                    val (v',is) = case DynamicEnv.findLongVId(E, longvid)
                                    of SOME valstr => valstr
                                     | NONE =>
                                        errorLongVId(I,"runtime error: \
                                                       \unknown constructor ",
                                                        longvid)
                in
                    if Val.equal(v, v') then
                        (* [Rule 136] *)
                        VIdMap.empty
                    else
                        (* [Rule 137] *)
                        raise FAIL
                end
        end

      | evalAtPat(s,E,v, RECORDAtPat(I, patrow_opt)) =
        (* [Rule 138] *)
        let
            val r  = case v
                       of Val.Record r => r
                        | _ =>
                          error(I, "runtime type error: record expected")

            val VE = case patrow_opt
                       of NONE        =>
                          if LabMap.isEmpty r then
                             VIdMap.empty
                          else
                             error(I, "runtime type error: \
                                      \empty record expected")

                        | SOME patrow =>
                              evalPatRow(s,E,r, patrow)
        in
            VE
        end

      | evalAtPat(s,E,v, PARAtPat(I, pat)) =
        (* [Rule 139] *)
        let
            val VE = evalPat(s,E,v, pat)
        in
            VE
        end


    (* Pattern Rows *)

    and evalPatRow(s,E,r, WILDCARDPatRow(I)) =
        (* [Rule 140] *)
        VIdMap.empty

      | evalPatRow(s,E,r, ROWPatRow(I, lab, pat, patrow_opt)) =
        (* [Rule 141 and 142] *)
        let
            val v   = case LabMap.find(r, lab)
                        of SOME v => v
                         | _ => errorLab(I, "runtime type error: \
                                            \unmatched label ", lab)
            val VE  = evalPat(s,E,v, pat)
            (* [Rule 142] *)
            val VE' = case patrow_opt
                        of NONE        => VIdMap.empty
                         | SOME patrow => evalPatRow(s,E,r, patrow)
        in
            VIdMap.unionWithi #2 (VE, VE')
        end
        (* FAIL on evalPat propagates through [Rule 142] *)


    (* Patterns *)

    and evalPat(s,E,v, ATPATPat(I, atpat)) =
        (* [Rule 143] *)
        let
            val VE = evalAtPat(s,E,v, atpat)
        in
            VE
        end

      | evalPat(s,E,v, CONPat(I, _, longvid, atpat)) =
        (* [Rules 144 to 148] *)
        (case (DynamicEnv.findLongVId(E, longvid), v)
           of ( SOME(Val.VId vid, IdStatus.c),
                     Val.VIdVal(vid',v') ) =>   
                 if vid = VId.fromString "ref" then
                    error(I, "runtime type error: address expected")
                 else if vid = vid' then
                    (* [Rule 144] *)
                    let
                        val VE = evalAtPat(s,E,v', atpat)
                    in
                        VE
                    end
                 else
                    (* [Rule 145] *)
                    raise FAIL

            | ( SOME(Val.ExVal(Val.ExName en),IdStatus.e),
                     Val.ExVal(Val.ExNameVal(en',v')) ) =>      
                 if en = en' then
                    (* [Rule 146] *)
                    let
                        val VE = evalAtPat(s,E,v', atpat)
                    in
                        VE
                    end
                 else
                    (* [Rule 147] *)
                    raise FAIL

            | ( SOME(Val.VId vid, IdStatus.c),
                     Val.Addr a ) =>    
                 if vid = VId.fromString "ref" then
                    (* [Rule 148] *)
                    let
                        val v =  case State.findAddr(!s, a)
                                   of SOME v => v
                                    | NONE   =>
                                      raise Fail "EvalCore.evalPat: \
                                                 \invalid address"
                        val VE = evalAtPat(s,E,v, atpat)
                    in
                        VE
                    end
                else
                    error(I, "runtime type error: reference expected")

            | _ =>
                 error(I, "runtime type error: constructor expected")
        )

      | evalPat(s,E,v, TYPEDPat(I, pat, _)) =
        (* Omitted [Section 6.1] *)
        evalPat(s,E,v, pat)

      | evalPat(s,E,v, ASPat(I, _, vid, _, pat)) =
        (* [Rule 149] *)
        let
            val VE = evalPat(s,E,v, pat)
        in
            VIdMap.insert(VE, vid, (v,IdStatus.v))
        end

  end
(* stop of EvalCore.sml *)
(* start of INTBASIS.sml *)
(*
 * Standard ML interface basis
 *
 * Definition, section 7.2
 *)

signature INTBASIS =
  sig

    (* Import types *)

    type SigId       = SigId.Id
    type longTyCon   = LongTyCon.longId
    type Basis       = DynamicBasis.Basis
    type SigEnv      = DynamicBasis.SigEnv
    type Env         = DynamicEnv.Env
    type Int         = Interface.Int
    type ValInt      = Interface.ValInt

    type 'a SigIdMap = 'a SigIdMap.map


    (* Types [Section 7.2] *)

    type IntBasis = SigEnv * Int                                (* [IB] *)


    (* Operations *)

    val Inter:          Basis -> IntBasis

    val plusI:          IntBasis * Int    -> IntBasis

    val findSigId:      IntBasis * SigId     -> Int option
    val findLongTyCon:  IntBasis * longTyCon -> ValInt option
 
  end
(* stop of INTBASIS.sml *)
(* start of IntBasis.sml *)
(*
 * Standard ML interface basis
 *
 * Definition, section 7.2
 *)


structure IntBasis :> INTBASIS =
  struct

    (* Import types *)

    type SigId       = SigId.Id
    type longTyCon   = LongTyCon.longId
    type Basis       = DynamicBasis.Basis
    type SigEnv      = DynamicBasis.SigEnv
    type Env         = DynamicEnv.Env
    type Int         = Interface.Int
    type ValInt      = Interface.ValInt

    type 'a SigIdMap = 'a SigIdMap.map


    (* Types [Section 7.2] *)

    type IntBasis = SigEnv * Int                                (* [IB] *)


    (* Injections [Section 7.2] *)

    fun Inter (F,G,E) = (G, Interface.Inter E)


    (* Modifications [Sections 4.3 and 7.2] *)

    infix plusI

    fun (G,I) plusI I'  = ( G, Interface.plus(I,I') )


    (* Application (lookup) [Sections 7.2 and 4.3] *)

    fun findSigId((G,I), sigid) = SigIdMap.find(G, sigid)

    fun findLongTyCon((G,I), longtycon) = Interface.findLongTyCon(I, longtycon)

  end
(* stop of IntBasis.sml *)
(* start of EVAL_MODULE.sml *)
(*
 * Standard ML modules evaluation
 *
 * Definition, section 7.3
 *
 * Notes:
 *   - State is passed as reference and modified via side effects. This way
 *     expanding out the state and exception convention in the inference rules
 *     can be avoided (would really be a pain). Note that the state therefore
 *     never is returned.
 *   - Doing so, we can model the exception convention using exceptions.
 *)

signature EVAL_MODULE =
  sig

    (* Import types *)

    type TopDec = GrammarModule.TopDec
    type Basis  = DynamicBasis.Basis
    type State  = EvalCore.State


    (* Export *)

    val evalTopDec:  State ref * Basis * TopDec -> Basis

  end
(* stop of EVAL_MODULE.sml *)
(* start of EvalModule.sml *)
(*
 * Standard ML modules evaluation
 *
 * Definition, section 7.3
 *
 * Notes:
 *   - State is passed as reference and modified via side effects. This way
 *     expanding out the state and exception convention in the inference rules
 *     can be avoided (would really be a pain). Note that the state therefore
 *     never is returned.
 *   - Doing so, we can model the exception convention using exceptions.
 *     Rules of the form A |- phrase => A'/p therefore turn into
 *     A |- phrase => A'.
 *   - We only pass the state where necessary, ie. strexp, strdec, strbind, and
 *     topdec (compare note in [Section 7.3]).
 *   - There is a typo in the Definition in rule 182: both occurances of IB
 *     should be replaced by B.
 *   - The rules for toplevel declarations are all wrong: in the conclusions,
 *     the result right of the arrow must be B' <+ B''> instead of B'<'> in
 *     all three rules.
 *)

structure EvalModule :> EVAL_MODULE =
  struct

    (* Import *)

    type TopDec = GrammarModule.TopDec
    type Basis  = DynamicBasis.Basis
    type State  = EvalCore.State


    open GrammarModule


    (* Helpers for error messages *)

    val error = Error.error

    fun errorSigId(I, s, sigid) = error(I, s ^ SigId.toString sigid)
    fun errorFunId(I, s, funid) = error(I, s ^ FunId.toString funid)

    fun errorLongTyCon(I, s, longtycon) =
        error(I, s ^ LongTyCon.toString longtycon)
    fun errorLongStrId(I, s, longstrid) =
        error(I, s ^ LongStrId.toString longstrid)


    (* Helpers for basis modification *)

    val plus    = DynamicBasis.plus
    val plusSE  = DynamicBasis.plusSE
    val plusG   = DynamicBasis.plusG
    val plusF   = DynamicBasis.plusF
    val plusE   = DynamicBasis.plusE

    infix plus plusG plusF plusE plusSE



    (* Inference rules [Section 7.3] *)


    (* Structure Expressions *)

    fun evalStrExp(s,B, STRUCTStrExp(I, strdec)) =
        (* [Rule 150] *)
        let
            val E = evalStrDec(s,B, strdec)
        in
            E
        end

      | evalStrExp(s,B, LONGSTRIDStrExp(I, longstrid)) =
        (* [Rule 151] *)
        let
            val E = case DynamicBasis.findLongStrId(B, longstrid)
                      of SOME(DynamicEnv.Str E) => E
                       | NONE =>
                         errorLongStrId(I, "runtime error: unknown structure ",
                                           longstrid)
        in
            E
        end

      | evalStrExp(s,B, TRANSStrExp(I, strexp, sigexp)) =
        (* [Rule 152] *)
        let
            val E = evalStrExp(s,B, strexp)
            val I = evalSigExp(IntBasis.Inter B, sigexp)
        in
            Interface.cutdown(E, I)
        end

      | evalStrExp(s,B, OPAQStrExp(I, strexp, sigexp)) =
        (* [Rule 153] *)
        let
            val E = evalStrExp(s,B, strexp)
            val I = evalSigExp(IntBasis.Inter B, sigexp)
        in
            Interface.cutdown(E, I)
        end

      | evalStrExp(s,B, APPStrExp(I, funid, strexp)) =
        (* [Rule 154] *)
        let
            val DynamicBasis.FunctorClosure((strid, I), strexp', B') =
                      case DynamicBasis.findFunId(B, funid)
                        of SOME funcclos => funcclos
                         | NONE => errorFunId(I, "runtime error: \
                                                 \unknown functor ", funid)
            val E  = evalStrExp(s,B, strexp)
            val E' = evalStrExp(
                        s,
                        B' plusSE
                            StrIdMap.singleton(strid, 
                                DynamicEnv.Str(Interface.cutdown(E, I))),
                        strexp')
        in
            E'
        end

      | evalStrExp(s,B, LETStrExp(I, strdec, strexp)) =
        (* [Rule 155] *)
        let
            val E  = evalStrDec(s,B, strdec)
            val E' = evalStrExp(s,B plusE E, strexp)
        in
            E'
        end


    (* Structure-level Declarations *)

    and evalStrDec(s,B, DECStrDec(I, dec)) =
        (* [Rule 156] *)
        let
            val E' = EvalCore.evalDec(s,DynamicBasis.Eof B, dec)
        in
            E'
        end

      | evalStrDec(s,B, STRUCTUREStrDec(I, strbind)) =
        (* [Rule 157] *)
        let
            val SE = evalStrBind(s,B, strbind)
        in
            DynamicEnv.fromSE SE
        end

      | evalStrDec(s,B, LOCALStrDec(I, strdec1, strdec2)) =
        (* [Rule 158] *)
        let
            val E1 = evalStrDec(s,B, strdec1)
            val E2 = evalStrDec(s,B plusE E1, strdec2)
        in
            E2
        end

      | evalStrDec(s,B, EMPTYStrDec(I)) =
        (* [Rule 159] *)
        DynamicEnv.empty

      | evalStrDec(s,B, SEQStrDec(I, strdec1, strdec2)) =
        (* [Rule 160] *)
        let
            val E1 = evalStrDec(s,B, strdec1)
            val E2 = evalStrDec(s,B plusE E1, strdec2)
        in
            DynamicEnv.plus(E1, E2)
        end


    (* Structure Bindings *)

    and evalStrBind(s,B, StrBind(I, strid, strexp, strbind_opt)) =
        (* [Rule 161] *)
        let
            val E  = evalStrExp(s,B, strexp)
            val SE = case strbind_opt
                       of NONE         => StrIdMap.empty
                        | SOME strbind => evalStrBind(s,B, strbind)
        in
            StrIdMap.insert(SE, strid, DynamicEnv.Str E)
        end


    (* Signature Expressions *)

    and evalSigExp(IB, SIGSigExp(I, spec)) =
        (* [Rule 162] *)
        let
            val I = evalSpec(IB, spec)
        in
            I
        end

      | evalSigExp(IB, SIGIDSigExp(I, sigid)) =
        (* [Rule 163] *)
        let
            val I = case IntBasis.findSigId(IB, sigid)
                      of SOME I => I
                       | NONE   => errorSigId(I, "runtime error: unknown \
                                                 \signature ",sigid)
        in
            I
        end

      | evalSigExp(IB, WHERETYPESigExp(I, sigexp, _, _, _)) =
        (* Omitted [Section 7.1] *)
        evalSigExp(IB, sigexp)


    (* Signature Declarations *)

    and evalSigDec(IB, SigDec(I, sigbind)) =
        (* [Rule 164] *)
        let
            val G = evalSigBind(IB, sigbind)
        in
            G
        end


    (* Signature Bindings *)

    and evalSigBind(IB, SigBind(I, sigid, sigexp, sigbind_opt)) =
        (* [Rule 165] *)
        let
            val I = evalSigExp(IB, sigexp)
            val G = case sigbind_opt
                      of NONE         => SigIdMap.empty
                       | SOME sigbind => evalSigBind(IB, sigbind)
        in
            SigIdMap.insert(G, sigid, I)
        end


    (* Specifications *)

    and evalSpec(IB, VALSpec(I, valdesc)) =
        (* [Rule 166] *)
        let
            val VI = evalValDesc(valdesc)
        in
            Interface.fromVI VI
        end

      | evalSpec(IB, TYPESpec(I, typdesc)) =
        (* [Rule 167] *)
        let
            val TI = evalTypDesc(typdesc)
        in
            Interface.fromTI TI
        end

      | evalSpec(IB, EQTYPESpec(I, typdesc)) =
        (* [Rule 168] *)
        let
            val TI = evalTypDesc(typdesc)
        in
            Interface.fromTI TI
        end

      | evalSpec(IB, DATATYPESpec(I, datdesc)) =
        (* [Rule 169] *)
        let
            val (VI,TI) = evalDatDesc(datdesc)
        in
            Interface.fromVIandTI(VI,TI)
        end

      | evalSpec(IB, REPLICATIONSpec(I, tycon, longtycon)) =
        (* [Rule 170] *)
        let
            val VI = case IntBasis.findLongTyCon(IB, longtycon)
                       of SOME VI => VI
                        | NONE => errorLongTyCon(I, "runtime error: \
                                                    \unknown type ", longtycon)
            val TI = TyConMap.singleton(tycon, VI)
        in
            Interface.fromVIandTI(VI,TI)
        end

      | evalSpec(IB, EXCEPTIONSpec(I, exdesc)) =
        (* [Rule 171] *)
        let
            val VI = evalExDesc(exdesc)
        in
            Interface.fromVI VI
        end

      | evalSpec(IB, STRUCTURESpec(I, strdesc)) =
        (* [Rule 172] *)
        let
            val SI = evalStrDesc(IB, strdesc)
        in
            Interface.fromSI SI
        end

      | evalSpec(IB, INCLUDESpec(I, sigexp)) =
        (* [Rule 173] *)
        let
            val I = evalSigExp(IB, sigexp)
        in
            I
        end

      | evalSpec(IB, EMPTYSpec(I)) =
        (* [Rule 174] *)
        Interface.empty

      | evalSpec(IB, SEQSpec(I, spec1, spec2)) =
        (* [Rule 77] *)
        let
            val I1 = evalSpec(IB, spec1)
            val I2 = evalSpec(IntBasis.plusI(IB, I1), spec2)
        in
            Interface.plus(I1,I2)
        end

      | evalSpec(IB, SHARINGTYPESpec(I, spec, longtycons)) =
        (* Omitted [Section 7.1] *)
        evalSpec(IB, spec)

      | evalSpec(IB, SHARINGSpec(I, spec, longstrids)) =
        (* Omitted [Section 7.1] *)
        evalSpec(IB, spec)


    (* Value Descriptions *)

    and evalValDesc(ValDesc(I, vid, _, valdesc_opt)) =
        (* [Rule 176] *)
        let
            val VI = case valdesc_opt
                       of NONE         => VIdMap.empty
                        | SOME valdesc => evalValDesc(valdesc)
        in
            VIdMap.insert(VI, vid, IdStatus.v)
        end


    (* Type Descriptions *)

    and evalTypDesc(TypDesc(I, tyvarseq, tycon, typdesc_opt)) =
        (* [Rule 177] *)
        let
            val TI = case typdesc_opt
                       of NONE         => TyConMap.empty
                        | SOME typdesc => evalTypDesc(typdesc)
        in
            TyConMap.insert(TI, tycon, VIdMap.empty)
        end


    (* Datatype Descriptions *)

    and evalDatDesc(DatDesc(I, tyvarseq, tycon, condesc, datdesc_opt)) =
        (* [Rule 178] *)
        let
            val  VI       = evalConDesc(condesc)
            val (VI',TI') = case datdesc_opt
                              of NONE          => ( VIdMap.empty, TyConMap.empty )
                               | SOME datdesc' => evalDatDesc(datdesc')
        in
            ( VIdMap.unionWith #2 (VI, VI')
            , TyConMap.insert(TI', tycon, VI)
            )
        end


    (* Constructor Descriptions *)

    and evalConDesc(ConDesc(I, vid, _, condesc_opt)) =
        (* [Rule 179] *)
        let
            val VI = case condesc_opt
                       of NONE         => VIdMap.empty
                        | SOME condesc => evalConDesc(condesc)
        in
            VIdMap.insert(VI, vid, IdStatus.c)
        end


    (* Exception Description *)

    and evalExDesc(ExDesc(I, vid, _, exdesc_opt)) =
        (* [Rule 180] *)
        let
            val VI = case exdesc_opt
                       of NONE        => VIdMap.empty
                        | SOME exdesc => evalExDesc(exdesc)
        in
            VIdMap.insert(VI, vid, IdStatus.e)
        end


    (* Structure Descriptions *)

    and evalStrDesc(IB, StrDesc(I, strid, sigexp, strdesc_opt)) =
        (* [Rule 181] *)
        let
            val I  = evalSigExp(IB, sigexp)
            val SI = case strdesc_opt
                       of NONE         => StrIdMap.empty
                        | SOME strdesc => evalStrDesc(IB, strdesc)
        in
            StrIdMap.insert(SI, strid, Interface.Str I)
        end


    (* Functor Bindings *)

    and evalFunBind(B, FunBind(I, funid, strid, sigexp, strexp, funbind_opt)) =
        (* [Rule 182] *)
        (* Note that there is a typo in this rule. *)
        let
            val I  = evalSigExp(IntBasis.Inter B, sigexp)
            val F  = case funbind_opt
                       of NONE         => FunIdMap.empty
                        | SOME funbind => evalFunBind(B, funbind)
        in
            FunIdMap.insert(F, funid,
                            DynamicBasis.FunctorClosure((strid,I),strexp,B))
        end


    (* Functor Declarations *)

    and evalFunDec(B, FunDec(I, funbind)) =
        (* [Rule 183] *)
        let
            val F = evalFunBind(B, funbind)
        in
            F
        end


    (* Top-level Declarations *)

    and evalTopDec(s,B, STRDECTopDec(I, strdec, topdec_opt)) =
        (* [Rule 184] *)
        (* Note the mistake in the conclusion of this rule. *)
        let
            val E   = evalStrDec(s,B, strdec)
            val B'  = DynamicBasis.fromE E
            val B'' = case topdec_opt
                        of NONE        => DynamicBasis.empty
                         | SOME topdec => evalTopDec(s,B plus B', topdec)
        in
            B' plus B''
        end

      | evalTopDec(s,B, SIGDECTopDec(I, sigdec, topdec_opt)) =
        (* [Rule 185] *)
        (* Note the mistake in the conclusion of this rule. *)
        let
            val G   = evalSigDec(IntBasis.Inter B, sigdec)
            val B'  = DynamicBasis.fromG G
            val B'' = case topdec_opt
                        of NONE        => DynamicBasis.empty
                         | SOME topdec => evalTopDec(s,B plus B', topdec)
        in
            B' plus B''
        end

      | evalTopDec(s,B, FUNDECTopDec(I, fundec, topdec_opt)) =
        (* [Rule 186] *)
        (* Note the mistake in the conclusion of this rule. *)
        let
            val F   = evalFunDec(B, fundec)
            val B'  = DynamicBasis.fromF F
            val B'' = case topdec_opt
                        of NONE        => DynamicBasis.empty
                         | SOME topdec => evalTopDec(s,B plus B', topdec)
        in
            B' plus B''
        end

  end
(* stop of EvalModule.sml *)
(* start of PRETTY_PRINT.sml *)
(*
 * A generic pretty printer.
 *
 * Based on:
 *    Philip Wadler. "A prettier printer"
 *    http://cm.bell-labs.com/cm/cs/who/wadler/
 * and Christian Lindig's port to OCaml.
 *
 * The semantics has been extended to allow 4 different kinds of
 * groups (`boxes'), 2 modes of nesting, and varying break representations.
 * This is no more easily described by an algebra though, and the `below'
 * combinator looses optimality.
 *)

signature PRETTY_PRINT =
  sig

    type doc

    val empty :         doc                     (* empty document *)
    val break :         doc                     (* space or line break *)
    val ebreak :        doc                     (* empty or line break *)
    val text :          string -> doc           (* raw text *)

    val ^^ :            doc * doc -> doc        (* concatenation *)
    val ^/^ :           doc * doc -> doc        (* concatenation with break *)

    val hbox :          doc -> doc              (* horizontal box *)
    val vbox :          doc -> doc              (* vertical box *)
    val fbox :          doc -> doc              (* fill box (h and v) *)
    val abox :          doc -> doc              (* auto box (h or v) *)

    val nest :          int -> doc -> doc       (* indentation by k char's *)
    val below :         doc -> doc              (* keep current indentation *)

    val isEmpty :       doc -> bool

    val toString :      doc * int -> string
    val output :        TextIO.outstream * doc * int -> unit

  end
(* stop of PRETTY_PRINT.sml *)
(* start of PrettyPrint.sml *)
(*
 * A generic pretty printer.
 *
 * Based on:
 *    Philip Wadler. "A prettier printer"
 *    http://cm.bell-labs.com/cm/cs/who/wadler/
 * and Christian Lindig's port to OCaml.
 *
 * The semantics has been extended to allow 4 different kinds of
 * groups (`boxes'), 2 modes of nesting, and varying break representations.
 * This is no more easily described by an algebra though, and the `below'
 * combinator looses optimality.
 *)

structure PrettyPrint :> PRETTY_PRINT =
  struct

    (* Types *)

    datatype mode = H | V | F | A

    datatype doc =
          EMPTY
        | BREAK of string
        | TEXT  of string
        | CONS  of doc * doc
        | BOX   of mode * doc
        | NEST  of int * doc
        | BELOW of doc

    datatype prim =
          PTEXT of string
        | PLINE of int


    (* Interface operators *)

    infixr ^^ ^/^

    val empty   = EMPTY
    val break   = BREAK " "
    val ebreak  = BREAK ""
    val text    = TEXT

    fun x ^^ EMPTY      = x
      | EMPTY ^^ y      = y
      | x ^^ y          = CONS(x, y)

    fun x ^/^ EMPTY     = x
      | EMPTY ^/^ y     = y
      | x ^/^ y         = CONS(x, CONS(break, y))

    fun below EMPTY     = EMPTY
      | below x         = BELOW x

    fun hbox EMPTY      = EMPTY
      | hbox x          = BOX(H, x)

    fun vbox EMPTY      = EMPTY
      | vbox x          = BOX(V, x)

    fun fbox EMPTY      = EMPTY
      | fbox x          = BOX(F, x)

    fun abox EMPTY      = EMPTY
      | abox x          = BOX(A, x)

    fun nest k EMPTY    = EMPTY
      | nest k x        = NEST(k, x)


    fun isEmpty EMPTY   = true
      | isEmpty _       = false


    (* Check whether the first line of a document fits into remaining characters *)

    (* We abuse the mode A (which can never occur in the lists passed to
     * fits) to flag breaks which occur inside swallowed vboxes.
     *)

    fun fits(w, z) =
        w >= 0 andalso
        case z
          of []                 => true
           | (i,m,EMPTY)::z     => fits(w, z)
           | (i,m,CONS(x,y))::z => fits(w, (i,m,x)::(i,m,y)::z)
           | (i,m,TEXT s)::z    => fits(w - String.size s, z)
           | (i,H,BREAK s)::z   => fits(w - String.size s, z)
           | (i,A,BREAK s)::z   => false
           | (i,m,BREAK s)::z   => true
           | (i,m,BOX(V,x))::z  => fits(w, (i,A,x)::z)
           | (i,m,BOX(n,x))::z  => fits(w, (i,H,x)::z)
           | (i,m,NEST(j,x))::z => fits(w, (i,m,x)::z)
           | (i,m,BELOW x)::z   => fits(w, (i,m,x)::z)


    (* Layout *)

    fun best(w, k, z, a) =
        case z
          of []                 => List.rev a
           | (i,m,EMPTY)::z     => best(w, k, z, a)
           | (i,m,CONS(x,y))::z => best(w, k, (i,m,x)::(i,m,y)::z, a)
           | (i,m,TEXT s)::z    => best(w, k + String.size s, z, PTEXT(s)::a)
           | (i,H,BREAK s)::z   => horizontal(w, k, s, z, a)
           | (i,V,BREAK s)::z   => vertical(w, i, z, a)
           | (i,F,BREAK s)::z   => if fits(w - k - String.size s, z)
                                   then horizontal(w, k, s, z, a)
                                   else vertical(w, i, z, a)
           | (i,A,BREAK s)::z   => raise Fail "PrettyPrint.best"
           | (i,m,BOX(A,x))::z  => if fits(w - k, (i,H,x)::z)
                                   then best(w, k, (i,H,x)::z, a)
                                   else best(w, k, (i,V,x)::z, a)
           | (i,m,BOX(n,x))::z  => best(w, k, (i,n,x)::z, a)
           | (i,m,NEST(j,x))::z => best(w, k, (i+j,m,x)::z, a)
           | (i,m,BELOW x)::z   => best(w, k, (k,m,x)::z, a)

    and horizontal(w, k, s, z, a) =
            best(w, k + String.size s, z, PTEXT(s)::a)

    and vertical(w, i, z, a) =
            best(w, i, z, PLINE(i)::a)


    fun layout(doc, w) = best(w, 0, [(0,V,doc)], [])



    (* Convert a document *)

    fun primToString(PTEXT s) = s
      | primToString(PLINE i) = 
            String.implode(#"\n" :: List.tabulate(i, fn _ => #" "))

    val toString = String.concat o List.map primToString o layout



    (* Output a document directly (is MUCH faster!) *)

    fun loop 0 f = ()
      | loop n f = ( f() ; loop (n-1) f )

    fun outputPrim os (PTEXT s) = TextIO.output(os, s)
      | outputPrim os (PLINE i) =
            ( TextIO.output1(os, #"\n")
            ; loop i (fn() => TextIO.output1(os, #" "))
            )

    fun output(os, doc, w) = List.app (outputPrim os) (layout(doc, w))

  end
(* stop of PrettyPrint.sml *)
(* start of PP_MISC.sml *)
(*
 * Standard ML miscellaneous pretty printing helpers
 *)

signature PP_MISC =
  sig

    type doc = PrettyPrint.doc

    val nest:           doc -> doc

    val paren:          doc -> doc
    val brace:          doc -> doc
    val brack:          doc -> doc

    val ppCommaList:    ('a -> doc) -> 'a list -> doc
    val ppStarList:     ('a -> doc) -> 'a list -> doc
    val ppSeq:          ('a -> doc) -> 'a list -> doc
    val ppSeqPrec:      (int -> 'a -> doc) -> int -> 'a list -> doc

  end
(* stop of PP_MISC.sml *)
(* start of PPMisc.sml *)
(*
 * Standard ML miscellaneous pretty printing helpers
 *)

structure PPMisc :> PP_MISC =
  struct

    (* Import *)

    open PrettyPrint

    infixr ^^


    (* Some PP combinators *)

    val nest = nest 2

    fun paren doc = text "(" ^^ fbox(below doc) ^^ text ")"
    fun brace doc = text "{" ^^ fbox(below doc) ^^ text "}"
    fun brack doc = text "[" ^^ fbox(below doc) ^^ text "]"

    fun ppCommaList ppX   []    = empty
      | ppCommaList ppX   [x]   = ppX x
      | ppCommaList ppX (x::xs) = ppX x ^^ text "," ^^ break ^^
                                  ppCommaList ppX xs

    fun ppStarList ppX   []     = empty
      | ppStarList ppX   [x]    = ppX x
      | ppStarList ppX (x::xs)  = hbox(ppX x ^^ break ^^ text "*") ^^ break ^^
                                  ppStarList ppX xs

    fun ppSeqPrec ppXPrec n []  = empty
      | ppSeqPrec ppXPrec n [x] = ppXPrec n x
      | ppSeqPrec ppXPrec n  xs = paren(ppCommaList (ppXPrec 0) xs)

    fun ppSeq ppX = ppSeqPrec (fn _ => ppX) 0

  end
(* stop of PPMisc.sml *)
(* start of PP_VAL.sml *)
(*
 * Standard ML pretty printing of values
 *)

signature PP_VAL =
  sig

    type doc      = PrettyPrint.doc
    type 'a State = 'a State.State
    type 'a Val   = 'a Val.Val
    type 'a ExVal = 'a Val.ExVal

    val ppVal:    'a State * 'a Val -> doc
    val ppExVal:  'a State * 'a ExVal -> doc

  end
(* stop of PP_VAL.sml *)
(* start of PPVal.sml *)
(*
 * Standard ML pretty printing of values
 *)

structure PPVal :> PP_VAL =
  struct

    (* Import *)

    type 'a State = 'a State.State

    open Val
    open PrettyPrint
    open PPMisc

    infixr ^^ ^/^


    (* Simple objects *)

    val ppFn        = text "<fn>"

    fun ppLab lab   = text(Lab.toString lab)
    fun ppVId vid   = text(VId.toString vid)
    fun ppExName en = text(ExName.toString en)
    fun ppSVal sv   = text(SVal.toString sv)


    (* Values *)

    (* Precedence:
     *  0 : plain expressions
     *  1 : constructor arguments
     *)

    fun ppVal  (s, v) = fbox(below(nest(ppValPrec (0, s) v)))
    and ppExVal(s, e) = fbox(below(nest(ppExValPrec (0, s) e)))

    and ppValPrec (p, s) (op:=) =
            ppFn

      | ppValPrec (p, s) (SVal sv) =
            ppSVal sv

      | ppValPrec (p, s) (BasVal b) =
            ppFn

      | ppValPrec (p, s) (VId vid) =
            ppVId vid

      | ppValPrec (p, s) (v as VIdVal(vid, v')) =
        let
            exception NotAList

            fun items(VId vid, vs) =
                if vid <> VId.fromString "nil" then
                    raise NotAList
                else
                    List.rev vs

              | items(VIdVal(vid, v), vs) =
                if vid <> VId.fromString "::" then
                    raise NotAList
                else
                    (case Val.unpair v
                       of NONE         => raise NotAList
                        | SOME(v1, v2) => items(v2, v1::vs)
                    )

              | items(_, vs) = raise NotAList
        in
            let
                val vs = items(v, [])
            in
                brack(ppCommaList (ppValPrec (0, s)) vs)
            end
            handle NotAList =>
            let
                val doc = ppVId vid ^/^ ppValPrec (1, s) v'
            in
                if p = 0 then
                    doc
                else
                    paren doc
            end
        end

      | ppValPrec (p, s) (ExVal e) =
            ppExValPrec (p, s) e

      | ppValPrec (p, s) (Record r) =
        let
            fun isTuple(   [],     n) = n > 2
              | isTuple(lab::labs, n) =
                    lab = Lab.fromInt n andalso isTuple(labs, n+1)

            val labvs     = LabMap.listItemsi r
            val (labs,vs) = ListPair.unzip labvs
        in
            if List.null labs then
                text "()"
            else if isTuple(labs, 1) then
                paren(ppCommaList (ppValPrec (0, s)) vs)
            else
                brace(ppCommaList (ppLabVal s) labvs)
        end

      | ppValPrec (p, s) (Addr a) =
        let
            val v   = case State.findAddr(s, a)
                        of SOME v => v
                         | NONE   => raise Fail "PPVal.ppVal: invalid address"

            val doc = text "ref" ^/^ ppValPrec (1, s) v
        in
            if p = 0 then
                doc
            else
                paren doc
        end

      | ppValPrec (p, s) (FcnClosure _) =
            ppFn


    and ppLabVal s (lab, v) =
            abox(
                hbox(
                    ppLab lab ^/^
                    text "="
                ) ^^
                below(nest(break ^^
                    ppVal(s, v)
                ))
            )


    and ppExValPrec (p, s) (ExName en) =
            ppExName en

      | ppExValPrec (p, s) (ExNameVal(en, v)) =
        let
            val doc = ppExName en ^/^ ppValPrec (1, s) v
        in
            if p = 0 then
                doc
            else
                paren doc
        end

  end
(* stop of PPVal.sml *)
(* start of PP_DYNAMIC_ENV.sml *)
(*
 * Standard ML pretty printing of the dynamic environment
 *)

signature PP_DYNAMIC_ENV =
  sig

    type doc   = PrettyPrint.doc
    type Env   = DynamicEnv.Env
    type Str   = DynamicEnv.Str
    type State = DynamicEnv.FcnClosure State.State

    val ppEnv: State * Env -> doc
    val ppStr: State * Str -> doc

  end
(* stop of PP_DYNAMIC_ENV.sml *)
(* start of PPDynamicEnv.sml *)
(*
 * Standard ML pretty printing of the dynamic environment
 *)

structure PPDynamicEnv :> PP_DYNAMIC_ENV =
  struct

    (* Import *)

    type Env   = DynamicEnv.Env
    type Str   = DynamicEnv.Str
    type State = DynamicEnv.FcnClosure State.State

    open PrettyPrint
    open PPMisc

    infixr ^^ ^/^


    (* Simple objects *)

    fun ppVId vid     = text(VId.toString vid)
    fun ppStrId strid = text(StrId.toString strid)


    (* Environments *)

    fun ppValEnv(s, VE) =
        VIdMap.foldri
            (fn(vid, (v,IdStatus.v), doc) =>
                abox(
                    hbox(
                        text "val" ^/^
                        ppVId vid ^/^
                        text "="
                    ) ^^
                    nest(break ^^
                        abox(PPVal.ppVal(s, v))
                    )
                ) ^/^
                doc

             | (vid, (v,_), doc) => doc
            )
            empty VE

    fun ppExEnv VE =
        VIdMap.foldri
            (fn(vid, (v,IdStatus.e), doc) =>
                hbox(
                    text "exception" ^/^
                    ppVId vid
                ) ^/^
                doc

             | (vid, (v,_), doc) => doc
            )
            empty VE

    fun ppConEnv VE =
        VIdMap.foldli
            (fn(vid, (v,IdStatus.c), doc) =>
                hbox(
                    text "con" ^/^
                    ppVId vid
                ) ^/^
                doc

             | (vid, (v,_), doc) => doc
            )
            empty VE

    fun ppStrEnv(s, SE) =
        StrIdMap.foldri
            (fn(strid, S, doc) =>
                abox(
                    hbox(
                        text "structure" ^/^
                        ppStrId strid ^/^
                        text "="
                    ) ^^
                    nest(break ^^
                        ppStr(s, S)
                    )
                ) ^/^
                doc
            )
            empty SE

    and ppEnv(s, (SE,TE,VE)) =
            vbox(
                ppStrEnv(s, SE) ^/^
                ppConEnv VE ^/^
                ppExEnv  VE ^/^
                ppValEnv(s, VE)
            )


    (* Structures *)

    and ppStr(s, DynamicEnv.Str E) =
        let
            val doc = ppEnv(s, E)
        in
            abox(below(
                text "struct" ^^
                (if isEmpty doc then
                    empty
                 else
                    nest(vbox(break ^^ doc))
                ) ^^ break ^^
                text "end"
            ))
        end

  end
(* stop of PPDynamicEnv.sml *)
(* start of PP_DYNAMIC_BASIS.sml *)
(*
 * Standard ML pretty printing of the dynamic basis
 *)

signature PP_DYNAMIC_BASIS =
  sig

    type doc   = PrettyPrint.doc
    type Basis = DynamicBasis.Basis
    type State = DynamicEnv.FcnClosure State.State

    val ppBasis: State * Basis -> doc

  end
(* stop of PP_DYNAMIC_BASIS.sml *)
(* start of PPDynamicBasis.sml *)
(*
 * Standard ML pretty printing of the dynamic basis
 *)

structure PPDynamicBasis :> PP_DYNAMIC_BASIS =
  struct

    (* Import *)

    type Basis = DynamicBasis.Basis
    type State = DynamicEnv.FcnClosure State.State

    open PrettyPrint

    infixr ^^ ^/^


    (* Simple objects *)

    fun ppFunId funid = text(FunId.toString funid)


    (* Environments *)

    fun ppFunEnv F =
        FunIdMap.foldri
            (fn(funid, _, doc) =>
                hbox(
                    text "functor" ^/^
                    ppFunId funid
                ) ^/^
                doc
            )
            empty F


    (* Basis *)

    fun ppBasis(s, (F,G,E)) =
            vbox(
                ppFunEnv F ^/^
                PPDynamicEnv.ppEnv(s, E) ^/^
                text ""
            )

  end
(* stop of PPDynamicBasis.sml *)
(* start of CHECK_PATTERN.sml *)
(*
 * Standard ML consistency of patterns and matches
 *
 * Definition, section 4.11
 *
 * Note:
 *     The requirement to check for irredundancy of matches is a `bug' in the
 *     definition since this cannot be checked in general for two reasons:
 *
 *     (1) There may be (hidden) aliasing of exception constructors.
 *         Consequently, we only detect redundant exception constructors
 *         if they are denoted by the same longvid.
 *
 *     (2) There is no requirement of consistency for constructors in
 *         sharing specifications or type realisations (actually, we
 *         consider this a serious bug). For example,
 *              datatype t1 = A | B
 *              datatype t2 = C
 *              sharing type t1 = t2
 *         is a legal specification. This allows a mix of the constructors
 *         to appear in matches, rendering the terms of irredundancy and
 *         exhaustiveness meaningless. We make no attempt to detect this,
 *         so generated warnings may or may not make sense in that situation.
 *)


signature CHECK_PATTERN =
  sig

    (* Import *)

    type Pat   = GrammarCore.Pat
    type Match = GrammarCore.Match
    type Env   = StaticEnv.Env


    (* Operations *)

    val checkPat:       Env * Pat   -> unit
    val checkMatch:     Env * Match -> unit

  end
(* stop of CHECK_PATTERN.sml *)
(* start of CheckPattern.sml *)
(*
 * Standard ML consistency of patterns and matches
 *
 * Definition, section 4.11
 *
 * Note:
 *     The requirement to check for irredundancy of matches is a `bug' in the
 *     definition since this cannot be checked in general for two reasons:
 *
 *     (1) There may be (hidden) aliasing of exception constructors.
 *         Consequently, we only detect redundant exception constructors
 *         if they are denoted by the same longvid.
 *
 *     (2) There is no requirement of consistency for constructors in
 *         sharing specifications or type realisations (actually, we
 *         consider this a serious bug). For example,
 *              datatype t1 = A | B
 *              datatype t2 = C
 *              sharing type t1 = t2
 *         is a legal specification. This allows a mix of the constructors
 *         to appear in matches, rendering the terms of irredundancy and
 *         exhaustiveness meaningless. We make no attempt to detect this,
 *         so generated warnings may or may not make sense in that situation.
 *
 * Bugs:
 *     All types of special constants are assumed to be infinite, so that
 *     a match only gets exhaustive by placing a variable. This is a bit
 *     inaccurate for char in particular where the programmer actually would
 *     be able to write down the complete set of values.
 *     The reason is that for special constants to be treated properly in
 *     the presence of overloading we would require the (resolved) type
 *     information.
 *)

structure CheckPattern :> CHECK_PATTERN =
  struct

    (* Import *)

    type SCon    = SCon.SCon
    type Lab     = Lab.Lab
    type VId     = VId.Id
    type longVId = LongVId.longId
    type Pat     = GrammarCore.Pat
    type Match   = GrammarCore.Match
    type Env     = StaticEnv.Env

    type SConSet    = SConSet.set
    type VIdSet     = VIdSet.set
    type LongVIdSet = LongVIdSet.set
    type 'a LabMap  = 'a LabMap.map


    open GrammarCore



    (*
     * Algorithm has been derived from:
     *    Peter Sestoft.
     *         "ML pattern matching compilation and partial evaluation",
     *    in: Dagstuhl Seminar on Partial Evaluation,
     *        Lecture Notes in Computer Science, Springer-Verlag 1996
     *)


    (* Value description *)

    datatype description =
          ANY
        | SCON      of SCon
        | NOT_SCON  of SConSet
        | EXCON     of longVId * description option
        | NOT_EXCON of LongVIdSet
        | CON       of VId * description option
        | NOT_CON   of VIdSet
        | RECORD    of description LabMap

    datatype context =
          EXCON'  of longVId
        | CON'    of VId
        | LAB'    of Lab
        | RECORD' of description LabMap

    type knowledge = description * context list

    type continuations = PatRow option list * Match option



    (* Extending the context on partial success *)

    fun augment(EXCON'(longvid)::context, desc) =
            augment(context, EXCON(longvid, SOME desc))

      | augment(CON'(vid)::context, desc) =
            augment(context, CON(vid, SOME desc))

      | augment(LAB'(lab)::RECORD'(descs)::context, desc) =
            RECORD'(LabMap.insert(descs, lab, desc)) :: context

      | augment _ = raise Fail "CheckPattern.augment: invalid context"


    (* Building the description on failure *)

    fun build([], desc) =
            desc

      | build(EXCON'(longvid)::context, desc) =
            build(context, EXCON(longvid, SOME desc))

      | build(CON'(vid)::context, desc) =
            build(context, CON(vid, SOME desc))

      | build(LAB'(lab)::RECORD'(descs)::context, desc) =
            build(context, RECORD(LabMap.insert(descs, lab, desc)))

      | build _ = raise Fail "CheckPattern.build: invalid context"


    (* Result type for static matching *)

    structure RegionSet = FinSetFn(type ord_key = Source.region
                                   val compare  = Source.compare)

    type result = RegionSet.set * bool

    val success = ( RegionSet.empty, true )
    val failure = ( RegionSet.empty, false )

    fun branch((P1, exhaustive1), (P2, exhaustive2)) =
            ( RegionSet.union(P1, P2), exhaustive1 andalso exhaustive2 )

    fun reached(I, (P, exhaustive)) =
            ( RegionSet.add(P, I), exhaustive )



    (* Static pattern matching *)

    fun matchMatch(E, desc, Match(_, mrule, match_opt)) =
            matchMrule(E, desc, mrule, match_opt)


    and matchMrule(E, desc, Mrule(I, pat, exp), match_opt) =
            reached(I, matchPat(E, (desc, []), pat, ([], match_opt)))


    and matchAtPat(E, know, atpat, cont) =
        case atpat
          of WILDCARDAtPat(_) =>
                succeed(E, know, cont)

           | SCONAtPat(_, scon) =>
                matchSCon(E, know, scon, cont)

           | LONGVIDAtPat(_, _, longvid) =>
               (case StaticEnv.findLongVId(E, longvid)
                  of NONE =>
                        succeed(E, know, cont)

                   | SOME(sigma, IdStatus.v) =>
                        succeed(E, know, cont)

                   | SOME(sigma, IdStatus.e) =>
                        matchExCon(E, know, longvid, NONE, cont)

                   | SOME((_,tau), IdStatus.c) =>
                     let
                        val vid  = LongVId.toId longvid
                        val span = TyName.span(Type.tyname(Type.range tau))
                     in
                        matchCon(E, know, vid, span, NONE, cont)
                     end
               )

           | RECORDAtPat(_, patrow_opt) =>
                matchRecord(E, know, patrow_opt, cont)

           | PARAtPat(_, pat) =>
                matchPat(E, know, pat, cont)


    and matchPat(E, know, pat, cont) =
        case pat
          of ATPATPat(_, atpat) =>
                matchAtPat(E, know, atpat, cont)

           | CONPat(_, _, longvid, atpat) =>
               (case StaticEnv.findLongVId(E, longvid)
                  of SOME(sigma, IdStatus.e) =>
                        matchExCon(E, know, longvid, SOME atpat, cont)

                   | SOME((_,tau), IdStatus.c) =>
                     let
                        val vid  = LongVId.toId longvid
                        val span = TyName.span(Type.tyname(Type.range tau))
                     in
                        matchCon(E, know, vid, span, SOME atpat, cont)
                     end

                   | _ => raise Fail "CheckMatching.matchPat: \
                                     \invalid constructed pattern"
               )

          | TYPEDPat(_, pat, ty) =>
                matchPat(E, know, pat, cont)

          | ASPat(_, _, vid, ty_opt, pat) =>
                matchPat(E, know, pat, cont)


    and matchRecord(E, (desc, context), patrow_opt, cont) =
        let
            val descs = case desc
                          of ANY          => LabMap.empty
                           | RECORD descs => descs
                           | _ =>
                             raise Fail "CheckPattern.matchRecord: type error"
        in
            matchPatRowOpt(E, RECORD'(descs)::context, patrow_opt, cont)
        end


    and matchPatRowOpt(E, RECORD'(descs)::context, patrow_opt,
                                        cont as (patrow_opts, match_opt)) =
        (case patrow_opt
           of SOME(ROWPatRow(_, lab, pat, patrow_opt')) =>
              let
                  val desc' = case LabMap.find(descs, lab)
                                of NONE       => ANY
                                 | SOME desc' => desc'
              in
                  matchPat(E, (desc', LAB'(lab)::RECORD'(descs)::context), pat,
                           (patrow_opt'::patrow_opts, match_opt))
              end

            | _ =>
                  succeed(E, (RECORD descs, context), cont)
        )
      | matchPatRowOpt _ =
            raise Fail "CheckPattern.matchPatRowOpt: inconsistent context"


    and matchSCon(E, know as (desc, context), scon, cont) =
        let
           val knowSucc       = (SCON scon, context)
           fun knowFail scons = (NOT_SCON(SConSet.add(scons, scon)), context)
        in
           case desc
             of ANY =>
                branch(succeed(E, knowSucc, cont),
                       fail(E, knowFail SConSet.empty, cont)
                      )

              | SCON scon' =>
                if SCon.compare(scon, scon') = EQUAL then
                    succeed(E, know, cont)
                else
                    fail(E, know, cont)

              | NOT_SCON scons =>
                if SConSet.member(scons, scon) then
                    fail(E, know, cont)
                else
                    branch(succeed(E, knowSucc, cont),
                           fail(E, knowFail scons, cont)
                          )

              | _ => raise Fail "CheckPattern.matchSCon: type error"
        end


    and matchExCon(E, know as (desc, context), longvid, atpat_opt, cont) =
        let
           val knowSucc = (EXCON(longvid, NONE), EXCON'(longvid)::context)
           fun knowFail longvids =
                (NOT_EXCON(LongVIdSet.add(longvids, longvid)), context)
        in
           case desc
             of ANY =>
                branch(matchArgOpt(E, knowSucc, SOME ANY, atpat_opt, cont),
                       fail(E, knowFail LongVIdSet.empty, cont)
                      )

              | EXCON(longvid', desc_opt) =>
                if longvid = longvid' then
                    matchArgOpt(E, knowSucc, desc_opt, atpat_opt, cont)
                else
                    fail(E, know, cont)

              | NOT_EXCON longvids =>
                if LongVIdSet.member(longvids, longvid) then
                    fail(E, know, cont)
                else
                    branch(matchArgOpt(E, knowSucc, SOME ANY, atpat_opt, cont),
                           fail(E, knowFail longvids, cont)
                          )

              | _ => raise Fail "CheckPattern.matchSCon: type error"
        end


    and matchCon(E, know as (desc, context), vid, span, atpat_opt, cont) =
        let
           val knowSucc      = (CON(vid, NONE), CON'(vid)::context)
           fun knowFail vids = (NOT_CON(VIdSet.add(vids, vid)), context)
        in
           case desc
             of ANY =>
                if span = 1 then
                    matchArgOpt(E, knowSucc, SOME ANY, atpat_opt, cont)
                else
                    branch(matchArgOpt(E, knowSucc, SOME ANY, atpat_opt, cont),
                           fail(E, knowFail VIdSet.empty, cont)
                    )

              | CON(vid', desc_opt) =>
                if vid = vid' then
                    matchArgOpt(E, knowSucc, desc_opt, atpat_opt, cont)
                else
                    fail(E, know, cont)

              | NOT_CON vids =>
                if VIdSet.member(vids, vid) then
                    fail(E, know, cont)
                else if VIdSet.numItems vids = span - 1 then
                    matchArgOpt(E, knowSucc, SOME ANY, atpat_opt, cont)
                else
                    branch(matchArgOpt(E, knowSucc, SOME ANY, atpat_opt, cont),
                           fail(E, knowFail vids, cont)
                          )

              | _ => raise Fail "CheckPattern.matchSCon: type error"
        end


    and matchArgOpt(E, (desc, context), desc_opt, atpat_opt, cont) =
        case atpat_opt
          of NONE =>
                succeed(E, (desc, List.tl context), cont)

           | SOME atpat =>
                matchAtPat(E, (valOf desc_opt, context), atpat, cont)



    and succeed(E, know, ([], match_opt)) =
            success

      | succeed(E, (desc, context), (patrow_opt::patrow_opts, match_opt)) =
        let
            val context' = augment(context, desc)
        in
            matchPatRowOpt(E, context', patrow_opt, (patrow_opts, match_opt))
        end


    and fail(E, know, (_, NONE)) =
            failure

      | fail(E, (desc, context), (_, SOME match)) =
            matchMatch(E, build(context, desc), match)



    (* Checking matches [Section 4.11, item 2] *)

    fun checkReachableMrule(reachables, Mrule(I, _, _)) =
            if RegionSet.member(reachables, I) then
                ()
            else
                Error.warning(I, "redundant match rule")

    fun checkReachableMatchOpt(reachables, NONE)                             = ()
      | checkReachableMatchOpt(reachables, SOME(Match(_, mrule, match_opt))) =
            ( checkReachableMrule(reachables, mrule)
            ; checkReachableMatchOpt(reachables, match_opt)
            )

    fun checkMatch(E, match) =
        let
            val (reachables, exhaustive) = matchMatch(E, ANY, match)
        in
            checkReachableMatchOpt(reachables, SOME match)
          ; if exhaustive then
                ()
            else
                Error.warning(infoMatch match, "match not exhaustive")
        end



    (* Checking single patterns [Section 4.11, item 3] *)

    fun checkPat(E, pat) =
        let
            val (_, exhaustive) = matchPat(E, (ANY, []), pat, ([], NONE))
        in
            if exhaustive then
                ()
            else
                Error.warning(infoPat pat, "pattern not exhaustive")
        end

  end
(* stop of CheckPattern.sml *)
(* start of ELAB_CORE.sml *)
(*
 * Standard ML core elaboration
 *
 * Definition, sections 4.10, 4.11, 4.6, 4.7, 2.9
 *
 * Notes:
 *   - Elaboration also checks the syntactic restrictions [Section 2.9]
 *     and the further restrictions [Section 4.11].
 *   - To implement the 3rd restriction in 4.11 elabDec is passed an
 *     additional boolean argument to recognise being on the toplevel.
 *)


signature ELAB_CORE =
  sig

    (* Import types *)

    type Dec      = GrammarCore.Dec
    type Ty       = GrammarCore.Ty
    type TyVarseq = GrammarCore.TyVarseq

    type VId      = VId.Id
    type TyVar    = TyVar.TyVar
    type TyVarSet = TyVarSet.set
    type Type     = Type.Type
    type Env      = StaticEnv.Env
    type Context  = Context.Context


    (* Export *)

    val elabDec:                bool * Context * Dec -> Env
    val elabTy:                 Context * Ty -> Type

    val tyvars:                 TyVarseq -> TyVarSet * TyVar list

    val validBindVId:           VId -> bool
    val validConBindVId:        VId -> bool

  end
(* stop of ELAB_CORE.sml *)
(* start of ElabCore.sml *)
(*
 * Standard ML core elaboration
 *
 * Definition, sections 4.10, 4.11, 4.6, 4.7, 2.9
 *
 * Notes:
 *   - Elaboration also checks the syntactic restrictions [Section 2.9]
 *     and the further restrictions [Section 4.11].
 *   - To implement the 3rd restriction in 4.11 some elab functions are
 *     passed an additional boolean argument to recognise being on the toplevel.
 *   - There is a bug in the Definition -- an important syntactic restriction
 *     is missing:
 *       "Any tyvar occuring on the right side of a typbind or datbind of the
 *        form tyvarseq tycon = ... must occur in tyvarseq."
 *   - The definition says that overloaded types get defaulted if the
 *     "surrounding text" does not resolve it. It leaves some freedom to
 *     how large this context may be. We choose the innermost value binding.
 *   - The definition states that "the program context" must determine the
 *     exact type of flexible records, but it does not say how large this
 *     context may be either. Again we choose the innermost surrounding value
 *     binding.
 *   - Most conditions on type names can be ignored since they are
 *     always ensured by the Stamp mechanism.
 *
 * Bugs:
 *   - Unresolved overloading is left unnoticed if it never propagates to a
 *     value binding's result environment. To resolve all cases we either had
 *     to annotate all expressions with their types and walk the whole tree
 *     for each value binding's RHS, or extend the inference results with
 *     complicated information on overloaded type variables, or use some dirty
 *     side effect hack.
 *   - The same goes for unresolved flexible record types, for essentially the
 *     same reason.
 *)

structure ElabCore :> ELAB_CORE =
  struct

    (* Import *)

    type Dec      = GrammarCore.Dec
    type Ty       = GrammarCore.Ty
    type TyVarseq = GrammarCore.TyVarseq

    type VId      = VId.Id
    type TyVar    = TyVar.TyVar
    type TyVarSet = TyVarSet.set
    type Type     = Type.Type
    type Env      = StaticEnv.Env
    type Context  = Context.Context


    open GrammarCore


    (* Some helpers for error messages *)

    val error = Error.error

    fun errorLab(I, s, lab)     = error(I, s ^ Lab.toString lab)
    fun errorVId(I, s, vid)     = error(I, s ^ VId.toString vid)
    fun errorTyCon(I, s, tycon) = error(I, s ^ TyCon.toString tycon)
    fun errorTyVar(I, s, tyvar) = error(I, s ^ TyVar.toString tyvar)

    fun errorLongVId(I, s, longvid) = error(I, s ^ LongVId.toString longvid)
    fun errorLongTyCon(I, s, longtycon) =
            error(I, s ^ LongTyCon.toString longtycon)
    fun errorLongStrId(I, s, longstrid) =
            error(I, s ^ LongStrId.toString longstrid)



    (* Helpers for context modification *)

    val plus         = StaticEnv.plus
    val plusU        = Context.plusU
    val plusVE       = Context.plusVE
    val oplusE       = Context.oplusE
    val oplusTE      = Context.oplusTE
    val oplusVEandTE = Context.oplusVEandTE

    infix plusU plusVE oplusE oplusTE oplusVEandTE



    (* Checking restriction for vids in binding [Section 2.9, 5th bullet] *)

    fun validBindVId vid =
            vid <> VId.fromString "true" andalso
            vid <> VId.fromString "false" andalso
            vid <> VId.fromString "nil" andalso
            vid <> VId.fromString "::"  andalso
            vid <> VId.fromString "ref"

    fun validConBindVId vid =
            validBindVId vid andalso
            vid <> VId.fromString "it"


    (* Treating tyvarseqs *)

    fun tyvars(TyVarseq(I, tyvars)) =
        let
            fun collect(     [],       U) = U
              | collect(tyvar::tyvars, U) =
                    if TyVarSet.member(U, tyvar) then
                        (* Syntactic restriction [Section 2.9, 3rd bullet] *)
                        errorTyVar(I, "duplicate type variable ", tyvar)
                    else
                        collect(tyvars, TyVarSet.add(U, tyvar))
        in
            ( collect(tyvars, TyVarSet.empty), tyvars )
        end



    (* Typing special constants [Section 4.1, Appendix E.1] *)

    fun typeSCon(SCon.INT _)  = Type.fromOverloadingClass InitialStaticEnv.Int
      | typeSCon(SCon.WORD _) = Type.fromOverloadingClass InitialStaticEnv.Word
      | typeSCon(SCon.CHAR _) = Type.fromOverloadingClass InitialStaticEnv.Char
      | typeSCon(SCon.REAL _) = Type.fromOverloadingClass InitialStaticEnv.Real
      | typeSCon(SCon.STRING _) =
            Type.fromOverloadingClass InitialStaticEnv.String


    (* Calculate sets of unguarded explicit type variables [Section 4.6] *)

    local
        val op+ = TyVarSet.union

        fun ? tyvarsX  NONE    = TyVarSet.empty
          | ? tyvarsX (SOME x) = tyvarsX x
    in

    fun unguardedTyVarsAtExp(RECORDAtExp(_, exprow_opt)) =
            ?unguardedTyVarsExpRow exprow_opt
      | unguardedTyVarsAtExp(LETAtExp(_, dec, exp)) =
            unguardedTyVarsDec dec + unguardedTyVarsExp exp
      | unguardedTyVarsAtExp(PARAtExp(_, exp)) =
            unguardedTyVarsExp exp
      | unguardedTyVarsAtExp _ = TyVarSet.empty

    and unguardedTyVarsExpRow(ExpRow(_, lab, exp, exprow_opt)) =
            unguardedTyVarsExp exp + ?unguardedTyVarsExpRow exprow_opt

    and unguardedTyVarsExp(ATEXPExp(_, atexp)) =
            unguardedTyVarsAtExp atexp
      | unguardedTyVarsExp(APPExp(_, exp, atexp)) =
            unguardedTyVarsExp exp + unguardedTyVarsAtExp atexp
      | unguardedTyVarsExp(TYPEDExp(_, exp, ty)) =
            unguardedTyVarsExp exp + unguardedTyVarsTy ty
      | unguardedTyVarsExp(HANDLEExp(_, exp, match)) =
            unguardedTyVarsExp exp + unguardedTyVarsMatch match
      | unguardedTyVarsExp(RAISEExp(_, exp)) =
            unguardedTyVarsExp exp
      | unguardedTyVarsExp(FNExp(_, match)) =
            unguardedTyVarsMatch match

    and unguardedTyVarsMatch(Match(_, mrule, match_opt)) =
            unguardedTyVarsMrule mrule + ?unguardedTyVarsMatch match_opt

    and unguardedTyVarsMrule(Mrule(_, pat, exp)) =
            unguardedTyVarsPat pat + unguardedTyVarsExp exp

    and unguardedTyVarsDec(ABSTYPEDec(_, datbind, dec)) =
            unguardedTyVarsDec dec
      | unguardedTyVarsDec(EXCEPTIONDec(_, exbind)) =
            unguardedTyVarsExBind exbind
      | unguardedTyVarsDec(LOCALDec(_, dec1, dec2)) =
            unguardedTyVarsDec dec1 + unguardedTyVarsDec dec2
      | unguardedTyVarsDec(SEQDec(_, dec1, dec2)) =
            unguardedTyVarsDec dec1 + unguardedTyVarsDec dec2
      | unguardedTyVarsDec _ = TyVarSet.empty

    and unguardedTyVarsValBind(PLAINValBind(_, pat, exp, valbind_opt)) =
            unguardedTyVarsPat pat + unguardedTyVarsExp exp +
            ?unguardedTyVarsValBind valbind_opt
      | unguardedTyVarsValBind(RECValBind(_, valbind)) =
            unguardedTyVarsValBind valbind

    and unguardedTyVarsExBind(NEWExBind(_, _, vid, ty_opt, exbind_opt)) =
            ?unguardedTyVarsTy ty_opt + ?unguardedTyVarsExBind exbind_opt
      | unguardedTyVarsExBind(EQUALExBind(_, _, vid, _, longvid, exbind_opt)) =
            ?unguardedTyVarsExBind exbind_opt

    and unguardedTyVarsAtPat(RECORDAtPat(_, patrow_opt)) =
            ?unguardedTyVarsPatRow patrow_opt
      | unguardedTyVarsAtPat(PARAtPat(_, pat)) =
            unguardedTyVarsPat pat
      | unguardedTyVarsAtPat _ = TyVarSet.empty

    and unguardedTyVarsPatRow(WILDCARDPatRow(_)) = TyVarSet.empty
      | unguardedTyVarsPatRow(ROWPatRow(_, lab, pat, patrow_opt)) =
            unguardedTyVarsPat pat + ?unguardedTyVarsPatRow patrow_opt

    and unguardedTyVarsPat(ATPATPat(_, atpat)) =
            unguardedTyVarsAtPat atpat
      | unguardedTyVarsPat(CONPat(_, _, longvid, atpat)) =
            unguardedTyVarsAtPat atpat
      | unguardedTyVarsPat(TYPEDPat(_, pat, ty)) =
            unguardedTyVarsPat pat + unguardedTyVarsTy ty
      | unguardedTyVarsPat(ASPat(_, _, vid, ty_opt, pat)) =
            ?unguardedTyVarsTy ty_opt + unguardedTyVarsPat pat

    and unguardedTyVarsTy(TYVARTy(_, tyvar)) = TyVarSet.singleton tyvar
      | unguardedTyVarsTy(RECORDTy(_, tyrow_opt)) =
            ?unguardedTyVarsTyRow tyrow_opt
      | unguardedTyVarsTy(TYCONTy(_, tyseq, longtycon)) =
            unguardedTyVarsTyseq tyseq
      | unguardedTyVarsTy(ARROWTy(_, ty, ty')) =
            unguardedTyVarsTy ty + unguardedTyVarsTy ty'
      | unguardedTyVarsTy(PARTy(_, ty)) =
            unguardedTyVarsTy ty

    and unguardedTyVarsTyRow(TyRow(_, lab, ty, tyrow_opt)) =
            unguardedTyVarsTy ty + ?unguardedTyVarsTyRow tyrow_opt

    and unguardedTyVarsTyseq(Tyseq(_, tys)) =
            List.foldl (fn(ty,U) => unguardedTyVarsTy ty + U) TyVarSet.empty tys

    end (* local *)



    (* Check whether a pattern binds an identifier *)

    local
        fun ? boundByX(NONE,   vid) = false
          | ? boundByX(SOME x, vid) = boundByX(x, vid)
    in

    fun boundByAtPat(WILDCARDAtPat(_), vid)   = false
      | boundByAtPat(SCONAtPat(_, scon), vid) = false
      | boundByAtPat(LONGVIDAtPat(_, _, longvid), vid) =
        let
            val (strids,vid') = LongVId.explode longvid
        in
            List.null strids andalso vid = vid'
        end
      | boundByAtPat(RECORDAtPat(_, patrow_opt), vid) =
            ?boundByPatRow(patrow_opt, vid)
      | boundByAtPat(PARAtPat(_, pat), vid) = boundByPat(pat, vid)

    and boundByPatRow(WILDCARDPatRow(_), vid) = false
      | boundByPatRow(ROWPatRow(_, lab, pat, patrow_opt), vid) =
            boundByPat(pat, vid) orelse ?boundByPatRow(patrow_opt, vid)

    and boundByPat(ATPATPat(_, atpat), vid)           = boundByAtPat(atpat, vid)
      | boundByPat(CONPat(_, _, longvid, atpat), vid) = boundByAtPat(atpat, vid)
      | boundByPat(TYPEDPat(_, pat, ty), vid)         = boundByPat(pat, vid)
      | boundByPat(ASPat(_, _, vid', ty_opt, pat), vid) =
            vid = vid' orelse boundByPat(pat, vid)

    end (* local *)



    (* Non-expansive expressions [Section 4.7] *)

    local
        fun ? isNonExpansiveX C  NONE    = true
          | ? isNonExpansiveX C (SOME x) = isNonExpansiveX C x
    in

    fun isNonExpansiveAtExp C (SCONAtExp(_, scon))          = true
      | isNonExpansiveAtExp C (LONGVIDAtExp(_, _, longvid)) = true
      | isNonExpansiveAtExp C (RECORDAtExp(_, exprow_opt))  =
            ?isNonExpansiveExpRow C exprow_opt
      | isNonExpansiveAtExp C (PARAtExp(_, exp))    = isNonExpansiveExp C exp
      | isNonExpansiveAtExp C  _                    = false

    and isNonExpansiveExpRow C (ExpRow(_, lab, exp, exprow_opt)) =
            isNonExpansiveExp C exp andalso ?isNonExpansiveExpRow C exprow_opt

    and isNonExpansiveExp C (ATEXPExp(_, atexp))   = isNonExpansiveAtExp C atexp
      | isNonExpansiveExp C (APPExp(_, exp, atexp)) =
            isConExp C exp andalso isNonExpansiveAtExp C atexp
      | isNonExpansiveExp C (TYPEDExp(_, exp, ty))  = isNonExpansiveExp C exp
      | isNonExpansiveExp C (FNExp(_, match))       = true
      | isNonExpansiveExp C  _                      = false

    and isConAtExp C (PARAtExp(_, exp))            = isConExp C exp
      | isConAtExp C (LONGVIDAtExp(_, _, longvid)) =
            LongVId.explode longvid <> ([],VId.fromString "ref") andalso
            (case Context.findLongVId(C, longvid)
               of SOME(_,is) => is=IdStatus.c orelse is=IdStatus.e
                | NONE       => false
            )
      | isConAtExp C  _                            = false

    and isConExp C (ATEXPExp(_, atexp))                  = isConAtExp C atexp
      | isConExp C (TYPEDExp(_, ATEXPExp(_, atexp), ty)) = isConAtExp C atexp
      | isConExp C  _                                    = false

    end (* local *)



    (* Closure of value environments [Section 4.8] *)

    fun hasNonExpansiveRHS C (vid, PLAINValBind(I, pat, exp, valbind_opt)) =
        if boundByPat(pat, vid) then
            isNonExpansiveExp C exp
        else
            hasNonExpansiveRHS C (vid, valOf valbind_opt)

      | hasNonExpansiveRHS C (vid, RECValBind _) =
            (* A rec valbind can only contain functions. *)
            true

    fun Clos (C,valbind) VE =
        let
            val tyvarsC = Context.tyvars C

            fun alphas(vid, tau) =
                if hasNonExpansiveRHS C (vid, valbind) then
                    TyVarSet.listItems
                        (TyVarSet.difference(Type.tyvars tau, tyvarsC))
                else
                    []
        in
            VIdMap.mapi
                (fn(vid, ((_,tau),is)) => ((alphas(vid,tau),tau),is))
                VE
        end


    (* Inference rules [Section 4.10] *)


    (* Atomic Expressions *)

    fun elabAtExp(C, SCONAtExp(I, scon)) =
        (* [Rule 1] *)
        typeSCon scon

      | elabAtExp(C, LONGVIDAtExp(I, _, longvid)) =
        (* [Rule 2] *)
        let
            val (sigma,is) = case Context.findLongVId(C, longvid)
                               of SOME valstr => valstr
                                | NONE =>
                                  errorLongVId(I, "unknown identifier ",longvid)
            val tau = TypeScheme.instance sigma
        in
            tau
        end

      | elabAtExp(C, RECORDAtExp(I, exprow_opt)) =
        (* [Rule 3] *)
        let
            val rho = case exprow_opt
                        of NONE        => Type.emptyRho
                         | SOME exprow => elabExpRow(C, exprow)
        in
            Type.fromRowType rho
        end

      | elabAtExp(C, LETAtExp(I, dec, exp)) =
        (* [Rule 4] *)
        let
            val E   = elabDec(false, C, dec)
            val tau = elabExp(C oplusE E, exp)
        in
            if TyNameSet.isSubset(Type.tynames tau, Context.Tof C) then
                tau
            else
                error(I, "escaping local type name in let expression")
        end

      | elabAtExp(C, PARAtExp(I, exp)) =
        (* [Rule 5] *)
        let
            val tau = elabExp(C, exp)
        in
            tau
        end


    (* Expression Rows *)

    and elabExpRow(C, ExpRow(I, lab, exp, exprow_opt)) =
        (* [Rule 6] *)
        let
            val tau = elabExp(C, exp)
            val rho = case exprow_opt
                        of NONE        => Type.emptyRho
                         | SOME exprow => elabExpRow(C, exprow)
        in
            if isSome(Type.findLab(rho, lab)) then
                (* Syntactic restriction [Section 2.9, 1st bullet] *)
                errorLab(I, "duplicate label ", lab)
            else
                Type.insertRho(rho, lab, tau)
        end


    (* Expressions *)

    and elabExp(C, ATEXPExp(I, atexp)) =
        (* [Rule 7] *)
        let
            val tau = elabAtExp(C, atexp)
        in
            tau
        end

      | elabExp(C, APPExp(I, exp, atexp)) =
        (* [Rule 8] *)
        let
            val tau1 = elabExp(C, exp)
            val tau' = elabAtExp(C, atexp)
            val tau  = Type.invent()
        in
            Type.unify(tau1, Type.fromFunType(tau',tau))
            handle Type.Unify => error(I, "type mismatch on application")
          ; tau
        end

      | elabExp(C, TYPEDExp(I, exp, ty)) =
        (* [Rule 9] *)
        let
            val tau1 = elabExp(C, exp)
            val tau  = elabTy(C, ty)
        in
            Type.unify(tau1,tau)
            handle Type.Unify =>
                   error(I, "expression does not match annotation")
          ; tau
        end

      | elabExp(C, HANDLEExp(I, exp, match)) =
        (* [Rule 10] *)
        let
            val tau1 = elabExp(C, exp)
            val tau2 = elabMatch(C, match)
        in
            Type.unify(tau1,tau2)
            handle Type.Unify =>
                   error(I, "type mismatch between expression and handler")
          ; tau1
        end

      | elabExp(C, RAISEExp(I, exp)) =
        (* [Rule 11] *)
        let
            val tau1 = elabExp(C, exp)
        in
            Type.unify(tau1, InitialStaticEnv.tauExn)
            handle Type.Unify =>
                   error(I, "raised expression is not an exception")
          ; Type.invent()
        end

      | elabExp(C, FNExp(I, match)) =
        (* [Rule 12] *)
        let
            val tau = elabMatch(C, match)
        in
            (* Further restriction [Section 4.11, item 2] *)
            CheckPattern.checkMatch(Context.Eof C, match)
          ; tau
        end


    (* Matches *)

    and elabMatch(C, Match(I, mrule, match_opt)) =
        (* [Rule 13] *)
        let
            val tau = elabMrule(C, mrule)
        in
            case match_opt
              of NONE       => tau
               | SOME match =>
                 let
                     val tau2 = elabMatch(C, match)
                 in
                     Type.unify(tau, tau2)
                     handle Type.Unify =>
                            error(I, "type mismatch between different matches")
                   ; tau
                 end
        end


    (* Match rules *)

    and elabMrule(C, Mrule(I, pat, exp)) =
        (* [Rule 14] *)
        let
            val (VE,tau) = elabPat(C, pat)
            val  tau'    = elabExp(C plusVE VE, exp)
            (* Side condition on type names is always ensured. *)
        in
            Type.fromFunType(tau,tau')
        end


    (* Declarations *)

    and elabDec(toplevel, C, VALDec(I, tyvarseq, valbind)) =
        (* [Rule 15] *)
        let
            val U'  = #1(tyvars(tyvarseq))
                      (* Collect implicitly bound tyvars [Section 4.6] *)
            val U   = TyVarSet.union(U',
                        TyVarSet.difference(unguardedTyVarsValBind valbind,
                                            Context.Uof C))
            val VE  = elabValBind(toplevel, C plusU U, valbind)
            val VE' = Clos(C,valbind) VE
            val  _  = StaticEnv.defaultOverloaded VE'
        in
            if not(TyVarSet.isEmpty(
                                TyVarSet.intersection(Context.Uof C, U))) then
                (* Syntactic restriction [Section 2.9, last bullet] *)
                error(I, "some type variables shadow previous ones")
            else if StaticEnv.containsFlexibleType VE' then
                (* Further restriction [Section 4.11, item 1] *)
                error(I, "unresolved flexible record type")
            else if TyVarSet.isEmpty(
                        TyVarSet.intersection(U, StaticEnv.tyvarsVE VE')) then
                StaticEnv.fromVE VE'
            else
                error(I, "some explicit type variables cannot be generalised")
        end

      | elabDec(toplevel, C, TYPEDec(I, typbind)) =
        (* [Rule 16] *)
        let
            val TE = elabTypBind(C, typbind)
        in
            StaticEnv.fromTE TE
        end

      | elabDec(toplevel, C, DATATYPEDec(I, datbind)) =
        (* [Rule 17] *)
        let
            val      TE1  = lhsDatBind datbind
            val (VE2,TE2) = elabDatBind(C oplusTE TE1, datbind)
            val (TE, VE)  = StaticEnv.maximiseEquality(TE2,VE2)
            (* Side condition on type names is always ensured. *)
        in
            StaticEnv.fromVEandTE(VE,TE)
        end

      | elabDec(toplevel, C, REPLICATIONDec(I, tycon, longtycon)) =
        (* [Rule 18] *)
        let
            val (theta,VE) = case Context.findLongTyCon(C, longtycon)
                              of SOME tystr => tystr
                               | NONE =>
                                 errorLongTyCon(I, "unknown type ", longtycon)
            val  TE        = TyConMap.singleton(tycon, (theta,VE))
        in
            StaticEnv.fromVEandTE(VE,TE)
        end

      | elabDec(toplevel, C, ABSTYPEDec(I, datbind, dec)) =
        (* [Rule 19] *)
        let
            val      TE1  = lhsDatBind datbind
            val (VE2,TE2) = elabDatBind(C oplusTE TE1, datbind)
            val (TE, VE)  = StaticEnv.maximiseEquality(TE2,VE2)
            val    E      = elabDec(false, C oplusVEandTE (VE,TE), dec)
            (* Side condition on type names is always ensured. *)
        in
            StaticEnv.Abs(TE,E)
        end

      | elabDec(toplevel, C, EXCEPTIONDec(I, exbind)) =
        (* [Rule 20] *)
        let
            val VE = elabExBind(C, exbind)
        in
            StaticEnv.fromVE VE
        end

      | elabDec(toplevel, C, LOCALDec(I, dec1, dec2)) =
        (* [Rule 21] *)
        let
            val E1 = elabDec(false, C, dec1)
            val E2 = elabDec(false, C oplusE E1, dec2)
        in
            E2
        end

      | elabDec(toplevel, C, OPENDec(I, longstrids)) =
        (* [Rule 22] *)
        let
            val Es =
                List.map
                    (fn longstrid =>
                        case Context.findLongStrId(C, longstrid)
                          of SOME(StaticEnv.Str E) => E
                           | NONE =>
                             errorLongStrId(I, "unknown structure ", longstrid))
                    longstrids
        in
            List.foldl StaticEnv.plus StaticEnv.empty Es
        end

      | elabDec(toplevel, C, EMPTYDec(I)) =
        (* [Rule 23] *)
        StaticEnv.empty

      | elabDec(toplevel, C, SEQDec(I, dec1, dec2)) =
        (* [Rule 24] *)
        let
            val E1 = elabDec(toplevel, C, dec1)
            val E2 = elabDec(toplevel, C oplusE E1, dec2)
        in
            StaticEnv.plus(E1, E2)
        end


    (* Value Bindings *)

    and elabValBind(toplevel, C, PLAINValBind(I, pat, exp, valbind_opt)) =
        (* [Rule 25] *)
        let
            val (VE,tau1) = elabPat(C, pat)
            val     tau2  = elabExp(C, exp)
            val VE'       = case valbind_opt
                              of NONE         => VIdMap.empty
                               | SOME valbind => elabValBind(toplevel, C, valbind)
        in
            Type.unify(tau1,tau2)
            handle Type.Unify =>
                   error(I, "type mismatch between pattern and expression")
          ; if toplevel then () else
                (* Further restriction [Section 4.11, item 3] *)
                CheckPattern.checkPat(Context.Eof C, pat)
          ; VIdMap.unionWithi
                (fn(vid,_,_) =>
                 (* Syntactic restriction [Section 2.9, 2nd bullet] *)
                 errorVId(I, "duplicate variable ", vid))
                (VE,VE')
        end

      | elabValBind(toplevel, C, RECValBind(I, valbind)) =
        (* [Rule 26] *)
        let
            val VE1 = lhsRecValBind valbind
            val VE  = elabValBind(toplevel, C plusVE VE1, valbind)
            (* Side condition on type names is always ensured. *)
        in
            VE
        end


    (* Type Bindings *)

    and elabTypBind(C, TypBind(I, tyvarseq, tycon, ty, typbind_opt)) =
        (* [Rule 27] *)
        let
            val (U,alphas) = tyvars tyvarseq
            val tau        = elabTy(C, ty)
            val TE         = case typbind_opt
                               of NONE         => TyConMap.empty
                                | SOME typbind => elabTypBind(C, typbind)
        in
            if not(TyVarSet.isSubset(Type.tyvars tau, U)) then
                (* Syntactic restriction (missing in the Definition!) *)
                error(I, "free type variables in type binding")
            else if isSome(TyConMap.find(TE, tycon)) then
                (* Syntactic restriction [Section 2.9, 2nd bullet] *)
                errorTyCon(I, "duplicate type constructor ", tycon)
            else
                TyConMap.insert(TE, tycon, ((alphas,tau),VIdMap.empty))
        end


    (* Datatype Bindings *)

    and elabDatBind(C, DatBind(I, tyvarseq, tycon, conbind, datbind_opt)) =
        (* [Rule 28, part 2] *)
        let
            val (U,alphas)   = tyvars tyvarseq
            val (alphas,tau) = case Context.findTyCon(C, tycon)
                                 of SOME(theta,VE) => theta
                                  | NONE => (* lhsDatBind inserted it! *)
                                    raise Fail "ElabCore.elabDatBind: \
                                                \tycon not pre-bound"
            val VE       = elabConBind(C,tau, conbind)
            val(VE',TE') = case datbind_opt
                             of NONE         => ( VIdMap.empty, TyConMap.empty )
                              | SOME datbind => elabDatBind(C, datbind)
                                (* Side condition on t is always true. *)
            val ClosVE   = if TyVarSet.isSubset(StaticEnv.tyvarsVE VE, U) then
                             StaticEnv.Clos VE
                           else
                             (* Syntactic restriction (missing in Definition!)*)
                             error(I, "free type variables in datatype binding")
        in
            if isSome(TyConMap.find(TE', tycon)) then
                  (* Syntactic restriction [Section 2.9, 2nd bullet] *)
                  errorTyCon(I, "duplicate type constructor ", tycon)
            else
            ( VIdMap.unionWithi (fn(vid,_,_) =>
                  (* Syntactic restriction [Section 2.9, 2nd bullet] *)
                  errorVId(I, "duplicate data cnstructor ", vid)) (ClosVE,VE')
            , TyConMap.insert(TE', tycon, ((alphas,tau),ClosVE))
            )
        end


    (* Constructor Bindings *)

    and elabConBind(C,tau, ConBind(I, _, vid, ty_opt, conbind_opt)) =
        (* [Rule 29] *)
        let
            val tau1 = case ty_opt
                         of NONE    => tau
                          | SOME ty =>
                            let
                                val tau' = elabTy(C, ty)
                            in
                                Type.fromFunType(tau',tau)
                            end
            val VE   = case conbind_opt
                         of NONE         => VIdMap.empty
                          | SOME conbind => elabConBind(C,tau, conbind)
        in
            if isSome(VIdMap.find(VE, vid)) then
                (* Syntactic restriction [Section 2.9, 2nd bullet] *)
                errorVId(I, "duplicate data constructor ", vid)
            else if not(validConBindVId vid) then
                (* Syntactic restriction [Section 2.9, 5th bullet] *)
                errorVId(I, "illegal rebinding of identifier ", vid)
            else
                VIdMap.insert(VE, vid, (([],tau1),IdStatus.c))
        end


    (* Exception Bindings *)

    and elabExBind(C, NEWExBind(I, _, vid, ty_opt, exbind_opt)) =
        (* [Rule 30] *)
        let
            val tau1 = case ty_opt
                         of NONE    => InitialStaticEnv.tauExn
                          | SOME ty =>
                            let
                                val tau = elabTy(C, ty)
                            in
                                Type.fromFunType(tau, InitialStaticEnv.tauExn)
                            end
            val VE   = case exbind_opt
                         of NONE        => VIdMap.empty
                          | SOME exbind => elabExBind(C, exbind)
        in
            if isSome(VIdMap.find(VE, vid)) then
                (* Syntactic restriction [Section 2.9, 2nd bullet] *)
                errorVId(I, "duplicate exception constructor ", vid)
            else if not(validConBindVId vid) then
                (* Syntactic restriction [Section 2.9, 5th bullet] *)
                errorVId(I, "illegal rebinding of identifier ", vid)
            else
                VIdMap.insert(VE, vid, (([],tau1),IdStatus.e))
        end

      | elabExBind(C, EQUALExBind(I, _, vid, _, longvid, exbind_opt)) =
        (* [Rule 31] *)
        let
            val tau = case Context.findLongVId(C, longvid)
                        of SOME(([],tau),IdStatus.e) => tau
                         | SOME _ =>
                           errorLongVId(I, "non-exception identifier ", longvid)
                         | NONE =>
                           errorLongVId(I, "unknown identifier ", longvid)
            val VE  = case exbind_opt
                        of NONE        => VIdMap.empty
                         | SOME exbind => elabExBind(C, exbind)
        in
            if isSome(VIdMap.find(VE, vid)) then
                (* Syntactic restriction [Section 2.9, 2nd bullet] *)
                errorVId(I, "duplicate exception constructor ", vid)
            else
                VIdMap.insert(VE, vid, (([],tau),IdStatus.e))
        end


    (* Atomic Patterns *)

    and elabAtPat(C, WILDCARDAtPat(I)) =
        (* [Rule 32] *)
        ( VIdMap.empty, Type.invent() )

      | elabAtPat(C, SCONAtPat(I, scon)) =
        (* [Rule 33] *)
        (case scon
           of SCon.REAL _ =>
              (* Syntactic restriction [Section 2.9, 6th bullet] *)
              error(I, "real constant in pattern")
            | _ =>
              ( VIdMap.empty, typeSCon scon )
        )

      | elabAtPat(C, LONGVIDAtPat(I, _, longvid)) =
        (* [Rule 34 and 35] *)
        let
            val (strids,vid) = LongVId.explode longvid
        in
            if List.null strids andalso
               ( case Context.findVId(C, vid)
                   of NONE           => true
                    | SOME(sigma,is) => is = IdStatus.v ) then
                (* [Rule 34] *)
                let
                    val tau = Type.invent()
                in
                    ( VIdMap.singleton(vid, (([],tau),IdStatus.v))
                    , tau )
                end
            else
                (* [Rule 35] *)
                let
                    val (sigma,is) = case Context.findLongVId(C, longvid)
                                       of SOME valstr => valstr
                                        | NONE =>
                                          errorLongVId(I,"unknown constructor ",
                                                         longvid)
                    val  tau       = TypeScheme.instance sigma
                    (* Note that tau will always be a ConsType. *)
                in
                    if is <> IdStatus.v then
                        ( VIdMap.empty, tau )
                    else
                        error(I, "non-constructor long identifier in pattern")
                end
        end

      | elabAtPat(C, RECORDAtPat(I, patrow_opt)) =
        (* [Rule 36] *)
        let
            val (VE,rho) = case patrow_opt
                             of NONE        => ( VIdMap.empty, Type.emptyRho )
                              | SOME patrow => elabPatRow(C, patrow)
        in
            (VE, Type.fromRowType rho)
        end

      | elabAtPat(C, PARAtPat(I, pat)) =
        (* [Rule 37] *)
        let
            val (VE,tau) = elabPat(C, pat)
        in
            (VE,tau)
        end


    (* Pattern Rows *)

    and elabPatRow(C, WILDCARDPatRow(I)) =
        (* [Rule 38] *)
        ( VIdMap.empty, Type.inventRho() )

      | elabPatRow(C, ROWPatRow(I, lab, pat, patrow_opt)) =
        (* [Rule 39] *)
        let
            val (VE,tau)  = elabPat(C, pat)
            val (VE',rho) = case patrow_opt
                              of NONE        => ( VIdMap.empty, Type.emptyRho )
                               | SOME patrow => elabPatRow(C, patrow)
        in
            if isSome(Type.findLab(rho, lab)) then
                (* Syntactic restriction [Section 2.9, 1st bullet] *)
                errorLab(I, "duplicate label ", lab)
            else
                ( VIdMap.unionWithi (fn(vid,_,_) =>
                      errorVId(I, "duplicate variable ", vid)) (VE,VE')
                , Type.insertRho(rho, lab, tau)
                )
        end


    (* Patterns *)

    and elabPat(C, ATPATPat(I, atpat)) =
        (* [Rule 40] *)
        let
            val (VE,tau) = elabAtPat(C, atpat)
        in
            (VE,tau)
        end

      | elabPat(C, CONPat(I, _, longvid, atpat)) =
        (* [Rule 41] *)
        let
            val (sigma,is) = case Context.findLongVId(C, longvid)
                               of SOME valstr => valstr
                                | NONE =>
                                errorLongVId(I, "unknown constructor ", longvid)
            val _          = if is <> IdStatus.v then () else
                                errorLongVId(I, "non-constructor ", longvid)
            val (tau',tau) = case !(TypeScheme.instance sigma)
                               of Type.FunType(tau',tau) => (tau', tau)
                                | _ =>
                                errorLongVId(I,"misplaced nullary constructor ",
                                                longvid)
            val (VE,tau'2)  = elabAtPat(C, atpat)
        in
            Type.unify(tau',tau'2)
            handle Type.Unify =>
                   error(I, "type mismatch in constructor pattern")
          ; (VE,tau)
        end

      | elabPat(C, TYPEDPat(I, pat, ty)) =
        (* [Rule 42] *)
        let
            val (VE,tau1) = elabPat(C, pat)
            val     tau   = elabTy(C, ty)
        in
            Type.unify(tau1,tau)
            handle Type.Unify => error(I, "pattern does not match annotation")
          ; (VE,tau)
        end

      | elabPat(C, ASPat(I, _, vid, ty_opt, pat)) =
        (* [Rule 43] *)
        let
            val (VE1,tau1) = elabPat(C, pat)
            val (VE, tau)  =
                case ty_opt
                  of NONE    => (VE1,tau1)
                   | SOME ty =>
                     let
                         val tau = elabTy(C, ty)
                     in
                         Type.unify(tau1,tau)
                         handle Type.Unify =>
                                error(I, "pattern does not match annotation")
                       ; (VE1,tau)
                     end
        in
            if not( case Context.findVId(C, vid)
                      of NONE           => true
                       | SOME(sigma,is) => is = IdStatus.v ) then
                errorVId(I, "misplaced constructor ", vid)
            else if isSome(VIdMap.find(VE, vid)) then
                errorVId(I, "duplicate variable ", vid)
            else
                ( VIdMap.insert(VE, vid, (([],tau),IdStatus.v)), tau )
        end


    (* Type Expressions *)

    and elabTy(C, ty) = Type.normalise(elabTy'(C, ty))

    and elabTy'(C, TYVARTy(I, tyvar)) =
        (* [Rule 44] *)
        let
            val alpha = tyvar
        in
            Type.fromTyVar alpha
        end

      | elabTy'(C, RECORDTy(I, tyrow_opt)) =
        (* [Rule 45] *)
        let
            val rho = case tyrow_opt
                        of NONE       => Type.emptyRho
                         | SOME tyrow => elabTyRow'(C, tyrow)
        in
            Type.fromRowType rho
        end

      | elabTy'(C, TYCONTy(I, tyseq, longtycon)) =
        (* [Rule 46] *)
        let
            val Tyseq(I',tys) = tyseq
            val k             = List.length tys
            val taus          = List.map (fn ty => elabTy'(C, ty)) tys
            val (theta,VE)    =
                case Context.findLongTyCon(C, longtycon)
                  of SOME tystr => tystr
                   | NONE =>
                     errorLongTyCon(I, "unknown type constructor ", longtycon)
        in
            TypeFcn.apply(taus, theta)
            handle TypeFcn.Apply =>
                errorLongTyCon(I, "arity mismatch at type application ",
                                  longtycon)
        end

      | elabTy'(C, ARROWTy(I, ty, ty')) =
        (* [Rule 47] *)
        let
            val tau  = elabTy'(C, ty)
            val tau' = elabTy'(C, ty')
        in
            Type.fromFunType(tau,tau')
        end

      | elabTy'(C, PARTy(I, ty)) =
        (* [Rule 48] *)
        let
            val tau = elabTy'(C, ty)
        in
            tau
        end


    (* Type-expression Rows *)

    and elabTyRow'(C, TyRow(I, lab, ty, tyrow_opt)) =
        (* [Rule 49] *)
        let
            val tau = elabTy'(C, ty)
            val rho = case tyrow_opt
                        of NONE       => Type.emptyRho
                         | SOME tyrow => elabTyRow'(C, tyrow)
        in
            if isSome(Type.findLab(rho, lab)) then
                (* Syntactic restriction [Section 2.9, 1st bullet] *)
                errorLab(I, "duplicate label ", lab)
            else
                Type.insertRho(rho, lab, tau)
        end



    (* Build tentative VE from LHSs of recursive valbind *)

    and lhsRecValBind(PLAINValBind(I, pat, exp, valbind_opt)) =
        let
            val VE  = lhsRecValBindPat pat
            val VE' = case valbind_opt
                        of NONE         => VIdMap.empty
                         | SOME valbind => lhsRecValBind valbind
            val _   = case exp
                        of FNExp _ => ()
                         | _ =>
                           (* Syntactic restriction [Section 2.9, 4th bullet] *)
                           error(I, "illegal expression within recursive \
                                    \value binding")
        in
            VIdMap.unionWithi
                (fn(vid,_,_) =>
                       (* Syntactic restriction [Section 2.9, 2nd bullet] *)
                       errorVId(I, "duplicate variable ", vid))  (VE,VE')
        end

      | lhsRecValBind(RECValBind(I, valbind)) =
            lhsRecValBind valbind

    and lhsRecValBindPat(ATPATPat(I, atpat)) =
            lhsRecValBindAtPat atpat

      | lhsRecValBindPat(CONPat(I, _, longvid, atpat)) =
            lhsRecValBindAtPat atpat

      | lhsRecValBindPat(TYPEDPat(I, pat, ty)) =
            lhsRecValBindPat pat

      | lhsRecValBindPat(ASPat(I, _, vid, ty_opt, pat)) =
        let
            val VE = lhsRecValBindPat pat
        in
            if isSome(VIdMap.find(VE, vid)) then
                (* Syntactic restriction [Section 2.9, 2nd bullet] *)
                errorVId(I, "duplicate variable ", vid)
            else if not(validBindVId vid) then
                (* Syntactic restriction [Section 2.9, 5th bullet] *)
                errorVId(I, "illegal rebinding of identifier ", vid)
            else
                VIdMap.insert(VE, vid, (([],Type.invent()), IdStatus.v))
        end

    and lhsRecValBindAtPat(WILDCARDAtPat(I)) =
            VIdMap.empty

      | lhsRecValBindAtPat(SCONAtPat(I, scon)) =
            VIdMap.empty

      | lhsRecValBindAtPat(LONGVIDAtPat(I, _, longvid)) =
           (case LongVId.explode longvid
              of ([], vid) =>
                    if not(validBindVId vid) then
                        (* Syntactic restriction [Section 2.9, 5th bullet] *)
                        errorVId(I, "illegal rebinding of identifier ", vid)
                    else
                        VIdMap.singleton(vid, (([],Type.invent()),IdStatus.v))

               | _ => VIdMap.empty
           )

      | lhsRecValBindAtPat(RECORDAtPat(I, patrow_opt)) =
           (case patrow_opt
              of NONE        => VIdMap.empty
               | SOME patrow => lhsRecValBindPatRow patrow
           )

      | lhsRecValBindAtPat(PARAtPat(I, pat)) =
            lhsRecValBindPat pat

    and lhsRecValBindPatRow(WILDCARDPatRow(I)) =
            VIdMap.empty

      | lhsRecValBindPatRow(ROWPatRow(I, lab, pat, patrow_opt)) =
        let
            val VE = lhsRecValBindPat pat
        in
            case patrow_opt
              of NONE        => VE
               | SOME patrow =>
                 let
                     val VE' = lhsRecValBindPatRow patrow
                 in
                     VIdMap.unionWithi (fn(vid,_,_) =>
                         (* Syntactic restriction [Section 2.9, 2nd bullet] *)
                         errorVId(I, "duplicate variable ", vid)) (VE,VE')
                 end
        end



    (* Build tentative TE from LHSs of datbind *)

    and lhsDatBind(DatBind(I, tyvarseq, tycon, conbind, datbind_opt)) =
        (* [Rule 28, part 1] *)
        let
            val (U,alphas) = tyvars tyvarseq
            val k          = List.length alphas
            val span       = lhsConBind conbind
            val t          = TyName.tyname(tycon, k, TyName.EQ, span)
            val tau        = Type.fromConsType(List.map Type.fromTyVar alphas,t)
            val TE'        = case datbind_opt
                               of NONE         => TyConMap.empty
                                | SOME datbind => lhsDatBind datbind
        in
            if isSome(TyConMap.find(TE', tycon)) then
                (* Syntactic restriction [Section 2.9, 2nd bullet] *)
                errorTyCon(I, "duplicate type constructor ", tycon)
            else
                TyConMap.insert(TE', tycon, ((alphas,tau), VIdMap.empty))
        end

    and lhsConBind(ConBind(I, _, vid, ty_opt, conbind_opt)) =
        case conbind_opt
          of NONE         => 1
           | SOME conbind => 1 + lhsConBind conbind

  end
(* stop of ElabCore.sml *)
(* start of ELAB_MODULE.sml *)
(*
 * Standard ML modules elaboration
 *
 * Definition, sections 5.7 and 3.5
 *
 * Note:
 *     Elaboration also checks the syntactic restrictions [Section 3.5].
 *)

signature ELAB_MODULE =
  sig

    (* Import types *)

    type TopDec = GrammarModule.TopDec
    type Basis  = StaticBasis.Basis


    (* Export *)

    val elabTopDec:     Basis * TopDec -> Basis

  end
(* stop of ELAB_MODULE.sml *)
(* start of ElabModule.sml *)
(*
 * Standard ML modules elaboration
 *
 * Definition, sections 5.7 and 3.5
 *
 * Notes:
 *   - Elaboration also checks the syntactic restrictions [Section 3.5].
 *   - To implement the 3rd restriction in 4.11 some elab functions are
 *     passed an additional boolean argument to recognise being on the toplevel.
 *)

structure ElabModule :> ELAB_MODULE =
  struct

    (* Import *)

    type TopDec = GrammarModule.TopDec
    type Basis  = StaticBasis.Basis


    open GrammarModule


    (* Helpers for error messages *)

    val error = Error.error

    fun errorVId  (I, s, vid)   = error(I, s ^ VId.toString vid)
    fun errorTyCon(I, s, tycon) = error(I, s ^ TyCon.toString tycon)
    fun errorStrId(I, s, strid) = error(I, s ^ StrId.toString strid)
    fun errorSigId(I, s, sigid) = error(I, s ^ SigId.toString sigid)
    fun errorFunId(I, s, funid) = error(I, s ^ FunId.toString funid)

    fun errorLongTyCon(I, s, longtycon) =
        error(I, s ^ LongTyCon.toString longtycon)
    fun errorLongStrId(I, s, longstrid) =
        error(I, s ^ LongStrId.toString longstrid)


    (* Helpers for basis modification *)

    val plus    = StaticBasis.plus
    val plusT   = StaticBasis.plusT
    val oplusSE = StaticBasis.oplusSE
    val oplusG  = StaticBasis.oplusG
    val oplusF  = StaticBasis.oplusF
    val oplusE  = StaticBasis.oplusE

    infix plus plusT oplusG oplusF oplusE oplusSE



    (* Inference rules [Section 5.7] *)


    (* Structure Expressions *)

    fun elabStrExp(B, STRUCTStrExp(I, strdec)) =
        (* [Rule 50] *)
        let
            val E = elabStrDec(false, B, strdec)
        in
            E
        end

      | elabStrExp(B, LONGSTRIDStrExp(I, longstrid)) =
        (* [Rule 51] *)
        let
            val E = case StaticBasis.findLongStrId(B, longstrid)
                      of SOME(StaticEnv.Str E) => E
                       | NONE =>
                         errorLongStrId(I, "unknown structure ", longstrid)
        in
            E
        end

      | elabStrExp(B, TRANSStrExp(I, strexp, sigexp)) =
        (* [Rule 52] *)
        let
            val E      = elabStrExp(B, strexp)
            val Sigma  = elabSigExp(B, sigexp)
            val (E',_) = Sig.match(E, Sigma)
                         handle Sig.Match =>
                                error(I, "structure does not match constraint")
        in
            E'
        end

      | elabStrExp(B, OPAQStrExp(I, strexp, sigexp)) =
        (* [Rule 53] *)
        let
            val E       = elabStrExp(B, strexp)
            val (T',E') = Sig.rename(elabSigExp(B, sigexp))
            val (E'',_) = Sig.match(E, (T',E'))
                          handle Sig.Match =>
                                 error(I, "structure does not match constraint")
            (* Renaming ensures side condition on T' *)
        in
            E'
        end

      | elabStrExp(B, APPStrExp(I, funid, strexp)) =
        (* [Rule 54] *)
        let
            val E = elabStrExp(B, strexp)
            val (T1'',(E1'',(T1',E1'))) =
                      case StaticBasis.findFunId(B, funid)
                        of SOME Phi => Phi
                         | NONE     => errorFunId(I, "unknown functor ", funid)
            val (E'',phi) = Sig.match(E, (T1'',E1''))
                            handle Sig.Match =>
                                error(I, "structure does not match constraint")
            val (T',E')   = Sig.rename (T1', StaticEnv.realise phi E1')
            (* Renaming ensures side condition on T' *)
        in
            E'
        end

      | elabStrExp(B, LETStrExp(I, strdec, strexp)) =
        (* [Rule 55] *)
        let
            val E1 = elabStrDec(false, B, strdec)
            val E2 = elabStrExp(B oplusE E1, strexp)
        in
            E2
        end


    (* Structure-level Declarations *)

    and elabStrDec(toplevel, B, DECStrDec(I, dec)) =
        (* [Rule 56] *)
        let
            val E = ElabCore.elabDec(toplevel, StaticBasis.Cof B, dec)
        in
            E
        end

      | elabStrDec(toplevel, B, STRUCTUREStrDec(I, strbind)) =
        (* [Rule 57] *)
        let
            val SE = elabStrBind(B, strbind)
        in
            StaticEnv.fromSE SE
        end

      | elabStrDec(toplevel, B, LOCALStrDec(I, strdec1, strdec2)) =
        (* [Rule 58] *)
        let
            val E1 = elabStrDec(false, B, strdec1)
            val E2 = elabStrDec(false, B oplusE E1, strdec2)
        in
            E2
        end

      | elabStrDec(toplevel, B, EMPTYStrDec(I)) =
        (* [Rule 59] *)
        StaticEnv.empty

      | elabStrDec(toplevel, B, SEQStrDec(I, strdec1, strdec2)) =
        (* [Rule 60] *)
        let
            val E1 = elabStrDec(toplevel, B, strdec1)
            val E2 = elabStrDec(toplevel, B oplusE E1, strdec2)
        in
            StaticEnv.plus(E1,E2)
        end


    (* Structure Bindings *)

    and elabStrBind(B, StrBind(I, strid, strexp, strbind_opt)) =
        (* [Rule 61] *)
        let
            val E  = elabStrExp(B, strexp)
            val SE = case strbind_opt
                       of NONE         => StrIdMap.empty
                        | SOME strbind =>
                          elabStrBind(B plusT StaticEnv.tynames E, strbind)
        in
            if isSome(StrIdMap.find(SE, strid)) then
                (* Syntactic restriction [Section 3.5, 1st bullet] *)
                errorStrId(I, "duplicate structure identifier ", strid)
            else
                StrIdMap.insert(SE, strid, StaticEnv.Str E)
        end


    (* Signature Expressions *)

    and elabSigExpE(B, SIGSigExp(I, spec)) =
        (* [Rule 62] *)
        let
            val E = elabSpec(B, spec)
        in
            E
        end

      | elabSigExpE(B, SIGIDSigExp(I, sigid)) =
        (* [Rule 63] *)
        let
            val (T,E) = case StaticBasis.findSigId(B, sigid)
                          of SOME Sigma => Sig.rename Sigma
                           | NONE => errorSigId(I, "unknown signature ",sigid)
        in
            E
        end

      | elabSigExpE(B, WHERETYPESigExp(I, sigexp, tyvarseq, longtycon, ty)) =
        (* [Rule 64] *)
        let
            val E      = elabSigExpE(B, sigexp)
            val alphas = #2(ElabCore.tyvars tyvarseq)
            val tau    = ElabCore.elabTy(StaticBasis.Cof B, ty)
            val t      = case StaticEnv.findLongTyCon(E,longtycon)
                           of NONE =>
                              errorLongTyCon(I, "unknown type ", longtycon)
                            | SOME(theta,VE) =>
                         case TypeFcn.toTyName theta
                           of NONE =>
                              errorLongTyCon(I, "non-flexible type ", longtycon)
                            | SOME t => t
            val  _     = if not(TyNameSet.member(StaticBasis.Tof B, t)) then ()
                         else errorLongTyCon(I, "rigid type ", longtycon)
            val phi    = TyNameMap.singleton(t, (alphas,tau))
            val  _     = if TyName.equality t = TyName.NOEQ
                         orelse TypeFcn.admitsEquality (alphas,tau) then () else
                          error(I, "type realisation does not respect equality")
            val E'     = StaticEnv.realise phi E
            val  _     = if StaticEnv.isWellFormed E' then () else
                          error(I, "type realisation does not respect datatype")
        in
            E'
        end

    and elabSigExp(B, sigexp) =
        (* [Rule 65] *)
        let
            val E = elabSigExpE(B, sigexp)
            val T = TyNameSet.difference(StaticEnv.tynames E, StaticBasis.Tof B)
        in
            (T,E)
        end


    (* Signature Declarations *)

    and elabSigDec(B, SigDec(I, sigbind)) =
        (* [Rule 66] *)
        let
            val G = elabSigBind(B, sigbind)
        in
            G
        end


    (* Signature Bindings *)

    and elabSigBind(B, SigBind(I, sigid, sigexp, sigbind_opt)) =
        (* [Rule 67] *)
        let
            val Sigma = elabSigExp(B, sigexp)
            val G     = case sigbind_opt
                          of NONE         => SigIdMap.empty
                           | SOME sigbind => elabSigBind(B, sigbind)
        in
            if isSome(SigIdMap.find(G, sigid)) then
                (* Syntactic restriction [Section 3.5, 1st bullet] *)
                errorSigId(I, "duplicate signature identifier ", sigid)
            else
                SigIdMap.insert(G, sigid, Sigma)
        end


    (* Specifications *)

    and elabSpec(B, VALSpec(I, valdesc)) =
        (* [Rule 68] *)
        let
            val VE = elabValDesc(StaticBasis.Cof B, valdesc)
        in
            StaticEnv.fromVE(StaticEnv.Clos VE)
        end

      | elabSpec(B, TYPESpec(I, typdesc)) =
        (* [Rule 69] *)
        let
            val TE = elabTypDesc(StaticBasis.Cof B, typdesc)
            (* Side condition on type names is always ensured. *)
        in
            StaticEnv.fromTE TE
        end

      | elabSpec(B, EQTYPESpec(I, typdesc)) =
        (* [Rule 70] *)
        let
            val TE = elabTypDesc(StaticBasis.Cof B, typdesc)
            val _  = StaticEnv.makeEquality TE
        in
            StaticEnv.fromTE TE
        end

      | elabSpec(B, DATATYPESpec(I, datdesc)) =
        (* [Rule 71] *)
        let
            val      TE1  = lhsDatDesc datdesc
            val (VE2,TE2) = elabDatDesc(Context.oplusTE(StaticBasis.Cof B,TE1),
                                        datdesc)
            val (TE, VE)  = StaticEnv.maximiseEquality(TE2,VE2)
            (* Side condition on type names is always ensured. *)
        in
            StaticEnv.fromVEandTE(VE,TE)
        end

      | elabSpec(B, REPLICATIONSpec(I, tycon, longtycon)) =
        (* [Rule 72] *)
        let
            val (theta,VE) = case StaticBasis.findLongTyCon(B, longtycon)
                              of SOME tystr => tystr
                               | NONE =>
                                 errorLongTyCon(I, "unknown type ", longtycon)
            val  TE        = TyConMap.singleton(tycon, (theta,VE))
        in
            StaticEnv.fromVEandTE(VE,TE)
        end

      | elabSpec(B, EXCEPTIONSpec(I, exdesc)) =
        (* [Rule 73] *)
        let
            val VE = elabExDesc(StaticBasis.Cof B, exdesc)
        in
            StaticEnv.fromVE VE
        end

      | elabSpec(B, STRUCTURESpec(I, strdesc)) =
        (* [Rule 74] *)
        let
            val SE = elabStrDesc(B, strdesc)
        in
            StaticEnv.fromSE SE
        end

      | elabSpec(B, INCLUDESpec(I, sigexp)) =
        (* [Rule 75] *)
        let
            val E = elabSigExpE(B, sigexp)
        in
            E
        end

      | elabSpec(B, EMPTYSpec(I)) =
        (* [Rule 76] *)
        StaticEnv.empty

      | elabSpec(B, SEQSpec(I, spec1, spec2)) =
        (* [Rule 77] *)
        let
            val E1 = elabSpec(B, spec1)
            val E2 = elabSpec(B oplusE E1, spec2)
            val _  = if StaticEnv.disjoint(E1,E2) then () else
                     error(I, "duplicate specifications in signature")
        in
            StaticEnv.plus(E1,E2)
        end

      | elabSpec(B, SHARINGTYPESpec(I, spec, longtycons)) =
        (* [Rule 78] *)
        let
            val E  = elabSpec(B, spec)
            val ts =
                List.map
                (fn longtycon =>
                 case StaticEnv.findLongTyCon(E, longtycon)
                   of NONE =>
                        errorLongTyCon(I, "unknown type ", longtycon)
                    | SOME(theta,VE) =>
                 case TypeFcn.toTyName theta
                   of NONE =>
                        errorLongTyCon(I, "non-flexible type ", longtycon)
                    | SOME t =>
                      if TyNameSet.member(StaticBasis.Tof B, t) then
                        errorLongTyCon(I, "rigid type ", longtycon)
                      else
                        t
                )
                longtycons
            val equality = if List.exists
                                (fn t => TyName.equality t <> TyName.NOEQ) ts
                           then TyName.EQ
                           else TyName.NOEQ
            val span  = List.foldl
                                (fn(t, span) => Int.max(TyName.span t, span))
                                0 ts
            val t1    = List.hd ts
            val t     = TyName.tyname(TyName.tycon t1, TyName.arity t1,
                                      equality, span)
            val theta = TypeFcn.fromTyName t
            val phi   = List.foldl
                            (fn(ti, phi) => TyNameMap.insert(phi, ti, theta))
                            TyNameMap.empty ts
        in
            StaticEnv.realise phi E
        end

      | elabSpec(B, SHARINGSpec(I, spec, longstrids)) =
        (* [Appendix A] *)
        let
            fun shareFlexibleTyName(t1, t2, phi) =
                let
                    val equality = if TyName.equality t1 <> TyName.NOEQ
                                   orelse TyName.equality t2 <> TyName.NOEQ
                                   then TyName.EQ
                                   else TyName.NOEQ
                    val t        = TyName.tyname(TyName.tycon t1,
                                                 TyName.arity t1,
                                                 equality,
                                                 Int.max(TyName.span t1,
                                                         TyName.span t2))
                    val theta    = TypeFcn.fromTyName t
                in
                    TyNameMap.insert(TyNameMap.insert(phi,
                        t1, theta),
                        t2, theta)
                end

            fun shareTE(TE1, TE2, phi) =
                TyConMap.foldli
                    (fn(tycon, (theta1,VE1), phi) =>
                        case TyConMap.find(TE2, tycon)
                          of NONE             => phi
                           | SOME(theta2,VE2) =>
                        case (TypeFcn.toTyName(TypeFcn.realise phi theta1),
                              TypeFcn.toTyName(TypeFcn.realise phi theta2))
                          of (SOME t1, SOME t2) =>
                             if TyNameSet.member(StaticBasis.Tof B, t1)
                             orelse TyNameSet.member(StaticBasis.Tof B,t2) then
                                errorTyCon(I, "structure contains rigid type ",
                                              tycon)
                             else
                                shareFlexibleTyName(t1, t2, phi)
                           | _ =>
                             errorTyCon(I, "structure contains non-flexible \
                                           \type ", tycon)
                    )
                    phi TE1

            fun shareSE(SE1, SE2, phi) =
                StrIdMap.foldli
                    (fn(strid, StaticEnv.Str E1, phi) =>
                        case StrIdMap.find(SE2, strid)
                          of NONE                   => phi
                           | SOME(StaticEnv.Str E2) => shareE(E1, E2, phi)
                    )
                    phi SE1

            and shareE((SE1,TE1,VE1), (SE2,TE2,VE2), phi) =
                let
                    val phi'  = shareTE(TE1, TE2, phi)
                    val phi'' = shareSE(SE1, SE2, phi')
                in
                    phi''
                end

            fun share1(E1,   [],   phi) = phi
              | share1(E1, E2::Es, phi) =
                let
                    val phi' = shareE(E1, E2, phi)
                in
                    share1(E1, Es, phi')
                end

            fun shareAll( [],   phi) = phi
              | shareAll(E::Es, phi) =
                let
                    val phi' = share1(E, Es, phi)
                in
                    shareAll(Es, phi')
                end

            val E   = elabSpec(B, spec)
            val Es  = List.map
                        (fn longstrid =>
                         case StaticEnv.findLongStrId(E, longstrid)
                           of SOME(StaticEnv.Str E') => E'
                            | NONE =>
                              errorLongStrId(I, "unknown structure ", longstrid)
                        ) longstrids
            val phi = shareAll(Es, TyNameMap.empty)
        in
            StaticEnv.realise phi E
        end


    (* Value Descriptions *)

    and elabValDesc(C, ValDesc(I, vid, ty, valdesc_opt)) =
        (* [Rule 79] *)
        let
            val tau = ElabCore.elabTy(C, ty)
            val VE  = case valdesc_opt
                        of NONE         => VIdMap.empty
                         | SOME valdesc => elabValDesc(C, valdesc)
        in
            if isSome(VIdMap.find(VE, vid)) then
                (* Syntactic restriction [Section 3.5, 2nd bullet] *)
                errorVId(I, "duplicate variable ", vid)
            else if not(ElabCore.validBindVId vid) then
                (* Syntactic restriction [Section 3.5, 5th bullet] *)
                errorVId(I, "illegal specification of identifier ", vid)
            else
                VIdMap.insert(VE, vid, (([],tau),IdStatus.v))
        end


    (* Type Descriptions *)

    and elabTypDesc(C, TypDesc(I, tyvarseq, tycon, typdesc_opt)) =
        (* [Rule 80] *)
        let
            val alphas = #2(ElabCore.tyvars tyvarseq)
            val k      = List.length alphas
            val t      = TyName.tyname(tycon, k, TyName.NOEQ, 0)
            val TE     = case typdesc_opt
                           of NONE         => TyConMap.empty
                            | SOME typdesc => elabTypDesc(C, typdesc)
                              (* Side condition on t is always true. *)
            val tau    = Type.fromConsType (List.map Type.fromTyVar alphas, t)
        in
            if isSome(TyConMap.find(TE, tycon)) then
                (* Syntactic restriction [Section 3.5, 2nd bullet] *)
                errorTyCon(I, "duplicate type constructor ", tycon)
            else
                TyConMap.insert(TE, tycon, ((alphas,tau),VIdMap.empty))
        end


    (* Datatype Descriptions *)

    and elabDatDesc(C, DatDesc(I, tyvarseq, tycon, condesc, datdesc_opt)) =
        (* [Rule 81, part 2] *)
        let
            val (U,alphas)   = ElabCore.tyvars tyvarseq
            val (alphas,tau) = case Context.findTyCon(C, tycon)
                                 of SOME(theta,VE) => theta
                                  | NONE => (* lhsDatDesc inserted it! *)
                                    raise Fail "ElabCore.elabDatDesc: \
                                                \tycon not pre-bound"
            val VE       = elabConDesc(C,tau, condesc)
            val(VE',TE') = case datdesc_opt
                             of NONE         => ( VIdMap.empty, TyConMap.empty )
                              | SOME datdesc => elabDatDesc(C, datdesc)
                                (* Side condition on t is always true. *)
            val ClosVE   = if TyVarSet.isSubset(StaticEnv.tyvarsVE VE, U) then
                             StaticEnv.Clos VE
                           else
                             (* Syntactic restriction [Section 3.5,4th bullet]*)
                             error(I, "free type variables \
                                      \in datatype description")
        in
            if isSome(TyConMap.find(TE', tycon)) then
                  (* Syntactic restriction [Section 3.5, 2nd bullet] *)
                  errorTyCon(I, "duplicate type constructor ", tycon)
            else
            ( VIdMap.unionWithi (fn(vid,_,_) =>
                  (* Syntactic restriction [Section 3.5, 2nd bullet] *)
                  errorVId(I, "duplicate data cnstructor ", vid)) (ClosVE,VE')
            , TyConMap.insert(TE', tycon, ((alphas,tau),ClosVE))
            )
        end


    (* Constructor Descriptions *)

    and elabConDesc(C,tau, ConDesc(I, vid, ty_opt, condesc_opt)) =
        (* [Rule 82] *)
        let
            val tau1 = case ty_opt
                         of NONE    => tau
                          | SOME ty =>
                            let
                                val tau' = ElabCore.elabTy(C, ty)
                            in
                                Type.fromFunType(tau',tau)
                            end
            val VE   = case condesc_opt
                         of NONE         => VIdMap.empty
                          | SOME condesc => elabConDesc(C,tau, condesc)
        in
            if isSome(VIdMap.find(VE, vid)) then
                (* Syntactic restriction [Section 3.5, 2nd bullet] *)
                errorVId(I, "duplicate data constructor ", vid)
            else if not(ElabCore.validConBindVId vid) then
                (* Syntactic restriction [Section 3.5, 5th bullet] *)
                errorVId(I, "illegal specifiation of identifier ", vid)
            else
                VIdMap.insert(VE, vid, (([],tau1),IdStatus.c))
        end


    (* Exception Description *)

    and elabExDesc(C, ExDesc(I, vid, ty_opt, exdesc_opt)) =
        (* [Rule 83] *)
        let
            val tau1 = case ty_opt
                         of NONE    => InitialStaticEnv.tauExn
                          | SOME ty =>
                            let
                                val tau = ElabCore.elabTy(C, ty)
                                val  _  = if TyVarSet.isEmpty(Type.tyvars tau)
                                          then () else
                                          error(I, "free type variables \
                                                   \in exception description")
                            in
                                Type.fromFunType(tau, InitialStaticEnv.tauExn)
                            end
            val VE   = case exdesc_opt
                         of NONE        => VIdMap.empty
                          | SOME exdesc => elabExDesc(C, exdesc)
        in
            if isSome(VIdMap.find(VE, vid)) then
                (* Syntactic restriction [Section 3.5, 2nd bullet] *)
                errorVId(I, "duplicate exception constructor ", vid)
            else if not(ElabCore.validConBindVId vid) then
                (* Syntactic restriction [Section 3.5, 5th bullet] *)
                errorVId(I, "illegal specification of identifier ", vid)
            else
                VIdMap.insert(VE, vid, (([],tau1),IdStatus.e))
        end


    (* Structure Descriptions *)

    and elabStrDesc(B, StrDesc(I, strid, sigexp, strdesc_opt)) =
        (* [Rule 84] *)
        let
            val E  = elabSigExpE(B, sigexp)
            val SE = case strdesc_opt
                       of NONE         => StrIdMap.empty
                        | SOME strdesc =>
                          elabStrDesc(B plusT StaticEnv.tynames E, strdesc)
        in
            if isSome(StrIdMap.find(SE, strid)) then
                (* Syntactic restriction [Section 3.5, 2nd bullet] *)
                errorStrId(I, "duplicate structure identifier ", strid)
            else
                StrIdMap.insert(SE, strid, StaticEnv.Str E)
        end


    (* Functor Declarations *)

    and elabFunDec(B, FunDec(I, funbind)) =
        (* [Rule 85] *)
        let
            val F = elabFunBind(B, funbind)
        in
            F
        end


    (* Functor Bindings *)

    and elabFunBind(B, FunBind(I, funid, strid, sigexp, strexp, funbind_opt)) =
        (* [Rule 86] *)
        let
            val (T,E) = elabSigExp(B, sigexp)
            val  E'   = elabStrExp(
                           B oplusSE StrIdMap.singleton(strid,StaticEnv.Str E),
                           strexp)
            (* Side condition on T is always ensured. *)
            val T'    = TyNameSet.difference(StaticEnv.tynames E',
                                TyNameSet.union(StaticBasis.Tof B, T))
            val F     = case funbind_opt
                          of NONE         => FunIdMap.empty
                           | SOME funbind => elabFunBind(B, funbind)
        in
            if isSome(FunIdMap.find(F, funid)) then
                (* Syntactic restriction [Section 3.5, 1st bullet] *)
                errorFunId(I, "duplicate functor identifier ", funid)
            else
                FunIdMap.insert(F, funid, (T,(E,(T',E'))))
        end


    (* Top-level Declarations *)

    and elabTopDec(B, STRDECTopDec(I, strdec, topdec_opt)) =
        (* [Rule 87] *)
        let
            val E   = elabStrDec(true, B, strdec)
            val B'  = case topdec_opt
                        of NONE        => StaticBasis.empty
                         | SOME topdec => elabTopDec(B oplusE E, topdec)
            val B'' = StaticBasis.plus
                        (StaticBasis.fromTandE(StaticEnv.tynames E, E), B')
        in
            if TyVarSet.isEmpty(StaticBasis.tyvars B'') then
                B''
            else
                error(I, "free type variables on top-level")
        end

      | elabTopDec(B, SIGDECTopDec(I, sigdec, topdec_opt)) =
        (* [Rule 88] *)
        let
            val G   = elabSigDec(B, sigdec)
            val B'  = case topdec_opt
                        of NONE        => StaticBasis.empty
                         | SOME topdec => elabTopDec(B oplusG G, topdec)
            val B'' = StaticBasis.plus
                        (StaticBasis.fromTandG(StaticBasis.tynamesG G, G), B')
        in
            B''
        end

      | elabTopDec(B, FUNDECTopDec(I, fundec, topdec_opt)) =
        (* [Rule 89] *)
        let
            val F   = elabFunDec(B, fundec)
            val B'  = case topdec_opt
                        of NONE        => StaticBasis.empty
                         | SOME topdec => elabTopDec(B oplusF F, topdec)
            val B'' = StaticBasis.plus
                        (StaticBasis.fromTandF(StaticBasis.tynamesF F, F), B')
        in
            if TyVarSet.isEmpty(StaticBasis.tyvars B'') then
                B''
            else
                error(I, "free type variables on top-level")
        end



    (* Build tentative TE from LHSs of datdesc *)

    and lhsDatDesc(DatDesc(I, tyvarseq, tycon, condesc, datdesc_opt)) =
        (* [Rule 81, part 1] *)
        let
            val (U,alphas) = ElabCore.tyvars tyvarseq
            val k          = List.length alphas
            val span       = lhsConDesc condesc
            val t          = TyName.tyname(tycon, k, TyName.EQ, span)
            val tau        = Type.fromConsType(List.map Type.fromTyVar alphas,t)
            val TE'        = case datdesc_opt
                               of NONE         => TyConMap.empty
                                | SOME datdesc => lhsDatDesc datdesc
        in
            if isSome(TyConMap.find(TE', tycon)) then
                (* Syntactic restriction [Section 3.5, 2nd bullet] *)
                errorTyCon(I, "duplicate type constructor ", tycon)
            else
                TyConMap.insert(TE', tycon, ((alphas,tau), VIdMap.empty))
        end

    and lhsConDesc(ConDesc(I, vid, ty_opt, condesc_opt)) =
        case condesc_opt
          of NONE         => 1
           | SOME condesc => 1 + lhsConDesc condesc

  end
(* stop of ElabModule.sml *)
(* start of PP_TYPE.sml *)
(*
 * Standard ML pretty printing of types and type schemes
 *)

signature PP_TYPE =
  sig

    type doc        = PrettyPrint.doc
    type Type       = Type.Type
    type TypeScheme = TypeScheme.TypeScheme

    val ppType:         Type -> doc
    val ppTypeScheme:   TypeScheme -> doc

  end
(* stop of PP_TYPE.sml *)
(* start of PPType.sml *)
(*
 * Standard ML pretty printing of types and type schemes
 *)

structure PPType :> PP_TYPE =
  struct

    (* Import *)

    type TypeScheme = TypeScheme.TypeScheme

    open Type
    open PrettyPrint
    open PPMisc

    infixr ^^ ^/^


    (* Simple objects *)

    fun ppLab lab     = text(Lab.toString lab)
    fun ppTyVar alpha = text(TyVar.toString alpha)
    fun ppTyName t    = text(TyName.toString t)

    fun ppOverloadingClass O =
        let
            val T  = OverloadingClass.set O
            val t  = OverloadingClass.default O
            val ts = t :: TyNameSet.listItems(TyNameSet.delete(T,t))
        in
            brack(ppCommaList ppTyName ts)
        end


    fun ppRowVar CLOSEDRow  = empty
      | ppRowVar(FLEXRow _) = text "," ^^ break ^^ text "..."


    (* Types *)

    (* Precedence:
     *  0 : function arrow (ty1 -> ty2)
     *  1 : tuple (ty1 * ... * tyn)
     *  2 : constructed type (tyseq tycon)
     *)

    fun ppType tau = fbox(below(nest(ppTypePrec 0 tau)))

    and ppTypePrec p (ref tau')        = ppType'Prec p tau'

    and ppType'Prec p (TyVar(alpha))   = ppTyVar alpha

      | ppType'Prec p (RowType(Rho,r)) =
        let
            fun isTuple(   [],     n) = n > 2
              | isTuple(lab::labs, n) =
                    lab = Lab.fromInt n andalso isTuple(labs, n+1)

            val labtaus     = LabMap.listItemsi Rho
            val (labs,taus) = ListPair.unzip labtaus
        in
            if r = CLOSEDRow andalso List.null labs then
                text "unit"
            else if r = CLOSEDRow andalso isTuple(labs, 1) then
                let
                    val doc = ppStarList (ppTypePrec 2) taus
                in
                    if p > 1 then
                        paren doc
                    else
                        fbox(below(nest doc))
                end
            else
                brace(ppCommaList ppLabType labtaus ^^ ppRowVar r)
        end

      | ppType'Prec p (FunType(tau1,tau2)) =
        let
            val doc = ppTypePrec 1 tau1 ^/^
                      text "->" ^/^
                      ppTypePrec 0 tau2
        in
            if p > 0 then
                paren doc
            else
                doc
        end

      | ppType'Prec p (ConsType(taus,t)) =
            fbox(nest(ppSeqPrec ppTypePrec 2 taus ^/^ ppTyName t))

      | ppType'Prec p (Overloaded(O)) =
            text "'" ^^ ppOverloadingClass O

      | ppType'Prec p (Link tau) =
            ppTypePrec p tau

    and ppLabType(lab, tau) =
            abox(
                hbox(
                    ppLab lab ^/^
                    text ":"
                ) ^^
                below(nest(break ^^
                    ppType tau
                ))
            )


    (* Type schemes *)

    fun ppTypeScheme sigma =
        let
            val (alphas,tau) = TypeScheme.normalise sigma
        in
            ppType tau
        end

  end
(* stop of PPType.sml *)
(* start of PP_STATIC_ENV.sml *)
(*
 * Standard ML pretty printing of the static environment
 *)

signature PP_STATIC_ENV =
  sig

    type doc       = PrettyPrint.doc
    type ValEnv    = StaticEnv.ValEnv
    type TyEnv     = StaticEnv.TyEnv
    type Env       = StaticEnv.Env
    type TyNameSet = TyNameSet.set

    val ppEnv:   Env -> doc
    val ppSig:   TyNameSet * Env -> doc

    val ppTyEnv: TyNameSet * TyEnv -> doc
    val ppExEnv: ValEnv -> doc

  end
(* stop of PP_STATIC_ENV.sml *)
(* start of PPStaticEnv.sml *)
(*
 * Standard ML pretty printing of the static environment
 *)

structure PPStaticEnv :> PP_STATIC_ENV =
  struct

    (* Import *)

    type ValEnv    = StaticEnv.ValEnv
    type TyEnv     = StaticEnv.TyEnv
    type Env       = StaticEnv.Env
    type TyNameSet = TyNameSet.set

    open PrettyPrint
    open PPMisc

    infixr ^^ ^/^


    (* Simple objects *)

    fun ppVId vid     = text(VId.toString vid)
    fun ppTyCon tycon = text(TyCon.toString tycon)
    fun ppTyVar alpha = text(TyVar.toString alpha)
    fun ppStrId strid = text(StrId.toString strid)

    fun ppTyName t    = text(TyName.toString t)


    (* Environments *)

    fun ppConTypeScheme (_, ref(Type.FunType(tau,_))) =
            text "of" ^^ break ^^ PPType.ppType tau

      | ppConTypeScheme _ = empty


    fun ppValEnv VE =
        VIdMap.foldri
            (fn(vid, (sigma,IdStatus.v), doc) =>
                abox(
                    hbox(
                        text "val" ^/^
                        ppVId vid ^/^
                        text ":"
                    ) ^^
                    nest(break ^^
                        abox(PPType.ppTypeScheme sigma)
                    )
                ) ^/^
                doc

             | (vid, (sigma,_), doc) => doc
            )
            empty VE

    fun ppExEnv VE =
        VIdMap.foldri
            (fn(vid, (sigma,IdStatus.e), doc) =>
                abox(
                    hbox(
                        text "exception" ^/^
                        ppVId vid
                    ) ^^
                    nest(break ^^
                        abox(ppConTypeScheme sigma)
                    )
                ) ^/^
                doc

             | (vid, (sigma,_), doc) => doc
            )
            empty VE

    fun ppConEnv VE =
        VIdMap.foldli
            (fn(vid, (sigma,_), doc) =>
                doc ^/^
                abox(
                    hbox(
                        (if isEmpty doc then empty else text "|") ^/^
                        ppVId vid
                    ) ^^
                    nest(text "" ^/^
                        abox(ppConTypeScheme sigma)
                    )
                )
            )
            empty VE


    fun absTy(T, tycon, theta) =
        case TypeFcn.toTyName theta
          of NONE    => NONE
           | SOME t  => if TyName.tycon t = tycon
                        andalso TyNameSet.member(T, t) then
                            SOME(TyName.equality t <> TyName.NOEQ)
                        else
                            NONE

    fun ppAbsTyEnv(T,TE) =
        TyConMap.foldri
            (fn(tycon, (theta as (alphas,tau), VE), doc) =>
                if VIdMap.isEmpty VE then
                case absTy(T, tycon, theta)
                 of NONE    => doc
                  | SOME eq =>
                    abox(
                        hbox(
                            text(if eq then "eqtype" else "type") ^/^
                            ppSeq ppTyVar alphas ^/^
                            ppTyCon tycon
                        )
                    ) ^/^
                    doc
                else
                    doc
            )
            empty TE

    fun ppSynTyEnv(T,TE) =
        TyConMap.foldri
            (fn(tycon, (theta as (alphas,tau), VE), doc) =>
                if VIdMap.isEmpty VE
                andalso not(isSome(absTy(T, tycon, theta))) then
                    abox(
                        hbox(
                            text "type" ^/^
                            ppSeq ppTyVar alphas ^/^
                            ppTyCon tycon ^/^
                            text "="
                        ) ^^
                        nest(break ^^
                            abox(PPType.ppType tau)
                        )
                    ) ^/^
                    doc
                else
                    doc
            )
            empty TE

    fun ppDataTyEnv TE =
        TyConMap.foldri
            (fn(tycon, ((alphas,tau),VE), doc) =>
                if VIdMap.isEmpty VE then
                    doc
                else
                    abox(
                        hbox(
                            text "datatype" ^/^
                            ppSeq ppTyVar alphas ^/^
                            ppTyCon tycon ^/^
                            text "="
                        ) ^^
                        nest(break ^^
                            abox(ppConEnv VE)
                        )
                    ) ^/^
                    doc
            )
            empty TE

    fun ppTyEnv(T,TE) =
            vbox(
                ppAbsTyEnv(T,TE) ^/^
                ppSynTyEnv(T,TE) ^/^
                ppDataTyEnv TE
            )

    fun ppStrEnv(T,SE) =
        StrIdMap.foldri
            (fn(strid, StaticEnv.Str E, doc) =>
                abox(
                    hbox(
                        text "structure" ^/^
                        ppStrId strid ^/^
                        text ":"
                    ) ^^
                    nest(break ^^
                        ppSig (T,E)
                    )
                ) ^/^
                doc
            )
            empty SE

    and ppEnv'(T,(SE,TE,VE)) =
            vbox(
                ppStrEnv(T,SE) ^/^
                ppTyEnv(T,TE) ^/^
                ppExEnv VE ^/^
                ppValEnv VE
            )

    and ppEnv E = ppEnv'(TyNameSet.empty,E)


    (* Signatures *)

    and ppSig (T,E) =
        let
            val doc = ppEnv'(T, E)
        in
            abox(below(
                text "sig" ^^
                brace(ppCommaList ppTyName (TyNameSet.listItems T)) ^^
                (if isEmpty doc then
                    empty
                 else
                    nest(vbox(break ^^ doc))
                ) ^^ break ^^
                text "end"
            ))
        end

  end
(* stop of PPStaticEnv.sml *)
(* start of PP_STATIC_BASIS.sml *)
(*
 * Standard ML pretty printing of the static basis
 *)

signature PP_STATIC_BASIS =
  sig

    type doc    = PrettyPrint.doc
    type Basis  = StaticBasis.Basis
    type SigEnv = StaticBasis.SigEnv
    type FunEnv = StaticBasis.FunEnv

    val ppBasis:   Basis  -> doc
    val ppSigEnv:  SigEnv -> doc
    val ppFunEnv:  FunEnv -> doc

  end
(* stop of PP_STATIC_BASIS.sml *)
(* start of PPStaticBasis.sml *)
(*
 * Standard ML pretty printing of the static basis
 *)

structure PPStaticBasis :> PP_STATIC_BASIS =
  struct

    (* Import *)

    type Basis  = StaticBasis.Basis
    type SigEnv = StaticBasis.SigEnv
    type FunEnv = StaticBasis.FunEnv

    open PrettyPrint
    open PPMisc

    infixr ^^ ^/^


    (* Simple objects *)

    fun ppSigId sigid = text(SigId.toString sigid)
    fun ppFunId funid = text(FunId.toString funid)


    (* Environments *)

    fun ppSigEnv G =
        SigIdMap.foldri
            (fn(sigid, Sigma, doc) =>
                abox(
                    hbox(
                        text "signature" ^/^
                        ppSigId sigid ^/^
                        text "="
                    ) ^^
                    nest(break ^^
                        PPStaticEnv.ppSig Sigma
                    )
                ) ^/^
                doc
            )
            empty G

    fun ppFunEnv F =
        FunIdMap.foldri
            (fn(funid, (T,(E,Sigma)), doc) =>
                abox(
                    hbox(
                        text "functor" ^/^
                        ppFunId funid
                    ) ^^
                    nest(ebreak ^^
                        abox(
                            hbox(
                                text "(" ^^
                                text "Arg" ^/^
                                text ":"
                            ) ^^
                            nest(break ^^
                                PPStaticEnv.ppSig(T,E)
                            ) ^^ ebreak ^^
                            hbox(
                                text ")" ^/^
                                text ":"
                            )
                        ) ^/^
                        PPStaticEnv.ppSig Sigma
                    )
                ) ^/^
                doc
            )
            empty F


    (* Basis *)

    fun ppBasis (T,F,G,E) =
            vbox(
                ppSigEnv G ^/^
                ppFunEnv F ^/^
                PPStaticEnv.ppEnv E ^/^
                text ""
            )

  end
(* stop of PPStaticBasis.sml *)
(* start of PP_ENV.sml *)
(*
 * Standard ML pretty printing of the combined static/dynamic environment
 *)

signature PP_ENV =
  sig

    type doc   = PrettyPrint.doc
    type Env   = StaticEnv.Env * DynamicEnv.Env
    type State = PPDynamicEnv.State

    val ppEnv: State * Env -> doc

  end
(* stop of PP_ENV.sml *)
(* start of PPEnv.sml *)
(*
 * Standard ML pretty printing of the combined static/dynamic environment
 *)

structure PPEnv :> PP_ENV =
  struct

    (* Import *)

    type Env   = StaticEnv.Env * DynamicEnv.Env
    type State = PPDynamicEnv.State

    open PrettyPrint
    open PPMisc

    infixr ^^ ^/^


    (* Simple objects *)

    fun ppVId vid     = text(VId.toString vid)
    fun ppStrId strid = text(StrId.toString strid)


    (* Environments *)

    fun ppValEnv(s, (VE_STAT,VE_DYN)) =
        VIdMap.foldri
            (fn(vid, (sigma,IdStatus.v), doc) =>
             let
                val (v,is) = valOf(VIdMap.find(VE_DYN, vid))
             in
                fbox(
                    hbox(
                        text "val" ^/^
                        ppVId vid
                    ) ^^
                    nest(break ^^
                        text "=" ^/^
                        below(abox(PPVal.ppVal(s, v))) ^/^
                        text ":" ^/^
                        below(abox(PPType.ppTypeScheme sigma))
                    )
                ) ^/^
                doc
             end

             | (vid, (sigma,_), doc) => doc
            )
            empty VE_STAT

    fun ppStrEnv(s, T, (SE_STAT,SE_DYN)) =
        StrIdMap.foldri
            (fn(strid, StaticEnv.Str E_STAT, doc) =>
             let
                val DynamicEnv.Str E_DYN = valOf(StrIdMap.find(SE_DYN, strid))
             in
                abox(
                    hbox(
                        text "structure" ^/^
                        ppStrId strid ^/^
                        text "="
                    ) ^^
                    nest(break ^^
                        ppStr (s, T, (E_STAT,E_DYN))
                    )
                ) ^/^
                doc
             end
            )
            empty SE_STAT

    and ppEnv'(s, T, ((SE_STAT,TE_STAT,VE_STAT), (SE_DYN, TE_DYN, VE_DYN))) =
            vbox(
                ppStrEnv(s, T, (SE_STAT,SE_DYN)) ^/^
                PPStaticEnv.ppTyEnv(T,TE_STAT) ^/^
                PPStaticEnv.ppExEnv VE_STAT ^/^
                ppValEnv(s, (VE_STAT,VE_DYN))
            )

    and ppEnv(s, E) = ppEnv'(s, TyNameSet.empty, E)


    (* Structures *)

    and ppStr(s, T, E) =
        let
            val doc = ppEnv'(s, T, E)
        in
            abox(below(
                text "struct" ^^
                (if isEmpty doc then
                    empty
                 else
                    nest(vbox(break ^^ doc))
                ) ^^ break ^^
                text "end"
            ))
        end

  end
(* stop of PPEnv.sml *)
(* start of PP_BASIS.sml *)
(*
 * Standard ML pretty printing of the combined basis
 *)

signature PP_BASIS =
  sig

    type doc   = PrettyPrint.doc
    type Basis = Basis.Basis
    type State = PPEnv.State

    val ppBasis: State * Basis -> doc

  end
(* stop of PP_BASIS.sml *)
(* start of PPBasis.sml *)
(*
 * Standard ML pretty printing of the combined basis
 *)

structure PPBasis :> PP_BASIS =
  struct

    (* Import *)

    type Basis = Basis.Basis
    type State = PPEnv.State

    open PrettyPrint

    infixr ^^ ^/^


    (* Basis *)

    fun ppBasis (s, ((T,F_STAT,G_STAT,E_STAT), (F_DYN,G_DYN,E_DYN))) =
            vbox(
                PPStaticBasis.ppSigEnv G_STAT ^/^
                PPStaticBasis.ppFunEnv F_STAT ^/^
                PPEnv.ppEnv(s, (E_STAT,E_DYN)) ^/^
                text ""
            )

  end
(* stop of PPBasis.sml *)
(* start of PROGRAM.sml *)
(*
 * Standard ML programs
 *
 * Definition, section 8
 *
 * Note:
 *     State is passed as reference and modified via side effects. This way
 *     expanding out the state and exception convention in the inference rules
 *     of modules and core can be avoided. Note that the state therefore
 *     never is returned.
 *)

signature PROGRAM =
  sig

    (* Import types *)

    type Program      = GrammarProgram.Program
    type StaticBasis  = StaticBasis.Basis
    type DynamicBasis = DynamicBasis.Basis
    type Basis        = Basis.Basis
    type State        = EvalModule.State


    (* Export *)

    val execProgram:    State ref * Basis * Program -> Basis
    val elabProgram:    StaticBasis * Program -> StaticBasis
    val evalProgram:    State ref * DynamicBasis * Program -> DynamicBasis

  end
(* stop of PROGRAM.sml *)
(* start of Program.sml *)
(*
 * Standard ML programs
 *
 * Definition, section 8
 *
 * Note:
 *     State is passed as reference and modified via side effects. This way
 *     expanding out the state and exception convention in the inference rules
 *     of modules and core can be avoided. Note that the state therefore
 *     never is returned.
 *)

structure Program :> PROGRAM =
  struct

    (* Import *)

    type StaticBasis  = StaticBasis.Basis
    type DynamicBasis = DynamicBasis.Basis
    type Basis        = Basis.Basis
    type State        = EvalModule.State


    open GrammarProgram


    (* Helpers for output *)

    val width = 79

    fun printException(s, e) =
        ( TextIO.output(TextIO.stdOut, "Uncaught exception: ")
        ; PrettyPrint.output(TextIO.stdOut, PPVal.ppExVal(s, e), width)
        ; TextIO.output1(TextIO.stdOut, #"\n")
        ; TextIO.flushOut TextIO.stdOut
        )

    fun printStaticBasis B_STAT =
        ( PrettyPrint.output(TextIO.stdOut, PPStaticBasis.ppBasis B_STAT,
                             width)
        ; TextIO.flushOut TextIO.stdOut
        )

    fun printDynamicBasis(s, B_DYN) =
        ( PrettyPrint.output(TextIO.stdOut, PPDynamicBasis.ppBasis(s, B_DYN),
                             width)
        ; TextIO.flushOut TextIO.stdOut
        )

    fun printBasis(s, B) =
        ( PrettyPrint.output(TextIO.stdOut, PPBasis.ppBasis(s, B), width)
        ; TextIO.flushOut TextIO.stdOut
        )


    (* Helpers for basis modification *)

    val oplus = Basis.oplus

    infix oplus


    (* Inference rules [Section 8] *)

    fun execProgram(s,B, Program(I, topdec, program_opt)) =
        (* [Rules 187 to 189] *)
        let
            val B_STAT1 = ElabModule.elabTopDec(Basis.B_STATof B, topdec)
            val B_DYN1  = EvalModule.evalTopDec(s,Basis.B_DYNof B, topdec)
            (* [Rule 189] *)
            val _   = printBasis(!s, (B_STAT1,B_DYN1))
            val B'  = B oplus (B_STAT1,B_DYN1)
            val B'' = case program_opt
                        of NONE         => B'
                         | SOME program => execProgram(s,B', program)
        in
            B''
        end
        handle Error.Error m =>
               (* [Rule 187] *)
               let
                   val B' = case program_opt
                              of NONE         => B
                               | SOME program => execProgram(s,B, program)
               in
                   B'
               end

             | Pack.Pack e =>
               (* [Rule 188] *)
               let
                   val _  = printException(!s, e)
                   val B' = case program_opt
                              of NONE         => B
                               | SOME program => execProgram(s,B, program)
               in
                   B'
               end


    (* Elaboration only *)

    fun elabProgram(B_STAT, Program(I, topdec, program_opt)) =
        let
            val B_STAT1  = ElabModule.elabTopDec(B_STAT, topdec)
            val  _       = printStaticBasis B_STAT1
            val B_STAT'  = StaticBasis.plus(B_STAT, B_STAT1)
            val B_STAT'' = case program_opt
                             of NONE         => B_STAT'
                              | SOME program => elabProgram(B_STAT', program)
        in
            B_STAT''
        end
        handle Error.Error m =>
               B_STAT


    (* Evaluation only *)

    fun evalProgram(s,B_DYN, Program(I, topdec, program_opt)) =
        let
            val B_DYN1  = EvalModule.evalTopDec(s,B_DYN, topdec)
            val  _      = printDynamicBasis(!s, B_DYN1)
            val B_DYN'  = DynamicBasis.plus(B_DYN, B_DYN1)
            val B_DYN'' = case program_opt
                            of NONE         => B_DYN'
                             | SOME program => evalProgram(s,B_DYN', program)
        in
            B_DYN''
        end
        handle Error.Error m =>
               (* Runtime error *)
               let
                   val B_DYN' = case program_opt
                                  of NONE         => B_DYN
                                   | SOME program =>
                                        evalProgram(s,B_DYN, program)
               in
                   B_DYN'
               end

             | Pack.Pack e =>
               let
                   val  _     = printException(!s, e)
                   val B_DYN' = case program_opt
                                  of NONE         => B_DYN
                                   | SOME program =>
                                        evalProgram(s,B_DYN, program)
               in
                   B_DYN'
               end

  end
(* stop of Program.sml *)
(* start of ml-yacc/lib/base.sig *)
(* ML-Yacc Parser Generator (c) 1989 Andrew W. Appel, David R. Tarditi *)

(* base.sig: Base signature file for SML-Yacc.  This file contains signatures
   that must be loaded before any of the files produced by ML-Yacc are loaded
*)

(* STREAM: signature for a lazy stream.*)

signature STREAM =
 sig type 'xa stream
     val streamify : (unit -> '_a) -> '_a stream
     val cons : '_a * '_a stream -> '_a stream
     val get : '_a stream -> '_a * '_a stream
 end

(* LR_TABLE: signature for an LR Table.

   The list of actions and gotos passed to mkLrTable must be ordered by state
   number. The values for state 0 are the first in the list, the values for
    state 1 are next, etc.
*)

signature LR_TABLE =
    sig
        datatype ('a,'b) pairlist = EMPTY | PAIR of 'a * 'b * ('a,'b) pairlist
        datatype state = STATE of int
        datatype term = T of int
        datatype nonterm = NT of int
        datatype action = SHIFT of state
                        | REDUCE of int
                        | ACCEPT
                        | ERROR
        type table
        
        val numStates : table -> int
        val numRules : table -> int
        val describeActions : table -> state ->
                                (term,action) pairlist * action
        val describeGoto : table -> state -> (nonterm,state) pairlist
        val action : table -> state * term -> action
        val goto : table -> state * nonterm -> state
        val initialState : table -> state
        exception Goto of state * nonterm

        val mkLrTable : {actions : ((term,action) pairlist * action) array,
                         gotos : (nonterm,state) pairlist array,
                         numStates : int, numRules : int,
                         initialState : state} -> table
    end

(* TOKEN: signature revealing the internal structure of a token. This signature
   TOKEN distinct from the signature {parser name}_TOKENS produced by ML-Yacc.
   The {parser name}_TOKENS structures contain some types and functions to
    construct tokens from values and positions.

   The representation of token was very carefully chosen here to allow the
   polymorphic parser to work without knowing the types of semantic values
   or line numbers.

   This has had an impact on the TOKENS structure produced by SML-Yacc, which
   is a structure parameter to lexer functors.  We would like to have some
   type 'a token which functions to construct tokens would create.  A
   constructor function for a integer token might be

          INT: int * 'a * 'a -> 'a token.
 
   This is not possible because we need to have tokens with the representation
   given below for the polymorphic parser.

   Thus our constructur functions for tokens have the form:

          INT: int * 'a * 'a -> (svalue,'a) token

   This in turn has had an impact on the signature that lexers for SML-Yacc
   must match and the types that a user must declare in the user declarations
   section of lexers.
*)

signature TOKEN =
    sig
        structure LrTable : LR_TABLE
        datatype ('a,'b) token = TOKEN of LrTable.term * ('a * 'b * 'b)
        val sameToken : ('a,'b) token * ('a,'b) token -> bool
    end

(* LR_PARSER: signature for a polymorphic LR parser *)

signature LR_PARSER =
    sig
        structure Stream: STREAM
        structure LrTable : LR_TABLE
        structure Token : TOKEN

        sharing LrTable = Token.LrTable

        exception ParseError

        val parse : {table : LrTable.table,
                     lexer : ('_b,'_c) Token.token Stream.stream,
                     arg: 'arg,
                     saction : int *
                               '_c *
                                (LrTable.state * ('_b * '_c * '_c)) list * 
                                'arg ->
                                     LrTable.nonterm *
                                     ('_b * '_c * '_c) *
                                     ((LrTable.state *('_b * '_c * '_c)) list),
                     void : '_b,
                     ec : { is_keyword : LrTable.term -> bool,
                            noShift : LrTable.term -> bool,
                            preferred_change : (LrTable.term list * LrTable.term list) list,
                            errtermvalue : LrTable.term -> '_b,
                            showTerminal : LrTable.term -> string,
                            terms: LrTable.term list,
                            error : string * '_c * '_c -> unit
                           },
                     lookahead : int  (* max amount of lookahead used in *)
                                      (* error correction *)
                        } -> '_b *
                             (('_b,'_c) Token.token Stream.stream)
    end

(* LEXER: a signature that most lexers produced for use with SML-Yacc's
   output will match.  The user is responsible for declaring type token,
   type pos, and type svalue in the UserDeclarations section of a lexer.

   Note that type token is abstract in the lexer.  This allows SML-Yacc to
   create a TOKENS signature for use with lexers produced by ML-Lex that
   treats the type token abstractly.  Lexers that are functors parametrized by
   a Tokens structure matching a TOKENS signature cannot examine the structure
   of tokens.
*)

signature LEXER =
   sig
       structure UserDeclarations :
           sig
                type ('a,'b) token
                type pos
                type svalue
           end
        val makeLexer : (int -> string) -> unit -> 
         (UserDeclarations.svalue,UserDeclarations.pos) UserDeclarations.token
   end

(* ARG_LEXER: the %arg option of ML-Lex allows users to produce lexers which
   also take an argument before yielding a function from unit to a token
*)

signature ARG_LEXER =
   sig
       structure UserDeclarations :
           sig
                type ('a,'b) token
                type pos
                type svalue
                type arg
           end
        val makeLexer : (int -> string) -> UserDeclarations.arg -> unit -> 
         (UserDeclarations.svalue,UserDeclarations.pos) UserDeclarations.token
   end

(* PARSER_DATA: the signature of ParserData structures in {parser name}LrValsFun
   produced by  SML-Yacc.  All such structures match this signature.  

   The {parser name}LrValsFun produces a structure which contains all the values
   except for the lexer needed to call the polymorphic parser mentioned
   before.

*)

signature PARSER_DATA =
   sig
        (* the type of line numbers *)

        type pos

        (* the type of semantic values *)

        type svalue

         (* the type of the user-supplied argument to the parser *)
        type arg
 
        (* the intended type of the result of the parser.  This value is
           produced by applying extract from the structure Actions to the
           final semantic value resultiing from a parse.
         *)

        type result

        structure LrTable : LR_TABLE
        structure Token : TOKEN
        sharing Token.LrTable = LrTable

        (* structure Actions contains the functions which mantain the
           semantic values stack in the parser.  Void is used to provide
           a default value for the semantic stack.
         *)

        structure Actions : 
          sig
              val actions : int * pos *
                   (LrTable.state * (svalue * pos * pos)) list * arg->
                         LrTable.nonterm * (svalue * pos * pos) *
                         ((LrTable.state *(svalue * pos * pos)) list)
              val void : svalue
              val extract : svalue -> result
          end

        (* structure EC contains information used to improve error
           recovery in an error-correcting parser *)

        structure EC :
           sig
             val is_keyword : LrTable.term -> bool
             val noShift : LrTable.term -> bool
             val preferred_change : (LrTable.term list * LrTable.term list) list
             val errtermvalue : LrTable.term -> svalue
             val showTerminal : LrTable.term -> string
             val terms: LrTable.term list
           end

        (* table is the LR table for the parser *)

        val table : LrTable.table
    end

(* signature PARSER is the signature that most user parsers created by 
   SML-Yacc will match.
*)

signature PARSER =
    sig
        structure Token : TOKEN
        structure Stream : STREAM
        exception ParseError

        (* type pos is the type of line numbers *)

        type pos

        (* type result is the type of the result from the parser *)

        type result

         (* the type of the user-supplied argument to the parser *)
        type arg
        
        (* type svalue is the type of semantic values for the semantic value
           stack
         *)

        type svalue

        (* val makeLexer is used to create a stream of tokens for the parser *)

        val makeLexer : (int -> string) ->
                         (svalue,pos) Token.token Stream.stream

        (* val parse takes a stream of tokens and a function to print
           errors and returns a value of type result and a stream containing
           the unused tokens
         *)

        val parse : int * ((svalue,pos) Token.token Stream.stream) *
                    (string * pos * pos -> unit) * arg ->
                                result * (svalue,pos) Token.token Stream.stream

        val sameToken : (svalue,pos) Token.token * (svalue,pos) Token.token ->
                                bool
     end

(* signature ARG_PARSER is the signature that will be matched by parsers whose
    lexer takes an additional argument.
*)

signature ARG_PARSER = 
    sig
        structure Token : TOKEN
        structure Stream : STREAM
        exception ParseError

        type arg
        type lexarg
        type pos
        type result
        type svalue

        val makeLexer : (int -> string) -> lexarg ->
                         (svalue,pos) Token.token Stream.stream
        val parse : int * ((svalue,pos) Token.token Stream.stream) *
                    (string * pos * pos -> unit) * arg ->
                                result * (svalue,pos) Token.token Stream.stream

        val sameToken : (svalue,pos) Token.token * (svalue,pos) Token.token ->
                                bool
     end

(* stop of ml-yacc/lib/base.sig *)
(* start of ml-yacc/lib/join.sml *)
(* ML-Yacc Parser Generator (c) 1989 Andrew W. Appel, David R. Tarditi *)

(* functor Join creates a user parser by putting together a Lexer structure,
   an LrValues structure, and a polymorphic parser structure.  Note that
   the Lexer and LrValues structure must share the type pos (i.e. the type
   of line numbers), the type svalues for semantic values, and the type
   of tokens.
*)

functor Join(structure Lex : LEXER
             structure ParserData: PARSER_DATA
             structure LrParser : LR_PARSER
             sharing ParserData.LrTable = LrParser.LrTable
             sharing ParserData.Token = LrParser.Token
             sharing type Lex.UserDeclarations.svalue = ParserData.svalue
             sharing type Lex.UserDeclarations.pos = ParserData.pos
             sharing type Lex.UserDeclarations.token = ParserData.Token.token)
                 : PARSER =
struct
    structure Token = ParserData.Token
    structure Stream = LrParser.Stream
 
    exception ParseError = LrParser.ParseError

    type arg = ParserData.arg
    type pos = ParserData.pos
    type result = ParserData.result
    type svalue = ParserData.svalue
    val makeLexer = LrParser.Stream.streamify o Lex.makeLexer
    val parse = fn (lookahead,lexer,error,arg) =>
        (fn (a,b) => (ParserData.Actions.extract a,b))
     (LrParser.parse {table = ParserData.table,
                lexer=lexer,
                lookahead=lookahead,
                saction = ParserData.Actions.actions,
                arg=arg,
                void= ParserData.Actions.void,
                ec = {is_keyword = ParserData.EC.is_keyword,
                      noShift = ParserData.EC.noShift,
                      preferred_change = ParserData.EC.preferred_change,
                      errtermvalue = ParserData.EC.errtermvalue,
                      error=error,
                      showTerminal = ParserData.EC.showTerminal,
                      terms = ParserData.EC.terms}}
      )
     val sameToken = Token.sameToken
end

(* functor JoinWithArg creates a variant of the parser structure produced 
   above.  In this case, the makeLexer take an additional argument before
   yielding a value of type unit -> (svalue,pos) token
 *)

functor JoinWithArg(structure Lex : ARG_LEXER
             structure ParserData: PARSER_DATA
             structure LrParser : LR_PARSER
             sharing ParserData.LrTable = LrParser.LrTable
             sharing ParserData.Token = LrParser.Token
             sharing type Lex.UserDeclarations.svalue = ParserData.svalue
             sharing type Lex.UserDeclarations.pos = ParserData.pos
             sharing type Lex.UserDeclarations.token = ParserData.Token.token)
                 : ARG_PARSER  =
struct
    structure Token = ParserData.Token
    structure Stream = LrParser.Stream

    exception ParseError = LrParser.ParseError

    type arg = ParserData.arg
    type lexarg = Lex.UserDeclarations.arg
    type pos = ParserData.pos
    type result = ParserData.result
    type svalue = ParserData.svalue

    val makeLexer = fn s => fn arg =>
                 LrParser.Stream.streamify (Lex.makeLexer s arg)
    val parse = fn (lookahead,lexer,error,arg) =>
        (fn (a,b) => (ParserData.Actions.extract a,b))
     (LrParser.parse {table = ParserData.table,
                lexer=lexer,
                lookahead=lookahead,
                saction = ParserData.Actions.actions,
                arg=arg,
                void= ParserData.Actions.void,
                ec = {is_keyword = ParserData.EC.is_keyword,
                      noShift = ParserData.EC.noShift,
                      preferred_change = ParserData.EC.preferred_change,
                      errtermvalue = ParserData.EC.errtermvalue,
                      error=error,
                      showTerminal = ParserData.EC.showTerminal,
                      terms = ParserData.EC.terms}}
      )
    val sameToken = Token.sameToken
end;
(* stop of ml-yacc/lib/join.sml *)
(* start of ml-yacc/lib/lrtable.sml *)
(* ML-Yacc Parser Generator (c) 1989 Andrew W. Appel, David R. Tarditi *)
structure LrTable : LR_TABLE = 
    struct
        open Array List
        infix 9 sub
        datatype ('a,'b) pairlist = EMPTY
                                  | PAIR of 'a * 'b * ('a,'b) pairlist
        datatype term = T of int
        datatype nonterm = NT of int
        datatype state = STATE of int
        datatype action = SHIFT of state
                        | REDUCE of int (* rulenum from grammar *)
                        | ACCEPT
                        | ERROR
        exception Goto of state * nonterm
        type table = {states: int, rules : int,initialState: state,
                      action: ((term,action) pairlist * action) array,
                      goto :  (nonterm,state) pairlist array}
        val numStates = fn ({states,...} : table) => states
        val numRules = fn ({rules,...} : table) => rules
        val describeActions =
           fn ({action,...} : table) => 
                   fn (STATE s) => action sub s
        val describeGoto =
           fn ({goto,...} : table) =>
                   fn (STATE s) => goto sub s
        fun findTerm (T term,row,default) =
            let fun find (PAIR (T key,data,r)) =
                       if key < term then find r
                       else if key=term then data
                       else default
                   | find EMPTY = default
            in find row
            end
        fun findNonterm (NT nt,row) =
            let fun find (PAIR (NT key,data,r)) =
                       if key < nt then find r
                       else if key=nt then SOME data
                       else NONE
                   | find EMPTY = NONE
            in find row
            end
        val action = fn ({action,...} : table) =>
                fn (STATE state,term) =>
                  let val (row,default) = action sub state
                  in findTerm(term,row,default)
                  end
        val goto = fn ({goto,...} : table) =>
                        fn (a as (STATE state,nonterm)) =>
                          case findNonterm(nonterm,goto sub state)
                          of SOME state => state
                           | NONE => raise (Goto a)
        val initialState = fn ({initialState,...} : table) => initialState
        val mkLrTable = fn {actions,gotos,initialState,numStates,numRules} =>
             ({action=actions,goto=gotos,
               states=numStates,
               rules=numRules,
               initialState=initialState} : table)
end;
(* stop of ml-yacc/lib/lrtable.sml *)
(* start of ml-yacc/lib/stream.sml *)
(* ML-Yacc Parser Generator (c) 1989 Andrew W. Appel, David R. Tarditi *)

(* Stream: a structure implementing a lazy stream.  The signature STREAM
   is found in base.sig *)

structure Stream :> STREAM =
struct
   datatype 'a str = EVAL of 'a * 'a str ref | UNEVAL of (unit->'a)

   type 'a stream = 'a str ref

   fun get(ref(EVAL t)) = t
     | get(s as ref(UNEVAL f)) = 
            let val t = (f(), ref(UNEVAL f)) in s := EVAL t; t end

   fun streamify f = ref(UNEVAL f)
   fun cons(a,s) = ref(EVAL(a,s))

end;
(* stop of ml-yacc/lib/stream.sml *)
(* start of ml-yacc/lib/parser2.sml *)
(* ML-Yacc Parser Generator (c) 1989 Andrew W. Appel, David R. Tarditi *)

(* parser.sml:  This is a parser driver for LR tables with an error-recovery
   routine added to it.  The routine used is described in detail in this
   article:

        'A Practical Method for LR and LL Syntactic Error Diagnosis and
         Recovery', by M. Burke and G. Fisher, ACM Transactions on
         Programming Langauges and Systems, Vol. 9, No. 2, April 1987,
         pp. 164-197.

    This program is an implementation is the partial, deferred method discussed
    in the article.  The algorithm and data structures used in the program
    are described below.  

    This program assumes that all semantic actions are delayed.  A semantic
    action should produce a function from unit -> value instead of producing the
    normal value.  The parser returns the semantic value on the top of the
    stack when accept is encountered.  The user can deconstruct this value
    and apply the unit -> value function in it to get the answer.

    It also assumes that the lexer is a lazy stream.

    Data Structures:
    ----------------
        
        * The parser:

           The state stack has the type

                 (state * (semantic value * line # * line #)) list

           The parser keeps a queue of (state stack * lexer pair).  A lexer pair
         consists of a terminal * value pair and a lexer.  This allows the 
         parser to reconstruct the states for terminals to the left of a
         syntax error, and attempt to make error corrections there.

           The queue consists of a pair of lists (x,y).  New additions to
         the queue are cons'ed onto y.  The first element of x is the top
         of the queue.  If x is nil, then y is reversed and used
         in place of x.

    Algorithm:
    ----------

        * The steady-state parser:  

            This parser keeps the length of the queue of state stacks at
        a steady state by always removing an element from the front when
        another element is placed on the end.

            It has these arguments:

           stack: current stack
           queue: value of the queue
           lexPair ((terminal,value),lex stream)

        When SHIFT is encountered, the state to shift to and the value are
        are pushed onto the state stack.  The state stack and lexPair are
        placed on the queue.  The front element of the queue is removed.

        When REDUCTION is encountered, the rule is applied to the current
        stack to yield a triple (nonterm,value,new stack).  A new
        stack is formed by adding (goto(top state of stack,nonterm),value)
        to the stack.

        When ACCEPT is encountered, the top value from the stack and the
        lexer are returned.

        When an ERROR is encountered, fixError is called.  FixError
        takes the arguments to the parser, fixes the error if possible and
        returns a new set of arguments.

        * The distance-parser:

        This parser includes an additional argument distance.  It pushes
        elements on the queue until it has parsed distance tokens, or an
        ACCEPT or ERROR occurs.  It returns a stack, lexer, the number of
        tokens left unparsed, a queue, and an action option.
*)

signature FIFO = 
  sig type 'a queue
      val empty : 'a queue
      exception Empty
      val get : 'a queue -> 'a * 'a queue
      val put : 'a * 'a queue -> 'a queue
  end

(* drt (12/15/89) -- the functor should be used in development work, but
   it wastes space in the release version.

functor ParserGen(structure LrTable : LR_TABLE
                  structure Stream : STREAM) : LR_PARSER =
*)

structure LrParser :> LR_PARSER =
   struct
      structure LrTable = LrTable
      structure Stream = Stream

      structure Token : TOKEN =
        struct
            structure LrTable = LrTable
            datatype ('a,'b) token = TOKEN of LrTable.term * ('a * 'b * 'b)
            val sameToken = fn (TOKEN(t,_),TOKEN(t',_)) => t=t'
        end

      open LrTable
      open Token

      val DEBUG1 = false
      val DEBUG2 = false
      exception ParseError
      exception ParseImpossible of int

      structure Fifo :> FIFO =
        struct
          type 'a queue = ('a list * 'a list)
          val empty = (nil,nil)
          exception Empty
          fun get(a::x, y) = (a, (x,y))
            | get(nil, nil) = raise Empty
            | get(nil, y) = get(rev y, nil)
          fun put(a,(x,y)) = (x,a::y)
        end

      type ('a,'b) elem = (state * ('a * 'b * 'b))
      type ('a,'b) stack = ('a,'b) elem list
      type ('a,'b) lexv = ('a,'b) token
      type ('a,'b) lexpair = ('a,'b) lexv * (('a,'b) lexv Stream.stream)
      type ('a,'b) distanceParse =
                 ('a,'b) lexpair *
                 ('a,'b) stack * 
                 (('a,'b) stack * ('a,'b) lexpair) Fifo.queue *
                 int ->
                   ('a,'b) lexpair *
                   ('a,'b) stack * 
                   (('a,'b) stack * ('a,'b) lexpair) Fifo.queue *
                   int *
                   action option

      type ('a,'b) ecRecord =
         {is_keyword : term -> bool,
          preferred_change : (term list * term list) list,
          error : string * 'b * 'b -> unit,
          errtermvalue : term -> 'a,
          terms : term list,
          showTerminal : term -> string,
          noShift : term -> bool}

      local 
         val print = fn s => TextIO.output(TextIO.stdOut,s)
         val println = fn s => (print s; print "\n")
         val showState = fn (STATE s) => "STATE " ^ (Int.toString s)
      in
        fun printStack(stack: ('a,'b) stack, n: int) =
         case stack
           of (state,_) :: rest =>
                 (print("\t" ^ Int.toString n ^ ": ");
                  println(showState state);
                  printStack(rest, n+1))
            | nil => ()
                
        fun prAction showTerminal
                 (stack as (state,_) :: _, next as (TOKEN (term,_),_), action) =
             (println "Parse: state stack:";
              printStack(stack, 0);
              print("       state="
                         ^ showState state      
                         ^ " next="
                         ^ showTerminal term
                         ^ " action="
                        );
              case action
                of SHIFT state => println ("SHIFT " ^ (showState state))
                 | REDUCE i => println ("REDUCE " ^ (Int.toString i))
                 | ERROR => println "ERROR"
                 | ACCEPT => println "ACCEPT")
        | prAction _ (_,_,action) = ()
     end

    (* ssParse: parser which maintains the queue of (state * lexvalues) in a
        steady-state.  It takes a table, showTerminal function, saction
        function, and fixError function.  It parses until an ACCEPT is
        encountered, or an exception is raised.  When an error is encountered,
        fixError is called with the arguments of parseStep (lexv,stack,and
        queue).  It returns the lexv, and a new stack and queue adjusted so
        that the lexv can be parsed *)
        
    val ssParse =
      fn (table,showTerminal,saction,fixError,arg) =>
        let val prAction = prAction showTerminal
            val action = LrTable.action table
            val goto = LrTable.goto table
            fun parseStep(args as
                         (lexPair as (TOKEN (terminal, value as (_,leftPos,_)),
                                      lexer
                                      ),
                          stack as (state,_) :: _,
                          queue)) =
              let val nextAction = action (state,terminal)
                  val _ = if DEBUG1 then prAction(stack,lexPair,nextAction)
                          else ()
              in case nextAction
                 of SHIFT s =>
                  let val newStack = (s,value) :: stack
                      val newLexPair = Stream.get lexer
                      val (_,newQueue) =Fifo.get(Fifo.put((newStack,newLexPair),
                                                            queue))
                  in parseStep(newLexPair,(s,value)::stack,newQueue)
                  end
                 | REDUCE i =>
                     (case saction(i,leftPos,stack,arg)
                      of (nonterm,value,stack as (state,_) :: _) =>
                          parseStep(lexPair,(goto(state,nonterm),value)::stack,
                                    queue)
                       | _ => raise (ParseImpossible 197))
                 | ERROR => parseStep(fixError args)
                 | ACCEPT => 
                        (case stack
                         of (_,(topvalue,_,_)) :: _ =>
                                let val (token,restLexer) = lexPair
                                in (topvalue,Stream.cons(token,restLexer))
                                end
                          | _ => raise (ParseImpossible 202))
              end
            | parseStep _ = raise (ParseImpossible 204)
        in parseStep
        end

    (*  distanceParse: parse until n tokens are shifted, or accept or
        error are encountered.  Takes a table, showTerminal function, and
        semantic action function.  Returns a parser which takes a lexPair
        (lex result * lexer), a state stack, a queue, and a distance
        (must be > 0) to parse.  The parser returns a new lex-value, a stack
        with the nth token shifted on top, a queue, a distance, and action
        option. *)

    val distanceParse =
      fn (table,showTerminal,saction,arg) =>
        let val prAction = prAction showTerminal
            val action = LrTable.action table
            val goto = LrTable.goto table
            fun parseStep(lexPair,stack,queue,0) = (lexPair,stack,queue,0,NONE)
              | parseStep(lexPair as (TOKEN (terminal, value as (_,leftPos,_)),
                                      lexer
                                     ),
                          stack as (state,_) :: _,
                          queue,distance) =
              let val nextAction = action(state,terminal)
                  val _ = if DEBUG1 then prAction(stack,lexPair,nextAction)
                          else ()
              in case nextAction
                 of SHIFT s =>
                  let val newStack = (s,value) :: stack
                      val newLexPair = Stream.get lexer
                  in parseStep(newLexPair,(s,value)::stack,
                               Fifo.put((newStack,newLexPair),queue),distance-1)
                  end
                 | REDUCE i =>
                    (case saction(i,leftPos,stack,arg)
                      of (nonterm,value,stack as (state,_) :: _) =>
                         parseStep(lexPair,(goto(state,nonterm),value)::stack,
                                 queue,distance)
                      | _ => raise (ParseImpossible 240))
                 | ERROR => (lexPair,stack,queue,distance,SOME nextAction)
                 | ACCEPT => (lexPair,stack,queue,distance,SOME nextAction)
              end
           | parseStep _ = raise (ParseImpossible 242)
        in parseStep : ('_a,'_b) distanceParse 
        end

(* mkFixError: function to create fixError function which adjusts parser state
   so that parse may continue in the presence of an error *)

fun mkFixError({is_keyword,terms,errtermvalue,
              preferred_change,noShift,
              showTerminal,error,...} : ('_a,'_b) ecRecord,
             distanceParse : ('_a,'_b) distanceParse,
             minAdvance,maxAdvance) 

            (lexv as (TOKEN (term,value as (_,leftPos,_)),_),stack,queue) =
    let val _ = if DEBUG2 then
                        error("syntax error found at " ^ (showTerminal term),
                              leftPos,leftPos)
                else ()

        fun tokAt(t,p) = TOKEN(t,(errtermvalue t,p,p))

        val minDelta = 3

        (* pull all the state * lexv elements from the queue *)

        val stateList = 
           let fun f q = let val (elem,newQueue) = Fifo.get q
                         in elem :: (f newQueue)
                         end handle Fifo.Empty => nil
           in f queue
           end

        (* now number elements of stateList, giving distance from
           error token *)

        val (_, numStateList) =
              List.foldr (fn (a,(num,r)) => (num+1,(a,num)::r)) (0, []) stateList

        (* Represent the set of potential changes as a linked list.

           Values of datatype Change hold information about a potential change.

           oper = oper to be applied
           pos = the # of the element in stateList that would be altered.
           distance = the number of tokens beyond the error token which the
             change allows us to parse.
           new = new terminal * value pair at that point
           orig = original terminal * value pair at the point being changed.
         *)

        datatype ('a,'b) change = CHANGE of
           {pos : int, distance : int, leftPos: 'b, rightPos: 'b,
            new : ('a,'b) lexv list, orig : ('a,'b) lexv list}


         val showTerms = concat o map (fn TOKEN(t,_) => " " ^ showTerminal t)

         val printChange = fn c =>
          let val CHANGE {distance,new,orig,pos,...} = c
          in (print ("{distance= " ^ (Int.toString distance));
              print (",orig ="); print(showTerms orig);
              print (",new ="); print(showTerms new);
              print (",pos= " ^ (Int.toString pos));
              print "}\n")
          end

        val printChangeList = app printChange

(* parse: given a lexPair, a stack, and the distance from the error
   token, return the distance past the error token that we are able to parse.*)

        fun parse (lexPair,stack,queuePos : int) =
            case distanceParse(lexPair,stack,Fifo.empty,queuePos+maxAdvance+1)
             of (_,_,_,distance,SOME ACCEPT) => 
                        if maxAdvance-distance-1 >= 0 
                            then maxAdvance 
                            else maxAdvance-distance-1
              | (_,_,_,distance,_) => maxAdvance - distance - 1

(* catList: concatenate results of scanning list *)

        fun catList l f = List.foldr (fn(a,r)=> f a @ r) [] l

        fun keywordsDelta new = if List.exists (fn(TOKEN(t,_))=>is_keyword t) new
                       then minDelta else 0

        fun tryChange{lex,stack,pos,leftPos,rightPos,orig,new} =
             let val lex' = List.foldr (fn (t',p)=>(t',Stream.cons p)) lex new
                 val distance = parse(lex',stack,pos+length new-length orig)
              in if distance >= minAdvance + keywordsDelta new 
                   then [CHANGE{pos=pos,leftPos=leftPos,rightPos=rightPos,
                                distance=distance,orig=orig,new=new}] 
                   else []
             end


(* tryDelete: Try to delete n terminals.
              Return single-element [success] or nil.
              Do not delete unshiftable terminals. *)


    fun tryDelete n ((stack,lexPair as (TOKEN(term,(_,l,r)),_)),qPos) =
        let fun del(0,accum,left,right,lexPair) =
                  tryChange{lex=lexPair,stack=stack,
                            pos=qPos,leftPos=left,rightPos=right,
                            orig=rev accum, new=[]}
              | del(n,accum,left,right,(tok as TOKEN(term,(_,_,r)),lexer)) =
                   if noShift term then []
                   else del(n-1,tok::accum,left,r,Stream.get lexer)
         in del(n,[],l,r,lexPair)
        end

(* tryInsert: try to insert tokens before the current terminal;
       return a list of the successes  *)

        fun tryInsert((stack,lexPair as (TOKEN(_,(_,l,_)),_)),queuePos) =
               catList terms (fn t =>
                 tryChange{lex=lexPair,stack=stack,
                           pos=queuePos,orig=[],new=[tokAt(t,l)],
                           leftPos=l,rightPos=l})
                              
(* trySubst: try to substitute tokens for the current terminal;
       return a list of the successes  *)

        fun trySubst ((stack,lexPair as (orig as TOKEN (term,(_,l,r)),lexer)),
                      queuePos) =
              if noShift term then []
              else
                  catList terms (fn t =>
                      tryChange{lex=Stream.get lexer,stack=stack,
                                pos=queuePos,
                                leftPos=l,rightPos=r,orig=[orig],
                                new=[tokAt(t,r)]})

     (* do_delete(toks,lexPair) tries to delete tokens "toks" from "lexPair".
         If it succeeds, returns SOME(toks',l,r,lp), where
             toks' is the actual tokens (with positions and values) deleted,
             (l,r) are the (leftmost,rightmost) position of toks', 
             lp is what remains of the stream after deletion 
     *)
        fun do_delete(nil,lp as (TOKEN(_,(_,l,_)),_)) = SOME(nil,l,l,lp)
          | do_delete([t],(tok as TOKEN(t',(_,l,r)),lp')) =
               if t=t'
                   then SOME([tok],l,r,Stream.get lp')
                   else NONE
          | do_delete(t::rest,(tok as TOKEN(t',(_,l,r)),lp')) =
               if t=t'
                   then case do_delete(rest,Stream.get lp')
                         of SOME(deleted,l',r',lp'') =>
                               SOME(tok::deleted,l,r',lp'')
                          | NONE => NONE
                   else NONE
                             
        fun tryPreferred((stack,lexPair),queuePos) =
            catList preferred_change (fn (delete,insert) =>
               if List.exists noShift delete then [] (* should give warning at
                                                 parser-generation time *)
               else case do_delete(delete,lexPair)
                     of SOME(deleted,l,r,lp) => 
                            tryChange{lex=lp,stack=stack,pos=queuePos,
                                      leftPos=l,rightPos=r,orig=deleted,
                                      new=map (fn t=>(tokAt(t,r))) insert}
                      | NONE => [])

        val changes = catList numStateList tryPreferred @
                        catList numStateList tryInsert @
                          catList numStateList trySubst @
                            catList numStateList (tryDelete 1) @
                              catList numStateList (tryDelete 2) @
                                catList numStateList (tryDelete 3)

        val findMaxDist = fn l => 
          foldr (fn (CHANGE {distance,...},high) => Int.max(distance,high)) 0 l

(* maxDist: max distance past error taken that we could parse *)

        val maxDist = findMaxDist changes

(* remove changes which did not parse maxDist tokens past the error token *)

        val changes = catList changes 
              (fn(c as CHANGE{distance,...}) => 
                  if distance=maxDist then [c] else [])

      in case changes 
          of (l as change :: _) =>
              let fun print_msg (CHANGE {new,orig,leftPos,rightPos,...}) =
                  let val s = 
                      case (orig,new)
                          of (_::_,[]) => "deleting " ^ (showTerms orig)
                           | ([],_::_) => "inserting " ^ (showTerms new)
                           | _ => "replacing " ^ (showTerms orig) ^
                                 " with " ^ (showTerms new)
                  in error ("syntax error: " ^ s,leftPos,rightPos)
                  end
                   
                  val _ = 
                      (if length l > 1 andalso DEBUG2 then
                           (print "multiple fixes possible; could fix it by:\n";
                            app print_msg l;
                            print "chosen correction:\n")
                       else ();
                       print_msg change)

                  (* findNth: find nth queue entry from the error
                   entry.  Returns the Nth queue entry and the  portion of
                   the queue from the beginning to the nth-1 entry.  The
                   error entry is at the end of the queue.

                   Examples:

                   queue = a b c d e
                   findNth 0 = (e,a b c d)
                   findNth 1 =  (d,a b c)
                   *)

                  val findNth = fn n =>
                      let fun f (h::t,0) = (h,rev t)
                            | f (h::t,n) = f(t,n-1)
                            | f (nil,_) = let exception FindNth
                                          in raise FindNth
                                          end
                      in f (rev stateList,n)
                      end
                
                  val CHANGE {pos,orig,new,...} = change
                  val (last,queueFront) = findNth pos
                  val (stack,lexPair) = last

                  val lp1 = foldl(fn (_,(_,r)) => Stream.get r) lexPair orig
                  val lp2 = foldr(fn(t,r)=>(t,Stream.cons r)) lp1 new

                  val restQueue = 
                      Fifo.put((stack,lp2),
                               foldl Fifo.put Fifo.empty queueFront)

                  val (lexPair,stack,queue,_,_) =
                      distanceParse(lp2,stack,restQueue,pos)

              in (lexPair,stack,queue)
              end
        | nil => (error("syntax error found at " ^ (showTerminal term),
                        leftPos,leftPos); raise ParseError)
    end

   val parse = fn {arg,table,lexer,saction,void,lookahead,
                   ec=ec as {showTerminal,...} : ('_a,'_b) ecRecord} =>
        let val distance = 15   (* defer distance tokens *)
            val minAdvance = 1  (* must parse at least 1 token past error *)
            val maxAdvance = Int.max(lookahead,0)(* max distance for parse check *)
            val lexPair = Stream.get lexer
            val (TOKEN (_,(_,leftPos,_)),_) = lexPair
            val startStack = [(initialState table,(void,leftPos,leftPos))]
            val startQueue = Fifo.put((startStack,lexPair),Fifo.empty)
            val distanceParse = distanceParse(table,showTerminal,saction,arg)
            val fixError = mkFixError(ec,distanceParse,minAdvance,maxAdvance)
            val ssParse = ssParse(table,showTerminal,saction,fixError,arg)
            fun loop (lexPair,stack,queue,_,SOME ACCEPT) =
                   ssParse(lexPair,stack,queue)
              | loop (lexPair,stack,queue,0,_) = ssParse(lexPair,stack,queue)
              | loop (lexPair,stack,queue,distance,SOME ERROR) =
                 let val (lexPair,stack,queue) = fixError(lexPair,stack,queue)
                 in loop (distanceParse(lexPair,stack,queue,distance))
                 end
              | loop _ = let exception ParseInternal
                         in raise ParseInternal
                         end
        in loop (distanceParse(lexPair,startStack,startQueue,distance))
        end
 end;

(* stop of ml-yacc/lib/parser2.sml *)
(* start of DERIVED_FORMS_CORE.sml *)
(*
 * Standard ML core derived forms
 *
 * Definition, Section 2.7 and appendix A
 *
 * Note:
 *   Two phrases named Fmatch and Fmrule have been added to factorize FvalBind.
 *)


signature DERIVED_FORMS_CORE =
  sig

    (* Import *)

    type Info      = GrammarCore.Info

    type Lab       = GrammarCore.Lab
    type VId       = GrammarCore.VId

    type Op        = GrammarCore.Op
    type AtExp     = GrammarCore.AtExp
    type AppExp    = GrammarCore.AtExp list
    type InfExp    = GrammarCore.Exp
    type Exp       = GrammarCore.Exp
    type Match     = GrammarCore.Match
    type Mrule     = GrammarCore.Mrule
    type Dec       = GrammarCore.Dec
    type ValBind   = GrammarCore.ValBind
    type FvalBind  = GrammarCore.ValBind
    type Fmatch    = GrammarCore.Match * VId * int
    type Fmrule    = GrammarCore.Mrule * VId * int
    type TypBind   = GrammarCore.TypBind
    type DatBind   = GrammarCore.DatBind
    type AtPat     = GrammarCore.AtPat
    type PatRow    = GrammarCore.PatRow
    type Pat       = GrammarCore.Pat
    type Ty        = GrammarCore.Ty
    type TyVarseq  = GrammarCore.TyVarseq


    (* Expressions [Figure 15] *)

    val UNITAtExp:      Info                                    -> AtExp
    val TUPLEAtExp:     Info * Exp list                         -> AtExp
    val HASHAtExp:      Info * Lab                              -> AtExp
    val CASEExp:        Info * Exp * Match                      -> Exp
    val IFExp:          Info * Exp * Exp * Exp                  -> Exp
    val ANDALSOExp:     Info * Exp * Exp                        -> Exp
    val ORELSEExp:      Info * Exp * Exp                        -> Exp
    val SEQAtExp:       Info * Exp list                         -> AtExp
    val LETAtExp:       Info * Dec * Exp list                   -> AtExp
    val WHILEExp:       Info * Exp * Exp                        -> Exp
    val LISTAtExp:      Info * Exp list                         -> AtExp

    (* Patterns [Figure 16] *)

    val UNITAtPat:      Info                                    -> AtPat
    val TUPLEAtPat:     Info * Pat list                         -> AtPat
    val LISTAtPat:      Info * Pat list                         -> AtPat

    val VIDPatRow:      Info * VId * Ty option * Pat option * PatRow option
                                                                -> PatRow
    (* Types [Figure 16] *)

    val TUPLETy:        Info * Ty list                          -> Ty

    (* Function-value bindings [Figure 17] *)

    val FvalBind:       Info * Fmatch * FvalBind option         -> FvalBind
    val Fmatch:         Info * Fmrule * Fmatch option           -> Fmatch
    val Fmrule:         Info * Op * VId * AtPat list * Ty option * Exp -> Fmrule

    (* Declarations [Figure 17] *)

    val FUNDec:         Info * TyVarseq * FvalBind              -> Dec
    val DATATYPEDec:    Info * DatBind * TypBind option         -> Dec
    val ABSTYPEDec:     Info * DatBind * TypBind option * Dec   -> Dec

  end
(* stop of DERIVED_FORMS_CORE.sml *)
(* start of DerivedFormsCore.sml *)
(*
 * Standard ML core derived forms
 *
 * Definition, Section 2.7 and appendix A
 *
 * Notes:
 * - Two phrases named Fmatch and Fmrule have been added to factorize FvalBind.
 * - In Fvalbinds we do not enforce that all optional type annotations are
 *   syntactically identical (as the Definition enforces, although this seems
 *   to be a mistake).
 * - The Definition is somewhat inaccurate about the derived forms of Exp
 *   [Definition, Appendix A, Figure 15] in that most forms are actually AtExp
 *   derived forms, as can be seen from the full grammar [Definition,
 *   Appendix B, Figure 20]. To achieve consistency, the equivalent forms must
 *   be put in parentheses in some cases.
 * - The same goes for pattern derived forms [Definition, Appendix A, Figure 16;
 *   Appendix B, Figure 22].
 *)


structure DerivedFormsCore :> DERIVED_FORMS_CORE =
  struct

    (* Import *)

    structure C    = GrammarCore

    type Info      = C.Info

    type Lab       = C.Lab
    type VId       = C.VId

    type Op        = C.Op
    type AtExp     = C.AtExp
    type AppExp    = C.AtExp list
    type InfExp    = C.Exp
    type Exp       = C.Exp
    type Match     = C.Match
    type Mrule     = C.Mrule
    type Dec       = C.Dec
    type ValBind   = C.ValBind
    type FvalBind  = C.ValBind
    type Fmatch    = C.Match * C.VId * int
    type Fmrule    = C.Mrule * C.VId * int
    type TypBind   = C.TypBind
    type DatBind   = C.DatBind
    type AtPat     = C.AtPat
    type PatRow    = C.PatRow
    type Pat       = C.Pat
    type Ty        = C.Ty
    type TyVarseq  = C.TyVarseq


    (* Some helpers *)

    val vidFALSE               = VId.fromString "false"
    val vidTRUE                = VId.fromString "true"
    val vidNIL                 = VId.fromString "nil"
    val vidCONS                = VId.fromString "::"

    val longvidCONS            = LongVId.fromId vidCONS


    fun LONGVIDExp(I, longvid) = C.ATEXPExp(I, C.LONGVIDAtExp(I, C.SANSOp,
                                                                 longvid))
    fun LONGVIDPat(I, longvid) = C.ATPATPat(I, C.LONGVIDAtPat(I, C.SANSOp,
                                                                 longvid))

    fun VIDExp(I, vid)         = LONGVIDExp(I, LongVId.fromId vid)
    fun VIDPat(I, vid)         = LONGVIDPat(I, LongVId.fromId vid)

    fun FALSEExp(I)            = VIDExp(I, vidFALSE)
    fun TRUEExp(I)             = VIDExp(I, vidTRUE)
    fun NILExp(I)              = VIDExp(I, vidNIL)
    fun CONSExp(I)             = VIDExp(I, vidCONS)

    fun FALSEPat(I)            = VIDPat(I, vidFALSE)
    fun TRUEPat(I)             = VIDPat(I, vidTRUE)
    fun NILPat(I)              = VIDPat(I, vidNIL)


    (* Rewriting of withtype declarations [Appendix A, 2nd bullet] *)

    fun lookupTyCon(tycon, C.TypBind(_, tyvarseq, tycon', ty, typbind_opt)) =
            if tycon' = tycon then
                (tyvarseq, ty)
            else
                lookupTyCon(tycon, Option.valOf typbind_opt)
                (* may raise Option *)


    fun replaceTy (C.TyVarseq(_,tyvars), C.Tyseq(i',tys)) (C.TYVARTy(i,tyvar)) =
        let
            fun loop(tyvar'::tyvars', ty'::tys') =
                    if tyvar' = tyvar then
                        ty'
                    else
                        loop(tyvars', tys')
              | loop([],_) =
                    Error.error(i, "unbound type variable")
              | loop(_,[]) =
                    Error.error(i', "type sequence has wrong arity")
        in
            loop(tyvars, tys)
        end

      | replaceTy tyvarseq_tyseq (C.RECORDTy(I, tyrow_opt)) =
            C.RECORDTy(I, Option.map (replaceTyRow tyvarseq_tyseq) tyrow_opt)

      | replaceTy tyvarseq_tyseq (C.TYCONTy(I, tyseq', tycon)) =
            C.TYCONTy(I, replaceTyseq tyvarseq_tyseq tyseq', tycon)

      | replaceTy tyvarseq_tyseq (C.ARROWTy(I, ty1, ty2)) =
            C.ARROWTy(I, replaceTy tyvarseq_tyseq ty1,
                         replaceTy tyvarseq_tyseq ty2)

      | replaceTy tyvarseq_tyseq (C.PARTy(I, ty)) =
            C.PARTy(I, replaceTy tyvarseq_tyseq ty)

    and replaceTyRow tyvarseq_tyseq (C.TyRow(I, lab, ty, tyrow_opt)) =
            C.TyRow(I, lab, replaceTy tyvarseq_tyseq ty, 
                       Option.map (replaceTyRow tyvarseq_tyseq) tyrow_opt)

    and replaceTyseq tyvarseq_tyseq (C.Tyseq(I, tys)) =   
            C.Tyseq(I, List.map (replaceTy tyvarseq_tyseq) tys)


    fun rewriteTy typbind (ty as C.TYVARTy _) = ty

      | rewriteTy typbind (C.RECORDTy(I, tyrow_opt)) =
            C.RECORDTy(I, Option.map (rewriteTyRow typbind) tyrow_opt)

      | rewriteTy typbind (C.TYCONTy(I, tyseq, longtycon)) =
        let 
            val tyseq'          = rewriteTyseq typbind tyseq
            val (strids, tycon) = LongTyCon.explode longtycon
        in
            if not(List.null strids) then
                C.TYCONTy(I, tyseq', longtycon)
            else
                let 
                    val (tyvarseq', ty') = lookupTyCon(tycon, typbind)
                in
                    replaceTy (tyvarseq',tyseq') ty'
                end
                handle Option => C.TYCONTy(I, tyseq', longtycon)
        end

      | rewriteTy typbind (C.ARROWTy(I, ty1, ty2)) =
            C.ARROWTy(I, rewriteTy typbind ty1, rewriteTy typbind ty2)

      | rewriteTy typbind (C.PARTy(I, ty)) =
            C.PARTy(I, rewriteTy typbind ty)

    and rewriteTyRow typbind (C.TyRow(I, lab, ty, tyrow_opt)) =
            C.TyRow(I, lab, rewriteTy typbind ty,
                       Option.map (rewriteTyRow typbind) tyrow_opt)

    and rewriteTyseq typbind (C.Tyseq(I, tys)) =
            C.Tyseq(I, List.map (rewriteTy typbind) tys)

    fun rewriteConBind typbind (C.ConBind(I, op_opt, vid, ty_opt, conbind_opt))=
            C.ConBind(I, op_opt, vid,
                         Option.map (rewriteTy typbind) ty_opt,
                         Option.map (rewriteConBind typbind) conbind_opt)

    fun rewriteDatBind typbind (C.DatBind(I, tyvarseq, tycon, conbind,
                                                              datbind_opt)) =
            C.DatBind(I, tyvarseq, tycon, rewriteConBind typbind conbind,
                         Option.map (rewriteDatBind typbind) datbind_opt)


    (* Patterns [Figure 16] *)

    fun UNITAtPat(I) = C.RECORDAtPat(I, NONE)

    fun TUPLEAtPat(I, [pat]) = C.PARAtPat(I, pat)
      | TUPLEAtPat(I,  pats) =
        let
            fun toPatRow(n,    []     ) = NONE
              | toPatRow(n, pat::pats') =
                  SOME(C.ROWPatRow(I, Lab.fromInt n, pat, toPatRow(n+1,pats')))
        in
            C.RECORDAtPat(I, toPatRow(1, pats))
        end

    fun LISTAtPat(I, pats)  =
        let
            fun toPatList    []       = NILPat(I)
              | toPatList(pat::pats') =
                C.CONPat(I, C.SANSOp, longvidCONS,
                             TUPLEAtPat(I, [pat,toPatList pats']))
        in
            C.PARAtPat(I, toPatList pats)
        end


    (* Pattern Rows [Figure 16] *)

    fun VIDPatRow(I, vid, ty_opt, pat_opt, patrow_opt) =
        let
            val lab    = Lab.fromString(VId.toString vid)
            val vidPat = VIDPat(I, vid)
            val pat    =
                case (ty_opt, pat_opt)
                  of (NONE,    NONE) => vidPat
                   | (SOME ty, NONE) => C.TYPEDPat(I, vidPat, ty)
                   | ( _ , SOME pat) => C.ASPat(I, C.SANSOp,vid,ty_opt,pat)
        in
            C.ROWPatRow(I, lab, pat, patrow_opt)
        end


    (* Expressions [Figure 15] *)

    fun UNITAtExp(I) = C.RECORDAtExp(I, NONE)

    fun TUPLEAtExp(I, [exp]) = C.PARAtExp(I, exp)
      | TUPLEAtExp(I,  exps) =
        let
            fun toExpRow(n,    []     ) = NONE
              | toExpRow(n, exp::exps') =
                  SOME(C.ExpRow(I, Lab.fromInt n, exp, toExpRow(n+1, exps')))
        in
            C.RECORDAtExp(I, toExpRow(1, exps))
        end

    fun HASHAtExp(I, lab) =
        let
            val vid    = VId.invent()
            val dots   = C.WILDCARDPatRow(I)
            val patrow = C.ROWPatRow(I, lab, VIDPat(I, vid), SOME dots)
            val pat    = C.ATPATPat(I, C.RECORDAtPat(I, SOME patrow))
            val mrule  = C.Mrule(I, pat, VIDExp(I, vid))
            val match  = C.Match(I, mrule, NONE)
        in
            C.PARAtExp(I, C.FNExp(I, match))
        end

    fun CASEExp(I, exp, match) =
        let
            val function = C.ATEXPExp(I, C.PARAtExp(I, C.FNExp(I, match)))
        in
            C.APPExp(I, function, C.PARAtExp(I, exp))
        end

    fun IFExp(I, exp1, exp2, exp3) =
        let
            val mruleTrue  = C.Mrule(I, TRUEPat(I), exp2)
            val mruleFalse = C.Mrule(I, FALSEPat(I), exp3)
            val matchFalse = C.Match(I, mruleFalse, NONE)
            val matchTrue  = C.Match(I, mruleTrue, SOME matchFalse)
        in
            CASEExp(I, exp1, matchTrue)
        end

    fun ORELSEExp (I, exp1, exp2) = IFExp(I, exp1, TRUEExp(I), exp2)

    fun ANDALSOExp(I, exp1, exp2) = IFExp(I, exp1, exp2, FALSEExp(I))

    fun SEQAtExp(I, exps) =
        let
            val wildcard             = C.ATPATPat(I, C.WILDCARDAtPat(I))

            fun toExpSeq []          = raise Fail "DerivedFormsCore.SEQAtExp: \
                                                  \empty exp list"
              | toExpSeq [exp]       = exp
              | toExpSeq(exp::exps') =
                  let
                      val mrule = C.Mrule(I, wildcard, toExpSeq exps')
                      val match = C.Match(I, mrule, NONE)
                  in
                      CASEExp(I, exp, match)
                  end
        in
            C.PARAtExp(I, toExpSeq exps)
        end

    fun LETAtExp(I, dec, [exp]) = C.LETAtExp(I, dec, exp)
      | LETAtExp(I, dec,  exps) =
            C.LETAtExp(I, dec, C.ATEXPExp(I, SEQAtExp(I, exps)))

    fun WHILEExp(I, exp1, exp2) =
        let
            val vid       = VId.invent()
            val vidExp    = VIDExp(I, vid)
            val unitAtExp = UNITAtExp(I)
            val unitExp   = C.ATEXPExp(I, unitAtExp)
            val callVid   = C.APPExp(I, vidExp, unitAtExp)

            val seqExp    = C.ATEXPExp(I, SEQAtExp(I, [exp2, callVid]))
            val fnBody    = IFExp(I, exp1, seqExp, unitExp)
            val mrule     = C.Mrule(I, C.ATPATPat(I, UNITAtPat(I)), fnBody)
            val match     = C.Match(I, mrule, NONE)
            val fnExp     = C.FNExp(I, match)
            val fnBind    = C.PLAINValBind(I, VIDPat(I, vid), fnExp, NONE)
            val valbind   = C.RECValBind(I, fnBind)
            val dec       = C.VALDec(I, C.TyVarseq(I, []), valbind)
        in
            C.ATEXPExp(I, C.LETAtExp(I, dec, callVid))
        end

    fun LISTAtExp(I, exps) =
        let
            fun toExpList    []       = NILExp(I)
              | toExpList(exp::exps') =
                  C.APPExp(I, CONSExp(I), TUPLEAtExp(I, [exp, toExpList exps']))
        in
            C.PARAtExp(I, toExpList exps)
        end


    (* Type Expressions [Figure 16] *)

    fun TUPLETy(I, [ty]) = ty
      | TUPLETy(I,  tys) =
        let
            fun toTyRow(n,   []    ) = NONE
              | toTyRow(n, ty::tys') =
                  SOME(C.TyRow(I, Lab.fromInt n, ty, toTyRow(n+1, tys')))
        in
            C.RECORDTy(I, toTyRow(1, tys))
        end


    (* Function-value Bindings [Figure 17] *)

    fun FvalBind(I, (match, vid, arity), fvalbind_opt) =
        let
            fun abstract(0, vidExps) =
                let
                    val exp = C.ATEXPExp(I, TUPLEAtExp(I, List.rev vidExps))
                in
                    CASEExp(I, exp, match)
                end

              | abstract(n, vidExps) =
                let
                    val vid   = VId.invent()
                    val exp   = VIDExp(I, vid)
                    val pat   = VIDPat(I, vid)
                    val mrule = C.Mrule(I, pat, abstract(n-1, exp::vidExps))
                in
                    C.FNExp(I, C.Match(I, mrule, NONE))
                end

            val exp = abstract(arity, [])
            val pat = VIDPat(I, vid)
        in
            C.PLAINValBind(I, pat, exp, fvalbind_opt)
        end


    fun Fmatch(I, (mrule, vid, arity), NONE) =
            ( C.Match(I, mrule, NONE), vid, arity )

      | Fmatch(I, (mrule, vid, arity), SOME(match, vid', arity')) =
            if vid <> vid' then
                Error.error(I, "inconsistent function identifier")
             else if arity <> arity' then
                Error.error(I, "inconsistent function arity")
             else
                ( C.Match(I, mrule, SOME match), vid, arity )


    fun Fmrule(I, _, vid, atpats, ty_opt, exp) =
        let
            val pats = List.map (fn atpat => C.ATPATPat(I, atpat)) atpats
            val pat' = C.ATPATPat(I, TUPLEAtPat(I, pats))
            val exp' = case ty_opt
                         of NONE    => exp
                          | SOME ty => C.TYPEDExp(I, exp, ty)
            val arity = List.length atpats
        in
            ( C.Mrule(I, pat', exp'), vid, arity )
        end


    (* Declarations [Figure 17] *)

    fun FUNDec(I, tyvarseq, fvalbind) =
            C.VALDec(I, tyvarseq, C.RECValBind(I, fvalbind))

    fun DATATYPEDec(I, datbind, NONE)         = C.DATATYPEDec(I, datbind)
      | DATATYPEDec(I, datbind, SOME typbind) =
        let
            val datbind' = rewriteDatBind typbind datbind
        in
            C.SEQDec(I, C.DATATYPEDec(C.infoDatBind datbind, datbind'),
                        C.TYPEDec(C.infoTypBind typbind, typbind))
        end

    fun ABSTYPEDec(I, datbind, NONE, dec)         = C.ABSTYPEDec(I, datbind,dec)
      | ABSTYPEDec(I, datbind, SOME typbind, dec) =
        let
            val I'       = C.infoTypBind typbind
            val datbind' = rewriteDatBind typbind datbind
        in
            C.ABSTYPEDec(I, datbind', C.SEQDec(I, C.TYPEDec(I', typbind), dec))
        end

  end
(* stop of DerivedFormsCore.sml *)
(* start of DERIVED_FORMS_MODULE.sml *)
(*
 * Standard ML modules derived forms
 *
 * Definition, Appendix A
 *
 * Notes:
 * - A phrase named SynDesc has been added to factorize type synonym
 *   specifications.
 * - Similarly, a phrase named TyReaDesc has been added to factorize type
 *   realisation signature expressions.
 * - The structure sharing derived form is missing since it cannot be resolved
 *   syntactically. It has been moved to the bare grammar.
 *)


signature DERIVED_FORMS_MODULE =
  sig

    (* Import *)

    type Info       = GrammarModule.Info

    type VId        = GrammarCore.VId
    type TyCon      = GrammarCore.TyCon
    type StrId      = GrammarCore.StrId
    type SigId      = GrammarModule.SigId
    type FunId      = GrammarModule.FunId
    type longTyCon  = GrammarCore.longTyCon

    type Ty         = GrammarCore.Ty
    type TyVarseq   = GrammarCore.TyVarseq

    type StrExp     = GrammarModule.StrExp
    type StrDec     = GrammarModule.StrDec
    type StrBind    = GrammarModule.StrBind
    type SigExp     = GrammarModule.SigExp
    type TyReaDesc  = (Info * TyVarseq * longTyCon * Ty) list
    type Spec       = GrammarModule.Spec
    type SynDesc    = (Info * TyVarseq * TyCon * Ty) list
    type FunBind    = GrammarModule.FunBind


    (* Structure Bindings [Figure 18] *)

    val TRANSStrBind:     Info * StrId * SigExp option * StrExp
                               * StrBind option                 -> StrBind
    val OPAQStrBind:      Info * StrId * SigExp * StrExp
                               * StrBind option                 -> StrBind

    (* Structure Expressions [Figure 18] *)

    val APPDECStrExp:     Info * FunId * StrDec                 -> StrExp

    (* Functor Bindings [Figure 18] *)

    val TRANSFunBind:     Info * FunId * StrId * SigExp * SigExp option
                               * StrExp * FunBind option        -> FunBind
    val OPAQFunBind:      Info * FunId * StrId * SigExp * SigExp
                               * StrExp * FunBind option        -> FunBind
    val TRANSSPECFunBind: Info * FunId * Spec * SigExp option
                               * StrExp * FunBind option        -> FunBind
    val OPAQSPECFunBind:  Info * FunId * Spec * SigExp
                               * StrExp * FunBind option        -> FunBind

    (* Specifications [Figure 19] *)

    val SYNSpec:          Info * SynDesc                        -> Spec
    val INCLUDEMULTISpec: Info * SigId list                     -> Spec

    val SynDesc:          Info * TyVarseq * TyCon * Ty
                               * SynDesc option                 -> SynDesc

    (* Signature Expressions [Figure 19] *)

    val WHERETYPESigExp:  Info * SigExp * TyReaDesc             -> SigExp

    val TyReaDesc:        Info * TyVarseq * longTyCon * Ty
                               * TyReaDesc option               -> TyReaDesc
  end
(* stop of DERIVED_FORMS_MODULE.sml *)
(* start of DerivedFormsModule.sml *)
(*
 * Standard ML modules derived forms
 *
 * Definition, Appendix A
 *
 * Notes:
 * - A phrase named SynDesc has been added to factorize type synonym
 *   specifications.
 * - Similarly, a phrase named TyReaDesc has been added to factorize type
 *   realisation signature expressions.
 * - The structure sharing derived form is missing since it cannot be resolved
 *   syntactically. It has been moved to the bare grammar.
 *)


structure DerivedFormsModule :> DERIVED_FORMS_MODULE =
  struct

    (* Import *)

    structure C     = GrammarCore
    structure M     = GrammarModule

    type Info       = M.Info

    type VId        = M.VId
    type TyCon      = M.TyCon
    type StrId      = M.StrId
    type SigId      = M.SigId
    type FunId      = M.FunId
    type longTyCon  = M.longTyCon

    type Ty         = M.Ty
    type TyVarseq   = M.TyVarseq

    type StrExp     = M.StrExp
    type StrDec     = M.StrDec
    type StrBind    = M.StrBind
    type SigExp     = M.SigExp
    type TyReaDesc  = (M.Info * M.TyVarseq * M.longTyCon * M.Ty) list
    type Spec       = M.Spec
    type SynDesc    = (M.Info * M.TyVarseq * M.TyCon * M.Ty) list
    type FunBind    = M.FunBind


    (* Structure Bindings [Figure 18] *)

    fun TRANSStrBind(I, strid, NONE, strexp, strbind_opt) =
            M.StrBind(I, strid, strexp, strbind_opt)

      | TRANSStrBind(I, strid, SOME sigexp, strexp, strbind_opt) =
            M.StrBind(I, strid, M.TRANSStrExp(I, strexp, sigexp), strbind_opt)

    fun OPAQStrBind(I, strid, sigexp, strexp, strbind_opt) =
            M.StrBind(I, strid, M.OPAQStrExp(I, strexp, sigexp), strbind_opt)


    (* Structure Expressions [Figure 18] *)

    fun APPDECStrExp(I, funid, strdec) =
            M.APPStrExp(I, funid, M.STRUCTStrExp(M.infoStrDec strdec, strdec))


    (* Functor Bindings [Figure 18] *)

    fun TRANSFunBind(I, funid, strid, sigexp, NONE, strexp, funbind_opt) =
            M.FunBind(I, funid, strid, sigexp, strexp, funbind_opt)

      | TRANSFunBind(I, funid, strid,sigexp, SOME sigexp', strexp, funbind_opt)=
            M.FunBind(I, funid, strid, sigexp, M.TRANSStrExp(I, strexp,sigexp'),
                         funbind_opt)

    fun OPAQFunBind(I, funid, strid, sigexp, sigexp', strexp, funbind_opt) =
            M.FunBind(I, funid, strid, sigexp, M.OPAQStrExp(I, strexp, sigexp'),
                         funbind_opt)


    fun TRANSSPECFunBind(I, funid, spec, sigexp_opt, strexp, funbind_opt) =
        let
            val I'     = M.infoStrExp strexp
            val strid  = StrId.invent()
            val sigexp = M.SIGSigExp(M.infoSpec spec, spec)

            val strdec = M.DECStrDec(I', C.OPENDec(I',[LongStrId.fromId strid]))
            val strexp'= case sigexp_opt
                           of NONE         => strexp
                            | SOME sigexp' => M.TRANSStrExp(I', strexp, sigexp')
            val letexp = M.LETStrExp(I', strdec, strexp')
        in
            M.FunBind(I, funid, strid, sigexp, letexp, funbind_opt)
        end

    fun OPAQSPECFunBind(I, funid, spec, sigexp', strexp, funbind_opt) =
        let
            val I'     = M.infoStrExp strexp
            val strid  = StrId.invent()
            val sigexp = M.SIGSigExp(M.infoSpec spec, spec)

            val strdec = M.DECStrDec(I', C.OPENDec(I',[LongStrId.fromId strid]))
            val strexp'= M.TRANSStrExp(I', strexp, sigexp')
            val letexp = M.LETStrExp(I', strdec, strexp')
        in
            M.FunBind(I, funid, strid, sigexp, letexp, funbind_opt)
        end


    (* Specifications [Figure 19] *)

    fun SYNSpec(I, [])                            = M.EMPTYSpec(I)
      | SYNSpec(I, (I',tyvarseq,tycon,ty)::syns') =
        let
            val longtycon = LongTyCon.fromId tycon
            val typdesc = M.TypDesc(I', tyvarseq, tycon, NONE)
            val sigexp  = M.SIGSigExp(I', M.TYPESpec(I', typdesc))
            val sigexp' = M.WHERETYPESigExp(I', sigexp, tyvarseq, longtycon, ty)
            val spec1   = M.INCLUDESpec(I', sigexp')
        in
            M.SEQSpec(I, spec1, SYNSpec(I, syns'))
        end

    fun INCLUDEMULTISpec(I,      []       ) = M.EMPTYSpec(I)
      | INCLUDEMULTISpec(I, sigid::sigids') =
        let
            val spec1 = M.INCLUDESpec(I, M.SIGIDSigExp(I, sigid))
        in
            M.SEQSpec(I, spec1, INCLUDEMULTISpec(I, sigids'))
        end


    fun SynDesc(I, tyvarseq, tycon, ty, NONE) =
            (I, tyvarseq, tycon, ty) :: []

      | SynDesc(I, tyvarseq, tycon, ty, SOME syndesc) =
            (I, tyvarseq, tycon, ty) :: syndesc


    (* Signature Expressions [Figure 19] *)

    fun WHERETYPESigExp(I, sigexp,                           []     ) = sigexp
      | WHERETYPESigExp(I, sigexp, (I',tyvarseq,longtycon,ty)::reas') =
        let
            val sigexp' = M.WHERETYPESigExp(I', sigexp, tyvarseq, longtycon, ty)
        in
            WHERETYPESigExp(I, sigexp', reas')
        end


    fun TyReaDesc(I, tyvarseq, longtycon, ty, NONE) =
            (I, tyvarseq, longtycon, ty) :: []

      | TyReaDesc(I, tyvarseq, longtycon, ty, SOME tyreadesc) =
            (I, tyvarseq, longtycon, ty) :: tyreadesc

  end
(* stop of DerivedFormsModule.sml *)
(* start of DERIVED_FORMS_PROGRAM.sml *)
(*
 * Standard ML program derived forms
 *
 * Definition, Appendix A
 *)


signature DERIVED_FORMS_PROGRAM =
  sig

    (* Import *)

    type Info    = GrammarProgram.Info

    type Exp     = GrammarCore.Exp
    type TopDec  = GrammarModule.TopDec
    type Program = GrammarProgram.Program


    (* Programs [Figure 18] *)

    val TOPDECProgram:  Info * TopDec * Program option -> Program
    val EXPProgram:     Info *  Exp   * Program option -> Program

  end
(* stop of DERIVED_FORMS_PROGRAM.sml *)
(* start of DerivedFormsProgram.sml *)
(*
 * Standard ML program derived forms
 *
 * Definition, Appendix A
 *)


structure DerivedFormsProgram :> DERIVED_FORMS_PROGRAM =
  struct

    (* Import *)

    structure C  = GrammarCore
    structure M  = GrammarModule
    structure P  = GrammarProgram

    type Info    = GrammarProgram.Info

    type Exp     = GrammarCore.Exp
    type TopDec  = GrammarModule.TopDec
    type Program = GrammarProgram.Program


    (* Programs [Figure 18] *)

    fun TOPDECProgram(I, topdec, program_opt) =
            P.Program(I, topdec, program_opt)

    fun EXPProgram(I, exp, program_opt) =
        let
            val longvid = LongVId.fromId(VId.fromString "it")
            val pat     = C.ATPATPat(I, C.LONGVIDAtPat(I, C.SANSOp, longvid))
            val valbind = C.PLAINValBind(I, pat, exp, NONE)
            val dec     = C.VALDec(I, C.TyVarseq(I, []), valbind)
            val topdec  = M.STRDECTopDec(I, M.DECStrDec(I, dec), NONE)
        in
            P.Program(I, topdec, program_opt)
        end

  end
(* stop of DerivedFormsProgram.sml *)
(* start of Parser.grm.sig *)
signature Parser_TOKENS =
sig
type ('a,'b) token
type svalue
val LONGID: (string list*string) *  'a * 'a -> (svalue,'a) token
val ETYVAR: (string) *  'a * 'a -> (svalue,'a) token
val TYVAR: (string) *  'a * 'a -> (svalue,'a) token
val STAR:  'a * 'a -> (svalue,'a) token
val SYMBOL: (string) *  'a * 'a -> (svalue,'a) token
val ALPHA: (string) *  'a * 'a -> (svalue,'a) token
val CHAR: (char) *  'a * 'a -> (svalue,'a) token
val STRING: (string) *  'a * 'a -> (svalue,'a) token
val REAL: (real) *  'a * 'a -> (svalue,'a) token
val WORD: (word) *  'a * 'a -> (svalue,'a) token
val INT: (int) *  'a * 'a -> (svalue,'a) token
val NUMERIC: (int) *  'a * 'a -> (svalue,'a) token
val DIGIT: (int) *  'a * 'a -> (svalue,'a) token
val ZERO:  'a * 'a -> (svalue,'a) token
val COLONGREATER:  'a * 'a -> (svalue,'a) token
val WHERE:  'a * 'a -> (svalue,'a) token
val STRUCTURE:  'a * 'a -> (svalue,'a) token
val STRUCT:  'a * 'a -> (svalue,'a) token
val SIGNATURE:  'a * 'a -> (svalue,'a) token
val SIG:  'a * 'a -> (svalue,'a) token
val SHARING:  'a * 'a -> (svalue,'a) token
val INCLUDE:  'a * 'a -> (svalue,'a) token
val FUNCTOR:  'a * 'a -> (svalue,'a) token
val EQTYPE:  'a * 'a -> (svalue,'a) token
val HASH:  'a * 'a -> (svalue,'a) token
val ARROW:  'a * 'a -> (svalue,'a) token
val DARROW:  'a * 'a -> (svalue,'a) token
val EQUALS:  'a * 'a -> (svalue,'a) token
val BAR:  'a * 'a -> (svalue,'a) token
val UNDERBAR:  'a * 'a -> (svalue,'a) token
val DOTS:  'a * 'a -> (svalue,'a) token
val SEMICOLON:  'a * 'a -> (svalue,'a) token
val COLON:  'a * 'a -> (svalue,'a) token
val COMMA:  'a * 'a -> (svalue,'a) token
val RBRACE:  'a * 'a -> (svalue,'a) token
val LBRACE:  'a * 'a -> (svalue,'a) token
val RBRACK:  'a * 'a -> (svalue,'a) token
val LBRACK:  'a * 'a -> (svalue,'a) token
val RPAR:  'a * 'a -> (svalue,'a) token
val LPAR:  'a * 'a -> (svalue,'a) token
val WHILE:  'a * 'a -> (svalue,'a) token
val WITHTYPE:  'a * 'a -> (svalue,'a) token
val WITH:  'a * 'a -> (svalue,'a) token
val VAL:  'a * 'a -> (svalue,'a) token
val TYPE:  'a * 'a -> (svalue,'a) token
val THEN:  'a * 'a -> (svalue,'a) token
val REC:  'a * 'a -> (svalue,'a) token
val RAISE:  'a * 'a -> (svalue,'a) token
val ORELSE:  'a * 'a -> (svalue,'a) token
val OPEN:  'a * 'a -> (svalue,'a) token
val OP:  'a * 'a -> (svalue,'a) token
val OF:  'a * 'a -> (svalue,'a) token
val NONFIX:  'a * 'a -> (svalue,'a) token
val LOCAL:  'a * 'a -> (svalue,'a) token
val LET:  'a * 'a -> (svalue,'a) token
val INFIXR:  'a * 'a -> (svalue,'a) token
val INFIX:  'a * 'a -> (svalue,'a) token
val IN:  'a * 'a -> (svalue,'a) token
val IF:  'a * 'a -> (svalue,'a) token
val HANDLE:  'a * 'a -> (svalue,'a) token
val FUN:  'a * 'a -> (svalue,'a) token
val FN:  'a * 'a -> (svalue,'a) token
val EXCEPTION:  'a * 'a -> (svalue,'a) token
val END:  'a * 'a -> (svalue,'a) token
val ELSE:  'a * 'a -> (svalue,'a) token
val DATATYPE:  'a * 'a -> (svalue,'a) token
val DO:  'a * 'a -> (svalue,'a) token
val CASE:  'a * 'a -> (svalue,'a) token
val AS:  'a * 'a -> (svalue,'a) token
val ANDALSO:  'a * 'a -> (svalue,'a) token
val AND:  'a * 'a -> (svalue,'a) token
val ABSTYPE:  'a * 'a -> (svalue,'a) token
val EOF:  'a * 'a -> (svalue,'a) token
end
signature Parser_LRVALS=
sig
structure Tokens : Parser_TOKENS
structure ParserData:PARSER_DATA
sharing type ParserData.Token.token = Tokens.token
sharing type ParserData.svalue = Tokens.svalue
end
(* stop of Parser.grm.sig *)
(* start of Parser.grm.sml *)
functor LrValsFn(structure Token: TOKEN) = 
struct
structure ParserData=
struct
structure Header = 
struct
(*                                                                              *)
(* Standard ML syntactical analysis                                             *)
(*                                                                              *)
(* Definition, sections 2, 3, and 8, Appendix A and B                           *)
(*                                                                              *)
(* Notes:                                                                       *)
(*   - Two phrases named Fmatch and Fmrule have been added to factorize         *)
(*     Fvalbind.                                                                *)
(*   - A phrase named SynDesc has been added to factorize type synonym          *)
(*     specifications. Similarly, a phrase named TyReaDesc has been added to    *)
(*     factorize type realisation signature expressions.                        *)
(*   - Infix expressions [Definition, section 2.6] are resolved externally in   *)
(*     structure Infix. The parser just maintains the infix environment J by    *)
(*     side effect. To achieve correct treatment of scoped fixity directives,   *)
(*     a stack of environments is used. To handle `local' we even need a        *)
(*     second environment J' (together with a a second stack).                  *)
(*   - Syntactic restrictions [Definition, sections 2.9 and 3.5] are checked    *)
(*     during elaboration, as well as the Fvalbind derived form.                *)
(*   - The Definition is not clear about whether `=' should also be legal as    *)
(*     a tycon. Since this would result in massive conflicts, and a type named  *)
(*     `=' could only be used legally if an implementation would be mad enough  *)
(*     to predefine it anyway, we simply disallow it.                           *)
(*   - The Definition is also vague about what consists a non-infixed occurance *)
(*     of an infix identifier: we assume any occurances in expressions          *)
(*     or patterns. This implies that uses of the keyword `op' in constructor   *)
(*     and exception bindings are completely redundant.                         *)
(*   - Datatype replication requires rules for datatype to be duplicated to     *)
(*     avoid conflicts on empty tyvarseqs.                                      *)
(*   - Layered patterns require some grammar transformation hack, see pat.      *)
(*   - The messy `sigexp where type ... and type ...' syntax requires some      *)
(*     really ugly transformations (in absence of a lookahead of 2), watch out  *)
(*     for non-terminals of the form xxx__AND_yyybind_opt.                      *)
(*   - ML-Yacc does not seem to like comments that stretch over several         *)
(*     lines... Similarly, comments in semantic actions make it puke...         *)
(*                                                                              *)
(* Bugs:                                                                        *)
(*   - We do NOT support declarations like                                      *)
(*        fun f p1 = case e1 of p2 => e2                                        *)
(*          | f p3 = e3                                                         *)
(*     (without parentheses around the case) because the transformations        *)
(*     required to support this would be even a magnitude uglier than those     *)
(*     above. In fact, no compiler I know of supports this.                     *)
(*                                                                              *)



    (* Import *)

    open GrammarCore
    open GrammarModule
    open GrammarProgram
    open DerivedFormsCore
    open DerivedFormsModule
    open DerivedFormsProgram


    (* Helper to build info fields *)

    fun I(left, right) = if right = 0 then (left, left) else (left, right)


    (* Handling infix environments *)

    val J  = ref Infix.empty    (* context *)
    val J' = ref Infix.empty    (* local environment (+ enclosing one) *)

    val stackJ  = ref [] : Infix.InfEnv list ref
    val stackJ' = ref [] : Infix.InfEnv list ref

    fun initJandJ'(J0) =
        (
            J       := J0;
            J'      := J0;
            stackJ  := [];
            stackJ' := []
        )

    fun pushJ() =
        (
            stackJ  := !J :: !stackJ
        )

    fun popJ() =
        (
            J       := List.hd(!stackJ);
            stackJ  := List.tl(!stackJ)
        )

    fun pushJ'shiftJ() =
        (
            stackJ' := !J' :: !stackJ';
            J'      := List.hd(!stackJ)
        )

    fun popJandJ'() =
        (
            J       := !J';
            J'      := List.hd(!stackJ');
            stackJ  := List.tl(!stackJ);
            stackJ' := List.tl(!stackJ')
        )


    fun assignInfix(infstatus, vids) =
        (
            J  := Infix.assign(!J, vids, infstatus);
            J' := Infix.assign(!J', vids, infstatus)
        )

    fun cancelInfix(vids) =
        (
            J  := Infix.cancel(!J, vids);
            J' := Infix.cancel(!J', vids)
        )


    (* Helper for long identifiers *)

    fun toLongId toId (strids, id) =
            ( List.map StrId.fromString strids, toId id )


    (* Helper to handle typed patterns (needed because of layered patterns) *)

    fun typedPat(pat,   []   ) = pat
      | typedPat(pat, ty::tys) =
        let
            val I = Source.over(infoPat pat, infoTy ty)
        in
            typedPat(TYPEDPat(I, pat, ty), tys)
        end




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\001\000\184\003\002\000\049\000\006\000\048\000\008\000\047\000\
\\011\000\046\000\012\000\045\000\013\000\044\000\015\000\043\000\
\\017\000\042\000\018\000\041\000\019\000\040\000\020\000\039\000\
\\021\000\038\000\023\000\037\000\024\000\036\000\026\000\035\000\
\\029\000\034\000\030\000\033\000\033\000\032\000\034\000\031\000\
\\036\000\030\000\038\000\029\000\042\000\174\003\046\000\151\002\
\\049\000\028\000\051\000\027\000\055\000\026\000\057\000\025\000\
\\060\000\024\000\061\000\023\000\062\000\022\000\063\000\021\000\
\\064\000\020\000\065\000\019\000\066\000\018\000\067\000\017\000\
\\068\000\151\002\069\000\151\002\070\000\151\002\073\000\151\002\000\000\
\\001\000\002\000\139\002\003\000\139\002\008\000\139\002\010\000\139\002\
\\011\000\139\002\013\000\139\002\016\000\139\002\017\000\139\002\
\\018\000\139\002\020\000\139\002\021\000\139\002\024\000\139\002\
\\029\000\139\002\030\000\139\002\034\000\141\002\035\000\139\002\
\\041\000\139\002\042\000\139\002\051\000\139\002\055\000\139\002\
\\057\000\139\002\059\000\139\002\000\000\
\\001\000\002\000\178\002\003\000\178\002\004\000\178\002\007\000\178\002\
\\008\000\178\002\009\000\178\002\010\000\178\002\011\000\178\002\
\\013\000\178\002\014\000\178\002\016\000\178\002\017\000\178\002\
\\018\000\178\002\019\000\040\000\020\000\178\002\021\000\178\002\
\\022\000\178\002\023\000\037\000\024\000\178\002\025\000\178\002\
\\028\000\178\002\029\000\178\002\030\000\178\002\034\000\031\000\
\\035\000\178\002\036\000\030\000\037\000\178\002\038\000\029\000\
\\039\000\178\002\040\000\178\002\041\000\178\002\042\000\178\002\
\\045\000\178\002\046\000\151\002\049\000\028\000\051\000\178\002\
\\055\000\178\002\057\000\178\002\060\000\024\000\061\000\023\000\
\\062\000\022\000\063\000\021\000\064\000\020\000\065\000\019\000\
\\066\000\018\000\067\000\017\000\068\000\151\002\069\000\151\002\
\\070\000\151\002\073\000\151\002\000\000\
\\001\000\002\000\034\003\003\000\034\003\004\000\034\003\005\000\034\003\
\\007\000\034\003\008\000\034\003\009\000\034\003\010\000\034\003\
\\011\000\034\003\013\000\034\003\014\000\034\003\016\000\034\003\
\\017\000\034\003\018\000\034\003\020\000\034\003\021\000\034\003\
\\022\000\034\003\024\000\034\003\025\000\034\003\028\000\034\003\
\\029\000\034\003\030\000\034\003\031\000\034\003\032\000\034\003\
\\035\000\034\003\037\000\034\003\039\000\034\003\040\000\034\003\
\\041\000\034\003\042\000\034\003\045\000\034\003\046\000\034\003\
\\047\000\034\003\048\000\034\003\050\000\034\003\051\000\034\003\
\\052\000\034\003\053\000\034\003\055\000\034\003\057\000\034\003\
\\058\000\034\003\059\000\034\003\068\000\045\003\069\000\045\003\
\\070\000\248\000\073\000\045\003\000\000\
\\001\000\002\000\075\003\003\000\148\001\008\000\075\003\010\000\075\003\
\\011\000\075\003\013\000\075\003\016\000\075\003\017\000\075\003\
\\018\000\075\003\020\000\075\003\021\000\075\003\024\000\075\003\
\\029\000\075\003\030\000\075\003\035\000\075\003\041\000\056\003\
\\042\000\075\003\051\000\075\003\055\000\075\003\057\000\075\003\
\\059\000\056\003\000\000\
\\001\000\002\000\075\003\003\000\148\001\008\000\075\003\010\000\075\003\
\\011\000\075\003\013\000\075\003\016\000\075\003\017\000\075\003\
\\018\000\075\003\020\000\075\003\021\000\075\003\024\000\075\003\
\\029\000\075\003\030\000\075\003\035\000\075\003\041\000\086\003\
\\042\000\075\003\051\000\075\003\055\000\075\003\057\000\075\003\
\\058\000\086\003\059\000\086\003\000\000\
\\001\000\002\000\075\003\003\000\097\002\008\000\075\003\010\000\075\003\
\\011\000\075\003\013\000\075\003\016\000\075\003\017\000\075\003\
\\018\000\075\003\020\000\075\003\021\000\075\003\024\000\075\003\
\\029\000\075\003\030\000\075\003\035\000\075\003\041\000\101\003\
\\042\000\075\003\051\000\075\003\055\000\075\003\057\000\075\003\
\\058\000\101\003\059\000\101\003\000\000\
\\001\000\002\000\093\003\003\000\086\001\008\000\093\003\011\000\093\003\
\\013\000\093\003\017\000\093\003\018\000\093\003\020\000\093\003\
\\021\000\093\003\024\000\093\003\029\000\093\003\030\000\093\003\
\\042\000\093\003\051\000\093\003\055\000\093\003\057\000\093\003\
\\058\000\086\003\000\000\
\\001\000\002\000\093\003\003\000\077\002\008\000\093\003\011\000\093\003\
\\013\000\093\003\017\000\093\003\018\000\093\003\020\000\093\003\
\\021\000\093\003\024\000\093\003\029\000\093\003\030\000\093\003\
\\042\000\093\003\051\000\093\003\055\000\093\003\057\000\093\003\
\\058\000\101\003\000\000\
\\001\000\002\000\164\003\003\000\032\002\008\000\164\003\011\000\164\003\
\\013\000\164\003\017\000\164\003\018\000\164\003\020\000\164\003\
\\021\000\164\003\024\000\164\003\029\000\164\003\030\000\164\003\
\\041\000\056\003\042\000\164\003\051\000\164\003\055\000\164\003\
\\057\000\164\003\059\000\056\003\000\000\
\\001\000\002\000\164\003\003\000\032\002\008\000\164\003\011\000\164\003\
\\013\000\164\003\017\000\164\003\018\000\164\003\020\000\164\003\
\\021\000\164\003\024\000\164\003\029\000\164\003\030\000\164\003\
\\041\000\086\003\042\000\164\003\051\000\164\003\055\000\164\003\
\\057\000\164\003\058\000\086\003\059\000\086\003\000\000\
\\001\000\002\000\164\003\003\000\108\002\008\000\164\003\011\000\164\003\
\\013\000\164\003\017\000\164\003\018\000\164\003\020\000\164\003\
\\021\000\164\003\024\000\164\003\029\000\164\003\030\000\164\003\
\\041\000\101\003\042\000\164\003\051\000\164\003\055\000\164\003\
\\057\000\164\003\058\000\101\003\059\000\101\003\000\000\
\\001\000\002\000\049\000\006\000\048\000\008\000\047\000\011\000\046\000\
\\012\000\045\000\013\000\044\000\015\000\043\000\017\000\042\000\
\\018\000\041\000\019\000\040\000\020\000\039\000\021\000\038\000\
\\023\000\037\000\024\000\036\000\026\000\035\000\029\000\034\000\
\\030\000\033\000\033\000\032\000\034\000\031\000\036\000\030\000\
\\038\000\029\000\042\000\174\003\046\000\151\002\049\000\028\000\
\\051\000\027\000\055\000\026\000\057\000\025\000\060\000\024\000\
\\061\000\023\000\062\000\022\000\063\000\021\000\064\000\020\000\
\\065\000\019\000\066\000\018\000\067\000\017\000\068\000\151\002\
\\069\000\151\002\070\000\151\002\073\000\151\002\000\000\
\\001\000\003\000\005\002\008\000\152\003\010\000\152\003\011\000\152\003\
\\029\000\152\003\030\000\152\003\035\000\152\003\050\000\152\003\
\\052\000\152\003\053\000\152\003\057\000\152\003\058\000\086\003\000\000\
\\001\000\003\000\101\002\008\000\152\003\010\000\152\003\011\000\152\003\
\\029\000\152\003\030\000\152\003\035\000\152\003\050\000\152\003\
\\052\000\152\003\053\000\152\003\057\000\152\003\058\000\101\003\000\000\
\\001\000\004\000\059\000\007\000\183\000\014\000\058\000\025\000\057\000\
\\041\000\056\000\000\000\
\\001\000\004\000\059\000\009\000\131\001\014\000\058\000\025\000\057\000\
\\041\000\056\000\000\000\
\\001\000\004\000\059\000\014\000\058\000\022\000\242\000\025\000\057\000\
\\041\000\056\000\000\000\
\\001\000\004\000\059\000\014\000\058\000\025\000\057\000\028\000\224\000\
\\041\000\056\000\000\000\
\\001\000\004\000\059\000\014\000\058\000\025\000\057\000\035\000\180\000\
\\040\000\179\000\041\000\056\000\042\000\178\000\000\000\
\\001\000\004\000\059\000\014\000\058\000\025\000\057\000\041\000\056\000\
\\042\000\055\000\000\000\
\\001\000\005\000\133\002\039\000\133\002\040\000\133\002\041\000\133\002\
\\046\000\126\002\000\000\
\\001\000\005\000\134\002\039\000\134\002\040\000\134\002\041\000\134\002\
\\046\000\127\002\000\000\
\\001\000\005\000\135\002\039\000\135\002\040\000\135\002\041\000\135\002\
\\046\000\128\002\000\000\
\\001\000\005\000\012\003\035\000\029\003\037\000\029\003\039\000\029\003\
\\040\000\029\003\041\000\186\000\046\000\029\003\047\000\029\003\000\000\
\\001\000\005\000\013\003\023\000\144\002\034\000\144\002\035\000\144\002\
\\036\000\144\002\037\000\144\002\038\000\144\002\039\000\144\002\
\\040\000\144\002\041\000\031\001\044\000\144\002\046\000\144\002\
\\047\000\144\002\060\000\144\002\061\000\144\002\062\000\144\002\
\\063\000\144\002\064\000\144\002\065\000\144\002\066\000\144\002\
\\067\000\144\002\068\000\144\002\069\000\144\002\070\000\144\002\
\\073\000\144\002\000\000\
\\001\000\005\000\118\001\000\000\
\\001\000\006\000\048\000\012\000\045\000\015\000\043\000\019\000\040\000\
\\023\000\037\000\026\000\035\000\033\000\032\000\034\000\031\000\
\\036\000\030\000\037\000\163\002\038\000\029\000\046\000\151\002\
\\049\000\028\000\060\000\024\000\061\000\023\000\062\000\022\000\
\\063\000\021\000\064\000\020\000\065\000\019\000\066\000\018\000\
\\067\000\017\000\068\000\151\002\069\000\151\002\070\000\151\002\
\\073\000\151\002\000\000\
\\001\000\008\000\233\001\068\000\067\000\069\000\066\000\070\000\065\000\000\000\
\\001\000\010\000\157\001\000\000\
\\001\000\010\000\198\001\000\000\
\\001\000\010\000\238\001\000\000\
\\001\000\010\000\020\002\000\000\
\\001\000\010\000\027\002\000\000\
\\001\000\010\000\070\002\000\000\
\\001\000\010\000\072\002\000\000\
\\001\000\016\000\045\001\000\000\
\\001\000\016\000\047\001\000\000\
\\001\000\016\000\190\001\000\000\
\\001\000\016\000\251\001\000\000\
\\001\000\019\000\081\001\056\000\080\001\068\000\079\001\073\000\118\000\000\000\
\\001\000\023\000\037\000\034\000\142\000\035\000\018\003\036\000\107\000\
\\037\000\018\003\038\000\106\000\039\000\018\003\040\000\018\003\
\\044\000\105\000\046\000\018\003\047\000\018\003\060\000\024\000\
\\061\000\023\000\062\000\022\000\063\000\021\000\064\000\020\000\
\\065\000\019\000\066\000\018\000\067\000\017\000\068\000\151\002\
\\069\000\151\002\070\000\151\002\073\000\151\002\000\000\
\\001\000\023\000\037\000\034\000\142\000\035\000\026\003\036\000\107\000\
\\037\000\026\003\038\000\106\000\039\000\026\003\040\000\026\003\
\\041\000\026\003\044\000\105\000\046\000\026\003\047\000\026\003\
\\060\000\024\000\061\000\023\000\062\000\022\000\063\000\021\000\
\\064\000\020\000\065\000\019\000\066\000\018\000\067\000\017\000\
\\068\000\151\002\069\000\151\002\070\000\151\002\073\000\151\002\000\000\
\\001\000\023\000\037\000\034\000\142\000\036\000\107\000\037\000\003\003\
\\038\000\106\000\044\000\105\000\060\000\024\000\061\000\023\000\
\\062\000\022\000\063\000\021\000\064\000\020\000\065\000\019\000\
\\066\000\018\000\067\000\017\000\068\000\151\002\069\000\151\002\
\\070\000\151\002\073\000\151\002\000\000\
\\001\000\029\000\096\001\068\000\071\000\073\000\118\000\000\000\
\\001\000\029\000\155\001\000\000\
\\001\000\029\000\160\001\000\000\
\\001\000\029\000\160\001\068\000\074\000\000\000\
\\001\000\029\000\162\001\068\000\071\000\073\000\118\000\000\000\
\\001\000\029\000\024\002\000\000\
\\001\000\029\000\024\002\068\000\071\000\000\000\
\\001\000\029\000\040\002\000\000\
\\001\000\029\000\040\002\068\000\071\000\000\000\
\\001\000\029\000\088\002\000\000\
\\001\000\029\000\088\002\068\000\077\000\000\000\
\\001\000\031\000\066\001\000\000\
\\001\000\034\000\113\000\068\000\150\000\069\000\149\000\071\000\104\000\000\000\
\\001\000\034\000\173\000\000\000\
\\001\000\034\000\151\001\000\000\
\\001\000\035\000\181\000\000\000\
\\001\000\035\000\182\000\000\000\
\\001\000\035\000\038\001\000\000\
\\001\000\035\000\040\001\040\000\039\001\000\000\
\\001\000\035\000\041\001\000\000\
\\001\000\035\000\071\001\000\000\
\\001\000\035\000\073\001\040\000\072\001\000\000\
\\001\000\035\000\090\001\000\000\
\\001\000\035\000\217\001\058\000\082\001\000\000\
\\001\000\035\000\246\001\000\000\
\\001\000\035\000\249\001\041\000\248\001\059\000\247\001\000\000\
\\001\000\037\000\177\000\000\000\
\\001\000\037\000\037\001\000\000\
\\001\000\039\000\174\000\000\000\
\\001\000\039\000\033\001\000\000\
\\001\000\039\000\069\001\000\000\
\\001\000\041\000\070\001\000\000\
\\001\000\041\000\091\001\000\000\
\\001\000\041\000\150\001\059\000\149\001\000\000\
\\001\000\041\000\166\001\000\000\
\\001\000\041\000\173\001\000\000\
\\001\000\041\000\034\002\059\000\033\002\000\000\
\\001\000\042\000\050\000\000\000\
\\001\000\043\000\200\000\061\000\083\000\062\000\082\000\068\000\199\000\
\\069\000\198\000\070\000\197\000\000\000\
\\001\000\046\000\068\000\068\000\067\000\069\000\066\000\070\000\065\000\
\\073\000\064\000\000\000\
\\001\000\046\000\122\000\068\000\067\000\069\000\066\000\070\000\065\000\000\000\
\\001\000\046\000\172\000\000\000\
\\001\000\046\000\175\000\000\000\
\\001\000\046\000\187\000\000\000\
\\001\000\046\000\241\000\000\000\
\\001\000\046\000\255\000\000\000\
\\001\000\046\000\035\001\000\000\
\\001\000\046\000\043\001\000\000\
\\001\000\046\000\050\001\000\000\
\\001\000\046\000\059\001\000\000\
\\001\000\046\000\065\001\000\000\
\\001\000\046\000\083\001\058\000\082\001\000\000\
\\001\000\046\000\167\001\000\000\
\\001\000\046\000\177\001\000\000\
\\001\000\046\000\215\001\000\000\
\\001\000\046\000\223\001\000\000\
\\001\000\046\000\227\001\000\000\
\\001\000\046\000\230\001\000\000\
\\001\000\046\000\001\002\058\000\082\001\000\000\
\\001\000\046\000\029\002\000\000\
\\001\000\046\000\030\002\000\000\
\\001\000\046\000\036\002\000\000\
\\001\000\046\000\063\002\058\000\082\001\000\000\
\\001\000\046\000\083\002\000\000\
\\001\000\046\000\084\002\000\000\
\\001\000\046\000\089\002\000\000\
\\001\000\046\000\103\002\000\000\
\\001\000\047\000\233\000\000\000\
\\001\000\054\000\003\001\068\000\074\000\000\000\
\\001\000\058\000\087\001\000\000\
\\001\000\058\000\006\002\000\000\
\\001\000\061\000\083\000\062\000\082\000\068\000\081\000\069\000\080\000\
\\070\000\079\000\000\000\
\\001\000\068\000\067\000\069\000\066\000\070\000\065\000\000\000\
\\001\000\068\000\067\000\069\000\066\000\070\000\065\000\073\000\064\000\000\000\
\\001\000\068\000\067\000\069\000\066\000\070\000\065\000\073\000\192\000\000\000\
\\001\000\068\000\071\000\000\000\
\\001\000\068\000\071\000\073\000\118\000\000\000\
\\001\000\068\000\074\000\000\000\
\\001\000\068\000\077\000\000\000\
\\001\000\068\000\150\000\069\000\149\000\000\000\
\\001\000\068\000\150\000\069\000\149\000\073\000\247\000\000\000\
\\001\000\071\000\104\000\000\000\
\\111\002\000\000\
\\112\002\000\000\
\\113\002\000\000\
\\113\002\041\000\248\001\059\000\247\001\000\000\
\\114\002\000\000\
\\115\002\000\000\
\\116\002\000\000\
\\117\002\000\000\
\\118\002\000\000\
\\119\002\000\000\
\\120\002\000\000\
\\121\002\000\000\
\\122\002\000\000\
\\123\002\000\000\
\\124\002\000\000\
\\125\002\000\000\
\\126\002\000\000\
\\127\002\000\000\
\\128\002\000\000\
\\129\002\000\000\
\\130\002\000\000\
\\131\002\000\000\
\\132\002\000\000\
\\133\002\000\000\
\\134\002\000\000\
\\135\002\000\000\
\\136\002\000\000\
\\137\002\000\000\
\\138\002\000\000\
\\139\002\000\000\
\\140\002\000\000\
\\141\002\000\000\
\\142\002\000\000\
\\143\002\000\000\
\\144\002\000\000\
\\145\002\000\000\
\\145\002\041\000\186\000\000\000\
\\146\002\000\000\
\\147\002\000\000\
\\148\002\000\000\
\\149\002\000\000\
\\150\002\000\000\
\\151\002\006\000\048\000\012\000\045\000\015\000\043\000\019\000\040\000\
\\023\000\037\000\026\000\035\000\033\000\032\000\034\000\031\000\
\\035\000\093\000\036\000\030\000\038\000\029\000\049\000\028\000\
\\060\000\024\000\061\000\023\000\062\000\022\000\063\000\021\000\
\\064\000\020\000\065\000\019\000\066\000\018\000\067\000\017\000\000\000\
\\151\002\006\000\048\000\012\000\045\000\015\000\043\000\019\000\040\000\
\\023\000\037\000\026\000\035\000\033\000\032\000\034\000\031\000\
\\036\000\030\000\038\000\029\000\049\000\028\000\060\000\024\000\
\\061\000\023\000\062\000\022\000\063\000\021\000\064\000\020\000\
\\065\000\019\000\066\000\018\000\067\000\017\000\000\000\
\\151\002\008\000\063\001\023\000\037\000\000\000\
\\151\002\023\000\037\000\000\000\
\\151\002\023\000\037\000\027\000\109\000\034\000\108\000\036\000\107\000\
\\038\000\106\000\044\000\105\000\060\000\024\000\061\000\023\000\
\\062\000\022\000\063\000\021\000\064\000\020\000\065\000\019\000\
\\066\000\018\000\067\000\017\000\071\000\104\000\000\000\
\\151\002\023\000\037\000\027\000\109\000\034\000\142\000\036\000\107\000\
\\038\000\106\000\044\000\105\000\060\000\024\000\061\000\023\000\
\\062\000\022\000\063\000\021\000\064\000\020\000\065\000\019\000\
\\066\000\018\000\067\000\017\000\000\000\
\\151\002\023\000\037\000\034\000\108\000\036\000\107\000\038\000\106\000\
\\044\000\105\000\060\000\024\000\061\000\023\000\062\000\022\000\
\\063\000\021\000\064\000\020\000\065\000\019\000\066\000\018\000\
\\067\000\017\000\071\000\104\000\000\000\
\\151\002\023\000\037\000\034\000\142\000\035\000\208\000\036\000\107\000\
\\038\000\106\000\044\000\105\000\060\000\024\000\061\000\023\000\
\\062\000\022\000\063\000\021\000\064\000\020\000\065\000\019\000\
\\066\000\018\000\067\000\017\000\000\000\
\\151\002\023\000\037\000\034\000\142\000\035\000\208\000\036\000\107\000\
\\038\000\106\000\044\000\105\000\060\000\024\000\061\000\023\000\
\\062\000\022\000\063\000\021\000\064\000\020\000\065\000\019\000\
\\066\000\018\000\067\000\017\000\071\000\104\000\000\000\
\\151\002\023\000\037\000\034\000\142\000\036\000\107\000\038\000\106\000\
\\044\000\105\000\060\000\024\000\061\000\023\000\062\000\022\000\
\\063\000\021\000\064\000\020\000\065\000\019\000\066\000\018\000\
\\067\000\017\000\000\000\
\\152\002\000\000\
\\153\002\000\000\
\\154\002\000\000\
\\155\002\000\000\
\\156\002\000\000\
\\157\002\000\000\
\\158\002\000\000\
\\159\002\000\000\
\\160\002\000\000\
\\161\002\000\000\
\\162\002\000\000\
\\164\002\000\000\
\\165\002\004\000\059\000\014\000\058\000\025\000\057\000\040\000\176\000\
\\041\000\056\000\000\000\
\\166\002\000\000\
\\167\002\000\000\
\\168\002\004\000\059\000\014\000\058\000\025\000\057\000\041\000\056\000\
\\042\000\188\001\000\000\
\\169\002\000\000\
\\170\002\004\000\059\000\014\000\058\000\025\000\057\000\041\000\056\000\
\\042\000\178\000\000\000\
\\171\002\000\000\
\\172\002\000\000\
\\173\002\004\000\059\000\014\000\058\000\025\000\057\000\040\000\114\001\
\\041\000\056\000\000\000\
\\174\002\000\000\
\\175\002\061\000\083\000\062\000\082\000\068\000\081\000\069\000\080\000\
\\070\000\079\000\000\000\
\\176\002\000\000\
\\177\002\000\000\
\\179\002\000\000\
\\180\002\000\000\
\\181\002\004\000\059\000\041\000\056\000\000\000\
\\182\002\004\000\059\000\025\000\057\000\041\000\056\000\000\000\
\\183\002\000\000\
\\184\002\004\000\059\000\014\000\058\000\025\000\057\000\041\000\056\000\000\000\
\\185\002\004\000\059\000\014\000\058\000\025\000\057\000\041\000\056\000\000\000\
\\186\002\004\000\059\000\014\000\058\000\025\000\057\000\041\000\056\000\000\000\
\\187\002\000\000\
\\188\002\000\000\
\\189\002\000\000\
\\190\002\000\000\
\\191\002\045\000\235\000\000\000\
\\192\002\004\000\059\000\014\000\058\000\025\000\057\000\041\000\056\000\000\000\
\\193\002\002\000\049\000\008\000\047\000\011\000\046\000\013\000\044\000\
\\017\000\042\000\018\000\041\000\020\000\221\000\021\000\038\000\
\\024\000\036\000\029\000\034\000\030\000\033\000\042\000\220\000\000\000\
\\194\002\002\000\049\000\008\000\047\000\011\000\046\000\013\000\044\000\
\\017\000\042\000\018\000\041\000\020\000\221\000\021\000\038\000\
\\024\000\036\000\029\000\034\000\030\000\033\000\042\000\220\000\000\000\
\\195\002\000\000\
\\196\002\000\000\
\\197\002\002\000\049\000\008\000\047\000\011\000\046\000\013\000\044\000\
\\017\000\042\000\018\000\041\000\020\000\221\000\021\000\038\000\
\\024\000\036\000\029\000\034\000\030\000\033\000\000\000\
\\198\002\000\000\
\\199\002\000\000\
\\200\002\000\000\
\\201\002\000\000\
\\202\002\000\000\
\\203\002\000\000\
\\204\002\000\000\
\\205\002\000\000\
\\206\002\000\000\
\\207\002\000\000\
\\208\002\000\000\
\\209\002\000\000\
\\210\002\000\000\
\\211\002\000\000\
\\212\002\000\000\
\\213\002\000\000\
\\214\002\032\000\239\000\000\000\
\\215\002\000\000\
\\216\002\046\000\122\000\068\000\067\000\069\000\066\000\070\000\065\000\000\000\
\\217\002\000\000\
\\218\002\068\000\071\000\073\000\118\000\000\000\
\\219\002\000\000\
\\220\002\060\000\128\000\061\000\127\000\000\000\
\\221\002\000\000\
\\222\002\000\000\
\\223\002\000\000\
\\224\002\003\000\117\001\004\000\059\000\014\000\058\000\025\000\057\000\
\\041\000\056\000\000\000\
\\225\002\000\000\
\\226\002\000\000\
\\227\002\003\000\232\000\000\000\
\\228\002\000\000\
\\229\002\000\000\
\\230\002\045\000\230\000\000\000\
\\231\002\004\000\059\000\014\000\058\000\025\000\057\000\041\000\056\000\000\000\
\\232\002\000\000\
\\233\002\000\000\
\\234\002\003\000\186\001\000\000\
\\235\002\000\000\
\\236\002\000\000\
\\237\002\000\000\
\\238\002\000\000\
\\239\002\003\000\139\001\000\000\
\\240\002\000\000\
\\241\002\000\000\
\\242\002\045\000\242\001\000\000\
\\243\002\000\000\
\\244\002\022\000\058\001\000\000\
\\244\002\022\000\058\001\046\000\057\001\000\000\
\\245\002\000\000\
\\246\002\000\000\
\\247\002\000\000\
\\248\002\003\000\134\001\000\000\
\\249\002\000\000\
\\249\002\041\000\186\000\000\000\
\\250\002\000\000\
\\251\002\000\000\
\\252\002\000\000\
\\253\002\000\000\
\\254\002\000\000\
\\255\002\000\000\
\\000\003\000\000\
\\001\003\000\000\
\\002\003\000\000\
\\004\003\000\000\
\\005\003\040\000\036\001\000\000\
\\006\003\000\000\
\\007\003\000\000\
\\008\003\000\000\
\\009\003\000\000\
\\010\003\000\000\
\\011\003\040\000\182\001\000\000\
\\012\003\000\000\
\\013\003\041\000\227\000\000\000\
\\014\003\000\000\
\\015\003\005\000\121\001\000\000\
\\016\003\000\000\
\\017\003\043\000\200\000\061\000\083\000\062\000\082\000\068\000\199\000\
\\069\000\198\000\070\000\197\000\000\000\
\\019\003\041\000\186\000\000\000\
\\020\003\000\000\
\\021\003\000\000\
\\022\003\000\000\
\\023\003\000\000\
\\024\003\000\000\
\\025\003\000\000\
\\027\003\000\000\
\\028\003\000\000\
\\029\003\041\000\186\000\000\000\
\\030\003\048\000\249\000\000\000\
\\031\003\000\000\
\\032\003\000\000\
\\033\003\000\000\
\\035\003\000\000\
\\036\003\000\000\
\\037\003\000\000\
\\038\003\000\000\
\\039\003\000\000\
\\040\003\000\000\
\\041\003\000\000\
\\042\003\040\000\200\001\000\000\
\\043\003\000\000\
\\044\003\061\000\083\000\062\000\082\000\068\000\081\000\069\000\080\000\
\\070\000\079\000\000\000\
\\046\003\034\000\165\000\038\000\164\000\071\000\104\000\000\000\
\\047\003\000\000\
\\048\003\000\000\
\\049\003\040\000\072\001\000\000\
\\050\003\000\000\
\\051\003\034\000\113\000\071\000\104\000\000\000\
\\052\003\000\000\
\\053\003\000\000\
\\054\003\000\000\
\\055\003\040\000\042\001\000\000\
\\056\003\000\000\
\\057\003\058\000\082\001\000\000\
\\057\003\058\000\245\001\000\000\
\\057\003\058\000\079\002\000\000\
\\058\003\058\000\082\001\000\000\
\\058\003\058\000\245\001\000\000\
\\058\003\058\000\079\002\000\000\
\\059\003\000\000\
\\060\003\000\000\
\\061\003\000\000\
\\062\003\000\000\
\\063\003\000\000\
\\064\003\002\000\049\000\008\000\047\000\011\000\046\000\013\000\044\000\
\\017\000\042\000\018\000\041\000\020\000\039\000\021\000\038\000\
\\024\000\036\000\029\000\034\000\030\000\033\000\042\000\216\000\
\\057\000\025\000\000\000\
\\065\003\002\000\049\000\008\000\047\000\011\000\046\000\013\000\044\000\
\\017\000\042\000\018\000\041\000\019\000\081\001\020\000\039\000\
\\021\000\038\000\024\000\036\000\029\000\034\000\030\000\033\000\
\\042\000\216\000\056\000\080\001\057\000\025\000\068\000\079\001\
\\073\000\118\000\000\000\
\\065\003\002\000\049\000\008\000\047\000\011\000\046\000\013\000\044\000\
\\017\000\042\000\018\000\041\000\020\000\039\000\021\000\038\000\
\\024\000\036\000\029\000\034\000\030\000\033\000\042\000\216\000\
\\057\000\025\000\000\000\
\\066\003\000\000\
\\067\003\002\000\049\000\008\000\047\000\011\000\046\000\013\000\044\000\
\\017\000\042\000\018\000\041\000\020\000\039\000\021\000\038\000\
\\024\000\036\000\029\000\034\000\030\000\033\000\057\000\025\000\000\000\
\\068\003\000\000\
\\069\003\000\000\
\\070\003\000\000\
\\071\003\000\000\
\\072\003\000\000\
\\073\003\000\000\
\\074\003\000\000\
\\076\003\000\000\
\\077\003\000\000\
\\078\003\000\000\
\\079\003\000\000\
\\080\003\000\000\
\\081\003\000\000\
\\082\003\000\000\
\\083\003\000\000\
\\084\003\058\000\082\001\000\000\
\\085\003\041\000\171\000\059\000\170\000\000\000\
\\085\003\041\000\171\000\059\000\164\001\000\000\
\\085\003\041\000\171\000\059\000\003\002\000\000\
\\086\003\000\000\
\\087\003\000\000\
\\088\003\000\000\
\\089\003\000\000\
\\089\003\068\000\074\000\000\000\
\\090\003\000\000\
\\091\003\000\000\
\\092\003\000\000\
\\094\003\000\000\
\\095\003\000\000\
\\096\003\000\000\
\\097\003\000\000\
\\098\003\000\000\
\\099\003\000\000\
\\100\003\000\000\
\\101\003\003\000\074\002\000\000\
\\102\003\008\000\020\001\011\000\019\001\029\000\018\001\030\000\017\001\
\\050\000\015\001\052\000\014\001\053\000\089\001\057\000\012\001\000\000\
\\103\003\008\000\020\001\011\000\019\001\029\000\018\001\030\000\017\001\
\\042\000\016\001\050\000\015\001\052\000\014\001\053\000\013\001\
\\057\000\012\001\000\000\
\\103\003\008\000\020\001\011\000\019\001\029\000\018\001\030\000\017\001\
\\042\000\016\001\050\000\015\001\052\000\014\001\053\000\013\001\
\\057\000\012\001\068\000\071\000\000\000\
\\104\003\000\000\
\\105\003\000\000\
\\106\003\000\000\
\\107\003\000\000\
\\108\003\000\000\
\\109\003\000\000\
\\110\003\000\000\
\\111\003\000\000\
\\112\003\000\000\
\\113\003\000\000\
\\114\003\000\000\
\\115\003\000\000\
\\116\003\000\000\
\\117\003\000\000\
\\118\003\000\000\
\\119\003\000\000\
\\120\003\058\000\082\001\000\000\
\\121\003\000\000\
\\122\003\000\000\
\\123\003\068\000\074\000\000\000\
\\124\003\000\000\
\\125\003\046\000\042\002\000\000\
\\126\003\000\000\
\\127\003\000\000\
\\128\003\046\000\007\002\000\000\
\\129\003\000\000\
\\130\003\000\000\
\\131\003\000\000\
\\132\003\003\000\012\002\000\000\
\\133\003\000\000\
\\134\003\000\000\
\\135\003\003\000\225\001\000\000\
\\135\003\003\000\225\001\046\000\227\001\000\000\
\\136\003\000\000\
\\137\003\000\000\
\\138\003\003\000\045\002\000\000\
\\139\003\000\000\
\\140\003\000\000\
\\141\003\000\000\
\\142\003\000\000\
\\143\003\003\000\017\002\000\000\
\\144\003\000\000\
\\145\003\000\000\
\\146\003\045\000\050\002\000\000\
\\147\003\000\000\
\\148\003\000\000\
\\149\003\003\000\229\001\000\000\
\\150\003\000\000\
\\151\003\000\000\
\\153\003\000\000\
\\154\003\000\000\
\\155\003\000\000\
\\156\003\000\000\
\\157\003\000\000\
\\158\003\000\000\
\\159\003\000\000\
\\160\003\000\000\
\\161\003\000\000\
\\162\003\000\000\
\\163\003\000\000\
\\165\003\000\000\
\\166\003\000\000\
\\167\003\000\000\
\\168\003\000\000\
\\169\003\000\000\
\\170\003\000\000\
\\171\003\000\000\
\\172\003\000\000\
\\173\003\000\000\
\\175\003\000\000\
\\176\003\000\000\
\\177\003\000\000\
\\178\003\000\000\
\\179\003\002\000\049\000\008\000\047\000\011\000\046\000\013\000\044\000\
\\017\000\042\000\018\000\041\000\020\000\039\000\021\000\038\000\
\\024\000\036\000\029\000\034\000\030\000\033\000\051\000\027\000\
\\055\000\026\000\057\000\025\000\000\000\
\\180\003\000\000\
\\181\003\000\000\
\\182\003\000\000\
\\183\003\000\000\
\"
val actionRowNumbers =
"\127\000\013\000\207\001\201\001\
\\082\000\206\001\206\001\206\001\
\\096\001\021\000\204\000\003\000\
\\202\000\084\000\179\000\139\000\
\\138\000\140\000\137\000\136\000\
\\135\000\134\000\133\000\120\000\
\\122\000\123\000\116\000\201\000\
\\028\000\169\000\170\000\173\000\
\\073\001\170\000\121\000\168\000\
\\085\000\128\000\128\000\245\000\
\\245\000\170\000\175\000\178\000\
\\172\000\057\000\170\000\073\001\
\\001\000\204\001\205\001\203\001\
\\202\001\001\000\068\001\170\000\
\\178\000\170\000\203\000\159\000\
\\180\000\161\000\162\000\152\000\
\\151\000\150\000\160\000\097\001\
\\111\001\156\000\119\001\086\000\
\\157\000\187\001\058\000\158\000\
\\182\000\145\000\144\000\143\000\
\\147\000\146\000\073\000\200\000\
\\087\000\191\000\189\000\071\000\
\\020\000\060\000\061\000\183\000\
\\016\000\174\000\044\001\088\000\
\\020\001\042\000\224\000\119\000\
\\074\001\023\001\155\000\022\001\
\\043\001\044\000\177\000\174\000\
\\072\001\124\000\228\000\126\000\
\\209\000\234\000\243\000\166\000\
\\167\000\237\000\148\000\241\000\
\\149\000\092\001\219\000\085\000\
\\244\000\142\000\141\000\085\000\
\\019\000\178\000\039\001\019\001\
\\043\000\255\000\252\000\226\000\
\\118\000\112\000\216\000\213\000\
\\176\000\233\000\117\000\124\000\
\\239\000\239\000\089\000\154\000\
\\153\000\018\000\124\000\239\000\
\\208\001\210\001\209\001\125\000\
\\058\001\004\000\056\001\054\001\
\\205\000\060\001\067\001\068\001\
\\207\000\208\000\206\000\090\000\
\\113\000\113\000\113\000\132\001\
\\181\000\170\000\170\000\185\000\
\\170\000\170\000\188\000\186\000\
\\184\000\170\000\225\000\046\001\
\\068\001\170\000\045\001\051\001\
\\021\001\026\000\163\000\074\000\
\\042\001\039\001\091\000\024\000\
\\023\000\022\000\033\001\031\001\
\\029\001\072\000\062\000\063\000\
\\064\000\077\001\025\001\247\000\
\\092\000\242\000\240\000\093\001\
\\090\001\037\000\095\001\220\000\
\\218\000\038\000\223\000\128\000\
\\236\000\235\000\170\000\227\000\
\\093\000\068\001\050\001\253\000\
\\178\000\250\000\178\000\170\000\
\\214\000\178\000\014\001\094\000\
\\230\000\073\001\229\000\171\000\
\\178\000\095\000\056\000\059\001\
\\164\000\165\000\068\001\068\001\
\\075\000\066\001\076\000\065\000\
\\066\000\041\000\114\001\096\000\
\\117\001\131\001\110\001\120\001\
\\008\000\114\000\133\001\130\001\
\\067\000\077\000\120\000\045\000\
\\113\000\073\001\135\001\117\000\
\\073\001\117\000\057\000\199\000\
\\190\000\196\000\195\000\192\000\
\\211\000\053\001\249\000\047\001\
\\027\000\068\001\048\001\024\001\
\\041\001\178\000\178\000\027\001\
\\075\001\178\000\028\001\026\001\
\\126\000\068\001\094\001\131\000\
\\222\000\170\000\219\000\017\000\
\\170\000\038\001\254\000\251\000\
\\217\000\215\000\018\001\172\000\
\\068\001\172\000\238\000\008\001\
\\117\000\125\000\212\000\172\000\
\\219\000\057\001\055\001\061\001\
\\068\001\069\001\068\001\062\001\
\\099\001\005\000\078\000\086\001\
\\059\000\002\000\128\000\128\000\
\\046\000\041\000\030\000\122\001\
\\122\000\047\000\134\001\049\000\
\\112\001\113\000\148\001\079\000\
\\138\001\097\000\125\000\150\001\
\\149\001\118\001\142\001\124\000\
\\140\001\080\000\143\001\141\001\
\\124\000\147\001\013\001\145\001\
\\144\001\124\000\098\000\197\000\
\\116\000\052\001\246\000\174\000\
\\178\000\025\000\037\001\178\000\
\\037\001\030\001\032\001\076\001\
\\003\001\092\001\194\000\129\000\
\\039\000\170\000\000\001\015\001\
\\172\000\084\000\012\001\008\001\
\\005\001\073\001\013\001\231\000\
\\008\001\031\000\065\001\070\001\
\\071\001\102\001\120\000\113\000\
\\113\000\091\001\092\001\092\001\
\\115\001\073\001\100\001\116\001\
\\121\001\123\001\073\001\139\001\
\\125\000\099\000\113\000\068\000\
\\113\000\121\000\136\001\100\000\
\\151\001\152\001\164\001\068\001\
\\165\001\179\001\102\000\029\000\
\\198\000\248\000\049\001\035\001\
\\083\000\040\001\034\001\001\001\
\\073\001\132\000\170\000\032\000\
\\131\000\210\000\017\001\018\001\
\\006\001\007\001\011\001\004\001\
\\232\000\063\001\116\000\101\001\
\\006\000\083\001\104\001\080\001\
\\103\001\069\000\078\001\070\000\
\\129\000\040\000\125\000\125\000\
\\137\001\041\000\103\000\113\001\
\\180\001\014\000\115\000\158\001\
\\157\001\125\000\162\001\073\001\
\\161\001\068\001\177\001\117\000\
\\117\000\173\001\013\001\125\000\
\\036\001\002\001\033\000\193\000\
\\187\000\219\000\016\001\009\001\
\\172\000\064\001\105\001\050\000\
\\088\001\113\000\113\000\087\001\
\\034\000\041\000\104\000\105\000\
\\190\001\010\000\081\000\041\000\
\\106\000\113\000\182\001\120\000\
\\052\000\121\000\155\001\154\001\
\\163\001\159\001\117\000\168\001\
\\178\001\173\001\170\001\073\001\
\\176\001\146\001\098\001\132\000\
\\010\001\106\001\073\001\082\001\
\\079\001\085\001\130\000\068\001\
\\068\001\193\001\123\000\113\000\
\\113\000\191\001\041\000\107\000\
\\181\001\183\001\073\001\156\001\
\\125\000\160\001\166\001\073\001\
\\171\001\172\001\124\000\174\001\
\\117\000\035\000\125\000\036\000\
\\129\001\009\000\192\001\195\001\
\\011\000\084\001\194\001\081\001\
\\188\001\041\000\125\000\153\001\
\\167\001\124\000\108\000\175\001\
\\221\000\109\000\089\001\127\001\
\\046\000\124\001\125\001\048\000\
\\196\001\054\000\189\001\110\000\
\\101\000\117\000\068\001\128\001\
\\126\001\197\001\073\001\068\001\
\\173\001\007\000\125\000\015\000\
\\169\001\107\001\108\001\051\000\
\\111\000\184\001\185\001\053\000\
\\109\001\068\001\186\001\012\000\
\\198\001\199\001\055\000\200\001\
\\000\000"
val gotoT =
"\
\\142\000\108\002\145\000\001\000\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\025\000\011\000\
\\026\000\010\000\027\000\009\000\033\000\008\000\087\000\007\000\
\\097\000\006\000\132\000\005\000\139\000\004\000\140\000\003\000\
\\143\000\002\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\033\000\008\000\087\000\007\000\097\000\006\000\132\000\005\000\
\\140\000\050\000\141\000\049\000\000\000\
\\033\000\008\000\087\000\007\000\097\000\006\000\132\000\005\000\
\\140\000\050\000\141\000\051\000\000\000\
\\033\000\008\000\087\000\007\000\097\000\006\000\132\000\005\000\
\\140\000\050\000\141\000\052\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\001\000\014\000\015\000\013\000\016\000\058\000\000\000\
\\000\000\
\\005\000\061\000\011\000\060\000\012\000\059\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\008\000\068\000\088\000\067\000\000\000\
\\009\000\071\000\098\000\070\000\000\000\
\\010\000\074\000\133\000\073\000\000\000\
\\003\000\076\000\000\000\
\\003\000\084\000\022\000\083\000\023\000\082\000\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\017\000\087\000\
\\018\000\086\000\025\000\011\000\026\000\010\000\027\000\085\000\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\019\000\090\000\
\\021\000\089\000\025\000\011\000\026\000\010\000\027\000\088\000\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\025\000\011\000\
\\026\000\010\000\027\000\092\000\000\000\
\\001\000\101\000\007\000\100\000\015\000\099\000\038\000\098\000\
\\056\000\097\000\057\000\096\000\066\000\095\000\068\000\094\000\
\\081\000\093\000\000\000\
\\007\000\100\000\045\000\110\000\080\000\109\000\081\000\108\000\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\025\000\011\000\
\\026\000\010\000\027\000\112\000\000\000\
\\008\000\115\000\014\000\114\000\036\000\113\000\000\000\
\\000\000\
\\004\000\119\000\005\000\118\000\035\000\117\000\000\000\
\\146\000\121\000\000\000\
\\146\000\122\000\000\000\
\\002\000\124\000\037\000\123\000\000\000\
\\002\000\124\000\037\000\127\000\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\025\000\011\000\
\\026\000\010\000\027\000\128\000\000\000\
\\001\000\101\000\007\000\100\000\015\000\136\000\040\000\135\000\
\\042\000\134\000\044\000\133\000\056\000\132\000\057\000\131\000\
\\067\000\130\000\081\000\129\000\000\000\
\\001\000\101\000\015\000\099\000\028\000\139\000\030\000\138\000\
\\056\000\097\000\057\000\096\000\066\000\137\000\068\000\094\000\000\000\
\\015\000\142\000\054\000\141\000\000\000\
\\006\000\146\000\007\000\100\000\048\000\145\000\049\000\144\000\
\\081\000\143\000\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\025\000\011\000\
\\026\000\010\000\027\000\149\000\000\000\
\\007\000\100\000\047\000\151\000\080\000\150\000\081\000\108\000\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\025\000\011\000\
\\026\000\010\000\027\000\009\000\033\000\008\000\087\000\007\000\
\\097\000\006\000\132\000\005\000\139\000\004\000\140\000\003\000\
\\143\000\153\000\144\000\152\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\025\000\011\000\
\\026\000\010\000\027\000\009\000\033\000\008\000\087\000\007\000\
\\097\000\006\000\132\000\005\000\139\000\004\000\140\000\003\000\
\\143\000\153\000\144\000\154\000\000\000\
\\007\000\161\000\070\000\160\000\071\000\159\000\072\000\158\000\
\\073\000\157\000\074\000\156\000\078\000\155\000\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\025\000\011\000\
\\026\000\010\000\027\000\164\000\000\000\
\\001\000\101\000\015\000\099\000\028\000\165\000\030\000\138\000\
\\056\000\097\000\057\000\096\000\066\000\137\000\068\000\094\000\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\025\000\011\000\
\\026\000\010\000\027\000\166\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\094\000\167\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\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\001\000\101\000\015\000\099\000\038\000\182\000\056\000\097\000\
\\057\000\096\000\066\000\095\000\068\000\094\000\000\000\
\\069\000\183\000\000\000\
\\000\000\
\\069\000\186\000\000\000\
\\001\000\101\000\015\000\136\000\056\000\132\000\057\000\131\000\
\\067\000\187\000\000\000\
\\000\000\
\\005\000\189\000\012\000\188\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\003\000\194\000\005\000\193\000\061\000\192\000\062\000\191\000\000\000\
\\001\000\101\000\015\000\099\000\056\000\097\000\057\000\096\000\
\\058\000\201\000\059\000\200\000\066\000\199\000\068\000\094\000\000\000\
\\001\000\101\000\007\000\205\000\015\000\099\000\056\000\097\000\
\\057\000\096\000\060\000\204\000\066\000\203\000\068\000\094\000\
\\082\000\202\000\000\000\
\\001\000\101\000\015\000\099\000\038\000\207\000\056\000\097\000\
\\057\000\096\000\066\000\095\000\068\000\094\000\000\000\
\\000\000\
\\006\000\208\000\000\000\
\\000\000\
\\007\000\205\000\082\000\202\000\000\000\
\\000\000\
\\000\000\
\\008\000\115\000\014\000\114\000\036\000\209\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\004\000\119\000\005\000\118\000\035\000\210\000\000\000\
\\000\000\
\\033\000\008\000\085\000\213\000\086\000\212\000\087\000\211\000\000\000\
\\031\000\217\000\032\000\216\000\033\000\215\000\000\000\
\\004\000\119\000\005\000\118\000\035\000\220\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\004\000\119\000\005\000\118\000\035\000\221\000\000\000\
\\000\000\
\\001\000\101\000\015\000\136\000\040\000\223\000\042\000\134\000\
\\044\000\133\000\056\000\132\000\057\000\131\000\067\000\130\000\000\000\
\\064\000\224\000\000\000\
\\000\000\
\\001\000\101\000\015\000\136\000\056\000\132\000\057\000\131\000\
\\067\000\226\000\000\000\
\\043\000\227\000\000\000\
\\041\000\229\000\000\000\
\\000\000\
\\005\000\061\000\012\000\188\000\000\000\
\\000\000\
\\029\000\232\000\000\000\
\\000\000\
\\001\000\101\000\015\000\099\000\056\000\097\000\057\000\096\000\
\\060\000\204\000\066\000\203\000\068\000\094\000\000\000\
\\000\000\
\\005\000\234\000\000\000\
\\006\000\235\000\000\000\
\\034\000\236\000\000\000\
\\034\000\238\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\006\000\241\000\000\000\
\\034\000\242\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\006\000\244\000\013\000\243\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\003\000\250\000\075\000\249\000\076\000\248\000\000\000\
\\007\000\161\000\070\000\252\000\071\000\159\000\072\000\158\000\
\\073\000\157\000\074\000\156\000\078\000\155\000\079\000\251\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\009\000\000\001\095\000\255\000\096\000\254\000\000\000\
\\009\000\000\001\095\000\002\001\096\000\254\000\000\000\
\\009\000\000\001\095\000\005\001\096\000\004\001\100\000\003\001\000\000\
\\008\000\009\001\105\000\008\001\106\000\007\001\107\000\006\001\000\000\
\\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\025\000\011\000\
\\026\000\010\000\027\000\019\001\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\018\000\020\001\
\\025\000\011\000\026\000\010\000\027\000\085\000\000\000\
\\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\021\000\022\001\
\\025\000\011\000\026\000\010\000\027\000\021\001\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\018\000\023\001\
\\025\000\011\000\026\000\010\000\027\000\085\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\025\000\011\000\
\\026\000\010\000\027\000\024\001\000\000\
\\000\000\
\\000\000\
\\007\000\161\000\070\000\025\001\071\000\159\000\072\000\158\000\
\\073\000\157\000\074\000\156\000\078\000\155\000\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\025\000\011\000\
\\026\000\010\000\027\000\026\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\064\000\028\001\069\000\027\001\000\000\
\\069\000\030\001\000\000\
\\000\000\
\\000\000\
\\064\000\032\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\
\\033\000\008\000\086\000\042\001\087\000\211\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\032\000\044\001\033\000\215\000\000\000\
\\000\000\
\\000\000\
\\146\000\046\001\000\000\
\\000\000\
\\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\025\000\011\000\
\\026\000\010\000\027\000\047\001\000\000\
\\000\000\
\\000\000\
\\007\000\161\000\070\000\049\001\071\000\159\000\072\000\158\000\
\\073\000\157\000\074\000\156\000\078\000\155\000\000\000\
\\000\000\
\\000\000\
\\001\000\101\000\015\000\136\000\042\000\050\001\044\000\133\000\
\\056\000\132\000\057\000\131\000\067\000\130\000\000\000\
\\000\000\
\\001\000\101\000\015\000\136\000\040\000\051\001\042\000\134\000\
\\044\000\133\000\056\000\132\000\057\000\131\000\067\000\130\000\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\025\000\011\000\
\\026\000\010\000\027\000\052\001\000\000\
\\000\000\
\\001\000\101\000\015\000\099\000\028\000\053\001\030\000\138\000\
\\056\000\097\000\057\000\096\000\066\000\137\000\068\000\094\000\000\000\
\\053\000\054\001\000\000\
\\000\000\
\\000\000\
\\007\000\100\000\045\000\058\001\080\000\109\000\081\000\108\000\000\000\
\\000\000\
\\015\000\060\001\051\000\059\001\000\000\
\\001\000\101\000\015\000\099\000\028\000\062\001\030\000\138\000\
\\056\000\097\000\057\000\096\000\066\000\137\000\068\000\094\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\007\000\161\000\072\000\065\001\073\000\157\000\074\000\156\000\
\\078\000\155\000\000\000\
\\007\000\161\000\070\000\066\001\071\000\159\000\072\000\158\000\
\\073\000\157\000\074\000\156\000\078\000\155\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\008\000\115\000\010\000\076\001\014\000\075\001\083\000\074\001\
\\084\000\073\001\090\000\072\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\105\000\082\001\106\000\007\001\107\000\006\001\000\000\
\\000\000\
\\000\000\
\\099\000\083\001\000\000\
\\000\000\
\\000\000\
\\107\000\086\001\000\000\
\\000\000\
\\000\000\
\\008\000\091\001\127\000\090\001\000\000\
\\008\000\115\000\014\000\093\001\112\000\092\001\000\000\
\\009\000\097\001\095\000\096\001\096\000\254\000\108\000\095\001\000\000\
\\007\000\100\000\080\000\099\001\081\000\108\000\115\000\098\001\000\000\
\\000\000\
\\005\000\101\001\113\000\100\001\000\000\
\\007\000\100\000\080\000\104\001\081\000\108\000\115\000\103\001\
\\117\000\102\001\000\000\
\\005\000\106\001\125\000\105\001\000\000\
\\006\000\110\001\007\000\100\000\081\000\109\001\120\000\108\001\
\\121\000\107\001\000\000\
\\024\000\111\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\069\000\113\001\000\000\
\\039\000\114\001\000\000\
\\000\000\
\\000\000\
\\007\000\161\000\070\000\117\001\071\000\159\000\072\000\158\000\
\\073\000\157\000\074\000\156\000\078\000\155\000\000\000\
\\000\000\
\\000\000\
\\065\000\118\001\000\000\
\\001\000\101\000\015\000\099\000\056\000\097\000\057\000\096\000\
\\066\000\120\001\068\000\094\000\000\000\
\\001\000\101\000\015\000\099\000\056\000\097\000\057\000\096\000\
\\059\000\121\001\066\000\199\000\068\000\094\000\000\000\
\\000\000\
\\000\000\
\\001\000\101\000\015\000\099\000\056\000\097\000\057\000\096\000\
\\059\000\122\001\066\000\199\000\068\000\094\000\000\000\
\\000\000\
\\000\000\
\\007\000\205\000\082\000\123\001\000\000\
\\007\000\161\000\070\000\124\001\071\000\159\000\072\000\158\000\
\\073\000\157\000\074\000\156\000\078\000\155\000\000\000\
\\033\000\008\000\086\000\042\001\087\000\211\000\000\000\
\\148\000\125\001\000\000\
\\032\000\044\001\033\000\215\000\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\020\000\127\001\
\\025\000\011\000\026\000\010\000\027\000\126\001\000\000\
\\031\000\128\001\032\000\216\000\033\000\215\000\000\000\
\\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\025\000\011\000\
\\026\000\010\000\027\000\130\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\055\000\131\001\000\000\
\\015\000\133\001\000\000\
\\007\000\161\000\070\000\134\001\071\000\159\000\072\000\158\000\
\\073\000\157\000\074\000\156\000\078\000\155\000\000\000\
\\015\000\060\001\051\000\135\001\000\000\
\\000\000\
\\050\000\136\001\000\000\
\\005\000\138\001\000\000\
\\006\000\244\000\013\000\139\001\000\000\
\\000\000\
\\015\000\060\001\051\000\140\001\000\000\
\\031\000\141\001\032\000\216\000\033\000\215\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\007\000\161\000\070\000\142\001\071\000\159\000\072\000\158\000\
\\073\000\157\000\074\000\156\000\078\000\155\000\000\000\
\\000\000\
\\007\000\161\000\070\000\144\001\071\000\159\000\072\000\158\000\
\\073\000\157\000\074\000\156\000\078\000\155\000\079\000\143\001\000\000\
\\000\000\
\\000\000\
\\089\000\145\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\146\000\150\001\000\000\
\\146\000\151\001\000\000\
\\103\000\152\001\000\000\
\\008\000\115\000\010\000\076\001\014\000\075\001\083\000\074\001\
\\084\000\073\001\090\000\154\001\000\000\
\\000\000\
\\000\000\
\\009\000\071\000\098\000\156\001\000\000\
\\101\000\157\001\103\000\152\001\000\000\
\\000\000\
\\008\000\115\000\014\000\093\001\112\000\159\001\000\000\
\\094\000\161\001\000\000\
\\009\000\000\001\095\000\163\001\096\000\254\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\006\000\244\000\013\000\167\001\110\000\166\001\000\000\
\\000\000\
\\000\000\
\\009\000\169\001\108\000\168\001\000\000\
\\000\000\
\\006\000\170\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\006\000\172\001\000\000\
\\000\000\
\\053\000\173\001\000\000\
\\000\000\
\\000\000\
\\006\000\174\001\000\000\
\\000\000\
\\000\000\
\\003\000\084\000\022\000\176\001\000\000\
\\000\000\
\\000\000\
\\001\000\101\000\015\000\099\000\038\000\177\001\056\000\097\000\
\\057\000\096\000\066\000\095\000\068\000\094\000\000\000\
\\001\000\101\000\015\000\099\000\056\000\097\000\057\000\096\000\
\\066\000\178\001\068\000\094\000\000\000\
\\069\000\113\001\000\000\
\\063\000\179\001\000\000\
\\001\000\101\000\015\000\099\000\056\000\097\000\057\000\096\000\
\\066\000\181\001\068\000\094\000\000\000\
\\063\000\182\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\046\000\183\001\000\000\
\\033\000\008\000\085\000\185\001\086\000\212\000\087\000\211\000\000\000\
\\000\000\
\\147\000\187\001\000\000\
\\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\025\000\011\000\
\\026\000\010\000\027\000\189\001\000\000\
\\000\000\
\\000\000\
\\015\000\142\000\054\000\190\001\000\000\
\\005\000\061\000\011\000\191\001\012\000\059\000\000\000\
\\000\000\
\\050\000\192\001\000\000\
\\000\000\
\\007\000\100\000\047\000\193\001\080\000\150\000\081\000\108\000\000\000\
\\053\000\194\001\000\000\
\\000\000\
\\050\000\195\001\000\000\
\\000\000\
\\077\000\197\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\008\000\068\000\088\000\199\001\000\000\
\\009\000\000\001\091\000\202\001\095\000\201\001\096\000\200\001\000\000\
\\009\000\000\001\091\000\204\001\095\000\203\001\096\000\200\001\000\000\
\\008\000\115\000\010\000\076\001\014\000\075\001\033\000\008\000\
\\083\000\207\001\084\000\206\001\085\000\205\001\086\000\212\000\
\\087\000\211\000\000\000\
\\033\000\008\000\085\000\208\001\086\000\212\000\087\000\211\000\000\000\
\\033\000\008\000\085\000\209\001\086\000\212\000\087\000\211\000\000\000\
\\000\000\
\\007\000\100\000\080\000\210\001\081\000\108\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\007\000\100\000\080\000\211\001\081\000\108\000\000\000\
\\000\000\
\\006\000\244\000\013\000\167\001\110\000\212\001\000\000\
\\000\000\
\\009\000\000\001\095\000\214\001\096\000\254\000\000\000\
\\000\000\
\\009\000\000\001\095\000\218\001\096\000\217\001\129\000\216\001\000\000\
\\008\000\115\000\014\000\220\001\111\000\219\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\009\000\169\001\108\000\168\001\000\000\
\\116\000\222\001\000\000\
\\007\000\161\000\070\000\224\001\071\000\159\000\072\000\158\000\
\\073\000\157\000\074\000\156\000\078\000\155\000\000\000\
\\116\000\222\001\000\000\
\\126\000\226\001\000\000\
\\000\000\
\\005\000\230\001\123\000\229\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\003\000\194\000\005\000\193\000\061\000\232\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\007\000\100\000\045\000\233\001\080\000\109\000\081\000\108\000\000\000\
\\149\000\234\001\000\000\
\\001\000\014\000\015\000\013\000\016\000\012\000\020\000\235\001\
\\025\000\011\000\026\000\010\000\027\000\126\001\000\000\
\\000\000\
\\148\000\237\001\000\000\
\\000\000\
\\000\000\
\\055\000\238\001\000\000\
\\000\000\
\\000\000\
\\052\000\239\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\003\000\250\000\075\000\241\001\000\000\
\\000\000\
\\089\000\242\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\147\000\248\001\000\000\
\\000\000\
\\006\000\244\000\013\000\250\001\000\000\
\\006\000\244\000\013\000\251\001\000\000\
\\000\000\
\\008\000\115\000\010\000\076\001\014\000\075\001\083\000\254\001\
\\084\000\253\001\135\000\252\001\000\000\
\\000\000\
\\094\000\000\002\000\000\
\\000\000\
\\128\000\002\002\000\000\
\\000\000\
\\000\000\
\\000\000\
\\006\000\244\000\013\000\007\002\109\000\006\002\000\000\
\\000\000\
\\007\000\100\000\080\000\099\001\081\000\108\000\115\000\008\002\000\000\
\\114\000\009\002\000\000\
\\007\000\161\000\070\000\011\002\071\000\159\000\072\000\158\000\
\\073\000\157\000\074\000\156\000\078\000\155\000\000\000\
\\000\000\
\\005\000\106\001\125\000\012\002\000\000\
\\005\000\230\001\123\000\013\002\000\000\
\\122\000\014\002\000\000\
\\053\000\016\002\000\000\
\\006\000\244\000\013\000\017\002\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\031\000\019\002\032\000\216\000\033\000\215\000\000\000\
\\000\000\
\\000\000\
\\015\000\060\001\051\000\020\002\000\000\
\\000\000\
\\000\000\
\\092\000\021\002\103\000\152\001\000\000\
\\000\000\
\\009\000\000\001\095\000\023\002\096\000\254\000\000\000\
\\009\000\000\001\095\000\024\002\096\000\254\000\000\000\
\\000\000\
\\000\000\
\\008\000\115\000\010\000\076\001\014\000\075\001\083\000\026\002\
\\084\000\206\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\134\000\029\002\000\000\
\\000\000\
\\008\000\115\000\010\000\076\001\014\000\075\001\083\000\254\001\
\\084\000\253\001\135\000\033\002\000\000\
\\000\000\
\\009\000\000\001\095\000\035\002\096\000\254\000\000\000\
\\000\000\
\\008\000\091\001\127\000\036\002\000\000\
\\103\000\152\001\130\000\037\002\000\000\
\\008\000\115\000\014\000\220\001\111\000\039\002\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\005\000\101\001\113\000\041\002\000\000\
\\118\000\042\002\000\000\
\\000\000\
\\122\000\044\002\000\000\
\\000\000\
\\007\000\100\000\080\000\046\002\081\000\108\000\119\000\045\002\000\000\
\\124\000\047\002\000\000\
\\000\000\
\\000\000\
\\149\000\049\002\000\000\
\\000\000\
\\000\000\
\\007\000\100\000\080\000\050\002\081\000\108\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\147\000\051\002\000\000\
\\007\000\161\000\070\000\052\002\071\000\159\000\072\000\158\000\
\\073\000\157\000\074\000\156\000\078\000\155\000\000\000\
\\007\000\161\000\070\000\053\002\071\000\159\000\072\000\158\000\
\\073\000\157\000\074\000\156\000\078\000\155\000\000\000\
\\000\000\
\\010\000\074\000\133\000\054\002\000\000\
\\009\000\000\001\095\000\057\002\096\000\056\002\136\000\055\002\000\000\
\\009\000\000\001\095\000\059\002\096\000\056\002\136\000\058\002\000\000\
\\000\000\
\\008\000\115\000\010\000\076\001\014\000\075\001\083\000\254\001\
\\084\000\253\001\135\000\060\002\000\000\
\\000\000\
\\000\000\
\\000\000\
\\007\000\100\000\080\000\062\002\081\000\108\000\000\000\
\\000\000\
\\006\000\244\000\013\000\007\002\109\000\063\002\000\000\
\\000\000\
\\000\000\
\\007\000\100\000\080\000\065\002\081\000\108\000\117\000\064\002\000\000\
\\000\000\
\\000\000\
\\006\000\066\002\000\000\
\\000\000\
\\005\000\230\001\123\000\067\002\000\000\
\\000\000\
\\006\000\244\000\013\000\069\002\000\000\
\\000\000\
\\104\000\071\002\000\000\
\\099\000\074\002\102\000\073\002\104\000\071\002\000\000\
\\000\000\
\\000\000\
\\134\000\076\002\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\008\000\115\000\010\000\076\001\014\000\075\001\083\000\254\001\
\\084\000\253\001\135\000\078\002\000\000\
\\006\000\244\000\013\000\079\002\000\000\
\\000\000\
\\000\000\
\\006\000\080\002\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\103\000\083\002\000\000\
\\000\000\
\\000\000\
\\009\000\071\000\098\000\156\001\101\000\084\002\103\000\083\002\000\000\
\\000\000\
\\103\000\152\001\137\000\085\002\000\000\
\\000\000\
\\000\000\
\\000\000\
\\005\000\230\001\123\000\088\002\000\000\
\\007\000\161\000\070\000\089\002\071\000\159\000\072\000\158\000\
\\073\000\157\000\074\000\156\000\078\000\155\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\007\000\100\000\080\000\090\002\081\000\108\000\000\000\
\\007\000\161\000\070\000\091\002\071\000\159\000\072\000\158\000\
\\073\000\157\000\074\000\156\000\078\000\155\000\000\000\
\\122\000\092\002\000\000\
\\089\000\094\002\093\000\093\002\104\000\071\002\000\000\
\\006\000\244\000\013\000\096\002\000\000\
\\104\000\071\002\128\000\098\002\131\000\097\002\000\000\
\\000\000\
\\000\000\
\\000\000\
\\008\000\068\000\088\000\199\001\092\000\100\002\103\000\083\002\000\000\
\\000\000\
\\000\000\
\\000\000\
\\008\000\091\001\103\000\083\002\127\000\036\002\130\000\102\002\000\000\
\\000\000\
\\007\000\161\000\070\000\103\002\071\000\159\000\072\000\158\000\
\\073\000\157\000\074\000\156\000\078\000\155\000\000\000\
\\000\000\
\\104\000\071\002\134\000\105\002\138\000\104\002\000\000\
\\000\000\
\\000\000\
\\010\000\074\000\103\000\083\002\133\000\054\002\137\000\107\002\000\000\
\\000\000\
\\000\000\
\"
val numstates = 621
val numrules = 330
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 = int
type arg = Infix.InfEnv
structure MlyValue = 
struct
datatype svalue = VOID | ntVOID of unit ->  unit
 | LONGID of unit ->  (string list*string)
 | ETYVAR of unit ->  (string) | TYVAR of unit ->  (string)
 | SYMBOL of unit ->  (string) | ALPHA of unit ->  (string)
 | CHAR of unit ->  (char) | STRING of unit ->  (string)
 | REAL of unit ->  (real) | WORD of unit ->  (word)
 | INT of unit ->  (int) | NUMERIC of unit ->  (int)
 | DIGIT of unit ->  (int) | popLocalInfix of unit ->  (unit)
 | pushLocalInfix of unit ->  (unit) | popInfix of unit ->  (unit)
 | pushInfix of unit ->  (unit) | initInfix of unit ->  (unit)
 | program_opt of unit ->  (Program option)
 | program' of unit ->  (Program)
 | program of unit ->  (Program*Infix.InfEnv)
 | topdec_opt of unit ->  (TopDec option)
 | topdec1 of unit ->  (TopDec) | topdec of unit ->  (TopDec)
 | AND_tyreadesc_opt__AND_funbind_opt of unit ->  (TyReaDesc option*FunBind option)
 | tyreadesc__AND_funbind_opt of unit ->  (TyReaDesc*FunBind option)
 | sigexp__AND_funbind_opt of unit ->  (SigExp*FunBind option)
 | strexp__AND_funbind_opt of unit ->  (StrExp*FunBind option)
 | AND_funbind_opt of unit ->  (FunBind option)
 | funbind of unit ->  (FunBind) | fundec of unit ->  (FunDec)
 | AND_tyreadesc_opt__AND_strdesc_opt of unit ->  (TyReaDesc option*StrDesc option)
 | tyreadesc__AND_strdesc_opt of unit ->  (TyReaDesc*StrDesc option)
 | sigexp__AND_strdesc_opt of unit ->  (SigExp*StrDesc option)
 | AND_strdesc_opt of unit ->  (StrDesc option)
 | strdesc of unit ->  (StrDesc)
 | AND_exdesc_opt of unit ->  (ExDesc option)
 | exdesc of unit ->  (ExDesc)
 | BAR_condesc_opt of unit ->  (ConDesc option)
 | condesc of unit ->  (ConDesc)
 | AND_datdesc_opt of unit ->  (DatDesc option)
 | datdesc1 of unit ->  (DatDesc) | datdesc0 of unit ->  (DatDesc)
 | datdesc of unit ->  (DatDesc)
 | AND_syndesc_opt of unit ->  (SynDesc option)
 | syndesc of unit ->  (SynDesc)
 | AND_typdesc_opt of unit ->  (TypDesc option)
 | typdesc of unit ->  (TypDesc)
 | AND_valdesc_opt of unit ->  (ValDesc option)
 | valdesc of unit ->  (ValDesc)
 | longstrid_EQUALS_list2 of unit ->  (longStrId list)
 | longstrid_EQUALS_list1 of unit ->  (longStrId list)
 | longtycon_EQUALS_list2 of unit ->  (longTyCon list)
 | longtycon_EQUALS_list1 of unit ->  (longTyCon list)
 | sigid_list2 of unit ->  (SigId list) | spec1' of unit ->  (Spec)
 | spec1 of unit ->  (Spec) | spec of unit ->  (Spec)
 | AND_tyreadesc_opt of unit ->  (TyReaDesc option)
 | tyreadesc of unit ->  (TyReaDesc)
 | AND_tyreadesc_opt__AND_sigbind_opt of unit ->  (TyReaDesc option*SigBind option)
 | tyreadesc__AND_sigbind_opt of unit ->  (TyReaDesc*SigBind option)
 | sigexp__AND_sigbind_opt of unit ->  (SigExp*SigBind option)
 | AND_sigbind_opt of unit ->  (SigBind option)
 | sigbind of unit ->  (SigBind) | sigdec of unit ->  (SigDec)
 | sigexp' of unit ->  (SigExp) | sigexp of unit ->  (SigExp)
 | COLON_sigexp_opt of unit ->  (SigExp option)
 | AND_tyreadesc_opt__AND_strbind_opt of unit ->  (TyReaDesc option*StrBind option)
 | tyreadesc__AND_strbind_opt of unit ->  (TyReaDesc*StrBind option)
 | sigexp__AND_strbind_opt of unit ->  (SigExp*StrBind option)
 | strexp__AND_strbind_opt of unit ->  (StrExp*StrBind option)
 | AND_strbind_opt of unit ->  (StrBind option)
 | strbind of unit ->  (StrBind) | strdec1' of unit ->  (StrDec)
 | strdec1 of unit ->  (StrDec) | strdec of unit ->  (StrDec)
 | strexp' of unit ->  (StrExp) | strexp of unit ->  (StrExp)
 | tyvar_COMMA_list1 of unit ->  (TyVar list)
 | tyvarseq1 of unit ->  (TyVarseq) | tyvarseq of unit ->  (TyVarseq)
 | ty_COMMA_list2 of unit ->  (Ty list) | tyseq of unit ->  (Tyseq)
 | COMMA_tyrow_opt of unit ->  (TyRow option)
 | tyrow_opt of unit ->  (TyRow option) | tyrow of unit ->  (TyRow)
 | atty of unit ->  (Ty) | consty of unit ->  (Ty)
 | ty_STAR_list of unit ->  (Ty list) | tupty of unit ->  (Ty)
 | ty of unit ->  (Ty) | COLON_ty_list1 of unit ->  (Ty list)
 | atpat_list2 of unit ->  (AtPat list)
 | atpat_list1 of unit ->  (AtPat list) | pat of unit ->  (Pat)
 | AS_pat_opt of unit ->  (Pat option)
 | COLON_ty_opt of unit ->  (Ty option)
 | COMMA_patrow_opt of unit ->  (PatRow option)
 | patrow_opt of unit ->  (PatRow option)
 | patrow of unit ->  (PatRow)
 | pat_COMMA_list2 of unit ->  (Pat list)
 | pat_COMMA_list1 of unit ->  (Pat list)
 | pat_COMMA_list0 of unit ->  (Pat list) | atpat' of unit ->  (AtPat)
 | atpat of unit ->  (AtPat)
 | AND_exbind_opt of unit ->  (ExBind option)
 | exbind of unit ->  (ExBind) | OF_ty_opt of unit ->  (Ty option)
 | BAR_conbind_opt of unit ->  (ConBind option)
 | conbind of unit ->  (ConBind)
 | AND_datbind_opt of unit ->  (DatBind option)
 | datbind1 of unit ->  (DatBind) | datbind0 of unit ->  (DatBind)
 | datbind of unit ->  (DatBind)
 | AND_typbind_opt of unit ->  (TypBind option)
 | typbind of unit ->  (TypBind) | fmrule of unit ->  (Fmrule)
 | BAR_fmatch_opt of unit ->  (Fmatch option)
 | fmatch of unit ->  (Fmatch)
 | AND_fvalbind_opt of unit ->  (FvalBind option)
 | fvalbind of unit ->  (FvalBind)
 | AND_valbind_opt of unit ->  (ValBind option)
 | valbind of unit ->  (ValBind) | d_opt of unit ->  (int)
 | longstrid_list1 of unit ->  (longStrId list)
 | vid_list1 of unit ->  (VId list)
 | WITHTYPE_typbind_opt of unit ->  (TypBind option)
 | dec1' of unit ->  (Dec) | dec1 of unit ->  (Dec)
 | dec of unit ->  (Dec) | mrule of unit ->  (Mrule)
 | BAR_match_opt of unit ->  (Match option)
 | match of unit ->  (Match) | exp of unit ->  (Exp)
 | infexp of unit ->  (InfExp) | appexp of unit ->  (AppExp)
 | COMMA_exprow_opt of unit ->  (ExpRow option)
 | exprow_opt of unit ->  (ExpRow option)
 | exprow of unit ->  (ExpRow)
 | exp_SEMICOLON_list2 of unit ->  (Exp list)
 | exp_SEMICOLON_list1 of unit ->  (Exp list)
 | exp_COMMA_list2 of unit ->  (Exp list)
 | exp_COMMA_list1 of unit ->  (Exp list)
 | exp_COMMA_list0 of unit ->  (Exp list) | atexp of unit ->  (AtExp)
 | OP_opt of unit ->  (Op) | longstrid of unit ->  (longStrId)
 | longtycon of unit ->  (longTyCon) | longvid' of unit ->  (longVId)
 | longvid of unit ->  (longVId) | funid of unit ->  (FunId)
 | sigid of unit ->  (SigId) | strid of unit ->  (StrId)
 | tyvar of unit ->  (TyVar) | tycon of unit ->  (TyCon)
 | vid' of unit ->  (VId) | vid of unit ->  (VId)
 | lab of unit ->  (Lab) | d of unit ->  (int)
 | scon of unit ->  (SCon)
end
type svalue = MlyValue.svalue
type result = Program*Infix.InfEnv
end
structure EC=
struct
open LrTable
val is_keyword =
fn (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 11) => true | (T 12) => true | (T 13)
 => true | (T 14) => true | (T 15) => true | (T 16) => true | (T 17)
 => true | (T 18) => true | (T 19) => true | (T 20) => true | (T 21)
 => true | (T 22) => true | (T 23) => true | (T 24) => true | (T 25)
 => true | (T 26) => true | (T 27) => true | (T 28) => true | (T 29)
 => true | (T 30) => true | (T 31) => true | (T 32) => true | (T 49)
 => true | (T 50) => true | (T 51) => true | (T 52) => true | (T 53)
 => true | (T 54) => true | (T 55) => true | (T 56) => true | (T 57)
 => true | _ => false
val preferred_change = 
nil
val noShift = 
fn (T 0) => true | _ => false
val showTerminal =
fn (T 0) => "EOF"
  | (T 1) => "ABSTYPE"
  | (T 2) => "AND"
  | (T 3) => "ANDALSO"
  | (T 4) => "AS"
  | (T 5) => "CASE"
  | (T 6) => "DO"
  | (T 7) => "DATATYPE"
  | (T 8) => "ELSE"
  | (T 9) => "END"
  | (T 10) => "EXCEPTION"
  | (T 11) => "FN"
  | (T 12) => "FUN"
  | (T 13) => "HANDLE"
  | (T 14) => "IF"
  | (T 15) => "IN"
  | (T 16) => "INFIX"
  | (T 17) => "INFIXR"
  | (T 18) => "LET"
  | (T 19) => "LOCAL"
  | (T 20) => "NONFIX"
  | (T 21) => "OF"
  | (T 22) => "OP"
  | (T 23) => "OPEN"
  | (T 24) => "ORELSE"
  | (T 25) => "RAISE"
  | (T 26) => "REC"
  | (T 27) => "THEN"
  | (T 28) => "TYPE"
  | (T 29) => "VAL"
  | (T 30) => "WITH"
  | (T 31) => "WITHTYPE"
  | (T 32) => "WHILE"
  | (T 33) => "LPAR"
  | (T 34) => "RPAR"
  | (T 35) => "LBRACK"
  | (T 36) => "RBRACK"
  | (T 37) => "LBRACE"
  | (T 38) => "RBRACE"
  | (T 39) => "COMMA"
  | (T 40) => "COLON"
  | (T 41) => "SEMICOLON"
  | (T 42) => "DOTS"
  | (T 43) => "UNDERBAR"
  | (T 44) => "BAR"
  | (T 45) => "EQUALS"
  | (T 46) => "DARROW"
  | (T 47) => "ARROW"
  | (T 48) => "HASH"
  | (T 49) => "EQTYPE"
  | (T 50) => "FUNCTOR"
  | (T 51) => "INCLUDE"
  | (T 52) => "SHARING"
  | (T 53) => "SIG"
  | (T 54) => "SIGNATURE"
  | (T 55) => "STRUCT"
  | (T 56) => "STRUCTURE"
  | (T 57) => "WHERE"
  | (T 58) => "COLONGREATER"
  | (T 59) => "ZERO"
  | (T 60) => "DIGIT"
  | (T 61) => "NUMERIC"
  | (T 62) => "INT"
  | (T 63) => "WORD"
  | (T 64) => "REAL"
  | (T 65) => "STRING"
  | (T 66) => "CHAR"
  | (T 67) => "ALPHA"
  | (T 68) => "SYMBOL"
  | (T 69) => "STAR"
  | (T 70) => "TYVAR"
  | (T 71) => "ETYVAR"
  | (T 72) => "LONGID"
  | _ => "bogus-term"
local open Header in
val errtermvalue=
fn _ => MlyValue.VOID
end
val terms = (T 0) :: (T 1) :: (T 2) :: (T 3) :: (T 4) :: (T 5) :: (T 6
) :: (T 7) :: (T 8) :: (T 9) :: (T 10) :: (T 11) :: (T 12) :: (T 13)
 :: (T 14) :: (T 15) :: (T 16) :: (T 17) :: (T 18) :: (T 19) :: (T 20)
 :: (T 21) :: (T 22) :: (T 23) :: (T 24) :: (T 25) :: (T 26) :: (T 27)
 :: (T 28) :: (T 29) :: (T 30) :: (T 31) :: (T 32) :: (T 33) :: (T 34)
 :: (T 35) :: (T 36) :: (T 37) :: (T 38) :: (T 39) :: (T 40) :: (T 41)
 :: (T 42) :: (T 43) :: (T 44) :: (T 45) :: (T 46) :: (T 47) :: (T 48)
 :: (T 49) :: (T 50) :: (T 51) :: (T 52) :: (T 53) :: (T 54) :: (T 55)
 :: (T 56) :: (T 57) :: (T 58) :: (T 59) :: (T 69) :: nil
end
structure Actions =
struct 
type int = Int.int
exception mlyAction of int
local open Header in
val actions = 
fn (i392:int,defaultPos,stack,
    (J0):arg) =>
case (i392,stack)
of (0,rest671) => let val result=MlyValue.initInfix(fn _ => (
 initJandJ'(J0) ))
 in (LrTable.NT 144,(result,defaultPos,defaultPos),rest671) end
| (1,rest671) => let val result=MlyValue.pushInfix(fn _ => ( pushJ() )
)
 in (LrTable.NT 145,(result,defaultPos,defaultPos),rest671) end
| (2,rest671) => let val result=MlyValue.popInfix(fn _ => ( popJ() ))
 in (LrTable.NT 146,(result,defaultPos,defaultPos),rest671) end
| (3,rest671) => let val result=MlyValue.pushLocalInfix(fn _ => (
 pushJ'shiftJ() ))
 in (LrTable.NT 147,(result,defaultPos,defaultPos),rest671) end
| (4,rest671) => let val result=MlyValue.popLocalInfix(fn _ => (
 popJandJ'() ))
 in (LrTable.NT 148,(result,defaultPos,defaultPos),rest671) end
| (5,(_,(_,ZERO1left,ZERO1right))::rest671) => let val result=
MlyValue.scon(fn _ => ( SCon.fromInt 0 ))
 in (LrTable.NT 0,(result,ZERO1left,ZERO1right),rest671) end
| (6,(_,(MlyValue.DIGIT DIGIT1,DIGIT1left,DIGIT1right))::rest671) => 
let val result=MlyValue.scon(fn _ => let val DIGIT as DIGIT1=DIGIT1 ()
 in ( SCon.fromInt DIGIT ) end
)
 in (LrTable.NT 0,(result,DIGIT1left,DIGIT1right),rest671) end
| (7,(_,(MlyValue.NUMERIC NUMERIC1,NUMERIC1left,NUMERIC1right))::
rest671) => let val result=MlyValue.scon(fn _ => let val NUMERIC as 
NUMERIC1=NUMERIC1 ()
 in ( SCon.fromInt NUMERIC ) end
)
 in (LrTable.NT 0,(result,NUMERIC1left,NUMERIC1right),rest671) end
| (8,(_,(MlyValue.INT INT1,INT1left,INT1right))::rest671) => let val 
result=MlyValue.scon(fn _ => let val INT as INT1=INT1 ()
 in ( SCon.fromInt INT ) end
)
 in (LrTable.NT 0,(result,INT1left,INT1right),rest671) end
| (9,(_,(MlyValue.WORD WORD1,WORD1left,WORD1right))::rest671) => let 
val result=MlyValue.scon(fn _ => let val WORD as WORD1=WORD1 ()
 in ( SCon.fromWord WORD ) end
)
 in (LrTable.NT 0,(result,WORD1left,WORD1right),rest671) end
| (10,(_,(MlyValue.STRING STRING1,STRING1left,STRING1right))::rest671)
 => let val result=MlyValue.scon(fn _ => let val STRING as STRING1=
STRING1 ()
 in ( SCon.fromString STRING ) end
)
 in (LrTable.NT 0,(result,STRING1left,STRING1right),rest671) end
| (11,(_,(MlyValue.CHAR CHAR1,CHAR1left,CHAR1right))::rest671) => let 
val result=MlyValue.scon(fn _ => let val CHAR as CHAR1=CHAR1 ()
 in ( SCon.fromChar CHAR ) end
)
 in (LrTable.NT 0,(result,CHAR1left,CHAR1right),rest671) end
| (12,(_,(MlyValue.REAL REAL1,REAL1left,REAL1right))::rest671) => let 
val result=MlyValue.scon(fn _ => let val REAL as REAL1=REAL1 ()
 in ( SCon.fromReal REAL ) end
)
 in (LrTable.NT 0,(result,REAL1left,REAL1right),rest671) end
| (13,(_,(_,ZERO1left,ZERO1right))::rest671) => let val result=
MlyValue.d(fn _ => ( 0 ))
 in (LrTable.NT 1,(result,ZERO1left,ZERO1right),rest671) end
| (14,(_,(MlyValue.DIGIT DIGIT1,DIGIT1left,DIGIT1right))::rest671) => 
let val result=MlyValue.d(fn _ => let val DIGIT as DIGIT1=DIGIT1 ()
 in ( DIGIT ) end
)
 in (LrTable.NT 1,(result,DIGIT1left,DIGIT1right),rest671) end
| (15,(_,(MlyValue.ALPHA ALPHA1,ALPHA1left,ALPHA1right))::rest671) => 
let val result=MlyValue.lab(fn _ => let val ALPHA as ALPHA1=ALPHA1 ()
 in ( Lab.fromString ALPHA ) end
)
 in (LrTable.NT 2,(result,ALPHA1left,ALPHA1right),rest671) end
| (16,(_,(MlyValue.SYMBOL SYMBOL1,SYMBOL1left,SYMBOL1right))::rest671)
 => let val result=MlyValue.lab(fn _ => let val SYMBOL as SYMBOL1=
SYMBOL1 ()
 in ( Lab.fromString SYMBOL ) end
)
 in (LrTable.NT 2,(result,SYMBOL1left,SYMBOL1right),rest671) end
| (17,(_,(_,STAR1left,STAR1right))::rest671) => let val result=
MlyValue.lab(fn _ => ( Lab.fromString "*" ))
 in (LrTable.NT 2,(result,STAR1left,STAR1right),rest671) end
| (18,(_,(MlyValue.DIGIT DIGIT1,DIGIT1left,DIGIT1right))::rest671) => 
let val result=MlyValue.lab(fn _ => let val DIGIT as DIGIT1=DIGIT1 ()
 in ( Lab.fromInt DIGIT ) end
)
 in (LrTable.NT 2,(result,DIGIT1left,DIGIT1right),rest671) end
| (19,(_,(MlyValue.NUMERIC NUMERIC1,NUMERIC1left,NUMERIC1right))::
rest671) => let val result=MlyValue.lab(fn _ => let val NUMERIC as 
NUMERIC1=NUMERIC1 ()
 in ( Lab.fromInt NUMERIC ) end
)
 in (LrTable.NT 2,(result,NUMERIC1left,NUMERIC1right),rest671) end
| (20,(_,(MlyValue.vid' vid'1,vid'1left,vid'1right))::rest671) => let 
val result=MlyValue.vid(fn _ => let val vid' as vid'1=vid'1 ()
 in ( vid' ) end
)
 in (LrTable.NT 3,(result,vid'1left,vid'1right),rest671) end
| (21,(_,(_,EQUALS1left,EQUALS1right))::rest671) => let val result=
MlyValue.vid(fn _ => ( VId.fromString "=" ))
 in (LrTable.NT 3,(result,EQUALS1left,EQUALS1right),rest671) end
| (22,(_,(MlyValue.ALPHA ALPHA1,ALPHA1left,ALPHA1right))::rest671) => 
let val result=MlyValue.vid'(fn _ => let val ALPHA as ALPHA1=ALPHA1 ()
 in ( VId.fromString ALPHA ) end
)
 in (LrTable.NT 4,(result,ALPHA1left,ALPHA1right),rest671) end
| (23,(_,(MlyValue.SYMBOL SYMBOL1,SYMBOL1left,SYMBOL1right))::rest671)
 => let val result=MlyValue.vid'(fn _ => let val SYMBOL as SYMBOL1=
SYMBOL1 ()
 in ( VId.fromString SYMBOL ) end
)
 in (LrTable.NT 4,(result,SYMBOL1left,SYMBOL1right),rest671) end
| (24,(_,(_,STAR1left,STAR1right))::rest671) => let val result=
MlyValue.vid'(fn _ => ( VId.fromString "*" ))
 in (LrTable.NT 4,(result,STAR1left,STAR1right),rest671) end
| (25,(_,(MlyValue.ALPHA ALPHA1,ALPHA1left,ALPHA1right))::rest671) => 
let val result=MlyValue.tycon(fn _ => let val ALPHA as ALPHA1=ALPHA1 
()
 in ( TyCon.fromString ALPHA ) end
)
 in (LrTable.NT 5,(result,ALPHA1left,ALPHA1right),rest671) end
| (26,(_,(MlyValue.SYMBOL SYMBOL1,SYMBOL1left,SYMBOL1right))::rest671)
 => let val result=MlyValue.tycon(fn _ => let val SYMBOL as SYMBOL1=
SYMBOL1 ()
 in ( TyCon.fromString SYMBOL ) end
)
 in (LrTable.NT 5,(result,SYMBOL1left,SYMBOL1right),rest671) end
| (27,(_,(MlyValue.TYVAR TYVAR1,TYVAR1left,TYVAR1right))::rest671) => 
let val result=MlyValue.tyvar(fn _ => let val TYVAR as TYVAR1=TYVAR1 
()
 in ( TyVar.fromString TYVAR ) end
)
 in (LrTable.NT 6,(result,TYVAR1left,TYVAR1right),rest671) end
| (28,(_,(MlyValue.ALPHA ALPHA1,ALPHA1left,ALPHA1right))::rest671) => 
let val result=MlyValue.strid(fn _ => let val ALPHA as ALPHA1=ALPHA1 
()
 in ( StrId.fromString ALPHA ) end
)
 in (LrTable.NT 7,(result,ALPHA1left,ALPHA1right),rest671) end
| (29,(_,(MlyValue.ALPHA ALPHA1,ALPHA1left,ALPHA1right))::rest671) => 
let val result=MlyValue.sigid(fn _ => let val ALPHA as ALPHA1=ALPHA1 
()
 in ( SigId.fromString ALPHA ) end
)
 in (LrTable.NT 8,(result,ALPHA1left,ALPHA1right),rest671) end
| (30,(_,(MlyValue.ALPHA ALPHA1,ALPHA1left,ALPHA1right))::rest671) => 
let val result=MlyValue.funid(fn _ => let val ALPHA as ALPHA1=ALPHA1 
()
 in ( FunId.fromString ALPHA ) end
)
 in (LrTable.NT 9,(result,ALPHA1left,ALPHA1right),rest671) end
| (31,(_,(MlyValue.longvid' longvid'1,longvid'1left,longvid'1right))::
rest671) => let val result=MlyValue.longvid(fn _ => let val longvid'
 as longvid'1=longvid'1 ()
 in ( longvid' ) end
)
 in (LrTable.NT 10,(result,longvid'1left,longvid'1right),rest671) end
| (32,(_,(_,EQUALS1left,EQUALS1right))::rest671) => let val result=
MlyValue.longvid(fn _ => ( LongVId.fromId(VId.fromString "=") ))
 in (LrTable.NT 10,(result,EQUALS1left,EQUALS1right),rest671) end
| (33,(_,(MlyValue.vid' vid'1,vid'1left,vid'1right))::rest671) => let 
val result=MlyValue.longvid'(fn _ => let val vid' as vid'1=vid'1 ()
 in ( LongVId.fromId vid' ) end
)
 in (LrTable.NT 11,(result,vid'1left,vid'1right),rest671) end
| (34,(_,(MlyValue.LONGID LONGID1,LONGID1left,LONGID1right))::rest671)
 => let val result=MlyValue.longvid'(fn _ => let val LONGID as LONGID1
=LONGID1 ()
 in ( LongVId.implode(toLongId VId.fromString LONGID) ) end
)
 in (LrTable.NT 11,(result,LONGID1left,LONGID1right),rest671) end
| (35,(_,(MlyValue.tycon tycon1,tycon1left,tycon1right))::rest671) => 
let val result=MlyValue.longtycon(fn _ => let val tycon as tycon1=
tycon1 ()
 in ( LongTyCon.fromId tycon ) end
)
 in (LrTable.NT 12,(result,tycon1left,tycon1right),rest671) end
| (36,(_,(MlyValue.LONGID LONGID1,LONGID1left,LONGID1right))::rest671)
 => let val result=MlyValue.longtycon(fn _ => let val LONGID as 
LONGID1=LONGID1 ()
 in ( LongTyCon.implode(toLongId TyCon.fromString LONGID) ) end
)
 in (LrTable.NT 12,(result,LONGID1left,LONGID1right),rest671) end
| (37,(_,(MlyValue.strid strid1,strid1left,strid1right))::rest671) => 
let val result=MlyValue.longstrid(fn _ => let val strid as strid1=
strid1 ()
 in ( LongStrId.fromId strid ) end
)
 in (LrTable.NT 13,(result,strid1left,strid1right),rest671) end
| (38,(_,(MlyValue.LONGID LONGID1,LONGID1left,LONGID1right))::rest671)
 => let val result=MlyValue.longstrid(fn _ => let val LONGID as 
LONGID1=LONGID1 ()
 in ( LongStrId.implode(toLongId StrId.fromString LONGID) ) end
)
 in (LrTable.NT 13,(result,LONGID1left,LONGID1right),rest671) end
| (39,(_,(_,OP1left,OP1right))::rest671) => let val result=
MlyValue.OP_opt(fn _ => ( WITHOp ))
 in (LrTable.NT 14,(result,OP1left,OP1right),rest671) end
| (40,rest671) => let val result=MlyValue.OP_opt(fn _ => ( SANSOp ))
 in (LrTable.NT 14,(result,defaultPos,defaultPos),rest671) end
| (41,(_,(MlyValue.scon scon1,sconleft as scon1left,sconright as 
scon1right))::rest671) => let val result=MlyValue.atexp(fn _ => let 
val scon as scon1=scon1 ()
 in ( SCONAtExp(I(sconleft,sconright), scon) ) end
)
 in (LrTable.NT 15,(result,scon1left,scon1right),rest671) end
| (42,(_,(MlyValue.longvid longvid1,_,longvidright as longvid1right))
::(_,(MlyValue.OP_opt OP_opt1,OP_optleft as OP_opt1left,_))::rest671)
 => let val result=MlyValue.atexp(fn _ => let val OP_opt as OP_opt1=
OP_opt1 ()
val longvid as longvid1=longvid1 ()
 in (
 LONGVIDAtExp(I(OP_optleft,longvidright),
                                       OP_opt, longvid) 
) end
)
 in (LrTable.NT 15,(result,OP_opt1left,longvid1right),rest671) end
| (43,(_,(_,_,RBRACEright as RBRACE1right))::(_,(MlyValue.exprow_opt 
exprow_opt1,_,_))::(_,(_,LBRACEleft as LBRACE1left,_))::rest671) => 
let val result=MlyValue.atexp(fn _ => let val exprow_opt as 
exprow_opt1=exprow_opt1 ()
 in ( RECORDAtExp(I(LBRACEleft,RBRACEright), exprow_opt) ) end
)
 in (LrTable.NT 15,(result,LBRACE1left,RBRACE1right),rest671) end
| (44,(_,(MlyValue.lab lab1,_,labright as lab1right))::(_,(_,HASHleft
 as HASH1left,_))::rest671) => let val result=MlyValue.atexp(fn _ => 
let val lab as lab1=lab1 ()
 in ( HASHAtExp(I(HASHleft,labright), lab) ) end
)
 in (LrTable.NT 15,(result,HASH1left,lab1right),rest671) end
| (45,(_,(_,_,RPARright as RPAR1right))::(_,(_,LPARleft as LPAR1left,_
))::rest671) => let val result=MlyValue.atexp(fn _ => (
 UNITAtExp(I(LPARleft,RPARright)) ))
 in (LrTable.NT 15,(result,LPAR1left,RPAR1right),rest671) end
| (46,(_,(_,_,RPARright as RPAR1right))::(_,(MlyValue.exp_COMMA_list2 
exp_COMMA_list21,_,_))::(_,(_,LPARleft as LPAR1left,_))::rest671) => 
let val result=MlyValue.atexp(fn _ => let val exp_COMMA_list2 as 
exp_COMMA_list21=exp_COMMA_list21 ()
 in ( TUPLEAtExp(I(LPARleft,RPARright), exp_COMMA_list2) ) end
)
 in (LrTable.NT 15,(result,LPAR1left,RPAR1right),rest671) end
| (47,(_,(_,_,RBRACKright as RBRACK1right))::(_,(
MlyValue.exp_COMMA_list0 exp_COMMA_list01,_,_))::(_,(_,LBRACKleft as 
LBRACK1left,_))::rest671) => let val result=MlyValue.atexp(fn _ => 
let val exp_COMMA_list0 as exp_COMMA_list01=exp_COMMA_list01 ()
 in ( LISTAtExp(I(LBRACKleft,RBRACKright),
                                    exp_COMMA_list0 ))
 end
)
 in (LrTable.NT 15,(result,LBRACK1left,RBRACK1right),rest671) end
| (48,(_,(_,_,RPARright as RPAR1right))::(_,(
MlyValue.exp_SEMICOLON_list2 exp_SEMICOLON_list21,_,_))::(_,(_,
LPARleft as LPAR1left,_))::rest671) => let val result=MlyValue.atexp(
fn _ => let val exp_SEMICOLON_list2 as exp_SEMICOLON_list21=
exp_SEMICOLON_list21 ()
 in ( SEQAtExp(I(LPARleft,RPARright), exp_SEMICOLON_list2) ) end
)
 in (LrTable.NT 15,(result,LPAR1left,RPAR1right),rest671) end
| (49,(_,(_,_,ENDright as END1right))::(_,(MlyValue.popInfix popInfix1
,_,_))::(_,(MlyValue.exp_SEMICOLON_list1 exp_SEMICOLON_list11,_,_))::_
::(_,(MlyValue.dec dec1,_,_))::(_,(MlyValue.pushInfix pushInfix1,_,_))
::(_,(_,LETleft as LET1left,_))::rest671) => let val result=
MlyValue.atexp(fn _ => let val pushInfix1=pushInfix1 ()
val dec as dec1=dec1 ()
val exp_SEMICOLON_list1 as exp_SEMICOLON_list11=exp_SEMICOLON_list11 
()
val popInfix1=popInfix1 ()
 in ( LETAtExp(I(LETleft,ENDright),
                                   dec, exp_SEMICOLON_list1) )
 end
)
 in (LrTable.NT 15,(result,LET1left,END1right),rest671) end
| (50,(_,(_,_,RPARright as RPAR1right))::(_,(MlyValue.exp exp1,_,_))::
(_,(_,LPARleft as LPAR1left,_))::rest671) => let val result=
MlyValue.atexp(fn _ => let val exp as exp1=exp1 ()
 in ( PARAtExp(I(LPARleft,RPARright), exp) ) end
)
 in (LrTable.NT 15,(result,LPAR1left,RPAR1right),rest671) end
| (51,(_,(MlyValue.exp_COMMA_list1 exp_COMMA_list11,
exp_COMMA_list11left,exp_COMMA_list11right))::rest671) => let val 
result=MlyValue.exp_COMMA_list0(fn _ => let val exp_COMMA_list1 as 
exp_COMMA_list11=exp_COMMA_list11 ()
 in ( exp_COMMA_list1 ) end
)
 in (LrTable.NT 16,(result,exp_COMMA_list11left,exp_COMMA_list11right)
,rest671) end
| (52,rest671) => let val result=MlyValue.exp_COMMA_list0(fn _ => (
 [] ))
 in (LrTable.NT 16,(result,defaultPos,defaultPos),rest671) end
| (53,(_,(MlyValue.exp_COMMA_list1 exp_COMMA_list11,_,
exp_COMMA_list11right))::_::(_,(MlyValue.exp exp1,exp1left,_))::
rest671) => let val result=MlyValue.exp_COMMA_list1(fn _ => let val 
exp as exp1=exp1 ()
val exp_COMMA_list1 as exp_COMMA_list11=exp_COMMA_list11 ()
 in ( exp::exp_COMMA_list1 ) end
)
 in (LrTable.NT 17,(result,exp1left,exp_COMMA_list11right),rest671)
 end
| (54,(_,(MlyValue.exp exp1,exp1left,exp1right))::rest671) => let val 
result=MlyValue.exp_COMMA_list1(fn _ => let val exp as exp1=exp1 ()
 in ( exp::[] ) end
)
 in (LrTable.NT 17,(result,exp1left,exp1right),rest671) end
| (55,(_,(MlyValue.exp_COMMA_list1 exp_COMMA_list11,_,
exp_COMMA_list11right))::_::(_,(MlyValue.exp exp1,exp1left,_))::
rest671) => let val result=MlyValue.exp_COMMA_list2(fn _ => let val 
exp as exp1=exp1 ()
val exp_COMMA_list1 as exp_COMMA_list11=exp_COMMA_list11 ()
 in ( exp::exp_COMMA_list1 ) end
)
 in (LrTable.NT 18,(result,exp1left,exp_COMMA_list11right),rest671)
 end
| (56,(_,(MlyValue.exp_SEMICOLON_list1 exp_SEMICOLON_list11,_,
exp_SEMICOLON_list11right))::_::(_,(MlyValue.exp exp1,exp1left,_))::
rest671) => let val result=MlyValue.exp_SEMICOLON_list1(fn _ => let 
val exp as exp1=exp1 ()
val exp_SEMICOLON_list1 as exp_SEMICOLON_list11=exp_SEMICOLON_list11 
()
 in ( exp::exp_SEMICOLON_list1 ) end
)
 in (LrTable.NT 19,(result,exp1left,exp_SEMICOLON_list11right),rest671
) end
| (57,(_,(MlyValue.exp exp1,exp1left,exp1right))::rest671) => let val 
result=MlyValue.exp_SEMICOLON_list1(fn _ => let val exp as exp1=exp1 
()
 in ( exp::[] ) end
)
 in (LrTable.NT 19,(result,exp1left,exp1right),rest671) end
| (58,(_,(MlyValue.exp_SEMICOLON_list2 exp_SEMICOLON_list21,_,
exp_SEMICOLON_list21right))::_::(_,(MlyValue.exp exp1,exp1left,_))::
rest671) => let val result=MlyValue.exp_SEMICOLON_list2(fn _ => let 
val exp as exp1=exp1 ()
val exp_SEMICOLON_list2 as exp_SEMICOLON_list21=exp_SEMICOLON_list21 
()
 in ( exp::exp_SEMICOLON_list2 ) end
)
 in (LrTable.NT 20,(result,exp1left,exp_SEMICOLON_list21right),rest671
) end
| (59,(_,(MlyValue.exp exp2,_,exp2right))::_::(_,(MlyValue.exp exp1,
exp1left,_))::rest671) => let val result=MlyValue.exp_SEMICOLON_list2(
fn _ => let val exp1=exp1 ()
val exp2=exp2 ()
 in ( [exp1, exp2] ) end
)
 in (LrTable.NT 20,(result,exp1left,exp2right),rest671) end
| (60,(_,(MlyValue.COMMA_exprow_opt COMMA_exprow_opt1,_,
COMMA_exprow_optright as COMMA_exprow_opt1right))::(_,(MlyValue.exp 
exp1,_,_))::_::(_,(MlyValue.lab lab1,lableft as lab1left,_))::rest671)
 => let val result=MlyValue.exprow(fn _ => let val lab as lab1=lab1 ()
val exp as exp1=exp1 ()
val COMMA_exprow_opt as COMMA_exprow_opt1=COMMA_exprow_opt1 ()
 in (
 ExpRow(I(lableft,COMMA_exprow_optright),
                                         lab, exp, COMMA_exprow_opt) 
) end
)
 in (LrTable.NT 21,(result,lab1left,COMMA_exprow_opt1right),rest671)
 end
| (61,(_,(MlyValue.exprow exprow1,_,exprow1right))::(_,(_,COMMA1left,_
))::rest671) => let val result=MlyValue.COMMA_exprow_opt(fn _ => let 
val exprow as exprow1=exprow1 ()
 in ( SOME exprow ) end
)
 in (LrTable.NT 23,(result,COMMA1left,exprow1right),rest671) end
| (62,rest671) => let val result=MlyValue.COMMA_exprow_opt(fn _ => (
 NONE ))
 in (LrTable.NT 23,(result,defaultPos,defaultPos),rest671) end
| (63,(_,(MlyValue.exprow exprow1,exprow1left,exprow1right))::rest671)
 => let val result=MlyValue.exprow_opt(fn _ => let val exprow as 
exprow1=exprow1 ()
 in ( SOME exprow ) end
)
 in (LrTable.NT 22,(result,exprow1left,exprow1right),rest671) end
| (64,rest671) => let val result=MlyValue.exprow_opt(fn _ => ( NONE ))
 in (LrTable.NT 22,(result,defaultPos,defaultPos),rest671) end
| (65,(_,(MlyValue.atexp atexp1,atexp1left,atexp1right))::rest671) => 
let val result=MlyValue.appexp(fn _ => let val atexp as atexp1=atexp1 
()
 in ( atexp::[] ) end
)
 in (LrTable.NT 24,(result,atexp1left,atexp1right),rest671) end
| (66,(_,(MlyValue.atexp atexp1,_,atexp1right))::(_,(MlyValue.appexp 
appexp1,appexp1left,_))::rest671) => let val result=MlyValue.appexp(
fn _ => let val appexp as appexp1=appexp1 ()
val atexp as atexp1=atexp1 ()
 in ( atexp::appexp ) end
)
 in (LrTable.NT 24,(result,appexp1left,atexp1right),rest671) end
| (67,(_,(MlyValue.appexp appexp1,appexp1left,appexp1right))::rest671)
 => let val result=MlyValue.infexp(fn _ => let val appexp as appexp1=
appexp1 ()
 in ( Infix.parseExp(!J, List.rev appexp) ) end
)
 in (LrTable.NT 25,(result,appexp1left,appexp1right),rest671) end
| (68,(_,(MlyValue.infexp infexp1,infexp1left,infexp1right))::rest671)
 => let val result=MlyValue.exp(fn _ => let val infexp as infexp1=
infexp1 ()
 in ( infexp ) end
)
 in (LrTable.NT 26,(result,infexp1left,infexp1right),rest671) end
| (69,(_,(MlyValue.ty ty1,_,tyright as ty1right))::_::(_,(MlyValue.exp
 exp1,expleft as exp1left,_))::rest671) => let val result=MlyValue.exp
(fn _ => let val exp as exp1=exp1 ()
val ty as ty1=ty1 ()
 in ( TYPEDExp(I(expleft,tyright), exp, ty) ) end
)
 in (LrTable.NT 26,(result,exp1left,ty1right),rest671) end
| (70,(_,(MlyValue.exp exp2,_,exp2right))::_::(_,(MlyValue.exp exp1,
exp1left,_))::rest671) => let val result=MlyValue.exp(fn _ => let val 
exp1=exp1 ()
val exp2=exp2 ()
 in ( ANDALSOExp(I(exp1left,exp2right), exp1, exp2)) end
)
 in (LrTable.NT 26,(result,exp1left,exp2right),rest671) end
| (71,(_,(MlyValue.exp exp2,_,exp2right))::_::(_,(MlyValue.exp exp1,
exp1left,_))::rest671) => let val result=MlyValue.exp(fn _ => let val 
exp1=exp1 ()
val exp2=exp2 ()
 in ( ORELSEExp(I(exp1left,exp2right), exp1, exp2) ) end
)
 in (LrTable.NT 26,(result,exp1left,exp2right),rest671) end
| (72,(_,(MlyValue.match match1,_,matchright as match1right))::_::(_,(
MlyValue.exp exp1,expleft as exp1left,_))::rest671) => let val result=
MlyValue.exp(fn _ => let val exp as exp1=exp1 ()
val match as match1=match1 ()
 in ( HANDLEExp(I(expleft,matchright), exp, match) ) end
)
 in (LrTable.NT 26,(result,exp1left,match1right),rest671) end
| (73,(_,(MlyValue.exp exp1,_,expright as exp1right))::(_,(_,RAISEleft
 as RAISE1left,_))::rest671) => let val result=MlyValue.exp(fn _ => 
let val exp as exp1=exp1 ()
 in ( RAISEExp(I(RAISEleft,expright), exp) ) end
)
 in (LrTable.NT 26,(result,RAISE1left,exp1right),rest671) end
| (74,(_,(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 ( IFExp(I(IFleft,exp3right), exp1, exp2, exp3) ) end
)
 in (LrTable.NT 26,(result,IF1left,exp3right),rest671) end
| (75,(_,(MlyValue.exp exp2,_,exp2right))::_::(_,(MlyValue.exp exp1,_,
_))::(_,(_,WHILEleft as WHILE1left,_))::rest671) => let val result=
MlyValue.exp(fn _ => let val exp1=exp1 ()
val exp2=exp2 ()
 in ( WHILEExp(I(WHILEleft,exp2right), exp1, exp2) ) end
)
 in (LrTable.NT 26,(result,WHILE1left,exp2right),rest671) end
| (76,(_,(MlyValue.match match1,_,matchright as match1right))::_::(_,(
MlyValue.exp exp1,_,_))::(_,(_,CASEleft as CASE1left,_))::rest671) => 
let val result=MlyValue.exp(fn _ => let val exp as exp1=exp1 ()
val match as match1=match1 ()
 in ( CASEExp(I(CASEleft,matchright), exp, match) ) end
)
 in (LrTable.NT 26,(result,CASE1left,match1right),rest671) end
| (77,(_,(MlyValue.match match1,_,matchright as match1right))::(_,(_,
FNleft as FN1left,_))::rest671) => let val result=MlyValue.exp(fn _
 => let val match as match1=match1 ()
 in ( FNExp(I(FNleft,matchright), match) ) end
)
 in (LrTable.NT 26,(result,FN1left,match1right),rest671) end
| (78,(_,(MlyValue.BAR_match_opt BAR_match_opt1,_,BAR_match_optright
 as BAR_match_opt1right))::(_,(MlyValue.mrule mrule1,mruleleft as 
mrule1left,_))::rest671) => let val result=MlyValue.match(fn _ => let 
val mrule as mrule1=mrule1 ()
val BAR_match_opt as BAR_match_opt1=BAR_match_opt1 ()
 in (
 Match(I(mruleleft,BAR_match_optright),
                                        mrule, BAR_match_opt) )
 end
)
 in (LrTable.NT 27,(result,mrule1left,BAR_match_opt1right),rest671)
 end
| (79,(_,(MlyValue.match match1,_,match1right))::(_,(_,BAR1left,_))::
rest671) => let val result=MlyValue.BAR_match_opt(fn _ => let val 
match as match1=match1 ()
 in ( SOME match ) end
)
 in (LrTable.NT 28,(result,BAR1left,match1right),rest671) end
| (80,rest671) => let val result=MlyValue.BAR_match_opt(fn _ => (
 NONE ))
 in (LrTable.NT 28,(result,defaultPos,defaultPos),rest671) end
| (81,(_,(MlyValue.exp exp1,_,expright as exp1right))::_::(_,(
MlyValue.pat pat1,patleft as pat1left,_))::rest671) => let val result=
MlyValue.mrule(fn _ => let val pat as pat1=pat1 ()
val exp as exp1=exp1 ()
 in ( Mrule(I(patleft,expright), pat, exp) ) end
)
 in (LrTable.NT 29,(result,pat1left,exp1right),rest671) end
| (82,(_,(MlyValue.dec1 dec11,dec11left,dec11right))::rest671) => let 
val result=MlyValue.dec(fn _ => let val dec1 as dec11=dec11 ()
 in ( dec1 ) end
)
 in (LrTable.NT 30,(result,dec11left,dec11right),rest671) end
| (83,rest671) => let val result=MlyValue.dec(fn _ => (
 EMPTYDec(I(defaultPos,defaultPos)) ))
 in (LrTable.NT 30,(result,defaultPos,defaultPos),rest671) end
| (84,(_,(MlyValue.dec1' dec1'1,dec1'1left,dec1'1right))::rest671) => 
let val result=MlyValue.dec1(fn _ => let val dec1' as dec1'1=dec1'1 ()
 in ( dec1' ) end
)
 in (LrTable.NT 31,(result,dec1'1left,dec1'1right),rest671) end
| (85,(_,(_,_,ENDright as END1right))::(_,(MlyValue.popLocalInfix 
popLocalInfix1,_,_))::(_,(MlyValue.dec dec2,_,_))::(_,(
MlyValue.pushLocalInfix pushLocalInfix1,_,_))::_::(_,(MlyValue.dec 
dec1,_,_))::(_,(MlyValue.pushInfix pushInfix1,_,_))::(_,(_,LOCALleft
 as LOCAL1left,_))::rest671) => let val result=MlyValue.dec1(fn _ => 
let val pushInfix1=pushInfix1 ()
val dec1=dec1 ()
val pushLocalInfix1=pushLocalInfix1 ()
val dec2=dec2 ()
val popLocalInfix1=popLocalInfix1 ()
 in ( LOCALDec(I(LOCALleft,ENDright), dec1, dec2) ) end
)
 in (LrTable.NT 31,(result,LOCAL1left,END1right),rest671) end
| (86,(_,(MlyValue.dec1 dec12,_,dec12right))::(_,(MlyValue.dec1 dec11,
dec11left,_))::rest671) => let val result=MlyValue.dec1(fn _ => let 
val dec11=dec11 ()
val dec12=dec12 ()
 in ( SEQDec(I(dec11left,dec12right), dec11, dec12) ) end
)
 in (LrTable.NT 31,(result,dec11left,dec12right),rest671) end
| (87,(_,(_,SEMICOLON1left,SEMICOLON1right))::rest671) => let val 
result=MlyValue.dec1(fn _ => ( EMPTYDec(I(defaultPos,defaultPos)) ))
 in (LrTable.NT 31,(result,SEMICOLON1left,SEMICOLON1right),rest671)
 end
| (88,(_,(MlyValue.valbind valbind1,_,valbindright as valbind1right))
::(_,(_,VALleft as VAL1left,_))::rest671) => let val result=
MlyValue.dec1'(fn _ => let val valbind as valbind1=valbind1 ()
 in (
 VALDec(I(VALleft,valbindright),
                             TyVarseq(I(defaultPos,defaultPos), []), valbind) 
) end
)
 in (LrTable.NT 32,(result,VAL1left,valbind1right),rest671) end
| (89,(_,(MlyValue.valbind valbind1,_,valbindright as valbind1right))
::(_,(MlyValue.tyvarseq1 tyvarseq11,_,_))::(_,(_,VALleft as VAL1left,_
))::rest671) => let val result=MlyValue.dec1'(fn _ => let val 
tyvarseq1 as tyvarseq11=tyvarseq11 ()
val valbind as valbind1=valbind1 ()
 in ( VALDec(I(VALleft,valbindright), tyvarseq1, valbind) ) end
)
 in (LrTable.NT 32,(result,VAL1left,valbind1right),rest671) end
| (90,(_,(MlyValue.fvalbind fvalbind1,_,fvalbindright as 
fvalbind1right))::(_,(_,FUNleft as FUN1left,_))::rest671) => let val 
result=MlyValue.dec1'(fn _ => let val fvalbind as fvalbind1=fvalbind1 
()
 in (
 FUNDec(I(FUNleft,fvalbindright),
                            TyVarseq(I(defaultPos,defaultPos), []), fvalbind) 
) end
)
 in (LrTable.NT 32,(result,FUN1left,fvalbind1right),rest671) end
| (91,(_,(MlyValue.fvalbind fvalbind1,_,fvalbindright as 
fvalbind1right))::(_,(MlyValue.tyvarseq1 tyvarseq11,_,_))::(_,(_,
FUNleft as FUN1left,_))::rest671) => let val result=MlyValue.dec1'(fn 
_ => let val tyvarseq1 as tyvarseq11=tyvarseq11 ()
val fvalbind as fvalbind1=fvalbind1 ()
 in ( FUNDec(I(FUNleft,fvalbindright), tyvarseq1, fvalbind)) end
)
 in (LrTable.NT 32,(result,FUN1left,fvalbind1right),rest671) end
| (92,(_,(MlyValue.typbind typbind1,_,typbindright as typbind1right))
::(_,(_,TYPEleft as TYPE1left,_))::rest671) => let val result=
MlyValue.dec1'(fn _ => let val typbind as typbind1=typbind1 ()
 in ( TYPEDec(I(TYPEleft,typbindright), typbind) ) end
)
 in (LrTable.NT 32,(result,TYPE1left,typbind1right),rest671) end
| (93,(_,(MlyValue.WITHTYPE_typbind_opt WITHTYPE_typbind_opt1,_,
WITHTYPE_typbind_optright as WITHTYPE_typbind_opt1right))::(_,(
MlyValue.datbind0 datbind01,_,_))::(_,(_,DATATYPEleft as DATATYPE1left
,_))::rest671) => let val result=MlyValue.dec1'(fn _ => let val 
datbind0 as datbind01=datbind01 ()
val WITHTYPE_typbind_opt as WITHTYPE_typbind_opt1=
WITHTYPE_typbind_opt1 ()
 in (
 DATATYPEDec(I(DATATYPEleft,WITHTYPE_typbind_optright),
                                     datbind0, WITHTYPE_typbind_opt) 
) end
)
 in (LrTable.NT 32,(result,DATATYPE1left,WITHTYPE_typbind_opt1right),
rest671) end
| (94,(_,(MlyValue.WITHTYPE_typbind_opt WITHTYPE_typbind_opt1,_,
WITHTYPE_typbind_optright as WITHTYPE_typbind_opt1right))::(_,(
MlyValue.datbind1 datbind11,_,_))::(_,(_,DATATYPEleft as DATATYPE1left
,_))::rest671) => let val result=MlyValue.dec1'(fn _ => let val 
datbind1 as datbind11=datbind11 ()
val WITHTYPE_typbind_opt as WITHTYPE_typbind_opt1=
WITHTYPE_typbind_opt1 ()
 in (
 DATATYPEDec(I(DATATYPEleft,WITHTYPE_typbind_optright),
                                      datbind1, WITHTYPE_typbind_opt) 
) end
)
 in (LrTable.NT 32,(result,DATATYPE1left,WITHTYPE_typbind_opt1right),
rest671) end
| (95,(_,(MlyValue.longtycon longtycon1,_,longtyconright as 
longtycon1right))::_::_::(_,(MlyValue.tycon tycon1,_,_))::(_,(_,
DATATYPEleft as DATATYPE1left,_))::rest671) => let val result=
MlyValue.dec1'(fn _ => let val tycon as tycon1=tycon1 ()
val longtycon as longtycon1=longtycon1 ()
 in (
 REPLICATIONDec(I(DATATYPEleft,longtyconright),
                                         tycon, longtycon) 
) end
)
 in (LrTable.NT 32,(result,DATATYPE1left,longtycon1right),rest671) end
| (96,(_,(_,_,ENDright as END1right))::(_,(MlyValue.dec dec1,_,_))::_
::(_,(MlyValue.WITHTYPE_typbind_opt WITHTYPE_typbind_opt1,_,_))::(_,(
MlyValue.datbind datbind1,_,_))::(_,(_,ABSTYPEleft as ABSTYPE1left,_))
::rest671) => let val result=MlyValue.dec1'(fn _ => let val datbind
 as datbind1=datbind1 ()
val WITHTYPE_typbind_opt as WITHTYPE_typbind_opt1=
WITHTYPE_typbind_opt1 ()
val dec as dec1=dec1 ()
 in (
 ABSTYPEDec(I(ABSTYPEleft,ENDright), datbind,
                                     WITHTYPE_typbind_opt, dec) 
) end
)
 in (LrTable.NT 32,(result,ABSTYPE1left,END1right),rest671) end
| (97,(_,(MlyValue.exbind exbind1,_,exbindright as exbind1right))::(_,
(_,EXCEPTIONleft as EXCEPTION1left,_))::rest671) => let val result=
MlyValue.dec1'(fn _ => let val exbind as exbind1=exbind1 ()
 in ( EXCEPTIONDec(I(EXCEPTIONleft,exbindright), exbind) ) end
)
 in (LrTable.NT 32,(result,EXCEPTION1left,exbind1right),rest671) end
| (98,(_,(MlyValue.longstrid_list1 longstrid_list11,_,
longstrid_list1right as longstrid_list11right))::(_,(_,OPENleft as 
OPEN1left,_))::rest671) => let val result=MlyValue.dec1'(fn _ => let 
val longstrid_list1 as longstrid_list11=longstrid_list11 ()
 in (
 OPENDec(I(OPENleft,longstrid_list1right),
                                  longstrid_list1) )
 end
)
 in (LrTable.NT 32,(result,OPEN1left,longstrid_list11right),rest671)
 end
| (99,(_,(MlyValue.vid_list1 vid_list11,_,vid_list1right as 
vid_list11right))::(_,(MlyValue.d_opt d_opt1,_,_))::(_,(_,INFIXleft
 as INFIX1left,_))::rest671) => let val result=MlyValue.dec1'(fn _ => 
let val d_opt as d_opt1=d_opt1 ()
val vid_list1 as vid_list11=vid_list11 ()
 in (
 assignInfix((Infix.LEFT, d_opt), vid_list1);
                          EMPTYDec(I(INFIXleft,vid_list1right)) 
) end
)
 in (LrTable.NT 32,(result,INFIX1left,vid_list11right),rest671) end
| (100,(_,(MlyValue.vid_list1 vid_list11,_,vid_list1right as 
vid_list11right))::(_,(MlyValue.d_opt d_opt1,_,_))::(_,(_,INFIXRleft
 as INFIXR1left,_))::rest671) => let val result=MlyValue.dec1'(fn _
 => let val d_opt as d_opt1=d_opt1 ()
val vid_list1 as vid_list11=vid_list11 ()
 in (
 assignInfix((Infix.RIGHT, d_opt), vid_list1);
                          EMPTYDec(I(INFIXRleft,vid_list1right)) 
) end
)
 in (LrTable.NT 32,(result,INFIXR1left,vid_list11right),rest671) end
| (101,(_,(MlyValue.vid_list1 vid_list11,_,vid_list1right as 
vid_list11right))::(_,(_,NONFIXleft as NONFIX1left,_))::rest671) => 
let val result=MlyValue.dec1'(fn _ => let val vid_list1 as vid_list11=
vid_list11 ()
 in (
 cancelInfix(vid_list1);
                          EMPTYDec(I(NONFIXleft,vid_list1right)) )
 end
)
 in (LrTable.NT 32,(result,NONFIX1left,vid_list11right),rest671) end
| (102,(_,(MlyValue.typbind typbind1,_,typbind1right))::(_,(_,
WITHTYPE1left,_))::rest671) => let val result=
MlyValue.WITHTYPE_typbind_opt(fn _ => let val typbind as typbind1=
typbind1 ()
 in ( SOME typbind ) end
)
 in (LrTable.NT 33,(result,WITHTYPE1left,typbind1right),rest671) end
| (103,rest671) => let val result=MlyValue.WITHTYPE_typbind_opt(fn _
 => ( NONE ))
 in (LrTable.NT 33,(result,defaultPos,defaultPos),rest671) end
| (104,(_,(MlyValue.vid_list1 vid_list11,_,vid_list11right))::(_,(
MlyValue.vid vid1,vid1left,_))::rest671) => let val result=
MlyValue.vid_list1(fn _ => let val vid as vid1=vid1 ()
val vid_list1 as vid_list11=vid_list11 ()
 in ( vid::vid_list1 ) end
)
 in (LrTable.NT 34,(result,vid1left,vid_list11right),rest671) end
| (105,(_,(MlyValue.vid vid1,vid1left,vid1right))::rest671) => let 
val result=MlyValue.vid_list1(fn _ => let val vid as vid1=vid1 ()
 in ( vid::[] ) end
)
 in (LrTable.NT 34,(result,vid1left,vid1right),rest671) end
| (106,(_,(MlyValue.longstrid_list1 longstrid_list11,_,
longstrid_list11right))::(_,(MlyValue.longstrid longstrid1,
longstrid1left,_))::rest671) => let val result=
MlyValue.longstrid_list1(fn _ => let val longstrid as longstrid1=
longstrid1 ()
val longstrid_list1 as longstrid_list11=longstrid_list11 ()
 in ( longstrid::longstrid_list1 ) end
)
 in (LrTable.NT 35,(result,longstrid1left,longstrid_list11right),
rest671) end
| (107,(_,(MlyValue.longstrid longstrid1,longstrid1left,
longstrid1right))::rest671) => let val result=MlyValue.longstrid_list1
(fn _ => let val longstrid as longstrid1=longstrid1 ()
 in ( longstrid::[] ) end
)
 in (LrTable.NT 35,(result,longstrid1left,longstrid1right),rest671)
 end
| (108,(_,(MlyValue.d d1,d1left,d1right))::rest671) => let val result=
MlyValue.d_opt(fn _ => let val d as d1=d1 ()
 in ( d ) end
)
 in (LrTable.NT 36,(result,d1left,d1right),rest671) end
| (109,rest671) => let val result=MlyValue.d_opt(fn _ => ( 0 ))
 in (LrTable.NT 36,(result,defaultPos,defaultPos),rest671) end
| (110,(_,(MlyValue.AND_valbind_opt AND_valbind_opt1,_,
AND_valbind_optright as AND_valbind_opt1right))::(_,(MlyValue.exp exp1
,_,_))::_::(_,(MlyValue.pat pat1,patleft as pat1left,_))::rest671) => 
let val result=MlyValue.valbind(fn _ => let val pat as pat1=pat1 ()
val exp as exp1=exp1 ()
val AND_valbind_opt as AND_valbind_opt1=AND_valbind_opt1 ()
 in (
 PLAINValBind(I(patleft,AND_valbind_optright),
                                       pat, exp, AND_valbind_opt) 
) end
)
 in (LrTable.NT 37,(result,pat1left,AND_valbind_opt1right),rest671)
 end
| (111,(_,(MlyValue.valbind valbind1,_,valbindright as valbind1right))
::(_,(_,RECleft as REC1left,_))::rest671) => let val result=
MlyValue.valbind(fn _ => let val valbind as valbind1=valbind1 ()
 in ( RECValBind(I(RECleft,valbindright), valbind) ) end
)
 in (LrTable.NT 37,(result,REC1left,valbind1right),rest671) end
| (112,(_,(MlyValue.valbind valbind1,_,valbind1right))::(_,(_,AND1left
,_))::rest671) => let val result=MlyValue.AND_valbind_opt(fn _ => let 
val valbind as valbind1=valbind1 ()
 in ( SOME valbind ) end
)
 in (LrTable.NT 38,(result,AND1left,valbind1right),rest671) end
| (113,rest671) => let val result=MlyValue.AND_valbind_opt(fn _ => (
 NONE ))
 in (LrTable.NT 38,(result,defaultPos,defaultPos),rest671) end
| (114,(_,(MlyValue.AND_fvalbind_opt AND_fvalbind_opt1,_,
AND_fvalbind_optright as AND_fvalbind_opt1right))::(_,(MlyValue.fmatch
 fmatch1,fmatchleft as fmatch1left,_))::rest671) => let val result=
MlyValue.fvalbind(fn _ => let val fmatch as fmatch1=fmatch1 ()
val AND_fvalbind_opt as AND_fvalbind_opt1=AND_fvalbind_opt1 ()
 in (
 FvalBind(I(fmatchleft,AND_fvalbind_optright),
                                     fmatch, AND_fvalbind_opt) 
) end
)
 in (LrTable.NT 39,(result,fmatch1left,AND_fvalbind_opt1right),rest671
) end
| (115,(_,(MlyValue.fvalbind fvalbind1,_,fvalbind1right))::(_,(_,
AND1left,_))::rest671) => let val result=MlyValue.AND_fvalbind_opt(fn 
_ => let val fvalbind as fvalbind1=fvalbind1 ()
 in ( SOME fvalbind ) end
)
 in (LrTable.NT 40,(result,AND1left,fvalbind1right),rest671) end
| (116,rest671) => let val result=MlyValue.AND_fvalbind_opt(fn _ => (
 NONE ))
 in (LrTable.NT 40,(result,defaultPos,defaultPos),rest671) end
| (117,(_,(MlyValue.BAR_fmatch_opt BAR_fmatch_opt1,_,
BAR_fmatch_optright as BAR_fmatch_opt1right))::(_,(MlyValue.fmrule 
fmrule1,fmruleleft as fmrule1left,_))::rest671) => let val result=
MlyValue.fmatch(fn _ => let val fmrule as fmrule1=fmrule1 ()
val BAR_fmatch_opt as BAR_fmatch_opt1=BAR_fmatch_opt1 ()
 in (
 Fmatch(I(fmruleleft,BAR_fmatch_optright),
                                 fmrule, BAR_fmatch_opt) 
) end
)
 in (LrTable.NT 41,(result,fmrule1left,BAR_fmatch_opt1right),rest671)
 end
| (118,(_,(MlyValue.fmatch fmatch1,_,fmatch1right))::(_,(_,BAR1left,_)
)::rest671) => let val result=MlyValue.BAR_fmatch_opt(fn _ => let val 
fmatch as fmatch1=fmatch1 ()
 in ( SOME fmatch ) end
)
 in (LrTable.NT 42,(result,BAR1left,fmatch1right),rest671) end
| (119,rest671) => let val result=MlyValue.BAR_fmatch_opt(fn _ => (
 NONE ))
 in (LrTable.NT 42,(result,defaultPos,defaultPos),rest671) end
| (120,(_,(MlyValue.exp exp1,_,expright as exp1right))::_::(_,(
MlyValue.COLON_ty_opt COLON_ty_opt1,_,_))::(_,(MlyValue.atpat_list1 
atpat_list11,atpat_list1left as atpat_list11left,_))::rest671) => let 
val result=MlyValue.fmrule(fn _ => let val atpat_list1 as atpat_list11
=atpat_list11 ()
val COLON_ty_opt as COLON_ty_opt1=COLON_ty_opt1 ()
val exp as exp1=exp1 ()
 in (
 let
                            val (op_opt, vid, atpats) =
                                Infix.parseFmrule(!J, atpat_list1)
                          in
                            Fmrule(I(atpat_list1left,expright),
                                   op_opt, vid, atpats, COLON_ty_opt, exp)
                          end 
) end
)
 in (LrTable.NT 43,(result,atpat_list11left,exp1right),rest671) end
| (121,(_,(MlyValue.AND_typbind_opt AND_typbind_opt1,_,
AND_typbind_optright as AND_typbind_opt1right))::(_,(MlyValue.ty ty1,_
,_))::_::(_,(MlyValue.tycon tycon1,_,_))::(_,(MlyValue.tyvarseq 
tyvarseq1,tyvarseqleft as tyvarseq1left,_))::rest671) => let val 
result=MlyValue.typbind(fn _ => let val tyvarseq as tyvarseq1=
tyvarseq1 ()
val tycon as tycon1=tycon1 ()
val ty as ty1=ty1 ()
val AND_typbind_opt as AND_typbind_opt1=AND_typbind_opt1 ()
 in (
 TypBind(I(tyvarseqleft,AND_typbind_optright),
                                  tyvarseq, tycon, ty, AND_typbind_opt) 
) end
)
 in (LrTable.NT 44,(result,tyvarseq1left,AND_typbind_opt1right),
rest671) end
| (122,(_,(MlyValue.typbind typbind1,_,typbind1right))::(_,(_,AND1left
,_))::rest671) => let val result=MlyValue.AND_typbind_opt(fn _ => let 
val typbind as typbind1=typbind1 ()
 in ( SOME typbind ) end
)
 in (LrTable.NT 45,(result,AND1left,typbind1right),rest671) end
| (123,rest671) => let val result=MlyValue.AND_typbind_opt(fn _ => (
 NONE ))
 in (LrTable.NT 45,(result,defaultPos,defaultPos),rest671) end
| (124,(_,(MlyValue.AND_datbind_opt AND_datbind_opt1,_,
AND_datbind_optright as AND_datbind_opt1right))::(_,(MlyValue.conbind 
conbind1,_,_))::_::(_,(MlyValue.tycon tycon1,_,_))::(_,(
MlyValue.tyvarseq tyvarseq1,tyvarseqleft as tyvarseq1left,_))::rest671
) => let val result=MlyValue.datbind(fn _ => let val tyvarseq as 
tyvarseq1=tyvarseq1 ()
val tycon as tycon1=tycon1 ()
val conbind as conbind1=conbind1 ()
val AND_datbind_opt as AND_datbind_opt1=AND_datbind_opt1 ()
 in (
 DatBind(I(tyvarseqleft,AND_datbind_optright),
                                  tyvarseq, tycon, conbind, AND_datbind_opt) 
) end
)
 in (LrTable.NT 46,(result,tyvarseq1left,AND_datbind_opt1right),
rest671) end
| (125,(_,(MlyValue.AND_datbind_opt AND_datbind_opt1,_,
AND_datbind_optright as AND_datbind_opt1right))::(_,(MlyValue.conbind 
conbind1,_,_))::_::(_,(MlyValue.tycon tycon1,tyconleft as tycon1left,_
))::rest671) => let val result=MlyValue.datbind0(fn _ => let val tycon
 as tycon1=tycon1 ()
val conbind as conbind1=conbind1 ()
val AND_datbind_opt as AND_datbind_opt1=AND_datbind_opt1 ()
 in (
 DatBind(I(tyconleft,AND_datbind_optright),
                                  TyVarseq(I(defaultPos,defaultPos), []),
                                  tycon, conbind, AND_datbind_opt) 
) end
)
 in (LrTable.NT 47,(result,tycon1left,AND_datbind_opt1right),rest671)
 end
| (126,(_,(MlyValue.AND_datbind_opt AND_datbind_opt1,_,
AND_datbind_optright as AND_datbind_opt1right))::(_,(MlyValue.conbind 
conbind1,_,_))::_::(_,(MlyValue.tycon tycon1,_,_))::(_,(
MlyValue.tyvarseq1 tyvarseq11,tyvarseq1left as tyvarseq11left,_))::
rest671) => let val result=MlyValue.datbind1(fn _ => let val tyvarseq1
 as tyvarseq11=tyvarseq11 ()
val tycon as tycon1=tycon1 ()
val conbind as conbind1=conbind1 ()
val AND_datbind_opt as AND_datbind_opt1=AND_datbind_opt1 ()
 in (
 DatBind(I(tyvarseq1left,AND_datbind_optright),
                                  tyvarseq1, tycon, conbind, AND_datbind_opt) 
) end
)
 in (LrTable.NT 48,(result,tyvarseq11left,AND_datbind_opt1right),
rest671) end
| (127,(_,(MlyValue.datbind datbind1,_,datbind1right))::(_,(_,AND1left
,_))::rest671) => let val result=MlyValue.AND_datbind_opt(fn _ => let 
val datbind as datbind1=datbind1 ()
 in ( SOME datbind ) end
)
 in (LrTable.NT 49,(result,AND1left,datbind1right),rest671) end
| (128,rest671) => let val result=MlyValue.AND_datbind_opt(fn _ => (
 NONE ))
 in (LrTable.NT 49,(result,defaultPos,defaultPos),rest671) end
| (129,(_,(MlyValue.BAR_conbind_opt BAR_conbind_opt1,_,
BAR_conbind_optright as BAR_conbind_opt1right))::(_,(
MlyValue.OF_ty_opt OF_ty_opt1,_,_))::(_,(MlyValue.vid' vid'1,_,_))::(_
,(MlyValue.OP_opt OP_opt1,OP_optleft as OP_opt1left,_))::rest671) => 
let val result=MlyValue.conbind(fn _ => let val OP_opt as OP_opt1=
OP_opt1 ()
val vid' as vid'1=vid'1 ()
val OF_ty_opt as OF_ty_opt1=OF_ty_opt1 ()
val BAR_conbind_opt as BAR_conbind_opt1=BAR_conbind_opt1 ()
 in (
 ConBind(I(OP_optleft,BAR_conbind_optright),
                                  OP_opt, vid', OF_ty_opt, BAR_conbind_opt) 
) end
)
 in (LrTable.NT 50,(result,OP_opt1left,BAR_conbind_opt1right),rest671)
 end
| (130,(_,(MlyValue.conbind conbind1,_,conbind1right))::(_,(_,BAR1left
,_))::rest671) => let val result=MlyValue.BAR_conbind_opt(fn _ => let 
val conbind as conbind1=conbind1 ()
 in ( SOME conbind ) end
)
 in (LrTable.NT 51,(result,BAR1left,conbind1right),rest671) end
| (131,rest671) => let val result=MlyValue.BAR_conbind_opt(fn _ => (
 NONE ))
 in (LrTable.NT 51,(result,defaultPos,defaultPos),rest671) end
| (132,(_,(MlyValue.ty ty1,_,ty1right))::(_,(_,OF1left,_))::rest671)
 => let val result=MlyValue.OF_ty_opt(fn _ => let val ty as ty1=ty1 ()
 in ( SOME ty ) end
)
 in (LrTable.NT 52,(result,OF1left,ty1right),rest671) end
| (133,rest671) => let val result=MlyValue.OF_ty_opt(fn _ => ( NONE ))
 in (LrTable.NT 52,(result,defaultPos,defaultPos),rest671) end
| (134,(_,(MlyValue.AND_exbind_opt AND_exbind_opt1,_,
AND_exbind_optright as AND_exbind_opt1right))::(_,(MlyValue.OF_ty_opt 
OF_ty_opt1,_,_))::(_,(MlyValue.vid' vid'1,_,_))::(_,(MlyValue.OP_opt 
OP_opt1,OP_optleft as OP_opt1left,_))::rest671) => let val result=
MlyValue.exbind(fn _ => let val OP_opt as OP_opt1=OP_opt1 ()
val vid' as vid'1=vid'1 ()
val OF_ty_opt as OF_ty_opt1=OF_ty_opt1 ()
val AND_exbind_opt as AND_exbind_opt1=AND_exbind_opt1 ()
 in (
 NEWExBind(I(OP_optleft,AND_exbind_optright),
                                    OP_opt, vid', OF_ty_opt, AND_exbind_opt) 
) end
)
 in (LrTable.NT 53,(result,OP_opt1left,AND_exbind_opt1right),rest671)
 end
| (135,(_,(MlyValue.AND_exbind_opt AND_exbind_opt1,_,
AND_exbind_optright as AND_exbind_opt1right))::(_,(MlyValue.longvid 
longvid1,_,_))::(_,(MlyValue.OP_opt OP_opt2,_,_))::_::(_,(
MlyValue.vid' vid'1,_,_))::(_,(MlyValue.OP_opt OP_opt1,OP_opt1left,_))
::rest671) => let val result=MlyValue.exbind(fn _ => let val OP_opt1=
OP_opt1 ()
val vid' as vid'1=vid'1 ()
val OP_opt2=OP_opt2 ()
val longvid as longvid1=longvid1 ()
val AND_exbind_opt as AND_exbind_opt1=AND_exbind_opt1 ()
 in (
 EQUALExBind(I(OP_opt1left,AND_exbind_optright),
                                      OP_opt1, vid', OP_opt2, longvid,
                                      AND_exbind_opt) 
) end
)
 in (LrTable.NT 53,(result,OP_opt1left,AND_exbind_opt1right),rest671)
 end
| (136,(_,(MlyValue.exbind exbind1,_,exbind1right))::(_,(_,AND1left,_)
)::rest671) => let val result=MlyValue.AND_exbind_opt(fn _ => let val 
exbind as exbind1=exbind1 ()
 in ( SOME exbind ) end
)
 in (LrTable.NT 54,(result,AND1left,exbind1right),rest671) end
| (137,rest671) => let val result=MlyValue.AND_exbind_opt(fn _ => (
 NONE ))
 in (LrTable.NT 54,(result,defaultPos,defaultPos),rest671) end
| (138,(_,(MlyValue.atpat' atpat'1,atpat'1left,atpat'1right))::rest671
) => let val result=MlyValue.atpat(fn _ => let val atpat' as atpat'1=
atpat'1 ()
 in ( atpat' ) end
)
 in (LrTable.NT 55,(result,atpat'1left,atpat'1right),rest671) end
| (139,(_,(MlyValue.longvid' longvid'1,_,longvid'right as 
longvid'1right))::(_,(MlyValue.OP_opt OP_opt1,OP_optleft as 
OP_opt1left,_))::rest671) => let val result=MlyValue.atpat(fn _ => 
let val OP_opt as OP_opt1=OP_opt1 ()
val longvid' as longvid'1=longvid'1 ()
 in (
 LONGVIDAtPat(I(OP_optleft,longvid'right),
                                       OP_opt, longvid') 
) end
)
 in (LrTable.NT 55,(result,OP_opt1left,longvid'1right),rest671) end
| (140,(_,(_,UNDERBARleft as UNDERBAR1left,UNDERBARright as 
UNDERBAR1right))::rest671) => let val result=MlyValue.atpat'(fn _ => (
 WILDCARDAtPat(I(UNDERBARleft,UNDERBARright)) ))
 in (LrTable.NT 56,(result,UNDERBAR1left,UNDERBAR1right),rest671) end
| (141,(_,(MlyValue.scon scon1,sconleft as scon1left,sconright as 
scon1right))::rest671) => let val result=MlyValue.atpat'(fn _ => let 
val scon as scon1=scon1 ()
 in ( SCONAtPat(I(sconleft,sconright), scon) ) end
)
 in (LrTable.NT 56,(result,scon1left,scon1right),rest671) end
| (142,(_,(_,_,RBRACEright as RBRACE1right))::(_,(MlyValue.patrow_opt 
patrow_opt1,_,_))::(_,(_,LBRACEleft as LBRACE1left,_))::rest671) => 
let val result=MlyValue.atpat'(fn _ => let val patrow_opt as 
patrow_opt1=patrow_opt1 ()
 in ( RECORDAtPat(I(LBRACEleft,RBRACEright), patrow_opt) ) end
)
 in (LrTable.NT 56,(result,LBRACE1left,RBRACE1right),rest671) end
| (143,(_,(_,_,RPARright as RPAR1right))::(_,(_,LPARleft as LPAR1left,
_))::rest671) => let val result=MlyValue.atpat'(fn _ => (
 UNITAtPat(I(LPARleft,RPARright)) ))
 in (LrTable.NT 56,(result,LPAR1left,RPAR1right),rest671) end
| (144,(_,(_,_,RPARright as RPAR1right))::(_,(MlyValue.pat_COMMA_list2
 pat_COMMA_list21,_,_))::(_,(_,LPARleft as LPAR1left,_))::rest671) => 
let val result=MlyValue.atpat'(fn _ => let val pat_COMMA_list2 as 
pat_COMMA_list21=pat_COMMA_list21 ()
 in ( TUPLEAtPat(I(LPARleft,RPARright), pat_COMMA_list2) ) end
)
 in (LrTable.NT 56,(result,LPAR1left,RPAR1right),rest671) end
| (145,(_,(_,_,RBRACKright as RBRACK1right))::(_,(
MlyValue.pat_COMMA_list0 pat_COMMA_list01,_,_))::(_,(_,LBRACKleft as 
LBRACK1left,_))::rest671) => let val result=MlyValue.atpat'(fn _ => 
let val pat_COMMA_list0 as pat_COMMA_list01=pat_COMMA_list01 ()
 in ( LISTAtPat(I(LBRACKleft,RBRACKright),
                                    pat_COMMA_list0) )
 end
)
 in (LrTable.NT 56,(result,LBRACK1left,RBRACK1right),rest671) end
| (146,(_,(_,_,RPARright as RPAR1right))::(_,(MlyValue.pat pat1,_,_))
::(_,(_,LPARleft as LPAR1left,_))::rest671) => let val result=
MlyValue.atpat'(fn _ => let val pat as pat1=pat1 ()
 in ( PARAtPat(I(LPARleft,RPARright), pat) ) end
)
 in (LrTable.NT 56,(result,LPAR1left,RPAR1right),rest671) end
| (147,(_,(MlyValue.pat_COMMA_list1 pat_COMMA_list11,
pat_COMMA_list11left,pat_COMMA_list11right))::rest671) => let val 
result=MlyValue.pat_COMMA_list0(fn _ => let val pat_COMMA_list1 as 
pat_COMMA_list11=pat_COMMA_list11 ()
 in ( pat_COMMA_list1 ) end
)
 in (LrTable.NT 57,(result,pat_COMMA_list11left,pat_COMMA_list11right)
,rest671) end
| (148,rest671) => let val result=MlyValue.pat_COMMA_list0(fn _ => (
 [] ))
 in (LrTable.NT 57,(result,defaultPos,defaultPos),rest671) end
| (149,(_,(MlyValue.pat_COMMA_list1 pat_COMMA_list11,_,
pat_COMMA_list11right))::_::(_,(MlyValue.pat pat1,pat1left,_))::
rest671) => let val result=MlyValue.pat_COMMA_list1(fn _ => let val 
pat as pat1=pat1 ()
val pat_COMMA_list1 as pat_COMMA_list11=pat_COMMA_list11 ()
 in ( pat::pat_COMMA_list1 ) end
)
 in (LrTable.NT 58,(result,pat1left,pat_COMMA_list11right),rest671)
 end
| (150,(_,(MlyValue.pat pat1,pat1left,pat1right))::rest671) => let 
val result=MlyValue.pat_COMMA_list1(fn _ => let val pat as pat1=pat1 
()
 in ( pat::[] ) end
)
 in (LrTable.NT 58,(result,pat1left,pat1right),rest671) end
| (151,(_,(MlyValue.pat_COMMA_list1 pat_COMMA_list11,_,
pat_COMMA_list11right))::_::(_,(MlyValue.pat pat1,pat1left,_))::
rest671) => let val result=MlyValue.pat_COMMA_list2(fn _ => let val 
pat as pat1=pat1 ()
val pat_COMMA_list1 as pat_COMMA_list11=pat_COMMA_list11 ()
 in ( pat::pat_COMMA_list1 ) end
)
 in (LrTable.NT 59,(result,pat1left,pat_COMMA_list11right),rest671)
 end
| (152,(_,(_,DOTSleft as DOTS1left,DOTSright as DOTS1right))::rest671)
 => let val result=MlyValue.patrow(fn _ => (
 WILDCARDPatRow(I(DOTSleft,DOTSright)) ))
 in (LrTable.NT 60,(result,DOTS1left,DOTS1right),rest671) end
| (153,(_,(MlyValue.COMMA_patrow_opt COMMA_patrow_opt1,_,
COMMA_patrow_optright as COMMA_patrow_opt1right))::(_,(MlyValue.pat 
pat1,_,_))::_::(_,(MlyValue.lab lab1,lableft as lab1left,_))::rest671)
 => let val result=MlyValue.patrow(fn _ => let val lab as lab1=lab1 ()
val pat as pat1=pat1 ()
val COMMA_patrow_opt as COMMA_patrow_opt1=COMMA_patrow_opt1 ()
 in (
 ROWPatRow(I(lableft,COMMA_patrow_optright),
                                      lab, pat, COMMA_patrow_opt) 
) end
)
 in (LrTable.NT 60,(result,lab1left,COMMA_patrow_opt1right),rest671)
 end
| (154,(_,(MlyValue.COMMA_patrow_opt COMMA_patrow_opt1,_,
COMMA_patrow_optright as COMMA_patrow_opt1right))::(_,(
MlyValue.AS_pat_opt AS_pat_opt1,_,_))::(_,(MlyValue.COLON_ty_opt 
COLON_ty_opt1,_,_))::(_,(MlyValue.vid' vid'1,vid'left as vid'1left,_))
::rest671) => let val result=MlyValue.patrow(fn _ => let val vid' as 
vid'1=vid'1 ()
val COLON_ty_opt as COLON_ty_opt1=COLON_ty_opt1 ()
val AS_pat_opt as AS_pat_opt1=AS_pat_opt1 ()
val COMMA_patrow_opt as COMMA_patrow_opt1=COMMA_patrow_opt1 ()
 in (
 VIDPatRow(I(vid'left,COMMA_patrow_optright),
                                    vid', COLON_ty_opt, AS_pat_opt,
                                    COMMA_patrow_opt) 
) end
)
 in (LrTable.NT 60,(result,vid'1left,COMMA_patrow_opt1right),rest671)
 end
| (155,(_,(MlyValue.patrow patrow1,_,patrow1right))::(_,(_,COMMA1left,
_))::rest671) => let val result=MlyValue.COMMA_patrow_opt(fn _ => let 
val patrow as patrow1=patrow1 ()
 in ( SOME patrow ) end
)
 in (LrTable.NT 62,(result,COMMA1left,patrow1right),rest671) end
| (156,rest671) => let val result=MlyValue.COMMA_patrow_opt(fn _ => (
 NONE ))
 in (LrTable.NT 62,(result,defaultPos,defaultPos),rest671) end
| (157,(_,(MlyValue.ty ty1,_,ty1right))::(_,(_,COLON1left,_))::rest671
) => let val result=MlyValue.COLON_ty_opt(fn _ => let val ty as ty1=
ty1 ()
 in ( SOME ty ) end
)
 in (LrTable.NT 63,(result,COLON1left,ty1right),rest671) end
| (158,rest671) => let val result=MlyValue.COLON_ty_opt(fn _ => (
 NONE ))
 in (LrTable.NT 63,(result,defaultPos,defaultPos),rest671) end
| (159,(_,(MlyValue.pat pat1,_,pat1right))::(_,(_,AS1left,_))::rest671
) => let val result=MlyValue.AS_pat_opt(fn _ => let val pat as pat1=
pat1 ()
 in ( SOME pat ) end
)
 in (LrTable.NT 64,(result,AS1left,pat1right),rest671) end
| (160,rest671) => let val result=MlyValue.AS_pat_opt(fn _ => ( NONE )
)
 in (LrTable.NT 64,(result,defaultPos,defaultPos),rest671) end
| (161,(_,(MlyValue.patrow patrow1,patrow1left,patrow1right))::rest671
) => let val result=MlyValue.patrow_opt(fn _ => let val patrow as 
patrow1=patrow1 ()
 in ( SOME patrow ) end
)
 in (LrTable.NT 61,(result,patrow1left,patrow1right),rest671) end
| (162,rest671) => let val result=MlyValue.patrow_opt(fn _ => ( NONE )
)
 in (LrTable.NT 61,(result,defaultPos,defaultPos),rest671) end
| (163,(_,(MlyValue.atpat atpat1,atpat1left,atpat1right))::rest671)
 => let val result=MlyValue.pat(fn _ => let val atpat as atpat1=atpat1
 ()
 in ( Infix.parsePat(!J, [atpat]) ) end
)
 in (LrTable.NT 65,(result,atpat1left,atpat1right),rest671) end
| (164,(_,(MlyValue.atpat_list2 atpat_list21,atpat_list21left,
atpat_list21right))::rest671) => let val result=MlyValue.pat(fn _ => 
let val atpat_list2 as atpat_list21=atpat_list21 ()
 in ( Infix.parsePat(!J, atpat_list2) ) end
)
 in (LrTable.NT 65,(result,atpat_list21left,atpat_list21right),rest671
) end
| (165,(_,(MlyValue.COLON_ty_list1 COLON_ty_list11,_,
COLON_ty_list11right))::(_,(MlyValue.atpat' atpat'1,atpat'1left,_))::
rest671) => let val result=MlyValue.pat(fn _ => let val atpat' as 
atpat'1=atpat'1 ()
val COLON_ty_list1 as COLON_ty_list11=COLON_ty_list11 ()
 in (
 let val pat = Infix.parsePat(!J, [atpat'])
                          in typedPat(pat, COLON_ty_list1) end 
) end
)
 in (LrTable.NT 65,(result,atpat'1left,COLON_ty_list11right),rest671)
 end
| (166,(_,(MlyValue.COLON_ty_list1 COLON_ty_list11,_,
COLON_ty_list11right))::(_,(MlyValue.atpat_list2 atpat_list21,
atpat_list21left,_))::rest671) => let val result=MlyValue.pat(fn _ => 
let val atpat_list2 as atpat_list21=atpat_list21 ()
val COLON_ty_list1 as COLON_ty_list11=COLON_ty_list11 ()
 in (
 let val pat = Infix.parsePat(!J, atpat_list2)
                          in typedPat(pat, COLON_ty_list1) end 
) end
)
 in (LrTable.NT 65,(result,atpat_list21left,COLON_ty_list11right),
rest671) end
| (167,(_,(MlyValue.COLON_ty_list1 COLON_ty_list11,_,
COLON_ty_list11right))::(_,(MlyValue.vid' vid'1,_,vid'right))::(_,(
MlyValue.OP_opt OP_opt1,OP_optleft as OP_opt1left,_))::rest671) => 
let val result=MlyValue.pat(fn _ => let val OP_opt as OP_opt1=OP_opt1 
()
val vid' as vid'1=vid'1 ()
val COLON_ty_list1 as COLON_ty_list11=COLON_ty_list11 ()
 in (
 let val atpat = LONGVIDAtPat(I(OP_optleft,vid'right),
                                                       OP_opt,
                                                       LongVId.fromId vid')
                              val pat   = Infix.parsePat(!J, [atpat])
                          in typedPat(pat, COLON_ty_list1) end 
) end
)
 in (LrTable.NT 65,(result,OP_opt1left,COLON_ty_list11right),rest671)
 end
| (168,(_,(MlyValue.COLON_ty_list1 COLON_ty_list11,_,
COLON_ty_list11right))::(_,(MlyValue.LONGID LONGID1,_,LONGIDright))::(
_,(MlyValue.OP_opt OP_opt1,OP_optleft as OP_opt1left,_))::rest671) => 
let val result=MlyValue.pat(fn _ => let val OP_opt as OP_opt1=OP_opt1 
()
val LONGID as LONGID1=LONGID1 ()
val COLON_ty_list1 as COLON_ty_list11=COLON_ty_list11 ()
 in (
 let val longvid = LongVId.implode
                                                (toLongId VId.fromString LONGID)
                              val atpat = LONGVIDAtPat(I(OP_optleft,LONGIDright),
                                                       OP_opt, longvid)
                              val pat   = Infix.parsePat(!J, [atpat])
                          in typedPat(pat, COLON_ty_list1) end 
) end
)
 in (LrTable.NT 65,(result,OP_opt1left,COLON_ty_list11right),rest671)
 end
| (169,(_,(MlyValue.pat pat1,_,patright as pat1right))::_::(_,(
MlyValue.COLON_ty_opt COLON_ty_opt1,_,_))::(_,(MlyValue.vid' vid'1,_,
vid'right))::(_,(MlyValue.OP_opt OP_opt1,OP_optleft as OP_opt1left,_))
::rest671) => let val result=MlyValue.pat(fn _ => let val OP_opt as 
OP_opt1=OP_opt1 ()
val vid' as vid'1=vid'1 ()
val COLON_ty_opt as COLON_ty_opt1=COLON_ty_opt1 ()
val pat as pat1=pat1 ()
 in (
 Infix.parsePat(!J,
                                 [ LONGVIDAtPat(I(OP_optleft,vid'right),
                                                OP_opt,
                                                LongVId.implode([],vid')) ] ) ;
                          ASPat(I(OP_optleft,patright),
                                OP_opt, vid', COLON_ty_opt, pat) 
) end
)
 in (LrTable.NT 65,(result,OP_opt1left,pat1right),rest671) end
| (170,(_,(MlyValue.atpat_list1 atpat_list11,_,atpat_list11right))::(_
,(MlyValue.atpat atpat1,atpat1left,_))::rest671) => let val result=
MlyValue.atpat_list1(fn _ => let val atpat as atpat1=atpat1 ()
val atpat_list1 as atpat_list11=atpat_list11 ()
 in ( atpat::atpat_list1 ) end
)
 in (LrTable.NT 66,(result,atpat1left,atpat_list11right),rest671) end
| (171,(_,(MlyValue.atpat atpat1,atpat1left,atpat1right))::rest671)
 => let val result=MlyValue.atpat_list1(fn _ => let val atpat as 
atpat1=atpat1 ()
 in ( atpat::[] ) end
)
 in (LrTable.NT 66,(result,atpat1left,atpat1right),rest671) end
| (172,(_,(MlyValue.atpat_list1 atpat_list11,_,atpat_list11right))::(_
,(MlyValue.atpat atpat1,atpat1left,_))::rest671) => let val result=
MlyValue.atpat_list2(fn _ => let val atpat as atpat1=atpat1 ()
val atpat_list1 as atpat_list11=atpat_list11 ()
 in ( atpat::atpat_list1 ) end
)
 in (LrTable.NT 67,(result,atpat1left,atpat_list11right),rest671) end
| (173,(_,(MlyValue.COLON_ty_list1 COLON_ty_list11,_,
COLON_ty_list11right))::(_,(MlyValue.ty ty1,_,_))::(_,(_,COLON1left,_)
)::rest671) => let val result=MlyValue.COLON_ty_list1(fn _ => let val 
ty as ty1=ty1 ()
val COLON_ty_list1 as COLON_ty_list11=COLON_ty_list11 ()
 in ( ty::COLON_ty_list1 ) end
)
 in (LrTable.NT 68,(result,COLON1left,COLON_ty_list11right),rest671)
 end
| (174,(_,(MlyValue.ty ty1,_,ty1right))::(_,(_,COLON1left,_))::rest671
) => let val result=MlyValue.COLON_ty_list1(fn _ => let val ty as ty1=
ty1 ()
 in ( ty::[] ) end
)
 in (LrTable.NT 68,(result,COLON1left,ty1right),rest671) end
| (175,(_,(MlyValue.tupty tupty1,tupty1left,tupty1right))::rest671)
 => let val result=MlyValue.ty(fn _ => let val tupty as tupty1=tupty1 
()
 in ( tupty ) end
)
 in (LrTable.NT 69,(result,tupty1left,tupty1right),rest671) end
| (176,(_,(MlyValue.ty ty1,_,tyright as ty1right))::_::(_,(
MlyValue.tupty tupty1,tuptyleft as tupty1left,_))::rest671) => let 
val result=MlyValue.ty(fn _ => let val tupty as tupty1=tupty1 ()
val ty as ty1=ty1 ()
 in ( ARROWTy(I(tuptyleft,tyright), tupty, ty) ) end
)
 in (LrTable.NT 69,(result,tupty1left,ty1right),rest671) end
| (177,(_,(MlyValue.ty_STAR_list ty_STAR_list1,ty_STAR_listleft as 
ty_STAR_list1left,ty_STAR_listright as ty_STAR_list1right))::rest671)
 => let val result=MlyValue.tupty(fn _ => let val ty_STAR_list as 
ty_STAR_list1=ty_STAR_list1 ()
 in (
 TUPLETy(I(ty_STAR_listleft,ty_STAR_listright),
                                   ty_STAR_list) )
 end
)
 in (LrTable.NT 70,(result,ty_STAR_list1left,ty_STAR_list1right),
rest671) end
| (178,(_,(MlyValue.ty_STAR_list ty_STAR_list1,_,ty_STAR_list1right))
::_::(_,(MlyValue.consty consty1,consty1left,_))::rest671) => let val 
result=MlyValue.ty_STAR_list(fn _ => let val consty as consty1=consty1
 ()
val ty_STAR_list as ty_STAR_list1=ty_STAR_list1 ()
 in ( consty::ty_STAR_list ) end
)
 in (LrTable.NT 71,(result,consty1left,ty_STAR_list1right),rest671)
 end
| (179,(_,(MlyValue.consty consty1,consty1left,consty1right))::rest671
) => let val result=MlyValue.ty_STAR_list(fn _ => let val consty as 
consty1=consty1 ()
 in ( consty::[] ) end
)
 in (LrTable.NT 71,(result,consty1left,consty1right),rest671) end
| (180,(_,(MlyValue.atty atty1,atty1left,atty1right))::rest671) => 
let val result=MlyValue.consty(fn _ => let val atty as atty1=atty1 ()
 in ( atty ) end
)
 in (LrTable.NT 72,(result,atty1left,atty1right),rest671) end
| (181,(_,(MlyValue.longtycon longtycon1,_,longtyconright as 
longtycon1right))::(_,(MlyValue.tyseq tyseq1,tyseqleft as tyseq1left,_
))::rest671) => let val result=MlyValue.consty(fn _ => let val tyseq
 as tyseq1=tyseq1 ()
val longtycon as longtycon1=longtycon1 ()
 in ( TYCONTy(I(tyseqleft,longtyconright),
                                          tyseq, longtycon) )
 end
)
 in (LrTable.NT 72,(result,tyseq1left,longtycon1right),rest671) end
| (182,(_,(MlyValue.tyvar tyvar1,tyvarleft as tyvar1left,tyvarright
 as tyvar1right))::rest671) => let val result=MlyValue.atty(fn _ => 
let val tyvar as tyvar1=tyvar1 ()
 in ( TYVARTy(I(tyvarleft,tyvarright), tyvar) ) end
)
 in (LrTable.NT 73,(result,tyvar1left,tyvar1right),rest671) end
| (183,(_,(_,_,RBRACEright as RBRACE1right))::(_,(MlyValue.tyrow_opt 
tyrow_opt1,_,_))::(_,(_,LBRACEleft as LBRACE1left,_))::rest671) => 
let val result=MlyValue.atty(fn _ => let val tyrow_opt as tyrow_opt1=
tyrow_opt1 ()
 in ( RECORDTy(I(LBRACEleft,RBRACEright), tyrow_opt) ) end
)
 in (LrTable.NT 73,(result,LBRACE1left,RBRACE1right),rest671) end
| (184,(_,(_,_,RPARright as RPAR1right))::(_,(MlyValue.ty ty1,_,_))::(
_,(_,LPARleft as LPAR1left,_))::rest671) => let val result=
MlyValue.atty(fn _ => let val ty as ty1=ty1 ()
 in ( PARTy(I(LPARleft,RPARright), ty) ) end
)
 in (LrTable.NT 73,(result,LPAR1left,RPAR1right),rest671) end
| (185,(_,(MlyValue.COMMA_tyrow_opt COMMA_tyrow_opt1,_,
COMMA_tyrow_optright as COMMA_tyrow_opt1right))::(_,(MlyValue.ty ty1,_
,_))::_::(_,(MlyValue.lab lab1,lableft as lab1left,_))::rest671) => 
let val result=MlyValue.tyrow(fn _ => let val lab as lab1=lab1 ()
val ty as ty1=ty1 ()
val COMMA_tyrow_opt as COMMA_tyrow_opt1=COMMA_tyrow_opt1 ()
 in (
 TyRow(I(lableft,COMMA_tyrow_optright),
                                lab, ty, COMMA_tyrow_opt) 
) end
)
 in (LrTable.NT 74,(result,lab1left,COMMA_tyrow_opt1right),rest671)
 end
| (186,(_,(MlyValue.tyrow tyrow1,_,tyrow1right))::(_,(_,COMMA1left,_))
::rest671) => let val result=MlyValue.COMMA_tyrow_opt(fn _ => let val 
tyrow as tyrow1=tyrow1 ()
 in ( SOME tyrow ) end
)
 in (LrTable.NT 76,(result,COMMA1left,tyrow1right),rest671) end
| (187,rest671) => let val result=MlyValue.COMMA_tyrow_opt(fn _ => (
 NONE ))
 in (LrTable.NT 76,(result,defaultPos,defaultPos),rest671) end
| (188,(_,(MlyValue.tyrow tyrow1,tyrow1left,tyrow1right))::rest671)
 => let val result=MlyValue.tyrow_opt(fn _ => let val tyrow as tyrow1=
tyrow1 ()
 in ( SOME tyrow ) end
)
 in (LrTable.NT 75,(result,tyrow1left,tyrow1right),rest671) end
| (189,rest671) => let val result=MlyValue.tyrow_opt(fn _ => ( NONE ))
 in (LrTable.NT 75,(result,defaultPos,defaultPos),rest671) end
| (190,(_,(MlyValue.consty consty1,constyleft as consty1left,
constyright as consty1right))::rest671) => let val result=
MlyValue.tyseq(fn _ => let val consty as consty1=consty1 ()
 in ( Tyseq(I(constyleft,constyright),
                                                [consty]) ) end
)
 in (LrTable.NT 77,(result,consty1left,consty1right),rest671) end
| (191,rest671) => let val result=MlyValue.tyseq(fn _ => (
 Tyseq(I(defaultPos,defaultPos), []) ))
 in (LrTable.NT 77,(result,defaultPos,defaultPos),rest671) end
| (192,(_,(_,_,RPARright as RPAR1right))::(_,(MlyValue.ty_COMMA_list2 
ty_COMMA_list21,_,_))::(_,(_,LPARleft as LPAR1left,_))::rest671) => 
let val result=MlyValue.tyseq(fn _ => let val ty_COMMA_list2 as 
ty_COMMA_list21=ty_COMMA_list21 ()
 in ( Tyseq(I(LPARleft,RPARright),
                                                ty_COMMA_list2) ) end
)
 in (LrTable.NT 77,(result,LPAR1left,RPAR1right),rest671) end
| (193,(_,(MlyValue.ty_COMMA_list2 ty_COMMA_list21,_,
ty_COMMA_list21right))::_::(_,(MlyValue.ty ty1,ty1left,_))::rest671)
 => let val result=MlyValue.ty_COMMA_list2(fn _ => let val ty as ty1=
ty1 ()
val ty_COMMA_list2 as ty_COMMA_list21=ty_COMMA_list21 ()
 in ( ty::ty_COMMA_list2 ) end
)
 in (LrTable.NT 78,(result,ty1left,ty_COMMA_list21right),rest671) end
| (194,(_,(MlyValue.ty ty2,_,ty2right))::_::(_,(MlyValue.ty ty1,
ty1left,_))::rest671) => let val result=MlyValue.ty_COMMA_list2(fn _
 => let val ty1=ty1 ()
val ty2=ty2 ()
 in ( [ty1, ty2] ) end
)
 in (LrTable.NT 78,(result,ty1left,ty2right),rest671) end
| (195,(_,(MlyValue.tyvarseq1 tyvarseq11,tyvarseq11left,
tyvarseq11right))::rest671) => let val result=MlyValue.tyvarseq(fn _
 => let val tyvarseq1 as tyvarseq11=tyvarseq11 ()
 in ( tyvarseq1 ) end
)
 in (LrTable.NT 79,(result,tyvarseq11left,tyvarseq11right),rest671)
 end
| (196,rest671) => let val result=MlyValue.tyvarseq(fn _ => (
 TyVarseq(I(defaultPos,defaultPos),
                                                   []) ))
 in (LrTable.NT 79,(result,defaultPos,defaultPos),rest671) end
| (197,(_,(MlyValue.tyvar tyvar1,tyvarleft as tyvar1left,tyvarright
 as tyvar1right))::rest671) => let val result=MlyValue.tyvarseq1(fn _
 => let val tyvar as tyvar1=tyvar1 ()
 in ( TyVarseq(I(tyvarleft,tyvarright),
                                                   [tyvar]) ) end
)
 in (LrTable.NT 80,(result,tyvar1left,tyvar1right),rest671) end
| (198,(_,(_,_,RPARright as RPAR1right))::(_,(
MlyValue.tyvar_COMMA_list1 tyvar_COMMA_list11,_,_))::(_,(_,LPARleft
 as LPAR1left,_))::rest671) => let val result=MlyValue.tyvarseq1(fn _
 => let val tyvar_COMMA_list1 as tyvar_COMMA_list11=tyvar_COMMA_list11
 ()
 in ( TyVarseq(I(LPARleft,RPARright),
                                                   tyvar_COMMA_list1) )
 end
)
 in (LrTable.NT 80,(result,LPAR1left,RPAR1right),rest671) end
| (199,(_,(MlyValue.tyvar_COMMA_list1 tyvar_COMMA_list11,_,
tyvar_COMMA_list11right))::_::(_,(MlyValue.tyvar tyvar1,tyvar1left,_))
::rest671) => let val result=MlyValue.tyvar_COMMA_list1(fn _ => let 
val tyvar as tyvar1=tyvar1 ()
val tyvar_COMMA_list1 as tyvar_COMMA_list11=tyvar_COMMA_list11 ()
 in ( tyvar::tyvar_COMMA_list1 ) end
)
 in (LrTable.NT 81,(result,tyvar1left,tyvar_COMMA_list11right),rest671
) end
| (200,(_,(MlyValue.tyvar tyvar1,tyvar1left,tyvar1right))::rest671)
 => let val result=MlyValue.tyvar_COMMA_list1(fn _ => let val tyvar
 as tyvar1=tyvar1 ()
 in ( tyvar::[] ) end
)
 in (LrTable.NT 81,(result,tyvar1left,tyvar1right),rest671) end
| (201,(_,(MlyValue.strexp' strexp'1,strexp'1left,strexp'1right))::
rest671) => let val result=MlyValue.strexp(fn _ => let val strexp' as 
strexp'1=strexp'1 ()
 in ( strexp' ) end
)
 in (LrTable.NT 82,(result,strexp'1left,strexp'1right),rest671) end
| (202,(_,(MlyValue.sigexp sigexp1,_,sigexpright as sigexp1right))::_
::(_,(MlyValue.strexp strexp1,strexpleft as strexp1left,_))::rest671)
 => let val result=MlyValue.strexp(fn _ => let val strexp as strexp1=
strexp1 ()
val sigexp as sigexp1=sigexp1 ()
 in (
 TRANSStrExp(I(strexpleft,sigexpright),
                                      strexp, sigexp) )
 end
)
 in (LrTable.NT 82,(result,strexp1left,sigexp1right),rest671) end
| (203,(_,(MlyValue.sigexp sigexp1,_,sigexpright as sigexp1right))::_
::(_,(MlyValue.strexp strexp1,strexpleft as strexp1left,_))::rest671)
 => let val result=MlyValue.strexp(fn _ => let val strexp as strexp1=
strexp1 ()
val sigexp as sigexp1=sigexp1 ()
 in ( OPAQStrExp(I(strexpleft,sigexpright), strexp, sigexp)) end
)
 in (LrTable.NT 82,(result,strexp1left,sigexp1right),rest671) end
| (204,(_,(_,_,ENDright as END1right))::(_,(MlyValue.popInfix 
popInfix1,_,_))::(_,(MlyValue.strdec strdec1,_,_))::(_,(
MlyValue.pushInfix pushInfix1,_,_))::(_,(_,STRUCTleft as STRUCT1left,_
))::rest671) => let val result=MlyValue.strexp'(fn _ => let val 
pushInfix1=pushInfix1 ()
val strdec as strdec1=strdec1 ()
val popInfix1=popInfix1 ()
 in ( STRUCTStrExp(I(STRUCTleft,ENDright), strdec) ) end
)
 in (LrTable.NT 83,(result,STRUCT1left,END1right),rest671) end
| (205,(_,(MlyValue.longstrid longstrid1,longstridleft as 
longstrid1left,longstridright as longstrid1right))::rest671) => let 
val result=MlyValue.strexp'(fn _ => let val longstrid as longstrid1=
longstrid1 ()
 in (
 LONGSTRIDStrExp(I(longstridleft,longstridright),
                                          longstrid) )
 end
)
 in (LrTable.NT 83,(result,longstrid1left,longstrid1right),rest671)
 end
| (206,(_,(_,_,RPARright as RPAR1right))::(_,(MlyValue.strexp strexp1,
_,_))::_::(_,(MlyValue.funid funid1,funidleft as funid1left,_))::
rest671) => let val result=MlyValue.strexp'(fn _ => let val funid as 
funid1=funid1 ()
val strexp as strexp1=strexp1 ()
 in ( APPStrExp(I(funidleft,RPARright), funid, strexp) ) end
)
 in (LrTable.NT 83,(result,funid1left,RPAR1right),rest671) end
| (207,(_,(_,_,RPARright as RPAR1right))::(_,(MlyValue.strdec strdec1,
_,_))::_::(_,(MlyValue.funid funid1,funidleft as funid1left,_))::
rest671) => let val result=MlyValue.strexp'(fn _ => let val funid as 
funid1=funid1 ()
val strdec as strdec1=strdec1 ()
 in ( APPDECStrExp(I(funidleft,RPARright), funid, strdec) ) end
)
 in (LrTable.NT 83,(result,funid1left,RPAR1right),rest671) end
| (208,(_,(_,_,ENDright as END1right))::(_,(MlyValue.popInfix 
popInfix1,_,_))::(_,(MlyValue.strexp strexp1,_,_))::_::(_,(
MlyValue.strdec strdec1,_,_))::(_,(MlyValue.pushInfix pushInfix1,_,_))
::(_,(_,LETleft as LET1left,_))::rest671) => let val result=
MlyValue.strexp'(fn _ => let val pushInfix1=pushInfix1 ()
val strdec as strdec1=strdec1 ()
val strexp as strexp1=strexp1 ()
val popInfix1=popInfix1 ()
 in ( LETStrExp(I(LETleft,ENDright), strdec, strexp) ) end
)
 in (LrTable.NT 83,(result,LET1left,END1right),rest671) end
| (209,(_,(MlyValue.strdec1 strdec11,strdec11left,strdec11right))::
rest671) => let val result=MlyValue.strdec(fn _ => let val strdec1 as 
strdec11=strdec11 ()
 in ( strdec1 ) end
)
 in (LrTable.NT 84,(result,strdec11left,strdec11right),rest671) end
| (210,rest671) => let val result=MlyValue.strdec(fn _ => (
 EMPTYStrDec(I(defaultPos,defaultPos)) ))
 in (LrTable.NT 84,(result,defaultPos,defaultPos),rest671) end
| (211,(_,(MlyValue.strdec1' strdec1'1,strdec1'1left,strdec1'1right))
::rest671) => let val result=MlyValue.strdec1(fn _ => let val strdec1'
 as strdec1'1=strdec1'1 ()
 in ( strdec1' ) end
)
 in (LrTable.NT 85,(result,strdec1'1left,strdec1'1right),rest671) end
| (212,(_,(MlyValue.strdec1 strdec12,_,strdec12right))::(_,(
MlyValue.strdec1 strdec11,strdec11left,_))::rest671) => let val result
=MlyValue.strdec1(fn _ => let val strdec11=strdec11 ()
val strdec12=strdec12 ()
 in (
 SEQStrDec(I(strdec11left,strdec12right),
                                    strdec11, strdec12) 
) end
)
 in (LrTable.NT 85,(result,strdec11left,strdec12right),rest671) end
| (213,(_,(_,SEMICOLONleft as SEMICOLON1left,SEMICOLONright as 
SEMICOLON1right))::rest671) => let val result=MlyValue.strdec1(fn _
 => ( EMPTYStrDec(I(SEMICOLONleft,SEMICOLONright)) ))
 in (LrTable.NT 85,(result,SEMICOLON1left,SEMICOLON1right),rest671)
 end
| (214,(_,(MlyValue.dec1' dec1'1,dec1'left as dec1'1left,dec1'right
 as dec1'1right))::rest671) => let val result=MlyValue.strdec1'(fn _
 => let val dec1' as dec1'1=dec1'1 ()
 in ( DECStrDec(I(dec1'left,dec1'right), dec1') ) end
)
 in (LrTable.NT 86,(result,dec1'1left,dec1'1right),rest671) end
| (215,(_,(MlyValue.strbind strbind1,_,strbindright as strbind1right))
::(_,(_,STRUCTUREleft as STRUCTURE1left,_))::rest671) => let val 
result=MlyValue.strdec1'(fn _ => let val strbind as strbind1=strbind1 
()
 in ( STRUCTUREStrDec(I(STRUCTUREleft,strbindright),
                                          strbind) )
 end
)
 in (LrTable.NT 86,(result,STRUCTURE1left,strbind1right),rest671) end
| (216,(_,(_,_,ENDright as END1right))::(_,(MlyValue.popLocalInfix 
popLocalInfix1,_,_))::(_,(MlyValue.strdec strdec2,_,_))::(_,(
MlyValue.pushLocalInfix pushLocalInfix1,_,_))::_::(_,(MlyValue.strdec 
strdec1,_,_))::(_,(MlyValue.pushInfix pushInfix1,_,_))::(_,(_,
LOCALleft as LOCAL1left,_))::rest671) => let val result=
MlyValue.strdec1'(fn _ => let val pushInfix1=pushInfix1 ()
val strdec1=strdec1 ()
val pushLocalInfix1=pushLocalInfix1 ()
val strdec2=strdec2 ()
val popLocalInfix1=popLocalInfix1 ()
 in ( LOCALStrDec(I(LOCALleft,ENDright), strdec1, strdec2) ) end
)
 in (LrTable.NT 86,(result,LOCAL1left,END1right),rest671) end
| (217,(_,(MlyValue.strexp__AND_strbind_opt strexp__AND_strbind_opt1,_
,strexp__AND_strbind_optright as strexp__AND_strbind_opt1right))::_::(
_,(MlyValue.COLON_sigexp_opt COLON_sigexp_opt1,_,_))::(_,(
MlyValue.strid strid1,stridleft as strid1left,_))::rest671) => let 
val result=MlyValue.strbind(fn _ => let val strid as strid1=strid1 ()
val COLON_sigexp_opt as COLON_sigexp_opt1=COLON_sigexp_opt1 ()
val strexp__AND_strbind_opt as strexp__AND_strbind_opt1=
strexp__AND_strbind_opt1 ()
 in (
 TRANSStrBind(I(stridleft,
                                         strexp__AND_strbind_optright),
                                       strid, COLON_sigexp_opt,
                                       #1 strexp__AND_strbind_opt,
                                       #2 strexp__AND_strbind_opt) 
) end
)
 in (LrTable.NT 87,(result,strid1left,strexp__AND_strbind_opt1right),
rest671) end
| (218,(_,(MlyValue.strexp__AND_strbind_opt strexp__AND_strbind_opt1,_
,strexp__AND_strbind_optright as strexp__AND_strbind_opt1right))::_::(
_,(MlyValue.sigexp sigexp1,_,_))::_::(_,(MlyValue.strid strid1,
stridleft as strid1left,_))::rest671) => let val result=
MlyValue.strbind(fn _ => let val strid as strid1=strid1 ()
val sigexp as sigexp1=sigexp1 ()
val strexp__AND_strbind_opt as strexp__AND_strbind_opt1=
strexp__AND_strbind_opt1 ()
 in (
 OPAQStrBind(I(stridleft,strexp__AND_strbind_optright),
                                      strid, sigexp, #1 strexp__AND_strbind_opt,
                                      #2 strexp__AND_strbind_opt) 
) end
)
 in (LrTable.NT 87,(result,strid1left,strexp__AND_strbind_opt1right),
rest671) end
| (219,(_,(MlyValue.strbind strbind1,_,strbind1right))::(_,(_,AND1left
,_))::rest671) => let val result=MlyValue.AND_strbind_opt(fn _ => let 
val strbind as strbind1=strbind1 ()
 in ( SOME strbind ) end
)
 in (LrTable.NT 88,(result,AND1left,strbind1right),rest671) end
| (220,rest671) => let val result=MlyValue.AND_strbind_opt(fn _ => (
 NONE ))
 in (LrTable.NT 88,(result,defaultPos,defaultPos),rest671) end
| (221,(_,(MlyValue.AND_strbind_opt AND_strbind_opt1,_,
AND_strbind_opt1right))::(_,(MlyValue.strexp' strexp'1,strexp'1left,_)
)::rest671) => let val result=MlyValue.strexp__AND_strbind_opt(fn _
 => let val strexp' as strexp'1=strexp'1 ()
val AND_strbind_opt as AND_strbind_opt1=AND_strbind_opt1 ()
 in ( ( strexp', AND_strbind_opt ) ) end
)
 in (LrTable.NT 89,(result,strexp'1left,AND_strbind_opt1right),rest671
) end
| (222,(_,(MlyValue.sigexp__AND_strbind_opt sigexp__AND_strbind_opt1,_
,sigexp__AND_strbind_optright as sigexp__AND_strbind_opt1right))::_::(
_,(MlyValue.strexp strexp1,strexpleft as strexp1left,_))::rest671) => 
let val result=MlyValue.strexp__AND_strbind_opt(fn _ => let val strexp
 as strexp1=strexp1 ()
val sigexp__AND_strbind_opt as sigexp__AND_strbind_opt1=
sigexp__AND_strbind_opt1 ()
 in (
 ( TRANSStrExp(I(strexpleft,
                                          sigexp__AND_strbind_optright),
                                        strexp, #1 sigexp__AND_strbind_opt),
                            #2 sigexp__AND_strbind_opt ) 
) end
)
 in (LrTable.NT 89,(result,strexp1left,sigexp__AND_strbind_opt1right),
rest671) end
| (223,(_,(MlyValue.sigexp__AND_strbind_opt sigexp__AND_strbind_opt1,_
,sigexp__AND_strbind_optright as sigexp__AND_strbind_opt1right))::_::(
_,(MlyValue.strexp strexp1,strexpleft as strexp1left,_))::rest671) => 
let val result=MlyValue.strexp__AND_strbind_opt(fn _ => let val strexp
 as strexp1=strexp1 ()
val sigexp__AND_strbind_opt as sigexp__AND_strbind_opt1=
sigexp__AND_strbind_opt1 ()
 in (
 ( OPAQStrExp(I(strexpleft,
                                         sigexp__AND_strbind_optright),
                                       strexp, #1 sigexp__AND_strbind_opt),
                            #2 sigexp__AND_strbind_opt ) 
) end
)
 in (LrTable.NT 89,(result,strexp1left,sigexp__AND_strbind_opt1right),
rest671) end
| (224,(_,(MlyValue.AND_strbind_opt AND_strbind_opt1,_,
AND_strbind_opt1right))::(_,(MlyValue.sigexp' sigexp'1,sigexp'1left,_)
)::rest671) => let val result=MlyValue.sigexp__AND_strbind_opt(fn _
 => let val sigexp' as sigexp'1=sigexp'1 ()
val AND_strbind_opt as AND_strbind_opt1=AND_strbind_opt1 ()
 in ( ( sigexp', AND_strbind_opt ) ) end
)
 in (LrTable.NT 90,(result,sigexp'1left,AND_strbind_opt1right),rest671
) end
| (225,(_,(MlyValue.tyreadesc__AND_strbind_opt 
tyreadesc__AND_strbind_opt1,_,tyreadesc__AND_strbind_optright as 
tyreadesc__AND_strbind_opt1right))::_::(_,(MlyValue.sigexp sigexp1,
sigexpleft as sigexp1left,_))::rest671) => let val result=
MlyValue.sigexp__AND_strbind_opt(fn _ => let val sigexp as sigexp1=
sigexp1 ()
val tyreadesc__AND_strbind_opt as tyreadesc__AND_strbind_opt1=
tyreadesc__AND_strbind_opt1 ()
 in (
 ( WHERETYPESigExp(I(sigexpleft,
                                              tyreadesc__AND_strbind_optright),
                                           sigexp,
                                           #1 tyreadesc__AND_strbind_opt),
                            #2 tyreadesc__AND_strbind_opt ) 
) end
)
 in (LrTable.NT 90,(result,sigexp1left,
tyreadesc__AND_strbind_opt1right),rest671) end
| (226,(_,(MlyValue.AND_tyreadesc_opt__AND_strbind_opt 
AND_tyreadesc_opt__AND_strbind_opt1,_,
AND_tyreadesc_opt__AND_strbind_optright as 
AND_tyreadesc_opt__AND_strbind_opt1right))::(_,(MlyValue.ty ty1,_,_))
::_::(_,(MlyValue.longtycon longtycon1,_,_))::(_,(MlyValue.tyvarseq 
tyvarseq1,_,_))::(_,(_,TYPEleft as TYPE1left,_))::rest671) => let val 
result=MlyValue.tyreadesc__AND_strbind_opt(fn _ => let val tyvarseq
 as tyvarseq1=tyvarseq1 ()
val longtycon as longtycon1=longtycon1 ()
val ty as ty1=ty1 ()
val AND_tyreadesc_opt__AND_strbind_opt as 
AND_tyreadesc_opt__AND_strbind_opt1=
AND_tyreadesc_opt__AND_strbind_opt1 ()
 in (
 ( TyReaDesc(I(TYPEleft,
                                       AND_tyreadesc_opt__AND_strbind_optright),
                                      tyvarseq, longtycon, ty,
                                      #1 AND_tyreadesc_opt__AND_strbind_opt),
                            #2 AND_tyreadesc_opt__AND_strbind_opt ) 
) end
)
 in (LrTable.NT 91,(result,TYPE1left,
AND_tyreadesc_opt__AND_strbind_opt1right),rest671) end
| (227,(_,(MlyValue.AND_strbind_opt AND_strbind_opt1,
AND_strbind_opt1left,AND_strbind_opt1right))::rest671) => let val 
result=MlyValue.AND_tyreadesc_opt__AND_strbind_opt(fn _ => let val 
AND_strbind_opt as AND_strbind_opt1=AND_strbind_opt1 ()
 in ( ( NONE, AND_strbind_opt ) ) end
)
 in (LrTable.NT 92,(result,AND_strbind_opt1left,AND_strbind_opt1right)
,rest671) end
| (228,(_,(MlyValue.tyreadesc__AND_strbind_opt 
tyreadesc__AND_strbind_opt1,_,tyreadesc__AND_strbind_opt1right))::(_,(
_,AND1left,_))::rest671) => let val result=
MlyValue.AND_tyreadesc_opt__AND_strbind_opt(fn _ => let val 
tyreadesc__AND_strbind_opt as tyreadesc__AND_strbind_opt1=
tyreadesc__AND_strbind_opt1 ()
 in (
 ( SOME(#1 tyreadesc__AND_strbind_opt),
                                    #2 tyreadesc__AND_strbind_opt ) 
) end
)
 in (LrTable.NT 92,(result,AND1left,tyreadesc__AND_strbind_opt1right),
rest671) end
| (229,(_,(MlyValue.sigexp sigexp1,_,sigexp1right))::(_,(_,COLON1left,
_))::rest671) => let val result=MlyValue.COLON_sigexp_opt(fn _ => let 
val sigexp as sigexp1=sigexp1 ()
 in ( SOME sigexp ) end
)
 in (LrTable.NT 93,(result,COLON1left,sigexp1right),rest671) end
| (230,rest671) => let val result=MlyValue.COLON_sigexp_opt(fn _ => (
 NONE ))
 in (LrTable.NT 93,(result,defaultPos,defaultPos),rest671) end
| (231,(_,(MlyValue.sigexp' sigexp'1,sigexp'1left,sigexp'1right))::
rest671) => let val result=MlyValue.sigexp(fn _ => let val sigexp' as 
sigexp'1=sigexp'1 ()
 in ( sigexp' ) end
)
 in (LrTable.NT 94,(result,sigexp'1left,sigexp'1right),rest671) end
| (232,(_,(MlyValue.tyreadesc tyreadesc1,_,tyreadescright as 
tyreadesc1right))::_::(_,(MlyValue.sigexp sigexp1,sigexpleft as 
sigexp1left,_))::rest671) => let val result=MlyValue.sigexp(fn _ => 
let val sigexp as sigexp1=sigexp1 ()
val tyreadesc as tyreadesc1=tyreadesc1 ()
 in (
 WHERETYPESigExp(I(sigexpleft,tyreadescright),
                                          sigexp, tyreadesc) 
) end
)
 in (LrTable.NT 94,(result,sigexp1left,tyreadesc1right),rest671) end
| (233,(_,(_,_,ENDright as END1right))::(_,(MlyValue.spec spec1,_,_))
::(_,(_,SIGleft as SIG1left,_))::rest671) => let val result=
MlyValue.sigexp'(fn _ => let val spec as spec1=spec1 ()
 in ( SIGSigExp(I(SIGleft,ENDright), spec) ) end
)
 in (LrTable.NT 95,(result,SIG1left,END1right),rest671) end
| (234,(_,(MlyValue.sigid sigid1,sigidleft as sigid1left,sigidright
 as sigid1right))::rest671) => let val result=MlyValue.sigexp'(fn _
 => let val sigid as sigid1=sigid1 ()
 in ( SIGIDSigExp(I(sigidleft,sigidright), sigid) ) end
)
 in (LrTable.NT 95,(result,sigid1left,sigid1right),rest671) end
| (235,(_,(MlyValue.sigbind sigbind1,_,sigbindright as sigbind1right))
::(_,(_,SIGNATUREleft as SIGNATURE1left,_))::rest671) => let val 
result=MlyValue.sigdec(fn _ => let val sigbind as sigbind1=sigbind1 ()
 in ( SigDec(I(SIGNATUREleft,sigbindright), sigbind) ) end
)
 in (LrTable.NT 96,(result,SIGNATURE1left,sigbind1right),rest671) end
| (236,(_,(MlyValue.sigexp__AND_sigbind_opt sigexp__AND_sigbind_opt1,_
,sigexp__AND_sigbind_optright as sigexp__AND_sigbind_opt1right))::_::(
_,(MlyValue.sigid sigid1,sigidleft as sigid1left,_))::rest671) => let 
val result=MlyValue.sigbind(fn _ => let val sigid as sigid1=sigid1 ()
val sigexp__AND_sigbind_opt as sigexp__AND_sigbind_opt1=
sigexp__AND_sigbind_opt1 ()
 in (
 SigBind(I(sigidleft,sigexp__AND_sigbind_optright),
                                  sigid, #1 sigexp__AND_sigbind_opt,
                                  #2 sigexp__AND_sigbind_opt) 
) end
)
 in (LrTable.NT 97,(result,sigid1left,sigexp__AND_sigbind_opt1right),
rest671) end
| (237,(_,(MlyValue.sigbind sigbind1,_,sigbind1right))::(_,(_,AND1left
,_))::rest671) => let val result=MlyValue.AND_sigbind_opt(fn _ => let 
val sigbind as sigbind1=sigbind1 ()
 in ( SOME sigbind ) end
)
 in (LrTable.NT 98,(result,AND1left,sigbind1right),rest671) end
| (238,rest671) => let val result=MlyValue.AND_sigbind_opt(fn _ => (
 NONE ))
 in (LrTable.NT 98,(result,defaultPos,defaultPos),rest671) end
| (239,(_,(MlyValue.AND_sigbind_opt AND_sigbind_opt1,_,
AND_sigbind_opt1right))::(_,(MlyValue.sigexp' sigexp'1,sigexp'1left,_)
)::rest671) => let val result=MlyValue.sigexp__AND_sigbind_opt(fn _
 => let val sigexp' as sigexp'1=sigexp'1 ()
val AND_sigbind_opt as AND_sigbind_opt1=AND_sigbind_opt1 ()
 in ( ( sigexp', AND_sigbind_opt ) ) end
)
 in (LrTable.NT 99,(result,sigexp'1left,AND_sigbind_opt1right),rest671
) end
| (240,(_,(MlyValue.tyreadesc__AND_sigbind_opt 
tyreadesc__AND_sigbind_opt1,_,tyreadesc__AND_sigbind_optright as 
tyreadesc__AND_sigbind_opt1right))::_::(_,(MlyValue.sigexp sigexp1,
sigexpleft as sigexp1left,_))::rest671) => let val result=
MlyValue.sigexp__AND_sigbind_opt(fn _ => let val sigexp as sigexp1=
sigexp1 ()
val tyreadesc__AND_sigbind_opt as tyreadesc__AND_sigbind_opt1=
tyreadesc__AND_sigbind_opt1 ()
 in (
 ( WHERETYPESigExp(I(sigexpleft,
                                              tyreadesc__AND_sigbind_optright),
                                           sigexp,
                                           #1 tyreadesc__AND_sigbind_opt),
                            #2 tyreadesc__AND_sigbind_opt ) 
) end
)
 in (LrTable.NT 99,(result,sigexp1left,
tyreadesc__AND_sigbind_opt1right),rest671) end
| (241,(_,(MlyValue.AND_tyreadesc_opt__AND_sigbind_opt 
AND_tyreadesc_opt__AND_sigbind_opt1,_,
AND_tyreadesc_opt__AND_sigbind_optright as 
AND_tyreadesc_opt__AND_sigbind_opt1right))::(_,(MlyValue.ty ty1,_,_))
::_::(_,(MlyValue.longtycon longtycon1,_,_))::(_,(MlyValue.tyvarseq 
tyvarseq1,_,_))::(_,(_,TYPEleft as TYPE1left,_))::rest671) => let val 
result=MlyValue.tyreadesc__AND_sigbind_opt(fn _ => let val tyvarseq
 as tyvarseq1=tyvarseq1 ()
val longtycon as longtycon1=longtycon1 ()
val ty as ty1=ty1 ()
val AND_tyreadesc_opt__AND_sigbind_opt as 
AND_tyreadesc_opt__AND_sigbind_opt1=
AND_tyreadesc_opt__AND_sigbind_opt1 ()
 in (
 ( TyReaDesc(I(TYPEleft,
                                       AND_tyreadesc_opt__AND_sigbind_optright),
                                      tyvarseq, longtycon, ty,
                                      #1 AND_tyreadesc_opt__AND_sigbind_opt),
                            #2 AND_tyreadesc_opt__AND_sigbind_opt ) 
) end
)
 in (LrTable.NT 100,(result,TYPE1left,
AND_tyreadesc_opt__AND_sigbind_opt1right),rest671) end
| (242,(_,(MlyValue.AND_sigbind_opt AND_sigbind_opt1,
AND_sigbind_opt1left,AND_sigbind_opt1right))::rest671) => let val 
result=MlyValue.AND_tyreadesc_opt__AND_sigbind_opt(fn _ => let val 
AND_sigbind_opt as AND_sigbind_opt1=AND_sigbind_opt1 ()
 in ( ( NONE, AND_sigbind_opt) ) end
)
 in (LrTable.NT 101,(result,AND_sigbind_opt1left,AND_sigbind_opt1right
),rest671) end
| (243,(_,(MlyValue.tyreadesc__AND_sigbind_opt 
tyreadesc__AND_sigbind_opt1,_,tyreadesc__AND_sigbind_opt1right))::(_,(
_,AND1left,_))::rest671) => let val result=
MlyValue.AND_tyreadesc_opt__AND_sigbind_opt(fn _ => let val 
tyreadesc__AND_sigbind_opt as tyreadesc__AND_sigbind_opt1=
tyreadesc__AND_sigbind_opt1 ()
 in (
 ( SOME(#1 tyreadesc__AND_sigbind_opt),
                                    #2 tyreadesc__AND_sigbind_opt ) 
) end
)
 in (LrTable.NT 101,(result,AND1left,tyreadesc__AND_sigbind_opt1right)
,rest671) end
| (244,(_,(MlyValue.AND_tyreadesc_opt AND_tyreadesc_opt1,_,
AND_tyreadesc_optright as AND_tyreadesc_opt1right))::(_,(MlyValue.ty 
ty1,_,_))::_::(_,(MlyValue.longtycon longtycon1,_,_))::(_,(
MlyValue.tyvarseq tyvarseq1,_,_))::(_,(_,TYPEleft as TYPE1left,_))::
rest671) => let val result=MlyValue.tyreadesc(fn _ => let val tyvarseq
 as tyvarseq1=tyvarseq1 ()
val longtycon as longtycon1=longtycon1 ()
val ty as ty1=ty1 ()
val AND_tyreadesc_opt as AND_tyreadesc_opt1=AND_tyreadesc_opt1 ()
 in (
 TyReaDesc(I(TYPEleft,AND_tyreadesc_optright),
                                    tyvarseq, longtycon, ty,
                                    AND_tyreadesc_opt) 
) end
)
 in (LrTable.NT 102,(result,TYPE1left,AND_tyreadesc_opt1right),rest671
) end
| (245,(_,(MlyValue.tyreadesc tyreadesc1,_,tyreadesc1right))::(_,(_,
AND1left,_))::rest671) => let val result=MlyValue.AND_tyreadesc_opt(
fn _ => let val tyreadesc as tyreadesc1=tyreadesc1 ()
 in ( SOME tyreadesc ) end
)
 in (LrTable.NT 103,(result,AND1left,tyreadesc1right),rest671) end
| (246,rest671) => let val result=MlyValue.AND_tyreadesc_opt(fn _ => (
 NONE ))
 in (LrTable.NT 103,(result,defaultPos,defaultPos),rest671) end
| (247,(_,(MlyValue.spec1 spec11,spec11left,spec11right))::rest671)
 => let val result=MlyValue.spec(fn _ => let val spec1 as spec11=
spec11 ()
 in ( spec1 ) end
)
 in (LrTable.NT 104,(result,spec11left,spec11right),rest671) end
| (248,rest671) => let val result=MlyValue.spec(fn _ => (
 EMPTYSpec(I(defaultPos,defaultPos)) ))
 in (LrTable.NT 104,(result,defaultPos,defaultPos),rest671) end
| (249,(_,(MlyValue.spec1' spec1'1,spec1'1left,spec1'1right))::rest671
) => let val result=MlyValue.spec1(fn _ => let val spec1' as spec1'1=
spec1'1 ()
 in ( spec1' ) end
)
 in (LrTable.NT 105,(result,spec1'1left,spec1'1right),rest671) end
| (250,(_,(MlyValue.spec1' spec1'1,_,spec1'right as spec1'1right))::(_
,(MlyValue.spec1 spec11,spec1left as spec11left,_))::rest671) => let 
val result=MlyValue.spec1(fn _ => let val spec1 as spec11=spec11 ()
val spec1' as spec1'1=spec1'1 ()
 in ( SEQSpec(I(spec1left,spec1'right), spec1, spec1') ) end
)
 in (LrTable.NT 105,(result,spec11left,spec1'1right),rest671) end
| (251,(_,(_,SEMICOLON1left,SEMICOLON1right))::rest671) => let val 
result=MlyValue.spec1(fn _ => ( EMPTYSpec(I(defaultPos,defaultPos)) ))
 in (LrTable.NT 105,(result,SEMICOLON1left,SEMICOLON1right),rest671)
 end
| (252,(_,(MlyValue.longtycon_EQUALS_list2 longtycon_EQUALS_list21,_,
longtycon_EQUALS_list2right as longtycon_EQUALS_list21right))::_::(_,(
_,SHARINGleft as SHARING1left,_))::rest671) => let val result=
MlyValue.spec1(fn _ => let val longtycon_EQUALS_list2 as 
longtycon_EQUALS_list21=longtycon_EQUALS_list21 ()
 in (
 SHARINGTYPESpec(I(SHARINGleft,
                                            longtycon_EQUALS_list2right),
                                          EMPTYSpec(I(SHARINGleft,SHARINGleft)),
                                          longtycon_EQUALS_list2) 
) end
)
 in (LrTable.NT 105,(result,SHARING1left,longtycon_EQUALS_list21right)
,rest671) end
| (253,(_,(MlyValue.longtycon_EQUALS_list2 longtycon_EQUALS_list21,_,
longtycon_EQUALS_list2right as longtycon_EQUALS_list21right))::_::_::(
_,(MlyValue.spec1 spec11,spec1left as spec11left,_))::rest671) => let 
val result=MlyValue.spec1(fn _ => let val spec1 as spec11=spec11 ()
val longtycon_EQUALS_list2 as longtycon_EQUALS_list21=
longtycon_EQUALS_list21 ()
 in (
 SHARINGTYPESpec(I(spec1left,
                                            longtycon_EQUALS_list2right),
                                          spec1, longtycon_EQUALS_list2) 
) end
)
 in (LrTable.NT 105,(result,spec11left,longtycon_EQUALS_list21right),
rest671) end
| (254,(_,(MlyValue.longstrid_EQUALS_list2 longstrid_EQUALS_list21,_,
longstrid_EQUALS_list2right as longstrid_EQUALS_list21right))::(_,(_,
SHARINGleft as SHARING1left,_))::rest671) => let val result=
MlyValue.spec1(fn _ => let val longstrid_EQUALS_list2 as 
longstrid_EQUALS_list21=longstrid_EQUALS_list21 ()
 in (
 SHARINGSpec(I(SHARINGleft,
                                        longstrid_EQUALS_list2right),
                                      EMPTYSpec(I(SHARINGleft,SHARINGleft)),
                                      longstrid_EQUALS_list2) 
) end
)
 in (LrTable.NT 105,(result,SHARING1left,longstrid_EQUALS_list21right)
,rest671) end
| (255,(_,(MlyValue.longstrid_EQUALS_list2 longstrid_EQUALS_list21,_,
longstrid_EQUALS_list2right as longstrid_EQUALS_list21right))::_::(_,(
MlyValue.spec1 spec11,spec1left as spec11left,_))::rest671) => let 
val result=MlyValue.spec1(fn _ => let val spec1 as spec11=spec11 ()
val longstrid_EQUALS_list2 as longstrid_EQUALS_list21=
longstrid_EQUALS_list21 ()
 in (
 SHARINGSpec(I(spec1left,longstrid_EQUALS_list2right),
                                      spec1, longstrid_EQUALS_list2) 
) end
)
 in (LrTable.NT 105,(result,spec11left,longstrid_EQUALS_list21right),
rest671) end
| (256,(_,(MlyValue.valdesc valdesc1,_,valdescright as valdesc1right))
::(_,(_,VALleft as VAL1left,_))::rest671) => let val result=
MlyValue.spec1'(fn _ => let val valdesc as valdesc1=valdesc1 ()
 in ( VALSpec(I(VALleft,valdescright), valdesc) ) end
)
 in (LrTable.NT 106,(result,VAL1left,valdesc1right),rest671) end
| (257,(_,(MlyValue.typdesc typdesc1,_,typdescright as typdesc1right))
::(_,(_,TYPEleft as TYPE1left,_))::rest671) => let val result=
MlyValue.spec1'(fn _ => let val typdesc as typdesc1=typdesc1 ()
 in ( TYPESpec(I(TYPEleft,typdescright), typdesc) ) end
)
 in (LrTable.NT 106,(result,TYPE1left,typdesc1right),rest671) end
| (258,(_,(MlyValue.typdesc typdesc1,_,typdescright as typdesc1right))
::(_,(_,EQTYPEleft as EQTYPE1left,_))::rest671) => let val result=
MlyValue.spec1'(fn _ => let val typdesc as typdesc1=typdesc1 ()
 in ( EQTYPESpec(I(EQTYPEleft,typdescright), typdesc) ) end
)
 in (LrTable.NT 106,(result,EQTYPE1left,typdesc1right),rest671) end
| (259,(_,(MlyValue.syndesc syndesc1,_,syndescright as syndesc1right))
::(_,(_,TYPEleft as TYPE1left,_))::rest671) => let val result=
MlyValue.spec1'(fn _ => let val syndesc as syndesc1=syndesc1 ()
 in ( SYNSpec(I(TYPEleft,syndescright), syndesc) ) end
)
 in (LrTable.NT 106,(result,TYPE1left,syndesc1right),rest671) end
| (260,(_,(MlyValue.datdesc0 datdesc01,_,datdesc0right as 
datdesc01right))::(_,(_,DATATYPEleft as DATATYPE1left,_))::rest671)
 => let val result=MlyValue.spec1'(fn _ => let val datdesc0 as 
datdesc01=datdesc01 ()
 in ( DATATYPESpec(I(DATATYPEleft,datdesc0right), datdesc0)) end
)
 in (LrTable.NT 106,(result,DATATYPE1left,datdesc01right),rest671) end
| (261,(_,(MlyValue.datdesc1 datdesc11,_,datdesc1right as 
datdesc11right))::(_,(_,DATATYPEleft as DATATYPE1left,_))::rest671)
 => let val result=MlyValue.spec1'(fn _ => let val datdesc1 as 
datdesc11=datdesc11 ()
 in ( DATATYPESpec(I(DATATYPEleft,datdesc1right), datdesc1)) end
)
 in (LrTable.NT 106,(result,DATATYPE1left,datdesc11right),rest671) end
| (262,(_,(MlyValue.longtycon longtycon1,_,longtyconright as 
longtycon1right))::_::_::(_,(MlyValue.tycon tycon1,_,_))::(_,(_,
DATATYPEleft as DATATYPE1left,_))::rest671) => let val result=
MlyValue.spec1'(fn _ => let val tycon as tycon1=tycon1 ()
val longtycon as longtycon1=longtycon1 ()
 in (
 REPLICATIONSpec(I(DATATYPEleft,longtyconright),
                                          tycon, longtycon) 
) end
)
 in (LrTable.NT 106,(result,DATATYPE1left,longtycon1right),rest671)
 end
| (263,(_,(MlyValue.exdesc exdesc1,_,exdescright as exdesc1right))::(_
,(_,EXCEPTIONleft as EXCEPTION1left,_))::rest671) => let val result=
MlyValue.spec1'(fn _ => let val exdesc as exdesc1=exdesc1 ()
 in ( EXCEPTIONSpec(I(EXCEPTIONleft,exdescright), exdesc) ) end
)
 in (LrTable.NT 106,(result,EXCEPTION1left,exdesc1right),rest671) end
| (264,(_,(MlyValue.strdesc strdesc1,_,strdescright as strdesc1right))
::(_,(_,STRUCTUREleft as STRUCTURE1left,_))::rest671) => let val 
result=MlyValue.spec1'(fn _ => let val strdesc as strdesc1=strdesc1 ()
 in ( STRUCTURESpec(I(STRUCTUREleft,strdescright), strdesc)) end
)
 in (LrTable.NT 106,(result,STRUCTURE1left,strdesc1right),rest671) end
| (265,(_,(MlyValue.sigexp sigexp1,_,sigexpright as sigexp1right))::(_
,(_,INCLUDEleft as INCLUDE1left,_))::rest671) => let val result=
MlyValue.spec1'(fn _ => let val sigexp as sigexp1=sigexp1 ()
 in ( INCLUDESpec(I(INCLUDEleft,sigexpright), sigexp) ) end
)
 in (LrTable.NT 106,(result,INCLUDE1left,sigexp1right),rest671) end
| (266,(_,(MlyValue.sigid_list2 sigid_list21,_,sigid_list2right as 
sigid_list21right))::(_,(_,INCLUDEleft as INCLUDE1left,_))::rest671)
 => let val result=MlyValue.spec1'(fn _ => let val sigid_list2 as 
sigid_list21=sigid_list21 ()
 in (
 INCLUDEMULTISpec(I(INCLUDEleft,sigid_list2right),
                                           sigid_list2) 
) end
)
 in (LrTable.NT 106,(result,INCLUDE1left,sigid_list21right),rest671)
 end
| (267,(_,(MlyValue.sigid_list2 sigid_list21,_,sigid_list21right))::(_
,(MlyValue.sigid sigid1,sigid1left,_))::rest671) => let val result=
MlyValue.sigid_list2(fn _ => let val sigid as sigid1=sigid1 ()
val sigid_list2 as sigid_list21=sigid_list21 ()
 in ( sigid::sigid_list2 ) end
)
 in (LrTable.NT 107,(result,sigid1left,sigid_list21right),rest671) end
| (268,(_,(MlyValue.sigid sigid2,_,sigid2right))::(_,(MlyValue.sigid 
sigid1,sigid1left,_))::rest671) => let val result=MlyValue.sigid_list2
(fn _ => let val sigid1=sigid1 ()
val sigid2=sigid2 ()
 in ( sigid1::sigid2::[] ) end
)
 in (LrTable.NT 107,(result,sigid1left,sigid2right),rest671) end
| (269,(_,(MlyValue.longtycon_EQUALS_list1 longtycon_EQUALS_list11,_,
longtycon_EQUALS_list11right))::_::(_,(MlyValue.longtycon longtycon1,
longtycon1left,_))::rest671) => let val result=
MlyValue.longtycon_EQUALS_list1(fn _ => let val longtycon as 
longtycon1=longtycon1 ()
val longtycon_EQUALS_list1 as longtycon_EQUALS_list11=
longtycon_EQUALS_list11 ()
 in ( longtycon::longtycon_EQUALS_list1 ) end
)
 in (LrTable.NT 108,(result,longtycon1left,
longtycon_EQUALS_list11right),rest671) end
| (270,(_,(MlyValue.longtycon longtycon1,longtycon1left,
longtycon1right))::rest671) => let val result=
MlyValue.longtycon_EQUALS_list1(fn _ => let val longtycon as 
longtycon1=longtycon1 ()
 in ( longtycon::[] ) end
)
 in (LrTable.NT 108,(result,longtycon1left,longtycon1right),rest671)
 end
| (271,(_,(MlyValue.longtycon_EQUALS_list1 longtycon_EQUALS_list11,_,
longtycon_EQUALS_list11right))::_::(_,(MlyValue.longtycon longtycon1,
longtycon1left,_))::rest671) => let val result=
MlyValue.longtycon_EQUALS_list2(fn _ => let val longtycon as 
longtycon1=longtycon1 ()
val longtycon_EQUALS_list1 as longtycon_EQUALS_list11=
longtycon_EQUALS_list11 ()
 in ( longtycon::longtycon_EQUALS_list1 ) end
)
 in (LrTable.NT 109,(result,longtycon1left,
longtycon_EQUALS_list11right),rest671) end
| (272,(_,(MlyValue.longstrid_EQUALS_list1 longstrid_EQUALS_list11,_,
longstrid_EQUALS_list11right))::_::(_,(MlyValue.longstrid longstrid1,
longstrid1left,_))::rest671) => let val result=
MlyValue.longstrid_EQUALS_list1(fn _ => let val longstrid as 
longstrid1=longstrid1 ()
val longstrid_EQUALS_list1 as longstrid_EQUALS_list11=
longstrid_EQUALS_list11 ()
 in ( longstrid::longstrid_EQUALS_list1 ) end
)
 in (LrTable.NT 110,(result,longstrid1left,
longstrid_EQUALS_list11right),rest671) end
| (273,(_,(MlyValue.longstrid longstrid1,longstrid1left,
longstrid1right))::rest671) => let val result=
MlyValue.longstrid_EQUALS_list1(fn _ => let val longstrid as 
longstrid1=longstrid1 ()
 in ( longstrid::[] ) end
)
 in (LrTable.NT 110,(result,longstrid1left,longstrid1right),rest671)
 end
| (274,(_,(MlyValue.longstrid_EQUALS_list1 longstrid_EQUALS_list11,_,
longstrid_EQUALS_list11right))::_::(_,(MlyValue.longstrid longstrid1,
longstrid1left,_))::rest671) => let val result=
MlyValue.longstrid_EQUALS_list2(fn _ => let val longstrid as 
longstrid1=longstrid1 ()
val longstrid_EQUALS_list1 as longstrid_EQUALS_list11=
longstrid_EQUALS_list11 ()
 in ( longstrid::longstrid_EQUALS_list1 ) end
)
 in (LrTable.NT 111,(result,longstrid1left,
longstrid_EQUALS_list11right),rest671) end
| (275,(_,(MlyValue.AND_valdesc_opt AND_valdesc_opt1,_,
AND_valdesc_optright as AND_valdesc_opt1right))::(_,(MlyValue.ty ty1,_
,_))::_::(_,(MlyValue.vid' vid'1,vid'left as vid'1left,_))::rest671)
 => let val result=MlyValue.valdesc(fn _ => let val vid' as vid'1=
vid'1 ()
val ty as ty1=ty1 ()
val AND_valdesc_opt as AND_valdesc_opt1=AND_valdesc_opt1 ()
 in (
 ValDesc(I(vid'left,AND_valdesc_optright),
                                  vid', ty, AND_valdesc_opt) 
) end
)
 in (LrTable.NT 112,(result,vid'1left,AND_valdesc_opt1right),rest671)
 end
| (276,(_,(MlyValue.valdesc valdesc1,_,valdesc1right))::(_,(_,AND1left
,_))::rest671) => let val result=MlyValue.AND_valdesc_opt(fn _ => let 
val valdesc as valdesc1=valdesc1 ()
 in ( SOME valdesc ) end
)
 in (LrTable.NT 113,(result,AND1left,valdesc1right),rest671) end
| (277,rest671) => let val result=MlyValue.AND_valdesc_opt(fn _ => (
 NONE ))
 in (LrTable.NT 113,(result,defaultPos,defaultPos),rest671) end
| (278,(_,(MlyValue.AND_typdesc_opt AND_typdesc_opt1,_,
AND_typdesc_optright as AND_typdesc_opt1right))::(_,(MlyValue.tycon 
tycon1,_,_))::(_,(MlyValue.tyvarseq tyvarseq1,tyvarseqleft as 
tyvarseq1left,_))::rest671) => let val result=MlyValue.typdesc(fn _
 => let val tyvarseq as tyvarseq1=tyvarseq1 ()
val tycon as tycon1=tycon1 ()
val AND_typdesc_opt as AND_typdesc_opt1=AND_typdesc_opt1 ()
 in (
 TypDesc(I(tyvarseqleft,AND_typdesc_optright),
                                  tyvarseq, tycon, AND_typdesc_opt) 
) end
)
 in (LrTable.NT 114,(result,tyvarseq1left,AND_typdesc_opt1right),
rest671) end
| (279,(_,(MlyValue.typdesc typdesc1,_,typdesc1right))::(_,(_,AND1left
,_))::rest671) => let val result=MlyValue.AND_typdesc_opt(fn _ => let 
val typdesc as typdesc1=typdesc1 ()
 in ( SOME typdesc ) end
)
 in (LrTable.NT 115,(result,AND1left,typdesc1right),rest671) end
| (280,rest671) => let val result=MlyValue.AND_typdesc_opt(fn _ => (
 NONE ))
 in (LrTable.NT 115,(result,defaultPos,defaultPos),rest671) end
| (281,(_,(MlyValue.AND_syndesc_opt AND_syndesc_opt1,_,
AND_syndesc_optright as AND_syndesc_opt1right))::(_,(MlyValue.ty ty1,_
,_))::_::(_,(MlyValue.tycon tycon1,_,_))::(_,(MlyValue.tyvarseq 
tyvarseq1,tyvarseqleft as tyvarseq1left,_))::rest671) => let val 
result=MlyValue.syndesc(fn _ => let val tyvarseq as tyvarseq1=
tyvarseq1 ()
val tycon as tycon1=tycon1 ()
val ty as ty1=ty1 ()
val AND_syndesc_opt as AND_syndesc_opt1=AND_syndesc_opt1 ()
 in (
 SynDesc(I(tyvarseqleft,AND_syndesc_optright),
                                  tyvarseq, tycon, ty, AND_syndesc_opt) 
) end
)
 in (LrTable.NT 116,(result,tyvarseq1left,AND_syndesc_opt1right),
rest671) end
| (282,(_,(MlyValue.syndesc syndesc1,_,syndesc1right))::(_,(_,AND1left
,_))::rest671) => let val result=MlyValue.AND_syndesc_opt(fn _ => let 
val syndesc as syndesc1=syndesc1 ()
 in ( SOME syndesc ) end
)
 in (LrTable.NT 117,(result,AND1left,syndesc1right),rest671) end
| (283,rest671) => let val result=MlyValue.AND_syndesc_opt(fn _ => (
 NONE ))
 in (LrTable.NT 117,(result,defaultPos,defaultPos),rest671) end
| (284,(_,(MlyValue.AND_datdesc_opt AND_datdesc_opt1,_,
AND_datdesc_optright as AND_datdesc_opt1right))::(_,(MlyValue.condesc 
condesc1,_,_))::_::(_,(MlyValue.tycon tycon1,_,_))::(_,(
MlyValue.tyvarseq tyvarseq1,tyvarseqleft as tyvarseq1left,_))::rest671
) => let val result=MlyValue.datdesc(fn _ => let val tyvarseq as 
tyvarseq1=tyvarseq1 ()
val tycon as tycon1=tycon1 ()
val condesc as condesc1=condesc1 ()
val AND_datdesc_opt as AND_datdesc_opt1=AND_datdesc_opt1 ()
 in (
 DatDesc(I(tyvarseqleft,AND_datdesc_optright),
                                  tyvarseq, tycon, condesc, AND_datdesc_opt) 
) end
)
 in (LrTable.NT 118,(result,tyvarseq1left,AND_datdesc_opt1right),
rest671) end
| (285,(_,(MlyValue.AND_datdesc_opt AND_datdesc_opt1,_,
AND_datdesc_optright as AND_datdesc_opt1right))::(_,(MlyValue.condesc 
condesc1,_,_))::_::(_,(MlyValue.tycon tycon1,tyconleft as tycon1left,_
))::rest671) => let val result=MlyValue.datdesc0(fn _ => let val tycon
 as tycon1=tycon1 ()
val condesc as condesc1=condesc1 ()
val AND_datdesc_opt as AND_datdesc_opt1=AND_datdesc_opt1 ()
 in (
 DatDesc(I(tyconleft,AND_datdesc_optright),
                                  TyVarseq(I(defaultPos,defaultPos), []),
                                  tycon, condesc, AND_datdesc_opt) 
) end
)
 in (LrTable.NT 119,(result,tycon1left,AND_datdesc_opt1right),rest671)
 end
| (286,(_,(MlyValue.AND_datdesc_opt AND_datdesc_opt1,_,
AND_datdesc_optright as AND_datdesc_opt1right))::(_,(MlyValue.condesc 
condesc1,_,_))::_::(_,(MlyValue.tycon tycon1,_,_))::(_,(
MlyValue.tyvarseq1 tyvarseq11,tyvarseq1left as tyvarseq11left,_))::
rest671) => let val result=MlyValue.datdesc1(fn _ => let val tyvarseq1
 as tyvarseq11=tyvarseq11 ()
val tycon as tycon1=tycon1 ()
val condesc as condesc1=condesc1 ()
val AND_datdesc_opt as AND_datdesc_opt1=AND_datdesc_opt1 ()
 in (
 DatDesc(I(tyvarseq1left,AND_datdesc_optright),
                                  tyvarseq1, tycon, condesc, AND_datdesc_opt) 
) end
)
 in (LrTable.NT 120,(result,tyvarseq11left,AND_datdesc_opt1right),
rest671) end
| (287,(_,(MlyValue.datdesc datdesc1,_,datdesc1right))::(_,(_,AND1left
,_))::rest671) => let val result=MlyValue.AND_datdesc_opt(fn _ => let 
val datdesc as datdesc1=datdesc1 ()
 in ( SOME datdesc ) end
)
 in (LrTable.NT 121,(result,AND1left,datdesc1right),rest671) end
| (288,rest671) => let val result=MlyValue.AND_datdesc_opt(fn _ => (
 NONE ))
 in (LrTable.NT 121,(result,defaultPos,defaultPos),rest671) end
| (289,(_,(MlyValue.BAR_condesc_opt BAR_condesc_opt1,_,
BAR_condesc_optright as BAR_condesc_opt1right))::(_,(
MlyValue.OF_ty_opt OF_ty_opt1,_,_))::(_,(MlyValue.vid' vid'1,vid'left
 as vid'1left,_))::rest671) => let val result=MlyValue.condesc(fn _
 => let val vid' as vid'1=vid'1 ()
val OF_ty_opt as OF_ty_opt1=OF_ty_opt1 ()
val BAR_condesc_opt as BAR_condesc_opt1=BAR_condesc_opt1 ()
 in (
 ConDesc(I(vid'left,BAR_condesc_optright),
                                  vid', OF_ty_opt, BAR_condesc_opt) 
) end
)
 in (LrTable.NT 122,(result,vid'1left,BAR_condesc_opt1right),rest671)
 end
| (290,(_,(MlyValue.condesc condesc1,_,condesc1right))::(_,(_,BAR1left
,_))::rest671) => let val result=MlyValue.BAR_condesc_opt(fn _ => let 
val condesc as condesc1=condesc1 ()
 in ( SOME condesc ) end
)
 in (LrTable.NT 123,(result,BAR1left,condesc1right),rest671) end
| (291,rest671) => let val result=MlyValue.BAR_condesc_opt(fn _ => (
 NONE ))
 in (LrTable.NT 123,(result,defaultPos,defaultPos),rest671) end
| (292,(_,(MlyValue.AND_exdesc_opt AND_exdesc_opt1,_,
AND_exdesc_optright as AND_exdesc_opt1right))::(_,(MlyValue.OF_ty_opt 
OF_ty_opt1,_,_))::(_,(MlyValue.vid' vid'1,vid'left as vid'1left,_))::
rest671) => let val result=MlyValue.exdesc(fn _ => let val vid' as 
vid'1=vid'1 ()
val OF_ty_opt as OF_ty_opt1=OF_ty_opt1 ()
val AND_exdesc_opt as AND_exdesc_opt1=AND_exdesc_opt1 ()
 in (
 ExDesc(I(vid'left,AND_exdesc_optright),
                                 vid', OF_ty_opt, AND_exdesc_opt) 
) end
)
 in (LrTable.NT 124,(result,vid'1left,AND_exdesc_opt1right),rest671)
 end
| (293,(_,(MlyValue.exdesc exdesc1,_,exdesc1right))::(_,(_,AND1left,_)
)::rest671) => let val result=MlyValue.AND_exdesc_opt(fn _ => let val 
exdesc as exdesc1=exdesc1 ()
 in ( SOME exdesc ) end
)
 in (LrTable.NT 125,(result,AND1left,exdesc1right),rest671) end
| (294,rest671) => let val result=MlyValue.AND_exdesc_opt(fn _ => (
 NONE ))
 in (LrTable.NT 125,(result,defaultPos,defaultPos),rest671) end
| (295,(_,(MlyValue.sigexp__AND_strdesc_opt sigexp__AND_strdesc_opt1,_
,sigexp__AND_strdesc_optright as sigexp__AND_strdesc_opt1right))::_::(
_,(MlyValue.strid strid1,stridleft as strid1left,_))::rest671) => let 
val result=MlyValue.strdesc(fn _ => let val strid as strid1=strid1 ()
val sigexp__AND_strdesc_opt as sigexp__AND_strdesc_opt1=
sigexp__AND_strdesc_opt1 ()
 in (
 StrDesc(I(stridleft,sigexp__AND_strdesc_optright),
                                  strid, #1 sigexp__AND_strdesc_opt,
                                  #2 sigexp__AND_strdesc_opt) 
) end
)
 in (LrTable.NT 126,(result,strid1left,sigexp__AND_strdesc_opt1right),
rest671) end
| (296,(_,(MlyValue.strdesc strdesc1,_,strdesc1right))::(_,(_,AND1left
,_))::rest671) => let val result=MlyValue.AND_strdesc_opt(fn _ => let 
val strdesc as strdesc1=strdesc1 ()
 in ( SOME strdesc ) end
)
 in (LrTable.NT 127,(result,AND1left,strdesc1right),rest671) end
| (297,rest671) => let val result=MlyValue.AND_strdesc_opt(fn _ => (
 NONE ))
 in (LrTable.NT 127,(result,defaultPos,defaultPos),rest671) end
| (298,(_,(MlyValue.AND_strdesc_opt AND_strdesc_opt1,_,
AND_strdesc_opt1right))::(_,(MlyValue.sigexp' sigexp'1,sigexp'1left,_)
)::rest671) => let val result=MlyValue.sigexp__AND_strdesc_opt(fn _
 => let val sigexp' as sigexp'1=sigexp'1 ()
val AND_strdesc_opt as AND_strdesc_opt1=AND_strdesc_opt1 ()
 in ( ( sigexp', AND_strdesc_opt ) ) end
)
 in (LrTable.NT 128,(result,sigexp'1left,AND_strdesc_opt1right),
rest671) end
| (299,(_,(MlyValue.tyreadesc__AND_strdesc_opt 
tyreadesc__AND_strdesc_opt1,_,tyreadesc__AND_strdesc_optright as 
tyreadesc__AND_strdesc_opt1right))::_::(_,(MlyValue.sigexp sigexp1,
sigexpleft as sigexp1left,_))::rest671) => let val result=
MlyValue.sigexp__AND_strdesc_opt(fn _ => let val sigexp as sigexp1=
sigexp1 ()
val tyreadesc__AND_strdesc_opt as tyreadesc__AND_strdesc_opt1=
tyreadesc__AND_strdesc_opt1 ()
 in (
 ( WHERETYPESigExp(I(sigexpleft,
                                              tyreadesc__AND_strdesc_optright),
                                           sigexp,
                                           #1 tyreadesc__AND_strdesc_opt),
                            #2 tyreadesc__AND_strdesc_opt ) 
) end
)
 in (LrTable.NT 128,(result,sigexp1left,
tyreadesc__AND_strdesc_opt1right),rest671) end
| (300,(_,(MlyValue.AND_tyreadesc_opt__AND_strdesc_opt 
AND_tyreadesc_opt__AND_strdesc_opt1,_,
AND_tyreadesc_opt__AND_strdesc_optright as 
AND_tyreadesc_opt__AND_strdesc_opt1right))::(_,(MlyValue.ty ty1,_,_))
::_::(_,(MlyValue.longtycon longtycon1,_,_))::(_,(MlyValue.tyvarseq 
tyvarseq1,_,_))::(_,(_,TYPEleft as TYPE1left,_))::rest671) => let val 
result=MlyValue.tyreadesc__AND_strdesc_opt(fn _ => let val tyvarseq
 as tyvarseq1=tyvarseq1 ()
val longtycon as longtycon1=longtycon1 ()
val ty as ty1=ty1 ()
val AND_tyreadesc_opt__AND_strdesc_opt as 
AND_tyreadesc_opt__AND_strdesc_opt1=
AND_tyreadesc_opt__AND_strdesc_opt1 ()
 in (
 ( TyReaDesc(I(TYPEleft,
                                       AND_tyreadesc_opt__AND_strdesc_optright),
                                      tyvarseq, longtycon, ty,
                                      #1 AND_tyreadesc_opt__AND_strdesc_opt),
                            #2 AND_tyreadesc_opt__AND_strdesc_opt ) 
) end
)
 in (LrTable.NT 129,(result,TYPE1left,
AND_tyreadesc_opt__AND_strdesc_opt1right),rest671) end
| (301,(_,(MlyValue.AND_strdesc_opt AND_strdesc_opt1,
AND_strdesc_opt1left,AND_strdesc_opt1right))::rest671) => let val 
result=MlyValue.AND_tyreadesc_opt__AND_strdesc_opt(fn _ => let val 
AND_strdesc_opt as AND_strdesc_opt1=AND_strdesc_opt1 ()
 in ( ( NONE, AND_strdesc_opt ) ) end
)
 in (LrTable.NT 130,(result,AND_strdesc_opt1left,AND_strdesc_opt1right
),rest671) end
| (302,(_,(MlyValue.tyreadesc__AND_strdesc_opt 
tyreadesc__AND_strdesc_opt1,_,tyreadesc__AND_strdesc_opt1right))::(_,(
_,AND1left,_))::rest671) => let val result=
MlyValue.AND_tyreadesc_opt__AND_strdesc_opt(fn _ => let val 
tyreadesc__AND_strdesc_opt as tyreadesc__AND_strdesc_opt1=
tyreadesc__AND_strdesc_opt1 ()
 in (
 ( SOME(#1 tyreadesc__AND_strdesc_opt),
                                    #2 tyreadesc__AND_strdesc_opt ) 
) end
)
 in (LrTable.NT 130,(result,AND1left,tyreadesc__AND_strdesc_opt1right)
,rest671) end
| (303,(_,(MlyValue.funbind funbind1,_,funbindright as funbind1right))
::(_,(_,FUNCTORleft as FUNCTOR1left,_))::rest671) => let val result=
MlyValue.fundec(fn _ => let val funbind as funbind1=funbind1 ()
 in ( FunDec(I(FUNCTORleft,funbindright), funbind) ) end
)
 in (LrTable.NT 131,(result,FUNCTOR1left,funbind1right),rest671) end
| (304,(_,(MlyValue.strexp__AND_funbind_opt strexp__AND_funbind_opt1,_
,strexp__AND_funbind_optright as strexp__AND_funbind_opt1right))::_::(
_,(MlyValue.COLON_sigexp_opt COLON_sigexp_opt1,_,_))::_::(_,(
MlyValue.sigexp sigexp1,_,_))::_::(_,(MlyValue.strid strid1,_,_))::_::
(_,(MlyValue.funid funid1,funidleft as funid1left,_))::rest671) => 
let val result=MlyValue.funbind(fn _ => let val funid as funid1=funid1
 ()
val strid as strid1=strid1 ()
val sigexp as sigexp1=sigexp1 ()
val COLON_sigexp_opt as COLON_sigexp_opt1=COLON_sigexp_opt1 ()
val strexp__AND_funbind_opt as strexp__AND_funbind_opt1=
strexp__AND_funbind_opt1 ()
 in (
 TRANSFunBind(I(funidleft,
                                         strexp__AND_funbind_optright),
                                       funid, strid, sigexp, COLON_sigexp_opt,
                                       #1 strexp__AND_funbind_opt,
                                       #2 strexp__AND_funbind_opt) 
) end
)
 in (LrTable.NT 132,(result,funid1left,strexp__AND_funbind_opt1right),
rest671) end
| (305,(_,(MlyValue.strexp__AND_funbind_opt strexp__AND_funbind_opt1,_
,strexp__AND_funbind_optright as strexp__AND_funbind_opt1right))::_::(
_,(MlyValue.sigexp sigexp2,_,_))::_::_::(_,(MlyValue.sigexp sigexp1,_,
_))::_::(_,(MlyValue.strid strid1,_,_))::_::(_,(MlyValue.funid funid1,
funidleft as funid1left,_))::rest671) => let val result=
MlyValue.funbind(fn _ => let val funid as funid1=funid1 ()
val strid as strid1=strid1 ()
val sigexp1=sigexp1 ()
val sigexp2=sigexp2 ()
val strexp__AND_funbind_opt as strexp__AND_funbind_opt1=
strexp__AND_funbind_opt1 ()
 in (
 OPAQFunBind(I(funidleft,strexp__AND_funbind_optright),
                                      funid, strid, sigexp1, sigexp2,
                                      #1 strexp__AND_funbind_opt,
                                      #2 strexp__AND_funbind_opt) 
) end
)
 in (LrTable.NT 132,(result,funid1left,strexp__AND_funbind_opt1right),
rest671) end
| (306,(_,(MlyValue.strexp__AND_funbind_opt strexp__AND_funbind_opt1,_
,strexp__AND_funbind_optright as strexp__AND_funbind_opt1right))::_::(
_,(MlyValue.COLON_sigexp_opt COLON_sigexp_opt1,_,_))::_::(_,(
MlyValue.spec spec1,_,_))::_::(_,(MlyValue.funid funid1,funidleft as 
funid1left,_))::rest671) => let val result=MlyValue.funbind(fn _ => 
let val funid as funid1=funid1 ()
val spec as spec1=spec1 ()
val COLON_sigexp_opt as COLON_sigexp_opt1=COLON_sigexp_opt1 ()
val strexp__AND_funbind_opt as strexp__AND_funbind_opt1=
strexp__AND_funbind_opt1 ()
 in (
 TRANSSPECFunBind(I(funidleft,
                                             strexp__AND_funbind_optright),
                                           funid, spec, COLON_sigexp_opt,
                                           #1 strexp__AND_funbind_opt,
                                           #2 strexp__AND_funbind_opt) 
) end
)
 in (LrTable.NT 132,(result,funid1left,strexp__AND_funbind_opt1right),
rest671) end
| (307,(_,(MlyValue.strexp__AND_funbind_opt strexp__AND_funbind_opt1,_
,strexp__AND_funbind_optright as strexp__AND_funbind_opt1right))::_::(
_,(MlyValue.sigexp sigexp1,_,_))::_::_::(_,(MlyValue.spec spec1,_,_))
::_::(_,(MlyValue.funid funid1,funidleft as funid1left,_))::rest671)
 => let val result=MlyValue.funbind(fn _ => let val funid as funid1=
funid1 ()
val spec as spec1=spec1 ()
val sigexp as sigexp1=sigexp1 ()
val strexp__AND_funbind_opt as strexp__AND_funbind_opt1=
strexp__AND_funbind_opt1 ()
 in (
 OPAQSPECFunBind(I(funidleft,
                                            strexp__AND_funbind_optright),
                                          funid, spec, sigexp,
                                          #1 strexp__AND_funbind_opt,
                                          #2 strexp__AND_funbind_opt) 
) end
)
 in (LrTable.NT 132,(result,funid1left,strexp__AND_funbind_opt1right),
rest671) end
| (308,(_,(MlyValue.funbind funbind1,_,funbind1right))::(_,(_,AND1left
,_))::rest671) => let val result=MlyValue.AND_funbind_opt(fn _ => let 
val funbind as funbind1=funbind1 ()
 in ( SOME funbind ) end
)
 in (LrTable.NT 133,(result,AND1left,funbind1right),rest671) end
| (309,rest671) => let val result=MlyValue.AND_funbind_opt(fn _ => (
 NONE ))
 in (LrTable.NT 133,(result,defaultPos,defaultPos),rest671) end
| (310,(_,(MlyValue.AND_funbind_opt AND_funbind_opt1,_,
AND_funbind_opt1right))::(_,(MlyValue.strexp' strexp'1,strexp'1left,_)
)::rest671) => let val result=MlyValue.strexp__AND_funbind_opt(fn _
 => let val strexp' as strexp'1=strexp'1 ()
val AND_funbind_opt as AND_funbind_opt1=AND_funbind_opt1 ()
 in ( ( strexp', AND_funbind_opt ) ) end
)
 in (LrTable.NT 134,(result,strexp'1left,AND_funbind_opt1right),
rest671) end
| (311,(_,(MlyValue.sigexp__AND_funbind_opt sigexp__AND_funbind_opt1,_
,sigexp__AND_funbind_optright as sigexp__AND_funbind_opt1right))::_::(
_,(MlyValue.strexp strexp1,strexpleft as strexp1left,_))::rest671) => 
let val result=MlyValue.strexp__AND_funbind_opt(fn _ => let val strexp
 as strexp1=strexp1 ()
val sigexp__AND_funbind_opt as sigexp__AND_funbind_opt1=
sigexp__AND_funbind_opt1 ()
 in (
 ( TRANSStrExp(I(strexpleft,
                                          sigexp__AND_funbind_optright),
                                        strexp, #1 sigexp__AND_funbind_opt),
                            #2 sigexp__AND_funbind_opt ) 
) end
)
 in (LrTable.NT 134,(result,strexp1left,sigexp__AND_funbind_opt1right)
,rest671) end
| (312,(_,(MlyValue.sigexp__AND_funbind_opt sigexp__AND_funbind_opt1,_
,sigexp__AND_funbind_optright as sigexp__AND_funbind_opt1right))::_::(
_,(MlyValue.strexp strexp1,strexpleft as strexp1left,_))::rest671) => 
let val result=MlyValue.strexp__AND_funbind_opt(fn _ => let val strexp
 as strexp1=strexp1 ()
val sigexp__AND_funbind_opt as sigexp__AND_funbind_opt1=
sigexp__AND_funbind_opt1 ()
 in (
 ( OPAQStrExp(I(strexpleft,
                                         sigexp__AND_funbind_optright),
                                       strexp, #1 sigexp__AND_funbind_opt),
                            #2 sigexp__AND_funbind_opt ) 
) end
)
 in (LrTable.NT 134,(result,strexp1left,sigexp__AND_funbind_opt1right)
,rest671) end
| (313,(_,(MlyValue.AND_funbind_opt AND_funbind_opt1,_,
AND_funbind_opt1right))::(_,(MlyValue.sigexp' sigexp'1,sigexp'1left,_)
)::rest671) => let val result=MlyValue.sigexp__AND_funbind_opt(fn _
 => let val sigexp' as sigexp'1=sigexp'1 ()
val AND_funbind_opt as AND_funbind_opt1=AND_funbind_opt1 ()
 in ( ( sigexp', AND_funbind_opt ) ) end
)
 in (LrTable.NT 135,(result,sigexp'1left,AND_funbind_opt1right),
rest671) end
| (314,(_,(MlyValue.tyreadesc__AND_funbind_opt 
tyreadesc__AND_funbind_opt1,_,tyreadesc__AND_funbind_optright as 
tyreadesc__AND_funbind_opt1right))::_::(_,(MlyValue.sigexp sigexp1,
sigexpleft as sigexp1left,_))::rest671) => let val result=
MlyValue.sigexp__AND_funbind_opt(fn _ => let val sigexp as sigexp1=
sigexp1 ()
val tyreadesc__AND_funbind_opt as tyreadesc__AND_funbind_opt1=
tyreadesc__AND_funbind_opt1 ()
 in (
 ( WHERETYPESigExp(I(sigexpleft,
                                              tyreadesc__AND_funbind_optright),
                                           sigexp,
                                           #1 tyreadesc__AND_funbind_opt),
                            #2 tyreadesc__AND_funbind_opt ) 
) end
)
 in (LrTable.NT 135,(result,sigexp1left,
tyreadesc__AND_funbind_opt1right),rest671) end
| (315,(_,(MlyValue.AND_tyreadesc_opt__AND_funbind_opt 
AND_tyreadesc_opt__AND_funbind_opt1,_,
AND_tyreadesc_opt__AND_funbind_optright as 
AND_tyreadesc_opt__AND_funbind_opt1right))::(_,(MlyValue.ty ty1,_,_))
::_::(_,(MlyValue.longtycon longtycon1,_,_))::(_,(MlyValue.tyvarseq 
tyvarseq1,_,_))::(_,(_,TYPEleft as TYPE1left,_))::rest671) => let val 
result=MlyValue.tyreadesc__AND_funbind_opt(fn _ => let val tyvarseq
 as tyvarseq1=tyvarseq1 ()
val longtycon as longtycon1=longtycon1 ()
val ty as ty1=ty1 ()
val AND_tyreadesc_opt__AND_funbind_opt as 
AND_tyreadesc_opt__AND_funbind_opt1=
AND_tyreadesc_opt__AND_funbind_opt1 ()
 in (
 ( TyReaDesc(I(TYPEleft,
                                       AND_tyreadesc_opt__AND_funbind_optright),
                                      tyvarseq, longtycon, ty,
                                      #1 AND_tyreadesc_opt__AND_funbind_opt),
                            #2 AND_tyreadesc_opt__AND_funbind_opt ) 
) end
)
 in (LrTable.NT 136,(result,TYPE1left,
AND_tyreadesc_opt__AND_funbind_opt1right),rest671) end
| (316,(_,(MlyValue.AND_funbind_opt AND_funbind_opt1,
AND_funbind_opt1left,AND_funbind_opt1right))::rest671) => let val 
result=MlyValue.AND_tyreadesc_opt__AND_funbind_opt(fn _ => let val 
AND_funbind_opt as AND_funbind_opt1=AND_funbind_opt1 ()
 in ( ( NONE, AND_funbind_opt ) ) end
)
 in (LrTable.NT 137,(result,AND_funbind_opt1left,AND_funbind_opt1right
),rest671) end
| (317,(_,(MlyValue.tyreadesc__AND_funbind_opt 
tyreadesc__AND_funbind_opt1,_,tyreadesc__AND_funbind_opt1right))::(_,(
_,AND1left,_))::rest671) => let val result=
MlyValue.AND_tyreadesc_opt__AND_funbind_opt(fn _ => let val 
tyreadesc__AND_funbind_opt as tyreadesc__AND_funbind_opt1=
tyreadesc__AND_funbind_opt1 ()
 in (
 ( SOME(#1 tyreadesc__AND_funbind_opt),
                            #2 tyreadesc__AND_funbind_opt ) 
) end
)
 in (LrTable.NT 137,(result,AND1left,tyreadesc__AND_funbind_opt1right)
,rest671) end
| (318,(_,(MlyValue.topdec1 topdec11,topdec11left,topdec11right))::
rest671) => let val result=MlyValue.topdec(fn _ => let val topdec1 as 
topdec11=topdec11 ()
 in ( topdec1 ) end
)
 in (LrTable.NT 138,(result,topdec11left,topdec11right),rest671) end
| (319,rest671) => let val result=MlyValue.topdec(fn _ => (
 STRDECTopDec(I(defaultPos,defaultPos),
                                       EMPTYStrDec(I(defaultPos,defaultPos)),
                                       NONE) 
))
 in (LrTable.NT 138,(result,defaultPos,defaultPos),rest671) end
| (320,(_,(MlyValue.topdec_opt topdec_opt1,_,topdec_optright as 
topdec_opt1right))::(_,(MlyValue.strdec1' strdec1'1,strdec1'left as 
strdec1'1left,_))::rest671) => let val result=MlyValue.topdec1(fn _
 => let val strdec1' as strdec1'1=strdec1'1 ()
val topdec_opt as topdec_opt1=topdec_opt1 ()
 in (
 STRDECTopDec(I(strdec1'left,topdec_optright),
                                       strdec1', topdec_opt) 
) end
)
 in (LrTable.NT 139,(result,strdec1'1left,topdec_opt1right),rest671)
 end
| (321,(_,(MlyValue.topdec_opt topdec_opt1,_,topdec_optright as 
topdec_opt1right))::(_,(MlyValue.sigdec sigdec1,sigdecleft as 
sigdec1left,_))::rest671) => let val result=MlyValue.topdec1(fn _ => 
let val sigdec as sigdec1=sigdec1 ()
val topdec_opt as topdec_opt1=topdec_opt1 ()
 in (
 SIGDECTopDec(I(sigdecleft,topdec_optright),
                                       sigdec, topdec_opt) 
) end
)
 in (LrTable.NT 139,(result,sigdec1left,topdec_opt1right),rest671) end
| (322,(_,(MlyValue.topdec_opt topdec_opt1,_,topdec_optright as 
topdec_opt1right))::(_,(MlyValue.fundec fundec1,fundecleft as 
fundec1left,_))::rest671) => let val result=MlyValue.topdec1(fn _ => 
let val fundec as fundec1=fundec1 ()
val topdec_opt as topdec_opt1=topdec_opt1 ()
 in (
 FUNDECTopDec(I(fundecleft,topdec_optright),
                                       fundec, topdec_opt) 
) end
)
 in (LrTable.NT 139,(result,fundec1left,topdec_opt1right),rest671) end
| (323,(_,(MlyValue.topdec1 topdec11,topdec11left,topdec11right))::
rest671) => let val result=MlyValue.topdec_opt(fn _ => let val topdec1
 as topdec11=topdec11 ()
 in ( SOME topdec1 ) end
)
 in (LrTable.NT 140,(result,topdec11left,topdec11right),rest671) end
| (324,rest671) => let val result=MlyValue.topdec_opt(fn _ => ( NONE )
)
 in (LrTable.NT 140,(result,defaultPos,defaultPos),rest671) end
| (325,(_,(MlyValue.program' program'1,_,program'1right))::(_,(
MlyValue.initInfix initInfix1,initInfix1left,_))::rest671) => let val 
result=MlyValue.program(fn _ => let val initInfix1=initInfix1 ()
val program' as program'1=program'1 ()
 in ( (program', !J) ) end
)
 in (LrTable.NT 141,(result,initInfix1left,program'1right),rest671)
 end
| (326,(_,(MlyValue.program_opt program_opt1,_,program_opt1right))::(_
,(_,_,SEMICOLONright))::(_,(MlyValue.topdec topdec1,topdecleft as 
topdec1left,_))::rest671) => let val result=MlyValue.program'(fn _ => 
let val topdec as topdec1=topdec1 ()
val program_opt as program_opt1=program_opt1 ()
 in (
 TOPDECProgram(I(topdecleft,SEMICOLONright),
                                        topdec, program_opt) 
) end
)
 in (LrTable.NT 142,(result,topdec1left,program_opt1right),rest671)
 end
| (327,(_,(MlyValue.program_opt program_opt1,_,program_opt1right))::(_
,(_,_,SEMICOLONright))::(_,(MlyValue.exp exp1,expleft as exp1left,_))
::rest671) => let val result=MlyValue.program'(fn _ => let val exp as 
exp1=exp1 ()
val program_opt as program_opt1=program_opt1 ()
 in (
 EXPProgram(I(expleft,SEMICOLONright),
                                     exp, program_opt) )
 end
)
 in (LrTable.NT 142,(result,exp1left,program_opt1right),rest671) end
| (328,(_,(MlyValue.program' program'1,program'1left,program'1right))
::rest671) => let val result=MlyValue.program_opt(fn _ => let val 
program' as program'1=program'1 ()
 in ( SOME program' ) end
)
 in (LrTable.NT 143,(result,program'1left,program'1right),rest671) end
| (329,rest671) => let val result=MlyValue.program_opt(fn _ => ( NONE 
))
 in (LrTable.NT 143,(result,defaultPos,defaultPos),rest671) end
| _ => raise (mlyAction i392)
end
val void = MlyValue.VOID
val extract = fn a => (fn MlyValue.program 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 ABSTYPE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 1,(
ParserData.MlyValue.VOID,p1,p2))
fun AND (p1,p2) = Token.TOKEN (ParserData.LrTable.T 2,(
ParserData.MlyValue.VOID,p1,p2))
fun ANDALSO (p1,p2) = Token.TOKEN (ParserData.LrTable.T 3,(
ParserData.MlyValue.VOID,p1,p2))
fun AS (p1,p2) = Token.TOKEN (ParserData.LrTable.T 4,(
ParserData.MlyValue.VOID,p1,p2))
fun CASE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 5,(
ParserData.MlyValue.VOID,p1,p2))
fun DO (p1,p2) = Token.TOKEN (ParserData.LrTable.T 6,(
ParserData.MlyValue.VOID,p1,p2))
fun DATATYPE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 7,(
ParserData.MlyValue.VOID,p1,p2))
fun ELSE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 8,(
ParserData.MlyValue.VOID,p1,p2))
fun END (p1,p2) = Token.TOKEN (ParserData.LrTable.T 9,(
ParserData.MlyValue.VOID,p1,p2))
fun EXCEPTION (p1,p2) = Token.TOKEN (ParserData.LrTable.T 10,(
ParserData.MlyValue.VOID,p1,p2))
fun FN (p1,p2) = Token.TOKEN (ParserData.LrTable.T 11,(
ParserData.MlyValue.VOID,p1,p2))
fun FUN (p1,p2) = Token.TOKEN (ParserData.LrTable.T 12,(
ParserData.MlyValue.VOID,p1,p2))
fun HANDLE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 13,(
ParserData.MlyValue.VOID,p1,p2))
fun IF (p1,p2) = Token.TOKEN (ParserData.LrTable.T 14,(
ParserData.MlyValue.VOID,p1,p2))
fun IN (p1,p2) = Token.TOKEN (ParserData.LrTable.T 15,(
ParserData.MlyValue.VOID,p1,p2))
fun INFIX (p1,p2) = Token.TOKEN (ParserData.LrTable.T 16,(
ParserData.MlyValue.VOID,p1,p2))
fun INFIXR (p1,p2) = Token.TOKEN (ParserData.LrTable.T 17,(
ParserData.MlyValue.VOID,p1,p2))
fun LET (p1,p2) = Token.TOKEN (ParserData.LrTable.T 18,(
ParserData.MlyValue.VOID,p1,p2))
fun LOCAL (p1,p2) = Token.TOKEN (ParserData.LrTable.T 19,(
ParserData.MlyValue.VOID,p1,p2))
fun NONFIX (p1,p2) = Token.TOKEN (ParserData.LrTable.T 20,(
ParserData.MlyValue.VOID,p1,p2))
fun OF (p1,p2) = Token.TOKEN (ParserData.LrTable.T 21,(
ParserData.MlyValue.VOID,p1,p2))
fun OP (p1,p2) = Token.TOKEN (ParserData.LrTable.T 22,(
ParserData.MlyValue.VOID,p1,p2))
fun OPEN (p1,p2) = Token.TOKEN (ParserData.LrTable.T 23,(
ParserData.MlyValue.VOID,p1,p2))
fun ORELSE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 24,(
ParserData.MlyValue.VOID,p1,p2))
fun RAISE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 25,(
ParserData.MlyValue.VOID,p1,p2))
fun REC (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 VAL (p1,p2) = Token.TOKEN (ParserData.LrTable.T 29,(
ParserData.MlyValue.VOID,p1,p2))
fun WITH (p1,p2) = Token.TOKEN (ParserData.LrTable.T 30,(
ParserData.MlyValue.VOID,p1,p2))
fun WITHTYPE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 31,(
ParserData.MlyValue.VOID,p1,p2))
fun WHILE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 32,(
ParserData.MlyValue.VOID,p1,p2))
fun LPAR (p1,p2) = Token.TOKEN (ParserData.LrTable.T 33,(
ParserData.MlyValue.VOID,p1,p2))
fun RPAR (p1,p2) = Token.TOKEN (ParserData.LrTable.T 34,(
ParserData.MlyValue.VOID,p1,p2))
fun LBRACK (p1,p2) = Token.TOKEN (ParserData.LrTable.T 35,(
ParserData.MlyValue.VOID,p1,p2))
fun RBRACK (p1,p2) = Token.TOKEN (ParserData.LrTable.T 36,(
ParserData.MlyValue.VOID,p1,p2))
fun LBRACE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 37,(
ParserData.MlyValue.VOID,p1,p2))
fun RBRACE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 38,(
ParserData.MlyValue.VOID,p1,p2))
fun COMMA (p1,p2) = Token.TOKEN (ParserData.LrTable.T 39,(
ParserData.MlyValue.VOID,p1,p2))
fun COLON (p1,p2) = Token.TOKEN (ParserData.LrTable.T 40,(
ParserData.MlyValue.VOID,p1,p2))
fun SEMICOLON (p1,p2) = Token.TOKEN (ParserData.LrTable.T 41,(
ParserData.MlyValue.VOID,p1,p2))
fun DOTS (p1,p2) = Token.TOKEN (ParserData.LrTable.T 42,(
ParserData.MlyValue.VOID,p1,p2))
fun UNDERBAR (p1,p2) = Token.TOKEN (ParserData.LrTable.T 43,(
ParserData.MlyValue.VOID,p1,p2))
fun BAR (p1,p2) = Token.TOKEN (ParserData.LrTable.T 44,(
ParserData.MlyValue.VOID,p1,p2))
fun EQUALS (p1,p2) = Token.TOKEN (ParserData.LrTable.T 45,(
ParserData.MlyValue.VOID,p1,p2))
fun DARROW (p1,p2) = Token.TOKEN (ParserData.LrTable.T 46,(
ParserData.MlyValue.VOID,p1,p2))
fun ARROW (p1,p2) = Token.TOKEN (ParserData.LrTable.T 47,(
ParserData.MlyValue.VOID,p1,p2))
fun HASH (p1,p2) = Token.TOKEN (ParserData.LrTable.T 48,(
ParserData.MlyValue.VOID,p1,p2))
fun EQTYPE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 49,(
ParserData.MlyValue.VOID,p1,p2))
fun FUNCTOR (p1,p2) = Token.TOKEN (ParserData.LrTable.T 50,(
ParserData.MlyValue.VOID,p1,p2))
fun INCLUDE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 51,(
ParserData.MlyValue.VOID,p1,p2))
fun SHARING (p1,p2) = Token.TOKEN (ParserData.LrTable.T 52,(
ParserData.MlyValue.VOID,p1,p2))
fun SIG (p1,p2) = Token.TOKEN (ParserData.LrTable.T 53,(
ParserData.MlyValue.VOID,p1,p2))
fun SIGNATURE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 54,(
ParserData.MlyValue.VOID,p1,p2))
fun STRUCT (p1,p2) = Token.TOKEN (ParserData.LrTable.T 55,(
ParserData.MlyValue.VOID,p1,p2))
fun STRUCTURE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 56,(
ParserData.MlyValue.VOID,p1,p2))
fun WHERE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 57,(
ParserData.MlyValue.VOID,p1,p2))
fun COLONGREATER (p1,p2) = Token.TOKEN (ParserData.LrTable.T 58,(
ParserData.MlyValue.VOID,p1,p2))
fun ZERO (p1,p2) = Token.TOKEN (ParserData.LrTable.T 59,(
ParserData.MlyValue.VOID,p1,p2))
fun DIGIT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 60,(
ParserData.MlyValue.DIGIT (fn () => i),p1,p2))
fun NUMERIC (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 61,(
ParserData.MlyValue.NUMERIC (fn () => i),p1,p2))
fun INT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 62,(
ParserData.MlyValue.INT (fn () => i),p1,p2))
fun WORD (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 63,(
ParserData.MlyValue.WORD (fn () => i),p1,p2))
fun REAL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 64,(
ParserData.MlyValue.REAL (fn () => i),p1,p2))
fun STRING (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 65,(
ParserData.MlyValue.STRING (fn () => i),p1,p2))
fun CHAR (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 66,(
ParserData.MlyValue.CHAR (fn () => i),p1,p2))
fun ALPHA (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 67,(
ParserData.MlyValue.ALPHA (fn () => i),p1,p2))
fun SYMBOL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 68,(
ParserData.MlyValue.SYMBOL (fn () => i),p1,p2))
fun STAR (p1,p2) = Token.TOKEN (ParserData.LrTable.T 69,(
ParserData.MlyValue.VOID,p1,p2))
fun TYVAR (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 70,(
ParserData.MlyValue.TYVAR (fn () => i),p1,p2))
fun ETYVAR (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 71,(
ParserData.MlyValue.ETYVAR (fn () => i),p1,p2))
fun LONGID (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 72,(
ParserData.MlyValue.LONGID (fn () => i),p1,p2))
end
end
(* stop of Parser.grm.sml *)
(* start of Lexer.lex.sml *)
type int = Int.int
 functor LexerFn(structure Tokens: Parser_TOKENS) =
   struct
    structure UserDeclarations =
      struct
(*
 * Standard ML lexical analysis
 *
 * Definition, sections 2.1-2.5, 3.1
 *
 * Notes:
 *   Since all lexical classes must be disjoint:
 *   - There is no single class ID, use ALPHA|SYMBOL|STAR|EQUALS.
 *   - There is no class LAB, use ALPHA|SYMBOL|NUMERIC|DIGIT|STAR.
 *   - ID does not contain `=' and `*', those are EQUALS and STAR.
 *   - LONGID does not contain unqualified ids (but allows for `=' and `*').
 *   - INT does not contain positive decimal integers without leading 0,
 *     and single DIGIT integers, those are in NUMERIC, DIGIT, and ZERO.
 *   - NUMERIC does not contain single digit numbers, those are in DIGIT.
 *   - DIGIT does not contain 0, that is ZERO.
 *
 *   The parser uses a global variable to recognise nested comments, so it is
 *   not reentrant.
 *)


    open Tokens


    (* Types to match structure LEXER.UserDeclaration *)

    type ('a,'b) token = ('a,'b) Tokens.token
    type pos           = int
    type svalue        = Tokens.svalue
    type lexresult     = (svalue, pos) token



    (* Handling nested comments *)

    val nesting = ref 0         (* non-reentrant side-effect way :-P *)


    fun eof() =
        if !nesting = 0 then
            Tokens.EOF(0, 0)
        else
            Error.error((0,0), "unclosed comment")



    (* Some helpers to create tokens *)

    open Tokens


    fun toLRPos(yypos, yytext) =
        let
            val yypos = yypos - 2       (* bug in ML-Lex... *)
        in
            (yypos, yypos + String.size yytext)
        end

    fun token(TOKEN, yypos, yytext) =
        TOKEN(toLRPos(yypos, yytext))

    fun tokenOf(TOKEN, toVal, yypos, yytext) =
        let
            val i as (l,r) = toLRPos(yypos, yytext)
        in
            TOKEN(toVal(yytext, i), l, r)
        end

    fun error(yypos, yytext, s) =
            Error.error(toLRPos(yypos,yytext), s)

    fun invalid(yypos, yytext) =
        let
            val s = "invalid character `" ^ String.toCString yytext ^ "'"
        in
            error(yypos, yytext, s)
        end



    (* Convert identifiers *)

    fun toId(s, i)     = s

    fun toLongId(s, i) =
        let
            fun split  []    = raise Fail "Lexer.toLongId: empty longid"
              | split [x]    = ([],x)
              | split(x::xs) = let val (ys,y) = split xs in (x::ys,y) end
        in
            split(String.fields (fn c => c = #".") s)
        end


    (* Convert constants [Section 2.2] *)

    local open StringCvt in

    fun toInt(s,i) =
        (case String.explode s
          of #"0" :: #"x" :: s' =>
                  valOf(scanString (Int.scan HEX) (String.implode s'))
           | #"~" :: #"0" :: #"x" :: s' =>
                  ~(valOf(scanString (Int.scan HEX) (String.implode s')))
           | _ => valOf(scanString (Int.scan DEC) s)
        ) handle Overflow =>
                Error.error(i, "integer constant too big")

    fun toWord(s,i) =
        (case String.explode s
          of #"0" :: #"w" :: #"x" :: s' =>
                valOf(scanString (Word.scan HEX) (String.implode s'))
           | #"0" :: #"w" :: s' =>
                valOf(scanString (Word.scan DEC) (String.implode s'))
           | _ => raise Fail "Lexer.toWord: invalid word constant"
        ) handle Overflow =>
                Error.error(i, "word constant too big")

    fun toReal(s,i) = valOf(scanString Real.scan s)


    fun toString(s,i) =
        let
            fun convert(#"\\"::s, cs)  = escape(s, cs)
              | convert([#"\""],  cs)  = cs
              | convert(c::s,     cs)  = convert(s, c::cs)
              | convert([],       cs)  =
                    raise Fail "Lexer.toString: unclosed string literal"

            and escape(#"a"::s, cs)    = convert(s, #"\a"::cs)
              | escape(#"b"::s, cs)    = convert(s, #"\b"::cs)
              | escape(#"t"::s, cs)    = convert(s, #"\t"::cs)
              | escape(#"n"::s, cs)    = convert(s, #"\n"::cs)
              | escape(#"v"::s, cs)    = convert(s, #"\v"::cs)
              | escape(#"f"::s, cs)    = convert(s, #"\f"::cs)
              | escape(#"r"::s, cs)    = convert(s, #"\r"::cs)
              | escape(#"\""::s, cs)   = convert(s, #"\""::cs)
              | escape(#"\\"::s, cs)   = convert(s, #"\\"::cs)
              | escape(#"^"::c::s, cs) =
                    convert(s, Char.chr(Char.ord c - 64)::cs)

              | escape(#"u"::x1::x2::x3::x4::s, cs) =
                    convert(s, unicode[x1,x2,x3,x4]::cs)

              | escape(c::s, cs) =
                if Char.isDigit c then
                    case s
                      of c2::c3::s => convert(s, ascii[c,c2,c3]::cs)
                       | _ => raise Fail
                                "Lexer.toString: invalid ASCII escape sequence"
                else if Char.isSpace c then
                    escapeGap(s,cs)
                else
                    raise Fail "Lexer.toString: invalid escape sequence"

              | escape([], cs) =
                    raise Fail "Lexer.toString: empty escape character"

            and escapeGap(c::s, cs) =
                    if Char.isSpace c then
                        escapeGap(s, cs)
                    else (* c = #"\\" *)
                        convert(s, cs)

              | escapeGap([], cs) =
                    raise Fail "Lexer.toString: invalid string gap"

            and ascii s =
                Char.chr(valOf(scanString (Int.scan DEC) (String.implode s)))
                handle Chr =>
                         Error.error(i, "ASCII escape character too big")
                     | Overflow =>
                         Error.error(i, "ASCII escape character too big")

            and unicode s =
                Char.chr(valOf(scanString (Int.scan HEX) (String.implode s)))
                handle Chr =>
                         Error.error(i, "unicode escape character too big")
                     | Overflow =>
                         Error.error(i, "unicode escape character too big")

            val cs = List.tl(String.explode s)
        in
            String.implode(List.rev(convert(cs, [])))
        end


    fun toChar(s,i) =
        let
            val s'  = String.substring(s, 1, String.size s-1)
            val ss' = toString(s',i)
        in
            if String.size ss' = 1 then
                String.sub(ss',0)
            else if ss' = "" then
                Error.error(i, "empty character constant")
            else
                Error.error(i, "character constant too long")
        end

    end (* local *)


end (* end of user routines *)
exception LexError (* raised if illegal leaf action tried *)
structure Internal =
        struct

datatype yyfinstate = N of int
type statedata = {fin : yyfinstate list, trans: string}
(* transition & final state table *)
val tab = let
val s = [ 
 (0, 
"\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\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\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\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\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\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\000\000\000\000"
),
 (1, 
"\005\005\005\005\005\005\005\005\005\235\236\235\235\235\005\005\
\\005\005\005\005\005\005\005\005\005\005\005\005\005\005\005\005\
\\235\180\223\211\180\180\180\209\207\206\205\180\204\202\199\180\
\\191\189\189\189\189\189\189\189\189\189\187\186\180\184\180\180\
\\180\025\025\025\025\025\025\025\025\025\025\025\025\025\025\025\
\\025\025\025\025\025\025\025\025\025\025\025\183\180\182\180\181\
\\180\166\025\162\153\134\126\025\120\108\025\025\101\025\095\085\
\\025\025\078\055\048\025\045\030\025\025\025\024\023\022\006\005\
\\005\005\005\005\005\005\005\005\005\005\005\005\005\005\005\005\
\\005\005\005\005\005\005\005\005\005\005\005\005\005\005\005\005\
\\005\005\005\005\005\005\005\005\005\005\005\005\005\005\005\005\
\\005\005\005\005\005\005\005\005\005\005\005\005\005\005\005\005\
\\005\005\005\005\005\005\005\005\005\005\005\005\005\005\005\005\
\\005\005\005\005\005\005\005\005\005\005\005\005\005\005\005\005\
\\005\005\005\005\005\005\005\005\005\005\005\005\005\005\005\005\
\\005\005\005\005\005\005\005\005\005\005\005\005\005\005\005\005"
),
 (3, 
"\237\237\237\237\237\237\237\237\237\237\242\237\237\237\237\237\
\\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\
\\237\237\237\237\237\237\237\237\240\237\238\237\237\237\237\237\
\\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\
\\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\
\\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\
\\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\
\\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\
\\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\
\\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\
\\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\
\\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\
\\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\
\\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\
\\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\
\\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237\237"
),
 (6, 
"\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\007\000\007\007\007\007\000\000\000\007\007\000\007\000\007\
\\019\008\008\008\008\008\008\008\008\008\007\000\007\007\007\007\
\\007\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\007\000\007\000\
\\007\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\007\000\007\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\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\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\000\000\000"
),
 (7, 
"\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\007\000\007\007\007\007\000\000\000\007\007\000\007\000\007\
\\000\000\000\000\000\000\000\000\000\000\007\000\007\007\007\007\
\\007\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\007\000\007\000\
\\007\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\007\000\007\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\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\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\000\000\000"
),
 (8, 
"\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\000\000\000\000\013\000\
\\008\008\008\008\008\008\008\008\008\008\000\000\000\000\000\000\
\\000\000\000\000\000\009\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\009\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\
\\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\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\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"
),
 (9, 
"\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\000\000\000\000\000\000\
\\012\012\012\012\012\012\012\012\012\012\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\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\010\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\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\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\000\000\000"
),
 (10, 
"\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\000\000\000\000\000\000\
\\011\011\011\011\011\011\011\011\011\011\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\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\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\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\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"
),
 (12, 
"\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\000\000\000\000\000\000\
\\012\012\012\012\012\012\012\012\012\012\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\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\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\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\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"
),
 (13, 
"\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\000\000\000\000\000\000\
\\014\014\014\014\014\014\014\014\014\014\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\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\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\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\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"
),
 (14, 
"\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\000\000\000\000\000\000\
\\014\014\014\014\014\014\014\014\014\014\000\000\000\000\000\000\
\\000\000\000\000\000\015\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\015\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\
\\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\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\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"
),
 (15, 
"\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\000\000\000\000\000\000\
\\018\018\018\018\018\018\018\018\018\018\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\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\016\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\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\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\000\000\000"
),
 (16, 
"\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\000\000\000\000\000\000\
\\017\017\017\017\017\017\017\017\017\017\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\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\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\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\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"
),
 (18, 
"\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\000\000\000\000\000\000\
\\018\018\018\018\018\018\018\018\018\018\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\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\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\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\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"
),
 (19, 
"\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\000\000\000\000\013\000\
\\008\008\008\008\008\008\008\008\008\008\000\000\000\000\000\000\
\\000\000\000\000\000\009\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\009\000\000\000\000\000\000\000\000\000\000\
\\000\000\000\000\000\000\000\000\020\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\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\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\000\000\000\000\000\000\000\000\000"
),
 (20, 
"\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\000\000\000\000\000\000\
\\021\021\021\021\021\021\021\021\021\021\000\000\000\000\000\000\
\\000\021\021\021\021\021\021\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\021\021\021\021\021\021\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\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\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\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"
),
 (25, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (27, 
"\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\028\000\028\028\028\028\000\000\000\028\028\000\028\000\028\
\\000\000\000\000\000\000\000\000\000\000\028\000\028\028\028\028\
\\028\029\029\029\029\029\029\029\029\029\029\029\029\029\029\029\
\\029\029\029\029\029\029\029\029\029\029\029\000\028\000\028\000\
\\028\029\029\029\029\029\029\029\029\029\029\029\029\029\029\029\
\\029\029\029\029\029\029\029\029\029\029\029\000\028\000\028\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\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\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\000\000\000"
),
 (28, 
"\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\028\000\028\028\028\028\000\000\000\028\028\000\028\000\028\
\\000\000\000\000\000\000\000\000\000\000\028\000\028\028\028\028\
\\028\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\028\000\028\000\
\\028\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\028\000\028\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\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\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\000\000\000"
),
 (29, 
"\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\029\000\000\000\000\000\000\027\000\
\\029\029\029\029\029\029\029\029\029\029\000\000\000\000\000\000\
\\000\029\029\029\029\029\029\029\029\029\029\029\029\029\029\029\
\\029\029\029\029\029\029\029\029\029\029\029\000\000\000\000\029\
\\000\029\029\029\029\029\029\029\029\029\029\029\029\029\029\029\
\\029\029\029\029\029\029\029\029\029\029\029\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\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\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\000\000\000\000\000\000\000"
),
 (30, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\038\031\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (31, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\032\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (32, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\033\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (33, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\034\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (34, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\035\026\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\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\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\000\000\000\000\000\000\000"
),
 (35, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\036\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (36, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\037\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (38, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\042\026\026\026\039\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (39, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\040\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (40, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\041\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (42, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\043\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (43, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\044\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (45, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\046\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (46, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\047\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (48, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\052\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\049\026\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\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\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\000\000\000\000\000\000\000"
),
 (49, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\050\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (50, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\051\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (52, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\053\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (53, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\054\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (55, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\072\064\026\026\026\026\026\026\
\\026\026\026\026\056\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (56, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\057\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (57, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\058\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (58, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\059\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (59, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\060\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (60, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\061\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (61, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\062\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (62, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\063\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (64, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\065\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (65, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\066\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (66, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\067\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (67, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\068\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (68, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\069\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (69, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\070\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (70, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\071\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (72, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\073\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (73, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\074\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (74, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\075\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (75, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\076\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (76, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\077\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (78, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\081\026\026\026\079\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (79, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\080\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (81, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\082\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (82, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\083\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (83, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\084\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (85, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\094\026\026\026\026\026\026\026\026\026\
\\091\026\086\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (86, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\087\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (87, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\088\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (88, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\089\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (89, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\090\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (91, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\092\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (92, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\093\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (95, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\096\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (96, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\097\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (97, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\098\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (98, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\099\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (99, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\100\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (101, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\106\026\026\026\026\026\026\026\026\026\102\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (102, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\103\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (103, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\104\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (104, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\105\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (106, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\107\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (108, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\119\026\026\026\026\026\026\026\109\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (109, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\114\026\026\110\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (110, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\111\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (111, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\112\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (112, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\113\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (114, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\115\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (115, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\116\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (116, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\117\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (117, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\118\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (120, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\121\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (121, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\122\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (122, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\123\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (123, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\124\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (124, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\125\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (126, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\133\026\
\\026\026\026\026\026\127\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (127, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\128\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (128, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\129\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (129, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\130\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (130, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\131\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (131, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\132\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (134, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\150\026\148\026\
\\026\143\026\026\026\026\026\026\135\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (135, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\136\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (136, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\137\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (137, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\138\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (138, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\139\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (139, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\140\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (140, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\141\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (141, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\142\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (143, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\144\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (144, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\145\026\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\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\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\000\000\000\000\000\000\000"
),
 (145, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\146\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (146, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\147\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (148, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\149\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (150, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\151\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (151, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\152\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (153, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\155\026\026\026\026\026\026\026\026\026\026\026\026\026\154\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (155, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\156\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (156, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\157\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (157, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\158\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (158, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\159\026\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\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\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\000\000\000\000\000\000\000"
),
 (159, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\160\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (160, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\161\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (162, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\163\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (163, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\164\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (164, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\165\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (166, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\174\026\026\026\026\026\026\026\026\026\026\026\168\026\
\\026\026\026\167\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (168, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\169\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (169, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\170\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (170, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\171\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (171, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\172\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (172, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\173\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (174, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\175\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (175, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\176\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (176, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\177\026\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\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\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\000\000\000\000\000\000\000"
),
 (177, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\178\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (178, 
"\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\026\000\000\000\000\000\000\027\000\
\\026\026\026\026\026\026\026\026\026\026\000\000\000\000\000\000\
\\000\026\026\026\026\026\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\000\000\000\000\026\
\\000\026\026\026\026\179\026\026\026\026\026\026\026\026\026\026\
\\026\026\026\026\026\026\026\026\026\026\026\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\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\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\000\000\000\000\000\000\000"
),
 (184, 
"\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\007\000\007\007\007\007\000\000\000\007\007\000\007\000\007\
\\000\000\000\000\000\000\000\000\000\000\007\000\007\007\185\007\
\\007\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\007\000\007\000\
\\007\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\007\000\007\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\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\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\000\000\000"
),
 (187, 
"\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\007\000\007\007\007\007\000\000\000\007\007\000\007\000\007\
\\000\000\000\000\000\000\000\000\000\000\007\000\007\007\188\007\
\\007\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\007\000\007\000\
\\007\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\007\000\007\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\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\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\000\000\000"
),
 (189, 
"\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\000\000\000\000\013\000\
\\190\190\190\190\190\190\190\190\190\190\000\000\000\000\000\000\
\\000\000\000\000\000\009\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\009\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\
\\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\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\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"
),
 (191, 
"\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\000\000\000\000\013\000\
\\198\198\198\198\198\198\198\198\198\198\000\000\000\000\000\000\
\\000\000\000\000\000\009\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\009\000\000\000\000\000\000\000\000\000\000\
\\000\000\000\000\000\000\000\194\192\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\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\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\000\000\000\000\000\000\000\000\000"
),
 (192, 
"\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\000\000\000\000\000\000\
\\193\193\193\193\193\193\193\193\193\193\000\000\000\000\000\000\
\\000\193\193\193\193\193\193\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\193\193\193\193\193\193\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\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\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\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"
),
 (194, 
"\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\000\000\000\000\000\000\
\\197\197\197\197\197\197\197\197\197\197\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\000\000\000\000\000\000\000\000\000\000\000\000\
\\000\000\000\000\000\000\000\000\195\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\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\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\000\000\000\000\000\000\000\000\000"
),
 (195, 
"\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\000\000\000\000\000\000\
\\196\196\196\196\196\196\196\196\196\196\000\000\000\000\000\000\
\\000\196\196\196\196\196\196\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\196\196\196\196\196\196\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\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\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\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"
),
 (197, 
"\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\000\000\000\000\000\000\
\\197\197\197\197\197\197\197\197\197\197\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\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\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\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\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"
),
 (198, 
"\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\000\000\000\000\013\000\
\\198\198\198\198\198\198\198\198\198\198\000\000\000\000\000\000\
\\000\000\000\000\000\009\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\009\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\
\\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\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\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"
),
 (199, 
"\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\000\000\000\000\200\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\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\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\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\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"
),
 (200, 
"\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\000\000\000\000\201\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\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\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\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\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"
),
 (202, 
"\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\007\000\007\007\007\007\000\000\000\007\007\000\007\000\007\
\\000\000\000\000\000\000\000\000\000\000\007\000\007\007\203\007\
\\007\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\007\000\007\000\
\\007\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\007\000\007\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\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\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\000\000\000"
),
 (207, 
"\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\208\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\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\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\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\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\000\000\000"
),
 (209, 
"\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\210\000\000\000\000\000\000\000\000\
\\210\210\210\210\210\210\210\210\210\210\000\000\000\000\000\000\
\\000\210\210\210\210\210\210\210\210\210\210\210\210\210\210\210\
\\210\210\210\210\210\210\210\210\210\210\210\000\000\000\000\210\
\\000\210\210\210\210\210\210\210\210\210\210\210\210\210\210\210\
\\210\210\210\210\210\210\210\210\210\210\210\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\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\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\000\000\000\000\000\000\000"
),
 (211, 
"\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\007\212\007\007\007\007\000\000\000\007\007\000\007\000\007\
\\000\000\000\000\000\000\000\000\000\000\007\000\007\007\007\007\
\\007\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\007\000\007\000\
\\007\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\007\000\007\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\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\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\000\000\000"
),
 (212, 
"\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\
\\212\212\222\212\212\212\212\212\212\212\212\212\212\212\212\212\
\\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\
\\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\
\\212\212\212\212\212\212\212\212\212\212\212\212\213\212\212\212\
\\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\
\\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\000\
\\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\
\\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\
\\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\
\\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\
\\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\
\\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\
\\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\
\\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212"
),
 (213, 
"\000\000\000\000\000\000\000\000\000\221\221\221\221\221\000\000\
\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\\221\000\212\000\000\000\000\000\000\000\000\000\000\000\000\000\
\\219\219\219\219\219\219\219\219\219\219\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\212\000\218\000\
\\000\212\212\000\000\000\212\000\000\000\000\000\000\000\212\000\
\\000\000\212\000\212\214\212\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\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\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\000\000\000\000\000\000\000\000\000\000\000"
),
 (214, 
"\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\000\000\000\000\000\000\
\\215\215\215\215\215\215\215\215\215\215\000\000\000\000\000\000\
\\000\215\215\215\215\215\215\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\215\215\215\215\215\215\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\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\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\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"
),
 (215, 
"\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\000\000\000\000\000\000\
\\216\216\216\216\216\216\216\216\216\216\000\000\000\000\000\000\
\\000\216\216\216\216\216\216\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\216\216\216\216\216\216\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\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\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\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"
),
 (216, 
"\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\000\000\000\000\000\000\
\\217\217\217\217\217\217\217\217\217\217\000\000\000\000\000\000\
\\000\217\217\217\217\217\217\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\217\217\217\217\217\217\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\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\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\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"
),
 (217, 
"\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\000\000\000\000\000\000\
\\212\212\212\212\212\212\212\212\212\212\000\000\000\000\000\000\
\\000\212\212\212\212\212\212\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\212\212\212\212\212\212\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\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\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\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"
),
 (218, 
"\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\000\000\000\000\000\000\
\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\
\\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\212\
\\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\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\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\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"
),
 (219, 
"\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\000\000\000\000\000\000\
\\220\220\220\220\220\220\220\220\220\220\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\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\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\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\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"
),
 (220, 
"\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\000\000\000\000\000\000\
\\212\212\212\212\212\212\212\212\212\212\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\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\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\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\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"
),
 (221, 
"\000\000\000\000\000\000\000\000\000\221\221\221\221\221\000\000\
\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\\221\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\000\000\000\000\000\
\\000\000\000\000\000\000\000\000\000\000\000\000\212\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\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\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\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"
),
 (223, 
"\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\
\\224\224\234\224\224\224\224\224\224\224\224\224\224\224\224\224\
\\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\
\\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\
\\224\224\224\224\224\224\224\224\224\224\224\224\225\224\224\224\
\\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\
\\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\000\
\\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\
\\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\
\\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\
\\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\
\\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\
\\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\
\\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\
\\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224"
),
 (225, 
"\000\000\000\000\000\000\000\000\000\233\233\233\233\233\000\000\
\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\\233\000\224\000\000\000\000\000\000\000\000\000\000\000\000\000\
\\231\231\231\231\231\231\231\231\231\231\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\224\000\230\000\
\\000\224\224\000\000\000\224\000\000\000\000\000\000\000\224\000\
\\000\000\224\000\224\226\224\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\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\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\000\000\000\000\000\000\000\000\000\000\000"
),
 (226, 
"\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\000\000\000\000\000\000\
\\227\227\227\227\227\227\227\227\227\227\000\000\000\000\000\000\
\\000\227\227\227\227\227\227\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\227\227\227\227\227\227\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\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\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\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"
),
 (227, 
"\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\000\000\000\000\000\000\
\\228\228\228\228\228\228\228\228\228\228\000\000\000\000\000\000\
\\000\228\228\228\228\228\228\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\228\228\228\228\228\228\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\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\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\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"
),
 (228, 
"\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\000\000\000\000\000\000\
\\229\229\229\229\229\229\229\229\229\229\000\000\000\000\000\000\
\\000\229\229\229\229\229\229\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\229\229\229\229\229\229\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\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\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\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"
),
 (229, 
"\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\000\000\000\000\000\000\
\\224\224\224\224\224\224\224\224\224\224\000\000\000\000\000\000\
\\000\224\224\224\224\224\224\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\224\224\224\224\224\224\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\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\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\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"
),
 (230, 
"\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\000\000\000\000\000\000\
\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\
\\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\224\
\\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\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\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\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"
),
 (231, 
"\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\000\000\000\000\000\000\
\\232\232\232\232\232\232\232\232\232\232\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\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\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\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\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"
),
 (232, 
"\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\000\000\000\000\000\000\
\\224\224\224\224\224\224\224\224\224\224\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\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\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\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\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"
),
 (233, 
"\000\000\000\000\000\000\000\000\000\233\233\233\233\233\000\000\
\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\\233\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\000\000\000\000\000\
\\000\000\000\000\000\000\000\000\000\000\000\000\224\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\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\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\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"
),
 (235, 
"\000\000\000\000\000\000\000\000\000\236\236\236\236\236\000\000\
\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\\236\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\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\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\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\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\000\000\000\000\000\000\000\000\000\000\000\000\000"
),
 (238, 
"\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\239\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\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\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\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\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\000\000\000\000"
),
 (240, 
"\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\241\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\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\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\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\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\000\000\000"
),
(0, "")]
fun f x = x 
val s = map f (rev (tl (rev s))) 
exception LexHackingError 
fun look ((j,x)::r, i) = if i = j then x else look(r, i) 
  | look ([], i) = raise LexHackingError
fun g {fin=x, trans=i} = {fin=x, trans=look(s,i)} 
in Vector.fromList(map g 
[{fin = [], trans = 0},
{fin = [], trans = 1},
{fin = [], trans = 1},
{fin = [], trans = 3},
{fin = [], trans = 3},
{fin = [(N 472)], trans = 0},
{fin = [(N 436),(N 472)], trans = 6},
{fin = [(N 436)], trans = 7},
{fin = [(N 304)], trans = 8},
{fin = [], trans = 9},
{fin = [], trans = 10},
{fin = [(N 342)], trans = 10},
{fin = [(N 342)], trans = 12},
{fin = [], trans = 13},
{fin = [(N 342)], trans = 14},
{fin = [], trans = 15},
{fin = [], trans = 16},
{fin = [(N 342)], trans = 16},
{fin = [(N 342)], trans = 18},
{fin = [(N 304)], trans = 19},
{fin = [], trans = 20},
{fin = [(N 304)], trans = 20},
{fin = [(N 43),(N 472)], trans = 0},
{fin = [(N 41),(N 436),(N 472)], trans = 7},
{fin = [(N 39),(N 472)], trans = 0},
{fin = [(N 433),(N 472)], trans = 25},
{fin = [(N 433)], trans = 25},
{fin = [], trans = 27},
{fin = [(N 455)], trans = 28},
{fin = [(N 455)], trans = 29},
{fin = [(N 433),(N 472)], trans = 30},
{fin = [(N 433)], trans = 31},
{fin = [(N 433)], trans = 32},
{fin = [(N 273),(N 433)], trans = 33},
{fin = [(N 433)], trans = 34},
{fin = [(N 433)], trans = 35},
{fin = [(N 433)], trans = 36},
{fin = [(N 282),(N 433)], trans = 25},
{fin = [(N 433)], trans = 38},
{fin = [(N 433)], trans = 39},
{fin = [(N 433)], trans = 40},
{fin = [(N 268),(N 433)], trans = 25},
{fin = [(N 433)], trans = 42},
{fin = [(N 433)], trans = 43},
{fin = [(N 262),(N 433)], trans = 25},
{fin = [(N 433),(N 472)], trans = 45},
{fin = [(N 433)], trans = 46},
{fin = [(N 256),(N 433)], trans = 25},
{fin = [(N 433),(N 472)], trans = 48},
{fin = [(N 433)], trans = 49},
{fin = [(N 433)], trans = 50},
{fin = [(N 252),(N 433)], trans = 25},
{fin = [(N 433)], trans = 52},
{fin = [(N 433)], trans = 53},
{fin = [(N 247),(N 433)], trans = 25},
{fin = [(N 433),(N 472)], trans = 55},
{fin = [(N 433)], trans = 56},
{fin = [(N 433)], trans = 57},
{fin = [(N 433)], trans = 58},
{fin = [(N 433)], trans = 59},
{fin = [(N 232),(N 433)], trans = 60},
{fin = [(N 433)], trans = 61},
{fin = [(N 433)], trans = 62},
{fin = [(N 242),(N 433)], trans = 25},
{fin = [(N 433)], trans = 64},
{fin = [(N 215),(N 433)], trans = 65},
{fin = [(N 433)], trans = 66},
{fin = [(N 433)], trans = 67},
{fin = [(N 433)], trans = 68},
{fin = [(N 433)], trans = 69},
{fin = [(N 433)], trans = 70},
{fin = [(N 225),(N 433)], trans = 25},
{fin = [(N 433)], trans = 72},
{fin = [(N 433)], trans = 73},
{fin = [(N 433)], trans = 74},
{fin = [(N 433)], trans = 75},
{fin = [(N 433)], trans = 76},
{fin = [(N 211),(N 433)], trans = 25},
{fin = [(N 433),(N 472)], trans = 78},
{fin = [(N 433)], trans = 79},
{fin = [(N 203),(N 433)], trans = 25},
{fin = [(N 433)], trans = 81},
{fin = [(N 433)], trans = 82},
{fin = [(N 433)], trans = 83},
{fin = [(N 199),(N 433)], trans = 25},
{fin = [(N 433),(N 472)], trans = 85},
{fin = [(N 433)], trans = 86},
{fin = [(N 433)], trans = 87},
{fin = [(N 433)], trans = 88},
{fin = [(N 433)], trans = 89},
{fin = [(N 193),(N 433)], trans = 25},
{fin = [(N 181),(N 433)], trans = 91},
{fin = [(N 433)], trans = 92},
{fin = [(N 186),(N 433)], trans = 25},
{fin = [(N 178),(N 433)], trans = 25},
{fin = [(N 433),(N 472)], trans = 95},
{fin = [(N 433)], trans = 96},
{fin = [(N 433)], trans = 97},
{fin = [(N 433)], trans = 98},
{fin = [(N 433)], trans = 99},
{fin = [(N 175),(N 433)], trans = 25},
{fin = [(N 433),(N 472)], trans = 101},
{fin = [(N 433)], trans = 102},
{fin = [(N 433)], trans = 103},
{fin = [(N 433)], trans = 104},
{fin = [(N 168),(N 433)], trans = 25},
{fin = [(N 433)], trans = 106},
{fin = [(N 162),(N 433)], trans = 25},
{fin = [(N 433),(N 472)], trans = 108},
{fin = [(N 137),(N 433)], trans = 109},
{fin = [(N 433)], trans = 110},
{fin = [(N 433)], trans = 111},
{fin = [(N 151),(N 433)], trans = 112},
{fin = [(N 158),(N 433)], trans = 25},
{fin = [(N 433)], trans = 114},
{fin = [(N 433)], trans = 115},
{fin = [(N 433)], trans = 116},
{fin = [(N 433)], trans = 117},
{fin = [(N 145),(N 433)], trans = 25},
{fin = [(N 134),(N 433)], trans = 25},
{fin = [(N 433),(N 472)], trans = 120},
{fin = [(N 433)], trans = 121},
{fin = [(N 433)], trans = 122},
{fin = [(N 433)], trans = 123},
{fin = [(N 433)], trans = 124},
{fin = [(N 131),(N 433)], trans = 25},
{fin = [(N 433),(N 472)], trans = 126},
{fin = [(N 433)], trans = 127},
{fin = [(N 116),(N 433)], trans = 128},
{fin = [(N 433)], trans = 129},
{fin = [(N 433)], trans = 130},
{fin = [(N 433)], trans = 131},
{fin = [(N 124),(N 433)], trans = 25},
{fin = [(N 112),(N 433)], trans = 25},
{fin = [(N 433),(N 472)], trans = 134},
{fin = [(N 433)], trans = 135},
{fin = [(N 433)], trans = 136},
{fin = [(N 433)], trans = 137},
{fin = [(N 433)], trans = 138},
{fin = [(N 433)], trans = 139},
{fin = [(N 433)], trans = 140},
{fin = [(N 433)], trans = 141},
{fin = [(N 109),(N 433)], trans = 25},
{fin = [(N 433)], trans = 143},
{fin = [(N 433)], trans = 144},
{fin = [(N 433)], trans = 145},
{fin = [(N 433)], trans = 146},
{fin = [(N 99),(N 433)], trans = 25},
{fin = [(N 433)], trans = 148},
{fin = [(N 92),(N 433)], trans = 25},
{fin = [(N 433)], trans = 150},
{fin = [(N 433)], trans = 151},
{fin = [(N 88),(N 433)], trans = 25},
{fin = [(N 433),(N 472)], trans = 153},
{fin = [(N 83),(N 433)], trans = 25},
{fin = [(N 433)], trans = 155},
{fin = [(N 433)], trans = 156},
{fin = [(N 433)], trans = 157},
{fin = [(N 433)], trans = 158},
{fin = [(N 433)], trans = 159},
{fin = [(N 433)], trans = 160},
{fin = [(N 80),(N 433)], trans = 25},
{fin = [(N 433),(N 472)], trans = 162},
{fin = [(N 433)], trans = 163},
{fin = [(N 433)], trans = 164},
{fin = [(N 71),(N 433)], trans = 25},
{fin = [(N 433),(N 472)], trans = 166},
{fin = [(N 66),(N 433)], trans = 25},
{fin = [(N 433)], trans = 168},
{fin = [(N 55),(N 433)], trans = 169},
{fin = [(N 433)], trans = 170},
{fin = [(N 433)], trans = 171},
{fin = [(N 433)], trans = 172},
{fin = [(N 63),(N 433)], trans = 25},
{fin = [(N 433)], trans = 174},
{fin = [(N 433)], trans = 175},
{fin = [(N 433)], trans = 176},
{fin = [(N 433)], trans = 177},
{fin = [(N 433)], trans = 178},
{fin = [(N 51),(N 433)], trans = 25},
{fin = [(N 436),(N 472)], trans = 7},
{fin = [(N 37),(N 472)], trans = 0},
{fin = [(N 35),(N 472)], trans = 0},
{fin = [(N 33),(N 472)], trans = 0},
{fin = [(N 28),(N 436),(N 472)], trans = 184},
{fin = [(N 31),(N 436)], trans = 7},
{fin = [(N 26),(N 472)], trans = 0},
{fin = [(N 21),(N 436),(N 472)], trans = 187},
{fin = [(N 24),(N 436)], trans = 7},
{fin = [(N 286),(N 289),(N 304),(N 472)], trans = 189},
{fin = [(N 289),(N 304)], trans = 189},
{fin = [(N 284),(N 304),(N 472)], trans = 191},
{fin = [], trans = 192},
{fin = [(N 304)], trans = 192},
{fin = [], trans = 194},
{fin = [], trans = 195},
{fin = [(N 314)], trans = 195},
{fin = [(N 314)], trans = 197},
{fin = [(N 304)], trans = 198},
{fin = [(N 472)], trans = 199},
{fin = [], trans = 200},
{fin = [(N 19)], trans = 0},
{fin = [(N 436),(N 472)], trans = 202},
{fin = [(N 15),(N 436)], trans = 7},
{fin = [(N 12),(N 472)], trans = 0},
{fin = [(N 10),(N 436),(N 472)], trans = 7},
{fin = [(N 8),(N 472)], trans = 0},
{fin = [(N 6),(N 472)], trans = 207},
{fin = [(N 458)], trans = 0},
{fin = [(N 428),(N 472)], trans = 209},
{fin = [(N 428)], trans = 209},
{fin = [(N 4),(N 436),(N 472)], trans = 211},
{fin = [], trans = 212},
{fin = [], trans = 213},
{fin = [], trans = 214},
{fin = [], trans = 215},
{fin = [], trans = 216},
{fin = [], trans = 217},
{fin = [], trans = 218},
{fin = [], trans = 219},
{fin = [], trans = 220},
{fin = [], trans = 221},
{fin = [(N 423)], trans = 0},
{fin = [(N 470),(N 472)], trans = 223},
{fin = [], trans = 223},
{fin = [], trans = 225},
{fin = [], trans = 226},
{fin = [], trans = 227},
{fin = [], trans = 228},
{fin = [], trans = 229},
{fin = [], trans = 230},
{fin = [], trans = 231},
{fin = [], trans = 232},
{fin = [], trans = 233},
{fin = [(N 382)], trans = 0},
{fin = [(N 2),(N 472)], trans = 235},
{fin = [(N 2)], trans = 235},
{fin = [(N 466)], trans = 0},
{fin = [(N 466)], trans = 238},
{fin = [(N 464)], trans = 0},
{fin = [(N 466)], trans = 240},
{fin = [(N 461)], trans = 0},
{fin = [(N 468)], trans = 0}])
end
structure StartStates =
        struct
        datatype yystartstate = STARTSTATE of int

(* start state definitions *)

val COMMENT = STARTSTATE 3;
val INITIAL = STARTSTATE 1;

end
type result = UserDeclarations.lexresult
        exception LexerError (* raised if illegal leaf action tried *)
end

type int = Int.int
fun makeLexer (yyinput: int -> string) =
let     val yygone0:int=1
        val yyb = ref "\n"              (* buffer *)
        val yybl: int ref = ref 1               (*buffer length *)
        val yybufpos: int ref = ref 1           (* location of next character to use *)
        val yygone: int ref = ref yygone0       (* position in file of beginning of buffer *)
        val yydone = ref false          (* eof found yet? *)
        val yybegin: int ref = ref 1            (*Current 'start state' for lexer *)

        val YYBEGIN = fn (Internal.StartStates.STARTSTATE x) =>
                 yybegin := x

fun lex () : Internal.result =
let fun continue() = lex() in
  let fun scan (s,AcceptingLeaves : Internal.yyfinstate list list,l,i0: int) =
        let fun action (i: int,nil) = raise LexError
        | action (i,nil::l) = action (i-1,l)
        | action (i,(node::acts)::l) =
                case node of
                    Internal.N yyk => 
                        (let fun yymktext() = String.substring(!yyb,i0,i-i0)
                             val yypos: int = i0+ !yygone
                        open UserDeclarations Internal.StartStates
 in (yybufpos := i; case yyk of 

                        (* Application actions *)

  10 => let val yytext=yymktext() in  token(STAR,      yypos, yytext)  end
| 109 => let val yytext=yymktext() in  token(EXCEPTION, yypos, yytext)  end
| 112 => let val yytext=yymktext() in  token(FN,        yypos, yytext)  end
| 116 => let val yytext=yymktext() in  token(FUN,       yypos, yytext)  end
| 12 => let val yytext=yymktext() in  token(COMMA,     yypos, yytext)  end
| 124 => let val yytext=yymktext() in  token(FUNCTOR,   yypos, yytext)  end
| 131 => let val yytext=yymktext() in  token(HANDLE,    yypos, yytext)  end
| 134 => let val yytext=yymktext() in  token(IF,        yypos, yytext)  end
| 137 => let val yytext=yymktext() in  token(IN,        yypos, yytext)  end
| 145 => let val yytext=yymktext() in  token(INCLUDE,   yypos, yytext)  end
| 15 => let val yytext=yymktext() in  token(ARROW,     yypos, yytext)  end
| 151 => let val yytext=yymktext() in  token(INFIX,     yypos, yytext)  end
| 158 => let val yytext=yymktext() in  token(INFIXR,    yypos, yytext)  end
| 162 => let val yytext=yymktext() in  token(LET,       yypos, yytext)  end
| 168 => let val yytext=yymktext() in  token(LOCAL,     yypos, yytext)  end
| 175 => let val yytext=yymktext() in  token(NONFIX,    yypos, yytext)  end
| 178 => let val yytext=yymktext() in  token(OF,        yypos, yytext)  end
| 181 => let val yytext=yymktext() in  token(OP,        yypos, yytext)  end
| 186 => let val yytext=yymktext() in  token(OPEN,      yypos, yytext)  end
| 19 => let val yytext=yymktext() in  token(DOTS,      yypos, yytext)  end
| 193 => let val yytext=yymktext() in  token(ORELSE,    yypos, yytext)  end
| 199 => let val yytext=yymktext() in  token(RAISE,     yypos, yytext)  end
| 2 => ( continue() )
| 203 => let val yytext=yymktext() in  token(REC,       yypos, yytext)  end
| 21 => let val yytext=yymktext() in  token(COLON,     yypos, yytext)  end
| 211 => let val yytext=yymktext() in  token(SHARING,   yypos, yytext)  end
| 215 => let val yytext=yymktext() in  token(SIG,       yypos, yytext)  end
| 225 => let val yytext=yymktext() in  token(SIGNATURE, yypos, yytext)  end
| 232 => let val yytext=yymktext() in  token(STRUCT,    yypos, yytext)  end
| 24 => let val yytext=yymktext() in  token(COLONGREATER, yypos, yytext)  end
| 242 => let val yytext=yymktext() in  token(STRUCTURE, yypos, yytext)  end
| 247 => let val yytext=yymktext() in  token(THEN,      yypos, yytext)  end
| 252 => let val yytext=yymktext() in  token(TYPE,      yypos, yytext)  end
| 256 => let val yytext=yymktext() in  token(VAL,       yypos, yytext)  end
| 26 => let val yytext=yymktext() in  token(SEMICOLON, yypos, yytext)  end
| 262 => let val yytext=yymktext() in  token(WHERE,     yypos, yytext)  end
| 268 => let val yytext=yymktext() in  token(WHILE,     yypos, yytext)  end
| 273 => let val yytext=yymktext() in  token(WITH,      yypos, yytext)  end
| 28 => let val yytext=yymktext() in  token(EQUALS,    yypos, yytext)  end
| 282 => let val yytext=yymktext() in  token(WITHTYPE,  yypos, yytext)  end
| 284 => let val yytext=yymktext() in  token  (ZERO,              yypos, yytext)  end
| 286 => let val yytext=yymktext() in  tokenOf(DIGIT,   toInt,    yypos, yytext)  end
| 289 => let val yytext=yymktext() in  tokenOf(NUMERIC, toInt,    yypos, yytext)  end
| 304 => let val yytext=yymktext() in  tokenOf(INT,     toInt,    yypos, yytext)  end
| 31 => let val yytext=yymktext() in  token(DARROW,    yypos, yytext)  end
| 314 => let val yytext=yymktext() in  tokenOf(WORD,    toWord,   yypos, yytext)  end
| 33 => let val yytext=yymktext() in  token(LBRACK,    yypos, yytext)  end
| 342 => let val yytext=yymktext() in  tokenOf(REAL,    toReal,   yypos, yytext)  end
| 35 => let val yytext=yymktext() in  token(RBRACK,    yypos, yytext)  end
| 37 => let val yytext=yymktext() in  token(UNDERBAR,  yypos, yytext)  end
| 382 => let val yytext=yymktext() in  tokenOf(STRING,  toString, yypos, yytext)  end
| 39 => let val yytext=yymktext() in  token(LBRACE,    yypos, yytext)  end
| 4 => let val yytext=yymktext() in  token(HASH,      yypos, yytext)  end
| 41 => let val yytext=yymktext() in  token(BAR,       yypos, yytext)  end
| 423 => let val yytext=yymktext() in  tokenOf(CHAR,    toChar,   yypos, yytext)  end
| 428 => let val yytext=yymktext() in  tokenOf(TYVAR,   toId,     yypos, yytext)  end
| 43 => let val yytext=yymktext() in  token(RBRACE,    yypos, yytext)  end
| 433 => let val yytext=yymktext() in  tokenOf(ALPHA,   toId,     yypos, yytext)  end
| 436 => let val yytext=yymktext() in  tokenOf(SYMBOL,  toId,     yypos, yytext)  end
| 455 => let val yytext=yymktext() in  tokenOf(LONGID,  toLongId, yypos, yytext)  end
| 458 => ( nesting := 1 ; YYBEGIN COMMENT ; continue() )
| 461 => ( nesting := !nesting+1 ; continue() )
| 464 => ( nesting := !nesting-1 ;
                             if !nesting = 0 then YYBEGIN INITIAL else () ;
                             continue() )
| 466 => ( continue() )
| 468 => ( continue() )
| 470 => let val yytext=yymktext() in  error(yypos, yytext, "invalid string")  end
| 472 => let val yytext=yymktext() in  invalid(yypos, yytext)  end
| 51 => let val yytext=yymktext() in  token(ABSTYPE,   yypos, yytext)  end
| 55 => let val yytext=yymktext() in  token(AND,       yypos, yytext)  end
| 6 => let val yytext=yymktext() in  token(LPAR,      yypos, yytext)  end
| 63 => let val yytext=yymktext() in  token(ANDALSO,   yypos, yytext)  end
| 66 => let val yytext=yymktext() in  token(AS,        yypos, yytext)  end
| 71 => let val yytext=yymktext() in  token(CASE,      yypos, yytext)  end
| 8 => let val yytext=yymktext() in  token(RPAR,      yypos, yytext)  end
| 80 => let val yytext=yymktext() in  token(DATATYPE,  yypos, yytext)  end
| 83 => let val yytext=yymktext() in  token(DO,        yypos, yytext)  end
| 88 => let val yytext=yymktext() in  token(ELSE,      yypos, yytext)  end
| 92 => let val yytext=yymktext() in  token(END,       yypos, yytext)  end
| 99 => let val yytext=yymktext() in  token(EQTYPE,    yypos, yytext)  end
| _ => raise Internal.LexerError

                ) end )

        val {fin,trans} = Vector.sub(Internal.tab, s)
        val NewAcceptingLeaves = fin::AcceptingLeaves
        in if l = !yybl then
             if trans = #trans(Vector.sub(Internal.tab,0))
               then action(l,NewAcceptingLeaves
) else      let val newchars= if !yydone then "" else yyinput 1024
            in if (String.size newchars)=0
                  then (yydone := true;
                        if (l=i0) then UserDeclarations.eof ()
                                  else action(l,NewAcceptingLeaves))
                  else (if i0=l then yyb := newchars
                     else yyb := String.substring(!yyb,i0,l-i0)^newchars;
                     yygone := !yygone+i0;
                     yybl := String.size (!yyb);
                     scan (s,AcceptingLeaves,l-i0,0))
            end
          else let val NewChar = Char.ord(CharVector.sub(!yyb,l))
                val NewState = Char.ord(CharVector.sub(trans,NewChar))
                in if NewState=0 then action(l,NewAcceptingLeaves)
                else scan(NewState,NewAcceptingLeaves,l+1,i0)
        end
        end
(*
        val start= if String.substring(!yyb,!yybufpos-1,1)="\n"
then !yybegin+1 else !yybegin
*)
        in scan(!yybegin (* start *),nil,!yybufpos,!yybufpos)
    end
end
  in lex
  end
end
(* stop of Lexer.lex.sml *)
(* start of PARSE.sml *)
signature PARSE =
  sig

    (* Import *)

    type source  = Source.source
    type InfEnv  = Infix.InfEnv
    type Program = GrammarProgram.Program


    (* Export *)

    val parse: InfEnv * source -> InfEnv * Program

  end
(* stop of PARSE.sml *)
(* start of Parse.sml *)
structure Parse :> PARSE =
  struct

    (* Import *)

    type source  = Source.source
    type InfEnv  = Infix.InfEnv
    type Program = GrammarProgram.Program


    (* Build Yacc parser *)

    structure LrVals = LrValsFn(structure Token      = LrParser.Token)
    structure Lexer  = LexerFn (structure Tokens     = LrVals.Tokens)
    structure Parser = Join    (structure LrParser   = LrParser
                                structure ParserData = LrVals.ParserData
                                structure Lex        = Lexer)


    (* The actual parsing function *)

    fun parse(J, source) =
        let
            val yyread = ref false
            fun yyinput _ =
                if !yyread then
                    ""
                else
                    ( yyread := true; source )

            val lexer = Parser.makeLexer yyinput

            fun onError(s, pos1, pos2) = Error.error((pos1,pos2), s)

            val ((program,J'), lexer') = Parser.parse(0, lexer, onError, J)
        in
            (J',program)
        end

  end
(* stop of Parse.sml *)
(* start of SML.sml *)
(*
 * Standard ML implementation main structure
 *)

signature SML =
  sig

    val parseString:    string -> unit  (* Parse only *)
    val elabString:     string -> unit  (* Parse and elaborate *)
    val evalString:     string -> unit  (* Parse and evaluate *)
    val execString:     string -> unit  (* Parse, elaborate, and evaluate *)

    val parseFile:      string -> unit
    val elabFile:       string -> unit
    val evalFile:       string -> unit
    val execFile:       string -> unit

    val parseFiles:     string -> unit
    val elabFiles:      string -> unit
    val evalFiles:      string -> unit
    val execFiles:      string -> unit

    val parseSession:   unit -> unit
    val elabSession:    unit -> unit
    val evalSession:    unit -> unit
    val execSession:    unit -> unit

  end
(* stop of SML.sml *)
(* start of Sml.sml *)
(*
 * Standard ML implementation main structure
 *)

structure Sml :> SML =
  struct

    (* Initial arguments *)

    val J0      = InitialInfixEnv.J0
    val B_STAT0 = InitialStaticBasis.B0
    val B_DYN0  = InitialDynamicBasis.B0
    val B0      = (B_STAT0, B_DYN0)
    val s0      = InitialDynamicBasis.s


    (* Parsing only *)

    fun parse J source =
        let
            val (J',program) = Parse.parse(J, source)
            val    _         = TextIO.output(TextIO.stdOut, "OK\n")
        in
            J'
        end

    val parseInitialArg = J0
    val parseInitial    = parse parseInitialArg


    (* Parsing and elaboration *)

    val elabInitialArg = (J0, B_STAT0)

    fun elab (J, B_STAT) source =
        let
            val (J',program) = Parse.parse(J, source)
            val B_STAT'      = Program.elabProgram(B_STAT, program)
        in
            (J', B_STAT')
        end


    (* Parsing and evaluation *)

    val evalInitialArg = (J0, B_DYN0, s0)

    fun eval (J, B_DYN, s) source =
        let
            val (J',program) = Parse.parse(J, source)
            val s'           = ref s
            val B_DYN'       = Program.evalProgram(s', B_DYN, program)
        in
            (J', B_DYN', !s')
        end


    (* Parsing, elaboration, and evaluation *)

    val execInitialArg = (J0, B0, s0)

    fun exec (J, B, s) source =
        let
            val (J',program) = Parse.parse(J, source)
            val s'           = ref s
            val B'           = Program.execProgram(s', B, program)
        in
            (J', B', !s' )
        end


    (* Processing of strings *)

    fun processString (process, arg) source =
            ignore(process arg source)
            handle Error.Error _ => ()  (* Syntax error *)

    val parseString = processString(parse, parseInitialArg)
    val elabString  = processString(elab, elabInitialArg)
    val evalString  = processString(eval, evalInitialArg)
    val execString  = processString(exec, execInitialArg)


    (* Processing of files *)

    fun processFile (process, arg) name =
        let
            val file   = TextIO.openIn name
            val source = TextIO.inputAll file
            val _      = TextIO.closeIn file
        in
            ignore(process arg source)
            handle Error.Error _ => ()  (* Syntax error *)
        end

    val parseFile = processFile(parse, parseInitialArg)
    val elabFile  = processFile(elab, elabInitialArg)
    val evalFile  = processFile(eval, evalInitialArg)
    val execFile  = processFile(exec, execInitialArg)


    (* Processing several files mentioned in a list file *)

    fun processFiles (process, initialArg) name =
        let
            val file    = TextIO.openIn name
            val content = TextIO.inputAll file
            val _       = TextIO.closeIn file

            val _       = Stamp.reset()

            fun loop(arg,     [] )     = ()
              | loop(arg,  "" ::names) = loop(arg, names)
              | loop(arg, name::names) =
                let
                    val file   = TextIO.openIn name
                    val source = TextIO.inputAll file
                    val _      = TextIO.closeIn file
                    val _      = TextIO.output(TextIO.stdOut,
                                               ">> File \"" ^ name ^ "\":\n")
                in
                    loop(process arg source, names)
                    handle Error.Error _ =>     (* Syntax error *)
                        loop(arg, names)
                end
        in
            loop(initialArg, String.fields Char.isSpace content)
        end

    val parseFiles = processFiles(parse, parseInitialArg)
    val elabFiles  = processFiles(elab,  elabInitialArg)
    val evalFiles  = processFiles(eval,  evalInitialArg)
    val execFiles  = processFiles(exec,  execInitialArg)


    (* Session *)

    fun processSession(process, initialArg) =
        let
           val ins = !ins
            fun loop arg =
                let
                    val _      = TextIO.output(TextIO.stdOut, "SML> ")
                    val _      = TextIO.flushOut TextIO.stdOut
                in
                   case TextIO.inputLine ins of
                      NONE => ()
                    | SOME source =>
                        loop(process arg source)
                        handle Error.Error _ => (* Syntax error *)
                            loop arg
                end
        in
            loop initialArg
        end

    fun parseSession() = processSession(parse, parseInitialArg)
    fun elabSession()  = processSession(elab,  elabInitialArg)
    fun evalSession()  = processSession(eval,  evalInitialArg)
    fun execSession()  = processSession(exec,  execInitialArg)

  end
(* stop of Sml.sml *)
(* start of Main.sml *)
(*
 * Standard ML implementation stand-alone
 *)

structure Main =
  struct

    val version = "0.5"

    fun usage() =
        ( TextIO.output(TextIO.stdErr,
            "Usage: hamlet -<mode>\n\
            \where <mode> is one of:\n\
            \  h   help:       print this message\n\
            \  p   parse mode: just parse input\n\
            \  l   elab mode:  parse and elaborate\n\
            \  v   eval mode:  parse and evaluate (no type checking!)\n\
            \  x   exec mode:  parse, elaborate, and evaluate\n"
          )
        ; TextIO.flushOut TextIO.stdErr
        ; OS.Process.failure
        )

    fun start process =
        ( TextIO.output(TextIO.stdOut, "HaMLet " ^ version ^
                                       " - to be or not to be SML\n")
        ; TextIO.flushOut TextIO.stdOut
        ; process()
        ; TextIO.output(TextIO.stdOut, "\n")
        ; TextIO.flushOut TextIO.stdOut
        ; OS.Process.success
        )

    fun main' ["-h"] = ( usage() ; OS.Process.success )
      | main' ["-p"] = start Sml.parseSession
      | main' ["-l"] = start Sml.elabSession
      | main' ["-v"] = start Sml.evalSession
      | main' ["-x"] = start Sml.execSession
      | main'  _     = usage()

    fun main() = OS.Process.exit(main'(CommandLine.arguments()))

  end
(* stop of Main.sml *)

(* Here begins the simple test case. *)

structure Main =
   struct
      fun doit size =
         let
            open TextIO
            fun loop n =
               if n < 0
                  then ()
               else
                  let
                     val _ = ins := openIn "DATA/hamlet-input.sml"
                     val _ = Main.main' ["-x"]
                     val _ = closeIn (!ins)
                  in loop (n - 1)
                  end
         in 
            loop size
         end
   end