h&R      !"#$%&'()*+,-./0123456789:;<= > ? @ ABCDEFG 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 vw x y z { | } ~      !!!!!!% Safe-Inferred % flat"Convert to/from strict ByteStrings   Trustworthy |flatReinterpret-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-InferredBflat5Copy bytestring to given pointer, returns new pointerCflat?Create a new bytestring, copying sourceLen bytes from sourcePtrDflat4Copy ByteArray to given pointer, returns new pointerflatWrapper around copyByteArrayToAddr# primop."Copied from the store-core packageflatWrapper around copyAddrToByteArray# primop."Copied from the store-core packageCflat sourcePtrflat sourceLenABCDEFEFDBAC  Safe-Inferred!Gflat4A 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).Iflat8Switch to constructor decoding {-# INLINE consOpen #-}Jflat;Switch back to normal decoding {-# NOINLINE consClose #-}KflatDecode a single bitLflatDecode 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 availableMflat!Drop the specified number of bitsNflatDecode a booleanOflat7Return 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")Pflat8Return 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 11111111QflatReturn the n most significant bits (up to maximum of 32) The bits are returned right shifted.RflatReturn the n most significant bits (up to maximum of 64) The bits are returned right shifted.Sflat1Return the 8 most significant bits (same as dBE8)Tflat"Return the 8 most significant bitsUflat#Return the 16 most significant bitsVflat#Return the 32 most significant bitsWflat#Return the 64 most significant bitsXflatDecode a FloatYflatDecode a DoubleZflatDecode a Lazy ByteString[flatDecode 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 sizes^flatGiven a value's decoder, returns the size in bits of the encoded value_flat:Given a value's decoder, returns the value's bit encoding.The encoding starts at the returned bit position in the return bytestring's first byte and ends in an unspecified bit position in its final byteGHIJKLMNOPQRSTUVWXYZ[\]^_NSTUVWOPQRMXY][Z\GHIJKL^_  Safe-Inferred!S`abcdefghijklmnopqrsa`spqrnocbmSjkldfghie  Safe-Inferred#tflatGiven a decoder and an input buffer returns either the decoded value or an error (if the input buffer is not fully consumed)uflat-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.See  ../test/Big.hs" for a test and an example of use. See also  Flat.AsBin.tutu" Safe-Inferred#0 !(GHIJKLMNOPQRSTUVWXY`abcdefghijklmnopqrstu0tu! (spqrnoa`XYcbmNSjkldfghieTUVWOPQRMGHIJKL# Safe-Inferred$i Safe-Inferred$vflatNumber of bitsvv  Safe-Inferred%wflatA basic encoderxflatStrict encoder state}flatAdd the maximum size in bits of the encoding of value a to a NumBitsvwxy|z{}}vwxy|z{ 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+w 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.<v}<v} Trustworthy1<5_flat 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 Encoderflat*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$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(6w !(GHIJKLMNOPQRSTUVWXY`abcdefghijklmnopqrstuv} 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-InferredFflat.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"Sets are saved as lists of values.tstBits $ AsSet (Data.Set.fromList ([False,True,False]::[Bool]))(True,5,"10110")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;qflat5tst (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-InferredrflatFor 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-Inferredsflat&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-Inferredxgflat,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-Inferred{flat?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-Inferred{ Safe-Inferred;= 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-InferredyflatEncode 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-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-Inferred2flatWhen the flat serialisation of a value takes a lot less memory than the value itself, it can be convenient to keep the value in its encoded representation and decode it on demand.To do so, just decode a value a as a `AsBin a`. Examples:Encode a list of Ints and then decode it to a list of AsBin Int:4unflat (flat [1::Int .. 3]) :: Decoded ([AsBin Int])Right [AsBin {repr = "\129A", offsetBits = 1},AsBin {repr = "A ", offsetBits = 2},AsBin {repr = " \193", offsetBits = 3}]To decode an `AsBin a` to an a, use :5unbin <$> (unflat (flat 'a') :: Decoded (AsBin Char)) Right 'a'Keep the values of a list of Ints encoded and decode just one on demand:let Right l :: Decoded [AsBin Int] = unflat (flat [1..5]) in unbin (l !! 2)3$Show exactly how values are encoded:let Right t :: Decoded (AsBin Bool,AsBin Word8,AsBin Bool) = unflat (flat (False,3:: Word64,True)) in prettyShow t"(0, _0000001 1, _1)"(Ten bits in total spread over two bytes: '0 _0000001 1 _1 = 00000001 11 Tests:&unflat (flat ()) :: Decoded (AsBin ()))Right (AsBin {repr = "", offsetBits = 0})7unflat (flat (False,True)) :: Decoded (Bool,AsBin Bool)0Right (False,AsBin {repr = "A", offsetBits = 1})unflat (flat (False,False,255 :: Word8)) :: Decoded (Bool,Bool,AsBin Word8):Right (False,False,AsBin {repr = "?\193", offsetBits = 2})let Right (b0,b1,rw,b3) :: Decoded (Bool,Bool,AsBin Word8,Bool) = unflat (flat (False,False,255 :: Word8,True)) in (b0,b1,unbin rw,b3)(False,False,255,True)flatFlat encoding of the value (encoding starts after offset bits in the first byte and ends in an unspecified position in the last byte)flatFirst byte offset: number of unused most significant bits in the first byteflatDecode a value! Safe-Inferred2kflat>Useful to skip unnecessary values and to check encoding sizes. Examples:2Ignore the second and fourth component of a tuple:let v = flat ('a',"abc",'z',True) in unflat v :: Decoded (Char,AsSize String,Char,AsSize Bool)"Right ('a',AsSize 28,'z',AsSize 1)+Notice the variable size encoding of Words:unflat (flat (1::Word16,1::Word64)) :: Decoded (AsSize Word16,AsSize Word64)Right (AsSize 8,AsSize 8)Text:unflat (flat (T.pack "",T.pack "a",T.pack "",UTF8Text $ T.pack "",UTF16Text $ T.pack "",UTF16Text $ T.pack "a")) :: Decoded (AsSize T.Text,AsSize T.Text,AsSize T.Text,AsSize UTF8Text,AsSize UTF16Text,AsSize UTF16Text)Right (AsSize 16,AsSize 32,AsSize 48,AsSize 48,AsSize 40,AsSize 40)Various encodings:unflat (flat (False,[T.pack "",T.pack "a",T.pack ""],'a')) :: Decoded (AsSize Bool,AsSize [T.Text],AsSize Char)#Right (AsSize 1,AsSize 96,AsSize 8)% Safe-Inferred !! &'(&')*+,&-.&/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVVWWXYZZ[\]^_`abcdefghijklm n o p qrstuvw x x y z { | } ~                                         W W   Y  k%     !!!!!!&& &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&W&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&  flat-0.6-CjdmNH3KA6VH8k7cYdCbFX 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.Bits Flat.AsBin Flat.AsSize 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'pokeByteStringpeekByteString pokeByteArraychunksToByteStringchunksToByteArray ConsStateconsOpen consCloseconsBoolconsBitsdropBitsdBooldBEBits8 dBEBits16 dBEBits32 dBEBits64dWord8dBE8dBE16dBE32dBE64dFloatdDoubledLazyByteString_ dByteString_ dByteArray_ getChunksInfosizeOfbinOfdecodeListWithdecodeArrayWithdNaturaldIntegerdWorddIntdInt8dInt16dInt32dInt64dWord16dWord32dWord64dChardUTF16dUTF8dLazyByteStringdShortByteStringdShortByteString_ 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 GFlatEncodeencodedecodesizegetSize$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$fGFlatSizeSumM1$fGFlatSizeSum:+:$fGFlatSize:+:$fGFlatDecode:+:0$fGFlatEncode:+: 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 unflatRawWithunflatRawWithOffsetflatRawBitstoBools fromBoolsbits paddedBits takeAllBitstakeBitsasBitsasBytes$fPrettyVectortsttstBitsasListflatBitsallBitsencBitsAsBinunbin $fFlatAsBin $fPrettyAsBin $fShowAsBinAsSize $fFlatAsSize $fEqAsSize $fOrdAsSize $fShowAsSizeGHC.WordWord32ghc-prim GHC.TypesFloatDoubleWord64copyByteArrayToAddrcopyAddrToByteArray ensureBitsIntGHC.IntInt8Int16Int32Int64WordWord8Word16 byteSwap64 byteSwap32 byteSwap16 bitReverse8 bitReverse64 bitReverse32 bitReverse16 eIntegralWpokeWordGHC.Bits unsafeShiftR unsafeShiftLNumConstructors GFlatSizeSumGFlatDecodeSum GHC.GenericsGenerictoRepfromGeneric1to1Rep1from1Datatype packageName moduleName datatypeName isNewtype ConstructorconName conFixity conIsRecordSelectorselSourceUnpackednessselSourceStrictnessselDecidedStrictnessselNameV1U1Par1unPar1Rec1unRec1K1unK1M1unM1:+:L1R1:*::.:Comp1unComp1RDCRec0D1C1S1URecuWord#uInt#uFloat#uDouble#uChar#uAddr#UWordUIntUFloatUDoubleUAddrUCharSourceUnpackednessNoSourceUnpackedness SourceUnpackSourceNoUnpackSourceStrictnessNoSourceStrictness SourceLazy SourceStrictMetaMetaSelMetaDataMetaConsFixityIPrefixIInfixIFixityInfixPrefixDecidedStrictness DecidedUnpack DecidedLazy DecidedStrict AssociativityNotAssociativeLeftAssociativeRightAssociativeprecbyteValbytesrepr offsetBits