! 3M]       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                     ! " # $ % & ' (!)!*!+!,!-!.!/!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/J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r1s1t1u1v1w1x1y1z1{1|1}1~1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 1 1 1 1 1111111111111111111 2!3"3#3$3%3&3'3(3)3*3+3,3-3.3/303132333435363738393:3;3<3=3>3?3@3A3B3C3D3E4F4G4H4I4J4K4L4M4N4O4P4Q4R4S4T4U4V4W4X4Y4Z4[5\5]5^5_6`6a6b6c6d7e7f7g7h7i7j7k7l8m8n8o8p8q8r8s8t8u9v9w9x9y9z:{:|;};~;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<========================================================>>>>>>>>>>>> > > > > > > > > ? @ @ @ @ @ @ A A A A A A A A A A A A A A A A A A !A "A #A $A %A &A 'A (A )A *A +A ,A -A .A /A 0A 1A 2A 3A 4A 5A 6A 7A 8A 9A :A ;A <A =A >A ?A @A AA BA CA DA EA FA GA HA IA JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB ZC [C \C ]C ^C _C `C aC bC cC dC eC fC gC hC iC jC kC lC mC nC oC pC qC rC sC tC uC vC wC xC yC zC {C |C }C ~C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D E E E E E E E E E E E E E E E E E E E E E E E E E E E !E "E #F $F %F &F 'F (F )F *F +F ,F -F .F /F 0F 1F 2F 3F 4F 5F 6F 7F 8F 9F :F ;F <G =G >G ?G @G AG BG CG DG EG FG GG HG IG JG KG LG MG NG OG PG QG RG SG TG UG VG WG XG YG ZG [G \G ]G ^G _G `G aG bG cG dG eG fG gG hG iG jG kG lG mG nG oG pG qG rG sG tG uG vG wG xG yG zG {G |G }G ~G G G G G G G G G H H H H H H H H H H H H H H H H H H H H H I I I I I I I I I I I I 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 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 0K 1K 2K 3K 4K 5K 6K 7K 8K 9K :K ;K <K =K >K ?K @K AK BK CK DK EL FL GL HL IL JL KL LL ML NL OL PL QL RL SL TL UL VL WL XL YL ZL [L \L ]L ^L _L `L aL bL cL dL eL fL gL hL iL jL kL lL mL nL oL pL qL rL sL tL uL vL wL xL yL zL {L |L }L ~L L L L L L L L L L L M N O 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 R R R R R R R R R R R R R R R R R R R R R R R R S S S S S S S S T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T !T "T #T $T %T &T 'T (T )T *T +T ,T -T .T /T 0U 1U 2U 3U 4U 5 6 7 8 9 : ; < = > ? @ A B C D E FV GV HV IV JV KV LV MV NV OV PV QV RV SV TW UW VW WW XW YW ZW [W \W ]W ^W _W `W aW bW cW dW eW fW gW hW iW jW kW lW mW nW oW pW qW rW sW tW uW vW wW xW yW zW {W |W }W ~W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X Y Y Y Y Y Y Y Y Y Y Y Y Y Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z 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] {] |] }] ~] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _d(c) 2014-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafecryptolvThis 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.None &'.>SUVXkͩ cryptol2This exceptoin is throws if the types don't match. cryptolbThis exception is thrown if the operations try to create a floating point value we do not supportcryptol Symbolic floating point numbers. cryptolThrow   exception cryptolConstruct the   with the given parameters.cryptol#A fresh variable of the given type.cryptol Not a numbercryptolPositive infinitycryptol;A floating point number corresponding to the given rations.cryptol?Make a floating point number with the given bit representation."cryptol4This is undefined on "special" values (NaN,infinity)&cryptol&Returns a predicate and two integers, x and y#. If the the predicate holds, then x / y is a rational representing the floating point number. Assumes the FP number is not one of the special ones that has no real representation.  cryptolLabel cryptolExponent width cryptolPrecision width cryptolExponent width cryptolPrecision width cryptolExponent width cryptolPrecision width cryptolExponent width cryptolPrecision width cryptolExponent width cryptolPrecision width cryptolExponent width cryptolPrecision width &  !"#$%&'(& !"#%&$'( (c) 2019 Galois, Inc.BSD3cryptol@galois.com provisionalportableNoneҍ.cryptol'Compute a fingerprint for a bytestring./cryptolKAttempt to compute the fingerprint of the file at the given path. Returns   in the case of an error.-./-./`(c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe79Q;cryptol Information about associativity.?cryptolLet op1 have fixity f1 and op2 have fixity  f2. Then compareFixity f1 f2/ determines how to parse the infix expression x op1 y op2 z@.FCLeft: (x op1 y) op2 zFCRight: x op1 (y op2 z)FCError : no parse@cryptol&The fixity used when none is provided.3456789:;<=>?@;<=>789:@3456?(c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe70Kcryptol2A way to identify primitives: we used to use just M, but this isn't good anymore as now we have primitives in multiple modules. This is used as a key when we need to lookup details about a specific primitive. Also, this is intended to mostly be used internally, so we don't store the fixity flag of the M McryptolIdentifiers, 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.NcryptolModule names are just text.ScryptolConvert a parameterized module's name to the name of the module containing the same definitions but with explicit parameters on each definition.ecryptol9A shortcut to make (non-infix) primitives in the prelude.KLMNOPQRSTUVWXYZ[\]^_`abcdefgNOPQUVWXYZ[RSTM\]^_`abcdKLefgSafe xcryptol:A logger provides simple abstraction for sending messages.ycryptol!Send the given string to the log.zcryptol0Send the given string with a newline at the end.{cryptolSend the given value using its  & instance. Adds a newline at the end.|cryptol#A logger that ignores all messages.}cryptolLog to the given handle.~cryptolLog to stdout.cryptolLog to stderr.cryptol#Just use this function for logging. xyz{|}~ x~}|yz{(c) 2014-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe>cryptol:Apply a function to all elements of a container. Returns   if nothing changed, and Just container otherwise.cryptol5Apply functions to both elements of a pair. Returns   if neither changed, and  Just pair otherwise. (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe79 cryptol3Information about an infix expression of some sort.cryptoloperatorcryptol left argumentcryptolright argumentcryptoloperator fixitycryptol&Fixity information for infix operatorscryptolPrint a name in prefix: f a b or (+) a b)cryptol#Print a name as an infix operator: a + bcryptol*How to display names, inspired by the GHC  Outputable module. Getting a value of   from the NameDisp function indicates that the display has no opinion on how this name should be displayed, and some other display should be tried out. cryptol%Never qualify names from this module.cryptolMCompose two naming environments, preferring names from the left environment.cryptol Get the format for a name. When  2 is returned, the name is not currently in scope.cryptol1Produce a document in the context of the current .cryptol5Fix the way that names are displayed inside of a doc.cryptol.Pretty print an infix expression of some sort.cryptol1Display a numeric value as an ordinal (e.g., 2nd)cryptol9The suffix to use when displaying a number as an oridinalcryptol1Non-infix leaves are printed with this precedencecryptol+pattern to check if sub-thing is also infixcryptol"Pretty print this infix expressionBB665 (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone ] (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe=>?cryptolzThis packages together a type with some names to be used to display the variables. It is used for pretty printing types. cryptol*Compute the n-th variant of a name (e.g., a5). cryptol Compute all variants of a name: a, a1, a2, a3, ...cryptol@Expand a list of base names into an infinite list of variations.J (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe79!cryptolSelectors 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.cryptolUZero-based tuple selection. Optionally specifies the shape of the tuple (one-based).cryptol@Record selection. Optionally specifies the shape of the record.cryptol=List selection. Optionally specifies the length of the list.cryptol3Display the thing selected by the selector, nicely.cryptol2The name of a selector (e.g., used in update code)cryptolJShow a list of selectors as they appear in a nested selector in an update. (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe"#79%cryptolAn empty range.[Caution: using this on the LHS of a use of rComb will cause the empty source to propagate.(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Trustworthy'X!"#!"#(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe79I}%cryptol(Natural numbers with an infinity element*cryptol&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+cryptol&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) ^ n.cryptolnSub x y = Just z iff z is the unique value such that Add y z = Just x. /cryptol 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 0I, 2. The well-formedness constraints can be expressed as a conjunction.1cryptolnCeilDiv msgLen blockSize computes the least n such that msgLen <= blockSize * n. It is undefined when  blockSize = 0\. It is also undefined when either input is infinite; perhaps this could be relaxed later.2cryptolnCeilMod msgLen blockSize computes the least k such that  blockSize divides  msgLen + k. It is undefined when  blockSize = 0\. It is also undefined when either input is infinite; perhaps this could be relaxed later.3cryptol Rounds up.  lg2 x = y, iff y" is the smallest number such that  x <= 2 ^ y4cryptolnWidth nL is number of bits needed to represent all numbers from 0 to n, inclusive. nWidth x = nLg2 (x + 1).5cryptol length [ x, y .. z ]6cryptolCompute 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.7cryptolCCompute the number of bits required to represent the given integer.8cryptolgCompute the exact root of a natural number. The second argument specifies which root we are computing.9cryptolCompute 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. %'&()*+,-./0123456789%'&()*+,-./0123456789(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeQ[?cryptolKMaps string names to values, allowing for partial key matches and querying.Bcryptol)Insert a value into the Trie. Will call #* if a value already exists with that key.Ccryptol)Return all matches with the given prefix.Dcryptol^Given a key, return either an exact match for that key, or all matches with the given prefix.Ecryptol%Return all of the values from a Trie.?@ABCDE?@ABCDE(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeS cryptolThe preprocessor for  cryptolThe preprocessor for  GHIJKLMMGHIJLK(c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe7Y&Ncryptol%Passes that can generate fresh names.Qcryptol#Names that originate in the parser.RcryptolUnqualified names like x, Foo, or +.ScryptolQualified names like Foo::bar or  module::!.Tcryptol Fresh names generated by a pass. NPOQTSRUVWXY QTSRNPOUVWXYa(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe79mygcryptolvalue, base, number of digitshcryptol value, base.icryptolcharacter literaljcryptol(qualified) identifierkcryptolstring literallcryptolkeywordmcryptoloperatorncryptolsymbolocryptolvirtual token (for layout)pcryptolwhite space tokenqcryptol error token cryptol>The named operators are a special case for parsing types, and  8 is used for all other cases that lexed as an operator.cryptol.Virtual tokens, inserted by layout processing. cryptolVirtual layout block cryptol7An explicit layout block, expecting this ending token.cryptolFile that we are working oncryptolSettings for layout processingcryptolPreprocessor settingscryptolImplicit includescryptol^When we do layout processing should we add a vCurly (i.e., are we parsing a list of things). cryptol=Split out the prefix and name part of an identifier/operator. cryptol'Drop white-space tokens from the input. cryptoleCollapse 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 cryptolbase fonlhikqrjpmgsyvutxwz~}|{          !" (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable TrustworthyFvcryptolReturns 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.cryptoloReturns the tokens and the last position of the input that we processed. The tokens include whte space tokens.ifgmpjrqkihlnoswxtuvyz{|}~ifgmpjrqkihlnoswxtuvyz{|}~(c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Trustworthy "#79=?@AMcryptolEA mapping from an identifier defined in some module to its real name.cryptol)A monad for easing the use of the supply.#cryptolINVARIANT: this field uniquely identifies a name for one session with the Cryptol library. Names are unique to their binding site.$cryptol*Information about the origin of this name.%cryptolThe name of the identifier&cryptol?The associativity and precedence level of infix operators.  * indicates an ordinary prefix operator.'cryptolWhere this name was definedcryptol/Information about the binding site of the name.cryptol2This name refers to a declaration from this modulecryptol+This name is a parameter (function or type)cryptolCompare two names lexically.cryptol5Compare two names by the way they would be displayed.(cryptolFigure 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.cryptol9Pretty-print a name with its source location information.cryptol)Retrieve the next unique from the supply.cryptolThis 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).cryptol"Make a new name for a declaration.cryptolMake a new parameter name.cryptolvIt's assumed that we're looking things up that we know already exist, so this will panic if it doesn't find the name.cryptolvIt's assumed that we're looking things up that we know already exist, so this will panic if it doesn't find the name.##Safe79>2cryptolZBuilt-in type functions. If you add additional user-visible constructors, please update primTys in Cryptol.Prims.Types.cryptol  : Num -> Num -> Numcryptol  : Num -> Num -> Numcryptol  : Num -> Num -> Numcryptol  : Num -> Num -> Numcryptol  : Num -> Num -> Numcryptol  : Num -> Num -> Numcryptol  : Num -> Numcryptol  : Num -> Num -> Numcryptol  : Num -> Num -> Numcryptol  : Num -> Num -> Numcryptol  : Num -> Num -> Numcryptol : Num -> Num -> Num -> Num Example: ,[ 1, 5 .. 9 ] :: [lengthFromThenTo 1 5 9][b]"cryptolO1-1 constants. If you add additional user-visible constructors, please update primTys.#cryptolNumbers$cryptolInf%cryptolBit&cryptolInteger'cryptolFloat(cryptol Z _)cryptol Rational*cryptol  Array _ _+cryptol [_] _,cryptol _ -> _-cryptol  (_, _, _).cryptolAn abstract type/cryptoluser-defined, T0cryptolSPredicate symbols. If you add additional user-visible constructors, please update primTys.1cryptol _ == _2cryptol _ /= _3cryptol _ >= _4cryptol fin _5cryptolHas sel type field does not appear in schemas6cryptol Zero _7cryptol Logic _8cryptol Ring _9cryptol  Integral _:cryptol Field _;cryptol Round _<cryptol Eq _=cryptol Cmp _>cryptol  SignedCmp _?cryptol  Literal _ _@cryptol FLiteral _ _ _AcryptolValidFloat _ _9 constraints on supported floating point representaitonsBcryptol/This is useful when simplifying things in placeCcryptolDittoDcryptolType constants.KcryptolKinds, classify types.PcryptolcThis is used for pretty prinitng. XXX: it would be nice to just rely in the info from the Prelude.B !"./-,+#*()&%$'0CB5@?>=<;:98764A321DHFGEIJKNMLOPQBPQKNMLOIJDHFGE0CB5@?>=<;:98764A321"./-,+#*()&%$' !O5Safe =?@ACHSVX cryptolQCheck that a value satisfies multiple patterns. For example, an "as" pattern is  (__ &&& p).cryptol%Match a value, and modify the result.cryptol*Match a value, and return the given resultcryptol View pattern.cryptolVariable pattern.cryptolConstant pattern.cryptolPredicate patterncryptolCheck for exact value.cryptol3Match a pattern, using the given default if valure.cryptol2Match an irrefutable pattern. Crashes on faliure.(c) 2020 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeSXڕcryptolAn "order insensitive" datastructure. The fields can be accessed either according to a "canonical" order, or based on a "display" order, which matches the order in which the fields were originally specified.cryptol*Return the fields in this record as a set.cryptol2The order in which the fields originally appeared.cryptolLRetrieve the elements of the record in canonical order of the field namescryptol6Return a list of field/value pairs in canonical order.cryptol4Return a list of field/value pairs in display order.cryptolGenerate a record from a list of field/value pairs. Precondition: each field identifier appears at most once in the given list.cryptolGenerate a record from a list of field/value pairs. If any field name is repeated, the first repeated name/value pair is returned. Otherwise the constructed record is returned.cryptolGenerate a record from a list of field/value pairs, and also provide the "display" order for the fields directly. Precondition: each field identifier appears at most once in each list, and a field name appears in the display order iff it appears in the field list.cryptolLookup the value of a fieldcryptolyUpdate the value of a field by applying the given function. If the field is not present in the record, return Nothing.cryptol_Traverse the elements of the given record map in canonical order, applying the given action.cryptol5Apply the given function to each element of a record.cryptolmThe function recordMapAccum threads an accumulating argument through the map in canonical order of fields.cryptolZip together the fields of two records using the provided action. If some field is present in one record, but not the other, an  Either a ap will be returned, indicating which record is missing the field, and returning the name of the missing field.The  displayOrderW of the resulting record will be taken from the first argument (rather arbitrarily).cryptolPure version of Safe"#79=>?n&cryptol;The type is "simple" (i.e., it contains no type functions).cryptol#Information about an abstract type.cryptol Named recordscryptol Type synonym.cryptolNamecryptol ParameterscryptolEnsure body is OKcryptol Definitioncryptol Documentationcryptol#The type is supposed to be of kind N.cryptolName of module parametercryptolA variable in a signaturecryptolSource code that gave risecryptol DescriptioncryptolType variables.cryptolzUnique, kind, ids of bound type variables that are in scope The last field gives us some infor for nicer warnings/errors.cryptolLThe internal representation of types. These are assumed to be kind correct.cryptolType constant with argscryptolType variable (free or bound)cryptolThis 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 t# that was written as T ts by the user. cryptol Record typecryptolType parameters.cryptolParameter identifiercryptolKind of parametercryptol#What sort of type parameter is thiscryptol"A description for better messages.cryptol The types of polymorphic values.cryptol7Get the names of something that is related to the tvar.cryptolCompute the set of all PropCs that are implied by the given prop via superclass constraints.cryptolESplit up repeated occurances of the given binary type-level function.>cryptolMake a function type.?cryptol"Eliminate outermost type synonyms.@cryptoloMake an error value of the given type to replace the given malformed type (the argument to the error function)McryptolEquality for numeric types.Ycryptol+Make a greater-than-or-equal-to constraint.ZcryptolA Has1 constraint, used for tuple and record selection.rcryptolmThe precedence levels used by this pretty-printing instance correspond with parser non-terminals as follows:0-1: type2:  infix_type3: app_type4: atypetcryptol<Syntactic equality, ignoring type synonyms and record order. !"'$%&)(*#+,-/.0123A46789:;<=>?@5BCDEGFHIJKOLMNPQ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd>5M4Y4Safe]4!Safecryptol:Common checks: check for error, or simple full evaluation.(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe"#45679CkcryptolA  is a # that represents a type constraint.cryptol  [8] -> [8]cryptol [8] acryptol Bitcryptol 10cryptol acryptolA type variable or synonymcryptol `{ x = [8], y = Integer }cryptol { x : [8], y : [32] }cryptol  ([8], [32])cryptol_, just some type.cryptolLocation informationcryptol  (ty)cryptol  ty + tycryptol  xcryptol  _cryptol  (x,y,z)cryptol  { x = (a,b,c), y = z }cryptol  [ x, y, z ]cryptol  x : [8]cryptol  (x # y)cryptolLocation informationcryptolp <- e cryptol#Are we setting or updating a field. cryptolnon-empty list  x.y = ecryptol  xcryptol  0x10cryptol  -1cryptol  ~1cryptol  generate fcryptol  (1,2,3)cryptol  { x = 1, y = 2 }cryptol  e.lcryptol  { r | x = e }cryptol  [1,2,3]cryptol  [1, 5 .. 117 : t]cryptol  [1, 3 ...]cryptol  [ 1 | x <- xs ]cryptol  f xcryptol  f `{x = 8}, f`{8}cryptol  if ok then e1 else e2cryptol  1 + x where { x = 2 }cryptol  1 : [8] cryptol `(x + 1), x is a type!cryptol  \x y -> x"cryptolposition annotation#cryptol splitAt x  (Introduced by NoPat)$cryptol (e)  (Removed by Fixity)%cryptol a + b  (Removed by Fixity)&cryptol Literals.'cryptol0x10 (HexLit 2)(cryptol a)cryptol 1.2e3*cryptol "hello"+cryptol&Information about fractional literals.0cryptol;Infromation about the representation of a numeric constant.1cryptoln-digit binary literal2cryptoln-digit octal literal3cryptoloverloaded decimal literal4cryptoln-digit hex literal5cryptolpolynomial literal6cryptolA top-level module declaration.;cryptol%Export information for a declaration.>cryptol:Input at the REPL, which can either be an expression or a let statement.Acryptol0A declaration for a type with no implementation.Ecryptol:parameters are in the order used by the type constructor.Icryptol Type nameJcryptol Type paramsKcryptol ConstructorScryptolBindings. 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.Ucryptol Defined thingVcryptol ParametersWcryptol DefinitionXcryptolOptional type sigYcryptolInfix operator?ZcryptolOptional fixity info[cryptolOptional pragmas\cryptolIs this a monomorphic binding]cryptolOptional doc stringbcryptol&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 T% constructors should not be present.ecryptolAn import declaration.jcryptolA value parameterlcryptolname of value parametermcryptolschema for parameterncryptoloptional documentationocryptolinfo for infix usepcryptolA type parameterrcryptolname of type parameterscryptolkind of parametertcryptoloptional documentationucryptolinfo for infix usevcryptolnumber of the parametercryptol@newtype T as = tcryptol  include Filecryptol parameter type T : #cryptol !parameter type constraint (fin T)cryptol parameter someVal : [256]cryptolA parsed module.cryptolName of the modulecryptol8Functor to instantiate (if this is a functor instnaces)cryptolImports for the modulecryptolDeclartions for the module)cryptol"A record with located ident fieldscryptol#A string with location information.cryptol(An identifier with location information.cryptol!A name with location information.cryptolConversational3 printing of kinds (e.g., to use in error messages)3456789:;<=>?@MN_`abcNOPQRSTUVWX      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~M_`abcNQRSTWXUVNOP;<=>wxyz{|}~789:@3456?`a^_STUVWXYZ[\]OPQRLMN;<=6789:efghibcdGHIJKABCDEFpqrstuvjklmno>?@  !"#$%&'()*012345+,-./    (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeKwxxwb(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe79\ *cryptol=Keep track of the type parameters as they appear in the input+cryptolInput fields are reversed!,cryptolInput expression are reversed-cryptolWWARNING: This is a bit of a hack. It is used to represent anonymous type applications..cryptolGenerate 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./cryptolFix-up the documentation strings by removing the comment delimiters on each end, and stripping out common prefixes on all the remaining lines.0cryptolMake an ordinary module1cryptol'Make an unnamed module---gets the name Main.2cryptol/Make a module which defines a functor instance.D34*56y|z}{789:;<~=>?@ABCDEFGHIJKLM+,NOPQR-STUVWXYZ[\]^_`ab.c/de012fg(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeuqcryptolThe names defined by a newtype.cryptolIThe names defined and used by a group of mutually recursive declarations.cryptol4The names defined and used by a single declarations.cryptolThe 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.cryptol/The names defined and used by a single binding.cryptol The names used by an expression.cryptol)The names defined by a group of patterns.cryptolHThe names defined by a pattern. These will always be unqualified names.cryptol&The names defined and used by a match.cryptol<The names defined and used by an arm of alist comprehension.cryptol;Remove some defined variables from a set of free variables.cryptol;Remove some defined variables from a set of free variables.cryptol;Remove some defined variables from a set of free variables.cryptolNThe type names defined and used by a group of mutually recursive declarations.cryptol8The type names defined and used by a single declaration.cryptol(The type names used by a single binding.cryptol%The type names used by an expression.cryptol!The type names used by a pattern.cryptolThe type names used by a match.cryptol%The type names used by a type schema.cryptolThe type names used by a prop.cryptol8Compute the type synonyms/type variables used by a type.(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe"#79=?cryptol$Eliminate all patterns in a program.hcryptolGiven a pattern, transform it into a simple pattern and a set of bindings. Simple patterns may only contain variables and type annotations.icryptol/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.jcryptolHAdd annotations, keeping track of which annotations are not yet used up.kcryptolAdd annotations, keeping track of which annotations are not yet used up. The exception indicates which declarations are no longer needed.lcryptol.Add pragma/signature annotations to a binding.mcryptol1Add fixity annotations to a type synonym binding.ncryptol7Add fixity annotations to a constraint synonym binding.ocryptol&Annotate a primitive type declaration.pcryptol#Annotate a module's type parameter.qcryptolCheck for multiple signatures.rcryptol.Does this declaration provide some signatures?scryptol.Does this declaration provide some signatures?tcryptol1Does this declaration provide fixity information?ucryptol?Does this top-level declaration provide a documentation string?vcryptol5Pick a new name, to be used when desugaring patterns.wcryptolRecord an error.  Safe7xcryptol@Add a binding name to the export list, if it should be exported.cryptolEAdd a type synonym name to the export list, if it should be exported.cryptol&Check to see if a binding is exported.cryptol+Check to see if a type synonym is exported.   (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe"#79=>?|cryptolMutually recursive declarationscryptolNon-recursive declarationcryptolLType arguments are the length and element type of the sequence expressioncryptol"List value (with type of elements)cryptol Tuple valuecryptol Record valuecryptolElimination for tuplerecordlistcryptolChange the value of a field.cryptol If-then-elsecryptolZList comprehensions The types cache the length of the sequence and its element type.cryptolUse of a bound variablecryptolFunction ValuecryptolType applicationcryptolFunction applicationcryptolFunction valuecryptolProof 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 N.cryptolIf  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.cryptolA value parameter of a module.cryptolA type parameter of a module.cryptolThe number of the parameter in the module This is used when we move parameters from the module level to individual declarations (type synonyms in particular)cryptolA Cryptol module.cryptol7This is just the type-level type synonyms of a module.cryptolIs this a parameterized module?cryptol@Construct a primitive, given a map to the unique primitive name.cryptolMake an expression that is error% pre-applied to a type and a message.cryptolDeconstruct an expression, typically polymorphic, into the types and proofs to which it is applied. Since we don't store the proofs, we just return the number of proof applications. The first type is the one closest to the expr.[789: !"'$%&)(*#+,-/.0123A46789:;<=>?@5BCDEGFHIJKOLMNPQ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd;<=LMNbcdefghizefghibcd;<=LMN789:!(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe4=?@ACS()+*,-./1023456789:;<=>?()+*,-23456789;<:=>?./10"(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeÏFcryptol&All ways to split a type in the form: a + t1, where a is a variable.Gcryptol,Check if we can express a type in the form: a + t1.Hcryptol,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. Icryptol,Check if we can express a type in the form: k * t1, where kw is a constant > 1. This assumes that the type has been simplified already, so that constants are floated to the left. FGHIFGHI#(c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe Lcryptollower bound (inclusive)McryptolQupper bound (inclusive) If there is no upper bound, then all *natural* numbers.Rcryptol!Only meaningful for numeric typesVcryptol1What we learn about variables from a single prop.[cryptolFinite positive number.  [1 .. inf).\cryptolReturns x, when the intervals definitely overlap, and y otherwise.]cryptolIntersect two intervals, yielding a new one that describes the space where they overlap. If the two intervals are disjoint, the result will be  .^cryptol Any value_cryptolAny finite value`cryptolExactly this value#JKLMNQPORSTUVWXYZ[\]^_`abcdefghijkl#RSNQPOTUVJKLMWXYZ[\]^_`abcdefghijkl$Safe,qcryptolSolved, assuming the sub-goals.rcryptolWe could not solve the goal.scryptolThe goal can never be solved. psrqtuwvxyz{ tuwvpsrqxyz{%(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe9cryptolThis places constraints on the floating point numbers that we can work with. This is a bit of an odd check, as it is really a limitiation of the backend, and not the language itself.On the other hand, it helps us give sane results if one accidentally types a polymorphic float at the REPL. Hopefully, most users will stick to particular FP sizes, so this should be quite transparent.zcryptolCheck that the type parameters correspond to a float that we support, and if so make the precision settings for the BigFloat library.cryptol1Solve a Zero constraint by instance, if possible.cryptol2Solve a Logic constraint by instance, if possible.cryptol1Solve a Ring constraint by instance, if possible.{cryptolcSolve a Ring constraint for a sequence. The type passed here is the element type of the sequence.cryptol6Solve an Integral constraint by instance, if possible.cryptol2Solve a Field constraint by instance, if possible.cryptol2Solve a Round constraint by instance, if possible.cryptolSolve Eq constraints.cryptolSolve Cmp constraints.|cryptolhSolve a SignedCmp constraint for a sequence. The type passed here is the element type of the sequence.cryptolSolve SignedCmp constraints.cryptol'Solving fractional literal constraints.cryptolSolve Literal constraints.  &(c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe'Safe`cryptol Try to solve t1 = t2cryptol Try to solve t1 /= t2cryptol Try to solve t1 >= t2}cryptol%Try to solve something by evaluation.~cryptol Try to solve K >= tcryptol Try to solve t >= KcryptolHTry to prove GEQ by considering the known intervals for the given types.cryptol3Cancel finite positive variables from both sides. 2(fin a, a >= 1) => a * t1 == a * t2 ~~~> t1 == t2 2(fin a, a >= 1) => a * t1 >= a * t2 ~~~> t1 >= t2cryptol1K1 * t1 + K2 * t2 + ... = K3 * t3 + K4 * t4 + ...cryptol %(t1 + t2 = Inf, fin t1) ~~> t2 = Infcryptol?Check for addition of constants to both sides of a relation. ((K1 + K2) + t1) R (K1 + t2) ~~> (K2 + t1) R t2OThis relies on the fact that constants are floated left during simplification.cryptolCheck for situations where a unification variable is involved in a sum of terms not containing additional unification variables, and replace it with a solution and an inequality. )s1 = ?a + s2 ~~> (?a = s1 - s2, s1 >= s2)cryptolMatch a sum of the form (s1 + ... + ?a + ... sn) where s1 through sn# do not contain any free variables..Note: a successful match should only occur if  s1 ... sn is not empty.cryptolIIs this a sum of products, where the products have constant coefficients?( Trustworthy)(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe"#=>?h cryptol1Reasons to reject a single-variable substitution.cryptol- maps to a type containing the same variable.cryptolD maps to a type containing one or more out-of-scope bound variables.cryptol& maps to a type with a different kind.cryptolA 0 value represents a substitution that maps each  to a .(Invariant 1: If there is a mapping from TVFree _ _ tps _ to a type t, then tN must not mention (directly or indirectly) any type parameter that is not in tps. In particular, if t contains a variable TVFree _ _ tps2 _, then tps2 must be a subset of tpsk. This ensures that applying the substitution will not permit any type parameter to escape from its scope.ZInvariant 2: The substitution must be idempotent, in that applying a substitution to any  in the map should leave that  unchanged. In other words,  values in the range of a  should not mention any  in the domain of the e. In particular, this implies that a substitution must not contain any recursive variable mappings.9Invariant 3: The substitution must be kind correct: Each $ in the substitution must map to a  of the same kind.cryptoljA defaulting substitution maps all otherwise-unmapped free variables to a kind-appropriate default type (Bit for value types and 0 for numeric types).cryptolMakes 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.cryptolMakes 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.cryptolApply a substitution. Returns   if nothing changed.cryptol3Pick types for unconstrained unification variables.cryptol1Apply the substitution to the keys of a type map.cryptolZThis instance does not need to worry about bound variable capture, because we rely on the O datatype invariant to ensure that variable scopes will be properly preserved. cryptolreplaces free vars*(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe%4"cryptolXThe most general unifier is a substitution and a set of constraints on bound variables.+(c) 2014-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe%+cryptolGiven 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.cryptolGApply a substitution to a type *without* simplifying constraints like  Arith [n]a to Arith a. (This is in contrast to 4, which performs simplifications wherever possible.)cryptolBYields the return type of the selector on the given argument type.,Safe2McryptolImprovements from a bunch of propositions. Invariant: the substitions should be already applied to the new sub-goals, if any.cryptoluImprovements from a proposition. Invariant: the substitions should be already applied to the new sub-goals, if any.cryptol|Improvements from equality constraints. Invariant: the substitions should be already applied to the new sub-goals, if any.-(c) 2013-2017 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe"#79=>?3.(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe%79=>?RacryptolGInformation about how a constraint came to be, used in error reporting.cryptol%Computing shape of list comprehensioncryptolUse of a split patterncryptol+A type signature in a pattern or expressioncryptol Instantiation of this expressioncryptol#Just defaulting on the command linecryptolUse of a partial type function.cryptol/Constraints arising from type-checking patternscryptol#Instantiating a parametrized modulecryptolGDelayed implication constraints, arising from user-specified type sigs.cryptolKSignature that gave rise to this constraint Nothing means module top-levelcryptolA solution for a cryptol3Select a specific field from the input expsression.cryptol<Set a field of the first expression to the second expressioncryptol,Something that we need to find evidence for.cryptolWhat it is aboutcryptol$Part of source code that caused goalcryptolWhat needs to be provedcryptolThis abuses the type  a bit. The Q field contains only the numeric part of the Literal constraint. For example, (a, Goal { goal = t }) representats the goal for  Literal t acryptol,A bunch of goals, not including the ones in .cryptolEThe set of nonliteral goals, saturated by all superclass implicationscryptol An entry (a,t) corresponds to  Literal t a.cryptol*The types of variables in the environment.cryptol Known typecryptolPart of current SCC. The expression will replace the variable, after we are done with the SCC. In this way a variable that gets generalized is replaced with an appropriate instantiation of itself.  cryptolThe SMT solver to invoke cryptol*Additional arguments to pass to the solver cryptol$How verbose to be when type-checking cryptol/Look for the solver prelude in these locations.cryptolFor use in error messages:     :     /(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe"#=>?]6 4cryptol1An SMT solver packed with a logger for debugging.cryptolThe actual solvercryptol For debugging5cryptol3Execute a computation with a fresh solver instance.cryptol,Load the definitions used for type checking.7cryptol"Returns goals that were not proved8cryptol4Check if the given goals are known to be unsolvable.cryptol7Check if some numeric goals are known to be unsolvable.cryptol Split up the And in a goal;cryptol Assumes no AndcryptolSearch in this paths 3456789:; 45;63789:0Safe79=?rJcryptol?Various errors that might happen during type checking/inferenceKcryptol Just say thisLcryptolExpected kind, inferred kindMcryptolMNumber of extra parameters, kind of result (which should not be of the form _ -> _)Ncryptol.A type variable was applied to some arguments.Ocryptol$Type-synonym, number of extra paramsPcryptol/Who is missing params, number of missing paramsQcryptol+The type synonym declarations are recursiveRcryptolExpected type, inferred typeScryptol'Unification results in a recursive typeTcryptol1A constraint that we could not solve If we have  TCErrorMess2 than the goal is impossible for the given reasonUcryptol3A constraint (with context) that we could not solveVcryptolVType wild cards are not allowed in this context (e.g., definitions of type synonyms).WcryptolLUnification variable depends on quantified variables that are not in scope.XcryptolgQuantified type variables (of kind *) need to match the given type, so it does not work for all types.YcryptolFToo many positional type arguments, in an explicit type instantiation]cryptolCould not determine the value of a numeric type variable, but we know it must be at least as large as the given type (or unconstrained, if Nothing).ccryptol-Should the first error suppress the next one.J]\[ZYWVUTSRQPONMLKX^a`_bcbc^a`_J]\[ZYWVUTSRQPONMLKX1(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe"#79NircryptolFThis is what's returned when we lookup variables during kind checking.scryptolLocally bound variable.tcryptolAn outer binding.wcryptolkinds of (known) vars.ycryptol,Do we allow wild cards in the given context.~cryptollazy map, with tparams.cryptolare type-wild cards allowed?cryptol"Read-write component of the monad.cryptolCollected errorscryptolCollected warningscryptolAccumulated substitutioncryptol|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.cryptolFSelector constraints that have been solved (ref. iSolvedSelectorsLazy)cryptolOrdinary constraintscryptol*Tuple/record projection constraints. The [ is the "name" of the constraint, used so that we can name its solution properly. cryptol!Read-only component of the monad.cryptolSource code being analysedcryptol"Type of variable that are in scopecryptolType variable that are in scopecryptolType synonyms that are in scopecryptolNewtype 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).cryptolParameter typescryptol"Constraints on the type parameterscryptolParameter functionscryptolKNOTE: 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.cryptolWhen 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.cryptolThe results of type inference.cryptolWe found some errorscryptolType inference was successful.cryptol*This is used for generating various names.cryptol&Information needed for type inference.cryptolLocation of program sourcecryptolVariables that are in scopecryptolType synonyms that are in scopecryptolNewtypes in scopecryptolAbstract types in scopecryptolType parameterscryptolConstraints on parameterscryptolValue parameterscryptolPrivate state of type-checkercryptol=Should local bindings without signatures be monomorphized?cryptol!Options for the constraint solvercryptol&Where to look for Cryptol theory file.cryptolUThis is used when the type-checker needs to refer to a predefined identifier (e.g., number).cryptol$The supply for fresh name generationcryptolWThe initial seeds, used when checking a fresh program. XXX: why does this start at 10?cryptoleThe monadic computation is about the given range of source code. This is useful for error reporting.cryptol1This is the current range that we are working on.cryptolReport an error.cryptolIRetrieve the mapping between identifiers and declarations in the prelude.cryptoleRecord some constraints that need to be solved. The string explains where the constraints came from.cryptol^The constraints are removed, and returned to the caller. The substitution IS applied to them. cryptol'Add a bunch of goals that need solving.cryptolUCollect the goals emitted by the given sub-computation. Does not emit any new goals.cryptol;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.cryptol)Add a previously generate has constrainedcryptolGet the HasJ constraints. Each of this should either be solved, or added back using .cryptolSpecify the solution ( Expr -> Expr) for the given constraint ().cryptol=Generate a fresh variable name to be used in a local binding.cryptolGenerate a new name for a goal.cryptol"Generate a new free type variable.cryptolTGenerate a new free type variable that depends on these additional type parameters.cryptol"Generate a new free type variable.cryptolKGenerate an unknown type. The doc is a note about what is this type about.cryptol8Record that the two types should be syntactically equal.cryptolIApply the accumulated substitution to something with free type variables.cryptol5Get the substitution that we have accumulated so far.cryptolOAdd to the accumulated substitution, checking that the datatype invariant for  is maintained.cryptolTVariables that are either mentioned in the environment or in a selector constraint.cryptolLookup the type of a variable.cryptol Lookup a type variable. Return  _ if there is no such variable in scope, in which case we must be dealing with a type constant.cryptol(Lookup the definition of a type synonym.cryptol"Lookup the definition of a newtypecryptol#Lookup the kind of a parameter typecryptol+Lookup the schema for a parameter function.cryptolCheck 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.cryptol6Returns the type synonyms that are currently in scope.cryptol3Returns the newtype declarations that are in scope.cryptol9Returns the abstract type declarations that are in scope.cryptol,Returns the parameter functions declarationscryptol*Returns the abstract function declarationscryptol'Constraints on the module's parameters.cryptol6Get the set of bound type variables that are in scope.cryptol9Return the keys of the bound variables that are in scope.cryptolRetrieve the value of the  `mono-binds` option.cryptolWe 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. cryptolHThe sub-computation is performed with the given type parameter in scope.cryptolFThe sub-computation is performed with the given type-synonym in scope.cryptolBThe sub-computation is performed with the given variable in scope.cryptolKThe sub-computation is performed with the given abstract function in scope.cryptol)Add some assumptions for an entire modulecryptolCThe sub-computation is performed with the given variables in scope.cryptolCThe sub-computation is performed with the given variables in scope.cryptolVThe sub-computation is performed with the given type synonyms and variables in scope.cryptollPerform the given computation in a new scope (i.e., the subcomputation may use existential type variables).cryptol.The arguments to this function are as follows:9(type param. name, kind signature (opt.), type parameter)The type parameter is just a thunk that we should not force. The reason is that the parameter depends on the kind 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. cryptol*Check if a name refers to a type variable.cryptol'Are type wild-cards OK in this context?cryptolReports an error.cryptolGenerate a fresh unification variable of the given kind. NOTE: We do not simplify these, because we end up with bottom. See cd* XXX: Perhaps we can avoid the recursion?cryptol(Lookup the definition of a type synonym.cryptol#Lookup the definition of a newtype. cryptol6Replace the given bound variables with concrete types. cryptolRecord 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). cryptol@The sub-computation is about the given range of the source code.cryptol See comment     rstuvwxyz{|}~     rstuvwxyz{|}~     2(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe cryptolCompute 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. cryptolSolve has-constraints.cryptol,Generator an appropriate selector, once the Has constraint has been discharged. The resulting selectors should always work on their corresponding types (i.e., tuple selectros only select from tuples). This function generates the code for lifting tuple/record selectors to sequences and functions.Assumes types are zonked.  cryptolchanges, solved  3(c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe "cryptolexpected, actual#cryptolexpected a mono type, got thiscryptol$Validate a type, returning its kind.cryptol8Check that the type is valid, and it has the given kind.cryptol"Check that this is a valid schema.cryptolzCheck that the expression is well-formed, and compute its type. Reports an error if the expression is not of a mono type.cryptolACheck that the expression is well-formed, and compute its schema.cryptol2Check if the one type is convertible to the other.cryptolKCheck a declaration. The boolean indicates if we should check the siganture!."/2#3+*0,-&$)'%(4516789:;<:;<8!."/2#3+*0,-&$)'%(4516794(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe=?" Lcryptol Type synonymMcryptolNewtypeNcryptolParameter typeOcryptolProperty synonymPcryptolA primitive/abstract typeeRcryptol`Check for duplicate and recursive type synonyms. Returns the type-synonyms in dependency order.ScryptolIAssociate type signatures with bindings and order bindings by dependency.TcryptolGiven 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. UcryptolgCombine a bunch of definitions into a single map. Here we check that each name is defined only onces. VcryptolgCombine a bunch of definitions into a single map. Here we check that each name is defined only onces. Wcryptol*Identify multiple occurances of something.EJIHGFKPNMLOQRSTUVWKPNMLOQRSEJIHGFTUVW5Safe/[cryptol#We default constraints of the form  Literal t a and FLiteral m n r a.For  Literal t a3 we examine the context of constraints on the type a" to decide how to default. If Logic aR is required, we cannot do any defaulting. Otherwise, we default to either Integer or Rational/. In particular, if we need to satisfy the Field a, constraint, we choose Rational and otherwise we choose Integer.For  FLiteral t a we always default to Rational.^cryptolTry 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. The parameters should be all of numeric kind, and the props should als be numeric [\]^[\]^6(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe"# [8] f x = x + `n Note that nE does not appear in the body of the schema, so we will default it to Mu, 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.cryptol(Check an application of a type constant.cryptolACheck a type application of a non built-in type or type variable.cryptolCheck a type-application.cryptolValidate a parsed type.cryptolValidate a parsed proposition.cryptol(Check that a type has the expected kind.cryptolDo we allow wild cards cryptolWhat sort of params are these? cryptol The params cryptoldo this using the params cryptolType constant being appliedcryptolType parameterscryptol Expected kindcryptolResulting typecryptol2The name that is being applied to some arguments. cryptolParameters to the type cryptolExpected kind cryptolResulting type cryptolParameters to type functioncryptolKind of type functioncryptol$Validated parameters, resulting kindcryptolType that needs to be checkedcryptolExpected kind (if any)cryptol Checked typecryptol#Proposition that need to be checkedcryptolChecked representationcryptolKind-checked typecryptolExpected kind (if any)cryptol Inferred kindcryptol$A type consistent with expectations.defghijkjdhifgek8(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafekcryptolInstantiate 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 # for each constraint on the schema; lnmopqrst topqrslnm9(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe"#%N cryptol0Construct a Prelude primitive in the parsed AST.cryptol0Construct a Prelude primitive in the parsed AST.cryptol?Infer the type of an expression with an explicit instantiation.vcryptolSInfer the type of an expression, and translate it to a fully elaborated core term.cryptol$The type the is the smallest of all cryptolPInfer the type of a pattern. Assumes that the pattern will be just a variable. cryptol4Infer the type of one match in a list comprehension.cryptol2Infer the type of one arm of a list comprehension.wcryptol!inferBinds isTopLevel isRec binds; performs inference for a strongly-connected component of Sys. If any of the members of the recursive group are already marked as monomorphic, then we don't do generalzation. 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.cryptolCome 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.cryptol_The inputs should be declarations with monomorphic types (i.e., of the form `Forall [] [] t`). cryptolCheck a monomorphic binding.uvwxyvxuwy:(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe=>?@A'zcryptoltNote that this assumes that this pass will be run only once for each module, otherwise we will get name collisions.cryptolProduce a fresh top-level name.cryptolmNot really any distinction between global and local, all names get the module prefix added, and a unique id.zz;SafeccryptolKSet of top-level names which need to be instantiate, and module parameters.cryptolhAdjust uses of names to account for the new parameters. Assumes unique names---no capture or shadowing.cryptol0Extra parameters to dd when instantiating a type||<(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe"#79Mcryptol Name of thingcryptolTypecryptolPragmascryptolIs this an infix thingcryptolFixity informationcryptol DocumentationcryptolConstraints on param. typescryptolHThe resulting interface generated by a module that has been typechecked.cryptol Module namecryptolExported definitionscryptolPrivate defintiionscryptol+Uninterpreted constants (aka module params)cryptol,Generate an Iface from a typechecked module.cryptol$Produce a PrimMap from an interface.NOTE: the map will expose both public and private names.  =(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe "#45679=>?5cryptol"Things that define exported names.cryptolThe @ is used by the renamer to determine what identifiers refer to.cryptolExpr renaming environmentcryptolType renaming environmentcryptolGReturn a list of value-level names to which this parsed name may refer.cryptolFReturn a list of type-level names to which this parsed name may refer.cryptoliMerge two name maps, collapsing cases where the entries are the same, and producing conflicts otherwise.cryptolGenerate a mapping from  PrimIdent to ! for a given naming environment.cryptol8Generate a display format based on a naming environment.cryptol9Produce 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.cryptolQualify all symbols in a  with the given prefix.cryptol$Singleton type renaming environment.cryptol*Singleton expression renaming environment.cryptol9Like mappend, but when merging, prefer values on the lhs.cryptol Generate a  using an explicit supply.cryptoljInterpret an import in the context of an interface, to produce a name environment for the renamer, and a  for pretty-printing.cryptolcGenerate a naming environment from a declaration interface, where none of the names are qualified.cryptolUCompute an unqualified naming environment, containing the various module parameters.cryptol0The naming environment for a single declaration.cryptolThe naming environment for a single module. This is the mapping from unqualified names to fully qualified names with uniques.cryptol5Generate the naming environment for a type parameter.cryptolIntroduce the namecryptolXGenerate a type renaming environment from the parameters that are bound by this schema.cryptol|Produce a naming environment from an interface file, that contains a mapping only from unqualified names to qualified ones.cryptolThe import declarations cryptol Declarations of imported module >Safe=?ÿcryptolConvert a module instantiation into a partial module. The resulting module is incomplete because it is missing the definitions from the instantiation.cryptol+Generate a new instance of a declared name.cryptol]Compute renaming environment from a module instantiation. computeEnv :: ModInst -> InstM EnvcryptolParametrized module cryptolName of the new module cryptol Type params cryptolValue parameters cryptol2Instantiated constraints, fresh module, new supplycryptolFunctor being instantiated ?SafeΈ cryptol8Check that the instance provides what the functor needs.cryptolQCheck that the type parameters of the functors all have appropriate definitions.cryptolxGiven a parameter definition, compute an appropriate instantiation that will match the actual schema for the parameter. cryptoltype-checked functor cryptoltype-checked instance cryptolInstantiated modulecryptolParameterized module cryptolType instantiations cryptolInstantiation module cryptolDefinitions for the parameterscryptolDefinition of parameter cryptol Schema for parameter definition cryptolSchema for parameter cryptol'Expression to use for param definition   @(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeҀ cryptolRCheck a module instantiation, assuming that the functor has already been checked. cryptolfunctor cryptol TC settings cryptolnew version of instance 9     JXKLMNOPQRSTUVWYZ[\]^_`a 9      JXKLMNOPQRSTUVWYZ[\]^_`a A(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe24$ cryptol7Operation cannot be supported in the symbolic simulator cryptol=Data type describing errors that can occur during evaluation. cryptolOut-of-bounds index cryptolNon-numeric type passed to number function cryptolDivision or modulus by 0 cryptol"Exponentiation by negative integer cryptolLogarithm of a negative integer cryptolBitvector too large cryptolCall to the Cryptol error primitive cryptolDetectable nontermination cryptol Primitive with no implementation cryptolInvalid rounding mode cryptol/Value outside the domain of a partial function.cryptol"This thunk has not yet been forcedcryptol'This thunk is currently being evaluatedcryptoldThis thunk has previously been forced, and has the given value, or evaluation resulted in an error. cryptol!The monad for Cryptol evaluation. cryptolSome options for evalutaion "cryptol Where to print stuff (e.g., for trace) #cryptolHow to pretty print things. %cryptolAlways show an exponent &cryptolOnly show exponent when needed (cryptolUse this many significant digis )cryptol*Show this many digits after floating point *cryptol Use the correct number of digits +cryptol*How to pretty print things when evaluating 2cryptol6A computation that returns an already-evaluated value. 4cryptolAccess the evaluation options. 5cryptolrDelay 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. 6cryptolBegin executing the given operation in a separate thread, returning a thunk which will await the completion of the computation when forced. 7cryptolProduce 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. 8cryptol$Execute the given evaluation action. 9cryptolLift an  computation into the   monad. :cryptolPanic from an Eval context. ;cryptolFor things like `(inf) or `(0-1). <cryptolFor 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). 5cryptolComputation to delay cryptol6Backup computation to run if a tight loop is detected 7cryptol%A name to associate with this thunk. .                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; <.    8 ! " # 4 + , - . / 0 1 ' ( ) * $ % & 3 9 5 2 7 6               : < ;BSafe* Ocryptol=Make LibBF options for the given precision and rounding mode. Pcryptol/Mapping from the rounding modes defined in the ef to the rounding modes of LibBF. Qcryptol.Check that we didn't get an unexpected status. RcryptolPretty print a float ScryptolMake a literal TcryptolKMake a floating point number from a rational, using the given rounding mode Ucryptol;Convert a floating point number to a rational, if possible. Vcryptol;Convert a floating point number to an integer, if possible. XcryptolMake a float using "raw" bits. YcryptolTurn a float into raw bits. NaN& is represented as a positive "quiet" NaNG (most significant bit in the significand is set, the rest of it is 0) ScryptolExponent width cryptolPrecision width WcryptolExponent width cryptolPrecision widht cryptol Raw bits XcryptolExponent width cryptolPrecision widht cryptol Raw bits  J K M L N O P Q R S T U V W X Y J K M L N O P Q R S T U V W X YCSafe>HVA [cryptolThis type class defines a collection of operations on bits, words and integers that are necessary to define generic evaluator primitives that operate on both concrete and symbolic values uniformly. acryptolPCheck if an operation is "ready", which means its evaluation will be trivial. bcryptolProduce 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. ccryptolrDelay 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. dcryptolBegin evaluating the given computation eagerly in a separate thread and return a thunk which will await the completion of the given computation when forced. ecryptol<Merge the two given computations according to the predicate. fcryptoljAssert that a condition must hold, and indicate what sort of error is indicated if the condition fails. gcryptol(Indiciate that an error condition exists hcryptolPretty-print an individual bit icryptolPretty-print a word value jcryptolPretty-print an integer value kcryptol#Pretty-print a floating-point value lcryptol3Determine if this symbolic bit is a boolean literal mcryptol#The number of bits in a word value. ncryptolWDetermine if this symbolic word is a literal. If so, return the bit width and value. ocryptol>Attempt to render a word value as an ASCII character. Return  B if the character value is unknown (e.g., for symbolic values). pcryptol/Determine if this symbolic integer is a literal qcryptol-Construct a literal bit value from a boolean. rcryptol=Construct a literal word value given a bit width and a value. scryptol9Construct a literal integer value from the given integer. tcryptol9Construct a floating point value from the given rational. }cryptol'Extract the numbered bit from the word.|NOTE: this assumes that the sequence of bits is big-endian and finite, so the bit numbered 0 is the most significant bit. ~cryptol$Update the numbered bit in the word.|NOTE: this assumes that the sequence of bits is big-endian and finite, so the bit numbered 0 is the most significant bit. cryptolConstruct 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. cryptolDeconstruct 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. cryptolEConstruct a packed word of the specified width from an integer value. cryptolgConcatenate the two given word values. NOTE: the first argument represents the more-significant bits cryptolTake 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. cryptolExtract 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 equivalent to first shifting w right by i! bits, and then truncating to n bits. cryptol Bitwise OR cryptol Bitwise AND cryptol Bitwise XOR cryptolBitwise complement cryptol2'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. cryptol2'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. cryptol2'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. cryptol2's complement unsigned division of packed words. The arguments must have equal bit width, and the result is of the same width. It is illegal to call with a second argument concretely equal to 0. cryptol2's complement unsigned modulus of packed words. The arguments must have equal bit width, and the result is of the same width. It is illegal to call with a second argument concretely equal to 0. cryptol2's complement signed division of packed words. The arguments must have equal bit width, and the result is of the same width. It is illegal to call with a second argument concretely equal to 0. cryptol2's complement signed modulus of packed words. The arguments must have equal bit width, and the result is of the same width. It is illegal to call with a second argument concretely equal to 0. cryptol%2's complement negation of bitvectors cryptol%Compute rounded-up log-2 of the input cryptolATest if two words are equal. Arguments must have the same width. cryptolJSigned less-than comparison on words. Arguments must have the same width. cryptolLUnsigned less-than comparison on words. Arguments must have the same width. cryptolOUnsigned greater-than comparison on words. Arguments must have the same width. cryptol6Construct an integer value from the given packed word. cryptolAddition of unbounded integers. cryptolNegation of unbounded integers cryptol"Subtraction of unbounded integers. cryptol%Multiplication of unbounded integers. cryptolInteger division, rounding down. It is illegal to call with a second argument concretely equal to 0. Same semantics as Haskell's div operation. cryptolInteger modulus, with division rounding down. It is illegal to call with a second argument concretely equal to 0. Same semantics as Haskell's mod operation. cryptolEquality comparison on integers cryptol Less-than comparison on integers cryptol#Greater-than comparison on integers cryptol#Turn an integer into a value in Z_n cryptolYTransform a Z_n value into an integer, ensuring the value is properly reduced modulo n cryptolAAddition of integers modulo n, for a concrete positive integer n. cryptol%Additive inverse of integers modulo n cryptolDSubtraction of integers modulo n, for a concrete positive integer n. cryptolGMultiplication of integers modulo n, for a concrete positive integer n. cryptol"Equality test of integers modulo n cryptolHRepresentation of rational numbers. Invariant: denominator is not 0 cryptolDelay 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. ecryptolA merge operation on values cryptolThe condition cryptolThe "then" computation cryptolThe "else" computation rcryptolWidth cryptolValue scryptolValue tcryptolexponent bits cryptolprecision bits cryptol The rational }cryptolBit position to extract ~cryptolBit position to update cryptol bit-width cryptol left width cryptol right width cryptolNumber of bits to take cryptol starting bit cryptolmodulus cryptolmodulus cryptolmodulus cryptolmodulus cryptolmodulus cryptolmodulus cryptolmodulus cryptol)Name of the function for error reporting cryptolRounding mode cryptolrounding mode cryptolthe integeer to use q Z [ _ ^ ] ` \ t g c s | f w l p j a b d e h i k m n o q r u v x y z { } ~  q [ _ ^ ] ` \ t g c s | f w l p j a b d e h i k m n o q r u v x y z { } ~  Z D(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe "#%79=>?`#cryptolCheck for overlap and shadowingcryptolOnly check for overlapcryptolDon't check the environmentcryptol\How many times did we refer to each name. Used to generate warnings for unused definitions. cryptol+Multiple imported symbols contain this name cryptol.Expression name is not bound to any definition cryptol(Type name is not bound to any definition cryptol8An environment has produced multiple overlapping symbols cryptol[When a value is expected from the naming environment, but one or more types exist instead. cryptoleWhen a type is missing from the naming environment, but one or more values exist with the same name. cryptol)When the fixity of two operators conflict cryptol5When it's not possible to produce a Prop from a Type. cryptol6When a builtin type/type-function is used incorrectly. cryptol)When a builtin type is named in a binder. cryptol#When record updates overlap (e.g., { r | x = e1, x.y = e2 })cryptol(Record an error. XXX: use a better namecryptol<Get the source range for wahtever we are currently renaming.cryptol*Annotate something with the current range.cryptol:Do the given computation using the source code range from loc if any.cryptol(Retrieve the name of the current module. cryptol;Shadow the current naming environment with some more names.cryptol;Shadow the current naming environment with some more names.cryptolGenerate warnings when the left environment shadows things defined in the right. Additionally, generate errors when two names overlap in the left environment.cryptol?Check the RHS of a single name rewrite for conflicting sources. cryptolAThrow errors for any names that overlap in a rewrite environment.cryptolProduce 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.cryptolvAssuming an error has been recorded already, construct a fake name that's not expected to make it out of the renamer.cryptolXRename a schema, assuming that the type variables have already been brought into scope.cryptolRename a qualified thing.cryptol1The name environment generated by a single match.cryptolERename patterns, and collect the new environment that they introduce.cryptolERename patterns, and collect the new environment that they introduce. cryptolNote that after this point the ->I updates have an explicit function and there are no more nested updates. cryptolRename a binding. cryptolPRename a schema, assuming that none of its type variables are already in scope.cryptolMay contain infix expressionscryptolThe operator to usecryptol"Will not contain infix expressions  ESafe cryptolUndefined value names cryptol#Undefined type names (from newtype) cryptol'Undefined type params (e.d. mod params) cryptol9Compute the transitive closure of the given dependencies. cryptolDependencies of top-level declarations in a module. These are dependencies on module parameters or things defined outside the module.            F(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe79 $cryptoljAn evaluated type of kind *. These types do not contain type variables, type synonyms, or type functions. %cryptol  Bit &cryptol  Integer 'cryptol  Float e p (cryptol  Z n )cryptol Rational *cryptol  Array a b +cryptol  [n]a ,cryptol  [inf]t -cryptol  (a, b, c ) .cryptol  { x : a, y : b, z : c } /cryptol  a -> b 0cryptolan abstract type 1cryptol-Convert a type value back into a regular type 2cryptolTrue if the evaluated value is Bit 3cryptolProduce a sequence type value 4cryptolLCoerce an extended natural into an integer, for values known to be finite 5cryptol#Evaluation for types (kind * or #). 6cryptol$Evaluation for value types (kind *). 7cryptol%Evaluation for number types (kind #). 8cryptolAReduce type functions, raising an exception for undefined values. # $ 0 / . - , + * ) ( ' & % 1 2 3 4 5 6 7 8 $ 0 / . - , + * ) ( ' & % 1 2 3 4 # 5 6 7 8G(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe%1479=>?@AHPVX_; <cryptol8Generic value type, parameterized by bit and word types.FNOTE: we maintain an important invariant regarding sequence types.  CD must never be used for finite sequences of bits. Always use the  DH constructor instead! Infinite sequences of bits are handled by the  E& constructor, just as for other types. =cryptol  { .. } >cryptol  ( .. ) ?cryptol  Bit @cryptol Integer  or  Z n Acryptol  Rational Ccryptol [n]a / Invariant: VSeq is never a sequence of bits Dcryptol  [n]Bit Ecryptol  [inf]a Fcryptol functions Gcryptolpolymorphic values (kind *) Hcryptolpolymorphic values (kind #) IcryptolYFor efficiency 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 evaluator) 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. Jcryptol-Packed word representation for bit sequences. Kcryptol0A large bitvector sequence, represented as a  L of bits. LcryptolA sequence map represents a mapping from nonnegative integer indices to values. These are used to represent both finite and infinite sequences. PcryptolwAn arbitrarily-chosen number of elements where we switch from a dense sequence representation of bit-level words to  L representation. Qcryptol4Generate a finite sequence map from a list of values Rcryptol9Generate an infinite sequence map from a stream of values ScryptolCreate a finite list of length n of the values from [0..n-1]# in the given the sequence emap. Tcryptol=Create an infinite stream of all the values in a sequence map Ucryptol*Reverse the order of a finite sequence map WcryptolConcatenate the first nS values of the first sequence map onto the beginning of the second sequence map. XcryptolGiven 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. YcryptolDrop the first n elements of the given  L. ZcryptolbGiven a sequence map, return a new sequence map that is memoized using a finite map memo table. [cryptolPApply the given evaluation function pointwise to the two given sequence maps. \cryptol@Apply the given function to each value in the given sequence map ]cryptol(Force a word value into packed word form ^cryptol*Force a word value into a sequence of bits _cryptolmTurn a word value into a sequence of bits, forcing each bit. The sequence is returned in big-endian order. `cryptolTurn a word value into a sequence of bits, forcing each bit. The sequence is returned in reverse of the usual order, which is little-endian order. acryptol Compute the size of a word value bcryptol*Select an individual bit from a word value ccryptolProduce a new  I$ from the one given by updating the i#th bit with the given bit value. dcryptol$Force the evaluation of a word value ecryptolForce the evaluation of a value hcryptolCreate a packed word of n bits. jcryptol!Functions that assume word inputs kcryptol+Functions that assume floating point inputs lcryptolA type lambda that expects a Type. mcryptolA type lambda that expects a Type of kind #. ncryptol1A type lambda that expects a finite numeric type. ocryptolGenerate a stream. qcryptolConstruct either a finite sequence, or a stream. In the finite case, record whether or not the elements were bits, to aid pretty-printing. rcryptolConstruct either a finite sequence, or a stream. In the finite case, record whether or not the elements were bits, to aid pretty-printing. scryptolExtract a bit value. tcryptolExtract an integer value. ucryptolExtract a rational value. vcryptol Extract a finite sequence value. wcryptolExtract a sequence. zcryptolExtract a packed word. |cryptolIf 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  . }cryptol Extract a function from a value. ~cryptol,Extract a polymorphic function from a value. cryptol,Extract a polymorphic function from a value. cryptolExtract a tuple from a value. cryptolExtract a record from a value. cryptolLookup a field in a record. UcryptolSize of the sequence map 3 [ _ ^ ] ` \ t g c s | f w l p j a b d e h i k m n o q r u v 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 [ \ ] ^ _ ` 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 d e [ _ ^ ] ` \ t g c s | f w l p j a b d e h i k m n o q r u v x y z { } ~  g h i j k l m n o p q r s t u v w x y z { | } ~  3 f L M N O Q R S T U V Y W X Z [ \ P I J K ] ^ _ ` a b cHSafe"#$%*HPSVX_ cryptoleConcrete bitvector values: width, value Invariant: The value must be within the range 0 .. 2^width-1 cryptolsApply an integer function to the values of bitvectors. This function assumes both bitvectors are the same width. cryptolwApply an integer function to the values of a bitvector. This function assumes the function will not require masking. cryptolSmart constructor for  !s that checks for the width limit cryptol Bit-width cryptolValue cryptolMasked result cryptol Rouding mode cryptolRounding mode   I(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe79=?% cryptol'Evaluation environment with no bindings cryptol.Bind a variable in the evaluation environment. cryptolVBind a variable to a value in the evaluation environment, without creating a thunk. cryptol%Lookup a variable in the environment. cryptolBind a type variable of kind *. cryptolLookup a type variable. J(c) 2013-2020 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe "#$%*@APSX_U cryptol/Make a numeric literal value at the given type. cryptolMake a numeric constant. cryptol/Convert an unbounded integer to a value in Ring cryptol)Convert a word to a non-negative integer. cryptol4Join a sequence of sequences into a single sequence. cryptol%Extract a subsequence of bits from a  WordValue. 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 `extractWordVal n i w` is equivalent to first shifting w right by i! bits, and then truncating to n bits. cryptolSplit implementation. cryptolBMerge two values given a binop. This is used for and, or and xor. cryptolIndexing operations. cryptolCompute the list of bits in an integer in big-endian order. Fails if neither the sequence length nor the type value provide an upper bound for the integer. cryptolCompute the list of bits in an integer in big-endian order. The integer argument is a concrete upper bound for the symbolic integer. cryptolGeneric implementation of shifting. Uses the provided word-level operation to perform the shift, when possible. Otherwise falls back on a barrel shifter that uses the provided reindexing operation to implement the concrete shifting operations. The reindex operation is given the size of the sequence, the requested index value for the new output sequence, and the amount to shift. The return value is an index into the original sequence if in bounds, and Nothing otherwise. cryptolExpect a word value. Mask it to an 8-bits ASCII value and return the associated character, if it is concrete. Otherwise, return a ? character cryptol6Make a Cryptol value for a binary arithmetic function. cryptolFRounding mode used in FP operations that do not specify it explicitly. cryptolFRounding mode used in FP operations that do not specify it explicitly. cryptolFRounding mode used in FP operations that do not specify it explicitly. cryptolFRounding mode used in FP operations that do not specify it explicitly. cryptolFRounding mode used in FP operations that do not specify it explicitly. cryptolFRounding mode used in FP operations that do not specify it explicitly. cryptol bit-width cryptolbig-endian list of index bits cryptolUpper bound to test against cryptolSequence size bounds cryptol Index value cryptolconcrete shifting operation cryptolinitial value cryptol*bits of shift amount, in big-endian order cryptol*operation for range reduction on integers cryptol*word shift operation for positive indices cryptol*word shift operation for negative indices cryptolWreindexing operation for positive indices (sequence size, starting index, shift amount cryptolWreindexing operation for negative indices (sequence size, starting index, shift amount n                  n                  K(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Trustworthy "#HVX cryptol#The property as entered by the user !cryptol#The property as entered by the user #cryptolNothing indicates infinity (cryptol@A test result is either a pass, a failure due to evaluating to False;, or a failure due to an exception raised during evaluation -cryptolJApply a testable value to some randomly-generated arguments. Returns Nothing if the function returned True , or Just counterexample if it returned False.oPlease note that this function assumes that the generators match the supplied value, otherwise we'll panic. /cryptol$Return a collection of random tests. 0cryptolWGiven a (function) type, compute generators for the function's arguments. This is like  1>, but allows the result to be any finite type instead of just Bit. 1cryptolGiven 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. 2cryptol{A generator for values of the given type. This fails if we are given a type that lacks a suitable random value generator. 3cryptolGenerate a random bit value. 5cryptolGenerate a random integer value. The size parameter is assumed to vary between 1 and 100, and we use it to generate smaller numbers first. 8cryptolBGenerate 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. 9cryptol(Generate a random infinite stream value. :cryptolyGenerate a random sequence. This should be used for sequences other than bits. For sequences of bits use "randomWord". ;cryptolGenerate a random tuple value. <cryptolGenerate a random record value. >cryptolProduce 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 zero @cryptolpApply a testable value to some arguments. Note that this function assumes that the values come from a call to  AP (i.e., things are type-correct). We run in the IO monad in order to catch any  EvalErrors. AcryptolGiven a (function) type, compute all possible inputs for it. We also return the types of the arguments and the total number of test (i.e., the length of the outer list. BcryptolQGiven a fully-evaluated type, try to compute the number of values in it. Returns   for infinite types, user-defined types, polymorphic types, and, currently, function spaces. Of course, we can easily compute the sizes of function spaces, but we can't easily enumerate their inhabitants. CcryptolTReturns all the values in a type. Returns an empty list of values, for types where  B returned  .  -cryptolhow to evaluate thingscryptolFunction under testcryptolArgument generatorscryptolSize .cryptolHow to evaluate thingscryptol&Function to be used to calculate testscryptolArgument generatorscryptolSizecryptolInitial random statecryptol'Arguments, result, and new random state /cryptolThe random generator statecryptolHow to evaluate thingscryptol%Generators for the function argumentscryptolThe function itselfcryptolHow many tests?cryptol8A list of pairs of random arguments and computed outputs =cryptolExponent width cryptolPrecision width -         ' & % $ # " ! ( + * ) , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D- , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ( + * ) ? @ A B C   ' & % $ # " !       DL(c) 2020 Galois, Inc.BSD3cryptol@galois.comNone %*4HVX_ EcryptolThe symbolic value we computed. FcryptolA malformed value GcryptolSsafety predicate and result: the result only makes sense when the predicate holds. HcryptolDKeep track of a value and a context defining uninterpeted vairables. LcryptolThis layer has the symbolic back-end, and can keep track of definitional predicates used when working with uninterpreted constants defined via a property. OcryptolFThis is the monad used for symbolic evaluation. It adds to aspects to Eval'F keeps track of the backend and collects definitional predicates, and  O+ adds support for partially defined values WcryptolA value with no context. XcryptolA total value. YcryptolAccess the symbolic back-end ZcryptolRecord a definition. [cryptolCompute conjunction. \cryptolCompute negation. ]cryptolCompute if-then-else. ^cryptol^Add a definitional equation. This will always be asserted when we make queries to the solver. _cryptolAdd s safety condition. `cryptol A fully undefined symbolic value gcryptolyTry successive powers of 2 to find the first that dominates the input. We could perhaps reduce to using CLZ instead... pcryptol6Compare a symbolic word value with a concrete integer.; E F G H I K J 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 { | } ~ ; S T R O P Q L M N H I K J E F G 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 { | } ~ MNone*n cryptol"Table of floating point primitivescryptol0A helper for definitng floating point constants.  N(c) 2020 Galois, Inc.BSD3cryptol@galois.comNone%k E G F H I J K O R S T U S T E G F H I J K O U R OSafe*  P(c) 2013-2020 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe"#$%HPSVX_ cryptoldGiven 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.cryptolfThe function may assume its arguments are masked. It is responsible for masking its result if needed.cryptollength of the sequence cryptoltype of values in the sequence cryptolsequence to update cryptolindex cryptolnew value at index cryptollength of the sequence cryptoltype of values in the sequence cryptolbit sequence to update cryptolindex cryptolnew value at index cryptollength of the sequence cryptoltype of values in the sequence cryptolsequence to update cryptolindex cryptolnew value at index cryptollength of the sequence cryptoltype of values in the sequence cryptolbit sequence to update cryptolindex cryptolnew value at index   Q(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe "#%>PX_o cryptolA prover result is either an error message, an empty result (eg for the offline prover), a counterexample or a lazy list of satisfying assignments. cryptolA :prove command can fail either because some input causes the predicate to violate a safety assertion, or because the predicate returns false for some input. cryptolThe type of query to run cryptol+Which prover to use (one of the strings in  proverConfigs) cryptolVerbosity flag passed to SBV cryptol#Model validation flag passed to SBV cryptolRecord timing information here cryptol?Extra declarations to bring into scope for symbolic simulation cryptol,Optionally output the SMTLIB query to a file cryptol&The typechecked expression to evaluate cryptolThe  of pcExpr cryptol#Should we ignore safety predicates?) ) R(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone %4=?@AHMV_cryptol6Compare a symbolic word value with a concrete integer.cryptolCeiling (log_2 x)  S(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe %,@AJX_ cryptolEvaluation environments for list comprehensions: Each variable name is bound to a list of values, one for each element in the list comprehension.cryptol&Bindings whose values vary by positioncryptol"Bindings whose values are constant cryptolcExtend the given evaluation environment with all the declarations contained in the given module. cryptolUEvaluate 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.cryptol1Introduce the constructor function for a newtype. cryptoltExtend the given evaluation environment with the result of evaluating the given collection of declaration groups.cryptolbThis 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 its eta-expanded form. The straightforward solution to this is to force an eta-expansion procedure on all recursive definitions. However, for the so-called Value- types we can instead optimistically use the  5U operation and only fall back on full eta expansion if the thunk is double-forced.cryptolValue 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  5h operation to build a thunk that falls back on performing eta-expansion rather than doing it eagerly.cryptolFEta-expand a word value. This forces an unpacked word representation.cryptolGiven a simulator value and its 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.cryptolEvaluate 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. cryptolApply 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).cryptoljEvaluate a list environment at a position. This choses a particular value for the varying locations.cryptolEvaluate a comprehension.cryptolUTurn a list of matches into the final environments for each iteration of the branch.cryptol9Turn a match into the list of environments it represents. cryptol+Module containing declarations to evaluate cryptolEnvironment to extend cryptolEvaluation environment cryptolExpression to evaluate cryptolDeclaration groups to evaluate cryptolEnvironment to extend cryptol8A 'read only' environment for use in declaration bodies cryptol?An evaluation environment to extend with the given declaration cryptolThe declaration to evaluate cryptol Starting evaluation environment cryptolLength of the comprehension cryptol#Type of the comprehension elements cryptol%Head expression of the comprehension cryptol(List of parallel comprehension branches $                ! " # + , - . / 0 1 3 8 e $ 8 ! " # + , - . / 0 1 3                eT(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone"#79D' cryptolExtra 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. cryptol1The name of this module. Should match what's in  cryptol=The file path used to load this module (may not be canonical) cryptolAn identifier used to identify the source of the bytes for the module. For files we just use the cononical path, for in memory things we use their label. cryptol\The module's interface. This is for convenient. At the moment we have the whole module in  , so this could be computer. cryptolThe actual type-checked module cryptol3Invariants: 1) All the dependencies of any module m must precede m= in the list. 2) Does not contain any parameterized modules. cryptolLoaded parameterized modules. cryptolThe location of a module cryptolLabel, content cryptol2Specifies how a declared name came to be in scope. cryptolVContains enough information to browse what's in scope, or type check new expressions. cryptolShould we run the linter? cryptolDon't run core lint cryptol Run core lint cryptol-This is the current state of the interpreter. cryptol+Information about all loaded modules. See  . Contains information such as the file where the module was loaded from, as well as the module's interface, used for type checking. cryptol+A source of new names for the type checker. cryptolAConfiguration settings for the SMT solver used for type-checking. cryptolbThe evaluation environment. Contains the values for all loaded modules, both public and private. cryptol*Should we run the linter to ensure sanity. cryptolnAre we assuming that local bindings are monomorphic. XXX: We should probably remove this flag, and set it to x. cryptolFThe "current" module. Used to decide how to print names, for example. cryptolWhere we look for things. cryptolqThis contains additional definitions that were made at the command line, and so they don't reside in any module. cryptolName source for the renamer cryptol7Try to focus a loaded module in the module environment. cryptolGet a list of all the loaded modules. Each module in the resulting list depends only on other modules that precede it. Note that this includes parameterized modules. cryptol|Get a list of all the loaded non-parameterized modules. These are the modules that can be used for evaluation, proving etc. cryptol%Are any parameterized modules loaded? cryptolGiven the state of the environment, compute information about what's in scope on the REPL. This includes what's in the focused module, plus any additional definitions from the REPL (e.g., let bound names, and it). cryptolFThe name of the content---either the file path, or the provided label. cryptol$Has this module been loaded already. cryptol&Is this a loaded parameterized module. cryptol&Try to find a previously loaded module cryptol\Add a freshly loaded module. If it was previously loaded, then the new version is ignored. cryptolRemove a previously loaded module. Note that this removes exactly the modules specified by the predicate. One should be carfule to preserve the invariant on  . cryptolBuild D 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. cryptol'In-memory things are compared by label.A                    A                    g(c) 2014-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable TrustworthyGhSafeG 0U(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeIJ 0 1 2 3 4 1 2 3 4 0(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Trustworthy=?FhK 'GHIJLy{}z|~ 5 6 7 8 9 : ; < = > ? @ A B C D E' 8 9 7 ; : = < ? > A @ C B E D 5 6y{}z|~LGHIJ9 9 V(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe"#79_cryptolFiles that have been loadedcryptol&The path that includes are relative tocryptolHow to load filescryptolGGet the absolute directory name of a file that contains cryptol source.cryptolRun 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.cryptol6Adjust an included file with the current include path.cryptol Raise an  G error.cryptolPush 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.cryptolNLift an IO operation, with a way to handle the exception that it might throw.cryptolLike B, but tries to collect as many errors as possible before failing.cryptolRemove includes from a module.cryptolRemove includes from a program.cryptolSSubstitute top-level includes with the declarations from the files they reference.cryptolPResolve the file referenced by a include into a list of top-level declarations.cryptol%Read a file referenced by an include. F G H I J K L K F G H I J LW(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone79>x acryptol=Unable to find the module given, tried looking in these paths bcryptolUnable to open a file ccryptol.Bad UTF-8 encoding in while decoding this file dcryptol4Some other IO error occurred while reading this file ecryptol=Generated this parse error when parsing the file for module m fcryptol!Recursive module group discovered gcryptol"Problems during the renaming phase hcryptolProblems during the NoPat phase icryptol#Problems during the NoInclude phase jcryptolProblems during type checking kcryptol0Problems after type checking, eg. specialization lcryptolModule loaded by 'import'$ statement has the wrong module name mcryptolATwo modules loaded from different files have the same module name ncryptolBAttempt to import a parametrized module that was not instantiated. ocryptolCFailed to add the module parameters to all definitions in a module. qcryptolThis is just a tag on the error, indicating the file containing it. It is convenient when we had to look for the module, and we'd like to communicate the location of pthe problematic module to the handler. cryptolTRun the computation, and if it caused and error, tag the error with the given file. cryptolgPush an "interactive" context onto the loading stack. A bit of a hack, as it uses a faked module name cryptol(Get the currently focused import source. cryptolRun a  T action in a context with a prepended search path. Useful for temporarily looking in other places while resolving imports, for example. cryptol#Usefule for logging. For example: withLogger logPutStrLn Hello^ T U V W X Y \ [ Z ] ^ _ ` q p o n m l k j i h g f e d c b a r u t s v w x y z { | } ~  ^ r u t s v ` q p o n m l k j i h g f e d c b a w x y z { | } ~  ] ^ _ X Y \ [ Z U V W T X(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone"#>/ cryptol7Rename a module in the context of its imported modules. cryptolRun the noPat pass. cryptolLoad a module by its path. cryptol/Load a module, unless it was previously loaded. cryptol>Load dependencies, typecheck, and add to the eval environment. cryptol0Rewrite an import declaration to be of the form: &import foo as foo [ [hiding] (a,b,c) ] cryptolcFind the interface referenced by an import, and generate the naming environment that it describes. cryptol=Load a series of interfaces, merging their public interfaces. cryptolDiscover a module. cryptol'Discover a file. This is distinct from  D in that we assume we've already been given a particular file name. cryptolAAdd the prelude to the import list if it's not already mentioned. cryptol7Load the dependencies of a module into the environment. cryptoluTypecheck a single expression, yielding a renamed parsed expression, typechecked core expression, and a type schema. cryptol"Typecheck a group of declarations.LINVARIANT: This assumes that NoPat has already been run on the declarations. cryptolGenerate the primitive map. If the prelude is currently being loaded, this should be generated directly from the naming environment given to the renamer instead. cryptol@Load a module, be it a normal module or a functor instantiation. cryptolTypecheck a single module. If the module is an instantiation of a functor, then this just type-checks the instantiating parameters. See  cryptol#Generate input for the typechecker. cryptol how to check cryptolwhy are we loading this cryptolmodule to check % % Y(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone> cryptolFFind the file associated with a module name in the module search path. cryptol,Load the module contained in the given file. cryptolLoad the given parsed module. cryptolnCheck the type of an expression. Give back the renamed expression, the core expression, and its type schema. cryptolEvaluate an expression. cryptol!Typecheck top-level declarations. cryptol?Evaluate declarations and add them to the extended environment.P          ] _ ^ ` a b c d e f g h i j k l m n o p q P         ` a b c d e f g h i j k l m n o p q ] _ ^  Z(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableNoneO cryptolThe specializer monad. cryptolA  should have an entry in the   iff it is specializable. Each  starts out with an empty -. cryptolAdd a where clause to the given expression containing type-specialized versions of all functions called (transitively) by the body of the expression. cryptolAdd 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. cryptolCompute the specialization of  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. cryptolqTransform 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. cryptol)Freshen a name by giving it a new unique. cryptolReduce  length ts! outermost type abstractions and n proof abstractions.                    [(c) 2013-2020 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone"#%*>HPSVX_QcryptolEReturns definitions, together with the value and it safety predicate.cryptolKSimulate and manipulate query into a form suitable to be sent to a solver.cryptol0optional safety predicate. Nothing = SAT query                  \(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone "#%>PX_ߔ cryptol-The names of all the solvers supported by SBVcryptolSelect the appropriate solver or solvers from the given prover command, and invoke those solvers on the given symbolic value. cryptolSPrepare a symbolic query by symbolically simulating the expression found in the  ProverQuery. The result will either be an error or a list of the types of the symbolic inputs and the symbolic value to supply to the solver.PNote that the difference between sat and prove queries is reflected later in  where we call different SBV methods depending on the mode, so we do _not_ negate the goal here. Moreover, assumptions are added using conjunction for sat queries and implication for prove queries.For safety properties, we want to add them as an additional goal when we do prove queries, and an additional assumption when we do sat queries. In both cases, the safety property is combined with the main goal via a conjunction. cryptol%Turn the SMT results from SBV into a  ProverResultg that is ready for the Cryptol REPL. There may be more than one result if we made a multi-sat query. !cryptolExecute a symbolic ':prove' or ':sat' command.This command returns a pair: the first element is the name of the solver that completes the given query (if any) along with the result of executing the query. "cryptolExecute a symbolic ':prove' or ':sat' command when the prover is set to offline. This only prepares the SMT input file for the solver and does not actually invoke the solver.{This method returns either an error message or the text of the SMT input file corresponding to the given prover command. cryptolGiven concrete values from the solver and a collection of finite types, reconstruct Cryptol concrete values, and return any unused solver values. cryptolParse a single value of a finite type by consuming some number of solver values. The parsed Cryptol values is returned along with any solver values not consumed. cryptolTypes of the symbolic inputs cryptolResults from the solver       ! "    ! "  ](c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone "#%2=?@AHV_ C, cryptol)Returns maybe an error, and some warningscryptol:User modifiable environment, for things like numeric base. 3cryptolREPL exceptions. Ccryptol#REPL_ context with InputT handling.cryptolREPL RW Environment.cryptolPThis is the name of the currently "focused" module. This is what we reload (:r)cryptolThis is what we edit (:e)cryptol<Should we keep going when we encounter an error, or give up.cryptolAre we in batch mode.cryptol-The current environment of all things loaded.cryptol User settingscryptol%Use this to send messages to the usercryptolShould we allow `let` on the command linecryptolnExecute this every time we load a module. This is used to change the title of terminal when loading a module. Fcryptol3This indicates what the user would like to work on. HcryptolWorking on this module. IcryptolWorking on this file.cryptolInitial, empty environment.cryptol!Build up the prompt for the REPL. Jcryptol+Run a REPL action with a fresh environment. KcryptolRaise an exception. Pcryptol1Construct the prompt for the current environment. Rcryptol7Set the name of the currently focused file, loaded via :r. TcryptolSet the path for the ':e'V command. Note that this does not change the focused module (i.e., what ":r" reloads) ]cryptolPRun a computation in batch mode, restoring the previous isBatch flag afterwards `cryptol&Are let-bindings enabled in this REPL? acryptolbIs evaluation enabled. If the currently focused module is parameterized, then we cannot evalute. bcryptolUpdate the title ccryptol<Set the function that will be called when updating the title dcryptolSet the REPL's string-printer ecryptolGet the REPL's string-printer gcryptol2Use the configured output action to print a string hcryptolJUse the configured output action to print a string with a trailing newline icryptolKUse the configured output action to print something using its Show instance kcryptolHGet visible variable names. This is used for command line completition. lcryptolNGet visible type signature names. This is used for command line completition. mcryptol@Return a list of property names, sorted by position in the file. scryptolGiven 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. tcryptolOGenerate a fresh name using the given index. The name will reside within the " interactive " namespace.cryptol9Generate a UserEnv from a description of the options map. ucryptolSet a user option. vcryptol+Get a user option, using Maybe for failure. wcryptolOGet a user option, when it's known to exist. Fail with panic when it doesn't.cryptolCheck the value to the base option.[ % & ' ( ) * + - , . / 0 1 2 3 4 @ 9 : A B ? 5 6 7 8 ; < = > 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 { | } ~ [ C D E J O K [ L M h g i 3 4 @ 9 : A B ? 5 6 7 8 ; < = > N j o p q r s t ~ k l m n F G H I S R Q T U V W X P Z \ ] ^ _ ` a b c . / 0 1 2 ' ( ) * + - , u w x v { } y z | Y e f d  % &^AThe reference implementation of the Cryptol evaluation semantics.(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone*) cryptol'Value type for the reference evaluator. cryptol Bit  booleans cryptol Integer  or Z n integers cryptol Rational  rationals cryptolFloating point numbers cryptol [n]a  finite or infinite lists cryptol ( .. )  tuples cryptol { .. }  records cryptol functions cryptolpolymorphic values (kind *) cryptolpolymorphic values (kind #)cryptolDestructor for VBit.cryptolDestructor for VInteger.cryptolDestructor for  VRational. cryptolDestructor for VList.!cryptolDestructor for VTuple."cryptolDestructor for VRecord.#cryptolDestructor for VFun.$cryptolDestructor for VPoly.%cryptolDestructor for VNumPoly.&cryptolLook up a field in a record.'cryptol>Polymorphic function values that expect a finite numeric type.(cryptol.Bind a variable in the evaluation environment.)cryptol$Bind a type variable of kind # or *.*cryptol>Convert a list of booleans in big-endian format to an integer.+cryptolEConvert a list of booleans in signed big-endian format to an integer.,cryptol;Process two elements based on their lexicographic ordering.-cryptol%Lexicographic ordering on two values..cryptol,Lexicographic ordering on two signed values./cryptolSplit a list into w pieces, each of length k.0cryptolTranspose a list of length-w lists into w lists.1cryptol,Indexing operations that return one element. cryptolEvaluation environmentcryptolExpression to evaluate2cryptolStarting evaluation environmentcryptol$Head expression of the comprehensioncryptol'List of parallel comprehension branches  _(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone"#>_`[ cryptolCommand builder. cryptol Commands. cryptolSuccessfully parsed command cryptol2Ambiguous command, list of conflicting commands cryptolThe unknown command3cryptolREPL command parsing.4cryptolNotebook command parsing.5cryptol0A subset of commands safe for Notebook execution cryptolRun a command. cryptolwRandomly 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.6cryptol~This function computes the expected coverage percentage and expected number of unique test vectors when using random testing.,The expected test coverage proportion is: 1 - ((n-1)/n)^k This formula takes into account the fact that test vectors are chosen uniformly at random _with replacement_, and thus the same vectors may be generated multiple times. If the test vectors were chosen randomly without replacement, the proportion would instead be k/n.We compute raising to the k] power in the log domain to improve numerical precision. The equivalant comptutation is: -expm1( k * log1p (-1/n) )Where expm1(x) = exp(x) - 1 and log1p(x) = log(1 + x). However, if sz is large enough, even carefully preserving precision may not be enough to get sensible results. In such situations, we expect the naive approximation k/nu to be very close to accurate and the expected number of unique values is essentially equal to the number of tests.7cryptol7Attempts to prove the given term is safe for all inputs8cryptolConsole-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.9cryptol<Make a type/expression pair that is suitable for binding to it after running :sat or :prove:cryptol Convert a ; (big-endian) of length n to an < with 8*n= bits. This function uses a balanced binary fold to achieve  O(n log n); total memory allocation and run-time, in contrast to the O(n^2). that would be required by a naive left-fold. cryptol*Lift a parsing action into the REPL monad.=cryptol@Check declarations as though they were defined at the top-level.>cryptolhCreates a fresh binding of "it" to the expression given, and adds it to the current dynamic environment?cryptolExtend the dynamic environment with a fresh binding for "it", as defined by the given value. If we cannot determine the definition of the value, then we don't bind it.@cryptolCreates a fresh binding of "it" to a finite sequence of expressions of the same type, and adds that sequence to the current dynamic environment cryptolStrip leading space.AcryptolStrip trailing space. cryptol!Split at the first word boundary.BcryptolUncons a list. cryptol$Lookup a string in the command list. cryptoljLookup a string in the command list, returning an exact match even if it's the prefix of another command. cryptol2Lookup a string in the notebook-safe command list. cryptolParse a line as a command.5 5 Cijklmmnopqqrsttuvwxxyz{|}~                                               ! " # $ % & ' ( ) * + , - . / 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 V W X Y Z 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 { | } ~  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa a a a a aaaaaaaaaaaaaaaaaaaaaa a!a"a#a$%&''()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxxyzz{|}~{c      !"#$%&'()*+,-./001234563789:;<<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      6k !"7#$%&'()<<N>*c+AB,,-./0123456789:;<=>??@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghiijklmnopqrsstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~bbbbbb                   @ J F  H  P M A   N    Q                                                            ^ _ `    Z [ Y c d e 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){)|)})~)))))))))))))))))))***************++,,,,------------------..................................................................................../////// / / / / ////////////00000000 0!0"0#0$0%0&0'0(0)0*0+0,0-0.0/000102003040500060708090:0001;1<1=1>1>1?1@1A1A1B1C1C1D1E1F1G1H1I1I1J1K1L1M1N1O1P1Q1R1S1S1T1U1V1W1X1Y1Z1[1\1]1^1_1`1a1b1c1d1e1f1g1h1i1j1k1k1l1m1n1n1o1p1q1r1s1t1u1v1w1x1y1z1{1|1}1~111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111233!33333333333333333333333333333333334444444 4 4 4 4 4444444444455556666 6!7"7#7$7%7&7'7(7)8*8+8,8-8-8.8/80819293949596:7:8;9;:;;;<;=;>;?;@;A;B;C;D;E;F;G;H;I;J<K<K<L<M<N<O<P<Q<R<S<T<T<U<V<W<X<Y<Y<Z<[<\<]<]<^<_<`<a<b<c<d<e<f<g<h<i<j<k<l<m<n<o<p<q<r<s<t=u=u=v=w=x=x=y=z=z={={=|=}=~==========================================>>>>>>B>C>>>>>D>>H>F>E>G>I>J>?@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCC C CxC C C C C C C C C C C C C C C C C C C C CC C C C C C C C C C C C !C "C #C $C %C &C 'C (C )C *C +C ,C -C .C /C 0C 1C 2C 3C 4C 5C 6C 7C 8C 9C :C ;C <C =C >C ?C @C AC BC CC DC EC FC GCC HC IC JC KC LCCC MCC NC NC OC PC QC RC SC TC UC VC WC XC YC ZC [C \C ]C ^C _C `C aC bC cC dC eC fD gD hD iD jD kD lD mD nD oD pD qD rD sD tD uD vD wD xD yD zD {D |D }D ~D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D D E E E E E E E E E E E E E E E E E E E E E E E E E E E E E 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 G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G G !H "H "H #H $H $H %H &H 'H (H )H *H +H ,H -H .H /H 0H 1H 2H 3H 4I 5I 6I 7I 8I 9I :II ;II <I =I >I ?I @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 YJ ZJ [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 yJ zJ {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 KK 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 L #L L L L L LL L L L L L L L L L L L L L L LL L L L L L L L L L L L L L L L L L L L 0L L L L L L L L L L L L M N O 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 0Q 1Q 2Q 3Q 4Q 5Q 6Q 7Q 8Q 9Q :Q ;Q <Q =Q >Q ?Q @R AR AR BR CR DR CR #R ER ER FR GR HR IR JR KR R LR MR NR OR PR QR RR SS 6S TS US VS WS XS YS ZT [T \T ]T ^T _T `T `T aT bT cT dT eT fT gT gT hT iT jT kT lT mT nT oT pT qT rT sT sT tT uT vT wT xT yT zT {T zT |T |T }T ~T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T h U U U U                  V V V V V V V V V V V V V V W W W W WSWSW W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W WW W W W W W W W W W W W W W W W W WW W W W W W W WW W W W !W "W #W $W %W &W 'W (W )W *W +W ,W -W .W /W 0W 1W 2W 3W 4W 5W 6W 7W 8W 9W :X ;X ;X <X =X >X ?X @X @X AX BX hX |X CX X DX EX FX GX HX IX JX KX LX MX NX OX PXX QX RX SX TX UX VX WX UX VY XY YYY KY DY ZY OY UY PY VY CY }Y ~Z [Z \Z ]Z ^Z _Z `Z aZ bZ cZ dZ eZ fZ gZ hZ iZ jZ kZ lZ mZ nZ oZ pZ qZ Z r[ s[ t[ u[ v[ w[ x[ y[ z[ {[ |[ }\ ~\ \ \ w\ x\ y\ z\ {\ \ ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ]] ] ] ] ]]] ] ] ] ] D] ] ] t] ] ] ] `] `] ] ] ] ] ] ] ]] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] "] ] ] ] ] ] ] #] $] ] o] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ^ #^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ U^ ^ ^ ^ ^ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _    ! "i # $` %` &` '` (i ) * + , - .a /a 0a 1a 2a 3a 4a 5a 6a 7a 8a 9a :a ;a <a =a >a ?a @a Aa Ba Ca Da Ea Fa Ga Ha Ia Ja Ka La Ma Na Oa Pa Qa Ra Sa Ta Ua Va Wa Xaa Ya Za [a \a ]a ^a _a `a aa ba c d e f g h i jb kb lb mb nb ob pb qb rb sb tb tb ub vb wb xb yb zb {b |b }b ~b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b  C                % % % ' ' ' ' ' ' ' ' ' ' ' ) + + / / / / /  2 2 3(3 3"3 3 3 3 6 6 6 777 7 7 7 7 8 9 9 9 9 9 9 9 9 9 9 :: ; E; ; > > ? ? ? A A A  D D D D D D D D D D DDDDDDDDDD H M P P P P PR R SSSSSSSSSSSSSSgggh h!h"h#h$h%h&''V(V)V*V+V,V-V.V/V0V1V2i34V5V6V7V8V9[:[;[<\=\;\>\?\@]A]B]I]C]D]E]F]G]H]I]J]K]L]M]N]O^ ^ ^ ^P^ ^ ^ ^ ^ ^ ^Q^^ <^R^S^T^U^V^W^ ^X^_Y_Z_[_\_]_^___`abcdef_g_h_i_j_k_lm$cryptol-2.9.0-4aSi1YZNBynFQwh9aOpllRCryptol.Utils.PanicCryptol.Eval.ArchCryptol.Eval.What4.SFloat Cryptol.ModuleSystem.FingerprintCryptol.Utils.FixityCryptol.Utils.IdentCryptol.Utils.LoggerCryptol.Utils.MiscCryptol.Utils.PPCryptol.Utils.DebugCryptol.TypeCheck.PPCryptol.Parser.SelectorCryptol.Parser.PositionCryptol.TypeCheck.Solver.InfNatCryptol.REPL.TrieCryptol.Parser.UnlitCryptol.Parser.NameCryptol.Parser.LexerCryptol.ModuleSystem.NameCryptol.TypeCheck.TConCryptol.Utils.PatternsCryptol.Utils.RecordMapCryptol.TypeCheck.TypeCryptol.TypeCheck.TypePatCryptol.TypeCheck.SimpTypeCryptol.Parser.ASTCryptol.Parser.UtilsCryptol.ParserCryptol.Parser.NamesCryptol.Parser.NoPatCryptol.ModuleSystem.ExportsCryptol.TypeCheck.ASTCryptol.TypeCheck.TypeMapCryptol.TypeCheck.Solver.Utils)Cryptol.TypeCheck.Solver.Numeric.IntervalCryptol.TypeCheck.Solver.TypesCryptol.TypeCheck.Solver.Class$Cryptol.TypeCheck.Solver.Numeric.Fin Cryptol.TypeCheck.Solver.NumericCryptol.TypeCheck.SimpleSolverCryptol.TypeCheck.SubstCryptol.TypeCheck.UnifyCryptol.TypeCheck.TypeOf Cryptol.TypeCheck.Solver.ImproveCryptol.TypeCheck.ParseableCryptol.TypeCheck.InferTypesCryptol.TypeCheck.Solver.SMTCryptol.TypeCheck.ErrorCryptol.TypeCheck.Monad!Cryptol.TypeCheck.Solver.SelectorCryptol.TypeCheck.SanityCryptol.TypeCheck.DependsCryptol.TypeCheck.DefaultCryptol.TypeCheck.SolveCryptol.TypeCheck.KindCryptol.TypeCheck.InstantiateCryptol.TypeCheck.InferCryptol.Transform.MonoValuesCryptol.Transform.AddModParamsCryptol.ModuleSystem.InterfaceCryptol.ModuleSystem.NamingEnv&Cryptol.ModuleSystem.InstantiateModule%Cryptol.TypeCheck.CheckModuleInstanceCryptol.TypeCheckCryptol.Eval.Monad"Cryptol.Eval.Concrete.FloatHelpersCryptol.Eval.BackendCryptol.ModuleSystem.RenamerCryptol.IR.FreeVarsCryptol.Eval.TypeCryptol.Eval.ValueCryptol.Eval.Concrete.ValueCryptol.Eval.EnvCryptol.Eval.GenericCryptol.Testing.RandomCryptol.Eval.What4.ValueCryptol.Eval.What4.FloatCryptol.Eval.What4Cryptol.Eval.Concrete.FloatCryptol.Eval.ConcreteCryptol.SymbolicCryptol.Eval.SBV Cryptol.EvalCryptol.ModuleSystem.EnvCryptol.VersionCryptol.Parser.NoIncludeCryptol.ModuleSystem.MonadCryptol.ModuleSystem.BaseCryptol.ModuleSystemCryptol.Transform.SpecializeCryptol.Symbolic.What4Cryptol.Symbolic.SBVCryptol.REPL.MonadCryptol.Eval.ReferenceCryptol.REPL.CommandCryptol.PreludeCryptol.Parser.LexerUtilsCryptol.Parser.ParserUtilsKindhsFloatcryGitRev Paths_cryptolbaseGHC.Stack.Types HasCallStack$panic-0.4.0.1-E9mSbJZBlYCDp8i0Bd1wOIPanicmaxBigIntWidth SFloatRelSFloatBinArith FPTypeError fpExpectedfpActualUnsupportedFloatfpWho exponentBits precisionBitsSFloatfpReprOffpSizefpFreshfpNaNfpPosInffpFromRationalLit fpFromBinary fpToBinaryfpNegfpAddfpSubfpMulfpDivfpEqfpEqIEEEfpLtIEEEfpGtIEEEfpRoundfpToReal fpFromReal fpFromIntegerfpFromRational fpToRationalfpIsInffpIsNaN$fExceptionUnsupportedFloat$fExceptionFPTypeError$fShowUnsupportedFloat$fShowFPTypeError Fingerprint fingerprintfingerprintFile$fNFDataFingerprint$fEqFingerprint$fShowFingerprint FixityCmpFCErrorFCLeftFCRightFixityfAssocfLevelAssoc LeftAssoc RightAssocNonAssoc compareFixity defaultFixity $fShowAssoc $fEqAssoc$fGenericAssoc $fNFDataAssoc $fEqFixity$fGenericFixity$fNFDataFixity $fShowFixity$fShowFixityCmp $fEqFixityCmp PrimIdentIdentModName modNameToText textToModName modNameChunksisParamInstModNameparamInstModNamenotParamInstModName packModName preludeName floatName arrayNameinteractiveName noModuleName exprModName packIdent packInfix unpackIdentmkIdentmkInfix isInfixIdent nullIdent identText modParamIdentprelPrim floatPrim arrayPrim$fNFDataModName $fNFDataIdent$fIsStringIdent $fOrdIdent $fEqIdent$fNFDataPrimIdent $fEqModName $fOrdModName $fShowModName$fGenericModName $fShowIdent$fGenericIdent $fEqPrimIdent$fOrdPrimIdent$fShowPrimIdent$fGenericPrimIdentLogger logPutStr logPutStrLnlogPrint quietLogger handleLogger stdoutLogger stderrLogger funLogger$fNFDataLoggeranyJustanyJust2InfixieOpieLeftieRightieFixityPPName ppNameFixity ppPrefixName ppInfixNamePPppPrecDoc NameFormat UnQualified Qualified NotInScopeNameDisp EmptyNameDispneverQualifyMod alwaysQualify neverQualify fmtModNameextend getNameFormat withNameDisp fixNameDisprunDocrender renderOneLinepppretty optParenscommaSepppInfixordinal ordSuffixliftPJliftPJ1liftPJ2liftSep<.><+>$$sepfsephsephcatvcathangnestparensbracesbracketsquotes backticks punctuatetextcharintegerintcommaemptycolon$fMonoidNameDisp$fSemigroupNameDisp$fShowNameDisp $fIsStringDoc $fShowDoc $fMonoidDoc$fSemigroupDoc $fPPFixity $fPPAssoc $fPPModName $fPPIdent$fPPText$fShowNameFormat$fGenericNameDisp$fNFDataNameDisp $fGenericDoc $fNFDataDoctraceppTrace WithNamesNameMap emptyNameMapppWithNamesPrec ppWithNamesdumpnameListSelectorTupleSel RecordSelListSel ppSelectorselName ppNestedSels $fPPSelector $fEqSelector$fShowSelector $fOrdSelector$fGenericSelector$fNFDataSelectorAddLocaddLocdropLocHasLocgetLocRangefromtosourcePositionlinecolLocatedsrcRangething emptyRangestartmovemovesrCombrCombsatcombLoc $fPPPosition $fPPRange$fPPNameLocated $fPPLocated$fFunctorLocated $fHasLoc[] $fHasLoc(,)$fHasLocLocated $fHasLocRange$fAddLocLocated $fEqPosition $fOrdPosition$fShowPosition$fGenericPosition$fNFDataPosition $fEqRange $fOrdRange $fShowRange$fGenericRange $fNFDataRange $fEqLocated $fOrdLocated $fShowLocated$fGenericLocated$fNFDataLocated CryptolPanicCryptolpanic$fPanicComponentCryptolNat'NatInffromNatnAddnMulnExpnMinnMaxnSubnDivnModnCeilDivnCeilModnLg2nWidthnLenFromThenTogenLog widthInteger rootExactgenRoot $fShowNat'$fEqNat' $fOrdNat' $fGenericNat' $fNFDataNat'TrieNode emptyTrie insertTrie lookupTrielookupTrieExactleaves $fShowTriePreProcNoneMarkdownLaTeX knownExts guessPreProcunLitPassNoPat MonoValuesPNameUnQualQualNewNamemkUnqualmkQual getModNamegetIdentisGeneratedName $fNFDataPass $fPPNamePName $fPPPName $fNFDataPName$fEqPass $fOrdPass $fShowPass $fGenericPass $fEqPName $fOrdPName $fShowPName$fGenericPNameTokenTNumFracChrLitStrLitKWOpSymVirtWhiteErrEOFTokenErrUnterminatedCommentUnterminatedStringUnterminatedChar InvalidString InvalidChar LexicalErrorTokenSymBarArrLArrRFatArrRLambdaEqDefCommaSemiDotDotDot DotDotDotColonBackTickParenLParenRBracketLBracketRCurlyLCurlyRTriLTriR UnderscoreTokenKWKW_else 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_primitive KW_parameter KW_constraintKW_PropTokenW BlockComment LineCommentSpaceDocStrTokenVVCurlyLVCurlyRVSemiToken tokenType tokenTextLayoutNoLayoutConfig cfgSource cfgLayout cfgPreProccfgAutoIncludecfgModuleScope defaultConfiglexer primLexerPrimMap primDecls primTypesSupplySupplyTFreshM liftSupply NameSource SystemNameUserNameNameNameInfoDeclared ParametercmpNameLexicalcmpNameDisplay ppLocName nameUnique nameIdentnameInfonameLoc nameFixityasPrimtoParamInstName asParamName runSupplyT nextUniqueM emptySupply nextUnique mkDeclared mkParameterparamModRecParamlookupPrimDecllookupPrimType $fPPNameName$fPPName $fOrdName$fEqName$fMonadFixSupplyT$fRunMSupplyTa->$fBaseMSupplyTn$fMonadTSupplyT$fMonadSupplyT$fApplicativeSupplyT$fFunctorSupplyT$fFreshMSupplyT$fFreshMStateT$fFreshMReaderT$fFreshMWriterT$fFreshMExceptionT$fSemigroupPrimMap$fGenericNameSource$fNFDataNameSource$fShowNameSource$fEqNameSource $fEqNameInfo$fShowNameInfo$fGenericNameInfo$fNFDataNameInfo $fGenericName $fNFDataName $fShowName $fShowSupply$fGenericSupply$fNFDataSupply $fShowPrimMap$fGenericPrimMap$fNFDataPrimMapTFunTCAddTCSubTCMulTCDivTCModTCExpTCWidthTCMinTCMax TCCeilDiv TCCeilModTCLenFromThenToTCErrorMessagetcErrorMessageUserTCTCTCNumTCInfTCBit TCIntegerTCFloatTCIntMod TCRationalTCArrayTCSeqTCFunTCTuple TCAbstract TCNewtypePCPEqualPNeqPGeqPFinPHasPZeroPLogicPRing PIntegralPFieldPRoundPEqPCmp PSignedCmpPLiteral PFLiteral PValidFloatPAndPTrueTConTFTErrorHasKindkindOfKTypeKNumKProp:-> infixPrimTy builtInType$fPPKind$fPPPC $fHasKindPC $fPPUserTC $fOrdUserTC $fEqUserTC$fHasKindUserTC$fPPTC $fHasKindTC$fPPTCErrorMessage$fPPTFun $fHasKindTFun$fPPTCon $fHasKindTCon$fEqKind $fOrdKind $fShowKind $fGenericKind $fNFDataKind$fShowPC$fEqPC$fOrdPC $fGenericPC $fNFDataPC $fShowUserTC$fGenericUserTC$fNFDataUserTC$fShowTC$fEqTC$fOrdTC $fGenericTC $fNFDataTC$fShowTCErrorMessage$fEqTCErrorMessage$fOrdTCErrorMessage$fGenericTCErrorMessage$fNFDataTCErrorMessage $fShowTFun$fEqTFun $fOrdTFun $fBoundedTFun $fEnumTFun $fGenericTFun $fNFDataTFun $fShowTCon$fEqTCon $fOrdTCon $fGenericTCon $fNFDataTConMatchesmatchesPatMatch|||&&&~>~~><~__succeed checkThatlit matchDefaultmatch matchMaybelist><$fMonadPlusMatch$fAlternativeMatch$fMonadFailMatch $fMonadMatch$fApplicativeMatch$fFunctorMatch$fMatchesa(,,,)(,,)$fMatchesa(,,)(,)$fMatchesa(,)r1 RecordMapfieldSet displayOrderrecordElementscanonicalFields displayFieldsrecordFromFieldsrecordFromFieldsErrrecordFromFieldsWithDisplay lookupField adjustFieldtraverseRecordMapmapWithFieldNamerecordMapAccum zipRecordsM zipRecords$fTraversableRecordMap$fFoldableRecordMap$fFunctorRecordMap$fNFDataRecordMap$fShowRecordMap$fOrdRecordMap $fEqRecordMapFVSfvsSType AbstractTypeatNameatKindatCtrs atFixitiyatDocNewtypentNamentParams ntConstraintsntFieldsntDocTySyntsNametsParams tsConstraintstsDeftsDocProp TVarSourceTVFromModParamTVFromSignature TypeWildCardTypeOfRecordFieldTypeOfTupleFieldTypeOfSeqElementLenOfSeqTypeParamInstNamedTypeParamInstPos DefinitionOf LenOfCompGen TypeOfArg TypeOfResTypeErrorPlaceHolderTVarInfo tvarSourcetvarDescTVarTVFreeTVBoundTypeTUserTRecTPFlavor TPModParamTPOtherTParamtpUniquetpKindtpFlavtpInfoSchemaForallsVarssPropssTypetMonoisMono schemaParam tySynParam propSynParam newtypeParam modTyParamtpfNametpNametvInfo tvSourceName quickApply kindResulttpVar superclassSetnewtypeConTypeabstractTypeTCisFreeTV isBoundTVtIsErrortIsNat'tIsNumtIsInftIsVartIsFuntIsSeqtIsBit tIsInteger tIsIntModtIsTupletIsRec tIsBinFun tSplitFunpIsFinpIsGeqpIsEqualpIsZeropIsLogicpIsRingpIsField pIsIntegralpIsRoundpIsEqpIsCmp pIsSignedCmp pIsLiteral pIsFLiteralpIsTruepIsWidth pIsValidFloattNumtZerotOnetTwotInftNat' tAbstracttBittInteger tRationaltFloattIntModtArraytWordtSeqtChartStringtRectTuple newtypeTyContFuntNoUsertErrortf1tf2tf3tSubtMultDivtModtExptMintCeilDivtCeilModtLenFromThenTo=#==/=pZeropLogicpRing pIntegralpFieldpRoundpEqpCmp pSignedCmppLiteral>==pHaspTruepAnd pSplitAndpFin pValidFloatnoFreeVariables freeParams addTNamesppNewtypeShort pickTVarName$fPPTVarSource $fPPTVarInfo $fPPWithNames $fPPTParam $fOrdTParam $fEqTParam$fHasKindTParam$fPPTVar$fPPWithNames0 $fOrdTVar$fEqTVar $fHasKindTVar$fPPType$fPPWithNames1 $fOrdType$fEqType $fHasKindType$fPPWithNames2 $fPPSchema$fPPWithNames3 $fPPTySyn$fHasKindTySyn$fPPWithNames4 $fPPNewtype$fHasKindNewtype $fFVSSchema$fFVS(,)$fFVS[] $fFVSMaybe $fFVSType$fGenericTPFlavor$fNFDataTPFlavor$fShowTPFlavor$fShowTVarSource$fGenericTVarSource$fNFDataTVarSource$fShowTVarInfo$fGenericTVarInfo$fNFDataTVarInfo$fGenericTParam$fNFDataTParam $fShowTParam $fShowTVar $fGenericTVar $fNFDataTVar $fShowType $fGenericType $fNFDataType $fEqSchema $fShowSchema$fGenericSchema$fNFDataSchema $fShowTySyn$fGenericTySyn $fNFDataTySyn $fShowNewtype$fGenericNewtype$fNFDataNewtype$fShowAbstractType$fGenericAbstractType$fNFDataAbstractTypeaInfaNataNat'anAdd|-|aMul|^||/||%|aMinaMaxaWidthaCeilDivaCeilModaLenFromThenToaTVar aFreeTVaraBitaSeqaWordaCharaTupleaRec|->|aFin|=||/=||>=|aAndaTrueaLiteralaLogicanError tRebuild'tRebuildtContAddtMaxtWidthtotalop1op2op3tOpNoPosnoPosCTypeTSeqTBitTNumTCharTTyAppTRecordTTupleTWildTLocatedTParensTInfixtpRangeKFunNamednamevaluePatternPVarPWildPTuplePRecordPListPTypedPSplitPLocatedMatchLetTypeInst NamedInstPosInstUpdHowUpdSetUpdFunUpdFieldExprEVarELitENeg EComplement EGenerateETupleERecordESelEUpdEListEFromToEInfFromECompEAppEAppTEIfEWhereETypedETypeValEFunELocatedESplitEParensEInfixLiteralECNumECCharECFracECStringFracInfoBinFracOctFracDecFracHexFracNumInfoBinLitOctLitDecLitHexLitPolyLitTopLeveltlExporttlDoctlValue ExportTypePublicPrivate ReplInput ExprInputLetInputPrimType primTName primTKindprimTCts primTFixitynNamenParamsnBodyPragma PragmaNotePragmaPropertyBindDefDPrimDExprLBindDefBindbNamebParamsbDef bSignaturebInfixbFixitybPragmasbMonobDocPropSyn ImportSpecHidingOnlyImportiModuleiAsiSpec ParameterFunpfNamepfSchemapfDocpfFixity ParameterTypeptNameptKindptDocptFixityptNumberDecl DSignatureDFixityDPragmaDBindDPatBindDTypeDPropDLocatedTopDecl DPrimType TDNewtypeIncludeDParameterTypeDParameterConstraint DParameterFunModulemName mInstancemImportsmDeclsProgramLStringLIdentLPNamemodRangepsNametsFixitypsFixitycppKind$fPPImportSpec $fPPImport $fPPPragma $fPPTopLevel$fHasLocTopLevel $fPPLiteral $fPPUpdHow $fHasLocNamed$fPPParameterType$fHasLocParameterType$fAddLocTParam$fHasLocTParam $fAddLocType $fHasLocType $fPPPattern$fHasLocPattern$fAddLocPattern $fPPTypeInst$fHasLocNewtype$fPPProp$fAddLocSchema$fHasLocSchema$fPPParameterFun$fHasLocParameterFun $fPPPrimType$fHasLocPrimType $fPPPropSyn $fPPMatch $fPPUpdField$fPPExpr $fPPBindDef$fPPBind$fPPDecl $fAddLocDecl $fHasLocDecl $fHasLocMatch $fHasLocBind $fHasLocExpr $fAddLocExpr $fPPTopDecl$fHasLocTopDecl $fPPModule$fHasLocModule $fPPProgram $fNoPosProp $fNoPosType $fNoPosTParam $fNoPosSchema$fNoPosPattern $fNoPosMatch$fNoPosTypeInst$fNoPosUpdField $fNoPosExpr$fNoPosPropSyn $fNoPosTySyn $fNoPosPragma $fNoPosBind$fNoPosNewtype $fNoPosDecl$fNoPosTopLevel$fNoPosParameterFun$fNoPosParameterType$fNoPosPrimType$fNoPosTopDecl $fNoPosModule$fNoPosProgram $fNoPos(,) $fNoPosMaybe $fNoPos[] $fNoPosRange $fNoPosNamed$fNoPosLocated$fEqImportSpec$fShowImportSpec$fGenericImportSpec$fNFDataImportSpec $fEqImport $fShowImport$fGenericImport$fNFDataImport $fEqPragma $fShowPragma$fGenericPragma$fNFDataPragma$fEqExportType$fShowExportType$fOrdExportType$fGenericExportType$fNFDataExportType$fShowTopLevel$fGenericTopLevel$fNFDataTopLevel$fFunctorTopLevel$fFoldableTopLevel$fTraversableTopLevel $fEqNumInfo $fShowNumInfo$fGenericNumInfo$fNFDataNumInfo $fEqFracInfo$fShowFracInfo$fGenericFracInfo$fNFDataFracInfo $fEqLiteral $fShowLiteral$fGenericLiteral$fNFDataLiteral $fEqUpdHow $fShowUpdHow$fGenericUpdHow$fNFDataUpdHow $fEqNamed $fShowNamed$fFoldableNamed$fTraversableNamed$fGenericNamed $fNFDataNamed$fFunctorNamed$fEqParameterType$fShowParameterType$fGenericParameterType$fNFDataParameterType$fFunctorTParam $fFunctorType $fEqPattern $fShowPattern$fGenericPattern$fNFDataPattern$fFunctorPattern $fEqTypeInst$fShowTypeInst$fGenericTypeInst$fNFDataTypeInst$fFunctorTypeInst $fEqNewtype $fEqTySyn$fFunctorTySyn$fEqProp $fShowProp $fGenericProp $fNFDataProp $fFunctorProp$fFunctorSchema$fEqParameterFun$fShowParameterFun$fGenericParameterFun$fNFDataParameterFun$fShowPrimType$fGenericPrimType$fNFDataPrimType $fEqPropSyn $fShowPropSyn$fGenericPropSyn$fNFDataPropSyn$fFunctorPropSyn$fEqDecl $fShowDecl $fGenericDecl $fNFDataDecl $fFunctorDecl$fEqExpr $fShowExpr $fGenericExpr $fNFDataExpr $fFunctorExpr $fEqMatch $fShowMatch$fGenericMatch $fNFDataMatch$fEqBind $fGenericBind $fNFDataBind $fFunctorBind $fShowBind $fEqBindDef $fShowBindDef$fGenericBindDef$fNFDataBindDef$fFunctorBindDef $fEqUpdField$fShowUpdField$fGenericUpdField$fNFDataUpdField$fFunctorUpdField $fEqReplInput$fShowReplInput $fShowTopDecl$fGenericTopDecl$fNFDataTopDecl $fShowModule$fGenericModule$fNFDataModule $fShowProgram widthIdenttranslateExprToNumT ParseError HappyError HappyErrorMsgHappyUnexpectedHappyOutOfTokensppErrortnamesNTnamesDsnamesD allNamesDnamesBnamesDefnamesEnamesUFnamesPsnamesPnamesMnamesArm boundLNames boundNames boundNamesSettnamesDstnamesDtnamesB tnamesDeftnamesEtnamesUFtnamesTItnamesPtnamesMtnamesStnamesCtnamesTErrorMultipleSignaturesSignatureNoBind PragmaNoBindMultipleFixities FixityNoBind MultipleDocsRemovePatternsremovePatterns $fPPError $fMonadNoPatM$fApplicativeNoPatM$fFunctorNoPatM$fRemovePatterns[]$fRemovePatternsModule$fRemovePatternsExpr$fRemovePatternsProgram $fShowError$fGenericError $fNFDataError ExportSpeceTypeseBinds modExports exportBind exportTypeisExportedBindisExportedType$fMonoidExportSpec$fSemigroupExportSpec$fNFDataExportSpec$fShowExportSpec$fGenericExportSpecDeclDefdName dSignature dDefinitiondPragmasdInfixdFixitydDoc DeclGroup Recursive NonRecursiveFromLetERecESetETAbsETAppEAbs EProofAbs EProofApp ModVParammvpNamemvpTypemvpDoc mvpFixity ModTParammtpNamemtpKind mtpNumbermtpDocmExportsmTySyns mNewtypes mPrimTypes mParamTypesmParamConstraints mParamFunsisParametrizedModulemtpParam groupDeclsePrimeErroreStringeCharppLam splitWhilesplitAbs splitTAbs splitProofAbs splitTApp splitProofApp splitExprInst $fPPDeclGroup$fShowModTParam$fGenericModTParam$fNFDataModTParam$fShowModVParam$fGenericModVParam$fNFDataModVParam $fShowDeclDef$fGenericDeclDef$fNFDataDeclDef$fShowDeclGroup$fGenericDeclGroup$fNFDataDeclGroupTypeMapTMtvartcontrecTypesMapListLnilconsTrieMapemptyTMnullTMlookupTMalterTMunionTMtoListTMmapMaybeWithKeyTM membersTMinsertTM insertWithTMmapTM mapWithKeyTM mapMaybeTM $fTrieMapMapa$fTrieMapList[] $fShowTypeMap$fTrieMapTypeMapType $fFunctorList$fFunctorTypeMapsplitVarSummandssplitVarSummandsplitConstSummandsplitConstFactorIntervaliLoweriUpperIntervalUpdateNoChangeInvalidInterval NewIntervals typeInterval tvarIntervalupdateIntervalcomputePropIntervals propInterval ppIntervals ppIntervaliIsExactiIsFin iIsPosFiniOverlap iIntersectiAnyiAnyFiniConstiAddiMuliExpiMiniMaxiSubiDiviModiCeilDiviCeilModiWidthiLenFromThenTo $fEqInterval$fShowInterval$fShowIntervalUpdateSolvedSolvedIfUnsolved UnsolvableCtxt SolverCtxt intervalssaturatedAsmpselseTry solveOpts matchThenguarded $fMonoidCtxt$fSemigroupCtxt $fPPSolved $fShowSolvedsolveValidFloat solveZeroInstsolveLogicInst solveRingInstsolveIntegralInstsolveFieldInstsolveRoundInst solveEqInst solveCmpInstsolveSignedCmpInstsolveFLiteralInstsolveLiteralInstcryIsFin cryIsFinType cryIsEqual cryIsNotEqualcryIsGeqsimplify simplifyStepTVarsapSubst SubstErrorSubstRecursive SubstEscapedSubstKindMismatchSubst emptySubst singleSubstuncheckedSingleSubstsingleTParamSubst@@defaultingSubst listSubstlistParamSubst isEmptySubst substBinds substToList apSubstMaybeapplySubstToVarapSubstTypeMapKeys $fPPSubst $fTVarsModule$fTVarsDeclDef $fTVarsDecl$fTVarsDeclGroup $fTVarsMatch $fTVarsExpr $fTVarsSchema$fTVarsTypeMap $fTVarsList $fTVarsType $fTVars(,) $fTVars[] $fTVarsMaybe $fShowSubstUnificationErrorUniTypeMismatchUniKindMismatchUniTypeLenMismatch UniRecursiveUniNonPolyDepends UniNonPolyResultMGU runResultuniErroremptyMGUmgumguManybindVar fastTypeOf fastSchemaOf improveProps improveProp improveLit improveEq ShowParseable showParseable maybeNameDoc$fShowParseableName$fShowParseableTParam$fShowParseableLocated$fShowParseableMaybe$fShowParseable[]$fShowParseableDeclGroup$fShowParseableDeclDef$fShowParseableDecl$fShowParseableMatch$fShowParseableSelector$fShowParseableType$fShowParseableIdent$fShowParseableInt$fShowParseable(,)$fShowParseableExprConstraintSourceCtComprehension CtSplitPat CtTypeSigCtInst CtSelector CtExactType CtEnumeration CtDefaultingCtPartialTypeFun CtImprovement CtPatternCtModuleInstance DelayedCt dctSource dctForalldctAsmpsdctGoals HasGoalSln hasDoSelecthasDoSetHasGoalhasNamehasGoalGoal goalSource goalRangegoalLitGoalGoalsgoalSetsaturatedPropSet literalGoalsVarTypeExtVarCurSCC SolverConfig solverPath solverArgs solverVerbosesolverPreludePath litGoalToGoal goalToLitGoal emptyGoals nullGoals fromGoals goalsFromList insertGoaladdTVarsDescsAfteraddTVarsDescsBeforeppUse$fPPConstraintSource$fTVarsConstraintSource $fTVarsGoal $fFVSGoal $fOrdGoal$fEqGoal$fTVarsDelayedCt$fFVSDelayedCt$fTVarsHasGoal $fTVarsGoals$fShowSolverConfig$fGenericSolverConfig$fNFDataSolverConfig$fShowConstraintSource$fGenericConstraintSource$fNFDataConstraintSource $fShowGoal $fGenericGoal $fNFDataGoal$fShowDelayedCt$fGenericDelayedCt$fNFDataDelayedCt $fShowHasGoal $fShowGoalsdebugLogSolver withSolver debugBlockproveImpcheckUnsolvable tryGetModel shrinkModel isNumeric$fDebugLogSubst$fDebugLogGoal$fDebugLogType $fDebugLogDoc$fDebugLogMaybe $fDebugLog[]$fDebugLogChar$fMk(,,)$fMk(,)$fMkTCErrorMessage$fMkType$fMkTVar $fMkInteger$fMk()ErrorMsg KindMismatchTooManyTypeParamsTyVarWithParamsTooManyTySynParamsTooFewTyParamsRecursiveTypeDecls TypeMismatch RecursiveType UnsolvedGoalsUnsolvedDelayedCtUnexpectedTypeWildCardTypeVariableEscaped NotForAllTooManyPositionalTypeParams%CannotMixPositionalAndNamedTypeParamsUndefinedTypeParameterRepeatedTypeParameter AmbiguousSizeWarningDefaultingKindDefaultingWildType DefaultingTo cleanupErrorssubsumes $fPPWarning $fFVSWarning$fTVarsWarning $fFVSError $fTVarsError $fShowWarning$fGenericWarning$fNFDataWarningLkpTyVar TLocalVar TOuterVarKRW typeParamskCtrsAllowWildCards NoWildCardsKRO lazyTParams allowWildKindMKMunKMRWiErrors iWarningsiSubst iExistTVars iSolvedHas iNameSeedsiCtsiHasCtsiSupplyROiRangeiVarsiTVarsiTSyns iNewtypesiAbstractTypes iParamTypesiParamConstraints iParamFunsiSolvedHasLazy iMonoBindsiSolver iPrimNames iSolveCounterDefLocIsLocal IsExternalInferMIMunIM InferOutput InferFailedInferOK NameSeedsseedTVarseedGoal InferInputinpRangeinpVarsinpTSyns inpNewtypesinpAbstractTypes inpParamTypesinpParamConstraints inpParamFuns inpNameSeeds inpMonoBindsinpSolverConfig inpSearchPath inpPrimNames inpSupply nameSeeds bumpCounter runInferMioinRange inRangeMbcurRange recordError recordWarning getSolver getPrimMapnewGoalnewGoalsgetGoalsaddGoals collectGoalssimpGoal simpGoals newHasGoal addHasGoal getHasGoals solveHasGoal newParamNamenewName newGoalNamenewTVarnewTVar' newTParamnewTypeunify applySubstapplySubstPredsapplySubstGoalsgetSubst extendSubst varsWithAsmps lookupVar lookupTParam lookupTSyn lookupNewtypelookupAbstractTypelookupParamTypelookupParamFunexistVargetTSyns getNewtypesgetAbstractTypes getParamFuns getParamTypesgetParamConstraintsgetTVarsgetBoundInScope getMonoBindscheckTShadowing withTParam withTParams withTySyn withNewtype withPrimType withParamType withVarType withVarTypeswithVar withParamFunswithParameterConstraints withMonoType withMonoTypes withDecls inNewScoperunKindM kLookupTyVarkWildOK kRecordErrorkRecordWarningkIOkNewType kLookupTSynkLookupNewtypekLookupParamTypekLookupAbstractType kExistTVar kInstantiateTkSetKindkInRange kNewGoals kInInferM$fFreshMInferM$fMonadFixInferM$fMonadFailInferM $fMonadInferM$fApplicativeInferM$fFunctorInferM$fMonadFailKindM $fMonadKindM$fApplicativeKindM$fFunctorKindM$fShowNameSeeds$fGenericNameSeeds$fNFDataNameSeeds$fShowInferInput$fShowInferOutput tryHasGoal ExpectedMonoTupleSelectorOutOfRange MissingFieldUnexpectedTupleShapeUnexpectedRecordShapeUnexpectedSequenceShape BadSelectorBadInstantiationCaptured BadProofNoAbsBadProofTyVarsNotEnoughArgumentsInKindBadApplicationFreeTypeVariableBadTypeApplicationRepeatedVariableInForallBadMatchEmptyArmUndefinedTypeVaraibleUndefinedVariableProofObligationsametcExprtcDeclstcModule $fSameTParam $fSameSchema $fSameType$fSame[] $fMonadTcM$fApplicativeTcM $fFunctorTcMFromDecltoBind toParamFuntoParamConstraintstoTyDecl isTopDeclTyDeclTSNTATPSPT setDocString orderTyDecls orderBindsmkScc combineMapscombine duplicates$fFromDeclDecl$fFromDeclTopDecl $fShowTyDecldefaultLiteralsflitDefaultCandidatesimproveByDefaultingWithPuredefaultReplExpr'defaultReplExprdefaultAndSimplifysimplifyAllConstraintsproveModuleTopLevelproveImplication checkSchemacheckParameterType checkTySyn checkPropSyn checkNewtype checkPrimType checkTypecheckParameterConstraintsMaybeCheckedTypeChecked UncheckedTypeArg tyArgName tyArgTypeuncheckedTypeArginstantiateWith inferModulecheckE inferBinds checkSigBinferDs rewModule$fTrieMapRewMap'(,,) addModParams$fAddParamsNewtype$fAddParamsTySyn$fAddParamsDecl$fAddParamsDeclGroup$fAddParamsExpr$fAddParamsType$fAddParamsSchema $fAddParams[] $fInstNewtype $fInstTySyn $fInstType $fInstDeclDef $fInstDecl$fInstDeclGroup $fInstMatch $fInstExpr$fInst[] IfaceDecl ifDeclName ifDeclSig ifDeclPragmas ifDeclInfix ifDeclFixity ifDeclDoc IfaceNewtype IfaceTySyn IfaceDeclsifTySyns ifNewtypesifAbstractTypesifDecls IfaceParams ifParamTypesifParamConstraints ifParamFunsIface ifModNameifPublic ifPrivateifParams noIfaceParams ifTySynName mkIfaceDeclgenIface ifacePrimMap$fMonoidIfaceDecls$fSemigroupIfaceDecls$fShowIfaceParams$fGenericIfaceParams$fNFDataIfaceParams$fShowIfaceDecl$fGenericIfaceDecl$fNFDataIfaceDecl$fShowIfaceDecls$fGenericIfaceDecls$fNFDataIfaceDecls $fShowIface$fGenericIface $fNFDataIface ImportIface BindsNames namingEnvBuildNamingEnvrunBuildInModule NamingEnvneExprsneTypeslookupValNameslookupTypeNamesmerge toPrimMap toNameDisp visibleNamesqualify filterNames singletonT singletonE shadowing travNamingEnv namingEnv'newTopnewLocal interpImportunqualifiedEnvmodParamsNamingEnv$fMonoidNamingEnv$fSemigroupNamingEnv$fMonoidBuildNamingEnv$fSemigroupBuildNamingEnv$fBindsNamesInModule$fBindsNamesInModule0$fBindsNamesInModule1$fBindsNamesInModule2$fBindsNamesInModule3$fBindsNamesInModule4$fBindsNamesModule$fBindsNamesTParam$fBindsNamesInModule5$fBindsNamesSchema$fBindsNames[]$fBindsNamesMaybe$fBindsNamesNamingEnv$fBindsNamesImportIface$fShowNamingEnv$fGenericNamingEnv$fNFDataNamingEnv$fFunctorInModule$fTraversableInModule$fFoldableInModule$fShowInModuleinstantiateModule$fDefinesDeclGroup $fDefinesDecl $fDefines[]$fInstAbstractType$fInstExportSpec $fInstUserTC$fInstTC $fInstTCon $fInstSchema $fShowEnvcheckModuleInstance tcModuleInst ppWarning UnsupportedUnsupportedSymbolicOp EvalError InvalidIndexTypeCannotBeDemoted DivideByZeroNegativeExponent LogNegative WordTooWide UserError LoopErrorNoPrimBadRoundingModeBadValueEvalReadyThunkEvalOpts evalLogger evalPPOpts PPFloatExp ForceExponent AutoExponent PPFloatFormat FloatFixed FloatFrac FloatFreePPOptsuseAsciiuseBase useInfLength useFPBase useFPFormatready defaultPPOpts getEvalOpts delayFill evalSpark blackholerunEval evalPanictypeCannotBeDemoted wordTooWide$fMonadFixEval $fNFDataEval $fMonadIOEval$fMonadFailEval $fMonadEval$fApplicativeEval $fFunctorEval$fExceptionEvalError $fPPEvalError$fExceptionUnsupported$fPPUnsupported$fShowEvalError$fShowUnsupportedBF bfExpWidth bfPrecWidthbfValuefpOpts fpCheckStatusfpPPfpLitfloatFromRationalfloatToRationalfloatToInteger floatFromBitsfloatFromBits' floatToBitsFPArith2BackendSBitSWordSIntegerSEvalisReady sDeclareHole sDelayFillsSpark mergeEvalassertSideCondition raiseErrorppBitppWord ppIntegerppFloatbitAsLitwordLen wordAsLit wordAsChar integerAsLitbitLitwordLit integerLititeBititeWord iteIntegerbitEqbitOrbitAndbitXor bitComplementwordBit wordUpdatepackWord unpackWord wordFromIntjoinWord splitWord extractWordwordOrwordAndwordXorwordComplementwordPlus wordMinuswordMultwordDivwordMod wordSignedDiv wordSignedMod wordNegatewordLg2wordEqwordSignedLessThan wordLessThanwordGreaterThan wordToIntintPlus intNegateintMinusintMultintDivintModintEq intLessThanintGreaterThanintToZnznToIntznPlusznNegateznMinusznMultznEq fpLessThan fpGreaterThanfpPlusfpMinusfpMult fpToInteger SRationalsNumsDenom invalidIndex cryUserErrorcryNoPrimErrorsDelay intToRationalratio rationalReciprationalDivide rationalFloorrationalCeiling rationalTruncrationalRoundAwayrationalRoundToEven rationalAdd rationalSubrationalNegate rationalMul rationalEqrationalLessThanrationalGreaterThan iteRational ppRationalRenamerenameRenameMRenamerWarningSymbolShadowed UnusedName RenamerError MultipleSyms UnboundExpr UnboundTypeOverlappingSyms ExpectedValue ExpectedType FixityErrorInvalidConstraintMalformedBuiltinBoundReservedTypeOverlappingRecordUpdate runRenamer shadowNamescheckNamingEnv renameModule renameVar renameType$fPPRenamerError$fPPRenamerWarning$fFreshMRenameM$fMonadRenameM$fApplicativeRenameM$fFunctorRenameM$fMonoidRenameM$fSemigroupRenameM$fRenamePropSyn $fRenameTySyn $fRenameMatch$fRenameTypeInst $fRenameExpr$fRenameUpdField$fRenamePattern$fRenameBindDef $fRenameBind $fRenameType $fRenameProp$fRenameTParam$fRenameSchema$fRenameNewtype $fRenameDecl$fRenameParameterFun$fRenameParameterType$fRenamePrimType$fRenameTopDecl$fShowRenamerError$fGenericRenamerError$fNFDataRenamerError$fShowRenamerWarning$fGenericRenamerWarning$fNFDataRenamerWarning $fEqEnvCheck$fShowEnvCheckDefsdefsFreeVarsfreeVarsDepsvalDepstyDepstyParams transDeps moduleDeps $fMonoidDeps$fSemigroupDeps$fFreeVarsNewtype$fFreeVarsTCon$fFreeVarsTVar$fFreeVarsType$fFreeVarsSchema$fFreeVarsMatch$fFreeVarsDeclDef$fFreeVarsDecl $fFreeVars[] $fDefsMatch $fDefsDecl$fDefsDeclGroup$fDefs[]$fFreeVarsExpr$fFreeVarsDeclGroup$fEqDepsTypeEnvTValueTVBit TVIntegerTVFloatTVIntMod TVRationalTVArrayTVSeqTVStreamTVTupleTVRecTVFun TVAbstracttValTyisTBittvSeqfinNat'evalType evalValType evalNumTypeevalTF $fShowTValue$fGenericTValue$fNFDataTValueGenValueVRecordVTupleVBitVInteger VRationalVFloatVSeqVWordVStreamVFunVPolyVNumPoly WordValueWordVal LargeBitsValSeqMap IndexSeqMap UpdateSeqMap lookupSeqMap largeBitSize finiteSeqMapinfiniteSeqMapenumerateSeqMap streamSeqMap reverseSeqMap updateSeqMap concatSeqMap splitSeqMap dropSeqMapmemoMap zipSeqMap mapSeqMap asWordVal asBitsMapenumerateWordValueenumerateWordValueRev wordValueSizeindexWordValueupdateWordValueforceWordValue forceValueppValue asciiModewordlamwlamflamtlamnlamilamtoStreamtoFinSeqtoSeqmkSeqfromVBit fromVInteger fromVRationalfromVSeqfromSeq fromWordValasIndex fromVWordvWordLen tryFromBitsfromVFun fromVPoly fromVNumPoly fromVTuple fromVRecord fromVFloat lookupRecord$fShowGenValue$fGenericGenValue$fGenericWordValueBVValueConcretebinBVunaryBVbvValmkBvsignedBV signedValue integerToCharlg2ppBVmask liftBinIntMod fpBinArith fpRoundMode$fBackendConcrete$fShowBV$fShowConcrete GenEvalEnvEvalEnvenvVarsenvTypesppEnvemptyEnv bindVarDirectbindType lookupType$fMonoidGenEvalEnv$fSemigroupGenEvalEnv$fGenericGenEvalEnv UnaryWordBinWordUnaryBinarymkLit ecNumberVintVratioV ecFractionVfromZVbinaryunary ringBinary ringUnary ringNullaryintegralBinary fromIntegerVaddVsubVnegateVmulVdivVexpVcomputeExponentmodV toIntegerVrecipV fieldDivideVroundOpfloorVceilingVtruncV roundAwayV roundToEvenVandVorVxorV complementVlg2VsdivVsmodVcmpValue bitLessThanbitGreaterThanvalEqvalLtvalGt eqCombine lexCombineeqV distinctV lessThanV lessThanEqV greaterThanVgreaterThanEqVsignedLessThanVzeroV joinWordVal joinWordsjoinSeqjoinV splitWordValsplitAtVextractWordValecSplitVreverseV transposeVccatVwordValLogicOp logicBinarywordValUnaryOp logicUnarybitsValueLessThanassertIndexInBounds indexPrim updatePrimfromToV fromThenToVinfFromV infFromThenV barrelShiftershiftLeftReindexshiftRightReindexrotateLeftReindexrotateRightReindexenumerateIntBitsenumerateIntBits' logicShift intShifter wordShifter shiftShrink rotateShrinkerrorV valueToChar valueToStringiteValue mergeWord mergeWord' mergeValue' mergeValue mergeSeqMapparmapV sparkParMap fpBinArithV fpRndModefpRndRNEfpRndRNAfpRndRTPfpRndRTNfpRndRTZ TestReport reportResult reportPropreportTestsRunreportTestsPossibleTestSpectestFntestProp testTotal testPossibletestRptProgresstestClrProgresstestRptFailuretestRptSuccess TestResult FailFalse FailErrorGen runOneTest returnOneTest returnTests dumpableTypetestableTypeGenerators randomValue randomBit randomSize randomInteger randomIntModrandomRational randomWord randomStreamrandomSequence randomTuple randomRecord randomFloatrandomVisPassevalTest testableTypetypeSize typeValuesrunTestsW4ResultW4ErrorW4Defsw4Defsw4ResultW4ConnevalConnW4Eval evalPartialWhat4w4Evalw4ThunkdoEvalgetSymaddDefw4Andw4Notw4ITE addDefEqn addSafety evalErrorassertBVDivisorassertIntDivisorsModAddsModSubsModMult sModNegatesLg2lazyIteindexFront_int indexBack_intindexFront_wordindexBack_wordindexFront_bitsindexBack_bitswordValueEqualsIntegerupdateFrontSym updateBackSymupdateFrontSym_wordupdateBackSym_wordsshrVw4bvShlw4bvLshrw4bvAshrw4bvRolw4bvRorfpRoundingModefpCvtToIntegerfpCvtToRationalfpCvtFromRational$fMonadIOW4Conn $fMonadW4Conn$fApplicativeW4Conn$fFunctorW4Conn$fBackendWhat4$fMonadIOW4Eval $fMonadW4Eval$fApplicativeW4Eval$fFunctorW4Eval floatPrimsevalPrimtoExprFinTypeFTBit FTIntegerFTIntMod FTRationalFTFloatFTSeqFTTupleFTRecord ProverResult AllSatResult ThmResultCounterExample EmptyResult ProverErrorCounterExampleTypeSafetyViolationPredicateFalsified ProverStats ProverCommand pcQueryType pcProverName pcVerbose pcValidate pcProverStats pcExtraDecls pcSmtFilepcExprpcSchemapcIgnoreSafety QueryTypeSatQuery ProveQuery SafetyQuerySatNumAllSatSomeSat predArgTypesfinType unFinType $fShowSatNum$fShowQueryTypeSBVEvalsbvEval SBVResultSBVErrorSBV forallBV_ existsBV_ forallSBool_ existsSBool_forallSInteger_existsSInteger_$fMonadSBVResult$fApplicativeSBVResult$fFunctorSBVResult $fBackendSBV$fMonadIOSBVEval$fMonadSBVEval$fApplicativeSBVEval$fFunctorSBVEval moduleEnvevalExpr evalDeclsevalSel evalSetSel$fMonoidListEnv$fSemigroupListEnv DynamicEnvDEnvdeNamesdeDeclsdeEnv LoadedModulelmName lmFilePath lmModuleId lmInterfacelmModule lmFingerprint LoadedModuleslmLoadedModuleslmLoadedParamModules ModulePathInFileInMemDeclProvenanceNameIsImportedFromNameIsLocalPublicNameIsLocalPrivateNameIsParameterNameIsDynamicDecl ModContext mctxParams mctxDecls mctxNames mctxNameDispmctxTypeProvenacemctxValueProvenanceCoreLint NoCoreLint ModuleEnvmeLoadedModules meNameSeedsmeSolverConfig meEvalEnv meCoreLint meMonoBindsmeFocusedModule meSearchPathmeDynEnvmeSupplyresetModuleEnvinitialModuleEnv focusModule loadedModulesloadedNonParamModuleshasParamModules allDeclGroups focusedEnvmodulePathLabelgetLoadedModulesisLoadedisLoadedParamMod lookupModuleaddLoadedModuleremoveLoadedModule deIfaceDecls$fPPModulePath$fEqModulePath$fMonoidLoadedModules$fSemigroupLoadedModules$fMonoidDynamicEnv$fSemigroupDynamicEnv$fNFDataModuleEnv$fGenericCoreLint$fNFDataCoreLint$fEqDeclProvenance$fOrdDeclProvenance$fShowModulePath$fGenericModulePath$fNFDataModulePath$fShowLoadedModule$fGenericLoadedModule$fNFDataLoadedModule$fShowLoadedModules$fGenericLoadedModules$fNFDataLoadedModules$fGenericDynamicEnv$fGenericModuleEnvversion commitHashcommitShortHash commitBranch commitDirty parseModName parseHelpNameparseProgramWith parseModule parseProgram parseExprWith parseExpr parseDeclWith parseDeclparseDeclsWith parseDeclsparseLetDeclWith parseLetDecl parseReplWith parseReplparseSchemaWith parseSchema IncludeError IncludeFailedIncludeDecodeFailedIncludeParseError IncludeCycleremoveIncludesModuleppIncludeError$fMonadFailNoIncM $fMonadNoIncM$fApplicativeNoIncM$fFunctorNoIncM$fShowIncludeError$fGenericIncludeError$fNFDataIncludeErrorModuleMModuleT unModuleT roLoading roEvalOpts roFileReader ModuleWarningTypeCheckWarningsRenamerWarnings ModuleErrorModuleNotFound CantFindFileBadUtf8 OtherIOErrorModuleParseErrorRecursiveModules RenamerErrors NoPatErrorsNoIncludeErrorsTypeCheckingFailed OtherFailureModuleNameMismatchDuplicateModuleNameImportedParamModuleFailedToParameterizeModDefsNotAParameterizedModule ErrorInFile ImportSource FromModule FromImportFromModuleInstanceimportedModulemoduleNotFound cantFindFilebadUtf8 otherIOErrormoduleParseErrorrecursiveModules renamerErrors noPatErrorsnoIncludeErrorstypeCheckingFailedmoduleNameMismatchduplicateModuleNameimportParamModulefailedToParameterizeModDefsnotAParameterizedModule errorInFilewarntypeCheckWarningsrenamerWarningsemptyRO runModuleT runModuleM getByteReader readBytes getModuleEnv setModuleEnvmodifyModuleEnvgetLoadedMaybe loadingImport loadingModuleloadingModInstance interactiveloadinggetImportSourcegetIface getLoaded getNameSeeds getSupply setMonoBinds setNameSeeds setSupply unloadModule loadedModule modifyEvalEnv getEvalEnvgetFocusedModulesetFocusedModule getSearchPathwithPrependedSearchPath getFocusedEnv getDynEnv setDynEnv setSolvergetSolverConfig withLogger$fPPImportSource$fEqImportSource$fPPModuleError$fNFDataModuleError$fPPModuleWarning$fMonadIOModuleT$fFreshMModuleT$fMonadTModuleT$fMonadFailModuleT$fMonadModuleT$fApplicativeModuleT$fFunctorModuleT$fShowImportSource$fGenericImportSource$fNFDataImportSource$fShowModuleError$fShowModuleWarning$fGenericModuleWarning$fNFDataModuleWarningTCActiontcActiontcLintertcPrimsActTCLinter lintCheck lintModulenoPatloadModuleByPathloadModuleFrom doLoadModulefullyQualified importIface importIfaces moduleFile findModulefindFile addPreludeloadDeps checkExpr checkDecls checkModulecheckSingleModule exprLinter declsLinter moduleLinter typecheck genInferInput ModuleRes ModuleCmdloadModuleByNameSpecMSpecT SpecCacherunSpecT liftSpecT getSpecCache setSpecCachemodifySpecCachemodify specializespecializeExprspecializeMatchwithDeclGroupsspecializeEWherespecializeDeclGroupsspecializeConstdestEProofApps destETApps destEProofAbs destETAbs freshNameinstantiateSchemainstantiateExpr traverseSndW4ProverConfig W4ExceptionW4ExW4PortfolioFailure defaultProver proverNames setupProversatProvesatProveOffline$fExceptionW4Exception$fShowW4ExceptionSBVProverConfigSBVPortfolioException $fExceptionSBVPortfolioException$fShowSBVPortfolioExceptionSmoke Z3NotFound OptionDescroptName optDefaultoptCheckoptHelpoptEffEnvVal EnvStringEnvProgEnvNumEnvBool REPLException FileNotFoundDirectoryNotFound NoPatErrorNoIncludeErrorModuleSystemError EvalPolyErrorTypeNotTestableEvalInParamModule SBVExceptionREPLunREPLlNamelPathrunREPLraisecatchfinallyrethrowEvalError getPromptclearLoadedMod setLoadedMod getLoadedMod setEditPath getEditPath clearEditPath setSearchPathprependSearchPathgetProverConfigshouldContinuestop unlessBatchasBatch disableLet enableLet getLetEnabledvalidEvalContextupdateREPLTitlesetUpdateREPLTitle setPutStr getPutStr getLoggerrPutStr rPutStrLnrPrint getExprNames getTypeNamesgetPropertyNames getModNamesuniqifysetUser tryGetUsergetUser getKnownUsergetUserShowProverStatsgetUserProverValidate userOptionsparsePPFloatFormat getUserSatNum whenDebug smokeTest$fPPREPLException$fExceptionREPLException$fMonadMaskREPL$fMonadCatchREPL$fMonadThrowREPL $fFreshMREPL$fMonadBaseControlIOREPL$fMonadBaseIOREPL $fMonadIOREPL $fMonadREPL$fApplicativeREPL $fFunctorREPL $fIsEnvVal[] $fIsEnvVal(,) $fIsEnvValInt$fIsEnvValBool $fPPSmoke$fShowREPLException $fShowEnvVal $fShowSmoke $fEqSmokeVList evalDeclGroupevaluate $fMonoidEnv$fSemigroupEnvQCModeQCRandom QCExhaustCommandExitCode CommandOk CommandError CommandBodyExprArg FileExprArgDeclsArg ExprTypeArg ModNameArg FilenameArg OptionArgShellArgHelpArgNoArg CommandDescrcNamescArgscBodycHelp cLongHelpCommand AmbiguousUnknown commandList runCommandqcCmdsatCmdproveCmdonlineProveSatofflineProveSat moduleCmd loadPreludeloadCmd setOptionCmd handleCtrlC replParse replParseExprinteractiveConfig liftModuleCmdmoduleCmdResult replCheckExpr replEvalExprsanitize splitCommand findCommandfindCommandExact findNbCommand parseCommand$fOrdCommandDescr$fEqCommandDescr$fShowCommandDescr $fEqQCMode $fShowQCMode unsupportedfpReprwhat4-1.0-IcCGmY3T3YeXUBLCM24PeWhat4.BaseTypesFloatPrecisionRepr GHC.MaybeNothingpreludeContents floatContents arrayContentscryptolTcContentsGHC.ShowShow nameVariant nameVariantsmarkdownlatexTokenOpOtherVirtualExplicit splitQual dropWhite byteForCharnumToken ComplementGEQLEQHashEqualPlusMinusMulAtExpModDivBlock AlexInputInpinputalexInputPrevCharalexPosLexSInCharInString InCommentNormalAction startComment endComment addToCommentstartEndComment startString endString addToString startCharendChar addToChar mkQualIdentmkQualOpemitemitS fromDigit fnumToken alexGetByte isExplicit startsLayoutlayoutvirtnUniquenInfonIdentnFixitynLocppNameRecsNextTyParamNummkRecordmkEApp anonTyApp mkPrimDeclmkDocmkModulemkAnonymousModulemkModuleInstanceSsTokenssPrevTokParseMPunP parseStringparselexerP happyError errorMessage customErrorexpected mkModNamemkSchemagetNamegetNumgetChrgetStrnumLitfracLitintValmkFixity mkTupleSel fromStrLitvalidDemotedTypeunOpbinOpeFromTo eFromToType exprToNumT exportDecl exportNewtypemkParFun mkParType changeExport mkTypeInstmkTParammkTySyn mkPropSynpolyTermmkPoly mkProperty mkIndexedDecl mkIndexedExpr mkGeneratemkIfmkPrimTypeDecldistrLocmkProp ufToNamed selExprToSels annotTopDsannotDsannotDannotB annotTySyn annotPropSyn annotPrimTypeannotParameterType checkSigstoSigtoPragmatoFixitytoDocsghc-prim GHC.TypesTrueFalseknownSupportedFloat solveRingSeqsolveSignedCmpSeqpBin tryGeqKThan tryGeqThanK geqByInterval tryCancelVar tryEqMulConst tryEqAddInf tryAddConsttryLinearSolutionmatchLinearUnifier matchLineardefaultFreeVar plainSubst typeSelectsolverlogger loadTcPrelude unsolvableflatGoalInt solveSelectormkSelSln checkTypeIsexprType exprSchema convertible checkDecl simpHasGoals quickSolverproveImplicationIO checkTUserappTy doCheckType checkProp checkKindinstantiateWithNamesmkPrimmkPrim'appTyssmallestinferP inferMatch inferCArm guessType generalize checkMonoBinLocalInst instTyParams freshenName computeEnv checkTyParamsmakeValParamDefcheckValParamsUnforced BlackHoleForcedIOCheckAll CheckOverlap CheckNonerwNameUseCountrecordcurLoclocatedwithLocgetNS shadowNames'checkEnvcontainsOverlap typeExists mkFakeName renameSchema renameQual renameMatch renamePat renamePatsmkEInfixfpConst updateFrontupdateFront_word updateBackupdateBack_wordListEnvleVarsleStatic EvalPrims evalNewtypefillHole isValueTypeetaWordetaDelayevalDecl evalListEnvevalComp branchEnvs evalMatchhashbranchdirty getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameHappyStkenvSeen envIncPath envFileReader getIncPath withIncPathNoIncM fromIncPath includeFailedpushPath failsWith collectErrorsData.TraversablemapMnoIncludeModulenoIncludeProgram noIncTopDeclresolveInclude readIncludedoW4Eval prepareQuery singleQuery runProverprocessResults parseValues parseValueCheckerUserEnv eLoadedMod eEditFile eContinueeIsBatch eModuleEnveUserEnveLogger eLetEnabled eUpdateTitle defaultRWmkPrompt mkUserEnv checkBase fromVListvFinPoly bitsToIntegersignedBitsToIntegercmpOrder lexComparelexSignedComparesplitV indexPrimOnecommands nbCommands nbCommandListexpectedCoveragesafeCmd cmdProveSatmkSolverResultbyteStringToIntegerbytestring-0.10.8.2Data.ByteString.Internal ByteString integer-gmpGHC.Integer.TypeIntegerreplCheckDeclsbindItVariablebindItVariableValbindItVariables sanitizeEnduncons