F"      !None"QCompile-time constant; True on LE, False on BE, and compile-time error otherwise."""None 4<CN'jTypes whose hashes can be compared across platforms. This is somewhat like a limited, but cross-platform #.Instances are expected to be universally-unique, and should be generated randomly. Type parameters can be hashed together using $, like: instance (StableHashable b) => StableHashable (A b) where typeHash = TypeHash $ 530184177609460980 `xor` (typeHashWord (typeHash :: TypeHash b))When   instances change, the ` must be changed to a new random value. This lets us "version" a set of hashes; if we store a ' along with a set of hashes in program A , in program B/ we can compare the stored value with our own 0 and verify that hashes we generate in program B can be meaningfully compared.Note, obviously this doesn't ensure that values were hashed with the same hashing algorithm, and you should come up with your own means to serialize that information if you need to.#A value that uniquely identifies a ? type. This serves to both version a type with respect to its  > instance, and distinguish types from each other (similar to %7) across program runs, platforms and library versions.eA class for defining how a hash function consumes input data. Bytes are fed to these methods in our  O instances, which promise to call these methods in a platform-independent way. Instances of  only need to define , but may additionally handle mix-ing in larger word chunks for performance reasons. For instance a hash function which operates on four bytes at a time might make use of , and perhaps in  pad with three additional 0s.Endianness is normalized in  Y instances, so these mix methods can expect to receive identical words across platforms.Mix in one byte.&Mix in a 2-byte word. Defaults to two * on bytes from most to least significant.'Mix in a 4-byte word. Defaults to four * on bytes from most to least significant. &Mix in a 8-byte word. Defaults to two 2 on 32-byte words from most to least significant. {A class of types that can be converted into a hash value. We expect all instances to display "good" hashing properties (wrLt avalanche, bit independence, etc.) when passed to an ideal hash function.We try to ensure that bytes are extracted from values in a way that is portable across architectures (where possible), and straightforward to replicate on other platforms and in other languages. Portable instances are also instances of ", and non-portable instances are NOTE"-ed in instance docs here as well.See the section  #principled"Defining Hashable instances"/ for details of what we expect from instances. Add the bytes from the second argument into the hash, producing a new hash value. This is essentially a left fold of the methods of & over individual bytes extracted from a.For some instances of , this method might be a complete hashing algorithm, or might comprise the core of a hashing algorithm (perhaps with some final mixing), or might do something completely apart from hashing (e.g. simply cons bytes into a list for debugging).5Implementations must ensure that, for the same data:  Word16/32/64& arguments passed into the methods of , and...the choice of mix function itself......are consistent across architectures of different word size and endianness. For example do not define an instance which conditionally implements   only on 64-bit architectures.BHash a value using the standard spec-prescribed 32-bit seed value.  hashFNV32 =  . fnv32 .    hHash a value using the standard spec-prescribed 64-bit seed value. This may be slow on 32-bit machines.  hashFNV64 =  . fnv64 .     (mixConstructor n h = h `mix8` (0xFF - n)&mThe value here depends on whether we're on a 32 or 64-bit platform. See also the instance documentation for  .'mThe value here depends on whether we're on a 32 or 64-bit platform. See also the instance documentation for  .( hash = const . mixConstructor 0) 2hash h = hash h . \b-> if b then (1::Word8) else 0*NOTEE: No promise of stability across runs or platforms. Implemented via +.,The (now deprecated)  versionTags& field is ignored, and we follow the -/ instance which does not ignore trailing zeros..NOTEE: No promise of stability across runs or platforms. Implemented via /.0NOTE=: no promise of consistency across platforms or GHC versions.1NOTE5: no promise of consistency across runs or platforms.2Hash a Char as big endian UTF-16. Note that Char permits values in the reserved unicode range U+D800 to U+DFFF; these Char values are added to the hash just as if they were valid 16-bit characters.3eHere we hash each byte of the array in turn. If using this to hash some data stored internally as a  ByteArray#, be aware that depending on the size and alignment requirements of that data, as well as the endianness of your machine, this might result in different hash values across different architectures.4Lazy Text, hashed as big endian UTF-16.5Strict Text, hashed as big endian UTF-16.6%Exposed only in bytestring >= v0.10.47Lazy  ByteString8Strict  ByteString9fHash a Double as IEEE 754 double-precision format bytes. This is terribly slow; direct complaints to /http://hackage.haskell.org/trac/ghc/ticket/4092:eHash a Float as IEEE 754 single-precision format bytes. This is terribly slow; direct complaints to /http://hackage.haskell.org/trac/ghc/ticket/4092;NOTE: WordF has platform-dependent size. When hashing on 64-bit machines if the Word value to be hashed falls in the 32-bit Word range, we first cast it to a Word32. This should help ensure that programs that are correct across architectures will also produce the same hash values.<NOTE: IntF has platform-dependent size. When hashing on 64-bit machines if the Int value to be hashed falls in the 32-bit Int range, we first cast it to an Int32. This should help ensure that programs that are correct across architectures will also produce the same hash values.= 4hash s a = s `hash` numerator a `hash` denominator a> hash _ _ = absurdExposed only in GHC 7.10?The Natural's value is represented in 32-bit chunks (at least one, for zero; but no more than necessary), then bytes are added to the hash from most to least significant (including all initial padding 0s). Finally  0' is called on the resulting hash value.Exposed only in GHC 7.10@The BigNat's value is represented in 32-bit chunks (at least one, for zero; but no more than necessary), then bytes are added to the hash from most to least significant (including all initial padding 0s). Finally  0' is called on the resulting hash value.Exposed only in GHC 7.10.A Arbitrary-precision integers are hashed as follows: the magnitude is represented with 32-bit chunks (at least one, for zero; but no more than necessary), then bytes are added to the hash from most to least significant (including all initial padding 0s). Finally . is called on the resulting hash value, with  (1::Word8) if the Integer was negative, otherwise with 0.B  (C h64) b = C $ (h64 `$` fromIntegral b) *  D  (E h32) b = E $ (h32 `$` fromIntegral b) *  CFGEHI JKLMNOPQRSTUVWXYZ[\]^_`BConstructor number. We recommend starting from 0 and incrementing.%Hash state value to mix our byte intoNew hash stateabcdefghijklmnopqrstuvwxyz{|}~&'()*,.0123456789:;<=>?@ABDBCFGEHI JKLMNOPQRSTUVWXYZ[\]^_`abcdefCFGEHI   JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~&'()*,.0123456789:;<=>?@ABDNonebytes remaining for a full m#we'll accumulate this as we consumeQA 128-bit secret key. This should be generated randomly and must be kept secret. (An implementation of 64-bit siphash-2-4.This function is fast on 64-bit machines, and provides very good hashing properties and protection against hash flooding attacks.!(An implementation of 64-bit siphash-2-4.This function is fast on 64-bit machines, and provides very good hashing properties and protection against hash flooding attacks. ! ! !None"  !"  !        !"#$%&$'($%)*+,-.$/012345$6789:;<=>?@ABCDEFGHIJKLMKNMOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~hasha_IekbvBtrHirLXHTa1LwXjpData.HashablerMachDepsData.Hashabler.InternalData.Hashabler.SipHashStableHashabletypeHashTypeHash typeHashWord HashStatemix8mix16mix32mix64HashablehashHash128 hashWord128_0 hashWord128_1Hash64 hashWord64Hash32 hashWord32 fnvPrime32 fnvPrime64fnvOffsetBasis32fnvOffsetBasis64 hashFNV32 hashFNV64mixConstructor typeHashOftypeHashOfProxySipKey siphash64 siphash128 littleEndianbaseData.Typeable.InternalTypeable Data.BitsxorTypeRep$fStableHashableWord$fStableHashableInt $fHashable()$fHashableBool$fHashableUnique Data.Unique hashUnique$fHashableVersionghc-prim GHC.ClassesEq$fHashableStableNameSystem.Mem.StableNamehashStableName$fHashableTypeRep$fHashableThreadId$fHashableChar$fHashableByteArray$fHashableText$fHashableText0$fHashableShortByteString$fHashableByteString$fHashableByteString0$fHashableDouble$fHashableFloat$fHashableWord $fHashableInt$fHashableRatio$fHashableVoid$fHashableNatural$fHashableBigNat$fHashableInteger$fHashStateFNV64FNV64$fHashStateFNV32FNV32fnv64fnv32 getThreadIdcoerceInt32Word32coerceInt64Word64 _byteSwap32 _byteSwap64bytes16bytes32bytes64 _bytes64_64 _bytes64_32words32 floatToWord doubleToWordcastViaSTArray _signBytemagnitudeAsWordmixSignificantMachWord64_hash32Integer _integerWordshash32BigNatByteshash32BigNatByteArrayBytes_hash32_Int_64_hash32_Word_64 typeRepInt32hashByteStringhashText hashByteArray hashFoldl'hashLeftUnfolded $fStableHashable(,,,,,,,,,,,,,,)$fStableHashable(,,,,,,,,,,,,,)$fStableHashable(,,,,,,,,,,,,)$fStableHashable(,,,,,,,,,,,)$fStableHashable(,,,,,,,,,,)$fStableHashable(,,,,,,,,,)$fStableHashable(,,,,,,,,)$fStableHashable(,,,,,,,)$fStableHashable(,,,,,,)$fStableHashable(,,,,,)$fStableHashable(,,,,)$fStableHashable(,,,)$fStableHashable(,,)$fStableHashable(,)$fStableHashable()$fStableHashableEither$fStableHashableMaybe$fStableHashable[]$fStableHashableOrdering$fStableHashableBool$fStableHashableVersion$fStableHashableChar$fStableHashableByteArray$fStableHashableText$fStableHashableText0$fStableHashableShortByteString$fStableHashableByteString$fStableHashableByteString0$fStableHashableWord64$fStableHashableWord32$fStableHashableWord16$fStableHashableWord8$fStableHashableInt64$fStableHashableInt32$fStableHashableInt16$fStableHashableInt8$fStableHashableDouble$fStableHashableFloat$fStableHashableRatio$fStableHashableVoid$fStableHashableNatural$fStableHashableBigNat$fStableHashableInteger$fHashable(,,,,,,,,,,,,,,)$fHashable(,,,,,,,,,,,,,)$fHashable(,,,,,,,,,,,,)$fHashable(,,,,,,,,,,,)$fHashable(,,,,,,,,,,)$fHashable(,,,,,,,,,)$fHashable(,,,,,,,,)$fHashable(,,,,,,,)$fHashable(,,,,,,)$fHashable(,,,,,)$fHashable(,,,,)$fHashable(,,,)$fHashable(,,) $fHashable(,)$fHashableEither$fHashableMaybe $fHashable[]$fHashableOrdering$fHashableWord64$fHashableWord32$fHashableWord16$fHashableWord8$fHashableInt64$fHashableInt32$fHashableInt16$fHashableInt8bytesRemaininginlenSipStatev0v1v2v3mPartrotlsipRoundsiphashForWord$fHashStateSipState