#H      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK LM N OPQ R S T UVWXYZ[\]^_`abcdefgh i j k lmnopqrst u v w xyz{|}~               ! " # $ % & ' ( ) * + , - . / 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 [ \]^_`abcdefghijklmnopqrstuvwxyz{|}~                                            !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK L MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;< = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~           !!!"""""""""""##$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& & & & & &&&&&&&&&&&&&&&&&&& &!&"&#&$&%&&&'&(&)&*&+&,&-&.&/&0&1&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&YZ[\]^_`abcdefghijklmnopqrst'u'v'w'x'y'z'{'|'}'~''''''''((((((((((((((((((((((((((((((())))))))))***********+++++++++++++++++++++++++++++++++++++++++++++++++++ + + + + ++++++++++,,,,,,,,, !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghij-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z-{-|-}-~-----------------------------------1None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp\/lorentz A Generic  HasAnnotation implementationlorentzThis class defines the type and field annotations for a given type. Right now the type annotations come from names in a named field, and field annotations are generated from the record fields.lorentzUsed in V as a flag to track whether or not field/constructor annotations should be generated.lorentzUsed in  and n as a flag to track whether or not it directly follows an entrypoint to avoid introducing extra entrypoints.lorentzQAllow customization of field annotation generated for a type when declaring its  instance.lorentzDrops the field name prefix from a field. We assume a convention of the prefix always being lower case, and the first letter of the actual field name being uppercase. It also accepts another function which will be applied directly after dropping the prefix.lorentzappendTo suffix fields field appends the given suffix to field if the field exists in the fields list.lorentzUse this in the instance of  HasAnnotation1 when field annotations should not be generated../0:0/.:None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmperlorentz1Constraint applied to any part of parameter type.ZNote that you don't usually apply this constraint to the whole parameter, consider using  . 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.%          % None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpo~lorentz%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. None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpZ,!lorentzsNo entrypoints declared, parameter type will serve as argument type of the only existing entrypoint (default one)."lorentzCheck that the given entrypoint has some fields inside. This interface allows for an abstraction of contract parameter so that it requires some *minimal* specification, but not a concrete one.lorentz1A helper datatype which prettifies interface for ".$lorentzRChecks that the given parameter consists of some specific entrypoint. Similar as (> but ensures that the argument matches the following datatype.%lorentz$This wrapper allows to pass untyped sF 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 s 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. s 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 0g, but in a version which the compiler can work with (and which produces errors confusing for users :/)0lorentz6Ensure that there is no explicit "default" entrypoint.1lorentz:Get type of entrypoint with given name, fail if not found.2lorentz:Get type of entrypoint with given name, fail if not found.3lorentz#Lookup for entrypoint type by name.4Does not treat default entrypoints in a special way.4lorentz+Get all entrypoints declared for parameter.5lorentz Version of 8e which we actually use in function signatures. When given type is sum type or newtype, we refer to 89, otherwise we suppose that no entrypoints are declared.6lorentz$Parameter declares some entrypoints.This is a version of 7_ which we actually use in constraints. When given type is a sum type or newtype, we refer to 75 instance, otherwise this instance is not necessary.7lorentz+Which entrypoints given parameter declares.GNote that usually this function should not be used as constraint, use 6 for this purpose.:lorentz&Wrap into constructor with given name.;lorentz%How one of the entrypoints is called.xType arguments are name of the constructor which eventually gave name to the entrypoint and this entrypoint's argument.=lorentzEntrypoint argument type.>lorentzName of assigned entrypoint.?lorentzIf we emulated entrypoints calling via just wrapping an argument into constructors until getting the full parameter, how would it look like. Steps are enlisted in reversed order - top-level constructors go last.@lorentz*Result of entrypoint lookup at term level.Clorentz0Ensure that all declared entrypoints are unique.ElorentzMDefines 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.Methods of this typeclass aim to better type-safety when making up an implementation and they may be not too convenient to use; users should exploit their counterparts.FlorentzbName 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.uNote [order of entrypoints children]: If this contains entrypoints referring to indermediate nodes (not leaves) in orW tree, then each such entrypoint should be mentioned eariler than all of its children.Glorentz Get entrypoint argument by name.HlorentzJConstruct parameter annotations corresponding to expected entrypoints set.IThis method is implementation detail, for actual notes construction use O.IlorentzConstruct entrypoint caller.AThis does not treat calls to default entrypoint in a special way.HThis method is implementation detail, for actual entrypoint lookup use P.Jlorentz:Description of how each of the entrypoints is constructed.Klorentz Version of Ho which we actually use in code. It hides derivations stuff inside, and treats primitive types specially like 5 does.Llorentz Version of Io which we actually use in code. It hides derivations stuff inside, and treats primitive types specially like 5 does.Mlorentz Version of Jo which we actually use in code. It hides derivations stuff inside, and treats primitive types specially like 5 does.Nlorentz;Descriptions of how each of the entrypoints is constructed. Similar to MR, but includes default entrypoint disregard whether it is explicit or not, while MB includes it only if it is explicit. Also this returns list, not 6, for simplicity.DNote that [order of entrypoints children] property still holds here.Olorentz'Derive annotations for given parameter.Plorentz!Prepare call to given entrypoint.kThis does not treat calls to default entrypoint in a special way. To call default entrypoint properly use Q.QlorentzCall the default entrypoint.RlorentzCall root entrypoint safely.TlorentzUniversal entrypoint calling.5!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRST5EFGHIJ@AB;<=>?9:C7865KLMN43O2P1Q0/R,-.+S*%&()'$"T!#D#0 None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp[lorentz-Constraint applied to a whole parameter type.[[/None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp%     [None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp \lorentz*Applicable for wrappers over Lorentz code.]lorentz'Modify all the code under given entity.lorentz;Errors that can happen during parsing into a Lorentz value._lorentz An alias for :.}We discourage its use as this hinders reading error messages (the compiler inserts unnecessary parentheses and indentation).dlorentz Alias for e3, seems to make signatures more readable sometimes.:Let's someday decide which one of these two should remain.elorentzAAlias for instruction which hides inner types representation via T.olorentz4Wrap Lorentz instruction with variable annotations, annotsD list has to be non-empty, otherwise this function raises an error.qlorentz`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).rlorentzLorentz version of .slorentzLorentz version of .\]^_`abcdefghijklmnopqrstuefgd_pihjklmnoqrsut\]cb`a^_2d1e1p8None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp1~lorentz 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.~~ None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp4 lorentzConvert something from  ContractAddr in Haskell world.lorentzConvert something to h in Haskell world.lorentzHConvert something referring to a contract (not specific entrypoint) to  in Haskell world.lorentzConvert something to w 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 hJ can appear are now severely limited, this type gives you type-safety of h 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 h~, having this type you still cannot be sure that the referred contract exists and need to perform a lookup before calling it.lorentz%Something coercible to 'TAddress cp'.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 h 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.lorentzCast something appropriate to .KQRSThijkwwQRSThijkKNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp&'lorentzEInclude a value at given position on stack into comment produced by . stackRef @0<includes the top of the stack>lorentz-Print a comment. It will be visible in tests.printComment "Hello world!":printComment $ "On top of the stack I see " <> stackRef @0lorentz,Test an invariant, fail if it does not hold.NThis won't be included into production contract and is executed only in tests.lorentz2Fix the current type of the stack to be given one.stackType @'[Natural]"stackType @(Integer : Natural : s)PstackType @'["balance" :! Integer, "toSpend" :! Integer, BigMap Address Integer]3Note that you can omit arbitrary parts of the type.>stackType @'["balance" :! Integer, "toSpend" :! _, BigMap _ _]None8!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpq/p lorentzLifted .lorentzLifted .lorentzLifted .lorentzLifted .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 .lorentzLifted .lorentz-A useful property which holds for reasonable  instances.It's a separate thing from  because it mentions b type parameter.lorentzLifted .None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp1 "!  $# 1231 "! $#  23None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp7>lorentz Provides 5 instance that prints Lorentz value via Michelson's P.7Result won't be very pretty, but this avoids requiring  or  instances.Q&'(789 KLOPQRSTefghijklmnpoqrswxyz{|}~IPmnpor8wQRSTz}xy{|&efgOhijksLlq~7K'(9 None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpeplorentzGeneric 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 , , and < which allow specifying root annotation for the parameters.lorentz Extension of : on parameters being defined as several nested datatypes.MIn particular, it will traverse the immediate sum type, and require another 7 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 mv instance, this derivation way will not work. As a workaround, you can wrap your argument into some primitive (e.g. :!).lorentzImplementation of 7l 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.lorentz-Makes up descriptions of entrypoints calling.  None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmphNlorentzLifted .lorentzLifted .None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpm+lorentz+ is similar to lens Wrapped class without the method. It provides type family that is mainly used as constraint when unwrapping Lorentz instruction into a Haskell newtype and vice versa.+,+,None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpp/lorentzOWrap parameter into this to locally assign a way to derive entrypoints for it./01/010None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpr-!"#$%&'()*,-./01234678CEFGHIJOPQRST/01-EFGHIJ78643O2P1Q0/R,-.S*()'$"%&TC#!/01None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp7lorentzLCode for a contract along with compilation options for the Lorentz compiler.It is expected that a 7 is one packaged entity, wholly controlled by its author. Therefore the author should be able to set all options that control contract's behavior.~This helps ensure that a given contract will be interpreted in the same way in all environments, like production and testing.Raw b2 should not be used for distribution of contracts.9lorentzThe contract itself.:lorentzBFlag which defines whether compiled Michelson contract will have CASTs (which drops parameter annotations) as a first instruction. Note that when flag is false, there still may be no CAST3 (in case when parameter type has no annotations).;lorentz5General compilation options for the Lorentz compiler.<lorentz4Options to control Lorentz to Michelson compilation.>lorentzConfig for Michelson optimizer.?lorentz(Function to transform strings with. See r.@lorentz-Function to transform byte strings with. See s.AlorentzRRuns Michelson optimizer with default config and does not touch strings and bytes.Blorentz%For use outside of Lorentz. Will use A.ClorentzUCompile Lorentz code, optionally running the optimizer, string and byte transformers.DlorentzCompile contract with A and : set to False.Elorentz&Compile a whole contract to Michelson.Note that compiled contract can be ill-typed in terms of Michelson code when some of the compilation options are used (e.g. when ccoDisableInitialCast is TrueB, resulted contract can be ill-typed). However, compilation with !defaultContractCompilationOptions should be valid.Florentz_Interpret a Lorentz instruction, for test purposes. Note that this does not run the optimizer.GlorentzLike F9, but works on lambda rather than arbitrary instruction.HlorentzLorentz version of analyzer.789:;<=>?@ABCDEFGH<=>?@ABC789:;DEFGHNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpLIlorentz.Pretty-print a Haskell value as Michelson one.Jlorentz4Pretty-print a Lorentz contract into Michelson code.IJIJ None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpKlorentzEstimate code operation size.LlorentzEstimate value operation size.MNtuvKLtuvMNKLNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpd Mlorentz!Require several stacks to comply N constraint.Nlorentz"Zipping stack into tuple and back.Olorentz-A type which contains the whole stack zipped.Plorentz6Fold given stack into single value in typed Michelson.Qlorentz:Unfold given stack from a single value in typed Michelson.lorentz Version of p/ which performs some optimizations immediately.#In particular, this avoids glueing Nops and DIP Nops.Rlorentz#Fold given stack into single value.Slorentz'Unfold given stack from a single value.Tlorentz'Flatten both ends of instruction stack.Ulorentz)Unflatten both ends of instruction stack.XlorentzHSuch definition seems the only possible one we can support efficiently. MNOPQRSTU NOPQRSMTUNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp'[lorentzRun a lambda with given input.Note that this always returns one value, but can accept multiple input values (in such case they are grouped into nested pairs).'For testing and demonstration purposes.\lorentzLike [&, assumes that no failure is possible.'For testing and demonstration purposes.import Lorentz.Instrnop -$ 55 sub -$ (3, 2)1 push 9 -$ ()9add # add -$ ((1, 2), 3)6]lorentz(Version of (-$?) with arguments flipped.^lorentz'Version of (-$) with arguments flipped._lorentz1Version of (-$) applicable to a series of values.[\]^_[\]^_[2\2]2^2_2None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp`lorentz)Modify the example value of an entrypointblorentzPut a document item.clorentzpGroup documentation built in the given piece of code into block dedicated to one thing, e.g. to one entrypoint.dlorentzfInsert documentation of the contract storage type. The type should be passed using type applications.elorentzCGive a name to given contract. Apply it to the whole contract code.glorentzTakes an instruction that inserts documentation items with general information about the contract. Inserts it into general section. See .hlorentzHInserts general information about the contract using the default format.This includes git revision and some other information common for all contracts. Git revision is left unknown in the library code and is supposed to be updated in an executable using e.g. i.llorentz1Leave 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.m<=>?@ABCDEFGHIJUVWXYZ\[]^_`ab`abcdefghijklmmbcdfijkeghl`amUVA\[]^_`abYZWXB@GIJF<=CDEH>?None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmprlorentzx actions parsed from CLI.lorentz-Specifies how to parse initial storage value.]Normally you pass some user data and call a function that constructs storage from that data.KIf storage is simple and can be easilly constructed manually, you can use .lorentzRewrite annotations in storage. We don't won't to uncoditionally override storage notes since after #20 we require notes to be non-empty, so we wrap them into .lorentzRun an action operating with x.rstuvwxyz{|}~{|}~xyzrstuvwNone6!"#$%&'*,.012456789;<=>?@AHMNPSUVX_`befgkmpJ lorentz'Documentation item for hash algorithms.lorentzHash algorithm used in Tezos.lorentz Hash of type t evaluated from data of type a.lorentz^Open kind for hash algorithms, to make it more difficult to apply type arguments incorrectly.lorentz9Represents a signature, where signed data has given type.HSince we usually sign a packed data, a common pattern for this type is  TSignature ( signedData). If you don't want to use  , use plain TSignature ByteString instead.lorentz Represents a ( resulting from packing a value of type a.This is not+ guaranteed to keep some packed value, and unpack can fail. We do so because often we need to accept values of such type from user, and also because there is no simple way to check validity of packed data without performing full unpack. So this wrapper is rather a hint for users.lorentz0Everything which is represented as bytes inside.lorentzxSign data using Ed25519 curve. TODO [#456]: handle other methods, either all at once (if viable) or each one separatelylorentzEvaluate hash in Haskell world.None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmplorentz-This function transforms Lorentz values into  script_expr. script_expr is used in RPC as an argument in entrypoint designed for getting value by key from the big_map in Babylon. In order to convert value to the  script_expr9 we have to pack it, take blake2b hash and add specific expr prefix. Take a look at  https://gitlab.com/tezos/tezos/blob/6e25ae8eb385d9975a30388c7a7aa2a9a65bf184/src/proto_005_PsBabyM1/lib_protocol/script_expr_hash.ml and  https://gitlab.com/tezos/tezos/blob/6e25ae8eb385d9975a30388c7a7aa2a9a65bf184/src/proto_005_PsBabyM1/lib_protocol/contract_services.ml#L136 for more information.lorentz Similar to , but for values encoded as s. This is only used in tests.None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp"lorentz(Retain the value only if it is not zero.lorentz Drop top n elements from the stack.lorentz Version of G which uses Peano number. It is inteded for internal usage in Lorentz.lorentz Version of G which uses Peano number. It is inteded for internal usage in Lorentz.lorentz 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.lorentz Version of @ that works for lambdas with arbitrary length input and output.lorentz Version of G which uses Peano number. It is inteded for internal usage in Lorentz.lorentz(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 s^ you can not have this evidence (the value is only available in runtime). If you have typed ,, use S to construct s.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 Q.=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 <, but throw an error on attempt to overwrite existing entry.p      !"#$%&'()*+,-./p./      !"#$%&'()*+,-None8!"#$%&'*,-.012456789;<=>?@ACHMNPSUVX_`befgkmp2lorentz<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.3lorentz3Duplicate an element of stack referring it by type.IIf stack contains multiple entries of this type, compile error is raised.4lorentzFDip 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.5lorentz2Remove element with the given type from the stack.345345 None9!"#$%&'*,-.012456789:;<=>?@AHMNPSUVX_`befgkmp~*<lorentz Documentation for custom errors.,Mentions that entrypoint throws given error.>lorentz(Mentions that contract uses given error.Alorentz/What should happen for this error to be raised.BlorentzBrief version of AR. This will appear along with the error when mentioned in entrypoint description.?By default, the first sentence of the full description is used.Clorentz Error class.~By default this returns "unknown error" class; though you should provide explicit implementation in order to avoid a warning.Dlorentz(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 anotherElorentz=Error class on how the error should be handled by the client.FlorentzRNormal expected error. Examples: "insufficient balance", "wallet does not exist".GlorentzaInvalid 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.HlorentzzUnexpected error. Most likely it means that there is a bug in the contract or the contract has been deployed incorrectly.Ilorentz/It's possible to leave error class unspecified.lorentzHow K& is actually represented in Michelson.KlorentzMaterial custom error.:Use this in pattern matches against error (e.g. in tests).Olorentz"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.!This is the basic [error format].PlorentzType wrapper for an IsError.Rlorentz!Use this type as replacement for () when you really( want to leave error cause unspecified.UlorentzConstraints which we require in a particular instance. You are not oblidged to often instantiate this correctly, it is only useful for some utilities.Vlorentz?Name of error as it appears in the corresponding section title.Wlorentz/What should happen for this error to be raised.XlorentzBrief version of W.This will appear along with the error when mentioned in entrypoint description. By default, the first sentence of the full description is used.Ylorentz)How this error is represented in Haskell.Zlorentz Error class.[lorentz8Which definitions documentation for this error mentions.\lorentzCaptured constraints which we require in a particular instance. This is a way to encode a bidirectional instance in the nowaday Haskell, for (class MyConstraint => ErrorHasDoc MyType instance it lets deducing  MyConstraint by ErrorHasDoc MyType.tYou are not oblidged to always instantiate, it is only useful for some utilities which otherwise would not compile.]lorentz Haskell type representing error.^lorentzConverts a Haskell error into Value representation._lorentz Converts a Value into Haskell error.alorentzImplementation of ^ via m.blorentzImplementation of _ via m.lorentz!Helper for managing descriptions.clorentz"Fail with the given Haskell value.dlorentzTFail, providing a reference to the place in the code where this function is called.Like 3? in Haskell code, this instruction is for internal errors only.elorentz/Description of error representation in Haskell.florentzDemote error tag to term level.hlorentzFail with given custom error.ilorentzSpecialization of h for no-arg errors.jlorentz3Whether given error class is about internal errors.]Internal errors are not enlisted on per-entrypoint basis, only once for the entire contract.klorentzImplementation of _ (of \A 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.nlorentz)This instance cannot be implemented, use ] instance instead.vlorentzIf K{ constructor is not provided its argument, we assume that this is no-arg error and interpret the passed value as complete.ylorentz"Use this for internal errors only.NormalF error scenarios should use the mechanism of custom errors, see below.0<=>?@ABCDEIHFGJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk0]^_`abTUVWXYZ[\kejRSPQcdOKLMNhJiEIHFG@ABCD>?<=gf!None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp@lorentz!QuasiQuote that helps generating ParameterHasEntrypoints instance.Usage: [entrypointDoc| Parameter <parameter-type> <optional-root-annotation> |] [entrypointDoc| Parameter plain |] [entrypointDoc| Parameter plain "root"|]  See this  ,https://indigo-lang.gitlab.io/contract-docs/tutorial! which includes this quasiquote.lorentz!QuasiQuote that helps generating CustomErrorHasDoc instance.Usage: t[errorDoc| <error-name> <error-type> <error-description> |] [errorDoc| "errorName" exception "Error description" |]  See this  ,https://indigo-lang.gitlab.io/contract-docs/tutorial! which includes this quasiquote.lorentz!QuasiQuote that helps generating  TypeHasDoc instance.Usage: V[typeDoc| <type> <description> |] [typeDoc| Storage "This is storage description" |]  See this  ,https://indigo-lang.gitlab.io/contract-docs/tutorial! which includes this quasiquote."None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp 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).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 string is used as a tag, but it is not found in the passed map, we conservatively preserve that string (because this whole approach is rather a heuristic).  #None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpklorentzPContract initiator should be contract admin in order to perform this operation.$None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpelorentz!Replacement for uninhabited type.lorentz)Witness of that this code is unreachable.lorentzSomeone constructed  type.%None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmplorentzCoercions between a to b are permitted and safe.lorentzCoercion from a to b is permitted and safe.lorentzExplicitly allowed coercions.a  b proclaims that a can be casted to b& without violating any invariants of b.This relation is reflexive; it may be symmetric or not. It tends to be composable: casting complex types usually requires permission to cast their respective parts; for such types consider using 4 as implementation of the method of this typeclass.For cases when a cast from a to b| requires some validation, consider rather making a dedicated function which performs the necessary checks and then calls  forcedCoerce.lorentzAn optional method which helps passing -Wredundant-constraints check. Also, you can set specific implementation for it with specific sanity checks.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.iThis function is not safe in a sense that this allows * breaking invariants of casted type (example: UStore from morley-upgradeable), 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.lorentzImplementation of { for types composed from smaller types. It helps to ensure that all necessary constraints are requested in instance head.+,+,&None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp8%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 .lorentzview! type synonym as described in A1.lorentzwConstraint for updateN that combines kind-agnostic constraint for Lorentz (Haskell) types and for our typed Michelson.lorentz$Kind-agnostic constraint for updateNlorentzxConstraint for replaceN that combines kind-agnostic constraint for Lorentz (Haskell) types and for our typed Michelson.lorentz%Kind-agnostic constraint for replaceNlorentz(Various convenient instructions on maps.lorentzSpecialized version of .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 ,  and . 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.lorentzInsert given element into set.!This is a separate function from  updateMap4 because stacks they operate with differ in length.lorentzWInsert 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.!lorentz^Replace nth element (0-indexed) with the one on the top of the stack. For example, `replaceN 93` replaces the 3rd element with the 0th one. `replaceN D0` is not a valid operation (and it is not implemented). `replaceN n1` is equivalent to `swap # drop` (and is the only one implemented like this). In all other cases `replaceN $n` will drop the nth element (`dipN 6n drop`) and then put the 0th one in its place (`dug (n-1)`)."lorentzReplaces the nth element (0-indexed) with the result of the given "updating" instruction (binary with the return type equal to the second argument) applied to the 0th element and the nth element itself. For example, `updateN 53 cons` replaces the 3rd element with the result of ; applied to the topmost element and the 3rd one. `updateN I0 instr` is not a valid operation (and it is not implemented). `updateN 1 instr` is equivalent to instr$ (and so is implemented). `updateN c2 instr` is equivalent to `swap # dip instr` (and so is implemented). In all other cases `updateN En instr` will put the topmost element right above the nth one (`dug L(n-1)`) and then apply the function to them in place (`dipN @(n-1) instr`).%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.,lorentz*Wrap internal representation of void 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./lorentzPush 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.0lorentz$Get address of the current contract.0TODO [#373]: reimplement this using SELF_ADDRESS1lorentz0Duplicate two topmost items on top of the stack.4lorentz5Retain the value if it is not equal to the given one. non 0 -$ 5Just 5 non 0 -$ 0Nothing5lorentz Version of 4 with a custom predicate. non' eq0 -$ 5Just 5 non' eq0 -$ 0Nothing6lorentz!Check whether container is empty.k      !"#$%&'()*+,-./0123456k      !"(%&'+*,-)123456$#./0None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpM YlorentzPredicate 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 ifilorentzNExplicitly named binary condition, to ensure proper order of stack arguments.jlorentz"Provide the compared arguments to if branches.klorentz Aliases for p used by do-blocks.llorentzDefines semantics of if ... then ... else ... construction.mlorentzNamed version of e.In this and similar operators you provide names of accepted stack operands as a safety measure of that they go in the expected order.nlorentzNamed version of f.olorentzNamed version of g.plorentzNamed version of h.qlorentzNamed version of c.rlorentzNamed version of d.slorentzVCondition modifier, makes stack operands of binary comparison to be available within if branches. Y^]Z[\_`abcdefghijklmnopqrs klY^]Z[\_`abcdefghijmnopqrsm4n4o4p4q4r4'None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpilorentz;Helper typeclass which overloads representation for errors.lorentzHError representation with respect to tags being changed to numeric ones.tlorentz'Some error with a numeric tag attached.lorentzHPseudo error which stands for textual errors converted to numeric codes.ulorentzBHandler which changes documentation for one particular error type.vlorentz Errors for ulorentz=Given handler is not suitable, probably another one will fit.lorentzGGiven handler suits and tells that given error should remain unchanged.wlorentz0Adds a section which explains error tag mapping.ylorentz=Describes where the error tag map is defined in Haskell code.lorentz@Anchor which refers to the section describing error tag mapping.zlorentz:Modify documentation generated for given code so that all KX mention not their textual error tag rather respective numeric one from the given map.hIf some documented error is not present in the map, it remains unmodified. This function may fail with 3- if contract uses some uncommon errors, see { for details.{lorentzExtended version of z which accepts error handlers.In most cases that function should be enough for your purposes, but it uses a fixed set of base handlers which may be not enough in case when you define your own errors. In this case define and pass all the necessary handlers to this function.It fails with 3S if some of the errors used in the contract cannot be handled with given handlers.|lorentzHandler for all Ks.}lorentz Handler for .lorentz#Handler for textual error messages.~lorentz3Handlers for most common errors defined in Lorentz. tuvwxyz{|}~ wxyz{uv|}~t1None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpltuvwxyz{|}~(None8!"#$%&'*,-./012456789;<=>?@AHMNPSUVX_`befgkmpFlorentz*Helper which documents single constructor.lorentz0Information to be provided for documenting some  x.lorentzImplementation for b of the corresponding  Extensible.lorentzImplementation for ] 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)None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp$lorentzLorentz version of '.*None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpplorentzLorentz version of 23.lorentzInvert an isomorphism.lorentz2Given a function that is its own inverse, make an  using it in both directions.lorentzPThe isomorphism between two values with identical representation and semantics.lorentzAThe isomorphism between two values with identical representation.The same precautions as for  apply here.lorentz,The isomorphism between raw and named value.lorentzbAbsence of value on the left hand side is associated with the given value on the right hand side.lorentzdAbsence of value on the left hand side is associated with the default value on the right hand side. This is more general version of  nonIso ldef) since it can work with e.g. containers.  None8!"#$%&'*,-.012456789;<=>?@ACHMNPSUVX_`befgkmp/lorentzDProvides "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-Construct an object from fields on the stack.lorentz*Decompose a complex object into its fieldslorentz)Lift an instruction to field constructor.lorentz0Wrap entry in constructor. Useful for sum types.lorentz=Wrap entry in single-field constructor. Useful for sum types.lorentz$Pattern match on the given sum type.You have to provide a 6; 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 45 and ensure that his tuple isn't bigger than generated instances, if so, he should probably extend number of generated instances.lorentz?Unwrap a constructor with the given name. Useful for sum types.%)*+,-654cd%dc654,-+)*00+None8!"#$%&'*,-.012456789;<=>?@ACHMNPSUVX_`befgkmp22lorentzIConcise way to write down constraints with expected content of a storage.Use it like follows: type StorageConstraint store = StorageContains store [ "fieldInt" := Int , "fieldNat" := Nat , "epsToNat" := Int ::-> Nat , "balances" := Address ~> Int ] lorentz-Indicates a stored entrypoint with the given param and store types.lorentz2Indicates a submap with given key and value types.lorentz*Provides operations on stored entrypoints.store/ is the storage containing both the entrypoint epName (note: it has to be in a e/ to take advantage of lazy evaluation) and the epStore field this operates on.lorentz/Datatype containing the full implementation of  typeclass.We use this grouping because in most cases the 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 the  DerivingVia extension.)lorentzType synonym of a e mapping 8 (entrypoint names) to .*This is useful when defining instances of S as a storage field containing one or more entrypoints (lambdas) of the same type.lorentzType synonym for a ^" that can be used as an entrypointlorentz*Provides operations on submaps of storage.lorentz/Datatype containing the full implementation of  typeclass.We use this grouping because in most cases the 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 the  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 the 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 the  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.lorentzExtracts and executes the epNameE entrypoint lambda from storage, returing the updated full storage (store) and the produced Os.lorentzPick stored entrypoint lambda.lorentzIGet stored entrypoint lambda, preserving the storage itself on the stack.lorentzBStores the entrypoint lambda in the storage. Fails if already set.lorentz5Pick the sub-storage that the entrypoint operates on.lorentzaGet the sub-storage that the entrypoint operates on, preserving the storage itself on the stack.lorentz7Update the sub-storage that the entrypoint operates on.lorentzImplementation of 0 for case of datatype keeping a pack of fields.lorentzImplementation of  for a datatype keeping a pack of fields, among which one has contains the entrypoint and another is what such entrypoint operates on.lorentzImplementation of  for a datatype that has a  for an $ that contains the entrypoint and a , for the field such entrypoint operates on.lorentzImplementation of  for a datatype that has a % that contains the entrypoint and a , for the field such entrypoint operates on.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.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 0 implementation is made up for field with name  desiredNameE, not its actual name. Logic of the implementation remains the same. See also  . lorentzPretend that given 5 implementation is made up for entrypoint with name  desiredNameE, not its actual name. Logic of the implementation remains the same. See also  . lorentz>Change field operations so that they work on a modified field.For instance, to go from $StoreFieldOps Storage "name" Integer to /StoreFieldOps Storage "name" (value :! Integer) you can use "mapStoreFieldOps (namedIso #value) lorentz=Change submap operations so that they work on a modified key.lorentz?Change submap operations so that they work on a modified value.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.lorentziChain implementations of two submap operations sets. Used to provide shortcut access to a nested submap.This is very inefficient since on each access to substore it has to be serialized/deserialized. Use this implementation only if due to historical reasons migrating storage is difficult.LIso (Maybe substore) substore argument describes how to get substoreP value if it was absent in map and how to detect when it can be safely removed.Example of use: HsequenceStoreSubmapOps #mySubmap nonDefIso storeSubmapOps storeSubmapOpslorentzETurn submap operations into operations on a part of the submap value.>Normally, if you need this set of operations, it would be better to split your submap into several separate submaps, each operating with its own part of the value. This set of operations is pretty inefficient and exists only as a temporary measure, if due to historical reasons you have to leave storage format intact.0This implementation puts no distinction between value == Nothing and value == Just defValue cases. Getters, when notice a value equal to the default value, report its absence. Setters tend to remove the value from submap when possible.LIso (Maybe value) value and LIso (Maybe subvalue) subvaluex arguments describe how to get a value if it was absent in map and how to detect when it can be safely removed from map.Example of use: PzoomStoreSubmapOps #mySubmap nonDefIso nonDefIso storeSubmapOps storeFieldOpsADTlorentz Utility to push the 8! name of and entrypoint from its 9lorentzUtility to extract an  from a , fails in case of .lorentzUtility to set an < into a store. Fails in case the entrypoint is already set.lorentzUtility to create s from an entrypoint name (epName ) and an F implementation. Note that you need to merge multiple of these (with 9) if your field contains more than one entrypoint lambda.lorentz< can be used as standalone key-value storage if very needed.lorentze\ can be used as standalone key-value storage, name of submap is not accounted in this case.?     ?     9 9 ,None8!"#$%&'*,-.012456789;<=>?@ACHMNPSUVX_`befgkmpGD lorentz Version of  for multiple variables.Ltype HasContext = HasNamedVars s ["x" := Integer, "f" := Lambda MText MText]lorentzIndicates that stack s contains a  name :! var or  name :? var value.lorentz*1-based position of the variable on stack.lorentzRequires type x to be an unnamed variable. When e.g. b sees a polymorphic variable, it can't judge whether is it a variable we are seeking for or not;  VarIsUnnamedE helps to assure the type system that given variable won't be named.lorentz with pretty error message.lorentzGet variable name.lorentzName of a variable on stack.lorentzGet the variable at nO-th position on stack, assuming that caller is sure that stack is long enough.@martoon: I'm not ready to fight the compiler regarding numerous complex constraints, so just assuring it that those constraints will hold.lorentz Version of ' that leaves a named variable on stack.lorentz>Take the element with given label on stack and copy it on top.eIf there are multiple variables with given label, the one closest to the top of the stack is picked.None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp,"lorentz6Provides arror for convenient entrypoint documentation#lorentzLift 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.$lorentzConstraint for .%lorentzPick a type documentation from .'lorentz$Describes argument of an entrypoint.)lorentz!Argument of the entrypoint. Pass  if no argument is required.*lorentzhDescribes a way to lift an entrypoint argument into full parameter which can be passed to the contract.Steps are supposed to be applied in the order opposite to one in which they are given. E.g. suppose that an entrypoint is called as Run (Service1 arg)C; then the first step (actual last) should describe wrapping into RunQ constructor, and the second step (actual first) should be about wrapping into Service1 constructor.+lorentz[Untyped representation of entrypoint, used for printing its michelson type representation.,lorentz$Describes a parameter building step.SThis can be wrapping into (Haskell) constructor, or a more complex transformation.-lorentzWraps something into constructor with given name. Constructor should be the one which corresponds to an entrypoint defined via field annotation, for more complex cases use /..lorentz;Directly call an entrypoint marked with a field annotation./lorentz Other action.0lorentzThis entrypoint cannot be called, which is possible when an explicit default entrypoint is present. This is not a true entrypoint but just some intermediate node in orP tree and neither it nor any of its parents are marked with a field annotation.It contains dummy ,Bs which were assigned before entrypoints were taken into account.3lorentz'Plain english description of this step.4lorentz+How to construct parameter in Haskell code.5lorentz4How to construct parameter working on raw Michelson.6lorentzgWhen describing the way of parameter construction - piece of incremental builder for this description.8lorentzuArgument stands for previously constructed parameter piece, and returned value - a piece constructed after our step.9lorentz.Inserts a reference to an existing entrypoint.fThis helps to avoid duplication in the generated documentation, in order not to overwhelm the reader.;lorentz=Describes the behaviour common for entrypoints of given kind.cThis has very special use cases, like contracts with mix of upgradeable and permanent entrypoints.<lorentz3Describes the behaviour common for all entrypoints.}For instance, if your contract runs some checks before calling any entrypoint, you probably want to wrap those checks into EentrypointSection "Prior checks" (Proxy @CommonContractBehaviourKind).=lorentzDefault value for B type argument.>lorentz4Describes location of entrypoints of the given kind.All such entrypoints will be placed under the same "entrypoints" section, and this instance defines characteristics of this section.?lorentzzPosition of the respective entrypoints section in the doc. This shares the same positions space with all other doc items.@lorentz+Name of the respective entrypoints section.Alorentz2Description in the respective entrypoints section.Blorentz,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.Florentz"Pattern that checks whether given  hides B" inside (of any entrypoint kind).0In case a specific kind is necessary, use plain (cast -> Just DEntrypoint{..}) construction instead.GlorentzDefault implementation of  for entrypoints.Hlorentz0Mark code as part of entrypoint with given name.JThis is automatically called at most of the appropriate situations, like P calls.lorentzShow what given 6 does on a sample.IlorentzMake a ,Z that tells about wrapping an argument into a constructor with given name and uses given 6# as description of Michelson part.lorentz5Go over contract code and update every occurrence of '5 documentation item, modifying param building steps.Nlorentz5Go 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.OlorentzLike >, to be used for pattern-matching on a parameter or its part.}Modifies documentation accordingly. Including description of entrypoints' arguments, thus for them you will need to supply \ instance.Plorentz Version of O for tuples.QlorentzjWrapper 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.RlorentzWModify param building steps with respect to entrypoints that given parameter declares.Each contract with entrypoints should eventually call this function, otherwise, in case if contract uses built-in entrypoints feature, the resulting parameter building steps in the generated documentation will not consider entrypoints and thus may be incorrect.9Calling this twice over the same code is also prohibited.)In simple contracts you may prefer using U.SlorentzWhether R) has already been applied to these steps.Ulorentz Version of PC for contracts with flat parameter, use it when you need only one P& all over the contract implementation.This method calls R inside.lorentz6Surrouned a markdown text in a span tag with given id.9;UV !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU9BCDEF>?@AH9:"#=<;G'()*+UV%&67812345,-./0INJK;LM$QPORSTU! -None7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmpRlorentz5Generic traversal for conversion between ADT sum and z.jlorentz1Entry points template derived from given ADT sum.klorentzConstraint required by .llorentz#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.mlorentz=An action invoked when user-provided entrypoint is not found.nlorentz%Implementations of some entry points.,Note that this thing inherits properties of 6, 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.rlorentz"This class is needed to implement s.slorentzTurn za into a Haskell value. Since we don't know its type in compile time, we have to erase it using tu. The user of this function can require arbitrary constraint to hold (depending on how they want to use the result).tlorentzBThis type can store any value that satisfies a certain constraint.vlorentz>Ensure that given entry points do no contain duplicated names.wlorentz,Get type of entrypoint argument by its name.xlorentzHomomorphic version of z, forgets the exact interface.ylorentzPseudo value for z type variable.zlorentzpEncapsulates 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.|lorentz6A convenient alias for type-level name-something pair.}lorentzGAn entrypoint is described by two types: its name and type of argument.~lorentz Construct a z safely.lorentz-Helper instruction which extracts content of z.lorentzDefault implementation for m, simply reports an error.lorentzPattern-match on given UParam entries.bYou have to provide all case branches and a fallback action on case when entrypoint is not found.lorentzLike (, but accepts a tuple of clauses, not a 6.lorentzMake up z from ADT sum.'Entry points template will consist of '(constructorName, constructorFieldType)@ pairs. Each constructor is expected to have exactly one field.lorentz:Note that calling given entrypoints involves constructing z.lorentzAllows casts only between x and z.jklmnoqprstuvwxyz{|}~z{}|~tursyxnmoqplwvkjNone7!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp "!    $# %&'()*+,-./0123654789 :;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\[]^_`abcdefghijklmnponqrstuvwxyz{|}~     !"#$%&'()*,-./012346788CEFGHIJFGOPQRST[\]^_`abcdefghijklmnopqrstu~+,,/01789:;<=>?@ABCDEFGHIJKL[\]^_`abcdefghijklm      !"#$%&'()*+,-./345<=>?@ABCDEIHFGJKLMNOPQRSTUVWXYZ[\U]^_`abcdefghijk      !"#$%&'()*+,-./0123456Y^]Z[\_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUjklmnoqprstuvwxyz{|}~ "!    $# %&'()*+,-./0123654789 :;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\[]^_`abcdefghijklmnponqrstuvwxyz{|}~     !"#$%&'()*,-./01234678CEFGHIJOPQRST[\]^_`abcdefghijklmnopqrstu~+,/01789:;<=>?@ABCDEFGHIJKL[\]^_`abcdefghijklm      !"#$%&'()*+,-./345<=>?@ABCDEIHFGJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk      !"#$%&'()*+,-./0123456Y^]Z[\_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUjklmnoqprstuvwxyz{|}~6None8!"#$%&'*,-.012456789;<=>?@AHMNPSUVX_`befgkmp7897:;78<7=>78?78@78A78B78C7DEFGHFGI7JK78L78MFNOPQR7ST7UV7WXFNY7UZ7U[FN\7W]7W^_`abcd78efgh7ij7kl7kl7Dm7Dn78o78pqrsftuvwxvwyz{|z{}z{~z{z{9       !"#$$%&'(()*)+,,-./0012233456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkl m n o o p q r s t u v w x y y z { | } ~                                                .                                            !"#$%&'()(*(+(,(-(.(/(01123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}}~  2      !"#$%&'()*+,-./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,RSTUVWXYZZ[\]^_`abccdefgghiijklmnopqqrstuvwxyz{|}~------------------------------------------------------- 7   #$&&&&&'''''' ' ( ( ( ((((((FN+++,,,,, !"#$%-&-'-(6)6*6+6,6-6.6/601lorentz-0.8.0-inplaceLorentz.PreludeLorentz.Rebinded Lorentz.ValueLorentz.Constraints.Scopes Lorentz.ADTLorentz.AnnotationLorentz.Entrypoints.Doc Lorentz.DocLorentz.AddressLorentz.OpSizeLorentz.Entrypoints.HelpersLorentz.Entrypoints.CoreLorentz.Constraints.Derivative Lorentz.BaseLorentz.Common Lorentz.ExtLorentz.PolymorphicLorentzLorentz.Entrypoints.Impl Lorentz.ArithLorentz.WrappableLorentz.Entrypoints.Manual Lorentz.Run Lorentz.Print Lorentz.ZipLorentz.Run.SimpleLorentz.ContractRegistry Lorentz.Bytes Lorentz.Pack Lorentz.InstrLorentz.ReferencedLorentz.ErrorsLorentz.Util.THLorentz.Errors.Numeric.ContractLorentz.Errors.Common Lorentz.EmptyLorentz.Coercions Lorentz.MacroLorentz.Errors.Numeric.DocLorentz.ExtensibleLorentz.Default Lorentz.IsoLorentz.StoreClassLorentz.ReferencedByNameLorentz.UParamNiceParameterFullLorentz.ConstraintsLorentz.EntrypointsLorentz.Errors.Numeric Control.LensIsoUtil.TypeTuple Instances Paths_lorentzbaseGHC.Base$GHC.Num fromIntegerreturn Data.String fromString<>memptymappendmconcatpureGHC.EnumBoundedghc-prim GHC.ClassesEqOrd GHC.GenericsGeneric SemigroupMonoid GHC.TypesBoolinteger-wired-inGHC.Integer.TypeInteger GHC.NaturalNatural GHC.MaybeMaybe Data.EitherEitherFalseNothingJustTrueLeftRightbytestring-0.10.10.0Data.ByteString.Internal ByteString text-1.2.4.0Data.Text.InternalText.containers-0.6.2.1Data.Map.InternalMapGHC.OverloadedLabels fromLabel Data.ProxyProxymaxBoundminBoundstimessconcatQconstraints-0.12-219813e80846a99ce76bdb4a8e0b66c26d970340aef6c06b2fe8a5b96699e0aaData.ConstraintwithDictData.Set.InternalSet[data-default-class-0.1.2.0-cd82420962fb1bb36843e51775abe5ffe3c35016e35b1db0a0fccf8ccfb6a31dData.Default.ClassDefaultdefNnamed-0.3.0.1-c213d4c2c01df3dfd493e55bc222296fdaec9c9d140602f3c9de6390e6f03aa3Named.InternalargDefargFarg:!:?Xtext-manipulate-0.2.0.1-0b1092dc65bf581af911191b4232d056cc36b45e84e5aeda1ab3652751fe21faData.Text.ManipulatetoSnaketoPascaltoCamelPuniversum-1.6.1-feb74d29edc41a61b0de06fa402f3d29121212e577bc6fc320dbebeb8a0f5a01Universum.TypeOpsUniversum.Debug undefinederrorMvinyl-0.12.1-7eed6fcae264e50bba3530560fb2a8e8cadbc76c371a4c09876689da9126d803Data.Vinyl.Core:&RNilRecmorley-1.10.0-inplaceMichelson.TextmtMText Util.LabelLabelMichelson.Typed.Annotation insertTypeAnnMichelson.Typed.ExtractmkUTypeMichelson.Typed.Haskell.DocconcreteTypeDocHaskellRepconcreteTypeDocHaskellRepUnsafeconcreteTypeDocMichelsonRep!concreteTypeDocMichelsonRepUnsafecustomTypeDocMdReferencedTypeDepgenericTypeDocDependencieshaskellAddNewtypeFieldhaskellRepNoFieldshaskellRepStripFieldPrefixhomomorphicTypeDocHaskellRephomomorphicTypeDocMdReferencehomomorphicTypeDocMichelsonReppoly1TypeDocMdReferencepoly2TypeDocMdReferenceMichelson.Typed.Haskell.ValuecoerceContractRefMichelson.Untyped.Entrypoints DefEpNameMichelson.Untyped.OpSizeopSizeHardLimitsmallTransferOpSizeMichelson.Typed.Aliases OperationValueMichelson.Typed.Entrypoints EpAddress eaAddress eaEntrypointDTypeHaveCommonTypeCtor IsHomomorphicSomeTypeWithDocTypeDocFieldDescriptions TypeHasDoctypeDocDependenciestypeDocHaskellReptypeDocMdDescriptiontypeDocMdReferencetypeDocMichelsonRep typeDocName%Michelson.Typed.Haskell.Instr.ProductConstructorFieldTypesInstrConstructCBigMapunBigMap ContractRef crAddress crEntrypointEntrypointCallIsoValueToTfromValtoValSomeEntrypointCallWellTypedIsoValueEpNameOpSizeunOpSize Tezos.AddressAddress Tezos.CoreChainId Tezos.CryptoKeyHashMutez PublicKey Signature TimestamponeMuteztimestampFromSecondstimestampFromUTCTimetimestampQuotetoMutez zeroMutezGHasAnnotationgGetAnnotation HasAnnotation getAnnotation annOptionsGenerateFieldAnnFlagGenerateFieldAnnNotGenerateFieldAnnFollowEntrypointFlagFollowEntrypointNotFollowEntrypoint AnnOptionsfieldAnnModifierdefaultAnnOptionsdropPrefixThenappendToctorNameToAnnWithOptionsgGetAnnotationNoField$fGHasAnnotation:*:$fGHasAnnotation:+:$fGHasAnnotationM1$fGHasAnnotationM10$fGHasAnnotationM11$fGHasAnnotationM12$fGHasAnnotationU1 Michelson.Doc SomeDocItem DocGroupingcontractDocToMarkdowndocDefinitionRefdocItemPositiondocItemSectionRef mdTocFromRefmkDGitRevisionmorleyRepoSettingssubDocToMarkdown ContractDoc cdContentscdDefinitionIds cdDefinitionscdDefinitionsSetDAnchorDComment DDescription DGitRevisionDGitRevisionKnownDGitRevisionUnknownDocElemdeItemdeSubDocItemDocItemPlacementDocItemReferenceddocItemDependencies docItemPos docItemRefdocItemSectionDescriptiondocItemSectionNamedocItemSectionNameStyledocItemToMarkdown docItemToToc docItemsOrder DocItemIdDocItemPlacementKindDocItemInDefinitionsDocItemInlined DocItemPos DocItemRef DocItemNoRefDocItemRefInlined DocSectionDocSectionNameStyleDocSectionNameBigDocSectionNameSmallGitRepoSettingsgrsMkGitRevisionSomeDocDefinitionItemSubDoc Util.MarkdownMarkdown$fGHasAnnotationK1$fHasAnnotation(,,,,,,)$fHasAnnotation(,,,,,)$fHasAnnotation(,,,,)$fHasAnnotation(,,,)$fHasAnnotation(,,)$fHasAnnotation(,)$fHasAnnotationEither$fHasAnnotationOperation'$fHasAnnotation[]$fHasAnnotationSet$fHasAnnotationBigMap$fHasAnnotationMap$fHasAnnotationContractRef$fHasAnnotationChainId$fHasAnnotationSignature$fHasAnnotationPublicKey$fHasAnnotationTimestamp$fHasAnnotationKeyHash$fHasAnnotationEpAddress$fHasAnnotationAddress$fHasAnnotationMutez$fHasAnnotationByteString$fHasAnnotationBool$fHasAnnotationMText$fHasAnnotationNatural$fHasAnnotationInteger$fHasAnnotation()$fHasAnnotationMaybe$fHasAnnotationNamedF$fHasAnnotationNamedF0NiceComparableNicePrintedValueNiceFullPackedValueNiceUnpackedValueNicePackedValue NiceConstant NiceStorage NiceParameter CanHaveBigMapNoBigMapNoContractType NoOperation KnownValueniceParameterEviniceStorageEviniceConstantEvinicePackedValueEviniceUnpackedValueEvinicePrintedValueEvi $fKnownValuea$fNoOperationa$fNoContractTypea $fNoBigMapa$fCanHaveBigMapaRequireSumTypeCanHaveEntrypointsShouldHaveEntrypointsunHasEntrypoints ctorNameToAnn ctorNameToEp$fGenericShouldHaveEntrypoints$fIsoValueShouldHaveEntrypointsEpdNoneParameterContainsEntrypoints:>HasEntrypointOfType TrustEpNameHasDefEntrypointArgHasEntrypointArguseHasEntrypointArgGetEntrypointArgCustomNiceEntrypointName EntrypointRef CallDefaultCallNoExplicitDefaultEntrypointForbidExplicitDefaultEntrypointGetDefaultEntrypointArgGetEntrypointArgLookupParameterEntrypointAllParameterEntrypointsGetParameterEpDerivationParameterDeclaresEntrypointsParameterHasEntrypointsParameterEntrypointsDerivation EpCallingStep EpsWrapIn EpCallingDescepcdArgepcdEntrypoint epcdStepsEpConstructionRes EpConstructedEpConstructionFailedRequireAllUniqueEntrypointsRequireAllUniqueEntrypoints'EntrypointsDerivationEpdAllEntrypointsEpdLookupEntrypointepdNotesepdCallepdDescspepNotespepCallpepDescspepDescsWithDefparameterEntrypointsToNotesparameterEntrypointCallparameterEntrypointCallDefaultsepcCallRootCheckedeprNameparameterEntrypointCallCustom#$fHasEntrypointArgkcpTrustEpNamearg$$fEntrypointsDerivationTYPEEpdNonecp($fHasEntrypointArgTYPEcpEntrypointRefarg$fShowEpCallingStep$fEqEpCallingStep$fShowEpCallingDescMapLorentzInstrmapLorentzInstrLambda&SomeContractCode ContractCode ContractOut%>:-> LorentzInstrunLorentzInstrFII iGenericIfiAnyCodeiNonFailingCode iMapAnyCode iForceNotFailiWithVarAnnotations#parseLorentzValuetransformStringsLorentztransformBytesLorentzoptimizeLorentzWithConfoptimizeLorentz $fMonoid:->$fSemigroup:->$fBuildableParseLorentzError$fMapLorentzInstr:-> $fShow:->$fEq:->$fShowParseLorentzError$fEqParseLorentzError Entrypoint_ EntrypointFromContractReffromContractRef ToContractRef toContractRef ToTAddress toTAddress ToAddress toAddressFutureContractunFutureContract ToTAddress_TAddress unTAddresscallingTAddresscallingDefTAddress toTAddress_convertContractRef$fHasAnnotationFutureContract$fIsoValueFutureContract$fToAddressContractRef$fToAddressFutureContract$fToAddressTAddress$fToAddressEpAddress$fToAddressAddress$fToTAddresscpTAddress$fToTAddresscpAddress$fToContractRefargTAddress$fToContractRefcpFutureContract$fToContractRefcpContractRef$fFromContractRefcpAddress$fFromContractRefcpEpAddress!$fFromContractRefcpFutureContract$fFromContractRefcpContractRef$fGenericTAddress$fIsoValueTAddress$fHasAnnotationTAddressstackRef printComment testAssert stackTypeEDivOpHs 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$fEDivOpHsIntegerIntegerUtil.CustomGenericcstr customGenericfld leftBalancedleftComb rightBalanced rightComb withDepths PrintAsValueList$fBuildablePrintAsValue BuildEPTreeEPTreeEPNodeEPLeaf EPDelegatePlainEntrypointsC EpdWithRoot EpdDelegate EpdRecursiveEpdPlain $fGEntrypointsNotesmodeEPLeaf:*:$fGEntrypointsNotesmodeEPLeafU1*$fGEntrypointsNotesEpdDelegateEPDelegateK1$fGEntrypointsNotesmodeepM1$fGEntrypointsNotesmodeEPNodeM1 $fGEntrypointsNotesmodeEPNode:+:$fGEntrypointsNotesmodeepM10#$fGEntrypointsNotesEpdRecursiveepK1($fEntrypointsDerivationTYPEEpdWithRootcp($fEntrypointsDerivationTYPEEpdDelegatecp)$fEntrypointsDerivationTYPEEpdRecursivecp%$fEntrypointsDerivationTYPEEpdPlaincp#$fGEntrypointsNotesmodeEPDelegateM1$fGEntrypointsNotesmodeEPLeafM1UnaryArithOpHsUnaryArithResHs 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 Wrappable Unwrappable$fWrappableNamedF$fWrappableNamedF0ParameterWrapperunParameterWraper)$fParameterHasEntrypointsParameterWrapper2$fEntrypointsDerivationTYPEPwDerivParameterWrapper$fGenericParameterWrapper$fIsoValueParameterWrapper$fWrappableParameterWrapperContractcCodecDisableInitialCastcCompilationOptionsCompilationOptionscoOptimizerConfcoStringTransformercoBytesTransformerdefaultCompilationOptionscompileLorentzcompileLorentzWithOptionsdefaultContractcompileLorentzContractinterpretLorentzInstrinterpretLorentzLambdaanalyzeLorentzprintLorentzValueprintLorentzContractcontractOpSize valueOpSize ZipInstrsZipInstr ZippedStack zipInstrTypedunzipInstrTypedzipInstr unzipInstr zippingStackunzippingStack$fHasAnnotation:-> $fIsoValue:-> $fZipInstr: $fZipInstr:0 $fZipInstr[]-$?-$&?-&-<-$>DEntrypointExampledocdocGroup docStorage contractNamebuildLorentzDoccontractGeneralcontractGeneralDefaultbuildLorentzDocWithGitRevrenderLorentzDocrenderLorentzDocWithGitRevcutLorentzNonDocmkDEntrypointExample$fTypeHasDocFutureContract$fTypeHasDocTAddress$fTypeHasDoc:->$fDocItemDEntrypointExample CmdLnArgsPrintDocumentAnalyze PrintStorageContractRegistryunContractRegistry ContractInfo ciContractciIsDocumentedciStorageParserciStorageNotes?::printContractFromRegistryDoc argParserrunContractRegistry$fBuildableContractRegistryBlake2bSha512Sha256DHashAlgorithmKnownHashAlgorithmhashAlgorithmName computeHashtoHashHash HashUnsafeunHash TSignature unTSignaturePackedunPacked BytesLiketoBytes lSignEd22519toHashHs$fBytesLikeByteString$fTypeHasDocPacked$fBuildablePacked$fTypeHasDocTSignature$fBuildableTSignature$fBuildableHash$fDocItemDHashAlgorithm$fOrdDHashAlgorithm$fEqDHashAlgorithm$fKnownHashAlgorithmSha256$fKnownHashAlgorithmSha512$fKnownHashAlgorithmBlake2b$fTypeHasDocHash $fShowPacked $fEqPacked $fOrdPacked$fGenericPacked$fIsoValuePacked$fHasAnnotationPacked$fBytesLikePacked$fShowTSignature$fGenericTSignature$fIsoValueTSignature$fHasAnnotationTSignature $fShowHash$fEqHash $fOrdHash $fGenericHash$fIsoValueHash$fHasAnnotationHash$fBytesLikeHash lPackValueRawlUnpackValueRaw lPackValue lUnpackValue lEncodeValuevalueToScriptExprexpressionToScriptExprNonZerononZeroLorentzFunctorlmapConstraintDIPNLorentzConstraintDUGLorentzConstraintDIGLorentznop justCommentcommentcommentAroundFuncommentAroundStmtdropdropNdupswapdigPeanodigdugPeanodugpushsomenoneunitifNonepaircarcdrleftrightifLeftnilconsifConssizeemptySetemptyMap emptyBigMapmapitermemgetupdateif_looploopLeftlambdaexecexecuteapply applicatedip dipNPeanodipNfailWithcastpackunpackpackRaw unpackRawconcatconcat'sliceisNataddsubrsubmuledivabsneglsllsrorandxornotcompareeq0neq0lt0gt0le0ge0intself selfCallingcontractcontractCallingcontractCallingUnsaferunFutureContractepAddressToContracttransferTokens setDelegatecreateContractimplicitAccountnowamountbalancecheckSignaturesha256sha512blake2BhashKeysourcesenderaddresschainIdframedfailingWhenPresent updateNew$fLorentzFunctorMaybe$fNonZeroNatural$fNonZeroIntegerdupTdipTdropT$fDupTorigSta:$fDupTorigSta:0$fDupTorigSta[]$fDipTorigSta:dipInpdipOutout1$fDipTorigSta:dipInpdipOutout$fDipTorigSta[]dipInpdipOutoutDThrowsDErrorCustomErrorHasDoccustomErrDocMdCausecustomErrDocMdCauseInEntrypointcustomErrClasscustomErrArgumentSemantics ErrorClassErrClassActionExceptionErrClassBadArgumentErrClassContractInternalErrClassUnknownRequireNoArgError CustomErrorceTagceArgErrorArg SomeErrorUnspecifiedError ErrorHasDocErrorRequirements errorDocNameerrorDocMdCauseerrorDocMdCauseInEntrypointerrorDocHaskellRep errorDocClasserrorDocDependencieserrorDocRequirementsIsError errorToVal errorFromVal ErrorScope isoErrorToValisoErrorFromVal failUsingfailUnexpectedcustomErrorDocHaskellRepGeneralerrorTagToMTexterrorTagToText failCustom failCustom_isInternalErrorClass typeDocMdDescriptionReferToError$fShow->$fEq->$fIsoValueCustomError$fBuildableCustomError$fBuildableErrorClass$fReadErrorClass$fErrorHasDoc->$fErrorHasDocUnspecifiedError$fErrorHasDoc()$fErrorHasDocMText $fIsError->$fIsErrorUnspecifiedError $fIsError()$fIsErrorMText$fShowSomeError$fBuildableSomeError $fEqSomeError$fErrorHasDocCustomError$fIsErrorCustomError$fDocItemDError $fOrdDError $fEqDError$fDocItemDThrows $fEqDThrows$fGenericUnspecifiedError$fIsoValueUnspecifiedError$fLiftErrorClass$fShowCustomError$fEqCustomError entrypointDocerrorDoctypeDocErrorTagExclusions ErrorTagMapgatherErrorTagsaddNewErrorTagsbuildErrorTagMapexcludeErrorTagsapplyErrorTagMapapplyErrorTagMapWithExclusionsuseNumericErrorserrorFromValNumericerrorToValNumeric%$fCustomErrorHasDoc"senderIsNotAdmin"Emptyabsurd_"$fCustomErrorHasDoc"emptySupplied"$fTypeHasDocEmpty$fGenericEmpty$fIsoValueEmpty$fHasAnnotationEmpty Coercible_ Castable_ CanCastTo castDummyMichelsonCoercible forcedCoerce forcedCoerce_gForcedCoerce_ fakeCoerce fakeCoercing coerceWrap coerceUnwraptoNamed fromNamed checkedCoercecheckedCoerce_checkedCoercing_allowCheckedCoerceToallowCheckedCoerce castDummyG$fCanCastToTYPETYPEHashHash'$fCanCastToTYPETYPETSignatureTSignature$fCanCastToTYPETYPEPackedPacked!$fCanCastToTYPETYPEHashByteString'$fCanCastToTYPETYPETSignatureByteString#$fCanCastToTYPETYPEPackedByteString*$fCanCastToTYPETYPEFutureContractEpAddress"$fCanCastToTYPETYPEAddressTAddress"$fCanCastToTYPETYPETAddressAddress!$fCanCastToTYPETYPE(,,,,,)(,,,,,)$fCanCastToTYPETYPE(,,,,)(,,,,)$fCanCastToTYPETYPE(,,,)(,,,)$fCanCastToTYPETYPE(,,)(,,)$fCanCastToTYPETYPE(,)(,)$fCanCastToTYPETYPENamedFNamedF)$fCanCastToTYPETYPEContractRefContractRef$fCanCastToTYPETYPE:->:->$fCanCastToTYPETYPEBigMapBigMap$fCanCastToTYPETYPEMapMap$fCanCastToTYPETYPESetSet$fCanCastToTYPETYPEEitherEither$fCanCastToTYPETYPEMaybeMaybe$fCanCastToTYPETYPE[][]$fCanCastTokkaa VoidResult unVoidResultVoid_ voidParam voidResProxyView viewParamviewCallbackToUpdateN updateNImplConstraintUpdateNLorentzReplaceN replaceNImplConstraintReplaceNLorentz mapInsert mapInsertNew deleteMapDuupX duupXImplConstraintDuupXLorentzeqneqgtlegeltifEq0ifNeq0ifLt0ifGt0ifLe0ifGe0ifEqifNeqifLtifGtifLeifGefail_assert assertEq0 assertNeq0 assertLt0 assertGt0 assertLe0 assertGe0assertEq assertNeqassertLtassertGtassertLeassertGe assertNone assertSome assertLeft assertRight assertUsingdropXcloneXduupXframedNpapairppaiirunpaircdarcddrcaarcadrsetCarsetCdrmapCarmapCdrifRightifSomewhen_unless_whenSomewhenNone setInsert setInsertNew setDeletereplaceNupdateNbuildViewTuple buildViewmkViewwrapView unwrapViewview_ voidResultTagmkVoidvoid_wrapVoid unwrapVoidaddressToEpAddresspushContractRef selfAddressdupTop2 fromOptionisSomenonnon'isEmpty $fCloneXSas $fCloneXZas$fDuupX[][]Ssas1tail$fDuupXkkS:as1tail$fDuupXkkSsas1tail$fMapInstrsBigMap$fMapInstrsMap$fReplaceN[][]Ssamidtail$fReplaceNkkSsamidtail$fUpdateN[][]Ssabmidtail$fUpdateNk[]Ssabmidtail$fUpdateNk[]Ssabmidtail0$fBuildableView$fBuildableView0$fTypeHasDocView$fCanCastToTYPETYPEViewView$fBuildableVoid_$fTypeHasDocVoid_$fCanCastToTYPETYPEVoid_Void_$fIsoValueVoidResult$fErrorHasDocVoidResult$fIsErrorVoidResult$fTypeHasDocVoidResult$fEqView $fShowView $fGenericView$fHasAnnotationView$fGenericVoid_ $fShowVoid_$fHasAnnotationVoid_$fGenericVoidResult$fEqVoidResult$fIsoValueVoid_$fIsoValueView ConditionHoldsIsSomeIsNoneIsLeftIsRightIsConsIsNilIsZero IsNotZeroIsEqIsNeqIsLtIsGtIsLeIsGeNamedBinConditionPreserveArgsBinCondition>> ifThenElse<.>.<=.>=.==./=. keepIfArgsNumericErrorWrapperNumericErrorDocHandlerNumericErrorDocHandlerErrorDDescribeErrorTagMap detmSrcLocapplyErrorTagToErrorsDocapplyErrorTagToErrorsDocWithcustomErrorDocHandlervoidResultDocHandlerbaseErrorDocHandlers$fDocItemDDescribeErrorTagMap$fErrorHasDocNumericTextError$fErrorHasNumericDocVoidResult$fErrorHasNumericDocCustomError $fErrorHasDocNumericErrorWrapper$fEqDDescribeErrorTagMap$fOrdDDescribeErrorTagMapExtensibleHasDocextensibleDocNameextensibleDocDependenciesextensibleDocMdDescriptionExtConversionErrorConstructorIndexNotFoundArgumentUnpackFailedWrapExtCExtVal ExtensibletoExtVal fromExtValwrapExt$fWrapExtNoFields$fWrapExtOneField$fBuildableExtConversionError$fGExtValkt:+:$fGExtValTYPEtM1$fGExtValTYPEtM10 $fGExtValktM1$fTypeHasDocExtensible$fDocumentCtorCtor$fGenericExtensible$fEqExtensible$fShowExtensible$fIsoValueExtensible$fHasAnnotationExtensible$fWrappableExtensible$fEqExtConversionError$fShowExtConversionErrorLDefaultldeflIsDef $fLDefault(,)$fLDefaultNamedF $fLDefaultMap $fLDefaultSet $fLDefault[]$fLDefaultNatural$fLDefaultIntegerLIsoliToliFrom invertIso involutedIsocheckedCoerceIsoforcedCoerceIsonamedIsononIso nonDefIsoCaseTC CaseArrow/-> CaseClauseLHasFieldsOfType:= NamedFieldHasFieldOfTypeHasFieldtoField toFieldNamedgetField getFieldNamedsetField modifyField construct constructTconstructStack deconstruct fieldCtorwrap_wrapOnecase_caseT unwrapUnsafe_$fCaseArrownamebodyCaseClauseLStorageContains::->~>StoreHasEntrypoint storeEpOpsStoreEntrypointOps sopToEpLambdasopSetEpLambda sopToEpStore sopSetEpStoreEntrypointsFieldEntrypointLambdaStoreHasSubmapstoreSubmapOpsStoreSubmapOpssopMemsopGet sopUpdate sopDelete sopInsert StoreHasField storeFieldOps StoreFieldOps sopToField sopSetField stToField stGetField stSetFieldstMemstGetstUpdatestDeletestInsert stInsertNew stEntrypoint stToEpLambda stGetEpLambda stSetEpLambda stToEpStore stGetEpStore stSetEpStorestoreFieldOpsADTstoreEntrypointOpsADTstoreEntrypointOpsFieldsstoreEntrypointOpsSubmapFieldstoreFieldOpsDeeperstoreSubmapOpsDeeperstoreEntrypointOpsDeeperstoreSubmapOpsReferTostoreFieldOpsReferTostoreEntrypointOpsReferTomapStoreFieldOpsmapStoreSubmapOpsKeymapStoreSubmapOpsValuecomposeStoreFieldOpscomposeStoreSubmapOpssequenceStoreSubmapOpscomposeStoreEntrypointOpszoomStoreSubmapOps mkStoreEp$fStoreHasSubmapMapnamekeyvalue"$fStoreHasSubmapBigMapnamekeyvalue HasNamedVars HasNamedVar VarIsUnnamed dupLNameddupL$fHasNamedVar[]namevar$fElemHasNamedVar:namevarFalse$fElemHasNamedVar:namevarTrue$fHasNamedVar:namevarRequireFlatEpDerivationRequireFlatParamEps EntryArrow#->DocumentEntrypointsDeriveCtorFieldDocderiveCtorFieldDocDEntrypointArgepaArg epaBuildingepaTypeParamBuildingStep PbsWrapInPbsCallEntrypoint PbsCustom PbsUncallableParamBuildingDesc pbdEnglish pbdHaskell pbdMichelson ParamBuilderunParamBuilderDEntrypointReferenceCommonEntrypointsBehaviourKindCommonContractBehaviourKindPlainEntrypointsKindEntrypointKindHasDocentrypointKindPosentrypointKindSectionName entrypointKindSectionDescription DEntrypointdepNamedepSubDEntrypointDocItemdiEntrypointToMarkdownentrypointSection mkPbsWrapInconstructDEpArg emptyDEpArg mkDEpUTypemkDEntrypointArgSimpleclarifyParamBuildingSteps entryCase_ entryCasedocumentEntrypointfinalizeParamCallingDocareFinalizedParamBuildingStepsentryCaseSimple_entryCaseSimple$fDocItemDEntrypoint*$fEntrypointKindHasDocPlainEntrypointsKind1$fEntrypointKindHasDocCommonContractBehaviourKind4$fEntrypointKindHasDocCommonEntrypointsBehaviourKind$fDocItemDEntrypointReference$fEqParamBuilder$fShowParamBuilder$fBuildableParamBuilder$fBuildableParamBuildingStep$fDocItemDEntrypointArg$fDeriveCtorFieldDocconOneField$fDeriveCtorFieldDocconNoFields$fGDocumentEntrypointskindM1$fGDocumentEntrypointskind:+:$fGDocumentEntrypointskindM10$fEntryArrowTYPEkindnamebody$fShowParamBuildingDesc$fEqParamBuildingDesc$fShowParamBuildingStep$fEqParamBuildingStepUParamLinearizedUParamLinearize CaseUParamUParamFallbackEntrypointsImplEntrypointLookupErrorNoSuchEntrypoint UnpackUParam unpackUParamConstrainedSomeRequireUniqueEntrypointsLookupEntrypointUParam_ SomeInterfaceUParam UParamUnsafe?:EntrypointKindmkUParam unwrapUParamuparamFallbackFail caseUParam caseUParamT uparamFromAdt pbsUParam/$fCustomErrorHasDoc"uparamArgumentUnpackFailed"+$fCustomErrorHasDoc"uparamNoSuchEntrypoint"$fBuildableCustomError0$fTypeHasDocUParam$fCanCastToTYPETYPEUParamUParam$fBuildableConstrainedSome$fShowConstrainedSome$fCaseArrowname'bodyCaseClauseU $fBuildableEntrypointLookupError$fUnpackUParamc:$fUnpackUParamc[] $fCaseUParam:$fCaseUParam[]$fGUParamLinearizeM1$fGUParamLinearizeM10$fGUParamLinearizeM11$fGUParamLinearize:+:$fGUParamLinearizeM12$fGenericUParam $fEqUParam $fShowUParam$fIsoValueUParam$fHasAnnotationUParam$fWrappableUParam$fGenericEntrypointLookupError$fEqEntrypointLookupError$fShowEntrypointLookupErrorNamedEpMichelson.Typed.ArithOrParseLorentzErrorMichelson.PreprocesstransformStringstransformBytesMichelson.Typed.PolymorphicEDivOpSliceOpConcatOpGetOpUpdOpSizeOpMichelson.Typed.TTIterOpMapOpMemOpKeyQformatting-6.3.7-049a4dda9be71694fc22278f1b9dd369bec3241f8b1c00e31eebc244eddd3029Formatting.Buildable BuildableGHC.ShowShowGEntrypointsNotesEntrypointsNotesgMkEntrypointsNotesAllEntrypointsNotesTOrmkEntrypointsNotesmkEpLiftSequence mkEpDescs UnaryArithOpArithOp##DGeneralInfoSectionHashAlgorithmKindMorley.Micheline.Expression ExpressionMichelson.Typed.InstrCONTRACTSELFDipTDupTCustomErrorReppickFirstSentenceerrorsDocumentationFAILWITHD:R:ErrorArg"senderIsNotAdmin"D:R:ErrorArg"emptySupplied"UpdateNConstraint'ReplaceNConstraint' MapInstrs mapUpdateDuupXConstraint'ErrorHasNumericDocnumericErrorDocHaskellRepNumericTextErrorEheNotApplicableEheConversionUnnecessarydDescribeErrorTagMapAnchortextErrorDocHandler DocumentCtorGExtVal GGetCtorsEnumerateCtorsCtorKindCtor LookupCtorWrapExt packForWrap!Michelson.Typed.Haskell.Instr.Sum CaseClauseTypepushStEpsomeStEpsetStEp varPosition VarNamePrettyVarNameVarNamed dupLUnsafeGDocumentEntrypointsgDocumentEntrypointsdocumentEntrypoints CtorFieldpbSamplemodifyParamBuildingStepsmdAddIdGUParamLinearizecaseUParamUnsafe CaseClauseUversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName