h&1y߀$      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS T UVWXYZ [ \ ] ^ _ ` 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 { | } ~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""#################################################$$%%%%%%&&&&&&&&&&'''''''''''''''''''''((((((((((((((()**************************************************+++++++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,-------------------------------------------------------------------------------------------------------------------...................................////0000000000000000000000000000000000000001111111111111111222222222222233444445566666666666666666666666666666666666666666666666677777777777777777777777777777777788999999999999999999999::::;;;;;;;;;;;;;;;;;;;;;<<<<<===========================================================================================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>??????????????????????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCDDDDEEEEEEFFFFFFFFFGGGGGGGGGHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSTTUVVVVVWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^________________________________```````````````````````````````````````````````aaaaaaaaaaaaaabbbbbbbbbbbccccccccccccccdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeefffggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjklllll l l l l l l l l l l l l l l l l l l l l l l l l m n n n n n n % % % % % % % % % % % % % % % % % o o o o o o o o o o o o o o p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!p!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!q!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!s"s"s"s"s"s"s"s"s"s"s"s"s"s"s"s"s"t"t"t"t"t"t"t"t"t"t"t"t"t"t"t"u"u"u"u"u"u"u"u"u"u"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v"v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#v#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#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y#y(c) Levent ErkokBSD3erkokl@gmail.com experimental Safe-Inferred`/cryptolThe key, which can be 128, 192, or 256 bits. Represented as a sequence of 32-bit words.cryptolAES state. The state consists of four 32-bit words, each of which is in turn treated as four GF28's, i.e., 4 bytes. The T-Box implementation keeps the four-bytes together for efficient representation.$cryptolAn element of the Galois Field 2^8, which are essentially polynomials with maximum degree 7. They are conveniently represented as values between 0 and 255.$cryptol4Rotating a state row by a fixed amount to the right.cryptolThe  InvMixColumns transformation, as described in Section 5.3.3 of the standard. Note that this transformation is only used explicitly during key-expansion in the T-Box implementation of AES.$cryptolDefinition of round-constants, as specified in Section 5.2 of the AES standard. We only need up to the 11th value for AES-128, and fewer than that for AES-192 and AES-256.$cryptolThe AES sbox transformation$cryptol!The inverse s-box transformation.$cryptol.T-box table generation function for encryption$cryptol&First look-up table used in encryption$cryptol'Second look-up table used in encryption$cryptol&Third look-up table used in encryption$cryptol'Fourth look-up table used in encryption$cryptol.T-box table generating function for decryption$cryptol&First look-up table used in decryption$cryptol'Second look-up table used in decryption$cryptol&Third look-up table used in decryption$cryptol'Fourth look-up table used in decryption  (c) 2014-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferredb cryptolThis 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.  (c) 2019 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferredc# cryptol'Compute a fingerprint for a bytestring.cryptolAttempt to compute the fingerprint of the file at the given path. Returns $ in the case of an error.  z(c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe"c$$$$$$$ Safe-Inferredc !"#$%&''&$%#! " Safe-Inferrede(cryptolStatistics returned by -.This is extremely crude compared to the full analysis that criterion can do, but is enough for now.-cryptolBenchmark the application of the given function to the given input and the execution of the resulting IO action to WHNF, spending at least the given amount of time in seconds to collect measurements.()*+,-()*+,-(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe;=gz7cryptol 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./0123456789:;<789:3456The 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.(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe%&89:;=cryptolReturns $3 if the first range is contained in the second one.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 provisionalportableSafe";=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.cryptolZero-based tuple selection. Optionally specifies the shape of the tuple (one-based).cryptolRecord 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)cryptolShow a list of selectors as they appear in a nested selector in an update.(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe;= cryptol(Natural numbers with an infinity elementcryptol&Some algebraic properties of interest: 1 * x = x x * (y * z) = (x * y) * z 0 * x = 0 x * y = y * x x * (a + b) = x * a + x * bcryptol&Some algebraic properties of interest: x ^ 0 = 1 x ^ (n + 1) = x * (x ^ n) x ^ (m + n) = (x ^ m) * (x ^ n) x ^ (m * n) = (x ^ m) ^ ncryptolnSub x y = Just z iff z is the unique value such that Add y z = Just x. cryptol Rounds down. https://github.com/ghc/ghc/blob/master/compiler/parser/Lexer.x0$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ Safe-Inferred"-EcryptolVirtual layout blockcryptol6An explicit layout block, expecting this ending token.cryptol+These tokens start an implicit layout blockcryptol)These tokens end an implicit layout blockcryptolThese tokens start an explicit "paren" layout block. If so, the result contains the corresponding closing paren.cryptol&Make a virtual token of the given type  (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Trustworthy"cryptolReturns 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.cryptolReturns the tokens and the last position of the input that we processed. The tokens include whte space tokens.(c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred"%&-;=cryptolA 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?The associativity and precedence level of infix operators. $* indicates an ordinary prefix operator.$cryptolWhere this name was definedcryptolCompare two names by the way they would be displayed. This is used to order names nicely when showing what's in scope$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 parentheses.cryptol9Pretty-print a name with its source location information.cryptol;Primtiives must be in a top level module, at least for now.cryptol'Get the module path for the given name.cryptolGet the module path for the given name. The name should be a top-level name.cryptol?Get the name of the top-level module that introduced this name.cryptolGet the name of the top-level module that introduced this name. Works only for top-level names (i.e., that have original names)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.cryptolMake a local name derived from the given name. This is a bit questionable, but it is used by the translation to SAW Core cryptol(This is used when instantiating functorscryptolIt's assumed that we're looking things up that we know already exist, so this will panic if it doesn't find the name.cryptolIt's assumed that we're looking things up that we know already exist, so this will panic if it doesn't find the name.cryptol Module containing the parameter cryptol Name of the module parameter cryptol Location cryptol Name in the signature 1hijklmn1klmnhijSafe";=3cryptolBuilt-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]cryptol1-1 constants. If you add additional user-visible constructors, please update primTys.cryptolNumberscryptolInfcryptolBitcryptolIntegercryptolFloatcryptol Z _cryptol Rationalcryptol  Array _ _cryptol [_] _cryptol _ -> _cryptol  (_, _, _)cryptolAn abstract typecryptolPredicate symbols. If you add additional user-visible constructors, please update primTys.cryptol _ == _cryptol _ /= _cryptol _ >= _cryptol fin _cryptol prime _cryptolHas sel type field does not appear in schemascryptol Zero _cryptol Logic _cryptol Ring _cryptol  Integral _cryptol Field _cryptol Round _cryptol Eq _cryptol Cmp _cryptol  SignedCmp _cryptol  Literal _ _cryptol LiteralLessThan _ _cryptol FLiteral _ _ _cryptolValidFloat _ _9 constraints on supported floating point representaitonscryptol/This is useful when simplifying things in placecryptolDittocryptolType constants.cryptolKinds, classify types.cryptolThis is used for pretty prinitng. XXX: it would be nice to just rely in the info from the Prelude.5 Safe-Inferred-;=cryptol4A non-empty collection of names used by the renamer.cryptol Non-emptycryptol Non-empty  Safe";=lcryptolPath to cryptol modulecryptol Error messagecryptol Function namecryptol Error message Safe-Inferred %&-;=cryptolExistential wrapper around a .cryptol(Types which can be returned from libffi.=The Storable constraint is so that we can put them in arrays.cryptol3Types which can be converted into libffi arguments.=The Storable constraint is so that we can put them in arrays.cryptol(An implementation of a foreign function.$cryptolWe don't need this to call the function but we want to keep the library around as long as we still have a function from it so that it isn't unloaded too early.cryptolA source from which we can retrieve implementations of foreign functions.$cryptolThe file path of the .$cryptolThe $ wraps the pointer returned by $, where the finalizer calls $ when the library is no longer needed. We keep references to the $ in each foreign function that is in the evaluation environment, so that the shared library will stay open as long as there are references to it.$cryptolWe support explicit unloading of the shared library so we keep track of if it has already been unloaded, and if so the finalizer does nothing. This is updated atomically when the library is unloaded.cryptolGet the file path of the .cryptolLoad a  for the given Cryptol file path. The file path of the shared library that we try to load is the same as the Cryptol file path except with a platform specific extension.cryptolGiven the path to a Cryptol module, compute the location of the shared library we'd like to load.cryptolExplicitly unload a  immediately instead of waiting for the garbage collector to do it. This can be useful if you want to immediately load the same library again to pick up new changes.The  must not= be used in any way after this is called, including calling s loaded from it.cryptolLoad a $ with the given name from the given .cryptolCall a  with the given arguments. The type parameter decides how the return value should be converted into a Haskell value.  Safe v cryptolCheck 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 provisionalportableSafecryptolAn "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.cryptolRetrieve the elements of the record in canonical order of the field namescryptol6Return a list of field/value pairs in canonical order.cryptolRetrieve the elements of the record in display order of the field names.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 fieldcryptolUpdate the value of a field by applying the given function. If the field is not present in the record, return Nothing.cryptolTraverse the elements of the given record map in canonical order, applying the given action.cryptol5Apply the given function to each element of a record.cryptolThe 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 a will be returned, indicating which record is missing the field, and returning the name of the missing field.The  displayOrder of the resulting record will be taken from the first argument (rather arbitrarily).cryptolPure version of (c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe "%&-89:;=@cryptolA  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]cryptolLocation informationcryptolp <- ecryptol#Are we setting or updating a field.cryptolnon-empty list  x.y = ecryptolDescription of functions. Only trivial information is provided here by the parser. The NoPat pass fills this in as required.cryptol$Name of this function, if it has onecryptolnumber of previous arguments to this function bound in surrounding lambdas (defaults to 0)cryptolPrefix operator.cryptol  -cryptol  ~cryptol  xcryptol  0x10cryptol  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 .. 10 by 2 : t ]cryptol  [10 .. 1 down by 2 : t ]cryptol  [ 1 .. < 10 : t ]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 typecryptol  \x y -> xcryptolposition annotationcryptol splitAt x  (Introduced by NoPat)cryptol (e)  (Removed by Fixity)cryptol  -1, ~1cryptol Literals.cryptol0x10 (HexLit 2)cryptol acryptol 1.2e3cryptol "hello"cryptol&Information about fractional literals.cryptol;Infromation about the representation of a numeric constant.cryptoln-digit binary literalcryptoln-digit octal literalcryptoloverloaded decimal literalcryptoln-digit hex literalcryptolpolynomial literalcryptolA top-level module declaration.cryptol%Export information for a declaration.cryptol1Input at the REPL, which can be an expression, a let+ statement, or empty (possibly a comment).cryptol0A declaration for a type with no implementation.cryptol:parameters are in the order used by the type constructor.cryptol Type namecryptol Type paramscryptolConstructor function namecryptolBodycryptolBindings. 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.cryptol Defined thingcryptol Parameterscryptol DefinitioncryptolOptional type sigcryptolInfix operator?cryptolOptional fixity infocryptolOptional pragmascryptolIs this a monomorphic bindingcryptolOptional doc stringcryptol&The list of names following an import.cryptolAn import declaration.cryptol exists only during parsingcryptolA module parameter declaration. *import interface A import interface A as B.The name of the parameter is derived from the as clause. If there is no as clause then it is derived from the name of the interface module.If there is no as clause, then the type/value parameters are unqualified, and otherwise they are qualified.cryptolSignature for parametercryptolQualified for actual paramscryptolParameter name (for inst.) Note that this is not resolved in the renamer, and is only used when instantiating a functor. cryptolOptional documentationcryptolFilled in by the renamer. Maps the actual (value/type) parameter names to the names in the interface module. cryptol6A constraint or type synonym declared in an interface.cryptol2Interface Modules (aka types of functor arguments)IMPORTANT: Interface Modules are a language construct and are different from the notion of "interface" in the Cryptol implementation.Note that the names *defined* in an interface module are only really used in the other members of the interface module. When an interface module is "imported" as a functor parameter these names are instantiated to new names, because there could be multiple paramers using the same interface. cryptolAdd things in scopecryptolType parameterscryptol5Constraints on the type parameters and type synonyms.cryptolType and constraint synonymscryptolValue parameterscryptolA value parameter for a module.cryptolname of value parametercryptolschema for parametercryptoloptional documentationcryptolinfo for infix usecryptolA type parameter for a module.cryptolname of type parametercryptolkind of parametercryptoloptional documentationcryptolinfo for infix usecryptolnumber of the parametercryptolA simple declaration. Generally these are things that can appear both at the top-level of a module and in `where` clauses.cryptolA type signature. Eliminated in NoPat--after NoPat signatures are in their associated BindcryptolA fixity declaration. Eliminated in NoPat---after NoPat fixities are in their associated BindcryptolA pragma declaration. Eliminated in NoPat---after NoPat fixities are in their associated BindcryptolA non-recursive binding.cryptol9A group of recursive bindings. Introduced by the renamer.cryptolA pattern binding. Eliminated in NoPat---after NoPat fixities are in their associated BindcryptolA type synonym.cryptolA constraint synonym.cryptol-Keeps track of the location of a declaration.cryptolThe name of an imported modulecryptolA top-level module cryptol'The module in scope with the given name cryptol&An argument in a functor instantiation cryptolAn argument that is a module cryptolAn argument that is a parameter cryptol>Arguments adds extra parameters to decls. ("backtick" import) cryptol+A named argument in a functor instantiation cryptol(All arguments in a functor instantiation cryptolSingle parameter instantitaion cryptolSingle parameter instantitaion using this anonymous module. (parser only) cryptolThings that maybe appear in an interface/parameter block. These only exist during parsering. cryptolparameter type T : # (parser only) cryptolparameter someVal : [256] (parser only) cryptolA delcaration in an interface cryptol !parameter type constraint (fin T) cryptolA declaration that may only appear at the top level of a module. The module may be nested, however. cryptol@newtype T as = t cryptol include File (until NoInclude) cryptol parameter ... (parser only) cryptol submodule M where ... cryptol import X cryptol import interface X ... cryptol interface constraint cryptolA nested module. cryptolA top-level module cryptolMaps names in the original functor with names in the instnace. Does *NOT* include the parameters, just names for the definitions. This *DOES* include entrirs for all the name in the instantiated functor, including names in modules nested inside the functor. cryptol%Different flavours of module we have. cryptol(The instance is filled in by the renamer cryptolA module for the pre-typechecker phasese. The two parameters are:mname the type of module names. This is because top-level and nested modules use differnt types to identify a module.name the type of identifiers used by declarations. In the parser this starts off as < and after resolving names in the renamer, this becomes Name. cryptolName of the module$cryptol"A record with located ident fields cryptol#A string with location information. cryptol(An identifier with location information. cryptol!A name with location information. cryptol1Imports of top-level (i.e. "file" based) modules. cryptol9Get the module parameters of a module (new module system) cryptolConversational3 printing of kinds (e.g., to use in error messages)cryptol  (x # y)cryptol  [1, 3 ...]cryptol a + b  (Removed by Fixity)/0123456789:;<\g \g 789: 3456 FFIArray [n, m, p] TcryptolType of a foreign function.cryptolNote: any type variables within this function type must be bound here.cryptolThe size of the Cryptol typecryptol,The machine word size that it corresponds tocryptolExponentcryptol Precisioncryptol-The machine float size that it corresponds to$(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe"d|(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe"-;= $cryptol=Keep track of the type parameters as they appear in the input$cryptol?This is how we derive the name of a module parameter from the  import source declaration.$cryptolInput fields are reversed!$cryptolInput expression are reversed$cryptolWARNING: This is a bit of a hack. It is used to represent anonymous type applications.$cryptolGenerate a signature and a binding for value declarations with no implementation (i.e. primitive or foreign declarations). The reason for generating both instead of just adding the signature at this point is that it means the 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 and foreigns.$cryptolFix-up the documentation strings by removing the comment delimiters on each end, and stripping out common prefixes on all the remaining lines.$cryptolMake an ordinary module$cryptol'Make an unnamed module---gets the name Main.$cryptol/Make a module which defines a functor instance.$cryptol The import cryptolThe insantiation $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%$%%%%%%%%%%%%%%%%%%%%%%%$%$%%%$%%%%%%%%$$%%%%%%%%%%$&(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeUcryptolThe names defined by a newtype.%cryptolThe names defined and used by a group of mutually recursive declarations.cryptol4The names defined and used by a single declarations.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.cryptolThe names defined by a pattern. These will always be unqualified names.%cryptol&The names defined and used by a match.%cryptolExepcted one kind (first one) but found the other (second one)+(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe%&;=3:cryptol Name of thingcryptolTypecryptolPragmascryptolIs this an infix thingcryptolFixity informationcryptol DocumentationcryptolDeclarations in a module. Note that this includes things from nested modules, but not things from nested functors, which are in .cryptolXXX: Maybe arg info? Also, with the current implementation we aim to complete remove functors by essentially inlining them. To achieve this with just interfaces we'd have to store here the entire module, not just its interface. At the moment we work around this by passing all loaded modules to the type checker, so it looks up functors there, instead of in the interfaces, but we'd need to change this if we want better support for separate compilation. cryptol(Information about the names in a module.cryptolName of this submodulecryptolThings nested in this modulecryptolThings defined in this modulecryptol Subset of  that is publiccryptol Documentationcryptol8The interface repersenting a typecheck top-level module.cryptolInfo about names in this modulecryptolModule parameters, if anycryptol?All things defines in the module (includes nested definitions)cryptolRemove the name of a module. This is useful for dealing with collections of modules, as in `Map (ImpName Name) (IfaceG ())`.cryptolAccess the name of a module.cryptol Is this interface for a functor.cryptol$Produce a PrimMap from an interface.NOTE: the map will expose both public and private names. NOTE: this is a bit misnamed, as it is used to resolve known names that Cryptol introduces (e.g., during type checking). These names need not be primitives. A better way to do this in the future might be to use original names instead (see #1522).cryptolGiven an interface computing a map from original names to actual names, grouped by namespace.'',Safe;5cryptolAdd a binding name to the export list, if it should be exported.cryptolAdd 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 "%&'(;=>cryptolMutually recursive declarationscryptolNon-recursive declarationcryptolType 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. The included type gives the type of the record being updatedcryptol If-then-elsecryptolList comprehensions The types cache the length of the sequence and its element type.cryptolUse of a bound variablecryptolFunction ValuecryptolType applicationcryptolFunction applicationcryptolFunction valuecryptolSource location informationcryptolProof 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 .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 Cryptol module.cryptolParameters grouped by "import".cryptolFunctors directly nested in this module. Things further nested are in the modules in the elements of the map.cryptolSubmodules, functors, and interfaces nested directly in this modulecryptol$Panics if the entity is not a modulecryptolFind all the foreign declarations in the module and return their names and FFIFunTypes.cryptolFind all the foreign declarations that are in functors. This is used to report an errorcryptolIs this a parameterized module?cryptolConstruct a primitive, given a map to the unique primitive name.cryptolMake an expression that is error% pre-applied to a type and a message.cryptolRemove outermost locationscryptolDeconstruct 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.3456  3456.(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe 89:C/(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-InferredFcryptol&All ways to split a type in the form: a + t1, where a is a variable.cryptol,Check if we can express a type in the form: a + t1.cryptol,Check if we can express a type in the form: k + t1, where k is a constant > 0. This assumes that the type has been simplified already, so that constants are floated to the left. cryptol,Check if we can express a type in the form: k * t1, where k is a constant > 1. This assumes that the type has been simplified already, so that constants are floated to the left. 0(c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeI cryptollower bound (inclusive)cryptolupper bound (inclusive) If there is no upper bound, then all *natural* numbers.cryptol!Only meaningful for numeric typescryptol1What we learn about variables from a single prop.cryptolFinite positive number.  [1 .. inf).cryptolReturns $, when the intervals definitely overlap, and % 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 valuecryptolAny finite valuecryptolExactly this value$$1Safe";=K cryptolSolved, assuming the sub-goals.cryptolWe could not solve the goal.cryptolThe goal can never be solved.  2(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-InferredQBcryptolThis 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.%cryptolCheck 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.%cryptolSolve 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.%cryptolSolve 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.cryptolSolve Literal constraints.  3(c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-InferredQ4 Safe-InferredWcryptol 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 >= t%cryptol Try to solve t >= K%cryptolTry 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 >= t2%cryptol1K1 * t1 + K2 * t2 + ... = K3 * t3 + K4 * t4 + ...%cryptol %(t1 + t2 = Inf, fin t1) ~~> t2 = Inf%cryptol?Check for addition of constants to both sides of a relation. ((K1 + K2) + t1) R (K1 + t2) ~~> (K2 + t1) R t2This 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.%cryptolIs this a sum of products, where the products have constant coefficients?5 TrustworthyW6(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe %&89:c|cryptolReplaces free variables. To prevent space leaks when used with large  values, every instance of > should satisfy a strictness property: Forcing evaluation of  s x> should also force the evaluation of all recursive calls to  s7. This ensures that unevaluated thunks will not cause # values to be retained on the heap.cryptol1Reasons to reject a single-variable substitution.cryptol - maps to a type containing the same variable.cryptol  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 t 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 tps. This ensures that applying the substitution will not permit any type parameter to escape from its scope.Invariant 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 . 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.cryptolA 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.cryptol(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe%&y cryptol1An SMT solver packed with a logger for debugging.%cryptolThe actual solver%cryptol For debuggingcryptolStart a fresh solver instancecryptolShut down a solver instancecryptol3Execute a computation with a fresh solver instance.%cryptol,Load the definitions used for type checking.cryptol"Returns goals that were not provedcryptol4Check 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 goalcryptol Assumes no And%cryptolSearch in this paths ?Safe";=cryptol?Various errors that might happen during type checking/inferencecryptolExpected kind, inferred kindcryptolNumber of extra parameters, kind of result (which should not be of the form _ -> _)cryptol.A type variable was applied to some arguments.cryptol$Type-synonym, number of extra paramscryptol/Who is missing params, number of missing paramscryptol+The type synonym declarations are recursivecryptolExpected type, inferred typecryptolName of module parameter, expected scehema, actual schema. This may happen when instantiating modules.cryptol'Unification results in a recursive typecryptolA constraint that we could not solve, usually because there are some left-over variables that we could not infer.cryptolA constraint that we could not solve and we know it is impossible to do it.cryptol3A constraint (with context) that we could not solvecryptolType wild cards are not allowed in this context (e.g., definitions of type synonyms).cryptolUnification variable depends on quantified variables that are not in scope.cryptolQuantified type variables (of kind *) need to match the given type, so it does not work for all types.cryptolToo many positional type arguments, in an explicit type instantiationcryptolKind other than % or # given to parameter of type synonym, newtype, function signature, etc.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).cryptol Bare expression of the form `{_}cryptolKind is not supported for FFIcryptolType is not supported for FFIcryptol1Constraint guards may only apper at the top-levelcryptolAll declarataions in a recursive group involving constraint guards should have signaturescryptol:The given constraint may not be used as a constraint guardcryptolThis is for errors that don't fit other cateogories. We should not use it much, and is generally to be used for transient errors, which are due to incomplete implementation.cryptol-Should the first error suppress the next one.cryptolWhen we have multiple errors on the same location, we show only the ones with the has highest rating according to this function.cryptol=This picks the names to use when showing errors and warnings.::@(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred"%&-;=bcryptolThis is what's returned when we lookup variables during kind checking.cryptolLocally bound variable.cryptolAn outer binding.cryptolkinds of (known) vars.cryptol,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 substitutioncryptolThese 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.cryptolSelector constraints that have been solved (ref. iSolvedSelectorsLazy)cryptolOrdinary constraintscryptolTuple/record projection constraints. These are separate from the other constraints because solving them results in actual elaboration of the term, indicating how to do the projection. The modification of the term is done using lazyness, by looking up a thunk ahead of time (iSolvedHasLazy in RO), which is filled in when the constrait is solved ( iSolvedHas ). See also .cryptolNested scopes we are currently checking, most nested first. These are basically partially built modules.cryptolTypes of variables that we know about. We don't worry about scoping here because we assume the bindings all have different names.cryptol!Read-only component of the monad.cryptolSource code being analysedcryptolType of variable that are in scope These are only parameters vars that are in recursive component we are checking at the moment. If a var is not there, keep looking in the cryptolType variable that are in scopecryptolAn exteral top-level module. We need the actual module when we instantiate functors, because currently the type-checker desugars such modules.cryptolExternal top-level signatures.cryptolThese are things we know about, but are not part of the modules we are currently constructing. XXX: this sould probably be an interface NOTE: External functors should be looked up in 1 and not here, as they may be top-level modules.cryptolNOTE: 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.cryptolWhen this flag is true, retain source location information in typechecked termscryptolThe Text is docscryptolThe 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 scopecryptolSignatures in scopecryptolPrivate state of type-checkercryptol=Should local bindings without signatures be monomorphized?cryptolAre we tracking call stacks?cryptol&Where to look for Cryptol theory file.cryptolThis is used when the type-checker needs to refer to a predefined identifier (e.g., number).cryptol$The supply for fresh name generationcryptol"Solver connection for typecheckingcryptolThe initial seeds, used when checking a fresh program. XXX: why does this start at 10?cryptolThis introduces a new "selector scope" which is currently a module. I think that it might be possible to have selectors scopes be groups of recursive declarations instead, as we are not going to learn anything additional once we are done with the recursive group that generated the selectors constraints. We do it at the module level because this allows us to report more errors at once.A selector scope does the following: * Keep track of the Has constraints generated in this scope * Keep track of the solutions for discharged selector constraints: - this uses a laziness trick where we build up a map containing the solutions for the Has constraints in the state - the *final* value for this map (i.e., at the value the end of the scope) is passed in as thunk in the reader component of the moment - as we type check expressions when we need the solution for a Has constraint we look it up from the reader environment; note that since the map is not yet built up we just get back a thunk, so we have to be carefule to not force it until *after* we've solved the goals - all of this happens in the `rec` block below * At the end of a selector scope we make sure that all Has constraints were discharged. If not, we *abort* further type checking. The reason for aborting rather than just recording an error is that the expression which produce contains thunks that will lead to non-termination if forced, and some type-checking operations (e.g., instantiation a functor) require us to traverse the expressions.cryptolThe 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.cryptolReport an error.cryptolIf there are any recoded errors than abort firther type-checking.cryptolRetrieve the mapping between identifiers and declarations in the prelude.cryptolRecord some constraints that need to be solved. The string explains where the constraints came from.cryptolThe constraints are removed, and returned to the caller. The substitution IS applied to them. cryptol'Add a bunch of goals that need solving.cryptolCollect the goals emitted by the given sub-computation. Does not emit any new goals.cryptolRecord 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.cryptolAdd a previously generated Has constraintcryptolGet the Has 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.cryptolGenerate a new free type variable that depends on these additional type parameters.cryptolCheck that the given "flavor" of parameter is allowed to have the given type, and raise an error if notcryptol"Generate a new free type variable.cryptolGenerate a new version of a type parameter. We use this when instantiating module parameters (the "backtick" imports)cryptolGenerate an unknown type. The doc is a note about what is this type about.cryptol8Record that the two types should be syntactically equal.cryptolApply the accumulated substitution to something with free type variables.cryptol5Get the substitution that we have accumulated so far.cryptolAdd to the accumulated substitution, checking that the datatype invariant for  is maintained.cryptolVariables 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 typecryptol8Lookup an external (i.e., previously loaded) top module.cryptolGet information about the things defined in the module. Note that, in general, the interface may contain *more* than just the definitions in the module, however the ifNames3 should indicate which ones are part of the module.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 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.cryptol.Retrieve 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. cryptolThe sub-computation is performed with the given type parameter in scope.cryptolExecute the given computation in a new top scope. The sub-computation would typically be validating a module.cryptolStart a new submodule scope. The imports and exports are just used to initialize an empty module. As we type check declarations they are added to this module's scope. cryptolUpdate the current scope (first in the list). Assumes there is one.cryptol/Get an environment combining all nested scopes.cryptolThe sub-computation is performed with the given type-synonym in scope.cryptolThe sub-computation is performed with the given abstract function in scope.cryptol)Add some assumptions for an entire modulecryptolPerform the given computation in a new scope (i.e., the subcomputation may use existential type variables). This is a different kind of scope from the nested modules one.cryptolThe sub-computation is performed with the given variable in scope.cryptolThe sub-computation is performed with the given variables in scope.cryptolThe sub-computation is performed with the given variables in scope.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.As 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 }~* 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). cryptolThe sub-computation is about the given range of the source code.cryptol See commentA(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred%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, solvedB(c) 2015-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred" cryptolexpected, actualcryptolexpected a mono type, got this%cryptolIdentify proof obligations that are obviously true. We can filter these to avoid clutter%cryptol$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.%cryptolCheck that the expression is well-formed, and compute its type. Reports an error if the expression is not of a mono type.%cryptolCheck that the expression is well-formed, and compute its schema.%cryptol2Check if the one type is convertible to the other.%cryptolCheck a declaration. The boolean indicates if we should check the siganture  C Safe-Inferred"-cryptolRewrite declarations to add the given module parameters. Assumes the renaming due to the instantiation has already happened. The module being rewritten should not contain any nested functors (or module with only top-level constraints) because it is not clear how to parameterize the parameters.DSafe`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 a 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 E(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred%&ʰ%cryptol Integral a%cryptolField a or FLiteral %cryptol Simplify Has! constraints as much as possible.cryptolTry to clean-up any left-over constraints after we've checked everything in a module. Typically these are either trivial things, or constraints on the module's type parameters.cryptolProve an implication, and return any improvements that we computed. Records errors, if any of the goals couldn't be solved.cryptolTries to prove an implication. If proved, then returns `Right (m_su :: InferM Subst)` where m_su is an  computation that results in the solution substitution, and records any warning invoked during proving. If not proved, then returns `Left (m_err :: InferM ())`, which records all errors invoked during proving.%cryptolFacts we can knowcryptolNeed to solve thesecryptolLeft: contradicting goals, Right: inferred types, unsolved goals.&cryptol+Whether to remove duplicate goals in errorscryptolChecking this functioncryptolThese appear in the env., and we should not try to default themcryptolType parameterscryptolAssumed constraintcryptolCollected constraintsF(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred- cryptolCheck a type signature. Returns validated schema, and any implicit constraints that we inferred.cryptolValidate parsed propositions that appear in the guard of a PropGuard.Note that we don't validate the well-formedness constraints here---instead, they'd be validated when the signature for the auto generated function corresponding guard is checked.>We also check that there are no wild-cards in the constraints.cryptolCheck a module parameter declarations. Nothing much to check, we just translate from one syntax to another.cryptol!Check a type-synonym declaration.cryptol'Check a constraint-synonym declaration.cryptolCheck a newtype declaration. XXX: Do something with constraints.&cryptol%Check something with type parameters.When we check things with type parameters (i.e., type schemas, and type synonym declarations) we do kind inference based only on the immediately visible body. Type parameters that are not mentioned in the body are defaulted to kind . If this is not the desired behavior, programmers may add explicit kind annotations on the type parameters.+Here is an example of how this may show up: !f : {n}. [8] -> [8] f x = x + `n Note that n does not appear in the body of the schema, so we will default it to , 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: It 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.&cryptolCheck 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 type&cryptol2The 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 kind&cryptolType that needs to be checkedcryptolExpected kind (if any)cryptol Checked type&cryptol#Proposition that need to be checkedcryptolChecked representation&cryptolKind-checked typecryptolExpected kind (if any)cryptol Inferred kindcryptol$A type consistent with expectations.  G(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred"!&cryptolInstantiate 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)where - There will be one `ETApp t` for each insantiated type parameter; - there will be one # for each constraint on the schema;  H(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred"cryptolNote 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.&cryptolNot really any distinction between global and local, all names get the module prefix added, and a unique id.I(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred"%&-;=cryptolThe  is used by the renamer to determine what identifiers refer to.cryptolThis "joins" two naming environments by matching the text name. The result maps the unique names from the first environment with the matching names in the second. This is used to compute the naming for an instantiated functor: * if the left environment has the defined names of the functor, and * the right one has the defined names of the instantiation, then * the result maps functor names to instance names.cryptolKeep only the bindings in the 1st environment that are *NOT* in the second.cryptol&All names mentioned in the environmentcryptol8Get a unqualified naming environment for the given namescryptol"Get the names in a given namespacecryptol&Resolve a name in the given namespace.cryptol&Resolve a name in the given namespace.cryptol7Singleton renaming environment for the given namespace.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.NOTE: 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.cryptolFind the ambiguous entries in an environmet. A name is ambiguous if it might refer to multiple entities.cryptolGet the subset of the first environment that shadows something in the second one.cryptolDo an arbitrary choice for ambiguous names. We do this to continue checking afetr we've reported an ambiguity error.cryptol9Like mappend, but when merging, prefer values on the lhs.cryptolCompute an unqualified naming environment, containing the various module parameters.cryptolGenerate a naming environment from a declaration interface, where none of the names are qualified.cryptolAdapt the things exported by something to the specific import/open.cryptolThe import declarations cryptolAll public things coming in J(c) 2013-2020 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe"68(cryptolBitvector too largecryptol7Operation cannot be supported in the symbolic simulatorcryptol=Data type describing errors that can occur during evaluation.cryptolOut-of-bounds indexcryptolDivision or modulus by 0cryptol"Exponentiation by negative integercryptolLogarithm of a negative integercryptolCall to the Cryptol error primitivecryptolDetectable nonterminationcryptol Primitive with no implementationcryptolInvalid rounding modecryptol/Value outside the domain of a partial function.cryptol1No prop guard holds for the given type variables.cryptol!Foreign function cannot be calledcryptolNumber passed to foreign function as a type argument is too large&cryptol3This datastructure tracks the lifecycle of a thunk.Thunks are used for basically three use cases. First, we use thunks to preserve sharing. Basically every cryptol expression that is bound to a name, and is not already obviously a value (and in a few other places as well) will get turned into a thunk in order to avoid recomputation. These thunks will start in the & state, and have a backup computation that just raises the  exception.Secondly, thunks are used to cut cycles when evaluating recursive definition groups. Every named clause in a recursive definition is thunked so that the value can appear in its definition. Such thunks start in the & state, as they must exist before we have a definition to assign them. Forcing a thunk in the & state is a programmer error (panic). Once the body of a definition is ready, we replace the thunk with the relevant computation, going to the & state.In the third case, we are using thunks to provide an optimistic shortcut for evaluation. In these cases we first try to run a computation that is stricter than the semantics actually allows. If it succeeds, all is well an we continue. However, if it tight loops, we fall back on a lazier (and generally more expensive) version, which is the "backup" computation referred to above.&cryptol'This thunk has not yet been initialized&cryptolThis thunk has not yet been forced. We keep track of the "main" computation to run and an optional "backup" computation to run if we detect a tight loop when evaluating the first one. The final two arguments are used to throw a loop exception if the backup computation also causes a tight loop.&cryptolThis thunk is currently being evaluated by the thread with the given thread ID. We track an optional "backup" computation to run if we detect a tight loop evaluating this thunk. If the thunk is being evaluated by some other thread, the current thread will await its completion. The final two arguments are used to throw a loop exception if the backup computation also causes a tight loop.&cryptolThis thunk has been forced, and its evaluation results in an exception&cryptol-This thunk has been forced to the given valuecryptolThe monad for Cryptol evaluation. A computation is either "ready", which means it represents only trivial computation, or is an "eval" action which must be computed to get the answer, or it is a "thunk", which represents a delayed, shared computation.cryptolThe type of dynamic call stacks for the interpreter. New frames are pushed onto the right side of the sequence.cryptol6A computation that returns an already-evaluated value.cryptolPretty print a call stack with each call frame on a separate line, with most recent call frames at the top.cryptolCombine the call stack of a function value with the call stack of the current calling context. This algorithm is the same one GHC uses to compute profiling calling contexts.The algorithm is as follows.3ccs ++> ccsfn = ccs ++ dropCommonPrefix ccs ccsfnwheredropCommonPrefix A B -- returns the suffix of B after removing any prefix common -- to both A and B.cryptol+Add a call frame to the top of a call stackcryptolTest if a value is "ready", which means that it requires no computation to return.cryptolDelay the given evaluation computation, returning a thunk which will run the computation when forced. Run the & computation instead if the resulting thunk is forced during its own evaluation.cryptolBegin executing the given operation in a separate thread, returning a thunk which will await the completion of the computation when forced.&cryptolTo the work of forcing a thunk. This is the worker computation that is forked off via  evalSpark.cryptolProduce 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.&cryptol Force a thunk to get the result.cryptolGet the current call stackcryptol,Execute the action with the given call stackcryptol-Run the given action with a modify call stackcryptol$Execute the given evaluation action.cryptolLift an & computation into the  monad.cryptolPanic from an Eval context.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).cryptol&call stack of the application context cryptol)call stack of the function being applied &cryptol&call stack of the application context cryptol)call stack of the function being applied cryptolComputation to delay cryptol?Optional backup computation to run if a tight loop is detected cryptolmessage for the  loop' exception if a tight loop is detected cryptol%A name to associate with this thunk. ''K Safe-Inferred%&-89:cryptol,Do something in the context of a module. If $ than we are working with a local declaration. Otherwise we are at the top-level of the given module.By wrapping types with this, we can pass the module path to methods that need the extra information. cryptol"Things that define exported names.cryptolThings defined by a modulecryptolthis includes signaturescryptolThings defined by this module. Note the for normal modules we really just need the public names, however for things within functors we need all defined names, so that we can generate fresh names in instantiations cryptolThese are the exported namescryptolUsed in the import loop to track the current state of processing. The reason this is here, rather than just having a pair in the other algorithm is because this type is recursive (for nested modules) and it is conveninet to keep track for all modules at once cryptol=Generate a map from this module and all modules nested in it.cryptolMake a  from the public declarations in an interface. This is used to handle imports.&cryptolThese are the names "owned" by the signature. These names are used when resolving the signature. They are also used to figure out what names to instantuate when the signature is used.cryptol Generate a  using an explicit supply.cryptolGiven a name in a signature, make a name for the parameter corresponding to the signature.cryptol5Generate the naming environment for a type parameter.cryptolGenerate a type renaming environment from the parameters that are bound by this schema.cryptol0The naming environment for a single declaration.cryptolIntroduce the nameL Safe-Inferred-%&cryptolThis is what needs to be done&cryptolThe top-level module we are working on. This does not change throught the algorithm, it is just convenient to pass it here with all the other stuff. &cryptol5Modules defined outside the current top-level modules&cryptolNested modules/signatures in the current top-level modules. These may be either defined locally, or be the result of instantiating a functor. Note that the functor itself may be either local or external.&cryptol Use this to instantiate functors&cryptol/True if something changed on the last iteration&cryptol-Things which come in scope from outer modules&cryptolThings which come in scope via imports. These shadow outer names.&cryptolThis keeps track of the current state of resolution of a module.cryptolA resolved module that's not defined in the current top-level modulecryptolA resolved module that's defined in (or is) the current top-level modulecryptolThis represents a resolved module or signaure. The type parameter helps us distinguish between two types of resolved modules: Resolved modules that are *inputs* to the algorithm (i.e., they are defined outside the current module). For such modules the type parameter is imps is ()Resolved modules that are *outputs* of the algorithm (i.e., they are defined within the current module). For such modules the type parameter imps contains the naming environment for things that came in through the import.Note that signaures are never "imported", however we do need to keep them here so that signatures in a functor are properly instantiated when the functor is instantiated.cryptol'Things defined by the module/signature.cryptolExported namescryptolWhat sort of thing are wecryptol)Modules and signatures nested in this onecryptolResolved imports. External modules need not specify this field, it is just part of the thing we compute for local modules. &cryptol0Initial state of a module that needs processing.&cryptol:A module is fully processed when we are done with all its:submodule importsinstantiations&nested things (signatures and modules)&cryptol2Finish up all unfinished modules as best as we can&cryptol=A place-holder entry for instnatitations we couldn't resolve.&cryptolFinish up unresolved modules as well as we can, in situations where the program contains an error.&cryptolThis is used when we need to use a local resolved module as an input to another module. &cryptol8Keep applying a transformation while things are changing&cryptol7Is this a known name for a module in the current scope?&cryptolIs the module mentioned in this import known in the current scope?&cryptol7Is the module mentioned in the import already resolved?&cryptolTry to resolve an import. If the imported module can be resolved, and it refers to a module that's already been resolved, then we do the import and extend the current scoping environment. Otherwise, we just queue the import back on the  modImports/ of the current module to be tried again later.&cryptol*Resolve all imports in the current modules&cryptolTry to instantiate a functor. This succeeds if we can resolve the functor and the arguments and the both refer to already resolved names. Note: at the moment we ignore the arguments, but we'd have to do that in order to implment applicative behavior with caching. &cryptolTry to instantiate a functor. If successful, then the newly instantiated module (and all things nested in it) are going to be added to the  doneModules7 field. Otherwise, we queue up the instantiatation in curMod for later processing &cryptol?Generate a fresh instance for the functor with the given name. &cryptolGenerate a new instantiation of the given module/signature. Note that the module might not be a functor itself (e.g., if we are instantiating something nested in a functor &cryptol+Try to make progress on all instantiations.&cryptol7Try to resolve the "normal" module with the given name.&cryptol#Process all submodules of a module.&cryptol*All steps involved in processing a module.&cryptolFunctor and arguments &cryptolThis indicates if the result is a functor or not. When instantiating a functor applied to some arguments the result is not a functor. However, if we are instantiating a functor nested within some functor that's being instantiated, then the result is still a functor. cryptolPath for instantiated names cryptol.Name of the functor/module being instantiated &cryptolSee & cryptolPath for instantiated names cryptolThe thing being instantiated M(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred"%&-'F"cryptolCheck for overlap and shadowingcryptolOnly check for overlapcryptolDon't check the environmentcryptolMaps names that come into scope through this parameter to the names in the *module interface*. This is for functors, NOT functor instantantiations. cryptolHow many times did we refer to each name. Used to generate warnings for unused definitions.cryptol/keeps track of names *used* by something. see cryptol1keeps track of the dependencies for things. see cryptol1Info about imported things, from external modulescryptolExternally loaded modules.  is defined in .cryptol Current module we are working oncryptolMaps module paths to the actual name for it. This is used for dependency tracking, to find the name of a containing module. See the note on . cryptol"Info about locally defined modulescryptolModule parameters. These are used when rename the module parameters, and only refer to the parameters of the current module (i.e., no outer parameters as those are not needed) cryptolKeeps track of which names were introduce by module parameters and which one. The  is always a .cryptol'Information needed to do some renaming.cryptolUse to make new namescryptolWe are renaming things in herecryptolThis is what's in scopecryptolExternal modulescryptol;Indicates if a name is in a binding poisition or a use sitecryptolRecord an error.cryptolRename something. All name uses in the sub-computation are assumed to be dependenices of the thing.cryptolThis is used when renaming a group of things. The result contains dependencies between names defined in the group, and is intended to be used to order the group members in dependency order.cryptol updates have an explicit function and there are no more nested updates.cryptolRename a binding.cryptolRename a schema, assuming that none of its type variables are already in scope.&cryptolResolved name for this module &cryptolMay contain infix expressionscryptolThe operator to usecryptol"Will not contain infix expressions--O Safe-Inferred3XP Safe-Inferred/4vcryptol`?tSu` should be applied to all types. `?vSu` shoudl be applied to all values. cryptolHas value names but no types.cryptolHas types but not values.cryptolHas both value names and types.Q Safe-Inferred-> &cryptol Argument that defines the params&cryptolArgument that add parameters The type parameters are in their module type parameter form (i.e., tpFlav is TPModParam)&cryptol Instantiate using this parameter&cryptolInstantiate using this module&cryptol Instantiate by adding parameters&cryptolValidate a functor application, just checking the argument names. The result associates a module parameter with the concrete way it should be instantiated, which could be:&5 instanciate using another parameter that is in scope&5 instanciate using a module, with the given interface&cryptol3Check the argument to a functor parameter. Returns:A substitution which will replace the parameter types with the concrete types that were providedSome declarations that define the parameters in terms of the provided values.8XXX: Extra parameters for instantiation by adding params&cryptol#Check a type parameter to a module.&cryptol$Check a value parameter to a module.&cryptolMake an "adaptor" that instantiates the paramter into the form expected by the functor. If the actual type is:  {x} P => tand the provided type is: f : {y} Q => s#The result, if successful would be:/x {P}. f @a {Q}!To do this we need to find types a to instantiate y , and prove that: {x} P => Q[ay]  s = tcryptolName for the new module cryptolFunctor being instantiated cryptolInstance arguments cryptolInstantitation. These is the renaming for the functor that arises from generativity (i.e., it is something that will make the names "fresh").cryptolDocumentation &cryptolLocation for reporting errors cryptolThe functor being instantiated cryptolThe arguments cryptolAssociates functor parameters with the interfaces of the instantiating modules &cryptolLocation for error reporting cryptol Actual types cryptolType parameter cryptol+Mapping from parameter name to actual type &cryptolLocation for error reporting cryptolActual values cryptolThe parameter we are checking cryptol*Mapping from parameter name to definition &cryptolLocation for error reporting cryptolName of functor parameter cryptolModule parameter cryptolType to add to things, $ on err &cryptol.Location of instantiation for error reporting cryptolName and type of parameter cryptol!Name and type of actual argument R Safe-Inferred@wcryptolUndefined value namescryptol#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.  S Safe-Inferred%&-G&cryptolThe result of converting a Cryptol type into its C representation.&cryptolA type that can be directly returned if it is a return type and passed as a single parameter if it is a Cryptol parameter type.&cryptolA type that is turned into a number of parameters, for both Cryptol parameter and return type cases.&cryptol1The "direction" of a parameter (input or output).&cryptolThe monad for generating headers. We keep track of which headers we need to include and add them to the output at the end.&cryptol Include foo! represents an include statement  #include foocryptol=Generate a C header file from the given foreign declarations.&cryptolConvert a Cryptol foreign declaration into a C function declaration.&cryptol8Convert a Cryptol type parameter to a C value parameter.&cryptol0Convert a Cryptol parameter or return type to C.&cryptolConvert many Cryptol types, each associated with a prefix, to C parameters named with their prefixes.&cryptolConvert a basic Cryptol FFI type to a C type with its corresponding calling convention. At present all value types use the same calling convention no matter if they are inputs or outputs, so we don't need the &. &cryptolConvert a basic Cryptol FFI type to a C type. This is used when the type is stored in array.&cryptol3Convert a basic Cryptol FFI type to a value C type.&cryptol7Convert a basic Cryptol FFI type to a reference C type.&cryptolCreate a suffix corresponding to some component name of some larger type.&cryptolReturn a type with the given name, included from some header file.&cryptolGiven some Cryptol identifiers (normal ones, not operators) pick suitable unique C names for themT Safe-InferredHcryptol9Exponent and precision of 32-bit IEEE-754 floating point.cryptol9Exponent and precision of 64-bit IEEE-754 floating point.USafe%&(-J\cryptol Convert a   to a , along with any  "s that must be satisfied for the  to be valid.&cryptol Convert a   to a , along with any  "s that must be satisfied for the  to be valid.&cryptol Convert a   to a  , returning $ if it isn't a basic type and &1 if it is but there was some other issue with it.V(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred"%&(-U9&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.cryptolInfer the type of an expression, and translate it to a fully elaborated core term.&cryptol$The type the is the smallest of all &cryptolInfer 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.cryptol!inferBinds isTopLevel isRec binds: performs inference for a strongly-connected component of s. If any of the members of the recursive group are already marked as monomorphic, then we don't do generalization. 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 exprMap is a thunk where we can lookup the final expressions and we should be careful not to force it.&cryptolThe inputs should be declarations with monomorphic types (i.e., of the form `Forall [] [] t`). &cryptolCheck a monomorphic binding.&cryptolGiven a DPropGuards of the form :f : {...} A f | (B1, B2) => ... | (C1, C2, C2) => ... we check that it is exhaustive by trying to prove the following implications:  A  ~B1 => C1  C2 / C3 A  ~B2 => C1  C2 / C3 The implications were derive by the following general algorithm: - Find that  (C1, C2, C3) is the guard that has the most conjuncts, so we will keep it on the RHS of the generated implications in order to minimize the number of implications we need to check. - Negate (B1, B2) which yields  (~B1) / (~B2). This is a disjunction, so we need to consider a branch for each disjunct --- one branch gets the assumption ~B1( and another branch gets the assumption ~B2?. Each branch's implications need to be proven independently.&cryptolThis function does not validate anything---it just translates into the type-checkd syntax. The actual validation of the guard will happen when the (automatically generated) function corresponding to the guard is checked, assuming ExpandpropGuards did its job correctly.W(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred"UX(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe;=[cryptolAn evaluated type of kind *. These types do not contain type variables, type synonyms, or type functions.cryptol  Bitcryptol  Integercryptol  Float e pcryptol  Z ncryptol Rationalcryptol  Array a bcryptol  [n]acryptol  [inf]tcryptol  (a, b, c )cryptol  { x : a, y : b, z : c }cryptol  a -> bcryptola named newtypecryptolan abstract typecryptol-Convert a type value back into a regular typecryptolTrue if the evaluated value is BitcryptolProduce a sequence type valuecryptol The Cryptol Float64 type.cryptolCoerce an extended natural into an integer, for values known to be finitecryptol#Evaluation for types (kind * or #).cryptol9Evaluate the body of a newtype, given evaluated argumentscryptol$Evaluation for value types (kind *).cryptol%Evaluation for number types (kind #).cryptolReduce type functions, raising an exception for undefined values.Y Safe-Inferred"-_ cryptol=Make LibBF options for the given precision and rounding mode.cryptol/Mapping from the rounding modes defined in the  to the rounding modes of LibBF.cryptol.Check that we didn't get an unexpected status.cryptolPretty print a floatcryptolMake a literalcryptolMake a floating point number from a rational, using the given rounding modecryptol;Convert a floating point number to a rational, if possible.cryptol;Convert a floating point number to an integer, if possible.cryptolTurn a float into raw bits. NaN& is represented as a positive "quiet" NaN (most significant bit in the significand is set, the rest of it is 0)cryptolCreate a 64-bit IEEE-754 float.cryptolExponent width cryptolPrecision width cryptolExponent width cryptolPrecision widht cryptol Raw bits Z Safe-InferredcryptolThis 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.cryptolCheck if an operation is "ready", which means its evaluation will be trivial.cryptolProduce 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.cryptolDelay the given evaluation computation, returning a thunk which will run the computation when forced. Run the retry computation instead if the resulting thunk is forced during its own evaluation.cryptolBegin evaluating the given computation eagerly in a separate thread and return a thunk which will await the completion of the given computation when forced.cryptolPush a call frame on to the current call stack while evaluating the given actioncryptol:Use the given call stack while evaluating the given actioncryptolApply the given function to the current call stack while evaluating the given actioncryptol*Retrieve the current evaluation call stackcryptolAttempt to render a word value as an ASCII character. Return $ if the character value is unknown (e.g., for symbolic values).cryptol/Determine if this symbolic integer is a literalcryptol 2 . The input x is required to be in reduced form, and will output a value in reduced form.'cryptolCompute the modular multiplication of two input values. Currently, this uses naive modular reduction, and does not require the inputs to be in reduced form. The output is in reduced form.'cryptolCompute the modular difference of two input values. The inputs are required to be in reduced form, and will output a value in reduced form.'cryptol-Compute the modular square of an input value x ; that is, x*x. The input is not required to be in reduced form, and the output will be in reduced form.'cryptol*Compute the modular scalar multiplication 2x = x+x. The input is required to be in reduced form and the output will be in reduced form.'cryptol*Compute the modular scalar multiplication  3x = x+x+x. The input is required to be in reduced form and the output will be in reduced form.'cryptol*Compute the modular scalar multiplication  4x = x+x+x+x. The input is required to be in reduced form and the output will be in reduced form.'cryptol*Compute the modular scalar multiplication 8x = x+x+x+x+x+x+x+x. The input is required to be in reduced form and the output will be in reduced form.cryptolCompute the elliptic curve group doubling operation. In other words, if S> is a projective point on a curve, this operation computes S+S in the ECC group.In geometric terms, this operation computes a tangent line to the curve at S and finds the (unique) intersection point of this line with the curve, R; then returns the point R' , which is R reflected across the x axis.'cryptolCompute the elliptic curve group addition operation, including the special case for adding points which might be the identity.'cryptolCompute the elliptic curve group subtraction operation, including the special cases for subtracting points which might be the identity.cryptolCompute the elliptic curve group addition operation for values known not to be the identity. In other words, if S and T3 are projective points on a curve, with nonzero z$ coordinate this operation computes S+T in the ECC group.In geometric terms, this operation computes a line that passes through S and T%, and finds the (unique) other point R where the line intersects the curve; then returns the point R' , which is R; reflected across the x axis. In the special case where S == T, we instead call the  ec_double8 operation, which instead computes a tangent line to S .'cryptolGiven a nonidentity projective point, normalize it so that its z component is 1. This helps to avoid some modular multiplies in ec_add<, and may be a win if the point will be added many times.cryptolGiven an integer k and a projective point S', compute the scalar multiplication kS , which is S added to itself k times.'cryptolCompute the sum and difference of the given points, and normalize all four values. This can be done jointly in a more efficient way than computing the necessary field inverses separately. When given points S and T, the returned tuple contains normalized representations for (S, T, S+T, S-T).Note there are some special cases that must be handled separately.cryptolGiven an integer j and a projective point S#, together with another integer k and point T8 compute the "twin" scalar the scalar multiplication jS + kT. This computation can be done essentially the same number of modular arithmetic operations as a single scalar multiplication by doing some additional bookkeeping and setup.\(c) 2020 Galois, Inc.BSD3cryptol@galois.com Safe-Inferred (-8cryptolThe symbolic value we computed.cryptolA malformed valuecryptolsafety predicate and result: the result only makes sense when the predicate holds.cryptolThis layer has the symbolic back-end, and can keep track of definitional predicates used when working with uninterpreted constants defined via a property. cryptolThis is the monad used for symbolic evaluation. It adds to aspects to ---WConn keeps track of the backend and collects definitional predicates, and + adds support for partially defined values cryptolA value with no context.cryptolA total value.cryptolAccess the symbolic back-endcryptolRecord a definition. addDef :: W4.Pred sym -> W4Conn sym () addDef p = W4Conn _ -> pure W4Defs { w4Defs = p, w4Result = () }Compute conjunction.cryptolCompute negation.cryptolCompute if-then-else.cryptolAdd a definitional equation. This will always be asserted when we make queries to the solver.cryptolAdd s safety condition.cryptol A fully undefined symbolic valuecryptolTry successive powers of 2 to find the first that dominates the input. We could perhaps reduce to using CLZ instead...11](c) 2013-2020 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred%&'(-cryptolConcrete bitvector values: width, value Invariant: The value must be within the range 0 .. 2^width-1cryptolApply an integer function to the values of bitvectors. This function assumes both bitvectors are the same width.cryptolApply 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 limitcryptol Bit-width cryptolValue cryptolMasked result cryptol Rouding mode 'cryptolRounding mode ^(c) 2013-2021 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred(58;=i cryptolA sequence map represents a mapping from nonnegative integer indices to values. These are used to represent both finite and infinite sequences.cryptol4Generate a finite sequence map from a list of valuescryptol9Generate an infinite sequence map from a stream of valuescryptolCreate a finite list of length n of the values from [0..n-1]# in the given the sequence emap.cryptol=Create an infinite stream of all the values in a sequence mapcryptol*Reverse the order of a finite sequence mapcryptolConcatenate the first n values of the first sequence map onto the beginning of the second sequence map.cryptolGiven 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.cryptolDrop the first n elements of the given .cryptolGiven a sequence map, return a new sequence map that is memoized using a finite map memo table.cryptolApply the given evaluation function pointwise to the two given sequence maps.cryptolApply the given function to each value in the given sequence mapcryptolSize of the sequence map cryptolifthenelse operation of values cryptolreindexing operation cryptol zero value cryptolsize of the sequence cryptolsequence to shift cryptol-shift amount, assumed to be in range [0,len] cryptolifthenelse operation of values cryptolconcrete shifting operation cryptolSize of the map being shifted cryptolinitial value cryptol2segments of the shift amount, in big-endian order _(c) 2013-2021 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred(5; cryptolFor 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.'cryptol-Packed word representation for bit sequences.cryptol$Force the evaluation of a word value'cryptolAn arbitrarily-chosen number of elements where we switch from a dense sequence representation of bit-level words to  representation.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.cryptol(Force a word value into packed word formcryptol*Force a word value into a sequence of bitscryptolTurn 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.cryptolCompute the size of a word value TODO, can we get rid of this? If feels like it should be unnecessary.cryptol*Select an individual bit from a word valuecryptolProduce a new $ from the one given by updating the i#th bit with the given bit value.'cryptolLength of the wordcryptolThunk for packing the word'cryptol bit-width cryptolbig-endian list of index bits cryptolUpper bound to test against cryptoloperation on word values cryptolreindexing operation cryptolword value to shift cryptol-shift amount, assumed to be in range [0,len] cryptoloperation on word values cryptolreindexing operation cryptolvalue to shift cryptolamount to shift cryptolvalue to update cryptolindex to update at cryptol fresh bit cryptolifthenelse operation of values cryptolreindexing operation cryptol zero value cryptolsize of the sequence cryptolsequence to shift cryptol shift amount `(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred(58;=$cryptol8Generic value type, parameterized by bit and word types.NOTE: we maintain an important invariant regarding sequence types.  must never be used for finite sequences of bits. Always use the  constructor instead! Infinite sequences of bits are handled by the & constructor, just as for other types.cryptol  { .. }cryptol  ( .. )cryptol  Bitcryptol Integer  or  Z n cryptol  Rationalcryptol [n]a / Invariant: VSeq is never a sequence of bitscryptol  [n]Bitcryptol  [inf]acryptol functionscryptolpolymorphic values (kind *)cryptolpolymorphic values (kind #)cryptolSome options for evalutaioncryptol Where to print stuff (e.g., for trace)cryptolHow to pretty print things.cryptolForce the evaluation of a valuecryptolCreate a packed word of n bits.cryptolConstruct a function valuecryptol+Functions that assume floating point inputscryptolA type lambda that expects a Type.cryptolA type lambda that expects a Type of kind #.cryptol1A type lambda that expects a finite numeric type.cryptolConstruct either a finite sequence, or a stream. In the finite case, record whether or not the elements were bits, to aid pretty-printing.cryptolExtract a bit value.cryptolExtract an integer value.cryptolExtract a rational value.cryptol Extract a finite sequence value.cryptolExtract a sequence.cryptolExtract 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.a(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Trustworthy %&qcryptolA test result is either a pass, a failure due to evaluating to False;, or a failure due to an exception raised during evaluation'cryptolApply a testable value to some randomly-generated arguments. Returns Nothing if the function returned True , or Just counterexample if it returned False.Please note that this function assumes that the generators match the supplied value, otherwise we'll panic.cryptol$Return a collection of random tests.cryptolGiven a (function) type, compute generators for the function's arguments. cryptolA generator for values of the given type. This fails if we are given a type that lacks a suitable random value generator. 'cryptolGenerate a random bit value.'cryptolGenerate a random integer value. The size parameter is assumed to vary between 1 and 100, and we use it to generate smaller numbers first.'cryptolGenerate a random word of the given length (i.e., a value of type [w]) The size parameter is assumed to vary between 1 and 100, and we use it to generate smaller numbers first.'cryptol(Generate a random infinite stream value.'cryptolGenerate 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.'cryptolApply a testable value to some arguments. Note that this function assumes that the values come from a call to  (i.e., things are type-correct). We run in the IO monad in order to catch any  EvalErrors.cryptolGiven a (function) type, compute data necessary for random or exhaustive testing.The first returned component is a count of the number of possible input test vectors, if the input types are finite. The second component is a list of all the types of the function inputs. The third component is a list of all input test vectors for exhaustive testing. This will be empty unless the input types are finite. The final argument is a list of generators for the inputs of the function.This function will return Nothing3 if the input type does not eventually return Bit, or if we cannot compute a generator for one of the inputs.'cryptolGiven 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. 'cryptolReturns all the values in a type. Returns an empty list of values, for types where ' returned $. 'cryptolFunction under testcryptolArgument generatorscryptolSize'cryptol&Function to be used to calculate testscryptolArgument generatorscryptolSizecryptolInitial random statecryptol'Arguments, result, and new random statecryptolThe random generator statecryptol%Generators for the function argumentscryptolThe function itselfcryptolHow many tests?cryptolA list of pairs of random arguments and computed outputs as well as the new state of the RNGcryptolThe random generator statecryptol%Generators for the function argumentscryptolThe function itselfcryptolHow many tests?cryptolA list of pairs of random arguments and computed outputs as well as the new state of the RNG'cryptolExponent width cryptolPrecision width cryptolprogress callback cryptolfunction under test cryptolexhaustive set of test values cryptolprogress callback cryptolMaximum number of tests to run cryptolfunction under test cryptolinput value generators cryptolInital random generator cryptolprogress callback cryptolMaximum number of tests to run cryptolfunction under test cryptolinput value generators cryptolInital random generator b Safe-Inferred$cryptolThis type provides a lightweight syntactic framework for defining Cryptol primitives. The main purpose of this type is to provide an abstraction barrier that insulates the definitions of primitives from possible changes in the representation of values.cryptol-Evaluate a primitive into a value computation  c(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred;=&cryptol'Evaluation environment with no bindingscryptol.Bind a variable in the evaluation environment.cryptolBind 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.  d(c) 2013-2020 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred"%&'(-)cryptol/Make a numeric literal value at the given type.cryptolMake a numeric constant.cryptol/Convert an unbounded integer to a value in Ringcryptol)Convert a word to a non-negative integer.cryptol4Join a sequence of sequences into a single sequence.cryptolSplit implementation.cryptolMerge two values given a binop. This is used for and, or and xor.cryptolIndexing operations.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 ? charactercryptolProduce 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 zerocryptol0A helper for definitng floating point constants.cryptol6Make a Cryptol value for a binary arithmetic function.cryptolRounding mode used in FP operations that do not specify it explicitly.cryptolRounding mode used in FP operations that do not specify it explicitly.cryptolRounding mode used in FP operations that do not specify it explicitly.cryptolRounding mode used in FP operations that do not specify it explicitly.cryptolRounding mode used in FP operations that do not specify it explicitly.cryptolRounding mode used in FP operations that do not specify it explicitly.cryptolSequence size bounds cryptol Index value cryptol*operation for range reduction on integers cryptol*word shift operation for positive indices cryptol*word shift operation for negative indices cryptolreindexing operation for positive indices (sequence size, starting index, shift amount cryptolreindexing operation for negative indices (sequence size, starting index, shift amount e(c) 2020 Galois, Inc.BSD3cryptol@galois.com Safe-Inferred"()*-1'cryptolRetrieve the named uninterpreted function, with the given argument types and return type, from a cache. Create a fresh function if it has not previously been requested. A particular named function is required to be used with consistent types every time it is requested; otherwise this function will panic.'cryptol8Apply the named uninterpreted function to a sequence of [4][32]% values, and return a sequence of [4][32] values. This shape of function is used for most of the SuiteB AES primitives.'cryptolFunction name cryptolfunction argument types cryptolfunction return type f(c) 2013-2020 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred "-cryptolGiven an expected type, returns an expression that evaluates to this value, if we can determine it.'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 g(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred "%&(+ 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 runcryptol+Which prover to use (one of the strings in  proverConfigs)cryptolVerbosity flag passed to SBVcryptol#Model validation flag passed to SBVcryptolRecord timing information herecryptol?Extra declarations to bring into scope for symbolic simulationcryptol,Optionally output the SMTLIB query to a filecryptol&The typechecked expression to evaluatecryptolThe   of pcExprcryptol#Should we ignore safety predicates?cryptolFlatten structured shapes (like tuples and sequences), leaving only a sequence of variable shapes of base type.h(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred '(/'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 position'cryptol"Bindings whose values are constantcryptolExtend the given evaluation environment with all the declarations contained in the given module.cryptolEvaluate a Cryptol expression to a value. This evaluator is parameterized by the ' class, which defines the behavior of bits and words, in addition to providing implementations for all the primitives.cryptolChecks whether an evaluated   holds'cryptol Evaluates a   in an - by substituting all variables according to % and expanding all type synonyms via  .'cryptolCapure the current call stack from the evaluation monad and annotate function values. When arguments are later applied to the function, the call stacks will be combined together.'cryptol1Introduce the constructor function for a newtype.cryptolExtend the given evaluation environment with the result of evaluating the given collection of declaration groups.'cryptolThis operation is used to complete the process of setting up recursive declaration groups. It  backfills 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  operation and only fall back on full eta expansion if the thunk is double-forced.'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. Note that selectors are expected to apply only to values of the right type, e.g. tuple selectors expect only tuple values. The lifting of tuple an record selectors over functions and sequences has already been resolved earlier in the typechecker.'cryptolEvaluate a list environment at a position. This choses a particular value for the varying locations.'cryptolEvaluate a comprehension.'cryptolTurn 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 ,,i(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred "%&-;= ,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.cryptolThe module's interface.cryptolThe actual type-checked modulecryptolThe dynamically loaded source for any foreign functions in the modulecryptolA generic type for loaded things. The things can be either modules or signatures.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.cryptolWhat's in scope in this modulecryptol3Invariants: 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 modulecryptolLabel, contentcryptolContains enough information to browse what's in scope, or type check new expressions.cryptol=Should contain at least names in NamingEnv, but may have morecryptol!What's in scope inside the modulecryptolShould we run the linter?cryptolDon't run core lintcryptol Run core lintcryptol-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.cryptolThe evaluation environment. Contains the values for all loaded modules, both public and private.cryptol*Should we run the linter to ensure sanity.cryptolAre we assuming that local bindings are monomorphic. XXX: We should probably remove this flag, and set it to $.cryptolThe "current" module. Used to decide how to print names, for example.cryptolWhere we look for things.cryptolThis contains additional definitions that were made at the command line, and so they don't reside in any module.cryptolName source for the renamercryptol7Try 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.cryptolGet 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).cryptolThe 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"Is this a loaded interface module.cryptol&Try to find a previously loaded modulecryptolAdd 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  that correspond to all of the bindings in the dynamic environment.9XXX: if we add newtypes, etc. at the REPL, revisit this.cryptol'In-memory things are compared by label.cryptol'In-memory things are compared by label.j Safe-Inferred"-'cryptol4Organize by module where defined, then sort by name.k Safe-Inferred%&'(- T 'cryptol7Operations needed for returning a basic reference type.'cryptol9Initialize the object before passing to foreign function.'cryptolFree the object after returning from foreign function and obtaining return value.'cryptol&Convert the object to a Cryptol value.'cryptolMethods for obtaining a return value. The producer of this type must supply both 1) a polymorphic IO object directly containing a return value that the consumer can instantiate at any  type, and 2) an effectful function that takes some output arguments and modifies what they are pointing at to store a return value. The consumer can choose which one to use.cryptolAdd the given foreign declarations to the environment, loading their implementations from the given . This is a separate pass from the main evaluation functions in  Cryptol.Eval/ since it only works for the Concrete backend.'cryptol Generate a  value representing the given foreign function, containing all the code necessary to marshal arguments and return values and do the actual FFI call.'cryptol-Generate the monomorphic part of the foreign  , given a = containing all the type arguments we have already received.'cryptolGiven a way to ' , create a ' , where the ', simply allocates a temporary space to call ' on. This is useful for return types that we know how to obtain directly as a value but need to obtain as an output argument when multiple return values are involved.'cryptolGiven a , call the callback with a marshalling function that marshals values to the  type corresponding to the . The callback must be able to handle marshalling functions that marshal to any  type.'cryptolGiven a =, call the callback with an unmarshalling function from the  type corresponding to the  to Cryptol values. The callback must be able to handle unmarshalling functions from any  type.'cryptolCall the callback with the Word type corresponding to the given .'cryptolGiven a , call the callback with a marshalling function that takes a Cryptol value and calls its callback with the ' type corresponding to the .l(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred(8!)'cryptolCeiling (log_2 x)'cryptolmodulus: must be prime      m(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred(-8"  (c) 2014-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Trustworthy"w''' Safe-Inferred" '''''''n(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred#&  %(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Trustworthy"#) ) '9 '9 o(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred%&-;=)'cryptolFiles that have been loaded'cryptol&The path that includes are relative to'cryptolHow to load files'cryptolGet 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   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.'cryptolLift an IO operation, with a way to handle the exception that it might throw.'cryptolLike ', but tries to collect as many errors as possible before failing.'cryptolRemove includes from a module.'cryptolRemove includes from a program.'cryptolSubstitute top-level includes with the declarations from the files they reference.'cryptolResolve the file referenced by a include into a list of top-level declarations.'cryptol%Read a file referenced by an include.  p(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred"-;=1 cryptol=Unable to find the module given, tried looking in these paths cryptolUnable to open a file cryptol.Bad UTF-8 encoding in while decoding this file cryptol4Some other IO error occurred while reading this file cryptol=Generated this parse error when parsing the file for module m cryptol!Recursive module group discovered cryptol"Problems during the renaming phase cryptolProblems during the NoPat phase cryptol*Problems during the ExpandPropGuards phase cryptol#Problems during the NoInclude phase cryptolProblems during type checking cryptol0Problems after type checking, eg. specialization cryptolModule loaded by 'import'$ statement has the wrong module name cryptolTwo modules loaded from different files have the same module name cryptol/Errors loading foreign function implementations cryptolThis 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. cryptolRun the computation, and if it caused and error, tag the error with the given file.!cryptolThis checks if the given name is loaded---it might refer to either a module or a signature.!cryptolPush 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   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 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!q(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred"%&-:!cryptol7Rename a module in the context of its imported modules.!cryptolRun the noPat pass.!cryptolRun the expandPropGuards pass.!cryptolParse a module and expand includes Returns a fingerprint of the module, and a set of dependencies due to include directives.!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) ]!cryptolDiscover a module.!cryptol'Discover a file. This is distinct from ! in that we assume we've already been given a particular file name.!cryptolAdd the prelude to the import list if it's not already mentioned.!cryptol7Load the dependencies of a module into the environment.!cryptolFind all imports in a module.!cryptol7Find the set of top-level modules imported by a module.!cryptol A helper ! and !" that actually does the searching.!cryptolTypecheck a single expression, yielding a renamed parsed expression, typechecked core expression, and a type schema.!cryptol"Typecheck a group of declarations.INVARIANT: 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.!cryptol1Typecheck a single module. Note: we assume that includes have already been processed!cryptol#Generate input for the typechecker.!cryptol$evaluate declarations in the module !cryptol quiet mode !cryptol$evaluate declarations in the module cryptol9quiet mode: true suppresses the "loading module" message cryptolinclude dependencies !cryptolwhy are we loading this cryptolmodule to check *!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!r(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred-? !cryptolFind 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.!cryptolParse and typecheck a module, but don't evaluate or change the environment.!cryptolCheck the type of an expression. Give back the renamed expression, the core expression, and its type schema.!cryptolEvaluate an expression.!cryptolBenchmark an expression.!cryptol!Typecheck top-level declarations.!cryptol?Evaluate declarations and add them to the extended environment.!cryptolRename a *use* of a value name. The distinction between uses and binding is used to keep track of dependencies.!cryptolRename a *use* of a type name. The distinction between uses and binding is used to keep track of dependencies.!cryptol1Get information about the dependencies of a file.!cryptol3Get information about the dependencies of a module. !!!!!!!!!!!!!!!!! !! !!!!!!!!!!!!!!!s(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-InferredG5!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 dgs is replicated once for each monomorphic type instance at which it is used; decls not mentioned in e- (even monomorphic ones) are simply dropped."cryptolTransform 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.!!!!!!!!!""""""""""""""""!!!!!!!!!""""""""""""""""t(c) 2013-2020 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred%&()*-I'cryptolReturns definitions, together with the value and it safety predicate.'cryptolSimulate and manipulate query into a form suitable to be sent to a solver.'cryptolLike ', but lifted to work over '."cryptol hash consing cryptol warn on uninterpreted functions "cryptol hash consing cryptol warn on uninterpreted functions 'cryptol0optional safety predicate. Nothing = SAT query """"""""" """""""""u(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred %&(R"cryptol-The names of all the solvers supported by SBV'cryptolSelect the appropriate solver or solvers from the given prover command, and invoke those solvers on the given symbolic value.'cryptolPrepare 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.Note 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  ProverResult that is ready for the Cryptol REPL. There may be more than one result if we made a multi-sat query."cryptol.Execute 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 """"""""""""""""v(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred"%&(6`.'cryptol)Returns maybe an error, and some warnings'cryptol:User modifiable environment, for things like numeric base."cryptolREPL exceptions."cryptol#REPL_ context with InputT handling.'cryptolREPL RW Environment.'cryptolThis is the name of the currently "focused" module. This is what we reload (:r)'cryptolThis is what we edit (:e)'cryptolPolymorphic 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 Evaluates a   in an EvalEnv. by substituting all variables according to (% and expanding all type synonyms via  .(cryptol>Convert a list of booleans in big-endian format to an integer.(cryptolConvert 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.(cryptol,Indexing operations that return one element.#cryptolEvaluation environmentcryptolExpression to evaluate(cryptolStarting evaluation environmentcryptol$Head expression of the comprehensioncryptol'List of parallel comprehension branches######################################(0y(c) 2013-2016 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred"%&-x#cryptolCommand builder.#cryptol Commands.#cryptolSuccessfully parsed command#cryptol2Ambiguous command, list of conflicting commands#cryptolThe unknown command(cryptolREPL command parsing.(cryptolNotebook command parsing.(cryptol0A subset of commands safe for Notebook execution#cryptolRun a command.#cryptolRandomly 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.(cryptolThis 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)^kThis 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/n to be very close to accurate and the expected number of unique values is essentially equal to the number of tests.(cryptol7Attempts to prove the given term is safe for all inputs(cryptolConsole-specific version of proveSat/. Prints output to the console, and binds the it variable to a record whose form depends on the expression given. See ticket #66 for a discussion of this design.(cryptol>>>>>>>>>>>>>>>>>>>>>>>>>>>>>??????????????????????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCDDDDEEEEEEFFFFFFFFFGGGGGGGGGHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOP PPPPPPPPPPPPPPPPPPPPPPPPQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSTTUVVVVVWWWWWWWXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYYYYYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[[[[[[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]]]]]]]]]]]]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^________________________________```````````````````````````````````````````````aaaaaaaaaaaaaabbbbbbbbbbbccccccccccccccdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeefffggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggghhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjklllllllllllllllllllllllllllllmnnnnn%%%%%%%%%%%%%%%%%oooooooooooooopppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp p p p p p p pp p p p p p p p p p p p p p p p p p p p p p p p p p p q q q q q q q q q q qqq qqq q q q q q q q q q q q q q q q qq q q q q q q qq qr r rr r r r r rr r rr rrr r s s s s s s s s s s s s s s s s s s s s s s s ss t t t t t t t t t t t t t t t u u u u u u u u u u v v v v v v v v v v v v v v!v!v!vv!v!v!v!vv!vv!v!v!v!v!vv!v v v!v!v!vvv!v!v!v!v!v!v!vv!vvv!v!v v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v v!v!v!v!vvv v v!v!v!v!v v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!v!w!xxxxxx!xxxxxx!xxxx!x!xx!x!x!x!x!x!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y!y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y"y""""""""""""""""""z"z"z"z"z"z"z""" " " " """""" " " """"""{"{"{"{"{"{"{"{"{"{"{"{"{"{"{"{"{"{"{"{"{"{"{"{"{"{{"{"{"{"{"{"{"{"{"{""""""""""""""####|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#|#&#&#&#&#&#&#&#&#&#&#&#&#' '#'#'#'#'#'#'#'#'#'#'#'#'')#)$)$)$""$2$2$2$4$4$4$4$4$4$4$4$4$4$4$"$"$"$6$8$8$>$>$>$>$$$""$A$A$B$BB$BB$B$B$B$E$E$E$E$E$FFF$F$F$FF$G$HH$J$J$J$J$J$J$$$J$J$""$J$K$L$L$L$L$L$L$L$L$L$L$L$L$L$L$L$L$L$L$L$L$L$L$L$L$L$L$L$L$L$N$N$N$N$N$N$N$N$N$N$N$N$N$N$Q$Q$Q$Q$Q$Q$$$$$Q$Q$Q$Q$Q$S$S$S$S$S$S S$S$S$S%S%S%S%S%S%S%S%U%U%V%V%V%V%V%V%V%V%V%V%V%V%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%[%[%[%[%[%[%[%[%[%[%[%[%[%[%]_%_%_%_%a%a%a%a%a%a%a%a%a%a%a%a%a%e%e%f%f%f%f%h%h%h%h%h%h%h%h%h%h%h%h%h%jk%k%k%k%k%k%k%k%k%k%k%k%k%k%%%ll%%%%%%%%%%%%%%o%o%o%o%o%o%o&o&o&o&o&&&o&o&o&o&o&t&t&t&&&"&t&u&u&u&u&u&v&v&vv&v&v&v&v&v&v&v&v&v&v&v&v&v&v&v&w&xxxx&xxxxx&xxx%xx&x&x&x&x&x&x%xy&y&y&y&y&y&y&y&&&&y&y&y&y&y&y&y&&$cryptol-3.0.0-CoAB0rhRDtyEduZtDlyHHMCryptol.Utils.PanicCryptol.Utils.Benchmark Cryptol.AESCryptol.Backend.Arch Cryptol.ModuleSystem.Fingerprint Cryptol.SHACryptol.Utils.FixityCryptol.Utils.LoggerCryptol.Utils.MiscCryptol.Utils.IdentCryptol.Utils.PPCryptol.Utils.DebugCryptol.TypeCheck.PPCryptol.Parser.TokenCryptol.Parser.PositionCryptol.Parser.SelectorCryptol.TypeCheck.Solver.InfNat Cryptol.F2Cryptol.REPL.TrieCryptol.Parser.UnlitCryptol.Parser.NameCryptol.Parser.LexerCryptol.Parser.LayoutCryptol.ModuleSystem.NameCryptol.TypeCheck.TConCryptol.ModuleSystem.NamesCryptol.Backend.FFI.ErrorCryptol.Backend.FFICryptol.Utils.PatternsCryptol.Utils.RecordMapCryptol.Parser.ASTCryptol.TypeCheck.TypeCryptol.TypeCheck.TypePatCryptol.TypeCheck.SimpTypeCryptol.TypeCheck.FFI.FFITypeCryptol.Parser.UtilsCryptol.ParserCryptol.Parser.NamesCryptol.Parser.NoPatCryptol.Parser.ExpandPropGuards,Cryptol.ModuleSystem.Renamer.ImplicitImports"Cryptol.ModuleSystem.Renamer.ErrorCryptol.ModuleSystem.InterfaceCryptol.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.TypeOfCryptol.TypeCheck.FFI.Error Cryptol.TypeCheck.Solver.ImproveCryptol.TypeCheck.ParseableCryptol.TypeCheck.InterfaceCryptol.TypeCheck.InferTypesCryptol.TypeCheck.Solver.SMTCryptol.TypeCheck.ErrorCryptol.TypeCheck.Monad!Cryptol.TypeCheck.Solver.SelectorCryptol.TypeCheck.Sanity(Cryptol.TypeCheck.ModuleBacktickInstanceCryptol.TypeCheck.DefaultCryptol.TypeCheck.SolveCryptol.TypeCheck.KindCryptol.TypeCheck.InstantiateCryptol.Transform.MonoValuesCryptol.ModuleSystem.NamingEnvCryptol.Backend.MonadCryptol.ModuleSystem.Binds$Cryptol.ModuleSystem.Renamer.Imports"Cryptol.ModuleSystem.Renamer.MonadCryptol.ModuleSystem.RenamerCryptol.IR.TraverseNames Cryptol.TypeCheck.ModuleInstanceCryptol.TypeCheck.ModuleCryptol.IR.FreeVarsCryptol.Eval.FFI.GenHeaderCryptol.Utils.TypesCryptol.TypeCheck.FFICryptol.TypeCheck.InferCryptol.TypeCheckCryptol.Eval.TypeCryptol.Backend.FloatHelpersCryptol.BackendCryptol.PrimeECCryptol.Backend.What4Cryptol.Backend.ConcreteCryptol.Backend.SeqMapCryptol.Backend.WordValueCryptol.Eval.ValueCryptol.Testing.RandomCryptol.Eval.PrimsCryptol.Eval.EnvCryptol.Eval.GenericCryptol.Eval.What4Cryptol.Eval.ConcreteCryptol.Symbolic Cryptol.EvalCryptol.ModuleSystem.EnvCryptol.REPL.BrowseCryptol.Eval.FFICryptol.Backend.SBVCryptol.Eval.SBVCryptol.VersionCryptol.Parser.NoIncludeCryptol.ModuleSystem.MonadCryptol.ModuleSystem.BaseCryptol.ModuleSystemCryptol.Transform.SpecializeCryptol.Symbolic.What4Cryptol.Symbolic.SBVCryptol.REPL.MonadCryptol.REPL.HelpCryptol.Eval.ReferenceCryptol.REPL.CommandCryptol.PreludeCryptol.Parser.LexerUtilsCryptol.Parser.ParserUtilsKindhsCryptol.RenamerBindsFloatcryGHC.Num.CompatGitRev Paths_cryptolbaseGHC.Stack.Types HasCallStack3criterion-measurement-0.2.1.0-1lvq2IF280QPd8Ox2CDviCriterion.Measurementsecs$panic-0.4.0.1-4rN30rGkfht6LQZ7sHRRkVPanicKeyState invMixColumnskeyExpansionWordsaesRound aesFinalRound aesInvRoundaesInvFinalRoundmaxBigIntWidth Fingerprint fingerprintfingerprintFilefingerprintHexString$fNFDataFingerprint$fEqFingerprint$fShowFingerprint SHA512Block SHA256Block SHA512StateSHA512S SHA256StateSHA256SinitialSHA224StateinitialSHA256StateinitialSHA384StateinitialSHA512StatepadSHA1 padSHA1Chunks padSHA512padSHA512Chunkscalc_ktoBigEndianSBSfromBigEndianSBSprocessSHA256BlockprocessSHA512BlockBenchmarkStats benchAvgTimebenchAvgCpuTimebenchAvgCycles benchmark$fShowBenchmarkStats FixityCmpFCErrorFCLeftFCRightFixityfAssocfLevelAssoc LeftAssoc RightAssocNonAssoc compareFixity defaultFixity$fShowFixityCmp $fEqFixityCmp $fEqFixity $fOrdFixity$fGenericFixity$fNFDataFixity $fShowFixity $fShowAssoc $fEqAssoc $fOrdAssoc$fGenericAssoc $fNFDataAssocLogger logPutStr logPutStrLnlogPrint quietLogger handleLogger stdoutLogger stderrLogger funLogger$fNFDataLoggeranyJustanyJust2 CryptolPanicCryptolpanicxxxTODO$fPanicComponentCryptol PrimIdentIdent OrigSourceFromDefinitionFromFunctorInst FromModParamOrigName ogNamespaceogModuleogSourceogNameModNameModPath TopModuleNested NamespaceNSValueNSTypeNSModule allNamespaces apPathRoot topModuleFor modPathCommonmodPathIsOrContains modPathSplitmodPathIsNormal modNameArgmodNameIfaceModmodNameToNormalModName modNameToTextmodNameIsNormal textToModNamemodNameChunksText modNameChunks packModName preludeNameundefinedModNamepreludeReferenceName floatName arrayName suiteBName primeECNameinteractiveName noModuleName exprModNameogFromModParam packIdent packInfix unpackIdentmkIdentmkInfix isInfixIdent nullIdent identText modParamIdent identAnonArgidentAnonIfaceMod identIsNormalprelPrim floatPrim suiteBPrim primeECPrim arrayPrim$fNFDataMaybeAnon $fNFDataIdent$fIsStringIdent $fOrdIdent $fEqIdent$fNFDataModName$fNFDataPrimIdent $fEqPrimIdent$fOrdPrimIdent$fShowPrimIdent$fGenericPrimIdent $fEqOrigName $fOrdOrigName$fShowOrigName$fGenericOrigName$fNFDataOrigName $fEqModPath $fOrdModPath $fShowModPath$fGenericModPath$fNFDataModPath $fEqModName $fOrdModName $fShowModName$fGenericModName$fEqOrigSource$fOrdOrigSource$fShowOrigSource$fGenericOrigSource$fNFDataOrigSource $fShowIdent$fGenericIdent $fEqMaybeAnon$fOrdMaybeAnon$fShowMaybeAnon$fGenericMaybeAnon$fGenericNamespace$fShowNamespace$fNFDataNamespace $fEqNamespace$fOrdNamespace$fEnumNamespace$fBoundedNamespaceInfixieOpieLeftieRightieFixityPPName ppNameFixity ppPrefixName ppInfixNamePPppPrecDocPPCfg ppcfgNameDispppcfgShowNameUniques NameFormat UnQualified Qualified NotInScopeNameDisp EmptyNameDisp FieldOrder DisplayOrderCanonicalOrder PPFloatExp ForceExponent AutoExponent PPFloatFormat FloatFixed FloatFrac FloatFreePPOptsuseAsciiuseBase useInfLength useFPBase useFPFormat useFieldOrder asciiMode defaultPPOptsneverQualifyMod neverQualifyextend getNameFormat withNameDisp withPPCfg fixNameDispfixPPCfgupdPPCfgdebugShowUniques defaultPPCfg runDocWithrunDoc renderOneLinepppretty optParensppInfixordinal ordSuffixliftPPliftPP1liftPP2liftSepreflow<.><+>$$sepfsephsephcatvcatvsepgrouphangnestindentalignparensbracesbracketsquotescommaSep commaSepFillppListppTupleppRecord backtickstextcharintegerintcommacolonpipe$fMonoidNameDisp$fSemigroupNameDisp$fShowNameDisp $fIsStringDoc $fShowDoc $fMonoidDoc$fSemigroupDoc $fPPPrimIdent $fPPNamespace $fPPOrigName $fPPModPath $fPPFixity $fPPAssoc $fPPModName $fPPIdent$fPPText$fPPNameModName $fGenericDoc $fNFDataDoc$fGenericNameDisp$fNFDataNameDisp$fShowNameFormat $fShowPPOpts$fBoundedFieldOrder$fEnumFieldOrder$fEqFieldOrder$fOrdFieldOrder$fReadFieldOrder$fShowFieldOrder$fShowPPFloatFormat$fShowPPFloatExptraceppTrace WithNamesNameMap emptyNameMapppWithNamesPrec ppWithNamesdumpnameListTokenTNumFracChrLitStrLitSelectorKWOpSymVirtWhiteErrEOF SelectorTypeRecordSelectorTokTupleSelectorTokTokenErrUnterminatedCommentUnterminatedStringUnterminatedChar InvalidString InvalidChar LexicalErrorMalformedLiteralMalformedSelectorInvalidIndentationTokenSymBarArrLArrRFatArrRLambdaEqDefCommaSemiDotDotDot DotDotDotDotDotLtDotDotGtColonBackTickParenLParenRBracketLBracketRCurlyLCurlyRTriLTriRLtGt UnderscoreTokenOpPlusMinusMulDivExpModEqualLEQGEQ ComplementHashAtOtherTokenKWKW_elseKW_finKW_if KW_private KW_includeKW_infKW_lg2KW_lengthFromThenKW_lengthFromThenToKW_maxKW_min KW_module KW_submodule 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_constraint KW_interface KW_foreignKW_PropKW_byKW_downTokenW BlockComment LineCommentSpaceDocStrTokenVVCurlyLVCurlyRVSemiToken tokenType tokenText $fPPToken $fShowToken$fGenericToken $fNFDataToken $fEqTokenT $fShowTokenT$fGenericTokenT$fNFDataTokenT $fEqTokenErr$fShowTokenErr$fGenericTokenErr$fNFDataTokenErr$fEqSelectorType$fShowSelectorType$fGenericSelectorType$fNFDataSelectorType $fEqTokenSym$fShowTokenSym$fGenericTokenSym$fNFDataTokenSym $fEqTokenOp $fShowTokenOp$fGenericTokenOp$fNFDataTokenOp $fEqTokenKW $fShowTokenKW$fGenericTokenKW$fNFDataTokenKW $fEqTokenW $fShowTokenW$fGenericTokenW$fNFDataTokenW $fEqTokenV $fShowTokenV$fGenericTokenV$fNFDataTokenVAddLocaddLocdropLocHasLocgetLocRangefromtosourcePositionlinecolLocatedsrcRangething rangeWithin emptyRangestartmovemovesrComb rCombMayberCombsatcombLoc $fPPPosition $fPPRange$fPPNameLocated $fPPLocated $fHasLoc[] $fHasLoc(,)$fHasLocLocated $fHasLocRange$fAddLocLocated $fEqLocated $fOrdLocated $fShowLocated$fGenericLocated$fNFDataLocated$fFunctorLocated$fFoldableLocated$fTraversableLocated $fEqRange $fOrdRange $fShowRange$fGenericRange $fNFDataRange $fEqPosition $fOrdPosition$fShowPosition$fGenericPosition$fNFDataPositionTupleSel RecordSelListSel ppSelectorselName ppNestedSels $fPPSelector $fEqSelector$fShowSelector $fOrdSelector$fGenericSelector$fNFDataSelectorNat'NatInffromNatnAddnMulnExpnMinnMaxnSubnDivnModnCeilDivnCeilModnLg2nWidthnLenFromThenTogenLog widthInteger rootExactgenRoot $fShowNat'$fEqNat' $fOrdNat' $fGenericNat' $fNFDataNat'pmultpdivpmodTrieNode emptyTrie insertTrie lookupTrielookupTrieExactleaves $fShowTriePreProcNoneMarkdownLaTeXRST knownExts guessPreProcunLitPassNoPat MonoValuesExpandPropGuardsPNameUnQualQualNewNamemkUnqualmkQual getModNamegetIdentisGeneratedName $fNFDataPass $fPPNamePName $fPPPName $fNFDataPName $fEqPName $fOrdPName $fShowPName$fGenericPName$fEqPass $fOrdPass $fShowPass $fGenericPassLayoutNoLayoutConfig cfgSourcecfgStart cfgLayout cfgPreProccfgAutoIncludecfgModuleScope defaultConfigBlockVirtualExplicitlayout startsLayout endsLayoutstartsParenBlockvirterrTok $fShowBlocklexer primLexerdbgLexPrimMap primDecls primTypesSupplySupplyTFreshM liftSupply NameSource SystemNameUserNameNameNameInfo GlobalName LocalNamecmpNameDisplay ppLocName nameUniquenameInfo nameIdent mapNameIdent nameNamespacenameLoc nameFixityasPrim asOrigNamenameModPathMaybe nameModPathnameTopModuleMaybe nameTopModule runSupplyT runSupply nextUniqueM emptySupply nextUnique mkDeclaredmkLocalasLocal mkModParam freshNameForlookupPrimDecllookupPrimType $fPPNameName$fPPName $fOrdName$fEqName$fRunMSupplyTaFUN$fBaseMSupplyTn$fMonadTSupplyT$fMonadSupplyT$fApplicativeSupplyT$fFunctorSupplyT$fFreshMSupplyT$fFreshMStateT$fFreshMReaderT$fFreshMWriterT$fFreshMExceptionT$fSemigroupPrimMap $fShowPrimMap$fGenericPrimMap$fNFDataPrimMap $fShowSupply$fGenericSupply$fNFDataSupply $fGenericName $fNFDataName $fShowName$fGenericNameInfo$fNFDataNameInfo$fShowNameInfo$fGenericNameSource$fNFDataNameSource$fShowNameSource$fEqNameSourceTFunTCAddTCSubTCMulTCDivTCModTCExpTCWidthTCMinTCMax TCCeilDiv TCCeilModTCLenFromThenToUserTCTCTCNumTCInfTCBit TCIntegerTCFloatTCIntMod TCRationalTCArrayTCSeqTCFunTCTuple TCAbstractPCPEqualPNeqPGeqPFinPPrimePHasPZeroPLogicPRing PIntegralPFieldPRoundPEqPCmp PSignedCmpPLiteralPLiteralLessThan PFLiteral PValidFloatPAndPTrueTConTFTErrorHasKindkindOfKTypeKNumKProp:-> infixPrimTy builtInType$fPPKind$fPPPC $fHasKindPC $fPPUserTC $fOrdUserTC $fEqUserTC$fHasKindUserTC$fPPTC $fHasKindTC$fPPTFun $fHasKindTFun$fPPTCon $fHasKindTCon $fShowTCon$fEqTCon $fOrdTCon $fGenericTCon $fNFDataTCon $fShowTFun$fEqTFun $fOrdTFun $fBoundedTFun $fEnumTFun $fGenericTFun $fNFDataTFun$fShowTC$fEqTC$fOrdTC $fGenericTC $fNFDataTC $fShowUserTC$fGenericUserTC$fNFDataUserTC$fShowPC$fEqPC$fOrdPC $fGenericPC $fNFDataPC$fEqKind $fOrdKind $fShowKind $fGenericKind $fNFDataKindNamesOneAmbig namesToListanyOne namesFromSetunionManyNamesmapNames filterNames travNames diffNames$fSemigroupNames $fShowNames$fGenericNames $fNFDataNames FFILoadErrorCantLoadFFISrcCantLoadFFIImpl FFIDuplicates FFIInFunctor$fPPFFILoadError$fShowFFILoadError$fGenericFFILoadError$fNFDataFFILoadError SomeFFIArgFFIRetFFIArg ForeignImpl ForeignSrcgetForeignSrcPathloadForeignSrcforeignLibPathunloadForeignSrcloadForeignImplcallForeignImpl$fNFDataForeignSrc$fShowForeignSrc $fFFIArgCSize $fFFIArgPtr$fFFIArgCDouble$fFFIArgCFloat$fFFIArgWord64$fFFIArgWord32$fFFIArgWord16 $fFFIArgWord8 $fFFIRet()$fFFIRetCDouble$fFFIRetCFloat$fFFIRetWord64$fFFIRetWord32$fFFIRetWord16 $fFFIRetWord8MatchesmatchesPatMatch|||&&&~>~~><~__succeed checkThatlit matchDefaultmatch matchMaybelist><$fMonadPlusMatch$fAlternativeMatch$fMonadFailMatch $fMonadMatch$fApplicativeMatch$fFunctorMatch$fMatchesa(,,,)(,,)$fMatchesa(,,)(,)$fMatchesa(,)r1 RecordMapfieldSet displayOrderrecordElementscanonicalFieldsdisplayElements displayFieldsrecordFromFieldsrecordFromFieldsErrrecordFromFieldsWithDisplay lookupField adjustFieldtraverseRecordMapmapWithFieldNamerecordMapAccum zipRecordsM zipRecords$fTraversableRecordMap$fFoldableRecordMap$fFunctorRecordMap$fNFDataRecordMap$fShowRecordMap$fOrdRecordMap $fEqRecordMapNoPosnoPosPropCTypeTypeTSeqTBitTNumTCharTUserTTyAppTRecordTTupleTWildTLocatedTParensTInfixTParamtpNametpKindtpRangeKFunSchemaForallNamednamevaluePatternPVarPWildPTuplePRecordPListPTypedPSplitPLocatedMatchLetTypeInst NamedInstPosInstUpdHowUpdSetUpdFunUpdFieldFunDesc funDescrNamefunDescrArgOffsetPrefixOp PrefixNegPrefixComplementExprEVarELit EGenerateETupleERecordESelEUpdEListEFromTo EFromToBy EFromToDownByEFromToLessThanEInfFromECompEAppEAppTEIfEWhereETypedETypeValEFunELocatedESplitEParensEInfixEPrefixLiteralECNumECCharECFracECStringFracInfoBinFracOctFracDecFracHexFracNumInfoBinLitOctLitDecLitHexLitPolyLitTopLeveltlExporttlDoctlValue ExportTypePublicPrivate ReplInput ExprInputLetInput EmptyInputPrimType primTName primTKindprimTCts primTFixityNewtypenNamenParamsnConNamenBodyPragma PragmaNotePragmaProperty PropGuardCasepgcPropspgcExprBindDefDPrimDForeignDExpr DPropGuardsLBindDefBindbNamebParamsbDef bSignaturebInfixbFixitybPragmasbMonobDocbExportPropSynTySyn ImportSpecHidingOnlyImportImportGiModuleiAsiSpeciInstModParam mpSignaturempAsmpNamempDoc mpRenamingSigDeclSigTySyn SigPropSyn Signature sigImports sigTypeParamssigConstraintssigDecls sigFunParams ParameterFunpfNamepfSchemapfDocpfFixity ParameterTypeptNameptKindptDocptFixityptNumberDecl DSignatureDFixityDPragmaDBindDRecDPatBindDTypeDPropDLocatedImpNameImpTop ImpNestedModuleInstanceArg ModuleArg ParameterArg AddParamsModuleInstanceNamedArgModuleInstanceArgsDefaultInstArgDefaultInstAnonArg NamedInstArgs ParamDeclDParameterType DParameterFunDParameterDeclDParameterConstraintTopDecl DPrimType TDNewtypeInclude DParamDeclDModuleDImport DModParamDInterfaceConstraint NestedModuleModuleModuleInstanceModuleDefinition NormalModuleFunctorInstanceInterfaceModuleModuleGmNamemDefProgramLStringLIdentLPNameemptyModuleInstancemDeclsmImports mModParams mIsFunctor isParamDeclmodRangetsNamepsNametsFixitypsFixity prefixFixity emptyFunDescasEAppscppKind $fPPImpName$fPPModuleInstanceArg$fPPModuleInstanceNamedArg $fPPModParam$fHasLocModParam$fPPImportSpec $fPPPragma $fPPTopLevel$fHasLocTopLevel $fPPLiteral $fPPUpdHow $fHasLocNamed$fPPParameterType$fHasLocParameterType $fPPTParam$fAddLocTParam$fHasLocTParam$fPPType $fAddLocType $fHasLocType $fPPPattern$fHasLocPattern$fAddLocPattern $fPPTypeInst $fPPNewtype$fHasLocNewtype $fPPTySyn $fHasLocTySyn$fPP[]$fPPProp $fPPSchema$fAddLocSchema$fHasLocSchema$fPPParameterFun$fHasLocParameterFun $fPPPrimType$fHasLocPrimType $fPPPropSyn$fHasLocPropSyn $fPPSigDecl$fHasLocSigDecl $fPPMatch $fPPUpdField$fPPExpr $fPPBindDef$fPPBind$fPPDecl $fAddLocDecl $fHasLocDecl $fHasLocMatch $fHasLocBind $fHasLocExpr $fAddLocExpr $fPPParamDecl$fHasLocParamDecl $fPPImportG $fPPTopDecl$fPPModuleInstanceArgs$fPPModuleDefinition$fPPNestedModule $fPPModuleG$fHasLocNestedModule$fHasLocModuleG$fHasLocTopDecl $fPPProgram $fNoPosProp $fNoPosType $fNoPosTParam $fNoPosSchema$fNoPosPattern $fNoPosMatch$fNoPosTypeInst$fNoPosUpdField $fNoPosExpr$fNoPosPropSyn $fNoPosTySyn $fNoPosPragma $fNoPosBind$fNoPosNewtype $fNoPosDecl$fNoPosTopLevel$fNoPosParameterFun$fNoPosParameterType$fNoPosPrimType$fNoPosModParam$fNoPosSigDecl$fNoPosSignature$fNoPosParamDecl$fNoPosTopDecl$fNoPosNestedModule$fNoPosModuleInstanceNamedArg$fNoPosModuleInstanceArgs$fNoPosModuleDefinition$fNoPosModuleG$fNoPosProgram $fNoPos(,) $fNoPosMaybe $fNoPos[] $fNoPosRange $fNoPosNamed$fNoPosLocated $fShowProgram $fShowTopDecl$fGenericTopDecl$fNFDataTopDecl $fShowImportG$fGenericImportG$fNFDataImportG$fShowModuleInstanceArgs$fGenericModuleInstanceArgs$fNFDataModuleInstanceArgs$fShowSignature$fGenericSignature$fNFDataSignature$fShowNestedModule$fGenericNestedModule$fNFDataNestedModule $fShowModuleG$fGenericModuleG$fNFDataModuleG$fShowModuleDefinition$fGenericModuleDefinition$fNFDataModuleDefinition$fShowParamDecl$fGenericParamDecl$fNFDataParamDecl $fEqReplInput$fShowReplInput$fEqDecl $fShowDecl $fGenericDecl $fNFDataDecl $fFunctorDecl$fEqExpr $fShowExpr $fGenericExpr $fNFDataExpr $fFunctorExpr $fEqMatch $fShowMatch$fGenericMatch $fNFDataMatch$fEqBind $fGenericBind $fNFDataBind $fFunctorBind $fShowBind $fEqBindDef $fShowBindDef$fGenericBindDef$fNFDataBindDef$fFunctorBindDef$fEqPropGuardCase$fGenericPropGuardCase$fNFDataPropGuardCase$fFunctorPropGuardCase$fShowPropGuardCase $fEqUpdField$fShowUpdField$fGenericUpdField$fNFDataUpdField$fFunctorUpdField $fShowSigDecl$fGenericSigDecl$fNFDataSigDecl $fEqPropSyn $fShowPropSyn$fGenericPropSyn$fNFDataPropSyn$fFunctorPropSyn$fShowPrimType$fGenericPrimType$fNFDataPrimType$fEqParameterFun$fShowParameterFun$fGenericParameterFun$fNFDataParameterFun $fEqSchema $fShowSchema$fGenericSchema$fNFDataSchema$fFunctorSchema$fEqProp $fShowProp $fGenericProp $fNFDataProp $fFunctorProp $fEqTySyn $fShowTySyn$fGenericTySyn $fNFDataTySyn$fFunctorTySyn $fEqNewtype $fShowNewtype$fGenericNewtype$fNFDataNewtype $fEqTypeInst$fShowTypeInst$fGenericTypeInst$fNFDataTypeInst$fFunctorTypeInst $fEqPattern $fShowPattern$fGenericPattern$fNFDataPattern$fFunctorPattern$fEqType $fShowType $fGenericType $fNFDataType $fFunctorType $fEqTParam $fShowTParam$fGenericTParam$fNFDataTParam$fFunctorTParam$fEqParameterType$fShowParameterType$fGenericParameterType$fNFDataParameterType $fEqNamed $fShowNamed$fFoldableNamed$fTraversableNamed$fGenericNamed $fNFDataNamed$fFunctorNamed $fEqUpdHow $fShowUpdHow$fGenericUpdHow$fNFDataUpdHow $fEqFunDesc $fShowFunDesc$fGenericFunDesc$fNFDataFunDesc$fFunctorFunDesc $fEqPrefixOp$fShowPrefixOp$fGenericPrefixOp$fNFDataPrefixOp $fEqLiteral $fShowLiteral$fGenericLiteral$fNFDataLiteral $fEqFracInfo$fShowFracInfo$fGenericFracInfo$fNFDataFracInfo $fEqNumInfo $fShowNumInfo$fGenericNumInfo$fNFDataNumInfo$fShowTopLevel$fGenericTopLevel$fNFDataTopLevel$fFunctorTopLevel$fFoldableTopLevel$fTraversableTopLevel$fEqExportType$fShowExportType$fOrdExportType$fGenericExportType$fNFDataExportType $fEqPragma $fShowPragma$fGenericPragma$fNFDataPragma$fEqImportSpec$fShowImportSpec$fGenericImportSpec$fNFDataImportSpec $fEqModParam$fShowModParam$fGenericModParam$fNFDataModParam$fShowModuleInstanceNamedArg$fGenericModuleInstanceNamedArg$fNFDataModuleInstanceNamedArg$fShowModuleInstanceArg$fGenericModuleInstanceArg$fNFDataModuleInstanceArg $fShowImpName$fGenericImpName$fNFDataImpName $fEqImpName $fOrdImpName FreeAbstract freeAbstractFVSfvsSType AbstractTypeatNameatKindatCtrs atFixitiyatDocntNamentParams ntConstraints ntConNamentFieldsntDoctsParams tsConstraintstsDeftsDocTypeWithSource WithSourcetwsType twsSourcetwsRangeArgDescr argDescrFunargDescrNumber TypeSourceTVFromModParamTVFromSignature TypeWildCardTypeOfRecordFieldTypeOfTupleFieldTypeOfSeqElementLenOfSeqTypeParamInstNamedTypeParamInstPos DefinitionOf LenOfCompGen TypeOfArg TypeOfResFunAppTypeOfIfCondExprTypeFromUserAnnotationGeneratorOfListCompTypeErrorPlaceHolderTVarInfo tvarSourcetvarDescTVarTVFreeTVBoundTRecTNewtypeTPFlavor TPModParam TPUnifyVar TPSchemaParam TPTySynParamTPPropSynParamTPNewtypeParam TPPrimParamtpUniquetpFlavtpInfosVarssPropssType ModVParammvpNamemvpTypemvpDoc mvpFixity ModTParammtpNamemtpKindmtpDoc ModParamNamesmpnTypesmpnTySynmpnConstraintsmpnFunsmpnDocmpQualmpIface mpParameters FunctorParams allParamNamesmtpParamtMonoisMono schemaParam tySynParam propSynParam newtypeParam modTyParamtpfNametvInfotvUnique noArgDescr tvSourceName quickApply kindResulttpVar superclassSetnewtypeConTypeabstractTypeTCisFreeTV isBoundTVtIsError tHasErrorstIsNat'tIsNumtIsInftIsVartIsFuntIsSeqtIsBit tIsInteger tIsIntMod tIsRationaltIsFloattIsTupletIsRec tIsBinFun tSplitFunpIsFinpIsPrimepIsGeqpIsEqualpIsZeropIsLogicpIsRingpIsField pIsIntegralpIsRoundpIsEqpIsCmp pIsSignedCmp pIsLiteralpIsLiteralLessThan pIsFLiteralpIsTruepIsWidth pIsValidFloattNumtZerotOnetTwotInftNat' tAbstracttNewtypetBittInteger tRationaltFloattIntModtArraytWordtSeqtChartStringtRectTupletFuntNoUsertErrortf1tf2tf3tSubtMultDivtModtExptMintCeilDivtCeilModtLenFromThenTo=#==/=pZeropLogicpRing pIntegralpFieldpRoundpEqpCmp pSignedCmppLiteralpLiteralLessThan>==pHaspTruepAnd pSplitAndpFin pValidFloatpPrime pNegNumericnoFreeVariables freeParams addTNamesppNewtypeShort ppNewtypeFull pickTVarName $fPPModTParam $fPPArgDescr$fPPTypeSource $fPPTVarInfo $fPPWithNames $fOrdTParam$fHasKindTParam$fPPTVar$fPPWithNames0 $fOrdTVar$fEqTVar $fHasKindTVar$fPPWithNames1$fPPWithNames2 $fOrdType$fHasKindNewtype $fHasKindType $fOrdNewtype$fPPWithNames3$fHasKindTySyn$fPPWithNames4 $fPPModVParam$fPPModParamNames$fHasKindAbstractType $fFVSSchema$fFVS(,)$fFVS[] $fFVSMaybe $fFVSType$fFreeAbstractType$fFreeAbstractTCon$fFreeAbstract(,)$fFreeAbstract[]$fShowAbstractType$fGenericAbstractType$fNFDataAbstractType$fShowModParamNames$fGenericModParamNames$fNFDataModParamNames$fShowModVParam$fGenericModVParam$fNFDataModVParam $fShowTVar $fGenericTVar $fNFDataTVar$fShowTVarInfo$fGenericTVarInfo$fNFDataTVarInfo$fShowTypeSource$fGenericTypeSource$fNFDataTypeSource$fShowArgDescr$fGenericArgDescr$fNFDataArgDescr$fGenericTPFlavor$fNFDataTPFlavor$fShowTPFlavor$fShowModTParam$fGenericModTParam$fNFDataModTParamaInfaNataNat'anAdd|-|aMul|^||/||%|aMinaMaxaWidthaCeilDivaCeilModaLenFromThenToaTVaranAbstractType aFreeTVaraBitaSeqaWordaCharaTupleaRec|->|aFin|=||/=||>=|aAndaTrueaLiteralaLiteralLessThanaLogicanError tRebuild'tRebuildtContAddtMaxtWidthtotalop1op2op3tOpFFIBasicRefType FFIInteger FFIRational FFIFloatSize FFIFloat32 FFIFloat64 FFIWordSizeFFIWord8 FFIWord16 FFIWord32 FFIWord64FFIBasicValTypeFFIWordFFIFloat FFIBasicType FFIBasicVal FFIBasicRefFFITypeFFIBoolFFIBasicFFIArrayFFITuple FFIRecord FFIFunType ffiTParams ffiArgTypes ffiRetType$fShowFFIFunType$fGenericFFIFunType$fNFDataFFIFunType $fShowFFIType$fGenericFFIType$fNFDataFFIType$fShowFFIBasicType$fGenericFFIBasicType$fNFDataFFIBasicType$fShowFFIBasicRefType$fGenericFFIBasicRefType$fNFDataFFIBasicRefType$fShowFFIBasicValType$fGenericFFIBasicValType$fNFDataFFIBasicValType$fShowFFIFloatSize$fGenericFFIFloatSize$fNFDataFFIFloatSize$fShowFFIWordSize$fGenericFFIWordSize$fNFDataFFIWordSize widthIdenttranslateExprToNumT ParseError HappyError HappyErrorMsgHappyUnexpectedHappyOutOfTokensppErrortnamesNTnamesNTnamesDnamesBnamesP boundNames boundNamesSettnamesDtnamesCtnamesTErrorMultipleSignaturesSignatureNoBind PragmaNoBindMultipleFixities FixityNoBind MultipleDocsRemovePatternsremovePatterns $fPPError $fMonadNoPatM$fApplicativeNoPatM$fFunctorNoPatM$fRemovePatternsNestedModule$fRemovePatterns[]$fRemovePatternsModuleG$fRemovePatternsExpr$fRemovePatternsProgram $fShowError$fGenericError $fNFDataError NoSignatureExpandPropGuardsMrunExpandPropGuardsMexpandPropGuardsexpandModuleDef expandTopDecl expandDecl expandBind patternToExprnewNameaddImplicitNestedImportsRenamerWarningSymbolShadowed UnusedNamePrefixAssocChangedModKindAFunctor ASignatureAModuleDepName NamedThing ModParamName ConstratintAt RenamerError MultipleSyms UnboundNameOverlappingSymsWrongNamespace FixityErrorOverlappingRecordUpdateInvalidDependencyMultipleModParamsInvalidFunctorImportUnexpectedNestModuleKindMismatch depNameLoc $fPPDepName $fPPModKind$fPPRenamerError$fPPRenamerWarning$fOrdRenamerWarning$fEqRenamerWarning$fShowRenamerWarning$fGenericRenamerWarning$fNFDataRenamerWarning$fShowRenamerError$fGenericRenamerError$fNFDataRenamerError$fEqRenamerError$fOrdRenamerError $fShowModKind$fGenericModKind$fNFDataModKind $fEqModKind $fOrdModKind $fEqDepName $fOrdDepName $fShowDepName$fGenericDepName$fNFDataDepName IfaceDecl ifDeclName ifDeclSig ifDeclIsPrim ifDeclPragmas ifDeclInfix ifDeclFixity ifDeclDoc IfaceDeclsifTySyns ifNewtypesifAbstractTypesifDecls ifModules ifSignatures ifFunctors IfaceNamesifsName ifsNested ifsDefines ifsPublicifsDocIfaceGIfaceifNamesifParams ifDefinesifaceForgetName ifModNameifaceIsFunctor emptyIfacefilterIfaceDeclsifaceDeclsNames ifacePrimMapifaceOrigNameMap$fMonoidIfaceDecls$fSemigroupIfaceDecls$fShowIfaceDecls$fGenericIfaceDecls$fNFDataIfaceDecls $fShowIfaceG$fGenericIfaceG$fNFDataIfaceG$fShowIfaceDecl$fGenericIfaceDecl$fNFDataIfaceDecl$fShowIfaceNames$fGenericIfaceNames$fNFDataIfaceNames ExportSpec exportedDecls exportedNames exportName allExportedexported exportBind exportType isExportedisExportedBindisExportedType$fMonoidExportSpec$fSemigroupExportSpec$fNFDataExportSpec$fShowExportSpec$fGenericExportSpecDeclDefdName dSignature dDefinitiondPragmasdInfixdFixitydDoc DeclGroup Recursive NonRecursiveFromLetERecESetETAbsETAppEAbs EProofAbs EProofApp EPropGuardsmDocmExports mParamTypes mParamFunsmParamConstraintsmParams mFunctorsmNestedmTySyns mNewtypes mPrimTypes mSubmodules mSignatures TCTopEntity TCTopModuleTCTopSignaturetcTopEntitytNametcTopEntityToModule emptyModulefindForeignDeclsfindForeignDeclsInFunctorsisParametrizedModule groupDeclsePrimeErroreStringeCharppLam splitWhilesplitLocdropLocssplitAbssplitApp splitTAbs splitProofAbs splitTApp splitProofApp splitExprInst $fPPDeclGroup$fPPWithNames5$fPPTCTopEntity$fShowTCTopEntity$fGenericTCTopEntity$fNFDataTCTopEntity $fShowDeclDef$fGenericDeclDef$fNFDataDeclDef$fShowDeclGroup$fGenericDeclGroup$fNFDataDeclGroupTypeMapTMtvartcontrectnewtypeTypesMapListLnilconsTrieMapemptyTMnullTMlookupTMalterTMunionTMtoListTMmapMaybeWithKeyTM membersTMinsertTM insertWithTMmapTM mapWithKeyTM mapMaybeTM $fTrieMapMapa$fTrieMapList[] $fShowTypeMap$fTrieMapTypeMapType$fFunctorTypeMap$fFoldableTypeMap$fTraversableTypeMap $fFunctorList$fFoldableList$fTraversableListsplitVarSummandssplitVarSummandsplitConstSummandsplitConstFactorIntervaliLoweriUpperIntervalUpdateNoChangeInvalidInterval NewIntervals typeInterval tvarIntervalupdateIntervalcomputePropIntervals propInterval ppIntervalsppIntervalsWithNames ppIntervaliIsExactiIsFin iIsPosFiniOverlap iIntersectiAnyiAnyFiniConstiAddiMuliExpiMiniMaxiSubiDiviModiCeilDiviCeilModiWidthiLenFromThenTo$fShowIntervalUpdate $fEqInterval$fShowIntervalSolvedSolvedIfUnsolved UnsolvableCtxt SolverCtxt intervalssaturatedAsmpselseTry solveOpts matchThenguarded $fMonoidCtxt$fSemigroupCtxt $fPPSolved $fShowSolvedsolveValidFloat solveZeroInstsolveLogicInst solveRingInstsolveIntegralInstsolveFieldInstsolveRoundInst solveEqInst solveCmpInstsolveSignedCmpInstsolveFLiteralInstsolveLiteralInstsolveLiteralLessThanInstcryIsFin cryIsFinType cryIsEqual cryIsNotEqualcryIsGeq primeTable cryIsPrimesimplify simplifyStepTVarsapSubst SubstErrorSubstRecursive SubstEscapedSubstKindMismatchSubst emptySubstmergeDistinctSubst singleSubstuncheckedSingleSubstsingleTParamSubst@@defaultingSubst listSubstlistParamSubst isEmptySubst substBinds substToList!$.$fmap' apSubstMaybeapplySubstToVarapSubstTypeMapKeys $fPPSubst$fApplicativeDone$fTVarsTCTopEntity$fTVarsModuleG$fTVarsDeclDef $fTVarsDecl$fTVarsDeclGroup $fTVarsMatch $fTVarsExpr $fTVarsSchema $fTVarsTySyn $fTVarsMap$fTVarsTypeMap $fTVarsList $fTVarsType $fTVars(,) $fTVars[] $fTVarsMaybe $fFunctorDone$fFoldableDone$fTraversableDone $fShowSubst PathElementTConArg TNewtypeArgTRecArgPathUnificationErrorUniTypeMismatchUniKindMismatchUniTypeLenMismatch UniRecursiveUniNonPolyDepends UniNonPolyResultMGU runResultuniErrorrootPath isRootPathextPathemptyMGUdoMGUmgumguManybindVarppPathEl$fPPPath $fShowPath $fGenericPath $fNFDataPath$fShowPathElement$fGenericPathElement$fNFDataPathElement fastTypeOf fastSchemaOfFFITypeErrorReasonFFIBadWordSizeFFIBadFloatSizeFFIBadArrayTypeFFIBadComponentTypes FFIBadTypeFFINotFunction FFITypeError$fFVSFFITypeErrorReason$fFVSFFITypeError$fTVarsFFITypeErrorReason$fTVarsFFITypeError$fShowFFITypeErrorReason$fGenericFFITypeErrorReason$fNFDataFFITypeErrorReason$fShowFFITypeError$fGenericFFITypeError$fNFDataFFITypeError improveProps improveProp improveLit improveEq ShowParseable showParseable maybeNameDoc$fShowParseableName$fShowParseableTParam$fShowParseableLocated$fShowParseableMaybe$fShowParseable[]$fShowParseableDeclGroup$fShowParseableDeclDef$fShowParseableDecl$fShowParseableMatch$fShowParseableSelector$fShowParseableType$fShowParseableIdent$fShowParseableInt$fShowParseable(,)$fShowParseableExpr mkIfaceDecl genIfaceNames genModDefinesgenIfacegenIfaceWithNamesConstraintSourceCtComprehension CtSplitPat CtTypeSigCtInst CtSelector CtExactType CtEnumeration CtDefaultingCtPartialTypeFun CtImprovement CtPatternCtModuleInstanceCtPropGuardsExhaustiveCtFFI DelayedCt dctSource dctForalldctAsmpsdctGoals HasGoalSln hasDoSelecthasDoSetHasGoalhasNamehasGoalGoal goalSource goalRangegoalLitGoalGoalsgoalSetsaturatedPropSet literalGoalsliteralLessThanGoalsVarTypeExtVarCurSCC SolverConfig solverPath solverArgs solverVerbosesolverPreludePathdefaultSolverConfig litGoalToGoal goalToLitGoallitLessThanGoalToGoalgoalToLitLessThanGoal emptyGoals nullGoals fromGoals goalsFromList insertGoalselSrcaddTVarsDescsAfteraddTVarsDescsBeforeppUse$fPPConstraintSource$fTVarsConstraintSource $fTVarsGoal $fFVSGoal $fOrdGoal$fEqGoal$fTVarsDelayedCt$fFVSDelayedCt$fTVarsHasGoal $fTVarsGoals $fShowGoals $fShowHasGoal$fShowDelayedCt$fGenericDelayedCt$fNFDataDelayedCt $fShowGoal $fGenericGoal $fNFDataGoal$fShowConstraintSource$fGenericConstraintSource$fNFDataConstraintSource$fShowSolverConfig$fGenericSolverConfig$fNFDataSolverConfigdebugLogSolver startSolver stopSolver resetSolver withSolver debugBlockproveImpcheckUnsolvable tryGetModel shrinkModel inNewFrame declareVarsassume unsolvable isNumeric$fDebugLogSubst$fDebugLogGoal$fDebugLogType $fDebugLogDoc$fDebugLogMaybe $fDebugLog[]$fDebugLogChar$fMk(,,)$fMk(,)$fMkType$fMkTVar $fMkInteger$fMk()BIWhat BIFunctor BIInterface BIPrimitive BIForeignBIAbstractTypeBadBacktickInstanceBIPolymorphicArgumentBINestedBIMultipleParams KindMismatchTooManyTypeParamsTyVarWithParamsTooManyTySynParamsTooFewTyParamsRecursiveTypeDecls TypeMismatchSchemaMismatch RecursiveType UnsolvedGoalsUnsolvableGoalsUnsolvedDelayedCtUnexpectedTypeWildCardTypeVariableEscaped NotForAllTooManyPositionalTypeParamsBadParameterKind%CannotMixPositionalAndNamedTypeParamsUndefinedTypeParameterRepeatedTypeParameter AmbiguousSize BareTypeAppUndefinedExistVar TypeShadowingMissingModTParamMissingModVParamMissingModParamFunctorInstanceMissingArgumentFunctorInstanceBadArgumentFunctorInstanceMissingNameFunctorInstanceBadBacktickUnsupportedFFIKindUnsupportedFFITypeNestedConstraintGuard"DeclarationRequiresSignatureCtrGrdInvalidConstraintGuardTemporaryErrorWarningDefaultingKindDefaultingWildType DefaultingToNonExhaustivePropGuards cleanupErrorssubsumeserrorImportanceexplainUnsolvablecomputeFreeVarNames $fPPWarning $fFVSWarning$fTVarsWarning $fFVSError $fTVarsError$fShowBadBacktickInstance$fGenericBadBacktickInstance$fNFDataBadBacktickInstance $fShowBIWhat$fGenericBIWhat$fNFDataBIWhat $fShowWarning$fGenericWarning$fNFDataWarningLkpTyVar TLocalVar TOuterVarKRW typeParamskCtrsAllowWildCards NoWildCardsKRO lazyTParams allowWildKindMKMunKMRWiErrors iWarningsiSubst iExistTVars iSolvedHas iNameSeedsiCtsiHasCtsiScope iBindTypesiSupplyROiRangeiVarsiTVars iExtModulesiExtSignatures iExtScopeiSolvedHasLazy iMonoBinds iCallStacksiSolver iPrimNames iSolveCounter ScopeName ExternalScope LocalScope SubModuleSignatureScopeTopSignatureScope MTopModuleInferMIMunIM InferOutput InferFailedInferOK NameSeedsseedTVarseedGoal InferInputinpRangeinpVarsinpTSyns inpNewtypesinpAbstractTypes inpSignatures inpTopModulesinpTopSignatures inpParams inpNameSeeds inpMonoBinds inpCallStacks inpSearchPath inpPrimNames inpSupply inpSolver nameSeeds bumpCounter runInferM selectorScopeioinRange inRangeMbcurRange recordErrorrecordErrorLoc abortIfErrors recordWarning getSolver getPrimMapnewGoalnewGoalsgetGoalsaddGoals collectGoalssimpGoal simpGoals newHasGoal addHasGoal getHasGoals solveHasGoal newLocalName newGoalNamenewTVarnewTVar'checkParamKind newTParam freshTParamnewTypeunify applySubstapplySubstPredsapplySubstGoalsgetSubst extendSubst varsWithAsmps lookupVar lookupTParam lookupTSyn lookupNewtypelookupAbstractTypelookupParamTypelookupSignaturelookupTopModule lookupFunctor lookupModulelookupModParamexistVargetTSyns getNewtypesgetAbstractTypes getParamTypesgetParamConstraintsgetTVarsgetBoundInScope getMonoBinds getCallStacks getSignaturescheckTShadowing withTParam withTParamsnewScope newLocalScopenewSignatureScopenewTopSignatureScopenewSubmoduleScopenewModuleScopeupdScope endLocalScope endSubmodule endModule endSignatureendTopSignaturegetScope getCurDeclsaddDeclsaddTySyn addNewtype addPrimType addParamType addSignatures addSubmodules addFunctors addParamFunaddParameterConstraints addModParam inNewScope withVarType withVarTypeswithVar withMonoType withMonoTypesrunKindM kLookupTyVarkWildOK kRecordErrorkRecordWarningkIOkNewType kLookupTSynkLookupNewtypekLookupParamTypekLookupAbstractType kExistTVar kInstantiateTkSetKindkInRange kNewGoals kInInferM$fFreshMInferM$fMonadFixInferM$fMonadFailInferM $fMonadInferM$fApplicativeInferM$fFunctorInferM$fMonadFailKindM $fMonadKindM$fApplicativeKindM$fFunctorKindM$fShowInferOutput$fShowNameSeeds$fGenericNameSeeds$fNFDataNameSeeds tryHasGoal ExpectedMonoTupleSelectorOutOfRange MissingFieldUnexpectedTupleShapeUnexpectedRecordShapeUnexpectedSequenceShape BadSelectorBadInstantiationCaptured BadProofNoAbsBadProofTyVarsNotEnoughArgumentsInKindBadApplicationFreeTypeVariableBadTypeApplicationRepeatedVariableInForallBadMatchEmptyArmUndefinedTypeVaraibleUndefinedVariableProofObligationsameAreSameSameIfNotSametcExprtcDeclstcModuleonlyNonTrivial $fSameTParam $fSameSchema$fSame[] $fSameType $fSameField $fMonadTcM$fApplicativeTcM $fFunctorTcMMBQualdoBacktickInstance$fAddParamsDeclGroup $fAddParams[]$fAddParamsMap$fAddParamsDecl$fAddParamsTySyn$fAddParamsNewtype$fRewTypeSchema$fRewTypeRecordMap $fRewType[] $fRewTypeType $fRewValMatch$fRewValDeclDef $fRewValDecl$fRewValDeclGroup $fRewValExpr$fRewValRecordMap $fRewVal[]defaultLiteralsflitDefaultCandidatesimproveByDefaultingWithPuredefaultReplExpr'defaultReplExprdefaultAndSimplifysimplifyAllConstraintsproveModuleTopLevelproveImplicationtryProveImplication checkSchemacheckPropGuardscheckParameterType checkTySyn checkPropSyn checkNewtype checkPrimType checkTypecheckParameterConstraintsMaybeCheckedTypeChecked UncheckedTypeArg tyArgName tyArgTypeuncheckedTypeArginstantiateWith rewModule$fTrieMapRewMap'(,,) NamingEnv zipByTextNamewithoutnamingEnvNamesnamingEnvFromNames namespaceMaplookupNS lookupListNS singletonNS toPrimMap toNameDisp visibleNamesqualify filterPNames filterUNames findAmbig findShadowing forceUnambig shadowing mapNamingEnv travNamingEnvisEmptyNamingEnvmodParamsNamingEnvunqualifiedEnvinterpImportEnv $fPPNamingEnv$fSemigroupNamingEnv$fMonoidNamingEnv$fShowNamingEnv$fGenericNamingEnv$fNFDataNamingEnv WordTooWide UnsupportedUnsupportedSymbolicOp EvalErrorEx EvalError InvalidIndex DivideByZeroNegativeExponent LogNegative UserError LoopErrorNoPrimBadRoundingModeBadValueNoMatchingPropGuardCaseFFINotSupportedFFITypeNumTooBigEvalReadyThunk CallStackreadydisplayCallStackcombineCallStacks pushCallFrame maybeReady delayFill evalSpark blackhole getCallStack withCallStackmodifyCallStackrunEval evalPanic wordTooWide$fMonoidCallStack$fSemigroupCallStack$fShowEvalError $fPPEvalError$fExceptionEvalErrorEx$fShowEvalErrorEx$fPPEvalErrorEx $fMonadIOEval $fMonadEval$fApplicativeEval $fFunctorEval$fExceptionUnsupported$fPPUnsupported$fExceptionWordTooWide$fShowWordTooWide$fPPWordTooWide$fShowUnsupportedInModule BindsNames modImportsmodKind modInstancesmodMods modDefines modPublicmodStateTopDefTopModTopInst modNestedmodToMap ifaceToMod ifaceSigToMod modBuilder topModuleDefs topDeclsDefsdefsOf newModParam $fFunctorMod$fMonoidBuildNamingEnv$fSemigroupBuildNamingEnv$fBindsNamesTParam$fBindsNamesSchema$fBindsNames[]$fBindsNamesMaybe$fBindsNamesNamingEnv$fBindsNamesInModule$fBindsNamesInModule0$fBindsNamesInModule1$fBindsNamesInModule2$fBindsNamesInModule3$fBindsNamesInModule4$fBindsNamesInModule5$fBindsNamesInModule6$fBindsNamesInModule7$fFunctorInModule$fTraversableInModule$fFoldableInModule$fShowInModule ResolvedExt ResolvedLocalResolvedModule rmodDefines rmodPublicrmodKind rmodNested rmodImportsresolveImports$fHasCurScopeMod$fHasCurScope()EnvCheckCheckAll CheckOverlap CheckNone RenModParamrenModParamNamerenModParamRangerenModParamSigrenModParamInstance rwWarningsrwErrorsrwSupplyrwNameUseCount rwCurrentDeps rwDepGraphrwExternalDepsroLocroNames roExternalroCurMod roNestedModsroResolvedModules roModParamsroFromModParamRenameM unRenameM RenamerInfo renSupply renContextrenEnv renIfacesNameTypeNameBindNameUse runRenamer setCurMod getCurMod getNamingEnvsetResolvedLocalslookupResolved setModParamsfoldLoop getModParamgetNamesFromModParamsgetLocalModParamDepssetNestedModulenestedModuleOrigcollectIfaceDepsdepsOfdepGroupcurLoclocatedwithLoc shadowNames checkOverlapcheckShadowing shadowNames' recordUseaddDep warnUnused getExternalgetExternalModgetTopModuleIface recordImportlookupModuleThing lookupDefines checkIsModulelookupDefinesAndSubs$fFreshMRenameM$fMonadRenameM$fApplicativeRenameM$fFunctorRenameM$fMonoidRenameM$fSemigroupRenameM $fEqEnvCheck$fShowEnvCheckRenamerename RenamedModulermModule rmDefines rmInScope rmImported renameModulerenameTopDecls renameVar renameType$fPPRenamedModule$fRenamePropSyn $fRenameTySyn $fRenameMatch$fRenameTypeInst $fRenameExpr$fRenameFunDesc$fRenameUpdField$fRenamePattern$fRenamePropGuardCase$fRenameBindDef $fRenameBind $fRenameType $fRenameProp$fRenameTParam$fRenameSchema$fRenameNewtype $fRenameDecl$fRenameSigDecl$fRenameParameterFun$fRenameParameterType$fRenamePrimType$fRenameNestedModule$fRenameModuleInstanceArg$fRenameModuleInstanceNamedArg$fRenameModuleInstanceArgs$fRenameImpName$fRenameModParam$fRenameTopDecl TraverseNamestraverseNamesIP traverseNames$fTraverseNamesTySyn$fTraverseNamesFFIType$fTraverseNamesFFIFunType$fTraverseNamesModVParam$fTraverseNamesModTParam$fTraverseNamesNewtype$fTraverseNamesTVar$fTraverseNamesUserTC$fTraverseNamesTC$fTraverseNamesTCon$fTraverseNamesType$fTraverseNamesArgDescr$fTraverseNamesTypeSource$fTraverseNamesTVarInfo$fTraverseNamesTPFlavor$fTraverseNamesTParam$fTraverseNamesSchema$fTraverseNamesDeclDef$fTraverseNamesDecl$fTraverseNamesDeclGroup$fTraverseNamesMatch$fTraverseNamesExpr$fTraverseNamesExportSpec$fTraverseNamesName$fTraverseNamesLocated$fTraverseNamesSet$fTraverseNamesMaybe$fTraverseNames[]moduleInstanceSudoVInstdoTInstdoTVInstdoMapdoSet$fModuleInstanceModParam$fModuleInstanceModVParam$fModuleInstanceModTParam$fModuleInstanceModParamNames$fModuleInstanceIfaceNames$fModuleInstanceDecl$fModuleInstanceDeclGroup$fModuleInstanceAbstractType$fModuleInstanceNewtype$fModuleInstanceTySyn$fModuleInstanceSchema$fModuleInstanceType$fModuleInstanceModuleG$fModuleInstanceImpName$fModuleInstanceName$fModuleInstanceLocated$fModuleInstance[] doFunctorInstDefsdefsFreeVarsfreeVarsDepsvalDepstyDepstyParams transDeps moduleDeps $fMonoidDeps$fSemigroupDeps$fFreeVarsNewtype$fFreeVarsTCon$fFreeVarsTVar$fFreeVarsType$fFreeVarsSchema$fFreeVarsMatch$fFreeVarsDeclDef$fFreeVarsDecl $fFreeVars[] $fDefsMatch $fDefsDecl$fDefsDeclGroup$fDefs[]$fFreeVarsExpr$fFreeVarsDeclGroup$fEqDepsgenerateForeignHeader $fEqInclude $fOrdIncludefloat32ExpPrecfloat64ExpPrec toFFIFunTypeinferTopModulecheckE inferBinds checkSigB checkTopDecls ppWarningppNamedWarning ppNamedErrorTypeEnv envTypeMapTValueTVBit TVIntegerTVFloatTVIntMod TVRationalTVArrayTVSeqTVStreamTVTupleTVRecTVFun TVNewtype TVAbstracttValTytNumTy tNumValTyisTBittvSeq tvFloat64finNat' lookupTypeVar bindTypeVarevalTypeevalNewtypeBody evalValType evalNumTypeevalTF $fShowTValue$fSemigroupTypeEnv$fMonoidTypeEnv $fShowTypeEnv$fGenericTValue$fNFDataTValue $fEqTValueBF bfExpWidth bfPrecWidthbfValuefpOptsfpRound fpCheckStatusfpPPfpLitfloatFromRationalfloatToRationalfloatToInteger floatFromBits floatToBitsfloatFromDoubleFPArith2BackendSBitSWordSIntegerSFloatSEvalisReady sDeclareHole sDelayFillsSpark sPushFramesWithCallStacksModifyCallStack sGetCallStack mergeEvalassertSideCondition raiseErrorbitAsLitwordLen wordAsLit wordAsChar integerAsLitfpAsLitbitLitwordLit integerLit fpExactLititeBititeWord iteIntegeriteFloatbitEqbitOrbitAndbitXor bitComplementwordBit wordUpdatepackWord unpackWord wordFromIntjoinWord splitWord extractWordwordOrwordAndwordXorwordComplementwordPlus wordMinuswordMultwordDivwordMod wordSignedDiv wordSignedMod wordShiftLeftwordShiftRightwordSignedShiftRightwordRotateLeftwordRotateRight wordNegatewordLg2wordEqwordSignedLessThan wordLessThanwordGreaterThan wordToIntwordToSignedIntintPlus intNegateintMinusintMultintDivintModintEq intLessThanintGreaterThanintToZnznToIntznPlusznNegateznMinusznMultznEqznRecipfpEq fpLessThan fpGreaterThan fpLogicalEqfpNaNfpPosInffpPlusfpMinusfpMultfpDivfpNegfpAbsfpSqrtfpFMAfpIsZerofpIsNegfpIsNaNfpIsInffpIsNorm fpIsSubnormfpToBits fpFromBits fpToInteger fpFromInteger fpToRationalfpFromRational SRationalsNumsDenomIndexDirection IndexForward IndexBackward invalidIndex cryUserErrorcryNoPrimErrorsDelay intToRationalratio rationalReciprationalDivide rationalFloorrationalCeiling rationalTruncrationalRoundAwayrationalRoundToEven rationalAdd rationalSubrationalNegate rationalMul rationalEqrationalLessThanrationalGreaterThan iteRationalenumerateIntBits'enumerateIntBitsbigNatToIntegerintegerToBigNat PrimeModulusProjectivePointpxpypztoProjectivePoint primeModulus ec_doubleec_add_nonzeroec_mult ec_twin_multW4ResultW4ErrorW4ConnevalConnW4Eval evalPartial SomeSymFn What4FunCacheWhat4w4w4defsw4funsw4uninterpWarnsw4Evalw4ThunkdoEvalgetSymw4Andw4Notw4ITE addDefEqn addSafety evalErrorassertBVDivisorassertIntDivisorsModAddsModSubsModMult sModNegatesLg2lazyItew4bvShlw4bvLshrw4bvAshrw4bvRolw4bvRorfpRoundingMode fpBinArithfpCvtToIntegerfpCvtToRationalfpCvtFromRational sModRecip$fMonadIOW4Conn $fMonadW4Conn$fApplicativeW4Conn$fFunctorW4Conn$fBackendWhat4$fMonadIOW4Eval $fMonadW4Eval$fApplicativeW4Eval$fFunctorW4Eval$fFunctorW4ResultBVConcretebinBVunaryBVbvValmkBvsignedBV signedValue integerToCharlg2ppBVmask liftBinIntMod fpRoundMode$fBackendConcrete$fShowBV$fShowConcrete IndexSegmentBitIndexSegmentWordIndexSegmentSeqMap indexSeqMap lookupSeqMap finiteSeqMapinfiniteSeqMapenumerateSeqMap streamSeqMap reverseSeqMap updateSeqMap concatSeqMap splitSeqMap dropSeqMap delaySeqMapmemoMap zipSeqMap mapSeqMap mergeSeqMapshiftSeqByInteger barrelShifter$fFunctorSeqMap WordValueforceWordValuewordVal bitmapWordVal joinWordVal takeWordVal dropWordValextractWordValwordValLogicOpwordValUnaryOp joinWordsreverseWordVal wordValAsLit asWordValwordValueEqualsInteger asWordList asBitsMapenumerateWordValueenumerateWordValueRevenumerateIndexSegmentsassertWordValueInBoundsdelayWordValueshiftWordByIntegershiftWordByWordupdateWordByWordshiftSeqByWord wordValueSizeindexWordValueupdateWordValue mergeWord mergeWord'$fGenericWordValueGenValueVRecordVTupleVBitVInteger VRationalVFloatVSeqVWordVStreamVFunVPolyVNumPolyEvalOpts evalLogger evalPPOpts forceValueppValuewordlamflamtlamnlamilammkSeqfromVBit fromVInteger fromVRationalfromVSeqfromSeq fromWordValasIndex fromVWordvWordLen tryFromBitsfromVFun fromVPoly fromVNumPoly fromVTuple fromVRecord fromVFloat lookupRecorditeValue mergeValue$fShowGenValue$fGenericGenValue TestResult FailFalse FailErrorGen returnTests returnTests' dumpableType randomValueisPass testableTypeexhaustiveTests randomTests randomTests'PrimPFunPStrictPWordFun PFloatFunPTyPolyPNumPolyPFinPolyPPrimPValevalPrim GenEvalEnvEvalEnvenvVarsenvTypesppEnvemptyEnv bindVarDirectbindType lookupType$fMonoidGenEvalEnv$fSemigroupGenEvalEnv$fGenericGenEvalEnv UnaryWordBinWordUnaryBinarymkLit ecNumberVintVratioV ecFractionVfromZVbinaryunary ringBinary ringUnary ringNullaryintegralBinary fromIntegerVaddVsubVnegateVmulVdivVexpVcomputeExponentmodV toIntegerVrecipV fieldDivideVroundOpfloorVceilingVtruncV roundAwayV roundToEvenVandVorVxorV complementVlg2VsdivVsmodVtoSignedIntegerVcmpValue bitLessThanbitGreaterThanvalEqvalLtvalGt eqCombine lexCombineeqV distinctV lessThanV lessThanEqV greaterThanVgreaterThanEqVsignedLessThanVzeroVjoinSeqjoinVtakeVdropVsplitVreverseV transposeVccatV logicBinary logicUnaryassertIndexInBounds indexPrim updatePrimfromToV fromThenToVfromToLessThanV fromToByVfromToByLessThanV fromToDownByVfromToDownByGreaterThanVinfFromV infFromThenVshiftLeftReindexshiftRightReindexrotateLeftReindexrotateRightReindex logicShift intShifter wordShifter shiftShrink rotateShrinksshrVerrorV valueToChar valueToStringfoldlVfoldl'VscanlVrandomVparmapV sparkParMapfpConst fpBinArithV fpRndModefpRndRNEfpRndRNAfpRndRTPfpRndRTNfpRndRTZgenericFloatTablegenericPrimTableValue primTabletoExpr FreshVarFns freshBitVar freshWordVarfreshIntegerVar freshFloatVarVarShapeVarBit VarInteger VarRationalVarFloatVarWord VarFinSeqVarTuple VarRecordFinTypeFTBit FTIntegerFTIntMod FTRationalFTFloatFTSeqFTTupleFTRecord FTNewtype ProverResult AllSatResult ThmResultCounterExample EmptyResult ProverErrorCounterExampleTypeSafetyViolationPredicateFalsified ProverStats ProverCommand pcQueryType pcProverName pcVerbose pcValidate pcProverStats pcExtraDecls pcSmtFilepcExprpcSchemapcIgnoreSafety QueryTypeSatQuery ProveQuery SafetyQuerySatNumAllSatSomeSat predArgTypesfinType unFinType flattenShapes flattenShapevarShapeToValuefreshVar computeModel modelPred varModelPred varToExpr$fShowQueryType $fShowSatNum moduleEnvevalExpr checkPropevalNewtypeDecls evalDeclsevalSel evalSetSel$fMonoidListEnv$fSemigroupListEnv DynamicEnvDEnvdeNamesdeDeclsdeTySynsdeEnvFileInfo fiFingerprint fiIncludeDeps fiImportDeps fiForeignDepsLoadedSignatureLoadedModuleData lmdInterface lmdModule lmForeignSrc LoadedModule LoadedModuleGlmName lmFilePath lmModuleId lmNamingEnv lmFileInfolmData LoadedEntity ALoadedModuleALoadedFunctorALoadedInterface LoadedModuleslmLoadedModuleslmLoadedParamModuleslmLoadedSignatures ModulePathInFileInMem ModContext mctxParams mctxExported mctxDecls mctxNames mctxNameDispModContextParamsInterfaceParamsNoParamsCoreLint NoCoreLint ModuleEnvmeLoadedModules meNameSeeds meEvalEnv meCoreLint meMonoBindsmeFocusedModule meSearchPathmeDynEnvmeSupplyresetModuleEnvinitialModuleEnv focusModule loadedModulesloadedNonParamModulesloadedNewtypeshasParamModules allDeclGroupsmodContextParamNames modContextOf dynModContext focusedEnvmodulePathLabelgetLoadedEntitiesgetLoadedModulesgetLoadedNameslmModule lmInterfaceisLoadedisLoadedParamModisLoadedInterfacelookupTCEntityaddLoadedSignatureaddLoadedModuleremoveLoadedModulefileInfo deIfaceDecls$fMonoidModContext$fSemigroupModContext$fPPModulePath$fOrdModulePath$fEqModulePath$fMonoidLoadedModules$fSemigroupLoadedModules$fMonoidDynamicEnv$fSemigroupDynamicEnv$fNFDataModuleEnv$fGenericModuleEnv$fGenericDynamicEnv$fShowLoadedModules$fGenericLoadedModules$fNFDataLoadedModules$fShowLoadedModuleG$fGenericLoadedModuleG$fNFDataLoadedModuleG$fShowFileInfo$fGenericFileInfo$fNFDataFileInfo$fShowLoadedModuleData$fGenericLoadedModuleData$fNFDataLoadedModuleData$fShowModulePath$fGenericModulePath$fNFDataModulePath$fGenericCoreLint$fNFDataCoreLint BrowseHowBrowseExported BrowseInScopebrowseModContextevalForeignDeclsSBVEvalsbvEval SBVResultSBVErrorSBV sbvStateVarsbvDefRelations literalSWordfreshBV_ freshSBool_freshSInteger_ svToInteger svFromIntegerashrlshrshl$fMonadSBVResult$fApplicativeSBVResult$fFunctorSBVResult $fBackendSBV$fMonadIOSBVEval$fMonadSBVEval$fApplicativeSBVEval$fFunctorSBVEvalversion commitHashcommitShortHash commitBranch commitDirtydisplayVersion parseModName parseHelpNameparseProgramWith parseModule parseProgram parseExprWith parseExpr parseDeclWith parseDeclparseDeclsWith parseDeclsparseLetDeclWith parseLetDecl parseReplWith parseReplparseSchemaWith parseSchema IncludeError IncludeFailedIncludeDecodeFailedIncludeParseError IncludeCycleremoveIncludesModuleppIncludeError$fMonadFailNoIncM $fMonadNoIncM$fApplicativeNoIncM$fFunctorNoIncM$fShowIncludeError$fGenericIncludeError$fNFDataIncludeErrorModuleM ModuleInputminpCallStacks minpEvalOptsminpByteReader minpModuleEnv minpTCSolverModuleT unModuleT roLoading roEvalOpts roCallStacks roFileReader roTCSolver ModuleWarningTypeCheckWarningsRenamerWarnings ModuleErrorModuleNotFound CantFindFileBadUtf8 OtherIOErrorModuleParseErrorRecursiveModules RenamerErrors NoPatErrorsExpandPropGuardsErrorNoIncludeErrorsTypeCheckingFailed OtherFailureModuleNameMismatchDuplicateModuleName FFILoadErrors ErrorInFile ImportSource FromModule FromImport FromSigImportFromModuleInstanceimportedModulemoduleNotFound cantFindFilebadUtf8 otherIOErrormoduleParseErrorrecursiveModules renamerErrors noPatErrorsexpandPropGuardsErrornoIncludeErrorstypeCheckingFailedmoduleNameMismatchduplicateModuleName ffiLoadErrors errorInFilewarntypeCheckWarningsrenamerWarningsemptyRO runModuleT runModuleM getByteReader readBytes getModuleEnv getTCSolver setModuleEnvmodifyModuleEnvgetLoadedMaybe loadingImport loadingModuleloadingModInstance interactiveloadinggetImportSource getIfaces getLoaded getAllLoadedgetAllLoadedSignatures getNameSeeds getSupply setMonoBinds setNameSeeds setSupply unloadModule loadedModulemodifyEvalEnvM modifyEvalEnv getEvalEnvgetEvalOptsAction getEvalOptsgetFocusedModulesetFocusedModule getSearchPathwithPrependedSearchPath getFocusedEnv getDynEnv setDynEnv withLogger$fPPImportSource$fEqImportSource$fPPModuleError$fNFDataModuleError$fPPModuleWarning$fMonadIOModuleT$fFreshMModuleT$fMonadTModuleT$fMonadFailModuleT$fMonadModuleT$fApplicativeModuleT$fFunctorModuleT$fShowModuleWarning$fGenericModuleWarning$fNFDataModuleWarning$fShowModuleError$fShowImportSource$fGenericImportSource$fNFDataImportSourceTCActiontcActiontcLintertcPrimsActTCLinter lintCheck lintModulenoPatloadModuleByPathloadModuleFrom doLoadModulefullyQualified moduleFile findModulefindFile addPreludeloadDepsfindDepsfindDepsOfModule findDepsOffindModuleDeps findDeps' checkExpr checkDecls checkModule exprLinter declsLinter moduleLintertcTopEntitytLinter typecheck genInferInput benchmarkExpr ModuleRes ModuleCmdloadModuleByNamecheckModuleByPathgetFileDependenciesgetModuleDependenciesSpecMSpecT SpecCacherunSpecT liftSpecT getSpecCache setSpecCachemodifySpecCachemodify specializespecializeExprspecializeMatchwithDeclGroupsspecializeEWherespecializeDeclGroupsspecializeConstdestEProofApps destETApps destEProofAbs destETAbs freshNameinstantiateSchemainstantiateExpr traverseSndW4ProverConfig W4ExceptionW4ExW4PortfolioFailure defaultProver proverNames setupProversatProvesatProveOffline$fExceptionW4Exception$fShowW4Exception$fMonadIOMultiSat$fMonadMultiSat$fApplicativeMultiSat$fFunctorMultiSatSBVProverConfigSBVPortfolioException $fExceptionSBVPortfolioException$fShowSBVPortfolioExceptionSmoke Z3NotFound OptionDescroptName optAliases optDefaultoptCheckoptHelpoptEffEnvVal EnvStringEnvProgEnvNumEnvBool REPLException FileNotFoundDirectoryNotFound NoPatErrorNoIncludeErrorTooWideModuleSystemError EvalPolyErrorInstantiationsNotFoundTypeNotTestableEvalInParamModule SBVExceptionREPLunREPLlNamelPathrunREPLraisecatchfinallyrethrowEvalError getPrompt resetTCSolver getPPValOptsclearLoadedMod setLoadedMod getLoadedMod setEditPath getEditPath clearEditPath setSearchPathprependSearchPathgetProverConfigshouldContinuestop unlessBatchasBatchvalidEvalContextupdateREPLTitlesetUpdateREPLTitle setPutStr getPutStr getLoggerrPutStr rPutStrLnrPrint getExprNames getTypeNamesgetPropertyNames getModNames getRandomGen setRandomGen withRandomGenuniqifyparseSearchPathsetUser tryGetUsergetUser getKnownUsergetUserShowProverStatsgetUserProverValidateuserOptionsWithAliases userOptionsparsePPFloatFormatparseFieldOrder getUserSatNum whenDebug smokeTest$fPPREPLException$fExceptionREPLException$fMonadMaskREPL$fMonadCatchREPL$fMonadThrowREPL $fFreshMREPL$fMonadBaseControlIOREPL$fMonadBaseIOREPL $fMonadIOREPL $fMonadREPL$fApplicativeREPL $fFunctorREPL$fIsEnvValFieldOrder $fIsEnvVal[] $fIsEnvVal(,) $fIsEnvValInt$fIsEnvValBool $fPPSmoke $fShowSmoke $fEqSmoke $fShowEnvVal$fShowREPLException helpForNamedVListE evalDeclGroupppEValueevaluate$fMonadE$fApplicativeE $fFunctorE $fMonoidEnv$fSemigroupEnv TestReport reportExpr reportResultreportTestsRunreportTestsPossibleQCModeQCRandom QCExhaustCommandExitCode CommandOk CommandError CommandBodyExprArg FileExprArgDeclsArg ExprTypeArg ModNameArg FilenameArg OptionArgShellArgHelpArgNoArg CommandDescrcNamescArgscBodycHelp cLongHelpCommand AmbiguousUnknown commandList runCommandqcCmdqcExprsatCmdproveCmdonlineProveSatofflineProveSatwithRWTempFile moduleCmd loadPreludeloadCmd setOptionCmd handleCtrlC replParse replParseExprinteractiveConfig liftModuleCmdmoduleCmdResult replCheckExpr replEvalExprsanitize splitCommand findCommandfindCommandExact findNbCommand parseCommand$fOrdCommandDescr$fEqCommandDescr$fShowCommandDescr $fEqQCMode $fShowQCModeGF28rotRroundConstantssboxunSBoxt0Funct0t1t2t3u0Funcu0u1u2u3 GHC.MaybeNothingpreludeContentspreludeReferenceContents floatContents arrayContentssuiteBContentsprimeECContentscryptolTcContentsGHC.ShowShow MaybeAnon NormalNameAnonModArgNameAnonIfaceModName text-1.2.5.0Data.Text.InternalTextGHC.BaseString maybeAnonText nameVariant nameVariantsghc-prim GHC.TypesTruemarkdownlatex splitQual fnumTokens dropWhite byteForChar AlexInputinputalexInputPrevCharalexPosInpLexSInCharNormalInString InCommentAction startComment endComment addToCommentstartEndComment startString endString addToString startCharendChar addToChar mkQualIdentmkQualOpemitemitS emitFancynumToken fromDigit selectorToken readDecimal alexGetBytenUniquenFixitynLocppNameforeignImplSrcforeignSrcPathforeignSrcFPtrGHC.ForeignPtr ForeignPtr unix-2.7.2.2System.Posix.DynamicLinkerdlopen!System.Posix.DynamicLinker.CommondlcloseforeignSrcLoadedRecsNextTyParamNummkModParamNamemkRecordmkEApp anonTyApp mkNoImplDeclmkDocmkModulemkAnonymousModulemkModuleInstanceAnondesugarInstImport AnonThing AnonIfaceModAnonArgMkAnon toImpNamemkAnonSsTokenssPrevTokParseMunPP parseStringparselexerP happyError errorMessage customErrorexpected mkModNamemkSchemagetNamegetNumgetChrgetStrnumLitfracLitintValmkFixity fromStrLitvalidDemotedTypeunOpbinOpeFromTo eFromToByeFromToByTyped eFromToDownByeFromToDownByTypedasETyped eFromToTypeeFromToLessThaneFromToLessThanType exprToNumT exportDecl exportNewtype exportModulemkParFun mkParType changeExport mkTypeInstmkTParammkTySyn mkPropSyn mkNewtype typeToDeclpolyTermmkPoly mkProperty mkIndexedDeclmkPropGuardsDeclmkConstantPropGuardsDecl mkIndexedExpr mkGeneratemkIf mkPrimDecl mkForeignDeclmkPrimTypeDecldistrLoc mkPropGuardsmkPropmkNested mkSigDeclmkInterfaceConstraint mkParDeclsonlySimpleImports mkInterface' mkInterfacemkIfacePropSynmkModuleInstance ufToNamedexprToFieldPath mkSelectormkBacktickImportmkImport mkTopModsmkTopSig desugarMod desugarTopDsnamesDsnamesEnamesPsnamesMnamesArm boundLNamestnamesDstnamesBtnamesEtnamesPtnamesMtnamesS annotTopDsannotDsannotDannotB annotTySyn annotPropSyn annotPrimType checkSigstoSigtoPragmatoFixitytoDocsaddImplicitNestedImports'isToQualisToNamemkImpFalseknownSupportedFloat solveRingSeqsolveSignedCmpSeqpBin tryGeqKThan tryGeqThanK geqByInterval tryCancelVar tryEqMulConst tryEqAddInf tryAddConsttryLinearSolutionmatchLinearUnifier matchLinear$!$fmapdefaultFreeVar plainSubst typeSelectsolverlogger loadTcPreludeflatGoalGHC.Num*Int solveSelectormkSelSlntrivialProofObligation checkTypeIsexprType exprSchema convertible checkDecl integralTVars fracTVars simpHasGoals quickSolverproveImplicationIO checkTUserappTy doCheckType checkKindinstantiateWithNamesinLocal ThunkStateUnforcedVoidUnderEvaluation ForcedErrForced GHC.Conc.Syncretry sparkThunkunDelayIOcombineCallStacks' signatureDefscurModcurTopexternalModules doneModules nameSupplychangesmodOuter modImportedTodo todoModuleisDone forceFinishforceResolveInstforceResolveModforgetdoStep knownPName knownImpName knownModule tryImport doImportSteptryInstanceMaybe tryInstancedoInstantiateByName doInstantiatedoInstancesStep tryModule doModulesStep doModuleStep renameModule' renameDeclsrenameSigDecls doModParam doModParamsresolveNameMaybe resolveName mkFakeName renameSchema renameQual renameMatch renamePat renamePatsmkEInfix DefinedInst ParamInst UseParameter UseModule AddDeclParams checkArity Data.EitherLeftRightcheckArgcheckParamTypecheckParamValue mkParamDefcheckSimpleParameterValue ConvertResultDirectParamsParamDir GenHeaderM convertFunconvertTypeParam convertTypeconvertMultiTypeconvertBasicTypeconvertBasicTypeInArrayconvertBasicValTypeconvertBasicRefTypecomponentSuffixtypedefFromInclude pickNames toFFITypetoFFIBasicTypemkPrimmkPrim'appTyssmallestinferP inferMatch inferCArm guessType generalize checkMonoBcheckExhaustivecheckPropGuardCaseintegerRecipMod ghc-bignumGHC.Num.IntegerIntegerISIPINGHC.Num.BigNat bigNatSub bigNatSqr bigNatMul bigNatIsZero bigNatIsOne bigNatAddBigNat#bigNatSubUnsafe bigNatRem oneBigNatrecipModBigNat shiftLBigNat shiftRBigNat testBitBigNat zeroBigNatzromod_addmod_halfmod_mulmod_sub mod_squaremul2mul3mul4mul8ec_addec_sub ec_normalizenormalizeForTwinMultWordVal largeBitSize BitmapValbitsValueLessThan runOneTest randomBit randomInteger randomWord randomStreamrandomSequence randomTuple randomRecordevalTesttypeSize typeValues returnOneTest randomFloat getUninterpFnapplyAESStateFunc updateFrontupdateFront_word updateBackupdateBack_wordListEnvleVarsleStatic EvalPrimsevalPropcacheCallStackevalNewtypeDeclfillHoleevalDecl evalListEnvevalComp branchEnvs evalMatch BasicRefRetinitBasicRefRetclearBasicRefRetmarshalBasicRefRetGetRetforeignPrimPoly foreignPrimgetRetFromAsOutArgsgetRetAsOutArgs getRetAsValuegetMarshalBasicValArggetMarshalBasicValRet withWordTypegetMarshalBasicRefArgForeign.StorableStorablehashbranchdirtygetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirHappyStkenvSeen envIncPath envFileReader getIncPath withIncPathNoIncM fromIncPath includeFailedpushPath failsWith collectErrorsData.TraversablemapMnoIncludeModulenoIncludeProgram noIncTopDeclresolveInclude readIncludedoW4Eval prepareQuery withMaybeFileGHC.IO.StdHandleswithFileMaybe singleQuery runProverprocessResults parseValues parseValueCheckerUserEnv eLoadedMod eEditFile eContinueeIsBatch eModuleEnveUserEnveLogger eUpdateTitle eTCConfig eTCSolvereTCSolverRestarts eRandomGen defaultRWmkPrompt mkUserEnv checkBase showModHelp fromVListvFinPoly bitsToIntegersignedBitsToIntegercmpOrder lexComparelexSignedCompare indexPrimOnecommands nbCommands nbCommandListexpectedCoveragesafeCmd cmdProveSatmkSolverResultbyteStringToIntegerbytestring-0.11.3.1Data.ByteString.Internal ByteStringreplCheckDeclsreplPrepareCheckedExprbindItVariablebindItVariableValbindItVariables sanitizeEnduncons