(* * 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 * 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 lnrn 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) 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 "" 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 -\n\ \where 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