C~U      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~               !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None Safe-Infered    None"This would also work for vectors, /but LLVM-3.1 crashes when actually doing this.     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.  !"#$%&'() !"#$%&'() !"#%$&'() !"#$%&'()None*If isJust = False, then fromJust is an  undefTuple. .counterpart to  0counterpart to  with swapped arguments 2%counterpart to Data.Maybe.HT.toMaybe *+,-./0123456789*+,-./0123456789*+,-./0123456789None: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. ?counterpart to  :;<=>?@AB :;<=>?@AB:;<=>?@ABNone,CDEFGHIJKLMN CDEFGHIJKLMN HIFGJCDEKLMN(CDEFGHIJKLMNNoneW8The order of addition is chosen for maximum efficiency. 'We do not try to prevent cancelations. YCThe 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. ZJTreat the vector as concatenation of pairs and all these pairs are added. ( Useful for stereo signal processing.  n must be at least D2. fGAllow 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. j,Manually assemble a vector of equal values. %Better use ScalarOrVector.replicate. k*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 }. nLManually 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 k. p0Rotate 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. xImplement the d! method using the methods of the f class. }Kprovide the elements of a vector as a list of individual virtual registers &This can be considered the inverse of k. 8Like LLVM.Util.Loop.mapVector but the loop is unrolled, >which is faster since it can be packed by the code generator. 8Like LLVM.Util.Loop.mapVector but the loop is unrolled, >which is faster since it can be packed by the code generator. 7Ideally 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. 6We 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 qOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     7OPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~7abcdefg^_iojmknpqrstuvwxyz{|}`hl~WXYZ[\]OPQRSTUV]OPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      None*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 . Kprovide the elements of an array as a list of individual virtual registers &This can be considered the inverse of . The loop is unrolled, since  and  expect constant indices. None*+,-./0123456789*+,-./0123547869None :;<=>?@AB :;<=>?B@A Nonean alternative is using the  vector type  !"  !" 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. ^#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc!!Q#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcNone$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 d. In Haskell terms this is a e. .both increment and phase must be non-negative Lfghijklmnopqrstuvwxyz{|}~= = /fghijklmnopqrstuvwxyz{|}~ 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 . NoneSimulates 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. ZipList semantics                     "None* It must hold 4 max x y == do gt <- cmp CmpGT x y; select gt x y T 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) W A nested . A combination of W and T =that let you operate on tuple multivalues as Haskell tuples. N !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~! !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSNone0Rotate 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. TUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~YYTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None`      !"#$%&'()*%      !"#$%&'()*%   !"#$  %&' ()*T      !"#$%&'()*None +,-./0     +,-./0+,-./0 +,-./0     None !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~bc[\]^_`adefghijklmnopqrstuvXYZwxyz{|}~UVWSTRQOPMNKLGHIJEFCDB@A;<=>?89:7645-./0123+,)*'("#$%& !None#123456789:;<=>? !"123456789:;<=>?123456789:;<=>?123456789:;<=>? !"None@ABCDE#$%&'()*+,-./@ABCDE@ABCDE@ABCDE#$%&'()*+,-./NoneJAn implementation of both C 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. E0123FG45H6789:IJKLMNOPQRSTU;<=>?@VWXYZ[ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^FGHIJKLMNOPQRSTUVWXYZ[JKLMNOPVWIHQRSTUXYZ[FG60123FG45H6789:IJKLMNOPQRSTU;<=>?@VWXYZ[ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^None\]^_`abcdefghijklmnopqrs\]^_`abcdefghijklmnopqrs\]^bcdhijk_`aefglmnqrsop\]^_`abcdefghijklmnopqrsNone_#Warning: For [0 .. (0xFFFF::Word16)] it would compute an undefined 0xFFFF+1. 6In modulo arithmetic it would enter an infinite loop. tuvwxy`z{a_btuvwxyz{yz{tuvwxtuvwxy`z{a_bNone,|}~cd*|}~*|}~"|}~cde%&'%&(%&)%&*%&+%&,%&-./0123456789:;<=>?@ABCDEFGHIJKLMNOP!QRSTUDVWXYZ[\]^!Q_`aTbcdefghijklmnopq89:<rBstuvwxy7z{|}~$ K        q 8 9 : <  r B @A>?rBq89:< 712 ! Q ^ ! Q W X  R Y V I E F!IEGF""""""""@"A"""">""?"C"D"""""""""""""r"B"q"8"9":"<""" """"7""1"2""""""""""""""""" "$" "" "" " "!"Q""""""""""""""""""" "!"""Y"""#"$"%"&"'"(")"*"+","-"."/"0"1"2"3"4"5"6"7"8"9":";"<"=">"?""@"A"B"C"D"E"F"G""^"H"3"4""""""I@A>?CDrBq89:<712$   J!QKL4578MNOPQRSTFUUVWXYZ[\\]^_``aabbccddefghijklmnopqrstuvwx$yz{|}~$yz{}$yz{"#*&'+,-./04578RPD?$~ 12789:<rB?>@A% %                       ! " # $ % & ' ( ) * + , - . / 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%PJQRSTUVWXYZ[\]^_`abcdefghijkl m n o p q r s t u v   wxy z { | |Q}"~""""""""""""""""""""""""""""""""""""""""""""""""""""""""m""""n"""""""""""""""o""N"O"p""K"J"""""""""""q""4"5"r""""s""""""""""""t""""""""""""""u"v""$"%""'"("+","-"."/"0"1"2")"*"""w""""""""""""""""""""""""""""""""""""""" " "   G^HmnoNOpq45rstuv$%+,-./012)*   w !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO#&P  PQRSTUVWXYZ[\]^_`ab}cdefghijklmnopqrstuvwxyz{|}~llvm-extra-0.9LLVM.Extra.ArithmeticLLVM.Extra.MonadLLVM.Extra.ArithmeticPrivateLLVM.Extra.ControlLLVM.Extra.MaybeLLVM.Extra.EitherLLVM.Extra.ClassLLVM.Extra.VectorLLVM.Extra.Array LLVM.Extra.ScalarOrVectorPrivateLLVM.Extra.ScalarOrVectorLLVM.Extra.ScalarLLVM.Extra.MaybeContinuationLLVM.Extra.IteratorLLVM.Extra.Multi.ValueLLVM.Extra.Multi.VectorLLVM.Extra.FastMath LLVM.Extra.Multi.Vector.InstanceLLVM.Extra.Multi.Value.MemoryLLVM.Extra.Multi.Vector.MemoryLLVM.Extra.MemoryLLVM.Extra.Multi.Value.VectorLLVM.Extra.Multi.IteratorLLVM.Extra.Multi.ClassLLVM.Extra.MemoryPrivateLLVM.Extra.MaybePrivate Data.Maybe fromMaybeLLVM.Extra.EitherPrivateVectorConstantScalarTLLVM.Extra.Multi.Value.PrivateMemoryC llvm-tf-9.0LLVM.Core.Instructions.PrivateCmpEQCmpNECmpGTCmpGECmpLTCmpLE CmpPredicatechainliftR2liftR3addsubincdecadvanceArrayElementPtrdecreaseArrayElementPtrmulminmaxabs signumGensignum cmpSelectfcmpcmpandorfractionSelectselect arrayLoop arrayLoop2arrayLoopWithExitarrayLoop2WithExitfixedLengthLoop whileLoop loopWithExitwhileLoopShared ifThenElseifThenselectTraversable ifThenSelectConsisJustfromJustrunfor alternativefromBooltoBooljust getIsNothinglift2sequencetraverseliftM2isRightfromLeft fromRightmapLeftmapRight getIsLeftMakeValueTuple ValueTuple valueTupleOfZero zeroTuple Undefined undefTuplezeroTuplePointedundefTuplePointedvalueTupleOfFunctorphisTraversableaddPhisFoldableRealtruncatefloor Arithmeticsum sumToPairsumInterleavedToPaircumulate dotProduct Canonical ConstructSimpleElementSize shuffleMatchextractinsertconstantsize replicateassemble insertChunkiterateshuffle sizeInTuplerotateUp rotateDownreverseshiftUp shiftDownshiftUpMultiZeroshiftDownMultiZeroshuffleMatchTraversableshuffleMatchAccessshuffleMatchPlain1shuffleMatchPlain2insertTraversableextractTraversable extractAllmodifymap mapChunks zipChunksWithchopconcat cumulate1signedFractionnothingleftright ReplicatereplicateConst singletonuaddSatusubSatsaddSatssubSatsaddSatLogicalTranscendentalConstantconstPiRationalConstantconstFromRationalIntegerConstantconstFromInteger PseudoModulescale scaleConst SaturatedaddSatsubSatFraction addToPhaseincPhase truncateToIntroundToIntFast floorToIntsplitFractionToInt ceilingToInt replicateOfTranscendentalpisinlogexpcospow AlgebraicsqrtLogicxorinvFloatingComparison Comparison CmpResult fromRational'Fieldfdiv fromInteger' PseudoRingAdditivezeronegonesquareidiviremdeconsliftMunliftMunliftM2unliftM3unliftM4unliftM5resolvewithBoolfromPlainMaybetoMaybeliftguardbindonFailmapM_ mapState_ mapStateM_mapWhileState_emptyconsmapMmapMaybe catMaybes takeWhileJust takeWhile cartesian countDowntake arrayPtrsIntegralBitShiftshlshrNativeFloating NativeIntegerAtom PatternTuple Decomposed Decompose decomposeComposeComposedcomposeBoundedminBoundmaxBoundReprundefphisaddPhis consPrimitiveundefPrimitive zeroPrimitive phisPrimitiveaddPhisPrimitiveconsUnit undefUnitzeroUnitphisUnit addPhisUnit boolPFrom8 bool8FromP intFromBool8floatFromBool8toEnumfromEnumsuccpredcmpEnum splitMaybefstsndcurryuncurrymapFstmapSndmapFstFmapSndFswapfst3snd3thd3mapFst3mapSnd3mapThd3mapFst3FmapSnd3FmapThd3Fzipzip3zip4unzipunzip3unzip4taguntag liftTaggedM liftTaggedM2 consComplex deconsComplexmodify2modifyFmodifyF2atomrealPartimagPartlift1liftM0liftM3 fromIntegralValueconsPrim deconsPrimshufflePrimitiveextractPrimitiveinsertPrimitivedissect dissectListtakeRevshiftUpMultiUndefshiftDownMultiUndefContextTuple setTupleFlags MultiVectorsetMultiVectorFlags MultiValuesetMultiValueFlagsNumber deconsNumberFlagssetFlagsFastAllowReciprocal NoSignedZerosNoInfsNoNaNs getNumbermvNumber mvDenumberattachMultiValueFlags liftNumberM liftNumberM2 mvecNumber mvecDenumberattachMultiVectorFlagsliftMultiVectorMliftMultiVectorM2attachTupleFlags liftContext liftContext2MVVector toMultiValuefromMultiValueliftMultiValueMliftMultiValueM2liftMultiValueM3Structloadstore loadPrimitivestorePrimitivedecomposePrimitivecomposePrimitiveloadUnit storeUnit decomposeUnit composeUnit castStructPtr FirstClassStoredRecordelement loadRecord storeRecorddecomposeRecord composeRecordcastStorablePtr castTuplePtr loadNewtype storeNewtypedecomposeNewtypecomposeNewtypeEnumenumFrom enumFromToOp2runOp2Op1runOp1Op0runOp0ConstgetConstswitchdecomposeFromLoadcomposeFromStore_arrayLoopWithExitDecLoop _whileLoop _emitCode $fSelect(,,) $fSelect(,) $fSelect() $fSelectValuebasemaybemaybeArg$fPhiT $fFunctorT Data.Eithereither$fMakeValueTupleVector$fMakeValueTupleStablePtr$fMakeValueTupleFunPtr$fMakeValueTuplePtr$fMakeValueTuple()$fMakeValueTupleWord64$fMakeValueTupleWord32$fMakeValueTupleWord16$fMakeValueTupleWord8$fMakeValueTupleInt64$fMakeValueTupleInt32$fMakeValueTupleInt16$fMakeValueTupleInt8$fMakeValueTupleBool$fMakeValueTupleDouble$fMakeValueTupleFloat$fMakeValueTupleEither$fMakeValueTupleMaybe$fMakeValueTuple(,,)$fMakeValueTuple(,) $fZero(,,) $fZero(,)$fZeroConstValue $fZeroValue$fZero() $fUndefinedT $fUndefinedT0$fUndefined(,,)$fUndefined(,)$fUndefinedConstValue$fUndefinedValue $fUndefined() _mapByFolddotProductPartialreduceSumInterleaved replicateCore iterateCoreconstCyclicVector extractList mapChunks2_zipChunks2With sumPartialchopCore getLowestPair_reduceAddInterleaved sumGenericsumToPairGeneric_cumulateSimplecumulateGeneric cumulateFrom1signumIntGenericsignumWordGenericsignumFloatGeneric $fRealWord64 $fRealWord32 $fRealWord16 $fRealWord8 $fRealInt64 $fRealInt32 $fRealInt16 $fRealInt8 $fRealDouble $fRealFloat$fArithmeticWord64$fArithmeticWord32$fArithmeticWord16$fArithmeticWord8$fArithmeticInt64$fArithmeticInt32$fArithmeticInt16$fArithmeticInt8$fArithmeticDouble$fArithmeticFloat$fCanonicaln(,,)$fCanonicaln(,)$fCanonicalnValue$fSimpleConstant$fUndefinedConstant $fPhiConstant$fTraversableConstant$fFoldableConstant$fApplicativeConstant$fFunctorConstant$fC(,,) $fSimple(,,)$fC(,) $fSimple(,)$fCValue $fSimpleValueLLVM.Core.Instructions insertvalue extractvalue$fReplicateVector$fReplicateWordN$fReplicateIntN$fReplicateWord64$fReplicateWord32$fReplicateWord16$fReplicateWord8$fReplicateInt64$fReplicateInt32$fReplicateInt16$fReplicateInt8$fReplicateBool$fReplicateFP128$fReplicateDouble$fReplicateFloat _fractionGen_fractionLogicalintratio addSatProxy subSatProxy$fTranscendentalConstantVector$fTranscendentalConstantDouble$fTranscendentalConstantFloat$fRationalConstantVector$fRationalConstantDouble$fRationalConstantFloat$fIntegerConstantVector$fIntegerConstantIntN$fIntegerConstantWordN$fIntegerConstantDouble$fIntegerConstantFloat$fIntegerConstantInt64$fIntegerConstantInt32$fIntegerConstantInt16$fIntegerConstantInt8$fIntegerConstantWord64$fIntegerConstantWord32$fIntegerConstantWord16$fIntegerConstantWord8$fPseudoModuleVector$fPseudoModuleDouble$fPseudoModuleFloat$fPseudoModuleInt64$fPseudoModuleInt32$fPseudoModuleInt16$fPseudoModuleInt8$fPseudoModuleWord64$fPseudoModuleWord32$fPseudoModuleWord16$fPseudoModuleWord8$fSaturatedVector$fSaturatedWordN$fSaturatedIntN$fSaturatedWord64$fSaturatedWord32$fSaturatedWord16$fSaturatedWord8$fSaturatedInt64$fSaturatedInt32$fSaturatedInt16$fSaturatedInt8 $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$fIntegerConstantT$fZeroTNothingJust $fMonadIOT$fMonadT$fApplicativeT cartesianAux$fIntegralTagged$fIntegralInt64$fIntegralInt32$fIntegralWord64$fIntegralWord32$fBitShiftInt64$fBitShiftInt32$fBitShiftInt16$fBitShiftInt8$fBitShiftWord64$fBitShiftWord32$fBitShiftWord16$fBitShiftWord8$fLogicT $fLogicTagged $fLogicT0 $fLogicWordN $fLogicWord64 $fLogicWord32 $fLogicWord16 $fLogicWord8 $fLogicBool8 $fLogicBool$fFloatingComparisonT$fFloatingComparisonTagged$fFloatingComparisonFloat $fComparisonT$fComparisonTagged$fComparisonWordN$fComparisonIntN$fComparisonWord64$fComparisonWord32$fComparisonWord16$fComparisonWord8$fComparisonInt64$fComparisonInt32$fComparisonInt16$fComparisonInt8$fComparisonDouble$fComparisonFloat $fSelectT$fSelectTagged $fSelectInt64 $fSelectInt32 $fSelectInt16 $fSelectInt8$fSelectWord64$fSelectWord32$fSelectWord16 $fSelectWord8$fSelectDouble $fSelectFloat $fSelectBool8 $fSelectBool$fTranscendentalTagged$fTranscendentalDouble$fTranscendentalFloat$fAlgebraicTagged$fAlgebraicDouble$fAlgebraicFloat$fNativeFloatingDoubleDouble$fNativeFloatingFloatFloat$fNativeIntegerTaggeda$fNativeIntegerInt64Int64$fNativeIntegerInt32Int32$fNativeIntegerInt16Int16$fNativeIntegerInt8Int8$fNativeIntegerWord64Word64$fNativeIntegerWord32Word32$fNativeIntegerWord16Word16$fNativeIntegerWord8Word8$fFractionTagged $fRealTagged$fPseudoModuleTagged $fFieldTagged $fFieldDouble $fFieldFloat$fPseudoRingTagged$fPseudoRingInt64$fPseudoRingInt32$fPseudoRingInt16$fPseudoRingInt8$fPseudoRingWord64$fPseudoRingWord32$fPseudoRingWord16$fPseudoRingWord8$fPseudoRingDouble$fPseudoRingFloat$fAdditiveTagged$fAdditiveIntN$fAdditiveWordN$fAdditiveInt64$fAdditiveInt32$fAdditiveInt16$fAdditiveInt8$fAdditiveWord64$fAdditiveWord32$fAdditiveWord16$fAdditiveWord8$fAdditiveDouble$fAdditiveFloat$fRationalConstantTagged$fIntegerConstantTagged$fDecomposeComplex$fComposeComplex$fDecomposeTagged$fComposeTagged$fDecompose(,,,)$fCompose(,,,)$fDecompose(,,) $fCompose(,,)$fDecompose(,) $fCompose(,) $fDecompose() $fCompose()$fDecomposeAtom $fComposeT $fCComplex $fCTagged$fC(,,,)$fCMaybe$fCT $fBoundedT$fCT0$fCBool8$fC() $fCStablePtr $fCFunPtr$fCPtr$fCIntN$fCInt64$fCInt32$fCInt16$fCInt8$fCWordN $fCWord64 $fCWord32 $fCWord16$fCWord8 $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$fMultiVectorDouble$fMultiVectorFloat$fFloatingComparisonNumber0$fComparisonNumber0$fSelectNumber0$fTranscendentalNumber0$fAlgebraicNumber0$fFractionNumber0 $fRealNumber0$fPseudoModuleNumber$fFieldNumber0$fPseudoRingNumber0$fAdditiveNumber0$fRationalConstantNumber0$fIntegerConstantNumber0$fDecomposeNumber$fComposeNumber$fMultiValueDouble$fMultiValueFloat $fCNumber0 $fFlags(,,,,) $fFlags(,,,) $fFlags(,,) $fFlags(,) $fFlagsFast$fFlagsAllowReciprocal$fFlagsNoSignedZeros $fFlagsNoInfs $fFlagsNoNaNs$fBitShiftVector $fLogicVector$fAdditiveVector $fCVector$fCn(,,)$fCn(,) $fCnDouble $fCnFloat $fCnInt64 $fCnInt32 $fCnInt16$fCnInt8 $fCnWord64 $fCnWord32 $fCnWord16 $fCnWord8 ConvertStructdecomposeField composeField StoredStruct fromStorable toStorable loadElement storeElementextractElement insertElementpairtriplefieldsdecSucc$fConvertStructsi()$fConvertStructsi(,)$fFirstClassStruct$fFirstClassStablePtr$fFirstClassFunPtr$fFirstClassPtr$fFirstClassArray$fFirstClassVector$fFirstClassBool$fFirstClassWord64$fFirstClassWord32$fFirstClassWord16$fFirstClassWord8$fFirstClassInt64$fFirstClassInt32$fFirstClassInt16$fFirstClassInt8$fFirstClassDouble$fFirstClassFloat$fCT1$fCT2$fCT3$fApplicativeElement$fFunctorElement_enumFromToSimple unpackBoolsuccMax$fEnumT