u       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ (c) Duncan Coutts 2015-2017BSD3-style (see LICENSE.txt)duncan@community.haskell.org experimentalnon-portable (GHC extensions)Safe(c) Duncan Coutts 2015-2017BSD3-style (see LICENSE.txt)duncan@community.haskell.org experimentalnon-portable (GHC extensions)NoneDQV=-GThe type of a token, which a decoder can ask for at an arbitrary time.lAn action, representing a step for a decoder to taken and a continuation to invoke with the expected value.:_A continuation-based decoder, used for decoding values that were previously encoded using the Codec.CBOR.Encoding module. As : has a  ! instance, you can easily write :7s monadically for building your deserialisation logic.<Given a :, give us the = Decode a  .> Decode a  .? Decode a  .@ Decode a  .A Decode a .BDecode a negative  .CDecode a negative .D Decode an .E Decode an .F Decode an .G Decode an .H Decode an .I Decode an .J Decode a .K Decode a .LDecode a string of bytes as a .MKDecode a token marking the beginning of an indefinite length set of bytes.N&Decode a textual string as a piece of .OEDecode a token marking the beginning of an indefinite length string.PDecode the length of a list.QEDecode a token marking the beginning of a list of indefinite length.RDecode the length of a map.SDDecode a token marking the beginning of a map of indefinite length.T+Decode an arbitrary tag and return it as a  .U2Decode an arbitrary 64-bit tag and return it as a .VDecode a bool.W0Decode a nullary value, and return a unit value.X Decode a simple CBOR value and give back a  ,. You probably don't ever need to use this.YAttempt to decode a word with =7, and ensure the word is exactly as expected, or fail.Z&Attempt to decode a list length using P:, and ensure it is exactly the specified length, or fail.[]Attempt to decode a token for the length of a finite, known list, or an indefinite list. If D is returned, then an indefinite length list occurs afterwords. If  x% is returned, then a list of length x is encoded.\[Attempt to decode a token for the length of a finite, known map, or an indefinite map. If C is returned, then an indefinite length map occurs afterwords. If  x$ is returned, then a map of length x is encoded.]Attempt to decode a Break, token, and if that was successful, return .. If the token was of any other type, return .^?Peek at the current token we're about to decode, and return a  specifying what it is._TPeek and return the length of the current buffer that we're running our decoder on.`%Decode an indefinite sequence length.aDecode a sequence length.bcdeY"Expected value of the decoded wordb 89 !"#$%&'()*+,-./01234567:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab: !"#$%&'()*+,-./0123456789;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_ `a  !"#$%&'()*+,-./0123456789:(c) Duncan Coutts 2015-2017BSD3-style (see LICENSE.txt)duncan@community.haskell.org experimentalnon-portable (GHC extensions)SafepU!kA flattened representation of a term, which is independent of any underlying binary representation, but which we later serialise into CBOR format.l@An intermediate form used during serialisation, specified as a K. It supports efficient concatenation, and is equivalent to a specialised    k type.It is used for the stage in serialisation where we flatten out the Haskell data structure but it is independent of any specific external binary or text format.&Traditionally, to build any arbitrary lc value, you specify larger structures from smaller ones and append the small ones together using  . Encode a   in a flattened format. Encode a   in a flattened format. Encode a   in a flattened format. Encode a   in a flattened format. Encode a  in a flattened format. Encode an  in a flattened format. Encode an  in a flattened format. Encode an  in a flattened format. Encode an  in a flattened format. Encode an @ in a flattened format.Encode an arbitrarily large @ in a flattened format.Encode an arbitrary strict  in a flattened format.Encode a token specifying the beginning of a string of bytes of indefinite length. In reality, this specifies a stream of many occurrences of , each specifying a single chunk of the overall string. After all the bytes desired have been encoded, you should follow it with a break token (see ). Encode a  in a flattened format.-Encode the beginning of an indefinite string.cEncode the length of a list, used to indicate that the following tokens represent the list values.Encode a token specifying that this is the beginning of an indefinite list of unknown size. Tokens representing the list are expected afterwords, followed by a break token (see ) when the list has ended.aEncode the length of a Map, used to indicate that the following tokens represent the map values.Encode a token specifying that this is the beginning of an indefinite map of unknown size. Tokens representing the map are expected afterwords, followed by a break token (see ) when the map has ended.[Encode a 'break', used to specify the end of indefinite length objects like maps or lists.Encode an arbitrary   tag.Encode an arbitrary 64-bit  tag. Encode a  . Encode an Undef value. Encode a Null value.lEncode a 'simple' CBOR token that can be represented with an 8-bit word. You probably don't ever need this.Encode a small 16-bit  in a flattened format.Encode a full precision  in a flattened format. Encode a  in a flattened format.8kqrstuvwxyz{|}~lm8lmkqrstuvwxyz{|}~kqrstuvwxyz{|}~lm(c) Duncan Coutts 2015-2017BSD3-style (see LICENSE.txt)duncan@community.haskell.org experimentalnon-portable (GHC extensions)NoneDQV nA concrete encoding of l) values, one which mirrors the original l type closely.oA "flat" representation of an l5 value, useful for round-tripping and writing tests.pConvert an arbitrary l into a o.!FA data type used for tracking the position we're at as we traverse a o and make sure it's valid.Given a : , decode a o2 back into an ordinary value, or return an error."Map a n to the underlying CBOR  Ensure a o= is internally consistent and was created in a valid manner.#Validate an arbitrary o at an arbitrary location.$ Do a careful check to ensure an  is in the range of a  .p The input l.The resulting o.A : for a serialised value.The serialised o.$The deserialised value, or an error. The input o if valid,  otherwise.noponpn! %&'()*+,-./(c) Duncan Coutts 2015-2017BSD3-style (see LICENSE.txt)duncan@community.haskell.org experimentalnon-portable (GHC extensions)NoneDV1;An efficient, mutable counter. Designed to be used inside 0A or other primitive monads, hence it carries an abstract rank-2 s type parameter. Grab a 8-bit   given a 1 to some address.Grab a 16-bit   given a 1 to some address.Grab a 32-bit   given a 1 to some address.Grab a 64-bit  given a 1 to some address.Take the tail of a ^ (i.e. drop the first byte) and read the resulting byte(s) as an 8-bit word value. The input X MUST be at least 2 bytes long: one byte to drop from the front, and one to read as a  [ value. This is not checked, and failure to ensure this will result in undefined behavior.Take the tail of a ^ (i.e. drop the first byte) and read the resulting byte(s) as a 16-bit word value. The input _ MUST be at least 3 bytes long: one byte to drop from the front, and two to read as a 16-bit  [ value. This is not checked, and failure to ensure this will result in undefined behavior.Take the tail of a ^ (i.e. drop the first byte) and read the resulting byte(s) as a 32-bit word value. The input ` MUST be at least 5 bytes long: one byte to drop from the front, and four to read as a 32-bit  [ value. This is not checked, and failure to ensure this will result in undefined behavior.Take the tail of a ^ (i.e. drop the first byte) and read the resulting byte(s) as a 64-bit word value. The input a MUST be at least 9 bytes long: one byte to drop from the front, and eight to read as a 64-bit [ value. This is not checked, and failure to ensure this will result in undefined behavior.2Unsafely take a 1 to a  and do unholy things with it. Convert a   to a half-sized .Convert a half-sized  to a  .Cast a   to a .Cast a  to a .3)Cast an unboxed word to an unboxed float.4*Cast an unboxed word to an unboxed double.Create a negative  out of a raw . Create an  out of a raw .%Create a new counter with a starting  value.Read the current value of a .Write a new value into the . Increment a  by one. Decrement a  by one.Copy a  and create a primitive 5 from it.Copy a 5( at a certain offset and length into a .6Copy the data pointed to by a 1 into a @7.8Copy a 5 into a 1 with a given offset and length.5 to copy from.Offset into the 5 to start with.Length of the data to copy.61 to buffer to copy from.7 to copy into.Offset to start copying from.Length of the data to copy.85 to copy.Offset into the 5 of where to start copying.Pointer to destination buffer.7Length of the data to copy into the destination buffer.9(c) Duncan Coutts 2015-2017BSD3-style (see LICENSE.txt)duncan@community.haskell.org experimentalnon-portable (GHC extensions)None1DQVeSimple alias for &, used to make types more descriptive.An Incremental decoder, used to represent the result of attempting to run a decoder over a given input, and return a value of type a.RThe decoder has consumed the available input and needs more to continue. Provide ! if more input is available and # otherwise, and you will get a new .The decoder has successfully finished. Except for the output value you also get any unused input as well as the number of bytes consumed.8The decoder ran into an error. The decoder either used :h or was not provided enough input. Contains any unconsumed input, the number of bytes consumed, and a ; exception describing the reason why the failure occurred.}An exception type that may be returned (by pure functions) or thrown (by IO actions) that fail to deserialise a given input.Given a : and some ;- representing an encoded CBOR value, return <k the decoded CBOR value or an error. In addition to the decoded value return any remaining input content.Run a :\ incrementally, returning a continuation representing the result of the incremental decode. =>?@ABCDEFGHIJKLMNOPQ(c) Duncan Coutts 2015-2017BSD3-style (see LICENSE.txt)duncan@community.haskell.org experimentalnon-portable (GHC extensions)NoneA general CBOR term, which can be used to serialise or deserialise arbitrary CBOR terms for interoperability or debugging. This type is essentially a direct reflection of the CBOR abstract syntax tree as a Haskell data type.The  type also comes with a  Serialise" instance, so you can easily use decode :: : X to directly decode any arbitrary CBOR value into Haskell with ease, and likewise with encode.Encode an arbitrary  into an l for later serialization.(Decode some arbitrary CBOR value into a .(c) Duncan Coutts 2015-2017BSD3-style (see LICENSE.txt)duncan@community.haskell.org experimentalnon-portable (GHC extensions)None3DQVלTurn an l into a lazy ; in CBOR binary format.Turn an l into a strict  in CBOR binary format.Turn an l into a ; R in CBOR binary format.The l of a CBOR value.The encoded CBOR value.The l of a CBOR value.The encoded value.The l of a CBOR value.The encoded value as a R.(c) Duncan Coutts 2015-2017BSD3-style (see LICENSE.txt)duncan@community.haskell.org experimentalnon-portable (GHC extensions)None03DQVPretty prints an l in an annotated, hexadecimal format that maps CBOR values to their types. The output format is similar to the format used on  http://cbor.me/.For example, with the term: S .  .  " $ ( True , [1,2,3::Int] , (L [("Hello",True),("World",False)], "This is a long string which wraps") ) You get:  83 # list(3) f5 # bool(true) 9f # list(*) 01 # int(1) 02 # int(2) 03 # int(3) ff # break 82 # list(2) a2 # map(2) 65 48 65 6c 6c 6f # text("Hello") f5 # bool(true) 65 57 6f 72 6c 64 # text("World") f4 # bool(false) 78 21 54 68 69 73 20 69 73 20 61 20 6c 6f 6e 67 20 73 74 72 69 6e 67 20 77 68 69 63 68 20 77 72 61 70 73 # text("This is a long string which wraps") TUV !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{||}~IH         !"J#$%&'()*+,-./0123456789:;<=>?<=@ABCDEFFGHIJKLMNNOPQRSTUVVWXYZ[\\]$cborg-0.1.1.0-JvhGqtyhexbDusJs7bnjWqCodec.CBOR.DecodingCodec.CBOR.EncodingCodec.CBOR.FlatTermCodec.CBOR.MagicCodec.CBOR.ReadCodec.CBOR.TermCodec.CBOR.WriteCodec.CBOR.Pretty Codec.CBOR Data.MonoidEndomconcatencodeData.MapfromList TokenTypeTypeUInt TypeUInt64TypeNInt TypeNInt64 TypeInteger TypeFloat16 TypeFloat32 TypeFloat64 TypeBytesTypeBytesIndef TypeStringTypeStringIndef TypeListLen TypeListLen64TypeListLenIndef TypeMapLen TypeMapLen64TypeMapLenIndefTypeTag TypeTag64TypeBoolTypeNull TypeSimple TypeBreak TypeInvalid DecodeAction ConsumeWord ConsumeWord8 ConsumeWord16 ConsumeWord32ConsumeNegWord ConsumeInt ConsumeInt8 ConsumeInt16 ConsumeInt32ConsumeListLen ConsumeMapLen ConsumeTagConsumeInteger ConsumeFloat ConsumeDouble ConsumeBytes ConsumeString ConsumeBool ConsumeSimpleConsumeBytesIndefConsumeStringIndefConsumeListLenIndefConsumeMapLenIndef ConsumeNullConsumeListLenOrIndefConsumeMapLenOrIndefConsumeBreakOr PeekTokenType PeekAvailableFailDoneDecoderliftSTgetDecodeAction decodeWord decodeWord8 decodeWord16 decodeWord32 decodeWord64 decodeNegWorddecodeNegWord64 decodeInt decodeInt8 decodeInt16 decodeInt32 decodeInt64 decodeInteger decodeFloat decodeDouble decodeBytesdecodeBytesIndef decodeStringdecodeStringIndef decodeListLendecodeListLenIndef decodeMapLendecodeMapLenIndef decodeTag decodeTag64 decodeBool decodeNull decodeSimple decodeWordOfdecodeListLenOfdecodeListLenOrIndefdecodeMapLenOrIndef decodeBreakOr peekTokenType peekAvailabledecodeSequenceLenIndefdecodeSequenceLenN$fMonadFailDecoder$fMonadDecoder$fApplicativeDecoder$fFunctorDecoder $fEqTokenType$fOrdTokenType$fEnumTokenType$fBoundedTokenType$fShowTokenTypeTokensEncoding TermTokenFlatTerm toFlatTermTkWordTkWord64TkIntTkInt64TkBytes TkBytesBeginTkString TkStringBegin TkListLen TkListBeginTkMapLen TkMapBeginTkTagTkTag64 TkIntegerTkNullTkUndefTkBoolTkSimple TkFloat16 TkFloat32 TkFloat64TkBreakTkEnd encodeWord encodeWord8 encodeWord16 encodeWord32 encodeWord64 encodeInt encodeInt8 encodeInt16 encodeInt32 encodeInt64 encodeInteger encodeBytesencodeBytesIndef encodeStringencodeStringIndef encodeListLenencodeListLenIndef encodeMapLenencodeMapLenIndef encodeBreak encodeTag encodeTag64 encodeBool encodeUndef encodeNull encodeSimple encodeFloat16 encodeFloat encodeDouble$fMonoidEncoding$fSemigroupEncoding$fShowEncoding $fShowTokens $fEqTokens fromFlatTerm validFlatTerm $fEqTermToken$fOrdTermToken$fShowTermToken $fShowLocCounter grabWord8 grabWord16 grabWord32 grabWord64 eatTailWord8 eatTailWord16 eatTailWord32 eatTailWord64 wordToFloat16 floatToWord16 wordToFloat32 wordToFloat64nintegerFromBytesuintegerFromBytes newCounter readCounter writeCounter incCounter decCountercopyByteStringToByteArraycopyByteArrayToByteString ByteOffsetIDecodePartialDeserialiseFailuredeserialiseFromBytesdeserialiseIncremental$fExceptionDeserialiseFailure$fMonadIncrementalDecoder$fApplicativeIncrementalDecoder$fFunctorIncrementalDecoder$fShowDeserialiseFailure$fShowDecodedToken$fShowLongTokenTermTIntTIntegerTBytesTBytesITStringTStringITListTListITMapTMapITTaggedTBoolTNullTSimpleTHalfTFloatTDouble encodeTerm decodeTerm$fEqTerm $fOrdTerm $fShowTerm $fReadTermtoLazyByteStringtoStrictByteString toBuilder prettyHexEnc $fMonadFailPP $fMonadPP$fApplicativePP $fFunctorPPbaseGHC.BaseMonadghc-prim GHC.TypesWordGHC.WordWord8Word16Word32Word64IntGHC.IntInt8Int16Int32Int64 integer-gmpGHC.Integer.TypeIntegerFloatDoublebytestring-0.10.8.2Data.ByteString.Internal ByteString#text-1.2.2.2-EGUst8sqNAZCw1xLPcmcMHData.Text.InternalTextNothingJustTrueFalse runDecoderMonoidBoolLoc tokenTypeOf validateTermintIsValidWord32TopLevelSingleTopLevelSequenceInStringInBytesInListNInList InMapNKey InMapNValInMapKeyInMapValInTaggedGHC.STSTGHC.PtrPtr withBsPtrwordToFloat32#wordToFloat64#'primitive-0.6.2.0-V0ibjLQDdN6fcQS5bjLVgData.Primitive.ByteArray ByteArraycopyPtrToMutableByteArrayMutableByteArraycopyByteArrayToPtrfailData.ByteString.Lazy.Internal Data.EitherEither BigIntTokenBigUIntNeedBodyBigNIntNeedBodyBigUIntNeedHeaderBigNIntNeedHeader LongTokenFitsTooLong DecodedToken DecodeFailureSlowPathFastDoneSlowConsumeTokenStringSlowConsumeTokenBytesSlowDecodeActionSlowFailIncrementalDecoderunIncrementalDecoder Data.ByteString.Builder.InternalBuilder System.IOputStrLnPP