!Lɮ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                      ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                             ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E!F!G!H!I!J!K!L!M!N!O!P!Q!R!S!T!U"V"W"X"Y"Z#[#\#]#^#_#`#a#b#c#d#e#f#g#h#i#j#k#l#m#n#o#p#q#r#s#t#u#v#w#x#y#z#{#|#}#~#################################$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&& & & & & &&&&&&&&&&&&&&&&&&& &!&"&#&$&%&&&'&(&)&*&+&,&-&.&/&0&1&2&3&4&5&6&7&8&9&:&;&<&=&>&?&@&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({(|(}(~(((((())))))))))))))))))))*+++++++++++++++++++++++++++++++++++,,-------------------------------------------------------------     .......... !"#$%&'()*+,-./01234/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 [ \0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~000000000000000000001112222222333333333333333349None5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmRSlorentz1Constraint applied to any part of parameter type.ZNote that you don't usually apply this constraint to the whole parameter, consider using  5 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.lorentz/Ensure given type does not contain "operation". lorentz2Gathers constraints, commonly required for values.%          % None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm\Olorentz%Ensure that given type is a sum type.LThis helps to prevent attempts to apply a function to, for instance, a pair.lorentzJUsed to understand whether a type can potentially declare any entrypoints.lorentz[A special type which wraps over a primitive type and states that it has entrypoints (one).Assuming that any type can have entrypoints makes use of Lorentz entrypoints too annoying, so for declaring entrypoints for not sum types we require an explicit wrapper. None5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm$"lorentzsNo entrypoints declared, parameter type will serve as argument type of the only existing entrypoint (default one).lorentz$This wrapper allows to pass untyped F and bypass checking that entrypoint with given name and type exists.!lorentz". constraint specialized to default entrypoint."lorentzWhen 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.#lorentz;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.$lorentzUniversal entrypoint lookup.%lorentz3Constraint on type-level entrypoint name specifier.&lorentzWhich entrypoint to call.iWe intentionally distinguish default and non-default cases because this makes API more details-agnostic.'lorentzHCall the default entrypoint, or root if no explicit default is assigned.(lorentzCall 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.)lorentz Similar to *g, but in a version which the compiler can work with (and which produces errors confusing for users :/)*lorentz6Ensure that there is no explicit "default" entrypoint.+lorentz:Get type of entrypoint with given name, fail if not found.,lorentz:Get type of entrypoint with given name, fail if not found.-lorentz#Lookup for entrypoint type by name.4Does not treat default entrypoints in a special way..lorentz+Get all entrypoints declared for parameter./lorentz Version of 2e which we actually use in function signatures. When given type is sum type or newtype, we refer to 29, otherwise we suppose that no entrypoints are declared.0lorentz$Parameter declares some entrypoints.This is a version of 1_ which we actually use in constraints. When given type is a sum type or newtype, we refer to 15 instance, otherwise this instance is not necessary.1lorentz+Which entrypoints given parameter declares.GNote that usually this function should not be used as constraint, use 0 for this purpose.3lorentz*Result of entrypoint lookup at term level.6lorentz0Ensure that all declared entrypoints are unique.8lorentzMDefines 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 T arms should be callable, though you can put this burden on user if very necessary.9lorentzbName 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.:lorentz Get entrypoint argument by name.;lorentzJConstruct parameter annotations corresponding to expected entrypoints set.IThis method is implementation detail, for actual notes construction use ?./TODO [#35]: Should also return field annotation<lorentzConstruct entrypoint caller.AThis does not treat calls to default entrypoint in a special way.HThis method is implementation detail, for actual entrypoint lookup use @.=lorentz Version of ;o which we actually use in code. It hides derivations stuff inside, and treats primitive types specially like / does.>lorentz Version of <o which we actually use in code. It hides derivations stuff inside, and treats primitive types specially like / does.?lorentz'Derive annotations for given parameter.@lorentz!Prepare call to given entrypoint.kThis does not treat calls to default entrypoint in a special way. To call default entrypoint properly use A.AlorentzCall the default entrypoint.BlorentzCall root entrypoint safely.DlorentzUniversal entrypoint calling.ElorentzZFlatten 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.) !"#$%&'()*+,-./0123456789:;<=>?@ABCDE)89:;<3456120/=>.-?,@+AE*)B&'(%C$ "#!D7 None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmIlorentz-Constraint applied to a whole parameter type.II6None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm%     INone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmJlorentzOWrap parameter into this to locally assign a way to derive entrypoints for it.JKLJKLNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmxRSRSNone5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmqƍ TlorentzLifted .WlorentzLifted .XlorentzLifted .YlorentzLifted .\lorentzLifted ._lorentzLifted .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.`lorentzLifted .blorentzLifted .elorentz-A useful property which holds for reasonable  instances.It's a separate thing from b because it mentions b type parameter.florentzLifted .TUVWXYZ[\]^_`abdcefgfgbdc`a_\]^YZ[XWTUVeNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm "!  $#  "! $#  None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm5lorentzConvert something from  ContractAddr in Haskell world.lorentzConvert something to  in Haskell world.lorentzHConvert something referring to a contract (not specific entrypoint) to  in Haskell world.lorentzConvert something to  in Haskell world.]Use this when you want to access state of the contract and are not interested in calling it.lorentz!Address associated with value of  contract arg type. Places where J can appear are now severely limited, this type gives you type-safety of  but still can be used everywhere. This type is not a full-featured one rather a helper; in particular, once pushing it on stack, you cannot return it back to Haskell world.~Note that it refers to an entrypoint of the contract, not just the contract as a whole. In this sense this type differs from . Unlike with ~, having this type you still cannot be sure that the referred contract exists and need to perform a lookup before calling it.lorentzHAddress which remembers the parameter type of the contract it refers to.It differs from Michelson's contract type because it cannot contain entrypoint, and it always refers to entire contract parameter even if this contract has explicit default entrypoint.lorentzTurn  to  in Haskell world.This is an analogy of address to contractl convertion in Michelson world, thus you have to supply an entrypoint (or call the default one explicitly).lorentzSpecification of  callTAddress to call the default entrypoint.R&'(R&'(None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmYlorentz;Errors that can happen during parsing into a Lorentz value.lorentz Alias for 3, seems to make signatures more readable sometimes.:Let's someday decide which one of these two should remain.lorentzAAlias for instruction which hides inner types representation via T.lorentz4Wrap Lorentz instruction with variable annotations, annotsD list has to be non-empty, otherwise this function raises an error.lorentz Version of / which performs some optimizations immediately.lorentz`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).lorentzLorentz version of .lorentzLorentz version of .2118None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmlorentzLike  but for Lorentz types.lorentzLike 0, but for Lorentz types.None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmkNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmlorentz Version of  which accepts no argument.lorentz 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.None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmlorentzLifted  UnaryAithOp.lorentzLifted AithOp.None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmBlorentz!Require several stacks to comply  constraint.lorentz"Zipping stack into tuple and back.lorentz-A type which contains the whole stack zipped.lorentz#Fold given stack into single value.lorentz'Unfold given stack from a single value.lorentz'Flatten both ends of instruction stack.lorentz)Unflatten both ends of instruction stack.lorentzHSuch definition seems the only possible one we can support efficiently.None5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmX      None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm;lorentzGeneric traversal for .lorentzReturns: 1. Notes corresponding to this level; 2. Field annotation for this level (and which should be used one level above).lorentz6Fetches information about all entrypoints - leaves of  tree.lorentz6Fetches information about all entrypoints - leaves of  tree.lorentz"Traverses sum type and constructs 7 which report constructor names via field annotations.lorentzBuild  by parameter type.lorentzEntrypoints tree - skeleton on  tree later used to distinguish between constructors-entrypoints and constructors which consolidate a whole pack of entrypoints.lorentz6We are in the intermediate node and need to go deeper.lorentzWe reached entrypoint argument.lorentzIWe reached complex parameter part and will need to ask how to process it.(lorentz Extension of *: on parameters being defined as several nested datatypes.MIn particular, it will traverse the immediate sum type, and require another 1 for the inner complex datatypes. Only those inner types are considered which are the only fields in their respective constructors. Inner types should not themselves declare default entrypoint, we enforce this for better modularity. Each top-level constructor will be treated as entrypoint even if it contains a complex datatype within, in such case that would be an entrypoint corresponding to intermediate node in or tree. Comparing to )M this gives you more control over where and how entrypoints will be derived.)lorentz Extension of *: on parameters 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.)If some entrypoint arguments have custom v instance, this derivation way will not work. As a workaround, you can wrap your argument into some primitive (e.g. :!).*lorentzImplementation of 1l 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 '' will designate the default entrypoint.lorentzAMakes up notes with proper field annotations for given parameter.lorentz=Makes up a way to lift entrypoint argument to full parameter.()**)(7None5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm=) !"#$&'()*+,-.012689:;<?@ABCDEJKL()*)89:;<120.-?E,@+A*)B&'(C$"#! D6*)(JKLNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmNf:lorentzCFlag which defines, whether compiled Michelson contract will have CASTt (which drops parameter annotations) as a first instruction. Note, that when flag is false, there still can be no CAST3 (in case when parameter type has no annotations).;lorentzFor use outside of Lorentz.<lorentz Version of ;< specialized to instruction corresponding to contract code.=lorentz Version on < which accepts CompilationOptions.Note that compiled contract can be ill-typed in terms of Michelson code when some of the compilation options are used (e.g. when coDoInitialCast is False, resulted contract can be ill-typed). However, compilation with defaultCompilationOptions should be valid.>lorentz3Interpret a Lorentz instruction, for test purposes.?lorentzLike >9, but works on lambda rather than arbitrary instruction.@lorentzLorentz version of analyzer. 89:;<=>?@ 89:;<=>?@None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmRXAlorentz.Pretty-print a Haskell value as Michelson one.Blorentz4Pretty-print a Lorentz contract into Michelson code.ABABNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm] Clorentz_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.Dlorentz*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`CDCDNone4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmGlorentz(Retain the value only if it is not zero.lorentz%Something coercible to 'TAddress cp'.Mlorentz Drop top n elements from the stack.Plorentz Version of QG which uses Peano number. It is inteded for internal usage in Lorentz.olorentz Similar to n@ 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.rlorentz Version of sG which uses Peano number. It is inteded for internal usage in Lorentz.lorentzCast something appropriate to '. TODO [TM-280]: try to move somewherelorentz(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 .lorentzFMake 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.lorentz-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 .lorentz<Make a reference to a contract, maybe a specific entrypoint.fWhen calling this function, make sure that parameter type is known. It's recommended that you supply 2 with a concrete parameter as the stack argument.lorentzSpecialized 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 C to construct .lorentz Version of N instruction which may accept address with already specified entrypoint name.TAlso you cannot specify entrypoint name here because this could result in conflict.lorentz Similar to  , works with .=Validity of such operation cannot be ensured at compile time.lorentz-Execute given instruction on truncated stack.ZThis instruction requires you to specify the piece of stack to truncate as type argument.lorentzHelper instruction.jChecks whether given key present in the storage and fails if it is. This instruction leaves stack intact.lorentzLike i<, but throw an error on attempt to overwrite existing entry.fGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~fKLMNOPQRSTUVWXYZ[\]^_abcdefghij`klmnopqJrstuvwxyz{|}~HIGNone5!"#$%&'*,-.012456789;=>?@ACHMNPSUVX_`befgkmlorentz<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.lorentz9Allows duplicating stack elements referring them by type.lorentz3Duplicate an element of stack referring it by type.IIf stack contains multiple entries of this type, compile error is raised.lorentzFDip 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.lorentz2Remove element with the given type from the stack.None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmlorentzCoercions between a to b are permitted and safe.lorentzCoercion from a to b is permitted and safe.lorentzExplicitly allowed coercions.lorentzEAn optional method which helps passing -Wredundant-constraints check.lorentz9Whether two types have the same Michelson representation.lorentzCoercion 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.lorentzBConvert 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.lorentz'Convert between two stacks via failing.lorentzSpecialized version of coerce_ to wrap into a haskell newtype.lorentzSpecialized version of coerce_ to unwrap a haskell newtype.lorentz"Lift given value to a named value.lorentzUnpack named value.lorentz)Coercion in Haskell world which respects .lorentzPCoerce between types which have an explicit permission for that in the face of  constraint.lorentz4Pretends that the top item of the stack was coerced.lorentzLocally provide given  instance.lorentzLocally provide bidirectional  instance.+*)+*)None5!"#$%&'*,-./012456789;=>?@AHMNPSUVX_`befgkmlorentz*Helper which documents single constructor.lorentz0Information to be provided for documenting some  x.lorentzImplementation for v of the corresponding  Extensible.lorentzImplementation for s of the corresponding  Extensible.lorentz!Overall description of this type.lorentz1Generic implementation of toExtVal and fromExtVallorentz?Having a sum-type, yields a type-level list of its constructorslorentzTransform list of  s to list of 2s, assigning numbers to elements starting from 0.lorentz>Finds the constructor's position and argument type by its namelorentz'Errors related to fromExtVal conversionlorentzqHelper typeclass which allows us to sanely handle cases of no-arg constructor and constructor with one argument.lorentz3Pack argument on top of the stack, if any required.lorentzConverts a value from a Haskell representation to its extensible Michelson representation (i.e. (Natural, Bytestring) pair).lorentzConverts 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.lorentzGWraps an argument on top of the stack into an Extensible representation None5!"#$%&'*,-.012456789;=>?@ACHMNPSUVX_`befgkmlorentzDProvides "case" arrow which works on different wrappers for clauses.lorentz#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.lorentzLorentz analogy of , it works on plain  types.lorentzShortcut for multiple  constraints.lorentzA pair of field name and type.lorentzLike &, but allows constrainting field type.lorentz%Allows field access and modification.lorentz]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.lorentzLike , but leaves field named.lorentzFExtract a field of a datatype, leaving the original datatype on stack.lorentzLike , but leaves field named.lorentzSet a field of a datatype.lorentz)Apply given modifier to a datatype field.lorentzIMake 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.lorentz Version of + which accepts tuple of field constructors.lorentz)Lift an instruction to field constructor.lorentz0Wrap entry in constructor. Useful for sum types.lorentz$Pattern match on the given sum type.You have to provide a ; containing case branches. To construct a case branch use  operator.lorentzLike ;, 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 89 and ensure that his tuple isn't bigger than generated instances, if so, he should probably extend number of generated instances.lorentz0Wrap entry in constructor. Useful for sum types."~"~00None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm lorentzPut a document item. lorentzpGroup documentation built in the given piece of code into block dedicated to one thing, e.g. to one entrypoint. lorentzCGive a name to given contract. Apply it to the whole contract code.lorentz1Leave 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.Sdefghijklmnopwvutsrqyx{z|}    S    {zwvutsrqyx|}lponmkjihgfed None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm8lorentz)Collect all fields with the given marker.lorentzGet kind of field.lorentz>Get type of plain field. This ignores marker with field type.lorentzGet type of submap value.lorentzGet type of submap key.lorentz9Get map signature from the constructor with a given name.lorentz-What was found on lookup by constructor name.$This keeps either type arguments of ) or &.lorentzhAllows to specify format of key under which fields of this type are stored. Useful to avoid collisions.lorentztDisplay type-level information about UStore field with given marker and field value type. Used for error messages. lorentz<By field name derive key under which field should be stored."lorentzSWhat do we serialize when constructing big_map key for accessing an UStore submap.$lorentz Just a plain field used as data.%lorentz,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).lorentzJust a servant type.&lorentz%Describes plain field in the storage.)lorentz-Describes one virtual big map in the storage.,lorentzGathers 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./lorentz Version of   which accepts label.0lorentz Shortcut for  @ which accepts not marker but store template and name of entry.  !"#$%&'()*+,-./0 ,-.)*+&'($%# /0"!!None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm5PElorentzApply multiple coverage steps.lorentzSingle piece of a coverage.FlorentzOApply given diff coverage, returning type of affected field and modified diff.GlorentzNCover the respective part of diff. Maybe fail if such action is not required.This type is very similar to Q, 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.JlorentzVHelper type family which dumps error message about remaining diff if such is present.Klorentz5Renders human-readable message describing given diff.Llorentz3Make up a migration diff between given old and new , templates.lorentzLift a list of T to Ps via attaching given Q.lorentzLHelper to make sure that datatype field is named and then extract this name.Mlorentz(Get only field names of UStore template.Olorentz>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.PlorentzSingle piece of a diff.Qlorentz%What should happen with a particular  UStoreItem.Tlorentz)Information about single field of UStore.EFGHIJKLMNOPQRSTTQRSPLKJONMGHIFE"None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmKlorentz)Get all fields names accessible in given , template.VlorentzLift 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.Wlorentz 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 V/ 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.lorentzJThis example demostrates a way to run an instruction, operating on small ,, so that it works on a larger ,.UVWVWU#None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm$Zlorentz+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._lorentz"Describes single migration action.In most cases it is possible to derive reasonable description for migration atom automatically, this datatype exactly carries this information.alorentz3Action on field, e.g. "set", "remove", "overwrite".blorentzName of affected field of ,.clorentzType of affected field of , in new storage version.dlorentzAn action on storage entry.elorentz9Some sort of addition: "init", "set", "overwrite", e.t.c.florentzRemoval.ilorentzCorner case of j! with some type argument unknown.You can turn this into j using .jlorentzCode 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).mlorentzUStore with hidden template.nlorentzDummy template for ,V, use this when you want to forget exact template and make type of store homomorphic.lorentz&Manually perform a piece of migration.rlorentz;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.slorentzjAdd description of action, it will be used in rendering migration plan and some batching implementations.tlorentzWe allow casting between m and , freely.lorentz%Migration script splitted in batches.PThis is an intermediate form of migration content and needed because compiling  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.lorentz2Way 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.lorentz 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.lorentz8A bunch of migration atoms produced by migration writer.lorentz*Keeps information about migration between ,s with two given templates.lorentzTurn  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.lorentzModify all code in migration.lorentz Create migration atom from code.HThis is an internal function, should not be used for writing migrations.lorentz,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.lorentz'Put the whole migration into one batch.lorentz Version of - which allows splitting migration in batches.pHere you supply a sequence of migration blocks which then are automatically distributed among migration stages.lorentz)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 .lorentz(Compile migration for use in production.lorentzIGet migration scripts, each to be executed in separate Tezos transaction.lorentzGet migration scripts as list.lorentz?Get migration script in case of simple (non-batched) migration.lorentz?Get migration script in case of simple (non-batched) migration.lorentz!Get information about each batch.lorentzNumber of stages in migration.lorentzRender migration plan.7Z[\]^_`abcdefghijklmnopqrs7nmjklihgZ[\]^oprqdef_`abcs$None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmlorentzType of batch.lorentzAddition of any type of data.lorentzAddition of code.lorentz*Several joined actions of different types.lorentz`No information to chooseType about batching. This means that the given action does not contain _.lorentzXPuts 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.lorentz Similar to nub:, counts number of invocations and attaches to text entry.nubCounting ["a", "b", "a"]["a (x2)", "b"]  %None5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkme+lorentz Signature of  userFailWith.lorentz$Prompt an error message saying that ! is not applicable for this type.lorentz Documentation for custom errors.,Mentions that entrypoint throws given error.lorentz(Mentions that contract uses given error.lorentz/What should happen for this error to be raised.lorentzBrief 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.lorentz Error class.~By default this returns "unknown error" class; though you should provide explicit implementation in order to avoid a warning.lorentz(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 anotherlorentz=Error class on how the error should be handled by the client.lorentzRNormal expected error. Examples: "insufficient balance", "wallet does not exist".lorentzaInvalid argument passed to entrypoint. Examples: your entrypoint accepts an enum represented as natT, 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.lorentzzUnexpected error. Most likely it means that there is a bug in the contract or the contract has been deployed incorrectly.lorentz/It's possible to leave error class unspecified.lorentzHow & is actually represented in Michelson.lorentzMaterial custom error.:Use this in pattern matches against error (e.g. in tests).lorentz"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.lorentz!Use this type as replacement for () when you really( want to leave error cause unspecified.lorentz?Name of error as it appears in the corresponding section title.lorentz/What should happen for this error to be raised.lorentzBrief 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.lorentz)How this error is represented in Haskell.lorentz Error class.lorentz8Which definitions documentation for this error mentions.lorentz Haskell type representing error.lorentzConverts a Haskell error into Value representation.lorentz Converts a Value into Haskell error.lorentzImplementation of  via .lorentzImplementation of  via .lorentz!Helper for managing descriptions.lorentz"Fail with the given Haskell value.lorentzTFail, 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.lorentzDemote error tag to term level.lorentzFail with given custom error.lorentzSpecialization of  for no-arg errors.lorentzImplementation of u (of wA typeclass) for Haskell types which sole purpose is to be error.lorentz!This is to be included on top of Errors) section of the generated documentation.lorentzImplementation of  for custom errors.lorentzImplementation of  for custom errors.This function is deprecated.lorentzDerive  instance for given type.This will also forbid deriving V instance for that type to avoid having multiple different Michelson representations.lorentzMFail 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.lorentz)This instance cannot be implemented, use  instance instead.lorentzIf { constructor is not provided its argument, we assume that this is no-arg error and interpret the passed value as complete.lorentz"Use this for internal errors only.NormalF error scenarios should use the mechanism of custom errors, see below...&None5!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befghkm)lorentzeNewtype 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.lorentzvoid! type synonym as described in A1.lorentzEntry point argument.lorentzType of result reported via t.lorentzview! type synonym as described in A1.lorentz(Various convenient instructions on maps.lorentzSpecialized version of i.lorentzInsert given element into map.lorentzWInsert given element into map, ensuring that it does not overwrite any existing entry.=As first argument accepts container name (for error message).lorentzDelete element from the map.lorentzuConstraint for duupX that combines kind-agnostic constraint for Lorentz (Haskell) types and for our typed Michelson.lorentz"Kind-agnostic constraint for duupXlorentzxAnalog of the FAIL macro in Michelson. Its usage is discouraged because it doesn't carry any information about failure.$lorentz[Custom Lorentz macro that drops element with given index (starting from 0) from the stack.%lorentzDuplicate the top of the stack n times.@For example, `cloneX @3` has type `a & s :-> a & a & a & a & s`.&lorentzDUU+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 s, Q and Nq. 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.'lorentz Version of L 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.8lorentzInsert given element into set.!This is a separate function from  updateMap4 because stacks they operate with differ in length.9lorentzWInsert given element into set, ensuring that it does not overwrite any existing entry.)As first argument accepts container name.:lorentz"Delete given element from the set.=lorentzPolymorphic version of  constructor.>lorentz*Wrap internal representation of view into  itself.8 is part of public standard and should not change often.?lorentzUnwrap " into its internal representation.8 is part of public standard and should not change often.DlorentzPush a value of contract type.Doing this via SH 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.U      !"#$%&'()*+,-./0123456789:;<=>?@ABCDU      !"#$%&'-.+,3456712()*/089:@=>?BA<;CD'None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmFm ^lorentz1Write 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._lorentz>This constraint can be used if a function needs to work with big6 store, but needs to know only about some field of it.`lorentz>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.blorentz 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.glorentzKInsert a key-value pair, but fail if it will overwrite some existing entry.ilorentzLike toField , but for ,.This may fail only if ,9 was made up incorrectly during contract initialization.jlorentzLike getField , but for ,.This may fail only if ,9 was made up incorrectly during contract initialization.klorentzLike setField , but for ,.llorentzRemove a field from ,, for internal purposes only.lorentzWhen 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  entirely.lorentz with store instantiated to .^_`abcdefghijklbcdefghijkl`_^a(None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmsculorentzPut 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).lorentz Helper for F which ensures that given store hasn't been (partially) migrated yet.vlorentzDCast 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.wlorentz&Get a field present in old version of ,.xlorentz}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 {) which would declare removal explicitly.ylorentzmRemove 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.zlorentz+Get and remove a field from old version of ,.4You probably want to use this more often than plain y.{lorentz.Remove field and write new one in place of it.$This is semantically equivalent to 7dip (migrateRemoveField label) >> migrateAddField label, but is cheaper.|lorentz_Modify field which should stay in new version of storage. This does not affect remaining diff.}lorentzDefine 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 ~.. Names are used in rendering migration plan.~lorentz(Define a migration atom with given name.0Name will be used when rendering migration plan.lorentz Composition of migration blocks.lorentzThis is $ operator with priority higher than .It allows you writing EmkUStoreBatchedMigration = muBlock $: do migrateAddField ...  --, muBlock $: do migrateRemoveField ... Alternatively, BlockArguments extension can be used.lorentzGet 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.lorentzThis version can be used in mkUStoreMultiMigration as the last migration block.lorentzThis version can be used in .tuvwxyz{|}~tuvwxyz{|}~27:None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmuOZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~)None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmBlorentzGeneric traversal for  and .lorentz"Convert generic value to internal , representation.lorentzParse internal ,/ representation into generic Haskell value of ,", also returning unparsed entries.lorentz<Convert generic value to a script filling the corresponding ,.lorentz#Given template can be converted to , value.lorentz,( content represented as key-value pairs.lorentzMake , from separate big_map s and fields.lorentz 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.lorentz(Make migration script which initializes , from scratch.lorentz Version of  for batched migrations.4Each field write will be placed to a separate batch.lorentzFill ,C with entries from the given template as part of simple migration.7Sometimes you already have some fields initialized and  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 .lorentzLike  , but requires all entries from UStore to be recognized.lorentz!Recursive template traversal for .lorentz!Recursive template traversal for .lorentz!Recursive template traversal for .lorentzCase of &.lorentzCase of ).lorentzCase of nested template.*None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmblorentz9Remembers parameters it was called with, last goes first.+None5!"#$%&'*,-.012456789;=>?@ACHMNPSUVX_`befgkmŽlorentzIConcise 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 ] lorentz2Indicates a submap with given key and value types.lorentz*Provides operations on fields for storage.lorentz/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.)lorentz*Provides operations on fields for storage.lorentz/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.)lorentzPick storage field.lorentz:Get storage field, preserving the storage itself on stack.lorentzUpdate storage field.lorentz Check value presence in storage.lorentzGet value in storage.lorentzUpdate a value in storage.lorentzDelete a value in storage.lorentzAdd a value in storage.lorentzJAdd a value in storage, but fail if it will overwrite some existing entry.lorentzImplementation of 0 for case of datatype keeping a pack of fields.lorentzImplementation of + for a data type which has an instance of = inside. For instance, it can be used for top-level storage.lorentzImplementation of + for a data type which has an instance of = inside. For instance, it can be used for top-level storage.lorentzPretend 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 lorentzPretend 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 .lorentz.Chain two implementations of field operations.eSuits for a case when your store does not contain its fields directly rather has a nested structure.lorentz5Chain implementations of field and submap operations.lorentz< can be used as standalone key-value storage if very needed.lorentz\ 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_`befgkmU4 $%&'()*+,VWgjkl^_`cdefghijkwxyz{|4,)*+&'($% cdefghijk`_^VWjklgwxyz{|-None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmlorentzContract storage with big_map.HDue to Michelson constraints it is the only possible layout containing big_map.lorentz1Write 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.lorentz>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.lorentz\Prepend a constructor name with a lower-case character so that you could make a label with OverloadedLabels% extension matching resulting thing.lorentz9Get map signature from the constructor with a given name.lorentzType arguments of .lorentz Number of datatype constructors.lorentzDPosition of a constructor in the corresponding datatype declaration.lorentzDescribes one virtual big map.lorentzGathers 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.lorentzKInsert a key-value pair, but fail if it will overwrite some existing entry.lorentzUnpack  into a pair.lorentzPack a pair into .lorentzKInsert a key-value pair, but fail if it will overwrite some existing entry.lorentzLift a key-value pair to .Further you can use  instance of Store to make up large stores.lorentzGet a value from store by key.SIt expects map to be consistent, otherwise call to this function fails with error.""None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm lorentzPredicate for if ... then .. else ...] construction, defines a kind of operation applied to the top elements of the current stack."Type arguments mean: 1. Input of ifS 2. Left branch input 3. Right branch input 4. Output of branches 5. Output of if lorentzNExplicitly named binary condition, to ensure proper order of stack arguments. lorentz"Provide the compared arguments to if branches. lorentz$Aliases for '(#)' used by do-blocks.lorentzDefines semantics of if ... then ... else ... construction.lorentzNamed version of .In this and similar operators you provide names of accepted stack operands as a safety measure of that they go in the expected order.lorentzNamed version of .lorentzNamed version of  .lorentzNamed version of  .lorentzNamed version of .lorentzNamed version of .lorentzVCondition modifier, makes stack operands of binary comparison to be available within if branches.            444444.None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm lorentzTags excluded from map.lorentzXThis is a bidirectional map with correspondence between numeric and textual error tags.lorentz6Find all textual error tags that are used in typical FAILWITHA patterns within given instruction. Map them to natural numbers.lorentz#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 .lorentzBuild  from a set of textual tags.lorentzRemove some error tags from map. This way you say to remain these string tags intact, while others will be converted to numbers when this map is applied.2Note that later you have to apply this map using %, otherwise an error would be raised.lorentzFor 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 .lorentz Similar to >, but for case when you have excluded some tags from map via . Needed, because both V and this function do not tolerate unknown errors in contract code (for your safety).lorentzThis 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.lorentz<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?@ABCDEFGHSRQPONMLKJIYZ[\]^_`&'( !"#$%&'()*+,-./0123H`_^]\[ZYBA3EFGHSRQPONMLKJIDC !"#$&'(%@?<>=;:98721654'(&)*+,-./0123/None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmAlorentzPContract initiator should be contract admin in order to perform this operation. None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmr6lorentz6Provides arror for convenient entrypoint documentation7lorentzLift entrypoint implementation.+Entrypoint names should go with "e" prefix.lorentzTraverse 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.lorentz*Add corresponding parameter building step.MFirst argument is accumulator for Michelson description of the building step.8lorentzConstraint for .9lorentzPick a type documentation from  .;lorentz$Describes argument of an entrypoint.=lorentz!Argument of the entrypoint. Pass  if no argument is required.>lorentzWhether this entrypoint has a field annotation (and thus is callable using the standard "lightweigth entrypoints" mechanism) or is a virtual entrypoint which requires constructing a value of the full parameter type.?lorentzhDescribes a way to lift an entrypoint argument into full parameter which can be passed to the contract.uSteps are supposed to be applied in the order in which they are given. E.g. suppose that an entrypoint 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.@lorentz[Untyped representation of entrypoint, used for printing its michelson type representation.Alorentz$Describes a parameter building step.SThis can be wrapping into (Haskell) constructor, or a more complex transformation.Clorentz'Plain english description of this step.Dlorentz+How to construct parameter in Haskell code.Elorentz4How to construct parameter working on raw Michelson. lorentz_During incremental assembly of parameter building steps - current representation of parameter.FlorentzDefault value for G type argument.Glorentz,Gathers information about single entrypoint.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 9 instances with appropriate custom descriptions for them.KlorentzDefault implementation of  for entry points.Plorentz5Go over contract code and update every occurrence of ;Y documentation item, adding the given step to its "how to build parameter" description.lorentz,Add necessary documentation to entry points.QlorentzLike /, to be used for pattern-matching on parameter.}Modifies documentation accordingly. Including description of entrypoints' arguments, thus for them you will need to supply w instance.Rlorentz Version of Q for tuples.SlorentzjWrapper for documenting single entrypoint which parameter isn't going to be unwrapped from some datatype. entryCases unwraps a datatype, however, sometimes we want to have entrypoint parameter to be not wrapped into some datatype.!{z6789:;<=>?@ABCDEFGHIJKLMNOPQRS!GHIJ67FK;<=>?@{z9:ABCDEPLMNO8SRQ0None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm lorentz5Generic traversal for conversion between ADT sum and l.\lorentz1Entry points template derived from given ADT sum.]lorentzConstraint required by u.^lorentz#Make up a "case" over entry points. lorentzPattern-match on given UParam entries.bYou have to provide all case branches and a fallback action on case when entrypoint is not found.lThis function is unsafe because it does not make sure at type-level that entry points' names do not repeat._lorentz=An action invoked when user-provided entrypoint is not found.`lorentz%Implementations of some entry points.,Note that this thing inherits properties of , e.g. you can Data.Vinyl.Core.rappendX implementations for two entrypoint sets when assembling scattered parts of a contract. lorentz#Wrapper for a single "case" branch.dlorentz"This class is needed to implement e.elorentzTurn la into a Haskell value. Since we don't know its type in compile time, we have to erase it using fu. The user of this function can require arbitrary constraint to hold (depending on how they want to use the result).florentzBThis type can store any value that satisfies a certain constraint.hlorentz>Ensure that given entry points do no contain duplicated names.ilorentz,Get type of entrypoint argument by its name.jlorentzHomomorphic version of l, forgets the exact interface.klorentzPseudo value for l type variable.llorentzpEncapsulates parameter for one of entry points. It keeps entrypoint 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.nlorentz6A convenient alias for type-level name-something pair.olorentzGAn entrypoint is described by two types: its name and type of argument.plorentz Construct a l safely.qlorentz-Helper instruction which extracts content of l.rlorentzDefault implementation for _, simply reports an error.slorentzPattern-match on given UParam entries.bYou have to provide all case branches and a fallback action on case when entrypoint is not found.tlorentzLike s(, but accepts a tuple of clauses, not a .ulorentzMake up l from ADT sum.'Entry points template will consist of '(constructorName, constructorFieldType)@ pairs. Each constructor is expected to have exactly one field.vlorentz:Note that calling given entrypoints involves constructing l.}lorentzAllows casts only between j and l.\]^_`acbdefghijklmnopqrstuvlmonpfgdekj`_acb^strihu]\vq1None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmlorentz,Check that contract documents its parameter.lorentz8It's a common issue to forget to describe an entrypoint.lorentzTests all properties.,-2None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmlorentz!Replacement for uninhabited type.lorentz)Witness of that this code is unreachable.lorentzSomeone constructed  type.3None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm>None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkm" "!    $# %&'(+*)defghijklmnopwvutsrqyx{z|}~      !"#$&'()*+,-.012689:;<?@ABCDEIJKLRSTUVWXYZ[\]^_`abdcefg   ()*89:;<=>?@ABGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     $%&'()*+,VWgjkl      !"#$%&'()*+,-./0123456789:;<=>?@ABCD^_`cdefghijkwxyz{|     6789:;<=>?@ABCDEFGHIJKLMNOPQRS\]^_`acbdefghijklmnopqrstuv" "!    $# %&'(+*)defghijklmnopwvutsrqyx{z|}~      !"#$&'()*+,-.012689:;<?@ABCDEIJKLRSTUVWXYZ[\]^_`abdcefg   ()*89:;<=>?@ABGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     $%&'()*+,VWgjkl      !"#$%&'()*+,-./0123456789:;<=>?@ABCD^_`cdefghijkwxyz{|     6789:;<=>?@ABCDEFGHIJKLMNOPQRS\]^_`acbdefghijklmnopqrstuv4None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmlorentz<Expect the given contract to have some specific entrypoints.None4!"#$%&'*,-.012456789;=>?@AHMNPSUVX_`befgkmY,-./012456789:;<=>?@CDEFGHSRQPONMLKJITUVWXYZ[\]^_`abc&'( !"#$%&'()*+,-./0123Y0/.XVUTEFHGSRQPONMLKJIDC !"#$&'(%@?<>=;:98721654'(&)*+,-./0123`_^]\[ZY,-Wcba?@A?BC?@D?EF?@G?@H?@I?@J?@K?LMNOPNOQ?RS?@T?@UNVWXYZ?[\?]^?_`NVa?]b?]cNVd?_e?_fghijkl?@mnop?qr?st?st?Lu?Lv?@w?@xyz{n|}~~      !!"#"$"%"&"'"(")"*"+",-.-/-0-0123435363738389:;<;=;>;?;@;A;BCDCECFGHGIJKLMLNOPOQOROSTUVTUWXYZXY[X\ATU]TU^TU_`ab`ab`cd`ce`cfghijklmnopqrstuvwxyz{|}~                                                    5      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>??@ABCDEFGHIJKLMNOPQR S T U V V W X Y Y Z [ \ ] ^ _ ` a b c d e f g h ijklmnop q r s t u v w x y z { | } ~                                      !!!!!!!!!!!!!!!!"""""#####################################################################$$$$$$$$$$$$$%%%%%%%%%% % % % % %%%%%%%%%%%%%%%%%%%%% %!%"%#%$%%%&%'%(%)%*%+%,%-%.%/%0%1%2%3%4%5%6%7%8%9%:%;%<%=%>%?%@%A%B&C&C&D&E&E&F&G&H&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-:;<=>?@ABCDEFGHIJKLMNOPQRSTU.V.W.X.Y.Z.[.\.].^._`abcdefghijklmnopqrs/t/u v w x y z { { | } ~                            00000000<0000000000000000000000u000000000000000000000000111222u222233333333333333334?-     NV !!!""# $!%"%#%$&%&&&'&(')'*'+',(-).)/)0)1)2)3)4-5-6-|-7-89:;<=>?@A/B C D EF G0H0I0JKLMNOPQRSTTUVW2XY$lorentz-0.1.0-1IijY81BuYC4to9wXiBP3GLorentz.PreludeLorentz.Rebinded Lorentz.ValueLorentz.Constraints.ScopesLorentz.Coercions Lorentz.TestLorentz.Test.Integrational Lorentz.Doc Lorentz.ADTLorentz.EntryPoints.DocLorentz.EntryPoints.HelpersLorentz.EntryPoints.CoreLorentz.Constraints.DerivativeLorentz.EntryPoints.Manual Lorentz.PackLorentz.PolymorphicLorentz.UStore.Common Lorentz.BaseLorentz.Test.Import Lorentz.ExtLorentz.Common Lorentz.Arith Lorentz.ZipLorentz.TypeAnnsLorentz.EntryPoints.Impl Lorentz.Run Lorentz.PrintLorentz.TestScenario Lorentz.InstrLorentz.ReferencedLorentz.ExtensibleLorentz.UStore.TypesLorentz.UStore.Migration.DiffLorentz.UStore.LiftLorentz.UStore.Migration.Base!Lorentz.UStore.Migration.BatchingLorentz.Errors Lorentz.MacroLorentz.UStore.InstrLorentz.UStore.Migration.BlocksLorentz.UStore.HaskellLorentz.Test.ConsumerLorentz.StoreClassLorentz.UStore.Instances Lorentz.StoreLorentz.Errors.NumericLorentz.Errors.CommonLorentz.UParamLorentz.Test.Doc Lorentz.EmptyLorentz.ContractRegistryLorentz.Test.UnitNiceParameterFullLorentz.ConstraintsLorentz.EntryPointsUtil.TypeTuple InstancesLorentz.UStore.MigrationLorentz.UStoreLorentz.Contracts.ConsumercontractConsumerLorentzbaseGHC.Base$GHC.Num fromIntegerreturn Data.String fromString<>memptymappendmconcatpureGHC.EnumBoundedghc-prim GHC.ClassesEqOrd GHC.GenericsGeneric SemigroupMonoid GHC.TypesBool integer-gmpGHC.Integer.TypeInteger GHC.NaturalNatural GHC.MaybeMaybe Data.EitherEitherFalseNothingJustTrueLeftRightbytestring-0.10.8.2Data.ByteString.Internal ByteString text-1.2.3.1Data.Text.InternalText.containers-0.6.0.1Data.Map.InternalMapGHC.OverloadedLabels fromLabel Data.ProxyProxymaxBoundminBoundstimessconcat'constraints-0.12-9r4GNEjfdu11xgOuzOy6H1Data.ConstraintwithDictData.Set.InternalSet1data-default-class-0.1.2.0-FeIQ5tLoVZBHMSgrT9zptQData.Default.ClassDefaultdef"lens-4.19.1-1E66IAG2JhX7QGFcxXMPO9Control.Lens.Wrapped _Wrapped' UnwrappedWrapped#morley-1.0.0-C7XzI9RyjTtBq2aPgQePpZMichelson.Doc.Test runDocTestsexcludeDocTestsMichelson.Test.ImportspecWithUntypedContractspecWithTypedContractspecWithContractMichelson.Test.IntegrationalcomposeValidatorsListcomposeValidatorstExpectStorageConstexpectNoStorageUpdatesexpectNoUpdatesexpectAnySuccessoffshoot?- branchout setChainId withSender setMaxSteps rewindTimesetNowintegrationalFailvalidate tTransfer tOriginateintegrationalTestPropertyintegrationalTestExpectationIntegrationalValidatorSuccessValidatorIntegrationalScenarioMIntegrationalScenarioCustomValidationErrorUnexpectedUpdatesInvalidBalanceStoragePredicateMismatchInvalidStorageIncorrectStorageUpdateIncorrectUpdatesExpectingInterpreterToFailUnexpectedTypeCheckErrorUnexpectedExecutorErrorValidationErrorMichelson.Test.UnitcontractPropVal contractPropContractPropValidatorMichelson.Test.DummydummyContractEnvMichelson.InterpretContractReturnMichelson.Runtime.GStategenesisAddress6genesisAddress5genesisAddress4genesisAddress3genesisAddress2genesisAddress1genesisAddressgenesisAddressesMichelson.Test.Gen midTimestamp maxTimestamp minTimestampMichelson.Typed.Haskell.Doc!concreteTypeDocMichelsonRepUnsafeconcreteTypeDocMichelsonRephomomorphicTypeDocMichelsonRephaskellRepStripFieldPrefixhaskellRepNoFieldsconcreteTypeDocHaskellRepUnsafeconcreteTypeDocHaskellRephomomorphicTypeDocHaskellRepgenericTypeDocDependenciespoly2TypeDocMdReferencepoly1TypeDocMdReferencehomomorphicTypeDocMdReferencecustomTypeDocMdReferencetypeDocMichelsonReptypeDocHaskellReptypeDocDependenciestypeDocMdReferencetypeDocMdDescription typeDocName TypeHasDocSomeTypeWithDocDTypeHaveCommonTypeCtor IsHomomorphic%Michelson.Typed.Haskell.Instr.ProductConstructorFieldTypesInstrConstructCMichelson.Typed.Haskell.ValuecoerceContractReffromCValtoCValToCT IsoCValuefromValtoValToTIsoValueEntryPointCallSomeEntryPointCall crEntryPoint crAddress ContractRefunBigMapBigMapMichelson.Typed.AliasesValue Operation Michelson.DocmkDGitRevisionmorleyRepoSettingscontractDocToMarkdown DocGrouping DDescriptionDGitRevisionUnknownDGitRevisionKnown DGitRevisiongrsMkGitRevisionGitRepoSettingsDCommentsubDocToMarkdowndocDefinitionRefdocItemPosition docItemsOrderdocItemDependenciesdocItemToMarkdown docItemRefdocItemSectionNameStyledocItemSectionDescriptiondocItemSectionNameDocItemPlacementDocItemPositionDocItem DocItemIdDocItemInDefinitionsDocItemInlinedDocItemPlacementKind DocItemNoRef DocItemRefDocSectionNameSmallDocSectionNameBigDocSectionNameStyle SomeDocItemSomeDocDefinitionItemSubDoccdDefinitionIdscdDefinitionsSet cdDefinitions cdContents ContractDocMichelson.Typed.CValue CvAddress CvTimestamp CvKeyHashCvBoolCvMutezCvBytesCvStringCvNatCvIntCValueMichelson.Typed.EntryPoints eaEntryPoint eaAddress EpAddressMichelson.Typed.ExtractmkUTypeMichelson.Runtime.TxDatatdAmount tdEntrypoint tdParametertdSenderAddressTxData Tezos.AddressAddress Tezos.CoretimestampQuotetimestampFromUTCTimetimestampFromSecondstoMutezMutez TimestampChainId Tezos.Crypto PublicKey SignatureKeyHashMichelson.TextmtMText Util.MarkdownMarkdownMichelson.Untyped.EntryPoints DefEpNameEpNameMichelson.Test.Util qcIsRightqcIsLeft succeededProp failedProp$named-0.3.0.1-GwpuPjBY1xnHurMYYo5M6DNamed.Internal:?:!&universum-1.6.1-LZBxAqSxrQs6W7PvqgzcwoUniversum.Debugerror undefinedUniversum.TypeOpsargDefargFarg#vinyl-0.12.1-58YqsKWLFBt1AleDHjYrQbData.Vinyl.DerivedLabelData.Vinyl.Core:&RNilRecNiceComparableNicePrintedValueNiceFullPackedValueNiceUnpackedValueNicePackedValue NiceConstant NiceStorage NiceParameter CanHaveBigMapNoBigMapNoContractType NoOperation KnownCValue KnownValueniceParameterEviniceStorageEviniceConstantEvinicePackedValueEviniceUnpackedValueEvinicePrintedValueEvi $fKnownValuea$fKnownCValuea$fNoOperationa$fNoContractTypea $fNoBigMapa$fCanHaveBigMapaRequireSumTypeCanHaveEntryPointsShouldHaveEntryPointsunHasEntryPoints ctorNameToAnn$fGenericShouldHaveEntryPoints$fIsoValueShouldHaveEntryPointsEpdNone TrustEpNameHasDefEntryPointArgHasEntryPointArguseHasEntryPointArgGetEntryPointArgCustomNiceEntryPointName EntryPointRef CallDefaultCallNoExplicitDefaultEntryPointForbidExplicitDefaultEntryPointGetDefaultEntryPointArgGetEntryPointArgLookupParameterEntryPointAllParameterEntryPointsGetParameterEpDerivationParameterDeclaresEntryPointsParameterHasEntryPointsParameterEntryPointsDerivationEpConstructionRes EpConstructedEpConstructionFailedRequireAllUniqueEntryPointsRequireAllUniqueEntryPoints'EntryPointsDerivationEpdAllEntryPointsEpdLookupEntryPointepdNotesepdCallpepNotespepCallparameterEntryPointsToNotesparameterEntryPointCallparameterEntryPointCallDefaultsepcCallRootCheckedeprNameparameterEntryPointCallCustomflattenEntryPoints#$fHasEntryPointArgkcpTrustEpNamearg$$fEntryPointsDerivationTYPEEpdNonecp($fHasEntryPointArgTYPEcpEntryPointRefargParameterWrapperunParameterWraper$fWrappedParameterWrapper)$fParameterHasEntryPointsParameterWrapper2$fEntryPointsDerivationTYPEPwDerivParameterWrapper$fGenericParameterWrapper$fIsoValueParameterWrapper lPackValue lUnpackValueEDivOpHs 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$fEDivOpHsIntegerIntegerfieldNameToMTextFromContractReffromContractRef ToContractRef toContractRef ToTAddress toTAddress ToAddress toAddressFutureContractunFutureContractTAddress unTAddressListcallingTAddresscallingDefTAddressconvertContractRef$fIsoValueFutureContract$fToAddressContractRef$fToAddressFutureContract$fToAddressTAddress$fToAddressEpAddress$fToAddressAddress$fToTAddresscpTAddress$fToTAddresscpAddress$fToContractRefargTAddress$fToContractRefcpFutureContract$fToContractRefcpContractRef$fFromContractRefcpAddress$fFromContractRefcpEpAddress!$fFromContractRefcpFutureContract$fFromContractRefcpContractRef$fGenericTAddress$fIsoValueTAddressLambda& SomeContractContract ContractOut%>:-> LorentzInstrunLorentzInstrFII iGenericIfiAnyCodeiNonFailingCode iMapAnyCode iForceNotFailiWithVarAnnotations###parseLorentzValuetransformStringsLorentztransformBytesLorentzoptimizeLorentzWithConfoptimizeLorentz $fMonoid:->$fSemigroup:->$fBuildableParseLorentzError $fShow:->$fEq:->$fShowParseLorentzError$fEqParseLorentzErrortestTreesWithContractLspecWithContractLstackRef printComment testAssert stackType Entrypoint_ EntrypointUnaryArithOpHsUnaryArithResHs 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 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 EpdDelegate EpdRecursiveEpdPlain $fGEntryPointsNotesmodeEPLeaf:*:$fGEntryPointsNotesmodeEPLeafU1*$fGEntryPointsNotesEpdDelegateEPDelegateK1$fGEntryPointsNotesmodeepM1$fGEntryPointsNotesmodeEPNodeM1 $fGEntryPointsNotesmodeEPNode:+:$fGEntryPointsNotesmodeepM10#$fGEntryPointsNotesEpdRecursiveepK1($fEntryPointsDerivationTYPEEpdDelegatecp)$fEntryPointsDerivationTYPEEpdRecursivecp%$fEntryPointsDerivationTYPEEpdPlaincp#$fGEntryPointsNotesmodeEPDelegateM1$fGEntryPointsNotesmodeEPLeafM1CompilationOptionscoDisableInitialCastcompileLorentzcompileLorentzContract!compileLorentzContractWithOptionsinterpretLorentzInstrinterpretLorentzLambdaanalyzeLorentzprintLorentzValueprintLorentzContract TestScenarioshowTestScenario$fGenericParameter$fIsoValueParameternonZeroLorentzFunctorlmapConstraintDIPNLorentznopdropdropNdupswapdigPeanodigdugpushsomenoneunitifNonepaircarcdrleftrightifLeftnilconsifConssizeemptySetemptyMap emptyBigMapmapitermemgetupdateif_looploopLeftlambdaexecexecuteapplydip dipNPeanodipNfailWithcastpackunpackconcatconcat'sliceisNataddsubrsubmuledivabsneglsllsrorandxornotcompareeq0neq0lt0gt0le0ge0int toTAddress_self selfCallingcontractcontractCallingcontractCallingUnsaferunFutureContractepAddressToContracttransferTokens setDelegatecreateContractimplicitAccountnowamountbalancecheckSignaturesha256sha512blake2BhashKey stepsToQuotasourcesenderaddresschainIdframedfailingWhenPresent updateNew$fLorentzFunctorMaybe$fNonZeroNatural$fNonZeroIntegerdupTdipTdropT$fDupTorigSta:$fDupTorigSta:0$fDupTorigSta[]$fDipTorigSta:dipInpdipOutout1$fDipTorigSta:dipInpdipOutout$fDipTorigSta[]dipInpdipOutout Coercible_ CanCastTo castDummyMichelsonCoercible forcedCoerce forcedCoerce_gForcedCoerce_ fakeCoerce fakeCoercing coerceWrap coerceUnwraptoNamed fromNamed checkedCoercecheckedCoerce_checkedCoercing_allowCheckedCoerceToallowCheckedCoerce*$fCanCastToTYPETYPEFutureContractEpAddress"$fCanCastToTYPETYPEAddressTAddress"$fCanCastToTYPETYPETAddressAddress$fCanCastToTYPETYPEMaybeMaybe$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_$fCaseArrownamebodyCaseClauseLdocdocGroup contractNamebuildLorentzDocrenderLorentzDoccutLorentzNonDoc$fTypeHasDoc:->PickMarkedFieldsGetUStoreFieldMarkerGetUStoreFieldGetUStoreValue GetUStoreKey GetUStoreFSMarkerFSValueMSValueMSKey ElemSignature MapSignatureFieldSignatureKnownUStoreMarkerShowUStoreFieldmkFieldMarkerUKeyUStoreSubmapKeyTUStoreSubmapKeyUMarkerPlainField UStoreFieldUStoreMarkerTypeUStoreFieldExt unUStoreField|~> UStoreSubMapunUStoreSubMapUStoreunUStoremkFieldMarkerUKeyL mkFieldUKey$fTypeHasDocUStore$fWrappedUStore$$fKnownUStoreMarkerUMarkerPlainField $fEqUStore $fShowUStore$fGenericUStore$fDefaultUStore$fSemigroupUStore$fMonoidUStore$fIsoValueUStore$fMemOpHsUStore$fGetOpHsUStore$fUpdOpHsUStore $fShow|~>$fEq|~> $fDefault|~>$fArbitrary|~>$fShowUStoreFieldExt$fEqUStoreFieldExt$fArbitraryUStoreFieldExt 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$fEqSlBatchType FailUsingArgCustomErrorNoIsoValueDThrowsDErrorCustomErrorHasDoccustomErrDocMdCausecustomErrDocMdCauseInEntrypointcustomErrClasscustomErrArgumentSemantics ErrorClassErrClassActionExceptionErrClassBadArgumentErrClassContractInternalErrClassUnknownRequireNoArgError CustomErrorceTagceArgErrorArgUnspecifiedError ErrorHasDoc errorDocNameerrorDocMdCauseerrorDocMdCauseInEntrypointerrorDocHaskellRep errorDocClasserrorDocDependenciesIsError errorToVal errorFromVal isoErrorToValisoErrorFromVal failUsingfailUnexpected failCustom failCustom_ typeDocMdDescriptionReferToErrorerrorsDocumentationcustomErrorToValcustomErrorFromValderiveCustomError failUsingArg$fShow->$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 assertUsingdropXcloneXduupXframedNpapairppaiirunpaircdarcddrcaarcadrsetCarsetCdrmapCarmapCdrifRightifSomewhen_unless_whenSome setInsert setInsertNew setDeletebuildViewTuple buildViewmkViewwrapView unwrapViewview_mkVoidvoid_addressToEpAddresspushContractRef $fCloneXSas $fCloneXZas$fDuupX[][]Ssas1tail$fDuupXkkS:as1tail$fDuupXkkSsas1tail$fMapInstrsBigMap$fMapInstrsMap$fBuildableView$fBuildableView0$fTypeHasDocView$fBuildableVoid_$fTypeHasDocVoid_$fIsoValueVoidResult$fErrorHasDocTYPEVoidResult$fIsErrorVoidResult$fTypeHasDocVoidResult$fEqView $fShowView $fGenericView$fIsoValueView$fGenericVoid_ $fShowVoid_$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$fUStoreConversibletemplateStorageContains~>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 IsNotZeroIsEqIsNeqIsLtIsGtIsLeIsGeNamedBinConditionPreserveArgsBinCondition>> ifThenElse<.>.<=.>=.==./=. keepIfArgsErrorTagExclusions ErrorTagMapgatherErrorTagsaddNewErrorTagsbuildErrorTagMapexcludeErrorTagsapplyErrorTagMapapplyErrorTagMapWithExclusionsuseNumericErrorserrorFromValNumeric lOriginatelOriginateEmpty lTransferlCalllCallEPlCallDeflExpectStoragelExpectStorageUpdatelExpectBalancelExpectStorageConstlExpectMichelsonFailedlExpectFailWith lExpectErrorlExpectErrorNumericlExpectCustomErrorlExpectCustomErrorNumericlExpectCustomError_lExpectCustomErrorNumeric_lExpectConsumerStoragelExpectViewConsumerStorage%$fCustomErrorHasDoc"senderIsNotAdmin"$fBuildableCustomError EntryArrow#->DocumentEntryPointsDeriveCtorFieldDocderiveCtorFieldDocDEntryPointArgepaArgepaHasAnnotation epaBuildingepaTypeParamBuildingStep pbsEnglish pbsHaskell pbsMichelsonPlainEntryPointsKind DEntryPointdepNamedepSubdiEntryPointToMarkdownconstructDEpArg emptyDEpArg mkDEpUTypemkDEntryPointArgSimpleclarifyParamBuildingSteps entryCase_ entryCasedocumentEntryPoint$fDocItemDEntryPoint$fDocItemDEntryPointArg$fDeriveCtorFieldDocconOneField$fDeriveCtorFieldDocconNoFields$fGDocumentEntryPointskindM1$fGDocumentEntryPointskind:+:$fGDocumentEntryPointskindM10$fEntryArrowTYPEkindnamebodyUParamLinearizedUParamLinearize CaseUParamUParamFallbackEntryPointsImplEntryPointLookupErrorNoSuchEntryPoint UnpackUParam unpackUParamConstrainedSomeRequireUniqueEntryPointsLookupEntryPointUParam_ SomeInterfaceUParam UParamUnsafe?:EntryPointKindmkUParam unwrapUParamuparamFallbackFail caseUParam caseUParamT uparamFromAdt pbsUParam/$fCustomErrorHasDoc"uparamArgumentUnpackFailed"+$fCustomErrorHasDoc"uparamNoSuchEntryPoint"$fBuildableCustomError0$fTypeHasDocUParam$fWrappedUParam$fCanCastToTYPETYPEUParamUParam$fBuildableConstrainedSome$fShowConstrainedSome$fCaseArrowname'bodyCaseClauseU $fBuildableEntryPointLookupError$fUnpackUParamc:$fUnpackUParamc[] $fCaseUParam:$fCaseUParam[]$fGUParamLinearizeM1$fGUParamLinearizeM10$fGUParamLinearizeM11$fGUParamLinearize:+:$fGUParamLinearizeM12$fGenericUParam $fEqUParam $fShowUParam$fIsoValueUParam$fGenericEntryPointLookupError$fEqEntryPointLookupError$fShowEntryPointLookupErrortestDeclaresParametertestEachEntrypointIsDescribedtestLorentzDocEmptyabsurd_"$fCustomErrorHasDoc"emptySupplied"$fTypeHasDocEmpty$fGenericEmpty$fIsoValueEmpty CmdLnArgsPrintDocumentContractRegistryunContractRegistry ContractInfo ciContractciIsDocumented?:: getContractprintContractFromRegistryDoc argParser$fBuildableContractRegistryexpectContractEntrypointsMichelson.Typed.ArithOrData.Semigroup.InternalEndo ParamNotesMichelson.Typed.AnnotationNotesMichelson.Typed.PolymorphicEDivOpSliceOpConcatOpGetOpUpdOpSizeOpMichelson.Typed.TTIterOpMapOpMemOpKeyParseLorentzErrorMichelson.PreprocesstransformStringstransformBytestestTreesWithContractGEntryPointsNotesEntryPointsNotesgMkEntryPointsNotesAllEntryPoints BuildEPTreeEPTreeTOrEPNodeEPLeaf EPDelegatemkEntryPointsNotesmkEpLiftSequence ToTAddress_Michelson.Typed.InstrCONTRACTSELFDipTDupT Castable_ DocumentCtorGExtVal GGetCtorsEnumerateCtorsCtorKindCtor LookupCtorWrapExt packForWrap!Michelson.Typed.Haskell.Instr.Sum CaseClauseType UStoreMarkerDiffCoverageItem LiftToDiffRequireFieldName UStoreFields_sampleWithMyStoremanualWithUStore nubCountingCustomErrorReppickFirstSentenceerrorTagToMText MapInstrs mapUpdateConstraintDuupXLorentzDuupXConstraint'_sample7MyStoreTemplate _sample7'MyStoreTemplateBigRequireBeInitialGUStoreConversible gUstoreToValgUstoreFromValgUstoreToScript mkUStoreRecstoreDecomposeRec fillUStoreRecCtorNameToLabelGetStoreCtorsNumCtorIdxFAILWITH originateMichelson.RuntimetransfervalidateStorageCb expectStorageexpectStorageUpdate expectBalanceexpectStorageConstD:R:ErrorArg"senderIsNotAdmin"GDocumentEntryPointsgDocumentEntryPointsdocumentEntryPoints CtorField CurrentParamGUParamLinearizecaseUParamUnsafe CaseClauseU testDocBasictestNoAdjacentDescriptionstestDocNotEmptytestContractNameAtTopforEachContractDocItemforEachContractLayerexpectDocTestFailureexcludeDocTest mkDocTestDocTest dtDeclLocdtDescdtSuiteD:R:ErrorArg"emptySupplied"