diff --git a/src/libraries/System.IO.Hashing/ref/System.IO.Hashing.cs b/src/libraries/System.IO.Hashing/ref/System.IO.Hashing.cs index 73f3a644506c8..88312d3dcf73d 100644 --- a/src/libraries/System.IO.Hashing/ref/System.IO.Hashing.cs +++ b/src/libraries/System.IO.Hashing/ref/System.IO.Hashing.cs @@ -59,6 +59,19 @@ protected virtual void GetHashAndResetCore(System.Span destination) { } public bool TryGetCurrentHash(System.Span destination, out int bytesWritten) { throw null; } public bool TryGetHashAndReset(System.Span destination, out int bytesWritten) { throw null; } } + public sealed partial class XxHash128 : System.IO.Hashing.NonCryptographicHashAlgorithm + { + public XxHash128() : base (default(int)) { } + public XxHash128(long seed) : base (default(int)) { } + public override void Append(System.ReadOnlySpan source) { } + protected override void GetCurrentHashCore(System.Span destination) { } + public static byte[] Hash(byte[] source) { throw null; } + public static byte[] Hash(byte[] source, long seed) { throw null; } + public static byte[] Hash(System.ReadOnlySpan source, long seed = (long)0) { throw null; } + public static int Hash(System.ReadOnlySpan source, System.Span destination, long seed = (long)0) { throw null; } + public override void Reset() { } + public static bool TryHash(System.ReadOnlySpan source, System.Span destination, out int bytesWritten, long seed = (long)0) { throw null; } + } public sealed partial class XxHash3 : System.IO.Hashing.NonCryptographicHashAlgorithm { public XxHash3() : base (default(int)) { } diff --git a/src/libraries/System.IO.Hashing/ref/System.IO.Hashing.csproj b/src/libraries/System.IO.Hashing/ref/System.IO.Hashing.csproj index ddc1732ad255d..3d8b365b9625e 100644 --- a/src/libraries/System.IO.Hashing/ref/System.IO.Hashing.csproj +++ b/src/libraries/System.IO.Hashing/ref/System.IO.Hashing.csproj @@ -8,6 +8,10 @@ + + + + diff --git a/src/libraries/System.IO.Hashing/ref/System.IO.Hashing.netcoreapp.cs b/src/libraries/System.IO.Hashing/ref/System.IO.Hashing.netcoreapp.cs new file mode 100644 index 0000000000000..4b77ad5945da1 --- /dev/null +++ b/src/libraries/System.IO.Hashing/ref/System.IO.Hashing.netcoreapp.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// ------------------------------------------------------------------------------ +// Changes to this file must follow the https://aka.ms/api-review process. +// ------------------------------------------------------------------------------ + +namespace System.IO.Hashing +{ + public sealed partial class XxHash128 : System.IO.Hashing.NonCryptographicHashAlgorithm + { + [System.CLSCompliantAttribute(false)] + public System.UInt128 GetCurrentHashAsUInt128() { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt128 HashToUInt128(System.ReadOnlySpan source, long seed = 0) { throw null; } + } +} diff --git a/src/libraries/System.IO.Hashing/src/System.IO.Hashing.csproj b/src/libraries/System.IO.Hashing/src/System.IO.Hashing.csproj index 38264827037d7..31c39cf023e48 100644 --- a/src/libraries/System.IO.Hashing/src/System.IO.Hashing.csproj +++ b/src/libraries/System.IO.Hashing/src/System.IO.Hashing.csproj @@ -15,11 +15,13 @@ System.IO.Hashing.XxHash32 + + Common\System\Numerics\Crc32ReflectedTable.cs diff --git a/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash128.cs b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash128.cs new file mode 100644 index 0000000000000..103e7ce6a659f --- /dev/null +++ b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash128.cs @@ -0,0 +1,446 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +// Based on the XXH128 implementation from https://github.com/Cyan4973/xxHash. + +using System.Buffers.Binary; +using System.Diagnostics; +using System.Numerics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using static System.IO.Hashing.XxHashShared; + +namespace System.IO.Hashing +{ + /// Provides an implementation of the XXH128 hash algorithm for generating a 128-bit hash. + /// + /// For methods that persist the computed numerical hash value as bytes, + /// the value is written in the Big Endian byte order. + /// +#if NET5_0_OR_GREATER + [SkipLocalsInit] +#endif + public sealed unsafe class XxHash128 : NonCryptographicHashAlgorithm + { + /// XXH128 produces 16-byte hashes. + private new const int HashLengthInBytes = 16; + + private State _state; + + /// Initializes a new instance of the class using the default seed value 0. + public XxHash128() : this(0) + { + } + + /// Initializes a new instance of the class using the specified seed. + public XxHash128(long seed) : base(HashLengthInBytes) + { + Initialize(ref _state, (ulong)seed); + } + + /// Computes the XXH128 hash of the provided data. + /// The data to hash. + /// The XXH128 128-bit hash code of the provided data. + /// is null. + public static byte[] Hash(byte[] source) => Hash(source, seed: 0); + + /// Computes the XXH128 hash of the provided data using the provided seed. + /// The data to hash. + /// The seed value for this hash computation. + /// The XXH128 128-bit hash code of the provided data. + /// is null. + public static byte[] Hash(byte[] source, long seed) + { +#if NET6_0_OR_GREATER + ArgumentNullException.ThrowIfNull(source); +#else + if (source is null) + { + throw new ArgumentNullException(nameof(source)); + } +#endif + + return Hash(new ReadOnlySpan(source), seed); + } + + /// Computes the XXH128 hash of the provided data using the optionally provided . + /// The data to hash. + /// The seed value for this hash computation. The default is zero. + /// The XXH128 128-bit hash code of the provided data. + public static byte[] Hash(ReadOnlySpan source, long seed = 0) + { + byte[] result = new byte[HashLengthInBytes]; + Hash(source, result, seed); + return result; + } + + /// Computes the XXH128 hash of the provided data into the provided using the optionally provided . + /// The data to hash. + /// The buffer that receives the computed 128-bit hash code. + /// The seed value for this hash computation. The default is zero. + /// The number of bytes written to . + /// is shorter than (8 bytes). + public static int Hash(ReadOnlySpan source, Span destination, long seed = 0) + { + if (!TryHash(source, destination, out int bytesWritten, seed)) + { + ThrowDestinationTooShort(); + } + + return bytesWritten; + } + + /// Attempts to compute the XXH128 hash of the provided data into the provided using the optionally provided . + /// The data to hash. + /// The buffer that receives the computed 128-bit hash code. + /// When this method returns, contains the number of bytes written to . + /// The seed value for this hash computation. The default is zero. + /// if is long enough to receive the computed hash value (8 bytes); otherwise, . + public static bool TryHash(ReadOnlySpan source, Span destination, out int bytesWritten, long seed = 0) + { + if (destination.Length >= sizeof(ulong) * 2) + { + Hash128 hash = HashToHash128(source, seed); + WriteBigEndian128(hash, destination); + bytesWritten = HashLengthInBytes; + return true; + } + + bytesWritten = 0; + return false; + } + +#if NET7_0_OR_GREATER + /// Computes the XXH128 hash of the provided data. + /// The data to hash. + /// The seed value for this hash computation. The default is zero. + /// The computed XXH128 hash. + [CLSCompliant(false)] + public static UInt128 HashToUInt128(ReadOnlySpan source, long seed = 0) + { + Hash128 hash = HashToHash128(source, seed); + return new UInt128(hash.High64, hash.Low64); + } +#endif + + private static Hash128 HashToHash128(ReadOnlySpan source, long seed = 0) + { + uint length = (uint)source.Length; + fixed (byte* sourcePtr = &MemoryMarshal.GetReference(source)) + { + if (length <= 16) + { + return HashLength0To16(sourcePtr, length, (ulong)seed); + } + + if (length <= 128) + { + return HashLength17To128(sourcePtr, length, (ulong)seed); + } + + if (length <= MidSizeMaxBytes) + { + return HashLength129To240(sourcePtr, length, (ulong)seed); + } + + return HashLengthOver240(sourcePtr, length, (ulong)seed); + } + } + + /// Resets the hash computation to the initial state. + public override void Reset() + { + XxHashShared.Reset(ref _state); + } + + /// Appends the contents of to the data already processed for the current hash computation. + /// The data to process. + public override void Append(ReadOnlySpan source) + { + XxHashShared.Append(ref _state, source); + } + + /// Writes the computed 128-bit hash value to without modifying accumulated state. + /// The buffer that receives the computed hash value. + protected override void GetCurrentHashCore(Span destination) + { + Hash128 current = GetCurrentHashAsHash128(); + WriteBigEndian128(current, destination); + } + + private Hash128 GetCurrentHashAsHash128() + { + Hash128 current; + + if (_state.TotalLength > MidSizeMaxBytes) + { + // Digest on a local copy to ensure the accumulators remain unaltered. + ulong* accumulators = stackalloc ulong[AccumulatorCount]; + CopyAccumulators(ref _state, accumulators); + + fixed (byte* secret = _state.Secret) + { + DigestLong(ref _state, accumulators, secret); + current.Low64 = MergeAccumulators(accumulators, secret + SecretMergeAccsStartBytes, _state.TotalLength * Prime64_1); + current.High64 = MergeAccumulators(accumulators, secret + SecretLengthBytes - AccumulatorCount * sizeof(ulong) - SecretMergeAccsStartBytes, ~(_state.TotalLength * Prime64_2)); + } + } + else + { + fixed (byte* buffer = _state.Buffer) + { + current = HashToHash128(new ReadOnlySpan(buffer, (int)_state.TotalLength), (long)_state.Seed); + } + } + + return current; + } + +#if NET7_0_OR_GREATER + /// Gets the current computed hash value without modifying accumulated state. + /// The hash value for the data already provided. + [CLSCompliant(false)] + public UInt128 GetCurrentHashAsUInt128() + { + Hash128 current = GetCurrentHashAsHash128(); + return new UInt128(current.High64, current.Low64); + } +#endif + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void WriteBigEndian128(in Hash128 hash, Span destination) + { + ulong low = hash.Low64; + ulong high = hash.High64; + if (BitConverter.IsLittleEndian) + { + low = BinaryPrimitives.ReverseEndianness(low); + high = BinaryPrimitives.ReverseEndianness(high); + } + + ref byte dest0 = ref MemoryMarshal.GetReference(destination); + Unsafe.WriteUnaligned(ref dest0, high); + Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref dest0, new IntPtr(sizeof(ulong))), low); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static Hash128 HashLength0To16(byte* source, uint length, ulong seed) + { + if (length > 8) + { + return HashLength9To16(source, length, seed); + } + + if (length >= 4) + { + return HashLength4To8(source, length, seed); + } + + if (length != 0) + { + return HashLength1To3(source, length, seed); + } + + const ulong BitFlipL = DefaultSecretUInt64_8 ^ DefaultSecretUInt64_9; + const ulong BitFlipH = DefaultSecretUInt64_10 ^ DefaultSecretUInt64_11; + return new Hash128(XxHash64.Avalanche(seed ^ BitFlipL), XxHash64.Avalanche(seed ^ BitFlipH)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static Hash128 HashLength1To3(byte* source, uint length, ulong seed) + { + Debug.Assert(length >= 1 && length <= 3); + + // When source.Length == 1, c1 == source[0], c2 == source[0], c3 == source[0] + // When source.Length == 2, c1 == source[0], c2 == source[1], c3 == source[1] + // When source.Length == 3, c1 == source[0], c2 == source[1], c3 == source[2] + byte c1 = *source; + byte c2 = source[length >> 1]; + byte c3 = source[length - 1]; + + uint combinedl = ((uint)c1 << 16) | ((uint)c2 << 24) | c3 | (length << 8); + + uint combinedh = BitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); + const uint SecretXorL = (unchecked((uint)DefaultSecretUInt64_0) ^ (uint)(DefaultSecretUInt64_0 >> 32)); + const uint SecretXorH = (unchecked((uint)DefaultSecretUInt64_1) ^ (uint)(DefaultSecretUInt64_1 >> 32)); + ulong bitflipl = SecretXorL + seed; + ulong bitfliph = SecretXorH - seed; + ulong keyedLo = combinedl ^ bitflipl; + ulong keyedHi = combinedh ^ bitfliph; + + return new Hash128(XxHash64.Avalanche(keyedLo), XxHash64.Avalanche(keyedHi)); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static Hash128 HashLength4To8(byte* source, uint length, ulong seed) + { + Debug.Assert(length >= 4 && length <= 8); + + seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; + + uint inputLo = ReadUInt32LE(source); + uint inputHi = ReadUInt32LE(source + length - 4); + ulong input64 = inputLo + ((ulong)inputHi << 32); + ulong bitflip = (DefaultSecretUInt64_2 ^ DefaultSecretUInt64_3) + seed; + ulong keyed = input64 ^ bitflip; + + ulong m128High = Multiply64To128(keyed, Prime64_1 + (length << 2), out ulong m128Low); + + m128High += (m128Low << 1); + m128Low ^= (m128High >> 3); + + m128Low = XorShift(m128Low, 35); + m128Low *= 0x9FB21C651E98DF25UL; + m128Low = XorShift(m128Low, 28); + m128High = Avalanche(m128High); + + return new Hash128(m128Low, m128High); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static Hash128 HashLength9To16(byte* source, uint length, ulong seed) + { + Debug.Assert(length >= 9 && length <= 16); + ulong bitflipl = (DefaultSecretUInt64_4 ^ DefaultSecretUInt64_5) - seed; + ulong bitfliph = (DefaultSecretUInt64_6 ^ DefaultSecretUInt64_7) + seed; + ulong inputLo = ReadUInt64LE(source); + ulong inputHi = ReadUInt64LE(source + length - 8); + ulong m128High = Multiply64To128(inputLo ^ inputHi ^ bitflipl, Prime64_1, out ulong m128Low); + + m128Low += (ulong)(length - 1) << 54; + inputHi ^= bitfliph; + + m128High += sizeof(void*) < sizeof(ulong) ? + (inputHi & 0xFFFFFFFF00000000UL) + Multiply32To64((uint)inputHi, Prime32_2) : + inputHi + Multiply32To64((uint)inputHi, Prime32_2 - 1); + + m128Low ^= BinaryPrimitives.ReverseEndianness(m128High); + + ulong h128High = Multiply64To128(m128Low, Prime64_2, out ulong h128Low); + h128High += m128High * (ulong)Prime64_2; + + h128Low = Avalanche(h128Low); + h128High = Avalanche(h128High); + return new Hash128(h128Low, h128High); + } + + private static Hash128 HashLength17To128(byte* source, uint length, ulong seed) + { + Debug.Assert(length >= 17 && length <= 128); + + ulong accLow = length * Prime64_1; + ulong accHigh = 0; + + switch ((length - 1) / 32) + { + default: // case 3 + Mix32Bytes(ref accLow, ref accHigh, source + 48, source + length - 64, DefaultSecretUInt64_12, DefaultSecretUInt64_13, DefaultSecretUInt64_14, DefaultSecretUInt64_15, seed); + goto case 2; + case 2: + Mix32Bytes(ref accLow, ref accHigh, source + 32, source + length - 48, DefaultSecretUInt64_8, DefaultSecretUInt64_9, DefaultSecretUInt64_10, DefaultSecretUInt64_11, seed); + goto case 1; + case 1: + Mix32Bytes(ref accLow, ref accHigh, source + 16, source + length - 32, DefaultSecretUInt64_4, DefaultSecretUInt64_5, DefaultSecretUInt64_6, DefaultSecretUInt64_7, seed); + goto case 0; + case 0: + Mix32Bytes(ref accLow, ref accHigh, source, source + length - 16, DefaultSecretUInt64_0, DefaultSecretUInt64_1, DefaultSecretUInt64_2, DefaultSecretUInt64_3, seed); + break; + } + + return AvalancheHash(accLow, accHigh, length, seed); + } + + private static Hash128 HashLength129To240(byte* source, uint length, ulong seed) + { + Debug.Assert(length >= 129 && length <= 240); + + ulong accLow = length * Prime64_1; + ulong accHigh = 0; + + Mix32Bytes(ref accLow, ref accHigh, source + (32 * 0), source + (32 * 0) + 16, DefaultSecretUInt64_0, DefaultSecretUInt64_1, DefaultSecretUInt64_2, DefaultSecretUInt64_3, seed); + Mix32Bytes(ref accLow, ref accHigh, source + (32 * 1), source + (32 * 1) + 16, DefaultSecretUInt64_4, DefaultSecretUInt64_5, DefaultSecretUInt64_6, DefaultSecretUInt64_7, seed); + Mix32Bytes(ref accLow, ref accHigh, source + (32 * 2), source + (32 * 2) + 16, DefaultSecretUInt64_8, DefaultSecretUInt64_9, DefaultSecretUInt64_10, DefaultSecretUInt64_11, seed); + Mix32Bytes(ref accLow, ref accHigh, source + (32 * 3), source + (32 * 3) + 16, DefaultSecretUInt64_12, DefaultSecretUInt64_13, DefaultSecretUInt64_14, DefaultSecretUInt64_15, seed); + + accLow = Avalanche(accLow); + accHigh = Avalanche(accHigh); + + uint bound = ((length - (32 * 4)) / 32); + if (bound != 0) + { + Mix32Bytes(ref accLow, ref accHigh, source + (32 * 4), source + (32 * 4) + 16, DefaultSecret3UInt64_0, DefaultSecret3UInt64_1, DefaultSecret3UInt64_2, DefaultSecret3UInt64_3, seed); + if (bound >= 2) + { + Mix32Bytes(ref accLow, ref accHigh, source + (32 * 5), source + (32 * 5) + 16, DefaultSecret3UInt64_4, DefaultSecret3UInt64_5, DefaultSecret3UInt64_6, DefaultSecret3UInt64_7, seed); + if (bound == 3) + { + Mix32Bytes(ref accLow, ref accHigh, source + (32 * 6), source + (32 * 6) + 16, DefaultSecret3UInt64_8, DefaultSecret3UInt64_9, DefaultSecret3UInt64_10, DefaultSecret3UInt64_11, seed); + } + } + } + Mix32Bytes(ref accLow, ref accHigh, source + length - 16, source + length - 32, 0x4F0BC7C7BBDCF93F, 0x59B4CD4BE0518A1D, 0x7378D9C97E9FC831, 0xEBD33483ACC5EA64, 0 - seed); + + return AvalancheHash(accLow, accHigh, length, seed); + } + + private static Hash128 HashLengthOver240(byte* source, uint length, ulong seed) + { + Debug.Assert(length > 240); + + fixed (byte* defaultSecret = &MemoryMarshal.GetReference(DefaultSecret)) + { + byte* secret = defaultSecret; + if (seed != 0) + { + byte* customSecret = stackalloc byte[SecretLengthBytes]; + DeriveSecretFromSeed(customSecret, seed); + secret = customSecret; + } + + ulong* accumulators = stackalloc ulong[AccumulatorCount]; + InitializeAccumulators(accumulators); + + HashInternalLoop(accumulators, source, length, secret); + + Hash128 h128; + h128.Low64 = MergeAccumulators(accumulators, secret + SecretMergeAccsStartBytes, length * Prime64_1); + h128.High64 = MergeAccumulators(accumulators, secret + SecretLengthBytes - AccumulatorCount * sizeof(ulong) - SecretMergeAccsStartBytes, ~(length * Prime64_2)); + return h128; + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static Hash128 AvalancheHash(ulong accLow, ulong accHigh, uint length, ulong seed) + { + ulong h128Low = accLow + accHigh; + ulong h128High = (accLow * Prime64_1) + + (accHigh * Prime64_4) + + ((length - seed) * Prime64_2); + h128Low = Avalanche(h128Low); + h128High = 0ul - Avalanche(h128High); + return new Hash128(h128Low, h128High); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void Mix32Bytes(ref ulong accLow, ref ulong accHigh, byte* input1, byte* input2, ulong secret1, ulong secret2, ulong secret3, ulong secret4, ulong seed) + { + accLow += Mix16Bytes(input1, secret1, secret2, seed); + accLow ^= ReadUInt64LE(input2) + ReadUInt64LE(input2 + 8); + accHigh += Mix16Bytes(input2, secret3, secret4, seed); + accHigh ^= ReadUInt64LE(input1) + ReadUInt64LE(input1 + 8); + } + + [DebuggerDisplay("Low64: {" + nameof(Low64) + "}, High64: {" + nameof(High64) + "}")] + private struct Hash128 + { + public ulong Low64; + public ulong High64; + + public Hash128(ulong low64, ulong high64) + { + Low64 = low64; + High64 = high64; + } + } + } +} diff --git a/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash3.cs b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash3.cs index 51b4b4ce35ad3..525346246e80a 100644 --- a/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash3.cs +++ b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash3.cs @@ -5,18 +5,13 @@ using System.Buffers.Binary; using System.Diagnostics; -using System.Numerics; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; -#if NET7_0_OR_GREATER -using System.Runtime.Intrinsics; -using System.Runtime.Intrinsics.Arm; -using System.Runtime.Intrinsics.X86; -#endif +using static System.IO.Hashing.XxHashShared; namespace System.IO.Hashing { - /// Provides an implementation of the XXH3 hash algorithm. + /// Provides an implementation of the XXH3 hash algorithm for generating a 64-bit hash. /// /// For methods that persist the computed numerical hash value as bytes, /// the value is written in the Big Endian byte order. @@ -24,51 +19,10 @@ namespace System.IO.Hashing #if NET5_0_OR_GREATER [SkipLocalsInit] #endif - public sealed unsafe partial class XxHash3 : NonCryptographicHashAlgorithm + public sealed unsafe class XxHash3 : NonCryptographicHashAlgorithm { /// XXH3 produces 8-byte hashes. private new const int HashLengthInBytes = 8; - private const int StripeLengthBytes = 64; - private const int SecretLengthBytes = 192; - private const int SecretLastAccStartBytes = 7; - private const int SecretConsumeRateBytes = 8; - private const int SecretMergeAccsStartBytes = 11; - private const int NumStripesPerBlock = (SecretLengthBytes - StripeLengthBytes) / SecretConsumeRateBytes; - private const int AccumulatorCount = StripeLengthBytes / sizeof(ulong); - private const int MidSizeMaxBytes = 240; - private const int InternalBufferStripes = InternalBufferLengthBytes / StripeLengthBytes; - private const int InternalBufferLengthBytes = 256; - - /// The default secret for when no seed is provided. - /// This is the same as a custom secret derived from a seed of 0. - private static ReadOnlySpan DefaultSecret => new byte[] - { - 0xb8, 0xfe, 0x6c, 0x39, 0x23, 0xa4, 0x4b, 0xbe, 0x7c, 0x01, 0x81, 0x2c, 0xf7, 0x21, 0xad, 0x1c, - 0xde, 0xd4, 0x6d, 0xe9, 0x83, 0x90, 0x97, 0xdb, 0x72, 0x40, 0xa4, 0xa4, 0xb7, 0xb3, 0x67, 0x1f, - 0xcb, 0x79, 0xe6, 0x4e, 0xcc, 0xc0, 0xe5, 0x78, 0x82, 0x5a, 0xd0, 0x7d, 0xcc, 0xff, 0x72, 0x21, - 0xb8, 0x08, 0x46, 0x74, 0xf7, 0x43, 0x24, 0x8e, 0xe0, 0x35, 0x90, 0xe6, 0x81, 0x3a, 0x26, 0x4c, - 0x3c, 0x28, 0x52, 0xbb, 0x91, 0xc3, 0x00, 0xcb, 0x88, 0xd0, 0x65, 0x8b, 0x1b, 0x53, 0x2e, 0xa3, - 0x71, 0x64, 0x48, 0x97, 0xa2, 0x0d, 0xf9, 0x4e, 0x38, 0x19, 0xef, 0x46, 0xa9, 0xde, 0xac, 0xd8, - 0xa8, 0xfa, 0x76, 0x3f, 0xe3, 0x9c, 0x34, 0x3f, 0xf9, 0xdc, 0xbb, 0xc7, 0xc7, 0x0b, 0x4f, 0x1d, - 0x8a, 0x51, 0xe0, 0x4b, 0xcd, 0xb4, 0x59, 0x31, 0xc8, 0x9f, 0x7e, 0xc9, 0xd9, 0x78, 0x73, 0x64, - 0xea, 0xc5, 0xac, 0x83, 0x34, 0xd3, 0xeb, 0xc3, 0xc5, 0x81, 0xa0, 0xff, 0xfa, 0x13, 0x63, 0xeb, - 0x17, 0x0d, 0xdd, 0x51, 0xb7, 0xf0, 0xda, 0x49, 0xd3, 0x16, 0x55, 0x26, 0x29, 0xd4, 0x68, 0x9e, - 0x2b, 0x16, 0xbe, 0x58, 0x7d, 0x47, 0xa1, 0xfc, 0x8f, 0xf8, 0xb8, 0xd1, 0x7a, 0xd0, 0x31, 0xce, - 0x45, 0xcb, 0x3a, 0x8f, 0x95, 0x16, 0x04, 0x28, 0xaf, 0xd7, 0xfb, 0xca, 0xbb, 0x4b, 0x40, 0x7e, - }; - -#if DEBUG - static XxHash3() - { - // Make sure DefaultSecret is the custom secret derived from a seed of 0. - byte* secret = stackalloc byte[SecretLengthBytes]; - DeriveSecretFromSeed(secret, 0); - Debug.Assert(new Span(secret, SecretLengthBytes).SequenceEqual(DefaultSecret)); - - // Validate some relationships. - Debug.Assert(InternalBufferLengthBytes % StripeLengthBytes == 0); - } -#endif private State _state; @@ -80,21 +34,7 @@ public XxHash3() : this(0) /// Initializes a new instance of the class using the specified seed. public XxHash3(long seed) : base(HashLengthInBytes) { - _state.Seed = (ulong)seed; - - fixed (byte* secret = _state.Secret) - { - if (seed == 0) - { - DefaultSecret.CopyTo(new Span(secret, SecretLengthBytes)); - } - else - { - DeriveSecretFromSeed(secret, (ulong)seed); - } - } - - Reset(); + Initialize(ref _state, (ulong)seed); } /// Computes the XXH3 hash of the provided data. @@ -208,108 +148,14 @@ public static ulong HashToUInt64(ReadOnlySpan source, long seed = 0) /// Resets the hash computation to the initial state. public override void Reset() { - _state.BufferedCount = 0; - _state.StripesProcessedInCurrentBlock = 0; - _state.TotalLength = 0; - - fixed (ulong* accumulators = _state.Accumulators) - { - InitializeAccumulators(accumulators); - } + XxHashShared.Reset(ref _state); } /// Appends the contents of to the data already processed for the current hash computation. /// The data to process. public override void Append(ReadOnlySpan source) { - Debug.Assert(_state.BufferedCount <= InternalBufferLengthBytes); - - _state.TotalLength += (uint)source.Length; - - fixed (byte* buffer = _state.Buffer) - { - // Small input: just copy the data to the buffer. - if (source.Length <= InternalBufferLengthBytes - _state.BufferedCount) - { - source.CopyTo(new Span(buffer + _state.BufferedCount, source.Length)); - _state.BufferedCount += (uint)source.Length; - return; - } - - fixed (byte* secret = _state.Secret) - fixed (ulong* accumulators = _state.Accumulators) - fixed (byte* sourcePtr = &MemoryMarshal.GetReference(source)) - { - // Internal buffer is partially filled (always, except at beginning). Complete it, then consume it. - int sourceIndex = 0; - if (_state.BufferedCount != 0) - { - int loadSize = InternalBufferLengthBytes - (int)_state.BufferedCount; - - source.Slice(0, loadSize).CopyTo(new Span(buffer + _state.BufferedCount, loadSize)); - sourceIndex = loadSize; - - ConsumeStripes(accumulators, ref _state.StripesProcessedInCurrentBlock, NumStripesPerBlock, buffer, InternalBufferStripes, secret); - _state.BufferedCount = 0; - } - Debug.Assert(sourceIndex < source.Length); - - // Large input to consume: ingest per full block. - if (source.Length - sourceIndex > NumStripesPerBlock * StripeLengthBytes) - { - ulong stripes = (ulong)(source.Length - sourceIndex - 1) / StripeLengthBytes; - Debug.Assert(NumStripesPerBlock >= _state.StripesProcessedInCurrentBlock); - - // Join to current block's end. - ulong stripesToEnd = NumStripesPerBlock - _state.StripesProcessedInCurrentBlock; - Debug.Assert(stripesToEnd <= stripes); - Accumulate(accumulators, sourcePtr + sourceIndex, secret + ((int)_state.StripesProcessedInCurrentBlock * SecretConsumeRateBytes), (int)stripesToEnd); - ScrambleAccumulators(accumulators, secret + (SecretLengthBytes - StripeLengthBytes)); - _state.StripesProcessedInCurrentBlock = 0; - sourceIndex += (int)stripesToEnd * StripeLengthBytes; - stripes -= stripesToEnd; - - // Consume entire blocks. - while (stripes >= NumStripesPerBlock) - { - Accumulate(accumulators, sourcePtr + sourceIndex, secret, NumStripesPerBlock); - ScrambleAccumulators(accumulators, secret + (SecretLengthBytes - StripeLengthBytes)); - sourceIndex += NumStripesPerBlock * StripeLengthBytes; - stripes -= NumStripesPerBlock; - } - - // Consume complete stripes in the last partial block. - Accumulate(accumulators, sourcePtr + sourceIndex, secret, (int)stripes); - sourceIndex += (int)stripes * StripeLengthBytes; - Debug.Assert(sourceIndex < source.Length); // at least some bytes left - _state.StripesProcessedInCurrentBlock = stripes; - - // Copy the last stripe into the end of the buffer so it is available to GetCurrentHashCore when processing the "stripe from the end". - source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); - } - else if (source.Length - sourceIndex > InternalBufferLengthBytes) - { - // Content to consume <= block size. Consume source by a multiple of internal buffer size. - do - { - ConsumeStripes(accumulators, ref _state.StripesProcessedInCurrentBlock, NumStripesPerBlock, sourcePtr + sourceIndex, InternalBufferStripes, secret); - sourceIndex += InternalBufferLengthBytes; - } - while (source.Length - sourceIndex > InternalBufferLengthBytes); - - // Copy the last stripe into the end of the buffer so it is available to GetCurrentHashCore when processing the "stripe from the end". - source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); - } - - // Buffer the remaining input. - Span remaining = new Span(buffer, source.Length - sourceIndex); - Debug.Assert(sourceIndex < source.Length); - Debug.Assert(remaining.Length <= InternalBufferLengthBytes); - Debug.Assert(_state.BufferedCount == 0); - source.Slice(sourceIndex).CopyTo(remaining); - _state.BufferedCount = (uint)remaining.Length; - } - } + XxHashShared.Append(ref _state, source); } /// Writes the computed 64-bit hash value to without modifying accumulated state. @@ -331,35 +177,12 @@ public ulong GetCurrentHashAsUInt64() { // Digest on a local copy to ensure the accumulators remain unaltered. ulong* accumulators = stackalloc ulong[AccumulatorCount]; - fixed (ulong* stateAccumulators = _state.Accumulators) - { -#if NET7_0_OR_GREATER - if (Vector256.IsHardwareAccelerated) - { - Vector256.Store(Vector256.Load(stateAccumulators), accumulators); - Vector256.Store(Vector256.Load(stateAccumulators + 4), accumulators + 4); - } - else if (Vector128.IsHardwareAccelerated) - { - Vector128.Store(Vector128.Load(stateAccumulators), accumulators); - Vector128.Store(Vector128.Load(stateAccumulators + 2), accumulators + 2); - Vector128.Store(Vector128.Load(stateAccumulators + 4), accumulators + 4); - Vector128.Store(Vector128.Load(stateAccumulators + 6), accumulators + 6); - } - else -#endif - { - for (int i = 0; i < 8; i++) - { - accumulators[i] = stateAccumulators[i]; - } - } - } + CopyAccumulators(ref _state, accumulators); fixed (byte* secret = _state.Secret) { - DigestLong(accumulators, secret); - current = MergeAccumulators(accumulators, secret + SecretMergeAccsStartBytes, _state.TotalLength * XxHash64.Prime64_1); + DigestLong(ref _state, accumulators, secret); + current = MergeAccumulators(accumulators, secret + SecretMergeAccsStartBytes, _state.TotalLength * Prime64_1); } } else @@ -371,37 +194,6 @@ public ulong GetCurrentHashAsUInt64() } return current; - - void DigestLong(ulong* accumulators, byte* secret) - { - Debug.Assert(_state.BufferedCount > 0); - - fixed (byte* buffer = _state.Buffer) - { - byte* accumulateData; - if (_state.BufferedCount >= StripeLengthBytes) - { - uint stripes = (_state.BufferedCount - 1) / StripeLengthBytes; - ulong stripesSoFar = _state.StripesProcessedInCurrentBlock; - - ConsumeStripes(accumulators, ref stripesSoFar, NumStripesPerBlock, buffer, stripes, secret); - - accumulateData = buffer + _state.BufferedCount - StripeLengthBytes; - } - else - { - byte* lastStripe = stackalloc byte[StripeLengthBytes]; - int catchupSize = StripeLengthBytes - (int)_state.BufferedCount; - - new ReadOnlySpan(buffer + InternalBufferLengthBytes - catchupSize, catchupSize).CopyTo(new Span(lastStripe, StripeLengthBytes)); - new ReadOnlySpan(buffer, (int)_state.BufferedCount).CopyTo(new Span(lastStripe + catchupSize, (int)_state.BufferedCount)); - - accumulateData = lastStripe; - } - - Accumulate512(accumulators, accumulateData, secret + (SecretLengthBytes - StripeLengthBytes - SecretLastAccStartBytes)); - } - } } [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -422,7 +214,8 @@ private static ulong HashLength0To16(byte* source, uint length, ulong seed) return HashLength1To3(source, length, seed); } - return XxHash64.Avalanche(seed ^ 0x8726F9105DC21DDC); // DefaultSecretUInt64[7] ^ DefaultSecretUInt64[8] + const ulong SecretXor = DefaultSecretUInt64_7 ^ DefaultSecretUInt64_8; + return XxHash64.Avalanche(seed ^ SecretXor); } [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -439,7 +232,8 @@ private static ulong HashLength1To3(byte* source, uint length, ulong seed) uint combined = ((uint)c1 << 16) | ((uint)c2 << 24) | c3 | (length << 8); - return XxHash64.Avalanche(combined ^ (0x87275A9B + seed)); // DefaultSecretUInt32[0] ^ DefaultSecretUInt32[1] + const uint SecretXor = unchecked((uint)DefaultSecretUInt64_0) ^ (uint)(DefaultSecretUInt64_0 >> 32); + return XxHash64.Avalanche(combined ^ (SecretXor + seed)); } [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -452,30 +246,22 @@ private static ulong HashLength4To8(byte* source, uint length, ulong seed) uint inputLow = ReadUInt32LE(source); uint inputHigh = ReadUInt32LE(source + length - sizeof(uint)); - ulong bitflip = 0xC73AB174C5ECD5A2 - seed; // DefaultSecretUInt64[1] ^ DefaultSecretUInt64[2] + const ulong SecretXor = DefaultSecretUInt64_1 ^ DefaultSecretUInt64_2; + ulong bitflip = SecretXor - seed; ulong input64 = inputHigh + (((ulong)inputLow) << 32); return Rrmxmx(input64 ^ bitflip, length); } - /// "This is a stronger avalanche, preferable when input has not been previously mixed." - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static ulong Rrmxmx(ulong hash, uint length) - { - hash ^= BitOperations.RotateLeft(hash, 49) ^ BitOperations.RotateLeft(hash, 24); - hash *= 0x9FB21C651E98DF25; - hash ^= (hash >> 35) + length; - hash *= 0x9FB21C651E98DF25; - return XorShift(hash, 28); - } - [MethodImpl(MethodImplOptions.AggressiveInlining)] private static ulong HashLength9To16(byte* source, uint length, ulong seed) { Debug.Assert(length >= 9 && length <= 16); - ulong bitflipLow = 0x6782737BEA4239B9 + seed; // DefaultSecretUInt64[3] ^ DefaultSecretUInt64[4] - ulong bitflipHigh = 0xAF56BC3B0996523A - seed; // DefaultSecretUInt64[5] ^ DefaultSecretUInt64[6] + const ulong SecretXorL = DefaultSecretUInt64_3 ^ DefaultSecretUInt64_4; + const ulong SecretXorR = DefaultSecretUInt64_5 ^ DefaultSecretUInt64_6; + ulong bitflipLow = SecretXorL + seed; + ulong bitflipHigh = SecretXorR - seed; ulong inputLow = ReadUInt64LE(source) ^ bitflipLow; ulong inputHigh = ReadUInt64LE(source + length - sizeof(ulong)) ^ bitflipHigh; @@ -491,25 +277,25 @@ private static ulong HashLength17To128(byte* source, uint length, ulong seed) { Debug.Assert(length >= 17 && length <= 128); - ulong hash = length * XxHash64.Prime64_1; + ulong hash = length * Prime64_1; switch ((length - 1) / 32) { default: // case 3 - hash += Mix16Bytes(source + 48, 0x3F349CE33F76FAA8, 0x1D4F0BC7C7BBDCF9, seed); // DefaultSecretUInt64[12], DefaultSecretUInt64[13] - hash += Mix16Bytes(source + length - 64, 0x3159B4CD4BE0518A, 0x647378D9C97E9FC8, seed); // DefaultSecretUInt64[14], DefaultSecretUInt64[15] + hash += Mix16Bytes(source + 48, DefaultSecretUInt64_12, DefaultSecretUInt64_13, seed); + hash += Mix16Bytes(source + length - 64, DefaultSecretUInt64_14, DefaultSecretUInt64_15, seed); goto case 2; case 2: - hash += Mix16Bytes(source + 32, 0xCB00C391BB52283C, 0xA32E531B8B65D088, seed); // DefaultSecretUInt64[8], DefaultSecretUInt64[9] - hash += Mix16Bytes(source + length - 48, 0x4EF90DA297486471, 0xD8ACDEA946EF1938, seed); // DefaultSecretUInt64[10], DefaultSecretUInt64[11] + hash += Mix16Bytes(source + 32, DefaultSecretUInt64_8, DefaultSecretUInt64_9, seed); + hash += Mix16Bytes(source + length - 48, DefaultSecretUInt64_10, DefaultSecretUInt64_11, seed); goto case 1; case 1: - hash += Mix16Bytes(source + 16, 0x78E5C0CC4EE679CB, 0x2172FFCC7DD05A82, seed); // DefaultSecretUInt64[4], DefaultSecretUInt64[5] - hash += Mix16Bytes(source + length - 32, 0x8E2443F7744608B8, 0x4C263A81E69035E0, seed); // DefaultSecretUInt64[6], DefaultSecretUInt64[7] + hash += Mix16Bytes(source + 16, DefaultSecretUInt64_4, DefaultSecretUInt64_5, seed); + hash += Mix16Bytes(source + length - 32, DefaultSecretUInt64_6, DefaultSecretUInt64_7, seed); goto case 0; case 0: - hash += Mix16Bytes(source, 0xBE4BA423396CFEB8, 0x1CAD21F72C81017C, seed); // DefaultSecretUInt64[0], DefaultSecretUInt64[1] - hash += Mix16Bytes(source + length - 16, 0xDB979083E96DD4DE, 0x1F67B3B7A4A44072, seed); // DefaultSecretUInt64[2], DefaultSecretUInt64[3] + hash += Mix16Bytes(source, DefaultSecretUInt64_0, DefaultSecretUInt64_1, seed); + hash += Mix16Bytes(source + length - 16, DefaultSecretUInt64_2, DefaultSecretUInt64_3, seed); break; } @@ -520,16 +306,16 @@ private static ulong HashLength129To240(byte* source, uint length, ulong seed) { Debug.Assert(length >= 129 && length <= 240); - ulong hash = length * XxHash64.Prime64_1; + ulong hash = length * Prime64_1; - hash += Mix16Bytes(source + (16 * 0), 0xBE4BA423396CFEB8, 0x1CAD21F72C81017C, seed); // DefaultSecretUInt64[0], DefaultSecretUInt64[1] - hash += Mix16Bytes(source + (16 * 1), 0xDB979083E96DD4DE, 0x1F67B3B7A4A44072, seed); // DefaultSecretUInt64[2], DefaultSecretUInt64[3] - hash += Mix16Bytes(source + (16 * 2), 0x78E5C0CC4EE679CB, 0x2172FFCC7DD05A82, seed); // DefaultSecretUInt64[4], DefaultSecretUInt64[5] - hash += Mix16Bytes(source + (16 * 3), 0x8E2443F7744608B8, 0x4C263A81E69035E0, seed); // DefaultSecretUInt64[6], DefaultSecretUInt64[7] - hash += Mix16Bytes(source + (16 * 4), 0xCB00C391BB52283C, 0xA32E531B8B65D088, seed); // DefaultSecretUInt64[8], DefaultSecretUInt64[9] - hash += Mix16Bytes(source + (16 * 5), 0x4EF90DA297486471, 0xD8ACDEA946EF1938, seed); // DefaultSecretUInt64[10], DefaultSecretUInt64[11] - hash += Mix16Bytes(source + (16 * 6), 0x3F349CE33F76FAA8, 0x1D4F0BC7C7BBDCF9, seed); // DefaultSecretUInt64[12], DefaultSecretUInt64[13] - hash += Mix16Bytes(source + (16 * 7), 0x3159B4CD4BE0518A, 0x647378D9C97E9FC8, seed); // DefaultSecretUInt64[14], DefaultSecretUInt64[15] + hash += Mix16Bytes(source + (16 * 0), DefaultSecretUInt64_0, DefaultSecretUInt64_1, seed); + hash += Mix16Bytes(source + (16 * 1), DefaultSecretUInt64_2, DefaultSecretUInt64_3, seed); + hash += Mix16Bytes(source + (16 * 2), DefaultSecretUInt64_4, DefaultSecretUInt64_5, seed); + hash += Mix16Bytes(source + (16 * 3), DefaultSecretUInt64_6, DefaultSecretUInt64_7, seed); + hash += Mix16Bytes(source + (16 * 4), DefaultSecretUInt64_8, DefaultSecretUInt64_9, seed); + hash += Mix16Bytes(source + (16 * 5), DefaultSecretUInt64_10, DefaultSecretUInt64_11, seed); + hash += Mix16Bytes(source + (16 * 6), DefaultSecretUInt64_12, DefaultSecretUInt64_13, seed); + hash += Mix16Bytes(source + (16 * 7), DefaultSecretUInt64_14, DefaultSecretUInt64_15, seed); hash = Avalanche(hash); @@ -537,32 +323,31 @@ private static ulong HashLength129To240(byte* source, uint length, ulong seed) { default: // case 7 Debug.Assert((length - 16 * 8) / 16 == 7); - hash += Mix16Bytes(source + (16 * 14), 0xBBDCF93F349CE33F, 0xE0518A1D4F0BC7C7, seed); // Read(ref DefaultSecret[99]), Read(ref DefaultSecret[107]) + hash += Mix16Bytes(source + (16 * 14), DefaultSecret3UInt64_12, DefaultSecret3UInt64_13, seed); goto case 6; case 6: - hash += Mix16Bytes(source + (16 * 13), 0xEF19384EF90DA297, 0x76FAA8D8ACDEA946, seed); // Read(ref DefaultSecret[83]), Read(ref DefaultSecret[91]) + hash += Mix16Bytes(source + (16 * 13), DefaultSecret3UInt64_10, DefaultSecret3UInt64_11, seed); goto case 5; case 5: - hash += Mix16Bytes(source + (16 * 12), 0x65D088CB00C391BB, 0x486471A32E531B8B, seed); // Read(ref DefaultSecret[67]), Read(ref DefaultSecret[75]) + hash += Mix16Bytes(source + (16 * 12), DefaultSecret3UInt64_8, DefaultSecret3UInt64_9, seed); goto case 4; case 4: - hash += Mix16Bytes(source + (16 * 11), 0x9035E08E2443F774, 0x52283C4C263A81E6, seed); // Read(ref DefaultSecret[51]), Read(ref DefaultSecret[59]) + hash += Mix16Bytes(source + (16 * 11), DefaultSecret3UInt64_6, DefaultSecret3UInt64_7, seed); goto case 3; case 3: - hash += Mix16Bytes(source + (16 * 10), 0xD05A8278E5C0CC4E, 0x4608B82172FFCC7D, seed); // Read(ref DefaultSecret[35]), Read(ref DefaultSecret[43]) + hash += Mix16Bytes(source + (16 * 10), DefaultSecret3UInt64_4, DefaultSecret3UInt64_5, seed); goto case 2; case 2: - hash += Mix16Bytes(source + (16 * 9), 0xA44072DB979083E9, 0xE679CB1F67B3B7A4, seed); // Read(ref DefaultSecret[19]), Read(ref DefaultSecret[27]) + hash += Mix16Bytes(source + (16 * 9), DefaultSecret3UInt64_2, DefaultSecret3UInt64_3, seed); goto case 1; case 1: - hash += Mix16Bytes(source + (16 * 8), 0x81017CBE4BA42339, 0x6DD4DE1CAD21F72C, seed); // Read(ref DefaultSecret[3]), Read(ref DefaultSecret[11]) + hash += Mix16Bytes(source + (16 * 8), DefaultSecret3UInt64_0, DefaultSecret3UInt64_1, seed); goto case 0; case 0: + hash += Mix16Bytes(source + length - 16, 0x7378D9C97E9FC831, 0xEBD33483ACC5EA64, seed); // DefaultSecret[119], DefaultSecret[127] break; } - // Handle the last 16 bytes. - hash += Mix16Bytes(source + length - 16, 0x7378D9C97E9FC831, 0xEBD33483ACC5EA64, seed); // DefaultSecret[119], DefaultSecret[127] return Avalanche(hash); } @@ -583,473 +368,10 @@ private static ulong HashLengthOver240(byte* source, uint length, ulong seed) ulong* accumulators = stackalloc ulong[AccumulatorCount]; InitializeAccumulators(accumulators); - const int StripesPerBlock = (SecretLengthBytes - StripeLengthBytes) / SecretConsumeRateBytes; - const int BlockLen = StripeLengthBytes * StripesPerBlock; - int blocksNum = (int)((length - 1) / BlockLen); - - Accumulate(accumulators, source, secret, StripesPerBlock, true, blocksNum); - int offset = BlockLen * blocksNum; - - int stripesNumber = (int)((length - 1 - offset) / StripeLengthBytes); - Accumulate(accumulators, source + offset, secret, stripesNumber); - Accumulate512(accumulators, source + length - StripeLengthBytes, secret + (SecretLengthBytes - StripeLengthBytes - SecretLastAccStartBytes)); - - return MergeAccumulators(accumulators, secret + 11, length * XxHash64.Prime64_1); - } - } - - private static void ConsumeStripes(ulong* accumulators, ref ulong stripesSoFar, ulong stripesPerBlock, byte* source, ulong stripes, byte* secret) - { - Debug.Assert(stripes <= stripesPerBlock); // can handle max 1 scramble per invocation - Debug.Assert(stripesSoFar < stripesPerBlock); + HashInternalLoop(accumulators, source, length, secret); - ulong stripesToEndOfBlock = stripesPerBlock - stripesSoFar; - if (stripesToEndOfBlock <= stripes) - { - // need a scrambling operation - ulong stripesAfterBlock = stripes - stripesToEndOfBlock; - Accumulate(accumulators, source, secret + ((int)stripesSoFar * SecretConsumeRateBytes), (int)stripesToEndOfBlock); - ScrambleAccumulators(accumulators, secret + (SecretLengthBytes - StripeLengthBytes)); - Accumulate(accumulators, source + ((int)stripesToEndOfBlock * StripeLengthBytes), secret, (int)stripesAfterBlock); - stripesSoFar = stripesAfterBlock; - } - else - { - Accumulate(accumulators, source, secret + ((int)stripesSoFar * SecretConsumeRateBytes), (int)stripes); - stripesSoFar += stripes; + return MergeAccumulators(accumulators, secret + 11, length * Prime64_1); } } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static void InitializeAccumulators(ulong* accumulators) - { -#if NET7_0_OR_GREATER - if (Vector256.IsHardwareAccelerated) - { - Vector256.Store(Vector256.Create(XxHash32.Prime32_3, XxHash64.Prime64_1, XxHash64.Prime64_2, XxHash64.Prime64_3), accumulators); - Vector256.Store(Vector256.Create(XxHash64.Prime64_4, XxHash32.Prime32_2, XxHash64.Prime64_5, XxHash32.Prime32_1), accumulators + 4); - } - else if (Vector128.IsHardwareAccelerated) - { - Vector128.Store(Vector128.Create(XxHash32.Prime32_3, XxHash64.Prime64_1), accumulators); - Vector128.Store(Vector128.Create(XxHash64.Prime64_2, XxHash64.Prime64_3), accumulators + 2); - Vector128.Store(Vector128.Create(XxHash64.Prime64_4, XxHash32.Prime32_2), accumulators + 4); - Vector128.Store(Vector128.Create(XxHash64.Prime64_5, XxHash32.Prime32_1), accumulators + 6); - } - else -#endif - { - accumulators[0] = XxHash32.Prime32_3; - accumulators[1] = XxHash64.Prime64_1; - accumulators[2] = XxHash64.Prime64_2; - accumulators[3] = XxHash64.Prime64_3; - accumulators[4] = XxHash64.Prime64_4; - accumulators[5] = XxHash32.Prime32_2; - accumulators[6] = XxHash64.Prime64_5; - accumulators[7] = XxHash32.Prime32_1; - } - } - - private static ulong MergeAccumulators(ulong* accumulators, byte* secret, ulong start) - { - ulong result64 = start; - - result64 += Multiply64To128ThenFold(accumulators[0] ^ ReadUInt64LE(secret), accumulators[1] ^ ReadUInt64LE(secret + 8)); - result64 += Multiply64To128ThenFold(accumulators[2] ^ ReadUInt64LE(secret + 16), accumulators[3] ^ ReadUInt64LE(secret + 24)); - result64 += Multiply64To128ThenFold(accumulators[4] ^ ReadUInt64LE(secret + 32), accumulators[5] ^ ReadUInt64LE(secret + 40)); - result64 += Multiply64To128ThenFold(accumulators[6] ^ ReadUInt64LE(secret + 48), accumulators[7] ^ ReadUInt64LE(secret + 56)); - - return Avalanche(result64); - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static ulong Mix16Bytes(byte* source, ulong secretLow, ulong secretHigh, ulong seed) => - Multiply64To128ThenFold( - ReadUInt64LE(source) ^ (secretLow + seed), - ReadUInt64LE(source + sizeof(ulong)) ^ (secretHigh - seed)); - - /// Calculates a 32-bit to 64-bit long multiply. - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static ulong Multiply32To64(ulong v1, ulong v2) => (uint)v1 * (ulong)(uint)v2; - - /// "This is a fast avalanche stage, suitable when input bits are already partially mixed." - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static ulong Avalanche(ulong hash) - { - hash = XorShift(hash, 37); - hash *= 0x165667919E3779F9; - hash = XorShift(hash, 32); - return hash; - } - - /// Calculates a 64-bit to 128-bit multiply, then XOR folds it. - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static ulong Multiply64To128ThenFold(ulong left, ulong right) - { -#if NET5_0_OR_GREATER - ulong upper = Math.BigMul(left, right, out ulong lower); -#else - ulong lowerLow = Multiply32To64(left & 0xFFFFFFFF, right & 0xFFFFFFFF); - ulong higherLow = Multiply32To64(left >> 32, right & 0xFFFFFFFF); - ulong lowerHigh = Multiply32To64(left & 0xFFFFFFFF, right >> 32); - ulong higherHigh = Multiply32To64(left >> 32, right >> 32); - - ulong cross = (lowerLow >> 32) + (higherLow & 0xFFFFFFFF) + lowerHigh; - ulong upper = (higherLow >> 32) + (cross >> 32) + higherHigh; - ulong lower = (cross << 32) | (lowerLow & 0xFFFFFFFF); -#endif - return lower ^ upper; - } - - private static void DeriveSecretFromSeed(byte* destinationSecret, ulong seed) - { - fixed (byte* defaultSecret = &MemoryMarshal.GetReference(DefaultSecret)) - { -#if NET7_0_OR_GREATER - if (Vector256.IsHardwareAccelerated && BitConverter.IsLittleEndian) - { - Vector256 seedVec = Vector256.Create(seed, 0u - seed, seed, 0u - seed); - for (int i = 0; i < SecretLengthBytes; i += Vector256.Count) - { - Vector256.Store(Vector256.Load((ulong*)(defaultSecret + i)) + seedVec, (ulong*)(destinationSecret + i)); - } - } - else if (Vector128.IsHardwareAccelerated && BitConverter.IsLittleEndian) - { - Vector128 seedVec = Vector128.Create(seed, 0u - seed); - for (int i = 0; i < SecretLengthBytes; i += Vector128.Count) - { - Vector128.Store(Vector128.Load((ulong*)(defaultSecret + i)) + seedVec, (ulong*)(destinationSecret + i)); - } - } - else -#endif - { - for (int i = 0; i < SecretLengthBytes; i += sizeof(ulong) * 2) - { - WriteUInt64LE(destinationSecret + i, ReadUInt64LE(defaultSecret + i) + seed); - WriteUInt64LE(destinationSecret + i + 8, ReadUInt64LE(defaultSecret + i + 8) - seed); - } - } - } - } - - /// Optimized version of looping over . - [MethodImpl(MethodImplOptions.NoInlining)] - private static void Accumulate(ulong* accumulators, byte* source, byte* secret, int stripesToProcess, bool scramble = false, int blockCount = 1) - { - byte* secretForAccumulate = secret; - byte* secretForScramble = secret + (SecretLengthBytes - StripeLengthBytes); - -#if NET7_0_OR_GREATER - if (Vector256.IsHardwareAccelerated && BitConverter.IsLittleEndian) - { - Vector256 acc1 = Vector256.Load(accumulators); - Vector256 acc2 = Vector256.Load(accumulators + Vector256.Count); - - for (int j = 0; j < blockCount; j++) - { - secret = secretForAccumulate; - for (int i = 0; i < stripesToProcess; i++) - { - Vector256 secretVal = Vector256.Load((uint*)secret); - acc1 = Accumulate256(acc1, source, secretVal); - source += Vector256.Count; - - secretVal = Vector256.Load((uint*)secret + Vector256.Count); - acc2 = Accumulate256(acc2, source, secretVal); - source += Vector256.Count; - - secret += SecretConsumeRateBytes; - } - - if (scramble) - { - acc1 = ScrambleAccumulator256(acc1, Vector256.Load((ulong*)secretForScramble)); - acc2 = ScrambleAccumulator256(acc2, Vector256.Load((ulong*)secretForScramble + Vector256.Count)); - } - } - - Vector256.Store(acc1, accumulators); - Vector256.Store(acc2, accumulators + Vector256.Count); - } - else if (Vector128.IsHardwareAccelerated && BitConverter.IsLittleEndian) - { - Vector128 acc1 = Vector128.Load(accumulators); - Vector128 acc2 = Vector128.Load(accumulators + Vector128.Count); - Vector128 acc3 = Vector128.Load(accumulators + Vector128.Count * 2); - Vector128 acc4 = Vector128.Load(accumulators + Vector128.Count * 3); - - for (int j = 0; j < blockCount; j++) - { - secret = secretForAccumulate; - for (int i = 0; i < stripesToProcess; i++) - { - Vector128 secretVal = Vector128.Load((uint*)secret); - acc1 = Accumulate128(acc1, source, secretVal); - source += Vector128.Count; - - secretVal = Vector128.Load((uint*)secret + Vector128.Count); - acc2 = Accumulate128(acc2, source, secretVal); - source += Vector128.Count; - - secretVal = Vector128.Load((uint*)secret + Vector128.Count * 2); - acc3 = Accumulate128(acc3, source, secretVal); - source += Vector128.Count; - - secretVal = Vector128.Load((uint*)secret + Vector128.Count * 3); - acc4 = Accumulate128(acc4, source, secretVal); - source += Vector128.Count; - - secret += SecretConsumeRateBytes; - } - - if (scramble) - { - acc1 = ScrambleAccumulator128(acc1, Vector128.Load((ulong*)secretForScramble)); - acc2 = ScrambleAccumulator128(acc2, Vector128.Load((ulong*)secretForScramble + Vector128.Count)); - acc3 = ScrambleAccumulator128(acc3, Vector128.Load((ulong*)secretForScramble + Vector128.Count * 2)); - acc4 = ScrambleAccumulator128(acc4, Vector128.Load((ulong*)secretForScramble + Vector128.Count * 3)); - } - } - - Vector128.Store(acc1, accumulators); - Vector128.Store(acc2, accumulators + Vector128.Count); - Vector128.Store(acc3, accumulators + Vector128.Count * 2); - Vector128.Store(acc4, accumulators + Vector128.Count * 3); - } - else -#endif - { - for (int j = 0; j < blockCount; j++) - { - for (int i = 0; i < stripesToProcess; i++) - { - Accumulate512Inlined(accumulators, source, secret + (i * SecretConsumeRateBytes)); - source += StripeLengthBytes; - } - - if (scramble) - { - ScrambleAccumulators(accumulators, secretForScramble); - } - } - } - } - - [MethodImpl(MethodImplOptions.NoInlining)] - private static void Accumulate512(ulong* accumulators, byte* source, byte* secret) - { - Accumulate512Inlined(accumulators, source, secret); - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static void Accumulate512Inlined(ulong* accumulators, byte* source, byte* secret) - { -#if NET7_0_OR_GREATER - if (Vector256.IsHardwareAccelerated && BitConverter.IsLittleEndian) - { - for (int i = 0; i < AccumulatorCount / Vector256.Count; i++) - { - Vector256 accVec = Accumulate256(Vector256.Load(accumulators), source, Vector256.Load((uint*)secret)); - Vector256.Store(accVec, accumulators); - - accumulators += Vector256.Count; - secret += Vector256.Count; - source += Vector256.Count; - } - } - else if (Vector128.IsHardwareAccelerated && BitConverter.IsLittleEndian) - { - for (int i = 0; i < AccumulatorCount / Vector128.Count; i++) - { - Vector128 accVec = Accumulate128(Vector128.Load(accumulators), source, Vector128.Load((uint*)secret)); - Vector128.Store(accVec, accumulators); - - accumulators += Vector128.Count; - secret += Vector128.Count; - source += Vector128.Count; - } - } - else -#endif - { - for (int i = 0; i < AccumulatorCount; i++) - { - ulong sourceVal = ReadUInt64LE(source + (8 * i)); - ulong sourceKey = sourceVal ^ ReadUInt64LE(secret + (i * 8)); - - accumulators[i ^ 1] += sourceVal; // swap adjacent lanes - accumulators[i] += Multiply32To64(sourceKey & 0xFFFFFFFF, sourceKey >> 32); - } - } - } - -#if NET7_0_OR_GREATER - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static Vector256 Accumulate256(Vector256 accVec, byte* source, Vector256 secret) - { - Vector256 sourceVec = Vector256.Load((uint*)source); - Vector256 sourceKey = sourceVec ^ secret; - - // TODO: Figure out how to unwind this shuffle and just use Vector256.Multiply - Vector256 sourceKeyLow = Vector256.Shuffle(sourceKey, Vector256.Create(1u, 0, 3, 0, 5, 0, 7, 0)); - Vector256 sourceSwap = Vector256.Shuffle(sourceVec, Vector256.Create(2u, 3, 0, 1, 6, 7, 4, 5)); - Vector256 sum = accVec + sourceSwap.AsUInt64(); - Vector256 product = Avx2.IsSupported ? - Avx2.Multiply(sourceKey, sourceKeyLow) : - (sourceKey & Vector256.Create(~0u, 0u, ~0u, 0u, ~0u, 0u, ~0u, 0u)).AsUInt64() * (sourceKeyLow & Vector256.Create(~0u, 0u, ~0u, 0u, ~0u, 0u, ~0u, 0u)).AsUInt64(); - - accVec = product + sum; - return accVec; - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static Vector128 Accumulate128(Vector128 accVec, byte* source, Vector128 secret) - { - Vector128 sourceVec = Vector128.Load((uint*)source); - Vector128 sourceKey = sourceVec ^ secret; - - // TODO: Figure out how to unwind this shuffle and just use Vector128.Multiply - Vector128 sourceSwap = Vector128.Shuffle(sourceVec, Vector128.Create(2u, 3, 0, 1)); - Vector128 sum = accVec + sourceSwap.AsUInt64(); - - Vector128 product = MultiplyWideningLower(sourceKey); - accVec = product + sum; - return accVec; - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static Vector128 MultiplyWideningLower(Vector128 source) - { - if (AdvSimd.IsSupported) - { - Vector64 sourceLow = Vector128.Shuffle(source, Vector128.Create(0u, 2, 0, 0)).GetLower(); - Vector64 sourceHigh = Vector128.Shuffle(source, Vector128.Create(1u, 3, 0, 0)).GetLower(); - return AdvSimd.MultiplyWideningLower(sourceLow, sourceHigh); - } - else - { - Vector128 sourceLow = Vector128.Shuffle(source, Vector128.Create(1u, 0, 3, 0)); - return Sse2.IsSupported ? - Sse2.Multiply(source, sourceLow) : - (source & Vector128.Create(~0u, 0u, ~0u, 0u)).AsUInt64() * (sourceLow & Vector128.Create(~0u, 0u, ~0u, 0u)).AsUInt64(); - } - } -#endif - - private static void ScrambleAccumulators(ulong* accumulators, byte* secret) - { -#if NET7_0_OR_GREATER - if (Vector256.IsHardwareAccelerated && BitConverter.IsLittleEndian) - { - for (int i = 0; i < AccumulatorCount / Vector256.Count; i++) - { - Vector256 accVec = ScrambleAccumulator256(Vector256.Load(accumulators), Vector256.Load((ulong*)secret)); - Vector256.Store(accVec, accumulators); - - accumulators += Vector256.Count; - secret += Vector256.Count; - } - } - else if (Vector128.IsHardwareAccelerated && BitConverter.IsLittleEndian) - { - for (int i = 0; i < AccumulatorCount / Vector128.Count; i++) - { - Vector128 accVec = ScrambleAccumulator128(Vector128.Load(accumulators), Vector128.Load((ulong*)secret)); - Vector128.Store(accVec, accumulators); - - accumulators += Vector128.Count; - secret += Vector128.Count; - } - } - else -#endif - { - for (int i = 0; i < AccumulatorCount; i++) - { - ulong xorShift = XorShift(*accumulators, 47); - ulong xorWithKey = xorShift ^ ReadUInt64LE(secret); - *accumulators = xorWithKey * XxHash32.Prime32_1; - - accumulators++; - secret += sizeof(ulong); - } - } - } - -#if NET7_0_OR_GREATER - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static Vector256 ScrambleAccumulator256(Vector256 accVec, Vector256 secret) - { - Vector256 xorShift = accVec ^ Vector256.ShiftRightLogical(accVec, 47); - Vector256 xorWithKey = xorShift ^ secret; - accVec = xorWithKey * Vector256.Create((ulong)XxHash32.Prime32_1); - return accVec; - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static Vector128 ScrambleAccumulator128(Vector128 accVec, Vector128 secret) - { - Vector128 xorShift = accVec ^ Vector128.ShiftRightLogical(accVec, 47); - Vector128 xorWithKey = xorShift ^ secret; - accVec = xorWithKey * Vector128.Create((ulong)XxHash32.Prime32_1); - return accVec; - } -#endif - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static ulong XorShift(ulong value, int shift) - { - Debug.Assert(shift >= 0 && shift < 64); - return value ^ (value >> shift); - } - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static uint ReadUInt32LE(byte* data) => - BitConverter.IsLittleEndian ? - Unsafe.ReadUnaligned(data) : - BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned(data)); - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static ulong ReadUInt64LE(byte* data) => - BitConverter.IsLittleEndian ? - Unsafe.ReadUnaligned(data) : - BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned(data)); - - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private static void WriteUInt64LE(byte* data, ulong value) - { - if (!BitConverter.IsLittleEndian) - { - value = BinaryPrimitives.ReverseEndianness(value); - } - Unsafe.WriteUnaligned(data, value); - } - - [StructLayout(LayoutKind.Auto)] - private struct State - { - /// The accumulators. Length is . - internal fixed ulong Accumulators[AccumulatorCount]; - - /// Used to store a custom secret generated from a seed. Length is . - internal fixed byte Secret[SecretLengthBytes]; - - /// The internal buffer. Length is . - internal fixed byte Buffer[InternalBufferLengthBytes]; - - /// The amount of memory in . - internal uint BufferedCount; - - /// Number of stripes processed in the current block. - internal ulong StripesProcessedInCurrentBlock; - - /// Total length hashed. - internal ulong TotalLength; - - /// The seed employed (possibly 0). - internal ulong Seed; - }; } } diff --git a/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash32.State.cs b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash32.State.cs index 04a0cdc13e2a9..95dd956c4067b 100644 --- a/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash32.State.cs +++ b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash32.State.cs @@ -5,6 +5,7 @@ using System.Diagnostics; using System.Numerics; using System.Runtime.CompilerServices; +using static System.IO.Hashing.XxHashShared; // Implemented from the specification at // https://github.com/Cyan4973/xxHash/blob/f9155bd4c57e2270a4ffbb176485e5d713de1c9b/doc/xxhash_spec.md @@ -13,12 +14,6 @@ namespace System.IO.Hashing { public sealed partial class XxHash32 { - internal const uint Prime32_1 = 0x9E3779B1; - internal const uint Prime32_2 = 0x85EBCA77; - internal const uint Prime32_3 = 0xC2B2AE3D; - internal const uint Prime32_4 = 0x27D4EB2F; - internal const uint Prime32_5 = 0x165667B1; - private struct State { private uint _acc1; diff --git a/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash64.State.cs b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash64.State.cs index 92a900db8ce2b..efd32156862f7 100644 --- a/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash64.State.cs +++ b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHash64.State.cs @@ -5,6 +5,7 @@ using System.Diagnostics; using System.Numerics; using System.Runtime.CompilerServices; +using static System.IO.Hashing.XxHashShared; // Implemented from the specification at // https://github.com/Cyan4973/xxHash/blob/f9155bd4c57e2270a4ffbb176485e5d713de1c9b/doc/xxhash_spec.md @@ -13,12 +14,6 @@ namespace System.IO.Hashing { public sealed partial class XxHash64 { - internal const ulong Prime64_1 = 0x9E3779B185EBCA87; - internal const ulong Prime64_2 = 0xC2B2AE3D27D4EB4F; - internal const ulong Prime64_3 = 0x165667B19E3779F9; - internal const ulong Prime64_4 = 0x85EBCA77C2B2AE63; - internal const ulong Prime64_5 = 0x27D4EB2F165667C5; - [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static ulong Avalanche(ulong hash) { diff --git a/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHashShared.cs b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHashShared.cs new file mode 100644 index 0000000000000..60b934a8950cd --- /dev/null +++ b/src/libraries/System.IO.Hashing/src/System/IO/Hashing/XxHashShared.cs @@ -0,0 +1,819 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Buffers.Binary; +using System.Diagnostics; +using System.Numerics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +#if NET7_0_OR_GREATER +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; +using System.Runtime.Intrinsics.X86; +#endif + +namespace System.IO.Hashing +{ + /// Shared implementation of the XXH3 hash algorithm for 64-bit in and version. +#if NET5_0_OR_GREATER + [SkipLocalsInit] +#endif + internal static unsafe class XxHashShared + { + public const int StripeLengthBytes = 64; + public const int SecretLengthBytes = 192; + public const int SecretSizeMin = 136; + public const int SecretLastAccStartBytes = 7; + public const int SecretConsumeRateBytes = 8; + public const int SecretMergeAccsStartBytes = 11; + public const int NumStripesPerBlock = (SecretLengthBytes - StripeLengthBytes) / SecretConsumeRateBytes; + public const int AccumulatorCount = StripeLengthBytes / sizeof(ulong); + public const int MidSizeMaxBytes = 240; + public const int InternalBufferStripes = InternalBufferLengthBytes / StripeLengthBytes; + public const int InternalBufferLengthBytes = 256; + + /// The default secret for when no seed is provided. + /// This is the same as a custom secret derived from a seed of 0. + public static ReadOnlySpan DefaultSecret => new byte[] + { + 0xb8, 0xfe, 0x6c, 0x39, 0x23, 0xa4, 0x4b, 0xbe, // DefaultSecretUInt64_0 + 0x7c, 0x01, 0x81, 0x2c, 0xf7, 0x21, 0xad, 0x1c, // DefaultSecretUInt64_1 + 0xde, 0xd4, 0x6d, 0xe9, 0x83, 0x90, 0x97, 0xdb, // DefaultSecretUInt64_2 + 0x72, 0x40, 0xa4, 0xa4, 0xb7, 0xb3, 0x67, 0x1f, // DefaultSecretUInt64_3 + 0xcb, 0x79, 0xe6, 0x4e, 0xcc, 0xc0, 0xe5, 0x78, // DefaultSecretUInt64_4 + 0x82, 0x5a, 0xd0, 0x7d, 0xcc, 0xff, 0x72, 0x21, // DefaultSecretUInt64_5 + 0xb8, 0x08, 0x46, 0x74, 0xf7, 0x43, 0x24, 0x8e, // DefaultSecretUInt64_6 + 0xe0, 0x35, 0x90, 0xe6, 0x81, 0x3a, 0x26, 0x4c, // DefaultSecretUInt64_7 + 0x3c, 0x28, 0x52, 0xbb, 0x91, 0xc3, 0x00, 0xcb, // DefaultSecretUInt64_8 + 0x88, 0xd0, 0x65, 0x8b, 0x1b, 0x53, 0x2e, 0xa3, // DefaultSecretUInt64_9 + 0x71, 0x64, 0x48, 0x97, 0xa2, 0x0d, 0xf9, 0x4e, // DefaultSecretUInt64_10 + 0x38, 0x19, 0xef, 0x46, 0xa9, 0xde, 0xac, 0xd8, // DefaultSecretUInt64_11 + 0xa8, 0xfa, 0x76, 0x3f, 0xe3, 0x9c, 0x34, 0x3f, // DefaultSecretUInt64_12 + 0xf9, 0xdc, 0xbb, 0xc7, 0xc7, 0x0b, 0x4f, 0x1d, // DefaultSecretUInt64_13 + 0x8a, 0x51, 0xe0, 0x4b, 0xcd, 0xb4, 0x59, 0x31, // DefaultSecretUInt64_14 + 0xc8, 0x9f, 0x7e, 0xc9, 0xd9, 0x78, 0x73, 0x64, // DefaultSecretUInt64_15 + 0xea, 0xc5, 0xac, 0x83, 0x34, 0xd3, 0xeb, 0xc3, // DefaultSecretUInt64_16 + 0xc5, 0x81, 0xa0, 0xff, 0xfa, 0x13, 0x63, 0xeb, // DefaultSecretUInt64_17 + 0x17, 0x0d, 0xdd, 0x51, 0xb7, 0xf0, 0xda, 0x49, // DefaultSecretUInt64_18 + 0xd3, 0x16, 0x55, 0x26, 0x29, 0xd4, 0x68, 0x9e, // DefaultSecretUInt64_19 + 0x2b, 0x16, 0xbe, 0x58, 0x7d, 0x47, 0xa1, 0xfc, // DefaultSecretUInt64_20 + 0x8f, 0xf8, 0xb8, 0xd1, 0x7a, 0xd0, 0x31, 0xce, // DefaultSecretUInt64_21 + 0x45, 0xcb, 0x3a, 0x8f, 0x95, 0x16, 0x04, 0x28, // DefaultSecretUInt64_22 + 0xaf, 0xd7, 0xfb, 0xca, 0xbb, 0x4b, 0x40, 0x7e, // DefaultSecretUInt64_23 + }; + + // Cast of DefaultSecret byte[] => ulong[] (See above for the correspondence) + public const ulong DefaultSecretUInt64_0 = 0xBE4BA423396CFEB8; + public const ulong DefaultSecretUInt64_1 = 0x1CAD21F72C81017C; + public const ulong DefaultSecretUInt64_2 = 0xDB979083E96DD4DE; + public const ulong DefaultSecretUInt64_3 = 0x1F67B3B7A4A44072; + public const ulong DefaultSecretUInt64_4 = 0x78E5C0CC4EE679CB; + public const ulong DefaultSecretUInt64_5 = 0x2172FFCC7DD05A82; + public const ulong DefaultSecretUInt64_6 = 0x8E2443F7744608B8; + public const ulong DefaultSecretUInt64_7 = 0x4C263A81E69035E0; + public const ulong DefaultSecretUInt64_8 = 0xCB00C391BB52283C; + public const ulong DefaultSecretUInt64_9 = 0xA32E531B8B65D088; + public const ulong DefaultSecretUInt64_10 = 0x4EF90DA297486471; + public const ulong DefaultSecretUInt64_11 = 0xD8ACDEA946EF1938; + public const ulong DefaultSecretUInt64_12 = 0x3F349CE33F76FAA8; + public const ulong DefaultSecretUInt64_13 = 0x1D4F0BC7C7BBDCF9; + public const ulong DefaultSecretUInt64_14 = 0x3159B4CD4BE0518A; + public const ulong DefaultSecretUInt64_15 = 0x647378D9C97E9FC8; + + // Cast of DefaultSecret offset by 3 bytes, byte[] => ulong[] + public const ulong DefaultSecret3UInt64_0 = 0x81017CBE4BA42339; + public const ulong DefaultSecret3UInt64_1 = 0x6DD4DE1CAD21F72C; + public const ulong DefaultSecret3UInt64_2 = 0xA44072DB979083E9; + public const ulong DefaultSecret3UInt64_3 = 0xE679CB1F67B3B7A4; + public const ulong DefaultSecret3UInt64_4 = 0xD05A8278E5C0CC4E; + public const ulong DefaultSecret3UInt64_5 = 0x4608B82172FFCC7D; + public const ulong DefaultSecret3UInt64_6 = 0x9035E08E2443F774; + public const ulong DefaultSecret3UInt64_7 = 0x52283C4C263A81E6; + public const ulong DefaultSecret3UInt64_8 = 0x65D088CB00C391BB; + public const ulong DefaultSecret3UInt64_9 = 0x486471A32E531B8B; + public const ulong DefaultSecret3UInt64_10 = 0xEF19384EF90DA297; + public const ulong DefaultSecret3UInt64_11 = 0x76FAA8D8ACDEA946; + public const ulong DefaultSecret3UInt64_12 = 0xBBDCF93F349CE33F; + public const ulong DefaultSecret3UInt64_13 = 0xE0518A1D4F0BC7C7; + + public const ulong Prime64_1 = 0x9E3779B185EBCA87UL; + public const ulong Prime64_2 = 0xC2B2AE3D27D4EB4FUL; + public const ulong Prime64_3 = 0x165667B19E3779F9UL; + public const ulong Prime64_4 = 0x85EBCA77C2B2AE63UL; + public const ulong Prime64_5 = 0x27D4EB2F165667C5UL; + + public const uint Prime32_1 = 0x9E3779B1U; + public const uint Prime32_2 = 0x85EBCA77U; + public const uint Prime32_3 = 0xC2B2AE3DU; + public const uint Prime32_4 = 0x27D4EB2FU; + public const uint Prime32_5 = 0x165667B1U; + +#if DEBUG + static XxHashShared() + { + // Make sure DefaultSecret is the custom secret derived from a seed of 0. + byte* secret = stackalloc byte[SecretLengthBytes]; + DeriveSecretFromSeed(secret, 0); + Debug.Assert(new Span(secret, SecretLengthBytes).SequenceEqual(DefaultSecret)); + + // Validate some relationships. + Debug.Assert(InternalBufferLengthBytes % StripeLengthBytes == 0); + + ReadOnlySpan defaultSecretUInt64 = MemoryMarshal.Cast(DefaultSecret); + Debug.Assert(ReadLE64(defaultSecretUInt64[0])== DefaultSecretUInt64_0); + Debug.Assert(ReadLE64(defaultSecretUInt64[1])== DefaultSecretUInt64_1); + Debug.Assert(ReadLE64(defaultSecretUInt64[2])== DefaultSecretUInt64_2); + Debug.Assert(ReadLE64(defaultSecretUInt64[3])== DefaultSecretUInt64_3); + Debug.Assert(ReadLE64(defaultSecretUInt64[4])== DefaultSecretUInt64_4); + Debug.Assert(ReadLE64(defaultSecretUInt64[5])== DefaultSecretUInt64_5); + Debug.Assert(ReadLE64(defaultSecretUInt64[6])== DefaultSecretUInt64_6); + Debug.Assert(ReadLE64(defaultSecretUInt64[7])== DefaultSecretUInt64_7); + Debug.Assert(ReadLE64(defaultSecretUInt64[8])== DefaultSecretUInt64_8); + Debug.Assert(ReadLE64(defaultSecretUInt64[9])== DefaultSecretUInt64_9); + Debug.Assert(ReadLE64(defaultSecretUInt64[10]) == DefaultSecretUInt64_10); + Debug.Assert(ReadLE64(defaultSecretUInt64[11]) == DefaultSecretUInt64_11); + Debug.Assert(ReadLE64(defaultSecretUInt64[12]) == DefaultSecretUInt64_12); + Debug.Assert(ReadLE64(defaultSecretUInt64[13]) == DefaultSecretUInt64_13); + Debug.Assert(ReadLE64(defaultSecretUInt64[14]) == DefaultSecretUInt64_14); + Debug.Assert(ReadLE64(defaultSecretUInt64[15]) == DefaultSecretUInt64_15); + + ReadOnlySpan defaultSecret3UInt64 = MemoryMarshal.Cast(DefaultSecret.Slice(3)); + Debug.Assert(ReadLE64(defaultSecret3UInt64[0])== DefaultSecret3UInt64_0); + Debug.Assert(ReadLE64(defaultSecret3UInt64[1])== DefaultSecret3UInt64_1); + Debug.Assert(ReadLE64(defaultSecret3UInt64[2])== DefaultSecret3UInt64_2); + Debug.Assert(ReadLE64(defaultSecret3UInt64[3])== DefaultSecret3UInt64_3); + Debug.Assert(ReadLE64(defaultSecret3UInt64[4])== DefaultSecret3UInt64_4); + Debug.Assert(ReadLE64(defaultSecret3UInt64[5])== DefaultSecret3UInt64_5); + Debug.Assert(ReadLE64(defaultSecret3UInt64[6])== DefaultSecret3UInt64_6); + Debug.Assert(ReadLE64(defaultSecret3UInt64[7])== DefaultSecret3UInt64_7); + Debug.Assert(ReadLE64(defaultSecret3UInt64[8])== DefaultSecret3UInt64_8); + Debug.Assert(ReadLE64(defaultSecret3UInt64[9])== DefaultSecret3UInt64_9); + Debug.Assert(ReadLE64(defaultSecret3UInt64[10]) == DefaultSecret3UInt64_10); + Debug.Assert(ReadLE64(defaultSecret3UInt64[11]) == DefaultSecret3UInt64_11); + Debug.Assert(ReadLE64(defaultSecret3UInt64[12]) == DefaultSecret3UInt64_12); + Debug.Assert(ReadLE64(defaultSecret3UInt64[13]) == DefaultSecret3UInt64_13); + + static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); + } +#endif + + public static void Initialize(ref State state, ulong seed) + { + state.Seed = (ulong)seed; + + fixed (byte* secret = state.Secret) + { + if (seed == 0) + { + DefaultSecret.CopyTo(new Span(secret, SecretLengthBytes)); + } + else + { + DeriveSecretFromSeed(secret, (ulong)seed); + } + } + + Reset(ref state); + } + + public static void Reset(ref State state) + { + state.BufferedCount = 0; + state.StripesProcessedInCurrentBlock = 0; + state.TotalLength = 0; + + fixed (ulong* accumulators = state.Accumulators) + { + InitializeAccumulators(accumulators); + } + } + + /// "This is a stronger avalanche, preferable when input has not been previously mixed." + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong Rrmxmx(ulong hash, uint length) + { + hash ^= BitOperations.RotateLeft(hash, 49) ^ BitOperations.RotateLeft(hash, 24); + hash *= 0x9FB21C651E98DF25; + hash ^= (hash >> 35) + length; + hash *= 0x9FB21C651E98DF25; + return XorShift(hash, 28); + } + + public static void HashInternalLoop(ulong* accumulators, byte* source, uint length, byte* secret) + { + Debug.Assert(length > 240); + + const int StripesPerBlock = (SecretLengthBytes - StripeLengthBytes) / SecretConsumeRateBytes; + const int BlockLen = StripeLengthBytes * StripesPerBlock; + int blocksNum = (int)((length - 1) / BlockLen); + + Accumulate(accumulators, source, secret, StripesPerBlock, true, blocksNum); + int offset = BlockLen * blocksNum; + + int stripesNumber = (int)((length - 1 - offset) / StripeLengthBytes); + Accumulate(accumulators, source + offset, secret, stripesNumber); + Accumulate512(accumulators, source + length - StripeLengthBytes, secret + (SecretLengthBytes - StripeLengthBytes - SecretLastAccStartBytes)); + } + + public static void ConsumeStripes(ulong* accumulators, ref ulong stripesSoFar, ulong stripesPerBlock, byte* source, ulong stripes, byte* secret) + { + Debug.Assert(stripes <= stripesPerBlock); // can handle max 1 scramble per invocation + Debug.Assert(stripesSoFar < stripesPerBlock); + + ulong stripesToEndOfBlock = stripesPerBlock - stripesSoFar; + if (stripesToEndOfBlock <= stripes) + { + // need a scrambling operation + ulong stripesAfterBlock = stripes - stripesToEndOfBlock; + Accumulate(accumulators, source, secret + ((int)stripesSoFar * SecretConsumeRateBytes), (int)stripesToEndOfBlock); + ScrambleAccumulators(accumulators, secret + (SecretLengthBytes - StripeLengthBytes)); + Accumulate(accumulators, source + ((int)stripesToEndOfBlock * StripeLengthBytes), secret, (int)stripesAfterBlock); + stripesSoFar = stripesAfterBlock; + } + else + { + Accumulate(accumulators, source, secret + ((int)stripesSoFar * SecretConsumeRateBytes), (int)stripes); + stripesSoFar += stripes; + } + } + + public static void Append(ref State state, ReadOnlySpan source) + { + Debug.Assert(state.BufferedCount <= InternalBufferLengthBytes); + + state.TotalLength += (uint)source.Length; + + fixed (byte* buffer = state.Buffer) + { + // Small input: just copy the data to the buffer. + if (source.Length <= InternalBufferLengthBytes - state.BufferedCount) + { + source.CopyTo(new Span(buffer + state.BufferedCount, source.Length)); + state.BufferedCount += (uint)source.Length; + return; + } + + fixed (byte* secret = state.Secret) + fixed (ulong* accumulators = state.Accumulators) + fixed (byte* sourcePtr = &MemoryMarshal.GetReference(source)) + { + // Internal buffer is partially filled (always, except at beginning). Complete it, then consume it. + int sourceIndex = 0; + if (state.BufferedCount != 0) + { + int loadSize = InternalBufferLengthBytes - (int)state.BufferedCount; + + source.Slice(0, loadSize).CopyTo(new Span(buffer + state.BufferedCount, loadSize)); + sourceIndex = loadSize; + + ConsumeStripes(accumulators, ref state.StripesProcessedInCurrentBlock, NumStripesPerBlock, buffer, InternalBufferStripes, secret); + state.BufferedCount = 0; + } + Debug.Assert(sourceIndex < source.Length); + + // Large input to consume: ingest per full block. + if (source.Length - sourceIndex > NumStripesPerBlock * StripeLengthBytes) + { + ulong stripes = (ulong)(source.Length - sourceIndex - 1) / StripeLengthBytes; + Debug.Assert(NumStripesPerBlock >= state.StripesProcessedInCurrentBlock); + + // Join to current block's end. + ulong stripesToEnd = NumStripesPerBlock - state.StripesProcessedInCurrentBlock; + Debug.Assert(stripesToEnd <= stripes); + Accumulate(accumulators, sourcePtr + sourceIndex, secret + ((int)state.StripesProcessedInCurrentBlock * SecretConsumeRateBytes), (int)stripesToEnd); + ScrambleAccumulators(accumulators, secret + (SecretLengthBytes - StripeLengthBytes)); + state.StripesProcessedInCurrentBlock = 0; + sourceIndex += (int)stripesToEnd * StripeLengthBytes; + stripes -= stripesToEnd; + + // Consume entire blocks. + while (stripes >= NumStripesPerBlock) + { + Accumulate(accumulators, sourcePtr + sourceIndex, secret, NumStripesPerBlock); + ScrambleAccumulators(accumulators, secret + (SecretLengthBytes - StripeLengthBytes)); + sourceIndex += NumStripesPerBlock * StripeLengthBytes; + stripes -= NumStripesPerBlock; + } + + // Consume complete stripes in the last partial block. + Accumulate(accumulators, sourcePtr + sourceIndex, secret, (int)stripes); + sourceIndex += (int)stripes * StripeLengthBytes; + Debug.Assert(sourceIndex < source.Length); // at least some bytes left + state.StripesProcessedInCurrentBlock = stripes; + + // Copy the last stripe into the end of the buffer so it is available to GetCurrentHashCore when processing the "stripe from the end". + source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); + } + else if (source.Length - sourceIndex > InternalBufferLengthBytes) + { + // Content to consume <= block size. Consume source by a multiple of internal buffer size. + do + { + ConsumeStripes(accumulators, ref state.StripesProcessedInCurrentBlock, NumStripesPerBlock, sourcePtr + sourceIndex, InternalBufferStripes, secret); + sourceIndex += InternalBufferLengthBytes; + } + while (source.Length - sourceIndex > InternalBufferLengthBytes); + + // Copy the last stripe into the end of the buffer so it is available to GetCurrentHashCore when processing the "stripe from the end". + source.Slice(sourceIndex - StripeLengthBytes, StripeLengthBytes).CopyTo(new Span(buffer + InternalBufferLengthBytes - StripeLengthBytes, StripeLengthBytes)); + } + + // Buffer the remaining input. + Span remaining = new Span(buffer, source.Length - sourceIndex); + Debug.Assert(sourceIndex < source.Length); + Debug.Assert(remaining.Length <= InternalBufferLengthBytes); + Debug.Assert(state.BufferedCount == 0); + source.Slice(sourceIndex).CopyTo(remaining); + state.BufferedCount = (uint)remaining.Length; + } + } + } + + public static void CopyAccumulators(ref State state, ulong* accumulators) + { + fixed (ulong* stateAccumulators = state.Accumulators) + { +#if NET7_0_OR_GREATER + if (Vector256.IsHardwareAccelerated) + { + Vector256.Store(Vector256.Load(stateAccumulators), accumulators); + Vector256.Store(Vector256.Load(stateAccumulators + 4), accumulators + 4); + } + else if (Vector128.IsHardwareAccelerated) + { + Vector128.Store(Vector128.Load(stateAccumulators), accumulators); + Vector128.Store(Vector128.Load(stateAccumulators + 2), accumulators + 2); + Vector128.Store(Vector128.Load(stateAccumulators + 4), accumulators + 4); + Vector128.Store(Vector128.Load(stateAccumulators + 6), accumulators + 6); + } + else +#endif + { + for (int i = 0; i < 8; i++) + { + accumulators[i] = stateAccumulators[i]; + } + } + } + } + + public static void DigestLong(ref State state, ulong* accumulators, byte* secret) + { + Debug.Assert(state.BufferedCount > 0); + + fixed (byte* buffer = state.Buffer) + { + byte* accumulateData; + if (state.BufferedCount >= StripeLengthBytes) + { + uint stripes = (state.BufferedCount - 1) / StripeLengthBytes; + ulong stripesSoFar = state.StripesProcessedInCurrentBlock; + + ConsumeStripes(accumulators, ref stripesSoFar, NumStripesPerBlock, buffer, stripes, secret); + + accumulateData = buffer + state.BufferedCount - StripeLengthBytes; + } + else + { + byte* lastStripe = stackalloc byte[StripeLengthBytes]; + int catchupSize = StripeLengthBytes - (int)state.BufferedCount; + + new ReadOnlySpan(buffer + InternalBufferLengthBytes - catchupSize, catchupSize).CopyTo(new Span(lastStripe, StripeLengthBytes)); + new ReadOnlySpan(buffer, (int)state.BufferedCount).CopyTo(new Span(lastStripe + catchupSize, (int)state.BufferedCount)); + accumulateData = lastStripe; + } + + Accumulate512(accumulators, accumulateData, secret + (SecretLengthBytes - StripeLengthBytes - SecretLastAccStartBytes)); + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void InitializeAccumulators(ulong* accumulators) + { +#if NET7_0_OR_GREATER + if (Vector256.IsHardwareAccelerated) + { + Vector256.Store(Vector256.Create(Prime32_3, Prime64_1, Prime64_2, Prime64_3), accumulators); + Vector256.Store(Vector256.Create(Prime64_4, Prime32_2, Prime64_5, Prime32_1), accumulators + 4); + } + else if (Vector128.IsHardwareAccelerated) + { + Vector128.Store(Vector128.Create(Prime32_3, Prime64_1), accumulators); + Vector128.Store(Vector128.Create(Prime64_2, Prime64_3), accumulators + 2); + Vector128.Store(Vector128.Create(Prime64_4, Prime32_2), accumulators + 4); + Vector128.Store(Vector128.Create(Prime64_5, Prime32_1), accumulators + 6); + } + else +#endif + { + accumulators[0] = Prime32_3; + accumulators[1] = Prime64_1; + accumulators[2] = Prime64_2; + accumulators[3] = Prime64_3; + accumulators[4] = Prime64_4; + accumulators[5] = Prime32_2; + accumulators[6] = Prime64_5; + accumulators[7] = Prime32_1; + } + } + + public static ulong MergeAccumulators(ulong* accumulators, byte* secret, ulong start) + { + ulong result64 = start; + + result64 += Multiply64To128ThenFold(accumulators[0] ^ ReadUInt64LE(secret), accumulators[1] ^ ReadUInt64LE(secret + 8)); + result64 += Multiply64To128ThenFold(accumulators[2] ^ ReadUInt64LE(secret + 16), accumulators[3] ^ ReadUInt64LE(secret + 24)); + result64 += Multiply64To128ThenFold(accumulators[4] ^ ReadUInt64LE(secret + 32), accumulators[5] ^ ReadUInt64LE(secret + 40)); + result64 += Multiply64To128ThenFold(accumulators[6] ^ ReadUInt64LE(secret + 48), accumulators[7] ^ ReadUInt64LE(secret + 56)); + + return Avalanche(result64); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong Mix16Bytes(byte* source, ulong secretLow, ulong secretHigh, ulong seed) => + Multiply64To128ThenFold( + ReadUInt64LE(source) ^ (secretLow + seed), + ReadUInt64LE(source + sizeof(ulong)) ^ (secretHigh - seed)); + + /// Calculates a 32-bit to 64-bit long multiply. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong Multiply32To64(uint v1, uint v2) => (ulong)v1 * v2; + + /// "This is a fast avalanche stage, suitable when input bits are already partially mixed." + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong Avalanche(ulong hash) + { + hash = XorShift(hash, 37); + hash *= 0x165667919E3779F9; + hash = XorShift(hash, 32); + return hash; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong Multiply64To128(ulong left, ulong right, out ulong lower) + { +#if NET5_0_OR_GREATER + return Math.BigMul(left, right, out lower); +#else + ulong lowerLow = Multiply32To64((uint)left, (uint)right); + ulong higherLow = Multiply32To64((uint)(left >> 32), (uint)right); + ulong lowerHigh = Multiply32To64((uint)left, (uint)(right >> 32)); + ulong higherHigh = Multiply32To64((uint)(left >> 32), (uint)(right >> 32)); + + ulong cross = (lowerLow >> 32) + (higherLow & 0xFFFFFFFF) + lowerHigh; + ulong upper = (higherLow >> 32) + (cross >> 32) + higherHigh; + lower = (cross << 32) | (lowerLow & 0xFFFFFFFF); + return upper; +#endif + } + + /// Calculates a 64-bit to 128-bit multiply, then XOR folds it. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong Multiply64To128ThenFold(ulong left, ulong right) + { + ulong upper = Multiply64To128(left, right, out ulong lower); + return lower ^ upper; + } + + public static void DeriveSecretFromSeed(byte* destinationSecret, ulong seed) + { + fixed (byte* defaultSecret = &MemoryMarshal.GetReference(DefaultSecret)) + { +#if NET7_0_OR_GREATER + if (Vector256.IsHardwareAccelerated && BitConverter.IsLittleEndian) + { + Vector256 seedVec = Vector256.Create(seed, 0u - seed, seed, 0u - seed); + for (int i = 0; i < SecretLengthBytes; i += Vector256.Count) + { + Vector256.Store(Vector256.Load((ulong*)(defaultSecret + i)) + seedVec, (ulong*)(destinationSecret + i)); + } + } + else if (Vector128.IsHardwareAccelerated && BitConverter.IsLittleEndian) + { + Vector128 seedVec = Vector128.Create(seed, 0u - seed); + for (int i = 0; i < SecretLengthBytes; i += Vector128.Count) + { + Vector128.Store(Vector128.Load((ulong*)(defaultSecret + i)) + seedVec, (ulong*)(destinationSecret + i)); + } + } + else +#endif + { + for (int i = 0; i < SecretLengthBytes; i += sizeof(ulong) * 2) + { + Unsafe.WriteUnaligned(destinationSecret + i, Unsafe.ReadUnaligned(defaultSecret + i) + seed); + Unsafe.WriteUnaligned(destinationSecret + i + 8, Unsafe.ReadUnaligned(defaultSecret + i + 8) - seed); + } + } + } + } + + /// Optimized version of looping over . + [MethodImpl(MethodImplOptions.NoInlining)] + private static void Accumulate(ulong* accumulators, byte* source, byte* secret, int stripesToProcess, bool scramble = false, int blockCount = 1) + { + byte* secretForAccumulate = secret; + byte* secretForScramble = secret + (SecretLengthBytes - StripeLengthBytes); + +#if NET7_0_OR_GREATER + if (Vector256.IsHardwareAccelerated && BitConverter.IsLittleEndian) + { + Vector256 acc1 = Vector256.Load(accumulators); + Vector256 acc2 = Vector256.Load(accumulators + Vector256.Count); + + for (int j = 0; j < blockCount; j++) + { + secret = secretForAccumulate; + for (int i = 0; i < stripesToProcess; i++) + { + Vector256 secretVal = Vector256.Load((uint*)secret); + acc1 = Accumulate256(acc1, source, secretVal); + source += Vector256.Count; + + secretVal = Vector256.Load((uint*)secret + Vector256.Count); + acc2 = Accumulate256(acc2, source, secretVal); + source += Vector256.Count; + + secret += SecretConsumeRateBytes; + } + + if (scramble) + { + acc1 = ScrambleAccumulator256(acc1, Vector256.Load((ulong*)secretForScramble)); + acc2 = ScrambleAccumulator256(acc2, Vector256.Load((ulong*)secretForScramble + Vector256.Count)); + } + } + + Vector256.Store(acc1, accumulators); + Vector256.Store(acc2, accumulators + Vector256.Count); + } + else if (Vector128.IsHardwareAccelerated && BitConverter.IsLittleEndian) + { + Vector128 acc1 = Vector128.Load(accumulators); + Vector128 acc2 = Vector128.Load(accumulators + Vector128.Count); + Vector128 acc3 = Vector128.Load(accumulators + Vector128.Count * 2); + Vector128 acc4 = Vector128.Load(accumulators + Vector128.Count * 3); + + for (int j = 0; j < blockCount; j++) + { + secret = secretForAccumulate; + for (int i = 0; i < stripesToProcess; i++) + { + Vector128 secretVal = Vector128.Load((uint*)secret); + acc1 = Accumulate128(acc1, source, secretVal); + source += Vector128.Count; + + secretVal = Vector128.Load((uint*)secret + Vector128.Count); + acc2 = Accumulate128(acc2, source, secretVal); + source += Vector128.Count; + + secretVal = Vector128.Load((uint*)secret + Vector128.Count * 2); + acc3 = Accumulate128(acc3, source, secretVal); + source += Vector128.Count; + + secretVal = Vector128.Load((uint*)secret + Vector128.Count * 3); + acc4 = Accumulate128(acc4, source, secretVal); + source += Vector128.Count; + + secret += SecretConsumeRateBytes; + } + + if (scramble) + { + acc1 = ScrambleAccumulator128(acc1, Vector128.Load((ulong*)secretForScramble)); + acc2 = ScrambleAccumulator128(acc2, Vector128.Load((ulong*)secretForScramble + Vector128.Count)); + acc3 = ScrambleAccumulator128(acc3, Vector128.Load((ulong*)secretForScramble + Vector128.Count * 2)); + acc4 = ScrambleAccumulator128(acc4, Vector128.Load((ulong*)secretForScramble + Vector128.Count * 3)); + } + } + + Vector128.Store(acc1, accumulators); + Vector128.Store(acc2, accumulators + Vector128.Count); + Vector128.Store(acc3, accumulators + Vector128.Count * 2); + Vector128.Store(acc4, accumulators + Vector128.Count * 3); + } + else +#endif + { + for (int j = 0; j < blockCount; j++) + { + for (int i = 0; i < stripesToProcess; i++) + { + Accumulate512Inlined(accumulators, source, secret + (i * SecretConsumeRateBytes)); + source += StripeLengthBytes; + } + + if (scramble) + { + ScrambleAccumulators(accumulators, secretForScramble); + } + } + } + } + + [MethodImpl(MethodImplOptions.NoInlining)] + public static void Accumulate512(ulong* accumulators, byte* source, byte* secret) + { + Accumulate512Inlined(accumulators, source, secret); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void Accumulate512Inlined(ulong* accumulators, byte* source, byte* secret) + { +#if NET7_0_OR_GREATER + if (Vector256.IsHardwareAccelerated && BitConverter.IsLittleEndian) + { + for (int i = 0; i < AccumulatorCount / Vector256.Count; i++) + { + Vector256 accVec = Accumulate256(Vector256.Load(accumulators), source, Vector256.Load((uint*)secret)); + Vector256.Store(accVec, accumulators); + + accumulators += Vector256.Count; + secret += Vector256.Count; + source += Vector256.Count; + } + } + else if (Vector128.IsHardwareAccelerated && BitConverter.IsLittleEndian) + { + for (int i = 0; i < AccumulatorCount / Vector128.Count; i++) + { + Vector128 accVec = Accumulate128(Vector128.Load(accumulators), source, Vector128.Load((uint*)secret)); + Vector128.Store(accVec, accumulators); + + accumulators += Vector128.Count; + secret += Vector128.Count; + source += Vector128.Count; + } + } + else +#endif + { + for (int i = 0; i < AccumulatorCount; i++) + { + ulong sourceVal = ReadUInt64LE(source + (8 * i)); + ulong sourceKey = sourceVal ^ ReadUInt64LE(secret + (i * 8)); + + accumulators[i ^ 1] += sourceVal; // swap adjacent lanes + accumulators[i] += Multiply32To64((uint)sourceKey, (uint)(sourceKey >> 32)); + } + } + } + +#if NET7_0_OR_GREATER + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static Vector256 Accumulate256(Vector256 accVec, byte* source, Vector256 secret) + { + Vector256 sourceVec = Vector256.Load((uint*)source); + Vector256 sourceKey = sourceVec ^ secret; + + // TODO: Figure out how to unwind this shuffle and just use Vector256.Multiply + Vector256 sourceKeyLow = Vector256.Shuffle(sourceKey, Vector256.Create(1u, 0, 3, 0, 5, 0, 7, 0)); + Vector256 sourceSwap = Vector256.Shuffle(sourceVec, Vector256.Create(2u, 3, 0, 1, 6, 7, 4, 5)); + Vector256 sum = accVec + sourceSwap.AsUInt64(); + Vector256 product = Avx2.IsSupported ? + Avx2.Multiply(sourceKey, sourceKeyLow) : + (sourceKey & Vector256.Create(~0u, 0u, ~0u, 0u, ~0u, 0u, ~0u, 0u)).AsUInt64() * (sourceKeyLow & Vector256.Create(~0u, 0u, ~0u, 0u, ~0u, 0u, ~0u, 0u)).AsUInt64(); + + accVec = product + sum; + return accVec; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static Vector128 Accumulate128(Vector128 accVec, byte* source, Vector128 secret) + { + Vector128 sourceVec = Vector128.Load((uint*)source); + Vector128 sourceKey = sourceVec ^ secret; + + // TODO: Figure out how to unwind this shuffle and just use Vector128.Multiply + Vector128 sourceSwap = Vector128.Shuffle(sourceVec, Vector128.Create(2u, 3, 0, 1)); + Vector128 sum = accVec + sourceSwap.AsUInt64(); + + Vector128 product = MultiplyWideningLower(sourceKey); + accVec = product + sum; + return accVec; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static Vector128 MultiplyWideningLower(Vector128 source) + { + if (AdvSimd.IsSupported) + { + Vector64 sourceLow = Vector128.Shuffle(source, Vector128.Create(0u, 2, 0, 0)).GetLower(); + Vector64 sourceHigh = Vector128.Shuffle(source, Vector128.Create(1u, 3, 0, 0)).GetLower(); + return AdvSimd.MultiplyWideningLower(sourceLow, sourceHigh); + } + else + { + Vector128 sourceLow = Vector128.Shuffle(source, Vector128.Create(1u, 0, 3, 0)); + return Sse2.IsSupported ? + Sse2.Multiply(source, sourceLow) : + (source & Vector128.Create(~0u, 0u, ~0u, 0u)).AsUInt64() * (sourceLow & Vector128.Create(~0u, 0u, ~0u, 0u)).AsUInt64(); + } + } +#endif + + private static void ScrambleAccumulators(ulong* accumulators, byte* secret) + { +#if NET7_0_OR_GREATER + if (Vector256.IsHardwareAccelerated && BitConverter.IsLittleEndian) + { + for (int i = 0; i < AccumulatorCount / Vector256.Count; i++) + { + Vector256 accVec = ScrambleAccumulator256(Vector256.Load(accumulators), Vector256.Load((ulong*)secret)); + Vector256.Store(accVec, accumulators); + + accumulators += Vector256.Count; + secret += Vector256.Count; + } + } + else if (Vector128.IsHardwareAccelerated && BitConverter.IsLittleEndian) + { + for (int i = 0; i < AccumulatorCount / Vector128.Count; i++) + { + Vector128 accVec = ScrambleAccumulator128(Vector128.Load(accumulators), Vector128.Load((ulong*)secret)); + Vector128.Store(accVec, accumulators); + + accumulators += Vector128.Count; + secret += Vector128.Count; + } + } + else +#endif + { + for (int i = 0; i < AccumulatorCount; i++) + { + ulong xorShift = XorShift(*accumulators, 47); + ulong xorWithKey = xorShift ^ ReadUInt64LE(secret); + *accumulators = xorWithKey * Prime32_1; + + accumulators++; + secret += sizeof(ulong); + } + } + } + +#if NET7_0_OR_GREATER + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static Vector256 ScrambleAccumulator256(Vector256 accVec, Vector256 secret) + { + Vector256 xorShift = accVec ^ Vector256.ShiftRightLogical(accVec, 47); + Vector256 xorWithKey = xorShift ^ secret; + accVec = xorWithKey * Vector256.Create((ulong)Prime32_1); + return accVec; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static Vector128 ScrambleAccumulator128(Vector128 accVec, Vector128 secret) + { + Vector128 xorShift = accVec ^ Vector128.ShiftRightLogical(accVec, 47); + Vector128 xorWithKey = xorShift ^ secret; + accVec = xorWithKey * Vector128.Create((ulong)Prime32_1); + return accVec; + } +#endif + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong XorShift(ulong value, int shift) + { + Debug.Assert(shift >= 0 && shift < 64); + return value ^ (value >> shift); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static uint ReadUInt32LE(byte* data) => + BitConverter.IsLittleEndian ? + Unsafe.ReadUnaligned(data) : + BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned(data)); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ulong ReadUInt64LE(byte* data) => + BitConverter.IsLittleEndian ? + Unsafe.ReadUnaligned(data) : + BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned(data)); + + [StructLayout(LayoutKind.Auto)] + public struct State + { + /// The accumulators. Length is . + internal fixed ulong Accumulators[AccumulatorCount]; + + /// Used to store a custom secret generated from a seed. Length is . + internal fixed byte Secret[SecretLengthBytes]; + + /// The internal buffer. Length is . + internal fixed byte Buffer[InternalBufferLengthBytes]; + + /// The amount of memory in . + internal uint BufferedCount; + + /// Number of stripes processed in the current block. + internal ulong StripesProcessedInCurrentBlock; + + /// Total length hashed. + internal ulong TotalLength; + + /// The seed employed (possibly 0). + internal ulong Seed; + }; + } +} diff --git a/src/libraries/System.IO.Hashing/tests/System.IO.Hashing.Tests.csproj b/src/libraries/System.IO.Hashing/tests/System.IO.Hashing.Tests.csproj index 264e4d0559b40..961ac1ef63c3a 100644 --- a/src/libraries/System.IO.Hashing/tests/System.IO.Hashing.Tests.csproj +++ b/src/libraries/System.IO.Hashing/tests/System.IO.Hashing.Tests.csproj @@ -8,6 +8,7 @@ + diff --git a/src/libraries/System.IO.Hashing/tests/XxHash128Tests.cs b/src/libraries/System.IO.Hashing/tests/XxHash128Tests.cs new file mode 100644 index 0000000000000..8d32a6f06c1d2 --- /dev/null +++ b/src/libraries/System.IO.Hashing/tests/XxHash128Tests.cs @@ -0,0 +1,1694 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Buffers.Binary; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Xunit; + +namespace System.IO.Hashing.Tests +{ + public class XxHash128Tests + { + [Fact] + public void Hash_InvalidInputs_Throws() + { + AssertExtensions.Throws("source", () => XxHash128.Hash(null)); + AssertExtensions.Throws("source", () => XxHash128.Hash(null, 42)); + + AssertExtensions.Throws("destination", () => XxHash128.Hash(new byte[] { 1, 2, 3 }, new byte[7])); + } + + [Fact] + public void Hash_OneShot_Expected() + { + byte[] destination = new byte[16]; + + // Run each test case. This doesn't use a Theory to avoid bloating the xunit output with thousands of cases. + foreach ((ulong HashHigh, ulong HashLow, long Seed, string Ascii) test in TestCases()) + { + var expectedHash128 = new Hash128(test.HashHigh, test.HashLow); + + byte[] input = Encoding.ASCII.GetBytes(test.Ascii); + + // Validate `byte[] XxHash128.Hash` with and without a seed + if (test.Seed == 0) + { + Assert.Equal(expectedHash128, ReadHashBigEndian(XxHash128.Hash(input))); + Assert.Equal(expectedHash128, ReadHashBigEndian(XxHash128.Hash((ReadOnlySpan)input))); + } + Assert.Equal(expectedHash128, ReadHashBigEndian(XxHash128.Hash(input, test.Seed))); + Assert.Equal(expectedHash128, ReadHashBigEndian(XxHash128.Hash((ReadOnlySpan)input, test.Seed))); + +#if NET7_0_OR_GREATER + // Validate `XxHash128.HashToUInt128` + Assert.Equal(new UInt128(test.HashHigh, test.HashLow), XxHash128.HashToUInt128(input, test.Seed)); +#endif + Assert.False(XxHash128.TryHash(input, destination.AsSpan(0, destination.Length - 1), out int bytesWritten, test.Seed)); + Assert.Equal(0, bytesWritten); + + // Validate `XxHash128.TryHash` with and without a seed + if (test.Seed == 0) + { + Array.Clear(destination, 0, destination.Length); + Assert.True(XxHash128.TryHash(input, destination, out bytesWritten)); + Assert.Equal(16, bytesWritten); + Assert.Equal(expectedHash128, ReadHashBigEndian(destination)); + } + Array.Clear(destination, 0, destination.Length); + Assert.True(XxHash128.TryHash(input, destination, out bytesWritten, test.Seed)); + Assert.Equal(16, bytesWritten); + Assert.Equal(expectedHash128, ReadHashBigEndian(destination)); + + // Validate `XxHash128.Hash(span, out int)` with and without a seed + if (test.Seed == 0) + { + Array.Clear(destination, 0, destination.Length); + Assert.Equal(16, XxHash128.Hash(input, destination)); + Assert.Equal(expectedHash128, ReadHashBigEndian(destination)); + } + Array.Clear(destination, 0, destination.Length); + Assert.Equal(16, XxHash128.Hash(input, destination, test.Seed)); + Assert.Equal(expectedHash128, ReadHashBigEndian(destination)); + } + } + + [Fact] + public void Hash_Streaming_Expected() + { + var rand = new Random(42); + byte[] destination = new byte[16], destination2 = new byte[16]; + + // Run each test case. This doesn't use a Theory to avoid bloating the xunit output with thousands of cases. + foreach ((ulong HashHigh, ulong HashLow, long Seed, string Ascii) test in TestCases().OrderBy(t => t.Seed)) + { + var expectedHash128 = new Hash128(test.HashHigh, test.HashLow); + + // Validate the seeded constructor as well as the unseeded constructor if the seed is 0. + int ctorIterations = test.Seed == 0 ? 2 : 1; + for (int ctorIteration = 0; ctorIteration < ctorIterations; ctorIteration++) + { + XxHash128 hash = ctorIteration == 0 ? + new XxHash128(test.Seed) : + new XxHash128(); + + byte[] asciiBytes = Encoding.ASCII.GetBytes(test.Ascii); + + // Run the hashing twice, once with the initially-constructed object and once with it reset. + for (int trial = 0; trial < 2; trial++) + { + // Append the data from the source in randomly-sized chunks. + ReadOnlySpan input = asciiBytes; + int processed = 0; + while (!input.IsEmpty) + { + ReadOnlySpan slice = input.Slice(0, rand.Next(0, input.Length) + 1); + hash.Append(slice); + input = input.Slice(slice.Length); + processed += slice.Length; + + // Validate that the hash we get from doing a one-shot of all the data up to this point + // matches the incremental hash for the data appended until now. +#if NET7_0_OR_GREATER + Assert.Equal(XxHash128.HashToUInt128(asciiBytes.AsSpan(0, processed), test.Seed), hash.GetCurrentHashAsUInt128()); +#endif + Assert.True(hash.TryGetCurrentHash(destination, out int bytesWritten)); + Assert.Equal(16, XxHash128.Hash(asciiBytes.AsSpan(0, processed), destination2, test.Seed)); + AssertExtensions.SequenceEqual(destination, destination2); + Assert.Equal(16, bytesWritten); + } + + // Validate the final hash code. +#if NET7_0_OR_GREATER + Assert.Equal(new UInt128(test.HashHigh, test.HashLow), hash.GetCurrentHashAsUInt128()); +#endif + Array.Clear(destination, 0, destination.Length); + Assert.Equal(16, hash.GetHashAndReset(destination)); + Assert.Equal(expectedHash128, ReadHashBigEndian(destination)); + } + } + } + } + + private static Hash128 ReadHashBigEndian(ReadOnlySpan span) + { + var high = BinaryPrimitives.ReadUInt64BigEndian(span); + var low = BinaryPrimitives.ReadUInt64BigEndian(span.Slice(8)); + return new Hash128(high, low); + } + + private record struct Hash128(ulong High, ulong Low) + { + public override string ToString() + { + return $"Hash128 {{ High = 0x{High:x16}, Low = 0x{Low:x16} }}"; + } + } + + private static IEnumerable<(ulong HashHigh, ulong HashLow, long Seed, string Ascii)> TestCases() + { + yield return (HashHigh: 0x99aa06d3014798d8UL, HashLow: 0x6001c324468d497fUL, Seed: 0x0000000000000000L, Ascii: ""); + yield return (HashHigh: 0x4a807558806f6b31UL, HashLow: 0xeca8475b2cc08feeUL, Seed: 0x00000000000013f0L, Ascii: ""); + yield return (HashHigh: 0xbecb6b41f8c7c702UL, HashLow: 0x8bcfeb4c4ff25443UL, Seed: 0x00000000000008baL, Ascii: ""); + yield return (HashHigh: 0xa2a900ec02fd312fUL, HashLow: 0xa75380084c7b1df2UL, Seed: 0x0000000000001bc1L, Ascii: ""); + yield return (HashHigh: 0xa26f5ff5290b016cUL, HashLow: 0x2753d05a8f320003UL, Seed: 0x0000000000000000L, Ascii: "Z"); + yield return (HashHigh: 0x4623628864bd3461UL, HashLow: 0x826ed41a6e3413f3UL, Seed: 0x5a7a3a6dd84a445fL, Ascii: "f"); + yield return (HashHigh: 0x764b216a6748e65bUL, HashLow: 0xb92fbf351dd100eeUL, Seed: 0x0000000000001c09L, Ascii: "C"); + yield return (HashHigh: 0x506e248b0503589eUL, HashLow: 0xec9a584c5994b0fbUL, Seed: 0x761747debc4bf2fdL, Ascii: "e"); + yield return (HashHigh: 0x71f1afcb4f6947d5UL, HashLow: 0x123a6f50f1ca0359UL, Seed: 0x0000000000001cf4L, Ascii: "V4"); + yield return (HashHigh: 0x054d1416a8ac6149UL, HashLow: 0x30a9330b3de18584UL, Seed: 0x27f065e4850461f5L, Ascii: "HA"); + yield return (HashHigh: 0x274c6130ae605b8aUL, HashLow: 0xccdf6c02b23ec3fcUL, Seed: 0x00000000000017e0L, Ascii: "KP"); + yield return (HashHigh: 0x3248dd8b112b8de0UL, HashLow: 0xe90908587fefc64dUL, Seed: 0x000000000000200bL, Ascii: "5O"); + yield return (HashHigh: 0xbb6d264f3da93569UL, HashLow: 0x0c3efabfc49a356eUL, Seed: 0x0000000000000840L, Ascii: "H4p"); + yield return (HashHigh: 0xed353f9a3e2c25e3UL, HashLow: 0x5ab2c95dccb3f945UL, Seed: 0x00000000000009d0L, Ascii: "9Vj"); + yield return (HashHigh: 0x6a500075fa490773UL, HashLow: 0x9a892645f137e437UL, Seed: 0x000000000000198cL, Ascii: "ajB"); + yield return (HashHigh: 0x83b9766abe82fb07UL, HashLow: 0xf917a1f0983dac91UL, Seed: 0x6f3502011f621a64L, Ascii: "kLi"); + yield return (HashHigh: 0xf29da7d603a9409fUL, HashLow: 0x90373b3f6da10e37UL, Seed: 0x0000000000000499L, Ascii: "KdjE"); + yield return (HashHigh: 0xb6b99015d0e80f41UL, HashLow: 0x15ac2f7581d32767UL, Seed: 0x0000000000000000L, Ascii: "fCiJ"); + yield return (HashHigh: 0x289387774d4702aeUL, HashLow: 0xa11bc364b3242dd0UL, Seed: 0x0000000000000f04L, Ascii: "HZOD"); + yield return (HashHigh: 0xb26e407110fee12dUL, HashLow: 0x43701b3e9f856441UL, Seed: 0x0000000000000353L, Ascii: "d9v6"); + yield return (HashHigh: 0x4da901296206362cUL, HashLow: 0x5b4171745fecbf51UL, Seed: 0x0000000000000000L, Ascii: "Zx63J"); + yield return (HashHigh: 0x0cf89ac9cf9d9848UL, HashLow: 0xadda76a25f503d7dUL, Seed: 0x00000000000019fcL, Ascii: "mosH8"); + yield return (HashHigh: 0x9c1809f990c624c0UL, HashLow: 0x8b38984e0b2c2f35UL, Seed: 0x0000000000000faaL, Ascii: "QDajZ"); + yield return (HashHigh: 0x28cf7e977573bb64UL, HashLow: 0x01f54f45353730c9UL, Seed: 0x00000000000008baL, Ascii: "DNHWf"); + yield return (HashHigh: 0xb9e61a5de2afbe81UL, HashLow: 0x753d475d0b87e693UL, Seed: 0x0000000000001062L, Ascii: "yyaFtP"); + yield return (HashHigh: 0xd5911b46e493be09UL, HashLow: 0x3198541f3c02ef75UL, Seed: 0x0000000000001d89L, Ascii: "kXzedT"); + yield return (HashHigh: 0xcfbfd6d5f49a2e56UL, HashLow: 0x26aa5e13f8a2a76eUL, Seed: 0x4ef78ad67d7e2c8fL, Ascii: "E27wiW"); + yield return (HashHigh: 0xb9515a7b65af9257UL, HashLow: 0xbf40898c0f8a0f8cUL, Seed: 0x0000000000000007L, Ascii: "M2sgd4"); + yield return (HashHigh: 0xb47c1a2be46a9038UL, HashLow: 0xcc05dcae7d590f01UL, Seed: 0x3d065f4429458c97L, Ascii: "ZTCkePQ"); + yield return (HashHigh: 0xea8aca80dae26bb2UL, HashLow: 0xe254764fa5b83a1cUL, Seed: 0x0000000000000064L, Ascii: "klpn67g"); + yield return (HashHigh: 0x519db5957ff6d25eUL, HashLow: 0x0b0e3e138a8cf5a4UL, Seed: 0x000000000000158cL, Ascii: "lPOSwvf"); + yield return (HashHigh: 0x4dfc8bc32f60ec85UL, HashLow: 0xf2081fdcb4e7adc3UL, Seed: 0x0000000000000000L, Ascii: "SbmPVuZ"); + yield return (HashHigh: 0x9ef5de9b23143fa1UL, HashLow: 0x99d532146c2c0a73UL, Seed: 0x00000000000025daL, Ascii: "TLRDvLvS"); + yield return (HashHigh: 0x020829fc5ce20aabUL, HashLow: 0x5b59238c8cc116bfUL, Seed: 0x0000000000001a31L, Ascii: "5kKXT8hE"); + yield return (HashHigh: 0xeb44c89e63652621UL, HashLow: 0xc84f4604987a580eUL, Seed: 0x0000000000002051L, Ascii: "UHj4U70w"); + yield return (HashHigh: 0xf8413a924a279bd1UL, HashLow: 0xe1ad88ff626f786fUL, Seed: 0x000000000000095fL, Ascii: "YYiJtbOe"); + yield return (HashHigh: 0xa98564b5fb852a84UL, HashLow: 0xdef8b6b70a62024cUL, Seed: 0x00000000000006d1L, Ascii: "EGM4yxHgk"); + yield return (HashHigh: 0x16012a87e426b9cbUL, HashLow: 0x4082958cd43d6513UL, Seed: 0x00000000000014b2L, Ascii: "ixKUUt5pO"); + yield return (HashHigh: 0x6367b1c4996543fcUL, HashLow: 0x761f04e10593209bUL, Seed: 0x00000000000022b1L, Ascii: "s6aMbUVkK"); + yield return (HashHigh: 0x81b1195f861a569fUL, HashLow: 0xc4723ec01465266cUL, Seed: 0x70cb1cd220fe3a09L, Ascii: "SsNiqNqBf"); + yield return (HashHigh: 0x2b8ed073c7d1a9a8UL, HashLow: 0x2a8b2106ac7829caUL, Seed: 0x00000000000011e0L, Ascii: "Ov4zwcvLx0"); + yield return (HashHigh: 0x3a122b70036e904fUL, HashLow: 0x229f40d4a8e52ffdUL, Seed: 0x00000000000009e3L, Ascii: "bM7sIUkRTp"); + yield return (HashHigh: 0x0b864bf7ff537160UL, HashLow: 0xc59daa13b10e606bUL, Seed: 0x0000000000002313L, Ascii: "sitCYl1zu2"); + yield return (HashHigh: 0xfbcde1ed8641b470UL, HashLow: 0x75f88cb1362f1c2dUL, Seed: 0x0000000000000d3bL, Ascii: "Ck3S0qy5xH"); + yield return (HashHigh: 0xa16e4736df3d24b2UL, HashLow: 0xec73bef56c57450dUL, Seed: 0x0000000000000bbcL, Ascii: "Y4lXHPbJCix"); + yield return (HashHigh: 0xc696323ec62ad592UL, HashLow: 0x398891b92d8dd119UL, Seed: 0x00000000000022bcL, Ascii: "yD0Ex2vQ9zW"); + yield return (HashHigh: 0x4fea8787fd490ddaUL, HashLow: 0x2c69900c70d19b04UL, Seed: 0x0000000000000000L, Ascii: "uOnyD2tQQ7v"); + yield return (HashHigh: 0x9f999df17cd05310UL, HashLow: 0xe3aa72d1092ebb8fUL, Seed: 0x5539de8caf41e41aL, Ascii: "vTU3yFsqOQ6"); + yield return (HashHigh: 0xd2e9f28209687ec1UL, HashLow: 0x4bce6fa0bf99412eUL, Seed: 0x00000000000013d1L, Ascii: "Hy3emis1M7eV"); + yield return (HashHigh: 0x3c038688775fe64fUL, HashLow: 0x54000864b933726bUL, Seed: 0x0000000000000647L, Ascii: "ZuXRMHrPQHtz"); + yield return (HashHigh: 0x575ac4345a1b6ad0UL, HashLow: 0x0f2087776d37810fUL, Seed: 0x00000000000017ebL, Ascii: "TsKvY0FLKoQf"); + yield return (HashHigh: 0xb2675e6ad8339bd2UL, HashLow: 0xd69c359804383ca2UL, Seed: 0x0000000000002512L, Ascii: "s9hk0ogUPKf1"); + yield return (HashHigh: 0x3c251a63e3d48d6fUL, HashLow: 0x038087b74c6e14dcUL, Seed: 0x00000000000013fbL, Ascii: "kdFgtjHcConq5"); + yield return (HashHigh: 0x297175e758e86f57UL, HashLow: 0xcd7498d94a672885UL, Seed: 0x0000000000000000L, Ascii: "PfI6lstr0ZLWG"); + yield return (HashHigh: 0xbb0c381e51998f64UL, HashLow: 0x57719f37134a266aUL, Seed: 0x00000000000023e6L, Ascii: "0ryRPmjP1mSun"); + yield return (HashHigh: 0xc1ff2ee022be1ad2UL, HashLow: 0x2bd68a11c0606c5fUL, Seed: 0x0000000000000000L, Ascii: "XEjB6XqOe5ymx"); + yield return (HashHigh: 0x05350b438700d9c8UL, HashLow: 0x461ea209cf21ebcaUL, Seed: 0x000000000000139aL, Ascii: "64WbTFxlWe3U2k"); + yield return (HashHigh: 0x3eadb498d13a37d7UL, HashLow: 0x622e40b0d1df1d28UL, Seed: 0x268e74fe41033efbL, Ascii: "He08m7cz6BVUKB"); + yield return (HashHigh: 0x5abdfbdcd245e260UL, HashLow: 0xa2a968262e882547UL, Seed: 0x0000000000001fb0L, Ascii: "Ij5MBfLKVkAFYF"); + yield return (HashHigh: 0x10ba15135341f2efUL, HashLow: 0x38ae7fa8bdcba136UL, Seed: 0x0000000000000000L, Ascii: "VSVb2538wGyeRM"); + yield return (HashHigh: 0x836653ac668d328bUL, HashLow: 0x134c845fa1140333UL, Seed: 0x0000000000000a27L, Ascii: "hueNVzaX9p7JdKL"); + yield return (HashHigh: 0xc77cc4e476afa994UL, HashLow: 0x48075e4b92a682a4UL, Seed: 0x511ca41ca4193614L, Ascii: "kpx0STYilb7EM88"); + yield return (HashHigh: 0xcfae3e25c13a277cUL, HashLow: 0xfa327321c32db69fUL, Seed: 0x0000000000001cf5L, Ascii: "dvmStMmz8Uhj4G0"); + yield return (HashHigh: 0x66b801b19a8b3ec7UL, HashLow: 0x12935062325aa240UL, Seed: 0x0000000000002464L, Ascii: "8csqW0j3hptGCwO"); + yield return (HashHigh: 0xbf9e3fce82fea007UL, HashLow: 0x51ae8dd7283b1328UL, Seed: 0x27ea2fd22273f024L, Ascii: "fcuQxJ1a7XHWjOak"); + yield return (HashHigh: 0x04a18c598ec0b7e5UL, HashLow: 0x660762826fd6d2e4UL, Seed: 0x0000000000001d88L, Ascii: "cTXadjhxzktQVtPW"); + yield return (HashHigh: 0xe4521ffc01debde3UL, HashLow: 0x65c22c1974720a41UL, Seed: 0x00000000000011ddL, Ascii: "VdnhfZNlPd5zBO9G"); + yield return (HashHigh: 0xe70ae568494fc62cUL, HashLow: 0x2a9bbc733b7c639eUL, Seed: 0x00000000000001f1L, Ascii: "sRcoac2Z1XKinWsY"); + yield return (HashHigh: 0x1f3ba7ee629b72e0UL, HashLow: 0x8e26be7440f5fc90UL, Seed: 0x00000000000019c9L, Ascii: "4pgR1N0LgL2QpoaNc"); + yield return (HashHigh: 0xe414f6707f6ead9aUL, HashLow: 0xa7fcffec8f76f118UL, Seed: 0x1e18b9a7c8f02d7dL, Ascii: "ZJaCUfU0OXHoLCEfw"); + yield return (HashHigh: 0x12235b54944449d9UL, HashLow: 0xbeb38a091327c173UL, Seed: 0x00000000000012abL, Ascii: "uUFLXT60uVkCOXvPj"); + yield return (HashHigh: 0x2c733d5a026d4083UL, HashLow: 0x71ba1a2164870694UL, Seed: 0x0000000000000a7aL, Ascii: "uLLdztp6cDZ1pL9BR"); + yield return (HashHigh: 0x5a7f341db512a31cUL, HashLow: 0x7e2e0349c0e69e6bUL, Seed: 0x0000000000001962L, Ascii: "LuOyAcRwmGEH8z6k6m"); + yield return (HashHigh: 0x88312137dc4b6af8UL, HashLow: 0x6aae2cde1c9c88ceUL, Seed: 0x0000000000000000L, Ascii: "KDuzVTjAQ4xNGS3WF6"); + yield return (HashHigh: 0xdb49e798a5203d13UL, HashLow: 0x8018da180b94a4efUL, Seed: 0x0000000000000ebeL, Ascii: "A1ihuWZ2uERWycZxPa"); + yield return (HashHigh: 0x2b849e4e52aa0ed2UL, HashLow: 0xb95f9ca4526d0961UL, Seed: 0x00000000000009c2L, Ascii: "3Ux0vVy8UG3pLbfakF"); + yield return (HashHigh: 0x0c80d091f072b327UL, HashLow: 0x71054be7717504f0UL, Seed: 0x0000000000000000L, Ascii: "kZADmGnOFWl6Phiu8tE"); + yield return (HashHigh: 0x42ab70e912af4e15UL, HashLow: 0x5b08618751756b74UL, Seed: 0x16580c02347e75b6L, Ascii: "86PTDY6UXtSuJUe22wA"); + yield return (HashHigh: 0xf66d33242d08959aUL, HashLow: 0x77cc4c45f50ce208UL, Seed: 0x00000000000007eeL, Ascii: "PVFVy0kMDJgMo593sxl"); + yield return (HashHigh: 0x073c5989bf4fa6c0UL, HashLow: 0x526253288d710d17UL, Seed: 0x0000000000001571L, Ascii: "aerl20lkguiB4Gf3T9R"); + yield return (HashHigh: 0x8f60190e04b20030UL, HashLow: 0x850448a147507baeUL, Seed: 0x55babd76a130f515L, Ascii: "aGfZbBNKvUGfWCu34gub"); + yield return (HashHigh: 0xbb99ac16f4945cb4UL, HashLow: 0x918a3f7892a28c6aUL, Seed: 0x0000000000000000L, Ascii: "VMkxhcMDr321w7YjThXV"); + yield return (HashHigh: 0xfff510bc9bf53685UL, HashLow: 0xc6f6c1b456e9bf6fUL, Seed: 0x0000000000000ddaL, Ascii: "DmBC0bnc4kQOA6YCsPpe"); + yield return (HashHigh: 0x3a57a810cd4c8ae3UL, HashLow: 0x392cd4dadf5651b7UL, Seed: 0x000000000000074dL, Ascii: "RBwHqQrG3cyoDw0eLlT3"); + yield return (HashHigh: 0x79bb83de1c692143UL, HashLow: 0x9bef365c4c43131fUL, Seed: 0x0000000000000d19L, Ascii: "HpsRBCVOx5SkugteBIbaQ"); + yield return (HashHigh: 0x66097c1fc468d198UL, HashLow: 0x6f79ea3f021705c9UL, Seed: 0x0000000000002214L, Ascii: "G9YRrhLX02ReHdMSPJhsn"); + yield return (HashHigh: 0x167dd8c10ad24ca7UL, HashLow: 0x24d10d5a8a573a31UL, Seed: 0x0000000000000000L, Ascii: "x35LiatiPGJa74outlVGU"); + yield return (HashHigh: 0x5687c9578a8af662UL, HashLow: 0xb459433f882b2f5eUL, Seed: 0x000000000000188eL, Ascii: "AsHWiTENK1HPZr0XPVA9m"); + yield return (HashHigh: 0xe5cc06711fd7125dUL, HashLow: 0x2793a1bc5ad230dcUL, Seed: 0x000000000000245bL, Ascii: "ocWWrY4XvGhWB3fRZfuOHP"); + yield return (HashHigh: 0x01f71c3cd79a9cdbUL, HashLow: 0x47dfbc53c890099dUL, Seed: 0x0000000000000000L, Ascii: "Fjc59qu4SZWLuTuklHLxk1"); + yield return (HashHigh: 0x9f4d0609fbcadf0aUL, HashLow: 0xc679f70fe1241040UL, Seed: 0x00000000000018b1L, Ascii: "oqcVab4jAR21vhNpsbp2AT"); + yield return (HashHigh: 0xa9d517e93349e24fUL, HashLow: 0x1a17d204aaa740afUL, Seed: 0x0000000000000000L, Ascii: "ymXSTaCeolI6VjlQgh6cMl"); + yield return (HashHigh: 0x33f2f3847bbbeaedUL, HashLow: 0x1eaa1999af974e6bUL, Seed: 0x000000000000070cL, Ascii: "ug3aKCkY08yMF2Iz86ig55v"); + yield return (HashHigh: 0x5a50005621f22559UL, HashLow: 0x4b791432d34e3cd5UL, Seed: 0x0000000000002535L, Ascii: "rDC2FcItWoHusdg0fedMIB3"); + yield return (HashHigh: 0x6627e0bcd66c1cf0UL, HashLow: 0x782a793594e27209UL, Seed: 0x0000000000000000L, Ascii: "9vM6157UG2KPMPYg8bicb1e"); + yield return (HashHigh: 0x908e625821fb265dUL, HashLow: 0x23ecfb0247a16efaUL, Seed: 0x00000000000015b3L, Ascii: "Z8LQMWuVPsXAB6IuP15y25c"); + yield return (HashHigh: 0xde9e607a15cf780aUL, HashLow: 0x06e5f9c3a56d5be5UL, Seed: 0x000000000000252fL, Ascii: "C7tG9KNrvX7GP5Fb4AONOkLt"); + yield return (HashHigh: 0xbb1380c08962f0a1UL, HashLow: 0x582eff56047085eeUL, Seed: 0x0000000000001587L, Ascii: "YOI0xGx2Ge1jdh6k6KsXCFXI"); + yield return (HashHigh: 0x087174e73e004842UL, HashLow: 0x8d1c18e99aa89f10UL, Seed: 0x0000000000000000L, Ascii: "7iOlOMeM6UmJnavHzgMSUdZ9"); + yield return (HashHigh: 0xfca964a9d8ed87ccUL, HashLow: 0x7337acc5722afdb1UL, Seed: 0x0000000000000000L, Ascii: "CbxYsDsDPFbc4H0qmKCvXr3m"); + yield return (HashHigh: 0x9a5a732bd08658ffUL, HashLow: 0x9e79227c2ec02ff5UL, Seed: 0x0000000000000000L, Ascii: "kcvageMDWBf8N6f4QRjW8492m"); + yield return (HashHigh: 0xba2f21b61db2be15UL, HashLow: 0x67ab5a1dbd487895UL, Seed: 0x000000000000107bL, Ascii: "3hatHgqJ43eeWMVabG3ZmGH2E"); + yield return (HashHigh: 0xa7585cc024226753UL, HashLow: 0x86fae8edb7c5382aUL, Seed: 0x00000000000014f9L, Ascii: "GZZO2HsROBhSwPibHjl3C9K9r"); + yield return (HashHigh: 0x3523734739f92d53UL, HashLow: 0x1aec2232165bba8eUL, Seed: 0x00000000000003d8L, Ascii: "sy5RrooAbS2a4spp3UT3g3B8s"); + yield return (HashHigh: 0xcf3696dec9e686f5UL, HashLow: 0xed4b05ab45d1e5c5UL, Seed: 0x0000000000000cc8L, Ascii: "GjnKAVokRisPBwjCceOHrVnR9M"); + yield return (HashHigh: 0x5bc593b542c1b4b0UL, HashLow: 0xaa8508826938e7c0UL, Seed: 0x011a75bcd188cfd0L, Ascii: "5qzewuqd4RMJJVBTbd7z4vEv5Q"); + yield return (HashHigh: 0xce1541a5cb7b5058UL, HashLow: 0xe0ba8df2e74fb66dUL, Seed: 0x0000000000002085L, Ascii: "cDjSOSHGn8nM839nFvNqPc0oLw"); + yield return (HashHigh: 0x49dd6f8d88d5e61eUL, HashLow: 0x33d8f061f420b1e2UL, Seed: 0x00000000000025e7L, Ascii: "zZWOvuCOQ7S78PmteXs9orf1sW"); + yield return (HashHigh: 0xa4c278de9a8a2135UL, HashLow: 0x828c7677d5f2345dUL, Seed: 0x0000000000001df7L, Ascii: "Equb0NmabCbKGaEmh6dE8gjfL1E"); + yield return (HashHigh: 0x8984aa4098b7f9ffUL, HashLow: 0xdb3cc2ff3f14c5b8UL, Seed: 0x00000000000012b5L, Ascii: "X7vd0dgpT9eRzMHx3LDgjvEQwE4"); + yield return (HashHigh: 0xf9f2a7cc3f59980dUL, HashLow: 0xd9e5bdb4c7c83da8UL, Seed: 0x0000000000002370L, Ascii: "H8QsGBXFPf89x5Q47qSBj4AhT3u"); + yield return (HashHigh: 0x227255a30d2571b8UL, HashLow: 0xaab49a97ad9bd967UL, Seed: 0x0000000000000000L, Ascii: "8TRix56rWbRPISXdMbdtjKAeZRZ"); + yield return (HashHigh: 0x4031fb88da3925e4UL, HashLow: 0x9c74e64f3b042834UL, Seed: 0x3f54eddf60ada18bL, Ascii: "icq9LPMDvmULotIweEESeEDVi0HN"); + yield return (HashHigh: 0x423152c3b7ad40c6UL, HashLow: 0xd698982f494d629bUL, Seed: 0x0000000000000000L, Ascii: "i6PCFvzKoWZ2qkeiCTA2r8rywUkZ"); + yield return (HashHigh: 0xfb87e9a91563cfbbUL, HashLow: 0x4156aac971d6b931UL, Seed: 0x0000000000000a63L, Ascii: "b7zmpPTGOXWgpxCGNrLdGrjgpUkp"); + yield return (HashHigh: 0xfab2cb544fd820a2UL, HashLow: 0xc18dea55ed24bd6bUL, Seed: 0x0000000000000f88L, Ascii: "7ER0gY3jYRTc7UuQX0jy4ILm0QxP"); + yield return (HashHigh: 0x2d1e39d5eaab2af0UL, HashLow: 0x2a70f2eeac683d0bUL, Seed: 0x000000000000064dL, Ascii: "srmanGgb2muidgoV99SSZDXii7Gf2"); + yield return (HashHigh: 0xf2406cceeaf789b1UL, HashLow: 0x7f357e0d4b0dbd94UL, Seed: 0x0000000000000000L, Ascii: "SkZnT9dHnEaafaU0YQIBnB735xYcl"); + yield return (HashHigh: 0xcab951ee4bbebc43UL, HashLow: 0x06925aaa2a673fb8UL, Seed: 0x000000000000162aL, Ascii: "dl5ZP6cffXfE3l0PAWd51TBvSsG9S"); + yield return (HashHigh: 0x610ba5617e546152UL, HashLow: 0xacea3ce6524e43d4UL, Seed: 0x0000000000000f18L, Ascii: "CSQBwJqxtVJeMOv5mqzH6g7ZGnPyh"); + yield return (HashHigh: 0x7f0e0f3aa7cf82f2UL, HashLow: 0xc493df64be1cb131UL, Seed: 0x000000000000222cL, Ascii: "tTGa8TJUETEztj5zsfDWU2BwGmB6Ky"); + yield return (HashHigh: 0xdc64bf2a49682c98UL, HashLow: 0x0a5862b8f34eb2f0UL, Seed: 0x00000000000000d1L, Ascii: "ZakSEMaZxYJnhoj40dgW0Od1dBrpBd"); + yield return (HashHigh: 0xef37b48c0dcf30faUL, HashLow: 0xf86a3d7c9c12f0e9UL, Seed: 0x0000000000000000L, Ascii: "b7k1mN7utrKrm0UCDOArIhg6D1xEg9"); + yield return (HashHigh: 0x1e1346e62386e738UL, HashLow: 0x526793e7355d4fbeUL, Seed: 0x2ed1256a014f6d46L, Ascii: "ECJ4VLtsuggTR4wcLJjTm8x6DXFhTB"); + yield return (HashHigh: 0x9a79d2b1024b18e7UL, HashLow: 0x355787a651015181UL, Seed: 0x00000000000026e6L, Ascii: "DiRtMWxnI3qkMdYanz82e6bfpp8VUTw"); + yield return (HashHigh: 0xe45a5e4de60a1d29UL, HashLow: 0x8016c4e1f68959adUL, Seed: 0x113a1735f166548bL, Ascii: "4gIXXrYOrAJpQZtb2lYLqsqzrRBdRh3"); + yield return (HashHigh: 0xac76c0f645ac910fUL, HashLow: 0x7fe76cc004fd8c41UL, Seed: 0x0000000000001d1cL, Ascii: "RuxoiJfBipXTwGRnMLXS9UiaQDLYy35"); + yield return (HashHigh: 0x7e733bd5cc4a0fa5UL, HashLow: 0xd62a4d833bf0fd9cUL, Seed: 0x0000000000000000L, Ascii: "Z0KHCqxcHGVVuwQUDbQMSqYJcBl9y6U"); + yield return (HashHigh: 0x0cb534f1fbd7ccbcUL, HashLow: 0x2fcd13cb42c47ad4UL, Seed: 0x0000000000000000L, Ascii: "Tc8otaCWJhcl5Nz5CDz7vFJX6zsYPl4I"); + yield return (HashHigh: 0x121b8e2a654c5f04UL, HashLow: 0xe2ee0fbe65be642dUL, Seed: 0x0000000000001162L, Ascii: "H3tw59bhz1T1nnR3phpWiSkdwEpOuz5s"); + yield return (HashHigh: 0x1912c33cd6bfe613UL, HashLow: 0x7af33ab3183bfbbcUL, Seed: 0x0000000000000000L, Ascii: "xB0c6wK9bmxwnzf2jvZNxOYJNM2fGL0r"); + yield return (HashHigh: 0xf5266cebff992781UL, HashLow: 0xecfb92c488654a79UL, Seed: 0x0000000000000b0eL, Ascii: "lDzIPQrmi2UvgSSWTe0sMEXWNQX1t3ZC"); + yield return (HashHigh: 0xd961769319c53b55UL, HashLow: 0x4d9b9dde38966881UL, Seed: 0x23eaccb8f24a289dL, Ascii: "6Dj7XpVnlDS3iskE2RiCX7f46L3pxayir"); + yield return (HashHigh: 0x877a8a6f474d64f6UL, HashLow: 0x7c91a261d7a43c89UL, Seed: 0x00000000000014a7L, Ascii: "k2TsCmhgBSoOIYeZduUoVjR377OQE1JfY"); + yield return (HashHigh: 0xbfe1f40d123aa39eUL, HashLow: 0x44d8d3ff9d79a493UL, Seed: 0x00000000000024acL, Ascii: "aOR7hd3xbGoB0FQGYZ2ufM2ueyyDV0L93"); + yield return (HashHigh: 0x9a40d0438baa71a7UL, HashLow: 0x515cec6af4476090UL, Seed: 0x0000000000000978L, Ascii: "L9E196PbLYnr7TKQb44d2jPAjLDuE2xMq"); + yield return (HashHigh: 0xb8bbce0684d1cc58UL, HashLow: 0xb291b3d9ef093c2aUL, Seed: 0x00000000000015d7L, Ascii: "X1a9zapq9YvpqtP0LQwkXCacvz8TTJrR5m"); + yield return (HashHigh: 0x33d0ba6547a5482eUL, HashLow: 0x221f75763d2d15beUL, Seed: 0x2ba124b4f3ead0deL, Ascii: "o5t9IPouVvQ7Anqa8b96M0JKZEQer4Io87"); + yield return (HashHigh: 0xaa517a80cac5f907UL, HashLow: 0x6b3b06d70695bc82UL, Seed: 0x0000000000000000L, Ascii: "vRTbTeQP2nIh2u5LeK5w4s2Pa1kjw73Vwk"); + yield return (HashHigh: 0x7e3ed77059aaf4c0UL, HashLow: 0x8a98b186c5058cfbUL, Seed: 0x0000000000000000L, Ascii: "30vfO7V1QAAifNBsjia1qbCIP80KqjvqGf"); + yield return (HashHigh: 0xd61757ac3d54dd3eUL, HashLow: 0x997e8d274c520f5cUL, Seed: 0x3ffe7d86a697da93L, Ascii: "FAIUOWamAotqfoHv4Ie6Iib8Z59ZSO3nmkd"); + yield return (HashHigh: 0x8cc320d76d51ebd1UL, HashLow: 0x34fecb5247399ab5UL, Seed: 0x00000000000014c6L, Ascii: "XS8b1YF7ljMz6H6XcUtNA5VTQ2noYWTSHDj"); + yield return (HashHigh: 0x518094b708e83606UL, HashLow: 0x5cb7f6052b0fa4caUL, Seed: 0x0000000000000000L, Ascii: "yFgI3MX0SsxIReDPO67ELAEPam8KZB38hK3"); + yield return (HashHigh: 0xf5b7ad6fa7886447UL, HashLow: 0x314678c9b02c29cdUL, Seed: 0x00000000000014b4L, Ascii: "Zj6tDKmocGIFyyCmDJf2u91Sabx3pLiQ5Bi"); + yield return (HashHigh: 0x3ac5eab6557b9523UL, HashLow: 0xe72fd486db472f6aUL, Seed: 0x10ec20959d09dd55L, Ascii: "xOwM20yHXHCf6d6a3KbbQfLGeSLZASkWILAs"); + yield return (HashHigh: 0xecb2bbe9417426baUL, HashLow: 0x642b47da0f3cf681UL, Seed: 0x0000000000000a20L, Ascii: "TZAxr2MOi7t5U4bY7ViTVRFHW2k6GLa03a0X"); + yield return (HashHigh: 0xe4a443da1d1ed626UL, HashLow: 0xd8d2a812c460f7d4UL, Seed: 0x00000000000019b7L, Ascii: "04bBCjlbOURXBpQWFXiyqnpijPdMBjSQLY9Y"); + yield return (HashHigh: 0xd91c67238ac19941UL, HashLow: 0xe7dd77cf692df7e8UL, Seed: 0x0000000000000418L, Ascii: "4OQFyXv26youfQn4z9uBe4dEcqxXuvmA5FZh"); + yield return (HashHigh: 0xa01cd6822701e7a8UL, HashLow: 0x72e52e54d2211b39UL, Seed: 0x6aaaeac1e226ce06L, Ascii: "eFdnTZwHdKvPkPQ8Bo5bivEk6mHC4tNjoZ7l3"); + yield return (HashHigh: 0x9b66a9bbc70f3a37UL, HashLow: 0x52a8bd02e075939eUL, Seed: 0x0000000000000bfbL, Ascii: "WOnlojc8sZner4PjtLzhHkh3Y4OGqromTrsWx"); + yield return (HashHigh: 0xec6a24e06f704a5cUL, HashLow: 0xa96d7eb152da7d98UL, Seed: 0x0000000000000000L, Ascii: "7W1tr4qALkdKhiOwtFHbNxWh949TA6fRPNAED"); + yield return (HashHigh: 0x3f775a02f5d2c4afUL, HashLow: 0x375d3111d2c3eb00UL, Seed: 0x0000000000000000L, Ascii: "GjIC9TfpZS187U5qnS0m5BjlFYIlCb65drVYx"); + yield return (HashHigh: 0x4dc1db88e720147eUL, HashLow: 0x0b6992192eb825daUL, Seed: 0x0000000000002096L, Ascii: "rq1m7dsJynO2hnuN29L032MvweATJteQzb5s9m"); + yield return (HashHigh: 0xdeca67855f921396UL, HashLow: 0x969eec52b1ef1e1bUL, Seed: 0x0000000000002531L, Ascii: "pcop6coqVECPZ6Ywdfw0tf97F2gIUIQSIlYsGR"); + yield return (HashHigh: 0xa3d581605880a96fUL, HashLow: 0x77638040f533d88aUL, Seed: 0x0000000000002612L, Ascii: "V0tLcpF0mLBRLatMz67ME7g2R0uZVsFUG7HWC0"); + yield return (HashHigh: 0xec4cb38fc38cd0b5UL, HashLow: 0x8828cd3a01cb1986UL, Seed: 0x0000000000000e20L, Ascii: "FgTTUKngL13WKXstwuSKGAsEmrKxmRm29WD86d"); + yield return (HashHigh: 0xe16bebcc35d56cdeUL, HashLow: 0xd5b3e889a6197c0cUL, Seed: 0x00000000000014f9L, Ascii: "VSnKYX4NmxyAAoVJAS5YzzqqwtJp5DjL9ogkvaY"); + yield return (HashHigh: 0x61d4418aa94d7a3fUL, HashLow: 0x951328529534fdd3UL, Seed: 0x0000000000000a69L, Ascii: "dXgaJgKCJ849AED2FyHLi2Hjd4wU7n02iEk3Haf"); + yield return (HashHigh: 0x2c71395ddc05d36eUL, HashLow: 0xff652db2ab78cfe3UL, Seed: 0x0000000000000b25L, Ascii: "yTQVdgm7uIuiAaz1qknDpajdBTNMXMCbNZR4MFX"); + yield return (HashHigh: 0x6f0e1fc7c616fad1UL, HashLow: 0x606418b9cd175bb3UL, Seed: 0x0000000000000000L, Ascii: "CTiZlNvCQ3UGNvemq0dPvPKqyhMn316cDcPJSqG"); + yield return (HashHigh: 0x32ddd82fba526c4dUL, HashLow: 0xcc1e40490a434cccUL, Seed: 0x7b510ad4c9cd1f2bL, Ascii: "vQMOlSQtz9Zs9EX3iUUVdabSsD1GVaXEf99LFt08"); + yield return (HashHigh: 0x539fa3326625fcebUL, HashLow: 0x94e2742d73332d39UL, Seed: 0x3c2edddf6ae3473aL, Ascii: "VfPMDOuJiYd7K35LzrckzjaCaEhY1YqtrdModUEb"); + yield return (HashHigh: 0xcccb08d970a1eaedUL, HashLow: 0x0112e76dadf8b80dUL, Seed: 0x0000000000000625L, Ascii: "bdtPfyPoSB65mUWrLWvDQ9YcPmf3aYDbTAP3qTiv"); + yield return (HashHigh: 0x9f5ee7a4c7ab1531UL, HashLow: 0x27727101bbbc48e1UL, Seed: 0x000000000000248eL, Ascii: "a5zgDNpHWC0CvOccqiABGDcnyZwwRxbD2bpj90vl"); + yield return (HashHigh: 0x742268a669b483afUL, HashLow: 0x8d56d65f71e6822eUL, Seed: 0x000000000000183bL, Ascii: "sACG5HtreqQdQ4H9yXLk81UfD2Av3aSTcZdqClt6R"); + yield return (HashHigh: 0x6bd1293a3e5eb00eUL, HashLow: 0x961e59da7c442504UL, Seed: 0x00000000000002c3L, Ascii: "nFIS8engjL85yGKk6CHIBoi2XVSGnO0SazJEcomqb"); + yield return (HashHigh: 0x4ce190a899713fceUL, HashLow: 0x91294c3c430f9284UL, Seed: 0x0000000000000000L, Ascii: "gJrLLQoUXbZrVIrC8hVi3JCvxDNnxmXJ8B0WpcbHc"); + yield return (HashHigh: 0x97b85c55fce463acUL, HashLow: 0x130678f34a5e4cd5UL, Seed: 0x00000000000005c1L, Ascii: "57C715ySXk7ymep2B4o0MNRiGEsK6esgnTQhv5q4P"); + yield return (HashHigh: 0xab46eded3b4537e5UL, HashLow: 0xcd635684ee04782cUL, Seed: 0x0000000000000000L, Ascii: "7zCrwP8ISCDHpoTWQLygqG6deBqXmQggsreOQWxxXw"); + yield return (HashHigh: 0xf8e7e1c42bf85e61UL, HashLow: 0xf70a249888b1690dUL, Seed: 0x000000000000212bL, Ascii: "KKQzNTI5jMtHVROqR85d8I4rpldY23KcCqVYMJvFIl"); + yield return (HashHigh: 0x46ed3e841fd03223UL, HashLow: 0xa5dc4f9d55e1fa6aUL, Seed: 0x0000000000002281L, Ascii: "9QvlFSi8AOwfwzdY2DVPEtKkysr2E5ec98EZ7laNm8"); + yield return (HashHigh: 0x336250baebfdc728UL, HashLow: 0xfb636f937fb6165aUL, Seed: 0x0000000000000dd8L, Ascii: "tdZwMxNh2wMQDQCjrJAcUvbwnfoGGmDKgRxGu0Eanv"); + yield return (HashHigh: 0x6e9a9da5144647b3UL, HashLow: 0xcf5ae98818f89351UL, Seed: 0x0000000000001e5dL, Ascii: "8eQws6NnMzpSfvW69EJnkg1gYSLKiuJrT5UVsQnrsmR"); + yield return (HashHigh: 0xa879e41e507eaaeeUL, HashLow: 0x0916830d8d5aacf8UL, Seed: 0x3269ffabf9fe4912L, Ascii: "Edxrm8YOHQ69GcaJFDBDMS4t1tL1huF1C4l0YlTMa5j"); + yield return (HashHigh: 0x6749fa3894bf85f1UL, HashLow: 0xed2a15d9e952672aUL, Seed: 0x00000000000001b2L, Ascii: "iIb3TJacRk5lTmjUVwb50hrGdnI9GbrJIZLDbzdxiEz"); + yield return (HashHigh: 0x8cd9ed14e69319afUL, HashLow: 0x8e2fe5ac67d80e5fUL, Seed: 0x45bc9445ec98a116L, Ascii: "QNGZnwuSJxE9w5GbecA65ajidWuNQWH9i7DD14PZQmq"); + yield return (HashHigh: 0x869d93e8126ade07UL, HashLow: 0xcf536b58b896f4d5UL, Seed: 0x0000000000000000L, Ascii: "TmQKZZKn5GUyOJDneWKHBkNtFHc0PfDRsUWTsdfvpnmB"); + yield return (HashHigh: 0x51dba0f6c5dac14aUL, HashLow: 0x6bc35abf1badf620UL, Seed: 0x2c6d4115a33ec2b1L, Ascii: "2esyriPaAO5FmQd0K8PqkjuQLUfw0rYxn2tpfkoRW5PO"); + yield return (HashHigh: 0x132e11c7e9161451UL, HashLow: 0x80e869d310ec28faUL, Seed: 0x0000000000001d98L, Ascii: "LMEKV14ZqsFpOq0izrKQphMbQ9JEmLuzLEMuJGKhUlUd"); + yield return (HashHigh: 0x730d360f1adfc5a4UL, HashLow: 0x3b247667b9d4e4bfUL, Seed: 0x000000000000147bL, Ascii: "uTrlb8pId8MuDzBBHgrSYiBWto8oIRcq25j6mHHOPnk5"); + yield return (HashHigh: 0x933f4977597b4b77UL, HashLow: 0x0f79283b8c41f610UL, Seed: 0x7c45ea4a6dba9f4bL, Ascii: "Zld7gfG0QSNQTJXR0ejdBjJX6CcBrMUH09fe0CdkdWt9W"); + yield return (HashHigh: 0x1e62f68e9302a350UL, HashLow: 0x679d411a4ec9171fUL, Seed: 0x0000000000000000L, Ascii: "6S17ZBT7gAnKSmTHLQZhVYvz9x7qJQSFXwg2TAgLN8o5Y"); + yield return (HashHigh: 0x64716f84aa728f87UL, HashLow: 0x42f463bc942fc31dUL, Seed: 0x0000000000000531L, Ascii: "zgOcPuSSNhWP4mtIsengVnbgCwP81Jn2Ywt0DvlYZGdAY"); + yield return (HashHigh: 0x4a889bad6e46fbcaUL, HashLow: 0x0c301c9dd6e98d6aUL, Seed: 0x00000000000025f6L, Ascii: "Kf46oy6paO5m0BITkQBNDFj4IZB69QwyLLX9KQWj2naSZ"); + yield return (HashHigh: 0xac909d0552c7c2bfUL, HashLow: 0xbb9aea0aa0c8ab8cUL, Seed: 0x0000000000000000L, Ascii: "7yUQsmy2PUSXBj7wZ6gMyYhMYyeaOX7TZA1dKfYTWZ3lkX"); + yield return (HashHigh: 0x3ef0a97bb650c186UL, HashLow: 0x16c50f7ef0f0ddfeUL, Seed: 0x1b789758fc51f4ffL, Ascii: "wsXMtF0seyh9Wq3TnVSOLCfrBOZGCr0YJZd3sBxJQgCyyD"); + yield return (HashHigh: 0x0f5bffb27e7bc948UL, HashLow: 0x97341e438244f44cUL, Seed: 0x0000000000000c0aL, Ascii: "0ruKjbSl8wBTihQRn41GAXbvYwGUo4OWGFLa2TwDJjCCg9"); + yield return (HashHigh: 0xe591b1b5214f0fe3UL, HashLow: 0xd6c610ccbde124e1UL, Seed: 0x00000000000018a9L, Ascii: "4a32HpJhxXIvX8hUclomupa3QNdcc1pxnVowIs7zEiXj0p"); + yield return (HashHigh: 0xd20d8eeafc240491UL, HashLow: 0xfb966c85baa85b97UL, Seed: 0x0000000000001178L, Ascii: "JNBl17xyqUmKZljoCxnoKP1D5voTAdLpHJtF6jZVLz68xLv"); + yield return (HashHigh: 0x92c1f187c2f0d135UL, HashLow: 0x9371d6345bea4a60UL, Seed: 0x0000000000000a7bL, Ascii: "xOTg2nw9GbYX5pPg0SzxC8q6IEybp1GZmMPyLzbtL7UYZcK"); + yield return (HashHigh: 0x633f4e0bf5f9dfabUL, HashLow: 0x0fefea424807590cUL, Seed: 0x0000000000001894L, Ascii: "EZRi4XK7jJTrgPKRA5SHoz0Q4sif7cQIHKFokZY8SSVEyrh"); + yield return (HashHigh: 0x78b2d5348c951852UL, HashLow: 0x96fea78817684324UL, Seed: 0x0000000000001c4cL, Ascii: "7OrNWNJR2u89m4WipmIbRlyNBOh01gpw7nerBk8R9L3tCrH"); + yield return (HashHigh: 0x269fd5ad49f480feUL, HashLow: 0x026805e30325e5d0UL, Seed: 0x0000000000000000L, Ascii: "Ij6Ag30H4NcF6qeJEz3Wsz5l6Dq8l4mhhKBirBq3vIaqRRQV"); + yield return (HashHigh: 0xda0dcd307f2bafe2UL, HashLow: 0xcb066fd7c972d632UL, Seed: 0x0000000000000000L, Ascii: "IDOWgPqCXnvFdmWDzqacG7q4o1A27CIXzbexey5B4UgPJJBB"); + yield return (HashHigh: 0x94677b46ddb4de7eUL, HashLow: 0x2c2f96e9c834e10cUL, Seed: 0x00000000000003d4L, Ascii: "2099xOkn9wkKjKY5CDlkDdHwi8D4TQJl5gS4d1hcvyR2RQtf"); + yield return (HashHigh: 0x7329d242fad612b0UL, HashLow: 0x5684c46fffa544fbUL, Seed: 0x0e6a5f795944f2abL, Ascii: "oeDsxodqj2WWr7Muiq077o5VrVaP5K2adfs2u5CzVgGHi3zI"); + yield return (HashHigh: 0xbd7f9a46b45b8014UL, HashLow: 0x165693a465fe120fUL, Seed: 0x79ac05cd3e7e0747L, Ascii: "CLWOfGOevFJeoegPEWvCPNhABOE0RwTyFxm3CQaFuhUFZE8Fb"); + yield return (HashHigh: 0x9040744287a729a4UL, HashLow: 0x9eb02e5a4caac5f4UL, Seed: 0x0000000000000000L, Ascii: "LGcQ0YebgP5cfln0Fd758gcv71YusgWgLF5pPPRQFKjnlrmR5"); + yield return (HashHigh: 0xe5eb72827700928aUL, HashLow: 0x4c52d406a5286aa0UL, Seed: 0x0000000000001c8fL, Ascii: "lzi6j73dq8g9jSQWe8JiNsQBZvg28u4eefXWB0aZAnd1sAQEX"); + yield return (HashHigh: 0x988c6534f53d6ae0UL, HashLow: 0x59b7e58468a47a5bUL, Seed: 0x0000000000001e43L, Ascii: "C2g2lYC0KNSl5ogPIeHDMPPIdTfAMX83NFOLTvzNCMOcjybVU"); + yield return (HashHigh: 0x806dd46b9dd40e7bUL, HashLow: 0x9bb428a5c8eef65bUL, Seed: 0x000000000000202dL, Ascii: "LfZcvbaYnMc7ilNCiIfqBMIUDq6nPZdbZADb7uLmeG4fZMgHcf"); + yield return (HashHigh: 0x287382e233db2218UL, HashLow: 0xebb4f3d64427bf4aUL, Seed: 0x0000000000000f7aL, Ascii: "Ye9VF3LmVIom3at1cJeyEfEJ0FZNMMvkATqvW02AWyGSswPLDh"); + yield return (HashHigh: 0xa80dacc39c04fd69UL, HashLow: 0x3368ca9b9c393388UL, Seed: 0x0000000000001a4aL, Ascii: "ZqWK3ZqTGNSC62HuKNbQnhU4iPL1AIaBsRKH46Hk2dekaEZbK9"); + yield return (HashHigh: 0x3baff25a5910c038UL, HashLow: 0xcafc58419a2e2e53UL, Seed: 0x0000000000000000L, Ascii: "IzxO16cucXkJxNAdGLv1vlEbpbvLh59hxMIDOKyiRHT29qo3Jx"); + yield return (HashHigh: 0x17381414137cf40aUL, HashLow: 0xa94116c1bae74ddbUL, Seed: 0x0000000000000000L, Ascii: "Ls6VWKVpKBWkLqLn2Dcz7M9X3SyAd3pIgl7l1rk1sFe0OBxz8ig"); + yield return (HashHigh: 0xdc3de5453fc9334dUL, HashLow: 0xf3d5b88891bc5683UL, Seed: 0x000000000000150eL, Ascii: "a9HXkqKa63WKbhvtg0ZBs9I8sF98C7VLpajeWEZ7qfcAKn9x2u4"); + yield return (HashHigh: 0xec3f47984bc5b8a6UL, HashLow: 0xf251ebe79aedf8b6UL, Seed: 0x19364680b7cfae64L, Ascii: "QxZmg62MBpJkk3hzweVPW7WuBg5O3lg5gogVKg7EvgcX5gFZg0j"); + yield return (HashHigh: 0x2049999f3cce6282UL, HashLow: 0xfcdff39c5893a7faUL, Seed: 0x0000000000000000L, Ascii: "ro9oxAxTDXRNROpQfAwZ6NEptKRF1SOkiHTeUuygMCgydNyONd8"); + yield return (HashHigh: 0xea57ddf5667ff2d8UL, HashLow: 0xb2717aebec50b432UL, Seed: 0x0000000000000000L, Ascii: "VgBPITWUgUJHF7eKLDrfatEay6LggqLL9PmXfmwYlBvfqU45s2QC"); + yield return (HashHigh: 0xda3b4982116662bfUL, HashLow: 0xe8ea13131ee22388UL, Seed: 0x0000000000000146L, Ascii: "AcnQHNqJ9CbnxgYAeqhpNvxTSviImLq98dZtTjXg3Ull81cKBASt"); + yield return (HashHigh: 0xbda70a81e8a95fbeUL, HashLow: 0x7719d2e47c378934UL, Seed: 0x0000000000001941L, Ascii: "v1pEcieRUyQnEkrkxfCEgdhMuZ5ZJTCX9pygddRcQ98Flh00YOt9"); + yield return (HashHigh: 0x9e44aa970765e1deUL, HashLow: 0xefa181e9e00575c9UL, Seed: 0x000000000000098cL, Ascii: "kW8S6p5FaD0SWxtfn6rNgk6j0wVvJEt6jDz0pojRELPyrynVUyew"); + yield return (HashHigh: 0x9ada43e6dbede79cUL, HashLow: 0x9801b4daf9442a01UL, Seed: 0x0000000000000000L, Ascii: "gGTtJkt3jWNXV77yMOLHgWh2wpgK8qFcMs5MX1SdN35RNt8XzC8it"); + yield return (HashHigh: 0xed036d96a56ae643UL, HashLow: 0xe28ce840bbd646c0UL, Seed: 0x41d3b15754067041L, Ascii: "DiNDfLboOnvczVWhwRR7UPDsljgYz3mJazI037LfMMPVx4NUoArV5"); + yield return (HashHigh: 0x26929f2dd87b324dUL, HashLow: 0x9fda9b678b73b9cbUL, Seed: 0x0000000000000985L, Ascii: "vTQ7jBRVAlRRUjQVADVtixvS5QlaqFhs6Gq7aDjmVZIpge5abpjZq"); + yield return (HashHigh: 0x06b4cd6c5e3fc467UL, HashLow: 0x56be575ee6fa1d85UL, Seed: 0x000000000000258bL, Ascii: "JIgjs2RG2EA6NN56sZCE7hKybrSGCf9BgatWqRbp4XQVbtbIMKhhO"); + yield return (HashHigh: 0x27285dc018de9219UL, HashLow: 0x7cd194b0615ad828UL, Seed: 0x000000000000081bL, Ascii: "ml82dtCvI9dWohM3KqakVqbrDVihy4ihUZwrf0RU8CC0qGJk2hi3Xe"); + yield return (HashHigh: 0x726589d84cd8842eUL, HashLow: 0x73bd723d06f4be4dUL, Seed: 0x74b9e97496068171L, Ascii: "9Q3Bp5kfmgzShiQhH7knhi65LLdxoEy2WmOR1eI7rvsnABhbF8DbP4"); + yield return (HashHigh: 0x85ee3327d20389e2UL, HashLow: 0x113170bbda455d40UL, Seed: 0x00000000000013d5L, Ascii: "0VYRaLR75oh74pxV3IlOWn2I3la5pjPqvFo1XqpSo3fiaQ66J5gXej"); + yield return (HashHigh: 0xa733454846dae2b2UL, HashLow: 0x23b201ad49f2f557UL, Seed: 0x0000000000002278L, Ascii: "WEaHPT5CFIgnYDGEAbVomBtvu1LhyejKcwpzKXrPJRDWRHQ8UQrLR3"); + yield return (HashHigh: 0x24d6877b1b867cacUL, HashLow: 0x127970fe898e86e6UL, Seed: 0x00000000000013b5L, Ascii: "nGS6WGHxSo8vPLfVgA4dgokSCV6ojBbUu35fpVQuGVjkHGvYd6PlZ3w"); + yield return (HashHigh: 0xfc997aa8ed327795UL, HashLow: 0xacfad4f08b1b8036UL, Seed: 0x0000000000000a8aL, Ascii: "LpeQUOYVWJZ4CFpEGC9An1gSaE9j7FMjG5nhX8duWZD2hKaGrSXIg1D"); + yield return (HashHigh: 0x7029e9558049f8b2UL, HashLow: 0x82c69a5efc7dbc17UL, Seed: 0x0000000000000576L, Ascii: "AMFxrECxyQHyBnIGcz1m6cqwJ9nNuF5WrJgMNF548ajy4o0OVJAJzph"); + yield return (HashHigh: 0xc2d6647eb7d4f584UL, HashLow: 0xa5329c92ca78503cUL, Seed: 0x0000000000001641L, Ascii: "Z7dYLz1eVa1zrPrAL19mFtmz4EfWNxIu4omhJO0Gfg23KXYpU3IpVfw"); + yield return (HashHigh: 0x4fa2e792fc67b61fUL, HashLow: 0x475d6b792978de1eUL, Seed: 0x00000000000022c4L, Ascii: "SSwQgScmLMY2diX01UVpg2v2bnAgs6ZpsWv5PbDM4IwHslW8mWgUORIW"); + yield return (HashHigh: 0x8e2fb6a3958fd86fUL, HashLow: 0x66dfe2895b914d3dUL, Seed: 0x00000000000010c3L, Ascii: "2tlEXjmV8Uiuf0c0wnSb9QvQobIYsg4BhbHOYnsj7Ry7WizG4lODAa8d"); + yield return (HashHigh: 0x0b9b77280fcbece7UL, HashLow: 0x5f18823657b4b79cUL, Seed: 0x0000000000000edbL, Ascii: "YQyUWpSRyow0JDpO9iE2niSNsrV4i4n9T2phg5AyGNoCufSHwIcjXPX1"); + yield return (HashHigh: 0x649682da2374eecdUL, HashLow: 0x6d84ada66f79bc4aUL, Seed: 0x000000000000217fL, Ascii: "qChqIWMKTD93cd25eOcPmsXDPJN5doh1sweE2IOUeMHVtEzV2X6xAM8I"); + yield return (HashHigh: 0x08382b76418565c7UL, HashLow: 0xab54d56cb850d9d8UL, Seed: 0x0000000000000000L, Ascii: "48o2hjGrFlqK9fWKtPaGO0yeS7EinKtpCrW1pJTNZP8FdyNWRtRq7hLsy"); + yield return (HashHigh: 0x79111349f9281f76UL, HashLow: 0x3a75797b49ee8569UL, Seed: 0x00000000000001daL, Ascii: "UxbCoJqztrbLN4tXQMN1Ub13Pb1LtlRHZxFpJqjxIyNeL9k2zbj2XtiMe"); + yield return (HashHigh: 0xecabee748a68ffc1UL, HashLow: 0x59f5725026099ebfUL, Seed: 0x5e11ec7ccdae524bL, Ascii: "zFuPfgSUIJrUVkfOItIrV9AkQrEc9lWOJREQIhSoCrilCPOlCoBbxXPr4"); + yield return (HashHigh: 0xf5446c5fae78142aUL, HashLow: 0x02e36e8338721944UL, Seed: 0x5519a7394afe885bL, Ascii: "hMVfSoFYmNPvgczhngnL2nmAdLM77JnCd5OzB4ZZxLd2GKCGyDgMCGld2"); + yield return (HashHigh: 0x823567a88fcd8dbdUL, HashLow: 0x5c1b8f98b2621cddUL, Seed: 0x2f50b68dd1216820L, Ascii: "bDcIN878DQrQwGWieIjIRzucEWCxdqkmNsUetKNBo3Fc2dGHvLptSMbL0A"); + yield return (HashHigh: 0x35b745ed78267835UL, HashLow: 0xcc343a3d6e2ba718UL, Seed: 0x3022ec39e9bbb80fL, Ascii: "5kGjt6moDX5CGU8My6gK8e0ia212HfJlIv6tmzLu57b6LlgbsQamVrqeWK"); + yield return (HashHigh: 0xce44bb2f7aa4f71eUL, HashLow: 0x64b301f9e8758900UL, Seed: 0x000000000000180eL, Ascii: "C4gSolKgHsQLi8oQ7625q0cVMNSgrhkYKJkyvKAjydg6CkKEFzxCqxjbNA"); + yield return (HashHigh: 0xcd093e3296c0d0fdUL, HashLow: 0x0574c56f1dff7aefUL, Seed: 0x0000000000001918L, Ascii: "GS0YDzYitXptN53db5eprQxfCof7LvTmC8PnvMb1h1NPxjpQUUcDkR3wMr"); + yield return (HashHigh: 0x4084b18c7c0837f3UL, HashLow: 0x7725a01c1c0e45adUL, Seed: 0x000000000000259aL, Ascii: "QHoMl8c7TxBkBCVhSwpMW0XlQUnetmkwEjEW1sbBMygvmWPnmkdrYp7Dx6P"); + yield return (HashHigh: 0xbde00740480028a4UL, HashLow: 0x020771ef2a9b702aUL, Seed: 0x0000000000000000L, Ascii: "qpWiY8KnV7C9gd0XrPZKIJQxgsGrMeFawP6jOy6EsCr2WhnBNc33wMHjkQw"); + yield return (HashHigh: 0x4156b45aa62a7133UL, HashLow: 0x3f01825dac720066UL, Seed: 0x00000000000011b7L, Ascii: "dgqIgOoGQ70Vn5DHxW5ljVjhHW5XszxVMEjlfnKUgEJkJlql3UPxX4zArkA"); + yield return (HashHigh: 0x0d313481af88003cUL, HashLow: 0x7e28baa49714ec8dUL, Seed: 0x0000000000000000L, Ascii: "d3zh7ciWb42tmd8GVOFIQFlvRaJFd04AWJQgLZ8uEXYlYdxwuhyYMMDBFqZ"); + yield return (HashHigh: 0xe86bde316c1f97b1UL, HashLow: 0x443e6886b63a9fc8UL, Seed: 0x0000000000000000L, Ascii: "iFcgmFMBZmi4M91evoCByqY6lZDHtG08qMLgQqOMrMjjzlzPerTY5XiE0p3C"); + yield return (HashHigh: 0x9b5d41d2752d8d44UL, HashLow: 0xc16cc36b39155d47UL, Seed: 0x00000000000014b5L, Ascii: "CUnB8aP78JwmdOzqsHCOMkVXWbcrcNrGGmRaedmFnONXsBk2auUae3vxjQlB"); + yield return (HashHigh: 0x89507679f46f5d05UL, HashLow: 0x836a8893fa8d6624UL, Seed: 0x00000000000003b3L, Ascii: "CgjMVFpO2wAny4P0SId20EJDrHUKPKwhXkYLf8TMSvetL75Hbd8UeSkjiRoR"); + yield return (HashHigh: 0x17c82c0e67d429c4UL, HashLow: 0x80ce344684af0e34UL, Seed: 0x38f31597a69f595dL, Ascii: "NLU14nP7C72v3yTjzULrMTgNWyxwNnGc9UC9fXLOxzmjcAi67X6nzAZXxK9m"); + yield return (HashHigh: 0x7962006fa372ee11UL, HashLow: 0xb46b2e1d8775e0acUL, Seed: 0x14ae24b2073113f2L, Ascii: "Vy6ZyYEuXWrz7Quv1BR2MRUCeCXiXnh3ZGuNncajoO9OInkaXHfWYGEtcxtbG"); + yield return (HashHigh: 0x5618c2cdaafd2c95UL, HashLow: 0xb787439e2a246d8dUL, Seed: 0x0454617a8f747ce4L, Ascii: "G2A72g8ejMhySFBmSH0CuvAEEjXbaFKmyicWp43YVgygrbq3FpUS024Io30zR"); + yield return (HashHigh: 0x516baf43bd10624bUL, HashLow: 0x2a00c2900ff5297eUL, Seed: 0x000000000000140bL, Ascii: "ETo4HYuNApzBgyaagRiEwNlXGninxHyLcsW7vu8p4HqLsHmUoZ2wxIzrXo9HN"); + yield return (HashHigh: 0x8cf6c862bf45b9cdUL, HashLow: 0x9da377f58d050b2eUL, Seed: 0x0000000000002233L, Ascii: "mswFyfJ4YTrRr5DnUhl1f9o8YjRsRhYL2nEqoGQz8iDamdkU8dRj4GNrM1QqZ"); + yield return (HashHigh: 0x4fd59ec51c8dd737UL, HashLow: 0x1f70ecab403dcae1UL, Seed: 0x00000000000023f7L, Ascii: "rR2Cc5Tan4C1RpIXm4Vqbk0hQ44bcJT8FaPC68YYoVZqD8AYm4FNLFmWXK4w9u"); + yield return (HashHigh: 0xbf1fea5ffa0f20b2UL, HashLow: 0x29f4e52d9b1ab07aUL, Seed: 0x0000000000002484L, Ascii: "cDr9lGyW06vlulQKmPYUrm1q0XvRKBkz5LHvVfejtWjGovbtV3Ssttyop2SFRJ"); + yield return (HashHigh: 0x24f687059c3653adUL, HashLow: 0x9d0e1708dace29aaUL, Seed: 0x0000000000000000L, Ascii: "aTSzxIuznzTgF8UMqJc70DDDKWguVRuXJOtdAiCBnlg38XcmrD23HEZm3yviH2"); + yield return (HashHigh: 0x81b0d787f89770c9UL, HashLow: 0x3e6264041a341edbUL, Seed: 0x49a9d98fa20a1fccL, Ascii: "Af9PJlbMfGS19PiYKRS7MYyDlXB1xBdihQtv3PPPUQsDghsLrKnTIhPUuakcE8"); + yield return (HashHigh: 0x9451584c5739cbb5UL, HashLow: 0xfa0fb8244b0fa8ddUL, Seed: 0x0000000000000becL, Ascii: "dChRHLmoLX3g2ZOqvhHheCcz4Pc7Qipaz9hRhIVPogE48DjMDDs5aNDdwYrf9la"); + yield return (HashHigh: 0xac49326ddbfc83e1UL, HashLow: 0x9b215d645d69bbafUL, Seed: 0x0000000000001cfbL, Ascii: "E2KhIsi9hBmz20c9ljrFZrHI0FzzXbhvDJCjYOovgj9bcncjPrLCMhOzOOHUV7j"); + yield return (HashHigh: 0x34b01ba4e7eef64aUL, HashLow: 0x891b9bd73dab9a6cUL, Seed: 0x000000000000048bL, Ascii: "IsI2YiVzaCDbfL33z1lO72OhvvfcCyFrLuDBZTgI64V7GFEinbuAMDA30ZFauvS"); + yield return (HashHigh: 0xbd742cb486e440d4UL, HashLow: 0x299f0ab4fa69a6cdUL, Seed: 0x7fac3c7a00d71af5L, Ascii: "Ae8sZwZzuLjWxRzS8Xvw3erSRWskQCxSLZ0o5XrABGJN2e1LByA28esW9caWILS"); + yield return (HashHigh: 0x27c0b5d6cb685cf5UL, HashLow: 0x073ff68dcba5fc45UL, Seed: 0x0000000000000000L, Ascii: "TvExjicqiLQwVII8NV5YKv9VKavvOsQOpsUgdDHQXBcWygTFFcfe4uhWRRxRnCNC"); + yield return (HashHigh: 0xad7f6da929b98115UL, HashLow: 0xf8293c6b7c36bd7aUL, Seed: 0x0000000000001897L, Ascii: "XPqxjOibm1bP65xGaaRsetVdaPzr44WYu4pBFBNyPiD8XOfb5UDhFVEoLercZco9"); + yield return (HashHigh: 0x7034c2cd355498c8UL, HashLow: 0x5621c29aed575106UL, Seed: 0x0000000000000c25L, Ascii: "i0ZFqvtSlIKdXfPuKoZTeTEb9L8WLptyzEq4FZWznuBban1DwTWhy8KFTNS287KZ"); + yield return (HashHigh: 0x9d45aba34f8e2a8aUL, HashLow: 0x9b64d2419d87166cUL, Seed: 0x0000000000001edeL, Ascii: "FrSgpf1CccjeB6aIMtu0YyDhnD8YVF0Jz8zo7tDGOVzhKwEYrbEVfhYVsVAuURQr"); + yield return (HashHigh: 0xa0f795c89f3f412eUL, HashLow: 0xb6d8083ed313742eUL, Seed: 0x332504d827fe35ffL, Ascii: "UV15wti7vDPvp5vdZDqLsOmiSiBymdWYH8uw5TjPqV4QpEXDy42REJAkj6PiWi8SE"); + yield return (HashHigh: 0xefd9696109b7996bUL, HashLow: 0x65f719cb4f91dba9UL, Seed: 0x0000000000000000L, Ascii: "v4n0tGBDBWlHljIM0I3XM3oKIBTT8Y4kSWkT42r7PyoD5I2iSJyrUclS3n8h6Xmzg"); + yield return (HashHigh: 0x0a3a42cc1bec7e58UL, HashLow: 0xb2e1964a2844c57cUL, Seed: 0x0000000000001b2aL, Ascii: "9kQUYZUF3VA20kgGgNujYD22HiU5onoxWxvQFmMlxlu0fzEv7962PSTejq8gwfvrk"); + yield return (HashHigh: 0x662bbebf73761f2dUL, HashLow: 0x94a6d46c5ca08393UL, Seed: 0x00000000000021dbL, Ascii: "Felb7yzSkykG2IkOlrcubpQRnw2eoG8OVsB3cs4MKKeaQiyl5WVbLKeajEuH2R5cA"); + yield return (HashHigh: 0x3f946b95f9853555UL, HashLow: 0x25735971d47c1577UL, Seed: 0x2d5b9a19d86072e2L, Ascii: "m5VOpDrDiurU62bcoqXWfzW75UUtAYcL9uh5SmOubsGBCL9lHeSAeQ7l4oh80nuHa7"); + yield return (HashHigh: 0x44d64d2e7fa804b4UL, HashLow: 0x813485b7da343d49UL, Seed: 0x0000000000001413L, Ascii: "YA3eHmH7HwBnvh9kNXMlv1RZck99qhkZ6fJyUaUnehTIEd4gIWNhaUU06MrbwKt5ox"); + yield return (HashHigh: 0xdf4f4c1bcdb46354UL, HashLow: 0xfc022fc6626d032eUL, Seed: 0x0000000000001de9L, Ascii: "pgOW10uGa4dqCcNvrYlYMGErIwRX2kjIQvutKi7br1O87xo2aq6Sy8Odqr9TF6mI3W"); + yield return (HashHigh: 0x3cd26c3b1fed9ce3UL, HashLow: 0xd4ad389bb6d92331UL, Seed: 0x0000000000002584L, Ascii: "OKBXjBXOXm0mmdORpNwqdwY2oItFNEn0plGPXWyWRR8fzVJLvdhOBO1jQ5XeoIdCPu"); + yield return (HashHigh: 0x4f3244ed4204034aUL, HashLow: 0x47729c59fa4a66ebUL, Seed: 0x0000000000001676L, Ascii: "2mueH2ma9BTIgNpadxRCb0RFafKa3j91pRC5on1RmRfjBZEpn63mQ0CLuLJwIqnZMFZ"); + yield return (HashHigh: 0x8d5f8ab651869182UL, HashLow: 0x3977a319c0dc0b9dUL, Seed: 0x778837d41e84868aL, Ascii: "oFIt4hmqFm5YkhRSlf8egNhotDP3rpgIcsUK4bJjrxErvjVjFOkqZOLeBnSSEoDIi5d"); + yield return (HashHigh: 0xf9da99f975cddc86UL, HashLow: 0xbb4e0b2f69d57640UL, Seed: 0x57c7768f23d56971L, Ascii: "MH8bsvNnxc9zlZbxu3xpSPvEdAH7T2XPG4X8SPbu0fHxTGozYB4OM3f4QCnMYqxPPKk"); + yield return (HashHigh: 0xae525a13f7807c49UL, HashLow: 0xcaa0dc2628611468UL, Seed: 0x0000000000001ed5L, Ascii: "qoaBsrdaeTH8fkhlC7cdQip2rfta3FFf0wlzKcFT4dBDvogACjVRLx2e0vQ8X8zogB3"); + yield return (HashHigh: 0xe4bd50a79f26360cUL, HashLow: 0x9f542f42be05fa45UL, Seed: 0x0000000000000000L, Ascii: "ryH9tH9CiBS8W0mFlB7lSmjxAtjZ8hVCpRr0SHzX1nqlAnD8LZqV8Jt2bGnwvr97NEdo"); + yield return (HashHigh: 0xd1049488ccc7d2b7UL, HashLow: 0x3be25cbae5ad35e2UL, Seed: 0x00000000000025bcL, Ascii: "khdx087Y0Ha75yBiMVEsIpvhpyAc5kUd5yl0nK9oSbSudDzAP6aS7rwZJvdeQaKWoCkL"); + yield return (HashHigh: 0x7cf1b340f68dd1d1UL, HashLow: 0x73db2e7b055102b7UL, Seed: 0x0000000000000f5aL, Ascii: "ag6kjPG4042HDDC1Y3G1HQLJkglVR7d7Fcd2lsuGieXX4jcURYltTkKybdec9GMw5PKs"); + yield return (HashHigh: 0x9c316045c2e43cd2UL, HashLow: 0xd669fb672162800cUL, Seed: 0x000000000000208bL, Ascii: "8TVDv9CQaAsdESpuhUWT6fkqCBTE5y8wovp81YSEdTchBLcoA6sjVtB9BYR0WPHamt7U"); + yield return (HashHigh: 0xe850c19ebcc9e68fUL, HashLow: 0x5f11d5d1cfb14fc8UL, Seed: 0x0000000000000d1fL, Ascii: "iKJJLsCO8sDlFFzEKAUATO1jWDEQgfrufqdnZU66xbma8LqFrac7kHqiayzPuP94udCv8"); + yield return (HashHigh: 0x19ee95b0a514461fUL, HashLow: 0xa31f6de69bad3490UL, Seed: 0x0000000000000796L, Ascii: "ndk6VGpA9umWEGNVU3i07c5CnUCotxkuWgCECgKnpevbEZu5RCCvqOoP9S4lv5fvwhxN0"); + yield return (HashHigh: 0x8018e61ec6dadfe5UL, HashLow: 0x621153c6e99db83bUL, Seed: 0x4d98cad46acb947bL, Ascii: "crOzxbA8fTVCM38ypXFpKIJieKY9IxwIToT4JhTstdb7RV2jlZXfwJu1gMYmxTjfQO3nN"); + yield return (HashHigh: 0x73cad6b8f8c89518UL, HashLow: 0x45b6c28274569ad8UL, Seed: 0x0000000000001f8fL, Ascii: "JWBq1w2WqWsRY51JvcLnPI5ceeEdop3e7pxZASclMAglJh8dg9UKS6LzMB1ekr7gprpuw"); + yield return (HashHigh: 0x656930d6b8c344cdUL, HashLow: 0xc4bf3e12608525c8UL, Seed: 0x60e925ed68699381L, Ascii: "spTdj3N5564MmYgvK9tKn4cZfPlp3Fjksyfy33TBH6UwwgYIc0asipqBXrjVlyP8GNibWD"); + yield return (HashHigh: 0x42ff86309f0aa22aUL, HashLow: 0x6655208f444d54d8UL, Seed: 0x0000000000000703L, Ascii: "C30wXszDqwix9JqtvRST0YzM2j1W47KYRJHeIPMYbsDx32JnVHysFYui34Qaz3xHyXlQmR"); + yield return (HashHigh: 0x24a1cc2f43a7fca8UL, HashLow: 0xdb9c20a5917874b6UL, Seed: 0x00000000000023beL, Ascii: "V3cBt2iuYUdhvnnTDjqRE01fAHn133BGUZVNXeP2Az5zvyLv9OCEiu5DQYWhYHaLpUNWTJ"); + yield return (HashHigh: 0x0c3c0d87724cf1a9UL, HashLow: 0x676fdcbd5ac41358UL, Seed: 0x0000000000001c61L, Ascii: "xz2M3W2nRYKXusjtGRHvjmvQqPLPXXamYCn9EcOni72EpzD2yQ5qnkQ7PzwbwQCCTIFUPF"); + yield return (HashHigh: 0xa7308d55801e9233UL, HashLow: 0x383b7b221004bebcUL, Seed: 0x00000000000023f8L, Ascii: "hE01bC95EVZV34bnQKpKn0Pkr3bZA5ZNZRS7qNZLi19zAS8lgBliLIlLAhEe13KmsspLeye"); + yield return (HashHigh: 0x013a83b0a89bf177UL, HashLow: 0x20334151664ef3d1UL, Seed: 0x000000000000257fL, Ascii: "6e2BkJaZwEy5ufx6acaXPli5MEpECXo1aDiiOwprDIdiBU5TgiHydJ2dSmqpTXzaS3f7voM"); + yield return (HashHigh: 0x6be4d6318546b9aeUL, HashLow: 0x674c4bda5f8c5d9eUL, Seed: 0x3d589af0acce8d16L, Ascii: "BVt798Xm1REq9bzq5Xgn0Hr46JkvgCbJtCPViGhz7zKVhoLofiTDVNpagnGwLDBCDLgKLH2"); + yield return (HashHigh: 0x2e23f53cec9463b8UL, HashLow: 0x287bdc4928e9a9d2UL, Seed: 0x0ca51c7b9a233d1eL, Ascii: "AliAeUYgonrjyqZWlDRdNBefJW6QWqPo9rKKhPL6PMYoUfqi2vjEbejADiT4wRkbVnJjDUX"); + yield return (HashHigh: 0xe42813127508a603UL, HashLow: 0xb6b4aad8440979ecUL, Seed: 0x000000000000104cL, Ascii: "L5Jx44k6L0rtSagbPrytT3X6tEmYwKF0mN8oZgTAq3RSUWzrxHHL9VMdSDLFUVmRv5KrlNfr"); + yield return (HashHigh: 0x5041bde61f0224d0UL, HashLow: 0x39e4a99d9e239aa7UL, Seed: 0x0000000000000000L, Ascii: "kXdFhAz02ox0GuVeSPsaVLcKMJePZkLQXbcN3kzmFMgWA8WpLfuJDj5rS1KGmwBqyh0Inl5D"); + yield return (HashHigh: 0x967232e425f95f5bUL, HashLow: 0x50de1f6f2f79a6d8UL, Seed: 0x0000000000000000L, Ascii: "ttMF9MSoQC8ubvtmrxKFbn9EPg5aYzJY6jvVjvaCgK68cmC7me1ikVRYqs4biHGwOpNKsqpn"); + yield return (HashHigh: 0xd3309e7856c01260UL, HashLow: 0x300de539db1fafe3UL, Seed: 0x0000000000000cffL, Ascii: "HH7EP8PtwXPiJEcLrGXMYmyUc4ESerMA0mwIWj8esmTlUph4IIv3AHAmOcPxImannSodYltW"); + yield return (HashHigh: 0xf6c1e33977408eedUL, HashLow: 0xaec18cb88a016bafUL, Seed: 0x0000000000000000L, Ascii: "GrkDeCbWqUEesxt9uf1hLN9bixDxAYsgIMc50DFyteH7INNFLP5jgAFkBgrGHIhmpVQxeY1a9"); + yield return (HashHigh: 0xf28771de74a9860fUL, HashLow: 0xf32a36b2f95b0797UL, Seed: 0x0000000000000000L, Ascii: "Teff5S6uVmhge4MmwnYTRRMLgStlo2StE4v5TGXWGVz27pM36vzOqTqTObKFrY47uCHn9YAZr"); + yield return (HashHigh: 0x25a4204a88044e76UL, HashLow: 0x38828f77cc0d07c1UL, Seed: 0x000000000000111dL, Ascii: "0ENitpVTcRiZ8Wf5NyvmcgMJODJq3j4HtomCzkGQAhh4HDCn6QUNSxpYOqk8g1ddyErIS4ekJ"); + yield return (HashHigh: 0x758303871e694df5UL, HashLow: 0x01b8ce555cb43163UL, Seed: 0x00000000000021abL, Ascii: "Dl5V5SLtpMUiJJgdLRXWBzRWbf7FIosJ2KyFd8LAm84AfusyRbhJJhF4NKmzcJ7yTyH89GuwJ"); + yield return (HashHigh: 0x7527bc28c988d8c3UL, HashLow: 0xf7b55b29dd76bb17UL, Seed: 0x576729e915b125bdL, Ascii: "AR4lc0CsPcQMjn3Rc7FQnWU2jsFwkSimhBZtYtOKSo7GPQ3T3Fl4jzIuVYTrBGT2gXIxeQudoK"); + yield return (HashHigh: 0x871d66b12ac6d191UL, HashLow: 0xb47fd55b85b376efUL, Seed: 0x0000000000000000L, Ascii: "5jdoyrUYoR169zYY9rUMIKy940a5LRnhbY5s6zExO3PCmfvL2bpDPIY3LIwynXg2APdkgNSWSL"); + yield return (HashHigh: 0x4574e29a58b80778UL, HashLow: 0xd7d3910d6fe449a3UL, Seed: 0x00000000000002e2L, Ascii: "knIJ4zeR6ftmVtUOoKtpCWRKmdLxJdQCAevdcw4afpzeGaM3GJ7EhPUSDW0ncbATlKSur50xmZ"); + yield return (HashHigh: 0x6dd65f8547aafcb5UL, HashLow: 0xb9030cc384c7282bUL, Seed: 0x0000000000001470L, Ascii: "Y9P6C3lY0DnxGxipk30OhIE5JIzjmMHzjOe7BYdhBrRoEooQsEL5TdQpUlc2UkB2FyMzt3lERW"); + yield return (HashHigh: 0xa546f8fdd36970aeUL, HashLow: 0x5bd4d823e1fd1e3dUL, Seed: 0x0000000000000000L, Ascii: "g5Bsfq3p8iytDC69UBlTn0sYVCLesPEX4Yje3nMyh46YkUkFlJlI1zh2fQwtApwjdVu0l2y569Y"); + yield return (HashHigh: 0x9569712dc5d29dd8UL, HashLow: 0xf7e44b3e2cd0593eUL, Seed: 0x00000000000007c9L, Ascii: "ed8guoucGjtPkhLP5M6ukfYlfZ9nCrvKdSpJU9no7BqyYG9JbF34J7Ld4mFvvcWWMXA6R1tnEey"); + yield return (HashHigh: 0x254b12991530b279UL, HashLow: 0x0be484d81decdb28UL, Seed: 0x0000000000001e87L, Ascii: "9gh52nsaHapnqgccLo9C9lukB5Uvn70il79LwLlIKDbwOmtsPePhm94wqtJ7Z534GHTEOz5mt09"); + yield return (HashHigh: 0x0e23ce7c96252c7bUL, HashLow: 0x15336657740ef407UL, Seed: 0x0a558d8bdefcd2f3L, Ascii: "AIS4D1HaMvqRq6c2goG6qVXtmauWzSBHjXuURz7oUb93cYi1TRO33CgSnTQldVcyAEvXiN9hv88"); + yield return (HashHigh: 0xb3317c9bc31bc1a1UL, HashLow: 0x78bf6bbecc423c4bUL, Seed: 0x0000000000000d63L, Ascii: "4gLhTmcXNAjO5hzjFaNyJwZQA0xgvgXqY4YktLe5jBqXktO4ljSRIuSInx2jiYnMvyVQQDlSCCga"); + yield return (HashHigh: 0xd9286e690430b950UL, HashLow: 0xf3c3887725733b6eUL, Seed: 0x0000000000000000L, Ascii: "yICRSATk9jlBrmGQkmpVq0ZTyIFbrqBYjoLaKxEKixNAfof1wwEHTuPYnDdaQkpwiqFyGDH0QO8m"); + yield return (HashHigh: 0x8f211ad1709cf312UL, HashLow: 0x594a888807fac3e9UL, Seed: 0x0000000000000000L, Ascii: "shbkpE7GQJehIvAcFb4NpuoJT7ax8nJEBaDOCa6cwp4Mi60W59t8Nfzsp16QFABa4C6KNoRl8Ufe"); + yield return (HashHigh: 0x141e13e1a35b49caUL, HashLow: 0x8b0bdef6a1e1033bUL, Seed: 0x0000000000001cf7L, Ascii: "2Xuzb0FSCOTN910D26le5DFMx9qJEPqugm6TZ202MUExumgdOSvpo0d7DG0vtaZUFeRBK006io2l"); + yield return (HashHigh: 0xcab76de0f506675fUL, HashLow: 0x8a2720222b7ed695UL, Seed: 0x64436f175308030aL, Ascii: "q7sxIPRAM2Og77sNTXWkQWVdHicRlPFhWfyxtVlbcj6UgWWg25EiZ2PP3qrR7SHnOqZlySIYWJo03"); + yield return (HashHigh: 0xa72777f0a454d754UL, HashLow: 0x346747f97b62ed93UL, Seed: 0x0000000000000e83L, Ascii: "loMRiwlZaYhfjwHuBEPYjtNxS75MA6vLS6EGZmj0XNmMdHAHaPAq8ERDFQi9orBkT8rWBgKNsYkJj"); + yield return (HashHigh: 0xa5e8e05cc58b2358UL, HashLow: 0x0cf288cda39a8c4bUL, Seed: 0x00000000000019f9L, Ascii: "4vAi26eGZ5TlYTqznrLKYcpxKJ4Y7883pgHBDOoGActgK5ZbrqppP150qbmNytnA1vqc7l8eT8oEW"); + yield return (HashHigh: 0x49273f45a1268f1dUL, HashLow: 0xc1b1d4204b55a88eUL, Seed: 0x0bcc809852294e09L, Ascii: "rROwD6YwvSMx86Y5MmCqNKmUtIWMtMOXtLClOksIdal8lDboxqFWSSVKmwqdVBDoDR7elRYYM4PLD"); + yield return (HashHigh: 0x7fa8662e4f6198c9UL, HashLow: 0x43eb0ba00cf98712UL, Seed: 0x057a5a6ff3541340L, Ascii: "bB3lurVvoz64fwEouyj9AsGxsnLdy1NDOAEA2n4Mj7tzENnt3WQNlfD78Vz02IhytA1bcoVn8KXQL8"); + yield return (HashHigh: 0x7e63ba9a9c125384UL, HashLow: 0xe14d309ecef59917UL, Seed: 0x0000000000000d6bL, Ascii: "sfZiQdoIaLFkM1XS159ya1TGvv8SrE2ahJP1D5fxelGzvPndJC4l47HyPyZ5hOxgff2SuuqbIhdKPr"); + yield return (HashHigh: 0xf689d7bd37bc5e29UL, HashLow: 0xb3154d844b44a137UL, Seed: 0x0000000000000000L, Ascii: "jxRWEK6LJazWynCNTJLyg8nWsWnB38nYXq6cvSIzOtW091yMZEfgHaz5O05oI59UL7m00Lw6FYyGZ1"); + yield return (HashHigh: 0xf4e6f14b2de069dcUL, HashLow: 0xaee0383aeb3224bdUL, Seed: 0x0000000000000ef9L, Ascii: "ZaxQFYVo7FOe51lc596Dvvtll8dQuWWcPS0mfBVENDWxNHvXhMQm4vfW0sauM4uE3qdeOUiDI6Ndqd"); + yield return (HashHigh: 0xbf469f1cb7b83fb1UL, HashLow: 0x5df1e0887af913b1UL, Seed: 0x0965aee13d012a9cL, Ascii: "JtXkLq3fXKJ3yzMHbr3LbgpnKSdktDHkmD2v6yljj9eT6p5gbAAFPMQKrQMaxxiSYkutYamf45cW1Ar"); + yield return (HashHigh: 0x62da62072023f354UL, HashLow: 0x1bde6b7c1e5a4c69UL, Seed: 0x1d7c540438c70dd9L, Ascii: "HxYHgpI1GuU1GBvUCDV84DJXd08NA5pxEWQZbTknnZhw5pWVFLyBv8jS5UP31xUa5iwrgbTskSDcbG9"); + yield return (HashHigh: 0x94be9830dd69f531UL, HashLow: 0x4b5f682e5dde7d95UL, Seed: 0x0000000000000000L, Ascii: "W2NSFrUjANeP4FVIhnoGVFe3MS48y7q61jghNQzH29cDqocuaTjAdPwgIaWjcQea7D8puxKPF2Re6ES"); + yield return (HashHigh: 0xdb2ebd2bd3e57e0eUL, HashLow: 0xd675575222cbbe92UL, Seed: 0x2850993126a7f996L, Ascii: "xKnvXs7ULC5O0on8tr8Cys8FbUehnJLCiETUAFRNiXvCE9SAnl1yF1lmkgv87lMG8KDdAbyX9QimPQO"); + yield return (HashHigh: 0x68a08d24212e9da5UL, HashLow: 0xea5f285345171dfeUL, Seed: 0x00000000000020beL, Ascii: "1xOzPHzGQiqo1SQqDzFB1gTdAoAo2MEmNdtYO1NeQ48mBWG6F5owFO9aLVlVLDHzcZEkpAon20g3xOF2"); + yield return (HashHigh: 0xd45e849f19f8a977UL, HashLow: 0xa31f3dee8d585cedUL, Seed: 0x0000000000000000L, Ascii: "1CLclXs7CcEU5wHEhO9ENbeP6XItnXoAmc1dP1uWNiakHyAiY6FFL3z34V9iPRltZw36ACYev0eEukf5"); + yield return (HashHigh: 0x2c84e5615200a066UL, HashLow: 0x00b12f310021fefaUL, Seed: 0x00000000000024d5L, Ascii: "9XiE8okSHwClRCIEt3FEOU07BDEB9CgAC8Adltc5jOGVeFnNktQu9aszHFgVGX3PZ9ILBMucYwOAxYYX"); + yield return (HashHigh: 0x0b7bfe53855f3276UL, HashLow: 0x53b8ca3fb45c10fbUL, Seed: 0x0000000000000573L, Ascii: "wgMLhX7QoJbXANDELpVj95pKNQKAoYdB5cVO5Nv73p4373iciCh1fU0TacEEXyDzO1tgFUfKUKu1kgpA"); + yield return (HashHigh: 0x1842f25d793df9feUL, HashLow: 0x8c5ce9b1c76520adUL, Seed: 0x0000000000000000L, Ascii: "Y2K1guD2KTnldiKASvOepwIC4pPCLKVitKGNfXv1qNsCgPoe6DoqKlFAT73NZB7BALAFv5GWbtoT2MG8h"); + yield return (HashHigh: 0x9186c05896383d9dUL, HashLow: 0x8a8110a59846f1a2UL, Seed: 0x0000000000001a72L, Ascii: "IUnCEf9bGM1nbosXqMT7AKto4tW8Me4AdiSc4YuxBukkt6AyWgXAWJMnxMzX8B7rAzf7DzfsIPX8TiFGz"); + yield return (HashHigh: 0x1f18ff2af4e9888dUL, HashLow: 0x940766b08c4a429eUL, Seed: 0x388ec634c9324d40L, Ascii: "kHjJnGo4IJKuiK6TvKKTm9IomXlTSKoUmXKRGjdq2Iw4y57NsORDkhGtfCylmlA6n7murXdpuZEU8YlVn"); + yield return (HashHigh: 0x632cccb4332c2968UL, HashLow: 0x13b22d68676766b0UL, Seed: 0x0000000000001a30L, Ascii: "CD7bQOQNV2YZFCRsUp4ss4G0bwASuowA1gZIwx9q8k5IQ8MKQN0vQVmTJnvsYp6Gs0RSX34Mr4qbg9joj"); + yield return (HashHigh: 0x5af39f9bbae4f81aUL, HashLow: 0xd093e13c1536ad5fUL, Seed: 0x0000000000000e05L, Ascii: "dtSPsb0jJzCZ1JrmsLMXJVXuyyDDTBW36P9ngdyM7VVc9ZXIBmVPyU13Cxx8uiSeMRgc2NvFuWbQf7MZ5O"); + yield return (HashHigh: 0xb7868d55a03242c0UL, HashLow: 0xdff91124d56f9b38UL, Seed: 0x0000000000000000L, Ascii: "JDMrnJeFOCgc3r2GJYyDJ4UwkWeZaU68lLVpygpyYos3C5t2yBxhes7YepAURnhmf4PouTq3ghDk22J4VT"); + yield return (HashHigh: 0x0345f31b311c330cUL, HashLow: 0x24ccb1d3f231ad25UL, Seed: 0x00000000000014d2L, Ascii: "RSuevETNns05LTDdUoiqtCSmB59b5mdJIhwGHYhmggWXvOHLc3s86ZpugUmMVQMJkMFdy6DrcbDTqnOBCy"); + yield return (HashHigh: 0x28b4d8e543d45381UL, HashLow: 0x855a48bda8c3e8efUL, Seed: 0x0000000000000667L, Ascii: "WmfzdvD8CMaFfI8fLcEjCialZSDn7lyQNmiQleDA0fX9WLGKWeRaCXM7gFJW25L5HGupr1RxYkRcqBGnrC"); + yield return (HashHigh: 0x915dc0c0b6505f5dUL, HashLow: 0x104d65e5cc50cd1dUL, Seed: 0x0000000000000e8fL, Ascii: "0vyTy1PsyfMtOSsWEORfWH2hJjF8mqhrAZKvhNTFPCEi4B6xu6ANDRnhR16eFNFA8AMkYri8PdNOeN3NNxi"); + yield return (HashHigh: 0x07bdfa3c3f713399UL, HashLow: 0x3493c8f42eccc150UL, Seed: 0x49379dc49721786fL, Ascii: "DQPjKzXQJ9RHiloP3yzIo1mPn95mEf6NeNfJCghHj8NKyKS1IoBM1pexRmViojfnnmDaOtQ1UKkJ1ry0tdu"); + yield return (HashHigh: 0x528b8bb1c0c86654UL, HashLow: 0x8cf42bfb51c03b1bUL, Seed: 0x0000000000000000L, Ascii: "GU8ISi5OBIWYBeK2RZnNscT6DEYN0uB11BpgKekeh56vm3ksjXA7YYE6jNiJ2jhgFHYupsUqW6GzAdPyhUv"); + yield return (HashHigh: 0xa0ac2c857f33c4f2UL, HashLow: 0x8126fefa77148c22UL, Seed: 0x0000000000001609L, Ascii: "VjsOLFvsdyj2l7KrrZ9fyLsqc0f5w9ALbFPV0LYTiugCdip8R9WCs9DrpgxtgRlUvFGUnQUTx1KSySnOfbO"); + yield return (HashHigh: 0x96f4a37cc4f8db8bUL, HashLow: 0x91c540795d6b46adUL, Seed: 0x631139e5539f35e3L, Ascii: "3E3UtumllL6ZlbDR30TvTbYn9SHqxRpnG7d6GyjSIcNB5PvcQaZd1IRFbSzgUom3rKQzIDqCrywuO3hLNnME"); + yield return (HashHigh: 0x8bcefcdb74768654UL, HashLow: 0x5dfdd795e8663503UL, Seed: 0x02ab9de80a052f42L, Ascii: "LF1Yr3508zzhL4or5VAh0H9ztfDeHysy5gM45eOgWLDmIo5dZ4QuRWDWzx0pJos2oZUiTZQpcf8nF2MQBCOV"); + yield return (HashHigh: 0x17c18f254bb48173UL, HashLow: 0x00342930e641f794UL, Seed: 0x0000000000000d6eL, Ascii: "jeS5hvqlGabtRxiAyPQhQWMmnoRzZ6QMlaMsOodS82kdmKXGm0XfyglRCLutG6ZXI7l7vqIbTdLz0nvGLMm1"); + yield return (HashHigh: 0x6a778219c1f41f8dUL, HashLow: 0x9a5383245ed64680UL, Seed: 0x00000000000019ffL, Ascii: "cpUbKnjYjWCEp4VqvJ7X3cBsiPYVLKOXDc5ZHAyQWh4z48YNFYbu1YExQKDo8aR2zdaYLRvntqFko8wRCBio"); + yield return (HashHigh: 0x170ce8869c5182a0UL, HashLow: 0xf081c9bbf5a6730dUL, Seed: 0x0000000000001532L, Ascii: "jrS8UsCkonNS7kj6IpzzbIIZbHpJBsREwk5IC9rNyjklOm1PCvrmTBZK9eys51G7HMZIZZBjSCcWHn6nCOkHx"); + yield return (HashHigh: 0x618169c97024de71UL, HashLow: 0x6c2482293bfcb890UL, Seed: 0x42375fa6978a8ce0L, Ascii: "dd73diYCxIP1ws4uZjCgSMDSosJ94thLDPduo0jTqwdKZunPjMAupanYsSdm64zpN6NeQ1LGEKuG4wt6Y3SVU"); + yield return (HashHigh: 0x45cf12292709aa13UL, HashLow: 0x44cdb4cf6ffe8084UL, Seed: 0x0000000000000d6aL, Ascii: "8qRe9e6PjnuT6dAQ8P1KdWwafr2NmdOaUqnCHrX8BoxHAPPr06gM4rSurQ4wO5btRSvdaAOkdgWSpQL3LmWwQ"); + yield return (HashHigh: 0xca1783152e8f9fc7UL, HashLow: 0xc465a48486685404UL, Seed: 0x0000000000000000L, Ascii: "Ys2i2ULXx10I95yTezfu5fMxIxY2lKI23rjhPzB0tSSR1mmCVfNk0MylEWDLrLJKDm6zwoaf5dW3lWs1gvOvn"); + yield return (HashHigh: 0xc1b52bbda2464d3eUL, HashLow: 0x6b63bad910131834UL, Seed: 0x0000000000001467L, Ascii: "RTsWdlmUBgkRcvDDd6NP4GyFgarm1I9nqAEyD84zhOylaT7JSxayq9eEPaDRCjXSZ4fittmekdaz2SNpMPnVOw"); + yield return (HashHigh: 0xa1b72125226f4fa2UL, HashLow: 0x69762c2d3aa794eeUL, Seed: 0x0000000000000967L, Ascii: "WzUnFL0OucevcOamRIuPYS07D125Qle6Lq6xT8y0oRJj6pcZfrTde5KDSt1g7IuvAVR34wD6TRqcdsi3Ul5SUk"); + yield return (HashHigh: 0xb5dd5aa5cda92562UL, HashLow: 0x800ecaeecc1b7c4aUL, Seed: 0x34710ce41037c450L, Ascii: "HOqOvCuFWK5zJrbPrTuqRmS1Gu5iJnsy10GCBEqfd21vB6yhJX4UE44UIXxHiWaTd8kVZb98TstXHPpsbY9cnI"); + yield return (HashHigh: 0x6dc77d1f80ed4891UL, HashLow: 0x3000caec11163ab9UL, Seed: 0x0000000000000020L, Ascii: "pznGNp5jjnmpUPCia2hhUcCNifekLJ7j8WrBlDDMaeeWKEVAcnkezBSpeLIMu1Ug6ddZDdrKgB4vTKgATvuJr0"); + yield return (HashHigh: 0x7368810912e098deUL, HashLow: 0x8ae8a6dbd0d48635UL, Seed: 0x60e2dfb361ec07a6L, Ascii: "icHYkTi8vGXsvjXjbKI00iY06R927cl8tByHNmk7oXIDCZF2Hv2qwpp0eQFP8BpXRXPKS7kZqF9LIOAUHPJarVc"); + yield return (HashHigh: 0x29d9973dde617bd6UL, HashLow: 0xee5e48516fd2e3acUL, Seed: 0x00000000000005ffL, Ascii: "PV5W9JFi16GN7eVIGpPgyCjhaWBMGPmZgvdvTWJdLK6XcySgEbpvO1NMN37TaHGs4pQsZDPCIX70Iu6bo97TeTo"); + yield return (HashHigh: 0x3178870acc7a84a4UL, HashLow: 0xf6f5087a44b74000UL, Seed: 0x0000000000001258L, Ascii: "oWBsc5EmYQwmbCptYMN4hmpN1pyeIhS1yL4dFajXbhfmgrxVmT3YfdCZeefAQkcxEAqxScBVDLVB3dP9xIpzg8J"); + yield return (HashHigh: 0xcba0807f61a1b062UL, HashLow: 0x3479ae8ab0bf3142UL, Seed: 0x30d1280a2255cff0L, Ascii: "Fdmm0omXgPBESo0geVOZuT28dNiz0haDn2DX4NYyfTEzSu3XKmtg8Ppbwrkw2YTe6Jpc6HAb9uTiMln31GaUTzd"); + yield return (HashHigh: 0xa7f0ca468eec77c2UL, HashLow: 0x6859c3963f7faa42UL, Seed: 0x0000000000000ca6L, Ascii: "msE9S2EKEiEI0Ckcv2tlMykdR2hAwu7bKOocWKj6JT1vkuHitZT6ltdUVKw6xzHrCgHDMCd7pDZlTyBddDq73OB1"); + yield return (HashHigh: 0x0f8e3050421a83edUL, HashLow: 0xda8b768a60f3cec3UL, Seed: 0x00000000000001e4L, Ascii: "eN66tT6yA5bkLXKxju7LhsVsDCXh9b2nKAcxUMlLk6kOG9hgwf90jmR24jnufoW2Mhy4inON8yFz59jIWUWQiIAe"); + yield return (HashHigh: 0x9c3d5fec5b1f90afUL, HashLow: 0x882d1a13b178dfbfUL, Seed: 0x00000000000009c4L, Ascii: "T9XJsRN6EtJFuhAnOfJmc4ebq50rHPxhO7BIVuqZzMmyIB5e34HAMU4gZHmKI5i3f2LXd8agHjiv9txK5EoCaCgX"); + yield return (HashHigh: 0xc6ac9193dd9fc316UL, HashLow: 0x76f8e20206c5da87UL, Seed: 0x5745190cbbf503feL, Ascii: "3b6fCjZVHW3sGOBouCLm9qnQhu2mqWDXLaiWZ3AULlb38LYnnpaY3BUUcFlOz6FQtjdjIFrlH04ht8fd1WTmaM7G"); + yield return (HashHigh: 0xfb331eb4eb3431fdUL, HashLow: 0x31a8ef86b87b96acUL, Seed: 0x000000000000119aL, Ascii: "1h5xhrLp5Pm4aUTB2VxKj4tt622qO9eBswifEsh6AyOhoKUokwRMjVhIuiM3kPqXElD7yh2U9XyfxbR7gqUMVgXSA"); + yield return (HashHigh: 0x58ddc3d41dcdba8dUL, HashLow: 0x2c6b3f4671b39106UL, Seed: 0x000000000000042bL, Ascii: "CMMnPlYPFfpMQ2GFAxEzzBR6SYlEemynU4iiOkxcQnJ0gQOsA1HI4zOqCx0p5xdWvw6KKCT6SznlV9Rb8Pmfc3ret"); + yield return (HashHigh: 0xaa88d4963f375c72UL, HashLow: 0xbde3d05118bf4068UL, Seed: 0x0000000000001dd3L, Ascii: "805Kt79f2xIrEgaoLoYb2fukowtErK9PdjHeqTZNVxPVEHod0KSJVjSzNPYKP0hJmiALt65FpIFUUBsu5XZJqzr3H"); + yield return (HashHigh: 0xb7a2f516497fd605UL, HashLow: 0xa60e2c642d1a667fUL, Seed: 0x0000000000001c59L, Ascii: "hrfOJ94OlRphBxBnrfLRNW30oUiDf8S8mLJL2CLnwga3PDxaZKuTK98GwP1Rr3mRFlRj2WXR69knsqmY60CeaC3a4"); + yield return (HashHigh: 0x23ea4bc18ababb57UL, HashLow: 0x1112ba61cbf0cf39UL, Seed: 0x54cb3bfe8ca3fa31L, Ascii: "mncxHLZA2MOTR3FQ2O9VAXPekOvJwy4qwis7dztqNGDz6rIhubuBrTwgD9MXwgdN9nmdAs8JvmZzMEodiaHVI4aJJx"); + yield return (HashHigh: 0x942f78a93d14cbf6UL, HashLow: 0xf1ba9ec5bac55538UL, Seed: 0x0000000000001494L, Ascii: "tkUoWSt4GsMaFYvzDYB1eKymiyFlW0kYGpWCH3RR3bKhGerJ7ZD7nKeTfyonVau3Q0XDbs2YufUVDKpbyo5K4pqHar"); + yield return (HashHigh: 0x2e07c8bfb2268b2cUL, HashLow: 0x5cb74d98056bb95eUL, Seed: 0x00000000000012cbL, Ascii: "QCH1shq4UBmQW8lq68B8Nk1sIBLqoRRqCpC6tSYQoxNZtvrVVyL32ziy5tFoJQYedW39KrycO8Bz7EMUoCIAvpdd9k"); + yield return (HashHigh: 0x920622c9f36b56bcUL, HashLow: 0x10a70e9a0620c7aeUL, Seed: 0x0000000000002142L, Ascii: "A5PjqMnYlEFIsdQY3D6w34CLQRDC18OgGRwg1ojrsTg3S1xloYXDzoaM5qxzEU4sOSCW03BWyrLV9orKJYUowrwVWi"); + yield return (HashHigh: 0x9c46fae26c81b37fUL, HashLow: 0x3f6392fb175a62a7UL, Seed: 0x0000000000001da9L, Ascii: "RJWlnW50Y596v38EioTodlxPOyjRhs4aXZfuuQnNmRkcno0j7Wlas5fCBBKHADdQ357mzP16uNcsE9ZoqVKBj55hR0f"); + yield return (HashHigh: 0x61e4124e57cf026fUL, HashLow: 0x5993582b1ebd25c3UL, Seed: 0x000000000000078fL, Ascii: "sxfHb96ETfH1gsllblJmHJ419swjLnVPGNh9L8kSdNgFNeK4SObPrb1YiHiP6q2GVWuuB7tDIDTTCT8Mw4Rv0StywGH"); + yield return (HashHigh: 0x15524c0b37de86b5UL, HashLow: 0x78d20ab6aea27ff1UL, Seed: 0x0ca925d9e177c363L, Ascii: "fxPzz16TkqExxzvWxgmVTppXlpxTpRnBdmGNTCmJT5Mv3JDlZGuUfhWmOmkBu7Vh2t4isZiJ48jIr556Ut2IfZDOWjm"); + yield return (HashHigh: 0x212b74d3e29abe3bUL, HashLow: 0x5005403a4be89f03UL, Seed: 0x0000000000001ed6L, Ascii: "plbKTkmoJKnv4zlCt9IsROTrT4pkR0AdiU38pDjI2nlXdixf2uZW07InGOSI6E4Evn6LMqkUGuvzpeFkjIUB7OlqRdR"); + yield return (HashHigh: 0xb9d447379f035183UL, HashLow: 0xbfeb293d6d9145d0UL, Seed: 0x0000000000000602L, Ascii: "bsz8XLhzwmbIaM690caHhkWWxzXs8VUinQQLhQ9JfAe3lwPttXOcqf1eSngar4T3Ut6IVMWwfW43ENQneTjuuIwOWS3p"); + yield return (HashHigh: 0x04550a2eb4366501UL, HashLow: 0xdf427b26fc7d2895UL, Seed: 0x0000000000000eeaL, Ascii: "QtnJzyD0qIHgIFuhTa95GWjzsMtz8EWYsGi5Kg5uY95A2ucHKibo8kr2ymepSYC8fKt8yivOVriciCagMB8wHORKO38o"); + yield return (HashHigh: 0x321254913e82237fUL, HashLow: 0x3ec8caf9d47fb80dUL, Seed: 0x0000000000000387L, Ascii: "UpXLB8btnEY2reXU3HGbjZ1viz1cyhkrVYn4BpSRwrFSesbm9uJvE3LQ3emRWt02X0eIQUAnUSA630GSrp97uWs8XIkC"); + yield return (HashHigh: 0x683cd987ec805005UL, HashLow: 0x5fe9b95d1ca22b8cUL, Seed: 0x0000000000000000L, Ascii: "p2ZHDFlKSGEH1FHyi8VL71p0mX6FConLxy0Jhaiy0tj6JMIWA62SxUw3jW3uluBBUtPyiyHCV7SFjFRmgTZK93VpIeWX"); + yield return (HashHigh: 0x97d6a759d614ef44UL, HashLow: 0x94c798407f15ea28UL, Seed: 0x27d35b7ad1dbb2d9L, Ascii: "v6MgHS6LMB7OgVENx4TbtYMd1kcVwyvKNAXxsv4h7Pz67utR3mGj8hgxqFlC4jzIXPDQeJVNARK05tQ2mpUEQIqTjwM8b"); + yield return (HashHigh: 0x6af5c270ab71723eUL, HashLow: 0x9660c9265b8bed33UL, Seed: 0x0000000000001da4L, Ascii: "sk5J8Df1UtxtOeUYFieEwdlc19AuNdW8wFkgFFFhAYBLHRjbQXbZjRug9jpWrwCNdo3gW6LdS5mHzyDi5UD1y2qpquCdr"); + yield return (HashHigh: 0x19898a18acfc4a04UL, HashLow: 0xd748028a5fdcd75cUL, Seed: 0x0000000000000000L, Ascii: "AecznQe8iEMZeWWTmpTPQSXOWJGea9f7LtndRQ4phOtCM1PbAQip1QNIGqng8YPweeZHN0JBggBNiLe1UCTsJz1XLyhLZ"); + yield return (HashHigh: 0x95d84222c74042f0UL, HashLow: 0x0b5558daedf73398UL, Seed: 0x0000000000001e9fL, Ascii: "yV7nZTSS6GgjMkj1npv2Z8rtqA1tOeQw7D4xyLL2lUYppZ9j42cazdHhf0kbyhpKtwYrFQ9mMcAdFwm74S2mpJAcII7FI"); + yield return (HashHigh: 0xe293dad6a891a0d5UL, HashLow: 0xc05e3c361468cc24UL, Seed: 0x6f88fd13e34392a1L, Ascii: "1Q2UdjUFr1gBxskQDm4Rla2CmaXbimwoMVnVqGP0MbpTIR5oor1dcTSlldIV5iP3PTwUoICH26X4gBnhg6I1t5fLIYvYOd"); + yield return (HashHigh: 0xee815ae931a1e977UL, HashLow: 0x6cf075a40ea8a205UL, Seed: 0x0000000000000000L, Ascii: "O58pvF3a8YRtgya9zzl01iZ7QObwQNJ1Zk5FlsQmApHVXMtyugINWuw2gOzBNwMTa9CYemEDEJUqTE5bLojrHONUi6BQgr"); + yield return (HashHigh: 0x321a1ae5d00f84d1UL, HashLow: 0xe1f0652e45f2e07bUL, Seed: 0x0000000000001700L, Ascii: "GhtLuZMyG1XQnAyyIa7RCqT5sMQrywQfcjehPBvYWra9XHYq2l6ARUdod0Sa8FeTLSX05eiERBM23MmVdsA2OKLScV1OBx"); + yield return (HashHigh: 0xee6e68e834f8ebf0UL, HashLow: 0x2e5672e0594c719dUL, Seed: 0x00000000000026acL, Ascii: "SZSYg617FijnkY3bDV4fXvrWGk88t78nvfURjMdp8c5HCGZMB8uVXEVYXdfqcrCofd4OF7gC4Vkr9i0tW7HwaHFl3jFPsI"); + yield return (HashHigh: 0x2f4437e100f689f9UL, HashLow: 0xca3141196da99169UL, Seed: 0x0ca6fa8ccee7f53bL, Ascii: "dBaNLClzLlWyHovtJt6GhPRW0xZpaTFsHIt8dBUvezPPrGkqkgoBZ3TZ1KdgMjGCD4U9fODbDcahLmSnLgg4GDRBA90vPIh"); + yield return (HashHigh: 0x2f2ba8c754a72445UL, HashLow: 0x7052f911f07768b3UL, Seed: 0x000000000000112eL, Ascii: "VfqlsjAkcKGLKdn3Uaw7CqBBsM97ZbBdtmCYeqtSDKSkw5F7Jsj7Hog0zQdRslNVL5jsjEYBTSJSHdQ1D9yeenW9SfvE1KP"); + yield return (HashHigh: 0xe3f11d71ce227e70UL, HashLow: 0x171a7fa319f2be42UL, Seed: 0x000000000000109eL, Ascii: "2Ek7E3bnqhTtPcWwGmqBTU2SCXsfq5FPUl5huI1S0ybZi20XzG9GLjFJNa33NV3ymgwkMVZKBur8KHbEnuaHhDfbIbarc94"); + yield return (HashHigh: 0xe48f2814575fa7fcUL, HashLow: 0xcf3280b3d697fc20UL, Seed: 0x0000000000000000L, Ascii: "Az7ehWUO16NwvRHyVdIJXEliFvTFhSnh4xxU2tZzZa1c7hlFZaS0ogKlYUSbmlGV79UGZkXNaWKFnhyNhP0n36MNWLv3gWX"); + yield return (HashHigh: 0x2e21dda526d1d199UL, HashLow: 0xf8e2351224f8af7bUL, Seed: 0x00000000000004d5L, Ascii: "aDsLKOX8ej6wfnhD0RZledxUxAepdUjpVTnQfWwi9fx6nOY9VzhsI33fQKusiX6FipsaiKoeAb708o8q29PgACXUnndM2BK3"); + yield return (HashHigh: 0xf98d1081b7e97df7UL, HashLow: 0xf05ddb7db22a8904UL, Seed: 0x0000000000000fc0L, Ascii: "DlXZF0c4JMLqt1lfVbCwp36tpCs2Hni4DaAiuAdXjQJLT4IfijfPusvPaOZOXujM3gPNOJCfQJloybPl4lmmVVnJABVAphzR"); + yield return (HashHigh: 0x9092e67279a8bdfeUL, HashLow: 0x16c10849bf7f6a46UL, Seed: 0x0000000000002340L, Ascii: "enTD8N3YsFrowNU6lIBkYvdIOJlzAm17C88wWa8NLrWeUDwF9mASo1Wc4r7lZ5x5Hk59TaAYW5xFfFoCZeP9hEk0fUbSJCXw"); + yield return (HashHigh: 0xeb832d4974110b07UL, HashLow: 0x9784bba63cea8468UL, Seed: 0x0000000000001d7aL, Ascii: "byZ3cRkWHTmzZYK2uWWYNI4wiCktVbi63lZWLgNzwWpOfEORLlzG6Nyqy9Bl1G3YmgwEIMbwXFXTpZ8krRkTC8NutauCE3aP"); + yield return (HashHigh: 0x9c2df00e35b52375UL, HashLow: 0x3bcbeb4935e89aa2UL, Seed: 0x0000000000001c7fL, Ascii: "YhKrs3ZYmrSa5VSRZGM4V8OYvXckAvoQNPtV07iCUJeKDmYOk1fNmkVLwSlBWrjslzkib2pRljteQWICxd4nR3iBhRu2SOHjE"); + yield return (HashHigh: 0xd5ccc7c2d6ba64b4UL, HashLow: 0xc946e19397872b36UL, Seed: 0x0000000000000b83L, Ascii: "8xNVKxaxHKCpuyN99eRUFC7J0aUjryo19gTm0DTe3uClUzIAMQ5s3GRZtm0yYvLoMv24ZQDb5Eoe4BlX0vFfkFekryVZbnHhp"); + yield return (HashHigh: 0x1f70c855c4f02a37UL, HashLow: 0x498f1ef6aa9bc0f0UL, Seed: 0x0000000000000000L, Ascii: "lEeV9huQLVCi6UVI2b97K1o5ELJHCm2sWBSUC8IVFGZavNez0OGxkIJblx2WowrsVJoL5xLAr8rLfOX6J8B3wSJaPzM3RsjrV"); + yield return (HashHigh: 0xb3617ee62879db46UL, HashLow: 0x474081d31ae10344UL, Seed: 0x00000000000009c4L, Ascii: "DIoXdkmKdPkqgmD754zIBJhvXejvnEVzCQVg3i51ShwxkvfsWK9VIkVqIROx5wpav0PyEyWWtfQ0M7pbVsLM9cOgowZQ8BR2A"); + yield return (HashHigh: 0x81d34192dc4414d4UL, HashLow: 0x3d9bcb70503e3be9UL, Seed: 0x00000000000014d3L, Ascii: "q1JfFrO90sN7C9FSs5fdL1jQqiQblGaKd6r4hc2exz9MSjBZ0AZi6tA7QK88Yp3lclgjP02GCS83QBhCfBeITWoA9bpz4tzDwV"); + yield return (HashHigh: 0xd4afd63e89b116aeUL, HashLow: 0xd14b88e21c4cdf11UL, Seed: 0x1b540f1754eabeb5L, Ascii: "muZJfTugpL1NztwGkqgXUcEZmNxJOEMCB7itdUP1vKp4d29NVA1SIWZAefELEt88YRZngUBsczSgCdojJfwk5b8XSkoNortOfg"); + yield return (HashHigh: 0x8a44b60c93c70c67UL, HashLow: 0x3beadc8c4c651c85UL, Seed: 0x3f25c8cbbe8d8cecL, Ascii: "dJOhJRCO3QObtEcE37h7boKXSFBuyKkEVoPsU69Yy8jOJbBD8ImjW7AqvHYUtGk4FlJlTK1h2XzRgtXpIUxMUNeH9KQCeXgGIx"); + yield return (HashHigh: 0x521eb041a525c965UL, HashLow: 0xf0e39452ed2b6455UL, Seed: 0x0000000000000351L, Ascii: "RUju8gCDfD28Gh28UsjsteaYN7c7PmnabjqBLgCvM8jzMfpFMF7OakYmtMAx9VBC7Xta4iT5Gr1sn4l0mLvhL9gEe8BMSuFFL4"); + yield return (HashHigh: 0x5c181f3e4a8440aaUL, HashLow: 0xd301a5b5c073c673UL, Seed: 0x0000000000001448L, Ascii: "lGWvIexcyBKiKnUMvSQzo9BceGBuAf4WmAqdgKgppmhSrvmdOdEVyxvxq7GftnfRx2HxoiPARdO3DK1bzPKMbclWs9NEM4oQB08"); + yield return (HashHigh: 0x87457b5242582cd4UL, HashLow: 0x6e9f8881bdd18ca5UL, Seed: 0x0000000000000399L, Ascii: "P4cbUGRzgVYZQQVJSR9DnankJ5dWEAiQfnt8RMIfWaObfrrPTc3QU2IqL7Mp4oNtAydl0XGoFQbF2hJr3utSZclmSMieRJNGHOL"); + yield return (HashHigh: 0x47119211ddc09755UL, HashLow: 0x2758dfba3fca74f9UL, Seed: 0x0000000000000000L, Ascii: "FiQri1z7OnyQOHXTum3o9AAZCz8iMWsIdADPtrIp6nHWgf0kf04CiWTdTEfhupYVt23z3UzycQzkV6rOg0uZvcK3gGA0ShYmnuR"); + yield return (HashHigh: 0x46e8a00faae944c0UL, HashLow: 0x695b1cb5d398ab60UL, Seed: 0x0000000000001382L, Ascii: "1MJLEsLLvs1aM8KICum2XF7Z148NFlYwPnqmoZ8SmLyqogW9SKtgI7VdK0HSQM3bHig4K5w3NXIRCd8BQ7kbW0hWkBszY9pWca3"); + yield return (HashHigh: 0xc09323868727f1a3UL, HashLow: 0xa5c31c47922d486eUL, Seed: 0x0000000000000b98L, Ascii: "KoKne76FGJfH1TokABK1wmFqwzJetkU6OO9umoiMoCBbnJywDbWEZF71TwAlVxp2HgXCIR5x7O9d5RRisvzHD4kwe9wal69kWFs4"); + yield return (HashHigh: 0xb11377ea2e1cf86bUL, HashLow: 0x8ac8600a6490a4bfUL, Seed: 0x5676131a5b81e39cL, Ascii: "vMsWYScvCxCi5txDAf4i2Abg6mnQpY4SMAxJ74eIelYZlAvN2ZzinYbCsNDcBAnFcnoR8EDsxdd2dKB78pSx6QdoejvoGNxXE7sv"); + yield return (HashHigh: 0xf709513ff59bd6eaUL, HashLow: 0x8c34128bf6531877UL, Seed: 0x0000000000001345L, Ascii: "xl8l6PuZIF5k8eBlRdhsvXElTOuMCRtKNSeNRdmnzYr5WSCkNsCMu31fYZkg0UImOkJmNKtaXno8rVFSpRz27aIFJbzBTJ9o7PGa"); + yield return (HashHigh: 0xe57cc891e1b83d08UL, HashLow: 0x061be75c4be74698UL, Seed: 0x0000000000000afaL, Ascii: "CixcGldVkzXHsgO9NFfeEtr7uJAIyby5k2HTskxIkjbOL4mirmkUlcy5lrzRuhGJFpzEYfAutGqKGAYdnx9UkhApx5eDMzEYRG5b"); + yield return (HashHigh: 0x3f4e7825ae54c76dUL, HashLow: 0x249d3ca32369e8e7UL, Seed: 0x0000000000000f93L, Ascii: "VJ2gEMmhpR0G2oN1nuX9wvYKu2e9cWenEgN3KQOk2Lp91TzB1T2gJTVgzH5HV3jR02rXLsVjHGCsPer4tzru56uUk3LVLsGWZ14gO"); + yield return (HashHigh: 0x13c9c11bb14919a0UL, HashLow: 0x92e08401f58b3473UL, Seed: 0x00000000000012f6L, Ascii: "M8zzd22RD965pkcs1LVUciCYntDxLPJqlUB6S6mpCfkB2qAvrVA80oMMYHFKk8DkiKZIqJzKz48mdkZDES48Q1m3NIFRWWdqewFmL"); + yield return (HashHigh: 0x4f4f17302f31347dUL, HashLow: 0xab71555ecd316796UL, Seed: 0x000000000000191eL, Ascii: "4j4ol2DDiy5k4o1zbXj2dDJwsh4d9uL3MiWkDtwiHMrM2lDoE1HuGCG5nuL90ZTzeVvD3VMAYa1qTTFBaT8ksK0aLbyJg13zhO3VN"); + yield return (HashHigh: 0x9814f312e4091a78UL, HashLow: 0x4802c28390d48c3fUL, Seed: 0x000000000000118cL, Ascii: "2MCeN6Wy4zmwOjfQVMqcfO0kMtiVN3wsYBolyqurxKLHDkHkzVUfNBu7xcvxOkoIjMymYvd0O0YODxC0fB2HIqwm3JGYODHAkgkdg"); + yield return (HashHigh: 0xb8e217d54ceb3a0eUL, HashLow: 0xd67a7d64e145587cUL, Seed: 0x00c8c7ed5cb31073L, Ascii: "dNpfYJyD1cl3a7bTG1S7GBtBnOFTsZgbk74LrZlcwmBP09aLuW5CeYaFHVKAAken0PyXel7YFNLPTUiz8KVgMffK2mWux6dHcqYqGh"); + yield return (HashHigh: 0xf68f689237610442UL, HashLow: 0x1b83ce753d0b66cfUL, Seed: 0x00000000000017c1L, Ascii: "dv2CvYIaluVrrg2Qpa9sUipj9yD6VmOhp21RA6XDibYrrnOFvIlIeG1IbVj1I9AGMsfQQHtXxBat3RTz33akQ1WEtimP3dp2n6l58g"); + yield return (HashHigh: 0xabaacc0702860bf7UL, HashLow: 0x8a1b6766f5140adaUL, Seed: 0x0000000000000000L, Ascii: "vRnEYJ42n6Lb8vaIhDfQQBgs15GstAYyqb1K1JKBPr4dfgjWxDxHgxThFgASYVtkNBaqnJRlSo8bLQHNbrPHj6sE4KcPwa9IrrSLPs"); + yield return (HashHigh: 0x6510e895634870eaUL, HashLow: 0xcc8cc9af1e246147UL, Seed: 0x13a1b6117c92c32aL, Ascii: "konuMUTcPb4YcE8rPUlrBKyQs3VyhESFAKajW61QircmO1PZSylIAsN7Rydpmixc2VAhOVoRrwjJMLFN6OynVC0eJA08YcatYivyq8"); + yield return (HashHigh: 0x7c70072fc7af32ecUL, HashLow: 0xe1a25b6589371810UL, Seed: 0x0000000000000000L, Ascii: "9at4zzJbKSkzZ7QzpC8XQBfTxNCKVfm4BNIQQJ3mXOVItuuthILZoLXv063v16nUkwAbZ35IhCHtDISPaaqyN3BvkduXr8A8JIKnicQ"); + yield return (HashHigh: 0xe8aba689e6cd28ecUL, HashLow: 0x218e40cb19957a5bUL, Seed: 0x00000000000018ecL, Ascii: "Tq05bClJTAUlpR1BybMz0tR8O8Qba1tK5riABfzBzw3jYJUrngZD5n0cOWax4pNn6aBFAnfATk2N20lOlJ6Pl1wnbV2LPcCG0fliz44"); + yield return (HashHigh: 0x372ce5c8309dea41UL, HashLow: 0xde56a9c0a9efa432UL, Seed: 0x0000000000002702L, Ascii: "RDtQGbzGx5lMpq5BRzZS3LRw6SyG94SVcWAiAHcP8zxwKAmI7AL4styZHcFDV8wEBVbWj5i74QFitVpmXJ6qMwtpZ6X91zz6Sg7zYv4"); + yield return (HashHigh: 0xddc317722ef9b5d0UL, HashLow: 0xf1030fba877928ecUL, Seed: 0x430c6bfa730ca3acL, Ascii: "wcmuStaaAqHZT55kNk0cPMn6Ss4bfZqrNljRvHTWLdJdPpnJVp3NvumEQnyDjUk7w4XDMWZnijh7eSDRQvXBkKCb1OjmJhqJzIuzWLQ"); + yield return (HashHigh: 0x10908ac52ff79b15UL, HashLow: 0x84a7bbf319f164dcUL, Seed: 0x0000000000000000L, Ascii: "4NV18d9gEA2fWXahWTEpIHIm2yvtgzALIxerEHBdgdw0OqLFTmh8OCws89kcUhqn76dgvTNKKO3Vez3GMjy5wfvXsR6sMbv1mQoPAv1w"); + yield return (HashHigh: 0x44d000dd10a3f02dUL, HashLow: 0xc1b52516ea38c03dUL, Seed: 0x0000000000000000L, Ascii: "NA1JBZi1MP272ObONjM8pPiSEgpjV1CKdr2cQctD2KMCKH7BwhJPubNEfOnI4UZ5gRSywtYE7VIcz35Q6ptCEHzieGQguFxtYTRM5HwH"); + yield return (HashHigh: 0x560771a9ad57f3e1UL, HashLow: 0x1b5e7435e2199c15UL, Seed: 0x000000000000012dL, Ascii: "lah5ogTyrmN1wV3Sk2RCYngrQ0eaHQHij9G7yaLSkF4ccmvBqlEPAyGJUZfnb47Ur1qKLhCnpsX7beYb9VtDTrjUmRaUWVtpEBLoOHs1"); + yield return (HashHigh: 0x70e331007fd1f062UL, HashLow: 0x6978dd32c09db54eUL, Seed: 0x000000000000021eL, Ascii: "c7jOJNcVq66FO6Zsa3lijt1DzXFlH9Vq6IImFxw9fILZRhoyUt4baGcO6BwB1HoPBgimCNB4mcUzTdB8IzmUPCnlds03TsT0NUx2SeMf"); + yield return (HashHigh: 0x50bfc7008737b47cUL, HashLow: 0x76251a2d0110b303UL, Seed: 0x125e614646dae5a6L, Ascii: "VUqqX9d4m02E3ZrqFVjjYEYUQWTb5nyICzCBehfzYujhDz8enZhbuqOl6aEf6LLlmqVKT7oDLi7rgQX4ov5LMEmROFNkOTUICQ437uzUk"); + yield return (HashHigh: 0xe4a707bbaeee8af1UL, HashLow: 0xace8c42503de33c5UL, Seed: 0x0000000000001183L, Ascii: "wEy7HTHaOEMIqhXWHC06r3D7GbWfEDtLspXQXf24nzuLegqU7fbLogdbtMwwnO9oMpVMLM2gAN0MrwNs5jNzTI9C5gEghpDXjgvb1SnB7"); + yield return (HashHigh: 0x2d99ddbd77a97bc8UL, HashLow: 0xe57bffaf201a8d8fUL, Seed: 0x0000000000000a65L, Ascii: "BTgr0thLDUNJWUHBpLNclyIGUK3wFqtAjV5qRIA2Tis26GOpS9daJCSAmSAnNtINFXPqQyXud7Yvk0oyZMaFvLWI1h8i7FT7sHq74jLho"); + yield return (HashHigh: 0x1aca5bef7e7d808cUL, HashLow: 0xc8905111d46f9407UL, Seed: 0x0000000000000000L, Ascii: "6MUY5w78z1s4HJSrSHxYbsssWba85V4dHlw4m6BIovgyRF1kcPcAcrptVplsZ1QxTsWqJcTaJluJuT10ErL3LWVbRq7E0kSiSkXuxU7yy"); + yield return (HashHigh: 0x3fe97784ecd32e9aUL, HashLow: 0xaea94129a9ae369cUL, Seed: 0x0000000000001764L, Ascii: "mrcfUdgjly8Q3Hozf82396puLhdh6rPb9YR7YYehjKgzzlaacbUkCNPEl9SZJ4nyhM1F3EqkQgrFspmF1olnGhYqErbk6Td6Hjq4X7ukZP"); + yield return (HashHigh: 0x17e04ad99fc6738fUL, HashLow: 0x25c7608e13e68e23UL, Seed: 0x000000000000115dL, Ascii: "Bem3uWWi7UrkICxMyg5QjHRfiEK2MEeLyhRi8BE6EtZFMYCJdCJ0ISICUKjaS5OPOifKFMVUE4eWQ7rJ44neh6oKSYJaweeaV9Xt5q91o7"); + yield return (HashHigh: 0x9b302c19f131298bUL, HashLow: 0xe502d01285583be6UL, Seed: 0x0c82a4507bdb4368L, Ascii: "Ws5KhyfRqtoo1z2eNAWJlIafgLV3QD0D06MRISpT8eIUNLkzJ37ZhYbXS5LkAAWidw4cKrJFIT7vRy70ugveCvEDlBZxds31ZkgGDmyaHT"); + yield return (HashHigh: 0x4c08da5b3c91ffaaUL, HashLow: 0xfc172275b297a708UL, Seed: 0x0000000000001610L, Ascii: "ttvDZ7Y7FO1cbhVVL4qAYBJ9gfvjTvTdk3e4nbLVKtfnINNRPZgcw9psemLB1mdE4M4rh3LzSfQ8atHh8Zrbymsyxn2yw5hzq7uvSmBKgN"); + yield return (HashHigh: 0xb45b4b8c492e3e3cUL, HashLow: 0x64bcb441802577f2UL, Seed: 0x000000000000186cL, Ascii: "m1v6gn9c24FcnmfrDUirtQnKMbI3aVrGwks3P7mE6lUpYgEkRrlJde46plOPzqMC67JBfwvbGYNdtXSZdGEJ4RLUeG9YAfjbSXO1p2vqYHn"); + yield return (HashHigh: 0x380509810789dae0UL, HashLow: 0xee75ee0cfe44e7adUL, Seed: 0x06432474765b54a0L, Ascii: "Q4YVo8pphP5tR2lRq0hUuV5x3DU7uSUcdENYNYtb7rGVnqkrK5sNjbYawVWMDIDwMXslrl8UMM0WIXh1L1vO3uV12nwixlrfv3e8O8N0PxJ"); + yield return (HashHigh: 0x60d628f1ea9c3f89UL, HashLow: 0x48ccadcfca1078cfUL, Seed: 0x0000000000001648L, Ascii: "ynkXthgDExjk58lj18xS52kRMXRza6m2Ef3fI2yWa1Zsttg5jPVVrbdwO2L3JM04fGX4rBkjPnhlYiTBTMLTLk1XSgrBicNa45yPTijloTU"); + yield return (HashHigh: 0x82ad4448c0e8b50eUL, HashLow: 0x501cfe3720c9bcb0UL, Seed: 0x000000000000088aL, Ascii: "Mbm2N6Ql3AcvccjzCM5JJcqPiqbJwBAJbfLpdmUtvY6GFoHGhlOoY6DABNDWmB2c8bsEIKdDlqyknbrLzqJny0MksQMv1N7tGqZrrfKx7bE"); + yield return (HashHigh: 0x41340ae885ffeb94UL, HashLow: 0xb0e62ecf3fd4acdcUL, Seed: 0x0000000000000000L, Ascii: "ilbYweKSYLsZjZ396Qms3bqxt3uPshmTRvvHmGF4Bw2pAFbtoErKRdZTGUGh0ZNi5X0MsU8zGBVUo6JvsYMx5hnFfurjcobbaXjAgI0hk4gW"); + yield return (HashHigh: 0x8cb6abab60599871UL, HashLow: 0x7b70dcba2913456aUL, Seed: 0x0000000000000537L, Ascii: "S6X5lplz4f0v4fyu9ZfZzWhDknI945mHyW4yI7lSwJRjdc5drcIqHSKQutfVpVAEBJ83uAl9X8JELAQBstSOXkYTg0nB215XYZeGv9LYmYRu"); + yield return (HashHigh: 0x2c02be06641086dbUL, HashLow: 0xc8677db5a5d9140fUL, Seed: 0x0000000000001514L, Ascii: "DZVFRcVzfvRveuyKN4KwzoEflsy0ejkjY1VeMsnd54920VkRdnP8sLeue0LxNPRjOqeCPdperH6wCfQiuEGXsZK1nCdc4eB193GwL40FrUUr"); + yield return (HashHigh: 0xc15c142ddd90905aUL, HashLow: 0xcc299831ee08ff04UL, Seed: 0x2aa91d47fa101199L, Ascii: "545eAVBh4b7h8aehQQEg1dLzfuxwMUWHyaIWVGcIu5BAvfPq7SKZDTvcZwuI6TyJCXQDw6U5Rj6DSHD0UOdEKfsQdnFfu4biL2sJF9PLboRZ"); + yield return (HashHigh: 0x72d91bb5844a33e4UL, HashLow: 0xc56622f95c09c99aUL, Seed: 0x0000000000001cb4L, Ascii: "7g7zhlNtdOEzZU1fed9IlHXbHhucy1rr2SCXnDs4tqAJK8x4aOVICZnFGRkICrQp7AFVY2LnYEttVsr95qnh8Z7fzpUlvEkLOPpPXLx4y7fih"); + yield return (HashHigh: 0xaad41aacd138ce6fUL, HashLow: 0xbfcf77e37bdad3e7UL, Seed: 0x0000000000001a3dL, Ascii: "dxcMi9u4rCVHP33GxxszNRHc3ZrHRHfAdHCuLlNkrwNqcAHY571SEeNtywxxMLz5RRt0UDWQcUBoOoHDgHFTt60B372nKOIYgwk8lVETPJ5Nd"); + yield return (HashHigh: 0x3448cf1a86af7c03UL, HashLow: 0x119760edc0c27736UL, Seed: 0x0000000000000901L, Ascii: "aajuMfDbNWoyon6w0jFUp5tBkzzxJolEMVPcQLGL61OjH5IVlxLcC9c9FCXS4B8GUIRFlB0WCgHZ7frwBKSAiruI4mi2VBhmSu2KC4paVBSPj"); + yield return (HashHigh: 0x7d905412f0c138daUL, HashLow: 0x018b66bcb9cc141dUL, Seed: 0x27a315498513d45dL, Ascii: "HG0QpHMCdIRTDLZ9ZWWyCrbpRNPibPTr0I0Tsg9ghDLIp5thiynBVmdxOrf27XA3n6YWHWEXNgarBNXJKethif5911W8ltsfDPoHTku3soCHz"); + yield return (HashHigh: 0x8122292c9d03f826UL, HashLow: 0xf61f1f260bd2a6d4UL, Seed: 0x0000000000000966L, Ascii: "7JWbki9hlTEOHarwjE9nxy9f4XEp2rdxNnm2LannA48ZYsvuc2ROx9cEMJXSmVfgiUDWCYkdRKb0G4Jati75y5u4xs9J9Mtl9c7bzFvwNm4YrF"); + yield return (HashHigh: 0x99b66dd905f680a3UL, HashLow: 0x1f8a9d7b956cc152UL, Seed: 0x00000000000009d5L, Ascii: "l8hv8CxLrilgAOYRQoWzTeyA7AcDE3rp8rbW00GwdrTgBHA0xr1gGdvtQhfWEvkdHrJunoHhQzl2mjTwOZWqCiQyaJqLoCFOnDIJk2ZYmOVLKt"); + yield return (HashHigh: 0x6e87914ed1b4fb06UL, HashLow: 0x14b7694119ad2251UL, Seed: 0x4a7ce3b9fd7be6f9L, Ascii: "jRMZhON2Jod0b5Eate6ICumrjHrrveYzKyqjlodKS8cGP4y8x7YXs688roH6JcmsCZBT6tDmteF6kCaQTqGgF7cb1O9XpknH1kqa7jV6TaHYav"); + yield return (HashHigh: 0x9a97b4553334e600UL, HashLow: 0xa76c9193c8f68244UL, Seed: 0x0000000000000211L, Ascii: "SemvpZAtfvyZ6eMvyWnLy7mRF77zttNn0rd1jv3lo9dEHcaCNdZsKMs2p70EtPokO0GR8gESY2wCUAiJuumvaObDz3XXABc3UKVMjHVxBA97GJ"); + yield return (HashHigh: 0x18cc4088bf3fdbb0UL, HashLow: 0x4ca210caf0f46016UL, Seed: 0x00000000000025aaL, Ascii: "Zg5R4Ht8dmz3Tc5WHr1Rk2ObqEmfxFyfRW88nuLstcddmAzqMbswIDUWQkP6Fiwhp5LHE7y2q73ibaZgyILICNu00a6UARbEJjws3MtYjPGO4o1"); + yield return (HashHigh: 0xd931bc822470a14fUL, HashLow: 0x610fbd7714f3369aUL, Seed: 0x0000000000001c8aL, Ascii: "uxS3iI0HXjLRuGbFQQrouJfQ9g0POnrQdxeO0Fo5Os9vpsMbrbFuuOS051HilwLGi5bIxGIvdO5qcV1omPywnSMgz1FCFhnQGcWov98gVkoWYDz"); + yield return (HashHigh: 0x0a5f3b47812bbc8eUL, HashLow: 0x0addd83fd46fde45UL, Seed: 0x00000000000017ddL, Ascii: "5ELV3bT55nI5e39OaEHYw4tukRZRQg5wKhvGvJAV4r2GOFKpyg13UmrFVzBEfapjOsUeiY4jNFhlU8a4kKhHoxqPwl5OfyaUsxLYNPBXvewFZzD"); + yield return (HashHigh: 0xcf9337d403f5e324UL, HashLow: 0x5cb562eb2f281bf8UL, Seed: 0x28575846a38e23a0L, Ascii: "TmnJlRfYqwg7y8zX4aRywJF4lhL6zdVJBUWbAXwZXhEzTgkHfd8eOehqKZ7sbwpzGIBjaAcRRGPOzXTlsudNUhFKQiPEbEy31oEjtPDkaAp4DNU"); + yield return (HashHigh: 0xcb2c95779b1890e7UL, HashLow: 0xcf35783ab9a81261UL, Seed: 0x0000000000000000L, Ascii: "y7mSkgmgATyI6RrBQiwinhZOGEyNq4gDPtMIfauXlKv7nOgdkXo8nygfTbkiedQzxC5rYO7Q224tQdX3pHIOYa1uhjAIEfIAKu2AFIMO0zJObPZn"); + yield return (HashHigh: 0x06301baa975486a1UL, HashLow: 0x116026a1589ab849UL, Seed: 0x0000000000001733L, Ascii: "kvpSpqD7jHbHTlP9jZ73lSxfaFPUR06eWj9YuKOEuURLkqOEzlKRtNtlehWOqHBRvN5Ja8Ndrx65sBoHqiB0vP8vw3W9hM9FiKsRXSyVziJdMtf1"); + yield return (HashHigh: 0xc8f8ccbcfe60ed24UL, HashLow: 0x7d3182eae3cd1eccUL, Seed: 0x000000000000117cL, Ascii: "ACvVLJN4YvbvrWlIBkloqpy0sEgxiXWyO4bkk2DdWG1sZ5fQZurYRjEIPHCRwNkMZSBoPzdSoFqyS3nMDAb5roZhCIA4LHNk4NqpywMI3eaBrqc3"); + yield return (HashHigh: 0x20ced5dffc826629UL, HashLow: 0x5907de8887e36397UL, Seed: 0x00000000000004fdL, Ascii: "JcvgEjRAnVnbr3vargAeaaBNli2QIDEWyo2jqLhB8c8vzALUYqqnkJh7dmW5fky6x8NL6hUFtAJ7kxVc8wOtlOjpZWqM8z3OWD35xmih3RW9e3PW"); + yield return (HashHigh: 0x9e7a47f5585bdaafUL, HashLow: 0x6eb06ce894224820UL, Seed: 0x0000000000000000L, Ascii: "1osqpwzvEYMXBhwDCKUPlSjMVRW2qy8AKv6Hp9PugG0cLhwUztcjrEb506Bm6UPmS8i4icbB8xhu92MT9hff9xuLKKZg2qkEgDWm5PILwVpT9E8KJ"); + yield return (HashHigh: 0x9c97f2a877498fafUL, HashLow: 0x191f0cd801043dd4UL, Seed: 0x0000000000001457L, Ascii: "sbkapE0QobFzNZ0QWsj1cMmPoGT7QGOUzoMDpgmwLkF9MsfnPT8GStThbxRaHsDr64pQ7vfdpDzylFP604F1aH6S2CGT51FdUKrdJ3BLMsd7B1eoJ"); + yield return (HashHigh: 0x9bb011a041c5ddc6UL, HashLow: 0x81d47d82578aa8e0UL, Seed: 0x1f9194b29973d7c9L, Ascii: "hf3UyHA316qMnV3ZWvZYKjmdaCgv8mNkqICISTU5S9AnuN8r68HrMrrY8nUSQ631LdpF1mfxP88I4uienZJNhaOOzfB5s20JexuxlRyLu6pUDqHRi"); + yield return (HashHigh: 0x317b7c14373d61f1UL, HashLow: 0xb54071818147144dUL, Seed: 0x0000000000000000L, Ascii: "Mb1fTHyhvQNuCur14DwDIPky7QP9kdi9AUEcqJTeGbShRh1Qf2AB36QPbQe17mKzmfeNun1qisQzu2Y8YI4dlw44TFh0otAltgRHe6EKemPhRxUk5"); + yield return (HashHigh: 0x24c43b5308fb36c0UL, HashLow: 0xfa21ae3fc5a23575UL, Seed: 0x00000000000013bcL, + Ascii: "suvm9A69ZT4fDwAv8bb5qSoRq4wdLW0RQLgM6wNjzqSl3eeaIcPfk2jQy5wsyub23Vvqxp30cSxrzV1jECsTBYt9HGr7CQSssF4WtAJR1TzxsTZVBo"); + yield return (HashHigh: 0xff8c1f3f2b523a3eUL, HashLow: 0x69bfe72c96a9974eUL, Seed: 0x0000000000002688L, + Ascii: "LTioJY66DooZXeELJKOZIOM94DnJS3xNqNT28mm6QofQTPIal2TtE188cOD5MxeUaMPxhnmb0MNfqybyp81ighJzODQzwH6LFlky3dObQ6ooeX6WQW"); + yield return (HashHigh: 0x812d7846bd90b4e7UL, HashLow: 0xe781cd1cbe09d441UL, Seed: 0x7ddd0fea86fc4155L, + Ascii: "PiRkx5zRiTzKmFEnS5CdpKiVR8BR7MC8SLdsJoUztXAprDJ9WSJ8i7SdEq0W6vZarlUWGux0b7eM7V7ioMGDxIDUkyYQLgJIdB2Biv9rXjbP9OT32s"); + yield return (HashHigh: 0x4223696d0e2672caUL, HashLow: 0x6e193da844cc6e52UL, Seed: 0x0000000000000000L, + Ascii: "ez4oz0YxL2Jkn22gSC8bOB3pwGxJyTZ87OGkKQ30OgnGRIWHCFiujT7iDHczTW17niBoOg1vMMYjJWvPABRNKAE0M45PbLX2cqwmdSd4vjRKM78icV"); + yield return (HashHigh: 0xc2e65ad7ba26273fUL, HashLow: 0x02118ec48f85a577UL, Seed: 0x150ecd8202ec6f94L, + Ascii: "CdCswqltKhXEh2cz1bslQvLDyBwBg30jJf2PXuYMHrm0ttCaBhuG91QSq2pZDNMZYycOACbaBdaqm40WBoJqxKFoWGfaIkxlcY9gngw0HVjSMHLujt1"); + yield return (HashHigh: 0x70e58b10cc2066e1UL, HashLow: 0xcda27aa66d48260dUL, Seed: 0x0000000000000570L, + Ascii: "J0iF4oPqTEEeQ5jwZxbBzeZtcCezbXoWuLOMdYpwA6lF3pQ4BGoKJ0aHSnwCxuWneUZFXmtM4qzCSzg4F8Cz8zncHfX8fcV36MrhxIayngvR0LzlWBH"); + yield return (HashHigh: 0xab4123fd3a8d17d7UL, HashLow: 0x8c58920dd09f3a61UL, Seed: 0x0000000000000000L, + Ascii: "0Q4RacmwfaS9Z7YoJZvdV5NDXk1jWA0Dh8yj2cRQhAXYTx6MVrV65doHvtcJJ7zYqHnIXLmi3WhyrMPHpVwZyTPdtqAjw4yZ5ZDcTAxqVI0CewVB3F4"); + yield return (HashHigh: 0x3441e60b537c2930UL, HashLow: 0xd1b4add7a0e160f0UL, Seed: 0x00000000000001edL, + Ascii: "JLMeBXM88Aoo6xrvTosLJdBkU6YYzKoNsopKfAdTxGq1EauEoOxSWQiJLNIvlFGgHmWaFaPNFjmLbq4OrKbD6lpk7mfTEcDVbNvji4yCzWDlkVQX0d4"); + yield return (HashHigh: 0xca5df5c55e7735f8UL, HashLow: 0xcf623fbca2293251UL, Seed: 0x16571a16bbbcecdbL, + Ascii: "uKn1dndpEJ3N2bkSfnioYt447xio5E85vu2Oyx7rPqFPq6IGfu3ldNjppkfdSjaUXkAAcEYAxDNevOl6OOZoAyizIG6DPTZuAmq9kNf8m9bzxjlfDtX1"); + yield return (HashHigh: 0xc53084a9d828a845UL, HashLow: 0xadaad5a3ab0478e4UL, Seed: 0x000000000000084aL, + Ascii: "lJzhKyv3xdb65vVwrdbpoS81txrDUsNRoNH5t4CgvjSLXvsrWu4iUW1LYJLZT4KldWJ34cIswprinL0ngFrcRkI3Sf1gkPSbIA1FVtctnOsPZS1y74Ov"); + yield return (HashHigh: 0xce92bece84e77a8eUL, HashLow: 0xbed4b4e73a9bf60dUL, Seed: 0x51629b40fb407cdfL, + Ascii: "ZJ1nQjq9SRgzB9MRmv8D2iUazO7MYBoTqppTPl0zQLVyi24brxU1BVDrqGtQbgbOXrGNugUbqngR79vUjLnN51j9rSHWbTQt96K7cMiaRbJXzhCk3SSF"); + yield return (HashHigh: 0x42a6585c10c26348UL, HashLow: 0x682367dfe51063b1UL, Seed: 0x0000000000000000L, + Ascii: "eggHdD0JKgUjFttO86f8m4VUzNbRchbFvC5egeOyjZPtKCIjTEYiLurYBzhMs4lbDsdUolcKKmPhZ6QNb1yDgnJKzMvU7d7oPH1MK49uWnXrLap1y2De"); + yield return (HashHigh: 0xe1fcdace9a4f11b5UL, HashLow: 0xe0bb9fdf86f3eb3fUL, Seed: 0x00000000000012e3L, + Ascii: "T08gMFR4dwi6dLgRYjNwJeXKCsMEy3MfEb5dtoKV7y2q1ABDOI9kEojlQZZ4pmD08k84F3tjZdVwEnzTdqdsddnrJWYhg80HeVCL7Xddr9J7DFyf5jX83"); + yield return (HashHigh: 0xd24e5c49789a3cffUL, HashLow: 0x4b315e53782a882eUL, Seed: 0x0000000000001bedL, + Ascii: "gxVJPhh7jsSGrEmXquVDpC8Fyl0vZv2OLeEgiN19qmbVtnobg4ZzHLRxqcvAWF0CjvMD70MzVFI49CiXDLQ5N0lpENAA1G6ZU3tr13N7GeUCh9mDKBRuV"); + yield return (HashHigh: 0x794472beb410cbd0UL, HashLow: 0xd1ad2b3b4bd625e5UL, Seed: 0x0000000000000000L, + Ascii: "j88XCe0gssrKv89sNDavDX3o8lo6PA9wi6PTYVm7wQLT5HUtVVf9rvx995f7BYPzuAwf1Vz9w8NvWTpqVWxRe8ODOTgPGc6Rm1qyHgJZ47nUfSSTeIceK"); + yield return (HashHigh: 0xf2653634dec2891fUL, HashLow: 0x04f083373aa7f7b1UL, Seed: 0x1deb3f9bc2d7fab5L, + Ascii: "dxT7avcylPgJJDwzume0GTP5OemkAhvVdMCryi5GOjimReS4wZfx3JjoJKhUPapov8DlmP3bRXoLdRfCvGnZk8AOwWtXcBOihM6FELk3PwQshwTnOjsoH"); + yield return (HashHigh: 0xfd95b3a8d33be2c3UL, HashLow: 0x6eb4ab134f545685UL, Seed: 0x0000000000000000L, + Ascii: "mw5M8OrwUXWPR8jYBNcyQKd74sB5OmpPdIfvG0zwbxRtJxk7Zp7mOrxI6u7Wi6H4augaat3De9MsxwEvbCXJb6OKjAalJaxh9xGgsbkf7hxRqXuWpVQJQ5"); + yield return (HashHigh: 0x60b299a950aaa60fUL, HashLow: 0x804c5b8aa25e590aUL, Seed: 0x0000000000002378L, + Ascii: "D3DALUgqg5sSHA7y38PHxoPYC7ZAGba87jdK165Sf3LKhk6BdKMSBRFMIbMJ39qjDTyemqfXB4ngJ0TqvJFiWmnwHrsZaUebNgTA7Ie3kXWhQEZkyYxNAX"); + yield return (HashHigh: 0x7b96d76993262dadUL, HashLow: 0xb509b02cc827fb9eUL, Seed: 0x0000000000002426L, + Ascii: "BW3FTDpTd0ti3BlqKR9JTywoyzEaDtZ4SpUflwMoYyPNb6NNdkWjhh478Mz5zhEQColgpTfct6YwltR5aXbOkVH0WQL6JEV20eqF28QTibW4W5YaOidIdU"); + yield return (HashHigh: 0xd2599f3edd089b9cUL, HashLow: 0xd8287c5751c0df66UL, Seed: 0x00000000000022bdL, + Ascii: "R95ufGUuwozutwJyHugFA1LD6LRebVMEYTRBCJX7F66FALs65ZctZkztFtuWHv6ZJK5F8GeAr83PJA9VH99WIDGxzpnJnrbRX6ac5BQBU5traRMmFnNmI5"); + yield return (HashHigh: 0xa76d7f05174ed3bbUL, HashLow: 0xb1b82a26ab1e0d73UL, Seed: 0x0000000000001b08L, + Ascii: "fa9PFmPkwourA0w8kgqtYOC4pzLZpmRZupeJQ3zxpqizARB9zDTxyIcaKJhzdEYDzR9D2f6sHDevG5RwSOuiw3bRRsHztjIvfBtentMUXB0FnvNr7cPfFUL"); + yield return (HashHigh: 0x6531efc97c6b2df9UL, HashLow: 0x6d902379429f32d7UL, Seed: 0x0000000000002578L, + Ascii: "nWjpSNomqnBRgLxX1XIEZOokQljYqGg47rasLRu6ik4HUDK2J33u68joIae5EKevMOWFpyEFLz0xwwWfHRk5zZOEFIhtvbRXCKVv6J1ySihD6VURmhEITAu"); + yield return (HashHigh: 0xc3b5c0891e6fad69UL, HashLow: 0x4acad820be9232eaUL, Seed: 0x0000000000000000L, + Ascii: "fEkGIcqyImaJ6a5XkoHR7hNfFBMQqwUiqDc2qVenrbXBRzDR6JlEXvHVrUQlpoUgLigNv20E5JB036PTL7P5cvke3cfffpfyRRpOZCmID4ah4wXgjqJZxDL"); + yield return (HashHigh: 0x923d440f71770b36UL, HashLow: 0x4275da2eafa9c67dUL, Seed: 0x0000000000000000L, + Ascii: "h0dmpmYdBfkDgzSMVwwgbFHztjHm3LAtmzplqJBWiyIEmvAQmDp3yOWe4r0yk3La9oQQObEurfUwjHD17jBhFh9wYdgk0K4FSzVztfUA59vPvkYMMCedcxj"); + yield return (HashHigh: 0xde063fc696385f50UL, HashLow: 0x1b85374207acf59dUL, Seed: 0x6ef0b80e82afb6e6L, + Ascii: "DYZbrjzRA49CJxbgbtMGholC08uAZwMx80APLGsHyAeWg4we170Y9bbvQ9ZJaOyoHMZ8Cm9npmac2moX7477HmhbSFJ9SGwrZwzM8XNFri7pW32jeiC7r0QE"); + yield return (HashHigh: 0x2680082ab8ceb373UL, HashLow: 0x5db11941e47b1c9dUL, Seed: 0x22b9503c0be28addL, + Ascii: "a7WZkZdJNAo8YoZSEPykILtVSKnmofkQDPKbmn3z7KV3WCRnBLY1nMzIUcmYhc9y694NwkqEfcB6gYgxWSmIVhcnb6ajl3xuWaSi4a5NTTfVXb1MJ2ZNTZOX"); + yield return (HashHigh: 0xb4b1b28cc6cabafaUL, HashLow: 0xfeeb09d20ba3a6f3UL, Seed: 0x25d77c238fae0965L, + Ascii: "ZVMmHy9A0KeocuovOZk1Tcdra0LYFTahBKJp1ZqBKz4S5ud0bp5SfWiFSFjU49wMYNxklCwpsqN404V3qQIhoxwPcAzk8p9Pc5LS976t0t0OaIFyVeMMD23K"); + yield return (HashHigh: 0x85c9e8adcc526728UL, HashLow: 0x804d1156fc444a37UL, Seed: 0x0000000000000000L, + Ascii: "Yb5xDwVr49RumOz0TTNCo9UI4g9beuUiNAXdOgtnt2Ac4e0uSPeLDb0jDz0E7shdlBaNXYQqxhk8mXuDCp2TFdFu9sAidqgx3fzFg0lV6XTxiw7quTxq4YqQ"); + yield return (HashHigh: 0xfd6008f8965f9bdfUL, HashLow: 0x822bf11f7c923541UL, Seed: 0x0000000000000000L, + Ascii: "2dM2EworvyZsPrddBQeV1Fy4nglGaNmb3AMx5XXdtB7JKMvWJ5FkmQK9TX5nZSsaOJ4ejodmbcXS3ouItsJyEgJDCVFye1Hsbmc9PlIvDvMMIUtM2K6tOY8Bb"); + yield return (HashHigh: 0xfbf500d2b085a299UL, HashLow: 0x06ac210f151b7287UL, Seed: 0x0000000000002500L, + Ascii: "SDHTckez9eTizt2778eK2avXdb8ZPXTB2DUd5TxKqmjMTIGtGI7BF2p0JlnIWYsqzd3xn8JhpmnT2oWxWy3U2bw8NbE4aHp3vBPGaaUm2xpV6yaVsTTxuKfmk"); + yield return (HashHigh: 0xaeed15cf03515788UL, HashLow: 0xd96f76dd21e0b5fbUL, Seed: 0x0000000000001d58L, + Ascii: "efKBPphMEfx7NKuSPiEvxsNMBR4k9ehqo2YR8HgCAK1ZMAacELKQnjr4zniqLfauvLkV3M4eYK0hWd6ITDIxCjbOkTpvNz9f4L4tjzNCP5oW8hjrZwA9PtLFk"); + yield return (HashHigh: 0xf4a66dbc18cf7da5UL, HashLow: 0x3be6de4330c1fd0bUL, Seed: 0x0000000000000000L, + Ascii: "LB1wzaDyYNckrwL8ZqlTzqvwYKpK1L2Su5GwqGTyE895mzsFsPmetCadr9gXd3I7eZNzqR25oMnERLrMjSTmKYxRcLDLlFwSUeE3nN1Mxh6jOSdHlpASZKhDK"); + yield return (HashHigh: 0x7c57caa46a9fc2d5UL, HashLow: 0x566aac607fa0e927UL, Seed: 0x0000000000000000L, + Ascii: "to0CMhNGgBNfmXsMx0db0UgVSfhwPn8kCuHbC05UOU9Pir7fwTkNS2D0WUBkk8TtlnRd4kPQa5HbAtE3sSeBYv6gOZnCfBSmzQBe84nYQLz0npj8C8P87CFnvi"); + yield return (HashHigh: 0x4fa5eb93bb896b8eUL, HashLow: 0xecc32559efe61ea5UL, Seed: 0x00000000000008d2L, + Ascii: "Syjto1ID4pcwx4rmLfn0nL8tFwb5rRudN4fG6PsCLp7viesuyYUFXdtC9M3QXPHz2vLhm3OboqIczqjl77PxRrc36whJ5xOvi3pepo3yZwGgjhGmlqdtBm43vv"); + yield return (HashHigh: 0xd73aaac1842a7b17UL, HashLow: 0xdf8bb19cff4b4826UL, Seed: 0x0000000000000220L, + Ascii: "6q6JUmGZeVs2S88i0qKiyOOqEEIm5bAJbVshthBolDkLtalZVll1O5ZT2iogZoCZkjJm5pEGaL2OCqP3hTXNznY7d1YW4jPAR6A5R50JnqPQC6it7yDl0B7rxg"); + yield return (HashHigh: 0x57bbeccdba6fb24dUL, HashLow: 0x7de92607e8bc5e2bUL, Seed: 0x0000000000000000L, + Ascii: "eZH1fd8pO6EDmo0o1Bmuwt22D1fZvYqLhx7PztSU5IE8HWDK7tBAijYG1gBt07Uk3AJ71WkUEkormEdLK02RsY7MYNAeM3xJatJcohbylxgaT2hGKJ4Qw16Kux"); + yield return (HashHigh: 0xda27ff604be54cf4UL, HashLow: 0xefab37213621eedbUL, Seed: 0x119cc06277f49604L, + Ascii: "4bUBTIsAjWzJoPYajd4sb71W9lF2zlcR1pNclTQJ9QGUQUcvLan3btn4FYEbpIJJ9tUdGC5ieQyzsuVMu51Ic76bdpkBSzPsJGPFlRUACXs6Ej3McXc7k7aJZv8"); + yield return (HashHigh: 0xd2be792d16d03a58UL, HashLow: 0x478448b6662d309fUL, Seed: 0x0000000000001df1L, + Ascii: "n2vm68ZfMpgFzBAwg5IJdnWppUe8y1rjtQ9j5QPAhAhqg0JviKLmq89E8GzYL7Sa23lwPgGXLfC21obN8cSKoobNMEfXlFKsxvrmfazgAKio47bLpjLp9KugkD8"); + yield return (HashHigh: 0xb9166484caf99320UL, HashLow: 0x7af84bff1450cac5UL, Seed: 0x00000000000000feL, + Ascii: "BPPIpwzff9njaLQhRKebBeLCJ6O3kpXA7K72KBYDERPNrhDpDXxk1a1O9f74cjxoEftOh98wFT750ZOhhBq1zlRUUDKHYofmUWzAXlpUaHLNbHo2EnQvW5xOhz0"); + yield return (HashHigh: 0x8f0f4bc9fd9e8c74UL, HashLow: 0x97572819e1af79eaUL, Seed: 0x0000000000001befL, + Ascii: "9PSFC6Dtq23t1AXLeyaTEXkBbXRT8haIPej07DlsEFFisvp6Bkx9lK0nNeWGF56y8Zl9XmTIyF1hOQ2wFBAW4hEvL9bjGLbznPxmxVxi5AGOK4DwB4oCpYgnXY9"); + yield return (HashHigh: 0xa5ba4bc3457a1e47UL, HashLow: 0x6e07977cd679868cUL, Seed: 0x000000000000195bL, + Ascii: "11rvPCNSxDfVupdWAD4cGbgX5aTY4vtgtY0pgZAoKDL4GNXtidM2QOIfRSQbGriGyYyce6HEb0kqrXU3CAjBKlkz995WXc3iCidZQGDCGtJMvlxpaCYYOao106UU"); + yield return (HashHigh: 0x421ed48dda1db2a1UL, HashLow: 0xcf3e570f5979bab8UL, Seed: 0x0000000000000000L, + Ascii: "kh5Yj9RxyD2LupLfmbE2ohuldqEEqIZaQ1brSKZcDPuh7OFGA6rOVS78CwPyPKh1EB2U0JZpkiqXXRoZQX1y6nGQZBgXj6FlF7cSJEE58TuRv47ECFvlKwioRN2N"); + yield return (HashHigh: 0xf8732516ab6a77f6UL, HashLow: 0x946283a0f9c6c92bUL, Seed: 0x0000000000000c7aL, + Ascii: "sy8HXdhWMyH6zELpNiBlFOVKcoisLkAwK3Vs2wMsvIihYwKCdrgP1SLYQ9VcTr9qjPdJllZ7KwDG7AzW1i6d4eUHlNhNHaCTqD4DqzMCnL4g4ObPAEFNMu5hES2F"); + yield return (HashHigh: 0x8eb142b851a11cc9UL, HashLow: 0xf734723bd77a90daUL, Seed: 0x6e791466d1b71ecfL, + Ascii: "GVbT6QpqMbG6CD5PkyXhhgb2pj38HYJ3leVQhwRkuGuBjtGpBxKmLTfDCUZ4UcUPvR8pGW5ARTcYVWKqklFQ5R0pK0gDsLCurNBeeH8DPJmpK1XwZwRbL075ICfP"); + yield return (HashHigh: 0xe2b63d3130c2cdb9UL, HashLow: 0x490d423b611644f8UL, Seed: 0x0000000000002009L, + Ascii: "ID04vto7CdUYgg14K0WbVzHmCas3lw1adGRN4UWp6llYwReFUI0xjOyOU4Nuf5r3iGuOWcmj0R8njVApDh0Xyn0s9af7yWRwBP06UsJOAFpSIaXjuGt9axkZX5ZFt"); + yield return (HashHigh: 0x0be651e910df272eUL, HashLow: 0xcd92ec687c41738fUL, Seed: 0x00000000000016adL, + Ascii: "yicaI21xPFetRXBMXg048VnQ2B4ojMHQka58NDzE4PTKkmaOf0D2yGOb5kxbSLgqD7FBJCNPhXaUn04kcZOpJjgWLKhKkE93SeOgMq08038CrWlOAXCOBGbam69SF"); + yield return (HashHigh: 0xfb994721deb39aa3UL, HashLow: 0xff474b99c52b1a29UL, Seed: 0x000000000000110dL, + Ascii: "aN36fVjiCSVWe4rhyn40Yn9uHRo6sfVNJCKz6vDLX41mdZg4H0LbCerAxI189qQGElgXzLEFO1uaUFT7OIhxmPO8v8XiH3eSk0nCHrzVHuBOwr4dNje4Zvd8IAPLv"); + yield return (HashHigh: 0x04db90bb35509330UL, HashLow: 0x2df49cfc5e66971fUL, Seed: 0x00000000000011f1L, + Ascii: "WSObRIFudcaaiIma8jovld92hz8yf1isyIefqjV1DPWsdb2Mb0sbyBCXIciTdRMbMXdO6CTF7jjPhZ83qqLRngpWv5l2Yqm1Owy3EqVFgktelIxnDnoTVho9NGOD1"); + yield return (HashHigh: 0x6de7d0074f94bccbUL, HashLow: 0x42e85be151993721UL, Seed: 0x000000000000213bL, + Ascii: "jDPUahItRlZneDoujRspI55yhCATOZbRMzp0sZwmMshcE84vugA4inws20JIeWSZSYcPqGNvwGqa6Ygzv6sZYS6eMEOwtLKuz93nb48uBhay2aWtMPdNuRxmzZaUBu"); + yield return (HashHigh: 0xa2584b5745534643UL, HashLow: 0xa88bbc1b7d1737c4UL, Seed: 0x0000000000000000L, + Ascii: "kuVv7vsS9fsPOCZgTVeeYMJAumM3XuGdLwd13XhqOgNqGeLpcdgugmwtNyijl41CtQROLCx8to8nzvocNUeATjUfu3puYiZxyHmSsupADY8iQbMtpKUCAL5dm88WML"); + yield return (HashHigh: 0x59d34b5a643a793aUL, HashLow: 0x0daf1f6bdf9a166aUL, Seed: 0x7541e104150588ddL, + Ascii: "7mJOM91tJRrFgnTzxpXD3A1fRWj9unBPhs60v2F6FqWB57sUWFJc7N6UG0WKnVVfVuWVD3L28GwguQMi1Fvw1GtoZToXiTsvpcnRqFeTVNp5eSrYHMHHBiF54qoCD6"); + yield return (HashHigh: 0xf11522ddb1bc96c9UL, HashLow: 0xe4269cdcbd2d6424UL, Seed: 0x0000000000001f1bL, + Ascii: "yYEfhCPqNBZFil1tkG12vU3882dn9YL8HiAlvwmM80K6OVUWveM9MNBM0Nkgp3RfsXSR6Tz9V6vCnXwjrabwJ6xGPJTqz2ApkoJWN6cs1jKp4y2m0RoR15LsSLupUp"); + yield return (HashHigh: 0xd287daf1c8212cb0UL, HashLow: 0x223172e1bb0fc548UL, Seed: 0x0000000000001fbcL, + Ascii: "jbLVx0sDosYXshOWv1Qh0mQTfxenkKM0puoQSTg0Y0ur3UzB846mgGj6dqIG5pgMCs30I1VYYDTBMfuBQ9JejRkvcKQ33lDDtOQDQRJjNm6GcnFhXAhoCK4PVAdIWy4"); + yield return (HashHigh: 0x733aa04ac5adb3a1UL, HashLow: 0x3e5e4267e0a59d46UL, Seed: 0x282bbf957aa4124bL, + Ascii: "Iii5uebDxGwxHV6VURGxShQkPPcBfZgJTT1L2hQuoGyNfhmSm8oVPKce9APyZdnRuDpcjfmhyIgbCxEbxgxyl6HH2BXdGxTzJaCGsJGeiBquN6aahfkaE5xItLcMLds"); + yield return (HashHigh: 0x50fa41e2e6d42047UL, HashLow: 0x0f4c763efe3f92e4UL, Seed: 0x0000000000001da5L, + Ascii: "1J8qWDXA1bTBa0zp81ZCm0gAG4OvOGKlK3sHCmDCBNJvE45oYhnw9uVI54Kqz5OazJIHpqSvMQ3UnQccSyjszKe9olSUukOEEzS6NOHQreuuDseYzQApdf2rkV2M0LZ"); + yield return (HashHigh: 0x88f31dece924dac6UL, HashLow: 0x7e691713defac1d6UL, Seed: 0x4e0078473dd91e60L, + Ascii: "vJ75E3w5rzh5rpH7GP83uzRRIkx0mFuBOUjDnQfsXcjHIc4FVId4CjFRBXMtNDW3K6iNwgM9kWapyxMQj5WXfOk9zcxpANSdizfvliKn9J9c4L1jdiFL5pZeNkmHkXp"); + yield return (HashHigh: 0xdb8a765db1353d02UL, HashLow: 0x5e12382e881064f7UL, Seed: 0x00000000000024dfL, + Ascii: "60vnJXQlyQfa1Ab3P5PHfLbq3uN7ZJ3lN7Wr1jEFweUHKIBbQbvmfoRtxFlEpkJF3BSX05Mcw0s4acFNBeiScjKyd91eICkXmCbqN0jME8gyu73qBUN5lvP3mLMDY7W2"); + yield return (HashHigh: 0x473464459a871ff6UL, HashLow: 0xef53b38ba91a93b0UL, Seed: 0x414a0e4285faeb0bL, + Ascii: "0oXm4Ua8BSFugTc0jjJP7qqgKqqmAM5pjKx0fH1lsN5JOoUWwlSkpjiXDpWUWcakDbLN5HnomU7pfKLfGu4jVZCOdLs8IhkCm6KtidMd6VpvE3rveNgput5Wl15SnJxG"); + yield return (HashHigh: 0xb91f001c9a9f6eebUL, HashLow: 0x647a8e09af8e7ffeUL, Seed: 0x000000000000258dL, + Ascii: "rDbjGANGnoqP1OyE1jS2Nh9u2jCe3I2aylK9AxrwWrX9eWeZktCCM1zHEWZyy3nkayGTMlZYrPUz3BV8aXmzH08XVJq9CONAa3gGInx8ul2oukX7gMVzn6HIktSVlrnf"); + yield return (HashHigh: 0x2491a7aa1060c4e1UL, HashLow: 0xdba0d6922f30bd0fUL, Seed: 0x0000000000000719L, + Ascii: "Vb9DqE75q7FoDNwXC5z7JXv8MClHWVlP46ZM2DEpcnESepjjCoPc3A0SB3sdD5Qf5WFVZZD5eMK3d72wIatzLikDYdAkjGB2TBYELWnh9sbn1Ei9neg1wTkMj3CGM1a7"); + yield return (HashHigh: 0xba597cb8756e411aUL, HashLow: 0xa7723549559c62ecUL, Seed: 0x0000000000001b1dL, + Ascii: "uqMPHc9Ks7bAPG6zdpkbSjcqkVXzOGBSyBXTvbzQlpdQ6Zv362rdkRlzBIbV7nPyLOGutx6Q4YD2wksGcsC6GapRBMT5QOQq3Vt6NkobpxENMG3anX1cChirvogNtnej8"); + yield return (HashHigh: 0x52a03823ed51021cUL, HashLow: 0xce6bd016f92cfee6UL, Seed: 0x54cca3d4fa3790bcL, + Ascii: "9MR7gE7doHNszhTm9YvMpUSOYiQL98mr6xXzYLVVDxzFT0jG5Xpy0n52wk62MwX6uIOY7NzoZzJrQeoyUPOX0qrfYSCiSgDmgs62yJkZLPKYHW671T9JHEzKtyZ08l9Ev3"); + yield return (HashHigh: 0xa2fbc68b28ca3619UL, HashLow: 0x919887092bbc53e9UL, Seed: 0x0000000000000000L, + Ascii: "U4MVPYsUfMzMZLh1554Kp8ro4m0CYRTG581ZSciQVu4pkps8pL3mrGW11rBxqWq1QAG2IjmYMpj3jYhIbFFNT8Ni0rIgGBtk8R6cS35Dy4NIlzPZZ3VeSNka3YbQH2JsQI"); + yield return (HashHigh: 0xd154e0ac11923be9UL, HashLow: 0x3452adce55076408UL, Seed: 0x0000000000000000L, + Ascii: "9nN4HswXHi16IpInViwg08zARLQWPteDT7PGZ8rEm7jAxT6m1tjIfbOQWy3hBtg6QXGFpj0qKjUvdEmeGgN12hrI5eZMxQTZsbTIPpo1iNxkawtpeQFj8y7gfSgz1vZPPwP"); + yield return (HashHigh: 0x7bf8e4aca0875fcfUL, HashLow: 0x94cf2d90c2727cb3UL, Seed: 0x00000000000003eeL, + Ascii: "OG3H6jQJUMEKuS6ScLLdUEKaOl7CAKC7wRrzyvFQJPl5kSTYtFzycrybLpLwRoQ3LSPEHWQtvnVA8vDoSaAc7qEo4CO4e1FvQ3gmAQps2FtPq8GG9q95S30uCHJwVuUSaiW"); + yield return (HashHigh: 0x45501ce0ea80325aUL, HashLow: 0xafdadb344df80b9dUL, Seed: 0x0000000000000000L, + Ascii: "gPdhSSq4nip27S7b4skjCs3Rvu7oKnzUY5IIpMEDYomFC7QhpRlRqBEJcllvmhtsSBZHe9T7VktR4zRpilfa9DSj4EiyDrBpEX2eYqAAuzvgh9XAZ1S8L09Ua6YyddvEocO"); + yield return (HashHigh: 0x2445bf5ea33092e7UL, HashLow: 0x2477a33bc4271565UL, Seed: 0x00000000000020daL, + Ascii: "jmiaRf4pl6y5mvJCawW9V8coo1w5P47Z7kLL6SqTnnX87gEAZA6V4lBmVyMxZmGHI19aFVCOXTvimQjpgyMZ0sKriuhdbO0IwR7pjln2RfZwOExrNAzcCiEHnEPKzMt7yQ2"); + yield return (HashHigh: 0xd0099560495820b3UL, HashLow: 0xd52b949f8e2e41d7UL, Seed: 0x00000000000011fcL, + Ascii: "3NRVB5oUvOnIHozic5qU9QUQn9tGPz3F3A7ziKLusgsABEx3Q0UbnUjoiSURpumSCdjksxSE2Xbu4v5LRLsimqYSivFcmgia9j006UtTeANVrqZHo0PvwhI7wHfCZUM3fasY"); + yield return (HashHigh: 0x76ca93a810156068UL, HashLow: 0x3f833e46f7fc9592UL, Seed: 0x0000000000000000L, + Ascii: "16U0mZVdknAxLjDYnszfD6Wl5VJaS1hq3e3riTqyHibOSueGwXi4Chv3cdlyeUOUjpHTjRrSa7akVQM7VzQ6I8waMVpt4ndYDyiwx9Wqivsec3qQak9h8EawBbKVpA1LIYvk"); + yield return (HashHigh: 0xba6e4dd8414b5c2cUL, HashLow: 0xcd4d7ec3a0bde018UL, Seed: 0x1f8d4a4ce16cd022L, + Ascii: "WfPOMwQe8Yc0pW4Lzvijp4M6ySmHzteHVAgeTq01IMD8kyEZQPLq9tEmuiHM6WHDSf8ML9IVorqTQgFhAaiUXal72dEREUa1WWeusot7i3OMr3NOnyXc4itXjGC3Rbrtlzie"); + yield return (HashHigh: 0x5dc48a8e6279f419UL, HashLow: 0x1a7a23f90e501821UL, Seed: 0x0000000000000000L, + Ascii: "pkEpdDVhUfUMS3ASIvA5FAgWcJaf7hn2j5lNpjwJKRDSTSkKK2g80S7TbtqYgcdK9FNcCCaSI5uAT2JIDyIx3S1X4DgcEg7A9FO3zVrLwrh8hqQrS1xB7yIIqelfKBSTNg6a"); + yield return (HashHigh: 0x7f5c3a9e40b94834UL, HashLow: 0x658564ad0a410ef5UL, Seed: 0x0000000000000c61L, + Ascii: "8qgkEfNDcw0Fe4YA4JxGVZetLthMJ3OpR2xIZITaPR4F0nZW1xLvEGu4Ast6RMP8d9NY17Y85sqIuLI7QPSx7mj8ZwvJDcTMVlhuja6sJFwY4lwYMkrdiUyrzCt8ABJNohxWO"); + yield return (HashHigh: 0x05218554e3f0045eUL, HashLow: 0x2cf2b47147c64501UL, Seed: 0x0000000000001769L, + Ascii: "F5cSZPLTlGxNoHDCfRYxxHfRjZobExObDlBdY6XgfUlQn41Ep9I6469ErOlgDAOxLknh7SbJeHWzMWRlNjdDQABmquDPPvunf3bmiTXwBojvDQheknbkqTJq5enJ5MDwkUdhs"); + yield return (HashHigh: 0xdc3e89f24178244bUL, HashLow: 0x0c8b54115eb4173fUL, Seed: 0x000000000000135fL, + Ascii: "H1V6q9I6hIdiK5yGBsBSGLkKMGpcvTOUeKj1W0qHLgG8liwikP0EPL4R83BM199VTrIafmXA28fDpQQnMlQyMGEpDHXChYkAXjEKiz5xiRHAJoELpjOMA0VSqUZ4LyzSx3DWM"); + yield return (HashHigh: 0xe2b7147ca84780d8UL, HashLow: 0x6e936a3c7dbc86f9UL, Seed: 0x000000000000103eL, + Ascii: "M0Vir8hbKd9ycWn7Ex9YTPSdN2jUxe8Od7R5FzVv1BCTIw5kM3lTkrE91oPc8DHQ2ze7Rdv1r2PGJaV9gqvcCSfDwA5vbEciCLEOqwFkClzNHKUtzDxlFHPjjqpkX7j8Gd9g3"); + yield return (HashHigh: 0x957948983d639781UL, HashLow: 0xbf66d81fc14edacaUL, Seed: 0x00000000000022f4L, + Ascii: "UyI3ZMRVJ6IdKKyaO0hTImJM80Z3w66JktmiQ4YOAxEaSzoRibkmoZHAX2LyupgOWmoTol8ZXffaghlN1D967JKQlnZW1KzxzrbXBW13b6LiBQbCtC45hHBzhBHNJH96egKqH6"); + yield return (HashHigh: 0xc9de4b6024f681abUL, HashLow: 0x850126bea5d5eea0UL, Seed: 0x0000000000001a3eL, + Ascii: "B0yiozgg7CMWHU3rQc8u87BRSB77mmFfo5dRJfnPLU1hCdrZtfFptYIlBv5mcDJRXfJ7YxnpSq6reI6oWnJoSi8kHIFOyiqePaS9auXA2KkD5XZMHVRae72F0fPdIXRAh6qmAc"); + yield return (HashHigh: 0xaaa039846de9d858UL, HashLow: 0x342cf78049f79426UL, Seed: 0x0000000000002551L, + Ascii: "rXNLAbMWlaSEJtHZg7KcdKwVhN0tirSYXfSH6LtsZ8X2aBKHLC5KkJCQuTDKJIym3AW4Fy0LqUVbyoPo0EF2xfh8pVwG4h0bSgKCfAIduI8A9D45Fm8WMuV5wd8uR4DomM1Tvf"); + yield return (HashHigh: 0xd16a907209a4656eUL, HashLow: 0x27b1515859939a09UL, Seed: 0x0000000000000000L, + Ascii: "O9SUvMx6NYYU1i9iKK3dVYwU4mOB6tsBAOzlBgv1nObsPf91OVQoYHXLiZTIYELA8uJKhbgcKKGJ7OWqJ5Pf43dkpTQZoi1QpC7OAfGtFuqeiHT87LKnsv6w4YzI8aj0a7pDZ9"); + yield return (HashHigh: 0x2f6a3b729b39fb53UL, HashLow: 0x2aeb1dcf7bf69f09UL, Seed: 0x0000000000000000L, + Ascii: "k9qB2FUXd3TaZuIivj58Wshydm0OfxdJZu6llqoWjEu6et1ObBscfKjQ1axmf69Yu9Xn3n1D5L8fNCuMBWWijGRIk0qLKgnJ0r5MCRIlmPm6nXSYh4ucLASRjENHZwqyWW5K2cI"); + yield return (HashHigh: 0x3f2813e97cb75496UL, HashLow: 0x354a521471755dcbUL, Seed: 0x00000000000000b2L, + Ascii: "Hoi7QDtELUdDFqVnamEQAh3BFz37L2U96Yc9bVQMjHtzpGRiqCS8P4vM5UyCQYPDgaR6xcLfHzpEDwx2NLmEuVqTBXyBRfn2rRPoViuh0yanJpbbugRhXsTkdfUBV7WrVkodMc9"); + yield return (HashHigh: 0x067d0df9cb56eb1aUL, HashLow: 0x174242594750774fUL, Seed: 0x0000000000000ad0L, + Ascii: "HYpEYSzz4djNcmGn816C9VFfbbb5IWjxRxtp1oBSgRymSEOosG2d8UbqsNakdoBuNecS5TXW9XjebX8h0gXNhEmhakMttmLerjQog2Yhf8uPYUqhb5YRnN57pNW3voiA3Gl8hGy"); + yield return (HashHigh: 0x99d0fc8e007d3e10UL, HashLow: 0xe75914d0abf15175UL, Seed: 0x0000000000001cafL, + Ascii: "J0O182AfCRPaOO51XlQaRktTQvkFW8ASaYAmqIuz7tjQ1ViWtk1NAuUQwTL0k51Ph9YmTj7nF6MPoBnryzfTUN9OCbcYCKUm98cBvjhJXZOPTJt4h3fCkSJ1EClyMAwVyQRRoZY"); + yield return (HashHigh: 0xe91262705d24d791UL, HashLow: 0xd4a950023a53258eUL, Seed: 0x0000000000000bbeL, + Ascii: "OdsE4rVr8LKy8AXhYgzQYwIU7F70FGaFY3SZwNYnkgQW2iW9d220JUIiYTfkG3MWdzfBsdTAggmH8yZwAyKaF3Zl5gLHm8ajax9s0twPFEcHgrGpTQmtqdXtetop1vEE1ysDxm9x"); + yield return (HashHigh: 0x44386292653ce4a0UL, HashLow: 0xa1e9f5dc1bf89cf4UL, Seed: 0x0000000000000000L, + Ascii: "83rTxhOPcDzcCyO5EoZkbc0NErhb4mWZ1NC98aK1AbC5bisvsmDfQQAWAmHCkb76jwFRTKuorGmugdrUyO9VMLMpIn6XY2V9Rr7VY3kShTTd2QpUgJxcigy3AAZ6uaXt2cNT1gcH"); + yield return (HashHigh: 0x8152a2ea2ec5c72aUL, HashLow: 0x6c7a47ec036d6667UL, Seed: 0x0000000000000000L, + Ascii: "0bvwRn5eaAx7Yd4fv9ZAw1IuwIpO9eQescxy3S784602dan9jmjKfqRwTiYF6vhkGjN3w0JPlxlyiyrY4julxexONinlGVLqsH92m5e3wxXEPMjmlozY5Ru7ecuZn1TWTBgipcGm"); + yield return (HashHigh: 0xcf6eae1abf46fef9UL, HashLow: 0x0a102546f3cfae9cUL, Seed: 0x0000000000000000L, + Ascii: "Zj8ZXsJcjfcOKSvGAu53hSYTLXBxgAft3WIWmhYGti15rzRDaXmWYIwsgZxTdGQX4nktfzfP02kb6s0FxnAJCWN9pLRwZicDjHhrur3trefUjRROE3HQ5tI6ALMXiz5PHXjjC3W8"); + yield return (HashHigh: 0x90bc03d216103cd0UL, HashLow: 0x17d577f06417ea21UL, Seed: 0x0000000000002089L, + Ascii: "nqlcFmZYVA2UnbzyUj25rR20uy9XRUYMIn25uF8ld2HkKHrzTZpHwVuLcieb8bTsIRMBTyZ0D7uDLf1JCde2GN2QAcX7aKMMyPakmaRKnRGMzVVEvwc2edrvLmty79vGMu2jAZFtE"); + yield return (HashHigh: 0x73369139f9a72bb4UL, HashLow: 0x49f9f84e61878049UL, Seed: 0x0000000000002118L, + Ascii: "50eWLaSIzVFSAE1y2jxPu4pXhbUn5fbrZ2ISzjeWXClpH7pYI3fbYbZ2fWLkKt4LbAUtQ91o0B3oJGAQdIXlvcB0zao8KNRcThuSfT135gRNdukfDjmpINltxRSafuoxDRHIgKfS5"); + yield return (HashHigh: 0xb693956317161676UL, HashLow: 0xb3d9ae214bae6196UL, Seed: 0x0000000000001fd2L, + Ascii: "XAdZWNfdjveSGCbiQoUzRIVRpTRw38a4si2uK1ujrUi8x9XOLgn0EIMDdTTnPYGyT6YCID6jjIiuaj1ljvEG1POgWmcTXpISyIU7fv5deBztXiicZDbL61NcH6ktStaLByZI9MDCW"); + yield return (HashHigh: 0x82aa3ed78dd761f3UL, HashLow: 0xcf9561e21705fbf6UL, Seed: 0x0000000000000000L, + Ascii: "QHuDIZ23SZ00UrLu1Augid9QqPRPW3YF2yNX2Jb1bWwmRJnaGnD8W36z2g2u7EeU0oynrKLT1S6zAL1v9MgqbdfDOdPJpABxGz5UIXkf5YJCbMLD8u7ifiFipSTmkw2cqhBnBcbSP"); + yield return (HashHigh: 0x46327ab1e629dea9UL, HashLow: 0xbab6c5cc7b4463f7UL, Seed: 0x000000000000065aL, + Ascii: "vTJfi86OzxCEBZIgdnuoNwRsN5myyrktrH6CmxCNnqidWYYqIqOTrWPT8A8vXkqExoex7mJu7xfvG8FIHLVExk8pmqsD9CWx7jOvQm9OS3wsoIAeOyRrQ3zeRBKKLbXwgw5Sv6O8EK"); + yield return (HashHigh: 0xf19335ff25be68b8UL, HashLow: 0x60c586415e0ea0b9UL, Seed: 0x00000000000025c9L, + Ascii: "aeR4Ikfbab1jcP3xOZKbQncSKqTteyRRI47ndwQ2lAVlKXe6T9qrjQMTOMNHl5Z2TpVexHZfxk3TGOmK6c08EmCk2KhJ7Hbk6MR4pzvfGh0jba7cKKQ4FjzFKUgoGkTLEIUCpjRRDZ"); + yield return (HashHigh: 0xc234cc07f4771acbUL, HashLow: 0x7e1275a17b505a4cUL, Seed: 0x1b913e9ede6d5cc2L, + Ascii: "7Y8uKD0vmUdO5BNaHvDCBZfJv47KNbDIRWnmPgGYUh50RzTkEqoe1eBr9vauaV16bvZcusbjs5ruqQ5xQDNIEU1UG4Nu2BTA2e9D8TxrtXH6zjDxiRTtY6K2bHhWG0xKA634jTqxvr"); + yield return (HashHigh: 0xcf396d47d97e68e8UL, HashLow: 0x387603d6583b9770UL, Seed: 0x0000000000002128L, + Ascii: "FS4Q7RAFeTyOz5nyYF9WRtUsrhKcslqBwdSIowySyxNxIeJRd2PIiDKGF2MUGOvoHx4FpA44kcxRJeVzfjUOjKDR8OiUjGZlVpFBYrCB6OTDPnuGhFkba0innKsQF5ZgjEvlX49EJI"); + yield return (HashHigh: 0x46d0e82fcee7e71fUL, HashLow: 0x2fef91b105aefadeUL, Seed: 0x57fb342f893572acL, + Ascii: "LABT9OF4MVWIPO2nxE6RYLjq5svbYkH9KLUDI8kpKb6CItxG73SCMAPRSk64Geyc8tHDMjwkWkyNiT8idQ82r8nL7It228YlhePGw8jkuxChsnNFmsDGDgy7xAjMgO04XrEhPBjpAdy"); + yield return (HashHigh: 0x149f3ed8949b442eUL, HashLow: 0x4b9d564fa69a10d8UL, Seed: 0x0000000000000236L, + Ascii: "oYxflnPgurDiUW6nnQnZGDzw3CC3WUNWlhLbHgpZJm76oTBJlqTUrcMomp5MAfjTaUTlREu8DUL2wjtl4gp0ZlZ0sRHEEAqFTgZOyKe90kZ1NIIzCRQO0QTaTMNaP7bipyIA7Yz8cv1"); + yield return (HashHigh: 0x906858abaa97f581UL, HashLow: 0x160d1edfcfd5f284UL, Seed: 0x5aeb29b2d48b91eaL, + Ascii: "i08q4MC0QpQ92tpeqTUgtf0V4NMrgf6Ui6XryC2zNrNSuQN6edxj9d74OnnwiZO5cZCLwAKKz3Mupafzka1DxhoCD5huf1OV63JlJogojViYyXKo0CPPKbjGCOw84rHRaG4x77QNHOU"); + yield return (HashHigh: 0x56ea46ab0c2269feUL, HashLow: 0x386f78c4ccb8e3abUL, Seed: 0x0000000000001bd1L, + Ascii: "0c8W21X9nZ6HEZBDWIPFCvaCKLR0ExjIsMprL61MqO4GLJ4DSxcA5IhNKRgIHS33BCVWMISftY9fImhGe6wduMTEKXSHITqMx94CKxuFDm8psPe2qdA317K52dMZYPQcGWIMI9ZQur2"); + yield return (HashHigh: 0xf6ed7ea3379ce478UL, HashLow: 0xe98892fd4a45e93eUL, Seed: 0x000000000000219eL, + Ascii: "RQncXAONa98LllMBK9qAt9ms19zNIVMrJrVcuOhcokwFmyMF0geyJeUZkVMmhbzbzujQPC4kNcwN1Vdt70KzagMvhIT7wSOHBMu1NUGIaBZXqxyE0EDaocrK44y2uOxkHz3bbFbFWyLy"); + yield return (HashHigh: 0x7a7ec28247cf1fd5UL, HashLow: 0x47841f890808095aUL, Seed: 0x76c7dd87ed6bae92L, + Ascii: "koRmL1gHtX7WUX86WV2fnTtWrlLUw2KrMkTcsCtpiacCPsSqnPMlP8e3IB6LZf2AGSRYJ30GrfwdM03KPCnsDwGxd6xkIGAeiQhbQl3zqk1NhebSmfAdBi67SVOyWBD1HknGEd80zPtN"); + yield return (HashHigh: 0x9d9adab41cb135b2UL, HashLow: 0xabaa9832ec798cc5UL, Seed: 0x0000000000000000L, + Ascii: "6U3RW7QvEd28xpKj5AXhaxt9SzNlaAfen6667b9wnCig729J3UnOKoYaSRi2f14aXDEQpYTgdsXE7zBm0yKb0QfpbSX0n1TLlFFnTU32ebIUmdWFQDX9i8k8r3PMBY4SXsmByI5xnP2Q"); + yield return (HashHigh: 0xdd6880902f07c83cUL, HashLow: 0xbfcb95237c2ffa17UL, Seed: 0x1b03d5aeaa9f87dfL, + Ascii: "cJz36xeOEDL4lWkNyVDoVB3xg8W4rbZ6pgnDpecDuUQhsy0GwIufGOz2g5QkMhoMyv4wjkSOI1h6TmnD6840w54weVTGJJAto3j4lY2KcyNiftl5NKVVh3bpLeHUlTSTs0vUYELw0t1a"); + yield return (HashHigh: 0x57bfb494f96671c3UL, HashLow: 0x8fed4887f4f2d7e9UL, Seed: 0x0000000000001122L, + Ascii: "LRr0gGIKPbSYSzJ6dkhAawEUcaexhjB3mRmOdqleUevzPNqBJaaXnhh0D9tnvwaKYLnbK7IYfElrPVlvIbbZK5yPtHfMxkmis1yfBmiu7xml6sNmZt5CisV1RjEl9gjj1Vx9zhsh66pNT"); + yield return (HashHigh: 0x7a1d6a7a5c8bf46cUL, HashLow: 0x8d9be3b69e03f6f2UL, Seed: 0x000000000000266bL, + Ascii: "INqvwfmkN70mrx1CLzDvgyLMaIDeqAt3rKqLp9j0dKfPfyUenN0fHVC7axbd85i9CRcuN81ENMlTlA4pdM1Z0EJBEi11drzCAr1Qaw2CMQhvJCmft35NVMoBfn6dBnx9RZP2zqdW1ZK8r"); + yield return (HashHigh: 0x4fc45455b9cb6222UL, HashLow: 0x37b4072ce231f1a6UL, Seed: 0x0000000000001827L, + Ascii: "ueBA0AtMdwP2kkOh9BHBYJnFQ8UjWieCTRMmkRbNVM0Cs8wpAWEKF8U5w35K09tyHkvH8SAAYiOJbJxDbf6mKWmT34WWpon65Ps0wSj0fc3hb7ArItHHh0yEV0orcwXTvCCSBgIUf9WPF"); + yield return (HashHigh: 0xe73461416c2c1ff8UL, HashLow: 0xfdc320a6041fbee7UL, Seed: 0x0000000000001e98L, + Ascii: "XrQz5QVeOXyGV4REu5ZBI1qeHiYFoZYnzaL9c9HBlXiMSJISAc0Ix0X6K2AdfbvaeHlI79HBT4OGDtSG3gUntptaPELq3rhiQeIPQKZnHlDVtQMTdMqEwv190P5NvbTnq9MiNd4V2OtkE"); + yield return (HashHigh: 0x9ecbfc7c98fde54eUL, HashLow: 0xbf0a0003d6615773UL, Seed: 0x0f8be7479eb05133L, + Ascii: "YCeS8ejYuPJYOsEsvse6xfCKgZ4rDBIfCsEuThLeS1vRxNabzC5WGEMrWt96EYwGvWtStxbEcqeuzDjco3iieSt23euOIHodAkLeH6fYaEdJ9wg1c3kaxjBy76xcUUvUgQdNeyIgixjJBb"); + yield return (HashHigh: 0xa5d69dbb3136ba43UL, HashLow: 0x8965623726f1cd76UL, Seed: 0x0000000000000000L, + Ascii: "NZRIvp7eLAe9SoC5Furbk3IWXNR4GrOA8smVblKjNBj62ArLuReMOOiXQkRn964AnCNcYAJl2eKXuVCmYchYUN31we4dCcTqNXSZr6Yq4hCgKY4Uj8WeboayZ95mwAaChaLFlAlLP38DvH"); + yield return (HashHigh: 0xe19268c0094ee61dUL, HashLow: 0x60eab39cb1c5fd27UL, Seed: 0x0000000000000000L, + Ascii: "bnbwbxBNUrVu2O9WdVObgmXRNk91ddPOcrfjgUpP2Qhg8ug3W63Kd0Gs0nc30h4kcjI8wtRYhlmsDKLdLRrCHtPnrlNOttBIcL3tls5kzgoHriyk1TyIcb6Z3z9OdNokTghPnqp5bTfigN"); + yield return (HashHigh: 0x57c68037d704a5fdUL, HashLow: 0xb8daaa7c4abbf90bUL, Seed: 0x0000000000000d05L, + Ascii: "tzlNV7L4NVKgZpn6e6Aq8BqTNug8x1ryUYqTG3TadfPFmYboOPqgUIY0NJNMgqdxRUaUe2U2kaVHMuddKztIeX2gU7qEeb9XRFxeHZAVaIZ6lYLUXv1gzYDmw9trFYenp5EnyOzvutTdYN"); + yield return (HashHigh: 0x88edaa2398e168c7UL, HashLow: 0x0a5e54cbd8db37ceUL, Seed: 0x00000000000014d3L, + Ascii: "ZGwLelMo5hB8lZAJEImVcUlqaSuWYvHq1XBIAagwJ2Mq0hM5bbj7r9yyDj8m1dRQeGch2Sv7gZNWKghhbOLckJ07kEF2YPR8gwp3PgNXE0dNMUEiin7725FcnSTY2bOuRO3arZTjwLjwsaG"); + yield return (HashHigh: 0x7f7412573832229cUL, HashLow: 0x61cf242bf6beae2bUL, Seed: 0x0000000000001cd8L, + Ascii: "2vECEMJDes34YpXzV1BUUYtVPPcd92N7tg88CUw1oMj5W4eiZIQ6cXi1tQos5T1kLpH2oixJSeSqLu5h8LxganABgUzFPYOjIWL9uOEuDfUMsgktgQ4bU0cHw2nC8hFlCZDxqtnnhTrQjVR"); + yield return (HashHigh: 0x8e74db8449204145UL, HashLow: 0xb5bd0e09129ef0c2UL, Seed: 0x7661f00871943a00L, + Ascii: "4kNidsgh1ULYzj0rbKMjQMCimtXWVjt18nxVpMP4F9KxA59c3nniCIXKbCvq5HXeqxE59L9W8uHEBBhHX1ahTR3p9LEnCXtPM4m8WWNW542LJTQFCtyZ5IR1kqB75Wdehw3ZYdYTci9AUvz"); + yield return (HashHigh: 0x5c69c4ee5489a887UL, HashLow: 0xe2aefd1975236a58UL, Seed: 0x0000000000000000L, + Ascii: "xSnYEnPY0DFcZXjabmJZZv11XR63GM6Ukf9aPmjQxRwmlOED837tCB521Tv6zNowcu7aRCx3u6FkE0tHF5jbHIzUD6cJTMwKLnhjSQ89qwNLmNQUdCd3BMnmShmoQ14dj7Xxo8nE3pvQQMV"); + yield return (HashHigh: 0x9e8802a2cb965361UL, HashLow: 0x7c75e321588b4f32UL, Seed: 0x0000000000001608L, + Ascii: "16TEUrYwuNZN7nXydHKcqgL7J8NXZCHc5AHRNtTYEB0wXHtkOWORDf0TRUuOSqj9orOgHyr7VETWFWcy11fChAROkyXXpYe7RkBbhERdMBmdaSMRSLpvZ4HkiX3d1F2iwGTBKipzpy5J4qmB"); + yield return (HashHigh: 0x9b443d5544cef0ceUL, HashLow: 0xb73ad12fa092570dUL, Seed: 0x0000000000001b7aL, + Ascii: "nGVDgcQ6ZW8W2bokBryEg8Z3m7grx6B6s7iSXcnHNuEpp3fd9vKnt697JFlrV5JFLc8cZ83bSJWm4Xn4T1OfEzKl6cXg43qFJgYY410R7yxKX5r8XClgz3ZyyzrSqxiVjk12sZA85vFXm5EE"); + yield return (HashHigh: 0xb59a299a00349adeUL, HashLow: 0x8f68ef6ec9a8e219UL, Seed: 0x0000000000001471L, + Ascii: "uW1clwZEqFxakgn0ExK0TYbfjv4FCVpWP65T2wy0eA7iS50iztHqIYuTOsoPpcYIVunRjBOcMG3OfFY94uWDqHxwGwzssHzCO61MtCLBvTxIZ8J410bL1YgRNoLgZKEdIC93Hb6YvTSP3Adj"); + yield return (HashHigh: 0x039806bab62ebf00UL, HashLow: 0x069841c8a7277c82UL, Seed: 0x0000000000001550L, + Ascii: "QBkETJmofm4YRD3TQddoKvpyjzm3LMjsCkOoIBlbr6yzDBe0xT8PE2Hx4cHPub6P3O4oAv5sqGH79yHxJPyugMpmczKCKtFR4nbBWklfgQzZDoNv2i6816YDIAjKWjjpKtAMCrKTVmw0xkFO"); + yield return (HashHigh: 0xd46fd39001c8dffcUL, HashLow: 0x699a5a5c7b0e8e5fUL, Seed: 0x0000000000000000L, + Ascii: "h7vxY18IBFufeMfQEF0uvNH441g0xOK3jfM7J6R3pTgiYmzyX8rp6LGUvUMCNZzi6AefpdtWcHn1SX7E036pJZFRSemmpaBhUoQbBm5hA8g0DEx8NFcPNJ1ur5AaywSC0DTTteFXG6tBmkzmw"); + yield return (HashHigh: 0x8f690e7c0d292b38UL, HashLow: 0xe6e76c1b01005b68UL, Seed: 0x0000000000001455L, + Ascii: "XM5roMXpfUT6yezGaKFFvx2CWI28KXu0jfWo3VKvIoB62dd9cOMt7DHs5xSxWjwYjkqKBnOZMExbv28liPpEQ8stFg2cMy3o0fQIFnt8poRKfmvCrREGuq71m63FTa2rQmGJUyTK1UAuUlTEe"); + yield return (HashHigh: 0xbbce0106605b3a5cUL, HashLow: 0xdfadec21f7e67cb9UL, Seed: 0x000000000000248dL, + Ascii: "MkD2kzabFivfDIm1DUFFVje69UYx4KP7zb4gM9dDlT4vTDX9Boo7YloTU2Lm402XU84QenglLDDyCF00z0D27lteqzYRmXkH1CbmdFRoAamtW4wILybXYQeYGGKXivPFpzkfPsWhzz9j4wnhP"); + yield return (HashHigh: 0x742b6275ee7ed929UL, HashLow: 0x43651530f20e227aUL, Seed: 0x0000000000000000L, + Ascii: "lZh19faRQKjevEwNpVH02ADNfnLL6hceJP5yPxo5Bkd8irhjrRa227eaMlfrqwsAF1GsmH9tSDQJRGi7CGA0icgHUlcogKoYHIiglBHwLFNY74bbY8anenvnp88VfZsORihIwh3Ip8lhfLssf"); + yield return (HashHigh: 0xae4c5f19ea44abedUL, HashLow: 0x0dbf7f3cb87e4e5eUL, Seed: 0x5053e8563b8e105bL, + Ascii: "mji9X45Kg2ieBWzBIJgKlAVI5xu3jNoLaFju9cRpNZs59VUvR3bxxBbb6AUMUFgDm6uXJY07m76VMUhGjuNQfJL1Rek2WarSzKIf8ZXnKVOHAoEgoOV04W6rBBsRoKCaMaXyUy2HAF078IYhWz"); + yield return (HashHigh: 0x6b80d81c159424e6UL, HashLow: 0x6d467762269203b1UL, Seed: 0x0000000000001c68L, + Ascii: "QhdEgUvMnNhbiiKccrmrE11Xrrp2HiPhTIKyFWJb51zUEWc7Hwszj3KH7tbvuVcaPsrfogRgsXeO3GlBkZ6iXqRccHPVdSZcKZWHjS2nrgwbzZXKuxvb3st2xZuRctBTbKeRWlmyApmwyhZNXE"); + yield return (HashHigh: 0xabb8300c450b606fUL, HashLow: 0xfac2e60a8daa2723UL, Seed: 0x0000000000000000L, + Ascii: "C6NSXfV5l88vvycmtINmb3FQ9DqTA7stdWvF1ZGmZzn8IOT9PkLRYwu29xBGz3u64DtOqhcWs29TWacrLo3htPrg9GobyClvNHHEq0o0OAmihp8K45cJb3tdeiXTZIY1Czrcpj0VABvZn6mkGO"); + yield return (HashHigh: 0x15dbac54c2a75015UL, HashLow: 0xef99ba1251b78649UL, Seed: 0x0000000000001718L, + Ascii: "kbeaxNxCAOMaJZG4ndPplTGKwdw2UIukSbkSuWxFyFnVp5rfUw7RMAfIjgsE1lFaigGI3ALU5gyTXEMo0xlzFz74GZ7PzraAIyEHpW4yMeltmndUlnj21LBiXRWTCkriVH2uNupXBS2XC43OmR"); + yield return (HashHigh: 0xabe2973c92d0f517UL, HashLow: 0x280c5be1560f7c1dUL, Seed: 0x00000000000002aaL, + Ascii: "lRDPYl0Iv939jZw9iglpNKD9uNKxoK26xOG3XmFMAOPKSl6a2ZHc4NCFVHP4jCxwVXskI3buxPZr3yFXt8oqCaA7gZxKCgREcIDoUJEMiIq50OQoIfCr3okNQPDM7zzg5cqZRQhn520ghcYTiAk"); + yield return (HashHigh: 0xeb3faf63d11ab3aaUL, HashLow: 0xe1c8e373561c33c0UL, Seed: 0x6cafbbc0d4d9d448L, + Ascii: "2SE1OL9I2HXxFeZ9cwpG1bvHORfMYzlHqH4O2DMqPiDBQNssznaruH0lD5ggyyixdtdr0LIUyOdywEFJbtsdpRZloOJHNyGvRZ13AKfbnp1d0cI4OBDSEtljyVPKwYff7bT1UMD5Qb7GSCHD8yy"); + yield return (HashHigh: 0xfe2d9aea8ed87e2eUL, HashLow: 0xa90547857addba86UL, Seed: 0x0000000000001d92L, + Ascii: "VrmLgJssGQMypADPBHCcZzfAf02WEAVfmDdX3ROFbBxUKu57jQEaPDv6yF1yuZrUM1GmrwWj7jpZfF5xPbVBD8G6HBKjhXj7lZuzEfn1HTFzWvvhRCm4lsO16zhYIYt2kdDguWTBUTxz8jE5ciW"); + yield return (HashHigh: 0x2e1410ae61645e3aUL, HashLow: 0x239d49e758cf2e6eUL, Seed: 0x0000000000000483L, + Ascii: "YqLOaCkvunkE6MNqJpIbwvfcQhkUGG6JEewerE7rHH6797Ln4KzEelspi45h4SmHAjdNDNcM3Cvm0F6AbNhnhqtBFdFaby7GEPeeQaWMqAQ8Q0ig1BN1juCwfflybwbLaA8Jokd9ZXVwA2W3SKw"); + yield return (HashHigh: 0xd7dac2de6f2eb1f4UL, HashLow: 0x1ce3d2d5b5fee8bdUL, Seed: 0x000000000000015dL, + Ascii: "wdwPvtZuwFk2xZz5ILImhDQoCQzoWDgkUnWLJiqAg2UHh171FoHHRZHVuFPAAUBeBC7g0rTzFtEbvPjmAuph55JHMPJ66PzXSg6oKj1GE6l2sM4v41TV1S17c3rOr36P0VXDpzJrDqNjYefaDcrD"); + yield return (HashHigh: 0x7952d8ec83229e0eUL, HashLow: 0x2a0523aad50caeceUL, Seed: 0x0000000000000000L, + Ascii: "Ca21pwuAz4ChrAWVQCQaGiGufxKTd2Juom4dcuPa7vML1kzz87lAQ4Sr4Pspv09YfvAyPzKltoBE2VxxvkkDgrRQxJ9NhGoZbFj9yVyMvpMSsqgGHVCsUuWhROOQJt6Lw9PcL45lHWCcheDrQejt"); + yield return (HashHigh: 0x66ca0eb368070887UL, HashLow: 0x44474726bbcb0ff4UL, Seed: 0x000000000000150bL, + Ascii: "KnSIM1z4E2EkYDzGqSxyMxy8kkxwQbdCYOloyzm2pKQ7wjDs6znbxIbeXx5T5jFaPv6D0rwbywt7RBaAd094bSl82if1n3bea8tTzKaWHrHyztPRvdIOyjYmJUwLXEAFTnsIfU4w7tkD6wP7hrgP"); + yield return (HashHigh: 0xca7f96ac9bf04d6eUL, HashLow: 0x8190fd1bfdcc3ffeUL, Seed: 0x00000000000003d6L, + Ascii: "YlEO2h05Ro9uZTDjpeVVHBcBYTyrarAQyNaUboQ2F48CmEFhcd78JPfhMD8IPgSDBR6gZzwTnd0AEIpWOhFyHxQTWT95EtRbky7XPXq74npH9zDWUO5Oa5wwOZXLRNTNwDuZARcmmf1kJEgNTnpH"); + yield return (HashHigh: 0xb6ac087a0d45e20dUL, HashLow: 0xc54c9518bb3d0a6dUL, Seed: 0x0000000000000ffbL, + Ascii: "RiWtMv91x0z3MJi9YfUq8rJcpeBCwIMyaCMGjuaunyQRUMg7f2ySvTu8wIpg50dpyUWCBskBErrOSFveIvWoVfV1085dXHrG7nUEwl8IrMKendmmfz1yhJ6akVYk5cFoQam96fzyvsQD8BB6GimHE"); + yield return (HashHigh: 0x628aba5d463f809cUL, HashLow: 0x21cd0e6bf33a336cUL, Seed: 0x00000000000011f1L, + Ascii: "mnv36rJDzm1Zochb46MhGXcLeDZbKSZ5WK1jSa8i4IluVBGOgfAJHSF2AS7YHZANxDCLJVVloSLxeVL0PGrrwQxmdIXNYbTuRT2xUmAg74oJh832LD6D6IfO3J5DEsmDc1B99aIGMpgatVj6z8hIW"); + yield return (HashHigh: 0xb62eff46e66790caUL, HashLow: 0x3adfedcfdd201812UL, Seed: 0x0000000000001a75L, + Ascii: "31nAhSK6lKwLUMflSqSxLBWCfoRlfKPDWo9XTOOFnwdFoPPsrkYXXFpE5toYNUzmEFZ0xC5KeYBIa9xeVJ8w0nGi6ISL8PDhl8mBeaaHn68WvOr5SsdMP5l5IDmaxsftmmBs37NtG0fHuh6ICifl5"); + yield return (HashHigh: 0x6803ee2e26725c30UL, HashLow: 0xe43ecf314a3a82d3UL, Seed: 0x0000000000000d44L, + Ascii: "ANpgMiMNheGfrkOHwYj27tY1XBzItUDmuyCRjfuazR702hViGWK89PD0QxDdWJDxgvY2UY9IjluyUiHpMBoycE0d4nS88MUwF2vov0gjvJ4LJ1cUfCYvptYhPQHVyfpRxXZ24yJNnbjmbrb3EMFXa"); + yield return (HashHigh: 0x7f8cc78f768070faUL, HashLow: 0xe2397c15cc54e954UL, Seed: 0x00000000000017caL, + Ascii: "P86XZCtYQO4z23K3Os2V1deOCsWdEEJI2APQ83oDSn51Na4hioDJzhkVK51cIPJC71l0tTcWx9uZmdOzOCni8x79irZUZXaJokHlEf2rloZ0TehEIH7wObIuH09lIkQocRRBJR5M6PSYVAoU7MiFPQ"); + yield return (HashHigh: 0x0e76a187aac9fac9UL, HashLow: 0xca0fc091795e03a9UL, Seed: 0x0000000000000000L, + Ascii: "506lXaeVt1PN957la0rgUiKtGxB4Ki2hqgTK832nY1vtUkXcdwQVvWIaDrn28WvMUAR8AoZcxIxcYsNfT1iXgNohzJbDSSnkNTCj6rAgsZOWxpsPJiUlbEJNZi5gsZBGt5UMb3XuHAXf6cKIhk2izS"); + yield return (HashHigh: 0x4acf974a7bfe9a5fUL, HashLow: 0x7f7f0b179b5df850UL, Seed: 0x74422383d0621306L, + Ascii: "5RR4CrqvBsonK7drBXlhL1VUQxm6cX4UKtYg8zZOW9pRFaJCM2BjEBAjN5NGBNUq3UVyHF5XQOtU88ZkpMwoAkrekG4UlpOdm4DmB6P1UVpSCuAcAJNO3HSkYyG4jMnxLrWZsoN54ZSm3ZC7Fd7b9q"); + yield return (HashHigh: 0xa2554fd13f900ddbUL, HashLow: 0xfbbc4658bb118caeUL, Seed: 0x00000000000020d3L, + Ascii: "Zca6ISTkVdarTdiYoiCtulPQhB4szxFmw7GGTptQqyCEdDxaCdTTwHoHRncshyTHadwJC5Xpnmx6HHVedezqatsCtOGGq0rvk4umVLdvqgNcJsjx2EVbK9xIWgWIoxIYFqh4HbROxI958uXMBP4KEw"); + yield return (HashHigh: 0x0f2680af7a218693UL, HashLow: 0x717537706f0ea759UL, Seed: 0x00000000000025a8L, + Ascii: "7CwoN6n1mk3yjMN70v2BIbDP0DxSxSrmEkAh26csqE5MIdD0bDQ8CHVF1t8MlQENE9Usv77bCm23GGSJO1zwWBwMfw77H9jONyFhh9IxyTkiFDiPyJZHPAFAI7Khh5BWeS69XSROUDkCYEr2w3wMD7J"); + yield return (HashHigh: 0x910b6eaf09d691c4UL, HashLow: 0x3702983700355d54UL, Seed: 0x0000000000001e3fL, + Ascii: "mWYT7sChygmozGjDYHiRHOKCIZ5MpMOINswQw5rMn7aNT927s43Fu1VbDFCI65WuzfJFQdH5T3B5V5azx7iewhxIEAyxQ8LMkyIfwgrGaN968Eo3lQ85LWk3dP5vcYsD6e6WuCpxVQ9ehN1oNyGBUFh"); + yield return (HashHigh: 0xe865d9d3c9509fdeUL, HashLow: 0x0a13d1d4770b26b1UL, Seed: 0x1eadf009cbf8ac7dL, + Ascii: "FVIs5vdoGlQH8mO7gwIr6dzuitt7tCLlto3j9ISwyo2ccMZVwfFgpmI52ZSzMHxd1jk9gUu0ap2qRVMQoY8EQan7tTGO0UJeYChSsgLmsA6N19adBoUG0Jl2aLuAUpJOxkUwWtnqBweYzskBihqeeeK"); + yield return (HashHigh: 0x035bd324b14e0973UL, HashLow: 0x64f04e9ebacb5cf8UL, Seed: 0x0000000000000286L, + Ascii: "9r7sdylVeJ6UPrid18hQRVGKD9aHkJg0MgrpFQBiJL1LyS7GKbg53W3dpFpZX4VKDtqVU22QdAtuhkBRG0ARJ2CvJcvhG85kiS3xRiOjtRr1LyBAhmP0Sc7qDxZGVRz4c8xX2Uxqk6lKugvHSDqm1rD"); + yield return (HashHigh: 0xdc81ff3582298a62UL, HashLow: 0xb47d5072f96dba1dUL, Seed: 0x000000000000248aL, + Ascii: "f1CzSvUf7nMOhfG0aLlFfETuxIA8g2DHzWv48KA1gg9up1gdB4IpWMwOBlon2i0iAma3p9t4otplwQqGkcdwLKI1CBu0PZhNDihtsBTnvsIXM3CnA8XGZ352FYJ4aMyRVMFFse5fAOXwM1Zw6u7yhyKE"); + yield return (HashHigh: 0x5f87bcb4478ba699UL, HashLow: 0xb3d241c78d5d87e3UL, Seed: 0x0000000000000065L, + Ascii: "zZKL0OlySsRishB74cl4RGBN2d9OWsFhWNZWdeFUisBNX2UwuLWHR784AKOeIDSxMkvN5AthRuxjClrO76vQl8OBozvGWUMKeSqlLNR9vywn8orNrBp354Edxc9ByHPT2toJUniK6ZJBy0MibcxrQ7CG"); + yield return (HashHigh: 0x18e6db40e10ad21dUL, HashLow: 0x8a5e5811e526a6dcUL, Seed: 0x0000000000000000L, + Ascii: "0cMGeRh3IXvLixGzdMVb9xBGjA6kEu4IamxKrYBh4e66zsoCJKZqorkk70vMXiiU8HDAZ3L0hQafI8AXRGUt52gIFbx52etqU36ye7ZZA05WwURAxSfohBVJR4CyHgAwtvZPnAIQTYqUVabcuvpVMNlO"); + yield return (HashHigh: 0x3ff386d2dbd478e5UL, HashLow: 0x53f2dd2465dc929eUL, Seed: 0x575d01e52051c5cdL, + Ascii: "RASyAErgK2cfd8LnRO5t0PyCVNbsfcru6yQkeyNQ3MWQ3T48eMowT4HFcE2ZppMsBXZm1e29iIsPpIzcOM9ZWEf5GVOlO5Xjyb1yuzHVtgPXEKbAvJJGjeuKpNtIriONajKOn1TdWUnT2jcoQpexBmUD"); + yield return (HashHigh: 0xb9916b8decc426f3UL, HashLow: 0x440287edfb38796eUL, Seed: 0x00000000000023a3L, + Ascii: "63iWiybDwerjql22wHy5iLaIkJA6yU4pbimzlndJqI3pHt1RoVud6cmtgxc1V2Lzg77Ij2ozFJ4OewXmcLus9dVxiD1nn8iHtl73mce7FD6rzJhZAm7LYfqn3W6u3dwnZl1JYHSeHtwrhZBRLhVbDYp7O"); + yield return (HashHigh: 0x75ceaf3cbe571522UL, HashLow: 0x015cbb373398be1cUL, Seed: 0x0000000000000014L, + Ascii: "ACkIGaxRIZMiLn6IKDnj2TQKLxoO9FFCkpwHqiBjTEP5HlIzbJxfwfU2iRFT83QNJg7JsrFNb6euxR3Q3AhRgNLblJD7A74H7Dr31dqs0FujW8l9WcizDpfUVpS9A8lsll1uZqZmk83kpxOmt0UyDlnu1"); + yield return (HashHigh: 0xd9b745edef8d46d5UL, HashLow: 0xa159928e9af71958UL, Seed: 0x0000000000001dc5L, + Ascii: "pDWf5Nm5aVeWCKqWj0ZzCuCG41CG3uMD4K7HbVfsyRHBb8PPxlUaZZafBNw5PzReVrZInVGGz7J1B0gHcXBgWi67bFD8JKjGRGUhHrEs1GP18TmFxQYnsugA71HtbNZMTkrQmKEmOEcDUbQVsQOivL5T8"); + yield return (HashHigh: 0x9ae0141c6bd9edb1UL, HashLow: 0xf48bd5b303b935caUL, Seed: 0x00000000000002d3L, + Ascii: "hQ5invCoIPWENdwevPniAqnrcOX59VfELHjdysQntRUyXVEcPrb0jhprmY1MiAbfsYrqsAkjqR3allmcIuRwzub6yBu3H5IFl9Y31ZbbPZ2QLKRlXFurlrRaHjNtiOjNT0YqW6JLixmNBFMw6xAfdPArk"); + yield return (HashHigh: 0xe052b33ac613296cUL, HashLow: 0xc28f3e77fa1d950fUL, Seed: 0x000000000000155dL, + Ascii: "Y4JbTln4lJObiJ7EQRU2CPLoLhwGf2Lk6jJnoUhQrS6nEcn5EbEJiHmaXI3aXr9Bm2STZlA1uaV4AMXeCvtdbHKePn0lPjgII0WX6fOnpYpOGjXjPSt6ad14XlSFI4YwmqLsA9lrYJa5R0bkkAi62E8rMn"); + yield return (HashHigh: 0x6993e62da22fcb52UL, HashLow: 0x468bd1a9f938bcf6UL, Seed: 0x0000000000001102L, + Ascii: "VrD0o8djpXMDKYuKitrNnCC83Q5ijSNlCAuyIql4CHAuBxC8LklWurywYciPmaarWef5zacECokLWd02dKXG2jHRwHFzEkkgjky94CZHJsEUAoIRTvbXSMPZA2880UbkIbQ2Sm5zrXQsoMoGwrQZaKxugm"); + yield return (HashHigh: 0xa2e617fec14cbf83UL, HashLow: 0xe238025be6e76cd1UL, Seed: 0x384c038aecc68846L, + Ascii: "xMEm4HPPaNLsqoqtloLN8ygMjf5O9hbLEVuSG6X61BzNShJWDtRxzRXZ5sKhxASjBmweXMrkoG9s7ri3Lv9CRZ0H74L4HNR8GPQQlX8sqXy1TBAaeRUXkZadZtNwyjXNULCuAsLgfCDjndDr8sGVtL1OBJ"); + yield return (HashHigh: 0x1d60f5062b0eaaf7UL, HashLow: 0xb32e85a98f9bac34UL, Seed: 0x0000000000001c35L, + Ascii: "eHjiuI0JzxZSiHdZetVhEqyWE2AoxnU9W2aUNEehVlwoTlW8ca9Z9IRWc17NE3DEvBormfTJOjwUKXdv6OI1u1nspYUHJ8qY9zJVgFSVf6nQl09sG2TOVHrgspV0WFTgzOGfsvhJoHsRYRgh96BuS1hY0S"); + yield return (HashHigh: 0xd0fb4506107a2b68UL, HashLow: 0x1d3166fed32819b7UL, Seed: 0x0000000000000000L, + Ascii: "yfPiKy0htYoBIT0XWK9OCGJFZ89aknaEG2iTdxMCUl4MBt8u4zTucKtg55gUVGSpqT7Ui8oayu0qJLyeu6YeT9GjEKz7ymcl1nI1jR204GL0Vgi7TAxCraZDGzu9KQE80S1Yzxb1dY07MyZhUL7oyWoXnm4"); + yield return (HashHigh: 0xbe7032384d0f3724UL, HashLow: 0x6818d4ee69d44f9eUL, Seed: 0x00000000000015eeL, + Ascii: "Hb1ulxeUfjEalMMwNcgWGvRKc8U47rPPUOc8dgfbfIEpFOV3NX6IEPGhnzNK6jOiDlssWFdeaL9vLOCWloY0Hx1MPUzNpPx1N7p5Y1d6CtrK97ciOXarxEJz5aFU5v1KqCfC4JdJiomACEOp2MCsnmJz1xg"); + yield return (HashHigh: 0x8d37639a76505f42UL, HashLow: 0xcff4abbbcf63b706UL, Seed: 0x0000000000000cf1L, + Ascii: "m6FxWVVTtTVJgteLjAr1UnxEQoTJiVg8ULaj2L7O91gfbBe5olfO2xwDsLcTpidQmhMyGCtOBr1hVO3Ugnl678jn89UdDu7B06yBTg93y08gD6P671JBkRqgQV3vNN5o76DaandiNfg8QJrwkmidGHHYhaA"); + yield return (HashHigh: 0x42a059387e6ac267UL, HashLow: 0xd9d2eef67e3ccabfUL, Seed: 0x000000000000095cL, + Ascii: "wzLjHXCGSajJWmj95VcIHoLZ9lP4xydL1tJsTsM7hNhD8vTFwvzteCmxBd9QTHul40VzyucnIlZpt7IXE5mbuRNTD8xqdg76uXGzPYCBx8H1Apydw9zOHpRJRhIz89HEsP74ePBYAaETTxwgNLlKApt3zOe"); + yield return (HashHigh: 0x806ba8fa309b06d5UL, HashLow: 0x0a60f6a4e1e98c3fUL, Seed: 0x0000000000000c55L, + Ascii: "u1urrFActQ6OHUkGPZkVZBOKcJGu7WAGe0VU8x61gM4HqUI6Cbdq3WKewjzneNl3zvxZ9qylzwZ6iyaz9DjmfsPBB9VJfKC0XOBFGRHsEghTwFwmdeXs2O78quvRFP0vEXD9rzctYXYPzqvMcNQBs29tWMsA"); + yield return (HashHigh: 0xf386b0b63b3345adUL, HashLow: 0xd25f8cb14232721cUL, Seed: 0x000000000000241fL, + Ascii: "MB19edtYkCHPdZKlQpdLnzpRI0G73IN2djAIZPAnQEgoyQYNaTLJiG3XuoW5Br6nE3TcfzZsOfwIf4iOu5rzts0UjmOQXM2NTOQAfXqsAW6hHzS94BgHfjyOlOjrjR5qGorJxx3eNY24hgKNVH686b6rb6Sa"); + yield return (HashHigh: 0xd6a88e83f520d4bcUL, HashLow: 0xdb5df31e841f366fUL, Seed: 0x0000000000002499L, + Ascii: "MfKVGmZXEkUCm5FWOBPCmQnjgqK40oZsjdZjUfiyVlT51MDRNN1M8Igm46TLUmehoj8FvjMwQBZMZ2f307c4VHq9XJSHrlzleZ2pu2WXkQxlVM8bYKSgX0c0dITSgilVBWYb05uzKdxDXdt05SdI6GoEaFR5"); + yield return (HashHigh: 0xc0a86717adfedfd9UL, HashLow: 0x0e21405a8fcafb86UL, Seed: 0x0000000000000da6L, + Ascii: "ydXxM6vIjrISOJL7dQVQUvuIfjOdyiptXUuWcHgFIQwyhmUGeEdVEIdICVUSzuRlMwatIE9scF85DNJZjksaYGblCeaawoBgDylTFIdlipgQ10BGxVbrpbRGAE2vshvgbLRmyteU7yt0CKOkZDIxdW3QF39G"); + yield return (HashHigh: 0x2036a451068584d0UL, HashLow: 0x10f79f60d94e4455UL, Seed: 0x50cc1ea8563a34c9L, + Ascii: "Tubapz3FQuUbljkXjfqs94japLyuOfNYxMXcwosPdRM8udnzFzivbsa9ovq35KJ7Kqc1fTN83wajhIG01T3JLfGl2hV2R4eoWzgJvTdqzDs6Co9PVHRqPIIycaEUwA7SrxiVvcoHXJm5KITZI3QznRShpZqOL"); + yield return (HashHigh: 0x710b20a1b5ef6239UL, HashLow: 0x8e179eca51c1099aUL, Seed: 0x25ce729810d4079bL, + Ascii: "Vs2XzwmoUIY89K94OPUdTm8JiYJ8QMyf9DseOZDlP4M5nnJEBIzpHyToV5wY3NwOjfscaPTB2mhVgIHvs0O1WtELXX2KyLyP8u0ynBdPWKCQzwl6GAkC1yfx1BYRMr82X9rLDYW4nfObG4XKAhIEZd3MCzEua"); + yield return (HashHigh: 0x167df0d01a3cb63eUL, HashLow: 0x9a9b65ef84871f14UL, Seed: 0x1e01bf58a2995f69L, + Ascii: "3Qw7U87hMFvrz9vXTV3cq6wulh5uZgo0XzyZLMgLNpNeYBeKCXi3GpVuTjSiiXm9hiL7YJ5ZK93V3SsrWhK3CrIXBhm7m69kGBwgxY7aF9idxWcPiCwJru66lI11Ep1gUGdUmyyCqmurzqpv1uE4ZbXITcvRt"); + yield return (HashHigh: 0x5e5e09b08ad55e90UL, HashLow: 0x714381efc5892d5bUL, Seed: 0x0000000000001b7aL, + Ascii: "teilLoRmzlGc5Ebm3B3ArhH6f1sZ2qAyVXyiurRzZ2Sy9yoBrN8SktjjlU2TWHr5NUPC9zz1zX0FW8sk6xobnfSdsdet0JgidHflK4IeQLhWeGJTg04jEei5YiFt6abmfyGvIddICdNtDtN93IZBKou35UYxN"); + yield return (HashHigh: 0xebece3096fdf3523UL, HashLow: 0x992b35c9a8d6e370UL, Seed: 0x23fd58b8d01cf794L, + Ascii: "HMAPg9YS9ggf6OGW8eQzUFvysR7jmGcwAjMltQ8mXMiN0nrCtKqhRaQQyc8WiBZpgLtTsgvBaKfPglRA2HPLNzu28Q6xNG2UEvhdS1qJRYBglRDBItcN1pwjIyCeewM00wTToh03nXXP9xUS2Odv1S4CAzxeKG"); + yield return (HashHigh: 0x0becceaf5fb196f9UL, HashLow: 0x2c82a10629b452a7UL, Seed: 0x00000000000007a7L, + Ascii: "rEcZMF0bj2imyLVxiuOUlM6pMlC6gwo5fWlYNx1UjDb8RyGf2JUrYbvDz9SpUzeJ0EE7e83PSVVtUKPE6wioBQ3DiH3b9nRXD37LstFYriMdcT5omHHZxZvR08yqitrpRIJtTVFFTUAIgoRZxpgJGW8ssAkmY9"); + yield return (HashHigh: 0x7eda0ab5418f5599UL, HashLow: 0x1abcf02977c08ef4UL, Seed: 0x0000000000000607L, + Ascii: "VUAU8d9A9JaJxsMHWm9DSsa3fU0LX1HVe0pGTZoVGcQMrtikk4fAJPUi1Zl9U6Vy5lkkwY94EdxY31VPcKfm94kviQ9a3uelIligqUQ9KtachOw6wm1sCTnJ3dDmZGzbUafyFOe2TgIQf2iORP8BzOPwt4pn87"); + yield return (HashHigh: 0x913992f5431498aaUL, HashLow: 0x55f6b082c3074b3cUL, Seed: 0x3c2902e3451cc760L, + Ascii: "KjchkxMHEzdw2pPGSaSMmmnTtUJmzf0XkICXwpEaC0W8Jsfm0At8azF9hdcoZnYSGD0DXASpWQvLCBQH9bJP17gRsJvH56shCfgTzp7ns9NYYEao2tJj0zIjbQMmMTo5cNEtfQl6xGZENSWwqfXUn6WLd1NM7P"); + yield return (HashHigh: 0xe53ff56ac0850865UL, HashLow: 0xd05a46c85431d126UL, Seed: 0x0000000000000000L, + Ascii: "IiBxrgW2w6mBZzsR6GeF9sB3l7I34uKW95L9NvrwMl85aUozrXwYXHxb6UE6EjasVcMOOFxSkH2gUxWeWb5Frf5HmadebjNQmbe76g8NGqnGpNEOhmwwbH9areTGnF1dzck6cZRbuwAOdBndLxzp8CXqwQtXpmM"); + yield return (HashHigh: 0x77f3acc4a79702d1UL, HashLow: 0x877817e65309e04aUL, Seed: 0x0000000000000000L, + Ascii: "1NceKUaAZTYZ0iecBTH3JkOcsfT71BIsuY0AuyMA2fxlaoe8e26upSR9vGKl97oBMgZKPw5lTPSb5UCemUoGNYqHSVNUmqsRrNezeFXS5L8mnAhfgYa2i1VCoYnRP1wtwYFHdJ7wqZNNmHkxUmqGMuQdJu71axT"); + yield return (HashHigh: 0x0010e3c1c07669aaUL, HashLow: 0x300983f5cfa705cfUL, Seed: 0x6777505caa5b9166L, + Ascii: "lIrKpXvXKWI16oZEvS9Fs7BWiwjrFVDdEW4zVb9gt1WiIodsSfXtqu20Z2WlCdQEsEMKi6aL4IhOtG3u603nRTb86R77S1eiAaOjDTdAxVmCeTzQLGz1LnMtNmyC6n82mOt0dD5qsA76opQZmA1VjnYB4TGuIbu"); + yield return (HashHigh: 0xd00279ab4df8a58cUL, HashLow: 0x776e20f501ef727fUL, Seed: 0x00000000000018acL, + Ascii: "QtxcQDjjVqymMG4ESynWyEtG5J48iGfFg8DYczpwOo6MoeEYwqTtAVOpdCLFhJkiAnaAxvGy3YOJxnoMrk9ubOSWeWAKx0OmuQMtQBuJAtZyWuIYfngKLAfWVcfbbKfz2HJFNbbJILQhjVwvkI05Fr7xnfPMB5e"); + yield return (HashHigh: 0x7191d5e0d74e2b30UL, HashLow: 0x02d407cf0a5dfdd1UL, Seed: 0x1c8c8928397043ebL, + Ascii: "Y7fXUKQipnEtMzOFxH3rZojzw9HUw0pko7wNGm8IqYruxttgBScSAgj6uN9x40EYFq0DNdetX4eqplZRFaayvPlR70XlvX55JQu2ClGpveMdHbh3LDJInlIJbvGzc50jluJ6xWnPThMRK70ifM69obKUh8QEuLMX"); + yield return (HashHigh: 0x31745183c4312c2bUL, HashLow: 0x29fc371ddbbc1270UL, Seed: 0x0000000000000000L, + Ascii: "HzVRodZLoIsR7yjNoOvev7Hx23M4zXYylsuJMgxVPZ2kDdCsyG7JopItDEqZJk1TVHX71xDAvogeOO6fhC9TTZWYm2KtMZCKlYqdDKNvkzXDcHpJcOsDSHxMbkb8BMBZSEzp3PSpk5lbjhsthpKwqCTHyenbTOMB"); + yield return (HashHigh: 0x8347a82729e1d1b1UL, HashLow: 0x047fd580bc62c034UL, Seed: 0x3760d5c09f8db647L, + Ascii: "ZfRUlMvz6ihV0GtOaUEC6pVp6a6OA59nNTBlt9CtrZ6RKz8317XC0AKWm5PnxVidImQeeX0pRDkuFXmfi5U256QffEbmJdw2NvYvyOQYZmGDWp6UlbwgRVRp2srwEl5dWpuUfMVeyNBMJW1hV4nAgxpAOHYtxTp7"); + yield return (HashHigh: 0x37c86788fe7254f4UL, HashLow: 0x34ac2aadc84772c0UL, Seed: 0x0000000000000000L, + Ascii: "ao4zfgApzSbgG4Ftq9wf5QgDZirSVqA1PPK546x3LOgNG2JQHhjT65oby3dgQ1Byaqo87dAHtvhbSoMJKJ6gXpEG1ZaGMtDU11jw28rbqkNkPRGhFFA65ZEcTPtiKAHggYfJjxEPQ66UqJrLlYa3GW459GVPeoFo"); + yield return (HashHigh: 0x702f9caa1fe83a57UL, HashLow: 0x1ad19dc0b1cb4298UL, Seed: 0x79e642717fbf5a27L, + Ascii: "8soJhddrb3vn3BzioBaOmKi0Fo0mbjpFyrpcc5mJ0VnCWjS0YyBOswiRTMoVQYxoNdN2k2wzkJX23QwpXACid2h86nv27YnPS1L5rpIhFqdTROgS5r6mNFRTxbQFAvbqu00nCzxKgw5GJu4qvB7ipXbnpWjWu9SWB"); + yield return (HashHigh: 0xb2da83048486a843UL, HashLow: 0x8fd1449b08d84631UL, Seed: 0x0000000000000000L, + Ascii: "uCTbnQFcR82L2E59yMlIT8LsKURuLM0RZUlCODP8ArNwhlkRAetszECVonCjW1QSVB4xYvzusAb164DU66ElcODEaV15ufuztpD6tT82Sj9R6tcdLYOBC6aNMvnimakXTYkNvi091QRpPST1jOoNlJWWOUtYYE0lp"); + yield return (HashHigh: 0x1fdd0173c6008b82UL, HashLow: 0x7cffe4234efae13aUL, Seed: 0x000000000000047bL, + Ascii: "MvbXwjtP6WnGNEVx4iJ61MGaEwTZIAfCBwHX9WKOXCl1UAP0h84AhcG9iz6WZOme36zlkXdrJkDa1UQNZmcg0JrX9oNXPLha84UD4o8TNCSkbEitP3L70Aasn1Jjyw5UbFvcSNHMNBhEgBBF7b3olBorHCCSzYaGX"); + yield return (HashHigh: 0x69c8483b197d2b3eUL, HashLow: 0x07b4631ff422cda1UL, Seed: 0x00000000000021b6L, + Ascii: "HjFuXIJSeEXBU445lsex6x1BJeMOmD0OlaqLRwQIJSnBbwfAUv3muHK5t5kH9Dr1oDbSzs4zJ84D5UDoFvKBwMUJWZc5jGTE5gtpTznhVoTRXIKtAzIzysg8pA2aTvUeoYTTo0DNUHwYddlvMriG3HPEOuwPZDs9W"); + yield return (HashHigh: 0xe96c1fb346eb09a0UL, HashLow: 0xab3dad0f03e04e52UL, Seed: 0x0000000000000000L, + Ascii: "0gABXgE7m768NXW5kMNQ8ouE7LuSq4ncHhBP2jblEAqHn2rFhuLSNoD4LXmhvfYlDpEueh9IIps1UXmwEEUfoRCZLXwMwJd86nyFcA2finm7MsVOKCbAnGnsHh0aXcgcB9bJ7UZc6xlrSAbyzESkeyQOY4mWKyJhyf"); + yield return (HashHigh: 0x13980da167fd31d4UL, HashLow: 0x55cdf4b576c9a190UL, Seed: 0x00000000000026e2L, + Ascii: "m46SbDPvUCuopzRosoOzoh1svBy4yg7SU4XYnJOmD9bLDdTFx6Tfkf7BHOmaJcx445mUtBHw1NpuyMYCUfp8kD3CUDpN3oDGmzpnvS1ei2r78tQn2rPSu70n75s4wXQukEvbtkQVE3zbSCl0h1h0vmjy4vGqz1T9sZ"); + yield return (HashHigh: 0xa4a7a2f1ed370b2aUL, HashLow: 0xd3420621784f50ecUL, Seed: 0x0000000000002674L, + Ascii: "Otm5vGmVV6jF8TLUAHeHnxtSvH667GG88QdLrHzvJFdsmhiAZotqgmidTP3skJIf7YgM904PRVEGntlT0F0vAP5883qPKINAB1lj5NDGYTlU8UTkjM1eDziygtyKTaoftVW0JXVvZOldbL9K9f1p95YyzGxHxdeQER"); + yield return (HashHigh: 0xc64d95640c1e4756UL, HashLow: 0xe6994773f20366adUL, Seed: 0x0000000000000000L, + Ascii: "4oiCjBB9RQvl2aEzhG6Mq2J5kxxzj0xuJQfd4OXoOkOPT3Wfbg1E4Dvi3ch5VN8Zni4udCQlQqEOvhORazvnulCyZme9t5OoAIVxB48wWdJWhZuHOsPsziX1Hi5DMRCnyuphm8IHtUP6eE9XUoaPn7DCiEujVnusWJ"); + yield return (HashHigh: 0xbfc74a714df51f94UL, HashLow: 0xbf2853c55f9d2fd5UL, Seed: 0x0000000000000000L, + Ascii: "ay05ztOO6vxffFs5jon3nuCYOE5RrLdooRRDibetaLfWwMYgkSuj4wZLQeLSFDIy9UdhSLRjGN6AkSxUuDxNaZmvXboqH6ox7WOM0SvRur6fsVaHgkZ2yM4X9ybQRSQK43kWEsIwOJn81YXgMLrA2G0Jl1BWtbSDTsq"); + yield return (HashHigh: 0x475e2118386c16c5UL, HashLow: 0x2d9b637b67eb6236UL, Seed: 0x0000000000000fc6L, + Ascii: "0TC1betJD5n0UTWOYp9KG3stDTCK4IRpCzPPdLjIQlmgweMdDtRQDJq6RwTVHZEMVOxmaEttgkuxKI0LyA9VM1CBIeZuVK6w1wAai6LGTIh5S2qcYiZkFRKrurNLie89NfRM1gGuiz5SWpkMih3sWhOL51fKRxSK9aB"); + yield return (HashHigh: 0x55d822ae3bf4c8e4UL, HashLow: 0xf0b4338f997ec38aUL, Seed: 0x0000000000000fb9L, + Ascii: "7tBqI0zFhDi2TI7n2fVF6t7tfaisgpZNTEzJK8XBO6TDX2oGNERANFK5EzzA2npjI63vefCaDtNBHPQJVUhenNWwjMJ8rVdeerM7PlZyJqTBnXIEnFpfSnWCg55PsDXsQo4tX8LgxM1HYiwhab8FB5o9tdCpwWjsGa7"); + yield return (HashHigh: 0xb177a7d281e70903UL, HashLow: 0x6642a1661e1dfe3eUL, Seed: 0x000000000000019bL, + Ascii: "ogI7UGx94eVJAUXcfXLLAip89FeiJNgZhSLyctvpO0WAPpVbLqmB8aY2pbdMrDIaJJGQ63OCp5vj53b5AhuU9qeun2C43v5F0fBFaeuCs9g5e7X5w3PC50IHNm3dt0NDZNiesyt8YtrYhFuVyW3Gwiyn9lQnkQOFRJG"); + yield return (HashHigh: 0x190e4cc15dbb84fcUL, HashLow: 0xa95602ea7a6b049bUL, Seed: 0x0000000000000000L, + Ascii: "d3OblcFTEllzMGUk7FKNQM4yuV9i9PzQQtPs3G9bxbseeHRfnywdCkvv3btlshYExqVG3fFh39Wqqp0re0umNfJhdQDn3aKix002yzbWaqsBifnYMbSoPg6GyzOIRpSE9Ev7qtB8AtOPi3Ehvcs0t17rLS1oEPXEfjwJ"); + yield return (HashHigh: 0x18b6817ecd7ba2cbUL, HashLow: 0x4981cbe58b07ada9UL, Seed: 0x0000000000000595L, + Ascii: "39a2kzihtWSooZlSR0E6zMij0MRIGFOoP1AVVPtxT7l28cUUStWSYzkmtAj7fdHaoYkF6IamxRE9d9RJ66bgcvxE7PtwXYEwE90aQ4Dzg7OeBX7EdUw4jWNtPpi0aLRQDzGqLk0sCrqDxDAfyu7rJufUSHxB6dEa0Fwj"); + yield return (HashHigh: 0xf60fe6319c931d14UL, HashLow: 0x1e46ffeeb3f98408UL, Seed: 0x000000000000144bL, + Ascii: "nqNm2Z9wJ53A0uCS5at6v1SLNTQKxldOhyLTaAAsqwuUCxqz5AwEr94jklUcI5ewVWc048aDkoaumWZVkq4PDQWn3uuBb77tJ6QrOHsT1lTu7XPrxuDnumG6Io2qyJkVKoQ3pfNLPs59fTbCLyCsXkoBt7XUPtTbs31S"); + yield return (HashHigh: 0x59cf6efb67a89104UL, HashLow: 0x1e69d10c8fdeff2bUL, Seed: 0x0000000000001b64L, + Ascii: "VFFUtoHwiGTiDo5Ce8wpCGFcpwREf6m9CfWejh9KcqlekxNxhlsShqOfY79Y6rbBdhYKIf6lQKO7lkwFlvSGWQV2tCZH9sUz6NVVcuogH1RtzmNfnGILLHpwFU3NAI1eAOhmXqPoMVvWbTzQ5vgIEKZ4Vhk5kDL9FO6M"); + yield return (HashHigh: 0xbc6133ee2a1394efUL, HashLow: 0x2ebad593f2de9e4aUL, Seed: 0x0000000000000ec4L, + Ascii: "EYWylwmIZryh8ywRf9p7fGwyl6auKZm2B5DUfvG9Tp58RmcISiDmaGhQFbPVp2sAe4xQQi7eixU4m73nB6iKhJCQJjtoNssxWwoWCQpA0r0K1L37pGyMf6toUC31c50oyVwJfppdO0g4vBAECaBoHAMVoqA5xtnLlYrFJ"); + yield return (HashHigh: 0x98ca9dbe5d8b2c46UL, HashLow: 0xe9a7b1743eaa5260UL, Seed: 0x5f0f8f008cb448ccL, + Ascii: "TSGEoEUeacXsHOsAUHFL5Ya5zEVOnMgtYZyBYOI8d5euiYw7PavCK7xAIhGJ1EaMtNrKQLzaZS2y4jyfvGXWedGHClfC04zhGPRbsvVKIa7aXGMFaIq3Stzj65D3brutKMvcQZYOIK90LXL47LyLUIZN3DHSrzOOgmm4P"); + yield return (HashHigh: 0xc52b091d5444c7ceUL, HashLow: 0x0571a3c218987ab1UL, Seed: 0x20f0f02e5f401aebL, + Ascii: "JxyYsERzBkehNnCb8CrNUJ8vomqJQ3AvKUW9xczR6nZBCRQ70OoLMFag4sd9uUO2iaMfpej7iP1X72WtH8htlavohdGxefkScgi2iZVRD1S5s6E5JP0XaIFJ2whK28hrumfLRbwQBh2eCgK4OGNM2Vm866u7m5N7IsBQn"); + yield return (HashHigh: 0xb0661164bc99dac2UL, HashLow: 0x0091985bb0faf198UL, Seed: 0x0000000000001295L, + Ascii: "mGHQ0u4zgPiTK747dKXZmbfNi9ysFykGTrJmSRpCE4s7gow05r971UvrqDWNGPKjjZZcJg0ZvvhV0lslVsZ6a3yw3AXHS06Wp2QSpQuskJrMLiAnzu6LgKGKMc21D8O7hnr4820P506ZiGzVfeO0CeB4toFYNd7PVB96l"); + yield return (HashHigh: 0x13d820a85079dbb8UL, HashLow: 0xc234d6da41754b85UL, Seed: 0x00000000000008cfL, + Ascii: "B2ODuv3lFxt3qofD7lNmxvzpINollwlEZodmWjMPYHn29b2RsUCMGjMkYcxJKUpF4LNC14283aowzsqa2VrtUuQUyQFCIC5qcUcj0ABEDnhzUkk5rHnLVs17rhUeaCQfijc9ubvFzT6dVPasAYFu1ERHMiXctm21kwKuaC"); + yield return (HashHigh: 0x156d55e92dd16559UL, HashLow: 0x3ad31a70b4169bbcUL, Seed: 0x0000000000001246L, + Ascii: "bKUMbezUjDvlxfV2DrfYQZrIef9tk9zupc8xyyq9LK0zQ0U1BgM7s6JAafSQXmK9lVYLLckbaULYxmhnaVjvwLStHZrld0g5W5UDgIygHvoBeXB6OYsuUbfjmP4LrHzFr28kBmqzmfhYJSv3PnBArSleZxfLoSU0lfh8Fl"); + yield return (HashHigh: 0x7e32224321d14130UL, HashLow: 0x0d4b0583fb4eb7f5UL, Seed: 0x1b007726071e7058L, + Ascii: "4KW4aAYsR6GkllK4WGt6RkzTPVw6arqy6tVMmra4diCo7iIoCxwAICkGpMITGYt5NXWYxNGwekswGjPU2oNA38EiWGWohCCR0NJMX3NAzbn85kq3G1ntdVWpV2CxK0QVbkCRsVymxKuD58qPblbD5NMq1tGZWPTY8PNlw4"); + yield return (HashHigh: 0x8489fe8da06167d5UL, HashLow: 0x1744abae93c39944UL, Seed: 0x0000000000000a11L, + Ascii: "uFwcXzidGnJX0g1fRClmTSHrfpB2p7ZriGoq9a5GkMiqmdihUfOg3cC5WbYVWnWSU2szmeeolCLnT62oWrNNeIyQE3xAebkWRjQ0wJMvFNCZtkhDcZxX5nHT0pkMDk2W7xmT8MgN4bYO0Ze3ToN7oONG4JVPAYODqS3HTu"); + yield return (HashHigh: 0x8263e3c2bf745f71UL, HashLow: 0x6780c6353f4b6f02UL, Seed: 0x0000000000001c19L, + Ascii: "FAuCN3mA3XboKGeskyl2jzyDFlcRwrtSUuih2vLkE5nELy3xGKB4bSnzhkyHMBCjvfpyqsqohAr5HmwdEacCZ5TWa0aym063UJpDnFN9EUErtqFARiq1Bgv6BxBaQiIDB0InavI1cKbznOUddVxS6uPXPt1RM3Ae2eqWwZP"); + yield return (HashHigh: 0xfd6841f2f18c5262UL, HashLow: 0x181b3f1fa4002141UL, Seed: 0x0000000000000ea8L, + Ascii: "DmmRYqWD0NqRtiUbaLLodxyDMcmFavA6AYfaN75Xu4WbVALfC0pGrM82bX8zG63Jbd4Jf08qTi1EyVohXkiqCcavOE0i1txTl2fpIOtYuIXL9sc2eonjbuLjoxG8Y6BQWEaqP0h4AZFcFYD7edvqZpek4s7JI5gUpRgQmzF"); + yield return (HashHigh: 0x93dc0aa6251be6b4UL, HashLow: 0x5e6c9a4de565a086UL, Seed: 0x0000000000001e25L, + Ascii: "oLpP6h4aqJFX2oEbIMGtrKEHJu9K1mZsv5C1COJdEsHraUyHBKJJjWaaSaqy5YErcJFosnEBvOL9fi196BhwNzPm7tc88Dv2ZuARvIffOZkuzB640TND6To0lUmar92iTs0tHshgbzscV4qSkKoAWwuieAonG8CUOVaYvqv"); + yield return (HashHigh: 0x964b3e78919b8a06UL, HashLow: 0x4979b4930dc50b4fUL, Seed: 0x0000000000001eefL, + Ascii: "EiFDWQoocRk2oLlnRbTa90CrcSPfE9pHuMEuzw1V6PNk2TEmW596EgXfyAbramxQxDQ6nfLnJi7SK1CXNySz5sXKcSOLWI6bNIbbIO146PIDDKQUeP3UE7jOU9oWiLkd3t8OASON1HmDOMVIFJFDJKQW1eeFeKc8F14buT6"); + yield return (HashHigh: 0xf4c9bab56f3c9fe1UL, HashLow: 0x3949c71ed7cd3354UL, Seed: 0x0000000000001686L, + Ascii: "G46BeGhk3L6lIhNk20fRI6NHp8t5Y53kfn7UV0F1ZIkjKpsXsGtKw57alhPdT7nTC4QrH2Y9byKZUckDWYO5fdcMhmNlbwjblpXwLsNlqEG1wH9s8wOrdgGZliuLcoqQHXN8aSRNg0v8WHr2IRjyjwKQx392I1Qg36m3tDGW"); + yield return (HashHigh: 0xb85f97bd5a7cf658UL, HashLow: 0xc1103d58a79a2f0bUL, Seed: 0x7ee96f72c661a920L, + Ascii: "lXCf0G9tGPCiFzFhhJPNwavhc81yh3imEgZwfBTzdWqD1Ehg0mSFGDZKa7onMP9QPaEkdv5xkX4Ozc2H9v6RQjVdzq7s9KeM9BuPqllVAvZl0RUs5jq1omWntpf7QG5dBz8GD8eoVMX0RfG0f1FJ2bc3z6WWtCSNGLsoXkG1"); + yield return (HashHigh: 0x48eba4a506993ce6UL, HashLow: 0x1ed7516893000976UL, Seed: 0x0000000000000000L, + Ascii: "DV3Mg3Jhs0IdFiNXmyHyV8WG0bRMEJrzNMgQuUlrEozWsJY4FwzYoiro2xv1Cuv3VhlkLfj2Zzjw4ssWF0jpnEp60iUXF6L7JxXE8Q5ZmcuoxbeIaqiJMUFu1HYjHnwtQY1YA9JmEbAUtbQyjRwr6U2n0So95SY0dhzcnWAg"); + yield return (HashHigh: 0x50fe8bea606cb254UL, HashLow: 0x83ad0668bfb57be3UL, Seed: 0x0000000000000000L, + Ascii: "UFYQ6EksaCxSOFR9IBWTaqOlTPWBamLYhNOJ2bSRjTrYwNJqbgqYdPF2VnzyyKDd7hmJP3JSaCtDscRlCIUTVImZvPeLKwYzaMjiWAoaAKf5U47OrSWfCvlCWWaMtkTBRjlVguOEPiw0piqbp4v1BnPkO53qofFOSyFS9hU2"); + yield return (HashHigh: 0xf9ed5d76217b133fUL, HashLow: 0xf4cac77651431689UL, Seed: 0x0000000000000736L, + Ascii: "Ycfm5RRicse1McJ3pUaQasVQCBPB4fMn4UFJnkZGy2Jz3qU3rmTWldgtsQqqNlNewIBsXBWbCKVw6rnCxsOTkUwpSt94mRQBUzgng9c8K0txX7sDUkQfQ2obbhyCeMChfhDyv9iYb32hfLDc2qTwiyjAqe7mIBa2YBac5YLMa"); + yield return (HashHigh: 0x50894f2aedd70fa3UL, HashLow: 0x893ec422e4e3d72dUL, Seed: 0x0000000000000000L, + Ascii: "TGrNfG6t279sfcTxZwhV8q4w5qWLjC4fCHAxc2BybPffMlwUA6SbAhiYRnJ1FSX2Ve9ycbDKM8ndkJf1G4BWfxispDLNAFDqeZnG8GyfelRK0njYMQgqCcYlIeYXhkLw2TNR3HiR0vKNDeo0PjHFTB2aCHEPG5ZZ3yoGwYaGX"); + yield return (HashHigh: 0xee498cdbf46484e1UL, HashLow: 0xde46f2caf14a94dfUL, Seed: 0x0000000000001099L, + Ascii: "byYoDNAqkwTTjOJzPNGT1QjYBHXqSGpMBXFika3fsMjPm4WIUSBX8RzfAYsntzlZv22amjp8LpyQmHwK5YceDrZe2D8ZNLplxeQ1cAOQRwNJG7wIVZDS6OBWJakx9dwXdTLtIul8jicOX6YwCkgneMI8qG9AeqB7oPPSSRbAJ"); + yield return (HashHigh: 0x020bcd0e20dc907cUL, HashLow: 0x6b049025463a099dUL, Seed: 0x0000000000000000L, + Ascii: "eFvEvT511W4r8irHUFyq5xVn0CqRS6w3UaLXKTXjTfRDrOtidaDnlJ7n5BxsBPqs8wJYqsy2xKs0c2xpcOMQuY2eM7XKbeXlwCnKbfGMsjOoBx702j5CISzowT8lA9hVLHTOLT5ptWOprU2Cazt7SlhXvQpjCutzWxQNbwm4f"); + yield return (HashHigh: 0x778d6ac68596886eUL, HashLow: 0x8b521faeaa7f0ae7UL, Seed: 0x0000000000000000L, + Ascii: "69t4PnV9HZjqxyd614OpQ4UUVFaLwLZjHwswUVhd9w5WRpOOkgLHwinBSOTBdBGdzVcD5LlQ8rfEfG0PUPY8OpcXvxLFSp5y690sQPgisz3dsZQkPGwTfRWXniGtLugTEV9DvBqe26JsflgQ3WrAgL61pesPLqUjGQOjTZ1SOs"); + yield return (HashHigh: 0x43b59cde0bd1ea06UL, HashLow: 0x976649111906d646UL, Seed: 0x5b6591895d28d90dL, + Ascii: "7LoO3KeIOyuTzZUVLLhkpHHDk73ESMrTtrgAvb8u43USMk6oWdez3ltcbz5dufMfnBRJG1oTNFArxx2YJqO3i8UVdkAA6Xar24iigoQIN4wYHZGJ1HKJJkcVunTR0rQrcwaKTxxgDqo0wd4YdAxx85mNT59P3uRpGpHIhYBFzo"); + yield return (HashHigh: 0x01e8375fdcf288fbUL, HashLow: 0xe6f047aeb8f4caaaUL, Seed: 0x0000000000000f3dL, + Ascii: "yphlsnEFmkZwrMKri2QCAhHbNnMViBQuLV06ja42hK7D68O8Y9TkFO5mwYVZVAqnbEw5i3D1XNcmsyfyk5CmKQHq74h6YSN8291cBDvQ8lCdUeVRPxE8Jqds47truLtYK2xPMuYoY2I0aQcRNdWR5JIdtQe7KSBEzyR3qgVmYc"); + yield return (HashHigh: 0x62fb0aae35603ceeUL, HashLow: 0x35e6a50dba0142d6UL, Seed: 0x0000000000000a6bL, + Ascii: "RNjhtZxCyOOjXrJABHwbEp3oXQIfeYijz2H6a965ITyBXArhkw49dtRSmpdakArrBtgMLRpzG7FPn8aKdCTh6bbxcMTUYfUH8HVAAtedFqyX7jJ9jyI4FrkPOKSiEjXpL06mlyJFGZV4wXNMlygi579Dl6EF9I1cItF5Y4zrhx"); + yield return (HashHigh: 0xcabfdbb5aa4bc3afUL, HashLow: 0x11ee1c6bfb6942e9UL, Seed: 0x4bbf94d0e3316a9eL, + Ascii: "Ve5FS4djrjD7bhCuXFhvQceTEKnr1ILCeEyfEmznIfIfDLxNBB5teSTP7EIQM9AxNe9GqivC7aU0e84LHgJcbURShbVfJ74rs1VbkLB1jKFqkq2dGmNyKJJMBTd7NhSoe8Xxo0a7zV7173HbVSotvDmcZkroJQWFLXidem3vpNn"); + yield return (HashHigh: 0xf167bc9f31d02ba4UL, HashLow: 0x8c659dcc845e0418UL, Seed: 0x00000000000008a1L, + Ascii: "SxYJKtcy22X2DlPHAXXvX8H8dwsHH2s2BDp0KMWaF6gBut1nEArXUoHGKOq9aMhBHYr7zjWJ0ANdPVFsZQBVsxuJ39K6rQGrI2NJNwikoCL0cLSa8rLGSyu735qpa42kgaigj6RmDgnc47p7HfHPyvudYV18oqK8cDiBdEJ160B"); + yield return (HashHigh: 0x0864011cfb8b65ddUL, HashLow: 0x3eba99ac53b9c432UL, Seed: 0x00000000000016caL, + Ascii: "t7J7gMiUNjRyVclvZ4jDA5GLmxDLHR0Nz3JaLBoNq6mWPYUp5QNCEMOZ4qDnjHT9Mo2RgdKtGGeT8axHb0lrM5WhQX31Lzh5nITkU1WUpKhKXAnVvXvpPC5FjRexZRwgjAkE1lgNlMZBA3MNr3sagaJLrZQoREGAJq8EVYcWror"); + yield return (HashHigh: 0x11a022f54ea382e9UL, HashLow: 0x0d6e442c556dd575UL, Seed: 0x0000000000001d40L, + Ascii: "f9Sl7veXY1JwUr5KTQaQauyOVxeD6iuWp7KzhBsUI07Qp69jUqlpqPG1propVwt9pAcghPpr3vOkuHPWdtCcpsQ17YTC1MrZqv1vUs21zHHono4ITzSP4vCXzguU2SiMd3zltIi1O4MOb9nEyduJGDzy0aIJA6V6moDBYykyxft"); + yield return (HashHigh: 0xfaae73443af8fbe1UL, HashLow: 0xa0bb3b31a76670d2UL, Seed: 0x0000000000002639L, + Ascii: "DPFLTNJwyO15kY2flHP2CJjYhGs7cCxhIdiXdOvScO4JY1HAyqyjrzN1W4AKXCkVTQnNoD8p3QvisKTeK1jFRPMrplnoxyDti2f9vFLkIadn43txwZtwudaqzixWHdj26LHvQKYdHo67lEaxWOqxV5R6nXYChKDZm382oeW4Avbx"); + yield return (HashHigh: 0xdcd41291711fc457UL, HashLow: 0x08dc9cbe1bc37ba8UL, Seed: 0x0000000000000b97L, + Ascii: "li8b9ODwJRG7oQ2xanuTE1TdLAGxVNqexRDdsN5yvD5vwcgkF09F8Z3e4jQZcPKsQ7Rse1k14tm91z34vTxBHbBhhht2s9UuYr0RgmZP1t14hCtxxHGbfn7iXTxxce1RDMzyOBjV8TD1L2uiev7XK4QfigJZ8ZbJ6ZkBjea3r7zN"); + yield return (HashHigh: 0x4362ea87528cf65fUL, HashLow: 0x1c02f7c9fd03623eUL, Seed: 0x41e37724bae99a43L, + Ascii: "QXIZfwWkXQkRwZOCC1Rn52AN29lLufsyDdtWMgkN37yUHN8QSTgU23DMke9zphultPnjiXSmuZG4FxAMNkm2Cxvbw2KBUq4lQl2WtW4FY8f2MLu1XYcdwTYRFBDt8EVZRI5OngKLTHB6koRF2NZ1l609ESGyR5WN2lDzlz4heq5U"); + yield return (HashHigh: 0x078010e4c09442d2UL, HashLow: 0xacc29fe09d2d618fUL, Seed: 0x0000000000000000L, + Ascii: "JN0f75tX7QOtnnD5Uewz0xVY5l9pnTuNBCXQjd62JKAkbqYOGLOKN4qM482gC6TmNyWbjNlVndw4hopzHGJB2thEoNO1d43R5bSDc77jvXeZ8zPp5mfbIAAoTnsFbCFjDVfVtCYHHMz49JE8IWThoguCwoSQDQxLc8e7QRl3hEAh"); + yield return (HashHigh: 0x5b4033774bac63d6UL, HashLow: 0xf4b90080241c673bUL, Seed: 0x00000000000006a7L, + Ascii: "Si5ePHomZqzQcU8dkfDQsnLpQA4Ys0eUuJQnLnAGU533xVzVwr3i4OR7ajLCR7DOX2Xn91pUCZgQ5yyJ8nfDU6YRBnaSywnkDdrpYp619DpZCBLlzqyCnaCCVPMVOthcXm5o4goGS3yaGxJfRYCnMoy8whFGgM4OREQFbFFF9frAK"); + yield return (HashHigh: 0x31d7ebea32534710UL, HashLow: 0x579b64df2a3d6e88UL, Seed: 0x0000000000000000L, + Ascii: "qgVnQMzRNPkx4wFffJKN5iSPLgOQwRl9Qxo4oa5Ayi2KaMIB0K03LtzfNYBkKLbj1AbJkTHVlnvtvlNReKJCMmwn3NXSEwp54qNO2lwWQO64u27Moqg0vq5gS5DXfIS9FTOYkWVka6jNfn846s6yQa3iE5sBSeazk4domSEjjw7iF"); + yield return (HashHigh: 0xeed387b84454392bUL, HashLow: 0xb2036982f03abbe7UL, Seed: 0x00000000000008fbL, + Ascii: "yCh3xyhOIarvSlLsPB54PQ4EoqkQH69UQrhwgUDD8IV6HrCxu5EQMMiWYpeSfnXhtNCGzU5xbsSrK3LxYq7AkZqycazjplStIbeD8IUuaY70dRLh9RGToYfHEJpVKiBRN3Ei4uIksoYq3eM66pZyUag908THDQsFsJrrmqqChdorH"); + yield return (HashHigh: 0x683fba73342a0c05UL, HashLow: 0x3b24b27a043aa11bUL, Seed: 0x7f55f3730aa104d1L, + Ascii: "OpIHHgp1poW3DqK0flDsZbExyh8odgUdC5KGUIHPZbRp8gxKauoOcdrfuWrwHIz4K4q2QVHIXqCjP5jbCM237CJDSmEXBQm5Xe0fsTgzE7XlPRdeS3QSdrkWEE38FFiTsSlqlQbzCTzI8nREphY9dxViO63kxDkWOKZ1NIeKuUrFC"); + yield return (HashHigh: 0x8d31f628ac99633aUL, HashLow: 0x042b00e0f610a5b7UL, Seed: 0x00000000000022c9L, + Ascii: "zaA4n2ZzbeHZICkmWLOUqOo6DSpcGaknEnZmULFYD5clAyrvkEkpbktQiYjjs6CgYnd1q5tn5kgAlRKg5IB7jhcD2uEJRNT5AMXvon83GrX64c9cxRsIPNgBODuzvdsFBJOPikJ2IaQgH2O6eoO7mLQw41pQFbVSWvJUnwsWoco1dQ"); + yield return (HashHigh: 0x714841c17a4c501fUL, HashLow: 0x98c9ebd473d1d33aUL, Seed: 0x6adc8b669bd6311bL, + Ascii: "TBrNqFvW930t1B0Cf7nNX2jvcnnTyuLYHhinwCkeKplwLBZlVtiA3PAqHPtcX5KBT9yvhJtoBMHw0dYhSsSNx8LKHFqe1RrSfjMmp6BLUYrOtbykkf5Zf5dKo8Cw2BY87RoTC04RRsDEMB5s0f2Idyc63aP8wDJ5BqisAH1GSSSG86"); + yield return (HashHigh: 0x0ecdc7721ef53c7aUL, HashLow: 0xce3e665b82fb0f60UL, Seed: 0x00000000000017d2L, + Ascii: "TQuxURhF6DjeDoo9sGcQt9pTeyy3O709uT8FBfjZZTBiuXl8KPSnJzK0aKWFgHCwu7PMGCkZQw7bWfV5MUGdywz0WUE0twTBeKcmGoCe5XR18R0X1w0XbkC9sFKGZIaTKwbXqeFB46Xrb5CiZnZ9hGVBJKqac8dWO8yVgNzWvsZzWL"); + yield return (HashHigh: 0xae86c7e6da343610UL, HashLow: 0x52c19a2b2aa26427UL, Seed: 0x0000000000002194L, + Ascii: "ZbzTdTGpIRbfH14hhoaoq8swak0oK0wYRImyQ06Gospcns9avJo7aAxY1xHo1gMrKW6f9ZXqqrkaNB4xx3CZP5egAyN1NNwLz7BLdBlWrpxJWRg7IqSdqsGAVWKt5iNmyTaN8Fhw6yUpxVqruGJyCHQ5zkM8rW6xFSr4gXDIrNzmWC"); + yield return (HashHigh: 0xbd4f02c75b23d00aUL, HashLow: 0xc7b67ca38825b072UL, Seed: 0x0000000000000000L, + Ascii: "a3zegmCznlfo8ePYK3gLwiSR0viat3PIjkjl7oyt5xQ3QJE4MYrqAW5AJwwCJpNWIO6WpYZsA5EchW8qD0iVec5hRv8NEKDTPopzR8ttgGXtjcO2MFwrR413qxfK3NxxWtdJ5cfJBCzAuSxrdQNYBLfLMy0HaAQ11855fhSvKJ7kQ2z"); + yield return (HashHigh: 0xeaa087b5d4869bc5UL, HashLow: 0xfcb0397e4d475450UL, Seed: 0x0000000000000000L, + Ascii: "h8cEn1EWrsatjwjYT9bwKJz6Axxs7pQ6f1lvydrOqtkP0UHjyxR1INj5Z3HV089qdMQNxlrKwnGhrlq4I4iKxlTJIvVFM8HzgEaqoh8QQqDABobpN9lbfQsjlbJNM3gH4FSUDrLfNcr6cSAIjqlYEdv1Md0YaDlqsul53iXwpVPgC0c"); + yield return (HashHigh: 0x6c8e0ffc04d27b5aUL, HashLow: 0xa843d4ab90b30bfdUL, Seed: 0x0000000000002589L, + Ascii: "viOHAyJJSBIki64hUgbwyguF2MhMloJgbw7dAy5pijA3zbJObpRolOrFr7aG4Mx3vXGfr97eHvN5EOaYS85daM70YM7vm0SDijlYdr3C95kfSavEnx5TZlpQuMfwxX7MxfbWUZkxTeJfQVpQos6wBHNIG1kv2f1yIB6gTdZC9CP6Qql"); + yield return (HashHigh: 0x52e291cde1ff3c70UL, HashLow: 0xbe53b4541430fe93UL, Seed: 0x0000000000002343L, + Ascii: "RN2Ed0iusynRxoH9LTGfbhEB0VE1aE6grVGPqCatvVazhxoTzz4XH6Tfun9YEVLoHnEYGN5ofv7F303wGv06LvwnZQ1HiukdekVchbdcNSeVN3tplqxZERR7HBqJPzOdBkrXcjlrtWKQkEgKRliMpcFxgEj16EDV7Cu8PIvAch3c4oh"); + yield return (HashHigh: 0xea176312a5391d3fUL, HashLow: 0x5796c33a93bcf090UL, Seed: 0x0000000000000887L, + Ascii: "C6d4lvLwj6L4OtadVcgzbHHXeZnXHHTNwJnlz2ORtfiSiZ5jAKDC5BnOyGuGjMc7wX3JY7TJh00PeCEVoxHn0yF1Nn68OdHnWhjzVoyjOjuG0tFm7Yk9sQbXkPqbCa47fkxQbjXna2qenclMYTSfng0yauu2xMxnQY3qcKbrpSrdED65"); + yield return (HashHigh: 0x77d149fb1c1bbb60UL, HashLow: 0xdf91f97615da47afUL, Seed: 0x00000000000017a3L, + Ascii: "dZhFolrz3cgY7Bcq6joKumrEi9JNFY70F2CFIMe2SxObMQYGf52odirMHQcfPCiV60WnFOWJmJBd3rPXdDrcoBdwObFRvCudXHaAWcujfw8c15DGZHlWLk1nZUGIIDR6XYnhgrJ3WETHGQ4877JEWt5I0qVenQyQezpDz09mX6CK2zhx"); + yield return (HashHigh: 0x0052ead23718fb97UL, HashLow: 0x2b20b26782f12dc2UL, Seed: 0x000000000000230bL, + Ascii: "dLsYLvmOQYnDDlxDUXalLzd1hFQggKxJBB1jtWnePp2t4GQUK8AvuEtXsih6rvdB4r85lthPIhkcDVcGmFrKLMuYfzm3N8eCSfab9WD1MztTJkUxckYzMSuynESDlLUVWbxlgeHSevClVjKvqpsHCa007dEsuSiIvswFmnH8a0mQUpRh"); + yield return (HashHigh: 0x2a8aa8329e17d7f2UL, HashLow: 0x01d0c60ac482e355UL, Seed: 0x0000000000000000L, + Ascii: "J57JXjaL5JLObJQ3oUgLErePCRDzNmtkBDUmVsU1pwTtydAIDL1pGiAbRqimx2z3aUDtLp01F9NJgpBnTDtvNTSW7UGxL0qe3UhUiKbaAvEbUTWlPvTippmQBnf7yfnGCQCYXIRi3DyCXgvYWwqFR9eqB0ZTXg6WL371956TmsfNHgQQ"); + yield return (HashHigh: 0xd81333e21dc966d2UL, HashLow: 0x75810237bcaf7e12UL, Seed: 0x0000000000001dccL, + Ascii: "Lq8p2D0n05LdsOWZSC1ZW525PgNUp5nPtzmH2alnzXQg5TZRnrP0aZacyeybvi2KHpPB84lCFZ8CBlk5hvrIbuWo5ji1cwON7QL3AQ3vqVCUbmvnmiO3ylX14r3huWVEtVxFRYVNBjNpv4icH8VoYzfHkmQ2qbamgTz0lmM93qbgIPLnJ"); + yield return (HashHigh: 0x426f8be8cabf80fdUL, HashLow: 0x9b1cf70dd5dc5f44UL, Seed: 0x0000000000000000L, + Ascii: "VkpCNWkIT5EJxuRljD0VJvqY5oN82jUPkHdXlBkSmHYDCuCuBxCdbZKS4pw93Pd2EohxIGFO06p4BBCsIceenb6IWVVdIiKZ8ikKjpm1gjr9RijjMxzvgvnW75l8VxNt1jAJ1Exyb58zNPP2nwz9rLqlSjEOaCItOQx2rQrnqXC2Lh3dz"); + yield return (HashHigh: 0x749253d468c1b764UL, HashLow: 0xf5ba8a765f3ed485UL, Seed: 0x1c30f1d9689a88cdL, + Ascii: "HW9zQM7NDJfQSwMCXH53n1SFltoHkx39AdTkKuwTPg8V2MIQcy6SKYtqYNFjiCQW1iDSTQxYLcPmZRarmj4aj4n2psQW2oiKX2Vhlc5KgEdApEXsc5qqYxcDqUzv8nHNDexnAmagY2Cgi5IHC3APhDwT6oEpBslz2gBBUyTfF3iz0g3pD"); + yield return (HashHigh: 0xfa76e5960557f0a5UL, HashLow: 0xf5644a5e1ef9c344UL, Seed: 0x0000000000000000L, + Ascii: "f0TDQc3ksKMeoz0XKg7ubWELhCTzvrtP8GwCVSJT7lSTo7ucoFlblH79GnkNvOv6gsFxCWWlKjKPFjo5wmOe27DMu9kZ9VXwnTbnGDriFtaH6S7BOR83KHvXm9Y3whL1GEWHQs6sY7XBDmCDwEjtXQmBfx4K22i9YdlU1B64e17JXP1Sd"); + yield return (HashHigh: 0x57da73c5d100d1eeUL, HashLow: 0x87dd5d00b9428d8dUL, Seed: 0x0000000000000bd7L, + Ascii: "NWqOsKqA2yneMRscJuSwCDRnCcJ8BRZdH5r0bKcFOJ85TB2Wsfx7p7ZIgjyApCuzWbpbqKDYEdwXeMC1n52dQkYehWUhFhi3oVQ6SCilf70cGE5zgktSFkuNbw1gUmXDRiGaXPBnxUZZPwapo05i0onEdQ3XxFV8cGBA0ScipSIujBfgve"); + yield return (HashHigh: 0xf35e60cbcfea325bUL, HashLow: 0x82c4ed84e5bfd752UL, Seed: 0x00000000000020afL, + Ascii: "eJmud8YcT1ocwrNQ2md1y8jenLAi7CXqWmp0yuPSZtTyHBEu9qMlIDiv64Df98NtF8jWJdNnM7FlYxc8HiLLm51Y9kEpsH6a79ARqNRa9EIR506YqLxQLWz7ai9pOD82iUrXQ3BAMluQk2KkhB7hYeOJ6ZjeWuLeiOndP0kKgJTRvx1U5x"); + yield return (HashHigh: 0x8efab55fbd06fbcaUL, HashLow: 0x730cfbb84773719eUL, Seed: 0x0000000000002306L, + Ascii: "18fhz9SuiXQoq8efCDhF9ey8dDrXUuripB3dgCC7aRA9JlmLfcpHcqqwFLXoqapfF2IWOPqvISuIfBU6imlz4eIGtdY2TIiX5B3XLX1LuDKhfrescbh8wZWYZyAgMqCq39gIhKLeDOp3FUwtpJ15bgyCcYfXCjZswksZbP82XKMi99Zz39"); + yield return (HashHigh: 0xfcfb1ed2ae9be467UL, HashLow: 0xc611816a7dbe53edUL, Seed: 0x0000000000000059L, + Ascii: "RSlDwXPk7QRaouwN3ZpDby96hMHm8Pdrchzs8N37NjQa2fhE23jUVBBMRauHxUV9XsHXQRNi4WYqCJqGOsGB3ebRIUKtfRmRCLdte5nYozGvhDB0itCZrLl2KW9YjbYQSylHawBo54P91CJJIyCfZBHtM31GvP4Kf54N9TmfJeHvolInO0"); + yield return (HashHigh: 0x8c591e9f650f65abUL, HashLow: 0x7b4807faff71aff8UL, Seed: 0x0000000000001648L, + Ascii: "MtdxsWT3aivOWEiFfI3rZeYfyhGraz5WRKGMUMFSew31QObTxntiBuaR5B1lCqHWmyrrMc9rjrKD9BmZ9kkMdrO2veSduNPiJ1E3k79doASJhCN6D4W41aHRUk1tk5d0WRtczms1b4xTQpXklrrPKyuOnD2w4jrIPdQdqhbOYIV9as53Ix6"); + yield return (HashHigh: 0x7a84dbe2229148e6UL, HashLow: 0x3c71ade5cccae1eeUL, Seed: 0x0000000000000000L, + Ascii: "dZvz5IhrziZVFIqSsMPsTYqm2yZXVlK16KRz9HOnoIVTXndJ9wXy8snmPBlmE4UVKMl43htrrMXmGHnn2uF5TbdXSyMDe4eM1I7nP73FZVj3qcTwyMm1E6Eqgrv6ueXkSDypLaJoO4c91lBehmBBQBfMMbzK12IhAe0oBFfYJNR89WrE2T2"); + yield return (HashHigh: 0x1c9ed20f10b15e85UL, HashLow: 0xab82598b27805beaUL, Seed: 0x00000000000011c7L, + Ascii: "3pZGgG0wdGRvQKX4q8EyvTnxuNREvdVOd19Oh04AW4cnzcp2rmM1848odP0Hz3MqXI7ZAoEfNv2Dzj4DTSHY8nCF91SZ5zGeWvJtaDcz3IPGAQ08NBb9QT7xXVC65Edx6g6wF93LSKJRemBCmcm4mKdPcV312XXuZeEoORzXUENzizlXQHQ"); + yield return (HashHigh: 0x9013f6cefbd7da90UL, HashLow: 0x8226f413a329f3ebUL, Seed: 0x0000000000002462L, + Ascii: "7960wj69aXsHI0qmPHgQzqQ5ZW8M9AcuYsUmmNX46uzwCvOx9Uu9KzpFUjhlDu2mwdbvdHfKMnx1td7hAKmLgMKYQ6kvYSevcSWfhNJZAUSVAe1ZzaEzgELBY9hAp4eLv3My39GdzsQPb9F3r0JvVL3B1hvgAGu0QEI8acrOlfcu5KQeFCA"); + yield return (HashHigh: 0x1e6f5beb7c2b5ddcUL, HashLow: 0x6ca379d33520d6daUL, Seed: 0x00000000000016d5L, + Ascii: "yW2PrCj4oEhwXiS3a3Ap1rsrOqXMwMFSngA5zZvYNHvjEQh1LP6XMFOuAUbUtDLRovZ3TCAtbAo49Bypi1VoKj63sVCe2EIgVb0YKWQs0L8tqRPbwRfrjdbqBqT74SipSqlUFGAD4KL4C9uKXCl7dWIvz8oyAUrmhBpat9teMSiRM80gWL8L"); + yield return (HashHigh: 0x595b6d555ebcb501UL, HashLow: 0x4ec3907a264fa28bUL, Seed: 0x0000000000000000L, + Ascii: "tKkewASucUiCiFRIrqgHXnih6szxGRKOEe7jgyaepXGV38nRzcyXuvomMBRWW5XcIijG2I9J0VxJsida1PyIJK0evR3PZp8EQpMDmn7PmwFB6JzTRzRurD7YeIXcZFBfryGdpY0sLZQYn6MMbceeRqsxw17mYcs4t1V4wYsnu16iWpKX9olC"); + yield return (HashHigh: 0xf727c8160703b060UL, HashLow: 0xe0e1f2f2c4c16976UL, Seed: 0x4e1c2997f7786979L, + Ascii: "tx2gAcVeuWYTQnLACJk8GUGaeedDIblXsXQD8ITi9ZmyNNe383ByCRAeytfKe1SYWi1rXT6Y5tcJIqeab3H7NOnZnw3XhItAdbfKpBy2ENJiVyPtSMs1cLlaN2JqmRrdrThygetWxYeVdFxJmawobIdyzvtjnuykne6Pc4cEqthI6kmRe6LN"); + yield return (HashHigh: 0x90274619609d3ad3UL, HashLow: 0x64e2fdb2a6393379UL, Seed: 0x0000000000000177L, + Ascii: "Pn1S7LvUboNX29kV6hDbNUY2mRLNUJwGqsTomTlo60bvXQEq7pJwdGNlJ5KTLV9RVD7NFegUF982RmmJxXIIQimj4fgvvUYq5jtAkT9OltBJvinqNuYneYRAWLSqh8Xoa9j4z3qiYXhegEJxuaoQ85ePlXcgDyljaPAWaFUZI1b2JCyYtzVp"); + yield return (HashHigh: 0xd0ce809f65d51a6cUL, HashLow: 0xf019e440b2a9f8b9UL, Seed: 0x0000000000002484L, + Ascii: "flBRRzYt1hrYXdrwGBey2oQuqX0Xe4FeGE0MUhMHnv48P0Tjkm7M9P8xWEp9Mnb4XTnyW7rtNZiodPyCmgS1QGEFeOFluj5m0Qu6YqZ8QEGmTln7Bck7AGhN0KQLwo4ZKTDEOz8GHJK46MEhoV1h47VRhnqwrp08v03FWLQgUub82bR9y2vwm"); + yield return (HashHigh: 0xa5386bf2da5d7ed9UL, HashLow: 0x9409f3e192df2f27UL, Seed: 0x3aeda318187a8ceaL, + Ascii: "xakiyYp1uPRDpENkGatZqaaVSCqSglYxE3EW75mb6ocRpXxyYtsE96glnTti6Ax34ocuI5kSKu1SUwXYNJeiXVcOR4c1ditIgbJOTWcdSjVVszT1SXkz7h0mX3zbwHkta81pf0yI1iqF0qVy7nbgcI23bOWymEFXFEwVWzqrsh3q0ZyxM0F0m"); + yield return (HashHigh: 0xd556eab56954012bUL, HashLow: 0x6349fc948903888bUL, Seed: 0x0000000000000b95L, + Ascii: "MAP4ZluXtkCysWGhXgNp8g5XJdAoZgQd69WwQ5kiKcNTJXDAau8YfoAh0wQp3Pt8xRTIwgqpXLibJPkPVWJrJ3a0iVFco3A1cMd9AUZeDlIngYbKUhVkDJ8ySPGymOowWR1bF1G3lJtckamNEcnflIfVUaofCBTJ1juuJgwHqOlYJsgaF9LS8"); + yield return (HashHigh: 0x7587bace1fed79a7UL, HashLow: 0x98694af975387964UL, Seed: 0x00000000000023caL, + Ascii: "pdI32M9n3BMoIz8POWSaaXprQtrNMbGttrQs1jJhm0dTx6MLRV58Y5Saa1FWxbHcWHlkymDo9VNVUI1KXqmlpZGPEvDcf16uxTkawDZvO8xAXvBaDyHqGNqldJQhsLtz2rRlm4N41SUhKB9Hl6oQjbfmRlRxXc4n4mO7qUdQfsjCjS4h8r4Nl"); + yield return (HashHigh: 0x9647f2ee2642fe11UL, HashLow: 0xf01004e49da8f6aeUL, Seed: 0x000000000000096dL, + Ascii: "v2yB464jsFYA57ehyggHcHUIDgnlyy2iBToexISkax6CTrlf8haI8QqjZG1YL0hBWOc1JOAahb3IX7Jj8uSAFqKOCOwshDyuih5jisPPzNScDo1NP98EHsujAo5c7EUyDCucvDfyatwjMTDRy1z6NnpdrYKocXpOQfuLRM1RYg9QY2Xo5e6ahq"); + yield return (HashHigh: 0x533eff4cf96fa0f4UL, HashLow: 0xe6330ac99d86b66bUL, Seed: 0x0000000000001cebL, + Ascii: "d6Z1rQHNfl4razuB91Z7dMCCqIbPUemIl1uCFwp1dkZddKBQ30fhbD2OCRby3hrUTkrG7rGqhOZ35qE0WltDskgeGPZZdkcGMISX41JwjxDXg00a6kDvKupwyQzK868kESLJ8SElB7G3XAu6fNbvwdTFhL43T872PKF7Y6wnkK1dq6fcGuIRNz"); + yield return (HashHigh: 0x76552d9af28b6515UL, HashLow: 0xd684e48cd98bf1e6UL, Seed: 0x144723cfee66f76bL, + Ascii: "zTUm7XCHKUGnExdeHD4d3n00gJo1dDsJV880dRneEw12DxJQwbkf1kfge90GblTqRwyDEdEqL3ygOc77onaKIux5mSz5DI5O3Lc6r7ynQzOyJ4iBfZUu2IdBT89hdeo2FECqlN4qikHysfz66Cw8umK0xJ7AwJWZGgmt0KsSdm4KSgXDmQumj5"); + yield return (HashHigh: 0x4bac13f22d9240c0UL, HashLow: 0x106e5a9b3a661a45UL, Seed: 0x000000000000030aL, + Ascii: "a551YE3acidpdsBEAbKSVafw9T5oA2FlaXpDOjBILDTLOJsgqCqR396yARyFkvQWU90eu9lM2Ts14MBuD3ZG0gNHe2txRmCejSR7FPvcYQiqsoCSWE1XYEZqnM7MpNENmCyULgc9jahlaRZcHi6cjivtHBKMgK7GdjKEnhn0oGNG2aJF1Jlm2A"); + yield return (HashHigh: 0x09c233be3425aad7UL, HashLow: 0x286f4e05c02a9cebUL, Seed: 0x0000000000000000L, + Ascii: "N8zaWjtUPYwptlEtQHKytOaUXDLtti1azxEysaZMzVzXiF29t2gNjwM3DEHyBpRsO5tttioaLgXoLNYBGtmMyrobhVLpzSLlS6HlC44PpvCwimAiyduddCVUUq9giXLMLGNBtmRg5lxhrBfhLyyVTX3uE3u10gfNGnvixQ4sNwzXQVfBW982Fib"); + yield return (HashHigh: 0xe9964ed4dca9b6c8UL, HashLow: 0x178a49d366adcaeeUL, Seed: 0x0000000000000d47L, + Ascii: "ca0CQsE9xvx5zoHANK3MHhVfwxuu07LZHeEuXwosS1y0ugSBa6pR8ac8SlnS5LB9wFCIUSiDiThnigKVi9UqSoXgFmJ5YN9l6NPJSfB10dCzz6Qxc5uJXhA7H3xqMVE548HLwaen8YQubkRCpVdHgnSPMHKssKchUZxUOlHHgGRbBaLoGIArnce"); + yield return (HashHigh: 0x704e7ae0402be062UL, HashLow: 0x3bbbc379ef25faadUL, Seed: 0x5568b6f89bac7088L, + Ascii: "QixL5o3UG6iQCF2PplvydxVCtIjonJiKHCdZaEUD1RGjN1gqR4uGMwcB0MZP91IyEhUyu1Rx6DJmRyHGLdFZjLkXMtYAQdfms9G4wvO0QPzAYJbsz3Y5ap8ciOi6LX4aOJWAvf5ziD0uJ1TQWAqupVSpJmu2hsrT193iOYmTbXc1Lfgci75Ai8E"); + yield return (HashHigh: 0x6c1a406264ff52f3UL, HashLow: 0x1b3a2fe87d7a903aUL, Seed: 0x0000000000000000L, + Ascii: "mnriVJXia45AHhEjsZeismFaGZnDH46U4Ipl07CN39zUsfwNguHdfumNQczQOjbCZjx5EzUGix1989IKEiIIbs19krp5JJRiVBsp6j2r7bwJwaPANOllxQGhzFs18scV8QoVDbG4amGu9LoKKJ5a059GcP3QrahRBfEH0LRLOa99ctrOkojZu3t"); + yield return (HashHigh: 0xaaad93ce1ce47555UL, HashLow: 0x80e7bc0b2b241da8UL, Seed: 0x65ad2bc75727a669L, + Ascii: "BLwpEgFYeGxJJb1qrdp975NnOy6AWRMj7LA842tJFqWLUUGaa3PsDCa9zOOIIgIiTNTYRJCvBTtPeoXOiTqvKsLs2n3XfNMTLjrBACeUO4J5LbrKToq5URAR9l6DRvsaIlYANAXAEbj4R4FaOFarRUuNt2n0svPqSMZWCQgSRtKmuTSWE4BRTKdg"); + yield return (HashHigh: 0x2566d9abe6562bcfUL, HashLow: 0x255888c202842eefUL, Seed: 0x0000000000000000L, + Ascii: "ZCMAzC4R4SolVuavlBOqxhSjlr4sRN8x5EWoKzxvN3H3jNjJ1Ckz0NrAdV9bp3tNxN9kwssCM56oEG1KHCTgJ1t0Z10Qes09k1JuO24swHp7Y1IySnK7SqjI0ZwETMCiQFL4qtsXt62ecCRzem3l5HiwXtfkYeBYu793tdJlcRy5V1PRSGkB843g"); + yield return (HashHigh: 0x2e704aa1e8413e4aUL, HashLow: 0x535c775b9828526fUL, Seed: 0x0000000000002279L, + Ascii: "cHahV0PeKgS4onXHTJYVusiYLXtbgXBHgW36ziefpkCzVBnrhM7N75u7azuu2wIWqkVAoOD0LHhN8MWeFVQsg9ErppcUE22HaCHyXwJ3PKwKf6DylWXe3QXzWMmGMcNe935CA0vBoQvEDA9EawTdxa03SgwUApCF3KcVmYTCA3rfKgkKlyp42Nz7"); + yield return (HashHigh: 0x052565cc459ed07cUL, HashLow: 0xa588a8a90b82d2edUL, Seed: 0x0000000000000db3L, + Ascii: "21ZCWnU0rbsDyYJIgw7qcYmRCOGF6cT6Ovq4irqpQpU0ATCqh9NvrrW8izTwx1zemE9PS1dxROTOXDLkrSyGBaZDijLUKHjnpLzd5zacpW0H6TaT3HL1pLm5K3obvwavi9V14AOvQGQl0DpgHUHpd5RFFDiGsSM2urjP2yHZrChkjwuKh6cME6Ik"); + yield return (HashHigh: 0xf612942c62c65ae6UL, HashLow: 0x38dc577e8251a098UL, Seed: 0x0000000000002345L, + Ascii: "z1ioVlUCa5wzoh01a4WOUhY9uj4fNcA2T1HiowIKE5eKPqaJfFB4NSlH0HiWpObtpV55ESYNeVD5gLSp3TOYgRl7VylkpJDUPjniPLSlfHJHVbHN9SIzEPqXn915PIFzrn0LoyMOfWyduJH1vVG4jHgNFKDRNbzIiaznFYUDfGAjmdqusykzTlupo"); + yield return (HashHigh: 0x7a86cb6d74f46f09UL, HashLow: 0xfc481702f833d969UL, Seed: 0x50d6ef30cff0396fL, + Ascii: "LHditi1jQVTporJKnT90iwBECIdcVV8SCfYL4SwEWYBQygOC523O4beSJERUb4FIszAvarFvFWUUW1ADGk6qiTKk8WJ6QVynphASLoBRP0Ns6KzNJGKBRYkm4MgFnD7klrBvmrMVrwndYNHcoiDiccHFX0tgX2v6dmYfdYmIA8JrpxxCS0F5rywav"); + yield return (HashHigh: 0x2426115c57801c4eUL, HashLow: 0x5a8ab15637d25c46UL, Seed: 0x0000000000000967L, + Ascii: "aG7JhuytrqbKSBeGsw1M2HFyqPldvTVLlhKrLFZre5arHSuTe7lAdoQkSRGn6Cs2pZXhm4VItNqsjvBEyPatyoIFzxNWwxkuJerDGDDqdQe4ZaA3CtxkwvYeyM1rvP3sNiLbzngb7kbSfaYNUcfrZQSNDn6NOsjL9JQAt5bFYHpdyQmVzIBVicDTe"); + yield return (HashHigh: 0xb89120874a5a751fUL, HashLow: 0xe4755f276a5fec43UL, Seed: 0x000000000000127dL, + Ascii: "O2FnWmdorQDXrcKFqb4LoICVEjePiqRfSoJj6g7bpQ7L8dIpKjAU1XYA5JYL7pSj04V1L4UZq8SNS51ngDYq8PE5zbMDflca7AIxsU6dVK7i0CusqTWOPU73I2XwjttAyhgO4eHLyIYkkd6rKMdYYAdKObsuLBOs3zDWkSXzEoUTjrcmAOnoSyAFT"); + yield return (HashHigh: 0x4a9437d7970c9ee6UL, HashLow: 0x34b2da479b63e462UL, Seed: 0x1f5466a634b2344fL, + Ascii: "7UKc1xLfwgsT6EIWH7d9nJ71CZKIlK8f14bJrGtZw4kSj3sBbOi7Et14bEOSyJv7iEOEpUdZr80FOZaZLe21rLXCpEz3eJKhcv2GAc5LLCoHGLvhKT02BoUJYIsTZGy8pasoGSVZ3y5nkO7q43nlU1QyuyI9Tlbp6qxdqEp10ZBXExjttA2ms8EHdh"); + yield return (HashHigh: 0x033043b997df9121UL, HashLow: 0xbfb495f480361250UL, Seed: 0x5333704f0de8d057L, + Ascii: "KmEMSK9wnBzxZZuLqHt3Rp7Ca8run5dGywtmJ82nnLwpgjF7ef82O7aiOuNtkOmIEPZVO2xGbZxWw6oLbarM6QuPLQxozommRgwfI9ANID1KlxyQfeIQCTZ6FxpjsysZhB06pTk8Ia7aSSq2y3E3z0fU7SRBZKdfbeNoG7V9TOEvgLaDvKMAjtkXS9"); + yield return (HashHigh: 0x8ce49661508b800fUL, HashLow: 0x104fb7405d4c12ffUL, Seed: 0x0000000000000d61L, + Ascii: "0sWIE1CjQRzucXici9FVQj1X5v15FH5TqDWr2mU9yBjiLg4wX1RzSREVeapJcqd3HOHXyc5WDbNawA8E5f1CNKobgNDvzudSN3B0DU8ThHCNpqeWJji8ZYOMomTzHfvJl7EfhauJEA2AbS6I2YrlLaJRnFsp1FxWZDP90wv35GjDSQgGfPQrXBDsPg"); + yield return (HashHigh: 0x5cf4819d192b144fUL, HashLow: 0x413a1370cb73c003UL, Seed: 0x0000000000000000L, + Ascii: "j4DP169lyPbb2ngAcgQ8zhCwwZvp8rZpR04glQVUuv149TPFjbM3OFI4AaR9tZ6ywHjI1dj3DJA2cosLJCSdeaPf61tFrjqL1IpA1fmyfZtzUjOC34DZ1hGCKwra4pcwNKzwFtgtvMQBfkoHVCeoO3q43BPFJLxRET8vz1cHQFXVdEHGLTxgSCfO6c"); + yield return (HashHigh: 0x4a60204af8fd5160UL, HashLow: 0x0b8fc132793e0973UL, Seed: 0x0000000000000000L, + Ascii: "QXvSj1TRkxyJ2oNPhfDScOxR1yysCzWx2xcZClxeQDXB6S76pQgMJ6frZW5WKRPoAfCrZ9qpycaWvRzxo56jBoaTaFcSMvAibeHRoQcSmKLMAX9cC8lY0T4gFjNkO2bqiRy5cUrbS1ksHotXiBQEuT7ukaj3z7qfTa49SfjY5M19c0HobFUAXl9LHZ8"); + yield return (HashHigh: 0xac74a766f3820941UL, HashLow: 0x5f5ac295cc8fb2beUL, Seed: 0x000000000000063dL, + Ascii: "WDiVQUckZZ9EdzM1Rr7X8Vy3lmiVQJjyHfXjptvM0ND8qvMrZU0mCCTs8JKCsxsRI0vJahOSxvJA2nmo1lBgv1WxMFdomur6rNmhnJT9BBoGNwvjkNWB1RaUW48pf8bjWHxQ5dSQCBurFIM0xSbzAMpD6fbldCHfs3rPCcM0Q5p5Tpg5qvMVMBq8YAS"); + yield return (HashHigh: 0x800543faf368d033UL, HashLow: 0x6fb501af8b02a5a4UL, Seed: 0x0f5a789a30d0d57fL, + Ascii: "ERqJy7lwgnX8MtZwlGqJDKcBH0oD0qen7ZhM7IqzYTKBZJeHervu5svOIBYpX5QL6yGED1clTZZea20MH1Vqa7TxlBNHqvVQgogH4xPGK3cZVlqs0707DtyX3d90t7X70ZFQ0YrAsjTgFCtwUiqiWBHW6jtOFjX5guRs2AQoKPDQRvQprHJqTbaJpL5"); + yield return (HashHigh: 0x60df6933e2b087b1UL, HashLow: 0x05b55899e6e495d5UL, Seed: 0x0000000000000b78L, + Ascii: "8qwcfLY0YL8Rhev6F4Yh2UFvKUYFwRNolzqxZWEYKysMwH0SMQs0Q6L3zfvuyfYVf1zTtxmgtc4VaU9w9RBJkbapICbz7Su0IbJrlZj7g5QnJsfX1FlcD3DXJSwFcrbmzUQx5fTqRUingqagLNu74Hk3LdhonukC8qUf2KXxNKlGNHUcta6bD6PmuCD"); + yield return (HashHigh: 0x05a220a112399858UL, HashLow: 0x61d378511b077d3dUL, Seed: 0x0000000000000000L, + Ascii: "XYn3EnzSkomK6EzY1PaQaoWertGvTTEnrS92QSFEf7Yl0JHfQHdH0aDodYrK7NhJPXKJmC0nJIWucSR3z5O1rtPfZ3YKjcemEShMTZLY5Vo5QUGVfz3qJLR8OJEbFuiUF7lebMcA6n8vTrkxNnAWFq3LeCuW33cS6hgoen4mUsS3aNVNwjWZYPKcuIxU"); + yield return (HashHigh: 0xeb34d7dd80c5a279UL, HashLow: 0xd67d7b4c5471d896UL, Seed: 0x0000000000001c87L, + Ascii: "psJi17TqMilZ9KIO1XVZap6eFczLL4WtHJiixM5ylMcrKiS2uWrZTnmsxTVAzzKEWN411xYRCtr7ZGIw35Mi7KBTH3TBULI5QCWYxucww28EZyUIC017YdDY1vZPt5H5je8qUux23YTXglhSqFdfDEyfDiN29q2LZFr8j7ro6rCW6k3qpqrzBzysE5iq"); + yield return (HashHigh: 0x27cc3347e65b7c04UL, HashLow: 0xe811b1b385409419UL, Seed: 0x000000000000023dL, + Ascii: "3EiVYxYs1VPn5fzkC3gpXJfakAtoeKnmmIoE4MOVVUf1ZiaRhd26wB7kec6I4vMtacA94aVdoY9QUEs3xdSVXXABd3IjjCjWLk6OEugYzM66ZJxKIdrKHbZ9znh3tWErWhlGxGVTE3Yi32j8Rud6JGf6WFgi2EZGsaw9MdeGqoNZk69GNaiPXocfNiLD"); + yield return (HashHigh: 0x8cc07daadcf457ddUL, HashLow: 0xf87fdb33c99717e8UL, Seed: 0x0000000000000000L, + Ascii: "46FpeGnsUKlV4iqKU14iUoDneTxp9ZhoQCscrpXrDYyntdHUDNtIQWYodm9PqZFwm3Dznz97I7inlhxPFa9m9Jq6ee29IvxaRbOo0UwQ8KE9T1AQTVFttkhkn2pZ1l6TKPsPo6wtCL9m2jyEvIY2HcBDQaxKSesVbCTd5Ufy0xaUm6o9Q06ogzJkziAf"); + yield return (HashHigh: 0xe10526f13c12ee60UL, HashLow: 0x93c6cbad90ce9eb2UL, Seed: 0x0000000000000000L, + Ascii: "JmNWKJBt4LH3rbfFyVyaPkNuwwwjTS2RQ62nwGQBwF41isH9GTTF8Wrwd6Y2gZbI5ybqIMxOFWnDWN3jmTIyjjTKxDteIRjP9iRtbFtQWNB9ptt7OzDnxVajIHrJI5Qqes4kMzc9FkUeVJ52iTHbaoczMksYsYCKPCGIXQN3zKtMRUhggHLP1wFVyAROF"); + yield return (HashHigh: 0x2f2551f1f7b7df8dUL, HashLow: 0x62a2a6153a624c4cUL, Seed: 0x0000000000000000L, + Ascii: "W6trZ2sxJE5sR575xVY5Gr1RXdXkShRgfa3xyqt670Zy7OnWKXwmipmRqY5AujAYBJy2YpPy8GbqwB7EbyqAawtLFF9L8aQr4vAkQf1oyVhWkeJ2PExP3X6yAgPL6SrJVSaveoUJ9rWgSKrnQgvw8i8TaTd7c5WotRzZi5fUHvWyu2AHUkopnN25wDZPr"); + yield return (HashHigh: 0xe11987cd53f3ee5aUL, HashLow: 0x956fe88548a6c503UL, Seed: 0x00000000000003d2L, + Ascii: "OoCx5frXeT5abvARZQF8DbdwrN3yZJlmd2l7HqH176vO2TzOeRnYnhsMygvpcp6LSJlY2XCTSp06uK4q6GLRnmpeRs5Wllft5WUMLqsXuT5hRrRGOzGQvM4iH5coaYMFn8YwvtB9sD6p9oMwOKaSVoVLHPLeUFLr65A9QXtF8Y1clukhKWepfc4EhTnbl"); + yield return (HashHigh: 0xfbfa6f369b67478fUL, HashLow: 0x481128de8006f74fUL, Seed: 0x0000000000000a72L, + Ascii: "PBCC5mjFekV8Hndfcv6jgSDcrJuLDQhIg9R4XISyapqDdSmk21al9rtQZkDztkbKNi7LqQ8aDRJnnKTfia5J713I7znjER5h536BmTdIHqUblGISBJgNgN7cURT23SfrJ4jbfoYgGWzm1zLqUWMuyMRDsAgfnNNrQIYG3TTQxtZ7g0BejJPKgo7CVXwsQ"); + yield return (HashHigh: 0xfc1a3a2ba998c77bUL, HashLow: 0x18d0a09d8933f273UL, Seed: 0x75db5b20f097c469L, + Ascii: "rvjxm10eoISk1JvBdZ0FtVfX3DZq0WIisqXILTnPOevfy9yxV6MRKg4DjaeT51OwU96vVMWD7lNDysWuJpnxO2hJrorItYjToF79P1eLRgOqApetmpDNxj7Dwuj2wjErduxt2AYZfduLB6LLFEjnvuegUPDnSR2QauVB79fTDvftTWzz73dIF29UO7F0U3"); + yield return (HashHigh: 0x3b2a3919ba67e333UL, HashLow: 0xfb1592fdd939111cUL, Seed: 0x00000000000006a1L, + Ascii: "ql0avRT5wcDNIGMPGoFvAnVnAFgvm1dwRmk18ZzQVYRvuldA9NoqF7umL1UOJrx2xOts7Xc7dmuWnKCOkH7YhnpWhGwY2IVwh4T0IWRnkZfF1kJXwtleX6pgErY2vfux7kdmYrx7LNjH0sJ0JFtlrXUq5KHdVWpOKFD5oMY0PDMtaEfgXF79bQtYSDyYzZ"); + yield return (HashHigh: 0xfa54c870d9f4161dUL, HashLow: 0x8b72dc86c8678a82UL, Seed: 0x0000000000000000L, + Ascii: "U3YUfYEra0YIs8gt5qsUVsSRx2swlTua0XpIgRwxlHFm2J8Dei6xEFxPA4BUkCSBvvQveo6wvtREcBRuHSeOmxgWecXsMQVzJXwdFiiYP5qWKIlNmNZGjvAvqPBFNzkfZmhR0BWMpwPMY7nB5RVKFyhAWHOeryTtdJkCrKxT8Z9y9Anhg139jjNeFl06cU"); + yield return (HashHigh: 0xdd54dcf0fb3fc438UL, HashLow: 0x9003a190f57b5789UL, Seed: 0x7f92fda1109c7005L, + Ascii: "UpkixotoQNGcONcTFsbtb4mcFM2w7hrashYpRpUc5F9uKI5h16RlvkqICfgyUEVwjvFfN8hFD6YRtV32c2KdLYWTX5di9tjhkWIBipThPPMmoSejZIWjE3Z1tjcgbbZb0pZFv020phWTeXxw3wlQpZWA8gFRckBL6tVY6oWtbV6gUGY7nJF69XXRbTCr1R"); + yield return (HashHigh: 0x4cea21f626653dd6UL, HashLow: 0x502ceb87c379b6b9UL, Seed: 0x0000000000001263L, + Ascii: "km4CV6neshlr0GzepVNIEnWXRi8hYyhmHiS3fJzHh4YbpdZAasUCg7cFr3mPMuQPqDDUYhZeqZhj0985eQQyE29kEUGSUqnxKUwVb4AGUIhIjRTGvocnEEF46MfmSh4vrmLz4aFn8toOYlpY4fZPAMziZOXEcSe1qXOUxypG4dkQFnxXU931Mf8qZzQZCD8"); + yield return (HashHigh: 0xe814d6f0e113b96fUL, HashLow: 0x21845c4bc1751820UL, Seed: 0x00000000000024d2L, + Ascii: "iOPgLWdCy1lrEuxUcHiPPSIubuiBiihc22LKoOqH1nzCbjFnm5TUKqArnMgnvmdSHde04Fx6dgf1bZSD0fML5mJnNSahGcxQiD6ow9KayC7W2z7Pz7vmDhKxJ4OVMq13fkvXcEDAj1MBuVQIZ0dmUsirUdomFQnOZkpD5XTJ2Usz0Dzc4vDsksgBF2osLn8"); + yield return (HashHigh: 0x49d5946ecce52836UL, HashLow: 0x264fab8ee4715ca0UL, Seed: 0x4fb24495dffafc30L, + Ascii: "Vleawe0EnlMWaznjUaZDoOjvEzt1iaWrmD33usV3KWps7BeoysYXDbl80iA2ZzjRMnjuN6YU8nSPRpSdJtdFwNSNiO7NguPGzGaGXbskQ6cduOS1LESdr1hEhQEuSMEmrhYkc8kETwwUn2fiHYA6yGxz86w9VRxMa2Z2zVtjrbT0Hx3kL4a32fXrao8C9Zl"); + yield return (HashHigh: 0x4960d28ad27aea08UL, HashLow: 0x73cafc7d21008410UL, Seed: 0x0000000000000000L, + Ascii: "1uRmqXqP3y7BezETYuqIb4eRq44oUDrQMiCzYu8Tl2eR3UcN04BRUljItKwjBSNV6ZKrwVTSqvHAjnUP4MSAMz2Rj6kuxj0NrXhsWonPPPeBgtgbyv7Efb4Y32nHHBwJv3eeHs51sEOpiqF2TJXRCsvzJ5lfqt7jicS3GEZ9PddVFSWohyvZITlL32y10J2"); + yield return (HashHigh: 0xe6fe970ffd59ac38UL, HashLow: 0x0575ae2d2d390520UL, Seed: 0x0000000000000a75L, + Ascii: "T0NKoiP1ejhTNTIjwlRjfhf8aRDsM8eOGcomBjvwm6NkdiS4Ap2okyONWEtU6ZB9btDnRChjgLLDikHqKdtDUCv7kkfATbaWxKsP9PXc2wQemb7azIxNqUtczT1BxMiOETCEz6AZ5YXmd8JRvvC8Ww3MUzfKK5jmFBeT8vCYBEVarhfHpK7PDZRn4u1brrlY"); + yield return (HashHigh: 0x1c43f33d2122e752UL, HashLow: 0x87e605489da106a4UL, Seed: 0x0000000000000974L, + Ascii: "e2exMRoBFO0WrmVhccHLXi5eucVyumPed5UUYOsYSzk3tstsPBEkmQt7q893koyF96vJuXJ5VjXhnE9kSPLvqJag15ORzCPdi6eJtshBQRauvsnIkxssAOoMN6rvR26UAOfj4srMrvsLpKa4qNGGR7MP6IrVs45FznrCys1XuxCgKFrGP0i6CPK1AoTVI5xs"); + yield return (HashHigh: 0x47660e95e2ae55b7UL, HashLow: 0x14fc34dab595ac5dUL, Seed: 0x0000000000002073L, + Ascii: "TSQqxL0dGMSGwcQhYaaoKOSeUZnATbGTJPrUhaa2MDMR1CWS0NFf0apxUP3YNPQwQXdtlaUmgMpIxEYuHWY2ZstR8CjtysIQbZKclsaTJC2ehp9MClfkRQTR0yGt8DwfFgicUMoNjF8bgfp9KuE5iBNBjpvVyyPw2Pnx98pWJCog3JyUCegTVSxO8cPoswgI"); + yield return (HashHigh: 0x860c1619cd22e4caUL, HashLow: 0xd532592a52ab9f87UL, Seed: 0x00000000000004f6L, + Ascii: "iXTGoPucJks6tsvfmjnpmkzfnTkycGlJwcsQVqWsp5ReZEceZcXrHNVfUvn4uK5jm5i0pLwkgHjraNM02wlGZ5AwhXLSXhea32lcUL0G9ArAyF1VEysZZkiquHDeEjxr00yKHHFyjrMrZrt5xQS03Pq1WR8R5Tp49CLNa7AcOuR8wnIItmeMZI4kPwdQCEUH"); + yield return (HashHigh: 0x3d660793218c261eUL, HashLow: 0x051b34110a3955baUL, Seed: 0x0000000000000270L, + Ascii: "wJTg47sVQ9N39ZF5ibtniA8XB0rbEZTPoIsFfdKEVEeGaDAG8abDD5Fa8Sjv93Jk1iNNKjg02Rkv0Vre4KTMS0usJa5fH4kJVHxPbJt7wyzMtEZBSnHJlxcE3tm2rZfD1Fqtcs4JbOFry391CL6Y4SZkqM6AJXYliPzxRfnZXMACCLCtrdnxLqUqGXeMPvXTx"); + yield return (HashHigh: 0x8eff2cd0bba2eb17UL, HashLow: 0x8aae0a364fc7203bUL, Seed: 0x000000000000124dL, + Ascii: "0BOwda1cclUajOSEMC2bGST5vm9ZtCE9ee32HgqtfIP6uA6rcS1P7aKFQRed2437Dlnpj87gY8xrDgraOmjf2ruJ6sQVo9XlbKRjmkvkg7RsoSIwelsoEBIXZ6MiadbyW65ynEf2m3vwD42DptkKBYBLqoTgAAyE8Egd3BspMQEh9OpYlpNnYZiDPJvZo8e3q"); + yield return (HashHigh: 0xbe464997daf45adfUL, HashLow: 0xfb70365ba36e2915UL, Seed: 0x32563880bd11daecL, + Ascii: "Mq86Fm66UGSkmfDadjSS3UQSbQxqR5Hn4AFy3wthh3PB9q0m4xyF9Ob1844LSQulwt43Yn2QTFsmSElfyPA0FO26NnSEhBQ6giIEsmCRTiRoav6gP4jNwK0UOr3zWlgprKpeDIzBDuavaEzLC8UImmoQd60CyOymdyQn1NEqnJypOC1HEVKENXIz8mrU514ON"); + yield return (HashHigh: 0xc8c19e2f58a8472fUL, HashLow: 0xa7b974bf25aa4c71UL, Seed: 0x0000000000001de2L, + Ascii: "50aHDDC2wpcxTjo82ukkjaWAak0xsVlYqeWABZwHSXB6EjsvTWPqxMUDLDk6IenJR1uErGD5CmFj0KkT1c4MWDoQjx3M2ooMmSe8Bg6iM0cO1EWxkFZZWvcmXh3w0dOJ411oZ5IHBx91mcmSomWr3OssJkqc0FkcJF2u3CM3ll4jMILl6Rj8FVqg6bNgSp1jB"); + yield return (HashHigh: 0x23220c656ae84b56UL, HashLow: 0x60bf84ebac2cbe62UL, Seed: 0x0000000000000000L, + Ascii: "FTwBoP8usBBvjMziZZrDaZfnouXR6nenK0TgWmKfsPybU7Nz2wVwp2srQMoEUNsAI0OnmHl4oTj3LOrRXQlirr0ALGTROHyUizVVAKGJsKN4TBpAyZGrRbqF2pDrG9rLbqOWVfjwTRvZns6swXKyEtcQWW0jq19j4oHhf8Wr7jh4ixAsMgCVvmqhJiuoTlKJI7"); + yield return (HashHigh: 0xfb2a4a921455d634UL, HashLow: 0xc774f948089c4fdaUL, Seed: 0x0000000000001686L, + Ascii: "ZXLkd1gbDppBcMhsne20O40Y2xygpbv94455Jx84KmQhvRtJzG9DC6nW65C12uCTX6K7J8PDmRhNruHDy9mwV9EI5eTgLFvMTApz3UXaFGWqAHQzsul1TdyCSGvkKoZ8mX3P78Cs2IthvaubYsq2Oyt8oBgEVR3UxwbXGic4qfnMVLtHygRIhvn2AkkXkh0QSv"); + yield return (HashHigh: 0x0dd9408580971eaaUL, HashLow: 0xc37815bbbf32af33UL, Seed: 0x2bc608cf2207aee5L, + Ascii: "0jU730nzyIsZYmFFEKW7LqzjhNFOINPtcIrGKxIRn14R7DE6D0gV3Ujw5Tn3CHLpwlEucGcAH3DKhZOexmadErC4T3Ma1QC5TgvZ3qcwcpiuBgXbU6ifMdkTpgx618rHvyKkJG1n74HRwKcIJWgN7j7xrCPjOCBU9s40H8Xk2i4YnS6kR1wOiRaMeBame3evyo"); + yield return (HashHigh: 0x7a5d13bd58ef273eUL, HashLow: 0xa8a9a52dcab75ee2UL, Seed: 0x00000000000009cfL, + Ascii: "VlZBGeqf7vixsvJNQBhm6bYGwri41Zvpc4xzrWX51JjtrYRfOzxXMNDB4ZnyW807FNTmQodYQpULseqOopIMisipjHszqUoVWOTh1J2rBgTe3NiFGNC5mvLPqDrB4el08a88298Weg1LQZH4ZpCTgwgzS6VU0K45b0XSZwIusVykz2du8yW3NELg33X1mbWoNU"); + yield return (HashHigh: 0x8475dd060f60fc69UL, HashLow: 0x0edad37e205c1287UL, Seed: 0x00000000000013b2L, + Ascii: "kfOh6LpJy1c0R9OfjpumomrPdrEQWkY4fEFsiCAqQpU88sCKRDHsRcCdXB6kZRnpL907YTb0Yb9JPPpDUlXsxWKQkntkjFOKURvxVWdPHNfV7hWG5OtmwfvKVJH6sQsbtlfRC7jGH7JqDUF7twv6rNcYH8xA9St74f4rINqRR3LzlyJ7dFqUwQNPAKK71vNgI4h"); + yield return (HashHigh: 0x3feebafc79c6e690UL, HashLow: 0x8bf036a3fc566396UL, Seed: 0x059e6144ab7385c7L, + Ascii: "E8LvErh2dHlbiDcIzaz4bTJBcPPnI4jREgmFX6i83SGvXG4ezYf1b19LWXqbDD6Drg6aUCIoLSh70F2wcNsbcviDrQr9DzazOLYYQNWBHWtrWji59OgLXu1dlJFQIdX9ZjQIKOskeexktDSixJ6fdfWZ1IH0cYbg4baMDzX8GmTPnBuIoxnj0X9JiWDCuyNjBPX"); + yield return (HashHigh: 0x7e134f3caab01aedUL, HashLow: 0x95545c39856041c9UL, Seed: 0x00000000000022ffL, + Ascii: "iTWosRgGzLwZXX7UUrqI7OLPrcNVZGDvf9f2u0TmkLLnRUvK1GdVoQrykfcUC0wraOEu3F5yDB6AEYSpsmek9kiPeLxkajuPkvIASVvF0VJj9PLhXwS6eGsvrrEDItewb4HxEKtQurBtqpIagjWkKSb3VfiEoW1EzHp46cNkcL7Exd4YG3N8Plixy0N4tHh8nrH"); + yield return (HashHigh: 0xa71f6378d079d547UL, HashLow: 0xd59af747daef2965UL, Seed: 0x0000000000000000L, + Ascii: "zTPaxuYpXy0RMWlEPzUHHSud1xUz4zXnHIsxvn4u07SXkkVW6e4VkZV3u7KsNQaI7y7jYeoAXquNBzMrTfLfPEWoijoPGaMiPJ1127GwFT4yuadB9ehG9PXeFpq8js5eJCgMGKPJWoYT1xR5PAI9YyXNZX6PBPNJCJFV0uQnEoIWo1ZZIfoX6rl0XrkLUfyZiD0"); + yield return (HashHigh: 0x983865a285dc7fc5UL, HashLow: 0xb21a62c104658163UL, Seed: 0x0000000000001677L, + Ascii: "okeRXrWl7WKE0rpSq2LjGbWDJjsNgHKRlF1a4DQ8M3gyhPQ9k7qsOhHcYXhHBHJxoa2WruDDtO2L9iONUpmW1jqARn8S1DTbk7TMM9YWtyeIgirAEKVyeQ4Ibd7FHKVls3AOtUYoH7aGrDFkLgPdjdtrjvVDBTODFI0vM9RUOYlAtuHUXredKtLaMlnRZYsLfj6n"); + yield return (HashHigh: 0x7163ac5b43bb2515UL, HashLow: 0x6e50aa0641caa241UL, Seed: 0x0000000000000000L, + Ascii: "mVQPVPD2S9zDg6im0K04xSDtxJXYSn0WBtOjAp3ZmosraMtSQ3EfOURnByQDAtCrUE0UZqbIFOORusqZmU00GP3VLD11JQ17GG9JwRd4Zr2rQiwmJF0nCyexH0vhUAAo3x99951cn9tpFM2tkZBnjSKalgh6gGPZNtrWFmMYZo37ClUPXgskdDGzilIwpUInzg5x"); + yield return (HashHigh: 0x6ab0824846cfaf8cUL, HashLow: 0x8e67e6058b55ebeaUL, Seed: 0x0000000000001187L, + Ascii: "SNsrE3l1LFCloXtSEZT3wmG8OmSxi8CLJG0Oyjxl7H5VkAMpgnfb0D5oXRq5eo0kIYTsgwVcyw3gx3GJZxWJ1UWZXGoc5tAGlURMqomHO0YqmIlWStQfa7oUi3qvcdGBAXwnRXkEvliAbx0X25fpTVhgEUJMSrR9PREGH0wJW1aThY0AUsEY4JRAcGMe5EVB5eo6"); + yield return (HashHigh: 0xbb7c982db9474694UL, HashLow: 0x545a0cf45fee623cUL, Seed: 0x0000000000002448L, + Ascii: "4gzo7Lxz1oPfOsfDiomHKGFIb5avvfVOQXtSN1KcefGd4QmabYXPDBN9Iq08jEIK52ZYHRIB35zrmhNMB7rVdqdH1uYdq8mQeFITakHEQQfUktQb51YLAFgoEWn47GKMLXHctmlNfCCmXHXCiMca1WHJrenVRnqF8Htyglc7pqK77wXLwKPcmOU2nK1C2vJlg3RZ"); + yield return (HashHigh: 0x0a15e68a034d9c7aUL, HashLow: 0x71ccd190e6b75777UL, Seed: 0x0000000000000000L, + Ascii: "gxD8dp9Es2jaH9Fp7sDhFo9O9dutlkzzf5lbY0DEeHANikDwZCuV57OAPebSXMfDg40gZCcAyWfj2J6zKb9kLyke0hAPK0CGGhSocwqQFOA2K7MZCFk9ljI2y7r0FdLsu7xcWy8S6lCAvNtxv0M6ftPQWDFQyRwehmpJUBwewOuFZ7VZbaGidfPt7j8AxSozVrocU"); + yield return (HashHigh: 0x8e9642b5e60ada61UL, HashLow: 0x3aa569a04ba548d9UL, Seed: 0x6bce3584ea311313L, + Ascii: "xGVxFjsFy5GNRyTALes79BwSPskiYumMr1oNJ06heHqpdGUJHjqfuMp9HR4bXcnDTN5p1tdnLN6b7Wkoz87B2qrgN697oPS34WKkcACWbwHo7uawfjJagfG3GPrBbRCJJhOuRrw2288s0DSXZQVpTCjhAygQE3pdHOv08rvUnorPJgmChV4EOWbu5TYiBC4tDTjKV"); + yield return (HashHigh: 0x5e32a28735e97926UL, HashLow: 0x0fbe4d9644d9e453UL, Seed: 0x0000000000001c2fL, + Ascii: "EINQYV7PKpQRCBjwXJINeSzcigzh8DGR09DeVLvpmqp0sbcuPeQEjCugarM9tNOPb8kSSfrTe36xHrz2i4qL5ePIx6a4Aypzi4aMs1x5E32MKIyQtsrMLPWhy9hIvvYIB8xQYBEBDQFvzIKTJ1eoIR25cn0u6bzH3O4IPqGzecHbRm3mxIrCWq7CWgVLI3AHheMHU"); + yield return (HashHigh: 0x35bfd4d027363204UL, HashLow: 0x572346097822beedUL, Seed: 0x0000000000000da1L, + Ascii: "st05R0wLsgNC1YYfCRgGe3r2HnQutl3h9R1Yxqdr2yDFcNZZYFOScEmrgjbnD63nMwrebYsunf2graifBydzdXW8boxF31oVA9gGkwNxPWRmzf3RdH3MFFt9DNK94uyF2cH0CEVA3hG8J4yhJLoz1BQHgHEK4p0sCkMeRK23XAp3xVSMnpaL0OCyZ8nGLYAUjVjhM"); + yield return (HashHigh: 0x5b16eebab182d6c0UL, HashLow: 0x5e343b99c20cc4b9UL, Seed: 0x00000000000001f1L, + Ascii: "eNVVlGptzIUZLWdU2T8l8zVxwo4NZGGMYVPQjHfHB1tD4CPxPuXvnBF5AVngIZRSiK4ZZXMbgBgsCIteJzkMlMUVz05ZsIRSpIQK5eFwLsDOGLfiaTb8Bf9tsvg5EijRqMSJUeJAwJ3JGIHRbvnWoVLv4kLvUwsjIXcEOGxSEUaUjO6g1JZhlj4nn1IbSniaeTrWuf"); + yield return (HashHigh: 0x8f4a34c6b345afecUL, HashLow: 0x0737329deb2c430cUL, Seed: 0x0000000000001047L, + Ascii: "0kv3KDl6zCMnofBv1kDEtL3Qo6F4pF3ojNuoUQDlTtbnz5AiF857PKJg1zwomMw6uNKJLDMYODmJ0s3x3KEmy9ueM99Wpmn9kVtniusi1caGOYAA8cOrpNtmlzZXR1R7RkS9bbj9zgWQVjoaUW3LGuOPOrHk7X06fev7ftKFJTUCYlBoCI7EehaSozTHM17c7M0DAs"); + yield return (HashHigh: 0x3fdfe9916d74b8a8UL, HashLow: 0x668cc92b915b5505UL, Seed: 0x0000000000000000L, + Ascii: "A4rHJS19TNCabgywUE0pljIza5JFJ9UOpYXI8g4x6AcgXFaTETYhF5dkO3lHBM9twkRhTeNVtgq64mrZqXXKZcE9JGgnIbp97BObIy6TfwqaHZGuKPYHMbxVd1SQaGrbPydcDqiYOuH0NBMCWf6tltxR587HPqX3hjNxbjVJM23dqA9OHygWm0X3PZ9mTcIHaCR5J3"); + yield return (HashHigh: 0xb858ebc7a33cfc1cUL, HashLow: 0x97eb03ed94b11bbeUL, Seed: 0x6eaac083a09881cdL, + Ascii: "9y3Te5AvOOJ76IxcjcZyCqWacELsegeusXL8p4JmCoiDk4x2afdSOFWLMcVYNT0MqtbewJmkuNYHVzDwd6unfbrtuXZ7YXrWrMteD2btijMlpKKy6DN3rOYsz5gEF652OiHAK2clHqegYzvWllL92h3AV68t3Ots7RIwxZpuwils66gpISYWGeZwzyUVe136OLZbBf"); + yield return (HashHigh: 0x87e19c32b0d78288UL, HashLow: 0x77e0cf47b61b8c13UL, Seed: 0x39b2708786296a3dL, + Ascii: "77GKm15HN9YcPLaFCjgHNheN29NmvQdYGgwhrbMcjECG7bBMSvlf330O5maD00Necro281700cNgSb02HqAFTAqqgStbtcdgbiAiTgoEpTK7VixXjRxnUfGRV0nubNgamyP1gVxGLcXbLQJxm88Qlh5jYYuofHg59VOesQenJPBZtXSlPsTfsQP8GR54AWzhhndfUR1"); + yield return (HashHigh: 0x6fbaa142f0df6237UL, HashLow: 0x9a7dcd73db310ffaUL, Seed: 0x0000000000001c20L, + Ascii: "prtgeiSM0Rr09rr90Q4i6lTfBQgI9pEB69QysRc4tkJVu83b7bNZKvLaWZxSZ5PngjF29h296rfKs7qzVNHXYjGvASFXmPRpB90DQdcXNFbUB3OEnvklMXyVLXizbjGlOSTRzqESiLYrOwwVWDurIedIRp3rBKYaecBrNAIzWlXv5sUPPTQDcM3fVuHIHmb5Eo6fVfh"); + yield return (HashHigh: 0xb46638f16268a657UL, HashLow: 0x0df797c69706bdccUL, Seed: 0x0000000000000000L, + Ascii: "QFFMSp1luSh32MHpoTC24NHOfCyIGiBdyoHY9njPElMQnDXsNIfgtnVs1TjiSDn0MIi0d25cuVjdwEcYI4ZoTECHazYQcSkvzxn79LjuK21Urha09w0N2lCyv8pf6XpJBRBEyKQS0v5nSIQ48fVTaa32AlWGZRiTi8FbO5jYz4l4QVoXlXN4qzROPsjOQTg9o4LGsXH"); + yield return (HashHigh: 0x36c92e2df52eb59cUL, HashLow: 0xe424e61f62f30bdeUL, Seed: 0x0000000000000000L, + Ascii: "ic5H6y6VLOh3d8LxbBkaCsBnnK9DRm6BoqMJ2ty8pzdTq2S7vY7SIgTR7illK6360xrqSQrlh9asCEFlLm8cUUDVkPVSgjaZbtamCC2Bxcz4QghRYQlQUHjN5sOjLqN1LgLZLQFKszjHjQTJdj4NUr09tbW0zLA2rn4soutXq6tAix7JozDpLH7yXShybA4PiSRWDbs"); + yield return (HashHigh: 0x6a2924e1a97dd7fcUL, HashLow: 0x13ed98dbc25604f7UL, Seed: 0x0000000000000000L, + Ascii: "n1bjmOYe7NMcghKYScBlGRVTtLTlEIODjxY9CULIHdnDRSTNxmfquaHDy9jpss9VKp5bDpxLPg28uUzs0ZdckeSNIfprYlQMGrUdgqDgRWLJjML01wIWkAa0ei7ngTCfpFWBX1WZIvpmgLzybv7ieU7uOzSeDFGAM1c1uP1sEkSvKPHDSUDa6qx7q9bdrDtqmg1TsE8b"); + yield return (HashHigh: 0x046c7ab74efd2742UL, HashLow: 0x8038692ca26033e3UL, Seed: 0x0000000000000000L, + Ascii: "ERu1x9IgVGUehmOv54iL0asx725pWMTcWZ1a7BykhIVyvkT6TvujesPBT7G9uqbxr0vPVIZKhQk3eoCWkN5jNaHorvyBzGu9TGGDIPLCNfICmvUoZQ3tCDtuU7a8uR77X0xPaJghT49EibKDv83ITUue1SXYKTOkyMcH5K9eEOy1q1zGwu1e7rl0DQaml7qMcRX584zx"); + yield return (HashHigh: 0xb5d837874a52973bUL, HashLow: 0x242c8ce2f79eb12aUL, Seed: 0x00000000000010ffL, + Ascii: "XEOAfSCaBmxlGweXaEyY108UlYD2t8KbkJ2F6KtevwvZ6YuDq1WwmdsRodUygwFsPsJdNCzZXTznSFONEX2BAqxWSJCdAc1vRfu4ANZZB3gfXH87MqJCrY8A7945ikpWH0GqCXojfhX9QMhQz1JPOGyE1MP3cwCh5opqMc6t5vP2DUTjXmjXCWyiL2PS41S1Q9zI29Gz"); + yield return (HashHigh: 0x85c31e633c183a0dUL, HashLow: 0x4f04b67ce498a52dUL, Seed: 0x0000000000001f51L, + Ascii: "jdSPmVTMfYXDW1L1IkvTlrfNHQdV00qpWXy2yMr7Ivzqm2MmUiqTO5euIDTZ5k9VcaDccgnGKDwtCzpBr8INY1a501XfYXFqiK2fHoKWMplgHpEt2EefKvhyqOXL4JYslL9X8qCIhQ3dDPM8In6xHN2VNqPOs1CSb2fgoziJaXTQDFHSMIrZ4JQAIMG65FStArWr9pEQA"); + yield return (HashHigh: 0x11fffd97f017a713UL, HashLow: 0x7dd53baa8a3ba4caUL, Seed: 0x0000000000001497L, + Ascii: "BMLA6WSGL5XzfLmZLxIhOVXEFbbnkzF6gdgBkYI2DDOSVrl03TfCLPKINF1G21TBUcWtSd21llrsskrvmxW4R3uX8nd45IebrxeiwEFRgnTg4iMNDibzHnUKqoitQTXPX9wHfVVLF3az5zHKPOY8Uoe2vdvLtAdKmXI6bfQNjFj5s4MO3QPOGBh6JpHvgWVEaeh7vd2Pi"); + yield return (HashHigh: 0x6f1eea0e31bc14a0UL, HashLow: 0x72175fdc15f3690bUL, Seed: 0x00000000000006f8L, + Ascii: "D3BRDro1Gex78qmI3VE9RPAlgYIISaOXtIADxQ3T4K69WkIvXs3ohlE70uQ1Hyg3Pwf2c5tUCdy6ERnwtdQyZEBwLCoDhdTJ4guMEQxjlskIBRqiHPjijCH0pOnZcdkMMoHqeCLakLu4LZTvODHQmy9e2MD0gkpaf215cDvaL5kHTzPFK57yu489jjJmBYXcqjZ7DruRk"); + yield return (HashHigh: 0x621cd36faba9990aUL, HashLow: 0x9183c4055827a563UL, Seed: 0x0000000000001bfdL, + Ascii: "quTQG0dSEVNxGVWXbiSO1E4liYRLRJFVHEWjeXheBmgMTNqeUT4jRpb5KjsOB79xgHxWAAY7Aae8lzcBwvDP7WOtrhFAyMX7sfjqRcqWLALY25Qplxjla7H4XcC2byr5IzvEebp9g5pZcRRWAWWruRq60dIy5d5GArn3iuJ59KB2I4gnXGamTVObJfp9o9BJkT3sQcyxPa"); + yield return (HashHigh: 0x292dd6d4c9151e40UL, HashLow: 0x771b6fbca83d29cdUL, Seed: 0x0000000000000020L, + Ascii: "44pAhedm716O8ozBEHOPHNzDvNXZg7bV27TZ2GwIAAm1qO8cSB2yY3ickIycyWxuJSjQb7561pLhMXnxyLvGQhtdSyaCoqld9e1xN88mMPpBTnk155HMcBiBiQxsWKDNLBfiZgv4xlvWYJIaqSfARp2ldGdR6k74GHqbwwUPz0jgbzNEk5oixnWmrC82SKxIm1kKp7MAJM"); + yield return (HashHigh: 0x264c7789459ae772UL, HashLow: 0x0e2b371ea14491b7UL, Seed: 0x000000000000006bL, + Ascii: "Dam42yTDJxhGrApDgPFKv3n88kjSe9fKNB2M8MDOVQ2qFK4PM2wxwO1Eaa4ccnsdokM8Crx0u6pF4HdUt0bNld3eNZ3mIxw2JoeMFPM7xzUBVeKX8s5Dy4hYbUsqggVUn8geKzEHLnB0lxAkJH50lkjWnSluE5yYfZy0aJsV9BQdy0MpXON8lm5FFI3QDPYUjiSfpHzH2D"); + yield return (HashHigh: 0xb5003afea35e4f7fUL, HashLow: 0x3becc1573cfb6078UL, Seed: 0x6dc8185ac1bfab6bL, + Ascii: "XMiqWzsuc4z7YaloyqlKs8vUVGd63MRjice3xtKUElzpdai4dtxqw2ji2vKYtR9qXYTGF5yATxO3C0ZJ67LXbuvgiR82hLgM3Fed2u4ak57qzPbIaZYRGP2zcJ6gzgCjSn9jEFlW0jdCXlhi8fxUAYbfIVZM489lRfYE40s6WDj0bN8UOrKQROzgmp1sjwqIbh0tdFgmJ2"); + yield return (HashHigh: 0x68b01827f4f7e838UL, HashLow: 0xc262473653102a4fUL, Seed: 0x0000000000001febL, + Ascii: "qwHb3J6hfCjldQULb2ziSsUpSBN5byCXfHa1Gj2OVQSw3qjnD24bTXYgJFbGEpPMXqrjguJ859Wi4DHQHxNROKFrq4tHbutxdKcgjIEwrPmhSSyNkJ61wTrjC3EFzM6aLdpnHkiOwy1kziYvQu0P9gKfnFw7d0iKxREUDZX2rKppgzQIvX2dAbtV0zgFIJtqBxxiV3nCUDW"); + yield return (HashHigh: 0xe23675cec8c70639UL, HashLow: 0x899bf435b566a0d1UL, Seed: 0x0000000000000000L, + Ascii: "RtaMs90IiMkoFim8fC9ffiV9Wxq6kdyBztVIAZwg5Yo7SAaqvAeUNnV12gGDJ7FDpP2PnCuqP4mSnKdlDAonWCnWEtek3tvXpvcZvsOLdD15Q4UNXkcc0u2XZMVIukxWn6XXAGpfAW50iUxkRpxqzmQkdO67NN6JDRDLsDNmhnqB22dzfS60qEj2h4q46E9xitSLUvNP9yF"); + yield return (HashHigh: 0x148d77e4199d5df3UL, HashLow: 0x0a501bddccc490c3UL, Seed: 0x00000000000020edL, + Ascii: "g7swABpjAHpeWeXxNzgoctMEw5GRPQV9NscbfeS93kOS2Puld6Ao9ZtOTHxiZJJK5UHxcxCMccpusRDjkOgkW8KggS0BA3dzN6TZyRoiGffvHLOUuArfNXapI5XWvxGfslvbtkbwNQSAd1w6luvIpBBV10Le9dKU32UfO0kaEsuCIHSnZBD113IC1Bu2P99wbnv4tNzmodR"); + yield return (HashHigh: 0x3a2c68dc00fa2e90UL, HashLow: 0x48eab1854370b089UL, Seed: 0x0000000000002162L, + Ascii: "l3oVf4xHK4lGNoBzZY4r8Az54QI4TE1SRkWGBpTwcBQvZTxDikyKjk5DUjIdypZdQim114pyZoIgfogQfPSKjUtp5JRfh43YgMAK1SHydH9dqWe46t5htTcFdpB8rw4aXxMntkLXfj56KbTfy2ZwlVvFAIq3A0FGQHuxhbuM35JUOXjzBLdU9hzq5v6VReuw9NjxyDVoS0Ti"); + yield return (HashHigh: 0x8b7f7c665e5d6e98UL, HashLow: 0xdf1e27cb971384fbUL, Seed: 0x0000000000000ff6L, + Ascii: "BseKYldGrJmCBb9BIoiyKirniQwAk3arxPhWgiv7DZSA3RQLZsZGtRIbPn0w8Ql6Tph4kXbux4y8HWUTkQF6mbYMUDpZOIfg1KIbdg5xBkZ7LRAgIGJ0qa83A1Dc6qI9I5Xo56JiqIiB86hnla0M44FJICRxIhIQnKL3iQpF86WrsYphZ7zIOEocnrRr4YlHzY3kf2WQmK6O"); + yield return (HashHigh: 0x4230960da9a7698fUL, HashLow: 0xd519f33cfc970895UL, Seed: 0x0000000000000000L, + Ascii: "kE4ylCzKHAkVdJjliNIUitJhfmiGZkKwZS5yH32uUGbzSIMQnq8sy5ZgPGeYkR75RZkXoc3z2r7gfQe45eQLpq3ZhTDTQvjKnNYG6aLmLMp4VknmdFdrPVi1xz2QmHuSlX9ix5AdDr2D2SGxde61EJgLD6PZI45PxA2oiGyVTO2MNnCt6e1gLmd0O1HPeKTCr5eS7ZFKAW4W"); + yield return (HashHigh: 0x559d70ec41355841UL, HashLow: 0x3a3133b9c19fbeddUL, Seed: 0x0000000000000000L, + Ascii: "6y5XD36CB0vckoWi5CI30UrvnzasdfUlE6cL2GnIZMktF2LOcZY1xLcwYh4owhjefTq6vhzMcVhnaBoUOla0rF0f69g9gkOdDM75tSaEuEVDH3QrdO4RKKJPOomEGKg6KJbr96T0TRn7Kv9T4GR9rhooOVcrUY4qb2q4ivf6iDFqjRHCPonujUrin6Z3njm4rBeTtYxcvcAE"); + yield return (HashHigh: 0x9f5d9465d7ad1839UL, HashLow: 0xff1317c5a7f84ad0UL, Seed: 0x5ec61bc65ad53a22L, + Ascii: "3uySfjNQ0zfwIUgov465LnZFIORkQKzY35QZq3KvBZtARcW2WcUCiqgnfFW6Oy7DpvdGOv7eyQgIUWO2zwGyuN40wJE8FfyawCNJQOb0gFfY3YxWESPm0ySzcfBLqtGbQF4xYh3iuiDtadAgJhQYVDSxeBNPBXeuElbH3uz70YVP221D8Yh5dfdLQzINOKMZWUKaHxsxCutbb"); + yield return (HashHigh: 0x002976652cabadf3UL, HashLow: 0x0280d170033eae14UL, Seed: 0x0000000000000000L, + Ascii: "qg5wjwRmiVRejyh71UouGPimOCCXJULeY24IamrLLSdzBnehynHY9SOMW1ME2Otvfi4Zg98XjpNeTvXRy6qGImq02Fgsx1TBnA94EhidIx1edpu01NOSJ1MtqqnaNeNapoLkcqsYWKaso36ExpO8dZ3McTfMEOaYJFeg03fx0GBvMc56kAO3uRDXsXQvy4xgzs81HQxVXoWDu"); + yield return (HashHigh: 0x3efcd7991ba24627UL, HashLow: 0x19a6366d750dd702UL, Seed: 0x000000000000266aL, + Ascii: "UOmbwzUUvwpnkCO5iSCT619bxqlBAaoK4zp57bEEiWz2jzVT6tgw5CFF9k8GeJjLiVaeW4EVckbjQ8CAChDBST9jdf9rYHfZdZuVqK8LKBgn3FoazV0mPK33ktH2FLDR5ySe0cNYZZBeb8c0WptKwUzcpZ2g16oa4D05tH8pdmAOaSOFEOZeFHCS6d4wsnl7tj6m95GJP6g8i"); + yield return (HashHigh: 0x82d14d147a7e0edbUL, HashLow: 0x548470ddccb70303UL, Seed: 0x0000000000000174L, + Ascii: "8c94zFZDCvTGUQ5TzF9N5cuFHcvgnbGvqEF4cEIH7iThoTf6UFWkKZCRkW7Z5QanapN2v5WOK55wq8UDvvhIQMZJaEit3LftlHkS5kiDrctm5a9iADx5H0N907urfepAcqQTvAMMijIMoAICao6gmm1r6FbiLANoV9KlHGfjsTAXZKz1SEqGq3LXHzgJwM7y7LSOBHN3Irr2LK"); + yield return (HashHigh: 0xcbf944231f0a207cUL, HashLow: 0x9f63d233df85f142UL, Seed: 0x0000000000002707L, + Ascii: "mX1PRUJrik1WmNpZI6Jtxmv9uGNI3sZtblIy5nk889Pi4Z4QVQBgy0zLoywAelB0AUAXgqKrGNlmuakSLGbYyvE1PpZFARPEmugjI2hCShCLKtAZrmpwfISacGQ5NY9UoW0YUXKzknxjwhIwrDtGMsaStLEpMjDUngoKCectL1rJWKMlxXZd4s0jfRQEFuClCALF7beEqJBHd4"); + yield return (HashHigh: 0x5ad4b7cfe6da1cdbUL, HashLow: 0xbd42184be21051f1UL, Seed: 0x2e52512cc58aa935L, + Ascii: "4ztdsJPql9TZC7rzDG91MxZjNO8ypBpxScJtI9c7NPkwNVK5idy4FWneFiKUl0kFcPl01oMV1lRU1ix1fUxPqfsIdGyWNROz0antbMTftAzRXc62KYUjGQ5vIVcKY96J9XIuMO9ObRku8xalFx5MW6PRjet7JqjsRyLDFDva6Gyfr5rxIczIwQtbqJ78rqbCvWaJVTvTmPudph"); + yield return (HashHigh: 0x6fd47ff27b6b3501UL, HashLow: 0xaf95d8843740717dUL, Seed: 0x0000000000002591L, + Ascii: "D0oqONFjsOhHnY2DTEA2ybfWknu3lb7mbrOqtkITu7BAw95U9lGAcRInCSrbDL0TPwwkMsgQnPd50LronyOjZ1ShT1CKx7MnYmFxFg3cajqwJQ33AIiT5ZmlQJBXhi16UCORA94bRzDWdiupox665G9CWRBKAJZNbfgdjVI5tEm54hBuwLM6QUXIz7FabRGAUJFaqu3tSA3O4W"); + yield return (HashHigh: 0xe5b4f03fc446e2b1UL, HashLow: 0x391ad12eadd57c56UL, Seed: 0x0000000000000368L, + Ascii: "03cTK7C1gkwEQVwXlWcXh0ESkvbCrckJ7E6WoYuEDGCShmZ2xRCmlx2iQ48WcLseyvnP9wDbckI1O5VH5NIHT28ArVU7oby6xijPbXweKup3dpxUoI9LnXkr4TQaFLrWPXwuGgZDevkgtkBapBVYxuMlAnqf5tNb6U9RyXo1VFqAtMugNbUSxpGIzbJ2NQRO1k6ZpWsf6elRxMr"); + yield return (HashHigh: 0xea149c8374140053UL, HashLow: 0x0a52f4eea9f8ef1cUL, Seed: 0x000000000000080dL, + Ascii: "iPH0IO7cO678mdTWSaBwwVgJv3ttUh6aKXLsHdIAyjAw8smIujFRccrU1Es3uheBpwsjOAkwPUpJLkHpT1ffuAbURkMpCv3NmYkvQRw77EpHjp099t0iq8O6CBUF6yigFigCRV0gITw23SZOtfOPJuC2f9nPH19hvE8eeBy84nFHQkGhB6rSKnqivvszMFSO6qd4qRSibU3jS94"); + yield return (HashHigh: 0x6ee146ebf3e805fcUL, HashLow: 0x00330c645129febbUL, Seed: 0x0000000000000112L, + Ascii: "hW16QQ7Pv5H9UZK6FbXlLgBkAIBqO8YxOqamPOPBQ9SErhI9keLHzhRMVeL2kRpWTO2Jp7bKDZPgbZ60VImXtyplriAdLiLFTIyMWYDv3TTI0Zhr3bFsqrOoTqoiIdp1TdaeChOkb6fhjgeJmOnEQVxFHQVQE2Q7fRXucnTPIWRAs8L4PIQL6m5DlDtXKzv4zs0P7n4knxLj7pi"); + yield return (HashHigh: 0x20c75f753a84e616UL, HashLow: 0x0a09fc82b525e063UL, Seed: 0x00000000000019a7L, + Ascii: "IXfuXoGOjZYCriurKgpliUAfWM0obqz7Z7WT1Iedk93lZhNtoyjbY9gij743SAAK4q9Cvr7pAsndmTQVwZip1aUc81kZ4ZKFNU8EURL46wAdlTgD97ZEEmYwKuRDzNGOctDGYwLovP3YE4Uaj6Xj24egfhyhr9dSoWYOxyq9Xex2TLDeiuzkb2T7fxgwCQPcvHPUuTG1khSobRtI"); + yield return (HashHigh: 0x8793ffbc57f0056fUL, HashLow: 0x8871175a6ad75119UL, Seed: 0x0000000000000adfL, + Ascii: "n5jaccam8c7bd2y6zvSxJCEcLJxeQ7gRVcOsTtU5TMHTEINp2DayB2imv8ubvJLOjQ9XHej1haK5KXqoZysIsrGz0aYYTIU9ObfOgkzpED6kLPwI1PyjpMKCcOCD6TLHDZQsxs4e0ii2YQaNmRJpT7tZ7thOwdRv3KEk8SU52eAGGXyPc6IdC6OBhM6lfjRFxpUhuD0LNMjZztoP"); + yield return (HashHigh: 0xed277518761d2400UL, HashLow: 0x6e98cea9d0f353d2UL, Seed: 0x0000000000000000L, + Ascii: "0B1Ow3HA7F7eGGzheBNspjxVM9vMWCdlU3WLZlePxFSsGP8X7vwDv6RaFxQXqdxsu1P6LpblAM6e0NAnYQKEa4Aao0HI2EpnXhj2rk61XKXBBnMg4fSC9uTedcfw8rOk9Rryy7mnEdp0Vb05Uj5cGVEtLVJtWsWriK4uYUmnjCxdb3EqYYMEiAebJf3Z5OevqvPThgbgLnYRDiXp"); + yield return (HashHigh: 0xe65fe3529f3aec6aUL, HashLow: 0x1bcd7610ed115cc8UL, Seed: 0x00000000000020c4L, + Ascii: "Y3qZo3vgY78iDqSAKtuYPdV5PSv83nq9ZbDgEmq1DXv4T88joZP7k1Cx717NvuHTaQmQcJKM9S7G2EMoFtTRCJMEahuNF3DAvZ64LJhupjwmLo3wy1DluDKZUPglYtNVA5qhjwkmE7ZTr7qWqjpXxeLRvcJMHUCtXblGhf55beQa4MDGiEztUmxmCMahOBHIBzzRPD2DuGlU8bk1"); + yield return (HashHigh: 0x7d7b5325457a383cUL, HashLow: 0x5b6f263ed3c74d3dUL, Seed: 0x30b52b853f3c90a8L, + Ascii: "POkjcvdYJtZG5hdudDILMGlYffvT7puFwieMGzzFSo1cCmnFTQCxfZFKH5TEKdl003mluc7zjytqOD9VQtp0T1oa7wZKxdsJylmBmYlGTRUT3ltQNy65lyoFsHG2ElZe2ryiC8Og7SHdc7pgtL5PnrI6vgofq6WubtpCowKw640dbenk54ZXJxYmOKOS7NHMHUqXrlM8tguWNqwew"); + yield return (HashHigh: 0xffb33f00093c3d3fUL, HashLow: 0x7c1141aeda8b9578UL, Seed: 0x0000000000000728L, + Ascii: "HdUWxTmWLMYxDvlS3g6lvPs6zdL6Z7759ymLuPG08UbKXWDfsvMuTVEprrR7HbCas48BmoQpgWtLEabIcApEE1c2pWmtuqanbA93PDjOW86R11YcCobMNJBrWHJqNpZjH0LlvIhS0C92t0D8Ej5uyJN7JHgzwwyTNLQncnGUkSMIBNTQ3YzCtBSPhKoHSfUBKEzk2fzy68pZGSi4X"); + yield return (HashHigh: 0x0a1a33a9f41976d7UL, HashLow: 0x4b54dfa63ebb3ccfUL, Seed: 0x0000000000001c2aL, + Ascii: "dAN1SdBmr2gMNyALQrdDXfQ55t6DvouZbZu9cFXibXwHweIdgdFifK6CjnNnlvzlFCnNQDjSR56Qvj7f3QQbBMdaLN2hAh4SayCDBLlfFjU97lzoIHem1n2cOU627S3KMhFKDz7QnicmqKgEeYKAWCMZLh1i18jQDk9SvY9wz85clcFrwBJvULVEJYCIZQKy6qurTDitVFFnnzIvh"); + yield return (HashHigh: 0x66fa22c9eec5fb5cUL, HashLow: 0xb70e79c506a105f0UL, Seed: 0x0000000000000389L, + Ascii: "s4vBkb0vmkbjzA1CIzLGyOtb8Ers2LzuSbXvmPNjNulNzPG2OaGfU67UnMq3i1ubVydnzBdit01OxJ1JJTcxPjvxhkkCdRGIwxE9AvXzcrtPHwnJvCtwnJeJvO24yY6DnUCZ6P4in7fjyvZLEjJbf4lxSOzazHOxDKHKZitF2yQKFWAYc7mc6wov7DnwVYuhudXbdLsOWOIw1btvtj"); + yield return (HashHigh: 0x47c690897547920bUL, HashLow: 0x8482dfc09c16d8d2UL, Seed: 0x000000000000196aL, + Ascii: "c4jJohV3gr10UmzwfQhRtE8dIdtPx9SGpNE1aSq0ZCQLDQzkUQAefMagUxE7uOdNIr6IWA9aXjapnUgDjWagND4CNHYgkk8FPYgSIiU239nI7qO4CkrxrffMJUVAh1EsS51pm6lmeAPixzx6ROCX6JUebS5SOQynqDvFxTh4ZALMiBZadkgC2achNnbA7KEnel85MGrsCYD8996Jul"); + yield return (HashHigh: 0xc6314b859faa8853UL, HashLow: 0xe99724e47261171bUL, Seed: 0x0000000000000acfL, + Ascii: "Cljyh41sippSYGQXUXTCELfcslOnjQgtAbhdENTD9h81WKugXpFsQVom21pW58m3SImLqlmKlR20RtvA6sSiPg2Ids0VkSzrHsiv5d6E4XtwQO2RMiJdbrjMShNAiEv12f7pWh1UZwZr0qOqoFsWvpuTLNiziwUXXJIyy2EYprN7E65MVXoXPmrrd9RwdfR7G7SDyis9XJDavdIQip"); + yield return (HashHigh: 0x2f153f57c056c664UL, HashLow: 0x60634c9f2e3382c6UL, Seed: 0x0000000000000000L, + Ascii: "OJFu10AE0lILXYVyS0SnWq8bomiymsqnFXR9RBK2vfdQHBtxI4jzL2dQjEyP8Kow9Bm8shOTckKeisDHBPkF9bOa3WDKz5I2szl20rD77vmFepzzVCfnAuCMGxRXRHoWUmRCjDYN6b9HsRAs9xNPLeichB0rnSQ5mQWObL0j1Wz6eCnXHVfPNWw7jd4kFjSpCgoI7qT7DLQz75HjzV"); + yield return (HashHigh: 0x1ba637efef510642UL, HashLow: 0xeab67d06fa529b4eUL, Seed: 0x0000000000002386L, + Ascii: "l9JXwaCxFbWwpmYCQHjcNUarJSQknk5wuWJrhnG2yqJOwbxG19Ut90ivq6paYtcaUC4BQ4NaeG98g8ixNTlqTuN6v7x1cG7FTf91lctBOqWkUdQKi7x0h4iKFTK0uqrYOAGV98g0mPQZlMPnYMWYqwlO2fIMfC9BDmRId2xpOH2td0ydnOFbw7QU7Ee99C5gZdW5zgRgZ1CAsuE8OQ2"); + yield return (HashHigh: 0x954e74ed75833687UL, HashLow: 0xf4c6a2fb81bf1c99UL, Seed: 0x0000000000000f22L, + Ascii: "hFHhF4ptvamaEUcRYAVs7TkHdDkCYKyLzzQQdwwyHuiBmzaTw2yatG4OivT5zoBUozXNwizWKMybP7GciEQ70EikxxaZxLDEzL1dA54ncIhyROBQp9DXGCNds7ajaLZ5IjE3QGWlkqivvo8aOW3EBojz205favpRd8J5kihp16jsAY7FVOFpPm7m23hXchZTHyE2vxtQz1PWrbAhCPx"); + yield return (HashHigh: 0x8b68f8b50cc18a3cUL, HashLow: 0xee7aa02fc6b950f9UL, Seed: 0x0000000000001cdeL, + Ascii: "THBuisT25JtpMf9WHebygRp7y3glzDksekJZTodZdrE0AlyjmKWigQRZXy0ysS2hzuXvAMecSQR758gncHc8uknFWyCBcKj9YVhPobrSrgmxeRkPPwDYFD2Jq15UKdKX0D3Vt50QJYPdTYyKAeNdBB9QHHh7zd0gno2BSNgY4Pph62SY3wtrURyTDWG1IrYd1C1LbVK42GppAUP2vBC"); + yield return (HashHigh: 0xffb380e0c7e0344bUL, HashLow: 0xfbc1808b36b6185fUL, Seed: 0x0000000000000000L, + Ascii: "7aBu9nr9J4LDM72H7w6971aIssorqHAUeKcc5y1GwosXqTsCNnYAnm4rooC8takVhZPSQvJWMF8asKhjEz1tULAsMmrdnUGmKmOBWknWrbpVlWhAsuxPFmoi3YO3zWPxTkFhUYzTN2uPto7LbfHFpxrH6acx9NIvC7BqzMzWoEpxyw1LkZF1UwMqYANJbeTsQh3MBQVRjbys2JJP6Vhu"); + yield return (HashHigh: 0x58a0b75fed72a784UL, HashLow: 0x47ba4a49a835f815UL, Seed: 0x00000000000007e1L, + Ascii: "5KBL51l4hNuRo0ySKbXnecgOY2O6cf8ncMfEN3rfEjsNOUpJ9NIP26L9x1ci97r8StvvGQeIXDSHvQGVJH6JMCCPdKDpcfKbupt8PbqacoiPLK0vo8wFOyqVz7E2N4sr4DoNVbtqXVjgeDHiF5F2qwsHI7qsUTNQjeEwqZtSJ5de2XnjJNcKl3f3uWac6XgyrsZjNInpn6xzK0Ph2slI"); + yield return (HashHigh: 0x7a61eb658a274ba8UL, HashLow: 0x84246e0e531d5581UL, Seed: 0x0000000000001f1cL, + Ascii: "Vpk9ceAicxUFUIS1highaulRcOoXA9XNESNyzocWCRjpVYFhp2BDj1dt3CKPziHJ9LiPl4pSr7DtKSROKJkoOFD2Bi1Ig5pjUqCOR0NUalZoVjytBukvD2l4v1366bPbo2CIPZ8E2tSB6AgSJY1nGvqHFojrHZJFQe9QQNjlvKyjmTzgSr39t7dcQn47AH4FgWtjIeQdsvKqafqFN470"); + yield return (HashHigh: 0xbc8a5a36ebf3b9d2UL, HashLow: 0x29c892378d82340aUL, Seed: 0x0000000000001485L, + Ascii: "WsozAtXaFmiAIlDmKBH6QnjJqPQ3Y1yQCYOgWGf7mKA2U3LE45DGb0O1YDk6mSRP3doCSjqCRGPIjtarjFp9CMRnkmGPD2ezubhN1JXXbImNCuOYwWmxgiXPqm2ueVgPrN6WmRQFDKAzp4y5qnkFgtavCTWYjNS1VQI7o5X95rVm4ZhyNNZIpqki5wgcYBRCMQ0tJDx8hnxBEtUyWaVl"); + yield return (HashHigh: 0xb9dc20dccafe3e8fUL, HashLow: 0x4bb3a39c5f5298c2UL, Seed: 0x000000000000010eL, + Ascii: "aVKyR92AaCBW0Lk0WjMia61RVhrECMDfG5luUnLSiyLoPEoockTbFllYK7LnEvEBWqjTNBLOAk16OdmzmKhZCEivvPI1RZQejG54M5kys6mR4ZZ3uBnAgscmFd0k8YTmmneyaNUSdvsLKGuZI46gqLnkn5CKIMQORwvmBseoQ1uzfTjzXGohAkepgzsWrv8CHeImc7052iYWnZ8NalBW6"); + yield return (HashHigh: 0x5e7e4892aa088536UL, HashLow: 0x4d045b24bff27927UL, Seed: 0x0000000000000000L, + Ascii: "leqYs9WeGmmwoxgeZUplpxGTrNqHomntsxO4zdDuwSacUUi2d06ybw3xJZTxH2QEn6lagba0Dr0qQ0AulJOHUigJxGT2kxjWiRZuqVUrIJ76DpuYVORujv5pwsr072YHhXrX70V29wZVHfeZYf5Bz4AyzY64bixdXoAfJ9HMceEzvHxQNcFJsj4xLVOvzR2HIlYII7BBQyG0ik788LwUT"); + yield return (HashHigh: 0x22314cc967309151UL, HashLow: 0xb87e4dc3e43e7058UL, Seed: 0x000000000000097fL, + Ascii: "d70Snry8sIxRblM5EjJNu7QPmYLNq3GV6UGHlKpIQNBi1vvbuFDJYj9uIkmCyuAG6ZTh6eXfMZnR6BfClgq5z0i0hXipMnHW95Fn6zs1mCPVao4egkbkruY93D6OgkAeA67BL2R5s92HMmm0lOs0idIeGoD8RRR7ImbD16QTOYPLaPeghCAH6AjS99bJoIH0SPuGXZZNqrv8B55StJghF"); + yield return (HashHigh: 0x807eb9bfeb1aee2dUL, HashLow: 0x4635b073d84964dcUL, Seed: 0x00000000000023a9L, + Ascii: + "gfOM0utqVsQRzcQ2aIyaXVtHFq7LG3fkEPedKgZEwIovPUEyZCbfyRuWAZPZ1Jo7g0IGkeslhR3XT0GyBFQL6X3YcCcad7fwTePhFSm6KVxDEiLpHh1dA9UWQ9x2xJh9Ky3F6RTMxeQEh9zM5GaHjK7vmqjvk3oE0CwUNXGXd3CxeYd6ULFlYRiS9QbHfGiBxWbvSRj2ymtHIxS8886lwJ"); + yield return (HashHigh: 0x23a22f40dcefafb5UL, HashLow: 0xc4d19df58245ab26UL, Seed: 0x0000000000000000L, + Ascii: + "lcBa3QpwhYbZq4HRypc8k5ULkpzue48yKXd6NzBSYTnWrakJGMW8GJEjbOFtqkp9IWKLBieoXgLwibggsY9E4J8OJVGdKS9BlpzxNPHWRwcGLP3B7UK2VOR3uvtCnW7YZSk6gqhJuNOy6zlurxRDt927OMzoWwGC7cyh0WlmCQpn0meRxe7Vha6ocNeA8yHlXPqgd6omqaph25XU9hKrn9"); + yield return (HashHigh: 0xd12975aa89e90225UL, HashLow: 0x0805534b4207665cUL, Seed: 0x0000000000002255L, + Ascii: + "IjKVZoeHMlj9TRfbtrnSlFOiQvxLC8uz0gSpycAxRbywjWo97Xgzq1WGB6Ktn2B4zf4iBZEbo7FGVLRAhATBolA5nRqqgQEqycVY2yBmAdKQ7qkSQ0JRhsnBhYcNPZBb7nhtVPPubxKRyRPSAg2GDGgweoxFhRF0WImnAyxne0OvHhj3EBpwcVUZ4P7wu9wEQhW7VJugFmhA4iVeMAOUh3"); + yield return (HashHigh: 0x4fcd47932b5011d9UL, HashLow: 0xeb26b7438e5ac29bUL, Seed: 0x0000000000002468L, + Ascii: + "z4eqekhdv34U2YYfDBGkSR85HW6IprKH1Lky7LKuGwGVARNNUDCVZ6kXXUagNdmRS2a4clYUs7GVHJ7wQ3dbNkyl4H0tq6TqCkDVSu5pLBbUhwrdx3xPfNfPMWv82bH0vPZNzYPt2Fei8C7OU3KbUm5KHOn9EfcaWgTbpqLsa5JgQm9o2sVilrPKNIhbK8KGy8hsiSgurUfmS0DHgBpv9D"); + yield return (HashHigh: 0x25bd7fa9f571fa68UL, HashLow: 0x911dd64b71fa03daUL, Seed: 0x0000000000001e3bL, + Ascii: + "rtCUv9vqzMDXQMtMTQcCAynQMczuLHldkkc6R9O06nIGIiI4q3ehCmHLHv9hNRbH02bo3TlzI5G8VUaW4PYzHqLj2dn7KuPF6PlRh0rSWEXfhHbjaWtMrJc7jPeGFTCl0kGIqADkw6Dw7LZ1vznTTITBX4yeIbS5NVqA3TnnlpRmeKR8JGxZpqzjOtR5ZdNESzlqZBiYmRqpCPykkjX0tBe"); + yield return (HashHigh: 0x088637860322c4cdUL, HashLow: 0xc60e7b4e5a2fc706UL, Seed: 0x00000000000009d7L, + Ascii: + "L6fREVHqM4d8B9Wy76v7yGbjCzpfhXvh2tNiwmMNFjKwr8rBPpwg74JrghKyBI7dr3SlCs5sH1NhePoZJEd0hkmcEfB8f20k9WWYmNpCtqUCWkOrWPywUT9KASvYUhGIYfJr39d3tuipvRt7cjbOdl1P37xKHrmWissbXfNsiGSEaUhRr1KjBP5PcUMLSY6VSZXrSQE65qwLOT4XLXCgWdz"); + yield return (HashHigh: 0x0bfe2786eccc643fUL, HashLow: 0x35615ce1371f2979UL, Seed: 0x0000000000000000L, + Ascii: + "MWxfcALWJHfUT1laJANXHfshrogEiBVSsr1Mt73oaxVXdtBOZvw3lm9TqDgPn8U6sIro5oJiYDPaObAXJzZ6U1aqmM96jT6XuarIg24ME3iQJWofn1Unv3I59iquisA3958OuWYbXQldCbMQkt2pJShpS3eY1p5GTObknktBzgucOJJg2Wa1Mx1zUiC519aTgRm03s98RiWb759DApHlUtj"); + yield return (HashHigh: 0x85f86d5cd1de913eUL, HashLow: 0x774b240b2ef420dbUL, Seed: 0x00000000000013e6L, + Ascii: + "v43KCmTFfV4m8izbNRwsKKvSCvb7eo0QyEZHDMN24W1bsocSGHegt5HmnqjtB0UebT2xvFkp7VFgCUkMT2797wwIpK3ovYXDtBfSTDNLjyRBkKDf8F1OmfPsrxU3bfuMLNvn67pFn81iY1aPh3LWM9DEwte7UpiTyu9cjZg3lWPkIdgijUfjSAaFw2wvpxolxp9XP3RgbaM3g6xSm5XoHGRP"); + yield return (HashHigh: 0xe706d5ccfb0059a4UL, HashLow: 0x7bbf01ede90844c7UL, Seed: 0x0000000000000520L, + Ascii: + "Cv4acz39tU14kWL7FXMG6l3LdCdhZiNMsNctdM9O20zcWaYqZZbO3byAQA3LORByXU5K0HKsfpHwUVZ2FqdpaZNph9qbBjDtMt4oTztSAMO2XkUUBga3iwwrCsBDxRWWjfiRZSAwQ9UMtucNoPguHagnjgtLDExdjRnbbTqVxmlVJRs7QTCiv36YUGvJpPcMf0GH3WTM3950ACaasdI5lKSe"); + yield return (HashHigh: 0xdfe6f18b71ddb080UL, HashLow: 0x857115e3b50b936fUL, Seed: 0x0000000000000542L, + Ascii: + "2MVJdGUpZDznM8g2TVKVDhJCMQxwR2DVRNHP73F7w5WEHtcxxtMTZxAVdnGtEiXv3tg3fs3nqcuqvmIUQcgqb719xFxznuZXeSF66kfnpPuC7NELb3eOdcbDvgIscxslXN4kEEYnXAPcfBw5lMms8fEbGwD7YqAZCYyv7wYvom5h1duRsBPCMULDoVeqUTVOyo7jdq2TQqO5ZjIVcrZ6vfS4"); + yield return (HashHigh: 0x49f01fd3ae387ab9UL, HashLow: 0xf7216d3ec902f94cUL, Seed: 0x00000000000015ddL, + Ascii: + "eaKj2Wxvp03jvf8wxE4StW9KSzC7PWN9O9FqwHv7agGho9p91Nzkx84NNiskHnFzaAwOed93zlLH9aRSuO2MnggSm3EliYmRgYK795xdeb9FrtIRYqBBZSU23J9IhOMHIy3hitU4EvxrieJEuqp6xozpCxmTivsHwMva6K71wewc9HdSYiDoq4xv2x4JJeCyRNlRYAYyP0mqm1CTHKrgKqcV"); + yield return (HashHigh: 0x6231be7078c06e63UL, HashLow: 0x614924e04835ccb1UL, Seed: 0x0000000000000e15L, + Ascii: + "NZTFL4A3q60uKDcIdOkRSV8HZkziOyUuPBrfooNFrV2MA6JscKmA2MBGUsz275Gl8BbTVmrbnnK2fM0zpCXqxZSDXKDvOW0erPGjkUuW6ZWQLZAXSuSPlq3yDRJzPgTIB4VnTCQQyl13wQJ5DfnYdf4ScYXjxJup3BFhbEt0Hnq5v0X6kKbmPSkzuNenzlNBKfTu8hb7rncjDS6tgefyS3mOv"); + yield return (HashHigh: 0x4b9896b948a3cbcaUL, HashLow: 0x834e88b055a1425aUL, Seed: 0x0000000000000991L, + Ascii: + "HqKZwK91tBYpPOl8o342vzvpM05Sgw5bGQDSR0jZMWuEGp2bzjN00wjn9fsF474WwXKtySnONtiqTKCn0tAVK6iXMfnPSeYNugcmVGelM6pymFoJPQxvZsrJjG0oAFQzwh5L8XZiD8UC4FndZuYpPOrffG43WebqwnEmFlJ1zZyN4sBSBflBDeCufIV3lcWDBUJD3ILsaepi4MUaV1zOmAHy6"); + yield return (HashHigh: 0x010618b21543f69dUL, HashLow: 0x7ec8734ce44a1e78UL, Seed: 0x000000000000140eL, + Ascii: + "1pTZnHAKgnUPv6pYmmhRFuyy2fXjAndgADY4ehcYAcHrkmKH1UVQObV0vFx33NdIbA9D2hP2FBXNJHzrfwXDOEHc6CLETKUxRxqZc3N0RhBWjibXXiChsLZ3XmTAQF0Q1Rz9YJXgiXHwgzNO5cWtvmNB5eq3xNbN6n9F3IarH7bwxnioCBj5uNQMahPgLu03TA6t6e00sSlFQEwgFwMNLPWWt"); + yield return (HashHigh: 0xbc24ba13fae92218UL, HashLow: 0x3879e964518a1221UL, Seed: 0x00000000000021c5L, + Ascii: + "4DC3Y6FtuATiCbFMTkXH4zWjn4tf8dahGDINMHJk8cw6E23iCe5WrocnMeEi0ka0YZt3LrNGUvWTaAMk6RoFtkspNRedvRHZuxCH48By38b94fTpMun56GBQg7OJiA39e7LY1prxJdzCb8vDTgzn3rPI0OUM3NNJ56A2WbXaQNkzgkEJuUodlCFxUniOmvuZBOWAY8N7MMqTnPUgR2O6qiQQnb"); + yield return (HashHigh: 0x74754a8e20358c51UL, HashLow: 0x3fdffae6ed883539UL, Seed: 0x0000000000000000L, + Ascii: + "UoQAMlKisK1Dd2QUq8O6rbseXSJAehbR0pRyo5wnH1sSMtmFOAgMH4dome2gORSovkCiifjYbVymxmK7pqedP5AzH5gYK8gAQPATdP7wEXt4EYn4X6RpJBkzvAVXaRLTTgBClXsW6VtqUtHQJUADgd0V267esMM1HbqoaISEsahDb3dbYyV59FpmCbClJc2GzK7DcMpj4Y3uF4cQU0I0nqBEQm"); + yield return (HashHigh: 0xddbfd58b5eda3c49UL, HashLow: 0x28f38c2eb19c0acaUL, Seed: 0x000000000000143fL, + Ascii: + "627hgrPLCV1AHFX07JV3BY9dpY4q1gSUKGAau8oqxi4vDsUigISmsL0jm4arxli9YdJCN37sjExSRuLIJ7HpKI5JACKCi2Q7dYgP4BwvpwEQDmvF2t6mPT79S6FVmeHt6827kFh3vkVD4SmbviFIfhHb97p6JbuLNb2ilCrNDuuoCadTFkp1Rx882SKaVrzAPma5Lgir5ccGVWw7dqBwnzO4Y4"); + yield return (HashHigh: 0x595c616be6fb17ddUL, HashLow: 0xe16cddd7822d16b7UL, Seed: 0x479cc0ad776c4358L, + Ascii: + "roOfMBk01by3B3I87XgQBfha9NDfpLe4QDYiB8pupi9Kv6AqIC8FYpVmhcLWWMTliUsE5ZWhQ5BRN79vqEHlJUwC1hD3A1CBgxbUctJmposwuZ6gJiwaN8HOxOzYzHvd73fUgdnvxcT4PIRT9N15qrkvfBN1LegelSQOZkPdI0QAux8rj0FZ9yh4vqb1e0ulO7FqFLFFiwkhawEZK8kidyGETK"); + yield return (HashHigh: 0xaaca3d8adc98bcd8UL, HashLow: 0xb04802a97e0ad4c8UL, Seed: 0x5836ea31e9bc3892L, + Ascii: + "bRhk9VWj3SVYdenBUrI9wPN67VTIhO8ZOtut63LlNhY9xw5igHP4HnCdFimHkhhbEmxwpLJKCygXyT22y3afMymVyXm1Wc5akyK9sHW3DAOLY3oVCi3YGkkNEJHDBLOXoYCPlLOG00VOk4ue92dAs6DfZpqtblUTlJlF7CL2GNFg0SCzS3LFbuZz90jz55AuTTdY1dLJOWwrqm4U3zwQerBSJ92"); + yield return (HashHigh: 0xbdce848657fd93f3UL, HashLow: 0xa79fa38e868e84c4UL, Seed: 0x0000000000000728L, + Ascii: + "ZO5IkvVUUjpHBSm1D5xsnZ1IA8uCxaxr7j1CLxBbs65qCt2SxtJxwVzzDMKvKgxJgEKF4IsHD5jAkGqlBPweJ9tWX08KnlLPn6KSvtYmcWGWeY5fsmTsozhyRWLEH0pxVUWFqlgDhPt6B6zJ3lYZDKNUIdJgetOs51Z1Zbcz7n6wQGrym4MdovHNs7AZTxMoNDORopMbJz9ZeoOGMUE1X0ZlP3V"); + yield return (HashHigh: 0x478b8dd9f9f83c94UL, HashLow: 0xbd5af4d77f06e61aUL, Seed: 0x0000000000001bbbL, + Ascii: + "lExmEnuj4PbJuial7hsE3h15damh0vWA0nKDm6YzGX5vtZjpefvYA5fJciZ1wRlAOTxXNORsvoNfAvHFmGMevPGJY8OHLbNCN2hQFgGj8C8iYT3feJpAmJdiGMGzrQBps3CDCYK7Y2mjnSxmloPKarj7qWGWw9DsE3ObNqSQ2fOksIkMD5xOKF2WtoVvVCrVdszkEsmfyzxCh62yvAoiDjq7meH"); + yield return (HashHigh: 0x41b87801f5429c4eUL, HashLow: 0x9a9ec0e302eca6c4UL, Seed: 0x0000000000000c19L, + Ascii: + "0XUrhozMrVQwExvzSvjTfSuPEqIwrxvmAO8TTcpaON3Yl1Ru21M8u6sFyBtyf6wCOuQQvic4b1kQjBlGuuJpaFM5Cnejw5viTM2VdFQNJIrup72Xb2CkvPk7R2CpOGc0SLdeLjtRjHV4LqskpX4ge3w27Q8rtX6k2MN3703vaOXe2axJXD7HW1btH3q9CuROgdfuU1iLW1crT1GpbLRsvosS0y8x"); + yield return (HashHigh: 0x5e213ff038c64f55UL, HashLow: 0x0a7619e69ef778ddUL, Seed: 0x0000000000000000L, + Ascii: + "iK5YjBQqLtYY57nUaCwhUYOMgg2sZHjCn9Bbx1U5xIleBfIwxfHS4DC8VCXUgvuhIs2Fx0sJq7YZXC3NwNC6cBRX0tKTPP9RJeIhg77yPXETHOogEf78ZQTBisbfRwtBbM9KI3ibTyeTkjRP5aJ1GV3g1c5jVez1jQcZ87Gws5cLO1zrEacglwdmDU22MVAPNGC8BHyZseVj6pfWkUS3kEJ2Fd1I"); + yield return (HashHigh: 0xb298680297d19007UL, HashLow: 0xbc46d16914d04220UL, Seed: 0x0000000000001bf2L, + Ascii: + "nD7cdBdnA0smbnr9ACDFAA1be4tpxONfBuNVsVTwYnzPhfCdpzibBjLHtHFfthHMiiRnaGusXRHOGn5OLff8Mr8Xkt29s2CezETI6Cqns7mVKopNdBSICuifMVFrzzQqaMyrYch28i5jNmfmKeX28yhAafViX1dYshTws0lpCbHR7EvpDJ2PH0NOsMFAODKDaofZ6Pbiv3pwejsfDW2DtwEIdIJ9"); + yield return (HashHigh: 0xeb686c408f9bbb78UL, HashLow: 0xe397002ee1eb67c1UL, Seed: 0x0000000000000b51L, + Ascii: + "u7VtIagZe18tpDCAKDmCpW5WC4vqvVGH3goGq3qc0yGp4w9uYysET9XpF6MmNdSEfu4b6A1n36OupgQNTOtOVvihJHsMIjbpiEQoOFhvWA0fh1IG2XGudHHzSbcCB8NU6iJYrED0C8RgOwgkJ9ofgHwhZlk9sarsNkAoINnnFogd6DyYarOt3O6Q6TaY1nWQhnxNhOJjdZCAA4X2nx0CYGaqyGI8"); + yield return (HashHigh: 0x0c9881eb2566d48cUL, HashLow: 0x868a3c7b0190436dUL, Seed: 0x0000000000002319L, + Ascii: + "pcW30Qxc5kKUnQnSKaiJ4BDaPbwUv6SIQg6XOzlw4mfglLy9m6MX5wQBoAXmz9363YKLM1MdaRCDDWOlCGO2sQbBUK6sZmWb8o3RJsNMRGEaTYrKDbgiwAecsrsCgeS3SupxFHeEGLgnMDPHEPm921IFpQY1JNNW1glWtmghuXoyMzWikot2m1ujaQ2yJA4D0TwBj95b16pgvrHugdS62DM9GL46X"); + yield return (HashHigh: 0x311f1e89964d87a6UL, HashLow: 0xb115adb0075ba3ecUL, Seed: 0x0000000000000000L, + Ascii: + "F03wfhRNki4vgSPfDdFSZeNy8oyUMQwioqrRv3xsJk8Y4SqqLhE1YI2enghydmhIWttp4uLPwvq17OYcXcHMuBDyCwHaIpJLuSlSLP09nZOTWhJls3YJPP4kRyvTWONsEy6AaHIlNUIVH2mLSk5uPmJHK5js9V6OGxGG6XFMThIA4uSQyQSNXLeFuXvQ0QuQ5GWcxh21zQMu6UPEhOA0nDWRxa3QK"); + yield return (HashHigh: 0x533680f5d4810efcUL, HashLow: 0x6fd1aa103b4cb87fUL, Seed: 0x0000000000000fc4L, + Ascii: + "BTxzhZqt5gg2Edi11DsiA7woNQXjS9FMm0Snii2pWcGUmVKHoHtu7YMJVjs5g20rhG5m5956dMOyqhSL1IKhdeogZWwASviEatgfrbC1xoqTzOUmKoYQY7etIvDS5jq6BV0DGICCHvAXexxtf9n6jv2IMOnVXopDgXaRGTVmr0TRVeeCLsCE0lU0IGPuXQsG701jUMoiaRkdIEak05Qk2Lh0o2VJC"); + yield return (HashHigh: 0xc5d8c9bf4fc9e603UL, HashLow: 0xd90549d20367443dUL, Seed: 0x00000000000018cbL, + Ascii: + "oRYALytkrlDyGh86DFGGYPTJGNsSyhBn4fjkl60WSUebIptUTqbqXeCxX2tyRPHRtClA0gCqq8ufa8yqcFRjBqnGJ1hEm99xidjKlyQI9Efx6lW29IE3SaP6PlYuM4IlvtZnsXldLo42jbrvKR9OcGYjlQk2rsJHDgvQLz8Cvx3Ei8q8ISDUiFYlpA8sjh93JD6WCel57jNiXB14RtRtgDN8c2W4ua"); + yield return (HashHigh: 0x579dee60932c84a1UL, HashLow: 0x3b3d141e0a37b106UL, Seed: 0x0000000000000000L, + Ascii: + "S9cbotxZR4B15Hjl2hKUdzIJkakuWMyGbFHGqgIB9PR8xocs1BRzi7MQ44lmFdmQDAmCgOqLWFR9LlGbaN0OQQGgBa6lEnmoqBukT7sIkoCJjHUi2HgfLRiKfeWD8sEE2a5RTVKvbNDmiuUgkUsxwuh6QiOjc0Pc2Du8euDHDzS8krhxePFW5ReIWtxlxxdqfbV0tANKpifFJXb5gZ6k26qkTDJv9X"); + yield return (HashHigh: 0x422962643711816dUL, HashLow: 0x1f87e1488ec1593dUL, Seed: 0x5329a3b70d0f4a59L, + Ascii: + "9TK6ReBZeZ1K6IO9C4EYZuemID5jadSyEGvmxZZEWp7d6kWLCQIeieGMFRGUloj4Uont0qznglqe41GO3hh3U96nzYdpWFdiuehvL7q45L62sj3IYoQWCZk5SBNyVkmCGyJzRILWUzUiWJJVlK0ppbrcUVLUV4Jepw9ejLKucNU3P7hifLxvoNOYaXftmEKZH6KISwD3WdxKIE9OSWrcZp3fzatrU9"); + yield return (HashHigh: 0x215c0af71e12d4cdUL, HashLow: 0x97b70500e33fea28UL, Seed: 0x0000000000000b0eL, + Ascii: + "jufg2umT1RqPEeANom8xVhHAC5L42tMYhCpNXve8wUDhfrhWN4H422MskP6tBY2EmEqePlccygB9ZQVTpHQqiP9Ka5mQYyAGx77GUs2NMnU0euVywIO5CBx9ei6de9oCeDMZc7k3wXvSx64x5eZJGUDITcyTTlyDLR0Nw1YRxzxdRdKCzM02wsfJ62SlnYbTk8MPKpOnox0Yf1LyHGIdInWUVj3fyb"); + yield return (HashHigh: 0x1b003552eba777eeUL, HashLow: 0x04514f8106a66ebcUL, Seed: 0x00000000000006acL, + Ascii: + "GV1MgnpqvoSDspt8vNJkG6EhDYNzvaAO7tOH0PZvGGoXtmMjW7bi9bjis2s4rWHtfX2bza2xfKKI6LFpkjQLQK4uiVzUZrW0qChLjsmpWIZRdGVIGCtG6ioxs0WR6EPDYFrTNoj7o1VKJEmW8VV6BG2hcO0mwrIUnTCd39CfBPKIkTm60R5uiYU9XUhsf9spgu6w4wH1eHFzoVGsxkapM8xmcqWEDHU"); + yield return (HashHigh: 0xeb1dd3aebda8aa13UL, HashLow: 0x3cf14839ddc28fa8UL, Seed: 0x000000000000266eL, + Ascii: + "WGhakvdr5URzegxBalPiDzXEY1viANvoS4m0bZGAtcpjafxDA2fcud3OPkRiq2otDcndRgBMA5vKwxuaUdwIcy0SwhnQPvonKbIiH6ihAE0PDNP5wnNVoGwPhLxuC5M7rRqnm7jqnIevjTR5ZCc0NDMfeZWoEl94XZcixZurJgI8Gtq2ILUdqgrwL2iuoa4aPwh0YnZpkotBse8mUERANTf2EJfZrIZ"); + yield return (HashHigh: 0x508db609e87ef946UL, HashLow: 0x2f5aa206eedef609UL, Seed: 0x0000000000000530L, + Ascii: + "U3jiPo6HiD1tYHnCbrkOo0rZismuXvf2r2hKvELc7llbPvCJKDR7ekfiXWzImRBuViE97og5YCPzAXNEq7Ib81PaCxmN4vm6iBZkghhPUvjfcU2f0xUlkzu9G2UkhT99QOO2rFyCnN1qwuY8utUmmKrJf2W7FCdBm17b8yG9jegKTpKLbobuKWwLcmkotRcguOOv8qq4nNaE4EMMtMPssm5YzHXflJB"); + yield return (HashHigh: 0x8b65e1b9edc06346UL, HashLow: 0xcc172952208517efUL, Seed: 0x000000000000134bL, + Ascii: + "hrrLz2buLvxWkERcKPsq7YpYcyRzmV8GHdXV2ujmzVtrt4epM0wZclAhkSzP2yA2qokCFjp9FDJnwk3ev0K5qWwsMkulMNCs23x8KSChg73HeC9kjPDfvkFG98rF9lS9jPaTQp9t2ALqVV6AIFS4gHEroFKXVaHtgacNOpOYwaORIces1ENbq2AeYcIcmomXs3XyPGqaHmxizYRjchXEpHWvK5qv2l21"); + yield return (HashHigh: 0x0cf53509250abd97UL, HashLow: 0xd70f8bd24a91d4fdUL, Seed: 0x00000000000012d6L, + Ascii: + "33wNhFAj3b00HKKB93gYphsoEczhprR73uEMR4fR8rdMe9t11pI4Xjm1XK8YHWJoPtIDhwWhJThCvahs2gYEyAg3w8hFAwD49Din0hcv7D59FzlvMhLzeGwaicTUYXitXx2R6T160RkmDrVeNEFa4mSiWU5kPbYUO07l7nJbaduDA9Dg7YDIUZUmOjY36v7dnO8LRuHWVMxdiILVGMH7TqN732NuGBQv"); + yield return (HashHigh: 0x00a2ad522b46e891UL, HashLow: 0xc47c20017825d300UL, Seed: 0x0000000000000000L, + Ascii: + "HOQiALDlp6Q6srIQ8q02p9sZtYbDmMErff2Y7hw4gBBvWwcvEwkIY6UQeaGsRvG12x4S0PL6Q3xJmYiddO1SNcsDAhAz32wXQxBvisdQWkL8ifYJSL2gTqawFbWz5X8UqzSXb4zLEThzVT3iURoaebCdXC57jO2Vuy9FAZmc41I9l2YjMels27noGfwOsicYpKdkxR848Dys54b21T1evrtLHQF2pp5R"); + yield return (HashHigh: 0xe2bcdb64a38b5e1fUL, HashLow: 0x162f9615f2970563UL, Seed: 0x68cad26577bb3e37L, + Ascii: + "qXz5F7z9e2ctXtxxVFhUkJ2mgXPcQ3NXnkRxatRX6THQZTE7sdORZDZF3MQYYKc5XlQTVi0BeEeopicACLB0KokWNEF6F5AFzpB0rLLaDrCo4f2zssslxq7rTvkvE8VWcD0uBLppope0HmdjgXQCorCpihOeZNgEiMtwtjRABeVq71d040ZRcnsmtxDCMeK8w3GiTInjF7AHXjb9oAxoymrbpPP89hGd"); + yield return (HashHigh: 0xe19e0f2f0c74f86eUL, HashLow: 0x146140b7d4c68ac1UL, Seed: 0x0000000000000000L, + Ascii: + "wDoaPoLLrmMPQVHhPuKys5igkxzDoVPKfdC5jAbIN2lzEFDTLdmKdXcvFHi3xKWsG2VUbFDV8G8K3l6GDKNGTpaH3pXOaXVFUp0eMtunD152PWSI0lDCAbo8sg9CMDdkjVOd90krfDXuK0QsZTRp5q3viK2XIcOcQazhlvgPpzR7EkZZt8ANXkECIICpaXE8AnLD3Du9GBNSaQq5u1ZBBqisCNz36cswY"); + yield return (HashHigh: 0x2192847c67d247d9UL, HashLow: 0xc7f8c15398a92f66UL, Seed: 0x0000000000001a6fL, + Ascii: + "0cowtHJveA5UlcfWWMaT0BlBwa6jb1zLYEtDo7tpwtuFQ0o5HHKepNwQbWKKnaf2Pm9tFUBXA5Z1JKDMew6IkLiESY1HFCbvnyeicMF5htD5azvoPZzM49yfn8gxtxdZ196R3z8Sf3fOi0o1OMWbxRSEzkfA7Co73Mh1YdbKW2LWzrligAGxhkKb4PlLi3NMWjZSKQShgLIf6EWd2usvqYAV9sy2tzSxU"); + yield return (HashHigh: 0x5155d4c3e5f411f0UL, HashLow: 0x5ba86cc3283534d5UL, Seed: 0x0000000000000d2eL, + Ascii: + "gGr2S5o2nUvizSEiswmATeFJhu7Eq48wyK2H2fScS76BeL9Bxy803jsJaiLCoQn7WtZaURcgLRwh3lREBvFaqHkjG9xc70QDx5IJ4kgn9iKOwlEJzqAgke2Z4QHfwbG3i6058MjKDnVT7adVWRxapgq0HvgnxxvQC0IUW5QRa1jnF6NNfaaq5mXIwS4c6NPzy9ao3LVScS2nzXBknCwoyHRsUFTJFxRgA"); + yield return (HashHigh: 0xb28ecaa618d95c62UL, HashLow: 0x0c62112c99980982UL, Seed: 0x0000000000000000L, + Ascii: + "Mg2Aa578qi3oKeFQ0XdDZV1Cyef1uIn25WwxmN0F9XaPms6fRuOZJ9YAitOMw0eBpbEBtNeYeCB98kWYHlvLVSJUc8vY6c1DxlEF5i4Os6GsXj1W6MBWP1W0zsxSewIWw4OhQEXOW6Yc1p0ox5euNviAtnhGeKSJRO5qBGDiBfYK0ZEQwu4tTFf6QRHEzz5UbzMjWTHTVjP5LrXGQ89WbquVcGv1akXFla"); + yield return (HashHigh: 0x895e6f292e5b2e73UL, HashLow: 0xc2ab4e9915eae14fUL, Seed: 0x00000000000019e9L, + Ascii: + "90dXdie6aN17ABy652EGCdRAgJ3GyK87YkkL56gs8ts582dCH44SDG1zAQbL1B0Aygbg6PIehPzo7ftrIVaAyVPXqmy0FqzcGooZ4RcVgxgUApEzQbYwv6mfG0Z5DjX2uMalHMQAum3khSwxmxy5NrjnasUOaWp3Pgvtsdnk96za6ZhTiElU8ukznJRidGnLWQwuk0fFF3vr0JyVentetezX2kCTGgnkVK"); + yield return (HashHigh: 0xe37d0c58641d7fa6UL, HashLow: 0xdc5182d362ea7f41UL, Seed: 0x000000000000103dL, + Ascii: + "KoLiG5gWNCyjrekQ5dPdUm66ofTKFKMh2hxGQf3Jb4OBHZ8Jqyz3IU7lBKrFpzokB5kkQb4tCs1NeLvJGZCgWXU0iPlRVv3NOlLLbyfcWyG4HBcMGyNaYZjoOfLUwjsF5gV6ltLrEEr9ZhDN7UQbvRKUCwL7MKgqSug1D4DetkXVfXsiYFoCXQoxCswyqns3pnIqSn4rrnHreSRF76fjikfA1uSIWN0bz2"); + yield return (HashHigh: 0xa80fa19ae264686fUL, HashLow: 0x915d2bdb92285b39UL, Seed: 0x000000000000066fL, + Ascii: + "oysBKVVZRJbhE5n0hyTfIO1IN1ssqnLBrfWge4bT8JhW9oxpl63nCtzliNCPe4OWwFlBo8B3bjbgW1PrNprj2J4FvRCTTmsyIRNqReKJZNs4bbzIXLpgExQNmQfVk8ohGkuFxUpEuBw70M5faz7XWHPNo2xWg4GNWaVndgG0d4Z3sE4c9Mx3jdgXHR2MoL05GvFInzQkgXFHekvYc5Iletzi3VEYJHn3ZN"); + yield return (HashHigh: 0x46411c593e71dec2UL, HashLow: 0xcead3a004eef09c0UL, Seed: 0x0000000000001b12L, + Ascii: + "iqArWz0yyJSkrpEuRw827vrJUn8bdV63OFFF08kPfy0L0BXNtXU0X5KMbLmQR4SLh5nBETIsk0KNdV6MJl4tL6CJJuSr0MayRY9Aoe7VO7Lp8Aj7SDemgZ6CmqS9aUWy1UlKWIt2nNFYp1Hec3QiMLu1aXsDJfLhrLUxZXUcmPy11RPAP9z3whKL0FtLXrA0QZ6GgdgfYPEv0uzbzzlpYqj4kmSSCz1SLa6"); + yield return (HashHigh: 0xfbf24128ee1152feUL, HashLow: 0x69e6dc310be2267eUL, Seed: 0x0000000000000248L, + Ascii: + "bQG0CwxjjRELQAdre7vEAPYgs0ZvlU9fgqLDOArJB4A9HNYmSMY4bbH8EiguwX31seg7sRxBnfHHk1jrfuL4IAwlOKhYpWX2eMKmJDrAOPSLpT3oev2c7WYB1lrL1XH9o2D2yZPOnYWW0RzmCMMnB0yUUuNWEgPFENSwotfD90kZtC3sGPPHAKikVHiZO11W6J2z3W7P8YmdQp6MENhsVjXsdHrzlAoklM3"); + yield return (HashHigh: 0x3f476109e8953cb3UL, HashLow: 0x059fe85a5d818609UL, Seed: 0x0000000000000000L, + Ascii: + "0nZfUPdj3ewov9qOUFEai4Rz8U8KL5MfpqnxHnBG7eKYVLpYuCqlFBQ51pZ60QSg6w5AQsLxqThQWq8yF7GjG4eoJfEf7cFycOx72vLSc8lOPcufrmbeHpE5Bl8tvGVxWIuCXhVVmkqUpKhTQu0roVylcMK4V1jUBmGjAdyRnSedPxAzwT6F5tk1U0OZGxmgvZVpH0vP8KcXWTCSHSaOTA2mZnvvFVeVYuL"); + yield return (HashHigh: 0x99457054a98bc910UL, HashLow: 0x0b51939414aa0873UL, Seed: 0x0000000000000ad8L, + Ascii: + "ZVIRu9Rob0qOuJSdtT6diIt8vfTaV20KZTNxiLiYdKfnvEVsYS3f5hMqYpWxz13FsksZgvg2z1YM4GmjRkzRXrUZFKvCf0R5JFqBflGQ0K7oriGjCZYgoSxhJSld3ke8APgGVcBnPBGghYoKPBBoF7mp7Z8HCciEj9V4fYUPpgc9mjAaaXChW0QeZFbHdAMdAlhFdQjQGTWgoW0EFJ7w41aGD6QTyUvmjv1I"); + yield return (HashHigh: 0xaf93eab63b55ec0eUL, HashLow: 0x2e4991729b41aa82UL, Seed: 0x000000000000107fL, + Ascii: + "geRSNrQuZqWr5zPtwTnv8aNuLuJnDufynqqQmFH67hy7hTn0zyeX0VZrisMHm9gMkW5smugA0hjHtaSbriDB4G20IKrYyezXVN7pL0Zd3VNAPrU7t7SNJ5Jg9jlDRS69F5WLEEanb1AMXQZyuUla81lFSm5Bgugudly9JbF82NwpbZW8ZsN611xGzBVfHUqCXBH6VQh5yCr6GrQ5kWUmGTVYn76veuMpR4OO"); + yield return (HashHigh: 0x006751a9a91f4c9eUL, HashLow: 0xe901c20aa3fcc1f4UL, Seed: 0x000000000000075aL, + Ascii: + "QmY5yiBfM5iKcOcKBh1FhXXZcnHMXfHWWUQHJo97trTjWEqgHjr8Y1QYR3u6gaZKydIPUXXlGybBNnML7ia5FHB0E53K1VriIrGr0usuZyrP3d1zHkKKPCEdKxhWxs1bhzgwbUYdsKzUPiMVyVNlHKIYtQMF1ufn0EY9yt7crX70FRjafZ9xBI1PR0NEuHLv8khRtAMaimR5Sxb0xKZLASuc51jF31rmOYNW"); + yield return (HashHigh: 0xcb1ce11ee014da02UL, HashLow: 0x210e30cf8d7402ffUL, Seed: 0x0000000000000120L, + Ascii: + "ENUbVCQu3gZc63rKyJ9rF5h0pmk0K5fzfNCobpUnZCrSRwBhAGFUCPAEepGxVILklkEjyxSmla89sveifPgoqaSGDn94g0L4qgGbKfSQhE7qKncbGgaM9m5cSdxumPRkDrcBA7wJ41CoynKaYDP2f9Qdfbc6rtzPG17vPtKWeyRl3lnnzlMKF7B2jU9cAzDMTeZrdLA38LZPqFHazN0xsAI6QU79ty1cAR4B"); + yield return (HashHigh: 0x6682c9728a22f4feUL, HashLow: 0x8be14a7a1ae50211UL, Seed: 0x00000000000015b3L, + Ascii: + "32fNLnH4iMH1yWxQjJ2HPAn0rGSYzU4hZlKsCsVZKYyFbQd5uM4exCun2TW3IkNPUHyQP3msMXPFegpssk2tBFbitkOaTEX6jKiDfHCjJ1BCbJOR8eetVs3VpNnf2kFzTPdNvZRpIXD1BnCUqwgi2IMEYLoLUwKibUY11cL7fLEeKKFwrot9x3DnUOvL69Mr3Ubmb4EkKtRUB4J08Y9VynHCQ6F1tFxJqhQnb"); + yield return (HashHigh: 0x9b6ea90e01908c00UL, HashLow: 0x708b4a3fd703a62bUL, Seed: 0x0000000000000496L, + Ascii: + "D3ItgWHDnRAYV18wCoBGjf3Ay7ensCZODX45bdKZ24lBI5F9JrEJoVTY8bk7J5izL4zrG1QjwJBnisdNVrAT5Q0SlHGROnGNMChG4lhbyCOwGDRKb4LarSDlRSI0vmTkGdCQ0oma6ijguL2g3QGGYPiMbom7Qb3MQbGo3u4GkTqnNWiPZKfxj7CV6BedzRA9WEfaTBkvSo3FNnc4Bo0ubeZabTfcesiO2zJ6G"); + yield return (HashHigh: 0x9901fddc33003147UL, HashLow: 0xd19d88194457e39bUL, Seed: 0x0000000000000000L, + Ascii: + "fBecYKgD7Wzw6TVIsxoegWUON8UlPGtDbx8evocil8TUN8JenRPZK07JStDLbp2eAhJfds0knxc1JdEYlhNM696ol0mKyeAimErejkrrJehHzqANEIt5LIvHXw8oC68SGBEGLcaRhstoDmdh5D4ulam0rUc0Z9KiesBCu0neindQwOLRA0Ej0vfeYBdhyNEiki6FYzCRaLWsrpPEOZALpZZmz5Y2is4ChSBTr"); + yield return (HashHigh: 0x52d17504be201e34UL, HashLow: 0x8d113c8011acfbd6UL, Seed: 0x0000000000000000L, + Ascii: + "6h5WS7LLG1EOdfPLy5v5cgJvKHlmi7yZqzTGZeDECOpm7X1Ofy96jzIGPBbQqzl5qFE8JO4tNKrv9OFoJGBN6xWvVyHvPKq8lHCFkAFTKWcNM0KaUTrDmGp3fHyR9moZ0Jj050nBMfGr82jIMNlT3RFHjbhQ4Rmf4HG2ZW7cPKJvNDfGeJSIooX82A6L3fEdm219N4KYzbIHC7nZRzJjPtx4DJeLwGvpipwOWm"); + yield return (HashHigh: 0x5e59331857b62770UL, HashLow: 0xa46887d66d485fdeUL, Seed: 0x0000000000002702L, + Ascii: + "O21hsDzuNkt0terpCdAFFQJITRnVZInheD46IZZCMrsJrLnA9j9LWC0rBlWfApMWjHyFn3xlWLkUTQjaSAY1Fkk5Z3FXP6qJLNjR1IsPoZF5H67KK8w0Bp40rSkguilH3AYp9YpV3TI3GRlk0CaQAUc2dj8avN7a2bgB0OXh0T35oEnk2BO8ydKR5Qu9DJfPZsuF5lQUsdzyk8NTJECabDtb0ikuPhW1ZnzQmd"); + yield return (HashHigh: 0x742f1d9f43d44f76UL, HashLow: 0x7e57a13b70f1f16eUL, Seed: 0x000000000000196fL, + Ascii: + "4NUz3yRrnE44DpvKA43wNKC00KkXFLxPwlhqz3Sn946nwjqKc3N1Z8Gl2qqV5EtBvZ6LCrty17v1Kn5aCI8j154J753wRiREtyGfAeYNHE2ulSBKKiLUpvtHJzQIhEjPwpz1rtP4rZi6H7yoz1mfG6dGqV6BhszaAYywJUwXrqhAoKWT5vOaxa9fvIeuKt3IGWdAd0b2XAEtljeVv1qXIPrYkRiFpWtstdCYU1"); + yield return (HashHigh: 0x242f85f3945b55aaUL, HashLow: 0x4ec922557f772e1aUL, Seed: 0x0000000000000112L, + Ascii: + "7oZ5NgmZh9J557vhCTsDJtgce835yhalytjn3NPcWpfg9EEKrzhXQhU6A91m2D5pPlLL0hr60wORRLrjpsZTFIEReKrqJ3RTpk7jTB8M1nBZy0LvFF6j8pILYS6IvpgtxSMn6yzySWv7u3oYYNUiCiq29wKNYDR29R46AwkAg4fLBkuriCYhbBkDbwQ4r1Xtrcx5fseAM9GhO7HrUsBhsGj10JAlew9vRXpphP"); + yield return (HashHigh: 0x1ec5875533a5935bUL, HashLow: 0xf1931a8854a28de1UL, Seed: 0x0000000000001fd9L, + Ascii: + "isND9RcrdR1ITMnEIUV5wTjQ4lbFdThVBcxEvC4zp78k5JHPjPFwIfyQeNYU0oF9lZ9lZyDGU59C19YUA8PAsfiTIivWB9qvyntquc3GoPiNQzAxNaqUw7gRIINzQK3YNXmwzoBVNZW562u7DQk6h0KjaRZIQyEdJPUgvCsGTSNFAPTdgc4ChuO4YJihrdY9qrQkIAcJiU4OnaFFSDIsQ34abJ0kYy5LrHqk5HZ"); + yield return (HashHigh: 0x01edc0a0ef305c93UL, HashLow: 0x39d295c23bf2c7dfUL, Seed: 0x000000000000174eL, + Ascii: + "j5hGuIZzpHZXY8V2jANqt5KqQVe5fjiOI5GLkM5PNpxeUvYnZDUdf8OPaYKWxsrs8Z01Zham5ChDz8sCutlDqCU0Vru567AMpwbSbnbiNGS0UuZ4AWNrXtwp7bShtQEjMuJlxYv3gy6V5B09OAhx0eyNKgxdMMX4FMEvsCWVg7Q56XTHOVHsRlbptSakG243LwopneNyNd9QOcszLOzp9lxg1AFJOgPoozvNOYR"); + yield return (HashHigh: 0xc267af4655bef716UL, HashLow: 0x04e847100d0bf256UL, Seed: 0x0000000000000000L, + Ascii: + "vyeHqoDe8ia5SXHl1CRqcr9cn52bCCM2jN0h0d8WXC62Y2hbhk25ig3UVynISL8H62zHnTtvl6MjhgIwBROKT1AUVlUq0UNLYHmgpgZ4AR2DnhWwscyJiUCJlG5gE8su4FsaFQteM5DW3qlyPQ9u7xvOaJk9YNaoR7IIvMbbGeqqvltPE408wCJQSZQ4ay5KQV0tOmylxj8jznPgSSy7xPf0M0wM9H91m8fUAnI"); + yield return (HashHigh: 0x6900aeaa8d9204b9UL, HashLow: 0xebfb682540d182d5UL, Seed: 0x0000000000000390L, + Ascii: + "7AKcE2gF94Hq9ygXiit8Y2wwWDQsygmCh3nPWwTDlexJyM6geusUORNjCGoqagQsDI1kSrY0pV2ftX86dTdRHjTNOcqXcHq4yUwlLvVYfJcVG7J8WttHQe8igkwO497yiGSHKkrpqLR94iteEs7ANQMRfM9SxRB0vxlTEPEocnFh0YROxPPBZ0KdT6eXtdxnbUBt76wG7W8A4kiul6Nidx6hvoAfEs4ff8hrOUPB"); + yield return (HashHigh: 0xf942630094b2c371UL, HashLow: 0x056f97be8930cddfUL, Seed: 0x000000000000072eL, + Ascii: + "myXEIWnV1uW5B2AyOD6E6hs9YJnfHkQIwBnNM26Jd7AQVqWu1QEzJbJ2x2ZiUjaPS74RFwBpi15wsl9I1MkGUJj1xJJjIpmsMIQOGb9diyvvTRo8RmhYn280Uhu2gEWVtb4ZbD1Fz7QkdeRptgBISxS1XrI60tuDWxvBLssPNxKcneLVWw2Oop6M9Lcb13XLw5g1tiLNQR8gmmesML3L9YXLrjRAyHA2JQ4QF84e"); + yield return (HashHigh: 0x651078b8c0773341UL, HashLow: 0x02250ec6295a6512UL, Seed: 0x0000000000000000L, + Ascii: + "7AnVvxpxeUBaAeyTIk02DR7KLyfM03bxx1ENtgncWrLyLkiYbvOb9REGHXlc88iQ4v95JdLYVL6DLcnVqn6TsMM3HW4mmIfeDdHQNJTPXKiiRBt1hxx3N0T38sytGxwgjjNRHMeSt3sdEfkFm2ZGUg7UJCrsPtXC5zogxEH2M1NUeHNM3l2xFbEWG8Oy31f8FiMqKHHbnprqgk6B4ScNVu52D1A4ByWBJTnQOb4Z"); + yield return (HashHigh: 0xae05052816226a7fUL, HashLow: 0x9a997c8bc8a7de6dUL, Seed: 0x00000000000019d9L, + Ascii: + "xlbYnRAxf1QoDVc3WawSh7UOF98XvXnMUpW2UBedxdXMoOxwyN8ya5zAPXEsRi3YXmu22XqCIgaUe2WfpDBwNJf9ZOLfp67GY5Y9SzwZowZTjeiHz3OSop2nDNZ2TVybzLA9A904j5FVF3rPXZMAqRkrrh648gB88y0NH19Unzze5ogiXOjvGHHW51UAiCzUvx3TqZer53wCbtjVdxikS71q1s4QrYR7anJhmoPu"); + yield return (HashHigh: 0x24f3bc8f707d6ea3UL, HashLow: 0x6ec5a5c31c4b4ba7UL, Seed: 0x00000000000014deL, + Ascii: + "9ZZ0jTByvCFhgV4REwj0BX99tRoHRe4GwvI8qkZ6W9au2OPhP4anea7LuFOELlE01MC2ZALviOpZg27Y6jJnneLSVPGjgswjWkqxQZPIykGeuXZPYwetdEX4hqzVobvYw47NiGsqpCVaru552qOOQR2Uvs4Vls7DNyZVLo85bgmvjowJKRejb6Ju3IGl0kBAU2JRJ8ViVkuDxUpP5JIBrzSzmAUz5pqjSCD8dIUXo"); + yield return (HashHigh: 0xe05f3cedcbf7d929UL, HashLow: 0x5269659736a7f64aUL, Seed: 0x00000000000008e3L, + Ascii: + "rUkprWbCHMids1dz2b17N3tHHvMd4B7QjuzzOnnuui52tXq8Zp2cWfRbuRp8eZexIDSIZOnpnJgvrt84ebnQKYbvG8omiLiGopIVnQDNRpd5Sa8vtqK9hlE4U31pEFrJOReK8qEY78XpDrbZMp2EvmKLqDtaTM3uJkULmPkYjXC2HgRfWtBrM5jbCpK8Cevt8rJKb3W4VcUxYpu5hhEGc4Zp5tr1vwm36axDHKefR"); + yield return (HashHigh: 0x6c644bc692b7b7f0UL, HashLow: 0x3fe0fa26c17797d4UL, Seed: 0x0000000000000000L, + Ascii: + "vVshxkFpwcssocHgztFkbNSbxwCqBOKVuDQV2zmvnKHTCcgrwgiGcRqJu1F1RwVLcFzqSOs6RFsEeyPnMdxtOoexeu879rPBczE2sMbw7hSLj54YPsUUDRBbpkrEZ3CufODNiwMX5oxpqFDT959Nbb9odz3NrRkvEuiylVb4G6KkCH2Go4aPoPpgqd6cG9Waw89w7LtqcZf6kzIXn11WG4pBNAHWU1Oqrfex6kviZ"); + yield return (HashHigh: 0x64ed6d63ec85f758UL, HashLow: 0x61862e3429844789UL, Seed: 0x00000000000011d3L, + Ascii: + "C4tWTBxJfptCCTMchfrhMAs9rjMpFuOZvkmIxHG23FLHrg1rkY8jwEnOqrK7EWxDUHWnjZcfr7tnNwUq9Jaf3A1qqYAihQYQGyZlLkzLaOuiU1j438TlTnLlp6t3vYPeHIcZwgRIc7eyIp73gQaoBgAeHbTEuONTKJ0iUTQQuiTvMN82T7SpIwjGMFKPcCKQqWtPilyM5N5VfreyLFW6DibHnx8snGKldAmVTDVzEp"); + yield return (HashHigh: 0x8b1e3472e1ac9a66UL, HashLow: 0x8f628af6a1908b28UL, Seed: 0x0000000000002121L, + Ascii: + "88zsKqhN7uandbNaTDhAKTnA5SajgVnACX2p3Vu2IekQIA2miHwCfmmjCjyy8lDq4qIC80exb0q6zbLaOMTzYGNqo5AvtEafsPmS8Ge9YDIq6hHwUS11pwjdf147SBFbdLuzBEZ7HW1doMgFsSPn4v4dANqVRZOxxrSbUUkPVhJpBbiI4QQLw0CtjAQFJHKWMiRWKKpnnmHxtXc1cbLZgJfbexucbUHUmZ6IgPbsnL"); + yield return (HashHigh: 0xb065e744cb607cbfUL, HashLow: 0xf7d4922ef773e054UL, Seed: 0x0000000000001a91L, + Ascii: + "46oflCJXgfz8y1xwJy564zxDu29wdODudwT4lHMUCPExhMtoyLIupLwpw7J8dxRwrzsf0dLG12D3Rh7J3kpenSXQLLsAC4UKvuC3P9NAoIjRNFlXOmjYblIzIviA03qpzmIWvl4qJkzJsVbjFUCEWVKOtL5SlMXNc40tw4M76LbCn4oV2qpbN68wBLX4JBoV86x2VQcuiP3kC55gTtRdU9ekfdbCpaaZtgspSegSSl"); + yield return (HashHigh: 0x79e567a8ef8790b8UL, HashLow: 0x8ec56151d5475a2eUL, Seed: 0x0000000000000000L, + Ascii: + "8gvtplYsrLdFspMwUKfZeIJTtb5WXL4STd47kufbMfMWyb8B1PqhlWGnbhOYObNOhdpWaMggYiuBL6tjH2qabB52NbVwm0TJJ4zDUqVPVw1NFmsFftl1DJpnh9wFB1107wtPWdWSRlbf12eLabbGV8APtmRrVHT3DZADyW3h6z4S6YRoIeaU209Y9MA5YWpX5VpTyJ4BaEXPpATE4EX43gswKBUTfpMbis2tUQB2Gz"); + yield return (HashHigh: 0xd43bfd3229218adeUL, HashLow: 0xfcb12b7a4140fa92UL, Seed: 0x0000000000000000L, + Ascii: + "cNYvYuZsq06i7H7WLyfFupM0LMSPAl0YG9GIQlb2j1MpUEOHTJMNhSixgozom286SIRoWESHtQpqmpxQqL3M5gnNpbLetqfKr5XTrS0kZ85t4dnxHzRhnQ227DuqoTUlwPbHlsC68fSOUgR72IUSPH4tVAza8LKjYXDR32AyU6xosyqJjUOiGWTfCZvBoOgOxQtLKWcu0zbiGo9wuB5fuKQQhm9mHPQ1qUPr97UTvGC"); + yield return (HashHigh: 0x9b1a6cc32abe529aUL, HashLow: 0x4f0851b91a94b9b1UL, Seed: 0x39f52b1b0c535141L, + Ascii: + "Fg5rgyd7wAL8cmS5FUJ9DopvpyB0hbrMEq8KCrbVYWoZ5oGCc5zAZ01ICohJ7xxE39O9RIZU5IHns7A9WaoLatO1M8am7ymYr8yy6YslbcpdR1T7xMhN7uRHbF0TjTvtRGPzLv5vd4nRA6XrCXPAj4ctcXE7l7GpY3sfOK5m7ZpfYsL0NA917z1zR3Ljfx3qspHMnAP7LSCyw4Eb8EOBwdZ1fN9bRL8NOBkerIC7mha"); + yield return (HashHigh: 0x0eafb11616ea0e8fUL, HashLow: 0xb9d805f92225fc11UL, Seed: 0x0000000000001163L, + Ascii: + "0gY41Jalya9vYJjOXT5D0Cv1RCFCUzdzKYlttwov2v4ZJ5Q0qfKAvuQNYeTtsOKqMpbgStqsEiCaSTyPZ5rveLC8vxnHiiALJEFKwEyatTXJPs0onHxUFWCGN8cKIEE180cHtTlBQjDPmNGhH41lfK9smaVf4AKYWMRpNpI5KF5GNlkHIqDvh15GUdcb7oSdRr8Y4uvyCYDIIlNjA2hLmPmL2WPyIiVxzZLS2hF2F5g"); + yield return (HashHigh: 0xc63a05f2b32557d4UL, HashLow: 0xb1a867e5db639b70UL, Seed: 0x000000000000083cL, + Ascii: + "lcweVocSaVB1nJiuE6h4ebmEKbN5OqNy6krCy1t9u0sYEVoP4pWOQis7qUf0BZYispUnrt09uVOPDmGFTIBNmF3lwWFhro0nRfuuhenbwibHy0KNy5LFMksHnC6r6wCf5JjfILEsZA6kIAjqxpUcs2i7tQyQM9wLWbVDwVNjxy03NlRrSKmjObfuYlxGlaCWARB41OmDS5kMJG4oyNmqMbAT1usQN8g5cSxN06XuUAd0"); + yield return (HashHigh: 0x8fe9cdbe949d8d77UL, HashLow: 0x5680f16726367131UL, Seed: 0x0000000000000c86L, + Ascii: + "Uhwt7Dz1vwYRowKUmx3n7eURaEJyDk9OFxdSp3NzqEG1g9BpBCwrEIVg8bXz9cZfPfkigdJN5W6i0F0vXclcpBxzcBdbj5hs5sEnOkLnYGsKQkKOXpD1ktgX5h2ByhukExqP0cXWyMpJYtOPJLOBkModEGOexc2gSlzDs13cEiG1jBD3069e2Y9dUxArwDjHQTTHadymOzp3TuynpFN9hcUT7IM2lYJor9SArYgvEJoZ"); + yield return (HashHigh: 0x775baba3e7abaceaUL, HashLow: 0xc588b66b3247e72dUL, Seed: 0x0000000000001986L, + Ascii: + "T1CPelBwyTr1stvMqH5JLWhpnlnA8EZVoylEZ0IfCp2brdRRul0m5V79DjDVMO0iz33FHQ3zeIFf1GZzbSbW1W2dWgXgh6d9joqLWx0Al3DHhosynGNgzgvnOnIydpS3Jr6M3bmErEtKGCzldILfBwAmJEI3nBpFZGfYH8lWGq2uoBqJpNFqdY8EeC5YUI1CV9N2wQd9V8fo6FLUJ58jcUDTxFUly0TjoYoY9zjc5RrM"); + yield return (HashHigh: 0xef146adbfa40e8e8UL, HashLow: 0xc3d0325bbe4f38bbUL, Seed: 0x0000000000001bc2L, + Ascii: + "lbA1aER8HIbsbNTyXgYw2QdKrLJMOWv3Ns0SBIpBMCvWfsUUrFTmz3pTKQmWWbnrx2sjo3aZXAYoctJcXc5AjudoORKZefO7rTlv4PSJEoLLEtPsKDi7I3AiNjmAx5YCLaS7TWqPonVMe6ht3s1cEq91i8hsUTtbBqvHfoC6O0aZXlUYxG8QQyMhCXqlX3W1iV3HpLa8AwGHB72eVw3LQB6YECAlRz91rgUTmRgLSVyq"); + yield return (HashHigh: 0xa88c7bfa03243ca0UL, HashLow: 0x1e6049840ca9627eUL, Seed: 0x5ba05907e31eb021L, + Ascii: + "SuOT6LZK4c1gthmKUbRPawWdadQQ9GOR0vKQqlq6YYZTFIvdrZZyqEeeW7ZZ4WOL1sqydeehtV7AxM6uv90X0CnBwnasBFo7oYC9OT4ux9GSNmSbvhdvaBnEJQbhtsz9jfDYpKCFrnjMGTgHTRcIRf5KBEONkJCnBWFiOQOkfBh3MmNXPri6kmS1EmZRdMfPdiLXPN0fKSeEBrpLRTKfJOO1xd2I4PwJR10EeN7K3PxBs"); + yield return (HashHigh: 0x720f95ac2546fe35UL, HashLow: 0x4a99be91113637c7UL, Seed: 0x00000000000008e9L, + Ascii: + "0YOh4gh7ncDM7FmOF0mK53DkVfcO6LlAjbbxOAQEHHXzbwbDcc5pFiws4g0S9G2a0Y80hFjfEtryoByiebv75jVjlGQPtwZx67pefBo0AyJCZUbQb7TmBKAcOKGhgaC7pmF2dZPGzBrAiJpfMGd48B2UDTKZMNLXZZRc4rmvHCC2z6P9IZoOWymNoB3e3TK70oFRgpHiqG45aKxHatoGRq6jxYwjYMwQg7nZFRHrNGT9y"); + yield return (HashHigh: 0x28ea84a1bfd4bdadUL, HashLow: 0x11457b654bdee031UL, Seed: 0x000000000000065cL, + Ascii: + "wKalrN29JvUsm53gnqKjg8th3UVwiwrUNeSKwDuKpWJLUhJJi51Tm2vhU9fA5iKeyJIIGlvnPACouqplAyr91f7vD9wG8GCNtvveTkq75MfXgI68psQ8Cu8VNjsnNmctg81mrPnNUf2x9jsEWgAl7pnUMN0gEvhpSpkzHHAwLXuXKGAzFpTeiNkoToKJbXLesQq7vUieskQ9yB6uVq7nTzNyRjvwlzLkv7j8fPNQCBKEK"); + yield return (HashHigh: 0x78fb51b420756317UL, HashLow: 0x5bfdf75995ecac84UL, Seed: 0x0000000000001245L, + Ascii: + "Rpp36ahhyCIgSWfeA7zHAAC1DzXYQZdSToI6F1WRlPDNotVy6AvrYYIu8Oki319xGhl3aSjQd5EmEUO2HgOh72Dv24wzulbiSo45qS73BxAYcZRZenk5oq0T1O4draIIGNChbyLpaVXk2oIEku7CixuAoKltwu14cfTikr3rWhNSGYgRLoS6OhRRsyqZyB8PQ6NqMc2yzidYXhlMoiyjwYY86oMSCJQPYYfJ7x2M3Tujow"); + yield return (HashHigh: 0xd2470c9fc8d59d8aUL, HashLow: 0xbf740401007c3642UL, Seed: 0x0000000000001894L, + Ascii: + "BxapM6Bj9U8ybZ7qGTDaBrVajPOUhCkFCrPyo1SjkcIJu9Nf9EbdVnwxLxqMuzfLAFI5FCmr2M6kf2lLn1QxNFWuGWI5zjCXklSWj6xUhAMSmfk92AKpTnTVgaAGvzkSQlcT7vGSpyFny8AeiNncSoc3PjuDbdqsWjLD6Sob8WCGO4faIuwohfhTec0yUALddr8oVgf2yDtIOxtsP2JyFOLLCOngEZbZqy8SL81DsXVfWa"); + yield return (HashHigh: 0x55636bfa715705cbUL, HashLow: 0x1a6773f4c2a08547UL, Seed: 0x0000000000000223L, + Ascii: + "ECtOyFI3zjPsJ3SjpmDSVV0oPkCmRB3CtYK1HIx7o6qDI5J7GXaZPr4YQ8UNILkLppiguZdiS0YmDTgDF8s2GUGLyYrpTfM2SOjCz4qBnnbnEbFuh7y6POH00gShC9p0FosAy7l3P8vYqCkeZQ1KjaRFGLnVw3Q0UkLeKWCbbI3fSSxU6apg2X4wSlTDPb6gzZrA5NGS3r3L68u8MhfgR1mnXVm1wOER3KOHf7iRYO0GQw"); + yield return (HashHigh: 0x4de37425afac5f8dUL, HashLow: 0x8f8e10a543b493f6UL, Seed: 0x0000000000001a92L, + Ascii: + "mma8l32S3LRF6fm7dYd9bhZsh9bO2FtCmBs2a8wOaNDVitVEuTiR3WTcwYMb6IvVIyb4RTT9IbW8R7rLTveJa2ZJrQfk2V5TZlsU7gULcs50QIkZst7dncj70d5HbjvNQGsW6NzrdcYmHDh2UL2C3ntic1iMv6Rnm83CfiuRkQQgUcdlMHbrXLHzn9FwBsc5j7HcCRBFfEgVAvSaLzvpVwFOUUONYNXrxQpig1ZbPbFh5Q"); + yield return (HashHigh: 0xb4261f0d1490b308UL, HashLow: 0x5c50073d0ffb7eb7UL, Seed: 0x0000000000000000L, + Ascii: + "1QzdPiIjLZsdR7JxhNnDCq79jAnpyHI4QtN03F6fMIfpkamA9dvnXsloBCAHt5SuhoLFYmEnpJa6rBA5PCemq6i4gpUdA5ROGVHlcoe7tSM94yrc4scqTZY8lXzSwF7FrfmfLVaW86qKCB82Ppj00TvStbgr3ZiWEUMdoJzNWfdUgAlUKWFwPV0g40G80aWDtbKNeB1dSO5tYOSVfNTFpIbWS44MOKKegPWQbXsqj2bqHJc"); + yield return (HashHigh: 0xb5243d1271b67cc0UL, HashLow: 0x720501fb39b87169UL, Seed: 0x0000000000001215L, + Ascii: + "UEVrGej4bdByOasGirKZMXe5lnOb1AjCjIrsS2gAw8OFOszvMM9zgFNYeiEEY99AUe46oWIMf98bsXX9UMiCLNF886dPtvzwpkz6k6DdW8UBYHLQdjKETvNZUAjw7ArGlv1uHJcPA4xZPoSCXdmDvUDqf2mZ5CUJ7cmXySCafuzUFq0eK996DoNM5L5DaTBM95QHXYaR34vsDFLE7KhfmBgoD03S9U8oizxHJkylOZavxVA"); + yield return (HashHigh: 0x0397d7ff16335f25UL, HashLow: 0x030577636cb6882aUL, Seed: 0x5612008dc6ed9806L, + Ascii: + "dsVmJjeoqmmID9IkVicCbJnEIZA1hxpj0wPlyCg7dCN4HFkeUmlF4n5GahSPdzKuC3VWvqUdYQcnymvqdHsvBvpgeAy6h4KUhlaQ3iM9EMKhWhH1DUzg4ZlDT9zYMBopdhgNjQsHxDbPDc5Bl3SD5wGeH3A38WyRU6x9QzeJc4fyjFD9uL8qJVbn3sSneFJQ6grobyzqLIZ4sLh6OjVcXbOWMWKzHGQ7K7HJarw787aB7hw"); + yield return (HashHigh: 0xea1c00cb841d0f4fUL, HashLow: 0x879884a1e65a2459UL, Seed: 0x00000000000016bdL, + Ascii: + "FdKNc9fjo7dTluFwLxwuOTXSzmzMgj9ItywHo7T6HQ5Fg39kHSVqullshpruTdP0BrEEcx652xt5USD0wkSzC8FQFxX8OHJKgBle5w450uePgZOP4hfAvzh0sNXzMVyyW9wUL1JUsG59Y0KvahNyZxO2hXNRVslyhy1LP0BDgA7dd1KUqM4ACALQOLUHDiAHyKMfONwEgX1G0zlJU5D4vTzTvNyqYGbytrcO4znn4SntVStm"); + yield return (HashHigh: 0xa282e3d70c5f254bUL, HashLow: 0x09de9f66182cdb3aUL, Seed: 0x0000000000001c75L, + Ascii: + "x3TbzUpexub17sbjFpLsvGvyMLRjSF1gN0tiPUfFwyfEH1MQCKARAA4RPvI3WvbzUkfu97LNuon6kMlgdJE89UesIF8IoiADhKhovTybJsDaTK88RsV4VjYvI1a9HDP0eNTfFzCJhZ2mEKArqgXyjLIOIkQRCPI1a95p1HQxdbFlmwgubyli3WJFzdls07676LeCLKod7ZmsxqJhuRJ7khw6eWJzIpT0fLl25g0kyku8NUlj"); + yield return (HashHigh: 0xcaca634dc4a96947UL, HashLow: 0x7c75bc55a5d25519UL, Seed: 0x0000000000000e2cL, + Ascii: + "mvOuW5Er55j43BJSdhWYGEPxIBc8XLthVAFLhy60A4s3DZ98dlpnPWPA4JsDQCv7cgV8Z2Hyzaz1hErmHCWowCvxllLqdFSxQ2lQKMWaMTAAnUwcqxZdu5SzOzikRgf3X5zWUqvJPJXgsT8jsdJNJIYmaJqDVZCIpnBilqZiNoImlgM7LPMr9Wy5GLYrBdlNsHdHRbsk4k32UXUQUeiuxKlL2lZZhVZJnPA6O5xyV9iOpGfx"); + yield return (HashHigh: 0x71a8f9355f01256aUL, HashLow: 0xc80dbc9e7ca8c151UL, Seed: 0x0000000000002521L, + Ascii: + "KQ0ok3bAflZ1shhiIlX98i3I44BKFr4kqZmNITmCKCWnDn6sa8SEStoPYmFhAuFJJjdcgIVKa1gfUTq8GArzFpA43NaCTcXYRvH5jO5PNPXCTwGfd2J2tmtWGC0vIMR4sfCAIXrUHtEsLVEu5w0CeHRfBJZpGjSMgAD3WmIJgeTGrmnrWIJpiAgG46vKVz2tRaEmUpzbBFPiGR6JNlfNOVOo2u32NWRpYrlpQP1acQVbOE1d"); + yield return (HashHigh: 0x381ddc601f6ab794UL, HashLow: 0x2f37d7c5257055c5UL, Seed: 0x000000000000021fL, + Ascii: + "a2WBB5GKMkHnAySB7uXFtoT8z1GgX0MPgzX4Zu4QWjZ5sfUPXZq3UXFUbG74Fw8Jk55geWbT9PB35YSVEbtIizEgLcpOll09vmDXlLcR6MxmGl6apvXEAodsve1dgw4eq9Lsx8LLdd5kJY1HlJL7Sd4fckloMiVNR1n8UdOzUdyZa0T0iKRc9wYvpG6py0QWwevVqXlZjwEyYmSQsHoXEtwzjUaRL5Fx15E21ANuyugJVKk7Sgmi8CVrQYFQZbeF6e2POv5ZFzf1OgjLnYHp0xpfWDD8uOKH4zE882uBMshXjVSjFRY9Yv5rKdymxkR4VMTZTNPNgiuPJSKQlt0XU2NdzVdH7iTNZ3Hxt1vIyFEtqCqHjFGxXPNaPGJbioubL3hGCs5lqEOVPHHNQNxjhmzmyS3O2DsZrvXkFbD1HpLisgz6T4S3mEJ3tDhzWpAkC3UnitHpgaoJnyBa0EchtNbtekxnSBQ6yShQN3CktaPjfTfGWMmUzkYOZFoG2dYZ"); + yield return (HashHigh: 0x6f5bbac339994527UL, HashLow: 0xda2ff091f3590e72UL, Seed: 0x0000000000001865L, + Ascii: + "USxLu2Huv2su0RCa7ZAFf0cMpMLk7oYmPAUhnDBXAQyRMWT8Eoryj3FWiuo6LaGF60OFmx5lUXL6jvD741QrSZ54Ik312oxZurB9bBdCwQVzfnM65KgPdW3Adl5EQCf2zY8v9KZmkSjp6hIBc0iBhJtB1Pj2keW35tvQQhTfMWhmIHM2ZpB4AwK8aPrax3EmoGvs2sjcaijbVZOBQu1SNff8QmAWK4k6FldD3a7oz0OYk1rxaTccT2qoouqwBbgNvYXcsRlkH8s0F9FLRTAXYmYKro224xjli6ZdsoegrhrJjoPsNERGh5xm9mBGdadQRo4ZHLPoEpGWRq2u8gX9bM9jcellAeT7jJDIjXfsc9CfdPzF454x7H8D2Duh6TdRVnE56strIx1urtfbfqK4uH23JUgzsD3S9zasTsyatKv2DdbNSBs1zqBTGIDxwRyOF6Y7Z1UIjP2U7oLLzI7IwdaOzZmdnTJWTGqGO1y6xjjv7o0dzjRCtkfN0HFWF6C4AWQkj15GfEopfbw3nohIo9d9LdAZ9beW3Wt0mMTkg3UqgtpcQad3uRQj3Qwo2hXfxSF4OI4o7CF353coopSScASXKxSgSOTKSp0txdPBHpEGjlBjfyaLWbb4KF3lfAyzcFOdHhIXw4X5OXKfP9CzvWsBX30dJYPUM0iqMo4LPKyK6SSVakfTnMhfnWCkyt0q9FI2yn0hVkTs9qQuqSkH9INxYNhnn1OTDScudPq1d01hYCry4RtaxAbGYfvyGCcaua6MyGo5NDkrr8o6mXROvpDtX5LSqRLE8ArgGDmYkWeQx6whRPK7l5JRhN9NLOpglAUmOF8mstzQEcVhV8hK9xfXs0AdQZMMUrEQXgk2Qg1x02FNqKYbScPr5HWxxUc40fUHPhdllmC0f0CnrRE0xM8x9D1bgoVLkNBYQ34hATXuRd1wwKMXoOZ5Uw6lWAnUtpVB6e8Ns9XPYrJblJ61UD5RwHGczt4uv4Gla4SQ8zLLLq5rhRB2toDA3MiZc6wK"); + yield return (HashHigh: 0x42113bfd29cfadecUL, HashLow: 0x80eb9cc47d75ef79UL, Seed: 0x0000000000000000L, + Ascii: + "TI6XYevJji9MGqpXH8Wa3hChji5jt91W8MyhwuKrpPUEBwp9sqWdebdVvoOEfJ2vGg1lNZIvuLwmVDKd8Vou3qGCT5VcqI8goIxXDF0jZF0XDLAQXCFikOvcx0CvZZYJjBVqiY49rbSIAqw4CdR2ex3guwaubHERWWU1WL4AwBYvqM40BZVP52jArDymVhTEg7kjsEgOPQbYxHCOiE0OVgDxvOfvLfnOvbVHAbJtACeFR7EuTQhnYI7WrEPTjmbSLxdV62FAi1DYVdHLSmJm0gmyGTYI7oKrbv90hbIJgv4D5hUGi2S43rmLixssqtosdSUBhsH25qJvJx1FZ6rIhtYrajtDpaCNPS1pH5aAe4NtujDG9mqqmm9IFSqw19cAE6dGCTd8FgLlWCKt8Vdoqn5Wy39E15wkCzV4ZtpTd1tMfdiQtIf7LIZKOmPQUjkj62i1pLbam8EHradR8iF9ZskMU2u3W7e7e4IWdGFzubnoH266VZSTZPn9RcLhwN0yrE3AvNk9WjKW6vwRV6C0nl1n96ir7VKTD08l4Nh1RXopC2ASGF2P72byEwdue5n8KjCvkoYSJdbif9QNiLeZoGMUB64ufVknWPjMGqxBRzUXuhhoXlsh2clxhSVycHYFc2WvldpGt11R4wgobPmtcrgQG6zjvGNKzVDQDnHxGN68c7Ij7CrghizJu14vZwfElUxoaPsdU1u0Uz8Re8XSR6O4NE7Rd3uo3EOSr3CVTjXTlKYMyheNzTTA3UsywfQJhK6W6aB2QZLrpwb27FBciHiXGsTGzJya3YeG1mCTRpCTNK0RY1EqBzzU6HI2rvHQhR6GLaVMVb4GXKqfi4NaSaj7h4kuFNc2M2Mu2VrznLBmBZ53Le6YeKpET1U40DROIhFWetZjD7kswu5xduEB6CCQDhHz2ZQWzivVHu5970LFcMI5oxwdUuOoIpgBAit3QNlqaHcvRKK8dR2TNl84AkLlxFnGx6HQHA4hPsFvfPJbAoHycCL7YcJIQGgZlGKB" + + "ByZdEP6ZSs0vp5MNmIjRxJU7fxuTfgGUj1uMX7AnHZOktctLuT0dqJZ4uLwX55RxnibG7N9KsBMW2ic4h9bCEUVh9NsWYK6SuWzm6q7xBL4tcLtTkdVotWlmEGfUHd5RBuUZW7HaizfB5obQMgkRt6M7U9zMhruYY1RYsQOCHpCrefvcYrMCu2oass3T3l08fMudGelG6E0wAnDhHlBzJ9ACn0zjS6bxxV8IGPW5DtUCxfq1sTMs9T05DLAWVIP2ldLoRSaShmjZ3WP0iA97qgBVcSReu53OLYmmcnCUz5WBvmUpbLdf5mcCoshyJUprc1NXMhVJtrrt7FUMrEsXjMyusQapvduAo1eIYF7YGHVgN63lnZ7xPNaDERPHaIgtF3inQSKDLg3SF1sBR5y7FcYUS5cq1HefxvgWyx55uNCyRHIq6a5QHLLZqnuMcM0BvRrrsQchEn6uTfBvsnhycJNhKAUNbanKOKF95gNUEFIro7PHKB1sehxxAoa64oF3OctnFnSn5LintZDACNenvgwq3x2bCyE32zA7QHESF5f2TOmMzT0xKJOXShS2PcOThuFnsX5YIeS6N8BxX2C3wmld5Ka17I89K5msFZZnmhdk5y1iOyoeY3hP8bQgo5fNSaRgp6FIGpiU3z5sKTvEBJ8c6VmaS79PyDHYMHtNqv8FWRWmrY2cHlA3AFu9kyLwZpqIAWmiseRwZFRzFqF5rUtzPfwu0rxrxyJCVIbno4mrgjD5WP5CFXgAMrb9IxvvAteyEGmgs8Lvf5rLAqvyxASEA6FboVWVTPbwSCCx4SaknSMQlpIueBfbQFPQAnvZWiqFTi5A8CER6hdngTvNDXs2HjlCpJYphlkT7DRwwA6LUP2BwtKHBVAo3gR7wwexkoy0oRbA5cHwZtt1peKLp7gj2L2R3lcgtecll4lpcDo1GvBrwJAgkhDXwNZCRbVaCypqszwzET6XMv9ehWsLM5XvIaRFG6Oxmx12YzsggT22tPZP3dz6hzflpGsS7GgD"); + yield return (HashHigh: 0x586d70310b7b0495UL, HashLow: 0x58793064f61ffc57UL, Seed: 0x104dff97b01e2965L, + Ascii: + "OeWmLYqrzy5uyrJpXEdAKKylrcZqYQ3vcpqZ5qMNlhCR2cSVfKIImaObd0qLjRPXXtHA3Ql0vBXbWRKXcCTxLpVAiPRx39Rgc8F6tMTBhLKh3rIq3ZU8r21tsdsnsnmHfxFgdcRTjdacf3Ml8eQIH8eelifyq3po08CvFbR1WF4DCDuRNCBd8THV6eTVMumdzRG2L9Vr2qVDsRkSzaDKAghjfLrnhxbDxtcXJKA8Lw9aIFJSNozCtGDot21N92AXwf3kZvikQGhV5QZMDJ39WrI1SdjfCOlQZrPRjX85HM3tJIoaBwRw57w8nYCIxehAMCQ1fAWMgdb2AfLhE9soOJaiLpbf0XurnnQXqb3Uy5DVhBUFQ4MLxdwHEzhQRwcnjeOo5iDW81WPtqQCYp7OueHrRWifcINoafhfqS0A7QenNkMsKwCjsJmYRfcyqzu6P1FzBdr7QTIyINomxHE5uD6pgtGF0HoM3TnaVwsTOaEnniG7CiOsV1knedfzG65NDXYk4zauhOdr5kBORn1dkPwYXr1fZJ0FciuyauTpN7pSWmpvihiUaiuNZsprWmENYhri5NT7GlrIdlMLyM2jztAiZI0ZCGV4It1WSv691Nlfc9TPBWFxaPK9Qibx16VY7JDheIxrDxw31F3NetfAytzINetjw28OYm8iiulIAqTrhZOoebesbnT2c2BkkWgCVVJpxmtR9RGDaiMag9fzQ6QTZK3Rh8vuKdJc8Gi7Nh1sK3DAqTcTzkW5LNNrQXSyLEbkxxEEvl3lm4RSoZ3GMXfjbwkKI22PMce4YXeLP9KtKopHvbgQpJ5JLw5X5QKDyhB64f8tbbnNMDdTYPka7ywOoVEsNzYhnT9mYfwNR8sYrzqCFxWuwE8USYoXdzkvjzomC9lxLKO9N1s0cg2Dk0yUilnBHxmk49STdIaohJO3eA3Pja3Zrw0Ua2ZriE6rvIgBv2cZEb6JSalwDyYhCOSwYPN5SqQArXtG8MoQXfO0nhGzh3AMDuS4Go3BaEXH" + + "I6fcziqxna6gz3TOFO4a8XOFokCrDcPBArj6zlfAqfuAwD4wbjnmTUlTA8boOHPyZ0LFaKek5DOftarl7HO7XIzVZ23X0KgKNhxOHh3S439t6HpkUqxWb8nAf6jLSVDHKbPXVGHorGnMbSyZb49BQKGidNnHZQoxT2DOmQuhOJHs31cbriBIrQKAQZaAvsVLa2vn8YbjguekDWBFqk3Q4V26Xmrm4McUUuIwHG6pCUXDyGeYANgcy6r2Ngw6DrueDQo3tTJn2xO1258T82KQbmK73LKo1ZDdCt7S6plQ1tEsJYL9bDcr0e0DhZH51NGnEZcLhnG0z83NQmfoaj7eeijY0MehsOCfWKIZu9lemMwmblrVZrTlsWA8kvHRFgLWrKGjzjVaN30dEZFpp3nN5B3WQ54oqjqCRLMDJUUBW6oTa15sBBq8zljziyJRFlNlQJyVKViGB2ZJEZC4l3Td0LLsimO2XyQKqq4rFZe7B6QVeG8xly84d3QfYatQqVqN1IkD9u2SUzfhs15Qmg9vGmtWLbbaTbjmYwTm58geEcBIQwTyUkl6HUdBGs1oaKL7kFevkXEGWjt1yOXLyUOwA0mi2XKOp3sXDZXZFeQYMC23UuA4RDvL4cyBNel9pTNOlw1UzR1kD5Mn36Mcmsm42i5lZrk1CoLpXanfS1aNuiK40ZcXyDvnszDQ3fOGCbRND8seacADmdpKFczhKe0f6dIJcMVNrWYUAuOjz29uyZfeALqc2OamzLV4LdpSbaebG4qDEcE5N4SQLRSvvdJvBkbmdllZ1IEWE64Ol8Ti22jlWTsrT6BWyXhm4D08K3v5UDVCwVbRwLLeGdBvoG31AU3KOfJWmDWthtlLdIigz1hatt0TWSB4vmfp7H6gVzFjK4e9HhofapuVpbE7duSsMcHVGZsQeS2DucQdjogVEHOFJ4XqTsIK8v4qvRyeGnQf5LHXlp49tKfffvGSRlmQaniYIjKXEVKYOs3QNwCDmRMOUb1kRngiKwnWkmz5EveB" + + "idPy67bwr05B7MQxSVsh3eXfjIrWw2AiiYC33Lthhrs07S9ALFGlfDhv3L2tejbBQ7NjBe0AT8NV4U1Q80quhJwCbybUWcLbf7GklusePDCzLURqrbn253MXP9vfgAedNniqRj4hks9XFoTd5pijUw6H1sxtYQsFXe4DcJyvRiS0tWOGxVJQrnZq6TEZPHo0Wj8xjIKtauJQihtOlU8ZRTdOdqiIcJf7f5erUBc3TDkKixLoxhh1fFYnLp9fPrc7I1ylCthBI3e3WFJGRZurCNwzBzCrhPQ0wLl7Z3fVz3cCfST4oaVsro55KRZ2RHgBx8JXMmaqLTFFp40d4JlPAE88HCzjX5TViHO1RNIVE2ajcGCVYB81pc4fgb9Dw3i8vIUpMYG06P2UDegFKVmsOR8gcfPwQOObdHDPSjBGK8uPgUd1NhbsgSGSV9KWlXciINbE5lqY0tticBerp7oS5lSag2UrAXizgVu1GaKSm9h98k5GZubwDDQbmSQ9jNyqg9u7CF6dpUoiF5rGVqps25Tg7B6vYYkydoaynDtvFf27XGw8N9XQUr5L7jxmYi50xCdQZhjxPpE76Wm5haYbTmrcqw2rm1tSFBk8x87f3cRrFjngfTA2aMD7bOENJyfPmHeFG9CpweDZSbzCb6Xasr0sGUmtDcb2gPoOV38BBOGkudVaK0jDgUXSy9a8sLJUHSM3hRxlcAX8VKhcd827830yRK7uUj39Xwwhl7WwPcX9vyt1QH7IpcqqvSSsXuGQWheBmIRjjpViU7q5rGSJtn339cYmtwiHFOHN5m60Qx3rcu6nyAl8uTjBHcGxum4oNz7f168MPvtxvmY57WVzNkekJYMyDQIeZEvNJtyogE6V0Uq2wbJwjwwQ0lOveOj2Jm0qDltUU9yOsYzBT6Vl417IZ3ib9JfeaVep4A94PoiP5jhuKqTDSH7j87UcMBToMe3X1CB7u1XrSjdYe1YckTdVvWXAAr3JqzdxkCdLWaSTV2Dgzyna6BmPCnBvpYuW" + + "eRdmqLDlMDY3CMnJzHxu7Dte0qm5K0o0gVEkfjcgQ2MUpf1KQQCpsR6vsbFezLcJcMOH0dmFmujKY1KLbkcCY7MofrD1jafg3Tdt9JiQCi7aiutMXBpAOow9WgUXqnPIm0mE4ypiyMLiMpzjPoM9KAQoOeEIfkRRuvberQhtmFPJXD0hvQ0amYuEICOJ7P7iAt7jW14yGO7zemL2MGJlgMf0Zxzj18d4mWgaBLGXyFIBbaCpItwvL9pNQmIJugOWYvqYZ7mTROxSAfKaFvWPLOiQrp5WqzJ8g7Qyv71aNpDhFNxUnwfBWXlVNHKPSfLbTvmPhUpOrypMjE8x4Sk9V9sJpJ08DEg3nC5bLvmG0yMeoIWXQTOcQRyfCehc36HHvdoE7QYYlJ0YQrq9aDLTweLvpIpPBUOaEpWcaDmZV9xnOr4H9x12L7qevGx9KswaxATacXKvkR77FbeapXpEvvNqWEtP4zGbJ9UjbkgqM9s01SUCiiocFOkrZrvWaZrUxnhW9yenrI5P4px77cWAkqtFG1EbkcTNewS49UFnBEW3BTbgO5n9uWdfVS4L7eo8yyzdOSjWxXqXaxjHwrNEKz8TMTiwSe9a8j3Qtea0DiiYkkmhem38E73c9pBqP1Yd95pRrHKQ4tILPgT1WdwAU2EmgdBNbqC8ypDWvvYB12CZwEuckDcx1D7uT3vCkNx2LBDKNFTe2TX0XmX2ei78dAlBmNbhPEHZD4TLkwg7OlzYHvd7RxcR9bMuz7kuonBLuvzR2UqxBWwXvtlX3t6XNFqAHRkvZLry7i6xFowXTEJzYnq97RaHvtc8Cs4qznIjONLsKMvtYDek3awCQoQVBeDdHUIxGtT7gmUXHKF3B87g3ZKHHhXTY4RGLwcGsIFEOUhSPCGhyiiN3SnBaeHCkcKSVs6RWh6zzC7pclGpGemjZ7mcYT4xZihIpdgpoGEBWcggLrWvVVm2HNszMSdxNIHremngBAl9JD7oV1d2BqZfw8sHUg2QHp3zLMdBQLtQ"); + yield return (HashHigh: 0xfd77d5586ef464e7UL, HashLow: 0xc05b765025561928UL, Seed: 0x0000000000000000L, + Ascii: + "iyWHI6mdPnxxYq6y3OF9nYbygTqAT8PWWoFZtq7PntXBgqqwIhA6vYF4SLIQwN9to5YH2CYIXqJ6ZmTxbw1GJwnUfdOYDtUQgX3ZioRMKDlHdIwjlYPD4wEvPGu3aRl5R0sW9ppujWlpFO7I2CrNVXb4mBxCAgjbRCoONwDStGDirdQeU1Ug5KfwfWYDSUYr2rUfeBV3O4HcH36SgY7LlIqIvKBEBgBnUa9gUMeD5dAyNAlqvRXYrN4IYq0Bmi4X7F5KZIrEcA7lwnQJe1MkYMDWVbChE5XyKqgTdKZey5vURvlboJMpZ1510Ltctp83CiUezqTVwxcZpHtvA05qHaueeMCCvjOsu8qLpvN2WRG7MrRPCZ5v8JlMsqLZ8MYbQxriqUV2K8BSFpJlYZfd86wMDaxDxRzUgDTn1KeLZFbbJtcVDsr87pPxgwl92xAosI1hbfc7iaeVGSqCJjmxnAGeevjcB14u7pjNhLUTT20N973vVGxevjPY9Nr8hUrXhHNpHIavdgdtIQSbOqa9If5rRY1maIHkO7idmUO3fqiu6R5RxWTtTWs0pPwydmqEuqQzHcjvV7y8wrxjbgb5cHbqYTy549sT639zopUGjSMMwqjJzeVqME9n7XIrdQ23zlbq1LNCQ810XHJDx4FFuhpS70m1PclYztHdvOlkuHvI2JwUZgD4TnHwXj1IsGbFXW5ut4MujNZ1tha8nc5T6LmaYsu179wFCX5I1lqZqB4z2Y7nqFS0rkX4SJFBF5PQ0GLnmN3KJYztXC6KlhjFTkKW5HRJiyF9L7dbZQaSfxqVjAm6RzL142sSqlD1eKLfJcpfxTqxoLRnT2sp0adhLTO8jNHS0JPvlTxrWIG0sl7tSc5n0TfhLQJIK8NDZp7nklRVayNRvfSRc0DB0JBPrOMTxmVUkzbKgB9xIgudR17EkhJZlkEGCIxVTPs526N8ULNqv8bqm2MM7CH3eyXUujaxXBHKVbMaUDIkbNVLzDt0k3NixMuRGLDAKujqFzNy" + + "re5IyNTbMqrG2PpuozrNAJUc2b6Qzvd3vqdNoG7vL89OjF6nRJY5E5kSGzNJbJOMzshVkT2KJYtRFe9kvLsLTlaTGb0sAYqeUMYpVF1cAS89xvBnO4bAMsiYXapLxOkw6EEyhd6nJWnnVX9bKzZYcHcbJwH4lPRzFWa7VMb24lOGws9GCse0IFJ2zU2SszGEFMSjriAfcpSncVrscM5WFedYRtZNXwfGSl6xjcnq3e09ukHC2gtJ5r6l5tqNVAiZE7aolL1DaeXUsxAar9DaRErJ3IttkB2qa4pWNEnA9TKn5xMkx0UUBu7InIedxRlS2t3H6dDUxcOcdIOQ8ocWCNA1LyD84rt3PefPYcVQQuCgMSWcCxdkDr0oEAzhHo930FdF9xwEG4wKHq3h6hnBGlALvCO3Uy70KtpisTRgioIx2emw7EopNbMHKxzgzkyNewh2w9Z30Vm06joWe1qvzCm66SFrmx6nPTHb2X3NU0M7ZW9wJ60agW3fj5NcuErPV8vtZzcPMWEtE8Kj0FX2OUq741UziApFgi8SIl3uw9NzvRxMNv8LZJjmqrWRcs2scrnnxqw9wohmPLYqOAbDRYr5Vqy7LynWwJR2usdgNOGvlc4rTXDYM4TggscpaBGGYgfnBC3JT5EcNa3M13JvQ8HVXt7CSbdZBdyQbrQwblsWEXan7JMNrkl0LZgE04ItpXtBP9Motv5ZpIpKdE0UbL3jQmhksPsARPQsqQ84F63dTc5x6pSnQDlDlWH6TSshc6N8Czc4i2QpPY8HkGt5Xq0kxN0mQBy26cSmKceIKKAKh2tXYWRQS9usNZHYYn2u8wojmvcPFjE58xE43Gz9NgxiDjW5XVVvWxCsdDoGcPFh2KZtbCyosRJ7aJJr5dD2XqmhbAX6UG8QEsgcZQyTsfbzBC3zDfl5blXbyx1hhvra7MvNuK4uy4cnrj9qdL9YgQTyYZkZxQtuf6qPtwQKMbXvyBKD88Fpbzb0vXNItW1O23Y38DsPgB1L7UoNAc80" + + "EKuAJUaaj6tMVQeGgXQUQDYnTOkJXZPlrDtnrXLFUjYZdhw23ZFlTZNPkiCzQpg0ZarlBYrVELyoXsFLbBO3HV6MHAISFNDpTsjN0FrgaGabTZzRVSr4KRuvT8Q8lZ1j0xft4narUuu8i8SiJK0f9qVxcQZDuUQSB5tvZPj1J4F0L1bJ44S775tGpjx5mUgI3xKyfBBUipgwPSW3X2rcQ20uljePYE4XuzjNLRKmbA7RhD4E8v5wJqiqGDqtEXOEFJFLHD8JAbjAbysd2SSuO4aEufjfyZjLfJ47kL4XvhrCD39X8buY5poRKqWdbHP8OmPEGsjypBijSd1fhaPGegkUAt8friWlEfEHtATfIa8kkF33WrTRpcVH2P64uQtSItVxtL4m6mWeFQIhPe5h2sftSJPKRboiqOx2tkjmXFQxhccBHRkmt90Qpyj4vRR1Eh1UoMbyhhjwaC0j14307KTiz6us73rNotyDi6OjNhEPdID3ysSOJEIAAdrn8rBVGLBLKp16Cxqni49aHb9F5LlWfNjSggUt8RsqTPwSBM78xju6WVsQK8brbA1C7GtvnqYgt1zXRGAuYmHeEz6BhmYNNQVYql2vK4Z2LuYh66hjC4SWbOnk9LnohyyNyohvwF2Er61ZlqpGcsLuQGp5Xxf4JOJbQFnelM0Bk5iGeF4qbXpIN18yxWVoZXxtvehXmiQE4fgEK5L5cIjl5r5wLGc6QtI1oddpLx5Rkpm9pxYstzO50psCEEAUU7KUSKpoapi2KUXoENi1g6PvnDpv6ItiH2MlIVUm514bd6wGO9A5yXZNTjeiDzgbCRI1nuXGapZ9yekZpqONJkKJxfuun2IKPzzD850m7YI87M5PQtU8qQNxYapk5aFlfWh49vHiTQDbEjnn4HveprIfcCMainMT4T4znAtToODoH12Hmu5UydcsoKLNNJAUiUAOIUmlEjYmXEgGEMLEF6kxkoCpncxf5aYo22BImbjAy5TGIo9wEfMuDes8L5EB7GiwSjkl" + + "eDErSdaakXXBOhCMT8Pb5EhQSlpSgERDUlCbV20E1GRa8xkGNWU3HiyMuXGrhBnlZGBd6t80DpOlptqhHnAYEsMPnDOSY0JrtsaS8SoaFDOjnFL3aLgKgvXnxDK7qALssTObpAz0LLrJ7UhSa7bqMJVFscMTWE5JpSUbQ343fhiKX6fAJWOBasJUOK2xKROH0MToYdYbY7W6NTeELi7S0d7tqPMAVCs4WJcKzUvK7PluHXifcxBsVLo46W0FIatYe5S1fQwUvi2Y4VwXfla84DxrwtFmknNLAq86Fxv5NqVsV1yCMduHbgtI6XoeQ8ioUIx5jLiworGEh9jlnUJgN8cBYZyVgKjBgbE72AJFgSxKlp6tgmSSTkXxjBuY2t3fFJ6Aa8DuUHMwg6ZXPcgnMSNpszvXQyfig06rbvNKm0PhwAIYRrQ9kbNVx201Z5U9jYIuI8dgAG2wOibcKTkPmcWnUB2ijcm0xE6gXHihNPHmJexO9UeTV4m3MgQsSlE54bSL4tDE06nQJ2GsZDJPFAOlHKz2NyrMLg04MNzUfj89Un09afgqOLXoAa49deoqXGgTTT6iM8Fn2TDVMCFMO1t0zhy3mMKyilDSzPdGkSfQ29JotOGboQ3UOUXlYpQTXyrZ36lvhSKqji3jE5TujbViQvOXsnARKvgxDLSXeSdapsx2DXm6KobxrpGKdbMzzIYtfFpxYFy6BUQrkCXDYnVp50WhVtIzJEuDiM0ZYEwRYFhPsormPVNEE90rw6nhL1cznDcKjxDdC3sxh6i4lhG7jdPMpG9RqLYdRsnseCCkJKHUdq55YMEneZpOYjfxdteK8ML8Z24RmMODn3H23ga7QtmboOPAJBG5ahMNQ6DWyGaHqMRz3IUvKfi5nU0Nfpm4j0TdZRh6a9Hu8BtySKHH5Y6NgFToSa6aeGulTIpcik0KixeJgzeVRGpQ0KLHKS5WPfbNTXIUG0iGurgWWo3OSBgPowY50M9yrndhRjjZLLVOTJRZTn8rgdKz4v4c" + + "wpkOVXr35VWwsGmFKDqa4xv7d2eIHpGPz0d7Ix3NkDe4lVM3ye8qpvzTjdiFMNgDXrEDGYXf8pGigqSxfU0V5PV68gmTl3xyWE4ulMYgmrBPmTCbp7svSLOL9VFp60AAJFzLmrjfaYJikwhh6UkxDH91cLDs9VFFWBcxs9qQSKIoM5bn99HdG4sJovNAfJQIDxaG4DjSeC9RCrtvA7VYUdhiPV4E06sWCMe1hl0pasyhCtgxUqRNA482aq1E2O6GTKrSxSh59HLcOIkKhFvEWmji8YoAQjqMm5rojIjwD2pnLIuSbwc9nOMdIHgRDQlmQhSQykduChqALN5D7lanlUnsR06IRLZrI5IqZTxERYFsnognsBauwdYjraY32mAoBe4cVZn259BDBfcQgxqAH2xoq11rd2hkbNuGozNIAuXu3DfCCEBJrQ7vdYiKKtd9yzk3mx3l3C8yPLLidJksnACUiaFWVke2rVHwULIZ2gH9IsqJIEbrjadgeC4AzC3EmsIGEDB56FOQfwiYxiZl4V7COQ2mvA2s7BW4kXeOYz4N1Tk892b9WgKEZf4ZSUIrc1luqwiMkqjHW3KjvCyPSgsPyk2E8hivCNsX11x3Igu1xJsEBFMIqngYW9Hf44RVzZ9QC737yfKhZ8NIqFjdjXkdUC9nkORpsVGEwEtHDl4kex3mQfRU8XNQj7RpHfNLGuPKryQVX3RIob18ZBxIZzJc9myKAj5q7OMyNGNzwJI51E92weX72GKzfM3mqOe0Nzx6KznLuf4s2ltjSYEWNaezKQaggz7mxchYFXUHkJvoMB482oUTXfRuiIWfCYQw9D1FCQhwI3BHVvIi4y4R55jVThswFcY8JAJ98wRELFaqlICRC15pwfgdlDCdBDFSLpFLuNEXLIQPvncycPYzttF2wMks4YZU1oF5T210MmO7PiOarXeWoTpzFQWOfwEl390den99HoSrVy0egVTXP1jomOeBjpDeYqVyqp2LnXdc0TTvhkMJQmpTSzMSj6o1" + + "hGWoQDi4BAU5vfstgQcdgt4JvWU9wu0XtHfOtOmXRLkGIOoaR6JteOJ9EnTBt8dF6iMXFDb8V9v1Dtej07gSZA35GMesSOX6X2acTiUeS2LhGeWTGByPJwJMqe7u43noxXLZ4RFCQxv3OcOjvBrTQrt3HUITud2RefPVVVHpdXF2DN3kwBjFnonceJP6pk6MbkVv42oV0tgI9JHGWDOF5CU4mBYYZbKNv4QFgmvZYif7fAiFpuPKa8hW6jsiqVcWGRoUnJXrMYZp9zykNHGS76BcIzCgfSlF1jnZqeZcL2unmjoeyonwyic24B9n7YkSiWSEUmIgLXrqzGp82VXrcq9SRX9BAcn53U9jDQD8L9rksklY158asKiVJwGhj3EQuWpNqTipySKrr8R3xWLebpNCAnAlXckYTJqLZcrl2evBj3YmpfJWgOWkKMfGsluotOAnyLhr6psIe1PVNcYGUrilH1M6H9mF8LcWEuXvigL90roK4Kki3IDarCDSnc1mRzPf0I3v1ROuNNlgqbZNoMbL0TyMZDUq3wFzOf83emI8EHwhXagAd6LsfizcrSnVRraaOEYACDzqFBOjgtz1as0FKlaBSA67teTCKuoAp9XN4WBI0OsVPuY8NaiEkdvq3oPGahfqEHT988koGBqKJiv6GUeoTCQ3FsxOEXkVBlo46fimCNxIoqHKQKXoOoxfkJThKhGDrEK3R8iD4AyP5i3Whjakt0pmiLNTOoIrV0r7aqbvK7KA8NIZl8dXVjGQOtu1VyoLFfZ0nnWKMthJrroPqm83XcmulLWYxcG8lVGOLoilby0sxemMRDWveRqmrWx305h4n9y7wU5fYClZNlcsAC3xPPgDj5Mvf8bDEG4EIpZkvWGyUStN9vdkshPmm4vVMS9Fj25BTvPEix6ZL7MlRXYnQCOB1knysMTJsNPp7GN1YysFIFWRNvE4csYrJGkoeBKwMZVXvhLKgl2hqPyUfRJGGxBdTyuHItBHnQ2eXUtWuCqOXNktMOPReClF" + + "rP52DQlgQG3BDVHE0BZKc7qD7XTSAdpQmqkzWfT21xfHpwcWecFHDxacJPX97ULpeVAmiP0I3Z1dcI7KqjSbr1shDzyjPspnHgulEvDDzT1a81B3JHADw4jv6rlwn2lFfy3AN2T8nZu5R4hnJcd0PjxV8ylVYStP0aEqQmR5haflXffyH2DHc3w5BjFq59jdZ0aN8D4yapVuOJUPHJIJmFvIhXiZZmoWjGFnF3dKPgUz2AZlnbTINRNbSCSUq2J9q0ZKo3IwdtqyonEH02yrFTn2WGoL1nfepY3vxdXX6FMFKaeLiFs22rXfZ6RkIv5tEZCtJTisJNT055bKWdCcLLCn9jY0s2j3YJs8dHLepjhxe7uAFMytTVq8Y0SE65nhUV832leIZR9JrMmNsmdfI59ABGEh2f6CBJ3ZJFameh0co9BzYBtEtcsajgM6PCOElRJHO9d8xmBRIlmNhBhcGC4BH2oEtFo6tbRnC3FRPsTLsv2yiDNL9UJ3S6lBJfMhkbLdUXCgBjaEXz5TkbNQDaaujQWQkHAVMHIdQ0deOtlvMsYvBCszf9181qAoTDF2ahmDQAnTarUxEn9GN3MHumhjI8Eki3h0hLZzgtoo4ovZwCCZLBeeAX8ycud9oBnn2b6f17peUNURveHuFeAuFz7ZUtXez1BcoflaqyKoq6vh6MGVxnNthBArU4sBP352OLhXIFoEggIP2MGBGpj2LxsXSZhbHrHMRflHSAgrTDqkHKqfjRdSxdEHfXxMkdj4f0FVhZEgOf99IN00YXwXfet2gHQWHfRjsvjzkDTzLoZSy6HQPXYrKnIcgsoAtt4OGkO0LxKXoAZT8Lm9cF1eJHdsAWEMmssd73oV0WXA111iAhf2IOfQW65htyEvP2ljlN9BmA2PLXZGaq2EG0ozV6XqiZ1pgEyyQ2qxRdEoKv8VJQuoWSvK8j6at7V5RjChJVVwL96LdVgvxnSeinlRWWcf5jYljn7SvLPMV9F9fXGNhZGvvnQVfhU0cZtny8k7" + + "a1MO3gpnke0l1w03ZPgXVOMQH7DcIIy6IJSUNN5FqcubUATqdGWneXEi3HLYlcyO4CflRtGXO4vRSiAJSBla186vSiiJTe6L5t36t0G28hIIMkURDrAFjeB2VhLqVdqsmbDBxq4xxxrAi9KatciNCExmDk9JeHSrFeyjVkbw1SSb96Z4fSxtTyhpI7IiSP5vw9xqGBLUbpfewUaIfmXrwsAoLjurbE5W159x2bkL0b6XF9K0BMLsh7FJpl8Uh84XlDxYVUGYxL1jw9Cc29WAuy5uiCF6ThNw4p0NDlMslMMI6XJN4yz2bd7BJs4wlYFUwKqmwTVJAXoJIghgAX44ix9UxBcMjNWUqkIZa8Xaweh9pOrd7dhdWO2RMS25LD8yKSfan32deCGzcafjv6ZSy7MkiwYuviXpjlK4IJYd6wyitXts86MaP3ATXw472SHnnjLYJP9yBKuwBjdG5HfCUHGQwq5W6UQyoI7U5eszG62rJdr0YGkMuYbs0ayjWDf4gJxDz2UDwdkPH1fDOBIuQSiPcX8PRIELHfgwYseBhppC0PBDU6QAXjjxqRXz6iGHkNOOif67LS3tYOGif4jBPHEQLtbphuCCl2rXnKiRkxQb2LwEeSZVbPnzqlh5cN28bSLiFYpae03M7Cl7zC7oDz3XvthwgqfdZX224veXJzaEjsVOdXZKtNWaI8pf1J55Mq6FH5VRsHgpry86wXMVRrkty9UepTvrvkkHHprBAWuGQAanubxH2TRQrO8FukHKH0XfxxySbvN124hMBBNHysfWUyOhSoHl52AzkoARYTOkMS22MIGpLhuc8i7C2UVUraAZ5C3AhQITe2iVK6tEPHEy7tLFqHxrKpuZGKrc60pdkScSbRXsyF1kIWbc2JNDk4qv2QySbWPIIIz5aL9Pp8kT97QUiLFtdK8O2ghcHTFB8PqMKsg59Ex0Zlh2epGNCXqaqjkXjeMZxgLbqyrmfDMpNzOcgj4d66jhS0JwrFdoPAQOp1ODzJcLLP9eMhDl"); + } + } +}