eP       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./012345 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S!T!U"V"W"X"Y"Z"["\"]"^"_"`#a#b#c#d$e$f%g%h%i%j%k%l%m%n%o%p%q%r%s%t%u%v%w%x%y%z%{%|%}%~%%%%%%&&&&&&&&&&&&&&&&&&''''''''(((()))**++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, , , , , ,,,,,,,,,,,,,,,,,,, ,!,",#,$,%,&,',(,),*,+,,,-,.,/,0,1,2,3,4,5,6,7,8,9,:,;,<-=->-?-@-A-B-C-D-E-F-G-H-I-J-K-L-M-N-O-P-Q-R-S-T-U-V-W-X-Y-Z-[-\-]-^-_-`.a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z.{.|.}.~.....///00111111111111111111122222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222 2 2 2 2 2222222222222222222 2!2"2#2$2%2&2'2(2)2*2+3,3-3.3/303132333435363738393:4;5<6=6>6?6@6A6B6C6D6E7F7G7H7I7J7K8L8M8N8O9P9Q9R9S9T9U9V9W9X9Y9Z9[9\9]9^9_9`9a9b9c9d9e9f9g9h9i9j:k:l:m:n:o;p;q;r;s;t;u;v;w;x;y;z;{;|;};~;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<====================================================>>>>>>>>>>>>>>>>>>>>> > > > > >>>>>>>???????????? ?!?"?#?$?%?&?'@(A)A*A+A,A-A.A/A0A1A2A3A4A5A6A7A8A9A:A;A<A=A>A?A@AAABACADAEAFAGAHAIAJAKALAMANAOAPAQARASATAUAVAWAXAYAZA[A\A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}A~AAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F G G G !G "G #G $G %G &G 'G (G )G *G +G ,G -G .G /G 0G 1G 2G 3G 4G 5G 6G 7G 8G 9G :G ;G <G =G >G ?G @H AH BH CH DH EI FI GI HI II JI KI LI MI NI OI PI QI RI SI TI UI VI WI XI YI ZI [I \I ]I ^I _I `I aI bI cI dI eI fI gI hI iI jI kI lI mI nI oI pI qI rI sI tI uI vI wI xI yI zI {I |I }J ~J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K L L L L L L L L L L L L L M M M M M M M M M M M N N N N N N N N N N N !N "N #N $N %N &N 'N (N )N *N +N ,N -N .N /N 0N 1O 2O 3O 4O 5O 6O 7O 8O 9O :O ;O <O =O >O ?O @O AO BO CO DO EO FO GO HO IO JO KO LO MO NO OO PO QO RO SO TO UO VO WO XO YO ZO [O \O ]O ^O _O `O aO bO cP dP eP fP gP hP iP jP kP lP mP nP oP pP qP rP sP tP uP vP wP xP yP zP {P |P }P ~P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q QVRSafe   S(c) 2014-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Trustworthy   (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeSafe 9;<=?DORT QCheck that a value satisfies multiple patterns. For example, an "as" pattern is  (__ &&& p). %Match a value, and modify the result. *Match a value, and return the given result View pattern.Variable pattern.Constant pattern.Predicate patternCheck for exact value.3Match a pattern, using the given default if valure.2Match an irrefutable pattern. Crashes on faliure.     (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe!"0     !"       !"(c) 2014-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe:#:Apply a function to all elements of a container. Returns   if nothing changed, and Just container otherwise.$5Apply functions to both elements of a pair. Returns   if neither changed, and  Just pair otherwise.#$#$#$#$(c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe5%Identifiers, along with a flag that indicates whether or not they're infix operators. The boolean is present just as cached information from the lexer, and never used during comparisons.'Module names are just text.%&'()*+,-./0123456789%&'()*+,-./012345'()*%&9876+,-./012345%&'()*+,-./0123456789(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe57M<3Information about an infix expression of some sort.>operator? left argument@right argumrntAoperator precedenceBoperator associativityC Information about associativity.H&Fixity information for infix operatorsIPrint a name in prefix: f a b or (+) a b)J#Print a name as an infix operator: a + bS*How to display names, inspired by the GHC  Outputable module. Getting a value of  E from the NameDisp function indicates that the name is not in scope.V%Never qualify names from this module.ZMCompose two naming environments, preferring names from the left environment.[ Get the format for a name. When  2 is returned, the name is not currently in scope.\1Produce a document in the context of the current S.]5Fix the way that names are displayed inside of a doc.d.Pretty print an infix expression of some sort.e2Display a numeric values as an ordinar (e.g., 2nd)f9The suffix to use when displaying a number as an oridinalL<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd1Non-infix leaves are printed with this precedence+pattern to check if sub-thing is also infix"Pretty print this infix expressionefghijklmnopqrstuvwxyz{|}~E<=>?@ABCDEFGHIJKLMNOPQRSUTVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~LSTUOPQRVWXYZ[\]MN^_KLGHIJ`abCDEF<=>?@ABcdefghijklmnopqrstuvwxyz{|}~9<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~k6l6m5(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe57 (Natural numbers with an infinity element&Some algebraic properties of interest: W1 * x = x x * (y * z) = (x * y) * z 0 * x = 0 x * y = y * x x * (a + b) = x * a + x * b&Some algebraic properties of interest: gx ^ 0 = 1 x ^ (n + 1) = x * (x ^ n) x ^ (m + n) = (x ^ m) * (x ^ n) x ^ (m * n) = (x ^ m) ^ nnSub x y = Just z iff z is the unique value such that Add y z = Just x.  Rounds down. <y * q + r = x x / y = q with remainder r 0 <= r && r < yWe don't allow H in the first argument for two reasons: 1. It matches the behavior of I, 2. The well-formedness constraints can be expressed as a conjunction. Rounds up.  lg2 x = y, iff y" is the smallest number such that  x <= 2 ^ ynWidth nL is number of bits needed to represent all numbers from 0 to n, inclusive. nWidth x = nLg2 (x + 1).length ([ x, y .. ] : [_][w])0 We don't check that the second element fits in wY many bits as the second element may not be part of the list. For example, the length of [ 0 .. ] : [_][0] is nLenFromThen 0 1 0, which should evaluate to 1. length [ x, y .. z ]Compute the logarithm of a number in the given base, rounded down to the closest integer. The boolean indicates if we the result is exact (i.e., True means no rounding happened, False means we rounded down). The logarithm base is the second argument.CCompute the number of bits required to represent the given integer.gCompute the exact root of a natural number. The second argument specifies which root we are computing.Compute the the n-th root of a natural number, rounded down to the closest natural number. The boolean indicates if the result is exact (i.e., True means no rounding was done, False means rounded down). The second argument specifies which root we are computing.  (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe9:;zThis packages together a type with some names to be used to display the variables. It is used for pretty printing types. *Compute the n-th variant of a name (e.g., a5).  Compute all variants of a name: a, a1, a2, a3, ...@Expand a list of base names into an infinite list of variations.  N<=>?@ABCDEFGHIJKLMNOPQRSUTVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~    (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeKMaps string names to values, allowing for partial key matches and querying.)Insert a value into the Trie. Will call  * if a value already exists with that key.)Return all matches with the given prefix.^Given a key, return either an exact match for that key, or all matches with the given prefix.%Return all of the values from a Trie.T(c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Trustworthy [Write the contents of the Prelude to a temporary file so that Cryptol can load the module. [Write the contents of the Prelude to a temporary file so that Cryptol can load the module.      (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeM The preprocessor for   The preprocessor for                   (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe!"57An empty range.[Caution: using this on the LHS of a use of rComb will cause the empty source to propegate.## (c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe5%Passes that can generate fresh names.#Names that originate in the parser.Unqualified names like x, Foo, or +.Qualified names like Foo::bar or  module::!. Fresh names generated by a pass.  (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe57  Built-in types.  : Num -> Num -> Num  : Num -> Num -> Num  : Num -> Num -> Num  : Num -> Num -> Num  : Num -> Num -> Num  : Num -> Num -> Num  : Num -> Num  : Num -> Num -> Num  : Num -> Num -> Num : Num -> Num -> Num -> Num Example: ([ 1, 5 .. ] :: [lengthFromThen 1 5 b][b] : Num -> Num -> Num -> Num Example: ,[ 1, 5 .. 9 ] :: [lengthFromThenTo 1 5 9][b]:Type functions, with their arity and function constructor.            U(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe57M#value, base, number of digits$character literal%(qualified) identifier&string literal'keyword(operator)symbol*virtual token (for layout)+white space token, error token >The named operators are a special case for parsing types, and  8 is used for all other cases that lexed as an operator.r.Virtual tokens, inserted by layout processing. Virtual layout block 7An explicit layout block, expecting this ending token.File that we are working onSettings for layout processingPreprocessor settingsImplicit includes^When we do layout processing should we add a vCurly (i.e., are we parsing a list of things). =Split out the prefix and name part of an identifier/operator. 'Drop white-space tokens from the input. eCollapse characters into a single Word8, identifying ASCII, and classes of unicode. This came from: Jhttps://github.com/glguy/config-value/blob/master/src/Config/LexerUtils.hsWhich adapted: >https://github.com/ghc/ghc/blob/master/compiler/parser/Lexer.x"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK     ! " # $ % & ' LMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxy (  z{| ) * + , - . / 0 1 2 3}~ 4 5 6 7 8 9 : ; < = > ? @ A B  C D E  F G H I  J"#%-,(+&$')*.23/0145CDGHEF<6789:;=>?@ABIJK  !  ' "   #  $ % &LcU]MNOPQRSTVWXYZ[\^_`abdefghijklmpqnortsuvwxy (  z|{ ) * , + - . / 0 1 2 3}~ 4 5 6 7 8 9 : ; < = > ? @ A B  C D E  F G H I )" #$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK     ! " # $ % & ' L MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxy (  z{| ) * + , - . / 0 1 2 3}~ 4 5 6 7 8 9 : ; < = > ? @ A B  C D E  F G H I  J(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable TrustworthyBReturns the tokens in the last position of the input that we processed. White space is removed, and layout processing is done as requested. This stream is fed to the parser.oReturns the tokens and the last position of the input that we processed. The tokens include whte space tokens.p K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  i"#%-,(+&$')*.23/0145CDGHEF<6789:;=>?@ABIJKLcU]MNOPQRSTVWXYZ[\^_`abdefghijklmpqnortsuvwxyz|{}~iz{|vwxy"#$%&'()*+,-rstuLMNOPQRSTUVWXYZ[\]^_`abcdefghijkl./0123456789:;<=>?@ABCDEFGHIJKmnopq}~e K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe!"23457MZ  fin x  x == 10  x >= 10  Arith a  Cmp aLocation information After parsing  [8] -> [8] [8] a Bit 10 a infA type variable or synonym 2 + x { x : [8], y : [32] }  ([8], [32])_, just some type.Location information  (ty)  ty + ty  x  _  (x,y,z)  { x = (a,b,c), y = z }  [ x, y, z ]  x : [8]  (x # y)Location informationp <- eSelectors are used for projecting from various components. Each selector has an option spec to specify the shape of the thing that is being selected. Currently, there is no surface syntax for list selectors, but they are used during the desugaring of patterns.UZero-based tuple selection. Optionally specifies the shape of the tuple (one-based).@Record selection. Optionally specifies the shape of the record.=List selection. Optionally specifies the length of the list.  x  0x10  (1,2,3)  { x = 1, y = 2 }  e.l  [1,2,3] [1, 5 .. 117 ]  [1, 3 ...]  [ 1 | x <- xs ]  f x  f `{x = 8}, f`{8}  if ok then e1 else e2  1 + x where { x = 2 }  1 : [8] `(x + 1), x is a type  \x y -> xposition annotation (e)  (Removed by Fixity) a + b  (Removed by Fixity) Literals.0x10 (HexLit 2) "hello";Infromation about the representation of a numeric constant.n-digit binary literaln-digit octal literaloverloaded decimal literaln-digit hex literalcharacter literalpolynomial literal%Export information for a declaration.:Input at the REPL, which can either be an expression or a let statement. Type name Type params ConstructorBindings. Notes:The parser does not associate type signatures and pragmas with their bindings: this is done in a separate pass, after de-sugaring pattern bindings. In this way we can associate pragmas and type signatures with the variables defined by pattern bindings as well.Currently, there is no surface syntax for defining monomorphic bindings (i.e., bindings that will not be automatically generalized by the type checker. However, they are useful when de-sugaring patterns. Defined thing Parameters DefinitionOptional type sigInfix operator? Optional fixity info Optional pragmas Is this a monomorphic binding Optional doc string&The list of names following an import.INVARIANT: All of the Name@ entries in the list are expected to be unqualified names; the QName or % constructors should not be present.An import declaration.*#A string with location information.+(An identifier with location information.,!A name with location information./&The fixity used when none is provided.0@Add a binding name to the export list, if it should be exported.1&Check to see if a binding is exported.2EAdd a type synonym name to the export list, if it should be exported.3+Check to see if a type synonym is exported.53Display the thing selected by the selector, nicely.6Conversational3 printing of kinds (e.g., to use in error messages)      !"#$%&'()*+,-./01234 56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwx%'./012CDEF      !"#$%&'()*+,-./0123456%./012'-CDEF4#$%&'() !"/.     0213,*+65w       !"#$%&'()*+,-./01234 56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwx(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeThe names defined by a newtype.IThe names defined and used by a group of mutually recursive declarations.4The names defined and used by a single declarations.The names defined and used by a single declarations in such a way that they cannot be duplicated in a file. For example, it is fine to use xH on the RHS of two bindings, but not on the LHS of two type signatures./The names defined and used by a single binding. The names used by an expression.)The names defined by a group of patterns.HThe names defined by a pattern. These will always be unqualified names.&The names defined and used by a match.<The names defined and used by an arm of alist comprehension.;Remove some defined variables from a set of free variables.]Given the set of type variables that are in scope, compute the type synonyms used by a type.NThe type names defined and used by a group of mutually recursive declarations.8The type names defined and used by a single declaration.(The type names used by a single binding.%The type names used by an expression.!The type names used by a pattern.The type names used by a match.%The type names used by a type schema.The type names used by a prop.8Compute the type synonyms/type variables used by a type.(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe!"579;M $Eliminate all patterns in a program. Given a pattern, transform it into a simple pattern and a set of bindings. Simple patterns may only contain variables and type annotations. /Add annotations to exported declaration groups.XXX: This isn't quite right: if a signature and binding have different export specifications, this will favor the specification of the binding. This is most likely the intended behavior, so it's probably fine, but it does smell a bit. GAdd annotations, keeping track of which annotation are not yet used up. Add annotations, keeping track of which annotation are not yet used up. The exception indicates which declarations are no longer needed. .Add pragma/signature annotations to a binding. Check for multiple signatures. .Does this declaration provide some signatures? .Does this declaration provide some signatures? 1Does this declaration provide fixity information? ?Does this top-level declaration provide a documentation string? 5Pick a new name, to be used when desugaring patterns. Record an error.7                   +         (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeV(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe57M WWARNING: This is a bit of a hack. It is used to represent anonymous type applications. Generate a signature and a primitive binding. The reason for generating both instead of just adding the signature at this point is that it means the primitive declarations don't need to be treated differently in the noPat pass. This is also the reason we add the doc to the TopLevel constructor, instead of just place it on the binding directly. A better solution might be to just have a different constructor for primitives. Fix-up the documentation strings by removing the comment delimiters on each end, and stripping out common prefixes on all the remaining lines.4  !                 0   !             /    !                 (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Trustworthy" /023459:;<=?@ABCDFIJKMNOQRT          ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"#$%&'()*+,-./012%z|{}~ !"#$%&'()*+,-./012%%&$('*),+.-0/21"# !z{|}~          ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"#$%&'()*+,-./012 9  9 (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe!"57Files that have been loaded&The path that includes are relative toGGet the absolute directory name of a file that contains cryptol source.Run a  action with a different include path. The argument is expected to be the path of a file that contains cryptol source, and will be adjusted with getIncPath.6Adjust an included file with the current include path. Raise an 4 error.Push a path on the stack of included files, and run an action. If the path is already on the stack, an include cycle has happened, and an error is raised.NLift an IO operation, with a way to handle the exception that it might throw.Like B, but tries to collect as many errors as possible before failing.Remove includes from a module.Remove includes from a program.SSubstitute top-level includes with the declarations from the files they reference.PResolve the file referenced by a include into a list of top-level declarations.%Read a file referenced by an include.3456789:;3456787345683456789:;(c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Trustworthy !"579;<=I?EA mapping from an identifier defined in some module to its real name.D)A monad for easing the use of the supply.INVARIANT: this field uniquely identifies a name for one session with the Cryptol library. Names are unique to their binding site.*Information about the origin of this name.The name of the identifier?The associativity and precedence level of infix operators.  * indicates an ordinary prefix operator.Where this name was definedH/Information about the binding site of the name.I2This name refers to a declaration from this moduleJ+This name is a parameter (function or type)KCompare two names lexically.L5Compare two names by the way they would be displayed.Figure out how the name should be displayed, by referencing the display function in the environment. NOTE: this function doesn't take into account the need for parenthesis.M9Pretty-print a name with its source location information.U)Retrieve the next unique from the supply.VThis should only be used once at library initialization, and threaded through the rest of the session. The supply is started at 0x1000 to leave us plenty of room for names that the compiler needs to know about (wired-in constants).X"Make a new name for a declaration.YMake a new parameter name.ZvIt's assumed that we're looking things up that we know already exist, so this will panic if it doesn't find the name.[vIt's assumed that we're looking things up that we know already exist, so this will panic if it doesn't find the name.7?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[GHIJNOPQRSKLMXYEFUDTCVW?@ABZ[(?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkSafe!"579:;M0{;The type is "simple" (i.e., it contains no type functions).~ Named records Type synonym.Name ParametersEnsure body is OK Definition1-1 constants.NumbersInfBit [_] _ _ -> _  (_, _, _)user-defined, TPredicate symbols. _ == _ _ /= _ _ >= _ fin _Has sel type field does not appear in schemas Arith _ Cmp _/This is useful when simplifying things in placeDittoType constants.#The type is supposed to be of kind Type variables.AUnique, kind, ids of bound type variables that are in scope The M. is a description of how this type came to be.LThe internal representation of types. These are assumed to be kind correct.Type constant with argsType variable (free or bound)This is just a type annotation, for a type that was written as a type synonym. It is useful so that we can use it to report nicer errors. Example: `TUser T ts t` is really just the type t7 that was written as `T ts` by the user.  Record typeType parameters.Parameter identifierKind of parameterName from source, if any. The types of polymorphic values.Kinds, classify types.ESplit up repeated occurances of the given binary type-level function.Make a function type."Eliminate outermost type synonyms.Make a malformed numeric type.Equality for numeric types.+Make a greater-than-or-equal-to constraint.A Has1 constraint, used for tuple and record selection.Make a malformed property.yz{|}~      !"#$%&   yz{|}~~|}&%$#"! {yz        yyz{|}~       !"#$%&5544(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe!"579:;McMutually recursive declarationsdNon-recursive declarationfLType arguments are the length and element type of the sequence expressioni"List value (with type of elements)j Tuple valuek Record valuelElimination for tuplerecordlistm If-then-elsenZList comprehensions The types cache the length of the sequence and its element type.oUse of a bound variablepFunction ValueqType applicationrFunction applicationsFunction valuetProof abstraction. Because we don't keep proofs around we don't need to name the assumption, but we still need to record the assumption. The assumption is the 0 term, which should be of kind .uRIf `e : p => t`, then `EProofApp e : t`, as long as we can prove p.We don't record the actual proofs, as they are not used for anything. It may be nice to keep them around for sanity checking.wA Cryptol module.NConstruct a primitive, given a map to the unique names of the Cryptol module.Make an expression that is % pre-applied to a type and a message.>VWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   13?@ABGyz{|}~VWXYZ[\]^_`abcdegfhrojlinmvkpqstuwxy{~z|}nwxyz{|}~hijklmnopqrstuvefgbcdYZ[\]^_`aVWXG   13?@ABVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~(c) 2014-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe!"5<=>Replaces occurances of the name with the expression. Returns  ) if there were no occurances of the name.2Expressions, representing Cryptol's numeric types.KPropopsitions, representing Cryptol's numeric constraints (and a bit more). The constant 0. The constant 1. The constant 2. The constant infinity.+Make a conjucntion of the given properties.+Make a disjunction of the given properties.&Compute all expressions in a property.7Compute the immediate sub-expressions of an expression.Rebuild an expression, using the top-level strucutre of the first expression, but the second list of expressions as sub-expressions.,Compute the free variables in an expression.,Compute the free variables in a proposition.Pretty print a name./An infinite list of names, for pretty prinitng."Pretty print a top-level property.<Pretty print a proposition, in the given precedence context.,Pretty print an expression at the top level.<Pretty print an expression, in the given precedence context.$Pretty print an experssion with ifs.$Pretty print an experssion with ifs.EThis is used in the simplification to "apply" substitutions to Props.A==#   66784444432(c) 2014-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeBA condition ensure that the given *basic* proposition makes sense.Generate a property ensuring that the expression is well-defined. This might be a bit too strict. For example, we reject things like max inf (0 - 1)*, which one might think would simplify to inf.(c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe$Simplify an expression, if possible.4Perform simplification from the leaves up. Returns   if there were no changes.CMake a simplification step, assuming the expression is well-formed.    (c) 2014-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe9;M!Simplify a property, if possible.!Simplify a property, if possible.A single simplification step.ZRebalance parens, and arrange conjucts so that we can transfer information left-to-right.[Rebalance parens, and arrange disjuncts so that we can transfer information left-to-right.6Identify propositions that are suiatable for inlining.7Rearrange proposition for conjuctions and disjunctions.Vinformation left-to-right, so we put proposition with information content on the left.Simplification of '. Assumes arranged conjucntions. See .Simplification of '. Assumes arranged disjunctions. See <Propagate the fact that the variable is known to be finite () or not-finite (8). Note that this may introduce new expression redexes. Negation.Simplificaiton for :== Simplificatoin for :> Attempt to simplify a fin& constraint. Assumes a defined input. Constant > expression Expression > constant'Simplify only the Expr parts of a Prop.1Simplify only the Expr parts of a Prop. Returns   if there were no changes. Our goal is to bubble inf terms to the top of Return.VMake an expression that should work ONLY on natural nubers. Eliminates occurances of inf{. Assumes that the two input expressions are well-formed and finite. The expression is constructed by the given function.          (c) 2014-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe!",Substitution does not affect the expression.8The expression was updated and, maybe, it became linear.,Factor-out non-linear terms, by naming them.BApply a substituin to the non-linear expression database. Returns  , if nothing was affected. Otherwise returns C, and a substitution for non-linear expressions that became linear.The definitions of NL terms do not contain other named NL terms, so it does not matter if the substitution contains bindings like _a = e.nThere should be no bindings that mention NL term names in the definitions of the substition (i.e, things like x = _a are NOT ok).Get the known non-linear terms. 0The initial state for the linearization process.:Apply the substituint to all non-linear bindings. Returns  , if nothing was affected. Otherwise returns O, and a substituion mapping names that used to be non-linear but became linear.~Note that we may return `Just empty`, indicating that some non-linear expressions were updated, but they remained non-linear. +Is the top-level operator a non-linear one. !"#$ %&'()*   !"#$ %&'()*(c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeM  lower bound (inclusive)Qupper bound (inclusive) If there is no upper bound, than all *natural* numbers.!Only meaningful for numeric types1What we learn about variables from a single prop.Returns , when the intervals definitely overlap, and  otherwise.Intersect two intervals, yielding a new one that describes the space where they overlap. If the two intervals are disjoint, the result will be  . Any valueAny finite valueExactly this value     !"#$%&'()*     !"#$%&'()*     !"#$%&'()*    !"#$%&'()*(c) 2014-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe+8Assumes simplified, linear, finite, defined expressions..$Assumes simplified, linear, defined.0.The name of a variable in the SMT translation.15The name of a boolean variable, representing `fin x`.2Get the value for the given name. * Assumes that we are in a SAT state (i.e., there is a model) * Assumes that the name is in the model 3#Get the values for the given names.,uConvert a bunch of improving equations into an idempotent substitution. Assumes that the equations don't have loops.4wGiven a model, compute an improving substitution, implied by the model. The entries in the substitution look like this:x = A variable x must equal constant Ax = y variable x must equal variable y x = A * y + B, (coming soon) variable x is a linear function of y, A and B are natural numbers.We are mostly interested in improving unification variables. However, it is also useful to improve skolem variables, as this could turn non-linear constraints into linear ones. For example, if we have a constraint  x * y = z, and we can figure out that x4 must be 5, then we end up with a linear constraint  5 * y = z.-"Try to prove the given expression..Try to prove the given expression. If we fail, we try to give a counter example. If the answer is unknown, then we return an empty counter example./lIs this the only possible value for the constant, under the current assumptions. Assumes that we are in a Sat state. Returns  ~ if the variables must always match the given value. Otherwise, we return a counter-example (which may be empty, if uniknown)0mDo these two variables need to always be the same, under the current assumptions. Assumes that we are in a Sat state.1Try to find a linear relation between the two variables, based on two observed data points. NOTE: The variable being defined is the SECOND name.2ZCompute a linear relation through two concrete points. Try to find a relation of the form  y = a * x + b. Depending on the signs of a and b+, we need additional checks, to ensure tha  a * x + b is valid.9y1 = A * x1 + B y2 = A * x2 + B (y2 - y1) = A * (x2 - x1))A = (y2 - y1) / (x2 - x1) B = y1 - A * x1+./340123,4-./01&Definition in terms of this variable. Define this variable. Values in one model (x,y) Values in another model (x,y) aEither nothing, or an improving expression, and any additional obligations 2 First point  Second point (A,B) ./01234.01/423+./340123,4-./012 (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe29;<=?56789:;<=>?@ABCDEFGHIJKL5MNOP56879:;<>=?@BCADEFGHIJKL56789:?@ABCDEFHIGJKL;<=>56789:;<=>?@ABCDEFGHIJKL5MNOP!(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe9:;<=MStNote that this assumes that this pass will be run only once for each module, otherwise we will get name collisions.6Produce a fresh top-level name.7mNot really any distinction between global and local, all names get the module prefix added, and a unique id.89:;<S6=7>?@ABCDETSS89:;<S6=7>?@ABCDET"SafeVSolved, assuming the sub-goals.WWe could not solve the goal.XThe goal can never be solved. UVWXYZ[\]^ UVWXYZ[\] YUVWXZ[\]^UVWXYZ[\]^#(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeM`1Solve class constraints. If not, then we return  . If solved, ther we return  a list of sub-goals.a3Solve an Arith constraint by instance, if possible.FeSolve an Arith constraint for a sequence. The type passed here is the element type of the sequence.bSolve Cmp constraints.cvAdd propositions that are implied by the given one. The result contains the orignal proposition, and maybe some more.`aFbc`abc`abc`aFbc$(c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeMdededede%Safe&GHIJKLMNfghijklmnopqrstuvwxyz{|}~1 fghijklmnopqrstuvwxyz{|}~fghijklmnopqrstuvwxyz{|}~&GHIJKLMNfghijklmnopqrstuvwxyz{|}~&SafeM:Common checks: check for error, or simple full evaluation.'(c) 2014-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe((c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe6All ways to split a type in the form: `a + t1`, where a is a variable.5Check if we can express a type in the form: `a + t1`.<Check if we can express a type in the form: `k + t1`, where kw is a constant > 0. This assumes that the type has been simplified already, so that constants are floated to the left. <Check if we can express a type in the form: `k * t1`, where kv is a constant > 1 This assumes that the type has been simplified already, so that constants are floated to the left. )SafeM\O<Check for addition of constants to both sides of a relation.OThis relies on the fact that constants are floated left during simplification.PQRSTUVWXYZ[OPQRSTUVWXYZ[O* TrustworthyM+(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe!"9:;MMakes a substitution out of a list. WARNING: We do not validate the list in any way, so the caller should ensure that we end up with a valid (e.g., idempotent) substitution.Apply a substitution. Returns   if nothing changed.\3Pick types for unconstrained unification variables.1Apply the substitution to the keys of a type map.3WARNING: This instance assumes that the quantified variables in the types in the substitution will not get captured by the quantified variables. This is reasonable because there should be no shadowing of quantified variables but, just in case, we make a sanity check and panic if somehow capture did occur. !]^_\yzyz]^_\,(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe$579:;+GInformation about how a constraint came to be, used in error reporting.%Computing shape of list comprehensionUse of a split pattern+A type signature in a pattern or expression Instantiation of this expression#Just defaulting on the command lineUse of a partial type function./Constraints arising from type-checking patterns?Various errors that might happen during type checking/inference Just say thisExpected kind, inferred kindMNumber of extra parameters, kind of result (which should not be of the form _ -> _)$Type-synonym, number of extra params&Type-synonym, number of missing params2Type parameters with the same name (in definition)&Multiple definitions for the same name+The type synonym declarations are recursive*Use of a type synonym that was not defined&Use of a variable that was not defined7Attempt to explicitly instantiate a non-existent param.0Multiple definitions for the same type parameterExpected type, inferred type'Unification results in a recursive typekA constraint that we could not solve The boolean indicates if we know that this constraint is impossible.3A constraint (with context) that we could not solveVType wild cards are not allowed in this context (e.g., definitions of type synonyms).LUnification variable depends on quantified variables that are not in scope.gQuantified type variables (of kind *) need to match the given type, so it does not work for all types.RThe given constraints causes the signature of the function to be not-satisfiable.FToo many positional type arguments, in an explicit type instantiationGDelayed implication constraints, arising from user-specified type sigs.+Signature that gave rise to this constraint,Something that we need to find evidence for.What it is about$Part of source code that caused goalWhat needs to be proved*The types of variables in the environment. Known typePart of current SCCThe SMT solver to invoke*Additional arguments to pass to the solver$How verbose to be when type-checking For use in error messages`      !"#$K     `    $#"!  &       !"#$-(c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe =expected, actual>expected a mono type, got this`$Validate a type, returning its kind.a8Check that the type is valid, and it has the given kind.b"Check that this is a valid schema.czCheck that the expression is well-formed, and compute its type. Reports an error if the expression is not of a mono type.dACheck that the expression is well-formed, and compute its schema.e2Check if the one type is convertible to the other.fKCheck a declaration. The boolean indicates if we should check the sigantureC<=>?@ABCDEFGHIJKLMNOPQRghijkSlmnopqTUVWrs`abcdeftuvwxyz{|}~XYZ[\]^<IR=JM>A?DB@CNFEKGHOPLQSTUVWUVWS<=>?@ABCDEFGHIJKLMNOPQRT%<=>?@ABCDEFGHIJKLMNOPQRghijkSlmnopqTUVWrs`abcdeftuvwxyz{|}~XYZ[\]^.(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe!"9:M%OVariables declared in this scope (not counting the ones from previous scopes).These are the non-linear terms mentioned in the assertions that are currently asserted (including ones from previous scopes). Either a type variable that makes the asserted properties unsatisfiable (due to a broken interval), or the current set of intervals for type variables. If a variable is not in the interval map, its value can be anything.1This includes all intervals from previous scopes.MThis is the set of currently-asserted cryptol properties only in this scope.6This includes all asserted props from previous scopes.7Keeps track of declared variables and non-linear terms.c6An SMT solver, and some info about declared variables.The actual solver?Information about declared variables, and assumptions in scope.d For debuggingeh and iA should be logically equivalent, to each other, and to whatever a represents (usually a is a ).g;Optional data to associate with prop. Often, the original # from which the prop was extracted.hFully simplified: may mention ORs, and named non-linear terms. These are what we send to the prover, and we don't attempt to convert them back into Cryptol types. iA version of the proposition where just the expression terms have been simplified. These should not contain ORs or named non-linear terms because we want to import them back into Crytpol types. *We use this to remember what we simplifiedk:Class goals go on the left, numeric goals go on the right.lSimplify a bunch of well-defined properties. * Eliminates properties that are implied by the rest. * Does not modify the set of assumptions.Simplify easy less-than-or-equal-to and equal-to goals. Those are common with long lists of literals, so we have special handling for them. In particular:Reduce goals of the form  (a >= k1, a >= k2, a >= k3, ...) to a >= max (k1, k2, k3, ...) , when all the k's are constant.Eliminate goals of the form ki >= k2, when k2 is leq than k1.Eliminate goals of the form a >= 0.4NOTE: This assumes that the goals are well-defined.mAdd the given constraints as assumptions. * We assume that the constraints are well-defined. * Modifies the set of assumptions.nGiven a list of propositions that together lead to a contradiction, find a sub-set that still leads to a contradiction (but is smaller).oZAttempt to find a substituion that, when applied, makes all of the given properties hold. \Given a *simplified* prop, separate linear and non-linear parts and return the linear ones. No scopes.%Check if a name is any of the scopes.Add a name to a scope.?Add an assertion to the current scope. Returns the linear part.Enter a scope. Exit a scope.lAll declared names, that have not been "marked". These are the variables whose values we are interested in.All known non-linear terms.s3Execute a computation with a fresh solver instance.t,Execute a computation in a new solver scope.Declare a variable.MAdd an assertion to the current context. INVARIANT: Assertion is simplified.MAdd an assertion to the current context. INVARIANT: Assertion is simplified.(Try to prove a property. The result is 0 when we are sure that the property holds, and % otherwise. In other words, getting 5 *does not* mean that the proposition does not hold.uCheck if the current set of assumptions is satisfiable, and find some facts that must hold in any models of the current assumptions.Returns  E if the currently asserted constraints are known to be unsatisfiable.JReturns `Just (su, sub-goals)` is the current set is satisfiable. * The sum is a substitution that may be applied to the current constraint set without loosing generality. * The  `sub-goals`Z are additional constraints that must hold if the constraint set is to be satisfiable.Assuming that we are in a satisfiable state, try to compute an improving substitution. We also return additional constraints that must hold for the currently asserted propositions to hold.K`abcdefghijklmnopqrstuvwxyz{|}~`abcdefghijklmnopqrstuvtsmloucddrefghiv`abjknpq6`abcdefghijklmnopqrstuvwxyz{|}~/SafeImprovements from a bunch of propositions. Invariant: the substitions should be already applied to the new sub-goals, if any.uImprovements from a proposition. Invariant: the substitions should be already applied to the new sub-goals, if any.|Improvements from euqality constraints. Invariant: the substitions should be already applied to the new sub-goals, if any.0(c) 2014-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe$MGiven a typing environment and an expression, compute the type of the expression as quickly as possible, assuming that the expression is well formed with correct type annotations.BYields the return type of the selector on the given argument type.1(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe$2MXThe most general unifier is a substitution and a set of constraints on bound variables. 2(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe!"57JMXFThis is what's returned when we lookup variables during kind checking.Locally bound variable.An outer binding.kinds of (known) vars.lazy map, with tyvars.are type-wild cards allowed?"Read-write component of the monad.Collected errorsCollected warningsAccumulated substitution|These keeps track of what existential type variables are available. When we start checking a function, we push a new scope for its arguments, and we pop it when we are done checking the function body. The front element of the list is the current scope, which is the only thing that will be modified, as follows. When we encounter a existential type variable: 1. we look in all scopes to see if it is already defined. 2. if it was not defined, we create a fresh type variable, and we add it to the current scope. 3. it is an error if we encounter an existential variable but we have no current scope.FSelector constraints that have been solved (ref. iSolvedSelectorsLazy)Ordinary constraints*Tuple/record projection constraints. The Z is the "name" of the constraint, used so that we can name it solution properly. !Read-only component of the monad.Source code being analysed"Type of variable that are in scopeType variable that are in scopeType synonyms that are in scopeNewtype declarations in scope3NOTE: type synonyms take precedence over newtype. The reason is that we can define local type synonyms, but not local newtypes. So, either a type-synonym shadows a newtype, or it was declared at the top-level, but then there can't be a newtype with the same name (this should be caught by the renamer).KNOTE: This field is lazy in an important way! It is the final version of  in , and the two are tied together through recursion. The field is here so that we can look thing up before they are defined, which is OK because we don't need to know the results until everything is done.When this flag is set to true, bindings that lack signatures in where-blocks will never be generalized. Bindings with type signatures, and all bindings at top level are unaffected.The results of type inference.We found some errorsType inference was successful.*This is used for generating various names.&Information needed for type inference.Location of program sourceVariables that are in scopeType synonyms that are in scopeNewtypes in scopePrivate state of type-checker=Should local bindings without signatures be monomorphized?!Options for the constraint solver&Where to look for Cryptol theory file.The mapping from Ident to G5, for names that the typechecker needs to refer to.$The supply for fresh name generation6The initial seeds, used when checking a fresh program.eThe monadic computation is about the given range of source code. This is useful for error reporting.1This is the current range that we are working on.Report an error.IRetrieve the mapping between identifiers and declarations in the prelude.eRecord some constraints that need to be solved. The string explains where the constraints came from.^The constraints are removed, and returned to the caller. The substitution IS applied to them. 'Add a bunch of goals that need solving.UCollect the goals emitted by the given sub-computation. Does not emit any new goals.;Record a constraint that when we select from the first type, we should get a value of the second type. The returned function should be used to wrap the expression from which we are selecting (i.e., the record or tuple). Plese note that the resulting expression should not be forced before the constraint is solved.)Add a previously generate has constrainedGet the HasJ constraints. Each of this should either be solved, or added back using .@Specify the solution (`Expr -> Expr`) for the given constraint ().Generate a new name for a goal."Generate a new free type variable.TGenerate a new free type variable that depends on these additional type parameters."Generate a new free type variable.KGenerate an unknown type. The doc is a note about what is this type about.8Record that the two types should be syntactically equal.IApply the accumulated substitution to something with free type variables.5Get the substitution that we have accumulated so far.$Add to the accumulated substitution.TVariables that are either mentioned in the environment or in a selector constraint.Lookup the type of a variable. Lookup a type variable. Return  _ if there is no such variable in scope, in which case we must be dealing with a type constant.(Lookup the definition of a type synonym."Lookup the definition of a newtypeCheck if we already have a name for this existential type variable and, if so, return the definition. If not, try to create a new definition, if this is allowed. If not, returns nothing.6Returns the type synonyms that are currently in scope.3Returns the newtype declarations that are in scope.6Get the set of bound type variables that are in scope.9Return the keys of the bound variables that are in scope.Retrieve the value of the  `mono-binds` option.We disallow shadowing between type synonyms and type variables because it is confusing. As a bonus, in the implementation we don't need to worry about where we lookup things (i.e., in the variable or type synonym environment. HThe sub-computation is performed with the given type parameter in scope.FThe sub-computation is performed with the given type-synonym in scope. BThe sub-computation is performed with the given variable in scope. CThe sub-computation is performed with the given variables in scope. CThe sub-computation is performed with the given variables in scope.VThe sub-computation is performed with the given type synonyms and variables in scope.lPerform the given computation in a new scope (i.e., the subcomputation may use existential type variables)..The arguments to this function are as follows:H(type param. name, kind signature (opt.), a type representing the param)The type representing the parameter is just a thunk that we should not force. The reason is that the type depnds on the kind of parameter, that we are in the process of computing.fAs a result we return the value of the sub-computation and the computed kinds of the type parameters. *Check if a name refers to a type variable.'Are type wild-cards OK in this context?Reports an error.Generate a fresh unification variable of the given kind. NOTE: We do not simplify these, because we end up with bottom. See WX* XXX: Perhaps we can avoid the recursion?(Lookup the definition of a type synonym.#Lookup the definition of a newtype.6Replace the given bound variables with concrete types.Record the kind for a local type variable. This assumes that we already checked that there was no other valid kind for the variable (if there was one, it gets over-written). @The sub-computation is about the given range of the source code.      See comment !"#$%          %$#"!      X         !"#$%3(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe9;2`Check for duplicate and recursive type synonyms. Returns the type-synonyms in dependency order.3IAssociate type signatures with bindings and order bindings by dependency.4Given a list of declarations, annoted with (i) the names that they define, and (ii) the names that they use, we compute a list of strongly connected components of the declarations. The SCCs are in dependency order. 5gCombine a bunch of definitions into a single map. Here we check that each name is defined only onces. 6gCombine a bunch of definitions into a single map. Here we check that each name is defined only onces. 7*Identify multiple occurances of something.+,-./0123456789 +,-./01234567/0123+,-.984567 +,-./01234567894(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeInstantiate an expression of the given polymorphic type. The arguments that are provided will be instantiated as requested, the rest will be instantiated with fresh type variables.EProofApp (ETApp e t)awhere - There will be one `ETApp t` for each insantiated type parameter; - there will be one u# for each constraint on the schema;::::5(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeMCompute the type of a field based on the selector. The given type should be "zonked" (i.e., substitution was applied to it), and (outermost) type synonyms have been expanded.;Solve has-constraints.;changes, solved;;;6Safe9;<"Returns goals that were not proved=4Check if the given goals are known to be unsolvable.7Check if some numeric goals are known to be unsolvable.<=>?@ABCD<=<=<=>?@ABCD7(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe!"MEAdd additional constraints that ensure validity of type function. Note that these constraints do not introduce additional malformed types, so the well-formedness constraints are guaranteed to be well-formed. This assumes that the parameters are well-formed. F>Add additional constraints that ensure the validity of a type. Simplify Has! constraints as much as possible.Import an improving substitutin (i.e., a bunch of equations) into a Cryptol substitution (which is idempotent). The substitution will contain only unification variables.  Improvements3 on skolem variables become additional constraints.JTry to pick a reasonable instantiation for an expression, with the given type. This is useful when we do evaluation at the REPL. The resulting types should satisfy the constraints of the schema.iAttempt to default the given constraints by asserting them in the SMT solver, and asking it for a model.EFFacts we can knowNeed to solve theseDLeft: contradicting goals, Right: inferred types, unsolved goals.GHChecking this function?These appear in the env., and we should not try to default theType parametersAssumed constraintCollected constraintsLeft: contradiciting goals, Right: goals that were not solved, or sub-goals for solved goals. Does not include "old"Consult these  Solve these IJEFGHIJGHFEIJEFGHIJ8(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeJ KCheck a type signature.L!Check a type-synonym declaration.MACheck a newtype declaration. XXX: Do something with constraints.%Check something with type parameters.When we check things with type parameters (i.e., type schemas, and type synonym declarations) we do kind inference based only on the immediately visible body. Type parameters that are not mentioned in the body are defaulted to kind m. If this is not the desired behavior, programmers may add explicit kind annotations on the type parameters.+Here is an example of how this may show up: !f : {n}. [8] -> [8] f x = x + `n Note that nE does not appear in the body of the schema, so we will default it to u, which is the correct thing in this case. To use such a function, we'd have to provide an explicit type application:  f `{n = 3}&There are two reasons for this choice: uIt makes it possible to figure if something is correct without having to look through arbitrary amounts of code.It is a bit easier to implement, and it covers the large majority of use cases, with a very small inconvenience (an explicit kind annotation) in the rest.(Check an application of a type constant.@Check a use of a type-synonym, newtype, or scoped-type variable.Check a type-application.Validate a parsed type.&Check a type-variable or type-synonym.Validate a parsed proposition.(Check that a type has the expected kind. KLMNType constant being appliedType parameters Expected kindResulting type%Should we check for scoped type vars.Name of type sysnonymType synonym parameters Expected kindResulting typeParameters to type functionKind of type function$Validated parameters, resulting kindType that needs to be checkedExpected kind (if any) Checked type!Name of thing that needs checking Expected kind#Proposition that need to be checkedChecked representationKind-checked typeExpected kind (if any) Inferred kind$A type consistent with expectations.KLMNNKML KLMN9(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe!"$JM P(Construct a primitive in the parsed AST.R?Infer the type of an expression with an explicit instantiation.U]We use this when we want to ensure that the expr has exactly (syntactically) the given type.VSInfer the type of an expression, and translate it to a fully elaborated core term.^$The type the is the smallest of all `PInfer the type of a pattern. Assumes that the pattern will be just a variable. a4Infer the type of one match in a list comprehension.b2Infer the type of one arm of a list comprehension.c!inferBinds isTopLevel isRec binds; performs inference for a strongly-connected component of s. If  isTopLevel is true, any bindings without type signatures will be generalized. If it is false, and the mono-binds flag is enabled, no bindings without type signatures will be generalized, but bindings with signatures will be unaffected.dCome up with a type for recursive calls to a function, and decide how we are going to be checking the binding. Returns: (Name, type or schema, computation to check binding)The exprMapd is a thunk where we can lookup the final expressions and we should be careful not to force it.e_The inputs should be declarations with monomorphic types (i.e., of the form `Forall [] [] t`).OPQRSTUVWXYZ[\]^_`abcdefghiOPQRSTUVWXYZ[\]^_`abcdefghiOPQRSTUVWXYZ[\]^_`abcdefghiOPQRSTUVWXYZ[\]^_`abcdefghi:(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeMjklmn7jklmn7jklmnjklmn;(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe!"57M~HThe resulting interface generated by a module that has been typechecked.,Generate an Iface from a typechecked module.$Produce a PrimMap from an interface.NOTE: the map will expose both public and private names.opqrstuvwxyz{|}~opqrstuvwxyz{|}~~yz{|}xwopqrstuv opqrstuvwxyz{|}~<(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe !"234579:;M"Things that define exported names.Expr renaming environmentType renaming environment#Expression-level fixity environmentiMerge two name maps, collapsing cases where the entries are the same, and producing conflicts otherwise.Generate a mapping from % to G for a given naming environment.8Generate a display format based on a naming environment.9Produce sets of visible names for types and declarations.rNOTE: if entries in the NamingEnv would have produced a name clash, they will be omitted from the resulting sets.Qualify all symbols in a  with the given prefix.$Singleton type renaming environment.*Singleton expression renaming environment.9Like mappend, but when merging, prefer values on the lhs. Generate a  using an explicit supply.jInterpret an import in the context of an interface, to produce a name environment for the renamer, and a S for pretty-printing.cGenerate a naming environment from a declaration interface, where none of the names are qualified.0The naming environment for a single declaration.The naming environment for a single module. This is the mapping from unqualified names to fully qualified names with uniques.5Generate the naming environment for a type parameter.Introduce the name|Produce a naming environment from an interface file, that contains a mapping only from unqualified names to qualified ones.XGenerate a type renaming environment from the parameters that are bound by this schema.((=(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe !"$579:;M\Check for overlap and shadowingOnly check for overlapDon't check the environment+Multiple imported symbols contain this name.Expression name is not bound to any definition(Type name is not bound to any definition8An environment has produced multiple overlapping symbols[When a value is expected from the naming environment, but one or more types exist instead.eWhen a type is missing from the naming environment, but one or more values exist with the same name.)When the fixity of two operators conflict5When it's not possible to produce a Prop from a Type.6When a builtin type/type-function is used incorrectly.)When a builtin type is named in a binder.(Retrieve the name of the current module.;Shadow the current naming environment with some more names.Shadow the current naming environment with some more names. The boolean parameter indicates whether or not to check for shadowing.Generate warnings when the left environment shadows things defined in the right. Additionally, generate errors when two names overlap in the left environment.?Check the RHS of a single name rewrite for conflicting sources.AThrow errors for any names that overlap in a rewrite environment.Produce a name if one exists. Note that this includes situations where overlap exists, as it's just a query about anything being in scope. In the event that overlap does exist, an error will be recorded.vAssuming an error has been recorded already, construct a fake name that's not expected to make it out of the renamer.XRename a schema, assuming that the type variables have already been brought into scope.ACheck to see if this identifier is a reserved type/type-function.UWhen possible, rewrite the type operator to a known constructor, otherwise return a ; that reconstructs the original term, and a default fixity.uCheck if we are resolving operators whose precedence will change in the future, and issue a warning in that event.(&&) is scheduled to have higher precedence than the comparisons and (^) (||) is scheduled to have higher precedence than the comparisonsSee /https://github.com/GaloisInc/cryptol/issues/2411The name environment generated by a single match.ERename patterns, and collect the new environment that they introduce.Rename a binding./Resolve fixity, then rename the resulting type.PRename a schema, assuming that none of its type variables are already in scope.[May contain infix expressionsThe operator to use"Will not contain infix expressions@ >(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe02=Data type describing errors that can occur during evaluation.Out-of-bounds index*Non-numeric type passed to demote functionDivision or modulus by 0Bitvector too largeCall to the Cryptol error primitiveDetectable nontermination"This thunk has not yet been forced'This thunk is currently being evaluated>This thunk has previously been forced, and has the given value!The monad for Cryptol evaluation.6A computation that returns an already-evaluated value.Delay the given evaluation computation, returning a thunk which will run the computation when forced. Raise a loop error if the resulting thunk is forced during its own evaluation.rDelay the given evaluation computation, returning a thunk which will run the computation when forced. Run the retryV computation instead if the resulting thunk is forced during its own evaluation.Produce a thunk value which can be filled with its associated computation after the fact. A preallocated thunk is returned, along with an operation to fill the thunk with the associated computation. This is used to implement recursive declaration groups.$Execute the given evaluation action.Lift an  computation into the  monad.Panic from an Eval context.For things like `(inf) or `(0-1).For division by 0.For when we know that a word is too wide and will exceed gmp's limits (though words approaching this size will probably cause the system to crash anyway due to lack of memory).For the Cryptol error function. *For cases where we can detect tight loops. 3A sequencing operation has gotten an invalid index.%,Optional name to print if a loop is detectedComputation to delayComputation to delay5Backup computation to run if a tight loop is detected$A name to associate with this thunk.                  ?(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe57MjAn evaluated type of kind *. These types do not contain type variables, type synonyms, or type functions.  Bit  [n]a  [inf]t  (a, b, c )  { x : a, y : b, z : c }  a -> b-Convert a type value back into a regular typeTrue if the evaluated value is BitProduce a sequence type valueLCoerce an extended natural into an integer, for values known to be finite #Evaluation for types (kind * or #).!$Evaluation for value types (kind *)."%Evaluation for number types (kind #).#AReduce type functions, raising an exception for undefined values. !"#$ !"#$ !"#  !"#$@(c) 2014-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe'vThis is the widest word we can have before gmp will fail to allocate and bring down the whole program. According to  ?https://gmplib.org/list-archives/gmp-bugs/2009-July/001538.html the sizes are 2^32-1 for 32-bit, and 2^37 for 64-bit, however experiments show that it's somewhere under 2^37 at least on 64-bit Mac OS X.''''A(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe$(2579;<=?LMT[F(]This class defines additional operations necessary to define generic evaluation functions.)SEval prim binds primitive declarations to the primitive values that implement them.*ifthen#else operation. Choose either the 'then' value or the 'else'1 value depending on the value of the test bit.+This type class defines a collection of operations on bits and words that are necessary to define generic evaluator primitives that operate on both concrete and symbolic values uniformly.,Pretty-print an individual bit-Pretty-print a word value.>Attempt to render a word value as an ASCII character. Return  B if the character value is unknown (e.g., for symbolic values)./#The number of bits in a word value.0-Construct a literal bit value from a boolean.1=Construct a literal word value given a bit width and a value.2Construct a word value from a finite sequence of bits. NOTE: this assumes that the sequence of bits is big-endian and finite, so the first element of the list will be the most significant bit.3Deconstruct a packed word value in to a finite sequence of bits. NOTE: this produces a list of bits that represent a big-endian word, so the most significant bit is the first element of the list.4gConcatenate the two given word values. NOTE: the first argument represents the more-significant bits5Take the most-significant bits, and return those bits and the remainder. The first element of the pair is the most significant bits. The two integer sizes must sum to the length of the given word value.68Extract a subsequence of bits from a packed word value. The first integer argument is the number of bits in the resulting word. The second integer argument is the number of less-significant digits to discard. Stated another way, the operation `extractWord n i w` is equivelant to first shifting w right by i! bits, and then truncating to n bits.72's complement addition of packed words. The arguments must have equal bit width, and the result is of the same width. Overflow is silently discarded.82's complement subtraction of packed words. The arguments must have equal bit width, and the result is of the same width. Overflow is silently discarded.92's complement multiplication of packed words. The arguments must have equal bit width, and the result is of the same width. The high bits of the multiplication are silently discarded.@8Generic value type, parameterized by bit and word types.FNOTE: we maintain an important invariant regarding sequence types. DD must never be used for finite sequences of bits. Always use the EH constructor instead! Infinite sequences of bits are handled by the F& constructor, just as for other types.A  { .. }B  ( .. )C  BitD [n]a / Invariant: VSeq is never a sequence of bitsE  [n]BitF  [inf]aG functionsHpolymorphic values (kind *)Ipolymorphic values (kind #)JXFor efficency reasons, we handle finite sequences of bits as special cases in the evaluator. In cases where we know it is safe to do so, we prefer to used a "packed word" representation of bit sequences. This allows us to rely directly on Integer types (in the concrete evalautor) and SBV's Word types (in the symbolic simulator).However, if we cannot be sure all the bits of the sequence will eventually be forced, we must instead rely on an explicit sequence of bits representation.K-Packed word representation for bit sequences.L%Sequence of thunks representing bits.NA sequence map represents a mapping from nonnegative integer indices to values. These are used to represent both finite and infinite sequences.QeConcrete bitvector values: width, value Invariant: The value must be within the range 0 .. 2^width-1SsApply an integer function to the values of bitvectors. This function assumes both bitvectors are the same width.TwApply an integer function to the values of a bitvector. This function assumes the function will not require masking.VSmart constructor for Q!s that checks for the width limitX4Generate a finite sequence map from a list of valuesY9Generate an infinite sequence map from a stream of valuesZCreate a finite list of length n? of the values from [0..n-1] in the given the sequence emap.[=Create an infinite stream of all the values in a sequence map\*Reverse the order of a finite sequence map^Given a number n and a sequence map, return two new sequence maps: the first containing the values from `[0..n-1]` and the next containing the values from n onward._bGiven a sequence map, return a new sequence map that is memoized using a finite map memo table.`PApply the given evaluation function pointwise to the two given sequence maps.a@Apply the given function to each value in the given sequence mapb(Force a word value into packed word formc*Force a word value into a sequence of bitsd*Select an individual bit from a word valuee$Force the evaluation of a word valuefForce the evaluation of a valueoCreate a packed word of n bits.q!Functions that assume word inputsrA type lambda that expects a Type.sA type lambda that expects a Type of kind #.tGenerate a stream.vThis is strict!wConstruct either a finite sequence, or a stream. In the finite case, record whether or not the elements were bits, to aid pretty-printing.xConstruct either a finite sequence, or a stream. In the finite case, record whether or not the elements were bits, to aid pretty-printing.yExtract a bit value.{Extract a sequence.~Extract a packed word.If the given list of values are all fully-evaluated thunks containing bits, return a packed word built from the same bits. However, if any value is not a fully-evaluated bit, return  .3Turn a value into an integer represented by w bits. Extract a function from a value.,Extract a polymorphic function from a value.,Extract a polymorphic function from a value.Extract a tuple from a value.Extract a record from a value.Lookup a field in a record.dGiven an expected type, returns an expression that evaluates to this value, if we can determine it.AXXX: View patterns would probably clean up this definition a lot.e()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\Size of the sequence map]^_`abcdefghijklmn Bit-widthValue Masked resultopqrstuvwxyz{|}~a()*+23,-./01456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~eQRSTUVNOPWMXYZ[\]^_`aJKLbcd@ABCDEFGHIef?:;<=>ghijklm+,-./0123456789()*nopqrstuvwxyz{|}~C()*+,-./0123456789:;<=>?@ ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~B(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe579;'Evaluation environment with no bindings.Bind a variable in the evaluation environment.VBind a variable to a value in the evaluation environment, without creating a thunk.%Lookup a variable in the environment.Bind a type variable of kind *.Lookup a type variable.    C(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone9;<=IM*@ABCDEFGHIprtuwy{~*@ABCDEFGHIprtuwy{~D(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe!"#The property as entered by the user#The property as entered by the user@A test result is either a pass, a failure due to evaluating to False;, or a failure due to an exception raised during evaluationpApply a testable value to some arguments. Note that this function assumes that the values come from a call to P (i.e., things are type-correct). We run in the IO monad in order to catch any  EvalErrors.Given a (function) type, compute all possible inputs for it. We also return the total number of test (i.e., the length of the outer list. QGiven a fully-evaluated type, try to compute the number of values in it. Returns   for infinite types, user-defined types, polymorhic types, and, currently, function spaces. Of course, we can easily compute the sizes of function spaces, but we can't easily enumerate their inhabitants. TReturns all the values in a type. Returns an empty list of values, for types where  returned  .   E(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe JApply a testable value to some randomly-generated arguments. Returns   if the function returned /, or `Just counterexample` if it returned .oPlease note that this function assumes that the generators match the supplied value, otherwise we'll panic.Given a (function) type, compute generators for the function's arguments. Currently we do not support polymorphic functions. In principle, we could apply these to random types, and test the results. {A generator for values of the given type. This fails if we are given a type that lacks a suitable random value generator. Generate a random bit value.BGenerate a random word of the given length (i.e., a value of type [w]m) The size parameter is assumed to vary between 1 and 100, and we use it to generate smaller numbers first.(Generate a random infinite stream value.yGenerate a random sequence. This should be used for sequences other than bits. For sequences of bits use "randomWord". Generate a random tuple value.Generate a random record value. Function under testArgument generatorsSize   F(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Trustworthy !"$<=LMOT[ Make a numeric constant.Create a packed wordKTurn a normal binop on Integers into one that can also deal with a bitsize.Turn a normal binop on Integers into one that can also deal with a bitsize. Generate a thunk that throws a divide by 0 error when forced if the second argument is 0.%Lexicographic ordering on two values.;Process two elements based on their lexicographic ordering.4Join a sequence of sequences into a single sequence.Split implementation.BMerge two values given a binop. This is used for and, or and xor. ,Indexing operations that return one element. .Indexing operations that return many elements. Produce a random value with the given seed. If we do not support making values of the given type, return zero of that type. TODO: do better than returning zeroHbit size of the resulting wordbaseexponentbase exponent maskmodulusfThe function may assume its arguments are masked. It is responsible for masking its result if needed.                        G                       H                        H                        G(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone !"$9:<=MOT[ !CBarrel-shifter algorithm. Takes a list of bits in big-endian order. 0Ceiling (log_2 x) 9Add two polynomials"   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?!   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = >"  ?  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = >"   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?H(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe(<=FMT[ Evaluation environments for list comprehensions: Each variable name is bound to a list of values, one for each element in the list comprehension. &Bindings whose values vary by position "Bindings whose values are constant AcExtend the given evaluation environment with all the declarations contained in the given module. BUEvaluate a Cryptol expression to a value. This evaluator is parameterized by the (y class, which defines the behavior of bits and words, in addition to providing implementations for all the primitives.1Introduce the constructor function for a newtype. CtExtend the given evaluation environment with the result of evaluating the given collection of declaration groups.bThis operation is used to complete the process of setting up recursive declaration groups. It  backfillsq previously-allocated thunk values with the actual evaluation procedure for the body of recursive definitions.}In order to faithfully evaluate the nonstrict semantics of Cryptol, we have to take some care in this process. In particular, we need to ensure that every recursive definition binding is indistinguishable from it's eta-expanded form. The straightforward solution to this is to force an eta-expansion procedure on all recursive definitions. However, for the so-called ?+ types we can instead optimisticly use the U operation and only fall back on full eta expansion if the thunk is double-forced.? types are non-polymorphic types recursive constructed from bits, finite sequences, tuples and records. Types of this form can be implemented rather more efficently than general types because we can rely on the h operation to build a thunk that falls back on performing eta-expansion rather than doing it eagerly.FEta-expand a word value. This forces an unpacked word representation.Given a simulator value and it's type, fully eta-expand the value. This is a type-directed pass that always produces a canonical value of the expected shape. Eta expansion of values is sometimes necessary to ensure the correct evaluation semantics of recursive definitions. Otherwise, expressions that should be expected to produce well-defined values in the denotational semantics will fail to terminate instead.Evaluate a declaration, extending the evaluation environment. Two input environments are given: the first is an environment to use when evaluating the body of the declaration; the second is the environment to extend. There are two environments to handle the subtle name-binding issues that arise from recursive definitions. The 'read only' environment is used to bring recursive names into scope while we are still defining them.Apply the the given "selector" form to the given value. This function pushes tuple and record selections pointwise down into other value constructs (e.g., streams and functions).jEvaluate a list environment at a position. This choses a particular value for the varying locations.Evaluate a comprehension.UTurn a list of matches into the final environments for each iteration of the branch.9Turn a match into the list of environments it represents.    @ A*Module containing declarations to evaluateEnvironment to extend BEvaluation environmentExpression to evaluate CDeclaration groups to evaluateEnvironment to extend7A 'read only' environment for use in declaration bodies>An evaluation environment to extend with the given declarationThe declaration to evaluateStarting evaluation environmentLength of the comprehension"Type of the comprehension elements$Head expression of the comprehension'List of parallel comprehension branches Df @ A B C A @ B Cf    @ A B C DI(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe!"57M EExtra information we need to carry around to dynamically extend an environment outside the context of a single module. Particularly useful when dealing with interactive declarations as in :let or it. M=The file path used to load this module (may not be canonical) N0The canonical version of the path of this module Q.Invariant: All the dependencies of any module m must precede m in the list. UDon't run core lint V Run core lint e7Try to focus a loaded module in the module environment. fwGet a list of all the loaded modules. Each module in the resulting list depends only on other modules that precede it. gbProduce an ifaceDecls that represents the focused environment of the module system, as well as a S5 for pretty-printing names according to the imports.XXX This could really do with some better error handling, just returning mempty when one of the imports fails isn't really desirable. hOThe unqualified declarations and name environment for the dynamic environment. i Retrieve all ye referenced by a module, as well as all of its public and private declarations, checking expressions nBuild yD that correspond to all of the bindings in the dynamic environment.IXXX: if we ever add type synonyms or newtypes at the REPL, revisit this., E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p* E F G H I J K P O L M N Q R S T V U W X a Y Z [ \ ] ^ _ ` b c d e f g h i j k l m n, W X Y Z [ \ ] ^ _ ` a b T U V c d e f g h i Q R S p J K L M N O P j k l m E F G H I o n E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o pJ(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe57: =Unable to find the module given, tried looking in these paths Unable to open a file 4Some other IO error occurred while reading this file =Generated this parse error when parsing the file for module m !Recursive module group discovered "Problems during the renaming phase Problems during the NoPat phase #Problems during the NoInclude phase Problems during type checking 0Problems after type checking, eg. specialization Module loaded by 'import'$ statement has the wrong module name ATwo modules loaded from different files have the same module name gPush an "interactive" context onto the loading stack. A bit of a hack, as it uses a faked module name (Get the currently focused import source. ;Remove a module from the set of loaded module, by its path. Run a  } action in a context with a prepended search path. Useful for temporarily looking in other places while resolving imports, for example.V } ~  K } ~  V ~  } B } ~     K(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe!": 7Rename a module in the context of its imported modules. Run the noPat pass. Load a module by its path. 'Load the module specified by an import. >Load dependencies, typecheck, and add to the eval environment. 0Rewrite an import declaration to be of the form: &import foo as foo [ [hiding] (a,b,c) ] cFind the interface referenced by an import, and generate the naming environment that it describes. =Load a series of interfaces, merging their public interfaces. Discover a module. 'Discover a file. This is distinct from  D in that we assume we've already been given a particular file name. AAdd the prelude to the import list if it's not already mentioned. 7Load the dependencies of a module into the environment. Load the local environment, which consists of the environment for the currently opened module, shadowed by the dynamic environment. uTypecheck a single expression, yielding a renamed parsed expression, typechecked core expression, and a type schema. "Typecheck a group of declarations.LINVARIANT: This assumes that NoPat has already been run on the declarations. Generate the primitive map. If the prelude is currently being loaded, this should be generated directly from the naming environment given to the renamer instead. Typecheck a module. #Generate input for the typechecker.$ $ $    L(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe: FFind the file associated with a module name in the module search path. ,Load the module contained in the given file. Load the given parsed module. nCheck the type of an expression. Give back the renamed expression, the core expression, and its type schema. Evaluate an expression. !Typecheck top-level declarations. ?Evaluate declarations and add them to the extended environment.         Dopqrstuvxyz{|}~ E F G H I W X a Y Z [ \ ] ^ _ ` b d g         D W X Y Z [ \ ] ^ _ ` a b d E F G H I         g ~yz{|}xopqrstuv         MAThe reference implementation of the Cryptol evaluation semantics.(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeM 'Value type for the reference evaluator.  Bit  booleans  [n]a  finite or infinite lists  ( .. )  tuples  { .. }  records  functions polymorphic values (kind *) polymorphic values (kind #) Destructor for VBit.!Destructor for VList."Destructor for VTuple.#Destructor for VRecord.$Destructor for VFun.%Destructor for VPoly.&Destructor for VNumPoly.'Look up a field in a record.(>Polymorphic function values that expect a finite numeric type.).Bind a variable in the evaluation environment.*$Bind a type variable of kind # or *.+>Convert a list of booleans in big-endian format to an integer.,EConvert an integer to big-endian binary value of the specified width.-AConvert an integer to a big-endian format of the specified width..0Create a run-time error value of bitvector type./;Process two elements based on their lexicographic ordering.0%Lexicographic ordering on two values.1Split a list into w pieces, each of length k.2Transpose a list of length-w lists into w lists.3,Indexing operations that return one element.4.Indexing operations that return many elements.M5678     9:;< !"#$%&'()*=Evaluation environmentExpression to evaluate>?@ABCStarting evaluation environment$Head expression of the comprehension'List of parallel comprehension branchesDEFGHIJK+,-.LMNOPQRS/0T12UVWXYZ34[\]^_`a                 C5678      9:;< !"#$%&'()*=>?@ABCDEFGHIJK+,-.LMNOPQRS/0T12UVWXYZ34[\]^_`a   N(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe The specializer monad. sA Name should have an entry in the SpecCache iff it is specializable. Each Name starts out with an empty TypesMap. Add a `where` clause to the given expression containing type-specialized versions of all functions called (transitively) by the body of the expression. "Add the declarations to the SpecCache, run the given monadic action, and then pull the specialized declarations back out of the SpecCache state. Return the result along with the declarations and a table of names of specialized bindings. #<Compute the specialization of `EWhere e dgs`. A decl within dgse is replicated once for each monomorphic type instance at which it is used; decls not mentioned in e- (even monomorphic ones) are simply dropped. $qTransform the given declaration groups into a set of monomorphic declarations. All of the original declarations with monomorphic types are kept; additionally the result set includes instantiated versions of polymorphic decls that are referenced by the monomorphic bindings. We also return a map relating generated names to the names from the original declarations. *)Freshen a name by giving it a new unique. ,3Reduce `length ts` outermost type abstractions and n proof abstractions.           ! " # $ % & ' ( ) * + , - . / 0           ! " # $ % & ' ( ) * + , - . / 0           ! " # $ % & ' ( ) * + , - . / 0           ! " # $ % & ' ( ) * + , - . / 0O(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone!"$:LMT 6A prover result is either an error message, an empty result (eg for the offline prover), a counterexample or a lazy list of satisfying assignments. >The type of query to run ?+Which prover to use (one of the strings in  N) @Verbosity flag passed to SBV ARecord timing information here B?Extra declarations to bring into scope for symbolic simulation C,Optionally output the SMTLIB query to a file D&The typechecked expression to evaluate EThe  of pcExpr0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ `0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ `0 M N O P L I J K F G H < = > ? @ A B C D E ; 6 7 8 9 : Q R S T U V W X Y Z 1 2 3 4 5 [ \ ] ^ _ ` 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ `P(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone !"$0<=DMR[b:User modifiable environment, for things like numeric base. qREPL exceptions. {#REPL_ context with InputT handling.cREPL RW Environment. Focused module  Focused filedInitial, empty environment.e!Build up the prompt for the REPL. +Run a REPL action with a fresh environment. Raise an exception. 1Construct the prompt for the current environment. 6Set the name of the currently focused file, edited by :e and loaded via :r. PRun a computation in batch mode, restoring the previous isBatch flag afterwards &Are let-bindings enabled in this REPL? Update the title <Set the function that will be called when updating the title Set the REPL's string-printer Get the REPL's string-printer 2Use the configured output action to print a string JUse the configured output action to print a string with a trailing newline KUse the configured output action to print something using its Show instance Get visible variable names. !Get visible type signature names. @Return a list of property names, sorted by position in the file. Given an existing qualified name, prefix it with a relatively-unique string. We make it unique by prefixing with a character #. that is not lexically valid in a module name. OGenerate a fresh name using the given index. The name will reside within the " interactive " namespace.f9Generate a UserEnv from a description of the options map. Set a user option. +Get a user option, using Maybe for failure. OGet a user option, when it's known to exist. Fail with panic when it doesn't.gCheck the value to the base option.r c dh e f g h i j ki l m n o pb q r s t u v w x y z { | }cjklmnopqr ~  de stu f v wx gyz{| } L c d e f g h i k j l m n o p q r w s t u v x y z { | } ~  L { | } q r s t u v w x y z ~  l m n o p e f g h i j k c dP c dh e f g h i j ki l m n o pb q r s t u v w x y z { | }c jklmnopqr ~  de stu f v wx gyz{| } Q(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone!":M Command builder.  Commands. Successfully parsed command 2Ambiguous command, list of conflicting commands The unknown command~REPL command parsing.Notebook command parsing.0A subset of commands safe for Notebook execution Run a command. wRandomly test a property, or exhaustively check it if the number of values in the type under test is smaller than the tests9 environment variable, or we specify exhaustive testing.Console-specific version of proveSat/. Prints output to the console, and binds the its variable to a record whose form depends on the expression given. See ticket #66 for a discussion of this design.<Make a type/expression pair that is suitable for binding to it after running :sat or :prove *Lift a parsing action into the REPL monad.@Check declarations as though they were defined at the top-level.hCreates a fresh binding of "it" to the expression given, and adds it to the current dynamic environmentCreates a fresh binding of "it" to a finite sequence of expressions of the same type, and adds that sequence to the current dynamic environment Strip leading space.Strip trailing space. !Split at the first word boundary.Uncons a list. $Lookup a string in the command list. jLookup a string in the command list, returning an exact match even if it's the prefix of another command. 2Lookup a string in the notebook-safe command list. Parse a line as a command.] ~             0 0 J      ~             RYZ[\]^_`aabcdefghijklmnopqrstuvwxyz{|}}~                                     ! " # # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z[\]^_`abcdefghijklmnopqUrUsUtU}UuUvUwUxUyUzU{U|U}U~UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU[Waa      !"#$%%&'(()*+,-./01223456789:;<==>?@ABCDDEFGHIJKLMNNOPQRRSTUVWXYZ[\]^V_`aabcdeefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYVZV[V\V]^_`abcdefghijklmnopqrstuvwxyz{{|}~22NN/W      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^    _ABVV`abcdefghiajk  l mnopqaabrcstduvwxyz{|}~*+,-.&'(                           ! " # $!%!&"'"(")"*"+","-"."/"0"1#2#3#4#5$6$7%8%9%:%;%<%=%>%?%@%A%B%C%D%E%F%G%H%I%J%K%L%M%N%O%P%Q%R%S%T%U&V&W&X&&&&&&&Y&&&&Z&[&\&]&^'_'`'n'a'b'c'd'e(f(g(h(i)j)k)l*m*n+o+++p+q+r+s+t+u+v+w+x+y+z+{+|+}+~+++++++++++*+,,,,,,,,,,,,,,,,D,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,r,,,*,+,,,,-,M,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,U,V,W,,-D--------------------------- - - - - ----U................. .!.".#.$.%.&.'.(.).*.+.,.-.../.0.1.2/3/4/5060718191:1;1<1=1>1?1@1D1A1B1C1D1E1F1G1H1I2J2K2L2M2M2N2O2P2P2Q2R2S2T2U2V2V2W2X2Y2Z2[2\2]2^2_2`2`2a2b2c2d2e2f2g2h2i2j2k2l2m2n2o2p2q2r2s2t2t2u2v2w2w2x2y2z2{2|2}2~2222222222222222222222222222222222222222222222222222222222222222222222222222222222222333333333333333456666666667777778888999999999999999999 9 9 9 9 99999: ::::];;;;;;;;;;;;;;; ;!;!;";#;$;%;&;';(;);*;+;,;-;.;/;0;1;2<3<3<4<5<6<6<7<8<8<9<9<:<;<<<=<><?<@<A<B<C<D<E<F<G<H<I<J<K<L<M<N<O<P<Q<R<S<T<U<V<W<X<Y<Z<[<\<]=^=_=`=a=b=c=d=e=f=g=h=i=j=k=l=m=n=o=p=q=r=s=t=u=v=w=x=y=z={=|=}=~===================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>???????????????????@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA A A A A AAAAAAAAAAAAAAAAAAA A!A"A#A$A%A&A'A(A)A*A+A,A-B.B/B0B1B2B3BFB4BB5B6B7B8B9CC:C;C<C=C>C?C@CACBCCCDCECFCGCCHDIDIDJDKDLDMDNDNDODPDQDRDSDTDUDVDWDDDXDYDZD[D\D]D^D_E`E[E\EaEbEcEdEeEfEgFhFiFjFkFlFmFnFoFpFqFrFsFtFuFvFwFxFyFzF{F|F}F~FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGlGGGGGGGGGGGGGGGsGGGGGGGGGGGGGGGGGH/HHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII I I J J J J J`J`J J J J J J J J J J J J J J J J J J J J J J J J J J J J !J "J #J $J %J &J 'J (J )J *J +JJ ,J -J .JJ /J 0J 1J 2J 3J 4J 5J 6JJ 7J 8J 9J :J ;J <J =J >J ?J @J AJ BJ CJ DJ EJ FJ GJ HJ IJ JJ KJ LJ MJ NJ OJ PJ QJ RJ SJ TJ UJ VJ WJ XJ YK ZK ZK [K \K ]K ^K ^K _K `K_KrK aKaK bK cK dK eK fK gK hK iK jK kK lK mK nK oKK pK qK rK sK tK uKKL vL wLL iL bL dL nLL oLL aLsLtMMM xMMMMMMM yM zN {N |N }N ~N N N N N N N N N N N N N N N N N N N N N N NO O O O O O O O O O O O O O O O O O O O O O O O O O O O O/O O O O O O O O O O O O O O O O O O O O O P P P P P P P P P P P P P P P PZP P P P PP P P P P P PPP P P P P P PP P P P P P P P P P P P P P P P P P P P BP PPP P P P ,P -P DP EP P P P P P P P P P P P P P P P P P P P P P P P Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q !Q "Q "Q #Q $Q %Q &Q 'Q (Q )Q *Q +Q ,Q -Q .Q /Q 0Q 1Q 2Q 3Q 4Q 5Q 6Q 7Q 8Q 9Q :Q ;Q <Q =Q >Q ?Q @Q AR BR CR DR ER FR GR HR IR JR KR LR MS NS OS P Q Q R S T U V W XT YT ZT [T \T ]T ^ _ `  a  b  c d e fU gU hU iU jU kU lU mU nU oU pUU qUU rU sU tU uU vU aU wU xU yU zU {U |U }U ~U U U U U U U U U U U U U UU U U U U U U U U U U U                                                                                                                       a         VV              ! " # $ % & ' ( ) *V +V ,V -V .V .V /V 0V 1V 2V 3V 4V 5V 6V 7V 8V 9V :V ;V <V =V >V ?V @V AV BV CV DV EV FV GV HV IV JV KV LV MV NV OV PV QV RV SV TV UV VV WV XV Y Z [ \ \ ] ^ _ ` ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                       !"#$% T&'()*+,--  ./01234~5 T67 89:;<=>?@AB@ACDEF6GHIJKLMNO T UPQRSTUVWXYZ[\]^_`abcdefghijklm n!!o!`! !p!q!r!s!t!u!v!w!x!y!z!{#|% %}%~%%%%%)))))))))))))++ .++----------V-V--`-`------------------..........................................0@A44455555666 f6o6666666d777777777777788 888888;==================`==V=V====`=`= = = = = ================>>> @A!>">#>$H%H&H'H(H)H*H+H,H-H.H/H0H1H2H%H3H4H5H6H7H8MM9M M!MMMM"M:MFM5M;M<M=M>M{MyM?MMMM-M-M0M1M@MAMBMCMM.MDMEM2MFM0M5M-MGMMlMrMqMMHMIMMMwMuMJMKMLMMMNMOMPMQMRMMMMMMSMPTPVPUPVPWPXPYPZPVP[P\P]P^P_P`PaPbPcPdPePfPgPhPiPjPkPlPmQnQoQpQqQrQsQtQuQvQwQxQyQzQ{Q|Q}Q~QQQQQQQQQQQQQQQQQQQQQQQQQ#cryptol-2.5.0-62ntwDPh16AFY461fF3rKCryptol.VersionCryptol.Utils.PatternsCryptol.Utils.PanicCryptol.Utils.MiscCryptol.Utils.IdentCryptol.Utils.PPCryptol.Utils.DebugCryptol.TypeCheck.Solver.InfNatCryptol.TypeCheck.PPCryptol.REPL.TrieCryptol.Parser.UnlitCryptol.Parser.PositionCryptol.Parser.NameCryptol.Prims.SyntaxCryptol.Parser.LexerCryptol.Parser.ASTCryptol.Parser.NamesCryptol.Parser.NoPatCryptol.Parser.UtilsCryptol.ParserCryptol.Parser.NoIncludeCryptol.ModuleSystem.NameCryptol.TypeCheck.TypeCryptol.TypeCheck.AST$Cryptol.TypeCheck.Solver.Numeric.AST(Cryptol.TypeCheck.Solver.Numeric.Defined-Cryptol.TypeCheck.Solver.Numeric.SimplifyExpr)Cryptol.TypeCheck.Solver.Numeric.Simplify'Cryptol.TypeCheck.Solver.Numeric.NonLin)Cryptol.TypeCheck.Solver.Numeric.Interval$Cryptol.TypeCheck.Solver.Numeric.SMTCryptol.TypeCheck.TypeMapCryptol.Transform.MonoValuesCryptol.TypeCheck.Solver.TypesCryptol.TypeCheck.Solver.Class$Cryptol.TypeCheck.Solver.Numeric.FinCryptol.TypeCheck.TypePatCryptol.TypeCheck.SimpType-Cryptol.TypeCheck.Solver.Numeric.ImportExportCryptol.TypeCheck.Solver.Utils Cryptol.TypeCheck.Solver.NumericCryptol.TypeCheck.SimpleSolverCryptol.TypeCheck.SubstCryptol.TypeCheck.InferTypesCryptol.TypeCheck.SanityCryptol.TypeCheck.Solver.CrySAT Cryptol.TypeCheck.Solver.ImproveCryptol.TypeCheck.TypeOfCryptol.TypeCheck.UnifyCryptol.TypeCheck.MonadCryptol.TypeCheck.DependsCryptol.TypeCheck.Instantiate!Cryptol.TypeCheck.Solver.SelectorCryptol.TypeCheck.Solver.SMTCryptol.TypeCheck.SolveCryptol.TypeCheck.KindCryptol.TypeCheck.InferCryptol.TypeCheckCryptol.ModuleSystem.InterfaceCryptol.ModuleSystem.NamingEnvCryptol.ModuleSystem.RenamerCryptol.Eval.MonadCryptol.Eval.TypeCryptol.Eval.ArchCryptol.Eval.ValueCryptol.Eval.EnvCryptol.Symbolic.ValueCryptol.Testing.ConcreteCryptol.Testing.RandomCryptol.Prims.EvalCryptol.Symbolic.Prims Cryptol.EvalCryptol.ModuleSystem.EnvCryptol.ModuleSystem.MonadCryptol.ModuleSystem.BaseCryptol.ModuleSystemCryptol.Eval.ReferenceCryptol.Transform.SpecializeCryptol.SymbolicCryptol.REPL.MonadCryptol.REPL.Command Paths_cryptolGitRevCryptol.PreludeCryptol.Parser.LexerUtilsCryptol.Parser.ParserUtilsKindhsversion commitHashcommitShortHash commitBranch commitDirtyMatchesmatchesPatMatch|||&&&~>~~><~__succeed checkThatlit matchDefaultmatch matchMaybelist><$fMatchesa(,,,)(,,)$fMatchesa(,,)(,)$fMatchesa(,)r1$fMonadPlusMatch$fAlternativeMatch $fMonadMatch$fApplicativeMatch$fFunctorMatchpanic$fExceptionCryptolPanic$fShowCryptolPanicanyJustanyJust2IdentModName unpackModName packModNamemodSep packIdent packInfix unpackIdentmkIdentmkInfix isInfixIdent nullIdent identText preludeNamepreludeExtrasNameinteractiveName $fNFDataIdent$fIsStringIdent $fOrdIdent $fEqIdent $fShowIdent$fGenericIdentInfixieOpieLeftieRightiePrecieAssocAssoc LeftAssoc RightAssocNonAssocPPName ppNameFixity ppPrefixName ppInfixNamePPppPrecDoc NameFormat UnQualified Qualified NotInScopeNameDisp EmptyNameDispneverQualifyMod alwaysQualify neverQualify fmtModNameextend getNameFormat withNameDisp fixNameDisprunDocrenderpppretty optParenscommaSepppInfixordinal ordSuffixliftPJliftPJ1liftPJ2liftSep<><+>$$sepfsephsephcatvcathangnestparensbracesbracketsquotes punctuatetextcharintegerintcommaemptycolon $fPPIdent$fPPText $fIsStringDoc $fShowDoc $fMonoidDoc$fMonoidNameDisp$fShowNameDisp$fShowNameFormat$fGenericNameDisp$fNFDataNameDisp $fGenericDoc $fNFDataDoc $fShowAssoc $fEqAssoc$fGenericAssoc $fNFDataAssoctraceppTraceNat'NatInffromNatnAddnMulnExpnMinnMaxnSubnDivnModnLg2nWidth nLenFromThennLenFromThenTogenLog widthInteger rootExactgenRoot $fShowNat'$fEqNat' $fOrdNat' $fGenericNat' $fNFDataNat' WithNamesNameMap emptyNameMapppWithNamesPrec ppWithNamesdumpnameList intToNameTrieNode emptyTrie insertTrie lookupTrielookupTrieExactleaves $fShowTriePreProcNoneMarkdownLaTeX knownExts guessPreProcunLitAddLocaddLocdropLocHasLocgetLocRangefromtosourcePositionlinecolLocatedsrcRangething emptyRangestartmovemovesrCombrCombsat$fAddLocLocated $fHasLoc[] $fHasLoc(,)$fHasLocLocated $fHasLocRange$fPPNameLocated $fPPLocated $fPPRange $fPPPosition$fFunctorLocated $fEqPosition $fOrdPosition$fShowPosition$fGenericPosition$fNFDataPosition $fEqRange $fShowRange$fGenericRange $fNFDataRange $fEqLocated $fShowLocated$fGenericLocated$fNFDataLocatedPassNoPat MonoValuesPNameUnQualQualNewNamemkUnqualmkQual getModNamegetIdent $fPPNamePName $fPPPName $fNFDataPass $fNFDataPName$fEqPass $fOrdPass $fShowPass $fGenericPass $fEqPName $fOrdPName $fShowPName$fGenericPNameTFunTCAddTCSubTCMulTCDivTCModTCExpTCWidthTCMinTCMax TCLenFromThenTCLenFromThenTo tBinOpPrec tfunNames$fPPTFun $fPPNameTFun $fShowTFun$fEqTFun $fOrdTFun $fBoundedTFun $fEnumTFun $fGenericTFun $fNFDataTFunTokenTNumChrLitStrLitKWOpSymVirtWhiteErrEOFTokenErrUnterminatedCommentUnterminatedStringUnterminatedChar InvalidString InvalidChar LexicalErrorTokenSymBarArrLArrRFatArrRLambdaEqDefCommaSemiDotDotDot DotDotDotColonBackTickParenLParenRBracketLBracketRCurlyLCurlyRTriLTriR UnderscoreTokenKWKW_ArithKW_BitKW_CmpKW_elseKW_Eq KW_externKW_finKW_if KW_private KW_includeKW_infKW_lg2KW_lengthFromThenKW_lengthFromThenToKW_maxKW_min KW_module KW_newtype KW_pragma KW_propertyKW_thenKW_typeKW_whereKW_letKW_x KW_importKW_as KW_hiding KW_infixl KW_infixrKW_infix KW_primitiveTokenW BlockComment LineCommentSpaceDocStrTokenVVCurlyLVCurlyRVSemiToken tokenType tokenTextLayoutNoLayoutConfig cfgSource cfgLayout cfgPreProccfgAutoIncludecfgModuleScope defaultConfiglexer primLexerNoPosnoPosPropCFinCEqualCGeqCArithCCmpCLocatedCTypeTypeTSeqTBitTNumTCharTInfTUserTAppTRecordTTupleTWildTLocatedTParensTInfixTParamtpNametpKindtpRangeKNumKTypeSchemaForallNamednamevaluePatternPVarPWildPTuplePRecordPListPTypedPSplitPLocatedMatchLetSelectorTupleSel RecordSelListSelTypeInst NamedInstPosInstExprEVarELitETupleERecordESelEListEFromToEInfFromECompEAppEAppTEIfEWhereETypedETypeValEFunELocatedEParensEInfixLiteralECNumECStringNumInfoBinLitOctLitDecLitHexLitCharLitPolyLit ExportSpeceTypeseBindsTopLeveltlExporttlDoctlValue ExportTypePublicPrivate ReplInput ExprInputLetInputNewtypenNamenParamsnBodyPragma PragmaNotePragmaProperty FixityCmpFCErrorFCLeftFCRightFixityfAssocfLevelBindDefDPrimDExprLBindDefBindbNamebParamsbDef bSignaturebInfixbFixitybPragmasbMonobDocTySyn ImportSpecHidingOnlyImportiModuleiAsiSpecDecl DSignatureDFixityDPragmaDBindDPatBindDTypeDLocatedTopDecl TDNewtypeIncludeModulemNamemImportsmDeclsProgramLStringLIdentLPNamemodRange compareFixity defaultFixity exportBindisExportedBind exportTypeisExportedType tconNames ppSelectorcppKind $fNoPosProp $fNoPosType $fNoPosTParam $fNoPosSchema$fNoPosPattern $fNoPosMatch$fNoPosTypeInst $fNoPosExpr $fNoPosTySyn $fNoPosPragma $fNoPosBind$fNoPosNewtype $fNoPosDecl$fNoPosTopLevel$fNoPosTopDecl $fNoPosModule$fNoPosProgram $fNoPosMaybe $fNoPos[] $fNoPosNamed$fNoPosLocated$fPPProp$fPPType $fPPTParam$fPPKind $fPPSchema $fPPMatch $fPPPattern $fPPSelector$fPPExpr $fPPTypeInst $fPPLiteral $fPPTySyn $fPPBindDef$fPPBind $fPPPragma $fPPTopLevel$fPPImportSpec $fPPImport $fPPNewtype$fPPDecl $fPPTopDecl $fPPProgram $fPPModule$fHasLocNewtype$fHasLocModule$fHasLocTopDecl$fHasLocTopLevel $fAddLocDecl $fHasLocDecl$fAddLocSchema$fHasLocSchema $fHasLocNamed $fHasLocMatch $fHasLocBind$fHasLocPattern$fAddLocPattern $fAddLocProp $fHasLocProp $fAddLocType $fHasLocType$fAddLocTParam$fHasLocTParam $fHasLocExpr $fAddLocExpr$fMonoidExportSpec$fEqImportSpec$fShowImportSpec$fGenericImportSpec$fNFDataImportSpec $fEqImport $fShowImport$fGenericImport$fNFDataImport $fEqFixity $fShowFixity$fGenericFixity$fNFDataFixity$fShowFixityCmp $fEqFixityCmp $fEqPragma $fShowPragma$fGenericPragma$fNFDataPragma$fEqExportType$fShowExportType$fOrdExportType$fGenericExportType$fNFDataExportType$fShowTopLevel$fGenericTopLevel$fNFDataTopLevel$fFunctorTopLevel$fFoldableTopLevel$fTraversableTopLevel$fShowExportSpec$fGenericExportSpec$fNFDataExportSpec $fEqNumInfo $fShowNumInfo$fGenericNumInfo$fNFDataNumInfo $fEqLiteral $fShowLiteral$fGenericLiteral$fNFDataLiteral $fEqSelector$fShowSelector $fOrdSelector$fGenericSelector$fNFDataSelector $fEqNamed $fShowNamed$fFoldableNamed$fTraversableNamed$fGenericNamed $fNFDataNamed$fFunctorNamed$fEqKind $fShowKind $fGenericKind $fNFDataKind $fEqTParam $fShowTParam$fGenericTParam$fNFDataTParam$fEqType $fShowType $fGenericType $fNFDataType $fEqPattern $fShowPattern$fGenericPattern$fNFDataPattern $fEqTypeInst$fShowTypeInst$fGenericTypeInst$fNFDataTypeInst $fEqNewtype $fShowNewtype$fGenericNewtype$fNFDataNewtype $fEqTySyn $fShowTySyn$fGenericTySyn $fNFDataTySyn$fEqProp $fShowProp $fGenericProp $fNFDataProp $fEqSchema $fShowSchema$fGenericSchema$fNFDataSchema$fEqDecl $fShowDecl $fGenericDecl $fNFDataDecl$fEqExpr $fShowExpr $fGenericExpr $fNFDataExpr $fEqMatch $fShowMatch$fGenericMatch $fNFDataMatch$fEqBind $fShowBind $fGenericBind $fNFDataBind $fEqBindDef $fShowBindDef$fGenericBindDef$fNFDataBindDef $fEqReplInput$fShowReplInput $fShowTopDecl$fGenericTopDecl$fNFDataTopDecl $fShowModule$fGenericModule$fNFDataModule $fShowProgram modExportstnamesNTnamesDsnamesD allNamesDtsNamenamesBnamesDefnamesEnamesPsnamesPnamesMnamesArm boundNamesnamesTtnamesDstnamesDtnamesB tnamesDeftnamesEtnamesTItnamesPtnamesMtnamesStnamesCtnamesTErrorMultipleSignaturesSignatureNoBind PragmaNoBindMultipleFixities FixityNoBind MultipleDocsRemovePatternsremovePatterns $fPPError $fMonadNoPatM$fApplicativeNoPatM$fFunctorNoPatM$fRemovePatterns[]$fRemovePatternsModule$fRemovePatternsExpr$fRemovePatternsProgram $fShowError$fGenericError $fNFDataError widthIdenttranslateExprToNumT ParseError HappyError HappyErrorMsgppError parseModName parseHelpNameparseProgramWith parseModule parseProgram parseExprWith parseExpr parseDeclWith parseDeclparseDeclsWith parseDeclsparseLetDeclWith parseLetDecl parseReplWith parseReplparseSchemaWith parseSchema IncludeError IncludeFailedIncludeParseError IncludeCycleremoveIncludesModuleppIncludeError $fMonadNoIncM$fApplicativeNoIncM$fFunctorNoIncM$fShowIncludeError$fGenericIncludeError$fNFDataIncludeErrorPrimMap primDecls primTypesSupplySupplyTFreshM liftSupplyNameNameInfoDeclared ParametercmpNameLexicalcmpNameDisplay ppLocName nameUnique nameIdentnameInfonameLoc nameFixityasPrim runSupplyT nextUniqueM emptySupply nextUnique mkDeclared mkParameterlookupPrimDecllookupPrimType$fMonadFixSupplyT$fRunMSupplyTa(->)$fBaseMSupplyTn$fMonadTSupplyT$fMonadSupplyT$fApplicativeSupplyT$fFunctorSupplyT$fFreshMSupplyT$fFreshMStateT$fFreshMReaderT$fFreshMWriterT$fFreshMExceptionT $fPPNameName$fPPName $fOrdName$fEqName $fEqNameInfo$fShowNameInfo$fGenericNameInfo$fNFDataNameInfo $fShowName $fGenericName $fNFDataName $fShowSupply$fGenericSupply$fNFDataSupply $fShowPrimMap$fGenericPrimMap$fNFDataPrimMapFVSfvsSTypeHasKindkindOfntNamentParams ntConstraintsntFieldstsParams tsConstraintstsDefTCErrorMessagetcErrorMessageUserTCTCTCNumTCInfTCBitTCSeqTCFunTCTuple TCNewtypePCPEqualPNeqPGeqPFinPHasPArithPCmpPAndPTrueTConTFTErrorTVarTVFreeTVBoundTRectpUniquesVarssPropssTypeKProp:-> quickApply kindResulttpVarnewtypeConTypeisFreeTV isBoundTVtIsErrortIsNat'tIsNumtIsInftIsVartIsFuntIsSeqtIsBittIsTuple tIsBinFun tSplitFunpIsFinpIsGeqpIsEqpIsArithpIsCmppIsTruepIsWidthtNumtZerotOnetTwotInftNat'tBittWordtSeqtChartStringtRectTuple newtypeTyContFuntNoUser tBadNumbertf1tf2tf3tSubtMultDivtModtExptMintWidth tLenFromThentLenFromThenTo=#==/=pArithpCmp>==pHaspTruepAnd pSplitAndpFinpError addTNamesppNewtypeShort $fPPUserTC$fPPTC$fPPPC$fPPTCErrorMessage$fPPTCon$fPPTVar $fPPWithNames$fPPWithNames0$fPPWithNames1$fPPWithNames2$fPPWithNames3 $fFVSSchema$fFVS(,)$fFVS[] $fFVSMaybe $fFVSType $fOrdTVar$fEqTVar $fOrdUserTC $fEqUserTC $fOrdTParam $fOrdType$fHasKindTParam$fHasKindNewtype$fHasKindTySyn $fHasKindType $fHasKindTFun $fHasKindPC $fHasKindTC$fHasKindUserTC $fHasKindTCon $fHasKindTVar $fOrdKind $fShowTVar $fGenericTVar $fNFDataTVar$fShowPC$fEqPC$fOrdPC $fGenericPC $fNFDataPC $fShowUserTC$fGenericUserTC$fNFDataUserTC$fShowTC$fEqTC$fOrdTC $fGenericTC $fNFDataTC$fShowTCErrorMessage$fEqTCErrorMessage$fOrdTCErrorMessage$fGenericTCErrorMessage$fNFDataTCErrorMessage $fShowTCon$fEqTCon $fOrdTCon $fGenericTCon $fNFDataTConDeclDefdName dSignature dDefinitiondPragmasdInfixdFixitydDoc DeclGroup Recursive NonRecursiveFromLetERecETAbsETAppEAbs EProofAbs EProofAppmExportsmTySyns mNewtypes groupDeclsePrimeErroreStringeCharppLam splitWhilesplitAbs splitTAbs splitProofAbs $fPPDeclGroup$fPPWithNames4 $fShowDeclDef$fGenericDeclDef$fNFDataDeclDef$fShowDeclGroup$fGenericDeclGroup$fNFDataDeclGroupHasVarsapSubstSubstIfExprIfExpr'IfReturn ImpossibleKVar:+:-:*DivMod:^^MinMaxWidth LenFromThen LenFromThenToFin:==:>=:>:==::>::&&:||NotPFalseUserNameSysNamezeroonetwoinfcryAndscryOrs cryPropExprs cryExprExprscryRebuildExpr cryExprFVS cryPropFVS composeSubstcryLet doAppSubstppNameppProp ppPropPrecppExpr ppExprPrecppIfExprppIf $fHasVarsProp $fHasVarsExpr $fHasVarsBool$fApplicativeIfExpr'$fFunctorIfExpr'$fMonadIfExpr' $fOrdExpr $fEqIfExpr'cryDefinedProp cryDefinedSignPosNeg crySimpExprcrySimpExprMaybe otherSignsignedsplitSumnormSumcrySimpExprStepcrySimpExprStep1 $fShowSign crySimplifycrySimplifyMaybecrySimpPropExprcrySimpPropExprMaybeNonLinS nonLinProp apSubstNLlookupNL nonLinSubstinitialNonLinS $fShowNonLinSIntervaliLoweriUpperIntervalUpdateNoChangeInvalidInterval NewIntervals typeIntervalupdateIntervalcomputePropIntervals propInterval ppIntervals ppIntervaliIsExactiIsFin iDisjoint iIntersectiAnyiAnyFiniConstiAddiMuliExpiMiniMaxiSubiDiviModiWidth iLenFromTheniLenFromThenTo $fEqInterval$fShowInterval$fShowIntervalUpdate desugarPropifPropToSmtLibsmtName smtFinNamegetValgetValscryImproveModelTypeMapTMtvartcontrecTypesMapListLnilconsTrieMapemptyTMnullTMlookupTMalterTMunionTMtoListTMmapMaybeWithKeyTM membersTMinsertTM insertWithTMmapTM mapWithKeyTM mapMaybeTM $fShowTypeMap$fTrieMapTypeMapType $fTrieMapMapa$fTrieMapList[] $fFunctorList$fFunctorTypeMap rewModule$fTrieMapRewMap'(,,)SolvedSolvedIfUnsolved UnsolvableCtxtelseTry solveOpts matchThenguarded $fPPSolved $fShowSolved classStepsolveArithInst solveCmpInst expandPropcryIsFin cryIsFinTypeaInfaNataNat'anAdd|-|aMul|^||/||%|aMinaMaxaWidth aLenFromThenaLenFromThenToaTVaraBitaSeqaWordaCharaTuple|->|aFin|=||/=||>=|aCmpaArithaAndaTrueanError tRebuild'tRebuildtAddtMaxtotalop1op2op3tOpExportM exportProp runExportM exportPropM exportTypeM importProp importTypesplitVarSummandssplitVarSummandsplitConstSummandsplitConstFactor cryIsEqual cryIsNotEqualcryIsGeqsimplify simplifyStepTVars emptySubst singleSubst@@defaultingSubst listSubst isEmptySubst substBinds substToList apSubstMaybeapplySubstToVarapSubstTypeMapKeys $fTVarsModule$fTVarsDeclDef $fTVarsDecl$fTVarsDeclGroup $fTVarsMatch $fTVarsExpr $fTVarsSchema$fTVarsTypeMap $fTVarsList $fTVarsType $fTVars(,) $fTVars[] $fTVarsMaybe $fPPSubst $fShowSubst TyFunName UserTyFun BuiltInTyFunConstraintSourceCtComprehension CtSplitPat CtTypeSigCtInst CtSelector CtExactType CtEnumeration CtDefaultingCtPartialTypeFun CtImprovement CtPatternErrorMsg KindMismatchTooManyTypeParamsTooManyTySynParamsTooFewTySynParamsRepeatedTyParamsRepeatedDefinitionsRecursiveTypeDeclsUndefinedTypeSynonymUndefinedVariableUndefinedTypeParamMultipleTypeParamDefs TypeMismatch RecursiveType UnsolvedGoalsUnsolvedDelayedCtUnexpectedTypeWildCardTypeVariableEscaped NotForAllUnusableFunctionTooManyPositionalTypeParams%CannotMixPositionalAndNamedTypeParams AmbiguousTypeWarningDefaultingKindDefaultingWildType DefaultingTo DelayedCt dctSource dctForalldctAsmpsdctGoalsHasGoalhasNamehasGoalGoal goalSource goalRangegoalGoalsVarTypeExtVarCurSCC SolverConfig solverPath solverArgs solverVerbose emptyGoals nullGoals fromGoals insertGoal addTVarsDescsppUse$fPPConstraintSource $fPPWarning$fTVarsDelayedCt$fTVarsHasGoal $fTVarsGoal $fTVarsGoals$fFVSDelayedCt $fFVSGoal $fFVSError $fTVarsError $fFVSWarning$fTVarsWarning$fTVarsConstraintSource $fPPTyFunName $fOrdGoal$fEqGoal$fShowSolverConfig$fGenericSolverConfig$fNFDataSolverConfig $fShowWarning$fGenericWarning$fNFDataWarning$fShowTyFunName$fGenericTyFunName$fNFDataTyFunName$fShowConstraintSource$fGenericConstraintSource$fNFDataConstraintSource $fShowGoal $fGenericGoal $fNFDataGoal$fShowDelayedCt$fGenericDelayedCt$fNFDataDelayedCt $fShowHasGoal $fShowGoals ExpectedMonoTupleSelectorOutOfRange MissingFieldUnexpectedTupleShapeUnexpectedRecordShapeUnexpectedSequenceShape BadSelectorBadInstantiationCaptured BadProofNoAbsBadProofTyVarsNotEnoughArgumentsInKindBadApplicationFreeTypeVariableBadTypeApplicationRepeatedVariableInForallBadMatchEmptyArmUndefinedTypeVaraibleProofObligationsametcExprtcDeclstcModule $fMonadTcM$fApplicativeTcM $fFunctorTcM $fSameTParam $fSameSchema $fSameType$fSame[]DebugLogdebugLog debugLogListSolverlogger DefinedPropdpData dpSimpPropdpSimpExprProp knownDefined numericRight simplifyProps assumePropsminimizeContradictionSimpDefgetModelloadFile rawSolver getIntervals withSolver withScopecheck debugBlock$fDebugLogProp$fDebugLogSubst$fDebugLogGoal$fDebugLogType $fDebugLogDoc$fDebugLogMaybe $fDebugLog[]$fDebugLogChar $fHasPropGoal $fHasPropType $fShowScope $fShowVarInfo improveProps improveProp improveEq fastTypeOf fastSchemaOfUnificationErrorUniTypeMismatchUniKindMismatchUniTypeLenMismatch UniRecursiveUniNonPolyDepends UniNonPolyResultOKMGUuniErroremptyMGUmgumguManybindVar $fMonadResult$fApplicativeResult$fFunctorResultLkpTyVar TLocalVar TOuterVarKRW typeParamskCtrsKRO lazyTVars allowWildKindMKMunKMRWiErrors iWarningsiSubst iExistTVars iSolvedHas iNameSeedsiCtsiHasCtsiSupplyROiRangeiVarsiTVarsiTSyns iNewtypesiSolvedHasLazy iMonoBindsiSolver iPrimNames iSolveCounterDefLocIsLocal IsExternalInferMIMunIM InferOutput InferFailedInferOK NameSeedsseedTVarseedGoal InferInputinpRangeinpVarsinpTSyns inpNewtypes inpNameSeeds inpMonoBindsinpSolverConfig inpSearchPath inpPrimNames inpSupply nameSeeds bumpCounter runInferMioinRange inRangeMbcurRange recordError recordWarning getSolver getPrimMapnewGoalnewGoalsgetGoalsaddGoals collectGoalssimpGoal simpGoals newHasGoal addHasGoal getHasGoals solveHasGoalnewName newGoalNamenewTVarnewTVar' newTParamnewTypeunify applySubstgetSubst extendSubst varsWithAsmps lookupVar lookupTVar lookupTSyn lookupNewtypeexistVargetTSyns getNewtypesgetTVarsgetBoundInScope getMonoBindscheckTShadowing withTParam withTParams withTySyn withNewtype withVarType withVarTypeswithVar withMonoType withMonoTypes withDecls inNewScoperunKindM kLookupTyVarkWildOK kRecordErrorkRecordWarningkNewType kLookupTSynkLookupNewtype kExistTVar kInstantiateTkSetKindkInRange kNewGoals kInInferM $fMonadKindM$fApplicativeKindM$fFunctorKindM$fFreshMInferM$fMonadFixInferM $fMonadInferM$fApplicativeInferM$fFunctorInferM$fShowNameSeeds$fGenericNameSeeds$fNFDataNameSeeds$fShowInferInput$fShowInferOutputFromDecltoBindtoTyDecl isTopDeclTyDeclTSNT orderTyDecls orderBindsmkScc combineMapscombine duplicates$fFromDeclDecl$fFromDeclTopDeclinstantiateWith tryHasGoalproveImpcheckUnsolvable$fMk(,,)$fMk(,)$fMkTCErrorMessage$fMkType$fMkTVar $fMkInteger$fMk()wfTypeFunctionwfTypesimplifyAllConstraintsproveImplicationimproveByDefaultingWithdefaultReplExpr checkSchema checkTySyn checkNewtype checkType inferModulemkPrimdesugarLiteralappTys inferTyParamcheckTypeOfKindinferEcheckE expectSeq expectTuple expectRec expectFin expectFun checkHasTypecheckFunsmallestcheckPinferP inferMatch inferCArm inferBinds guessType generalize checkMonoB checkSigBinferDstcPanic ppWarning IfaceDecl ifDeclName ifDeclSig ifDeclPragmas ifDeclInfix ifDeclFixity ifDeclDoc IfaceNewtype IfaceTySyn IfaceDeclsifTySyns ifNewtypesifDeclsIface ifModNameifPublic ifPrivate ifTySynName mkIfaceDeclgenIface ifacePrimMap$fMonoidIfaceDecls$fShowIfaceDecl$fGenericIfaceDecl$fNFDataIfaceDecl$fShowIfaceDecls$fGenericIfaceDecls$fNFDataIfaceDecls $fShowIface$fGenericIface $fNFDataIface ImportIface BindsNames namingEnvBuildNamingEnvrunBuildInModule NamingEnvneExprsneTypesneFixitymerge toPrimMap toNameDisp visibleNamesqualify filterNames singletonT singletonE shadowing travNamingEnv namingEnv' interpImportunqualifiedEnv$fBindsNamesInModule$fBindsNamesInModule0$fBindsNamesInModule1$fBindsNamesModule$fBindsNamesTParam$fBindsNamesInModule2$fBindsNamesImportIface$fBindsNamesSchema$fBindsNames[]$fBindsNamesMaybe$fBindsNamesNamingEnv$fMonoidBuildNamingEnv$fMonoidNamingEnv$fShowNamingEnv$fGenericNamingEnv$fNFDataNamingEnv$fFunctorInModule$fTraversableInModule$fFoldableInModule$fShowInModuleRenamerenameRenameMRenamerWarningSymbolShadowedDangerousFixity RenamerError MultipleSyms UnboundExpr UnboundTypeOverlappingSyms ExpectedValue ExpectedType FixityErrorInvalidConstraintMalformedBuiltinBoundReservedType runRenamer shadowNamescheckNamingEnv renameModule renameVar renameType $fRenameTySyn $fRenameMatch$fRenameTypeInst $fRenameExpr$fRenamePattern$fRenameBindDef $fRenameBind $fRenameType $fRenameProp$fRenameTParam$fRenameSchema$fRenameNewtype $fRenameDecl$fRenameTopDecl$fFreshMRenameM$fMonadRenameM$fApplicativeRenameM$fFunctorRenameM$fMonoidRenameM$fPPRenamerWarning$fPPRenamerError$fShowRenamerError$fGenericRenamerError$fNFDataRenamerError$fShowRenamerWarning$fGenericRenamerWarning$fNFDataRenamerWarning $fEqEnvCheck$fShowEnvCheck EvalError InvalidIndexTypeCannotBeDemoted DivideByZero WordTooWide UserError LoopErrorEvalReadyThunkreadydelay delayFill blackholerunEval evalPanictypeCannotBeDemoted divideByZero wordTooWide cryUserError cryLoopError invalidIndex$fExceptionEvalError $fPPEvalError$fMonadFixEval $fNFDataEval $fMonadIOEval $fMonadEval$fApplicativeEval $fFunctorEval$fShowEvalErrorTypeEnvTValueTVBitTVSeqTVStreamTVTupleTVRecTVFuntValTyisTBittvSeqfinNat'evalType evalValType evalNumTypeevalTF $fShowTValue$fGenericTValue$fNFDataTValuemaxBigIntWidth EvalPrimsevalPrimiteValueBitWordppBitppWord wordAsCharwordLenbitLitwordLitpackWord unpackWordjoinWord splitWord extractWordwordPlus wordMinuswordMultPPOptsuseAsciiuseBase useInfLengthValueGenValueVRecordVTupleVBitVSeqVWordVStreamVFunVPolyVNumPoly WordValueWordValBitsVal SeqValMapSeqMap IndexSeqMap UpdateSeqMapBVbinBVunaryBVbvValmkBv lookupSeqMap finiteSeqMapinfiniteSeqMapenumerateSeqMap streamSeqMap reverseSeqMap updateSeqMap splitSeqMapmemoMap zipSeqMap mapSeqMap asWordVal asBitsValindexWordValueforceWordValue forceValue defaultPPOptsatFstatSndppValue asciiMode integerToCharppBVmaskwordlamwlamtlamnlamtoStreamtoFinSeq boolToWordtoSeqmkSeqfromVBitbitsSeqfromSeqfromStr fromWordVal fromVWordvWordLen tryFromBitsfromWordfromVFun fromVPoly fromVNumPoly fromVTuple fromVRecord lookupRecordtoExpr$fBitWordBoolBV$fShowGenValue$fNFDataSeqMap$fShowBV $fGenericBV $fNFDataBV$fGenericWordValue$fNFDataWordValue$fGenericGenValue$fNFDataGenValue GenEvalEnvEvalEnvenvVarsenvTypesppEnvemptyEnv bindVarDirectbindType lookupType$fMonoidGenEvalEnv$fGenericGenEvalEnv$fNFDataGenEvalEnvSWordSBool fromBitsLE literalSWord forallBV_ existsBV_ forallSBool_ existsSBool_ iteSValuemergeBit mergeWord mergeBits mergeValue mergeSeqMap$fBitWordSValSVal TestReport reportResult reportPropreportTestsRunreportTestsPossibleTestSpectestFntestProp testTotal testPossibletestRptProgresstestClrProgresstestRptFailuretestRptSuccess TestResult FailFalse FailErrorisPass runOneTest testableTypetypeSize typeValuesrunTestsGen randomValue randomBit randomWord randomStreamrandomSequence randomTuple randomRecord UnaryArithBinArithUnaryBinary primTable ecDemoteV divModPolymodExp doubleAndAddbinaryunary liftBinArith liftDivArith arithBinaryliftUnaryArith arithUnarylg2 lexCompare zipLexComparecmpOrder withOrdermaxVminVfunCmpzeroV joinWordVal joinWordsjoinSeqjoinV splitWordValsplitAtVextractWordValecSplitVreverseV transposeVccatVwordValLogicOp logicBinarywordValUnaryOp logicUnary logicShiftshiftLWshiftLBshiftLSshiftRWshiftRBshiftRSrotateLWrotateLBrotateLSrotateRWrotateRBrotateRS indexPrimOne indexFrontindexFront_bits indexBackindexBack_bits indexPrimMany updateFrontupdateFront_bits updateBackupdateBack_bits updatePrim fromThenVfromToV fromThenToVinfFromV infFromThenVrandomVerrorV$fEvalPrimsBoolBV traverseSnditeWordshifterselectVupdateFrontSymupdateFrontSym_bits updateBackSymupdateBackSym_bits asBitList asWordListsExpsLg2cmpValuecmpEqcmpNotEqcmpLtcmpGtcmpLtEqcmpGtEq cmpBinaryaddPolyitesdegreemdpnthdivx$fEvalPrimsSValSVal moduleEnvevalExpr evalDecls$fMonoidListEnv DynamicEnvDEnvdeNamesdeDeclsdeEnv LoadedModulelmName lmFilePathlmCanonicalPath lmInterfacelmModule LoadedModulesgetLoadedModulesCoreLint NoCoreLint ModuleEnvmeLoadedModules meNameSeeds meEvalEnvmeFocusedModule meSearchPathmeDynEnv meMonoBindsmeSolverConfig meCoreLintmeSupplyresetModuleEnvinitialModuleEnv focusModule loadedModules focusedEnv dynamicEnv qualifiedEnvisLoaded lookupModuleaddLoadedModuleremoveLoadedModule deIfaceDecls$fMonoidDynamicEnv$fMonoidLoadedModules$fGenericCoreLint$fNFDataCoreLint$fShowLoadedModule$fGenericLoadedModule$fNFDataLoadedModule$fShowLoadedModules$fGenericLoadedModules$fNFDataLoadedModules$fGenericDynamicEnv$fNFDataDynamicEnv$fGenericModuleEnv$fNFDataModuleEnvModuleMModuleT unModuleT roLoading ModuleWarningTypeCheckWarningsRenamerWarnings ModuleErrorModuleNotFound CantFindFile OtherIOErrorModuleParseErrorRecursiveModules RenamerErrors NoPatErrorsNoIncludeErrorsTypeCheckingFailed OtherFailureModuleNameMismatchDuplicateModuleName ImportSource FromModule FromImportimportedModulemoduleNotFound cantFindFile otherIOErrormoduleParseErrorrecursiveModules renamerErrors noPatErrorsnoIncludeErrorstypeCheckingFailedmoduleNameMismatchduplicateModuleNamewarntypeCheckWarningsrenamerWarningsemptyRO runModuleT runModuleM getModuleEnv setModuleEnvmodifyModuleEnv loadingImport loadingModule interactiveloadinggetImportSourcegetIface getNameSeeds getSupply setMonoBinds setNameSeeds setSupply unloadModule loadedModule modifyEvalEnv getEvalEnvgetFocusedModulesetFocusedModule getSearchPathwithPrependedSearchPath getFocusedEnvgetQualifiedEnv getDynEnv setDynEnv setSolvergetSolverConfig$fMonadIOModuleT$fFreshMModuleT$fMonadTModuleT$fMonadModuleT$fApplicativeModuleT$fFunctorModuleT$fPPModuleWarning$fPPModuleError$fNFDataModuleError$fPPImportSource$fEqImportSource$fShowImportSource$fGenericImportSource$fNFDataImportSource$fShowModuleError$fShowModuleWarning$fGenericModuleWarning$fNFDataModuleWarningTCActiontcActiontcLintertcPrimsTCLinter lintCheck lintModulenoPatloadModuleByPath loadImport loadModulefullyQualified importIface importIfaces moduleFile findModulefindFile addPreludeloadDeps getLocalEnv checkExpr checkDecls checkModule exprLinter declsLinter moduleLinter typecheck genInferInput ModuleRes ModuleCmdVListevaluate $fMonoidEnvSpecMSpecT SpecCacherunSpecT liftSpecT getSpecCache setSpecCachemodifySpecCachemodify specializespecializeExprspecializeMatchwithDeclGroupsspecializeEWherespecializeDeclGroupsspecializeConstdestEProofApps destETApps destEProofAbs destETAbs freshNameinstantiateSchemainstantiateExpr allDeclGroupsallLoadedModulesallPublicNamesFinTypeFTBitFTSeqFTTupleFTRecord ProverResult AllSatResult ThmResult EmptyResult ProverError ProverStats ProverCommand pcQueryType pcProverName pcVerbose pcProverStats pcExtraDecls pcSmtFilepcExprpcSchema QueryTypeSatQuery ProveQuerySatNumAllSatSomeSat SatResult proverConfigs proverNames lookupProver satSMTResultsallSatSMTResults thmSMTResults proverErrorsatProvesatProveOffline protectStack parseValues parseValuenumTypefinType unFinType predArgTypes forallFinType existsFinType $fShowSatNum$fShowQueryTypeSmoke Z3NotFound OptionDescroptName optDefaultoptCheckoptHelpoptEffEnvVal EnvStringEnvProgEnvNumEnvBool REPLException FileNotFoundDirectoryNotFound NoPatErrorNoIncludeErrorModuleSystemError EvalPolyErrorTypeNotTestableREPLunREPLlNamelPathrunREPLraisecatchrethrowEvalError getPrompt setLoadedMod getLoadedMod setSearchPathprependSearchPathshouldContinuestop unlessBatchasBatch disableLet enableLet getLetEnabledupdateREPLTitlesetUpdateREPLTitle setPutStr getPutStrrPutStr rPutStrLnrPrintgetVars getExprNames getTypeNamesgetPropertyNamesuniqifysetUser tryGetUsergetUsergetUserShowProverStats userOptions getUserSatNum whenDebug smokeTest $fPPSmoke$fPPREPLException$fExceptionREPLException $fFreshMREPL$fMonadBaseControlIOREPL$fMonadBaseIOREPL $fMonadIOREPL $fMonadREPL$fApplicativeREPL $fFunctorREPL$fShowREPLException $fShowEnvVal $fShowSmoke $fEqSmokeQCModeQCRandom QCExhaustCommandExitCode CommandOk CommandError CommandBodyExprArg FileExprArgDeclsArg ExprTypeArg FilenameArg OptionArgShellArgNoArg CommandDescrcNamescBodycHelpCommand AmbiguousUnknown runCommandqcCmdsatCmdproveCmdonlineProveSatofflineProveSat moduleCmd loadPreludeloadCmd setOptionCmd handleCtrlC replParse replParseExprinteractiveConfig liftModuleCmdmoduleCmdResult replCheckExpr replEvalExprsanitize splitCommand findCommandfindCommandExact findNbCommand parseCommand$fOrdCommandDescr$fEqCommandDescr$fShowCommandDescr $fEqQCMode $fShowQCModecatchIObindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNamehashbranchdirty CryptolPanicpanicLocpanicMsgbaseGHC.BaseNothing nameVariant nameVariantswritePreludeContentswriteTcPreludeContentspreludeContentspreludeExtrasContentswritePreludeExtrasContentscryptolTcContentsmarkdownlatexBlockCodeCommentpreProc toCryptolmkTokenOpOtherVirtualExplicit splitQual dropWhite byteForCharPlusMinusMulExpEqualLEQGEQ ComplementHash AlexInputInpalexPosalexInputPrevCharinputLexSNormal InCommentInStringInCharAction startComment endComment addToCommentstartEndComment startString endString addToString startCharendChar addToChar mkQualIdentmkQualOpemitemitSnumToken fromDigit alexGetByte isExplicit startsLayoutlayoutvirt $fPPTokenAlexAcc AlexAccNone AlexAccSkip AlexLastAccAlexNone AlexLastSkip AlexReturnAlexEOF AlexErrorAlexSkip AlexTokenAlexAddrAlexA# alex_tab_size alex_base alex_table alex_check alex_deflt alex_accept alex_actions stateToIntcommentstring alex_action_0 alex_action_1 alex_action_2 alex_action_3 alex_action_4 alex_action_5 alex_action_6 alex_action_7 alex_action_8 alex_action_9alex_action_10alex_action_11alex_action_12alex_action_13alex_action_14alex_action_15alex_action_16alex_action_17alex_action_18alex_action_19alex_action_20alex_action_21alex_action_22alex_action_23alex_action_24alex_action_25alex_action_26alex_action_27alex_action_28alex_action_29alex_action_30alex_action_31alex_action_32alex_action_33alex_action_34alex_action_35alex_action_36alex_action_37alex_action_38alex_action_39alex_action_40alex_action_41alex_action_42alex_action_43alex_action_44alex_action_45alex_action_46alex_action_47alex_action_48alex_action_49alex_action_50alex_action_51alex_action_52alex_action_53alex_action_54alex_action_55alex_action_56alex_action_57alex_action_58alex_action_59alex_action_60alex_action_61alex_action_62alex_action_63alex_action_64alex_action_65alex_action_66alex_action_67alex_action_68alex_action_69alex_action_70alex_action_71alex_action_72alex_action_73alex_action_74alex_action_75alex_action_76alex_action_77alexIndexInt16OffAddralexIndexInt32OffAddr quickIndexalexScan alexScanUser alex_scan_tknppLppNamedppFixityppPragmappNumLitwrapisEAppasEApps annotTopDsannotDsannotDannotB checkSigstoSigtoPragmatoFixitytoDocsnameserrorsNoPatMMunMAnnotMap simpleBindsel splitSimplePnoPatEnoPatFunnoPatArmnoPatMnoMatchBnoMatchDnoPatDs noPatTopDs noPatProg noPatModule checkFixs checkDocsgetRange runNoPatM anonRecord mkPrimDeclmkDocSParseMPunP parseStringparselexerP happyError errorMessage customError mkModNamemkSchemagetNamegetNumgetStrnumLitintValmkFixity mkTupleSel fromStrLitvalidDemotedTypemkEAppunOpbinOpeFromTo exprToNumT exportDecl exportNewtype changeExport mkTypeInstmkTParammkTySynpolyTermmkPoly mkPropertymkIfmkProp arithIdentfinIdentcmpIdent$fApplicativeParseM$fFunctorParseM $fMonadParseM$fPPParseError HappyAddrHappyA#HappyStk Happy_IntList HappyConsHappyAny HappyAbsSyn happyIn15 happyOut15 happyIn16 happyOut16 happyIn17 happyOut17 happyIn18 happyOut18 happyIn19 happyOut19 happyIn20 happyOut20 happyIn21 happyOut21 happyIn22 happyOut22 happyIn23 happyOut23 happyIn24 happyOut24 happyIn25 happyOut25 happyIn26 happyOut26 happyIn27 happyOut27 happyIn28 happyOut28 happyIn29 happyOut29 happyIn30 happyOut30 happyIn31 happyOut31 happyIn32 happyOut32 happyIn33 happyOut33 happyIn34 happyOut34 happyIn35 happyOut35 happyIn36 happyOut36 happyIn37 happyOut37 happyIn38 happyOut38 happyIn39 happyOut39 happyIn40 happyOut40 happyIn41 happyOut41 happyIn42 happyOut42 happyIn43 happyOut43 happyIn44 happyOut44 happyIn45 happyOut45 happyIn46 happyOut46 happyIn47 happyOut47 happyIn48 happyOut48 happyIn49 happyOut49 happyIn50 happyOut50 happyIn51 happyOut51 happyIn52 happyOut52 happyIn53 happyOut53 happyIn54 happyOut54 happyIn55 happyOut55 happyIn56 happyOut56 happyIn57 happyOut57 happyIn58 happyOut58 happyIn59 happyOut59 happyIn60 happyOut60 happyIn61 happyOut61 happyIn62 happyOut62 happyIn63 happyOut63 happyIn64 happyOut64 happyIn65 happyOut65 happyIn66 happyOut66 happyIn67 happyOut67 happyIn68 happyOut68 happyIn69 happyOut69 happyIn70 happyOut70 happyIn71 happyOut71 happyIn72 happyOut72 happyIn73 happyOut73 happyIn74 happyOut74 happyIn75 happyOut75 happyIn76 happyOut76 happyIn77 happyOut77 happyIn78 happyOut78 happyIn79 happyOut79 happyIn80 happyOut80 happyIn81 happyOut81 happyIn82 happyOut82 happyIn83 happyOut83 happyIn84 happyOut84 happyIn85 happyOut85 happyIn86 happyOut86 happyIn87 happyOut87 happyIn88 happyOut88 happyIn89 happyOut89 happyIn90 happyOut90 happyIn91 happyOut91 happyIn92 happyOut92 happyIn93 happyOut93 happyIn94 happyOut94 happyIn95 happyOut95 happyIn96 happyOut96 happyIn97 happyOut97 happyIn98 happyOut98 happyInTok happyOutTokhappyActOffsetshappyGotoOffsetshappyDefActions happyCheck happyTablehappyReduceArr happy_n_termshappy_n_nontermshappyReduce_12happyReduction_12happyReduce_13happyReduction_13happyReduce_14happyReduction_14happyReduce_15happyReduction_15happyReduce_16happyReduction_16happyReduce_17happyReduction_17happyReduce_18happyReduction_18happyReduce_19happyReduction_19happyReduce_20happyReduction_20happyReduce_21happyReduction_21happyReduce_22happyReduction_22happyReduce_23happyReduction_23happyReduce_24happyReduction_24happyReduce_25happyReduction_25happyReduce_26happyReduction_26happyReduce_27happyReduction_27happyReduce_28happyReduction_28happyReduce_29happyReduction_29happyReduce_30happyReduction_30happyReduce_31happyReduction_31happyReduce_32happyReduction_32happyReduce_33happyReduction_33happyReduce_34happyReduction_34happyReduce_35happyReduction_35happyReduce_36happyReduction_36happyReduce_37happyReduction_37happyReduce_38happyReduction_38happyReduce_39happyReduction_39happyReduce_40happyReduction_40happyReduce_41happyReduction_41happyReduce_42happyReduction_42happyReduce_43happyReduction_43happyReduce_44happyReduction_44happyReduce_45happyReduction_45happyReduce_46happyReduction_46happyReduce_47happyReduction_47happyReduce_48happyReduction_48happyReduce_49happyReduction_49happyReduce_50happyReduction_50happyReduce_51happyReduction_51happyReduce_52happyReduction_52happyReduce_53happyReduction_53happyReduce_54happyReduction_54happyReduce_55happyReduction_55happyReduce_56happyReduction_56happyReduce_57happyReduction_57happyReduce_58happyReduction_58happyReduce_59happyReduction_59happyReduce_60happyReduction_60happyReduce_61happyReduction_61happyReduce_62happyReduction_62happyReduce_63happyReduction_63happyReduce_64happyReduction_64happyReduce_65happyReduction_65happyReduce_66happyReduction_66happyReduce_67happyReduction_67happyReduce_68happyReduction_68happyReduce_69happyReduction_69happyReduce_70happyReduction_70happyReduce_71happyReduction_71happyReduce_72happyReduction_72happyReduce_73happyReduction_73happyReduce_74happyReduction_74happyReduce_75happyReduction_75happyReduce_76happyReduction_76happyReduce_77happyReduction_77happyReduce_78happyReduction_78happyReduce_79happyReduction_79happyReduce_80happyReduction_80happyReduce_81happyReduction_81happyReduce_82happyReduction_82happyReduce_83happyReduction_83happyReduce_84happyReduction_84happyReduce_85happyReduction_85happyReduce_86happyReduction_86happyReduce_87happyReduction_87happyReduce_88happyReduction_88happyReduce_89happyReduction_89happyReduce_90happyReduction_90happyReduce_91happyReduction_91happyReduce_92happyReduction_92happyReduce_93happyReduction_93happyReduce_94happyReduction_94happyReduce_95happyReduction_95happyReduce_96happyReduction_96happyReduce_97happyReduction_97happyReduce_98happyReduction_98happyReduce_99happyReduction_99happyReduce_100happyReduction_100happyReduce_101happyReduction_101happyReduce_102happyReduction_102happyReduce_103happyReduction_103happyReduce_104happyReduction_104happyReduce_105happyReduction_105happyReduce_106happyReduction_106happyReduce_107happyReduction_107happyReduce_108happyReduction_108happyReduce_109happyReduction_109happyReduce_110happyReduction_110happyReduce_111happyReduction_111happyReduce_112happyReduction_112happyReduce_113happyReduction_113happyReduce_114happyReduction_114happyReduce_115happyReduction_115happyReduce_116happyReduction_116happyReduce_117happyReduction_117happyReduce_118happyReduction_118happyReduce_119happyReduction_119happyReduce_120happyReduction_120happyReduce_121happyReduction_121happyReduce_122happyReduction_122happyReduce_123happyReduction_123happyReduce_124happyReduction_124happyReduce_125happyReduction_125happyReduce_126happyReduction_126happyReduce_127happyReduction_127happyReduce_128happyReduction_128happyReduce_129happyReduction_129happyReduce_130happyReduction_130happyReduce_131happyReduction_131happyReduce_132happyReduction_132happyReduce_133happyReduction_133happyReduce_134happyReduction_134happyReduce_135happyReduction_135happyReduce_136happyReduction_136happyReduce_137happyReduction_137happyReduce_138happyReduction_138happyReduce_139happyReduction_139happyReduce_140happyReduction_140happyReduce_141happyReduction_141happyReduce_142happyReduction_142happyReduce_143happyReduction_143happyReduce_144happyReduction_144happyReduce_145happyReduction_145happyReduce_146happyReduction_146happyReduce_147happyReduction_147happyReduce_148happyReduction_148happyReduce_149happyReduction_149happyReduce_150happyReduction_150happyReduce_151happyReduction_151happyReduce_152happyReduction_152happyReduce_153happyReduction_153happyReduce_154happyReduction_154happyReduce_155happyReduction_155happyReduce_156happyReduction_156happyReduce_157happyReduction_157happyReduce_158happyReduction_158happyReduce_159happyReduction_159happyReduce_160happyReduction_160happyReduce_161happyReduction_161happyReduce_162happyReduction_162happyReduce_163happyReduction_163happyReduce_164happyReduction_164happyReduce_165happyReduction_165happyReduce_166happyReduction_166happyReduce_167happyReduction_167happyReduce_168happyReduction_168happyReduce_169happyReduction_169happyReduce_170happyReduction_170happyReduce_171happyReduction_171happyReduce_172happyReduction_172happyReduce_173happyReduction_173happyReduce_174happyReduction_174happyReduce_175happyReduction_175happyReduce_176happyReduction_176happyReduce_177happyReduction_177happyReduce_178happyReduction_178happyReduce_179happyReduction_179happyReduce_180happyReduction_180happyReduce_181happyReduction_181happyReduce_182happyReduction_182happyReduce_183happyReduction_183happyReduce_184happyReduction_184happyReduce_185happyReduction_185happyReduce_186happyReduction_186happyReduce_187happyReduction_187happyReduce_188happyReduction_188happyReduce_189happyReduction_189happyReduce_190happyReduction_190happyReduce_191happyReduction_191happyReduce_192happyReduction_192happyReduce_193happyReduction_193happyReduce_194happyReduction_194happyReduce_195happyReduction_195happyReduce_196happyReduction_196happyReduce_197happyReduction_197happyReduce_198happyReduction_198happyReduce_199happyReduction_199happyReduce_200happyReduction_200happyReduce_201happyReduction_201happyReduce_202happyReduction_202happyReduce_203happyReduction_203happyReduce_204happyReduction_204happyReduce_205happyReduction_205happyReduce_206happyReduction_206happyReduce_207happyReduction_207happyReduce_208happyReduction_208happyReduce_209happyReduction_209happyReduce_210happyReduction_210happyReduce_211happyReduction_211happyReduce_212happyReduction_212happyReduce_213happyReduction_213happyReduce_214happyReduction_214happyReduce_215happyReduction_215happyReduce_216happyReduction_216happyReduce_217happyReduction_217happyReduce_218happyReduction_218happyReduce_219happyReduction_219happyReduce_220happyReduction_220happyReduce_221happyReduction_221happyReduce_222happyReduction_222happyReduce_223happyReduction_223happyReduce_224happyReduction_224happyReduce_225happyReduction_225happyReduce_226happyReduction_226happyReduce_227happyReduction_227happyReduce_228happyReduction_228happyReduce_229happyReduction_229happyReduce_230happyReduction_230happyReduce_231happyReduction_231happyReduce_232happyReduction_232happyReduce_233happyReduction_233happyReduce_234happyReduction_234happyReduce_235happyReduction_235happyReduce_236happyReduction_236happyReduce_237happyReduction_237happyReduce_238happyReduction_238happyReduce_239happyReduction_239happyReduce_240happyReduction_240happyReduce_241happyReduction_241happyReduce_242happyReduction_242happyReduce_243happyReduction_243happyReduce_244happyReduction_244happyReduce_245happyReduction_245happyReduce_246happyReduction_246happyReduce_247happyReduction_247happyReduce_248happyReduction_248happyReduce_249happyReduction_249happyReduce_250happyReduction_250happyReduce_251happyReduction_251 happyNewToken happyError_ happyThen happyReturn happyThen1 happyReturn1 happyError'vmoduleprogram programLayoutexprdecldecls declsLayoutletDeclreplschemamodNamehelpNamehappySeqaddImplicitIncludes happyParse happyAccept happyDoActionindexShortOffAddr happyShifthappySpecReduce_0happySpecReduce_1happySpecReduce_2happySpecReduce_3 happyReducehappyMonadReducehappyMonad2Reduce happyDrop happyDropStk happyGoto happyFail notHappyAtAll happyTcHack happyDoSeq happyDontSeqenvSeen envIncPath getIncPath withIncPathNoIncM fromIncPath includeFailedpushPath failsWith collectErrorsData.TraversablemapMnoIncludeModulenoIncludeProgram noIncTopDeclresolveInclude readIncludeEnv runNoIncM tryNoIncMnUniquenInfonIdentnFixitynLocunSupplyGHC.Errerror crySimpStepcryRearrangeAndcryRearrangeOr cryIsDefn cryRearrangecryAndcryOr cryKnownFinghc-prim GHC.TypesTrueFalsecryNotcryIsEqcryIsGtcryNatGtcryGtNatcryNoInfcryNatOp PropOrderingcmpAndcmpOrcryIsNatUpdatedJust mApSubstNL isNonLinOpnextName nonLinExprsnlKnownnlTodoNonLinM SubstOneRes trie_empty trie_insert trie_delete trie_lookuprunNL mApSubstOneNL nlImplied nonLinPropM nonLinExprMnameExpr finishTodos desugarExprtoSubst checkUnsatgetCounterExample cryMustEqualK cryMustEqualVcryCheckLinRellinRel propToSmtLib exprToSmtLibupdSubinLocalRewMapRewMap'RMnewTopOrLocalNamerewErewMrewDrewDef rewDeclGroup splitTParams splitTAppnotFun solveArithSeqar0ar1ar2ar3tftctp tryAddConstpBin tryGeqKThan tryGeqThanK tryGeqThanSub tryGeqThanVar geqByInterval tryMinIsGeqtryEqMintryEqVartryEqK tryEqMulConst tryEqAddInfdefaultFreeVarsuMap suDefaulting checkTypeIsexprType exprSchema convertible checkDeclTcMwoProofObligationsroTVarsroAsmpsroVarsSametMonoisMonocheckDeclGroup checkMatchcheckArmrunTcM reportErrorwithTVarwithAsmpwithVarsproofObligation scopeNames scopeNonLinSscopeIntervals scopeAssertedVarInfosolverdeclaredSimpPropeliminateSimpleGEQscopeAssertSimpPropviEmptyviElemviInsertviAssertSimpPropviPushviPopviUnmarkedNames getNLSubst declareVarassertassertSimpPropprove getImpSubstScopecurScope otherScopesHasPropgetProp unSimpPropsimpProp scopeEmpty scopeElem scopeInsertscopeAssertNew scopeAssertviAssertsolPushsolPop typeSelectIntinstantiateWithNamesinstantiateWithPosdoInst solveSelector recordType tupleTypelistTypeimproveSelector unsolvableMkassume isNumeric cryInfNattoSMT simpHasGoalsimportSplitImps tryGetModel quickSolverIO quickSolverproveImplicationIO cleanupError simpGoals'assumptionIntervalssolveConstraints solveNumericscomputeImprovementsimproveByDefaultingWithPuretySynappTy doCheckType checkTyThing checkProp checkKindifaceDeclsPrimMapCheckAll CheckOverlap CheckNonegetNS shadowNames'checkEnvcontainsOverlap typeExists mkFakeName renameSchema isReserved lookupFixityTOpisDangerousFixity renameMatch renamePatsEnvCheck unRenameM rwWarningsrwErrorsrwSupplyroLocroModroNamesroDisprecordrecordWcurLoclocatedwithLoc shadowNamesNS rnLocated translatePropisReservedTyConresolveTypeFixity infixPropsmkTInfixmkEInfixrenameOp renameArm patternEnvrnNamedUnforced BlackHoleForcedIO ThunkStateunDelayevalBindListEnvleVarsleStatic evalNewtypefillHole isValueTypeetaWordetaDelayevalDeclevalSel evalListEnvevalComp branchEnvs evalMatchleTypes evalNewtypes evalDeclGroupdeclHole toListEnv bindVarList fromVListvFinPoly bitsToInteger vWordValue integerToBits vWordErrorsplitV copyBySchema copyByTValue copyStreamcopyList condValuecondBit evalBranchevalDeclRecursivevWord logicNullarydivWrapmodWraplexListshiftVshiftLVshiftRVrotateVrotateLVrotateRVupdateAtUserEnv defaultRWmkPrompt mkUserEnv checkBase SmokeTest OptionMap eLoadedMod eContinueeIsBatch eModuleEnveUserEnvePutStr eLetEnabled eUpdateTitlegetRWmodifyRW modifyRW_ splitOptArgs mkOptionMap simpleOptcheckInfLength checkProverproverListString checkSatNumz3existscommands nbCommands nbCommandList cmdProveSatmkSolverResultreplCheckDeclsbindItVariablebindItVariables sanitizeEnduncons CommandMap commandListgenHelp getPPValOptsevalCmdshowProverStatsrIdent specializeCmd refEvalCmd typeOfCmd readFileCmd writeFileCmd reloadCmdeditCmdquitCmd browseCmd browseTSynsbrowseNewtypes browseVarshelpCmd runShellCmdcdCmd isNamePrefixreplParseInput replSpecExpritIdent replWriteFile replReadFile replEvalDeclreplEdittrim