# Y 4             !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !!!"""""""""""""""""##$$$ %&&&&&&&&&&&&&&&&&&&&&&&&&&&'((((((((((((((()**      !" # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F+G+H+I+J+K+L+M+N+O+P+Q+R+S+T+U+V+W+X+Y+Z+[+\+]+^+_+`+a+b+c d e f g h i j k l m n o p q r s t u v w x y z { | } ~     ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,-----------------------------------------.........................................////////////////// / / / / //////////////////0 0!0"0#0$0%0&0'0(0)0*0+0,0-0.0/000102030405060708090:0;0<0=0>0?0@0A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u1v1w1x1y1z1{1|1}1~1111111111111111111111111111111111111111111111111111111111111111222222222222222222222222222222233333333333333333333333333333333333333333334 4 4 5 5 5555555555555555555 5!5"5#5$5%5&5'5(5)5*5+5,5-5.5/505152535455565758595:5;5<5=5>5?5@5A5B5C5D5E5F5G5H5I5J5K5L5M5N5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5\5]5^5_5`6a6b6c6d6e6f6g6h6i6j6k6l6m6n6o6p6q6r6s6t6u6v6w6x6y6z6{6|6}6~6666666666666666667777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777788899999999 9 9 9 9 99999:::;<<<<<<<<<< <!<"<#<$<%<&<'<(<)<*<+<,<-<.</<0123456789=:=;=<===>=?=@=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@2A3A4A5A6A7A8A9A:A;A<A=A>A?A@AAABACADAEAFAGAHAIAJAKALAMANAOAPAQARASATAUAVAWAXAYAZA[A\A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoBpBqBrBsBtBuBvBwBxByBzB{B|B}B~BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC C C C C CCCCCCCCCCCCCCCCCCC C!C"C#C$C%C&C'C(C)C*C+C,C-C.C/C0C1C2C3C4C5C6C7C8C9C:C;C<C=C>C?C@CACBCCCDCECFCGCHCICJCKCLCMCNDODPDQDRDSDTDUDVDWDXDYDZD[D\D]D^D_D`DaDbDcDdDeDfDgDhDiDjDkDlDmDnDoDpDqDrDsDtDuDvDwDxDyDzD{D|D}D~DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEFFFFFFFFF F F F F F F F F F F F F F F                    ! " # $ % & ' ( ) * + , - . / 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 vG wG xG yG zG {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 G G G G G G G G G G G G G G G G G G G H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H I I I I I I I I I I I I I I I I I I J J J J J J J J J J K K K L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L !L "L #L $L %L &L 'L (L )L *L +L ,L -L .L /L 0L 1L 2L 3L 4L 5L 6L 7L 8L 9L :L ;L <L =L >L ?L @L AL BL CL DL EL FL GL HL IL JL KL LL ML NL OL PL QL RL SL TL UL VL WL XL YL ZL [L \L ]L ^L _L `L aL bL cL dM eM fM gM hM iM jM kM lN mN nN oN pN qN rN sN tN uN vN wN xN yN zN {N |N }N ~N N N N N N 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 O O O O P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P Q Q Q Q Q Q R R R R R R R R R R R R R !R "R #R $R %R &R 'R (R )R *R +R ,R -R .R /R 0R 1R 2R 3R 4R 5R 6R 7R 8R 9R :R ;R <R =S >S ?S @S AS BS CS DS ES FS GS HS IS JS KS LS MS NS OS PS QS RS SS TS US VS WS XS YS ZS [S \S ]S ^S _S `S aT bT cU dV eV fV gV hV iV jV kV lV mV nW oW pW qW rW sW tW uW vW wW xW yW zW {W |W }X ~X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X Y Y Y Y Y Y Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z !Z "Z #Z $Z %Z &Z 'Z (Z )Z *Z +Z ,Z -Z .Z /Z 0Z 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` qa ra sa tb ub vb wc xc yc zc {c |c }d ~d d d d d e e e e f f g g g g g h h h h h h h h h h h i i i i i i i i i i i i i i i i i i i i i i j j j j j j j j j k k k k k k k k k k k k k k l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l !l "l #l $l %l &l 'l (l )l *m +m ,m -m .n /n 0n 1n 2n 3n 4n 5n 6n 7n 8n 9n :n ;n <n =n >n ?n @n An Bn Cn Dn En Fn Gn Hn In Jn Kn Ln Mn Nn On Pn Qn Rn Sn Tn Un Vn Wn Xn Yn Zn [n \n ]n ^n _n `n an bn cn dn en fo go ho io jo ko lo mo no oo po qo ro so to up vp wp xp yp zp {q |q }q ~q q q q q q q qyNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp&morley#Encode a number as tezos does this.>In the Tezos reference implementation this encoding is called zarith.&&None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp'morleyA new type that can wrap values so that the RenderDoc instances of the combined value can have a different behavior for the pretty printer.)morleyGeneralize converting a type into a Text.PrettyPrint.Leijen.Text.Doc. Used to pretty print Michelson code and define Fmt.Buildable instances.+morleyWhether a value can be represented in Michelson code. Normally either all values of some type are renderable or not renderable. However, in case of instructions we have extra instructions which should not be rendered. Note: it's not suficcient to just return   for such instructions, because sometimes we want to print lists of instructions and we need to ignore them complete (to avoid putting redundant separators).,morley/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.-morleyConvert   to   with a line width of 80..morleyConvert   to   in the same maner as -./morleyConvert   to   in the same maner as -.0morleyLGeneric way to render the different op types that get passed to a contract.3morley#Create a specific number of spaces.4morleyCWrap documents in parentheses if there are two or more in the list.5morley#Turn something that is instance of ) into a  ". It's formatted the same way as - 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.html6morley ParensNeeded constant.7morley ParensNeeded constant.8morleyAdd parentheses if needed.9morleygEnsure parentheses are not required, for case when you cannot sensibly wrap your expression into them.'()*+,-./0123456789)*+'(-./012345,6789None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp:morleyJPath to a leaf (some field or constructor) in generic tree representation.;morleyQWhich branch to choose in generic tree representation: left, straight or right. =P is used when there is one constructor with one field (something newtype-like).The reason why we need = can be explained by this example: data A = A1 B | A2 Integer data B = B Bool Now we may search for A1 constructor or B constructor. Without =, in both cases path will be the same ([L]).:;>=<;>=<:None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp morleyDCheck that Generic representation for a constructor has given field  fieldName. morleyCheck that Generic   has given field  fieldName in a given constructor conName. morley#Actual recursive implementation of  . morley9Check whether all fields described for given constructor conName are present in the datatype.LThis family also checks whether the constructor is present and fails with a  otherwise. morley%Check whether given constructor name conName is present in   of a datatype. morley$Actual recursive implementation for ?.?morley^This type family checks that field descriptions mention only existing constructors and fields.When descrR is empty this family does nothing, to avoid breaking for built-in, non-ADT types.When descr' is not empty, this family will demand   instance for typ and fail with a  if there none.@morleyValue-level counterpart to A.Amorley8Description of constructors and fields of some datatype.pThis type is just two nested maps represented as associative lists. It is supposed to be interpreted like this: X[(Constructor name, (Maybe constructor description, [(Field name, Field description)]))]"Example with a concrete data type: :data Foo = Foo { fFoo :: Int } | Bar { fBar :: Text } deriving (Generic) type FooDescriptions = '[ '( "Foo", '( 'Just "foo constructor", , '[ '("fFoo", "some number") ]) ) , '( "Bar", '( 'Nothing, , '[ '("fBar", "some string") ]) ) ]?@AA@?rNone8!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpBmorleyCompute a cryptographic hash of a bytestring using the Blake2b_256 cryptographic hash function. It's used by the BLAKE2B instruction in Michelson.Cmorley`Compute a cryptographic hash of a bytestring using the Blake2b_160 cryptographic hash function.Dmorley[Compute a cryptographic hash of a bytestring using the Sha256 cryptographic hash function.Emorley[Compute a cryptographic hash of a bytestring using the Sha512 cryptographic hash function.BCDEBCDENone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpRFmorleyOptions that we use in morley-based packages (including morley ) by default.FFNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp3)Gmorley*Field annotation for the entire parameter.QmorleyAn Q contains all the typefield variable Rs , with each group in order, associated with an entity. Note that in its rendering/show instances the unnecessary annotations will be omitted, as well as in some of the functions operating with it. Necessary Rds are the ones strictly required for a consistent representation. In particular, for each group (tf v): - if all annotations are ]* they are all omitted - if one or more ] follow a non-empty ^', they are omitted - if one or more ] precede a non-empty ^%, they are kept - every non-empty ^p is obviously kept This is why order for each group is important as well as separation of different groups of Rs.Rmorley 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: %|%%|%|[:%][_0-9a-zA-Z][_0-9a-zA-Z.%@]*WmorleyAn Q without any R.XmorleyAn Q with only a single R (of any kind).YmorleyAn Q with several Rs of the same kind.ZmorleyAn Q built from all 3 kinds of R.[morleyReturns   if all Rs in the Set are unnecessaryempty]. False otherwise.\morleyReturns the amount of R;s that are necessary for a consistent representation. See Q. morleyRemoves all unnecessary Rs. See Q. morleyRemoves all unnecessary Rs from a list of the same type morleyRenders a single RZ, this is used in every rendering instance of it. Note that this also renders empty ones/]s because a single RA does not have enough context to know if it can be omitted, use X! if you want to hide it instead. morleyRenders a list of R#s, omitting unnecessary empty ones/]'. This is used (3 times) to render an Q.^morley Makes an R" from its textual value, prefix (%@*:) excluded Throws an error if the given   contains invalid characters_morley Makes an R" 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 b and c.amorley3The only special Field Annotation, only allowed in PAIR, LEFT and RIGHTH instructions, prefix (%) excluded. This does not respect the rules of b and c.bmorley Checks if a  6 is valid to be the first of an annotation, prefix (%@8:) excluded, the ones following should be checked with cB instead. Note that this does not check Special Annotations, see ` and acmorley Checks if a  O is valid to be part of an annotation, following a valid first character (see b) and the prefix (%@<:). Note that this does not check Special Annotations, see ` and a!GHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg!RSTVUQWZ[\XYOPKJIHGNML]^_`abcdefgNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp8morley>Since Babylon parameter type can have special root annotation.morleyKFor implicit account, which type its parameter seems to have from outside.55None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpNg morley8A stack function that expresses the type signature of a LetMacromorleyA stack pattern-matchmorley"A type-variable or a type-constantmorleyA reference into the stack.morley3Implementation-specific instructions embedded in a NOPW primitive, which mark a specific point during a contract's typechecking or execution.These instructions are not allowed to modify the contract's stack, but may impose additional constraints that can cause a contract to report errors in type-checking or testing.VAdditionaly, some implementation-specific language features such as type-checking of LetMacro6s are implemented using this mechanism (specifically FN and FN_END).morley,Matches current stack against a type-patternmorley'A typed stack function (push and pop a  TcExtFrame)morley8Copy the current stack and run an inline assertion on itmorley'Print a comment with optional embedded StackRefsmorleyA comment in Michelson codemorleyConvert # to a list of types. Also returns   which is  . if the pattern is a fixed list of types and  2 if it's a pattern match on the head of the stack.morley+Get the set of variables in a stack pattern None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpX@morley'Contract block, convenient when parsingDmorleyTop-level entries order of the contract. This is preserved due to the fact that it affects the output of pretty-printing and serializing contract.Kmorley9The canonical entries order which is ordered as follow:  parameter, storage, and code.Lmorley(Int, Int, Int) is the positions of  parameter, storage, and code respectively.NmorleyQMap each contract fields by the given function and sort the output based on the D.9:;<=>?@ABCDEFGHIJKLMNDEFGHIJKLN@ABCM9:;<=>?None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp]emorley6Michelson language type with annotations stripped off.}morleyConverts from e to st.~morley"Format type stack in a pretty way.etuvxyz{w|fghimjklnopqrs}~etuvxyz{w|fghimjklnopqrs}~None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpk morley Version of   with  ' constraint, specialized for use with e kind.morley  + ! constraints.4This restricts a type to be a constructible type of e kind.morleyInstance of data family   for e5. Custom instance is implemented in order to inject  & constraint for some of constructors.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 e! 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  .None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp;"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.morleyWhether the type contains m , 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 s contains another smorley$Report a human-readable error about s at a wrong place. morley$Report a human-readable error about n at a wrong place.morley$Report a human-readable error about m at a wrong place.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 ss .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 s type. morleyWhether this type contains n 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 m 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 m.morley1Check at runtime whether the given type contains n.morley1Check at runtime whether the given type contains s.morley1Check at runtime whether the given type contains s.morley6Check at runtime that the given type does not contain m.morley6Check at runtime that the given type does not contain n.morley7Check at runtime that the given type does not containt smorley=Check at runtime that the given type does not contain nested sD! D! None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpI          None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp#?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.??None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp@morleyDescribes how MG should decode tag-dependent data. We expect bytes of such structure: B5 followed by a bytestring which will be parsed with C.DmorleyAny decoding error.Imorley Alias for @ constructor.JmorleydGet a bytestring of the given length leaving no references to the original data in serialized form.KmorleyGet 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.LmorleyFail with "unknown tag" error.@ABCDEFGHIJKLMNDEFGH@ABCINMJKLI0None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpśVmorleyFError that can happen during parsing of cryptographic primitive types.\morley*Encode a bytestring in Base58Check format.]morley,Decode a bytestring from Base58Check format.^morleyParse a base58check encoded value expecting some prefix. If the actual prefix matches the expected one, it's stripped of and the resulting payload is returned._morley!Template for 'format*' functions.`morley Template for 'parse*' functions.amorleyReturns first encountered  2 in a list. If there are none, returns arbitrary  %. It is useful to implement parsing.bmorley*Do randomized action using specified seed.fmorleyMake a  PublicKey from raw bytes.dRaw bytes are in the format of Compressed SEC Format. Refer to this article on how this is parsed: Phttps://www.oreilly.com/library/view/programming-bitcoin/9781492031482/ch04.htmlgmorley Convert a  PublicKey to raw bytes.hmorley Convert a  PublicKey to raw bytes.imorley Convert a  PublicKey to raw bytes.jmorleyMake a  Signature from raw bytes.kmorleyMake a  SecretKey from raw bytes.STUVWXYZ[\]^_`abcdefghijkVWXYZ[\]STU^_`abcejkihfgdNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpqmorley]Newtype wrapper for ByteString which uses hexadecimal representation for JSON serialization.qrsqrsNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp|}|} None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp~morleyIf monadic action returns a  P value, it will be thrown. Otherwise the returned value will be returned as is.~~None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpmorley Similar to  , but compares types via  DefaultEq& used in singletons comparisons (see Data.Singletons.Prelude.Eq module).!None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpomorley5Extract datatype name via its Generic representation.:For polymorphic types this throws away all type arguments.morleyBRebuild a list into a binary tree of exactly the same form which uv 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."None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp=* morley0Reorders entries corresponding to constructors (a) and fields (b) according to some rule. morleyNSimple type synonym used (internally) between functions, basically extending   with the  s of the constructor and its fields. For fields it carries both names in the original order and in the order specified by the strategy (and the latter is paired with depths). morleyConstructor's depth morleyConstructor's name morley2Names of constructor fields in the original order. morley<Names and depths of constructor fields after the reordering. morley;Defines how to reorder fields when their names are unknown. morley.Defines how to reorder fields or constructors.morleyType of a strategy to derive   instances. morley Given the  "s for given datatype, return the  >s for it. This function should when possible make checks and  , using the constructors'   provided by the  . morley'Reorder constructors given their names. morleyReorder fields given their names, the argument depends on whether fields are part of record (and thus named) or not (unnamed). morleySimple tuple that carries basic info about a constructor: it's name, number of its fields and their names. Used only in this module. morleyrSimple tuple that defines the "shape" of a constructor: it's name and number of fields. Used only in this module. morleyWSimple tuple specifying the depth of a constuctor and a list of depths for its fields.VThis is used as a way to specify the tree topology of the Generic instance to derive.morleyIn this strategy the desired depths of contructors (in the type tree) and fields (in each constructor's tree) are provided manually and simply checked against the number of actual constructors and fields.morleyLStrategy to make right-balanced instances (both in constructors and fields)..This will try its best to produce a flat tree:4the balances of all leaves differ no more than by 1;Dleaves at left will have equal or lesser depth than leaves at right.morleyKStrategy to make left-balanced instances (both in constructors and fields).)This is the same as symmetrically mapped .morleyQStrategy to make fully right-leaning instances (both in constructors and fields).morleyPStrategy to make fully left-leaning instances (both in constructors and fields).morleyVStrategy to make Haskell's Generics-like instances (both in constructors and fields).This is similar to , except for the "flat" part:`for each node, size of the left subtree is equal or less by one than size of the right subtree.This strategy matches A1.1.customGeneric T haskellBalanced is equivalent to mere deriving stock Generic T.morley.Modify given strategy to reorder constructors.nThe reordering will take place before depths are evaluated and structure of generic representation is formed. Example: .reorderingConstrs alphabetically rightBalanced.morley(Modify given strategy to reorder fields.Same notes as for  apply here. Example: AreorderingFields forbidUnnamedFields alphabetically rightBalanced.morley9Modify given strategy to reorder constructors and fields.Same notes as for  apply here. Example: ?reorderingData forbidUnnamedFields alphabetically rightBalanced.morley$Sort entries by name alphabetically.morley4Leave unnamed fields intact, without any reordering.morleyTFail in case records are unnamed and we cannot figure out the necessary reordering. morleyvConstruct a strategy that only constructs Generic instance of given form, without e.g. changing the order of entries.morleyrHelper to make a strategy that created depths for constructor and fields in the same way, just from their number.The provided function f" must satisfy the following rules: length (f n) "a nsum $ (x -> 2 ^^ (-x))  $ f n "a 1 (unless n = 0)morley&Helper for making a constructor depth.VNote that this is only intended to be more readable than directly using a tuple with 1 and for the ability to be used in places where RebindableSyntax) overrides the number literal resolution.morley Helper for making a field depth.VNote that this is only intended to be more readable than directly using a tuple with 1 and for the ability to be used in places where RebindableSyntax) overrides the number literal resolution. morleyApply a reordering strategy.This uses given  [CstrNames]} to understand how constructors and their fields should be reordered, and applies the same transposition to entries within  . morley*Reifies info from a type name (given as a  <). The lookup happens from the current splice's scope (see  B) and the only accepted result is a "plain" data type (no GADTs). morleyiDerives, as well as possible, a type definition from its name, its kind (where known) and its variables. morley4Extract the info for each of the given constructors. morley#Combines depths with constructors,  *ing in case of mismatches, and generates  "s for the constructors' arguments. morley Creates the   type for an unbalanced  R instance, for a type given its name, constructors' depths and derived full type.rNote: given that these types definition can be very complex to generate, especially in the metadata, here we let generic-deriving# make a balanced value first (see  !) and then de-balance the result. morleyBreaks down a tree of GenericQ types from the contructor of "nodes" and the constructor for "leaves" metadata.@This expects (and should always be the case) the "root" to be a Generic` metadata contructor, which is returned in the result alongside the list of leaves (in order). morleyCreate the unbalanced  Q fuction declaration for a type starting from its list of weighted constructors. morleyCreate the unbalanced  Q fuction declaration for a type starting from its list of weighted constructors. morleyRecursively aggregates the values in the given list by merging (with the given function) the ones that are adjacent and with the same depth.^This will fail for every case in which the list cannot be folded into a single 0-depth value. morley(Original name of a constructor or field.#None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpDmorleyDefault layout in LIGO.To be used with  , see this method for more info.This is similar to , but!fields are sorted alphabetically;Balways puts as large complete binary subtrees as possible at left.morleyComb layout in LIGO ( [@layout:comb] ).To be used with .$None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpF None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpImorley?For datatype with "myNyan" field it will create "myNyanL" lens.%None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpQUmorleySome defaults in Haskell are debatable and we typically want to customize them in our applications. Some customizations are done at the level of main!. Currently we have two of them:   from the  with-utf8 package.  from the uncaught-exception package.'This function is supposed to apply all main- customizations that we typcally want to do.&None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp]|morley"Picking anchor for various things.What you want here is potentially adding some prefix to ensure anchors uniqueness. It is not necessary to preprocess the text to fit anchor format - that will happen when the anchor is embedded into .morleyAnchor with given text.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.morley#Text which is hidden until clicked.morleyQuasi quoter for Markdown. This supports interpolation via  #{expression} syntax.'None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpaTmorleyBConvert between integral types, checking for overflows/underflows.(None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpgmorleyInteger values starting from 1.,We define our own datatype in order to have  _ 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.)None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpl=morley)Generates an NFData instance for a GADT. Note:` This will not generate additional constraints to the generated instance if those are required.*None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpomorley,Leads first character of text to lower case.(For empty text this will throw an error.None8!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpqmorley*Constaints that can be provided on demand.Needless to say, this is a pretty unsafe operation. This typeclass makes using it safer in a sense that getting a segfault becomes harder, but still it deceives the type system and should be used only if providing a proper proof would be too difficult.morley%Produce a constraint out of thin air.morley"A value of type parametrized with some type parameter.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   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.morleyGHC can't deduce this itself because in general a type family might be not associative, what brings extra difficulties and redundant constraints, especially if you have complex types. But (++) type family is associative, so let's define this small hack.morleyFUtility function to help transform the first argument of a binfunctor.morleyIn majority of the cases we don't want to mock typeclass constraints since coercing instances of typeclasses with methods is utterly unsafe.!%!%None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp morleyWe can have `RequireLongerOrSameLength = (RequireLongerOrSameLength' l a, LongerOrSameLength l a)`, but apparently the printed error message can be caused by  rather than u`. 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.$#"  $#"  None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp morleyConditional 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.   None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp[morley)Proxy for a label type that includes the  constraintmorleyUtility function to get the   representation of a   None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp#morley7Isomorphism between named entity and the entity itself. morley\Isomorphism between named entity and the entity itself wrapped into the respective functor. "#$%&'() &'()%$"#(4)4 None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpX 5morleySupporting typeclass for >. It specifies how a value should be parsed from command line. Even though the main purpose of this class is to implement helpers below, feel free to use it for other goals.7morley"This string will be passed to the   function, hence we use   type rather   (even though we use   almost everywhere).8morleyLMaybe add the default value and make sure it will be shown in help message.9morley6Parser for path to a file where output will be writen.:morley Create a   for a value using 5 instance (hence CLe in the name). It uses reader and metavar from that class, the rest should be supplied as arguments.iWe expect some common modifiers to be always provided, a list of extra modifies can be provided as well.;morleyA more general version of := which takes a list of extra (not as widely used) modifiers.<morleyAkin to :(, but for arguments rather than options.=morleyAkin to ;(, but for arguments rather than options.>morley Create a  ' for a value using its type-level name.oThis expects type-level name to be in camelCase as appropriate for Haskell and transforms the variable inside. 56789:;<=> 89567:;<=>+None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp FmorleyEntrypoint name.'There are two properties we care about: Special treatment of the default entrypoint name. default is prohibited in the CONTRACT instruction and in values of address and contract. types. However, it is not prohibited in the SELF' instruction. Hence, the value inside EpName can be  "default", so that we can distinguish SELF and  SELF %default. It is important to distinguish them because their binary representation that is inserted into blockchain is different. For example, typechecking  SELF %default consumes more gas than SELFU. In this module, we provide several smart constructors with different handling of default3, please use the appropriate one for your use case.The set of permitted characters. Intuitively, an entrypoint name should be valid only if it is a valid annotation (because entrypoints are defined using field annotations). However, it is not enforced in Tezos. It is not clear whether this behavior is intended. There is an upstream  +https://gitlab.com/tezos/tezos/-/issues/851issue which received bugJ label, so probably it is considered a bug. Currently we treat it as a bug and deviate from upstream implementation by probiting entrypoint names that are not valid annotations. If Tezos developers fix it soon, we will be happy. If they don't, we should (maybe temporarily) remove this limitation from our code. There is an  7https://gitlab.com/morley-framework/morley/-/issues/275issue in our repo as well.PmorleyBThis is a bidirectional pattern that can be used for two purposes:  Construct an F% referring to the default entrypoint.GUse it in pattern-matching or in equality comparison to check whether FT refers to the default entrypoint. This is trickier because there are two possible F/ values referring to the default entrypoints. PY will match only the most common one (no entrypoint). However, there is a special case: SELF instruction can have explicit %default7 reference. For this reason, it is recommended to use Q instead. Pattern-matching on P[ is still permitted for backwards compatibility and for the cases when you are sure that F does not come from the SELF instruction.QmorleyCheck whether given F+ refers to the default entrypoint. Unlike PD pattern, this function correctly handles all cases, including the SELF instruction.RmorleyMake up F/ from annotation in parameter type declaration.Returns  # if no entrypoint is assigned here.SmorleyHTurn entrypoint name into annotation for contract parameter declaration.TmorleyMake up Fu from annotation which is reference to an entrypoint. Note that it's more common for Michelson to prohibit explicit default entrypoint reference.Specifically, %default' annotation is probitited in values of address and contract$ types. It's also prohibited in the CONTRACT/ instruction. However, there is an exception:  SELF %defaultA is a perfectly valid instruction. Hence, when you construct an F$ from an annotation that's part of SELF, you should use U instead.Umorley Make up an F* from an annotation which is part of the SELF instruction.VmorleyETurn entrypoint name into annotation used as reference to entrypoint.WmorleyWMake a valid entrypoint name from an arbitrary text. This function prohibits explicit default= entrypoint name which is permitted by Michelson inside the SELF@ instruction. This limitation shouldn't be restrictive because SELF is equivalent to  SELF %default.XmorleyPartial version of W.Ymorley Given an untyped parameter type, extract a map that maps entrypoint names to the their parameter types. If there are duplicate entrypoints in the given Type then the duplicate entrypoints at a deeper nesting level will get overwritten with the ones that are on top. morley Version of mkEntrypointMaps for plain untyped type.FGHNOPQRSTUVWXYFGHPQRSTUVNOWXY None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpxcdefghijklmnophijklmnopefgcd,None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp4 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. morley;Error message indicating bad character in a string literal.morleyWrap a Haskell text into , performing necessary checks.You can use e.g. 'n'X character directly in supplied argument, but attempt to use other bad characters like 'r' will cause failure.morley Contruct T from a Haskell text, failing if provided Haskell text is invalid Michelson string.morley Construct  from a Haskell text, eliminating all characters which should not appear in Michelson strings. Characters which can be displayed normally via escaping are preserved.morleyPrint 9 for Michelson code, with all unusual characters escaped.morley/QuasyQuoter for constructing Michelson strings.:Validity of result will be checked at compile time. Note:slash must be escaped$newline character must appear as 'n'use quotes as is)other special characters are not allowed.morleyParser used in  quasi quoter.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.-None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp? morley"Secp256k1 cryptographic signature.morley#Secp256k1 secret cryptographic key.morley#Secp256k1 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.morleyMake a  from raw bytes.morley Convert a  to raw bytes.morleyMake a  from raw bytes. morley Convert a  to raw bytes. morleyBase16 format is 11a2e0c9morley$Sign a message using the secret key.morley@Check that a sequence of bytes has been signed with a given key..None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpK 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.morleyMake a  from raw bytes.morley Convert a  to raw bytes.morleyMake a  from raw bytes. morley Convert a  to raw bytes. morleyBase16 format is 1051eebdmorley$Sign a message using the secret key.morley@Check that a sequence of bytes has been signed with a given key./None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpUb morley ED25519 cryptographic signature.morley!ED25519 secret cryptographic key.morley!ED25519 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.morleyMake a  from raw bytes.morley Convert a  to raw bytes.morleyMake a  from raw bytes.morley$Sign a message using the secret key.morley@Check that a sequence of bytes has been signed with a given key.          0None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpzVmorley!Blake2b_160 hash of a public key.!morley<We store which curve was used because it affects formatting."morley Hash itself.#morley6Which curve was used for the hashed public key inside .'morleyDCryptographic signatures used by Tezos. Constructors correspond to 0 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.(morley4Signature that uses the ed25519 cryptographic curve.)morley6Siganture that uses the secp256k1 cryptographic curve.*morley7Signature that uses the NIST P-256 cryptographic curve.+morley-Generic signature for which curve is unknown.,morleyDSecret cryptographic key used by Tezos. Constructors correspond to 0 constructors.-morley5Secret key that uses the ed25519 cryptographic curve..morley7Secret key that uses the secp256k1 cryptographic curve./morley8Secret key that uses the NIST P-256 cryptographic curve.0morleyvPublic cryptographic key used by Tezos. There are three cryptographic curves each represented by its own constructor.1morley5Public key that uses the ed25519 cryptographic curve.2morley7Public key that uses the secp256k1 cryptographic curve.3morley8Public key that uses the NIST P-256 cryptographic curve.4morleyZDeterministicaly generate a secret key from seed. Type of the key depends on seed length.5morley&Create a public key from a secret key.6morley Convert a ' to raw bytes.7morleyMake a '4 from raw bytes. Can return only generic signature.:morley@Check that a sequence of bytes has been signed with a given key.DmorleyParse  unencryptedG secret key. It accepts formats containing either with or without the  unecrypted prefix.EmorleyPLength of key hash in bytes (only hash itself, no tags, checksums or anything).Fmorley*Compute the b58check of a public key hash.>BCDESTUVWXYZ[\]^ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKL>0123,-./'()*+#$%& !"456789:;VWXYZ[<=>?@ABGHIJECDFBCDE\]STU^KL1None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpumorleynIdentifier 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".xmorley\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.~morley Version of }# that accepts a number of any type.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   or  l 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   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.morleyConvert mutez to signed number.<TODO [#423]: try to provide a generic safe conversion methodmorleyprettyTez (toMutez 420) "0.00042 )"prettyTez (toMutez 42000000)"42 )"morley!Add given amount of seconds to a x.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 x.morleyQuote a value of type x 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 x.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 u as it is displayed e.g. in ./babylonnet.sh head call.Example of produced value: NetXUdfLh6Gm88t. morleyJIt's a magic constant used by Tezos to encode a chain ID. Corresponds to Net part.)uvwxyz{|}~){|}~xyzuvw2None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp3None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpmorleyType for Micheline Expressionmorley-Micheline represents both nats and ints using the same decimal format. The Haskell Integer type spans all possible values that the final (Michelson) type could end up being, and then some, so we use (StringEncode Integer) to represent all integral values here for easy JSON encoding compatibility.4None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpmorleyEncode  to  . morleyDecode  from  . morleyPartial version of  .    5None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpmorley:Raw bytes representation of an address has invalid length.morley<Raw bytes representation of an address has incorrect prefix.morley>Raw bytes representation of an address does not end with "00".morley.Errors that can happen during address parsing.morley%Address is not in Base58Check format.morley,Both address parsers failed with some error.morley,When a transfer operation triggers multiple CREATE_CONTRACT instructions, using Q to compute those contracts' addresses is not enough to ensure their uniqueness.*For that reason, we also keep track of an U that starts out as 0 when a transfer is initiated, and is incremented every time a CREATE_CONTRACT instruction is interpreted.See &.morley(Represents the network's global counter.VWhen a new contract is created (either via a "global" origination operation or via a CREATE_CONTRACTI instruction), this counter is used to create a new address for it (see &).The counter is incremented after every operation, and thus ensures that these addresses are unique (i.e. origination of identical contracts with identical metadata will result in different addresses.)3In Tezos each operation has a special field called counter , see here: https://gitlab.com/tezos/tezos/-/blob/397dd233a10cc6df0df959e2a624c7947997dd0c/src/proto_006_PsCARTHA/lib_protocol/operation_repr.ml#L113-120This counter seems to be a part of global state of Tezos network. In fact, it may be observed in raw JSON representation of the operation in the network explorer.Our counter is represented as  \, while in Tezos it is unbounded. We believe that for our interpreter it should not matter.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. morleyULength of contract hash in bytes (only hash itself, no tags, checksums or anything).$morleySmart constructor for  .%morley$Deterministically generate a random   and discard its secret key.&morleycCompute address of a contract from its origination operation, origination index and global counter.CHowever, in real Tezos encoding of the operation is more than just OriginationOperationb. There an Operation has several more meta-fields plus a big sum-type of all possible operations. See here: https://gitlab.com/tezos/tezos/-/blob/f57c50e3a657956d69a1699978de9873c98f0018/src/proto_006_PsCARTHA/lib_protocol/operation_repr.ml#L78What is important is that one (big) Operation may lead to origination of multiple contracts. That is why contract address is constructed from hash of the operation that originated and of index of the contract's origination in the execution of that operation.In other words, contract hash is calculated as the blake2b160 (20-byte) hash of origination operation hash + int32 origination index + word64 global counter.In Morley we do not yet support full encoding of Tezos Operations, therefore we choose to generate contract addresses in a simplified manner.Namely, we encode OriginationOperation[ as we can and concat it with the origination index and the global counter. Then we take CK hash of the resulting bytes and consider it to be the contract's address.'morleyCreate a dummy " value by hashing given  .Use in tests **only**.*morleyParse an address from its human-readable textual representation used by Tezos (e. g. "tz1faswCTDciRzE4oJ9jn2Vm2dvjeyA9fUzU"). Or fail if it's invalid.+morleyParse the given address in its raw byte form used by Tezos (e.g "01521139f84791537d54575df0c74a8084cc68861c00")) . Or fail otherwise if it's invalid.-morleyParse a KT1G contract address, fail if address does not match the expected format..morleyPartial version of *B which assumes that the address is correct. Can be used in tests./morleyPartially parse raw bytes representation of an address and assume that it is correct from the beginning. Can be used in tests.%    !"#$%&'()*+,-./%"# !$%&'   ()+,*/.-6None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp`morleyByteString does not have an instance for ToJSON and FromJSON, to avoid orphan type class instances, make a new type wrapper around it.qmorleydA sequence of elements: can be a list or a set. We can't distinguish lists and sets during parsing.`abcdefghijklmnopqrstdefghijklmnopqrsbc`at7None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpVmorley.Michelson instruction with abstract parameter op. This parameter is necessary, because at different stages of our pipeline it will be different. Initially it can contain macros and non-flattened instructions, but then it contains only vanilla Michelson instructions.morley"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  @ 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.morley$ is essentially as special case for 8, 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).^^8None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp49None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp(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 an arbitrary number of K J and/or IH that belong to the same entity and returns their total operation size.MNote that annotations which belong to the same entity (type or instruction) must be\ considered in aggregate using one call of this function and to be specified in order. See Q for details.wNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp*JGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg9:;<=>?@ABCDEFGHIJKLMNFGHNOPQRSTUVWXY`abcdefghijklmnopqrst:None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp4morleyBuilding a record from tuple.%It differs from similar typeclass in xyG 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.;None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp7morleyProduce ( instance for tuple of the given length.<None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp9zNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp;None8!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpqPv 0morleyLike  L, casts some container's elements, producing informative error on mismatch.1morley  version of  .2morleySuppose you have a data type X with parameter aX and you have two values: `x1 :: X a1` and `x2 :: X a2`. You can't compare them using  J, because they have different types. However, you can compare them using 2! as long as both parameters are  .3morley Version of 2 for types with 2 parameters.4morley Version of 2 for types with 3 parameters.5morley2Compare two entries of completely different types.6morley Extension of 5 to   function.7morleyCast 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 7N you get a way to extract this object no matter which phantom argument it had.8morley)Match given type against another type of * -> *. kind without caring about its type argument.  012345678 012345678 =None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpa9morley>Data type, holding annotation data for a given Michelson type t.;Each constructor corresponds to exactly one constructor of eh and holds all type and field annotations that can be attributed to a Michelson type corresponding to t.TmorleyHForget information about annotations, pick singleton with the same type.!Note: currently we cannot derive   from 9 without !U because for comparable types notes do not remember which exact comparable was used.UmorleyGet term-level type of notes.Vmorley In memory of NStar5 constructor. Generates notes with no annotations.Wmorley%Checks if no annotations are present.YmorleyCombines 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.Zmorley<Insert the provided type annotation into the provided notes.[morley:Converge two type or field notes (which may be wildcards)."9:;<=>?@ABCDEFGHIJKLMNOPRSTUVWXYZ["9:;<=>?@ABCDEFGHIJKLMNOPRSY[ZXWVTU>None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpmdmorley Similar to e, but also gives   for given type.emorley Transparently represent untyped Type as wrapper over Notes t from typed world with SingI t constraint.$As expression this carries logic of g, and as pattern it performs h! 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.hmorleyConvert 7 to the isomorphic set of information from typed world.}defghfg}hed?None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpzimorleySDescribes 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.mmorley<Errors specific to parameter type declaration (entrypoints).smorley?Coordinates of "arm" in Or tree, used solely in error messages.tmorley/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 itselfmorley Entrypoint name (might be empty)morleyvParse an address which can be suffixed with entrypoint name (e.g. "tz1faswCTDciRzE4oJ9jn2Vm2dvjeyA9fUzU%entrypoint").morley1Parses byte representation of entrypoint address.For every address -KT1QbdJ7M7uAQZwLpvzerUyk7LYkJWDL7eDh%foo%bar (we get the following byte representation `01afab866e7f1e74f9bba388d66b246276ce50bf4700666f6f25626172 ______________________________________//__/____: address % ep1 % ep2 morleyParameter without annotations. morley4Check whether given notes are valid parameter notes.morley Construct t! performing all necessary checks.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.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. morleyBuild i.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.morleyBuild .ZHere we accept entrypoint name and type information for the parameter of target contract.Returns   if entrypoint is not found.morley Parameter type of implicit account.>FGHNOPRSTVijklmnopqrstuvwxyz{|}~>xyz{|}~tuvwpqrsmnoijklFGHPRSTVNO@None8!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpqmorley"Representation of Michelson value.Type parameter instr` stands for Michelson instruction type, i.e. data type to represent an instruction of language.morleyAlias for comparable types. morley#Report a human-readable error that s contains another s morley1Constraint which ensures that type is comparable.morleyWWrapper 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 i into actual function on Values.morley+Lift entrypoint argument to full parameter.morley,Get a witness of that value's type is known.ONote that we cannot pick such witness out of nowhere as not all types of kind e have   and ! instances; example: -type family Any :: T where -- nothing here morley0Provide a witness of that value's type is known. morley1Extended values comparison - it does not require Value7s to be of the same type, only their content to match. morleyIIgnoring distinction between constructors here, comparing only semantics.H H ANone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpm5morley%Converge the notes of given operands.Qmorley Computing  u function in Michelson style. When divisor is negative, Haskell gives x as integer part, while Michelson gives x+1.Rmorley Computing   function in Michelson style. When divisor is negative, Haskell gives a negative modulo, while there is a positive modulo in Michelson.!23456789:;<=>?@ABCDEFGHIJKLMNOPQR!23456NOPIJKLMFGHDE<=>?@ABC789:;QRBNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp morley#Marker data type for add operation.morley0Represents an arithmetic error of the operation.morleyLDenotes the error type occurred in the arithmetic operation involving mutez.morleyBDenotes the error type occurred in the arithmetic shift 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.morley%Converge the notes of given operands.morley0Evaluate arithmetic operation on given operands.morleyAn operation can marked as commutative, it does not affect its runtime behavior, but enables certain optimization in the optimizer. We conservatively consider operations non-commutative by default.%Note that there is one unusual case: AND works with  int : nat but not with  nat : int). That's how it's specified in Michelson.%opqrstuvwxyz{|}~%~}|{zyxwvutsrqpoCNone8!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp^Mmorley=Keeps documentation gathered for some piece of contract code..Used for building documentation of a contract.morleyAll inlined doc items.morleyDefinitions 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.morleyhWe remember all already declared entries to avoid cyclic dependencies in documentation items discovery.morleyWe 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).morley@A part of documentation to be grouped. Essentially incapsulates . morleyQAnchor for all the sections (referring them as to headers may cause colissions). morley Section namemorley*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, ~ is not yet applied at this stage. You only can be sure that items within each group are splitted across sections correctly.morley#Several doc items of the same type.morley: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.morleySuitable for block name.morley+Suitable for subsection title within block.morley=Type-level check whether or not a doc item can be referenced.morley!Where do we place given doc item.morley&Placed in the document content itself.morleyAPlaced in dedicated definitions section; can later be referenced.morley'Position of all doc items of some type.morley%Some unique identifier of a doc item.FAll doc items which should be refer-able need to have this identifier.morleyA 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.morleyDefines 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   and   instances which comply the following law: if two documentation items describe the same entity or property, they should be considered equal.morleyPosition of this item in the resulting documentation; the smaller the value, the higher the section with this element will be placed. If the position is the same as other doc items, they will be placed base on their name, alphabetically.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.morley]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.morleyDescription of a section.qCan be used to mention some common things about all elements of this section. Markdown syntax is permitted here.morleyHow to render section name.)Takes effect only if section name is set.morleyDefines 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.morleyPRender 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).morley>Render table of contents entry for given doc item to Markdown.morley,All doc items which this doc item refers to.UThey will automatically be put to definitions as soon as given doc item is detected.morleyThis 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.morley Generate  entry anchor from .morley$Get doc item position at term-level. morleyARender an item into Markdown block with all required adjustments. morleyOrder items by their  docItemId.morley,Make a reference to doc item in definitions.morleyWhether given  is atomic.Normally, atomic s are ones appearing in DOC_ITEM. instruction, and non-atomic ones are put to DocGroup.morleyRender a documentation block.morley;Make an anchor that is to be attached to the given section.morleyReference to the given section. Will return NothingL if sections of given doc item type are not assumed to be referred outside.morley(Render a part of table of contents from .morleyBLift a doc item to a block, be it atomic doc item or grouping one.morley#Lift an atomic doc item to a block.morley%Find all doc items of the given type.morleyRender documentation for .morleyRender documentation for . morleyTo automatically derive #instance Show Michelson.Typed.Instr later.morleyA hand-made anchor.morleyTable of contents. to be inserted into the doc in an ad-hoc way.0It is not intended to be inserted manually. See = to understand how this works.morley-Comment in the doc (mostly used for licenses)morleyRepository settings for .morley@By commit sha make up a url to that commit in remote repository.morley"Specify version if given contract."morleyDescription of something.$morleyGive a name to document block.&morleyGeneral (meta-)information about the contract such as git revision, contract's authors, etc. Should be relatively short (not several pages) because it is put somewhere close to the beginning of documentation.(morleyOften there is some tuning recommended prior to rendering the contract, like attaching git revision info; this type designates that those last changes were applied.4For example, at Michelson level you may want to use >.JIf you want no special tuning (e.g. for tests), say that explicitly with 6.*morley9Some contract languages may support documentation update.+morley+Modify all documentation items recursively.,morleyQEverything that contains doc items that can be used to render the documentation.-morleyGather documentation.9Calling this method directly is discouraged in prod, see 75 instead. Using this method in tests is fine though..morley:A function which groups a piece of doc under one doc item.3morley9Render given contract documentation to markdown document.5morley2Apply given grouping to documentation being built.6morley8Mark the code with doc as finalized without any changes.7morleyGather documenation.8morley3Construct and format documentation in textual form.9morleyERecursevly traverse doc items and modify those that match given type.If mapper returns  ", doc item will remain unmodified.;morleyMake .:t $mkDGitRevisionGitRepoSettings -> DGitRevision<morleyWAttach information about git revision. The code must contain git revision placeholder.We do this in two stages because we use TH to deduce git revision information at compile time, and this is best to be done in the very end to recompile less modules.>morley<Attach common information that is available only in the end.@morleyBContract documentation assembly primarily relies on this instance.Cmorley,This instance allows writing something like  docGroup Titlem, this makes sense as the most primitive and basic use case for doc groups is putting a section under name.a !"#$%&'()*+,-./0123456789:;<=>a./120345()6,-*+789&'$%"# !;:<=>DNone8!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpqNmorley\Typed contract and information about annotations which is not present in the contract code.`morley  for any stack typeamorley-A print format with references into the stackdmorley+A reference into the stack of a given type.emorley=Keeps 0-based index to a stack element counting from the top.hmorleyERepresentation 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 m DROP m DUPO. Special case where there are no instructions is represented by constructor Nop, e.g. IF_NONE {} { SWAP; DROP; } -> IF_NONE Nop (SWAP m 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.imorley?A wrapper carrying original source location of the instruction.JTODO [#283]: replace this wrapper with something more clever and abstract.jmorley^A wrapper for instruction that also contain annotations for the top type on the result stack.tAs of now, when converting from untyped representation, we only preserve field annotations and type annotations in  PackedNotes). Variable annotations are preserved in InstrWithVarNotes.PThis can wrap only instructions with at least one non-failing execution branch.kmorley4A wrapper for instruction with variable annotations.lmorley-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.nmorleyeNop operation. Missing in Michelson spec, added to parse construction like `IF {} { SWAP; DROP; }`.pmorleyNested 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.qmorley\Places documentation generated for given instruction under some group. This is not part of U! because it does not behave like n?; instead, it inherits behaviour of instruction put within it.rmorleyVariants 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.morleyAnnotations for PAIR instructions can be different from notes presented on the stack in case of special field annotations, so we carry annotations for instruction separately from notes.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 h also helps to derive the  instance for h as `Sing a` does not have a  instance on its own.morley<Create a stack reference, performing checks at compile time.morleyWMap each typed contract fields by the given function and sort the output based on the D.NOPQRSTUYVWXZ`[\]^_abcdefghmpotv~|z{w}xyuijklnqrsՈhmpotv~|z{w}xyuijklnqrsUYVWXZ`[\]^_deabcfgTNOPQRSENone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp FNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpӺ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. morleyTThere 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 ns.TPlease note that this function is not recursive, it does not linearize contents of IF and similar instructions. morleyDeep version of  G. It recursively linearizes instructions stored in other instructions. morley&Traverse a value in depth-first order. morleySpecialization of  3 for case when changing the value is not required. morleySpecialization of  ! which only modifies given value. 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 a value can be converted to something. Recursively applies it to all values. Collects extracted values in a list.                  None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp morleyThis class encodes Michelson rules w.r.t where it requires comparable types. Earlier we had a dedicated type for representing comparable types CT,. But then we integreated those types into TW. This meant that some of the types that could be formed with various combinations of T would be illegal as per Michelson typing rule. Using this class, we inductively enforce that a type and all types it contains are well typed as per Michelson's rules. morley2Constraints required for instance of a given type. 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. morleyEWhether Michelson representation of the type is derived via Generics. morley-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.iIn case an unbalanced tree is needed, the Generic instance can be derived by using the utilities in the {| module. morleySince Contract@ name is used to designate contract code, lets call analogy of n 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. "morley6Any Haskell value which can be converted to Michelson . $morley4Hides some Haskell value put in line with Michelson . &morleyOverloaded version of  ( to work on Haskell and T types. 'morley=Isomorphism between Michelson values and plain Haskell types.WDefault implementation of this typeclass converts ADTs to Michelson "pair"s and "or"s. (morley:Type function that converts a regular Haskell type into a T type. )morley"Converts a Haskell structure into Value representation. *morley Converts a Value into Haskell type. ,morleyReplace type argument of  ContractAddr with isomorphic one.%                   ! " # $ % & ' ( ) * + , - . /% ' ( ) * +   & $ % " #     !     , -         . /GNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp* morleyPTraverse a single contructor and supply its field to instruction in case clause. morleyGeneric traversal for  . ymorleyList of  |.s required to pattern match on the given type. zmorley*Type information about single case clause. |morleyuIn what different case branches differ - related constructor name and input stack type which the branch starts with. morleyGeneric 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.morleyForce result of  to be  morley;Transitively find constructor of some sum type by its name.dTransitivity means that if sum type consists of other sum types, they will be searched recursively.morleyEResult of constructor lookup - entry type and path to it in the tree. morleyTo use   not only here for e/-based stacks, but also later in Lorentz with  --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). morleyLike  } but only works for contructors with a single field. Results in a type error if a constructor with no field is used instead. 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.morleyFailure 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.#:;>=< v w x y z { | } ~  # ~ v | } z { y x w;>=<:   8HNone8!"#$%&'*,-./012456789;<=>?@AHMNPSUVX_`befgkmpAmorleyGeneric traversal for  . morleyConstraint for  .morleyGeneric traversal for  .morley&Retrieve field names of a constructor. morleyConstraint for   and . morley"Names of all fields in a datatype. morley"Types of all fields in a datatype. morleyAbility to pass list of fields with the same ToTs. It may be useful if you don't want to work with NamedF in ConstructorFieldTypes. morley9Way to construct one of the fields in a complex datatype.morleyGeneric traversal for  . morleyConstraint for  .morleyGeneric traversal for  instrAccess. morleyConstraint for  . morley@Get type of field by datatype it is contained in and field name.morleyForce result of  to be  morley,Find field of some product type by its name.2Name might be either field record name, or one in  if field is wrapped using  or .morley>Result of field lookup - its type and path to it in the tree. morleyEMake an instruction which accesses given field of the given datatype. morleyFor given complex type dt and its field fieldTy update the field value. morleyFor given complex type dt and its field fieldTy update the field value. morleyFor given complex type dt# deconstruct it to its field types.  }None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpC~5:;>=< v w w x x y z { | } ~  INone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpO morley6Pick a field from constructor with zero or one fields.morleyGeneric 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  .  JNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpZ morleyConvert a typed Val to an untyped .'For full isomorphism type of the given Val should not contain mP - a compile error will be raised otherwise. You can analyse its presence with  function. morleyGet   from untyped value.Throw error if U.Type contains  TOperation. morleyTSample values used for generating examples of entrypoint parameter in documentation. morleykFlatten a provided list of notes to a map of its entrypoints and its corresponding utype. Please refer to mkEntrypointsMap6 in regards to how duplicate entrypoints are handled.  KNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp^ morley$Estimate instruction operation size. morley&Estimate contract code operation size. morley9Estimate value operation size. TODO: [#428]: do not use  here.  LNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpѾ, morley7Representation of a field with an optional description. morley=Representation of a constructor with an optional description. 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.JThis representation also includes descriptions of constructors and fields.!morley Version of   for comparable types. morley#Constraint, required when deriving  R for polymorphic type with the least possible number of methods defined manually. morleyProduct 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."morleyCWhen 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. A value of @b is provided by the library to make sure that instances won't replace it with an unchecked value.When value is  2, 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).-When 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. morley*Description of constructors and fields of a.See A' documentation for an example of usage.uDescriptions will be checked at compile time to make sure that only existing constructors and fields are referenced.For that check to work instance Generic a is required whenever TypeDocFieldDescriptions is not empty.$For implementation of the check see ? type family. 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 uuR 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:[Integer](#type-integer),%[Maybe](#type-Maybe) [()](#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 Show given   in a neat way.#morleyMap field names in a  @, with the possibility to remove some names by mapping them to  .$morley$How field names should be displayed.UResult of this function call should appear right before rendered type of that field. morley Create a  ! in form suitable for putting to  . morleyProxy version of  . !morley Shortcut for  . "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. +morleyAdd field name for newtype.Since newtypeQ field is automatically erased. Use this function to add the desired field name. ,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.<A                           ! " # $ % & ' ( ) * + , - . /<                 A    & " # $ % ' ( ) + * , - . /  !     ~None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpՌ:;>=<A                 ! " # $ % & ' ( ) * ( + , - . / v w w x x y z { | } ~                             ! " # $ % & ' ( ) * + , - . /:;>=<A                 ! " # $ % & ' ( ) * + , - . / v w w x x y z { | } ~                            ! " # $ % & ' ( ) * + , - . /MNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp dmorleyPut a document item. emorleyBAssemble contract documentation with the revision of the contract. fmorley Assemble contract documentation. gmorley+Modify all documentation items recursively. hmorleyWRecursevly traverse an instruction and modify documentation items matching given type.If mapper returns  ", doc item will remain unmodified. imorley1Leave 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. d e f g h i f e h g i dNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp! :;>=<Aetuvxyz{w|fghimjklnopqrs}~FGHNOPRSTV9:;<=>?@ABCDEFGHIJKLMNOPRSTUVWXYZ[defghijklmnopqrstuvwxyz{|}~ 2345634789:;<=>?=>@ABCABDEFGHGIJKLMJKNOPOQRopqrstuvwxyz{|}~NOPQRSTUYVWXZ`[\]^_abcdefghmpotv~|z{w}xyuijklnqrs                         ! " # $ % & ' ( ) * ( + , - . / v w w x x y z { | } ~                             ! " # $ % & ' ( ) * + , - . / d e f g h iNNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp  lmorley.Error type for when a value is not well-typed. nmorleyState for type checking nop omorley(Set of variables defined in a let-block. qmorleySRepresents a typed contract & a storage value of the type expected by the contract. umorleywData type keeping the whole type check result: instruction and type representations of instruction's input and output. wmorley]This data type keeps part of type check result - instruction and corresponding output stack. xmorley?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. ymorley}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). zmorleyNo-argument type wrapper for HST data type. |morleyHData type holding type information for stack (Heterogeneous Stack Type).8This data type is used along with instruction data type Instr> to carry information about its input and output stack types.That is, if there is value instr :: Instr inp out, along with this instr one may carry inpHST :: HST inp and outHST :: HST outN which will contain whole information about input and output stack types for instr. Data type HST is very similar to Data.Vinyl.RecN, but is specialized for a particular purpose. In particular, definition of HST (t1 ': t2 ': ... tn ': '[]) requires constraints ,(Typeable t1, Typeable t2, ..., Typeable tn) as well as constraints -(Typeable '[ t1 ], Typeable '[ t1, t2 ], ...). These applications of Typeable= class are required for convenient usage of type encoded by HST ts with some functions from  Data.Typeable. Data type HST (Heterogeneous Stack Type) is a heterogenuous list of tuples. First element of tuple is a structure, holding field and type annotations for a given type. Second element of tuple is an optional variable annotation for the stack element. Additionally constructor keeps !! constraint for the current type. morleyExtended pattern-match - adds Sing x argument. morleyAppend a type to  |A, assuming that notes and annotations for this type are unknown. morleyGiven a type, provide evidence that it is well typed w.r.t to the Michelson rules regarding where comparable types are required. morleyGiven a type and an action that requires evidence that the type is well typed, generate the evidence and execute the action, or else fail with an error. morley Similar to withWTPm% but is mean to be used within tests. l m n o p q r s t u v w x y z { | } ~   | } ~  z { w x y u v s t q r o p n l m  v8 x9  ~7 7 7ONone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp* morley%Represents a non-well-typed operation morley&Constructs a partialy typed operation. morley*Constructs a completely untyped operation. morley5Represents nodes of a partially typed operation tree. morleyConstructs well-typed node. morley[Constructs ill-typed node which might in turn contain well-typed and non-typed operations. morley6Represents a root of a partially typed operation tree. morleyMakes a well-typed node out of  u  PNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpM7 morleyDVarious type errors possible when checking Morley extension commands morleyType check error morleyData type that represents various errors which are related to type system. These errors are used to specify info about type check errors in TCError data type. morleyAnnotation unify error morleyType equality error morleyStacks equality error morleyError that happens when type cannot be used in the corresponding scope. Argument of this constructor carries type which violates the restriction, e.g. big_map in UNPACK4, and a concrete reason why the type is unsuported. morleyVArithmetic operation is applied to types, at least one of which is not numeric (e.g.  timestamp and  timestamp passed to MUL instruction). morleyError that happens when actual types are different from the type that instruction expects. The param is an non-empty list of all expected stack types that the instruction would accept. Each expected stack types is represented as non-empty list as well. morley=Some instruction can not be used in a specific context, like SELF in LAMBDA. morleyError that happens when a . is never a valid source for this type (e.g.  timestamp cannot be obtained from a i) morleyEThere are not enough items on stack to perform a certain instruction. morley Invalid entrypoint name provided morley.Contract with given address is not originated. morley 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 representation morley:KeyHash couldn't be parsed from its textual representation morley!Timestamp is not RFC339 compliant morley1Code always fails, but shouldn't, like ITER body. morley$Empty block of code, like ITER body. morleyAGeneric error when instruction does not match something sensible. morley$Contexts where type error can occur. morley>Description of the type to be expected by certain instruction.N N QNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpXY morley5Represents a partiall typed sequence of instructions. morleyA fully well-typed sequence. morleyGA well-typed prefix followed by some error and semi-typed instructions. morleyIThere is no well-typed prefix, only an error and semi-typed instructions. morleyCase analysis for TypeCheckedSeq. morley1On error, with all already typechecked operationsmorleyOn well-typed instructionmorleyThe sequence to dispatch on             RNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp~ morleyNWhether to add stack type comments after every instruction a la tezos-client. morleyThe typechecking state morley|Typechecking mode that tells the type checker whether it is typechecking contract code in actual contract, lambda, or test. #morleyA non-throwing alternative for  TypeCheckK. Mainly meant to be used for construction of a partially typed tree (see TypeCheckedSeq).%morleyGHelper function means to provide a quick way for creating instance of  SomeParamType needed in test. %morley Construct  SomeParamType from  ParameterType, mainly used in test. 'morley Buildable instance of  SomeParamType, mainly used in test. (morleyEq instance of  SomeParamType, mainly used in test. )morleyShow instance of  SomeParamType, mainly used in test. 2morleyzRun 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). 3morley Similar to  2, but for 'TypeCheckInstr.' 9morleyPerform a throwing action on an acquired instruction. Preserve the acquired result by embedding it into a type checking tree with a specified parent instruction. :morleyPerform a non-throwing action on an acquired instruction. Preserve the acquired result even if the action does not succeed. Embed the result into a type checking tree with a specified parent instruction. ;morleyAcquire a resource. If successfully, call a follow-up action on it, otherwise embed the error into a type checking tree along with a specified untyped instruction. <morleySame as guarding< but doesn't pass an acquired result to a follow-up action. 8morleyCall this if the action throwsmorleyCall this if it doesn'tmorleyThe action to performmorleyA non-throwing action 9morleyAcquiring computationmorley"The parent instruction constructormorleyThe throwing action :morleyAcquiring computationmorley"The parent instruction constructormorley The action ;morleyUntyped instructionmorleyAcquiring computationmorleyFollow-up action%             ! " # $ % & + , - . / 0 1 2 3 4 5 6 7 8 9 : ; <% + .        $ # 1 - , 2 3 4 5 6 7 9 : ; < 8 / 0      ! " & %SNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp- =morleyAFunction which derives special annotations for PAIR instruction.+Namely, it does following transformation:  PAIR % % [  p.a int : p.b int : .. ] ~ [ "p (pair (int %a) (int %b) : .. ] All relevant cases (e.g.  PAIR %myf % 3) are handled as they should be according to spec. >morleyGFunction which derives special annotations for CDR / CAR instructions. ?morley8Append suffix to variable annotation (if it's not empty) @morley(Function which extracts annotations for or" type (for left and right parts).It extracts field/type annotations and also auto-generates variable annotations if variable annotation is not provided as second argument. Amorley(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. Cmorley.Combine annotations from two given stack types Dmorley:Extract singleton for each single type of the given stack. Emorley.Check whether the given stack types are equal. FmorleyCheck whether the given stack has size 1 and its only element matches the given type. This function is a specialized version of  E. HmorleyCheck whether elements go in strictly ascending order and return the original list (to keep only one pass on the original list). Imorley Function eqType is a simple wrapper around Data.Typeable.eqT suited for use within Either TCTypeError a applicative.&morleyLike  Q: but doesn't add a stack type comment after the sequence. PmorleyLike  Qn but without the first and the last stack type comments. Useful to reduce duplication of stack type comments. RmorleyJCheck whether given types are structurally equal and annotations converge. Smorley%Generic implementation for MEMeration ZmorleyLHelper function to construct instructions for binary arithmetic operations. _morleyKHelper function to construct instructions for unary arithmetic operations. `morleylHelper function to construct instructions for unary arithmetic operations that should preserve annotations.$ = > ? @ 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 N J K L M Q P R S T U W Y X V Z [ ] ^ \ _ ` OTNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp bmorley Function typeCheckValImplA converts a single Michelson value given in representation from Michelson.Type2 module to representation in strictly typed GADT.typeCheckValImpl. is polymorphic in the 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.typeCheckValImpl also has a 'Maybe TcOriginatedContracts' argument that should contain the originated contracts when typechecking a parameter and   otherwise. a b b aUNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp'morleyPerform some, possibly throwing, action presumably making use of a supplied external instruction. In case of an error, return  IllTypedSeqU wrapping the thrown error and the instruction. If the action successfully returns  SomeInstr, wrap it in a  WellTypedSeq.(morleyDCheck that the optional "forall" variables are consistent if present)morley Executes function body, pushing ExtFrame+ onto the state and checks the pattern in FN.*morley Check that a StackTypePattern& matches the type of the current stack+morley<Create stack reference accessing element with a given index.2Fails when index is too large for the given stack. c cVNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpߪ dmorleyaType check a contract and verify that the given storage is of the type expected by the contract. fmorley 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. gmorley Function typeCheckListNoExceptG converts list of Michelson instructions given in representation from Michelson.Type: module to representation in a partially typed tree. See TypeCheckedSeq and  TypeCheckedOp.yTypes are checked along the way. It is necessary to embed well typed node as well as type checking errors into the tree. hmorley Function typeCheckValueA converts a single Michelson value given in representation from Michelson.Untyped< module hierarchy to representation in strictly typed GADT.typeCheckValue. is polymorphic in the expected type of value.VType checking algorithm pattern-matches on parse value representation, expected type t and constructs Value 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. kmorleyLike  h), but for values to be used as parameter.Also accepts a  $ in order to be able to type-check  contract p0 values (which can only be part of a parameter). lmorleyLike  h', but for values to be used as storage. mmorley 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. d e f g h i j k l m e d m f g k l h i jNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp 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 : ; < I R c d e f g h i j k l m e d c m f g k l h i j I RWNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpJ nmorley.Data associated with a particular transaction. tmorley5A parameter associated with a particular transaction. n o p q r s t u v y z { | n o p q r s t u v | { z yXNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp }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. morleyContract itself. morley,Storage value associated with this contract. 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. morley"Ever increasing operation counter. 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. morleySecret key assotiated with  . 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./morley3Update storage value associated with given address.0morley3Update storage value associated with given address. morley&Retrive all contracts stored in GState- } ~  - } ~  YNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp 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. morleykConvert typed contract into a textual representation which will be accepted by the OCaml reference client. morleyhConvert typed value into a textual representation which will be accepted by the OCaml reference client. morleyjConvert untyped value into a textual representation which will be accepted by the OCaml reference client. morleyConvert  sU into a textual representation which will be accepted by the OCaml reference client. )*+- )*+- ZNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpn morley6Built-in Michelson Macros defined by the specification morley1Unexpanded instructions produced directly by the ops[ parser, which contains primitive Michelson Instructions, inline-able macros and sequences morleyPrimitive Michelson instruction morley5Built-in Michelson macro defined by the specification morley2User-defined macro with instructions to be inlined morleyA sequence of instructions morleyA programmer-defined macro morley%Expand all macros in parsed contract.> > [None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp! 1morley!A programmer-defined type-synonym 5morleyA programmer-defined constant 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9\None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp$ Bmorley2The environment containing lets from the let-block B C E F D G H G B C E F D H]None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp& L M N O P Q R S T U V W X Y L M N O P Q R S T U V W X Y^None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp-t [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. Z [ \ ] ^ _ \ Z [ ] ^ __None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp1 `morleyParse untyped  i. Take instruction parser as argument to avoid cyclic dependencies between modules, hence ' in its name. ` a b c d ` d a b c`None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp4 emorley General TV2F Annotation parser, including Special Annotations|} e f g h i j k l m n o p e h f g i j k l n o m p|}aNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp7' q r s q s rbNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp9- t u v t v ucNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp= wmorleyFParser for primitive Michelson instruction (no macros and extensions). xmorley!Parse a sequence of instructions. w x y z { | w x | { z ydNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp?1 } ~   } ~  eNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpD1morleyElement of a let block morleylet block parser morley'Incrementally build the let environment2morley1add a Let to the environment in the correct place3morley7build a let name parser from a leading character parser  None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpR morleyParse with empty environment morley'Michelson contract with let definitions4morleyCThis ensures that the error message will point to the correct line.5morleyMichelson 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)) : morleyCreates  by its Morley representation."cdefghijklmnop G a b c q u " G hijklmnopcdefg q a b c u fNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpYf 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.6morley%Should transform only atomic values,   will be applied to it.  gNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpo7morleyAlias for label attaching.8morley-Read a byte and match it against given value.9morleynRead a byte describing the primitive going further and match it against expected tag in the given conditions.Aside of context description, you have to specify number of arguments which given instruction accepts when written in Michelson. For instance, PUSH) accepts two arguments - type and value.:morleyLike ;a, but doesn't backtrack if next entry failed to parse yet there are some bytes to consume ahead.9This function exists primarily for better error messages. morley6Deserialize bytes into the given value. Suitable for UNPACK operation only. morleyLike  , for strict byte array. 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.Amorley?Utility function to fill a constructor with an empty annotationBmorley5Decodes an annotations' string and uses the provided  G to parse untyped annotations from it. This has to produce at least one annotation (Annotations' String parsing will fail otherwise)DEF DEF 70hNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp morley9Prefix prepended to the binary representation of a value. 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.Cmorley4Lift encoded list content to an entire encoded list.DmorleyEncode a list-like structure.EmorleyEncode a text.FmorleyEncode some raw data.GmorleyEncode some map. morley"Encode contents of a given number.HmorleyEncode an int-like value.ImorleyEncode a code block.JmorleyEncode an instruction.KmorleygIff there are non-empty annotations it increments the value's tag and appends the encoded annotations.Lmorley/Encode an instruction with variable annotationsMmorley&Encode an instruction with Annotations iNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp morleyWType class that provides the ability to convert something from a Micheline Expression. morley*Errors that can happen when we convert an  to our data type. morleyRType class that provides an ability to convert something to Micheline Expression.  None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp<%  jNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp morley'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 Construct  for an  .  kNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp morleyKDefault config - all commonly useful rules will be applied to all the code. 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 N rule by default because it is potentially dangerous. There are various code processing functions that may depend on constants, e. g. string transformations.Omorley Sequences of DROPs can be turned into single DROP n. When n0 is greater than 2 it saves size and gas. When n is 2 it saves gas only.PmorleyAppend LHS of  m to RHS and re-run pointwise ocRuleset 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.fThe reason this function invokes ocRuleset 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 ocRuleset. morleyCombine two rule fixpoints. morley*Combine a rule fixpoint and a simple rule.QmorleyTurn rule fixpoint into rule.RmorleyDApply the rule once, if it fails, return the instruction unmodified.SmorleyAn adapter for  .Tmorley.Apply a rule to the same code, until it fails. lNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp' morleyCMorley logs for interpreter state that are stored in reverse order. morley Represents [FAILED]Q state of a Michelson program. Contains value that was on top of the stack when FAILWITH 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. morley4The contract that initiated the current transaction. morley=The contract that initiated the current internal transaction. morley"Amount of the current transaction. morley Identifier of the current chain. morley`Hash of the currently executed operation, required for correct contract address computation in  instruction. morleyWA global counter that is used to ensure newly created contracts have unique addresses.UmorleymFunction to change amount of remaining steps stored in State monad | Helper function to convert a record of Value to StkEl. These will be created with  starNotes.Vmorley'Helper function to convert a record of StkEl to Value'. Any present notes will be discarded. morleyRInterpret an instruction in vacuum, putting no extra contraints on its execution.Mostly for testing purposes. morleysInterpret an instruction in vacuum, putting no extra contraints on its execution while preserving its annotations.Mostly for testing purposes. morleyCFunction to change amount of remaining steps stored in State monad. morleyCFunction to interpret Michelson instruction(s) against given stack.Wmorley?Evaluates an arithmetic operation and either fails or proceeds. morley*Unpacks given raw data into a typed value.Xmorley,Access given stack reference (in CPS style).?         )? )         mNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp׭ *morley0Dummy timestamp, can be used to specify current NOW value or maybe something else. +morleyDummy 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. ,morleyDummy  s with some reasonable hardcoded values. You can override values you are interested in using record update syntax. -morley  with most data hardcoded to some reasonable values. Contract and initial values must be passed explicitly, because otherwise it hardly makes sense. * + , - * + , -nNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp # .morley,Result of a single execution of interpreter. 0morleyNew  . 1morleyUpdates applied to  . 2morleyDuring 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. 3morley2Now much gas all remaining executions can consume. 4morleyMOperations 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  n , because  n0 is supposed to be provided by the user, while  can be computed by our code. 5morleyOriginate a contract. 6morleybSend a transaction to given address which is assumed to be the address of an originated contract. Emorley(A monad in which contract executor runs. GmorleyEErrors that can happen during contract interpreting. Type parameter aE determines how contracts will be represented in these errors, e.g. . Hmorley0The interpreted contract hasn't been originated. Imorley,Interpretation of Michelson contract failed. Jmorley!A contract is already originated. KmorleySender address is unknown. LmorleyManager address is unknown. Mmorley!Sender doesn't have enough funds. NmorleySending 0tz towards an address. Omorley"Failed to apply updates to GState. Pmorley Contract parameter is ill-typed. QmorleyUContract parameter is well-typed, but its type does not match the entrypoint's type. Rmorley)Specified entrypoint to run is not found. UmorleyParse a contract from  . VmorleyParse a contract from   and expand macros. Wmorley,Read and parse a contract from give path or Y (if the argument is   ). The contract is not expanded. XmorleyRead a contract using  W8, expand and flatten. The contract is not type checked. YmorleyFOriginate a contract. Returns the address of the originated contract. Zmorley}Run a contract. The contract is originated first (if it's not already) and then we pretend that we send a transaction to it. [morley:Send a transaction to given address with given parameters. \morleyKRun some executor action, returning its result and final executor state in  ..The action has access to the hash of currently executed global operation, in order to construct addresses of originated contracts. It is expected that the action uses #isGlobalOp .! True9 to specify this hash. Otherwise it is initialized with Z. ]morley<Run some executor action, reading state from the DB on disk.Unless dryRun is False., the final state is written back to the disk.If the executor fails with  F# it will be thrown as an exception. ^morley>Execute a list of global operations, discarding their results. _morley'Execute a global origination operation. `morley!Execute an origination operation. amorleyExecute a transfer operation.[morleyCReset nonce and source address before executing a global operation.; n o p q r s t u v } ~  . / 0 1 2 3 4 5 6 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; Y Z [ U V W X } ~  n o p q r s t u v 4 5 6 . / 0 1 2 3 G H I J K L M N O P Q R F E \ ] ^ _ ` a B D A C S ToNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp ! fmorleyFull parser for a client. gmorley#Parser for path to a contract code. hmorley Parser for the time returned by NOW instruction. imorley+Parser for gas limit on contract execution. jmorley.Parser for path to database with Morley state. kmorley"Parser for transaction parameters. lmorley$Generic parser to read an option of  type. mmorley$Generic parser to read an option of , type. nmorley$Generic parser to read an option of  type. omorley$Generic parser to read an option of { type. pmorley$Generic parser to read an option of  type. qmorley --oneline flag. rmorley$Generic parser to read an option of F type. smorley$Generic parser to read an option of  type. f g h i j k l m n o p q r s f g h i j k l m n o p q r spNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp % umorley,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. vmorley!We need this class to pass it to . ' is needed because we push a value and   is needed for . wmorleyExtract error tag out of  u. xmorley4Check whether given instruction ends with a typical ^ usage. It does not recursively check instructions that can be passed to other instructions.4The instruction MUST be linearized to the left (see  ). ymorley)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. u v w x y u w x y vqNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp 3 }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. { | } ~   { | } ~  _      !"#$%&'()*+,-./011tt23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkklmnoopqqrstuvwxyz{||}}~ !"#$%&'()*+,-./0LKVWY      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}}~ !!!"""""""""""""""""##$$$  % & & & & &&&&&&&&&&&&&&&&&&&& &!&"&#'$(%(&('((()(*(+(,(-(.(/(0(1(2(3)4*5*6789::;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                    +++++++++++++++++++++++++++++                                ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, , , , - - -------------------- -!-"-#-$-%-&-'-(-)-*-+-,---.-/-0-1-2-3. . .................... .!.".#.$.%.&.'.(.).*.+.,.-.../.0.1.2.3/ / /////////////////!/"/// /#/$/%/&/'/(/)/*/,/+/-/.///0/1/2/3040405060708090:0 0;0<0=0>00?0@0A00B0C0D00000E00$0#0000F000 0!0"0G0H0I0J0K0L0M0N0O0P0%0&0'0Q0(0R0S0)020*0T0U0V0W0X0Y0Z0,0+0-0.0/0001030[0\0]0^0_0`0a0b0c0d0e0f0g1h1i1j1k1k1l1m1n1o1p1q1r1s1t1u1v1w1x1y1z1{1|1}1~111111111111111111111111111111111111111111111111122222222222222222222222222222223333333333333333333333333333333333333333333444555555555555555555555555555 5 5 5 5 5555555555555555555 5!5"5#5$5%5&5'5(5)5*5+5,5-5.5/505152535455565758595:5;5<5=5>5?5@5A5B5C6D6D6E6E6F6G6H6I6J6K6L6M6N6O6P6Q6R6S6T6U6V6W6X6Y6Z6[6\6]6^6_6`6a6b6c6d6e6f6g6h6i6j6k6l6m6n6o6p6q7r7s7t7u7v7w7x7y7z7{7|7}7~777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777788899999999999999999:::;<<<<<<<<<<<<<<<<<<<< < < < < <<======== =!="=#=$=%=&='=(=)=*=+=,=-=.=/=0=1=2=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?[?\?]?^?^?_?`?S?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?{?|?}?~??????????????????????=??????????@@@@@F@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@p@@@@@@@@@@d@e@@@@@@_AAAAA 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@AABBBCBDBEBFBGBHBIBJBKBLBMBNBOBPBQBBRBSBTBUBVBWBXBYBZB[B\B]B^B_B`BaBbBcBdBeBfBgBhBiBjBkBlBmBnBoBpBqBrBsBtBuBvBwBxByBzB{B|B}B~BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC C C C C DDDDDDDDDDDDDDDDDDDDoDoDD}D}DkDkD D!D"D#D$D%D&D'D(D)D*D+DuDtDvDwDxDyDzD{D|D}D~D,DDDDDDDDDDDDDDDDDDDDDDDDDDDDDD-DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD.D/D0D1D2D3D4D4DD5DDD6D7D8DD9D:D;D<DDDD=DD>D?D@DDADBDDDDCDDDEDFDGDHDIDJDDKDLEMEEEFNFNFOFPFQFQFRFSFTFUFVFWFXFYFZF[F\F]F^F_F`FaFbcdefghijkllmnnopqrsttuuvwxyz{|}~GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHH H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H !H "I #I $I %I &I 'I (I )I *I +I ,I -I .I /I 0I 1I 2I 3I 4J 5J 6J 7J 8J 9J :J ;J[JJ <KK =KL >L >L ?L @L AL BL BL CL DL EL FL GL HL IL JL KL LL ML NL OL OL PL PL QL QL RL SL TL UL VL WL XL YL ZL [L \L \L ]L ^L _L `L aL bL cL dL eL fL gL hL iL jL kL lL mL nL oL pL qL rL sL tL uL vL wL xL yL zL {L |L }L ~L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L 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 N N N N N N N 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 O O O O P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P P PP P P P P P P P P P P P P P !P "P #P $P %P &P 'P (P )P *P +P ,P -P .P /P 0P 1P 2P 3P 4P 5P 6P 7P 8P 9P :P ;P <P =P >P ?P @P AP BP CP DP EP FP GP HP IQ JQ KQ LQ MQ NQ OR PR PR QR RR RR SR TR UR VR WR XR YR ZR [R [R \R ]R ^R _R `R aR bR cR dR eR fR gR hR iR jR kR lR mR nR oR pR qR rR sR tR uS vS wS xS yS zS {S |S }S ~S S S S S S S S S S S S S S S S S S S S S S S S S S S T T U V V V V V V V V V V W W W W W W W W W W W W W W W X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X Y Y Y Y Y Y Z Z Z Z Z Z Z Z Z Z Z Z Z Z5Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z%Z Z Z Z Z Z Z Z !Z "Z #Z #Z $Z %Z &Z 'Z (Z )Z *Z +Z ,Z -Z .Z /Z 0Z 1Z 2Z 3Z 4Z 5Z 6Z 7Z 8Z 9Z :Z ;Z <Z =Z >Z ?Z @Z AZ BZ CZ DZ EZ FZ GZ HZ IZ JZ KZ LZ MZ NZ OZ PZ QZ RZ SZ TZ UZ VZ WZ XZ YZ ZZ [Z \Z ]Z ^Z _Z `Z aZ bZ c[ d[ d[ e[ f[ g[ g[ h[ i[ j[ k[ l[ m[ n[ o[ p[ q[ r\ s\ s\ t\ u\ v\ w\ x\ y\ z\ {] |] }] ~] ] ] ] ] ] ] ] ] ] ] ^ ^ ^ ^ ^ ^ _ _ _ _ _ ` ` ` ` ` ` ` ` ` ` ` ` a a a b b b c c c c c c d d d d d d e e e e f f g g g g g h h h h h h h h h h h i i i i i i i i i i i i i i i i i i i i i i j j j j j j j j j k k k k k k k k k k k k k k l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l l !l "l #l $l %l &l 'l (l )l *l +l ,l -l .l /l 0l 1l 2l 3l 4l 5l 6l 7l 8l 9l :l ;l <l =l >l ?l @l Al Bl Cl Dl El Fl Gl Hl Il Jl Kl Ll Ml Nm Om Pm Qm Rn Sn Sn Tn Un Vn Wn Xn Yn Zn [n \n ]n ^n _n `n an bn cn dn en fn gn hn in jn kn ln mn nn on pn qn rn sn tn un vn wn xn yn zn {n |n }n ~n n n n n n n n n n n o o o o o o o o o o o o o o o p p p p p p q q q q q q q q q q q               vr r r r r r r r                       " " "  " " " " " " " " " " " " " " " " " " " "  "  " "   ut      w  + , - - . .      1  ! " # $5 %9 & ' ( ) * * +? ,? -@ .@ / 0 1 0 2C 3C 4 * 5 * 6C 7C 8C 9C :C ;C <C =C > ? @ AF B C D% EG FG GG HG IG JG KG LG MH NH OH PH QH RH SH IH JH K TH LI UI VJ WL XL YL ZL [R \S ]U ^U _U `U aU bV cX dX eX fX ge he ie j k lf mg ng og pg q rg sg tg ug vg wg xg yh zh {h |h }h ~h h h h h h k k k k k k k l l l l n p p p morley-1.11.0-inplace Util.TypeLits Util.Label Util.Typeable Util.TypeMichelson.Typed.ScopeMichelson.Typed.Haskell.Value Util.DefaultUtil.Fcf Util.LensMichelson.ParserMichelson.Parser.Error Util.NamedUtil.CLI Util.PeanoMichelson.Interpret.UtilsMichelson.Printer.Util%Michelson.Typed.Haskell.Instr.Helpers+Michelson.Typed.Haskell.ValidateDescriptionTezos.Crypto.Hash Util.AesonMichelson.Untyped.AnnotationMichelson.Untyped.TypeMichelson.Untyped.ExtMichelson.Untyped.ContractMichelson.Typed.TMichelson.Typed.SingMichelson.ErrorPosUtil.Alternative Util.BinaryTezos.Crypto.UtilUtil.ByteStringUtil.Exception Util.GenericUtil.CustomGeneric%Michelson.Typed.Haskell.CompatibilityUtil.Instances Util.Main Util.MarkdownUtil.Num Util.PositiveUtil.TH Util.TextMichelson.Untyped.EntrypointsMichelson.TextTezos.Crypto.Secp256k1Tezos.Crypto.P256Tezos.Crypto.Ed25519 Tezos.Crypto Tezos.CoreMorley.Micheline.JsonMorley.Micheline.ExpressionMorley.Micheline.Binary Tezos.AddressMichelson.Untyped.ValueMichelson.Untyped.InstrMichelson.Untyped.AliasesMichelson.Untyped.OpSizeUtil.TypeTuple.ClassUtil.TypeTuple.THUtil.TypeTuple.InstancesMichelson.Typed.AnnotationMichelson.Typed.ExtractMichelson.Typed.EntrypointsMichelson.Typed.ValueMichelson.Typed.PolymorphicMichelson.Typed.Arith Michelson.DocMichelson.Typed.InstrMichelson.Typed.AliasesMichelson.Typed.Util!Michelson.Typed.Haskell.Instr.Sum%Michelson.Typed.Haskell.Instr.Product Michelson.Typed.Haskell.LooseSumMichelson.Typed.ConvertMichelson.Typed.OpSizeMichelson.Typed.Haskell.DocMichelson.Typed.DocMichelson.TypeCheck.Types!Michelson.TypeCheck.TypeCheckedOpMichelson.TypeCheck.Error"Michelson.TypeCheck.TypeCheckedSeqMichelson.TypeCheck.TypeCheckMichelson.TypeCheck.HelpersMichelson.TypeCheck.ValueMichelson.TypeCheck.ExtMichelson.TypeCheck.InstrMichelson.Runtime.TxDataMichelson.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.PackMorley.Micheline.ClassMichelson.Typed.OriginationMichelson.OptimizerMichelson.InterpretMichelson.Runtime.DummyMichelson.Runtime Morley.CLIMichelson.FailPatternMichelson.Analyzer Paths_morleyMichelson.TypeTypeDataGenericMichelson.Untyped Data.Vinyl FromTupleUtil.TypeTupleUtilGenericsMichelson.Typed.Haskell.InstrMichelson.Typed.HaskellMichelson.TypedMichelson.TypeCheckMorley.Michelinebase GHC.TypeLits KnownSymbolGHC.OverloadedLabelsIsLabelghc-prim GHC.TypesSymbol TypeError AppendSymbolText:<>::$$:ShowType fromLabel Data.TypeableeqT symbolVal ErrorMessageData.Type.EqualityRefl:~:==Data.Type.BoolIfQconstraints-0.12-219813e80846a99ce76bdb4a8e0b66c26d970340aef6c06b2fe8a5b96699e0aaData.ConstraintwithDictDictSub:-[data-default-class-0.1.2.0-cd82420962fb1bb36843e51775abe5ffe3c35016e35b1db0a0fccf8ccfb6a31dData.Default.ClassDefaultdef]first-class-families-0.8.0.0-0702e60137eed6bd2439ef227d6e578c06701d4403198b37cdb3e854ca745e66Fcf.CoreEvalLlens-4.18.1-71a48fae2ba075ea7f14133e309298b9553a34f2c53380601d5d27bf926c286fControl.Lens.THmakeLensesWithQmegaparsec-8.0.0-f2d82a512bed2c13e307d9cc9ac9be855c5332a59a60ea14f90b90adc50f1b21Text.Megaparsec.ErrorerrorBundlePrettyParseErrorBundleNnamed-0.3.0.1-c213d4c2c01df3dfd493e55bc222296fdaec9c9d140602f3c9de6390e6f03aa3Named.Internal:!:?^optparse-applicative-0.15.1.0-af5f40ff48e52dc4c99e942446213183a4a678ceb1eac78114f60167f422ebccOptions.Applicative.Builder eitherReaderOptions.Applicative.Types readerErrorOsingletons-2.6-bc9e9efcd42ed95898675958f8f864b759edb324126e3a605303bb31393c73bbData.Singletons.InternalsingSingIMvinyl-0.12.1-7eed6fcae264e50bba3530560fb2a8e8cadbc76c371a4c09876689da9126d803Data.Vinyl.TypeLevelSZNat++encodeZarithNumberPrettier RenderDoc renderDoc isRenderable RenderContextprintDoc printDocB printDocS renderOps renderOpsListrenderOpsListNoBracesspaces wrapInParensbuildRenderDoc needsParensdoesntNeedParens addParensassertParensNotNeededPathBranchLRFieldDescriptionsValidFieldDescriptionsVFieldDescriptionsblake2b blake2b160sha256sha512morleyAesonOptionsRootAnnSomeAnnVarAnnFieldAnnTypeAnnVarTagFieldTagTypeTag KnownAnnTag annPrefix AnnotationSet AnnotationAnnotationUnsafe unAnnotationWithAnn emptyAnnSet singleAnnSetsingleGroupAnnSet fullAnnSet isNoAnnSet minAnnSetSizenoAnnann mkAnnotationspecialVarAnnsspecialFieldAnnisValidAnnStartisValidAnnBodyCharunifyAnn ifAnnUnified disjoinVnconvAnn$fDefaultAnnotation$fNFDataAnnotation$fBuildableAnnotation$fRenderDocAnnotation$fShowAnnotation$fKnownAnnTagTypeTag$fKnownAnnTagFieldTag$fKnownAnnTagVarTag$fMonoidAnnotation$fSemigroupAnnotation$fBuildableAnnotationSet$fRenderDocAnnotationSet$fShowAnnotationSet$fMonoidAnnotationSet$fSemigroupAnnotationSet$fEqAnnotation$fDataAnnotation$fFunctorAnnotation$fGenericAnnotation$fIsStringAnnotation$fEqAnnotationSet$fFromJSONAnnotation$fToJSONAnnotation$fLiftAnnotationTTKeyTUnit TSignatureTChainIdTOptionTListTSet TOperation TContractTPairTOrTLambdaTMapTBigMapTIntTNatTStringTBytesTMutezTBoolTKeyHash TTimestampTAddress ParameterTypeunwrapT renderTypetoptiontpairtortyinttynattyunittybooltypairtyortyImplicitAccountParam isAtomicTypeisKey isSignature isComparableisMutez isTimestamp isKeyHashisBoolisString isIntegerisNatisIntisBytes $fNFDataT $fBuildableT$fBuildableType $fRenderDocT$fRenderDocType$fRenderDocPrettier $fNFDataType$fBuildableParameterType$fRenderDocParameterType$fRenderDocPrettier0$fNFDataParameterType$fEqT$fShowT$fDataT $fGenericT$fEqType $fShowType $fDataType $fGenericType$fEqParameterType$fShowParameterType$fDataParameterType$fGenericParameterType$fFromJSONType $fToJSONType $fFromJSONT $fToJSONT$fFromJSONParameterType$fToJSONParameterType $fLiftType$fLiftT$fLiftParameterType TestAsserttassName tassComment tassInstrs PrintCommentunUPrintCommentStackFnsfnQuantifiedVars sfnInPattern sfnOutPatternStackTypePatternStkEmptyStkRestStkConsTyVarVarIDTyConVarStackRefExtInstrAbstract STACKTYPEFN UTEST_ASSERTUPRINTUCOMMENTstackTypePatternToListvarSet$fBuildableStackRef$fNFDataStackRef$fBuildableVar $fNFDataVar$fBuildableTyVar $fNFDataTyVar$fBuildableStackTypePattern$fNFDataStackTypePattern$fBuildableStackFn$fNFDataStackFn$fBuildablePrintComment$fNFDataPrintComment$fBuildableTestAssert$fNFDataTestAssert$fBuildableExtInstrAbstract$fRenderDocExtInstrAbstract$fNFDataExtInstrAbstract $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'ContractcontractParametercontractStorage contractCode entriesOrderStorage ContractBlockCBParam CBStorageCBCode EntriesOrderPSCPCSSPCSCPCSPCPScanonicalEntriesOrderentriesOrderToIntorderContractBlockmapEntriesOrdered$fNFDataEntriesOrder$fDefaultEntriesOrder$fBuildableContract'$fRenderDocContract'$fNFDataContract'$fBoundedEntriesOrder$fDataEntriesOrder$fEnumEntriesOrder$fEqEntriesOrder$fGenericEntriesOrder$fShowEntriesOrder$fEqContractBlock$fShowContractBlock $fEqContract'$fShowContract'$fFunctorContract'$fDataContract'$fGenericContract'$fFromJSONEntriesOrder$fToJSONEntriesOrder$fFromJSONContract'$fToJSONContract'toUType buildStackKnownTSingTSTKeySTUnit STSignature STChainIdSTOptionSTListSTSet STOperation STContractSTPairSTOrSTLambdaSTMapSTBigMapSTIntSTNatSTStringSTBytesSTMutezSTBool STKeyHash STTimestamp STAddress withSomeSingT fromSingT $fKnownTt$fSingITTAddress$fSingITTTimestamp$fSingITTKeyHash $fSingITTBool$fSingITTMutez$fSingITTBytes$fSingITTString $fSingITTNat $fSingITTInt$fSingITTBigMap $fSingITTMap$fSingITTLambda $fSingITTOr $fSingITTPair$fSingITTContract$fSingITTOperation $fSingITTSet $fSingITTList$fSingITTOption$fSingITTChainId$fSingITTSignature $fSingITTUnit $fSingITTKey $fSingKindTProperPrintedValBetterErrorsProperUnpackedValBetterErrorsProperPackedValBetterErrorsProperConstantBetterErrorsProperStorageBetterErrorsProperParameterBetterErrors CheckScope checkScopePrintedValScopeUnpackedValScopePackedValScope ConstantScope StorageScopeParameterScopeBadTypeForScopeBtNotComparable BtIsOperation BtHasBigMapBtHasNestedBigMap BtHasContractNestedBigMapsPresenceNestedBigMapsPresentNestedBigMapsAbsentBigMapPresence BigMapPresent BigMapAbsentContractPresenceContractPresentContractAbsent OpPresence OpPresentOpAbsentForbidNestedBigMaps ForbidBigMapForbidContractForbidOpFailOnNestedBigMapsFoundFailOnBigMapFoundFailOnOperationFoundHasNoNestedBigMaps HasNoBigMap HasNoContractHasNoOpContainsNestedBigMapsContainsBigMap forbiddenOpforbiddenBigMapforbiddenNestedBigMapsforbiddenContractTypecheckOpPresencecheckContractTypePresencecheckBigMapPresencecheckNestedBigMapsPresence opAbsensecontractTypeAbsense bigMapAbsensenestedBigMapsAbsenseproperParameterEviproperStorageEviproperConstantEviproperPackedValEviproperUnpackedValEviproperPrintedValEvi $fHasNoOpt$fHasNoContractt$fHasNoBigMapt$fHasNoNestedBigMapst$fBuildableBadTypeForScope$fCheckScope(%,%)$fCheckScope(%,,%)$fCheckScope(%,,,%)$fCheckScope(%,,,%)0$fCheckScope(%,,%)0$fCheckScopeHasNoContract$fCheckScopeHasNoNestedBigMaps$fCheckScopeHasNoBigMap$fCheckScopeHasNoOp$fShowBadTypeForScope$fEqBadTypeForScope$fGenericBadTypeForScope$fNFDataBadTypeForScopeInstrCallStack icsCallStack icsSrcPos LetCallStackLetNameSrcPossrcLinesrcColPosunPos unsafeMkPosmkPossrcPos $fDefaultPos $fNFDataPos$fDefaultSrcPos$fNFDataSrcPos$fBuildableSrcPos$fNFDataLetName$fDefaultInstrCallStack$fNFDataInstrCallStack$fEqPos$fOrdPos $fShowPos $fGenericPos $fDataPos $fEqSrcPos $fOrdSrcPos $fShowSrcPos$fGenericSrcPos $fDataSrcPos $fEqLetName $fOrdLetName $fShowLetName $fDataLetName$fGenericLetName$fBuildableLetName$fEqInstrCallStack$fOrdInstrCallStack$fShowInstrCallStack$fGenericInstrCallStack$fDataInstrCallStack $fFromJSONPos $fToJSONPos$fFromJSONSrcPos$fToJSONSrcPos$fFromJSONLetName$fToJSONLetName$fFromJSONInstrCallStack$fToJSONInstrCallStacksomeNE TaggedDecodertdTag tdDecoder UnpackError unUnpackError ensureEnd launchGet#:getByteStringCopygetRemainingByteStringCopy unknownTag decodeWithTagdecodeBytesLike$fExceptionUnpackError$fBuildableUnpackError$fShowUnpackError$fEqUnpackErrorB58CheckWithPrefixErrorB58CheckWithPrefixWrongPrefixB58CheckWithPrefixWrongEncodingCryptoParseErrorCryptoParseWrongBase58CheckCryptoParseWrongTagCryptoParseCryptoErrorCryptoParseUnexpectedLengthCryptoParseBinaryErrorencodeBase58CheckdecodeBase58CheckdecodeBase58CheckWithPrefix formatImpl parseImpl firstRight deterministicrnfCurvesignatureLengthBytes_publicKeyLengthBytes_ mkPublicKey_publicKeyToBytes_signatureToBytes_secretKeyToBytes_ mkSignature_ mkSecretKey_$fBuildableCryptoParseError$fNFDataCryptoParseError$fShowCryptoParseError$fEqCryptoParseError$fShowB58CheckWithPrefixErrorHexJSONByteStringunHexJSONByteString$fFromJSONHexJSONByteString$fToJSONHexJSONByteString$fEqHexJSONByteString$fOrdHexJSONByteString$fShowHexJSONByteString$fGenericHexJSONByteString$fNFDataHexJSONByteString$fHashableHexJSONByteString permute2Def permute3Def throwLeftApplyConstraintsTyEqSing<|>Over2GenericTypeName mkGenericTreemkGenericTreeVecGenericStrategy withDepths rightBalanced leftBalanced rightCombleftCombhaskellBalancedreorderingConstrsreorderingFieldsreorderingDataalphabeticallyleaveUnnamedFieldsforbidUnnamedFieldsfromDepthsStrategycstrfld customGeneric ligoLayoutligoCombLayout$fBuildableIdentity$fBuildableNatural$fDefaultNaturalpostfixLFieldswrapMainToAnchortoAnchorAnchorunAnchor HeaderLevelMarkdownnextHeaderLevelmdHeadermdTocmdSubsectionTitle mdSubsectionmdBoldmdItalicmdTickedmdEscapeAnchormdRef mdLocalRefmdAnchor mdSeparator mdSpoiler mdCommentmd$fIsStringAnchor$fToAnchorText$fToAnchorAnchorfromIntegralCheckedPositivePositiveUnsafe unPositive mkPositivelengthNE replicateNE$fNFDataPositive $fEqPositive $fOrdPositive$fDataPositive$fGenericPositive$fShowPositive$fBuildablePositive$fToJSONPositive$fFromJSONPositivederiveGADTNFData headToLowersurroundMockableConstraintprovideConstraintUnsafeConcatListOfTypesAssociativitySome1RSplitKListKNilKCons KnownListklist ReifyList reifyList PatternMatchL PatternMatchRequireAllUnique AllUniqueFailWhen FailUnlessGuard///IsElem failUnlessEvi failWhenEvireifyTypeEqualityrsplitrecordToSomeList#listOfTypesConcatAssociativityAxiomonFirst$fReifyListac:$fReifyListkc[] $fKnownListk:$fKnownListk[]$fMockableConstraint(%,,,,%)$fMockableConstraint(%,,,%)$fMockableConstraint(%,,%)$fMockableConstraint(%,%)$fMockableConstraintc$fMockableConstraint~ $fShowSome1RequireLongerOrSameLengthRequireLongerThanLongerOrSameLengthIsLongerOrSameLength LongerThan IsLongerThanTakeDropAtLengthSingNatSZSS KnownPeanopeanoVal FromPeanoToPeanoPeano peanoVal' peanoValSingrequireLongerThanrequireLongerOrSameLength$fMockableConstraintKnownPeano $fKnownPeanoS $fKnownPeanoZ $fSingINatS $fSingINatZ$fNFDataSingNat%$fMockableConstraintRequireLongerThan$fRequireLongerThankla-$fMockableConstraintRequireLongerOrSameLength$fRequireLongerOrSameLengthkla $fEqSingNat $fShowSingNatTypeErrorUnless symbolValT symbolValT'inTypeErrorUnlessLabel labelToText$fBuildableLabel$fIsLabelsLabel $fShowLabel $fEqLabelKnownNamedFunctornamedL NamedInnerApplyNamedFunctor.!.?<.!><.?>$fBuildableNamedF $fShowNamedF$fKnownNamedFunctorMaybe$fKnownNamedFunctorIdentity$fFromJSONNamedF$fFromJSONNamedF0$fToJSONNamedF$fToJSONNamedF0 $fDataNamedF $fOrdNamedF $fEqNamedF HasCLReader getReader getMetavarmaybeAddDefault outputOptionmkCLOptionParsermkCLOptionParserExtmkCLArgumentParsermkCLArgumentParserExt namedParser$fHasCLReader[]$fHasCLReaderText$fHasCLReaderInt$fHasCLReaderInteger$fHasCLReaderWord16$fHasCLReaderWord64$fHasCLReaderNaturalEpName EpNameUnsafeunEpName$fNFDataEpName $fShowEpName $fEqEpName $fOrdEpName$fGenericEpNameEpNameFromRefAnnErrorInEpNameBadAnnotation DefEpName isDefEpNameepNameFromParamAnnepNameToParamAnnepNameFromRefAnnepNameFromSelfAnnepNameToRefAnn buildEpNameunsafeBuildEpNamemkEntrypointsMap$fHasCLReaderEpName$fBuildableEpName$fFromJSONEpName$fToJSONEpName $fBuildableEpNameFromRefAnnError$fNFDataEpNameFromRefAnnError$fShowEpNameFromRefAnnError$fEqEpNameFromRefAnnError$fGenericEpNameFromRefAnnErrorParserExceptionStringLiteralParserExceptionInvalidEscapeSequence InvalidCharCustomParserExceptionUnknownTypeExceptionStringLiteralExceptionOddNumberBytesException WrongTagArgsWrongAccessArgs WrongSetArgsExcessFieldAnnotationMultiRootAnnotationException0$fShowErrorComponentStringLiteralParserException$$fNFDataStringLiteralParserException)$fShowErrorComponentCustomParserException$fNFDataCustomParserException$fBuildableParserException$fExceptionParserException$fShowParserException $fEqStringLiteralParserException"$fDataStringLiteralParserException!$fOrdStringLiteralParserException"$fShowStringLiteralParserException%$fGenericStringLiteralParserException$fEqCustomParserException$fDataCustomParserException$fOrdCustomParserException$fShowCustomParserException$fGenericCustomParserException$fEqParserExceptionDoNotUseTextErrorMText MTextUnsafeunMText minBoundMChar maxBoundMCharisMCharmkMText mkMTextUnsafe mkMTextCut writeMText takeMText dropMTextmtqqMText symbolToMText labelToMTextmtextHeadToUpper$fIsStringMText$fHasCLReaderMText$fFromJSONMText $fToJSONMText $fToTextMText $fNFDataMText $fShowMText $fEqMText $fOrdMText $fDataMText$fGenericMText$fSemigroupMText $fMonoidMText$fContainerMText$fBuildableMText$fHashableMText Signature unSignature SecretKey PublicKey unPublicKey detSecretKeydetSecretKeyDotoPublicpublicKeyToBytes mkPublicKeypublicKeyLengthBytessignatureToBytes mkSignaturesignatureLengthBytesformatPublicKeymformatPublicKeyparsePublicKeyformatSignaturemformatSignatureparseSignatureformatSecretKeyparseSecretKeysigncheckSignature$fBuildablePublicKey$fNFDataPublicKey$fBuildableSecretKey$fNFDataSecretKey$fBuildableSignature$fNFDataSignature $fEqPublicKey$fShowPublicKey$fGenericPublicKey$fShowSecretKey $fEqSecretKey$fGenericSecretKey$fShowSignature $fEqSignature$fGenericSignatureKeyHashkhTagkhBytes KeyHashTagKeyHashEd25519KeyHashSecp256k1 KeyHashP256SignatureEd25519SignatureSecp256k1 SignatureP256SignatureGenericSecretKeyEd25519SecretKeySecp256k1 SecretKeyP256PublicKeyEd25519PublicKeySecp256k1 PublicKeyP256parseSignatureRawparsePublicKeyRawkeyHashLengthByteshashKey formatKeyHashmformatKeyHash parseKeyHashparseKeyHashRaw keyDecoderskeyHashDecoders$fFromJSONPublicKey$fToJSONPublicKey$fHasCLReaderSecretKey$fFromJSONSignature$fToJSONSignature!$fBuildableParseSignatureRawError$fNFDataKeyHashTag$fHasCLReaderKeyHash$fBuildableKeyHash$fNFDataKeyHash$fFromJSONKeyHash$fToJSONKeyHash$fEqParseSignatureRawError$fShowParseSignatureRawError$fGenericParseSignatureRawError$fShowKeyHashTag$fEqKeyHashTag$fOrdKeyHashTag$fBoundedKeyHashTag$fEnumKeyHashTag$fGenericKeyHashTag $fShowKeyHash $fEqKeyHash $fOrdKeyHash$fGenericKeyHashChainId ChainIdUnsafe unChainId Timestamp unTimestampMutezunMutezmkMutezmkMutez' unsafeMkMuteztoMutezaddMutezunsafeAddMutezsubMutezunsafeSubMutezmulMutez divModMutezdivModMutezInt mutezToInt64 zeroMutezoneMutez prettyTeztimestampToSecondstimestampFromSecondstimestampFromUTCTimetimestampToUTCTimetimestampPlusSecondsformatTimestampparseTimestamptimestampQuotegetCurrentTime farFuturefarPast mkChainIdmkChainIdUnsafe dummyChainId formatChainIdmformatChainId parseChainId chainIdLength $fNFDataMutez$fHasCLReaderMutez$fBoundedMutez$fBuildableMutez$fBuildableTimestamp$fNFDataTimestamp$fBuildableChainId$fNFDataChainId$fExceptionParseChainIdError$fBuildableParseChainIdError $fShowMutez $fEqMutez $fOrdMutez $fDataMutez$fGenericMutez $fEnumMutez$fShowTimestamp $fEqTimestamp$fOrdTimestamp$fDataTimestamp$fGenericTimestamp $fShowChainId $fEqChainId$fGenericChainId$fShowParseChainIdError$fEqParseChainIdError$fFromJSONMutez $fToJSONMutez$fFromJSONChainId$fToJSONChainId$fFromJSONTimestamp$fToJSONTimestamp TezosMutez unTezosMutez TezosInt64 TezosBigNum StringEncodeunStringEncode$fToJSONStringEncode$fFromJSONStringEncode$fToJSONStringEncode0$fBuildableStringEncode$fFromJSONStringEncode0$fFromJSONTezosMutez$fToJSONTezosMutez$fGenericStringEncode$fEqStringEncode$fOrdStringEncode$fBoundedStringEncode$fReadStringEncode$fShowStringEncode$fEnumStringEncode$fNumStringEncode$fIntegralStringEncode$fBitsStringEncode$fRealStringEncode$fNFDataStringEncode$fHashableStringEncode$fShowTezosMutez$fEqTezosMutez$fOrdTezosMutezMichelinePrimApmpaPrimmpaArgs mpaAnnotsAnnotationTypeAnnotationVariableAnnotationField Expression ExpressionIntExpressionStringExpressionBytes ExpressionSeqExpressionPrimMichelinePrimitivemichelsonPrimitive annotFromText annotToText$fToJSONExpression$fFromJSONExpression$fToJSONMichelinePrimAp$fFromJSONMichelinePrimAp$fBuildableExpression$fPlatedExpression$fEqMichelinePrimitive$fOrdMichelinePrimitive$fToJSONMichelinePrimitive$fFromJSONMichelinePrimitive$fShowMichelinePrimitive$fDataMichelinePrimitive$fEqMichelinePrimAp$fShowMichelinePrimAp$fDataMichelinePrimAp$fEqExpression$fShowExpression$fDataExpressionencodeExpressioneitherDecodeExpressiondecodeExpressionParseContractAddressError$ParseContractAddressWrongBase58CheckParseContractAddressWrongSizeParseContractAddressWrongPrefixParseAddressRawErrorParseAddressRawWrongSizeParseAddressRawInvalidPrefix!ParseAddressRawMalformedSeparatorParseAddressErrorParseAddressWrongBase58CheckParseAddressBothFailedOriginationIndexunOriginationIndex GlobalCounterunGlobalCounter OperationHashunOperationHashAddress KeyAddressContractAddress ContractHash mkKeyAddressdetGenKeyAddressmkContractAddressmkContractHashHack formatAddressmformatAddress parseAddressparseAddressRawparseContractHashunsafeParseContractHashunsafeParseAddressunsafeParseAddressRaw$fNFDataContractHash$fFromJSONKeyAddress$fFromJSONAddress$fToJSONKeyAddress$fToJSONAddress$fHasCLReaderAddress$fBuildableAddress$fNFDataAddress$fBuildableParseAddressRawError$fNFDataParseAddressRawError$$fBuildableParseContractAddressError!$fNFDataParseContractAddressError$fBuildableParseAddressError$fNFDataParseAddressError$fShowContractHash$fEqContractHash$fOrdContractHash$fGenericContractHash $fShowAddress $fEqAddress $fOrdAddress$fGenericAddress$fShowOperationHash$fEqOperationHash$fOrdOperationHash$fGenericOperationHash$fNFDataOperationHash$fShowGlobalCounter$fEqGlobalCounter$fGenericGlobalCounter$fNFDataGlobalCounter$fToJSONGlobalCounter$fFromJSONGlobalCounter$fNumGlobalCounter$fShowOriginationIndex$fEqOriginationIndex$fOrdOriginationIndex$fGenericOriginationIndex$fNFDataOriginationIndex$fEqParseAddressRawError$fShowParseAddressRawError$fGenericParseAddressRawError$fShowParseContractAddressError$fEqParseContractAddressError"$fGenericParseContractAddressError$fShowParseAddressError$fEqParseAddressError$fGenericParseAddressErrorInternalByteStringEltValue'ValueInt ValueString ValueBytes ValueUnit ValueTrue ValueFalse ValuePair ValueLeft ValueRight ValueSome ValueNoneValueNilValueSeqValueMap ValueLambdaunInternalByteString$fFromJSONInternalByteString$fToJSONInternalByteString$fNFDataInternalByteString$fBuildableElt$fBuildableValue'$fRenderDocElt$fRenderDocValue' $fNFDataElt$fNFDataValue'$fDataInternalByteString$fEqInternalByteString$fShowInternalByteString$fGenericInternalByteString $fEqValue' $fShowValue'$fFunctorValue' $fDataValue'$fGenericValue'$fEqElt $fShowElt $fFunctorElt $fDataElt $fGenericElt$fFromJSONValue'$fToJSONValue' $fFromJSONElt $fToJSONElt InstrAbstractEXTDROPNDROPDUPSWAPDIGDUGPUSHSOMENONEUNITIF_NONEPAIRCARCDRLEFTRIGHTIF_LEFTNILCONSIF_CONSSIZE EMPTY_SET EMPTY_MAP EMPTY_BIG_MAPMAPITERMEMGETUPDATEIFLOOP LOOP_LEFTLAMBDAEXECAPPLYDIPDIPNFAILWITHCASTRENAMEPACKUNPACKCONCATSLICEISNATADDSUBMULEDIVABSNEGLSLLSRORANDXORNOTCOMPAREEQNEQLTGTLEGEINTSELFCONTRACTTRANSFER_TOKENS SET_DELEGATECREATE_CONTRACTIMPLICIT_ACCOUNTNOWAMOUNTBALANCECHECK_SIGNATURESHA256SHA512BLAKE2BHASH_KEYSOURCESENDERADDRESSCHAIN_ID ExpandedOpPrimExSeqEx WithSrcEx ExpandedInstrflattenExpandedOp$fBuildableInstrAbstract$fRenderDocInstrAbstract$fNFDataInstrAbstract$fShowInstrAbstract$fBuildableExpandedOp$fRenderDocExpandedOp$fNFDataExpandedOp$fEqInstrAbstract$fFunctorInstrAbstract$fDataInstrAbstract$fGenericInstrAbstract$fShowExpandedOp$fEqExpandedOp$fDataExpandedOp$fGenericExpandedOp$fFromJSONExpandedOp$fToJSONExpandedOp$fFromJSONInstrAbstract$fToJSONInstrAbstractExpandedExtInstrValueOpSizeunOpSizeopSizeHardLimitsmallTransferOpSize instrOpSizeexpandedInstrsOpSize valueOpSize$fMonoidOpSize$fSemigroupOpSize$fBuildableOpSize$fAnnsOpSizeVarargOpSize$fAnnsOpSizeVararg->$fAnnsOpSizeVararg->0 $fShowOpSize $fEqOpSize $fOrdOpSize 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 compareExtcastIgnoringPhantomeqTypeIgnoringPhantomNotesNTKeyNTUnit NTSignature NTChainIdNTOptionNTListNTSet NTOperation NTContractNTPairNTOrNTLambdaNTMapNTBigMapNTIntNTNatNTStringNTBytesNTMutezNTBool NTKeyHash NTTimestamp NTAddress $fEqNotesAnnConvergeError notesSingnotesT starNotesisStarorAnnconverge insertTypeAnn convergeAnns$fRenderDocNotes$fBuildableNotes $fShowNotes $fNFDataNotes$fBuildableAnnConvergeError$fEqAnnConvergeError$fShowAnnConvergeError$fNFDataAnnConvergeError AsUTypeExtAsUType fromUTypemkUType withUTypeEpLiftSequence EplArgHere EplWrapLeft EplWrapRight ParamEpErrorParamEpDuplicatedNamesParamEpUncallableArmArmCoordAcLeftAcRight ArmCoords ParamNotesParamNotesUnsafepnNotes pnRootAnnParseEpAddressErrorParseEpAddressBadAddressParseEpAddressRawBadAddressParseEpAddressBadEntryopintParseEpAddressBadRefAnnParseEpAddressRefAnnErrorParseEpAddressInvalidLength EpAddress eaAddress eaEntrypointformatEpAddressmformatEpAddressparseEpAddressunsafeParseEpAddressparseEpAddressRawunsafeParseEpAddressRawstarParamNotes mkParamNotes$fNFDataEpAddress$fBuildableEpAddress$fBuildableParseEpAddressError$fNFDataParseEpAddressError$fBuildableArmCoord$fNFDataArmCoord$fBuildableParamEpError$fNFDataParamEpError$fShowEpAddress $fEqEpAddress$fOrdEpAddress$fGenericEpAddress$fShowParseEpAddressError$fEqParseEpAddressError$fGenericParseEpAddressError$fShowParamNotes$fEqParamNotes$fGenericParamNotes$fNFDataParamNotes$fShowArmCoord $fEqArmCoord$fGenericArmCoord$fShowParamEpError$fEqParamEpError$fGenericParamEpError$fShowEpLiftSequence$fEqEpLiftSequenceMkEntrypointCallResSomeEntrypointCallTSomeEpcForbidOrEntrypointCallTEntrypointCallepcName epcParamProxyepcLiftSequenceepcCallRootUnsafe epcPrimitivesepcCallRootUnsafe sepcPrimitivesepcNamemkEntrypointCall$fBuildableEpLiftSequence$fNFDataEpLiftSequence$fBuildableEntrypointCallT$fNFDataEntrypointCallT$fBuildableSomeEntrypointCallT$fNFDataSomeEntrypointCallT$fEqSomeEntrypointCallT$fShowSomeEntrypointCallT$fShowEntrypointCallT$fEqEntrypointCallTSomeConstrainedValue'SomeConstrainedValue SomeValue' SomeValueVKeyVUnit VSignatureVChainIdVOptionVListVSetVOp VContractVPairVOrVLamVMapVBigMapVIntVNatVStringVBytesVMutezVBoolVKeyHash VTimestampVAddress Comparability CanBeComparedCannotBeComparedComparabilityScope ComparableRemFailRfNormal RfAlwaysFails ContractOut ContractOut1 ContractInp ContractInp1CreateContract ccOriginator ccDelegate ccBalance ccStorageValccContractCode SetDelegate sdMbKeyHashTransferTokensttTransferArgumentttAmount ttContract Operation'OpTransferTokens OpSetDelegateOpCreateContractrfMerge rfAnyInstr rfMapAnyInstrgetComparableProofScheckComparabilitycomparabilityPresenceaddressToVContractbuildVContractcompileEpLiftSequence liftCallArgvalueTypeSanitywithValueTypeSanity eqValueExt$fBuildableSetDelegate$fNFDataSetDelegate $fEqRemFail$fNFDataRemFail$fCheckScopeComparable $fOrdValue'$fComparableTAddress$fComparableTTimestamp$fComparableTKeyHash$fComparableTBool$fComparableTMutez$fComparableTBytes$fComparableTString$fComparableTNat$fComparableTInt$fComparableTPair$fBuildableCreateContract$fNFDataCreateContract$fBuildableTransferTokens$fNFDataTransferTokens$fEqOperation'$fBuildableOperation'$fEqSomeValue'$fShowSetDelegate$fEqSetDelegate$fGenericSetDelegate$fShowTransferTokens$fEqTransferTokens$fGenericTransferTokens$fShowSomeConstrainedValue'$fShowSomeValue' $fShowRemFail$fEqCreateContract$fShowCreateContract$fShowOperation'$fNFDataOperation'EDivOp EDivOpRes EModOpRes convergeEDiv evalEDivOpSliceOp evalSliceConcatOp evalConcat evalConcat'GetOpGetOpKeyGetOpValevalGetUpdOpUpdOpKey UpdOpParamsevalUpdSizeOpevalSizeIterOpIterOpEliterOpDetachOneMapOpMapOpInpMapOpRes mapOpToList mapOpFromListMemOpMemOpKeyevalMemdivMichmodMich$fMemOpTBigMap $fMemOpTMap $fMemOpTSet $fMapOpTList $fMapOpTMap $fIterOpTSet $fIterOpTList $fIterOpTMap $fSizeOpTMap $fSizeOpTList $fSizeOpTSet$fSizeOpTBytes$fSizeOpTString $fUpdOpTSet$fUpdOpTBigMap $fUpdOpTMap $fGetOpTMap$fGetOpTBigMap$fConcatOpTBytes$fConcatOpTString$fSliceOpTBytes$fSliceOpTString$fEDivOpTMutezTNat$fEDivOpTMutezTMutez$fEDivOpTNatTNat$fEDivOpTNatTInt$fEDivOpTIntTNat$fEDivOpTIntTIntGeLeGtLtNeqEq'CompareLsrLslNotXorAndOrNegAbsMulAdd UnaryArithOp UnaryArithResevalUnaryArithOp ArithErrorMutezArithErrorShiftArithErrorMutezArithErrorType AddOverflow MulOverflow SubUnderflowShiftArithErrorType LslOverflow LsrUnderflowArithOpArithRes convergeArithevalOpcommutativityProof compareOp$fBuildableShiftArithErrorType$fNFDataShiftArithErrorType$fBuildableMutezArithErrorType$fNFDataMutezArithErrorType$fBuildableArithError$fNFDataArithError$fArithOpTYPEAddTMutezTMutez$fArithOpTYPEAddTIntTTimestamp$fArithOpTYPEAddTTimestampTInt$fArithOpTYPEAddTIntTInt$fArithOpTYPEAddTNatTNat$fArithOpTYPEAddTIntTNat$fArithOpTYPEAddTNatTInt$fArithOpTYPESubTMutezTMutez$$fArithOpTYPESubTTimestampTTimestamp$fArithOpTYPESubTTimestampTInt$fArithOpTYPESubTIntTInt$fArithOpTYPESubTNatTNat$fArithOpTYPESubTIntTNat$fArithOpTYPESubTNatTInt$fArithOpTYPEMulTMutezTNat$fArithOpTYPEMulTNatTMutez$fArithOpTYPEMulTIntTInt$fArithOpTYPEMulTNatTNat$fArithOpTYPEMulTIntTNat$fArithOpTYPEMulTNatTInt$fUnaryArithOpTYPEAbsTInt$fUnaryArithOpTYPENegTNat$fUnaryArithOpTYPENegTInt$fArithOpTYPEOrTBoolTBool$fArithOpTYPEOrTNatTNat$fArithOpTYPEAndTBoolTBool$fArithOpTYPEAndTNatTNat$fArithOpTYPEAndTIntTNat$fArithOpTYPEXorTBoolTBool$fArithOpTYPEXorTNatTNat$fUnaryArithOpTYPENotTBool$fUnaryArithOpTYPENotTNat$fUnaryArithOpTYPENotTInt$fArithOpTYPELslTNatTNat$fArithOpTYPELsrTNatTNat$fUnaryArithOpTYPEEq'TInt$fUnaryArithOpTYPENeqTInt$fUnaryArithOpTYPELtTInt$fUnaryArithOpTYPEGtTInt$fUnaryArithOpTYPELeTInt$fUnaryArithOpTYPEGeTInt$fShowShiftArithErrorType$fEqShiftArithErrorType$fOrdShiftArithErrorType$fGenericShiftArithErrorType$fShowMutezArithErrorType$fEqMutezArithErrorType$fOrdMutezArithErrorType$fGenericMutezArithErrorType$fShowArithError$fEqArithError$fOrdArithError$fGenericArithError ContractDoc cdContents cdDefinitionscdDefinitionsSetcdDefinitionIdsSubDocDocBlock DocSectionDocElemdeItemdeSubSomeDocDefinitionItem SomeDocItemDocSectionNameStyleDocSectionNameBigDocSectionNameSmall DocItemRefDocItemRefInlined DocItemNoRefDocItemReferencedKindDocItemPlacementKindDocItemInlinedDocItemInDefinitions DocItemPos DocItemIdDocItemDocItemPlacementDocItemReferenced docItemPosdocItemSectionNamedocItemSectionDescriptiondocItemSectionNameStyle docItemRefdocItemToMarkdown docItemToTocdocItemDependencies docItemsOrder mdTocFromRefdocItemPositiondocDefinitionRef deIsAtomicdocItemSectionRefdocItemToBlocklookupDocBlockSectionsubDocToMarkdown$fBuildableDocItemPos$fToAnchorDocItemRef$fOrdSomeDocDefinitionItem$fEqSomeDocDefinitionItem$fShowSomeDocItem$fNFDataSomeDocItem$fToAnchorSectionAnchor$fShowDocSection $fEqDocItemId$fOrdDocItemId$fShowDocItemId$fToAnchorDocItemId$fEqDocItemPos$fOrdDocItemPos$fShowDocItemPosDConversionInfoDAnchorDTocDCommentGitRepoSettingsgrsMkGitRevision DGitRevisionDGitRevisionKnownDGitRevisionUnknown DDescriptionDNameDGeneralInfoSectionWithFinalizedDocContainsUpdateableDocmodifyDocEntirely ContainsDocbuildDocUnfinalized DocGrouping cdContentsLcdDefinitionIdsLcdDefinitionsLcdDefinitionsSetLcontractDocToMarkdowncontractDocToTocdocGroupContent finalizedAsIsbuildDocbuildMarkdownDoc modifyDocmorleyRepoSettingsmkDGitRevision attachGitInfo attachTocattachDocCommons$fMonoidContractDoc$fSemigroupContractDoc$fShow->$fDocItemDGeneralInfoSection $fIsString->$fDocItemDName$fDocItemDDescription$fDocItemDGitRevision$fDocItemDComment $fDocItemDToc$fDocItemDAnchor$fDocItemDConversionInfo$fFunctorWithFinalizedDoc$fApplicativeWithFinalizedDoc$fMonadWithFinalizedDoccCode cParamNotes cStoreNotes cEntriesOrder ContractCodeExtInstr TEST_ASSERTPRINTDOC_ITEM COMMENT_ITEM CommentTypeFunctionStarts FunctionEndsStatementStarts StatementEnds JustCommentStackTypeCommentunPrintCommentInstrWithLocInstrWithNotesInstrWithVarNotes FrameInstrSeqNopExtNestedDocGroupAnnCARAnnCDRAnnPAIRCONCAT' ConstraintDUGConstraintDUG' ConstraintDIGConstraintDIG'ConstraintDIPNConstraintDIPN' PackedNotesUNPAIR mkStackRefdefaultContractmapContractCode$fRenderDocPackedNotes$fBuildablePackedNotes$fShowPackedNotes$fNFDataPackedNotes$fIsStringPrintComment$fNFDataCommentType$fNFDataContract$fNFDataExtInstr $fMonoidInstr$fSemigroupInstr$fSemigroupPrintComment$fMonoidPrintComment$fShowCommentType$fGenericCommentType$fShowExtInstr$fGenericExtInstr $fEqContract$fShowContract $fShowInstr $fNFDataInstr OperationCtorEffectsAppceaNameceaApplyEffects DfsSettings dsGoToValuesdsCtorEffectsAppceaBottomToTopdfsInstr dfsFoldInstrdfsModifyInstr linearizeLeftlinearizeLeftDeepdfsValue dfsFoldValuedfsModifyValue isStringValue isBytesValueallAtomicValues$fShowCtorEffectsApp$fDefaultDfsSettings$fShowDfsSettings WellTypedIsoValuesStack toValStack fromValStackToTs'ToTsGenericIsoValue GIsoValue GValueTypeBigMapunBigMap ContractRef crAddress crEntrypointWellTypedIsoValue WellTypedToTSomeEntrypointCall AnyIsoValue SomeIsoValueToT'IsoValueToTtoValfromVal KnownIsoTcoerceContractRefcontractRefToAddrtotsKnownLemmatotsAppendLemma $fGIsoValueU1$fGIsoValue:*:$fGIsoValue:+: $fGIsoValueM1$fWellTypedTAddress$fWellTypedTTimestamp$fWellTypedTKeyHash$fWellTypedTBool$fWellTypedTMutez$fWellTypedTBytes$fWellTypedTString$fWellTypedTNat$fWellTypedTInt$fWellTypedTBigMap$fWellTypedTMap$fWellTypedTLambda$fWellTypedTOr$fWellTypedTPair$fWellTypedTContract$fWellTypedTOperation$fWellTypedTSet$fWellTypedTList$fWellTypedTOption$fWellTypedTChainId$fWellTypedTSignature$fWellTypedTUnit$fWellTypedTKey $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$fIsoValuesStack:$fIsoValuesStack[]$fIsoValueContractRef$fBuildableContractRef $fEqBigMap $fShowBigMap$fDefaultBigMap$fSemigroupBigMap$fMonoidBigMap$fEqContractRef$fShowContractRef$fIsoValueNamedF$fIsoValueNamedF0$fIsoValueIdentity InstrUnwrapCGCaseBranchInput GCaseClauses CaseClauses CaseClauseCaseClauseParam InstrCaseCMyCompoundType InstrWrapOneC InstrWrapC CtorOnlyFieldCtorHasOnlyField GetCtorFieldIsPrimitiveValueAppendCtorFieldAxiomAppendCtorFieldExtractCtorField CtorFieldOneFieldNoFieldsappendCtorFieldAxiom instrWrap instrWrapOnehsWrap 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$fIsoValueMyTypeWithNamedFieldInstrDeconstructCInstrConstructCConstructorFieldNamesConstructorFieldTypesCastFieldConstructorscastFieldConstructorsImplFieldConstructorInstrSetFieldCInstrGetFieldC GetFieldType instrGetField instrSetFieldinstrConstructinstrConstructStackinstrDeconstruct$fGInstrGetname:*::f$fGInstrGetname:*::f0$fGInstrGetnameK1[]f'$fGInstrGetnameM1pathf$fGInstrSetFieldname:*::f$fGInstrSetFieldname:*::f0$fGInstrSetFieldnameK1[]f'$fGInstrSetFieldnameM1pathf$fCastFieldConstructors::$fCastFieldConstructors[][]$fGInstrConstructK1$fGInstrConstruct:+:$fGInstrConstructU1$fGInstrConstruct:*:$fGInstrConstructM1$fGInstrDeconstructK1$fGInstrDeconstruct:+:$fGInstrDeconstructU1$fGInstrDeconstruct:*:$fGInstrDeconstructM1$fGenericMyType2$fIsoValueMyType2 LooseSumC ComposeResult ComposeOkComposeCtorNotFoundComposeFieldTypeMismatch toTaggedVal fromTaggedVal$fMonoidComposeResult$fSemigroupComposeResult $fGLooseSumV1$fGLooseSum:+: $fGLooseSumM1$fGAccessField:*:$fGAccessFieldU1$fGAccessFieldK1$fGAccessFieldM1$fGLooseSumM10$fFunctorComposeResultconvertParamNotesconvertContractCodeconvertContract untypeValue instrToOpssampleValueFromUntypeflattenEntrypoints $fEqInstrcontractOpSizeFieldRepfrName frDescription frTypeRepConstructorRepcrName crDescriptioncrFieldsADTRepcrDescriptionL crFieldsLcrNameLPolyTypeHasDocCGProductHasDoc GTypeHasDoc IsHomomorphicHaveCommonTypeCtor DStorageTypeDTypeSomeTypeWithDocTypeDocMichelsonRepTypeDocHaskellRep TypeHasDocTypeDocFieldDescriptions typeDocNametypeDocMdDescriptiontypeDocMdReferencetypeDocDependenciestypeDocHaskellReptypeDocMichelsonRep WithinParensfrDescriptionLfrNameL frTypeRepL buildADTRepapplyWithinParensdTypeDep dTypeDepPdStoragecustomTypeDocMdReferencehomomorphicTypeDocMdReferencepoly1TypeDocMdReferencepoly2TypeDocMdReferencegenericTypeDocDependencieshomomorphicTypeDocHaskellRepconcreteTypeDocHaskellRepconcreteTypeDocHaskellRepUnsafehaskellRepNoFieldshaskellAddNewtypeFieldhaskellRepStripFieldPrefixhomomorphicTypeDocMichelsonRepconcreteTypeDocMichelsonRep!concreteTypeDocMichelsonRepUnsafe$fHaveCommonTypeCtorkkaa$fHaveCommonTypeCtorkkacbc$fIsHomomorphicka$fIsHomomorphicka0$fTypeHasDocNamedF$fTypeHasDoc()$fTypeHasDocChainId$fTypeHasDocSignature$fTypeHasDocPublicKey$fTypeHasDocEpAddress$fTypeHasDocAddress$fTypeHasDocTimestamp$fTypeHasDocKeyHash$fTypeHasDocMutez$fTypeHasDocByteString$fTypeHasDocBool$fTypeHasDocNatural$fTypeHasDocInteger$fGTypeHasDocV1$fGTypeHasDoc:+:$fGTypeHasDocM1$fGTypeHasDocM10$fTypeHasDocOperation'$fTypeHasDocMText$fDocItemDType $fOrdDType $fEqDType $fShowDType$fDocItemDStorageType$fGProductHasDocU1$fGProductHasDocM1$fGProductHasDocM10$fGProductHasDoc:*:$fGTypeHasDocM11$fTypeHasDoc(,,,,,,)$fTypeHasDoc(,,,,,)$fTypeHasDoc(,,,,)$fTypeHasDoc(,,,)$fTypeHasDoc(,,)$fTypeHasDocContractRef$fTypeHasDoc(,)$fTypeHasDocEither$fTypeHasDocMaybe$fTypeHasDoc[]$fTypeHasDocBigMap$fTypeHasDocMap$fTypeHasDocSet$fIsStringDocTypeRepLHS$fBuildableDocTypeRepLHS$fGenericDStorageType$fEqDStorageType$fOrdDStorageTypedocInstrbuildInstrDocWithGitRev buildInstrDocmodifyInstrAllDocmodifyInstrDoccutInstrNonDoc$fContainsUpdateableDocInstr$fContainsDocInstr NotWellTyped TcExtFrames BoundVarsSomeContractAndStorage SomeContract SomeInstr:/ SomeInstrOut::: AnyOutInstrSomeHSTHSTSNil::&::&+-:&mapSomeInstrOut mapSomeInstrmapSomeContract noBoundVarsgetWTPwithWTPm unsafeWithWTP$fEqHST$fBuildableHST $fShowHST $fNFDataHST $fEqSomeHST$fNFDataSomeHST$fShowSomeInstrOut$fShowSomeInstr$fNFDataSomeContract$fBuildableNotWellTyped$fShowSomeContractAndStorage$fShowSomeContract $fShowSomeHST IllTypedInstrSemiTypedInstr NonTypedInstr TypeCheckedOp WellTypedOp IllTypedOpTypeCheckedInstr someInstrToOp$fRenderDocTypeCheckedOp$fEqTypeCheckedOp$fEqIllTypedInstr$fGenericIllTypedInstr$fNFDataIllTypedInstr$fNFDataTypeCheckedOpExtErrorLengthMismatchVarError TypeMismatch TyVarMismatchStkRestMismatchTestAssertErrorInvalidStackReference StackSizeTCErrorTCFailedOnInstrTCFailedOnValueTCContractErrorTCUnreachableCode TCExtErrorTCIncompletelyTyped TCTypeErrorAnnError TypeEqError StackEqErrorUnsupportedTypeForScopeNotNumericTypesUnexpectedTypeInvalidInstructionInvalidValueTypeNotEnoughItemsOnStackIllegalEntrypointUnknownContractEntrypointNotFoundIllegalParamDecl NegativeNat MutezOverflowInvalidAddressInvalidKeyHashInvalidTimestampCodeAlwaysFails EmptyCodeAnyError TypeContextLambdaArgument LambdaCodeDipCode ConsArgumentComparisonArgumentsContractParameterContractStorageArithmeticOperation IterationCast CarArgument CdrArgumentConcatArgumentContainerKeyTypeContainerValueType ExpectType ExpectTypeVarExpectStackVar ExpectBool ExpectInt ExpectNat ExpectByte ExpectString ExpectAddress ExpectKey ExpectKeyHashExpectSignatureExpectContract ExpectMutez ExpectList ExpectSet ExpectMap ExpectBigMap ExpectOption ExpectPairExpectOr ExpectLambda$fBuildableExpectType$fNFDataExpectType$fBuildableTypeContext$fBuildableTCTypeError$fNFDataStackSize$fBuildableExtError$fNFDataExtError$fExceptionTCError $fShowTCError$fBuildableTCError$fNFDataTCError$fShowExpectType$fEqExpectType$fGenericExpectType$fShowTypeContext$fEqTypeContext$fGenericTypeContext$fNFDataTypeContext$fShowTCTypeError$fEqTCTypeError$fGenericTCTypeError$fNFDataTCTypeError$fShowStackSize $fEqStackSize$fGenericStackSize $fEqExtError$fGenericExtError $fEqTCError$fGenericTCErrorTypeCheckedSeq WellTypedSeqMixedSeq IllTypedSeqseqToOps tcsEitherTypeCheckOptions tcVerbose TypeCheckEnv tcExtFramestcMode TypeCheckModeTypeCheckValueTypeCheckContract TypeCheckTest TypeCheckPackTcOriginatedContracts SomeParamTypeTypeCheckNoExcept TypeCheckmkSomeParamTypeUnsafemkSomeParamType$fBuildableSomeParamType$fEqSomeParamType$fShowSomeParamType$fDefaultTypeCheckOptionsTcInstrHandlerTypeCheckInstrNoExceptTypeCheckInstrTcResult tcExtFramesLtcModeL runTypeCheckrunTypeCheckIsolatedrunTypeCheckInstrIsolated liftNoExcept liftNoExcept'throwingTCErrorthrowingTCError'tcEither preserving preserving'guarding guarding_deriveSpecialFNsderiveSpecialVNderiveVN deriveNsOrderiveNsOption convergeHSTEl convergeHSThstToTseqHSTeqHST1 lengthHSTensureDistinctAsceqTypeonTypeCheckInstrErronScopeCheckInstrErrtypeCheckInstrErrtypeCheckInstrErr'onTypeCheckInstrAnnErrwithCompareableChecktypeCheckImplStripped typeCheckImpl matchTypesmemImplgetImplupdImplsizeImpl sliceImpl concatImpl' concatImpl arithImpladdImpledivImplsubImplmulImplunaryArithImplunaryArithImplAnnotatedtcFailedOnValuetypeCheckValImpl typeCheckExttypeCheckContractAndStoragetypeCheckContract typeCheckListtypeCheckListNoExcepttypeCheckValuetypeVerifyParametertypeVerifyStoragetypeCheckParametertypeCheckStoragetypeCheckInstrTxDatatdSenderAddress tdParameter tdEntrypointtdAmountTxParam TxTypedParamTxUntypedParam $fShowTxData $fShowTxParam tdAmountL tdEntrypointL tdParameterLtdSenderAddressL AddressStateASSimple ASContract ContractState csBalance csContract csStorage$fBuildableContractState$fFromJSONContractState$fToJSONContractState$fBuildableAddressState$fShowAddressState$fGenericAddressState$fShowContractStateGState gsChainId gsAddresses gsCounter asBalance$fFromJSONAddressState$fToJSONAddressState $fShowGState gsAddressesL gsChainIdL gsCounterLGStateUpdateErrorGStateAddressExistsGStateUnknownAddressGStateNotContractGStateStorageNotMatch GStateUpdate GSAddAddressGSSetStorageValue GSSetBalanceGSIncrementCountergenesisSecretsgenesisKeyHashesgenesisAddressesgenesisKeyHashgenesisAddressgenesisSecretKeygenesisAddress1genesisAddress2genesisAddress3genesisAddress4genesisAddress5genesisAddress6 initGState readGState writeGState applyUpdate applyUpdatesextractAllContracts$fFromJSONGState$fToJSONGState$fExceptionGStateParseError$fBuildableGStateUpdate$fBuildableGStateUpdateError$fShowGStateParseError$fShowGStateUpdateError$fShowGStateUpdateprintUntypedContractprintTypedContractCodeprintTypedContractprintTypedValueprintUntypedValueprintSomeContractMacroCASETAGACCESSSET CONSTRUCTVIEWVOIDCMPIFXIFCMPFAILPAPAIRCADRSET_CADRMAP_CADRDIIPDUUPASSERTASSERTX ASSERT_CMP ASSERT_NONE ASSERT_SOME ASSERT_LEFT ASSERT_RIGHTIF_SOMEIF_RIGHT ParsedValue ParsedInstrParsedUExtInstrParsedOpPrimMacLMac CadrStructAD UnpairStructUFUP PairStructFPLetMacrolmNamelmSiglmExpr expandListexpandContract expandValueexpand expandMacro expandPapairexpandUnpapair expandCadr expandSetCadr expandMapCadr mapPairLeavesmapUnpairLeaves$fBuildablePairStruct$fNFDataPairStruct$fBuildableUnpairStruct$fNFDataUnpairStruct$fBuildableCadrStruct$fNFDataCadrStruct $fNFDataMacro$fBuildableMacro$fNFDataParsedOp$fBuildableParsedOp$fRenderDocParsedOp$fNFDataLetMacro$fBuildableLetMacro$fEqPairStruct$fShowPairStruct$fDataPairStruct$fGenericPairStruct$fEqUnpairStruct$fShowUnpairStruct$fDataUnpairStruct$fGenericUnpairStruct$fEqCadrStruct$fShowCadrStruct$fDataCadrStruct$fGenericCadrStruct $fEqMacro $fShowMacro $fDataMacro$fGenericMacro $fEqParsedOp$fShowParsedOp$fDataParsedOp$fGenericParsedOp $fEqLetMacro$fShowLetMacro$fDataLetMacro$fGenericLetMacro$fFromJSONParsedOp$fToJSONParsedOp$fFromJSONLetMacro$fToJSONLetMacro$fFromJSONPairStruct$fToJSONPairStruct$fFromJSONUnpairStruct$fToJSONUnpairStruct$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 intLiteralmkLetValnotenoteVnoteDefnoteF noteV2DefnotesTVF notesTVF2 notesTVF2DefnotesVFnotesTVnotesTF fieldTypetype_field typeWithParenextInstr printComment stackType primInstrops'dupOpcmpOppairOpmapOpmacrodupNMacduupMacpairMac mapCadrMacifCmpMacletBlockletInnerletTypemkLetMac parseNoEnvprogramvalue parseValueparseExpandValue codeEntryparsedOpopsutypeQ uparamTypeQtransformStringstransformBytes unpackValue unpackValue' unpackInstr'decodeContract decodeTypepackValuePrefix packValue packValue' encodeValue'packT' packCode' encodeValueencodeKeyHashRawencodeEpAddressencodeIntPayload packNotedT'FromExpressionfromExpressionFromExpressionError ToExpression toExpression$fToExpressionContract$fToExpressionValue'$fToExpressionType$fToExpressionNotes$fToExpressionT$fToExpressionInstr$fExceptionFromExpressionError$fBuildableFromExpressionError$fFromExpressionInstr$fFromExpressionT$fFromExpressionType$fFromExpressionContract'$fFromExpression[]$fFromExpressionValue'$fShowFromExpressionError$fEqFromExpressionErrorOriginationOperation ooOriginator ooDelegate ooBalance ooStorage ooContractmkOriginationOperationHash$fShowOriginationOperationRule OptimizerConf ocGotoValues ocRulesetdefaultOptimizerConfoptimizeoptimizeWithConf defaultRulesdefaultRulesAndPushPackorRule orSimpleRule$fDefaultOptimizerConf ocGotoValuesL InstrRunnerStkElseValueseVarAnnseNotesEvalMInterpreterStateMonadgetInterpreterStateputInterpreterStatestateInterpreterStatemodifyInterpreterStateInterpreterState isMorleyLogsisRemainingStepsisOriginationNonceRemainingSteps SomeItStackContractReturn MorleyLogsInterpretResultiurOps iurNewStorage iurNewStateInterpretErrorMichelsonFailedMichelsonFailedWithMichelsonArithErrorMichelsonGasExhaustionMichelsonFailedTestAssert ContractEnvceNow ceMaxSteps ceBalance ceContractsceSelfceSourceceSenderceAmount ceChainIdceOperationHashceGlobalCounterpickMorleyLogs noMorleyLogshandleContractReturn mkInitStackfromFinalStack interpretinitInterpreterStateinterpretInstrinterpretInstrAnnotatedrunInstr runInstrNoGas runInstrImpl runUnpack$fBuildableMichelsonFailed$fEqMichelsonFailed$fNFDataMorleyLogs$fBuildableMorleyLogs$fBuildableInterpretError$fNFDataRemainingSteps$fNFDataInterpreterState$fInterpreterStateMonadExceptT$fEqMorleyLogs$fShowMorleyLogs$fGenericMorleyLogs$fDefaultMorleyLogs$fGenericInterpretError$fShowRemainingSteps$fGenericRemainingSteps$fEqRemainingSteps$fOrdRemainingSteps$fBuildableRemainingSteps$fNumRemainingSteps$fShowInterpreterState$fGenericInterpreterState $fEqStkEl $fShowStkEl$fShowInterpretResult$fShowInterpretError$fShowMichelsonFailed$fNFDataMichelsonFailed isMorleyLogsLdummyNow dummyMaxStepsdummyContractEnvdummyOrigination ExecutorRes _erGState _erUpdates_erInterpretResults_erRemainingSteps ExecutorOp OriginateOp TransferOp$fShowExecutorOp$fShowExecutorRes$fShowExecutorEnv$fGenericExecutorEnv$fShowExecutorLog$fGenericExecutorLog$fSemigroupExecutorLog$fMonoidExecutorLog$fShowExecutorState$fGenericExecutorStateerGStateerInterpretResultserRemainingSteps erUpdates ExecutorM ExecutorErrorExecutorError'EEUnknownContractEEInterpreterFailedEEAlreadyOriginatedEEUnknownSenderEEUnknownManagerEENotEnoughFundsEEZeroTransactionEEFailedToApplyUpdatesEEIllTypedParameterEEUnexpectedParameterTypeEEUnknownEntrypointelInterpreterResults elUpdates parseContractparseExpandContractreadAndParseContractprepareContractoriginateContract runContracttransfer runExecutorMrunExecutorMWithDBexecuteGlobalOperationsexecuteGlobalOriginationexecuteOriginationexecuteTransfer$fExceptionExecutorError'$fBuildableExecutorError'$fShowExecutorError'$fFunctorExecutorError' parserInfocontractFileOption nowOptionmaxStepsOption dbPathOption txDataOption keyHashOptionsecretKeyOption valueOption mutezOption addressOption onelineOptionentrypointOption mTextOption$fHasCLReaderValue'TypicalFailWithConstantScope'typicalFailWithTagisTypicalFailWithmodifyTypicalFailWith$fConstantScope'a AnalyzerResarConstStrings arConstBytes arErrorTagsanalyze$fMonoidAnalyzerRes$fSemigroupAnalyzerRes$fBuildableAnalyzerRes$fShowAnalyzerRes$fEqAnalyzerResGHC.Basemempty_rcWillNeedParensTrueWwl-pprint-text-1.2.0.1-f2bfefe22034312ce59b69f29add880d1d2256e46325ad73d1776e2c078e458fText.PrettyPrint.Leijen.TextDoc text-1.2.4.0Data.Text.InternalData.Text.Internal.BuilderBuilderStringdoRender ConHasFieldHasField GHC.GenericsRepHasAllFieldsImpl HasAllFieldsHasConstructorFieldDescriptionsValidImplversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameminimizeAnnSet trimEndNoAnn renderAnnrenderAnnGroupCharBoolFalse SomeSingTSomeSingData.Typeable.InternalTypeableSingfromSingtoSingTtoSingFailOnContractFoundPuniversum-1.6.1-feb74d29edc41a61b0de06fa402f3d29121212e577bc6fc320dbebeb8a0f5a01Universum.TypeOpsEachContainsContract ContainsOpforbiddenOpEviforbiddenContractTypeEvisomeNonEmpty Data.EitherRightLeft Fcf.UtilsTyEq EntriesTranspNamedCstrDepths CstrDepthtemplate-haskellLanguage.Haskell.TH.SyntaxName ncdCstrDepth ncdCstrNamencdOrigFieldNames ncdFieldsUnnamedEntriesReorderEntriesReorder gsEvalDepths CstrShapeControl.Monad.FailfailgsReorderCstrsOngsReorderFieldsOn CstrNamessimpleGenericStrategy reorderCstrs reifyDataTypelookupTypeNamederiveFullType cstrNamesmakeWeightedConstrsmakeUnbalancedRepXgeneric-deriving-1.13.1-c166254d241ceac90355f32d4f4251c6f2250de0853f61f4ca6a9a8601e3c375Generics.Deriving.THmakeRep0InlinedismantleGenericTreemakeUnbalancedFromfrommakeUnbalancedTotounbalancedFoldorigNameRwith-utf8-1.0.2.1-a53766951a28bb801df085ac5901b153b36c687b691f878095cfc79e540adc2e Main.Utf8withUtf8Yuncaught-exception-0.1.0-ed6fc7c1f8e84cb20e226f9071a04a39ef63782eb413f259af9e62d297005cd7Control.Exception.UncaughtwithDisplayExceptionHandler Data.DataRequireLongerOrSameLength'RequireLongerThan'OfLengthWithTailnamedFLmetavar GHC.MaybeNothingmkEntrypointsMapRecinvalidMCharErrorsecretKeyToBytes secretKeyTag GHC.NaturalNaturalWordJust chainIdPrefixbytestring-0.10.10.0Data.ByteString.Internal ByteStringGHC.WordWord64contractHashLengthBytes annsOpSizegcast Data.ProxyProxy GHC.ClassescompareverifyParamNoteswithEpLiftSequenceFailOnNonComparable IsComparableGHC.Realdivmod SectionAnchor_unSectionAnchorEqOrddocItemToMarkdownFulldocItemsOrderByIddocBlockToMarkdowndocItemSectionAnchor docBlockToTocdocItemToBlockGeneral subDocToTocDGitRevisionInfoGHC.ShowShow<>analyzeInstrFailurecontainers-0.6.2.1Data.Sequence.InternalWellTypedSuperCGInstrCaseBranch GInstrCase GInstrWrapLNRequireFound GLookupNamedGetNamedLookupNamedResultfailWithWrongCtorGInstrDeconstructGInstrConstruct GFieldNamesgInstrConstructStackGInstrSetField GInstrGetNamedF GAccessField GLooseSumsampleTypedValuePolyCTypeHasDocC DocTypeRepLHSmapADTRepFieldsbuildFieldNamesomeParamToParameterTypetypeCheckImplNoLastTypeComment workOnInstr checkVarscheckFncheckStackTypecreateStackRef genericIfgenesisAddressesNum addAddresssetStorageValue setBalanceLetaddLetletNameensureNotDuplicatecontracttransformConstants? expectTag expectDescTag manyForcedmanyfinalizeDecoder decodeLength decodeAsList decodeIntdecodeTypeCheckLam decodeNoAnn decodeAnns encodeAsList encodeList encodeString encodeBytes encodeMap encodeNumeric encodeInstrs encodeInstrencodeWithAnnsencodeVarNotedInstrencodeNotedInstrpushPack adjacentDropslinearizeAndReapplyfixpoint applyOnceadapter whileApplies mapToStkEl mapToValue runArithOp withStackElemGHC.IO.Handle.FDstdinUniversum.DebugerrorbeginGlobalOperationFailWithStringFailWithConstantPairFailWithStackValue