h&~i      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                           !!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""##################################################$ Safe-Inferred&)*0125689:;<=>??binrep"A hex bytestring looks like this: 00 01 89 8a FEff. You can mix and match capitalization and spacing, but I prefer to space each byte, full caps.binrepParse a byte formatted as two hex digits e.g. EF. You _must_ provide both nibbles e.g. 0F, not F. They cannot be spaced e.g. E F is invalid.Returns a value 0-255, so can fit in any Num type that can store that.binrepPretty print to default format  00 12 AB FF': space between each byte, all caps.This format I consider most human readable. I prefer caps to draw attention to this being data instead of text (you don't see that many capital letters packed together in prose).binrep!Pretty print to "compact" format 0012abff (often output by hashers).   Safe-Inferred&)*0125689:;<=>?nbinrepCommon type error string for when GHC attempts to derive an binrep instance for a (the?) void datatype V1.binrep/How to turn a constructor name into a byte tag. Safe-Inferred&)*0125689:;<=>? binrep+Put with inlined checks via an environment.binrep:Attempt to serialize to binary with the given environment.binrepSerialize to binary.binrepRun the serializer.binrepHelper for wrapping a BinRep into a  BinRepWith (for encoding). binrep.Run the serializer with the given environment.#binrepSerialize the bytestring as-is.Careful -- the only way you're going to be able to parse this is to read until EOF.%binrepSerialize each element in order. No length indicator, so parse until either error or EOF. Usually not what you want, but sometimes used at the "top" of binary formats.&binrepImpossible to serialize .    Safe-Inferred&)*0125689:;<=>?(binrep Byte order.)binrep2big endian, MSB first. e.g. most network protocols*binrep;little endian, MSB last. e.g. most processor architectures(*)(*) Safe-Inferred')*0125689:;<=>?0binrep Convert some  i where i >= 0 to a .,This is intended for wrapping the output of  functions.*underflows if you call it with a negative  :)/01/01 Safe-Inferred()*0125689:;<=>?I4binrep'Efficiently reify a list of type-level % bytes to to a bytestring builder.Attempting to reify a ) larger than 255 results in a type error.This is about as far as one should go for pointless performance here, I should think.23456787864523 Safe-Inferred&)*0125689:;<=>?!3binrepHelper definitions for using the given type to store byte lengths.Byte lengths must be non-negative. Thus, the ideal representation is a .. However, most underlying types that we use ($% , lists) store their length in s. By similarly storing an 6 ourselves, we could potentially improve performance.I like both options, and don't want to give up either. So we provide helpers via a typeclass so that the user doesn't ever have to think about the underlying type.+For simplicity, documentation may consider a to be an "unsigned" type. For example, underflow refers to a negative a result.binrep!Safe blen subtraction, returning  for negative results.Regular subtraction should only be used when you have a guarantee that it won't underflow.binrep Convert some  i where i >= 0 to a blen.,This is intended for wrapping the output of  functions.binrep Convert some  w where w <= maxBound  a@ to a blen.binrep Convert some  n where n <= maxBound  a@ to a blen. Safe-Inferred()*0125689:;<=>?*binrepNewtype wrapper for defining  instances which are allowed to assume the existence of a valid  family instance.binrepThe length in bytes of a value of the given type can be known on the cheap e.g. by reading a length field, or using compile time information.Some binary representation building blocks require the notion of length in bytes in order to handle, e.g. null padding. One may always obtain this by serializing the value, then reading out the length of the output bytestring. But in most cases, we can be much more efficient.Certain primitives have a size known at compile time, irrelevant of the value. A - is always 8 bytes; some data null-padded to n bytes is exactly n bytes long.For simple ADTs, it's often possible to calculate length in bytes via pattern matching and some numeric operations. Very little actual work.This type class enables each type to implement its own efficient method of byte length calculation. Aim to write something that plainly feels more efficient than full serialization. If that doesn't feel possible, you might be working with a type ill-suited for binary representation.8A thought: Some instances could be improved by reifying . But it would mess up all the deriving, and it feels like too minor an improvement to be worthwhile supporting, writing a bunch of newtype wrappers, etc.binrep?The length in bytes of any value of the given type is constant.Many binary representation primitives are constant, or may be designed to "store" their size in their type. This is a stronger statement about their length than just .-This is now an associated type family of the : type class in hopes of simplifying the binrep framework.binrep,The length in bytes of the serialized value.The default implementation reifies the constant length for the type. If a type-wide constant length is not defined, it will fail at compile time.binrep6Reify a type's constant byte length to the term level.binrep O(n)binrep#Impossible to put a byte length to .   Safe-Inferred')*0125689:;<=>?._ binrep=A type that can be parsed from binary given some environment.Making this levity polymorphic makes things pretty strange, but is useful. See Binrep.Example.FileTable.binrep-Parse from binary with the given environment.binrepParse from binary.binrepexpected first, got secondbinrepexpected first, got secondbinrepexpected first, got secondbinrep known failbinrepparse fail (where you parse a larger object, then a smaller one in it)binrep#ran out of input, needed precisely n bytes for this part (n > 0)binrep2TODO confirm correct operation (error combination)binrepParse heterogeneous lists in order. No length indicator, so either fails or succeeds by reaching EOF. Probably not what you usually want, but sometimes used at the "top" of binary formats.binrepImpossible to parse .binrepdatatype name   Safe-Inferred')*0125689:;<=>?/binrepI don't know how to pattern match in types without writing type families.  Safe-Inferred&)*0125689:;<=>?1BbinrepThe length in bytes of a 3-able type is the length of the serialized term.Do not use this in  instances. It's intended as a proof, and potentially for testing purposes. Calculating length in bytes shouldn't involve serializing (it should be fast and use minimal memory).8   Safe-Inferred')*0125689:;<=>?2   Safe-Inferred')*0125689:;<=>?7p binrep(simple, some varints have the same valuebinrep*each integer has exactly 1 varint encodingbinrepon=continue, off=endbinrepon=end, off=continuebinrep-A variable-length unsigned integer (natural).The base algorithm is to split the natural into groups of 7 bits, and use the MSB to indicate whether another octet follows. You must specify a handful of type variables, which select precise varint behaviour beyond this. See their documentation for details.You may select the type to use varnats at, but error handling isn't provided: negatives won't work correctly, and overflow cannot be detected. So most of the time, you probably want Natural and .Some examples:@ ' ' ') matches VLQ.@ ' ' '* matches LEB128, protobuf.@ ' ' '* matches Git's varints.@ ' ' '* matches BPS's varints.binrep3Git varint (cont=on), BPS (beat patches) (cont=off)binrep$protobuf (cont=on), LEB128 (cont=on).not truly infinite length since shifters take , but practically infinitebinrep0TODO nothing to test against - unsure if correctbinrep VLQ (cont=on)   Safe-Inferred'")*0125689:;<=>?8 Safe-Inferred'")*0125689:;<=>?:binrepSafety: we assert actual length is within expected length (in order to calculate how much padding to parse).Note that the consumer probably doesn't care about the content of the padding, just that the data is chunked correctly. I figure we care about correctness here, so it'd be nice to know about the padding well-formedness (i.e. that it's all nulls).(TODO maybe better definition via isolate Safe-Inferred')*0125689:;<=>?: Safe-Inferred()*0125689:;<=>?>binrep!Types which define a magic value.binrep*How to turn the type into a list of bytes.binrepAn empty data type representing a magic number (a constant bytestring) via a phantom type.The phantom type variable unambiguously defines a short, constant bytestring. A handful of types are supported for using magics conveniently, e.g. for pure ASCII magics, you may use a  type-level string.binrep&Strengthen the unit to some 'Magic a'.binrepWeaken a 'Magic a' to the unit. Perhaps you prefer pattern matching on () over Magic, or wish a weak type to be fully divorced from its binrep origins.binrepType-level symbols are turned into their Unicode codepoints - but multibyte characters aren't handled, so they'll simply be overlarge bytes, which will fail further down.binrepType-level naturals go as-is. (Make sure you don't go over 255, though!) Safe-Inferred')*0125689:;<=>?B binrep Restricted reflected version of maxBound.binrep Shortcut.binrepGrouping for matching a signedness and size to a Haskell integer data type.binrep(Machine integer size in number of bytes.binrepMachine integer sign.binrepsignedbinrepunsignedbinrepWrapper type grouping machine integers (sign, size) along with an explicit endianness.The internal representation is selected via a type family to correspond to the relevant Haskell data type, so common overflow behaviour should match. We derive lots of handy instances, so you may perform regular arithmetic on pairs of these types. For example:255 + 1 :: I 'U 'I1 e0255 + 1 :: I 'U 'I2 e256binrep5Signed machine integers can be idealized as integers.binrep7Unsigned machine integers can be idealized as naturals.None()*0125689:;<=>?CbinrepHoly shit - no need to do a smart constructor, it's simply impossible to instantiate invalid values of this type! Safe-Inferred(")*0125689:;<=>?Ebinrep;A bytestring using the given representation, stored in the Text type.binrepBytestring representation.binrepC-style bytestring. Arbitrary length, terminated with a null byte. Permits no null bytes inside the bytestring.binrepPascal-style bytestring. Length defined in a prefixing integer of given size and endianness.binrep5A C-style bytestring must not contain any null bytes. Safe-Inferred)")*0125689:;<=>?Nbinrep Decode a  ByteString to  with an explicit encoding.;This is intended to be used with visible type applications.binrep?PbinrepA  represented in binary as an ASCII string, where each character a is a digit in the given base (> 1). instances display the stored number in the given base. If the base has a common prefix (e.g. 0x for hex), it is used.binrep Compare two s with arbitrary bases.binrepThe bytelength of an  is the number of digits in the number in the given base. We can calculate this generically with great efficiency using GHC primitives. Safe-Inferred&)*0125689:;<=>?Q( Safe-Inferred&)*0125689:;<=>?Q Safe-Inferred&)*0125689:;<=>?TbinrepTODO * can't do generic because BPS doesn't store command list length, instead requiring a dynamic check on every command * wonder if this is better or more efficient that using a  for the length, same as metadata, or storing the end size as a . * maybe two diff types of varint, +ve and -ve. unclear from spec * perhaps store the varint type(s) as a type var, to allow switching between efficient machine ints and safe , Natural!binrepOptional metadata. According to the specification, this should "officially" be XML version 1.0 encoding UTF-8 data, but anything goes. Safe-Inferred&)*0125689:;<=>?VbinrepApparently from the Sfio library, also similar (but not identical) to BPS's varints.binrep(0 and meaningless unless instr is a COPYbinrepFirst 3 bytes are VCD each with their MSB on.binrepTODO annoying and impacts rest of format. forcing to 0x00 to simplify  & Safe-Inferred')*0125689:;<=>?Wt Safe-Inferred')*0125689:;<=>?ZNbinrep? without the value (only used as a proxy). Lets us push our s into one place.binrep? without the value (only used as a proxy). Lets us push our s into one place.binrep? without the value (only used as a proxy). Lets us push our s into one place.binrep.Get the record name for a selector if present.On the type level, a 'Maybe Symbol' is stored for record names. But the reification is done using  fromMaybe "". So we have to inspect the resulting string to determine whether the field uses record syntax or not. (Silly.) Safe-Inferred')*0125689:;<=>?\binrep2Get the name of the constructor of a sum datatype.binrep$Any datatype, constructor or record.binrep,Refuse to derive instance for void datatype.binrep$Product type fields are consecutive.binrepField.binrepEmpty constructor.binrep4Constructor sums are differentiated by a prefix tag. Safe-Inferred')*0125689:;<=>?^jbinrepTODO: Want to return an Either [(String, Text)] indicating the constructors and their expected tags tested, but needs fiddling (can't use  Alternative1). Pretty minor, but Aeson does it and it's nice.binrep/Refuse to derive instance for empty data types.binrepThe empty constructor trivially succeeds without parsing anything.binrepTODO: Non-sum data types.binrep4Constructor sums are differentiated by a prefix tag.   Safe-Inferred')*0125689:;<=>?`binrep$Any datatype, constructor or record.binrep,Refuse to derive instance for void datatype.binrep$Product type fields are consecutive.binrepField.binrepEmpty constructor.binrep4Constructor sums are differentiated by a prefix tag. Safe-Inferred&)*0125689:;<=>?ebinrepObtain the tag for a sum type value by applying a function to the constructor name, and reading the result as a hexadecimal number.binrep8Successfully parse exactly one result, or runtime error.binrepObtain the tag for a sum type value using the constructor name directly (with a null terminator).This is probably not what you want in a binary representation, but it's safe and may be useful for debugging.The refine force is safe under the assumption that Haskell constructor names are UTF-8 with no null bytes allowed. I haven't confirmed that, but I'm fairly certain.binrep0Default generic derivation configuration, using .binrepSpecial generic derivation configuration you may use for non-sum data types.When generically deriving binrep instances for a non-sum type, you may like to ignore sum tag handling. You could use , but this will silently change behaviour if your type becomes a sum type. This configuration will generate clear runtime errors when used with a sum type. By selecting  for the sum tag type, consumption actions (serializing, getting length in bytes) will runtime error, while generation actions (parsing) will hit the , instance first and always safely error out.  Safe-Inferred&)*0125689:;<=>?f#  ! Safe-Inferred()*0125689:;<=>?f  " Safe-Inferred&)*0125689:;<=>?hbinrepThe naturals in tars are sized octal ASCII digit strings that end with a null byte (and may start with leading ASCII zeroes). The size includes the terminating null, so you get n-1 digits. What a farce.Don't use this constructor directly! The size must be checked to ensure it fits.binrepNo need to check for underflow etc. as TarNat guarantees good sizing.  # Safe-Inferred')*0125689:;<=>?iW'(()*+,-./01234567899:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                           !!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""##################################################&&&&&&&&binrep-0.3.0-inplaceBinrep.Extra.HexByteStringBinrep.Generic.Internal Binrep.PutBinrep.Type.Common Binrep.UtilBinrep.Type.ByteBinrep.BLen.Internal.AsBLen Binrep.BLen Binrep.GetBinrep.Generic.CBLenBinrepBinrep.Type.VectorBinrep.Type.VarintBinrep.Type.SizedBinrep.Type.NullPaddedBinrep.Type.Magic.UTF8Binrep.Type.MagicBinrep.Type.IntBinrep.Type.LenPfxBinrep.Type.ByteStringBinrep.Type.TextBinrep.Type.AsciiNatBinrep.Example.FileTableData.Aeson.Extra.SizedVectorHaskpatch.Format.BpsHaskpatch.Format.Vcdiff Util.GenericBinrep.Generic.PutBinrep.Generic.GetBinrep.Generic.BLenBinrep.GenericBinrep.Example.WavBinrep.Example.TiffBinrep.Example.TarBinrep.ExampleB ByteString Paths_binrep HexByteStringHexunHexparseHexByteString parseHexByteprettyHexByteString prettyHexByteprettyHexByteStringCompact $fToJSONHex $fFromJSONHex $fShowHex $fToJSONHex0$fFromJSONHex0 $fShowHex0 $fGenericHex $fDataHex$fEqHexGErrRefuseVoidCfgcSumTag cSumTagEq cSumTagShowPutWithputWithPutputBuilderrunPut runBuilder putWithout runPutWith $fPutInt8 $fPutWord8$fPutByteString$fPut(,)$fPut[] $fPutVoid $fPutWithr[] EndiannessBELE$fGenericEndianness$fDataEndianness$fShowEndianness$fEqEndiannesstshow posIntToNatnatVal''WriteReifiedByteswriteReifiedBytes ReifyBytes reifyBytesLengthByteValbyteVal $fByteVal255 $fByteVal254 $fByteVal253 $fByteVal252 $fByteVal251 $fByteVal250 $fByteVal249 $fByteVal248 $fByteVal247 $fByteVal246 $fByteVal245 $fByteVal244 $fByteVal243 $fByteVal242 $fByteVal241 $fByteVal240 $fByteVal239 $fByteVal238 $fByteVal237 $fByteVal236 $fByteVal235 $fByteVal234 $fByteVal233 $fByteVal232 $fByteVal231 $fByteVal230 $fByteVal229 $fByteVal228 $fByteVal227 $fByteVal226 $fByteVal225 $fByteVal224 $fByteVal223 $fByteVal222 $fByteVal221 $fByteVal220 $fByteVal219 $fByteVal218 $fByteVal217 $fByteVal216 $fByteVal215 $fByteVal214 $fByteVal213 $fByteVal212 $fByteVal211 $fByteVal210 $fByteVal209 $fByteVal208 $fByteVal207 $fByteVal206 $fByteVal205 $fByteVal204 $fByteVal203 $fByteVal202 $fByteVal201 $fByteVal200 $fByteVal199 $fByteVal198 $fByteVal197 $fByteVal196 $fByteVal195 $fByteVal194 $fByteVal193 $fByteVal192 $fByteVal191 $fByteVal190 $fByteVal189 $fByteVal188 $fByteVal187 $fByteVal186 $fByteVal185 $fByteVal184 $fByteVal183 $fByteVal182 $fByteVal181 $fByteVal180 $fByteVal179 $fByteVal178 $fByteVal177 $fByteVal176 $fByteVal175 $fByteVal174 $fByteVal173 $fByteVal172 $fByteVal171 $fByteVal170 $fByteVal169 $fByteVal168 $fByteVal167 $fByteVal166 $fByteVal165 $fByteVal164 $fByteVal163 $fByteVal162 $fByteVal161 $fByteVal160 $fByteVal159 $fByteVal158 $fByteVal157 $fByteVal156 $fByteVal155 $fByteVal154 $fByteVal153 $fByteVal152 $fByteVal151 $fByteVal150 $fByteVal149 $fByteVal148 $fByteVal147 $fByteVal146 $fByteVal145 $fByteVal144 $fByteVal143 $fByteVal142 $fByteVal141 $fByteVal140 $fByteVal139 $fByteVal138 $fByteVal137 $fByteVal136 $fByteVal135 $fByteVal134 $fByteVal133 $fByteVal132 $fByteVal131 $fByteVal130 $fByteVal129 $fByteVal128 $fByteVal127 $fByteVal126 $fByteVal125 $fByteVal124 $fByteVal123 $fByteVal122 $fByteVal121 $fByteVal120 $fByteVal119 $fByteVal118 $fByteVal117 $fByteVal116 $fByteVal115 $fByteVal114 $fByteVal113 $fByteVal112 $fByteVal111 $fByteVal110 $fByteVal109 $fByteVal108 $fByteVal107 $fByteVal106 $fByteVal105 $fByteVal104 $fByteVal103 $fByteVal102 $fByteVal101 $fByteVal100 $fByteVal99 $fByteVal98 $fByteVal97 $fByteVal96 $fByteVal95 $fByteVal94 $fByteVal93 $fByteVal92 $fByteVal91 $fByteVal90 $fByteVal89 $fByteVal88 $fByteVal87 $fByteVal86 $fByteVal85 $fByteVal84 $fByteVal83 $fByteVal82 $fByteVal81 $fByteVal80 $fByteVal79 $fByteVal78 $fByteVal77 $fByteVal76 $fByteVal75 $fByteVal74 $fByteVal73 $fByteVal72 $fByteVal71 $fByteVal70 $fByteVal69 $fByteVal68 $fByteVal67 $fByteVal66 $fByteVal65 $fByteVal64 $fByteVal63 $fByteVal62 $fByteVal61 $fByteVal60 $fByteVal59 $fByteVal58 $fByteVal57 $fByteVal56 $fByteVal55 $fByteVal54 $fByteVal53 $fByteVal52 $fByteVal51 $fByteVal50 $fByteVal49 $fByteVal48 $fByteVal47 $fByteVal46 $fByteVal45 $fByteVal44 $fByteVal43 $fByteVal42 $fByteVal41 $fByteVal40 $fByteVal39 $fByteVal38 $fByteVal37 $fByteVal36 $fByteVal35 $fByteVal34 $fByteVal33 $fByteVal32 $fByteVal31 $fByteVal30 $fByteVal29 $fByteVal28 $fByteVal27 $fByteVal26 $fByteVal25 $fByteVal24 $fByteVal23 $fByteVal22 $fByteVal21 $fByteVal20 $fByteVal19 $fByteVal18 $fByteVal17 $fByteVal16 $fByteVal15 $fByteVal14 $fByteVal13 $fByteVal12 $fByteVal11 $fByteVal10 $fByteVal9 $fByteVal8 $fByteVal7 $fByteVal6 $fByteVal5 $fByteVal4 $fByteVal3 $fByteVal2 $fByteVal1 $fByteVal0$fWriteReifiedBytes:$fWriteReifiedBytes[]$fReifyBytesnsAsBLen safeBLenSub posIntToBLen wordToBLen# natToBLen$fAsBLenNatural $fAsBLenInt WithCBLen unWithCBLenBLenCBLenblenBLenT typeNatToBLencblen $fBLenInt64 $fBLenWord64 $fBLenInt32 $fBLenWord32 $fBLenInt16 $fBLenWord16 $fBLenInt8 $fBLenWord8$fBLenByteString $fBLen(,)$fBLen[] $fBLenVoid$fBLenWithCBLen$fBLenWithCBLen0GetWithgetWithGetget EGenericSumEGenericSumTagEGenericSumTagNoMatchEGeneric EGenericFieldEBaseENoVoidEFailEEof EExpectedByte EOverlong EExpected EFailNamed EFailParseERanOutEGettereBasegetEWrapgetEBasecutEBaserunGet runGetter runGetWith $fGetInt8 $fGetWord8$fGetByteString$fGet(,)$fGet[] $fGetVoid$fEqEGenericSum$fShowEGenericSum$fGenericEGenericSum$fEqE$fShowE $fGenericE $fEqEGeneric$fShowEGeneric$fGenericEGeneric $fEqEBase $fShowEBase$fGenericEBaseNothingXJustXGCBLenCaseMaybeMaybeEq GCBLenSumGCBLen CBLenGeneric blenViaPut getVector $fGetVector $fPutVector $fBLenVectorVarintContinuationvarintContinueEncoding Redundant BijectiveContinuationBitBehaviour OnContinues OffContinuesVarnat getVarnattestVarintCont setVarintCont $fVarintContinuationOffContinues$fVarintContinuationOnContinues $fPutVarnat $fPutVarnat0 $fGetVarnat $fGetVarnat0 $fGetVarnat1 $fGetVarnat2 $fEqVarnat $fOrdVarnat $fEnumVarnat $fNumVarnat $fRealVarnat$fIntegralVarnat $fShowVarnatSizedSize$fPredicateTYPESizea $fGetRefined $fPutRefined $fBLenRefined NullPaddedNullPad getNNulls$fPredicateTYPENullPada MagicUTF8symValencodeStringUtf8$fGetMagicUTF8$fPutMagicUTF8$fBLenMagicUTF8$fShowMagicUTF8Magical MagicBytesSymbolAsCharList'SymbolAsCharListCharListUnicodeCodepointsSymbolUnicodeCodepointsMagic$fStrengthenMagic $fWeakenMagic$fMagicalSymbolsym $fMagical[]ns $fGetMagic $fPutMagic $fBLenMagic$fGenericMagic $fDataMagic $fShowMagic $fEqMagicMaxBoundIMaxIRepISizeI1I2I4I8ISignSUIgetI$fGetI$fPutI$fGetI0$fPutI0$fGetI1$fPutI1$fGetI2$fPutI2$fGetI3$fPutI3$fGetI4$fPutI4$fGetI5$fPutI5$fGetI6$fPutI6$fGetI7$fPutI7$fGetI8$fPutI8$fGetI9$fPutI9$fGetI10$fPutI10$fGetI11$fPutI11$fGetI12$fPutI12$fBLenI $fStrengthenI $fWeakenI$fStrengthenI0 $fWeakenI0 $fGenericI$fGenericISize $fDataISize $fShowISize $fEqISize$fGenericISign $fDataISign $fShowISign $fEqISign $fFromJSONI $fToJSONI $fIntegralI$fEnumI$fRealI$fNumI $fBoundedI$fOrdI$fEqI$fShowI$fDataILenPfxunLenPfxvsEqasLenPfxlenPfxFromList lenPfxSize getLenPfx $fGetLenPfx $fPutLenPfx $fBLenLenPfx$fStrengthenLenPfx$fWeakenLenPfx $fShowLenPfx $fEqLenPfx$fGenericLenPfx AsByteStringRepCPascal getCString putCString$fPredicateRepPascalByteString$fPredicateRepCByteString $fGetRefined0 $fPutRefined0$fBLenRefined0 $fGenericRep $fDataRep $fShowRep$fEqRepDecodedecodeEncodeAsTextUTF8UTF16UTF32ASCIISJISencode encodeToRepdecodeViaTextICU$fPredicateEncodingSJISText$fPredicateEncodingASCIIText$fPredicateEncodingUTF32Text$fPredicateEncodingUTF16Text$fPredicateEncodingUTF8Text $fEncodeSJIS $fEncodeUTF32$fEncodeUTF320 $fEncodeUTF16$fEncodeUTF160 $fEncodeASCII $fEncodeUTF8 $fDecodeSJIS $fDecodeUTF32$fDecodeUTF320 $fDecodeUTF16$fDecodeUTF160 $fDecodeUTF8$fGenericEncoding$fDataEncoding$fShowEncoding $fEqEncodingAsciiNat getAsciiNatasciiNatCompareoctalFromAsciiDigitnatToAsciiBytesasciiBytesToNatdigits $fGetAsciiNat $fPutAsciiNat$fBLenAsciiNat$fShowAsciiNat$fShowAsciiNat0$fShowAsciiNat1$fShowAsciiNat2$fGenericAsciiNat$fDataAsciiNat $fEqAsciiNat $fOrdAsciiNatEntry entryName entryDataTableunTableBS putFileTable prepEntry getFileTablegetEntryw8i#exBs$fGetWithAddrRepAddr#Entry$fStrengthenEntry $fWeakenEntry $fGetTable $fPutTable$fGenericEntry $fEqEntry $fShowEntry $fEqEntry0 $fShowEntry0$fFromJSONVector$fToJSONVector BpsFooterbpsFooterSourceChecksumbpsFooterTargetChecksumbpsFooterPatchChecksum BpsCommandBpsCommandSourceReadBpsCommandTargetReadBpsCommandSourceCopyBpsCommandTargetCopyBpsMeta BpsVarintBpsbpsMagic bpsSourceSize bpsTargetSize bpsMetadata bpsCommands bpsFooter VcdiffVarintInstr Instr0Noop Instr1Add Instr2Run Instr3Copy InstrTripleinstrTripleInstrinstrTripleSizeinstrTripleMode InstrCodeinstrCodeTriple1instrCodeTriple2DeltadeltaIndicator deltaAddRun deltaInstrs deltaCopyWindowwindowIndicator windowDeltaHeader headerMagicheaderIndicatorVcdiff vcdiffHeader datatypeName'conName'selName' selName'' GetConName getConNameGPutSumgputsumGPutgput putGeneric $fGPutkM1 $fGPutkV1 $fGPutk:*: $fGPutkK1 $fGPutkU1 $fGPutSumkM1 $fGPutSumk:+:$fGetConNamekM1$fGetConNamek:+: $fGPutk:+:GGetCSumggetCSumGGetSggetSGGetCggetCGGetDggetD getGeneric $fGGetCkV1 $fGGetDkM1 $fGGetSkM1 $fGGetSk:*: $fGGetSkU1 $fGGetCkM1 $fGGetCSumkM1$fGGetCSumk:+: $fGGetCk:+:GBLenSumgblensumGBLengblen blenGeneric $fGBLenkM1 $fGBLenkV1 $fGBLenk:*: $fGBLenkK1 $fGBLenkU1 $fGBLenSumkM1$fGBLenSumk:+: $fGBLenk:+: EDerivedSumInstanceWithNonSumCfgcfg cSumTagHexcSumTagNullTermcDefcNoSum+$fExceptionEDerivedSumInstanceWithNonSumCfg&$fShowEDerivedSumInstanceWithNonSumCfg WavHeaderwavHeaderMagicwavHeaderChunkSize wavHeaderFmtwavHeaderFmtChunkMarkerwavHeaderFmtTypewavHeaderChannelsW16W32End$fGetWavHeader$fPutWavHeader$fBLenWavHeader$fGenericWavHeader$fDataWavHeader$fShowWavHeader $fEqWavHeader TiffMagicTiffBody tiffBodyMagic tiffBodyExIntTiffW8tiffLEbstiffBEbs $fGetTiffBody $fPutTiffBody$fBLenTiffBody $fGetTiff $fPutTiff $fBLenTiff $fShowTiff$fGenericTiffBody$fShowTiffBody $fEqTiffBody$fDataTiffBodyTar tarFileName tarFileModetarFileUIDOwnertarFileUIDGrouptarFileFileSizetarFileLastModTarNat getTarNat $fGetTarNat $fPutTarNat $fBLenTarNat$fGetTar$fPutTar $fBLenTar $fGenericTar $fShowTar$fEqTar$fGenericTarNat $fShowTarNat $fEqTarNatDXBrSumDCSDCSDCS1DCS2DCS3DCS4DCS5DSSdss1dss2dss3dss4dss5DUDVbrCfgDCS$fGetDU$fPutDU$fBLenDU$fGetDSS$fPutDSS $fBLenDSS$fGetDCS$fPutDCS $fBLenDCS$fGetDX$fPutDX$fBLenDX $fGenericDX$fDataDX$fShowDX$fEqDX $fGenericDCS $fDataDCS $fShowDCS$fEqDCS $fGenericDSS $fDataDSS $fShowDSS$fEqDSS $fGenericDU$fDataDU$fShowDU$fEqDU $fGenericDV$fDataDVbase Data.VoidVoidghc-prim GHC.TypesInt ghc-bignumGHC.Num.NaturalNatural Data.Foldablelength GHC.MaybeNothingGHC.PrimWord#GHC.WordWord64GHC.Num.IntegerIntegerSymbol text-1.2.5.0Data.Text.InternalTextencode' decodeTextByteswrapUnsafeDecoderencodeViaTextICUGHC.ShowShowversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDir GHC.Generics datatypeNameGHC.Err undefinedconNameselName forceRead