kq      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopNone,BDQR*Bit size+Return a Word with at least n bits*+Lqrstuvwxyz {|}~! &*+*+!  &*+Safe ,:DQRT/%Offset obtained when following path p0#Type obtained when following path p1Symbol in a layout path3Index in a layout path5Path in a layout7Index in the layout path8Symbol in the layout path ,-./012345678 ,-./012345678 0/.56341278-, ,-./012345678None,:DETf9Pointer operations:'Cast a pointer from one type to another;Null pointer (offset is 0)<@Advance a pointer by the given amount of bytes (may be negative)=0Distance between two pointers in bytes (p2 - p1)>Use the pointer? Malloc the given number of bytes@$Add offset to the given layout fieldABAdd offset corresponding to the layout field with the given symbolBAAdd offset corresponding to the layout field with the given indexCA finalized pointerpWe use an offset because we can't modify the pointer directly (it is passed to the foreign pointer destructors)ENull foreign pointerNull finalized pointerFUse a finalized pointerGGeneralized version of <HMalloc a foreign pointerIUse a foreign pointerJFree a malloced memory9:;<=>?@ABCDEFGHIJKLM%"#$9;:?<=>@ABCDEFGHIJ9:;<=>?@ABG%JCDFIHE$"# 9 :;<=>?@ABCDEFGHIJKLMNone ,6:DQRTf'NStorable data-typesECurrently we cannot automatically derive a Storable class with type-level naturals for "alignment" and "sizeOf". Instead we define a Storable class isomorphic to the Foreign.Storable's one but with default methods using DefaultSignatures (i.e., the Storable instance can be automatically derived from a Generic instance).TOCompute the required padding between the size sz and b to respect b's alignmentUECompute the required padding between a and b to respect b's alignmentVEA storable data in constant space whose size is known at compile timeW"Size of the stored data (in bytes)X Alignment requirement (in bytes)Y)Peek (read) a value from a memory addressZ0Poke (write) a value at the given memory address[)Peek (read) a value from a memory address\0Poke (write) a value at the given memory address]Get statically known size^Get statically known alignment_"Get bytes in host-endianness order`Peek a value from a pointeraPoke a value to a pointerb Generalized RcSizeOf (for type-application)dSizeOf' (for type-application)e Generalized Qf Alignment (for type-application)g!Alignment' (for type-application)hPeek with byte offsetiPoke with byte offsetjPeek with element size offsetkPoke with element size offsetlAllocate some bytesmAllocate some aligned bytesnn f executes the computation fo, passing as argument a pointer to a temporarily allocated block of memory sufficient to hold values of type a.The memory is freed when fM terminates (either normally or via an exception), so the pointer passed to f must not be used after this.oFAllocate a block of memory that is sufficient to hold values of type a6. The size of the area allocated is determined by the R method from the instance of N for the appropriate type.$The memory may be deallocated using J or  finalizerFree when no longer required.pp val f executes the computation fX, passing as argument a pointer to a temporarily allocated block of memory into which val) has been marshalled (the combination of n and a).The memory is freed when fM terminates (either normally or via an exception), so the pointer passed to f must not be used after this.qCTemporarily allocate space for the given number of elements (like n, but for multiple elements).r7Allocate space for the given number of elements (like o, but for multiple elements).s~Convert an array of given length into a Haskell list. The implementation is tail-recursive and so uses constant stack space.t/Write the list elements consecutive into memoryu=Temporarily store a list of storable values in memory (like p, but for multiple elements).vLike uF, but the action gets the number of values as an additional parameterw Replicates a withXXXJ combinator over a list of objects, yielding a list of marshalled objectsGeneralize FS.peekGeneralize FS.pokeUNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~*NRQOPSTUVXWYZ[\]^_`abcdefghijklmnopqrstuvw.VWXYZ[\UTS]^_NOOPPQQRR`abcdefghijknlmopwqruvstHNOOPPQQRRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None memsetmemcpy Copy memory Set memoryAllocate several arraysPeek several arraysPoke several arraysAllocate several arraysExecute f with a pointer to a or NULL  None,-9:;<=ADQRTfReturn type from a field pathReturn offset from a field pathRecord alignment'Record size (with ending padding bytes)0Get record size without the ending padding bytesFieldRecordGet record sizeGet record alignmentGet a field offset Get a field Get a field offset from its pathGet a field from its pathConvert a record into a HList )X ) None,9:;<=DQRTf An union &We use a list of types as a parameter.The union is just a pointer to a buffer containing the value(s). The size of the buffer is implicitly known from the types in the list.%Retrieve a union member from its type.Create a new union from one of the union typesLike ! but set the remaining bytes to 0.Create a new union from one of the union types?Get the union size (i.e. the maximum of the types in the union)DGet the union alignment (i.e. the maximum of the types in the union) None6DRTfBy default, use fromEnumtoEnum to convert fromto an Integral.But it can be overloaded to perform transformation before using fromEnum/toEnum. E.g. if values are shifted by 1 compared to Enum values, define fromCEnum = (+1) . fromIntegral . fromEnum Store enum a as a bRead an enum fieldCreate an enum fieldTMake an enum with the last constructor taking a parameter for the rest of the rangeE.g., data T = A | B | C | D Word8 makeEnumWithCustom :: Int -> T makeEnumWithCustom x = case x of 0 -> A 1 -> B 2 -> C n -> D (n - 3)zMake an enum with the last constructor taking a parameter for the rest of the range, but don't build the last constructorE.g., data T = A | B | C | D Word8 makeEnumMaybe :: Int -> T makeEnumMaybe x = case x of 0 -> Just A 1 -> Just B 2 -> Just C n -> Nothing&Make an enum from a number (0 indexed)   Safe Bit orderThe first letter indicates the outer bit ordering, i.e. how bytes are filled: B*: from left to right (B is for BigEndian) L*: from right to left (L is for LittleEndian)The second letter indicates the inner bit ordering, i.e. how words are stored: *B: the most significant bit is stored first (in the outer bit order!) *L: the least-significant bit is stored first (in the outer bit order!)E.g. two successive words of 5 bits: ABCDE, VWXYZ - BB: ABCDEVWX YZxxxxxx - BL: EDCBAZYX WVxxxxxx - LB: XWVEDCBA xxxxxxZY - LL: XYZABCDE xxxxxxVWSafe None<=Tf-A bufferDuplicate a bufferBuffer filled with zero'Zip two buffers with the given function_Unsafe: be careful if you modify the buffer contents or you may break referential transparencyTest if the buffer is empty Empty buffer Buffer sizePeek a storable#Peek a storable at the given offset(Pop a Storable and return the new buffer Poke a bufferMapReverseDrop some bytes O(1)Split on the given Byte valuesTailAppendConsSnocInitHeadIndexUnpackUnpackTake some bytes O(1)Take some bytes O(n)Take some bytes O(1)Pack a ByteStringPack a list of bytesPack a StorablePack a list of StorablePack from a pointer (copy)#Pack from a pointer (add finalizer)"Unsafe drop (don't check the size)"Unsafe take (don't check the size)"Unsafe tail (don't check the size)"Unsafe head (don't check the size)"Unsafe last (don't check the size)"Unsafe init (don't check the size)#Unsafe index (don't check the size) Map memoryUse buffer pointer Read file Write file0../ None Data whose bits can be reversedReverse bits in a WordObvious recursive verion?Reverse bits in a Word8 (3 64-bit operations, modulus division):Reverse bits in a Word8 (4 64-bit operations, no division)!Reverse bits using a lookup table=Reverse bits in a Word8 (7 no 64-bit operations, no division)Parallel recursive version >Convert a function working on Word8 to one working on any Word6The number of bits in the Word must be a multiple of 8             None BufferListConvert to a bufferConvert from a bufferConvert to a lazy ByteStringNone/IBuffer builderEmpty buffer builderCreate a Builder denoting the same sequence of bytes as a strict ByteString. The Builder inserts large ByteStrings directly, but copies small ones to ensure that the generated chunks are large on average.$Encode a single unsigned byte as-is.Execute a Builder and return the generated chunks as a BufferList. The work is performed lazily, i.e., only when a chunk of the BufferList is forced.>Execute a Builder and return the generated chunks as a Buffer.None  Execute Put Put a bufferPut a ByteStringPut null bytes5Put null bytes to align the given value to the second  Put a Word8!Put a Word16 little-endian"Put a Word16 big-endian#Put a Word32 little-endian$Put a Word32 big-endian%Put a Word64 little-endian&Put a Word64 big-endian  !"#$%& ( !"#$%& ( !"#$%&  !"#$%&None,9:;<=DQRTf -Offset of the i-th element in a stored vector'Vector with type-checked size)$Return the buffer backing the vector*Yield the first n elements+Drop the first n elements,O(1)7 Index safely into the vector using a type level index.->Convert a list into a vector if the number of elements matches.0Take at most n element from the list, then use z/4Take at most (n-1) element from the list, then use z0Convert a vector into a list1&Create a vector by replicating a value2(Concat several vectors into a single one'()*+,-./0123456 '()*+,-./012 '()*+,-./012'()*+,-./0123456None7makeMask 3 = 0000011189Keep only the n least-significant bits of the given value9$Compute bit offset (equivalent to x  8 but faster):%Compute byte offset (equivalent to x  8 but faster); Reverse the nH least important bits of the given value. The higher bits are set to 0.<'Convert bits into a string composed of '0' and '1' chars=Convert a string of '0' and '1' chars into a word>QTake n bits at offset o and put them in the least-significant bits of the result789:;<=>*789:;<=> ;78<=>9:789:;<=>None? BitGet monad@BitGet monad transformerA BitGet stateCInputDBit offset (0-7)E Bit orderFCreate a new BitGetStateG!Indicate that the source is emptyH,Skip the given number of bits from the inputI8Skip the required number of bits to be aligned on 8-bitsJ:Read the given number of bits and put the result in a wordK*Perform some checks before calling getBitsMCheck that the number of bits to read is not greater than the first parameterL:Read the given number of Word8 and return them in a BufferExamples: BB: xxxABCDE FGHIJKLM NOPxxxxx -> ABCDEFGH IJKLMNOP LL: LMNOPxxx DEFGHIJK xxxxxABC -> ABCDEFGH IJKLMNOP BL: xxxPONML KJIHGFED CBAxxxxx -> ABCDEFGH IJKLMNOP LB: EDCBAxxx MLKJIHGF xxxxxPON -> ABCDEFGH IJKLMNOPMEvaluate a BitGet monadNEvaluate a BitGet monadO3Evaluate a BitGet monad, return the remaining stateP3Evaluate a BitGet monad, return the remaining stateQResume a BitGet evaluationRResume a BitGet evaluationS#Indicate if all bits have been readT>Skip the given number of bits from the input (monadic version)UJSkip the required number of bits to be aligned on 8-bits (monadic version)V:Read the given number of bits and put the result in a wordW+Perform some checks before calling getBitsMX$Get a bit and convert it into a BoolYGet the given number of Word8ZChange the current bit orderingBe careful to change the outer bit ordering (B* to L* or the inverse) only on bytes boundaries! Otherwise, you will read the same bits more than once.[.Change the bit ordering for the wrapped BitGet<Be careful, this function uses changeBitGetOrder internally.?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[ABCDEFGHIJKL?@NMOPQRSTUVWXYZ[?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[None[]?Test whether all input *in the current chunk* has been consumed^AGet the number of remaining unparsed bytes *in the current chunk*_>Skip ahead n bytes. Fails if fewer than n bytes are available.`9Skip ahead n bytes. No error if there isn't enough bytes.aASkip to align n to al. Fails if fewer than n bytes are available.bASkip to align n to al. Fails if fewer than n bytes are available.c=Run the getter without consuming its input. Fails if it failsdGRun the getter. Consume its input if Just _ returned. Fails if it failseHRun the getter. Consume its input if Right _ returned. Fails if it failsfORequire an action to consume exactly the given number of bytes, fail otherwisegORequire an action to consume at most the given number of bytes, fail otherwiseh(Pull n bytes from the input, as a Bufferi Get Word8jGet Word16 little-endiankGet Word16 big-endianlGet Word32 little-endianmGet Word32 big-endiannGet Word64 little-endianoGet Word64 big-endianp4Get while True (read and discard the ending element)q.Repeat the getter to read the whole bytestringrGet remaining bytess.Count the number of bytes consumed by a gettert9Execute the getter and align on the given number of Word8u(Get Buffer terminated with 0 (consume 0)vRun the Get monadw,Run a getter and throw an exception on errorxGet bits from a BitGet. .Discard last bits to align on a Word8 boundaryLFIXME: we use a continuation because Data.Serialize.Get doesn't export "put"yApply the getter at most  timeszApply the getter at least  times and at most  times]^_`abcdefghijklmnopqrstuvwxyz']^_`abcdefghijklmnopqrstuvwxyz'vw]^_`abstfgcderhuijklmnopqxyz]^_`abcdefghijklmnopqrstuvwxyzNone{ BitPut monad|BitPut monad transformer} BitPut stateBuilder Current byteCurrent offset Bit orderCreate a new BitPut statePut bits Put a BufferExamples: 3 bits are already written in the current byte BB: ABCDEFGH IJKLMNOP -> xxxABCDE FGHIJKLM NOPxxxxx LL: ABCDEFGH IJKLMNOP -> LMNOPxxx DEFGHIJK xxxxxABC BL: ABCDEFGH IJKLMNOP -> xxxPONML KJIHGFED CBAxxxxx LB: ABCDEFGH IJKLMNOP -> EDCBAxxx MLKJIHGF xxxxxPONFlush the current byteGet a lazy byte string Get a BufferEvaluate a BitPut monadEvaluate a BitPut monadPut bits (monadic)Put a single bit (monadic)Put a Buffer (monadic)Change the current bit orderingBe careful to change the outer bit ordering (B* to L* or the inverse) only on bytes boundaries! Otherwise, you will write the same bits more than once..Change the bit ordering for the wrapped BitPut<Be careful, this function uses changeBitPutOrder internally.{|}~{|}~}~{|{|}~NoneDIRTf%/Force a data to be read/stored as little-endian,Force a data to be read/stored as big-endianReverse bytes in a wordExtended word putters Write a Word8Write a Word16Write a Word132Write a Word64&Write a Word64 into a native size wordExtended word getters Read a Word8 Read a Word16Read a Word132 Read a Word64%Read a native size word into a Word64Size of a machine word32-bit64-bit Word putters Write a Word8Write a Word16Write a Word132Write a Word64 Word getter Read a Word8 Read a Word16Read a Word132 Read a Word64 EndiannessLess significant bytes firstMost significant bytes first$Get getters for the given endianness$Get putters for the given endiannessReturn extended gettersReturn extended putters(Detect the endianness of the host memoryDetected host endianness;00None.Get an unsigned word in Little Endian Base 128.Put an unsigned word in Little Endian Base 128*Get a signed int in Little Endian Base 128*Put a signed int in Little Endian Base 1283Get a bytestring containing a decoded LEB128 stringNone6DIRBit set indexed with a#Return the bit offset of an element-Return the value associated with a bit offsetPA bit set: use bitwise operations (fast!) and minimal storage (sizeOf basetype);b is the base type (Bits b) a is the element type (Enum a)mThe elements in the Enum a are flags corresponding to each bit of b starting from the least-significant bit.Indicate if the set is empty Empty bitset%Create a BitSet from a single elementInsert an element in the setRemove an element from the setUnwrap the bitset Wrap a bitset Test if an element is in the set Test if an element is in the set$Test if an element is not in the setRetrieve elements in the setIntersection of two setsIntersection of two setsIntersection of several setsConvert a list of enum elements into a bitset Warning: b must have enough bits to store the given elements! (we don't perform any check, for performance reason)-Convert a bitset into a list of Enum elementsConvert a set into a listConvert a Foldable into a set3It can be useful to get the indexes of the set bitsNone,9:;<=DIQRTf!Get the whole size of a BitFields$Get the size of a field from it name%Get the type of a field from its name+Get the bit offset of a field from its nameA field of n bitsBit fields on a base type bGet backing wordGet the value of a field1Get the value of a field (without checking sizes)Set the value of a field1Set the value of a field (without checking sizes)Modify the value of a field4Modify the value of a field (without checking sizes)Get values in a tuple %Get field names and values in a tuple%Get field names and values in a tuple %Get field names and values in a tuple.       (     None ,/:ADIQRTfFixed-point number w is the backing type iG is the number of bits for the integer part (before the readix point) fF is the number of bits for the fractional part (after the radix point)Convert to a fixed point value Convert from a fixed-point valueNone*,9:;<=DQRTf1& Add two Unums' Add two SORNs(Add a SORN with itself)Subtract two Unums*Subtract two SORNS+Subtract a SORN with itself2Uncertainty bit3 Exact number4#OpenInterval above the exact number7Backing word for the unum9#Compute the number of bits requiredAll unum membersIndexable numbersPositive numbers in the unums:Compute the precise numbers setAAn UnumO0 (and its reciprocal) is always included. Numbers have to be >= 1 and sorted.e.g., Unum '[] =>  0 .. 0 .. 0 Unum '[I 1] => 0 .. -1 .. 0 .. 1 .. 0 Unum '[I 1, I 2] => 0 .. -2 .. -1 .. - 2 .. 0 .. 2 .. 1 .. 2 .. 0 Unum '[I 1, PI] => 0 .. -PI .. -1 .. - PI .. 0 .. PI .. 1 .. PI .. 0B Unum labelsCSize of an unum in bitsDZeroEInfiniteGEncode a numberHNegate a numberIReciprocate a numberJ Get unum signKShow SORN bitsLSize of a SORN in bitsM Empty SORNN Full SORNOFull SORN without infinitePFull SORN without infiniteQSORN singletonRInsert in a SORNSRemove in a SORNTTest membership in a SORNUUnion of two SORNsVIntersection of two SORNsWComplement the SORNX Negate a SORNYElements in the SORNZCreate a SORN from its elements[*Create a contiguous SORN from two elements\%Convert a contiguous SORN into a SORN]!Size of a contiguous SORN in bits^Show contiguous SORN bits_Empty contigiuous SORN`#Test if a contigiuous SORN is emptyaContiguous SORN buildbFull contiguous SORNcContiguous SORN singleton`#$%&'()*+,-./0123456789:  ; <=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[  \]^_`abcdefghijklA#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcAA?@>56=<;8:97234CDEGFHIB./01J,-KLMNOPQRTSUVWXYZ[%&'()*+#$]^\_`abcP#$%&'()*+,-./0123456789:  ; <=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[  \]^_`abcdefghijkl !"#$%&%'()*+,-./01234567898:8;<=<><?<@<A<B<C<C%D%E%F%&GHIJKILMNOPQRSTUVWXXYYZZ[\]^_`abcdefgghijklmnopqrstuvwxyz{|}~                                            ! " # $ % & ' ( ) * + , - . / 0112345678329:;<=>?@ABCDEFFGHIJKLMNOPQRSTUVWXYZ[\]^__`abcdefghijklmnopqrstuvwxydz{|}~NK      !"#$%&'()*+,-./01223456789:;<=>?@ABCCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}G~G            5,:     ,haskus-binary-0.6.0.0-L6GKuGFdfrMAsmNKIT3AC2Haskus.Format.Binary.WordHaskus.Format.Binary.PtrHaskus.Format.Binary.GetHaskus.Format.Binary.PutHaskus.Format.Binary.RecordHaskus.Format.Binary.LayoutHaskus.Format.Binary.StorableHaskus.Utils.MemoryHaskus.Format.Binary.UnionHaskus.Format.Binary.EnumHaskus.Format.Binary.Bits.OrderHaskus.Format.Binary.Buffer!Haskus.Format.Binary.Bits.ReverseHaskus.Format.Binary.BufferList"Haskus.Format.Binary.BufferBuilderHaskus.Format.Binary.VectorHaskus.Format.Binary.BitsHaskus.Format.Binary.Bits.GetHaskus.Format.Binary.Bits.PutHaskus.Format.Binary.Endianness#Haskus.Format.Binary.VariableLengthHaskus.Format.Binary.BitSetHaskus.Format.Binary.BitFieldHaskus.Format.Binary.FixedPointHaskus.Format.Binary.UnumHaskus.Format.Binary.Bits.Basicghc-primGHC.PrimInt#baseGHC.IntInt8Int16Int32Int64Word#GHC.PtrPtrFunPtr+#-#>#>=#==#<#<=# plusWord# minusWord#gtWord#geWord#eqWord#ltWord#leWord#GHC.ForeignPtr ForeignPtr Foreign.Ptr wordPtrToPtr ptrToWordPtrWordPtrForeign.C.TypesCShortCUShortCIntCUIntCLongCULongCSizecastPtrToFunPtrcastFunPtrToPtr nullFunPtr GHC.TypesisTrue#%cereal-0.5.4.0-LXuGw964IxKFJaPTyZmzLsData.Serialize.GetGetData.Serialize.PutPut+haskus-utils-0.6.0.0-12e3ZYOVvtk9LflyuRQhODHaskus.Utils.TypesModuloBitSize WordAtLeast:#>:-> LayoutRootLayoutPathOffsetLayoutPathType LayoutSymbol LayoutIndex LayoutPath layoutIndex layoutSymbolPtrLikecastPtrnullPtrindexPtr ptrDistancewithPtr mallocBytes indexField-->-#> FinalizedPtrnullForeignPtrwithFinalizedPtr indexPtr'mallocForeignPtrByteswithForeignPtrfree$fPtrLikeFinalizedPtr $fPtrLikePtr$fShowFinalizedPtrStorablepeekIOpokeIO alignmentsizeOf PaddingExPaddingRequiredPaddingStaticStorableSizeOf Alignment staticPeekIO staticPokeIO staticPeek staticPoke staticSizeOfstaticAlignment wordBytespeekpokesizeOf'sizeOfTsizeOfT' alignment' alignmentT alignmentT' peekByteOff pokeByteOff peekElemOff pokeElemOff allocaBytesallocaBytesAlignedallocamallocwith allocaArray mallocArray peekArray pokeArray withArray withArrayLenwithMany$fStorableWordPtr$fStorableCShort$fStorableCUShort$fStorableCInt$fStorableCUInt$fStorableCLong$fStorableCULong$fStorableCChar$fStorableCSize $fStorablePtr $fStorableInt$fStorableWord$fStorableChar$fStorableDouble$fStorableFloat$fStorableInt64$fStorableInt32$fStorableInt16$fStorableInt8$fStorableWord64$fStorableWord32$fStorableWord16$fStorableWord8$fStaticStorableInt64$fStaticStorableInt32$fStaticStorableInt16$fStaticStorableInt8$fStaticStorableWord64$fStaticStorableWord32$fStaticStorableWord16$fStaticStorableWord8 $fGStorableK1 $fGStorableM1$fGStorable:*: $fGStorableU1memCopymemSet allocaArrays peekArrays pokeArrays withArrayswithMaybeOrNullPath RecordSizeFieldRecord recordSizerecordAlignmentrecordFieldOffset recordFieldrecordFieldPathOffsetrecordFieldPath recordToList $fShowRecord$fApplyExtract(,)r$fStaticStorableRecordUnion fromUniontoUnion toUnionZero$fStorableUnion$fStorableUnion0$fApplyFoldAlignment(,)r$fApplyFoldSizeOf(,)r$fStaticStorableUnion $fShowUnionCEnum fromCEnumtoCEnum EnumField fromEnumField toEnumFieldmakeEnumWithCustom makeEnumMaybemakeEnum$fStaticStorableEnumField$fStorableEnumField$fShowEnumField $fEqEnumFieldBitOrderBBLBBLLL$fShowBitOrder $fEqBitOrderBuffer bufferDup bufferZero bufferZipWith withBufferPtr isBufferEmpty emptyBuffer bufferSizebufferPeekStorablebufferPeekStorableAtbufferPopStorable bufferPoke bufferMap bufferReverse bufferDrop bufferSplitOn bufferTail bufferAppend bufferCons bufferSnoc bufferInit bufferHead bufferIndexbufferUnpackByteListbufferUnpackByteString bufferTakebufferTakeWhilebufferTakeAtMostbufferPackByteStringbufferPackByteListbufferPackStorablebufferPackStorableList bufferPackPtrbufferUnsafePackPtrbufferUnsafeDropbufferUnsafeTakebufferUnsafeTailbufferUnsafeHeadbufferUnsafeLastbufferUnsafeInitbufferUnsafeIndexbufferUnsafeMapMemorybufferUnsafeUsePtrbufferReadFilebufferWriteFile $fBitsBuffer $fShowBuffer $fEqBuffer $fOrdBuffer BitReversable reverseBitsreverseBitsGenericreverseBitsObviousreverseBits3OpsreverseBits4OpsreverseBitsTablereverseBits7OpsreverseBits5LgNliftReverseBits$fBitReversableWord$fBitReversableWord64$fBitReversableWord32$fBitReversableWord16$fBitReversableWord8 BufferListtoBuffer toBufferListtoLazyByteString BufferBuilderemptyBufferBuilder fromBuffer fromWord8$fMonoidBufferBuilderrunPut putBuffer putByteString putPaddingputPaddingAlignputWord8 putWord16le putWord16be putWord32le putWord32be putWord64le putWord64beVector vectorBuffertakedropindexfromListfromFilledListfromFilledListZtoList replicateconcat$fApplyStoreVector(,)r$fStorableVector$fStaticStorableVector $fShowVectormakeMask maskLeastBits bitOffset byteOffsetreverseLeastBits bitsToStringbitsFromString getBitRangeBitGetBitGetT BitGetStatebitGetStateInputbitGetStateBitOffsetbitGetStateBitOrdernewBitGetStateisEmptyskipBitsskipBitsToAlignOnWord8getBitsgetBitsChecked getBitsBuffer runBitGetT runBitGetrunBitGetPartialTrunBitGetPartialresumeBitGetPartialTresumeBitGetPartialisEmptyM skipBitsMskipBitsToAlignOnWord8MgetBitsMgetBitsCheckedM getBitBoolM getBitsBSMchangeBitGetOrderwithBitGetOrder$fShowBitGetState remainingskip uncheckedSkip skipAlignuncheckedSkipAlign lookAhead lookAheadM lookAheadEconsumeExactly consumeAtMost getBuffergetWord8 getWord16le getWord16be getWord32le getWord32be getWord64le getWord64begetWhilegetWhole getRemaining countBytes alignAfter getBufferNulrunGet runGetOrFail getBitGet getManyAtMostgetManyBoundedBitPutBitPutT BitPutStatebitPutStateBuilderbitPutStateCurrentbitPutStateOffsetbitPutStateBitOrdernewBitPutStateputBits putBitsBuffergetBitPutBufferListgetBitPutBuffer runBitPutT runBitPutputBitsM putBitBoolMputBitsBufferMchangeBitPutOrderwithBitPutOrderAsLittleEndian AsBigEndianByteReversable reverseByteshostToBigEndianbigEndianToHosthostToLittleEndianlittleEndianToHostExtendedWordPuttersextwordPutter8extwordPutter16extwordPutter32extwordPutter64extwordPutterNExtendedWordGettersextwordGetter8extwordGetter16extwordGetter32extwordGetter64extwordGetterNWordSize WordSize32 WordSize64 WordPutters wordPutter8 wordPutter16 wordPutter32 wordPutter64 WordGetters wordGetter8 wordGetter16 wordGetter32 wordGetter64 Endianness LittleEndian BigEndiangetWordGettersgetWordPuttersgetExtendedWordGettersgetExtendedWordPuttersgetHostEndiannesshostEndianness$fStorableAsLittleEndian$fStaticStorableAsLittleEndian$fStorableAsBigEndian$fStaticStorableAsBigEndian$fShowAsLittleEndian$fShowAsBigEndian$fByteReversableWord64$fByteReversableWord32$fByteReversableWord16$fByteReversableWord8$fCEnumEndianness$fEqEndianness$fShowEndianness$fEnumEndianness$fShowWordSize $fEqWordSize$fEqAsBigEndian$fOrdAsBigEndian$fEnumAsBigEndian$fNumAsBigEndian$fIntegralAsBigEndian$fRealAsBigEndian$fEqAsLittleEndian$fOrdAsLittleEndian$fEnumAsLittleEndian$fNumAsLittleEndian$fIntegralAsLittleEndian$fRealAsLittleEndian getULEB128 putULEB128 getSLEB128 putSLEB128getLEB128BufferCBitSet toBitOffset fromBitOffsetBitSetnullempty singletoninsertdeletetoBitsfromBitsmemberelem notMemberelems intersectionunionunionsfromListToBitstoListFromBits$fIsListBitSet $fCBitSetInt $fShowBitSet $fEqBitSet $fOrdBitSet$fStorableBitSetBitField BitFields bitFieldsBits extractField extractField' updateField updateField' withField withField' matchFieldsmatchNamedFields $fEqBitFields$fShowBitFields$fApplyName(,)r$fFieldEnumField $fFieldBitSet $fFieldInt64 $fFieldInt32 $fFieldInt16 $fFieldInt8 $fFieldInt $fFieldWord64 $fFieldWord32 $fFieldWord16 $fFieldWord8 $fFieldWord $fFieldBool$fStorableBitFields$fStorableBitField FixedPoint toFixedPointfromFixedPoint$fStorableFixedPoint$fShowFixedPoint$fEqFixedPointCSORNSornAddsornAddUsornAdd sornAddDepsornSubUsornSub sornSubDepSORNSORNBackingWordSignPositiveNegativeNoSignUBit ExactNumber OpenIntervalU BackingWordLog2UnumSize UnumNumbersInfiniteRcpNegIUnumNum unumLabelUnum unumLabelsunumSizeunumZero unumInfiniteunumBits unumEncode unumNegateunumReciprocateunumSignsornBitssornSize sornEmptysornFullsornNonInfinite sornNonZero sornSingle sornInsert sornRemove sornMember sornUnion sornIntersectsornComplement sornNegate sornElems sornFromElems sornFromTo csornToSorn csornSize csornBits csornEmpty csornIsEmpty csornFromTo csornFull csornSingle $fShowCSORN $fShowSORN$fShowU$fEqU$fApplyGetLabel(,)r$fUnumNumUncertain $fUnumNumNeg $fUnumNumRcp $fUnumNumI $fShowUBit$fEqUBit $fShowSign$fEqSignWordW#GHC.WordWord8W8#Word16W16#Word32W32#Word64W64#leWord64ltWord64geWord64gtWord64neWord64eqWord64leWord32ltWord32geWord32gtWord32neWord32eqWord32leWord16ltWord16geWord16gtWord16neWord16eqWord16leWord8ltWord8geWord8gtWord8neWord8eqWord8 GHC.ClasseseqWordneWordgtWordgeWordltWordleWord byteSwap64uncheckedShiftRL64#uncheckedShiftL64# byteSwap32 byteSwap16nullFinalizedPtrfsPeekfsPoke GStorable gcAlignmentgcPeekgcPokegcSizeOf gcPaddingmemsetmemcpy FieldPathTypeFieldPathOffsetRecordAlignmentFullRecordSizeExtract ExtractRecord FieldType FieldOffsettoUnion' unionSizeunionAlignment FoldAlignment FoldSizeOf MapAlignment MapSizeOf Data.BitstoIntegralSizedpopCountDefaulttestBitDefault bitDefaultBits.&..|.xor complementshiftrotatezeroBitsbitsetBitclearBit complementBittestBit bitSizeMaybebitSizeisSignedshiftL unsafeShiftLshiftR unsafeShiftRrotateLrotateRpopCount FiniteBits finiteBitSizecountLeadingZeroscountTrailingZeros bitsTable ElemOffset WholeSize StoreVectorGHC.RealmoddivmaxminflushIncompleteSizeOutputOffsetmatchNamedFields'Name fromFieldtoField BitFieldTypes AddOffset fieldValues fieldNames UnumMembersUnumIndexables UnumPositivesCSORNBackingWord CSORNSizeSORNSize EncodableAddNegAddRcpMapNegMapRcpDiv2GetLabel MakeMembers Simplify'Simplify Uncertain csornStart csornStart' csornCount