h)o      !"#$%&'()*+,-./0123456789:;<=>? @ A B C D E F G H I J K L M N O P Q RS T U V WXY Z [ \ ] ^ _ ` a b c d e f g h i j k l m n opqrstu v w x yz{|}~                                                                                                                                                                                                                                                                                                                                                                                                        ! ! ! " " " " " " " " " " " # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #                                 $ $ $ $ $ $ $ $ $ % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %                              & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ( ( ( ( ( ( ( ( ( ( ) ) ) ) ) ) ) ) ) ) ) * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + , ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,----------............................./////////////////////////0111111111111111111111111111111111111111111111111111111112222222222222222222222222222222222233333445555555555555555555560.16.0< Safe-Inferred;"$%&'()*-/01235689:;<=?0{lorentz Check if a  type is a sum type.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..Allows generic derivation. The type must have Generic and IsoValue instances.data Foo = Fooinstance HasAnnotation Foo...... GHC.Generics.Rep Foo... is stuck. Likely... Generic Foo(... instance is missing or out of scope....+data Foo = Foo deriving (Generic, IsoValue)instance HasAnnotation FoolorentzUsed in  as a flag to track whether or not field/constructor annotations should be generated.lorentzUsed in  and  as a flag to track whether or not it directly follows an entrypoint to avoid introducing extra entrypoints.lorentzAllow customization of field annotation generated for a type when declaring its  instance.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.1=1= Safe-Inferred;"$%&'()*-/01235689:;<=?@ lorentzConstraint applied to a big_map value type.Shows human-readable errors:.emptyBigMap @Integer @(BigMap Integer Integer)...... Type `big_map` found in... 'TBigMap 'TInt 'TInt ... is not allowed in this scope...Also on ambiguity:emptyBigMap @Integer...... Can't check if type ... ToT v0/... contains `big_map`. Perhaps you need to add... NiceNoBigMap v0:... constraint? You can also try adding a type annotation....lorentzConstraint applied to any type, to check if Michelson representation (if exists) of this type is Comparable. In case it is not prints human-readable error messageemptySet @[Integer]...... Non-comparable type... 'TList 'TInt ... is not allowed in this scope...emptySet...... Can't check if type ... ToT e0:... contains non-comparable types. Perhaps you need to add... NiceComparable e0:... constraint? You can also try adding a type annotation....lorentz3Constraint applied to a value returned from a view.Shows human-readable errors:view' @"SomeView" @Operation...... Type `operation` found in... 'TOperation ... is not allowed in this scope...Also on ambiguity:view' @"SomeView"...... Can't check if type ... ToT ret0... contains `operation`, `big_map` or `ticket`. Perhaps you need to add... NiceViewable ret0:... constraint? You can also try adding a type annotation....lorentz-Constraint applied to a value being unpacked.Shows human-readable errors:unpack @Operation...... Type `operation` found in... 'TOperation ... is not allowed in this scope...Also on ambiguity:unpack...... Can't check if type ... ToT a0... contains `operation`, `big_map`, `contract`, `ticket` or `sapling_state`. Perhaps you need to add... NiceUnpackedValue a0:... constraint? You can also try adding a type annotation....lorentz+Constraint applied to a value being packed.Shows human-readable errors:pack @Operation...... Type `operation` found in... 'TOperation ... is not allowed in this scope...Also on ambiguity:pack...... Can't check if type ... ToT a0... contains `operation`, `big_map`, `ticket` or `sapling_state`. Perhaps you need to add... NicePackedValue a0:... constraint? You can also try adding a type annotation....lorentz Constraint applied to constants.Shows human-readable errors: ticket # dup...... Type `ticket` found in... 'TOption ('TTicket (ToT a)) ... is not allowed in this scope...Also on ambiguity:dup...... Can't check if type ... ToT a0.... contains `ticket`. Perhaps you need to add... Dupable a0:... constraint? You can also try adding a type annotation....pretty $ dup @Integer[DUP]lorentz Constraint applied to constants.)Shows human-readable errors on ambiguity:push undefined...... Can't check if type ... ToT t0... contains `operation`, `big_map`, `contract`, `ticket` or `sapling_state`. Perhaps you need to add... NiceConstant t0:... constraint? You can also try adding a type annotation....pretty $ push (1 :: Integer) [PUSH int 1]lorentz3Constraint applied to any part of a parameter type.Use 7 instead when you need to know the contract's entrypoints at compile-time.Shows human-readable errors:epAddressToContract @Operation...... Type `operation` found in... 'TOperation ... is not allowed in this scope...Also on ambiguity:epAddressToContract...... Can't check if type ... ToT p0... contains `operation` or nested `big_map`s. Perhaps you need to add... NiceParameter p0:... constraint? You can also try adding a type annotation....lorentz/Ensure given type does not contain "operation".lorentz2Gathers constraints, commonly required for values.++ Safe-Inferred;"$%&'()*-/01235689:;<=?Blorentz%Ensure that given type is a sum type.This helps to prevent attempts to apply a function to, for instance, a pair.lorentzUsed to understand whether a type can potentially declare any entrypoints.lorentzA 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. Safe-Inferred;"$%&'()*-/01235689:;<=?c,lorentzNo 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 .lorentzChecks 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  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,  type serves this purpose. If entrypoint name is not known, one can use  wrapper to take responsibility for presence of this entrypoint.If you want to call a function which has this constraint, you have two options: Pass contract parameter cp using type application, pass  as a value and pass entrypoint argument. Type system will check that cp1 has an entrypoint with given reference and type.Pass  wrapped into  and entrypoint argument. In this case passing contract parameter is not necessary, you do not even have to know it.You may need to add this constraint for polymorphic arguments. GHC should tell you when that is the case::{ ?f :: forall (cp :: Type). ParameterDeclaresEntrypoints cp => ()f = useHasEntrypointArg @cp @_ @(Maybe Integer) CallDefault & const ():}...'... Can not look up entrypoints in type... cp7... The most likely reason it is ambiguous, or you need... HasEntrypointArg cp (EntrypointRef 'Nothing) (Maybe Integer)... constraint...If GHC can't deduce the type of entrypoint argument, it'll use an unbound type variable, usually arg0, in the error message::{ ?f :: forall (cp :: Type). ParameterDeclaresEntrypoints cp => ()2f = useHasEntrypointArg @cp CallDefault & const ():}...'... Can not look up entrypoints in type... cp7... The most likely reason it is ambiguous, or you need7... HasEntrypointArg cp (EntrypointRef 'Nothing) arg0... constraint...lorentz;Data returned by this method may look somewhat arbitrary.  is obviously needed because name can be  or . Dict is returned because in  case we get this evidence for free and don't want to use it. We seem to always need it anyway.lorentzUniversal entrypoint lookup.lorentz3Constraint on type-level entrypoint name specifier.lorentzWhich entrypoint to call.We intentionally distinguish default and non-default cases because this makes API more details-agnostic.lorentzCall 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.Unfortunately, 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 , but in a version which the compiler can work with (and which produces errors confusing for users :/)lorentz6Ensure that there is no explicit "default" entrypoint.lorentz:Get type of entrypoint with given name, fail if not found.lorentz:Get type of entrypoint with given name, fail if not found.lorentz#Lookup for entrypoint type by name.4Does not treat default entrypoints in a special way.lorentz+Get all entrypoints declared for parameter.lorentz Version of  which we actually use in function signatures. When given type is sum type or newtype, we refer to 9, otherwise we suppose that no entrypoints are declared.lorentz$Parameter declares some entrypoints.This is a version of  which we actually use in constraints. When given type is a sum type or newtype, we refer to 5 instance, otherwise this instance is not necessary.lorentz+Which entrypoints given parameter declares.Note that usually this function should not be used as constraint, use  for this purpose.lorentz&Wrap into constructor with given name.lorentz%How one of the entrypoints is called.Type 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.lorentz0Ensure that all declared entrypoints are unique.lorentzDefines a generalized way to declare entrypoints for various parameter types.8When defining instances of this typeclass, set concrete deriv argument and leave variable cp argument. Also keep in mind, that in presence of explicit default entrypoint, all other  arms should be callable, 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.lorentzName 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.Note [order of entrypoints children]: If this contains entrypoints referring to indermediate nodes (not leaves) in or tree, then each such entrypoint should be mentioned eariler than all of its children.lorentz Get entrypoint argument by name.lorentzConstruct parameter annotations corresponding to expected entrypoints set.This method is implementation detail, for actual notes construction use .lorentzConstruct entrypoint caller.This does not treat calls to default entrypoint in a special way.This method is implementation detail, for actual entrypoint lookup use .lorentz:Description of how each of the entrypoints is constructed.lorentz Version of  which we actually use in code. It hides derivations stuff inside, and treats primitive types specially like  does.lorentz Version of  which we actually use in code. It hides derivations stuff inside, and treats primitive types specially like  does.lorentz Version of  which we actually use in code. It hides derivations stuff inside, and treats primitive types specially like  does.lorentz;Descriptions of how each of the entrypoints is constructed. Similar to , but includes default entrypoint disregard whether it is explicit or not, while  includes it only if it is explicit. Also this returns list, not 5, for simplicity.Note that [order of entrypoints children] property still holds here.lorentz'Derive annotations for given parameter.lorentz!Prepare call to given entrypoint.This does not treat calls to default entrypoint in a special way. To call default entrypoint properly use .lorentzCall the default entrypoint.lorentzCall root entrypoint safely.lorentzUniversal entrypoint calling.550 Safe-Inferred;"$%&'()*-/01235689:;<=?d #(4 &'% 320 #(4 &'% 320  Safe-Inferred;"$%&'()*-/01235689:;<=?klorentzHelper typeclass to demote s to s.lorentz)Interface of a single view at term-level.lorentzMap views to get their names.lorentzConstraint indicating that presence of the view with the specified parameters is implied by the views descriptor.lorentz#Reveal views and find a view there.lorentz"Find a view in a contract by name.lorentzA views descriptor that directly carries the full list of views.lorentz+Get a list of views by a descriptor object.The problem this type family solves: it is unpleasant to carry around a list of views because it may be large, and if we merely hide this list under a type alias, error messages will still mention the type alias expanded. We want e.g.  Contract Parameter Storage Views to be carried as-is.  Parameter and Storage5 are usually datatypes and they are fine, while for Views? to be not automatically expanded we have to take special care."You can still provide the list of s to this type family using , but generally prefer creating a dedicated datatype that would expand to a views list.lorentzNeat constructor for .*type View = "view" ?:: Integer >-> Naturallorentz$Type-level information about a view.lorentz/Demote view name from type level to term level.lorentzDemote s to s.lorentzDemote views descriptor to s.lorentzCheck that the given set of views covers the given view interfaces. Extra views in the set, that do not appear in the interface, are fine.SUTVSUTVU53 Safe-Inferred;"$%&'()*-/01235689:;<=?olorentzRequire views set referred by the given views descriptor to be proper.lorentzRequire views set to be proper.lorentz+Tells whether given type is dupable or not.lorentz-Constraint applied to a whole parameter type.lorentzCheck whether given value is dupable, returning a proof of that when it is.This lets defining methods that behave differently depending on whether given value is dupable or not. This may be suitable when for the dupable case you can provide a more efficient implementation, but you also want your implementation to be generic.Example: code = case decideOnDupable @a of IsDupable -> do dup; ... IsNotDupable -> ... 8 Safe-Inferred;"$%&'()*-/01235689:;<=?p:+  Safe-Inferred;"$%&'()*-/01235689:;<=?|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.lorentzAn instruction sequence taking one stack element as input and returning one stack element as output. Essentially behaves as a Michelson lambda without any additional semantical meaning.The reason for this distinction is Michelson lambdas allow instructions inside them that might be forbidden in the outer scope. This type doesn't add any such conditions.lorentz An alias for ':.We discourage its use as this hinders reading error messages (the compiler inserts unnecessary parentheses and indentation).lorentzCompiled Lorentz contract.Note, that the views argument (views descriptor) is added comparing to the Michelson. In Michelson, ability to call a view is fully checked at runtime, but in Lorentz we want to make calls safer at compile-time.lorentzReady contract code.lorentz%Contract that contains documentation.We have to keep it separately, since optimizer is free to destroy documentation blocks. Also, it is not  9: but Lorentz code because the latter is easier to modify.lorentzWrap contract code capturing the constraint that the code is not inside a view.lorentz Alias for 3, seems to make signatures more readable sometimes.:Let's someday decide which one of these two should remain.lorentz$An always-stuck type family to stub { for lorentz code z instance.lorentzEssentially, a compatibility notice. Constructing a value from code directly isn't possible any more.:set -XQualifiedDoimport Lorentzimport Prelude ():{ 7some_code :: KnownValue a => s :-> ('[a] :-> '[()]) : ssome_code = Lorentz.do push Lorentz.do drop unit:}...... Since the introduction of recursive lambdas in the Lima protocol,:... Lorentz code (:->) is no longer isomorphic to lambdas.... Construct a lambda value explicitly using mkLambda or mkLambdaRec....:{2some_code :: KnownValue a => s :-> Lambda a () : ssome_code = Lorentz.do push $ mkLambda Lorentz.do drop unit:}lorentzAlias for instruction which hides inner types representation via T.lorentzA helper to construct  that provides Y constraint.lorentzDemote Lorentz  to Michelson typed .lorentz&Function composition for instructions.Note that, unlike Morley's :; operator,  is left-associative.lorentzParse textual representation of a Michelson value and turn it into corresponding Haskell value.Note: it won't work in some complex cases, e. g. if there is a lambda which uses an instruction which depends on current contract's type. Obviously it can not work, because we don't have any information about a contract to which this value belongs (there is no such contract at all).lorentzLorentz version of .lorentzLorentz version of .#Y#Y2118< Safe-Inferred;"$%&'()*-/01235689:;<=?ylorentz-Execute given instruction on truncated stack.This instruction requires you to specify the piece of stack to truncate as type argument.The complexity of this operation is linear in the number of instructions. If possible, avoid nested uses as that would imply multiple traversals. Worst case, complexity can become quadratic. Safe-Inferred;"$%&'()*-/01235689:;<=?lorentzInclude a value at given position on stack into comment produced by .  stackRef @0 includesthe top of the stacklorentz-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.This 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) stackType @'["balance" :! Integer, "toSpend" :! Integer, BigMap Address Integer]3Note that you can omit arbitrary parts of the type. >stackType @'["balance" :! Integer, "toSpend" :! _, BigMap _ _] Safe-Inferred;"$%&'()*-/01235689:;<=?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 pair, and this is not possible if entrypoint implementation ends with =.  Safe-Inferred;"$%&'()*-/01235689:;<=?^ lorentzConvert something from u in Haskell world.lorentzConvert something to u in Haskell world.lorentzWe use this type class to forcibly default ambiguous parameter type to (), but still allow for other types. It also doubles as a proxy for a custom .lorentzConvert something referring to a contract (not specific entrypoint) to  in Haskell world.lorentzConvert something to  in Haskell world.Use this when you want to access state of the contract and are not interested in calling it.lorentz!Address associated with value of  contract arg type. Places where u can appear are now severely limited, this type gives you type-safety of u 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 u, 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'.lorentzAddress which remembers the parameter and views types 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.lorentzFor a contract and an address of its instance, construct a typed address.lorentzTurn any typed address to u in Haskell world.This is an analogy of address to contract convertion in Michelson world, thus you have to supply an entrypoint (or call the default one explicitly).lorentzSpecialization of  to call the default entrypoint.lorentzCast something appropriate to .!Z[\]^uvwxQ"Z[\]^[uvwxQNone<"$%&'()*-/01235689:;<=?:lorentzValue returned by  READ_TICKET instruction.lorentz Provides 5 instance that prints Lorentz value via Michelson's X.7Result won't be very pretty, but this avoids requiring   or  instances.Xz{}|:$Z[\]^!"rstqWuvwxRy~9Q ,-;<?@Xz{}|:$Z[\]^[!"rstqWuvwxRy~9Q ,-;< Safe-Inferred;"$%&'()*-/01235689:;<=?E lorentzLifted .lorentzLifted .lorentzLifted .lorentzLifted .lorentzLifted .4This could be just a constraint alias, but to avoid  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 . Safe-Inferred;"$%&'()*-/01235689:;<=?_lorentzGeneric traversal for .lorentzReturns: 1. Notes corresponding to this level; 2. Field annotation for this level (and which should be used one level above).lorentz6Fetches information about all entrypoints - leaves of  tree.lorentz6Fetches information about all entrypoints - leaves of  tree.lorentz"Traverses sum type and constructs 7 which report constructor names via field annotations.lorentzBuild  by parameter type.lorentzEntrypoints tree - skeleton on  tree later used to distinguish between constructors-entrypoints and constructors which consolidate a whole pack of entrypoints.lorentz6We are in the intermediate node and need to go deeper.lorentzWe reached entrypoint argument.lorentzWe 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.In particular, it will traverse the immediate sum type, and require another  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  this gives you more control over where and how entrypoints will be derived.lorentz Extension of : on parameters being defined as several nested datatypes.In 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 z instance, this derivation way will not work. As a workaround, you can wrap your argument into some primitive (e.g. >).lorentzImplementation of  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.lorentzMakes 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.    Safe-Inferred;"$%&'()*-/01235689:;<=?l lorentz,Renders to documentation of view descriptor.lorentz,Provides documentation for views descriptor.Note that views descriptors may describe views that do not belong to the current contract, e.g. TAddress may refer to an external contract provided by the user in which we want to call a view.lorentz=Helper typeclass to renders information about view interface.lorentz1Renders to a line mentioning the view's argument.lorentz1Renders to a line mentioning the view's argument.lorentzRenders to a view section.lorentz)Modify the example value of an entrypointlorentzPut a document item.lorentzGroup documentation built in the given piece of code into block dedicated to one thing, e.g. to one entrypoint.)Examples of doc items you can pass here: , .lorentzInserts 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. .lorentz1Leave only instructions related to documentation.This function is useful when your method executes a lambda coming from outside, but you know its properties and want to propagate its documentation to your contract code.D_`EfeghijklmncdNabFCJLMIAOGHKBPD_`EfeghijklmncdNabFCJLMIAOGHKBP Safe-Inferred:"$%&'()*-/1235689:;<=? lorentz'Documentation item for hash algorithms.lorentzHash algorithm used in Tezos.lorentz Hash of type t evaluated from data of type a.lorentzOpen kind for hash algorithms, to make it more difficult to apply type arguments incorrectly.lorentz9Represents a signature, where signed data has given type.Since 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.lorentzSign data using lorentzEvaluate hash in Haskell world. Safe-Inferred;"$%&'()*-/01235689:;<=?lorentz-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. Safe-Inferred;"$%&'()*-/01235689:;<=?elorentz5Helper typeclass that provides default definition of .lorentzLifted .lorentz5Helper typeclass that provides default definition of .lorentzLifted . Safe-Inferred;"$%&'()*-/01235689:;<=?TlorentzClass that enables support of rounding operations for Lorentz non-integer valueslorentzSince Michelson doesn't support divide operation, we will use our own to represent divison of Fixed and Rational valueslorentzOperation that represents division of two values with a given result Safe-Inferred;"$%&'()*-/01235689:;<=?lorentzDeclares that it is safe to wrap an inner type to the given wrapper type. Can be provided in addition to .You can declare this instance when your wrapper exists just to make type system differentiate the two types. Example: !newtype TokenId = TokenId Natural.Do not define this instance for wrappers that provide some invariants. Example: UStore type from morley-upgradeable. is similar to lens Wrapped class without the method.lorentzDeclares that this type is just a wrapper over some other type and it can be safely unwrapped to that inner type.Inspired by lens Wrapped.Generic-derivable for newtypes.import Lorentz:{newtype Foo = Foo Integer deriving stock Generic+ deriving anyclass (IsoValue, Unwrappable):}IsoValue instance is mandatory, but  isn't:import Morley.Michelson.Typed.T:{ data Foo = Foo Integer--instance IsoValue Foo where type ToT Foo = TInt toVal (Foo i) = toVal i fromVal i = Foo $ fromVal i--instance Unwrappable Foo where! type Unwrappabled Foo = Integer:}lorentz2The type we unwrap to (inner type of the newtype).Used in constraint for Lorentz instruction wrapping into a Haskell newtype and vice versa. Safe-Inferred;"$%&'()*-/01235689:;<=?lorentzWrap parameter into this to locally assign a way to derive entrypoints for it.? Safe-Inferred;"$%&'()*-/01235689:;<=?`-- Safe-Inferred;"$%&'()*-/01235689:;<=? lorentz!Require several stacks to comply  constraint.lorentz"Zipping stack into tuple and back.lorentz-A type which contains the whole stack zipped.lorentz6Fold given stack into single value in typed Michelson.lorentz:Unfold given stack from a single value in typed Michelson.lorentzA type used to represent an empty zipped stack, isomorphic to a unit and represented as such in Michelson.lorentzA type used to represent a zipped stack of at least two elements, isomorphic to a pair and represented as such in Michelson.lorentz Version of / which performs some optimizations immediately.#In particular, this avoids glueing Nops and DIP Nops.lorentz#Fold given stack into single value.lorentz'Unfold given stack from a single value.lorentz'Flatten both ends of instruction stack.lorentz)Unflatten both ends of instruction stack.lorentzSuch definition seems the only possible one we can support efficiently.5 Safe-Inferred;"$%&'()*-/01235689:;<=?̚lorentzCoercions 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 .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.We discourage using this function on Lorentz types, consider using @A instead. One of the reasons for that is that in Lorentz it's common to declare types as newtypes consisting of existing primitives, and  forcedCoerce tends to ignore all phantom type variables of newtypes thus violating their invariants.lorentzConvert between values of types that have the same representation.This 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  to unwrap a haskell newtype.lorentzSpecialized version of  to wrap a haskell newtype. Works under  constraint, thus is not safe.lorentzSpecialized version of  to wrap into a haskell newtype. Requires  constraint.lorentz"Lift given value to a named value.lorentzUnpack named value.lorentz)Coercion in Haskell world which respects .lorentzCoerce 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.!Shows human-readable errors when up is stuck.data Foo = Foo#castDummyG (Proxy @Foo) (Proxy @())...... GHC.Generics.Rep Foo... is stuck. Likely... Generic Foo(... instance is missing or out of scope....data Foo = Foo deriving Generic#castDummyG (Proxy @Foo) (Proxy @())() Safe-Inferred;"$%&'()*-/01235689:;<=?υlorentz.A type synonym representing Michelson lambdas.lorentzA helper type to construct Lorentz lambda values; Use this for lambda values outside of Lorentz contracts or with push.lorentz4A constructor providing the required constraint for . This is the only way to construct a lambda that uses operations forbidden in views.lorentz4A constructor providing the required constraint for . This is the only way to construct a lambda that uses operations forbidden in views. Safe-Inferred;"$%&'()*-/01235689:;<=?xlorentz Drop top n elements from the stack.lorentzCopies a stack argument.Hit the  constraint? Polymorphism and abstractions do not play very well with this constraint, you can enjoy suffering from the linear types feature under various sauces: -The most trivial option is to just propagate % constraint when you want to use , this suits for case when you are not planning to work with non-dupable types like tickets."Sometimes it is possible to avoid . and use other instructions instead (e.g. ' allows splitting a pair without using s,  allows accessing a map value without implicit duplication). But you may have to learn to write code in a completely different way, and the result may be less efficient comparing to the option with using dup.Use  to provide two code paths - when type is dupable and when it is not.lorentz Version of  which uses Peano number. It is intended for internal usage in Lorentz.lorentz Version of  which uses Peano number. It is intended 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  which uses Peano number. It is intended for internal usage in Lorentz.lorentzManual variation of VIEW2 instruction. It is pretty much like Michelson's VIEW, you must make sure that the compiler can infer the argument and return types of the view.In most cases prefer %B instead.lorentz(Get a reference to the current contract.Note that, similar to  instruction, in Michelson  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 SELF before introduction of lightweight entrypoints feature. Thus the contract must not6 have explicit "default" entrypoint for this to work.If you are going to call a specific entrypoint of the contract, see .lorentzMake 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 CONTRACT before introduction of lightweight entrypoints feature. The contract must not5 have explicit "default" entrypoint for this to work.If you are going to call a specific entrypoint of the contract, see .lorentz '[()]; -> [Integer, MText, Natural, ()] :-> [Integer, MText, ()]dipSample1 = dipT @Natural:}pretty $ dipSample1 drop # zipInstr -$ 123 ::: [mt|Hello|] ::: 321 ::: ()123 : Hello : ():{ dipSample2 :: [Natural, ()] :-> '[()]; -> [Integer, MText, Natural, ()] :-> [Integer, MText, ()]/dipSample2 = dipT -- No type application needed:}pretty $ dipSample2 drop # zipInstr -$ 123 ::: [mt|Hello|] ::: 321 ::: ()123 : Hello : ():{ -- An implementation of dropT that demands a bit more from inference. dipSample3 :: forall a inp dinp dout out. ( DipT a inp dinp dout out , dinp ~ (a ': dout) ) => inp :-> outdipSample3 = dipT (drop @a):}:{pretty $ dipSample3 @Natural @'[Integer, MText, Natural, ()] # zipInstr' -$ 123 ::: [mt|Hello|] ::: 321 ::: ():}123 : Hello : ():{ _dipSampleErr1 :: [Natural, ()] :-> '[()]2 -> [Integer, MText, ()] :-> [Integer, MText, ()]_dipSampleErr1 = dipT @Natural:}...7... @ Element of type 'Natural' is not present on stack... '[Integer, MText, ()]...:{ _dipSampleErr2 :: [Natural, ()] :-> '[()] -> [Integer, MText, Natural, (), Natural] :-> [Integer, MText, ()]_dipSampleErr2 = dipT @Natural:}...... @ Ambiguous reference to element of type 'Natural' for stack-... '[Integer, MText, Natural, (), Natural]...:{_dipSampleErr3 :: '[] :-> '[()]; -> [Integer, MText, Natural, ()] :-> [Integer, MText, ()]_dipSampleErr3 = dipT @Natural:}...... @ dipT requires a Lorentz instruction that takes input on the stack.... lorentzDip down until an element of the given type is on top of the stack.If the stack does not contain an element of this type, or contains more than one, then a compile-time error is raised. lorentz9Allows duplicating stack elements referring them by type.:{dupSample1 :: [Integer, MText, ()] :-> [MText, Integer, MText, ()]dupSample1 = dupT @MText:} [MText, Integer, MText, ()]dupSample2 = dupT:} adupSampleErr1 = dupT @Bool:}...4... @ Element of type 'Bool' is not present on stack ... '[]...:{ $-- Should fully infer both wildcards-dupSampleErr2 :: _ :-> [Bool, Integer, _, ()]dupSampleErr2 = dupT:}...... @ Found type wildcard @_@1... standing for @'[Integer, Bool, ()] :: [*]@...1... @ Found type wildcard @_@ standing for @Bool@<... To use the inferred type, enable PartialTypeSignatures...:{ $-- Should fully infer both wildcards2_dupSampleErr3 :: [Integer, _, ()] :-> (Bool ': _)_dupSampleErr3 = dupT:}...1... @ Found type wildcard @_@ standing for @Bool@...... @ Found type wildcard @_@2... standing for @'[Integer, Bool, ()] :: [*]@... lorentz3Duplicate an element of stack referring it by type.If stack contains multiple entries of this type, compile error is raised. lorentz2Remove element with the given type from the stack.:{ [Integer, Natural]dropSample1 = dropT @():}5pretty $ dropSample1 # zipInstr -$ 123 ::: () ::: 321 123 : 321:{;dropSampleErr1 :: [Integer, Natural] :-> [Integer, Natural]dropSampleErr1 = dropT @():}...2... @ Element of type '()' is not present on stack... '[Integer, Natural]...:{3dropSampleErr1 :: [Integer, Integer] :-> '[Integer]dropSampleErr1 = dropT @Integer:}...... @ Ambiguous reference to element of type 'Integer' for stack... '[Integer, Integer]...   Safe-Inferred= "$%&'()*-/01235689:;<=>?0 lorentz Documentation for custom errors.,Mentions that entrypoint throws given error. lorentz(Mentions that contract uses given error. lorentz/What should happen for this error to be raised. lorentzBrief version of  . This will appear along with the error when mentioned in entrypoint description.?By default, the first sentence of the full description is used. lorentz Error class.By default this returns "unknown error" class; though you should provide explicit implementation in order to avoid a warning. lorentz(Clarification of error argument meaning.?Provide when it's not obvious, e.g. argument is not named with >.NOTE: This should not; be an entire sentence, rather just the semantic backbone.Bad: * 9Error argument stands for the previous value of approval. Good: * the previous value of approval * pair, first argument of which is one thing, and the second is another lorentz=Error class on how the error should be handled by the client. lorentzNormal expected error. Examples: "insufficient balance", "wallet does not exist". lorentzInvalid argument passed to entrypoint. Examples: your entrypoint accepts an enum represented as nat, 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. lorentzUnexpected error. Most likely it means that there is a bug in the contract or the contract has been deployed incorrectly. lorentz/It's possible to leave error class unspecified. lorentz3Typeclass implements various method that work with . lorentzHow  & is actually represented in Michelson. lorentzTo be used as ErrorArg) instances. This is equivalent to using () but using  UnitErrorArg is preferred since ()* behavior could be changed in the future. lorentzTo be used as ErrorArg$ instance when failing with just a string instead of  pair string x lorentzMaterial custom error.:Use this in pattern matches against error (e.g. in tests). lorentz"Declares a custom error, defining error name - error argument relation.=If your error is supposed to carry no argument, then provide ().Note that this relation is defined globally rather than on per-contract basis, so define errors accordingly. If your error has argument specific to your contract, call it such that error name reflects its belonging to this contract.!This is the basic [error format]. lorentzType wrapper for an IsError. lorentzUse this error when sure that failing at the current position is possible in no curcumstances (including invalid user input or misconfigured storage).To use this as error, you have to briefly specify the reason why the error scenario is impossible (experimental feature). lorentz!Use this type as replacement for () when you really( want to leave error cause unspecified. lorentzConstraints which we require in a particular instance. You are not oblidged to often instantiate this correctly, it is only useful for some utilities. lorentz?Name of error as it appears in the corresponding section title. lorentz/What should happen for this error to be raised. lorentzBrief version of  .This will appear along with the error when mentioned in entrypoint description. By default, the first sentence of the full description is used. lorentz)How this error is represented in Haskell. lorentz Error class. lorentz8Which definitions documentation for this error mentions. 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.You 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. lorentz"Fail with the given Haskell value. lorentzSince 008 it's prohibited to fail with non-packable values and with the 'Contract t' type values, which is equivalent to our  ConstantScope constraint. See  ;https://gitlab.com/tezos/tezos/-/issues/1093#note_496066354 for more information. lorentzImplementation of   via z. lorentzImplementation of   via z. lorentzBasic implementation for  .lorentz!Helper for managing descriptions. lorentzFail, providing a reference to the place in the code where this function is called.Like 2? in Haskell code, this instruction is for internal errors only. lorentzDemote error tag to term level. lorentzFail with given custom error. lorentzFail with given custom error. lorentzSpecialization of   for unit-arg errors. lorentz3Whether given error class is about internal errors.Internal errors are not enlisted on per-entrypoint basis, only once for the entire contract. lorentzImplementation of i (of f 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. lorentz)This instance cannot be implemented, use   instance instead. lorentzIf   constructor is not provided its argument, we assume that this is unit-arg error and interpret the passed value as complete. lorentz"Use this for internal errors only."Normal" error scenarios should use the mechanism of custom errors, see below.;  ;  ! Safe-Inferred;"$%&'()*-/01235689:;<=? lorentz!QuasiQuote that helps generating ParameterHasEntrypoints instance.Usage: [entrypointDoc| Parameter [] |] [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: [errorDocArg| [] |] [errorDocArg| "errorName" exception "Error description" |] [errorDocArg| "errorName" contract-internal "Error description" () |] [errorDocArg| "errorName" bad-argument "Error description" Integer |] The default argument type is  . Only a type name can be used, if you need complex type, define a type synonym. See this  ,https://indigo-lang.gitlab.io/contract-docs/tutorial! which includes this quasiquote. lorentz!QuasiQuote that helps generating  TypeHasDoc instance.Usage: [typeDoc| [] |] [typeDoc| Storage "This is storage description" |] [typeDoc| Storage "This is storage description" stripFieldPrefix |] field naming strategy/ is optional, and is a function with signature  Text -> Text. Common strategies include  and stripFieldPrefix*. If unspecified, ultimately defaults to . See this  ,https://indigo-lang.gitlab.io/contract-docs/tutorial! which includes this quasiquote.  " Safe-Inferred;"$%&'()*-/01235689:;<=?! lorentzTags excluded from map. lorentzThis is a bidirectional map with correspondence between numeric and textual error tags. lorentz6Find all textual error tags that are used in typical FAILWITH 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   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. lorentzFinds the constructor's position and argument type by its name lorentz'Errors related to fromExtVal conversionlorentzHelper 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. lorentzWraps an argument on top of the stack into an Extensible representation   Safe-Inferred<"$%&'()*-/01235689:;<=?D lorentzProvides "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. lorentz/This marker typeclass is a requirement for the   (where it is imposed on the datatype4), and it is supposed to be satisfied in two cases: The entire datatype is ;When the datatype has non-dupable fields, they are located so that   remains efficient.?The problem we are trying to solve here: without special care,  - may become multiple times more costly, see  for the explanation. And this typeclass imposes an invariant: if we ever use   on a datatype, then we have to pay attention to the datatype's Michelson representation and ensure   remains optimal.%When you are developing a contract: Lorentz.Layouts.NonDupable module contains utilities to help you provide the necessary Michelson layout. In case you want to use your custom layout but still allow   for it, you can define an instance for your type manually as an assurance that Michelson layout is optimal enough to use   on this type..When you are developing a library: Note that   resolves to  by default, and when propagating this constraint you can switch to  anytime but this will also make your code unusable in the presence of s and other non-dupable types. lorentzShortcut for multiple   constraints. lorentzA pair of field name and type. lorentzLike  &, but allows constrainting field type. lorentz%Allows field access and modification. lorentzExtract a field of a datatype replacing the value of this datatype with the extracted field.For this and the following functions you have to specify field name which is either record name or name attached with (:!) operator.:{ (toField @TestProductWithNonDup #fieldTP -$ testProductWithNonDup) == testProduct:}True lorentzLike  , but leaves field named. lorentzExtract a field of a datatype, leaving the original datatype on stack.:{ (getField @TestProduct #fieldB # L.swap # toField @TestProduct #fieldB # mul) -$ testProduct { fieldB = 3 }:}9 lorentzLike  , but leaves field named. lorentzSet a field of a datatype.3setField @TestProduct #fieldB -$ 23 ::: testProduct5TestProduct {fieldA = True, fieldB = 23, fieldC = ()} lorentz)Apply given modifier to a datatype field.modifyField @TestProduct #fieldB (dup # mul) -$ testProduct { fieldB = 8 }5TestProduct {fieldA = True, fieldB = 64, fieldC = ()} lorentz"Open" version of  4, an advanced method suitable for chaining getters.It accepts two continuations accepting the extracted field, one that leaves the field on stack (and does a duplication of res inside) and another one that consumes the field. Normally these are just getField and toField for some nested field.'Unlike the straightforward chaining of  /  methods,  getFieldOpen does not require the immediate field to be dupable; rather, in the best case only res has to be dupable. lorentz"Open" version of  4, an advanced method suitable for chaining setters.It accepts a continuation accepting the field extracted for the update and the new value that is being set. Normally this continuation is just setField for some nested field. lorentzMake up a datatype. You provide a pack of individual fields constructors.Each element of the accepted record should be an instruction wrapped with   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.:{ let ctor =! (fieldCtor (push True)) :&, (fieldCtor (push (42 :: Integer))) :& (fieldCtor (push ())) :& RNil:}$construct @TestProduct ctor -$ ZSNil5TestProduct {fieldA = True, fieldB = 42, fieldC = ()} lorentz Version of  + which accepts tuple of field constructors.let ctor = (fieldCtor (push True), fieldCtor (push @Integer 42), fieldCtor (push ()))%constructT @TestProduct ctor -$ ZSNil5TestProduct {fieldA = True, fieldB = 42, fieldC = ()} lorentz-Construct an object from fields on the stack.1constructStack @TestProduct -$ True ::: 42 ::: ()5TestProduct {fieldA = True, fieldB = 42, fieldC = ()} lorentz*Decompose a complex object into its fieldsdeconstruct @TestProduct # constructStack @TestProduct -$ testProduct5TestProduct {fieldA = True, fieldB = 42, fieldC = ()},Will show human-readable error on a missing  instance:data Foo = Foo () ()deconstruct @Foo...... GHC.Generics.Rep Foo... is stuck. Likely... Generic Foo(... instance is missing or out of scope....1data Foo = Foo () () deriving (Generic, IsoValue)pretty $ deconstruct @Foo[UNPAIR, DIP { }] lorentz)Lift an instruction to field constructor. lorentz0Wrap entry in constructor. Useful for sum types.(wrap_ @TestSum #cTestSumB -$ (False, ())TestSumB (False,()) lorentz=Wrap entry in single-field constructor. Useful for sum types.!wrapOne @TestSum #cTestSumA -$ 42 TestSumA 42 lorentz$Pattern match on the given sum type.You have to provide a 5; containing case branches. To construct a case branch use   operator.:{# let caseTestSum = case_ @TestSum $ (#cTestSumA /-> nop) :&+ (#cTestSumB /-> L.drop # push 23) :& RNil:}caseTestSum -$ TestSumA 4242#caseTestSum -$ TestSumB (False, ())23 lorentzLike  ;, accepts a tuple of clauses, which may be more convenient.If user is experiencing problems with wierd errors about tuples while using this function, he should take look at Morley.Util.TypeTuple.Instances and ensure that his tuple isn't bigger than generated instances, if so, he should probably extend number of generated instances.:{$ let caseTTestSum = caseT @TestSum $ ( #cTestSumA /-> nop( , #cTestSumB /-> L.drop # push 23 ):}caseTTestSum -$ TestSumA 4242$caseTTestSum -$ TestSumB (False, ())23 lorentz?Unwrap a constructor with the given name. Useful for sum types.1unsafeUnwrap_ @TestSum #cTestSumA -$? TestSumA 42Right 42pretty $ unsafeUnwrap_ @TestSum #cTestSumA -$? TestSumB (False, ())% po567/. % po567/.  0 0$ Safe-Inferred<"$%&'()*-/01235689:;<=?K lorentz Version of   for multiple variables. type HasContext = HasNamedVars s ["x" := Integer, "f" := Lambda MText MText] lorentzIndicates that stack s contains a  name :! var value.lorentz*0-based position of the variable on stack. lorentzRequires type x to be an unnamed variable. When e.g.   sees a polymorphic variable, it can't judge whether is it a variable we are seeking for or not;  VarIsUnnamed 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. lorentz Version of  ' that leaves a named variable on stack.3dupLNamed #foo # pair -$ (#foo :! (123 :: Integer))1(fromLabel @"foo" :! 123,fromLabel @"foo" :! 123)(dupLNamed #bar # ppaiir) -$ (#foo :! (123 :: Integer)) ::: (#bar :! (321 :: Integer))(fromLabel @"bar" :! 321,(fromLabel @"foo" :! 123,fromLabel @"bar" :! 321))(dupLNamed #baz # ppaiir) -$ (#foo :! (123 :: Integer)) ::: (#bar :! (321 :: Integer))...3... Element with name "baz" is not present on stack... lorentz>Take the element with given label on stack and copy it on top.If there are multiple variables with given label, the one closest to the top of the stack is picked..dupL #foo # pair -$ (#foo :! (123 :: Integer))(123,fromLabel @"foo" :! 123)(dupL #bar # ppaiir) -$ (#foo :! (123 :: Integer)) ::: (#bar :! (321 :: Integer))7(321,(fromLabel @"foo" :! 123,fromLabel @"bar" :! 321))(dupL #baz # ppaiir) -$ (#foo :! (123 :: Integer)) ::: (#bar :! (321 :: Integer))...3... Element with name "baz" is not present on stack...  % Safe-Inferred;"$%&'()*-/01235689:;<=?nv9 lorentzMichelson supports only , which gives both the quotient and the remainder for integers. For convenience, we also offer  ", which gives just the remainder. lorentzMichelson supports only , which gives both the quotient and the remainder for integers. For convenience, we also offer  !, which gives just the quotient. lorentz(Retain the value only if it is not zero. lorentzNewtype over void result type used in tests to distinguish successful void result from other errors.;Usage example: lExpectFailWith (== VoidResult roleMaster)`This 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. lorentzConstraint for updateN that combines kind-agnostic constraint for Lorentz (Haskell) types and for our typed Michelson.lorentz$Kind-agnostic constraint for updateN lorentzConstraint 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. lorentzInsert 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. lorentz!An instruction that always fails. lorentzAnalog of the FAIL macro in Michelson. Its usage is discouraged because it doesn't carry any information about failure. lorentzCustom 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 DUU+P has since been added as the DUP n= instruction and so this macro is defined simply as follows: duupX = dupN @n lorentz Version of  which accepts number of elements on input stack which should be preserved.You can treat this macro as calling a Michelson function with given number of arguments.Given a stack of 3 elements, >>> arg = (1 :: Integer) ::: (2 :: Integer) ::: (3 :: Integer)framedN will have access to exactly the number of elements specified, >>> framedN $1 drop -$ arg 2 ::: 3 >>> framedN 1 (drop # drop) -$ arg ... ... error: ... Couldn't match type: '[] ... with: Integer : o'0 ...When the number of elements is larger than the size of the stack, framedN will have access to all of them: >>> framedN @5 (drop # drop) -$ arg 3But not more than there are on stack: >>> framedN @5 (drop # drop # drop # drop) -$ arg ... ... error: ... Couldn't match type @ZippedStackRepr a1 (ZippedStackRepr a0 out)@ ... with @Integer@ ... lorentzpapair == pair # pairTruepapair -$ True ::: 1 ::: () ((True,1),()) lorentzppaiir == dip pair # pairTrueppaiir -$ True ::: 1 ::: () (True,(1,())) lorentzcdar == cdr # carTruecdar -$ (True, (1, ()))1 lorentzcddr == cdr # cdrTruecddr -$ (True, (1, ()))() lorentzcaar == car # carTruecaar -$ ((True, 1), ())True lorentzcadr == car # cdrTruecadr -$ ((True, 1), ())1 lorentzsetCar == cdr # swap # pairTruesetCar -$ (True, 1) ::: ()((),1) lorentzsetCdr == car # pairTruesetCdr -$ (True, 1) ::: () (True,()) lorentz1mapCar (not @Bool) == unpair # (not @Bool) # pairTruemapCar not -$ (True, 1) (False,1) lorentz5mapCdr (not @Bool) == unpair # dip (not @Bool) # pairTruemapCdr not -$ (1, True) (1,False) lorentzifRight (not @Bool) (dup @Integer # compare # eq0) == ifLeft (dup @Integer # compare # eq0) (not @Bool)TrueifRight not (dup # compare # eq0) -$ (Right True :: Either Integer Bool)FalseifRight not (dup # compare # eq0) -$ (Left 1 :: Either Integer Bool)True lorentzifSome (dup @Integer # compare # eq0) (push False) == ifNone (push False) (dup @Integer # compare # eq0)TrueifSome (dup # compare # eq0) (push False) -$ (Just 1 :: Maybe Integer)TrueifSome (dup # compare # eq0) (push False) -$ (Nothing :: Maybe Integer)False lorentzwhen_ (push 5 # add @Integer @Integer) == if_ (push 5 # add @Integer @Integer) nopTrue+when_ (push 5 # add @Integer) -$ True ::: 38,when_ (push 5 # add @Integer) -$ False ::: 33 lorentzunless_ (push 5 # add @Integer @Integer) == if_ nop (push 5 # add @Integer @Integer)True-unless_ (push 5 # add @Integer) -$ True ::: 33.unless_ (push 5 # add @Integer) -$ False ::: 38 lorentz whenSome drop == ifSome drop nopTruewhenSome drop -$ Just 1 ::: ()() lorentz.whenNone (push True) == ifNone (push True) nopTrue/whenNone (push 1) -$ (Nothing :: Maybe Integer)1 lorentzInsert given element into set.!This is a separate function from 4 because stacks they operate with differ in length. lorentzInsert 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. lorentzReplace 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 0` is not a valid operation (and it is not implemented). `replaceN 1` 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 @3 cons. replaces the 3rd element with the result of cons2 applied to the topmost element and the 3rd one. updateN @0 instr8 is not a valid operation (and it is not implemented). updateN @1 instr is equivalent to instr (and so is implemented). updateN @2 instr is equivalent to swap # dip instr. (and so is implemented). In all other cases updateN @n instr8 will put the topmost element right above the nth one ( dug @(n-1)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  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. lorentz0Duplicate two topmost items on top of the stack. lorentz5Retain the value if it is not equal to the given one.non (0 :: Integer) -$ 5Just 5non (0 :: Integer) -$ 0Nothing lorentz Version of   with a custom predicate.non' @Integer eq0 -$ 5Just 5non' @Integer eq0 -$ 0Nothing lorentz!Check whether container is empty. lorentz Call a view.Accepts the view name via a type annotation. This internally asserts the view to be present, as if the supplied TAddress argument is valid, the view is guaranteed to be called successfully. lorentzInteger division.)idiv -$ (5 :: Integer) ::: (2 :: Integer)Just 2)idiv -$ (5 :: Integer) ::: (0 :: Integer)Nothing lorentzInteger modulus.)imod -$ (5 :: Integer) ::: (2 :: Integer)Just 1)imod -$ (5 :: Integer) ::: (0 :: Integer)Nothing     Safe-Inferred;"$%&'()*-/01235689:;<=?v$ lorentz!Everything that can be put after if keyword.The first type argument stands for the condition type, and all other type arguments define stack types around/within the  if then else8 construction. For semantics of each type argument see  . lorentzDefines semantics of if ... then ... else ... construction. lorentzThe most basic predicate 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 if 2. Left branch input 3. Right branch input 4. Output of branches 5. Output of if lorentzExplicitly named binary condition, to ensure proper order of stack arguments. lorentz"Provide the compared arguments to if branches. lorentz Aliases for  used by do-blocks. lorentzNamed version of  .In this and similar operators you provide names of accepted stack operands as a safety measure of that they go in the expected order. lorentzNamed version of  . lorentzNamed version of  . lorentzNamed version of  . lorentzNamed version of  . lorentzNamed version of  . lorentzCondition modifier, makes stack operands of binary comparison to be available within if branches."  8"  8 4 4 4 4 4 4&None="$%&'()*-/01235689:;<=?,/ lorentzHelper class to check if a range is empty. Gives up when both boundaries are exclusive.lorentzReturns  when a range is empty,  otherwise.lorentzLorentz version of . lorentz9Specify on how to fail on range overflow or underflow in  .This expects two always-failing Lorentz functions, one will be called on underflow, another on overflow.See  8 for a simpler helper to use with custom Lorentz errors.See  ? if you don't care about distinguishing underflow and overflow. lorentz)Information about the range check failure lorentz(Whether the boundary is inclusive or not lorentz!The boundary that failed to check lorentzThe value that failed to check lorentzHelper class for the  ) types that encapsulates common features. lorentzRange exclusive in lower boundary, but inclusive in upper boundary. lorentzRange inclusive in lower boundary, but exclusive in upper boundary. lorentz#Range exclusive in both boundaries. lorentz,Default range, inclusive in both boundaries.lorentzThe main range type. This exists as a base for other (new)types like  ,  , etc. The zoo of   types exists mostly for the purpose of making errors less scary:9f = push (1 :: Integer, 2 :: Natural) # unpair # inRange_... ... error:6... Couldn't match type @Range Natural@ with @Integer@...mkRange_ @_ @_ @_ @Integer # add -$ #min :! 123 ::: #max :! 321 ::: 555... ... error:... No instance for (ArithOpHs... Morley.Michelson.Typed.Arith.Add (Range Integer) Integer ())...lorentz)Hacky typeclass to default boundaries to  . lorentzHelper class for  .lorentzParentheses for the  instancelorentzHaskell comparison which either includes or excludes the boundarylorentzLorentz comparison which either includes or excludes the boundarylorentzHuman-readable name for the tag lorentzValue-level representation as  lorentzWhether to include boundary in  lorentzGet a range's lower bound lorentzGet a range's upper bound. lorentz Construct a  . Bear in mind, no checks are performed, so this can construct empty ranges.You can control whether boundaries are included or excluded by choosing the appropriate type out of  ,  ,   and  , either via a type application or a type annotation. Alternatively, you can set lower and upper type arguments to   or  <. If unspecified, the default is to include both boundaries.pretty $ mkRange 123 456 [123, 456]pretty $ mkRange 123 123 [123, 123]3pretty $ mkRange 123 0 -- note this range is empty![123, 0]+pretty (mkRange 123 456 :: RangeEE Integer) (123, 456)!pretty $ mkRange @RangeIE 123 456 [123, 456)?pretty $ mkRange @_ @'IncludeBoundary @'ExcludeBoundary 123 456 [123, 456)!pretty $ mkRange @RangeEI 123 456 (123, 456]?pretty $ mkRange @_ @'ExcludeBoundary @'IncludeBoundary 123 456 (123, 456] lorentz Convert a   to a pair of (lower, upper)mkRangeForSafe_ # fromRange_ -$ #start :! (123 :: Integer) ::: #length :! (456 :: Natural) (123,579) lorentzConvert a pair of (lower, upper) to  5. This has the potential to construct an empty range.0pretty (toRange_ -$ (123, 456) :: Range Integer) [123, 456]pretty (toRange_ -$ (123, -100500) :: Range Integer) -- empty range[123, -100500] lorentzGet the lower bound of a  mkRange_ # rangeLower_ -$ #min :! (123 :: Integer) ::: #max :! (456 :: Integer)123 lorentzGet the upper bound of a  mkRange_ # rangeUpper_ -$ #min :! (123 :: Integer) ::: #max :! (456 :: Integer)456 lorentzConstruct a range by specifying the start and length instead of lower and upper bounds.  lower = start, and upper = start + length..Note this can still construct empty ranges if length is negative.See  : for the information on how to control boundary inclusion.pretty $ mkRangeFor 123 123 [123, 246]-pretty $ mkRangeFor 123 (-123) -- empty range[123, 0] lorentzThe Lorentz version of  pretty $ mkRange_ -$ (#min :! (123 :: Integer)) ::: (#max :! (123 :: Integer)) [123, 123]pretty $ mkRange_ @RangeEE -$ (#min :! (123 :: Integer)) ::: (#max :! (123 :: Integer)) (123, 123)1Notice the latter range is empty by construction. lorentzThe Lorentz version of   . Note that length can be of different type from start.pretty $ mkRangeFor_ -$ (#start :! (123 :: Integer)) ::: (#length :! (123 :: Natural)) [123, 246] lorentz A version of   that requires length to be isomorphic to a nat and the range to be inclusive in both bounds. This guarantees that the range is non-empty.pretty $ mkRangeForSafe_ -$ (#start :! (123 :: Integer)) ::: (#length :! (1 :: Natural)) [123, 124] lorentzCheck if a value is in range.let range = mkRange -2 2inRange range <$> [-4..4]2[False,False,True,True,True,True,True,False,False] lorentz)Check if a value is in range, and return . This function returns  if the value is in range, + if it underflows, and 'GT if it overflows.%inRangeCmp (mkRange -2 2) <$> [-4..4][LT,LT,EQ,EQ,EQ,EQ,EQ,GT,GT].inRangeCmp (mkRange @RangeIE -2 2) <$> [-4..4][LT,LT,EQ,EQ,EQ,EQ,GT,GT,GT] lorentzLorentz version of  .'range = mkRange 0 10 :: RangeEE Integer testCode = push range # inRange_testCode -$ 123FalsetestCode -$ 10False testCode -$ 0FalsetestCode -$ -123False testCode -$ 1True testCode -$ 5True lorentzLorentz version of   . Instead of  , returns an , -1 if the value underflows, 0 if it's in range and 1 if it overflows.Use   if you don't particularly care whether the range is under- or overflowed.%range = mkRange 0 10 :: Range Integer#testCode = push range # inRangeCmp_testCode -$ 1231testCode -$ -123-1 testCode -$ 509push (mkRange 0 10 :: RangeIE Integer) # inRangeCmp_ -$ 00:push (mkRange 0 10 :: RangeIE Integer) # inRangeCmp_ -$ 1019push (mkRange 0 10 :: RangeEI Integer) # inRangeCmp_ -$ 0-1:push (mkRange 0 10 :: RangeEI Integer) # inRangeCmp_ -$ 1009push (mkRange 0 10 :: RangeEE Integer) # inRangeCmp_ -$ 0-1:push (mkRange 0 10 :: RangeEE Integer) # inRangeCmp_ -$ 101When lower and upper boundaries are the same and at least one boundary is exclusive, it is ambiguous whether the value on the boundary overflows or underflows. In this case, lower boundary takes precedence if it's exclusive.8push (mkRange 0 0 :: RangeIE Integer) # inRangeCmp_ -$ 018push (mkRange 0 0 :: RangeEI Integer) # inRangeCmp_ -$ 0-18push (mkRange 0 0 :: RangeEE Integer) # inRangeCmp_ -$ 0-1 lorentzAssert a value is in range; throw errors if it's under- or overflowing. See  * for information on how to specify errors.:If you don't need verbose error reporting, consider using  . lorentzA cheaper version of   without fancy error reporting.,let range = mkRange 123 456 :: Range Integer!let err = failUsing [mt|failure|]0assertInRangeSimple_ err -$ range ::: 123 ::: ()().assertInRangeSimple_ err -$ range ::: 1 ::: ()*** Exception: Reached FAILWITH instruction with '"failure"' ......lorentzSmall helper to construct   in Lorentz code. lorentz Construct  > that performs the same action on both overflow and underflow lorentz Construct   that throws custom errors. Errors used must be defined somewhere using  errorDocArg or equivalent, and must accept   as the argument.:{$type RFII = RangeFailureInfo Integer--[errorDocArg| "overflowInt" exception "Integer range overflow" RFII |][errorDocArg| "underflowInt" exception "Integer range underflow" RFII |]---testCode :: Range Integer : Integer : s :-> stestCode = assertInRange_ $ customErrorORAF ! #underflow #underflowInt ! #overflow #overflowInt:}'testCode -$ mkRange 0 10 ::: 123 ::: ()*** Exception: Reached FAILWITH instruction with 'Pair "OverflowInt" (Pair True (Pair 10 123))'...&testCode -$ mkRange 0 10 ::: -1 ::: ()*** Exception: Reached FAILWITH instruction with 'Pair "UnderflowInt" (Pair True (Pair 0 -1))'...%testCode -$ mkRange 0 10 ::: 5 ::: ()() lorentz A version of  : that uses the same error for both underflow and overflow.:{$type RFII = RangeFailureInfo Integer[errorDocArg| "rangeError" exception "Integer range check error" RFII |]---testCode :: Range Integer : Integer : s :-> s=testCode = assertInRange_ $ customErrorORAFSimple #rangeError:}'testCode -$ mkRange 0 10 ::: 123 ::: ()*** Exception: Reached FAILWITH instruction with 'Pair "RangeError" (Pair True (Pair 10 123))'...&testCode -$ mkRange 0 10 ::: -1 ::: ()*** Exception: Reached FAILWITH instruction with 'Pair "RangeError" (Pair True (Pair 0 -1))' ......%testCode -$ mkRange 0 10 ::: 5 ::: ()() lorentzCheck if a range is empty by construction. Note, however, this function is not suitable for checking whether a range with both boundaries excluded is empty, and hence will produce a type error when such a check is attempted.isRangeEmpty $ mkRange 0 1FalseisRangeEmpty $ mkRange 0 0FalseisRangeEmpty $ mkRange 0 -1True#isRangeEmpty $ mkRange @RangeIE 0 1False#isRangeEmpty $ mkRange @RangeIE 0 0True$isRangeEmpty $ mkRange @RangeIE 0 -1True#isRangeEmpty $ mkRange @RangeEI 0 1False#isRangeEmpty $ mkRange @RangeEI 0 0True$isRangeEmpty $ mkRange @RangeEI 0 -1True#isRangeEmpty $ mkRange @RangeEE 0 1... ... error:... This function can't be used to check whenter a range with both boundaries excluded is empty... lorentzLorentz version of  . Same caveats apply.7mkRange_ # isRangeEmpty_ -$ (#min :! 0) ::: (#max :! 1)False7mkRange_ # isRangeEmpty_ -$ (#min :! 0) ::: (#max :! 0)False8mkRange_ # isRangeEmpty_ -$ (#min :! 0) ::: (#max :! -1)TruemkRange_ @RangeIE # isRangeEmpty_ -$ (#min :! 0) ::: (#max :! 1)FalsemkRange_ @RangeIE # isRangeEmpty_ -$ (#min :! 0) ::: (#max :! 0)TruemkRange_ @RangeIE # isRangeEmpty_ -$ (#min :! 0) ::: (#max :! -1)TruemkRange_ @RangeEI # isRangeEmpty_ -$ (#min :! 0) ::: (#max :! 1)FalsemkRange_ @RangeEI # isRangeEmpty_ -$ (#min :! 0) ::: (#max :! 0)TruemkRange_ @RangeEI # isRangeEmpty_ -$ (#min :! 0) ::: (#max :! -1)TruemkRange_ @RangeEE # isRangeEmpty_ -$ (#min :! 0) ::: (#max :! 1)... ... error:... This function can't be used to check whenter a range with both boundaries excluded is empty... lorentzAssert a range is non-empty, run a failing function passed as the first argument if it is. Note, however, this function is not suitable for checking whether a range with both boundaries excluded is empty, and hence will produce a type error when such a check is attempted.let err = push [mt|empty range|] # pair # failWith @(MText, Range Integer)pretty $ mkRange_ # assertRangeNonEmpty_ err -$ (#min :! 0) ::: (#max :! 1)[0, 1]pretty $ mkRange_ # assertRangeNonEmpty_ err -$ (#min :! 0) ::: (#max :! 0)[0, 0]pretty $ mkRange_ # assertRangeNonEmpty_ err -$ (#min :! 0) ::: (#max :! -1)*** Exception: Reached FAILWITH instruction with 'Pair "empty range" (Pair 0 -1)' ......mkRange_ @RangeEE # assertRangeNonEmpty_ err -$ (#min :! 0) ::: (#max :! 1)... ... error:... This function can't be used to check whenter a range with both boundaries excluded is empty... lorentzPretty-printer for Range.pretty $ mkRange 123 456 [123, 456]!pretty $ mkRange @RangeEE 123 456 (123, 456)!pretty $ mkRange @RangeIE 123 456 [123, 456)?pretty $ mkRange @_ @'IncludeBoundary @'ExcludeBoundary 123 456 [123, 456)/ / ' Safe-Inferred;"$%&'()*-/01235689:;<=?Ulorentz;Helper typeclass which overloads representation for errors.lorentzError representation with respect to tags being changed to numeric ones. lorentz'Some error with a numeric tag attached.lorentzPseudo error which stands for textual errors converted to numeric codes. lorentzHandler which changes documentation for one particular error type. lorentz Errors for  lorentz=Given handler is not suitable, probably another one will fit.lorentzGiven handler suits and tells that given error should remain unchanged. lorentz0Adds a section which explains error tag mapping. lorentz=Describes where the error tag map is defined in Haskell code.lorentzAnchor which refers to the section describing error tag mapping. lorentz:Modify documentation generated for given code so that all   mention not their textual error tag rather respective numeric one from the given map.If some documented error is not present in the map, it remains unmodified. This function may fail with 2- if contract uses some uncommon errors, see   for details. lorentzExtended version of   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 2 if some of the errors used in the contract cannot be handled with given handlers. lorentzHandler for all  s. lorentz Handler for  .lorentz#Handler for textual error messages. lorentz3Handlers for most common errors defined in Lorentz. C Safe-Inferred;"$%&'()*-/01235689:;<=? ( Safe-Inferred;"$%&'()*-/01235689:;<=? lorentzLorentz version of ,.  ) Safe-Inferred;"$%&'()*-/01235689:;<=? lorentzLorentz version of Control.Lens.Iso. lorentzInvert an isomorphism. lorentz2Given a function that is its own inverse, make an   using it in both directions. lorentzThe isomorphism between two values with identical representation and semantics. lorentzThe isomorphism between two values with identical representation.The same precautions as for  apply here. lorentz,The isomorphism between raw and named value. lorentzAbsence of value on the left hand side is associated with the given value on the right hand side. lorentzAbsence 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. * Safe-Inferred= "$%&'()*-/01235689:;<=? lorentzConcise 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 ] Note that this won't work with complex field references, they have to be included using e.g.   manually. lorentz-Indicates a stored entrypoint with the given param and store types. lorentz2Indicates a submap with given key and value types. lorentzKind-restricted version of  # to work solely with string labels. lorentzAlias for a field reference.This allows creating _custom_ field references; you will have to define the respective   and   instances manually. Since this type occupies a different "namespace" than string labels and  ., no overlappable instances will be necessary.Example: -- Shortcut for a deeply nested field X data FieldX instance StoreHasField Storage (FieldAlias FieldX) Integer where ... accessX = stToField (stAlias @FieldX)  Note that alias1 type argument allows instantiations of any kind. lorentz,Refer to no particular field, access itself. lorentz#Refer to a nested entry in storage. Example: stToField (#a :-| #b) fetches field b in the type under field a.7If this syntax seems overly verbose, you can try using OverloadedRecordDot1. See module documentation for comments on that. lorentz*Provides operations on stored entrypoints.store/ is the storage containing both the entrypoint epName (note: it has to be in a q/ 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 q mapping : (entrypoint names) to  .*This is useful when defining instances of   as a storage field containing one or more entrypoints (lambdas) of the same type. lorentzType synonym for a " that can be used as an entrypoint lorentz*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.) lorentzSee  " for explanation of the signature. lorentzSee  " for explanation of the signature. lorentz9Provides access to the direct name of the referred field.This is used in  . lorentz Version of   restricted to symbolic labels. .FieldSymRef name D FieldName name 'FieldRefTag lorentzThe simplest field reference - just a name. Behaves similarly to ;. lorentz"Some kind of reference to a field.3The idea behind this type is that in trivial case (name :: Symbol) it can be instantiated with a mere label, but it is generic enough to allow complex field references as well. lorentzFor a type-level field reference - an associated term-level representation.This is similar to  singletons Sing + SingI pair but has small differences:9Dedicated to field references, thus term-level thing has   kind.The type of term-level value (FieldRefObject ty/) determines the kind of the reference type. lorentz'Open kind for various field references.&The simplest field reference could be ;, pointing to a field by its name, but we also support more complex scenarios like deep fields identifiers. lorentzConvert a symbolic  = to a label, useful for compatibility with other interfaces. lorentzConvert a label to  2, useful for compatibility with other interfaces. lorentzSimplified version of   where res is ftype. lorentzSimplified version of   where res is ftype. lorentzPick storage field. lorentz:Get storage field, preserving the storage itself on stack. lorentz3Pick storage field retaining a name label attached.For complex refs this tries to attach the immediate name of the referred field. lorentz Version of  % that preserves the storage on stack. lorentzUpdate storage field. lorentz Check value presence in storage. lorentzGet value in storage. lorentzUpdate a value in storage. lorentz-Atomically get and update a value in storage. lorentzDelete a value in storage. lorentzAdd a value in storage. lorentzAdd a value in storage, but fail if it will overwrite some existing entry. lorentzExtracts and executes the epName entrypoint lambda from storage, returing the updated full storage (store) and the produced Ws. lorentzPick stored entrypoint lambda. lorentzGet stored entrypoint lambda, preserving the storage itself on the stack. lorentzStores the entrypoint lambda in the storage. Fails if already set. lorentz5Pick the sub-storage that the entrypoint operates on. lorentzGet 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 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  desiredName, not its actual name. Logic of the implementation remains the same.Use 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: instance StoreHasSubmap Store X Key Value where storeSubmapOps = storeSubmapOpsReferTo #Y storeSubmapOpsForY lorentzPretend that given  0 implementation is made up for field with name  desiredName, 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  desiredName, 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.Suits for a case when your store does not contain its fields directly rather has a nested structure. lorentz5Chain implementations of field and submap operations.This requires Dupable substore for simplicity, in most cases it is possible to use a different chaining (nameInStore :-| mname :-| this) to avoid that constraint. If this constraint is still an issue, please create a ticket. lorentzChain 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 substore value if it was absent in map and how to detect when it can be safely removed.Example of use: sequenceStoreSubmapOps #mySubmap nonDefIso storeSubmapOps storeSubmapOps lorentzTurn 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) subvalue 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: zoomStoreSubmapOps #mySubmap nonDefIso nonDefIso storeSubmapOps storeFieldOpsADTlorentz Utility to  the :! name of and entrypoint from its ;lorentzUtility 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   implementation. Note that you need to merge multiple of these (with 9) if your field contains more than one entrypoint lambda. lorentz An alias for  . Examples:4push 5 # stMem this -$ (mempty :: Map Integer MText)False(stGetField this # pair -$ (5 :: Integer)(5,5) lorentzProvides alternative variadic interface for deep entries access. Example: stToField (stNested #a #b #c) lorentz!Construct an alias at term level.4This requires passing the alias via type annotation. lorentz Version of   adopted to labels. lorentz7Provides access to the submap via the respective field.Tricky storages that consolidate submaps in a non-trivial way can define instances overlapping this one.  9  9  8 8+ Safe-Inferred;"$%&'()*-/01235689:;<=? lorentz Alias for  .This makes nested field access look just like in other languages.Though it may collide with the dot operator from Haskell world, for instance, in tests, so we do not yet provide it directly in Lorentz.StoreClass.   8, Safe-Inferred;"$%&'()*-./0125689:;<=?nlorentzSpecial multiplication helper, in case you want to multiply three 'Rational values' given values (a  b) * (c  d) * (e / f) performs (a * c * e) / (b * d * f).lorentz For a given 6 values, calculates their gcd, using Euclid algorithm.lorentzReduce  value to the point, when numerator's and denominator's gcd is 1. This operation should be commonly used after several arithmetic operations, because numerator and denominator can become quite big. That in order, can lead to serious gas consumption.lorentzReduce  value, using extended Euclid algorithm. Consumes slightly more gas, than reduce:, but contract with it is cheaper in terms of origination.    77 Safe-Inferred;"$%&'()*-/01235689:;<=?lorentzLike Fixed but with a Natural value inside constructorlorentz9Represents decimal base of the Lorentz fixed-point valueslorentz8Represents binary base of the Lorentz fixed-point valueslorentz Open kind for fixed value bases.lorentz3Special function to get resolution without argumentlorentzConvert to the corresponding integral type by banker's rounding.lorentz-Convert from the corresponding integral type.lorentzRound is implemented using "banker's rounding" strategy, rounding half-way values towards nearest even value)*)*- Safe-Inferred;"$%&'()*-./0125689:;<=?)lorentz Converts  to )8 using value inside as numerator and base as denominatorlorentz Converts  to 8 using value inside as numerator and base as denominatorlorentz Converts ) to  according to formulae: numerator * base / denominator Note: Since result's base is determined by user, it is recommended to use higher value in order to achieve better accuracylorentz Converts  to ).lorentz Converts  to .lorentz Converts  to .lorentz Converts ) to - if it is greater than zero. If not, returns DElorentz Converts ) to , using  on numerator.  F Safe-Inferred;"$%&'()*-/01235689:;<=?3)*  . Safe-Inferred;"$%&'()*-/01235689:;<=?lorentz2Expression is just an instruction accepting stack inp and producing stack out with evaluation result res at the top.lorentzConsume an element at the top of stack. This is just an alias for nop.lorentz9Lift an instruction to an unary operation on expressions.lorentz An alias for .lorentz9Lift an instruction to a binary operation on expressions.lorentzExpressions addition.lorentzExpressions subtraction.lorentzExpressions multiplication.lorentzExpressions comparison.lorentzExpressions comparison.lorentzExpressions comparison.lorentzExpressions comparison.lorentzExpressions comparison.lorentzExpressions comparison.lorentzBitwise/logical AND on expressions.lorentzBitwise/logical OR on expressions.2In case you find this operator looking weird, see lorentz An alias for .lorentzBitwise/logical XOR on expressions.lorentzLeft shift on expressions.lorentzRight shift on expressions.lorentz on expressions. ,one :: a : s :-> [a] : s one = take |:| nil lorentzConstruct a simple pair. trivialContract :: ((), storage) :-> ([Operation], Storage) trivialContract = nil |@| cdr This is useful as pair appears even in simple contracts. For more advanced types, use G.lorentz Construct a  value from a given nominator and denominator. In case denominator is 0, fails with custom exception.lorentz An alias for . trivialContract :: ((), storage) :-> ([Operation], Storage) trivialContract = pairE ( nil , cdr ) lorentz8Construct a list given the constructor for each element.lorentz Version of < instruction that accepts all the arguments as expressions. transferTokensE ! #arg L.unit ! #amount (push zeroMutez) ! #contract take |:| nil You can provide arguments in arbitrary order, but direction of stack changes flow is fixed: stack change in arg( expression affects stack available in amount" expression, and stack changes in amount% expression affect stack changes in contract expression.lorentz Version of < instruction that accepts all the arguments as expressions. createContractE ! #delegate none ! #balance (push zeroMutez) ! #storage unit ! #contract myContract Note that this returns an operation, and pushes the address of the newly created contract as a side-effect.lorentz Version of  ; instruction that accepts all the arguments as expressions. viewE @"myview" ! #arg (push zeroMutez) ! #address (push addr) lorentzAn expression producing  can be placed as condition to 'if'.9 667444444211388107/ Safe-Inferred;"$%&'()*-./0125689:;<=? lorentzA ticket kept in storage.The common pattern of use here is 1. A ticket that permits spending few tokens comes in, it is partially validated and this  type is produced. 2. This type can repeatedly be used to consume up to the amount of permitted tokens.So in order to count allowed tokens, in storage you usually put this type, not bare .The action type parameter serves to distinguish tickets for different actions at type level and usually just matches the value in ticket data:)If the data in ticket is validated to be "pause"*, then the result of validation can be STicket "pause" ..."; This is the preferred option.If the data in ticket has enum type, and the value is validated to be some  PauseAction!, then validation can produce STicket PauseAction ....*CAUTION: when working with this type, you must ensure that the expected ticket emitter (the one you validate tickets against, e.g. admin address) is constant for the lifetime of the  value. Otherwise, tickets arithmetics (provided via methods below) won't work. So do one of0Either never change the expected ticket emitter;%Or, when it is changed, wipe all the ; values validated against the old ticketer from storage;Or keep ticket values in a map where key is the currently expected ticket emitter.Note some specificity of this type - its values mostly always appear optionally, either in a map, or in / (this is clear from the potential use cases).lorentzVerifies a ticket. This is an extremely generified , allows providing verifiers for all the ticket's parts. Provided just in case.lorentzGeneric method for verifying tickets that authorize some action. For concrete example of use see .lorentz*Generic method for verifying the ticketer.lorentzCheck data in a ticket when it carries target contract address and some other data that is to be verified with the given handler.lorentzCheck data in a ticket when it solely carries target contract address.lorentz?Verifies the given ticket value that permits running an action. /Ticketer is checked to match the given address.6Tokens amount in the ticket is checked to be equal to 1.Ticket data is checked with the provided handler. In case the data contains target contract, consider using  or .lorentzConstructs an .This also emits the ticketer address and ticket data for further use. You are oblidged to do something with both of them:8Either validate against the expected value, you can use ,  and  helpers here.Or use as key in a map where  should be put to as a value.-This way you can be sure that arithmetics on STickets works smoothly and there are no, for instance, attempts to join two tickets from different emitters.lorentzRead contents of .lorentzRead tokens amount in .lorentz Version of  that works without Maybe.lorentzConsume given amount of tokens from the ticket, failing with given handler if amount of tokens in the ticket is insufficient.We do not provide a ready error for this case since it will probably depend on particular tokens that the given STicket serves to permit.Note that you may want to run isSome nonZero none& on the result to save storage space.lorentz Similar to , but without Maybe.You may want to run  1 after this function call to save storage space.lorentz,Adds tokens permitted by an incoming ticket.Useful when someone permits you to spend even more tokens than you already have been allowed to spend.This assumes that the ticket being added has already been verified. The passed tickets must be verified against the same ticket data and ticket emitter.lorentz Similar to , but without Maybe.lorentzTicket emitter verifierlorentzTicket tokens verifierlorentzTicket data verifierlorentzTicket tokens verifierlorentzTicket data verifier0 Safe-Inferred;"$%&'()*-/01235689:;<=?-lorentzProduce  instance for a datatype containing non-dupable and plain dupable elements so that operations on this datatype (like getField) remain optimal in average.$Derivation strategies available for  suffer from a problem: getField is non-optimal as long as during its recursive descend it operates with a non-dupable pairs subtree.  tries to keep all dupable elements in the left subtree of the root (speeding up getField> on them), and all non-dupable elements in the right subtree.(Prerequisites for calling this function: All the fields of dupable types must locate before all the fields of non-dupable types.*You have to supply the expected number of  non-dupable fields as an argument. We expect this number, not the number of dupable fields, since non-dupable elements are rare and so are supposed to be updated less often.Unfortunately, there seems to be no decent way to see whether a type is dupable or not at TH time, so we have to accept some information explicitly. To ensure that this information is up to date, each time calling this function (we encourage the user to also add a test using utilities from Lorentz.Test.DupableScan module.lorentzGiven number of non-dupable field (that must be last fields in the datatype), produces a strategy that puts dupable fields at the left pair subtree and non-dupable fields at the right pair subtree.lorentz.Depths distribution generator to be passed to , it splits entries into two large groups and applies another depths generator to each group.H Safe-Inferred;"$%&'()*-/01235689:;<=??@ Safe-Inferred;"$%&'()*-/01235689:;<=?9n6lorentz6Provides arror for convenient entrypoint documentationlorentzLift 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.The first argument is accumulator for Michelson description of the building step.The third argument is a function to which the remaining unprocessed portion of the record will be passed.lorentzConstraint for .lorentzPick a type documentation from .lorentz$Describes argument of an entrypoint.lorentz!Argument of the entrypoint. Pass  if no argument is required.lorentzDescribes 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); then the first step (actual last) should describe wrapping into Run constructor, and the second step (actual first) should be about wrapping into Service1 constructor.lorentz1Entrypoint argument type in typed representation.lorentz$Describes a parameter building step.This 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.lorentzThis 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 or tree and neither it nor any of its parents are marked with a field annotation.It contains dummy s which were assigned before entrypoints were taken into account.lorentz'Plain english description of this step.lorentz+How to construct parameter in Haskell code.lorentz4How to construct parameter working on raw Michelson.lorentzWhen describing the way of parameter construction - piece of incremental builder for this description.lorentzArgument stands for previously constructed parameter piece, and returned value - a piece constructed after our step.lorentz.Inserts a reference to an existing entrypoint.This 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.This 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 entrypointSection "Prior checks" (Proxy @CommonContractBehaviourKind).lorentzA convenience type synonym for  not hiding any entrypoitns.lorentzSpecial entrypoint kind that flattens one level of recursive entrypoints.With 3, intermediary nodes are hidden from documentation.With ), intermediary nodes will still be shown.Any entrypoints can be omitted from docs by listing those in the type parameter (which is especially helpful with ).1For other entrypoint derivation strategies (e.g. ), behaves like 5 (with the exception of hiding entrypoints from docs)If you have several levels of recursion, each level will need to have this kind.Note that list of entrypoints to be hidden is not checked by default. Use  to have a static check that entrypoints to be hidden do indeed exist.lorentzDefault value for  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.lorentzCan be used to make a kind equivalent to some other kind; if changing this,  and  will be ignored.lorentzImplement this when specifying 3. This should never be normally used, but because MINIMAL7 pragma can't specify type families, we use this hack.:Default implementation is a bottom (i.e. a runtime error).If implemented, it should be &entrypointKindOverrideSpecified = DictlorentzPosition 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.lorentz2Description in the respective entrypoints section.lorentz,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 kind type argument for each of those groups will allow you defining different 9 instances with appropriate custom descriptions for them.lorentz"Pattern that checks whether given  hides " inside (of any entrypoint kind).0In case a specific kind is necessary, use plain (cast -> Just DEntrypoint{..}) construction instead.lorentzDefault implementation of  for entrypoints.lorentz0Mark code as part of entrypoint with given name.This is automatically called at most of the appropriate situations, like  calls.lorentzShow what given  does on a sample.lorentzMake a  that tells about wrapping an argument into a constructor with given name and uses given # as description of Michelson part.lorentz5Go over contract code and update every occurrence of 5 documentation item, modifying param building steps.lorentz5Go over contract code and update every occurrence of  documentation item, adding the given step to its "how to build parameter" description.lorentz,Add necessary documentation to entry points.lorentzLike  >, 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 f instance.lorentz Version of  for tuples.lorentzWrapper for documenting single entrypoint which parameter isn't going to be unwrapped from some datatype. entryCase unwraps a datatype, however, sometimes we want to have entrypoint parameter to be not wrapped into some datatype.lorentzModify 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.This method is for internal use, if you want to apply it to a contract manually, use .lorentzVersion of 'finalizeParamCallingDoc'' more convenient for manual call in a contract.lorentzWhether ) has already been applied to these steps.lorentz Version of # for contracts with flat parameter.lorentz Version of # for contracts with flat parameter.lorentz Version of  for contracts with recursive parameter that needs to be flattened. Use it with 4 when you don't need intermediary nodes in autodoc.lorentz Version of  for contracts with recursive parameter that needs to be flattened. Use it with 4 when you don't need intermediary nodes in autodoc.lorentz Version of  for contracts with recursive delegate parameter that needs to be flattened. Use it with  when you don't need hierarchical entrypoints in autodoc. You can also hide particular entrypoints with the type parameter. Consider using , if you don't want to hide any entrypoints.lorentz Version of  for contracts with recursive delegate parameter that needs to be flattened. Use it with  when you don't need hierarchical entrypoints in autodoc. You can also hide particular entrypoints with the first type parameter. Consider using , if you don't want to hide any entrypoints.  entryCaseFlattenedHiding @'[Ep1, Ep2] ... lorentz6Surrouned a markdown text in a span tag with given id._`>_`>1 Safe-Inferred;"$%&'()*-/01235689:;<=?Florentz5Generic traversal for conversion between ADT sum and .lorentz1Entry points template derived from given ADT sum.lorentzConstraint required by .lorentz#Make up a "case" over entry points.lorentzPattern-match on given UParam entries.You have to provide all case branches and a fallback action on case when entrypoint is not found.This function is unsafe because it does not make sure at type-level that entry points' names do not repeat.lorentz=An action invoked when user-provided entrypoint is not found.lorentz%Implementations of some entry points.,Note that this thing inherits properties of 5, e.g. you can Data.Vinyl.Core.rappend implementations for two entrypoint sets when assembling scattered parts of a contract.lorentz#Wrapper for a single "case" branch.lorentz"This class is needed to implement .lorentzTurn  into a Haskell value. Since we don't know its type in compile time, we have to erase it using . The user of this function can require arbitrary constraint to hold (depending on how they want to use the result).lorentzThis type can store any value that satisfies a certain constraint.lorentz>Ensure that given entry points do no contain duplicated names.lorentz,Get type of entrypoint argument by its name.lorentzHomomorphic version of , forgets the exact interface.lorentzPseudo value for  type variable.lorentzEncapsulates parameter for one of entry points. It keeps entrypoint name and corresponding argument serialized.In 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.lorentzAn entrypoint is described by two types: its name and type of argument.lorentz Construct a  safely.lorentz-Helper instruction which extracts content of .lorentzDefault implementation for , simply reports an error.lorentzPattern-match on given UParam entries.You 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 5.lorentzMake up  from ADT sum.&Entry points template will consist of '(constructorName, constructorFieldType)? pairs. Each constructor is expected to have exactly one field.!Shows human-readable errors when up is stuck.data Foo = Foo ()uparamFromAdt $ Foo ()...... GHC.Generics.Rep Foo... is stuck. Likely... Generic Foo(... instance is missing or out of scope...."data Foo = Foo () deriving GenericuparamFromAdt $ Foo ()9UnsafeUParam (UnsafeMText {unMText = "Foo"},"\ENQ\ETX\v")lorentz:Note that calling given entrypoints involves constructing .lorentzAllows casts only between  and .2 Safe-Inferred;"$%&'()*-/01235689:;<=?R:lorentzSingle contract view.lorentzCode for a contract along with compilation options for the Lorentz compiler.It is expected that a  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 2 should not be used for distribution of contracts.lorentzThe contract itself.lorentzContract views.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 .lorentz-Function to transform byte strings with. See .lorentzRuns Michelson optimizer with default config and does not touch strings and bytes.lorentz?Leave contract without any modifications. For testing purposes.lorentz%For use outside of Lorentz. Will use .lorentzCompile Lorentz code, optionally running the optimizer, string and byte transformers.lorentz'Construct and compile Lorentz contract.This is an alias for .lorentz'Construct and compile Lorentz contract.Note that this accepts code with initial and final stacks unpaired for simplicity.lorentz Version of ) that accepts custom compilation options.lorentzConstruct a view. 6mkView @"add" @(Integer, Integer) do car; unpair; addlorentzCompile contract with .lorentz&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. However, compilation with  should be valid.lorentz0Compile multiple views, with the related checks.lorentzCompile a single view.lorentzSet all the contract's views. compileLorentzContract $ defaultContractData do ... & setViews ( mkView  "myView" () do ... , mkView "anotherView" Integer do ... ) lorentz Version of  that accepts a 5.May be useful if you have too many views or want to combine views sets.lorentzRestrict type of , ) or other similar type to have no views.lorentzInterpret a Lorentz instruction, for test purposes. Note that this does not run the optimizer.lorentzLike 2, but works on singleton input and output stacks.lorentzLorentz version of analyzer.&&3 Safe-Inferred;"$%&'()*-/01235689:;<=?VlorentzRun 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. Note, that we specify the result type of polymorphic operations to avoid ambiguity arising from polymorphic literals.Use 1 to represent stack of two or more elements, and  for empty stacks. Stacks of one element are represented by the element itself.nop -$ 55sub -$ 3 ::: 2 :: Integer1push (9 :: Integer) -$ ZSNil9%add # add -$ 1 ::: 2 ::: 3 :: Integer6lorentz(Version of (-$?) with arguments flipped.lorentz'Version of (-$) with arguments flipped.lorentz1Version of (-$) applicable to a series of values.  222224 Safe-Inferred;"$%&'()*-/01235689:;<=?Xlorentz.Pretty-print a Haskell value as Michelson one.lorentz4Pretty-print a Lorentz contract into Michelson code.5 Safe-Inferred;"$%&'()*-/01235689:;<=?Zlorentz 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.If 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 .  Safe-Inferred;"$%&'()*-/01235689:;<=?[j   '& !"4$   )*X% ,-;<./ _` 567Z^][\uxvwz|{} poqrstW{mnY:  flkjihegcdab      y~SVUTe R 8 23#  ( 0  +      1Q =DENFCJLMIAOGHKBP>        9?@   '& !"4$   )*X% ,-;<./ _` 567Z^][\[uxvwz|{} poqrstW{mnY:  flkjihegcdab      y~SVUTUeR 8 23#  ( 0  +      1Q =DENFCJLMIAOGHKBP>        9?@I Safe-Inferred<"$%&'()*-/01235689:;<=?oJKLJMNJKOJPQJRSJKTJKUJKVJKWJKXJYZ[\][\^J_`JabJKcJKd[efghigjkJlm[enJop[eqJlEJlr[esJotJouJYvJYwJxyJxyz{|z}~JKJKJKJJJ>L99                              7                                                     <                                                                                                                   =                                                                                                                                                                            ! ! ! " " " " " " " " " " " # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #                      G          $ $ $ $ $ $ $ $ $ % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %B% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %                              & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ( ( ( ( ( ( ( ( ( ( ) ) ) ) ) ) ) ) ) ) ) * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ********************************************************+,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,----------............................./////////////////////////011111111 1111111111111111111111 1111111111111111111111111122222222222222222222222222222222222333334455555555555555555555    J ::  JK:#########[e$$$$%%%%&&&&&&&&[e[e[e&'''''''***,/0011122IIIIIIIIlorentz-0.16.0-inplaceLorentz.PreludeLorentz.Rebound Lorentz.ValueLorentz.CustomArith.FixedArithLorentz.Constraints.Scopes Lorentz.ADTLorentz.AnnotationLorentz.Entrypoints.DocLorentz Lorentz.DocLorentz.AddressLorentz.ViewBase Lorentz.BaseLorentz.ErrorsLorentz.Entrypoints.HelpersLorentz.Entrypoints.CoreLorentz.Constraints.Derivative Lorentz.Instr Lorentz.ExtLorentz.CommonLorentz.PolymorphicLorentz.Entrypoints.Impl Lorentz.Bytes Lorentz.Pack Lorentz.ArithLorentz.CustomArith.CommonLorentz.WrappableLorentz.Entrypoints.Manual Lorentz.ZipLorentz.CoercionsLorentz.LambdaLorentz.ReferencedLorentz.Util.THLorentz.Errors.Numeric.ContractLorentz.ExtensibleLorentz.ReferencedByName Lorentz.Macro Lorentz.RangeLorentz.Errors.Numeric.DocLorentz.Default Lorentz.IsoLorentz.StoreClassLorentz.StoreClass.Extra!Lorentz.CustomArith.RationalArithLorentz.CustomArith.Conversions Lorentz.ExprLorentz.TicketsLorentz.Layouts.NonDupableLorentz.UParam Lorentz.RunLorentz.Run.Simple Lorentz.PrintLorentz.ContractRegistrylorentzNiceParameterFullLorentz.Constraints ContractDocMorley.Michelson.Typed.Instr:#Lorentz.Instr.FramedfailWith:!Lorentz.Entrypoints Data.CoercecoerceviewLorentz.Errors.Numeric Data.MaybeNothingLorentz.CustomArith constructTLorentz.Layouts Paths_lorentzbaseGHC.Base$GHC.NumnegatereturnGHC.OverloadedLabels fromLabel Data.String fromString<>memptymappendmconcatpureGHC.EnumBoundedghc-prim GHC.ClassesEqOrdGHC.ShowShow GHC.GenericsGeneric SemigroupMonoid GHC.TypesBool ghc-bignumGHC.Num.IntegerIntegerGHC.Num.NaturalNatural GHC.MaybeMaybe~ Data.EitherEitherFalseJustTrueLeftRightminBoundmaxBound Data.ProxyProxycontainers-0.6.7Data.Set.InternalSetData.Map.InternalMap.bytestring-0.11.4.0Data.ByteString.Internal.Type ByteString text-2.0.2Data.Text.InternalTextsconcatstimes Data.Function& Data.FixedFixedMkFixedconstraints-0.13.4-a8e1f3503c00ee82a6deb6cecca8333a05e299a1a8f8f7be0c69bc202c490c1aData.ConstraintwithDictdata-default-class-0.1.2.0-7288b3ef1b90dc47ad37c369453e53f4bdf04f25ac559d3228179950435abeacData.Default.ClassDefaultdefnamed-0.3.0.1-7acd30f72c9daf5bc580201c4a267bef21b5a01c39de388eb525851d53652724Named.Internal:?!text-manipulate-0.3.1.0-05bf2dca4c04fb2d0204603db628fef06e903e7e56a27547dd997ba8a52518aaData.Text.ManipulatetoPascaluniversum-1.8.2-614c350ef815452d1fd0742055d54438b6d98d61d43ca9c07b64d671eda228f3Universum.Debugerror undefinedUniversum.TypeOpsvinyl-0.14.3-92b6343fa8e44e207669b6f190d15172c38d295689068d33f757f38dd8d91202Data.Vinyl.CoreRecRNil:&morley-prelude-0.6.0-inplaceUnsafe fromIntegermorley-1.20.0-inplaceMorley.Michelson.TextmtMTextMorley.Util.LabelLabel!Morley.Michelson.Typed.Annotation insertTypeAnnmkUType,Morley.Michelson.Typed.Haskell.CompatibilityligoCombLayout ligoLayout"Morley.Michelson.Typed.Haskell.DocconcreteTypeDocHaskellRepconcreteTypeDocMichelsonRepcustomTypeDocMdReferencedStoragedTypeDepgenericTypeDocDependencieshaskellAddNewtypeFieldhaskellRepNoFieldshomomorphicTypeDocHaskellRephomomorphicTypeDocMdReferencehomomorphicTypeDocMichelsonReppoly1TypeDocMdReferencepoly2TypeDocMdReferencetypeDocBuiltMichelsonRepunsafeConcreteTypeDocHaskellRep!unsafeConcreteTypeDocMichelsonRep$Morley.Michelson.Typed.Haskell.ValuecoerceContractRef$Morley.Michelson.Untyped.Entrypoints DefEpName"Morley.Michelson.Internal.ViewNameViewNameUnsafeViewName unViewNameMorley.Michelson.Typed.Aliases OperationValueMorley.Michelson.Typed.Contract IsNotInView"Morley.Michelson.Typed.Entrypoints EpAddress EpAddress' eaAddress eaEntrypointDTypeHaveCommonTypeCtor IsHomomorphicSomeTypeWithDocTypeDocFieldDescriptions TypeHasDoctypeDocDependenciestypeDocHaskellReptypeDocMdDescriptiontypeDocMdReferencetypeDocMichelsonRep typeDocNameTypeHasFieldNamingStrategytypeFieldNamingStrategy,Morley.Michelson.Typed.Haskell.Instr.ProductConstructorFieldTypesInstrConstructCBigMapBigMapId unBigMapId ContractRef crAddress crEntrypointEntrypointCallIsoValueToTfromValtoValSomeEntrypointCallTickettAmounttData tTicketermkBigMap WellTypedToT,Morley.Michelson.Typed.Scope.Internal.Scopes ConstantScopeEpNameMorley.Michelson.DocSomeDocDefinitionItemMorley.Util.MarkdownMarkdownDocItemDocItemPlacementKindDocItemInlinedDocItemInDefinitions DocItemRefDocItemPlacementDocItemReferencedMorley.Tezos.CoreChainIdMorley.Tezos.Crypto.TimelockChestChestKeyMorley.Tezos.AddressAddressMorley.Tezos.CryptoKeyHashMutez PublicKey Signature TimestampMorley.Util.TextstripFieldPrefix DocItemIdMorley.Tezos.Crypto.BLS12381 Bls12381Fr Bls12381G1 Bls12381G2oneMuteztimestampFromSecondstimestampFromUTCTimetimestampQuotetoMuteztz zeroMutez dropPrefixtoCameltoSnake ContainsDoc SomeDocItemSubDocContainsUpdateableDocGHasAnnotationgGetAnnotation HasAnnotation getAnnotation annOptionsGenerateFieldAnnFlagGenerateFieldAnnNotGenerateFieldAnnFollowEntrypointFlagFollowEntrypointNotFollowEntrypoint AnnOptionsfieldAnnModifierappendToctorNameToAnnWithOptionsgGetAnnotationNoField$fDefaultAnnOptions$fGHasAnnotation:*:$fGHasAnnotation:+:$fGHasAnnotationM1$fGHasAnnotationM10$fGHasAnnotationM11$fGHasAnnotationM12$fGHasAnnotationU1$fGIsSumTypeFUNM1$fGIsSumTypeFUNK1$fGIsSumTypeFUNM10$fGIsSumTypeFUNM11$fGIsSumTypeFUN:*:$fGIsSumTypeFUN:+:$fGIsSumTypeFUNV1$fGIsSumTypeFUNU1$fGHasAnnotationK1$fHasAnnotation(,,,,,,)$fHasAnnotation(,,,,,)$fHasAnnotation(,,,,)$fHasAnnotation(,,,)$fHasAnnotation(,,)$fHasAnnotation(,)$fHasAnnotationEither$fHasAnnotationChestKey$fHasAnnotationChest DocGrouping$fHasAnnotationOperation'$fHasAnnotation[]$fHasAnnotationSet$fHasAnnotationBigMapId$fHasAnnotationBigMap$fHasAnnotationMap$fHasAnnotationTicket$fHasAnnotationContractRef$fHasAnnotationChainId$fHasAnnotationSignature$fHasAnnotationPublicKey$fHasAnnotationTimestamp$fHasAnnotationHash$fHasAnnotationEpAddress$fHasAnnotationConstrained$fHasAnnotationMutez$fHasAnnotationByteString$fHasAnnotationBool$fHasAnnotationMText$fHasAnnotationNatural$fHasAnnotationInteger$fHasAnnotation()$fHasAnnotationMaybe$fHasAnnotationNamedF$fHasAnnotationNamedF0 NiceNoBigMapNiceComparable NiceViewableNiceUntypedValueNiceFullPackedValueNiceUnpackedValueNicePackedValueDupable NiceConstantNiceStorageFull NiceStorage NiceParameter CanHaveBigMapNoBigMapNoContractType NoOperation KnownValue $fKnownValuea$fNoOperationa$fNoContractTypea $fNoBigMapa$fCanHaveBigMapa$fNiceParametera$fNiceStoragea$fNiceConstanta $fDupablea$fNicePackedValuea$fNiceUnpackedValuea$fNiceUntypedValuea$fNiceViewablea$fNiceComparablen$fNiceNoBigMapnMorley.Util.CustomGenerichaskellBalancedGenericStrategyRequireSumTypeCanHaveEntrypointsShouldHaveEntrypointsunHasEntrypoints ctorNameToAnn ctorNameToEp!$fHasRPCReprShouldHaveEntrypointsattachDocCommonsbuildDocbuildMarkdownDoccontractDocToMarkdowndocDefinitionRefdocItemPositiondocItemSectionRef finalizedAsIs mdTocFromRefmkDGitRevision modifyDocmorleyRepoSettingssubDocToMarkdownbuildDocUnfinalizedmodifyDocEntirely cdContentscdDefinitionIds cdDefinitionscdDefinitionsSetDAnchorDComment DDescriptionDGeneralInfoSection DGitRevisionDGitRevisionKnownDGitRevisionUnknownDNameDocElemdeItemdeSubdocItemDependencies docItemPos docItemRefdocItemSectionDescriptiondocItemSectionNamedocItemSectionNameStyledocItemToMarkdown docItemToToc docItemsOrder DocItemPos DocItemNoRefDocItemRefInlined DocSectionDocSectionNameStyleDocSectionNameBigDocSectionNameSmallGitRepoSettingsgrsMkGitRevisionWithFinalizedDoc$fGenericShouldHaveEntrypoints$fIsoValueShouldHaveEntrypointsEpdNoneParameterContainsEntrypoints:>HasEntrypointOfType TrustEpNameHasDefEntrypointArgHasEntrypointArguseHasEntrypointArgGetEntrypointArgCustomNiceEntrypointName EntrypointRef CallDefaultCallNoExplicitDefaultEntrypointForbidExplicitDefaultEntrypointGetDefaultEntrypointArgGetEntrypointArgLookupParameterEntrypointAllParameterEntrypointsGetParameterEpDerivationParameterDeclaresEntrypointsParameterHasEntrypointsParameterEntrypointsDerivation EpCallingStep EpsWrapIn EpCallingDescepcdArgepcdEntrypoint epcdStepsEpConstructionRes EpConstructedEpConstructionFailedRequireAllUniqueEntrypointsRequireAllUniqueEntrypoints'EntrypointsDerivationEpdAllEntrypointsEpdLookupEntrypointepdNotesepdCallepdDescspepNotespepCallpepDescspepDescsWithDefparameterEntrypointsToNotesparameterEntrypointCallparameterEntrypointCallDefaultsepcCallRootCheckedeprNameparameterEntrypointCallCustom$fDefaultEntrypointRef$fIsLabelnameEntrypointRef#$fHasEntrypointArgkcpTrustEpNamearg$$fEntrypointsDerivationTYPEEpdNonecp($fHasEntrypointArgTYPEcpEntrypointRefarg$fShowEpCallingStep$fEqEpCallingStep$fShowEpCallingDescViewInterfaceMatchErrorVIMViewNotFoundVIMViewArgMismatchVIMViewRetMismatchDemoteViewsDescriptor ViewInterfaceviNameviArgviRet ViewsNamesHasViewLookupRevealView LookupView ViewsList RevealViews>->?:: ViewTyInfodemoteViewNamedemoteViewTyInfosdemoteViewsDescriptorcheckViewsCoverInterface$fDemoteViewTyInfo:$fDemoteViewTyInfo[]"$fExceptionViewInterfaceMatchError"$fBuildableViewInterfaceMatchError$fShowViewInterfaceMatchError$fEqViewInterfaceMatchErrorNiceViewsDescriptor NiceViewsDupableDecision IsDupable IsNotDupabledecideOnDupableMapLorentzInstrmapLorentzInstrFnContractcMichelsonContractcDocumentedCodeViewCodeSomeContractCode ContractCodeunContractCode ContractOut%>:-> LorentzInstrunLorentzInstrFII iGenericIfiAnyCodeiNonFailingCode iMapAnyCode iForceNotFailmkContractCodetoMichelsonContract#parseLorentzValuetransformStringsLorentztransformBytesLorentzoptimizeLorentzWithConfoptimizeLorentz $fMonoid:->$fSemigroup:-> $fNFData:->$fRenderDoc:->$fHasAnnotation:-> $fIsoValue:->$fToExpressionContract$fNFDataContract$fBuildableParseLorentzError$fMapLorentzInstr:->$fShowParseLorentzError$fEqParseLorentzError$fShowContractCode$fEqContractCode$fNFDataContractCode $fShow:->$fEq:-> $fEqContract$fShowContractframedstackRef printComment justCommentcommentcommentAroundFuncommentAroundStmt testAssert stackType Entrypoint_ EntrypointFromContractReffromContractRef ToContractRef toContractRefImplicitContractParameter ToTAddress toTAddress ToAddress toAddressFutureContractunFutureContract ToTAddress_TAddress unTAddress asAddressOf asAddressOf_callingAddresscallingDefAddress toTAddress_convertContractRef$fHasRPCReprTAddress$fHasRPCReprFutureContract$fHasAnnotationFutureContract$fIsoValueFutureContract$fToAddressContractRef$fToAddressFutureContract$fToAddressTAddress$fToAddressEpAddress$fToAddressKindedAddress$fToAddressConstrained$fToAddressConstrained0$fToTAddresscpvdTAddress$fToTAddresscpvdConstrained$fToTAddresscpvdKindedAddress$fToTAddresscpvdKindedAddress0$fToTAddresscpvdConstrained0$fToTAddresscpvdKindedAddress1"$fImplicitContractParametercptotcp$$fImplicitContractParametercpTTicket$fToContractRefargTAddress$fToContractRefcpFutureContract$fToContractRefcpContractRef$fFromContractRefcpConstrained$fFromContractRefcpEpAddress!$fFromContractRefcpFutureContract$fFromContractRefcpContractRef$fGenericTAddress$fShowTAddress $fEqTAddress $fOrdTAddress$fBuildableTAddress$fIsoValueTAddress$fHasAnnotationTAddress rightCombalphabeticallyforbidUnnamedFieldscstr customGenericcustomGeneric'deriveFullTypefldfromDepthsStrategyfromDepthsStrategy'leaveUnnamedFields leftBalancedleftCombmakeRightBalDepths!mangleGenericStrategyConstructorsmangleGenericStrategyFields reifyDataTypereorderingConstrsreorderingDatareorderingFields rightBalanced withDepths ReadTicket rtTicketerrtDatartAmountNeverList$fTypeHasDocNever$fHasRPCReprNever$fHasAnnotationNever$fBuildableNever$fShowReadTicket$fEqReadTicket$fOrdReadTicket$fGenericNever $fShowNever $fEqNever $fOrdNever$fIsoValueNever $fNFDataNever OpenChest PrintAsValue$fGenericReadTicket$fBuildablePrintAsValue$fTypeHasDocOpenChest$fGenericOpenChest$fShowOpenChest $fEqOpenChest$fIsoValueOpenChest$fHasAnnotationOpenChest$fIsoValueReadTicket SliceOpHs ConcatOpHsGetOpHs GetOpKeyHs GetOpValHsUpdOpHs UpdOpKeyHs UpdOpParamsHsSizeOpHsIterOpHs IterOpElHsMapOpHs MapOpInpHs MapOpResHs IsoMapOpResMemOpHs MemOpKeyHs$fMemOpHsBigMap $fMemOpHsMap $fMemOpHsSet$fMapOpHsMaybe $fMapOpHs[] $fMapOpHsMap $fIterOpHsSet $fIterOpHs[] $fIterOpHsMap $fSizeOpHsMap $fSizeOpHs[] $fSizeOpHsSet$fSizeOpHsByteString$fSizeOpHsMText $fUpdOpHsSet$fUpdOpHsBigMap $fUpdOpHsMap$fGetOpHsBigMap $fGetOpHsMap$fConcatOpHsByteString$fConcatOpHsMText$fSliceOpHsByteString$fSliceOpHsMText BuildEPTreeEPTreeEPNodeEPLeaf EPDelegatePlainEntrypointsC EpdWithRoot EpdDelegate EpdRecursiveEpdPlain $fGEntrypointsNotesmodeEPLeaf:*:$fGEntrypointsNotesmodeEPLeafV1$fGEntrypointsNotesmodeEPLeafU1*$fGEntrypointsNotesEpdDelegateEPDelegateK1$fGEntrypointsNotesmodeepM1$fGEntrypointsNotesmodeEPNodeM1 $fGEntrypointsNotesmodeEPNode:+:$fGEntrypointsNotesmodeepM10#$fGEntrypointsNotesEpdRecursiveepK1($fEntrypointsDerivationTYPEEpdWithRootcp($fEntrypointsDerivationTYPEEpdDelegatecp)$fEntrypointsDerivationTYPEEpdRecursivecp%$fEntrypointsDerivationTYPEEpdPlaincp#$fGEntrypointsNotesmodeEPDelegateM1$fGEntrypointsNotesmodeEPLeafM1 DViewDescViewsDescriptorHasDocviewsDescriptorNamerenderViewsDescriptorDocDViewRetDViewArgDViewdvNamedvSubDEntrypointExampledocdocGroupcontractGeneralDefaultcutLorentzNonDocmkDEntrypointExample$fTypeHasDocFutureContract$fContainsUpdateableDocContract$fContainsDocContract#$fContainsUpdateableDocContractCode$fContainsDocContractCode$fContainsUpdateableDoc:->$fContainsDoc:->$fDocItemDEntrypointExample$fDocItemDView$fDocItemDViewArg$fDocItemDViewRet$fRenderViewsImpl:$fRenderViewsImpl[]$fDocItemDViewDesc$fOrdDViewDesc $fEqDViewDesc$fTypeHasDocTAddress OpenChestT ChestContentTChestOpenFailedTChestTunChestTKeccakSha3Blake2bSha512Sha256DHashAlgorithmKnownHashAlgorithmhashAlgorithmName computeHashtoHashHash UnsafeHashunHash TSignature unTSignaturePackedunPacked BytesLiketoByteslSigntoHashHs openChestT$fBytesLikeByteString$fTypeHasDocPacked$fHasRPCReprPacked$fBuildablePacked$fTypeHasDocTSignature$fHasRPCReprTSignature$fBuildableTSignature$fHasRPCReprHash$fBuildableHash$fDocItemDHashAlgorithm$fOrdDHashAlgorithm$fEqDHashAlgorithm$fKnownHashAlgorithmSha256$fKnownHashAlgorithmSha512$fKnownHashAlgorithmBlake2b$fTypeHasDocHash$fKnownHashAlgorithmSha3$fKnownHashAlgorithmKeccak$fTypeHasDocChestT$fHasRPCReprChestT$fTypeHasDocOpenChestT$fHasRPCReprOpenChestT$fGenericOpenChestT$fShowOpenChestT$fEqOpenChestT$fIsoValueOpenChestT$fHasAnnotationOpenChestT$fIsoValueChestT$fHasAnnotationChestT$fGenericChestT $fShowHash$fEqHash $fOrdHash $fGenericHash$fIsoValueHash$fBytesLikeHash$fShowTSignature$fGenericTSignature$fIsoValueTSignature$fHasAnnotationTSignature $fShowPacked $fEqPacked $fOrdPacked$fGenericPacked$fIsoValuePacked$fHasAnnotationPacked$fBytesLikePacked lPackValueRawlUnpackValueRaw lPackValue lUnpackValue lEncodeValuevalueToScriptExprexpressionToScriptExprToBytesArithOpHsevalToBytesOpHsToIntegerArithOpHs evalToIntOpHsDefUnaryArithOpDefUnaryArithOpExtraConstraintsdefUnaryArithOpHsUnaryArithOpHsUnaryArithResHsevalUnaryArithOpHs DefArithOp defEvalOpHs ArithOpHs evalArithOpHs$fDefArithOpTYPEEDiv$fDefArithOpTYPELsr$fDefArithOpTYPELsl$fDefArithOpTYPEXor$fDefArithOpTYPEOr$fDefArithOpTYPEAnd$fDefArithOpTYPEMul$fDefArithOpTYPESub$fDefArithOpTYPEAdd $fArithOpHsLsrByteStringNaturalr$fArithOpHsLsrNaturalNaturalr $fArithOpHsLslByteStringNaturalr$fArithOpHsLslNaturalNaturalr#$fArithOpHsXorByteStringByteStringr$fArithOpHsXorBoolBoolr$fArithOpHsXorNaturalNaturalr#$fArithOpHsAndByteStringByteStringr$fArithOpHsAndBoolBoolr$fArithOpHsAndNaturalNaturalr$fArithOpHsAndIntegerNaturalr"$fArithOpHsOrByteStringByteStringr$fArithOpHsOrBoolBoolr$fArithOpHsOrNaturalNaturalr$fArithOpHsEDivMutezNaturalr$fArithOpHsEDivMutezMutezr$fArithOpHsEDivIntegerIntegerr$fArithOpHsEDivNaturalNaturalr$fArithOpHsEDivIntegerNaturalr$fArithOpHsEDivNaturalIntegerr#$fArithOpHsMulBls12381FrBls12381G2r#$fArithOpHsMulBls12381FrBls12381G1r#$fArithOpHsMulBls12381G2Bls12381Frr#$fArithOpHsMulBls12381G1Bls12381Frr#$fArithOpHsMulBls12381FrBls12381Frr $fArithOpHsMulBls12381FrNaturalr $fArithOpHsMulBls12381FrIntegerr $fArithOpHsMulNaturalBls12381Frr $fArithOpHsMulIntegerBls12381Frr$fArithOpHsMulMutezNaturalr$fArithOpHsMulNaturalMutezr$fArithOpHsMulIntegerIntegerr$fArithOpHsMulNaturalNaturalr$fArithOpHsMulIntegerNaturalr$fArithOpHsMulNaturalIntegerr!$fArithOpHsSubTimestampTimestampr$fArithOpHsSubTimestampIntegerr$fArithOpHsSubIntegerIntegerr$fArithOpHsSubNaturalNaturalr$fArithOpHsSubIntegerNaturalr$fArithOpHsSubNaturalIntegerr#$fArithOpHsAddBls12381G2Bls12381G2r#$fArithOpHsAddBls12381G1Bls12381G1r#$fArithOpHsAddBls12381FrBls12381Frr$fArithOpHsAddMutezMutezr$fArithOpHsAddIntegerTimestampr$fArithOpHsAddTimestampIntegerr$fArithOpHsAddIntegerIntegerr$fArithOpHsAddNaturalNaturalr$fArithOpHsAddIntegerNaturalr$fArithOpHsAddNaturalIntegerr$fDefUnaryArithOpTYPENeg$fDefUnaryArithOpTYPEGe$fDefUnaryArithOpTYPEGt$fDefUnaryArithOpTYPELe$fDefUnaryArithOpTYPELt$fDefUnaryArithOpTYPENeq$fDefUnaryArithOpTYPEEq'$fDefUnaryArithOpTYPEAbs$fDefUnaryArithOpTYPENot$fUnaryArithOpHsGeInteger$fUnaryArithOpHsLeInteger$fUnaryArithOpHsGtInteger$fUnaryArithOpHsLtInteger$fUnaryArithOpHsNeqInteger$fUnaryArithOpHsEq'Integer$fUnaryArithOpHsNotByteString$fUnaryArithOpHsNotBool$fUnaryArithOpHsNotNatural$fUnaryArithOpHsNotInteger$fUnaryArithOpHsAbsInteger$fUnaryArithOpHsNegBls12381G2$fUnaryArithOpHsNegBls12381G1$fUnaryArithOpHsNegBls12381Fr$fUnaryArithOpHsNegNatural$fUnaryArithOpHsNegInteger$fToIntegerArithOpHsbs$fToIntegerArithOpHsBls12381Fr$fToIntegerArithOpHsNatural$fUnaryArithOpHsGeNatural$fUnaryArithOpHsLeNatural$fUnaryArithOpHsGtNatural$fUnaryArithOpHsLtNatural$fUnaryArithOpHsNeqNatural$fUnaryArithOpHsEq'Natural$fToBytesArithOpHsInteger$fToBytesArithOpHsNaturalLorentzRoundinground_ceil_floor_Divdiv Wrappable Unwrappable Unwrappabled$fUnwrappableFixed$fUnwrappableNamedF$fUnwrappableNamedF0$fWrappableNamedF$fWrappableNamedF0ParameterWrapperunParameterWraper$fHasRPCReprParameterWrapper)$fParameterHasEntrypointsParameterWrapper2$fEntrypointsDerivationTYPEPwDerivParameterWrapper$fGenericParameterWrapper$fIsoValueParameterWrapper$fUnwrappableParameterWrapper$fWrappableParameterWrapper ZipInstrsZipInstr ZippedStack zipInstrTypedunzipInstrTypedZSNilZippedStackRepr:::##zipInstr unzipInstr zippingStackunzippingStack$fBuildableZippedStackRepr$fBuildableZSNil $fZipInstr: $fZipInstr:0 $fZipInstr[] $fShowZSNil $fEqZSNil$fGenericZSNil$fIsoValueZSNil$fHasAnnotationZSNil$fShowZippedStackRepr$fEqZippedStackRepr$fGenericZippedStackRepr$fIsoValueZippedStackRepr$fHasAnnotationZippedStackRepr Coercible_ Castable_ CanCastTo castDummyMichelsonCoercible forcedCoerce forcedCoerce_gForcedCoerce_ fakeCoerce fakeCoercing coerceUnwrapunsafeCoerceWrap coerceWraptoNamed fromNamed checkedCoercecheckedCoerce_checkedCoercing_allowCheckedCoerceToallowCheckedCoerce castDummyG$fCanCastToTYPETYPEHashHash'$fCanCastToTYPETYPETSignatureTSignature$fCanCastToTYPETYPEPackedPacked!$fCanCastToTYPETYPEHashByteString'$fCanCastToTYPETYPETSignatureByteString#$fCanCastToTYPETYPEPackedByteString*$fCanCastToTYPETYPEFutureContractEpAddress&$fCanCastToTYPETYPEConstrainedTAddress&$fCanCastToTYPETYPETAddressConstrained1$fCanCastToTYPETYPEZippedStackReprZippedStackRepr!$fCanCastToTYPETYPE(,,,,,)(,,,,,)$fCanCastToTYPETYPE(,,,,)(,,,,)$fCanCastToTYPETYPE(,,,)(,,,)$fCanCastToTYPETYPE(,,)(,,)$fCanCastToTYPETYPE(,)(,)$fCanCastToTYPETYPENamedFNamedF)$fCanCastToTYPETYPEContractRefContractRef$fCanCastToTYPETYPE:->:->$fCanCastToTYPETYPEBigMapBigMap$fCanCastToTYPETYPEMapMap$fCanCastToTYPETYPESetSet$fCanCastToTYPETYPEEitherEither$fCanCastToTYPETYPEMaybeMaybe$fCanCastToTYPETYPE[][]$fCanCastTokkaaLambda WrappedLambda RecLambdamkLambda mkLambdaRec-$fCanCastToTYPETYPEWrappedLambdaWrappedLambda$fTypeHasDocWrappedLambda$fHasRPCReprWrappedLambda$fHasAnnotationWrappedLambda$fMapLorentzInstrWrappedLambda$fIsoValueWrappedLambda$fShowWrappedLambda$fEqWrappedLambda$fGenericWrappedLambdaLorentzFunctorlmapConstraintDIPNLorentz PairUpdateHsConstraintPairUpdateLorentz PairGetHsConstraintPairGetLorentzConstraintDUGLorentzConstraintDIGLorentzConstraintDUPNLorentznopdropdropNdup dupNPeanodupNswapdigPeanodigdugPeanodugpushsomenoneunitifNonepaircarcdrunpairleftrightifLeftnilconsifConssizeemptySetemptyMap emptyBigMapmapitermemgetpairGetupdate getAndUpdate pairUpdateif_looploopLeftlambda lambdaRecexecexecuteapply applicatedip dipNPeanodipNcastpackunpackpackRaw unpackRawconcatconcat'sliceisNataddsubrsubsubMutez rsubMutezmuledivabsneglsllsrorandxornotcompareeq0neq0lt0gt0le0ge0intnatbytesview'self selfCallingcontractcontractCallingunsafeContractCallingrunFutureContractepAddressToContracttransferTokens setDelegatecreateContractimplicitAccountnow minBlockTimeamountbalance votingPowertotalVotingPowercheckSignaturesha256sha512blake2Bsha3keccakhashKey pairingChecksourcesenderaddresschainIdlevel selfAddressneverticket readTicket splitTicketsplitTicketNamed joinTickets openChestemitemitAutoemit'failingWhenPresent updateNew$fLorentzFunctorSetab$fLorentzFunctorMapab$fLorentzFunctor[]ab$fLorentzFunctorEitherab$fLorentzFunctorMaybeabDipTdipTDupTdupTdropT$fTheOnlyCke_errm_err:y $fDupTast$fDipTainpdipInpdipOutout$fTheOnlyCke_errm_err:y0$fTheOnlyCke_errm_err[]yDThrowsDErrorCustomErrorHasDoccustomErrDocMdCausecustomErrDocMdCauseInEntrypointcustomErrClasscustomErrArgumentSemantics ErrorClassErrClassActionExceptionErrClassBadArgumentErrClassContractInternalErrClassUnknownMustHaveErrorArgIsCustomErrorArgRepverifyErrorTagcustomErrorRepDocDepscustomErrorHaskellRepCustomErrorRep UnitErrorArg NoErrorArg CustomErrorceTagceArgErrorArg SomeError ImpossibleUnspecifiedError ErrorHasDocErrorRequirements errorDocNameerrorDocMdCauseerrorDocMdCauseInEntrypointerrorDocHaskellRep errorDocClasserrorDocDependencieserrorDocRequirementsIsError errorToVal errorFromVal failUsing ErrorScope isoErrorToValisoErrorFromValsimpleFailUsingfailUnexpectederrorTagToMTexterrorTagToText failCustomfailCustomNoArg failCustom_isInternalErrorClass typeDocMdDescriptionReferToError$fIsoValueCustomError$fBuildableCustomError$fBuildableErrorClass$fErrorHasDocFUN$fErrorHasDocImpossible$fErrorHasDocUnspecifiedError$fErrorHasDoc()$fErrorHasDocMText $fIsErrorFUN$fIsErrorImpossible$fIsErrorUnspecifiedError $fIsError()$fIsErrorMText$fBuildableSomeError $fEqSomeError$fErrorHasDocCustomError$fIsErrorCustomError$fIsCustomErrorArgRep(,)$fIsCustomErrorArgRepMText$fDocItemDError $fOrdDError $fEqDError$fDocItemDThrows $fEqDThrows$fLiftBoxedRepErrorClass$fGenericUnspecifiedError$fIsoValueUnspecifiedError$fShowCustomError$fEqCustomError entrypointDoc errorDocArgtypeDocErrorTagExclusions ErrorTagMapgatherErrorTagsaddNewErrorTagsbuildErrorTagMapexcludeErrorTagsapplyErrorTagMapapplyErrorTagMapWithExclusionsuseNumericErrorserrorFromValNumericerrorToValNumericExtensibleHasDocextensibleDocNameextensibleDocDependenciesextensibleDocMdDescriptionExtConversionErrorConstructorIndexNotFoundArgumentUnpackFailedWrapExtCExtVal ExtensibletoExtVal fromExtValwrapExt$fHasRPCReprExtensible$fWrapExtNoFields$fWrapExtOneField$fBuildableExtConversionError$fGExtValkt:+:$fGExtValTYPEtM1$fGExtValTYPEtM10 $fGExtValktM1$fTypeHasDocExtensible$fDocumentCtorCtor$fEqExtConversionError$fShowExtConversionError$fGenericExtensible$fEqExtensible$fShowExtensible$fIsoValueExtensible$fHasAnnotationExtensible$fUnwrappableExtensibleCaseTC CaseArrow/-> CaseClauseLHasDupableGettersHasFieldsOfType:= NamedFieldHasFieldOfTypeHasFieldtoField toFieldNamedgetField getFieldNamedsetField modifyField getFieldOpen setFieldOpen constructconstructStack deconstruct fieldCtorwrap_wrapOnecase_caseT unsafeUnwrap_$fHasDupableGettersTYPEa$fCaseArrownamebodyCaseClauseL HasNamedVars HasNamedVar VarIsUnnamed dupLNameddupL$fHasNamedVar[]namevar$fElemHasNamedVar:namevarFalse$fElemHasNamedVar:namevarTrue$fHasNamedVar:namevarIModIDivNonZerononZero VoidResult unVoidResultVoid_ voidParam voidResProxyView_ viewParamviewCallbackToUpdateN updateNImplConstraintUpdateNLorentzReplaceN replaceNImplConstraintReplaceNLorentz mapInsert mapInsertNew deleteMapErrInstreqneqgtlegeltifEq0ifNeq0ifLt0ifGt0ifLe0ifGe0ifEqifNeqifLtifGtifLeifGefail_assert assertEq0 assertNeq0 assertLt0 assertGt0 assertLe0 assertGe0assertEq assertNeqassertLtassertGtassertLeassertGe assertNone assertSome assertLeft assertRight assertUsingdropXcloneXduupXframedNcarNcdrNpapairppaiircdarcddrcaarcadrsetCarsetCdrmapCarmapCdrifRightifSomewhen_unless_whenSomewhenNone setInsert setInsertNew setDeletereplaceNupdateNbuildViewTuple_ buildView_mkView_ wrapView_ unwrapView_view_ voidResultTagmkVoidvoid_wrapVoid unwrapVoidaddressToEpAddresspushContractRefdupTop2 fromOptionisSomenonnon'isEmptyidivimod$fCustomErrorHasDoc"no_view" $fCloneXSas $fCloneXZas$fMapInstrsBigMap$fMapInstrsMap$fReplaceN[][]Ssamidtail$fReplaceNkkSsamidtail$fUpdateN[][]Ssabmidtail$fUpdateNk[]Ssabmidtail$fUpdateNk[]Ssabmidtail0$fBuildableView_$fBuildableView_0$fTypeHasDocView_$fHasRPCReprView_$fCanCastToTYPETYPEView_View_$fBuildableVoid_$fTypeHasDocVoid_$fHasRPCReprVoid_$fCanCastToTYPETYPEVoid_Void_$fIsoValueVoidResult$fErrorHasDocVoidResult$fIsErrorVoidResult$fTypeHasDocVoidResult$fNonZeroTicket$fNonZeroNatural$fNonZeroInteger$fArithOpHsIDivndmq$fArithOpHsIModndmr$fGenericVoidResult$fEqVoidResult$fGenericVoid_ $fShowVoid_$fHasAnnotationVoid_ $fEqView_ $fShowView_$fGenericView_$fHasAnnotationView_$fIsoValueVoid_$fIsoValueView_ IsCondition ifThenElse ConditionHoldsIsSomeIsNoneIsLeftIsRightIsConsIsNilNotIsZeroIsEqIsNeqIsLtIsGtIsLeIsGeNamedBinConditionPreserveArgsBinCondition>><.>.<=.>=.==./=. keepIfArgs-$fIsConditionConditionarg0argl0argr0outb0out0 CanCheckEmptyOnRangeAssertFailure orafUnderflow orafOverflowRangeFailureInfo rfiInclusive rfiBoundaryrfiValue NiceRangeRangeEI MkRangeEIRangeIE MkRangeIERangeEE MkRangeEERange MkRangeII RangeBoundary isInclusiveRangeBoundaryInclusionIncludeBoundaryExcludeBoundary rangeLower rangeUppermkRange fromRange_toRange_ rangeLower_ rangeUpper_ mkRangeFormkRange_ mkRangeFor_mkRangeForSafe_inRange inRangeCmpinRange_ inRangeCmp_assertInRange_assertInRangeSimple_mkOnRangeAssertFailureSimplecustomErrorORAFcustomErrorORAFSimple isRangeEmpty isRangeEmpty_assertRangeNonEmpty_+$fDefaultToInclusiveRangeBoundaryInclusiona9$fDefaultToInclusiveRangeBoundaryInclusionExcludeBoundary9$fDefaultToInclusiveRangeBoundaryInclusionIncludeBoundary$fRangeBoundaryExcludeBoundary$fRangeBoundaryIncludeBoundary$fBuildableRange'$fTypeHasDocRange'$fHasAnnotationRange'1$fNiceRangeRangeEEExcludeBoundaryExcludeBoundarya1$fNiceRangeRangeEIExcludeBoundaryIncludeBoundarya1$fNiceRangeRangeIEIncludeBoundaryExcludeBoundarya/$fNiceRangeRangeIncludeBoundaryIncludeBoundarya$fTypeHasDocRangeFailureInfo$fCanCheckEmptyRangeBoundaryInclusionRangeBoundaryInclusionExcludeBoundaryExcludeBoundary$fCanCheckEmptyRangeBoundaryInclusionRangeBoundaryInclusionExcludeBoundaryIncludeBoundary$fCanCheckEmptyRangeBoundaryInclusionRangeBoundaryInclusionIncludeBoundaryExcludeBoundary$fCanCheckEmptyRangeBoundaryInclusionRangeBoundaryInclusionIncludeBoundaryIncludeBoundary$fGenericRangeFailureInfo$fIsoValueRangeFailureInfo0$fTypeHasFieldNamingStrategyTYPERangeFailureInfo$fTypeHasDocRangeEI$fGenericRangeEI $fShowRangeEI$fBuildableRangeEI$fHasAnnotationRangeEI $fEqRangeEI$fIsoValueRangeEI$fTypeHasDocRangeIE$fGenericRangeIE $fShowRangeIE$fBuildableRangeIE$fHasAnnotationRangeIE $fEqRangeIE$fIsoValueRangeIE$fTypeHasDocRangeEE$fGenericRangeEE $fShowRangeEE$fBuildableRangeEE$fHasAnnotationRangeEE $fEqRangeEE$fIsoValueRangeEE$fTypeHasDocRange$fGenericRange $fShowRange$fBuildableRange$fHasAnnotationRange $fEqRange$fIsoValueRange$fGenericRange' $fShowRange' $fEqRange'$fIsoValueRange'NumericErrorWrapperNumericErrorDocHandlerNumericErrorDocHandlerErrorDDescribeErrorTagMap detmSrcLocapplyErrorTagToErrorsDocapplyErrorTagToErrorsDocWithcustomErrorDocHandlervoidResultDocHandlerbaseErrorDocHandlers$fDocItemDDescribeErrorTagMap$fErrorHasDocNumericTextError$fErrorHasNumericDocVoidResult$fErrorHasNumericDocCustomError $fErrorHasDocNumericErrorWrapper$fEqDDescribeErrorTagMap$fOrdDDescribeErrorTagMapLDefaultldeflIsDef $fLDefault(,)$fLDefaultNamedF $fLDefaultMap $fLDefaultSet $fLDefault[]$fLDefaultNatural$fLDefaultIntegerLIsoliToliFrom invertIso involutedIsocheckedCoerceIsoforcedCoerceIsonamedIsononIso nonDefIsoStorageContains::->~> FieldNickname FieldAliasSelfRef:-|StoreHasEntrypoint storeEpOpsStoreEntrypointOps sopToEpLambdasopSetEpLambda sopToEpStore sopSetEpStoreEntrypointsFieldEntrypointLambdaStoreHasSubmapstoreSubmapOpsStoreSubmapOpssopMemsopGet sopUpdatesopGetAndUpdate sopDelete sopInsert StoreHasField storeFieldOps StoreFieldOps sopToFieldsopGetFieldOpensopSetFieldOpenFieldRefHasFinalNameFieldRefFinalNamefieldRefFinalName FieldSymRef FieldNameFieldRef KnownFieldRefFieldRefObject mkFieldRef FieldRefTag FieldRefKindfieldNameToLabelfieldNameFromLabel sopGetField sopSetField stToField stGetFieldstToFieldNamedstGetFieldNamed stSetFieldstMemstGetstUpdatestGetAndUpdatestDeletestInsert stInsertNew stEntrypoint stToEpLambda stGetEpLambda stSetEpLambda stToEpStore stGetEpStore stSetEpStorestoreFieldOpsADTstoreEntrypointOpsADTstoreEntrypointOpsFieldsstoreEntrypointOpsSubmapFieldstoreFieldOpsDeeperstoreSubmapOpsDeeperstoreEntrypointOpsDeeperstoreSubmapOpsReferTostoreFieldOpsReferTostoreEntrypointOpsReferTomapStoreFieldOpsmapStoreSubmapOpsKeymapStoreSubmapOpsValuecomposeStoreFieldOpscomposeStoreSubmapOpssequenceStoreSubmapOpscomposeStoreEntrypointOpszoomStoreSubmapOps mkStoreEpthisstNestedstAlias stNickname$fKnownFieldRefSymbolname$fIsLabelnamex $fFieldRefHasFinalNameSymbolname$$fStoreHasFieldSymbolstorefnameftype#$fStoreHasSubmapFUNstore:-|keyvalue$fStoreHasFieldFUNstore:-|ty$fFieldRefHasFinalNameFUN:-|$fKnownFieldRefFUN:-|$fHasFieldSymbolfield:-|y"$fStoreHasSubmapFUNSetSelfRefkey()%$fStoreHasSubmapFUNMapSelfRefkeyvalue($fStoreHasSubmapFUNBigMapSelfRefkeyvalue#$fStoreHasFieldFUNstoreSelfRefstore$fKnownFieldRefFUNSelfRef'$fStoreHasSubmapSymbolstorenamekeyvalue$fHasFieldSymbolfieldSelfRefy$fStNestedImplkFUNacc$fStNestedImplkresacc$fKnownFieldRefFUNFieldAliasLorentzRational numerator denominatordeconstructRationalconstructRationalunsafePairToRationaluncheckedPairToRationalpairToRationaloppositeRationalreduce NRationalRational%! mkRational mkNRational%%! tripleMul gcdEuclideuclidExtendedNormalization mkRational_%$fCustomErrorHasDoc"zero_denominator"!$fArithOpHsDivNaturalIntegerMaybe!$fArithOpHsDivIntegerNaturalMaybe!$fArithOpHsDivIntegerIntegerMaybe$fArithOpHsMulRationalRationalr$fArithOpHsMulRationalNaturalr$fArithOpHsMulRationalIntegerr$fArithOpHsSubRationalRationalr$fArithOpHsSubNaturalRationalr$fArithOpHsSubRationalNaturalr$fArithOpHsSubIntegerRationalr$fArithOpHsSubRationalIntegerr$fArithOpHsAddRationalRationalr$fArithOpHsAddNaturalRationalr$fArithOpHsAddRationalNaturalr$fArithOpHsAddIntegerRationalr$fArithOpHsAddRationalIntegerr$fUnwrappableRational$fIsoValueRational$fHasAnnotationRational$fShowRational!$fArithOpHsDivNaturalNaturalMaybe $fArithOpHsMulNRationalRationalr $fArithOpHsMulRationalNRationalr $fArithOpHsSubNRationalRationalr $fArithOpHsSubRationalNRationalr $fArithOpHsAddNRationalRationalr $fArithOpHsAddRationalNRationalr!$fArithOpHsMulNRationalNRationalr$fArithOpHsMulNRationalNaturalr$fArithOpHsMulNRationalIntegerr!$fArithOpHsSubNRationalNRationalr$fArithOpHsSubNaturalNRationalr$fArithOpHsSubNRationalNaturalr$fArithOpHsSubIntegerNRationalr$fArithOpHsSubNRationalIntegerr!$fArithOpHsAddNRationalNRationalr$fArithOpHsAddNaturalNRationalr$fArithOpHsAddNRationalNaturalr$fArithOpHsAddIntegerNRationalr$fArithOpHsAddNRationalIntegerr$fUnwrappableNRational$fIsoValueNRational$fHasAnnotationNRational$fShowNRational$fLorentzRoundingra $fArithOpHsDivNRationalRationalr $fArithOpHsDivRationalNRationalr!$fArithOpHsDivNRationalNRationalr$fArithOpHsDivNRationalNaturalr$fArithOpHsDivNRationalIntegerr$fArithOpHsDivNaturalNRationalr$fArithOpHsDivIntegerNRationalr$fArithOpHsMulNaturalNRationalr$fArithOpHsMulIntegerNRationalr$fArithOpHsDivRationalRationalr$fArithOpHsDivRationalNaturalr$fArithOpHsDivRationalIntegerr$fArithOpHsDivNaturalRationalr$fArithOpHsDivIntegerRationalr$fArithOpHsMulNaturalRationalr$fArithOpHsMulIntegerRationalr$fLorentzRationalNRational$fLorentzRationalRational $fEqNRational $fEqRationalNFixedMkNFixedLorentzFixedBasegetBaseDecBaseBinBaseLorentzFixedBaseKind resolution_ fromFixedtoFixedcastNFixedToFixedcastFixedToNFixedunsafeCastFixedToNFixed$fUnaryArithOpHsNegFixed$fArithOpHsMulNaturalFixedr$fArithOpHsMulIntegerFixedr$fArithOpHsMulFixedNaturalr$fArithOpHsMulFixedIntegerr$fArithOpHsMulFixedFixedr$fArithOpHsSubNaturalFixedr$fArithOpHsSubIntegerFixedr$fArithOpHsSubFixedNaturalr$fArithOpHsSubFixedIntegerr$fArithOpHsSubFixedFixedr$fArithOpHsAddNaturalFixedr$fArithOpHsAddIntegerFixedr$fArithOpHsAddFixedNaturalr$fArithOpHsAddFixedIntegerr$fArithOpHsAddFixedFixedr$fHasResolutionFUNBinBase$fHasResolutionFUNDecBase$fLorentzFixedBaseBinBase$fLorentzFixedBaseDecBase$fArithOpHsEDivNFixedNaturalr$fArithOpHsEDivNFixedIntegerr$fArithOpHsEDivFixedNaturalr$fArithOpHsEDivFixedIntegerr$fToIntegerArithOpHsNFixed$fUnaryArithOpHsNegNFixed$fArithOpHsLsrNFixedNaturalr$fArithOpHsLslNFixedNaturalr$fArithOpHsMulNFixedFixedr$fArithOpHsMulFixedNFixedr$fArithOpHsMulNaturalNFixedr$fArithOpHsMulIntegerNFixedr$fArithOpHsMulNFixedNaturalr$fArithOpHsMulNFixedIntegerr$fArithOpHsMulNFixedNFixedr$fArithOpHsSubNFixedFixedr$fArithOpHsSubFixedNFixedr$fArithOpHsSubNaturalNFixedr$fArithOpHsSubIntegerNFixedr$fArithOpHsSubNFixedNaturalr$fArithOpHsSubNFixedIntegerr$fArithOpHsSubNFixedNFixedr$fArithOpHsAddNFixedFixedr$fArithOpHsAddFixedNFixedr$fArithOpHsAddNaturalNFixedr$fArithOpHsAddIntegerNFixedr$fArithOpHsAddNFixedNaturalr$fArithOpHsAddNFixedIntegerr$fArithOpHsAddNFixedNFixedr$fUnwrappableNFixed$fIsoValueNFixed $fRealNFixed$fFractionalNFixed $fNumNFixed $fShowNFixed$fArithOpHsDivIntegerNFixedr$fArithOpHsDivNaturalNFixedr$fArithOpHsDivNaturalFixedr$fArithOpHsDivIntegerFixedr$fArithOpHsDivNFixedNFixedr$fArithOpHsDivFixedFixedr"$fArithOpHsDivNaturalNaturalMaybe0$fLorentzRoundingNFixedNFixed$fLorentzRoundingFixedFixed $fEqNFixed $fOrdNFixedconvertFixedToRationalconvertNFixedToRationalconvertRationalToFixedunsafeConvertRationalToNFixedconvertRationalToNFixedconvertNRationalToFixedconvertNRationalToNFixedconvertNFixedToNRationalconvertFixedToNRationalunsafeConvertFixedToNRationalExprtake unaryExpr$: binaryExpr|+||-||*||==||/=||<||>||<=||>=||&|||||.|.||^||<<||>>||:||@||%!|pairElistEtransferTokensEcreateContractEviewE"$fIsCondition:->argarglargroutboutSTicketverifyTicketGeneric'verifyTicketGenericverifyTicketerverifyTargetContractAndverifyTargetContractauthorizeAction toSTicket readSTicket sTicketAmountsubtractSTicketsubtractSTicketPlain addSTicketaddSTicketPlain,$fCustomErrorHasDoc"nOT_SINGLE_TICKET_TOKEN"&$fCustomErrorHasDoc"nOT_TICKET_TARGET"#$fCustomErrorHasDoc"wRONG_TICKETER"$fTypeHasDocSTicket$fNonZeroSTicket!$fCanCastToTYPETYPESTicketSTicket$fGenericSTicket$fUnwrappableSTicket$fHasAnnotationSTicket$fIsoValueSTicketderiveSemiDupableGenericRequireFlatEpDerivationRequireFlatParamEps EntryArrow#->DocumentEntrypointsDeriveCtorFieldDocderiveCtorFieldDocDEntrypointArgepaArg epaBuildingSomeEntrypointArgParamBuildingStep PbsWrapInPbsCallEntrypoint PbsCustom PbsUncallableParamBuildingDesc pbdEnglish pbdHaskell pbdMichelson ParamBuilderunParamBuilderDEntrypointReferenceCommonEntrypointsBehaviourKindCommonContractBehaviourKindFlattenedEntrypointsKindFlattenedEntrypointsKindHidingPlainEntrypointsKindEntrypointKindHasDocEntrypointKindOverrideentrypointKindOverrideSpecifiedentrypointKindPosentrypointKindSectionName entrypointKindSectionDescription DEntrypointdepNamedepSubDEntrypointDocItemdiEntrypointToMarkdownentrypointSection mkPbsWrapIn emptyDEpArg mkDEpUTypemkDEntrypointArgSimpleclarifyParamBuildingSteps entryCase_ entryCasedocumentEntrypointfinalizeParamCallingDoc'finalizeParamCallingDocareFinalizedParamBuildingStepsentryCaseSimple_entryCaseSimpleentryCaseFlattened_entryCaseFlattenedentryCaseFlattenedHiding_entryCaseFlattenedHiding$fDocItemDEntrypoint*$fEntrypointKindHasDocPlainEntrypointsKind4$fEntrypointKindHasDocFlattenedEntrypointsKindHiding1$fEntrypointKindHasDocCommonContractBehaviourKind4$fEntrypointKindHasDocCommonEntrypointsBehaviourKind$fDocItemDEntrypointReference$fBuildableParamBuilder$fBuildableParamBuildingStep$fDocItemDEntrypointArg$fDeriveCtorFieldDocconOneField$fDeriveCtorFieldDocconNoFields=$fGDocumentEntrypointseptFlattenedEntrypointsKindHidingM1rest$fGDocumentEntrypointsEPNodeFlattenedEntrypointsKindHidingM1rest#$fGDocumentEntrypointseptkindM1rest'$fGDocumentEntrypointsEPNodekind:+:rest$$fGDocumentEntrypointseptkindM1rest0$fEntryArrowTYPEkindnamebodyUParamLinearizedUParamLinearize CaseUParamUParamFallbackEntrypointsImplEntrypointLookupErrorNoSuchEntrypoint UnpackUParam unpackUParamConstrainedSomeRequireUniqueEntrypointsLookupEntrypointUParam_ SomeInterfaceUParam UnsafeUParam?:EntrypointKindmkUParam unwrapUParamuparamFallbackFail caseUParam caseUParamT uparamFromAdt pbsUParam/$fCustomErrorHasDoc"uparamArgumentUnpackFailed"+$fCustomErrorHasDoc"uparamNoSuchEntrypoint"$fBuildableCustomError0$fTypeHasDocUParam$fHasRPCReprUParam$fCanCastToTYPETYPEUParamUParam$fBuildableConstrainedSome$fCaseArrowname'bodyCaseClauseU $fBuildableEntrypointLookupError$fUnpackUParamc:$fUnpackUParamc[] $fCaseUParam:$fCaseUParam[]$fGUParamLinearizeM1$fGUParamLinearizeM10$fGUParamLinearizeM11$fGUParamLinearize:+:$fGUParamLinearizeM12$fGenericEntrypointLookupError$fEqEntrypointLookupError$fShowEntrypointLookupError$fGenericUParam $fEqUParam $fShowUParam$fIsoValueUParam$fHasAnnotationUParam$fUnwrappableUParam$fShowConstrainedSome ContractView ContractDatacdCodecdViewscdCompilationOptionsCompilationOptionscoOptimizerConfcoStringTransformercoBytesTransformerdefaultCompilationOptionsintactCompilationOptionscompileLorentzcompileLorentzWithOptionsdefaultContract mkContractmkContractWithmkViewdefaultContractDatacompileLorentzContractsetViews setViewsRecnoViewsinterpretLorentzInstrinterpretLorentzLambdaanalyzeLorentz#$fContainsUpdateableDocContractData$fContainsDocContractDatacoBytesTransformerLcoOptimizerConfLcoStringTransformerLcdCodeLcdCompilationOptionsL-$?-$&?-&-<-$>printLorentzValueprintLorentzContract CmdLnArgsPrintDocumentAnalyze PrintStorageContractRegistryunContractRegistry ContractInfo ciContractciIsDocumentedciStorageParserciStorageNotesprintContractFromRegistryDoc argParserrunContractRegistry$fBuildableContractRegistry GIsSumTypeNamedEpMorley.Michelson.Typed.ArithOrDemoteViewTyInfoParseLorentzError+LorentzCodeIsNotIsomorphicToMichelsonValuesNoLambdaCodeIsomorphismErrorMorley.Michelson.PreprocesstransformStringstransformBytes GHC.TypeError TypeError Fmt.Buildable Buildable"Morley.Michelson.Typed.PolymorphicSliceOpConcatOpGetOpUpdOpSizeOpMorley.Michelson.Typed.TTIterOpMapOpMemOpKeyGEntrypointsNotesEntrypointsNotesgMkEntrypointsNotesAllEntrypointsNotesTOrmkEntrypointsNotesmkEpLiftSequence mkEpDescsRenderViewsImplHashAlgorithmKind SecretKeyMorley.Micheline.Expression Expression UnaryArithOpArithOpCONTRACTSELFTheOnlyC EnsureElemMorley.Util.TypeIsElemCustomErrorArgReppickFirstSentenceerrorsDocumentationidFAILWITH DocumentCtorGExtVal GGetCtorsEnumerateCtorsCtorKindCtor LookupCtorWrapExt packForWrap(Morley.Michelson.Typed.Haskell.Instr.Sum CaseClauseType instrGetField varPosition VarNamePrettyVarNameVarNamedEDivUpdateNConstraint'ReplaceNConstraint' MapInstrs mapUpdate checkEmpty checkEmpty_Range'DefaultToInclusive rangeParens inRangeComp inRangeComp_ rangeNameOrderingEQLTmkRangeFailureInfoErrorHasNumericDocnumericErrorDocHaskellRepNumericTextErrorEheNotApplicableEheConversionUnnecessarydDescribeErrorTagMapAnchortextErrorDocHandlerpushStEpsomeStEpsetStEpreduceRationalHelpersTicketAmountPlainsemiDupableGenericStrategymakeSplittedDepthsGDocumentEntrypointsgDocumentEntrypointsdocumentEntrypoints CtorFieldpbSamplemodifyParamBuildingStepsmdAddIdGUParamLinearizeunsafeCaseUParam CaseClauseUcompileLorentzViewscompileLorentzViewversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDirgetDataFileName getSysconfDir