diff --git a/include/Nazara/Core/Algorithm.hpp b/include/Nazara/Core/Algorithm.hpp index 15c59f00c..844ec705d 100644 --- a/include/Nazara/Core/Algorithm.hpp +++ b/include/Nazara/Core/Algorithm.hpp @@ -29,7 +29,7 @@ namespace Nz template decltype(auto) Apply(O& object, F&& fn, Tuple&& t); template constexpr std::size_t BitCount(); template ByteArray ComputeHash(HashType hash, const T& v); - template ByteArray ComputeHash(AbstractHash* hash, const T& v); + template ByteArray ComputeHash(AbstractHash& hash, const T& v); template constexpr std::size_t CountOf(T(&name)[N]) noexcept; template std::size_t CountOf(const T& c); inline bool HashAppend(AbstractHash* hash, const std::string_view& v); diff --git a/include/Nazara/Core/Algorithm.inl b/include/Nazara/Core/Algorithm.inl index d564ef606..1198df701 100644 --- a/include/Nazara/Core/Algorithm.inl +++ b/include/Nazara/Core/Algorithm.inl @@ -178,7 +178,7 @@ namespace Nz template ByteArray ComputeHash(HashType hash, const T& v) { - return ComputeHash(AbstractHash::Get(hash).get(), v); + return ComputeHash(*AbstractHash::Get(hash), v); } /*! @@ -195,15 +195,13 @@ namespace Nz * \see ComputeHash */ template - ByteArray ComputeHash(AbstractHash* hash, const T& v) + ByteArray ComputeHash(AbstractHash& hash, const T& v) { - NazaraAssert(hash != nullptr, "Invalid abstracthash pointer"); - - hash->Begin(); + hash.Begin(); HashAppend(hash, v); - return hash->End(); + return hash.End(); } /*! @@ -234,9 +232,9 @@ namespace Nz return c.size(); } - inline bool HashAppend(AbstractHash* hash, const std::string_view& v) + inline bool HashAppend(AbstractHash& hash, const std::string_view& v) { - hash->Append(reinterpret_cast(v.data()), v.size()); + hash.Append(reinterpret_cast(v.data()), v.size()); return true; } diff --git a/include/Nazara/Core/ByteArray.hpp b/include/Nazara/Core/ByteArray.hpp index 279139b79..7670f5d60 100644 --- a/include/Nazara/Core/ByteArray.hpp +++ b/include/Nazara/Core/ByteArray.hpp @@ -129,7 +129,7 @@ namespace Nz Container m_array; }; - inline bool HashAppend(AbstractHash* hash, const ByteArray& byteArray); + inline bool HashAppend(AbstractHash& hash, const ByteArray& byteArray); } namespace std diff --git a/include/Nazara/Core/ByteArray.inl b/include/Nazara/Core/ByteArray.inl index f37433ab8..ea7981227 100644 --- a/include/Nazara/Core/ByteArray.inl +++ b/include/Nazara/Core/ByteArray.inl @@ -732,9 +732,9 @@ namespace Nz return m_array >= rhs.m_array; } - inline bool HashAppend(AbstractHash* hash, const ByteArray& byteArray) + inline bool HashAppend(AbstractHash& hash, const ByteArray& byteArray) { - hash->Append(byteArray.GetConstBuffer(), byteArray.GetSize()); + hash.Append(byteArray.GetConstBuffer(), byteArray.GetSize()); return true; } } diff --git a/include/Nazara/Core/File.hpp b/include/Nazara/Core/File.hpp index 52bf92fda..fe1cf23ba 100644 --- a/include/Nazara/Core/File.hpp +++ b/include/Nazara/Core/File.hpp @@ -60,7 +60,7 @@ namespace Nz File& operator=(File&& file) noexcept; static inline ByteArray ComputeHash(HashType hash, const std::filesystem::path& filePath); - static inline ByteArray ComputeHash(AbstractHash* hash, const std::filesystem::path& filePath); + static inline ByteArray ComputeHash(AbstractHash& hash, const std::filesystem::path& filePath); private: void FlushStream() override; @@ -71,7 +71,7 @@ namespace Nz std::unique_ptr m_impl; }; - NAZARA_CORE_API bool HashAppend(AbstractHash* hash, const File& originalFile); + NAZARA_CORE_API bool HashAppend(AbstractHash& hash, const File& originalFile); } #include diff --git a/include/Nazara/Core/File.inl b/include/Nazara/Core/File.inl index 4230d6a2c..769eaa77b 100644 --- a/include/Nazara/Core/File.inl +++ b/include/Nazara/Core/File.inl @@ -18,7 +18,7 @@ namespace Nz inline ByteArray File::ComputeHash(HashType hash, const std::filesystem::path& filePath) { - return ComputeHash(AbstractHash::Get(hash).get(), filePath); + return ComputeHash(*AbstractHash::Get(hash), filePath); } /*! @@ -29,7 +29,7 @@ namespace Nz * \param filePath Path for the file */ - inline ByteArray File::ComputeHash(AbstractHash* hash, const std::filesystem::path& filePath) + inline ByteArray File::ComputeHash(AbstractHash& hash, const std::filesystem::path& filePath) { return Nz::ComputeHash(hash, File(filePath)); } diff --git a/include/Nazara/Core/Hash/CRC32.hpp b/include/Nazara/Core/Hash/CRC32.hpp index 85db71893..09973ae65 100644 --- a/include/Nazara/Core/Hash/CRC32.hpp +++ b/include/Nazara/Core/Hash/CRC32.hpp @@ -13,13 +13,11 @@ namespace Nz { - struct HashCRC32_state; - - class NAZARA_CORE_API HashCRC32 : public AbstractHash + class NAZARA_CORE_API CRC32Hash final : public AbstractHash { public: - HashCRC32(UInt32 polynomial = 0x04c11db7); - virtual ~HashCRC32(); + CRC32Hash(UInt32 polynomial = DefaultPolynomial); + virtual ~CRC32Hash(); void Append(const UInt8* data, std::size_t len) override; void Begin() override; @@ -28,8 +26,11 @@ namespace Nz std::size_t GetDigestLength() const override; const char* GetHashName() const override; + static constexpr UInt32 DefaultPolynomial = 0x04C11DB7; + private: - HashCRC32_state* m_state; + UInt32 m_crc; + const UInt32* m_table; }; } diff --git a/include/Nazara/Core/Hash/CRC64.hpp b/include/Nazara/Core/Hash/CRC64.hpp index b183fb044..c8ab1eb99 100644 --- a/include/Nazara/Core/Hash/CRC64.hpp +++ b/include/Nazara/Core/Hash/CRC64.hpp @@ -13,11 +13,11 @@ namespace Nz { - class NAZARA_CORE_API HashCRC64 : public AbstractHash + class NAZARA_CORE_API CRC64Hash final : public AbstractHash { public: - HashCRC64() = default; - ~HashCRC64() = default; + CRC64Hash() = default; + ~CRC64Hash() = default; void Append(const UInt8* data, std::size_t len) override; void Begin() override; diff --git a/include/Nazara/Core/Hash/Fletcher16.hpp b/include/Nazara/Core/Hash/Fletcher16.hpp index 138d20d22..0fff61418 100644 --- a/include/Nazara/Core/Hash/Fletcher16.hpp +++ b/include/Nazara/Core/Hash/Fletcher16.hpp @@ -13,13 +13,11 @@ namespace Nz { - struct HashFletcher16_state; - - class NAZARA_CORE_API HashFletcher16 : public AbstractHash + class NAZARA_CORE_API Fletcher16Hash final : public AbstractHash { public: - HashFletcher16(); - virtual ~HashFletcher16(); + Fletcher16Hash() = default; + ~Fletcher16Hash() = default; void Append(const UInt8* data, std::size_t len) override; void Begin() override; @@ -29,7 +27,8 @@ namespace Nz const char* GetHashName() const override; private: - HashFletcher16_state* m_state; + UInt16 m_sum1; + UInt16 m_sum2; }; } diff --git a/include/Nazara/Core/Hash/MD5.hpp b/include/Nazara/Core/Hash/MD5.hpp index b5ef9233b..bad02da9e 100644 --- a/include/Nazara/Core/Hash/MD5.hpp +++ b/include/Nazara/Core/Hash/MD5.hpp @@ -13,13 +13,11 @@ namespace Nz { - struct HashMD5_state; - - class NAZARA_CORE_API HashMD5 : public AbstractHash + class NAZARA_CORE_API MD5Hash final : public AbstractHash { public: - HashMD5(); - virtual ~HashMD5(); + MD5Hash() = default; + ~MD5Hash() = default; void Append(const UInt8* data, std::size_t len) override; void Begin() override; @@ -29,7 +27,11 @@ namespace Nz const char* GetHashName() const override; private: - HashMD5_state* m_state; + void md5_process(const UInt8* data); + + std::size_t m_count[2]; /* message length in bits, lsw first */ + UInt32 m_abcd[4]; /* digest buffer */ + UInt8 m_buf[64]; /* accumulate block */ }; } diff --git a/include/Nazara/Core/Hash/SHA1.hpp b/include/Nazara/Core/Hash/SHA1.hpp index a58760f77..9ca4cdfba 100644 --- a/include/Nazara/Core/Hash/SHA1.hpp +++ b/include/Nazara/Core/Hash/SHA1.hpp @@ -15,11 +15,11 @@ namespace Nz { union SHA_CTX; - class NAZARA_CORE_API HashSHA1 : public AbstractHash + class NAZARA_CORE_API SHA1Hash final : public AbstractHash { public: - HashSHA1(); - virtual ~HashSHA1(); + SHA1Hash(); + ~SHA1Hash(); void Append(const UInt8* data, std::size_t len) override; void Begin() override; diff --git a/include/Nazara/Core/Hash/SHA224.hpp b/include/Nazara/Core/Hash/SHA224.hpp index 2ea10733e..66629615f 100644 --- a/include/Nazara/Core/Hash/SHA224.hpp +++ b/include/Nazara/Core/Hash/SHA224.hpp @@ -15,11 +15,11 @@ namespace Nz { union SHA_CTX; - class NAZARA_CORE_API HashSHA224 : public AbstractHash + class NAZARA_CORE_API SHA224Hash final : public AbstractHash { public: - HashSHA224(); - virtual ~HashSHA224(); + SHA224Hash(); + ~SHA224Hash(); void Append(const UInt8* data, std::size_t len) override; void Begin() override; diff --git a/include/Nazara/Core/Hash/SHA256.hpp b/include/Nazara/Core/Hash/SHA256.hpp index 1bb0bef35..15ec23371 100644 --- a/include/Nazara/Core/Hash/SHA256.hpp +++ b/include/Nazara/Core/Hash/SHA256.hpp @@ -15,11 +15,11 @@ namespace Nz { union SHA_CTX; - class NAZARA_CORE_API HashSHA256 : public AbstractHash + class NAZARA_CORE_API SHA256Hash final : public AbstractHash { public: - HashSHA256(); - virtual ~HashSHA256(); + SHA256Hash(); + ~SHA256Hash(); void Append(const UInt8* data, std::size_t len) override; void Begin() override; diff --git a/include/Nazara/Core/Hash/SHA384.hpp b/include/Nazara/Core/Hash/SHA384.hpp index 1c2535fd2..82e1a7e7e 100644 --- a/include/Nazara/Core/Hash/SHA384.hpp +++ b/include/Nazara/Core/Hash/SHA384.hpp @@ -15,11 +15,11 @@ namespace Nz { union SHA_CTX; - class NAZARA_CORE_API HashSHA384 : public AbstractHash + class NAZARA_CORE_API SHA384Hash final : public AbstractHash { public: - HashSHA384(); - virtual ~HashSHA384(); + SHA384Hash(); + ~SHA384Hash(); void Append(const UInt8* data, std::size_t len) override; void Begin() override; diff --git a/include/Nazara/Core/Hash/SHA512.hpp b/include/Nazara/Core/Hash/SHA512.hpp index 1919afa55..e6ab3cc97 100644 --- a/include/Nazara/Core/Hash/SHA512.hpp +++ b/include/Nazara/Core/Hash/SHA512.hpp @@ -15,11 +15,11 @@ namespace Nz { union SHA_CTX; - class NAZARA_CORE_API HashSHA512 : public AbstractHash + class NAZARA_CORE_API SHA512Hash final : public AbstractHash { public: - HashSHA512(); - virtual ~HashSHA512(); + SHA512Hash(); + ~SHA512Hash(); void Append(const UInt8* data, std::size_t len) override; void Begin() override; diff --git a/include/Nazara/Core/Hash/Whirlpool.hpp b/include/Nazara/Core/Hash/Whirlpool.hpp index 1f2783da5..b2b088ef7 100644 --- a/include/Nazara/Core/Hash/Whirlpool.hpp +++ b/include/Nazara/Core/Hash/Whirlpool.hpp @@ -13,13 +13,11 @@ namespace Nz { - struct HashWhirlpool_state; - - class NAZARA_CORE_API HashWhirlpool : public AbstractHash + class NAZARA_CORE_API WhirlpoolHash final : public AbstractHash { public: - HashWhirlpool(); - virtual ~HashWhirlpool(); + WhirlpoolHash() = default; + ~WhirlpoolHash() = default; void Append(const UInt8* data, std::size_t len) override; void Begin() override; @@ -29,7 +27,13 @@ namespace Nz const char* GetHashName() const override; private: - HashWhirlpool_state* m_state; + void ProcessBuffer(); + + std::size_t m_bufferBits; // current number of bits on the buffer */ + std::size_t m_bufferPos; // current (possibly incomplete) byte slot on the buffer */ + UInt8 m_bitLength[32]; // global number of hashed bits (256-bit counter) */ + UInt8 m_buffer[64]; // buffer of data to hash */ + UInt64 m_hash[8]; // the hashing state */ }; } diff --git a/src/Nazara/Core/AbstractHash.cpp b/src/Nazara/Core/AbstractHash.cpp index 5dd7d705d..9a9c8f787 100644 --- a/src/Nazara/Core/AbstractHash.cpp +++ b/src/Nazara/Core/AbstractHash.cpp @@ -46,34 +46,34 @@ namespace Nz switch (type) { case HashType::Fletcher16: - return std::make_unique(); + return std::make_unique(); case HashType::CRC32: - return std::make_unique(); + return std::make_unique(); case HashType::CRC64: - return std::make_unique(); + return std::make_unique(); case HashType::MD5: - return std::make_unique(); + return std::make_unique(); case HashType::SHA1: - return std::make_unique(); + return std::make_unique(); case HashType::SHA224: - return std::make_unique(); + return std::make_unique(); case HashType::SHA256: - return std::make_unique(); + return std::make_unique(); case HashType::SHA384: - return std::make_unique(); + return std::make_unique(); case HashType::SHA512: - return std::make_unique(); + return std::make_unique(); case HashType::Whirlpool: - return std::make_unique(); + return std::make_unique(); } NazaraInternalError("Hash type not handled (0x" + NumberToString(UnderlyingCast(type), 16) + ')'); diff --git a/src/Nazara/Core/File.cpp b/src/Nazara/Core/File.cpp index 93738b8c7..16c3bb1b2 100644 --- a/src/Nazara/Core/File.cpp +++ b/src/Nazara/Core/File.cpp @@ -424,10 +424,8 @@ namespace Nz * \remark Produces a NazaraError if file could not be read */ - NAZARA_CORE_API bool HashAppend(AbstractHash* hash, const File& originalFile) + NAZARA_CORE_API bool HashAppend(AbstractHash& hash, const File& originalFile) { - NazaraAssert(hash, "Invalid hash"); - File file(originalFile.GetPath()); if (!file.Open(OpenMode::ReadOnly)) { @@ -448,7 +446,7 @@ namespace Nz } remainingSize -= size; - hash->Append(reinterpret_cast(&buffer[0]), size); + hash.Append(reinterpret_cast(&buffer[0]), size); } return true; diff --git a/src/Nazara/Core/Hash/CRC32.cpp b/src/Nazara/Core/Hash/CRC32.cpp index a190a0f5a..d5ae92ad7 100644 --- a/src/Nazara/Core/Hash/CRC32.cpp +++ b/src/Nazara/Core/Hash/CRC32.cpp @@ -8,12 +8,6 @@ namespace Nz { - struct HashCRC32_state - { - UInt32 crc; - const UInt32* table; - }; - namespace { UInt32 crc32_reflect(UInt32 ref, unsigned int j) @@ -32,47 +26,45 @@ namespace Nz } static const UInt32 crc32_table[256] = { - 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, - 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, - 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, - 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, - 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, - 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, - 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, - 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, - 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, - 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, - 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, - 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, - 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, - 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, - 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, - 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, - 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, - 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, - 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, - 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, - 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, - 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, - 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, - 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, - 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, - 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, - 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, - 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, - 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, - 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, - 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, - 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d + 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, + 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, + 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, + 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, + 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, + 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, + 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, + 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, + 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, + 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, + 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, + 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, + 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, + 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, + 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, + 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, + 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, + 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, + 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, + 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, + 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, + 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, + 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, + 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, + 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, + 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, + 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, + 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, + 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, + 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, + 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, + 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D }; } - HashCRC32::HashCRC32(UInt32 polynomial) + CRC32Hash::CRC32Hash(UInt32 polynomial) { - m_state = new HashCRC32_state; - - if (polynomial == 0x04c11db7) - m_state->table = crc32_table; // Table précalculée (Bien plus rapide) + if (polynomial == DefaultPolynomial) + m_table = crc32_table; else { UInt32* table = new UInt32[256]; @@ -86,46 +78,44 @@ namespace Nz table[i] = crc32_reflect(table[i], 32); } - m_state->table = table; + m_table = table; } } - HashCRC32::~HashCRC32() + CRC32Hash::~CRC32Hash() { - if (m_state->table != crc32_table) - delete[] m_state->table; - - delete m_state; + if (m_table != crc32_table) + delete[] m_table; } - void HashCRC32::Append(const UInt8* data, std::size_t len) + void CRC32Hash::Append(const UInt8* data, std::size_t len) { while (len--) - m_state->crc = m_state->table[(m_state->crc ^ *data++) & 0xFF] ^ (m_state->crc >> 8); + m_crc = m_table[(m_crc ^ *data++) & 0xFF] ^ (m_crc >> 8); } - void HashCRC32::Begin() + void CRC32Hash::Begin() { - m_state->crc = 0xFFFFFFFF; + m_crc = 0xFFFFFFFF; } - ByteArray HashCRC32::End() + ByteArray CRC32Hash::End() { - m_state->crc ^= 0xFFFFFFFF; + m_crc ^= 0xFFFFFFFF; #ifdef NAZARA_LITTLE_ENDIAN - SwapBytes(&m_state->crc, sizeof(UInt32)); + SwapBytes(&m_crc, sizeof(UInt32)); #endif - return ByteArray(reinterpret_cast(&m_state->crc), 4); + return ByteArray(reinterpret_cast(&m_crc), 4); } - std::size_t HashCRC32::GetDigestLength() const + std::size_t CRC32Hash::GetDigestLength() const { return 4; } - const char* HashCRC32::GetHashName() const + const char* CRC32Hash::GetHashName() const { return "CRC32"; } diff --git a/src/Nazara/Core/Hash/CRC64.cpp b/src/Nazara/Core/Hash/CRC64.cpp index 3fff6c2a1..0611e254b 100644 --- a/src/Nazara/Core/Hash/CRC64.cpp +++ b/src/Nazara/Core/Hash/CRC64.cpp @@ -8,93 +8,88 @@ namespace Nz { - struct HashCRC64_state - { - UInt64 crc; - }; - namespace { - static const UInt64 crc64_table[256] = { - 0x0000000000000000ULL, 0x7ad870c830358979ULL, 0xf5b0e190606b12f2ULL, 0x8f689158505e9b8bULL, - 0xc038e5739841b68fULL, 0xbae095bba8743ff6ULL, 0x358804e3f82aa47dULL, 0x4f50742bc81f2d04ULL, - 0xab28ecb46814fe75ULL, 0xd1f09c7c5821770cULL, 0x5e980d24087fec87ULL, 0x24407dec384a65feULL, - 0x6b1009c7f05548faULL, 0x11c8790fc060c183ULL, 0x9ea0e857903e5a08ULL, 0xe478989fa00bd371ULL, - 0x7d08ff3b88be6f81ULL, 0x07d08ff3b88be6f8ULL, 0x88b81eabe8d57d73ULL, 0xf2606e63d8e0f40aULL, - 0xbd301a4810ffd90eULL, 0xc7e86a8020ca5077ULL, 0x4880fbd87094cbfcULL, 0x32588b1040a14285ULL, - 0xd620138fe0aa91f4ULL, 0xacf86347d09f188dULL, 0x2390f21f80c18306ULL, 0x594882d7b0f40a7fULL, - 0x1618f6fc78eb277bULL, 0x6cc0863448deae02ULL, 0xe3a8176c18803589ULL, 0x997067a428b5bcf0ULL, - 0xfa11fe77117cdf02ULL, 0x80c98ebf2149567bULL, 0x0fa11fe77117cdf0ULL, 0x75796f2f41224489ULL, - 0x3a291b04893d698dULL, 0x40f16bccb908e0f4ULL, 0xcf99fa94e9567b7fULL, 0xb5418a5cd963f206ULL, - 0x513912c379682177ULL, 0x2be1620b495da80eULL, 0xa489f35319033385ULL, 0xde51839b2936bafcULL, - 0x9101f7b0e12997f8ULL, 0xebd98778d11c1e81ULL, 0x64b116208142850aULL, 0x1e6966e8b1770c73ULL, - 0x8719014c99c2b083ULL, 0xfdc17184a9f739faULL, 0x72a9e0dcf9a9a271ULL, 0x08719014c99c2b08ULL, - 0x4721e43f0183060cULL, 0x3df994f731b68f75ULL, 0xb29105af61e814feULL, 0xc849756751dd9d87ULL, - 0x2c31edf8f1d64ef6ULL, 0x56e99d30c1e3c78fULL, 0xd9810c6891bd5c04ULL, 0xa3597ca0a188d57dULL, - 0xec09088b6997f879ULL, 0x96d1784359a27100ULL, 0x19b9e91b09fcea8bULL, 0x636199d339c963f2ULL, - 0xdf7adabd7a6e2d6fULL, 0xa5a2aa754a5ba416ULL, 0x2aca3b2d1a053f9dULL, 0x50124be52a30b6e4ULL, - 0x1f423fcee22f9be0ULL, 0x659a4f06d21a1299ULL, 0xeaf2de5e82448912ULL, 0x902aae96b271006bULL, - 0x74523609127ad31aULL, 0x0e8a46c1224f5a63ULL, 0x81e2d7997211c1e8ULL, 0xfb3aa75142244891ULL, - 0xb46ad37a8a3b6595ULL, 0xceb2a3b2ba0eececULL, 0x41da32eaea507767ULL, 0x3b024222da65fe1eULL, - 0xa2722586f2d042eeULL, 0xd8aa554ec2e5cb97ULL, 0x57c2c41692bb501cULL, 0x2d1ab4dea28ed965ULL, - 0x624ac0f56a91f461ULL, 0x1892b03d5aa47d18ULL, 0x97fa21650afae693ULL, 0xed2251ad3acf6feaULL, - 0x095ac9329ac4bc9bULL, 0x7382b9faaaf135e2ULL, 0xfcea28a2faafae69ULL, 0x8632586aca9a2710ULL, - 0xc9622c4102850a14ULL, 0xb3ba5c8932b0836dULL, 0x3cd2cdd162ee18e6ULL, 0x460abd1952db919fULL, - 0x256b24ca6b12f26dULL, 0x5fb354025b277b14ULL, 0xd0dbc55a0b79e09fULL, 0xaa03b5923b4c69e6ULL, - 0xe553c1b9f35344e2ULL, 0x9f8bb171c366cd9bULL, 0x10e3202993385610ULL, 0x6a3b50e1a30ddf69ULL, - 0x8e43c87e03060c18ULL, 0xf49bb8b633338561ULL, 0x7bf329ee636d1eeaULL, 0x012b592653589793ULL, - 0x4e7b2d0d9b47ba97ULL, 0x34a35dc5ab7233eeULL, 0xbbcbcc9dfb2ca865ULL, 0xc113bc55cb19211cULL, - 0x5863dbf1e3ac9decULL, 0x22bbab39d3991495ULL, 0xadd33a6183c78f1eULL, 0xd70b4aa9b3f20667ULL, - 0x985b3e827bed2b63ULL, 0xe2834e4a4bd8a21aULL, 0x6debdf121b863991ULL, 0x1733afda2bb3b0e8ULL, - 0xf34b37458bb86399ULL, 0x8993478dbb8deae0ULL, 0x06fbd6d5ebd3716bULL, 0x7c23a61ddbe6f812ULL, - 0x3373d23613f9d516ULL, 0x49aba2fe23cc5c6fULL, 0xc6c333a67392c7e4ULL, 0xbc1b436e43a74e9dULL, - 0x95ac9329ac4bc9b5ULL, 0xef74e3e19c7e40ccULL, 0x601c72b9cc20db47ULL, 0x1ac40271fc15523eULL, - 0x5594765a340a7f3aULL, 0x2f4c0692043ff643ULL, 0xa02497ca54616dc8ULL, 0xdafce7026454e4b1ULL, - 0x3e847f9dc45f37c0ULL, 0x445c0f55f46abeb9ULL, 0xcb349e0da4342532ULL, 0xb1eceec59401ac4bULL, - 0xfebc9aee5c1e814fULL, 0x8464ea266c2b0836ULL, 0x0b0c7b7e3c7593bdULL, 0x71d40bb60c401ac4ULL, - 0xe8a46c1224f5a634ULL, 0x927c1cda14c02f4dULL, 0x1d148d82449eb4c6ULL, 0x67ccfd4a74ab3dbfULL, - 0x289c8961bcb410bbULL, 0x5244f9a98c8199c2ULL, 0xdd2c68f1dcdf0249ULL, 0xa7f41839ecea8b30ULL, - 0x438c80a64ce15841ULL, 0x3954f06e7cd4d138ULL, 0xb63c61362c8a4ab3ULL, 0xcce411fe1cbfc3caULL, - 0x83b465d5d4a0eeceULL, 0xf96c151de49567b7ULL, 0x76048445b4cbfc3cULL, 0x0cdcf48d84fe7545ULL, - 0x6fbd6d5ebd3716b7ULL, 0x15651d968d029fceULL, 0x9a0d8ccedd5c0445ULL, 0xe0d5fc06ed698d3cULL, - 0xaf85882d2576a038ULL, 0xd55df8e515432941ULL, 0x5a3569bd451db2caULL, 0x20ed197575283bb3ULL, - 0xc49581ead523e8c2ULL, 0xbe4df122e51661bbULL, 0x3125607ab548fa30ULL, 0x4bfd10b2857d7349ULL, - 0x04ad64994d625e4dULL, 0x7e7514517d57d734ULL, 0xf11d85092d094cbfULL, 0x8bc5f5c11d3cc5c6ULL, - 0x12b5926535897936ULL, 0x686de2ad05bcf04fULL, 0xe70573f555e26bc4ULL, 0x9ddd033d65d7e2bdULL, - 0xd28d7716adc8cfb9ULL, 0xa85507de9dfd46c0ULL, 0x273d9686cda3dd4bULL, 0x5de5e64efd965432ULL, - 0xb99d7ed15d9d8743ULL, 0xc3450e196da80e3aULL, 0x4c2d9f413df695b1ULL, 0x36f5ef890dc31cc8ULL, - 0x79a59ba2c5dc31ccULL, 0x037deb6af5e9b8b5ULL, 0x8c157a32a5b7233eULL, 0xf6cd0afa9582aa47ULL, - 0x4ad64994d625e4daULL, 0x300e395ce6106da3ULL, 0xbf66a804b64ef628ULL, 0xc5bed8cc867b7f51ULL, - 0x8aeeace74e645255ULL, 0xf036dc2f7e51db2cULL, 0x7f5e4d772e0f40a7ULL, 0x05863dbf1e3ac9deULL, - 0xe1fea520be311aafULL, 0x9b26d5e88e0493d6ULL, 0x144e44b0de5a085dULL, 0x6e963478ee6f8124ULL, - 0x21c640532670ac20ULL, 0x5b1e309b16452559ULL, 0xd476a1c3461bbed2ULL, 0xaeaed10b762e37abULL, - 0x37deb6af5e9b8b5bULL, 0x4d06c6676eae0222ULL, 0xc26e573f3ef099a9ULL, 0xb8b627f70ec510d0ULL, - 0xf7e653dcc6da3dd4ULL, 0x8d3e2314f6efb4adULL, 0x0256b24ca6b12f26ULL, 0x788ec2849684a65fULL, - 0x9cf65a1b368f752eULL, 0xe62e2ad306bafc57ULL, 0x6946bb8b56e467dcULL, 0x139ecb4366d1eea5ULL, - 0x5ccebf68aecec3a1ULL, 0x2616cfa09efb4ad8ULL, 0xa97e5ef8cea5d153ULL, 0xd3a62e30fe90582aULL, - 0xb0c7b7e3c7593bd8ULL, 0xca1fc72bf76cb2a1ULL, 0x45775673a732292aULL, 0x3faf26bb9707a053ULL, - 0x70ff52905f188d57ULL, 0x0a2722586f2d042eULL, 0x854fb3003f739fa5ULL, 0xff97c3c80f4616dcULL, - 0x1bef5b57af4dc5adULL, 0x61372b9f9f784cd4ULL, 0xee5fbac7cf26d75fULL, 0x9487ca0fff135e26ULL, - 0xdbd7be24370c7322ULL, 0xa10fceec0739fa5bULL, 0x2e675fb4576761d0ULL, 0x54bf2f7c6752e8a9ULL, - 0xcdcf48d84fe75459ULL, 0xb71738107fd2dd20ULL, 0x387fa9482f8c46abULL, 0x42a7d9801fb9cfd2ULL, - 0x0df7adabd7a6e2d6ULL, 0x772fdd63e7936bafULL, 0xf8474c3bb7cdf024ULL, 0x829f3cf387f8795dULL, - 0x66e7a46c27f3aa2cULL, 0x1c3fd4a417c62355ULL, 0x935745fc4798b8deULL, 0xe98f353477ad31a7ULL, - 0xa6df411fbfb21ca3ULL, 0xdc0731d78f8795daULL, 0x536fa08fdfd90e51ULL, 0x29b7d047efec8728ULL + static const UInt64 crc64_table[] = { + 0x0000000000000000ULL, 0x42F0E1EBA9EA3693ULL, 0x85E1C3D753D46D26ULL, 0xC711223CFA3E5BB5ULL, + 0x493366450E42ECDFULL, 0x0BC387AEA7A8DA4CULL, 0xCCD2A5925D9681F9ULL, 0x8E224479F47CB76AULL, + 0x9266CC8A1C85D9BEULL, 0xD0962D61B56FEF2DULL, 0x17870F5D4F51B498ULL, 0x5577EEB6E6BB820BULL, + 0xDB55AACF12C73561ULL, 0x99A54B24BB2D03F2ULL, 0x5EB4691841135847ULL, 0x1C4488F3E8F96ED4ULL, + 0x663D78FF90E185EFULL, 0x24CD9914390BB37CULL, 0xE3DCBB28C335E8C9ULL, 0xA12C5AC36ADFDE5AULL, + 0x2F0E1EBA9EA36930ULL, 0x6DFEFF5137495FA3ULL, 0xAAEFDD6DCD770416ULL, 0xE81F3C86649D3285ULL, + 0xF45BB4758C645C51ULL, 0xB6AB559E258E6AC2ULL, 0x71BA77A2DFB03177ULL, 0x334A9649765A07E4ULL, + 0xBD68D2308226B08EULL, 0xFF9833DB2BCC861DULL, 0x388911E7D1F2DDA8ULL, 0x7A79F00C7818EB3BULL, + 0xCC7AF1FF21C30BDEULL, 0x8E8A101488293D4DULL, 0x499B3228721766F8ULL, 0x0B6BD3C3DBFD506BULL, + 0x854997BA2F81E701ULL, 0xC7B97651866BD192ULL, 0x00A8546D7C558A27ULL, 0x4258B586D5BFBCB4ULL, + 0x5E1C3D753D46D260ULL, 0x1CECDC9E94ACE4F3ULL, 0xDBFDFEA26E92BF46ULL, 0x990D1F49C77889D5ULL, + 0x172F5B3033043EBFULL, 0x55DFBADB9AEE082CULL, 0x92CE98E760D05399ULL, 0xD03E790CC93A650AULL, + 0xAA478900B1228E31ULL, 0xE8B768EB18C8B8A2ULL, 0x2FA64AD7E2F6E317ULL, 0x6D56AB3C4B1CD584ULL, + 0xE374EF45BF6062EEULL, 0xA1840EAE168A547DULL, 0x66952C92ECB40FC8ULL, 0x2465CD79455E395BULL, + 0x3821458AADA7578FULL, 0x7AD1A461044D611CULL, 0xBDC0865DFE733AA9ULL, 0xFF3067B657990C3AULL, + 0x711223CFA3E5BB50ULL, 0x33E2C2240A0F8DC3ULL, 0xF4F3E018F031D676ULL, 0xB60301F359DBE0E5ULL, + 0xDA050215EA6C212FULL, 0x98F5E3FE438617BCULL, 0x5FE4C1C2B9B84C09ULL, 0x1D14202910527A9AULL, + 0x93366450E42ECDF0ULL, 0xD1C685BB4DC4FB63ULL, 0x16D7A787B7FAA0D6ULL, 0x5427466C1E109645ULL, + 0x4863CE9FF6E9F891ULL, 0x0A932F745F03CE02ULL, 0xCD820D48A53D95B7ULL, 0x8F72ECA30CD7A324ULL, + 0x0150A8DAF8AB144EULL, 0x43A04931514122DDULL, 0x84B16B0DAB7F7968ULL, 0xC6418AE602954FFBULL, + 0xBC387AEA7A8DA4C0ULL, 0xFEC89B01D3679253ULL, 0x39D9B93D2959C9E6ULL, 0x7B2958D680B3FF75ULL, + 0xF50B1CAF74CF481FULL, 0xB7FBFD44DD257E8CULL, 0x70EADF78271B2539ULL, 0x321A3E938EF113AAULL, + 0x2E5EB66066087D7EULL, 0x6CAE578BCFE24BEDULL, 0xABBF75B735DC1058ULL, 0xE94F945C9C3626CBULL, + 0x676DD025684A91A1ULL, 0x259D31CEC1A0A732ULL, 0xE28C13F23B9EFC87ULL, 0xA07CF2199274CA14ULL, + 0x167FF3EACBAF2AF1ULL, 0x548F120162451C62ULL, 0x939E303D987B47D7ULL, 0xD16ED1D631917144ULL, + 0x5F4C95AFC5EDC62EULL, 0x1DBC74446C07F0BDULL, 0xDAAD56789639AB08ULL, 0x985DB7933FD39D9BULL, + 0x84193F60D72AF34FULL, 0xC6E9DE8B7EC0C5DCULL, 0x01F8FCB784FE9E69ULL, 0x43081D5C2D14A8FAULL, + 0xCD2A5925D9681F90ULL, 0x8FDAB8CE70822903ULL, 0x48CB9AF28ABC72B6ULL, 0x0A3B7B1923564425ULL, + 0x70428B155B4EAF1EULL, 0x32B26AFEF2A4998DULL, 0xF5A348C2089AC238ULL, 0xB753A929A170F4ABULL, + 0x3971ED50550C43C1ULL, 0x7B810CBBFCE67552ULL, 0xBC902E8706D82EE7ULL, 0xFE60CF6CAF321874ULL, + 0xE224479F47CB76A0ULL, 0xA0D4A674EE214033ULL, 0x67C58448141F1B86ULL, 0x253565A3BDF52D15ULL, + 0xAB1721DA49899A7FULL, 0xE9E7C031E063ACECULL, 0x2EF6E20D1A5DF759ULL, 0x6C0603E6B3B7C1CAULL, + 0xF6FAE5C07D3274CDULL, 0xB40A042BD4D8425EULL, 0x731B26172EE619EBULL, 0x31EBC7FC870C2F78ULL, + 0xBFC9838573709812ULL, 0xFD39626EDA9AAE81ULL, 0x3A28405220A4F534ULL, 0x78D8A1B9894EC3A7ULL, + 0x649C294A61B7AD73ULL, 0x266CC8A1C85D9BE0ULL, 0xE17DEA9D3263C055ULL, 0xA38D0B769B89F6C6ULL, + 0x2DAF4F0F6FF541ACULL, 0x6F5FAEE4C61F773FULL, 0xA84E8CD83C212C8AULL, 0xEABE6D3395CB1A19ULL, + 0x90C79D3FEDD3F122ULL, 0xD2377CD44439C7B1ULL, 0x15265EE8BE079C04ULL, 0x57D6BF0317EDAA97ULL, + 0xD9F4FB7AE3911DFDULL, 0x9B041A914A7B2B6EULL, 0x5C1538ADB04570DBULL, 0x1EE5D94619AF4648ULL, + 0x02A151B5F156289CULL, 0x4051B05E58BC1E0FULL, 0x87409262A28245BAULL, 0xC5B073890B687329ULL, + 0x4B9237F0FF14C443ULL, 0x0962D61B56FEF2D0ULL, 0xCE73F427ACC0A965ULL, 0x8C8315CC052A9FF6ULL, + 0x3A80143F5CF17F13ULL, 0x7870F5D4F51B4980ULL, 0xBF61D7E80F251235ULL, 0xFD913603A6CF24A6ULL, + 0x73B3727A52B393CCULL, 0x31439391FB59A55FULL, 0xF652B1AD0167FEEAULL, 0xB4A25046A88DC879ULL, + 0xA8E6D8B54074A6ADULL, 0xEA16395EE99E903EULL, 0x2D071B6213A0CB8BULL, 0x6FF7FA89BA4AFD18ULL, + 0xE1D5BEF04E364A72ULL, 0xA3255F1BE7DC7CE1ULL, 0x64347D271DE22754ULL, 0x26C49CCCB40811C7ULL, + 0x5CBD6CC0CC10FAFCULL, 0x1E4D8D2B65FACC6FULL, 0xD95CAF179FC497DAULL, 0x9BAC4EFC362EA149ULL, + 0x158E0A85C2521623ULL, 0x577EEB6E6BB820B0ULL, 0x906FC95291867B05ULL, 0xD29F28B9386C4D96ULL, + 0xCEDBA04AD0952342ULL, 0x8C2B41A1797F15D1ULL, 0x4B3A639D83414E64ULL, 0x09CA82762AAB78F7ULL, + 0x87E8C60FDED7CF9DULL, 0xC51827E4773DF90EULL, 0x020905D88D03A2BBULL, 0x40F9E43324E99428ULL, + 0x2CFFE7D5975E55E2ULL, 0x6E0F063E3EB46371ULL, 0xA91E2402C48A38C4ULL, 0xEBEEC5E96D600E57ULL, + 0x65CC8190991CB93DULL, 0x273C607B30F68FAEULL, 0xE02D4247CAC8D41BULL, 0xA2DDA3AC6322E288ULL, + 0xBE992B5F8BDB8C5CULL, 0xFC69CAB42231BACFULL, 0x3B78E888D80FE17AULL, 0x7988096371E5D7E9ULL, + 0xF7AA4D1A85996083ULL, 0xB55AACF12C735610ULL, 0x724B8ECDD64D0DA5ULL, 0x30BB6F267FA73B36ULL, + 0x4AC29F2A07BFD00DULL, 0x08327EC1AE55E69EULL, 0xCF235CFD546BBD2BULL, 0x8DD3BD16FD818BB8ULL, + 0x03F1F96F09FD3CD2ULL, 0x41011884A0170A41ULL, 0x86103AB85A2951F4ULL, 0xC4E0DB53F3C36767ULL, + 0xD8A453A01B3A09B3ULL, 0x9A54B24BB2D03F20ULL, 0x5D45907748EE6495ULL, 0x1FB5719CE1045206ULL, + 0x919735E51578E56CULL, 0xD367D40EBC92D3FFULL, 0x1476F63246AC884AULL, 0x568617D9EF46BED9ULL, + 0xE085162AB69D5E3CULL, 0xA275F7C11F7768AFULL, 0x6564D5FDE549331AULL, 0x279434164CA30589ULL, + 0xA9B6706FB8DFB2E3ULL, 0xEB46918411358470ULL, 0x2C57B3B8EB0BDFC5ULL, 0x6EA7525342E1E956ULL, + 0x72E3DAA0AA188782ULL, 0x30133B4B03F2B111ULL, 0xF7021977F9CCEAA4ULL, 0xB5F2F89C5026DC37ULL, + 0x3BD0BCE5A45A6B5DULL, 0x79205D0E0DB05DCEULL, 0xBE317F32F78E067BULL, 0xFCC19ED95E6430E8ULL, + 0x86B86ED5267CDBD3ULL, 0xC4488F3E8F96ED40ULL, 0x0359AD0275A8B6F5ULL, 0x41A94CE9DC428066ULL, + 0xCF8B0890283E370CULL, 0x8D7BE97B81D4019FULL, 0x4A6ACB477BEA5A2AULL, 0x089A2AACD2006CB9ULL, + 0x14DEA25F3AF9026DULL, 0x562E43B4931334FEULL, 0x913F6188692D6F4BULL, 0xD3CF8063C0C759D8ULL, + 0x5DEDC41A34BBEEB2ULL, 0x1F1D25F19D51D821ULL, 0xD80C07CD676F8394ULL, 0x9AFCE626CE85B507ULL }; } - void HashCRC64::Append(const UInt8* data, std::size_t len) + void CRC64Hash::Append(const UInt8* data, std::size_t len) { while (len--) - m_crc = crc64_table[(m_crc ^ *data++) & 0xFF] ^ (m_crc >> 8); + m_crc = (m_crc << 8) ^ crc64_table[((m_crc >> 56) ^ *data++) & 0xFF]; } - void HashCRC64::Begin() + void CRC64Hash::Begin() { m_crc = 0; } - ByteArray HashCRC64::End() + ByteArray CRC64Hash::End() { #ifdef NAZARA_LITTLE_ENDIAN SwapBytes(&m_crc, sizeof(UInt64)); @@ -103,12 +98,12 @@ namespace Nz return ByteArray(reinterpret_cast(&m_crc), 8); } - std::size_t HashCRC64::GetDigestLength() const + std::size_t CRC64Hash::GetDigestLength() const { return 8; } - const char* HashCRC64::GetHashName() const + const char* CRC64Hash::GetHashName() const { return "CRC64"; } diff --git a/src/Nazara/Core/Hash/Fletcher16.cpp b/src/Nazara/Core/Hash/Fletcher16.cpp index a7bf74fd1..2a49df73a 100644 --- a/src/Nazara/Core/Hash/Fletcher16.cpp +++ b/src/Nazara/Core/Hash/Fletcher16.cpp @@ -8,66 +8,51 @@ namespace Nz { - struct HashFletcher16_state + void Fletcher16Hash::Append(const UInt8* data, std::size_t len) { - UInt16 sum1; - UInt16 sum2; - }; - - HashFletcher16::HashFletcher16() - { - m_state = new HashFletcher16_state; - } - - HashFletcher16::~HashFletcher16() - { - delete m_state; - } - - void HashFletcher16::Append(const UInt8* data, std::size_t len) - { - while (len) + while (len > 0) { - std::size_t tlen = std::min(len, 21U); + std::size_t tlen = std::min(len, 20U); len -= tlen; + do { - m_state->sum1 += *data++; - m_state->sum2 += m_state->sum1; + m_sum1 += *data++; + m_sum2 += m_sum1; } while (--tlen); - m_state->sum1 = (m_state->sum1 & 0xff) + (m_state->sum1 >> 8); - m_state->sum2 = (m_state->sum2 & 0xff) + (m_state->sum2 >> 8); + m_sum1 = (m_sum1 & 0xFF) + (m_sum1 >> 8); + m_sum2 = (m_sum2 & 0xFF) + (m_sum2 >> 8); } } - void HashFletcher16::Begin() + void Fletcher16Hash::Begin() { - m_state->sum1 = 0xff; - m_state->sum2 = 0xff; + m_sum1 = 0xFF; + m_sum2 = 0xFF; } - ByteArray HashFletcher16::End() + ByteArray Fletcher16Hash::End() { - m_state->sum1 = (m_state->sum1 & 0xff) + (m_state->sum1 >> 8); - m_state->sum2 = (m_state->sum2 & 0xff) + (m_state->sum2 >> 8); + m_sum1 = (m_sum1 & 0xFF) + (m_sum1 >> 8); + m_sum2 = (m_sum2 & 0xFF) + (m_sum2 >> 8); - UInt32 fletcher = (m_state->sum2 << 8) | m_state->sum1; + UInt16 fletcher = (m_sum2 << 8) | m_sum1; - #ifdef NAZARA_BIG_ENDIAN - SwapBytes(&fletcher, sizeof(UInt32)); + #ifdef NAZARA_LITTLE_ENDIAN + fletcher = SwapBytes(fletcher); #endif return ByteArray(reinterpret_cast(&fletcher), 2); } - std::size_t HashFletcher16::GetDigestLength() const + std::size_t Fletcher16Hash::GetDigestLength() const { return 2; } - const char* HashFletcher16::GetHashName() const + const char* Fletcher16Hash::GetHashName() const { return "Fletcher16"; } diff --git a/src/Nazara/Core/Hash/MD5.cpp b/src/Nazara/Core/Hash/MD5.cpp index d29a73a74..499aa02be 100644 --- a/src/Nazara/Core/Hash/MD5.cpp +++ b/src/Nazara/Core/Hash/MD5.cpp @@ -99,233 +99,55 @@ namespace Nz { - struct HashMD5_state - { - std::size_t count[2]; /* message length in bits, lsw first */ - UInt32 abcd[4]; /* digest buffer */ - UInt8 buf[64]; /* accumulate block */ - }; - - namespace - { - void md5_process(HashMD5_state* state, const UInt8* data) - { - UInt32 a = state->abcd[0]; - UInt32 b = state->abcd[1]; - UInt32 c = state->abcd[2]; - UInt32 d = state->abcd[3]; - UInt32 t; - - #ifdef NAZARA_BIG_ENDIAN - /* Define storage only for big-endian CPUs. */ - UInt32 X[16]; - - /* - * On big-endian machines, we must arrange the bytes in the - * right order. - */ - const UInt8* xp = data; - int i; - - for (i = 0; i < 16; ++i, xp += 4) - X[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24); - #else - /* Define storage for little-endian or both types of CPUs. */ - UInt32 xbuf[16]; - const UInt32* X; - - /* - * On little-endian machines, we can process properly aligned - * data without copying it. - */ - if (!((data - static_cast(nullptr)) & 3)) - { - /* data are properly aligned */ - X = reinterpret_cast(data); - } - else - { - /* not aligned */ - std::memcpy(xbuf, data, 64); - X = xbuf; - } - #endif - - #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n)))) - - /* Round 1. */ - /* Let [abcd k s i] denote the operation - a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */ - #define F(x, y, z) (((x) & (y)) | (~(x) & (z))) - #define SET(a, b, c, d, k, s, Ti)\ - t = a + F(b,c,d) + X[k] + Ti;\ - a = ROTATE_LEFT(t, s) + b - /* Do the following 16 operations. */ - SET(a, b, c, d, 0, 7, T1); - SET(d, a, b, c, 1, 12, T2); - SET(c, d, a, b, 2, 17, T3); - SET(b, c, d, a, 3, 22, T4); - SET(a, b, c, d, 4, 7, T5); - SET(d, a, b, c, 5, 12, T6); - SET(c, d, a, b, 6, 17, T7); - SET(b, c, d, a, 7, 22, T8); - SET(a, b, c, d, 8, 7, T9); - SET(d, a, b, c, 9, 12, T10); - SET(c, d, a, b, 10, 17, T11); - SET(b, c, d, a, 11, 22, T12); - SET(a, b, c, d, 12, 7, T13); - SET(d, a, b, c, 13, 12, T14); - SET(c, d, a, b, 14, 17, T15); - SET(b, c, d, a, 15, 22, T16); - #undef SET - - /* Round 2. */ - /* Let [abcd k s i] denote the operation - a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */ - #define G(x, y, z) (((x) & (z)) | ((y) & ~(z))) - #define SET(a, b, c, d, k, s, Ti)\ - t = a + G(b,c,d) + X[k] + Ti;\ - a = ROTATE_LEFT(t, s) + b - /* Do the following 16 operations. */ - SET(a, b, c, d, 1, 5, T17); - SET(d, a, b, c, 6, 9, T18); - SET(c, d, a, b, 11, 14, T19); - SET(b, c, d, a, 0, 20, T20); - SET(a, b, c, d, 5, 5, T21); - SET(d, a, b, c, 10, 9, T22); - SET(c, d, a, b, 15, 14, T23); - SET(b, c, d, a, 4, 20, T24); - SET(a, b, c, d, 9, 5, T25); - SET(d, a, b, c, 14, 9, T26); - SET(c, d, a, b, 3, 14, T27); - SET(b, c, d, a, 8, 20, T28); - SET(a, b, c, d, 13, 5, T29); - SET(d, a, b, c, 2, 9, T30); - SET(c, d, a, b, 7, 14, T31); - SET(b, c, d, a, 12, 20, T32); - #undef SET - - /* Round 3. */ - /* Let [abcd k s t] denote the operation - a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */ - #define H(x, y, z) ((x) ^ (y) ^ (z)) - #define SET(a, b, c, d, k, s, Ti)\ - t = a + H(b,c,d) + X[k] + Ti;\ - a = ROTATE_LEFT(t, s) + b - /* Do the following 16 operations. */ - SET(a, b, c, d, 5, 4, T33); - SET(d, a, b, c, 8, 11, T34); - SET(c, d, a, b, 11, 16, T35); - SET(b, c, d, a, 14, 23, T36); - SET(a, b, c, d, 1, 4, T37); - SET(d, a, b, c, 4, 11, T38); - SET(c, d, a, b, 7, 16, T39); - SET(b, c, d, a, 10, 23, T40); - SET(a, b, c, d, 13, 4, T41); - SET(d, a, b, c, 0, 11, T42); - SET(c, d, a, b, 3, 16, T43); - SET(b, c, d, a, 6, 23, T44); - SET(a, b, c, d, 9, 4, T45); - SET(d, a, b, c, 12, 11, T46); - SET(c, d, a, b, 15, 16, T47); - SET(b, c, d, a, 2, 23, T48); - #undef SET - - /* Round 4. */ - /* Let [abcd k s t] denote the operation - a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */ - #define I(x, y, z) ((y) ^ ((x) | ~(z))) - #define SET(a, b, c, d, k, s, Ti)\ - t = a + I(b,c,d) + X[k] + Ti;\ - a = ROTATE_LEFT(t, s) + b - /* Do the following 16 operations. */ - SET(a, b, c, d, 0, 6, T49); - SET(d, a, b, c, 7, 10, T50); - SET(c, d, a, b, 14, 15, T51); - SET(b, c, d, a, 5, 21, T52); - SET(a, b, c, d, 12, 6, T53); - SET(d, a, b, c, 3, 10, T54); - SET(c, d, a, b, 10, 15, T55); - SET(b, c, d, a, 1, 21, T56); - SET(a, b, c, d, 8, 6, T57); - SET(d, a, b, c, 15, 10, T58); - SET(c, d, a, b, 6, 15, T59); - SET(b, c, d, a, 13, 21, T60); - SET(a, b, c, d, 4, 6, T61); - SET(d, a, b, c, 11, 10, T62); - SET(c, d, a, b, 2, 15, T63); - SET(b, c, d, a, 9, 21, T64); - #undef SET - - /* Then perform the following additions. (That is increment each - of the four registers by the value it had before this block - was started.) */ - state->abcd[0] += a; - state->abcd[1] += b; - state->abcd[2] += c; - state->abcd[3] += d; - } - } - - HashMD5::HashMD5() - { - m_state = new HashMD5_state; - } - - HashMD5::~HashMD5() - { - delete m_state; - } - - void HashMD5::Append(const UInt8* data, std::size_t len) + void MD5Hash::Append(const UInt8* data, std::size_t len) { const UInt8 *p = data; std::size_t left = len; - int offset = (m_state->count[0] >> 3) & 63; + int offset = (m_count[0] >> 3) & 63; std::size_t nbits = len << 3; if (len <= 0) return; /* Update the message length. */ - m_state->count[1] += len >> 29; - m_state->count[0] += nbits; - if (m_state->count[0] < nbits) - m_state->count[1]++; + m_count[1] += len >> 29; + m_count[0] += nbits; + if (m_count[0] < nbits) + m_count[1]++; /* Process an initial partial block. */ if (offset) { std::size_t copy = (offset + len > 64 ? 64 - offset : len); - std::memcpy(m_state->buf + offset, p, copy); + std::memcpy(m_buf + offset, p, copy); if (offset + copy < 64) return; p += copy; left -= copy; - md5_process(m_state, m_state->buf); + md5_process(m_buf); } /* Process full blocks. */ for (; left >= 64; p += 64, left -= 64) - md5_process(m_state, p); + md5_process(p); /* Process a final partial block. */ if (left) - std::memcpy(m_state->buf, p, left); + std::memcpy(m_buf, p, left); } - void HashMD5::Begin() + void MD5Hash::Begin() { - m_state->count[0] = m_state->count[1] = 0; - m_state->abcd[0] = 0x67452301; - m_state->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476; - m_state->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301; - m_state->abcd[3] = 0x10325476; + m_count[0] = m_count[1] = 0; + m_abcd[0] = 0x67452301; + m_abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476; + m_abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301; + m_abcd[3] = 0x10325476; } - ByteArray HashMD5::End() + ByteArray MD5Hash::End() { static const unsigned char pad[64] = { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -339,26 +161,184 @@ namespace Nz /* Save the length before padding. */ for (i = 0; i < 8; ++i) - data[i] = static_cast(m_state->count[i >> 2] >> ((i & 3) << 3)); + data[i] = static_cast(m_count[i >> 2] >> ((i & 3) << 3)); /* Pad to 56 bytes mod 64. */ - Append(pad, ((55 - (m_state->count[0] >> 3)) & 63) + 1); + Append(pad, ((55 - (m_count[0] >> 3)) & 63) + 1); /* Append the length. */ Append(data, 8); UInt8 digest[16]; for (i = 0; i < 16; ++i) - digest[i] = static_cast(m_state->abcd[i >> 2] >> ((i & 3) << 3)); + digest[i] = static_cast(m_abcd[i >> 2] >> ((i & 3) << 3)); return ByteArray(&digest[0], 16); } - std::size_t HashMD5::GetDigestLength() const + std::size_t MD5Hash::GetDigestLength() const { return 16; } - const char* HashMD5::GetHashName() const + const char* MD5Hash::GetHashName() const { return "MD5"; } + + void MD5Hash::md5_process(const UInt8* data) + { + UInt32 a = m_abcd[0]; + UInt32 b = m_abcd[1]; + UInt32 c = m_abcd[2]; + UInt32 d = m_abcd[3]; + UInt32 t; + +#ifdef NAZARA_BIG_ENDIAN + /* Define storage only for big-endian CPUs. */ + UInt32 X[16]; + + /* + * On big-endian machines, we must arrange the bytes in the + * right order. + */ + const UInt8* xp = data; + int i; + + for (i = 0; i < 16; ++i, xp += 4) + X[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24); +#else + /* Define storage for little-endian or both types of CPUs. */ + UInt32 xbuf[16]; + const UInt32* X; + + /* + * On little-endian machines, we can process properly aligned + * data without copying it. + */ + if (!((data - static_cast(nullptr)) & 3)) + { + /* data are properly aligned */ + X = reinterpret_cast(data); + } + else + { + /* not aligned */ + std::memcpy(xbuf, data, 64); + X = xbuf; + } +#endif + +#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n)))) + + /* Round 1. */ + /* Let [abcd k s i] denote the operation + a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */ +#define F(x, y, z) (((x) & (y)) | (~(x) & (z))) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + F(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 0, 7, T1); + SET(d, a, b, c, 1, 12, T2); + SET(c, d, a, b, 2, 17, T3); + SET(b, c, d, a, 3, 22, T4); + SET(a, b, c, d, 4, 7, T5); + SET(d, a, b, c, 5, 12, T6); + SET(c, d, a, b, 6, 17, T7); + SET(b, c, d, a, 7, 22, T8); + SET(a, b, c, d, 8, 7, T9); + SET(d, a, b, c, 9, 12, T10); + SET(c, d, a, b, 10, 17, T11); + SET(b, c, d, a, 11, 22, T12); + SET(a, b, c, d, 12, 7, T13); + SET(d, a, b, c, 13, 12, T14); + SET(c, d, a, b, 14, 17, T15); + SET(b, c, d, a, 15, 22, T16); +#undef SET + + /* Round 2. */ + /* Let [abcd k s i] denote the operation + a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */ +#define G(x, y, z) (((x) & (z)) | ((y) & ~(z))) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + G(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 1, 5, T17); + SET(d, a, b, c, 6, 9, T18); + SET(c, d, a, b, 11, 14, T19); + SET(b, c, d, a, 0, 20, T20); + SET(a, b, c, d, 5, 5, T21); + SET(d, a, b, c, 10, 9, T22); + SET(c, d, a, b, 15, 14, T23); + SET(b, c, d, a, 4, 20, T24); + SET(a, b, c, d, 9, 5, T25); + SET(d, a, b, c, 14, 9, T26); + SET(c, d, a, b, 3, 14, T27); + SET(b, c, d, a, 8, 20, T28); + SET(a, b, c, d, 13, 5, T29); + SET(d, a, b, c, 2, 9, T30); + SET(c, d, a, b, 7, 14, T31); + SET(b, c, d, a, 12, 20, T32); +#undef SET + + /* Round 3. */ + /* Let [abcd k s t] denote the operation + a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */ +#define H(x, y, z) ((x) ^ (y) ^ (z)) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + H(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 5, 4, T33); + SET(d, a, b, c, 8, 11, T34); + SET(c, d, a, b, 11, 16, T35); + SET(b, c, d, a, 14, 23, T36); + SET(a, b, c, d, 1, 4, T37); + SET(d, a, b, c, 4, 11, T38); + SET(c, d, a, b, 7, 16, T39); + SET(b, c, d, a, 10, 23, T40); + SET(a, b, c, d, 13, 4, T41); + SET(d, a, b, c, 0, 11, T42); + SET(c, d, a, b, 3, 16, T43); + SET(b, c, d, a, 6, 23, T44); + SET(a, b, c, d, 9, 4, T45); + SET(d, a, b, c, 12, 11, T46); + SET(c, d, a, b, 15, 16, T47); + SET(b, c, d, a, 2, 23, T48); +#undef SET + + /* Round 4. */ + /* Let [abcd k s t] denote the operation + a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */ +#define I(x, y, z) ((y) ^ ((x) | ~(z))) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + I(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 0, 6, T49); + SET(d, a, b, c, 7, 10, T50); + SET(c, d, a, b, 14, 15, T51); + SET(b, c, d, a, 5, 21, T52); + SET(a, b, c, d, 12, 6, T53); + SET(d, a, b, c, 3, 10, T54); + SET(c, d, a, b, 10, 15, T55); + SET(b, c, d, a, 1, 21, T56); + SET(a, b, c, d, 8, 6, T57); + SET(d, a, b, c, 15, 10, T58); + SET(c, d, a, b, 6, 15, T59); + SET(b, c, d, a, 13, 21, T60); + SET(a, b, c, d, 4, 6, T61); + SET(d, a, b, c, 11, 10, T62); + SET(c, d, a, b, 2, 15, T63); + SET(b, c, d, a, 9, 21, T64); +#undef SET + + /* Then perform the following additions. (That is increment each + of the four registers by the value it had before this block + was started.) */ + m_abcd[0] += a; + m_abcd[1] += b; + m_abcd[2] += c; + m_abcd[3] += d; + } } diff --git a/src/Nazara/Core/Hash/SHA1.cpp b/src/Nazara/Core/Hash/SHA1.cpp index 36274479f..d1e8e6927 100644 --- a/src/Nazara/Core/Hash/SHA1.cpp +++ b/src/Nazara/Core/Hash/SHA1.cpp @@ -8,27 +8,27 @@ namespace Nz { - HashSHA1::HashSHA1() + SHA1Hash::SHA1Hash() { m_state = new SHA_CTX; } - HashSHA1::~HashSHA1() + SHA1Hash::~SHA1Hash() { delete m_state; } - void HashSHA1::Append(const UInt8* data, std::size_t len) + void SHA1Hash::Append(const UInt8* data, std::size_t len) { SHA1_Update(m_state, data, len); } - void HashSHA1::Begin() + void SHA1Hash::Begin() { SHA1_Init(m_state); } - ByteArray HashSHA1::End() + ByteArray SHA1Hash::End() { UInt8 digest[SHA1_DIGEST_LENGTH]; @@ -37,12 +37,12 @@ namespace Nz return ByteArray(digest, SHA1_DIGEST_LENGTH); } - std::size_t HashSHA1::GetDigestLength() const + std::size_t SHA1Hash::GetDigestLength() const { return SHA1_DIGEST_LENGTH; } - const char* HashSHA1::GetHashName() const + const char* SHA1Hash::GetHashName() const { return "SHA1"; } diff --git a/src/Nazara/Core/Hash/SHA224.cpp b/src/Nazara/Core/Hash/SHA224.cpp index 9112d70cd..36bcb36bf 100644 --- a/src/Nazara/Core/Hash/SHA224.cpp +++ b/src/Nazara/Core/Hash/SHA224.cpp @@ -8,27 +8,27 @@ namespace Nz { - HashSHA224::HashSHA224() + SHA224Hash::SHA224Hash() { m_state = new SHA_CTX; } - HashSHA224::~HashSHA224() + SHA224Hash::~SHA224Hash() { delete m_state; } - void HashSHA224::Append(const UInt8* data, std::size_t len) + void SHA224Hash::Append(const UInt8* data, std::size_t len) { SHA224_Update(m_state, data, len); } - void HashSHA224::Begin() + void SHA224Hash::Begin() { SHA224_Init(m_state); } - ByteArray HashSHA224::End() + ByteArray SHA224Hash::End() { UInt8 digest[SHA224_DIGEST_LENGTH]; @@ -37,12 +37,12 @@ namespace Nz return ByteArray(digest, SHA224_DIGEST_LENGTH); } - std::size_t HashSHA224::GetDigestLength() const + std::size_t SHA224Hash::GetDigestLength() const { return SHA224_DIGEST_LENGTH; } - const char* HashSHA224::GetHashName() const + const char* SHA224Hash::GetHashName() const { return "SHA224"; } diff --git a/src/Nazara/Core/Hash/SHA256.cpp b/src/Nazara/Core/Hash/SHA256.cpp index db6694c1b..154d312a0 100644 --- a/src/Nazara/Core/Hash/SHA256.cpp +++ b/src/Nazara/Core/Hash/SHA256.cpp @@ -8,27 +8,27 @@ namespace Nz { - HashSHA256::HashSHA256() + SHA256Hash::SHA256Hash() { m_state = new SHA_CTX; } - HashSHA256::~HashSHA256() + SHA256Hash::~SHA256Hash() { delete m_state; } - void HashSHA256::Append(const UInt8* data, std::size_t len) + void SHA256Hash::Append(const UInt8* data, std::size_t len) { SHA256_Update(m_state, data, len); } - void HashSHA256::Begin() + void SHA256Hash::Begin() { SHA256_Init(m_state); } - ByteArray HashSHA256::End() + ByteArray SHA256Hash::End() { UInt8 digest[SHA256_DIGEST_LENGTH]; @@ -37,12 +37,12 @@ namespace Nz return ByteArray(digest, SHA256_DIGEST_LENGTH); } - std::size_t HashSHA256::GetDigestLength() const + std::size_t SHA256Hash::GetDigestLength() const { return SHA256_DIGEST_LENGTH; } - const char* HashSHA256::GetHashName() const + const char* SHA256Hash::GetHashName() const { return "SHA256"; } diff --git a/src/Nazara/Core/Hash/SHA384.cpp b/src/Nazara/Core/Hash/SHA384.cpp index 82f088534..6c8a67193 100644 --- a/src/Nazara/Core/Hash/SHA384.cpp +++ b/src/Nazara/Core/Hash/SHA384.cpp @@ -8,27 +8,27 @@ namespace Nz { - HashSHA384::HashSHA384() + SHA384Hash::SHA384Hash() { m_state = new SHA_CTX; } - HashSHA384::~HashSHA384() + SHA384Hash::~SHA384Hash() { delete m_state; } - void HashSHA384::Append(const UInt8* data, std::size_t len) + void SHA384Hash::Append(const UInt8* data, std::size_t len) { SHA384_Update(m_state, data, len); } - void HashSHA384::Begin() + void SHA384Hash::Begin() { SHA384_Init(m_state); } - ByteArray HashSHA384::End() + ByteArray SHA384Hash::End() { UInt8 digest[SHA384_DIGEST_LENGTH]; @@ -37,12 +37,12 @@ namespace Nz return ByteArray(digest, SHA384_DIGEST_LENGTH); } - std::size_t HashSHA384::GetDigestLength() const + std::size_t SHA384Hash::GetDigestLength() const { return SHA384_DIGEST_LENGTH; } - const char* HashSHA384::GetHashName() const + const char* SHA384Hash::GetHashName() const { return "SHA384"; } diff --git a/src/Nazara/Core/Hash/SHA512.cpp b/src/Nazara/Core/Hash/SHA512.cpp index 0d17cf8f9..a54607277 100644 --- a/src/Nazara/Core/Hash/SHA512.cpp +++ b/src/Nazara/Core/Hash/SHA512.cpp @@ -8,27 +8,27 @@ namespace Nz { - HashSHA512::HashSHA512() + SHA512Hash::SHA512Hash() { m_state = new SHA_CTX; } - HashSHA512::~HashSHA512() + SHA512Hash::~SHA512Hash() { delete m_state; } - void HashSHA512::Append(const UInt8* data, std::size_t len) + void SHA512Hash::Append(const UInt8* data, std::size_t len) { SHA512_Update(m_state, data, len); } - void HashSHA512::Begin() + void SHA512Hash::Begin() { SHA512_Init(m_state); } - ByteArray HashSHA512::End() + ByteArray SHA512Hash::End() { UInt8 digest[SHA512_DIGEST_LENGTH]; @@ -37,12 +37,12 @@ namespace Nz return ByteArray(digest, SHA512_DIGEST_LENGTH); } - std::size_t HashSHA512::GetDigestLength() const + std::size_t SHA512Hash::GetDigestLength() const { return SHA512_DIGEST_LENGTH; } - const char* HashSHA512::GetHashName() const + const char* SHA512Hash::GetHashName() const { return "SHA512"; } diff --git a/src/Nazara/Core/Hash/Whirlpool.cpp b/src/Nazara/Core/Hash/Whirlpool.cpp index 4ed61704b..1a29e2062 100644 --- a/src/Nazara/Core/Hash/Whirlpool.cpp +++ b/src/Nazara/Core/Hash/Whirlpool.cpp @@ -64,7 +64,7 @@ #include #include -#define ONE64 0xffffffffffffffffULL +#define ONE64 0xFFffffffffffffffULL #define T64(x) ((x) & ONE64) #define ROTR64(v, n) (((v) >> (n)) | T64((v) << (64 - (n)))) @@ -73,819 +73,579 @@ namespace Nz { - struct HashWhirlpool_state - { - std::size_t bufferBits; // current number of bits on the buffer */ - std::size_t bufferPos; // current (possibly incomplete) byte slot on the buffer */ - UInt8 bitLength[32]; // global number of hashed bits (256-bit counter) */ - UInt8 buffer[64]; // buffer of data to hash */ - UInt64 hash[8]; // the hashing state */ - }; - namespace { const UInt64 C0[256] = { - 0x18186018c07830d8ULL, 0x23238c2305af4626ULL, 0xc6c63fc67ef991b8ULL, 0xe8e887e8136fcdfbULL, - 0x878726874ca113cbULL, 0xb8b8dab8a9626d11ULL, 0x0101040108050209ULL, 0x4f4f214f426e9e0dULL, - 0x3636d836adee6c9bULL, 0xa6a6a2a6590451ffULL, 0xd2d26fd2debdb90cULL, 0xf5f5f3f5fb06f70eULL, - 0x7979f979ef80f296ULL, 0x6f6fa16f5fcede30ULL, 0x91917e91fcef3f6dULL, 0x52525552aa07a4f8ULL, - 0x60609d6027fdc047ULL, 0xbcbccabc89766535ULL, 0x9b9b569baccd2b37ULL, 0x8e8e028e048c018aULL, - 0xa3a3b6a371155bd2ULL, 0x0c0c300c603c186cULL, 0x7b7bf17bff8af684ULL, 0x3535d435b5e16a80ULL, - 0x1d1d741de8693af5ULL, 0xe0e0a7e05347ddb3ULL, 0xd7d77bd7f6acb321ULL, 0xc2c22fc25eed999cULL, - 0x2e2eb82e6d965c43ULL, 0x4b4b314b627a9629ULL, 0xfefedffea321e15dULL, 0x575741578216aed5ULL, - 0x15155415a8412abdULL, 0x7777c1779fb6eee8ULL, 0x3737dc37a5eb6e92ULL, 0xe5e5b3e57b56d79eULL, - 0x9f9f469f8cd92313ULL, 0xf0f0e7f0d317fd23ULL, 0x4a4a354a6a7f9420ULL, 0xdada4fda9e95a944ULL, - 0x58587d58fa25b0a2ULL, 0xc9c903c906ca8fcfULL, 0x2929a429558d527cULL, 0x0a0a280a5022145aULL, - 0xb1b1feb1e14f7f50ULL, 0xa0a0baa0691a5dc9ULL, 0x6b6bb16b7fdad614ULL, 0x85852e855cab17d9ULL, - 0xbdbdcebd8173673cULL, 0x5d5d695dd234ba8fULL, 0x1010401080502090ULL, 0xf4f4f7f4f303f507ULL, - 0xcbcb0bcb16c08bddULL, 0x3e3ef83eedc67cd3ULL, 0x0505140528110a2dULL, 0x676781671fe6ce78ULL, - 0xe4e4b7e47353d597ULL, 0x27279c2725bb4e02ULL, 0x4141194132588273ULL, 0x8b8b168b2c9d0ba7ULL, - 0xa7a7a6a7510153f6ULL, 0x7d7de97dcf94fab2ULL, 0x95956e95dcfb3749ULL, 0xd8d847d88e9fad56ULL, - 0xfbfbcbfb8b30eb70ULL, 0xeeee9fee2371c1cdULL, 0x7c7ced7cc791f8bbULL, 0x6666856617e3cc71ULL, - 0xdddd53dda68ea77bULL, 0x17175c17b84b2eafULL, 0x4747014702468e45ULL, 0x9e9e429e84dc211aULL, - 0xcaca0fca1ec589d4ULL, 0x2d2db42d75995a58ULL, 0xbfbfc6bf9179632eULL, 0x07071c07381b0e3fULL, - 0xadad8ead012347acULL, 0x5a5a755aea2fb4b0ULL, 0x838336836cb51befULL, 0x3333cc3385ff66b6ULL, - 0x636391633ff2c65cULL, 0x02020802100a0412ULL, 0xaaaa92aa39384993ULL, 0x7171d971afa8e2deULL, - 0xc8c807c80ecf8dc6ULL, 0x19196419c87d32d1ULL, 0x494939497270923bULL, 0xd9d943d9869aaf5fULL, - 0xf2f2eff2c31df931ULL, 0xe3e3abe34b48dba8ULL, 0x5b5b715be22ab6b9ULL, 0x88881a8834920dbcULL, - 0x9a9a529aa4c8293eULL, 0x262698262dbe4c0bULL, 0x3232c8328dfa64bfULL, 0xb0b0fab0e94a7d59ULL, - 0xe9e983e91b6acff2ULL, 0x0f0f3c0f78331e77ULL, 0xd5d573d5e6a6b733ULL, 0x80803a8074ba1df4ULL, - 0xbebec2be997c6127ULL, 0xcdcd13cd26de87ebULL, 0x3434d034bde46889ULL, 0x48483d487a759032ULL, - 0xffffdbffab24e354ULL, 0x7a7af57af78ff48dULL, 0x90907a90f4ea3d64ULL, 0x5f5f615fc23ebe9dULL, - 0x202080201da0403dULL, 0x6868bd6867d5d00fULL, 0x1a1a681ad07234caULL, 0xaeae82ae192c41b7ULL, - 0xb4b4eab4c95e757dULL, 0x54544d549a19a8ceULL, 0x93937693ece53b7fULL, 0x222288220daa442fULL, - 0x64648d6407e9c863ULL, 0xf1f1e3f1db12ff2aULL, 0x7373d173bfa2e6ccULL, 0x12124812905a2482ULL, - 0x40401d403a5d807aULL, 0x0808200840281048ULL, 0xc3c32bc356e89b95ULL, 0xecec97ec337bc5dfULL, - 0xdbdb4bdb9690ab4dULL, 0xa1a1bea1611f5fc0ULL, 0x8d8d0e8d1c830791ULL, 0x3d3df43df5c97ac8ULL, - 0x97976697ccf1335bULL, 0x0000000000000000ULL, 0xcfcf1bcf36d483f9ULL, 0x2b2bac2b4587566eULL, - 0x7676c57697b3ece1ULL, 0x8282328264b019e6ULL, 0xd6d67fd6fea9b128ULL, 0x1b1b6c1bd87736c3ULL, - 0xb5b5eeb5c15b7774ULL, 0xafaf86af112943beULL, 0x6a6ab56a77dfd41dULL, 0x50505d50ba0da0eaULL, - 0x45450945124c8a57ULL, 0xf3f3ebf3cb18fb38ULL, 0x3030c0309df060adULL, 0xefef9bef2b74c3c4ULL, - 0x3f3ffc3fe5c37edaULL, 0x55554955921caac7ULL, 0xa2a2b2a2791059dbULL, 0xeaea8fea0365c9e9ULL, - 0x656589650fecca6aULL, 0xbabad2bab9686903ULL, 0x2f2fbc2f65935e4aULL, 0xc0c027c04ee79d8eULL, - 0xdede5fdebe81a160ULL, 0x1c1c701ce06c38fcULL, 0xfdfdd3fdbb2ee746ULL, 0x4d4d294d52649a1fULL, - 0x92927292e4e03976ULL, 0x7575c9758fbceafaULL, 0x06061806301e0c36ULL, 0x8a8a128a249809aeULL, - 0xb2b2f2b2f940794bULL, 0xe6e6bfe66359d185ULL, 0x0e0e380e70361c7eULL, 0x1f1f7c1ff8633ee7ULL, - 0x6262956237f7c455ULL, 0xd4d477d4eea3b53aULL, 0xa8a89aa829324d81ULL, 0x96966296c4f43152ULL, - 0xf9f9c3f99b3aef62ULL, 0xc5c533c566f697a3ULL, 0x2525942535b14a10ULL, 0x59597959f220b2abULL, - 0x84842a8454ae15d0ULL, 0x7272d572b7a7e4c5ULL, 0x3939e439d5dd72ecULL, 0x4c4c2d4c5a619816ULL, - 0x5e5e655eca3bbc94ULL, 0x7878fd78e785f09fULL, 0x3838e038ddd870e5ULL, 0x8c8c0a8c14860598ULL, - 0xd1d163d1c6b2bf17ULL, 0xa5a5aea5410b57e4ULL, 0xe2e2afe2434dd9a1ULL, 0x616199612ff8c24eULL, - 0xb3b3f6b3f1457b42ULL, 0x2121842115a54234ULL, 0x9c9c4a9c94d62508ULL, 0x1e1e781ef0663ceeULL, - 0x4343114322528661ULL, 0xc7c73bc776fc93b1ULL, 0xfcfcd7fcb32be54fULL, 0x0404100420140824ULL, - 0x51515951b208a2e3ULL, 0x99995e99bcc72f25ULL, 0x6d6da96d4fc4da22ULL, 0x0d0d340d68391a65ULL, - 0xfafacffa8335e979ULL, 0xdfdf5bdfb684a369ULL, 0x7e7ee57ed79bfca9ULL, 0x242490243db44819ULL, - 0x3b3bec3bc5d776feULL, 0xabab96ab313d4b9aULL, 0xcece1fce3ed181f0ULL, 0x1111441188552299ULL, - 0x8f8f068f0c890383ULL, 0x4e4e254e4a6b9c04ULL, 0xb7b7e6b7d1517366ULL, 0xebeb8beb0b60cbe0ULL, - 0x3c3cf03cfdcc78c1ULL, 0x81813e817cbf1ffdULL, 0x94946a94d4fe3540ULL, 0xf7f7fbf7eb0cf31cULL, - 0xb9b9deb9a1676f18ULL, 0x13134c13985f268bULL, 0x2c2cb02c7d9c5851ULL, 0xd3d36bd3d6b8bb05ULL, - 0xe7e7bbe76b5cd38cULL, 0x6e6ea56e57cbdc39ULL, 0xc4c437c46ef395aaULL, 0x03030c03180f061bULL, - 0x565645568a13acdcULL, 0x44440d441a49885eULL, 0x7f7fe17fdf9efea0ULL, 0xa9a99ea921374f88ULL, - 0x2a2aa82a4d825467ULL, 0xbbbbd6bbb16d6b0aULL, 0xc1c123c146e29f87ULL, 0x53535153a202a6f1ULL, - 0xdcdc57dcae8ba572ULL, 0x0b0b2c0b58271653ULL, 0x9d9d4e9d9cd32701ULL, 0x6c6cad6c47c1d82bULL, - 0x3131c43195f562a4ULL, 0x7474cd7487b9e8f3ULL, 0xf6f6fff6e309f115ULL, 0x464605460a438c4cULL, - 0xacac8aac092645a5ULL, 0x89891e893c970fb5ULL, 0x14145014a04428b4ULL, 0xe1e1a3e15b42dfbaULL, - 0x16165816b04e2ca6ULL, 0x3a3ae83acdd274f7ULL, 0x6969b9696fd0d206ULL, 0x09092409482d1241ULL, - 0x7070dd70a7ade0d7ULL, 0xb6b6e2b6d954716fULL, 0xd0d067d0ceb7bd1eULL, 0xeded93ed3b7ec7d6ULL, - 0xcccc17cc2edb85e2ULL, 0x424215422a578468ULL, 0x98985a98b4c22d2cULL, 0xa4a4aaa4490e55edULL, - 0x2828a0285d885075ULL, 0x5c5c6d5cda31b886ULL, 0xf8f8c7f8933fed6bULL, 0x8686228644a411c2ULL, + 0X18186018C07830D8ULL, 0X23238C2305AF4626ULL, 0XC6C63FC67EF991B8ULL, 0XE8E887E8136FCDFBULL, + 0X878726874CA113CBULL, 0XB8B8DAB8A9626D11ULL, 0X0101040108050209ULL, 0X4F4F214F426E9E0DULL, + 0X3636D836ADEE6C9BULL, 0XA6A6A2A6590451FFULL, 0XD2D26FD2DEBDB90CULL, 0XF5F5F3F5FB06F70EULL, + 0X7979F979EF80F296ULL, 0X6F6FA16F5FCEDE30ULL, 0X91917E91FCEF3F6DULL, 0X52525552AA07A4F8ULL, + 0X60609D6027FDC047ULL, 0XBCBCCABC89766535ULL, 0X9B9B569BACCD2B37ULL, 0X8E8E028E048C018AULL, + 0XA3A3B6A371155BD2ULL, 0X0C0C300C603C186CULL, 0X7B7BF17BFF8AF684ULL, 0X3535D435B5E16A80ULL, + 0X1D1D741DE8693AF5ULL, 0XE0E0A7E05347DDB3ULL, 0XD7D77BD7F6ACB321ULL, 0XC2C22FC25EED999CULL, + 0X2E2EB82E6D965C43ULL, 0X4B4B314B627A9629ULL, 0XFEFEDFFEA321E15DULL, 0X575741578216AED5ULL, + 0X15155415A8412ABDULL, 0X7777C1779FB6EEE8ULL, 0X3737DC37A5EB6E92ULL, 0XE5E5B3E57B56D79EULL, + 0X9F9F469F8CD92313ULL, 0XF0F0E7F0D317FD23ULL, 0X4A4A354A6A7F9420ULL, 0XDADA4FDA9E95A944ULL, + 0X58587D58FA25B0A2ULL, 0XC9C903C906CA8FCFULL, 0X2929A429558D527CULL, 0X0A0A280A5022145AULL, + 0XB1B1FEB1E14F7F50ULL, 0XA0A0BAA0691A5DC9ULL, 0X6B6BB16B7FDAD614ULL, 0X85852E855CAB17D9ULL, + 0XBDBDCEBD8173673CULL, 0X5D5D695DD234BA8FULL, 0X1010401080502090ULL, 0XF4F4F7F4F303F507ULL, + 0XCBCB0BCB16C08BDDULL, 0X3E3EF83EEDC67CD3ULL, 0X0505140528110A2DULL, 0X676781671FE6CE78ULL, + 0XE4E4B7E47353D597ULL, 0X27279C2725BB4E02ULL, 0X4141194132588273ULL, 0X8B8B168B2C9D0BA7ULL, + 0XA7A7A6A7510153F6ULL, 0X7D7DE97DCF94FAB2ULL, 0X95956E95DCFB3749ULL, 0XD8D847D88E9FAD56ULL, + 0XFBFBCBFB8B30EB70ULL, 0XEEEE9FEE2371C1CDULL, 0X7C7CED7CC791F8BBULL, 0X6666856617E3CC71ULL, + 0XDDDD53DDA68EA77BULL, 0X17175C17B84B2EAFULL, 0X4747014702468E45ULL, 0X9E9E429E84DC211AULL, + 0XCACA0FCA1EC589D4ULL, 0X2D2DB42D75995A58ULL, 0XBFBFC6BF9179632EULL, 0X07071C07381B0E3FULL, + 0XADAD8EAD012347ACULL, 0X5A5A755AEA2FB4B0ULL, 0X838336836CB51BEFULL, 0X3333CC3385FF66B6ULL, + 0X636391633FF2C65CULL, 0X02020802100A0412ULL, 0XAAAA92AA39384993ULL, 0X7171D971AFA8E2DEULL, + 0XC8C807C80ECF8DC6ULL, 0X19196419C87D32D1ULL, 0X494939497270923BULL, 0XD9D943D9869AAF5FULL, + 0XF2F2EFF2C31DF931ULL, 0XE3E3ABE34B48DBA8ULL, 0X5B5B715BE22AB6B9ULL, 0X88881A8834920DBCULL, + 0X9A9A529AA4C8293EULL, 0X262698262DBE4C0BULL, 0X3232C8328DFA64BFULL, 0XB0B0FAB0E94A7D59ULL, + 0XE9E983E91B6ACFF2ULL, 0X0F0F3C0F78331E77ULL, 0XD5D573D5E6A6B733ULL, 0X80803A8074BA1DF4ULL, + 0XBEBEC2BE997C6127ULL, 0XCDCD13CD26DE87EBULL, 0X3434D034BDE46889ULL, 0X48483D487A759032ULL, + 0XFFFFDBFFAB24E354ULL, 0X7A7AF57AF78FF48DULL, 0X90907A90F4EA3D64ULL, 0X5F5F615FC23EBE9DULL, + 0X202080201DA0403DULL, 0X6868BD6867D5D00FULL, 0X1A1A681AD07234CAULL, 0XAEAE82AE192C41B7ULL, + 0XB4B4EAB4C95E757DULL, 0X54544D549A19A8CEULL, 0X93937693ECE53B7FULL, 0X222288220DAA442FULL, + 0X64648D6407E9C863ULL, 0XF1F1E3F1DB12FF2AULL, 0X7373D173BFA2E6CCULL, 0X12124812905A2482ULL, + 0X40401D403A5D807AULL, 0X0808200840281048ULL, 0XC3C32BC356E89B95ULL, 0XECEC97EC337BC5DFULL, + 0XDBDB4BDB9690AB4DULL, 0XA1A1BEA1611F5FC0ULL, 0X8D8D0E8D1C830791ULL, 0X3D3DF43DF5C97AC8ULL, + 0X97976697CCF1335BULL, 0X0000000000000000ULL, 0XCFCF1BCF36D483F9ULL, 0X2B2BAC2B4587566EULL, + 0X7676C57697B3ECE1ULL, 0X8282328264B019E6ULL, 0XD6D67FD6FEA9B128ULL, 0X1B1B6C1BD87736C3ULL, + 0XB5B5EEB5C15B7774ULL, 0XAFAF86AF112943BEULL, 0X6A6AB56A77DFD41DULL, 0X50505D50BA0DA0EAULL, + 0X45450945124C8A57ULL, 0XF3F3EBF3CB18FB38ULL, 0X3030C0309DF060ADULL, 0XEFEF9BEF2B74C3C4ULL, + 0X3F3FFC3FE5C37EDAULL, 0X55554955921CAAC7ULL, 0XA2A2B2A2791059DBULL, 0XEAEA8FEA0365C9E9ULL, + 0X656589650FECCA6AULL, 0XBABAD2BAB9686903ULL, 0X2F2FBC2F65935E4AULL, 0XC0C027C04EE79D8EULL, + 0XDEDE5FDEBE81A160ULL, 0X1C1C701CE06C38FCULL, 0XFDFDD3FDBB2EE746ULL, 0X4D4D294D52649A1FULL, + 0X92927292E4E03976ULL, 0X7575C9758FBCEAFAULL, 0X06061806301E0C36ULL, 0X8A8A128A249809AEULL, + 0XB2B2F2B2F940794BULL, 0XE6E6BFE66359D185ULL, 0X0E0E380E70361C7EULL, 0X1F1F7C1FF8633EE7ULL, + 0X6262956237F7C455ULL, 0XD4D477D4EEA3B53AULL, 0XA8A89AA829324D81ULL, 0X96966296C4F43152ULL, + 0XF9F9C3F99B3AEF62ULL, 0XC5C533C566F697A3ULL, 0X2525942535B14A10ULL, 0X59597959F220B2ABULL, + 0X84842A8454AE15D0ULL, 0X7272D572B7A7E4C5ULL, 0X3939E439D5DD72ECULL, 0X4C4C2D4C5A619816ULL, + 0X5E5E655ECA3BBC94ULL, 0X7878FD78E785F09FULL, 0X3838E038DDD870E5ULL, 0X8C8C0A8C14860598ULL, + 0XD1D163D1C6B2BF17ULL, 0XA5A5AEA5410B57E4ULL, 0XE2E2AFE2434DD9A1ULL, 0X616199612FF8C24EULL, + 0XB3B3F6B3F1457B42ULL, 0X2121842115A54234ULL, 0X9C9C4A9C94D62508ULL, 0X1E1E781EF0663CEEULL, + 0X4343114322528661ULL, 0XC7C73BC776FC93B1ULL, 0XFCFCD7FCB32BE54FULL, 0X0404100420140824ULL, + 0X51515951B208A2E3ULL, 0X99995E99BCC72F25ULL, 0X6D6DA96D4FC4DA22ULL, 0X0D0D340D68391A65ULL, + 0XFAFACFFA8335E979ULL, 0XDFDF5BDFB684A369ULL, 0X7E7EE57ED79BFCA9ULL, 0X242490243DB44819ULL, + 0X3B3BEC3BC5D776FEULL, 0XABAB96AB313D4B9AULL, 0XCECE1FCE3ED181F0ULL, 0X1111441188552299ULL, + 0X8F8F068F0C890383ULL, 0X4E4E254E4A6B9C04ULL, 0XB7B7E6B7D1517366ULL, 0XEBEB8BEB0B60CBE0ULL, + 0X3C3CF03CFDCC78C1ULL, 0X81813E817CBF1FFDULL, 0X94946A94D4FE3540ULL, 0XF7F7FBF7EB0CF31CULL, + 0XB9B9DEB9A1676F18ULL, 0X13134C13985F268BULL, 0X2C2CB02C7D9C5851ULL, 0XD3D36BD3D6B8BB05ULL, + 0XE7E7BBE76B5CD38CULL, 0X6E6EA56E57CBDC39ULL, 0XC4C437C46EF395AAULL, 0X03030C03180F061BULL, + 0X565645568A13ACDCULL, 0X44440D441A49885EULL, 0X7F7FE17FDF9EFEA0ULL, 0XA9A99EA921374F88ULL, + 0X2A2AA82A4D825467ULL, 0XBBBBD6BBB16D6B0AULL, 0XC1C123C146E29F87ULL, 0X53535153A202A6F1ULL, + 0XDCDC57DCAE8BA572ULL, 0X0B0B2C0B58271653ULL, 0X9D9D4E9D9CD32701ULL, 0X6C6CAD6C47C1D82BULL, + 0X3131C43195F562A4ULL, 0X7474CD7487B9E8F3ULL, 0XF6F6FFF6E309F115ULL, 0X464605460A438C4CULL, + 0XACAC8AAC092645A5ULL, 0X89891E893C970FB5ULL, 0X14145014A04428B4ULL, 0XE1E1A3E15B42DFBAULL, + 0X16165816B04E2CA6ULL, 0X3A3AE83ACDD274F7ULL, 0X6969B9696FD0D206ULL, 0X09092409482D1241ULL, + 0X7070DD70A7ADE0D7ULL, 0XB6B6E2B6D954716FULL, 0XD0D067D0CEB7BD1EULL, 0XEDED93ED3B7EC7D6ULL, + 0XCCCC17CC2EDB85E2ULL, 0X424215422A578468ULL, 0X98985A98B4C22D2CULL, 0XA4A4AAA4490E55EDULL, + 0X2828A0285D885075ULL, 0X5C5C6D5CDA31B886ULL, 0XF8F8C7F8933FED6BULL, 0X8686228644A411C2ULL, }; const UInt64 C1[256] = { - 0xd818186018c07830ULL, 0x2623238c2305af46ULL, 0xb8c6c63fc67ef991ULL, 0xfbe8e887e8136fcdULL, - 0xcb878726874ca113ULL, 0x11b8b8dab8a9626dULL, 0x0901010401080502ULL, 0x0d4f4f214f426e9eULL, - 0x9b3636d836adee6cULL, 0xffa6a6a2a6590451ULL, 0x0cd2d26fd2debdb9ULL, 0x0ef5f5f3f5fb06f7ULL, - 0x967979f979ef80f2ULL, 0x306f6fa16f5fcedeULL, 0x6d91917e91fcef3fULL, 0xf852525552aa07a4ULL, - 0x4760609d6027fdc0ULL, 0x35bcbccabc897665ULL, 0x379b9b569baccd2bULL, 0x8a8e8e028e048c01ULL, - 0xd2a3a3b6a371155bULL, 0x6c0c0c300c603c18ULL, 0x847b7bf17bff8af6ULL, 0x803535d435b5e16aULL, - 0xf51d1d741de8693aULL, 0xb3e0e0a7e05347ddULL, 0x21d7d77bd7f6acb3ULL, 0x9cc2c22fc25eed99ULL, - 0x432e2eb82e6d965cULL, 0x294b4b314b627a96ULL, 0x5dfefedffea321e1ULL, 0xd5575741578216aeULL, - 0xbd15155415a8412aULL, 0xe87777c1779fb6eeULL, 0x923737dc37a5eb6eULL, 0x9ee5e5b3e57b56d7ULL, - 0x139f9f469f8cd923ULL, 0x23f0f0e7f0d317fdULL, 0x204a4a354a6a7f94ULL, 0x44dada4fda9e95a9ULL, - 0xa258587d58fa25b0ULL, 0xcfc9c903c906ca8fULL, 0x7c2929a429558d52ULL, 0x5a0a0a280a502214ULL, - 0x50b1b1feb1e14f7fULL, 0xc9a0a0baa0691a5dULL, 0x146b6bb16b7fdad6ULL, 0xd985852e855cab17ULL, - 0x3cbdbdcebd817367ULL, 0x8f5d5d695dd234baULL, 0x9010104010805020ULL, 0x07f4f4f7f4f303f5ULL, - 0xddcbcb0bcb16c08bULL, 0xd33e3ef83eedc67cULL, 0x2d0505140528110aULL, 0x78676781671fe6ceULL, - 0x97e4e4b7e47353d5ULL, 0x0227279c2725bb4eULL, 0x7341411941325882ULL, 0xa78b8b168b2c9d0bULL, - 0xf6a7a7a6a7510153ULL, 0xb27d7de97dcf94faULL, 0x4995956e95dcfb37ULL, 0x56d8d847d88e9fadULL, - 0x70fbfbcbfb8b30ebULL, 0xcdeeee9fee2371c1ULL, 0xbb7c7ced7cc791f8ULL, 0x716666856617e3ccULL, - 0x7bdddd53dda68ea7ULL, 0xaf17175c17b84b2eULL, 0x454747014702468eULL, 0x1a9e9e429e84dc21ULL, - 0xd4caca0fca1ec589ULL, 0x582d2db42d75995aULL, 0x2ebfbfc6bf917963ULL, 0x3f07071c07381b0eULL, - 0xacadad8ead012347ULL, 0xb05a5a755aea2fb4ULL, 0xef838336836cb51bULL, 0xb63333cc3385ff66ULL, - 0x5c636391633ff2c6ULL, 0x1202020802100a04ULL, 0x93aaaa92aa393849ULL, 0xde7171d971afa8e2ULL, - 0xc6c8c807c80ecf8dULL, 0xd119196419c87d32ULL, 0x3b49493949727092ULL, 0x5fd9d943d9869aafULL, - 0x31f2f2eff2c31df9ULL, 0xa8e3e3abe34b48dbULL, 0xb95b5b715be22ab6ULL, 0xbc88881a8834920dULL, - 0x3e9a9a529aa4c829ULL, 0x0b262698262dbe4cULL, 0xbf3232c8328dfa64ULL, 0x59b0b0fab0e94a7dULL, - 0xf2e9e983e91b6acfULL, 0x770f0f3c0f78331eULL, 0x33d5d573d5e6a6b7ULL, 0xf480803a8074ba1dULL, - 0x27bebec2be997c61ULL, 0xebcdcd13cd26de87ULL, 0x893434d034bde468ULL, 0x3248483d487a7590ULL, - 0x54ffffdbffab24e3ULL, 0x8d7a7af57af78ff4ULL, 0x6490907a90f4ea3dULL, 0x9d5f5f615fc23ebeULL, - 0x3d202080201da040ULL, 0x0f6868bd6867d5d0ULL, 0xca1a1a681ad07234ULL, 0xb7aeae82ae192c41ULL, - 0x7db4b4eab4c95e75ULL, 0xce54544d549a19a8ULL, 0x7f93937693ece53bULL, 0x2f222288220daa44ULL, - 0x6364648d6407e9c8ULL, 0x2af1f1e3f1db12ffULL, 0xcc7373d173bfa2e6ULL, 0x8212124812905a24ULL, - 0x7a40401d403a5d80ULL, 0x4808082008402810ULL, 0x95c3c32bc356e89bULL, 0xdfecec97ec337bc5ULL, - 0x4ddbdb4bdb9690abULL, 0xc0a1a1bea1611f5fULL, 0x918d8d0e8d1c8307ULL, 0xc83d3df43df5c97aULL, - 0x5b97976697ccf133ULL, 0x0000000000000000ULL, 0xf9cfcf1bcf36d483ULL, 0x6e2b2bac2b458756ULL, - 0xe17676c57697b3ecULL, 0xe68282328264b019ULL, 0x28d6d67fd6fea9b1ULL, 0xc31b1b6c1bd87736ULL, - 0x74b5b5eeb5c15b77ULL, 0xbeafaf86af112943ULL, 0x1d6a6ab56a77dfd4ULL, 0xea50505d50ba0da0ULL, - 0x5745450945124c8aULL, 0x38f3f3ebf3cb18fbULL, 0xad3030c0309df060ULL, 0xc4efef9bef2b74c3ULL, - 0xda3f3ffc3fe5c37eULL, 0xc755554955921caaULL, 0xdba2a2b2a2791059ULL, 0xe9eaea8fea0365c9ULL, - 0x6a656589650feccaULL, 0x03babad2bab96869ULL, 0x4a2f2fbc2f65935eULL, 0x8ec0c027c04ee79dULL, - 0x60dede5fdebe81a1ULL, 0xfc1c1c701ce06c38ULL, 0x46fdfdd3fdbb2ee7ULL, 0x1f4d4d294d52649aULL, - 0x7692927292e4e039ULL, 0xfa7575c9758fbceaULL, 0x3606061806301e0cULL, 0xae8a8a128a249809ULL, - 0x4bb2b2f2b2f94079ULL, 0x85e6e6bfe66359d1ULL, 0x7e0e0e380e70361cULL, 0xe71f1f7c1ff8633eULL, - 0x556262956237f7c4ULL, 0x3ad4d477d4eea3b5ULL, 0x81a8a89aa829324dULL, 0x5296966296c4f431ULL, - 0x62f9f9c3f99b3aefULL, 0xa3c5c533c566f697ULL, 0x102525942535b14aULL, 0xab59597959f220b2ULL, - 0xd084842a8454ae15ULL, 0xc57272d572b7a7e4ULL, 0xec3939e439d5dd72ULL, 0x164c4c2d4c5a6198ULL, - 0x945e5e655eca3bbcULL, 0x9f7878fd78e785f0ULL, 0xe53838e038ddd870ULL, 0x988c8c0a8c148605ULL, - 0x17d1d163d1c6b2bfULL, 0xe4a5a5aea5410b57ULL, 0xa1e2e2afe2434dd9ULL, 0x4e616199612ff8c2ULL, - 0x42b3b3f6b3f1457bULL, 0x342121842115a542ULL, 0x089c9c4a9c94d625ULL, 0xee1e1e781ef0663cULL, - 0x6143431143225286ULL, 0xb1c7c73bc776fc93ULL, 0x4ffcfcd7fcb32be5ULL, 0x2404041004201408ULL, - 0xe351515951b208a2ULL, 0x2599995e99bcc72fULL, 0x226d6da96d4fc4daULL, 0x650d0d340d68391aULL, - 0x79fafacffa8335e9ULL, 0x69dfdf5bdfb684a3ULL, 0xa97e7ee57ed79bfcULL, 0x19242490243db448ULL, - 0xfe3b3bec3bc5d776ULL, 0x9aabab96ab313d4bULL, 0xf0cece1fce3ed181ULL, 0x9911114411885522ULL, - 0x838f8f068f0c8903ULL, 0x044e4e254e4a6b9cULL, 0x66b7b7e6b7d15173ULL, 0xe0ebeb8beb0b60cbULL, - 0xc13c3cf03cfdcc78ULL, 0xfd81813e817cbf1fULL, 0x4094946a94d4fe35ULL, 0x1cf7f7fbf7eb0cf3ULL, - 0x18b9b9deb9a1676fULL, 0x8b13134c13985f26ULL, 0x512c2cb02c7d9c58ULL, 0x05d3d36bd3d6b8bbULL, - 0x8ce7e7bbe76b5cd3ULL, 0x396e6ea56e57cbdcULL, 0xaac4c437c46ef395ULL, 0x1b03030c03180f06ULL, - 0xdc565645568a13acULL, 0x5e44440d441a4988ULL, 0xa07f7fe17fdf9efeULL, 0x88a9a99ea921374fULL, - 0x672a2aa82a4d8254ULL, 0x0abbbbd6bbb16d6bULL, 0x87c1c123c146e29fULL, 0xf153535153a202a6ULL, - 0x72dcdc57dcae8ba5ULL, 0x530b0b2c0b582716ULL, 0x019d9d4e9d9cd327ULL, 0x2b6c6cad6c47c1d8ULL, - 0xa43131c43195f562ULL, 0xf37474cd7487b9e8ULL, 0x15f6f6fff6e309f1ULL, 0x4c464605460a438cULL, - 0xa5acac8aac092645ULL, 0xb589891e893c970fULL, 0xb414145014a04428ULL, 0xbae1e1a3e15b42dfULL, - 0xa616165816b04e2cULL, 0xf73a3ae83acdd274ULL, 0x066969b9696fd0d2ULL, 0x4109092409482d12ULL, - 0xd77070dd70a7ade0ULL, 0x6fb6b6e2b6d95471ULL, 0x1ed0d067d0ceb7bdULL, 0xd6eded93ed3b7ec7ULL, - 0xe2cccc17cc2edb85ULL, 0x68424215422a5784ULL, 0x2c98985a98b4c22dULL, 0xeda4a4aaa4490e55ULL, - 0x752828a0285d8850ULL, 0x865c5c6d5cda31b8ULL, 0x6bf8f8c7f8933fedULL, 0xc28686228644a411ULL, + 0XD818186018C07830ULL, 0X2623238C2305AF46ULL, 0XB8C6C63FC67EF991ULL, 0XFBE8E887E8136FCDULL, + 0XCB878726874CA113ULL, 0X11B8B8DAB8A9626DULL, 0X0901010401080502ULL, 0X0D4F4F214F426E9EULL, + 0X9B3636D836ADEE6CULL, 0XFFA6A6A2A6590451ULL, 0X0CD2D26FD2DEBDB9ULL, 0X0EF5F5F3F5FB06F7ULL, + 0X967979F979EF80F2ULL, 0X306F6FA16F5FCEDEULL, 0X6D91917E91FCEF3FULL, 0XF852525552AA07A4ULL, + 0X4760609D6027FDC0ULL, 0X35BCBCCABC897665ULL, 0X379B9B569BACCD2BULL, 0X8A8E8E028E048C01ULL, + 0XD2A3A3B6A371155BULL, 0X6C0C0C300C603C18ULL, 0X847B7BF17BFF8AF6ULL, 0X803535D435B5E16AULL, + 0XF51D1D741DE8693AULL, 0XB3E0E0A7E05347DDULL, 0X21D7D77BD7F6ACB3ULL, 0X9CC2C22FC25EED99ULL, + 0X432E2EB82E6D965CULL, 0X294B4B314B627A96ULL, 0X5DFEFEDFFEA321E1ULL, 0XD5575741578216AEULL, + 0XBD15155415A8412AULL, 0XE87777C1779FB6EEULL, 0X923737DC37A5EB6EULL, 0X9EE5E5B3E57B56D7ULL, + 0X139F9F469F8CD923ULL, 0X23F0F0E7F0D317FDULL, 0X204A4A354A6A7F94ULL, 0X44DADA4FDA9E95A9ULL, + 0XA258587D58FA25B0ULL, 0XCFC9C903C906CA8FULL, 0X7C2929A429558D52ULL, 0X5A0A0A280A502214ULL, + 0X50B1B1FEB1E14F7FULL, 0XC9A0A0BAA0691A5DULL, 0X146B6BB16B7FDAD6ULL, 0XD985852E855CAB17ULL, + 0X3CBDBDCEBD817367ULL, 0X8F5D5D695DD234BAULL, 0X9010104010805020ULL, 0X07F4F4F7F4F303F5ULL, + 0XDDCBCB0BCB16C08BULL, 0XD33E3EF83EEDC67CULL, 0X2D0505140528110AULL, 0X78676781671FE6CEULL, + 0X97E4E4B7E47353D5ULL, 0X0227279C2725BB4EULL, 0X7341411941325882ULL, 0XA78B8B168B2C9D0BULL, + 0XF6A7A7A6A7510153ULL, 0XB27D7DE97DCF94FAULL, 0X4995956E95DCFB37ULL, 0X56D8D847D88E9FADULL, + 0X70FBFBCBFB8B30EBULL, 0XCDEEEE9FEE2371C1ULL, 0XBB7C7CED7CC791F8ULL, 0X716666856617E3CCULL, + 0X7BDDDD53DDA68EA7ULL, 0XAF17175C17B84B2EULL, 0X454747014702468EULL, 0X1A9E9E429E84DC21ULL, + 0XD4CACA0FCA1EC589ULL, 0X582D2DB42D75995AULL, 0X2EBFBFC6BF917963ULL, 0X3F07071C07381B0EULL, + 0XACADAD8EAD012347ULL, 0XB05A5A755AEA2FB4ULL, 0XEF838336836CB51BULL, 0XB63333CC3385FF66ULL, + 0X5C636391633FF2C6ULL, 0X1202020802100A04ULL, 0X93AAAA92AA393849ULL, 0XDE7171D971AFA8E2ULL, + 0XC6C8C807C80ECF8DULL, 0XD119196419C87D32ULL, 0X3B49493949727092ULL, 0X5FD9D943D9869AAFULL, + 0X31F2F2EFF2C31DF9ULL, 0XA8E3E3ABE34B48DBULL, 0XB95B5B715BE22AB6ULL, 0XBC88881A8834920DULL, + 0X3E9A9A529AA4C829ULL, 0X0B262698262DBE4CULL, 0XBF3232C8328DFA64ULL, 0X59B0B0FAB0E94A7DULL, + 0XF2E9E983E91B6ACFULL, 0X770F0F3C0F78331EULL, 0X33D5D573D5E6A6B7ULL, 0XF480803A8074BA1DULL, + 0X27BEBEC2BE997C61ULL, 0XEBCDCD13CD26DE87ULL, 0X893434D034BDE468ULL, 0X3248483D487A7590ULL, + 0X54FFFFDBFFAB24E3ULL, 0X8D7A7AF57AF78FF4ULL, 0X6490907A90F4EA3DULL, 0X9D5F5F615FC23EBEULL, + 0X3D202080201DA040ULL, 0X0F6868BD6867D5D0ULL, 0XCA1A1A681AD07234ULL, 0XB7AEAE82AE192C41ULL, + 0X7DB4B4EAB4C95E75ULL, 0XCE54544D549A19A8ULL, 0X7F93937693ECE53BULL, 0X2F222288220DAA44ULL, + 0X6364648D6407E9C8ULL, 0X2AF1F1E3F1DB12FFULL, 0XCC7373D173BFA2E6ULL, 0X8212124812905A24ULL, + 0X7A40401D403A5D80ULL, 0X4808082008402810ULL, 0X95C3C32BC356E89BULL, 0XDFECEC97EC337BC5ULL, + 0X4DDBDB4BDB9690ABULL, 0XC0A1A1BEA1611F5FULL, 0X918D8D0E8D1C8307ULL, 0XC83D3DF43DF5C97AULL, + 0X5B97976697CCF133ULL, 0X0000000000000000ULL, 0XF9CFCF1BCF36D483ULL, 0X6E2B2BAC2B458756ULL, + 0XE17676C57697B3ECULL, 0XE68282328264B019ULL, 0X28D6D67FD6FEA9B1ULL, 0XC31B1B6C1BD87736ULL, + 0X74B5B5EEB5C15B77ULL, 0XBEAFAF86AF112943ULL, 0X1D6A6AB56A77DFD4ULL, 0XEA50505D50BA0DA0ULL, + 0X5745450945124C8AULL, 0X38F3F3EBF3CB18FBULL, 0XAD3030C0309DF060ULL, 0XC4EFEF9BEF2B74C3ULL, + 0XDA3F3FFC3FE5C37EULL, 0XC755554955921CAAULL, 0XDBA2A2B2A2791059ULL, 0XE9EAEA8FEA0365C9ULL, + 0X6A656589650FECCAULL, 0X03BABAD2BAB96869ULL, 0X4A2F2FBC2F65935EULL, 0X8EC0C027C04EE79DULL, + 0X60DEDE5FDEBE81A1ULL, 0XFC1C1C701CE06C38ULL, 0X46FDFDD3FDBB2EE7ULL, 0X1F4D4D294D52649AULL, + 0X7692927292E4E039ULL, 0XFA7575C9758FBCEAULL, 0X3606061806301E0CULL, 0XAE8A8A128A249809ULL, + 0X4BB2B2F2B2F94079ULL, 0X85E6E6BFE66359D1ULL, 0X7E0E0E380E70361CULL, 0XE71F1F7C1FF8633EULL, + 0X556262956237F7C4ULL, 0X3AD4D477D4EEA3B5ULL, 0X81A8A89AA829324DULL, 0X5296966296C4F431ULL, + 0X62F9F9C3F99B3AEFULL, 0XA3C5C533C566F697ULL, 0X102525942535B14AULL, 0XAB59597959F220B2ULL, + 0XD084842A8454AE15ULL, 0XC57272D572B7A7E4ULL, 0XEC3939E439D5DD72ULL, 0X164C4C2D4C5A6198ULL, + 0X945E5E655ECA3BBCULL, 0X9F7878FD78E785F0ULL, 0XE53838E038DDD870ULL, 0X988C8C0A8C148605ULL, + 0X17D1D163D1C6B2BFULL, 0XE4A5A5AEA5410B57ULL, 0XA1E2E2AFE2434DD9ULL, 0X4E616199612FF8C2ULL, + 0X42B3B3F6B3F1457BULL, 0X342121842115A542ULL, 0X089C9C4A9C94D625ULL, 0XEE1E1E781EF0663CULL, + 0X6143431143225286ULL, 0XB1C7C73BC776FC93ULL, 0X4FFCFCD7FCB32BE5ULL, 0X2404041004201408ULL, + 0XE351515951B208A2ULL, 0X2599995E99BCC72FULL, 0X226D6DA96D4FC4DAULL, 0X650D0D340D68391AULL, + 0X79FAFACFFA8335E9ULL, 0X69DFDF5BDFB684A3ULL, 0XA97E7EE57ED79BFCULL, 0X19242490243DB448ULL, + 0XFE3B3BEC3BC5D776ULL, 0X9AABAB96AB313D4BULL, 0XF0CECE1FCE3ED181ULL, 0X9911114411885522ULL, + 0X838F8F068F0C8903ULL, 0X044E4E254E4A6B9CULL, 0X66B7B7E6B7D15173ULL, 0XE0EBEB8BEB0B60CBULL, + 0XC13C3CF03CFDCC78ULL, 0XFD81813E817CBF1FULL, 0X4094946A94D4FE35ULL, 0X1CF7F7FBF7EB0CF3ULL, + 0X18B9B9DEB9A1676FULL, 0X8B13134C13985F26ULL, 0X512C2CB02C7D9C58ULL, 0X05D3D36BD3D6B8BBULL, + 0X8CE7E7BBE76B5CD3ULL, 0X396E6EA56E57CBDCULL, 0XAAC4C437C46EF395ULL, 0X1B03030C03180F06ULL, + 0XDC565645568A13ACULL, 0X5E44440D441A4988ULL, 0XA07F7FE17FDF9EFEULL, 0X88A9A99EA921374FULL, + 0X672A2AA82A4D8254ULL, 0X0ABBBBD6BBB16D6BULL, 0X87C1C123C146E29FULL, 0XF153535153A202A6ULL, + 0X72DCDC57DCAE8BA5ULL, 0X530B0B2C0B582716ULL, 0X019D9D4E9D9CD327ULL, 0X2B6C6CAD6C47C1D8ULL, + 0XA43131C43195F562ULL, 0XF37474CD7487B9E8ULL, 0X15F6F6FFF6E309F1ULL, 0X4C464605460A438CULL, + 0XA5ACAC8AAC092645ULL, 0XB589891E893C970FULL, 0XB414145014A04428ULL, 0XBAE1E1A3E15B42DFULL, + 0XA616165816B04E2CULL, 0XF73A3AE83ACDD274ULL, 0X066969B9696FD0D2ULL, 0X4109092409482D12ULL, + 0XD77070DD70A7ADE0ULL, 0X6FB6B6E2B6D95471ULL, 0X1ED0D067D0CEB7BDULL, 0XD6EDED93ED3B7EC7ULL, + 0XE2CCCC17CC2EDB85ULL, 0X68424215422A5784ULL, 0X2C98985A98B4C22DULL, 0XEDA4A4AAA4490E55ULL, + 0X752828A0285D8850ULL, 0X865C5C6D5CDA31B8ULL, 0X6BF8F8C7F8933FEDULL, 0XC28686228644A411ULL, }; const UInt64 C2[256] = { - 0x30d818186018c078ULL, 0x462623238c2305afULL, 0x91b8c6c63fc67ef9ULL, 0xcdfbe8e887e8136fULL, - 0x13cb878726874ca1ULL, 0x6d11b8b8dab8a962ULL, 0x0209010104010805ULL, 0x9e0d4f4f214f426eULL, - 0x6c9b3636d836adeeULL, 0x51ffa6a6a2a65904ULL, 0xb90cd2d26fd2debdULL, 0xf70ef5f5f3f5fb06ULL, - 0xf2967979f979ef80ULL, 0xde306f6fa16f5fceULL, 0x3f6d91917e91fcefULL, 0xa4f852525552aa07ULL, - 0xc04760609d6027fdULL, 0x6535bcbccabc8976ULL, 0x2b379b9b569baccdULL, 0x018a8e8e028e048cULL, - 0x5bd2a3a3b6a37115ULL, 0x186c0c0c300c603cULL, 0xf6847b7bf17bff8aULL, 0x6a803535d435b5e1ULL, - 0x3af51d1d741de869ULL, 0xddb3e0e0a7e05347ULL, 0xb321d7d77bd7f6acULL, 0x999cc2c22fc25eedULL, - 0x5c432e2eb82e6d96ULL, 0x96294b4b314b627aULL, 0xe15dfefedffea321ULL, 0xaed5575741578216ULL, - 0x2abd15155415a841ULL, 0xeee87777c1779fb6ULL, 0x6e923737dc37a5ebULL, 0xd79ee5e5b3e57b56ULL, - 0x23139f9f469f8cd9ULL, 0xfd23f0f0e7f0d317ULL, 0x94204a4a354a6a7fULL, 0xa944dada4fda9e95ULL, - 0xb0a258587d58fa25ULL, 0x8fcfc9c903c906caULL, 0x527c2929a429558dULL, 0x145a0a0a280a5022ULL, - 0x7f50b1b1feb1e14fULL, 0x5dc9a0a0baa0691aULL, 0xd6146b6bb16b7fdaULL, 0x17d985852e855cabULL, - 0x673cbdbdcebd8173ULL, 0xba8f5d5d695dd234ULL, 0x2090101040108050ULL, 0xf507f4f4f7f4f303ULL, - 0x8bddcbcb0bcb16c0ULL, 0x7cd33e3ef83eedc6ULL, 0x0a2d050514052811ULL, 0xce78676781671fe6ULL, - 0xd597e4e4b7e47353ULL, 0x4e0227279c2725bbULL, 0x8273414119413258ULL, 0x0ba78b8b168b2c9dULL, - 0x53f6a7a7a6a75101ULL, 0xfab27d7de97dcf94ULL, 0x374995956e95dcfbULL, 0xad56d8d847d88e9fULL, - 0xeb70fbfbcbfb8b30ULL, 0xc1cdeeee9fee2371ULL, 0xf8bb7c7ced7cc791ULL, 0xcc716666856617e3ULL, - 0xa77bdddd53dda68eULL, 0x2eaf17175c17b84bULL, 0x8e45474701470246ULL, 0x211a9e9e429e84dcULL, - 0x89d4caca0fca1ec5ULL, 0x5a582d2db42d7599ULL, 0x632ebfbfc6bf9179ULL, 0x0e3f07071c07381bULL, - 0x47acadad8ead0123ULL, 0xb4b05a5a755aea2fULL, 0x1bef838336836cb5ULL, 0x66b63333cc3385ffULL, - 0xc65c636391633ff2ULL, 0x041202020802100aULL, 0x4993aaaa92aa3938ULL, 0xe2de7171d971afa8ULL, - 0x8dc6c8c807c80ecfULL, 0x32d119196419c87dULL, 0x923b494939497270ULL, 0xaf5fd9d943d9869aULL, - 0xf931f2f2eff2c31dULL, 0xdba8e3e3abe34b48ULL, 0xb6b95b5b715be22aULL, 0x0dbc88881a883492ULL, - 0x293e9a9a529aa4c8ULL, 0x4c0b262698262dbeULL, 0x64bf3232c8328dfaULL, 0x7d59b0b0fab0e94aULL, - 0xcff2e9e983e91b6aULL, 0x1e770f0f3c0f7833ULL, 0xb733d5d573d5e6a6ULL, 0x1df480803a8074baULL, - 0x6127bebec2be997cULL, 0x87ebcdcd13cd26deULL, 0x68893434d034bde4ULL, 0x903248483d487a75ULL, - 0xe354ffffdbffab24ULL, 0xf48d7a7af57af78fULL, 0x3d6490907a90f4eaULL, 0xbe9d5f5f615fc23eULL, - 0x403d202080201da0ULL, 0xd00f6868bd6867d5ULL, 0x34ca1a1a681ad072ULL, 0x41b7aeae82ae192cULL, - 0x757db4b4eab4c95eULL, 0xa8ce54544d549a19ULL, 0x3b7f93937693ece5ULL, 0x442f222288220daaULL, - 0xc86364648d6407e9ULL, 0xff2af1f1e3f1db12ULL, 0xe6cc7373d173bfa2ULL, 0x248212124812905aULL, - 0x807a40401d403a5dULL, 0x1048080820084028ULL, 0x9b95c3c32bc356e8ULL, 0xc5dfecec97ec337bULL, - 0xab4ddbdb4bdb9690ULL, 0x5fc0a1a1bea1611fULL, 0x07918d8d0e8d1c83ULL, 0x7ac83d3df43df5c9ULL, - 0x335b97976697ccf1ULL, 0x0000000000000000ULL, 0x83f9cfcf1bcf36d4ULL, 0x566e2b2bac2b4587ULL, - 0xece17676c57697b3ULL, 0x19e68282328264b0ULL, 0xb128d6d67fd6fea9ULL, 0x36c31b1b6c1bd877ULL, - 0x7774b5b5eeb5c15bULL, 0x43beafaf86af1129ULL, 0xd41d6a6ab56a77dfULL, 0xa0ea50505d50ba0dULL, - 0x8a5745450945124cULL, 0xfb38f3f3ebf3cb18ULL, 0x60ad3030c0309df0ULL, 0xc3c4efef9bef2b74ULL, - 0x7eda3f3ffc3fe5c3ULL, 0xaac755554955921cULL, 0x59dba2a2b2a27910ULL, 0xc9e9eaea8fea0365ULL, - 0xca6a656589650fecULL, 0x6903babad2bab968ULL, 0x5e4a2f2fbc2f6593ULL, 0x9d8ec0c027c04ee7ULL, - 0xa160dede5fdebe81ULL, 0x38fc1c1c701ce06cULL, 0xe746fdfdd3fdbb2eULL, 0x9a1f4d4d294d5264ULL, - 0x397692927292e4e0ULL, 0xeafa7575c9758fbcULL, 0x0c3606061806301eULL, 0x09ae8a8a128a2498ULL, - 0x794bb2b2f2b2f940ULL, 0xd185e6e6bfe66359ULL, 0x1c7e0e0e380e7036ULL, 0x3ee71f1f7c1ff863ULL, - 0xc4556262956237f7ULL, 0xb53ad4d477d4eea3ULL, 0x4d81a8a89aa82932ULL, 0x315296966296c4f4ULL, - 0xef62f9f9c3f99b3aULL, 0x97a3c5c533c566f6ULL, 0x4a102525942535b1ULL, 0xb2ab59597959f220ULL, - 0x15d084842a8454aeULL, 0xe4c57272d572b7a7ULL, 0x72ec3939e439d5ddULL, 0x98164c4c2d4c5a61ULL, - 0xbc945e5e655eca3bULL, 0xf09f7878fd78e785ULL, 0x70e53838e038ddd8ULL, 0x05988c8c0a8c1486ULL, - 0xbf17d1d163d1c6b2ULL, 0x57e4a5a5aea5410bULL, 0xd9a1e2e2afe2434dULL, 0xc24e616199612ff8ULL, - 0x7b42b3b3f6b3f145ULL, 0x42342121842115a5ULL, 0x25089c9c4a9c94d6ULL, 0x3cee1e1e781ef066ULL, - 0x8661434311432252ULL, 0x93b1c7c73bc776fcULL, 0xe54ffcfcd7fcb32bULL, 0x0824040410042014ULL, - 0xa2e351515951b208ULL, 0x2f2599995e99bcc7ULL, 0xda226d6da96d4fc4ULL, 0x1a650d0d340d6839ULL, - 0xe979fafacffa8335ULL, 0xa369dfdf5bdfb684ULL, 0xfca97e7ee57ed79bULL, 0x4819242490243db4ULL, - 0x76fe3b3bec3bc5d7ULL, 0x4b9aabab96ab313dULL, 0x81f0cece1fce3ed1ULL, 0x2299111144118855ULL, - 0x03838f8f068f0c89ULL, 0x9c044e4e254e4a6bULL, 0x7366b7b7e6b7d151ULL, 0xcbe0ebeb8beb0b60ULL, - 0x78c13c3cf03cfdccULL, 0x1ffd81813e817cbfULL, 0x354094946a94d4feULL, 0xf31cf7f7fbf7eb0cULL, - 0x6f18b9b9deb9a167ULL, 0x268b13134c13985fULL, 0x58512c2cb02c7d9cULL, 0xbb05d3d36bd3d6b8ULL, - 0xd38ce7e7bbe76b5cULL, 0xdc396e6ea56e57cbULL, 0x95aac4c437c46ef3ULL, 0x061b03030c03180fULL, - 0xacdc565645568a13ULL, 0x885e44440d441a49ULL, 0xfea07f7fe17fdf9eULL, 0x4f88a9a99ea92137ULL, - 0x54672a2aa82a4d82ULL, 0x6b0abbbbd6bbb16dULL, 0x9f87c1c123c146e2ULL, 0xa6f153535153a202ULL, - 0xa572dcdc57dcae8bULL, 0x16530b0b2c0b5827ULL, 0x27019d9d4e9d9cd3ULL, 0xd82b6c6cad6c47c1ULL, - 0x62a43131c43195f5ULL, 0xe8f37474cd7487b9ULL, 0xf115f6f6fff6e309ULL, 0x8c4c464605460a43ULL, - 0x45a5acac8aac0926ULL, 0x0fb589891e893c97ULL, 0x28b414145014a044ULL, 0xdfbae1e1a3e15b42ULL, - 0x2ca616165816b04eULL, 0x74f73a3ae83acdd2ULL, 0xd2066969b9696fd0ULL, 0x124109092409482dULL, - 0xe0d77070dd70a7adULL, 0x716fb6b6e2b6d954ULL, 0xbd1ed0d067d0ceb7ULL, 0xc7d6eded93ed3b7eULL, - 0x85e2cccc17cc2edbULL, 0x8468424215422a57ULL, 0x2d2c98985a98b4c2ULL, 0x55eda4a4aaa4490eULL, - 0x50752828a0285d88ULL, 0xb8865c5c6d5cda31ULL, 0xed6bf8f8c7f8933fULL, 0x11c28686228644a4ULL, + 0X30D818186018C078ULL, 0X462623238C2305AFULL, 0X91B8C6C63FC67EF9ULL, 0XCDFBE8E887E8136FULL, + 0X13CB878726874CA1ULL, 0X6D11B8B8DAB8A962ULL, 0X0209010104010805ULL, 0X9E0D4F4F214F426EULL, + 0X6C9B3636D836ADEEULL, 0X51FFA6A6A2A65904ULL, 0XB90CD2D26FD2DEBDULL, 0XF70EF5F5F3F5FB06ULL, + 0XF2967979F979EF80ULL, 0XDE306F6FA16F5FCEULL, 0X3F6D91917E91FCEFULL, 0XA4F852525552AA07ULL, + 0XC04760609D6027FDULL, 0X6535BCBCCABC8976ULL, 0X2B379B9B569BACCDULL, 0X018A8E8E028E048CULL, + 0X5BD2A3A3B6A37115ULL, 0X186C0C0C300C603CULL, 0XF6847B7BF17BFF8AULL, 0X6A803535D435B5E1ULL, + 0X3AF51D1D741DE869ULL, 0XDDB3E0E0A7E05347ULL, 0XB321D7D77BD7F6ACULL, 0X999CC2C22FC25EEDULL, + 0X5C432E2EB82E6D96ULL, 0X96294B4B314B627AULL, 0XE15DFEFEDFFEA321ULL, 0XAED5575741578216ULL, + 0X2ABD15155415A841ULL, 0XEEE87777C1779FB6ULL, 0X6E923737DC37A5EBULL, 0XD79EE5E5B3E57B56ULL, + 0X23139F9F469F8CD9ULL, 0XFD23F0F0E7F0D317ULL, 0X94204A4A354A6A7FULL, 0XA944DADA4FDA9E95ULL, + 0XB0A258587D58FA25ULL, 0X8FCFC9C903C906CAULL, 0X527C2929A429558DULL, 0X145A0A0A280A5022ULL, + 0X7F50B1B1FEB1E14FULL, 0X5DC9A0A0BAA0691AULL, 0XD6146B6BB16B7FDAULL, 0X17D985852E855CABULL, + 0X673CBDBDCEBD8173ULL, 0XBA8F5D5D695DD234ULL, 0X2090101040108050ULL, 0XF507F4F4F7F4F303ULL, + 0X8BDDCBCB0BCB16C0ULL, 0X7CD33E3EF83EEDC6ULL, 0X0A2D050514052811ULL, 0XCE78676781671FE6ULL, + 0XD597E4E4B7E47353ULL, 0X4E0227279C2725BBULL, 0X8273414119413258ULL, 0X0BA78B8B168B2C9DULL, + 0X53F6A7A7A6A75101ULL, 0XFAB27D7DE97DCF94ULL, 0X374995956E95DCFBULL, 0XAD56D8D847D88E9FULL, + 0XEB70FBFBCBFB8B30ULL, 0XC1CDEEEE9FEE2371ULL, 0XF8BB7C7CED7CC791ULL, 0XCC716666856617E3ULL, + 0XA77BDDDD53DDA68EULL, 0X2EAF17175C17B84BULL, 0X8E45474701470246ULL, 0X211A9E9E429E84DCULL, + 0X89D4CACA0FCA1EC5ULL, 0X5A582D2DB42D7599ULL, 0X632EBFBFC6BF9179ULL, 0X0E3F07071C07381BULL, + 0X47ACADAD8EAD0123ULL, 0XB4B05A5A755AEA2FULL, 0X1BEF838336836CB5ULL, 0X66B63333CC3385FFULL, + 0XC65C636391633FF2ULL, 0X041202020802100AULL, 0X4993AAAA92AA3938ULL, 0XE2DE7171D971AFA8ULL, + 0X8DC6C8C807C80ECFULL, 0X32D119196419C87DULL, 0X923B494939497270ULL, 0XAF5FD9D943D9869AULL, + 0XF931F2F2EFF2C31DULL, 0XDBA8E3E3ABE34B48ULL, 0XB6B95B5B715BE22AULL, 0X0DBC88881A883492ULL, + 0X293E9A9A529AA4C8ULL, 0X4C0B262698262DBEULL, 0X64BF3232C8328DFAULL, 0X7D59B0B0FAB0E94AULL, + 0XCFF2E9E983E91B6AULL, 0X1E770F0F3C0F7833ULL, 0XB733D5D573D5E6A6ULL, 0X1DF480803A8074BAULL, + 0X6127BEBEC2BE997CULL, 0X87EBCDCD13CD26DEULL, 0X68893434D034BDE4ULL, 0X903248483D487A75ULL, + 0XE354FFFFDBFFAB24ULL, 0XF48D7A7AF57AF78FULL, 0X3D6490907A90F4EAULL, 0XBE9D5F5F615FC23EULL, + 0X403D202080201DA0ULL, 0XD00F6868BD6867D5ULL, 0X34CA1A1A681AD072ULL, 0X41B7AEAE82AE192CULL, + 0X757DB4B4EAB4C95EULL, 0XA8CE54544D549A19ULL, 0X3B7F93937693ECE5ULL, 0X442F222288220DAAULL, + 0XC86364648D6407E9ULL, 0XFF2AF1F1E3F1DB12ULL, 0XE6CC7373D173BFA2ULL, 0X248212124812905AULL, + 0X807A40401D403A5DULL, 0X1048080820084028ULL, 0X9B95C3C32BC356E8ULL, 0XC5DFECEC97EC337BULL, + 0XAB4DDBDB4BDB9690ULL, 0X5FC0A1A1BEA1611FULL, 0X07918D8D0E8D1C83ULL, 0X7AC83D3DF43DF5C9ULL, + 0X335B97976697CCF1ULL, 0X0000000000000000ULL, 0X83F9CFCF1BCF36D4ULL, 0X566E2B2BAC2B4587ULL, + 0XECE17676C57697B3ULL, 0X19E68282328264B0ULL, 0XB128D6D67FD6FEA9ULL, 0X36C31B1B6C1BD877ULL, + 0X7774B5B5EEB5C15BULL, 0X43BEAFAF86AF1129ULL, 0XD41D6A6AB56A77DFULL, 0XA0EA50505D50BA0DULL, + 0X8A5745450945124CULL, 0XFB38F3F3EBF3CB18ULL, 0X60AD3030C0309DF0ULL, 0XC3C4EFEF9BEF2B74ULL, + 0X7EDA3F3FFC3FE5C3ULL, 0XAAC755554955921CULL, 0X59DBA2A2B2A27910ULL, 0XC9E9EAEA8FEA0365ULL, + 0XCA6A656589650FECULL, 0X6903BABAD2BAB968ULL, 0X5E4A2F2FBC2F6593ULL, 0X9D8EC0C027C04EE7ULL, + 0XA160DEDE5FDEBE81ULL, 0X38FC1C1C701CE06CULL, 0XE746FDFDD3FDBB2EULL, 0X9A1F4D4D294D5264ULL, + 0X397692927292E4E0ULL, 0XEAFA7575C9758FBCULL, 0X0C3606061806301EULL, 0X09AE8A8A128A2498ULL, + 0X794BB2B2F2B2F940ULL, 0XD185E6E6BFE66359ULL, 0X1C7E0E0E380E7036ULL, 0X3EE71F1F7C1FF863ULL, + 0XC4556262956237F7ULL, 0XB53AD4D477D4EEA3ULL, 0X4D81A8A89AA82932ULL, 0X315296966296C4F4ULL, + 0XEF62F9F9C3F99B3AULL, 0X97A3C5C533C566F6ULL, 0X4A102525942535B1ULL, 0XB2AB59597959F220ULL, + 0X15D084842A8454AEULL, 0XE4C57272D572B7A7ULL, 0X72EC3939E439D5DDULL, 0X98164C4C2D4C5A61ULL, + 0XBC945E5E655ECA3BULL, 0XF09F7878FD78E785ULL, 0X70E53838E038DDD8ULL, 0X05988C8C0A8C1486ULL, + 0XBF17D1D163D1C6B2ULL, 0X57E4A5A5AEA5410BULL, 0XD9A1E2E2AFE2434DULL, 0XC24E616199612FF8ULL, + 0X7B42B3B3F6B3F145ULL, 0X42342121842115A5ULL, 0X25089C9C4A9C94D6ULL, 0X3CEE1E1E781EF066ULL, + 0X8661434311432252ULL, 0X93B1C7C73BC776FCULL, 0XE54FFCFCD7FCB32BULL, 0X0824040410042014ULL, + 0XA2E351515951B208ULL, 0X2F2599995E99BCC7ULL, 0XDA226D6DA96D4FC4ULL, 0X1A650D0D340D6839ULL, + 0XE979FAFACFFA8335ULL, 0XA369DFDF5BDFB684ULL, 0XFCA97E7EE57ED79BULL, 0X4819242490243DB4ULL, + 0X76FE3B3BEC3BC5D7ULL, 0X4B9AABAB96AB313DULL, 0X81F0CECE1FCE3ED1ULL, 0X2299111144118855ULL, + 0X03838F8F068F0C89ULL, 0X9C044E4E254E4A6BULL, 0X7366B7B7E6B7D151ULL, 0XCBE0EBEB8BEB0B60ULL, + 0X78C13C3CF03CFDCCULL, 0X1FFD81813E817CBFULL, 0X354094946A94D4FEULL, 0XF31CF7F7FBF7EB0CULL, + 0X6F18B9B9DEB9A167ULL, 0X268B13134C13985FULL, 0X58512C2CB02C7D9CULL, 0XBB05D3D36BD3D6B8ULL, + 0XD38CE7E7BBE76B5CULL, 0XDC396E6EA56E57CBULL, 0X95AAC4C437C46EF3ULL, 0X061B03030C03180FULL, + 0XACDC565645568A13ULL, 0X885E44440D441A49ULL, 0XFEA07F7FE17FDF9EULL, 0X4F88A9A99EA92137ULL, + 0X54672A2AA82A4D82ULL, 0X6B0ABBBBD6BBB16DULL, 0X9F87C1C123C146E2ULL, 0XA6F153535153A202ULL, + 0XA572DCDC57DCAE8BULL, 0X16530B0B2C0B5827ULL, 0X27019D9D4E9D9CD3ULL, 0XD82B6C6CAD6C47C1ULL, + 0X62A43131C43195F5ULL, 0XE8F37474CD7487B9ULL, 0XF115F6F6FFF6E309ULL, 0X8C4C464605460A43ULL, + 0X45A5ACAC8AAC0926ULL, 0X0FB589891E893C97ULL, 0X28B414145014A044ULL, 0XDFBAE1E1A3E15B42ULL, + 0X2CA616165816B04EULL, 0X74F73A3AE83ACDD2ULL, 0XD2066969B9696FD0ULL, 0X124109092409482DULL, + 0XE0D77070DD70A7ADULL, 0X716FB6B6E2B6D954ULL, 0XBD1ED0D067D0CEB7ULL, 0XC7D6EDED93ED3B7EULL, + 0X85E2CCCC17CC2EDBULL, 0X8468424215422A57ULL, 0X2D2C98985A98B4C2ULL, 0X55EDA4A4AAA4490EULL, + 0X50752828A0285D88ULL, 0XB8865C5C6D5CDA31ULL, 0XED6BF8F8C7F8933FULL, 0X11C28686228644A4ULL, }; const UInt64 C3[256] = { - 0x7830d818186018c0ULL, 0xaf462623238c2305ULL, 0xf991b8c6c63fc67eULL, 0x6fcdfbe8e887e813ULL, - 0xa113cb878726874cULL, 0x626d11b8b8dab8a9ULL, 0x0502090101040108ULL, 0x6e9e0d4f4f214f42ULL, - 0xee6c9b3636d836adULL, 0x0451ffa6a6a2a659ULL, 0xbdb90cd2d26fd2deULL, 0x06f70ef5f5f3f5fbULL, - 0x80f2967979f979efULL, 0xcede306f6fa16f5fULL, 0xef3f6d91917e91fcULL, 0x07a4f852525552aaULL, - 0xfdc04760609d6027ULL, 0x766535bcbccabc89ULL, 0xcd2b379b9b569bacULL, 0x8c018a8e8e028e04ULL, - 0x155bd2a3a3b6a371ULL, 0x3c186c0c0c300c60ULL, 0x8af6847b7bf17bffULL, 0xe16a803535d435b5ULL, - 0x693af51d1d741de8ULL, 0x47ddb3e0e0a7e053ULL, 0xacb321d7d77bd7f6ULL, 0xed999cc2c22fc25eULL, - 0x965c432e2eb82e6dULL, 0x7a96294b4b314b62ULL, 0x21e15dfefedffea3ULL, 0x16aed55757415782ULL, - 0x412abd15155415a8ULL, 0xb6eee87777c1779fULL, 0xeb6e923737dc37a5ULL, 0x56d79ee5e5b3e57bULL, - 0xd923139f9f469f8cULL, 0x17fd23f0f0e7f0d3ULL, 0x7f94204a4a354a6aULL, 0x95a944dada4fda9eULL, - 0x25b0a258587d58faULL, 0xca8fcfc9c903c906ULL, 0x8d527c2929a42955ULL, 0x22145a0a0a280a50ULL, - 0x4f7f50b1b1feb1e1ULL, 0x1a5dc9a0a0baa069ULL, 0xdad6146b6bb16b7fULL, 0xab17d985852e855cULL, - 0x73673cbdbdcebd81ULL, 0x34ba8f5d5d695dd2ULL, 0x5020901010401080ULL, 0x03f507f4f4f7f4f3ULL, - 0xc08bddcbcb0bcb16ULL, 0xc67cd33e3ef83eedULL, 0x110a2d0505140528ULL, 0xe6ce78676781671fULL, - 0x53d597e4e4b7e473ULL, 0xbb4e0227279c2725ULL, 0x5882734141194132ULL, 0x9d0ba78b8b168b2cULL, - 0x0153f6a7a7a6a751ULL, 0x94fab27d7de97dcfULL, 0xfb374995956e95dcULL, 0x9fad56d8d847d88eULL, - 0x30eb70fbfbcbfb8bULL, 0x71c1cdeeee9fee23ULL, 0x91f8bb7c7ced7cc7ULL, 0xe3cc716666856617ULL, - 0x8ea77bdddd53dda6ULL, 0x4b2eaf17175c17b8ULL, 0x468e454747014702ULL, 0xdc211a9e9e429e84ULL, - 0xc589d4caca0fca1eULL, 0x995a582d2db42d75ULL, 0x79632ebfbfc6bf91ULL, 0x1b0e3f07071c0738ULL, - 0x2347acadad8ead01ULL, 0x2fb4b05a5a755aeaULL, 0xb51bef838336836cULL, 0xff66b63333cc3385ULL, - 0xf2c65c636391633fULL, 0x0a04120202080210ULL, 0x384993aaaa92aa39ULL, 0xa8e2de7171d971afULL, - 0xcf8dc6c8c807c80eULL, 0x7d32d119196419c8ULL, 0x70923b4949394972ULL, 0x9aaf5fd9d943d986ULL, - 0x1df931f2f2eff2c3ULL, 0x48dba8e3e3abe34bULL, 0x2ab6b95b5b715be2ULL, 0x920dbc88881a8834ULL, - 0xc8293e9a9a529aa4ULL, 0xbe4c0b262698262dULL, 0xfa64bf3232c8328dULL, 0x4a7d59b0b0fab0e9ULL, - 0x6acff2e9e983e91bULL, 0x331e770f0f3c0f78ULL, 0xa6b733d5d573d5e6ULL, 0xba1df480803a8074ULL, - 0x7c6127bebec2be99ULL, 0xde87ebcdcd13cd26ULL, 0xe468893434d034bdULL, 0x75903248483d487aULL, - 0x24e354ffffdbffabULL, 0x8ff48d7a7af57af7ULL, 0xea3d6490907a90f4ULL, 0x3ebe9d5f5f615fc2ULL, - 0xa0403d202080201dULL, 0xd5d00f6868bd6867ULL, 0x7234ca1a1a681ad0ULL, 0x2c41b7aeae82ae19ULL, - 0x5e757db4b4eab4c9ULL, 0x19a8ce54544d549aULL, 0xe53b7f93937693ecULL, 0xaa442f222288220dULL, - 0xe9c86364648d6407ULL, 0x12ff2af1f1e3f1dbULL, 0xa2e6cc7373d173bfULL, 0x5a24821212481290ULL, - 0x5d807a40401d403aULL, 0x2810480808200840ULL, 0xe89b95c3c32bc356ULL, 0x7bc5dfecec97ec33ULL, - 0x90ab4ddbdb4bdb96ULL, 0x1f5fc0a1a1bea161ULL, 0x8307918d8d0e8d1cULL, 0xc97ac83d3df43df5ULL, - 0xf1335b97976697ccULL, 0x0000000000000000ULL, 0xd483f9cfcf1bcf36ULL, 0x87566e2b2bac2b45ULL, - 0xb3ece17676c57697ULL, 0xb019e68282328264ULL, 0xa9b128d6d67fd6feULL, 0x7736c31b1b6c1bd8ULL, - 0x5b7774b5b5eeb5c1ULL, 0x2943beafaf86af11ULL, 0xdfd41d6a6ab56a77ULL, 0x0da0ea50505d50baULL, - 0x4c8a574545094512ULL, 0x18fb38f3f3ebf3cbULL, 0xf060ad3030c0309dULL, 0x74c3c4efef9bef2bULL, - 0xc37eda3f3ffc3fe5ULL, 0x1caac75555495592ULL, 0x1059dba2a2b2a279ULL, 0x65c9e9eaea8fea03ULL, - 0xecca6a656589650fULL, 0x686903babad2bab9ULL, 0x935e4a2f2fbc2f65ULL, 0xe79d8ec0c027c04eULL, - 0x81a160dede5fdebeULL, 0x6c38fc1c1c701ce0ULL, 0x2ee746fdfdd3fdbbULL, 0x649a1f4d4d294d52ULL, - 0xe0397692927292e4ULL, 0xbceafa7575c9758fULL, 0x1e0c360606180630ULL, 0x9809ae8a8a128a24ULL, - 0x40794bb2b2f2b2f9ULL, 0x59d185e6e6bfe663ULL, 0x361c7e0e0e380e70ULL, 0x633ee71f1f7c1ff8ULL, - 0xf7c4556262956237ULL, 0xa3b53ad4d477d4eeULL, 0x324d81a8a89aa829ULL, 0xf4315296966296c4ULL, - 0x3aef62f9f9c3f99bULL, 0xf697a3c5c533c566ULL, 0xb14a102525942535ULL, 0x20b2ab59597959f2ULL, - 0xae15d084842a8454ULL, 0xa7e4c57272d572b7ULL, 0xdd72ec3939e439d5ULL, 0x6198164c4c2d4c5aULL, - 0x3bbc945e5e655ecaULL, 0x85f09f7878fd78e7ULL, 0xd870e53838e038ddULL, 0x8605988c8c0a8c14ULL, - 0xb2bf17d1d163d1c6ULL, 0x0b57e4a5a5aea541ULL, 0x4dd9a1e2e2afe243ULL, 0xf8c24e616199612fULL, - 0x457b42b3b3f6b3f1ULL, 0xa542342121842115ULL, 0xd625089c9c4a9c94ULL, 0x663cee1e1e781ef0ULL, - 0x5286614343114322ULL, 0xfc93b1c7c73bc776ULL, 0x2be54ffcfcd7fcb3ULL, 0x1408240404100420ULL, - 0x08a2e351515951b2ULL, 0xc72f2599995e99bcULL, 0xc4da226d6da96d4fULL, 0x391a650d0d340d68ULL, - 0x35e979fafacffa83ULL, 0x84a369dfdf5bdfb6ULL, 0x9bfca97e7ee57ed7ULL, 0xb44819242490243dULL, - 0xd776fe3b3bec3bc5ULL, 0x3d4b9aabab96ab31ULL, 0xd181f0cece1fce3eULL, 0x5522991111441188ULL, - 0x8903838f8f068f0cULL, 0x6b9c044e4e254e4aULL, 0x517366b7b7e6b7d1ULL, 0x60cbe0ebeb8beb0bULL, - 0xcc78c13c3cf03cfdULL, 0xbf1ffd81813e817cULL, 0xfe354094946a94d4ULL, 0x0cf31cf7f7fbf7ebULL, - 0x676f18b9b9deb9a1ULL, 0x5f268b13134c1398ULL, 0x9c58512c2cb02c7dULL, 0xb8bb05d3d36bd3d6ULL, - 0x5cd38ce7e7bbe76bULL, 0xcbdc396e6ea56e57ULL, 0xf395aac4c437c46eULL, 0x0f061b03030c0318ULL, - 0x13acdc565645568aULL, 0x49885e44440d441aULL, 0x9efea07f7fe17fdfULL, 0x374f88a9a99ea921ULL, - 0x8254672a2aa82a4dULL, 0x6d6b0abbbbd6bbb1ULL, 0xe29f87c1c123c146ULL, 0x02a6f153535153a2ULL, - 0x8ba572dcdc57dcaeULL, 0x2716530b0b2c0b58ULL, 0xd327019d9d4e9d9cULL, 0xc1d82b6c6cad6c47ULL, - 0xf562a43131c43195ULL, 0xb9e8f37474cd7487ULL, 0x09f115f6f6fff6e3ULL, 0x438c4c464605460aULL, - 0x2645a5acac8aac09ULL, 0x970fb589891e893cULL, 0x4428b414145014a0ULL, 0x42dfbae1e1a3e15bULL, - 0x4e2ca616165816b0ULL, 0xd274f73a3ae83acdULL, 0xd0d2066969b9696fULL, 0x2d12410909240948ULL, - 0xade0d77070dd70a7ULL, 0x54716fb6b6e2b6d9ULL, 0xb7bd1ed0d067d0ceULL, 0x7ec7d6eded93ed3bULL, - 0xdb85e2cccc17cc2eULL, 0x578468424215422aULL, 0xc22d2c98985a98b4ULL, 0x0e55eda4a4aaa449ULL, - 0x8850752828a0285dULL, 0x31b8865c5c6d5cdaULL, 0x3fed6bf8f8c7f893ULL, 0xa411c28686228644ULL, + 0X7830D818186018C0ULL, 0XAF462623238C2305ULL, 0XF991B8C6C63FC67EULL, 0X6FCDFBE8E887E813ULL, + 0XA113CB878726874CULL, 0X626D11B8B8DAB8A9ULL, 0X0502090101040108ULL, 0X6E9E0D4F4F214F42ULL, + 0XEE6C9B3636D836ADULL, 0X0451FFA6A6A2A659ULL, 0XBDB90CD2D26FD2DEULL, 0X06F70EF5F5F3F5FBULL, + 0X80F2967979F979EFULL, 0XCEDE306F6FA16F5FULL, 0XEF3F6D91917E91FCULL, 0X07A4F852525552AAULL, + 0XFDC04760609D6027ULL, 0X766535BCBCCABC89ULL, 0XCD2B379B9B569BACULL, 0X8C018A8E8E028E04ULL, + 0X155BD2A3A3B6A371ULL, 0X3C186C0C0C300C60ULL, 0X8AF6847B7BF17BFFULL, 0XE16A803535D435B5ULL, + 0X693AF51D1D741DE8ULL, 0X47DDB3E0E0A7E053ULL, 0XACB321D7D77BD7F6ULL, 0XED999CC2C22FC25EULL, + 0X965C432E2EB82E6DULL, 0X7A96294B4B314B62ULL, 0X21E15DFEFEDFFEA3ULL, 0X16AED55757415782ULL, + 0X412ABD15155415A8ULL, 0XB6EEE87777C1779FULL, 0XEB6E923737DC37A5ULL, 0X56D79EE5E5B3E57BULL, + 0XD923139F9F469F8CULL, 0X17FD23F0F0E7F0D3ULL, 0X7F94204A4A354A6AULL, 0X95A944DADA4FDA9EULL, + 0X25B0A258587D58FAULL, 0XCA8FCFC9C903C906ULL, 0X8D527C2929A42955ULL, 0X22145A0A0A280A50ULL, + 0X4F7F50B1B1FEB1E1ULL, 0X1A5DC9A0A0BAA069ULL, 0XDAD6146B6BB16B7FULL, 0XAB17D985852E855CULL, + 0X73673CBDBDCEBD81ULL, 0X34BA8F5D5D695DD2ULL, 0X5020901010401080ULL, 0X03F507F4F4F7F4F3ULL, + 0XC08BDDCBCB0BCB16ULL, 0XC67CD33E3EF83EEDULL, 0X110A2D0505140528ULL, 0XE6CE78676781671FULL, + 0X53D597E4E4B7E473ULL, 0XBB4E0227279C2725ULL, 0X5882734141194132ULL, 0X9D0BA78B8B168B2CULL, + 0X0153F6A7A7A6A751ULL, 0X94FAB27D7DE97DCFULL, 0XFB374995956E95DCULL, 0X9FAD56D8D847D88EULL, + 0X30EB70FBFBCBFB8BULL, 0X71C1CDEEEE9FEE23ULL, 0X91F8BB7C7CED7CC7ULL, 0XE3CC716666856617ULL, + 0X8EA77BDDDD53DDA6ULL, 0X4B2EAF17175C17B8ULL, 0X468E454747014702ULL, 0XDC211A9E9E429E84ULL, + 0XC589D4CACA0FCA1EULL, 0X995A582D2DB42D75ULL, 0X79632EBFBFC6BF91ULL, 0X1B0E3F07071C0738ULL, + 0X2347ACADAD8EAD01ULL, 0X2FB4B05A5A755AEAULL, 0XB51BEF838336836CULL, 0XFF66B63333CC3385ULL, + 0XF2C65C636391633FULL, 0X0A04120202080210ULL, 0X384993AAAA92AA39ULL, 0XA8E2DE7171D971AFULL, + 0XCF8DC6C8C807C80EULL, 0X7D32D119196419C8ULL, 0X70923B4949394972ULL, 0X9AAF5FD9D943D986ULL, + 0X1DF931F2F2EFF2C3ULL, 0X48DBA8E3E3ABE34BULL, 0X2AB6B95B5B715BE2ULL, 0X920DBC88881A8834ULL, + 0XC8293E9A9A529AA4ULL, 0XBE4C0B262698262DULL, 0XFA64BF3232C8328DULL, 0X4A7D59B0B0FAB0E9ULL, + 0X6ACFF2E9E983E91BULL, 0X331E770F0F3C0F78ULL, 0XA6B733D5D573D5E6ULL, 0XBA1DF480803A8074ULL, + 0X7C6127BEBEC2BE99ULL, 0XDE87EBCDCD13CD26ULL, 0XE468893434D034BDULL, 0X75903248483D487AULL, + 0X24E354FFFFDBFFABULL, 0X8FF48D7A7AF57AF7ULL, 0XEA3D6490907A90F4ULL, 0X3EBE9D5F5F615FC2ULL, + 0XA0403D202080201DULL, 0XD5D00F6868BD6867ULL, 0X7234CA1A1A681AD0ULL, 0X2C41B7AEAE82AE19ULL, + 0X5E757DB4B4EAB4C9ULL, 0X19A8CE54544D549AULL, 0XE53B7F93937693ECULL, 0XAA442F222288220DULL, + 0XE9C86364648D6407ULL, 0X12FF2AF1F1E3F1DBULL, 0XA2E6CC7373D173BFULL, 0X5A24821212481290ULL, + 0X5D807A40401D403AULL, 0X2810480808200840ULL, 0XE89B95C3C32BC356ULL, 0X7BC5DFECEC97EC33ULL, + 0X90AB4DDBDB4BDB96ULL, 0X1F5FC0A1A1BEA161ULL, 0X8307918D8D0E8D1CULL, 0XC97AC83D3DF43DF5ULL, + 0XF1335B97976697CCULL, 0X0000000000000000ULL, 0XD483F9CFCF1BCF36ULL, 0X87566E2B2BAC2B45ULL, + 0XB3ECE17676C57697ULL, 0XB019E68282328264ULL, 0XA9B128D6D67FD6FEULL, 0X7736C31B1B6C1BD8ULL, + 0X5B7774B5B5EEB5C1ULL, 0X2943BEAFAF86AF11ULL, 0XDFD41D6A6AB56A77ULL, 0X0DA0EA50505D50BAULL, + 0X4C8A574545094512ULL, 0X18FB38F3F3EBF3CBULL, 0XF060AD3030C0309DULL, 0X74C3C4EFEF9BEF2BULL, + 0XC37EDA3F3FFC3FE5ULL, 0X1CAAC75555495592ULL, 0X1059DBA2A2B2A279ULL, 0X65C9E9EAEA8FEA03ULL, + 0XECCA6A656589650FULL, 0X686903BABAD2BAB9ULL, 0X935E4A2F2FBC2F65ULL, 0XE79D8EC0C027C04EULL, + 0X81A160DEDE5FDEBEULL, 0X6C38FC1C1C701CE0ULL, 0X2EE746FDFDD3FDBBULL, 0X649A1F4D4D294D52ULL, + 0XE0397692927292E4ULL, 0XBCEAFA7575C9758FULL, 0X1E0C360606180630ULL, 0X9809AE8A8A128A24ULL, + 0X40794BB2B2F2B2F9ULL, 0X59D185E6E6BFE663ULL, 0X361C7E0E0E380E70ULL, 0X633EE71F1F7C1FF8ULL, + 0XF7C4556262956237ULL, 0XA3B53AD4D477D4EEULL, 0X324D81A8A89AA829ULL, 0XF4315296966296C4ULL, + 0X3AEF62F9F9C3F99BULL, 0XF697A3C5C533C566ULL, 0XB14A102525942535ULL, 0X20B2AB59597959F2ULL, + 0XAE15D084842A8454ULL, 0XA7E4C57272D572B7ULL, 0XDD72EC3939E439D5ULL, 0X6198164C4C2D4C5AULL, + 0X3BBC945E5E655ECAULL, 0X85F09F7878FD78E7ULL, 0XD870E53838E038DDULL, 0X8605988C8C0A8C14ULL, + 0XB2BF17D1D163D1C6ULL, 0X0B57E4A5A5AEA541ULL, 0X4DD9A1E2E2AFE243ULL, 0XF8C24E616199612FULL, + 0X457B42B3B3F6B3F1ULL, 0XA542342121842115ULL, 0XD625089C9C4A9C94ULL, 0X663CEE1E1E781EF0ULL, + 0X5286614343114322ULL, 0XFC93B1C7C73BC776ULL, 0X2BE54FFCFCD7FCB3ULL, 0X1408240404100420ULL, + 0X08A2E351515951B2ULL, 0XC72F2599995E99BCULL, 0XC4DA226D6DA96D4FULL, 0X391A650D0D340D68ULL, + 0X35E979FAFACFFA83ULL, 0X84A369DFDF5BDFB6ULL, 0X9BFCA97E7EE57ED7ULL, 0XB44819242490243DULL, + 0XD776FE3B3BEC3BC5ULL, 0X3D4B9AABAB96AB31ULL, 0XD181F0CECE1FCE3EULL, 0X5522991111441188ULL, + 0X8903838F8F068F0CULL, 0X6B9C044E4E254E4AULL, 0X517366B7B7E6B7D1ULL, 0X60CBE0EBEB8BEB0BULL, + 0XCC78C13C3CF03CFDULL, 0XBF1FFD81813E817CULL, 0XFE354094946A94D4ULL, 0X0CF31CF7F7FBF7EBULL, + 0X676F18B9B9DEB9A1ULL, 0X5F268B13134C1398ULL, 0X9C58512C2CB02C7DULL, 0XB8BB05D3D36BD3D6ULL, + 0X5CD38CE7E7BBE76BULL, 0XCBDC396E6EA56E57ULL, 0XF395AAC4C437C46EULL, 0X0F061B03030C0318ULL, + 0X13ACDC565645568AULL, 0X49885E44440D441AULL, 0X9EFEA07F7FE17FDFULL, 0X374F88A9A99EA921ULL, + 0X8254672A2AA82A4DULL, 0X6D6B0ABBBBD6BBB1ULL, 0XE29F87C1C123C146ULL, 0X02A6F153535153A2ULL, + 0X8BA572DCDC57DCAEULL, 0X2716530B0B2C0B58ULL, 0XD327019D9D4E9D9CULL, 0XC1D82B6C6CAD6C47ULL, + 0XF562A43131C43195ULL, 0XB9E8F37474CD7487ULL, 0X09F115F6F6FFF6E3ULL, 0X438C4C464605460AULL, + 0X2645A5ACAC8AAC09ULL, 0X970FB589891E893CULL, 0X4428B414145014A0ULL, 0X42DFBAE1E1A3E15BULL, + 0X4E2CA616165816B0ULL, 0XD274F73A3AE83ACDULL, 0XD0D2066969B9696FULL, 0X2D12410909240948ULL, + 0XADE0D77070DD70A7ULL, 0X54716FB6B6E2B6D9ULL, 0XB7BD1ED0D067D0CEULL, 0X7EC7D6EDED93ED3BULL, + 0XDB85E2CCCC17CC2EULL, 0X578468424215422AULL, 0XC22D2C98985A98B4ULL, 0X0E55EDA4A4AAA449ULL, + 0X8850752828A0285DULL, 0X31B8865C5C6D5CDAULL, 0X3FED6BF8F8C7F893ULL, 0XA411C28686228644ULL, }; const UInt64 C4[256] = { - 0xc07830d818186018ULL, 0x05af462623238c23ULL, 0x7ef991b8c6c63fc6ULL, 0x136fcdfbe8e887e8ULL, - 0x4ca113cb87872687ULL, 0xa9626d11b8b8dab8ULL, 0x0805020901010401ULL, 0x426e9e0d4f4f214fULL, - 0xadee6c9b3636d836ULL, 0x590451ffa6a6a2a6ULL, 0xdebdb90cd2d26fd2ULL, 0xfb06f70ef5f5f3f5ULL, - 0xef80f2967979f979ULL, 0x5fcede306f6fa16fULL, 0xfcef3f6d91917e91ULL, 0xaa07a4f852525552ULL, - 0x27fdc04760609d60ULL, 0x89766535bcbccabcULL, 0xaccd2b379b9b569bULL, 0x048c018a8e8e028eULL, - 0x71155bd2a3a3b6a3ULL, 0x603c186c0c0c300cULL, 0xff8af6847b7bf17bULL, 0xb5e16a803535d435ULL, - 0xe8693af51d1d741dULL, 0x5347ddb3e0e0a7e0ULL, 0xf6acb321d7d77bd7ULL, 0x5eed999cc2c22fc2ULL, - 0x6d965c432e2eb82eULL, 0x627a96294b4b314bULL, 0xa321e15dfefedffeULL, 0x8216aed557574157ULL, - 0xa8412abd15155415ULL, 0x9fb6eee87777c177ULL, 0xa5eb6e923737dc37ULL, 0x7b56d79ee5e5b3e5ULL, - 0x8cd923139f9f469fULL, 0xd317fd23f0f0e7f0ULL, 0x6a7f94204a4a354aULL, 0x9e95a944dada4fdaULL, - 0xfa25b0a258587d58ULL, 0x06ca8fcfc9c903c9ULL, 0x558d527c2929a429ULL, 0x5022145a0a0a280aULL, - 0xe14f7f50b1b1feb1ULL, 0x691a5dc9a0a0baa0ULL, 0x7fdad6146b6bb16bULL, 0x5cab17d985852e85ULL, - 0x8173673cbdbdcebdULL, 0xd234ba8f5d5d695dULL, 0x8050209010104010ULL, 0xf303f507f4f4f7f4ULL, - 0x16c08bddcbcb0bcbULL, 0xedc67cd33e3ef83eULL, 0x28110a2d05051405ULL, 0x1fe6ce7867678167ULL, - 0x7353d597e4e4b7e4ULL, 0x25bb4e0227279c27ULL, 0x3258827341411941ULL, 0x2c9d0ba78b8b168bULL, - 0x510153f6a7a7a6a7ULL, 0xcf94fab27d7de97dULL, 0xdcfb374995956e95ULL, 0x8e9fad56d8d847d8ULL, - 0x8b30eb70fbfbcbfbULL, 0x2371c1cdeeee9feeULL, 0xc791f8bb7c7ced7cULL, 0x17e3cc7166668566ULL, - 0xa68ea77bdddd53ddULL, 0xb84b2eaf17175c17ULL, 0x02468e4547470147ULL, 0x84dc211a9e9e429eULL, - 0x1ec589d4caca0fcaULL, 0x75995a582d2db42dULL, 0x9179632ebfbfc6bfULL, 0x381b0e3f07071c07ULL, - 0x012347acadad8eadULL, 0xea2fb4b05a5a755aULL, 0x6cb51bef83833683ULL, 0x85ff66b63333cc33ULL, - 0x3ff2c65c63639163ULL, 0x100a041202020802ULL, 0x39384993aaaa92aaULL, 0xafa8e2de7171d971ULL, - 0x0ecf8dc6c8c807c8ULL, 0xc87d32d119196419ULL, 0x7270923b49493949ULL, 0x869aaf5fd9d943d9ULL, - 0xc31df931f2f2eff2ULL, 0x4b48dba8e3e3abe3ULL, 0xe22ab6b95b5b715bULL, 0x34920dbc88881a88ULL, - 0xa4c8293e9a9a529aULL, 0x2dbe4c0b26269826ULL, 0x8dfa64bf3232c832ULL, 0xe94a7d59b0b0fab0ULL, - 0x1b6acff2e9e983e9ULL, 0x78331e770f0f3c0fULL, 0xe6a6b733d5d573d5ULL, 0x74ba1df480803a80ULL, - 0x997c6127bebec2beULL, 0x26de87ebcdcd13cdULL, 0xbde468893434d034ULL, 0x7a75903248483d48ULL, - 0xab24e354ffffdbffULL, 0xf78ff48d7a7af57aULL, 0xf4ea3d6490907a90ULL, 0xc23ebe9d5f5f615fULL, - 0x1da0403d20208020ULL, 0x67d5d00f6868bd68ULL, 0xd07234ca1a1a681aULL, 0x192c41b7aeae82aeULL, - 0xc95e757db4b4eab4ULL, 0x9a19a8ce54544d54ULL, 0xece53b7f93937693ULL, 0x0daa442f22228822ULL, - 0x07e9c86364648d64ULL, 0xdb12ff2af1f1e3f1ULL, 0xbfa2e6cc7373d173ULL, 0x905a248212124812ULL, - 0x3a5d807a40401d40ULL, 0x4028104808082008ULL, 0x56e89b95c3c32bc3ULL, 0x337bc5dfecec97ecULL, - 0x9690ab4ddbdb4bdbULL, 0x611f5fc0a1a1bea1ULL, 0x1c8307918d8d0e8dULL, 0xf5c97ac83d3df43dULL, - 0xccf1335b97976697ULL, 0x0000000000000000ULL, 0x36d483f9cfcf1bcfULL, 0x4587566e2b2bac2bULL, - 0x97b3ece17676c576ULL, 0x64b019e682823282ULL, 0xfea9b128d6d67fd6ULL, 0xd87736c31b1b6c1bULL, - 0xc15b7774b5b5eeb5ULL, 0x112943beafaf86afULL, 0x77dfd41d6a6ab56aULL, 0xba0da0ea50505d50ULL, - 0x124c8a5745450945ULL, 0xcb18fb38f3f3ebf3ULL, 0x9df060ad3030c030ULL, 0x2b74c3c4efef9befULL, - 0xe5c37eda3f3ffc3fULL, 0x921caac755554955ULL, 0x791059dba2a2b2a2ULL, 0x0365c9e9eaea8feaULL, - 0x0fecca6a65658965ULL, 0xb9686903babad2baULL, 0x65935e4a2f2fbc2fULL, 0x4ee79d8ec0c027c0ULL, - 0xbe81a160dede5fdeULL, 0xe06c38fc1c1c701cULL, 0xbb2ee746fdfdd3fdULL, 0x52649a1f4d4d294dULL, - 0xe4e0397692927292ULL, 0x8fbceafa7575c975ULL, 0x301e0c3606061806ULL, 0x249809ae8a8a128aULL, - 0xf940794bb2b2f2b2ULL, 0x6359d185e6e6bfe6ULL, 0x70361c7e0e0e380eULL, 0xf8633ee71f1f7c1fULL, - 0x37f7c45562629562ULL, 0xeea3b53ad4d477d4ULL, 0x29324d81a8a89aa8ULL, 0xc4f4315296966296ULL, - 0x9b3aef62f9f9c3f9ULL, 0x66f697a3c5c533c5ULL, 0x35b14a1025259425ULL, 0xf220b2ab59597959ULL, - 0x54ae15d084842a84ULL, 0xb7a7e4c57272d572ULL, 0xd5dd72ec3939e439ULL, 0x5a6198164c4c2d4cULL, - 0xca3bbc945e5e655eULL, 0xe785f09f7878fd78ULL, 0xddd870e53838e038ULL, 0x148605988c8c0a8cULL, - 0xc6b2bf17d1d163d1ULL, 0x410b57e4a5a5aea5ULL, 0x434dd9a1e2e2afe2ULL, 0x2ff8c24e61619961ULL, - 0xf1457b42b3b3f6b3ULL, 0x15a5423421218421ULL, 0x94d625089c9c4a9cULL, 0xf0663cee1e1e781eULL, - 0x2252866143431143ULL, 0x76fc93b1c7c73bc7ULL, 0xb32be54ffcfcd7fcULL, 0x2014082404041004ULL, - 0xb208a2e351515951ULL, 0xbcc72f2599995e99ULL, 0x4fc4da226d6da96dULL, 0x68391a650d0d340dULL, - 0x8335e979fafacffaULL, 0xb684a369dfdf5bdfULL, 0xd79bfca97e7ee57eULL, 0x3db4481924249024ULL, - 0xc5d776fe3b3bec3bULL, 0x313d4b9aabab96abULL, 0x3ed181f0cece1fceULL, 0x8855229911114411ULL, - 0x0c8903838f8f068fULL, 0x4a6b9c044e4e254eULL, 0xd1517366b7b7e6b7ULL, 0x0b60cbe0ebeb8bebULL, - 0xfdcc78c13c3cf03cULL, 0x7cbf1ffd81813e81ULL, 0xd4fe354094946a94ULL, 0xeb0cf31cf7f7fbf7ULL, - 0xa1676f18b9b9deb9ULL, 0x985f268b13134c13ULL, 0x7d9c58512c2cb02cULL, 0xd6b8bb05d3d36bd3ULL, - 0x6b5cd38ce7e7bbe7ULL, 0x57cbdc396e6ea56eULL, 0x6ef395aac4c437c4ULL, 0x180f061b03030c03ULL, - 0x8a13acdc56564556ULL, 0x1a49885e44440d44ULL, 0xdf9efea07f7fe17fULL, 0x21374f88a9a99ea9ULL, - 0x4d8254672a2aa82aULL, 0xb16d6b0abbbbd6bbULL, 0x46e29f87c1c123c1ULL, 0xa202a6f153535153ULL, - 0xae8ba572dcdc57dcULL, 0x582716530b0b2c0bULL, 0x9cd327019d9d4e9dULL, 0x47c1d82b6c6cad6cULL, - 0x95f562a43131c431ULL, 0x87b9e8f37474cd74ULL, 0xe309f115f6f6fff6ULL, 0x0a438c4c46460546ULL, - 0x092645a5acac8aacULL, 0x3c970fb589891e89ULL, 0xa04428b414145014ULL, 0x5b42dfbae1e1a3e1ULL, - 0xb04e2ca616165816ULL, 0xcdd274f73a3ae83aULL, 0x6fd0d2066969b969ULL, 0x482d124109092409ULL, - 0xa7ade0d77070dd70ULL, 0xd954716fb6b6e2b6ULL, 0xceb7bd1ed0d067d0ULL, 0x3b7ec7d6eded93edULL, - 0x2edb85e2cccc17ccULL, 0x2a57846842421542ULL, 0xb4c22d2c98985a98ULL, 0x490e55eda4a4aaa4ULL, - 0x5d8850752828a028ULL, 0xda31b8865c5c6d5cULL, 0x933fed6bf8f8c7f8ULL, 0x44a411c286862286ULL, + 0XC07830D818186018ULL, 0X05AF462623238C23ULL, 0X7EF991B8C6C63FC6ULL, 0X136FCDFBE8E887E8ULL, + 0X4CA113CB87872687ULL, 0XA9626D11B8B8DAB8ULL, 0X0805020901010401ULL, 0X426E9E0D4F4F214FULL, + 0XADEE6C9B3636D836ULL, 0X590451FFA6A6A2A6ULL, 0XDEBDB90CD2D26FD2ULL, 0XFB06F70EF5F5F3F5ULL, + 0XEF80F2967979F979ULL, 0X5FCEDE306F6FA16FULL, 0XFCEF3F6D91917E91ULL, 0XAA07A4F852525552ULL, + 0X27FDC04760609D60ULL, 0X89766535BCBCCABCULL, 0XACCD2B379B9B569BULL, 0X048C018A8E8E028EULL, + 0X71155BD2A3A3B6A3ULL, 0X603C186C0C0C300CULL, 0XFF8AF6847B7BF17BULL, 0XB5E16A803535D435ULL, + 0XE8693AF51D1D741DULL, 0X5347DDB3E0E0A7E0ULL, 0XF6ACB321D7D77BD7ULL, 0X5EED999CC2C22FC2ULL, + 0X6D965C432E2EB82EULL, 0X627A96294B4B314BULL, 0XA321E15DFEFEDFFEULL, 0X8216AED557574157ULL, + 0XA8412ABD15155415ULL, 0X9FB6EEE87777C177ULL, 0XA5EB6E923737DC37ULL, 0X7B56D79EE5E5B3E5ULL, + 0X8CD923139F9F469FULL, 0XD317FD23F0F0E7F0ULL, 0X6A7F94204A4A354AULL, 0X9E95A944DADA4FDAULL, + 0XFA25B0A258587D58ULL, 0X06CA8FCFC9C903C9ULL, 0X558D527C2929A429ULL, 0X5022145A0A0A280AULL, + 0XE14F7F50B1B1FEB1ULL, 0X691A5DC9A0A0BAA0ULL, 0X7FDAD6146B6BB16BULL, 0X5CAB17D985852E85ULL, + 0X8173673CBDBDCEBDULL, 0XD234BA8F5D5D695DULL, 0X8050209010104010ULL, 0XF303F507F4F4F7F4ULL, + 0X16C08BDDCBCB0BCBULL, 0XEDC67CD33E3EF83EULL, 0X28110A2D05051405ULL, 0X1FE6CE7867678167ULL, + 0X7353D597E4E4B7E4ULL, 0X25BB4E0227279C27ULL, 0X3258827341411941ULL, 0X2C9D0BA78B8B168BULL, + 0X510153F6A7A7A6A7ULL, 0XCF94FAB27D7DE97DULL, 0XDCFB374995956E95ULL, 0X8E9FAD56D8D847D8ULL, + 0X8B30EB70FBFBCBFBULL, 0X2371C1CDEEEE9FEEULL, 0XC791F8BB7C7CED7CULL, 0X17E3CC7166668566ULL, + 0XA68EA77BDDDD53DDULL, 0XB84B2EAF17175C17ULL, 0X02468E4547470147ULL, 0X84DC211A9E9E429EULL, + 0X1EC589D4CACA0FCAULL, 0X75995A582D2DB42DULL, 0X9179632EBFBFC6BFULL, 0X381B0E3F07071C07ULL, + 0X012347ACADAD8EADULL, 0XEA2FB4B05A5A755AULL, 0X6CB51BEF83833683ULL, 0X85FF66B63333CC33ULL, + 0X3FF2C65C63639163ULL, 0X100A041202020802ULL, 0X39384993AAAA92AAULL, 0XAFA8E2DE7171D971ULL, + 0X0ECF8DC6C8C807C8ULL, 0XC87D32D119196419ULL, 0X7270923B49493949ULL, 0X869AAF5FD9D943D9ULL, + 0XC31DF931F2F2EFF2ULL, 0X4B48DBA8E3E3ABE3ULL, 0XE22AB6B95B5B715BULL, 0X34920DBC88881A88ULL, + 0XA4C8293E9A9A529AULL, 0X2DBE4C0B26269826ULL, 0X8DFA64BF3232C832ULL, 0XE94A7D59B0B0FAB0ULL, + 0X1B6ACFF2E9E983E9ULL, 0X78331E770F0F3C0FULL, 0XE6A6B733D5D573D5ULL, 0X74BA1DF480803A80ULL, + 0X997C6127BEBEC2BEULL, 0X26DE87EBCDCD13CDULL, 0XBDE468893434D034ULL, 0X7A75903248483D48ULL, + 0XAB24E354FFFFDBFFULL, 0XF78FF48D7A7AF57AULL, 0XF4EA3D6490907A90ULL, 0XC23EBE9D5F5F615FULL, + 0X1DA0403D20208020ULL, 0X67D5D00F6868BD68ULL, 0XD07234CA1A1A681AULL, 0X192C41B7AEAE82AEULL, + 0XC95E757DB4B4EAB4ULL, 0X9A19A8CE54544D54ULL, 0XECE53B7F93937693ULL, 0X0DAA442F22228822ULL, + 0X07E9C86364648D64ULL, 0XDB12FF2AF1F1E3F1ULL, 0XBFA2E6CC7373D173ULL, 0X905A248212124812ULL, + 0X3A5D807A40401D40ULL, 0X4028104808082008ULL, 0X56E89B95C3C32BC3ULL, 0X337BC5DFECEC97ECULL, + 0X9690AB4DDBDB4BDBULL, 0X611F5FC0A1A1BEA1ULL, 0X1C8307918D8D0E8DULL, 0XF5C97AC83D3DF43DULL, + 0XCCF1335B97976697ULL, 0X0000000000000000ULL, 0X36D483F9CFCF1BCFULL, 0X4587566E2B2BAC2BULL, + 0X97B3ECE17676C576ULL, 0X64B019E682823282ULL, 0XFEA9B128D6D67FD6ULL, 0XD87736C31B1B6C1BULL, + 0XC15B7774B5B5EEB5ULL, 0X112943BEAFAF86AFULL, 0X77DFD41D6A6AB56AULL, 0XBA0DA0EA50505D50ULL, + 0X124C8A5745450945ULL, 0XCB18FB38F3F3EBF3ULL, 0X9DF060AD3030C030ULL, 0X2B74C3C4EFEF9BEFULL, + 0XE5C37EDA3F3FFC3FULL, 0X921CAAC755554955ULL, 0X791059DBA2A2B2A2ULL, 0X0365C9E9EAEA8FEAULL, + 0X0FECCA6A65658965ULL, 0XB9686903BABAD2BAULL, 0X65935E4A2F2FBC2FULL, 0X4EE79D8EC0C027C0ULL, + 0XBE81A160DEDE5FDEULL, 0XE06C38FC1C1C701CULL, 0XBB2EE746FDFDD3FDULL, 0X52649A1F4D4D294DULL, + 0XE4E0397692927292ULL, 0X8FBCEAFA7575C975ULL, 0X301E0C3606061806ULL, 0X249809AE8A8A128AULL, + 0XF940794BB2B2F2B2ULL, 0X6359D185E6E6BFE6ULL, 0X70361C7E0E0E380EULL, 0XF8633EE71F1F7C1FULL, + 0X37F7C45562629562ULL, 0XEEA3B53AD4D477D4ULL, 0X29324D81A8A89AA8ULL, 0XC4F4315296966296ULL, + 0X9B3AEF62F9F9C3F9ULL, 0X66F697A3C5C533C5ULL, 0X35B14A1025259425ULL, 0XF220B2AB59597959ULL, + 0X54AE15D084842A84ULL, 0XB7A7E4C57272D572ULL, 0XD5DD72EC3939E439ULL, 0X5A6198164C4C2D4CULL, + 0XCA3BBC945E5E655EULL, 0XE785F09F7878FD78ULL, 0XDDD870E53838E038ULL, 0X148605988C8C0A8CULL, + 0XC6B2BF17D1D163D1ULL, 0X410B57E4A5A5AEA5ULL, 0X434DD9A1E2E2AFE2ULL, 0X2FF8C24E61619961ULL, + 0XF1457B42B3B3F6B3ULL, 0X15A5423421218421ULL, 0X94D625089C9C4A9CULL, 0XF0663CEE1E1E781EULL, + 0X2252866143431143ULL, 0X76FC93B1C7C73BC7ULL, 0XB32BE54FFCFCD7FCULL, 0X2014082404041004ULL, + 0XB208A2E351515951ULL, 0XBCC72F2599995E99ULL, 0X4FC4DA226D6DA96DULL, 0X68391A650D0D340DULL, + 0X8335E979FAFACFFAULL, 0XB684A369DFDF5BDFULL, 0XD79BFCA97E7EE57EULL, 0X3DB4481924249024ULL, + 0XC5D776FE3B3BEC3BULL, 0X313D4B9AABAB96ABULL, 0X3ED181F0CECE1FCEULL, 0X8855229911114411ULL, + 0X0C8903838F8F068FULL, 0X4A6B9C044E4E254EULL, 0XD1517366B7B7E6B7ULL, 0X0B60CBE0EBEB8BEBULL, + 0XFDCC78C13C3CF03CULL, 0X7CBF1FFD81813E81ULL, 0XD4FE354094946A94ULL, 0XEB0CF31CF7F7FBF7ULL, + 0XA1676F18B9B9DEB9ULL, 0X985F268B13134C13ULL, 0X7D9C58512C2CB02CULL, 0XD6B8BB05D3D36BD3ULL, + 0X6B5CD38CE7E7BBE7ULL, 0X57CBDC396E6EA56EULL, 0X6EF395AAC4C437C4ULL, 0X180F061B03030C03ULL, + 0X8A13ACDC56564556ULL, 0X1A49885E44440D44ULL, 0XDF9EFEA07F7FE17FULL, 0X21374F88A9A99EA9ULL, + 0X4D8254672A2AA82AULL, 0XB16D6B0ABBBBD6BBULL, 0X46E29F87C1C123C1ULL, 0XA202A6F153535153ULL, + 0XAE8BA572DCDC57DCULL, 0X582716530B0B2C0BULL, 0X9CD327019D9D4E9DULL, 0X47C1D82B6C6CAD6CULL, + 0X95F562A43131C431ULL, 0X87B9E8F37474CD74ULL, 0XE309F115F6F6FFF6ULL, 0X0A438C4C46460546ULL, + 0X092645A5ACAC8AACULL, 0X3C970FB589891E89ULL, 0XA04428B414145014ULL, 0X5B42DFBAE1E1A3E1ULL, + 0XB04E2CA616165816ULL, 0XCDD274F73A3AE83AULL, 0X6FD0D2066969B969ULL, 0X482D124109092409ULL, + 0XA7ADE0D77070DD70ULL, 0XD954716FB6B6E2B6ULL, 0XCEB7BD1ED0D067D0ULL, 0X3B7EC7D6EDED93EDULL, + 0X2EDB85E2CCCC17CCULL, 0X2A57846842421542ULL, 0XB4C22D2C98985A98ULL, 0X490E55EDA4A4AAA4ULL, + 0X5D8850752828A028ULL, 0XDA31B8865C5C6D5CULL, 0X933FED6BF8F8C7F8ULL, 0X44A411C286862286ULL, }; const UInt64 C5[256] = { - 0x18c07830d8181860ULL, 0x2305af462623238cULL, 0xc67ef991b8c6c63fULL, 0xe8136fcdfbe8e887ULL, - 0x874ca113cb878726ULL, 0xb8a9626d11b8b8daULL, 0x0108050209010104ULL, 0x4f426e9e0d4f4f21ULL, - 0x36adee6c9b3636d8ULL, 0xa6590451ffa6a6a2ULL, 0xd2debdb90cd2d26fULL, 0xf5fb06f70ef5f5f3ULL, - 0x79ef80f2967979f9ULL, 0x6f5fcede306f6fa1ULL, 0x91fcef3f6d91917eULL, 0x52aa07a4f8525255ULL, - 0x6027fdc04760609dULL, 0xbc89766535bcbccaULL, 0x9baccd2b379b9b56ULL, 0x8e048c018a8e8e02ULL, - 0xa371155bd2a3a3b6ULL, 0x0c603c186c0c0c30ULL, 0x7bff8af6847b7bf1ULL, 0x35b5e16a803535d4ULL, - 0x1de8693af51d1d74ULL, 0xe05347ddb3e0e0a7ULL, 0xd7f6acb321d7d77bULL, 0xc25eed999cc2c22fULL, - 0x2e6d965c432e2eb8ULL, 0x4b627a96294b4b31ULL, 0xfea321e15dfefedfULL, 0x578216aed5575741ULL, - 0x15a8412abd151554ULL, 0x779fb6eee87777c1ULL, 0x37a5eb6e923737dcULL, 0xe57b56d79ee5e5b3ULL, - 0x9f8cd923139f9f46ULL, 0xf0d317fd23f0f0e7ULL, 0x4a6a7f94204a4a35ULL, 0xda9e95a944dada4fULL, - 0x58fa25b0a258587dULL, 0xc906ca8fcfc9c903ULL, 0x29558d527c2929a4ULL, 0x0a5022145a0a0a28ULL, - 0xb1e14f7f50b1b1feULL, 0xa0691a5dc9a0a0baULL, 0x6b7fdad6146b6bb1ULL, 0x855cab17d985852eULL, - 0xbd8173673cbdbdceULL, 0x5dd234ba8f5d5d69ULL, 0x1080502090101040ULL, 0xf4f303f507f4f4f7ULL, - 0xcb16c08bddcbcb0bULL, 0x3eedc67cd33e3ef8ULL, 0x0528110a2d050514ULL, 0x671fe6ce78676781ULL, - 0xe47353d597e4e4b7ULL, 0x2725bb4e0227279cULL, 0x4132588273414119ULL, 0x8b2c9d0ba78b8b16ULL, - 0xa7510153f6a7a7a6ULL, 0x7dcf94fab27d7de9ULL, 0x95dcfb374995956eULL, 0xd88e9fad56d8d847ULL, - 0xfb8b30eb70fbfbcbULL, 0xee2371c1cdeeee9fULL, 0x7cc791f8bb7c7cedULL, 0x6617e3cc71666685ULL, - 0xdda68ea77bdddd53ULL, 0x17b84b2eaf17175cULL, 0x4702468e45474701ULL, 0x9e84dc211a9e9e42ULL, - 0xca1ec589d4caca0fULL, 0x2d75995a582d2db4ULL, 0xbf9179632ebfbfc6ULL, 0x07381b0e3f07071cULL, - 0xad012347acadad8eULL, 0x5aea2fb4b05a5a75ULL, 0x836cb51bef838336ULL, 0x3385ff66b63333ccULL, - 0x633ff2c65c636391ULL, 0x02100a0412020208ULL, 0xaa39384993aaaa92ULL, 0x71afa8e2de7171d9ULL, - 0xc80ecf8dc6c8c807ULL, 0x19c87d32d1191964ULL, 0x497270923b494939ULL, 0xd9869aaf5fd9d943ULL, - 0xf2c31df931f2f2efULL, 0xe34b48dba8e3e3abULL, 0x5be22ab6b95b5b71ULL, 0x8834920dbc88881aULL, - 0x9aa4c8293e9a9a52ULL, 0x262dbe4c0b262698ULL, 0x328dfa64bf3232c8ULL, 0xb0e94a7d59b0b0faULL, - 0xe91b6acff2e9e983ULL, 0x0f78331e770f0f3cULL, 0xd5e6a6b733d5d573ULL, 0x8074ba1df480803aULL, - 0xbe997c6127bebec2ULL, 0xcd26de87ebcdcd13ULL, 0x34bde468893434d0ULL, 0x487a75903248483dULL, - 0xffab24e354ffffdbULL, 0x7af78ff48d7a7af5ULL, 0x90f4ea3d6490907aULL, 0x5fc23ebe9d5f5f61ULL, - 0x201da0403d202080ULL, 0x6867d5d00f6868bdULL, 0x1ad07234ca1a1a68ULL, 0xae192c41b7aeae82ULL, - 0xb4c95e757db4b4eaULL, 0x549a19a8ce54544dULL, 0x93ece53b7f939376ULL, 0x220daa442f222288ULL, - 0x6407e9c86364648dULL, 0xf1db12ff2af1f1e3ULL, 0x73bfa2e6cc7373d1ULL, 0x12905a2482121248ULL, - 0x403a5d807a40401dULL, 0x0840281048080820ULL, 0xc356e89b95c3c32bULL, 0xec337bc5dfecec97ULL, - 0xdb9690ab4ddbdb4bULL, 0xa1611f5fc0a1a1beULL, 0x8d1c8307918d8d0eULL, 0x3df5c97ac83d3df4ULL, - 0x97ccf1335b979766ULL, 0x0000000000000000ULL, 0xcf36d483f9cfcf1bULL, 0x2b4587566e2b2bacULL, - 0x7697b3ece17676c5ULL, 0x8264b019e6828232ULL, 0xd6fea9b128d6d67fULL, 0x1bd87736c31b1b6cULL, - 0xb5c15b7774b5b5eeULL, 0xaf112943beafaf86ULL, 0x6a77dfd41d6a6ab5ULL, 0x50ba0da0ea50505dULL, - 0x45124c8a57454509ULL, 0xf3cb18fb38f3f3ebULL, 0x309df060ad3030c0ULL, 0xef2b74c3c4efef9bULL, - 0x3fe5c37eda3f3ffcULL, 0x55921caac7555549ULL, 0xa2791059dba2a2b2ULL, 0xea0365c9e9eaea8fULL, - 0x650fecca6a656589ULL, 0xbab9686903babad2ULL, 0x2f65935e4a2f2fbcULL, 0xc04ee79d8ec0c027ULL, - 0xdebe81a160dede5fULL, 0x1ce06c38fc1c1c70ULL, 0xfdbb2ee746fdfdd3ULL, 0x4d52649a1f4d4d29ULL, - 0x92e4e03976929272ULL, 0x758fbceafa7575c9ULL, 0x06301e0c36060618ULL, 0x8a249809ae8a8a12ULL, - 0xb2f940794bb2b2f2ULL, 0xe66359d185e6e6bfULL, 0x0e70361c7e0e0e38ULL, 0x1ff8633ee71f1f7cULL, - 0x6237f7c455626295ULL, 0xd4eea3b53ad4d477ULL, 0xa829324d81a8a89aULL, 0x96c4f43152969662ULL, - 0xf99b3aef62f9f9c3ULL, 0xc566f697a3c5c533ULL, 0x2535b14a10252594ULL, 0x59f220b2ab595979ULL, - 0x8454ae15d084842aULL, 0x72b7a7e4c57272d5ULL, 0x39d5dd72ec3939e4ULL, 0x4c5a6198164c4c2dULL, - 0x5eca3bbc945e5e65ULL, 0x78e785f09f7878fdULL, 0x38ddd870e53838e0ULL, 0x8c148605988c8c0aULL, - 0xd1c6b2bf17d1d163ULL, 0xa5410b57e4a5a5aeULL, 0xe2434dd9a1e2e2afULL, 0x612ff8c24e616199ULL, - 0xb3f1457b42b3b3f6ULL, 0x2115a54234212184ULL, 0x9c94d625089c9c4aULL, 0x1ef0663cee1e1e78ULL, - 0x4322528661434311ULL, 0xc776fc93b1c7c73bULL, 0xfcb32be54ffcfcd7ULL, 0x0420140824040410ULL, - 0x51b208a2e3515159ULL, 0x99bcc72f2599995eULL, 0x6d4fc4da226d6da9ULL, 0x0d68391a650d0d34ULL, - 0xfa8335e979fafacfULL, 0xdfb684a369dfdf5bULL, 0x7ed79bfca97e7ee5ULL, 0x243db44819242490ULL, - 0x3bc5d776fe3b3becULL, 0xab313d4b9aabab96ULL, 0xce3ed181f0cece1fULL, 0x1188552299111144ULL, - 0x8f0c8903838f8f06ULL, 0x4e4a6b9c044e4e25ULL, 0xb7d1517366b7b7e6ULL, 0xeb0b60cbe0ebeb8bULL, - 0x3cfdcc78c13c3cf0ULL, 0x817cbf1ffd81813eULL, 0x94d4fe354094946aULL, 0xf7eb0cf31cf7f7fbULL, - 0xb9a1676f18b9b9deULL, 0x13985f268b13134cULL, 0x2c7d9c58512c2cb0ULL, 0xd3d6b8bb05d3d36bULL, - 0xe76b5cd38ce7e7bbULL, 0x6e57cbdc396e6ea5ULL, 0xc46ef395aac4c437ULL, 0x03180f061b03030cULL, - 0x568a13acdc565645ULL, 0x441a49885e44440dULL, 0x7fdf9efea07f7fe1ULL, 0xa921374f88a9a99eULL, - 0x2a4d8254672a2aa8ULL, 0xbbb16d6b0abbbbd6ULL, 0xc146e29f87c1c123ULL, 0x53a202a6f1535351ULL, - 0xdcae8ba572dcdc57ULL, 0x0b582716530b0b2cULL, 0x9d9cd327019d9d4eULL, 0x6c47c1d82b6c6cadULL, - 0x3195f562a43131c4ULL, 0x7487b9e8f37474cdULL, 0xf6e309f115f6f6ffULL, 0x460a438c4c464605ULL, - 0xac092645a5acac8aULL, 0x893c970fb589891eULL, 0x14a04428b4141450ULL, 0xe15b42dfbae1e1a3ULL, - 0x16b04e2ca6161658ULL, 0x3acdd274f73a3ae8ULL, 0x696fd0d2066969b9ULL, 0x09482d1241090924ULL, - 0x70a7ade0d77070ddULL, 0xb6d954716fb6b6e2ULL, 0xd0ceb7bd1ed0d067ULL, 0xed3b7ec7d6eded93ULL, - 0xcc2edb85e2cccc17ULL, 0x422a578468424215ULL, 0x98b4c22d2c98985aULL, 0xa4490e55eda4a4aaULL, - 0x285d8850752828a0ULL, 0x5cda31b8865c5c6dULL, 0xf8933fed6bf8f8c7ULL, 0x8644a411c2868622ULL, + 0X18C07830D8181860ULL, 0X2305AF462623238CULL, 0XC67EF991B8C6C63FULL, 0XE8136FCDFBE8E887ULL, + 0X874CA113CB878726ULL, 0XB8A9626D11B8B8DAULL, 0X0108050209010104ULL, 0X4F426E9E0D4F4F21ULL, + 0X36ADEE6C9B3636D8ULL, 0XA6590451FFA6A6A2ULL, 0XD2DEBDB90CD2D26FULL, 0XF5FB06F70EF5F5F3ULL, + 0X79EF80F2967979F9ULL, 0X6F5FCEDE306F6FA1ULL, 0X91FCEF3F6D91917EULL, 0X52AA07A4F8525255ULL, + 0X6027FDC04760609DULL, 0XBC89766535BCBCCAULL, 0X9BACCD2B379B9B56ULL, 0X8E048C018A8E8E02ULL, + 0XA371155BD2A3A3B6ULL, 0X0C603C186C0C0C30ULL, 0X7BFF8AF6847B7BF1ULL, 0X35B5E16A803535D4ULL, + 0X1DE8693AF51D1D74ULL, 0XE05347DDB3E0E0A7ULL, 0XD7F6ACB321D7D77BULL, 0XC25EED999CC2C22FULL, + 0X2E6D965C432E2EB8ULL, 0X4B627A96294B4B31ULL, 0XFEA321E15DFEFEDFULL, 0X578216AED5575741ULL, + 0X15A8412ABD151554ULL, 0X779FB6EEE87777C1ULL, 0X37A5EB6E923737DCULL, 0XE57B56D79EE5E5B3ULL, + 0X9F8CD923139F9F46ULL, 0XF0D317FD23F0F0E7ULL, 0X4A6A7F94204A4A35ULL, 0XDA9E95A944DADA4FULL, + 0X58FA25B0A258587DULL, 0XC906CA8FCFC9C903ULL, 0X29558D527C2929A4ULL, 0X0A5022145A0A0A28ULL, + 0XB1E14F7F50B1B1FEULL, 0XA0691A5DC9A0A0BAULL, 0X6B7FDAD6146B6BB1ULL, 0X855CAB17D985852EULL, + 0XBD8173673CBDBDCEULL, 0X5DD234BA8F5D5D69ULL, 0X1080502090101040ULL, 0XF4F303F507F4F4F7ULL, + 0XCB16C08BDDCBCB0BULL, 0X3EEDC67CD33E3EF8ULL, 0X0528110A2D050514ULL, 0X671FE6CE78676781ULL, + 0XE47353D597E4E4B7ULL, 0X2725BB4E0227279CULL, 0X4132588273414119ULL, 0X8B2C9D0BA78B8B16ULL, + 0XA7510153F6A7A7A6ULL, 0X7DCF94FAB27D7DE9ULL, 0X95DCFB374995956EULL, 0XD88E9FAD56D8D847ULL, + 0XFB8B30EB70FBFBCBULL, 0XEE2371C1CDEEEE9FULL, 0X7CC791F8BB7C7CEDULL, 0X6617E3CC71666685ULL, + 0XDDA68EA77BDDDD53ULL, 0X17B84B2EAF17175CULL, 0X4702468E45474701ULL, 0X9E84DC211A9E9E42ULL, + 0XCA1EC589D4CACA0FULL, 0X2D75995A582D2DB4ULL, 0XBF9179632EBFBFC6ULL, 0X07381B0E3F07071CULL, + 0XAD012347ACADAD8EULL, 0X5AEA2FB4B05A5A75ULL, 0X836CB51BEF838336ULL, 0X3385FF66B63333CCULL, + 0X633FF2C65C636391ULL, 0X02100A0412020208ULL, 0XAA39384993AAAA92ULL, 0X71AFA8E2DE7171D9ULL, + 0XC80ECF8DC6C8C807ULL, 0X19C87D32D1191964ULL, 0X497270923B494939ULL, 0XD9869AAF5FD9D943ULL, + 0XF2C31DF931F2F2EFULL, 0XE34B48DBA8E3E3ABULL, 0X5BE22AB6B95B5B71ULL, 0X8834920DBC88881AULL, + 0X9AA4C8293E9A9A52ULL, 0X262DBE4C0B262698ULL, 0X328DFA64BF3232C8ULL, 0XB0E94A7D59B0B0FAULL, + 0XE91B6ACFF2E9E983ULL, 0X0F78331E770F0F3CULL, 0XD5E6A6B733D5D573ULL, 0X8074BA1DF480803AULL, + 0XBE997C6127BEBEC2ULL, 0XCD26DE87EBCDCD13ULL, 0X34BDE468893434D0ULL, 0X487A75903248483DULL, + 0XFFAB24E354FFFFDBULL, 0X7AF78FF48D7A7AF5ULL, 0X90F4EA3D6490907AULL, 0X5FC23EBE9D5F5F61ULL, + 0X201DA0403D202080ULL, 0X6867D5D00F6868BDULL, 0X1AD07234CA1A1A68ULL, 0XAE192C41B7AEAE82ULL, + 0XB4C95E757DB4B4EAULL, 0X549A19A8CE54544DULL, 0X93ECE53B7F939376ULL, 0X220DAA442F222288ULL, + 0X6407E9C86364648DULL, 0XF1DB12FF2AF1F1E3ULL, 0X73BFA2E6CC7373D1ULL, 0X12905A2482121248ULL, + 0X403A5D807A40401DULL, 0X0840281048080820ULL, 0XC356E89B95C3C32BULL, 0XEC337BC5DFECEC97ULL, + 0XDB9690AB4DDBDB4BULL, 0XA1611F5FC0A1A1BEULL, 0X8D1C8307918D8D0EULL, 0X3DF5C97AC83D3DF4ULL, + 0X97CCF1335B979766ULL, 0X0000000000000000ULL, 0XCF36D483F9CFCF1BULL, 0X2B4587566E2B2BACULL, + 0X7697B3ECE17676C5ULL, 0X8264B019E6828232ULL, 0XD6FEA9B128D6D67FULL, 0X1BD87736C31B1B6CULL, + 0XB5C15B7774B5B5EEULL, 0XAF112943BEAFAF86ULL, 0X6A77DFD41D6A6AB5ULL, 0X50BA0DA0EA50505DULL, + 0X45124C8A57454509ULL, 0XF3CB18FB38F3F3EBULL, 0X309DF060AD3030C0ULL, 0XEF2B74C3C4EFEF9BULL, + 0X3FE5C37EDA3F3FFCULL, 0X55921CAAC7555549ULL, 0XA2791059DBA2A2B2ULL, 0XEA0365C9E9EAEA8FULL, + 0X650FECCA6A656589ULL, 0XBAB9686903BABAD2ULL, 0X2F65935E4A2F2FBCULL, 0XC04EE79D8EC0C027ULL, + 0XDEBE81A160DEDE5FULL, 0X1CE06C38FC1C1C70ULL, 0XFDBB2EE746FDFDD3ULL, 0X4D52649A1F4D4D29ULL, + 0X92E4E03976929272ULL, 0X758FBCEAFA7575C9ULL, 0X06301E0C36060618ULL, 0X8A249809AE8A8A12ULL, + 0XB2F940794BB2B2F2ULL, 0XE66359D185E6E6BFULL, 0X0E70361C7E0E0E38ULL, 0X1FF8633EE71F1F7CULL, + 0X6237F7C455626295ULL, 0XD4EEA3B53AD4D477ULL, 0XA829324D81A8A89AULL, 0X96C4F43152969662ULL, + 0XF99B3AEF62F9F9C3ULL, 0XC566F697A3C5C533ULL, 0X2535B14A10252594ULL, 0X59F220B2AB595979ULL, + 0X8454AE15D084842AULL, 0X72B7A7E4C57272D5ULL, 0X39D5DD72EC3939E4ULL, 0X4C5A6198164C4C2DULL, + 0X5ECA3BBC945E5E65ULL, 0X78E785F09F7878FDULL, 0X38DDD870E53838E0ULL, 0X8C148605988C8C0AULL, + 0XD1C6B2BF17D1D163ULL, 0XA5410B57E4A5A5AEULL, 0XE2434DD9A1E2E2AFULL, 0X612FF8C24E616199ULL, + 0XB3F1457B42B3B3F6ULL, 0X2115A54234212184ULL, 0X9C94D625089C9C4AULL, 0X1EF0663CEE1E1E78ULL, + 0X4322528661434311ULL, 0XC776FC93B1C7C73BULL, 0XFCB32BE54FFCFCD7ULL, 0X0420140824040410ULL, + 0X51B208A2E3515159ULL, 0X99BCC72F2599995EULL, 0X6D4FC4DA226D6DA9ULL, 0X0D68391A650D0D34ULL, + 0XFA8335E979FAFACFULL, 0XDFB684A369DFDF5BULL, 0X7ED79BFCA97E7EE5ULL, 0X243DB44819242490ULL, + 0X3BC5D776FE3B3BECULL, 0XAB313D4B9AABAB96ULL, 0XCE3ED181F0CECE1FULL, 0X1188552299111144ULL, + 0X8F0C8903838F8F06ULL, 0X4E4A6B9C044E4E25ULL, 0XB7D1517366B7B7E6ULL, 0XEB0B60CBE0EBEB8BULL, + 0X3CFDCC78C13C3CF0ULL, 0X817CBF1FFD81813EULL, 0X94D4FE354094946AULL, 0XF7EB0CF31CF7F7FBULL, + 0XB9A1676F18B9B9DEULL, 0X13985F268B13134CULL, 0X2C7D9C58512C2CB0ULL, 0XD3D6B8BB05D3D36BULL, + 0XE76B5CD38CE7E7BBULL, 0X6E57CBDC396E6EA5ULL, 0XC46EF395AAC4C437ULL, 0X03180F061B03030CULL, + 0X568A13ACDC565645ULL, 0X441A49885E44440DULL, 0X7FDF9EFEA07F7FE1ULL, 0XA921374F88A9A99EULL, + 0X2A4D8254672A2AA8ULL, 0XBBB16D6B0ABBBBD6ULL, 0XC146E29F87C1C123ULL, 0X53A202A6F1535351ULL, + 0XDCAE8BA572DCDC57ULL, 0X0B582716530B0B2CULL, 0X9D9CD327019D9D4EULL, 0X6C47C1D82B6C6CADULL, + 0X3195F562A43131C4ULL, 0X7487B9E8F37474CDULL, 0XF6E309F115F6F6FFULL, 0X460A438C4C464605ULL, + 0XAC092645A5ACAC8AULL, 0X893C970FB589891EULL, 0X14A04428B4141450ULL, 0XE15B42DFBAE1E1A3ULL, + 0X16B04E2CA6161658ULL, 0X3ACDD274F73A3AE8ULL, 0X696FD0D2066969B9ULL, 0X09482D1241090924ULL, + 0X70A7ADE0D77070DDULL, 0XB6D954716FB6B6E2ULL, 0XD0CEB7BD1ED0D067ULL, 0XED3B7EC7D6EDED93ULL, + 0XCC2EDB85E2CCCC17ULL, 0X422A578468424215ULL, 0X98B4C22D2C98985AULL, 0XA4490E55EDA4A4AAULL, + 0X285D8850752828A0ULL, 0X5CDA31B8865C5C6DULL, 0XF8933FED6BF8F8C7ULL, 0X8644A411C2868622ULL, }; const UInt64 C6[256] = { - 0x6018c07830d81818ULL, 0x8c2305af46262323ULL, 0x3fc67ef991b8c6c6ULL, 0x87e8136fcdfbe8e8ULL, - 0x26874ca113cb8787ULL, 0xdab8a9626d11b8b8ULL, 0x0401080502090101ULL, 0x214f426e9e0d4f4fULL, - 0xd836adee6c9b3636ULL, 0xa2a6590451ffa6a6ULL, 0x6fd2debdb90cd2d2ULL, 0xf3f5fb06f70ef5f5ULL, - 0xf979ef80f2967979ULL, 0xa16f5fcede306f6fULL, 0x7e91fcef3f6d9191ULL, 0x5552aa07a4f85252ULL, - 0x9d6027fdc0476060ULL, 0xcabc89766535bcbcULL, 0x569baccd2b379b9bULL, 0x028e048c018a8e8eULL, - 0xb6a371155bd2a3a3ULL, 0x300c603c186c0c0cULL, 0xf17bff8af6847b7bULL, 0xd435b5e16a803535ULL, - 0x741de8693af51d1dULL, 0xa7e05347ddb3e0e0ULL, 0x7bd7f6acb321d7d7ULL, 0x2fc25eed999cc2c2ULL, - 0xb82e6d965c432e2eULL, 0x314b627a96294b4bULL, 0xdffea321e15dfefeULL, 0x41578216aed55757ULL, - 0x5415a8412abd1515ULL, 0xc1779fb6eee87777ULL, 0xdc37a5eb6e923737ULL, 0xb3e57b56d79ee5e5ULL, - 0x469f8cd923139f9fULL, 0xe7f0d317fd23f0f0ULL, 0x354a6a7f94204a4aULL, 0x4fda9e95a944dadaULL, - 0x7d58fa25b0a25858ULL, 0x03c906ca8fcfc9c9ULL, 0xa429558d527c2929ULL, 0x280a5022145a0a0aULL, - 0xfeb1e14f7f50b1b1ULL, 0xbaa0691a5dc9a0a0ULL, 0xb16b7fdad6146b6bULL, 0x2e855cab17d98585ULL, - 0xcebd8173673cbdbdULL, 0x695dd234ba8f5d5dULL, 0x4010805020901010ULL, 0xf7f4f303f507f4f4ULL, - 0x0bcb16c08bddcbcbULL, 0xf83eedc67cd33e3eULL, 0x140528110a2d0505ULL, 0x81671fe6ce786767ULL, - 0xb7e47353d597e4e4ULL, 0x9c2725bb4e022727ULL, 0x1941325882734141ULL, 0x168b2c9d0ba78b8bULL, - 0xa6a7510153f6a7a7ULL, 0xe97dcf94fab27d7dULL, 0x6e95dcfb37499595ULL, 0x47d88e9fad56d8d8ULL, - 0xcbfb8b30eb70fbfbULL, 0x9fee2371c1cdeeeeULL, 0xed7cc791f8bb7c7cULL, 0x856617e3cc716666ULL, - 0x53dda68ea77bddddULL, 0x5c17b84b2eaf1717ULL, 0x014702468e454747ULL, 0x429e84dc211a9e9eULL, - 0x0fca1ec589d4cacaULL, 0xb42d75995a582d2dULL, 0xc6bf9179632ebfbfULL, 0x1c07381b0e3f0707ULL, - 0x8ead012347acadadULL, 0x755aea2fb4b05a5aULL, 0x36836cb51bef8383ULL, 0xcc3385ff66b63333ULL, - 0x91633ff2c65c6363ULL, 0x0802100a04120202ULL, 0x92aa39384993aaaaULL, 0xd971afa8e2de7171ULL, - 0x07c80ecf8dc6c8c8ULL, 0x6419c87d32d11919ULL, 0x39497270923b4949ULL, 0x43d9869aaf5fd9d9ULL, - 0xeff2c31df931f2f2ULL, 0xabe34b48dba8e3e3ULL, 0x715be22ab6b95b5bULL, 0x1a8834920dbc8888ULL, - 0x529aa4c8293e9a9aULL, 0x98262dbe4c0b2626ULL, 0xc8328dfa64bf3232ULL, 0xfab0e94a7d59b0b0ULL, - 0x83e91b6acff2e9e9ULL, 0x3c0f78331e770f0fULL, 0x73d5e6a6b733d5d5ULL, 0x3a8074ba1df48080ULL, - 0xc2be997c6127bebeULL, 0x13cd26de87ebcdcdULL, 0xd034bde468893434ULL, 0x3d487a7590324848ULL, - 0xdbffab24e354ffffULL, 0xf57af78ff48d7a7aULL, 0x7a90f4ea3d649090ULL, 0x615fc23ebe9d5f5fULL, - 0x80201da0403d2020ULL, 0xbd6867d5d00f6868ULL, 0x681ad07234ca1a1aULL, 0x82ae192c41b7aeaeULL, - 0xeab4c95e757db4b4ULL, 0x4d549a19a8ce5454ULL, 0x7693ece53b7f9393ULL, 0x88220daa442f2222ULL, - 0x8d6407e9c8636464ULL, 0xe3f1db12ff2af1f1ULL, 0xd173bfa2e6cc7373ULL, 0x4812905a24821212ULL, - 0x1d403a5d807a4040ULL, 0x2008402810480808ULL, 0x2bc356e89b95c3c3ULL, 0x97ec337bc5dfececULL, - 0x4bdb9690ab4ddbdbULL, 0xbea1611f5fc0a1a1ULL, 0x0e8d1c8307918d8dULL, 0xf43df5c97ac83d3dULL, - 0x6697ccf1335b9797ULL, 0x0000000000000000ULL, 0x1bcf36d483f9cfcfULL, 0xac2b4587566e2b2bULL, - 0xc57697b3ece17676ULL, 0x328264b019e68282ULL, 0x7fd6fea9b128d6d6ULL, 0x6c1bd87736c31b1bULL, - 0xeeb5c15b7774b5b5ULL, 0x86af112943beafafULL, 0xb56a77dfd41d6a6aULL, 0x5d50ba0da0ea5050ULL, - 0x0945124c8a574545ULL, 0xebf3cb18fb38f3f3ULL, 0xc0309df060ad3030ULL, 0x9bef2b74c3c4efefULL, - 0xfc3fe5c37eda3f3fULL, 0x4955921caac75555ULL, 0xb2a2791059dba2a2ULL, 0x8fea0365c9e9eaeaULL, - 0x89650fecca6a6565ULL, 0xd2bab9686903babaULL, 0xbc2f65935e4a2f2fULL, 0x27c04ee79d8ec0c0ULL, - 0x5fdebe81a160dedeULL, 0x701ce06c38fc1c1cULL, 0xd3fdbb2ee746fdfdULL, 0x294d52649a1f4d4dULL, - 0x7292e4e039769292ULL, 0xc9758fbceafa7575ULL, 0x1806301e0c360606ULL, 0x128a249809ae8a8aULL, - 0xf2b2f940794bb2b2ULL, 0xbfe66359d185e6e6ULL, 0x380e70361c7e0e0eULL, 0x7c1ff8633ee71f1fULL, - 0x956237f7c4556262ULL, 0x77d4eea3b53ad4d4ULL, 0x9aa829324d81a8a8ULL, 0x6296c4f431529696ULL, - 0xc3f99b3aef62f9f9ULL, 0x33c566f697a3c5c5ULL, 0x942535b14a102525ULL, 0x7959f220b2ab5959ULL, - 0x2a8454ae15d08484ULL, 0xd572b7a7e4c57272ULL, 0xe439d5dd72ec3939ULL, 0x2d4c5a6198164c4cULL, - 0x655eca3bbc945e5eULL, 0xfd78e785f09f7878ULL, 0xe038ddd870e53838ULL, 0x0a8c148605988c8cULL, - 0x63d1c6b2bf17d1d1ULL, 0xaea5410b57e4a5a5ULL, 0xafe2434dd9a1e2e2ULL, 0x99612ff8c24e6161ULL, - 0xf6b3f1457b42b3b3ULL, 0x842115a542342121ULL, 0x4a9c94d625089c9cULL, 0x781ef0663cee1e1eULL, - 0x1143225286614343ULL, 0x3bc776fc93b1c7c7ULL, 0xd7fcb32be54ffcfcULL, 0x1004201408240404ULL, - 0x5951b208a2e35151ULL, 0x5e99bcc72f259999ULL, 0xa96d4fc4da226d6dULL, 0x340d68391a650d0dULL, - 0xcffa8335e979fafaULL, 0x5bdfb684a369dfdfULL, 0xe57ed79bfca97e7eULL, 0x90243db448192424ULL, - 0xec3bc5d776fe3b3bULL, 0x96ab313d4b9aababULL, 0x1fce3ed181f0ceceULL, 0x4411885522991111ULL, - 0x068f0c8903838f8fULL, 0x254e4a6b9c044e4eULL, 0xe6b7d1517366b7b7ULL, 0x8beb0b60cbe0ebebULL, - 0xf03cfdcc78c13c3cULL, 0x3e817cbf1ffd8181ULL, 0x6a94d4fe35409494ULL, 0xfbf7eb0cf31cf7f7ULL, - 0xdeb9a1676f18b9b9ULL, 0x4c13985f268b1313ULL, 0xb02c7d9c58512c2cULL, 0x6bd3d6b8bb05d3d3ULL, - 0xbbe76b5cd38ce7e7ULL, 0xa56e57cbdc396e6eULL, 0x37c46ef395aac4c4ULL, 0x0c03180f061b0303ULL, - 0x45568a13acdc5656ULL, 0x0d441a49885e4444ULL, 0xe17fdf9efea07f7fULL, 0x9ea921374f88a9a9ULL, - 0xa82a4d8254672a2aULL, 0xd6bbb16d6b0abbbbULL, 0x23c146e29f87c1c1ULL, 0x5153a202a6f15353ULL, - 0x57dcae8ba572dcdcULL, 0x2c0b582716530b0bULL, 0x4e9d9cd327019d9dULL, 0xad6c47c1d82b6c6cULL, - 0xc43195f562a43131ULL, 0xcd7487b9e8f37474ULL, 0xfff6e309f115f6f6ULL, 0x05460a438c4c4646ULL, - 0x8aac092645a5acacULL, 0x1e893c970fb58989ULL, 0x5014a04428b41414ULL, 0xa3e15b42dfbae1e1ULL, - 0x5816b04e2ca61616ULL, 0xe83acdd274f73a3aULL, 0xb9696fd0d2066969ULL, 0x2409482d12410909ULL, - 0xdd70a7ade0d77070ULL, 0xe2b6d954716fb6b6ULL, 0x67d0ceb7bd1ed0d0ULL, 0x93ed3b7ec7d6ededULL, - 0x17cc2edb85e2ccccULL, 0x15422a5784684242ULL, 0x5a98b4c22d2c9898ULL, 0xaaa4490e55eda4a4ULL, - 0xa0285d8850752828ULL, 0x6d5cda31b8865c5cULL, 0xc7f8933fed6bf8f8ULL, 0x228644a411c28686ULL, + 0X6018C07830D81818ULL, 0X8C2305AF46262323ULL, 0X3FC67EF991B8C6C6ULL, 0X87E8136FCDFBE8E8ULL, + 0X26874CA113CB8787ULL, 0XDAB8A9626D11B8B8ULL, 0X0401080502090101ULL, 0X214F426E9E0D4F4FULL, + 0XD836ADEE6C9B3636ULL, 0XA2A6590451FFA6A6ULL, 0X6FD2DEBDB90CD2D2ULL, 0XF3F5FB06F70EF5F5ULL, + 0XF979EF80F2967979ULL, 0XA16F5FCEDE306F6FULL, 0X7E91FCEF3F6D9191ULL, 0X5552AA07A4F85252ULL, + 0X9D6027FDC0476060ULL, 0XCABC89766535BCBCULL, 0X569BACCD2B379B9BULL, 0X028E048C018A8E8EULL, + 0XB6A371155BD2A3A3ULL, 0X300C603C186C0C0CULL, 0XF17BFF8AF6847B7BULL, 0XD435B5E16A803535ULL, + 0X741DE8693AF51D1DULL, 0XA7E05347DDB3E0E0ULL, 0X7BD7F6ACB321D7D7ULL, 0X2FC25EED999CC2C2ULL, + 0XB82E6D965C432E2EULL, 0X314B627A96294B4BULL, 0XDFFEA321E15DFEFEULL, 0X41578216AED55757ULL, + 0X5415A8412ABD1515ULL, 0XC1779FB6EEE87777ULL, 0XDC37A5EB6E923737ULL, 0XB3E57B56D79EE5E5ULL, + 0X469F8CD923139F9FULL, 0XE7F0D317FD23F0F0ULL, 0X354A6A7F94204A4AULL, 0X4FDA9E95A944DADAULL, + 0X7D58FA25B0A25858ULL, 0X03C906CA8FCFC9C9ULL, 0XA429558D527C2929ULL, 0X280A5022145A0A0AULL, + 0XFEB1E14F7F50B1B1ULL, 0XBAA0691A5DC9A0A0ULL, 0XB16B7FDAD6146B6BULL, 0X2E855CAB17D98585ULL, + 0XCEBD8173673CBDBDULL, 0X695DD234BA8F5D5DULL, 0X4010805020901010ULL, 0XF7F4F303F507F4F4ULL, + 0X0BCB16C08BDDCBCBULL, 0XF83EEDC67CD33E3EULL, 0X140528110A2D0505ULL, 0X81671FE6CE786767ULL, + 0XB7E47353D597E4E4ULL, 0X9C2725BB4E022727ULL, 0X1941325882734141ULL, 0X168B2C9D0BA78B8BULL, + 0XA6A7510153F6A7A7ULL, 0XE97DCF94FAB27D7DULL, 0X6E95DCFB37499595ULL, 0X47D88E9FAD56D8D8ULL, + 0XCBFB8B30EB70FBFBULL, 0X9FEE2371C1CDEEEEULL, 0XED7CC791F8BB7C7CULL, 0X856617E3CC716666ULL, + 0X53DDA68EA77BDDDDULL, 0X5C17B84B2EAF1717ULL, 0X014702468E454747ULL, 0X429E84DC211A9E9EULL, + 0X0FCA1EC589D4CACAULL, 0XB42D75995A582D2DULL, 0XC6BF9179632EBFBFULL, 0X1C07381B0E3F0707ULL, + 0X8EAD012347ACADADULL, 0X755AEA2FB4B05A5AULL, 0X36836CB51BEF8383ULL, 0XCC3385FF66B63333ULL, + 0X91633FF2C65C6363ULL, 0X0802100A04120202ULL, 0X92AA39384993AAAAULL, 0XD971AFA8E2DE7171ULL, + 0X07C80ECF8DC6C8C8ULL, 0X6419C87D32D11919ULL, 0X39497270923B4949ULL, 0X43D9869AAF5FD9D9ULL, + 0XEFF2C31DF931F2F2ULL, 0XABE34B48DBA8E3E3ULL, 0X715BE22AB6B95B5BULL, 0X1A8834920DBC8888ULL, + 0X529AA4C8293E9A9AULL, 0X98262DBE4C0B2626ULL, 0XC8328DFA64BF3232ULL, 0XFAB0E94A7D59B0B0ULL, + 0X83E91B6ACFF2E9E9ULL, 0X3C0F78331E770F0FULL, 0X73D5E6A6B733D5D5ULL, 0X3A8074BA1DF48080ULL, + 0XC2BE997C6127BEBEULL, 0X13CD26DE87EBCDCDULL, 0XD034BDE468893434ULL, 0X3D487A7590324848ULL, + 0XDBFFAB24E354FFFFULL, 0XF57AF78FF48D7A7AULL, 0X7A90F4EA3D649090ULL, 0X615FC23EBE9D5F5FULL, + 0X80201DA0403D2020ULL, 0XBD6867D5D00F6868ULL, 0X681AD07234CA1A1AULL, 0X82AE192C41B7AEAEULL, + 0XEAB4C95E757DB4B4ULL, 0X4D549A19A8CE5454ULL, 0X7693ECE53B7F9393ULL, 0X88220DAA442F2222ULL, + 0X8D6407E9C8636464ULL, 0XE3F1DB12FF2AF1F1ULL, 0XD173BFA2E6CC7373ULL, 0X4812905A24821212ULL, + 0X1D403A5D807A4040ULL, 0X2008402810480808ULL, 0X2BC356E89B95C3C3ULL, 0X97EC337BC5DFECECULL, + 0X4BDB9690AB4DDBDBULL, 0XBEA1611F5FC0A1A1ULL, 0X0E8D1C8307918D8DULL, 0XF43DF5C97AC83D3DULL, + 0X6697CCF1335B9797ULL, 0X0000000000000000ULL, 0X1BCF36D483F9CFCFULL, 0XAC2B4587566E2B2BULL, + 0XC57697B3ECE17676ULL, 0X328264B019E68282ULL, 0X7FD6FEA9B128D6D6ULL, 0X6C1BD87736C31B1BULL, + 0XEEB5C15B7774B5B5ULL, 0X86AF112943BEAFAFULL, 0XB56A77DFD41D6A6AULL, 0X5D50BA0DA0EA5050ULL, + 0X0945124C8A574545ULL, 0XEBF3CB18FB38F3F3ULL, 0XC0309DF060AD3030ULL, 0X9BEF2B74C3C4EFEFULL, + 0XFC3FE5C37EDA3F3FULL, 0X4955921CAAC75555ULL, 0XB2A2791059DBA2A2ULL, 0X8FEA0365C9E9EAEAULL, + 0X89650FECCA6A6565ULL, 0XD2BAB9686903BABAULL, 0XBC2F65935E4A2F2FULL, 0X27C04EE79D8EC0C0ULL, + 0X5FDEBE81A160DEDEULL, 0X701CE06C38FC1C1CULL, 0XD3FDBB2EE746FDFDULL, 0X294D52649A1F4D4DULL, + 0X7292E4E039769292ULL, 0XC9758FBCEAFA7575ULL, 0X1806301E0C360606ULL, 0X128A249809AE8A8AULL, + 0XF2B2F940794BB2B2ULL, 0XBFE66359D185E6E6ULL, 0X380E70361C7E0E0EULL, 0X7C1FF8633EE71F1FULL, + 0X956237F7C4556262ULL, 0X77D4EEA3B53AD4D4ULL, 0X9AA829324D81A8A8ULL, 0X6296C4F431529696ULL, + 0XC3F99B3AEF62F9F9ULL, 0X33C566F697A3C5C5ULL, 0X942535B14A102525ULL, 0X7959F220B2AB5959ULL, + 0X2A8454AE15D08484ULL, 0XD572B7A7E4C57272ULL, 0XE439D5DD72EC3939ULL, 0X2D4C5A6198164C4CULL, + 0X655ECA3BBC945E5EULL, 0XFD78E785F09F7878ULL, 0XE038DDD870E53838ULL, 0X0A8C148605988C8CULL, + 0X63D1C6B2BF17D1D1ULL, 0XAEA5410B57E4A5A5ULL, 0XAFE2434DD9A1E2E2ULL, 0X99612FF8C24E6161ULL, + 0XF6B3F1457B42B3B3ULL, 0X842115A542342121ULL, 0X4A9C94D625089C9CULL, 0X781EF0663CEE1E1EULL, + 0X1143225286614343ULL, 0X3BC776FC93B1C7C7ULL, 0XD7FCB32BE54FFCFCULL, 0X1004201408240404ULL, + 0X5951B208A2E35151ULL, 0X5E99BCC72F259999ULL, 0XA96D4FC4DA226D6DULL, 0X340D68391A650D0DULL, + 0XCFFA8335E979FAFAULL, 0X5BDFB684A369DFDFULL, 0XE57ED79BFCA97E7EULL, 0X90243DB448192424ULL, + 0XEC3BC5D776FE3B3BULL, 0X96AB313D4B9AABABULL, 0X1FCE3ED181F0CECEULL, 0X4411885522991111ULL, + 0X068F0C8903838F8FULL, 0X254E4A6B9C044E4EULL, 0XE6B7D1517366B7B7ULL, 0X8BEB0B60CBE0EBEBULL, + 0XF03CFDCC78C13C3CULL, 0X3E817CBF1FFD8181ULL, 0X6A94D4FE35409494ULL, 0XFBF7EB0CF31CF7F7ULL, + 0XDEB9A1676F18B9B9ULL, 0X4C13985F268B1313ULL, 0XB02C7D9C58512C2CULL, 0X6BD3D6B8BB05D3D3ULL, + 0XBBE76B5CD38CE7E7ULL, 0XA56E57CBDC396E6EULL, 0X37C46EF395AAC4C4ULL, 0X0C03180F061B0303ULL, + 0X45568A13ACDC5656ULL, 0X0D441A49885E4444ULL, 0XE17FDF9EFEA07F7FULL, 0X9EA921374F88A9A9ULL, + 0XA82A4D8254672A2AULL, 0XD6BBB16D6B0ABBBBULL, 0X23C146E29F87C1C1ULL, 0X5153A202A6F15353ULL, + 0X57DCAE8BA572DCDCULL, 0X2C0B582716530B0BULL, 0X4E9D9CD327019D9DULL, 0XAD6C47C1D82B6C6CULL, + 0XC43195F562A43131ULL, 0XCD7487B9E8F37474ULL, 0XFFF6E309F115F6F6ULL, 0X05460A438C4C4646ULL, + 0X8AAC092645A5ACACULL, 0X1E893C970FB58989ULL, 0X5014A04428B41414ULL, 0XA3E15B42DFBAE1E1ULL, + 0X5816B04E2CA61616ULL, 0XE83ACDD274F73A3AULL, 0XB9696FD0D2066969ULL, 0X2409482D12410909ULL, + 0XDD70A7ADE0D77070ULL, 0XE2B6D954716FB6B6ULL, 0X67D0CEB7BD1ED0D0ULL, 0X93ED3B7EC7D6EDEDULL, + 0X17CC2EDB85E2CCCCULL, 0X15422A5784684242ULL, 0X5A98B4C22D2C9898ULL, 0XAAA4490E55EDA4A4ULL, + 0XA0285D8850752828ULL, 0X6D5CDA31B8865C5CULL, 0XC7F8933FED6BF8F8ULL, 0X228644A411C28686ULL, }; const UInt64 C7[256] = { - 0x186018c07830d818ULL, 0x238c2305af462623ULL, 0xc63fc67ef991b8c6ULL, 0xe887e8136fcdfbe8ULL, - 0x8726874ca113cb87ULL, 0xb8dab8a9626d11b8ULL, 0x0104010805020901ULL, 0x4f214f426e9e0d4fULL, - 0x36d836adee6c9b36ULL, 0xa6a2a6590451ffa6ULL, 0xd26fd2debdb90cd2ULL, 0xf5f3f5fb06f70ef5ULL, - 0x79f979ef80f29679ULL, 0x6fa16f5fcede306fULL, 0x917e91fcef3f6d91ULL, 0x525552aa07a4f852ULL, - 0x609d6027fdc04760ULL, 0xbccabc89766535bcULL, 0x9b569baccd2b379bULL, 0x8e028e048c018a8eULL, - 0xa3b6a371155bd2a3ULL, 0x0c300c603c186c0cULL, 0x7bf17bff8af6847bULL, 0x35d435b5e16a8035ULL, - 0x1d741de8693af51dULL, 0xe0a7e05347ddb3e0ULL, 0xd77bd7f6acb321d7ULL, 0xc22fc25eed999cc2ULL, - 0x2eb82e6d965c432eULL, 0x4b314b627a96294bULL, 0xfedffea321e15dfeULL, 0x5741578216aed557ULL, - 0x155415a8412abd15ULL, 0x77c1779fb6eee877ULL, 0x37dc37a5eb6e9237ULL, 0xe5b3e57b56d79ee5ULL, - 0x9f469f8cd923139fULL, 0xf0e7f0d317fd23f0ULL, 0x4a354a6a7f94204aULL, 0xda4fda9e95a944daULL, - 0x587d58fa25b0a258ULL, 0xc903c906ca8fcfc9ULL, 0x29a429558d527c29ULL, 0x0a280a5022145a0aULL, - 0xb1feb1e14f7f50b1ULL, 0xa0baa0691a5dc9a0ULL, 0x6bb16b7fdad6146bULL, 0x852e855cab17d985ULL, - 0xbdcebd8173673cbdULL, 0x5d695dd234ba8f5dULL, 0x1040108050209010ULL, 0xf4f7f4f303f507f4ULL, - 0xcb0bcb16c08bddcbULL, 0x3ef83eedc67cd33eULL, 0x05140528110a2d05ULL, 0x6781671fe6ce7867ULL, - 0xe4b7e47353d597e4ULL, 0x279c2725bb4e0227ULL, 0x4119413258827341ULL, 0x8b168b2c9d0ba78bULL, - 0xa7a6a7510153f6a7ULL, 0x7de97dcf94fab27dULL, 0x956e95dcfb374995ULL, 0xd847d88e9fad56d8ULL, - 0xfbcbfb8b30eb70fbULL, 0xee9fee2371c1cdeeULL, 0x7ced7cc791f8bb7cULL, 0x66856617e3cc7166ULL, - 0xdd53dda68ea77bddULL, 0x175c17b84b2eaf17ULL, 0x47014702468e4547ULL, 0x9e429e84dc211a9eULL, - 0xca0fca1ec589d4caULL, 0x2db42d75995a582dULL, 0xbfc6bf9179632ebfULL, 0x071c07381b0e3f07ULL, - 0xad8ead012347acadULL, 0x5a755aea2fb4b05aULL, 0x8336836cb51bef83ULL, 0x33cc3385ff66b633ULL, - 0x6391633ff2c65c63ULL, 0x020802100a041202ULL, 0xaa92aa39384993aaULL, 0x71d971afa8e2de71ULL, - 0xc807c80ecf8dc6c8ULL, 0x196419c87d32d119ULL, 0x4939497270923b49ULL, 0xd943d9869aaf5fd9ULL, - 0xf2eff2c31df931f2ULL, 0xe3abe34b48dba8e3ULL, 0x5b715be22ab6b95bULL, 0x881a8834920dbc88ULL, - 0x9a529aa4c8293e9aULL, 0x2698262dbe4c0b26ULL, 0x32c8328dfa64bf32ULL, 0xb0fab0e94a7d59b0ULL, - 0xe983e91b6acff2e9ULL, 0x0f3c0f78331e770fULL, 0xd573d5e6a6b733d5ULL, 0x803a8074ba1df480ULL, - 0xbec2be997c6127beULL, 0xcd13cd26de87ebcdULL, 0x34d034bde4688934ULL, 0x483d487a75903248ULL, - 0xffdbffab24e354ffULL, 0x7af57af78ff48d7aULL, 0x907a90f4ea3d6490ULL, 0x5f615fc23ebe9d5fULL, - 0x2080201da0403d20ULL, 0x68bd6867d5d00f68ULL, 0x1a681ad07234ca1aULL, 0xae82ae192c41b7aeULL, - 0xb4eab4c95e757db4ULL, 0x544d549a19a8ce54ULL, 0x937693ece53b7f93ULL, 0x2288220daa442f22ULL, - 0x648d6407e9c86364ULL, 0xf1e3f1db12ff2af1ULL, 0x73d173bfa2e6cc73ULL, 0x124812905a248212ULL, - 0x401d403a5d807a40ULL, 0x0820084028104808ULL, 0xc32bc356e89b95c3ULL, 0xec97ec337bc5dfecULL, - 0xdb4bdb9690ab4ddbULL, 0xa1bea1611f5fc0a1ULL, 0x8d0e8d1c8307918dULL, 0x3df43df5c97ac83dULL, - 0x976697ccf1335b97ULL, 0x0000000000000000ULL, 0xcf1bcf36d483f9cfULL, 0x2bac2b4587566e2bULL, - 0x76c57697b3ece176ULL, 0x82328264b019e682ULL, 0xd67fd6fea9b128d6ULL, 0x1b6c1bd87736c31bULL, - 0xb5eeb5c15b7774b5ULL, 0xaf86af112943beafULL, 0x6ab56a77dfd41d6aULL, 0x505d50ba0da0ea50ULL, - 0x450945124c8a5745ULL, 0xf3ebf3cb18fb38f3ULL, 0x30c0309df060ad30ULL, 0xef9bef2b74c3c4efULL, - 0x3ffc3fe5c37eda3fULL, 0x554955921caac755ULL, 0xa2b2a2791059dba2ULL, 0xea8fea0365c9e9eaULL, - 0x6589650fecca6a65ULL, 0xbad2bab9686903baULL, 0x2fbc2f65935e4a2fULL, 0xc027c04ee79d8ec0ULL, - 0xde5fdebe81a160deULL, 0x1c701ce06c38fc1cULL, 0xfdd3fdbb2ee746fdULL, 0x4d294d52649a1f4dULL, - 0x927292e4e0397692ULL, 0x75c9758fbceafa75ULL, 0x061806301e0c3606ULL, 0x8a128a249809ae8aULL, - 0xb2f2b2f940794bb2ULL, 0xe6bfe66359d185e6ULL, 0x0e380e70361c7e0eULL, 0x1f7c1ff8633ee71fULL, - 0x62956237f7c45562ULL, 0xd477d4eea3b53ad4ULL, 0xa89aa829324d81a8ULL, 0x966296c4f4315296ULL, - 0xf9c3f99b3aef62f9ULL, 0xc533c566f697a3c5ULL, 0x25942535b14a1025ULL, 0x597959f220b2ab59ULL, - 0x842a8454ae15d084ULL, 0x72d572b7a7e4c572ULL, 0x39e439d5dd72ec39ULL, 0x4c2d4c5a6198164cULL, - 0x5e655eca3bbc945eULL, 0x78fd78e785f09f78ULL, 0x38e038ddd870e538ULL, 0x8c0a8c148605988cULL, - 0xd163d1c6b2bf17d1ULL, 0xa5aea5410b57e4a5ULL, 0xe2afe2434dd9a1e2ULL, 0x6199612ff8c24e61ULL, - 0xb3f6b3f1457b42b3ULL, 0x21842115a5423421ULL, 0x9c4a9c94d625089cULL, 0x1e781ef0663cee1eULL, - 0x4311432252866143ULL, 0xc73bc776fc93b1c7ULL, 0xfcd7fcb32be54ffcULL, 0x0410042014082404ULL, - 0x515951b208a2e351ULL, 0x995e99bcc72f2599ULL, 0x6da96d4fc4da226dULL, 0x0d340d68391a650dULL, - 0xfacffa8335e979faULL, 0xdf5bdfb684a369dfULL, 0x7ee57ed79bfca97eULL, 0x2490243db4481924ULL, - 0x3bec3bc5d776fe3bULL, 0xab96ab313d4b9aabULL, 0xce1fce3ed181f0ceULL, 0x1144118855229911ULL, - 0x8f068f0c8903838fULL, 0x4e254e4a6b9c044eULL, 0xb7e6b7d1517366b7ULL, 0xeb8beb0b60cbe0ebULL, - 0x3cf03cfdcc78c13cULL, 0x813e817cbf1ffd81ULL, 0x946a94d4fe354094ULL, 0xf7fbf7eb0cf31cf7ULL, - 0xb9deb9a1676f18b9ULL, 0x134c13985f268b13ULL, 0x2cb02c7d9c58512cULL, 0xd36bd3d6b8bb05d3ULL, - 0xe7bbe76b5cd38ce7ULL, 0x6ea56e57cbdc396eULL, 0xc437c46ef395aac4ULL, 0x030c03180f061b03ULL, - 0x5645568a13acdc56ULL, 0x440d441a49885e44ULL, 0x7fe17fdf9efea07fULL, 0xa99ea921374f88a9ULL, - 0x2aa82a4d8254672aULL, 0xbbd6bbb16d6b0abbULL, 0xc123c146e29f87c1ULL, 0x535153a202a6f153ULL, - 0xdc57dcae8ba572dcULL, 0x0b2c0b582716530bULL, 0x9d4e9d9cd327019dULL, 0x6cad6c47c1d82b6cULL, - 0x31c43195f562a431ULL, 0x74cd7487b9e8f374ULL, 0xf6fff6e309f115f6ULL, 0x4605460a438c4c46ULL, - 0xac8aac092645a5acULL, 0x891e893c970fb589ULL, 0x145014a04428b414ULL, 0xe1a3e15b42dfbae1ULL, - 0x165816b04e2ca616ULL, 0x3ae83acdd274f73aULL, 0x69b9696fd0d20669ULL, 0x092409482d124109ULL, - 0x70dd70a7ade0d770ULL, 0xb6e2b6d954716fb6ULL, 0xd067d0ceb7bd1ed0ULL, 0xed93ed3b7ec7d6edULL, - 0xcc17cc2edb85e2ccULL, 0x4215422a57846842ULL, 0x985a98b4c22d2c98ULL, 0xa4aaa4490e55eda4ULL, - 0x28a0285d88507528ULL, 0x5c6d5cda31b8865cULL, 0xf8c7f8933fed6bf8ULL, 0x86228644a411c286ULL, + 0X186018C07830D818ULL, 0X238C2305AF462623ULL, 0XC63FC67EF991B8C6ULL, 0XE887E8136FCDFBE8ULL, + 0X8726874CA113CB87ULL, 0XB8DAB8A9626D11B8ULL, 0X0104010805020901ULL, 0X4F214F426E9E0D4FULL, + 0X36D836ADEE6C9B36ULL, 0XA6A2A6590451FFA6ULL, 0XD26FD2DEBDB90CD2ULL, 0XF5F3F5FB06F70EF5ULL, + 0X79F979EF80F29679ULL, 0X6FA16F5FCEDE306FULL, 0X917E91FCEF3F6D91ULL, 0X525552AA07A4F852ULL, + 0X609D6027FDC04760ULL, 0XBCCABC89766535BCULL, 0X9B569BACCD2B379BULL, 0X8E028E048C018A8EULL, + 0XA3B6A371155BD2A3ULL, 0X0C300C603C186C0CULL, 0X7BF17BFF8AF6847BULL, 0X35D435B5E16A8035ULL, + 0X1D741DE8693AF51DULL, 0XE0A7E05347DDB3E0ULL, 0XD77BD7F6ACB321D7ULL, 0XC22FC25EED999CC2ULL, + 0X2EB82E6D965C432EULL, 0X4B314B627A96294BULL, 0XFEDFFEA321E15DFEULL, 0X5741578216AED557ULL, + 0X155415A8412ABD15ULL, 0X77C1779FB6EEE877ULL, 0X37DC37A5EB6E9237ULL, 0XE5B3E57B56D79EE5ULL, + 0X9F469F8CD923139FULL, 0XF0E7F0D317FD23F0ULL, 0X4A354A6A7F94204AULL, 0XDA4FDA9E95A944DAULL, + 0X587D58FA25B0A258ULL, 0XC903C906CA8FCFC9ULL, 0X29A429558D527C29ULL, 0X0A280A5022145A0AULL, + 0XB1FEB1E14F7F50B1ULL, 0XA0BAA0691A5DC9A0ULL, 0X6BB16B7FDAD6146BULL, 0X852E855CAB17D985ULL, + 0XBDCEBD8173673CBDULL, 0X5D695DD234BA8F5DULL, 0X1040108050209010ULL, 0XF4F7F4F303F507F4ULL, + 0XCB0BCB16C08BDDCBULL, 0X3EF83EEDC67CD33EULL, 0X05140528110A2D05ULL, 0X6781671FE6CE7867ULL, + 0XE4B7E47353D597E4ULL, 0X279C2725BB4E0227ULL, 0X4119413258827341ULL, 0X8B168B2C9D0BA78BULL, + 0XA7A6A7510153F6A7ULL, 0X7DE97DCF94FAB27DULL, 0X956E95DCFB374995ULL, 0XD847D88E9FAD56D8ULL, + 0XFBCBFB8B30EB70FBULL, 0XEE9FEE2371C1CDEEULL, 0X7CED7CC791F8BB7CULL, 0X66856617E3CC7166ULL, + 0XDD53DDA68EA77BDDULL, 0X175C17B84B2EAF17ULL, 0X47014702468E4547ULL, 0X9E429E84DC211A9EULL, + 0XCA0FCA1EC589D4CAULL, 0X2DB42D75995A582DULL, 0XBFC6BF9179632EBFULL, 0X071C07381B0E3F07ULL, + 0XAD8EAD012347ACADULL, 0X5A755AEA2FB4B05AULL, 0X8336836CB51BEF83ULL, 0X33CC3385FF66B633ULL, + 0X6391633FF2C65C63ULL, 0X020802100A041202ULL, 0XAA92AA39384993AAULL, 0X71D971AFA8E2DE71ULL, + 0XC807C80ECF8DC6C8ULL, 0X196419C87D32D119ULL, 0X4939497270923B49ULL, 0XD943D9869AAF5FD9ULL, + 0XF2EFF2C31DF931F2ULL, 0XE3ABE34B48DBA8E3ULL, 0X5B715BE22AB6B95BULL, 0X881A8834920DBC88ULL, + 0X9A529AA4C8293E9AULL, 0X2698262DBE4C0B26ULL, 0X32C8328DFA64BF32ULL, 0XB0FAB0E94A7D59B0ULL, + 0XE983E91B6ACFF2E9ULL, 0X0F3C0F78331E770FULL, 0XD573D5E6A6B733D5ULL, 0X803A8074BA1DF480ULL, + 0XBEC2BE997C6127BEULL, 0XCD13CD26DE87EBCDULL, 0X34D034BDE4688934ULL, 0X483D487A75903248ULL, + 0XFFDBFFAB24E354FFULL, 0X7AF57AF78FF48D7AULL, 0X907A90F4EA3D6490ULL, 0X5F615FC23EBE9D5FULL, + 0X2080201DA0403D20ULL, 0X68BD6867D5D00F68ULL, 0X1A681AD07234CA1AULL, 0XAE82AE192C41B7AEULL, + 0XB4EAB4C95E757DB4ULL, 0X544D549A19A8CE54ULL, 0X937693ECE53B7F93ULL, 0X2288220DAA442F22ULL, + 0X648D6407E9C86364ULL, 0XF1E3F1DB12FF2AF1ULL, 0X73D173BFA2E6CC73ULL, 0X124812905A248212ULL, + 0X401D403A5D807A40ULL, 0X0820084028104808ULL, 0XC32BC356E89B95C3ULL, 0XEC97EC337BC5DFECULL, + 0XDB4BDB9690AB4DDBULL, 0XA1BEA1611F5FC0A1ULL, 0X8D0E8D1C8307918DULL, 0X3DF43DF5C97AC83DULL, + 0X976697CCF1335B97ULL, 0X0000000000000000ULL, 0XCF1BCF36D483F9CFULL, 0X2BAC2B4587566E2BULL, + 0X76C57697B3ECE176ULL, 0X82328264B019E682ULL, 0XD67FD6FEA9B128D6ULL, 0X1B6C1BD87736C31BULL, + 0XB5EEB5C15B7774B5ULL, 0XAF86AF112943BEAFULL, 0X6AB56A77DFD41D6AULL, 0X505D50BA0DA0EA50ULL, + 0X450945124C8A5745ULL, 0XF3EBF3CB18FB38F3ULL, 0X30C0309DF060AD30ULL, 0XEF9BEF2B74C3C4EFULL, + 0X3FFC3FE5C37EDA3FULL, 0X554955921CAAC755ULL, 0XA2B2A2791059DBA2ULL, 0XEA8FEA0365C9E9EAULL, + 0X6589650FECCA6A65ULL, 0XBAD2BAB9686903BAULL, 0X2FBC2F65935E4A2FULL, 0XC027C04EE79D8EC0ULL, + 0XDE5FDEBE81A160DEULL, 0X1C701CE06C38FC1CULL, 0XFDD3FDBB2EE746FDULL, 0X4D294D52649A1F4DULL, + 0X927292E4E0397692ULL, 0X75C9758FBCEAFA75ULL, 0X061806301E0C3606ULL, 0X8A128A249809AE8AULL, + 0XB2F2B2F940794BB2ULL, 0XE6BFE66359D185E6ULL, 0X0E380E70361C7E0EULL, 0X1F7C1FF8633EE71FULL, + 0X62956237F7C45562ULL, 0XD477D4EEA3B53AD4ULL, 0XA89AA829324D81A8ULL, 0X966296C4F4315296ULL, + 0XF9C3F99B3AEF62F9ULL, 0XC533C566F697A3C5ULL, 0X25942535B14A1025ULL, 0X597959F220B2AB59ULL, + 0X842A8454AE15D084ULL, 0X72D572B7A7E4C572ULL, 0X39E439D5DD72EC39ULL, 0X4C2D4C5A6198164CULL, + 0X5E655ECA3BBC945EULL, 0X78FD78E785F09F78ULL, 0X38E038DDD870E538ULL, 0X8C0A8C148605988CULL, + 0XD163D1C6B2BF17D1ULL, 0XA5AEA5410B57E4A5ULL, 0XE2AFE2434DD9A1E2ULL, 0X6199612FF8C24E61ULL, + 0XB3F6B3F1457B42B3ULL, 0X21842115A5423421ULL, 0X9C4A9C94D625089CULL, 0X1E781EF0663CEE1EULL, + 0X4311432252866143ULL, 0XC73BC776FC93B1C7ULL, 0XFCD7FCB32BE54FFCULL, 0X0410042014082404ULL, + 0X515951B208A2E351ULL, 0X995E99BCC72F2599ULL, 0X6DA96D4FC4DA226DULL, 0X0D340D68391A650DULL, + 0XFACFFA8335E979FAULL, 0XDF5BDFB684A369DFULL, 0X7EE57ED79BFCA97EULL, 0X2490243DB4481924ULL, + 0X3BEC3BC5D776FE3BULL, 0XAB96AB313D4B9AABULL, 0XCE1FCE3ED181F0CEULL, 0X1144118855229911ULL, + 0X8F068F0C8903838FULL, 0X4E254E4A6B9C044EULL, 0XB7E6B7D1517366B7ULL, 0XEB8BEB0B60CBE0EBULL, + 0X3CF03CFDCC78C13CULL, 0X813E817CBF1FFD81ULL, 0X946A94D4FE354094ULL, 0XF7FBF7EB0CF31CF7ULL, + 0XB9DEB9A1676F18B9ULL, 0X134C13985F268B13ULL, 0X2CB02C7D9C58512CULL, 0XD36BD3D6B8BB05D3ULL, + 0XE7BBE76B5CD38CE7ULL, 0X6EA56E57CBDC396EULL, 0XC437C46EF395AAC4ULL, 0X030C03180F061B03ULL, + 0X5645568A13ACDC56ULL, 0X440D441A49885E44ULL, 0X7FE17FDF9EFEA07FULL, 0XA99EA921374F88A9ULL, + 0X2AA82A4D8254672AULL, 0XBBD6BBB16D6B0ABBULL, 0XC123C146E29F87C1ULL, 0X535153A202A6F153ULL, + 0XDC57DCAE8BA572DCULL, 0X0B2C0B582716530BULL, 0X9D4E9D9CD327019DULL, 0X6CAD6C47C1D82B6CULL, + 0X31C43195F562A431ULL, 0X74CD7487B9E8F374ULL, 0XF6FFF6E309F115F6ULL, 0X4605460A438C4C46ULL, + 0XAC8AAC092645A5ACULL, 0X891E893C970FB589ULL, 0X145014A04428B414ULL, 0XE1A3E15B42DFBAE1ULL, + 0X165816B04E2CA616ULL, 0X3AE83ACDD274F73AULL, 0X69B9696FD0D20669ULL, 0X092409482D124109ULL, + 0X70DD70A7ADE0D770ULL, 0XB6E2B6D954716FB6ULL, 0XD067D0CEB7BD1ED0ULL, 0XED93ED3B7EC7D6EDULL, + 0XCC17CC2EDB85E2CCULL, 0X4215422A57846842ULL, 0X985A98B4C22D2C98ULL, 0XA4AAA4490E55EDA4ULL, + 0X28A0285D88507528ULL, 0X5C6D5CDA31B8865CULL, 0XF8C7F8933FED6BF8ULL, 0X86228644A411C286ULL, }; const UInt64 rc[R + 1] = { - 0x0000000000000000ULL, - 0x1823c6e887b8014fULL, - 0x36a6d2f5796f9152ULL, - 0x60bc9b8ea30c7b35ULL, - 0x1de0d7c22e4bfe57ULL, - 0x157737e59ff04adaULL, - 0x58c9290ab1a06b85ULL, - 0xbd5d10f4cb3e0567ULL, - 0xe427418ba77d95d8ULL, - 0xfbee7c66dd17479eULL, - 0xca2dbf07ad5a8333ULL, + 0X0000000000000000ULL, + 0X1823C6E887B8014FULL, + 0X36A6D2F5796F9152ULL, + 0X60BC9B8EA30C7B35ULL, + 0X1DE0D7C22E4BFE57ULL, + 0X157737E59FF04ADAULL, + 0X58C9290AB1A06B85ULL, + 0XBD5D10F4CB3E0567ULL, + 0XE427418BA77D95D8ULL, + 0XFBEE7C66DD17479EULL, + 0XCA2DBF07AD5A8333ULL, }; - - void processBuffer(HashWhirlpool_state* wstate) - { - int i, r; - UInt64 K[8]; // the round key - UInt64 block[8]; // mu(buffer) - UInt64 state[8]; // the cipher state - UInt64 L[8]; - UInt8 *buffer = wstate->buffer; - - // map the buffer to a block - for (i = 0; i < 8; i++, buffer += 8) - { - block[i] = - ((static_cast(buffer[0]) ) << 56) ^ - ((static_cast(buffer[1]) & 0xffL) << 48) ^ - ((static_cast(buffer[2]) & 0xffL) << 40) ^ - ((static_cast(buffer[3]) & 0xffL) << 32) ^ - ((static_cast(buffer[4]) & 0xffL) << 24) ^ - ((static_cast(buffer[5]) & 0xffL) << 16) ^ - ((static_cast(buffer[6]) & 0xffL) << 8) ^ - ((static_cast(buffer[7]) & 0xffL) ); - } - - // compute and apply K^0 to the cipher state - state[0] = block[0] ^ (K[0] = wstate->hash[0]); - state[1] = block[1] ^ (K[1] = wstate->hash[1]); - state[2] = block[2] ^ (K[2] = wstate->hash[2]); - state[3] = block[3] ^ (K[3] = wstate->hash[3]); - state[4] = block[4] ^ (K[4] = wstate->hash[4]); - state[5] = block[5] ^ (K[5] = wstate->hash[5]); - state[6] = block[6] ^ (K[6] = wstate->hash[6]); - state[7] = block[7] ^ (K[7] = wstate->hash[7]); - - // iterate over all rounds - for (r = 1; r <= R; r++) - { - // compute K^r from K^{r-1} - L[0] = - C0[static_cast(K[0] >> 56) ] ^ - C1[static_cast(K[7] >> 48) & 0xff] ^ - C2[static_cast(K[6] >> 40) & 0xff] ^ - C3[static_cast(K[5] >> 32) & 0xff] ^ - C4[static_cast(K[4] >> 24) & 0xff] ^ - C5[static_cast(K[3] >> 16) & 0xff] ^ - C6[static_cast(K[2] >> 8) & 0xff] ^ - C7[static_cast(K[1] ) & 0xff] ^ - rc[r]; - L[1] = - C0[static_cast(K[1] >> 56) ] ^ - C1[static_cast(K[0] >> 48) & 0xff] ^ - C2[static_cast(K[7] >> 40) & 0xff] ^ - C3[static_cast(K[6] >> 32) & 0xff] ^ - C4[static_cast(K[5] >> 24) & 0xff] ^ - C5[static_cast(K[4] >> 16) & 0xff] ^ - C6[static_cast(K[3] >> 8) & 0xff] ^ - C7[static_cast(K[2] ) & 0xff]; - L[2] = - C0[static_cast(K[2] >> 56) ] ^ - C1[static_cast(K[1] >> 48) & 0xff] ^ - C2[static_cast(K[0] >> 40) & 0xff] ^ - C3[static_cast(K[7] >> 32) & 0xff] ^ - C4[static_cast(K[6] >> 24) & 0xff] ^ - C5[static_cast(K[5] >> 16) & 0xff] ^ - C6[static_cast(K[4] >> 8) & 0xff] ^ - C7[static_cast(K[3] ) & 0xff]; - L[3] = - C0[static_cast(K[3] >> 56) ] ^ - C1[static_cast(K[2] >> 48) & 0xff] ^ - C2[static_cast(K[1] >> 40) & 0xff] ^ - C3[static_cast(K[0] >> 32) & 0xff] ^ - C4[static_cast(K[7] >> 24) & 0xff] ^ - C5[static_cast(K[6] >> 16) & 0xff] ^ - C6[static_cast(K[5] >> 8) & 0xff] ^ - C7[static_cast(K[4] ) & 0xff]; - L[4] = - C0[static_cast(K[4] >> 56) ] ^ - C1[static_cast(K[3] >> 48) & 0xff] ^ - C2[static_cast(K[2] >> 40) & 0xff] ^ - C3[static_cast(K[1] >> 32) & 0xff] ^ - C4[static_cast(K[0] >> 24) & 0xff] ^ - C5[static_cast(K[7] >> 16) & 0xff] ^ - C6[static_cast(K[6] >> 8) & 0xff] ^ - C7[static_cast(K[5] ) & 0xff]; - L[5] = - C0[static_cast(K[5] >> 56) ] ^ - C1[static_cast(K[4] >> 48) & 0xff] ^ - C2[static_cast(K[3] >> 40) & 0xff] ^ - C3[static_cast(K[2] >> 32) & 0xff] ^ - C4[static_cast(K[1] >> 24) & 0xff] ^ - C5[static_cast(K[0] >> 16) & 0xff] ^ - C6[static_cast(K[7] >> 8) & 0xff] ^ - C7[static_cast(K[6] ) & 0xff]; - L[6] = - C0[static_cast(K[6] >> 56) ] ^ - C1[static_cast(K[5] >> 48) & 0xff] ^ - C2[static_cast(K[4] >> 40) & 0xff] ^ - C3[static_cast(K[3] >> 32) & 0xff] ^ - C4[static_cast(K[2] >> 24) & 0xff] ^ - C5[static_cast(K[1] >> 16) & 0xff] ^ - C6[static_cast(K[0] >> 8) & 0xff] ^ - C7[static_cast(K[7] ) & 0xff]; - L[7] = - C0[static_cast(K[7] >> 56) ] ^ - C1[static_cast(K[6] >> 48) & 0xff] ^ - C2[static_cast(K[5] >> 40) & 0xff] ^ - C3[static_cast(K[4] >> 32) & 0xff] ^ - C4[static_cast(K[3] >> 24) & 0xff] ^ - C5[static_cast(K[2] >> 16) & 0xff] ^ - C6[static_cast(K[1] >> 8) & 0xff] ^ - C7[static_cast(K[0] ) & 0xff]; - K[0] = L[0]; - K[1] = L[1]; - K[2] = L[2]; - K[3] = L[3]; - K[4] = L[4]; - K[5] = L[5]; - K[6] = L[6]; - K[7] = L[7]; - - // apply the r-th round transformation - L[0] = - C0[static_cast(state[0] >> 56) ] ^ - C1[static_cast(state[7] >> 48) & 0xff] ^ - C2[static_cast(state[6] >> 40) & 0xff] ^ - C3[static_cast(state[5] >> 32) & 0xff] ^ - C4[static_cast(state[4] >> 24) & 0xff] ^ - C5[static_cast(state[3] >> 16) & 0xff] ^ - C6[static_cast(state[2] >> 8) & 0xff] ^ - C7[static_cast(state[1] ) & 0xff] ^ - K[0]; - L[1] = - C0[static_cast(state[1] >> 56) ] ^ - C1[static_cast(state[0] >> 48) & 0xff] ^ - C2[static_cast(state[7] >> 40) & 0xff] ^ - C3[static_cast(state[6] >> 32) & 0xff] ^ - C4[static_cast(state[5] >> 24) & 0xff] ^ - C5[static_cast(state[4] >> 16) & 0xff] ^ - C6[static_cast(state[3] >> 8) & 0xff] ^ - C7[static_cast(state[2] ) & 0xff] ^ - K[1]; - L[2] = - C0[static_cast(state[2] >> 56) ] ^ - C1[static_cast(state[1] >> 48) & 0xff] ^ - C2[static_cast(state[0] >> 40) & 0xff] ^ - C3[static_cast(state[7] >> 32) & 0xff] ^ - C4[static_cast(state[6] >> 24) & 0xff] ^ - C5[static_cast(state[5] >> 16) & 0xff] ^ - C6[static_cast(state[4] >> 8) & 0xff] ^ - C7[static_cast(state[3] ) & 0xff] ^ - K[2]; - L[3] = - C0[static_cast(state[3] >> 56) ] ^ - C1[static_cast(state[2] >> 48) & 0xff] ^ - C2[static_cast(state[1] >> 40) & 0xff] ^ - C3[static_cast(state[0] >> 32) & 0xff] ^ - C4[static_cast(state[7] >> 24) & 0xff] ^ - C5[static_cast(state[6] >> 16) & 0xff] ^ - C6[static_cast(state[5] >> 8) & 0xff] ^ - C7[static_cast(state[4] ) & 0xff] ^ - K[3]; - L[4] = - C0[static_cast(state[4] >> 56) ] ^ - C1[static_cast(state[3] >> 48) & 0xff] ^ - C2[static_cast(state[2] >> 40) & 0xff] ^ - C3[static_cast(state[1] >> 32) & 0xff] ^ - C4[static_cast(state[0] >> 24) & 0xff] ^ - C5[static_cast(state[7] >> 16) & 0xff] ^ - C6[static_cast(state[6] >> 8) & 0xff] ^ - C7[static_cast(state[5] ) & 0xff] ^ - K[4]; - L[5] = - C0[static_cast(state[5] >> 56) ] ^ - C1[static_cast(state[4] >> 48) & 0xff] ^ - C2[static_cast(state[3] >> 40) & 0xff] ^ - C3[static_cast(state[2] >> 32) & 0xff] ^ - C4[static_cast(state[1] >> 24) & 0xff] ^ - C5[static_cast(state[0] >> 16) & 0xff] ^ - C6[static_cast(state[7] >> 8) & 0xff] ^ - C7[static_cast(state[6] ) & 0xff] ^ - K[5]; - L[6] = - C0[static_cast(state[6] >> 56) ] ^ - C1[static_cast(state[5] >> 48) & 0xff] ^ - C2[static_cast(state[4] >> 40) & 0xff] ^ - C3[static_cast(state[3] >> 32) & 0xff] ^ - C4[static_cast(state[2] >> 24) & 0xff] ^ - C5[static_cast(state[1] >> 16) & 0xff] ^ - C6[static_cast(state[0] >> 8) & 0xff] ^ - C7[static_cast(state[7] ) & 0xff] ^ - K[6]; - L[7] = - C0[static_cast(state[7] >> 56) ] ^ - C1[static_cast(state[6] >> 48) & 0xff] ^ - C2[static_cast(state[5] >> 40) & 0xff] ^ - C3[static_cast(state[4] >> 32) & 0xff] ^ - C4[static_cast(state[3] >> 24) & 0xff] ^ - C5[static_cast(state[2] >> 16) & 0xff] ^ - C6[static_cast(state[1] >> 8) & 0xff] ^ - C7[static_cast(state[0] ) & 0xff] ^ - K[7]; - state[0] = L[0]; - state[1] = L[1]; - state[2] = L[2]; - state[3] = L[3]; - state[4] = L[4]; - state[5] = L[5]; - state[6] = L[6]; - state[7] = L[7]; - } - - // apply the Miyaguchi-Preneel compression function - wstate->hash[0] ^= state[0] ^ block[0]; - wstate->hash[1] ^= state[1] ^ block[1]; - wstate->hash[2] ^= state[2] ^ block[2]; - wstate->hash[3] ^= state[3] ^ block[3]; - wstate->hash[4] ^= state[4] ^ block[4]; - wstate->hash[5] ^= state[5] ^ block[5]; - wstate->hash[6] ^= state[6] ^ block[6]; - wstate->hash[7] ^= state[7] ^ block[7]; - } } - HashWhirlpool::HashWhirlpool() - { - m_state = new HashWhirlpool_state; - } - - HashWhirlpool::~HashWhirlpool() - { - delete m_state; - } - - void HashWhirlpool::Append(const UInt8* data, std::size_t len) + void WhirlpoolHash::Append(const UInt8* data, std::size_t len) { len *= 8; // Whirlpool works with bits int sourcePos = 0; /* index of leftmost source UInt8 containing data (1 to 8 bits). */ int sourceGap = (8 - (static_cast(len) & 7)) & 7; /* space on source[sourcePos]. */ - int bufferRem = m_state->bufferBits & 7; /* occupied bits on buffer[bufferPos]. */ + int bufferRem = m_bufferBits & 7; /* occupied bits on buffer[bufferPos]. */ UInt32 b; - UInt8* buffer = m_state->buffer; - UInt8* bitLength = m_state->bitLength; - std::size_t bufferBits = m_state->bufferBits; - std::size_t bufferPos = m_state->bufferPos; + UInt8* buffer = m_buffer; + UInt8* bitLength = m_bitLength; + std::size_t bufferBits = m_bufferBits; + std::size_t bufferPos = m_bufferPos; // tally the length of the added data UInt64 value = len; UInt32 carry = 0; for (int i = 31; i >= 0 && (carry != 0 || value != 0ULL); i--) { - carry += bitLength[i] + (static_cast(value) & 0xff); + carry += bitLength[i] + (static_cast(value) & 0xFF); bitLength[i] = static_cast(carry); carry >>= 8; @@ -897,8 +657,8 @@ namespace Nz { // N.B. at least source[sourcePos] and source[sourcePos+1] contain data. // take a byte from the source - b = ((data[sourcePos] << sourceGap) & 0xff) | - ((data[sourcePos + 1] & 0xff) >> (8 - sourceGap)); + b = ((data[sourcePos] << sourceGap) & 0xFF) | + ((data[sourcePos + 1] & 0xFF) >> (8 - sourceGap)); // process this byte buffer[bufferPos++] |= static_cast(b >> bufferRem); @@ -906,7 +666,7 @@ namespace Nz if (bufferBits == 512) { - processBuffer(m_state); // process data block + ProcessBuffer(); // process data block bufferBits = bufferPos = 0; // reset buffer } @@ -922,7 +682,7 @@ namespace Nz // furthermore, all data (if any is left) is in source[sourcePos]. if (len > 0) { - b = (data[sourcePos] << sourceGap) & 0xff; // bits are left-justified on b. + b = (data[sourcePos] << sourceGap) & 0xFF; // bits are left-justified on b. buffer[bufferPos] |= b >> bufferRem; // process the remaining bits } else @@ -941,7 +701,7 @@ namespace Nz // now 0 <= sourceBits < 8; furthermore, all data (if any is left) is in source[sourcePos]. if (bufferBits == 512) { - processBuffer(m_state); // process data block + ProcessBuffer(); // process data block bufferBits = bufferPos = 0; // reset buffer } @@ -949,27 +709,27 @@ namespace Nz bufferBits += len; } - m_state->bufferBits = bufferBits; - m_state->bufferPos = bufferPos; + m_bufferBits = bufferBits; + m_bufferPos = bufferPos; } - void HashWhirlpool::Begin() + void WhirlpoolHash::Begin() { - std::memset(m_state->bitLength, 0, 32); - m_state->bufferBits = m_state->bufferPos = 0; - m_state->buffer[0] = 0; // it's only necessary to cleanup buffer[bufferPos] + std::memset(m_bitLength, 0, 32); + m_bufferBits = m_bufferPos = 0; + m_buffer[0] = 0; // it's only necessary to cleanup buffer[bufferPos] for (int i = 0; i < 8; i++) - m_state->hash[i] = 0L; // initial value + m_hash[i] = 0L; // initial value } - ByteArray HashWhirlpool::End() + ByteArray WhirlpoolHash::End() { UInt8 result[64]; - UInt8 *buffer = m_state->buffer; - UInt8 *bitLength = m_state->bitLength; - std::size_t bufferBits = m_state->bufferBits; - std::size_t bufferPos = m_state->bufferPos; + UInt8 *buffer = m_buffer; + UInt8 *bitLength = m_bitLength; + std::size_t bufferBits = m_bufferBits; + std::size_t bufferPos = m_bufferPos; UInt8 *digest = result; // append a '1'-bit @@ -982,7 +742,7 @@ namespace Nz if (bufferPos < 64) std::memset(&buffer[bufferPos], 0, 64 - bufferPos); - processBuffer(m_state); // process data block + ProcessBuffer(); // process data block bufferPos = 0; // reset buffer } @@ -993,35 +753,270 @@ namespace Nz std::memcpy(&buffer[32], bitLength, 32); // append bit length of hashed data - processBuffer(m_state); // process data block + ProcessBuffer(); // process data block // return the completed message digest for (int i = 0; i < 8; i++) { - digest[0] = static_cast(m_state->hash[i] >> 56); - digest[1] = static_cast(m_state->hash[i] >> 48); - digest[2] = static_cast(m_state->hash[i] >> 40); - digest[3] = static_cast(m_state->hash[i] >> 32); - digest[4] = static_cast(m_state->hash[i] >> 24); - digest[5] = static_cast(m_state->hash[i] >> 16); - digest[6] = static_cast(m_state->hash[i] >> 8); - digest[7] = static_cast(m_state->hash[i] ); + digest[0] = static_cast(m_hash[i] >> 56); + digest[1] = static_cast(m_hash[i] >> 48); + digest[2] = static_cast(m_hash[i] >> 40); + digest[3] = static_cast(m_hash[i] >> 32); + digest[4] = static_cast(m_hash[i] >> 24); + digest[5] = static_cast(m_hash[i] >> 16); + digest[6] = static_cast(m_hash[i] >> 8); + digest[7] = static_cast(m_hash[i] ); digest += 8; } - m_state->bufferBits = bufferBits; - m_state->bufferPos = bufferPos; + m_bufferBits = bufferBits; + m_bufferPos = bufferPos; return ByteArray(&result[0], 64); } - std::size_t HashWhirlpool::GetDigestLength() const + std::size_t WhirlpoolHash::GetDigestLength() const { return 64; } - const char* HashWhirlpool::GetHashName() const + const char* WhirlpoolHash::GetHashName() const { return "Whirlpool"; } + + + void WhirlpoolHash::ProcessBuffer() + { + int i, r; + UInt64 K[8]; // the round key + UInt64 block[8]; // mu(buffer) + UInt64 state[8]; // the cipher state + UInt64 L[8]; + UInt8 *buffer = m_buffer; + + // map the buffer to a block + for (i = 0; i < 8; i++, buffer += 8) + { + block[i] = + ((static_cast(buffer[0]) ) << 56) ^ + ((static_cast(buffer[1]) & 0xFFL) << 48) ^ + ((static_cast(buffer[2]) & 0xFFL) << 40) ^ + ((static_cast(buffer[3]) & 0xFFL) << 32) ^ + ((static_cast(buffer[4]) & 0xFFL) << 24) ^ + ((static_cast(buffer[5]) & 0xFFL) << 16) ^ + ((static_cast(buffer[6]) & 0xFFL) << 8) ^ + ((static_cast(buffer[7]) & 0xFFL) ); + } + + // compute and apply K^0 to the cipher state + state[0] = block[0] ^ (K[0] = m_hash[0]); + state[1] = block[1] ^ (K[1] = m_hash[1]); + state[2] = block[2] ^ (K[2] = m_hash[2]); + state[3] = block[3] ^ (K[3] = m_hash[3]); + state[4] = block[4] ^ (K[4] = m_hash[4]); + state[5] = block[5] ^ (K[5] = m_hash[5]); + state[6] = block[6] ^ (K[6] = m_hash[6]); + state[7] = block[7] ^ (K[7] = m_hash[7]); + + // iterate over all rounds + for (r = 1; r <= R; r++) + { + // compute K^r from K^{r-1} + L[0] = + C0[static_cast(K[0] >> 56) ] ^ + C1[static_cast(K[7] >> 48) & 0xFF] ^ + C2[static_cast(K[6] >> 40) & 0xFF] ^ + C3[static_cast(K[5] >> 32) & 0xFF] ^ + C4[static_cast(K[4] >> 24) & 0xFF] ^ + C5[static_cast(K[3] >> 16) & 0xFF] ^ + C6[static_cast(K[2] >> 8) & 0xFF] ^ + C7[static_cast(K[1] ) & 0xFF] ^ + rc[r]; + + L[1] = + C0[static_cast(K[1] >> 56) ] ^ + C1[static_cast(K[0] >> 48) & 0xFF] ^ + C2[static_cast(K[7] >> 40) & 0xFF] ^ + C3[static_cast(K[6] >> 32) & 0xFF] ^ + C4[static_cast(K[5] >> 24) & 0xFF] ^ + C5[static_cast(K[4] >> 16) & 0xFF] ^ + C6[static_cast(K[3] >> 8) & 0xFF] ^ + C7[static_cast(K[2] ) & 0xFF]; + + L[2] = + C0[static_cast(K[2] >> 56) ] ^ + C1[static_cast(K[1] >> 48) & 0xFF] ^ + C2[static_cast(K[0] >> 40) & 0xFF] ^ + C3[static_cast(K[7] >> 32) & 0xFF] ^ + C4[static_cast(K[6] >> 24) & 0xFF] ^ + C5[static_cast(K[5] >> 16) & 0xFF] ^ + C6[static_cast(K[4] >> 8) & 0xFF] ^ + C7[static_cast(K[3] ) & 0xFF]; + + L[3] = + C0[static_cast(K[3] >> 56) ] ^ + C1[static_cast(K[2] >> 48) & 0xFF] ^ + C2[static_cast(K[1] >> 40) & 0xFF] ^ + C3[static_cast(K[0] >> 32) & 0xFF] ^ + C4[static_cast(K[7] >> 24) & 0xFF] ^ + C5[static_cast(K[6] >> 16) & 0xFF] ^ + C6[static_cast(K[5] >> 8) & 0xFF] ^ + C7[static_cast(K[4] ) & 0xFF]; + + L[4] = + C0[static_cast(K[4] >> 56) ] ^ + C1[static_cast(K[3] >> 48) & 0xFF] ^ + C2[static_cast(K[2] >> 40) & 0xFF] ^ + C3[static_cast(K[1] >> 32) & 0xFF] ^ + C4[static_cast(K[0] >> 24) & 0xFF] ^ + C5[static_cast(K[7] >> 16) & 0xFF] ^ + C6[static_cast(K[6] >> 8) & 0xFF] ^ + C7[static_cast(K[5] ) & 0xFF]; + + L[5] = + C0[static_cast(K[5] >> 56) ] ^ + C1[static_cast(K[4] >> 48) & 0xFF] ^ + C2[static_cast(K[3] >> 40) & 0xFF] ^ + C3[static_cast(K[2] >> 32) & 0xFF] ^ + C4[static_cast(K[1] >> 24) & 0xFF] ^ + C5[static_cast(K[0] >> 16) & 0xFF] ^ + C6[static_cast(K[7] >> 8) & 0xFF] ^ + C7[static_cast(K[6] ) & 0xFF]; + L[6] = + C0[static_cast(K[6] >> 56) ] ^ + C1[static_cast(K[5] >> 48) & 0xFF] ^ + C2[static_cast(K[4] >> 40) & 0xFF] ^ + C3[static_cast(K[3] >> 32) & 0xFF] ^ + C4[static_cast(K[2] >> 24) & 0xFF] ^ + C5[static_cast(K[1] >> 16) & 0xFF] ^ + C6[static_cast(K[0] >> 8) & 0xFF] ^ + C7[static_cast(K[7] ) & 0xFF]; + + L[7] = + C0[static_cast(K[7] >> 56) ] ^ + C1[static_cast(K[6] >> 48) & 0xFF] ^ + C2[static_cast(K[5] >> 40) & 0xFF] ^ + C3[static_cast(K[4] >> 32) & 0xFF] ^ + C4[static_cast(K[3] >> 24) & 0xFF] ^ + C5[static_cast(K[2] >> 16) & 0xFF] ^ + C6[static_cast(K[1] >> 8) & 0xFF] ^ + C7[static_cast(K[0] ) & 0xFF]; + + K[0] = L[0]; + K[1] = L[1]; + K[2] = L[2]; + K[3] = L[3]; + K[4] = L[4]; + K[5] = L[5]; + K[6] = L[6]; + K[7] = L[7]; + + // apply the r-th round transformation + L[0] = + C0[static_cast(state[0] >> 56) ] ^ + C1[static_cast(state[7] >> 48) & 0xFF] ^ + C2[static_cast(state[6] >> 40) & 0xFF] ^ + C3[static_cast(state[5] >> 32) & 0xFF] ^ + C4[static_cast(state[4] >> 24) & 0xFF] ^ + C5[static_cast(state[3] >> 16) & 0xFF] ^ + C6[static_cast(state[2] >> 8) & 0xFF] ^ + C7[static_cast(state[1] ) & 0xFF] ^ + K[0]; + + L[1] = + C0[static_cast(state[1] >> 56) ] ^ + C1[static_cast(state[0] >> 48) & 0xFF] ^ + C2[static_cast(state[7] >> 40) & 0xFF] ^ + C3[static_cast(state[6] >> 32) & 0xFF] ^ + C4[static_cast(state[5] >> 24) & 0xFF] ^ + C5[static_cast(state[4] >> 16) & 0xFF] ^ + C6[static_cast(state[3] >> 8) & 0xFF] ^ + C7[static_cast(state[2] ) & 0xFF] ^ + K[1]; + L[2] = + C0[static_cast(state[2] >> 56) ] ^ + C1[static_cast(state[1] >> 48) & 0xFF] ^ + C2[static_cast(state[0] >> 40) & 0xFF] ^ + C3[static_cast(state[7] >> 32) & 0xFF] ^ + C4[static_cast(state[6] >> 24) & 0xFF] ^ + C5[static_cast(state[5] >> 16) & 0xFF] ^ + C6[static_cast(state[4] >> 8) & 0xFF] ^ + C7[static_cast(state[3] ) & 0xFF] ^ + + K[2]; + L[3] = + C0[static_cast(state[3] >> 56) ] ^ + C1[static_cast(state[2] >> 48) & 0xFF] ^ + C2[static_cast(state[1] >> 40) & 0xFF] ^ + C3[static_cast(state[0] >> 32) & 0xFF] ^ + C4[static_cast(state[7] >> 24) & 0xFF] ^ + C5[static_cast(state[6] >> 16) & 0xFF] ^ + C6[static_cast(state[5] >> 8) & 0xFF] ^ + C7[static_cast(state[4] ) & 0xFF] ^ + K[3]; + L[4] = + C0[static_cast(state[4] >> 56) ] ^ + C1[static_cast(state[3] >> 48) & 0xFF] ^ + C2[static_cast(state[2] >> 40) & 0xFF] ^ + C3[static_cast(state[1] >> 32) & 0xFF] ^ + C4[static_cast(state[0] >> 24) & 0xFF] ^ + C5[static_cast(state[7] >> 16) & 0xFF] ^ + C6[static_cast(state[6] >> 8) & 0xFF] ^ + C7[static_cast(state[5] ) & 0xFF] ^ + K[4]; + + L[5] = + C0[static_cast(state[5] >> 56) ] ^ + C1[static_cast(state[4] >> 48) & 0xFF] ^ + C2[static_cast(state[3] >> 40) & 0xFF] ^ + C3[static_cast(state[2] >> 32) & 0xFF] ^ + C4[static_cast(state[1] >> 24) & 0xFF] ^ + C5[static_cast(state[0] >> 16) & 0xFF] ^ + C6[static_cast(state[7] >> 8) & 0xFF] ^ + C7[static_cast(state[6] ) & 0xFF] ^ + K[5]; + + L[6] = + C0[static_cast(state[6] >> 56) ] ^ + C1[static_cast(state[5] >> 48) & 0xFF] ^ + C2[static_cast(state[4] >> 40) & 0xFF] ^ + C3[static_cast(state[3] >> 32) & 0xFF] ^ + C4[static_cast(state[2] >> 24) & 0xFF] ^ + C5[static_cast(state[1] >> 16) & 0xFF] ^ + C6[static_cast(state[0] >> 8) & 0xFF] ^ + C7[static_cast(state[7] ) & 0xFF] ^ + K[6]; + + L[7] = + C0[static_cast(state[7] >> 56) ] ^ + C1[static_cast(state[6] >> 48) & 0xFF] ^ + C2[static_cast(state[5] >> 40) & 0xFF] ^ + C3[static_cast(state[4] >> 32) & 0xFF] ^ + C4[static_cast(state[3] >> 24) & 0xFF] ^ + C5[static_cast(state[2] >> 16) & 0xFF] ^ + C6[static_cast(state[1] >> 8) & 0xFF] ^ + C7[static_cast(state[0] ) & 0xFF] ^ + K[7]; + + state[0] = L[0]; + state[1] = L[1]; + state[2] = L[2]; + state[3] = L[3]; + state[4] = L[4]; + state[5] = L[5]; + state[6] = L[6]; + state[7] = L[7]; + } + + // apply the Miyaguchi-Preneel compression function + m_hash[0] ^= state[0] ^ block[0]; + m_hash[1] ^= state[1] ^ block[1]; + m_hash[2] ^= state[2] ^ block[2]; + m_hash[3] ^= state[3] ^ block[3]; + m_hash[4] ^= state[4] ^ block[4]; + m_hash[5] ^= state[5] ^ block[5]; + m_hash[6] ^= state[6] ^ block[6]; + m_hash[7] ^= state[7] ^ block[7]; + } } diff --git a/tests/Engine/Core/AlgorithmCoreTest.cpp b/tests/Engine/Core/AlgorithmCoreTest.cpp index 0e4561bf8..a64e7677f 100644 --- a/tests/Engine/Core/AlgorithmCoreTest.cpp +++ b/tests/Engine/Core/AlgorithmCoreTest.cpp @@ -2,6 +2,7 @@ #include #include #include +#include TEST_CASE("Apply", "[CORE][ALGORITHM]") { @@ -30,63 +31,47 @@ TEST_CASE("Apply", "[CORE][ALGORITHM]") TEST_CASE("ComputeHash", "[CORE][ALGORITHM]") { - /*SECTION("Compute CRC32 of '1234'") + struct Test { - auto result = Nz::ComputeHash(Nz::HashType::CRC32, "1234"); - REQUIRE(Nz::ToUpper(result.ToHex()) == "596A3B55"); - } + Nz::HashType hashType; + const char* input; + const char* expectedOutput; + }; - SECTION("Compute CRC64 of '1234'") - { - auto result = Nz::ComputeHash(Nz::HashType::CRC64, "1234"); - REQUIRE(Nz::ToUpper(result.ToHex()) == "33302B9FC23855A8"); - } + std::array tests{ + //Test{ Nz::HashType::CRC16, "Nazara Engine", "9412" }, + Test{ Nz::HashType::CRC32, "Nazara Engine", "8A2F5235" }, + Test{ Nz::HashType::CRC64, "Nazara Engine", "87211217C5FFCDDD" }, + Test{ Nz::HashType::Fletcher16, "Nazara Engine", "71D7" }, + Test{ Nz::HashType::MD5, "Nazara Engine", "71FF4EC3B56010ABC03E4B2C1C8A14B9" }, + Test{ Nz::HashType::SHA1, "Nazara Engine", "FCE7C077A1ED0881A8C60C4822BB1369B672CA5B" }, + Test{ Nz::HashType::SHA224, "Nazara Engine", "673677224E9B0D24C3828FE6CD36A37C2D43BA27C31B6E6E54756BD4" }, + Test{ Nz::HashType::SHA256, "Nazara Engine", "7E66722931B65BF780FB55D41834C3D67455029CC1CB497976D2D41A90D3FD4C" }, + Test{ Nz::HashType::SHA384, "Nazara Engine", "80064D11A4E4C2A44DE03406E03025C52641E04BA80DE78B1BB0BA6EA577B4B6914F2BDED5B95BB7285F8EA785B9B996" }, + Test{ Nz::HashType::SHA512, "Nazara Engine", "C3A8212B61B88D77E8C4B40884D49BA6A54202865CAA847F676D2EA20E60F43B1C8024DE982A214EB3670B752AF3EE37189F1EBDCA608DD0DD427D8C19371FA5" }, + Test{ Nz::HashType::Whirlpool, "Nazara Engine", "92113DC95C25057C4154E9A8B2A4C4C800D24DD22FA7D796F300AF9C4EFA4FAAB6030F66B0DC74B270A911DA18E007544B79B84440A1D58AA7C79A73C39C29F8" }, - SECTION("Compute Fletcher16 of '1234'") - { - auto result = Nz::ComputeHash(Nz::HashType::Fletcher16, "1234"); - REQUIRE(Nz::ToUpper(result.ToHex()) == "F5CA"); - }*/ + //Test{ Nz::HashType::CRC16, "The quick brown fox jumps over the lazy dog", "FCDF" }, + Test{ Nz::HashType::CRC32, "The quick brown fox jumps over the lazy dog", "414FA339" }, + Test{ Nz::HashType::CRC64, "The quick brown fox jumps over the lazy dog", "41E05242FFA9883B" }, + Test{ Nz::HashType::Fletcher16, "The quick brown fox jumps over the lazy dog", "FEE8" }, + Test{ Nz::HashType::MD5, "The quick brown fox jumps over the lazy dog", "9E107D9D372BB6826BD81D3542A419D6" }, + Test{ Nz::HashType::SHA1, "The quick brown fox jumps over the lazy dog", "2FD4E1C67A2D28FCED849EE1BB76E7391B93EB12" }, + Test{ Nz::HashType::SHA224, "The quick brown fox jumps over the lazy dog", "730E109BD7A8A32B1CB9D9A09AA2325D2430587DDBC0C38BAD911525" }, + Test{ Nz::HashType::SHA256, "The quick brown fox jumps over the lazy dog", "D7A8FBB307D7809469CA9ABCB0082E4F8D5651E46D3CDB762D02D0BF37C9E592" }, + Test{ Nz::HashType::SHA384, "The quick brown fox jumps over the lazy dog", "CA737F1014A48F4C0B6DD43CB177B0AFD9E5169367544C494011E3317DBF9A509CB1E5DC1E85A941BBEE3D7F2AFBC9B1" }, + Test{ Nz::HashType::SHA512, "The quick brown fox jumps over the lazy dog", "07E547D9586F6A73F73FBAC0435ED76951218FB7D0C8D788A309D785436BBB642E93A252A954F23912547D1E8A3B5ED6E1BFD7097821233FA0538F3DB854FEE6" }, + Test{ Nz::HashType::Whirlpool, "The quick brown fox jumps over the lazy dog", "B97DE512E91E3828B40D2B0FDCE9CEB3C4A71F9BEA8D88E75C4FA854DF36725FD2B52EB6544EDCACD6F8BEDDFEA403CB55AE31F03AD62A5EF54E42EE82C3FB35" }, + }; - SECTION("Compute MD5 of '1234'") + for (const Test& test : tests) { - auto result = Nz::ComputeHash(Nz::HashType::MD5, "1234"); - REQUIRE(Nz::ToUpper(result.ToHex()) == "81DC9BDB52D04DC20036DBD8313ED055"); - } + auto hash = Nz::AbstractHash::Get(test.hashType); - SECTION("Compute SHA1 of '1234'") - { - auto result = Nz::ComputeHash(Nz::HashType::SHA1, "1234"); - REQUIRE(Nz::ToUpper(result.ToHex()) == "7110EDA4D09E062AA5E4A390B0A572AC0D2C0220"); - } - - SECTION("Compute SHA224 of '1234'") - { - auto result = Nz::ComputeHash(Nz::HashType::SHA224, "1234"); - REQUIRE(Nz::ToUpper(result.ToHex()) == "99FB2F48C6AF4761F904FC85F95EB56190E5D40B1F44EC3A9C1FA319"); - } - - SECTION("Compute SHA256 of '1234'") - { - auto result = Nz::ComputeHash(Nz::HashType::SHA256, "1234"); - REQUIRE(Nz::ToUpper(result.ToHex()) == "03AC674216F3E15C761EE1A5E255F067953623C8B388B4459E13F978D7C846F4"); - } - - SECTION("Compute SHA384 of '1234'") - { - auto result = Nz::ComputeHash(Nz::HashType::SHA384, "1234"); - REQUIRE(Nz::ToUpper(result.ToHex()) == "504F008C8FCF8B2ED5DFCDE752FC5464AB8BA064215D9C5B5FC486AF3D9AB8C81B14785180D2AD7CEE1AB792AD44798C"); - } - - SECTION("Compute SHA512 of '1234'") - { - auto result = Nz::ComputeHash(Nz::HashType::SHA512, "1234"); - REQUIRE(Nz::ToUpper(result.ToHex()) == "D404559F602EAB6FD602AC7680DACBFAADD13630335E951F097AF3900E9DE176B6DB28512F2E000B9D04FBA5133E8B1C6E8DF59DB3A8AB9D60BE4B97CC9E81DB"); - } - - SECTION("Compute Whirlpool of '1234'") - { - auto result = Nz::ComputeHash(Nz::HashType::Whirlpool, "1234"); - REQUIRE(Nz::ToUpper(result.ToHex()) == "2F9959B230A44678DD2DC29F037BA1159F233AA9AB183CE3A0678EAAE002E5AA6F27F47144A1A4365116D3DB1B58EC47896623B92D85CB2F191705DAF11858B8"); + WHEN("We compute " << hash->GetHashName() << " of '" << test.input << '"') + { + auto result = Nz::ComputeHash(*hash, test.input); + REQUIRE(Nz::ToUpper(result.ToHex()) == test.expectedOutput); + } } }