h&      !"#$%&'()*+,-./0123456789:;<= > ? @ ABCDEF 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 st u v w x y z { |}~          $ Safe-Inferred  flat"Convert to/from strict ByteStrings   Trustworthy cflatReinterpret-casts a  to a .'\f -> wordToFloat (floatToWord f ) == f+++ OK, passed 100 tests.floatToWord (-0.15625) 3189768192wordToFloat 3189768192-0.15625%floatToWord (-5.828125) == 0xC0BA8000TrueflatReinterpret-casts a  to a .flatReinterpret-casts a  to a .)\f -> wordToDouble (doubleToWord f ) == f+++ OK, passed 100 tests.,showHex (doubleToWord 1.0000000000000004) """3ff0000000000002"5doubleToWord 1.0000000000000004 == 0x3FF0000000000002True$showHex (doubleToWord (-0.15625)) """bfc4000000000000"wordToDouble 0xbfc4000000000000-0.15625flatReinterpret-casts a  to a .flatrunST (cast (0xF0F1F2F3F4F5F6F7::Word64)) == (0xF0F1F2F3F4F5F6F7::Word64)True Safe-Inferred<flatConvert between a signed integral and the corresponding ZigZag encoded unsigned integral (e.g. between Int8 and Word8 or Integral and Natural).Allow conversion only between compatible types, invalid conversions produce a type error: zigZag (-1::Int64) :: Word32 ... ... Couldn't match type ... ... zigZag (0::Int8)0zigZag (-1::Int16)1zigZag (1::Int32)2zigZag (-2::Int16)3zigZag (-50::Integer)99zigZag (50::Integer)100zigZag (64::Integer)128zigZag (-256::Integer)511zigZag (256::Integer)512map zigZag [-3..3::Integer][5,3,1,0,2,4,6]map zagZig [0..6::Word8][0,-1,1,-2,2,-3,3]'\(f::Integer) -> zagZig (zigZag f) == f+++ OK, passed 100 tests.'\(f::Natural) -> zigZag (zagZig f) == f+++ OK, passed 100 tests.$\(f::Int8) -> zagZig (zigZag f) == f+++ OK, passed 100 tests.%\(f::Word8) -> zigZag (zagZig f) == f+++ OK, passed 100 tests.\(s::Int8) -> zigZag s == fromIntegral (zigZag (fromIntegral s :: Integer))+++ OK, passed 100 tests.\(u::Word8) -> zagZig u == fromIntegral (zagZig (fromIntegral u :: Natural))+++ OK, passed 100 tests.%\(f::Int64) -> zagZig (zigZag f) == f+++ OK, passed 100 tests.&\(f::Word64) -> zigZag (zagZig f) == f+++ OK, passed 100 tests.\(s::Int64) -> zigZag s == fromIntegral (zigZag (fromIntegral s :: Integer))+++ OK, passed 100 tests.\(u::Word64) -> zagZig u == fromIntegral (zagZig (fromIntegral u :: Natural))+++ OK, passed 100 tests. Safe-Inferred8flatAn exception during decoding!flatA decoded value$flat Decoder state(flat A decoder.Given:end of input buffer current position in input bufferReturns: decoded valuenew position in input buffer !"#$%&'()*+,-.()*$%&'"#! +,-.  Safe-Inferred>flat5Convert a 64 bit value in cpu endianess to big endiantoBE64 0xF0F1F2F3F4F5F6F7 == if isBigEndian then 0xF0F1F2F3F4F5F6F7 else 0xF7F6F5F4F3F2F1F0True?flat5Convert a 32 bit value in cpu endianess to big endiantoBE32 0xF0F1F2F3 == if isBigEndian then 0xF0F1F2F3 else 0xF3F2F1F0True@flat5Convert a 16 bit value in cpu endianess to big endian7toBE16 0xF0F1 == if isBigEndian then 0xF0F1 else 0xF1F0True=>?@?>@= Safe-Inferred+Bflat5Copy bytestring to given pointer, returns new pointerCflat4Copy ByteArray to given pointer, returns new pointerflatWrapper around copyByteArrayToAddr# primop."Copied from the store-core packageflatWrapper around copyAddrToByteArray# primop."Copied from the store-core packageABCDEDECBA  Safe-InferredFflat4A special state, optimised for constructor decoding.It consists of:The bits to parse, the top bit being the first to parse (could use a Word16 instead, no difference in performance)The number of decoded bits)Supports up to 512 constructors (9 bits).Hflat8Switch to constructor decoding {-# INLINE consOpen #-}Iflat;Switch back to normal decoding {-# NOINLINE consClose #-}JflatDecode a single bitKflatDecode from 1 to 3 bitsIt could read more bits that are available, but it doesn't matter, errors will be checked in consClose.flat5Ensure that the specified number of bits is availableLflat!Drop the specified number of bitsMflatDecode a booleanNflat7Return the n most significant bits (up to maximum of 8)$The bits are returned right shifted:?unflatWith (dBEBits8 3) [0b11100001::Word8] == Right 0b00000111True6unflatWith (dBEBits8 9) [0b11100001::Word8,0b11111111](Left (BadOp "read8: cannot read 9 bits")Oflat8Return the n most significant bits (up to maximum of 16)$The bits are returned right shifted:pPrint . asBits <$> unflatWith (dBEBits16 11) [0b10110111::Word8,0b11100001]Right 00000101 10111111If more than 16 bits are requested, only the last 16 are returned:pPrint . asBits <$> unflatWith (dBEBits16 19) [0b00000000::Word8,0b11111111,0b11100001]Right 00000111 11111111PflatReturn the n most significant bits (up to maximum of 32) The bits are returned right shifted.QflatReturn the n most significant bits (up to maximum of 64) The bits are returned right shifted.Rflat1Return the 8 most significant bits (same as dBE8)Sflat"Return the 8 most significant bitsTflat#Return the 16 most significant bitsUflat#Return the 32 most significant bitsVflat#Return the 64 most significant bitsWflatDecode a FloatXflatDecode a DoubleYflatDecode a Lazy ByteStringZflatDecode a ByteString[flat!Decode a ByteArray and its length\flatDecode an Array (a list of chunks up to 255 bytes long) returning the pointer to the first data byte and a list of chunk sizesFGHIJKLMNOPQRSTUVWXYZ[\MRSTUVNOPQLWX\ZY[FGHIJK  Safe-Inferred %R]^_`abcdefghijklmnop^]pmnokl`_jRghiacdefb  Safe-Inferred!qflatGiven a decoder and an input buffer returns either the decoded value or an error (if the input buffer is not fully consumed)rflat-Decode a list of values, one value at a time.Useful in case that the decoded values takes a lot more memory than the encoded ones.6See test/FlatRepr.hs for a test and an example of use.qrqr! Safe-Inferred!0 !(FGHIJKLMNOPQRSTUVWX]^_`abcdefghijklmnopqr0qr! (pmnokl^]WX`_jMRghiacdefbSTUVNOPQLFGHIJK" Safe-Inferred"~ Safe-Inferred"sflatNumber of bitsss  Safe-Inferred#tflatA basic encoderuflatStrict encoder statezflatAdd the maximum size in bits of the encoding of value a to a NumBitsstuvywxzzstuvywx Safe-Inferred( flatEncode text as UTF8 and encode the result as an array of bytesflat?Encode text as UTF16 and encode the result as an array of bytesflatEncode a Lazy ByteStringflatEncode up to 9 bitsflatEncode up to 8 bits.flat enc eTrueF"1"flat enc eFalseF"0"flatenc $ eTrueF >=> eFillerF "10000001" enc eFillerF "00000001"flat,enc $ \s-> eWord8F 0 s >>= updateWord8 255 s "11111111"enc $ \s0 -> eTrueF s0 >>= \s1 -> eWord8F 255 s1 >>= eWord8F 255 >>= updateWord8 0 s1"10000000 01111111 1"enc $ \s0 -> eFalseF s0 >>= \s1 -> eWord8F 0 s1 >>= updateWord8 255 s1 "01111111 1"enc $ \s0 -> eFalseF s0 >>= \s1 -> eWord8F 0 s1 >>= updateWord8 255 s1 >>= eFalseF "01111111 10"enc $ \s0 -> eTrueF s0 >>= \s1 -> eWord8F 255 s1 >>= eTrueF >>= updateWord8 0 s1 >>= eTrueF"10000000 011"flato == 0 = pokeByteAligned t s | otherwise = pokeByteUnaligned t s where {-# INLINE pokeByteUnaligned #-} pokeByteUnaligned :: Word8 -> S -> IO () pokeByteUnaligned t (S op w o) = do let op' = plusPtr op 1 poke op (w .|. (t . o)) v :: Word8 <- peek op' poke op' (t  (8 - o) .|. ((v  o)  o))!|}~!|}~ Safe-Inferred) Safe-Inferred%&+flatStrict encoderflatEncode as a ListflatEncode as Arrayflat(the maximum size in bits of the encodingflat the encoderflat:the encoded bytestring + the actual number of encoded bits== Safe-Inferred,,<sz<sz Trustworthy1<4flat Calculate number of constructorsflatCalculate size in bits of constructor vs proxy implementation: similar compilation time but much better run times (at least for Tree N, -70%)flatCalculate the number of bits required for the serialisation of a value Implemented as a function that adds the maximum size to a running totalflatConstructor DecoderflatGeneric DecodingflatGeneric EncoderflatDecode to the size in bits of a value rather than to the value itself (see  Flat.Repr)flat*Class of types that can be encoded/decoded&Encoding a value involves three steps::calculate the maximum size of the serialised value, using )preallocate a buffer of the required size&encode the value in the buffer, using flat/Return the encoding corrresponding to the valueflatDecode a valueflat8Add maximum size in bits of the value to the total count6Used to calculated maximum buffer size before encodingflatCalculate the maximum size in bits of the serialisation of the valueflat%Skip a value, return its size in bitsflat$Product: constructor with parametersflatConstructor without argumentsflatType without constructorsflat Metadata (constructor name, etc)flatConstructor without argumentsflatType without constructorsflat Skip metadataflat Skip metadataflat6Constants, additional parameters, and rank-1 recursionflatData types with up to 512 constructors Uses a custom constructor decoding state instance {-# OVERLAPPABLE #-} (GFlatDecodeSum (a :+: b),GFlatDecode a, GFlatDecode b) => GFlatDecode (a :+: b) where  Safe-Inferred(5( !(FGHIJKLMNOPQRSTUVWX]^_`abcdefghijklmnopqrsz Safe-Inferred:flattt (UTF16Text $ T.pack "aaa")(True,[1,6,97,0,97,0,97,0,0])tt (UTF16Text $ T.pack "ȆȆȆ")6(True,[1,12,0,216,72,223,0,216,72,223,0,216,72,223,0])(A wrapper to encode/decode Text as UTF16flatThe desired text encoding can be explicitly specified using the wrappers UTF8Text and UTF16Text.The default encoding is UTF8:3tst (UTF8Text $ T.pack "") == tst (T.pack "")True'A wrapper to encode/decode Text as UTF8flatText (and Data.Text.Lazy) is encoded as a byte aligned array of bytes corresponding to its UTF8 encoding.tt $ T.pack "" (True,[1,0])tt $ T.pack "aaa"(True,[1,3,97,97,97,0])tt $ T.pack ""&(True,[1,6,194,162,194,162,194,162,0])tt $ T.pack ""2(True,[1,9,230,151,165,230,151,165,230,151,165,0])tt $ T.pack "ȆȆȆ"?(True,[1,12,240,144,141,136,240,144,141,136,240,144,141,136,0]),Strict and Lazy Text have the same encoding:)tst (T.pack "abc") == tst (TL.pack "abc")True Safe-InferredDflat.Maps are saved as lists of (key,value) tuples.2tst (AsMap (Data.Map.fromList ([]::[(Word8,())]))) (True,1,[0])3tst (AsMap (Data.Map.fromList [(3::Word,9::Word)]))(True,18,[129,132,128])flat Sequences are defined as Arrays:Array v = A0 | A1 v (Array v) | A2 v v (Array v) ... | A255 ... (Array v)In practice, this means that the sequence is encoded as a sequence of blocks of up to 255 elements, with every block preceded by the count of the elements in the block and a final 0-length block.Lists are defined as:'List a D Nil | Cons a (List a)In practice, this means that the list elements will be prefixed with a 1 bit and followed by a final 0 bit.The AsList/AsArray wrappers can be used to serialise sequences as Lists or Arrays.Let's see some examples."flatBits $ AsList [True,True,True] "1111110"So we have Cons True (11) repeated three times, followed by a final Nil (0).The list encoding is the default one for lists so AsList is in this case unnecessary:flatBits $ [True,True,True] "1111110";We can force a list to be encoded as an Array with AsArray:#flatBits $ AsArray [True,True,True]"00000011 11100000 000"We have the initial block with a count of 3 (3 == 00000011) followed by the elements True True True (111) and then the final block of 0 elements ("00000 000").%flatBits $ [AsArray [True,True,True]]"10000001 11110000 00000"6flatBits $ (True,True,True,AsArray $ replicate 7 True)"11100000 11111111 11000000 00"flatBits $ AsArray ([]::[()]) "00000000"flatBits $ AsList ([]::[()])"0"tst (AsList [11::Word8,22,33])(True,28,[133,197,164,32])1tst (AsSet (Data.Set.fromList [11::Word8,22,33]))(True,28,[133,197,164,32])$tst [AsArray [1..3], AsArray [4..8]]/(True,99,[129,129,2,3,0,65,66,2,131,3,132,0,0])/tst $ [AsArray [(1::Word8)..3], AsArray [4..8]]4(True,99,[129,128,129,1,128,65,65,1,65,129,194,0,0])tst $ [AsArray [(1::Int)..3]](True,42,[129,129,2,3,0,0])flat7Calculate size of an instance of IsSequence as the sum:of the size of all the elementsplus the size of the array constructors (1 byte every 255 elements plus one final byte)flat-Encode an instance of IsSequence, as an arrayflat-Decode an instance of IsSequence, as an arrayflatunflat @Word64 (flat @Natural $ fromIntegral @Word64 maxBound)Right 18446744073709551615unflat @Word64 (flat @Natural $ fromIntegral @Word64 maxBound + 1)Left (BadEncoding ...:unflat @Int16 (flat @Int32 $ fromIntegral @Int16 maxBound) Right 32767>unflat @Int16 (flat @Int32 $ fromIntegral @Int16 maxBound + 1)Left (BadEncoding ...:unflat @Int32 (flat @Int64 $ fromIntegral @Int32 maxBound)Right 2147483647>unflat @Int32 (flat @Int64 $ fromIntegral @Int32 maxBound + 1)Left (BadEncoding ...unflat @Int16 (flat @Int32 $ fromIntegral @Int16 minBound - 1)Left (BadEncoding ...:unflat @Int32 (flat @Int64 $ fromIntegral @Int32 minBound)Right (-2147483648)>unflat @Int32 (flat @Int64 $ fromIntegral @Int32 minBound - 1)Left (BadEncoding ... Alt (Just 24) in tst a == tst wTruelet w = Just (11::Word8); a = Alt Nothing <> Alt w in tst a == tst wTrueflat Safe-Inferred 5;oflat5tst (Node (1::Word8) [Node 2 [Node 3 []], Node 4 []])(True,39,[1,129,64,200,32])flatData.Set is encoded as a list'asList Data.Set.fromList [3::Word8,4,7]Trueflat'Data.Sequence.Seq is encoded as a list.,asList Data.Sequence.fromList [3::Word8,4,7]True)In flat <0.4, it was encoded as an Array.;If you want to restore the previous behaviour, use AsArray:8tst $ AsArray (Data.Sequence.fromList [11::Word8,22,33])(True,40,[3,11,22,33,0]).tst $ Data.Sequence.fromList [11::Word8,22,33](True,28,[133,197,164,32])flatMaps are encoded as lists:!tst (Data.Map.empty :: Map () ()) (True,1,[0])0asList Data.Map.fromList [("a","aa"),("b","bb")]True Key/Values are encoded in order:let l = [("a","aa"),("b","bb")] in tst (Data.Map.fromList l) == tst (Data.Map.fromList $ Prelude.reverse l)True+IntMap and Map are encoded in the same way:let l = [(2::Int,"b"),(1,"a")] in tst (Data.IntMap.fromList l) == tst (Data.Map.fromList l)Trueflat1Maps are defined as a list of (Key,Value) tuples: 7Map = List (Key,Value) List a = Nil | Cons a (List a) $tst (Data.IntMap.empty :: IntMap ()) (True,1,[0])-asList Data.IntMap.fromList [(1,"a"),(2,"b")]True Safe-InferredqflatFor better encoding/decoding performance, it is useful to declare instances of concrete list types, such as [Char]. tstBits "" (True,1,"0") tstBits "aaa"+(True,28,"10110000 11011000 01101100 0010") Safe-Inferredqflat&test (Data.DList.fromList [7::Word,7])!(True,19,"10000011 11000001 110")=let l = [7::Word,7] in flat (Data.DList.fromList l) == flat lTrue Safe-Inferredvflat,tst ((False,True,False,SBS.pack [11,22,33]))(True,51,[65,3,11,22,33,0])flat*tst ((False,True,False,L.pack [11,22,33]))(True,51,[65,3,11,22,33,0])flatByteString, ByteString.Lazy and ByteString.Short are all encoded as Prealigned Arrays: PreAligned a D PreAligned {preFiller :: Filler, preValue :: a} Filler D FillerBit Filler | FillerEnd Array v = A0 | A1 v (Array v) | A2 v v (Array v) ... | A255 ... (Array v) That's to say as a byte-aligned sequence of blocks of up to 255 elements, with every block preceded by the count of the elements in the block and a final 0-length block.tst (B.pack [11,22,33])(True,48,[1,3,11,22,33,0])where:1= PreAlignment (takes a byte if we are already on a byte boundary) 3= Number of bytes in ByteString11,22,33= Bytes0= End of Arraytst (B.pack [])(True,16,[1,0])Pre-alignment ensures that a ByteString always starts at a byte boundary:*tst ((False,True,False,B.pack [11,22,33]))(True,51,[65,3,11,22,33,0]),All ByteStrings are encoded in the same way:all (tst (B.pack [55]) ==) [tst (L.pack [55]),tst (SBS.pack [55])]True Safe-Inferredyflat?Array is encoded as (lowBound,highBound,AsArray (elems array)):let arr = A.array ((1::Word,4::Word),(2,5)) [((1,4),11::Word),((1,5),22),((2,4),33),((2,5),44)] in tst (bounds arr,AsArray(elems arr)) == tst arrTrueAs it's easy to see:tst $ A.array ((1::Word,4::Word),(2,5)) [((1,4),11::Word),((1,5),22),((2,4),33),((2,5),44)]#(True,80,[1,4,2,5,4,11,22,33,44,0])tst $ A.array ((1,4),(2,5)) [((1,4),"1.4"),((1,5),"1.5"),((2,4),"2.4"),((2,5),"2.5")](True,160,[2,8,4,10,4,152,203,166,137,140,186,106,153,75,166,137,148,186,106,0])6Arrays and Unboxed Arrays are encoded in the same way:let bounds = ((1::Word,4::Word),(2,5));elems=[11::Word,22,33,44] in tst (U.listArray bounds elems :: U.UArray (Word,Word) Word) == tst (A.listArray bounds elems)True# Safe-Inferredz Safe-Inferred;=}7 flat1A Pre aligned value, a value preceded by a fillerUseful to prealign ByteArrays, Texts and any structure that can be encoded more efficiently when byte aligned. flat2A Post aligned value, a value followed by a filler4Useful to complete the encoding of a top-level valueflatA meaningless sequence of 0 bits terminated with a 1 bit (easier to implement than the reverse)5Used to align encoded values at byte/word boundaries.flatLength of a filler in bitsflatPost align a valueflatPre align a valueflat+Decode a value assuming that is PostAlignedflat*Decode a value assuming that is PreAlignedflat%Use a special encoding for the filler Safe-Inferred~flatEncode padded value.flatDecode padded value.flat9Decode padded value, using the provided unpadded decoder.flatDecode unpadded value.flat-Unflat unpadded value, using provided decoderflatEncode unpadded value Safe-Inferred2kflatFlat representation of a valueRepr It is occasionally useful to keep a decoded value, or part of it, in its encoded binary representation and decode it later on demand.To do so, just decode a value a to a `Repr a`.For example, we encode a list of Ints and then decode it to a list of Repr Int:3unflat (flat [1::Int .. 5]) :: Decoded ([Repr Int])Right [Repr {repr = "\STX\SOH"},Repr {repr = "\EOT\SOH"},Repr {repr = "\ACK\SOH"},Repr {repr = "\b\SOH"},Repr {repr = "\n\SOH"}]To decode a `Repr a` to an a , we use :let Right l = unflat (flat [1..5]) :: Decoded [Repr Int] in unrepr (l !! 2)3>See "test/FlatRepr.hs" for a test and a longer example of use.SizeOfIf a decoded value is not required, it can be skipped completely using `SizeOf a`.For example, to ignore the second and fourth component of the following tuple, it can be decoded as:let v = flat ('a',"abc",'z',True) in unflat v :: Decoded (Char,SizeOf String,Char,SizeOf Bool)"Right ('a',SizeOf 28,'z',SizeOf 1)The unused values have not been decoded and instead their size (in bits) is returned.  Safe-InferredflatA sequence of bitsflatThe sequence of bits corresponding to the serialization of the passed value (without any final byte padding) bits True[True]flatThe sequence of bits corresponding to the byte-padded serialization of the passed valuepaddedBits True/[True,False,False,False,False,False,False,True]flat>Convert an integral value to its equivalent bit representationasBits (5::Word8)/[False,False,False,False,False,True,False,True]flat=Convert a sequence of bits to the corresponding list of bytes asBytes $ asBits (256+3::Word16)[1,3]flat?Convert to the corresponding value (most significant bit first)flat,Split a list in groups of 8 elements or lessflat#prettyShow $ asBits (256+3::Word16)"00000001 00000011"   Safe-InferredflatReturns: result of flat/unflat test, encoding size in bits, byte encodingflatReturns: result of flat/unflat test, encoding size in bits, bits encodingflat+Test that container is serialised as a Listflat$ Safe-Inferred[ !! %&'%&()*+%,-%./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUUVVWXYYZ[\]^_`abcdefghijkl m n o pqrstu v v w x y z { | } ~                                     V V   X  j$          %% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%V%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  !flat-0.5.2-5geljEgTSvW8bBFDsAMy3l Flat.Encoder Flat.Types Flat.MemoryData.FloatCastFlat.Instances.TestData.ByteString.Convert Data.ZigZagFlat.Decoder.Types Flat.EndianFlat.Decoder.PrimFlat.Decoder.StrictFlat.Decoder.RunFlat.Encoder.TypesFlat.Encoder.PrimFlat.Encoder.SizeFlat.Encoder.Strict Flat.ClassFlat.Instances.UtilFlat.Instances.TextFlat.Instances.MonoFlat.Instances.VectorFlat.Instances.UnorderedFlat.Instances.BaseFlat.Instances.ContainersFlat.Instances.ExtraFlat.Instances.DListFlat.Instances.ByteStringFlat.Instances.Array Flat.FillerFlat.Run Flat.Repr Flat.Bits Flat.Decoder Flat.TutorialFlat.InstancesFlatbaseGHC.Base<>mempty ghc-bignumGHC.Num.NaturalNaturalGHC.PtrminusPtrGHC.STrunSTbytestring-0.11.3.1Data.ByteString.Short.InternalShortByteString text-1.2.5.0Data.Text.InternalTextpretty-1.1.3.6Text.PrettyPrint.HughesPJClass prettyShow'primitive-0.7.4.0-5Mou7sRsTgfjuEOfjOZOzData.Primitive.ByteArray ByteArray AsByteString toByteStringfromByteString$fAsByteString[]$fAsByteStringByteString$fAsByteStringByteString0 wordToFloat floatToWord doubleToWord wordToDoublecastZigZagzigZagzagZig$fZigZagIntegerNatural$fZigZagInt64Word64$fZigZagInt32Word32$fZigZagInt16Word16$fZigZagInt8Word8DecodeExceptionNotEnoughSpace TooMuchSpace BadEncodingBadOpDecoded GetResultScurrPtrusedBitsGetrunGetnotEnoughSpace tooMuchSpace badEncodingbadOp$fMonadFailGet $fMonadGet$fApplicativeGet $fShowGet $fNFDataGet $fFunctorGet$fExceptionDecodeException$fShowDecodeException$fEqDecodeException$fOrdDecodeException$fFunctorGetResult$fShowS$fEqS$fOrdS isBigEndiantoBE64toBE32toBE16unsafeCreateUptoN'pokeByteString pokeByteArraychunksToByteStringchunksToByteArray ConsStateconsOpen consCloseconsBoolconsBitsdropBitsdBooldBEBits8 dBEBits16 dBEBits32 dBEBits64dWord8dBE8dBE16dBE32dBE64dFloatdDoubledLazyByteString_ dByteString_ dByteArray_ getChunksInfodecodeListWithdecodeArrayWithdNaturaldIntegerdWorddIntdInt8dInt16dInt32dInt64dWord16dWord32dWord64dChardUTF16dUTF8dLazyByteStringdShortByteStringdShortByteString_ dByteString strictDecoder listTDecoderNumBitsPrimnextPtrcurrByteSizeeFloatFeDoubleF eWord64BEF eWord32BEFeCharFeWordFeIntFeInt8FeInt16FeInt32FeInt64F eIntegerF eNaturalFw7leWord8FeWord32EeWord64EeWord16FeWord32FeWord64FvarWordFeUTF8FeUTF16F eLazyBytesF eShortBytesFeBytesFeBits16FeBitsFeBoolFeTrueFeFalseFeFillerF updateWord8 sFillerMaxsBoolsWord8sInt8sFloatsDoublesCharsCharMaxsWordsIntsInt16sInt32sInt64sWord16sWord32sWord64sIntegersNatural sIntegralsUTF8Max sUTF16MaxsBytes sLazyBytes sShortBytes bitsToBytesnumBlks arrayBits arrayChunksblobBits blkBitsBSblksBitsEncodingrun strictEncodernumEncodedBitsstrictEncoderPartialencodingAppend encodersS sizeListWithencodeListWithencodeArrayWitheChareUTF16eUTF8eBytes eLazyBytes eShortByteseNaturaleFloateDoubleeIntegereInt64eInt32eInt16eInt8eInteWord64eWord32eWord16eWord8eWordeBits16eBitseFillereBooleTrueeFalsevsizecsizesUTF16$fMonoidEncoding$fSemigroupEncoding$fShowEncoding GFlatSize GFlatDecode GFlatEncodeSizeOfencodedecodesizegetSize$fGFlatEncode:*:$fGFlatEncodeU1$fGFlatEncodeV1$fGFlatEncodeM1$fGFlatEncodeM10$fGFlatEncodeSumM1$fGFlatEncodeSum:+:$fGFlatDecode:+:$fGFlatDecode:*:$fGFlatDecodeU1$fGFlatDecodeV1$fGFlatDecodeM1$fGFlatDecodeSumM1$fGFlatDecodeSum:+:$fGFlatDecodeSum:+:0$fGFlatDecodeSum:+:1$fGFlatSize:*: $fGFlatSizeU1 $fGFlatSizeV1 $fGFlatSizeM1 $fGFlatSizeK1$fGFlatDecodeK1$fGFlatEncodeK1 $fFlatSizeOf$fGFlatSizeSumM1$fGFlatSizeSum:+:$fGFlatSize:+:$fGFlatDecode:+:0$fGFlatEncode:+: $fShowSizeOf encodeArray UTF16TextunUTF16UTF8TextunUTF8 $fFlatText $fFlatText0$fFlatUTF8Text$fFlatUTF16Text $fEqUTF16Text$fOrdUTF16Text$fShowUTF16Text $fEqUTF8Text $fOrdUTF8Text$fShowUTF8TextAsMapunMapAsSetunSetAsListunListAsArrayunArray sizeSequenceencodeSequencedecodeSequencesizeList encodeList decodeListsizeSet encodeSet decodeSetsizeMap encodeMap decodeMap $fFlatAsArray $fFlatAsList $fFlatAsSet $fFlatAsMap $fShowAsMap $fEqAsMap $fOrdAsMap $fShowAsSet $fEqAsSet $fOrdAsSet $fShowAsList $fEqAsList $fOrdAsList $fShowAsArray $fEqAsArray $fOrdAsArray $fFlatVector $fFlatVector0 $fFlatVector1 $fFlatHashMap $fFlatHashSet$fFlat(,,,,,,) $fFlat(,,,,,) $fFlat(,,,,) $fFlat(,,,) $fFlat(,,) $fFlat(,)$fFlatNonEmpty$fFlat[] $fFlatRatio $fFlatComplex $fFlatDouble $fFlatFloat $fFlatInt64 $fFlatInt32 $fFlatInt16 $fFlatInt8 $fFlatInteger $fFlatInt $fFlatWord64 $fFlatWord32 $fFlatWord16 $fFlatNatural $fFlatWord $fFlatWord8 $fFlatFixed $fFlatEither $fFlatMaybe $fFlatChar $fFlatBool$fFlat() $fFlatLast $fFlatFirst $fFlatMax $fFlatMin $fFlatProduct $fFlatSum $fFlatAny $fFlatDual$fFlatIdentity $fFlatAlt $fFlatAll $fFlatTree $fFlatSet $fFlatSeq $fFlatMap $fFlatIntMap $fFlatDList$fFlatShortByteString$fFlatByteString$fFlatByteString0 $fFlatUArray $fFlatArray PreAligned preFillerpreValue PostAligned postValue postFillerFiller FillerBit FillerEnd fillerLength postAligned preAlignedpostAlignedDecoderpreAlignedDecoder $fFlatFiller$fShowPreAligned$fEqPreAligned$fOrdPreAligned$fGenericPreAligned$fNFDataPreAligned$fFlatPreAligned$fShowPostAligned$fEqPostAligned$fOrdPostAligned$fGenericPostAligned$fNFDataPostAligned$fFlatPostAligned $fShowFiller $fEqFiller $fOrdFiller$fGenericFiller$fNFDataFillerflatunflat unflatWith unflatRaw unflatRawWithflatRawReprreprunrepr $fFlatRepr $fShowReprBitstoBools fromBoolsbits paddedBits takeAllBitstakeBitsasBitsasBytes$fPrettyVectortsttstBitsasListflatBitsallBitsencBitsGHC.WordWord32ghc-prim GHC.TypesFloatDoubleWord64copyByteArrayToAddrcopyAddrToByteArray ensureBitsIntGHC.IntInt8Int16Int32Int64WordWord8Word16 byteSwap64 byteSwap32 byteSwap16 bitReverse8 bitReverse64 bitReverse32 bitReverse16 eIntegralWpokeWordGHC.Bits unsafeShiftR unsafeShiftLNumConstructors GFlatSizeSumGFlatDecodeSumskip GHC.GenericsGenerictoRepfromGeneric1to1Rep1from1Datatype packageName moduleName datatypeName isNewtype ConstructorconName conFixity conIsRecordSelectorselSourceUnpackednessselSourceStrictnessselDecidedStrictnessselNameV1U1Par1unPar1Rec1unRec1K1unK1M1unM1:+:L1R1:*::.:Comp1unComp1RDCRec0D1C1S1URecuWord#uInt#uFloat#uDouble#uChar#uAddr#UWordUIntUFloatUDoubleUAddrUCharSourceUnpackednessNoSourceUnpackedness SourceUnpackSourceNoUnpackSourceStrictnessNoSourceStrictness SourceLazy SourceStrictMetaMetaSelMetaDataMetaConsFixityIPrefixIInfixIFixityInfixPrefixDecidedStrictness DecidedUnpack DecidedLazy DecidedStrict AssociativityNotAssociativeLeftAssociativeRightAssociativeprecbyteValbytes