#/p      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLM N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmno$None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmb!%]\&  ^_a`'(+*)('&%$#"! ) TS*RQPONM+,- .z/01YXWVU23456#"$}789:;<= >[`?@ZA\BCDEFGHI]^JcdeK_LMNOPQRSTUabVWXYfghkjilmonpqstuvwxy{|~r     ,-./0123456789:;<=>?@ABCDEFGHIJKLZ[bcdefghijklmnopqrstuvwxyz{|}~     #!" %$'&)(*+,-./0123546789:;<=>?@ABCDEFGHIJKLMNOQPRSTUVWXYZ[\]^_`abcdhfeg~~}{sxtz|ypqvulkmnwojri!%]\&  ^_a`'(+*)('&%$#"! ) TS*RQPONM+,- .z/01YXWVU23456#"$}789:;<= >[`?@ZA\BCDEFGHI]^JcdeK_LMNOPQRSTUabVWXYfghkjilmonpqstuvwxy{|~r     ,-./0123456789:;<=>?@ABCDEFGHIJKLZ[bcdefghijklmnopqrstuvwxyz{|}~     #!" %$'&)(*+,-./0123546789:;<=>?@ABCDEFGHIJKLMNOQPRSTUVWXYZ[\]^_`abcdhfeg~~}{sxtz|ypqvulkmnwojriNone7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmz\W>[`GHI]^py      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqghrstuvwxy{z|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABABCDDEGFFGHIIJLMKLMNOPQRQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~W>[`GHI]^py      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqghrstuvwxy{z|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABABCDDEGFFGHIIJLMKLMNOPQRQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm indigo%Allows to get a variable with storageindigo(Allows to get a variable with operationsindigo0A variable referring to an element in the stack.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 cellindigoGiven 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.indigoDPush a new stack element with a reference to it, given the variable.indigo3Push a new stack element without a reference to it.indigo\Remove 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 operationsindigo;Return a variable which refers to a stack cell with storageNone7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm* pindigo.Decide whether type is either primitive or ADTqindigo5Type class instantiated for all possible Indigo types indigoLike +, but this one doesn't keep name of a fieldindigoHAuxiliary datatype to define a Objiable. Keeps field name as type paramrindigoLAuxiliary type family to convert list of field names to list of field typesindigoyA 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.indigoGDecomposed 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 oneindigo@Convert a list of fields from type-based list to named-based one        None8!"#$%&'*+,-./12456789;<=>?@ACHMNPSUVX_`befgkmB"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).nIndigoState 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.0indigoThen for rebindable syntax.1indigoPut new ".2indigo The simplest ,7, it does not modify the stack, nor the produced code.3indigo@Assigns a variable to reference the element on top of the stack.6indigoUtility function to create ,! that need access to the current .9indigo version for ':indigo version for ';indigo version for '<indigofProduces the generated Lorentz code that cleans after itself, leaving the same stack as the input oneq"#$%&'()*+,-./0123456789:;<,-./0q123456+'()*789:;"#$%&<None7!"#$%&'*+,-.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 xleton=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 I 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.yindigoLike = , but requires the depth of the  in the input stackzindigoLike > , but requires the depth of the  in the input stack{indigoLike ? , but requires the depth of the  in the input stack|indigoCalculates the v of the given  in the stack=>?@AB=>?@ABNone7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm!%]\&  ^_a`'(+*)('&%$#"! ) S*RQNM+,-.z/01YXWVU23456#"$}789:;<= >[`?@ZA\BCDEFGHI]^JcdeK_LMNOPQRSTUabVWXYfghkjilonpqstuvwxy{|~r     ,-.0123456789:<=>?@ABCDEFGHIJKLZ[bcdefghijklmnopqrstuvwxyz{|}~     #!" %$'&)(*+,-./0123546789:;<=>?@ABCDEFGHIJKLMNOQPRSTUVWXYZ[\]^_`abcdhfeg~~}{sxtz|ypqvumnwojri!%]\&  ^_a`'(+*)('&%$#"! ) S*RQNM+,-.z/01YXWVU23456#"$}789:;<= >[`?@ZA\BCDEFGHI]^JcdeK_LMNOPQRSTUabVWXYfghkjilonpqstuvwxy{|~r     ,-.0123456789:<=>?@ABCDEFGHIJKLZ[bcdefghijklmnopqrstuvwxyz{|}~     #!" %$'&)(*+,-./0123546789:;<=>?@ABCDEFGHIJKLMNOQPRSTUVWXYZ[\]^_`abcdhfeg~~}{sxtz|ypqvumnwojriNone7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmZDindigo,b with hidden output stack, necessary to generate typed Lorentz code from untyped Indigo frontend.Gindigo" with hidden output stackIindigoTo run D you need to pass an handler of "$ with any output stack and initial '.JindigoConvert , to DKindigo Similar to a >> for D.Lindigo Modify the " inside a D by passing an handler of " that returns a G8. Useful in some cases to "wrap" or update and exising G. DEFGHIJKL DEFGHJIKL None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmj Mindigo Class like * type class but holding a lens to a field.OindigoLens 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.Rindigo/Constraint to access/assign field stored in RecSindigoGet a field from list of fieldsTindigoAssign a field to a valueUindigo Access to Vindigo,Build a lens to a direct field of an object.Windigo*Build a lens to deeper field of an object.XindigoDefault instance for datatype and its direct field name. It will be useful unless you want to refer to a field using a custom name. MNOPQRSTUVW RSTOPQUMNWV None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmiindigoiAuxiliary datatype where each field refers to an expression the field equals to. It's not recursive one.lindigo?Datatype describing access to an inner fields of object, like Bobject !. field1 !. field2 ~. (field3, value3) ~. (field4, value4)jYZ[\]^_`abcdefghijklmonpz{qtux|w~y}rsvjpz{qtux|w~y}rsvgdefbc_^a`\ZY][lmonhijk None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmindigo( represents a postponed compilation of l datatype. When l 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 l; datatype to a cell on the stack. This function leverages % to put off actual field compilation.~indigoConvert arbitrary  into p- with respect to given converter for fields.indigoCompile M to a stack cell, with respect to given function that compiles inner fields.indigouThis 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 s3 constructor, but we take care of it just in case. None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm&indigo'Datatype representing decomposition of p.indigoAlike D& datatype but without objects argumentindigo~For given element on stack, generate code which decomposes it to list of its deep non-decomposable fields. Clean up code of D composes the value back.indigoADecompose (shallowly) an expression to list of its direct fields.indigoDecompose any & with regards to decomposer for field.indigoADeconstruct top element of the stack and return it wrapped into  constructor.indigo7Push the passed stack cells without references to them.  None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm)KindigoGeneric generator of failing ,# from failing Lorentz instructions.None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm9indigo<Expression class to remove an element from a data structure.!Note that while this is based on ! and PF, 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 PF, 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 (y and ) as well as key only ().indigo(Create an expression holding a variable.indigovConvert between types that have the same Michelson representation and an explicit permission for that in the face of  constraint.indigoRConvert between expressions of types that have the same Michelson representation.v      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUv      !"#$%&'()*+,.0246-/135789;:<=>?@ABCDEFGHIJKLMNRPQSTUO!66777444444882 3 265$8%8&8'8(8-8/818385878:8;8>8?8 None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmA YZ[\]^_`abcdefghijklmonpz{qtux|w~y}rsv      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU!None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmGkNq    "#$%&'()*+,-./0123456789:;<=>?@ABDEFGHIJKLMNOPQRSTUVWYZ[\]^_`abcdefghijklmonpz{qtux|w~y}rsv      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUNone7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmY_indigoKAssign 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.aindigo7Set the field (direct or indirect) of a complex object.bindigoJCall binary operator with constant argument to update a variable in-place._`ab_`abNone7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmhindigoTType 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 iindigoqProduces an Indigo computation that puts on the stack the evaluated returned expressions from the leaving scope.jindigozDrop the stack cells that were produced in the leaving scope, apart from ones corresponding to the returning expressions.kindigo Generate & for the whole statementlindigoLClass for values that can be returned from Indigo statements. They include () and tuples.mindigo^Type family reflecting the top elements of stack produced by a statement returning the value.nindigo<Type family reflecting the returning value from a statement.oindigoTuple 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.pindigoeAllocate variables referring to result of the statement. Requires an allocator operating in a Monad.qindigo^Push the variables referring to the result of the statement on top of the stack of the given .rindigo2This type family returns a promoted value of type sJ or causes a compilation error if a tuple with too many elements is used.sindigopTo 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.tindigo(If value is unit (don't return anything)uindigo"If it's a single value (not tuple)vindigo6If it's tuple (we don't care how many elements are in)windigo#Specific version of 'allocateVars''xindigo Specific version of 'liftClear''yindigopConcatenate a scoped code, generation of returning expressions, and clean up of redundant cells from the stack.zindigoPush variables in the 8, referring to the generated expressions, and generate & for the whole statement.indigo$Utility function to compile from an gcdefghijklmnopqrstvuwxyzstvuchijkdlmnopqgferxywzNone7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm/ indigo=Describes kind of lambda: pure, modifying storage, effectfullindigoEProvide common constraints that are presented in all constructors of indigo Execute lambda depending on its indigo'Create initial stack vars depending on indigo{Create a lambda, that takes only one argument, from the given computation, and return a variable referring to this lambda.indigoHExecute a lambda, which accepts only one argument, on passed expression.indigoHExecute 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.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)None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmeindigoIf 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.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 flowindigo@Variable for the "head" value (available to the next code block)indigo@Variable 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)None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmÇ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 r 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.indigoAVariable 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)None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmm indigoWhile statement.indigoFWhile-left statement. Repeats a block of code as long as the control U is a, returns when it is b.indigo+For statements to iterate over a container.indigoPut a document item.indigorGroup documentation built in the given piece of code into a 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.indigoGGive 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)Q_`abcdefghijklmnopqmnorstvuwxyzNone7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmCindigo#StatementF functor for Freer monad.MThe constructors correspond to every Indigo statement that has expressions (p 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@Analogous datatype as IndigoCaseClauseL from Indigo.Backend.Case%%None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmindigo8Type 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).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 it  None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm`findigo2Representation 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 indigo&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 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 P. 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.indigoLJust 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.indigoGCreates 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 D.indigoTranslation from a single  to a D.indigoLConvert 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.indigoaApplies the given monadic function giving it the inner code block of each case clause, in order.indigo6Input variable (accessible to the branch's code block)indigoCode block for this branchindigoReturn value of this branchindigoQKind of lambda (pure, storage modification, fully functional lambda with effects)indigoName of the lambdaindigo"Expression for the lambda argumentindigoDVariable 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 codeindigoDVariable 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 flowindigo@Variable for the "head" value (available to the next code block)indigo@Variable 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 ((None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmrindigovContains 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 m 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 ExecD, provided there is a known variable for an already created lambda.None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmt  None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmindigo=Typeable and stack size constraints for the parameters of an .indigow equivalent of   indigo=Typeable and stack size constraints for the parameters of an   and for converting to a w 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 x indigo Converts an   to its form without input s, alongside the 6 to use it with and the first available (unassingned) .indigow version of  indigo Converts an  to the equivalent 8 with the storage, parameter and ops list as arguments.      None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm%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  ).indigoSpecialiasation of  without var decompositions.indigoVCompile Indigo code to Lorentz contract. Drop elements from the stack to return only  [Operation] and storage.None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmL)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.%indigoDRun 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.0indigo=A case statement for indigo. See examples for a sample usage.1indigo0 for tuples.2indigo0# for pattern-matching on parameter.3indigo2 for tuples.5indigo An alias for 6& kept only for backward compatibility.6indigoUse this instead of .This operator is like  but wraps a body into  IndigoAnyOuty, which is needed for two reasons: to allow having any output stack and to allow returning not exactly the same values.vIt 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.8indigo Alias for 7 we use in the tutorial.9indigoA more specific version of 8 meant to more easily create s.Used in the tutorial. The I 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 8A. * Your computation is called only once, in this case also use 8.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.;indigo6Like defNamedEffLambda1 but doesn't make side effects.<indigo2Like defNamedLambda1 but doesn't take an argument.=indigoQLike defNamedEffLambda1 but doesn't modify storage and doesn't make side effects.>indigoWhile statement.@indigo+For statements to iterate over a container.AindigoPut a document item.BindigorGroup documentation built in the given piece of code into a block dedicated to one thing, e.g. to one entrypoint.CindigohInsert documentation of the contract's storage type. The type should be passed using type applications.DindigoGGive a name to the given contract. Apply it to the whole contract code.Eindigo*Attach general info to the given contract.Findigo:Attach default general info to the contract documentation.Gindigo0Indigo version for the homonym Lorentz function.HindigoPut a \ doc item.IindigoPut a X doc item.JindigoPut a P doc item.OindigoGCreate contract using default compilation options for Lorentz compiler.See  Lorentz.Run.Pindigo!Create contract from raw Lorentz .\indigo+Add a comment in a generated Michelson code]indigo+Add a comment in a generated Michelson code^indigooAdd a comment before and after the given Indigo function code. The first argument is the name of the function._indigoqAdd a comment before and after the given Indigo statement code. The first argument is the name of the statement.Qdf !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_Q #!"$%&'()*+,-./1032456789=;<:>?@KLABCDEFGIHJMNOPQURSTVWXYZ[df]\^_05060"None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmZdf !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_None7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkm`indigo4Pretty-print an Indigo contract into Michelson code.aindigo*Generate an Indigo contract documentation.bindigoWPrints the pretty-printed Michelson code of an Indigo contract to the standard output.1This is intended to be easy to use for newcomers.cindigoQSaves the pretty-printed Michelson code of an Indigo contract to the given file.1This is intended to be easy to use for newcomers.dindigo9Print the generated documentation to the standard output.eindigo3Save the generated documentation to the given file.`indigoForce result to be single line`abcde`abcdeNone7!"#$%&'*+,-.12456789;<=>?@ACHMNPSUVX_`befgkmindigoDisambiguation 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 T2 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 T 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!%]\&  ^_a`'(+*)('&%$#"! ) S*RQNM+,-.z/01YXWVU23456#"$}789:;<= >[`?@ZA\BCDEFGHI]^JcdeK_LMNOPQRSTUabVWXYfghkjilonpqstuvwxy{|~r     ,-.0123456789:<=>?@ABCDEFGHIJKLZ[bcdefghijklmnopqrstuvwxyz{|}~     #!" %$'&)(*+,-./0123546789:;<=>?@ABCDEFGHIJKLMNOQPRSTUVWXYZ[\]^_`abcdhfeg~~}{sxtz|ypqvumnwojri      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqghrstuvwxy{z|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABABCDDEGFFGHIIJLMKLMNOPQRQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~    "#$%&'()*+,-./123456789:;<=>?@ABDEFGHIJKLMNOPQRSTUVWYZ[\]^_`abcdefghijklmonpz{qtux|w~y}rsv      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUdf !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmno!%]\&  ^_a`'(+*)('&%$#"! ) S*RQNM+,-.z/01YXWVU23456#"$}789:;<= >[`?@ZA\BCDEFGHI]^JcdeK_LMNOPQRSTUabVWXYfghkjilonpqstuvwxy{|~r     ,-.0123456789:<=>?@ABCDEFGHIJKLZ[bcdefghijklmnopqrstuvwxyz{|}~     #!" %$'&)(*+,-./0123546789:;<=>?@ABCDEFGHIJKLMNOQPRSTUVWXYZ[\]^_`abcdhfeg~~}{sxtz|ypqvumnwojri      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqghrstuvwxy{z|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABABCDDEGFFGHIIJLMKLMNOPQRQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~    "#$%&'()*+,-./123456789:;<=>?@ABDEFGHIJKLMNOPQRSTUVWYZ[\]^_`abcdefghijklmonpz{qtux|w~y}rsv      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUdf !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmno$None7!"#$%&'*,-.12456789;<=>?@ACHMNPSUVX_`befgkm/%&'()*%+,%+-%./%.0%&1%&2%34%35%67%89%8:%8;%8<(=>(=?%3@%&A%&B%&C%&D%EF%GH%6I%6J%6K%6L%MN%&O%&P%&Q%&R%&S%&T%&U%&V%8W%8X(=Y%Z[%6\%6]%&^%&_%3`(=a%bc%6d%6e%fg%hi%Ej%Gk%&l%mn%op%qr%st%uv%&w%&x(yz(y{(y|(y}(y~%%%%%%(y%6%6(y(y%%%%%%%(y%s(y%(y(y(y%%%6(y%%(y(y(y%&%%%&%&%&%&(=%%%&%&%&%&%&%%%%%%%%%%%%%%%%%%%%%%%%%%%u%M%M%M%M%M%M%M%M%M%M%M%M%M%M%o%o%o%o %o %o %o %o %o%%%%%%%%%%%%%%% %!%"%#$%%&%'(%')%*+%*,%*-%*.%*/%01%02%02%m3%m4%m5%m6%m7%m8%9:%9;%9;%9<%9=%9=%>?%>@%>A%>B%>B%>C%>D%>D%>E%>F%>F%>G%>H%>H%>I%>J%>J%>K%>L%>L%>M%>N%>N%sO%sP%sQ%sQ%RS%RT%RU%RV%RW%RX%RY%RZ%R[%R\%R]%R^%R_%R`%Ra%Rb%Rc%Rd%ef%eg%h%i%j%k%l%mn%mo%mo%pq%pq%rs%rt%ru%rv%rw%Zx%Zy%Zz%Z{%Z|%Z}%Z~%Z%Z%Z%Z%Z%Z%Z%Z%Z%Z%%%%%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%6%8%8%8%8%8%8%8%8%%+%+%+%+%+%+%+%+%+%+%+%+%+%+%+%+%+%%%%%%%%%%%%%%%%.%.%.%%3%3%3%3%3%%&%&%&%&%&%&%&%&%&%&%&%&%&%&%&%&%&%&%&%&%&%&%&%% %> %*+(= (= (= (=(=(=(=(=(= !"#$%#$&'()'(*#$+#$,#$-./01234235236237238239:;<=>?@ABACDEFGHIJKLJKMJKNJKOJKPJKQJKRJSTJSUJSVJSWJSXJYZJY[JY\JY]^_G`abcabdabeabf:gh010iG`GjGkABAlAmAnAoApAqArstustvstwstxstyz{|z{}z{~z{z{z{z{z{z{z{z{=..../2      !"#$%&'()*)+),)-).)/)01213141516171819:;:<:=:>:?@A@B@C@DEFEGEHEIEJEKELEMENEOEPEQRSRTUVWXYZ[YZ\YZ]^_`^_a^_b^_c^_d^_e^_f^_g^_h^_i^_j^_k^_l^_m^_n^_n^_o^_p^_q^_r^_rstustv^wxsyz^w^{|s}~ss}ss}ssssssss^^^^^^w^w^w^w^w^w^w^w^w^w^w^w^w^w^w^w^w^w^w^w^w^w^w^w^w^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ssssssssssssssssssssss^^sssssssssss s s s s s s ssssssssssssssssssss s!s!s"s#s"s$s%s%s&s's(s)s)s*s+s+s,s,s-s-s.s.s/s0s1s1s2s3s4s5s6s7s8s9s:;s<^=>^=?^=@^=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^`a^`b^cd^ce^cf^cg^hi^hi^hj^kl^km^kn^ko^kp^kq^kr^ks^kt^kusvw^kx^kx^ky^kz^k{^k{^k|^k}^k~^k^k^k^k^k^k^k^k^k^k^k^k^k^k^k^k^k^k^k^k^k^k^ks^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^s}s}^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^ ^ ^ ^^^^^^^^^^^^^^^^^^^ ^!^"^#^$^%^&^'^(^)^*^+^,^-^.^/^0^1^2^2^3^4^5^6^7^7^8^9^:^;^<^=^>^?^@^@^A^B^C^D^E^F^GH^GI^GJ^GK^GL^GM^GN^G0^GO^GP^GP^GQ^GR^GS^GT^GU^GV^GW^GX^GY^GZ^G[^G\^G]^G^^G_^G`^ab^ac^ad^e^f^gshs}isjskslsmsnsospsqrsqssqtsqusqvsqwsqxsqy^z^{^^|^^}^~^^^^ssss}s}s}s}s}s}s}s}s}syzB                                                                  ! " # $ % & ' ( ) * + , - . / 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 pqrstuvw5xyz{>|} ~  ?/06O0       !"#$%&'()*+,-./0123456789:;<=>?@ABCCDEFGHIJKLMNOPPQRS%T'()UV*+,-./0123456789:;<=>?WXYZ[\]^_`abcdefghijklmnopqrstuv wxy z " {|}~" !lnop#4ss         ^@$$$$$$$$indigo-0.3.1-inplaceIndigo.Backend.PreludeIndigo.PreludeIndigo.LorentzIndigo.Internal.VarIndigo.Internal.ObjectIndigo.Internal.StateIndigo.Internal.LookupIndigo.Internal.SISIndigo.Internal.FieldIndigo.Internal.Expr.Types Indigo.Internal.Expr.CompilationIndigo.Internal.Expr.DecomposeIndigo.Backend.ErrorIndigo.Internal.Expr.SymbolicIndigo.Backend.VarIndigo.Backend.ScopeIndigo.Backend.LambdaIndigo.Backend.ConditionalIndigo.Backend.CaseIndigo.BackendIndigo.Frontend.StatementIndigo.Frontend.ProgramIndigo.Compilation.SequentialIndigo.Compilation.LambdaIndigo.Compilation.FieldIndigo.Compilation.ParamsIndigo.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:%TrueLeftRightLTEQGTideither mtl-2.2.2Control.Monad.Reader.Class MonadReaderasklocalreaderControl.Monad.State.Class MonadStategetputstatebytestring-0.10.10.0Data.ByteString.Internal ByteString Data.Functor<$><|>StringQhashable-1.3.0.0-6a06b304864f76cff7487530abcd9c53784bf2d5cb6bbcfefbf3eaf9ba34c680Data.Hashable.ClassHashable text-1.2.4.0Data.Text.InternalTextconst.^unordered-containers-0.2.10.0-f0b00e67598e7a365507d8332c934efdfc8b152436e255fa57288f3489d42a57Data.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/floorceilingroundtruncateproperFractionboundedEnumFromThenboundedEnumFrommaxBoundminBoundfromEnumtoEnumpredsuccGHC.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 runIdentityTQconstraints-0.12-219813e80846a99ce76bdb4a8e0b66c26d970340aef6c06b2fe8a5b96699e0aaData.ConstraintwithDictData.IntMap.InternalIntMapData.IntSet.InternalIntSetData.Sequence.InternalSeqData.Set.InternalSetdeepseq-1.4.4.0Control.DeepSeqrnfNFData[data-default-class-0.1.2.0-cd82420962fb1bb36843e51775abe5ffe3c35016e35b1db0a0fccf8ccfb6a31dData.Default.ClassDefaultdefforce$!!deepseqControl.Monad.Trans.MaybeMaybeTControl.Monad.Trans.ExceptExceptTRexceptions-0.10.4-49a3ddfb177101e7540692e7b9abea6fe3b622861e7c7e66eca0755e823a7c8aControl.Monad.Catch MonadThrow MonadCatchgeneralBracketuninterruptibleMaskmask MonadMaskControl.Monad.Trans.Classlift hashWithSaltData.Text.LazytoStrictData.HashSet.BaseHashSet Control.Monad.Trans.State.StrictStateTStatePvector-0.12.1.2-cdd11b636c315a5bb0964622b98d4a6081fef7ccc95974ea24e81b8b0e119995 Data.VectorVectorControl.Monad.Trans.ReaderReadergetsSmicrolens-0.4.11.2-bf9eaf00b69daf7523e0425ba84bbdf987923900daff3add5e7969303af1f769 Lens.Micro^?^..^.set.~over%~Lens.Micro.Internal_1_2_3_4_5Lens.Micro.TypeLensLens' Traversal Traversal'modifyasksReaderTVmicrolens-mtl-0.2.0.1-d2f7bd2b7607d43a03f0041a7443ca2c17b8cfb0d246b0f1723982eea7a1c266Lens.Micro.Mtlpreuseusepreviewview MonadTransmodify' runExceptT runReaderT runReader runStateTrunState evalState execState withState evalStateT execStateTNnamed-0.3.0.1-c213d4c2c01df3dfd493e55bc222296fdaec9c9d140602f3c9de6390e6f03aa3Named.InternalargDefargFarg:!:?Xsafe-exceptions-0.1.7.0-88d7a06c459925b027b72af16d1e68409f0db4e1b3429187bb7608638bb1d32cControl.Exception.SafebracketOnErrorfinallybracket_bracket onExceptiontryAnytry handleAnycatchAnycatchthrowM stm-2.5.0.0Control.Concurrent.STM.TVar modifyTVar' fromStrict Data.TextunwordsunlineslineswordsData.Text.Encoding decodeUtf8'decodeUtf8WithData.Text.Encoding.Error lenientDecode strictDecodeOnError OnDecodeErrorUnicodeExceptionexceptToMaybeTmaybeToExceptT runMaybeTPuniversum-1.6.1-feb74d29edc41a61b0de06fa402f3d29121212e577bc6fc320dbebeb8a0f5a01Universum.VarArg...SuperCompositionUniversum.TypeOpsEachWithUniversum.String.Conversionshow readEitherLText LByteStringdecodeUtf8Strict decodeUtf8 encodeUtf8 ConvertUtf8toTextToTexttoLTextToLTexttoStringToStringUniversum.Debug undefinedtraceIdtraceM traceShowMtraceShowIdWith traceIdWith traceShowId traceShowerrortrace UndefinedUniversum.Print putLTextLnputLText putTextLnputTexthPrintprintputStrLnputStr hPutStrLnhPutStrUniversum.Print.InternalPrint Universum.Nub unstableNubsortNubhashNubordNubUniversum.Bool.GuardguardMifMunlessMwhenMUniversum.DeepSeq evaluateNF_ evaluateNF evaluateWHNF_ evaluateWHNFUniversum.ExceptionnotebugExcBugUniversum.List.Safe whenNotNullM whenNotNullunconsUniversum.Monad.ContaineranyMallMorMandM concatForM concatMapMUniversum.Container.Classasum sequence_ sequenceA_forM_mapM_for_ traverse_productsum flipfoldl'elemskeystoPairsToPairssafeHeadfindorandanyallnotElemfoldl1foldr1foldr'foldfoldMapminimummaximumelemlengthfoldl'foldlfoldrnulltoListElement ContaineroneOneItemOneUniversum.Monoid maybeToMonoidUniversum.Monad.TransexecutingStateexecutingStateTevaluatingStateevaluatingStateT usingState usingStateT usingReader usingReaderTUniversum.Monad.Either whenRightM whenRight whenLeftMwhenLeft maybeToLeft maybeToRight rightToMaybe leftToMaybe fromRightfromLeftUniversum.Monad.Maybe whenNothingM_ whenNothingM whenNothing_ whenNothing whenJustMwhenJust?:Universum.Lifted.IORefatomicWriteIORefatomicModifyIORef'atomicModifyIORef modifyIORef' modifyIORef writeIORef readIORefnewIORefUniversum.Lifted.FilewithFilehCloseopenFilegetLine appendFileUniversum.Lifted.Envdie exitSuccess exitFailureexitWithUniversum.Lifted.Concurrent readTVarIO newTVarIO atomically tryTakeMVar tryReadMVar tryPutMVartakeMVarswapMVarreadMVarputMVarnewMVar newEmptyMVarUniversum.Functor.Fmap<<$>>mapUniversum.Base$!Universum.ApplicativepassMvinyl-0.12.1-7eed6fcae264e50bba3530560fb2a8e8cadbc76c371a4c09876689da9126d803Data.Vinyl.Core:&RNilReclorentz-0.7.0-inplace Lorentz.ADTconstructStack deconstruct fieldCtorgetField getFieldNamed modifyFieldtoField toFieldNamed unwrapUnsafe_wrapOnewrap_:= CaseArrow/-> CaseClauseLCaseTCHasFieldOfTypeHasFieldsOfType NamedFieldmorley-1.8.1-inplace%Michelson.Typed.Haskell.Instr.ProductConstructorFieldTypesInstrConstructC Lorentz.Base:-> Util.LabelLabelLorentz.Annotation HasAnnotationMichelson.Typed.Haskell.ValueToT Tezos.AddressAddressBigMap Tezos.CoreChainId ContractRefMichelson.Typed.Entrypoints EpAddress Tezos.CryptoKeyHashMichelson.TextMTextMutezMichelson.Typed.Aliases Operation PublicKey Signature Timestamp Lorentz.Arith ArithOpHs ArithResHsUnaryArithOpHsUnaryArithResHsLorentz.Constraints.ScopesNiceComparable###FIIiAnyCode iForceNotFail iGenericIf iMapAnyCodeiNonFailingCodeiWithVarAnnotationsoptimizeLorentzoptimizeLorentzWithConfparseLorentzValuetransformBytesLorentztransformStringsLorentz%> LorentzInstrunLorentzInstr ContractCode ContractOutLambdaMapLorentzInstrmapLorentzInstrSomeContractCodeLorentz.Constraints.DerivativeNiceParameterFull NiceStorage KnownValueLorentz.CoercionsallowCheckedCoerceallowCheckedCoerceTo castDummyG checkedCoercecheckedCoerce_checkedCoercing_ coerceUnwrap coerceWrap fakeCoerce fakeCoercing forcedCoerce forcedCoerce_ fromNamedgForcedCoerce_toNamed CanCastTo castDummy Castable_ Coercible_MichelsonCoercibleLorentz.Wrappable Wrappable UnwrappableLorentz.AddressTAddressFutureContractLorentz.Common Entrypoint Entrypoint_niceConstantEvinicePackedValueEviniceParameterEvinicePrintedValueEviniceStorageEviniceUnpackedValueEvi CanHaveBigMap NiceConstantNiceFullPackedValueNicePackedValue NiceParameterNicePrintedValueNiceUnpackedValueNoBigMapNoContractType NoOperation Lorentz.DocbuildLorentzDocbuildLorentzDocWithGitRevcutLorentzNonDocmkDEntrypointExamplerenderLorentzDocrenderLorentzDocWithGitRev Michelson.DoccontractDocToMarkdowndocDefinitionRefdocItemPosition mdTocFromRefmkDGitRevisionmorleyRepoSettingssubDocToMarkdownMichelson.Typed.Haskell.DocconcreteTypeDocHaskellRepconcreteTypeDocHaskellRepUnsafeconcreteTypeDocMichelsonRep!concreteTypeDocMichelsonRepUnsafecustomTypeDocMdReferencedTypeDepgenericTypeDocDependencieshaskellAddNewtypeFieldhaskellRepNoFieldshaskellRepStripFieldPrefixhomomorphicTypeDocHaskellRephomomorphicTypeDocMdReferencehomomorphicTypeDocMichelsonReppoly1TypeDocMdReferencepoly2TypeDocMdReferenceDEntrypointExample ContractDoc cdContentscdDefinitionIds cdDefinitionscdDefinitionsSetDAnchorDComment DDescription DGitRevisionDGitRevisionKnownDGitRevisionUnknownDocElemdeItemdeSub DocGroupingDocItemDocItemPlacementDocItemReferenceddocItemDependencies docItemPos docItemRefdocItemSectionDescriptiondocItemSectionNamedocItemSectionNameStyledocItemToMarkdown docItemToToc docItemsOrder DocItemIdDocItemPlacementKindDocItemInDefinitionsDocItemInlined DocItemPos DocItemRef DocItemNoRefDocItemRefInlined DocSectionDocSectionNameStyleDocSectionNameBigDocSectionNameSmallGitRepoSettingsgrsMkGitRevisionSomeDocDefinitionItem SomeDocItemSubDocDTypeHaveCommonTypeCtor IsHomomorphicSomeTypeWithDoc TypeHasDocTypeDocFieldDescriptionstypeDocDependenciestypeDocHaskellReptypeDocMdDescriptiontypeDocMdReferencetypeDocMichelsonRep typeDocName Util.MarkdownMarkdownValueLorentz.Entrypoints.CoreeprNameparameterEntrypointCallparameterEntrypointCallCustomparameterEntrypointCallDefaultparameterEntrypointsToNotessepcCallRootChecked:>AllParameterEntrypoints EntrypointRefCall CallDefaultEntrypointsDerivationEpdAllEntrypointsEpdLookupEntrypointepdCallepdDescsepdNotesEpdNoneForbidExplicitDefaultEntrypointGetDefaultEntrypointArgGetEntrypointArgGetEntrypointArgCustomHasDefEntrypointArgHasEntrypointArguseHasEntrypointArgHasEntrypointOfTypeLookupParameterEntrypointNoExplicitDefaultEntrypointParameterContainsEntrypointsParameterDeclaresEntrypointsParameterHasEntrypointsParameterEntrypointsDerivationRequireAllUniqueEntrypoints TrustEpNameLorentz.Entrypoints.HelpersShouldHaveEntrypointsunHasEntrypointsLorentz.Entrypoints.Impl EpdDelegateEpdPlain EpdRecursive EpdWithRootLorentz.Entrypoints.ManualParameterWrapperunParameterWraperLorentz.Entrypoints.DocareFinalizedParamBuildingStepsclarifyParamBuildingStepsconstructDEpArgdiEntrypointToMarkdowndocumentEntrypoint emptyDEpArgentryCaseSimple_mkDEntrypointArgSimple mkDEpUType mkPbsWrapInMichelson.Typed.ExtractmkUType DEntrypointdepNamedepSubDEntrypointArgepaArg epaBuildingepaTypeDEntrypointReferenceDeriveCtorFieldDocderiveCtorFieldDocDocumentEntrypoints EntryArrow#-> ParamBuilderunParamBuilderParamBuildingDesc pbdEnglish pbdHaskell pbdMichelsonParamBuildingStepPbsCallEntrypoint PbsCustom PbsUncallable PbsWrapInPlainEntrypointsKindRequireFlatEpDerivationRequireFlatParamEpsMichelson.Untyped.EntrypointsEpNameLorentz.ErrorscustomErrorDocHaskellRepGeneralerrorTagToMTexterrorTagToTextfailUnexpected failUsingisoErrorFromVal isoErrorToVal typeDocMdDescriptionReferToError CustomErrorceArgceTagCustomErrorHasDoccustomErrArgumentSemanticscustomErrClasscustomErrDocMdCausecustomErrDocMdCauseInEntrypointDErrorDThrowsErrorArg ErrorClassErrClassActionExceptionErrClassBadArgumentErrClassContractInternalErrClassUnknown ErrorHasDocErrorRequirements errorDocClasserrorDocDependencieserrorDocHaskellReperrorDocMdCauseerrorDocMdCauseInEntrypoint errorDocNameerrorDocRequirements ErrorScopeIsError errorFromVal errorToValRequireNoArgError SomeErrorUnspecifiedErrorIsoValueWellTypedIsoValueLorentz.Errors.Numeric.ContractaddNewErrorTagsapplyErrorTagMapapplyErrorTagMapWithExclusionsbuildErrorTagMaperrorFromValNumericerrorToValNumericexcludeErrorTagsgatherErrorTagsuseNumericErrorsLorentz.Errors.Numeric.DocapplyErrorTagToErrorsDocapplyErrorTagToErrorsDocWithbaseErrorDocHandlerscustomErrorDocHandlervoidResultDocHandlerErrorTagExclusions ErrorTagMapDDescribeErrorTagMap detmSrcLocNumericErrorDocHandlerNumericErrorDocHandlerErrorNumericErrorWrapper Lorentz.Ext printCommentstackRef stackType testAssert Lorentz.InstrNonZeroLorentz.Polymorphic ConcatOpHs Lorentz.ValueListEDivOpHs EDivOpResHs EModOpResHsMemOpHs MemOpKeyHsGetOpHs GetOpValHs GetOpKeyHsIterOpHs IterOpElHsMapOpHs IsoMapOpRes MapOpInpHs MapOpResHsSizeOpHs SliceOpHsUpdOpHs UpdOpKeyHs UpdOpParamsHs Lorentz.Macro voidResultTagView VoidResultVoid_ ToContractRef Lorentz.PackexpressionToScriptExpr lEncodeValue lPackValue lUnpackValuevalueToScriptExpr Lorentz.PrintprintLorentzContractprintLorentzValueLorentz.ReferenceddipTdropTdupT Lorentz.RunanalyzeLorentzcompileLorentzcompileLorentzContractcompileLorentzWithOptionsdefaultCompilationOptionsdefaultContractinterpretLorentzInstrinterpretLorentzLambdaCompilationOptionscoBytesTransformercoOptimizerConfcoStringTransformerLorentz.StoreClasscomposeStoreEntrypointOpscomposeStoreFieldOpscomposeStoreSubmapOps mkStoreEp stEntrypoint stGetEpLambda stGetEpStore stGetField stSetEpLambda stSetEpStore stSetField stToEpLambda stToEpStore stToFieldstoreEntrypointOpsADTstoreEntrypointOpsDeeperstoreEntrypointOpsFieldsstoreEntrypointOpsReferTostoreEntrypointOpsSubmapFieldstoreFieldOpsADTstoreFieldOpsDeeperstoreFieldOpsReferTostoreSubmapOpsDeeperstoreSubmapOpsReferTo::->EntrypointLambdaEntrypointsFieldStorageContainsStoreEntrypointOpssopSetEpLambda sopSetEpStore sopToEpLambda sopToEpStore StoreFieldOps sopSetField sopToFieldStoreHasEntrypoint storeEpOps StoreHasField storeFieldOpsStoreHasSubmapstoreSubmapOpsStoreSubmapOps sopDeletesopGet sopInsertsopMem sopUpdate~>Lorentz.UParam caseUParam caseUParamTmkUParam pbsUParam unwrapUParamuparamFallbackFail uparamFromAdt CaseUParamConstrainedSomeEntrypointKindEntrypointLookupErrorArgumentUnpackFailedNoSuchEntrypointEntrypointsImplLookupEntrypointRequireUniqueEntrypoints SomeInterfaceUParam UParamUnsafeUParamFallbackUParamLinearizeUParamLinearizedUParam_ UnpackUParam unpackUParamLorentz.Util.TH entrypointDocerrorDoctypeDoccallingDefTAddresscallingTAddressconvertContractRefmtcoerceContractRef DefEpNameoneMuteztimestampFromSecondstimestampFromUTCTimetimestampQuotetoMutez zeroMutezUtil.CustomGenericcstr customGenericfld leftBalancedleftComb rightBalanced rightComb withDepthsFromContractReffromContractRefunFutureContract unTAddress ToAddress toAddress toContractRef ToTAddress toTAddress eaAddress eaEntrypointunBigMap crAddress crEntrypointEntrypointCallfromValtoValSomeEntrypointCall HasStorageHasSideEffectsOpsVar StackVarsStkElNoRefRefRefId emptyStack assignVarAtpushRef pushNoRefpopNoRef operationsVar storageVar$fTestEqualityTYPEStkEl $fDefaultRec $fDefaultRec0 $fShowRefId$fGenericRefId $fEqRefId $fOrdRefId $fRealRefId $fNumRefId$fBoundedRefId $fGenericVar $fShowVarComplexObjectC FieldTypesIsObject TypedFieldObj SomeObjectObject NamedFieldObj unFieldObj IndigoObjectFCell DecomposednamedToTypedRectypedToNamedReccastFieldConstructorsnamedToTypedFieldObjtypedToNamedFieldObjcomplexObjectDict$fIsObject'ProductTypeDa$fIsObject'SumTypeDa$fIsObject'PrimitiveDa $fIsObjectaGenCodegcStackgcCodegcClearMetaDatamdStack mdObjectsDecomposedObjects IndigoStaterunIndigoStateusingIndigoStateiputnopState assignTopVar withObjectwithObjectState withStackVars replStkMd alterStkMd pushRefMd pushNoRefMd popNoRefMd cleanGenCode varActionGet varActionSetvarActionUpdatevarActionOperationrtakerdrop$fTestEqualityTTValSomeIndigoStateunSIS SomeGenCoderunSIStoSISthenSISoverSISHasField fieldLens FieldLens TargetField DeeperField AccessFieldC fetchField assignFieldflSFO fieldLensADTfieldLensDeeper$fHasFielddtfnameftype IsSizeExpr IsMemExpr IsUpdExpr IsGetExpr IsSliceExprIsConcatListExpr IsConcatExpr IsModExpr IsDivExpr IsArithExprIsUnaryArithExprToExprExprType:~>IsExpr ObjectExprNamedFieldExprunNamedFieldExprObjectManipulationToFieldSetFieldExprCVObjManCastSizeUpdateAddSubMulDivModAbsNegLslLsrEq'NeqLeLtGeGtOrXorAndNotInt'IsNatCoerce ForcedCoerceFstSndPairSomeNoneRight'Left'MemStGet StInsertNewStInsertStMemStUpdateStDeleteWrapUnwrap ConstructConstructWithoutNamedNameUnNameEmptySetGetEmptyMap EmptyBigMapPackUnpackConsNilConcatConcat'SliceContractSelfContractAddressContractCallingUnsafeRunFutureContractImplicitAccountConvertEpAddressToContractMakeViewMakeVoidCheckSignatureSha256Sha512Blake2bHashKeyNowAmountBalanceSenderExectoExpr$fToExpr'DecisionExprDExpr*$fToExpr'DecisionObjManDObjectManipulation$fToExpr'DecisionValDa$fToExpr'DecisionVarDVar $fToExprxObjManipulationRes StillObjectOnStack compileExpr namedToExprrunObjectManipulation ternaryOpbinaryOpunaryOp nullaryOp ternaryOpFlat binaryOpFlat unaryOpFlat nullaryOpFlatExprDecomposition ExprFields DeconstructeddeepDecomposeCompose decomposeExprfailWith failUsing_ failCustom failCustom_failUnexpected_removeinsert constExprvarExprcastaddsubmul%negeqneqltgtlegeisNattoIntnonZerocoercelsl<<<lsr>>>packunpackpaircarcdrnonerightleftslicecons.: concatAllnilupdatememsize#:!:+:-: emptyBigMapemptyMapemptySetstGet#@stUpdate!@stInsert+@ stInsertNew++@stDelete-@stMem?@wrapunwrap#!!!nameunName!~#~ construct constructReccontractselfcontractAddresscontractCallingUnsafecontractCallingStringrunFutureContractimplicitAccountconvertEpAddressToContractmakeViewmakeVoidnowamountsendercheckSignaturesha256sha512blake2bhashKeychainIdbalance$fExprMagmaSet$fExprMagmaMap$fExprMagmaBigMap$fExprInsertableSetexKey$fExprInsertableMap(,)$fExprInsertableBigMap(,)$fExprRemovableSet$fExprRemovableMap$fExprRemovableBigMap assignVarsetVarsetField updateVar ScopeCodeGenReturnableValueRetExprsRetVars RetOutStack ScopeCodeGen'compileScopeReturn' liftClear' genGcClear'ReturnableValue' RetOutStack'RetVars' RetExprs' allocateVars' assignVars'ClassifyReturnValue BranchRetKindUnit SingleValTuple allocateVars liftClear compileScopefinalizeStatement$fReturnableValue'Unit()$fScopeCodeGen'Unit()$fScopeCodeGen'Tuple(,,)$fReturnableValue'Tuple(,,)$fScopeCodeGen'Tuple(,)$fReturnableValue'Tuple(,)$fScopeCodeGen'SingleValsingle!$fReturnableValue'SingleValsingleExecuteLambdaEff1CCreateLambdaEff1CExecuteLambda1CCreateLambda1CExecuteLambdaPure1CCreateLambdaPure1CCreateLambda1CGenericLambda1Generic LambdaKind PureLambda StorageLambda EffLambdawithLambdaKindexecuteLambda1initLambdaStackVarscreateLambda1Generic IfConstraintif_ifSomeifRightifCons CaseCommonF IndigoClauseIndigoCaseClauseLcaseRec entryCaseRecentryCaseSimpleRec,$fCaseArrownameIndigoClauseIndigoCaseClauseLwhile whileLeftforEachdocdocGroup docStorage contractNamecontractGeneralcontractGeneralDefaultfinalizeParamCallingDoc selfCallingcontractCallingtransferTokens setDelegatecreateContractscopecomment StatementFLiftIndigoStateNewVarSetVarVarModification LambdaCall1ScopeIfIfSomeIfRightIfConsCase EntryCaseEntryCaseSimpleWhile WhileLeftForEach ContractNameDocGroupContractGeneralFinalizeParamCallingDocTransferTokens SetDelegateCreateContract SelfCallingContractCallingFailFailOverIndigoMCaseClauseLOneFieldIndigoMCaseClauseLIndigoContractIndigoM unIndigoMProgramDoneInstrBindinterpretProgram$fMonadProgram$fApplicativeProgram$fFunctorProgram$fFunctorIndigoM$fApplicativeIndigoM$fMonadIndigoM CaseBranchIndigoSeqCaseClauseOneFieldIndigoSeqCaseClause Instruction AssignVar CreateLambda1 ExecLambda1BlockindigoMtoSequentialsequentialToLorentz updateClauses mapMClausescompileLambdas$fOrdLambda1Def$fEqLambda1DefoptimizeFieldsAreIndigoParamsIndigoWithParamsfromIndigoWithParamscontractToIndigoWithParams compileIndigocompileIndigoContractIndigoEntrypointIndigoProcedureIndigoFunctionliftIndigoStatenew=:+=-=*=||=&&=^=<<<=>>>=setStorageFieldupdateStorageFieldgetStorageFieldifNonewhenSomewhenNoneifLeftcase_ entryCaseentryCaseSimple//->#= defFunction defContractdefNamedEffLambda1defNamedLambda1defNamedLambda0defNamedPureLambda1 descriptionanchorexamplecreateLorentzContractassert assertCustom assertCustom_ assertSome assertNone assertRight assertLeft justCommentcommentAroundFuncommentAroundStmtprintIndigoContractrenderIndigoDocprintAsMichelsonsaveAsMichelsonprintDocumentationsaveDocumentation ifThenElsenatintmutezview_projectvoid_ projectVoidsubGt0 TypeDecision IsObject'MapGFTTValMichelson.Typed.TT TValStackVarDepth Util.PeanoPeanoOsingletons-2.6-bc9e9efcd42ed95898675958f8f864b759edb324126e3a605303bb31393c73bbData.Singletons.InternalSingduupXVar replaceNVar updateNVarvarDepthcompileObjectManipulation objToExprcompileObjectF exprToManResSIS'decomposeObjectFdeconstructOnStack noRefGenCodefailIndigoState ExprRemovableExprInsertable compileToExprexecuteLambdaPure1executeLambdaSt1executeLambdaEff1executeLambda1Generic CaseCommonInstrCollector instrCollectcollectStatement collectInnercollectInLambdaappendNewInstr mkNextVarsequentialToSIS instrToSISclausesToBackendallocateClausesVarscollectClauses Lambda1DefldNamecollectNotInlinableLambdascreateLambdaRefscreateAllLambdas updateBlockAreIndigoPeanoParamsIndigoWithPeanoParamsfromIndigoWithPeanoParamscompileIndigoImplNumTypeNumKindversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName