h,W M%      !"#$%&'()*+,-./0123456 7 8 9 : ; < = > ? @ A B C DEFGHIJ K L M N O P Q R S T U V W X Y Z[\]^_`abcdefghijklmnopqrstuvwxyz{|}~          !!"""""""""""""""""""###################################$$$$$$%1.0.0&None )1=> pbinrepCommon type error string for when you attempt to use a binrep instance at a sum data type GHC is asked to derive a non-sum instance, but the data type in question turns out to be a sum data type.No need to add the data type name here, since GHC's context includes the surrounding instance declaration.binrepCommon type error string for when you attempt to use a binrep instance at an empty data type (e.g. &', ()).None )1=>   None )1=> ( binrep4DerivingVia newtype for types which can borrow from Prim'.  None )1=> |binrep0 binrep1 None ")1=> cbinrepA single indexed parse error."binrepTop-level parse error.The final element is the concrete error. Prior elements should "contain" the error (i.e. be the larger part that the error occurred in).Really should be non-empty-- but by using List, we can use the empty list for Fail. Bit of a cute cheat.#binrep Map over the pos index type of a .$binrepShorthand for one parse error.%binrep*binrep Decode a  ByteString to  with an explicit encoding.;This is intended to be used with visible type applications.+binrep2binrepAny  value is always valid UTF-8.11 None )1=>7binrep Encode some + to the given character set using text-icu.No guarantees about correctness. Encodings are weird. e.g. Shift JIS's yen/backslash problem is apparently to do with OSs treating it differently. Expects a = that is confirmed valid for converting to the character set.The charset must be valid, or it's exception time. See text-icu.=binrepTODO Unsafely assume all s are valid Shift-JIS.9:7866789: None ")1=>?binrep7-bitAbinrepWe reuse UTF-8 encoding for ASCII, since it is a subset of UTF-8.Bbinrep: must be validated if you want to permit 7-bit ASCII only.??None )1=> FEDG DGFE None )1=>KbinrepAny  value is always valid UTF-32.JJ None )1=>RbinrepAny  value is always valid UTF-16.QQ None )1=>XbinrepEncode some validated text.YbinrepEncode some text to a bytestring, asserting that the resulting value is valid for the requested bytestring representation.;This is intended to be used with visible type applications:+let Right t = refine @UTF8 (Text.pack "hi"):t tt :: AsText UTF8 let Right bs = encodeToRep @'C t:t bsbs :: Refined 'C BytesXY9:78?6QJ1-)*+,-+,XY)*None )1=>Zbinrep:Types which can encode natural (positive integer) lengths.'Types must provide convert to and from 7, which is the most common type used for data lengths.[binrep&The maximum value the type can encode.\binrepThe name of the type, to display when used as part of a predicate.]binrepTurn an  length into an a.It is guaranteed that the  fits i.e. <= [ a.^binrepTurn an a into an  length.Don't worry if a may encode larger numbers than . I think other things will be breaking at that point. Or perhaps it's our responsibility to emit the runtime error? TODO.cbinrep6The unit can only encode 1 value -> lengths of 0 only.binrep/Byte ordering doesn't change how prefixes work.Z[\]^Z^]\[None )1=>aebinrepCommon type error string for when GHC is asked to derive a sum instance, but the data type in question turns out to be a non-sum data type.No need to add the data type name here, since GHC's context includes the surrounding instance declaration.fbinrepCommon type error string for when GHC is asked to derive a non-sum instance, but the data type in question turns out to be a sum data type.No need to add the data type name here, since GHC's context includes the surrounding instance declaration.effe*None )1=>None )1=>gbinrepConvert a parsing failure to an error, which also receives the parser position (as a , from the end of input).hbinrepThrow a parsing error, which also receives the parser position (as a , from the end of input).ghghNone )1=> iiNone )1=>jbinrepRun a parser, and return the result as well as the number of bytes it consumed.jjNone )1=>klmklmNone)1=> pbinrepI don't know how to pattern match in types without writing type families.tbinrepUsing this necessitates UndecidableInstances.ubinrepUsing this necessitates UndecidableInstances.vbinrepDefunctionalization symbol for x.This is required for parameterized type-level generics e.g. bytezap's +,.ybinrep6Reify a type's constant byte length to the term level.binrep(Deriving via this instance necessitates UndecidableInstances.yz{tuvsprwxoqnwxyz{vutsrqponNone )1=>#binrepconstant size putterbinrep)Serialize a term of the struct-like type a via its  instance.binrep%Look weird? Yeah. But it's correct :)binrep)Unit type serializes to nothing. How zen.binrep2Byte order is irrelevant for 8-bit (1-byte) words.binrep2Byte order is irrelevant for 8-bit (1-byte) words.binrep8-bit (1-byte) words do not require byte order in order to precisely define their representation.binrep8-bit (1-byte) words do not require byte order in order to precisely define their representation.None")1=>%binrepconstant size parserbinrepConsume .binrepdoesn't check lenbinrepTurn a 9 into a single error, or prepend it to any existing ones.Use when wrapping other getters.We reimplement cutting with a tweak. Otherwise, we'd have to join lists in the error case (instead of simply prepending).binrep)Serialize a term of the struct-like type a via its  instance.None")1=>+ binrepParse from binary.binrep=Emit a single error. Use with flatparse primitives that only -..binrepTurn a -.) into a single error. (Re-emits existing -/s.):Use when wrapping flatparse primitives that directly only -.. (It's fine to use with combinators if the combinator itself doesn't -/.)binrepTurn a -.9 into a single error, or prepend it to any existing ones.Use when wrapping other ters.We reimplement -0 with a tweak. Otherwise, we'd have to join lists in the error case (instead of simply prepending).binrep Parse any .binrepReturn the rest of the input.A plain unannotated bytestring isn't very useful -- you'll usually want to null-terminate or length-prefix it.Note that this _does_ perform work: we make a new bytestring so we don't rely on the input bytestring. To use the input bytestring directly, see Binrep.Type.Thin.binrepParse elements until EOF. Sometimes used at the "top" of binary formats.binrepParse tuples left-to-right.binrepUnit type parses nothing.binrep2Byte order is irrelevant for 8-bit (1-byte) words.binrep2Byte order is irrelevant for 8-bit (1-byte) words.binrep8-bit (1-byte) words do not require byte order in order to precisely define their representation.binrep8-bit (1-byte) words do not require byte order in order to precisely define their representation.#$%&'"! None)1=>0 binrep1DerivingVia wrapper for types which may derive a ! instance through an existing w, instance (i.e. it is known at compile time)Examples of such types include machine integers, and explicitly-sized types (e.g. Binrep.Type.Sized).binrep7Class for types with easily-calculated length in bytes.If it appears hard to calculate byte length for a given type (e.g. without first serializing it, then measuring serialized byte length), consider whether this type is a good fit for binrep.binrep8Calculate the serialized byte length of the given value.binrep6Measure the byte length of a term of the non-sum type a via its  instance.binrep2Measure the byte length of a term of the sum type a via its  instance.binrep2Measure the byte length of a term of the sum type a via its  instance.binrep_O(1)_ 12s store their own length.binrep0_O(n)_ Sum the length of each element of a list.binrep_O(1)_ Sum tuples.binrep_O(1)_ Unit type has length 0. y yNone)1=>4c binrep%Serialize a term of the non-sum type a via its  instance.binrep!Serialize a term of the sum type a via its  instance.binrep!Serialize a term of the sum type a via its 4 instance, without pre-parsing constructor names.binrepPut types refined with multiple predicates by wrapping the left predicate with the right. LOL REALLY?binrep)Unit type serializes to nothing. How zen.binrep$Serialize generically using generic .binrep2Byte order is irrelevant for 8-bit (1-byte) words.binrep2Byte order is irrelevant for 8-bit (1-byte) words.binrep8-bit (1-byte) words do not require byte order in order to precisely define their representation.binrep8-bit (1-byte) words do not require byte order in order to precisely define their representation.  3None )1=>4yz{#$%&'xtuvsprwxoqn"! None )1=>5bNone")1=>5binrep$Essentially runtime reflection of a  type to x.None")1=>6%None")1=>8binrepThe byte length of a count-prefixed type is the length of the prefix type (holding the length of the type) plus the length of the type.(Bit confusing. How to explain this? TODObinrep(We can know byte length at compile time if0 we know it for the prefix and the list-like.This is extremely unlikely, because then what counting are we even performing for the list-like? But it's a valid instance.None ")1=>:binrepNull-terminated data. Arbitrary length terminated with a null byte. Permits no null bytes inside the data.binrep4Null-terminated data may not contain any null bytes.binrepWe may parse any null-terminated data using a special flatparse combinator.The combinator doesn't permit distinguishing between the two possible failures: either there was no next null, or the inner parser didn't consume up to it.binrepSerialization of null-terminated data may be defined generally using the data's underlying serializer.None )1=>;binrepTurn a constructor name into a prefix tag by adding a null terminator.Not common in binary data representations, but safe and useful for debugging.reallyUnsafeRefine : safe assuming Haskell constructor names are UTF-8 with no null bytes allowed None")1=>=binrep:A type which is to be null-padded to a given total length. Given some a ::  n a, it is guaranteed that  a  l @n thus l @n   a  0 That is, the serialized stored data will not be longer than the total length.binrepAssert that term will fit.binrepRun a Getter a isolated to n bytes.!None )1=>>binrepNull-terminated data, which is then null-padded to the given length.Instantiate with  ByteString for a null-padded C string.binrep5Predicate for null-terminated, then null-padded data."None")1=>Cm binrep The length of a type-level list.binrep!Types which define a magic value.binrep8How to turn the type into a list of bytes (stored using s).binrepA unit data type representing a "magic number" via a phantom type.The phantom type unambiguously defines a bytestring at compile time. This depends on the type's kind. See  for details.This is defined using GADT syntax to permit labelling the phantom type kind as inferred, which effectively means hidden (not available for visible type applications). That kind is always evident from the type, so it's just nicer.binrepStrengthen the unit () to some  a.binrep Weaken a  a to the unit ().binrep*Type-level symbols are converted to UTF-8.binrepType-level naturals go as-is. (Make sure you don't go over 255, though!)binrepEfficiently parse a  a. Serialization constraints are included as we emit the expected bytestring in errors.binrepEfficiently serialize a  a.binrep4The byte length of a magic is known at compile time.#None")1=>LbinrepSee ghc-bignum internals at  GHC.Num.*.binrepA natural represented in binary as an ASCII string, where each character is a digit in the given base.2Only certain bases are supported: 2, 8, 10 and 16.4Hex parsing permits mixed case digits when parsing ( 1-9a-fA-F4), and serializes with lower-case ASCII hex digits.binrep Compare two s, ignoring base information.binrepSafe for types smaller than a .Uses ghc-bignum internals. Slightly unwrapped for better performance.One could perhaps write faster algorithms for smaller primitive types too... but performance increase would be minimal if even present.binrepParse an ASCII natural in the given base with the given digit parser.?Parses byte-by-byte. As such, it only supports bases up to 256.binrepGet the digits in the given number as rendered in the given base.Digits will be between 0-base. The return type must be sized to support this.>Base must be > 2. This is not checked. (Internal function eh.) Note the  return type. Returns [0]0 for 0 input. (This does not match ghc-bignum's  sizeInBase primitives!)binrep!May only be called with 0<=n<=15.binrep0Parse a hex (base 16) ASCII natural to any  type..Parses lower and upper case (mixed permitted).binrep0Parse a decimal (base 10) ASCII natural to any  type.binrep/Parse an octal (base 8) ASCII natural to any  type.binrep/Parse a binary (base 2) ASCII natural to any  type.binrepSerialize any term of an  type to hex (base 16) ASCII.Uses lower-case ASCII.binrepSerialize any term of an ! type to decimal (base 10) ASCII.binrepSerialize any term of an  type to octal (base 8) ASCII.binrepSerialize any term of an  type to binary (base 2) ASCII.binrep can use , size (but TODO what happens for negatives?)binrepTODO unsafe for 32-bit platformbinrepTODO unsafe for 32-bit platformbinrepThe bytelength of an  is the number of digits in the number in the given base. We can calculate this generally with great efficiency using GHC (ghc-bignum) primitives!  $None )1=>M4564574589:;9:;9:;<=>???@AAABCDEFGHIJKLMNNNONPNQRRRSRTUVWXYZ[\]^_`abcdefgh i j k l m n o p q r s t u vwxyz{| } ~                        !!"""""""""""""""""""###################################$$$$$$********4(99.944444binrep-1.0.0-inplaceBinrep.Util.ByteOrderBinrep.Common.Class.TypeErrors$Binrep.Common.Via.Generically.NonSumBinrep.Common.Via.PrimBinrep.Example.TgaBinrep.Get.ErrorBinrep.Type.Text.InternalBinrep.Type.Text.Encoding.Utf8"Binrep.Type.Text.Encoding.ShiftJisBinrep.Type.Text.Encoding.AsciiBinrep.Type.Text.Encoding.Utf32Binrep.Type.Text.Encoding.Utf16Binrep.Type.TextBinrep.Type.Prefix.InternalBinrep.Util.Generic(Raehik.Compat.FlatParse.Basic.CutWithPos"Raehik.Compat.FlatParse.Basic.Prim(Raehik.Compat.FlatParse.Basic.WithLength Util.TypeNats Binrep.CBLenBinrep.Put.StructBinrep.Get.Struct Binrep.Get Binrep.BLen Binrep.PutBinrep.Type.ThinBinrep.Type.SizedBinrep.Type.Prefix.SizeBinrep.Type.Prefix.CountBinrep.Type.NullTerminatedBinrep.GenericBinrep.Type.NullPadded"Binrep.Type.Derived.NullTermPaddedBinrep.Type.MagicBinrep.Type.AsciiNatBinrep.Example.Sumbinrep Data.VoidVoid GHC.GenericsV1 Paths_binrepBytezap.Struct.Generic GPokeBaseFPFailErrorcuttingB ByteStringBinrepbase GHC.ByteOrder ByteOrder BigEndian LittleEndian$bytezap-1.6.0-5RPk6Jthf6G6m14HZOLNty)Raehik.Compat.Data.Primitive.Types.Endian ByteOrdered unByteOrderedENoSumENoEmptyGenericallyNonSumunGenericallyNonSumViaPrim unViaPrim ImageType NoImageDataUncompColorMappedUncompTrueColorUncompBWRLEColorMapped RLETrueColorRLEBW ColorMapType NoColorMap HasColorMapHeader imageType colorMapTypeidLenParseErrorSingleparseErrorSingleTextparseErrorSinglePos ParseErrormapParseErrorSinglePos parseError1parseErrorTextGenericFieldBld#parseErrorTextGenericNoCstrMatchBldparseErrorTextGenericSumTagBld$fShowParseErrorSingleDecodedecodeEncodeencode'AsTextBytes decodeTextwrapUnsafeDecoderUtf8$fRefineTYPEUtf8Text$fDecodeTYPEUtf8$fEncodeTYPEUtf8$fPredicateTYPEUtf8ShiftJisencodeViaTextICUencodeViaTextICU'decodeViaTextICUdecodeViaTextICU'$fDecodeTYPEShiftJis$fEncodeTYPEShiftJis$fRefineTYPEShiftJisText$fPredicateTYPEShiftJisAscii$fDecodeTYPEAscii$fEncodeTYPEAscii$fRefineTYPEAsciiText$fPredicateTYPEAscii EndianSuffixEndianBELE$fStrengthenByteOrdered$fWeakenByteOrderedUtf32$fRefineTYPEUtf32Text$fDecodeTYPEUtf32$fDecodeTYPEUtf320$fEncodeTYPEUtf32$fEncodeTYPEUtf320$fPredicateTYPEUtf32Utf16$fRefineTYPEUtf16Text$fDecodeTYPEUtf16$fDecodeTYPEUtf160$fEncodeTYPEUtf16$fEncodeTYPEUtf160$fPredicateTYPEUtf16encode encodeToRepLenNat LenNatMax LenNatNamelenToNatnatToLen$fLenNatWord64$fLenNatWord32$fLenNatWord16 $fLenNatWord8 $fLenNatUnit$fLenNatByteOrderedEUnexpectedNonSumEUnexpectedSumcut'err'anyPrimparseWithLengthnatVal'' natValInt natValWordNothingXJustXGCBLenCaseMaybeMaybeEq GCBLenSumGCBLenCBLenGenericNonSumCBLenGenericSumCBLenSymIsCBLenCBLencblencblen# cblenProxy#$fIsCBLenTYPEByteOrdered$fIsCBLenTYPEInt64$fIsCBLenTYPEWord64$fIsCBLenTYPEInt32$fIsCBLenTYPEWord32$fIsCBLenTYPEInt16$fIsCBLenTYPEWord16$fIsCBLenTYPEInt8$fIsCBLenTYPEWord8$fIsCBLenTYPEUnit$fIsCBLenTYPETuple2$fIsCBLenTYPERefined$fIsCBLenTYPEGenericallyNonSumPutCputCPutterCrunPutCputGenericStruct $fPutCTuple2 $fPutCUnit $fPutCPoke$fPutCIdentity $fPutCEither $fPutCVoid $fPutCViaPrim $fPutCRefined$fPutCGenericallyNonSum$fPutCGenerically$fGPokeBaseFUNPutC$fPutCByteOrdered$fPutCByteOrdered0$fPutCByteOrdered1$fPutCByteOrdered2 $fPutCInt8 $fPutCWord8GetCgetCGetterC runGetCBsunsafeRunGetCPtrgetGenericStruct$fGetCIdentity $fGetCViaPrim $fGetCUnit $fGetCRefined$fGetCGenericallyNonSum$fGetCGenerically$fGParseBaseFUNGetC$fGetCByteOrdered$fGetCByteOrdered0$fGetCByteOrdered1$fGetCByteOrdered2 $fGetCInt8 $fGetCWord8ViaGetC unViaGetCGetgetGetterrunGet runGettergetGenericNonSum getGenericSumgetGenericSumRawerr1cut1cutting1fpToBzbzToFpgetPrim $fGetRefined $fGetViaPrim$fGetByteString $fGetList $fGetTuple2 $fGetUnit $fGetIdentity $fGetEither $fGetVoid$fGenericFOnCstrFUNGet$fGetGenericallyNonSum$fGenericTraverseFUNGet $fGetViaGetC$fGetByteOrdered$fGetByteOrdered0$fGetByteOrdered1$fGetByteOrdered2 $fGetInt8 $fGetWord8ViaCBLen unViaCBLenBLenblenblenGenericNonSumblenGenericSumblenGenericSumRaw$fBLenByteString $fBLenList $fBLenTuple2 $fBLenUnit $fBLenEither $fBLenVoid $fBLenRefined$fBLenGenericallyNonSum$fGenericFoldMapFUNBLen$fBLenViaCBLen$fBLenByteOrdered $fBLenInt64 $fBLenWord64 $fBLenInt32 $fBLenWord32 $fBLenInt16 $fBLenWord16 $fBLenInt8 $fBLenWord8ViaPutC unViaPutCPutputPutterrunPutputGenericNonSum putGenericSumputGenericSumRaw $fPutRefined$fPutByteString $fPutList $fPutTuple2 $fPutUnit $fPutPoke $fPutIdentity $fPutEither $fPutVoid $fPutViaPrim$fPutGenericallyNonSum$fGenericFoldMapFUNPut $fPutViaPutC$fPutByteOrdered$fPutByteOrdered0$fPutByteOrdered1$fPutByteOrdered2 $fPutInt8 $fPutWord8ThinunThin $fGetThin $fGenericThin $fDataThin $fShowThin $fReadThin$fEqThin $fOrdThin$fSemigroupThin $fMonoidThin $fNFDataThin$fIsStringThin $fIsListThin $fBLenThin $fPutThin $fWeakenThin$fStrengthenThinSizedSize$fRefineTYPESizea$fPredicateTYPESizeGetSizegetSize SizePrefixed SizePrefix$fRefineTYPESizePrefixa$fPredicateTYPESizePrefix $fGetSizeThin$fGetSizeByteStringGetCountgetCount CountPrefixed CountPrefix$fRefineTYPECountPrefixf$fRefine1TYPETYPECountPrefixf$fPredicateTYPECountPrefix $fPutRefined1$fBLenRefined1$fIsCBLenTYPERefined1 $fGetRefined1$fGetCountListNullTerminated NullTerminate#$fRefineTYPENullTerminateByteString$fPredicateTYPENullTerminatenullTermCstrPfxTag NullPaddedNullPad$fRefineTYPENullPada$fPredicateTYPENullPadNullTermPadded NullTermPadLengthMagical MagicBytesMagic$fStrengthenMagic $fWeakenMagic$fMagicalSymbolsym$fMagicalListbs $fGetCMagic $fPutCMagic$fIsCBLenTYPEMagic$fGenericMagic $fDataMagic $fShowMagic $fEqMagic $fGetMagic $fPutMagic $fBLenMagic HasBaseOps sizeInBase#AsciiNatasciiNatComparesizeInBaseWordSizegetAsciiNatByByte unsafeDigitsasciiBytesToNatparseBinaryAsciiDigitparseOctalAsciiDigitparseDecimalAsciiDigitparseHexAsciiDigitunsafeHexDigitToAsciiLower $fGetRefined0 $fGetRefined2 $fPutRefined0 $fPutRefined2$fRefineTYPEAsciiNata$fPredicateTYPEAsciiNat$fHasBaseOpsInt$fHasBaseOpsInt64$fHasBaseOpsInt32$fHasBaseOpsInt16$fHasBaseOpsInt8$fHasBaseOpsWord64$fHasBaseOpsWord32$fHasBaseOpsWord16$fHasBaseOpsWord8$fHasBaseOpsNatural$fHasBaseOpsWordSumTypeSumType1SumType2 $fGetSumType$fGenericSumType $fShowSumTypetext-2.1.1-inplaceData.Text.InternalTextghc-prim GHC.TypesIntR:LenNatMaxByteOrdered getBinDir getDataDirgetDataFileName getDynLibDir getLibDir getLibexecDir getSysconfDirversion(flatparse-0.5.1.0-I9dwywoqBlCGtL0MyOX5X1FlatParse.Common.PositionPosGeneric finishGetterCBytezap.Parser.StructResult"Raehik.Compat.Data.Primitive.TypesPrim' Data.FoldablefoldMap GHC.Classes<=GHC.Num->= ghc-bignumGHC.Num.NaturalNaturalWordGHC.BaseNonEmptyNumGHC.RealIntegral