h*/)      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi j k l m n o p q r s t u v w x y z { | } ~                                  1.3.0 Safe-Inferred )1=> Safe-Inferred )1=>2 bytezap Generic type  using the addition monoid.   Safe-Inferred )1=>q Safe-Inferred )1=> Safe-Inferred )1=> Safe-Inferred)1=>6 Safe-Inferred)1=>u !"#$%&'()*+,- !"#$%&'()*+,- Safe-Inferred)1=>q.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!)0bytezap4Read a value from the array. The offset is in bytes../012345 ./012345  Safe-Inferred)1=> @bytezap'Newtype for easier instance derivation.FbytezapBoxed types which permit reversing byte order ("byte swapping").Sbytezap-Prim instance where we byte swap at accesses.@BACEDFGFGCED@BA Safe-Inferred)1=>._bytezapPoke newtype wrapper.bbytezapA 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.cbytezap Execute a _ at a fresh  of the given length.dbytezap 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 allocaBytesebytezapPoke a type via its . instance.fbytezap9The empty poke. Provided here as we can't provide it via .gbytezap Sequence two _/s. We only require the length of the left poke.hbytezapessentially memset _a`bcdefgh b_a`cdefgh  Safe-Inferred)1=> ibytezap0Serialize a type-level bytestring, byte-by-byte.kbytezap4Serialize a type-level bytestring, largest grouping Word16.mbytezap4Serialize a type-level bytestring, largest grouping Word32.obytezap4Serialize a type-level bytestring, largest grouping Word64.qbytezapEnough bytes to make a Word64.rbytezapEnough bytes to make a Word32.sbytezap Try to group Word32s next.tbytezapEnough bytes to make a Word16.ubytezap Try to group Word16s next.vbytezapEnd of the line.wbytezapReify the next byte.xbytezapReify byte-by-byte next.ijklmnopopmnklij  Safe-Inferred)1=> ybytezapPoke newtype wrapper.}bytezap Execute a y at a fresh  of the given length.~bytezap Execute a y at a fresh  of the given maximum length. Does not reallocate if final size is less than estimated.bytezap Execute a y3 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.bytezap Sequence two ys left-to-right. y{z|}~ |y{z}~  Safe-Inferred )1=>bytezapA Poke# with the associated size it pokes.bytezap The empty  is the empty Poke, which writes zero bytes.bytezap Sequence the Pokes, sum the sizes.  Safe-Inferred%&)1=>YbytezapHelper for writing  runners.bytezapessentially memset    Safe-Inferred )1=>   Safe-Inferred )1=>bytezapPoke 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=>fbytezapWrite a .bytezapWrite a .bytezapWrite a .Adapted from utf8-string. Safe-Inferred )1=> 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.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.bytezap 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)bytezappointer provenance bytezap base address bytezapcursor offset from base bytezap state token  Safe-Inferred)1=>$ bytezap0Serialize a type-level bytestring, byte-by-byte.bytezap4Serialize a type-level bytestring, largest grouping Word16.bytezap4Serialize a type-level bytestring, largest grouping Word32.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.bytezapReify the next byte.bytezapReify byte-by-byte next. Safe-Inferred )1=>% Safe-Inferred)1=>'bytezap=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=>(+ Safe-Inferred)1=>)dbytezapThe 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! !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^__`aabc2defghijklmnopqrstuvwxyz{{|}~                 { { | } ~                                   bytezap-1.3.0-inplace"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.Struct$Bytezap.Parser.Struct.TypeLits.Bytes Util.TypeNatsBytezap.Struct.GenericBytezap.Poke.KnownLenBytezap.Parser.Struct.GenericbytezapBytezap Paths_bytezapMonoidempty KnownSizeOf(primitive-0.8.0.0-BcoUEAnXhk925AP6fFV7UeData.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:$fReifyBytesW64ns$fReifyBytesW16:$fReifyBytesW32ns$fReifyBytesW8[]$fReifyBytesW8:$fReifyBytesW16nsunsafeRunPokeBSUptoN byteString byteArray#fromStructPoke toStructPoke $fMonoidPoke$fSemigroupPokeWritesizepoke $fMonoidWrite$fSemigroupWrite runWriteBSrunWriteBSUptoNw16lew16bew32lew32bew64lew64bei16lei16bei32lei32bei64lei64beshortByteStringtextcharunsafePokeIndexedc_lower_hex_tableescapedLength8escapeW8pokeEscapedTextUnquoted pokeEscapeW8 w8AsciiHexResultOKFailErrResI#Res#ParserSTParserIOParserParserT runParserT#ParserT#STModeIOModePureModeErr#Fail#OK#unsafeRunParserBsunsafeRunParserPtrunsafeRunParserFPtrunsafeRunParser' constParsesequenceParserslitwithLit$fFunctorParserT $fShowResultParseReifyBytesW8parseReifyBytesW8ParseReifyBytesW16parseReifyBytesW16ParseReifyBytesW32parseReifyBytesW32ParseReifyBytesW64parseReifyBytesW64$fParseReifyBytesW64:$fParseReifyBytesW32:$fParseReifyBytesW64ns$fParseReifyBytesW16:$fParseReifyBytesW32ns$fParseReifyBytesW8[]$fParseReifyBytesW8:$fParseReifyBytesW16nsnatVal'' natValIntGPokegPoke GPokeBase GPokeBaseSt GPokeBaseCGPokeBaseLenTF gPokeBase$fGPokekktagU1$fGPokekktagM1$fGPokekktag:*:$fGPokekktagM10$fGPokekktagM11 PokeKnownLenunPokeKnownLenmappend'mempty'runPokeKnownLenBSGParsegParse GParseBase GParseBaseSt GParseBaseC GParseBaseEGParseBaseLenTF gParseBase$fGParsekktagU1$fGParsekktagM1$fGParsekktag:*:$fGParsekktagM10$fGParsekktagM11base Data.FoldablefoldMapversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDirgetDataFileName getSysconfDirbytestring-0.11.5.3Data.ByteString.Internal.Type ByteString runWriteWithData.ByteString.Short.InternalShortByteString text-2.0.2Data.Text.InternalTextghc-prim GHC.TypesCharIOGHC.Basepure ApplicativeType ghc-bignumGHC.Num.NaturalNatural