h,? 8      !"#$%&'()*+,-./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.6.0None )1=>-bytezap Generic type  using the addition monoid.None )1=>dNone )1=>None )1=>None )1=>None)1=>GNone)1=>~-$'*!.%(+"/&),# !$'*-"%(+. #&),/None)1=>t0bytezap- 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!)2bytezap4Read a value from the array. The offset is in bytes. 01253647    05123467 None)1=> Bbytezap'Newtype for easier instance derivation.HbytezapBoxed types which permit reversing byte order ("byte swapping").Ubytezap-Prim instance where we byte swap at accesses.EFGHIBCDHIEGFBDC None)1=>"abytezapPoke newtype wrapper.dbytezapA 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.ebytezap Execute a a at a fresh  of the given length.fbytezap Execute a a3 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 allocaBytesgbytezapPoke a type via its 0 instance.hbytezap9The empty poke. Provided here as we can't provide it via .ibytezap Sequence two a/s. We only require the length of the left poke.jbytezapessentially memset hgjifeabcd dacbefghij None)1=> kbytezap0Serialize a type-level bytestring, byte-by-byte.mbytezap4Serialize a type-level bytestring, largest grouping Word16.obytezap4Serialize a type-level bytestring, largest grouping Word32.qbytezap4Serialize a type-level bytestring, largest grouping Word64.sbytezapEnough bytes to make a Word64.tbytezapEnough bytes to make a Word32.ubytezap Try to group Word32s next.vbytezapEnough bytes to make a Word16.wbytezap Try to group Word16s next.xbytezapEnd of the line.ybytezapReify the next byte.zbytezapReify byte-by-byte next.mnopqrklqropmnkl None)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!{|}~}~{| None)1=> bytezapPoke 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  at a fresh  of the given length.bytezap Execute a  at a fresh  of the given maximum length. Does not reallocate if final size is less than estimated.bytezap 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 allocaBytesbytezapPoke a type via its 0 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)   None )1=>#e bytezap'What a buffer write length field means.bytezapExact length to be written.bytezapMaximum length to be written.bytezapA  buffer write operation with the associated length to be written.,The length may be either exact or a maximum.TODO strictness?bytezapThe  buffer write operation.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.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 , which writes zero bytes.bytezap%Sequence the writes, sum the lengths.  None%&)1=>$bytezapHelper for writing  runners.bytezapessentially memset  None )1=>$wNone )1=>$  None )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).None )1=>'hbytezapWrite a  !.bytezapWrite a "#.bytezapWrite a .Adapted from utf8-string.None)-1=>3wbytezap1Higher-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).Unlike flatparse, we separate base address from offset, rather than adding them. This fits the unaligned  primops (added in GHC 9.10) better, and in my head should hopefully assist in emitting immediates where possible for offsets on the assembly level.Combining them like in flatparse might be faster; but I really don't know how to find out, without doing both and comparing various examples. After a lot of scratching my head, I think this is most appropriate.The  is for keeping the  data in scope.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)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?bytezap%pointer provenance (does not change) bytezapbase address (does not change) bytezapcursor offset from base bytezap state token bytezapresult None)1=>6 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.None)1=>8ebytezapThe 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!bytezapdata type name bytezapconstructor name bytezaprecord name (if present) bytezap field index $%&$%'()()*()+(),()-().()/()0()1()2()3()456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghiiijkkklm>nopqrstuvwxyz{|}~                                                                  8$%$%$$$bytezap-1.6.0-inplace*Raehik.Compat.GHC.Exts.GHC908MemcpyPrimops"Raehik.Compat.Data.Primitive.TypesBytezap.Common.GenericBytezap.Common.TypeNatsRaehik.Compat.Data.Int.ByteSwap Raehik.Compat.Data.Word.ByteSwap1Raehik.Compat.GHC.Exts.GHC910UnalignedAddrPrimops)Raehik.Compat.Data.Primitive.Types.EndianBytezap.StructBytezap.Struct.TypeLits.BytesBytezap.Struct.Generic Bytezap.PokeBytezap.Write.Internal Bytezap.WriteBytezap.Poke.KnownLenBytezap.Poke.Derived.EndianBytezap.Poke.DerivedBytezap.Write.DerivedBytezap.Parser.Struct$Bytezap.Parser.Struct.TypeLits.BytesBytezap.Parser.Struct.Genericbytezap Paths_bytezapPPrimBS ByteStringMonoidemptyWrite KnownSizeOfSBSShortByteStringTTextghc-primGHC.PrimcopyAddrToAddrNonOverlapping# setAddrRange#(primitive-0.8.0.0-3BJsIjA2qPo7Gwazwu8k4hData.Primitive.TypessizeOf# alignment#indexByteArray#readByteArray#writeByteArray# setByteArray# indexOffAddr# readOffAddr# writeOffAddr# setOffAddr#sizeOfGTFoldMapCAdditionPlusSym1PlusSymnatVal'' natValInt byteSwapI16 byteSwapI32 byteSwapI64 byteSwapIbyteSwapindexWord8OffAddrAsWord16#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:$fReifyBytesW16bsGPokegPoke GPokeBase GPokeBaseSt GPokeBaseCGPokeBaseLenTF gPokeBase$fGPokekktagU1$fGPokekktagM1$fGPokekktag:*:$fGPokekktagM10$fGPokekktagM11unsafeRunPokeBSUptoN byteString byteArray#fromStructPoke toStructPoke $fMonoidPoke$fSemigroupPoke LengthType ExactLength MaxLengthwriteOp writeLengthwriteMax writeMaxExact writeExactMax writeCombine $fMonoidWrite$fSemigroupWrite runWriteBSrunWriteBSUptoN PokeKnownLenunPokeKnownLenmappend'mempty'runPokeKnownLenBSw16lew16bew32lew32bew64lew64bei16lei16bei32lei32bei64lei64beshortByteStringtextcharunsafePokeIndexedResultOKFailErrResI#Res#ParserSTParserIOParserParserT runParserT#ParserT#STModeIOModePureModeErr#Fail#OK#unsafeRunParserBsunsafeRunParserPtrunsafeRunParserFPtrunsafeRunParser' constParsesequenceParserslitwithLit withLitErrfirstNonMatchByteIdx unsafeByteAt$fFunctorParserT $fShowResultParseReifyBytesW8parseReifyBytesW8ParseReifyBytesW16parseReifyBytesW16ParseReifyBytesW32parseReifyBytesW32ParseReifyBytesW64parseReifyBytesW64$fParseReifyBytesW64idx:$fParseReifyBytesW32idx:$fParseReifyBytesW64idxbs$fParseReifyBytesW16idx:$fParseReifyBytesW32idxbs$fParseReifyBytesW8idx[]$fParseReifyBytesW8idx:$fParseReifyBytesW16idxbsReifyMaybeSymbolreifyMaybeSymbol ProdArityGParseCgParseCGParsegParse GParseBase GParseBaseSt GParseBaseC GParseBaseEGParseBaseLenTF gParseBase symbolVal''$fGParseCkktagcdcc0U1$fGParsekktagM1$fGParseCkTYPEtagcdccsi:*:$fReifyMaybeSymbolJust$fReifyMaybeSymbolNothing$fGParseCkktagcdccsiM1base Data.FoldablefoldMap getBinDir getDataDirgetDataFileName getDynLibDir getLibDir getLibexecDir getSysconfDirversionAddr#MutableByteArray# runWriteWith GHC.TypesCharIOGHC.ForeignPtrForeignPtrContentsGHC.Basepure ApplicativeType ghc-bignumGHC.Num.NaturalNatural