!^]      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                    ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~          !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\!NoneHVG  llvm-extra WCodeGen (a->b->...-> IO z) = Value a -> Value b -> ... CodeGenFunction r (Value z)@.    SafeH##$%#$%NoneHq &'()*,+-./0NoneHVX] llvm-extraAn alternative to 9 where I try to persuade LLVM to use x86's LOOP instruction. Unfortunately it becomes even worse. LLVM developers say that x86 LOOP is actually slower than manual decrement, zero test and conditional branch.= llvm-extraFThis is a loop with a single point for exit from within the loop. The Bool5 value indicates whether the loop shall be continued.> llvm-extraThis is a variant of <n that may be more convient, because you only need one lambda expression for both loop condition and loop body.? llvm-extraKThis construct starts new blocks, so be prepared when continueing after an ?.B llvm-extraBranch-free variant of @ that 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.C llvm-extraC terminates a basic block which interferes badly with other control structures in this module. If you use the control structures then better use LLVM.Extra.Function.56789:;<=>?@ABCD789:;<>=?@56ABCDNoneHV\I llvm-extraIf isJust = False, then fromJust is an  undefTuple.M llvm-extracounterpart to ^O llvm-extracounterpart to  with swapped argumentsQ llvm-extra$counterpart to Data.Maybe.HT.toMaybeIJLKMNOPQRS_TUVWX`NoneHVa^Y llvm-extraIf isRight, then fromLeft is an  undefTuple. If  not isRight, then  fromRight is an  undefTupleh. I would prefer a union type, but it was temporarily removed in LLVM-2.8 and did not return since then.^ llvm-extracounterpart to a YZ]\[^_`abcNone =>?@AHUVb&'()*+,-./0bcdefgh*+,-.()/&'0efghbcdNone>HVc None>HUVgd llvm-extra>Not very efficient implementation because we want to adapt to  sizeOf Boolg dynamically. Unfortunately, LLVM-9's optimizer does not recognize the instruction pattern. Better use e for booleans.1fghijklmnopqrstuvwxyz{|}~NoneHVh*IJKLMNOPQRSTUVWXIJKLMNOPQRTSVWUX Nonen llvm-extra)construct an array out of single elementsCYou must assert that the length of the list matches the array size.&This can be considered the inverse of . llvm-extraJprovide the elements of an array as a list of individual virtual registers&This can be considered the inverse of . llvm-extraThe loop is unrolled, since  and  expect constant indices.NoneHVo$ YZ[\]^_`a YZ[\]^a_` None =>?@AHUV  llvm-extra^The order of addition is chosen for maximum efficiency. We do not try to prevent cancelations. llvm-extraCThe first result value is the sum of all vector elements from 0 to  div n 2 + 1C and the second result value is the sum of vector elements from div n 2 to n-1. n must be at least D2. llvm-extraTreat the vector as concatenation of pairs and all these pairs are added. Useful for stereo signal processing. n must be at least D2. llvm-extra/Allow to work on records of vectors as if they are vectors of records. This is a reasonable approach for records of different element types since 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  -b (Element, Size). Now we have only the dependency Vector -> (Element, Size). This means that we need some more type annotations as in umul32to64/assemble, on the other hand we can allow multiple vector types with respect to the same element type. E.g. we can provide a vector type with pair elements where the pair elements are interleaved in the vector. llvm-extraPManually assemble a vector of equal values. Better use ScalarOrVector.replicate. llvm-extra)construct a vector out of single elementsDYou must assert that the length of the list matches the vector size.&This can be considered the inverse of . llvm-extra#Manually 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 . llvm-extra/Rotate 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. llvm-extraImplement the ! method using the methods of the  class. llvm-extraJprovide the elements of a vector as a list of individual virtual registers&This can be considered the inverse of . llvm-extrauLike LLVM.Util.Loop.mapVector but the loop is unrolled, which is faster since it can be packed by the code generator. llvm-extrauLike LLVM.Util.Loop.mapVector but the loop is unrolled, which is faster since it can be packed by the code generator. llvm-extra7Ideally on ix86 with SSE41 this would be translated to dpps. llvm-extraIf the target vector type is a native type then the chop operation produces no actual machine instruction. (nop) If the vector cannot be evenly divided into chunks the last chunk will be padded with undefined values. llvm-extraThe target size is determined by the type. If the chunk list provides more data, the exceeding data is dropped. If the chunk list provides too few data, the target vector is filled with undefined elements. llvm-extraWe 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, since this way we do not need assumptions about the native vector size.We reduce the vector size only virtually, that is we maintain the vector size and fill with undefined values. This is reasonable since 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. Since we fill the vector with undefined values, LLVM actually treats the vectors like vectors of smaller size. llvm-extraNeeds (log n) vector additions77 None>HUV G llvm-extraoThe fraction has the same sign as the argument. This is not particular useful but fast on IEEE implementations.H llvm-extraLincrement (first operand) may be negative, phase must always be non-negativeI llvm-extra-both increment and phase must be non-negativeK llvm-extra4Rounds to the next integer. For numbers of the form n+0.5c, we choose one of the neighboured integers such that the overall implementation is most efficient. 0123456789:;<=>?@ABCDEFGHIJKLMNO DEFGHIJLNKM3012O?@ABC<=>:;896745None>HV llvm-extraThis and the following type classes are intended for arithmetic operations on wrappers around LLVM types. E.g. you might define a fixed point fraction type by newtype Fixed = Fixed Int32Land then use the same methods for floating point and fixed point arithmetic.-In contrast to the arithmetic methods in the llvm wrapper, in our methods the types of operands and result match. Advantage: Type inference determines most of the types automatically. Disadvantage: You cannot use constant values directly, but you have to convert them all to . llvm-extraIn Haskell terms this is a . llvm-extra-both increment and phase must be non-negative@1234@4213 NoneHVɟ llvm-extraThe entire purpose of this datatype is to mark a type as scalar, although it might also be interpreted as vector. This way you can write generic operations for vectors using the @ class, and specialise them to scalar types with respect to the 6 class. From another perspective you can consider the !"% type constructor a marker where the B type function stops reducing nested vector types to scalar types.  #None =>?@AHUV llvm-extra It must hold 2max x y == do gt <- cmp CmpGT x y; select gt x y- llvm-extra A nested w. Since it is not obvious how deep to decompose nested tuples, you must provide a pattern of the decomposed tuple. E.g. wf :: MultiValue ((a,b),(c,d)) -> ((MultiValue a, MultiValue b), MultiValue (c,d)) f = decompose ((atom,atom),atom)0 llvm-extra A nested t. llvm-extraA combination of 0 and -= that let you operate on tuple multivalues as Haskell tuples.      #"!$%&'()*+,-.0/165432798:@=?><;ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None =>?@AHUV< llvm-extraNeeds (log n) vector additions llvm-extra/Rotate 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.ffNoneHVNone@AHUV`None =>?@AHUV llvm-extraAn implementation of both e 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 StorableF methods. ToDo: In future we may also require Storable constraint for  llvmStruct.JWe use a functional dependency in order to let type inference work nicely. llvm-extraIn principle it holds: Tdecompose struct = do ptr <- LLVM.alloca LLVM.store struct ptr Memory.load ptrbut + will blast your stack when used in a loop. llvm-extraIn principle it holds: Rcompose struct = do ptr <- LLVM.alloca Memory.store struct ptr LLVM.load ptrbut + will blast your stack when used in a loop.None =>?@AHUV  &None>HUVNone-      !"#$%&'()*+,-./0123456789:;<>?=@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~AB:@=?><;CDEFGHIJKLMNOPQRSTUVWXYZ[798\]^_`abcdefghijklmnopqrstuvwxyz{165432|}~.0/,-+*()&'$% #"!     None =>?@AHUV  !"#$%&' !"#$%& 'NoneHUV*MNOPQRSTUVWXY[Z\]^_`abcdefghijklmnopqrstuv*Y[ZVWX\]STUPQRMNO^_`abcdefghijklmnopqrstuvNoneHVy llvm-extraIsomorphic to =ReaderT (CodeGenFunction r z) (ContT z (CodeGenFunction r)) a*, where the reader provides the block for ' and the continuation part manages the .} llvm-extra$counterpart to Data.Maybe.HT.toMaybe llvm-extraRun an exception handler if the Maybe-action fails. The exception is propagated. That is, the handler is intended for a cleanup procedure. llvm-extraxRun the first action and if that fails run the second action. If both actions fail, then the composed action fails, too. llvm-extraVIf the returned position is smaller than the array size, then returned final state is .yz{|}~yz{|}~'NoneHUV None0NoneHUV llvm-extra>Not very efficient implementation because we want to adapt to  sizeOf Boolg dynamically. Unfortunately, LLVM-9's optimizer does not recognize the instruction pattern. Better use e for booleans.NoneEHSVX  llvm-extraSimulates a non-strict list. llvm-extraOAttention: This always performs one function call more than necessary. I.e. if fS reads from or writes to memory make sure that accessing one more pointer is legal. llvm-extraZipList semanticsNoneHV llvm-extraCWarning: For [0 .. (0xFFFF::Word16)] it would compute an undefined 0xFFFF+17. In modulo arithmetic it would enter an infinite loop.NoneHMUV%     %     ()*()+(),()-().()/()0123%456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\Z[]Z[^Z[_`abcdefghijklm3nopqr"stuvwaxyz{|}~"svSTUOPQR"s    % h          %                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < =Z>?Z>Z>@Z>! A B C D E F G H I J K  L  M N O P Q R S T U V W 2 3 4 5 6 7 8 9 : ; 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 { | } ~            LCEGH!PMN " s                  (################`#a############L########G#H#!#########C##E####################%###R#P#T#U#"#s########################## # ##{# # # ################### #!#"###$#%#&#'#(#)#*#+#,#-#.##/#0#1#2#3#4#5#6###7#_#]#O#Q#S#P#R#8`aLG9CE%RPTU"s:; "#<=>?@ABCDEF GH 5H8IJKLMNOPQRSTUVW{|}~yzXYZ[\]^_`abcdefgjk789:;23456<=Z[hijklmnopqrstuvwopxyz{|}~YUv   "#EF?Ba8OR%%OPQRSJKLMNTUW&&&&&%OPQRSJKLMNTUW%RPH"syz t{xfbc'b'c''%VWOPQRSJKLMNTU  I   " !"#$%&'(E)*fbdc+,-&(E.//012345567899::;;<<==>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ W                           ((   ((llvm-extra-0.12-inplaceLLVM.Extra.ArithmeticLLVM.Extra.FunctionLLVM.Extra.MonadLLVM.Extra.TupleLLVM.Extra.ControlLLVM.Extra.MaybeLLVM.Extra.EitherLLVM.Extra.StructLLVM.Extra.StorableLLVM.Extra.ArrayLLVM.Extra.VectorLLVM.Extra.ScalarOrVectorLLVM.Extra.ScalarLLVM.Extra.Multi.Value.MarshalLLVM.Extra.Multi.ValueLLVM.Extra.Multi.Vector LLVM.Extra.Multi.Vector.InstanceLLVM.Extra.Multi.Value.VectorLLVM.Extra.MemoryLLVM.Extra.MarshalLLVM.Extra.Multi.ClassLLVM.Extra.MaybeContinuationLLVM.Extra.Multi.Value.StorableLLVM.Extra.IteratorLLVM.Extra.Multi.IteratorLLVM.Extra.FastMathLLVM.Extra.TuplePrivateLLVM.Extra.MaybePrivate Data.Maybe fromMaybeLLVM.Extra.EitherPrivateLLVM.Extra.Storable.PrivateScalarTLLVM.Extra.Multi.Value.PrivateMemoryCLLVM.Extra.Multi.Value.ArrayLLVM.Extra.Storable.Arrayllvm-tf-17.0-inplace-privateLLVM.Core.Instructions.Private CmpPredicateCmpEQCmpGECmpGTCmpLECmpLTCmpNEReturnResultretCodeGendefinecreate createNamed$fC->$fReturnStablePtr$fReturnFunPtr $fReturnPtr $fReturnPtr0$fReturnDouble $fReturnFloat$fReturnWord64$fReturnWord32$fReturnWord16 $fReturnWord8 $fReturnWord $fReturnInt64 $fReturnInt32 $fReturnInt16 $fReturnInt8 $fReturnInt $fReturnBool $fReturn()$fCIOchainliftR2liftR3Zerozero UndefinedundefPhiphiaddPhiphiTraversableaddPhiFoldable undefPointed zeroPointedllvm-extra-0.12-inplace-privateLLVM.Extra.ArithmeticPrivateadvanceArrayElementPtrdecdecreaseArrayElementPtrincSelectselect arrayLoop arrayLoop2arrayLoopWithExitarrayLoop2WithExitfixedLengthLoop whileLoop loopWithExitwhileLoopShared ifThenElseifThenselectTraversable ifThenSelectretVoid $fSelect(,,) $fSelect(,) $fSelect() $fSelectValueConsisJustfromJustrunfor alternativefromBooltoBooljust getIsNothinglift2sequencetraverseliftM2isRightfromLeft fromRightmapLeftmapRight getIsLeft VectorValue VectorValueOf vectorValueOfValueValueOfvalueOfvalueOfFunctor$fValueComplex$fValueT $fValueT0 $fValueTagged$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(,)$fVectorValuenWord64$fVectorValuenWord32$fVectorValuenWord16$fVectorValuenWord8$fVectorValuenWord$fVectorValuenInt64$fVectorValuenInt32$fVectorValuenInt16$fVectorValuenInt8$fVectorValuenInt$fVectorValuenBool8$fVectorValuenBool$fVectorValuenDouble$fVectorValuenFloat$fVectorValuenTuple$fVectorValuen(,,)$fVectorValuen(,)$fVectorValuenVector $fValueVector $fUndefined()$fUndefined(,) $fUndefinedT$fZero() $fZero(,)$fZeroT$fPhi()$fPhi(,)$fPhiT TupleVector deinterleave interleaveVectorassembleVectordisassembleVectorTuple loadTuple storeTupleloadstore storeNextmodify loadNewtype storeNewtypeloadTraversableloadApplicative storeFoldable advancePtr incrementPtr decrementPtrnothingsizeassemble extractAllmapleftrightRealminmaxabssignumtruncatefloorfraction Arithmeticsum sumToPairsumInterleavedToPaircumulate dotProductmul Canonical ConstructConstantSimpleElementSize shuffleMatchextractinsertconstant replicate insertChunkiterateshuffle sizeInTuplerotateUp rotateDownreverseshiftUp shiftDownshiftUpMultiZeroshiftDownMultiZeroshuffleMatchTraversableshuffleMatchAccessshuffleMatchPlain1shuffleMatchPlain2insertTraversableextractTraversable mapChunks zipChunksWithchopconcat cumulate1signedFraction $fSimple(,,) $fSimple(,) $fSimpleValue$fC(,,)$fC(,)$fCValue$fSimpleConstant$fUndefinedConstant $fPhiConstant$fTraversableConstant$fFoldableConstant$fApplicativeConstant$fFunctorConstant$fCanonicaln(,,)$fCanonicaln(,)$fCanonicalnValue$fArithmeticWord64$fArithmeticWord32$fArithmeticWord16$fArithmeticWord8$fArithmeticWord$fArithmeticInt64$fArithmeticInt32$fArithmeticInt16$fArithmeticInt8$fArithmeticInt$fArithmeticDouble$fArithmeticFloat $fRealWord64 $fRealWord32 $fRealWord16 $fRealWord8 $fRealWord $fRealInt64 $fRealInt32 $fRealInt16 $fRealInt8 $fRealInt $fRealDouble $fRealFloat LLVM.Extra.ScalarOrVectorPrivate ReplicatereplicateConstTranscendentalConstantconstPiRationalConstantconstFromRationalIntegerConstantconstFromInteger PseudoModulescale SaturatedaddSatsubSatFraction addToPhaseincPhase truncateToIntroundToIntFast floorToIntsplitFractionToInt ceilingToInt replicateOf $fRealVector $fRealWordN $fRealIntN $fRealFP128$fFractionVector$fFractionDouble$fFractionFloat$fSaturatedVector$fSaturatedWordN$fSaturatedIntN$fSaturatedWord64$fSaturatedWord32$fSaturatedWord16$fSaturatedWord8$fSaturatedWord$fSaturatedInt64$fSaturatedInt32$fSaturatedInt16$fSaturatedInt8$fSaturatedInt$fPseudoModuleVector$fPseudoModuleDouble$fPseudoModuleFloat$fPseudoModuleInt64$fPseudoModuleInt32$fPseudoModuleInt16$fPseudoModuleInt8$fPseudoModuleInt$fPseudoModuleWord64$fPseudoModuleWord32$fPseudoModuleWord16$fPseudoModuleWord8$fPseudoModuleWord$fIntegerConstantVector$fIntegerConstantIntN$fIntegerConstantWordN$fIntegerConstantDouble$fIntegerConstantFloat$fIntegerConstantInt64$fIntegerConstantInt32$fIntegerConstantInt16$fIntegerConstantInt8$fIntegerConstantInt$fIntegerConstantWord64$fIntegerConstantWord32$fIntegerConstantWord16$fIntegerConstantWord8$fIntegerConstantWord$fRationalConstantVector$fRationalConstantDouble$fRationalConstantFloat$fTranscendentalConstantVector$fTranscendentalConstantDouble$fTranscendentalConstantFloatTranscendentalpisincosexplogpow AlgebraicsqrtLogicandorxorinvFloatingComparisonfcmp Comparison CmpResultcmp fromRational'Fieldfdiv fromInteger' PseudoRingAdditiveaddsubnegonesquareidiviremexp2log2log10$fAdditive(,,) $fAdditive(,)$fAdditiveConstValue$fAdditiveValue$fPseudoRingConstValue$fPseudoRingValue$fPseudoModuleValue$fIntegerConstantValue$fIntegerConstantConstValue $fFieldValue$fRationalConstantValue$fRationalConstantConstValue $fRealValue$fFractionValue$fComparisonConstValue$fComparisonValue$fFloatingComparisonConstValue$fFloatingComparisonValue$fLogicConstValue $fLogicValue$fAlgebraicValue$fTranscendentalValuedeconsliftMunliftMunliftM2unliftM3unliftM4unliftM5$fTranscendentalT $fAlgebraicT $fFractionT$fRealT$fPseudoModuleT$fFieldT $fPseudoRingT $fAdditiveT$fRationalConstantT$fIntegerConstantTLLVM.ExecutionEngine.MarshalallocaIntegralBitShiftshlshrNativeFloating NativeIntegerAtom PatternTuple Decomposed Decompose decomposeComposeComposedcomposeStruct consStruct undefStruct zeroStruct phiStruct addPhiStructBoundedminBoundmaxBoundReprconscast consPrimitiveundefPrimitive zeroPrimitive phiPrimitiveaddPhiPrimitive consTuple undefTuple zeroTuplephiTuple addPhiTupleconsUnit undefUnitzeroUnitphiUnit addPhiUnit boolPFrom8 bool8FromP intFromBool8floatFromBool8toEnumfromEnumsuccpredcmpEnum splitMaybetoMaybefstsndcurryuncurrymapFstmapSndmapFstFmapSndFswapfst3snd3thd3curry3uncurry3mapFst3mapSnd3mapThd3mapFst3FmapSnd3FmapThd3Fzipzip3zip4unzipunzip3unzip4tupleuntuple structCons structUnconstaguntag liftTaggedM liftTaggedM2 consComplex deconsComplexmodify2modifyFmodifyF2atomrealPartimagPartlift1liftM0liftM3 fromIntegral scaleMulticonsPrim deconsPrimshufflePrimitiveextractPrimitiveinsertPrimitivedissect dissectList assemble1dissect1 dissectList1assembleFromVectortaketakeRevshiftUpMultiUndefshiftDownMultiUndef$fCTuple $fCWord64 $fCWord32 $fCWord16$fCWord8$fCWord$fCInt64$fCInt32$fCInt16$fCInt8$fCInt $fCDouble$fCFloat$fCBool8$fCBool$fAdditiveWord64$fAdditiveWord32$fAdditiveWord16$fAdditiveWord8$fAdditiveWord$fAdditiveInt64$fAdditiveInt32$fAdditiveInt16$fAdditiveInt8 $fAdditiveInt$fAdditiveDouble$fAdditiveFloat$fPseudoRingDouble$fPseudoRingFloat $fFieldDouble $fFieldFloat$fNativeIntegernInt64Int64$fNativeIntegernInt32Int32$fNativeIntegernInt16Int16$fNativeIntegernInt8Int8$fNativeIntegernIntInt$fNativeIntegernWord64Word64$fNativeIntegernWord32Word32$fNativeIntegernWord16Word16$fNativeIntegernWord8Word8$fNativeIntegernWordWord$fNativeFloatingnDoubleDouble$fNativeFloatingnFloatFloat$fAlgebraicDouble$fAlgebraicFloat$fTranscendentalDouble$fTranscendentalFloat $fSelectInt64 $fSelectInt32 $fSelectInt16 $fSelectInt8 $fSelectInt$fSelectWord64$fSelectWord32$fSelectWord16 $fSelectWord8 $fSelectWord $fSelectBool$fSelectDouble $fSelectFloat $fComparisonT$fComparisonInt64$fComparisonInt32$fComparisonInt16$fComparisonInt8$fComparisonInt$fComparisonWord64$fComparisonWord32$fComparisonWord16$fComparisonWord8$fComparisonWord$fComparisonDouble$fComparisonFloat$fFloatingComparisonT$fFloatingComparisonFloat$fLogicT $fLogicWord64 $fLogicWord32 $fLogicWord16 $fLogicWord8 $fLogicBool$fBitShiftInt64$fBitShiftInt32$fBitShiftInt16$fBitShiftInt8 $fBitShiftInt$fBitShiftWord64$fBitShiftWord32$fBitShiftWord16$fBitShiftWord8$fBitShiftWordMVVector toMultiValuefromMultiValueliftMultiValueMliftMultiValueM2liftMultiValueM3$fBitShiftVector $fLogicVector$fPseudoRingVector$fAdditiveVector $fCVector$fNativeIntegerVectorVector$fNativeIntegerInt64Int64$fNativeIntegerInt32Int32$fNativeIntegerInt16Int16$fNativeIntegerInt8Int8$fNativeIntegerIntInt$fNativeIntegerWord64Word64$fNativeIntegerWord32Word32$fNativeIntegerWord16Word16$fNativeIntegerWord8Word8$fNativeIntegerWordWord$fNativeFloatingVectorVector$fNativeFloatingDoubleDouble$fNativeFloatingFloatFloatRecordelement loadRecord storeRecorddecomposeRecord composeRecorddecomposeNewtypecomposeNewtype$fCT$fCT0$fCT1$fCT2$fCT3$fCT4 $fCComplex$fC(,,,)$fC()$fApplicativeElement$fFunctorElement$fConvertStructsi()$fConvertStructsi(,)$fCT5 packVector unpackVector VectorStructpackunpackpeekpokewith $fCStablePtr $fCFunPtr$fCPtr$fCPtr0 $fVectorn(,,) $fVectorn(,)$fVectornInt64$fVectornInt32$fVectornInt16 $fVectornInt8 $fVectornInt$fVectornWord64$fVectornWord32$fVectornWord16$fVectornWord8 $fVectornWord$fVectornDouble$fVectornFloat $fVectornBoolArray withArraySizeextractArrayValueinsertArrayValueOp2runOp2Op1runOp1Op0runOp0ConstgetConstswitchresolvewithBoolfromPlainMaybeliftguardbindonFail $fMonadIOT$fMonadT$fApplicativeT $fFunctorTarrayLoopMaybeContarrayLoopMaybeCont2 $fCStored $fTuple(,,) $fTuple(,) $fVectorBool8 $fVectorBool $fVectorInt64 $fVectorInt32 $fVectorInt16 $fVectorInt8 $fVectorInt$fVectorWord64$fVectorWord32$fVectorWord16 $fVectorWord8 $fVectorWord$fVectorDouble $fVectorFloat$fTupleVector(,,)$fTupleVector(,) $fVectorTuplemapM_ mapState_ mapStateM_mapWhileState_empty singletonmapMmapMaybe catMaybes takeWhileJust takeWhile cartesian countDown arrayPtrsstorableArrayPtrsEnumenumFrom enumFromTo$fEnumTContext setTupleFlags MultiVectorsetMultiVectorFlags MultiValuesetMultiValueFlagsNumber deconsNumberFlagssetFlagsFastAllowReciprocal NoSignedZerosNoInfsNoNaNs getNumbermvNumber mvDenumberattachMultiValueFlags liftNumberM liftNumberM2 mvecNumber mvecDenumberattachMultiVectorFlagsliftMultiVectorMliftMultiVectorM2attachTupleFlags liftContext liftContext2 $fFlags(,,,,) $fFlags(,,,) $fFlags(,,) $fFlags(,) $fFlagsFast$fFlagsAllowReciprocal$fFlagsNoSignedZeros $fFlagsNoInfs $fFlagsNoNaNs$fDecomposeNumber$fComposeNumber$fFloatingComparisonNumber$fComparisonNumber$fSelectNumber$fTranscendentalNumber$fAlgebraicNumber$fFractionNumber $fRealNumber$fPseudoModuleNumber $fFieldNumber$fPseudoRingNumber$fAdditiveNumber$fRationalConstantNumber$fIntegerConstantNumber$fMultiValueDouble$fMultiValueFloat $fCNumber$fFloatingComparisonNumber0$fComparisonNumber0$fSelectNumber0$fTranscendentalNumber0$fAlgebraicNumber0$fFractionNumber0 $fRealNumber0$fFieldNumber0$fPseudoRingNumber0$fAdditiveNumber0$fRationalConstantNumber0$fIntegerConstantNumber0 $fCNumber0$fMultiVectorDouble$fMultiVectorFloat $fTupleValue$fTranscendentalContext$fAlgebraicContext$fFloatingComparisonContext$fComparisonContext$fFractionContext $fRealContext$fRationalConstantContext$fFieldContext$fIntegerConstantContext$fPseudoModuleContext$fPseudoRingContext$fAdditiveContext $fZeroContext $fShowNoNaNs $fEqNoNaNs $fShowNoInfs $fEqNoInfs$fShowNoSignedZeros$fEqNoSignedZeros$fShowAllowReciprocal$fEqAllowReciprocal $fShowFast$fEqFast $fEqNumber $fOrdNumber $fShowNumber $fNumNumber$fFractionalNumber$fFloatingNumber$fStorableNumber_arrayLoopWithExitDecLoopbasemaybemaybeArg Data.EithereitherNbool8-0.0.1.1-64b6e95ecf593f860ffad7ab45ec8581491e2bac455677ef275a98cd874c6ee9 Data.Bool8Bool8BytePtr loadPrimitivestorePrimitive incPtrState runElements loadElement storeElement elementPtr elementOffsetassemblePrimitivedisassemblePrimitiveindicesrmapPtr loadState storeStateupdateadvancePtrStateadvancePtrStatic addPointer castToBytePtrcastFromBytePtrcastElementPtrsizeOfelementFromPtrelementFromProxyproxyFromElement2proxyFromElement3LLVM.Core.Instructions insertvalue extractvalue _mapByFolddotProductPartialreduceSumInterleavedLLVM.Core.CodeGenGHC.Realquot GHC.MaybeNothingJust_enumFromToSimple