bW2      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR S T U V W X Y Z [ \ ] ^_`ab 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[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None  CodeGen (a->b->...-> IO z) = < Value a -> Value b -> ... CodeGenFunction r (Value z)@.         None" NoneAn alternative to # 'where I try to persuade LLVM to use x86's LOOP instruction. %Unfortunately it becomes even worse. 5LLVM developers say that x86 LOOP is actually slower 9than manual decrement, zero test and conditional branch. 'BThis is a loop with a single point for exit from within the loop. The Bool6 value indicates whether the loop shall be continued. (This is a variant of & that may be more convient, ,because you only need one lambda expression 'for both loop condition and loop body. )"This construct starts new blocks, )so be prepared when continueing after an ). ,Branch-free variant of * 5that is faster if the enclosed block is very simply, .say, if it contains at most two instructions. &It can only be used as alternative to * /if the enclosed block is free of side effects. --1 terminates a basic block which interferes badly .with other control structures in this module. 2If you use the control structures then better use LLVM.Extra.Function.  !"#$%&'()*+,-. !"#$%&'()*+,-.!"#$%&(')* +,-. !"#$%&'()*+,-.None/If isRight, then fromLeft is an  undefTuple. If  not isRight, then  fromRight is an  undefTuple. I would prefer a union type, Jbut it was temporarily removed in LLVM-2.8 and did not return since then. 4counterpart to  /01234567 /01234567 /01234567 None8If isJust = False, then fromJust is an  undefTuple. <counterpart to   >counterpart to  with swapped arguments @%counterpart to Data.Maybe.HT.toMaybe 89:;<=>?@AB CDEFG  89:;<=>?@AB CDEFG 89:;<=>?@AB CDEFG  None Safe-InferedHIJHIJHIJHIJNone:KLMNOPQ !"#$%&'()*+,-./0123456789:;<=>?@ABCDKLMNOPQNOPQKLM6KLMNOPQ !"#$%&'()*+,-./0123456789:;<=>?@ABCD NoneRSTUVWXYZ[\]EFGHIJKLMNOP RSTUVWXYZ[\] \]Z[XYUVWRSTRSTUVWXYZ[\]EFGHIJKLMNOPNone^_ /01234567^_ /01234756^_^_None`a89:;<=>?@ABCDEFG`a89:;<=>?@ACB`EFDGa`a Nonec*construct an array out of single elements DYou must assert that the length of the list matches the array size. &This can be considered the inverse of d. dKprovide the elements of an array as a list of individual virtual registers &This can be considered the inverse of c. eThe loop is unrolled, since Q and R expect constant indices. bcdebcdebcdebcde Nonen8The order of addition is chosen for maximum efficiency. 'We do not try to prevent cancelations. pCThe first result value is the sum of all vector elements from 0 to  div n 2 + 1 B and the second result value is the sum of vector elements from div n 2 to n-1.  n must be at least D2. qJTreat the vector as concatenation of pairs and all these pairs are added. ( Useful for stereo signal processing.  n must be at least D2. }GAllow to work on records of vectors as if they are vectors of records. EThis is a reasonable approach for records of different element types Jsince processor vectors can only be built from elements of the same type. ;But also, say, for chunked stereo signal this makes sense. In this case we would work on Stereo (Value a). -Formerly we used a two-way dependency Vector  - (Element, Size). ;Now we have only the dependency Vector -> (Element, Size). 3This means that we need some more type annotations as in umul32to64/ assemble, 5on the other hand we can allow multiple vector types 'with respect to the same element type. 5E.g. we can provide a vector type with pair elements 7where the pair elements are interleaved in the vector. ,Manually assemble a vector of equal values. %Better use ScalarOrVector.replicate. *construct a vector out of single elements EYou must assert that the length of the list matches the vector size. &This can be considered the inverse of . LManually implement vector shuffling using insertelement and extractelement. In contrast to LLVM':s built-in instruction it supports distinct vector sizes, $but it allows only one input vector =(or a tuple of vectors, but we cannot shuffle between them). (For more complex shuffling we recommend  and . 0Rotate one element towards the higher elements. I don'-t want to call it rotateLeft or rotateRight, =because there is no prefered layout for the vector elements. In Intel's instruction manual vector $elements are indexed like the bits, that is from right to left. @However, when working with Haskell list and enumeration syntax, the start index is left. Implement the {! method using the methods of the } class. Kprovide the elements of a vector as a list of individual virtual registers &This can be considered the inverse of . 8Like LLVM.Util.Loop.mapVector but the loop is unrolled, >which is faster since it can be packed by the code generator. S8Like LLVM.Util.Loop.mapVector but the loop is unrolled, >which is faster since it can be packed by the code generator. T7Ideally on ix86 with SSE41 this would be translated to dpps. +If the target vector type is a native type Fthen the chop operation produces no actual machine instruction. (nop) 3If the vector cannot be evenly divided into chunks 5the last chunk will be padded with undefined values. +The target size is determined by the type. EIf the chunk list provides more data, the exceeding data is dropped. )If the chunk list provides too few data, 5the target vector is filled with undefined elements. U6We partition a vector of size n into chunks of size m -and add these chunks using vector additions. .We do this by repeated halving of the vector, Hsince this way we do not need assumptions about the native vector size. *We reduce the vector size only virtually, Dthat is we maintain the vector size and fill with undefined values. This is reasonable Wsince LLVM-2.5 and LLVM-2.6 does not allow shuffling between vectors of different size ;and because it likes to do computations on Vector D2 Float in MMX registers on ix86 CPU's, &which interacts badly with FPU usage. 0Since we fill the vector with undefined values, ?LLVM actually treats the vectors like vectors of smaller size. Needs (log n) vector additions ufghijklmnopqrstuvwVxyz{|}~WXYZS[\T]^_`abUcdefghijklmnopqrstuvwxyz{|}~7fghijklmnopqrstuvwxyz{|}~7xyz{|}~uvwnopqrstfghijklmafghijklmnopqrstuvwVxyz{|}~WXYZS[\T]^_`abUcdefghijklmnopqrstuvwxyz{|}~ None0The fraction has the same sign as the argument. @This is not particular useful but fast on IEEE implementations. +increment (first operand) may be negative, "phase must always be non-negative .both increment and phase must be non-negative Rounds to the next integer. For numbers of the form n+0.5, *we choose one of the neighboured integers 8such that the overall implementation is most efficient. f!!YNone$This and the following type classes Fare intended for arithmetic operations on wrappers around LLVM types. 5E.g. you might define a fixed point fraction type by   newtype Fixed = Fixed Int32 Mand then use the same methods for floating point and fixed point arithmetic. -In contrast to the arithmetic methods in the llvm wrapper, 7in our methods the types of operands and result match. FAdvantage: Type inference determines most of the types automatically. 7Disadvantage: You cannot use constant values directly, $but you have to convert them all to . In Haskell terms this is a . .both increment and phase must be non-negative L==/ NoneAThe entire purpose of this datatype is to mark a type as scalar, 1although it might also be interpreted as vector. 6This way you can write generic operations for vectors  using the  class, 8and specialise them to scalar types with respect to the  class. From another perspective you can consider the   type constructor a marker  where the  type function 4stops reducing nested vector types to scalar types.  NoneIsomorphic to =ReaderT (CodeGenFunction r z) (ContT z (CodeGenFunction r)) a, (where the reader provides the block for  &and the continuation part manages the . %counterpart to Data.Maybe.HT.toMaybe  4Run an exception handler if the Maybe-action fails. The exception is propagated. :That is, the handler is intended for a cleanup procedure.  >Run the first action and if that fails run the second action. ;If both actions fail, then the composed action fails, too.  9If the returned position is smaller than the array size, then returned final state is `.                     !None It must hold 4 max x y == do gt <- cmp CmpGT x y; select gt x y G A nested . @ Since it is not obvious how deep to decompose nested tuples, 7 you must provide a pattern of the decomposed tuple.  E.g. " f :: MultiValue ((a,b),(c,d)) -> 7 ((MultiValue a, MultiValue b), MultiValue (c,d)) " f = decompose ((atom,atom),atom) J A nested . A combination of J and G =that let you operate on tuple multivalues as Haskell tuples. y !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~H !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None0Rotate one element towards the higher elements. I don'-t want to call it rotateLeft or rotateRight, =because there is no prefered layout for the vector elements. In Intel's instruction manual vector $elements are indexed like the bits, that is from right to left. @However, when working with Haskell list and enumeration syntax, the start index is left.       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghiYY      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghiNoneb     jk !"#$%&'()*l+,-mnopqrstuvwxyz{|}~%      !"#$%&'()*+,-% !"#$%&' ()*    +,-V     jk !"#$%&'()*l+,-mnopqrstuvwxyz{|}~None ./0123./0123./0123 ./0123None !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Z[TUVWXY\]^_`abcdefghijklmnopqrsQRStuvwxyz{|}~KLMNOPHIJFGEDBC@A>?:;<=8967534./012+,-*)'( !"#$%&None6An implementation of both N and "# must ensure that  haskellValue is compatible with Stored (Struct haskellValue) (which we want to call  llvmStruct). That is, writing and reading  llvmStruct by LLVM must be the same as accessing  haskellValue by Storable methods. <ToDo: In future we may also require Storable constraint for  llvmStruct. KWe use a functional dependency in order to let type inference work nicely. 2456789:;<=>?@ABCDE456789:;<=>?@ABCDE6789:;<54=>?@ABCDE&456789:;<=>?@ABCDENoneEFGHIJKLMNOPQ FGHIJKLMNOPQ KLMNOPFJGHIQAFGHIJKLMNOPQ$None"Not very efficient implementation because we want to adapt to  sizeOf Bool dynamically. Unfortunately, LLVM-9'8s optimizer does not recognize the instruction pattern.  Better use  for booleans. ZRSTUVWXYZ[\]^_`abc     defghijk !"#$%&'()*+,-./0123456789:;<=>?@ABCDEF5RSTUVWXYZ[\]^_`abc     defghijk !"RRSTUVWXYZ[\]^_`abc     defghijk !"#$%&'()*+,-./0123456789:;<=>?@ABCDEF%NonelmnolmnolmnoNoneRSTUVWXYZ[\]^_`abcdefghijklmno[\]^_XYZUVWRST`abcdefghijklmnoNonepSimulates a non-strict list. } Attention: <This always performs one function call more than necessary. I.e. if f reads from or writes to memory 4make sure that accessing one more pointer is legal. GZipList semantics pHqrstuvwxyz{|}I~GJpqrstuvwxyz{|}~pqrstuvw}xyz{|~pHqrstuvwxyz{|}I~GJNoneNoneK#Warning: For [0 .. (0xFFFF::Word16)] it would compute an undefined 0xFFFF+1. 6In modulo arithmetic it would enter an infinite loop. LMKNLMKNNone,OP**"OPQ&'(&')&'*&'+&',&'-&'.&/0123#456789:;<=>?@ABCDECDFCDGCDHIJKLMNOPQRSTUV3W XYZ[\]^_ X`a\bJcdefghijklmnopqrstu r s t < = > 8 9 : ;  XvwxQ y z { | } ~         # y z { | CCCC      } ~   }~9  X k  X|de`fxcOKL!!!!!!!!!!!!!!!!I!J!!!!!!!!!!!!!!!}!~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ! ! !#! !;!9!=!>! !X!!!!!!!!!!!!!!!!!!! !!!"!#!$!%!&!!x!f!'!(!)!*!+!,!-!.!/!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!!k!S!E!G!!!!!!TIJ}~# ;9=>r XUV;<>?WXYzZ[|\]^_Q``abcdefgghijkkllmmnnoopqrstuvwxyz{|}~##$$$$$$$a$$$#$$$$$$$$$$$$$$$$%K%L%%  \OKML '(/+,012567;<>?\]ZJ#$\#;9~vwx      !"#$%&'()*+,-./01234567 # 7          &89&8: ; < =  > ? @ 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 q r s t u v w x y 9 z { | } ~                                                  P Q R S T U V W X Y  Z [   &r             !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ! ! ! !!!!!!!!!!!!!!!!!!!!!! !!!!"!#!$!%!&!'!(!)!*!+!,!-!.!/!0!!1!!!!2!!!U!V!W!X!Y!P!Q!R!S!T!Z![!!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!r!t!l!m!n!o!p!q!r!s!t!u!v!w!x!y!z!{!|!}!~!!!!!!yAB?@RkS      "#Z[56BCLMNOPGHIJKQRjrt}~wxyz{pimovkrtqkrtqrstuwxyz{}~$$$$ $ $ $$$ $ $$$$$$$$$$$$$$$$$$$q$$ $!$"$#$$$%$&$'$($)$*$+$,$-$.$/$$0$1$j$e$p$w$x$y$z${$}$~$$$$$X23456im7llvm-extra-0.10.1LLVM.Extra.ArithmeticLLVM.Extra.MarshalLLVM.Extra.FunctionLLVM.Extra.TupleLLVM.Extra.ControlLLVM.Extra.EitherLLVM.Extra.MaybeLLVM.Extra.MonadLLVM.Extra.StructLLVM.Extra.ArrayLLVM.Extra.VectorLLVM.Extra.ScalarOrVectorLLVM.Extra.ScalarLLVM.Extra.MaybeContinuationLLVM.Extra.Multi.ValueLLVM.Extra.Multi.VectorLLVM.Extra.FastMath LLVM.Extra.Multi.Vector.InstanceLLVM.Extra.MemoryLLVM.Extra.StorableLLVM.Extra.IteratorLLVM.Extra.Multi.Value.VectorLLVM.Extra.Multi.IteratorLLVM.Extra.Multi.ClassLLVM.Extra.TuplePrivateLLVM.Extra.EitherPrivateLLVM.Extra.MaybePrivate Data.Maybe fromMaybeLLVM.Extra.MemoryPrivateScalarTLLVM.Extra.Multi.Value.PrivateMemoryCLLVM.Extra.Storable.PrivateLLVM.Extra.Storable.Arrayz-llvm-tf-z-private-9.2LLVM.Core.Instructions.Private CmpPredicateCmpEQCmpNECmpGTCmpGECmpLTCmpLELLVM.ExecutionEngine.MarshalallocaReturnResultretCodeGendefinecreate createNamedZerozero UndefinedundefPhiphiaddPhiphiTraversableaddPhiFoldable undefPointed zeroPointedz-llvm-extra-z-private-0.10.1LLVM.Extra.ArithmeticPrivateincdecreaseArrayElementPtrdecadvanceArrayElementPtrSelectselect arrayLoop arrayLoop2arrayLoopWithExitarrayLoop2WithExitfixedLengthLoop whileLoop loopWithExitwhileLoopShared ifThenElseifThenselectTraversable ifThenSelectretVoidConsisRightfromLeft fromRightrunmapLeftmapRight getIsLeftisJustfromJustfor alternativefromBooltoBooljust getIsNothinglift2sequencetraverseliftM2chainliftR2liftR3 VectorValue VectorValueOf vectorValueOfValueValueOfvalueOfvalueOfFunctorleftrightnothingsizeassemble extractAllmapRealminmaxabssignumtruncatefractionfloor Arithmeticsum sumToPairsumInterleavedToPaircumulate dotProductmul Canonical ConstructConstantSimpleElementSize shuffleMatchextractinsertconstant replicate insertChunkiterateshuffle sizeInTuplerotateUp rotateDownreverseshiftUp shiftDownshiftUpMultiZeroshiftDownMultiZeroshuffleMatchTraversableshuffleMatchAccessshuffleMatchPlain1shuffleMatchPlain2insertTraversableextractTraversablemodify mapChunks zipChunksWithchopconcat cumulate1signedFraction LLVM.Extra.ScalarOrVectorPrivatereplicateConst ReplicateTranscendentalConstantconstPiRationalConstantconstFromRationalIntegerConstantconstFromInteger PseudoModulescale scaleConst SaturatedaddSatsubSatFraction addToPhaseincPhase truncateToIntroundToIntFast floorToIntsplitFractionToInt ceilingToInt replicateOfTranscendentalpisinlogexpcospow AlgebraicsqrtLogicandorxorinvFloatingComparisonfcmp Comparison CmpResultcmp fromRational'Fieldfdiv fromInteger' PseudoRingAdditiveaddsubnegonesquareidiviremdeconsliftMunliftMunliftM2unliftM3unliftM4unliftM5resolvewithBoolfromPlainMaybetoMaybeliftguardbindonFailIntegralBitShiftshlshrNativeFloating NativeIntegerAtom PatternTuple Decomposed Decompose decomposeComposeComposedcomposeStruct consStruct undefStruct zeroStruct phiStruct addPhiStructBoundedminBoundmaxBoundcons consPrimitiveundefPrimitive zeroPrimitive phiPrimitiveaddPhiPrimitive consTuple undefTuple zeroTuplephiTuple addPhiTupleconsUnit undefUnitzeroUnitphiUnit addPhiUnit boolPFrom8 bool8FromP intFromBool8floatFromBool8toEnumfromEnumsuccpredcmpEnum splitMaybefstsndcurryuncurrymapFstmapSndmapFstFmapSndFswapfst3snd3thd3curry3uncurry3mapFst3mapSnd3mapThd3mapFst3FmapSnd3FmapThd3Fzipzip3zip4unzipunzip3unzip4tupleuntuple structCons structUnconstaguntag liftTaggedM liftTaggedM2 consComplex deconsComplexmodify2modifyFmodifyF2atomrealPartimagPartlift1liftM0liftM3 fromIntegralconsPrim deconsPrimshufflePrimitiveextractPrimitiveinsertPrimitivedissect dissectListtaketakeRevshiftUpMultiUndefshiftDownMultiUndefContextTuple setTupleFlags MultiVectorsetMultiVectorFlags MultiValuesetMultiValueFlagsNumber deconsNumberFlagssetFlagsFastAllowReciprocal NoSignedZerosNoInfsNoNaNs getNumbermvNumber mvDenumberattachMultiValueFlags liftNumberM liftNumberM2 mvecNumber mvecDenumberattachMultiVectorFlagsliftMultiVectorMliftMultiVectorM2attachTupleFlags liftContext liftContext2MVVector toMultiValuefromMultiValueliftMultiValueMliftMultiValueM2liftMultiValueM3Recordloadstoreelement loadRecord storeRecorddecomposeRecord composeRecord loadNewtype storeNewtypedecomposeNewtypecomposeNewtypeMVVector packVector unpackVector VectorStructpackunpackpeekpokewith TupleVector deinterleave interleaveassembleVectordisassembleVector loadTuple storeTuple storeNextloadMultiValuestoreMultiValuestoreNextMultiValuemodifyMultiValueloadTraversableloadApplicative storeFoldable advancePtr incrementPtr decrementPtrarrayLoopMaybeContarrayLoopMaybeCont2mapM_ mapState_ mapStateM_mapWhileState_empty singletonmapMmapMaybe catMaybes takeWhileJust takeWhile cartesian countDown arrayPtrsstorableArrayPtrsEnumenumFrom enumFromToOp2runOp2Op1runOp1Op0runOp0ConstgetConstswitchaddRetproxyFromElement2$fReturnStablePtr$fReturnFunPtr $fReturnPtr $fReturnPtr0$fReturnDouble $fReturnFloat$fReturnWord64$fReturnWord32$fReturnWord16 $fReturnWord8 $fReturnWord $fReturnInt64 $fReturnInt32 $fReturnInt16 $fReturnInt8 $fReturnInt $fReturnBool $fReturn()$fCIO$fC(->)$fZeroT $fZeroComplex $fZero(,,,) $fZero(,,) $fZero(,)$fZeroConstValue $fZeroValue$fZero() $fUndefinedT$fUndefinedComplex$fUndefined(,,,)$fUndefined(,,)$fUndefined(,)$fUndefinedConstValue$fUndefinedValue $fUndefined()$fPhiT $fPhiComplex $fPhi(,,,) $fPhi(,,)$fPhi(,) $fPhiValue$fPhi()_arrayLoopWithExitDecLoop _whileLoop _emitCode $fSelect(,,) $fSelect(,) $fSelect() $fSelectValuebase Data.EithereithermaybemaybeArg $fFunctorTdecomposeFromLoadcomposeFromStorevectorFromList$fVectorValuenWord64$fVectorValuenWord32$fVectorValuenWord16$fVectorValuenWord8$fVectorValuenWord$fVectorValuenInt64$fVectorValuenInt32$fVectorValuenInt16$fVectorValuenInt8$fVectorValuenInt$fVectorValuenBool8$fVectorValuenBool$fVectorValuenDouble$fVectorValuenFloat$fVectorValuenTuple$fVectorValuen(,,)$fVectorValuen(,)$fVectorValuenVector$fValueComplex$fValueT $fValueT0 $fValueTagged $fValueVector$fValueStablePtr $fValueFunPtr $fValuePtr $fValuePtr0 $fValueWordN $fValueIntN $fValue() $fValueWord64 $fValueWord32 $fValueWord16 $fValueWord8 $fValueWord $fValueInt64 $fValueInt32 $fValueInt16 $fValueInt8 $fValueInt $fValueBool8 $fValueBool $fValueDouble $fValueFloat $fValueEither $fValueMaybe $fValueTuple $fValue(,,,) $fValue(,,) $fValue(,)LLVM.Core.Instructions insertvalue extractvalue _mapByFolddotProductPartialreduceSumInterleaved replicateCore iterateCoreconstCyclicVector extractList mapChunks2_zipChunks2With sumPartialchopCore getLowestPair_reduceAddInterleaved sumGenericsumToPairGeneric_cumulateSimplecumulateGeneric cumulateFrom1signumIntGenericsignumWordGenericsignumFloatGeneric $fRealWord64 $fRealWord32 $fRealWord16 $fRealWord8 $fRealWord $fRealInt64 $fRealInt32 $fRealInt16 $fRealInt8 $fRealInt $fRealDouble $fRealFloat$fArithmeticWord64$fArithmeticWord32$fArithmeticWord16$fArithmeticWord8$fArithmeticWord$fArithmeticInt64$fArithmeticInt32$fArithmeticInt16$fArithmeticInt8$fArithmeticInt$fArithmeticDouble$fArithmeticFloat$fCanonicaln(,,)$fCanonicaln(,)$fCanonicalnValue$fSimpleConstant$fUndefinedConstant $fPhiConstant$fTraversableConstant$fFoldableConstant$fApplicativeConstant$fFunctorConstant$fC(,,) $fSimple(,,)$fC(,) $fSimple(,)$fCValue $fSimpleValue _fractionGen_fractionLogicalintratio addSatProxy subSatProxy$fTranscendentalConstantVector$fTranscendentalConstantDouble$fTranscendentalConstantFloat$fRationalConstantVector$fRationalConstantDouble$fRationalConstantFloat$fIntegerConstantVector$fIntegerConstantIntN$fIntegerConstantWordN$fIntegerConstantDouble$fIntegerConstantFloat$fIntegerConstantInt64$fIntegerConstantInt32$fIntegerConstantInt16$fIntegerConstantInt8$fIntegerConstantInt$fIntegerConstantWord64$fIntegerConstantWord32$fIntegerConstantWord16$fIntegerConstantWord8$fIntegerConstantWord$fPseudoModuleVector$fPseudoModuleDouble$fPseudoModuleFloat$fPseudoModuleInt64$fPseudoModuleInt32$fPseudoModuleInt16$fPseudoModuleInt8$fPseudoModuleInt$fPseudoModuleWord64$fPseudoModuleWord32$fPseudoModuleWord16$fPseudoModuleWord8$fPseudoModuleWord$fSaturatedVector$fSaturatedWordN$fSaturatedIntN$fSaturatedWord64$fSaturatedWord32$fSaturatedWord16$fSaturatedWord8$fSaturatedWord$fSaturatedInt64$fSaturatedInt32$fSaturatedInt16$fSaturatedInt8$fSaturatedInt $fRealVector $fRealWordN $fRealIntN $fRealFP128$fFractionVector$fFractionDouble$fFractionFloatLLVM.Core.CodeGenGHC.Realquot_inc_dec$fTranscendentalValue$fAlgebraicValue$fLogicConstValue $fLogicValue$fFloatingComparisonConstValue$fFloatingComparisonValue$fComparisonConstValue$fComparisonValue$fFractionValue $fRealValue$fRationalConstantValue$fRationalConstantConstValue$fFieldConstValue $fFieldValue$fIntegerConstantValue$fIntegerConstantConstValue$fPseudoModuleConstValue$fPseudoModuleValue$fPseudoRingConstValue$fPseudoRingValue$fAdditive(,,) $fAdditive(,)$fAdditiveConstValue$fAdditiveValue$fTranscendentalT $fAlgebraicT $fFractionT$fRealT$fPseudoModuleT$fFieldT $fPseudoRingT $fAdditiveT$fRationalConstantT$fIntegerConstantTNothingJust $fMonadIOT$fMonadT$fApplicativeT$fIntegralTagged$fIntegralInt64$fIntegralInt32 $fIntegralInt$fIntegralWord64$fIntegralWord32$fIntegralWord$fBitShiftInt64$fBitShiftInt32$fBitShiftInt16$fBitShiftInt8 $fBitShiftInt$fBitShiftWord64$fBitShiftWord32$fBitShiftWord16$fBitShiftWord8$fBitShiftWord$fLogicT $fLogicTagged $fLogicT0 $fLogicWordN $fLogicWord64 $fLogicWord32 $fLogicWord16 $fLogicWord8 $fLogicBool8 $fLogicBool$fFloatingComparisonT$fFloatingComparisonTagged$fFloatingComparisonFloat $fComparisonT$fComparisonTagged$fComparisonWordN$fComparisonIntN$fComparisonWord64$fComparisonWord32$fComparisonWord16$fComparisonWord8$fComparisonWord$fComparisonInt64$fComparisonInt32$fComparisonInt16$fComparisonInt8$fComparisonInt$fComparisonDouble$fComparisonFloat $fSelectT$fSelectTagged $fSelectInt64 $fSelectInt32 $fSelectInt16 $fSelectInt8 $fSelectInt$fSelectWord64$fSelectWord32$fSelectWord16 $fSelectWord8 $fSelectWord$fSelectDouble $fSelectFloat $fSelectBool8 $fSelectBool$fTranscendentalTagged$fTranscendentalDouble$fTranscendentalFloat$fAlgebraicTagged$fAlgebraicDouble$fAlgebraicFloat$fNativeFloatingDoubleDouble$fNativeFloatingFloatFloat$fNativeIntegerTaggeda$fNativeIntegerInt64Int64$fNativeIntegerInt32Int32$fNativeIntegerInt16Int16$fNativeIntegerInt8Int8$fNativeIntegerIntInt$fNativeIntegerWord64Word64$fNativeIntegerWord32Word32$fNativeIntegerWord16Word16$fNativeIntegerWord8Word8$fNativeIntegerWordWord$fFractionTagged $fRealTagged$fPseudoModuleTagged $fFieldTagged $fFieldDouble $fFieldFloat$fPseudoRingTagged$fPseudoRingInt64$fPseudoRingInt32$fPseudoRingInt16$fPseudoRingInt8$fPseudoRingInt$fPseudoRingWord64$fPseudoRingWord32$fPseudoRingWord16$fPseudoRingWord8$fPseudoRingWord$fPseudoRingDouble$fPseudoRingFloat$fAdditiveTagged$fAdditiveIntN$fAdditiveWordN$fAdditiveInt64$fAdditiveInt32$fAdditiveInt16$fAdditiveInt8 $fAdditiveInt$fAdditiveWord64$fAdditiveWord32$fAdditiveWord16$fAdditiveWord8$fAdditiveWord$fAdditiveDouble$fAdditiveFloat$fRationalConstantTagged$fIntegerConstantTagged$fDecomposeComplex$fComposeComplex$fDecomposeTagged$fComposeTagged$fDecomposeTuple$fComposeTuple$fDecompose(,,,)$fCompose(,,,)$fDecompose(,,) $fCompose(,,)$fDecompose(,) $fCompose(,) $fDecompose() $fCompose()$fDecomposeAtom $fComposeT $fCComplex $fCTagged $fStruct(,) $fStruct()$fCT$fCTuple$fC(,,,)$fCMaybe$fCT0 $fBoundedT$fCT1$fCBool8$fC() $fCStablePtr $fCFunPtr$fCPtr$fCPtr0$fCIntN$fCInt64$fCInt32$fCInt16$fCInt8$fCInt$fCWordN $fCWord64 $fCWord32 $fCWord16$fCWord8$fCWord $fCDouble$fCFloat$fCBool PrimValuefromIntegerPrimitivefromRationalPrimitiveshiftUpMultiIndicesshiftDownMultiIndices_liftM0Id setSplitFlagsproxyFromContext$fTranscendentalContext$fAlgebraicContext$fFloatingComparisonContext$fComparisonContext$fFractionContext $fRealContext$fRationalConstantContext$fFieldContext$fIntegerConstantContext$fPseudoModuleContext$fPseudoRingContext$fAdditiveContext $fZeroContext $fTupleValue$fFloatingComparisonNumber$fComparisonNumber$fSelectNumber$fTranscendentalNumber$fAlgebraicNumber$fFractionNumber $fRealNumber $fFieldNumber$fPseudoRingNumber$fAdditiveNumber$fRationalConstantNumber$fIntegerConstantNumber $fCNumber$fVectorValuenNumber$fMultiVectorDouble$fMultiVectorFloat$fFloatingComparisonNumber0$fComparisonNumber0$fSelectNumber0$fTranscendentalNumber0$fAlgebraicNumber0$fFractionNumber0 $fRealNumber0$fPseudoModuleNumber$fFieldNumber0$fPseudoRingNumber0$fAdditiveNumber0$fRationalConstantNumber0$fIntegerConstantNumber0$fDecomposeNumber$fComposeNumber$fMultiValueDouble$fMultiValueFloat $fCNumber0 $fValueNumber $fFlags(,,,,) $fFlags(,,,) $fFlags(,,) $fFlags(,) $fFlagsFast$fFlagsAllowReciprocal$fFlagsNoSignedZeros $fFlagsNoInfs $fFlagsNoNaNs$fBitShiftVector $fLogicVector$fAdditiveVector $fCVector ConvertStructdecomposeFields composeFields StructStruct loadElement storeElementextractElement insertElementpairtriple quadruple iterateTravdecSucc$fConvertStructsi()$fConvertStructsi(,)$fCT2$fCT3$fCT4$fCT5$fApplicativeElement$fFunctorElement $fMV(,,,)$fMV(,,)$fMV(,)$fMV() $fMVStablePtr $fMVFunPtr$fMVPtr$fMVPtr0 $fMVInt64 $fMVInt32 $fMVInt16$fMVInt8$fMVInt $fMVWord64 $fMVWord32 $fMVWord16 $fMVWord8$fMVWord $fMVDouble $fMVFloat $fVectorn(,,) $fVectorn(,)$fVectornInt64$fVectornInt32$fVectornInt16 $fVectornInt8 $fVectornInt$fVectornWord64$fVectornWord32$fVectornWord16$fVectornWord8 $fVectornWord$fVectornDouble$fVectornFloat $fVectornBool bool8-0.0.1.1 Data.Bool8Bool8BytePtr loadPrimitivestorePrimitive incPtrState runElements elementPtr elementOffsetassemblePrimitivedisassemblePrimitiveindicesrmapPtr loadState storeStateupdateadvancePtrStateadvancePtrStatic addPointer castToBytePtrcastFromBytePtrcastElementPtrsizeOfelementFromPtrelementFromProxyproxyFromElement3$fTupleVector(,,)$fTupleVector(,) $fVectorTuple $fVectorBool8 $fVectorBool $fVectorInt64 $fVectorInt32 $fVectorInt16 $fVectorInt8 $fVectorInt$fVectorWord64$fVectorWord32$fVectorWord16 $fVectorWord8 $fVectorWord$fVectorDouble $fVectorFloat $fTuple(,,) $fTuple(,) cartesianAux_enumFromToSimple unpackBoolsuccMax$fEnumT