śĪ! z •Ī’b      !"#$%&'()*+,-./0123456789 : ; < = >?@A B C D E FGHIJKLM N O PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg h i j k l!m!n!o!p!q!r!s!t!u!v!w!x!y!z!{!|!} ~  €  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ  Ž‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©"Ŗ"«"¬"­"®"Æ"°"±"²"³"“"µ"¶ · ø ¹ ŗ » ¼ ½ ¾ æ Ą Į Ā Ć Ä Å Ę Ē Č É Ź Ė Ģ Ķ Ī Ļ Š#Ń$ŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģ%ķ%ī%ļ%š%ń%ņ%ó%ō%õ%ö%÷%ų%ł%ś%ū%ü%ż%ž%’%%%%%%%%%% % & & & &&&&&&&&&&&&&&&&&&& &!&"&#&$&%&&&'&(&)&*&+&,&-'.'/'0'1'2'3'4'5'6'7'8'9':';'<'='>'?'@'A'B'C'D'E'F'G'H'I'J'K'L'M'N(O(P(Q(R(S(T(U(V(W(X(Y(Z([(\(](^(_(`(a(b(c(d(e(f(g(h(i(j(k(l(m(n(o(p(q(r)s)t)u)v)w)x)y)z){)|)})~))€))‚)ƒ)„)…)†)‡)ˆ)‰)Š)‹)Œ))Ž)))‘)’)“)”)•)–)—)˜)™)š)›)œ))ž)Ÿ) )”)¢)£)¤)„)¦)§)Ø)©)Ŗ)«)¬)­)®)Æ)°)±*²*³*“*µ*¶*·*ø*¹*ŗ*»*¼*½*¾*æ*Ą*Į*Ā*Ć*Ä*Å*Ę*Ē*Č*É*Ź*Ė*Ģ*Ķ*Ī*Ļ*Š*Ń*Ņ*Ó*Ō*Õ*Ö*×*Ų*Ł*Ś*Ū*Ü*Ż*Ž*ß*ą*į*ā*ć*ä*å*ę*ē*č*é*ź*ė*ģ*ķ*ī*ļ+š+ń+ņ+ó+ō+õ+ö+÷+ų+ł+ś+ū+ü+ż+ž+’++++++++++ + + + + ++++++++++,,,,,,,,, ,!,",#,$,%,&,',(,),*,+,,,-,.,/,0,1,2,3,4,5,6,7,8,9,:,;,<,=,>,?,@,A,B,C-D-E-F-G-H-I-J-K-L-M-N-O-P-Q-R-S-T-U-V-W-X-Y-Z-[-\-]-^-_-`-a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z-{-|-}-~--€--‚-ƒ-„-…-†-‡-ˆ-‰-Š-‹-Œ--Ž---‘-’-“-”-•-–-—-˜-™-š-›-œ--ž-Ÿ- -”-¢-£-¤-„-¦-§-Ø-©-Ŗ-«-¬-­-®-Æ-°-±-²-³-“-µ-¶-·-ø-¹-ŗ-»-¼.½.¾.æ/Ą/Į/Ā/Ć/Ä/Å/Ę/Ē/Č/É/Ź/Ė0Ģ1Ķ1Ī1Ļ2Š3Ń3Ņ3Ó3Ō3Õ3Ö3×3Ų3Ł3Ś3Ū3Ü3Ż3Ž3ß3ą3į3ā3ć3ä3å3ę3ē3č3é3źėģķīļšńņ4ó4ō4õ4ö4÷4ų4ł4ś4ū4ü4ż4ž4’4444444444 4 4 4 4 4555566666666666666 6!6"6#6$6%6&6'6(6)6*6+6,6-6.6/606162636465666768696:6;6<6=6>6?6@6A6B6C6D6E6F6G6H6I6J6K6L6M6N6O6P6Q6R6S6T6U7V7W7X7Y7Z7[7\7]7^7_7`7a7b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}8~88€88‚8ƒ8„8…8†8‡8ˆ8‰8Š8‹8Œ88Ž888‘8’8“8”8•8–8—8˜8™8š8›8œ88ž8Ÿ8 8”8¢8£8¤8„8¦8§8Ø8©9Ŗ9«9¬9­9®9Æ9°9±9²9³9“9µ9¶9·9ø9¹9ŗ9»9¼9½9¾9æ9Ą9Į9Ā9Ć9Ä9Å9Ę9Ē9Č9É9Ź9Ė9Ģ9Ķ9Ī9Ļ9Š9Ń9Ņ9Ó9Ō9Õ9Ö9×9Ų9Ł9Ś9Ū9Ü9Ż9Ž9ß9ą9į9ā9ć:ä:å:ę:ē:č:é:ź:ė:ģ:ķ:ī:ļ:š:ń:ņ:ó:ō:õ:ö:÷:ų:ł:ś:ū:ü:ż:ž:’:::::::::: : : : : ::::::::::::::::::: :!:":#:$:%:&:':(:):*:+:,:-:.:/:0:1:2:3:4:5:6;7;8;9;:;;;<;=;>;?;@;A;B;C;D;E;F;G;H;I;J;K;L;M;N;O;P;Q;R;S;T;U;V;W;X;Y;Z;[;\;];^;_;`;a;b;c;d;e;f;g;h;i;j;k;l;m;n;o;p;q;r;s;t;u;v;w;x;y;z;{;|;};~;;€;;‚;ƒ;„;…;†;‡;ˆ;‰;Š;‹<Œ<<Ž<<<‘<’<“<”<•<–<—<˜<™<š<›<œ<<ž<Ÿ< <”<¢<£<¤<„<¦<§<Ø<©<Ŗ<«<¬<­<®<Æ<°<±<²<³<“<µ<¶<·<ø<¹<ŗ<»<¼<½<¾<æ<Ą<Į<Ā<Ć<Ä<Å<Ę<Ē<Č<É<Ź<Ė<Ģ<Ķ<Ī<Ļ<Š<Ń<Ņ<Ó<Ō<Õ<Ö<×<Ų<Ł<Ś<Ū<Ü<Ż<Ž<ß<ą<į<ā<ć<ä<å<ę<ē<č<é<ź<ė<ģ<ķ<ī<ļ<š<ń<ņ<ó<ō<õ<ö<÷<ų<ł<ś<ū<ü<ż<ž<’<<<<<<<<<< < < < < <<<<<<<<<======>>>> ?!?"?#?$?%?&?'?(?)?*?+?,?-?.?/?0?1?2@3@4@5@6@7@8@9@:@;@<@=@>@?@@@A@B@C@D@E@F@G@H@I@J@K@L@M@N@O@P@Q@R@S@T@U@V@W@X@Y@Z@[@\@]@^@_@`@a@b@c@d@e@f@g@h@i@j@k@l@m@n@o@p@q@r@s@t@u@v@w@x@y@z@{@|@}@~@@€@@‚@ƒ@„@…@†@‡@ˆ@‰@Š@‹@Œ@@ŽAAA‘A’A“A”A•A–A—A˜A™AšA›AœAAžAŸA A”A¢A£A¤A„A¦A§AØA©AŖA«A¬A­A®AÆA°A±A²A³A“AµA¶A·AøA¹AŗA»A¼A½A¾AæAĄAĮAĀAĆAÄAÅAĘBĒBČBÉCŹCĖCĢCĶCĪCĻCŠCŃCŅCÓCŌCÕCÖC×CŲCŁCŚCŪCÜCŻCŽCßCąCįCāDćDäDåDęDēDčDéDźDėDģDķDīDļDšDńDņDóDōEõEöE÷EųEłEśEūEüEżEžE’EEEEEEEEEE E E E E EEEEEEEEEEEEEEEEEEE E!E"E#E$E%E&E'E(E)E*E+E,E-E.E/E0E1E2E3E4E5E6E7E8E9E:E;E<E=E>E?E@EAEBECEDEEEFFGFHFIGJGKGLGMGNGOGPGQGRGSGTGUGVGWGXGYGZG[G\G]G^G_G`GaGbGcGdGeGfGgHhHiHjHkHlHmHnHoHpHqHrHsHtHuHvHwHxHyHzH{H|H}H~HH€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ŖJ«J¬J­J®JÆJ°J±J²J³J“JµJ¶J·JøJ¹JŗJ»J¼J½J¾JæJĄJĮJĀJĆJÄJÅJĘJĒJČJÉJŹJĖJĢJĶKĪKĻLŠMŃMŅMÓMŌMÕMÖ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ņOóOōOõOöO÷OųOłOśOūOüOżOžO’O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O !O "O #O $O %P &P 'P (P )P *Q +Q ,Q -Q .Q /Q 0Q 1Q 2Q 3Q 4Q 5Q 6Q 7Q 8Q 9Q :Q ;Q <Q =Q >Q ?Q @Q AQ BQ CQ DQ EQ FQ GQ HQ IQ JQ KQ LQ MQ NQ OQ PQ QQ RQ SQ TQ UQ VQ WQ XQ YQ ZQ [Q \Q ]Q ^Q _Q `Q aQ bQ cQ dQ eQ fQ gQ hQ iQ jQ kQ lQ mQ nQ oQ pQ qQ rQ sQ tQ uQ vQ wQ xQ yQ zQ {Q |Q }Q ~Q Q €Q Q ‚Q ƒQ „Q …Q †Q ‡Q ˆR ‰R ŠR ‹R ŒR R ŽR R R ‘R ’R “R ”R •R –R —R ˜R ™S šS ›S œS S žS ŸS  S ”S ¢S £T ¤T „T ¦T §T ØT ©T ŖT «T ¬T ­T ®T ÆU °U ±U ²U ³U “U µV ¶V ·V øV ¹V ŗW »W ¼W ½W ¾W æW ĄW ĮW ĀW ĆW ÄW ÅX ĘX ĒY ČY ÉY ŹZ ĖZ ĢZ ĶZ ĪZ Ļ[ Š[ Ń[ Ņ[ Ó\ Ō\ Õ\ Ö] ×] Ų] Ł] Ś] Ū] Ü] Ż^ Ž^ ß_ ą_ į_ ā_ ć_ ä_ å_ ę_ ē_ č` é` ź` ė` ģ` ķa īa ļa ša ńa ņa óa ōa õa öa ÷a ųa łb śb ūb üb żb žb ’b b b b b b b b b b c c c c c c c c c c c c c c c c c c c c c c c c !c "c #c $c %c &c 'c (c )c *c +c ,c -c .c /c 0c 1c 2c 3c 4c 5c 6c 7c 8c 9c :c ;c <c =c >c ?c @c Ac Bc Cc Dc Ec Fc Gc Hc Ic Jc Kc Ld Md Nd Od Pe Qe Re Se Te Ue Ve We Xe Ye Ze [e \e ]e ^e _e `e ae be ce de ee fe ge he ie je ke le me ne oe pe qe re se te ue ve we xe ye zf {f |f }f ~f f €g g ‚g ƒg „g …g †g ‡g ˆg ‰g Šg ‹g Œg g Žg g g ‘g ’g “g ”g •g –g —g ˜g ™g šg ›g œg g žg Ÿg  g ”g ¢g £g ¤g „g ¦g §g Øg ©g Ŗg «g ¬g ­g ®g Æg °g ±h ²h ³h “h µh ¶i ·i øi ¹i ŗi »i ¼i ½i ¾i æi Ąi Įj Āj Ćj Äj Åj Ęj Ēj Čj Éj Źj Ėj Ģj Ķj Īj Ļj Šj Ńj Ņj Ój Ōj Õj Öj ×j Ųj Łj Śj Ūj Üj Żj Žj ßj ąj įj āj ćj äj åj ęj ēj čj éj źj ėj ģj ķj īj ļj šj ńk ņk ók ōk õk ök ÷k ųk łk śk ūk ük żk žk ’k k k k k k k k k k k k l l l l l 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 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I 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 fn gn hn in jn kn ln mn nn on pn qn rn sn tn un vn wo xo yp zp {p |p }p ~p p €p q ‚q ƒq „q …q †q ‡q ˆq ‰q Šq ‹q Œq q Žq q q ‘q ’q “q ”q •q –q —q ˜q ™q šq ›q œq q žr Ÿr  r ”r ¢r £r ¤r „r ¦r §r Ør ©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 Ēs Čs Ét Źt Ėt Ģt Ķt Īt Ļt Št Ńt Ņt Ót Ōt Õt Öu ×u Ųu Łu Śu Ūv Üv Ż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 x !x "x #x $x %x &x 'x (x )x *x +x ,x -x .x /x 0x 1x 2x 3x 4x 5x 6x 7x 8x 9x :x ;x <x =x >x ?x @x Ax Bx Cx Dx Ex Fx Gx Hy Iy Jy Ky Ly My Ny Oy Py Qz Rz Sz Tz U{ V{ W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o| p| q| r| s| t| u| v| w| x| y| z| {| || }| ~| | €| | ‚| ƒ| „| …| †| ‡| ˆ| ‰| Š| ‹| Œ|  Ž   ‘ ’ “ ” • – — ˜ ™ š › œ  ž Ÿ   ” ¢ £ ¤ „ ¦} §} Ø} ©} Ŗ} «} ¬} ­} ®} Æ} °} ±} ²} ³} “} µ} ¶} ·} ø~ ¹~ ŗ~ »~ ¼~ ½~ ¾~ æ Ą Į Ā Ć Ä Å Ę Ē Č É Ź Ė Ģ Ķ Ī Ļ Š Ń Ņ Ó Ō Õ Ö × Ų Ł Ś Ū Ü Ż Ž ß ą į ā ć ä å ę ē č é ź ė ģ ķ ī€ ļ€ š€ ń€ ņ€ ó€ ō€ õ€ ö€ ÷€ ų€ ł€ ś€ ū€ ü€ ż€ ž ’    ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ ‚ !‚ "‚ #‚ $‚ %‚ &‚ '‚ (‚ )‚ *‚ +‚ ,‚ -‚ .‚ /‚ 0‚ 1‚ 2‚ 3‚ 4‚ 5‚ 6‚ 7‚ 8‚ 9‚ :‚ ;‚ <‚ =‚ >‚ ?‚ @‚ A‚ B‚ C‚ D‚ E‚ F‚ G‚ Hƒ Iƒ Jƒ Kƒ Lƒ Mƒ Nƒ Oƒ Pƒ Qƒ Rƒ Sƒ Tƒ U„ V„ W„ X„ Y„ Z„ [„ \„ ]„ ^„ _„ `„ a„ b„ c„ d„ e„ f„ g„ h„ i„ j„ k„ l„ m„ n„ o„ p„ q„ r… s… t… u† v† w† x† y† z† {† |† }† ~† † €† † ‚† ƒ† „† …† †† ‡† ˆ† ‰† Š† ‹† Œ† † Ž† † † ‘† ’† “† ”† •† –† —† ˜† ™† š† ›† œ† † ž† Ÿ†  † ”† ¢† £† ¤† „† ¦† §† ؆ ©† Ŗ† «† ¬† ­† ®† Ɔ °† ±† ²† ³† “† µ† ¶† ·† ø† ¹† ŗ‡ »‡ ¼‡ ½‡ ¾‡ æ‡ Ą‡ Į‡ Ā‡ Ƈ ć Ň ʇ Ē‡ ȇ ɇ Ź‡ Ė‡ Ģ‡ Ķ‡ Ī‡ Ļ‡ Š‡ ч Ņ‡ Ӈ Ō‡ Շ և ׇ Ų‡ Ł‡ Ś‡ Ū‡ ܇ Ż‡ Ž‡ ߇ ą‡ į‡ ā‡ ć‡ ä‡ å‡ ę‡ ē‡ č‡ é‡ ź‡ ė‡ ģ‡ ķ‡ ī‡ ļ‡ š‡ ń‡ ņ‡ ó‡ ō‡ õ‡ ö‡ ÷‡ ų‡ ł‡ ś‡ ū‡ ü‡ ż‡ ž‡ ’‡‡‡‡‡‡‡‡‡‡ ‡ ‡ ‡ ‡ ‡‡‡‡‡‡‡‡‡‡‡‡‡‡‡‡‡‡‡ ‡!‡"‡#‡$ˆ%ˆ&ˆ'ˆ(ˆ)ˆ*ˆ+ˆ,ˆ-ˆ.ˆ/ˆ0ˆ1ˆ2ˆ3ˆ4ˆ5ˆ6ˆ7ˆ8ˆ9ˆ:‰;‰<‰=‰>‰?‰@‰A‰B‰C‰D‰E‰F‰G‰H‰I‰JŠKŠLŠMŠNŠOŠPŠQŠRŠSŠTŠUŠVŠWŠXŠYŠZŠ[Š\Š]Š^‹_‹`‹a‹b‹c‹d‹e‹f‹g‹h‹i‹j‹k‹l‹m‹n‹o‹p‹q‹r‹s‹t‹u‹v‹w‹x‹y‹z‹{‹|‹}‹~‹‹€‹‹‚‹ƒ‹„‹…‹†‹‡‹ˆ‹‰‹Š‹‹‹Œ‹‹Ž‹‹‹‘‹’‹“‹”Œ•–—˜™š›œžŸ ”¢£¤„¦§؍©Ŗ«¬­®ƍ°±²³“µ¶·øŽ¹Žŗ»¼½¾æĄĮĀƏďŏʏĒȏɏŹĖĢĶĪĻŠяŅӏŌՏ֏׏ŲŁŚŪ܏ŻŽߏąįāćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’     ‘‘’’’’’’’’’’’’’’ ’!’"’#’$’%’&’'“(“)“*“+“,“-“.“/“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”¢None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmÉą 0/  21#$*)>?@$@ 0/21 #*)?>None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmĢž TUVWXYZ[\]^_` _]^[\`TUVWXYZNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmé‘€morleyA new type that can wrap values so that the RenderDoc instances of the combined value can have a different behavior for the pretty printer.‚morleyGeneralize converting a type into a Text.PrettyPrint.Leijen.Text.Doc. Used to pretty print Michelson code and define Fmt.Buildable instances.„morley’Whether 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.bmorleyzWhether 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 c to # with a line width of 80.‡morleyLGeneric way to render the different op types that get passed to a contract.‰morley#Create a specific number of spaces.ŠmorleyCWrap documents in parentheses if there are two or more in the list.‹morley#Turn something that is instance of ‚ into a d". It's formatted the same way as † formats docs.emorley9Here using a page width of 80 and a ribbon width of 1.0 Uhttps://hackage.haskell.org/package/wl-pprint-1.2.1/docs/Text-PrettyPrint-Leijen.htmlŒmorley ParensNeeded constant.morley ParensNeeded constant.ŽmorleyAdd parentheses if needed.morleygEnsure parentheses are not required, for case when you cannot sensibly wrap your expression into them.€‚ƒ„…†‡ˆ‰Š‹ŒŽ‚ƒ„€†‡ˆ‰Š‹…ŒŽNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmīS’morleyA f' that always failes with given message.“morleyA f that always succeeds.”morleyThe f holds on `Left a`.•morleyThe f holds on `Right b`.‘’“”•‘’“”•None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm÷“–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]).–—š™˜—š™˜–None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmė”morley Generic TypeFieldVariable Annotation|As per Michelson documentation, this type has an invariant: (except for the first character, here parametrized in the type tagH) the allowed character set is the one matching the following regexp: %|%%|%|[:%][_a-zA-Z][_0-9a-zA-Z.%@]*§morleyPrints empty prefix in case of noAnn.ÉSuch functionality is required in case when instruction has two annotations of the same type, former is empty and the latter is not. So that `PAIR noAnn noAnn noAnn %kek` is printed as `PAIR % %kek`©morley Makes an ”" from its textual value, prefix (%@*:) excluded Throws an error if the given # contains invalid charactersŖmorley Makes an ”" from its textual value, prefix (%@:) excluded Returns a # error message if the given # contains invalid characters«morley>List of all the special Variable Annotations, only allowed in CAR and CDRH instructions, prefix (@) excluded. These do not respect the rules of ­ and ®.¬morley3The only special Field Annotation, only allowed in PAIR, LEFT and RIGHTH instructions, prefix (%) excluded. This does not respect the rules of ­ and ®.­morley Checks if a g6 is valid to be the first of an annotation, prefix (%@8:) excluded, the ones following should be checked with ®B instead. Note that this does not check Special Annotations, see « and ¬®morley Checks if a gO is valid to be part of an annotation, following a valid first character (see ­) and the prefix (%@<:). Note that this does not check Special Annotations, see « and ¬›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²”¢£„¤Ÿ žœ›Ø©Ŗ«¬­®¦§Æ°±²None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmUĘmorleyEntrypoint name.¹Empty if this entrypoint is default one. Cannot be equal to "default", the reference implementation forbids that. Also, set of allowed characters should be the same as in annotations.ŹmorleyMake up Ę/ from annotation in parameter type declaration.Returns # if no entrypoint is assigned here.ĖmorleyHTurn entrypoint name into annotation for contract parameter declaration.ĢmorleyMake up ĘJ from annotation which is reference to an entrypoint (e.g. annotation in CONTRACT instruction).Fails if annotation is invalid.ĶmorleyETurn entrypoint name into annotation used as reference to entrypoint. ÄÅĘĒČÉŹĖĢĶ ĘĒČÉŹĖĢĶÄÅNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm!ÉmorleyKFor implicit account, which type its parameter seems to have from outside.IׯŲŚŁÜŽßŪąįāćäåęźēčéėģķīļšńņóōõö÷ųłśūüżž’     Ióōńņž’įāćäåęźēčéėģķīļš×ŻŲŚŁÜŽßŪążüūśłų÷öõ     None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm7Ÿ Pmorley8A stack function that expresses the type signature of a LetMacroUmorleyA stack pattern-matchYmorley"A type-variable or a type-constant^morleyA 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).amorley,Matches current stack against a type-patternbmorley'A typed stack function (push and pop a  TcExtFrame)cmorley8Copy the current stack and run an inline assertion on itdmorley'Print a comment with optional embedded StackRefsemorleyConvert U# 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.fmorley+Get the set of variables in a stack patternHIJKLMNOPQSTRUVWXY[Z\]^_`abcdef`abcd^_MNOHIJKL\]Y[ZUVWXPQSTRfeNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm:m£¤„¦§Ø©©Ø£¤„¦§None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm>¤³morley6Michelson language type with annotations stripped off.ĆmorleyConverts from ³ to •–.Ämorley"Format type stack in a pretty way.ׯŲŚŁÜŽßŪą³“µ¶·ø¼¹ŗ»½¾æĄĮĀĆÄׯŲŚŁÜŽßŪą³“µ¶·ø¼¹ŗ»½¾æĄĮĀĆÄNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmP¶ hmorley Version of i with j' constraint, specialized for use with ³ kind.kmorley Version of i with j' constraint, specialized for use with × kind.ąmorley Version of  withSomeSing with j- constraint provided to processing function.[Required for not to erase this useful constraint when doing conversion from value of type ×! to its singleton representation.lmorley Version of m which creates k.āmorley Version of  withSomeSing with j- constraint provided to processing function.]Required for not to erase these useful constraints when doing conversion from value of type ³! to its singleton representation.ćmorley Version of n specialized for use with data instance Sing :: T -> Type which requires j) constraint for some of its constructorsomorley Version of m which creates h.pmorleyInstance of data family H for ³5. Custom instance is implemented in order to inject j& constraint for some of constructors.qmorleyInstance of data family H for ×.HG×ŲŁŚŪÜŻŽßČÉŹĖĢĶĪĻŠŃŅÓŌÕÖFąįāćHG×ŲŁŚŪÜŻŽßČÉŹĖĢĶĪĻŠŃŅÓŌÕÖFāąćįNone5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmƒn"morley6Alias for constraints which are required for printing.morleyAAlias for constraints which Michelson applies to unpacked values.It is different from , e.g. contract- type cannot appear in a value we unpack to.morley?Alias for constraints which Michelson applies to packed values.morleyBAlias for constraints which Michelson applies to pushed constants. morleyBAlias for constraints which Michelson applies to contract storage. morley;Alias for constraints which Michelson applies to parameter. morleyAlias for comparable types.morleyWhether the type contains ¼ , with proof. morley This is like '., it raises a more human-readable error when t[ type is concrete, but GHC cannot make any conclusions from such constraint as it can for '(. Though, hopefully, it will someday:  /https://gitlab.haskell.org/ghc/ghc/issues/11503#11503. Use this constraint in our eDSL.rmorley#Report a human-readable error that Ā contains another Ā!morley#Report a human-readable error that Ā contains another Ā"morley$Report a human-readable error about Ā at a wrong place.smorley$Report a human-readable error about ½ at a wrong place.#morley$Report a human-readable error about ¼ at a wrong place.$morley9Constraint 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 t).(morley.Whether this type contains a type with nested Ās .ōNested big_maps (i.e. big_map which contains another big_map inside of it's value type). Are prohibited in all contexts. Some context such as PUSH, APPLY, PACK/UNPACK instructions are more strict because they doesn't work with big_map at all.)morleyWhether this type contains Ā type.umorleyWhether this type contains ½ type.˜In some scopes (constants, storage) appearing for contract type is prohibited. Contracts in input/output of lambdas are allowed without limits though.vmorleyWhether this type contains ¼ type.¦In some scopes (constants, parameters, storage) appearing for operation type is prohibited. Operations in input/output of lambdas are allowed without limits though.wmorleyEvidence of that ' is deducable from  .*morleyReify ' contraint from  . Left for backward compatibility.xmorleyReify & contraint from .-morleyReify & contraint from ./morley1Check at runtime whether the given type contains ¼.0morley1Check at runtime whether the given type contains ½.1morley1Check at runtime whether the given type contains Ā.2morley1Check at runtime whether the given type contains Ā.4morley6Check at runtime that the given type does not contain ¼.5morley6Check at runtime that the given type does not contain ½.6morley7Check at runtime that the given type does not containt Ā7morley=Check at runtime that the given type does not contain nested ĀE354JIž’      !"#$%&'()*+,-./0123456789:;<=E   ’ž89:;<=54 %$'&)( "!# 3./0124567*-+,3JI—None5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm‡tyz{|}~€None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm›Bmorley”Compute 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.BCDEBCDENone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmœ#ImorleyFError that can happen during parsing of cryptographic primitive types.Nmorley*Encode a bytestring in Base58Check format.Omorley,Decode a bytestring from Base58Check format.Pmorley”Parse 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.Qmorley Template for  'format*' functions.Rmorley Template for 'parse*' functions.SmorleyReturns first encountered 2 in a list. If there are none, returns arbitrary %. It is useful to implement parsing.Tmorley*Do randomized action using specified seed.FGHIJKLMNOPQRSTIJKLMNOFGHPQRSTNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm ŅYmorleyThis 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.YYNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm¢°78Z[Z[78None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm¦¶\morley Similar to ƒ, but compares types via  DefaultEq& used in singletons comparisons (see Data.Singletons.Prelude.Eq module).\]^^]\None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmÆ_morley5Extract 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 ˜™ uses to represent datatypes.ŗAlong with the original list you have to provide constructor for intermediate nodes - it accepts zero-based index of the leftmost element of the right tree and merged trees themselves._`a`a_None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm³*fmorleyChange the character encoding of the given Handle to transliterate on unsupported characters instead of throwing an exception.bcdefbcdef None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmµ( None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmøjmorley?For datatype with "myNyan" field it will create "myNyanL" lens.9jkj9k!None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm¾żlmorley!Level of header, starting from 1.nmorleyA 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.zmorley#Text which is hidden until clicked.|morleyQuasi quoter for Markdown.lmnopqrstuvwxyz{|nlmoprqstuvwxyz{| None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmĮ[DE}~€‚DE€‚~}None5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmą Žmorley We can have `RequireLongerOrSameLength = (RequireLongerOrSameLength' l a, LongerOrSameLength l a)`, but apparently the printed error message can be caused by  rather than …t. We do not know for sure how it all works, but we think that if we require constraint X before Y (using multiple `=>`)s) then X will always be evaluated first.…morley‘W 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 R0s in user API, need to distinguish them somehow. morley!Get runtime value from singleton.HžRQPŽ‘’“”•–—˜™š›œŸ œRQP›š˜™HžŸ —–•”“’‘Ž"None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmē‚©morleyInteger 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.©Ŗ«¬­®©Ŗ«¬­® None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkméˆ =¶·ø¹ŗ»¼½¾æĄĮ »¼½¾æĄĮø¹ŗ=¶·#None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmķ‘Šmorley:This is the default set of ingredients extended with the ‰. which is used to generate xml reports for CI.ŠŠ$None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmšåŃmorley,Leads first character of text to lower case.(For empty text this will throw an error.ŃŃNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmśÆÓ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.ßmorleyDifference between two lists.ąmorley+Remove all occurences of the given element.āmorley*Reify type equality from boolean equality.ćmorleySplit a record into two pieces.-.SŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāć-.SįąßŽŻÜŲŁŪŚÖ×ÓŌÕŅćāNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm¬č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. ( !čéźė  éź( !čė%None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm%Ō ģmorleyA type error asking to use ķ instead of (.ķmorleyMichelson string value.DThis is basically a mere text with limits imposed by the language:  @http://tezos.gitlab.io/zeronet/whitedoc/michelson.html#constantsn Although, this document seems to be not fully correct, and thus we applied constraints deduced empirically.CYou construct an item of this type using one of the following ways:6With QuasyQuotes when need to create a string literal.[mt|Some text|]%MTextUnsafe { unMText = "Some text" }With ń- when constructing from a runtime text value.With ņ or īF when absolutelly sure that given string does not violate invariants.With ó] when not sure about text contents and want to make it compliant with Michelson constraints.šmorley<Constraint on literals appearing in Michelson contract code.‹morley;Error message indicating bad character in a string literal.ńmorleyWrap a Haskell text into ķ, performing necessary checks.You can use e.g. '\n'X character directly in supplied argument, but attempt to use other bad characters like '\r' will cause failure.ņmorley Contruct ķT from a Haskell text, failing if provided Haskell text is invalid Michelson string.ómorley Construct ķ§ from a Haskell text, eliminating all characters which should not appear in Michelson strings. Characters which can be displayed normally via escaping are preserved.ōmorleyPrint ķ9 for Michelson code, with all unusual characters escaped.÷morley/QuasyQuoter for constructing Michelson strings.:Validity of result will be checked at compile time. Note:slash must be escaped!newline character must appear as '\n'use quotes as is)other special characters are not allowed.ųmorleyParser used in ÷ quasi quoter.łmorley Create a ķ from type-level string.ŠWe assume that no unicode characters are used in plain Haskell code, so unless special tricky manipulations are used this should be safe.śmorley Create a ķ from label.ŠWe assume that no unicode characters are used in plain Haskell code, so unless special tricky manipulations are used this should be safe.ūmorley,Leads first character of text to upper case.(For empty text this will throw an error.ģķīļšńņóōõö÷ųłśūķīļńņóōõöšų÷ģłśū&None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm;…  morley"Secp256k1 cryptographic signature. morley#Secp256k1 secret cryptographic key.morley#Secp256k1 public cryptographic key.morley¼This is the hack we use to make serialization correct. Decoding is currently not implemented, so when we have to decode bytes we remember these bytes and produce some random public key.TODO (#18) remove it.morley1Deterministicaly generate a secret key from seed.morley&Create a public key from a secret key.morley Convert a  to raw bytes.FTODO (#18): apparently it uses compressed SEC format as described in  Phttps://www.oreilly.com/library/view/programming-bitcoin/9781492031482/ch04.html However, it is not tested yet.morleyMake a  from raw bytes.{TODO (#18): it should decode from compressed SEC format, but it's left for a future task, so for now we return a constant.morley Convert a  to raw bytes.oTODO (#18): apparently a signature always has 64 bytes, so this format might be correct, but it is not tested.morleyMake a   from raw bytes.oTODO (#18): apparently a signature always has 64 bytes, so this format might be correct, but it is not tested. morley$Sign a message using the secret key.!morley@Check that a sequence of bytes has been signed with a given key.     !     !'None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmFĖ -morleyP256 cryptographic signature.0morleyP256 secret cryptographic key.1morleyP256 public cryptographic key.4morley1Deterministicaly generate a secret key from seed.5morley&Create a public key from a secret key.6morley Convert a 1 to raw bytes.TODO (#18): implement properly.7morleyMake a 1 from raw bytes.TODO (#18): implement properly.9morley Convert a 1 to raw bytes.TODO (#18): implement properly.:morleyMake a - from raw bytes.TODO (#18): implement properly.Bmorley@Check that a sequence of bytes has been signed with a given key.-./0123456789:;<=>?@AB1230-./456789:;<=>?@AB(None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmP× Nmorley ED25519 cryptographic signature.Qmorley!ED25519 secret cryptographic key.Rmorley!ED25519 public cryptographic key.Umorley1Deterministicaly generate a secret key from seed.Vmorley&Create a public key from a secret key.Wmorley Convert a R to raw bytes.XmorleyMake a R from raw bytes.Zmorley Convert a N to raw bytes.[morleyMake a N from raw bytes.dmorley$Sign a message using the secret key.emorley@Check that a sequence of bytes has been signed with a given key.NOPQRSTUVWXYZ[\]^_`abcdeRSTQNOPUVWXYZ[\]^_`abcde)None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmt¢rmorley!Blake2b_160 hash of a public key.tmorley<We store which curve was used because it affects formatting.umorley Hash itself.vmorley6Which curve was used for the hashed public key inside r.zmorleyDCryptographic signatures used by Tezos. Constructors correspond to € 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 € 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.€morleyvPublic cryptographic key used by Tezos. There are three cryptographic curves each represented by its own constructor.morley5Public key that uses the ed25519 cryptographic curve.‚morley7Public key that uses the secp256k1 cryptographic curve.ƒmorley8Public key that uses the NIST P-256 cryptographic curve.„morleyZDeterministicaly generate a secret key from seed. Type of the key depends on seed length.…morley&Create a public key from a secret key.†morley Convert a z to raw bytes.‡morleyMake a z4 from raw bytes. Can return only generic signature.‰morleyuCheck that a sequence of bytes has been signed with a given key. TODO (#18) consider generic signature here as well.morleyPLength of key hash in bytes (only hash itself, no tags, checksums or anything).‘morley*Compute the b58check of a public key hash.2BCDEFGHIJKLMNOPrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”2€‚ƒz{|}~vwxyrstu„…†‡ˆ‰IJKLMŠ‹ŒŽ’“”‘BCDENOFGHP*None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm ņ±morleynIdentifier of a network (babylonnet, mainnet, test network or other). Evaluated as hash of the genesis block.ąThe only operation supported for this type is packing. Use case: multisig contract, for instance, now includes chain ID into signed data "in order to add extra replay protection between the main chain and the test chain".“morley\Time in the real world. Use the functions below to convert it to/from Unix time in seconds.·morleyDMutez is a wrapper over integer data type. 1 mutez is 1 token (¼Tz).¹morleySafely create · checking for overflow.ŗmorleyPartial function for ·P creation, it's pre-condition is that the argument must not exceed the maximal · value.»morleySafely create ·."This is recommended way to create Mutez8 from a numeric literal; you can't construct all valid Mutez@ values using this function but for small values it works neat.4Warnings displayed when trying to construct invalid  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.Ęmorley!Add given amount of seconds to a “.Ēmorley€Display timestamp in human-readable way as used by Michelson. Uses UTC timezone, though maybe we should take it as an argument.<NB: this will render timestamp with up to seconds precision.Čmorley Parse textual representation of “.ÉmorleyQuote a value of type “ in yyyy-mm-ddThh:mm:ss[.sss]Z format.@formatTimestamp [timestampQuote| 2019-02-21T16:54:12.2344523Z |]"2019-02-21T16:54:12Z" Inspired by  'time-quote' library.ŹmorleyReturn current time as “.Ėmorley1Timestamp which is always greater than result of Ź.Ģmorley.Timestamp which is always less than result of Ź.Ķmorley"Construct chain ID from raw bytes.ĪmorleyNConstruct chain ID from raw bytes or fail otherwise. Expects exactly 4 bytes.ĻmorleyIdentifier of a pseudo network.Šmorley Pretty print ± as it is displayed e.g. in ./babylonnet.sh head call.Example of produced value: NetXUdfLh6Gm88t.morleyJIt's a magic constant used by Tezos to encode a chain ID. Corresponds to Net part.#±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓ#·ø¹ŗ»¼½¾æĄĮĀ“µ¶ĆÄÅĘĒČÉŹĖĢ±²³ĶĪĻŠŃŅÓ+None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmŗ¶šmorley.Errors that can happen during address parsing.ńmorley%Address is not in Base58Check format.ņmorley,Both address parsers failed with some error.ómorley6Data type corresponding to address structure in Tezos.ōmorleytz) address which is a hash of a public key.õmorleyKT2 address which corresponds to a callable contract.ömorley.Hash of origination command for some contract.ųmorleySmart constructor for ō.łmorley$Deterministically generate a random ō and discard its secret key.śmorleySmart constructor for õ4. Its argument is serialized origination operation. Note: it's quite unsafe to pass "¦, because we can pass some garbage which is not a serialized origination operation, but this operation includes contract itself and necessary types are defined in š›O. So we have to serialize this data outside this module and pass it here as a "^. Alternatively we could add some constraint, but it would be almost as unsafe as passing a ". For this reason we add Raw: suffix to this function and provide a safer function in œ. We may reconsider it later.ūmorleyCreate a dummy ö value.žmorley˜Parse an address from its human-readable textual representation used by Tezos (e. g. "tz1faswCTDciRzE4oJ9jn2Vm2dvjeyA9fUzU"). Or fail if it's invalid.’morleyPartial version of žB which assumes that the address is correct. Can be used in tests.morleyParse a TKG contract address, fail if address does not match the expected format.ļšńņóōõö÷ųłśūüżž’ö÷óōõųłśūšńņļüżž’,None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmĮ morley‡ByteString does not have an instance for ToJSON and FromJSON, to avoid orphan type class instances, make a new type wrapper around it.(morleydA sequence of elements: can be a list or a set. We can't distinguish lists and sets during parsing. !"#$%&'()*+ !"#$%&'()*+-None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmŻ¹ Cmorley'Data necessary to originate a contract.EmorleyOriginator of the contract.FmorleyOptional delegate.Gmorley Initial balance of the contract.Hmorley&Initial storage value of the contract.ImorleyThe contract itself.Jmorley.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.Lmorleyµ"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.MmorleyM$ is essentially as special case for L8, but we need both because they are packed differently.„morley Flatten all ¢ in  ī. This function is mostly for testing. It returns instructions with the same logic, but they are not strictly equivalent, because they are serialized differently (grouping instructions into sequences affects the way they are PACK'ed).¦morley=Compute address of a contract from its origination operation.×TODO [TM-62] It's certainly imprecise, real Tezos implementation doesn't use JSON, but we don't need precise format yet, so we just use some serialization format (JSON because we have necessary instances already).dCDEFGHIJˆ†‰Š˜—œu‹XYWZ[KLMNOPQRSTUV\]^_`abcdefghijklmnopqrstvwxyz{|}~€‚ƒ„…‡ŒŽ‘’“”•–™š›žŸ ”¢£¤„¦dJˆ†‰Š˜—œu‹XYWZ[KLMNOPQRSTUV\]^_`abcdefghijklmnopqrstvwxyz{|}~€‚ƒ„…‡ŒŽ‘’“”•–™š›žŸ ”¢£¤„CDEFGHI¦.None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmāƼ½¾½¾¼œNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm䝒 ›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²ÄÅĘĒČÉŹĖĢĶׯŲŚŁÜŽßŪąįāćäåęźēčéėģķīļšńņóōõö÷ųłśūüżž’     HIJKLMNOPQSTRUVWXY[Z\]^_`abcdef£¤„¦§Ø© !"#$%&'()*+CDEFGHIJˆ†‰Š˜—œu‹XYWZ[KLMNOPQRSTUV\]^_`abcdefghijklmnopqrstvwxyz{|}~€‚ƒ„…‡ŒŽ‘’“”•–™š›žŸ ”¢£¤„¦¼½¾/None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmė…æmorley.Data associated with a particular transaction. æĄĮĀĆÄĒČÉŹ æĄĮĀĆÄŹÉČĒ0None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmķ«ĖĖ1None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmóæĢmorleyBuilding a record from tuple.%It differs from similar typeclass in žŸG 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.ĢĶĪĢĶĪ2None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmö˜ĻmorleyProduce Ģ( instance for tuple of the given length.ĻĻ3None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmųv None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmśLĢĶĪĢĶĪNone5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmq TźmorleyLike ‘L, casts some container's elements, producing informative error on mismatch.ėmorley* version of '.ģmorleySuppose you have a data type X with parameter aX and you have two values: `x1 :: X a1` and `x2 :: X a2`. You can't compare them using ’J, because they have different types. However, you can compare them using ģ! as long as both parameters are j.ķmorley Version of ģ for types with 2 parameters.īmorley Version of ģ for types with 3 parameters.ļmorley2Compare two entries of completely different types.šmorley Extension of ļ to “ function.ńmorley†Cast 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 j/ constraint, then in order to get it back with castb you need to know the exact type of the hidden object, including its phantom type parameter. With ńN you get a way to extract this object no matter which phantom argument it had. ',+źėģķīļšń źėģķīļšń,+'4None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmhōmorley>Data type, holding annotation data for a given Michelson type t.;Each constructor corresponds to exactly one constructor of ³f and holds all type and field annotations that can be attributed to a Michelson type corrspoding to t.morley In memory of NStar5 constructor. Generates notes with no annotations.morley%Checks if no annotations are present.morleyCombines two annotations trees a and b into a new one c in such a way that c can be obtained from both a and bD by replacing some empty leaves with type or/and field annotations.morley:Converge two type or field notes (which may be wildcards).ņóōõö÷ųłśūüżž’ōõö÷ųłśūüżž’ņó5None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm#õmorley Transparently represent untyped Type as wrapper over (Sing t, Notes t) from typed world.$As expression this carries logic of , and as pattern it performs ! but may make code a bit cleaner.½Note about constraints: pattern signatures usually require two constraints - one they require and another one which they provide. In our case we require nothing (thus first constraint is ()#) and provide some knowledge about t.morleyConvert ó7 to the isomorphic set of information from typed world.ĆĆ6None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmDÜmorley with hidden parameter type."This requires argument to satisfy  ­ constraint. Strictly speaking, entrypoint argument may one day start having different set of constraints comparing to ones applied to parameter, but this seems unlikely.morley4Reference for calling a specific entrypoint of type arg.morleyName of entrypoint.morleyAProxy of parameter, to make parameter type more easily fetchable.morley:How to call this entrypoint in the corresponding contract.morleySDescribes how to construct full contract parameter from given entrypoint argument. This could be just wrapper over Value arg -> Value param, but we cannot use Value type in this module easily.morley<Errors specific to parameter type declaration (entrypoints).%morley?Coordinates of "arm" in Or tree, used solely in error messages.&morley/Annotations for contract parameter declaration.|Following the Michelson specification, this type has the following invariants: 1. No entrypoint name is duplicated. 2. If default@ entrypoint is explicitly assigned, no "arm" remains uncallable.-morleyVAddress with optional entrypoint name attached to it. TODO: come up with better name?/morleyAddress itself0morley Entrypoint name (might be empty)4morleyvParse an address which can be suffixed with entrypoint name (e.g. "tz1faswCTDciRzE4oJ9jn2Vm2dvjeyA9fUzU%entrypoint").”morley4Check whether given notes are valid parameter notes.6morley Construct &! performing all necessary checks.•morleyBuild .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.8morleyBuild .ZHere we accept entrypoint name and type information for the parameter of target contract.Returns  if entrypoint is not found.9morley Parameter type of implicit account.@morleygCalls the default entrypoint. TODO [TM-280]: This implementation always refers parameter root, fix it.2ÄÅĘĒČÉŹĖĢĶ !"#$%&'()*+,-./01234567892-./0)*+,2345&'(1"#$% !6789ĘĒČÉŹĖĢĶÄÅ7None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmLXUmorley:Representation of comparable value in Michelson language.†By specification, we're allowed to compare only following types: int, nat, string, bytes, mutez, bool, key_hash, timestamp, address.;Only these values can be used as map keys or set elements. UVWXYZ[\]^ UVWXYZ[\]^8None5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmq[¢ fmorley"Representation of Michelson value.Type parameter instr` stands for Michelson instruction type, i.e. data type to represent an instruction of language.vmorleyWWrapper over instruction which remembers whether this instruction always fails or not.ŒmorleyvData type, representing operation, list of which is returned by Michelson contract (according to calling convention)._These operations are to be further executed against system state after the contract execution.morleyMerge two execution branches.‘morley2Get code disregard whether it always fails or not.’morleyModify inner code.“morleyMake value of contractJ type which refers to the given address and does not call any entrypoint.•morleyTurn  into actual function on Values.—morleyIIgnoring distinction between constructors here, comparing only semantics.>UVWXYZ[\]^bcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•>fghijklmnopqrstudebc|{zy}~€‚ƒUVWXYZ[\]^ŒŽ„…†‡ˆ‰Š‹vwx‘’“”•9None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm_h©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘ©Ŗ«¬ÄÅĘæĄĮĀĆ¼½¾ŗ»²³“µ¶·ø¹­®Æ°±:None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkml6õmorley#Marker data type for add operation.ųmorley0Represents an arithmetic error of the operation.ūmorley;Denotes the error type occured in the arithmetic operation.morley&Class for binary arithmetic operation.!Takes binary operation marker as op# parameter, types of left operand n and right operand m.morley Type family ArithRes6 denotes the type resulting from computing operation op from operands of types n and m.uFor instance, adding integer to natural produces integer, which is reflected in following instance of type family: ArithRes Add CNat CInt = CInt.morley0Evaluate arithmetic operation on given operands."ćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’"õö÷ųłśūüżž’ōóņńšļīķģėźéčēęåäć;None6!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmŃC56morley=Keeps documentation gathered for some piece of contract code..Used for building documentation of a contract.8morleyAll inlined doc items.9morleyDefinitions 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.;morleyÉWe 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 >.>morley*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.Amorley:A doc item which we store, along with related information.CmorleyDoc item itself.Dmorley+Subdocumentation, if given item is a group.EmorleyDHides some documentation item which is put to "definitions" section.GmorleyHides some documentation item.ImorleyHow to render section name.JmorleySuitable for block name.Kmorley+Suitable for subsection title within block.LmorleyBDefines an identifier which given doc item can be referenced with.Omorley!Where do we place given doc item.Pmorley&Placed in the document content itself.QmorleyAPlaced in dedicated definitions section; can later be referenced.–morley'Position of all doc items of some type.Rmorley%Some unique identifier of a doc item.FAll doc items which should be refer-able need to have this identifier.Tmorley’A 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.Umorley‡Position of this item in the resulting documentation; the smaller the value, the higher the section with this element will be placed.ŃDocumentation structure is not necessarily flat. If some doc item consolidates a whole documentation block within it, this block will have its own placement of items independent from outer parts of the doc.VmorleyDefines 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.Wmorley]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.XmorleyDescription of a section.qCan be used to mention some common things about all elements of this section. Markdown syntax is permitted here.YmorleyHow to render section name.)Takes effect only if section name is set.Zmorley‘Defines 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,All doc items which this doc item refers to.UThey will automatically be put to definitions as soon as given doc item is detected.]morleyŻThis 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$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 A is atomic.Normally, atomic As are ones appearing in DOC_ITEM. instruction, and non-atomic ones are put to DocGroup.™morleyRender a documentation block.šmorleyBLift a doc item to a block, be it atomic doc item or grouping one.amorley#Lift an atomic doc item to a block.bmorley%Find all doc items of the given type.cmorleyRender documentation for <.fmorleyTo automatically derive #instance Show Michelson.Typed.Instr later.qmorleyRepository settings for t.smorley@By commit sha make up a url to that commit in remote repository.›morley"Specify version if given contract.wmorleyDescription of something.ymorleyGive a name to document block.{morley:A function which groups a piece of doc under one doc item.€morley9Render given contract documentation to markdown document.morley2Apply given grouping to documentation being built.ƒmorleyMake t.:t $mkDGitRevisionGitRepoSettings -> DGitRevision…morleyBContract documentation assembly primarily relies on this instance.C6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcopqrstuvwxyz{|}~€‚ƒCTUVWXYZ[\]^RSOPQLMNIJKGHEFABCD?@><=6789:;{|~}`cab€_yzwxtuvqrsƒ‚op<None5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmq ³‹morleyyTyped contract and information about annotations which is not present in the contract code. TODO [#12]: rename this to  and the current  to  ContractCode?•morley-A print format with references into the stack˜morley+A reference into the stack of a given type.™morley=Keeps 0-based index to a stack element counting from the top.œmorleyERepresentation of Michelson instruction or sequence of instructions.ŽEach Michelson instruction is represented by exactly one constructor of this data type. Sequence of instructions is represented with use of Seq constructor in following way: SWAP; DROP ; DUP; -> SWAP œ DROP œ DUPO. Special case where there are no instructions is represented by constructor Nop, e.g. IF_NONE {} { SWAP; DROP; } -> IF_NONE Nop (SWAP œ DROP).Type parameter inpd states for input stack type. That is, type of the stack that is required for operation to execute.Type parameter out` states for output stack type or type of stack that will be left after instruction's execution.morley^A wrapper for instruction that also contain annotations for the top type on the result stack.šAs of now, when converting from untyped representation, we only preserve field annotations and type annotations. Variable annotations are not preserved.PThis can wrap only instructions with at least one non-failing execution branch.žmorley-Execute given instruction on truncated stack.PThis can wrap only instructions with at least one non-failing execution branch.øMorley has no such instruction, it is used solely in eDSLs. This instruction is sound because for all Michelson instructions the following property holds: if some code accepts stack i and produces stack o#, when it can also be run on stack i + s producing stack o + s’®; and also because Michelson never makes implicit assumptions on types, rather you have to express all "yet ambiguous" type information in code. We could make this not an instruction but rather a function which modifies an instruction (this would also automatically prove soundness of used transformation), but it occured to be tricky (in particular for TestAssert and DipN and family), so let's leave this for future work. morleyeNop operation. Missing in Michelson spec, added to parse construction like `IF {} { SWAP; DROP; }`.¢morley¢Nested wrapper is going to wrap a sequence of instructions with { }. It is crucial because serialisation of a contract depends on precise structure of its code.£morley\Places documentation generated for given instruction under some group. This is not part of ‘! because it does not behave like  ?; instead, it inherits behaviour of instruction put within it.¤morleyŅVariants of CAR/CDR to retain field annotations as they relate to the input stack, and hence won't be available from the annotation notes from the result stack we pack with the instructions during type check.žmorley[Constraint that is used in DIPN, we want to share it with typechecking code and eDSL code.’morley¤A wrapper to wrap annotations and corresponding singleton. Apart from packing notes along with the corresponding Singleton, this wrapper type, when included with œ also helps to derive the œ instance for œ as `Sing a` does not have a œ instance on its own.morley<Create a stack reference, performing checks at compile time.{‹ŒŽ‘’“”•–—˜™š›œįßāćŸńšõĶ¢ä”±²³§¦Ø©Ŗ«¬­®Æ°“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĪŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽąåęēčéźėģķīļņóōö÷ųž £¤„Ļłśūüżž’{œįßāćŸńšõĶ¢ä”±²³§¦Ø©Ŗ«¬­®Æ°“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĪŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽąåęēčéźėģķīļņóōö÷ųž £¤„Ļ‘’“”˜™•–—š›‹ŒŽ’żžūüłś=None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm²morleyConvert a typed Val to an untyped Value.'For full isomorphism type of the given Val should not contain ¼P - a compile error will be raised otherwise. You can analyse its presence with / function.>None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmØ?None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm=ü morleyCDescribes how intermediate nodes in instruction tree are accounted."morleyName of this way.#morley;This function accepts: 1. Effects gathered after applying stepe to node's children, but before applying it to the node itself. 2. Effects gathered after applying step_ to the given intermediate node. 3. Instruction resulting after all modifications produced by step.$morley Options for (.&morleyWhether ({ function should go into values which contain other instructions: lambdas and constant contracts (which can be passed to CREATE_CONTRACT).'morley8How do we handle intermediate nodes in instruction tree.morley@Gather effects first for children nodes, then for their parents.(morley4Traverse a typed instruction in depth-first order. c is used to concatenate intermediate results. Each instructions can be changed using the supplied stepO function. It does not consider extra instructions (not present in Michelson).)morleySpecialization of (9 for case when changing the instruction is not required.*morleySpecialization of (' which only modifies given instruction.žmorley^Check whether instruction fails at each execution path or have at least one non-failing path.’’This function assumes that given instruction contains no dead code (contract with dead code cannot be valid Michelson contract) and may behave in unexpected way if such is present. Term "dead code" includes instructions which render into empty Michelson, like Morley extensions. On the other hand, this function does not traverse the whole instruction tree; performs fastest on left-growing combs.•Often we already have information about instruction failure, use this function only in cases when this info is actually unavailable or hard to use.+morleykThere are many ways to represent a sequence of more than 2 instructions. E. g. for `i1; i2; i3` it can be Seq i1 $ Seq i2 i3 or Seq (Seq i1 i2) i3O. This function enforces a particular structure. Specifically, it makes each œ& have a single instruction (i. e. not œ?) in its second argument. This function also erases redundant  s.,morley/If value is a string, return the stored string.-morley7If value is a bytestring, return the stored bytestring..morleyõTakes a selector which checks whether an atomic value (i. e. that can not contain another value) can be converted to something. Recursively applies it to all atomic values in potentially non-atomic value. Collects extracted values in a list.Perhaps one day we'll have dfsValue. !"#$%&'()*+,-.$%&' !"#()*+,-.@None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm_/2morley?Isomorphism between Michelson stack and its Haskell reflection.5morleyOverloaded version of 6 to work on Haskell and T stacks.6morley1Type function to convert a Haskell stack type to T -based one.7morleyEWhether Michelson representation of the type is derived via Generics.8morley-Implements ADT conversion to Michelson value.wThanks to Generic, Michelson representation will be a balanced tree; this reduces average access time in general case.ŌA drawback of such approach is that, in theory, in new GHC version generified representation may change; however, chances are small and I (martoon) believe that contract versions will change much faster anyway.=morleySince Contract@ name is used to designate contract code, lets call analogy of ½ type as follows.Cmorley&A useful property which holds for all × types.Dmorley6Any Haskell value which can be converted to Michelson .Fmorley4Hides some Haskell value put in line with Michelson .HmorleyOverloaded version of J to work on Haskell and T types.Imorley=Isomorphism between Michelson values and plain Haskell types.WDefault implementation of this typeclass converts ADTs to Michelson "pair"s and "or"s.Jmorley:Type function that converts a regular Haskell type into a T type.Kmorley"Converts a Haskell structure into Value representation.Lmorley Converts a Value into Haskell type.MmorleyGIsomorphism between Michelson primitive values and plain Haskell types.Nmorley[Type function that converts a regular Haskell type into a comparable type (which has kind CT).Omorley%Converts a single Haskell value into CVal representation.Pmorley Converts a CVal# value into a single Haskell value.QmorleyReplace type argument of  ContractAddr with isomorphic one.WmorleyQThis instance erases reference to contract entrypoint! If this is an issue, use - instead.sApplications which use addresses just as participants identifiers should not experience problems with using plain ó."23456789:;<=>?@ABCDEFGHIJKLMNOPQRS"MNOPIJKL89HFGDEC7BA=>?@Q:;<65234RSANone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmĆŸmorleyPTraverse a single contructor and supply its field to instruction in case clause. morleyGeneric traversal for ¤.‘morleyList of ”.s required to pattern match on the given type.’morley*Type information about single case clause.”morleyuIn what different case branches differ - related constructor name and input stack type which the branch starts with.”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 ³/-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. morleyéWe support only two scenarious - constructor with one field and without fields. Nonetheless, it's not that sad since for sum types we can't even assign names to fields if there are many (the style guide prohibits partial records).£morley Proof of .¤morley:Wrap given element into a constructor with the given name./Mentioned constructor must have only one field.Since labels interpretable by OverloadedLabelsm extension cannot start with capital latter, prepend constructor name with letter "c" (see examples below).„morley<Wrap a haskell value into a constructor with the given name.This is symmetric to ¤.¦morley$Pattern-match on the given datatype.§morley#Lift an instruction to case clause.’\You should write out constructor name corresponding to the clause explicitly. Prefix constructor name with "c" letter, otherwise your label will not be recognized by Haskell parser. Passing constructor name can be circumvented but doing so is not recomended as mentioning contructor name improves readability and allows avoiding some mistakes.Ømorley)Unwrap a constructor with the given name.Rules which apply to ¤/ function work here as well. Although, unlike  instrWrap8, this function does not work for nullary constructors.©morley0Try to unwrap a constructor with the given name.¦morleyĮFailure 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.!–—š™˜Ž‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©!˜–Ž¤„¦§Ø©”•’“‘—š™˜– ”¢Ÿž£›š™—œ§8BNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm•wĘmorley%Ensure that given type is a sum type.LThis helps to prevent attempts to apply a function to, for instance, a pair.ĒmorleyJUsed to understand whether a type can potentially declare any entrypoints.LThis type family is conservative, if we are not sure, we suppose that type may have entrypoints.ĘĒČČĒĘCNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm„§morleyGeneric traversal for Ņ.ÉmorleyConstraint for Ņ.Źmorley"Types of all fields in a datatype.Ėmorley9Way to construct one of the fields in a complex datatype.ØmorleyGeneric traversal for Ń.ĶmorleyConstraint for Ń.©morleyGeneric traversal for  instrAccess.ĪmorleyConstraint for Š.Ļmorley@Get type of field by datatype it is contained in and field name.ŖmorleyForce result of « to be ¬morley,Find field of some product type by its name.2Name might be either field record name, or one in ­- if field is wrapped using '(:!)' or '(:?)'.®morley>Result of field lookup - its type and path to it in the tree.ŠmorleyEMake an instruction which accesses given field of the given datatype.ŃmorleyFor given complex type dt and its field fieldTy update the field value.ŅmorleyFor given complex type dt and its field fieldTy update the field value. ÉŹĖĢĶĪĻŠŃŅ ĪĶÉŠŃŅĻŹĖĢ”None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm§-+–—š™˜Ž‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©ÉŹĖĢĶĪĻŠŃŅDNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm²s Æ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 ē.āćäåęēčćäåęčēāENone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm}%±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.ųmorley'Doc element with description of a type.³morleyCWhen rendering type's inner representation, this stands for name ofƒHaving this makes sense for polymorhpic types, when you want to render representation of some concrete instantiation of that type.śmorley"Data hides some type implementing ž.ümorley Signature of  function.As in ż', set the first element of the pair to ™ for primitive types, otherwise it stands as some instantiation of a type, and its Michelson representation is given in the second element of the pair.(Examples of rendered representation: *  pair int nat - for homomorphic type. * !MyError Integer = pair string int( - concrete sample for polymorhpic type.żmorley Signature of  function.When value is 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).1When rendered, values of this type look like: * (Integer, Natural) - for homomorphic type. * !MyError Integer = (Text, Integer)( - concrete sample for polymorhpic type.žmorley:Description for a Haskell type appearing in documentation.’morley2Name of type as it appears in definitions section.^Each type must have its own unique name because it will be used in identifier for references.Default definition derives name from Generics. If it does not fit, consider defining this function manually. (We tried using ˜˜R for this, but it produces names including module names which is not do we want).morley6Explanation of a type. Markdown formatting is allowed.morley4How reference to this type is rendered, in Markdown. Examples: *  #type-integerInteger, *  #type-MaybeMaybe #type-unit().Consider using one of the following functions as default implementation; which one to use depends on number of type arguments in your type: *   *   * >If none of them fits your purposes precisely, consider using  .morley,All types which this type directly contains."Used in automatic types discovery.morley;For complex types - their immediate Haskell representation. For primitive types set this to .For homomorphic types use  implementation.%For polymorhpic types consider using  as implementation. Modifier ? can be used to hide names of fields, beneficial for newtypes.Another modifier called Q can be used for datatypes to leave only meaningful part of name in every field.morley)Final michelson representation of a type.For homomorphic types use  implementation.%For polymorhpic types consider using  as implementation.morleySWhether given text should be rendered grouped in parentheses (if they make sense).morley`Stands for representation of some Haskell ADT corresponding to Michelson value. Type parameter a\ is what you put in place of each field of the datatype, e.g. information about field type.‘Outer list layer corresponds to union, and the inner one corresponds to products within constructors. Constructors and fields names are present.morley Show given  in a neat way.“morleyRemove fields names from .JSometimes there is no sense in showing them in the doc. Example: newtypes.µmorley$How field names should be displayed.UResult of this function call should appear right before rendered type of that field. morleyLike : but returns values of more common type which is used in \. morley»Render a reference to a type which consists of type constructor (you have to provide name of this type constructor and documentation for the whole type) and zero or more type arguments. morleyDerive , for homomorphic types only. morleyDerive 5, for polymorphic type with one type argument, like  Maybe Integer.morleyDerive 6, for polymorphic type with two type arguments, like Lambda Integer Natural.morley Implement 1 via getting all immediate fields of a datatype.lNote: this will not include phantom types, I'm not sure yet how this scenario should be handled (@martoon).morley Implement  for a homomorphic type.1Note that it does not require your type to be of öŠ instance, which can be useful for some polymorhpic types which, for documentation purposes, we want to consider homomorphic. Example: [ is in fact polymorhpic, but we don't want this fact to be reflected in the documentation.morley Implement # on example of given concrete type.+This is a best effort attempt to implement ” for polymorhpic types, as soon as there is no simple way to preserve type variables when automatically deriving Haskell representation of a type.morley Version of † which does not ensure whether the type for which representation is built is any similar to the original type which you implement a ž instance for.morley2Erase fields from Haskell datatype representation.2Use this when rendering fields names is undesired.morley>Cut fields prefixes which we use according to the style guide.E.g.  cmMyField field will be transformed to myField.morley Implement  for homomorphic type.morley Implement # on example of given concrete type.,This function exists for the same reason as .morley Version of † which does not ensure whether the type for which representation is built is any similar to the original type which you implement a ž instance for.$ōõö÷ųłśūüżž’     $ž’żüōśū ÷ö   ųłõ ¢None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmsv–—š™˜234567:;<=>?@ABCDEFGHIJKLMNOPQRSŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©ÉŹĖĢĶĪĻŠŃŅāćäåęēčōõö÷ųłśūüżž’     v–—š™˜234567:;<=>?@ABCDEFGHIJKLMNOPQRSŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©ÉŹĖĢĶĪĻŠŃŅāćäåęēčōõö÷ųłśūüżž’     FNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm(ŃFmorley Assemble contract documentation.¶morley+Modify all documentation items recursively.GmorleyWRecursevly traverse an instruction and modify documentation items matching given type.Hmorley1Leave 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.FGHFGH£None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm*æ’V354HG×ŲŁŚŪÜŻŽßČÉŹĖĢĶĪĻŠŃŅÓŌÕÖFJI–—š™˜ÄÅĘĒČÉŹĖĢĶׯŲŚŁÜŽßŪą³“µ¶·ø¼¹ŗ»½¾æĄĮĀĆÄąįāćž’      !"#$%&'()*+,-./0123456789:;<=ņóōõö÷ųłśūüżž’ !"#$%&'()*+,-./0123456789UVWXYZ[\]^bcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’‹ŒŽ‘’“”•–—˜™š›œįßāćŸńšõĶ¢ä”±²³§¦Ø©Ŗ«¬­®Æ°“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĪŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽąåęēčéźėģķīļņóōö÷ųž £¤„Ļłśūüżž’ !"#$%&'()*+,-.234567:;<=>?@ABCDEFGHIJKLMNOPQRSŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©ÉŹĖĢĶĪĻŠŃŅāćäåęēčōõö÷ųłśūüżž’     FGHGNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm]h ImorleyState for type checking nopJmorley(Set of variables defined in a let-block.NmorleyQData type, holding strictly-typed Michelson value along with its type singleton.PmorleyQData type, holding strictly-typed Michelson value along with its type singleton.RmorleywData type keeping the whole type check result: instruction and type representations of instruction's input and output.Tmorley]This data type keeps part of type check result - instruction and corresponding output stack.Umorley?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.Vmorley}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).WmorleyNo-argument type wrapper for HST data type.YmorleyHData type holding type information for stack (Heterogeneous Stack Type).8This data type is used along with instruction data type Instr> to carry information about its input and output stack types.That is, if there is value instr :: Instr inp out, along with this instr one may carry inpHST :: HST inp and outHST :: HST outN which will contain whole information about input and output stack types for instr. Data type HST is very similar to Data.Vinyl.RecN, but is specialized for a particular purpose. In particular, definition of HST (t1 ': t2 ': ... tn ': '[]) requires constraints ,(Typeable t1, Typeable t2, ..., Typeable tn) as well as constraints -(Typeable '[ t1 ], Typeable '[ t1, t2 ], ...). These applications of Typeable= class are required for convenient usage of type encoded by HST ts with some functions from  Data.Typeable. Data type HST• (Heterogeneous Stack Type) is a heterogenuous list of triples. First element of triple is a type singleton which is due to main motivation behind HST0, namely for it to be used as representation of InstrÕ type data for pattern-matching. Second element of triple is a structure, holding field and type annotations for a given type. Third element of triple is an optional variable annotation for the stack element.\morleyAppend a type to YA, assuming that notes and annotations for this type are unknown.IJKLMNOPQRSTUVWXYZ[\]^YZ[\WXTUVRSPQLMNOJKI]^S8U9 [7\7HNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmu‰gmorleyDVarious type errors possible when checking Morley extension commandsqmorleyType check errorwmorleyData 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.xmorleyAnnotation unify errorymorleyType equality errorzmorleyStacks equality error{morley¬Error that happens when type cannot be used in the corresponding scope. Argument of this constructor carries types which, in the aggregate, violate the restriction (e.g.  timestamp and  timestamp passed to MUL instruction).|morleyError that happens when a ¾. is never a valid source for this type (e.g.  timestamp cannot be obtained from a  )}morleyEThere are not enough items on stack to perform a certain instruction.~morley Invalid entrypoint name providedmorley.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‡morleyWDescription of the instruction which wants more items on stack than currently present.%ghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹%‡ˆ‰Š‹wxyz{|}~€‚ƒ„…†qrstuvghijklmnopINone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm€¦šmorleyThe typechecking stateØmorleyzRun 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).©morleyRun ¢0 and modify thrown errors using given functions.š›œžŸ ”¢£¤„¦§Ø©”Ÿ£š›œž §¢Ø©¤„¦JNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmžTŖmorleyAFunction which derives special annotations for PAIR instruction.+Namely, it does following transformation:  PAIR % % [  p.a int : p.b int : .. ] ~ [ "p (pair (int %a) (int %b) : .. ] All relevant cases (e.g.  PAIR %myf % 3) are handled as they should be according to spec.«morleyGFunction which derives special annotations for CDR / CAR instructions.¬morley8Append suffix to variable annotation (if it's not empty)­morley(Function which extracts annotations for or" type (for left and right parts).‹It extracts field/type annotations and also auto-generates variable annotations if variable annotation is not provided as second argument.®morley(Function which extracts annotations for option t type.TIt extracts field/type annotations and also auto-generates variable annotation for Some/ case if it is not provided as second argument.°morley.Combine annotations from two given stack types²morley:Extract singleton for each single type of the given stack.³morley.Check whether the given stack types are equal.“morleyCheck whether the given stack has size 1 and its only element matches the given type. This function is a specialized version of ³.¶morleyCheck whether elements go in strictly ascending order and return the original list (to keep only one pass on the original list).ømorley Function eqType is a simple wrapper around Data.Typeable.eqT suited for use within Either TCTypeError a applicative.æmorleyJCheck whether given types are structurally equal and annotations converge.Ąmorley%Generic implementation for MEMerationĒmorleyLHelper function to construct instructions for binary arithmetic operations.ĢmorleyLHelper function to construct instructions for binary arithmetic operations.#Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢ#±«Ŗ¬­®Æ°²³“µ¶ø·¹½ŗ»¼¾æĄĮĀÄĘÅĆĒČŹĖÉĢKNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm¬śĪmorley Function typeCheckValImplA converts a single Michelson value given in representation from Michelson.Type2 module to representation in strictly typed GADT.As a third argument, typeCheckValImpl accepts expected type of value.VType checking algorithm pattern-matches on parse value representation, expected type t and constructs Val t value.’If there was no match on a given pair of value and expected type, that is interpreted as input of wrong type and type check finishes with error.·morley Function typeCheckMapVal typechecks given list of Elt5s and ensures, that its keys are in ascending order.YIt return list of pairs (key, value) with keys in ascending order so it is safe to call fromDistinctAscList on returned listĶĪĪĶLNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm“­ø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.ĻĻMNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmĻŠ¼morleyLike  typeCheck, but for non-empty lists.Ńmorley Function  typeCheckListG converts list of Michelson instructions given in representation from Michelson.Type2 module to representation in strictly typed GADT.YTypes are checked along the way which is neccessary to construct a strictly typed value.As a second argument,  typeCheckList) accepts input stack type representation.Ņmorley Function typeCheckValueA converts a single Michelson value given in representation from Michelson.Untyped< module hierarchy to representation in strictly typed GADT.As a second argument, typeCheckValue accepts expected type of value.VType checking algorithm pattern-matches on parse value representation, expected type t and constructs Val t value.’If there was no match on a given pair of value and expected type, that is interpreted as input of wrong type and type check finishes with error.ÓmorleyLike Ņ&, but returns value of a desired type.½morley Function typeCheckInstrG converts a single Michelson instruction given in representation from Michelson.Type2 module to representation in strictly typed GADT.As a second argument, typeCheckInstr) accepts input stack type representation.®Type checking algorithm pattern-matches on given instruction, input stack type and constructs strictly typed GADT value, checking necessary type equalities when neccessary.–If there was no match on a given pair of instruction and input stack, that is interpreted as input of wrong type and type check finishes with error.¾morleyMHelper function for two-branch if where each branch is given a single value.ŠŃŅÓŌÕŠŅÓŃŌÕ¤None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmŃÖUIJKLMNOPQRSTUVWXYZ[\]^ghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹š›œžŸ ”¢£¤„¦§Ø©øæĶĻŠŃŅÓŌÕ ŠÕŌŅÓŃĶĻøæNNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmŁlÖmorley&Minimal (earliest) timestamp used for Arbitrary (CValue 'CTimestamp)×morley$Maximal (latest) timestamp used for Arbitrary (CValue 'CTimestamp)Ųmorley Median of Ö and ×\. Useful for testing (exactly half of generated dates will be before and after this date).Ö×ŲÖ×ŲONone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmłäćmorleyState of an arbitrary address.ämorley5For contracts without code we store only its balance.åmorley<For contracts with code we store more state represented by ę.ęmorleyState of a contract with code.čmorley'Amount of mutez owned by this contract.émorley,Storage value associated with this contract.źmorleyContract itself (untyped).ģmorley­We keep typed representation of contract code and storage in form, that hides their actual type in order to simplify the rest of the code (e.g. avoid type parameters for ęc and so on). They are made optional in order to perform safe parsing from JSON (we simply return  in this parser and use   or  6 that optionally typecheck storage or contract code).ōmorleyaPersistent data passed to Morley contracts which can be updated as result of contract execution.ömorleyIdentifier of chain.÷morley$All known addresses and their state.ųmorleyExtract balance from ć. morleyUpdates that can be applied to ō.æmorleyNumber of genesis addresses.Ąmorley6Secrets from which genesis addresses are derived from. morleyKeyHash of genesis address. morley.Initially these addresses have a lot of money. morleyOne of genesis key hashes. morleyOne of genesis addresses. morleyMore genesis addressesWe know size of genesisAddresses, so it is safe to use !! morleyMore genesis addressesWe know size of genesisAddresses, so it is safe to use !! morleyMore genesis addressesWe know size of genesisAddresses, so it is safe to use !! morleyInitial ō!. It's supposed to be used if no ō? is provided. It puts plenty of money on each genesis address. morleyRead ō from a file. morleyWrite ō to a file. morleyApply   to ō. morleyApply a list of  s to ō.Įmorley.Add an address if it hasn't been added before.Āmorley3Updare storage value associated with given address.Ćmorley3Updare storage value associated with given address. morley&Retrive all contracts stored in GState0ćäåęēčéźėģōõö÷ųüżž’                       0ęēčéźėģ    ćäåųōõö÷żü                ž’    PNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmņ %morleypConvert an untyped contract into a textual representation which will be accepted by the OCaml reference client. &morleymConvert a typed contract into a textual representation which will be accepted by the OCaml reference client. ‚ƒ„† % & ' ( ) ‚ƒ„† % & ' ) (QNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm · *morley6Built-in Michelson Macros defined by the specification Imorley1Unexpanded instructions produced directly by the ops[ parser, which contains primitive Michelson Instructions, inline-able macros and sequences JmorleyPrimitive Michelson instruction Kmorley5Built-in Michelson macro defined by the specification Lmorley2User-defined macro with instructions to be inlined MmorleyA sequence of instructions TmorleyA programmer-defined macro Zmorley%Expand all macros in parsed contract.: * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I M J K L N P O Q R S T U V W X Y Z [ \ ] ^ _ ` a b c: N P O Q R S * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E T U V W X F G I M J K L H Z [ c \ Y ] ^ _ ` a bRNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm™ ˆmorley!A programmer-defined type-synonym ŒmorleyA programmer-defined constant ˆ ‰ Š ‹ Œ  Ž   ˆ ‰ Š ‹ Œ  Ž  SNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm” ™morley2The environment containing lets from the let-block ™ š œ  › ž Ÿ ž ™ š œ  › ŸTNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmÆ £ ¤ „ ¦ § Ø © Ŗ « ¬ ­ ® £ ¤ „ ¦ § Ø © Ŗ « ¬ ­ ®UNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm- °morley endBy2 p sep# parses two or more occurrences of p, separated by sep. ±morleyMake a parser from a string ²morley8Apply given parser and return default value if it fails. ³morleyParse a positive number. “morley5Parse expression which can be wrapped in parentheses. Æ ° ± ² ³ “ ± Æ ° ² ³ “VNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm: µmorleyParse untyped  Fi. Take instruction parser as argument to avoid cyclic dependencies between modules, hence ' in its name. µ ¶ · ø ¹ µ ¹ ¶ · øWNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm"Q ŗmorley General TV2F Annotation parser, including Special Annotations Z[ ŗ » ¼ ½ ¾ æ Ą Į Ā Ć Ä ŗ » ¼ ½ ¾ æ Ą Ā Ć Į ÄZ[XNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm%’ ÅmorleyParse untyped Michelson ó (i. e. one with annotations). Å Ę Å ĘYNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm'x Ē Č É Ē É ČZNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm+F ŹmorleyFParser for primitive Michelson instruction (no macros and extensions). Ėmorley!Parse a sequence of instructions. Ź Ė Ģ Ķ Ī Ź Ė Ī Ķ Ģ[None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm-D Ļ Š Ń Ņ Ļ Š Ņ Ń\None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm2øÄmorleyElement of a let block Ómorleylet block parserÅmorley'Incrementally build the let environmentĘmorley1add a Let to the environment in the correct placeĒmorley7build a let name parser from a leading character parser Ó Ō Õ Ó Õ Ō]None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm=ą ÖmorleyParse with empty environment ×morley'Michelson contract with let definitionsČmorleyMichelson contract ŁmorleyŸParse 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)) :=¶·ø¹ŗ»¼½¾æĄĮ ž ¶ · ø Å Č Ō Ö × Ų Ł Ś Ū Ü ž × Ų»¼½¾æĄĮ=¶·ø¹ŗ Ö Ł Ś Ū Å Ō ¶ · ø Č Ü^None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmD7 Żmorley”Transform all strings in a typed instructions using given function. The first argument specifies whether we should go into arguments that contain instructions. Žmorley Similar to  Ż+ but for bytes. TODO [TM-375]: deduplicate Ż Ž Ż Ž_None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmb¾ÉmorleyDescribes how ŹG should decode tag-dependent data. We expect bytes of such structure: Ė5 followed by a bytestring which will be parsed with Ģ. ßmorleyAny decoding error.ĶmorleyAlias for label attaching.ĪmorleydGet a bytestring of the given length leaving no references to the original data in serialized form.ĻmorleyGet remaining available bytes.ĀNote that reading all remaining decoded input may be expensive and is thus discouraged, use can use this function only when you know that amount of data to be consumed is limited, e.g. within  decodeAsBytes call.Šmorley-Read a byte and match it against given value.ŃmorleyFail with "unknown tag" error.ŅmorleynRead a byte describing the primitive going further and match it against expected tag in the given conditions.Aside of context description, you have to specify number of arguments which given instruction accepts when written in Michelson. For instance, PUSH) accepts two arguments - type and value.ÓmorleyLike Ōa, but doesn't backtrack if next entry failed to parse yet there are some bytes to consume ahead.9This function exists primarily for better error messages.Õmorley Alias for É constructor. āmorley6Deserialize bytes into the given value. Suitable for UNPACK operation only. ćmorleyLike  ā, for strict byte array.Ömorley Overall value decoder we use in UNPACK.×morley-Read length of something (list, string, ...).Ųmorley9Given decoder for list content, get a whole list decoder.ŁmorleyRead a numeric value.Śmorley-Type check instruction occured from a lambda.Ūmorley?Utility function to fill a constructor with an empty annotationÜmorley5Decodes an annotations' string and uses the provided  ž† to parse untyped annotations from it. This has to produce at least one annotation (Annotations' String parsing will fail otherwise) ß ą į ā ć ß ą į ā ćĶ0Õ0`None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmm“ čmorleySerialize a value given to PACK instruction. émorleySame as  č, for strict bytestring.Żmorley4Lift encoded list content to an entire encoded list.ŽmorleyEncode a list-like structure.ßmorleyEncode a text.ąmorleyEncode some raw data.įmorleyEncode some map. ģmorley"Encode contents of a given number.āmorleyEncode an int-like value.ćmorleyEncode a code block.ämorleyEncode an instruction.åmorleygIff there are non-empty annotations it increments the value's tag and appends the encoded annotations.ęmorley&Encode an instruction with Annotations č é ź ė ģ ė ź č é ģaNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmœ ņmorley“Optimize a typed instruction by replacing some sequences of instructions with smaller equivalent sequences. Applies default set of rewrite rules. ómorley9Optimize a typed instruction using a custom set of rules. õmorleyWe do not enable ē  rule by default because it is potentially dangerous. There are various code processing functions that may depend on constants, e. g. string transformations.čmorleyAppend LHS of œk to RHS and re-run pointwise ruleset at each point. That might cause reinvocation of this function (see  ō3), but productivity ensures it will flatten any œE-tree right-to-left, while evaling no more than once on each node.dThe reason this function invokes ruleset is when you append an instr to already-optimised RHS of œ$, you might get an optimisable tree.<The argument is a local, non-structurally-recursive ruleset. ömorleyCombine two rule fixpoints. ÷morley*Combine a rule fixpoint and a simple rule.émorleyTurn rule fixpoint into rule.źmorleyDApply the rule once, if it fails, return the instruction unmodified.ėmorleyAn adapter for (.ģmorley.Apply a rule to the same code, until it fails. ķ ī ļ š ń ņ ó ō õ ö ÷ ņ ó ō õ ö ÷ ķ ī ļ š ńbNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmŽ łmorleyOperation size in bytes.}We use newtype wrapper because there are different units of measure (another one is gas, and we don't want to confuse them). ümorley9Maximal operation size allowed by Tezos production nodes. żmorleyRBase cost of any transfer of 0 mutez with no extra parameters. (Add 'valueOpSize  param5' to it to get assessment of actual transfer op size)ķmorleyAccepts arbitrary number of ”es (maybe of different types) which belong to the same entity and returns their total operation size.MNote that annotations which belong to the same entity (type or instruction) must be9 considered in aggregate using one call of this function. ł ś ū ü ż ž ’  ł ś ū ü ż ž ’ cNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm„ morleyMorley interpreter state "morleyfRepresents `[FAILED]` state of a Michelson program. Contains value that was on top of the stack when É was called. (morley#Environment for contract execution. *morleyTimestamp returned by the ģ instruction. +morleyANumber of steps after which execution unconditionally terminates. ,morley0Current amount of mutez of the current contract. -morleyOMapping from existing contracts' addresses to their executable representation. .morley$Address of the interpreted contract. /morley4The contract that initiated the current transaction. 0morley=The contract that initiated the current internal transaction. 1morley"Amount of the current transaction. 2morley Identifier of the current chain. 4morley¢Interpret a contract without performing any side effects. This function uses untyped representation of contract, parameter and storage. Mostly used for testing. 7morleyRInterpret an instruction in vacuum, putting no extra contraints on its execution.Mostly for testing purposes. 8morleyBFunction to change amount of remaining steps stored in State monadīmorleyCFunction to interpret Michelson instruction(s) against given stack.ļmorley?Evaluates an arithmetic operation and either fails or proceeds. :morley*Unpacks given raw data into a typed value.šmorley,Access given stack reference (in CPS style).2                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 :2 ( ) * + , - . / 0 1 2 " # $ % & '        3 6 7  5 4      !      8 9 :dNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm³ Lmorley0Dummy timestamp, can be used to specify current “ value or maybe something else. Mmorley’Dummy 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. NmorleyDummy  (s with some reasonable hardcoded values. You can override values you are interested in using record update syntax. OmorleyC– with most data hardcoded to some reasonable values. Contract and initial values must be passed explicitly, because otherwise it hardly makes sense. L M N O L M N OeNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmܜ! Pmorley,Result of a single execution of interpreter. RmorleyNew ō. Smorley7List of operations to be added to the operations queue. TmorleyUpdates applied to ō. UmorleyŗDuring 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. VmorleyPAs soon as transfer operation is encountered, this address is set to its input. Wmorley2Now much gas all remaining executions can consume. XmorleyMOperations executed by interpreter. In our model one Michelson's operation ( operationA type in Michelson) corresponds to 0 or 1 interpreter operation.Note: ó is not part of æ , because æ0 is supposed to be provided by the user, while ó can be computed by our code. YmorleyOriginate a contract. ZmorleybSend a transaction to given address which is assumed to be the address of an originated contract. ^morleyEErrors that can happen during contract interpreting. Type parameter aE determines how contracts will be represented in these errors, e.g. Address _morley0The interpreted contract hasn't been originated. `morley,Interpretation of Michelson contract failed. amorley!A contract is already originated. bmorleySender address is unknown. cmorleyManager address is unknown. dmorley!Sender doesn't have enough funds. emorleySending 0tz towards an address. fmorley"Failed to apply updates to GState. gmorleyA contract is ill-typed. hmorleyContract storage is ill-typed. imorley Contract parameter is ill-typed. jmorley)Specified entrypoint to run is not found. mmorleyParse a contract from #. nmorleyParse a contract from # and expand macros. omorley,Read and parse a contract from give path or ń (if the argument is  ). The contract is not expanded. pmorleyRead a contract using  o8, expand and flatten. The contract is not type checked. qmorleyFOriginate a contract. Returns the address of the originated contract. rmorley}Run a contract. The contract is originated first (if it's not already) and then we pretend that we send a transaction to it. smorley:Send a transaction to given address with given parameters.ņmorleycExecute a contract on some global state (read from file) and transaction data (passed explicitly). tmorley#Implementation of executor outside ó«. It reads operations, executes them one by one and updates state accordingly. Each operation from the passed list is fully executed before the next one is considered.ōmorley&Execute only one operation and update ō accordingly.4æĄĮĀĆÄćäåęēčéźėģ 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 u4 q r s m n o p uęēčéźėģćäåæĄĮĀĆÄ X Y Z P Q R S T U V W ^ _ ` a b c d e f g h i j ] t k lfNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmģŠ zmorley'Type for contract execution validation.oIt's a function which is supplied with contract execution output (failure or new storage with operation list).FFunction returns a property which type is designated by type variable prop and might be „¦ or §Ø or anything else relevant. {morleyÆContract's property tester against given input. Takes contract environment, initial storage and parameter, interprets contract on this input and invokes validation function. |morley Version of  { which takes Val1 as arguments instead of regular Haskell values. }morley"Check if entrypoint is present in į. ~morleyBCheck whether the given set of entrypoints is present in contract. morleykMatch the given contract with provided set of entrypoints, return left if some entrypoints were not found.  z { | } ~   z { | ~  }gNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm/G*õmorley5Store result of interpreted operations as they added.ömorley7Store the most recent result of interpreted operations.÷morley4Map from contracts addresses to humanreadable names.ųmorleyRIf set, all following transfers will be executed on behalf of the given contract.łmorley"A result of an executed operation.śmorley.Overall information about test scenario error.ūmorley$A dummy data type that ensures that  šJ is called in the end of each scenario. It is intentionally not exported. ‹morleyMA monad inside which integrational tests can be described using do-notation. ŒmorleyFValidator for integrational testing that expects successful execution. morleyLValidator for integrational testing. If an error is expected, it should be Z with validator for errors. Otherwise it should check final global state and its updates.ümorley When using branchS function for building test scenarios - names of branches we are currently within. –morleyoIntegrational test that executes given operations and validates them using given validator. It can fail using ż capability. It starts with  ‡ and some reasonable dummy values for gas limit and current timestamp. You can update blockchain state by performing some operations. —morleyIntegrational test similar to  –. It can fail using f/ capability. It can be used with QuickCheck's forAll4 to make a property-based test with arbitrary data.žmorleyCHelper function which provides the results of the given operations.’morleyInterprets provided list of operations only if previous interpretation succeeded which allows for engine return the earliest error possible. ˜morleyVOriginate a contract with given initial storage and balance. Its address is returned. ™morley#Transfer tokens to a given address. šmorleyValidate the execution result. ›morleyJust fail with given error. œmorley@Make all further interpreter calls (which are triggered by the  š5 function) use modified timestamp as the current one. morley@Make all further interpreter calls (which are triggered by the  š2 function) use given timestamp as the current one. žmorley5Increase current time by the given number of seconds. Ÿmorley@Make all further interpreter calls (which are triggered by the  š function) use given gas limit.  morleyTPretend that given address initiates all the transfers within the code block (i.e. SENDER' instruction will return this address). ”morley@Make all further interpreter calls (which are triggered by the  š function) use given chain id.morley+Put an interpreted result to InternalState.morley?Make branch names for a case when we are not within any branch.morley4Add a new branch element to names provided by inner branch calls. ¢morleyaExecute multiple testing scenarios independently, basing them on scenario built till this point./The following property holds for this function:G pre >> branchout [a, b, c] = branchout [pre >> a, pre >> b, pre >> c] .TIn case of property failure in one of the branches no following branch is executed.TProviding empty list of scenarios to this function causes error; we do not require ‚ here though for convenience. £morley5Make a tuple with name without extra syntactic noise. ¤morleyvTest given scenario with the state gathered till this moment; if this scenario passes, go on as if it never happened. „morley Œ that always passes. ¦morley!Check that there were no updates. §morley)Check that there were no storage updates. ØmorleyjCheck that storage value is updated for given address. Takes a predicate that is used to check the value.YIt works even if updates are not filtered (i. e. a value can be updated more than once). ©morleyLike  Ø, but expects a constant. Ŗmorley@Check that eventually address has some particular storage value. «morley:Check that eventually address has some particular balance. ¬morleyCompose two success validators. For example:expectBalance bal addr  ¬* expectStorageUpdateConst addr2 ValueUnit ­morley%Compose a list of success validators. ®morley4Check that interpreter failed due to gas exhaustion. ÆmorleyOExpect that interpretation of contract with given address ended with [FAILED].5æĄĮĀĆÄ        €  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ  – — ˜ ™ š › œ  ž Ÿ   ” ¢ £ ¤ „ ¦ § Ø © Ŗ « ¬ ­ ® Æ5æĄĮĀĆÄ         Œ ‹ Š €  ‚ ƒ „ … † ‡ ˆ ‰ – — ˜ ™ š › Ÿ œ  ž   ” ¢ £ ¤ ¬ ­ „ ¦ § Ø © « Ŗ ® Æ £0hNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm?ł ±morley,This data type captures typical ways to use É? instruction. Each constructor corresponds to a usage pattern.morley(Push a constant string and fail with it.morleytPush a constant pair where the first item is a string and the second one is an arbitrary constant. Fail afterwards.morley%Push a constant string and apply the ± instruction, then fail.morley!We need this class to pass it to . ' is needed because we push a value and j is needed for É. ²morleyExtract error tag out of  ±. ³morley4Check whether given instruction ends with a typical É^ usage. It does not recursively check instructions that can be passed to other instructions. “morley)If given instruction ends with a typical É{ usage, modify the tag used there using given transformation function. It can return any value, not necessarily a string. ± ² ³ “ ± ² ³ “iNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmN2 ø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. »morleyĀStatically 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. ¶ · ø ¹ ŗ » ¶ · ø ¹ ŗ »jNone5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmqW? ĮmorleyLifted ©. ÄmorleyLifted ­. ÅmorleyLifted Æ. ĘmorleyLifted ². ÉmorleyLifted ¶. ĢmorleyLifted ŗ.4This could be just a constraint alias, but to avoid ³W types appearance in error messages we make a full type class with concrete instances. ĶmorleyLifted ¼. ĻmorleyLifted æ. Ņmorley-A useful property which holds for reasonable æ instances.It's a separate thing from  Ļ because it mentions b type parameter. ÓmorleyLifted Å. Į Ā Ć Ä Å Ę Ē Č É Ź Ė Ģ Ķ Ī Ļ Ń Š Ņ Ó Ō Ó Ō Ļ Ń Š Ķ Ī Ģ É Ź Ė Ę Ē Č Å Ä Į Ā Ć ŅkNone5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm`M ųmorley1Constraint applied to any part of parameter type.ZNote that you don't usually apply this constraint to the whole parameter, consider using m© in such case.‹Using this type is justified e.g. when calling another contract, there you usually supply an entrypoint argument, not the whole parameter. ümorley/Ensure given type does not contain "operation". žmorley2Gathers constraints, commonly required for values.3 ń ņ ó ō õ ö ÷ ų ł ś ū ü ż ž ’     ų ÷ ö õ ō ó ņ ń ’     ł ž ż ü ū ś3lNone5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm¬‹ morleysNo entrypoints declared, parameter type will serve as argument type of the only existing entrypoint (default one). morley$This wrapper allows to pass untyped ĘF and bypass checking that entrypoint with given name and type exists. morley . constraint specialized to default entrypoint. morley’When we call a Lorentz contract we should pass entrypoint name and corresponding argument. Ideally we want to statically check that parameter has entrypoint with given name and argument. Constraint defined by this type class holds for contract with parameter cp that have entrypoint matching name with type arg.^In order to check this property statically, we need to know entrypoint name in compile time,  I type serves this purpose. If entrypoint name is not known, one can use  A wrapper to take responsibility for presence of this entrypoint.mIf you want to call a function which has this constraint, you have two options: 1. Pass contract parameter cp using type application, pass  H as a value and pass entrypoint argument. Type system will check that cp; has an entrypoint with given reference and type. 2. Pass Ę wrapped into  v and entrypoint argument. In this case passing contract parameter is not necessary, you do not even have to know it. morley;Data returned by this method may look somewhat arbitrary. Ę is obviously needed because name can be   or  . Dict is returned because in  ` case we get this evidence for free and don't want to use it. We seem to always need it anyway. morleyUniversal entrypoint lookup. morleyWhich entrypoint to call.iWe intentionally distinguish default and non-default cases because this makes API more details-agnostic. morleyHCall the default entrypoint, or root if no explicit default is assigned. morleyŠCall the given entrypoint; calling default is not treated specially. You have to provide entrypoint name via passing it as type argument.’Unfortunatelly, here we cannot accept a label because in most cases our entrypoints begin from capital letter (being derived from constructor name), while labels must start from a lower-case letter, and there is no way to make a conversion at type-level. morley6Ensure that there is no explicit "default" entrypoint. morley:Get type of entrypoint with given name, fail if not found. morley:Get type of entrypoint with given name, fail if not found. morley#Lookup for entrypoint type by name.4Does not treat default entrypoints in a special way. morley+Get all entrypoints declared for parameter.morley Version of  e which we actually use in function signatures. When given type is sum type or newtype, we refer to  9, otherwise we suppose that no entrypoints are declared. morley$Parameter declares some entrypoints.This is a version of  _ which we actually use in constraints. When given type is a sum type or newtype, we refer to  5 instance, otherwise this instance is not necessary. morley+Which entrypoints given parameter declares.GNote that usually this function should not be used as constraint, use   for this purpose. morley*Result of entrypoint lookup at term level. morley0Ensure that all declared entrypoints are unique. !morleyMDefines a generalized way to declare entrypoints for various parameter types.8When defining instances of this typeclass, set concrete deriv argument and leave variable cp[ argument. Also keep in mind, that in presence of explicit default entrypoint, all other ļ arms should be callable. "morleybName and argument of each entrypoint. This may include intermediate ones, even root if necessary.%Touching this type family is costly (O(N^2)), don't use it often. #morley Get entrypoint argument by name. $morleyJConstruct parameter annotations corresponding to expected entrypoints set.IThis method is implementation detail, for actual notes construction use  &. %morleyConstruct entrypoint caller.AThis does not treat calls to default entrypoint in a special way.HThis method is implementation detail, for actual entrypoint lookup use  '. &morley'Derive annotations for given parameter. 'morley!Prepare call to given entrypoint.kThis does not treat calls to default entrypoint in a special way. To call default entrypoint properly use  (. (morleyCall the default entrypoint. *morleyUniversal entrypoint calling. +morleyZFlatten a provided list of notes to a map of its entrypoints and its corresponding utype.TIt is obtained by constructing `insert k1 v1 (insert k2 v2 ... mempty)` pipe using ” so that it is more concise rather than stacking composition of monoidal endomorphisms explicitly. Note that here no duplicates can appear in returned map for &' even if they may appear inside passed ō tree.!                   ! " # $ % & ' ( ) * +! ! " # $ %         &  '  ( +     )     * mNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm°? /morley-Constraint applied to a whole parameter type. / /ŖNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm²3 ń ņ ó ō õ ö ÷ ų ł ś ū ü ż ž ’     /None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmĄŌ 0morleyConvert something from  ContractAddr in Haskell world. 2morleyConvert something to = in Haskell world. 4morleyConvert something to ó in Haskell world.]Use this when you want to access state of the contract and are not interested in calling it. 6morley3Address associated with the contract of given type. Places where  ContractAddrJ can appear are now severely limited, this type gives you type-safety of  ContractAddr" but still can be used everywhere.WThis may be refer to specific entrypoint of the contract, in such case type parameter p1 stands for argument of that entrypoint like in  ContractAddr.BYou still cannot be sure that the referred contract exists though. :morley!Turn future contract into actual contract. @morley1Make contract ref calling the default entrypoint.L"%678LKĘÉķ÷rz€±“·»ÄÅÉó-./0UVWXYZ[\]^:;<=>?@ABIJKLMNOPQ 0 1 2 3 4 5 6 7 8 9 : ;LIJKLMNOPUVWXYZ[\]^ķ"ó-./0·“±r€z6%:;< 9=>?@ 6 7 8ĘÉBA»÷ÄÅÉQ : 4 5 2 3 0 1 ;78LKnNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmÅą JmorleyLifted  UnaryAithOp. LmorleyLifted AithOp. J K L M L M J KoNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmĒÖ w x w xpNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmĖ ymorleyOWrap parameter into this to locally assign a way to derive entrypoints for it. y z { y z {qNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmŲr morley;Errors that can happen during parsing into a Lorentz value. ‡morley Alias for  ˆ3, seems to make signatures more readable sometimes.:Let's someday decide which one of these two should remain. ˆmorleyAAlias for instruction which hides inner types representation via T. ’morley`Parse textual representation of a Michelson value and turn it into corresponding Haskell value.’Note: it won't work in some complex cases, e. g. if there is a lambda which uses an instruction which depends on current contract's type. Obviously it can not work, because we don't have any information about a contract to which this value belongs (there is no such contract at all). “morleyLorentz version of  Ż. ”morleyLorentz version of  Ž.  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ  Ž   ‘ ’ “ ” • – ˆ ‰ Š ‡ ‚ ‘ Œ ‹  Ž   ’ “ ” – • † … ƒ „  ‚2 ‡1 ˆ1 ‘8rNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmä[ žmorley!Require several stacks to comply  Ÿ constraint. Ÿmorley"Zipping stack into tuple and back.  morley-A type which contains the whole stack zipped. ”morley#Fold given stack into single value. ¢morley'Unfold given stack from a single value. morley Version of  ‘k which performs some optimizations immediatelly. Need it here at least because we don't want to surround fromVal (Lambda i o) with nops. £morley'Flatten both ends of instruction stack. ¤morley)Unflatten both ends of instruction stack. ¦morleyHSuch definition seems the only possible one we can support efficiently. ž Ÿ   ” ¢ £ ¤ Ÿ   ” ¢ ž £ ¤sNone5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmęq © Ŗ « ¬ « ¬ © ŖtNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm’€  morleyGeneric traversal for  . morley…Returns: 1. Notes corresponding to this level; 2. Field annotation for this level (and which should be used one level above).morley6Fetches information about all entrypoints - leaves of ļ tree.morley6Fetches information about all entrypoints - leaves of ļ tree. morley"Traverses sum type and constructs ō7 which report constructor names via field annotations.morleyBuild  by parameter type.morleyEntrypoints tree - skeleton on æ‚ tree later used to distinguish between constructors-entrypoints and constructors which consolidate a whole pack of entrypoints. Émorley Similar to  ŹG, but for case of parameter being defined as several nested datatypes.aIn particular, this will traverse sum types recursively, stopping at Michelson primitives (like =) and constructors with number of fields different from one.2It does not assign names to intermediate nodes of ļ tree, only to the very leaves. ŹmorleyImplementation of  l which fits for case when your contract exposes multiple entrypoints via having sum type as its parameter.ĮIn particular, each constructor would produce a homonymous entrypoint with argument type equal to type of constructor field (each constructor should have only one field). Constructor called 7' will designate the default entrypoint.morleyAMakes up notes with proper field annotations for given parameter.morley=Makes up a way to lift entrypoint argument to full parameter. É Ź Ź É«None5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmn"                ! " # $ % & ' ( ) * + y z { É Ź" ! " # $ %      & +  '  (     )     * y z { Ź ÉuNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmĢ ÖmorleyFor use outside of Lorentz. ×morley Version of  Ö< specialized to instruction corresponding to contract code. Ųmorley3Interpret a Lorentz instruction, for test purposes. ŁmorleyLike  Ų9, but works on lambda rather than arbitrary instruction. ŚmorleyLorentz version of analyzer. Ö × Ų Ł Ś Ö × Ų Ł ŚvNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm – Ūmorley.Pretty-print a Haskell value as Michelson one. Ümorley4Pretty-print a Lorentz contract into Michelson code. Ū Ü Ū ÜwNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmA Żmorley_Type that represents test scenario for Lorentz contract. Simply put, it is sequence of pairs (sender,  parameterI). Using this sequence we can perform transfers to the desired contract. Žmorley*Function to get textual representation of  TestScenario, each Parameter is printed as a raw Michelson value. This representation can later be used in order to run test scenario on real network.žThe format for a single contract call is the following: # `printed Lorentz parameter` (actually comment) `sender address` `printed raw Michelson parameter` Ż Ž Ż ŽxNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmAĪ įmorley(Retain the value only if it is not zero. ēmorley Drop top n elements from the stack. źmorley Version of  ėG which uses Peano number. It is inteded for internal usage in Lorentz. morley Similar to  @ but works for lambdas with arbitrary size of input and output.Note that this instruction has its arguments flipped, lambda goes first. This seems to be the only reasonable way to achieve good inference. morley Version of  G which uses Peano number. It is inteded for internal usage in Lorentz. +morley(Get a reference to the current contract.Note that, similar to ē instruction, in Michelson ęk instruction can accept an entrypoint as field annotation, and without annotation specified it creates a contract* value which calls the default entrypoint.2This particular function carries the behaviour of SELFR before introduction of lightweight entrypoints feature. Thus the contract must not6 have explicit "default" entrypoint for this to work.DIf you are going to call a specific entrypoint of the contract, see  ,. ,morleyFMake a reference to the current contract, maybe a specific entrypoint.‘Note that, since information about parameter of the current contract is not carried around, in this function you need to specify parameter type p explicitly. -morley-Get a reference to a contract by its address.*This instruction carries the behaviour of CONTRACTM before introduction of lightweight entrypoints feature. The contract must not5 have explicit "default" entrypoint for this to work.DIf you are going to call a specific entrypoint of the contract, see  .. .morley<Make a reference to a contract, maybe a specific entrypoint.LNote that in most cases you need to specify parameter type as type argument p. /morleySpecialized version of  .I for the case when you do not have compile-time evidence of appropriate  %. For instance, if you have untyped Ę^ you can not have this evidence (the value is only available in runtime). If you have typed  , use  ) to construct Ę. 0morley Version of  -Ö which may accept address with already specified entrypoint name. Validity of such operation cannot be ensured at compile time. Also you cannot provide entrypoint name here because this could result in conflict. Bmorley-Execute given instruction on truncated stack.ZThis instruction requires you to specify the piece of stack to truncate as type argument. CmorleyHelper instruction.jChecks whether given key present in the storage and fails if it is. This instruction leaves stack intact. DmorleyLike  <, but throw an error on attempt to overwrite existing entry.d į ā ć ä å ę ē č é ź ė ģ ķ ī ļ š ń ņ ó ō õ ö ÷ ų ł ś ū ü ż ž ’                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C Dd å ę ē č é ź ė ģ ķ ī ļ š ń ņ ó ō õ ö ÷ ų ł ū ü ż ž ’    C D  ś     ä                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B ā ć įyNone5!"#$%&'*,-.012456789;=>?@ACHMNPSUVX_`befgkmP‚morley<Allows diving into stack referring expected new tip by type.ŽImplemented with fun deps for conciseness; we can replace them with a type family anytime, but that would probably require more declarations.morley9Allows duplicating stack elements referring them by type. Hmorley3Duplicate an element of stack referring it by type.IIf stack contains multiple entries of this type, compile error is raised. ImorleyFDip repeatedly until element of the given type is on top of the stack.IIf stack contains multiple entries of this type, compile error is raised. Jmorley2Remove element with the given type from the stack. H I J H I JzNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmRp Q R S T Q R S T{None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmXŌ Umorley Version of  V which accepts no argument. Vmorley Single entrypoint of a contract.#Note that we cannot make it return [[Operation], store]5 because such entrypoint should've been followed by pairC, and this is not possible if entrypoint implementation ends with failWith. U V V U None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmu] WmorleyCoercions between a to b are permitted and safe.morleyCoercion from a to b is permitted and safe. XmorleyExplicitly allowed coercions. YmorleyEAn optional method which helps passing -Wredundant-constraints check. Zmorley9Whether two types have the same Michelson representation. [morleyCoercion for Haskell world.CWe discourage using this function on Lorentz types, consider using coerce‹ instead. One of the reasons forthat is that in Lorentz it's common to declare types as newtypes consisting of existing primitives, and  forcedCoerceY tends to ignore all phantom type variables of newtypes thus violating their invariants. \morleyBConvert between values of types that have the same representation.dThis function is not safe in a sense that this allows breaking invariants of casted type (example: UStore¹) or may stop compile on code changes (example: coercion of pair to a datatype with two fields will break if new field is added). Still, produced Michelson code will always be valid.=Prefer using one of more specific functions from this module. ^morley'Convert between two stacks via failing. _morleySpecialized version of coerce_ to wrap into a haskell newtype. `morleySpecialized version of coerce_ to unwrap a haskell newtype. amorley"Lift given value to a named value. bmorleyUnpack named value. cmorley)Coercion in Haskell world which respects  X. dmorleyPCoerce between types which have an explicit permission for that in the face of  X constraint. emorley4Pretends that the top item of the stack was coerced. fmorleyLocally provide given  X instance. gmorleyLocally provide bidirectional  X instance. hmorley Make up a  6. imorleyGet address referred by  6.<;: W X Y Z [ \ ] ^ _ ` a b c d e f g h i X Y c W d e f g ` _ a b Z [ \ ] ^ h i<;:|None5!"#$%&'*,-./012456789;=>?@AHMNPSUVX_`befgkm‹„morley*Helper which documents single constructor. omorley0Information to be provided for documenting some  x x. pmorleyImplementation for ’ of the corresponding  Extensible. qmorleyImplementation for  of the corresponding  Extensible. rmorley!Overall description of this type.morley1Generic implementation of toExtVal and fromExtValmorley?Having a sum-type, yields a type-level list of its constructorsmorleyTransform list of  s to list of 2s, assigning numbers to elements starting from 0.morley>Finds the constructor's position and argument type by its name smorley'Errors related to fromExtVal conversionmorleyqHelper typeclass which allows us to sanely handle cases of no-arg constructor and constructor with one argument.morley3Pack argument on top of the stack, if any required. zmorleyConverts a value from a Haskell representation to its extensible Michelson representation (i.e. (Natural, Bytestring) pair). {morleyįConverts a value from an extensible Michelson representation to its Haskell sum-type representation. Fails if the Michelson representation points to a nun-existent constructor, or if we failed to unpack the argument. |morleyGWraps an argument on top of the stack into an Extensible representation o p q r s t u v w x y z { | x y s t u w o p q r z { | v None5!"#$%&'*,-.012456789;=>?@ACHMNPSUVX_`befgkm±é ŽmorleyDProvides "case" arrow which works on different wrappers for clauses. 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. morleyLorentz analogy of ’, it works on plain Š types. ’morleyShortcut for multiple  – constraints. ”morleyA pair of field name and type. –morleyLike  —&, but allows constrainting field type. —morley%Allows field access and modification. ˜morley]Extract a field of a datatype replacing the value of this datatype with the extracted field.wFor this and the following functions you have to specify field name which is either record name or name attached with (:!) operator. ™morleyLike  ˜, but leaves field named. šmorleyFExtract a field of a datatype, leaving the original datatype on stack. ›morleyLike  š, but leaves field named. œmorleySet a field of a datatype. morley)Apply given modifier to a datatype field. žmorleyIMake up a datatype. You provide a pack of individual fields constructors.KEach element of the accepted record should be an instruction wrapped with   T function. This instruction will have access to the stack at the moment of calling  constructØ. Instructions have to output fields of the built datatype, one per instruction; instructions order is expected to correspond to the order of fields in the datatype. Ÿmorley Version of  ž+ which accepts tuple of field constructors.  morley)Lift an instruction to field constructor. ”morley0Wrap entry in constructor. Useful for sum types. ¢morley$Pattern match on the given sum type.You have to provide a O; containing case branches. To construct a case branch use   operator. £morleyLike  ¢;, accepts a tuple of clauses, which may be more convenient.sIf user is experiencing problems with wierd errors about tuples while using this function, he should take look at  ¬ƒ and ensure that his tuple isn't bigger than generated instances, if so, he should probably extend number of generated instances. ¤morley0Wrap entry in constructor. Useful for sum types."ABCDEONMÉŹ  Ž   ‘ ’ “ ” • – — ˜ ™ š › œ  ž Ÿ   ” ¢ £ ¤" — – ’ ” • “ ˜ ™ š › œ  ž Ÿ   ” ¢ £ ¤  Ž   ‘ÉŹONMDECAB 0 “0}None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmĢh ¦morley%Test case for contract documentation. Ømorley`Declaration location, used to distinguish different test predicates. This is primarily used in  ¬. ©morley+Description of predicate, which you put to  . Ŗmorley Test itself. «morley Construct  ¦. ¬morleyExclude given test suite. ­morleyCalling excludeDocTests tests toExclude returns all test suites from tests which are not present in  toExclude. ®morleyFinalize test suites. Æmorley Ensure that  ¦> check fires on given contract. Used in tests on this module.!morley1Apply given function to each group (created with DocGroupd instruction) recursively. This function will accept grouping doc item itself and its subcontents. °morley1Apply given function to each group (created with DocGroup instruction) within a contract recursively. This function will accept grouping doc item itself (unless we are at root) and its subcontents. ±morley2Check that contract documentation is wrapped with  contractName. ²morley7Check that there is at least one non-grouping doc item.{If there is no such, rendered documentation will be empty which signals about most of the documentation pieces being lost. ³morley!Check that no group contains two w items.½Normally such behaviour is allowed and can be exploited, but often it is not and multiple descriptions appearence under the same group signals about missing grouping wrapper (e.g. use of caseT instead of  entryCase). “morley;Base properties which should comply for all documentations. ¦ § Ø © Ŗ « ¬ ­ ® Æ ° ± ² ³ “ ¦ § Ø © Ŗ « ¬ ­ ® Æ “ ± ² ³ °~None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmÕÖ ømorleyPut a document item. ¹morleyqGroup documentation built in the given piece of code into block dedicated to one thing, e.g. to one entry point. ŗmorleyCGive a name to given contract. Apply it to the whole contract code. ½morley1Leave only instructions related to documentation.¬This function is useful when your method executes a lambda coming from outside, but you know its properties and want to propagate its documentation to your contract code.Sn6789:;<=EFGHIJKLMNOPQRSTUVWXYZ[\]^_copqrstuvwx{€‚ƒö÷ųłśūž’    ø ¹ ŗ » ¼ ½S ø ¹ » ¼ ŗ ½nTUVWXYZ[\]^RSOPQLMNIJKGHEF<={6789:;wxtuvqrsƒ‚opųł_€cž’śū÷ö   None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmōĖ æmorley)Collect all fields with the given marker. ĄmorleyGet kind of field. Įmorley>Get type of plain field. This ignores marker with field type. ĀmorleyGet type of submap value. ĆmorleyGet type of submap key. Ämorley9Get map signature from the constructor with a given name. Émorley-What was found on lookup by constructor name.$This keeps either type arguments of  Õ or  Ņ. ĢmorleyhAllows to specify format of key under which fields of this type are stored. Useful to avoid collisions. ĶmorleytDisplay type-level information about UStore field with given marker and field value type. Used for error messages. Īmorley<By field name derive key under which field should be stored. Šmorley Just a plain field used as data. Ńmorley,Specific kind used to designate markers for  Ņ.zWe suggest that fields may serve different purposes and so annotated with special markers accordingly. See example below.mThis kind is implemented like that because we want markers to differ from all other types in kind; herewith  ŃI is still an open kind (has potentially infinite number of inhabitants)."morleyJust a servant type. Ņmorley%Describes plain field in the storage. Õmorley-Describes one virtual big map in the storage. ŲmorleyGathers multple fields and :s under one object.˜Type argument of this datatype stands for a "store template" - a datatype with one constructor and multiple fields, each containing an object of type  Ņ or  Õ/ and corresponding to single virtual field or :„ respectively. It's also possible to parameterize it with a larger type which is a product of types satisfying the above property. Ūmorley Shortcut for  Ī< which accepts not marker but store type and name of entry. æ Ą Į Ā Ć Ä Å Ę Ē Č É Ź Ė Ģ Ķ Ī Ļ Š Ń Ņ Ó Ō Õ Ö × Ų Ł Ś Ū Ų Ł Ś Õ Ö × Ņ Ó Ō Š Ń Ļ Ģ Ķ Ī Ū Ć Ā Į Ą æ É Ź Ė Ä Č Ē Ę Å€None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm “ īmorleyApply multiple coverage steps.#morleySingle piece of a coverage. ļmorleyOApply given diff coverage, returning type of affected field and modified diff. šmorleyNCover the respective part of diff. Maybe fail if such action is not required.This type is very similar to  ś“, but we still use another type as 1. Their kinds will differ - no chance to mix up anything. 2. One day there might appear more complex actions. ómorleyVHelper type family which dumps error message about remaining diff if such is present. ōmorley5Renders human-readable message describing given diff. õmorley3Make up a migration diff between given old and new  Ų templates.$morleyLift a list of  ż to  łs via attaching given  ś.%morleyLHelper to make sure that datatype field is named and then extract this name. ömorley(Get only field names of UStore template. ųmorley>Get information about all fields of UStore template in a list.tIn particular, this recursivelly traverses template and retrives names and types of fields. Semantic wrappers like  Ņ and  Õ# in field types are returned as-is. łmorleySingle piece of a diff. śmorley%What should happen with a particular  UStoreItem. żmorley)Information about single field of UStore. ī ļ š ń ņ ó ō õ ö ÷ ų ł ś ū ü ż ż ś ū ü ł õ ō ó ų ÷ ö š ń ņ ļ īNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm !+&morley)Get all fields names accessible in given  Ų template. ’morleyLift an  Ų to another  ŲA which contains all the entries of the former under given field.RThis function is not intended for use in migrations, only in normal entry points.Note that this function ensures that template of resulting store does not contain inner nested templates with duplicated fields, otherwise  Ų invariants could get broken. morley Unlift an  Ų to a smaller  Ų which is part of the former.RThis function is not intended for use in migrations, only in normal entry points.Surprisingly, despite smaller  Ų² may have extra entries, this function is safe when used in contract code. Truly, all getters and setters are still safe to use. Also, there is no way for the resulting small UStore= to leak outside of the contract since the only place where big_map0 can appear is contract storage, so this small UStore+ can be either dropped or lifted back via  ’/ to appear as part of the new contract's state.…When this function is run as part of standalone instructions sequence, not as part of contract code (e.g. in tests), you may get an UStore" with entries not inherent to it.'morleyJThis example demostrates a way to run an instruction, operating on small  Ų, so that it works on a larger  Ų. ž ’  ’ ž‚None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm s4$ morley+Minimal possible piece of migration script.€Different atoms can be arbitrarily reordered and separated across migration stages, but each single atom is treated as a whole.ESplitting migration into atoms is responsibility of migration writer. morley"Describes single migration action.In most cases it is possible to derive reasonable description for migration atom automatically, this datatype exactly carries this information. morley3Action on field, e.g. "set", "remove", "overwrite". morleyName of affected field of  Ų. morleyType of affected field of  Ų in new storage version. morleyAn action on storage entry. morley9Some sort of addition: "init", "set", "overwrite", e.t.c. morleyRemoval. morleyCorner case of  ! with some type argument unknown.You can turn this into   using  c. morleyCode of migration for  Ų.šInvariant: preferably should fit into op size / gas limits (quite obvious). Often this stands for exactly one stage of migration (one Tezos transaction). morleyUStore with hidden template. morleyDummy template for  ŲV, use this when you want to forget exact template and make type of store homomorphic.(morley&Manually perform a piece of migration. morley;Merge several migration scripts. Used in manual migrations.pThis function is generally unsafe because resulting migration script can fail to fit into operation size limit. morleyjAdd description of action, it will be used in rendering migration plan and some batching implementations. morleyWe allow casting between   and  Ų freely. )morley%Migration script splitted in batches.PThis is an intermediate form of migration content and needed because compiling  2Į is a potentially heavyweight operation, and after compilation is performed you may need to get various information like number of migration steps, migration script, migration plan and other. ,morley2Way of distributing migration atoms among batches.©This also participates in describing migration plan and should contain information which would clarify to a user why migration is splitted such a way. Objects of type  batchInfoq stand for information corresponding to a batch and may include e.g. names of taken actions and gas consumption.Type argument  structureQ stands for container where batches will be put to and is usually a list ('[]').ßWhen writing an instance of this datatype, you should tend to produce as few batches as possible because Tezos transaction execution overhead is quite high; though these batches should still preferably fit into gas limit.’wNote that we never fail here because reaching perfect consistency with Tezos gas model is beyond dreams for now, even if our model predicts that some migration atom cannot be fit into gas limit, Tezos node can think differently and accept the migration. If your batching function can make predictions about fitting into gas limit, consider including this information in  batchInfo type. See batching implementations in !Lorentz.UStore.Migration.Batching module. .morley Wrapper over  Ų# which is currently being migrated. In type-level arguments it keeps Old and new  Ų: templates - mostly for convenience of the implementation.‚Remaining diff which yet should be covered. Here we track migration progress. Once remaining diff is empty, migration is finished.\Names of fields which have already been touched by migration. Required to make getters safe. 0morley8A bunch of migration atoms produced by migration writer. 2morley*Keeps information about migration between  Ųs with two given templates. 7morleyTurn  Migration5 into a whole piece of code for transforming storage.ˆThis is not want you'd want to use for contract deployment because of gas and operation size limits that Tezos applies to transactions. 8morleyModify all code in migration. 9morley Create migration atom from code.HThis is an internal function, should not be used for writing migrations. :morley,Put each migration atom to a separate batch.fIn most cases this is not what you want, but may be useful if e.g. you write your migration manually. ;morley'Put the whole migration into one batch. <morley Version of  =- which allows splitting migration in batches.pHere you supply a sequence of migration blocks which then are automatically distributed among migration stages. =morley)Safe way to create migration scripts for  Ų.0You have to supply a code which would transform  .P, coverring required diff step-by-step. All basic instructions work, also use migrate*- functions from this module to operate with  .. This method produces a whole migration, it cannot be splitted in batches. In case if your migration is too big to be applied within a single transaction, use  <. >morley(Compile migration for use in production. ?morleyIGet migration scripts, each to be executed in separate Tezos transaction. @morleyGet migration scripts as list. Amorley?Get migration script in case of simple (non-batched) migration. Bmorley?Get migration script in case of simple (non-batched) migration. Cmorley!Get information about each batch. DmorleyNumber of stages in migration. EmorleyRender migration plan.7                      ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E7      5 6 4         2 3 0 1 . / 7 8 = B A , - : ; > ) * + < ? @ C D E         9ƒNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm ‚ LmorleyType of batch. MmorleyAddition of any type of data. NmorleyAddition of code. Omorley*Several joined actions of different types. Pmorley`No information to chooseType about batching. This means that the given action does not contain  . QmorleyXPuts all data updates in one batch, and all lambdas in separate batches, one per batch.’The reason for such behaviour is that in production contracts amount of changed data (be it in contract initialization or contract upgrade) is small, while stored entrypoints are huge and addition of even one entrypoint often barely fits into gas limit.)morley Similar to nub:, counts number of invocations and attaches to text entry.nubCounting ["a", "b", "a"]["a (x2)", "b"] H I J K L M N O P Q L M N O P H I J K Q„None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm §Ü*morleyĄTraverse entry points and add parameter building step (which describes necessity to wrap parameter into some constructor of the given datatype) to all parameters described within given code.+morley*Add corresponding parameter building step.MFirst argument is accumulator for Michelson description of the building step. UmorleyConstraint for ,. VmorleyPick a type documentation from  . Xmorley%Describes argument of an entry point. Zmorley"Argument of the entry point. Pass  if no argument is required. [morleyiDescribes a way to lift an entry point argument into full parameter which can be passed to the contract.vSteps are supposed to be applied in the order in which they are given. E.g. suppose that an entry point is called as Run (Service1 arg)5; then the first step should describe wrapping into Service1A constructor, and the second step should be about wrapping into Run constructor. \morley$Describes a parameter building step.SThis can be wrapping into (Haskell) constructor, or a more complex transformation. ^morley'Plain english description of this step. _morley+How to construct parameter in Haskell code. `morley4How to construct parameter working on raw Michelson.-morley_During incremental assembly of parameter building steps - current representation of parameter. amorleyDefault value for  b type argument. bmorley-Gathers information about single entry point.ńWe assume that entry points might be of different kinds, which is designated by phantom type parameter. For instance, you may want to have several groups of entry points corresponding to various parts of a contract - specifying different kindL type argument for each of those groups will allow you defining different T9 instances with appropriate custom descriptions for them. fmorleyDefault implementation of [ for entry points. hmorley5Go over contract code and update every occurrence of  XY documentation item, adding the given step to its "how to build parameter" description.,morley,Add necessary documentation to entry points. imorleyLike  ¢/, to be used for pattern-matching on parameter.}Modifies documentation accordingly. Including description of entrypoints' arguments, thus for them you will need to supply ž instance. jmorley Version of  i for tuples. U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j b c d e a f X Y Z [ V W \ ] ^ _ ` h g U j i…None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm ¬¬ rmorley,Check that contract documents its parameter. smorley8It's a common issue to forget to describe an entrypoint. tmorleyTests all properties. ¦ § Ø © Ŗ « ¬ ­ ® Æ ° ± ² ³ “ r s t t r s†None5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm öŽ+ umorley Signature of  userFailWith. vmorley$Prompt an error message saying that I! is not applicable for this type. wmorley Documentation for custom errors.,Mentions that entrypoint throws given error. ymorley(Mentions that contract uses given error. |morley/What should happen for this error to be raised. }morleyBrief version of  |R. This will appear along with the error when mentioned in entrypoint description.?By default, the first sentence of the full description is used. ~morley Error class.~By default this returns "unknown error" class; though you should provide explicit implementation in order to avoid a warning. morley(Clarification of error argument meaning.?Provide when it's not obvious, e.g. argument is not named with :!.NOTE: This should not; be an entire sentence, rather just the semantic backbone.Bad: * 9Error argument stands for the previous value of approval. Good: * the previous value of approval * Epair, first argument of which is one thing, and the second is another €morley=Error class on how the error should be handled by the client. morleyRNormal expected error. Examples: "insufficient balance", "wallet does not exist". ‚morleyaInvalid argument passed to entrypoint. Examples: your entrypoint accepts an enum represented as nat’T, and unknown value is provided. This includes more complex cases which involve multiple entrypoints. E.g. API provides iterator interface, middleware should care about using it hiding complex details and exposing a simpler API to user; then an attempt to request non-existing element would also correspond to an error from this class. ƒmorleyzUnexpected error. Most likely it means that there is a bug in the contract or the contract has been deployed incorrectly. „morley/It's possible to leave error class unspecified..morleyHow  †& is actually represented in Michelson. †morleyMaterial custom error.:Use this in pattern matches against error (e.g. in tests). Šmorley"Declares a custom error, defining error name - error argument relation.=If your error is supposed to carry no argument, then provide ().čNote that this relation is defined globally rather than on per-contract basis, so define errors accordingly. If your error has argument specific to your contract, call it such that error name reflects its belonging to this contract. ‹morley!Use this type as replacement for () when you really( want to leave error cause unspecified. Žmorley?Name of error as it appears in the corresponding section title. morley/What should happen for this error to be raised. morleyBrief version of  .This will appear along with the error when mentioned in entrypoint description. By default, the first sentence of the full description is used. ‘morley)How this error is represented in Haskell. ’morley Error class. “morley8Which definitions documentation for this error mentions. ”morley Haskell type representing error. •morleyConverts a Haskell error into Value representation. –morley Converts a Value into Haskell error. —morleyImplementation of  • via I. ˜morleyImplementation of  – via I./morley!Helper for managing descriptions. ™morley"Fail with the given Haskell value. šmorleyTFail, providing a reference to the place in the code where this function is called.Like >? in Haskell code, this instruction is for internal errors only.0morleyDemote error tag to term level. ›morleyFail with given custom error. œmorleySpecialization of  › for no-arg errors. morleyImplementation of  (of žA typeclass) for Haskell types which sole purpose is to be error. žmorley!This is to be included on top of Errors) section of the generated documentation. ŸmorleyImplementation of  • for custom errors.  morleyImplementation of  – for custom errors.This function is deprecated. ”morleyDerive  ” instance for given type.This will also forbid deriving IV instance for that type to avoid having multiple different Michelson representations. ¢morleyMFail with given error, picking argument for error from the top of the stack.:If your error constructor does not carry an argument, use  ™¤ function instead. Consider the following practice: once error datatype for your contract is defined, create a specialization of this function to the error type.This function is deprecated. „morley)This instance cannot be implemented, use  ” instance instead. «morleyIf  †{ constructor is not provided its argument, we assume that this is no-arg error and interpret the passed value as complete. ®morley"Use this for internal errors only.NormalF error scenarios should use the mechanism of custom errors, see below.. u v w x y z { | } ~  € „ ƒ  ‚ … † ‡ ˆ ‰ Š ‹ Œ  Ž   ‘ ’ “ ” • – — ˜ ™ š › œ  ž Ÿ   ” ¢. ” • – — ˜  Ž   ‘ ’ “  ‹ Œ ™ š Š † ‡ ˆ ‰ › … œ € „ ƒ  ‚ { | } ~  y z w x Ÿ   ¢ u v ” ž‡None5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befghkm (ž ŗmorleyeNewtype over void result type used in tests to distinguish successful void result from other errors.;Usage example: lExpectFailWith (== VoidResult roleMaster)`mThis error is special - it can contain arguments of different types depending on entrypoint which raises it. ½morleyvoid! type synonym as described in A1. æmorleyEntry point argument. ĄmorleyType of result reported via  . Įmorleyview! type synonym as described in A1.1morley(Various convenient instructions on maps.2morleySpecialized version of  . ÅmorleyInsert given element into map. ĘmorleyWInsert given element into map, ensuring that it does not overwrite any existing entry.=As first argument accepts container name (for error message). ĒmorleyDelete element from the map.3morleyuConstraint for duupX that combines kind-agnostic constraint for Lorentz (Haskell) types and for our typed Michelson.4morley"Kind-agnostic constraint for duupX ŚmorleyxAnalog of the FAIL macro in Michelson. Its usage is discouraged because it doesn't carry any information about failure. ķmorley[Custom Lorentz macro that drops element with given index (starting from 0) from the stack. īmorleyDuplicate the top of the stack n times.@For example, `cloneX @3` has type `a & s :-> a & a & a & a & s`. ļmorleyDUU+P# macro. For example, `duupX @3` is DUUUP¹, it puts the 3-rd (starting from 1) element to the top of the stack. Note that it is implemented differently for `n "d 2` and for `n > 2`. In the latter case it is implemented using  ,  ė and  čq. In the former case it uses specialized versions. There is also a minor difference with the implementation of `DUU*P` in Michelson. They implement DUUUUPÓ as `DIP 3 { DUP }; DIG 4`. We implement it as `DIP 3 { DUP }; DIG 3`. These are equivalent. Our version is supposedly cheaper, at least it should be packed more efficiently due to the way numbers are packed. šmorley Version of  BL which accepts number of elements on input stack which should be preserved.YYou can treat this macro as calling a Michelson function with given number of arguments. žmorleyInsert given element into set.!This is a separate function from  updateMap4 because stacks they operate with differ in length. ’morleyWInsert given element into set, ensuring that it does not overwrite any existing entry.)As first argument accepts container name.morley"Delete given element from the set.morleyPolymorphic version of  Į constructor.morley*Wrap internal representation of view into  Į itself. Į8 is part of public standard and should not change often.morleyUnwrap  Į" into its internal representation. Į8 is part of public standard and should not change often. morleyTurn  6 into actual  -.,This requires contracts lookup and may fail. morleyPush a value of contract type.Doing this via  ķH instruction is not possible, so we need to perform extra actions here. Aside from contract] value itself you will need to specify which error to throw in case this value is not valid.S ń ŗ » ¼ ½ ¾ æ Ą Į Ā Ć Ä Ē Ę Å Č É Ź Ė Ģ Ķ Ī Ļ Š Ń Ņ Ó Ō Õ Ö × Ų Ł Ś Ū Ü Ż Ž ß ą į ā ć ä å ę ē č é ź ė ģ ķ ī ļ š ń ņ ó ō õ ö ÷ ų ł ś ū ü ż ž ’   S ń Č É Ķ Ź Ė Ģ Ī Ó Ń Ņ Š Ļ Ō Ł × Ų Ö Õ Ś Ū Ü Ż Ž ß ą į ā ć ä å ę ē č é ź ė ģ ķ ī ļ š ö ÷ ō õ ü ż ś ū ń ņ ó ų ł ž Å ’ Ę Ē Į Ā Ć Ä ½ ¾ æ Ą ŗ » ¼   ˆNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm E~ $morley1Write down all sensisble constraints which given store satisfies and apply them to  constrained.This store should have  Õ and  ŅB fields in its immediate fields, no deep inspection is performed.%morley>This constraint can be used if a function needs to work with big6 store, but needs to know only about some field of it.&morley>This constraint can be used if a function needs to work with big: store, but needs to know only about some submap(s) of it.fIt can use all UStore operations for a particular name, key and value without knowing whole template.(morley Put an empty  ŲR onto the stack. This function is generally unsafe: if store template contains a  Ņ, the resulting  Ų3 is not immediately usable. If you are sure that  Ųn contains only submaps, feel free to just use the result of this function. Otherwise you must set all fields.-morleyKInsert a key-value pair, but fail if it will overwrite some existing entry./morleyLike toField , but for  Ų.This may fail only if  Ų9 was made up incorrectly during contract initialization.0morleyLike getField , but for  Ų.This may fail only if  Ų9 was made up incorrectly during contract initialization.1morleyLike setField , but for  Ų.2morleyRemove a field from  Ų, for internal purposes only.5morleyˆWhen you want to express a constraint like "given big store contains all elements present in given small concrete store", you can use $.Here store- is a big store, and we expect it to contain 6 entirely.7morley5 with store instantiated to 8.$%&'()*+,-./012()*+,-./012&%$'‰None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm r4;morley°Put this in the end of migration script to get a human-readable message about remaining diff which yet should be covered. Use of this function in migration is fully optional.This function is not part of  =’’ for the sake of proper error messages ordering, during development you probably want errors in migration script to be located earlier in code than errors about not fully covered diff (if you used to fix errors in the same order in which they appear).9morley Helper for GF which ensures that given store hasn't been (partially) migrated yet.<morleyDCast field or submap pretending that its value fits to the new type.\Useful when type of field, e.g. lambda or set of lambdas, is polymorphic over storage type.=morley&Get a field present in old version of  Ų.>morley}Add a field which was not present before. This covers one addition from the diff and any removals of field with given name.\This function cannot overwrite existing field with the same name, if this is necessary use A) which would declare removal explicitly.?morleymRemove a field which should not be present in new version of storage. This covers one removal from the diff.—In fact, this action could be performed automatically, but since removal is a destructive operation, being explicit about it seems like a good thing.@morley+Get and remove a field from old version of  Ų.4You probably want to use this more often than plain ?.Amorley.Remove field and write new one in place of it.$This is semantically equivalent to 7dip (migrateRemoveField label) >> migrateAddField label, but is cheaper.Bmorley_Modify field which should stay in new version of storage. This does not affect remaining diff.CmorleyDefine a migration atom.QIt will be named automatically according to the set of actions it performs (via  ds). This may be want you want for small sequences of actions, but for complex ones consider using D.. Names are used in rendering migration plan.Dmorley(Define a migration atom with given name.0Name will be used when rendering migration plan.Emorley Composition of migration blocks.FmorleyThis is @$ operator with priority higher than E.It allows you writing EmkUStoreBatchedMigration = muBlock $: do migrateAddField ...  --, muBlock $: do migrateRemoveField ... Alternatively, BlockArguments extension can be used.GmorleyGet the old version of storage.7This can be applied only in the beginning of migration.[In fact this function is not very useful, all required operations should be available for  .#, but leaving it here just in case.HmorleyThis version can be used in mkUStoreMultiMigration as the last migration block.ImorleyThis version can be used in  =.:;<=>?@ABCDEFGG:;<=>?@ABCDEFE2F7­None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm t O                      ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E H I J K L M N O P Q:;<=>?@ABCDEFGŠNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm Ė:morleyGeneric traversal for L and M.;morley"Convert generic value to internal  Ų representation.<morleyParse internal  Ų/ representation into generic Haskell value of  Ų", also returning unparsed entries.=morley<Convert generic value to a script filling the corresponding  Ų.Jmorley#Given template can be converted to  Ų value.Kmorley Ų( content represented as key-value pairs.LmorleyMake  Ų from separate big_map s and fields.Mmorley Decompose  Ų into separate big_map s and fields.Since this function needs to UNPACK content of UStore1 to actual keys and values, you have to provide  UnpackEnv..Along with resulting value, you get a list of UStoreV entries which were not recognized as belonging to any submap or field according to UStore*'s template - this should be empty unless UStore invariants were violated.Nmorley(Make migration script which initializes  Ų from scratch.Omorley Version of P for batched migrations.4Each field write will be placed to a separate batch.PmorleyFill  ŲC with entries from the given template as part of simple migration.7Sometimes you already have some fields initialized and N— does not suit, then in case if your UStore template is a nested structure you can use sub-templates to initialize the corresponding parts of UStore.For batched migrations see O.QmorleyLike M , but requires all entries from UStore to be recognized.>morley!Recursive template traversal for L.?morley!Recursive template traversal for M.@morley!Recursive template traversal for N.RmorleyCase of  Ņ.SmorleyCase of  Õ.ZmorleyCase of nested template.JKLMNOPQKJLMQNPO‹None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm øAmorley5Generic traversal for conversion between ADT sum and n.^morley1Entry points template derived from given ADT sum._morleyConstraint required by w.`morley#Make up a "case" over entry points.BmorleyPattern-match on given UParam entries.cYou have to provide all case branches and a fallback action on case when entry point is not found.lThis function is unsafe because it does not make sure at type-level that entry points' names do not repeat.amorley>An action invoked when user-provided entry point is not found.bmorley%Implementations of some entry points.,Note that this thing inherits properties of O, e.g. you can Data.Vinyl.Core.rappendY implementations for two entry point sets when assembling scattered parts of a contract.Cmorley#Wrapper for a single "case" branch.fmorley"This class is needed to implement g.gmorleyTurn na into a Haskell value. Since we don't know its type in compile time, we have to erase it using hu. The user of this function can require arbitrary constraint to hold (depending on how they want to use the result).hmorleyBThis type can store any value that satisfies a certain constraint.jmorley>Ensure that given entry points do no contain duplicated names.kmorley-Get type of entry point argument by its name.lmorleyHomomorphic version of n, forgets the exact interface.mmorleyPseudo value for n type variable.nmorleyqEncapsulates parameter for one of entry points. It keeps entry point name and corresponding argument serialized.dIn Haskell world, we keep an invariant of that contained value relates to one of entry points from entries list.pmorley6A convenient alias for type-level name-something pair.qmorleyHAn entry point is described by two types: its name and type of argument.rmorley Construct a n safely.smorley-Helper instruction which extracts content of n.tmorleyDefault implementation for a, simply reports an error.umorleyPattern-match on given UParam entries.cYou have to provide all case branches and a fallback action on case when entry point is not found.vmorleyLike u(, but accepts a tuple of clauses, not a O.wmorleyMake up n from ADT sum.'Entry points template will consist of '(constructorName, constructorFieldType)@ pairs. Each constructor is expected to have exactly one field.xmorley:Note that calling given entrypoints involves constructing n.morleyAllows casts only between l and n.^_`abcedfghijklmnopqrstuvwxnoqprhifgmlbaced`uvtkjw_^xsŒNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm ¼5”morley9Remembers parameters it was called with, last goes first.””None5!"#$%&'*,-.012456789;=>?@ACHMNPSUVX_`befgkm é•morleyIConcise way to write down constraints with expected content of a storage.Use it like follows: ztype StorageConstraint = StorageContains [ "fieldInt" := Int , "fieldNat" := Nat , "balances" := Address ~> Int ] –morley2Indicates a submap with given key and value types.—morley*Provides operations on fields for storage.™morley/Datatype containing the full implementation of   typeclass.ŌWe use this grouping because in most cases implementation will be chosen among the default ones, and initializing all methods at once is simpler and more consistent. (One can say that we are trying to emulate  DerivingVia extension.) morley*Provides operations on fields for storage.¢morley/Datatype containing the full implementation of   typeclass.ąWe use this grouping because in most cases implementation will be chosen among the default ones, and initializing all methods at once is simpler and more consistent. (One can say that we are trying to emulate benefits of  DerivingVia extension.)¦morleyPick storage field.§morley:Get storage field, preserving the storage itself on stack.ØmorleyUpdate storage field.©morley Check value presence in storage.ŖmorleyGet value in storage.«morleyUpdate a value in storage.¬morleyDelete a value in storage.­morleyAdd a value in storage.®morleyJAdd a value in storage, but fail if it will overwrite some existing entry.ÆmorleyImplementation of  0 for case of datatype keeping a pack of fields.°morleyImplementation of  + for a data type which has an instance of  = inside. For instance, it can be used for top-level storage.±morleyImplementation of —+ for a data type which has an instance of —= inside. For instance, it can be used for top-level storage.²morleyPretend that given ™0 implementation is made up for submap with name  desiredNameD, not its actual name. Logic of the implementation remains the same.AUse case: imagine that your code requires access to submap named X,, but in your storage that submap is called Y.. Then you implement the instance which makes X refer to Y: oinstance StoreHasSubmap Store X Key Value where storeSubmapOps = storeSubmapOpsReferTo #Y storeSubmapOpsForY ³morleyPretend that given ™1 implementation is made up for submap with name  desiredNameE, not its actual name. Logic of the implementation remains the same. See also ².“morley.Chain two implementations of field operations.eSuits for a case when your store does not contain its fields directly rather has a nested structure.µmorley5Chain implementations of field and submap operations.¶morley%< can be used as standalone key-value storage if very needed.·morley:\ can be used as standalone key-value storage, name of submap is not accounted in this case.!•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ! ”¢£¤„—˜™š›œžŸ–•¦§Ø©Ŗ«¬­®Æ°±³²“µ–9 ŽNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm ėņ®None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm ķČ4 æ Ą Į Ā Ć Ģ Ķ Ī Š Ń Ņ Ó Ō Õ Ö × Ų ’     2 7 = A B$%&)*+,-./01=>?@ABGJLMNQ4 Ų Õ Ö × Ņ Ó Ō Š Ń Ģ Ķ Ī Ć Ā Į Ą)*+,-./01&%$ ’ JLMQN     2 B A 7 =G=>?@AB æNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm »morleyContract storage with big_map.HDue to Michelson constraints it is the only possible layout containing big_map.æmorley1Write down all sensisble constraints which given store satisfies and apply them to  constrained.This store should have ČD datatype in its immediate fields, no deep inspection is performed.Ąmorley>This constraint can be used if a function needs to work with big8 store, but needs to know only about some part(s) of it.eIt can use all Store operations for a particular name, key and value without knowing whole template.Dmorley\Prepend a constructor name with a lower-case character so that you could make a label with OverloadedLabels% extension matching resulting thing.Emorley9Get map signature from the constructor with a given name.FmorleyType arguments of Č.Gmorley Number of datatype constructors.HmorleyDPosition of a constructor in the corresponding datatype declaration.ČmorleyDescribes one virtual big map.ÉmorleyGathers multple :s under one object.ˆType argument of this datatype stands for a "map template" - a datatype with multiple constructors, each containing an object of type Č% and corresponding to single virtual :s. It's also possible to parameterize it with a larger type which is a sum of types satisfying the above property.Inside it keeps only one :* thus not violating Michelson limitations.See examples below.ŠmorleyKInsert a key-value pair, but fail if it will overwrite some existing entry.ŅmorleyUnpack » into a pair.ÓmorleyPack a pair into ».×morleyKInsert a key-value pair, but fail if it will overwrite some existing entry.ŁmorleyLift a key-value pair to É.Further you can use  instance of Store to make up large stores.ŪmorleyGet a value from store by key.SIt expects map to be consistent, otherwise call to this function fails with error."ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪ"ÉŹĖČĒĘĢĶĪĻŠŃÅÄĆĀĮĄæ»¼½¾ŅÓŌÕÖ×ŲŁŚŪŗNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm ū÷morleyPredicate for if ... then .. else ...] construction, defines a kind of operation applied to the top elements of the current stack.morley$Aliases for '(#)' used by do-blocks.morleyDefines semantics of if ... then ... else ... construction.&÷üūųłśżž’÷üūųłśżž’&None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm /“ morleyXThis is a bidirectional map with correspondence between numeric and textual error tags. morley6Find all textual error tags that are used in typical FAILWITHA patterns within given instruction. Map them to natural numbers. morley#Add more error tags to an existing  ś. It is useful when your contract consists of multiple parts (e. g. in case of contract upgrade), you have existing map for some part and want to add tags from another part to it. You can pass empty map as existing one if you just want to build  ! from a set of textual tags. See  . morleyBuild   from a set of textual tags. morleyFor each typical É’ that uses a string to represent error tag this function changes error tag to be a number using the supplied conversion map. It assumes that supplied map contains all such strings (and will error out if it does not). It will always be the case if you gather all error tags using   and build   from them using  .morleyĪThis function implements the simplest scenario of using this module's functionality: 1. Gather all error tags from a single instruction. 2. Turn them into error conversion map. 3. Apply this conversion.morley<If you apply numeric error representation in your contract,  –’" will stop working because it doesn't know about this transformation. This function takes this transformation into account. If a number is used as a tag, but it is not found in the passed map, we conservatively preserve that number (because this whole approach is rather a heuristic).          ‘None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm 3ImorleyPContract initiator should be contract admin in order to perform this operation.ÆNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm 4Ł’š 0/   &21"#$%*)3678<;:>?@ABCDELKONMĘÉnķ÷rz€±“·»ÄÅÉó-./0UVWXYZ[\]^6789:;<=EFGHIJKLMNOPQRSTUVWXYZ[\]^_copqrstuvwx{€‚ƒ:;<=>?@ABIJKLMNOPQÉŹö÷ųłśūž’    Į Ā Ć Ä Å Ę Ē Č É Ź Ė Ģ Ķ Ī Ļ Ń Š Ņ Ó Ō ń ņ ó ō õ ö ÷ ų ł ś ū ü ż ž ’                    ! " # $ % & ' ( ) * + / 0 1 2 3 4 5 6 7 8 9 : ; J K L M w x y z {  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ  Ž   ‘ ’ “ ” • – É Ź Ö × Ų Ł Ś Ū Ü į ā ć ä å ę ē č é ź ė ģ ķ ī ļ š ń ņ ó ō õ ö ÷ ų ł ś ū ü ż ž ’                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D H I J Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i  Ž   ‘ ’ “ ” • – — ˜ ™ š › œ  ž Ÿ   ” ¢ £ ¤ ø ¹ ŗ » ¼ ½ æ Ą Į Ā Ć Ģ Ķ Ī Š Ń Ņ Ó Ō Õ Ö × Ų ’     2 7 = A B U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j u v w x y z { | } ~  € „ ƒ  ‚ … † ‡ ˆ ‰ Š ‹ Œ  Ž   ‘ ’ “ ” • – — ˜ ™ š › œ  ž Ÿ   ” ¢ ŗ » ¼ ½ ¾ æ Ą Į Ā Ć Ä Å Ę Ē Č É Ź Ė Ģ Ķ Ī Ļ Š Ń Ņ Ó Ō Õ Ö × Ų Ł Ś Ū Ü Ż Ž ß ą į ā ć ä å ę ē č é ź ė ģ ķ ī ļ š ń ņ ó ō õ ö ÷ ų ł ś ū ü ż ž ’   $%&)*+,-./01=>?@ABGJLMNQ^_`abcedfghijklmnopqrstuvwx•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ÷üūųłśżž’     ’š 0/   &21"#$%*)3678<;:>?@ABCDELKONMĘÉnķ÷rz€±“·»ÄÅÉó-./0UVWXYZ[\]^6789:;<=EFGHIJKLMNOPQRSTUVWXYZ[\]^_copqrstuvwx{€‚ƒ:;<=>?@ABIJKLMNOPQÉŹö÷ųłśūž’    Į Ā Ć Ä Å Ę Ē Č É Ź Ė Ģ Ķ Ī Ļ Ń Š Ņ Ó Ō ń ņ ó ō õ ö ÷ ų ł ś ū ü ż ž ’                    ! " # $ % & ' ( ) * + / 0 1 2 3 4 5 6 7 8 9 : ; J K L M w x y z {  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ  Ž   ‘ ’ “ ” • – É Ź Ö × Ų Ł Ś Ū Ü į ā ć ä å ę ē č é ź ė ģ ķ ī ļ š ń ņ ó ō õ ö ÷ ų ł ś ū ü ż ž ’                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D H I J Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i  Ž   ‘ ’ “ ” • – — ˜ ™ š › œ  ž Ÿ   ” ¢ £ ¤ ø ¹ ŗ » ¼ ½ æ Ą Į Ā Ć Ģ Ķ Ī Š Ń Ņ Ó Ō Õ Ö × Ų ’     2 7 = A B U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j u v w x y z { | } ~  € „ ƒ  ‚ … † ‡ ˆ ‰ Š ‹ Œ  Ž   ‘ ’ “ ” • – — ˜ ™ š › œ  ž Ÿ   ” ¢ ŗ » ¼ ½ ¾ æ Ą Į Ā Ć Ä Å Ę Ē Č É Ź Ė Ģ Ķ Ī Ļ Š Ń Ņ Ó Ō Õ Ö × Ų Ł Ś Ū Ü Ż Ž ß ą į ā ć ä å ę ē č é ź ė ģ ķ ī ļ š ń ņ ó ō õ ö ÷ ų ł ś ū ü ż ž ’   $%&)*+,-./01=>?@ABGJLMNQ^_`abcedfghijklmnopqrstuvwx•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ÷üūųłśżž’     ’None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm `å morleyError type for ! function.morleyImport contract and use to create test trees. Both versions of contract are passed to the callback function (untyped and typed).øIf contract's import fails, a tree with single failing test will be generated (so test tree will likely be generated unexceptionally, but a failing result will notify about problem).morleyLike  but for Lorentz types.morleyLike $ but supplies only untyped contract.morleyLike " but supplies only typed contract.morley{Import contract and use it in the spec. Both versions of contract are passed to the callback function (untyped and typed).²If contract's import fails, a spec with single failing expectation will be generated (so tests will likely run unexceptionally, but a failing result will notify about problem).morleyLike , but for Lorentz types.morley A version of = which passes only the typed representation of the contract.!morley'Import contract from a given file path.²This function reads file, parses and type checks a contract. Within the typechecking we assume that no contracts are originated, otherwise a type checking error will be caused.This function may throw J and . !" !"°None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm cC9’“”•æĄĮĀĆÄÖ×Ų   N z { | Š ‹ Œ  – — ˜ ™ š ›  Ÿ ¢ £ „ ¦ § Ø © Ŗ « ¬ ­ ® Æ ­ ® “"9"  z { |  Œ Š ‹ – — ˜ ™ š › Ÿ  ¢ £ ¬ ­ „ ¦ § Ø © « Ŗ ® ÆæĄĮĀĆÄ ’“”• ® “ ­ NÖ×Ų“None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm kKmorley getRareT k generates į! producing anything big once per  1 / (k + 1) invocation.Lmorley getRareT k generates ó! producing anything big once per  1 / (k + 1) invocation.#Useful to avoid exponensial growth.'morley&Run given generator deterministically.''”None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm DLmorleyLike  originate#, but for typed contract and value.MmorleyLike  originate, but for Lorentz contracts.Nmorley<Originate a contract with empty balance and default storage.Omorley Similar to  s5, for typed values. Note that it works with untyped óģ and does not check that entrypoint with given name is present and has the expected type. Passed value must correspond to the entrypoint argument type, not the parameter type of the contract (and must be unit for implicit accounts).Pmorley Similar to  s, for Lorentz values.QmorleyLegacy version of R¬ function. Calls default entrypoint of a contract assuming its argument is the same as contract parameter (which is equivalent to absence of explicit default entrypoint).HThis function is DEPRECATED and exists only for backwards compatibility.Rmorley]Call an entrypoint of a contract without caring about the source address. Transfers 0 mutez.SmorleyR for default entrypoint.Tmorley Similar to expectStorageUpdate, for Lorentz values.UmorleyLike  expectBalance, for Lorentz values.Vmorley Similar to expectStorageConst, for typed stuff.Wmorley Similar to expectStorageConst, for Lorentz values.XmorleyOExpect that interpretation of contract with given address ended with [FAILED].YmorleyExpect contract to fail with FAILWITHF instruction and provided value to match against the given predicate.Zmorley)Expect contract to fail with given error.[morley Version of Z= for the case when numeric representation of errors is used.\morley#Expect contract to fail with given  CustomError.]morley Version of \= for the case when numeric representation of errors is used.^morleySpecialization of \ for non-arg error case._morley Version of ^= for the case when numeric representation of errors is used.`morley Version of T* specialized to "consumer" contract (see ±²).amorley8Assuming that "consumer" contract receives a value from View5, expect this view return value to be the given one.ŻDespite consumer stores parameters it was called with in reversed order, this function cares about it, so you should provide a list of expected values in the same order in which the corresponding events were happenning.CæĄĮĀĆÄ         €  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ  – — š ›  ž Ÿ   ” ¢ £ ¤ „ ¦ § ¬ ­LMNOPQRSTUVWXYZ[\]^_`aCæĄĮĀĆÄ        LOV  Œ ‹ Š €  ‚ ƒ „ … † ‡ ˆ ‰ – —MNPQRS š › Ÿ  ž   ” ¢ £ ¤ ¬ ­ „ ¦ §TUWXYZ[\]^_`a³None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm “2S’“”•æĄĮĀĆÄÖ×Ų          N z { | €  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ  – — š ›  ž Ÿ   ” ¢ £ ¤ „ ¦ § ¬ ­ ­ ® t”MNPQRSTUWXYZ[\]^_`aS  z { |  Œ Š ‹ €  ‚ ƒ „ … † ‡ ˆ ‰ – —MNPQRS š › Ÿ  ž   ” ¢ £ ¤ ¬ ­ „ ¦ §TUWXYZ[\]^_`aæĄĮĀĆÄ         ® t ­’“”• NÖ×Ų”M“µ¶“·ø“µ¹“ŗ»“µ¼“µ½“µ¾“µæ“µĄ“ĮĀĆÄÅĆÄĘ“Ē™“ČÉ“µŹ“µĖĆĢĶĪĻŠ“ŃŅ“ÓŌ“ÕÖĆĢדČŲ“ČŁĆĢŚ“ÓŪ“ÓÜĆĢŻ“ÕŽ“Õß“Čą“Čį“Čā“Čćäåęēčą“µéźėģ“ķī“ļš“Čń“ņó“ņó“ōõ“ōö“ō÷“ųł“Įś“Įū“µü“µżž’ž’ž’ź          ¶ ! " # $ %&'(&'(&)*&)+&),&-.&-/&-0&-1223456677889:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZZ[\]^_`abcdefghijklmnopq.rstuvwxyz{|y}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČČ––ÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’       !""#$%&'()*+,--../0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒ‚ƒų „…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’      ! " # $ % &!'!'!(!)!*!+!,!-!.!/!0!1!2!3!4!5!6 7 8 9 : ; < = > ? @ A B C D E F GHIJKLMNOPQRSTUVWXYZ[\]^_`ab"c"d"e"f"g"h"i"j"k"l"m"n"o p p q r s t u v w x y z { | } ~  €  ‚ ƒ „ … † ‡ ˆ#‰$Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤%„%¦%§%Ø%©%Ŗ%«%¬%­%®%Æ%°%±%²%³%“%µ%¶%·%ø%¹%ŗ%»%¼%½%¾%æ%Ą%Į%Ā&Ć&Ć&Ä&Å&Ę&Ę&Ē&Č&É&Ź&Ė&Ģ&Ķ&Ī&Ļ&Š&Ń&Ņ&Ó&Ō&Õ&Ö&×&Ų&Ł&Ś&Ū&Ü&Ż&Ž&ß&ą&į&ā&ć'Ć'Ć'Ä'Å'Ę'Ę'Ē'É'Ź'Ė'Ģ'Ķ'Ī'Ļ'Š'Ń'Ņ'Ó'Ō'Õ'Ö'Ų'Ł'Ś'Ü'Ż'Ž'ß'Ū'ą'į'ā'ć(Ć(Ć(Ä(Å(Ę(Ę(Ē(É(Ź(Ė(Ģ(Ķ(Ī(Ļ(Š(Ń(Ņ(Ó(ä(Ō(Õ(Ö(×(Ų(Ł(Ś(å(Ü(Ż(Ž(ß(Ū(ą(į(ā(ć)ę)ę)ē)č)é)ź)ė)ģ)Ć)ķ)ī)ļ)š)Å)Ę)ń)ņ)ó)É)Ź)Ī)Ļ)Š)Ų)Ń)Ņ)Ó)Ō)Õ)Ö)ō)õ)ö)÷)ų)ł)ś)Ł)Ś)Ü)ū)ü)Ż)Ž)ć)ż)ž)’)))ß)Ū)ą)į)ā)))))))) * * * * * ******************* *!*"*#*$*%*&*'*(*)***+*,*-*.*/*0*1*2*3*4*5*6*7*8*9*:*;*<*=*>*?*@*A*B*C*D*E*F+G+H+I+J+K+L+M+N+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,n,o,o,p,q,r,s,t,u,v,w,x,y,z,{,|,},~,,€,,‚,ƒ,„,…,†,‡,ˆ,‰,Š,‹,Œ,,Ž,,,‘,’,“,”,•,–,—-˜-˜-™-š-›-œ--ž-Ÿ- -”-¢-£-¤-„-¦-§-Ø-©-Ŗ-«-¬-­-®-Æ-°-±-²-³-“-µ-¶-·-ø-¹-ŗ-»-¼-½-¾-æ-Ą-Į-Ā-Ć-Ä-Å-Ę-Ē-Č-É-Ź-Ė-Ģ-Ķ-Ī-Ļ-Š-Ń-Ņ-Ó-Ō-Õ-Ö-×-Ų-Ł-Ś-Ū-Ü-Ż-Ž-ß-ą-į-ā-ć-ä-å-ę-ē-č-é-ź-ė-ģ-ķ-ī-ļ-š-ń-ņ-ó-ō-õ-ö-÷-ų-ł-ś-ū-ü-ż-ž-’---------- - - - - --..s.////////////0111 2!3"3#3$3%3&3'3(3)3*3+3,3-3.3/303132333435363738393:3;<=>?@ABC4D4D4E4F4G4H4I4J4K4L4M4N4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4\4]4^5_5`5a5b6c6c6d6e6f6g6h6i6j6k6l6m6n6o6p6q6r6s6t6u6v6w6x6y6z6{6|6}6}6~66v6€66‚6ƒ6„6…6†6ę6‡6ˆ6‰6Š6‹6Œ66Ž666‘6’6“6”6•6–6—6˜6™6š6›6œ66ž6Ÿ6 6”7¢7£7¤7„7¦7§7Ø7©7Ŗ7«7¬7­7®8Æ8°8±8²8p8³8“8µ8¶8·8ø8¹8ŗ8»8¼8½8¾8æ8Ą8Į8Ā8Ć8Ä8Å8Ę8Ē8Č8É8É8Ź8Ė8Ģ8Ķ8Ī8Ļ8Ļ8Š8Ń8Ń8Ņ8Ó8Ō8Õ8Ö8×8Ų8Ł8Ś8Ū8Ü8Ż8Ž8ß8ą8į8ā8ć8ä8å8ę8ē8č8é8ź8ė8Š8‹8ģ8ķ8ī8ļ9š9ń9ņ9ó9ō9õ9ö9÷9ų9ł9ś9ū9ü9ż9ž9’9999999999 9 9 9 9 9999999999999999999 9!9"9#9$9%9&9'9(9):*:+:,:-:.:/:0:1:2:3:4:5:6:7:8:9::::;:<:=:>:?:@:A:B:C:D:E:F:G:H:I:J:K:L:M:N:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:\:]:^:_:`:a:b:c:d:e:f:g:h:i:j:k:l:m:n:o:p:q:r:s:t:u:v:w:x:y:z:{;|;|;};~;;€;;;‚;ƒ;ƒ;„;„;…;†;‡;‡;ˆ;ˆ;‰;Š;‹;Œ;Œ;;Ž;;;‘;‘;’;“;”;•;–;—;˜;™;š;›;œ;;ž;Ÿ; ;”;¢;£;¤;„;¦;§;Ø;©;Ŗ;«;¬;­;­;®;®;Æ;°;±;²;³;³;“;“;µ;¶;·;ø;¹;ŗ;»;¼;½;¾;æ;Ą;Į;Ā;Ć;Ä<Å<Å<Ę<Ē<Č<s<É<Ź<Ė<Ģ< < <Ķ<.<.<<<<Ī<Ļ<Š<Ń<Ņ<Ó<Ō<Õ<Ö<”< <¢<£<¤<„<¦<§<Ø<©<Ŗ<«<®<Æ<°<±<²<³<“<µ<¶<·<ø<¹<ŗ<»<¼<½<¾<æ<Ą<Į<Ā<Ć<Ä<Å<Ę<Ē<Č<É<Ź<×<Ė<Ģ<Ķ<Ī<Ļ<Š<Ń<Ņ<Ó<Ō<Õ<Ö<×<Ų<Ł<Ś<Ū<Ü<Ż<Ž<ß<ą<į<ā<ć<ä<å<ę<ē<č<é<ź<ė<ģ<ķ<ī<ļ<š<ń<ņ<ó<Ų<Ł<Ś<Ū<Ü<Ż<Ž<Ž<­<¬<ß<ą<į<ā<@<?<ć<ä<å<ę<T<U<W<ē<č<é<ź<Y<ė=ģ=ķ=ī=ļ=X=š>ń>°>²>?ņ?ņ?ó?ō?õ?õ?ö?÷?ų?ł?ś?ū?ü?ż?ž?’??@@@@@@@@ @ @ @ @ @ @ @@@g@@@@@@@@@@@@@@@@@@@ @!@"@#@$@%@&@'@(@)@*@+@,@-@.@/@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@XAYAZA[A\A]A]A^A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}A~AA€AA‚AƒA„A…A†A‡AˆA‰AŠA‹AŒAAŽBBB‘C’C“C”C”C•C–C—C˜C™CšC›CœCCžCŸC C”C¢C£C¤C„C¦C§CØC©DŖD«D¬D­D®DÆD°D±D²D³D“DµD¶D·DøD¹DŗD»E¼E½E¾EæEĄEĄEĮEĮEĀEĆEÄEÅEĘEĒEČEÉEŹEĖEĖEĢEĶEĪEĻEŠEŃEŅEÓEŌEÕEÖE×EŲEŁEŚEŪEÜEŻEŽEßEąEįEāEćEäEåEęEēEčEéEźEėEģEķEīEļEšEńEņEóEōEõEöE÷EųEłEśEūEüEżEžE’EEEEEEEEEE E F F F GGGGGGGGGGGGGGGGGGGGGG G!G"G#G$G%G&G'G(H)H*H+H,H-H.H/H0H1H1H2H3H4H5H6H7H8H9H:H;H<H=H>H?H@HAHBHCHDHEHFHGHHHIHJHKHLHMHNHOHPHQHRHSHTHUHVHWHXHYHZI[I[I\I]I^I_I`IaIbIcIdIeIfIgIhIiJjJkJlJmJnJoJpJqJrJsJtJuJvJwJxJyJzJ{J|J}J~JJ€JJ‚JƒJ„J…J†J‡JˆJ‰JŠJ‹JŒKKŽLMM‘M’M“M”M•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°O±O²O³O³O“OµO¶O·OøO¹OŗO»O¼O½O¾OæOĄOĮOĀOĆOÄOÄOÅOĘOĒOČOÉOŹOĖOĢOĶOĪOĻOŠOŃOŅOÓOŌOÕOÖO×OŲOŁOŚOŪOÜOŻOŽOßOąOįPāPćPäPåPęQēQčQéQźQėQģQķQīQļQšQńQņQóQōQõQöQ÷QųQłQśQūQüQżQžQ’Q Q Q Q Q Q Q Q Q Q QŠQ Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q !Q "Q #Q $Q %Q &Q 'Q (Q )Q *Q +Q ,Q -Q .Q /Q 0Q 1Q 2Q 3Q 4Q 5Q 6Q 7Q 8Q 9Q :Q ;Q <Q =Q >Q ?Q @Q AQ BR CR CR DR ER FR FR GR HR IR JR KR LR MR NR OR PR QS RS RS SS TS US VS WS XS YS ZT [T \T ]T ^T _T `T aT bT cT dT eT fU gU hU iU jU kU lV mV nV oV pV qW rW sW tW uW vW wW xW yW zW {W |X }X ~Y Y €Y Z ‚Z ƒZ „Z …Z †[ ‡[ ˆ[ ‰[ Š\ ‹\ Œ\ ] Ž] ] ] ‘] ’] “] ”^ •^ –_ —_ —_ ˜_ ™_ š_ ›_ œ_ _ ž` Ÿ`  ` ”` ¢` £a ¤a „a „a ¦a §a Øa ©a Ŗa «a ¬a ­a ®b Æb Æb °b ±b ²b ³b “b µb ¶b ·b øb ¹b ŗb »b ¼b ½c ¾c æc æc Ąc Įc Āc Āc Ćc Ćc Äc Åc Åc Ęc Ēc Ēc Čc Éc Źc Ėc Ģc Ķc Īc Ļc Šc Ńc Ņc Óc Ōc Õc Öc ×c Ųc Ųc Łc Śc Ūc Üc Żc Žc ßc ąc įc āc ćc äc åc ęc ēc čc éc źc ėc ģc ķc īc ļc šc ńc ņc óc ōc õc öc ÷c ųc łc śd ūd üd żd že ’e ’e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e e !e "e #e $e %e &e 'f (f )f *f +f ,f -g .g /g 0g 1g 2g 3g 4g 5g 6g 7g 8g 9g :g ;g <g =g >g ?g @g Ag Bg Cg Dg Eg Fg !g Gg Hg Ig Jg Kg Lg Mg Ng Og Pg Qg Rg Sg Tg Ug Vg Wg Xg Yg Zg [g \g ]h ^h _h `h ah bi ci ci di ei fi gi hi ii ji ki lj mj nj oj pj qj rj sj tj uj vj wj xj yj zj {j |j }j ~j j €j j ‚j ƒj „j …j †j ‡j ˆj ‰j Šj ‹j Œj j Žj j j ‘j ’j “j ”j •j –j —j ˜j ™j šj ›j œk k žk Ÿk  k ”k ¢k £k ¤k „k ¦k §k Øk ©k Ŗk «k ¬k ­k ®k Æk °k ±k ²k ³k “k µk ¶l ·l øl øl ¹l ŗ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© Ś Ū Ü Ż Ž ß ą ą į ā ć ä å ę ē č é ź ė ģ ķ ī ļ š ń ņ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 n n n n o o !p "p "p #p $p %p &p 'p (q )q *qqqsqÅq +q ,q -q .q /q 0q 1q 2q 3q 4q 5q 6q 7q 8q 9q :q ;q <q =q >q ?q @q Ar Br Cr Dr Er Fr Gr Hr Ir Jr Kr Ls Ms Ns Os Ps Qs Rs Ss Ts Us Vs Ws Xs Ys Zs [s \s ]s ^s _s `s as bs cs ds es fs gs hs is js ks lt mt nt ot pt qt rt st tt ut vt wt xt yu zu {u |u }u ~v v €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 Ā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’xx Ūxõx Üx Żx Žx ßx ąx įx āx ćx äx åx ęy ēy čy éy źy ėy ģy ķy īy ļz šz €z ńz { ņ{ ó  ō  õ ö  ÷ ų ł ś ū ü ż ž ’         | | | | | | | | | | | | | | | | | | | | | | | !| "| #| $| %| &| '| (  )  * +  ,  ,  -  .  /  /  0  1 2 3 4 5 6 7 8 9 : ; < = > ?} @} @} A} B} C} D} E} F} G} H} I} J} K} L} M} N} O} P~ Q~ R~ S~ T~ U~ V~ W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k i l m n o p p q r s t u v w x y z { | } ~  €  ‚ ƒ „€ …€ †€ ‡€ ˆ€ ‰€ Š€ ‹€ Œ€ € Ž€ € € ‘€ ’€ “€ ” • – — ˜ ™‚ š‚ š‚ ›‚ œ‚ ‚ ž‚ ž‚ Ÿ‚  ‚ ”‚ ¢‚ £‚ ¤‚ „‚ ¦‚ §‚ ؂ ؂ ©‚ Ŗ‚ «‚ ¬‚ ­‚ ®‚ Ƃ °‚ ±‚ ²‚ ³‚ “‚ µ‚ ¶‚ ·‚ ø‚ ¹‚ ŗ‚ »‚ ¼‚ ½‚ ½‚ ¾‚ æ‚ æ‚ Ą‚ Į‚ Ā‚ Ā‚ Ƃ Ƃ Ă ł ʂ Ē‚ Ȃ ɂ Ź‚ Ė‚ Ģ‚ Ķ‚ Ī‚ Ļ‚ Š‚ т Ņ‚ ӂ Ō‚ Ղ ւ ׃ Ųƒ Ųƒ Łƒ Śƒ Ūƒ ܃ Żƒ Žƒ ߃ ąƒ įƒ āƒ ć„ ä„ å„ ę„ ē„ ē„ č„ é„ ź„ ź„ ė„ ģ„ ķ„ ī„ ļ„ ļ„ š„ ń„ ņ„ ó„ ō„ õ„ ö„ ÷„ ų„ ł„ ś„ ū„ ü„ ż… ž… ’… † † † † † † † † † † † † † † † † † † † † † † † † † † † † † † † † † † † † † !† "† #† $† %† &† '† († )† *†Ą† +† ,† -† .† /† 0† 1† 2† 3† 4† 5† 6† 7† 8† 9† :† ;† <† =† >† ?† @‡ A‡ A‡ B‡ C‡ C‡ D‡ E‡ F‡ 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‡ {‡ |‡ }‡ ~‡ ‡ €‡ ‡ ‚‡ ƒ‡ „‡ …‡ †‡ ‡‡ ˆ‡ ‰‡ Š‡ ‹‡ Œ‡ ‡ Ž‡ ‡ ‡ ‘‡ ’‡ “‡ ”‡ •‡ –‡ —‡ ˜‡ ™‡ š‡ ›‡ œ‡ ‡ ž‡ Ÿ‡  ‡ ”‡ ¢‡ £‡ ¤‡ „‡ ¦‡ §ˆ ؈ ©ˆ Ŗˆ «ˆ ¬ˆ ­ˆ ®ˆ ƈ °ˆ ±ˆ ²ˆ ³ˆ “ˆ µˆ ¶ˆ ·ˆ ˜ˆ øˆ ¹ˆ ŗˆ »ˆ ™‰ ¼‰ ½‰ ¾‰ æ‰ Ą‰ Į‰ Ā‰ Ɖ ĉ ʼn ʉ Ē‰ ȉ ɉ Ź‰ ĖŠ ĢŠ ĶŠ ĪŠ ĻŠ ŠŠ ъ ŅŠ ӊ ŌŠ Պ ֊ ׊ ŲŠ ŁŠ ŚŠ ŪŠ ܊ ŻŠ ˜Š ™‹ Ž‹ ߋ ą‹ į‹ ā‹ ć‹ ä‹ ‹ å‹ ę‹ ē‹ ē‹ č‹ é‹ ź‹ ė‹ ģ‹ ķ‹ ī‹ ļ‹ š‹ ń‹ ņ‹ ó‹ ō‹ õ‹ ö‹ ÷‹ ų‹ ł‹ ś‹ ū‹ ü‹ ż‹ ž‹ ’‹‹‹‹‹‹‹‹‹‹ ‹ ‹ ‹ ‹ ‹‹‹‹Œ² !"#$%&'()*+,-./012Ž3Ž4566789:;<=>?@ABC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ijklmnopqrstuvwxyz{|}~€‚‘ƒ‘ ł’„’…’†’‡’ˆ’‰’Š’‹’Œ’’Ž’’’‘’’’“’”’•’–’—’˜“™“š“›“œ““ž“Ÿ“ “”“¢“£“¤“„“œ“¦“§“ؓ©“Ŗ“«“¬“­“®“Ɠ°“±“²“³“““µ“¶“·“ø“¹“ŗ“»“¼”½”¾”æ”Ą”Į”Ā”ƔĔŔʔĒ”ȔɔŹ”Ė”Ģ”Ķ”Ī”Ļ”Š”єŅÓŌÕÖē×ŲŁŚŪ¦ĆĢÜŻ Ž“ßąįā ć äåęēčéźėģķī—ļ—š—ń—ņ—ó—ō—õ—ö“µ ’“µ÷ųłś!ūüżž“’˜ĆĢ–%)))ĆĢ*“ļ ĆÄ÷ĆÄ Ę6 6 ; ; ;;;;“??AAAAAAAACCC CCC!CD"D#E$E%E&E'E(F)K*L+L,L-L.M/M0M1O2O3O4O5O6\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`XaYaZa[a\a]a^b_c`cacb“cdeeĆĢfegghgigjgkglgmgngopqØg ågrgsgtguhvhwhxhylz“{|q}r~tt€tt ét‚tƒt„t…t†y‡yˆ ‰|Š|‹|Œ||Ž|||‘|’“”•}–—€˜€™€š›œ‚ƒž„Ÿ„ „”„¢†£†¤†„‡¦‡§‡؇©ˆŖˆ«ˆ¬ˆ­‰®ŠƊ°Š±Š²Š³Š“Šµ‹¶‹·‹ø¹ŗ c»¼‘½“¾æ“Ą“ĮĀ#morley-0.6.0-IcSJJapq7QZIEQu7njyuVyLorentz.PreludeLorentz.Rebinded Util.TypeLits Lorentz.Value Util.Typeable Util.TypeMichelson.Typed.Scope Util.Default Util.LensLorentz.CoercionsMichelson.Parser.Error Lorentz.ADT Util.NamedMichelson.Typed.Sing Util.PeanoMichelson.ErrorPosMichelson.Printer.UtilMichelson.Test.Util%Michelson.Typed.Haskell.Instr.HelpersMichelson.Untyped.AnnotationMichelson.Untyped.EntryPointsMichelson.Untyped.TypeMichelson.Untyped.ExtMichelson.Untyped.ContractMichelson.Typed.TTezos.Crypto.HashTezos.Crypto.UtilUtil.AlternativeUtil.Fcf Util.GenericUtil.IOUtil.Instances Util.Markdown Util.PositiveUtil.Test.Ingredients Util.TextMichelson.TextTezos.Crypto.Secp256k1Tezos.Crypto.P256Tezos.Crypto.Ed25519 Tezos.Crypto Tezos.Core Tezos.AddressMichelson.Untyped.ValueMichelson.Untyped.InstrMichelson.Untyped.AliasesMichelson.Runtime.TxDataLorentz.UStore.CommonUtil.TypeTuple.ClassUtil.TypeTuple.THUtil.TypeTuple.InstancesMichelson.Typed.AnnotationMichelson.Typed.ExtractMichelson.Typed.EntryPointsMichelson.Typed.CValueMichelson.Typed.ValueMichelson.Typed.PolymorphicMichelson.Typed.Arith Michelson.DocMichelson.Typed.InstrMichelson.Typed.ConvertMichelson.Typed.AliasesMichelson.Typed.UtilMichelson.Typed.Haskell.Value!Michelson.Typed.Haskell.Instr.SumLorentz.EntryPoints.Helpers%Michelson.Typed.Haskell.Instr.Product Michelson.Typed.Haskell.LooseSumMichelson.Typed.Haskell.DocMichelson.Typed.DocMichelson.TypeCheck.TypesMichelson.TypeCheck.ErrorMichelson.TypeCheck.TypeCheckMichelson.TypeCheck.HelpersMichelson.TypeCheck.ValueMichelson.TypeCheck.ExtMichelson.TypeCheck.InstrMichelson.Test.GenMichelson.Runtime.GStateMichelson.PrinterMichelson.Macro Michelson.LetMichelson.Parser.TypesMichelson.Parser.LexerMichelson.Parser.HelpersMichelson.Parser.ValueMichelson.Parser.AnnotationsMichelson.Parser.TypeMichelson.Parser.ExtMichelson.Parser.InstrMichelson.Parser.MacroMichelson.Parser.LetMichelson.ParserMichelson.PreprocessMichelson.Interpret.UnpackMichelson.Interpret.PackMichelson.OptimizerMichelson.OpSizeMichelson.InterpretMichelson.Test.DummyMichelson.RuntimeMichelson.Test.UnitMichelson.Test.IntegrationalMichelson.FailPatternMichelson.AnalyzerLorentz.PolymorphicLorentz.Constraints.ScopesLorentz.EntryPoints.CoreLorentz.Constraints.Derivative Lorentz.Arith Lorentz.PackLorentz.EntryPoints.Manual Lorentz.Base Lorentz.ZipLorentz.TypeAnnsLorentz.EntryPoints.Impl Lorentz.Run Lorentz.PrintLorentz.TestScenario Lorentz.InstrLorentz.Referenced Lorentz.ExtLorentz.CommonLorentz.ExtensibleMichelson.Doc.Test Lorentz.DocLorentz.UStore.TypesLorentz.UStore.Migration.DiffLorentz.UStore.LiftLorentz.UStore.Migration.Base!Lorentz.UStore.Migration.BatchingLorentz.EntryPoints.DocLorentz.Test.DocLorentz.Errors Lorentz.MacroLorentz.UStore.InstrLorentz.UStore.Migration.BlocksLorentz.UStore.HaskellLorentz.UParamLorentz.Test.ConsumerLorentz.StoreClassLorentz.UStore.Instances Lorentz.StoreLorentz.Errors.NumericLorentz.Errors.CommonMichelson.Test.ImportUtil.Test.ArbitraryLorentz.Test.IntegrationalMichelson.TypeType Paths_morleyDataGeneric Michelson*Michelson.UntypedInstr Data.Vinyl FromTupleUtil.TypeTupleMichelson.Typed.Haskell.InstrMichelson.Typed.HaskellMichelson.TypedMichelson.TypeCheckTest.QuickCheckProperty Test.Hspec ExpectationNiceParameterFullLorentz.ConstraintsLorentz.EntryPoints InstancesLorentz.UStore.MigrationLorentz.UStoreLorentzMichelson.TestLorentz.Contracts.ConsumercontractConsumer Lorentz.TestbaseGHC.Base$GHC.Num fromIntegerreturn Data.String fromString<>memptymappendmconcatpureGHC.EnumBoundedghc-prim GHC.ClassesEqOrd GHC.Generics GHC.TypeLits KnownSymbol SemigroupMonoid GHC.TypesBool integer-gmpGHC.Integer.TypeInteger GHC.NaturalNatural GHC.MaybeMaybe Data.EitherEitherSymbol TypeError AppendSymbolFalseNothingJustTrueLeftRightText:<>::$$:ShowTypebytestring-0.10.8.2Data.ByteString.Internal ByteString text-1.2.3.1Data.Text.Internal.containers-0.6.0.1Data.Map.InternalMapGHC.OverloadedLabels fromLabel Data.TypeableeqT ErrorMessage Data.ProxyProxyData.Type.EqualityRefl:~:==Data.Type.BoolIfmaxBoundminBoundstimessconcat)constraints-0.11.2-GZMSoVtvnAgCRhZL1gawmDData.ConstraintwithDictSub:-Data.Set.InternalSet1data-default-class-0.1.2.0-FeIQ5tLoVZBHMSgrT9zptQData.Default.ClassDefaultdef"lens-4.18.1-3CVKkhd76525nVMSc8Tyc2Control.Lens.THmakeLensesWithControl.Lens.Wrapped _Wrapped' UnwrappedWrapped&megaparsec-8.0.0-9g7AKmV0pGtLHgiBXCxWUText.Megaparsec.ErrorParseErrorBundle&universum-1.6.1-IcySg7B72urASaB0xXiYZfUniversum.Debugerror undefinedUniversum.TypeOps$named-0.3.0.1-GwpuPjBY1xnHurMYYo5M6DNamed.InternalargDefargFarg:!:?'singletons-2.5.1-A4kizWClywXHfGOUz1BoemData.Singletons.Internal applySingSLambdaSingsingSingI#vinyl-0.12.0-IALeOtLPo1cBDYNVTLLh2zData.Vinyl.DerivedLabelData.Vinyl.Core:&RNilRecData.Vinyl.TypeLevelSZNat++InstrCallStack icsCallStack icsSrcPos LetCallStackLetNameSrcPosPosmkPossrcPos $fFromJSONPos $fToJSONPos $fDefaultPos$fFromJSONSrcPos$fToJSONSrcPos$fDefaultSrcPos$fFromJSONLetName$fToJSONLetName$fFromJSONInstrCallStack$fToJSONInstrCallStack$fDefaultInstrCallStack$fEqPos$fOrdPos $fShowPos $fGenericPos $fDataPos $fEqSrcPos $fOrdSrcPos $fShowSrcPos$fGenericSrcPos $fDataSrcPos $fEqLetName $fOrdLetName $fShowLetName $fDataLetName$fGenericLetName$fEqInstrCallStack$fOrdInstrCallStack$fShowInstrCallStack$fGenericInstrCallStack$fDataInstrCallStackPrettier RenderDoc renderDoc isRenderable RenderContextprintDoc renderOps renderOpsListspaces wrapInParensbuildRenderDoc needsParensdoesntNeedParens addParensassertParensNotNeededleftToShowPanicleftToPrettyPanic failedProp succeededPropqcIsLeft qcIsRightPathBranchLRSomeAnnVarAnnFieldAnnTypeAnn KnownAnnTag annPrefix AnnotationAnnotationUnsafe unAnnotationWithAnn renderAnn renderWEAnnnoAnnann mkAnnotationspecialVarAnnsspecialFieldAnnisValidAnnStartisValidAnnBodyCharunifyAnn ifAnnUnified disjoinVnconvAnn$fDefaultAnnotation$fBuildableAnnotation$fRenderDocAnnotation$fShowAnnotation$fKnownAnnTagTYPETypeTag$fKnownAnnTagTYPEFieldTag$fKnownAnnTagTYPEVarTag$fMonoidAnnotation$fSemigroupAnnotation$fEqAnnotation$fDataAnnotation$fFunctorAnnotation$fGenericAnnotation$fIsStringAnnotation$fFromJSONAnnotation$fToJSONAnnotation$fLiftAnnotationEpNameFromRefAnnErrorInEpNameBadAnnotationEpName EpNameUnsafeunEpName DefEpNameepNameFromParamAnnepNameToParamAnnepNameFromRefAnnepNameToRefAnn$fArbitraryEpName$fDefaultEpName$fBuildableEpName $fBuildableEpNameFromRefAnnError $fShowEpName $fEqEpName $fOrdEpName$fShowEpNameFromRefAnnError$fEqEpNameFromRefAnnErrorCTCIntCNatCStringCBytesCMutezCBoolCKeyHash CTimestampCAddressTTcTKeyTUnit TSignatureTChainIdTOptionTListTSet TOperation TContractTPairTOrTLambdaTMapTBigMap ComparableTaddress Ttimestamp Tkey_hashTboolTmutezTbytesTstringTnatTint compToType typeToComptinttnattstringtbytestmuteztbooltkeyHash ttimestamptaddresstoptiontpairtortyinttynattyunittybooltypairtyortyImplicitAccountParam isAtomicTypeisKey isSignature isComparableisMutez isTimestamp isKeyHashisBoolisString isIntegerisNatisIntisBytes $fBuildableCT $fRenderDocCT$fBuildableComparable$fRenderDocComparable $fBuildableT$fBuildableType $fRenderDocT$fRenderDocType$fRenderDocPrettier$fEqCT$fOrdCT$fShowCT$fDataCT$fEnumCT $fBoundedCT $fGenericCT$fEqComparable$fShowComparable$fDataComparable$fGenericComparable$fEqT$fShowT$fDataT $fGenericT$fEqType $fShowType $fDataType $fGenericType$fFromJSONType $fToJSONType$fFromJSONComparable$fToJSONComparable $fFromJSONT $fToJSONT $fFromJSONCT $fToJSONCT $fLiftType$fLiftComparable$fLiftT$fLiftCT TestAsserttassName tassComment tassInstrs PrintCommentunUPrintCommentStackFnquantifiedVars inPattern outPatternStackTypePatternStkEmptyStkRestStkConsTyVarVarIDTyConVarStackRefExtInstrAbstract STACKTYPEFN UTEST_ASSERTUPRINTstackTypePatternToListvarSet$fBuildableStackRef$fBuildableVar$fBuildableTyVar$fBuildableStackTypePattern$fBuildableStackFn$fBuildablePrintComment$fBuildableTestAssert$fBuildableExtInstrAbstract$fRenderDocExtInstrAbstract $fEqStackRef$fShowStackRef$fDataStackRef$fGenericStackRef$fEqVar $fShowVar$fOrdVar $fDataVar $fGenericVar $fEqTyVar $fShowTyVar $fDataTyVar$fGenericTyVar$fEqStackTypePattern$fShowStackTypePattern$fDataStackTypePattern$fGenericStackTypePattern $fEqStackFn $fShowStackFn $fDataStackFn$fGenericStackFn$fEqPrintComment$fShowPrintComment$fDataPrintComment$fGenericPrintComment$fEqTestAssert$fShowTestAssert$fFunctorTestAssert$fDataTestAssert$fGenericTestAssert$fEqExtInstrAbstract$fShowExtInstrAbstract$fDataExtInstrAbstract$fGenericExtInstrAbstract$fFunctorExtInstrAbstract$fFromJSONExtInstrAbstract$fToJSONExtInstrAbstract$fFromJSONPrintComment$fToJSONPrintComment$fFromJSONStackTypePattern$fToJSONStackTypePattern$fFromJSONStackRef$fToJSONStackRef$fFromJSONStackFn$fToJSONStackFn $fFromJSONVar $fToJSONVar$fFromJSONTyVar $fToJSONTyVar$fFromJSONTestAssert$fToJSONTestAssert Contract'ContractparastorcodeStorage Parameter$fBuildableContract'$fRenderDocContract' $fEqContract'$fShowContract'$fFunctorContract'$fDataContract'$fGenericContract'$fFromJSONContract'$fToJSONContract'toUType buildStackSTcSTKeySTUnit STSignature STChainIdSTOptionSTListSTSet STOperation STContractSTPairSTOrSTLambdaSTMapSTBigMapSCIntSCNatSCStringSCBytesSCMutezSCBool SCKeyHash SCTimestamp SCAddresswithSomeSingCT fromSingCT withSomeSingT fromSingT$fSingITTBigMap $fSingITTMap$fSingITTLambda $fSingITTOr $fSingITTPair$fSingITTContract$fSingITTOperation $fSingITTSet $fSingITTList$fSingITTOption$fSingITTChainId$fSingITTSignature $fSingITTUnit $fSingITTKey $fSingITTc$fSingICTCAddress$fSingICTCTimestamp$fSingICTCKeyHash$fSingICTCBool$fSingICTCMutez$fSingICTCBytes$fSingICTCString $fSingICTCNat $fSingICTCInt $fSingKindCT $fSingKindTProperComparabilityBetterErrorsProperPrintedValBetterErrorsProperUnpackedValBetterErrorsProperPackedValBetterErrorsProperConstantBetterErrorsProperStorageBetterErrorsProperParameterBetterErrorsPrintedValScopeUnpackedValScopePackedValScope ConstantScope StorageScopeParameterScopeComparabilityScope Comparability CanBeComparedCannotBeComparedNestedBigMapsPresenceNestedBigMapsPresentNestedBigMapsAbsentBigMapPresence BigMapPresent BigMapAbsentContractPresenceContractPresentContractAbsent OpPresence OpPresentOpAbsentForbidNonComparableForbidNestedBigMaps ForbidBigMapForbidContractForbidOpFailOnNestedBigMapsFoundFailOnBigMapFoundFailOnOperationFoundHasNoNestedBigMaps HasNoBigMap HasNoContractHasNoOpContainsNestedBigMapsContainsBigMap forbiddenOpforbiddenBigMapforbiddenNestedBigMapsforbiddenContractTypecheckComparabilitycheckOpPresencecheckContractTypePresencecheckBigMapPresencecheckNestedBigMapsPresencecomparabilityPresence opAbsensecontractTypeAbsense bigMapAbsensenestedBigMapsAbsenseproperParameterEviproperStorageEviproperConstantEviproperPackedValEviproperUnpackedValEviproperPrintedValEvi $fHasNoOpt$fHasNoContractt$fHasNoBigMapt$fHasNoNestedBigMapstblake2b blake2b160sha256sha512B58CheckWithPrefixErrorB58CheckWithPrefixWrongPrefixB58CheckWithPrefixWrongEncodingCryptoParseErrorCryptoParseWrongBase58CheckCryptoParseWrongTagCryptoParseCryptoErrorCryptoParseUnexpectedLengthencodeBase58CheckdecodeBase58CheckdecodeBase58CheckWithPrefix formatImpl parseImpl firstRight deterministic$fBuildableCryptoParseError$fShowCryptoParseError$fEqCryptoParseError$fShowB58CheckWithPrefixErrorsomeNE permute2Def permute3DefTyEqSing<|>Over2GenericTypeName mkGenericTreemkGenericTreeVec readFileUtf8 writeFileUtf8appendFileUtf8 withEncoding hSetTranslit$fBuildableIdentity$fBuildableNatural$fDefaultNaturalpostfixLFields unwrappedP HeaderLevelMarkdownnextHeaderLevelmdHeadermdSubsectionTitle mdSubsectionmdBoldmdItalicmdTickedmdRef mdLocalRefmdAnchor mdSeparator mdSpoiler mdCommentmd NamedInnerApplyNamedFunctor.!.?<.!><.?>$fBuildableNamedF $fShowNamedF$fWrappedNamedF$fWrappedNamedF0$fFromJSONNamedF$fFromJSONNamedF0$fToJSONNamedF$fToJSONNamedF0 $fDataNamedF $fOrdNamedF $fEqNamedFRequireLongerOrSameLengthRequireLongerThanLongerOrSameLengthIsLongerOrSameLength LongerThan IsLongerThanTakeDropAtLength KnownPeanopeanoVal FromPeanoToPeanoPeanoSZSS peanoVal' peanoValSing $fSingINatZ $fSingINatS $fKnownPeanoS $fKnownPeanoZ$fRequireLongerThankla$fRequireLongerOrSameLengthkla$fEqSing $fShowSingPositivePositiveUnsafe unPositive mkPositivelengthNE replicateNE $fEqPositive $fOrdPositive$fDataPositive$fShowPositive$fBuildablePositive$fToJSONPositive$fFromJSONPositiveParserExceptionStringLiteralParserExceptionInvalidEscapeSequence InvalidCharCustomParserExceptionUnknownTypeExceptionStringLiteralExceptionOddNumberBytesException WrongTagArgsWrongAccessArgs WrongSetArgs0$fShowErrorComponentStringLiteralParserException)$fShowErrorComponentCustomParserException$fBuildableParserException$fExceptionParserException$fShowParserException $fEqStringLiteralParserException"$fDataStringLiteralParserException!$fOrdStringLiteralParserException"$fShowStringLiteralParserException$fEqCustomParserException$fDataCustomParserException$fOrdCustomParserException$fShowCustomParserException$fEqParserExceptionourIngredients headToLowerRSplitKListKNilKCons KnownListklist ReifyList reifyList PatternMatchL PatternMatchRequireAllUnique AllUniqueGuard///IsElemreifyTypeEqualityrsplit$fReifyListac:$fReifyListkc[] $fKnownListk:$fKnownListk[]TypeErrorUnless symbolValT symbolValT'inTypeErrorUnlessDoNotUseTextErrorMText MTextUnsafeunMTextisMCharmkMText mkMTextUnsafe mkMTextCut writeMText takeMText dropMTextmtqqMText symbolToMText labelToMTextmtextHeadToUpper$fIsStringMText$fFromJSONMText $fToJSONMText$fArbitraryMText $fToTextMText $fShowMText $fEqMText $fOrdMText $fDataMText$fSemigroupMText $fMonoidMText$fContainerMText$fBuildableMText$fHashableMText Signature unSignature SecretKey PublicKey unPublicKeypkBytes detSecretKeytoPublicpublicKeyToBytes mkPublicKeypublicKeyLengthBytessignatureToBytes mkSignaturesignatureLengthBytesformatPublicKeymformatPublicKeyparsePublicKeyformatSignaturemformatSignatureparseSignaturesigncheckSignature$fBuildablePublicKey$fArbitraryPublicKey $fEqPublicKey$fArbitrarySecretKey$fBuildableSignature$fArbitrarySignature$fShowPublicKey$fShowSecretKey $fEqSecretKey$fShowSignature $fEqSignatureformatSecretKey$fBuildableSecretKeyKeyHashkhTagkhBytes KeyHashTagKeyHashEd25519KeyHashSecp256k1 KeyHashP256SignatureEd25519SignatureSecp256k1 SignatureP256SignatureGenericPublicKeyEd25519PublicKeySecp256k1 PublicKeyP256keyHashLengthByteshashKey formatKeyHashmformatKeyHash parseKeyHash$fFromJSONPublicKey$fToJSONPublicKey$fFromJSONSignature$fToJSONSignature$fArbitraryKeyHashTag$fBuildableKeyHash$fArbitraryKeyHash$fFromJSONKeyHash$fToJSONKeyHash$fShowKeyHashTag$fEqKeyHashTag$fOrdKeyHashTag$fBoundedKeyHashTag$fEnumKeyHashTag $fShowKeyHash $fEqKeyHash $fOrdKeyHashChainId ChainIdUnsafe unChainId Timestamp unTimestampMutezunMutezmkMutez unsafeMkMuteztoMutezaddMutezunsafeAddMutezsubMutezunsafeSubMutezmulMutez divModMutezdivModMutezInttimestampToSecondstimestampFromSecondstimestampFromUTCTimetimestampPlusSecondsformatTimestampparseTimestamptimestampQuotegetCurrentTime farFuturefarPast mkChainIdmkChainIdUnsafe dummyChainId formatChainIdmformatChainId parseChainId chainIdLength$fBoundedMutez$fBuildableTimestamp$fArbitraryChainId$fBuildableChainId$fBuildableParseChainIdError $fShowMutez $fEqMutez $fOrdMutez $fDataMutez$fGenericMutez $fEnumMutez$fBuildableMutez$fShowTimestamp $fEqTimestamp$fOrdTimestamp$fDataTimestamp$fGenericTimestamp $fShowChainId $fEqChainId$fShowParseChainIdError$fEqParseChainIdError$fFromJSONMutez $fToJSONMutez$fFromJSONChainId$fToJSONChainId$fFromJSONTimestamp$fToJSONTimestampParseContractAddressErrorParseAddressErrorParseAddressWrongBase58CheckParseAddressBothFailedAddress KeyAddressContractAddress ContractHash mkKeyAddressdetGenKeyAddressmkContractAddressRawmkContractHashRaw formatAddressmformatAddress parseAddressunsafeParseAddressunsafeParseContractHash$fFromJSONKeyContractHash$fFromJSONContractHash$fToJSONKeyContractHash$fToJSONContractHash$fArbitraryAddress$fFromJSONKeyAddress$fFromJSONAddress$fToJSONKeyAddress$fToJSONAddress$fBuildableAddress$$fBuildableParseContractAddressError$fBuildableParseAddressError$fShowContractHash$fEqContractHash$fOrdContractHash $fShowAddress $fEqAddress $fOrdAddress$fShowParseContractAddressError$fEqParseContractAddressError$fShowParseAddressError$fEqParseAddressErrorInternalByteStringEltValue'ValueInt ValueString ValueBytes ValueUnit ValueTrue ValueFalse ValuePair ValueLeft ValueRight ValueSome ValueNoneValueNilValueSeqValueMap ValueLambdaunInternalByteString$fFromJSONInternalByteString$fToJSONInternalByteString$fBuildableElt$fBuildableValue'$fRenderDocElt$fRenderDocValue'$fDataInternalByteString$fEqInternalByteString$fShowInternalByteString $fEqValue' $fShowValue'$fFunctorValue' $fDataValue'$fGenericValue'$fEqElt $fShowElt $fFunctorElt $fDataElt $fGenericElt$fFromJSONValue'$fToJSONValue' $fFromJSONElt $fToJSONEltOriginationOperation ooOriginator ooDelegate ooBalance ooStorage ooContract InstrAbstractEXTDROPNDROPDUPSWAPDIGDUGPUSHSOMENONEUNITIF_NONEPAIRCARCDRLEFTRIGHTIF_LEFTNILCONSIF_CONSSIZE EMPTY_SET EMPTY_MAP EMPTY_BIG_MAPMAPITERMEMGETUPDATEIFLOOP LOOP_LEFTLAMBDAEXECAPPLYDIPDIPNFAILWITHCASTRENAMEPACKUNPACKCONCATSLICEISNATADDSUBMULEDIVABSNEGLSLLSRORANDXORNOTCOMPAREEQNEQLTGTLEGEINTSELFCONTRACTTRANSFER_TOKENS SET_DELEGATECREATE_CONTRACTIMPLICIT_ACCOUNTNOWAMOUNTBALANCECHECK_SIGNATURESHA256SHA512BLAKE2BHASH_KEYSTEPS_TO_QUOTASOURCESENDERADDRESSCHAIN_ID ExpandedOpPrimExSeqEx WithSrcEx ExpandedInstrflattenExpandedOpmkContractAddress$fFromJSONInstrAbstract$fToJSONInstrAbstract$fBuildableInstrAbstract$fRenderDocInstrAbstract$fFromJSONExpandedOp$fToJSONExpandedOp$fBuildableExpandedOp$fRenderDocExpandedOp$fToJSONOriginationOperation$fFromJSONOriginationOperation$fEqInstrAbstract$fShowInstrAbstract$fFunctorInstrAbstract$fDataInstrAbstract$fGenericInstrAbstract$fShowExpandedOp$fEqExpandedOp$fDataExpandedOp$fGenericExpandedOp$fShowOriginationOperation$fGenericOriginationOperationExpandedExtInstrValueTxDatatdSenderAddress tdParameter tdEntrypointtdAmount $fShowTxData $fEqTxData tdAmountL tdEntrypointL tdParameterLtdSenderAddressLfieldNameToMText RecFromTuple IsoRecTuple recFromTuplederiveRecFromTuple$fRecFromTupleRec$fRecFromTupleRec0$fRecFromTupleRec1$fRecFromTupleRec2$fRecFromTupleRec3$fRecFromTupleRec4$fRecFromTupleRec5$fRecFromTupleRec6$fRecFromTupleRec7$fRecFromTupleRec8$fRecFromTupleRec9$fRecFromTupleRec10$fRecFromTupleRec11$fRecFromTupleRec12$fRecFromTupleRec13$fRecFromTupleRec14$fRecFromTupleRec15$fRecFromTupleRec16$fRecFromTupleRec17$fRecFromTupleRec18$fRecFromTupleRec19$fRecFromTupleRec20$fRecFromTupleRec21$fRecFromTupleRec22$fRecFromTupleRec23$fRecFromTupleRec24gcastEeqPeqParam1eqParam2eqParam3eqExt compareExtcastIgnoringPhantomAnnConvergeErrorNotesNTcNTKeyNTUnit NTSignature NTChainIdNTOptionNTListNTSet NTOperation NTContractNTPairNTOrNTLambdaNTMapNTBigMap starNotesisStarorAnnconverge convergeAnns$fBuildableAnnConvergeError$fEqAnnConvergeError$fShowAnnConvergeError $fEqNotes $fShowNotesAsUType fromUTypemkUType withUTypeMkEntryPointCallResSomeEntryPointCallTSomeEpcEntryPointCallTEntryPointCallepcName epcParamProxyepcLiftSequenceEpLiftSequence EplArgHere EplWrapLeft EplWrapRight ParamEpErrorParamEpDuplicatedNamesParamEpUncallableArmArmCoordAcLeftAcRight ArmCoords ParamNotesParamNotesUnsafe unParamNotesParseEpAddressErrorParseEpAddressBadAddressParseEpAddressBadRefAnnParseEpAddressRefAnnError EpAddress eaAddress eaEntryPointformatEpAddressmformatEpAddressparseEpAddressunsafeParseEpAddress mkParamNotessepcNamemkEntryPointCall$fArbitraryEpAddress$fBuildableEpAddress$fBuildableParseEpAddressError$fBuildableArmCoord$fBuildableParamEpError$fBuildableEpLiftSequence$fDefaultEntryPointCallT$fBuildableEntryPointCallT$fDefaultSomeEntryPointCallT$fBuildableSomeEntryPointCallT$fEqSomeEntryPointCallT$fShowEpAddress $fEqEpAddress$fOrdEpAddress$fShowParseEpAddressError$fEqParseEpAddressError$fShowParamNotes$fEqParamNotes$fShowArmCoord $fEqArmCoord$fShowParamEpError$fEqParamEpError$fShowSomeEntryPointCallT$fShowEntryPointCallT$fEqEntryPointCallT$fShowEpLiftSequence$fEqEpLiftSequenceCValueCvIntCvNatCvStringCvBytesCvMutezCvBool CvKeyHash CvTimestamp CvAddress $fOrdCValue $fEqCValue $fShowCValueSomeConstrainedValue'SomeConstrainedValue SomeValue' SomeValueVCVKeyVUnit VSignatureVChainIdVOptionVListVSetVOp VContractVPairVOrVLamVMapVBigMapRemFailRfNormal RfAlwaysFails ContractOut ContractOut1 ContractInp ContractInp1CreateContract ccOriginator ccDelegate ccBalance ccStorageValccContractCode SetDelegate sdMbKeyHashTransferTokensttTransferArgumentttAmount ttContract Operation'OpTransferTokens OpSetDelegateOpCreateContractrfMerge rfAnyInstr rfMapAnyInstraddressToVContractbuildVContractcompileEpLiftSequence$fBuildableSetDelegate $fEqRemFail$fBuildableCreateContract$fBuildableTransferTokens$fEqOperation'$fBuildableOperation'$fEqSomeValue'$fShowSetDelegate$fEqSetDelegate$fShowTransferTokens$fEqTransferTokens$fShowSomeConstrainedValue'$fShowSomeValue' $fShowRemFail$fEqCreateContract$fShowCreateContract$fShowOperation'EDivOp EDivOpRes EModOpRes evalEDivOpSliceOp evalSliceConcatOp evalConcat evalConcat'GetOpGetOpKeyGetOpValevalGetUpdOpUpdOpKey UpdOpParamsevalUpdSizeOpevalSizeIterOpIterOpEliterOpDetachOneMapOpMapOpInpMapOpRes mapOpToList mapOpFromListMemOpMemOpKeyevalMem$fMemOpTBigMap $fMemOpTMap $fMemOpTSet $fMapOpTList $fMapOpTMap $fIterOpTSet $fIterOpTList $fIterOpTMap $fSizeOpTMap $fSizeOpTList $fSizeOpTSet $fSizeOpTc $fSizeOpTc0 $fUpdOpTSet$fUpdOpTBigMap $fUpdOpTMap $fGetOpTMap$fGetOpTBigMap $fConcatOpTc $fConcatOpTc0 $fSliceOpTc $fSliceOpTc0$fEDivOpCMutezCNat$fEDivOpCMutezCMutez$fEDivOpCNatCNat$fEDivOpCNatCInt$fEDivOpCIntCNat$fEDivOpCIntCIntGeLeGtLtNeqEq'CompareLsrLslNotXorAndOrNegAbsMulAdd UnaryArithOp UnaryArithResevalUnaryArithOp ArithErrorMutezArithErrorShiftArithErrorArithErrorType AddOverflow MulOverflow SubUnderflow LslOverflow LsrUnderflowArithOpArithResevalOp compareOp$fBuildableArithErrorType$fBuildableArithError$fArithOpTYPEAddCMutezCMutez$fArithOpTYPEAddCIntCTimestamp$fArithOpTYPEAddCTimestampCInt$fArithOpTYPEAddCIntCInt$fArithOpTYPEAddCNatCNat$fArithOpTYPEAddCIntCNat$fArithOpTYPEAddCNatCInt$fArithOpTYPESubCMutezCMutez$$fArithOpTYPESubCTimestampCTimestamp$fArithOpTYPESubCTimestampCInt$fArithOpTYPESubCIntCInt$fArithOpTYPESubCNatCNat$fArithOpTYPESubCIntCNat$fArithOpTYPESubCNatCInt$fArithOpTYPEMulCMutezCNat$fArithOpTYPEMulCNatCMutez$fArithOpTYPEMulCIntCInt$fArithOpTYPEMulCNatCNat$fArithOpTYPEMulCIntCNat$fArithOpTYPEMulCNatCInt$fUnaryArithOpTYPEAbsCInt$fUnaryArithOpTYPENegCNat$fUnaryArithOpTYPENegCInt$fArithOpTYPEOrCBoolCBool$fArithOpTYPEOrCNatCNat$fArithOpTYPEAndCBoolCBool$fArithOpTYPEAndCNatCNat$fArithOpTYPEAndCIntCNat$fArithOpTYPEXorCBoolCBool$fArithOpTYPEXorCNatCNat$fUnaryArithOpTYPENotCBool$fUnaryArithOpTYPENotCNat$fUnaryArithOpTYPENotCInt$fArithOpTYPELslCNatCNat$fArithOpTYPELsrCNatCNat$fUnaryArithOpTYPEEq'CInt$fUnaryArithOpTYPENeqCInt$fUnaryArithOpTYPELtCInt$fUnaryArithOpTYPEGtCInt$fUnaryArithOpTYPELeCInt$fUnaryArithOpTYPEGeCInt$fShowArithErrorType$fEqArithErrorType$fOrdArithErrorType$fShowArithError$fEqArithError$fOrdArithError ContractDoc cdContents cdDefinitionscdDefinitionsSetcdDefinitionIdsSubDocDocBlock DocSectionDocElemdeItemdeSubSomeDocDefinitionItem SomeDocItemDocSectionNameStyleDocSectionNameBigDocSectionNameSmall DocItemRef DocItemNoRefDocItemPlacementKindDocItemInlinedDocItemInDefinitions DocItemIdDocItemDocItemPositionDocItemPlacementdocItemSectionNamedocItemSectionDescriptiondocItemSectionNameStyle docItemRefdocItemToMarkdowndocItemDependencies docItemsOrderdocItemPositiondocDefinitionRef deIsAtomicdocItemToBlocklookupDocBlockSectionsubDocToMarkdown$fOrdSomeDocDefinitionItem$fEqSomeDocDefinitionItem$fShowSomeDocItem$fShowDocSection $fEqDocItemId$fOrdDocItemId$fShowDocItemId$fEqDocItemPos$fOrdDocItemPos$fShowDocItemPos$fBuildableDocItemPosDCommentGitRepoSettingsgrsMkGitRevision DGitRevisionDGitRevisionKnownDGitRevisionUnknown DDescriptionDName DocGrouping cdContentsLcdDefinitionIdsLcdDefinitionsLcdDefinitionsSetLcontractDocToMarkdowndocGroupContentmorleyRepoSettingsmkDGitRevision$fMonoidContractDoc$fSemigroupContractDoc$fShow->$fDocItemDName$fDocItemDDescription$fDocItemDGitRevision$fDocItemDComment FullContractfcCodefcParamNotesSafe fcStoreNotesExtInstr TEST_ASSERTPRINTDOC_ITEMunPrintCommentInstrWithNotes FrameInstrSeqNopExtNestedDocGroupAnnCARAnnCDRCONCAT' ConstraintDUGConstraintDUG' ConstraintDIGConstraintDIG'ConstraintDIPNConstraintDIPN' PackedNotes mkStackRef fcParamNotesmapFullContractCode$fShowPackedNotes$fIsStringPrintComment $fNFDataInstr $fMonoidInstr$fSemigroupInstr$fSemigroupPrintComment$fMonoidPrintComment$fShowExtInstr$fShowFullContract $fShowInstrconvertContractconvertFullContract untypeValue instrToOps $fEqInstr OperationCtorEffectsAppceaNameceaApplyEffects DfsSettings dsGoToValuesdsCtorEffectsAppdfsInstr dfsFoldInstrdfsModifyInstr linearizeLeft isStringValue isBytesValueallAtomicValues$fShowCtorEffectsApp$fDefaultDfsSettings$fShowDfsSettingsIsoValuesStack toValStack fromValStackToTs'ToTsGenericIsoValue GIsoValue GValueTypeBigMapunBigMap ContractRef crAddress crEntryPointSomeEntryPointCall IsComparable AnyIsoValue SomeIsoValueToT'IsoValueToTtoValfromVal IsoCValueToCTtoCValfromCValcoerceContractReftotsKnownLemmatotsAppendLemma$fIsoCValueTimestamp$fIsoCValueKeyHash$fIsoCValueEpAddress$fIsoCValueAddress$fIsoCValueMutez$fIsoCValueByteString$fIsoCValueBool$fIsoCValueText$fIsoCValueMText$fIsoCValueNatural$fIsoCValueInteger $fGIsoValueU1$fGIsoValue:*:$fGIsoValue:+: $fGIsoValueM1 $fGIsoValueK1$fIsoValueBigMap$fIsoValue(,,,,,,)$fIsoValue(,,,,,)$fIsoValue(,,,,)$fIsoValue(,,,)$fIsoValue(,,)$fIsoValueOperation' $fIsoValueMap $fIsoValueSet $fIsoValue(,)$fIsoValueEither$fIsoValueMaybe $fIsoValue[] $fIsoValue()$fIsoValueChainId$fIsoValueSignature$fIsoValuePublicKey$fIsoValueEpAddress$fIsoValueAddress$fIsoValueTimestamp$fIsoValueKeyHash$fIsoValueMutez$fIsoValueByteString$fIsoValueBool$fIsoValueText$fIsoValueMText$fIsoValueNatural$fIsoValueInteger$fIsoValueContractRef$fBuildableContractRef$fIsoValuesStack:$fIsoValuesStack[] $fEqBigMap $fShowBigMap$fDefaultBigMap$fSemigroupBigMap$fMonoidBigMap$fEqContractRef$fShowContractRef$fIsoValueNamedF$fIsoValueNamedF0$fIsoValueIdentity InstrUnwrapCGCaseBranchInput GCaseClauses CaseClauses CaseClauseCaseClauseParam InstrCaseCMyCompoundType InstrWrapC CtorOnlyFieldCtorHasOnlyField GetCtorFieldIsPrimitiveValueAppendCtorFieldAxiomAppendCtorFieldExtractCtorField CtorFieldOneFieldNoFieldsappendCtorFieldAxiom instrWraphsWrap instrCase//->instrUnwrapUnsafehsUnwrap$fGInstrWrapM1:NoFields$fGInstrWrapM1:e$fGInstrWrapM1:OneField$fGInstrWrap:+::e$fGInstrWrap:+::e0$fGInstrWrapM1pathe$fGInstrCase:+:$fGInstrCaseM1$fGInstrCaseBranchctorU1$fGInstrCaseBranchctorK1$fGInstrCaseBranchctorM1$fGInstrCaseBranchctor:*:$fGInstrCaseM10$fGInstrUnwrapM1:e$fGInstrUnwrapM1:e0$fGInstrUnwrap:+::e$fGInstrUnwrap:+::e0$fGInstrUnwrapM1pathe$fGenericMyType$fIsoValueMyType$fGenericMyType'$fIsoValueMyType'$fGenericMyCompoundType$fIsoValueMyCompoundType$fGenericMyEnum$fIsoValueMyEnum$fGenericMyTypeWithNamedField$fIsoValueMyTypeWithNamedFieldRequireSumTypeCanHaveEntryPoints ctorNameToAnnInstrConstructCConstructorFieldTypesFieldConstructorInstrSetFieldCInstrGetFieldC GetFieldType instrGetField instrSetFieldinstrConstruct$fGInstrGetname:*::f$fGInstrGetname:*::f0$fGInstrGetnameK1[]f'$fGInstrGetnameM1pathf$fGInstrSetFieldname:*::f$fGInstrSetFieldname:*::f0$fGInstrSetFieldnameK1[]f'$fGInstrSetFieldnameM1pathf$fGInstrConstructK1$fGInstrConstruct:+:$fGInstrConstructU1$fGInstrConstruct:*:$fGInstrConstructM1$fGenericMyType2$fIsoValueMyType2 LooseSumC ComposeResult ComposeOkComposeCtorNotFoundComposeFieldTypeMismatch toTaggedVal fromTaggedVal$fMonoidComposeResult$fSemigroupComposeResult $fGLooseSumV1$fGLooseSum:+: $fGLooseSumM1$fGAccessField:*:$fGAccessFieldU1$fGAccessFieldK1$fGAccessFieldM1$fGLooseSumM10$fFunctorComposeResultPolyTypeHasDocC GTypeHasDoc IsHomomorphicHaveCommonTypeCtorDTypeSomeTypeWithDocTypeDocMichelsonRepTypeDocHaskellRep TypeHasDoc typeDocNametypeDocMdDescriptiontypeDocMdReferencetypeDocDependenciestypeDocHaskellReptypeDocMichelsonRep WithinParensADTRep buildADTRepapplyWithinParenstypeDocDependencies'customTypeDocMdReferencehomomorphicTypeDocMdReferencepoly1TypeDocMdReferencepoly2TypeDocMdReferencegenericTypeDocDependencieshomomorphicTypeDocHaskellRepconcreteTypeDocHaskellRepconcreteTypeDocHaskellRepUnsafehaskellRepNoFieldshaskellRepStripFieldPrefixhomomorphicTypeDocMichelsonRepconcreteTypeDocMichelsonRep!concreteTypeDocMichelsonRepUnsafe$fHaveCommonTypeCtorkkaa$fHaveCommonTypeCtorkkacbc$fIsHomomorphicka$fIsHomomorphicka0$fTypeHasDocNamedF$fTypeHasDoc()$fTypeHasDocSignature$fTypeHasDocPublicKey$fTypeHasDocEpAddress$fTypeHasDocAddress$fTypeHasDocTimestamp$fTypeHasDocKeyHash$fTypeHasDocMutez$fTypeHasDocByteString$fTypeHasDocBool$fTypeHasDocNatural$fTypeHasDocInteger$fGTypeHasDocV1$fGTypeHasDoc:+:$fGTypeHasDocM1$fTypeHasDocOperation'$fTypeHasDocMText$fDocItemDType $fOrdDType $fEqDType $fShowDType$fGProductHasDocU1$fGProductHasDocM1$fGProductHasDocM10$fGProductHasDoc:*:$fGTypeHasDocM10$fTypeHasDoc(,,,,,,)$fTypeHasDoc(,,,,,)$fTypeHasDoc(,,,,)$fTypeHasDoc(,,,)$fTypeHasDoc(,,)$fTypeHasDocContractRef$fTypeHasDoc(,)$fTypeHasDocEither$fTypeHasDocMaybe$fTypeHasDoc[]$fTypeHasDocBigMap$fTypeHasDocMap$fTypeHasDocSet$fIsStringDocTypeRepLHS$fBuildableDocTypeRepLHS buildInstrDocmodifyInstrDoccutInstrNonDoc TcExtFrames BoundVars SomeContract SomeCValue:--:SomeNotedValue:::: SomeInstr:/ SomeInstrOut::: AnyOutInstrSomeHSTHSTSNil::&-:&mapSomeContract noBoundVars$fEqHST $fShowHST $fEqSomeHST$fShowSomeInstrOut$fShowSomeInstr$fShowSomeNotedValue$fShowSomeContract $fShowSomeHSTExtErrorLengthMismatchVarError TypeMismatch TyVarMismatchStkRestMismatchTestAssertErrorInvalidStackReference StackSizeTCErrorTCFailedOnInstrTCFailedOnValueTCContractErrorTCUnreachableCode TCExtError TCTypeErrorAnnError TypeEqError StackEqErrorUnsupportedTypesInvalidValueTypeNotEnoughItemsOnStackIllegalEntryPointUnknownContractEntryPointNotFoundIllegalParamDecl NegativeNat MutezOverflowInvalidAddressInvalidKeyHashInvalidTimestampNotEnoughItemsInstr NotEnoughDrop NotEnoughDip NotEnoughDig NotEnoughDug$fBuildableNotEnoughItemsInstr$fBuildableTCTypeError$fBuildableExtError$fExceptionTCError $fShowTCError$fBuildableTCError$fShowNotEnoughItemsInstr$fEqNotEnoughItemsInstr$fShowTCTypeError$fEqTCTypeError$fShowStackSize $fEqStackSize $fEqExtError $fEqTCError TypeCheckEnv tcExtFramestcContractParam tcContractsTcOriginatedContracts TypeCheckTcInstrHandlerTypeCheckInstrTcResulttcContractParamL tcContractsL tcExtFramesL runTypeCheckrunTypeCheckIsolated mapTCErrorderiveSpecialFNsderiveSpecialVNderiveVN deriveNsOrderiveNsOption convergeHSTEl convergeHSTonLefthstToTseqHSTeqHST1 lengthHSTensureDistinctAsccheckEqTeqType checkEqHSTonTypeCheckInstrErrtypeCheckInstrErrtypeCheckInstrErr'onTypeCheckInstrAnnErr typeCheckImpl matchTypesmemImplgetImplupdImplsizeImpl sliceImpl concatImpl' concatImpl arithImpladdImpledivImplsubImplmulImplunaryArithImpltypeCheckCValuetypeCheckValImpl typeCheckExttypeCheckContract typeCheckListtypeCheckValuetypeVerifyValuetypeVerifyTopLevelTypetypeCheckTopLevelType minTimestamp maxTimestamp midTimestamp$fArbitraryTimestamp$fArbitraryMutez$fArbitraryCValue$fArbitraryValue'$fArbitraryValue'0$fArbitraryValue'1$fArbitraryValue'2$fArbitraryCValue0$fArbitraryCValue1$fArbitraryCValue2 AddressStateASSimple ASContract ContractState csBalance csStorage csContractcsTypedContractcsTypedStorage$fBuildableContractState$fFromJSONContractState$fToJSONContractState$fBuildableAddressState$fShowAddressState$fGenericAddressState$fShowContractStateGState gsChainId gsAddresses asBalance$fFromJSONAddressState$fToJSONAddressState $fShowGState gsAddressesL gsChainIdLGStateUpdateErrorGStateAddressExistsGStateUnknownAddressGStateNotContract GStateUpdate GSAddAddressGSSetStorageValue GSSetBalanceSomeContractAndStorage scsContract scsStoragegetTypedContractgetTypedStoragegetTypedContractAndStoragegenesisKeyHashesgenesisAddressesgenesisKeyHashgenesisAddressgenesisAddress1genesisAddress2genesisAddress3genesisAddress4genesisAddress5genesisAddress6 initGState readGState writeGState applyUpdate applyUpdatesextractAllContracts$fFromJSONGState$fToJSONGState$fExceptionGStateParseError$fBuildableGStateUpdate$fBuildableGStateUpdateError$fShowGStateParseError$fShowGStateUpdate$fShowGStateUpdateErrorprintUntypedContractprintTypedContractprintTypedFullContractprintTypedValueprintSomeContractMacroCASETAGACCESSSET CONSTRUCTVIEWVOIDCMPIFXIFCMPFAILPAPAIRUNPAIRCADRSET_CADRMAP_CADRDIIPDUUPASSERTASSERTX ASSERT_CMP ASSERT_NONE ASSERT_SOME ASSERT_LEFT ASSERT_RIGHTIF_SOMEIF_RIGHT ParsedValue ParsedInstrParsedUExtInstrParsedOpPrimMacLMac CadrStructAD PairStructFPLetMacrolmNamelmSiglmExpr expandListexpandContract expandValueexpand expandMacro expandPapairexpandUnpapair expandCadr expandSetCadr expandMapCadr mapLeaves$fBuildablePairStruct$fBuildableCadrStruct$fBuildableMacro$fBuildableParsedOp$fRenderDocParsedOp$fBuildableLetMacro$fEqPairStruct$fShowPairStruct$fDataPairStruct$fGenericPairStruct$fEqCadrStruct$fShowCadrStruct$fDataCadrStruct$fGenericCadrStruct $fEqMacro $fShowMacro $fDataMacro$fGenericMacro $fEqParsedOp$fShowParsedOp$fDataParsedOp$fGenericParsedOp $fEqLetMacro$fShowLetMacro$fDataLetMacro$fGenericLetMacro$fFromJSONParsedOp$fToJSONParsedOp$fFromJSONLetMacro$fToJSONLetMacro$fFromJSONPairStruct$fToJSONPairStruct$fFromJSONCadrStruct$fToJSONCadrStruct$fFromJSONMacro $fToJSONMacroLetTypeltNameltSigLetValuelvNamelvSiglvVal $fEqLetValue$fShowLetValue $fEqLetType $fShowLetType$fFromJSONLetValue$fToJSONLetValue$fFromJSONLetType$fToJSONLetTypeLetEnv letMacros letValuesletTypesParsernoLetEnv$fDefaultReaderT $fShowLetEnv $fEqLetEnvlexememSpacesymbolsymbol'string'parensbracesbrackets brackets' semicoloncommavarID sepEndBy1sepBy2mkParserparseDefpositivemparensvalue' stringLiteral bytesLiteral intLiteralmkLetValnotenoteVnoteDef noteV2DefnotesTVF notesTVF2 notesTVF2DefnotesVFnotesTVnotesTF fieldTypetype_ comparableextInstr printComment stackType primInstrops'cmpOppairOpmapOpmacropairMac mapCadrMacifCmpMacletBlockletTypemkLetMac parseNoEnvprogramvalue parseValueparseExpandValue codeEntryutypeQtransformStringstransformBytes UnpackError unUnpackError unpackValue unpackValue'$fExceptionUnpackError$fBuildableUnpackError$fShowUnpackError$fEqUnpackError packValue packValue'packT' packCode'encodeIntPayloadRule OptimizerConf gotoValuesrulesetoptimizeoptimizeWithConf defaultRulesdefaultRulesAndPushPackorRule orSimpleRule$fDefaultOptimizerConfOpSizeunOpSizeopSizeHardLimitsmallTransferOpSize instrOpSizeexpandedInstrsOpSize valueOpSize$fMonoidOpSize$fSemigroupOpSize$fAnnsOpSizeVarargOpSize$fAnnsOpSizeVararg->$fAnnsOpSizeVararg->0 $fShowOpSize $fEqOpSize $fOrdOpSizeEvalOpInterpreterState isMorleyLogsisRemainingStepsRemainingSteps SomeItStackContractReturn MorleyLogs unMorleyLogsInterpretResultiurOps iurNewStorage iurNewStateInterpretErrorRuntimeFailureIllTypedContract IllTypedParamIllTypedStorageUnexpectedParamTypeUnexpectedStorageTypeMichelsonFailedMichelsonFailedWithMichelsonArithErrorMichelsonGasExhaustionMichelsonFailedTestAssertMichelsonAmbigousEpRef ContractEnvceNow ceMaxSteps ceBalance ceContractsceSelfceSourceceSenderceAmount ceChainId noMorleyLogsinterpretUntypedhandleContractReturn interpretinterpretInstrrunInstr runInstrNoGas runUnpack$fBuildableMichelsonFailed$fEqMichelsonFailed$fBuildableInterpretError$fEqMorleyLogs$fShowMorleyLogs$fDefaultMorleyLogs$fBuildableMorleyLogs$fGenericInterpretError$fShowRemainingSteps$fEqRemainingSteps$fOrdRemainingSteps$fBuildableRemainingSteps$fNumRemainingSteps$fShowInterpreterState$fShowInterpretResult$fShowInterpretError$fShowMichelsonFaileddummyNow dummyMaxStepsdummyContractEnvdummyOrigination ExecutorRes _erGState _erOperations _erUpdates_erInterpretResults_erSourceAddress_erRemainingSteps ExecutorOp OriginateOp TransferOp$fShowExecutorOp$fShowExecutorRes ExecutorErrorExecutorError'EEUnknownContractEEInterpreterFailedEEAlreadyOriginatedEEUnknownSenderEEUnknownManagerEENotEnoughFundsEEZeroTransactionEEFailedToApplyUpdatesEEIllTypedContractEEIllTypedStorageEEIllTypedParameterEEUnknownEntrypointerInterpretResults erUpdates parseContractparseExpandContractreadAndParseContractprepareContractoriginateContract runContracttransfer executorPuretypeCheckWithDb$fSemigroupExecutorRes$fExceptionExecutorError'$fBuildableExecutorError'$fShowExecutorError'ContractPropValidator contractPropcontractPropValhasEpcontractHasEntryPointsmatchContractEntryPointsValidationErrorUnexpectedExecutorErrorUnexpectedTypeCheckErrorExpectingInterpreterToFailIncorrectUpdatesIncorrectStorageUpdateInvalidStorageInvalidBalanceUnexpectedUpdatesCustomValidationErrorIntegrationalScenarioIntegrationalScenarioMSuccessValidatorIntegrationalValidator$fBuildableScenarioBranchName$fBuildableAddressName$fExceptionValidationError$fBuildableValidationError$fShowExpectedStorage$fShowExpectedBalance$fShowAddressName$fShowValidationErrorintegrationalTestExpectationintegrationalTestProperty originatevalidateintegrationalFail modifyNowsetNow rewindTime setMaxSteps withSender setChainId branchout?-offshootexpectAnySuccessexpectNoUpdatesexpectNoStorageUpdatesexpectStorageUpdateexpectStorageUpdateConstexpectStorageConst expectBalancecomposeValidatorscomposeValidatorsListexpectGasExhaustionexpectMichelsonFailed$fBuildableScenarioErrorTypicalFailWithtypicalFailWithTagisTypicalFailWithmodifyTypicalFailWith$fConstantScope'a AnalyzerResarConstStrings arConstBytes arErrorTagsanalyze$fMonoidAnalyzerRes$fSemigroupAnalyzerRes$fBuildableAnalyzerRes$fShowAnalyzerRes$fEqAnalyzerResEDivOpHs EDivOpResHs EModOpResHs SliceOpHs ConcatOpHsGetOpHs GetOpKeyHs GetOpValHsUpdOpHs UpdOpKeyHs UpdOpParamsHsSizeOpHsIterOpHs IterOpElHsMapOpHs MapOpInpHs MapOpResHs IsoMapOpResMemOpHs MemOpKeyHs$fMemOpHsBigMap $fMemOpHsMap $fMemOpHsSet $fMapOpHs[] $fMapOpHsMap $fIterOpHsSet $fIterOpHs[] $fIterOpHsMap $fSizeOpHsMap $fSizeOpHs[] $fSizeOpHsSet$fSizeOpHsByteString$fSizeOpHsMText $fUpdOpHsSet$fUpdOpHsBigMap $fUpdOpHsMap$fGetOpHsBigMap $fGetOpHsMap$fConcatOpHsByteString$fConcatOpHsMText$fSliceOpHsByteString$fSliceOpHsMText$fEDivOpHsMutezNatural$fEDivOpHsMutezMutez$fEDivOpHsNaturalNatural$fEDivOpHsNaturalInteger$fEDivOpHsIntegerNatural$fEDivOpHsIntegerIntegerNiceComparableNicePrintedValueNiceFullPackedValueNiceUnpackedValueNicePackedValue NiceConstant NiceStorage NiceParameter CanHaveBigMapNoBigMapNoContractType NoOperation KnownCValue KnownValueniceParameterEviniceStorageEviniceConstantEvinicePackedValueEviniceUnpackedValueEvinicePrintedValueEvi $fKnownValuea$fKnownCValuea$fNoOperationa$fNoContractTypea $fNoBigMapa$fCanHaveBigMapaEpdNone TrustEpNameHasDefEntryPointArgHasEntryPointArguseHasEntryPointArgGetEntryPointArgCustom EntryPointRef CallDefaultCallNoExplicitDefaultEntryPointGetDefaultEntryPointArgGetEntryPointArgLookupParameterEntryPointAllParameterEntryPointsParameterDeclaresEntryPointsParameterHasEntryPointsParameterEntryPointsDerivationEpConstructionRes EpConstructedEpConstructionFailedRequireAllUniqueEntryPointsEntryPointsDerivationEpdAllEntryPointsEpdLookupEntryPointepdNotesepdCallparameterEntryPointsToNotesparameterEntryPointCallparameterEntryPointCallDefaulteprNameparameterEntryPointCallCustomflattenEntryPoints#$fHasEntryPointArgkcpTrustEpNamearg$$fEntryPointsDerivationTYPEEpdNonecp($fHasEntryPointArgTYPEcpEntryPointRefargFromContractReffromContractAddr ToContractRef toContractRef ToAddress toAddressFutureContractfutureContractAddressListembodyFutureContractconvertContractRef$fToAddressContractRef$fToAddressFutureContract$fToAddressEpAddress$fToAddressAddress$fToContractRefcpAddress$fToContractRefcpEpAddress$fToContractRefcpFutureContract$fToContractRefcpContractRef$fFromContractRefcpAddress$fFromContractRefcpEpAddress!$fFromContractRefcpFutureContract$fFromContractRefcpContractRef$fGenericFutureContract$fIsoValueFutureContractUnaryArithOpHsUnaryArithResHs ArithOpHs ArithResHs$fArithOpHsLsrNaturalNatural$fArithOpHsLslNaturalNatural$fArithOpHsXorBoolBool$fArithOpHsXorNaturalNatural$fArithOpHsAndBoolBool$fArithOpHsAndNaturalNatural$fArithOpHsAndIntegerNatural$fArithOpHsOrBoolBool$fArithOpHsOrNaturalNatural$fArithOpHsMulMutezNatural$fArithOpHsMulNaturalMutez$fArithOpHsMulIntegerInteger$fArithOpHsMulNaturalNatural$fArithOpHsMulIntegerNatural$fArithOpHsMulNaturalInteger$fArithOpHsSubMutezMutez $fArithOpHsSubTimestampTimestamp$fArithOpHsSubTimestampInteger$fArithOpHsSubIntegerInteger$fArithOpHsSubNaturalNatural$fArithOpHsSubIntegerNatural$fArithOpHsSubNaturalInteger$fArithOpHsAddMutezMutez$fArithOpHsAddIntegerTimestamp$fArithOpHsAddTimestampInteger$fArithOpHsAddIntegerInteger$fArithOpHsAddNaturalNatural$fArithOpHsAddIntegerNatural$fArithOpHsAddNaturalInteger$fUnaryArithOpHsGeInteger$fUnaryArithOpHsLeInteger$fUnaryArithOpHsGtInteger$fUnaryArithOpHsLtInteger$fUnaryArithOpHsNeqInteger$fUnaryArithOpHsEq'Integer$fUnaryArithOpHsNotBool$fUnaryArithOpHsNotNatural$fUnaryArithOpHsNotInteger$fUnaryArithOpHsNegNatural$fUnaryArithOpHsNegInteger$fUnaryArithOpHsAbsInteger lPackValue lUnpackValueParameterWrapperunParameterWraper$fWrappedParameterWrapper)$fParameterHasEntryPointsParameterWrapper2$fEntryPointsDerivationTYPEPwDerivParameterWrapper$fGenericParameterWrapper$fIsoValueParameterWrapperLambda&%>:-> LorentzInstrunLorentzInstrFII iGenericIfiAnyCodeiNonFailingCode iMapAnyCode#parseLorentzValuetransformStringsLorentztransformBytesLorentzoptimizeLorentzWithConfoptimizeLorentz $fMonoid:->$fSemigroup:->$fBuildableParseLorentzError $fShow:->$fEq:->$fShowParseLorentzError$fEqParseLorentzError ZipInstrsZipInstr ZippedStackzipInstr unzipInstr zippingStackunzippingStack $fIsoValue:-> $fZipInstr: $fZipInstr:0 $fZipInstr[] GHasTypeAnn gGetTypeAnn HasTypeAnn getTypeAnn$fHasTypeAnn:->$fHasTypeAnnOperation'$fHasTypeAnn[]$fHasTypeAnnSet$fHasTypeAnnBigMap$fHasTypeAnnMap$fHasTypeAnnContractRef$fHasTypeAnnSignature$fHasTypeAnnPublicKey$fHasTypeAnnTimestamp$fHasTypeAnnKeyHash$fHasTypeAnnEpAddress$fHasTypeAnnAddress$fHasTypeAnnMutez$fHasTypeAnnByteString$fHasTypeAnnBool$fHasTypeAnnMText$fHasTypeAnnNatural$fHasTypeAnnInteger$fHasTypeAnnMaybe$fHasTypeAnnNamedF$fHasTypeAnnNamedF0$fGHasTypeAnnK1$fGHasTypeAnn:*:$fGHasTypeAnn:+:$fGHasTypeAnnM1$fGHasTypeAnnU1 $fHasTypeAnna EpdRecursiveEpdPlain $fGEntryPointsNotesdeepEPLeaf:*:$fGEntryPointsNotesdeepEPLeafU1$fGEntryPointsNotesdeepepM1$fGEntryPointsNotesTrueEPNodeM1 $fGEntryPointsNotesdeepEPNode:+:$fGEntryPointsNotesdeepepM10$fGEntryPointsNotesdeepepK1)$fEntryPointsDerivationTYPEEpdRecursivecp%$fEntryPointsDerivationTYPEEpdPlaincp$fGEntryPointsNotesTrueEPLeafM1$fGEntryPointsNotesFalseepM1compileLorentzcompileLorentzContractinterpretLorentzInstrinterpretLorentzLambdaanalyzeLorentzprintLorentzValueprintLorentzContract TestScenarioshowTestScenario$fGenericParameter$fIsoValueParameternonZeroLorentzFunctorlmapConstraintDIPNLorentznopdropdropNdupswapdigPeanodigdugpushsomenoneunitifNonepaircarcdrleftrightifLeftnilconsifConssizeemptySetemptyMap emptyBigMapmapitermemgetupdateif_looploopLeftlambdaexecexecuteapplydip dipNPeanodipNfailWithcastpackunpackconcatconcat'sliceaddsubrsubmuledivabsneglsllsrorandxornotcompareeq0neq0lt0gt0le0ge0intself selfCallingcontractcontractCallingcontractCallingUnsafeepAddressToContracttransferTokens setDelegatecreateContractimplicitAccountnowamountbalanceblake2B stepsToQuotasourcesenderaddresschainIdframedfailingWhenPresent updateNew$fLorentzFunctorMaybe$fNonZeroNatural$fNonZeroIntegerdupTdipTdropT$fDupTorigSta:$fDupTorigSta:0$fDupTorigSta[]$fDipTorigSta:dipInpdipOutout1$fDipTorigSta:dipInpdipOutout$fDipTorigSta[]dipInpdipOutoutstackRef testAssert Entrypoint_ Entrypoint Coercible_ CanCastTo castDummyMichelsonCoercible forcedCoerce forcedCoerce_gForcedCoerce_ fakeCoerce coerceWrap coerceUnwraptoNamed fromNamed checkedCoercecheckedCoerce_checkedCoercing_allowCheckedCoerceToallowCheckedCoercefutureContractunFutureContract($fCanCastToTYPETYPEFutureContractAddress$fCanCastToTYPETYPE:->:->$fCanCastToTYPETYPE(,)(,)$fCanCastToTYPETYPE[][]$fCanCastTokkaaExtensibleHasDocextensibleDocNameextensibleDocDependenciesextensibleDocMdDescriptionExtConversionErrorConstructorIndexNotFoundArgumentUnpackFailedWrapExtCExtVal ExtensibletoExtVal fromExtValwrapExt$fWrappedExtensible$fWrapExtNoFields$fWrapExtOneField$fBuildableExtConversionError$fGExtValkt:+:$fGExtValTYPEtM1$fGExtValTYPEtM10 $fGExtValktM1$fTypeHasDocExtensible$fDocumentCtorCtor$fGenericExtensible$fEqExtensible$fShowExtensible$fIsoValueExtensible$fEqExtConversionError$fShowExtConversionErrorCaseTC CaseArrow/-> CaseClauseLHasFieldsOfType:= NamedFieldHasFieldOfTypeHasFieldtoField toFieldNamedgetField getFieldNamedsetField modifyField construct constructT fieldCtorwrap_case_caseT unwrapUnsafe_$fCaseArrownamebodyCaseClauseLDocTest dtDeclLocdtDescdtSuite mkDocTestexcludeDocTestexcludeDocTests runDocTestsexpectDocTestFailureforEachContractLayertestContractNameAtToptestDocNotEmptytestNoAdjacentDescriptions testDocBasic$fBuildableDocTest $fShowDocTest $fEqDocTestdocdocGroup contractNamebuildLorentzDocrenderLorentzDoccutLorentzNonDoc$fTypeHasDoc:->PickMarkedFieldsGetUStoreFieldMarkerGetUStoreFieldGetUStoreValue GetUStoreKey GetUStoreFSMarkerFSValueMSValueMSKey ElemSignature MapSignatureFieldSignatureKnownUStoreMarkerShowUStoreFieldmkFieldMarkerUKeyUMarkerPlainField UStoreFieldUStoreMarkerTypeUStoreFieldExt unUStoreField|~> UStoreSubMapunUStoreSubMapUStoreunUStore mkFieldUKey$fTypeHasDocUStore$fWrappedUStore$$fKnownUStoreMarkerUMarkerPlainField $fEqUStore $fShowUStore$fGenericUStore$fDefaultUStore$fSemigroupUStore$fMonoidUStore$fIsoValueUStore$fMemOpHsUStore$fGetOpHsUStore$fUpdOpHsUStore $fShow|~>$fEq|~> $fDefault|~>$fShowUStoreFieldExt$fEqUStoreFieldExt CoverDiffMany CoverDiff DiffCoverageDcAddDcRemoveRequireEmptyDiffShowDiff BuildDiffAllUStoreFieldsFLinearizeUStoreFLinearizeUStoreDiffItemDiffKindToAddToDel FieldInfoUStoreFieldsAreUnique liftUStore unliftUStore$fGenericMyStoreTemplate$fGenericMyStoreTemplateBig MigrationAtommaNamemaScript maActionsDescDMigrationActionDesc manActionmanField manFieldTypeDMigrationActionType DAddAction DDelActionMigrationScript_MigrationScriptToMigrationScriptFromMigrationScriptunMigrationScriptUStore_ SomeUTemplatemanualWithOldUStoremanualWithNewUStoremanualMapMigrationScriptmanualConcatMigrationScriptsattachMigrationActionName$fCanCastToTYPETYPEUStoreUStore1$fCanCastToTYPETYPEMigrationScriptMigrationScript$fTypeHasDocMigrationScript$fWrappedMigrationScript$fBuildableDMigrationActionType$fDocItemDMigrationActionDesc$fShowMigrationScript$fGenericMigrationScript$fIsoValueMigrationScript$fShowDMigrationActionType$fShowDMigrationActionDesc$fShowMigrationAtomUStoreMigrationCompiledcompiledMigrationContentMigrationBatchingMUStore MUStoreUnsafeMigrationBlocksUStoreMigrationmaActionsDescLmaNameL maScriptLmigrationToLambdamapMigrationCodeformMigrationAtom mbBatchesAsIs mbNoBatchingmkUStoreBatchedMigrationmkUStoreMigrationcompileMigrationmigrationToScriptsmigrationToScriptsListmigrationToScriptImigrationToScriptmigrationToInfomigrationStagesNumbuildMigrationPlan$fGenericMUStore$fIsoValueMUStore SlBatchInfoslbiType slbiActions SlBatchTypeSlbtData SlbtLambda SlbtCustom SlbtUnknownmbSeparateLambdas$fBuildableSlBatchInfo$fShowSlBatchType$fEqSlBatchTypeDocumentEntryPointsDeriveCtorFieldDocderiveCtorFieldDocDEntryPointArgepaArg epaBuildingParamBuildingStep pbsEnglish pbsHaskell pbsMichelsonPlainEntryPointsKind DEntryPointdepNamedepSubdiEntryPointToMarkdownmkDEntryPointArgSimpleclarifyParamBuildingSteps entryCase_ entryCase$fDocItemDEntryPoint$fDocItemDEntryPointArg$fDeriveCtorFieldDocOneField$fDeriveCtorFieldDocNoFields$fGDocumentEntryPointskindM1$fGDocumentEntryPointskind:+:$fGDocumentEntryPointskindM10testDeclaresParametertestEachEntrypointIsDescribedtestLorentzDoc FailUsingArgCustomErrorNoIsoValueDThrowsDErrorCustomErrorHasDoccustomErrDocMdCausecustomErrDocMdCauseInEntrypointcustomErrClasscustomErrArgumentSemantics ErrorClassErrClassActionExceptionErrClassBadArgumentErrClassContractInternalErrClassUnknownRequireNoArgError CustomErrorceTagceArgErrorArgUnspecifiedError ErrorHasDoc errorDocNameerrorDocMdCauseerrorDocMdCauseInEntrypointerrorDocHaskellRep errorDocClasserrorDocDependenciesIsError errorToVal errorFromVal isoErrorToValisoErrorFromVal failUsingfailUnexpected failCustom failCustom_ typeDocMdDescriptionReferToErrorerrorsDocumentationcustomErrorToValcustomErrorFromValderiveCustomError failUsingArg$fEq->$fIsoValueCustomError$fBuildableErrorClass$fErrorHasDocTYPE->!$fErrorHasDocTYPEUnspecifiedError$fErrorHasDocTYPE()$fErrorHasDocTYPEMText $fIsError->$fIsErrorUnspecifiedError $fIsError()$fIsErrorMText$fErrorHasDocTYPECustomError$fIsErrorCustomError$fDocItemDError $fOrdDError $fEqDError$fDocItemDThrows $fEqDThrows$fGenericUnspecifiedError$fIsoValueUnspecifiedError$fShowCustomError$fEqCustomError VoidResult unVoidResultVoid_ voidParam voidResProxyView viewParamviewCallbackTo mapInsert mapInsertNew deleteMapeqneqgtlegeltifEq0ifNeq0ifLt0ifGt0ifLe0ifGe0ifEqifNeqifLtifGtifLeifGefail_assert assertEq0 assertNeq0 assertLt0 assertGt0 assertLe0 assertGe0assertEq assertNeqassertLtassertGtassertLeassertGe assertNone assertSome assertLeft assertRight assertUsingdropXcloneXduupXframedNpapairppaiirunpaircdarcddrcaarcadrsetCarsetCdrmapCarmapCdrifRightifSome setInsert setInsertNew setDeletebuildViewTuple buildViewmkViewwrapView unwrapViewview_mkVoidvoid_addressToEpAddresspickFutureContractpushContractRef $fCloneXSas $fCloneXZas$fDuupX[][]Ssas1tail$fDuupXkkS:as1tail$fDuupXkkSsas1tail$fMapInstrsBigMap$fMapInstrsMap$fBuildableView$fBuildableView0$fTypeHasDocView$fBuildableVoid_$fTypeHasDocVoid_$fIsoValueVoidResult$fErrorHasDocTYPEVoidResult$fIsErrorVoidResult$fTypeHasDocVoidResult$fEqView $fShowView $fGenericView$fIsoValueView$fGenericVoid_$fIsoValueVoid_$fGenericVoidResult$fEqVoidResultHasUStoreForAllIn HasUField HasUStorepackSubMapUKeyunsafeEmptyUStore ustoreMem ustoreGet ustoreUpdate ustoreInsertustoreInsertNew ustoreDelete ustoreToFieldustoreGetFieldustoreSetFieldustoreRemoveFieldUnsafe$fKnownUStoreMarkerMarker1$fGenericMyStoreTemplate2$fIsoCValueMyNatural$fIsoValueMyNatural$fGenericMyStoreTemplate3MigrationFinishCheckPositionmigrationFinishmigrateCoerceUnsafemigrateGetFieldmigrateAddFieldmigrateRemoveFieldmigrateExtractFieldmigrateOverwriteFieldmigrateModifyFieldmuBlock muBlockNamed<-->$: mustoreToOld-$fMigrationFinishCheckPositionMigrationBlocks!$fMigrationFinishCheckPosition:->UStoreConversible UStoreContentmkUStoreustoreDecompose fillUStorefillUStoreMigrationBlockmigrateFillUStoreustoreDecomposeFull$fGUStoreConversibleM1$fGUStoreConversibleM10$fGUStoreConversibleU1$fGUStoreConversible:*:$fGUStoreConversibleV1$fGUStoreConversible:+:$fGUStoreConversibleM11$fGUStoreConversibleM12$fGUStoreConversibleM13$fUStoreConversibletemplateUParamLinearizedUParamLinearize CaseUParamUParamFallbackEntryPointsImplEntryPointLookupErrorNoSuchEntryPoint UnpackUParam unpackUParamConstrainedSomeRequireUniqueEntryPointsLookupEntryPointUParam_ SomeInterfaceUParam UParamUnsafe?:EntryPointKindmkUParam unwrapUParamuparamFallbackFail caseUParam caseUParamT uparamFromAdt pbsUParam/$fCustomErrorHasDoc"uparamArgumentUnpackFailed"+$fCustomErrorHasDoc"uparamNoSuchEntryPoint"$fBuildableCustomError$fBuildableCustomError0$fTypeHasDocUParam$fWrappedUParam$fCanCastToTYPETYPEUParamUParam$fBuildableConstrainedSome$fShowConstrainedSome$fCaseArrowname'bodyCaseClauseU $fBuildableEntryPointLookupError$fUnpackUParamc:$fUnpackUParamc[] $fCaseUParam:$fCaseUParam[]$fGUParamLinearizeM1$fGUParamLinearizeM10$fGUParamLinearizeM11$fGUParamLinearize:+:$fGUParamLinearizeM12$fGenericUParam $fEqUParam $fShowUParam$fIsoValueUParam$fGenericEntryPointLookupError$fEqEntryPointLookupError$fShowEntryPointLookupErrorStorageContains~>StoreHasSubmapstoreSubmapOpsStoreSubmapOpssopMemsopGet sopUpdate sopDelete sopInsert StoreHasField storeFieldOps StoreFieldOps sopToField sopSetField stToField stGetField stSetFieldstMemstGetstUpdatestDeletestInsert stInsertNewstoreFieldOpsADTstoreFieldOpsDeeperstoreSubmapOpsDeeperstoreSubmapOpsReferTostoreFieldOpsReferTocomposeStoreFieldOpscomposeStoreSubmapOps$fStoreHasSubmapMapnamekeyvalue"$fStoreHasSubmapBigMapnamekeyvalue#$fStoreHasSubmapUStoremnamekeyvalue$fStoreHasFieldUStorefnameftype StorePieceCStorageSkeletonsMapsFieldsHasStoreForAllInHasStore StoreDeleteC StoreInsertC StoreUpdateC StoreGetC StoreMemC GetStoreValue GetStoreKey|->StoreunStorestoreMemstoreGet storeUpdate storeInsertstoreInsertNew storeDelete storageUnpack storagePack storageMem storageGet storageInsertstorageInsertNew storageDelete storePiecestoreKeyValueList storeLookup!$fStoreHasSubmapStorenamekeyvalue+$fStoreHasSubmapStorageSkeletonnamekeyvalue($fStoreHasFieldStorageSkeletonfnameftype $fEqStore $fShowStore$fDefaultStore$fSemigroupStore $fMonoidStore$fIsoValueStore $fGeneric|-> $fIsoValue|->$fIsoValueMyStoreTemplate$fIsoValueMyStoreTemplate2$fGenericMyNatural$fIsoValueMyStoreTemplate3$fIsoValueMyStoreTemplateBig$fEqStorageSkeleton$fShowStorageSkeleton$fGenericStorageSkeleton$fDefaultStorageSkeleton$fIsoValueStorageSkeleton ConditionHoldsIsSomeIsNoneIsLeftIsRightIsConsIsNilIsZero IsNotZeroIsEqIsNeqIsLtIsGtIsLeIsGe>> ifThenElse ErrorTagMapgatherErrorTagsaddNewErrorTagsbuildErrorTagMapapplyErrorTagMapuseNumericErrorserrorFromValNumeric%$fCustomErrorHasDoc"senderIsNotAdmin"ImportContractErrorICEUnexpectedParamTypeICEUnexpectedStorageTypeICEParse ICETypeChecktestTreesWithContracttestTreesWithContractLtestTreesWithUntypedContracttestTreesWithTypedContractconcatTestTreesspecWithContractspecWithContractLspecWithTypedContractspecWithUntypedContract readContractimportContractimportUntypedContract$fExceptionImportContractError$fBuildableImportContractError$fShowImportContractError$fEqImportContractErrorrunGen$fArbitraryUStoreFieldExt$fArbitrary|~>$fArbitraryComparable$fToADTArbitraryComparable $fArbitraryCT$fToADTArbitraryCT $fArbitraryT$fToADTArbitraryT$fArbitraryType$fToADTArbitraryType$fArbitraryElt$fToADTArbitraryElt$fToADTArbitraryValue'$fArbitraryInstrAbstract$fToADTArbitraryInstrAbstract$fArbitraryContract'$fToADTArbitraryContract'$fArbitraryAnnotation$fToADTArbitraryAnnotation$fToADTArbitraryMutez$fArbitraryExpandedOp$fToADTArbitraryExpandedOp$fArbitraryInstrCallStack$fToADTArbitraryInstrCallStack$fArbitraryLetName$fToADTArbitraryLetName$fArbitrarySrcPos$fToADTArbitrarySrcPos$fArbitraryPos$fToADTArbitraryPos$fArbitraryExtInstrAbstract$fArbitraryStackTypePattern$fArbitraryTyVar$fArbitraryVar$fArbitraryInternalByteString tOriginate lOriginatelOriginateEmpty tTransfer lTransferlCalllCallEPlCallDeflExpectStorageUpdatelExpectBalancetExpectStorageConstlExpectStorageConstlExpectMichelsonFailedlExpectFailWith lExpectErrorlExpectErrorNumericlExpectCustomErrorlExpectCustomErrorNumericlExpectCustomError_lExpectCustomErrorNumeric_lExpectConsumerStoragelExpectViewConsumerStorage_rcWillNeedParens-wl-pprint-text-1.2.0.0-L6i9Q0yxJZoBCBd4YxCMOZText.PrettyPrint.Leijen.TextDocData.Text.Internal.BuilderBuilderdoRender(QuickCheck-2.13.2-1FftnVviu6BCWJanU0jy5VTest.QuickCheck.PropertyChar SomeSingTSomeSingData.Typeable.InternalTypeable SomeSingCTtoSingCTtoSingfromSingtoSingT D:R:SingT0 D:R:SingCT0FailOnNonComparableFailOnContractFoundEachContainsContract ContainsOpforbiddenOpEviforbiddenContractTypeEviversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameNonEmpty3first-class-families-0.6.0.0-57cXSJxeSMHIB4QK5uTBck Fcf.UtilsTyEqmdEscapeAnchorRequireLongerOrSameLength'RequireLongerThan'OfLengthWithTail Data.Data)tasty-ant-xml-1.1.6-jAhJ3bKcip1MKdu90sazpTest.Tasty.Runners.AntXML antXMLRunnerinvalidMCharErrorSecretKeyEd25519SecretKeySecp256k1 SecretKeyP256Word chainIdPrefixgcastverifyParamNoteswithEpLiftSequence DocItemPosdocItemToMarkdownFulldocItemsOrderByIddocBlockToMarkdowndocItemToBlockGeneralDGitRevisionInfoGHC.ShowShowceaBottomToTopanalyzeInstrFailureGInstrCaseBranch GInstrCase GInstrWrapLNRequireFound GLookupNamedGetNamedLookupNamedResultfailWithWrongCtorGInstrConstructGInstrSetField GInstrGetNamedF GAccessField GLooseSumPolyCTypeHasDocCGProductHasDoc DocTypeRepLHSmapADTRepFieldsbuildFieldNamemodifyInstrAllDoctypeCheckMapVal checkVarscheckFncheckStackTypecreateStackRef typeCheckNEtypeCheckInstr genericIfgenesisAddressesNumgenesisSecrets addAddresssetStorageValue setBalanceLetletInneraddLetletName TaggedDecoder decodeWithTagtdTag tdDecoder?getByteStringCopygetRemainingByteStringCopy expectTag unknownTag expectDescTag manyForcedmany#: unpackDecoder decodeLength decodeAsList decodeIntdecodeTypeCheckLam decodeNoAnn decodeAnns encodeAsList encodeList encodeString encodeBytes encodeMap encodeNumeric encodeInstrs encodeInstrencodeWithAnnsencodeNotedInstrpushPacklinearizeAndReapplyfixpoint applyOnceadapter whileApplies annsOpSize runInstrImpl runArithOp withStackElemGHC.IO.Handle.FDstdinexecutorIO executeOneOp_isInterpreterLog_isExecutorResult_isContractsNames _isSenderExecutorResOrError ScenarioError ValidatedScenarioBranchName/hspec-expectations-0.8.2-JGqzAaMw3jpJhPKqSPpGFATest.Hspec.ExpectationsregisterInterpretationIfNeeded putResultemptyScenarioBranchappendScenarioBranchFailWithStringFailWithConstantPairFailWithStackValueConstantScope'GetParameterEpDerivationData.Semigroup.InternalEndoParseLorentzError##GEntryPointsNotesEntryPointsNotesgMkEntryPointsNotesAllEntryPoints BuildEPTreeEPTreemkEntryPointsNotesmkEpLiftSequenceDipTDupT Castable_ DocumentCtorGExtVal GGetCtorsEnumerateCtorsCtorKindCtor LookupCtorWrapExt packForWrap+tasty-hunit-0.10.0.2-EbAy6CHicjgGi2eTgvXXpNTest.Tasty.HUnittestCase forEachLayer UStoreMarkerDiffCoverageItem LiftToDiffRequireFieldName UStoreFields_sampleWithMyStoremanualWithUStore nubCountingGDocumentEntryPointsgDocumentEntryPointsdocumentEntryPoints CurrentParamCustomErrorReppickFirstSentenceerrorTagToMText MapInstrs mapUpdateConstraintDuupXLorentzDuupXConstraint'_sample7MyStoreTemplate _sample7'MyStoreTemplateBigRequireBeInitialGUStoreConversible gUstoreToValgUstoreFromValgUstoreToScript mkUStoreRecstoreDecomposeRec fillUStoreRecGUParamLinearizecaseUParamUnsafe CaseClauseUCtorNameToLabelGetStoreCtorsNumCtorIdxD:R:ErrorArg"senderIsNotAdmin"GHC.IO.Exception IOException genRareTypegenRareT