##{1p      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrs t u v w x y z { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p qrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmno"None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmb!%ih&  _`ba'g(.-,+*)('&%$#"! ) WV*UTSRQP+,- .}/01\[ZYX23456#"$789:;<= >[`?@ZA\BCDEFGHI^]JcdeK_LMNOPQRSTUabVWXYfjklonmpqsrtuwxyz{|~v     /0123456789:;<=>?@ABCDEFGHIJKLMNO]^cdefghijklmnopqrstuvwxyz{|}~$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{z|}~}  !%ih&  _`ba'g(.-,+*)('&%$#"! ) WV*UTSRQP+,- .}/01\[ZYX23456#"$789:;<= >[`?@ZA\BCDEFGHI^]JcdeK_LMNOPQRSTUabVWXYfjklonmpqsrtuwxyz{|~v     /0123456789:;<=>?@ABCDEFGHIJKLMNO]^cdefghijklmnopqrstuvwxyz{|}~$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{z|}~}  None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmzDv>[`GHI^]t|      !"#$%&'()*+,-./012654387?>=<;:9A@BCIHGFEDKJLMNOPQRSTUVWXY[Z\]_^a`bcdefgjihklmnopqrstuvwxyz{|}~      !"! #$#%&'('&)*+*),-./0/.123456789:=<;@?>BADCFEHGIJKLMNOPQRSTUVWXY\[Z]^_a`bcedfghijklpqrqponmstutvwxyz{|~}      !"#v>[`GHI^]t|      !"#$%&'()*+,-./012654387?>=<;:9A@BCIHGFEDKJLMNOPQRSTUVWXY[Z\]_^a`bcdefgjihklmnopqrstuvwxyz{|}~      !"! #$#%&'('&)*+*),-./0/.123456789:=<;@?>BADCFEHGIJKLMNOPQRSTUVWXY\[Z]^_a`bcedfghijklpqrqponmstutvwxyz{|~}      !"#None8!"#$%&'*+,-./12456789;<=>?@ACHMNPSUVX_`befgkm indigoResulting state of IndigoM. indigoInterpreter output valueindigoInterpreter meta data.indigoGenerated Lorentz code.indigoClearing Lorentz code.indigoInitial state of .indigo"Stack of the symbolic interpreter.indigoNumber of allocated variables.indigo"Stack of the symbolic interpreter.indigo*Stack element of the symbolic interpreter.GIt 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 cellindigo#IndigoState monad. It's basically  `https://hackage.haskell.org/package/category-extras-0.53.5/docs/Control-Monad-Indexed-State.htmlControl.Monad.Indexed.StateG , however this package is not in the used lts and it doesn't compile.It takes as input a ( (for the initial state) and returns a  : (for the resulting state and the generated Lorentz code).nIndigoState has to be used to write backend typed Lorentz code from the corresponding frontend constructions.indigoReturn for rebindable syntax. indigoBind for rebindable syntax.%It's basically like the bind for the 6 monad, but it also composes the generated code from m a and a -> m b."indigoThen for rebindable syntax.#indigo Get current .$indigoPut new  .&indigofProduces the generated Lorentz code that cleans after itself, leaving the same stack as the input oneu    !"#$%& !"u#$   %&None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm&2indigo%Allows to get a variable with storage3indigo(Allows to get a variable with operationspindigo.Decide whether type is either primitive or ADTqindigo5Type class instantiated for all possible Indigo types8indigoLike ;+, but this one doesn't keep name of a field:indigoVariable exposed to a user.:/ represents the tree of fields. Each field is :) itself: either a value on the stack or  of its direct fields.;indigoHAuxiliary datatype to define a variable. Keeps field name as type paramrindigoLAuxiliary type family to convert list of field names to list of field types>indigoyA 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.?indigoJValue stored on the stack, it might be either complex product type, like (a, b)", Storage, etc, or sum type like U, or primitive like B, , etc. Laziness of ) is needed here to make possible to put $1 in a variable. This is used as a workaround in Indigo.Compilation.Lambda.@indigoGDecomposed product type, which is NOT stored as one cell on the stack.Aindigo?Convert a list of fields from name-based list to type-based oneBindigo@Convert a list of fields from type-based list to named-based oneGindigoGiven 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.Hindigo>Create a variable referencing the element on top of the stack.Iindigo_Push a new stack element with a reference to it. Return the variable referencing this element.Jindigo3Push a new stack element without a reference to it.Kindigo\Remove the top element of the stack. It's supposed that no variable refers to this element.Lindigo>Return a variable which refers to a stack cell with operationsMindigo;Return a variable which refers to a stack cell with storage23456789:;<=>?@ABCDEFGHIJKLM>?@;<=896:ABDE7F5CGHIJK43L2MNone7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm sindigoSimple datatype used to keep a t and its 3 constraintuindigoStack representation of t used for constraint checkingvindigo-Keeps the 0-indexed depth of a variable as a w xletonRindigo'Puts a copy of the value for the given Var on top of the stackSindigoSets the value for the given Var" to the topmost value on the stackTindigo Updates the value for the given VarI with the topmost value on the stack using the given binary instruction.UindigoGiven a stack with a list of .s on its bottom, updates it by appending the  on the top.yindigoLike R , but requires the depth of the Var in the input stackzindigoLike S , but requires the depth of the Var in the input stack{indigoLike T , but requires the depth of the Var in the input stack|indigoCalculates the v of the given Var in the stackRSTUVWRSTUVWNone7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm!%ih&  _`ba'(.-,+*)('&%$#"! ) V*UTQP+,-.}/01\[ZYX23456#"$789:;<= >[`?@ZA\BCDEFGHI^]JcdeK_LMNOPQRSTUabVWXYfjklonmpsrtuwxyz{|~v     /013456789:;<=?@ABCDEFGHIJKLMNO]^cdefghijklmnopqrstuvwxyz{|}~$&()*,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^`abcdefghijkmopqrstuvwxyz{z|}~}  !%ih&  _`ba'(.-,+*)('&%$#"! ) V*UTQP+,-.}/01\[ZYX23456#"$789:;<= >[`?@ZA\BCDEFGHI^]JcdeK_LMNOPQRSTUabVWXYfjklonmpsrtuwxyz{|~v     /013456789:;<=?@ABCDEFGHIJKLMNO]^cdefghijklmnopqrstuvwxyz{|}~$&()*,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^`abcdefghijkmopqrstuvwxyz{z|}~}  None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm Yindigob with hidden output stack, necessary to generate typed Lorentz code from untyped Indigo frontend.\indigo!Gen code with hidden output stack^indigo for Y_indigodLike bind, but the input type of the second parameter is determined by the output of the first one.`indigoTo run Y you need to pass an handler of   with any output stack.aindigoConvert  to YbindigoCall an action with  stored in Y.:This function is kinda dummy because it passes IndigoState to the function which produces a GenCode independently on passed MetaData to it. It has to be used with only functions which pass MetaData in the same way. This function is needed to pass SomeIndigoState in contravariant positions of statements like if, case, while, forEach), etc. Alternative solution would be abstracting out IndigoState and SomeIndigoState with typeclass class CodeGenerator m where runCodeGen :: m inp a -> MetaData inp -> (forall out . GenCode inp out a -> r) -> r and passing CodeGenerator m in contravariant positions instead of IndigoState.cindigo The same as b9 but converting a function with one argument, also dummy.dindigo The same as c8 but converting a function with 2 arguments, also dummy. YZ[\]^_`abcd YZ[\]^_a`bcdNone7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm gindigo Class like 8* type class but holding a lens to a field.iindigoLens 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 fieldxHowever, a lens contains not only name of field but for each field it contains operations to get and set target field.lindigo/Constraint to access/assign field stored in RecmindigoGet a field from list of fieldsnindigoAssign a field to a valueoindigo Access to 6pindigo,Build a lens to a direct field of an object.qindigo*Build a lens to deeper field of an object.rindigoDefault instance for datatype and its direct field name. It will be useful unless you want to refer to a field using a custom name. ghijklmnopq lmnijkoghqp None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm/indigoiAuxiliary datatype where each field refers to an expression the field equals to. It's not recursive one.indigo?Datatype describing access to an inner fields of object, like Bobject !. field1 !. field2 ~. (field3, value3) ~. (field4, value4)gstuvwxyz{|}~g~|}yx{zvtswu None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm+indigo( 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.}indigoConvert arbitrary > into , having converter for fields.~indigoCompile >A to a stack cell, having a function which compiles inner fields.indigoCompile ; datatype to a cell on the stack. This function leverages % to put off actual field compilation.indigouThis function might look cumbersome but it basically 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. None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm8indigo<Expression class to remove an element from a data structure.!Note that while this is based on , and (F, it is necessary to have different instances to allow for different , parameter types, ( uses a > instead of a I).indigo<Expression class to insert an element into a data structure.!Note that while this is based on , and (F, it is necessary to have different instances to allow for different , parameter types, ( uses a > instead of a I ), just like ..Moreover, this class is parameterized with an insParam1 as well in order to have both key-value pairs (| and ) as well as key only ().indigo(Create an expression holding a variable.r      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^r      !"#$%&)*'(+,-./012345679;=?A8:<>@BDCEFGHIJKLMNOPQRSTUVW[YZ\]^X!6677744444 488232&6(5/80818283888:8<8>8@8B8C8D8G8H8 None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmHnhindigo'Datatype representing decomposition of .kindigo5Decompose an expression to list of its direct fields.lindigo~For given element on stack, generate code which decomposes it to list of its deep non-decomposable fields. Clean up code of Y composes the value back.indigoDecompose any > having decomposer for field.indigoADeconstruct top element of the stack and return it wrapped into j constructor.indigo7Push the passed stack cells without references to them.7hijklklhij7None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmJ7stuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^hijklNone7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmP.Bu    !"#$%&23456789:;<=>?@ABCDEFGHIJKLMRSTUVWYZ[\]^_`abcdghijklmnopqstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^hijkl None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm^mindigoACreate a new variable with passed expression as an initial value.nindigo 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 n recursively from its fields.oindigo7Set the field (direct or indirect) of a complex object.pindigoHCall binary operator with constant argument to update variable in-place.mnopmnopNone6!"#$%&'*,-.12456789;<=>?@ACHMNPSUVX_`befgkmkqindigoGenerates all of the r; (both with and without return value) from 1 to the given nrindigoIGenerates a function that converts a Lorentz expression to an Indigo one.~The first parameter is the number of elements that the Lorentz code consumes from the stack, as well as the number of Indigo  values.mThe second parameter is to establish if there is a return value or not, as well as the name of the function. Examples:fromLorentzFunN 1 False produces: JfromLorentzFun1Void :: IsExpr ex a => a & s :-> s -> ex -> IndigoM s s () fromLorentzFunN 2 True produces: fromLorentzFun2 :: (KnownValue ret, IsExpr ex1 a, IsExpr ex2 b) => a & b & s :-> ret & s -> ex1 -> ex2 -> IndigoM s (ret & s) (Var ret) qrqrNone7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmpxindigoTType 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: P 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 yindigoqProduces an Indigo computation that puts on the stack the evaluated returned expressions from the leaving scope.zindigozDrop the stack cells that were produced in the leaving scope, apart from ones corresponding to the returning expressions.{indigo Generate  for the whole statement|indigoLClass for values that can be returned from Indigo statements. They include () and tuples.}indigo^Type family reflecting the top elements of stack produced by a statement returning the value.~indigo<Type family reflecting the returning value from a statement.indigoTuple looking like (Expr x, Expr y, ..) that corresponds to expressions returning from the scope. 'RetVars'' and 'RetExprs'' are twin types because the former just adds :$ over each expression of the latter.indigo8Allocate variables referring to result of the statement.indigo2This type family returns a promoted value of type J or causes a compilation error if a tuple with too many elements is used.indigopTo avoid overlapping instances we need to somehow distinguish single values from tuples, because the instances: 3 instance Something a instance Something (a, b) overlap and adding {-# OVERLAPPING #-}H doesn't rescue in some cases, especially for type families defined in  Something.indigo(If value is unit (don't return anything)indigo"If it's a single value (not tuple)indigo6If it's tuple (we don't care how many elements are in)indigo#Specific version of 'allocateVars''indigo Specific version of 'liftClear''indigopConcatenate a scoped code, generation of returning expressions, and clean up of redundant cells from the stack.indigoPush a variables in 8, referring to the generated expressions, and generate  for the whole statement.indigoSingle variable allocatorstuvwxyz{|}~sxyz{t|}~wvuNone7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm"indigoCreate a lambda, that takes only one argument, from the given computation. The lambda is not allowed to modify storage and emit operations.indigoHExecute a lambda, which accepts only one argument, on passed expression.indigoyCreate a lambda, that takes only one argument, from the given computation. The lambda is not allowed to emit operations.indigoHExecute a lambda that accepts only one argument on the given expression.indigoCreate a lambda, that takes only one argument, from the given computation, and return a variable referring to this lambda. The lambda is allowed to modify storage and emit operations.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.indigo{Create a lambda, that takes only one argument, from the given computation, and return a variable referring to this 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.None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmbindigoIf statement. All variables created inside its branches will be released after the execution leaves the scope in which they were created.indigo#If which works like case for Maybe.indigo$If which works like case for Either.None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmx  None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmindigoThis type is analogous to the _r type but instead of wrapping a Lorentz instruction, this wraps an Indigo value with the same input/output types.indigo An alias for `V to use when the body is a lambda so that the whole thing won't have multiple arrows.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.  None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmτ indigo/While statement. The same rule about releasing.indigo)For statements to iterate over container.indigoPut a document item.indigopGroup documentation built in the given piece of code into block dedicated to one thing, e.g. to one entrypoint.indigofInsert documentation of the contract storage type. The type should be passed using type applications.indigoCGive a name to given contract. Apply it to the whole contract code.indigo&Attach general info to 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 commentcmnopstuvwxyz{|}~}~None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmindigo#StatementF functor for Freer monad.MThe constructors correspond to every Indigo statement that has expressions ( x) in its signature.>The ones that don't take expressions are compiled directly to  (and kept in J), 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. contH is needed to support statements which have recursive structure (like: if, while, case, etc).indigo_Direct injection of IndigoState of statements which are not going to be analyzed by optimizer.indigo Pure lambdaindigoDefault lambda which can modify storageindigo3Lambda which can modify storage and emit operationsindigo@Analogous datatype as IndigoCaseClauseL from Indigo.Backend.Case""None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmindigo$Monad for writing your contracts in.indigo7This is freer monad (in other words operational monad).LIt preserves the structure of the computation performed over it, including return and binda operations. This was introduced to be able to iterate over Indigo code and optimize/analyze it.aYou 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 itNone7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm0indigo<Typeable and stack size constraint for the parameters of an .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 ('S ('S 'Z)) '[a, b, c] x is the same as: Var b -> Var a -> IndigoM x indigo Converts an  to its form without input :s, alongside the ! to use it with. If there is an 4. to the bottom of the stack it also assigns a : to it.indigoAssigns a variable to the 4p list at the bottom of the stack iff there is one and it does not have one already. Otherwise returns the same .  None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm indigoThis is a hack, which prevents using a variable from an outer scope in a body of the lambda. This is not needed when a lambda is defined as top level function, but made just in case, if one wanted to define something like this: f :: Var Storage -> IndigoM () f storage = do field <- getStorageField let lambda = defNamedLambda1 $ arg -> ... using field here ... The idea is that when we pass this variable in a bind it will be propagated in all expressions, including the ones that are in the lambdas. An error will be raised during a variable lookup. This hack will be rewritten later.indigoCollect all used lambdas in a computation (which might be either a contract body or another function body), which are called at least twice. Only outer functions will be gathered, for instance, if we call lambda func1 from func0, only func0 will be taken.          None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmnindigo8Type of a contract that can be compiled to Lorentz with .indigo!Iteration over Indigo freer monadindigoConvert frontend Freer to .First of all, this function generates the definitions of lambdas, creates the variables that refer to them and calls them in the places where they are used. This happens only for those lambdas that are called at least twice, those that are used only once will be inlined instead.2After that the generation of the body code starts.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 ).indigoVCompile Indigo code to Lorentz contract. Drop elements from the stack to return only  [Operation] and storage. 234LM 43L2MNone7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmW%indigoUtility type for an M that does not modify the stack (only the values in it) and returns nothing.indigoUtility type for an K that adds one element to the stack and returns a variable pointing at it. indigoSCreate 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.0indigoDRun the instruction when the condition is met, do nothing otherwise.1indigo Reverse of 0.4indigo6Run the instruction when the given expression returns ^ a value, do nothing otherwise.5indigo6Run 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.@indigoUse this instead of `.This operator is like ` but wraps a body into y, which is needed for two reasons: to allow having any output stack and to allow returning not exactly the same values.Bindigo Alias for A we use in the tutorial.CindigoA more specific version of B meant to more easily create IndigoContracts.Used in the tutorial. The 3I constraint is specified to avoid the warning for redundant constraints.Dindigo 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 BA. * Your computation is called only once, in this case also use B.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.YPay attention, that lambda argument will be evaluated to variable before lambda calling.STODO Approach with lambda names has critical pitfall: in case if a function takes  Label namey, lambda body won't be regenerated for every different label. So be carefully, this will be fixed in a following issue.Eindigo6Like defNamedEffLambda1 but doesn't make side effects.Findigo2Like defNamedLambda1 but doesn't take an argument.GindigoQLike defNamedEffLambda1 but doesn't modify storage and doesn't make side effects.HindigoWhile statement.Jindigo+For statements to iterate over a container.KindigoPut a document item.LindigorGroup documentation built in the given piece of code into a block dedicated to one thing, e.g. to one entrypoint.MindigohInsert documentation of the contract's storage type. The type should be passed using type applications.NindigoGGive a name to the given contract. Apply it to the whole contract code.Oindigo*Attach general info to the given contract.Pindigo:Attach default general info to the contract documentation.Qindigo0Indigo version for the homonym Lorentz function.VindigoGCreate contract using default compilation options for Lorentz compiler.See  Lorentz.Run.Windigo!Create contract from raw Lorentz ._indigo+Add a comment in a generated Michelson code`indigo+Add a comment in a generated Michelson codeaindigooAdd a comment before and after the given Indigo function code. The first argument is the name of the function.bindigoqAdd a comment before and after the given Indigo statement code. The first argument is the name of the statement.G !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abG !#$%&*+(')".,-/0123456789:<;>=?@ABCGEFDHIJRSKLMNOPQTUVWYXZ[\]^`_ab"0@0 None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm\ O !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abNone7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkme<cindigo4Pretty-print an Indigo contract into Michelson code.dindigoWPrints the pretty-printed Michelson code of an Indigo contract to the standard output.1This is intended to be easy to use for newcomers.eindigoQSaves the pretty-printed Michelson code of an Indigo contract to the given file.1This is intended to be easy to use for newcomers.cindigoForce result to be single linecdecdeNone7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmrindigoDisambiguation type used in j that links a single $ to the numeric type to resolve to.indigoKind used for ) as part of the disambiguation machinery.findigoDefines semantics of if ... then ... else ...; construction for Indigo where the predicate is a generic exa for which IsExpr exa Bool holdsgindigo-Numerical literal disambiguation value for a H, see j.hindigo.Numerical literal disambiguation value for an G, see j.iindigo-Numerical literal disambiguation value for a , see j.jindigo1Defines numerical literals resolution for Indigo.%It is implemented with an additional M argument that disambiguates the resulting type. This allows, for example, 1 int to be resolved to  1 :: Integer.;fghijfjghi;None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmkindigoIndigo version of the viewE macro. It takes a function from view argument to view result and a 2 structure that typically comes from a top-level case.lindigoFlipped version of k2 that is present due to the common appearance of flip view parameter $ instr construction.FSemantically we "project" the given parameter inside the body of the  construction.mindigoIndigo version of the void macro.nindigoFlipped version of m2 that is present due to the common appearance of flip void_ parameter $ instr construction.oindigouIf 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.klmnokmlno!None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm&!%ih&  _`ba'(.-,+*)('&%$#"! ) V*UTQP+,-.}/01\[ZYX23456#"$789:;<= >[`?@ZA\BCDEFGHI^]JcdeK_LMNOPQRSTUabVWXYfjklonmpsrtuwxyz{|~v     /013456789:;<=?@ABCDEFGHIJKLMNO]^cdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./012654387?>=<;:9A@BCIHGFEDKJLMNOPQRSTUVWXY[Z\]_^a`bcdefgjihklmnopqrstuvwxyz{|}~      !"! #$#%&'('&)*+*),-./0/.123456789:=<;@?>BADCFEHGIJKLMNOPQRSTUVWXY\[Z]^_a`bcedfghijklpqrqponmstutvwxyz{|~}      !"#$&()*,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^`abcdefghijkmopqrstuvwxyz{z|}~}     #$%&23456789:;<=>?@ABCDEFGHIJKLMRSTUVWYZ[\]^_`abcdghijklmnopqstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^hijklqr !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmno!%ih&  _`ba'(.-,+*)('&%$#"! ) V*UTQP+,-.}/01\[ZYX23456#"$789:;<= >[`?@ZA\BCDEFGHI^]JcdeK_LMNOPQRSTUabVWXYfjklonmpsrtuwxyz{|~v     /013456789:;<=?@ABCDEFGHIJKLMNO]^cdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./012654387?>=<;:9A@BCIHGFEDKJLMNOPQRSTUVWXY[Z\]_^a`bcdefgjihklmnopqrstuvwxyz{|}~      !"! #$#%&'('&)*+*),-./0/.123456789:=<;@?>BADCFEHGIJKLMNOPQRSTUVWXY\[Z]^_a`bcedfghijklpqrqponmstutvwxyz{|~}      !"#$&()*,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^`abcdefghijkmopqrstuvwxyz{z|}~}     #$%&23456789:;<=>?@ABCDEFGHIJKLMRSTUVWYZ[\]^_`abcdghijklmnopqstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^hijklqr !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmno"None7!"#$%&'*,-.12456789;<=>?@ACHMNPSUVX_`befgkm #$%&'(#)*#)+#,-#,.#$/#$0#12#13#45#67#68#69#6:&;<&;=#1>#$?#$@#$A#$B#CD#EF#4G#4H#4I#4J#KL#$M#$N#$O#$P#$Q#$R#$S#$T#6U#6V&;W#XY#4Z#4[#$\#$]#1^&;_#`a#4b#4c#de#fg#Ch#Ei#$j#kl#mn#op#qr#st#$u#$v&wx&wy&wz&w{&w|#}~#}#}#}##&w#4#4&w&w#######&w#q&w#&w&w&w###4&w##&w&w&w#$&;#6#6#$###$#$#$&;###$#$#$#$#$###########################s#K#K#K#K#K#K#K#K#K#K#K#K#K#K#m#m#m #m #m #m #m #m#m############## #!#"###$%#&'#()#(*#+,#+-#+.#+/#+0#12#13#13#k4#k5#k6#k7#k8#k9#:;#:<#:<#:=#:>#:>#?@#?A#?B#?C#?C#?D#?E#?E#?F#?G#?G#?H#?I#?I#?J#?K#?K#?L#?M#?M#?N#?O#?O#qP#qQ#qR#qR#ST#SU#SV#SW#SX#SY#SZ#S[#S\#S]#S^#S_#S`#Sa#Sb#Sc#Sd#Se#fg#fh#i#j#k#l#m#no#np#np#qr#qr#st#su#sv#sw#sx#Xy#Xz#X{#X|#X}#X~#X#X#X#X#X#X#X#X#X#X#X#####4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#4#6#6#6#6#6#6##)#)#)#)#)#)#)#)#)#)#)#)#)#)#)#)#)################,#,#,##1#1#1#1#1##$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$###? #+,&; &; &; &; &;&;&;&; !"#!"$%&'%&(!")!"*!"+,-./01201301401501601789:;<=>?@?ABCDEFGHIJHIKHILHIMHINHIOHIPHIQHIRHISHITHIUHIVHIWHIXHIYHIYHIZHI[HI\HI]HI^HI_HI`HIaHIbHIcHdeHdfHdgHdhHdiHdjHdkHdlHdmHdnHdoHdpHdqHdqHdrHdsHdsHdtHduHduHdvHdwHdxHdyHdyHdzHd{Hd|Hd}Hd~HdHdHdHdHdHdHdHdHdHdHdHdHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH H H H H H HHHHHHHHHHHHHHHH HH!H"H#H$H%H&H'H(H)*H)+H),H)-H).H)/H)0H)1H)2H)3H)4H)5H)6H)7H)8H)9H):H);H)<H=>H=?H=@H=AH=BH=CH=DH=EH=FH=GHHIHHJHHKHHLHHMHHNHHOHHPHHQHHRHHSHHTHHUHHVHHWHHXHHYHHZHH[HH\HH]HH]HH^HH^HH_HH`HHaHHbHHbHHcHHdHHeHHfHHgHHhHHiHHjHHkHHlHHmHHnHHnHHoHHoHpqHprHpsHptHuvHuwHuxHyzH{|H{}H~H~H~H~H~H~H~H~H~H~H~H~H~HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH H H H  H H HHHHHHHHHHHHHHHHH H!H"#$%#$&#$'()*()+(),-.0-/0()1()234536736738938:3;<3;=3>?3>@3>A3BC3BD3BE3BF3BG3BH3BI3JK3LM3NO3NO3NP3NQ3RS3RS3RT3RU3RV3RW3RX3RX3RY3RY3RZ3RZ3R[3R\3R]3R^3R^3R_3R`3Ra3Rb3Rc3Rc3Rd3Re3Rf3Rg3Rh3Ri3Rj3Rk3Rl3Rm3Rn3Ro3Rp3Rq3Rq3Rr3Rr3Rs3Rs3Rt3Ru3Rv3Rw3Rx3Rx3Ry3Rz3R{3R|3}~3}333333333333333333333333333333333333333333333-/E--.----------------------------------R------------------ - - - - ----------------- -!-"-#-$-%-&-'-(-)-*-+-,---.-/-0-1-2-3-4-5-6-7-8-9-:-;<-;=-;>-;?-;@-;A-BC-BD-BE-FG-FG-FH-FI-FJ-KL-KM-KN-KO-PQ-PR-PS-PT-UV-UW-UX-UY-Z[-\]-\^-\_-\`-\a-\b-\c-\d-\e-\f-/g-/g-/h-/i-/j-/k-/l-/m-/n-/o-p-q-r-s-t-u-v-w-x-y-z-{-|-.}-~-~,-,,,;????????@EEE../8B?@                         ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i C j k l m n z o p q r s t u v w x y z { | } ~              3          <         =        *  )         -  .      7 M            R                                                                   !"#$%&'()*+,-./01234456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU"VWXYZ[\]^_`abcdefghijklmnopqqrstuvwxyz{|}~"#$%78I;<=>?@ABCDEFGH+&()*01J233         H~\""""""""%indigo-0.1.0.0-5znyikYVEwh8P5v7X39s0cIndigo.Backend.PreludeIndigo.PreludeIndigo.LorentzIndigo.Internal.StateIndigo.Internal.ObjectIndigo.Internal.LookupIndigo.Internal.SISIndigo.Internal.FieldIndigo.Internal.Expr.Types Indigo.Internal.Expr.CompilationIndigo.Internal.Expr.SymbolicIndigo.Internal.Expr.DecomposeIndigo.Backend.VarIndigo.FromLorentzIndigo.Backend.ScopeIndigo.Backend.LambdaIndigo.Backend.ConditionalIndigo.Backend.ErrorIndigo.Backend.CaseIndigo.BackendIndigo.Frontend.StatementIndigo.Frontend.ProgramIndigo.Compilation.ParamsIndigo.Compilation.LambdaIndigo.CompilationIndigo.Frontend.Language Indigo.PrintIndigo.Rebinded Indigo.LibIndigo.Internal.ExprIndigo.InternalIndigo.FrontendIndigo Paths_indigobaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip Data.Tuplefstsnd otherwise$GHC.Num fromInteger-GHC.Real fromRationalGHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=negate>>=>>fmapreturnControl.Monad.Failfail Data.String fromString fromIntegral 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.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64integer-wired-inGHC.Integer.TypeInteger GHC.NaturalNatural GHC.MaybeMaybeOrderingRatioRationalIOWordGHC.WordWord8Word16Word32Word64GHC.PtrPtrFunPtr Data.EitherEither ConstraintCmpNat CoercibleGHC.Stack.Types CallStackD#FalseF#NothingJust:%TrueLeftRightLTEQGTString/=maxBoundminBoundideither mtl-2.2.2Control.Monad.Reader.Class MonadReaderasklocalreaderControl.Monad.State.Class MonadStategetputstatebytestring-0.10.10.0Data.ByteString.Internal ByteString Data.Functor<$><|>'hashable-1.3.0.0-CzctMgLWbfP4pv5F2JiKgjData.Hashable.ClassHashable text-1.2.4.0Data.Text.InternalTextconst.4unordered-containers-0.2.10.0-KujsThAgCnwGXBG7PJnkNOData.HashMap.BaseHashMapcontainers-0.6.2.1Data.Map.InternalMapcompareGHC.IO.Handle.FDstdoutGHC.IO.Handle.TypesHandle<* Alternativemplusmzero MonadPlusData.Functor.Compose getComposeCompose Data.VoidvacuousabsurdVoidData.Semigroup mtimesDefaultcycle1 WrappedMonoid getOptionOptionGHC.ExtssortWithData.Bifunctorsecondfirstbimap BifunctorData.List.NonEmptyinitlasttailheadnonEmptyGHC.ExecutionStackshowStackTrace getStackTraceControl.Monad.IO.ClassliftIOMonadIO fromLabelmfilter<$!>unless replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMforever<=<>=>filterMfoldMapDefault fmapDefault mapAccumR mapAccumLforMsequencemapM sequenceAtraverseControl.Applicativeoptional getZipListZipList Control.Arrow&&&Data.Functor.Identity runIdentityIdentitystderrstdin GHC.StackwithFrozenCallStack callStack GHC.Conc.Sync writeTVarreadTVarnewTVarSTMTVar GHC.IORefIORefGHC.IOFilePath GHC.ExceptionprettyCallStack prettySrcLocGHC.Exception.Type SomeExceptiondisplayException fromException toException ExceptionData.Functor.ConstgetConstConst minimumBy maximumBy concatMapconcatfoldlMfoldrM Data.MonoidgetFirstFirstgetLastLastData.Semigroup.Internal stimesMonoidstimesIdempotentgetDualDualappEndoEndogetAllAllgetAnyAnygetSumSum getProductProductgetAltAlt someNatValnatValSomeNat Data.OldListunfoldrsortOnsortBysort permutations subsequencestailsinitsgroupgenericReplicategenericSplitAt genericDrop genericTake genericLength transpose intercalate intersperse isPrefixOf Text.Read readMaybereadsisRightisLeftpartitionEithersrightsleftsData.Ord comparingDown Data.ProxyProxy GHC.IO.IOMode ReadWriteMode AppendMode WriteModeReadModeIOModeatanhacoshasinhtanhcoshsinhatanacosasintancossinlogBase**sqrtexppi byteSwap64 byteSwap32 byteSwap16 Data.BitsxorintegralEnumFromThenTointegralEnumFromTointegralEnumFromThenintegralEnumFromgcdWord'gcdInt'lcmgcd^^%^^^%^^^^oddevennumericEnumFromThenTonumericEnumFromTonumericEnumFromThennumericEnumFrom denominator numeratorreduce notANumberinfinity ratioPrec1 ratioPrecunderflowError overflowErrorratioZeroDenominatorError divZeroErrordivModquotRemmoddivremquotrecip/floorceilingroundtruncateproperFractionboundedEnumFromThenboundedEnumFromfromEnumtoEnumpredsuccGHC.Charchrunzip3unzipzipWithzip3reversebreaksplitAtdroptake dropWhile takeWhilecycle replicaterepeatiteratescanrscanl Data.MaybemapMaybe catMaybes listToMaybe maybeToList fromMaybe isNothingisJustmaybe Data.Boolbool Data.Function&onfixvoid$><&>swapuncurrycurryGHC.MVarMVarsubtractsignumabs*+ GHC.Stack.CCScurrentCallStackasTypeOfflipmaxIntminIntordapliftM5liftM4liftM3liftM2when=<<liftA3<**>stimessconcat<$liftA2manysomeempty:|NonEmpty getCallStack HasCallStackstimesIdempotentMonoid<<=>maxmin&&||nottransformers-0.5.6.2Control.Monad.Trans.Identity IdentityT runIdentityT)constraints-0.11.2-8EHfvWmM9iq8fMaw1jmWHKData.ConstraintwithDictData.IntMap.InternalIntMapData.IntSet.InternalIntSetData.Sequence.InternalSeqData.Set.InternalSetdeepseq-1.4.4.0Control.DeepSeqrnfNFData1data-default-class-0.1.2.0-Hn6rbGElvv4B4VdN5m2X0WData.Default.ClassDefaultdefforce$!!deepseqControl.Monad.Trans.MaybeMaybeTControl.Monad.Trans.ExceptExceptT(exceptions-0.10.4-6ENJVzINLe28VlhOUrvEZKControl.Monad.Catch MonadThrow MonadCatchgeneralBracketuninterruptibleMaskmask MonadMaskControl.Monad.Trans.Classlift hashWithSaltData.Text.LazytoStrictData.HashSet.BaseHashSet Control.Monad.Trans.State.StrictStateTState&vector-0.12.1.2-AWRYcz9jfa25Avs2q9Jg9V Data.VectorVectorControl.Monad.Trans.ReaderReadergets$lorentz-0.4.0-C2OnstBqPq2JOxQuyTh5K3Lorentz.UParam pbsUParam uparamFromAdt caseUParamT caseUParamuparamFallbackFail unwrapUParammkUParamEntryPointKind?: UParamUnsafeUParam SomeInterfaceUParam_LookupEntryPointRequireUniqueEntryPointsConstrainedSome unpackUParam UnpackUParamArgumentUnpackFailedNoSuchEntryPointEntryPointLookupErrorEntryPointsImplUParamFallback CaseUParamUParamLinearizeUParamLinearizedLorentz.EntryPoints.DocentryCaseSimple_areFinalizedParamBuildingStepsdocumentEntryPointclarifyParamBuildingStepsmkDEntryPointArgSimple mkDEpUType emptyDEpArgconstructDEpArg mkPbsWrapIndiEntryPointToMarkdowndepSubdepName DEntryPointPlainEntryPointsKindDEntryPointReferenceunParamBuilder ParamBuilder pbdMichelson pbdHaskell pbdEnglishParamBuildingDesc PbsUncallable PbsCustomPbsCallEntrypoint PbsWrapInParamBuildingStepepaType epaBuildingepaArgDEntryPointArgderiveCtorFieldDocDeriveCtorFieldDocDocumentEntryPoints#-> EntryArrowRequireFlatParamEpsRequireFlatEpDerivationLorentz.StoreClass mkStoreEpcomposeStoreEntrypointOpscomposeStoreSubmapOpscomposeStoreFieldOpsstoreEntrypointOpsReferTostoreFieldOpsReferTostoreSubmapOpsReferTostoreEntrypointOpsDeeperstoreSubmapOpsDeeperstoreFieldOpsDeeperstoreEntrypointOpsSubmapFieldstoreEntrypointOpsFieldsstoreEntrypointOpsADTstoreFieldOpsADT stSetEpStore stGetEpStore stToEpStore stSetEpLambda stGetEpLambda stToEpLambda stEntrypoint stInsertNewstInsertstDeletestUpdatestGetstMem stSetField stGetField stToField sopSetField sopToField StoreFieldOps storeFieldOps StoreHasField sopInsert sopDelete sopUpdatesopGetsopMemStoreSubmapOpsstoreSubmapOpsStoreHasSubmapEntrypointLambdaEntrypointsField sopSetEpStore sopToEpStoresopSetEpLambda sopToEpLambdaStoreEntrypointOps storeEpOpsStoreHasEntrypoint~>::->StorageContains Lorentz.ADT unwrapUnsafe_wrap_ fieldCtor deconstructconstructStack modifyField getFieldNamedgetField toFieldNamedtoFieldHasFieldOfType NamedField:=HasFieldsOfType CaseClauseL/-> CaseArrowCaseTCLorentz.Errors.Numeric.DocbaseErrorDocHandlersvoidResultDocHandlercustomErrorDocHandlerapplyErrorTagToErrorsDocWithapplyErrorTagToErrorsDoc detmSrcLocDDescribeErrorTagMapNumericErrorDocHandlerErrorNumericErrorDocHandlerNumericErrorWrapperLorentz.UStore.Haskell fillUStoreustoreDecomposeFullustoreDecomposemkUStore MkUStoreTWDecomposeUStoreTW FillUStoreTWLorentz.UStore.Migration.Blocks mustoreToOldmigrateModifyFieldmigrateOverwriteFieldmigrateExtractFieldmigrateRemoveFieldmigrateAddFieldmigrateGetFieldLorentz.UStore.InstrustoreSetFieldustoreGetField ustoreToField ustoreDeleteustoreInsertNew ustoreInsert ustoreUpdate ustoreGet ustoreMem HasUStore HasUFieldHasUStoreForAllIn Lorentz.Macro voidResultTagViewVoid_ VoidResultLorentz.UStore.Lift unliftUStore liftUStoreLorentz.UStore.Migration.BasemigrationToScriptmigrationToScriptImkUStoreMigrationmigrationToLambdaUStoreMigrationunMigrationScriptMigrationScriptMigrationScript_Lorentz.UStore.DocustoreTemplateDocDependenciesustoreTemplateDocContentsustoreTemplateDocDescriptionustoreTemplateDocNameUStoreTemplateHasDocustoreMarkerKeyEncodingUStoreMarkerHasDocLorentz.UStore.TraversalUStoreTraversableLorentz.UStore.TypesUStoreunUStoreSubMap UStoreSubMap|~> unUStoreField UStoreFieldUStoreFieldExtUStoreMarkerTypemkFieldMarkerUKeyShowUStoreFieldKnownUStoreMarker GetUStoreKeyGetUStoreValueGetUStoreFieldGetUStoreFieldMarkerPickMarkedFieldsLorentz.Coercions castDummyGallowCheckedCoerceallowCheckedCoerceTocheckedCoercing_checkedCoerce_ checkedCoerce fromNamedtoNamed coerceUnwrap coerceWrap fakeCoercing fakeCoercegForcedCoerce_ forcedCoerce_ forcedCoerceMichelsonCoercible castDummy CanCastTo Coercible_Lorentz.Errors.Numeric.ContracterrorFromValNumericuseNumericErrorsapplyErrorTagMapWithExclusionsapplyErrorTagMapexcludeErrorTagsbuildErrorTagMapaddNewErrorTagsgatherErrorTags ErrorTagMapErrorTagExclusionsLorentz.Errors typeDocMdDescriptionReferToErrorerrorTagToTexterrorTagToMTextcustomErrorDocHaskellRepGeneralfailUnexpected failUsingisoErrorFromVal isoErrorToVal errorFromVal errorToValIsErrorerrorDocRequirementserrorDocDependencies errorDocClasserrorDocHaskellReperrorDocMdCauseInEntrypointerrorDocMdCause errorDocNameErrorRequirements ErrorHasDocUnspecifiedError SomeErrorErrorArgceArgceTag CustomErrorRequireNoArgErrorErrClassUnknownErrClassContractInternalErrClassBadArgumentErrClassActionException ErrorClasscustomErrArgumentSemanticscustomErrClasscustomErrDocMdCauseInEntrypointcustomErrDocMdCauseCustomErrorHasDocDErrorDThrows Lorentz.DoccutLorentzNonDocrenderLorentzDocbuildLorentzDocWithGitRevbuildLorentzDocLorentz.ReferenceddropTdipTdupT Lorentz.InstrNonZero Lorentz.PrintprintLorentzContractprintLorentzValue Lorentz.RunanalyzeLorentzinterpretLorentzLambdainterpretLorentzInstrcompileLorentzContractdefaultContractcompileLorentzWithOptionscompileLorentzdefaultCompilationOptionscoBytesTransformercoStringTransformercoOptimizerConfCompilationOptionsLorentz.EntryPoints.ManualunParameterWraperParameterWrapperLorentz.Wrappable Unwrappable Wrappable Lorentz.Arith ArithResHs ArithOpHsUnaryArithResHsUnaryArithOpHsLorentz.EntryPoints.ImplEpdPlain EpdRecursive EpdDelegate Lorentz.ValueListLorentz.Polymorphic MemOpKeyHsMemOpHs IsoMapOpRes MapOpResHs MapOpInpHsMapOpHs IterOpElHsIterOpHsSizeOpHs UpdOpParamsHs UpdOpKeyHsUpdOpHs GetOpValHs GetOpKeyHsGetOpHs ConcatOpHs SliceOpHs EModOpResHs EDivOpResHsEDivOpHs Lorentz.Pack lEncodeValue lUnpackValue lPackValue Lorentz.Ext stackType testAssert printCommentstackRefLorentz.AddressconvertContractRefcallingDefTAddresscallingTAddress unTAddressTAddressunFutureContractFutureContract toAddress ToAddress toTAddress ToTAddress toContractRef ToContractReffromContractRefFromContractRefLorentz.Common Entrypoint Entrypoint_ Lorentz.BaseoptimizeLorentzoptimizeLorentzWithConftransformBytesLorentztransformStringsLorentzparseLorentzValue###iWithVarAnnotations iForceNotFail iMapAnyCodeiNonFailingCodeiAnyCode iGenericIfIFIunLorentzInstr LorentzInstr:->%> ContractOut ContractCodeSomeContractCodeLambdamapLorentzInstrMapLorentzInstrLorentz.Constraints.DerivativeNiceParameterFullLorentz.EntryPoints.CoreparameterEntryPointCallCustomeprNamesepcCallRootCheckedparameterEntryPointCallDefaultparameterEntryPointCallparameterEntryPointsToNotesepdDescsepdCallepdNotesEpdLookupEntryPointEpdAllEntryPointsEntryPointsDerivationRequireAllUniqueEntryPointsParameterEntryPointsDerivationParameterHasEntryPointsParameterDeclaresEntryPointsAllParameterEntryPointsLookupParameterEntryPointGetEntryPointArgGetDefaultEntryPointArgForbidExplicitDefaultEntryPointNoExplicitDefaultEntryPointCall CallDefault EntryPointRefGetEntryPointArgCustomuseHasEntryPointArgHasEntryPointArgHasDefEntryPointArg TrustEpNameHasEntryPointOfType:>ParameterContainsEntryPointsEpdNoneLorentz.EntryPoints.HelpersunHasEntryPointsShouldHaveEntryPointsLorentz.Constraints.ScopesnicePrintedValueEviniceUnpackedValueEvinicePackedValueEviniceConstantEviniceStorageEviniceParameterEvi KnownValue NoOperationNoContractTypeNoBigMap CanHaveBigMap NiceParameter NiceStorage NiceConstantNicePackedValueNiceUnpackedValueNiceFullPackedValueNicePrintedValueNiceComparable#vinyl-0.12.1-5AwmFwPZtvbFH6BYFlWmMmData.Vinyl.CoreRecRNil:&$named-0.3.0.1-KR6CzcWiesR2FBWuXAfEa6Named.InternalargargFargDef&universum-1.6.1-9S3REjxS97oDtyplhqPK9gUniversum.TypeOpsUniversum.Debug undefined:!:?#morley-1.4.0-Dt8DNWWrU396MKHMT2Jwmb Util.MarkdownMarkdown Util.LabelLabelMichelson.Untyped.EntryPointsEpName DefEpNameMichelson.TextMTextmt Tezos.CryptoKeyHash Signature PublicKey Tezos.CoreChainId TimestampMuteztoMuteztimestampFromSecondstimestampFromUTCTimetimestampQuote Tezos.AddressAddressMichelson.Typed.ExtractmkUTypeMichelson.Typed.EntryPoints EpAddress eaAddress eaEntryPoint Michelson.Doc ContractDoc cdContents cdDefinitionscdDefinitionsSetcdDefinitionIdsSubDocSomeDocDefinitionItem SomeDocItemDocSectionNameStyleDocSectionNameBigDocSectionNameSmall DocItemRef DocItemNoRefDocItemPlacementKindDocItemInlinedDocItemInDefinitions DocItemIdDocItemDocItemPositionDocItemPlacementdocItemSectionNamedocItemSectionDescriptiondocItemSectionNameStyle docItemRefdocItemToMarkdowndocItemDependencies docItemsOrderdocItemPositiondocDefinitionRefsubDocToMarkdownDAnchorDCommentGitRepoSettingsgrsMkGitRevision DGitRevisionDGitRevisionKnownDGitRevisionUnknown DDescription DocGroupingcontractDocToMarkdownmorleyRepoSettingsmkDGitRevisionMichelson.Typed.Aliases OperationValueMichelson.Typed.Haskell.ValueBigMapunBigMap ContractRef crAddress crEntryPointWellTypedIsoValueSomeEntryPointCallEntryPointCallIsoValueToTtoValfromValcoerceContractRef%Michelson.Typed.Haskell.Instr.ProductInstrConstructCConstructorFieldTypesMichelson.Typed.Haskell.Doc IsHomomorphicHaveCommonTypeCtorDTypeSomeTypeWithDoc TypeHasDocTypeDocFieldDescriptions typeDocNametypeDocMdDescriptiontypeDocMdReferencetypeDocDependenciestypeDocHaskellReptypeDocMichelsonRepdTypeDepcustomTypeDocMdReferencehomomorphicTypeDocMdReferencepoly1TypeDocMdReferencepoly2TypeDocMdReferencegenericTypeDocDependencieshomomorphicTypeDocHaskellRepconcreteTypeDocHaskellRepconcreteTypeDocHaskellRepUnsafehaskellRepNoFieldshaskellRepStripFieldPrefixhomomorphicTypeDocMichelsonRepconcreteTypeDocMichelsonRep!concreteTypeDocMichelsonRepUnsafeerror)microlens-0.4.11.2-IwTHxwi8Eg8Dsmorq23zza Lens.Micro^?^..^.set.~over%~Lens.Micro.Internal_1_2_3_4_5Lens.Micro.TypeLensLens' Traversal Traversal'modifyasksReaderT,microlens-mtl-0.2.0.1-JS2xcS8Sa3eBzmmc9knuGVLens.Micro.MtlpreuseusepreviewviewUniversum.String.ConversionshowEachUniversum.ApplicativepassUniversum.Base$!Universum.Functor.Fmapmap<<$>>Universum.Lifted.Concurrent newEmptyMVarnewMVarputMVarreadMVarswapMVartakeMVar tryPutMVar tryReadMVar tryTakeMVar atomically newTVarIO readTVarIOUniversum.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 usingStateevaluatingStateTevaluatingStateexecutingStateTexecutingStateUniversum.Monoid maybeToMonoidUniversum.Container.ClassOneOneItemone ContainerElementtoListnullfoldrfoldlfoldl'lengthelemmaximumminimumfoldMapfoldfoldr'foldr1foldl1notElemallanyandorfindsafeHeadToPairstoPairskeyselems flipfoldl'sumproduct traverse_for_mapM_forM_ sequenceA_ sequence_asumUniversum.Monad.Container concatMapM concatForMandMorMallManyMUniversum.List.Safeuncons whenNotNull whenNotNullMUniversum.ExceptionBugExcbugnoteUniversum.DeepSeq evaluateWHNF evaluateWHNF_ evaluateNF evaluateNF_Universum.Bool.GuardwhenMunlessMifMguardM Universum.NubordNubhashNubsortNub unstableNubUniversum.Print.InternalPrintUniversum.PrinthPutStr hPutStrLnputStrputStrLnprinthPrintputText putTextLnputLText putLTextLn Undefinedtrace traceShow traceShowId traceIdWithtraceShowIdWith traceShowMtraceMtraceIdToStringtoStringToLTexttoLTextToTexttoText ConvertUtf8 encodeUtf8 decodeUtf8decodeUtf8Strict LByteStringLText readEitherWithUniversum.VarArgSuperComposition... runMaybeTmaybeToExceptTexceptToMaybeTData.Text.Encoding.ErrorUnicodeException OnDecodeErrorOnError strictDecode lenientDecodeData.Text.EncodingdecodeUtf8With decodeUtf8' Data.Textwordslinesunlinesunwords fromStrict stm-2.5.0.0Control.Concurrent.STM.TVar modifyTVar'.safe-exceptions-0.1.7.0-8Qc6QJ74Kec9lSAC96AGtOControl.Exception.SafethrowMcatchcatchAny handleAnytrytryAny onExceptionbracketbracket_finallybracketOnError execStateT evalStateT withState execState evalStaterunState runStateT runReader runReaderT runExceptTmodify' MonadTransGenCodegcOutgcMetagcCodegcClear DefaultStackMetaDatamdStack mdRefCount StackVarsStkElNoRefRefRefId IndigoStaterunIndigoStateusingIndigoStateigetiput emptyMetadata cleanGenCode$fTestEqualityTYPEStkEl$fDefaultMetaData$fDefaultMetaData0 $fShowRefId$fGenericRefId $fEqRefId $fOrdRefId $fRealRefId $fNumRefId$fFunctorGenCode$fFunctorIndigoState HasStorageHasSideEffectsOpsComplexObjectC FieldTypesIsObject TypedFieldVarVar NamedFieldVar unFieldVar IndigoObjectFCell DecomposednamedToTypedRectypedToNamedReccastFieldConstructorsnamedToTypedFieldVartypedToNamedFieldVarcomplexObjectDict withVarAt makeTopVar pushRefMd pushNoRefMd popNoRefMd operationsVar storageVar$fIsObject'ProductTypeDa$fIsObject'SumTypeDa$fIsObject'PrimitiveDa $fIsObjecta varActionGet varActionSetvarActionUpdatevarActionOperationrtakerdrop$fTestEqualityTTValSomeIndigoStateunSIS SomeGenCode returnSISbindSISrunSIStoSISwithSISwithSIS1withSIS2$fFunctorSomeIndigoState$fFunctorSomeGenCodeHasField fieldLens FieldLens TargetField DeeperField AccessFieldC fetchField assignFieldflSFO fieldLensADTfieldLensDeeper$fHasFielddtfnameftype IsSizeExpr IsMemExpr IsUpdExpr IsGetExpr IsSliceExprIsConcatListExpr IsConcatExpr IsModExpr IsDivExpr IsArithExprIsUnaryArithExprToExprExprTypeAreExprs:~>IsExpr ObjectExprNamedFieldExprunNamedFieldExprObjectManipulationObjectToFieldSetFieldExprCVObjManCastSizeUpdateAddSubMulDivModAbsNegLslLsrEq'NeqLeLtGeGtOrXorAndNotInt'IsNatFstSndPairSomeNoneRight'Left'MemUGet UInsertNewUInsertUMemUUpdateUDelete ConstructConstructWithoutNamedNameUnNameEmptySetGetEmptyMap EmptyBigMapPackUnpackConsNilConcatConcat'SliceContractSelfContractAddressContractCallingUnsafeRunFutureContractImplicitAccountConvertEpAddressToContractMakeViewMakeVoidCheckSignatureSha256Sha512Blake2bHashKeyNowAmountBalanceSenderExectoExpr$fToExpr'ExprDExpr"$fToExpr'ObjManDObjectManipulation$fToExpr'ValDa$fToExpr'VarDIndigoObjectF $fToExprxObjManipulationRes StillObjectOnStack compileExprrunObjectManipulation ternaryOpbinaryOpunaryOp nullaryOp ternaryOpFlat binaryOpFlat unaryOpFlat nullaryOpFlat compileToExprremoveinsert constExprvarExprcastaddsubmul%negeqneqltgtlegeisNattoIntnonZerolsl<<<lsr>>>packunpackpaircarcdrnonerightleftslicecons.: concatAllnilupdatememsize#:!:+:-: emptyBigMapemptyMapemptySetuGet#@uUpdate!@uInsert+@ uInsertNew++@uDelete-@uMem?@#!!!nameunName!~#~ construct constructReccontractselfcontractAddresscontractCallingUnsafecontractCallingStringrunFutureContractimplicitAccountconvertEpAddressToContractmakeViewmakeVoidnowamountsendercheckSignaturesha256sha512blake2bhashKeychainIdbalance$fExprMagmaSet$fExprMagmaMap$fExprMagmaBigMap$fExprInsertableSetexKey$fExprInsertableMap(,)$fExprInsertableBigMap(,)$fExprRemovableSet$fExprRemovableMap$fExprRemovableBigMapExprDecomposition ExprFields Deconstructed decomposeExprdeepDecomposeComposenewVarsetVarsetField updateVargenFromLorentzFunNfromLorentzFunN ScopeCodeGenReturnableValueRetExprsRetVars RetOutStack ScopeCodeGen'compileScopeReturn' liftClear' genGcClear'ReturnableValue' RetOutStack'RetVars' RetExprs' allocateVars'ClassifyReturnValue BranchRetKindUnit SingleValTuple allocateVars liftClear compileScopefinalizeStatement$fReturnableValue'Unit()$fScopeCodeGen'Unit()$fScopeCodeGen'Tuple(,,)$fReturnableValue'Tuple(,,)$fScopeCodeGen'Tuple(,)$fReturnableValue'Tuple(,)$fScopeCodeGen'SingleValsingle!$fReturnableValue'SingleValsingleLambdaExecutor LambdaCreatorLambda1GenericExecuteLambdaEff1CCreateLambdaEff1C LambdaEff1ExecuteLambda1CCreateLambda1CLambda1ExecuteLambdaPure1CCreateLambdaPure1C LambdaPure1createLambdaPure1executeLambdaPure1initMetaDataPure createLambda1executeLambda1 initMetaDatacreateLambdaEff1executeLambdaEff1initMetaDataEff IfConstraintif_ifSomeifRightifConsfailWith failUsing_ failCustom failCustom_failUnexpected_assert assertSome assertNone assertRight assertLeft assertCustom assertCustom_ CaseCommon CaseCommonF IndigoAnyOutIndigoCaseClauseL#=caseRec entryCaseRecentryCaseSimpleRec"$fCaseArrowname->IndigoCaseClauseLwhile whileLeftforEachdocdocGroup docStorage contractNamecontractGeneralcontractGeneralDefaultfinalizeParamCallingDoc selfCallingcontractCallingtransferTokens setDelegatescopecommentfromLorentzFun1fromLorentzFun2fromLorentzFun3fromLorentzFun1VoidfromLorentzFun2VoidfromLorentzFun3Void StatementFLiftIndigoStateNewVarSetVarVarModificationLambdaPure1Call Lambda1CallLambdaEff1CallScopeIfIfSomeIfRightIfConsCase EntryCaseEntryCaseSimpleWhile WhileLeftForEach ContractNameDocGroupContractGeneralFinalizeParamCallingDocTransferTokens SetDelegateCreateContractContractCallingFailWithAssert FailCustomIndigoMCaseClauseLOneFieldIndigoMCaseClauseLIndigoM unIndigoMProgramDoneInstrBindinterpretProgram$fMonadProgram$fApplicativeProgram$fFunctorProgram$fFunctorIndigoM$fApplicativeIndigoM$fMonadIndigoMAreIndigoParamsIndigoWithParamsfromIndigoWithParams Lambda1DefLambdaPure1Def LambdaEff1Def_ldProxy_ldName_ldBodyCompiledLambda _clProxyRes_clName _clVarLamcollectLambdas$fOrdLambda1Def$fEqLambda1DefIndigoContract compileIndigocompileIndigoContractIndigoEntrypointIndigoProcedureIndigoFunctionliftIndigoStatenew=:+=-=*=||=&&=^=<<<=>>>=setStorageFieldupdateStorageFieldgetStorageFieldifNonewhenSomewhenNoneifLeftcase_ entryCaseentryCaseSimple//-> defFunction defContractdefNamedEffLambda1defNamedLambda1defNamedLambda0defNamedPureLambda1createContractcreateLorentzContract justCommentcommentAroundFuncommentAroundStmtprintIndigoContractprintAsMichelsonsaveAsMichelson ifThenElsenatintmutezview_projectvoid_ projectVoidsubGt0 TypeDecision IsObject'MapGFTTValMichelson.Typed.TT TValStackVarDepth Util.PeanoPeano%singletons-2.6-8HaHZGUf8l7ErZBDUigN7kData.Singletons.InternalSingduupXVar replaceNVar updateNVarvarDepth objToExprcompileObjectFcompileObjectManipulation exprToManRes ExprRemovableExprInsertabledecomposeObjectFdeconstructOnStack noRefGenCodecreateLambda1GenericexecuteLambda1GenericassignVarToOps leakedVarcompileIndigoMsimpleCompileIndigoMNumTypeNumKindversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName