!Us              !" # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                            !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkl m n o p q r s t u v w x y z { | } ~                                                                  !"##############################$$$$$$$$$$$ $ $ $ $ $$$$$$$$$$$$$$$$$$$ $!%"%#%$%%%&%'%(%)%*%+%,%-%.%/%0%1%2%3%4%5%6%7%8%9%:%;%<%=%>%?%@%A%B&C&D&E&F&G&H&I&J&K&L&M&N&O&P&Q&R&S&T&U&V&W&X&Y&Z&[&\&]&^&_&`&a&b&c&d&e&f&g'h'i'j'k'l'm'n'o'p'q'r's't'u'v'w'x'y'z'{'|'}'~''''''''''''''''''''''''''''''''''''''''(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))) ) ) ) * ******************* *!*"*#*$*%*&*'*(*)***+*,*-*.*/*0*1*2*3*4*5*6*7*8+9+:+;+<+=+>+?+@+A+B+C+D+E+F+G+H+I+J+K+L+M+N+O+P+Q+R+S+T+U+V+W+X+Y+Z+[+\+]+^+_+`+a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+r+s+t+u+v+w+x+y+z+{+|+}+~+++++++++++++++++++++++++++++++++++++++++++++++++++,,,------------.../0000000000000000000000000011111111111111111111111111112222333 3 3 3 3 3333333333333333333 3!3"3#3$3%3&3'3(3)3*3+3,3-3.3/303132333435363738393:3;3<3=3>3?3@3A3B3C3D3E3F3G3H3I3J3K3L4M4N4O4P4Q4R4S4T4U4V4W4X4Y5Z5[5\5]5^5_5`5a5b5c5d5e5f5g5h5i5j5k5l5m5n5o5p5q5r5s5t5u5v5w5x5y5z5{5|5}5~5555555555555555555555555555555555666666666666666666666666666666666666666666666666666666666677777777777777777777777777777777777777777777777 7 7 7 7 7777777777777777777 7!7"7#7$7%7&7'7(7)7*7+7,7-8.8/808182838485868788898:8;8<8=8>8?8@8A8B8C8D8E8F8G8H8I8J8K8L8M8N8O8P8Q8R8S8T8U8V8W8X8Y8Z8[8\8]8^8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}8~8888999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999 9 9 9 9 9:::::::;;;;<<<<<<< <!<"<#<$<%<&<'<(<)<*<+=,=-=.=/=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={=|=}=~==========>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>?????????????????????????@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA A A A A AAAAAAAAAAAAAAAAAAA A!A"A#A$A%A&A'A(A)A*A+A,A-A.A/A0A1A2A3A4A5A6A7A8A9A:A;A<A=A>A?A@BABBBCCDCECFCGCHCICJCKCLCMCNCOCPCQCRCSCTCUCVCWCXCYCZC[C\C]C^C_C`CaDbDcDdDeDfDgDhDiDjDkDlDmDnDoDpDqDrDsDtDuDvDwDxDyDzD{D|D}D~DDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGHIIIIIIJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K K L !L "L #L $L %M &M 'M (M )M *M +M ,M -M .M /M 0M 1M 2M 3M 4M 5M 6M 7M 8M 9M :M ;M <M =M >M ?M @M AM BM CM DM EM FM GM HM IM JM KM LM MM NM OM PM QM RM SM TM UM VM WM XM YM ZM [M \M ]M ^M _M `M aM bM cM dM eM fM gM hM iM jM kM lM mM nM oM pM qM rM sM tM uM vM wM xM yM zM {M |M }M ~M M M M M N N N N N N N N N N N N N N N N N O O O O O O O O O O P P P P P P P P P P P P P P Q Q Q Q Q Q R R R R R S S S S S S S S S S S T T U U U V V V V V W W W W X X X        Y Y Z Z Z Z Z Z Z Z Z Z Z [ [ [ [ [ [ [ \ \ \ \ \ \ \ \ \ \ \ \ ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ !^ "^ #^ $^ %^ &^ '^ (^ )^ *^ +^ ,^ -^ .^ /^ 0^ 1^ 2^ 3^ 4^ 5^ 6^ 7^ 8^ 9^ :^ ;^ <^ =^ >^ ?^ @^ A^ B^ C^ D^ E^ F^ G^ H^ I^ J^ K^ L^ M_ N_ O_ P_ Q` R` S` T` U` V` W` X` Y` Z` [` \` ]` ^` _` `` a` b` c` d` e` f` g` h` i` j` k` l` m` n` o` p` q` r` s` t` u` v` w` x` y` z` {a |a }a ~a a a a b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b c c c c c c c c c c c c c c c c c c c d d d d d d e e e e e e e e e e e f f f f f f f f f f f f f f f f f f f g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g g go None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm "#$%&'()*+,-. -+,)*."#$%&'(None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmNmorleyA new type that can wrap values so that the RenderDoc instances of the combined value can have a different behavior for the pretty printer.PmorleyGeneralize converting a type into a Text.PrettyPrint.Leijen.Text.Doc. Used to pretty print Michelson code and define Fmt.Buildable instances.RmorleyWhether 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).Smorley/Environment carried during recursive rendering. morleyzWhether the current expression is going to be used as part of top-level expression or in a similar context. When set to  B, you may need to wrap your rendered expression into parentheses.TmorleyConvert   to   with a line width of 80.UmorleyConvert   to   in the same maner as T.VmorleyLGeneric way to render the different op types that get passed to a contract.Xmorley#Create a specific number of spaces.YmorleyCWrap documents in parentheses if there are two or more in the list.Zmorley#Turn something that is instance of P into a  ". It's formatted the same way as T formats docs. morley9Here using a page width of 80 and a ribbon width of 1.0 Uhttps://hackage.haskell.org/package/wl-pprint-1.2.1/docs/Text-PrettyPrint-Leijen.html[morley ParensNeeded constant.\morley ParensNeeded constant.]morleyAdd parentheses if needed.^morleygEnsure parentheses are not required, for case when you cannot sensibly wrap your expression into them.NOPQRSTUVWXYZ[\]^PQRNOTUVWXYZS[\]^None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmamorleyA  ' that always failes with given message.bmorleyA   that always succeeds.cmorleyThe   holds on `Left a`.dmorleyThe   holds on `Right b`.emorleyThis  : contains a property based test for conversion from some x to some y and back to x- (it should successfully return the initial x)._`abcde_`abcdeNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm&fmorleyJPath to a leaf (some field or constructor) in generic tree representation.gmorleyQWhich branch to choose in generic tree representation: left, straight or right. iP is used when there is one constructor with one field (something newtype-like).The reason why we need i 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 i, in both cases path will be the same ([L]).fgjihgjihfNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm]qmorley Generic TypeFieldVariable Annotation|As per Michelson documentation, this type has an invariant: (except for the first character, here parametrized in the type tagH) the allowed character set is the one matching the following regexp: %|%%|%|[:%][_a-zA-Z][_0-9a-zA-Z.%@]*wmorleyPrints 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`ymorley Makes an q" from its textual value, prefix (%@*:) excluded Throws an error if the given   contains invalid characterszmorley Makes an q" from its textual value, prefix (%@:) excluded Returns a   error message if the given   contains invalid characters{morley>List of all the special Variable Annotations, only allowed in CAR and CDRH instructions, prefix (@) excluded. These do not respect the rules of } and ~.|morley3The only special Field Annotation, only allowed in PAIR, LEFT and RIGHTH instructions, prefix (%) excluded. This does not respect the rules of } and ~.}morley Checks if a  6 is valid to be the first of an annotation, prefix (%@8:) excluded, the ones following should be checked with ~B instead. Note that this does not check Special Annotations, see { and |~morley Checks if a  O is valid to be part of an annotation, following a valid first character (see }) and the prefix (%@<:). Note that this does not check Special Annotations, see { and |klmnopqrstuvwxyz{|}~qrsutopnmlkxyz{|}~vwNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmmorleyEntrypoint name.Empty if this entrypoint is default one. Cannot be equal to "default", the reference implementation forbids that. Also, set of allowed characters should be the same as in annotations.morleyMake up / from annotation in parameter type declaration.Returns  # if no entrypoint is assigned here.morleyHTurn entrypoint name into annotation for contract parameter declaration.morleyMake up J from annotation which is reference to an entrypoint (e.g. annotation in CONTRACT instruction).Fails if annotation is invalid.morleyETurn entrypoint name into annotation used as reference to entrypoint. None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm;morleyKFor implicit account, which type its parameter seems to have from outside.IINone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm  morley8A stack function that expresses the type signature of a LetMacro%morleyA stack pattern-match)morley"A type-variable or a type-constant.morleyA reference into the stack.0morley3Implementation-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).1morley,Matches current stack against a type-pattern2morley'A typed stack function (push and pop a  TcExtFrame)3morley8Copy the current stack and run an inline assertion on it4morley'Print a comment with optional embedded StackRefs5morleyConvert %# 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.6morley+Get the set of variables in a stack pattern !#$"%&'()+*,-./012345601234./,-)+*%&'( !#$"65None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmstuvwxyyxstuvwNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmmorley6Michelson language type with annotations stripped off.morleyConverts from  to hi.morley"Format type stack in a pretty way. None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm( 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 .None5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmNN%morley$Should be present for common scopes.morley,Check that constraint hold for a given type.morley6Alias for constraints which are required for printing.morleyAAlias for constraints which Michelson applies to unpacked values.It is different from , e.g. contract- type cannot appear in a value we unpack to.morley?Alias for constraints which Michelson applies to packed values.morleyBAlias for constraints which Michelson applies to pushed constants.morleyBAlias for constraints which Michelson applies to contract storage.morley;Alias for constraints which Michelson applies to parameter.morleyAlias for comparable types.morleyWhether the type contains  , with proof.morley This is like ., it raises a more human-readable error when t[ type is concrete, but GHC cannot make any conclusions from such constraint as it can for (. Though, hopefully, it will someday:  /https://gitlab.haskell.org/ghc/ghc/issues/11503#11503. Use this constraint in our eDSL. )morley#Report a human-readable error that  contains another morley#Report a human-readable error that  contains another morley$Report a human-readable error about  at a wrong place. *morley$Report a human-readable error about  at a wrong place.morley$Report a human-readable error about  at a wrong place.morley1Constraint which ensures that type is comparable.morley:Constraint which ensures that there are no nested bigmaps.morleyEConstraint which ensures that bigmap does not appear in a given type.morleyLConstraint which ensures that contract type 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  +).morley.Whether this type contains a type with nested s .Nested big_maps (i.e. big_map which contains another big_map inside of it's value type). Are prohibited in all contexts. Some context such as PUSH, APPLY, PACK/UNPACK instructions are more strict because they doesn't work with big_map at all.morleyWhether this type contains  type. ,morleyWhether this type contains  type.In some scopes (constants, storage) appearing for contract type is prohibited. Contracts 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. .morleyEvidence of that  is deducable from .morleyReify  contraint from . Left for backward compatibility. /morleyReify  contraint from .morleyReify  contraint from .morley1Check at runtime whether the given type contains .morley1Check at runtime whether the given type contains . 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 . morley6Check at runtime that the given type does not contain .morley7Check at runtime that the given type does not containt morley=Check at runtime that the given type does not contain nested M     M     jNone5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmR 0 1 2 3 4 5 6 7None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm['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.'()*'()*None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmgC.morleyFError that can happen during parsing of cryptographic primitive types.3morley*Encode a bytestring in Base58Check format.4morley,Decode a bytestring from Base58Check format.5morleyParse 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.6morley Template for  'format*' functions.7morley Template for 'parse*' functions.8morleyReturns first encountered  82 in a list. If there are none, returns arbitrary  9%. It is useful to implement parsing.9morley*Do randomized action using specified seed.+,-./0123456789./01234+,-56789None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmk>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.>>None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmof?morley]Newtype wrapper for ByteString which uses hexadecimal representation for JSON serialization.?@A?@ANone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmqTDEDENone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmsJFGFGNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmw@Lmorley Similar to  <, but compares types via  DefaultEq& used in singletons comparisons (see Data.Singletons.Prelude.Eq module).KLMNNMLKNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmOmorley5Extract datatype name via its Generic representation.:For polymorphic types this throws away all type arguments.PmorleyBRebuild a list into a binary tree of exactly the same form which kl 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.OPQPQONone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmVmorleyChange the character encoding of the given Handle to transliterate on unsupported characters instead of throwing an exception.RSTUVRSTUVNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmZmorley?For datatype with "myNyan" field it will create "myNyanL" lens.ZZNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm[morley!Level of header, starting from 1.]morleyA piece of markdown document.This is opposed to  A type, which in turn is not supposed to contain markup elements. =morley@Turn text into valid anchor. Human-readability is not preserved.imorley#Text which is hidden until clicked.kmorleyQuasi quoter for Markdown.[\]^_`abcdefghijk][\^_a`bcdefghijk None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmlmnopqnopqml None5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm }morleyWe can have `RequireLongerOrSameLength = (RequireLongerOrSameLength' l a, LongerOrSameLength l a)`, but apparently the printed error message can be caused by  rather than  >t. We do not know for sure how it all works, but we think that if we require constraint X before Y (using multiple `=>`)s) then X will always be evaluated first. >morleyW in form of constraint that produces good error message. Should be used together with  because  gives GHC more information. We use it in combination, so that it gives enough information to GHC and also producess good error messages. ?morley[Comparison of type-level naturals, raises human-readable compile error when does not hold.%Here we use the same approach as for } , this type family is internal. @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  - 1 + 1 + Length s.5For concrete types this will be identical to calling FromPeano (Length l).morley; in form of constraint that gives most information to GHC.morley Similar to , but returns  / when list length equals to the passed number.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.morleyA convenient alias.We are going to use . numbers for type-dependent logic and normal  0s in user API, need to distinguish them somehow.morley!Get runtime value from singleton. }~ ~} None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmmorleyInteger values starting from 1.,We define our own datatype in order to have  A_ instance for it, which can not be derived for third-party types without exported constructor.morleyCount length of non-empty list.morley7Produce a non empty list consisting of the given value. None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm!None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm+morley:This is the default set of ingredients extended with the  B. which is used to generate xml reports for CI."None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmmorley,Leads first character of text to lower case.(For empty text this will throw an error.None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm3 morleySList analogy for .morley Similar to SingI []C, but does not require individual elements to be also instance of SingI.morley\Bring type-level list at term-level using given function to demote its individual elements.morleyLMake sure given type is evaluated. This type family fits only for types of  C kind.morley-Fail with given error if the condition holds.morley5Fail with given error if the condition does not hold.morleyDifference between two lists.morley+Remove all occurences of the given element.morley?A natural conclusion from the fact that error have not occured.morley*Reify type equality from boolean equality.morleySplit a record into two pieces. ! !None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmPmorleyConditional type error. Note that TypeErrorUnless cond err is the same as If cond () (TypeError err)U, but does not produce type-level error when one of its arguments cannot be deduced.morley$Reify the fact that condition under + constraint can be assumed to always hold.    #None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm\ morleyA type error asking to use  instead of  .morleyMichelson string value.DThis is basically a mere text with limits imposed by the language:  9https://tezos.gitlab.io/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. Dmorley;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.morley Create a  from type-level string.We assume that no unicode characters are used in plain Haskell code, so unless special tricky manipulations are used this should be safe.morley Create a  from label.We assume that no unicode characters are used in plain Haskell code, so unless special tricky manipulations are used this should be safe.morley,Leads first character of text to upper case.(For empty text this will throw an error.$None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm morley"Secp256k1 cryptographic signature.morley#Secp256k1 secret cryptographic key.morley#Secp256k1 public cryptographic key.morleyThis is the hack we use to make serialization correct. Decoding is currently not implemented, so when we have to decode bytes we remember these bytes and produce some random public key.TODO (#18) remove it.morley1Deterministicaly generate a secret key from seed.morley&Create a public key from a secret key.morley Convert a  to raw bytes.FTODO (#18): apparently it uses compressed SEC format as described in  Phttps://www.oreilly.com/library/view/programming-bitcoin/9781492031482/ch04.html However, it is not tested yet. morleyMake a  from raw bytes.{TODO (#18): it should decode from compressed SEC format, but it's left for a future task, so for now we return a constant. morley Convert a  to raw bytes.oTODO (#18): apparently a signature always has 64 bytes, so this format might be correct, but it is not tested. morleyMake a  from raw bytes.oTODO (#18): apparently a signature always has 64 bytes, so this format might be correct, but it is not tested.morley$Sign a message using the secret key.morley@Check that a sequence of bytes has been signed with a given key.          %None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmS !morleyP256 cryptographic signature.$morleyP256 secret cryptographic key.%morleyP256 public cryptographic key.(morley1Deterministicaly generate a secret key from seed.)morley&Create a public key from a secret key.*morley Convert a % to raw bytes.TODO (#18): implement properly.+morleyMake a % from raw bytes.TODO (#18): implement properly.-morley Convert a % to raw bytes.TODO (#18): implement properly..morleyMake a ! from raw bytes.TODO (#18): implement properly.6morley@Check that a sequence of bytes has been signed with a given key.!"#$%&'()*+,-./0123456%&'$!"#()*+,-./0123456&None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm$_ Bmorley ED25519 cryptographic signature.Emorley!ED25519 secret cryptographic key.Fmorley!ED25519 public cryptographic key.Imorley1Deterministicaly generate a secret key from seed.Jmorley&Create a public key from a secret key.Kmorley Convert a F to raw bytes.LmorleyMake a F from raw bytes.Nmorley Convert a B to raw bytes.OmorleyMake a B from raw bytes.Ymorley$Sign a message using the secret key.Zmorley@Check that a sequence of bytes has been signed with a given key.BCDEFGHIJKLMNOPQRSTUVWXYZFGHEBCDIJKLMNOPQRSTUVWXYZ'None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmH2gmorley!Blake2b_160 hash of a public key.imorley<We store which curve was used because it affects formatting.jmorley Hash itself.kmorley6Which curve was used for the hashed public key inside g.omorleyDCryptographic signatures used by Tezos. Constructors correspond to u constructors.Tezos distinguishes signatures for different curves. For instance, ed25519 signatures and secp256k1 signatures are printed differently (have different prefix). However, signatures are packed without information about the curve. For this purpose there is a generic signature which only stores bytes and doesn't carry information about the curve. Apparently unpacking from bytes always produces such signature. Unpacking from string produces a signature with curve information.pmorley4Signature that uses the ed25519 cryptographic curve.qmorley6Siganture that uses the secp256k1 cryptographic curve.rmorley7Signature that uses the NIST P-256 cryptographic curve.smorley-Generic signature for which curve is unknown.tmorleyDSecret cryptographic key used by Tezos. Constructors correspond to u constructors. Emorley5Secret key that uses the ed25519 cryptographic curve. Fmorley7Secret key that uses the secp256k1 cryptographic curve. Gmorley8Secret key that uses the NIST P-256 cryptographic curve.umorleyvPublic cryptographic key used by Tezos. There are three cryptographic curves each represented by its own constructor.vmorley5Public key that uses the ed25519 cryptographic curve.wmorley7Public key that uses the secp256k1 cryptographic curve.xmorley8Public key that uses the NIST P-256 cryptographic curve.ymorleyZDeterministicaly generate a secret key from seed. Type of the key depends on seed length.zmorley&Create a public key from a secret key.{morley Convert a o to raw bytes.|morleyMake a o4 from raw bytes. Can return only generic signature.~morleyuCheck that a sequence of bytes has been signed with a given key. TODO (#18) consider generic signature here as well.morleyPLength of key hash in bytes (only hash itself, no tags, checksums or anything).morley*Compute the b58check of a public key hash.2'()*+,-./012345ghijklmnopqrstuvwxyz{|}~2uvwxtopqrsklmnghijyz{|}~./012'()*34+,-5(None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmtmorleynIdentifier of a network (babylonnet, mainnet, test network or other). Evaluated as hash of the genesis block.The only operation supported for this type is packing. Use case: multisig contract, for instance, now includes chain ID into signed data "in order to add extra replay protection between the main chain and the test chain".morley\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.morleySafely create ."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  H or  Il literal are hardcoded for these types in GHC implementation, so we can only exploit these existing rules.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.morleySubtraction of  values. Returns  7 when the subtrahend is greater than the minuend, and  J otherwise.morleyPartial subtraction of ?, should be used only if you're sure there'll be no underflow.morleyMultiplication of " and an integral number. Returns   in case of overflow.morleyEuclidian division of two  values.morleyEuclidian division of  and a number.morley!Add given amount of seconds to a .morleyDisplay timestamp in human-readable way as used by Michelson. Uses UTC timezone, though maybe we should take it as an argument.<NB: this will render timestamp with up to seconds precision.morley Parse textual representation of .morleyQuote a value of type  in yyyy-mm-ddThh:mm:ss[.sss]Z format.@formatTimestamp [timestampQuote| 2019-02-21T16:54:12.2344523Z |]"2019-02-21T16:54:12Z" Inspired by  'time-quote' library.morleyReturn current time as .morley1Timestamp which is always greater than result of .morley.Timestamp which is always less than result of .morley"Construct chain ID from raw bytes.morleyNConstruct chain ID from raw bytes or fail otherwise. Expects exactly 4 bytes.morleyIdentifier of a pseudo network.morley Pretty print  as it is displayed e.g. in ./babylonnet.sh head call.Example of produced value: NetXUdfLh6Gm88t. KmorleyJIt's a magic constant used by Tezos to encode a chain ID. Corresponds to Net part.##)None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmFmorley.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.morleyKT2 address which corresponds to a callable contract.morley.Hash of origination command for some contract.morleySmart constructor for .morley$Deterministically generate a random  and discard its secret key.morleySmart constructor for 4. Its argument is serialized origination operation. Note: it's quite unsafe to pass  L, 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 mnO. So we have to serialize this data outside this module and pass it here as a  L^. Alternatively we could add some constraint, but it would be almost as unsafe as passing a  L. For this reason we add Raw: suffix to this function and provide a safer function in op. We may reconsider it later.morleyCreate a dummy  value.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.morleyParse a TKG contract address, fail if address does not match the expected format.*None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm 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.      +None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmI 8morley'Data necessary to originate a contract.:morleyOriginator of the contract.;morleyOptional delegate.<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.Amorley"DROP n" instruction. Note: reference implementation permits int16 here. Negative numbers are parsed successfully there, but rejected later. Morley is more permissive, so we use  I@ here, i. e. permit more positive numbers. We do not permit negative numbers at type level. In practice, probably nobody will ever have numbers greater than "H1000 here, at least due to gas limits. Same reasoning applies to other instructions which have a numeric parameter representing number of elements on stack.BmorleyB$ is essentially as special case for A8, but we need both because they are packed differently.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).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).d89:;<=>?}{~jMNLOP@ABCDEFGHIJKQRSTUVWXYZ[\]^_`abcdefghiklmnopqrstuvwxyz|d?}{~jMNLOP@ABCDEFGHIJKQRSTUVWXYZ[\]^_`abcdefghiklmnopqrstuvwxyz|89:;<=>,None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm?oNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm- klmnopqrstuvwxyz{|}~ !#$"%&'()+*,-./0123456stuvwxy   89:;<=>?}{~jMNLOP@ABCDEFGHIJKQRSTUVWXYZ[\]^_`abcdefghiklmnopqrstuvwxyz|-None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmmorley.Data associated with a particular transaction.  .None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmqmorleyBuilding a record from tuple.%It differs from similar typeclass in qrG 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./None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmJmorleyProduce ( instance for tuple of the given length.0None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm(sNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmNone5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmqmorleyLike  ML, casts some container's elements, producing informative error on mismatch.morley N version of .morleySuppose 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  OJ, 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.morley2Compare two entries of completely different types.morley Extension of  to  P function.morleyCast to a type with phantom type argument without matching this argument. The phantom type must be the last type argument of the type.Example of use: imagine a type data MyType a = MyType RNormally, if object of this type was hidden under existential quantification with  !/ constraint, then in order to get it back with castb you need to know the exact type of the hidden object, including its phantom type parameter. With N you get a way to extract this object no matter which phantom argument it had.    1None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmmorley>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 In memory of NStar5 constructor. Generates notes with no annotations.morley%Checks if no annotations are present.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 bD by replacing some empty leaves with type or/and field annotations.morley:Converge two type or field notes (which may be wildcards).2None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmmorley Transparently represent untyped Type as wrapper over (Sing t, Notes t) from typed world.$As expression this carries logic of , and as pattern it performs ! but may make code a bit cleaner.Note about constraints: pattern signatures usually require two constraints - one they require and another one which they provide. In our case we require nothing (thus first constraint is ()#) and provide some knowledge about t.morleyConvert 7 to the isomorphic set of information from typed world.3None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm:morley  with hidden parameter type."This requires argument to satisfy  constraint. Strictly speaking, entrypoint argument may one day start having different set of constraints comparing to ones applied to parameter, but this seems unlikely. morley4Reference for calling a specific entrypoint of type arg. morleyName of entrypoint.morleyAProxy of parameter, to make parameter type more easily fetchable.morley:How to call this entrypoint in the corresponding contract.morleySDescribes how to construct full contract parameter from given entrypoint argument. This could be just wrapper over Value arg -> Value param, but we cannot use Value type in this module easily.morley<Errors specific to parameter type declaration (entrypoints).morley?Coordinates of "arm" in Or tree, used solely in error messages.morley/Annotations for contract parameter declaration.|Following the Michelson specification, this type has the following invariants: 1. No entrypoint name is duplicated. 2. If default@ entrypoint is explicitly assigned, no "arm" remains uncallable."morleyVAddress with optional entrypoint name attached to it. TODO: come up with better name?$morleyAddress itself%morley Entrypoint name (might be empty))morleyvParse an address which can be suffixed with entrypoint name (e.g. "tz1faswCTDciRzE4oJ9jn2Vm2dvjeyA9fUzU%entrypoint"). Qmorley4Check whether given notes are valid parameter notes.+morley Construct ! performing all necessary checks.,morley Construct  P which calls no entrypoint and assumes that there is no explicit "default" one.*Validity of such operation is not ensured.-morley5Call parameter which has no entrypoints, always safe..morley Construct P which calls no entrypoint and assumes that there is no explicit "default" one.*Validity of such operation is not ensured./morley5Call parameter which has no entrypoints, always safe. RmorleyBuild .ZHere we accept entrypoint name and type information for the parameter of target contract.Returns  K if entrypoint is not found. Does not treat default entrypoints specially.1morleyBuild  .ZHere we accept entrypoint name and type information for the parameter of target contract.Returns   if entrypoint is not found.2morley Parameter type of implicit account.7      !"#$%&'()*+,-./0127"#$% !'()*&+   -, ./0 124None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm"Lmorley: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. LMNOPQRSTU LMNOPQRSTU5None5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmq2( ]morley"Representation of Michelson value.Type parameter instr` stands for Michelson instruction type, i.e. data type to represent an instruction of language.mmorleyWWrapper over instruction which remembers whether this instruction always fails or not.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.morleyMerge two execution branches.morley2Get code disregard whether it always fails or not.morleyModify inner code.morleyMake value of contractJ type which refers to the given address and does not call any entrypoint.morleyTurn  into actual function on Values.morleyIIgnoring distinction between constructors here, comparing only semantics.>LMNOPQRSTUYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~>]^_`abcdefghijkl[\YZsrqptuvwxyzLMNOPQRSTU{|}~mno6None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm57None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmBmorley#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.""8None6!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm5-morley=Keeps documentation gathered for some piece of contract code..Used for building documentation of a contract./morleyAll inlined doc items.0morleyDefinitions used in document.Usually you put some large and repetitive descriptions here. This differs from the document content in that it contains sections which are always at top-level, disregard the nesting.All doc items which define  docItemId method go here, and only they.1morleyhWe remember all already declared entries to avoid cyclic dependencies in documentation items discovery.2morleyWe remember all already used identifiers. (Documentation naturally should not declare multiple items with the same identifier because that would make references to the respective anchors ambiguous).3morley@A part of documentation to be grouped. Essentially incapsulates 5.5morley*A map from positions to document elements.This form effeciently keeps documentation for its incremental building. Doc items here appear close to how they were located in the contract; for instance, T~ is not yet applied at this stage. You only can be sure that items within each group are splitted across sections correctly.6morley#Several doc items of the same type.8morley:A doc item which we store, along with related information.:morleyDoc item itself.;morley+Subdocumentation, if given item is a group.<morleyDHides some documentation item which is put to "definitions" section.>morleyHides some documentation item.@morleyHow to render section name.AmorleySuitable for block name.Bmorley+Suitable for subsection title within block.CmorleyBDefines an identifier which given doc item can be referenced with.Fmorley!Where do we place given doc item.Gmorley&Placed in the document content itself.HmorleyAPlaced in dedicated definitions section; can later be referenced. Smorley'Position of all doc items of some type.Imorley%Some unique identifier of a doc item.FAll doc items which should be refer-able need to have this identifier.KmorleyA piece of documentation describing one property of a thing, be it a name or description of a contract, or an error throwable by given endpoint.ZItems of the same type appear close to each other in a rendered documentation and form a section.Doc items are later injected into a contract code via a dedicated nop-like instruction. Normally doc items which belong to one section appear in resulting doc in the same order in which they appeared in the contract.While documentation framework grows, this typeclass acquires more and more methods for fine tuning of existing rendering logic because we don't want to break backward compatibility, hope one day we will make everything concise :( E.g. all rendering and reording stuff could be merged in one method, and we could have several template implementations for it which would allow user to specify only stuff relevant to his case.LmorleyPosition of this item in the resulting documentation; the smaller the value, the higher the section with this element will be placed.Documentation structure is not necessarily flat. If some doc item consolidates a whole documentation block within it, this block will have its own placement of items independent from outer parts of the doc.MmorleyDefines where given doc item should be put. There are two options: 1. Inline right here (default behaviour); 2. Put into definitions section.LNote that we require all doc items with "in definitions" placement to have  T and  U instances which comply the following law: if two documentation items describe the same entity or property, they should be considered equal.Nmorley]When multiple items of the same type belong to one section, how this section will be called.<If not provided, section will contain just untitled content.OmorleyDescription of a section.qCan be used to mention some common things about all elements of this section. Markdown syntax is permitted here.PmorleyHow to render section name.)Takes effect only if section name is set.QmorleyDefines a function which constructs an unique identifier of given doc item, if it has been decided to put the doc item into definitions section.Identifier should be unique both among doc items of the same type and items of other types. Thus, consider using "typeId-contentId" pattern.RmorleyPRender given doc item to Markdown, preferably one line, optionally with header.Accepts the smallest allowed level of header. (Using smaller value than provided one will interfere with existing headers thus delivering mess).Smorley,All doc items which this doc item refers to.UThey will automatically be put to definitions as soon as given doc item is detected.TmorleyThis function accepts doc items put under the same section in the order in which they appeared in the contract and returns their new desired order. It's also fine to use this function for filtering or merging doc items.Default implementation * leaves inlined items as is; * for items put to definitions, lexicographically sorts them by their id.Umorley$Get doc item position at term-level. VmorleyARender an item into Markdown block with all required adjustments. WmorleyOrder items by their  docItemId.Vmorley,Make a reference to doc item in definitions.WmorleyWhether given 8 is atomic.Normally, atomic 8s are ones appearing in DOC_ITEM. instruction, and non-atomic ones are put to DocGroup. XmorleyRender a documentation block. YmorleyBLift a doc item to a block, be it atomic doc item or grouping one.Xmorley#Lift an atomic doc item to a block.Ymorley%Find all doc items of the given type.ZmorleyRender documentation for 3.]morleyTo automatically derive #instance Show Michelson.Typed.Instr later.hmorleyRepository settings for k.jmorley@By commit sha make up a url to that commit in remote repository. Zmorley"Specify version if given contract.nmorleyDescription of something.pmorleyGive a name to document block.rmorley:A function which groups a piece of doc under one doc item.wmorley9Render given contract documentation to markdown document.xmorley2Apply given grouping to documentation being built.zmorleyMake k.:t $mkDGitRevisionGitRepoSettings -> DGitRevision|morleyBContract documentation assembly primarily relies on this instance.C-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZfghijklmnopqrstuvwxyzCKLMNOPQRSTUIJFGHCDE@AB>?<=89:;67534-./012rsuvtWZXYwxVpqnoklmhijzyfg9None5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmq+morleyyTyped contract and information about annotations which is not present in the contract code. TODO [#12]: rename this to  and the current  to  ContractCode?morley-A print format with references into the stackmorley+A reference into the stack of a given type.morley=Keeps 0-based index to a stack element counting from the top.morleyERepresentation 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  DROP  DUPO. Special case where there are no instructions is represented by constructor Nop, e.g. IF_NONE {} { SWAP; DROP; } -> IF_NONE Nop (SWAP  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.morley^A wrapper for instruction that also contain annotations for the top type on the result stack.As of now, when converting from untyped representation, we only preserve field annotations and type annotations. Variable annotations are not preserved.PThis can wrap only instructions with at least one non-failing execution branch.morley4A wrapper for instruction with variable annotations.morley-Execute given instruction on truncated stack.PThis can wrap only instructions with at least one non-failing execution branch.Morley has no such instruction, it is used solely in eDSLs. This instruction is sound because for all Michelson instructions the following property holds: if some code accepts stack i and produces stack o#, when it can also be run on stack i + s producing stack o + s; and also because Michelson never makes implicit assumptions on types, rather you have to express all "yet ambiguous" type information in code. We could make this not an instruction but rather a function which modifies an instruction (this would also automatically prove soundness of used transformation), but it occured to be tricky (in particular for TestAssert and DipN and family), so let's leave this for future work.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\Places documentation generated for given instruction under some group. This is not part of ! because it does not behave like ?; instead, it inherits behaviour of instruction put within it.morleyVariants of CAR/CDR to retain field annotations as they relate to the input stack, and hence won't be available from the annotation notes from the result stack we pack with the instructions during type check.morley[Constraint that is used in DIPN, we want to share it with typechecking code and eDSL code.morleyA wrapper to wrap annotations and corresponding singleton. Apart from packing notes along with the corresponding Singleton, this wrapper type, when included with  also helps to derive the  [ instance for  as `Sing a` does not have a  [ instance on its own.morley<Create a stack reference, performing checks at compile time.||:None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm2morleyConvert 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.;None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm(<None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm|morleyCDescribes how intermediate nodes in instruction tree are accounted.morleyName of this way.morley;This function accepts: 1. Effects gathered after applying stepe to node's children, but before applying it to the node itself. 2. Effects gathered after applying step_ to the given intermediate node. 3. Instruction resulting after all modifications produced by step.morley Options for !.morleyWhether !{ function should go into values which contain other instructions: lambdas and constant contracts (which can be passed to CREATE_CONTRACT). morley8How do we handle intermediate nodes in instruction tree. \morley@Gather effects first for children nodes, then for their parents.!morley4Traverse a typed instruction in depth-first order.  ]c is used to concatenate intermediate results. Each instructions can be changed using the supplied stepO function. It does not consider extra instructions (not present in Michelson)."morleySpecialization of !9 for case when changing the instruction is not required.#morleySpecialization of !' which only modifies given instruction. ^morley^Check whether instruction fails at each execution path or have at least one non-failing path.This function assumes that given instruction contains no dead code (contract with dead code cannot be valid Michelson contract) and may behave in unexpected way if such is present. Term "dead code" includes instructions which render into empty Michelson, like Morley extensions. On the other hand, this function does not traverse the whole instruction tree; performs fastest on left-growing combs.Often we already have information about instruction failure, use this function only in cases when this info is actually unavailable or hard to use.$morleykThere are many ways to represent a sequence of more than 2 instructions. E. g. for `i1; i2; i3` it can be Seq i1 $ Seq i2 i3 or Seq (Seq i1 i2) i3O. This function enforces a particular structure. Specifically, it makes each & have a single instruction (i. e. not ?) in its second argument. This function also erases redundant s.%morley/If value is a string, return the stored string.&morley7If value is a bytestring, return the stored bytestring.'morleyTakes a selector which checks whether an atomic value (i. e. that can not contain another value) can be converted to something. Recursively applies it to all atomic values in potentially non-atomic value. Collects extracted values in a list.Perhaps one day we'll have dfsValue. !"#$%&' !"#$%&'=None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm:N+morley?Isomorphism between Michelson stack and its Haskell reflection..morleyOverloaded version of / to work on Haskell and T stacks./morley1Type function to convert a Haskell stack type to T -based one.0morleyEWhether Michelson representation of the type is derived via Generics.1morley-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.6morleySince Contract@ name is used to designate contract code, lets call analogy of  type as follows.Note that type argument always designates an argument of entrypoint. If a contract has explicit default entrypoint (and no root entrypoint),  ContractRefK referring to it can never have the entire parameter as its type argument.<morley&A useful property which holds for all  types.=morley6Any Haskell value which can be converted to Michelson .?morley4Hides some Haskell value put in line with Michelson .AmorleyOverloaded version of C to work on Haskell and T types.Bmorley=Isomorphism between Michelson values and plain Haskell types.WDefault implementation of this typeclass converts ADTs to Michelson "pair"s and "or"s.Cmorley:Type function that converts a regular Haskell type into a T type.Dmorley"Converts a Haskell structure into Value representation.Emorley Converts a Value into Haskell type.FmorleyGIsomorphism between Michelson primitive values and plain Haskell types.Gmorley[Type function that converts a regular Haskell type into a comparable type (which has kind CT).Hmorley%Converts a single Haskell value into CVal representation.Imorley Converts a CVal# value into a single Haskell value.JmorleyReplace type argument of  ContractAddr with isomorphic one.QmorleyQThis instance erases reference to contract entrypoint! If this is an issue, use " instead.sApplications which use addresses just as participants identifiers should not experience problems with using plain .#+,-./0123456789:;<=>?@ABCDEFGHIJKLM#FGHIBCDE12A?@=><0;:6789JK345/.+,-LM>None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmh _morleyPTraverse a single contructor and supply its field to instruction in case clause. `morleyGeneric traversal for .morleyList of .s required to pattern match on the given type.morley*Type information about single case clause.morleyuIn what different case branches differ - related constructor name and input stack type which the branch starts with. amorleyGeneric traversal for .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.morleyRGet type of constructor fields (one or zero) referred by given datatype and name.morley8Whether given type represents an atomic Michelson value. bmorleyForce result of  c to be  J dmorley;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. emorleyEResult of constructor lookup - entry type and path to it in the tree.morleyTo use  not only here for /-based stacks, but also later in Lorentz with  C--based stacks we need the following property.morleyPush field to stack, if any.morleyGet  something# as field of the given constructor.morleyWe 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).morley Proof of .morley: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).morley<Wrap a haskell value into a constructor with the given name.This is symmetric to .morley$Pattern-match on the given datatype.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)Unwrap a constructor with the given name.Rules which apply to / function work here as well. Although, unlike  instrWrap8, this function does not work for nullary constructors.morley0Try to unwrap a constructor with the given name. fmorleyFailure indicating that we expected value created with one constructor, but got value with different one. The error message is intentionally ugly to keep it relatively short and save on gas.!fgjih!gjihf8?None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmy} gmorleyGeneric traversal for .morleyConstraint for .morley"Types of all fields in a datatype.morley9Way to construct one of the fields in a complex datatype. hmorleyGeneric traversal for .morleyConstraint for . imorleyGeneric traversal for  instrAccess.morleyConstraint for .morley@Get type of field by datatype it is contained in and field name. jmorleyForce result of  k to be  J lmorley,Find field of some product type by its name.2Name might be either field record name, or one in  m- if field is wrapped using '(:!)' or '(:?)'. nmorley>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.  tNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm{+fgjih@None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm omorley6Pick a field from constructor with zero or one fields. pmorleyGeneric traversal for  and .morleyConstraint for  hsDecompose and  hsCompose.morleyjPossible outcomes of an attempt to construct a Haskell ADT value from constructor name and relevant data.morleyComposed fine.morleyNo constructor with such name.morleyRFound required constructor, but type of data does not correspond to provided one.morleyhDecompose Haskell type into constructor name and data it carries, converting the latter into Michelson .morley Inverse to .ANone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm& qmorley Version of  for comparable types.morley#Constraint, required when deriving R for polymorphic type with the least possible number of methods defined manually. rmorleyProduct type traversal for .morley<Generic traversal for automatic deriving of some methods in .morley$Require this type to be homomorphic.morley=Require two types to be built from the same type constructor.E.g. 2HaveCommonTypeCtor (Maybe Integer) (Maybe Natural) is defined, while +HaveCmmonTypeCtor (Maybe Integer) [Integer] is not.morley6Doc element with description of contract storage type.morley'Doc element with description of a type. smorleyCWhen rendering type's inner representation, this stands for name ofHaving this makes sense for polymorhpic types, when you want to render representation of some concrete instantiation of that type.morley"Data hides some type implementing .morley Signature of  function.As in ', set the first element of the pair to   for primitive types, otherwise it stands as some instantiation of a type, and its Michelson representation is given in the second element of the pair.(Examples of rendered representation: *  pair int nat - for homomorphic type. * !MyError Integer = pair string int( - concrete sample for polymorhpic type.morley Signature of  function.When value is  J2, it contains types which this type is built from.hFirst element of provided pair may contain name a concrete type which has the same type constructor as a (or just aX for homomorphic types), and the second element of the pair - its unfolding in Haskell.For example, for some 0newtype MyNewtype = MyNewtype (Integer, Natural)= we would not specify the first element in the pair because  MyNewtype? is already a concrete type, and second element would contain (Integer, Natural). For polymorhpic types like 1newtype MyPolyNewtype a = MyPolyNewtype (Text, a)=, we want to describe its representation on some example of ai, because working with type variables is too non-trivial; so the first element of the pair may be e.g. "MyPolyNewType Integer"/, and the second one shows that it unfolds to (Text, Integer).1When rendered, values of this type look like: * (Integer, Natural) - for homomorphic type. * !MyError Integer = (Text, Integer)( - concrete sample for polymorhpic type.morley:Description for a Haskell type appearing in documentation.morley2Name of type as it appears in definitions section.^Each type must have its own unique name because it will be used in identifier for references.Default definition derives name from Generics. If it does not fit, consider defining this function manually. (We tried using kkR for this, but it produces names including module names which is not do we want).morley6Explanation of a type. Markdown formatting is allowed.morley4How reference to this type is rendered, in Markdown. Examples: *  #type-integerInteger, *  #type-MaybeMaybe #type-unit().Consider using one of the following functions as default implementation; which one to use depends on number of type arguments in your type: *  *  * >If none of them fits your purposes precisely, consider using .morley,All types which this type directly contains."Used in automatic types discovery.morley;For complex types - their immediate Haskell representation. For primitive types set this to  .For homomorphic types use   implementation.%For polymorhpic types consider using   as implementation. Modifier  ? can be used to hide names of fields, beneficial for newtypes.Another modifier called  Q can be used for datatypes to leave only meaningful part of name in every field.morley)Final michelson representation of a type.For homomorphic types use  implementation.%For polymorhpic types consider using  as implementation.morleySWhether given text should be rendered grouped in parentheses (if they make sense).morley`Stands for representation of some Haskell ADT corresponding to Michelson value. Type parameter a\ is what you put in place of each field of the datatype, e.g. information about field type.Outer list layer corresponds to union, and the inner one corresponds to products within constructors. Constructors and fields names are present.morley Show given  in a neat way. tmorleyRemove fields names from .JSometimes there is no sense in showing them in the doc. Example: newtypes. umorley$How field names should be displayed.UResult of this function call should appear right before rendered type of that field.morleyLike : but returns values of more common type which is used in S.morleyRender a reference to a type which consists of type constructor (you have to provide name of this type constructor and documentation for the whole type) and zero or more type arguments.morleyDerive , for homomorphic types only.morleyDerive 5, for polymorphic type with one type argument, like  Maybe Integer.morleyDerive 6, for polymorphic type with two type arguments, like Lambda Integer Natural.morley Implement 1 via getting all immediate fields of a datatype.lNote: this will not include phantom types, I'm not sure yet how this scenario should be handled (@martoon). morley Implement  for a homomorphic type.1Note that it does not require your type to be of  instance, which can be useful for some polymorhpic types which, for documentation purposes, we want to consider homomorphic. Example: [ is in fact polymorhpic, but we don't want this fact to be reflected in the documentation. morley Implement # on example of given concrete type.+This is a best effort attempt to implement  for polymorhpic types, as soon as there is no simple way to preserve type variables when automatically deriving Haskell representation of a type. morley Version of   which does not ensure whether the type for which representation is built is any similar to the original type which you implement a  instance for. morley2Erase fields from Haskell datatype representation.2Use this when rendering fields names is undesired. morley>Cut fields prefixes which we use according to the style guide.E.g.  cmMyField field will be transformed to myField.morley Implement  for homomorphic type.morley Implement # on example of given concrete type.,This function exists for the same reason as  .morley Version of   which does not ensure whether the type for which representation is built is any similar to the original type which you implement a  instance for.&     &     uNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmyfgjih+,-./03456789:;<=>?@ABCDEFGHIJKLM     yfgjih+,-./03456789:;<=>?@ABCDEFGHIJKLM     BNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmi@morley Assemble contract documentation. vmorley+Modify all documentation items recursively.AmorleyWRecursevly traverse an instruction and modify documentation items matching given type.Bmorley1Leave only instructions related to documentation.Generated documentation for resulting instruction remains the same, but semantics of instruction itself gets lost. We have to pass optimizer here as an argument to avoid cyclic dependencies.@AB@ABvNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmWgfgjih           !"#$%&'()*+,-./012LMNOPQRSTUYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'+,-./03456789:;<=>?@ABCDEFGHIJKLM     @ABCNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm3D CmorleyState for type checking nopDmorley(Set of variables defined in a let-block.HmorleyQData type, holding strictly-typed Michelson value along with its type singleton.JmorleyQData type, holding strictly-typed Michelson value along with its type singleton.LmorleywData type keeping the whole type check result: instruction and type representations of instruction's input and output.Nmorley]This data type keeps part of type check result - instruction and corresponding output stack.Omorley?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.Pmorley}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).QmorleyNo-argument type wrapper for HST data type.SmorleyHData 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.VmorleyAppend a type to SA, assuming that notes and annotations for this type are unknown.CDEFGHIJKLMNOPQRSTUVWXSTUVQRNOPLMJKFGHIDECWXM8O9 U7V7DNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmKeamorleyDVarious type errors possible when checking Morley extension commandskmorleyType check errorqmorleyData 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.rmorleyAnnotation unify errorsmorleyType equality errortmorleyStacks equality errorumorleyError that happens when type cannot be used in the corresponding scope. Argument of this constructor carries types which, in the aggregate, violate the restriction (e.g.  timestamp and  timestamp passed to MUL instruction).vmorleyError that happens when a . is never a valid source for this type (e.g.  timestamp cannot be obtained from a )wmorleyEThere are not enough items on stack to perform a certain instruction.xmorley Invalid entrypoint name providedymorley.Contract with given address is not originated.zmorley Given entrypoint is not present.{morleyFIncorrect parameter declaration (with respect to entrypoints feature).|morley"Natural numbers cannot be negative}morleyExceeds the maximal mutez value~morley:Address couldn't be parsed from its textual representationmorley:KeyHash couldn't be parsed from its textual representationmorley!Timestamp is not RFC339 compliantmorleyWDescription of the instruction which wants more items on stack than currently present.%abcdefghijklmnopqrstuvwxyz{|}~%qrstuvwxyz{|}~klmnopabcdefghijENone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmWHmorleyThe 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 or for some utilities when environment does not matter. In particular, it is assumed that whatever we typecheck does not depend on the parameter type of the contract which is being typechecked (because there is no contract that we are typechecking).morley Similar to  , but for 'TypeCheckInstr.'morleyRun 0 and modify thrown errors using given functions.FNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmtmorleyAFunction 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.morleyJCheck whether given types are structurally equal and annotations converge.morley%Generic implementation for MEMerationmorleyLHelper function to construct instructions for binary arithmetic operations.morleyLHelper function to construct instructions for binary arithmetic operations.##GNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmmorley 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. wmorley 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 listHNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmW xmorleyDCheck that the optional "forall" variables are consistent if present ymorley Executes function body, pushing ExtFrame+ onto the state and checks the pattern in FN. zmorley 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.INone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmz |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.Untyped< module hierarchy 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.wNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmVCDEFGHIJKLMNOPQRSTUVWXabcdefghijklmnopqrstuvwxyz{|}~ JNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmmorley&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).KNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmВ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 .morleyState of a contract with code.morley'Amount of mutez owned by this contract.morley,Storage value associated with this contract.morleyContract itself (untyped).morleyWe keep typed representation of contract code and storage in form, that hides their actual type in order to simplify the rest of the code (e.g. avoid type parameters for c and so on). They are made optional in order to perform safe parsing from JSON (we simply return   in this parser and use   or  6 that optionally typecheck storage or contract code).morleyaPersistent data passed to Morley contracts which can be updated as result of contract execution.morleyIdentifier of chain.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 . 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. morley&Retrive all contracts stored in GState0                  0                   LNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmנ morleypConvert an untyped contract into a textual representation which will be accepted by the OCaml reference client. !morleymConvert a typed contract into a textual representation which will be accepted by the OCaml reference client. PQRT ! " # $ PQRT ! " $ #MNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkme %morley6Built-in Michelson Macros defined by the specification Dmorley1Unexpanded instructions produced directly by the ops[ parser, which contains primitive Michelson Instructions, inline-able macros and sequences EmorleyPrimitive Michelson instruction Fmorley5Built-in Michelson macro defined by the specification Gmorley2User-defined macro with instructions to be inlined HmorleyA sequence of instructions OmorleyA programmer-defined macro Umorley%Expand all macros in parsed contract.: % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D H E F G I K J L M N O P Q R S T U V W X Y Z [ \ ] ^: I K J L M N % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ O P Q R S A B D H E F G C U V ^ W T X Y Z [ \ ]NNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmG morley!A programmer-defined type-synonym morleyA programmer-defined constant ONone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmO morley2The environment containing lets from the let-block  PNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm]  QNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm morley endBy2 p sep# parses two or more occurrences of p, separated by sep. morleyMake a parser from a string morley8Apply given parser and return default value if it fails. morleyParse a positive number. morley5Parse expression which can be wrapped in parentheses.  RNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm morleyParse untyped  Ai. Take instruction parser as argument to avoid cyclic dependencies between modules, hence ' in its name.  SNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm morley General TV2F Annotation parser, including Special Annotations DE DETNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmM  UNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm3  VNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm morleyFParser for primitive Michelson instruction (no macros and extensions). morley!Parse a sequence of instructions.  WNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm  XNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkms morleyElement of a let block morleylet 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 parser  None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm morleyParse with empty environment morley'Michelson contract with let definitions morleyMichelson contract morleyParse untyped value from text which comes from something that is not a file (which is often the case). So we assume it does not need any parsing environment. morleyLike  , but also expands macros. morley5Parses code block after "code" keyword of a contract.IThis function is part of the module API, its semantics should not change. morleyCreates  by its Morley representation.[utypeQ| (int :a | nat :b) |]8Type (TOr % % (Type (Tc CInt) :a) (Type (Tc CNat) :b)) :   YNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm morleyTransform all strings in a typed instructions using given function. The first argument specifies whether we should go into arguments that contain instructions. morley Similar to  + but for bytes. TODO [TM-375]: deduplicate  ZNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm9 morleyDescribes how  G should decode tag-dependent data. We expect bytes of such structure:  5 followed by a bytestring which will be parsed with  . morleyAny decoding error. morleyAlias for label attaching. morleydGet a bytestring of the given length leaving no references to the original data in serialized form. morleyGet remaining available bytes.Note that reading all remaining decoded input may be expensive and is thus discouraged, use can use this function only when you know that amount of data to be consumed is limited, e.g. within  decodeAsBytes call. 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. morley Alias for   constructor. morley6Deserialize bytes into the given value. Suitable for UNPACK operation only. morleyLike  , for strict byte array. morley0Deserialize an instruction into the given value. morleyITurn composable decoder into a final decoder which will be run over data. morley-Read length of something (list, string, ...). morley9Given decoder for list content, get a whole list decoder. morleyRead a numeric value. morley-Type check instruction occured from a lambda. morley?Utility function to fill a constructor with an empty annotation morley5Decodes an annotations' string and uses the provided   to parse untyped annotations from it. This has to produce at least one annotation (Annotations' String parsing will fail otherwise)   0 0[None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmK morleySerialize a value given to PACK instruction. morleySame as  , for strict bytestring. morleyGeneric serializer.We don't require  HasNoBigMapH constraint here since the big_map serialization is only prohibited in PACK instructions, however, we still want to be able to serialize big_map e.g. in order to transform typed value to low-level Micheline representation. TODO: Serialize chain operations properly as well since they actually also have byte representation. 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. morleygIff there are non-empty annotations it increments the value's tag and appends the encoded annotations. morley/Encode an instruction with variable annotations morley&Encode an instruction with Annotations  \None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm_ morleyOptimize a typed instruction by replacing some sequences of instructions with smaller equivalent sequences. Applies default set of rewrite rules. morley9Optimize a typed instruction using a custom set of rules. morleyWe do not enable   rule by default because it is potentially dangerous. There are various code processing functions that may depend on constants, e. g. string transformations. morleyAppend LHS of k to RHS and re-run pointwise ruleset at each point. That might cause reinvocation of this function (see  3), but productivity ensures it will flatten any E-tree right-to-left, while evaling no more than once on each node.dThe reason this function invokes ruleset is when you append an instr to already-optimised RHS of $, you might get an optimisable tree.<The argument is a local, non-structurally-recursive ruleset. morleyCombine two rule fixpoints. morley*Combine a rule fixpoint and a simple rule. morleyTurn rule fixpoint into rule. morleyDApply the rule once, if it fails, return the instruction unmodified. morleyAn adapter for !. morley.Apply a rule to the same code, until it fails. ]None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmlM morleyOperation size in bytes.}We use newtype wrapper because there are different units of measure (another one is gas, and we don't want to confuse them). morley9Maximal operation size allowed by Tezos production nodes. morleyRBase cost of any transfer of 0 mutez with no extra parameters. (Add 'valueOpSize  param5' to it to get assessment of actual transfer op size) morleyAccepts arbitrary number of qes (maybe of different types) which belong to the same entity and returns their total operation size.MNote that annotations which belong to the same entity (type or instruction) must be9 considered in aggregate using one call of this function.  ^None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmS morleyMorley interpreter state #morleyfRepresents `[FAILED]` state of a Michelson program. Contains value that was on top of the stack when  was called. )morley#Environment for contract execution. +morleyTimestamp returned by the  instruction. ,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. 0morley4The contract that initiated the current transaction. 1morley=The contract that initiated the current internal transaction. 2morley"Amount of the current transaction. 3morley Identifier of the current chain. 5morleyInterpret a contract without performing any side effects. This function uses untyped representation of contract, parameter and storage. Mostly used for testing. 8morleyRInterpret an instruction in vacuum, putting no extra contraints on its execution.Mostly for testing purposes. 9morleyBFunction 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. ;morley*Unpacks given raw data into a typed value. morley,Access given stack reference (in CPS style).2                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;2 ) * + , - . / 0 1 2 3  # $ % & ' (        4 7 8  6 5     ! "      9 : ;_None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmM Mmorley0Dummy timestamp, can be used to specify current  value or maybe something else. NmorleyDummy 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. OmorleyDummy  )s with some reasonable hardcoded values. You can override values you are interested in using record update syntax. Pmorley8 with most data hardcoded to some reasonable values. Contract and initial values must be passed explicitly, because otherwise it hardly makes sense. M N O P M N O P`None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm! Qmorley,Result of a single execution of interpreter. SmorleyNew . Tmorley7List of operations to be added to the operations queue. UmorleyUpdates applied to . VmorleyDuring 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. WmorleyPAs soon as transfer operation is encountered, this address is set to its input. Xmorley2Now much gas all remaining executions can consume. YmorleyMOperations 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. ZmorleyOriginate a contract. [morleybSend a transaction to given address which is assumed to be the address of an originated contract. _morleyEErrors 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. amorley,Interpretation of Michelson contract failed. bmorley!A contract is already originated. cmorleySender address is unknown. dmorleyManager address is unknown. emorley!Sender doesn't have enough funds. fmorleySending 0tz towards an address. gmorley"Failed to apply updates to GState. hmorleyA contract is ill-typed. imorleyContract storage is ill-typed. jmorley Contract parameter is ill-typed. kmorley)Specified entrypoint to run is not found. nmorleyParse a contract from  . omorleyParse a contract from   and expand macros. pmorley,Read and parse a contract from give path or   (if the argument is   ). The contract is not expanded. qmorleyRead a contract using  p8, expand and flatten. The contract is not type checked. rmorleyFOriginate a contract. Returns the address of the originated contract. smorley}Run a contract. The contract is originated first (if it's not already) and then we pretend that we send a transaction to it. tmorley:Send a transaction to given address with given parameters. morleycExecute a contract on some global state (read from file) and transaction data (passed explicitly). umorley#Implementation of executor outside  . It reads operations, executes them one by one and updates state accordingly. Each operation from the passed list is fully executed before the next one is considered. morley&Execute only one operation and update  accordingly.4 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 v4 r s t n o p q v Y Z [ Q R S T U V W X _ ` a b c d e f g h i j k ^ u l maNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmЄ {morley'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 xy or z{ or anything else relevant. |morleyContract's property tester against given input. Takes contract environment, initial storage and parameter, interprets contract on this input and invokes validation function. }morley Version of  | which takes Val1 as arguments instead of regular Haskell values.This function assumes that contract has no explicit default entrypoints and you always have to construct parameter manually; if you need to test contract calling specific entrypoints, use integrational testing defined by Michelson.Test.Integrational module. ~morley"Check if entrypoint is present in . morleyBCheck whether the given set of entrypoints is present in contract. morleykMatch the given contract with provided set of entrypoints, return left if some entrypoints were not found. morley {_ that expects contract execution to succeed and update storage to a particular constant value.  { | } ~    { | }  ~ bNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm. morley5Store result of interpreted operations as they added. morley7Store the most recent result of interpreted operations. morley4Map from contracts addresses to humanreadable names. morleyRIf set, all following transfers will be executed on behalf of the given contract. morley"A result of an executed operation. morley.Overall information about test scenario error. 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  9Z with validator for errors. Otherwise it should check final global state and its updates. morley When using branchS function for building test scenarios - names of branches we are currently within. 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. morleyCHelper function which provides the results of the given operations. morleyInterprets provided list of operations only if previous interpretation succeeded which allows for engine return the earliest error possible. morleyVOriginate a contract with given initial storage and balance. Its address is returned. morleyLike  #, but for typed contract and value. morley#Transfer tokens to a given address. morley Similar to  5, for typed values. Note that it works with untyped  and does not check that entrypoint with given name is present and has the expected type. Passed value must correspond to the entrypoint argument type, not the parameter type of the contract (and must be unit for implicit accounts). morleyValidate the execution result. morleyJust fail with given error. morley@Make all further interpreter calls (which are triggered by the  5 function) use modified timestamp as the current one. morley@Make all further interpreter calls (which are triggered by the  2 function) use given timestamp as the current one. morley5Increase current time by the given number of seconds. 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@Make all further interpreter calls (which are triggered by the   function) use given chain id. morley+Put an interpreted result to InternalState. morley?Make branch names for a case when we are not within any branch. morley4Add a new branch element to names provided by inner branch calls. morleyaExecute multiple testing scenarios independently, basing them on scenario built till this point./The following property holds for this function:G pre >> branchout [a, b, c] = branchout [pre >> a, pre >> b, pre >> c] .TIn case of property failure in one of the branches no following branch is executed.TProviding empty list of scenarios to this function causes error; we do not require  ; here though for convenience. morley5Make a tuple with name without extra syntactic noise. morleyvTest given scenario with the state gathered till this moment; if this scenario passes, go on as if it never happened. morley  that always passes. morley!Check that there were no updates. morley)Check that there were no storage updates. morley7Check that storage value satisfies the given predicate. 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 Similar to  , for typed stuff. morley:Check that eventually address has some particular balance. morleyCompose two success validators. For example:expectBalance bal addr  * expectStorageUpdateConst addr2 ValueUnit morley%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].:     :      0cNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm/ morleyError type for   function. morleyImport contract and use to create test trees. Both versions of contract are passed to the callback function (untyped and typed).If contract's import fails, a tree with single failing test will be generated (so test tree will likely be generated unexceptionally, but a failing result will notify about problem). morleyLike  $ but supplies only untyped contract. morleyLike  " but supplies only typed contract. 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 fails, a spec with single failing expectation will be generated (so tests will likely 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 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  .  dNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm?1 morley,This data type captures typical ways to use ? instruction. Each constructor corresponds to a usage pattern. morley(Push a constant string and fail with it. morleytPush a constant pair where the first item is a string and the second one is an arbitrary constant. Fail afterwards. morley%Push a constant string and apply the  instruction, then fail. morley!We need this class to pass it to . ' is needed because we push a value and  ! is needed for . morleyExtract error tag out of  . morley4Check whether given instruction ends with a typical ^ usage. It does not recursively check instructions that can be passed to other instructions. morley)If given instruction ends with a typical { usage, modify the tag used there using given transformation function. It can return any value, not necessarily a string.  eNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmMr morley5All string constants and number of their occurrences. morley4All bytes constants and number of their occurrences. morley Which strings are used as error tags and how many times. There is no notion of "error tag" in Michelson, so we use a heuristic to find out whether a string is an error tag. Specifically, we consider three patterns: 1. A constant string is pushed and then there is ; immediately. 2. A constant string is pushed, followed by  instruction and then ^. 3. A constant pair is pushed where the first item is a string and then there is `FAILWITH. morleyStatically analyze an instruction. Typed representation is used because it's easier to analyze. It means that we can't analyze ill-typed contracts, but hopefully it's not a serious limitation.  fNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmh morley%Test case for contract documentation. morley`Declaration location, used to distinguish different test predicates. This is primarily used in  . morley+Description of predicate, which you put to  . morley Test itself. morley Construct  . morleyExclude given test suite. morleyCalling excludeDocTests tests toExclude returns all test suites from tests which are not present in  toExclude. morleyFinalize test suites. morley Ensure that  > check fires on given contract. Used in tests on this module. morley1Apply given function to each group (created with DocGroupd instruction) recursively. This function will accept grouping doc item itself and its subcontents. morley1Apply given function to each group (created with DocGroup instruction) within a contract recursively. This function will accept grouping doc item itself (unless we are at root) and its subcontents. morley8Apply given function to each doc item within a contract. morley2Check that contract documentation is wrapped with  contractName. morley7Check that there is at least one non-grouping doc item.{If there is no such, rendered documentation will be empty which signals about most of the documentation pieces being lost. morley!Check that no group contains two n items.Normally such behaviour is allowed and can be exploited, but often it is not and multiple descriptions appearence under the same group signals about missing grouping wrapper (e.g. use of caseT instead of  entryCase). morley'Check that all descriptions are proper. morley;Base properties which should comply for all documentations.  |None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmk@abcd  O { | } @  { | }  abcd OgNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmr 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. morley&Run given generator deterministically.  }~}~}~}~}~}~}~}}~}}}}                !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNNiiOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~>?@ABCDEFGHIJKLM ~                        ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklNmnopqrstuvwxyz{|}~                                                                         ! " # $ % & ' ( ) * + ,!-"./0123456789:;<=>?@ABCDEFGHIJKL#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$k$l$m$n$n$o$p$q$r$s$t$u$v$w$x$y$z${$|$}$~$$$$$$$$$$$$$%k%k%l%m%n%n%o%q%r%s%t%u%v%w%x%y%z%{%|%}%~%%%%%%%%%%%%&k&k&l&m&n&n&o&q&r&s&t&u&v&w&x&y&z&{&&&|&}&~&&&&&&&&&&&&&&'''''''''k'''''m'n''''q'r'v'w'x''y'z'{'|'}'~'''''''''''''''''''''''''''''''''(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))) ) ) ) ) )))))))))************ *!*"*#*$*%*&*'*(*)***+*,*-*.*/*0*1*2*3*4*5*6*7*8*9*:*;*<*=*>*?*@+A+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+{+|+}+~++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,------------.../000000000000000000000000001111111111111111111111111111222 2 3 3 3 3 3333333333333333333 3!3"3#3$3%3&3&3'3(33)3*3+3,3-3.3/303132333l3435363738393:3;3<3=3>3?3@3A3B3C3D3E3F3G3H3I3J3K3L4M4N4O4P4Q4R4S4T4U4V4W4X4Y5Z5[5\5]55^5_5`5a5b5c5d5e5f5g5h5i5j5k5l5m5n5o5p5q5r5s5t5t5u5v5w5x5y5z5z5{5|5|5}5~555555555555555555555555535455556666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777 7 7 7 7 7777777777777777777 7!7"7#7$7%7&8'8'8(8)8*8+8,8,8-8.8.8/8/808182828383848586878788898:8;8<8<8=8>8?8@8A8B8C8D8E8F8G8H8I8J8K8L8M8N8O8P8Q8R8S8T8U8V8W8X8X8Y8Y8Z8[8\8]8^8^8_8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o9p9p9q9r9s99t9u9v9w999x99999p9y9z9{9|9}9~99999J9I9K9L9M9N9O9P9Q9R9S9T9W9X9Y9Z9[9\9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s99t9u9v9w9x9y9z9{9|9}9~999999999999999999999999999999999999999V9U9999999999999999999:::::-::;;[;];<<<<<<<<<<<<<<<<<<=============================================================================================>>>> > > > > > > >>>>>>>>>>>>>>>>>>> >!>">#>$>%>&>'>(>)>*>+>,>->.>/>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@eAfAgAhAiAjAjAkAkAlAlAmAnAoApAqArAsAtAuAvAvAwAxAyAzA{A|A}A~AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEE E E E E EEEEEEEEEFFFFFFFFFF F!F"F#F$F%F&F'F(F)F*F+F,F-F.F/F0F1F2F3F4F5F6F7F8F9G:G;H<I=I>I?I@IAIBJCJDJEJFJGJHJIJJJKJLJMJNJOKPKQKRKSKSKTKUKVKWKXKYKZK[K\K]K^K_K`K`KaKbKcKdKeKfKgKhKiKjKkKlKmKnKoKpKqKqKrKsKtKuKvKwKxKyKzK{K|K}K~KKKKKKKKKKKKKKKKLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM|MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNOOO O O O O O O O P P P P P P P P P P P P P P Q Q Q Q Q Q R R R R R S !S "S #S $S %S &S 'S (S )S *S +T ,T -U .U /U 0V 1V 2V 3V 4V 5W 6W 7W 8W 9X :X ;X < = > ? @ A B CY DY EZ FZ FZ GZ HZ IZ JZ KZ LZ MZ NZ O[ P[ Q[ R[ S[ T[ U[ V\ W\ X\ X\ Y\ Z\ [\ \\ ]\ ^\ _\ `\ a] b] b] c] d] e] f] g] h] i] j] k] l] m] n] o] p^ q^ r^ r^ s^ t^ u^ u^ v^ v^ w^ x^ x^ y^ z^ z^ {^ |^ }^ ~^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ _ _ _ _ ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` a a a a a a a b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b b c c c c c c c c c c c !c "c #c $c %c &c 'c (c )d *d +d ,d -d .d /e 0e 0e 1e 2e 3e 4e 5e 6e 7e 8e 9f :f :f ;f <f =f >f ?f @f Af Bf Cf Df Ef Ff Gf Hf If Jf Kg Lg Mg Ng Og Pg Qg Rg Sg Tg Ug VgIg Wg Xg Yg Zg [g \g ]g ^g _g `g ag bg cg dg eg fg gg hg ig jg kg lg m} n o p q r s t u v u w x y z {y | } ~ }      }            j j j j j j j j }  }  } n } n      } k i# ' ' ' }   }  (  } }  3 3 8   8 8 8 8 8 }  < } n < > > > > > > > > ? ? ? ? ? ?  ? @ @ A A A A A B G H H H H I I I K K K K K X X X X  Z Z Z Z Z Z Z Z Z Z Z } n Z Z Z Z Z Z Z Z [ [ [ [ [ [ [ [ [ [ [ [ \ \ \ \ \ \ ] ^ ^ ^ }  ` ! "` #b $b %b &b 'b (b )b *b + , -{b b .b /b 0b 1} 2 3d 4d 5d 6 7 8 9f :f ;g <g = >#morley-1.0.0-Jo9z4xumEmKBIsSgg9Z0MH Util.TypeLits Util.Typeable Util.TypeMichelson.Typed.Scope Util.DefaultUtil.Fcf Util.LensMichelson.ParserMichelson.Parser.Error Util.NamedMichelson.Typed.Sing Util.PeanoMichelson.ErrorPosMichelson.Printer.UtilMichelson.Test.Util%Michelson.Typed.Haskell.Instr.HelpersMichelson.Untyped.AnnotationMichelson.Untyped.EntryPointsMichelson.Untyped.TypeMichelson.Untyped.ExtMichelson.Untyped.ContractMichelson.Typed.TTezos.Crypto.HashTezos.Crypto.UtilUtil.AlternativeUtil.ByteStringUtil.Exception Util.GenericUtil.IOUtil.Instances Util.Markdown Util.PositiveUtil.Test.Ingredients Util.TextMichelson.TextTezos.Crypto.Secp256k1Tezos.Crypto.P256Tezos.Crypto.Ed25519 Tezos.Crypto Tezos.Core Tezos.AddressMichelson.Untyped.ValueMichelson.Untyped.InstrMichelson.Untyped.AliasesMichelson.Runtime.TxDataUtil.TypeTuple.ClassUtil.TypeTuple.THUtil.TypeTuple.InstancesMichelson.Typed.AnnotationMichelson.Typed.ExtractMichelson.Typed.EntryPointsMichelson.Typed.CValueMichelson.Typed.ValueMichelson.Typed.PolymorphicMichelson.Typed.Arith Michelson.DocMichelson.Typed.InstrMichelson.Typed.ConvertMichelson.Typed.AliasesMichelson.Typed.UtilMichelson.Typed.Haskell.Value!Michelson.Typed.Haskell.Instr.Sum%Michelson.Typed.Haskell.Instr.Product Michelson.Typed.Haskell.LooseSumMichelson.Typed.Haskell.DocMichelson.Typed.DocMichelson.TypeCheck.TypesMichelson.TypeCheck.ErrorMichelson.TypeCheck.TypeCheckMichelson.TypeCheck.HelpersMichelson.TypeCheck.ValueMichelson.TypeCheck.ExtMichelson.TypeCheck.InstrMichelson.Test.GenMichelson.Runtime.GStateMichelson.PrinterMichelson.Macro Michelson.LetMichelson.Parser.TypesMichelson.Parser.LexerMichelson.Parser.HelpersMichelson.Parser.ValueMichelson.Parser.AnnotationsMichelson.Parser.TypeMichelson.Parser.ExtMichelson.Parser.InstrMichelson.Parser.MacroMichelson.Parser.LetMichelson.PreprocessMichelson.Interpret.UnpackMichelson.Interpret.PackMichelson.OptimizerMichelson.OpSizeMichelson.InterpretMichelson.Test.DummyMichelson.RuntimeMichelson.Test.UnitMichelson.Test.IntegrationalMichelson.Test.ImportMichelson.FailPatternMichelson.AnalyzerMichelson.Doc.TestUtil.Test.ArbitraryMichelson.TypeType Paths_morleyDataGeneric Michelson*Michelson.UntypedInstr Data.Vinyl FromTupleUtil.TypeTupleMichelson.Typed.Haskell.InstrMichelson.Typed.HaskellMichelson.TypedMichelson.TypeCheckTest.QuickCheckProperty Test.Hspec ExpectationMichelson.Testbase GHC.TypeLits KnownSymbolghc-prim GHC.TypesSymbol TypeError AppendSymbolText:<>::$$:ShowType Data.TypeableeqT ErrorMessageData.Type.EqualityRefl:~:==Data.Type.BoolIf'constraints-0.12-9r4GNEjfdu11xgOuzOy6H1Data.ConstraintwithDictSub:-1data-default-class-0.1.2.0-FeIQ5tLoVZBHMSgrT9zptQData.Default.ClassDefaultdef3first-class-families-0.7.0.0-1E9souF22Kn6FyzRYLu23AFcf.CoreEval"lens-4.19.1-1E66IAG2JhX7QGFcxXMPO9Control.Lens.THmakeLensesWith&megaparsec-8.0.0-9g7AKmV0pGtLHgiBXCxWUText.Megaparsec.ErrorerrorBundlePrettyParseErrorBundle$named-0.3.0.1-GwpuPjBY1xnHurMYYo5M6DNamed.Internal:!:?'singletons-2.5.1-KJmZfbYqxQ32cjJxSvMnMwData.Singletons.Internal applySingSLambdaSingsingSingI#vinyl-0.12.0-IALeOtLPo1cBDYNVTLLh2zData.Vinyl.TypeLevelSZNat++InstrCallStack 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$fDataInstrCallStackPrettier RenderDoc renderDoc isRenderable RenderContextprintDoc printDocB renderOps renderOpsListspaces wrapInParensbuildRenderDoc needsParensdoesntNeedParens addParensassertParensNotNeededleftToShowPanicleftToPrettyPanic failedProp succeededPropqcIsLeft qcIsRight roundtripTestPathBranchLRSomeAnnVarAnnFieldAnnTypeAnn KnownAnnTag annPrefix AnnotationAnnotationUnsafe unAnnotationWithAnn renderAnn renderWEAnnnoAnnann mkAnnotationspecialVarAnnsspecialFieldAnnisValidAnnStartisValidAnnBodyCharunifyAnn ifAnnUnified disjoinVnconvAnn$fDefaultAnnotation$fBuildableAnnotation$fRenderDocAnnotation$fShowAnnotation$fKnownAnnTagTYPETypeTag$fKnownAnnTagTYPEFieldTag$fKnownAnnTagTYPEVarTag$fMonoidAnnotation$fSemigroupAnnotation$fEqAnnotation$fDataAnnotation$fFunctorAnnotation$fGenericAnnotation$fIsStringAnnotation$fFromJSONAnnotation$fToJSONAnnotation$fLiftAnnotationEpNameFromRefAnnErrorInEpNameBadAnnotationEpName EpNameUnsafeunEpName DefEpNameepNameFromParamAnnepNameToParamAnnepNameFromRefAnnepNameToRefAnn$fArbitraryEpName$fDefaultEpName$fBuildableEpName $fBuildableEpNameFromRefAnnError $fShowEpName $fEqEpName $fOrdEpName$fShowEpNameFromRefAnnError$fEqEpNameFromRefAnnErrorCTCIntCNatCStringCBytesCMutezCBoolCKeyHash CTimestampCAddressTTcTKeyTUnit TSignatureTChainIdTOptionTListTSet TOperation TContractTPairTOrTLambdaTMapTBigMap ComparableTaddress Ttimestamp Tkey_hashTboolTmutezTbytesTstringTnatTint compToType typeToComptinttnattstringtbytestmuteztbooltkeyHash ttimestamptaddresstoptiontpairtortyinttynattyunittybooltypairtyortyImplicitAccountParam isAtomicTypeisKey isSignature isComparableisMutez isTimestamp isKeyHashisBoolisString isIntegerisNatisIntisBytes $fBuildableCT $fRenderDocCT$fBuildableComparable$fRenderDocComparable $fBuildableT$fBuildableType $fRenderDocT$fRenderDocType$fRenderDocPrettier$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 $fLiftType$fLiftComparable$fLiftT$fLiftCT 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'toUType buildStackSTcSTKeySTUnit STSignature STChainIdSTOptionSTListSTSet STOperation STContractSTPairSTOrSTLambdaSTMapSTBigMapSCIntSCNatSCStringSCBytesSCMutezSCBool SCKeyHash SCTimestamp SCAddresswithSomeSingCT fromSingCT withSomeSingT fromSingT$fSingITTBigMap $fSingITTMap$fSingITTLambda $fSingITTOr $fSingITTPair$fSingITTContract$fSingITTOperation $fSingITTSet $fSingITTList$fSingITTOption$fSingITTChainId$fSingITTSignature $fSingITTUnit $fSingITTKey $fSingITTc$fSingICTCAddress$fSingICTCTimestamp$fSingICTCKeyHash$fSingICTCBool$fSingICTCMutez$fSingICTCBytes$fSingICTCString $fSingICTCNat $fSingICTCInt $fSingKindCT $fSingKindTProperComparabilityBetterErrorsProperPrintedValBetterErrorsProperUnpackedValBetterErrorsProperPackedValBetterErrorsProperConstantBetterErrorsProperStorageBetterErrorsProperParameterBetterErrors CheckScope checkScopePrintedValScopeUnpackedValScopePackedValScope ConstantScope StorageScopeParameterScopeComparabilityScopeBadTypeForScopeBtNotComparable BtIsOperation BtHasBigMapBtHasNestedBigMap BtHasContract Comparability CanBeComparedCannotBeComparedNestedBigMapsPresenceNestedBigMapsPresentNestedBigMapsAbsentBigMapPresence BigMapPresent BigMapAbsentContractPresenceContractPresentContractAbsent OpPresence OpPresentOpAbsentForbidNonComparableForbidNestedBigMaps ForbidBigMapForbidContractForbidOpFailOnNestedBigMapsFoundFailOnBigMapFoundFailOnOperationFoundHasNoNestedBigMaps HasNoBigMap HasNoContractHasNoOpContainsNestedBigMapsContainsBigMap forbiddenOpforbiddenBigMapforbiddenNestedBigMapsforbiddenContractTypecheckComparabilitycheckOpPresencecheckContractTypePresencecheckBigMapPresencecheckNestedBigMapsPresencecomparabilityPresence opAbsensecontractTypeAbsense bigMapAbsensenestedBigMapsAbsenseproperParameterEviproperStorageEviproperConstantEviproperPackedValEviproperUnpackedValEviproperPrintedValEvi $fHasNoOpt$fHasNoContractt$fHasNoBigMapt$fHasNoNestedBigMapst $fComparablet$fBuildableBadTypeForScope$fCheckScope(%,%)$fCheckScope(%,,%)$fCheckScope(%,,,%)$fCheckScope(%,,,,%)$fCheckScope(%,,,%)0$fCheckScope(%,,%)0$fCheckScopeHasNoContract$fCheckScopeHasNoNestedBigMaps$fCheckScopeHasNoBigMap$fCheckScopeHasNoOp$fCheckScopeComparableblake2b blake2b160sha256sha512B58CheckWithPrefixErrorB58CheckWithPrefixWrongPrefixB58CheckWithPrefixWrongEncodingCryptoParseErrorCryptoParseWrongBase58CheckCryptoParseWrongTagCryptoParseCryptoErrorCryptoParseUnexpectedLengthencodeBase58CheckdecodeBase58CheckdecodeBase58CheckWithPrefix formatImpl parseImpl firstRight deterministic$fBuildableCryptoParseError$fShowCryptoParseError$fEqCryptoParseError$fShowB58CheckWithPrefixErrorsomeNEHexJSONByteStringunHexJSONByteString$fFromJSONHexJSONByteString$fToJSONHexJSONByteString permute2Def permute3Def TextException$fShowTextException$fBuildableTextException$fExceptionTextExceptionApplyConstraintsTyEqSing<|>Over2GenericTypeName mkGenericTreemkGenericTreeVec readFileUtf8 writeFileUtf8appendFileUtf8 withEncoding hSetTranslit$fBuildableIdentity$fBuildableNatural$fDefaultNaturalpostfixLFields HeaderLevelMarkdownnextHeaderLevelmdHeadermdSubsectionTitle mdSubsectionmdBoldmdItalicmdTickedmdRef mdLocalRefmdAnchor mdSeparator mdSpoiler mdCommentmd NamedInnerApplyNamedFunctor.!.?<.!><.?>$fBuildableNamedF $fShowNamedF$fWrappedNamedF$fWrappedNamedF0$fFromJSONNamedF$fFromJSONNamedF0$fToJSONNamedF$fToJSONNamedF0 $fDataNamedF $fOrdNamedF $fEqNamedFRequireLongerOrSameLengthRequireLongerThanLongerOrSameLengthIsLongerOrSameLength LongerThan IsLongerThanTakeDropAtLength KnownPeanopeanoVal FromPeanoToPeanoPeanoSZSS peanoVal' peanoValSing $fSingINatZ $fSingINatS $fKnownPeanoS $fKnownPeanoZ$fRequireLongerThankla$fRequireLongerOrSameLengthkla$fEqSing $fShowSingPositivePositiveUnsafe unPositive mkPositivelengthNE replicateNE $fEqPositive $fOrdPositive$fDataPositive$fShowPositive$fBuildablePositive$fToJSONPositive$fFromJSONPositiveParserExceptionStringLiteralParserExceptionInvalidEscapeSequence InvalidCharCustomParserExceptionUnknownTypeExceptionStringLiteralExceptionOddNumberBytesException WrongTagArgsWrongAccessArgs WrongSetArgsExcessFieldAnnotation0$fShowErrorComponentStringLiteralParserException)$fShowErrorComponentCustomParserException$fBuildableParserException$fExceptionParserException$fShowParserException $fEqStringLiteralParserException"$fDataStringLiteralParserException!$fOrdStringLiteralParserException"$fShowStringLiteralParserException$fEqCustomParserException$fDataCustomParserException$fOrdCustomParserException$fShowCustomParserException$fEqParserExceptionourIngredients headToLowerRSplitKListKNilKCons KnownListklist ReifyList reifyList PatternMatchL PatternMatchRequireAllUnique AllUniqueFailWhen FailUnlessGuard///IsElem failUnlessEvi failWhenEvireifyTypeEqualityrsplit$fReifyListac:$fReifyListkc[] $fKnownListk:$fKnownListk[]TypeErrorUnless symbolValT symbolValT'inTypeErrorUnlessDoNotUseTextErrorMText MTextUnsafeunMTextisMCharmkMText mkMTextUnsafe mkMTextCut writeMText takeMText dropMTextmtqqMText symbolToMText labelToMTextmtextHeadToUpper$fIsStringMText$fFromJSONMText $fToJSONMText$fArbitraryMText $fToTextMText $fShowMText $fEqMText $fOrdMText $fDataMText$fSemigroupMText $fMonoidMText$fContainerMText$fBuildableMText$fHashableMText Signature unSignature SecretKey PublicKey unPublicKeypkBytes detSecretKeytoPublicpublicKeyToBytes mkPublicKeypublicKeyLengthBytessignatureToBytes mkSignaturesignatureLengthBytesformatPublicKeymformatPublicKeyparsePublicKeyformatSignaturemformatSignatureparseSignaturesigncheckSignature$fBuildablePublicKey$fArbitraryPublicKey $fEqPublicKey$fArbitrarySecretKey$fBuildableSignature$fArbitrarySignature$fShowPublicKey$fShowSecretKey $fEqSecretKey$fShowSignature $fEqSignatureformatSecretKeyparseSecretKey$fBuildableSecretKeyKeyHashkhTagkhBytes KeyHashTagKeyHashEd25519KeyHashSecp256k1 KeyHashP256SignatureEd25519SignatureSecp256k1 SignatureP256SignatureGenericPublicKeyEd25519PublicKeySecp256k1 PublicKeyP256keyHashLengthByteshashKey formatKeyHashmformatKeyHash parseKeyHash$fFromJSONPublicKey$fToJSONPublicKey$fFromJSONSignature$fToJSONSignature$fArbitraryKeyHashTag$fBuildableKeyHash$fArbitraryKeyHash$fFromJSONKeyHash$fToJSONKeyHash$fShowKeyHashTag$fEqKeyHashTag$fOrdKeyHashTag$fBoundedKeyHashTag$fEnumKeyHashTag $fShowKeyHash $fEqKeyHash $fOrdKeyHashChainId ChainIdUnsafe unChainId Timestamp unTimestampMutezunMutezmkMutez unsafeMkMuteztoMutezaddMutezunsafeAddMutezsubMutezunsafeSubMutezmulMutez divModMutezdivModMutezInttimestampToSecondstimestampFromSecondstimestampFromUTCTimetimestampPlusSecondsformatTimestampparseTimestamptimestampQuotegetCurrentTime farFuturefarPast mkChainIdmkChainIdUnsafe dummyChainId formatChainIdmformatChainId parseChainId chainIdLength$fBoundedMutez$fBuildableTimestamp$fArbitraryChainId$fBuildableChainId$fBuildableParseChainIdError $fShowMutez $fEqMutez $fOrdMutez $fDataMutez$fGenericMutez $fEnumMutez$fBuildableMutez$fShowTimestamp $fEqTimestamp$fOrdTimestamp$fDataTimestamp$fGenericTimestamp $fShowChainId $fEqChainId$fShowParseChainIdError$fEqParseChainIdError$fFromJSONMutez $fToJSONMutez$fFromJSONChainId$fToJSONChainId$fFromJSONTimestamp$fToJSONTimestampParseContractAddressErrorParseAddressErrorParseAddressWrongBase58CheckParseAddressBothFailedAddress KeyAddressContractAddress ContractHash mkKeyAddressdetGenKeyAddressmkContractAddressRawmkContractHashRaw formatAddressmformatAddress parseAddressunsafeParseAddressunsafeParseContractHash$fFromJSONKeyContractHash$fFromJSONContractHash$fToJSONKeyContractHash$fToJSONContractHash$fArbitraryAddress$fFromJSONKeyAddress$fFromJSONAddress$fToJSONKeyAddress$fToJSONAddress$fBuildableAddress$$fBuildableParseContractAddressError$fBuildableParseAddressError$fShowContractHash$fEqContractHash$fOrdContractHash $fShowAddress $fEqAddress $fOrdAddress$fShowParseContractAddressError$fEqParseContractAddressError$fShowParseAddressError$fEqParseAddressErrorInternalByteStringEltValue'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 $fToJSONEltOriginationOperation ooOriginator ooDelegate ooBalance ooStorage ooContract InstrAbstractEXTDROPNDROPDUPSWAPDIGDUGPUSHSOMENONEUNITIF_NONEPAIRCARCDRLEFTRIGHTIF_LEFTNILCONSIF_CONSSIZE EMPTY_SET EMPTY_MAP EMPTY_BIG_MAPMAPITERMEMGETUPDATEIFLOOP LOOP_LEFTLAMBDAEXECAPPLYDIPDIPNFAILWITHCASTRENAMEPACKUNPACKCONCATSLICEISNATADDSUBMULEDIVABSNEGLSLLSRORANDXORNOTCOMPAREEQNEQLTGTLEGEINTSELFCONTRACTTRANSFER_TOKENS SET_DELEGATECREATE_CONTRACTIMPLICIT_ACCOUNTNOWAMOUNTBALANCECHECK_SIGNATURESHA256SHA512BLAKE2BHASH_KEYSTEPS_TO_QUOTASOURCESENDERADDRESSCHAIN_ID ExpandedOpPrimExSeqEx WithSrcEx ExpandedInstrflattenExpandedOpmkContractAddress$fFromJSONInstrAbstract$fToJSONInstrAbstract$fBuildableInstrAbstract$fRenderDocInstrAbstract$fFromJSONExpandedOp$fToJSONExpandedOp$fBuildableExpandedOp$fRenderDocExpandedOp$fToJSONOriginationOperation$fFromJSONOriginationOperation$fEqInstrAbstract$fShowInstrAbstract$fFunctorInstrAbstract$fDataInstrAbstract$fGenericInstrAbstract$fShowExpandedOp$fEqExpandedOp$fDataExpandedOp$fGenericExpandedOp$fShowOriginationOperation$fGenericOriginationOperationExpandedExtInstrValueTxDatatdSenderAddress tdParameter tdEntrypointtdAmount $fShowTxData $fEqTxData tdAmountL tdEntrypointL tdParameterLtdSenderAddressL RecFromTuple IsoRecTuple recFromTuplederiveRecFromTuple$fRecFromTupleRec$fRecFromTupleRec0$fRecFromTupleRec1$fRecFromTupleRec2$fRecFromTupleRec3$fRecFromTupleRec4$fRecFromTupleRec5$fRecFromTupleRec6$fRecFromTupleRec7$fRecFromTupleRec8$fRecFromTupleRec9$fRecFromTupleRec10$fRecFromTupleRec11$fRecFromTupleRec12$fRecFromTupleRec13$fRecFromTupleRec14$fRecFromTupleRec15$fRecFromTupleRec16$fRecFromTupleRec17$fRecFromTupleRec18$fRecFromTupleRec19$fRecFromTupleRec20$fRecFromTupleRec21$fRecFromTupleRec22$fRecFromTupleRec23$fRecFromTupleRec24gcastEeqPeqParam1eqParam2eqParam3eqExt compareExtcastIgnoringPhantomAnnConvergeErrorNotesNTcNTKeyNTUnit NTSignature NTChainIdNTOptionNTListNTSet NTOperation NTContractNTPairNTOrNTLambdaNTMapNTBigMap starNotesisStarorAnnconverge convergeAnns$fBuildableAnnConvergeError$fEqAnnConvergeError$fShowAnnConvergeError $fEqNotes $fShowNotesAsUType fromUTypemkUType withUTypeMkEntryPointCallResSomeEntryPointCallTSomeEpcForbidOrEntryPointCallTEntryPointCallepcName epcParamProxyepcLiftSequenceEpLiftSequence EplArgHere EplWrapLeft EplWrapRight ParamEpErrorParamEpDuplicatedNamesParamEpUncallableArmArmCoordAcLeftAcRight ArmCoords ParamNotesParamNotesUnsafe unParamNotesParseEpAddressErrorParseEpAddressBadAddressParseEpAddressBadRefAnnParseEpAddressRefAnnError EpAddress eaAddress eaEntryPointformatEpAddressmformatEpAddressparseEpAddressunsafeParseEpAddress mkParamNotesepcCallRootUnsafe epcPrimitivesepcCallRootUnsafe sepcPrimitivesepcNamemkEntryPointCall$fArbitraryEpAddress$fBuildableEpAddress$fBuildableParseEpAddressError$fBuildableArmCoord$fBuildableParamEpError$fBuildableEpLiftSequence$fBuildableEntryPointCallT$fBuildableSomeEntryPointCallT$fEqSomeEntryPointCallT$fShowEpAddress $fEqEpAddress$fOrdEpAddress$fShowParseEpAddressError$fEqParseEpAddressError$fShowParamNotes$fEqParamNotes$fShowArmCoord $fEqArmCoord$fShowParamEpError$fEqParamEpError$fShowSomeEntryPointCallT$fShowEntryPointCallT$fEqEntryPointCallT$fShowEpLiftSequence$fEqEpLiftSequenceCValueCvIntCvNatCvStringCvBytesCvMutezCvBool CvKeyHash CvTimestamp CvAddress $fOrdCValue $fEqCValue $fShowCValueSomeConstrainedValue'SomeConstrainedValue SomeValue' SomeValueVCVKeyVUnit VSignatureVChainIdVOptionVListVSetVOp VContractVPairVOrVLamVMapVBigMapRemFailRfNormal RfAlwaysFails ContractOut ContractOut1 ContractInp ContractInp1CreateContract ccOriginator ccDelegate ccBalance ccStorageValccContractCode SetDelegate sdMbKeyHashTransferTokensttTransferArgumentttAmount ttContract Operation'OpTransferTokens OpSetDelegateOpCreateContractrfMerge rfAnyInstr rfMapAnyInstraddressToVContractbuildVContractcompileEpLiftSequence$fBuildableSetDelegate $fEqRemFail$fBuildableCreateContract$fBuildableTransferTokens$fEqOperation'$fBuildableOperation'$fEqSomeValue'$fShowSetDelegate$fEqSetDelegate$fShowTransferTokens$fEqTransferTokens$fShowSomeConstrainedValue'$fShowSomeValue' $fShowRemFail$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'CompareLsrLslNotXorAndOrNegAbsMulAdd UnaryArithOp UnaryArithResevalUnaryArithOp ArithErrorMutezArithErrorShiftArithErrorArithErrorType AddOverflow MulOverflow SubUnderflow LslOverflow LsrUnderflowArithOpArithResevalOp compareOp$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$fUnaryArithOpTYPEEq'CInt$fUnaryArithOpTYPENeqCInt$fUnaryArithOpTYPELtCInt$fUnaryArithOpTYPEGtCInt$fUnaryArithOpTYPELeCInt$fUnaryArithOpTYPEGeCInt$fShowArithErrorType$fEqArithErrorType$fOrdArithErrorType$fShowArithError$fEqArithError$fOrdArithError ContractDoc cdContents cdDefinitionscdDefinitionsSetcdDefinitionIdsSubDocDocBlock DocSectionDocElemdeItemdeSubSomeDocDefinitionItem SomeDocItemDocSectionNameStyleDocSectionNameBigDocSectionNameSmall DocItemRef DocItemNoRefDocItemPlacementKindDocItemInlinedDocItemInDefinitions DocItemIdDocItemDocItemPositionDocItemPlacementdocItemSectionNamedocItemSectionDescriptiondocItemSectionNameStyle docItemRefdocItemToMarkdowndocItemDependencies docItemsOrderdocItemPositiondocDefinitionRef deIsAtomicdocItemToBlocklookupDocBlockSectionsubDocToMarkdown$fOrdSomeDocDefinitionItem$fEqSomeDocDefinitionItem$fShowSomeDocItem$fShowDocSection $fEqDocItemId$fOrdDocItemId$fShowDocItemId$fEqDocItemPos$fOrdDocItemPos$fShowDocItemPos$fBuildableDocItemPosDCommentGitRepoSettingsgrsMkGitRevision DGitRevisionDGitRevisionKnownDGitRevisionUnknown DDescriptionDName DocGrouping cdContentsLcdDefinitionIdsLcdDefinitionsLcdDefinitionsSetLcontractDocToMarkdowndocGroupContentmorleyRepoSettingsmkDGitRevision$fMonoidContractDoc$fSemigroupContractDoc$fShow->$fDocItemDName$fDocItemDDescription$fDocItemDGitRevision$fDocItemDComment FullContractfcCodefcParamNotesSafe fcStoreNotesExtInstr TEST_ASSERTPRINTDOC_ITEMunPrintCommentInstrWithNotesInstrWithVarNotes FrameInstrSeqNopExtNestedDocGroupAnnCARAnnCDRCONCAT' ConstraintDUGConstraintDUG' ConstraintDIGConstraintDIG'ConstraintDIPNConstraintDIPN' PackedNotes mkStackRef fcParamNotesmapFullContractCode$fShowPackedNotes$fIsStringPrintComment $fNFDataInstr $fMonoidInstr$fSemigroupInstr$fSemigroupPrintComment$fMonoidPrintComment$fShowExtInstr$fShowFullContract $fShowInstrconvertContractconvertFullContract untypeValue instrToOps $fEqInstr OperationCtorEffectsAppceaNameceaApplyEffects DfsSettings dsGoToValuesdsCtorEffectsAppdfsInstr dfsFoldInstrdfsModifyInstr linearizeLeft isStringValue isBytesValueallAtomicValues$fShowCtorEffectsApp$fDefaultDfsSettings$fShowDfsSettingsIsoValuesStack toValStack fromValStackToTs'ToTsGenericIsoValue GIsoValue GValueTypeBigMapunBigMap ContractRef crAddress crEntryPointSomeEntryPointCall IsComparable AnyIsoValue SomeIsoValueToT'IsoValueToTtoValfromVal IsoCValueToCTtoCValfromCValcoerceContractRefcontractRefToAddrtotsKnownLemmatotsAppendLemma$fIsoCValueTimestamp$fIsoCValueKeyHash$fIsoCValueEpAddress$fIsoCValueAddress$fIsoCValueMutez$fIsoCValueByteString$fIsoCValueBool$fIsoCValueText$fIsoCValueMText$fIsoCValueNatural$fIsoCValueInteger $fGIsoValueU1$fGIsoValue:*:$fGIsoValue:+: $fGIsoValueM1 $fGIsoValueK1$fIsoValueBigMap$fIsoValue(,,,,,,)$fIsoValue(,,,,,)$fIsoValue(,,,,)$fIsoValue(,,,)$fIsoValue(,,)$fIsoValueOperation' $fIsoValueMap $fIsoValueSet $fIsoValue(,)$fIsoValueEither$fIsoValueMaybe $fIsoValue[] $fIsoValue()$fIsoValueChainId$fIsoValueSignature$fIsoValuePublicKey$fIsoValueEpAddress$fIsoValueAddress$fIsoValueTimestamp$fIsoValueKeyHash$fIsoValueMutez$fIsoValueByteString$fIsoValueBool$fIsoValueText$fIsoValueMText$fIsoValueNatural$fIsoValueInteger$fIsoValueContractRef$fBuildableContractRef$fIsoValuesStack:$fIsoValuesStack[] $fEqBigMap $fShowBigMap$fDefaultBigMap$fSemigroupBigMap$fMonoidBigMap$fEqContractRef$fShowContractRef$fIsoValueNamedF$fIsoValueNamedF0$fIsoValueIdentity InstrUnwrapCGCaseBranchInput GCaseClauses CaseClauses CaseClauseCaseClauseParam InstrCaseCMyCompoundType InstrWrapC CtorOnlyFieldCtorHasOnlyField GetCtorFieldIsPrimitiveValueAppendCtorFieldAxiomAppendCtorFieldExtractCtorField 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$fGenericMyTypeWithNamedField$fIsoValueMyTypeWithNamedFieldInstrConstructCConstructorFieldTypesFieldConstructorInstrSetFieldCInstrGetFieldC GetFieldType instrGetField instrSetFieldinstrConstruct$fGInstrGetname:*::f$fGInstrGetname:*::f0$fGInstrGetnameK1[]f'$fGInstrGetnameM1pathf$fGInstrSetFieldname:*::f$fGInstrSetFieldname:*::f0$fGInstrSetFieldnameK1[]f'$fGInstrSetFieldnameM1pathf$fGInstrConstructK1$fGInstrConstruct:+:$fGInstrConstructU1$fGInstrConstruct:*:$fGInstrConstructM1$fGenericMyType2$fIsoValueMyType2 LooseSumC ComposeResult ComposeOkComposeCtorNotFoundComposeFieldTypeMismatch toTaggedVal fromTaggedVal$fMonoidComposeResult$fSemigroupComposeResult $fGLooseSumV1$fGLooseSum:+: $fGLooseSumM1$fGAccessField:*:$fGAccessFieldU1$fGAccessFieldK1$fGAccessFieldM1$fGLooseSumM10$fFunctorComposeResultPolyTypeHasDocC GTypeHasDoc IsHomomorphicHaveCommonTypeCtor DStorageTypeDTypeSomeTypeWithDocTypeDocMichelsonRepTypeDocHaskellRep TypeHasDoc typeDocNametypeDocMdDescriptiontypeDocMdReferencetypeDocDependenciestypeDocHaskellReptypeDocMichelsonRep WithinParensADTRep buildADTRepapplyWithinParenstypeDocDependencies'customTypeDocMdReferencehomomorphicTypeDocMdReferencepoly1TypeDocMdReferencepoly2TypeDocMdReferencegenericTypeDocDependencieshomomorphicTypeDocHaskellRepconcreteTypeDocHaskellRepconcreteTypeDocHaskellRepUnsafehaskellRepNoFieldshaskellRepStripFieldPrefixhomomorphicTypeDocMichelsonRepconcreteTypeDocMichelsonRep!concreteTypeDocMichelsonRepUnsafe$fHaveCommonTypeCtorkkaa$fHaveCommonTypeCtorkkacbc$fIsHomomorphicka$fIsHomomorphicka0$fTypeHasDocNamedF$fTypeHasDoc()$fTypeHasDocSignature$fTypeHasDocPublicKey$fTypeHasDocEpAddress$fTypeHasDocAddress$fTypeHasDocTimestamp$fTypeHasDocKeyHash$fTypeHasDocMutez$fTypeHasDocByteString$fTypeHasDocBool$fTypeHasDocNatural$fTypeHasDocInteger$fGTypeHasDocV1$fGTypeHasDoc:+:$fGTypeHasDocM1$fTypeHasDocOperation'$fTypeHasDocMText$fDocItemDType $fOrdDType $fEqDType $fShowDType$fDocItemDStorageType$fGProductHasDocU1$fGProductHasDocM1$fGProductHasDocM10$fGProductHasDoc:*:$fGTypeHasDocM10$fTypeHasDoc(,,,,,,)$fTypeHasDoc(,,,,,)$fTypeHasDoc(,,,,)$fTypeHasDoc(,,,)$fTypeHasDoc(,,)$fTypeHasDocContractRef$fTypeHasDoc(,)$fTypeHasDocEither$fTypeHasDocMaybe$fTypeHasDoc[]$fTypeHasDocBigMap$fTypeHasDocMap$fTypeHasDocSet$fIsStringDocTypeRepLHS$fBuildableDocTypeRepLHS buildInstrDocmodifyInstrDoccutInstrNonDoc TcExtFrames BoundVars SomeContract SomeCValue:--:SomeNotedValue:::: SomeInstr:/ SomeInstrOut::: AnyOutInstrSomeHSTHSTSNil::&-:&mapSomeContract noBoundVars$fEqHST $fShowHST $fEqSomeHST$fShowSomeInstrOut$fShowSomeInstr$fShowSomeNotedValue$fShowSomeContract $fShowSomeHSTExtErrorLengthMismatchVarError TypeMismatch TyVarMismatchStkRestMismatchTestAssertErrorInvalidStackReference StackSizeTCErrorTCFailedOnInstrTCFailedOnValueTCContractErrorTCUnreachableCode TCExtError TCTypeErrorAnnError TypeEqError StackEqErrorUnsupportedTypesInvalidValueTypeNotEnoughItemsOnStackIllegalEntryPointUnknownContractEntryPointNotFoundIllegalParamDecl NegativeNat MutezOverflowInvalidAddressInvalidKeyHashInvalidTimestampNotEnoughItemsInstr NotEnoughDrop NotEnoughDip NotEnoughDig NotEnoughDug$fBuildableNotEnoughItemsInstr$fBuildableTCTypeError$fBuildableExtError$fExceptionTCError $fShowTCError$fBuildableTCError$fShowNotEnoughItemsInstr$fEqNotEnoughItemsInstr$fShowTCTypeError$fEqTCTypeError$fShowStackSize $fEqStackSize $fEqExtError $fEqTCError TypeCheckEnv tcExtFramestcContractParam tcContractsTcOriginatedContracts TypeCheckTcInstrHandlerTypeCheckInstrTcResulttcContractParamL tcContractsL tcExtFramesL runTypeCheckrunTypeCheckIsolatedrunTypeCheckInstrIsolated mapTCErrorderiveSpecialFNsderiveSpecialVNderiveVN deriveNsOrderiveNsOption convergeHSTEl convergeHSTonLefthstToTseqHSTeqHST1 lengthHSTensureDistinctAsccheckEqTeqType checkEqHSTonTypeCheckInstrErrtypeCheckInstrErrtypeCheckInstrErr'onTypeCheckInstrAnnErr typeCheckImpl matchTypesmemImplgetImplupdImplsizeImpl sliceImpl concatImpl' concatImpl arithImpladdImpledivImplsubImplmulImplunaryArithImpltypeCheckCValuetypeCheckValImpl typeCheckExttypeCheckContract typeCheckListtypeCheckValuetypeVerifyValuetypeVerifyTopLevelTypetypeCheckTopLevelType minTimestamp maxTimestamp midTimestamp$fArbitraryTimestamp$fArbitraryMutez$fArbitraryCValue$fArbitraryValue'$fArbitraryValue'0$fArbitraryValue'1$fArbitraryValue'2$fArbitraryCValue0$fArbitraryCValue1$fArbitraryCValue2 AddressStateASSimple ASContract ContractState csBalance csStorage csContractcsTypedContractcsTypedStorage$fBuildableContractState$fFromJSONContractState$fToJSONContractState$fBuildableAddressState$fShowAddressState$fGenericAddressState$fShowContractStateGState gsChainId gsAddresses asBalance$fFromJSONAddressState$fToJSONAddressState $fShowGState gsAddressesL gsChainIdLGStateUpdateErrorGStateAddressExistsGStateUnknownAddressGStateNotContract GStateUpdate GSAddAddressGSSetStorageValue GSSetBalanceSomeContractAndStorage scsContract scsStoragegetTypedContractgetTypedStoragegetTypedContractAndStoragegenesisKeyHashesgenesisAddressesgenesisKeyHashgenesisAddressgenesisAddress1genesisAddress2genesisAddress3genesisAddress4genesisAddress5genesisAddress6 initGState readGState writeGState applyUpdate applyUpdatesextractAllContracts$fFromJSONGState$fToJSONGState$fExceptionGStateParseError$fBuildableGStateUpdate$fBuildableGStateUpdateError$fShowGStateParseError$fShowGStateUpdate$fShowGStateUpdateErrorprintUntypedContractprintTypedContractprintTypedFullContractprintTypedValueprintSomeContractMacroCASETAGACCESSSET CONSTRUCTVIEWVOIDCMPIFXIFCMPFAILPAPAIRUNPAIRCADRSET_CADRMAP_CADRDIIPDUUPASSERTASSERTX ASSERT_CMP ASSERT_NONE ASSERT_SOME ASSERT_LEFT ASSERT_RIGHTIF_SOMEIF_RIGHT ParsedValue ParsedInstrParsedUExtInstrParsedOpPrimMacLMac 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'wordword'string'parensbracesbrackets brackets' semicoloncommavarID sepEndBy1sepBy2mkParserparseDefpositivemparensvalue' stringLiteral bytesLiteral intLiteralmkLetValnotenoteVnoteDef noteV2DefnotesTVF notesTVF2 notesTVF2DefnotesVFnotesTVnotesTF fieldTypetype_ comparableextInstr printComment stackType primInstrops'cmpOppairOpmapOpmacropairMac mapCadrMacifCmpMacletBlockletTypemkLetMac parseNoEnvprogramvalue parseValueparseExpandValue codeEntryutypeQtransformStringstransformBytes UnpackError unUnpackError unpackValue unpackValue' unpackInstr'decodeContract$fExceptionUnpackError$fBuildableUnpackError$fShowUnpackError$fEqUnpackError packValue packValue' encodeValue'packT' packCode'encodeIntPayload packNotedT'Rule OptimizerConf gotoValuesrulesetoptimizeoptimizeWithConf defaultRulesdefaultRulesAndPushPackorRule orSimpleRule$fDefaultOptimizerConfOpSizeunOpSizeopSizeHardLimitsmallTransferOpSize instrOpSizeexpandedInstrsOpSize valueOpSize$fMonoidOpSize$fSemigroupOpSize$fAnnsOpSizeVarargOpSize$fAnnsOpSizeVararg->$fAnnsOpSizeVararg->0 $fShowOpSize $fEqOpSize $fOrdOpSizeEvalOpInterpreterState isMorleyLogsisRemainingStepsRemainingSteps SomeItStackContractReturn MorleyLogs unMorleyLogsInterpretResultiurOps iurNewStorage iurNewStateInterpretErrorRuntimeFailureIllTypedContract IllTypedParamIllTypedStorageUnexpectedParamTypeUnexpectedStorageTypeMichelsonFailedMichelsonFailedWithMichelsonArithErrorMichelsonGasExhaustionMichelsonFailedTestAssertMichelsonAmbigousEpRef ContractEnvceNow ceMaxSteps ceBalance ceContractsceSelfceSourceceSenderceAmount ceChainId noMorleyLogsinterpretUntypedhandleContractReturn interpretinterpretInstrrunInstr runInstrNoGas runUnpack$fBuildableMichelsonFailed$fEqMichelsonFailed$fBuildableInterpretError$fEqMorleyLogs$fShowMorleyLogs$fDefaultMorleyLogs$fBuildableMorleyLogs$fGenericInterpretError$fShowRemainingSteps$fEqRemainingSteps$fOrdRemainingSteps$fBuildableRemainingSteps$fNumRemainingSteps$fShowInterpreterState$fShowInterpretResult$fShowInterpretError$fShowMichelsonFaileddummyNow dummyMaxStepsdummyContractEnvdummyOrigination ExecutorRes _erGState _erOperations _erUpdates_erInterpretResults_erSourceAddress_erRemainingSteps ExecutorOp OriginateOp TransferOp$fShowExecutorOp$fShowExecutorRes ExecutorErrorExecutorError'EEUnknownContractEEInterpreterFailedEEAlreadyOriginatedEEUnknownSenderEEUnknownManagerEENotEnoughFundsEEZeroTransactionEEFailedToApplyUpdatesEEIllTypedContractEEIllTypedStorageEEIllTypedParameterEEUnknownEntrypointerInterpretResults erUpdates parseContractparseExpandContractreadAndParseContractprepareContractoriginateContract runContracttransfer executorPuretypeCheckWithDb$fSemigroupExecutorRes$fExceptionExecutorError'$fBuildableExecutorError'$fShowExecutorError'ContractPropValidator contractPropcontractPropValhasEpcontractHasEntryPointsmatchContractEntryPointsvalidateStorageIsValidationErrorUnexpectedExecutorErrorUnexpectedTypeCheckErrorExpectingInterpreterToFailIncorrectUpdatesIncorrectStorageUpdateInvalidStorageStoragePredicateMismatchInvalidBalanceUnexpectedUpdatesCustomValidationErrorIntegrationalScenarioIntegrationalScenarioMSuccessValidatorIntegrationalValidator$fBuildableScenarioBranchName$fBuildableAddressName$fExceptionValidationError$fBuildableValidationError$fShowExpectedStorage$fShowExpectedBalance$fShowAddressName$fShowValidationErrorintegrationalTestExpectationintegrationalTestProperty originate tOriginate tTransfervalidateintegrationalFail modifyNowsetNow rewindTime setMaxSteps withSender setChainId branchout?-offshootexpectAnySuccessexpectNoUpdatesexpectNoStorageUpdates expectStorageexpectStorageUpdateexpectStorageUpdateConstexpectStorageConsttExpectStorageConst expectBalancecomposeValidatorscomposeValidatorsListexpectGasExhaustionexpectMichelsonFailed$fBuildableScenarioErrorImportContractErrorICEUnexpectedParamTypeICEUnexpectedStorageTypeICEParse ICETypeChecktestTreesWithContracttestTreesWithUntypedContracttestTreesWithTypedContractconcatTestTreesspecWithContractspecWithTypedContractspecWithUntypedContract readContractimportContractimportUntypedContract$fExceptionImportContractError$fBuildableImportContractError$fShowImportContractError$fEqImportContractErrorTypicalFailWithConstantScope'typicalFailWithTagisTypicalFailWithmodifyTypicalFailWith$fConstantScope'a AnalyzerResarConstStrings arConstBytes arErrorTagsanalyze$fMonoidAnalyzerRes$fSemigroupAnalyzerRes$fBuildableAnalyzerRes$fShowAnalyzerRes$fEqAnalyzerResDocTest dtDeclLocdtDescdtSuite mkDocTestexcludeDocTestexcludeDocTests runDocTestsexpectDocTestFailureforEachContractLayerforEachContractDocItemtestContractNameAtToptestDocNotEmptytestNoAdjacentDescriptions testDocBasic$fBuildableDocTest $fShowDocTest $fEqDocTestrunGen$fArbitraryComparable$fToADTArbitraryComparable $fArbitraryCT$fToADTArbitraryCT $fArbitraryT$fToADTArbitraryT$fArbitraryType$fToADTArbitraryType$fArbitraryElt$fToADTArbitraryElt$fToADTArbitraryValue'$fArbitraryInstrAbstract$fToADTArbitraryInstrAbstract$fArbitraryContract'$fToADTArbitraryContract'$fArbitraryAnnotation$fToADTArbitraryAnnotation$fToADTArbitraryMutez$fArbitraryExpandedOp$fToADTArbitraryExpandedOp$fArbitraryInstrCallStack$fToADTArbitraryInstrCallStack$fArbitraryLetName$fToADTArbitraryLetName$fArbitrarySrcPos$fToADTArbitrarySrcPos$fArbitraryPos$fToADTArbitraryPos$fArbitraryExtInstrAbstract$fArbitraryStackTypePattern$fArbitraryTyVar$fArbitraryVar$fArbitraryInternalByteStringGHC.Basemempty_rcWillNeedParensTrue-wl-pprint-text-1.2.0.1-Ii8GVfRp5HKEISHsOwQWMrText.PrettyPrint.Leijen.TextDoc text-1.2.3.1Data.Text.InternalData.Text.Internal.BuilderBuilderdoRender(QuickCheck-2.13.2-1FftnVviu6BCWJanU0jy5VTest.QuickCheck.Property"tasty-1.2.3-Lu2PXUNBcm6Elx8idIMxKuTest.Tasty.CoreTestTreeChar GHC.MaybeNothingBoolFalse SomeSingTSomeSingData.Typeable.InternalTypeable SomeSingCTtoSingCTtoSingfromSingtoSingT D:R:SingT0 D:R:SingCT0FailOnNonComparableFailOnContractFound&universum-1.6.1-LZBxAqSxrQs6W7PvqgzcwoUniversum.TypeOpsEachContainsContract ContainsOpforbiddenOpEviforbiddenContractTypeEviversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName Data.EitherRightLeftsomeNonEmpty Fcf.UtilsTyEqmdEscapeAnchorRequireLongerOrSameLength'RequireLongerThan'OfLengthWithTail Data.Data)tasty-ant-xml-1.1.6-lfwv4wuLKY3eSIxLo76NCTest.Tasty.Runners.AntXML antXMLRunnerinvalidMCharErrorSecretKeyEd25519SecretKeySecp256k1 SecretKeyP256 GHC.NaturalNaturalWordJust chainIdPrefixbytestring-0.10.8.2Data.ByteString.Internal ByteStringgcast Data.ProxyProxy GHC.ClassescompareverifyParamNoteswithEpLiftSequence DocItemPosEqOrddocItemToMarkdownFulldocItemsOrderByIddocBlockToMarkdowndocItemToBlockGeneralDGitRevisionInfoGHC.ShowShowceaBottomToTop<>analyzeInstrFailureGInstrCaseBranch GInstrCase GInstrWrapLNRequireFound GLookupNamedGetNamedLookupNamedResultfailWithWrongCtorGInstrConstructGInstrSetField GInstrGetNamedF GAccessField GLooseSumPolyCTypeHasDocCGProductHasDoc DocTypeRepLHSmapADTRepFieldsbuildFieldNamemodifyInstrAllDoctypeCheckMapVal checkVarscheckFncheckStackTypecreateStackRef typeCheckNEtypeCheckInstr genericIfgenesisAddressesNumgenesisSecrets addAddresssetStorageValue setBalanceLetletInneraddLetletNamecontract TaggedDecoder decodeWithTagtdTag tdDecoder?getByteStringCopygetRemainingByteStringCopy expectTag unknownTag expectDescTag manyForcedmany#:finalizeDecoder decodeLength decodeAsList decodeIntdecodeTypeCheckLam decodeNoAnn decodeAnns encodeValue encodeAsList encodeList encodeString encodeBytes encodeMap encodeNumeric encodeInstrs encodeInstrencodeWithAnnsencodeVarNotedInstrencodeNotedInstrpushPacklinearizeAndReapplyfixpoint applyOnceadapter whileApplies annsOpSize runInstrImpl runArithOp withStackElemGHC.IO.Handle.FDstdinexecutorIO executeOneOp_isInterpreterLog_isExecutorResult_isContractsNames _isSenderExecutorResOrError ScenarioError ValidatedScenarioBranchName/hspec-expectations-0.8.2-JGqzAaMw3jpJhPKqSPpGFATest.Hspec.ExpectationsregisterInterpretationIfNeeded putResultemptyScenarioBranchappendScenarioBranchGHC.IO.Exception IOExceptionFailWithStringFailWithConstantPairFailWithStackValue/tasty-hunit-compat-0.1.0-7fQdqERWwFSJmf00wTwFqSTest.Tasty.HUnittestCase forEachLayer testDescriptionsAreWellFormatted genRareTypegenRareT