!      !"#$%&'()*+, - . / 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 TUVWXYZ[\]^_`abcdefghijklmnop q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI 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:;<=>?@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+[+\+]+^+_+`+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+{+|+}+~+++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,-------..............................//////////////000000000000000000000000 0 0 0 0 0000000000000000111 1!1"1#1$1%1&1'1(1)1*1+1,1-1.1/102122232425262728292:2;2<2=2>2?2@2A2B2C2D2E2F2G2H2I2J2K2L2M2N3O3P3Q3R3S3T3U3V3W3X3Y3Z3[3\3]3^3_3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o4p4q4r4s4t4u4v4w4x4y4z4{5|5}5~5555555555555555555555555555555555555555555555555555555555555555555555555556SafeGt% haskus-binary Bit orderMThe 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)NThe second letter indicates the inner bit ordering, i.e. how words are stored:F?B: the most significant bit is stored first (in the outer bit order!)G?L: the least-significant bit is stored first (in the outer bit order!)3E.g. two successive words of 5 bits: ABCDE, VWXYZ  BB: ABCDEVWX YZxxxxxx   BL: EDCBAZYX WVxxxxxx   LB: XWVEDCBA xxxxxxZY   LL: XYZABCDE xxxxxxVW %(&')%(&')SafeG None -.>HUVX[ haskus-binaryStructure field, haskus-binaryUnionMtype S = CUnion ['Field "i8" (CPrimitive 1 1), 'Field "i32" (CPrimitive 4 4)]:kind! CSizeOf SCSizeOf S :: Nat= 4:kind! CAlignment SCAlignment S :: Nat= 4. haskus-binaryStructNtype S = CStruct ['Field "i8" (CPrimitive 1 1), 'Field "i32" (CPrimitive 4 4)]:kind! CSizeOf SCSizeOf S :: Nat= 8:kind! CAlignment SCAlignment S :: Nat= 40 haskus-binaryUnbounded array!type S = CUArray (CPrimitive 8 8):kind! CSizeOf SCSizeOf S :: Nat= (TypeError ...):kind! CAlignment SCAlignment S :: Nat= 82 haskus-binaryArray#type S = CArray 10 (CPrimitive 8 8):kind! CSizeOf SCSizeOf S :: Nat= 80:kind! CAlignment SCAlignment S :: Nat= 84 haskus-binary Primitives:kind! CSizeOf (CPrimitive 8 1)CSizeOf (CPrimitive 8 1) :: Nat= 8":kind! CAlignment (CPrimitive 8 2)"CAlignment (CPrimitive 8 2) :: Nat= 28 haskus-binary%Offset obtained when following path p9 haskus-binary#Type obtained when following path p: haskus-binaryLayout path root; haskus-binaryLayout path element< haskus-binaryAddressing via a numeric index= haskus-binaryAddressing via a symbol> haskus-binaryPath in a layout@ haskus-binaryIndex in the layout path&Helper for ``ptr --> lPath @p`` until,-./0123456789:;<=>?@>?;<=@98:76452301./,- Safei A haskus-binary.Is the memory automatically garbage collected?B haskus-binary0Automatically collected by the garbage-collectorC haskus-binaryFinalizers are run just before the garbage collector collects the referencing entity (buffer, pointer...). The memory used by the entity may be collected too (Internal heap), explicitly freed by a finalizer or not freed at all.D haskus-binaryTThe memory is not automatically freed and we can't attach finalizers to the buffer.E haskus-binary!Is the buffer pinned into memory?F haskus-binary0The buffer has a fixed associated memory addressG haskus-binary:The buffer contents can be freely moved to another addressH haskus-binaryAllocation heapI haskus-binaryGHC heapJ haskus-binary External heapK haskus-binaryIs the memory mutable or not?L haskus-binaryMemory cells are mutableM haskus-binaryMemory cells are immutable ABCDEFGHIJKLM KLMHIJEFGABCDNone &'-.>HISX_kt T haskus-binary%Wrapper containing any kind of buffer\ haskus-binaryA pointer in memory haskus-binaryUnsafe Finalized to Raw pointera haskus-binaryTest if a pointer is Nullb haskus-binary Null pointerc haskus-binary Null pointerd haskus-binaryIndex a pointere haskus-binaryDistance between two pointersf haskus-binary2Use a finalized pointer as a non finalized pointerg haskus-binary;Use a pointer (finalized or not) as a non finalized pointerh haskus-binaryAlloc mutable finalized memoryi haskus-binary"Alloc mutable non-finalized memoryj haskus-binaryFree a non-finalized memoryTUVWXYZ[\]^_`abcdefghij\]^_`TU[ZYXWVabcdegfhijNone.FHUVvl haskus-binaryReturn a Int with exactly n bitsm haskus-binaryReturn a Int with at least n bits5 lm ml None.FHUVzn haskus-binaryReturn a Word with exactly n bitso haskus-binaryReturn a Word with at least n bits7       !no on   NoneF~8r haskus-binaryConvert a Word32 into a Float32s haskus-binaryConvert a Float32 into a Word32t haskus-binaryConvert a Word64 into a Float64u haskus-binaryConvert a Word64 into a Float64pqrstuqpsurt None .8>HUVXk'w haskus-binaryOCompute the required padding between the size sz and b to respect b's alignmentx haskus-binaryECompute the required padding between a and b to respect b's alignmenty haskus-binaryStorable 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).~ haskus-binaryEA storable data in constant space whose size is known at compile time haskus-binary"Size of the stored data (in bytes) haskus-binary Alignment requirement (in bytes) haskus-binary)Peek (read) a value from a memory address haskus-binary0Poke (write) a value at the given memory address haskus-binary)Peek (read) a value from a memory address haskus-binary0Poke (write) a value at the given memory address haskus-binaryGet statically known size haskus-binaryGet statically known alignment haskus-binary"Get bytes in host-endianness order haskus-binaryPeek a value from a pointer haskus-binaryPoke a value to a pointer haskus-binary Generalized } haskus-binarySizeOf (for type-application) haskus-binarySizeOf' (for type-application) haskus-binary Generalized | haskus-binary Alignment (for type-application) haskus-binary!Alignment' (for type-application) haskus-binaryPeek with byte offset haskus-binaryPoke with byte offset haskus-binaryPeek with element size offset haskus-binaryPoke with element size offset haskus-binaryAllocate some bytes haskus-binaryAllocate some aligned bytes haskus-binary 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. haskus-binaryFAllocate a block of memory that is sufficient to hold values of type a6. The size of the area allocated is determined by the } method from the instance of y for the appropriate type.$The memory may be deallocated using free or  finalizerFree when no longer required. haskus-binary 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  and ).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. haskus-binaryCTemporarily allocate space for the given number of elements (like , but for multiple elements). haskus-binary7Allocate space for the given number of elements (like , but for multiple elements). haskus-binary~Convert an array of given length into a Haskell list. The implementation is tail-recursive and so uses constant stack space. haskus-binary/Write the list elements consecutive into memory haskus-binary=Temporarily store a list of storable values in memory (like , but for multiple elements). haskus-binaryLike F, but the action gets the number of values as an additional parameter haskus-binary Replicates a withXXXJ combinator over a list of objects, yielding a list of marshalled objects" haskus-binaryGeneralize FS.peek# haskus-binaryGeneralize FS.poke*vwxy}|z{~*~y}|z{xwv None FA $ haskus-binarymemset haskus-binarymemcpy haskus-binary Copy memory haskus-binary Set memory haskus-binaryAllocate several arrays haskus-binaryPeek several arrays haskus-binaryPoke several arrays haskus-binaryAllocate several arrays haskus-binaryExecute f with a pointer to a or NULLNone %&'*-.=>?@ACFHSVX_u+ haskus-binary%Wrapper containing any kind of buffer haskus-binaryGet contents as a list of bytes haskus-binaryGet buffer size haskus-binary?Buffer that can be thawed (converted from immutable to mutable) haskus-binary{Convert an immutable buffer to a mutable one without copying. The original buffer should not be used after the conversion. haskus-binary?Buffer that can be frozen (converted from mutable to immutable) haskus-binaryvConvert a mutable buffer to an immutable one without copying. The buffer should not be modified after the conversion. haskus-binaryA memory buffer haskus-binary%Allocate a buffer (mutable, unpinned)b <- newBuffer 1024 haskus-binary#Allocate a buffer (mutable, pinned) haskus-binary,Allocate an aligned buffer (mutable, pinned)% haskus-binary@Insert a finalizer. Return True if there was no finalizer before& haskus-binaryGet buffer finalizers haskus-binaryAdd a finalizer.The latest added finalizers are executed first. Finalizers are not guaranteed to run (e.g. if the program exits before the buffer is collected).' haskus-binary,Internal function used to execute finalizers( haskus-binaryCreate empty Finalizers haskus-binaryTouch a buffer haskus-binary Touch a data haskus-binaryMake a buffer finalizable6The new buffer liveness is used to trigger finalizers. haskus-binaryZSome buffers managed by GHC can be pinned as an optimization. This function reports this. haskus-binaryhTransform type-level NotPinned buffers into type-level Pinned if the buffer is dynamically pinned (see ). haskus-binary"Do something with a buffer addressRNote: don't write into immutable buffer as it would break referential consistency haskus-binary"Do something with a buffer pointerRNote: don't write into immutable buffer as it would break referential consistency haskus-binary"Do something with a buffer address haskus-binary"Do something with a buffer pointer haskus-binaryGet buffer size haskus-binaryGet contents as a list of bytes) haskus-binaryAConvert a buffer into a list of bytes by reading bytes one by one* haskus-binaryAConvert a buffer into a list of bytes by reading bytes one by one haskus-binaryRead a Word8, offset in bytes'We don't check that the offset is valid let b = [25,26,27,28] :: BufferIbufferReadWord8IO b 227 haskus-binary4Read a Word8 in an immutable buffer, offset in bytes'We don't check that the offset is valid let b = [25,26,27,28] :: BufferI@putStrLn $ "Word8 at offset 2 is " ++ show (bufferReadWord8 b 2)Word8 at offset 2 is 27 haskus-binaryWrite a Word8, offset in bytes'We don't check that the offset is validb <- newBuffer 10bufferWriteWord8IO b 1 123bufferReadWord8IO b 1123 haskus-binaryRead a Word16, offset in bytes'We don't check that the offset is valid(let b = [0x12,0x34,0x56,0x78] :: BufferIx <- bufferReadWord16IO b 0(x == 0x1234) || (x == 0x3412)True haskus-binary5Read a Word16 in an immutable buffer, offset in bytes'We don't check that the offset is valid haskus-binaryWrite a Word16, offset in bytes'We don't check that the offset is validb <- newBuffer 10let v = 1234 :: Word16bufferWriteWord16IO b 1 vbufferReadWord16IO b 112347(x :: Word16) <- fromIntegral <$> bufferReadWord8IO b 17(y :: Word16) <- fromIntegral <$> bufferReadWord8IO b 2B(((x `shiftL` 8) .|. y) == v) || (((y `shiftL` 8) .|. x) == v)True haskus-binaryRead a Word32, offset in bytes'We don't check that the offset is valid(let b = [0x12,0x34,0x56,0x78] :: BufferIx <- bufferReadWord32IO b 0&(x == 0x12345678) || (x == 0x78563412)True haskus-binary5Read a Word32 in an immutable buffer, offset in bytes'We don't check that the offset is valid haskus-binaryWrite a Word32, offset in bytes'We don't check that the offset is validb <- newBuffer 10let v = 1234 :: Word32bufferWriteWord32IO b 1 vbufferReadWord32IO b 11234 haskus-binaryRead a Word64, offset in bytes'We don't check that the offset is valid<let b = [0x12,0x34,0x56,0x78,0x9A,0xBC,0xDE,0xF0] :: BufferIx <- bufferReadWord64IO b 06(x == 0x123456789ABCDEF0) || (x == 0xF0DEBC9A78563412)True haskus-binary5Read a Word64 in an immutable buffer, offset in bytes'We don't check that the offset is valid  haskus-binaryWrite a Word64, offset in bytes'We don't check that the offset is validb <- newBuffer 10let v = 1234 :: Word64bufferWriteWord64IO b 1 vbufferReadWord64IO b 11234  haskus-binary4Copy a buffer into another from/to the given offsetsWe don't check buffer limits.&let b = [0,1,2,3,4,5,6,7,8] :: BufferIb2 <- newBuffer 8copyBuffer b 4 b2 0 4copyBuffer b 0 b2 4 4"forM [0..7] (bufferReadWord8IO b2)[4,5,6,7,0,1,2,3]  haskus-binarySupport for OverloadedLists:set -XOverloadedLists let b = [25,26,27,28] :: BufferI  haskus-binary Source buffer haskus-binaryOffset in source buffer haskus-binary Target buffer haskus-binaryOffset in target buffer haskus-binaryNumber of Word8 to copyMABCDEFGHIJKLM  MEFGABCDKLMHIJ  None&'.SX_7 haskus-binaryTyped raw pointer9 haskus-binary Typed buffer; haskus-binaryTyped pointer 789:;<9:;<78None "#&'.FqW= haskus-binaryAAn embedding entry. Used to embed binary files into an executable? haskus-binaryType of data access@ haskus-binaryAlignement to respectA haskus-binarySymbol to associate to the dataB haskus-binaryInput file pathC haskus-binaryOffset in the input fileD haskus-binarySize limit in the input fileE haskus-binary Section typeF haskus-binary Read-onlyG haskus-binaryWritableH haskus-binary UninitializedI haskus-binary8Embed bytes at compile time using GHC's literal strings.:set -XTemplateHaskell'let b = $$(embedBytes [72,69,76,76,79]) bufferSize b5J haskus-binary-Load a buffer from a symbol. Return a BufferE-Note: we can't use Typed TH because of #13587 <> -- Test.c > const char mydata[9] = {1,2,30,40,50,6,7,8,9}; L> let b = $(loadSymbol 9 "mydata") > print (fmap (bufferReadWord8 b) [0..8]) 1,2,30,40,50,6,7,8,9K haskus-binary.Load a buffer from a symbol. Return a BufferME-Note: we can't use Typed TH because of #13587 m> -- Test.c > const char mydata[9] = {1,2,30,40,50,6,7,8,9}; > char mywrtdata[9] = {1,2,30,40,50,6,7,8,9}; > let w = $(loadMutableSymbol 9 "mywrtdata") > forM_ [0..8] (\i -> bufferWriteWord8IO w i (fromIntegral i)) > print =<< forM [0..8] (bufferReadWord8IO w) 0,1,2,3,4,5,6,7,8|Trying to write into constant memory: >> let err = $(loadMutableSymbol 9 "mydata") >> bufferWriteWordIO err 0 10 SEGFAULT/ haskus-binary+Create a GAS entry to include a binary fileP haskus-binary8Create an assembler file for the given embedding entriesQ haskus-binary0Embed a file in the executable. Return a BufferE0 haskus-binaryfEmbed a file in the executable. Return a BufferE or a BufferME depending on the mutability parameter.nodep parameter is used to indicate if we want to add a dependency on the input file (e.g. we don't want to do this for temporary files TH generated).R haskus-binaryPEmbed a pinned buffer in the executable. Return either a BufferE or a BufferME.S haskus-binaryREmbed a unpinned buffer in the executable. Return either a BufferE or a BufferME.T haskus-binaryHEmbed a buffer in the executable. Return either a BufferE or a BufferME.Q haskus-binary File to embed haskus-binaryMutable buffer or not haskus-binary Alignment haskus-binaryOffset in the file in bytes haskus-binary>Size to include in bytes (otherwise up to the end of the file) haskus-binary+BufferE or BufferME depending on mutabilityR haskus-binary Source buffer haskus-binary%Should the embedded buffer be mutable haskus-binary Alignement haskus-binaryOffset in the buffer haskus-binaryNumber of Word8 to write haskus-binary6BufferE or BufferME, depending on mutability parameterS haskus-binary Source buffer haskus-binary%Should the embedded buffer be mutable haskus-binary Alignement haskus-binaryOffset in the buffer haskus-binaryNumber of Word8 to write haskus-binary6BufferE or BufferME, depending on mutability parameterT haskus-binary Source buffer haskus-binary,Should the embedded buffer be mutable or not haskus-binaryOptional alignement constraint haskus-binary$Optional offset in the source buffer haskus-binary#Optional number of bytes to include haskus-binary6BufferE or BufferME, depending on mutability parameter=>?@ABCDEFGHIJKLMNOPQRSTIQTRSJKLMNOP=>?@ABCDEFGHNone &'FvE[ haskus-binary$Allocate a new Buffer using system `malloc`\ haskus-binary.Allocate a new finalized buffer using system `malloc` and finalized with `1`.] haskus-binaryMake a buffer finalized with `1`^ haskus-binaryFree a malloc-ed Buffer[\]^[\]^None.=>?@AHUVXkb_ haskus-binary 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.` haskus-binary%Retrieve a union member from its typea haskus-binary.Create a new union from one of the union typesb haskus-binaryLike a! but set the remaining bytes to 02 haskus-binary.Create a new union from one of the union types3 haskus-binary?Get the union size (i.e. the maximum of the types in the union)4 haskus-binaryDGet the union alignment (i.e. the maximum of the types in the union)_`ab_`abNone./=>?@AEHUVXk5 haskus-binaryReturn type from a field path6 haskus-binaryReturn offset from a field path7 haskus-binaryRecord alignment8 haskus-binary'Record size (with ending padding bytes)j haskus-binary0Get record size without the ending padding bytesk haskus-binaryFieldl haskus-binaryRecordm haskus-binaryGet record sizen haskus-binaryGet record alignmento haskus-binaryGet a field offsetp haskus-binary Get a fieldq haskus-binary Get a field offset from its pathr haskus-binaryGet a field from its paths haskus-binaryConvert a record into a HList ijklmnopqrs lkjimnporqsNone 8FHMVXkw haskus-binary Extended EnumHBy default, use dataToTag and toEnum to convert from and to 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 . dataToTagz haskus-binary Store enum a as a b{ haskus-binaryRead an enum field| haskus-binaryCreate an enum field} haskus-binaryTMake an enum with the last constructor taking a parameter for the rest of the range 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) ~ haskus-binaryzMake an enum with the last constructor taking a parameter for the rest of the range, but don't build the last constructor 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  haskus-binary&Make an enum from a number (0 indexed) haskus-binaryRetrieve data tagdata D = A | B | C dataToTag B1 wyxz{|}~ zwyx{|~}NoneM- haskus-binary8-bit character (ASCII, etc.)NoneF haskus-binarySigned bit shiftsSigned means that the sign bit (the higher order bit): - propagates to the right during right shifts and - keeps its value during left shifts (except when all other bits are 0)Checked means that there is an additional test to ensure that the shift offset is valid (less than the bit count). If you are sure that the offset is valid, use the "unchecked" version which should be faster. haskus-binaryChecked signed right shift haskus-binaryChecked signed left shift haskus-binaryUnchecked signed right shift haskus-binaryUnchecked signed left shift haskus-binaryFChecked signed shift to the left if positive, to the right if negative haskus-binaryHUnchecked signed shift to the left if positive, to the right if negative haskus-binary Bit shiftsChecked means that there is an additional test to ensure that the shift offset is valid (less than the bit count). If you are sure that the offset is valid, use the "unchecked" version which should be faster.To shift signed numbers, see  class methods. haskus-binaryChecked right shift haskus-binaryChecked left shift haskus-binaryUnchecked right shift haskus-binaryUnchecked left shift haskus-binary?Checked shift to the left if positive, to the right if negative haskus-binaryAUnchecked shift to the left if positive, to the right if negativeNone.8>@FHVXk haskus-binary,Type representable by a fixed amount of bits haskus-binaryNumber of bits haskus-binary%Number of bits (the value is ignored) haskus-binaryAll bits set to 0 haskus-binaryAll bits set to 1 haskus-binary@Count number of zero bits preceding the most significant set bit haskus-binaryACount number of zero bits following the least significant set bit haskus-binary ComplementNoneFU haskus-binaryBitwise bit operations haskus-binary Bitwise "and" haskus-binary Bitwise "or" haskus-binary Bitwise "xor"None8>  haskus-binaryTypes whose bits can be rotated haskus-binary*Rotate left if positive, right if negative haskus-binaryChecked left bit rotation haskus-binaryChecked right bit rotation haskus-binary4Unchecked rotate left if positive, right if negative haskus-binaryUnchecked left bit rotation haskus-binaryUnchecked right bit rotationNone,>Xk haskus-binaryMake a mask dynamically haskus-binarymakeMaskFinite 3 = 00000111 haskus-binaryMake a mask statically haskus-binary9Keep only the n least-significant bits of the given value haskus-binary9Keep only the n least-significant bits of the given valueNone.ke haskus-binary$Compute bit offset (equivalent to x 9 8 but faster) haskus-binary%Compute byte offset (equivalent to x : 8 but faster)None8Fq haskus-binaryType whose bits are indexable haskus-binarybit i is a value with the i$th bit set and all other bits clear. haskus-binary x `setBit` i is the same as  x .|. bit i haskus-binaryx `clearBit` i is the same as x .&. complement (bit i) haskus-binaryx `complementBit` i is the same as  x `xor` bit i haskus-binaryReturn ; if the nth bit of the argument is 1 haskus-binaryReturn the number of set bitsNone@AXkQ- haskus-binaryA buffer haskus-binaryDuplicate a buffer haskus-binaryBuffer filled with zero haskus-binary'Zip two buffers with the given function  haskus-binary_Unsafe: be careful if you modify the buffer contents or you may break referential transparency  haskus-binaryTest if the buffer is empty  haskus-binary Empty buffer  haskus-binary Buffer size  haskus-binaryPeek a storable haskus-binary#Peek a storable at the given offset haskus-binary(Pop a Storable and return the new buffer haskus-binary Poke a buffer haskus-binaryMap haskus-binaryReverse haskus-binaryDrop some bytes O(1) haskus-binarySplit on the given Byte values haskus-binaryTail haskus-binaryAppend haskus-binaryCons haskus-binarySnoc haskus-binaryInit haskus-binaryHead haskus-binaryIndex haskus-binaryUnpack haskus-binaryUnpack haskus-binaryTake some bytes O(1) haskus-binaryTake some bytes O(n)  haskus-binaryTake some bytes O(1)! haskus-binaryPack a ByteString" haskus-binaryPack a list of bytes# haskus-binaryPack a Storable$ haskus-binaryPack a list of Storable% haskus-binaryPack from a pointer (copy)& haskus-binary#Pack from a pointer (add finalizer)' haskus-binary"Unsafe drop (don't check the size)( haskus-binary"Unsafe take (don't check the size)) haskus-binary"Unsafe tail (don't check the size)* haskus-binary"Unsafe head (don't check the size)+ haskus-binary"Unsafe last (don't check the size), haskus-binary"Unsafe init (don't check the size)- haskus-binary#Unsafe index (don't check the size). haskus-binary Map memory/ haskus-binaryUse buffer pointer0 haskus-binary Read file1 haskus-binary Write file.      !"#$%&'()*+,-./01.      !"#$%'()*+,-./&01Nonem 7 haskus-binary Execute Put8 haskus-binary Execute PutM9 haskus-binary Put a buffer: haskus-binaryPut a ByteString; haskus-binaryPut null bytes< haskus-binary5Put null bytes to align the given value to the second= haskus-binary Put a Word8> haskus-binaryPut a Word16 little-endian? haskus-binaryPut a Word16 big-endian@ haskus-binaryPut a Word32 little-endianA haskus-binaryPut a Word32 big-endianB haskus-binaryPut a Word64 little-endianC haskus-binaryPut a Word64 big-endian !789:;<=>?@ABC! 789:;<=>?@ABCNoneKD haskus-binary BufferListF haskus-binaryConvert to a bufferG haskus-binaryConvert from a bufferH haskus-binaryConvert to a lazy ByteStringDEFGHDEFGH None1MI haskus-binaryBuffer builderJ haskus-binaryEmpty buffer builderK haskus-binaryCreate 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.L haskus-binary$Encode a single unsigned byte as-is.M haskus-binaryExecute 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.N haskus-binary>Execute a Builder and return the generated chunks as a Buffer.IJKLMNIJMNKL!None>Xd Q haskus-binaryData whose bits can be reversedS haskus-binaryReverse bits in a WordT haskus-binaryObvious recursive versionU haskus-binary?Reverse bits in a Word8 (3 64-bit operations, modulus division)V haskus-binary:Reverse bits in a Word8 (4 64-bit operations, no division)W haskus-binary!Reverse bits using a lookup tableX haskus-binary=Reverse bits in a Word8 (7 no 64-bit operations, no division)Y haskus-binaryParallel recursive versionZ haskus-binary>Convert a function working on Word8 to one working on any Word6The number of bits in the Word must be a multiple of 8 QRSTUVWXYZ QRSTUVWXYZ"None,.>Xk f haskus-binary)Check if a number is a power of two (2^n)isPowerOfTwo (10 :: Word)FalseisPowerOfTwo (16 :: Word)Trueg haskus-binary5Check if a number is a power of two (2^n) and return ngetPowerOfTwo (10 :: Word)NothinggetPowerOfTwo (16 :: Word)Just 4h haskus-binary*Check if a number is a power of four (4^n)isPowerOfFour (10 :: Word)FalseisPowerOfFour (16 :: Word)Truei haskus-binary6Check if a number is a power of four (4^n) and return ngetPowerOfFour (10 :: Word)NothinggetPowerOfFour (16 :: Word)Just 2j haskus-binary Reverse the nH least important bits of the given value. The higher bits are set to 0.k haskus-binary'Convert bits into a string composed of '0' and '1' charsl haskus-binary=Convert a specified amount of bits into a string composed of '0' and '1' charsm haskus-binaryConvert a string of '0' and '1' chars into a wordn haskus-binaryq`getBitRange bo offset n c` takes n bits at offset in c and put them in the least-significant bits of the result<QRSefghijklmn<eQRSjklmnfhgi#None &'.>HSX`k1| haskus-binary Kinded PositgGADT that can be used to ensure at the type level that we deal with non-infinite/non-zero Posit values haskus-binary+Get the kind of the posit at the type level haskus-binaryCheck if a posit is zero haskus-binaryCheck if a posit is infinity haskus-binaryCheck if a posit is positive haskus-binaryCheck if a posit is negative haskus-binaryPosit absolute value haskus-binaryDecode posit fields haskus-binaryConvert a Posit into a Rational haskus-binary-Convert a rational into the approximate Posit haskus-binarycFactor of approximation for a given Rational when encoded as a Posit. The closer to 1, the better.Usage:)positApproxFactor @(Posit 8 2) (52 % 137) haskus-binaryFCompute the decimal error if the given Rational is encoded as a Posit.Usage:)positDecimalError @(Posit 8 2) (52 % 137) haskus-binaryXCompute the number of decimals of accuracy if the given Rational is encoded as a Posit.Usage:,positDecimalAccuracy @(Posit 8 2) (52 % 137) haskus-binaryECompute the binary error if the given Rational is encoded as a Posit.Usage:(positBinaryError @(Posit 8 2) (52 % 137) haskus-binaryTCompute the number of bits of accuracy if the given Rational is encoded as a Posit.Usage:+positBinaryAccuracy @(Posit 8 2) (52 % 137) haskus-binary[Compute the number of bits of accuracy if the given Rational is encoded as a Float/Double.Usage:&floatBinaryAccuracy @Double (52 % 137) haskus-binary Show posit'orpqstuvwxyz{|}~'|}~orpqstuvwxyz{None%,-.1=>?@AHUVXgkL haskus-binaryBitNat backing type haskus-binary A natural on b bits haskus-binaryMCreate a natural number with the minimal number of bits required to store it bitNat @5 BitNat @3 5 bitNat @0 BitNat @1 0 bitNat @158748521123465897456465#BitNat @78 158748521123465897456465 haskus-binary Zero natural haskus-binary One natural haskus-binaryConvert a BitNat into a Natural haskus-binaryCreate a natural haskus-binary!Create a natural (check overflow)< haskus-binary4Create a natural (check overflow and throw on error) haskus-binaryExtract the primitive value haskus-binaryWiden a naturalwiden @7 (BitNat @5 25) BitNat @7 25 haskus-binaryNarrow a naturalnarrow @3 (BitNat @5 25) BitNat @3 1 haskus-binaryCompare two naturals haskus-binaryAdd two NaturalsBitNat @5 25 .+. BitNat @2 3 BitNat @6 28 haskus-binarySub two NaturalsBitNat @5 25 .-. BitNat @2 3Just (BitNat @5 22)BitNat @5 2 .-. BitNat @2 3Nothing haskus-binaryMultiply two NaturalsBitNat @5 25 .*. BitNat @2 3 BitNat @7 75 haskus-binary)Divide two Naturals, return (factor,rest)BitNat @5 25 ./. BitNat @2 3Just (BitNat @5 8,BitNat @2 1)BitNat @5 25 ./. BitNat @2 0Nothing BitNat @2 3 ./. BitNat @5 25 Just (BitNat  2 0,BitNat 5 3) haskus-binaryShift-left naturalslet x = BitNat @5 25x .<<. NatVal @2 BitNat @7 1003show (x .<<. NatVal @2) == show (x .*. BitNat @3 4)False.x .<<. NatVal @2 == narrow (x .*. BitNat @3 4)True haskus-binaryShift-right naturalsBitNat @5 25 .>>. NatVal @2 BitNat @3 6 haskus-binary Test a bit haskus-binaryXor haskus-binaryAnd haskus-binaryOr haskus-binaryShow instance for BitNat$#$#$None .>HUVXk[f  haskus-binary,A signed number (not in two-complement form))Bits: ddd..ddds where "s" is the sign bit-Allows symetric positive and negative numbersNegative zero is NaN haskus-binaryPositive signed literal signedPos @55 signedPos @00 haskus-binaryNegative signed literal signedNeg @5-5 signedNeg @00 haskus-binary Test for zerosignedIsZero (signedNeg @5)FalsesignedIsZero (signedNeg @0)True haskus-binary Test for NaNsignedIsNaN (signedPos @5)FalsesignedIsNaN (signedPos @0)False= haskus-binaryTest if positivesignedIsPositive (signedPos @5)TruesignedIsPositive (signedPos @0)TruesignedIsPositive (signedNeg @5)False haskus-binaryCreate from a BitNatsignedFromBitNat (bitNat @18)18 haskus-binaryNegate a signed numbersignedNegate (signedPos @5)-5signedNegate (signedNeg @5)5 haskus-binaryShow instance for Signed%None ,.>HUVXkh haskus-binary,A signed number (not in two-complement form))Bits: ddd..ddds where "s" is the sign bit-Allows symetric positive and negative numbers$Positive and negative zeros are zero haskus-binaryPositive signed literal signedPos @55 signedPos @00 haskus-binaryNegative signed literal signedNeg @5-5 signedNeg @00 haskus-binary Test for zerosignedIsZero (signedNeg @5)FalsesignedIsZero (signedNeg @0)True> haskus-binaryTest if positivesignedIsPositive (signedPos @5)TruesignedIsPositive (signedPos @0)TruesignedIsPositive (signedNeg @5)False haskus-binaryCreate from a BitNatsignedFromBitNat (bitNat @18)18 haskus-binaryNegate a signed numbersignedNegate (signedPos @5)-5signedNegate (signedNeg @5)5 haskus-binaryShow instance for Signed  &None%,-.1=>?@AHUVXgks  haskus-binary'A natural number in the specified range haskus-binaryNatural range patternNatRange @10 @12 11NatRange @10 @12 11 haskus-binary!Create a value in a Natural range haskus-binary2Create a value in a Natural range (check validity) haskus-binaryECreate a value in a Natural range (check validity and throw on error) haskus-binary!Create a value in a Natural range? haskus-binary!Convert a NatRange into a Natural haskus-binaryWiden a naturallet a = NatRange @18 @100 25widenNatRange @16 @200 aNatRange @16 @200 25 haskus-binaryAdd two natural ranges(NatRange @2 @4 3 .++. NatRange @7 @17 13NatRange @9 @21 16 haskus-binaryShow instance for natural range6NonetV'$#'None.=>?@AHUVX`k@ haskus-binary-Offset of the i-th element in a stored vector haskus-binaryVector with type-checked size haskus-binary$Return the buffer backing the vector haskus-binaryReverse a vector haskus-binaryYield the first n elements haskus-binaryDrop the first n elements haskus-binaryO(1)7 Index safely into the vector using a type level index. haskus-binary>Convert a list into a vector if the number of elements matches haskus-binary0Take at most n element from the list, then use z haskus-binary4Take at most (n-1) element from the list, then use z haskus-binaryConvert a vector into a list haskus-binary&Create a vector by replicating a value haskus-binary(Concat several vectors into a single one haskus-binaryZip two vectorsA haskus-binarymap(None> haskus-binary BitPut monad haskus-binaryBitPut monad transformer haskus-binary BitPut state haskus-binaryBuilder haskus-binary Current byte haskus-binaryCurrent offset haskus-binary Bit order haskus-binaryCreate a new BitPut state haskus-binaryPut bits haskus-binary Put a Buffer:Examples: 3 bits are already written in the current byte 6 BB: ABCDEFGH IJKLMNOP -> xxxABCDE FGHIJKLM NOPxxxxx  6 LL: ABCDEFGH IJKLMNOP -> LMNOPxxx DEFGHIJK xxxxxABC  6 BL: ABCDEFGH IJKLMNOP -> xxxPONML KJIHGFED CBAxxxxx  6 LB: ABCDEFGH IJKLMNOP -> EDCBAxxx MLKJIHGF xxxxxPON B haskus-binaryFlush the current byte haskus-binaryGet a buffer list haskus-binary Get a Buffer haskus-binaryEvaluate a BitPut monad haskus-binaryEvaluate a BitPut monad haskus-binaryPut bits (monadic) haskus-binaryPut a single bit (monadic) haskus-binaryPut a Buffer (monadic) haskus-binaryChange 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. haskus-binary.Change the bit ordering for the wrapped BitPut<Be careful, this function uses changeBitPutOrder internally.)None>| haskus-binary BitGet monad haskus-binaryBitGet monad transformer haskus-binary BitGet state  haskus-binaryInput  haskus-binaryBit offset (0-7)  haskus-binary Bit order  haskus-binaryCreate a new BitGetState haskus-binary!Indicate that the source is empty haskus-binary,Skip the given number of bits from the input haskus-binary8Skip the required number of bits to be aligned on 8-bits haskus-binary:Read the given number of bits and put the result in a word haskus-binary*Perform some checks before calling getBitsMCheck that the number of bits to read is not greater than the first parameter haskus-binary:Read the given number of Word8 and return them in a Buffer Examples: 6 BB: xxxABCDE FGHIJKLM NOPxxxxx -> ABCDEFGH IJKLMNOP  6 LL: LMNOPxxx DEFGHIJK xxxxxABC -> ABCDEFGH IJKLMNOP  6 BL: xxxPONML KJIHGFED CBAxxxxx -> ABCDEFGH IJKLMNOP  6 LB: EDCBAxxx MLKJIHGF xxxxxPON -> ABCDEFGH IJKLMNOP  haskus-binaryEvaluate a BitGet monad haskus-binaryEvaluate a BitGet monad haskus-binary3Evaluate a BitGet monad, return the remaining state haskus-binary3Evaluate a BitGet monad, return the remaining state haskus-binaryResume a BitGet evaluation haskus-binaryResume a BitGet evaluation haskus-binary#Indicate if all bits have been read haskus-binary>Skip the given number of bits from the input (monadic version) haskus-binaryJSkip the required number of bits to be aligned on 8-bits (monadic version) haskus-binary:Read the given number of bits and put the result in a word haskus-binary+Perform some checks before calling getBitsM haskus-binary$Get a bit and convert it into a Bool  haskus-binaryGet the given number of Word8! haskus-binaryChange 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." haskus-binary.Change the bit ordering for the wrapped BitGet<Be careful, this function uses changeBitGetOrder internally.      !"      !"None_ $ haskus-binary?Test whether all input *in the current chunk* has been consumed% haskus-binaryAGet the number of remaining unparsed bytes *in the current chunk*& haskus-binary>Skip ahead n bytes. Fails if fewer than n bytes are available.' haskus-binary9Skip ahead n bytes. No error if there isn't enough bytes.( haskus-binaryASkip to align n to al. Fails if fewer than n bytes are available.) haskus-binaryASkip to align n to al. Fails if fewer than n bytes are available.* haskus-binary=Run the getter without consuming its input. Fails if it fails+ haskus-binaryGRun the getter. Consume its input if Just _ returned. Fails if it fails, haskus-binaryHRun the getter. Consume its input if Right _ returned. Fails if it fails- haskus-binaryORequire an action to consume exactly the given number of bytes, fail otherwise. haskus-binaryORequire an action to consume at most the given number of bytes, fail otherwise/ haskus-binary(Pull n bytes from the input, as a Buffer0 haskus-binary Get Word81 haskus-binaryGet Word16 little-endian2 haskus-binaryGet Word16 big-endian3 haskus-binaryGet Word32 little-endian4 haskus-binaryGet Word32 big-endian5 haskus-binaryGet Word64 little-endian6 haskus-binaryGet Word64 big-endian7 haskus-binary4Get while True (read and discard the ending element)8 haskus-binary.Repeat the getter to read the whole bytestring9 haskus-binaryGet remaining bytes: haskus-binary.Count the number of bytes consumed by a getter; haskus-binary9Execute the getter and align on the given number of Word8< haskus-binary(Get Buffer terminated with 0 (consume 0)= haskus-binaryRun the Get monad> haskus-binary,Run a getter and throw an exception on error? haskus-binaryGet 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"@ haskus-binaryApply the getter at most C timesA haskus-binaryApply the getter at least D times and at most C times"$%&'()*+,-./0123456789:;<=>?@A"=>$%&'():;-.*+,9/<012345678?@A*None>B haskus-binary3Convert a stream of ULEB 128 bytes into an Integral:set -XBinaryLiterals import Control.Monad.Trans.State/getNext = do { ~(x:xs) <- get; put xs; pure x }Jlet x = evalState (fromULEB128 getNext) [0b10000001, 0b01111111] :: Word64x == 0b11111110000001TrueC haskus-binary2Convert an Integral into a stream of ULEB128 bytes:set -XBinaryLiterals:set -XFlexibleContexts4let f = toULEB128 (putStr . (++ " ") . bitsToString) f (0b1001001010101010 :: Word64)10101010 10100101 00000010D haskus-binary.Get an unsigned word in Little Endian Base 128E haskus-binary.Put an unsigned word in Little Endian Base 128F haskus-binary*Get a signed int in Little Endian Base 128G haskus-binary*Put a signed int in Little Endian Base 128H haskus-binary3Get a bytestring containing a decoded LEB128 stringBCDEFGHBCDEFGH+None >HMVXk?%I haskus-binary/Force a data to be read/stored as little-endianK haskus-binary,Force a data to be read/stored as big-endianM haskus-binaryReverse bytes in a wordS haskus-binaryExtended word puttersU haskus-binary Write a Word8V haskus-binaryWrite a Word16W haskus-binaryWrite a Word32X haskus-binaryWrite a Word64Y haskus-binary&Write a Word64 into a native size wordZ haskus-binaryExtended word getters\ haskus-binary Read a Word8] haskus-binary Read a Word16^ haskus-binary Read a Word32_ haskus-binary Read a Word64` haskus-binary%Read a native size word into a Word64a haskus-binarySize of a machine wordb haskus-binary32-bitc haskus-binary64-bitd haskus-binary Word puttersf haskus-binary Write a Word8g haskus-binaryWrite a Word16h haskus-binaryWrite a Word32i haskus-binaryWrite a Word64j haskus-binary Word getterl haskus-binary Read a Word8m haskus-binary Read a Word16n haskus-binary Read a Word32o haskus-binary Read a Word64p haskus-binary Endiannessq haskus-binaryLess significant bytes firstr haskus-binaryMost significant bytes firsts haskus-binary$Get getters for the given endiannesst haskus-binary$Get putters for the given endiannessu haskus-binaryReturn extended gettersv haskus-binaryReturn extended puttersw haskus-binary(Detect the endianness of the host memoryx haskus-binaryDetected host endiannessLTODO: use targetByteOrder in GHC.ByteOrder (should be introduced in GHC 8.4)0IJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoprqstuvwx0prqjklmnodefghistabcZ[\]^_`STUVWXYuvwxMNOPQRKLIJ,None .=>?HVX haskus-binary)Monad which can build a sequence of bytes haskus-binary Write a Word8 haskus-binaryWrite a Word16 haskus-binaryWrite a Word32 haskus-binaryWrite a Word64 haskus-binaryWrite some Word8 haskus-binaryWrite some Word16 haskus-binaryWrite some Word32 haskus-binaryWrite some Word64 haskus-binaryWrite the contents of a buffer haskus-binary/Pre-allocate at least the given amount of bytesBThis is a hint for the putter to speed up the allocation of memory haskus-binaryWrite a Float64 with host order haskus-binary(Write a Float64 with little-endian order haskus-binary%Write a Float64 with big-endian order haskus-binaryWrite a Float32 with host order haskus-binary(Write a Float32 with little-endian order haskus-binary%Write a Float32 with big-endian order haskus-binary'Write a Word16 with little-endian order haskus-binary'Write a Word32 with little-endian order haskus-binary'Write a Word64 with little-endian order haskus-binary$Write a Word16 with big-endian order haskus-binary$Write a Word32 with big-endian order haskus-binary$Write a Word64 with big-endian order haskus-binary*Write some Word16 with little-endian order haskus-binary*Write some Word32 with little-endian order haskus-binary*Write some Word64 with little-endian order haskus-binary'Write some Word16 with big-endian order haskus-binary'Write some Word32 with big-endian order haskus-binary'Write some Word64 with big-endian order-None*.;=?MQE haskus-binaryIncrement the current size haskus-binaryGet the total size.None .=>?HVX, haskus-binary(Monad which can read a sequence of bytes haskus-binary Read a Word8 haskus-binary"Read a Word16 with host endianness haskus-binary"Read a Word32 with host endianness haskus-binary"Read a Word64 with host endianness haskus-binaryRead some Word8 haskus-binary%Read some Word16 with host endianness haskus-binary%Read some Word32 with host endianness haskus-binary%Read some Word64 with host endianness haskus-binary0Read the given amount of bytes into a new buffer haskus-binary\Read the given amount of bytes into the specified buffer at the optionally specified offset haskus-binarySkip the given amount of bytes haskus-binaryGet a Float64 with host order haskus-binary&Get a Float64 with little-endian order haskus-binary#Get a Float64 with big-endian order haskus-binaryGet a Float32 with host order haskus-binary&Get a Float32 with little-endian order haskus-binary#Get a Float32 with big-endian order haskus-binary&Read a Word16 with little-endian order haskus-binary&Read a Word32 with little-endian order haskus-binary&Read a Word64 with little-endian order haskus-binary#Read a Word16 with big-endian order haskus-binary#Read a Word32 with big-endian order haskus-binary#Read a Word64 with big-endian order haskus-binary)Read some Word16 with little-endian order haskus-binary)Read some Word32 with little-endian order haskus-binary)Read some Word64 with little-endian order haskus-binary&Read some Word16 with big-endian order haskus-binary&Read some Word32 with big-endian order haskus-binary&Read some Word64 with big-endian order/None*;MX19 haskus-binaryA Get monad over a File haskus-binaryFileGetT stateF haskus-binaryGet file handleG haskus-binaryHelper to get some things haskus-binaryRun a getter on a file haskus-binaryRun a getter on a file0None*.;=?MO-% haskus-binaryA Get monad over a BufferH haskus-binaryBufferGetT stateI haskus-binaryBuffer used for readingJ haskus-binaryCurrent offsetK haskus-binaryExtension stretegy haskus-binaryJA Put monad than fails when there is not enough space in the target bufferL haskus-binaryBufferPutT stateM haskus-binaryBuffer used for writingN haskus-binaryCurrent offsetO haskus-binaryExtension strategy haskus-binaryBuffer extension information haskus-binaryCurrent buffer haskus-binaryCurrent offset in buffer haskus-binaryURequired size in bytes (don't take into account leftover bytes in the current buffer) haskus-binary|Action to perform when the buffer isn't large enough to contain the required data (extend the buffer, flush the data, etc.)8The returned buffer and offset replace the current ones. haskus-binaryBBuffer overflow strategy: fails when there isn't enough space left haskus-binary^Buffer extend strategy: double the buffer size each time and copy the original contents in it haskus-binary^Buffer extend strategy: double the buffer size each time and copy the original contents in it haskus-binaryZBuffer extend strategy: add the given size each time and copy the original contents in it haskus-binaryZBuffer extend strategy: add the given size each time and copy the original contents in it haskus-binaryLift into BufferPutT haskus-binaryRun a buffer put haskus-binaryGet current offset haskus-binary Get bufferP haskus-binary Set buffer haskus-binaryGet current offset haskus-binaryGet extend strategyQ haskus-binaryHelper to put somethingR haskus-binaryHelper to put some things  haskus-binaryLift into BufferGetT  haskus-binaryRun a buffer get  haskus-binaryGet current offset  haskus-binary Get bufferS haskus-binary Set buffer  haskus-binaryGet current offset haskus-binaryGet extend strategyT haskus-binaryHelper to get some things          1None .=>?HVXX  haskus-binaryBinary serializable data haskus-binarySize of the data in bytes haskus-binarySensible to endianness  haskus-binary!Dynamic size of the data in bytesThe default implementation execute the put method with a PutMonad that only stores the size in bytes. Overload this function if possible!! haskus-binarySerialize a value" haskus-binaryDeserialize a value# haskus-binary Size in bytes$ haskus-binaryExactly the given size% haskus-binary;Dynamically known size (the size is stored with the object) " !#%$ " !#%$2None8>HMVr0 haskus-binaryBit set indexed with a1 haskus-binary#Return the bit offset of an element2 haskus-binary-Return the value associated with a bit offset3 haskus-binaryPA 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.4 haskus-binaryIndicate if the set is empty5 haskus-binary Empty bitset6 haskus-binary%Create a BitSet from a single element7 haskus-binaryInsert an element in the set8 haskus-binaryRemove an element from the set9 haskus-binaryUnwrap the bitset: haskus-binary Wrap a bitset; haskus-binary Test if an element is in the set< haskus-binary Test if an element is in the set= haskus-binary$Test if an element is not in the set> haskus-binaryRetrieve elements in the set? haskus-binaryIntersection of two sets@ haskus-binaryIntersection of two setsA haskus-binaryIntersection of several setsB haskus-binaryConvert 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)C haskus-binary-Convert a bitset into a list of Enum elementsD haskus-binaryWConvert a bitset into a list of Enum elements by testing the Enum values successively.The difference with C5 is that extra values in the BitSet will be ignored.E haskus-binaryConvert a set into a listF haskus-binaryConvert a Foldable into a setH haskus-binary3It can be useful to get the indexes of the set bitsI haskus-binary3It can be useful to get the indexes of the set bits0123456789:;<=>?@ABCDEF3012456789:;<=>?@ABCDFE3None.=>?@AHMUVXk_U haskus-binary!Get the whole size of a BitFieldsV haskus-binary$Get the size of a field from it nameW haskus-binary%Get the type of a field from its nameX haskus-binary+Get the bit offset of a field from its nameO haskus-binaryA field of n bitsQ haskus-binaryBit fields on a base type bS haskus-binaryGet backing wordT haskus-binaryGet the value of a fieldU haskus-binary1Get the value of a field (without checking sizes)V haskus-binarySet the value of a fieldW haskus-binary1Set the value of a field (without checking sizes)X haskus-binaryModify the value of a fieldY haskus-binary4Modify the value of a field (without checking sizes)Z haskus-binaryGet values in a tuple[ haskus-binary%Get field names and values in a tupleY haskus-binary%Get field names and values in a tuplek haskus-binary%Get field names and values in a tupleNOPQRSTUVWXYZ[QRSOPTUVWXYZ[N4None.1>EHMUVXkPo haskus-binaryUnsigned fixed-point number * w is the backing type * iH is the number of bits for the integer part (before the radix point) * fF is the number of bits for the fractional part (after the radix point):set -XDataKindsimport Data.Word)fromIntegral 0 :: FixedPoint Word32 16 160 % 1*fromIntegral 10 :: FixedPoint Word32 16 1610 % 1q haskus-binaryGet base valuer haskus-binarySet base values haskus-binaryConvert to a fixed point valuet haskus-binary Convert from a fixed-point valueopqrstopqrst5None,.=>?@AHUVXk1~ haskus-binary Add two Unums haskus-binary Add two SORNs haskus-binaryAdd a SORN with itself haskus-binarySubtract two Unums haskus-binarySubtract two SORNS haskus-binarySubtract a SORN with itself haskus-binaryUncertainty bit haskus-binary Exact number haskus-binary#OpenInterval above the exact number haskus-binaryBacking word for the unum haskus-binary#Compute the number of bits requiredZ haskus-binaryAll unum members[ haskus-binaryIndexable numbers\ haskus-binaryPositive numbers in the unums haskus-binaryCompute the precise numbers set haskus-binaryAn 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 .. 0 haskus-binary Unum labels haskus-binarySize of an unum in bits haskus-binaryZero haskus-binaryInfinite haskus-binaryEncode a number haskus-binaryNegate a number haskus-binaryReciprocate a number haskus-binary Get unum sign haskus-binaryShow SORN bits haskus-binarySize of a SORN in bits haskus-binary Empty SORN haskus-binary Full SORN haskus-binaryFull SORN without infinite haskus-binaryFull SORN without infinite haskus-binarySORN singleton haskus-binaryInsert in a SORN haskus-binaryRemove in a SORN haskus-binaryTest membership in a SORN haskus-binaryUnion of two SORNs haskus-binaryIntersection of two SORNs haskus-binaryComplement the SORN haskus-binary Negate a SORN haskus-binaryElements in the SORN haskus-binaryCreate a SORN from its elements haskus-binary*Create a contiguous SORN from two elements haskus-binary%Convert a contiguous SORN into a SORN haskus-binary!Size of a contiguous SORN in bits haskus-binaryShow contiguous SORN bits haskus-binaryEmpty contigiuous SORN haskus-binary#Test if a contigiuous SORN is empty haskus-binaryContiguous SORN build haskus-binaryFull contiguous SORN haskus-binaryContiguous SORN singletonA{|}~A}~{|]78978:;<=78>78?78@78A78B78C78D78E78F78G78H78I78J78K;LM;LN;LO;LP;LQ;LR;LS;LS;TU;TV;TW;<X;<Y;<Z7[\]^_]^`]abcdecdefghijkl m m n n o o p p q q r s t u v w x y z z { | } ~                              !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPPQRSTUVWXYZ[\]^__``aabbcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'($)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abbcde f g h i d c j k!l!m!n!o!p!q!r!s!t!u!v!w!x!y!z!{!|!}!~!""""""""""############################################$$$$$$$$$%%%%%%%%%%%%%&&&&&&&&&''''''''''''''''''''''''((((((((((((( ( ( ( ( ((())))))))))))))))) )!)")#)$)%)&)')()))*)+),)-./0123456789:;<=>?@ABCDEFGHIJ*K*L*M*N*O*P*Q+R+R+S+S+T+U+V+W+X+Y+Z+Z+[+\+]+^+_+`+`+a+b+c+d+e+f+g+h+i+i+j+k+l+m+n+n+o+p+q+r+s+t+u+v+w+x+y+z+{+|+}+~+++++++++++++++++++++++++++++++++++++,,[,,,,,,,,W,,,,,,,,,,,,,,,,,,,-------..9........8....................//////////////000000000000000000000000000000000 0 0 0 0 000000011111111111111 1!1"1#1$1%2&2'2(2)2*2+2,2-2.2/202122232425262728292:222;2<2=2>2?2@2A33B3B3C3C3D3E3F3G3H3I3J3K3L3M3N3O3P3Q3R3S3T3U3V3W3X3Y3Z33[3\3]3^4_4_4`4a4b4c4d4e4f4g4h4i5j5j5k5l5m5n5o5p5q5r5s5t5u5v5w5x5y5z5{5{5|5}5~5555555555555555555555555555555555555555555555555555555 7[7[;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;777777;;7[7[;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7777 7 7 ; ; ;;;    !"#$%&';();(*7[+,$-%-&.'/'0(17273-4/5/60708090:0;0<0=0>0?0@0A0B063C33D3E3F5G5H5IJ(haskus-binary-1.5-KrERlT6pu1S99ACaI1BEy0Haskus.Number.IntHaskus.Number.WordHaskus.Memory.PtrHaskus.Binary.CTypesHaskus.Binary.PutHaskus.Binary.GetHaskus.Number.BitNatHaskus.Binary.Bits.OrderHaskus.Memory.LayoutHaskus.Memory.PropertyHaskus.Number.FloatHaskus.Binary.StorableHaskus.Memory.UtilsHaskus.Memory.BufferHaskus.Memory.ViewHaskus.Memory.TypedHaskus.Memory.EmbedHaskus.Memory.Allocator.MallocHaskus.Binary.UnionHaskus.Binary.RecordHaskus.Binary.EnumHaskus.Binary.CharHaskus.Binary.Bits.ShiftHaskus.Binary.Bits.FiniteHaskus.Binary.Bits.BitwiseHaskus.Binary.Bits.RotateHaskus.Binary.Bits.MaskHaskus.Binary.Bits.HelperHaskus.Binary.Bits.IndexHaskus.Binary.BufferHaskus.Binary.BufferListHaskus.Binary.BufferBuilderHaskus.Binary.Bits.ReverseHaskus.Binary.BitsHaskus.Number.PositHaskus.Number.SignedSafeHaskus.Number.SignedHaskus.Number.NaturalRangeHaskus.Binary.VectorHaskus.Binary.Bits.PutHaskus.Binary.Bits.GetHaskus.Number.VariableLengthHaskus.Binary.EndiannessHaskus.Binary.Serialize.PutHaskus.Binary.Serialize.SizeHaskus.Binary.Serialize.GetHaskus.Binary.Serialize.FileHaskus.Binary.Serialize.BufferHaskus.Binary.SerializeHaskus.Binary.BitSetHaskus.Binary.BitFieldHaskus.Number.FixedPointHaskus.Binary.Unum Haskus.Numberghc-primGHC.PrimInt#Word#baseGHC.PtrFunPtr+#-#>#>=#==#<#<=# plusWord# minusWord#gtWord#geWord#eqWord#ltWord#leWord#Foreign.C.TypesCShortCUShortCIntCUIntCLongCULongCSize Foreign.Ptr wordPtrToPtr ptrToWordPtrWordPtrcastPtrToFunPtrcastFunPtrToPtr nullFunPtr GHC.TypesisTrue#%cereal-0.5.8.1-KRPM4Pfa6l3HK7sjbDz33xData.Serialize.PutPutMPutData.Serialize.GetGet-haskus-utils-types-1.5-Ey3ChkeJKhMJ20wX0gLjL3Haskus.Utils.Types.ProxyNatValBitOrderBBLBBLLL$fShowBitOrder $fEqBitOrderCUnionCStructCUArrayCArray CPrimitive:#>:-> LPathOffset LPathTypeLRootPathElemLIndexLSymbolLPathlPath Finalization Collected Finalized NotFinalizedPinningPinned NotPinnedHeapInternalExternal MutabilityMutable Immutable$fShowMutability$fEqMutability $fShowPinning $fEqPinning$fShowFinalization$fEqFinalization AnyPointerPtrMFPtrIFPtrMPtrIFinPtrRawPtrPointer isNullPtrnullPtrInullPtrMindexPtr distancePtrwithFinalizedPtrwithPtrallocFinalizedPtrallocPtrfreePtr $fShowPointerIntN IntAtLeastWordN WordAtLeastFloat64Float32word32ToFloat32float32ToWord32word64ToFloat64float64ToWord64 PaddingExPaddingRequiredPaddingStorablepeekIOpokeIO alignmentsizeOfStaticStorableSizeOf Alignment staticPeekIO staticPokeIO staticPeek staticPoke staticSizeOfstaticAlignment wordBytespeekpokesizeOf'sizeOfTsizeOfT' alignment' alignmentT alignmentT' peekByteOff pokeByteOff peekElemOff pokeElemOff allocaBytesallocaBytesAlignedallocamallocwith allocaArray mallocArray peekArray pokeArray withArray withArrayLenwithMany$fStaticStorableInt64$fStaticStorableInt32$fStaticStorableInt16$fStaticStorableInt8$fStaticStorableWord64$fStaticStorableWord32$fStaticStorableWord16$fStaticStorableWord8 $fGStorableM1$fGStorable:*: $fGStorableU1$fStorableWordPtr$fStorableCShort$fStorableCUShort$fStorableCInt$fStorableCUInt$fStorableCLong$fStorableCULong$fStorableCChar$fStorableCSize $fStorablePtr $fStorableInt$fStorableWord$fStorableChar$fStorableDouble$fStorableFloat$fStorableInt64$fStorableInt32$fStorableInt16$fStorableInt8$fStorableWord64$fStorableWord32$fStorableWord16$fStorableWord8 $fGStorableK1memcpy#memCopymemSet allocaArrays peekArrays pokeArrays withArrayswithMaybeOrNull AnyBuffer BufferToList bufferToList BufferSize bufferSizeThawableunsafeBufferThaw FreezableunsafeBufferFreeze FinalizersBufferEF BufferMEF BufferMPFBufferMFBufferPFBufferFBufferEBufferMEBufferMPBufferMBufferPBufferIBuffer newBuffernewPinnedBuffernewAlignedPinnedBuffer addFinalizer touchBuffertouchmakeFinalizablebufferIsDynamicallyPinnedbufferDynamicallyPinnedunsafeWithBufferAddr#unsafeWithBufferPtrwithBufferAddr# withBufferPtr bufferSizeIObufferToListIObufferReadWord8IObufferReadWord8bufferWriteWord8IObufferReadWord16IObufferReadWord16bufferWriteWord16IObufferReadWord32IObufferReadWord32bufferWriteWord32IObufferReadWord64IObufferReadWord64bufferWriteWord64IO copyBuffer$fIsListBuffer$fFreezableBufferBuffer$fFreezableBufferBuffer0$fThawableBufferBuffer$fThawableBufferBuffer0$fBufferSizeBuffer$fBufferSizeBuffer0$fBufferSizeBuffer1$fBufferSizeBuffer2$fBufferSizeBuffer3$fBufferSizeBuffer4$fBufferSizeBuffer5$fBufferSizeBuffer6$fBufferToListBuffer$fBufferToListBuffer0$fBufferToListBuffer1$fBufferToListBuffer2 ViewPattern PatternFull Pattern1D Pattern2D PatternOnpattern1DOffset pattern1DSizepattern2DOffsetpattern2DWidthpattern2DHeightpattern2DStrideView ViewSource SourceBufferSourceWeakBufferSourceWeakViewunsafePatternSize patternSize viewReadWord8 newBufferViewnewBufferWeakViewnewViewWeakViewcopyBufferWithPattern viewToBuffer showViewState$fShowViewPatternPtrTBufferTPointerT EmbedEntryembedEntryTypeembedEntryAlignementembedEntrySymbolembedEntryFilePathembedEntryOffsetembedEntrySize SectionTypeReadOnlySectionWriteableSectionUninitializedSection embedBytes loadSymbolloadMutableSymbol toBufferE toBufferE' toBufferME toBufferME'makeEmbeddingFile embedFileembedPinnedBufferembedUnpinnedBuffer embedBuffer$fShowSectionType$fEqSectionType$fOrdSectionType$fShowEmbedEntry$fEqEmbedEntry$fOrdEmbedEntrynewFinalizedBuffer makeFinalized freeBufferUnion fromUniontoUnion toUnionZero$fStaticStorableUnion$fApplyFoldSizeOf(,)r$fStorableUnion$fStorableUnion0$fApplyFoldAlignment(,)r $fShowUnionPath RecordSizeFieldRecord recordSizerecordAlignmentrecordFieldOffset recordFieldrecordFieldPathOffsetrecordFieldPath recordToList$fStaticStorableRecord $fShowRecord$fApplyExtract(,)rCEnum fromCEnumtoCEnum EnumField fromEnumField toEnumFieldmakeEnumWithCustom makeEnumMaybemakeEnum dataToTag$fStaticStorableEnumField$fShowEnumField $fEqEnumField$fStorableEnumFieldChar8 $fShowChar8 $fEqChar8 $fOrdChar8$fStorableChar8SignedShiftableBits signedShiftR signedShiftLuncheckedSignedShiftRuncheckedSignedShiftL signedShiftuncheckedSignedShift ShiftableBitsshiftRshiftLuncheckedShiftRuncheckedShiftLshiftuncheckedShift$fShiftableBitsNatural$fShiftableBitsInteger$fShiftableBitsInt64$fShiftableBitsInt32$fShiftableBitsInt16$fShiftableBitsInt8$fShiftableBitsInt$fShiftableBitsWord64$fShiftableBitsWord32$fShiftableBitsWord16$fShiftableBitsWord8$fShiftableBitsWord$fSignedShiftableBitsInt64$fSignedShiftableBitsInt32$fSignedShiftableBitsInt16$fSignedShiftableBitsInt8$fSignedShiftableBitsInt FiniteBitsBitSizebitSizezeroBitsoneBitscountLeadingZeroscountTrailingZeros complement$fFiniteBitsInt64$fFiniteBitsInt32$fFiniteBitsInt16$fFiniteBitsInt8$fFiniteBitsInt$fFiniteBitsWord64$fFiniteBitsWord32$fFiniteBitsWord16$fFiniteBitsWord8$fFiniteBitsWordBitwise.&..|.xor$fBitwiseNatural$fBitwiseInteger$fBitwiseInt64$fBitwiseInt32$fBitwiseInt16 $fBitwiseInt8 $fBitwiseInt$fBitwiseWord64$fBitwiseWord32$fBitwiseWord16$fBitwiseWord8 $fBitwiseWord RotatableBitsrotaterotateLrotateRuncheckedRotateuncheckedRotateLuncheckedRotateR$fRotatableBitsInt64$fRotatableBitsInt32$fRotatableBitsInt16$fRotatableBitsInt8$fRotatableBitsInt$fRotatableBitsWord64$fRotatableBitsWord32$fRotatableBitsWord16$fRotatableBitsWord8$fRotatableBitsWordMaskableMaskBits makeMaskDynmakeMaskFinitemakeMaskmaskDynmask$fMaskBitsInt64$fMaskBitsInt32$fMaskBitsInt16$fMaskBitsInt8 $fMaskBitsInt$fMaskBitsWord64$fMaskBitsWord32$fMaskBitsWord16$fMaskBitsWord8$fMaskBitsWord$fMaskBitsNatural bitOffset byteOffset IndexableBitsbitsetBitclearBit complementBittestBitpopCount$fIndexableBitsNatural$fIndexableBitsInteger$fIndexableBitsInt64$fIndexableBitsInt32$fIndexableBitsInt16$fIndexableBitsInt8$fIndexableBitsInt$fIndexableBitsWord64$fIndexableBitsWord32$fIndexableBitsWord16$fIndexableBitsWord8$fIndexableBitsWord bufferDup bufferZero bufferZipWith isBufferEmpty emptyBufferbufferPeekStorablebufferPeekStorableAtbufferPopStorable bufferPoke bufferMap bufferReverse bufferDrop bufferSplitOn bufferTail bufferAppend bufferCons bufferSnoc bufferInit bufferHead bufferIndexbufferUnpackByteListbufferUnpackByteString bufferTakebufferTakeWhilebufferTakeAtMostbufferPackByteStringbufferPackByteListbufferPackStorablebufferPackStorableList bufferPackPtrbufferUnsafePackPtrbufferUnsafeDropbufferUnsafeTakebufferUnsafeTailbufferUnsafeHeadbufferUnsafeLastbufferUnsafeInitbufferUnsafeIndexbufferUnsafeMapMemorybufferUnsafeUsePtrbufferReadFilebufferWriteFile$fIndexableBitsBuffer$fBitwiseBuffer $fShowBuffer $fEqBuffer $fOrdBufferrunPutrunPutM putBuffer putByteString putPaddingputPaddingAlignputWord8 putWord16le putWord16be putWord32le putWord32be putWord64le putWord64be BufferListtoBuffer toBufferListtoLazyByteString BufferBuilderemptyBufferBuilder fromBuffer fromWord8$fSemigroupBufferBuilder$fMonoidBufferBuilderReversableBits reverseBitsreverseBitsGenericreverseBitsObviousreverseBits3OpsreverseBits4OpsreverseBitsTablereverseBits7OpsreverseBits5LgNliftReverseBits$fReversableBitsInt$fReversableBitsInt64$fReversableBitsInt32$fReversableBitsInt16$fReversableBitsInt8$fReversableBitsWord$fReversableBitsWord64$fReversableBitsWord32$fReversableBitsWord16$fReversableBitsWord8Bits isPowerOfTwo getPowerOfTwo isPowerOfFourgetPowerOfFourreverseLeastBits bitsToString bitsToStringNbitsFromString getBitRange PositEncoding PositInfinity PositZero PositFields positNegativepositRegimeBitCountpositExponentBitCountpositFractionBitCount positRegime positExponent positFractionPositKZeroInfinityValue PositKindZeroK InfinityKNormalKPosit positKindisZero isInfinity isPositive isNegativepositAbs positEncoding positFieldspositToRationalpositFromRationalpositApproxFactorpositDecimalErrorpositDecimalAccuracypositBinaryErrorpositBinaryAccuracyfloatBinaryAccuracy $fShowPosit$fShowPositKind $fEqPositKind$fShowPositFields$fShowPositEncodingBitNatShiftLeftBitNatShiftRightNarrowWiden MakeBitNatIsBitNat BitNatWordBitNatbitNat bitNatZero bitNatOnebitNatToNaturalunsafeMakeBitNatsafeMakeBitNatextractWwidennarrowcompareW.+..-..*../..<<..>>. bitNatTestBit bitNatXor bitNatAndbitNatOr $fOrdBitNat $fEqBitNat $fShowBitNatSigned signedPos signedNeg signedIsZero signedIsNaNsignedFromBitNat signedNegate $fShowSigned SignedNegateSignedFromBitNat SignedIsZero SignedNeg SignedPosNatRangeunsafeMakeNatRangesafeMakeNatRange makeNatRangenatRange widenNatRange.++.$fShowNatRangeVector vectorBuffer vectorReversetakedropindexfromListfromFilledListfromFilledListZtoList replicateconcatzipWith$fRotatableBitsVector$fIndexableBitsVector$fShiftableBitsVector$fFiniteBitsVector$fBitwiseVector $fEqVector$fStorableVector$fStaticStorableVector $fShowVector$fApplyStoreVector(,)rBitPutBitPutT BitPutStatebitPutStateBuilderbitPutStateCurrentbitPutStateOffsetbitPutStateBitOrdernewBitPutStateputBits putBitsBuffergetBitPutBufferListgetBitPutBuffer runBitPutT runBitPutputBitsM putBitBoolMputBitsBufferMchangeBitPutOrderwithBitPutOrderBitGetBitGetT 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 getManyAtMostgetManyBounded fromULEB128 toULEB128 getULEB128 putULEB128 getSLEB128 putSLEB128getLEB128BufferAsLittleEndian AsBigEndianByteReversable reverseByteshostToBigEndianbigEndianToHosthostToLittleEndianlittleEndianToHostExtendedWordPuttersextwordPutter8extwordPutter16extwordPutter32extwordPutter64extwordPutterNExtendedWordGettersextwordGetter8extwordGetter16extwordGetter32extwordGetter64extwordGetterNWordSize WordSize32 WordSize64 WordPutters wordPutter8 wordPutter16 wordPutter32 wordPutter64 WordGetters wordGetter8 wordGetter16 wordGetter32 wordGetter64 Endianness LittleEndian BigEndiangetWordGettersgetWordPuttersgetExtendedWordGettersgetExtendedWordPuttersgetHostEndiannesshostEndianness$fCEnumEndianness$fByteReversableWord64$fByteReversableWord32$fByteReversableWord16$fByteReversableWord8$fStorableAsBigEndian$fStaticStorableAsBigEndian$fShowAsBigEndian$fStorableAsLittleEndian$fStaticStorableAsLittleEndian$fShowAsLittleEndian$fEqEndianness$fShowEndianness$fEnumEndianness$fShowWordSize $fEqWordSize$fEqAsBigEndian$fOrdAsBigEndian$fEnumAsBigEndian$fNumAsBigEndian$fIntegralAsBigEndian$fRealAsBigEndian$fBitwiseAsBigEndian$fFiniteBitsAsBigEndian$fReversableBitsAsBigEndian$fRotatableBitsAsBigEndian$fShiftableBitsAsBigEndian$fIndexableBitsAsBigEndian$fEqAsLittleEndian$fOrdAsLittleEndian$fEnumAsLittleEndian$fNumAsLittleEndian$fIntegralAsLittleEndian$fRealAsLittleEndian$fBitwiseAsLittleEndian$fFiniteBitsAsLittleEndian$fReversableBitsAsLittleEndian$fRotatableBitsAsLittleEndian$fShiftableBitsAsLittleEndian$fIndexableBitsAsLittleEndianPutMonad putWord16 putWord32 putWord64 putWord8s putWord16s putWord32s putWord64spreAllocateAtLeast putFloat64 putFloat64LE putFloat64BE putFloat32 putFloat32LE putFloat32BE putWord16LE putWord32LE putWord64LE putWord16BE putWord32BE putWord64BE putWord16LEs putWord32LEs putWord64LEs putWord16BEs putWord32BEs putWord64BEsGetSize runGetSize$fPutMonadGetSize$fFunctorGetSize$fApplicativeGetSize$fMonadGetSizeGetMonad getWord16 getWord32 getWord64 getWord8s getWord16s getWord32s getWord64s getBufferInto getSkipBytes getFloat64 getFloat64LE getFloat64BE getFloat32 getFloat32LE getFloat32BE getWord16LE getWord32LE getWord64LE getWord16BE getWord32BE getWord64BE getWord16LEs getWord32LEs getWord64LEs getWord16BEs getWord32BEs getWord64BEsFileGetT FileGetState fileGetHandle runFileGetrunFilePathGet$fGetMonadFileGetT$fFunctorFileGetT$fApplicativeFileGetT$fMonadFileGetT$fMonadFailFileGetT$fMonadFixFileGetT$fMonadIOFileGetT BufferGet BufferGetT BufferPut BufferPutTBufferOverflowoverflowBufferoverflowOffsetoverflowRequiredOverflowStrategyoverflowBufferFailoverflowBufferDoubleoverflowBufferDoublePinnedoverflowBufferAddoverflowBufferAddPinned liftBufferPut runBufferPut getPutOffset getPutBuffer setPutOffsetgetPutOverflowStrategy liftBufferGet runBufferGet getGetOffset getGetBuffer setGetOffsetgetGetOverflowStrategy$fPutMonadBufferPutT$fGetMonadBufferGetT$fFunctorBufferPutT$fApplicativeBufferPutT$fMonadBufferPutT$fMonadFailBufferPutT$fMonadFixBufferPutT$fMonadIOBufferPutT$fFunctorBufferGetT$fApplicativeBufferGetT$fMonadBufferGetT$fMonadFailBufferGetT$fMonadFixBufferGetT$fMonadIOBufferGetT SerializableEndianputgetSizeExactlyDynamic$fSerializableAsLittleEndian$fSerializableAsBigEndian$fSerializableInt64$fSerializableInt32$fSerializableInt16$fSerializableInt8$fSerializableWord64$fSerializableWord32$fSerializableWord16$fSerializableWord8 BitOffset toBitOffset fromBitOffsetBitSetnullempty singletoninsertdeletetoBitsfromBitsmemberelem notMemberelems intersectionunionunionsfromListToBitstoListFromBitsenumerateSetBits$fIsListBitSet$fBitOffsetWord$fBitOffsetInt $fShowBitSet $fEqBitSet $fOrdBitSet$fStorableBitSetBitField BitFields bitFieldsBits extractField extractField' updateField updateField' withField withField' matchFieldsmatchNamedFields$fFieldEnumField $fFieldBitSet $fFieldInt64 $fFieldInt32 $fFieldInt16 $fFieldInt8 $fFieldInt $fFieldWord64 $fFieldWord32 $fFieldWord16 $fFieldWord8 $fFieldWord $fFieldBool $fEqBitFields$fShowBitFields$fApplyName(,)r$fStorableBitFields$fStorableBitField FixedPointgetFixedPointBasefromFixedPointBase toFixedPointfromFixedPoint$fShowFixedPoint$fOrdFixedPoint$fRealFixedPoint$fNumFixedPoint$fStorableFixedPoint$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 $fUnumNumI $fUnumNumNeg $fUnumNumRcp$fUnumNumUncertain$fApplyGetLabel(,)r$fShowU$fEqU $fShowSORN $fShowCSORN $fShowUBit$fEqUBit $fShowSign$fEqSignfToRIntI#GHC.IntInt8I8#Int16I16#Int32I32#Int64I64#leInt64ltInt64geInt64gtInt64neInt64eqInt64leInt32ltInt32geInt32gtInt32neInt32eqInt32leInt16ltInt16geInt16gtInt16neInt16eqInt16leInt8ltInt8geInt8gtInt8neInt8eqInt8 GHC.ClasseseqIntneIntgtIntgeIntltIntleIntuncheckedIShiftRA64#uncheckedIShiftL64#WordW#GHC.WordWord8W8#Word16W16#Word32W32#Word64W64#leWord64ltWord64geWord64gtWord64neWord64eqWord64leWord32ltWord32geWord32gtWord32neWord32eqWord32leWord16ltWord16geWord16gtWord16neWord16eqWord16leWord8ltWord8geWord8gtWord8neWord8eqWord8eqWordneWordgtWordgeWordltWordleWord byteSwap64uncheckedShiftRL64#uncheckedShiftL64# byteSwap32 byteSwap16fsPeekfsPokememsetinsertFinalizer getFinalizers runFinalizers newFinalizerstoListBufferIO toListBuffer patternOffsetpatternApplyOn withValidViewbufferWeakViewFinaliermakeEmbedEntry embedFile'freetoUnion' unionSizeunionAlignment FieldPathTypeFieldPathOffsetRecordAlignmentFullRecordSizeGHC.RealmoddivTruemakeWsignedIsPositivetoNaturalNatRange ElemOffsetmapflushIncompletemaxminincSize getHandle getSomethingBufferGetStatebufferGetBufferbufferGetOffsetbufferGetStratBufferPutStatebufferPutBufferbufferPutOffsetbufferPutStrat setPutBuffer putSomething putSomeThings setGetBuffer WholeSizeOutputOffsetmatchNamedFields' UnumMembersUnumIndexables UnumPositives