h*A|:~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                              1.4.0 Safe-Inferred )1=>f Safe-Inferred )1=> bytezap Generic type  using the addition monoid.   Safe-Inferred )1=> Safe-Inferred )1=>d Safe-Inferred )1=> Safe-Inferred)1=> Safe-Inferred)1=>  #&),!$'*-"%(+. #&),!$'*-"%(+. Safe-Inferred)1=> /bytezap- extension class providing unaligned accesseshoping to get this merged in /https://github.com/haskell/primitive/issues/4099(also includes Addr# primops which that issue/PR may not)Also includes an associated type for size in bytes. Another thing that maybe primitive could provide. (Wouldn't be hard!)1bytezap4Read a value from the array. The offset is in bytes./0412356 /0412356  Safe-Inferred)1=> >Abytezap'Newtype for easier instance derivation.GbytezapBoxed types which permit reversing byte order ("byte swapping").Tbytezap-Prim instance where we byte swap at accesses.ACBDFEGHGHDFEACB  Safe-Inferred)1=>`bytezapPoke newtype wrapper.cbytezapA struct poker: base address (constant), byte offset, state token.We could combine base address and byte offset, but we're aiming for code that stores the address in a register and uses immediates to access fields (like a good C compiler will do for its structs). So by keeping them separate, I'm hoping that we can nudge GHC towards such behaviour.dbytezap Execute a ` at a fresh  of the given length.ebytezap Execute a `3 at a pointer. Returns the number of bytes written.The pointer must be a mutable buffer with enough space to hold the poke. Absolutely none of this is checked. Use with caution. Sensible uses:.implementing pokes to ByteStrings and the likeexecuting known-length (!!) pokes to known-length (!!) buffers e.g. together with allocaBytesfbytezapPoke a type via its / instance.gbytezap9The empty poke. Provided here as we can't provide it via .hbytezap Sequence two `/s. We only require the length of the left poke.ibytezapessentially memset `bacdefghi c`badefghi  Safe-Inferred)1=> jbytezap0Serialize a type-level bytestring, byte-by-byte.lbytezap4Serialize a type-level bytestring, largest grouping Word16.nbytezap4Serialize a type-level bytestring, largest grouping Word32.pbytezap4Serialize a type-level bytestring, largest grouping Word64.rbytezapEnough bytes to make a Word64.sbytezapEnough bytes to make a Word32.tbytezap Try to group Word32s next.ubytezapEnough bytes to make a Word16.vbytezap Try to group Word16s next.wbytezapEnd of the line.xbytezapReify the next byte.ybytezapReify byte-by-byte next.pqnolmjkpqnolmjk  Safe-Inferred)1=> zbytezapPoke newtype wrapper.}bytezapUnboxed buffer write operation.The next offset must be greater than or equal to the input buffer offset. This is not checked.Note that the only way to find out the length of a write is to perform it. But you can't perform a length without providing a correctly-sized buffer. Thus, you may only use a } when you have a buffer large enough to fit its maximum write length-- which in turn means means you must track write lengths separately. (  does this.)I provide this highly unsafe, seemingly unhelpful type because it's a requirement for  , and here I can guarantee performance better because I don't need to worry about laziness.We cannot be polymorphic on the pointer type unless we box the pointer. We thus limit ourselves to writing to  s, and not &s. (I figure we're most interested in  ByteString s, which use .)Note that if we did provide write length, then the next offset might appear superfluous. But that next offset is usually already calculated, and may be passed directly to sequenced writes, unlike if we returned a write length which would need to be added to the original offset.~bytezap Execute a z at a fresh  of the given length.bytezap Execute a z at a fresh  of the given maximum length. Does not reallocate if final size is less than estimated.bytezap Execute a z3 at a pointer. Returns the number of bytes written.The pointer must be a mutable buffer with enough space to hold the poke. Absolutely none of this is checked. Use with caution. Sensible uses:.implementing pokes to ByteStrings and the likeexecuting known-length (!!) pokes to known-length (!!) buffers e.g. together with allocaBytesbytezapPoke a type via its / instance.bytezapessentially memsetbytezap$Use a struct poke as a regular poke.To do this, we must associate a constant byte length with an existing poker. Note that pokers don't expose the type of the data they are serializing, so this is a very clumsy operation by itself. You should only be using this when you have such types in scope, and the constant length should be obtained in a sensible manner (e.g.  for generic struct pokers, or your own constant size class if you're doing funky stuff).bytezapUse a struct poke as a regular poke by throwing away the return offset.bytezapThe empty buffer write simply returns its state token and offset.bytezap)Sequence two buffer writes left-to-right.}bytezapbuffer pointer bytezapbuffer offset bytezap state token bytezap(state token, next offset) z|{}~ }z|{~  Safe-Inferred )1=>!c bytezap'What a buffer write length field means.bytezapExact length to be written.bytezapMaximum length to be written.bytezapA z buffer write operation with the associated length to be written.,The length may be either exact or a maximum.TODO strictness?bytezapLength of the write in bytes.:This is not statically asserted. Any time you construct a , you must promise this.For   s%, this is an exact measurement. For   s, this is a maximum.bytezapThe z buffer write operation.bytezapTurn a   into a  .bytezap Sequence a   and a   left-to-right.bytezap Sequence a   and a   left-to-right.bytezap Sequence two s left-to-right.Unsafe, as it ignores s.&TODO strictness? INLINE[1]? INLINE[0]?bytezap The empty  is the empty z, which writes zero bytes.bytezap%Sequence the writes, sum the lengths.    Safe-Inferred%&)1=>"bytezapHelper for writing  runners.bytezapessentially memset   Safe-Inferred )1=>"   Safe-Inferred )1=>$qbytezapPoke a .bytezapPoke a .bytezapPoke a .Adapted from utf8-string.bytezapunsafePokeIndexed pokeAt off n performs n indexed pokes starting from off.Does not check bounds. Largely intended for bytewise pokes where some work needs to be performed for each byte (e.g. escaping text and poking inline). Safe-Inferred )1=>%6bytezapWrite a .bytezapWrite a .bytezapWrite a .Adapted from utf8-string. Safe-Inferred )1=>%z Safe-Inferred)-1=>/bytezap1Higher-level boxed data type for parsing results.bytezapContains return value.bytezapRecoverable-by-default failure.bytezapUnrecoverable-by-default error.bytezapPrimitive parser result.Like flatparse, but no  on success.bytezap3Primitive parser result wrapped with a state token.You should rarely need to manipulate values of this type directly. Use the provided bidirectional pattern synonyms ,  and .bytezap$The type of parsers which can embed ST actions.bytezap$The type of parsers which can embed  actions.bytezapThe type of pure parsers.bytezapLike flatparse, but no buffer length (= no buffer overflow checking), and no ) on success (= no dynamic length parses). we take a  because it lets us create bytestrings without copying if we want. it's usefulbytezap constructor for errors which are by default non-recoverable. Contains the error, plus a state token.bytezap constructor for recoverable failure. Contains only a state token.bytezap constructor for a successful parse. Contains the return value and a state token.bytezap=caller must guarantee that buffer is long enough for parser!!bytezap=caller must guarantee that buffer is long enough for parser!!bytezap=caller must guarantee that buffer is long enough for parser!!bytezap=caller must guarantee that buffer is long enough for parser!!bytezapcan't provide via  as no bytezap parse literalbytezapparse literal (CPS)bytezapparse literal, return first (leftmost) failing byte on error (CPS)This can be used to parse large literals via chunking, rather than byte-by-byte, while retaining useful error behaviour.We don't check equality with XOR even though we use that when handling errors, because it's hard to tell if it would be faster with modern CPUs and compilers.bytezapGiven two non-equal words wActual and wExpect, return the index of the first non-matching byte. Zero indexed.7If both words are equal, returns word_size (e.g. 4 for Word32).bytezap Get the byte at the given index.=The return value is guaranteed to be 0x00 - 0xFF (inclusive).!TODO meaning based on endianness?bytezappointer provenance bytezap base address bytezapcursor offset from base bytezap state token  Safe-Inferred)1=>1bytezapCopy the given number of bytes from the second area (source) into the first (destination); the copied areas may not overlap.,Reimplemented from the unexported function  !.bytezap Create a  of size l and use action f to fill its contents.Reimplemented from the unexported function 'Data.ByteString.Internal.Type.createFp. Safe-Inferred)1=>2bytezap newtype wrapper.Does not permit a : instance because pokes do not return offset information.   Safe-Inferred )1=>30 Safe-Inferred)1=>5bytezap=Class for holding info on class to use for poking base cases.The type is just used to map to class info. It is never instantiated. By packing  KnownSizeOf into here, we don't need to enforce a type-level solution! Now it's up to you how you want to track your constant lengths.We stay unboxed here because the internals are unboxed, just for convenience. Maybe this is bad, let me know.bytezapThe state token of our poker.bytezap.The type class that provides base case poking.9The type class should provide a function that looks like .bytezapWow, look! Nothing! Safe-Inferred )1=>6< Safe-Inferred)1=>9 bytezap0Serialize a type-level bytestring, byte-by-byte.bytezap0Parse a type-level bytestring, largest grouping Word16.bytezap0Parse a type-level bytestring, largest grouping Word32.bytezap0Parse a type-level bytestring, largest grouping Word64.bytezapEnough bytes to make a Word64.bytezapEnough bytes to make a Word32.bytezap Try to group Word32s next.bytezapEnough bytes to make a Word16.bytezap Try to group Word16s next.bytezapEnd of the line.bytezapParse the next byte.bytezapParse byte-by-byte next. Safe-Inferred)1=>:ZbytezapThe state token of the parser.bytezap5Defunctionalization symbol for a type family turning  s into 6s. (Needed as we can't partially apply type families.)bytezapWow, look! Nothing!" #$%&$%'$%($%)$%*$%+$%,$%-$%.$%/$%0$%123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeffghhij9klmnopqrstuvwxyz{|}~                                                            !"  "bytezap-1.4.0-inplace Tmp.BSExt"Raehik.Compat.Data.Primitive.TypesBytezap.Common.GenericRaehik.Compat.Data.Int.ByteSwap Raehik.Compat.Data.Word.ByteSwap*Raehik.Compat.GHC.Exts.GHC908MemcpyPrimops1Raehik.Compat.GHC.Exts.GHC910UnalignedAddrPrimops)Raehik.Compat.Data.Primitive.Types.EndianBytezap.StructBytezap.Struct.TypeLits.Bytes Bytezap.PokeBytezap.Write.Internal Bytezap.WriteBytezap.Poke.Derived.EndianBytezap.Poke.DerivedBytezap.Write.DerivedBytezap.Poke.JsonBytezap.Parser.StructBytezap.PokeCPS Util.TypeNatsBytezap.Struct.GenericBytezap.Poke.KnownLen$Bytezap.Parser.Struct.TypeLits.BytesBytezap.Parser.Struct.GenericbytezapBytezap Paths_bytezapMonoidemptyWrite KnownSizeOfData.ByteString.Internal.TypememcpyFpbytestring-0.11.5.3mkDeferredByteString(primitive-0.8.0.0-G7z1XrhwN0bFkYsIqIr1QUData.Primitive.TypesPrimsizeOf# alignment#indexByteArray#readByteArray#writeByteArray# setByteArray# indexOffAddr# readOffAddr# writeOffAddr# setOffAddr#sizeOfGTFoldMapCAdditionPlusSym1PlusSym byteSwapI16 byteSwapI32 byteSwapI64 byteSwapIbyteSwapcopyAddrToAddrNonOverlapping# setAddrRange#indexWord8OffAddrAsWord16#readWord8OffAddrAsWord16#writeWord8OffAddrAsWord16#indexWord8OffAddrAsWord32#readWord8OffAddrAsWord32#writeWord8OffAddrAsWord32#indexWord8OffAddrAsWord64#readWord8OffAddrAsWord64#writeWord8OffAddrAsWord64#indexWord8OffAddrAsWord#readWord8OffAddrAsWord#writeWord8OffAddrAsWord#indexWord8OffAddrAsInt16#readWord8OffAddrAsInt16#writeWord8OffAddrAsInt16#indexWord8OffAddrAsInt32#readWord8OffAddrAsInt32#writeWord8OffAddrAsInt32#indexWord8OffAddrAsInt64#readWord8OffAddrAsInt64#writeWord8OffAddrAsInt64#indexWord8OffAddrAsInt#readWord8OffAddrAsInt#writeWord8OffAddrAsInt#Prim'SizeOfindexWord8ByteArrayAs#readWord8ByteArrayAs#writeWord8ByteArrayAs#indexWord8OffAddrAs#readWord8OffAddrAs#writeWord8OffAddrAs# $fPrim'Int $fPrim'Word $fPrim'Int64 $fPrim'Int32 $fPrim'Int16 $fPrim'Int8 $fPrim'Word64 $fPrim'Word32 $fPrim'Word16 $fPrim'Word8PrimByteSwappedunPrimByteSwapped ByteOrdered unByteOrderedByteSwap$fByteSwapDouble$fByteSwapFloat $fByteSwapInt$fByteSwapInt64$fByteSwapInt32$fByteSwapInt16$fByteSwapWord$fByteSwapWord64$fByteSwapWord32$fByteSwapWord16$fPrim'PrimByteSwapped$fPrimPrimByteSwapped$fOrdByteOrdered$fEqByteOrdered$fShowByteOrdered$fNumByteOrdered$fRealByteOrdered$fEnumByteOrdered$fIntegralByteOrdered$fPrim'ByteOrdered$fPrimByteOrdered$fPrim'ByteOrdered0$fPrimByteOrdered0PokeunPokePoke#unsafeRunPokeBS unsafeRunPokeprim emptyPoke sequencePokes replicateByte ReifyBytesW8 reifyBytesW8 ReifyBytesW16 reifyBytesW16 ReifyBytesW32 reifyBytesW32 ReifyBytesW64 reifyBytesW64$fReifyBytesW64:$fReifyBytesW32:$fReifyBytesW64bs$fReifyBytesW16:$fReifyBytesW32bs$fReifyBytesW8[]$fReifyBytesW8:$fReifyBytesW16bsunsafeRunPokeBSUptoN byteString byteArray#fromStructPoke toStructPoke $fMonoidPoke$fSemigroupPoke LengthType ExactLength MaxLength writeLengthwriteOpwriteMax writeMaxExact writeExactMax writeCombine $fMonoidWrite$fSemigroupWrite runWriteBSrunWriteBSUptoNw16lew16bew32lew32bew64lew64bei16lei16bei32lei32bei64lei64beshortByteStringtextcharunsafePokeIndexedc_lower_hex_tableescapedLength8escapeW8pokeEscapedTextUnquoted pokeEscapeW8 w8AsciiHexResultOKFailErrResI#Res#ParserSTParserIOParserParserT runParserT#ParserT#STModeIOModePureModeErr#Fail#OK#unsafeRunParserBsunsafeRunParserPtrunsafeRunParserFPtrunsafeRunParser' constParsesequenceParserslitwithLit withLitErrfirstNonMatchByteIdx unsafeByteAt$fFunctorParserT $fShowResultcreateFpcreateUptoNCPS createCPScreateAndTrimCPSunsafeCreateAndTrimCPScreateAndTrimFailablecreateFpAndTrimFailablecreateUptoNFailablecreateFpUptoNFailablecreateFailablecreateFpFailable wrapAction unsafeDupablePerformIOByteStringPokeCPS unPokeCPSPokeCPS# emptyPokeCPSfullwithHexNibbleswithByteAsHexDigittextToByteStringUptoIOnatVal'' natValIntGPokegPoke GPokeBase GPokeBaseSt GPokeBaseCGPokeBaseLenTF gPokeBase$fGPokekktagU1$fGPokekktagM1$fGPokekktag:*:$fGPokekktagM10$fGPokekktagM11 PokeKnownLenunPokeKnownLenmappend'mempty'runPokeKnownLenBSParseReifyBytesW8parseReifyBytesW8ParseReifyBytesW16parseReifyBytesW16ParseReifyBytesW32parseReifyBytesW32ParseReifyBytesW64parseReifyBytesW64$fParseReifyBytesW64idx:$fParseReifyBytesW32idx:$fParseReifyBytesW64idxbs$fParseReifyBytesW16idx:$fParseReifyBytesW32idxbs$fParseReifyBytesW8idx[]$fParseReifyBytesW8idx:$fParseReifyBytesW16idxbsGParsegParse GParseBase GParseBaseSt GParseBaseC GParseBaseEGParseBaseLenTF gParseBase$fGParsekktagU1$fGParsekktagM1$fGParsekktag:*:$fGParsekktagM10$fGParsekktagM11base Data.FoldablefoldMapversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDirgetDataFileName getSysconfDir ByteStringghc-primGHC.PrimAddr#MutableByteArray# runWriteWithData.ByteString.Short.InternalShortByteString text-2.0.2Data.Text.InternalText GHC.TypesCharIOGHC.ForeignPtrForeignPtrContentsGHC.Basepure Applicative SemigroupType ghc-bignumGHC.Num.NaturalNatural