h&`!P      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  !!!!!"""""% Safe-Inferred9!#$%&'(),-./045789:;<>?,,#$ %w&' ()*+,qrstuv-./01234" !56789:;<[`=>?Z@\ABCDEFGH]^IecdJ_KLMNOPQRSTabUVWXYfghijklmnopxyz{|}~  #$ %w&' ()*+,qrstuv-./01234" !56789:;<[`=>?Z@\ABCDEFGH]^IecdJ_KLMNOPQRSTabUVWXYfghijklmnopxyz{|}~   Safe-Inferred9!#$%&'(),-./045789:;<>?7 indigo1Generates an Buildable instance for a Expr GADT. Note: This will not generate additional constraints to the generated instance if those are required. Inspired by deriveGADTNFData from Util.TH.   Safe-Inferred9!#$%&'(),-./045789:;<>?9 indigoReplicate the old behavior of (#), which ignores anything after failing instructions. Indigo relies on this. TODO #62: reconsider this.0<[`FGH]^fop  0<[`FGH]^fop   8 Safe-Inferred9!#$%&'(),-./045789:;<>?J indigo%Allows to get a variable with storage indigo(Allows to get a variable with operations indigo0A variable referring to an element in the stack. indigo"Stack of the symbolic interpreter. indigo*Stack element of the symbolic interpreter.It holds either a reference index that refers to this element or just  ;, indicating that there are no references to this element. indigoReference id to a stack cell indigoGiven a   and a Peano& singleton for a depth, it puts a new  < at that depth (0-indexed) and returns it with the updated  .If there is a  " there already it is used and the   not changed. indigoPush a new stack element with a reference to it, given the variable. indigo3Push a new stack element without a reference to it. indigoRemove the top element of the stack. It's supposed that no variable refers to this element. indigo>Return a variable which refers to a stack cell with operations indigo;Return a variable which refers to a stack cell with storage   Safe-Inferred:!#$%&'(),-./045789:;<>?Qwindigo.Decide whether type is either primitive or ADTindigo5Type class instantiated for all possible Indigo typesindigoSimply a synonym for a quantified constraint, because we can't use a quantified constraint in a synonym tuple.indigoWe need this because  is a constraint synonym, and parts of it aren't exported from morley. Hence can't declare a quantified constraint over it. And we really don't want to carry input stack everywhere explicitly, hence why we want a quantified constraint.indigo,Simply a synonym for an unwieldy constraint. indigoLike  +, but this one doesn't keep name of a field indigoAuxiliary datatype to define a Objiable. Keeps field name as type paramindigoAuxiliary type family to convert list of field names to list of field types indigoA object that can be either stored in the single stack cell or split into fields. Fields are identified by their names.f3 is a functor to be applied to each of field names. indigoValue stored on the stack, it might be either complex product type, like (a, b)", Storage, etc, or sum type like T, or primitive like A,  , etc. indigoDecomposed product type, which is NOT stored as one cell on the stack. indigo?Convert a list of fields from name-based list to type-based one indigoConvert a list of fields from type-based list to named-based one indigoProduce evidence of < for a concrete input stack, and run a computation with it.   Safe-Inferred:!#$%&'(),-./0145789:;<>?W indigoResulting state of IndigoM. indigo"Stack of the symbolic interpreter. indigoGenerated Lorentz code. indigoClearing Lorentz code. indigoIndigoState data type.It takes as input a  ( (for the initial state) and returns a  : (for the resulting state and the generated Lorentz code).IndigoState has to be used to write backend typed Lorentz code from the corresponding frontend constructions.It has no return type, IndigoState instruction may take one or more "return variables", that they assign to values produced during their execution. indigo Inverse of   for utility. indigoThen for rebindable syntax. indigoPut new  . indigo The simplest  7, it does not modify the stack, nor the produced code. indigoAssigns a variable to reference the element on top of the stack. indigoUtility function to create  ! that need access to the current  . indigo  version for  indigo  version for  indigo  version for  indigoProduces the generated Lorentz code that cleans after itself, leaving the same stack as the input one indigo Version of  / which performs some optimizations immediately.#In particular, this avoids glueing Nops.* *   Safe-Inferred9!#$%&'(),-./045789:;<>?\q indigoSimple datatype used to keep a  and its  constraintindigoStack representation of  used for constraint checkingindigo-Keeps the 0-indexed depth of a variable as a  leton indigo'Puts a copy of the value for the given   on top of the stack indigoSets the value for the given  " to the topmost value on the stack indigo Updates the value for the given   with the topmost value on the stack using the given binary instruction. indigoGiven a stack with a list of  .s on its bottom, updates it by appending the   on the top.indigoLike   , but requires the depth of the   in the input stackindigoLike   , but requires the depth of the   in the input stackindigoLike   , but requires the depth of the   in the input stackindigoCalculates the  of the given   in the stack   Safe-Inferred9!#$%&'(),-./045789:;<>?]#$ %&' ()*+,qsr-./01234" !56789:;<[`=>?Z@\ABCDEFGH]^IecdJ_KLMNOPQRSTabUVWXYfghijklmnopxyz{|}~  #$ %&' ()*+,qsr-./01234" !56789:;<[`=>?Z@\ABCDEFGH]^IecdJ_KLMNOPQRSTabUVWXYfghijklmnopxyz{|}~   Safe-Inferred9!#$%&'(),-./045789:;<>?i indigo  with hidden output stack, necessary to generate typed Lorentz code from untyped Indigo frontend. indigo  with hidden output stack indigoTo run   you need to pass an handler of  $ with any output stack and initial  . indigoConvert   to  indigo Similar to a >> for  . indigo Modify the   inside a   by passing an handler of   that returns a  8. Useful in some cases to "wrap" or update and exising  .  Safe-Inferred9!#$%&'(),-./045789:;<>?m indigo Class like * type class but holding a lens to a field. indigoLens to a field.  obj.f1.f2.f3! is represented as list names of  [f1, f2, f3].dt< is a type of source object (type of obj in example above) fname is a name of target field ("f3" in example above) ftype is a type of target fieldHowever, a lens contains not only name of field but for each field it contains operations to get and set target field. indigo/Constraint to access/assign field stored in Rec indigoGet a field from list of fields indigoAssign a field to a value indigo Access to  indigo,Build a lens to a direct field of an object. indigo*Build a lens to deeper field of an object. indigoDefault instance for datatype and its direct field name. It will be useful unless you want to refer to a field using a custom name.  Safe-Inferred9!#$%&'(),-./045789:;<>?oi indigo?Datatype describing access to an inner fields of object, like object !. field1 !. field2 ~. (field3, value3) ~. (field4, value4) indigoAuxiliary datatype where each field refers to an expression the field equals to. It's not recursive one.  Safe-Inferred9!#$%&'(),-./045789:;<>?uindigo?}Hindigo( represents a postponed compilation of   datatype. When   is being compiled we are trying to put off the generation of code for work with an object because we can just go to a deeper field without its "materialization" onto stack.indigoCompile  ; datatype to a cell on the stack. This function leverages % to put off actual field compilation.indigoConvert arbitrary   into  - with respect to given converter for fields.indigoCompile   to a stack cell, with respect to given function that compiles inner fields.indigoThis function might look cumbersome but basically it either goes deeper to an inner field or generates Lorentz code.indigoConvert an expression to . The function pattern matches on some specific cases of expression those compilation into a stack cell may be postponed. They include   variables and   expressions."This function can't be called for  3 constructor, but we take care of it just in case. Safe-Inferred9!#$%&'(),-./045789:;<>?mindigoType class which unions all related management of computations in a scope, like in if branch, in case body, etc.Particularly, it takes care of the computation of expressions returning from a scope to leave it safely. Basically, this type class encapsulates the generation of Lorentz code that looks like:  branch_code # -- we get some arbitrary type of a stack here, lets call it xs compute_returning_expressions # -- we get type of stack [e1, e2, ... ek] ++ xs cleanup_xs_to_inp -- we get [e1, e2, e3, ..., ek] ++ inp indigoProduces an Indigo computation that puts on the stack the evaluated returned expressions from the leaving scope.indigoDrop the stack cells that were produced in the leaving scope, apart from ones corresponding to the returning expressions.indigo Generate   for the whole statementindigoClass for values that can be returned from Indigo statements. They include () and tuples.indigoType family reflecting the top elements of stack produced by a statement returning the value.indigo?indigo'Datatype representing decomposition of  .indigoAlike  & datatype but without objects argumentindigoFor given element on stack, generate code which decomposes it to list of its deep non-decomposable fields. Clean up code of   composes the value back.indigoDecompose (shallowly) an expression to list of its direct fields.indigoDecompose any  & with regards to decomposer for field.indigoDeconstruct top element of the stack and return it wrapped into  constructor.indigo7Push the passed stack cells without references to them.   Safe-Inferred9!#$%&'(),-./045789:;<>?;indigoAssign the given variable to the value resulting from the given expression.indigo Set the variable to a new value.If a variable is a cell on the stack, we just compile passed expression and replace variable cell on stack. If a variable is decomposed, we decompose passed expression and call  recursively from its fields.Pay attention that this function takes a next RefId but it doesn't return RefId because all allocated variables will be destroyed during execution of the function, so allocated ones won't affect next allocated ones.indigo7Set the field (direct or indirect) of a complex object.indigoCall binary operator with constant argument to update a variable in-place. Safe-Inferred9!#$%&'(),-./045789:;<>? indigo=Describes kind of lambda: pure, modifying storage, effectfullindigoProvide common constraints that are presented in all constructors of indigo Execute lambda depending on its indigo'Create initial stack vars depending on indigoCreate a lambda, that takes only one argument, from the given computation, and return a variable referring to this lambda.indigoExecute a lambda, which accepts only one argument, on passed expression.indigoExecute a lambda that accepts only one argument on the given expression.indigoExecute a lambda that accepts only one argument on the given expression. Also updates the storage and operations with the values returned from the lambda.indigoExecute a lambda that accepts only one argument on the given expression. Also updates the storage and operations with the values returned from the lambda.indigoKind of lambdaindigoNext free variable referenceindigo5Variable that will be assigned to the resulting valueindigo;Variable(s) that will be assigned to the resulting value(s)indigo;Variable(s) that will be assigned to the resulting value(s)indigo;Variable(s) that will be assigned to the resulting value(s) Safe-Inferred9!#$%&'(),-./045789:;<>?indigoGeneric generator of failing  # from failing Lorentz instructions. Safe-Inferred9!#$%&'(),-./045789:;<>?indigoIf statement. All variables created inside its branches will be released after the execution leaves the scope in which they were created.indigo,If-statement that works like case for Maybe.indigo$If which works like case for Either.indigo%If which works like uncons for lists.indigoExpression for the control flowindigo"Code block for the positive branchindigo&Return value(s) of the positive branchindigo"Code block for the negative branchindigo&Return value(s) of the negative branchindigo;Variable(s) that will be assigned to the resulting value(s)indigoExpression for the control flowindigoVariable for the ^) value (available to the next code block)indigoCode block for the ^ branchindigoReturn value(s) of the ^ branchindigoCode block for the ] branchindigoReturn value(s) of the ] branchindigo;Variable(s) that will be assigned to the resulting value(s)indigoExpression for the control flowindigoVariable for the b) value (available to the next code block)indigoCode block for the b branchindigoReturn value(s) of the b branchindigoVariable for the a) value (available to the next code block)indigoCode block for the a branchindigoReturn value(s) of the a branchindigo;Variable(s) that will be assigned to the resulting value(s)indigoExpression for the control flowindigoVariable for the "head" value (available to the next code block)indigoVariable for the "tail" value (available to the next code block)indigo(Code block for the non-empty list branchindigo,Return value(s) of the non-empty list branchindigo$Code block for the empty list branchindigo(Return value(s) of the empty list branchindigo;Variable(s) that will be assigned to the resulting value(s) Safe-Inferred9!#$%&'(),-./045789:;<>?>indigo)This constraint is shared by all backend case* functions.indigo!This constraint is shared by all case*0 functions. Including some outside this module.indigoThis type is analogous to the  type but instead of wrapping a Lorentz instruction, this wraps an Indigo value with the same input/output types.indigo=A case statement for indigo. See examples for a sample usage.indigocase_# for pattern-matching on parameter.indigo entryCase_# for contracts with flat parameter.indigoVariable for the clause input value (available to its code block)indigoClause code blockindigoClause return value(s)indigo;Variable(s) that will be assigned to the resulting value(s)indigo;Variable(s) that will be assigned to the resulting value(s)indigo;Variable(s) that will be assigned to the resulting value(s) Safe-Inferred9!#$%&'(),-./045789:;<>?>indigo#StatementF functor for Freer monad.The constructors correspond to every Indigo statement that has expressions (  x) in its signature.>The ones that don't take expressions are compiled directly to  IndigoState (and kept in ), because they won't be taken into consideration by an optimizer anyway.One more detail about  is that it takes a cont% type parameter, which is basically IndigoM/ (freer monad), to avoid cyclic dependencies. cont is needed to support statements which have recursive structure (like: if, while, case, etc).indigoDirect injection of IndigoState of statements which are not going to be analyzed by optimizer.indigo Constructor wrapper which holds IndigoM3 function among with the callstack of caller side.#The another option could be to add  to Instr constructor of Program" but this would have held only a Y) of separate primitive statement (unlike updateStorageField, etc). The idea is to be able to have correspondence between original Indigo code and the generated Michelson assembler and vice versa to perform quick navigation and analyze, so it's better to have call stack for non-primitive frontend statements.indigoAnalogous datatype as IndigoCaseClauseL from Indigo.Backend.Case'' Safe-Inferred9!#$%&'(),-./045789:;<>?indigo8Type of a contract that can be compiled to Lorentz with compileIndigoContract.indigo$Monad for writing your contracts in.indigo7This is freer monad (in other words operational monad).It preserves the structure of the computation performed over it, including return and bind operations. This was introduced to be able to iterate over Indigo code and optimize/analyze it.You can read a clearer description of this construction in "The Book of Monads" by Alejandro Serrano. There is a chapter about free monads, specifically about Freer you can read at page 259. There is "operational" package which contains transformer of this monad and auxiliary functions but it's not used because we are using only some basics of it.indigo.Traverse over Freer structure and interpret it   Safe-Inferred9!#$%&'(),-./045789:;<>?indigo=Typeable and stack size constraints for the parameters of an .indigo equivalent of indigo=Typeable and stack size constraints for the parameters of an  and for converting to a indigoType of a function with n   arguments and  IndigoM a result.&Note that the arguments are the first n elements of the inp( stack in inverse order, for example: IndigoWithParams 2 [a, b, c] x is the same as: Var b -> Var a -> IndigoM xindigo Converts an  to its form without input  s, alongside the  6 to use it with and the first available (unassingned)  .indigo version of indigo Converts an  to the equivalent 8 with the storage, parameter and ops list as arguments. Safe-Inferred9!#$%&'(),-./045789:;<>? indigoWhile statement.indigoWhile-left statement. Repeats a block of code as long as the control T is a, returns when it is b.indigo+For statements to iterate over a container.indigoPut a document item.indigoGroup documentation built in the given piece of code into a block dedicated to one thing, e.g. to one entrypoint.indigoInsert documentation of the contract storage type. The type should be passed using type applications.indigoGive a name to the given contract. Apply it to the whole contract code.indigo*Attach general info to the given contract.indigo:Attach default general info to the contract documentation.indigo>Indigo version for the function of the same name from Lorentz.indigoTakes an arbitrary IndigoM and wraps it into an IndigoFunction producing a local scope for its execution. Once it executed, all non-returned variables are cleaned up so that the stack has only returned variables at the top. This also can be interpreted as if True then f else nop.Note, that by default we do not define scope inside indigo functions, meaning that once we want to create a new variable or return it from a function we need to do it inside  scope $ instr construction, for example: f :: IndigoFunction s Natural f = scope $ do *[s]* res <- newVar (0 :: Natural) *[Natural, s]* scope $ do _n <- newVar (1 :: Integer) *[Integer, Natural, s] res += 4 *[Natural, s]* return res *[s]* indigo Add a commentindigoExpression for the control flowindigo:Block of code to execute, as long as the expression holds `indigo%Expression for the control flow valueindigoVariable for the a$ value (available to the code block)indigo)Code block to execute while the value is aindigo5Variable that will be assigned to the resulting valueindigo(Expression for the container to traverseindigo;Variable for the current item (available to the code block)indigo8Code block to execute over each element of the containerindigo0Variable that will be assigned to the resulting  indigo0Variable that will be assigned to the resulting  indigo0Variable that will be assigned to the resulting indigo&Code block to execute inside the scopeindigo(Return value(s) of the scoped code blockindigo;Variable(s) that will be assigned to the resulting value(s)  Safe-Inferred9!#$%&'(),-./045789:;<>?дindigo2Representation of a branch of a generic case-like .indigoAnalogous datatype as  and IndigoMCaseClauseL.indigo Common constraint for case-like s.indigo%Data type internally used to collect s from IndigoMindigo&Data type representing an instruction.Differently from the frontend this is not used to build a Monad of some kind, it is instead based on having as argument the variable to associate with the resulting value (if any).(This is combined in simple lists, named , and it is intended to be easily altered, this is because these are used as the intermediate representation between the frontend and the backend, where optimizations can occur.indigoSimple synonym for a list of indigo6Input variable (accessible to the branch's code block)indigoCode block for this branchindigoReturn value of this branchindigoKind of lambda (pure, storage modification, fully functional lambda with effects)indigoName of the lambdaindigo"Expression for the lambda argumentindigoVariable for the argument value (available to the lambda code block)indigoCode block for the lambdaindigoReturn value(s) of the lambdaindigo;Variable(s) that will be assigned to the resulting value(s)indigoInitial   to be used in the lambda codeindigoVariable for the argument value (available to the lambda code block)indigoCode block for the lambdaindigoReturn value(s) of the lambdaindigo6Variable that will be assigned to the resulting lambdaindigo"Expression for the lambda argumentindigo%Variable of the lambda to be executedindigo;Variable(s) that will be assigned to the resulting value(s)indigo&Code block to execute inside the scopeindigo(Return value(s) of the scoped code blockindigo8Variable that will be assigned to the resulting value(s)indigoExpression for the control flowindigo"Code block for the positive branchindigo&Return value(s) of the positive branchindigo"Code block for the negative branchindigo&Return value(s) of the negative branchindigo;Variable(s) that will be assigned to the resulting value(s)indigoExpression for the control flowindigoVariable for the ^) value (available to the next code block)indigoCode block for the ^ branchindigoReturn value(s) of the ^ branchindigoCode block for the ] branchindigoReturn value(s) of the ] branchindigo;Variable(s) that will be assigned to the resulting value(s)indigoExpression for the control flowindigoVariable for the b) value (available to the next code block)indigoCode block for the b branchindigoReturn value(s) of the b branchindigoVariable for the a) value (available to the next code block)indigoCode block for the a branchindigoReturn value(s) of the a branchindigo;Variable(s) that will be assigned to the resulting value(s)indigoExpression for the control flowindigoVariable for the "head" value (available to the next code block)indigoVariable for the "tail" value (available to the next code block)indigo(Code block for the non-empty list branchindigo,Return value(s) of the non-empty list branchindigo$Code block for the empty list branchindigo(Return value(s) of the empty list branchindigo;Variable(s) that will be assigned to the resulting value(s)indigo;Variable(s) that will be assigned to the resulting value(s)indigo;Variable(s) that will be assigned to the resulting value(s)indigo;Variable(s) that will be assigned to the resulting value(s)indigoExpression for the control flowindigo:Block of code to execute, as long as the expression holds `indigo%Expression for the control flow valueindigoVariable for the a$ value (available to the code block)indigo)Code block to execute while the value is aindigo5Variable that will be assigned to the resulting valueindigo(Expression for the container to traverseindigo;Variable for the current item (available to the code block)indigo8Code block to execute over each element of the containerindigo0Variable that will be assigned to the resulting indigo0Variable that will be assigned to the resulting  indigo0Variable that will be assigned to the resulting  // Safe-Inferred9!#$%&'(),-./045789:;<>?~indigoTransformation from  to a  of s.Requires the first non-used   and returns the next one.indigo'Collects instructions starting from an . Returns an & as well as the return value for that .indigo$Collects instructions starting from . IMPORTANT: the instructions are collected in the opposite order (as a stack).indigoContinues collecting s from an inner > (e.g. scoped). This keeps advancing the ref counter as well.indigoJust a common set of steps used by collection of single-arg lambda's values.indigo Append a new & to the head of the list in the state.indigoCreates a new var. This simply advances the ref counter and updates it.indigoTranslation from a  and an initial   to Lorentz.indigoTranslation from a  to a  .indigoTranslation from a single  to a  .indigoConvert clauses from their "sequential" representation to the "backend" one.indigo7Allocate vars for the return value(s) of a clause-like .indigo*Collects clauses of a case-like statement.indigoApplies the given  to > transformation to the inner code block of every case clause.indigoApplies the given monadic function giving it the inner code block of each case clause, in order.33 Safe-Inferred8!#$%&'(),./045789:;<>?]indigo!Basically copy-pasted version of  with fixed .indigoConvert from enum-based verbosity description to specific actions. Safe-Inferred9!#$%&'(),-./045789:;<>? Safe-Inferred9!#$%&'(),-./045789:;<>?ޥindigoContains all the data necessary for the generation of a single-argument lambda. Is compared only on the base of it's .indigoCollects named lambdas that are used more than once and separates them into a lambda creation and multiple lambda executions. Leaves the remaining lambdas untouched, to be compiled inline.indigoCollect all used lambdas in a computation that are called at least twice. Only the outer lambdas will be gathered, for example, if we call lambda "func1" from "func0", only "func0" will be considered.indigoAssociates each given  to a new  >, starting from the given one. Also returns the first unused  indigo Generates an  for each given tuple, to generate a lambda (assigned to the respective variable) and leave it on the stack.indigo Updates a , it looks for lambda Calls: (defined and used in place) to replace them with lambda Exec, provided there is a known variable for an already created lambda. Safe-Inferred9!#$%&'(),-./045789:;<>?;indigoCompile Indigo code to Lorentz.Note: it is necessary to specify the number of parameters (using the first type variable) of the Indigo function. Also, these should be on the top of the input stack in inverse order (see ).indigoSpecialization of  without var decompositions.indigoSimplified version of indigoCompile Indigo code to Lorentz contract. Drop elements from the stack to return only  [Operation] and storage.indigoSimplified version of  Safe-Inferred9!#$%&'(),-./045789:;<>?U*indigoUtility type for an  that does not modify the stack (only the values in it) and returns nothing.indigoUtility type for an  that adds one element to the stack and returns a variable pointing at it.indigoCreate a new variable with the result of the given expression as its initial value.indigo=Set the given variable to the result of the given expression.indigo$Sets a storage field to a new value.indigo-Updates a storage field by using an updating .indigo1Get a field from the storage, returns a variable.?Note that the storage type almost always needs to be specified.indigoRun the instruction when the condition is met, do nothing otherwise.indigo Reverse of .indigo6Run the instruction when the given expression returns ^ a value, do nothing otherwise.indigo6Run the instruction when the given expression returns ], do nothing otherwise.indigo=A case statement for indigo. See examples for a sample usage.indigo for tuples.indigo# for pattern-matching on parameter.indigo for tuples.indigo An alias for & kept only for backward compatibility.indigoUse this instead of .This operator is like  but wraps a body into  IndigoAnyOut, which is needed for two reasons: to allow having any output stack and to allow returning not exactly the same values.It has the added benefit of not being an arrow, so in case the body of the clause is a lambda there won't be several.indigo Alias for  we use in the tutorial.indigoA more specific version of  meant to more easily create s.Used in the tutorial. The   constraint is specified to avoid the warning for redundant constraints.indigo Family of defNamed*LambdaN functions put an Indigo computation on the stack to later call it avoiding code duplication. defNamed*LambdaN takes a computation with N arguments. This family of functions add some overhead to contract byte size for every call of the function, therefore, DON'T use defNamed*LambdaN if: * Your computation is pretty small. It would be cheaper just to inline it, so use . * Your computation is called only once, in this case also use .Also, pay attention that defNamed*LambdaN accepts a string that is a name of the passed computation. Be careful and make sure that all declared computations have different names. Later the name will be removed.Pay attention, that lambda argument will be evaluated to variable before lambda calling.TODO Approach with lambda names has critical pitfall: in case if a function takes  Label name, lambda body won't be regenerated for every different label. So be carefully, this will be fixed in a following issue.indigo6Like defNamedEffLambda1 but doesn't make side effects.indigo2Like defNamedLambda1 but doesn't take an argument.indigoLike defNamedEffLambda1 but doesn't modify storage and doesn't make side effects.indigoWhile statement.indigo+For statements to iterate over a container.indigoPut a document item.indigoGroup documentation built in the given piece of code into a block dedicated to one thing, e.g. to one entrypoint.indigoInsert documentation of the contract's storage type. The type should be passed using type applications.indigoGive a name to the given contract. Apply it to the whole contract code.indigo*Attach general info to the given contract.indigo:Attach default general info to the contract documentation.indigo0Indigo version for the homonym Lorentz function.indigoPut a   doc item.indigoPut a   doc item.indigoPut a  doc item.indigoCreate contract using default compilation options for Lorentz compiler.See  Lorentz.Run.indigo!Create contract from raw Lorentz .indigoemit tag expression) emits a contract event with textual tag tag and payload  expression.(The tag must be a field annotation. Use  5 quoter to construct it from a literal, for example: emit [annQ|tag|] ()indigo+Add a comment in a generated Michelson codeindigo+Add a comment in a generated Michelson codeindigoAdd a comment before and after the given Indigo function code. The first argument is the name of the function.indigoAdd a comment before and after the given Indigo statement code. The first argument is the name of the statement.  000# Safe-Inferred9!#$%&'(),-./045789:;<>?;   Safe-Inferred9!#$%&'(),-./045789:;<>?indigo4Pretty-print an Indigo contract into Michelson code.indigo*Generate an Indigo contract documentation.indigoPrints the pretty-printed Michelson code of an Indigo contract to the standard output.1This is intended to be easy to use for newcomers.indigoSaves the pretty-printed Michelson code of an Indigo contract to the given file.1This is intended to be easy to use for newcomers.indigo9Print the generated documentation to the standard output.indigo3Save the generated documentation to the given file.indigoForce result to be single line! Safe-Inferred9!#$%&'(),-./045789:;<>?indigoDisambiguation type used in  that links a single $ to the numeric type to resolve to.indigoKind used for ) as part of the disambiguation machinery.indigoDefines semantics of if ... then ... else ...; construction for Indigo where the predicate is a generic exa for which IsExpr exa Bool holdsindigo-Numerical literal disambiguation value for a G, see .indigo.Numerical literal disambiguation value for an F, see .indigo-Numerical literal disambiguation value for a , see .indigo1Defines numerical literals resolution for Indigo.%It is implemented with an additional  argument that disambiguates the resulting type. This allows, for example, 1 int to be resolved to  1 :: Integer.99" Safe-Inferred9!#$%&'(),-./045789:;<>?qindigoIndigo version of the view macro. It takes a function from view argument to view result and a View2 structure that typically comes from a top-level case.indigoFlipped version of 2 that is present due to the common appearance of flip view parameter $ instr construction.Semantically we "project" the given parameter inside the body of the View construction.indigoIndigo version of the void macro.indigoFlipped version of 2 that is present due to the common appearance of flip void_ parameter $ instr construction.indigoIf the first value is greater than the second one, it returns their difference. If the values are equal, it returns ]2. Otherwise it fails using the supplied function.$ Safe-Inferred9!#$%&'(),-./045789:;<>?#$ %&' ()*+,qsr-./01234" !56789:;<[`=>?Z@\ABCDEFGH]^IecdJ_KLMNOPQRSTabUVWXYfghijklmnopxyz{|}~   #$ %&' ()*+,qsr-./01234" !56789:;<[`=>?Z@\ABCDEFGH]^IecdJ_KLMNOPQRSTabUVWXYfghijklmnopxyz{|}~   % Safe-Inferred9!#$%&'(),./045789:;<>?!;&'()*+&,-&,.&/0&/1&'2&'3&45&67&89&8:&8;&8<)=>)=?&4@&'A&'B&'C&'D&EF&GH&6I&6J&6K&LM&'N&'O&'P&'Q&'R&'S&'T&'U&8V&8W)=X&YZ&6[&6\&']&'^&4_)=`&ab&6c&6d&ef&gh&Ei&Gj&'k&lm&no&pq&rs&tu&'v&'w)xy&'z)x{)x|)x})x~&&&&&)x&6&6)x)x&&&&&&&)x)x&r)x&)x)x)x&&&6)x&&)x)x)x&&&&)=)=)=)=)=)=)=&&'&'&'&'&'&'&'&'&'&'&'&'&'&'&'&'&'&'&'&'&'&'&4&4&4&4&4&/&/&&&&&&&&&&&&,&,&,&,&,&,&,&,&,&,&,&,&,&,&,&,&,&&8&8&8&8&8&8&6&6&6&6&6&6&6&6&6&6&6&6&6&6&6&6&6&6&6&Y&Y&Y&Y&Y&Y&Y&Y&Y&Y&Y&Y&Y&Y&Y&Y&Y&&&&&&&&&&&&&&l&l&&&&&&&&&&&&&&&&&n&n&n&L&L&L&&&&&&&&'&'&'&&n&L&L&L&L&L&L&L&L&L&L&L&&&n&n&&&&&&&&&&&&&&&&&&&&t&n&n&n&n&&&&&&&&&&&&&&l&l&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&r&r&r&r&&&&&&&&&&&6&6&6&6&6&6&6&6&6&6&6&6&6&6&6&6&6&6&6&6&6&6&8&8&&&&&/&&'&'&'&'&'&'&'&&&                                                  3                                                                                                                                                                                                                                                          B                                                                                                                                                                    5          >          ?                  0  1       N                                                                                    !!!!! """""            !!%%%%%%%%indigo-0.6.0-inplaceIndigo.Backend.PreludeIndigo.PreludeIndigo.LorentzIndigo.Frontend.LanguageIndigo.Common.Expr.THIndigo.Common.VarIndigo.Common.ObjectIndigo.Common.StateIndigo.Backend.LookupIndigo.Common.SISIndigo.Common.FieldIndigo.Common.ExprIndigo.Frontend.ExprIndigo.Backend.Expr.CompilationIndigo.Backend.ScopeIndigo.Backend.Expr.DecomposeIndigo.Backend.VarIndigo.Backend.LambdaIndigo.Backend.ErrorIndigo.Backend.ConditionalIndigo.Backend.Case"Indigo.Frontend.Internal.StatementIndigo.Frontend.ProgramIndigo.Compilation.ParamsIndigo.Backend#Indigo.Compilation.Sequential.TypesIndigo.Compilation.SequentialIndigo.Compilation.HooksIndigo.Compilation.FieldIndigo.Compilation.LambdaIndigo.Compilation Indigo.PrintIndigo.Rebound Indigo.LibIndigo.FrontendIndigo Paths_indigobaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip Data.Tuplefstsnd otherwise$GHC.Num-GHC.Real fromRationalGHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=negate>>=>>fmapreturnControl.Monad.Failfail Data.String fromString realToFrac toInteger toRational Control.Monadguard<>memptymappendmconcatjoin<*>pure*>BoundedEnumEq GHC.FloatFloating FractionalIntegralMonadFunctorNumOrdGHC.ReadReadRealRealFracGHC.ShowShowData.Typeable.InternalTypeable MonadFailIsString Applicative Data.FoldableFoldableData.Traversable Traversable GHC.GenericsGeneric GHC.TypeNatsKnownNatGHC.OverloadedLabelsIsLabel SemigroupMonoid GHC.TypesBoolStringCharDoubleFloatIntGHC.IntInt8Int16Int32Int64 ghc-bignumGHC.Num.IntegerIntegerGHC.Num.NaturalNatural GHC.MaybeMaybeOrderingRatioRationalIOWordGHC.WordWord8Word16Word32Word64GHC.PtrPtrFunPtr Data.EitherEitherType ConstraintCmpNat CoercibleGHC.Stack.Types CallStackD#FalseF#NothingJust:%TrueLeftRightLTEQGTbytestring-0.10.12.1Data.ByteString.Internal ByteString byteSwap16 byteSwap32 byteSwap64GHC.MVarMVardeepseq-1.4.5.0Control.DeepSeqdeepseqforceNFDatarnfcontainers-0.6.4.1Data.Set.InternalSetData.Map.InternalMapminmaxcompare><=</=GHC.Exception.Type SomeException.=<<apasTypeOfconstflipidliftM2ordwhen Alternative<|>emptymanysome<*<$ MonadPlusmplusmzeroNonEmpty:|subtract*+abssignumcurryuncurry Data.Functor<$>void Data.Functionon Data.Maybe catMaybes fromMaybeisJust isNothing listToMaybemapMaybemaybe maybeToListbreakcycledrop dropWhileiteraterepeat replicatereversescanlscanrsplitAttake takeWhileunzipunzip3zip3zipWithGHC.CharchrmaxBoundminBoundfromEnumpredsucctoEnum^^^evengcdlcmodd/recipdivdivModmodquotquotRemremceilingfloorproperFractionroundtruncate**acosacoshasinasinhatanatanhcoscoshexplogBasepisinsinhsqrttantanh Data.ProxyProxyeitherpartitionEithers Text.Read readMaybereadsData.Ord comparing Data.OldList intercalate intersperse isPrefixOfsortsortByunfoldrconcat concatMapData.Functor.ConstConstgetConst ExceptiondisplayException fromException toException GHC.ExceptionprettyCallStackGHC.IOFilePath GHC.Stack callStackwithFrozenCallStackData.Functor.IdentityIdentity runIdentityControl.Applicativeoptionalfor sequenceAtraversefilterMfoldMunlessData.List.NonEmptyheadinitlasttail Data.VoidabsurdvacuousVoidtransformers-0.5.6.2Control.Monad.Trans.Classlift MonadTransliftM3liftM4liftM5fixforM<$!><=<>=>foldM_forever mapAndUnzipMmfilter replicateM replicateM_zipWithM zipWithM_Control.Monad.IO.ClassliftIOMonadIOsequencemapM mtl-2.2.2Control.Monad.State.ClassmodifyOddWord-1.0.2.0-e853974e376e3ce3873e3da29bfa9a657cbc2fdd021c781f6a12f17fc33127df Data.Word.OddWord62Word63Control.Monad.Reader.Class MonadReaderasklocalreader MonadStategetputstatehashable-1.3.5.0-ee1d11aeffe1a4498b2a34a42c92007de3e9469e8bd015079d433b2f1d3bc52dData.Hashable.ClassHashable text-1.2.5.0Data.Text.InternalTextunordered-containers-0.2.17.0-d61695753636b08b972d3fff45576fe8d8d4fb46b29a5f96c6c8888f2b653cc6Data.HashMap.InternalHashMapGHC.IO.StdHandlesstdoutGHC.IO.Handle.TypesHandleData.Bifunctorbimap BifunctorData.Functor.Compose getComposeComposeData.Semigroup WrappedMonoid getOptionOption mtimesDefaultcycle1GHC.ExtssortWithsecondfirstnonEmptyGHC.ExecutionStackshowStackTrace getStackTrace fromLabel mapAccumR mapAccumLfoldMapDefault fmapDefault getZipListZipList Control.Arrow&&&stdinstderr GHC.Conc.SyncTVarSTM writeTVarreadTVarnewTVar GHC.IORefIORef prettySrcLocfoldrMfoldlM transposetails subsequencessortOn permutationsinitsgroup genericTakegenericSplitAtgenericReplicate genericLength genericDrop Data.MonoidgetLastLastgetFirstFirstData.Semigroup.InternalgetSumSum getProductProductappEndoEndogetDualDualgetAltAlt stimesMonoidstimesIdempotentgetDownDownSomeNat someNatValnatValrightsleftsisRightisLeft GHC.IO.IOMode WriteMode ReadWriteModeReadMode AppendModeIOMode Data.BitsxorunderflowErrorreduceratioZeroDenominatorError ratioPrec1 ratioPrec overflowErrornumericEnumFromTonumericEnumFromThenTonumericEnumFromThennumericEnumFrom numerator notANumbernaturalFromIntintegralEnumFromTointegralEnumFromThenTointegralEnumFromThenintegralEnumFrominfinity divZeroError denominator^^%^^^%^boundedEnumFromThenboundedEnumFrom Data.Boolbool&<&>$>swap GHC.Stack.CCScurrentCallStackstimessconcatliftA2minIntmaxIntliftA3<**> HasCallStack getCallStackstimesIdempotentMonoidControl.Monad.Trans.Identity IdentityT runIdentityTconstraints-0.13.3-4e183ff792a4fcb1cec769adc551f3f527496cdb4275530d8e8d19e9e60adbb6Data.ConstraintwithDictData.IntMap.InternalIntMapData.IntSet.InternalIntSetData.Sequence.InternalSeqdata-default-class-0.1.2.0-0d4df8766596c63a63287a7334799552ce3c50d8f4b242705c4b63ce6c2e50b1Data.Default.ClassDefaultdef$!!Control.Monad.Trans.MaybeMaybeT runMaybeTControl.Monad.Trans.ExceptExceptT runExceptTexceptions-0.10.4Control.Monad.Catch MonadThrowuninterruptibleMaskmaskgeneralBracket MonadMask MonadCatch hashWithSaltint-cast-0.2.0.0-301fc2890ff6b29d6b8f465d6e428e1658227d9f5a5355d3189dc47c8b8e4e04 Data.IntCast IntBaseTypeData.Text.LazytoStrictData.HashSet.InternalHashSet Control.Monad.Trans.State.StrictStateTStatevector-0.12.3.1-5b45dfcf339f11b2e11171a909b8779385c22d3c21f307435db4024ed01e2fae Data.VectorVectorControl.Monad.Trans.ReaderReadergetslens-5.0.1-427d0f34a1f6d0af6dbcda694a7cbebf579e8e2a58de8907c852bc2e9b4735d1Control.Lens.Foldpreusepreview^?^..Control.Lens.Getteruse^.viewControl.Lens.Tuple_1_2_3_4_5Control.Lens.Setter.~%~setoverControl.Lens.TypeLensLens' Traversal Traversal'lorentz-0.15.1-14946191e6d9a7695987296ea2b3a6490dd01c2e42aff9a005187ca6e9f059f7 Lorentz.PrintprintLorentzContractprintLorentzValue Lorentz.RuncdCompilationOptionsLcdCodeLcoStringTransformerLcoOptimizerConfLcoBytesTransformerLanalyzeLorentzinterpretLorentzLambdainterpretLorentzInstrnoViews setViewsRecsetViewscompileLorentzContractdefaultContractDatamkViewmkContractWith mkContractdefaultContractcompileLorentzWithOptionscompileLorentzintactCompilationOptionsdefaultCompilationOptionscoBytesTransformercoStringTransformercoOptimizerConfCompilationOptionscdCompilationOptionscdViewscdCode ContractData ContractViewLorentz.UParam pbsUParam uparamFromAdt caseUParamT caseUParamuparamFallbackFail unwrapUParammkUParamEntrypointKind?: UnsafeUParamUParam SomeInterfaceUParam_LookupEntrypointRequireUniqueEntrypointsConstrainedSome unpackUParam UnpackUParamArgumentUnpackFailedNoSuchEntrypointEntrypointLookupErrorEntrypointsImplUParamFallback CaseUParamUParamLinearizeUParamLinearizedLorentz.Entrypoints.DocentryCaseFlattenedHidingentryCaseFlattenedHiding_entryCaseFlattenedentryCaseFlattened_entryCaseSimple_areFinalizedParamBuildingStepsfinalizeParamCallingDoc'documentEntrypointclarifyParamBuildingStepsmkDEntrypointArgSimple mkDEpUType emptyDEpArg mkPbsWrapInentrypointSectiondiEntrypointToMarkdownDEntrypointDocItemdepSubdepName DEntrypoint entrypointKindSectionDescriptionentrypointKindSectionNameentrypointKindPosentrypointKindOverrideSpecifiedEntrypointKindOverrideEntrypointKindHasDocPlainEntrypointsKindFlattenedEntrypointsKindHidingFlattenedEntrypointsKindCommonContractBehaviourKindCommonEntrypointsBehaviourKindDEntrypointReferenceunParamBuilder ParamBuilder pbdMichelson pbdHaskell pbdEnglishParamBuildingDesc PbsUncallable PbsCustomPbsCallEntrypoint PbsWrapInParamBuildingStepSomeEntrypointArg epaBuildingepaArgDEntrypointArgderiveCtorFieldDocDeriveCtorFieldDocDocumentEntrypoints#-> EntryArrowRequireFlatParamEpsRequireFlatEpDerivationLorentz.StoreClass stNicknamestAliasstNestedthis mkStoreEpzoomStoreSubmapOpscomposeStoreEntrypointOpssequenceStoreSubmapOpscomposeStoreSubmapOpscomposeStoreFieldOpsmapStoreSubmapOpsValuemapStoreSubmapOpsKeymapStoreFieldOpsstoreEntrypointOpsReferTostoreFieldOpsReferTostoreSubmapOpsReferTostoreEntrypointOpsDeeperstoreSubmapOpsDeeperstoreFieldOpsDeeperstoreEntrypointOpsSubmapFieldstoreEntrypointOpsFieldsstoreEntrypointOpsADTstoreFieldOpsADT stSetEpStore stGetEpStore stToEpStore stSetEpLambda stGetEpLambda stToEpLambda stEntrypointstGetAndUpdate stSetFieldstGetFieldNamedstToFieldNamed stGetField stToField sopSetField sopGetFieldfieldNameFromLabelfieldNameToLabel FieldRefKind FieldRefTag mkFieldRefFieldRefObject KnownFieldRefFieldRef FieldName FieldSymReffieldRefFinalNameFieldRefFinalNameFieldRefHasFinalNamesopSetFieldOpensopGetFieldOpen sopToField StoreFieldOps storeFieldOps StoreHasField sopInsert sopDeletesopGetAndUpdate sopUpdatesopGetsopMemStoreSubmapOpsstoreSubmapOpsStoreHasSubmapEntrypointLambdaEntrypointsField sopSetEpStore sopToEpStoresopSetEpLambda sopToEpLambdaStoreEntrypointOps storeEpOpsStoreHasEntrypoint:-|SelfRef FieldAlias FieldNickname~>::->StorageContainsLorentz.Errors.Numeric.DocbaseErrorDocHandlersvoidResultDocHandlercustomErrorDocHandlerapplyErrorTagToErrorsDocWithapplyErrorTagToErrorsDoc detmSrcLocDDescribeErrorTagMapNumericErrorDocHandlerErrorNumericErrorDocHandlerNumericErrorWrapper Lorentz.Macro voidResultTagView_Void_ VoidResultNonZero Lorentz.ADT unsafeUnwrap_wrapOnewrap_ fieldCtor deconstructconstructStack setFieldOpen getFieldOpen modifyField getFieldNamedgetField toFieldNamedtoFieldHasFieldOfType NamedField:=HasFieldsOfTypeHasDupableGetters CaseClauseL/-> CaseArrowCaseTCLorentz.Errors.Numeric.ContracterrorToValNumericerrorFromValNumericuseNumericErrorsapplyErrorTagMapWithExclusionsapplyErrorTagMapexcludeErrorTagsbuildErrorTagMapaddNewErrorTagsgatherErrorTags ErrorTagMapErrorTagExclusionsLorentz.Util.THtypeDoc errorDocArg entrypointDocLorentz.Errors typeDocMdDescriptionReferToErrorisInternalErrorClasserrorTagToTexterrorTagToMTextfailUnexpectedsimpleFailUsingisoErrorFromVal isoErrorToVal ErrorScope failUsing errorFromVal errorToValIsErrorerrorDocRequirementserrorDocDependencies errorDocClasserrorDocHaskellReperrorDocMdCauseInEntrypointerrorDocMdCause errorDocNameErrorRequirements ErrorHasDocUnspecifiedError Impossible SomeErrorErrorArgceArgceTag CustomError NoErrorArg UnitErrorArgCustomErrorRepcustomErrorHaskellRepcustomErrorRepDocDepsverifyErrorTagIsCustomErrorArgRepMustHaveErrorArgErrClassUnknownErrClassContractInternalErrClassBadArgumentErrClassActionException ErrorClasscustomErrArgumentSemanticscustomErrClasscustomErrDocMdCauseInEntrypointcustomErrDocMdCauseCustomErrorHasDocDErrorDThrowsLorentz.ReferenceddropTdupTDupTdipTDipTLorentz.Lambda mkLambdaRecmkLambda RecLambda WrappedLambdaLambdaLorentz.Coercions castDummyGallowCheckedCoerceallowCheckedCoerceTocheckedCoercing_checkedCoerce_ checkedCoerce fromNamedtoNamed coerceWrapunsafeCoerceWrap coerceUnwrap fakeCoercing fakeCoercegForcedCoerce_ forcedCoerce_ forcedCoerceMichelsonCoercible castDummy CanCastTo Castable_ Coercible_Lorentz.Entrypoints.ManualunParameterWraperParameterWrapperLorentz.Wrappable Unwrappabled Unwrappable Wrappable Lorentz.Arith evalArithOpHs ArithOpHs defEvalOpHs DefArithOpevalUnaryArithOpHsUnaryArithResHsUnaryArithOpHsdefUnaryArithOpHsDefUnaryArithOpExtraConstraintsDefUnaryArithOp evalToIntOpHsToIntegerArithOpHsevalToBytesOpHsToBytesArithOpHs Lorentz.PackexpressionToScriptExprvalueToScriptExpr lEncodeValue lUnpackValue lPackValuelUnpackValueRaw lPackValueRaw Lorentz.Bytes openChestTtoHashHslSigntoBytes BytesLikeunPackedPacked unTSignature TSignatureunHash UnsafeHashHashtoHash computeHashhashAlgorithmNameKnownHashAlgorithmDHashAlgorithmSha256Sha512Blake2bSha3KeccakunChestTChestTChestOpenFailedT ChestContentT OpenChestT Lorentz.DocmkDEntrypointExamplecutLorentzNonDocDEntrypointExampledvSubdvNameDViewDViewArgDViewRetrenderViewsDescriptorDocviewsDescriptorNameViewsDescriptorHasDoc DViewDescLorentz.Entrypoints.ImplEpdPlain EpdRecursive EpdDelegate EpdWithRootLorentz.Polymorphic MemOpKeyHsMemOpHs IsoMapOpRes MapOpResHs MapOpInpHsMapOpHs IterOpElHsIterOpHsSizeOpHs UpdOpParamsHs UpdOpKeyHsUpdOpHs GetOpValHs GetOpKeyHsGetOpHs ConcatOpHs SliceOpHs Lorentz.Value PrintAsValue OpenChestListNeverrtAmountrtData rtTicketer ReadTicketLorentz.AddressconvertContractRefcallingDefAddresscallingAddress unTAddressTAddressunFutureContractFutureContract toAddress ToAddress toTAddress ToTAddress toContractRef ToContractReffromContractRefFromContractRefLorentz.Common Entrypoint Entrypoint_ Lorentz.Ext stackType testAssertcommentAroundStmtcommentAroundFuncomment justComment printCommentstackRef Lorentz.BaseoptimizeLorentzoptimizeLorentzWithConftransformBytesLorentztransformStringsLorentzparseLorentzValuetoMichelsonContractmkContractCode iForceNotFail iMapAnyCodeiNonFailingCodeiAnyCode iGenericIfIFIunLorentzInstr LorentzInstr:->%> ContractOutunContractCode ContractCodeSomeContractCodeViewCodecDocumentedCodecMichelsonContractFnmapLorentzInstrMapLorentzInstrLorentz.Constraints.DerivativedecideOnDupableNiceParameterFull IsNotDupable IsDupableDupableDecision NiceViewsNiceViewsDescriptorLorentz.Entrypoints.CoreparameterEntrypointCallCustomeprNamesepcCallRootCheckedparameterEntrypointCallDefaultparameterEntrypointCallparameterEntrypointsToNotesepdDescsepdCallepdNotesEpdLookupEntrypointEpdAllEntrypointsEntrypointsDerivationRequireAllUniqueEntrypointsParameterEntrypointsDerivationParameterHasEntrypointsParameterDeclaresEntrypointsAllParameterEntrypointsLookupParameterEntrypointGetEntrypointArgGetDefaultEntrypointArgForbidExplicitDefaultEntrypointNoExplicitDefaultEntrypointCall CallDefault EntrypointRefGetEntrypointArgCustomuseHasEntrypointArgHasEntrypointArgHasDefEntrypointArg TrustEpNameHasEntrypointOfType:>ParameterContainsEntrypointsEpdNoneLorentz.Entrypoints.HelpersunHasEntrypointsShouldHaveEntrypointsLorentz.Constraints.Scopes KnownValue NoOperationNoContractTypeNoBigMap CanHaveBigMap NiceParameter NiceStorageNiceStorageFull NiceConstantDupableNicePackedValueNiceUnpackedValueNiceFullPackedValueNiceUntypedValue NiceViewableNiceComparable NiceNoBigMapLorentz.Annotation HasAnnotationvinyl-0.13.3-f4cb4d80a116d3efe1651ea9b9036fc52d77ee206f306132907c93ab7756a17fData.Vinyl.CoreRecRNil:&universum-1.7.3-59c527371c359af1add04ae53203790f44f68f61ceeb07825dd237ce65fcd14fUniversum.TypeOpsUniversum.Debug undefinedmorley-prelude-0.5.2-d4b06502381bad5ccf277f59b4f4a7bbf3166347e11bb237c07f536ebab1daf2Unsafe fromIntegernamed-0.3.0.1-6c0174fa90be25fdb4550b1611367742927ce2c1fe8ec4571928ecceec8dae9dNamed.Internal:!:?morley-1.19.1-89d7ac42a5ac8fc81c88530f4d30969c4454703b2fcca7202bcd6de583f1f177Morley.Util.CustomGenericGenericStrategy withDepths rightBalanced leftBalanced rightCombleftCombhaskellBalancedreorderingConstrsreorderingFieldsreorderingDataalphabeticallyleaveUnnamedFieldsforbidUnnamedFieldsfromDepthsStrategyfromDepthsStrategy'makeRightBalDepthscstrfld customGenericcustomGeneric' reifyDataTypederiveFullType!mangleGenericStrategyConstructorsmangleGenericStrategyFields,Morley.Michelson.Typed.Haskell.Compatibility ligoLayoutligoCombLayoutMorley.Util.MarkdownMarkdownMorley.Michelson.Typed.Scope ConstantScopeMorley.Util.LabelLabelMorley.Tezos.Crypto.TimelockChestChestKey$Morley.Michelson.Untyped.EntrypointsEpName DefEpNameMorley.Tezos.Crypto.BLS12381 Bls12381Fr Bls12381G2 Bls12381G1Morley.Michelson.TextMTextmtMorley.Tezos.CryptoKeyHash Signature PublicKeyMorley.Tezos.CoreChainId TimestampMuteztztoMutez zeroMutezoneMuteztimestampFromSecondstimestampFromUTCTimetimestampQuoteMorley.Tezos.AddressAddress!Morley.Michelson.Typed.AnnotationmkUType"Morley.Michelson.Typed.Entrypoints EpAddress EpAddress' eaAddress eaEntrypointMorley.Michelson.Typed.Contract IsNotInViewMorley.Michelson.Doc ContractDoc cdContents cdDefinitionscdDefinitionsSetcdDefinitionIdsSubDoc DocSectionDocElemdeItemdeSubSomeDocDefinitionItem SomeDocItemDocSectionNameStyleDocSectionNameBigDocSectionNameSmall DocItemRefDocItemRefInlined DocItemNoRefDocItemPlacementKindDocItemInlinedDocItemInDefinitions DocItemPos DocItemIdDocItemDocItemPlacementDocItemReferenced docItemPosdocItemSectionNamedocItemSectionDescriptiondocItemSectionNameStyle docItemRefdocItemToMarkdown docItemToTocdocItemDependencies docItemsOrder mdTocFromRefdocItemPositiondocDefinitionRefdocItemSectionRefsubDocToMarkdownDAnchorDCommentGitRepoSettingsgrsMkGitRevision DGitRevisionDGitRevisionKnownDGitRevisionUnknown DDescriptionDNameDGeneralInfoSectionWithFinalizedDocContainsUpdateableDocmodifyDocEntirely ContainsDocbuildDocUnfinalized DocGroupingcontractDocToMarkdown finalizedAsIsbuildDocbuildMarkdownDoc modifyDocmorleyRepoSettingsmkDGitRevisionattachDocCommonsMorley.Michelson.Typed.Aliases OperationValue$Morley.Michelson.Typed.Haskell.ValuemkBigMapBigMapBigMapId unBigMapIdTicket tTicketertDatatAmount ContractRef crAddress crEntrypoint WellTypedToTSomeEntrypointCallEntrypointCallIsoValueToTtoValfromValcoerceContractRef,Morley.Michelson.Typed.Haskell.Instr.ProductInstrConstructCConstructorFieldTypes"Morley.Michelson.Typed.Haskell.Doc IsHomomorphicHaveCommonTypeCtorDTypeSomeTypeWithDoc TypeHasDocTypeDocFieldDescriptions typeDocNametypeDocMdDescriptiontypeDocMdReferencetypeDocDependenciestypeDocHaskellReptypeDocMichelsonRepTypeHasFieldNamingStrategytypeFieldNamingStrategytypeDocBuiltMichelsonRepdTypeDepdStoragecustomTypeDocMdReferencehomomorphicTypeDocMdReferencepoly1TypeDocMdReferencepoly2TypeDocMdReferencegenericTypeDocDependencieshomomorphicTypeDocHaskellRepconcreteTypeDocHaskellRepunsafeConcreteTypeDocHaskellRephaskellRepNoFieldshaskellRepStripFieldPrefixhaskellAddNewtypeFieldhomomorphicTypeDocMichelsonRepconcreteTypeDocMichelsonRep!unsafeConcreteTypeDocMichelsonReperrorasksReaderTEachUniversum.Container.ClassfindMorley.Prelude.FromIntegral fromIntegral#Morley.Michelson.Untyped.AnnotationannQFieldAnnunsafeMunsafeMorley.Prelude.Showshow PrettyShowfromIntegralNoOverflowfromIntegralOverflowingfromIntegralToRealFracfromIntegralMaybeCheckIntSubTypeMorley.Prelude.Booleanall1any1allanyand1or1andornot||&&Booleantruefalse BooleanMonoidgetAllAllgetAnyAnyApplicativeBooleanUniversum.ApplicativepasssomeNEUniversum.Base$!Universum.Functor.Fmapmap<<$>>Universum.Lifted.Concurrent newEmptyMVarnewMVarputMVarreadMVarswapMVartakeMVar tryPutMVar tryReadMVar tryTakeMVar atomically newTVarIO readTVarIO updateMVar' updateTVar'Universum.Lifted.EnvexitWith exitFailure exitSuccessdieUniversum.Lifted.File appendFilegetLineopenFilehClosewithFileUniversum.Lifted.IORefnewIORef readIORef writeIORef modifyIORef modifyIORef'atomicModifyIORefatomicModifyIORef'atomicWriteIORefUniversum.Monad.MaybewhenJust whenJustM whenNothing whenNothing_ whenNothingM whenNothingM_Universum.Monad.EitherfromLeft fromRight leftToMaybe rightToMaybe maybeToRight maybeToLeftwhenLeft whenLeftM whenRight whenRightMUniversum.Monad.Trans usingReaderT usingReader usingStateT usingStateevaluatingStateTevaluatingStateexecutingStateTexecutingState hoistMaybe hoistEitherUniversum.Monoid maybeToMonoidOneOneItemone ContainerElementtoListnullfoldrfoldlfoldl'lengthelemfoldMapfoldfoldr'notElemsafeHead safeMaximum safeMinimum safeFoldr1 safeFoldl1FromList ListElement FromListCfromListToPairstoPairskeyselems flipfoldl'sumproduct traverse_for_mapM_forM_ sequenceA_ sequence_asumUniversum.Monad.Container concatMapM concatForMandMorMallManyMUniversum.List.Safeuncons whenNotNull whenNotNullMfoldl1foldr1 minimumByminimum maximumBymaximumUniversum.ExceptionBugExcbugnoteUniversum.DeepSeq evaluateWHNF evaluateWHNF_ evaluateNF evaluateNF_Universum.Bool.GuardwhenMunlessMifMguardM Universum.NubordNubhashNubsortNub unstableNubUniversum.Print.InternalPrintUniversum.PrinthPutStr hPutStrLnputStrputStrLnprinthPrintputText putTextLnputLText putLTextLn Undefinedtrace traceShow traceShowId traceIdWithtraceShowIdWith traceShowMtraceMtraceIdUniversum.String.ConversionToStringtoStringToLTexttoLTextToTexttoText ConvertUtf8 encodeUtf8 decodeUtf8decodeUtf8Strict LByteStringLText readEitherWithUniversum.VarArgSuperComposition...exceptToMaybeTmaybeToExceptTData.Text.Encoding.Error lenientDecode strictDecode OnDecodeErrorOnErrorUnicodeExceptionData.Text.Encoding decodeUtf8'decodeUtf8With Data.Textlinesunlinesunwordswords fromStrict stm-2.5.0.0Control.Concurrent.STM.TVar modifyTVar'safe-exceptions-0.1.7.2-8ffcbfd44e7ccdfedfa9722c5f260dfd3096b154bbd691c3a3e086f92857cdfdControl.Exception.SafethrowMcatchcatchAny handleAnytrytryAny onExceptionbracketbracket_finallybracketOnError runStateT withStaterunState execStateT execState evalStateT evalState runReaderT runReadermodify'deriveExprBuildable# HasStorageHasSideEffectsOpsVar StackVars StkElements FailureStack StackVars'StkElNoRefRefRefId emptyStack assignVarAtpushRef pushNoRefpopNoRef operationsVar storageVar$fBuildableRefId$fTestEqualityTYPEStkEl$fDefaultStackVars$fDefaultStackVars0$fBuildableVar $fGenericVar $fShowVar $fShowRefId$fGenericRefId $fEqRefId $fOrdRefId $fRealRefId $fNumRefId$fIntegralRefId $fEnumRefId$fBoundedRefIdComplexObjectC FieldTypesIsObject TypedFieldObj SomeObjectObject NamedFieldObj unFieldObj IndigoObjectFCell DecomposednamedToTypedRectypedToNamedReccastFieldConstructorsnamedToTypedFieldObjtypedToNamedFieldObjwithInstrDeconstructCcomplexObjectDict$fInstrDeconstructCClassast$fInstrDeconstructCGenerala$fIsObject'ProductTypeDa$fIsObject'SumTypeDa$fIsObject'PrimitiveDa $fIsObjectaGenCodegcStackgcCodegcClear GenCodeHooks gchStmtHookgchAuxiliaryHook gchExprHookMetaDatamdStack mdObjectsmdHooksDecomposedObjects IndigoStaterunIndigoStateusingIndigoStateiputnopState assignTopVar withObjectwithObjectState withStackVarsemptyGenCodeHooksstmtHook stmtHookState auxiliaryHookauxiliaryHookStateexprHook exprHookState replStkMd alterStkMd pushRefMd pushNoRefMd popNoRefMd cleanGenCode##$fMonoidGenCodeHooks$fSemigroupGenCodeHooks varActionGet varActionSetvarActionUpdatevarActionOperationrtakerdrop$fTestEqualityTTValSomeIndigoStateunSIS SomeGenCoderunSIStoSISthenSISoverSISHasField fieldLens FieldLens TargetField DeeperField AccessFieldC fetchField assignFieldflSFO fieldLensADTfieldLensDeeper$fHasFieldSymboldtfnameftypeObjectManipulationToFieldSetFieldExprCVObjManCastSizeUpdateAddSubMulDivModAbsNegLslLsrEq'NeqLeLtGeGtOrXorAndNotInt'IsNatCoerce ForcedCoerceFstSndPairSomeNoneRight'Left'MemStGet StInsertNewStInsertStMemStUpdateStDeleteWrapUnwrap ConstructConstructWithoutNamedNameUnNameEmptySetGetEmptyMap EmptyBigMapPackUnpackPackRaw UnpackRawConsNilConcatConcat'SliceContractSelf SelfAddressContractAddressContractCallingUnsafeRunFutureContractImplicitAccountConvertEpAddressToContractMakeViewMakeVoidCheckSignatureHashKeyLevelNowAmountBalanceSender VotingPowerTotalVotingPowerExec IsSizeExpr IsMemExpr IsUpdExpr IsGetExpr IsSliceExprIsConcatListExpr IsConcatExpr IsModExpr IsDivExpr IsArithExprIsUnaryArithExprToExprExprType:~>IsExpr ObjectExprNamedFieldExprunNamedFieldExprtoExpr$fBuildableObjectManipulation$fBuildableExpr$fToExpr'DecisionExprDExpr*$fToExpr'DecisionObjManDObjectManipulation$fToExpr'DecisionValDa$fToExpr'DecisionVarDVar $fToExprxremoveinsert constExprvarExprcastaddsubmul%negeqneqltgtlegeisNattoIntnonZerocoercelsl<<<lsr>>>packunpackpackRaw unpackRawpaircarcdrnonerightleftslicecons.: concatAllnilupdatememsize#:!:+:-: emptyBigMapemptyMapemptySetstGet#@stUpdate!@stInsert+@ stInsertNew++@stDelete-@stMem?@wrapunwrap#!!!nameunName!~#~ construct constructReccontractself selfAddresscontractAddresscontractCallingUnsafecontractCallingStringrunFutureContractimplicitAccountconvertEpAddressToContractmakeViewmakeVoidnowamountsendercheckSignaturesha256sha512blake2bsha3keccakhashKeychainIdbalancelevel votingPowertotalVotingPower$fParityExprMutezMutez$fParityExprNaturalNatural$fParityExprIntegerInteger$fExprMagmaSet$fExprMagmaMap$fExprMagmaBigMap$fExprInsertableSetexKey$fExprInsertableMap(,)$fExprInsertableBigMap(,)$fExprRemovableSet$fExprRemovableMap$fExprRemovableBigMapObjManipulationRes StillObjectOnStack compileExpr namedToExprrunObjectManipulation ternaryOpbinaryOpunaryOp nullaryOp ternaryOpFlat binaryOpFlat unaryOpFlat nullaryOpFlat ScopeCodeGenReturnableValueRetExprsRetVars RetOutStack ScopeCodeGen'compileScopeReturn' liftClear' genGcClear'ReturnableValue' RetOutStack'RetVars' RetExprs' allocateVars' assignVars' prettyAssign' prettyRet'ClassifyReturnValue BranchRetKindUnit SingleValTuple allocateVars liftClear prettyAssign prettyRetcondStmtPretty compileScopefinalizeStatement$fReturnableValue'Unit()$fScopeCodeGen'Unit()$fScopeCodeGen'Tuple(,,)$fReturnableValue'Tuple(,,)$fScopeCodeGen'Tuple(,)$fReturnableValue'Tuple(,)$fScopeCodeGen'SingleValsingle!$fReturnableValue'SingleValsingleExprDecomposition ExprFields DeconstructeddeepDecomposeCompose decomposeExpr assignVarsetVarsetField updateVarExecuteLambdaEff1CCreateLambdaEff1CExecuteLambda1CCreateLambda1CExecuteLambdaPure1CCreateLambdaPure1CCreateLambda1CGenericLambda1Generic LambdaKind PureLambda StorageLambda EffLambdawithLambdaKindexecuteLambda1initLambdaStackVarscreateLambda1GenericfailWithnever failUsing_ failCustom failCustom_failCustomNoArgfailUnexpected_ IfConstraintif_ifSomeifRightifCons CaseCommonF IndigoClauseIndigoCaseClauseLcaseRec entryCaseRecentryCaseSimpleRec,$fCaseArrownameIndigoClauseIndigoCaseClauseL StatementFLiftIndigoState CalledFromNewVarSetVarVarModification LambdaCall1ScopeIfIfSomeIfRightIfConsCase EntryCaseEntryCaseSimpleWhile WhileLeftForEach ContractNameDocGroupContractGeneralFinalizeParamCallingDocTransferTokens SetDelegateCreateContract SelfCallingContractCallingEmitFailFailOverIndigoMCaseClauseLOneFieldIndigoMCaseClauseLIndigoContractIndigoM unIndigoMProgramDoneInstrBindinterpretProgram$fMonadProgram$fApplicativeProgram$fFunctorProgram$fFunctorIndigoM$fApplicativeIndigoM$fMonadIndigoMAreIndigoParamsIndigoWithParamsfromIndigoWithParamscontractToIndigoWithParamswhile whileLeftforEachdocdocGroup docStorage contractNamecontractGeneralcontractGeneralDefaultfinalizeParamCallingDoc selfCallingcontractCallingtransferTokens setDelegatecreateContractemitscope CaseBranchIndigoSeqCaseClauseOneFieldIndigoSeqCaseClauseSequentialHooks shStmtHookInstrCollectornextRef instrListseqHooks InstructionComment AssignVar CreateLambda1 ExecLambda1Block$fMonoidSequentialHooks$fSemigroupSequentialHooks stmtHookLindigoMtoSequentialsequentialToLorentz updateClauses mapMClausesCommentsVerbosity NoCommentsLogTopLevelFrontendStatementsLogBackendStatements LogAuxCodeLogExpressionsComputationsCommentSettings csVerbositycsPrintFullStackTracecsPrintFileNamedefaultCommentSettings$fDefaultCommentSettings$fEqCommentSettings$fShowCommentSettings$fShowCommentsVerbosity$fEqCommentsVerbosity$fOrdCommentsVerbosity$fBoundedCommentsVerbosity$fEnumCommentsVerbosity CommentHookschFrontendHookschBackendHooks$fMonoidCommentHooks$fSemigroupCommentHookssettingsToHooksoptimizeFieldscompileLambdas$fOrdLambda1Def$fEqLambda1Def compileIndigocompileIndigoContractFullcompileIndigoContractIndigoEntrypointIndigoProcedureIndigoFunctionliftIndigoStatenew=:+=-=*=||=&&=^=<<<=>>>=setStorageFieldupdateStorageFieldgetStorageFieldifNonewhenSomewhenNoneifLeftcase_ entryCaseentryCaseSimple//->#= defFunction defContractdefNamedEffLambda1defNamedLambda1defNamedLambda0defNamedPureLambda1 descriptionanchorexamplecreateLorentzContractassert assertCustom assertCustom_assertCustomNoArg assertSome assertNone assertRight assertLeftprintIndigoContractrenderIndigoDocprintAsMichelsonsaveAsMichelsonprintDocumentationsaveDocumentation ifThenElsenatintmutezview_projectvoid_ projectVoidsubGt0 TypeDecision IsObject'InstrDeconstructCGeneralInstrDeconstructCClassInstrDeconstructC InstrDeconstructCClassConstraintMapGFTTValMorley.Michelson.Typed.TTsingletons-3.0.1-503bf7c7ada49acdce4b5bde4ccf64c3e78d7336daae2cf18f9d8e85824c87a2Data.SingletonsSingI TValStackVarDepthMorley.Util.PeanoPeanoSingduupXVar replaceNVar updateNVarvarDepth ExprRemovableExprInsertablecompileObjectManipulation objToExprcompileObjectF exprToManRes compileToExprSIS'decomposeObjectFdeconstructOnStack noRefGenCodeexecuteLambdaPure1executeLambdaSt1executeLambdaEff1executeLambda1GenericfailIndigoState CaseCommonAreIndigoPeanoParamsIndigoWithPeanoParamsfromIndigoWithPeanoParams instrCollectcollectStatement collectInnercollectInLambdaappendNewInstr mkNextVarsequentialToSIS instrToSISclausesToBackendallocateClausesVarscollectClausesprettyFrontendCallStack Lambda1DefldNamecollectNotInlinableLambdascreateLambdaRefscreateAllLambdas updateBlockcompileIndigoImplcompileIndigoFullNumTypeNumKindversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDir