!kQY>      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = SafelNoneSX   Safep None>NoneHV None @AHSUVXk%llvm-dsl Analogous to ?.(llvm-dsl A nested ?.Zllvm-dsl Analogus to  .\llvm-dsl1You can construct complex numbers this way, but they will not make you happy, because the numeric operations require a RealFloat instance that we could only provide with lots of undefined methods (also in its superclasses). You may either define your own arithmetic or use the NumericPrelude type classes.llvm-dslLike J but computes both alternative expressions and then uses LLVM's efficient select instruction.llvm-dsleWe do not require a numeric prelude superclass, thus also LLVM only types like vectors are instances."#! $%&(')*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~-./012)*+,3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY&('$%Z[\]"#! ^_`abcdefghijklmnopqrstuvwxyz{|}~ ~44444432756None@AHV"jllvm-dslcounterpart to   with swapped argumentsNoneHUV"None >EHSUVXL<llvm-dslmThis data type is for parameters of parameterized LLVM code. It is better than using plain functions of type p -> aa since it allows for numeric instances and we can make explicit, whether a parameter is constant.NWe recommend to use parameters for atomic types. Although a parameter of type  T p (a,b) is possible, it means that the whole parameter is variable if only one of the pair elements is variable. This way you may miss opportunities for constant folding.llvm-dsl The call  value param v requires that v represents the same value as valueTupleOf (get param p) for some p . However v- might be the result of a load operation and param? might be a constant. In this case it is more efficient to use "valueTupleOf (get param undefined)\ since the constant is translated to an LLVM constant that allows for certain optimizations.This is the main function for taking advantage of a constant parameter in low-level implementations. For simplicity we do not omit constant parameters in the parameter struct since this would mean to construct types at runtime and might become ugly. Instead we just check using valueV at the according places in LLVM code whether a parameter is constant and ignore the parameter from the struct in this case. In many cases there will be no speed benefit because the parameter will be loaded to a register anyway. It can only lead to speed-up if subsequent optimizations can precompute constant expressions. Another example is @ where a loop with constant loop count can be generated. For small loop counts and simple loop bodies the loop might get unrolled.llvm-dsl/This function provides specialised variants of  and valueS, that use the unit type for constants and thus save space in parameter structures.llvm-dsl>Provide all elements of a nested tuple as separate parameters.LIf you do not use one of the tuple elements, you will get a type error like -Couldn't match type `Param.Composed t0' with AI. The problem is that the type checker cannot infer that an element is a  Parameter.T if it remains unused.llvm-dslUseful for combining T p a and T p b to  T p (a,b) using  liftA2 (,)x. However, we do not recommend to do so because the result parameter can only be constant if both operands are constant.llvm-dslUseful for splitting  T p (a,b) into T p a and T p b using fmap fst and fmap snd.llvm-dslarrd is useful for lifting parameter selectors to our parameter type without relying on the constructor.llvm-dsl.= can be used for fetching a parameter from a super-parameter.0 None >@AHSUVXWllvm-dsl The same as B:, but needs only Algebraic constraint, not Transcendental.llvm-dslLazy ANDllvm-dslLazy ORllvm-dsl true ? (t,f) evaluates t,  false ? (t,f) evaluates f. t and fu can reuse interim results, but they cannot contribute shared results, since only one of them will be run. Cf. '(??)'llvm-dslThe expression  c ?? (t,f) evaluates both t and f and selects components from t and f according to c1. It is useful for vector values and for sharing t or f& with other branches of an expression.6llvm-dsleWe do not require a numeric prelude superclass, thus also LLVM only types like vectors are instances.+      !"#$%&'(+      !"#$%&'(  4 4 44443200C !"#$%&'()**+,-./01234567899:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_` abcdefghijklmnopqrstuvwxyz{|}~hPQURSXYZJK31    s 6 7 8 >      y z                 1sllvm-dsl-0.1-inplaceLLVM.DSL.Debug.CounterLLVM.DSL.Debug.MarshalLLVM.DSL.Debug.StablePtrLLVM.DSL.ExecutionLLVM.DSL.ExpressionLLVM.DSL.Expression.MaybeLLVM.DSL.Expression.VectorLLVM.DSL.ParameterLLVM.DSL.Value LLVM.DSL.Dump MultiValuemodifyMultiValue Data.Maybe fromMaybeTConsformatnewnext$fEnumT$fEqT$fOrdT ArrayElemDump dumpCounter toBytePtrdumpwithConstArray traceMalloc proxyFromDatasizeOf alignmenttrace FinalizerImporterExecdumpercompilecreateLLVMFunctioncreateFunctioncreateFinalizerScalar Aggregate MultiValuesOf ExpressionsOfbundledissect Decompose decomposeComposeComposedcomposeValuelift0lift1lift2ExpunExpunique_uniquewithKeylift3lift4liftMliftM2liftM3unliftM1unliftM2unliftM3unliftM4 liftReprM liftReprM2 liftReprM3zipzip3zip4unzipunzip3unzip4fstsndmapFstmapSndmapPairswapcurryuncurryfst3snd3thd3mapFst3mapSnd3mapThd3 mapTripletupleuntuplemodifyMultiValue2modifyMultiValueMmodifyMultiValueM2modifymodify2 consComplex deconsComplexconsunitzeroaddsubnegonemulsqrrecipfdivsqrtpowidiviremshlshr fromInteger' fromRational' boolPFrom8 bool8FromP intFromBool8floatFromBool8toEnumfromEnumsuccpred fromFastMath toFastMathminBoundmaxBoundcmp==*/=*<*>=*>*<=*minmaxlimitfractiontruefalse&&*||*notselect ifThenElse complement.&.*.|.*xortoMaybemaybetau fromIntegral truncateToInt floorToInt ceilingToIntroundToIntFastsplitFractionToInt$fCExp$fCExp0$fCExp1$fCExp2 $fCExpExp$fCExp3$fCExp4 $fFloatingExp$fFractionalExp$fNumExp $fValueExp$fValueT$fComposeComplex$fComposeTuple$fCompose(,,,) $fCompose(,,) $fCompose(,) $fCompose() $fComposeExp$fDecomposeComplex$fDecomposeTuple$fDecompose(,,,)$fDecompose(,,)$fDecompose(,) $fDecompose()$fDecomposeAtom $fAggregateTT$fAggregate(,,,)(,,,)$fAggregate(,,)(,,)$fAggregate(,)(,)$fAggregateExpT$fCScalarScalar $fCScalar $fCScalar0$fAggregateScalarT replicateiteratetaketakeRevcumulateTupleSourceTunnelget valueTuple multiValue withValue withMultiwithtunnelwordInt$# withTuple withTuple1 withTuple2$fCT$fCT0$fCT1$fCT2$fCT3 $fFloatingT $fFractionalT$fNumT$fMonadT$fApplicativeT $fFunctorT$fArrowT$fCategoryTYPET $fTuple(,,) $fTuple(,)$fTupleTFlatten Registers flattenCode unfoldCodedeconssquare%==%/=%>%>=%<%<=%&&%||???unlift0unlift1unlift2unlift3unlift4unlift5 constantValueconstantflattenunfoldflattenCodeTraversableunfoldCodeTraversableflattenFunction$fCTT$fSqrTT$fCTT0$fCTT1$fCT4 $fFlatten() $fFlattenT $fFlattenT0 $fFlatten(,,) $fFlatten(,)writerllvm-extra-0.11-inplaceLLVM.Extra.Multi.Value.PrivateWprelude-compat-0.0.0.2-86fc48c21f7a91823731cd2f9f01e3a24beccebbcf010fdacc30fe2eeb6b0494 Data.List2010dropghc-prim GHC.TypesIntVnumeric-prelude-0.4.4-81c22f813044e77f4bf1206a911a343fcfe83c9395ff4c329830a1c2c8159524Algebra.Algebraic