!s~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_` abcdefghijklmnopqrstuvwxyz{|}~                                                                                                               !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~            !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~0None+"#%&',-.014567=>?@AHMNPSUVX_`befgkDomorleySuppose 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 ! as long as both parameters are .morley Version of  for types with 2 parameters.morley Version of  for types with 3 parameters.None+"#%&',-.014567=>?@AHMNPSUVX_`befgkTmorleyGeneralize converting a type into a Text.PrettyPrint.Leijen.Text.Doc. Used to pretty print Michelson code and define Fmt.Buildable instances. morleyWhether 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  into a ". It's formatted the same way as   formats docs.    None-"#%&',-.0124567;=>?@AHMNPSUVX_`befgkV None-"#%&',-.0124567;=>?@AHMNPSUVX_`befgk\smorleyByteString 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. !"#$%&'()*+,-./0None+"#%&',-.014567=>?@AHMNPSUVX_`befgk^V1212None+"#%&',-.014567=>?@AHMNPSUVX_`befgk`33None+"#%&',-.014567=>?@AHMNPSUVX_`befgkd4morleyA ' that always failes with given message.5morleyA  that always succeeds.6morleyThe  holds on `Left a`.7morleyThe  holds on `Right b`.45674567None-"#%&',-.0124567;=>?@AHMNPSUVX_`befgkw8morley\Time in the real world. Use the functions below to convert it to/from Unix time in seconds.;morleyDMutez is a wrapper over integer data type. 1 mutez is 1 token (Tz).=morleySafely create ; checking for overflow.>morleyPartial function for ;P creation, it's pre-condition is that the argument must not exceed the maximal ; value.?morley Addition of ; values. Returns  in case of overflow.@morleyPartial addition of ;>, should be used only if you're sure there'll be no overflow.AmorleySubtraction of ; values. Returns 7 when the subtrahend is greater than the minuend, and  otherwise.BmorleyPartial subtraction of ;?, should be used only if you're sure there'll be no underflow.CmorleyMultiplication of ;" and an integral number. Returns  in case of overflow.DmorleyEuclidian division of two ; values.EmorleyEuclidian division of ; and a number.Imorley!Add given amount of seconds to a 8.JmorleyDisplay timestamp in human-readable way as used by Michelson. Uses UTC timezone, though maybe we should take it as an argument.Kmorley Parse textual representation of 8.LmorleyReturn current time as 8.89:;<=>?@ABCDEFGHIJKL;<=>?@ABCDE89:FGHIJKL None+"#%&',-.014567=>?@AHMNPSUVX_`befgkibmorleyFError that can happen during parsing of cryptographic primitive types.fmorleyb58check of a public key.imorley ED25519 cryptographic signature.jmorley!ED25519 secret cryptographic key.kmorley!ED25519 public cryptographic key.lmorley&Create a public key from a secret key.umorley$Sign a message using the secret key.vmorley@Check that a sequence of bytes has been signed with a given key.wmorley*Compute the b58check of a public key hash.xmorleyCompute a cryptographic hash of a bytestring using the Blake2b_256 cryptographic hash function. It's used by the BLAKE2B instruction in Michelson.ymorley`Compute a cryptographic hash of a bytestring using the Blake2b_160 cryptographic hash function.zmorley[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. _`abcdefghijklmnopqrstuvwxyz{|}~ kjifghlbcdemnopqrstuvwxyz{|}_`a~ None+"#%&',-.014567=>?@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  O. 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 !. 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."None-"#%&',-.0124567;=>?@AHMNPSUVX_`befgkmorley[Type function that converts a regular Haskell type into a comparable type (which has kind CT)?#None-"#%&',-.0124567;=>?@AHMNPSUVX_`befgk9$None-"#%&',-.0124567;=>?@AHMNPSUVX_`befgk 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.Rmorley9ExtU is extension of InstrAbstract by Morley instructions]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).g97:;KJ      !"#$%&'()*+,-./01234568<=>?@ABCDEFGHILMNOPQRSTUVWXYZ[\]%None+"#%&',-.014567=>?@AHMNPSUVX_`befgk^_None+"#%&',-.014567=>?@AHMNPSUVX_`befgkk !"#$%&'()*+,-./097:;KJ      !"#$%&'()*+,-./01234568<=>?@ABCDEFGHILMNOPQRSTUVWXYZ[\]^_ !"#$%&'()*+,-./097:;KJ      !"#$%&'()*+,-./01234568<=>?@ABCDEFGHILMNOPQXYZ[STUVR\W]^_ None+"#%&',-.014567=>?@AHMNPSUVX_`befgk[`morleypConvert an untyped contract into a textual representation which will be accepted by the OCaml reference client. ` `&None+"#%&',-.014567=>?@AHMNPSUVX_`befgkamorley:Type function that converts a regular Haskell type into a T' type. TODO: what should be done with p?bmorley6Michelson language type with annotations stripped off.abcdefjghiklmnop'None+"#%&',-.014567=>?@AHMNPSUVX_`befgkަ morley Version of SomeSing with ' constraint, specialized for use with b kind.morley Version of SomeSing 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 toSing 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 b! to its singleton representation.morley Version of fromSing specialized for use with data instance Sing :: T -> Type which requires ) constraint for some of its constructorsmorley Version of toSing which creates .morleyInstance of data family  for b5. Custom instance is implemented in order to inject & constraint for some of constructors.morleyInstance of data family  for .qrstuvwxyz{|}~(None+"#%&',-.014567=>?@AHMNPSUVX_`befgkPmorley>Data type, holding annotation data for a given Michelson type t.;Each constructor corresponds to exactly one constructor of bf 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).)None+"#%&',-.014567=>?@AHMNPSUVX_`befgklmorley Extracts b type from *.morley Extracts Notes t type from +* and corresponding singleton.morleyConverts from b to +*.,None+"#%&',-.014567=>?@AHMNPSUVX_`befgkmorley Converts a CVal# value into a single Haskell value.morley%Converts a single Haskell value into CVal representation.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. None+"#%&',-.014567=>?@AHMNPSUVX_`befgk morley Converts a Val! value into complex Haskell type.morley*Converts a complex Haskell structure into Val representation.morley"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.;;-None+"#%&',-.014567=>?@AHMNPSUVX_`befgkM !"#$%&'()*+,-./01234567.None+"#%&',-.014567=>?@AHMNPSUVX_`befgk\Jmorley#Marker data type for add operation.Mmorley0Represents an arithmetic error of the operation.Omorley;Denotes the error type occured in the arithmetic operation.Smorley&Class for binary arithmetic operation.!Takes binary operation marker as op# parameter, types of left operand n and right operand m.Tmorley 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.Umorley0Evaluate arithmetic operation on given operands.89:;<=>?@ABCDEFGHIJKLMNOPQRSTU/None+"#%&',-.014567=>?@AHMNPSUVX_`befgk1WmorleyERepresentation 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 W DROP W DUPO. Special case where there are no instructions is represented by constructor Nop, e.g. IF_NONE {} { SWAP; DROP; } -> IF_NONE Nop (SWAP W 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.YmorleyeNop 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.morley1ExtT is extension of Instr by Morley instructionsmorleyInfix version of Seq constructor.@One can represent sequence of Michelson opertaions as follows: SWAP; DROP; DUP; -> SWAP  DROP  DUP.ZVWX[Z\]^_`abcdefghijklmnopqrstuvwxyz{|}~Y00None+"#%&',-.014567=>?@AHMNPSUVX_`befgk:$morley Function unsafeValToValue converts typed Val to untyped Value from Michelson.Untyped.Value moduleVOp cannot be represented in ValueH from untyped types, so calling this function on it will cause an errormorleyConvert a typed  to an untyped ValueE, or fail if it contains operations which are unrepresentable there.None+"#%&',-.014567=>?@AHMNPSUVX_`befgk;1qrstuvwxyz{|}~abcdefjghiklmnop !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWX[Z\]^_`abcdefghijklmnopqrstuvwxyz{|}~Ybcdefjghiklmnopaqrstuvwxyz{|}~56701234-./+,#$%&'()* !"WX[Z\]^_`abcdefghijklmnopqrstuvwxyz{|}~YVSTUJKLMNOPQRIHGFEDCBA@?>=<;:98None-"#%&',-.0124567;=>?@AHMNPSUVX_`befgkbCmorley!A programmer-defined type-synonymmorleyA programmer-defined constantmorleyA programmer-defined macromorley8A stack function that expresses the type signature of a LetMacromorleyA stack pattern-matchmorley"A type-variable or a type-constantmorleyA reference into the stackmorley6Built-in Michelson Macros defined by the specificationmorleyMorley interpreter statemorley1Unexpanded instructions produced directly by the ops[ parser, which contains primitive Michelson Instructions, inline-able macros and sequencesmorleyPrimitive Michelson instructionmorley5Built-in Michelson macro defined by the specificationmorley2User-defined macro with instructions to be inlinedmorleyA sequence of instructionsmorley3Implementation-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). morley,Matches current stack against a type-pattern morley%Begin a typed stack function (push a  TcExtFrame) morleyEnd a stack function (pop a  TcExtFrame) morley8Copy the current stack and run an inline assertion on it morley'Print a comment with optional embedded StackRefsmorley2The environment containing lets from the let-blockmorleyConvert # 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.morley+Get the set of variables in a stack pattern !"#$%&'()*+,-./097:;KJ      !"#$%&'()*+,-./01234568<=>?@ABCDEFGHILMNOPQSTUVXYZ[      !"#$%&'()*+,-./97:;KJ      !"#$%&'()*+,-./01234568<=>?@ABCDEFGHILMNOPQ[XYZ0     VSTU None+"#%&',-.014567=>?@AHMNPSUVX_`befgklmorley.Data associated with a particular transaction.None+"#%&',-.014567=>?@AHMNPSUVX_`befgk8morleyState 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 .morley*Initially this address has a lot of money.morleyKeyHash of genesis address.morley*Initially this address has a lot of money.morleyInitial !. It's supposed to be used if no V is provided. For now it's empty, but we can hardcode some dummy data in the future.morleyRead  from a file.morleyWrite  to a file.morleyApply  to .morleyApply 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.None+"#%&',-.014567=>?@AHMNPSUVX_`befgk\morley%Expand all macros in parsed contract.  None+"#%&',-.014567=>?@AHMNPSUVX_`befgk:  None+"#%&',-.014567=>?@AHMNPSUVX_`befgk 1212None+"#%&',-.014567=>?@AHMNPSUVX_`befgk morleyElement of a let blockmorley'Michelson contract with let definitionsmorleyParse with empty environmentmorleyMichelson contractmorleylet block parsermorley'Incrementally build the let environmentmorley1add a Let to the environment in the correct placemorley7build a let name parser from a leading character parsermorleymake a parser from a string  None+"#%&',-.014567=>?@AHMNPSUVX_`befgkmorley&Minimal (earliest) timestamp used for Arbitrary (CVal 'CTimestamp)morley$Maximal (latest) timestamp used for Arbitrary (CVal 'CTimestamp)morley Median of  and \. Useful for testing (exactly half of generated dates will be before and after this date).1None+"#%&',-.014567=>?@AHMNPSUVX_`befgk  morleyThe typechecking statemorleyFunction for typeChecking a nop\ and updating state TypeCheckT is used because inside inside of TEST_ASSERT could be PRINT STACKTYPEetc extended instructions.morleyPConstraints on InstrExtT and untyped Instr which are required for type checkingmorleyState for type checking nopmorleyType check errormorleyQData type, holding strictly-typed Michelson value along with its type singleton.morleyQData type, holding strictly-typed Michelson value along with its type singleton.morley_Data type holding both instruction and type representations of instruction's input and output.>Intput and output stack types are wrapped inside the type and Typeable: constraints are provided to allow convenient unwrapping."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.     !"#$%&'&72None+"#%&',-.014567=>?@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 typesmorleyCheck whether elements go in strictly ascending order and return the original list (to keep only one pass on the original list).(morley Function eqT' is a simple wrapper around Data.Typeable.eqT suited for use within  Either Text a applicative.morley%Generic implementation for MEMerationmorleyIHelper function to construct instructions for binary arithmetic erations.morleyIHelper function to construct instructions for binary arithmetic erations.(3None+"#%&',-.014567=>?@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.)4None+"#%&',-.014567=>?@AHMNPSUVX_`befgkymorleyLike  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  typeCheckValA converts a single Michelson value given in representation from Michelson.Type2 module to representation in strictly typed GADT.As a second argument,  typeCheckVal 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 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.*+,None+"#%&',-.014567=>?@AHMNPSUVX_`befgk#     !"#$%&'()*+,#*,+)$%&"# !    '(None,"#%&',-.014567;=>?@AHMNPSUVX_`befgkGmorleyfRepresents `[FAILED]` state of a Michelson program. Contains value that was on top of the stack when | was called.Lmorley#Environment for contract execution.NmorleyATimestamp of the block whose validation triggered this execution.OmorleyANumber of steps after which execution unconditionally terminates.Pmorley0Current amount of mutez of the current contract.QmorleyOMapping from existing contracts' addresses to their executable representation.Rmorley$Address of the interpreted contract.Smorley4The contract that initiated the current transaction.Tmorley=The contract that initiated the current internal transaction.Umorley"Amount of the current transaction.Vmorley9Interpret a contract without performing any side effects.XmorleyBFunction to change amount of remaining steps stored in State monadmorleyCFunction to interpret Michelson instruction(s) against given stack.morley?Evaluates an arithmetic operation and either fails or proceeds.--./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY-LMNOPQRSTU4567./01GHIJK2389-W:V@ABCDEF;<=>?XYNone+"#%&',-.014567=>?@AHMNPSUVX_`befgkYfmorley0Dummy timestamp, can be used to specify current F value or maybe something else.gmorleyDummy 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.hmorleyDummy Ls with some reasonable hardcoded values. You can override values you are interested in using record update syntax.imorley with most data hardcoded to some reasonable values. Contract and initial values must be passed explicitly, because otherwise it hardly makes sense.fghifghiNone+"#%&',-.014567=>?@AHMNPSUVX_`befgkmorley-Various type errors possible when checking a NopInstr with the  nopHandlermorleyPrint error messagesmorleyDCheck that the optional "forall" variables are consistent if presentmorleyChecks the pattern in FN and pushes a ExtFrame onto the statemorleyPops a ExtFrame off the state and checks an FN_END based on itmorley Check that a StackTypePattern& matches the type of the current stackjklmnjklmnNone+"#%&',-.014567=>?@AHMNPSUVX_`befgk&omorley'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 56 or 78 or anything else relevant.pmorleyContract's property tester against given input. Takes contract environment, initial storage and parameter, interprets contract on this input and invokes validation function.qmorley Version of p which takes 1 as arguments instead of regular Haskell values.:opq:opqNone+"#%&',-.014567=>?@AHMNPSUVX_`befgkJrmorley,Result of a single execution of interpreter.tmorleyNew .umorley7List of operations to be added to the operations queue.vmorleyUpdates applied to .wmorleyDuring 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.xmorleyPAs soon as transfer operation is encountered, this address is set to its input.ymorley2Now much gas all remaining executions can consume.zmorleyMOperations 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  , because 0 is supposed to be provided by the user, while  can be computed by our code.{morleyOriginate a contract.|morleybSend a transaction to given address which is assumed to be the address of an originated contract.morley4Errors that can happen during contract interpreting.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.morley"Failed to apply updates to GState.morleyA contract is ill-typed.morleyParse a contract from .morleyParse a contract from  and expand macros.morley,Read and parse a contract from give path or  (if the argument is  ). The contract is not expanded.morleyRead a contract using 8, expand and flatten. The contract is not type checked.morleyFOriginate a contract. Returns the address of the originated contract.morley}Run a contract. The contract is originated first (if it's not already) and then we pretend that we send a transaction to it.morley:Send a transaction to given address with given parameters.morleyeInterpret a contract on some global state (read from file) and transaction data (passed explicitly).morley&Implementation of interpreter outside R. It reads operations, interprets them one by one and updates state accordingly.morley.Run only one interpreter operation and update  accordingly.)rstuvwxyz{|)z{|rstuvwxyNone+"#%&',-.014567=>?@AHMNPSUVX_`befgkpumorley"Operations to be interpreted when  TOValidate is encountered.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.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].None+"#%&',-.014567=>?@AHMNPSUVX_`befgk{morleyError type for  function.morley{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).morley A version of = 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 contract.This function may throw   and .  9None+"#%&',-.014567=>?@AHMNPSUVX_`befgk}(4567:hopq(:opq4567h :;<:;=>?@>ABCDECDFCDGHIJKLMNOPQRSTTUVWXYZ[\\]]^_`abcdefghijklmnopqrstuvvwxyz{|}~                """""""""""""""""""""""""""""*"*"" " " " " """"""""""""""""""" "!"""#"$"%"&"'"(#)#)#*#+#,#-#.$/$/$0$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?$@$A$B$C$D$E$F$G$H$I$J$K$L$M$N$O$P$Q$R$S$T$U$V$W$X$Y$Z$[$\$]$^$_$`$a$b$c$d$e$f$g$h$i$j$k$l$m$n$o$p$q$r$s$t$u$v$w$x$y$z${$|$}$~$$$$$$$$$$$$$$$$$$$$!$$%% &&&&&&&&&&&&&&&&'''''''''''''''''''''''''''(((((((((((((((((((((((()))),,,,,,,,,,,,,,                                                                          ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;-<-=->-?-@-A-B-C-D-E-F-G-H-I-J-K-L-M-N-O-P-Q-R-S-T-U-V-W-X-Y.Z.[.\.].^._.`.a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w/)/!/x/y/z/{/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/{/|/}/~///////////}/~/0000000x      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ [ [ \ ] ^ _``abcdefghijklmnopqqrstuvwxyz{|}~11111111111111111111111111111123444      !"#$%&'())*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNDOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqmrstuvwxywz{|}6m~m~   ''''''(jjj22222222222222222222222222223444mjm8m#morley-0.2.0-DKAk4nHfsQHKu9FVdoO5vJMorley.Default Morley.TypesMichelson.TypedMichelson.Printer.UtilMichelson.UntypedMorley.Parser.HelpersMorley.Test.Util Tezos.Core Tezos.Crypto Tezos.AddressMichelson.PrinterMichelson.Typed.ValueMorley.Runtime.TxDataMorley.Runtime.GState Morley.Macro Morley.LexerMorley.Parser.Annotations Morley.ParserMorley.Test.GenMichelson.TypeCheckMichelson.InterpretMorley.Test.Dummy Morley.ExtMorley.Test.UnitMorley.RuntimeMorley.Test.IntegrationalMorley.Test.ImportMichelson.EqParamMichelson.Untyped.AnnotationMichelson.Untyped.Value Michelson*InstrMichelson.Untyped.TypeMichelson.Untyped.ContractMichelson.Untyped.InstrMichelson.Untyped.AliasesMichelson.Typed.TMichelson.Typed.SingMichelson.Typed.AnnotationMichelson.Typed.ExtractTypeMichelson.TypeMichelson.Typed.CValueMichelson.Typed.PolymorphicMichelson.Typed.ArithMichelson.Typed.InstrMichelson.Typed.ConvertMichelson.TypeCheck.TypesMichelson.TypeCheck.HelpersMichelson.TypeCheck.ValueMichelson.TypeCheck.InstrTest.QuickCheckProperty Test.Hspec Expectation Morley.Test1data-default-class-0.1.2.0-FeIQ5tLoVZBHMSgrT9zptQData.Default.ClassDefaultdef'megaparsec-7.0.4-9ALYGrjYOOC9k3jnVKNZ4mText.MegaparsecParsecText.Megaparsec.ErrorParseErrorBundle'singletons-2.5.1-8rh3O7OlCjT56nom3eHup2Data.Singletons.Internal applySingSLambdaSing RenderDoc renderDoc isRenderableprintDoc renderOps renderOpsListspaces wrapInParensbuildRenderDocVarAnnFieldAnnTypeAnn AnnotationWithAnnnoAnnannunifyAnn ifAnnUnified disjoinVnconvAnnInternalByteStringEltValueValueInt ValueString ValueBytes ValueUnit ValueTrue ValueFalse ValuePair ValueLeft ValueRight ValueSome ValueNoneValueNilValueSeqValueMap ValueLambdaunInternalByteString permute2Def permute3Def sepEndBy1 failedProp succeededPropqcIsLeft qcIsRight Timestamp unTimestampMutezunMutezmkMutez unsafeMkMutezaddMutezunsafeAddMutezsubMutezunsafeSubMutezmulMutez divModMutezdivModMutezInttimestampToSecondstimestampFromSecondstimestampFromUTCTimetimestampPlusSecondsformatTimestampparseTimestampgetCurrentTime$fBoundedMutez$fBuildableTimestamp $fShowMutez $fEqMutez $fOrdMutez $fDataMutez$fGenericMutez $fEnumMutez$fBuildableMutez$fShowTimestamp $fEqTimestamp$fOrdTimestamp$fDataTimestamp$fGenericTimestamp$fFromJSONMutez $fToJSONMutez$fFromJSONTimestamp$fToJSONTimestampB58CheckWithPrefixErrorB58CheckWithPrefixWrongPrefixB58CheckWithPrefixWrongEncodingCryptoParseErrorCryptoParseWrongBase58CheckCryptoParseWrongTagCryptoParseCryptoErrorKeyHash unKeyHash Signature SecretKey PublicKeytoPublicformatPublicKeyparsePublicKeyformatSecretKeyparseSecretKeyformatSignatureparseSignature formatKeyHash 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 formatAddress parseAddressunsafeParseAddress$fArbitraryAddress$fFromJSONKeyAddress$fFromJSONAddress$fToJSONKeyAddress$fToJSONAddress$fBuildableAddress$$fBuildableParseContractAddressError$fBuildableParseAddressError $fShowAddress $fEqAddress $fOrdAddress$fShowParseContractAddressError$fEqParseContractAddressError$fShowParseAddressError$fEqParseAddressErrorToCTCTCIntCNatCStringCBytesCMutezCBoolCKeyHash CTimestampCAddressTTcTKeyTUnit TSignatureTOptionTListTSet TOperation TContractTPairTOrTLambdaTMapTBigMap ComparableTaddress Ttimestamp Tkey_hashTboolTmutezTbytesTstringTnatTint compToType typeToComptinttnattstringtbytestmuteztbooltkeyHash ttimestamptaddress isAtomicTypeisKey isSignature isComparableisMutez isTimestamp isKeyHashisBoolisString isIntegerisNatisIntisBytesContractparastorcodeStorage ParameterOriginationOperation ooManager ooDelegate ooSpendable ooDelegatable ooBalance ooStorage ooContract InstrAbstractEXTDROPDUPSWAPPUSHSOMENONEUNITIF_NONEPAIRCARCDRLEFTRIGHTIF_LEFTIF_RIGHTNILCONSIF_CONSSIZE EMPTY_SET EMPTY_MAPMAPITERMEMGETUPDATEIFLOOP LOOP_LEFTLAMBDAEXECDIPFAILWITHCASTRENAMEPACKUNPACKCONCATSLICEISNATADDSUBMULEDIVABSNEGLSLLSRORANDXORNOTCOMPAREEQNEQLTGTLEGEINTSELFCONTRACTTRANSFER_TOKENS SET_DELEGATECREATE_ACCOUNTCREATE_CONTRACTCREATE_CONTRACT2IMPLICIT_ACCOUNTNOWAMOUNTBALANCECHECK_SIGNATURESHA256SHA512BLAKE2BHASH_KEYSTEPS_TO_QUOTASOURCESENDERADDRESSExtU ExpandedOpPrimExSeqEx ExpandedInstrExpandedInstrExtUOpunOp InstrExtUmkContractAddressUntypedContract UntypedValueprintUntypedContractToTSTcSTKeySTUnit STSignatureSTOptionSTListSTSet STOperation STContractSTPairSTOrSTLambdaSTMapSTBigMapSCIntSCNatSCStringSCBytesSCMutezSCBool SCKeyHash SCTimestamp SCAddresswithSomeSingCT fromSingCT withSomeSingT fromSingTNotes'NTcNTKeyNTUnit NTSignatureNTOptionNTListNTSet NTOperation NTContractNTPairNTOrNTLambdaNTMapNTBigMapNotesNNStar notesCaseisStarmkNotesorAnnconverge convergeAnns fromUTypemkUType extractNotestoUTypeFromCValfromCValToCValtoCValCValCvIntCvNatCvStringCvBytesCvMutezCvBool CvKeyHash CvTimestamp CvAddressFromValfromValToValtoValValVCVKeyVUnit VSignatureVOptionVListVSetVOp VContractVPairVOrVLamVMapVBigMap ContractOut ContractInpCreateContract ccManager ccDelegate ccSpendable ccDelegatable ccBalance ccStorageValccContractCode CreateAccount caManager caDelegate caSpendable caBalance SetDelegate sdMbKeyHashTransferTokensttContractParameterttAmount ttContract OperationOpTransferTokens OpSetDelegateOpCreateAccountOpCreateContract$fBuildableSetDelegate$fBuildableCreateAccount$fBuildableCreateContract$fBuildableTransferTokens $fEqOperation$fBuildableOperation $fToValMap $fToValSet $fToVal[] $fToVal(,) $fToValEither $fToValMaybe$fToValAddress$fToValTimestamp$fToValKeyHash $fToValMutez $fToValBool$fToValByteString $fToValText$fToValNatural $fToValWord64 $fToValInt$fToValInteger $fToVal() $fFromValMap $fFromValSet $fFromVal(,)$fFromValEither$fFromValMaybe $fFromVal[] $fFromVal()$fFromValAddress$fFromValTimestamp$fFromValKeyHash$fFromValMutez$fFromValByteString $fFromValBool $fFromValText$fFromValNatural$fFromValInteger$fShowSetDelegate$fEqSetDelegate$fShowCreateAccount$fEqCreateAccount$fShowTransferTokens$fEqTransferTokens$fEqVal $fShowVal$fEqCreateContract$fShowCreateContract$fShowOperationEDivOp EDivOpRes EModOpRes evalEDivOpSliceOp evalSliceConcatOp evalConcat evalConcat'GetOpGetOpKeyGetOpValevalGetUpdOpUpdOpKey UpdOpParamsevalUpdSizeOpevalSizeIterOpIterOpEliterOpDetachOneMapOpMapOpInpMapOpRes mapOpToList mapOpFromListMemOpMemOpKeyevalMemGeLeGtLtNeqEq'CompareLsrLslNotXorAndOrNegAbsMulSubAdd UnaryArithOp UnaryArithResevalUnaryArithOp ArithErrorMutezArithErrorArithErrorType AddOverflow MulOverflow SubUnderflowArithOpArithResevalOpSeqNopExtNestedCONCAT' InstrExtTExtT#ConversibleExt ConversibleconvertconvertContractunsafeValToValuevalToOpOrValue instrToOps UTestAsserttassName tassComment tassInstrs PrintCommentunPrintCommentLetTypeltNameltSigLetValuelvNamelvSiglvValLetMacrolmNamelmSiglmExprStackFnquantifiedVars inPattern outPatternStackTypePatternStkEmptyStkRestStkConsTyVarVarIDTyConVarStackRefMacroCMPIFXIFCMPFAILPAPAIRUNPAIRCADRSET_CADRMAP_CADRDIIPDUUPASSERTASSERTX ASSERT_CMP ASSERT_NONE ASSERT_SOME ASSERT_LEFT ASSERT_RIGHTIF_SOME CadrStructAD PairStructFP MorleyLogs unMorleyLogsExtInstr TEST_ASSERTPRINT TestAssertExpandedUExtInstrParsedOpPrimMacLMac ParsedInstrParsedUExtInstrParsedUTestAssertUExtInstrAbstract STACKTYPEFNFN_END UTEST_ASSERTUPRINTLetEnv letMacros letValuesletTypesParserExceptionParserCustomParserExceptionUnknownTypeExceptionOddNumberBytesExceptionUnexpectedLineBreaknoLetEnv noMorleyLogsvarSet)$fShowErrorComponentCustomParserException$fBuildableParserException$fExceptionParserException$fShowParserException$fBuildablePairStruct$fBuildableCadrStruct$fBuildableStackRef$fBuildableVar$fBuildableTyVar$fBuildableStackTypePattern$fBuildableStackFn$fBuildableLetMacro$fBuildableMacro$fBuildableParsedOp$fRenderDocParsedOp$fDefaultReaderT$fBuildablePrintComment$fEqTestAssert$fBuildableUTestAssert&$fConversibleExtInstrUExtInstrAbstract$fBuildableUExtInstrAbstract$fEqCustomParserException$fDataCustomParserException$fOrdCustomParserException$fShowCustomParserException$fEqMorleyLogs$fShowMorleyLogs$fDefaultMorleyLogs$fBuildableMorleyLogs$fEqPairStruct$fShowPairStruct$fDataPairStruct$fGenericPairStruct$fEqCadrStruct$fShowCadrStruct$fDataCadrStruct$fGenericCadrStruct $fEqStackRef$fShowStackRef$fDataStackRef$fGenericStackRef$fEqVar $fShowVar$fOrdVar $fDataVar $fGenericVar $fEqTyVar $fShowTyVar $fDataTyVar$fGenericTyVar$fEqStackTypePattern$fShowStackTypePattern$fDataStackTypePattern$fGenericStackTypePattern $fEqStackFn $fShowStackFn $fDataStackFn$fGenericStackFn $fEqLetMacro$fShowLetMacro$fDataLetMacro$fGenericLetMacro $fEqParsedOp$fShowParsedOp$fDataParsedOp$fGenericParsedOp $fEqMacro $fShowMacro $fDataMacro$fGenericMacro $fEqLetValue$fShowLetValue $fEqLetType $fShowLetType $fShowLetEnv $fEqLetEnv$fEqPrintComment$fShowPrintComment$fDataPrintComment$fGenericPrintComment$fShowExtInstr $fEqExtInstr$fEqUTestAssert$fShowUTestAssert$fFunctorUTestAssert$fDataUTestAssert$fGenericUTestAssert$fEqUExtInstrAbstract$fShowUExtInstrAbstract$fDataUExtInstrAbstract$fGenericUExtInstrAbstract$fFunctorUExtInstrAbstract$fShowTestAssert$fFromJSONParsedOp$fToJSONParsedOp$fFromJSONUExtInstrAbstract$fToJSONUExtInstrAbstract$fFromJSONPrintComment$fToJSONPrintComment$fFromJSONStackTypePattern$fToJSONStackTypePattern$fFromJSONStackRef$fToJSONStackRef$fFromJSONStackFn$fToJSONStackFn $fFromJSONVar $fToJSONVar$fFromJSONTyVar $fToJSONTyVar$fFromJSONLetMacro$fToJSONLetMacro$fFromJSONLetValue$fToJSONLetValue$fFromJSONLetType$fToJSONLetType$fFromJSONUTestAssert$fToJSONUTestAssert$fFromJSONPairStruct$fToJSONPairStruct$fFromJSONCadrStruct$fToJSONCadrStruct$fFromJSONMacro $fToJSONMacroTxDatatdSenderAddress tdParametertdAmount $fShowTxData ContractState csBalance csStorage csContract$fBuildableContractState$fShowContractState$fGenericContractState$fEqContractState AddressStateASSimple ASContract$fFromJSONContractState$fToJSONContractState$fBuildableAddressState$fShowAddressState$fGenericAddressState$fEqAddressStateGState gsAddresses asBalance$fFromJSONAddressState$fToJSONAddressState $fShowGStateGStateUpdateErrorGStateAddressExistsGStateUnknownAddressGStateNotContract GStateUpdate GSAddAddressGSSetStorageValue GSSetBalancegenesisAddressTextgenesisKeyHashgenesisAddress initGState readGState writeGState applyUpdate applyUpdates$fFromJSONGState$fToJSONGState$fExceptionGStateParseError$fBuildableGStateUpdate$fBuildableGStateUpdateError$fShowGStateParseError$fShowGStateUpdate$fEqGStateUpdate$fShowGStateUpdateError expandListexpandContract expandValueexpand expandPapairexpandUnpapair expandCadr expandSetCadr expandMapCadr mapLeaveslexememSpacesymbolsymbol'string'parensbracesbrackets brackets' semicoloncommanotenoteTnoteVnoteFnoteF2noteTDefnoteVDef _noteFDefnotesTVF notesTVF2notesTVnotesVF fieldTypeprogram parseNoEnvvaluetype_ops intLiteral bytesLiteral stringLiteralpushOp printComment stackType minTimestamp maxTimestamp midTimestamp$fArbitraryTimestamp$fArbitraryMutez$fArbitraryCVal$fArbitraryVal$fArbitraryVal0$fArbitraryVal1$fArbitraryVal2$fArbitraryCVal0$fArbitraryCVal1$fArbitraryCVal2TcInstrHandlerTcResult TypeCheckEnv tcExtHandler tcExtFramestcContractParam TcExtHandler TypeCheckTExtC TcExtFramesTCErrorTCFailedOnInstrTCFailedOnValue TCOtherError SomeContractSomeValC:--:SomeVal:::: SomeInstr:::SiFailSomeHSTHSTSNil::& runTypeCheckTeqT' typeCheckCValtypeCheckContract typeCheckList typeCheckValEvalOpInterpreterState isExtStateisRemainingStepsRemainingStepsInterpreterEnv ieContractEnv ieItHandler SomeItStackContractReturnInterpretUntypedResultiurOps iurNewStorage iurNewStateInterpretUntypedErrorRuntimeFailureIllTypedContract IllTypedParamIllTypedStorageUnexpectedParamTypeUnexpectedStorageTypeMichelsonFailedMichelsonFailedWithMichelsonArithErrorMichelsonGasExhaustionMichelsonFailedOther ContractEnvceNow ceMaxSteps ceBalance ceContractsceSelfceSourceceSenderceAmountinterpretUntyped interpretrunInstr runInstrNoGas$fBuildableMichelsonFailed $fBuildableInterpretUntypedError$fGenericInterpretUntypedError$fShowRemainingSteps$fEqRemainingSteps$fOrdRemainingSteps$fBuildableRemainingSteps$fNumRemainingSteps$fShowInterpreterState$fShowInterpretUntypedResult$fShowInterpretUntypedError$fShowMichelsonFaileddummyNow dummyMaxStepsdummyContractEnvdummyOriginationinterpretMorleyUntypedinterpretMorleytypeCheckMorleyContracttypeCheckHandlerinterpretHandlerContractPropValidator contractPropcontractPropValInterpreterRes _irGState _irOperations _irUpdates_irInterpretResults_irSourceAddress_irRemainingSteps InterpreterOp OriginateOp TransferOp$fShowInterpreterOp$fShowInterpreterResInterpreterErrorIEUnknownContractIEInterpreterFailedIEAlreadyOriginatedIEUnknownSenderIEUnknownManagerIENotEnoughFundsIEFailedToApplyUpdatesIEIllTypedContract parseContractparseExpandContractreadAndParseContractprepareContractoriginateContract runContracttransferinterpreterPure$fExceptionInterpreterError$fBuildableInterpreterError$fShowInterpreterErrorIntegrationalScenarioSuccessValidatorIntegrationalValidatorintegrationalTestExpectationintegrationalTestProperty originatevalidatesetNow setMaxStepsexpectAnySuccessexpectStorageUpdateexpectStorageUpdateConstexpectStorageConst expectBalancecomposeValidatorscomposeValidatorsListexpectGasExhaustionexpectMichelsonFailedImportContractErrorICEUnexpectedParamTypeICEUnexpectedStorageTypeICEParse ICETypeCheckspecWithContractspecWithTypedContractspecWithUntypedContract readContractimportContractimportUntypedContract$fExceptionImportContractError$fBuildableImportContractError$fShowImportContractErroreqParam1ghc-prim GHC.Classes==baseData.Typeable.InternalTypeableeqParam2eqParam3GHC.Basemempty-wl-pprint-text-1.2.0.0-L6i9Q0yxJZoBCBd4YxCMOZText.PrettyPrint.Leijen.TextDoc text-1.2.3.1Data.Text.InternalTextData.Text.Internal.BuilderBuilder(QuickCheck-2.13.1-1rO57X9FmbTEL9U6cBekOsTest.QuickCheck.Property GHC.MaybeNothingJustParseAddressErrorParseAddressWrongBase58CheckParseAddressBothFailedbytestring-0.10.8.2Data.ByteString.Internal ByteString SomeSingT SomeSingCTtoSingCTtoSingT D:R:SingT0 D:R:SingCT0 converge'stackTypePatternToList GHC.TypesBoolTrueFalse addAddresssetStorageValue setBalanceLetcontractletBlockletInneraddLetletNamemkParserderiveSpecialFNsderiveSpecialVNderiveVN deriveNsOrderiveNsOption convergeHSTensureDistinctAscmemImpl arithImplunaryArithImpl convergeHSTElonLeftcheckEqT assertEqTtypeCheckInstrErrtypeCheckInstrErrM typeCheckImplgetImplupdImplsizeImpl sliceImpl concatImpl' concatImpladdImpledivImplsubImplmulImpl compareImpltypeCheckValImpl typeCheckNEtypeCheckInstr genericIf runInstrImpl runArithOp UExtError uextErrorText checkVarscheckFn checkFnEndcheckStackTypeGHC.IO.Handle.FDstdin interpreterIOinterpretOneOp _isOperations ValidatedIntegrationalScenarioM Data.EitherLeft.hspec-expectations-0.8.2-xEhsaJyqHC4OUn6v2CIJJTest.Hspec.ExpectationsGHC.IO.Exception IOException