N0X      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~               ! " # $ % & ' ( ) * + , - . /0123456789:;<=>?@ABCDEFG H I J K L M N O P Q R S T U V W (c) Duncan Coutts 2015-2017BSD3-style (see LICENSE.txt)duncan@community.haskell.org experimentalnon-portable (GHC extensions)NoneBT;An efficient, mutable counter. Designed to be used inside XA or other primitive monads, hence it carries an abstract rank-2 s type parameter. Grab a 8-bit Y given a Z to some address.Grab a 16-bit Y given a Z to some address.Grab a 32-bit Y given a Z to some address.Grab a 64-bit [ given a Z 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 Y[ 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 Y[ 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 Y[ 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.]Unsafely take a Z to a \ and do unholy things with it.  Convert a Y to a half-sized ^. Convert a half-sized ^ to a Y. Cast a Y to a ^. Cast a [ to a ^._)Cast an unboxed word to an unboxed float.`*Cast an unboxed word to an unboxed double. Create a negative a out of a raw \. Create an a out of a raw \.%Create a new counter with a starting b 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 c from it.Copy a c( at a certain offset and length into a \.dCopy the data pointed to by a Z into a @e.fCopy a c into a Z with a given offset and length.g] _` c to copy from.Offset into the c to start with.Length of the data to copy.dZ to buffer to copy from.e to copy into.Offset to start copying from.Length of the data to copy.fc to copy.Offset into the c of where to start copying.Pointer to destination buffer.7Length of the data to copy into the destination buffer.  g] _` df (c) Ben Gamari 2017-2018BSD3-style (see LICENSE.txt)duncan@community.haskell.org experimentalnon-portable (GHC extensions)NoneBOThmkByteArray n xs forms a c with contents xs . Note that n must be the precise length of xs.i'A conservative estimate of pinned-ness.joffsetlengtharrayklhimnjklhimjklhim(c) Ben Gamari 2017-2018BSD3-style (see LICENSE.txt)duncan@community.haskell.org experimentalnon-portable (GHC extensions)NoneBDR%"Note that this may require a copy. !"#$%o&'()*+  !"#$%&  $!"#%&  !"#$%o&'()*+(c) Duncan Coutts 2015-2017BSD3-style (see LICENSE.txt)duncan@community.haskell.org experimentalnon-portable (GHC extensions)None#A flattened representation of a term, which is independent of any underlying binary representation, but which we later serialise into CBOR format.@An intermediate form used during serialisation, specified as a pK. It supports efficient concatenation, and is equivalent to a specialised     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 c value, you specify larger structures from smaller ones and append the small ones together using  .F Encode a Y in a flattened format.G Encode a q in a flattened format.H Encode a r in a flattened format.I Encode a s in a flattened format.J Encode a [ in a flattened format.K Encode an b in a flattened format.L Encode an t in a flattened format.M Encode an u in a flattened format.N Encode an v in a flattened format.O Encode an @w in a flattened format.PEncode an arbitrarily large @a in a flattened format.QEncode an arbitrary strict \ in a flattened format.R*Encode a bytestring in a flattened format.SEncode a token specifying the beginning of a string of bytes of indefinite length. In reality, this specifies a stream of many occurrences of Q, 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 [).T Encode a x in a flattened format.U-Encode the beginning of an indefinite string.VnEncode a UTF-8 string in a flattened format. Note that the contents is not validated to be well-formed UTF-8.WcEncode the length of a list, used to indicate that the following tokens represent the list values.XEncode 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.YaEncode the length of a Map, used to indicate that the following tokens represent the map values.ZEncode 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 Y tag.]Encode an arbitrary 64-bit [ tag.^ Encode a y._ Encode an Undef value.` Encode a Null value.alEncode a 'simple' CBOR token that can be represented with an 8-bit word. You probably don't ever need this.bEncode a small 16-bit ^ in a flattened format.cEncode a full precision ^ in a flattened format.d Encode a z in a flattened format.ef?,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg<,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd<,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQSRTUVWXYZ[\]^_`abcd$,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg(c) Duncan Coutts 2015-2017BSD3-style (see LICENSE.txt)duncan@community.haskell.org experimentalnon-portable (GHC extensions)None2BOTjTurn an  into a lazy { in CBOR binary format.kTurn an  into a strict \ in CBOR binary format.lTurn an  into a { | in CBOR binary format.'jThe  of a CBOR value.The encoded CBOR value.kThe  of a CBOR value.The encoded value.lThe  of a CBOR value.The encoded value as a |.}~jklljk'jkl}~(c) Duncan Coutts 2015-2017BSD3-style (see LICENSE.txt)duncan@community.haskell.org experimentalnon-portable (GHC extensions)None/2BOTmPretty prints an  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:  . m . " $ ( 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") *mnopmm)mnop(c) Ben Gamari 2017-2018BSD3-style (see LICENSE.txt)duncan@community.haskell.org experimentalnon-portable (GHC extensions)None BDORTrstuvwxyz{|}~ rstuvwxyz rstuvwxyz rstuvwxyz{|}~(c) Duncan Coutts 2015-2017BSD3-style (see LICENSE.txt)duncan@community.haskell.org experimentalnon-portable (GHC extensions)NoneBOTGGThe 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.Lift an ST action into a Decoder\. Useful for, e.g., leveraging in-place mutation to efficiently build a deserialised value.Given a , give us the  Decode a Y. Decode a q. Decode a r. Decode a s. Decode a [.Decode a negative Y.Decode a negative [. Decode an b. Decode an t. Decode an u. Decode an v. Decode an w.%Decode canonical representation of a Y.%Decode canonical representation of a q.%Decode canonical representation of a r.%Decode canonical representation of a s.%Decode canonical representation of a [..Decode canonical representation of a negative Y..Decode canonical representation of a negative [.&Decode canonical representation of an b.&Decode canonical representation of an t.&Decode canonical representation of an u.&Decode canonical representation of an v.&Decode canonical representation of an w. Decode an a. Decode a ^. Decode a z.Decode a string of bytes as a \.KDecode a token marking the beginning of an indefinite length set of bytes.Decode a string of bytes as a r.Also note that this will eagerly copy the content out of the input to ensure that the input does not leak in the event that the r is live but not forced.&Decode a textual string as a piece of x.EDecode a token marking the beginning of an indefinite length string.)Decode a textual string as UTF-8 encoded rA. Note that the result is not validated to be well-formed UTF-8.Also note that this will eagerly copy the content out of the input to ensure that the input does not leak in the event that the r is live but not forced.Decode the length of a list.8Decode canonical representation of the length of a list.EDecode a token marking the beginning of a list of indefinite length.Decode the length of a map.7Decode canonical representation of the length of a map.DDecode a token marking the beginning of a map of indefinite length.+Decode an arbitrary tag and return it as a Y.2Decode an arbitrary 64-bit tag and return it as a [.HDecode canonical representation of an arbitrary tag and return it as a Y.ODecode canonical representation of an arbitrary 64-bit tag and return it as a [.Decode a bool.0Decode a nullary value, and return a unit value. Decode a simple CBOR value and give back a q,. You probably don't ever need to use this.&Decode canonical representation of an a.4Decode canonical representation of a half-precision ^.%Decode canonical representation of a ^.%Decode canonical representation of a z.%Decode canonical representation of a simple CBOR value and give back a q+. You probably don't ever need to use this.Attempt to decode a word with 7, and ensure the word is exactly as expected, or fail.&Attempt to decode a list length using :, and ensure it is exactly the specified length, or fail.:Attempt to decode canonical representation of a word with 7, and ensure the word is exactly as expected, or fail.CAttempt to decode canonical representation of a list length using :, 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. Decode a sequence length."Expected value of the decoded word"Expected value of the decoded word               I2      (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  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)NoneBOT A concrete encoding of ) values, one which mirrors the original  type closely.A "flat" representation of an 5 value, useful for round-tripping and writing tests.Convert an arbitrary  into a .FA data type used for tracking the position we're at as we traverse a  and make sure it's valid.AGiven a  , decode a 2 back into an ordinary value, or return an error.Map a  to the underlying CBOR B Ensure a = is internally consistent and was created in a valid manner.Validate an arbitrary  at an arbitrary location. Do a careful check to ensure an b is in the range of a s.@ The input .The resulting ./0123456789:;<=>?@AA  for a serialised value.The serialised .$The deserialised value, or an error.B The input  if valid,  otherwise./12345678:0<;=>?@9AB/0123456789:;<=>?@AB#/0123456789:;<=>?@ AB (c) Duncan Coutts 2015-2017BSD3-style (see LICENSE.txt)duncan@community.haskell.org experimentalnon-portable (GHC extensions)None0BOT GSimple alias for w&, used to make types more descriptive.HAn Incremental decoder, used to represent the result of attempting to run a decoder over a given input, and return a value of type a.IRThe 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 H.JThe decoder has successfully finished. Except for the output value you also get any unused input as well as the number of bytes consumed.K8The 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 L; exception describing the reason why the failure occurred.L}An exception type that may be returned (by pure functions) or thrown (by IO actions) that fail to deserialise a given input.NGiven 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.OGiven a  and some {- representing an encoded CBOR value, return  the decoded CBOR value or an error. In addition to the decoded value return any remaining input content and the number of bytes consumed.PRun a \ incrementally, returning a continuation representing the result of the incremental decode.\     GHIJKLMNOP !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOQRST GHKIJLMNOP NOPLMHIJKGF     GHIJKLMNOP !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOQRST(c) Duncan Coutts 2015-2017BSD3-style (see LICENSE.txt)duncan@community.haskell.org experimentalnon-portable (GHC extensions)NoneP !"#$%&'()**+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}8~348      !"#$ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; <@NBCEGHIJKVLQORSTU=>?@AB C D E   F F G H I J K L M N O PQRSTUVQWXQYZ[\]^TU_`abcdTUefghfgij k l m n o pTUqrQstQYuQYvQYwQxyQxzQx{Qx|}~TUTU[][QQsQsQsTUTU      QsQ                           ! " # $ % & ' ( ) * + , - . / 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 TU$cborg-0.2.0.0-8SbbXsK6qMm1mDHSexCvqPCodec.CBOR.MagicCodec.CBOR.EncodingCodec.CBOR.FlatTermCodec.CBOR.ByteArray.SlicedCodec.CBOR.WriteCodec.CBOR.PrettyCodec.CBOR.ByteArrayCodec.CBOR.DecodingCodec.CBOR.TermCodec.CBOR.ReadCodec.CBOR.ByteArray.Internal Data.MonoidEndomconcat Codec.CBORencodeData.MapfromListCounter grabWord8 grabWord16 grabWord32 grabWord64 eatTailWord8 eatTailWord16 eatTailWord32 eatTailWord64 wordToFloat16 floatToWord16 wordToFloat32 wordToFloat64nintegerFromBytesuintegerFromBytes newCounter readCounter writeCounter incCounter decCountercopyByteStringToByteArraycopyByteArrayToByteStringTokensEncoding TermTokenFlatTerm toFlatTermSlicedByteArraySBAunSBAoffsetlengthfromShortByteStringfromByteString fromByteArraysizeofSlicedByteArray toByteString toBuilder$fOrdSlicedByteArray$fEqSlicedByteArray$fShowSlicedByteArray$fIsListSlicedByteArray$fIsStringSlicedByteArrayTkWordTkWord64TkIntTkInt64TkBytes TkBytesBegin TkByteArrayTkStringTkUtf8ByteArray TkStringBegin TkListLen TkListBeginTkMapLen TkMapBeginTkTagTkTag64 TkIntegerTkNullTkUndefTkBoolTkSimple TkFloat16 TkFloat32 TkFloat64TkBreakTkEnd encodeWord encodeWord8 encodeWord16 encodeWord32 encodeWord64 encodeInt encodeInt8 encodeInt16 encodeInt32 encodeInt64 encodeInteger encodeBytesencodeByteArrayencodeBytesIndef encodeStringencodeStringIndefencodeUtf8ByteArray encodeListLenencodeListLenIndef encodeMapLenencodeMapLenIndef encodeBreak encodeTag encodeTag64 encodeBool encodeUndef encodeNull encodeSimple encodeFloat16 encodeFloat encodeDouble$fMonoidEncoding$fSemigroupEncoding$fShowEncoding $fShowTokens $fEqTokenstoLazyByteStringtoStrictByteString prettyHexEnc $fMonadFailPP $fMonadPP$fApplicativePP $fFunctorPP ByteArrayBAunBAsizeofByteArraytoShortByteStringtoSliced$fIsListByteArray$fIsStringByteArray$fOrdByteArray $fEqByteArray$fShowByteArray 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 ConsumeTagConsumeWordCanonicalConsumeWord8CanonicalConsumeWord16CanonicalConsumeWord32CanonicalConsumeNegWordCanonicalConsumeIntCanonicalConsumeInt8CanonicalConsumeInt16CanonicalConsumeInt32CanonicalConsumeListLenCanonicalConsumeMapLenCanonicalConsumeTagCanonicalConsumeInteger ConsumeFloat ConsumeDouble ConsumeBytesConsumeByteArray ConsumeStringConsumeUtf8ByteArray ConsumeBool ConsumeSimpleConsumeIntegerCanonicalConsumeFloat16CanonicalConsumeFloatCanonicalConsumeDoubleCanonicalConsumeSimpleCanonicalConsumeBytesIndefConsumeStringIndefConsumeListLenIndefConsumeMapLenIndef ConsumeNullConsumeListLenOrIndefConsumeMapLenOrIndefConsumeBreakOr PeekTokenType PeekAvailableFailDoneDecoderliftSTgetDecodeAction decodeWord decodeWord8 decodeWord16 decodeWord32 decodeWord64 decodeNegWorddecodeNegWord64 decodeInt decodeInt8 decodeInt16 decodeInt32 decodeInt64decodeWordCanonicaldecodeWord8CanonicaldecodeWord16CanonicaldecodeWord32CanonicaldecodeWord64CanonicaldecodeNegWordCanonicaldecodeNegWord64CanonicaldecodeIntCanonicaldecodeInt8CanonicaldecodeInt16CanonicaldecodeInt32CanonicaldecodeInt64Canonical decodeInteger decodeFloat decodeDouble decodeBytesdecodeBytesIndefdecodeByteArray decodeStringdecodeStringIndefdecodeUtf8ByteArray decodeListLendecodeListLenCanonicaldecodeListLenIndef decodeMapLendecodeMapLenCanonicaldecodeMapLenIndef decodeTag decodeTag64decodeTagCanonicaldecodeTag64Canonical decodeBool decodeNull decodeSimpledecodeIntegerCanonicaldecodeFloat16CanonicaldecodeFloatCanonicaldecodeDoubleCanonicaldecodeSimpleCanonical decodeWordOfdecodeListLenOfdecodeWordCanonicalOfdecodeListLenCanonicalOfdecodeListLenOrIndefdecodeMapLenOrIndef decodeBreakOr peekTokenType peekAvailabledecodeSequenceLenIndefdecodeSequenceLenN$fMonadFailDecoder$fMonadDecoder$fApplicativeDecoder$fFunctorDecoder $fEqTokenType$fOrdTokenType$fEnumTokenType$fBoundedTokenType$fShowTokenTypeTermTIntTIntegerTBytesTBytesITStringTStringITListTListITMapTMapITTaggedTBoolTNullTSimpleTHalfTFloatTDouble encodeTerm decodeTerm$fEqTerm $fOrdTerm $fShowTerm $fReadTerm fromFlatTerm validFlatTerm $fEqTermToken$fOrdTermToken$fShowTermToken $fShowLoc ByteOffsetIDecodePartialDeserialiseFailuredeserialiseFromBytesdeserialiseFromBytesWithSizedeserialiseIncremental$fMonadIncrementalDecoder$fApplicativeIncrementalDecoder$fFunctorIncrementalDecoder$fExceptionDeserialiseFailure$fShowDeserialiseFailure$fShowDecodedToken$fShowLongTokenbaseGHC.STSTghc-prim GHC.TypesWordGHC.PtrPtrGHC.WordWord64bytestring-0.10.8.1Data.ByteString.Internal ByteString withBsPtrFloatwordToFloat32#wordToFloat64# integer-gmpGHC.Integer.TypeIntegerInt(primitive-0.6.2.0-4578caNkWQ54Gt1mxLF2YhData.Primitive.ByteArraycopyPtrToMutableByteArrayMutableByteArraycopyByteArrayToPtr mkByteArrayisByteArrayPinnedfoldrByteArray copyToAddr sameByteArraytouchisTrue#toPinnedGHC.BaseMonoidWord8Word16Word32GHC.IntInt8Int16Int32Int64#text-1.2.2.2-KC7dWoG09dA1F6jKj5GSqhData.Text.InternalTextBoolDoubleData.ByteString.Lazy.Internal Data.ByteString.Builder.InternalBuilderheader constHeader withHeaderwithConstHeaderwordMPword64MP negInt64MPintMPint64MPbytesMP bytesLenMP byteArrayMP bytesBeginMPstringMP stringLenMP stringBeginMPutf8ByteArrayMP arrayLenMP arrayBeginMPmapLenMP mapBeginMPtagMPtag64MPsimpleMPfalseMPtrueMPnullMPundefMP canonicalNaNhalfMPfloatMPdoubleMPbreakMPbigNatMP negBigNatMPbigNatToBuilder System.IOputStrLnPPrunPPindentnlincdecgetTermpeekTermappShowSstrshownparensindefpprintppTkInt ppTkIntegerppTkWord ppTkBytesppTkBytesBegin ppTkStringppTkStringBegin ppTkListLen ppTkListBegin ppMapPairs ppTkMapLen ppTkMapBegin ppTkBreakppTkTagppTkBoolppTkNull ppTkSimple ppTkFloat16 ppTkFloat32 ppTkFloat64 unconsTokenhexRephexBSMonadNothingJustTrueFalse runDecoderdecodeListLenOfHelperdecodeWordOfHelperdecodeBytesIndefLendecodeStringIndefLen decodeListNdecodeListIndefLen decodeMapNdecodeMapIndefLenLoc tokenTypeOf validateTermintIsValidWord32TopLevelSingleTopLevelSequenceInStringInBytesInListNInList InMapNKey InMapNValInMapKeyInMapValInTagged convFlatTermunexpectedToken unexpectedEof validateBytesvalidateString validateListN validateList validateMapN validateMapmaxIntminIntmaxWordmaxInt8minInt8maxWord8maxInt16minInt16 maxWord16maxInt32minInt32 maxWord32unI#unW#unW8#unF#unD#fail Data.EitherEither BigIntTokenBigUIntNeedBodyBigNIntNeedBodyBigUIntNeedHeaderBigNIntNeedHeader LongTokenFitsTooLong DecodedToken DecodeFailureSlowPathFastDoneSlowConsumeTokenBytesSlowConsumeTokenByteArraySlowConsumeTokenStringSlowConsumeTokenUtf8ByteArraySlowDecodeActionSlowFailIncrementalDecoderunIncrementalDecoder runIDecoderunIncrementalDecoder decodeFail needChunkliftrunDecodeActiongo_fast go_fast_endgo_slow go_slow_fixupgo_slow_overlappedgetTokenVarLengetTokenVarLenSlow tokenSize decodeTableSzdecodeTokenTypeTable encodeHeaderisFloat16CanonicalisFloatCanonicalisDoubleCanonicalisWordCanonicalisIntCanonicaltryConsumeWordtryConsumeNegWord tryConsumeInttryConsumeIntegertryConsumeBytestryConsumeStringtryConsumeListLentryConsumeMapLentryConsumeListLenIndeftryConsumeMapLenIndeftryConsumeListLenOrIndeftryConsumeMapLenOrIndef tryConsumeTagtryConsumeFloattryConsumeDoubletryConsumeBooltryConsumeSimpletryConsumeBytesIndeftryConsumeStringIndeftryConsumeNulltryConsumeBreakOrreadBytesSmall readBytes8 readBytes16 readBytes32 readBytes64adjustContBigUIntNeedBodyadjustContBigNIntNeedBodyadjustContBigUIntNeedHeaderadjustContBigNIntNeedHeader readBigUInt readBigNIntisBigIntRepCanonical