!       !"#$%&'()*+,-./01 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 [ \ ] ^ _ `abcdefghijklmnopqrstuvwx 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-:.;.<.=.>.?.@/A0B1C1D1E2F3G3H3I3J3K3L3M3N3O3P3Q3R3S3T3U3V4W4X4Y4Z4[4\4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}4~444444444445555555555555555555555555555666666666666666666666666666666666677777777777777788888888888888888888888888888888888899:;;;;<<<<<<<< < < < < <<<<<<<<<<<<<<<<<<< <!<"<#<$<%<&<'<(<)<*<+<,<-<.</<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?{?|?}?~????????????????????????????????????????@@@@@@@@@@@@@@@@@AAAAAAAAAABBBBBBBBBBBBCCCCDDDDDEEEEEEEEEEFFFGGGHHHHHIIIIJJJKKKKLLLLLLLLLLLMMNNNNNN N N N N NNNNNNNNNNNNNNNNNNN N!N"N#N$N%N&N'N(N)N*N+N,N-N.N/N0N1N2N3N4N5N6N7N8N9N:N;N<N=N>N?N@NANBNCODOEOFOGOHPIPJPKPLQMQNQOQPQQQRQSQTQUQVQWQXQYQZQ[Q\Q]Q^Q_Q`QaQbQcQdQeQfQgQhQiQjQkQlQmQnQoQpQqQrRsRtRuRvRwRxRyRzR{R|R}R~RRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUVVVVVV V V V V VVVVVWWWWWWWWWWWWWW W!W"W#W$W%W&W'W(W)W*W+W,W-W.W/W0W1W2W3W4W5W6W7W8W9W:W;W<W=W>W?W@WAWBWCWDWEWFWGWHWIWJWKWLWMWNWOWPWQWRWSWTWUWVWWWXWYWZW[W\W]W^W_W`WaWbWcWdWeWfWgWhWiWjWkXlXmXnXoXpXqXrXsXtYuYvYwYxYyYzY{Y|Y}Y~YYYYYYYYYZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[                 \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ !\ "\ #\ $\ %\ &\ '\ (\ )\ *\ +\ ,\ -\ .\ /\ 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_ {_ |_ }_ ~_ _ _ _ _ _ _ _ _ _ ` ` ` ` ` ` ` ` ` ` ` `jNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk~J   &''   & None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkE1morleySuppose you have a data type X with parameter aX and you have two values: `x1 :: X a1` and `x2 :: X a2`. You can't compare them using  J, because they have different types. However, you can compare them using 1! as long as both parameters are  .2morley Version of 1 for types with 2 parameters.3morley Version of 1 for types with 3 parameters.123123 None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk 456789:;<=>?@ ?=>;<@456789:None1!"#$%&',-.01245678;=>?@AHMNPSUVX_`befgk9 %`abcdefghi efghibcd%`a None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk xmorleyGeneralize converting a type into a Text.PrettyPrint.Leijen.Text.Doc. Used to pretty print Michelson code and define Fmt.Buildable instances.zmorleyWhether a value can be represented in Michelson code. Normally either all values of some type are renderable or not renderable. However, in case of instructions we have extra instructions which should not be rendered. Note: it's not suficcient to just return  for such instructions, because sometimes we want to print lists of instructions and we need to ignore them complete (to avoid putting redundant separators).{morleyConvert   to  with a line width of 80.|morleyLGeneric way to render the different op types that get passed to a contract.~morley#Create a specific number of spaces.morleyCWrap documents in parentheses if there are two or more in the list.morley#Turn something that is instance of x into a  ". It's formatted the same way as { formats docs. xyz{|}~ xyz{|}~ None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkumorleyA  ' that always failes with given message.morleyA   that always succeeds.morleyThe   holds on `Left a`.morleyThe   holds on `Right b`. None1!"#$%&',-.01245678;=>?@AHMNPSUVX_`befgkQ morleyA type error asking to use  instead of  .morleyMichelson string value.DThis is basically a mere text with limits imposed by the language:  @http://tezos.gitlab.io/zeronet/whitedoc/michelson.html#constantsn Although, this document seems to be not fully correct, and thus we applied constraints deduced empirically.CYou construct an item of this type using one of the following ways:6With QuasyQuotes when need to create a string literal.[mt|Some text|]%MTextUnsafe { unMText = "Some text" }With - when constructing from a runtime text value.With  or F when absolutelly sure that given string does not violate invariants.With ] when not sure about text contents and want to make it compliant with Michelson constraints.morley<Constraint on literals appearing in Michelson contract code. morley;Error message indicating bad character in a string literal.morleyWrap a Haskell text into , performing necessary checks.You can use e.g. '\n'X character directly in supplied argument, but attempt to use other bad characters like '\r' will cause failure.morley Contruct T from a Haskell text, failing if provided Haskell text is invalid Michelson string.morley Construct  from a Haskell text, eliminating all characters which should not appear in Michelson strings. Characters which can be displayed normally via escaping are preserved.morleyPrint 9 for Michelson code, with all unusual characters escaped.morley/QuasyQuoter for constructing Michelson strings.:Validity of result will be checked at compile time. Note:slash must be escaped!newline character must appear as '\n'use quotes as is)other special characters are not allowed.morleyParser used in  quasi quoter. None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkhmorleySplit a record into two pieces.morleyJPath to a leaf (some field or constructor) in generic tree representation.morleyQWhich branch to choose in generic tree representation: left, straight or right. P is used when there is one constructor with one field (something newtype-like).The reason why we need  can be explained by this example: data A = A1 B | A2 Integer data B = B Bool Now we may search for A1 constructor or B constructor. Without , in both cases path will be the same ([L]).None1!"#$%&',-.01245678;=>?@AHMNPSUVX_`befgkmorley$Typeclass for printing annotations,  renderAnn! prints empty prefix in case of noAnn.Such functionality is required in case when instruction has two annotations of the same type, former is empty and the latter is not. So that `PAIR noAnn noAnn noAnn %kek` is printed as `PAIR % %kek`None1!"#$%&',-.01245678;=>?@AHMNPSUVX_`befgk@morley:Implicit Parameter type which can be used in contract codemorley8Implicit Storage type which can be used in contract code@     @     None1!"#$%&',-.01245678;=>?@AHMNPSUVX_`befgk 9morley8A stack function that expresses the type signature of a LetMacro>morleyA stack pattern-matchBmorley"A type-variable or a type-constantGmorleyA reference into the stack.Imorley3Implementation-specific instructions embedded in a NOPW primitive, which mark a specific point during a contract's typechecking or execution.These instructions are not allowed to modify the contract's stack, but may impose additional constraints that can cause a contract to report errors in type-checking or testing.VAdditionaly, some implementation-specific language features such as type-checking of LetMacro6s are implemented using this mechanism (specifically FN and FN_END).Jmorley,Matches current stack against a type-patternKmorley'A typed stack function (push and pop a  TcExtFrame)Lmorley8Copy the current stack and run an inline assertion on itMmorley'Print a comment with optional embedded StackRefsNmorleyConvert ># to a list of types. Also returns  which is . if the pattern is a fixed list of types and 2 if it's a pattern match on the head of the stack.Omorley+Get the set of variables in a stack pattern123456789:<=;>?@ABDCEFGHIJKLMNOIJKLMGH67812345EFBDC>?@A9:<=;ONNone1!"#$%&',-.01245678;=>?@AHMNPSUVX_`befgklNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkTmorley6Michelson language type with annotations stripped off.None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk. morley Version of   with  ' constraint, specialized for use with  kind. morley Version of   with  ' constraint, specialized for use with  kind.morley Version of  withSomeSing with  - constraint provided to processing function.[Required for not to erase this useful constraint when doing conversion from value of type ! to its singleton representation. morley Version of   which creates  .morley Version of  withSomeSing with  - constraint provided to processing function.]Required for not to erase these useful constraints when doing conversion from value of type ! to its singleton representation.morley Version of   specialized for use with data instance Sing :: T -> Type which requires  ) constraint for some of its constructors morley Version of   which creates  . morleyInstance of data family - for 5. Custom instance is implemented in order to inject  & constraint for some of constructors. morleyInstance of data family - for .-,+-,+None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkmorleyWhether the type contains  , with proof.morley This is like ., it raises a more human-readable error when t[ type is concrete, but you cannot easily extract a proof of no-operation-presence from it.Use it in our eDSL. morley$Report a human-readable error about  at a wrong place. morley$Report a human-readable error about  at a wrong place.morleyConstraint which ensures, that tm can be used as type of contract storage so it optionally has bigmap only on the left of its toplevel pair morleytType family to check if t is ill-typed contract storage (it contains bigmap not on the left of its toplevel pair)Used in BigMapConstraintmorleyEConstraint which ensures that bigmap does not appear in a given type.morleyMConstraint which ensures that operation type does not appear in a given type.JNot just a type alias in order to be able to partially apply it (e.g. in  ). morleyWhether this type contains  type.In some scopes (constants, parameters) appearing for big_map type is prohibited. It is permitted in toplevel left element of storage pair. Big_maps in input/output of lambdas are allowed without limits though. morleyWhether this type contains  type.In some scopes (constants, parameters, storage) appearing for operation type is prohibited. Operations in input/output of lambdas are allowed without limits though.morleyReify  contraint from .morley1Check at runtime whether the given type contains .morley1Check at runtime whether the given type contains .morley6Check at runtime that the given type does not contain .morley7Check at runtime that the given type does not containt morleyCheck at runtime that the given type optionally has bigmap only on the left of its toplevel pair, which is actuall constraint for bigmap appearance in the storageNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk7morley>Data type, holding annotation data for a given Michelson type t.;Each constructor corresponds to exactly one constructor of f and holds all type and field annotations that can be attributed to a Michelson type corrspoding to t.morley>Data type, holding annotation data for a given Michelson type t or ** in case no data is provided for the tree.[There is a little semantical duplication between data type constructors. Semantics behind  3 constructor are exactly same as semantics behind   constructor with relevant R constructor be given all default values (which means all annotations are empty). Constructor  ` is given as a tiny optimization to allow handling no-annotation case completely for free (see  and   functions). morleyHelper function for work with  data type.  notesCase f g notes is equivalent to + case notes of NStar -> f N v -> g v  morley*Check whether given annotations object is *. morleyChecks whether given notes n: can be immediately converted to star and returns either NStar or N n.Given  n :: Notes' t6 can be immediately converted to star iff all nested (sn :: Notes t) == NStar and for each annotation an:  an == def. morleyCombines two annotations trees a and b into a new one c in such a way that c can be obtained from both a and b by replacing some ** leafs with type or/and field annotations.morleySame as   but works with  data type.morley:Converge two type or field notes (which may be wildcards).          None1!"#$%&',-.01245678;=>?@AHMNPSUVX_`befgk>morleyByteString does not have an instance for ToJSON and FromJSON, to avoid orphan type class instances, make a new type wrapper around it.)morleydA sequence of elements: can be a list or a set. We can't distinguish lists and sets during parsing. !"#$%&'()*+, !"#$%&'()*+,aNone1!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk@i None1!"#$%&',-.01245678;=>?@AHMNPSUVX_`befgkYDmorley\Time in the real world. Use the functions below to convert it to/from Unix time in seconds.GmorleyDMutez is a wrapper over integer data type. 1 mutez is 1 token (Tz).ImorleySafely create G checking for overflow.JmorleyPartial function for GP creation, it's pre-condition is that the argument must not exceed the maximal G value.KmorleySafely create G."This is recommended way to create Mutez8 from a numeric literal; you can't construct all valid Mutez@ values using this function but for small values it works neat.4Warnings displayed when trying to construct invalid  or  l literal are hardcoded for these types in GHC implementation, so we can only exploit these existing rules.Lmorley Addition of G values. Returns  in case of overflow.MmorleyPartial addition of G>, should be used only if you're sure there'll be no overflow.NmorleySubtraction of G values. Returns 7 when the subtrahend is greater than the minuend, and  otherwise.OmorleyPartial subtraction of G?, should be used only if you're sure there'll be no underflow.PmorleyMultiplication of G" and an integral number. Returns  in case of overflow.QmorleyEuclidian division of two G values.RmorleyEuclidian division of G and a number.Vmorley!Add given amount of seconds to a D.WmorleyDisplay timestamp in human-readable way as used by Michelson. Uses UTC timezone, though maybe we should take it as an argument.Xmorley Parse textual representation of D.YmorleyReturn current time as D.DEFGHIJKLMNOPQRSTUVWXYGHIJKLMNOPQRDEFSTUVWXYNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkoomorleyFError that can happen during parsing of cryptographic primitive types.smorleyb58check of a public key.vmorley ED25519 cryptographic signature.ymorley!ED25519 secret cryptographic key.zmorley!ED25519 public cryptographic key.}morley1Deterministicaly generate a secret key from seed.~morley&Create a public key from a secret key.morley$Sign a message using the secret key.morley@Check that a sequence of bytes has been signed with a given key.morley*Compute the b58check of a public key hash.morleyCompute a cryptographic hash of a bytestring using the Blake2b_256 cryptographic hash function. It's used by the BLAKE2B instruction in Michelson.morley`Compute a cryptographic hash of a bytestring using the Blake2b_160 cryptographic hash function.morley[Compute a cryptographic hash of a bytestring using the Sha256 cryptographic hash function.morley[Compute a cryptographic hash of a bytestring using the Sha512 cryptographic hash function.morley*Encode a bytestring in Base58Check format.morley,Decode a bytestring from Base58Check format.morleyParse a base58check encoded value expecting some prefix. If the actual prefix matches the expected one, it's stripped of and the resulting payload is returned.*lmnopqrstuvwxyz{|}~*z{|yvwxstu}~opqrlmnNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk morley.Errors that can happen during address parsing. morley%Address is not in Base58Check format. morley,Both address parsers failed with some error.morley6Data type corresponding to address structure in Tezos.morleytz) address which is a hash of a public key.morleyKTy address which corresponds to a callable contract. It's a hash of origination command. TODO: we should probably have a Hash type.morleySmart constructor for .morleySmart constructor for 4. Its argument is serialized origination operation. Note: it's quite unsafe to pass , because we can pass some garbage which is not a serialized origination operation, but this operation includes contract itself and necessary types are defined in bcO. So we have to serialize this data outside this module and pass it here as a ^. Alternatively we could add some constraint, but it would be almost as unsafe as passing a . For this reason we add Raw: suffix to this function and provide a safer function in de. We may reconsider it later.morleyParse an address from its human-readable textual representation used by Tezos (e. g. "tz1faswCTDciRzE4oJ9jn2Vm2dvjeyA9fUzU"). Or fail if it's invalid.morleyPartial version of B which assumes that the address is correct. Can be used in tests.  None1!"#$%&',-.01245678;=>?@AHMNPSUVX_`befgkz morley'Data necessary to originate a contract.morleyManager of the contract.morleyOptional delegate.morley"Whether the contract is spendable.morley$Whether the contract is delegatable.morley Initial balance of the contract.morley&Initial storage value of the contract.morleyThe contract itself.morley.Michelson instruction with abstract parameter op. This parameter is necessary, because at different stages of our pipeline it will be different. Initially it can contain macros and non-flattened instructions, but then it contains only vanilla Michelson instructions.-morley Flatten all $ in ". This function is mostly for testing. It returns instructions with the same logic, but they are not strictly equivalent, because they are serialized differently (grouping instructions into sequences affects the way they are PACK'ed).#Note: it does not return a list of +H because this type is not used anywhere and should probably be removed..morley=Compute address of a contract from its origination operation.TODO [TM-62] It's certainly imprecise, real Tezos implementation doesn't use JSON, but we don't need precise format yet, so we just use some serialization format (JSON because we have necessary instances already).f      !"#$%&'()*+,-.f      !()*+"#$%&,'-.None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk`KLMLMKdNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk.     123456789:<=;>?@ABDCEFGHIJKLMNO !"#$%&'()*+,      !"#$%&'()*+,-.KLMNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkRmorley Extracts  type from df.Tmorley Extracts Notes t type from gf and corresponding singleton.UmorleyConverts from  to gf.NOPQRSTUNOPQTRSUNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkyYmorley"Format type stack in a pretty way.YYNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkM[morley:Representation of comparable value in Michelson language.By specification, we're allowed to compare only following types: int, nat, string, bytes, mutez, bool, key_hash, timestamp, address.;Only these values can be used as map keys or set elements. [\]^_`abcd [\]^_`abcdNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkRhmorley"Representation of Michelson value.Type parameter instr` stands for Michelson instruction type, i.e. data type to represent an instruction of language.morleyvData type, representing operation, list of which is returned by Michelson contract (according to calling convention)._These operations are to be further executed against system state after the contract execution.9[\]^_`abcdhqijklmnoprstuvwxyz{|}~9hqijklmnoprstuvzyxw{|}~[\]^_`abcd None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk!None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk~morley#Marker data type for add operation.morley0Represents an arithmetic error of the operation.morley;Denotes the error type occured in the arithmetic operation.morley&Class for binary arithmetic operation.!Takes binary operation marker as op# parameter, types of left operand n and right operand m.morley Type family ArithRes6 denotes the type resulting from computing operation op from operands of types n and m.uFor instance, adding integer to natural produces integer, which is reflected in following instance of type family: ArithRes Add CNat CInt = CInt.morley0Evaluate arithmetic operation on given operands.!!"None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkН=morleyThis function is the same as   except that it returns   , because  I is guaranteed to return non-empty list, but it's not captured in types.==None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk[ !>?>? !#None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk@morleyBRebuild a list into a binary tree of exactly the same form which hi uses to represent datatypes.Along with the original list you have to provide constructor for intermediate nodes - it accepts zero-based index of the leftmost element of the right tree and merged trees themselves.@A@A$None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkܭEmorleyChange the character encoding of the given Handle to transliterate on unsupported characters instead of throwing an exception.BCDEBCDE%None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkރ&None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkWHmorley?For datatype with "myNyan" field it will create "myNyanL" lens.HH'None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkImorley.Data associated with a particular transaction.IJKLMPQRIJKLMRQP(None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkSTUVWTUVWS)None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk\morley[Comparison of type-level naturals, raises human-readable compile error when does not hold.FThis is for in eDSL use only, GHC cannot reason about such constraint. morleyEvaluates list length.kThis type family is a best-effort attempt to display neat error messages when list is known only partially.For instance, when called on Int ': Int ': s, the result will be OfLengthWithTail 2 s! - compare with result of simple b - 1 + 1 + Length s.5For concrete types this will be identical to calling FromPeano (Length l).]morley3Comparison of type-level naturals, as a constraint.^morley1Comparison of type-level naturals, as a function.It is as lazy on the list argument as possible - there is no need to know the whole list if the natural argument is small enough. This property is important if we want to be able to extract reusable parts of code which are aware only of relevant part of stack.dmorleyA convenient alias.We are going to use d. numbers for type-dependent logic and normal  0s in user API, need to distinguish them somehow.hmorleyDerive ] from \.-ef\]^_`abcdghdcb`ag-ef_^]\h*None1!"#$%&',-.01245678;=>?@AHMNPSUVX_`befgk rmorley-A print format with references into the stackumorley+A reference into the stack of a given type.vmorley=Keeps 0-based index to a stack element counting from the top.ymorleyERepresentation of Michelson instruction or sequence of instructions.Each Michelson instruction is represented by exactly one constructor of this data type. Sequence of instructions is represented with use of Seq constructor in following way: SWAP; DROP ; DUP; -> SWAP y DROP y DUPO. Special case where there are no instructions is represented by constructor Nop, e.g. IF_NONE {} { SWAP; DROP; } -> IF_NONE Nop (SWAP y DROP).Type parameter inpd states for input stack type. That is, type of the stack that is required for operation to execute.Type parameter out` states for output stack type or type of stack that will be left after instruction's execution.{morleyeNop operation. Missing in Michelson spec, added to parse construction like `IF {} { SWAP; DROP; }`.}morleyNested wrapper is going to wrap a sequence of instructions with { }. It is crucial because serialisation of a contract depends on precise structure of its code.morley<Create a stack reference, performing checks at compile time.`nopqrstuvwxyz}|~{`yz}|~{opquvrstwxn+None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk,None1!"#$%&',-.01245678;=>?@AHMNPSUVX_`befgk*ymorley-Implements ADT conversion to Michelson value.wThanks to Generic, Michelson representation will be a balanced tree; this reduces average access time in general case.A drawback of such approach is that, in theory, in new GHC version generified representation may change; however, chances are small and I (martoon) believe that contract versions will change much faster anyway.morleySince Contract@ name is used to designate contract code, lets call analogy of  type as follows.morley&A useful property which holds for all  types.morleyOverloaded version of  to work on Haskell and T stacks.morleyOverloaded version of  to work on Haskell and T types.morley1Type function to convert a Haskell stack type to T -based one.morley=Isomorphism between Michelson values and plain Haskell types.WDefault implementation of this typeclass converts ADTs to Michelson "pair"s and "or"s.morley:Type function that converts a regular Haskell type into a T type.morley"Converts a Haskell structure into Value representation.morley Converts a Value into Haskell type.morleyGIsomorphism between Michelson primitive values and plain Haskell types.morley[Type function that converts a regular Haskell type into a comparable type (which has kind CT).morley%Converts a single Haskell value into CVal representation.morley Converts a CVal# value into a single Haskell value.-None2!"#$%&',-.012456789;=>?@AHMNPSUVX_`befgk: morleyGeneric traversal for *.!morleyConstraint for *."morley"Types of all fields in a datatype.#morley9Way to construct one of the fields in a complex datatype. morleyGeneric traversal for ).%morleyConstraint for ). morleyGeneric traversal for  instrAccess.&morleyConstraint for (.'morley@Get type of field by datatype it is contained in and field name. morleyForce result of   to be  morley,Find field of some product type by its name.2Name might be either field record name, or one in  - if field is wrapped using '(:!)' or '(:?)'. morley>Result of field lookup - its type and path to it in the tree.(morleyEMake an instruction which accesses given field of the given datatype.)morleyFor given complex type dt and its field fieldTy update the field value.*morleyFor given complex type dt and its field fieldTy update the field value. !"#$%&'()* &%!()*'"#$.None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk?;morleyConvert a typed Val to an untyped Value.'For full isomorphism type of the given Val should not contain P - a compile error will be raised otherwise. You can analyse its presence with  function.:;<:<;/None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkCq@morley:This is the default set of ingredients extended with the  . which is used to generate xml reports for CI.@@0None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkE/AA1None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkK#BmorleyBuilding a record from tuple.%It differs from similar typeclass in jkG module in that it allows type inference outside-in - knowing desired Rece you know which tuple should be provided - this improves error messages when constructing concrete Rec objects.BCDBCD2None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkMEmorleyProduce B( instance for tuple of the given length.EE3None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkOlNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkQPBCDBCD4None2!"#$%&',-.012456789;=>?@AHMNPSUVX_`befgk|~ morleyPTraverse a single contructor and supply its field to instruction in case clause. morleyGeneric traversal for i.WmorleyList of Z.s required to pattern match on the given type.Xmorley*Type information about single case clause.ZmorleyuIn what different case branches differ - related constructor name and input stack type which the branch starts with. morleyGeneric traversal for i._morleymExpect referred constructor to have only one field (otherwise compile error is raised) and extract its type.`morleyaExpect referred constructor to have only one field (in form of constraint) and extract its type.amorleyRGet type of constructor fields (one or zero) referred by given datatype and name. morleyForce result of   to be  morley;Transitively find constructor of some sum type by its name.dTransitivity means that if sum type consists of other sum types, they will be searched recursively. morleyEResult of constructor lookup - entry type and path to it in the tree.bmorleyTo use c not only here for /-based stacks, but also later in Lorentz with  --based stacks we need the following property.cmorleyPush field to stack, if any.dmorleyGet  something# as field of the given constructor.emorleyWe support only two scenarious - constructor with one field and without fields. Nonetheless, it's not that sad since for sum types we can't even assign names to fields if there are many (the style guide prohibits partial records).hmorley Proof of b.imorley:Wrap given element into a constructor with the given name./Mentioned constructor must have only one field.Since labels interpretable by OverloadedLabelsm extension cannot start with capital latter, prepend constructor name with letter "c" (see examples below).jmorley<Wrap a haskell value into a constructor with the given name.This is symmetric to i.kmorley$Pattern-match on the given datatype.lmorley#Lift an instruction to case clause.\You should write out constructor name corresponding to the clause explicitly. Prefix constructor name with "c" letter, otherwise your label will not be recognized by Haskell parser. Passing constructor name can be circumvented but doing so is not recomended as mentioning contructor name improves readability and allows avoiding some mistakes.mmorley)Unwrap a constructor with the given name.Rules which apply to i/ function work here as well. Although, unlike  instrWrap8, this function does not work for nullary constructors.nmorley0Try to unwrap a constructor with the given name. morleyjFailure indicating that we expected value created with one constructor, but got value with different one.VWXYZ[\]^_`abcdefghijklmn^\VijklmnZ[XYWefgdcbha`_]l8mNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk#!"#$%&'()*VWXYZ[\]^_`abcdefghijklmnnNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkQ5!"#$%&'()*VWXYZ[\]^_`abcdefghijklmn5!"#$%&'()*VWXYZ[\]^_`abcdefghijklmnoNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk-,+     NOPQRSTUY[\]^_`abcdhqijklmnoprstuvwxyz{|}~nopqrstuvwxyz}|~{!"#$%&'()*:;<VWXYZ[\]^_`abcdefghijklmn5None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk morleyState for type checking nopmorley(Set of variables defined in a let-block.morleyQData type, holding strictly-typed Michelson value along with its type singleton.morleyQData type, holding strictly-typed Michelson value along with its type singleton.morleywData type keeping the whole type check result: instruction and type representations of instruction's input and output.morley]This data type keeps part of type check result - instruction and corresponding output stack.morley?Type-check result with concrete output stack, most common case.1Output stack type is wrapped inside the type and Typeable8 constraint is provided to allow convenient unwrapping.morley}Type-check result which matches against arbitrary output stack. Information about annotations in the output stack is absent.HThis case is only possible when the corresponding code terminates with FAILWITH instruction in all possible executions. The opposite may be not true though (example: you push always-failing lambda and immediatelly execute it - stack type is known).morleyNo-argument type wrapper for HST data type.morleyHData type holding type information for stack (Heterogeneous Stack Type).8This data type is used along with instruction data type Instr> to carry information about its input and output stack types.That is, if there is value instr :: Instr inp out, along with this instr one may carry inpHST :: HST inp and outHST :: HST outN which will contain whole information about input and output stack types for instr. Data type HST is very similar to Data.Vinyl.RecN, but is specialized for a particular purpose. In particular, definition of HST (t1 ': t2 ': ... tn ': '[]) requires constraints ,(Typeable t1, Typeable t2, ..., Typeable tn) as well as constraints -(Typeable '[ t1 ], Typeable '[ t1, t2 ], ...). These applications of Typeable= class are required for convenient usage of type encoded by HST ts with some functions from  Data.Typeable. Data type HST (Heterogeneous Stack Type) is a heterogenuous list of triples. First element of triple is a type singleton which is due to main motivation behind HST0, namely for it to be used as representation of Instr type data for pattern-matching. Second element of triple is a structure, holding field and type annotations for a given type. Third element of triple is an optional variable annotation for the stack element.morleyAppend a type to A, assuming that notes and annotations for this type are unknown.89 776None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk morleyDVarious type errors possible when checking Morley extension commandsmorleyType check errormorleyData type that represents various errors which are related to type system. These errors are used to specify info about type check errors in TCError data type.morleyAnnotation unify errormorleyNotes extraction errormorleyType equality errormorleyStacks equality errormorleyMError that happens when some instruction doesn't have support for some typesmorley,Error that happens when we meet unknown type7None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkemorleyThe typechecking statemorleyzRun type checker as if it worked isolated from other world - no access to environment of the current contract is allowed.)Use this function for test purposes only.8None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk{morleyAFunction which derives special annotations for PAIR instruction.+Namely, it does following transformation:  PAIR % % [  p.a int : p.b int : .. ] ~ [ "p (pair (int %a) (int %b) : .. ] All relevant cases (e.g.  PAIR %myf % 3) are handled as they should be according to spec.morleyGFunction which derives special annotations for CDR / CAR instructions.morley8Append suffix to variable annotation (if it's not empty)morley(Function which extracts annotations for or" type (for left and right parts).It extracts field/type annotations and also auto-generates variable annotations if variable annotation is not provided as second argument.morley(Function which extracts annotations for option t type.TIt extracts field/type annotations and also auto-generates variable annotation for Some/ case if it is not provided as second argument.morley.Combine annotations from two given stack typesmorley:Extract singleton for each single type of the given stack.morley.Check whether the given stack types are equal.morleyCheck whether the given stack has size 1 and its only element matches the given type. This function is a specialized version of .morleyCheck whether elements go in strictly ascending order and return the original list (to keep only one pass on the original list).morley Function eqType is a simple wrapper around Data.Typeable.eqT suited for use within Either TCTypeError a applicative.morley.Check whether typed and untyped types convergemorley%Generic implementation for MEMerationmorleyLHelper function to construct instructions for binary arithmetic operations.morleyLHelper function to construct instructions for binary arithmetic operations.$$9None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk morley Function typeCheckValImplA converts a single Michelson value given in representation from Michelson.Type2 module to representation in strictly typed GADT.As a third argument, typeCheckValImpl accepts expected type of value.VType checking algorithm pattern-matches on parse value representation, expected type t and constructs Val t value.If there was no match on a given pair of value and expected type, that is interpreted as input of wrong type and type check finishes with error. morley Function typeCheckMapVal typechecks given list of Elt5s and ensures, that its keys are in ascending order.YIt return list of pairs (key, value) with keys in ascending order so it is safe to call fromDistinctAscList on returned list:None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk morleyDCheck that the optional "forall" variables are consistent if present morley Executes function body, pushing ExtFrame+ onto the state and checks the pattern in FN. morley Check that a StackTypePattern& matches the type of the current stack morley<Create stack reference accessing element with a given index.2Fails when index is too large for the given stack.;None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkk morleyLike  typeCheck, but for non-empty lists.morley Function  typeCheckListG converts list of Michelson instructions given in representation from Michelson.Type2 module to representation in strictly typed GADT.YTypes are checked along the way which is neccessary to construct a strictly typed value.As a second argument,  typeCheckList) accepts input stack type representation.morley Function typeCheckValueA converts a single Michelson value given in representation from Michelson.Type2 module to representation in strictly typed GADT.As a second argument, typeCheckValue accepts expected type of value.VType checking algorithm pattern-matches on parse value representation, expected type t and constructs Val t value.If there was no match on a given pair of value and expected type, that is interpreted as input of wrong type and type check finishes with error.morleyLike &, but returns value of a desired type. morley Function typeCheckInstrG converts a single Michelson instruction given in representation from Michelson.Type2 module to representation in strictly typed GADT.As a second argument, typeCheckInstr) accepts input stack type representation.Type checking algorithm pattern-matches on given instruction, input stack type and constructs strictly typed GADT value, checking necessary type equalities when neccessary.If there was no match on a given pair of instruction and input stack, that is interpreted as input of wrong type and type check finishes with error. morleyMHelper function for two-branch if where each branch is given a single value.pNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkAC<None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk/imorleyState of a contract with code.morley'Amount of mutez owned by this contract.morley,Storage value associated with this contract.morleyContract itself (untyped). morleyState of an arbitrary address. morley5For contracts without code we store only its balance. morley<For contracts with code we store more state represented by .morleyaPersistent data passed to Morley contracts which can be updated as result of contract execution.morley$All known addresses and their state.morleyExtract balance from  .morleyUpdates that can be applied to . morleyNumber of genesis addresses. morley6Secrets from which genesis addresses are derived from."morleyKeyHash of genesis address.#morley.Initially these addresses have a lot of money.$morleyOne of genesis key hashes.%morleyOne of genesis addresses.&morleyMore genesis addressesWe know size of genesisAddresses, so it is safe to use !!'morleyMore genesis addressesWe know size of genesisAddresses, so it is safe to use !!(morleyMore genesis addressesWe know size of genesisAddresses, so it is safe to use !!,morleyInitial !. It's supposed to be used if no ? is provided. It puts plenty of money on each genesis address.-morleyRead  from a file..morleyWrite  to a file./morleyApply  to .0morleyApply a list of s to . morley.Add an address if it hasn't been added before. morley3Updare storage value associated with given address. morley3Updare storage value associated with given address.1morley&Retrive all contracts stored in GState$    !"#$%&'()*+,-./01$   #"%&'()*+$,-. !/01=None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk6;morley&Minimal (earliest) timestamp used for Arbitrary (CValue 'CTimestamp)<morley$Maximal (latest) timestamp used for Arbitrary (CValue 'CTimestamp)=morley Median of ; and <\. Useful for testing (exactly half of generated dates will be before and after this date).;<=;<=>None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk< HmorleypConvert an untyped contract into a textual representation which will be accepted by the OCaml reference client.ImorleymConvert a typed contract into a textual representation which will be accepted by the OCaml reference client.xyz{HIxyz{HI?None1!"#$%&',-.01245678;=>?@AHMNPSUVX_`befgkEJmorley6Built-in Michelson Macros defined by the specificationgmorley1Unexpanded instructions produced directly by the ops[ parser, which contains primitive Michelson Instructions, inline-able macros and sequenceshmorleyPrimitive Michelson instructionimorley5Built-in Michelson macro defined by the specificationjmorley2User-defined macro with instructions to be inlinedkmorleyA sequence of instructionsrmorleyA programmer-defined macroxmorley%Expand all macros in parsed contract.8JKLMNOPQRSTUVWXYZ[\]^_`abcdefgkhijlnmopqrstuvwxyz{|}~8lnmopqJKLMNOPQRSTUVWXYZ[\]^_`abrstuvcdgkhijfexyzw{|}~@None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkJPmorley!A programmer-defined type-synonymmorleyA programmer-defined constant  ANone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkM8morley2The environment containing lets from the let-blockBNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkO&  CNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkT morley endBy2 p sep# parses two or more occurrences of p, separated by sep.morleyMake a parser from a stringmorley8Apply given parser and return default value if it fails.DNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkWmorleyParse untyped ci. Take instruction parser as argument to avoid cyclic dependencies between modules, hence ' in its name.ENone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkY >? >?FNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk]morleyParse untyped Michelson  (i. e. one with annotations).morleyParse only explicit ,  and  are prohibitedGNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk_HNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkcAmorleyFParser for primitive Michelson instruction (no macros and extensions).morley!Parse a sequence of instructions.INone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkeJNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkjs morleyElement of a let blockmorleylet block parser morley'Incrementally build the let environment morley1add a Let to the environment in the correct place morley7build a let name parser from a leading character parserKNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkpmorleyParse with empty environmentmorley'Michelson contract with let definitions morleyMichelson contractmorley5Parses code block after "code" keyword of a contract.IThis function is part of the module API, its semantics should not change.%`abcdefghiefghi%`abcdLNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkmorleyAny decoding error. morleyAlias for label attaching. morleydGet a bytestring of the given length leaving no references to the original data in serialized form. morley-Read a byte and match it against given value. morleyFail with "unknown tag" error. morleynRead a byte describing the primitive going further and match it against expected tag in the given conditions.Aside of context description, you have to specify number of arguments which given instruction accepts when written in Michelson. For instance, PUSH) accepts two arguments - type and value. morleyLike  a, but doesn't backtrack if next entry failed to parse yet there are some bytes to consume ahead.9This function exists primarily for better error messages.morley6Deserialize bytes into the given value. Suitable for UNPACK operation only.morleyLike , for strict byte array. morley Overall value decoder we use in UNPACK. morley-Read length of something (list, string, ...). morley9Given decoder for list content, get a whole list decoder. morleyRead a numeric value. morleyFor UNPACKp we do not consider annotations at all. If they start matter for other purposes some day, remove this function. morley-Type check instruction occured from a lambda. 0MNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk~ morleySerialize a value given to PACK instruction.morleySame as , for strict bytestring. morley4Lift encoded list content to an entire encoded list. morleyEncode a list-like structure. morleyEncode a text. morleyEncode some raw data. morleyEncode some map. morley"Encode contents of a given number. morleyEncode an int-like value. morleyEncode a code block. morleyEncode an instruction.NNone1!"#$%&',-.01245678;=>?@AHMNPSUVX_`befgk- morleyMorley interpreter statemorleyfRepresents `[FAILED]` state of a Michelson program. Contains value that was on top of the stack when  was called.!morley#Environment for contract execution.#morleyATimestamp of the block whose validation triggered this execution.$morleyANumber of steps after which execution unconditionally terminates.%morley0Current amount of mutez of the current contract.&morleyOMapping from existing contracts' addresses to their executable representation.'morley$Address of the interpreted contract.(morley4The contract that initiated the current transaction.)morley=The contract that initiated the current internal transaction.*morley"Amount of the current transaction.,morley9Interpret a contract without performing any side effects..morley%Emulate multiple calls of a contract./morleyBFunction to change amount of remaining steps stored in State monad morleyCFunction to interpret Michelson instruction(s) against given stack. morley?Evaluates an arithmetic operation and either fails or proceeds.1morley*Unpacks given raw data into a typed value. morley,Access given stack reference (in CPS style)./      !"#$%&'()*+,-./01/!"#$%&'()*     +-. ,/01ONone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk$Cmorley'Type for contract execution validation.oIt's a function which is supplied with contract execution output (failure or new storage with operation list).FFunction returns a property which type is designated by type variable prop and might be qr or st or anything else relevant.DmorleyContract's property tester against given input. Takes contract environment, initial storage and parameter, interprets contract on this input and invokes validation function.Emorley Version of D which takes Val1 as arguments instead of regular Haskell values. CDEFG CDEFGPNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkHmorley0Dummy timestamp, can be used to specify current  value or maybe something else.ImorleyDummy value for maximal number of steps a contract can make. Intentionally quite large, because most likely if you use dummy value you don't want the interpreter to stop due to gas exhaustion. On the other hand, it probably still prevents the interpreter from working for eternity.JmorleyDummy !s with some reasonable hardcoded values. You can override values you are interested in using record update syntax.Kmorley with most data hardcoded to some reasonable values. Contract and initial values must be passed explicitly, because otherwise it hardly makes sense.HIJKHIJKQNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkLmorley,Result of a single execution of interpreter.NmorleyNew .Omorley7List of operations to be added to the operations queue.PmorleyUpdates applied to .QmorleyDuring execution a contract can print logs and in the end it returns a pair. All logs and returned values are kept until all called contracts are executed. In the end they are printed.RmorleyPAs soon as transfer operation is encountered, this address is set to its input.Smorley2Now much gas all remaining executions can consume.TmorleyMOperations executed by interpreter. In our model one Michelson's operation ( operationA type in Michelson) corresponds to 0 or 1 interpreter operation.Note:  is not part of I , because I0 is supposed to be provided by the user, while  can be computed by our code.UmorleyOriginate a contract.VmorleybSend a transaction to given address which is assumed to be the address of an originated contract.ZmorleyEErrors that can happen during contract interpreting. Type parameter aE determines how contracts will be represented in these errors, e.g. Address[morley0The interpreted contract hasn't been originated.\morley,Interpretation of Michelson contract failed.]morley!A contract is already originated.^morleySender address is unknown._morleyManager address is unknown.`morley!Sender doesn't have enough funds.amorley"Failed to apply updates to GState.bmorleyA contract is ill-typed.emorleyParse a contract from .fmorleyParse a contract from  and expand macros.gmorley,Read and parse a contract from give path or   (if the argument is  ). The contract is not expanded.hmorleyRead a contract using g8, expand and flatten. The contract is not type checked.imorleyFOriginate a contract. Returns the address of the originated contract.jmorley}Run a contract. The contract is originated first (if it's not already) and then we pretend that we send a transaction to it.kmorley:Send a transaction to given address with given parameters. morleyeInterpret a contract on some global state (read from file) and transaction data (passed explicitly).lmorley&Implementation of interpreter outside  . It reads operations, interprets them one by one and updates state accordingly. Each operation from the passed list is fully interpreted before the next one is considered. morley.Run only one interpreter operation and update  accordingly.-IJKLM   LMNOPQRSTUVYZ[\]^_`abcdefghijklm-ijkefghm   IJKLMTUVLMNOPQRSZ[\]^_`abYlcdRNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk  morley"Operations to be interpreted when  TOValidate is encountered. morley4Map from contracts addresses to humanreadable names. morleyRIf set, all following transfers will be executed on behalf of the given contract. morley$A dummy data type that ensures that J is called in the end of each scenario. It is intentionally not exported.|morleyMA monad inside which integrational tests can be described using do-notation.}morleyFValidator for integrational testing that expects successful execution.~morleyLValidator for integrational testing. If an error is expected, it should be  Z with validator for errors. Otherwise it should check final global state and its updates.morleyoIntegrational test that executes given operations and validates them using given validator. It can fail using   capability. It starts with , and some reasonable dummy values for gas limit and current timestamp. You can update blockchain state by performing some operations.morleyIntegrational test similar to . It can fail using  / capability. It can be used with QuickCheck's forAll4 to make a property-based test with arbitrary data.morleyVOriginate a contract with given initial storage and balance. Its address is returned.morley!Transfer tokens to given address.morleyDExecute all operations that were added to the scenarion since last 9 call. If validator fails, the execution will be aborted.morley@Make all further interpreter calls (which are triggered by the 2 function) use given timestamp as the current one.morley@Make all further interpreter calls (which are triggered by the  function) use given gas limit.morleyTPretend that given address initiates all the transfers within the code block (i.e. SENDER' instruction will return this address).morley} that always passes.morleyjCheck that storage value is updated for given address. Takes a predicate that is used to check the value.YIt works even if updates are not filtered (i. e. a value can be updated more than once).morleyLike , but expects a constant.morley@Check that eventually address has some particular storage value.morley:Check that eventually address has some particular balance.morleyCompose two success validators. For example:expectBalance bal addr * expectStorageUpdateConst addr2 ValueUnitmorley%Compose a list of success validators.morley4Check that interpreter failed due to gas exhaustion.morleyOExpect that interpretation of contract with given address ended with [FAILED].*IJKLM%&'()*+rstuvwxyz{|}~*IJKLM%&'()*+~}|{rstuvwxyzNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk1 !DGKsvz[\]^_`abcd1[\]^_`abcdGDszvK !SNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk+morleyLifted  UnaryAithOp.morleyLifted AithOp.TNone1!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkq morleyLifted .morleyLifted .morleyLifted .morleyLifted .morleyLifted .morleyLifted .4This could be just a constraint alias, but to avoid W types appearance in error messages we make a full type class with concrete instances.morleyLifted .morleyLifted .morley-A useful property which holds for reasonable  instances.It's a separate thing from  because it mentions b type parameter.morleyLifted .UNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk &morley/Ensure given type does not contain "operation".morley2Gathers constraints, commonly required for values.VNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk'morley Alias for 3, seems to make signatures more readable sometimes.:Let's someday decide which one of these two should remain.morleyAAlias for instruction which hides inner types representation via . morleyFor use outside of Lorentz. morley Version of  < specialized to instruction corresponding to contract code.            211WNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk1dmorleyHelper instruction.jChecks whether given key present in the storage and fails if it is. This instruction leaves stack intact.emorleyLike -<, but throw an error on attempt to overwrite existing entry.fmorleyFail with a given message.gmorley;Fail with a given message and the top of the current stack.hmorley"Fail with the given Haskell value.imorleyTFail, providing a reference to the place in the code where this function is called.Like  ? in Haskell code, this instruction is for internal errors only.X !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghiX !"#$&'()*+,-de.%/01234fghi56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcXNone2!"#$%&',-.01245678;=>?@ACHMNPSUVX_`befgk? morley<Allows diving into stack referring expected new tip by type.Implemented with fun deps for conciseness; we can replace them with a type family anytime, but that would probably require more declarations. morley9Allows duplicating stack elements referring them by type.kmorley3Duplicate an element of stack referring it by type.IIf stack contains multiple entries of this type, compile error is raised.lmorleyFDip repeatedly until element of the given type is on top of the stack.IIf stack contains multiple entries of this type, compile error is raised.mmorley2Remove element with the given type from the stack.klmklmYNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkEtmorley+Contract names, for Haskell and for humans.vmorley)Identifier of a contract, e.g. "auction".wmorley1Name of a contract as is appears in Haskell code.xmorley=Information about a contract required for contracts registry.|morley+Defined for values representing a contract. tuvwxyz{|}~ |}xyz{tuvw~None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkMHmorley9Whether two types have the same Michelson representation.morleyBConvert between values of types that have the same representation.morleySpecialized version of  to wrap into a haskell newtype.morleySpecialized version of  to unwrap a haskell newtype.morley"Lift given value to a named value.morleyUnpack named value. $#" $#"ZNone2!"#$%&',-.012456789;=>?@AHMNPSUVX_`befgkjmorleyeNewtype over void result type used in tests to distinguish successful void result from other errors.;Usage example: lExpectFailWith (== VoidResult roleMaster)`morleyvoid! type synonym as described in A1.morleyEntry point argument.morleyType of result reported via 4.morleyview! type synonym as described in A1. morley(Various convenient instructions on maps. morleySpecialized version of -.morleyInsert given element into map.morleyWInsert given element into map, ensuring that it does not overwrite any existing entry.=As first argument accepts container name (for error message).morleyDelete element from the map.morleyxAnalog of the FAIL macro in Michelson. Its usage is discouraged because it doesn't carry any information about failure.morleyDII+P" macro. For example, `dipX @3` is DIIIP.morley[Custom Lorentz macro that drops element with given index (starting from 0) from the stack.morleyDuplicate the top of the stack n times.@For example, `cloneX @3` has type `a & s :-> a & a & a & a & s`.morleyDUU+P# macro. For example, `duupX @3` is DUUUPF, it puts the 3-rd (starting from 1) element to the top of the stack.morleyEMove item with given index (starting from 0) to the top of the stack.TODO: probably it can be implemented more efficiently, so if we ever want to optimize gas consumption we can rewrite it. It only makes sense if it's applied to a relatively large index.morleyInsert given element into set.!This is a separate function from  updateMap4 because stacks they operate with differ in length.morleyWInsert given element into set, ensuring that it does not overwrite any existing entry.)As first argument accepts container name.morley"Delete given element from the set.LLNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkrmorleyPredicate for if ... then .. else ...] construction, defines a kind of operation applied to the top elements of the current stack.morley$Aliases for '(#)' used by do-blocks.morleyDefines semantics of if ... then ... else ... construction.[None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgku6None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk% morleyLorentz analogy of X, it works on plain   types.morleyShortcut for multiple   constraints.morleyA pair of field name and type. morleyLike  &, but allows constrainting field type. morley%Allows field access and modification. morley]Extract a field of a datatype replacing the value of this datatype with the extracted field.wFor this and the following functions you have to specify field name which is either record name or name attached with (:!) operator. morleyLike  , but leaves field named. morleyFExtract a field of a datatype, leaving the original datatype on stack. morleyLike  , but leaves field named. morleySet a field of a datatype. morley)Apply given modifier to a datatype field. morleyIMake up a datatype. You provide a pack of individual fields constructors.KEach element of the accepted record should be an instruction wrapped with  T function. This instruction will have access to the stack at the moment of calling  construct. Instructions have to output fields of the built datatype, one per instruction; instructions order is expected to correspond to the order of fields in the datatype. morley Version of  + which accepts tuple of field constructors. morley)Lift an instruction to field constructor. morley0Wrap entry in constructor. Useful for sum types. morley#Lift an instruction to case clause.\You should write out constructor name corresponding to the clause explicitly. Prefix constructor name with "c" letter, otherwise your label will not be recognized by Haskell parser. Passing constructor name can be circumvented but doing so is not recomended as mentioning contructor name improves readability and allows avoiding some mistakes. morley$Pattern match on the given sum type.You have to provide a 0; containing case branches. To construct a case branch use   operator. morleyLike  ;, accepts a tuple of clauses, which may be more convenient.()*0/.                      0/.)*( 0\None2!"#$%&',-.012456789;=>?@AHMNPSUVX_`befgk morleyContract storage with big_map.HDue to Michelson constraints it is the only possible layout containing big_map. morley1Write down all sensisble constraints which given store satisfies and apply them to  constrained.This store should have  D datatype in its immediate fields, no deep inspection is performed. morley>This constraint can be used if a function needs to work with big8 store, but needs to know only about some part(s) of it.eIt can use all Store operations for a particular name, key and value without knowing whole template. morley\Prepend a constructor name with a lower-case character so that you could make a label with OverloadedLabels% extension matching resulting thing. morley9Get map signature from the constructor with a given name. morleyType arguments of  . morley Number of datatype constructors. morleyDPosition of a constructor in the corresponding datatype declaration. morleyDescribes one virtual big map. morleyGathers multple s under one object.Type argument of this datatype stands for a "map template" - a datatype with multiple constructors, each containing an object of type  % and corresponding to single virtual s. It's also possible to parameterize it with a larger type which is a sum of types satisfying the above property.Inside it keeps only one * thus not violating Michelson limitations.See examples below. $morleyKInsert a key-value pair, but fail if it will overwrite some existing entry. &morleyUnpack   into a pair. 'morleyPack a pair into  . +morleyKInsert a key-value pair, but fail if it will overwrite some existing entry. -morleyLift a key-value pair to  .Further you can use  instance of Store to make up large stores. .morleyGet a value from store by key.SIt expects map to be consistent, otherwise call to this function fails with error.                 ! " # $ % & ' ( ) * + , - .      ! " # $ %           & ' ( ) * + , - . ]None1!"#$%&',-.01245678;=>?@AHMNPSUVX_`befgk Gmorley Signature of  K. Hmorley?An error indicating a normal failure caused by such user input. morleyA unique error identifier. Imorley+Constraints on an object you can fail with. JmorleyPseudo-getter for error within  H. KmorleyyFail with given error, picking argument for error from the top of the stack if any required. Error will be wrapped into  H9 (i.e. an error tag will be attached to the error data).Consider the following practice: once error datatype for your contract is defined, create a specialization of this function to the error type. G H I J K I H J G KuNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgkt      !$#"&'()*0/.DGKsvz[\]^_`abcd      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghiklm                           ! " # $ % & ' ( ) * + , - . G H I J K^None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk QmorleyError type for  [ function. Vmorley{Import contract and use it in the spec. Both versions of contract are passed to the callback function (untyped and typed).If contract's import failed, a spec with single failing expectation will be generated (so tests will run unexceptionally, but a failing result will notify about problem). WmorleyLike  V, but for Lorentz types. Xmorley A version of  V= which passes only the typed representation of the contract. [morley'Import contract from a given file path.This function reads file, parses and type checks a contract. Within the typechecking we assume that no contracts are originated, otherwise a type checking error will be caused.This function may throw   and  Q. Q T U R S V W X Y Z [ \ Z V W X Y [ \ Q T U R SvNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk-IJKLM%;<= CDEFGJ{|}~ V W X Y \- V W X Y \ CDEFG~}{|IJKLM%J;<=_None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk/ morley getRareT k generates ! producing anything big once per  1 / (k + 1) invocation. morley getRareT k generates ! producing anything big once per  1 / (k + 1) invocation.#Useful to avoid exponensial growth. amorley&Run given generator deterministically. a a`None0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk morleyLike  originate#, but for typed contract and value. morleyLike  originate, but for Lorentz contracts. morley<Originate a contract with empty balance and default storage. morley Similar to k, for typed values. morley Similar to k, for Lorentz values. morley>Call a contract without caring about source address and money. morley Similar to expectStorageUpdate, for Lorentz values. morleyLike  expectBalance, for Lorentz values. morley Similar to expectStorageConst, for Lorentz values. morleyOExpect that interpretation of contract with given address ended with [FAILED]. morleyExpect contract to fail with FAILWITHF instruction and provided value to match against the given predicate. morley#Expect contract to fail with given LorentzUserError error. morley Version of  * specialized to "consumer" contract (see wx). morley8Assuming that "consumer" contract receives a value from View5, expect this view return value to be the given one.Despite consumer stores parameters it was called with in reversed order, this function cares about it, so you should provide a list of expected values in the same order in which the corresponding events were happenning./IJKLM#%&'()*+rstuvwxyz{|}~ /IJKLM#%&'()*+~}|{rstuvwxyz  yNone0!"#$%&',-.01245678=>?@AHMNPSUVX_`befgk@IJKLM#%&'()*+;<= CDEFGJrstuvwxyz{|}~ V X Y @ V X Y CDEFG~}{|rstuvwxyz  IJKLM#%&'()*+J;<= z{|z}~z{zz{z{z{z{z{zziz{z{zzzzzzzz{z{|                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 789:;<=>?@ABCDEFFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}}ff~      !"#$%&'()nopqrstuvwxyz{|*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrsttuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>??@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~e                      ! " # $ % & ' ( ) * + , - . / 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!{!|!}!~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"##$$$$%%&''''''''''((((((((())))))))))))))))))************e*****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/G0H1I1J1K2L3M3N3O3P3Q3R3S3T3U3V3W3X3Y3Z3[3\4]4^4_4_4`4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}4~4444444444444445555555555555555555555555555666666666666666666666666666666666677777777777777788888888888888888888888888888888888899:;;;;<<<<<<<<<< < < < < <<<<<<<<<<<<<<<<<<<< <!<"<#<$<%<&<'<(<)<*<+<,<-<.</<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?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}?~???????????????????????????????????@@@@@@@@@@@@@@@@@AAAAAAAAAABBBBBBBBBBBBCCCCDDDDDEEEEEEEEEEFFFGGGHHHHHIIIIJJJKKKKLLLLLLLLLLLMMNNNNNNNNNNNNNNNNNNNNN N N N N NNNNNNNNNNNNNNNNNNNN N!N"N#N$N%N&N'N(N)N*N+N,N-N.N/N0N1N2N3O4O5O6O7O8P9P:P;P<Q=Q=Q>Q?Q@QAQBQCQDQEQFQGQHQIQJQKQLQMQNQOQPQQQRQSQTQUQVQWQXQYQZQ[Q\Q]Q^Q_Q`QaRbRcRdReRfRgRhRiRjRkRlRmRnRoRpRqR[RrRsRtRuRvRwRxRyRzR{R|R}R~RRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUVVVVVVVVVVVVVVVWWWWWWWWWWW W W W W WWWWWWWWWWWWWWWWWWW W!W"W#W$W%W&W'WW(W)W*W+W,W-W.W/W0W1W2W3W4W5W6W7W8W9W:W;W<W=W>W?W@WAWBWCWDWEWFWWWWGWWHWIWJWKWLWMWNWOWPWQWRXSXTXUXVXWXXXYXZX[Y\Y\Y]Y^Y_Y_Y`YaYbYcYdYeYfYgYhYiYjYkYlmnopqrZsZsZtZuZuZvZwZxZxZyZzZ{Z|Z}Z~ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[[[\\\\\\\\\\\\\\\\\\\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ !\ "\ #\ $] %] &] '] (] )] *] +] ,] -] .^ /^ 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 qz r s t u v w x y zrz { | } ~             a a a a a a a a     z{z{ )  - - - - - -  - 4 4 4 4 4 4 4 f4 9 : : : : ; ; ; < < < < < J J J J K>L L L L L L z{ L L L L L L M M M M M M M M M N N N z Q  Q R R R R z  t X X Z Z  \ \ \ \ \ ] z  _ _ ` ` #morley-0.3.0-7oMtJCcnhvo7MqJS85kloiLorentz.PreludeLorentz.Rebinded Lorentz.Value Util.DefaultLorentz.CoercionsMichelson.Parser.Error Lorentz.ADTMichelson.Typed.SingMichelson.EqParamMichelson.ErrorPosMichelson.Printer.UtilMichelson.Test.UtilMichelson.Text%Michelson.Typed.Haskell.Instr.HelpersMichelson.Untyped.AnnotationMichelson.Untyped.TypeMichelson.Untyped.ExtMichelson.Untyped.ContractMichelson.Typed.TMichelson.Typed.ScopeMichelson.Typed.AnnotationMichelson.Untyped.Value Tezos.Core Tezos.Crypto Tezos.AddressMichelson.Untyped.InstrMichelson.Untyped.AliasesMichelson.Typed.ExtractMichelson.Typed.PrintMichelson.Typed.CValueMichelson.Typed.ValueMichelson.Typed.PolymorphicMichelson.Typed.ArithUtil.Alternative Util.GenericUtil.IOUtil.Instances Util.LensMichelson.Runtime.TxData Util.Named Util.PeanoMichelson.Typed.InstrMichelson.Typed.AliasesMichelson.Typed.Haskell.Value%Michelson.Typed.Haskell.Instr.ProductMichelson.Typed.ConvertUtil.Test.Ingredients Util.TypeUtil.TypeTuple.ClassUtil.TypeTuple.THUtil.TypeTuple.Instances!Michelson.Typed.Haskell.Instr.SumMichelson.TypeCheck.TypesMichelson.TypeCheck.ErrorMichelson.TypeCheck.TypeCheckMichelson.TypeCheck.HelpersMichelson.TypeCheck.ValueMichelson.TypeCheck.ExtMichelson.TypeCheck.InstrMichelson.Runtime.GStateMichelson.Test.GenMichelson.PrinterMichelson.Macro Michelson.LetMichelson.Parser.TypesMichelson.Parser.LexerMichelson.Parser.HelpersMichelson.Parser.ValueMichelson.Parser.AnnotationsMichelson.Parser.TypeMichelson.Parser.ExtMichelson.Parser.InstrMichelson.Parser.MacroMichelson.Parser.LetMichelson.ParserMichelson.Interpret.UnpackMichelson.Interpret.PackMichelson.InterpretMichelson.Test.UnitMichelson.Test.DummyMichelson.RuntimeMichelson.Test.Integrational Lorentz.ArithLorentz.PolymorphicLorentz.Constraints Lorentz.Base Lorentz.InstrLorentz.ReferencedLorentz.Discover Lorentz.Macro Lorentz.Ext Lorentz.StoreLorentz.ErrorsMichelson.Test.ImportUtil.Test.ArbitraryLorentz.Test.Integrational Paths_morley Michelson*Michelson.UntypedInstrTypeMichelson.TypeDataGeneric Data.Vinyl FromTupleUtil.TypeTupleMichelson.Typed.Haskell.InstrMichelson.Typed.HaskellMichelson.TypedMichelson.TypeCheckTest.QuickCheckProperty Test.Hspec ExpectationLorentzMichelson.TestLorentz.Contracts.ConsumercontractConsumer Lorentz.TestbaseGHC.Base$GHC.Num fromIntegerreturn Data.String fromString<>memptymappendmconcatpureGHC.EnumBoundedghc-prim GHC.ClassesEqOrd GHC.Generics SemigroupMonoid GHC.TypesBool integer-gmpGHC.Integer.TypeInteger GHC.NaturalNatural GHC.MaybeMaybeFalseNothingJustTruebytestring-0.10.8.2Data.ByteString.Internal ByteString text-1.2.3.1Data.Text.InternalTextcontainers-0.6.0.1Data.Map.InternalMapGHC.OverloadedLabels fromLabelmaxBoundminBoundstimessconcatData.Set.InternalSet1data-default-class-0.1.2.0-FeIQ5tLoVZBHMSgrT9zptQData.Default.ClassDefaultdef"lens-4.17.1-1i3IrnYg42BFdHAkisOfv6Control.Lens.Wrapped _Wrapped' UnwrappedWrapped'megaparsec-7.0.5-1qUnxTAiqclI8WUqrA8tSYText.Megaparsec.ErrorParseErrorBundle&universum-1.5.0-Cvx2YEtqRTXHRCbgP5xqGZUniversum.Debug undefinedUniversum.TypeOps#named-0.3.0.0-9leqS8aey8BQSrk7nzy67Named.Internalarg:!:?'singletons-2.5.1-8VGOuN3VpxJEwQD9OCbFN6Data.Singletons.Internal applySingSLambdaSing#vinyl-0.11.0-LJvBafk1nQd3k0i9gXI7LBData.Vinyl.Core:&RNilReceqParam1eqParam2eqParam3InstrCallStack icsCallStack icsSrcPos LetCallStackLetNameSrcPosPosmkPossrcPos $fFromJSONPos $fToJSONPos $fDefaultPos$fFromJSONSrcPos$fToJSONSrcPos$fDefaultSrcPos$fFromJSONLetName$fToJSONLetName$fFromJSONInstrCallStack$fToJSONInstrCallStack$fDefaultInstrCallStack$fEqPos$fOrdPos $fShowPos $fGenericPos $fDataPos $fEqSrcPos $fOrdSrcPos $fShowSrcPos$fGenericSrcPos $fDataSrcPos $fEqLetName $fOrdLetName $fShowLetName $fDataLetName$fGenericLetName$fEqInstrCallStack$fOrdInstrCallStack$fShowInstrCallStack$fGenericInstrCallStack$fDataInstrCallStackParserExceptionStringLiteralParserExceptionInvalidEscapeSequence InvalidCharCustomParserExceptionUnknownTypeExceptionStringLiteralExceptionOddNumberBytesExceptionProhibitedLetType0$fShowErrorComponentStringLiteralParserException)$fShowErrorComponentCustomParserException$fBuildableParserException$fExceptionParserException$fShowParserException $fEqStringLiteralParserException"$fDataStringLiteralParserException!$fOrdStringLiteralParserException"$fShowStringLiteralParserException$fEqCustomParserException$fDataCustomParserException$fOrdCustomParserException$fShowCustomParserException$fEqParserException RenderDoc renderDoc isRenderableprintDoc renderOps renderOpsListspaces wrapInParensbuildRenderDocleftToShowPanicleftToPrettyPanic failedProp succeededPropqcIsLeft qcIsRightDoNotUseTextErrorMText MTextUnsafeunMTextisMCharmkMText mkMTextUnsafe mkMTextCut writeMText takeMText dropMTextmtqqMText$fIsStringMText$fFromJSONMText $fToJSONMText$fArbitraryMText $fToTextMText $fShowMText $fEqMText $fOrdMText $fDataMText$fSemigroupMText $fMonoidMText$fContainerMText$fBuildableMTextRSplitrsplitPathBranchLSR $fRSplitk:r $fRSplitk[]r RenderAnn renderAnnVarAnnFieldAnnTypeAnn AnnotationWithAnnnoAnnannunifyAnn ifAnnUnified disjoinVnconvAnn$fDefaultAnnotation$fShowAnnotation$fShowAnnotation0$fShowAnnotation1$fBuildableAnnotation$fRenderDocAnnotation$fBuildableAnnotation0$fRenderDocAnnotation0$fMonoidAnnotation$fSemigroupAnnotation$fBuildableAnnotation1$fRenderDocAnnotation1$fRenderAnnAnnotation$fRenderAnnAnnotation0$fRenderAnnAnnotation1$fEqAnnotation$fDataAnnotation$fFunctorAnnotation$fGenericAnnotation$fIsStringAnnotation$fFromJSONAnnotation$fToJSONAnnotationCTCIntCNatCStringCBytesCMutezCBoolCKeyHash CTimestampCAddressTTcTKeyTUnit TSignatureTOptionTListTSet TOperation TContractTPairTOrTLambdaTMapTBigMap Comparable TypeParameter TypeStorageTaddress Ttimestamp Tkey_hashTboolTmutezTbytesTstringTnatTint compToType typeToComptinttnattstringtbytestmuteztbooltkeyHash ttimestamptaddress isAtomicTypeisKey isSignature isComparableisMutez isTimestamp isKeyHashisBoolisString isIntegerisNatisIntisBytes $fBuildableCT $fRenderDocCT$fBuildableComparable$fRenderDocComparable $fBuildableT$fBuildableType $fRenderDocT$fRenderDocType$fEqCT$fOrdCT$fShowCT$fDataCT$fEnumCT $fBoundedCT $fGenericCT$fEqComparable$fShowComparable$fDataComparable$fGenericComparable$fEqT$fShowT$fDataT $fGenericT$fEqType $fShowType $fDataType $fGenericType$fFromJSONType $fToJSONType$fFromJSONComparable$fToJSONComparable $fFromJSONT $fToJSONT $fFromJSONCT $fToJSONCT TestAsserttassName tassComment tassInstrs PrintCommentunUPrintCommentStackFnquantifiedVars inPattern outPatternStackTypePatternStkEmptyStkRestStkConsTyVarVarIDTyConVarStackRefExtInstrAbstract STACKTYPEFN UTEST_ASSERTUPRINTstackTypePatternToListvarSet$fBuildableStackRef$fBuildableVar$fBuildableTyVar$fBuildableStackTypePattern$fBuildableStackFn$fBuildablePrintComment$fBuildableTestAssert$fBuildableExtInstrAbstract$fRenderDocExtInstrAbstract $fEqStackRef$fShowStackRef$fDataStackRef$fGenericStackRef$fEqVar $fShowVar$fOrdVar $fDataVar $fGenericVar $fEqTyVar $fShowTyVar $fDataTyVar$fGenericTyVar$fEqStackTypePattern$fShowStackTypePattern$fDataStackTypePattern$fGenericStackTypePattern $fEqStackFn $fShowStackFn $fDataStackFn$fGenericStackFn$fEqPrintComment$fShowPrintComment$fDataPrintComment$fGenericPrintComment$fEqTestAssert$fShowTestAssert$fFunctorTestAssert$fDataTestAssert$fGenericTestAssert$fEqExtInstrAbstract$fShowExtInstrAbstract$fDataExtInstrAbstract$fGenericExtInstrAbstract$fFunctorExtInstrAbstract$fFromJSONExtInstrAbstract$fToJSONExtInstrAbstract$fFromJSONPrintComment$fToJSONPrintComment$fFromJSONStackTypePattern$fToJSONStackTypePattern$fFromJSONStackRef$fToJSONStackRef$fFromJSONStackFn$fToJSONStackFn $fFromJSONVar $fToJSONVar$fFromJSONTyVar $fToJSONTyVar$fFromJSONTestAssert$fToJSONTestAssert Contract'ContractparastorcodeStorage Parameter$fBuildableContract'$fRenderDocContract' $fEqContract'$fShowContract'$fFunctorContract'$fDataContract'$fGenericContract'$fFromJSONContract'$fToJSONContract'STcSTKeySTUnit STSignatureSTOptionSTListSTSet STOperation STContractSTPairSTOrSTLambdaSTMapSTBigMapSCIntSCNatSCStringSCBytesSCMutezSCBool SCKeyHash SCTimestamp SCAddresswithSomeSingCT fromSingCT withSomeSingT fromSingT$fSingITTBigMap $fSingITTMap$fSingITTLambda $fSingITTOr $fSingITTPair$fSingITTContract$fSingITTOperation $fSingITTSet $fSingITTList$fSingITTOption$fSingITTSignature $fSingITTUnit $fSingITTKey $fSingITTc$fSingICTCAddress$fSingICTCTimestamp$fSingICTCKeyHash$fSingICTCBool$fSingICTCMutez$fSingICTCBytes$fSingICTCString $fSingICTCNat $fSingICTCInt $fSingKindCT $fSingKindTBigMapPresence BigMapPresent BigMapAbsent OpPresence OpPresentOpAbsent AllowBigMap ForbidBigMapForbidOpBigMapConstraint HasNoBigMapHasNoOp forbiddenOpforbiddenBigMapcheckBigMapConstraintcheckOpPresencecheckBigMapPresence opAbsense bigMapAbsensebigMapConstrained $fHasNoOpt$fHasNoBigMaptAnnConvergeErrorNotes'NTcNTKeyNTUnit NTSignatureNTOptionNTListNTSet NTOperation NTContractNTPairNTOrNTLambdaNTMapNTBigMapNotesNNStar notesCaseisStarmkNotesorAnnconverge convergeAnns$fBuildableAnnConvergeError$fEqAnnConvergeError $fEqNotes$fShowAnnConvergeError $fEqNotes' $fShowNotes' $fShowNotesInternalByteStringEltValue'ValueInt ValueString ValueBytes ValueUnit ValueTrue ValueFalse ValuePair ValueLeft ValueRight ValueSome ValueNoneValueNilValueSeqValueMap ValueLambdaunInternalByteString$fFromJSONInternalByteString$fToJSONInternalByteString$fBuildableElt$fBuildableValue'$fRenderDocElt$fRenderDocValue'$fDataInternalByteString$fEqInternalByteString$fShowInternalByteString $fEqValue' $fShowValue'$fFunctorValue' $fDataValue'$fGenericValue'$fEqElt $fShowElt $fFunctorElt $fDataElt $fGenericElt$fFromJSONValue'$fToJSONValue' $fFromJSONElt $fToJSONElt Timestamp unTimestampMutezunMutezmkMutez unsafeMkMuteztoMutezaddMutezunsafeAddMutezsubMutezunsafeSubMutezmulMutez divModMutezdivModMutezInttimestampToSecondstimestampFromSecondstimestampFromUTCTimetimestampPlusSecondsformatTimestampparseTimestampgetCurrentTime$fBoundedMutez$fBuildableTimestamp $fShowMutez $fEqMutez $fOrdMutez $fDataMutez$fGenericMutez $fEnumMutez$fBuildableMutez$fShowTimestamp $fEqTimestamp$fOrdTimestamp$fDataTimestamp$fGenericTimestamp$fFromJSONMutez $fToJSONMutez$fFromJSONTimestamp$fToJSONTimestampB58CheckWithPrefixErrorB58CheckWithPrefixWrongPrefixB58CheckWithPrefixWrongEncodingCryptoParseErrorCryptoParseWrongBase58CheckCryptoParseWrongTagCryptoParseCryptoErrorKeyHash unKeyHash Signature unSignature SecretKey PublicKey unPublicKey detSecretKeytoPublicformatPublicKeymformatPublicKeyparsePublicKey mkPublicKeyformatSecretKeyparseSecretKeyformatSignaturemformatSignatureparseSignature mkSignature formatKeyHashmformatKeyHash parseKeyHashsigncheckSignaturehashKeyblake2b blake2b160sha256sha512encodeBase58CheckdecodeBase58CheckdecodeBase58CheckWithPrefix$fFromJSONPublicKey$fToJSONPublicKey$fBuildablePublicKey$fArbitraryPublicKey$fBuildableSecretKey$fArbitrarySecretKey$fFromJSONSignature$fToJSONSignature$fBuildableSignature$fArbitrarySignature$fFromJSONKeyHash$fToJSONKeyHash$fBuildableKeyHash$fArbitraryKeyHash$fBuildableCryptoParseError$fShowPublicKey $fEqPublicKey$fShowSecretKey $fEqSecretKey$fShowSignature $fEqSignature $fShowKeyHash $fEqKeyHash $fOrdKeyHash$fShowCryptoParseError$fEqCryptoParseError$fShowB58CheckWithPrefixErrorAddress KeyAddressContractAddress mkKeyAddressmkContractAddressRaw formatAddressmformatAddress parseAddressunsafeParseAddress$fArbitraryAddress$fFromJSONKeyAddress$fFromJSONAddress$fToJSONKeyAddress$fToJSONAddress$fBuildableAddress$$fBuildableParseContractAddressError$fBuildableParseAddressError $fShowAddress $fEqAddress $fOrdAddress$fShowParseContractAddressError$fEqParseContractAddressError$fShowParseAddressError$fEqParseAddressErrorOriginationOperation ooManager ooDelegate ooSpendable ooDelegatable ooBalance ooStorage ooContract InstrAbstractEXTDROPDUPSWAPPUSHSOMENONEUNITIF_NONEPAIRCARCDRLEFTRIGHTIF_LEFTNILCONSIF_CONSSIZE EMPTY_SET EMPTY_MAPMAPITERMEMGETUPDATEIFLOOP LOOP_LEFTLAMBDAEXECDIPFAILWITHCASTRENAMEPACKUNPACKCONCATSLICEISNATADDSUBMULEDIVABSNEGLSLLSRORANDXORNOTCOMPAREEQNEQLTGTLEGEINTSELFCONTRACTTRANSFER_TOKENS SET_DELEGATECREATE_ACCOUNTCREATE_CONTRACTIMPLICIT_ACCOUNTNOWAMOUNTBALANCECHECK_SIGNATURESHA256SHA512BLAKE2BHASH_KEYSTEPS_TO_QUOTASOURCESENDERADDRESS ExpandedOpPrimExSeqEx WithSrcEx ExpandedInstrExpandedInstrExtUOpunOp InstrExtUflattenExpandedOpmkContractAddress$fFromJSONInstrAbstract$fToJSONInstrAbstract$fBuildableInstrAbstract$fRenderDocInstrAbstract$fFromJSONExpandedOp$fToJSONExpandedOp$fBuildableExpandedOp$fRenderDocExpandedOp $fFromJSONOp $fToJSONOp$fToJSONOriginationOperation$fFromJSONOriginationOperation$fEqInstrAbstract$fShowInstrAbstract$fFunctorInstrAbstract$fDataInstrAbstract$fGenericInstrAbstract$fShowExpandedOp$fEqExpandedOp$fDataExpandedOp$fGenericExpandedOp$fShowOp$fEqOp $fGenericOp $fRenderDocOp $fBuildableOp$fShowOriginationOperation$fGenericOriginationOperationExpandedExtInstrValueTypeConvergeErrorTParameterConvergeErrorTStorageConvergeError fromUTypemkUType extractNotestoUType$fBuildableTypeConvergeError$fShowTypeConvergeError$fEqTypeConvergeError buildStackCValueCvIntCvNatCvStringCvBytesCvMutezCvBool CvKeyHash CvTimestamp CvAddress $fOrdCValue $fEqCValue $fShowCValueVCVKeyVUnit VSignatureVOptionVListVSetVOp VContractVPairVOrVLamVMapVBigMap ContractOut ContractOut1 ContractInp ContractInp1CreateContract ccManager ccDelegate ccSpendable ccDelegatable ccBalance ccStorageValccContractCode CreateAccount caManager caDelegate caSpendable caBalance SetDelegate sdMbKeyHashTransferTokensttContractParameterttAmount ttContract Operation'OpTransferTokens OpSetDelegateOpCreateAccountOpCreateContract$fBuildableSetDelegate$fBuildableCreateAccount$fBuildableCreateContract$fBuildableTransferTokens$fEqOperation'$fBuildableOperation'$fShowSetDelegate$fEqSetDelegate$fShowCreateAccount$fEqCreateAccount$fShowTransferTokens$fEqTransferTokens$fEqCreateContract$fShowCreateContract$fShowOperation'EDivOp EDivOpRes EModOpRes evalEDivOpSliceOp evalSliceConcatOp evalConcat evalConcat'GetOpGetOpKeyGetOpValevalGetUpdOpUpdOpKey UpdOpParamsevalUpdSizeOpevalSizeIterOpIterOpEliterOpDetachOneMapOpMapOpInpMapOpRes mapOpToList mapOpFromListMemOpMemOpKeyevalMem$fMemOpTBigMap $fMemOpTMap $fMemOpTSet $fMapOpTList $fMapOpTMap $fIterOpTSet $fIterOpTList $fIterOpTMap $fSizeOpTMap $fSizeOpTList $fSizeOpTSet $fSizeOpTc $fSizeOpTc0 $fUpdOpTSet$fUpdOpTBigMap $fUpdOpTMap $fGetOpTMap$fGetOpTBigMap $fConcatOpTc $fConcatOpTc0 $fSliceOpTc $fSliceOpTc0$fEDivOpCMutezCNat$fEDivOpCMutezCMutez$fEDivOpCNatCNat$fEDivOpCNatCInt$fEDivOpCIntCNat$fEDivOpCIntCIntGeLeGtLtNeqEq'CompareLsrLslNotXorAndOrNegAbsMulSubAdd UnaryArithOp UnaryArithResevalUnaryArithOp ArithErrorMutezArithErrorShiftArithErrorArithErrorType AddOverflow MulOverflow SubUnderflow LslOverflow LsrUnderflowArithOpArithResevalOp$fBuildableArithErrorType$fBuildableArithError$fArithOpTYPEAddCMutezCMutez$fArithOpTYPEAddCIntCTimestamp$fArithOpTYPEAddCTimestampCInt$fArithOpTYPEAddCIntCInt$fArithOpTYPEAddCNatCNat$fArithOpTYPEAddCIntCNat$fArithOpTYPEAddCNatCInt$fArithOpTYPESubCMutezCMutez$$fArithOpTYPESubCTimestampCTimestamp$fArithOpTYPESubCTimestampCInt$fArithOpTYPESubCIntCInt$fArithOpTYPESubCNatCNat$fArithOpTYPESubCIntCNat$fArithOpTYPESubCNatCInt$fArithOpTYPEMulCMutezCNat$fArithOpTYPEMulCNatCMutez$fArithOpTYPEMulCIntCInt$fArithOpTYPEMulCNatCNat$fArithOpTYPEMulCIntCNat$fArithOpTYPEMulCNatCInt$fUnaryArithOpTYPEAbsCInt$fUnaryArithOpTYPENegCNat$fUnaryArithOpTYPENegCInt$fArithOpTYPEOrCBoolCBool$fArithOpTYPEOrCNatCNat$fArithOpTYPEAndCBoolCBool$fArithOpTYPEAndCNatCNat$fArithOpTYPEAndCIntCNat$fArithOpTYPEXorCBoolCBool$fArithOpTYPEXorCNatCNat$fUnaryArithOpTYPENotCBool$fUnaryArithOpTYPENotCNat$fUnaryArithOpTYPENotCInt$fArithOpTYPELslCNatCNat$fArithOpTYPELsrCNatCNat$$fArithOpTYPECompareCKeyHashCKeyHash $fArithOpTYPECompareCMutezCMutez($fArithOpTYPECompareCTimestampCTimestamp $fArithOpTYPECompareCBytesCBytes"$fArithOpTYPECompareCStringCString$fArithOpTYPECompareCIntCInt$fArithOpTYPECompareCNatCNat$$fArithOpTYPECompareCAddressCAddress$fArithOpTYPECompareCBoolCBool$fUnaryArithOpTYPEEq'CInt$fUnaryArithOpTYPENeqCInt$fUnaryArithOpTYPELtCInt$fUnaryArithOpTYPEGtCInt$fUnaryArithOpTYPELeCInt$fUnaryArithOpTYPEGeCInt$fShowArithErrorType$fEqArithErrorType$fOrdArithErrorType$fShowArithError$fEqArithError$fOrdArithErrorsomeNE permute2Def permute3Def mkGenericTreemkGenericTreeVec readFileUtf8 writeFileUtf8 withEncoding hSetTranslit$fBuildableNatural$fDefaultNaturalpostfixLFieldsTxDatatdSenderAddress tdParametertdAmount $fShowTxData $fEqTxData tdAmountL tdParameterLtdSenderAddressL NamedInner.!.?<.!><.?> $fShowNamedF$fWrappedNamedF$fWrappedNamedF0 $fEqNamedFRequireLongerThan LongerThan IsLongerThanAt KnownPeanopeanoValLengthToPeanoPeanoSZSS peanoVal'requiredLongerThan $fSingINatS $fSingINatZ $fKnownPeanoS $fKnownPeanoZ$fEqSingExtInstr TEST_ASSERTPRINTunPrintCommentSeqNopExtNestedCONCAT' mkStackRef$fIsStringPrintComment$fSemigroupPrintComment$fMonoidPrintComment$fShowExtInstr $fShowInstr Operation GIsoValue GValueTypeBigMapunBigMap ContractAddrunContractAddress IsComparableToTs'ToT'ToTsIsoValueToTtoValfromVal IsoCValueToCTtoCValfromCVal$fIsoCValueTimestamp$fIsoCValueKeyHash$fIsoCValueAddress$fIsoCValueMutez$fIsoCValueByteString$fIsoCValueBool$fIsoCValueText$fIsoCValueMText$fIsoCValueNatural$fIsoCValueInteger $fGIsoValueU1$fGIsoValue:*:$fGIsoValue:+: $fGIsoValueM1 $fGIsoValueK1$fIsoValueBigMap$fIsoValueContractAddr$fIsoValue(,,,,,,)$fIsoValue(,,,,,)$fIsoValue(,,,,)$fIsoValue(,,,)$fIsoValue(,,)$fIsoValueOperation' $fIsoValueMap $fIsoValueSet $fIsoValue(,)$fIsoValueEither$fIsoValueMaybe $fIsoValue[] $fIsoValue()$fIsoValueSignature$fIsoValuePublicKey$fIsoValueAddress$fIsoValueTimestamp$fIsoValueKeyHash$fIsoValueMutez$fIsoValueByteString$fIsoValueBool$fIsoValueText$fIsoValueMText$fIsoValueNatural$fIsoValueInteger $fEqBigMap $fShowBigMap$fDefaultBigMap$fSemigroupBigMap$fMonoidBigMap$fIsoValueNamedF$fIsoValueNamedF0$fIsoValueIdentityInstrConstructCConstructorFieldTypesFieldConstructorInstrSetFieldCInstrGetFieldC GetFieldType instrGetField instrSetFieldinstrConstruct$fGInstrGetname:*::f$fGInstrGetname:*::f0$fGInstrGetnameK1[]f'$fGInstrGetnameM1pathf$fGInstrSetFieldname:*::f$fGInstrSetFieldname:*::f0$fGInstrSetFieldnameK1[]f'$fGInstrSetFieldnameM1pathf$fGInstrConstructK1$fGInstrConstruct:+:$fGInstrConstructU1$fGInstrConstruct:*:$fGInstrConstructM1$fGenericMyType2$fIsoValueMyType2convertContract untypeValue instrToOps $fEqInstr $fEqExtInstrourIngredientsIsElem RecFromTuple IsoRecTuple recFromTuplederiveRecFromTuple$fRecFromTupleRec$fRecFromTupleRec0$fRecFromTupleRec1$fRecFromTupleRec2$fRecFromTupleRec3$fRecFromTupleRec4$fRecFromTupleRec5$fRecFromTupleRec6$fRecFromTupleRec7$fRecFromTupleRec8$fRecFromTupleRec9$fRecFromTupleRec10$fRecFromTupleRec11$fRecFromTupleRec12$fRecFromTupleRec13$fRecFromTupleRec14 InstrUnwrapC CaseClauses CaseClauseCaseClauseParam InstrCaseCMyCompoundType InstrWrapC CtorOnlyFieldCtorHasOnlyField GetCtorFieldAppendCtorFieldAxiomAppendCtorFieldExtractCtorField CtorFieldOneFieldNoFieldsappendCtorFieldAxiom instrWraphsWrap instrCase//->instrUnwrapUnsafehsUnwrap$fGInstrWrapM1:NoFields$fGInstrWrapM1:e$fGInstrWrapM1:OneField$fGInstrWrap:+::e$fGInstrWrap:+::e0$fGInstrWrapM1pathe$fGInstrCase:+:$fGInstrCaseM1$fGInstrCaseBranchctorU1$fGInstrCaseBranchctorK1$fGInstrCaseBranchctorM1$fGInstrCaseBranchctor:*:$fGInstrCaseM10$fGInstrUnwrapM1:e$fGInstrUnwrapM1:e0$fGInstrUnwrap:+::e$fGInstrUnwrap:+::e0$fGInstrUnwrapM1pathe$fGenericMyType$fIsoValueMyType$fGenericMyType'$fIsoValueMyType'$fGenericMyCompoundType$fIsoValueMyCompoundType$fGenericMyEnum$fIsoValueMyEnum TcExtFrames BoundVars SomeContract SomeCValue:--: SomeValue:::: SomeInstr:/ SomeInstrOut::: AnyOutInstrSomeHSTHSTSNil::&-:& noBoundVars$fEqHST $fShowHST $fEqSomeHST$fShowSomeInstrOut$fShowSomeInstr$fShowSomeContract $fShowSomeHSTExtErrorLengthMismatchVarError TypeMismatch TyVarMismatchStkRestMismatchTestAssertErrorInvalidStackReference StackSizeTCErrorTCFailedOnInstrTCFailedOnValueTCContractErrorTCUnreachableCode TCExtError TCTypeErrorAnnErrorExtractionTypeMismatch TypeEqError StackEqErrorUnsupportedTypes UnknownType$fBuildableTCTypeError$fBuildableExtError$fExceptionTCError $fShowTCError$fBuildableTCError$fShowTCTypeError$fEqTCTypeError$fShowStackSize $fEqStackSize $fEqExtError $fEqTCError TypeCheckEnv tcExtFramestcContractParam tcContractsTcOriginatedContracts TypeCheckTcInstrHandlerTypeCheckInstrTcResulttcContractParamL tcContractsL tcExtFramesL runTypeCheckrunTypeCheckTestderiveSpecialFNsderiveSpecialVNderiveVN deriveNsOrderiveNsOption convergeHSTEl convergeHSTonLefthstToTseqHSTeqHST1 lengthHSTensureDistinctAsccheckEqTeqType checkEqHSTonTypeCheckInstrErrtypeCheckInstrErronTypeCheckInstrAnnErronTypeCheckInstrTypeErr typeCheckImpl compareTypesmemImplgetImplupdImplsizeImpl sliceImpl concatImpl' concatImpl arithImpladdImpledivImplsubImplmulImpl compareImplunaryArithImpltypeCheckCValuetypeCheckValImpl typeCheckExttypeCheckContract typeCheckListtypeCheckValuetypeVerifyValue ContractState csBalance csStorage csContract$fBuildableContractState$fShowContractState$fGenericContractState$fEqContractState AddressStateASSimple ASContract$fFromJSONContractState$fToJSONContractState$fBuildableAddressState$fShowAddressState$fGenericAddressState$fEqAddressStateGState gsAddresses asBalance$fFromJSONAddressState$fToJSONAddressState $fShowGStateGStateUpdateErrorGStateAddressExistsGStateUnknownAddressGStateNotContract GStateUpdate GSAddAddressGSSetStorageValue GSSetBalancegenesisKeyHashesgenesisAddressesgenesisKeyHashgenesisAddressgenesisAddress1genesisAddress2genesisAddress3genesisAddress4genesisAddress5genesisAddress6 initGState readGState writeGState applyUpdate applyUpdatesextractAllContracts$fFromJSONGState$fToJSONGState$fExceptionGStateParseError$fBuildableGStateUpdate$fBuildableGStateUpdateError$fShowGStateParseError$fShowGStateUpdate$fEqGStateUpdate$fShowGStateUpdateError minTimestamp maxTimestamp midTimestamp$fArbitraryTimestamp$fArbitraryMutez$fArbitraryCValue$fArbitraryValue'$fArbitraryValue'0$fArbitraryValue'1$fArbitraryValue'2$fArbitraryCValue0$fArbitraryCValue1$fArbitraryCValue2printUntypedContractprintTypedContractMacroCASETAGVIEWVOIDCMPIFXIFCMPFAILPAPAIRUNPAIRCADRSET_CADRMAP_CADRDIIPDUUPASSERTASSERTX ASSERT_CMP ASSERT_NONE ASSERT_SOME ASSERT_LEFT ASSERT_RIGHTIF_SOMEIF_RIGHT ParsedValue ParsedInstrParsedUExtInstrParsedUTestAssertParsedOpPrimMacLMac CadrStructAD PairStructFPLetMacrolmNamelmSiglmExpr expandListexpandContract expandValueexpand expandMacro expandPapairexpandUnpapair expandCadr expandSetCadr expandMapCadr mapLeaves$fBuildablePairStruct$fBuildableCadrStruct$fBuildableMacro$fBuildableParsedOp$fRenderDocParsedOp$fBuildableLetMacro$fEqPairStruct$fShowPairStruct$fDataPairStruct$fGenericPairStruct$fEqCadrStruct$fShowCadrStruct$fDataCadrStruct$fGenericCadrStruct $fEqMacro $fShowMacro $fDataMacro$fGenericMacro $fEqParsedOp$fShowParsedOp$fDataParsedOp$fGenericParsedOp $fEqLetMacro$fShowLetMacro$fDataLetMacro$fGenericLetMacro$fFromJSONParsedOp$fToJSONParsedOp$fFromJSONLetMacro$fToJSONLetMacro$fFromJSONPairStruct$fToJSONPairStruct$fFromJSONCadrStruct$fToJSONCadrStruct$fFromJSONMacro $fToJSONMacroLetTypeltNameltSigLetValuelvNamelvSiglvVal $fEqLetValue$fShowLetValue $fEqLetType $fShowLetType$fFromJSONLetValue$fToJSONLetValue$fFromJSONLetType$fToJSONLetTypeLetEnv letMacros letValuesletTypesParsernoLetEnv$fDefaultReaderT $fShowLetEnv $fEqLetEnvlexememSpacesymbolsymbol'string'parensbracesbrackets brackets' semicoloncommavarID sepEndBy1sepBy2mkParserparseDefvalue' stringLiteral bytesLiteral intLiteralmkLetValnoteVnoteFnoteFDefnoteTDefnoteVDefnotesTVF notesTVF2notesTVnotesVF fieldTypetype_ explicitType comparableextInstr printComment stackType primInstrops'cmpOppairOpmapOpmacropairMac mapCadrMacifCmpMacletBlockletTypemkLetMac parseNoEnvprogramvalue codeEntry UnpackEnv ueContracts UnpackError unUnpackError unpackValue unpackValue'$fBuildableUnpackError$fShowUnpackError$fEqUnpackError packValue packValue'EvalOpInterpreterState isMorleyLogsisRemainingStepsRemainingSteps SomeItStackContractReturn MorleyLogs unMorleyLogsInterpretUntypedResultiurOps iurNewStorage iurNewStateInterpretUntypedErrorRuntimeFailureIllTypedContract IllTypedParamIllTypedStorageUnexpectedParamTypeUnexpectedStorageTypeMichelsonFailedMichelsonFailedWithMichelsonArithErrorMichelsonGasExhaustionMichelsonFailedTestAssert ContractEnvceNow ceMaxSteps ceBalance ceContractsceSelfceSourceceSenderceAmount noMorleyLogsinterpretUntyped interpretinterpretRepeatedrunInstr runInstrNoGas runUnpack$fBuildableMichelsonFailed$fEqMichelsonFailed $fBuildableInterpretUntypedError$fEqMorleyLogs$fShowMorleyLogs$fDefaultMorleyLogs$fBuildableMorleyLogs$fGenericInterpretUntypedError$fShowRemainingSteps$fEqRemainingSteps$fOrdRemainingSteps$fBuildableRemainingSteps$fNumRemainingSteps$fShowInterpreterState$fShowInterpretUntypedResult$fShowInterpretUntypedError$fShowMichelsonFailedContractPropValidator contractPropcontractPropValcontractRepeatedPropcontractRepeatedPropValdummyNow dummyMaxStepsdummyContractEnvdummyOriginationInterpreterRes _irGState _irOperations _irUpdates_irInterpretResults_irSourceAddress_irRemainingSteps InterpreterOp OriginateOp TransferOp$fShowInterpreterOp$fShowInterpreterResInterpreterErrorInterpreterError'IEUnknownContractIEInterpreterFailedIEAlreadyOriginatedIEUnknownSenderIEUnknownManagerIENotEnoughFundsIEFailedToApplyUpdatesIEIllTypedContractirInterpretResults irUpdates parseContractparseExpandContractreadAndParseContractprepareContractoriginateContract runContracttransferinterpreterPuretypeCheckWithDb$fSemigroupInterpreterRes$fExceptionInterpreterError'$fBuildableInterpreterError'$fShowInterpreterError'ValidationErrorUnexpectedInterpreterErrorUnexpectedTypeCheckErrorExpectingInterpreterToFailIncorrectUpdatesIncorrectStorageUpdateInvalidStorageInvalidBalance CustomErrorIntegrationalScenarioIntegrationalScenarioMSuccessValidatorIntegrationalValidatorintegrationalTestExpectationintegrationalTestProperty originatevalidatesetNow setMaxSteps withSenderexpectAnySuccessexpectStorageUpdateexpectStorageUpdateConstexpectStorageConst expectBalancecomposeValidatorscomposeValidatorsListexpectGasExhaustionexpectMichelsonFailed$fBuildableAddressName$fExceptionValidationError$fBuildableValidationError$fShowExpectedStorage$fShowExpectedBalance$fShowAddressName$fShowValidationErrorListUnaryArithOpHsUnaryArithResHs ArithOpHs ArithResHs $fArithOpHsCompareKeyHashKeyHash$fArithOpHsCompareMutezMutez$$fArithOpHsCompareTimestampTimestamp&$fArithOpHsCompareByteStringByteString$fArithOpHsCompareMTextMText $fArithOpHsCompareIntegerInteger $fArithOpHsCompareNaturalNatural $fArithOpHsCompareAddressAddress$fArithOpHsCompareBoolBool$fArithOpHsLsrNaturalNatural$fArithOpHsLslNaturalNatural$fArithOpHsXorBoolBool$fArithOpHsXorNaturalNatural$fArithOpHsAndBoolBool$fArithOpHsAndNaturalNatural$fArithOpHsAndIntegerNatural$fArithOpHsOrBoolBool$fArithOpHsOrNaturalNatural$fArithOpHsMulMutezNatural$fArithOpHsMulNaturalMutez$fArithOpHsMulIntegerInteger$fArithOpHsMulNaturalNatural$fArithOpHsMulIntegerNatural$fArithOpHsMulNaturalInteger$fArithOpHsSubMutezMutez $fArithOpHsSubTimestampTimestamp$fArithOpHsSubTimestampInteger$fArithOpHsSubIntegerInteger$fArithOpHsSubNaturalNatural$fArithOpHsSubIntegerNatural$fArithOpHsSubNaturalInteger$fArithOpHsAddMutezMutez$fArithOpHsAddIntegerTimestamp$fArithOpHsAddTimestampInteger$fArithOpHsAddIntegerInteger$fArithOpHsAddNaturalNatural$fArithOpHsAddIntegerNatural$fArithOpHsAddNaturalInteger$fUnaryArithOpHsGeInteger$fUnaryArithOpHsLeInteger$fUnaryArithOpHsGtInteger$fUnaryArithOpHsLtInteger$fUnaryArithOpHsNeqInteger$fUnaryArithOpHsEq'Integer$fUnaryArithOpHsNotBool$fUnaryArithOpHsNotNatural$fUnaryArithOpHsNotInteger$fUnaryArithOpHsNegNatural$fUnaryArithOpHsNegInteger$fUnaryArithOpHsAbsIntegerEDivOpHs EDivOpResHs EModOpResHs SliceOpHs ConcatOpHsGetOpHs GetOpKeyHs GetOpValHsUpdOpHs UpdOpKeyHs UpdOpParamsHsSizeOpHsIterOpHs IterOpElHsMapOpHs MapOpInpHs MapOpResHs IsoMapOpResMemOpHs MemOpKeyHs$fMemOpHsBigMap $fMemOpHsMap $fMemOpHsSet $fMapOpHs[] $fMapOpHsMap $fIterOpHsSet $fIterOpHs[] $fIterOpHsMap $fSizeOpHsMap $fSizeOpHs[] $fSizeOpHsSet$fSizeOpHsByteString$fSizeOpHsMText $fUpdOpHsSet$fUpdOpHsBigMap $fUpdOpHsMap$fGetOpHsBigMap $fGetOpHsMap$fConcatOpHsByteString$fConcatOpHsMText$fSliceOpHsByteString$fSliceOpHsMText$fEDivOpHsMutezNatural$fEDivOpHsMutezMutez$fEDivOpHsNaturalNatural$fEDivOpHsNaturalInteger$fEDivOpHsIntegerNatural$fEDivOpHsIntegerInteger CanHaveBigMapNoBigMap NoOperation KnownCValue KnownValueLambda&%>:->IunIcompileLorentzcompileLorentzContractprintLorentzContract# $fIsoValue:-> $fShow:->$fEq:->LorentzFunctorlmapnopdropdupswappushsomenoneunitifNonepaircarcdrleftrightifLeftnilconsifConssizeemptySetemptyMapmapitermemgetupdateif_looploopLeftlambdaexecdipfailWithcastpackunpackconcatconcat'sliceaddsubrsubmuledivabsneglsllsrorandxornotcompareeq0neq0lt0gt0le0ge0intselfcontracttransferTokens setDelegate createAccountcreateContractimplicitAccountnowamountbalanceblake2B stepsToQuotasourcesenderaddressfailingWhenPresent updateNewfailText failTagged failUsingfailUnexpected$fLorentzFunctorMaybedupTdipTdropT$fDupTorigSta:$fDupTorigSta:0$fDupTorigSta[]$fDipTorigSta:dipInpdipOutout1$fDipTorigSta:dipInpdipOutout$fDipTorigSta[]dipInpdipOutoutExportedContractDeclecdNameecdVarExportedContractInfo eciModuleNameeciContractDecl IsContracttoUntypedContractisHaskellModulehaskellExportsParser$fIsContract:->$fIsContractInstr$fIsContractContract'$fShowExportedContractDecl$fEqExportedContractDecl$fShowExportedContractInfo$fEqExportedContractInfo Coercible_coerce_ coerceWrap coerceUnwraptoNamed fromNamed VoidResult unVoidResultVoid_ voidParam voidResProxyView viewParamviewCallbackTo mapInsert mapInsertNew deleteMapIfCmpXConstraintseqneqgtlegeltifEq0ifNeq0ifLt0ifGt0ifLe0ifGe0ifEqifNeqifLtifGtifLeifGefail_assert assertEq0 assertNeq0 assertLt0 assertGt0 assertLe0 assertGe0assertEq assertNeqassertLtassertGtassertLeassertGe assertNone assertSome assertLeft assertRight assertUsingdipXdropXcloneXduupXelevateXpapairppaiirunpaircdarcddrcaarcadrsetCarsetCdrmapCarmapCdrifRightifSome setInsert setInsertNew setDeleteview_mkVoidvoid_ $fDipXS:ss' $fDipXZ[]ss' $fCloneXSas $fCloneXZas $fDuupXS:a $fDuupXS:a0$fMapInstrsBigMap$fMapInstrsMap $fGenericView$fIsoValueView$fGenericVoid_$fIsoValueVoid_$fEqVoidResult$fIsoValueVoidResult ConditionHoldsIsSomeIsNoneIsLeftIsRightIsConsIsNilIsZero IsNotZeroIsEqIsNeqIsLtIsGtIsLeIsGe>> ifThenElsestackRef testAssertHasFieldsOfType:= NamedFieldHasFieldOfTypeHasFieldtoField toFieldNamedgetField getFieldNamedsetField modifyField construct constructT fieldCtorwrap_/->case_caseT StorePieceCStorageSkeletonsMapsFieldsHasStoreForAllInHasStore StoreDeleteC StoreInsertC StoreGetC StoreMemC GetStoreValue GetStoreKey|->StoreunStorestoreMemstoreGet storeInsertstoreInsertNew storeDelete storageUnpack storagePack storageMem storageGet storageInsertstorageInsertNew storageDelete storePiece storeLookup $fEqStore $fShowStore$fDefaultStore$fSemigroupStore $fMonoidStore$fIsoValueStore $fGeneric|-> $fIsoValue|->$fGenericMyStoreTemplate$fIsoValueMyStoreTemplate$fGenericMyStoreTemplate2$fIsoValueMyStoreTemplate2$fGenericMyNatural$fIsoCValueMyNatural$fIsoValueMyNatural$fGenericMyStoreTemplate3$fIsoValueMyStoreTemplate3$fGenericMyStoreTemplateBig$fIsoValueMyStoreTemplateBig$fEqStorageSkeleton$fShowStorageSkeleton$fGenericStorageSkeleton$fDefaultStorageSkeleton$fIsoValueStorageSkeleton UserFailInstrLorentzUserErrorIsErrorunLorentzUserError userFailWith$fShowErrorTag $fEqErrorTag $fOrdErrorTag$fIsStringErrorTag$fIsoValueErrorTagImportContractErrorICEUnexpectedParamTypeICEUnexpectedStorageTypeICEParse ICETypeCheckspecWithContractspecWithContractLspecWithTypedContractspecWithUntypedContract readContractimportContractimportUntypedContract$fExceptionImportContractError$fBuildableImportContractError$fShowImportContractError$fEqImportContractErrorrunGen$fArbitraryComparable$fToADTArbitraryComparable $fArbitraryCT$fToADTArbitraryCT $fArbitraryT$fToADTArbitraryT$fArbitraryType$fToADTArbitraryType$fArbitraryElt$fToADTArbitraryElt$fToADTArbitraryValue'$fArbitraryInstrAbstract$fToADTArbitraryInstrAbstract$fArbitraryContract'$fToADTArbitraryContract'$fArbitraryAnnotation$fToADTArbitraryAnnotation$fArbitraryAnnotation0$fToADTArbitraryAnnotation0$fArbitraryAnnotation1$fToADTArbitraryAnnotation1$fToADTArbitraryMutez$fArbitraryExpandedOp$fToADTArbitraryExpandedOp$fArbitraryInstrCallStack$fToADTArbitraryInstrCallStack$fArbitraryLetName$fToADTArbitraryLetName$fArbitrarySrcPos$fToADTArbitrarySrcPos$fArbitraryPos$fToADTArbitraryPos$fArbitraryExtInstrAbstract$fArbitraryStackTypePattern$fArbitraryTyVar$fArbitraryVar$fArbitraryInternalByteString lOriginatelOriginateEmpty lTransferlCalllExpectStorageUpdatelExpectBalancelExpectStorageConstlExpectMichelsonFailedlExpectFailWithlExpectUserErrorlExpectConsumerStoragelExpectViewConsumerStorage==Data.Typeable.InternalTypeable-wl-pprint-text-1.2.0.0-L6i9Q0yxJZoBCBd4YxCMOZText.PrettyPrint.Leijen.TextDocData.Text.Internal.BuilderBuilder(QuickCheck-2.13.1-1rO57X9FmbTEL9U6cBekOsTest.QuickCheck.Property GHC.TypeLits ErrorMessageinvalidMCharError SomeSingTSomeSing SomeSingCTtoSingCTtoSingfromSingtoSingT D:R:SingT0 D:R:SingCT0FailOnBigMapFoundFailOnOperationFound BadBigMapPairEachContainsBigMap ContainsOp converge'version getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameWordParseAddressErrorParseAddressWrongBase58CheckParseAddressBothFailedNonEmptyOfLengthWithTailData.Vinyl.TypeLevelNatGInstrConstructGInstrSetField GInstrGetLNRequireFound GLookupNamedGetNamedNamedFLookupNamedResult*tasty-ant-xml-1.1.6-Kt01akJtXLgFzgoJ6SRtOPTest.Tasty.Runners.AntXML antXMLRunnerGInstrCaseBranch GInstrCase GInstrWrapfailWithWrongCtortypeCheckMapVal checkVarscheckFncheckStackTypecreateStackRef typeCheckNEtypeCheckInstr genericIfgenesisAddressesNumgenesisSecrets addAddresssetStorageValue setBalanceLetletInneraddLetletName?getByteStringCopy expectTag unknownTag expectDescTag manyForcedmany unpackDecoder decodeLength decodeAsList decodeInt decodeAnndecodeTypeCheckLam encodeAsList encodeList encodeString encodeBytes encodeMapencodeIntPayload encodeNumeric encodeInstrs encodeInstr runInstrImpl runArithOp withStackElemGHC.IO.Handle.FDstdin interpreterIOinterpretOneOp _isOperations_isContractsNames _isSender Validated Data.EitherLeft.hspec-expectations-0.8.2-xEhsaJyqHC4OUn6v2CIJJTest.Hspec.ExpectationserrorDipTDupT MapInstrs mapUpdate CaseClauseLCtorNameToLabelGetStore MapSignatureCtorsNumCtorIdxErrorTagGHC.IO.Exception IOException genRareTypegenRareT tOriginate tTransfer