+v|p>      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd e f g h i j k l m n o p q r s t u v w x y z { | } ~                                   ! " # $ % & ' ( ) * + , - . /0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     !!!!""""""""""""""""""""""""### # # # # ################$%% %!%"%#%$%%%&%'%(%)%*%+%,%-%.%/%0%1%2%3%4%5%6%7%8%9%:%;%<%=%>%?%@%A%B%C%D%E%F%G&H&I&J&K&L&M'N(O(P(Q(R(S(T(U(V(W(X(Y(Z([(\(](^(_(`(a(b)c)d)e)f)g)h)i*j*k*l*m*n*o*p*q*r*s*t*u*v+w+x+y+z+{+|+}+~++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, , , , , ,,,,,,,,,,,,,,,,,,, ,!,",#,$,%,&,',(,),*,+,,,-,.,/,0,1,2,3,4,5,6,7,8,9,:,;,<,=,>,?,@,A,B,C,D,E,F,G,H,I,J,K,L,M,N-O-P-Q-R-S-T-U-V-W-X-Y-Z-[-\-].^/_/`/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q0r0s0t0u0v0w0x0y0z0{0|0}0~00000000000001112223345666777788888888888888888888888888899999:::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; ; ; ;;;;;;;;;;;;;;;;;;; ;!;";#;$;%;&;';(;);*;+;,;-;.;/;0<1<2<3<4<5<6<7<8<9<:<;<<<=<><?<@<A<B<C<D<E<F<G<H<I<J<K=L=M=N=O=P=Q=R=S=T=U>V>W>X>Y>Z>[>\>]>^>_>`>a>b>c>d>e>f>g>h>i>j>k>l>m>n>o>p>q>r?s?t?u?v?w?x?y?z?{?|?}?~??????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA A A A A AAAAAAAAAAAAAAAAAAB B!B"B#B$B%B&B'B(B)B*B+B,B-B.B/B0B1B2B3B4B5B6B7B8B9B:B;B<B=BGC(c) 2014-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Trustworthy>?@>?@>?@(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeD Safe-Inferred ABCDEFGHIJKLMBHIJKLM ABCDEFGHIJKLM(c) 2014-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-InferredvThis 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) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe+NOPQRSNOPQRS(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe (Natural numbers with an infinity element &Some algerbaic properties of interest: W1 * x = x x * (y * z) = (x * y) * z 0 * x = 0 x * y = y * x x * (a + b) = x * a + x * b 'Some algeibraic properties of interest: gx ^ 0 = 1 x ^ (n + 1) = x * (x ^ n) x ^ (m + n) = (x ^ m) * (x ^ n) x ^ (m * n) = (x ^ m) ^ nnSub x y = Just z iff z is the unique value such that Add y z = Just x.  Rounds down. <y * q + r = x x / y = q with remainder r 0 <= r && r < yWe don't allow H in the first argument for two reasons: 1. It matches the behavior of I, 2. The well-formedness constraints can be expressed as a conjunction. Rounds up.  lg2 x = y, iff y" is the smallest number such that  x <= 2 ^ ynWidth nL is number of bits needed to represent all numbers from 0 to n, inclusive. nWidth x = nLg2 (x + 1).Compute the logarithm of a number in the given base, rounded down to the closest integer. The boolean indicates if we the result is exact (i.e., True means no rounding happened, False means we rounded down). The logarithm base is the second argument.CCompute the number of bits required to represent the given integer.    (c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeRepresentation of intervals. Intervals always include the lower bound. Intervals include the upper bound if: * either the upper bound is finite, or * the upper bound is  and isFinite == False.AInvariant: if the upper bound is finite, then `isFinite == True`. x[x,y] Interval (Nat x) (Nat y) True [x,inf] Interval (Nat x) Inf False [x,inf) Interval (Nat x) Inf True Lower bound Upper bound5Do we know this to be a finite value. Note that for  [inf,inf] this field is Tp (i.e., this field is not talking about the size of the interval, but, rather, about if it contains infinity).Any possible value.,)The first interval is definiately smaller-)The first interval is definiately smaller.!The two intervals do not overlap.U !"#$%&'()*+,-.VBinary monotonic fun. to liftWBinary monotonic fun. to liftCompute finitnenessXY !"#$%&'()*+,-. %!"#$&'()*+,-.U !"#$%&'()*+,-.VWXY(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeFZThe preprocessor for Z[The preprocessor for [\]^/012345_`aZ[/0123455/21043 \^]/210345_`aZ[(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeFb Rounds up.  lg2 x = y, iff y" is the smallest number such that  x <= 2 ^ ycCompute the logarithm of a number in the given base, rounded down to the closest integer. The boolean indicates if we the result is exact (i.e., True means no rounding happened, False means we rounded down). The logarithm base is the second argument.hdefghijklmnopqrstuvwx6789:;<=y>?@ABCDEFGHIJKLMNOPQRSTUVz{WX|}~YZ[\bc'6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\'YMUTSRQPON>LKJIHGFEDCBA@?=Z[\6987:<;VWX9defghijklmnopqxwvutsr6987:<;=y>LKJIHGFEDCBA@?MUTSRQPONV{zWX|}~YZ[\bcHIJOPQRT(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred]KMaps string names to values, allowing for partial key matches and querying.`)Insert a value into the Trie. Will call * if a value already exists with that key.a)Return all matches with the given prefix.b^Given a key, return either an exact match for that key, or all matches with the given prefix.c%Return all of the values from a Trie.]^_`abc]^_`abc]^_`abc]^_`abc (c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeF d3Information about an infix expression of some sort.foperatorg left argumenthright argumrntioperator precedencejoperator associativityk Information about associativity.u.Pretty print an infix expression of some sort.v2Display a numeric values as an ordinar (e.g., 2nd)w9The suffix to use when displaying a number as an oridinaldefghijklmnopqrstu1Non-infix leaves are printed with this precedence+pattern to check if sub-thing is also infix"Pretty print this infix expressionvwQdefghijklmnopqrstuvwopqrsuknmldefghijvwt defghijknmlopqrstuvw (c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeAn empty range.[Caution: using this on the LHS of a use of rComb will cause the empty source to propegate."xyz{|}~xyz{|}~"}~{|xyzxyz{|}~E(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-InferredF error tokenwhite space tokenvirtual token (for layout)symboloperatorkeywordstring literal identifiercharacter literalvalue, base, number of digits.Virtual tokens, inserted by layout processing.7An explicit layout block, expecting this ending token.Virtual layout blockFile that we are working onSettings for layout processingPreprocessor settingsImplicit includes ^When we do layout processing should we add a vCurly (i.e., are we parsing a list of things).'Drop white-space tokens from the input.      !      !% )      !  Trustworthy;"Returns the tokens in the last position of the input that we processed. White space is removed, and layout processing is done as requested. This stream is fed to the parser.#oReturns the tokens and the last position of the input that we processed. The tokens include whte space tokens.     "# !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"##"      !     "# !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ (c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Trustworthy$%$%$%$% (c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe234&zThis packages together a type with some names to be used to display the variables. It is used for pretty printing types.*Compute the n-th variant of a name (e.g., a5). Compute all variants of a name: a, a1, a2, a3, ...-@Expand a list of base names into an infinite list of variations. &'()*+,-.Zdefghijklmnopqrstuvw&'()*+,-. (&')*+.-, &'()*+,-.(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred/Built-in constants._5Converts a numeric type into its corresponding value.bBuilt-in types.c : Num -> Num -> Num -> Num Example: ,[ 1, 5 .. 9 ] :: [lengthFromThenTo 1 5 9][b]d : Num -> Num -> Num -> Num Example: ([ 1, 5 .. ] :: [lengthFromThen 1 5 b][b]e  : Num -> Num -> Numf  : Num -> Num -> Numg  : Num -> Numh  : Num -> Num -> Numi  : Num -> Numj  : Num -> Num -> Numk  : Num -> Num -> Numl  : Num -> Num -> Numm  : Num -> Num -> Numn  : Num -> Num -> NumE/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqC/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqCbnmlkjihgfedc/a`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210opq/2a`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210b nmlkjihgfedcopq(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeFTuLocation informationv  Cmp aw  Arith ax  x >= 10y  x == 10z  fin x|Location information}_, just some type.~  ([8], [32]) { x : [8], y : [32] } 2 + xA type variable or synonym inf a 10 Bit [8] a  [8] -> [8]Location information  (x # y)  x : [8]  [ x, y, z ]  { x = (a,b,c), y = z }  (x,y,z)  _  xp <- eSelectors are used for projecting from various components. Each selector has an option spec to specify the shape of the thing that is being selected. Currently, there is no surface syntax for list selectors, but they are used during the desugaring of patterns.=List selection. Optionally specifies the length of the list.@Record selection. Optionally specifies the shape of the record.UZero-based tuple selection. Optionally specifies the shape of the tuple (one-based).position annotation  \x y -> x `(x + 1), x is a type  1 : [8]  1 + x where { x = 2 }  if ok then e1 else e2  f `{x = 8}, f`{8}  f x  [ 1 | x <- xs ]  [1, 3 ...] [1, 5 .. 117 ]  [1,2,3]  e.l  { x = 1, y = 2 }  (1,2,3)  0x10  split  x Literals. "hello"0x10 (HexLit 2);Infromation about the representation of a numeric constant.polynomial literalcharacter literaln-digit hex literaloverloaded decimal literaln-digit octal literaln-digit binary literal%Export information for a declaration.:Input at the REPL, which can either be an expression or a let statement. Type name Type params ConstructorBindings. Notes:The parser does not associate type signatures and pragmas with their bindings: this is done in a separate pass, after de-sugaring pattern bindings. In this way we can associate pragmas and type signatures with the variables defined by pattern bindings as well.Currently, there is no surface syntax for defining monomorphic bindings (i.e., bindings that will not be automatically generalized by the type checker. However, they are useful when de-sugaring patterns. Defined thing Parameters DefinitionOptional type sigOptional pragmasIs this a monomorphic binding&The list of names following an import.INVARIANT: All of the @ entries in the list are expected to be unqualified names; the  or  % constructors should not be present.An import declaration.#A string with location information.+A qualified name with location information.!A name with location information. !Module names are just namespaces.LINVARIANT: the list of strings should never be empty in a valid module name.@Add a binding name to the export list, if it should be exported.&Check to see if a binding is exported.EAdd a type synonym name to the export list, if it should be exported.+Check to see if a type synonym is exported.0Succeeds if the expression is an infix operator.3Display the thing selected by the selector, nicely.Conversational3 printing of kinds (e.g., to use in error messages)rstuvwxyz{|}~     rstuvwxyz{|}~          {~}|tzyxwvursrstzyxwvu{ ~}|     (c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe234FB!Non-recursive declaration"Mutually recursive declarations%Hdo we need this type? it seems like it can be computed from the expr(if e : t1, then cast e : t2 as long as we can prove that 't1 = t2'. We could express this in terms of a built-in constant. `cast :: {a,b} (a =*= b) => a -> b`4Using the constant is a bit verbose though, because we end up with both the source and target type. So, instead we use this language construct, which only stores the target type, and the source type can be reconstructed from the expression.jAnother way to think of this is simply as an expression with an explicit type annotation.)RIf `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.*Proof 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 R0 term, which should be of kind o.+Function value,Function application-Type application.Function Value/Use of a bound variable0?List comprehensions The type caches the type of the expr.1 If-then-else2Elimination for tuplerecordlist3 Record value4 Tuple value5"List value (with type of elements)6Built-in constant91-1 constants.:user-defined, T;  (_, _, _)< _ -> _= [_] _>Bit?Inf@NumbersABuilt-in type constants.Predicate symbols.B Cmp _C Arith _DHas sel type field does not appear in schemasE fin _F _ >= _G _ /= _H _ == _IType constants.MType variables.OAUnique, kind, ids of bound type variables that are in scope The . is a description of how this type came to be.P;The type is "simple" (i.e., it contains no type functions).Q#The type is supposed to be of kind oRLThe internal representation of types. These are assumed to be kind correct.S Record typeTThis is just a type annotation, for a type that was written as a type synonym. It is useful so that we can use it to report nicer errors. Example: `TUser T ts t` is really just the type t7 that was written as `T ts` by the user. UType variable (free or bound)VType constant with argsWType parameters.YParameter identifierZKind of parameter[Name from source, if any.\ Named recordsb Type synonym.dNamee ParametersfEnsure body is OKg Definitionh The types of polymorphic values.mKinds, classify types.rA Cryptol module.Make an expression that is & pre-applied to a type and a message.Make a function type.Eliminate type synonyms.Equality for numeric types.+Make a greater-than-or-equal-to constraint.A Has1 constraint, used for tuple and record selection.Make multiplication type.Make addition type.Make a min type. !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~bcdefghijklmn     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~rstuvwxymqponhijklbcdefg\]^_`aWXYZ[zRVUTSQPMONILKJAHGFEDCB9@?>=<;:78&6543210/.-,+*)('#%$ "!{|}~bnmlkjihgfedc    { "!#%$&6543210/.-,+*)('789@?>=<;:AHGFEDCBILKJMONPQRVUTSWXYZ[\]^_`abcdefghijklmqponrstuvwxyz{|}~n(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-InferredTypes of built-in constants.(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe+Panic from an Eval context.3A sequencing operation has gotten an invalid index. For things like `(inf) or `(0-1)For division by 0.For when we know that a word is too wide and will exceed gmp's limits (though words approaching this size will probably cause the system to crash anyway due to lack of memory)For   (c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe-246FNOTE this assumes that the sequence of bits is big-endian and finite, so the first element of the list will be the most significant bit.NOTE this produces a list of bits that represent a big-endian word, so the most significant bit is the first element of the list.`An evaluated type. These types do not contain type variables, type synonyms, or type functions.8Generic value type, parameterized by bit and word types. -width, value The value may contain junk bitsSmart constructor for  !s that checks for the width limitCreate a packed word of n bits.A type lambda that expects a Type.Generate a stream.!This is strict!"Construct either a finite sequence, or a stream. In the finite case, record whether or not the elements were bits, to aid pretty-printing.#Construct one of: * a word, when the sequence is finite and the elements are bits * a sequence, when the sequence is finite but the elements aren't bits * a stream, when the sequence is not finitehNOTE: do not use this constructor in the case where the thing may be a finite, but recursive, sequence.$Extract a bit value.%Extract a sequence.'SExtract a packed word. Note that this does not clean-up any junk bits in the word.)3Turn a value into an integer represented by w bits.* Extract a function from a value.+,Extract a polymorphic function from a value.,Extract a tuple from a value.-Extract a record from a value..Lookup a field in a record./dGiven an expected type, returns an expression that evaluates to this value, if we can determine it.AXXX: View patterns would probably clean up this definition a lot.@      Bit-widthValue Masked result !"#$%&'()*+,-./012=      !"#$%&'()*+,-./@     210 !"#$%&'()*+,-./.      !"#$%&'()*+,-./012(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-InferredE3@A test result is either a pass, a failure due to evaluating to False;, or a failure due to an exception raised during evaluation7pApply a testable value to some arguments. Note that this function assumes that the values come from a call to  testableTypeP (i.e., things are type-correct). We run in the IO monad in order to catch any  EvalErrors.34567345673654736547(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone246B89:;<=>?@ABCD-    "$%'*+,-.89:;<=>?@ABCD-:9<;=>?@8    "$*+,-.%'DABC89:;<=>?@ABCD(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred FJApply a testable value to some randomly-generated arguments. Returns  if the function returned /, or `Just counterexample` if it returned T.oPlease note that this function assumes that the generators match the supplied value, otherwise we'll panic.GGiven a (function) type, compute generators for the function's arguments. Currently we do not support polymorphic functions. In principle, we could apply these to random types, and test the results. H{A generator for values of the given type. This fails if we are given a type that lacks a suitable random value generator. IGenerate a random bit value.JBGenerate a random word of the given length (i.e., a value of type [w]m) The size parameter is assumed to vary between 1 and 100, and we use it to generate smaller numbers first.K(Generate a random infinite stream value.LGenerate a random sequence. Generally, this should be used for sequences other than bits. For sequences of bits use "randomWord". The difference is mostly about how the results will be displayed. MGenerate a random tuple value.NGenerate a random record value. EFFunction under testArgument generatorsSizeGHIJKLMN EFGHIJKLMN EFGHIJKLMN EFGHIJKLMN(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe24U.Bind a variable in the evaluation environment.V%Lookup a variable in the environment.WBind a type variable of kind *.XLookup a type variable. OPQRSTUVWXYZ OPQRSTUVWX SOPQRZYTUVWX OPQRSTUVWXYZ(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeF[Evaluation for types.\@Reduce type functions, rising an exception for undefined values.@Reduce type functions, rising an exception for undefined values.[\[\[\[\(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Trustworthy EFHM cMake a numeric constant.eCreate a packed word iKTurn a normal binop on Integers into one that can also deal with a bitsize.o%Lexicographic ordering on two values.q;Process two elements based on their lexicographic ordering.w4Join a sequence of sequences into a single sequence.ySplit implementation.z!Split into infinitely many chunks{Split into finitely many chunks}BMerge two values given a binop. This is used for and, or and xor.,Indexing operations that return one element..Indexing operations that return many elements.Produce a random value with the given seed. If we do not support making values of the given type, return zero of that type. TODO: do better than returning zero6]^_`abcdebit size of the resulting wordbaseexponentfbase exponent maskmodulusghijklmnopqrstuvwxyz{|}~dthe Integer value (argument 2) may contain junk bits, but the Int (argument 3) will always be clean6]^_`abcdefghijklmnopqrstuvwxyz{|}~6bcdefa`g_^hi]jklmnopqrstuvwxyz{|}~6]^_`abcdefghijklmnopqrstuvwxyz{|}~(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeF1Introduce the constructor function for a newtype. Evaluate a comprehension. UTurn a list of matches into the final environments for each iteration of the branch. 9Turn a match into the list of environments it represents.        OT OT       (c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe-2468      (c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe234FMakes 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.3Pick types for unconstrained unification variables.1Apply the substitution to the keys of a type map.3WARNING: This instance assumes that the quantified variables in the types in the substitution will not get captured by the quantified variables. This is reasonable because there should be no shadowing of quantified variables but, just in case, we make a sanity check and panic if somehow capture did occur. #replaces free vars#(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe -FXThe most general unifier is a substitution and a set of constraints on bound variables. (c) 2014-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe Given a typing environment and an expression, compute the type of the expression as quickly as possible, assuming that the expression is well formed with correct type annotations. BYields the return type of the selector on the given argument type.  (c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred6All ways to split a type in the form: `a + t1`, where a is a variable.5Check if we can express a type in the form: `a + t1`.<Check if we can express a type in the form: `k + t1`, where kw is a constant > 0. This assumes that the type has been simplified already, so that constants are floated to the left. <Check if we can express a type in the form: `k * t1`, where kv is a constant > 1 This assumes that the type has been simplified already, so that constants are floated to the left. !(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-InferredGiven a (function) type, compute all possible inputs for it. We also return the total number of test (i.e., the length of the outer list. }Apply a testable value to some arguments. Please note that this function assumes that the values come from a call to  (i.e., things are type-correct)QGiven a fully-evaluated type, try to compute the number of values in it. Returns  for infinite types, user-defined types, polymorhic types, and, currently, function spaces. Of course, we can easily compute the sizes of function spaces, but we can't easily enumerate their inhabitants. TReturns all the values in a type. Returns an empty list of values, for types where  returned . "(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-InferredThe names defined by a newtype.IThe names defined and used by a group of mutually recursive declarations.4The names defined and used by a single declarations.The names defined and used by a single declarations in such a way that they cannot be duplicated in a file. For example, it is fine to use xH on the RHS of two bindings, but not on the LHS of two type signatures./The names defined and used by a single binding. The names used by an expression.)The names defined by a group of patterns.HThe names defined by a pattern. These will always be unqualified names.&The names defined and used by a match.<The names defined and used by an arm of alist comprehension.;Remove some defined variables from a set of free variables.]Given the set of type variables that are in scope, compute the type synonyms used by a type.NThe type names defined and used by a group of mutually recursive declarations.8The type names defined and used by a single declaration.(The type names used by a single binding.%The type names used by an expression.!The type names used by a pattern.The type names used by a match.%The type names used by a type schema.The type names used by a prop.8Compute the type synonyms/type variables used by a type.#(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-InferredFHThe resulting interface generated by a module that has been typechecked. %Merge the entries in the simple case.@Like mappend for IfaceDecls, but preferring entries on the left.,Generate an Iface from a typechecked module.IInterpret an import declaration in the scope of the interface it targets.                            $(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred2346FtNote that this assumes that this pass will be run only once for each module, otherwise we will get name collisions.                !                !%(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred"Things that define exported names."Expr renaming environment#Type renaming environment3$Singleton type renaming environment.4*Singleton expression renaming environment.59Like mappend, but when merging, prefer values on the lhs.7xThe naming environment for a single declaration, unqualified. This is meanat to be used for things like where clauses.8{The naming environment for a single module. This is the mapping from unqualified internal names to fully qualified names.9|Generate an expression renaming environment from a pattern. This ignores type parameters that can be bound by the pattern.:5Generate the naming environment for a type parameter.<NTranslate names bound by the patterns of a match into a renaming environment.=MTranslate a set of declarations from an interface into a naming environment.>|Produce a naming environment from an interface file, that contains a mapping only from unqualified names to qualified ones.?XGenerate a type renaming environment from the parameters that are bound by this schema.) !"#$%&'()*+,-./0123456789:;<=>?@ABCDEF !"#$%&'()*+,-./0123456)021F,/.-'+*)($%&ED !"#C3456BA@?>=<;:987 !"#$%&'+*)(,/.-0213456789:;<=>?@ABCDEF&(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred24 L$Eliminate all patterns in a program. "Given a pattern, transform it into a simple pattern and a set of bindings. Simple patterns may only contain variables and type annotations. #/Add annotations to exported declaration groups.XXX: This isn't quite right: if a signature and binding have different export specifications, this will favor the specification of the binding. This is most likely the intended behavior, so it's probably fine, but it does smell a bit. $GAdd annotations, keeping track of which annotation are not yet used up. %Add annotations, keeping track of which annotation are not yet used up. The exception indicates which declarations are no longer needed. &.Add pragma/signature annotations to a binding. 'Check for multiple signatures. (.Does this declaration provide some signatures? ).Does this declaration provide some signatures? *5Pick a new name, to be used when desugaring patterns. +Record an error.0GHIJ , - . / 0 1 2 3KL 4 5 " 6 7 8 9 : ; < = > ? @ # $ % & ' ( ) * + A B C D E F G H I J KGHIJKLKLGJIH'GJIH , - . / 0 1 2 3KL 4 5 " 6 7 8 9 : ; < = > ? @ # $ % & ' ( ) * + A B C D E F G H I J K'(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-InferredMMMMF(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeF LWWARNING: This is a bit of a hack. It is used to represent anonymous type applications.- M NNOP O P Q R SQ T U V W X Y Z [ \ ] ^ _ ` a b c d e f L g h i j k l m n o p q r s t) M NNOP O P Q R SQ T U V W X Y Z [ \ ] ^ _ ` a b c d e f L g h i j k l m n o p( M NNPO O P Q R SQ T U V W X Y Z [ \ ] ^ _ ` a b c d e f L g h i j k l m n o p q r s t( Trustworthy! *+-./02345689:;<=?BCDFGHJKM u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i jR kSTUVWXYZ[\]^_`a l m n o p q r s t u v w x y z { | } ~ $/0124 !NOPQRSTUVWXYZ[\]^_`a$TUSWVYX[Z]\_^a`RNPOQ !4/210 u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i jR kSTUVWXYZ[\]^_`a l m n o p q r s t u v w x y z { | } ~  w  x )(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred  Raise an e error. Push a path on the stack of included files, and run an action. If the path is already on the stack, an include cycle has happened, and an error is raised. NLift an IO operation, with a way to handle the exception that it might throw. Like  B, but tries to collect as many errors as possible before failing. Remove includes from a module. Remove includes from a program. SSubstitute top-level includes with the declarations from the files they reference. PResolve the file referenced by a include into a list of top-level declarations. %Read a file referenced by an include. bcdefgh bcdefghfgbedch  bedcfgh *(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred24FneWhen a type is missing from the naming environment, but one or more values exist with the same name.o[When a value is expected from the naming environment, but one or more types exist instead.p8An environment has produced multiple overlapping symbolsq(Type name is not bound to any definitionr.Expression name is not bound to any definitions+Multiple imported symbols contain this name ;Shadow the current naming environment with some more names. Generate warnings when the left environment shadows things defined in the right. Additionally, generate errors when two names overlap in the left environment. ?Check the RHS of a single name rewrite for conflicting sources.uAThrow errors for any names that overlap in a rewrite environment. XRename a schema, assuming that the type variables have already been brought into scope. 5The type renaming environment generated by a binding. Rename a binding.NOTE: this does not bind its own name into the naming context of its body. The assumption here is that this has been done by the enclosing environment, to allow for top-level renaming PRename a schema, assuming that none of its type variables are already in scope.?ij klmnopqrst u  5ijklmnopqrstu 5uijtmsrqponkl/ij    klmsrqpont u +(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe234*yGInformation about how a constraint came to be, used in error reporting.zUse of a partial type function.{#Just defaulting on the command line Instantiation of this expreesion+A type signature in a pattern or expressionUse of a split pattern%Computing shape of list comprehension?Various errors that might happen during type checking/inferenceFToo many positional type arguments, in an explicit type instantiationQThe given constraint causes the signature of the function to be not-satisfiable.hQuantified type variables (of kind *) needs to match the given type, so it does not work for all types.LUnification variable depends on quantified variables that are not in scope.VType wild cards are not allowed in this context (e.g., definitions of type synonyms).3A constraint (with context) that we could not solve$A constraint that we could not solve'Unification results in a recursive typeExpected type, inferred type0Multiple definitions for the same type parameter7Attempt to explicitly instantiate a non-existent param.&Use of a variable that was not defined*Use of a type synonym that was not defined+The type synonym declarations are recursive&Multiple definitions for the same name2Type parameters with the same name (in definition)&Type-synonym, number of missing params$Type-synonym, number of extra paramsLNumber of extra parameters, kind of resut (which should not be of the form _ -> _)Expected kind, inferred kind Just say thisThe goal can never be solvedWe could not solved the goal. Solved, assumeing the sub-goals.GDelayed implication constraints, arising from user-specified type sigs.+Signature that gave rise to this constraint,Something that we need to find evidence for.With it is about$Part of source code that caused goalWhat needs to be proved*The types of variables in the environment.Part of current SCC Known typeFor use in error messages\vwxyz{|}~Hvwxyz{|}~\y~}|{zvxw%vxwy ~}|{z,(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeCSFThis is what's returned when we lookup variables during kind checking.An outer binding.Locally bound variable.kinds of (known) vars.lazy map, with tyvars.are type-wild cards allowed?"Read-write component of the monad.Collected errorsCollected warningsAccumulated substitution|These keeps track of what existential type variables are available. When we start checking a function, we push a new scope for its arguments, and we pop it when we are done checking the function body. The front element of the list is the current scope, which is the only thing that will be modified, as follows. When we encounter a existential type variable: 1. we look in all scopes to see if it is already defined. 2. if it was not defined, we create a fresh type variable, and we add it to the current scope. 3. it is an error if we encounter an existential variable but we have no current scope.FSelector constraints that have been solved (ref. iSolvedSelectorsLazy)Ordinary constraints*Tuple/record projection constraints. The  Z is the "name" of the constraint, used so that we can name it solution properly. !Read-only component of the monad.Source code being analysed"Type of variable that are in scopeType variable that are in scopeType synonyms that are in scopeNewtype declarations in scope3NOTE: type synonyms take precedence over newtype. The reason is that we can define local type synonyms, but not local newtypes. So, either a type-synonym shadows a newtype, or it was declared at the top-level, but then there can't be a newtype with the same name (this should be caught by the renamer).KNOTE: This field is lazy in an important way! It is the final version of  in , and the two are tied together through recursion. The field is here so that we can look thing up before they are defined, which is OK because we don't need to know the results until everything is done.When this flag is set to true, bindings that lack signatures in where-blocks will never be generalized. Bindings with type signatures, and all bindings at top level are unaffected.The results of type inference.Type inference was successful.We found some errors*This is used for generating various names.&Information needed for type inference.Location of program sourceVariables that are in scopeType synonyms that are in scopeNewtypes in scopePrivate state of type-checker=Should local bindings without signatures be monomorphized?6The initial seeds, used when checking a fresh program. eThe monadic computation is about the given range of source code. This is useful for error reporting. 1This is the current range that we are working on. Report an error.eRecord some constraints that need to be solved. The string explains where the constraints came from.^The constraints are removed, and returned to the caller. The substitution IS applied to them. 'Add a bunch of goals that need solving.UCollect the goals emitted by the given sub-computation. Does not emit any new goals.;Record a constraint that when we select from the first type, we should get a value of the second type. The returned function should be used to wrap the expression from which we are selecting (i.e., the record or tuple). Plese note that the resulting expression should not be forced before the constraint is solved.)Add a previously generate has constrainedGet the HasJ constraints. Each of this should either be solved, or added back using .@Specify the solution (`Expr -> Expr`) for the given constraint ( ).Generate a new name for a goal."Generate a new free type variable.TGenerate a new free type variable that depends on these additional type parameters."Generate a new free type variable.KGenerate an unknown type. The doc is a note about what is this type about.8Record that the two types should be syntactically equal.IApply the accumulated substitution to something with free type variables. 5Get the substitution that we have accumulated so far.!$Add to the accumulated substitution."TVariables that are either mentioned in the environment or in a selector constraint.#Lookup the type of a variable.$ Lookup a type variable. Return _ if there is no such variable in scope, in which case we must be dealing with a type constant.%(Lookup the definition of a type synonym.&"Lookup the definition of a newtype'Check if we already have a name for this existential type variable and, if so, return the definition. If not, try to create a new definition, if this is allowed. If not, returns nothing.(6Returns the type synonyms that are currently in scope.)3Returns the newtype declarations that are in scope.*6Get the set of bound type variables that are in scope.+9Return the keys of the bound variables that are in scope.,Retrieve the value of the  `mono-binds` option.-We disallow shadowing between type synonyms and type variables because it is confusing. As a bonus, in the implementation we don't need to worry about where we lookup things (i.e., in the variable or type synonym environment. .HThe sub-computation is performed with the given type parameter in scope.0FThe sub-computation is performed with the given type-synonym in scope.2BThe sub-computation is performed with the given variable in scope.5CThe sub-computation is performed with the given variables in scope.6CThe sub-computation is performed with the given variables in scope.7VThe sub-computation is performed with the given type synonyms and variables in scope.8lPerform the given computation in a new scope (i.e., the subcomputation may use existential type variables).9.The arguments to this function are as follows:H(type param. name, kind signature (opt.), a type representing the param)The type representing the parameter is just a thunk that we should not force. The reason is that the type depnds on the kind of parameter, that we are in the process of computing.fAs a result we return the value of the sub-computation and the computed kinds of the type parameters. :*Check if a name refers to a type variable.;'Are type wild-cards OK in this context?<Reports an error.>8Generate a fresh unification variable of the given kind.?(Lookup the definition of a type synonym.@#Lookup the definition of a newtype.B6Replace the given bound variables with concrete types.CRecord 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). D@The sub-computation is about the given range of the source code.|      !"#$%&'()*+,-./0123456789 See comment:;<=>?@ABCDEFGHIJKLMvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEF|MLKJ      !"#$%&'()*+,-./012345678IHG9:;<=>?@ABCDEFR       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLM-(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeU_Check for duplicate and recursive type synonyms. Returns the type-synonyms in dependecy order.VIAssociate type signatures with bindings and order bindings by dependency.WGiven a list of declarations, annoted with (i) the names that they define, and (ii) the names that they use, we compute a list of strongly connected components of the declarations. The SCCs are in dependency order. XgCombine a bunch of definitions into a single map. Here we check that each name is defined only onces. YgCombine a bunch of definitions into a single map. Here we check that each name is defined only onces. Z*Identify multiple occurances of something.NOPQRSTUVWXYZ[\ NOPQRSTUVWXYZRTSUVNOPQ\[WXYZ NOPQRTSUVWXYZ[\.(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred Instantiate 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.Note that we assume that type parameters are not normalized. Generally, the resulting expression will look something like this: ECast (EProofApp (ETApp e t)) t1awhere - There will be one `ETApp t` for each insantiated type parameter; - there will be one )6 for each constraint on the schema; - there will be (3 if we had equality constraints from normalization.] ]]] /(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe2F A varaation on , which allows us to support  & constraints: we add an extra element  , which is larger than all natural numbers, but smaller than infinity. Then, we can express `fin t` as `t <= fin`. This is only internal to the implementation and is not visible outside this module. WWhere did this edge come from? This is used so that we can turn edges back into goals. Names for non-primitive terms Maps terms to their name Maps names to terms For naming new terms._)Possible outcomes, when asserting a fact.`We could not perform opertaion.aThe fact is known to be falsebOnly if the two types are equalcWe already knew thisdWe added a new facteAdd a `(>=)` or  W goal into the model. Assumes that the types are normalized (i.e., no type functions).jQuery if the one type is known to be smaller than, or equal to, the other. Assumes that the type is simple (i.e., no type functions).kCompute an interval, that we know definately contains the given type. Assumes that the type is normalized (i.e., no type functions). EA finite number larger than all ordinary numbers. Used to represent   predicates. 1Get the edges immediately above or bellow a node. Insert a new node in a collection of facts. Returns the edges surrounding the new node. * Variable nodes are always linked to 0 and Inf''_ (directly or indirectly). * Constant nodes are always linked to neighbouring constant nodes.oRender facts in dot? notation. The boolean says if we want the arrows to point up.C ^ _`abcdefgh ijklm n op ^_`abcdefghijklmnop^_dcba`nijklmopefgh(       ^ _dcba`efgh ijklm n op 0(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeFqCollect fin and simple  & constraints in the ord model Returns  O if we find a goal which is incompatible with the others. Otherwise, we return  J with a model, and the remaining (i.e., the non-order related) properties.These sorts of facts are quite useful during type simplification, because they provide information which potentially useful for cancellation (e.g., this variables is finite and not 0)rThis returns order properties that are implied by the give property. It is important that the returned properties are propoer ordering properties (i.e., i will not return `).|tfSub x y = Just z iff z is the unique value such that tfAdd y z = Just x }1It is important that the 0 rules come before the  ones Rounds up lg2 x = Just y, if y" is the smallest number such that  x <= 2 ^ yXXX: width and lg2 are almost the same! width n == lg2 (n + 1)qrstuvwxyz{|}~qrstuvwxyz{|}~qrstuvwxyz{|}~qrstuvwxyz{|}~1(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeFTry to perform a single step of simplification for a numeric goal. We assume that the substitution has been applied to the goal. Check to see if we know that t1 is strictly smaller than t2] XXX: It'd be nice to combine this with knownLeq XXX: There can be all kinds of rules here. Detect equations of the form:\a = p + a // fin p, p >= 1 inf = p + a // fin p inf = p * a // fin p, p >= 1rThe only solution to such equations is when `a = inf`, which is what we return. When in doubt, it is OK to return Collect fin and   constraints in the ord model Returns (new model, bad goals, other goals). "bad goals" are goals that are incompatible with the model "other goals" are ones that are not "<=" or "fin"        2(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeFTry to pick a reasonable instantiation for an expression, with the given type. This is useful when we do evaluation at the REPL. The resaulting types should satisfy the constraints of the schema.3(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-InferredFSolve class constraints. 6Solve an original goal in terms of the give sub-goals. 3Solve an Arith constraint by instance, if possible. eSolve an Arith constraint for a sequence. The type passed here is the element type of the sequence. Solve Cmp constraints.vAdd propositions that are implied by the given one. The result contains the orignal proposition, and maybe some more.        4(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-InferredF Compute the type of a field based on the selector. The given type should be "zonked" (i.e., substitution was applied to it), and (outermost) type synonyms have been expanded.Solve has-constraints.    5(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-InferredFM First look for cvc4W in the path, but failing that, assume that it's installed side-by-side with Cryptol.                   6(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeF ;Assumes that the substitution has been applied to the goals qq 7(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafeC Check a type signature.!Check a type-synonym declaration.ACheck a newtype declaration. XXX: Do something with constraints. $Check someting 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 pm. If this is not the desired behavior, programmers may add explicit kind annotations on the type parameters.+Here is an example of how this may show up: !f : {n}. [8] -> [8] f x = x + `n Note that nE does not appear in the body of the schema, so we will default it to pu, 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: tIt makes it possible to figure if something is correct without having to look trough arbitrary amounts of code.It is a bit easier to implement, and it covers the large majority of use cases, with a very small inconvenience (an explicit kind annotation) in the rest. (Check an application of a type constant. @Check a use of a type-synonym, newtype, or scoped-type variable. Check a type-application. Validate a parsed type. &Check a type-variable or type-synonym. Validate a parsed proposition. (Check that a type has the expected kind.   Type constant being appliedType parameters Expected kindResulting type %Should we check for scoped type vars.Name of type sysnonymType synonym parameters Expected kindResulting type Parameters to type functionKind of type function$Validated parameters, resulting kind Type that needs to be checkedExpected kind (if any) Checked type !Name of thing that needs checking Expected kind #Proposition that need to be checkedChecked representation Kind-checked typeExpected kind (if any) Inferred kind$A type consistent with expectations.         8(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableSafe CF ?Infer the type of an expression with an explicit instantiation.]We use this when we want to ensure that the expr has exactly (syntactically) the given type.SInfer the type of an expression, and translate it to a fully elaborated core term.$The type the is the smallest of all PInfer the type of a pattern. Assumes that the pattern will be just a variable. 4Infer the type of one match in a list comprehension.2Infer the type of one arm of a list comprehension.!inferBinds isTopLevel isRec binds; performs inference for a strongly-connected component of s. If  isTopLevel is true, any bindings without type signatures will be generalized. If it is false, and the mono-binds flag is enabled, no bindings without type signatures will be generalized, but bindings with signatures will be unaffected.Come up with a type for recursive calls to a function, and decide how we are going to be checking the binding. Returns: (Name, type or schema, computation to check binding)The exprMapd is a thunk where we can lookup the final expressions and we should be careful not to force it.3Try to evaluate the inferred type of a mono-binding_The inputs should be declarations with monomorphic types (i.e., of the form `Forall [] [] t`).9(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred..:(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-InferredFExtra 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..Invariant: All the dependencies of any module m must precede m in the list.7Try to focus a loaded module in the module environment.wGet a list of all the loaded modules. Each module in the resulting list depends only on other modules that precede it.TProduce an ifaceDecls that represents the focused environment of the module system.This could really do with some better error handling, just returning mempty when one of the imports fails isn't really desirable.eProduce an ifaceDecls that represents the internal environment of the module, used for typechecking.Build  D that correspond to all of the bindings in the dynamic environment.IXXX: if we ever add type synonyms or newtypes at the REPL, revisit this.%#%;(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportable Safe-Inferred3ATwo modules loaded from different files have the same module nameModule loaded by 'import'$ statement has the wrong module name0Problems after type checking, eg. specializationProblems during type checking#Problems during the NoInclude phaseProblems during the NoPat phase"Problems during the renaming phase!Recursive module group discovered=Generated this parse error when parsing the file for module m4Some other IO error occurred while reading this fileUnable to open a file=Unable to find the module given, tried looking in these pathsgPush an "interactive" context onto the loading stack. A bit of a hack, as it uses a faked module name(Get the currently focused import source.;Remove a module from the set of loaded module, by its path.#Run a  action in a context with a prepended search path. Useful for temporarily looking in other places while resolving imports, for example.O      !"#$%&'()*+,-./G      !"#$%&'O/.-,  +*)(    !"#$%&';       !"#$%&'()*+,-./G(c) 2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone [Write the contents of the Prelude to a temporary file so that Cryptol can load the module. !   ! <(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone27Rename a module in the context of its imported modules.3:Rename an expression in the context of the focused module.49Rename declarations in the context of the focused module.5Run the noPat pass.7Load a module by its path.8'Load the module specified by an import.9>Load dependencies, typecheck, and add to the eval environment.:0Rewrite an import declaration to be of the form: &import foo as foo [ [hiding] (a,b,c) ];-Process the interface specified by an import.<=Load a series of interfaces, merging their public interfaces.>Discover a module.?'Discover a file. This is distinct from >D in that we assume we've already been given a particular file name.AAAdd the prelude to the import list if it's not already mentioned.B7Load the dependencies of a module into the environment.CTypecheck a single expression.D"Typecheck a group of declarations.ETypecheck a module.G`Process a list of imports, producing an aggregate interface suitable for use when typechecking.H#Generate input for the typechecker.0123456789:;<=>?@ABCDEFGHIJ0123456789:;<=>?@ABCDEFGHIJ123456789:;<=>?@ABCDE0FGHIJ0123456789:;<=>?@ABCDEFGHIJ=(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableNoneMFFind the file associated with a module name in the module search path.N,Load the module contained in the given file.OLoad the given parsed module.P Check the type of an expression.QEvaluate an expression.RTypecheck declarations.S?Evaluate declarations and add them to the extended environment. KLMNOPQRST;    KLMNOPQRST;LKMNOPQRST    KLMNOPQRST>(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableNoneVThe specializer monad.WuA QName should have an entry in the SpecCache iff it is specializable. Each QName starts out with an empty TypesMap.^Add a `where` clause to the given expression containing type-specialized versions of all functions called (transitively) by the body of the expression.aAdd 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.b<Compute the specialization of `EWhere e dgs`. A decl within dgse is replicated once for each monomorphic type instance at which it is used; decls not mentioned in e- (even monomorphic ones) are simply dropped.cqTransform 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.m3Reduce `length ts` outermost type abstractions and n proof abstractions.UVWXYZ[\]^_`abcdefghijklmnopqUVWXYZ[\]^_`abcdefghijklmnopqWVUXYZ[\]^_`abcdefghijklmnopqUVWXYZ[\]^_`abcdefghijklmnopq?(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone 3F t3An easy-to-use alternative representation for type .XMake a numeric constant. { val, bits } (fin val, fin bits, bits >= width val) => [bits]7Models functions of type `{a} (Arith a) => a -> a -> a`2Models functions of type `{a} (Arith a) => a -> a`Ceiling (log_2 x)4Join a sequence of sequences into a single sequence.Split implementation.!Split into infinitely many chunksSplit into finitely many chunksBMerge two values given a binop. This is used for and, or and xor.Add two polynomials2rstuvwxyz{|}~2rstuvwxyz{|}~2{|}~tzyxwvusr,rstzyxwvu{|}~@(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableNoneEFM A prover result is either an error message, an empty result (eg for the offline prover), a counterexample or a lazy list of satisfying assignments..Bind a variable in the evaluation environment.%Lookup a variable in the environment.Bind a type variable of kind *.Lookup a type variable.Make a copy of the given value, building the spine based only on the type without forcing the value argument. This lets us avoid strictness problems when evaluating recursive definitions.Evaluate a comprehension.UTurn a list of matches into the final environments for each iteration of the branch.9Turn a match into the list of environments it represents.2satNum12&A(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone+FT ":User modifiable environment, for things like numeric base.REPL exceptions.#REPL_ context with InputT handling. #REPL RW Environment.Focused module Focused file $Initial, empty environment. %!Build up the prompt for the REPL.+Run a REPL action with a fresh environment.Raise an exception.1Construct the prompt for the current environment.6Set the name of the currently focused file, edited by :e and loaded via :r.PRun a computation in batch mode, restoring the previous isBatch flag afterwards&Are let-bindings enabled in this REPL?Update the title<Set the function that will be called when updating the titleSet the REPL's string-printerGet the REPL's string-printer 2Use the configured output action to print a string JUse the configured output action to print a string with a trailing newline KUse the configured output action to print something using its Show instance &3Only meant for use with one of getVars or getTSyns.Get visible variable names.!Get visible type signature names.Given an existing qualified name, prefix it with a relatively-unique string. We make it unique by prefixing with a character #. that is not lexically valid in a module name. '9Generate a UserEnv from a description of the options map.Set a user option.+Get a user option, using Maybe for failure.OGet a user option, when it's known to exist. Fail with panic when it doesn't. (Check the value to the base option.l ) * " # + , - . / 0 1 2 3 4 $ % 5 6    &  7 ' 8 9 ( : ; < = > ? @ A B C DI     I     J ) * "  # + , - . / 0 1 2 3 4 $ % 5 6    &  7 ' 8 9 ( : ; < = > ? @ A B C DB(c) 2013-2015 Galois, Inc.BSD3cryptol@galois.com provisionalportableNone3F'Command builder., Commands.-The unknown command.2Ambiguous command, list of conflicting commands/Successfully parsed command EREPL command parsing. FNotebook command parsing. G0A subset of commands safe for Notebook execution0Run a command. HwRandomly 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. I4Run a SAT solver on the given expression. Binds the its variable to a record whose form depends on the expression given. See ticket #66 for a discussion of this design. J<Make a type/expression pair that is suitable for binding to it after running :sat or :prove5*Lift a parsing action into the REPL monad. K@Check declarations as though they were defined at the top-level. LhCreates a fresh binding of "it" to the expression given, and adds it to the current dynamic environment MCreates a fresh binding of "it" to a finite sequence of expressions of the same type, and adds that sequence to the current dynamic environment8Strip leading space. NStrip trailing space.9!Split at the first word boundary. OUncons a list.:$Lookup a string in the command list.;jLookup a string in the command list, returning an exact match even if it's the prefix of another command.<2Lookup a string in the notebook-safe command list.=Parse a line as a command.P P Q R S !"#$%&'()*+,-./ E F G T U0 V W H X Y I Z [ J \ ] ^ _123 ` a b c d e f g h4 i5 j k l67 m K n o L M p q8 N r9 O:;<= s t u !"#$%&'()*+,-./0123456789:;<=,/.-'()*+&%$#"! =09:;<13248567@ P Q S R&%$#"! '()*+,/.- E F G T U0 V W H X Y I Z [ J \ ] ^ _123 ` a b c d e f g h4 i5 j k l67 m K n o L M p q8 N r9 O:;<= s t u vHIJKLMNOPQRSTUVWXYZ[\]^_``abcdefghijklmnopqrstuvwxyz{|}~OP                EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE E E E E EEEEEEEEEEEEEEEEEEEEE E!E"E#E$E%E&E'E(E)E*E+E,E-E.E/E0E1E2E3E4E5E6E7E8E9E:E;E<E=E>E?E@EAEBECEDEEEFEGEHEIEJEKELEMENEOEPEQERERESETEUEVEUEWEWEXEYEZE[E\E] ^ _ ` a b b c d e f g h ijklmnopqrstuvwxyz{|}~j       !"#$%&&'()**+,-./011233456789:;<=>?@ABCDEFGHIJKLMNOPjQQRSTUVWXYZ[\]^_`abcZRdefghdbijklmnopqrstuv&&'w(xy)z{|}~      !"#$%&'()*+,-./01.23456789:;<=>2?@ABCDEFGGHIJKLMNO-PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~}L     !?!2!!""""""n""""""""""""""""""####################### $ % % % % %%%%%%%%%%%%%%%%%%% %%!%"%#%$%%%&%'%(%)%*%+%,%-%.%/%0%1&&2&3&4&5&6'7F8F9F:F;(<(=(>(?(@(A(B(C(D(E(F(G(H(I(J(K)L)M)N)O)P)Q)R*S*T*U*V*W*X*Y*Z*[*\*]*^*_+`+a+b+c+d+e+f+g+h+i+j+k+l++m+n+o+p+q+r+s+t+u+v+w+x+y+z+{+|+}+~++++++++++++++++++++++++++++++++++++++>++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,M,,,,,,,,,,,,,, , , , , ,,,,,,,,,,,,,,,,,,, ,!,",#,$,%-&-'-(-)-*-+-,---.-/-0-1-2-3-4.5/6/7/8/9/:/;/</=/>/?/@/A/B/C/D/E/F/G/H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b1c1d1e2f2g2h3i3j4k5l6m6n6o7p7q7r7s8t8u8v8w8x8y8z8{8|8}8~888888888888888899999;:::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<T<<<<<><<<<<<< < < < < <<<<<<<<<=== =======>>>>>>>>>> >!>">#>$>%>&>'>(>)>*>+>,>->.>/>0>1>2>3?T?V?4?5?6?7?8?9?:?3?X?;?<?=?>???@?A?B?Y?C?`?a?D?E?F?G?H?I?J?K?L?M?N?l?m?o?p?q?s?t????O?P?Q?R?S?T@U@U@H@I@V@W@X@Y@Z@[@\@]@^@_@`@a@b@c@d@e@f@g@h@i@j@k@0@l@m@n@o@p@q@K@L@M@N@O@@Q@r@@s@t@u@v@w@x@y@zA{A|A}A}A~AAAAAAAAAAAAAAAAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBB~BBBBBBBBBBBBBBBBCCCDDDDDDDDDDDDDZ^      !"#$%&'()*+,-./01234534634734834934:34;34<34=34>34?34@34A34B34C34D34E34F34G34H34I34J34K34L34M34N34O34P34Q34R34S34T34U34V34W34X34Y34Z34[34\34]34^34_34`34a34b34c34d34e34f34g34h34i34j34k34k34l34m34n34o34pEqErEsEEtEuEvEwExEyEzE{E|E}E~EEEEEEEEEEEEEEEEEEEEEE                      b                                                                                                                          ! " # $ %&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~qwxystr####$$$$$$$$$$$$$$$$$&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF(((((((((((((((((((((((((( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( !( "( #( $( %( &( '( (( )( *( +( ,( -( .( /( 0( 1( 2( 3( 4( 5( 6( 7( 8( 9( :( ;( <( =( >( ?( @( A( B( C( D( E( F( G( H( I( J( K( L( M( N( O( P( Q( R( S( T( U( V( W( X( Y( Z( [( \( ]( ^( _( `( a( b( c( d( e( f( g( h( i( j( k( l( m( n( o( p( q( r( s( t( u( v( w( x( y( z( {( |( }( ~( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( !( "( #( $( %( &( '( (( )( *( +( ,( -( .( /( 0( 1( 2( 3( 4( 5( 6( 7( 8( 9( :( ;( <( =( >( ?( @( A( B( C( D( E( F( G( H( I( J( K( L( M( N( O( P( Q( R( S( T( U( V( W( X( Y( Z( [( \( ]( ^( _( `( a( b( c( d( e( f( g( h( i( j( k( l( m( n( o( p( q( r( s( t( u( v( w( x( y( z( {( |( }( ~( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( !( "( #( $( %( &( '( (( )( *( +( ,( -( .( /( 0( 1( 2( 3( 4( 5( 6( 7( 8( 9( :( ;( <( =( >( ?( @( A( B( C( D( E( F( G( H( I( J( K( L( M( N( O( P( Q( R( S( T( U( V( W( X( Y( Z( [( \( ]( ^( _( `( a( b( c( d( e( f( g( h( i( j( k( l( m( n( o( p( q( r( s( t( u( v( w( x( y( z( {( |( }( ~( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ) ) ) ) q ) ) ) ) ) ) ))) ) ) ) ) * * * * * * * * * * * * * * *** * * * * * ** * * * * * * * * * * * * !* "* #* $* %* &* '* (* )* ** +* ,* -* .* / 0. 1. 2. 3/ 4/ 5/ 6/ 7/ 8/ 9/ :/ ;/ </ =/ >/ ?/ @/ A/ B/ 4/ C/ D/ E/ E/ F/ G/ H/ H/ I/ J/ 8/6/M/ K/ L/ M/ N/l/ O/ P/ Q/ R/ S/ T/ U/ V/ W/ X/ Y/ Z/ [/ \ ] ^q _ `q _ a1 b1 c1 d1 e1 f1 g1 h1 i3 j3 k3 l3 m4 n4 o4 p4 q4 r5 s5 t5~555 u5-5 v5 w5 x5 y6 z777 {7 |7 }7 ~7 7 G G A AA A A A A A A AA A A A A A A A A A A AA A A A A A A A A A A A A B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B cryptol-2.2.3Cryptol.VersionCryptol.Eval.ArchCryptol.Utils.PanicCryptol.TypeCheck.Solver.InfNat!Cryptol.TypeCheck.Solver.IntervalCryptol.Parser.UnlitCryptol.TypeCheck.Solver.CrySATCryptol.REPL.TrieCryptol.Utils.PPCryptol.Parser.PositionCryptol.Parser.LexerCryptol.Utils.DebugCryptol.TypeCheck.PPCryptol.Prims.SyntaxCryptol.Parser.ASTCryptol.TypeCheck.ASTCryptol.Prims.TypesCryptol.Prims.DocCryptol.Eval.ErrorCryptol.Eval.ValueCryptol.Testing.EvalCryptol.Symbolic.ValueCryptol.Testing.RandomCryptol.Eval.EnvCryptol.Eval.TypeCryptol.Prims.Eval Cryptol.EvalCryptol.TypeCheck.TypeMapCryptol.TypeCheck.SubstCryptol.TypeCheck.UnifyCryptol.TypeCheck.TypeOfCryptol.TypeCheck.Solver.UtilsCryptol.Testing.ExhaustCryptol.Parser.NamesCryptol.ModuleSystem.InterfaceCryptol.Transform.MonoValuesCryptol.ModuleSystem.NamingEnvCryptol.Parser.NoPatCryptol.Parser.UtilsCryptol.ParserCryptol.Parser.NoIncludeCryptol.ModuleSystem.RenamerCryptol.TypeCheck.InferTypesCryptol.TypeCheck.MonadCryptol.TypeCheck.DependsCryptol.TypeCheck.InstantiateCryptol.TypeCheck.Solver.FinOrdCryptol.TypeCheck.Solver.Eval Cryptol.TypeCheck.Solver.NumericCryptol.TypeCheck.DefaultingCryptol.TypeCheck.Solver.Class!Cryptol.TypeCheck.Solver.SelectorCryptol.TypeCheck.Solver.SmtlibCryptol.TypeCheck.SolveCryptol.TypeCheck.KindCryptol.TypeCheck.InferCryptol.TypeCheckCryptol.ModuleSystem.EnvCryptol.ModuleSystem.MonadCryptol.ModuleSystem.BaseCryptol.ModuleSystemCryptol.Transform.SpecializeCryptol.Symbolic.PrimsCryptol.SymbolicCryptol.REPL.MonadCryptol.REPL.CommandGitRev Paths_cryptolCryptol.Parser.LexerUtilsCryptol.Parser.ParserUtilsCryptol.Prelude commitHashcommitShortHash commitBranch commitDirtymaxBigIntWidthpanicNat'InfNatfromNatnAddnMulnExpnMinnMaxnSubnDivnModnLg2nWidth nLenFromThennLenFromThenTogenLog widthIntegerInterval lowerBound upperBoundisFiniteanythingiConstiAddiMuliMiniMaxiLg2iWidthiExpiSubiDiviMod iLenFromThen iLenFromToiLenFromThenToiLeqiLt iDisjointPreProcLaTeXMarkdownNone knownExts guessPreProcunLitResultUnknownUnsatSatInfNatPropSetExpr LenFromThenTo LenFromThenWidthLg2MaxMin:^^ModDiv:*:-:+VarKPropNot:||:&&:>:>=:/=:==FinNametoNamefromNamedebugnoPropsassertcheckSatTrieNode emptyTrie insertTrie lookupTrielookupTrieExactleavesInfixieOpieLeftieRightiePrecieAssocAssocNonAssoc RightAssoc LeftAssocPPppPrecpppretty optParenscommaSepppInfixordinal ordSuffixAddLocaddLocdropLocHasLocgetLocRangefromtosourcePositionlinecolLocatedsrcRangething emptyRangestartmovemovesrCombrCombsat$fAddLocLocated $fHasLoc[] $fHasLoc(,)$fHasLocLocated $fHasLocRange $fPPLocated $fPPRange $fPPPosition$fFunctorLocatedTokenTEOFErrWhiteVirtSymOpKWStrLitIdentChrLitNumTokenErr LexicalError InvalidChar InvalidStringUnterminatedCharUnterminatedStringUnterminatedCommentTokenSym UnderscoreTriRTriLCurlyRCurlyLBracketRBracketLParenRParenLBackTick ColonColonColon DotDotDotDotDotDotSemiCommaEqDefLambdaFatArrRArrRArrLBarTokenOpHashAtAtAtBangBangBang ComplementXorDisjConjRotRRotLShiftRShiftL NotEqualFunEqualFunGEQLEQ GreaterThanLessThanEqualNotEqualExpMulMinusPlusTokenKW KW_hidingKW_as KW_importKW_zeroKW_xKW_letKW_whereKW_type KW_transposeKW_then KW_splitAtKW_split KW_reverse KW_random KW_propertyKW_pmodKW_pdivKW_pmult KW_pragma KW_newtype KW_moduleKW_minKW_maxKW_lengthFromThenToKW_lengthFromThenKW_lg2KW_joinKW_inf KW_include KW_privateKW_ifKW_fin KW_externKW_errorKW_EqKW_elseKW_TrueKW_FalseKW_CmpKW_BitKW_ArithTokenWSpace LineComment BlockCommentTokenVVSemiVCurlyRVCurlyLToken tokenType tokenTextLayoutNoLayoutConfig cfgSource cfgLayout cfgPreProccfgAutoIncludecfgModuleScope defaultConfiglexer primLexertraceppTrace WithNamesNameMap emptyNameMapppWithNamesPrec ppWithNamesdumpnameList intToNameEConECRandomECPModECPDivECPMulECError ECInfFromThen ECInfFrom ECFromThenToECFromTo ECFromThen ECAtRangeBackECAtBack ECAtRangeECAt ECTranspose ECReverseECSplitECJoin ECSplitAtECCatECRotRECRotLECShiftRECShiftLECZeroECComplECXorECOrECAndECMaxECMin ECFunNotEqECFunEqECNotEqECEqECGtEqECLtEqECGtECLtECNegECLg2ECExpECModECDivECMulECMinusECPlusECDemoteECFalseECTrueTFunTCLenFromThenTo TCLenFromThenTCMaxTCMinTCWidthTCExpTCLg2TCModTCDivTCMulTCSubTCAdd eBinOpPrec tBinOpPrecppPrefixNoPosnoPosCLocatedCCmpCArithCGeqCEqualCFinTypeTLocatedTWildTTupleTRecordTAppTUserTInfTCharTNumTBitTSeqTParamtpNametpKindtpRangeKindKTypeKNumSchemaForallNamednamevaluePatternPLocatedPSplitPTypedPListPRecordPTuplePWildPVarMatchMatchLetSelectorListSel RecordSelTupleSelTypeInstPosInst NamedInstELocatedEFunETypeValETypedEWhereEIfEAppTEAppECompEInfFromEFromToEListESelERecordETupleELitEVarLiteralECStringECNumNumInfoPolyLitCharLitHexLitDecLitOctLitBinLit ExportSpeceTypeseBindsTopLeveltlExporttlValue ExportTypePrivatePublic ReplInputLetInput ExprInputNewtypenNamenParamsnBodyPragmaPragmaProperty PragmaNoteBindbNamebParamsbDef bSignaturebPragmasbMonoTySyn ImportSpecOnlyHidingImportiModuleiAsiSpecDeclDLocatedDTypeDPatBindDBindDPragma DSignatureTopDeclInclude TDNewtypeModulemNamemImportsmDeclsProgramLStringLQNameLNamePass MonoValuesNoPatQNameNewNameModNamemkQualmkUnqualunqualmodRange exportBindisExportedBind exportTypeisExportedTypetpQName ppSelectorcppKindHasKindkindOfdName dSignature dDefinitiondPragmas DeclGroup NonRecursive RecursiveLetFromECast EProofApp EProofAbsEAbsETAppETAbsERecUserTCTC TCNewtypeTCTupleTCFunTCSeqTCBitTCInfTCNumPCPCmpPArithPHasPFinPGeqPNeqPEqualTConTFTVarTVBoundTVFreeSTypeTRectpUniquentNamentParams ntConstraintsntFieldstsNametsParams tsConstraintstsDefsVarssPropssType:->KPropmExportsmTySyns mNewtypestpVar groupDeclsisFreeTV isBoundTVtIsNumtIsInftIsVartIsFuntIsSeqtIsBittIsTuplepIsFinpIsGeqpIsEqpIsArithpIsCmp pIsNumerictNumtZerotOnetTwotInftBiteTrueeFalsetWordtSeqtChareChartStringeStringeErrortRectTupletFuntNoUsertWidth tLenFromThentLenFromThenTotMax=#==/=pArithpCmp>==pHaspFin.*..+..-..^.tDivtModtMin newtypeTyConnewtypeConType quickApply addTNamesppNewtypeShortppLam splitWhilesplitAbs splitTAbs splitProofAbs $fPPWithNames $fPPModule$fPPDecl$fPPWithNames0 $fPPDeclGroup$fPPWithNames1 $fPPMatch$fPPWithNames2$fPPExpr$fPPWithNames3 $fPPUserTC$fPPTC$fPPPC$fPPTCon$fPPType$fPPWithNames4 $fPPTySyn$fPPWithNames5 $fPPSchema$fPPWithNames6$fPPWithNames7 $fPPTParam$fPPWithNames8$fPPKind$fHasKindTParam$fHasKindNewtype$fHasKindTySyn $fHasKindType $fHasKindTFun $fHasKindPC $fHasKindTC$fHasKindUserTC $fHasKindTCon $fHasKindTVar $fOrdTVar$fEqTVar $fOrdUserTC $fEqUserTC $fOrdTParam $fEqTParamtypeOfhelpDoc description EvalError UserError WordTooWide DivideByZeroTypeCannotBeDemoted InvalidIndex evalPanic invalidIndextypeCannotBeDemoted divideByZero wordTooWide cryUserError$fExceptionEvalError $fPPEvalErrorBitWordpackWord unpackWordWithBasePPOptsuseAsciiuseBase useInfLengthTValuetValTyValueGenValueVPolyVFunVStreamVWordVSeqVBitVTupleVRecordBVisTBitisTSeqisTFunisTTupleisTRectvSeq numTValue toNumTValue finTValuemkBv defaultPPOptsppValue asciiMode integerToCharppWordmaskwordlamtlamtoStreamtoFinSeq boolToWordtoSeq toPackedSeqfromVBitfromSeqfromStr fromVWordvWordLenfromWordfromVFun fromVPoly fromVTuple fromVRecord lookupRecordtoExpr$fBitWordBoolBV $fPPWithBase $fShowTValue TestResult FailError FailFalse runOneTestSWordSBool fromBitsLE literalSWord forallBV_ existsBV_ forallSBool_ existsSBool_iteValue sBranchValue mergeValueGen testableType randomValue randomBit randomWord randomStreamrandomSequence randomTuple randomRecordEvalEnvenvVarsenvTypesReadEnvemptyEnvbindVar lookupVarbindType lookupType$fMonoidEvalEnvevalTypeevalTFBinArithUnaryGenUnaryBinary GenBinaryevalECon ecDemoteV divModPolymodExp doubleAndAddbinaryunary liftBinArith arithBinary arithUnarylg2divWrapmodWrap lexCompare zipLexComparecmpOrder withOrdermaxVminVfunCmpzeroVjoinVsplitAtVecSplitV infChunksOf finChunksOfccatV logicBinary logicUnary logicShiftshiftLWshiftLSshiftRWshiftRSrotateLWrotateLSrotateRWrotateRS indexPrimOne indexFront indexBack indexPrimManyindexFrontRangeindexBackRange fromThenVfromToV fromThenToVrandomVtlamN moduleEnvevalExpr evalDeclsTypeMapTMtvartcontrecTypesMapListLnilconsTrieMapemptyTMnullTMlookupTMalterTMunionTMtoListTMmapMaybeWithKeyTM membersTMinsertTM insertWithTMmapTM mapWithKeyTM mapMaybeTMTVarsapSubstFVSfvsSubstSsuMap suDefaulting emptySubst singleSubst@@defaultingSubst listSubst isEmptySubst substToListdefaultFreeVarapSubstTypeMapKeys $fTVarsModule $fTVarsDecl$fTVarsDeclGroup $fTVarsMatch $fTVarsExpr $fTVarsSchema$fTVarsTypeMap $fTVarsList $fTVarsType $fTVars(,) $fTVars[] $fTVarsMaybe $fFVSSchema$fFVS(,)$fFVS[] $fFVSType $fPPSubstUnificationError UniNonPolyUniNonPolyDepends UniRecursiveUniTypeLenMismatchUniKindMismatchUniTypeMismatchErrorOKMGUuniErroremptyMGUmgumguMany $fMonadResult$fApplicativeResult fastTypeOf fastSchemaOf splitMinssplitVarSummandssplitVarSummandsplitConstSummandsplitConstFactortypeSize typeValues modExportstnamesNTnamesDsnamesD allNamesDnamesBnamesEnamesPsnamesPnamesMnamesArm boundNamesnamesTtnamesDstnamesDtnamesBtnamesEtnamesTItnamesPtnamesMtnamesStnamesCtnamesT IfaceDecl ifDeclName ifDeclSig ifDeclPragmas IfaceNewtype IfaceTySyn IfaceDeclsifTySyns ifNewtypesifDeclsIface ifModNameifPublic ifPrivate shadowing ifTySynName mkIfaceDecl unqualifiedgenIface interpImport rewModule BindsNames namingEnv NamingEnvneExprsneTypesHasQNameqnameoriginTNameTFromMod TFromNewtypeTFromSyn TFromParamENameEFromMod EFromNewtype EFromBind NameOriginImportedLocal singletonT singletonE travNamingEnv$fBindsNamesDecl$fBindsNamesModule$fBindsNamesPattern$fBindsNamesTParam$fBindsNamesBind$fBindsNamesMatch$fBindsNamesIfaceDecls$fBindsNamesIface$fBindsNamesSchema$fBindsNames[]$fBindsNamesMaybe$fBindsNamesNamingEnv$fMonoidNamingEnv$fHasQNameEName$fHasQNameTName$fPPNameOrigin PragmaNoBindSignatureNoBindMultipleSignaturesRemovePatternsremovePatternstranslateExprToNumT ParseError HappyErrorMsg HappyErrorppError parseModNameparseProgramWith parseModule parseProgram parseExprWith parseExpr parseDeclWith parseDeclparseDeclsWith parseDeclsparseLetDeclWith parseLetDecl parseReplWith parseReplparseSchemaWith parseSchema IncludeError IncludeCycleIncludeParseError IncludeFailedremoveIncludesremoveIncludesModuleppIncludeErrorRenamerenameRenamerWarningSymbolShadowed RenamerError ExpectedType ExpectedValueOverlappingSyms UnboundType UnboundExpr MultipleSyms runRenamercheckNamingEnv TyFunName BuiltInTyFun UserTyFunConstraintSourceCtPartialTypeFun CtDefaulting CtEnumeration CtExactType CtSelectorCtInst CtTypeSig CtSplitPatCtComprehension AmbiguousType%CannotMixPositionalAndNamedTypeParamsTooManyPositionalTypeParamsUnusableFunction NotForAllTypeVariableEscapedUnexpectedTypeWildCardUnsolvedDelcayedCt UnsolvedGoal RecursiveType TypeMismatchMultipleTypeParamDefsUndefinedTypeParamUndefinedVariableUndefinedTypeSynonymRecursiveTypeDeclsRepeatedDefinitionsRepeatedTyParamsTooFewTySynParamsTooManyTySynParamsTooManyTypeParams KindMismatchErrorMsgWarning DefaultingToDefaultingWildTypeDefaultingKindSolved UnsolvableUnsolved DelayedCt dctSource dctForalldctAsmpsdctGoalsHasGoalhasNamehasGoalGoal goalSource goalRangegoalGoalsVarTypeCurSCCExtVar emptyGoals nullGoals fromGoals insertGoal addTVarsDescsppUse $fPPSolved$fPPConstraintSource $fPPError $fPPWarning$fTVarsDelayedCt$fTVarsHasGoal $fTVarsGoal $fTVarsGoals$fFVSDelayedCt $fFVSGoal $fFVSError $fTVarsError $fFVSWarning$fTVarsWarning$fTVarsConstraintSource $fPPTyFunNameLkpTyVar TOuterVar TLocalVarKRW typeParamsKRO lazyTVars allowWildKindMKMunKMRWiErrors iWarningsiSubst iExistTVars iSolvedHas iNameSeedsiCtsiHasCtsROiRangeiVarsiTVarsiTSyns iNewtypesiSolvedHasLazy iMonoBindsDefLoc IsExternalIsLocalInferMIMunIM InferOutputInferOK InferFailed NameSeedsseedTVarseedGoal InferInputinpRangeinpVarsinpTSyns inpNewtypes inpNameSeeds inpMonoBinds nameSeeds runInferMioinRange inRangeMbcurRange recordError recordWarningnewGoalnewGoalsgetGoalsaddGoals collectGoals newHasGoal addHasGoal getHasGoals solveHasGoalnewName newGoalNamenewTVarnewTVar' newTParamnewTypeunify applySubstgetSubst extendSubst varsWithAsmps lookupTVar lookupTSyn lookupNewtypeexistVargetTSyns getNewtypesgetTVarsgetBoundInScope getMonoBindscheckTShadowing withTParam withTParams withTySyn withNewtype withVarType withVarTypeswithVar withMonoType withMonoTypes withDecls inNewScoperunKindM kLookupTyVarkWildOK kRecordErrorkRecordWarningkNewType kLookupTSynkLookupNewtype kExistTVar kInstantiateTkSetKindkInRange kNewGoals kInInferM $fMonadKindM$fApplicativeKindM$fFunctorKindM$fMonadFixInferM $fMonadInferM$fApplicativeInferM$fFunctorInferMFromDecltoBindtoTyDecl isTopDeclTyDeclNTTS orderTyDecls orderBindsmkScc combineMapscombine duplicates$fFromDeclDecl$fFromDeclTopDeclinstantiateWithOrdFacts AssertResult OrdCannot OrdImpossible OrdImproveOrdAlreadyKnownOrdAddedIsFactfactPropfactChangeProp factSourceaddFact isKnownLeq knownIntervalordFactsToGoalsordFactsToPropsnoFactsdumpDotdumpDocassumedOrderModel derivedOrd isSimpleTypesimpType reorderArgs commuteArgsevalTFun typeInterval typeKnownLeq typeKnownFintfAddtfSubtfMultfDivtfModtfMintfMaxtfExptfLg2tfWidth tfLenFromThentfLenFromThenTotoNat'fromNat' oneOrMore twoOrMore numericStepsimpFingoalOrderModel tryDefaulttryDefaultWith defaultExpr classStep expandProp tryHasGoal simpDelayedcheckTypeFunctionsimplifyAllConstraintsproveImplication checkSchema checkTySyn checkNewtype checkType inferModuledesugarLiteralappTys inferTyParamcheckTypeOfKindinferEcheckE expectSeq expectTuple expectRec expectFin expectFun checkHasTypecheckFunsmallestcheckPinferP inferMatch inferCArm inferBinds guessType simpMonoBind generalize checkMonoB checkSigBinferDstcPanictcModuletcExprtcDecls ppWarning DynamicEnvDEnvdeNamesdeDeclsdeEnv LoadedModulelmName lmFilePath lmInterfacelmModule LoadedModulesgetLoadedModules ModuleEnvmeLoadedModules meNameSeeds meEvalEnvmeFocusedModule meSearchPathmeDynEnv meMonoBindsresetModuleEnvinitialModuleEnv focusModule loadedModules focusedEnv qualifiedEnv loadModuleEnvisLoaded lookupModuleaddLoadedModuleremoveLoadedModule deIfaceDecls$fMonoidDynamicEnv$fMonoidLoadedModulesModuleMModuleT unModuleT roLoading ModuleWarningRenamerWarningsTypeCheckWarnings ModuleErrorDuplicateModuleNameModuleNameMismatch OtherFailureTypeCheckingFailedNoIncludeErrors NoPatErrors RenamerErrorsRecursiveModulesModuleParseError OtherIOError CantFindFileModuleNotFound ImportSource FromImport FromModuleimportedModulemoduleNotFound cantFindFile otherIOErrormoduleParseErrorrecursiveModules renamerErrors noPatErrorsnoIncludeErrorstypeCheckingFailedmoduleNameMismatchduplicateModuleNamewarntypeCheckWarningsrenamerWarningsemptyRO runModuleT runModuleM getModuleEnv setModuleEnvmodifyModuleEnv loadingImport loadingModule interactiveloadinggetImportSourcegetIface getNameSeeds setMonoBinds setNameSeeds unloadModule loadedModule modifyEvalEnv getEvalEnvgetFocusedModulesetFocusedModule getSearchPathwithPrependedSearchPath getFocusedEnvgetQualifiedEnv getDynEnv setDynEnv$fMonadTModuleT$fMonadModuleT$fApplicativeModuleT$fFunctorModuleT$fPPModuleWarning$fPPModuleError$fPPImportSource$fEqImportSourceTCAction renameModule renameExpr renameDeclsnoPatloadModuleByPath loadImport loadModulefullyQualified importIface importIfaces moduleFile findModulefindFile preludeName addPreludeloadDeps checkExpr checkDecls checkModule typecheckimportIfacesTc genInferInput ModuleRes ModuleCmdSpecMSpecT SpecCacherunSpecT liftSpecT getSpecCache setSpecCachemodifySpecCachemodify specializespecializeExprspecializeMatchwithDeclGroupsspecializeEWherespecializeDeclGroupsspecializeConstdestEProofApps destETApps destEProofAbs destETAbs freshNamematchingBoundNames reifyNameinstantiateSchemainstantiateExpr allDeclGroupsallLoadedModulesallPublicQNames traverseSndTypeValTVFunTVRecordTVTupleTVStreamTVSeqTVBitselectV replicateVnthnthVmapVcatVdropVtakeV toTypeValsExpsLg2cmpValuecmpEqcmpNotEqcmpLtcmpGtcmpLtEqcmpGtEq cmpBinaryerrorVaddPolyitesdegreemdpidxdivxEnv envIteSolverFinTypeFTRecordFTTupleFTSeqFTBit ProverResult ProverError EmptyResult ThmResult AllSatResult SatResult proverConfigs proverNames lookupProverallSatSMTResults thmSMTResultssatProvesatProveOffline protectStack parseValues parseValuenumTypefinType unFinType predArgTypes forallFinType existsFinTypeevalSel evalDeclGroupevalDecl copyBySchema copyByTypeevalComp branchEnvs evalMatch $fMonoidEnvSmoke CVC4NotFound OptionDescroptName optDefaultoptCheckoptHelpoptEffEnvValEnvBoolEnvNum EnvString REPLExceptionTypeNotTestable EvalPolyErrorModuleSystemErrorNoIncludeError NoPatErrorDirectoryNotFound FileNotFoundREPLunREPLlNamelPathrunREPLraisecatchrethrowEvalError getPrompt setLoadedMod getLoadedMod setSearchPathprependSearchPathshouldContinuestop unlessBatchasBatch disableLet enableLet getLetEnabledupdateREPLTitlesetUpdateREPLTitle setPutStr getPutStrrPutStr rPutStrLnrPrintbuiltInsgetVars getExprNames getTypeNamesgetPropertyNamesuniqifysetUser tryGetUsergetUser userOptions getUserSatNum whenDebug smokeTest CommandBodyNoArgShellArg OptionArg FilenameArg ExprTypeArgDeclsArgExprArg CommandDescrcNamescBodycHelpCommand Ambiguous runCommand moduleCmd loadPreludeloadCmd handleCtrlC replParse liftModuleCmdmoduleCmdResultsanitize splitCommand findCommandfindCommandExact findNbCommand parseCommandhashbranchdirtycatchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName CryptolPanicpanicLocpanicMsg$fExceptionCryptolPanic$fShowCryptolPanicghc-prim GHC.TypesFalse anyFinite liftMono1 liftMono2 liftPosNegmkFinmarkdownlatexBlockCommentCodepreProc toCryptolmkFFMunFMfinVarsinfVarslinearnonLinwaitVarschangesnextVarNonLinNLLg2NLMulNLExpRNLExpLNLExpNLModNLDivPSSysNameUserName exportNamesatVar importName satCheckSatgetModelsetNL noChangesaddLincheckConsistent tryImprove doImprovegetLin addNonLinmkAndmkOrttffisEqisGtisFinisInfcryIsEqcryIsNeqcryIsGtcryIsGeqcryIsDifferent cryDefinedcryIsInfcryIsFincryNoInfmkLintoConsttoVar $fMonadPlusFM $fMonadFM$fAlternativeFM$fApplicativeFM $fFunctorFMpretty-1.1.1.1Text.PrettyPrint.HughesPJ fullRender renderStylerenderstylefsepfcatcatsep<+><>$+$$$ punctuatehangnestvcathsephcatbracesbracketsparens doubleQuotesquotesrationaldoublefloatintegerintrbracelbracerbracklbrackrparenlparenequalsspacecoloncommasemiisEmptyempty zeroWidthText sizedTextptexttextcharDocChrStrPStr TextDetailsribbonsPerLine lineLengthmodeStylePageMode ZigZagModeLeftMode OneLineModeModeExplicitVirtual dropWhite AlexInputInpalexPosalexInputPrevCharinput moreBytesLexSInCharInString InCommentNormalAction startComment endComent addToComment startString endString addToString startCharendChar addToCharmkIdentemitemitSnumToken fromDecDigit fromHexDigit alexGetByte isExplicit startsLayoutlayoutvirt $fPPTokenAlexAcc AlexAccSkip AlexAccNone AlexLastAcc AlexLastSkipAlexNone AlexReturn AlexTokenAlexSkip AlexErrorAlexEOFAlexAddrAlexA# alex_base alex_table alex_check alex_deflt alex_accept stateToIntcommentstring alex_action_0 alex_action_1 alex_action_2 alex_action_3 alex_action_4 alex_action_5 alex_action_6 alex_action_7 alex_action_8 alex_action_9alex_action_10alex_action_11alex_action_12alex_action_13alex_action_14alex_action_15alex_action_16alex_action_17alex_action_18alex_action_19alex_action_20alex_action_21alex_action_22alex_action_23alex_action_24alex_action_25alex_action_26alex_action_27alex_action_28alex_action_29alex_action_30alex_action_31alex_action_32alex_action_33alex_action_34alex_action_35alex_action_36alex_action_37alex_action_38alex_action_39alex_action_40alex_action_41alex_action_42alex_action_43alex_action_44alex_action_45alex_action_46alex_action_47alex_action_48alex_action_49alex_action_50alex_action_51alex_action_52alex_action_53alex_action_54alex_action_55alex_action_56alex_action_57alex_action_58alex_action_59alex_action_60alex_action_61alex_action_62alex_action_63alex_action_64alex_action_65alex_action_66alex_action_67alex_action_68alex_action_69alex_action_70alex_action_71alex_action_72alex_action_73alex_action_74alex_action_75alex_action_76alex_action_77alex_action_78alex_action_79alex_action_80alex_action_81alex_action_82alex_action_83alex_action_84alex_action_85alex_action_86alex_action_87alex_action_88alex_action_89alex_action_90alex_action_91alex_action_92alex_action_93alex_action_94alex_action_95alex_action_96alex_action_97alex_action_98alex_action_99alex_action_100alex_action_101alex_action_102alex_action_103alex_action_104alex_action_105alex_action_106alex_action_107alex_action_108alex_action_109alex_action_110alex_action_111alex_action_112alex_action_113alexIndexInt16OffAddralexIndexInt32OffAddr quickIndexalexScan alexScanUser alex_scan_tkniUnbox$fFunctorAlexLastAcc nameVariant nameVariants$fPPECon$fPPTFun isInfixOpppLppNamedppPragmapassNameppNumLitwrap isPrefixOpisEAppasEAppsisEInfixisTInfix $fNoPosProp $fNoPosType $fNoPosTParam $fNoPosSchema$fNoPosPattern $fNoPosMatch$fNoPosTypeInst $fNoPosExpr $fNoPosTySyn $fNoPosPragma $fNoPosBind$fNoPosNewtype $fNoPosDecl$fNoPosTopLevel$fNoPosTopDecl $fNoPosModule$fNoPosProgram $fNoPosMaybe $fNoPos[] $fNoPosNamed$fNoPosLocated$fPPProp $fPPPattern $fPPSelector $fPPTypeInst $fPPLiteral$fPPName $fPPQName $fPPModName$fPPBind $fPPPragma $fPPTopLevel$fPPImportSpec $fPPImport $fPPNewtype $fPPTopDecl $fPPProgram$fHasLocNewtype$fHasLocModule$fHasLocTopDecl$fHasLocTopLevel $fAddLocDecl $fHasLocDecl$fAddLocSchema$fHasLocSchema $fHasLocNamed $fHasLocMatch $fHasLocBind$fHasLocPattern$fAddLocPattern $fAddLocProp $fHasLocProp $fAddLocType $fHasLocType$fAddLocTParam$fHasLocTParam $fHasLocExpr $fAddLocExpr$fFunctorNamed$fMonoidExportSpec$fFunctorTopLevelbaseGHC.ErrerrormethodnoDocdBitsdWordsdSeqsdFinSeqsdTuplesdRecordsdFunsdCmpsdAriths dEverything$fBitWordSValSVal Data.MaybeNothingTrueevalTF'cvt evalNewtype evalNewtypesupdSub $fShowTypeMap$fTrieMapTypeMapType $fTrieMapMapa$fTrieMapList[] typeSelect mergeByName mapIfaceDeclsfilterIfaceDecls$fMonoidIfaceDeclsMRewMapRewMap'RMnewTopOrLocalNameinLocalrewErewMrewD rewDeclGroup splitTParams splitTAppnotFun$fTrieMapRewMap'(,,) annotTopDsannotDsannotDannotB checkSigstoSigtoPragmanameserrorsNoPatMunMAnnotMap simpleBindsel splitSimplePnoPatEnoPatFunnoPatArmnoPatMnoMatchBnoMatchDnoPatDs noPatTopDs noPatProg noPatModulegetRange runNoPatM $fMonadNoPatM$fApplicativeNoPatM$fFunctorNoPatM$fRemovePatterns[]$fRemovePatternsModule$fRemovePatternsExpr$fRemovePatternsProgram anonRecordParseMPunPparselexerP happyError errorMessage customError mkModNamemkQNamemkSchemagetNamegetNumgetStrnumLit mkTupleSel fromStrLitvalidDemotedTypemkEAppopunOpbinOpeFromTo exprToNumT exportDecl exportNewtype changeExport mkTypeInstmkTParammkTySynpolyTermmkPoly mkPropertymkIf$fApplicativeParseM$fFunctorParseM $fMonadParseM$fPPParseError HappyAddrHappyA#HappyStk Happy_IntList HappyConsHappyAny HappyAbsSyn happyIn14 happyOut14 happyIn15 happyOut15 happyIn16 happyOut16 happyIn17 happyOut17 happyIn18 happyOut18 happyIn19 happyOut19 happyIn20 happyOut20 happyIn21 happyOut21 happyIn22 happyOut22 happyIn23 happyOut23 happyIn24 happyOut24 happyIn25 happyOut25 happyIn26 happyOut26 happyIn27 happyOut27 happyIn28 happyOut28 happyIn29 happyOut29 happyIn30 happyOut30 happyIn31 happyOut31 happyIn32 happyOut32 happyIn33 happyOut33 happyIn34 happyOut34 happyIn35 happyOut35 happyIn36 happyOut36 happyIn37 happyOut37 happyIn38 happyOut38 happyIn39 happyOut39 happyIn40 happyOut40 happyIn41 happyOut41 happyIn42 happyOut42 happyIn43 happyOut43 happyIn44 happyOut44 happyIn45 happyOut45 happyIn46 happyOut46 happyIn47 happyOut47 happyIn48 happyOut48 happyIn49 happyOut49 happyIn50 happyOut50 happyIn51 happyOut51 happyIn52 happyOut52 happyIn53 happyOut53 happyIn54 happyOut54 happyIn55 happyOut55 happyIn56 happyOut56 happyIn57 happyOut57 happyIn58 happyOut58 happyIn59 happyOut59 happyIn60 happyOut60 happyIn61 happyOut61 happyIn62 happyOut62 happyIn63 happyOut63 happyIn64 happyOut64 happyIn65 happyOut65 happyIn66 happyOut66 happyIn67 happyOut67 happyIn68 happyOut68 happyIn69 happyOut69 happyIn70 happyOut70 happyIn71 happyOut71 happyIn72 happyOut72 happyIn73 happyOut73 happyIn74 happyOut74 happyIn75 happyOut75 happyIn76 happyOut76 happyIn77 happyOut77 happyIn78 happyOut78 happyIn79 happyOut79 happyIn80 happyOut80 happyIn81 happyOut81 happyIn82 happyOut82 happyIn83 happyOut83 happyIn84 happyOut84 happyInTok happyOutTokhappyActOffsetshappyGotoOffsetshappyDefActions happyCheck happyTablehappyReduceArr happy_n_termshappy_n_nontermshappyReduce_11happyReduction_11happyReduce_12happyReduction_12happyReduce_13happyReduction_13happyReduce_14happyReduction_14happyReduce_15happyReduction_15happyReduce_16happyReduction_16happyReduce_17happyReduction_17happyReduce_18happyReduction_18happyReduce_19happyReduction_19happyReduce_20happyReduction_20happyReduce_21happyReduction_21happyReduce_22happyReduction_22happyReduce_23happyReduction_23happyReduce_24happyReduction_24happyReduce_25happyReduction_25happyReduce_26happyReduction_26happyReduce_27happyReduction_27happyReduce_28happyReduction_28happyReduce_29happyReduction_29happyReduce_30happyReduction_30happyReduce_31happyReduction_31happyReduce_32happyReduction_32happyReduce_33happyReduction_33happyReduce_34happyReduction_34happyReduce_35happyReduction_35happyReduce_36happyReduction_36happyReduce_37happyReduction_37happyReduce_38happyReduction_38happyReduce_39happyReduction_39happyReduce_40happyReduction_40happyReduce_41happyReduction_41happyReduce_42happyReduction_42happyReduce_43happyReduction_43happyReduce_44happyReduction_44happyReduce_45happyReduction_45happyReduce_46happyReduction_46happyReduce_47happyReduction_47happyReduce_48happyReduction_48happyReduce_49happyReduction_49happyReduce_50happyReduction_50happyReduce_51happyReduction_51happyReduce_52happyReduction_52happyReduce_53happyReduction_53happyReduce_54happyReduction_54happyReduce_55happyReduction_55happyReduce_56happyReduction_56happyReduce_57happyReduction_57happyReduce_58happyReduction_58happyReduce_59happyReduction_59happyReduce_60happyReduction_60happyReduce_61happyReduction_61happyReduce_62happyReduction_62happyReduce_63happyReduction_63happyReduce_64happyReduction_64happyReduce_65happyReduction_65happyReduce_66happyReduction_66happyReduce_67happyReduction_67happyReduce_68happyReduction_68happyReduce_69happyReduction_69happyReduce_70happyReduction_70happyReduce_71happyReduction_71happyReduce_72happyReduction_72happyReduce_73happyReduction_73happyReduce_74happyReduction_74happyReduce_75happyReduction_75happyReduce_76happyReduction_76happyReduce_77happyReduction_77happyReduce_78happyReduction_78happyReduce_79happyReduction_79happyReduce_80happyReduction_80happyReduce_81happyReduction_81happyReduce_82happyReduction_82happyReduce_83happyReduction_83happyReduce_84happyReduction_84happyReduce_85happyReduction_85happyReduce_86happyReduction_86happyReduce_87happyReduction_87happyReduce_88happyReduction_88happyReduce_89happyReduction_89happyReduce_90happyReduction_90happyReduce_91happyReduction_91happyReduce_92happyReduction_92happyReduce_93happyReduction_93happyReduce_94happyReduction_94happyReduce_95happyReduction_95happyReduce_96happyReduction_96happyReduce_97happyReduction_97happyReduce_98happyReduction_98happyReduce_99happyReduction_99happyReduce_100happyReduction_100happyReduce_101happyReduction_101happyReduce_102happyReduction_102happyReduce_103happyReduction_103happyReduce_104happyReduction_104happyReduce_105happyReduction_105happyReduce_106happyReduction_106happyReduce_107happyReduction_107happyReduce_108happyReduction_108happyReduce_109happyReduction_109happyReduce_110happyReduction_110happyReduce_111happyReduction_111happyReduce_112happyReduction_112happyReduce_113happyReduction_113happyReduce_114happyReduction_114happyReduce_115happyReduction_115happyReduce_116happyReduction_116happyReduce_117happyReduction_117happyReduce_118happyReduction_118happyReduce_119happyReduction_119happyReduce_120happyReduction_120happyReduce_121happyReduction_121happyReduce_122happyReduction_122happyReduce_123happyReduction_123happyReduce_124happyReduction_124happyReduce_125happyReduction_125happyReduce_126happyReduction_126happyReduce_127happyReduction_127happyReduce_128happyReduction_128happyReduce_129happyReduction_129happyReduce_130happyReduction_130happyReduce_131happyReduction_131happyReduce_132happyReduction_132happyReduce_133happyReduction_133happyReduce_134happyReduction_134happyReduce_135happyReduction_135happyReduce_136happyReduction_136happyReduce_137happyReduction_137happyReduce_138happyReduction_138happyReduce_139happyReduction_139happyReduce_140happyReduction_140happyReduce_141happyReduction_141happyReduce_142happyReduction_142happyReduce_143happyReduction_143happyReduce_144happyReduction_144happyReduce_145happyReduction_145happyReduce_146happyReduction_146happyReduce_147happyReduction_147happyReduce_148happyReduction_148happyReduce_149happyReduction_149happyReduce_150happyReduction_150happyReduce_151happyReduction_151happyReduce_152happyReduction_152happyReduce_153happyReduction_153happyReduce_154happyReduction_154happyReduce_155happyReduction_155happyReduce_156happyReduction_156happyReduce_157happyReduction_157happyReduce_158happyReduction_158happyReduce_159happyReduction_159happyReduce_160happyReduction_160happyReduce_161happyReduction_161happyReduce_162happyReduction_162happyReduce_163happyReduction_163happyReduce_164happyReduction_164happyReduce_165happyReduction_165happyReduce_166happyReduction_166happyReduce_167happyReduction_167happyReduce_168happyReduction_168happyReduce_169happyReduction_169happyReduce_170happyReduction_170happyReduce_171happyReduction_171happyReduce_172happyReduction_172happyReduce_173happyReduction_173happyReduce_174happyReduction_174happyReduce_175happyReduction_175happyReduce_176happyReduction_176happyReduce_177happyReduction_177happyReduce_178happyReduction_178happyReduce_179happyReduction_179happyReduce_180happyReduction_180happyReduce_181happyReduction_181happyReduce_182happyReduction_182happyReduce_183happyReduction_183happyReduce_184happyReduction_184happyReduce_185happyReduction_185happyReduce_186happyReduction_186happyReduce_187happyReduction_187happyReduce_188happyReduction_188happyReduce_189happyReduction_189happyReduce_190happyReduction_190happyReduce_191happyReduction_191happyReduce_192happyReduction_192happyReduce_193happyReduction_193happyReduce_194happyReduction_194happyReduce_195happyReduction_195happyReduce_196happyReduction_196happyReduce_197happyReduction_197happyReduce_198happyReduction_198happyReduce_199happyReduction_199happyReduce_200happyReduction_200happyReduce_201happyReduction_201happyReduce_202happyReduction_202happyReduce_203happyReduction_203happyReduce_204happyReduction_204happyReduce_205happyReduction_205happyReduce_206happyReduction_206happyReduce_207happyReduction_207happyReduce_208happyReduction_208happyReduce_209happyReduction_209happyReduce_210happyReduction_210happyReduce_211happyReduction_211happyReduce_212happyReduction_212happyReduce_213happyReduction_213happyReduce_214happyReduction_214happyReduce_215happyReduction_215happyReduce_216happyReduction_216happyReduce_217happyReduction_217happyReduce_218happyReduction_218happyReduce_219happyReduction_219happyReduce_220happyReduction_220happyReduce_221happyReduction_221happyReduce_222happyReduction_222happyReduce_223happyReduction_223happyReduce_224happyReduction_224happyReduce_225happyReduction_225happyReduce_226happyReduction_226happyReduce_227happyReduction_227happyReduce_228happyReduction_228happyReduce_229happyReduction_229happyReduce_230happyReduction_230happyReduce_231happyReduction_231happyReduce_232happyReduction_232happyReduce_233happyReduction_233happyReduce_234happyReduction_234happyReduce_235happyReduction_235happyReduce_236happyReduction_236happyReduce_237happyReduction_237happyReduce_238happyReduction_238happyReduce_239happyReduction_239happyReduce_240happyReduction_240happyReduce_241happyReduction_241happyReduce_242happyReduction_242happyReduce_243happyReduction_243happyReduce_244happyReduction_244happyReduce_245happyReduction_245happyReduce_246happyReduction_246happyReduce_247happyReduction_247happyReduce_248happyReduction_248happyReduce_249happyReduction_249happyReduce_250happyReduction_250happyReduce_251happyReduction_251happyReduce_252happyReduction_252happyReduce_253happyReduction_253happyReduce_254happyReduction_254happyReduce_255happyReduction_255happyReduce_256happyReduction_256happyReduce_257happyReduction_257happyReduce_258happyReduction_258happyReduce_259happyReduction_259happyReduce_260happyReduction_260happyReduce_261happyReduction_261happyReduce_262happyReduction_262happyReduce_263happyReduction_263happyReduce_264happyReduction_264happyReduce_265happyReduction_265happyReduce_266happyReduction_266happyReduce_267happyReduction_267happyReduce_268happyReduction_268happyReduce_269happyReduction_269happyReduce_270happyReduction_270happyReduce_271happyReduction_271happyReduce_272happyReduction_272happyReduce_273happyReduction_273happyReduce_274happyReduction_274happyReduce_275happyReduction_275happyReduce_276happyReduction_276happyReduce_277happyReduction_277happyReduce_278happyReduction_278happyReduce_279happyReduction_279happyReduce_280happyReduction_280happyReduce_281happyReduction_281happyReduce_282happyReduction_282happyReduce_283happyReduction_283happyReduce_284happyReduction_284happyReduce_285happyReduction_285happyReduce_286happyReduction_286happyReduce_287happyReduction_287happyReduce_288happyReduction_288happyReduce_289happyReduction_289happyReduce_290happyReduction_290happyReduce_291happyReduction_291happyReduce_292happyReduction_292happyReduce_293happyReduction_293happyReduce_294happyReduction_294happyReduce_295happyReduction_295happyReduce_296happyReduction_296happyReduce_297happyReduction_297happyReduce_298happyReduction_298happyReduce_299happyReduction_299 happyNewToken happyError_ happyThen happyReturn happyThen1 happyReturn1 happyError'vmoduleprogram programLayoutexprdecldecls declsLayoutletDeclreplschemamodNamehappySeqaddImplicitIncludes happyParse happyAccept happyDoActionindexShortOffAddr happyShifthappySpecReduce_0happySpecReduce_1happySpecReduce_2happySpecReduce_3 happyReducehappyMonadReducehappyMonad2Reduce happyDrop happyDropStk happyGoto happyFail notHappyAtAll happyTcHack happyDoSeq happyDontSeq includeFailedpushPath failsWith collectErrors Control.MonadmapMnoIncludeModulenoIncludeProgram noIncTopDeclresolveInclude readIncludeNoIncM runNoIncM tryNoIncM $fMonadNoIncM$fApplicativeNoIncM$fFunctorNoIncM shadowNamescheckEnvcontainsOverlap renameSchemabindingTypeEnv $fRenameBind$fRenameSchemaRenameM unRenameMOut oWarningsoErrorsroLocroNamesrecordrecordslocatedwithLoc renameType renameMatch renamePats renameLoc $fRenameTySyn $fRenameMatch$fRenameTypeInst $fRenameExpr$fRenamePattern$fRenamePragma $fRenameType $fRenameProp$fRenameNewtype $fRenameDecl$fRenameTopLevel$fRenameTopDecl$fRenameModule $fRenameNamed$fRenameLocated $fRenameMaybe $fRename[]$fMonadRenameM$fApplicativeRenameM$fFunctorRenameM $fMonoidOut$fPPRenamerWarning$fPPRenamerErrorIntinstantiateWithNamesinstantiateWithPosdoInstNat''finFinNat''EdgeSrcOrdTerms typeToName nameToTypenextIdimminsNodeNumTypeNTNamedNTVarNTNatInf''NoGoalFromGoalEdgetargeteSourceEdgesabovebelowordFactsToListnameTermzeroinf fromNumTypeisVarnoEdges reachablelinkisLeq insertLeq insertFin getLowerBound getUpperBound $fOrdEdge$fEqEdge $fIsFactType $fIsFactGoal GHC.Classes<= Data.EitherLeftRight knownSmaller checkOnlyInf simpEqMin simpFinTyeqBySub eqByCancelaIsMinisAparatsolvedsolveArithInst solveArithSeq solveCmpInst solveSelector recordType tupleTypelistTypeimproveSelectorfindCvc4 SMTResulttoTermsmtVartoPredtoScriptcvc4 simplifyGoalstySynappTy doCheckType checkTyThing checkProp checkKindwritePreludeContentspreludeContentsUserEnv defaultRWmkPromptkeepOne mkUserEnv checkBase SmokeTest OptionMap eLoadedMod eContinueeIsBatch eModuleEnv eNameSupplyeUserEnvePutStr eLetEnabled eUpdateTitlegetRW modifyRW_ mkOptionMap simpleOptcheckInfLength checkProverproverListString checkSatNum cvc4exists $fPPSmoke$fPPREPLException$fExceptionREPLException $fMonadREPL$fApplicativeREPL $fFunctorREPLcommands nbCommands nbCommandListqcCmd cmdProveSatmkSolverResultreplCheckDeclsbindItVariablebindItVariables sanitizeEnduncons CommandMapQCMode QCExhaustQCRandom commandListgenHelp getPPValOptsevalCmdsatCmdproveCmdonlineProveSatofflineProveSat specializeCmd typeOfCmd reloadCmdeditCmdquitCmd browseCmd browseTSynsbrowseNewtypes browseVars setOptionCmdhelpCmd runShellCmdcdCmd isNamePrefixreplParseInput replParseExprinteractiveConfig replCheckExpr replSpecExpr replEvalExpr replEvalDeclreplEdittrim$fOrdCommandDescr$fEqCommandDescr$fShowCommandDescr