rodecomp/Source/Utility/Hash/XxHash3.cpp

#include "Utility/Hash/XxHash3.h"

#include <cstddef>
#include <cstdint>
#include <cstring>
#include <emmintrin.h>
#include <intrin.h>

#define XXH_swap32 _byteswap_ulong
#define XXH_swap64 _byteswap_uint64
#define XXH_rotl32 _rotl
#define XXH_rotl64 _rotl64
#define XXH_mult32to64(x, y) __emulu(static_cast<unsigned>(x), static_cast<unsigned>(y))

// GLOBAL: gl_24486
alignas(64) static const unsigned char kSecret[192] = {
    0xb8, 0xfe, 0x6c, 0x39, 0x23, 0xa4, 0x4b, 0xbe, 0x7c, 0x01, 0x81, 0x2c, 0xf7, 0x21, 0xad, 0x1c,
    0xde, 0xd4, 0x6d, 0xe9, 0x83, 0x90, 0x97, 0xdb, 0x72, 0x40, 0xa4, 0xa4, 0xb7, 0xb3, 0x67, 0x1f,
    0xcb, 0x79, 0xe6, 0x4e, 0xcc, 0xc0, 0xe5, 0x78, 0x82, 0x5a, 0xd0, 0x7d, 0xcc, 0xff, 0x72, 0x21,
    0xb8, 0x08, 0x46, 0x74, 0xf7, 0x43, 0x24, 0x8e, 0xe0, 0x35, 0x90, 0xe6, 0x81, 0x3a, 0x26, 0x4c,
    0x3c, 0x28, 0x52, 0xbb, 0x91, 0xc3, 0x00, 0xcb, 0x88, 0xd0, 0x65, 0x8b, 0x1b, 0x53, 0x2e, 0xa3,
    0x71, 0x64, 0x48, 0x97, 0xa2, 0x0d, 0xf9, 0x4e, 0x38, 0x19, 0xef, 0x46, 0xa9, 0xde, 0xac, 0xd8,
    0xa8, 0xfa, 0x76, 0x3f, 0xe3, 0x9c, 0x34, 0x3f, 0xf9, 0xdc, 0xbb, 0xc7, 0xc7, 0x0b, 0x4f, 0x1d,
    0x8a, 0x51, 0xe0, 0x4b, 0xcd, 0xb4, 0x59, 0x31, 0xc8, 0x9f, 0x7e, 0xc9, 0xd9, 0x78, 0x73, 0x64,
    0xea, 0xc5, 0xac, 0x83, 0x34, 0xd3, 0xeb, 0xc3, 0xc5, 0x81, 0xa0, 0xff, 0xfa, 0x13, 0x63, 0xeb,
    0x17, 0x0d, 0xdd, 0x51, 0xb7, 0xf0, 0xda, 0x49, 0xd3, 0x16, 0x55, 0x26, 0x29, 0xd4, 0x68, 0x9e,
    0x2b, 0x16, 0xbe, 0x58, 0x7d, 0x47, 0xa1, 0xfc, 0x8f, 0xf8, 0xb8, 0xd1, 0x7a, 0xd0, 0x31, 0xce,
    0x45, 0xcb, 0x3a, 0x8f, 0x95, 0x16, 0x04, 0x28, 0xaf, 0xd7, 0xfb, 0xca, 0xbb, 0x4b, 0x40, 0x7e,
};

namespace {
  constexpr std::uint32_t XXH_PRIME32_1 = 0x9E3779B1U;
  constexpr std::uint32_t XXH_PRIME32_2 = 0x85EBCA77U;
  constexpr std::uint32_t XXH_PRIME32_3 = 0xC2B2AE3DU;

  constexpr std::uint64_t XXH_PRIME64_1 = 0x9E3779B185EBCA87ULL;
  constexpr std::uint64_t XXH_PRIME64_2 = 0xC2B2AE3D27D4EB4FULL;
  constexpr std::uint64_t XXH_PRIME64_3 = 0x165667B19E3779F9ULL;
  constexpr std::uint64_t XXH_PRIME64_4 = 0x85EBCA77C2B2AE63ULL;
  constexpr std::uint64_t XXH_PRIME64_5 = 0x27D4EB2F165667C5ULL;

  constexpr std::uint64_t XXH_PRIME_MX1 = 0x165667919E3779F9ULL;
  constexpr std::uint64_t XXH_PRIME_MX2 = 0x9FB21C651E98DF25ULL;

  constexpr std::size_t XXH_STRIPE_LEN = 64;
  constexpr std::size_t XXH_SECRET_CONSUME_RATE = 8;
  enum : std::size_t { XXH_ACC_NB = XXH_STRIPE_LEN / sizeof(std::uint64_t) };
  constexpr std::size_t XXH_SECRET_DEFAULT_SIZE = 192;
  constexpr std::size_t XXH_SECRET_SIZE_MIN = 136;
  constexpr std::size_t XXH3_MIDSIZE_MAX = 240;
  constexpr std::size_t XXH3_MIDSIZE_STARTOFFSET = 3;
  constexpr std::size_t XXH3_MIDSIZE_LASTOFFSET = 17;
  constexpr std::size_t XXH_SECRET_LASTACC_START = 7;
  constexpr std::size_t XXH_SECRET_MERGEACCS_START = 11;
  constexpr int XXH_PREFETCH_DIST = 384;

  constexpr unsigned XXH_VERSION_MAJOR = 0;
  constexpr unsigned XXH_VERSION_MINOR = 8;
  constexpr unsigned XXH_VERSION_RELEASE = 1;
  constexpr unsigned XXH_VERSION_NUMBER =
      XXH_VERSION_MAJOR * 100 * 100 + XXH_VERSION_MINOR * 100 + XXH_VERSION_RELEASE;

  using XXH3_f_accumulate_512 = void (*)(void*, const void*, const void*);
  using XXH3_f_scrambleAcc = void (*)(void*, const void*);
  using XXH3_f_initCustomSecret = void (*)(void*, std::uint64_t);
  using XXH3_hashLong64_f = std::uint64_t (*)(const void*, std::size_t, std::uint64_t, const void*, std::size_t);
  using XXH3_hashLong128_f = XXH128_hash_t (*)(const void*, std::size_t, std::uint64_t, const void*, std::size_t);

  // INLINED
  __forceinline void* MemCopy(void* dest, const void* src, std::size_t size) { return std::memcpy(dest, src, size); }

  // INLINED
  __forceinline std::uint32_t Read32(const void* data) {
    std::uint32_t value;
    MemCopy(&value, data, sizeof(value));
    return value;
  }

  // INLINED
  __forceinline std::uint64_t Read64(const void* data) {
    std::uint64_t value;
    MemCopy(&value, data, sizeof(value));
    return value;
  }

  // INLINED
  __forceinline std::uint32_t ReadLE32(const void* data) { return Read32(data); }

  // INLINED
  __forceinline std::uint64_t ReadLE64(const void* data) { return Read64(data); }

  // INLINED
  __forceinline std::uint32_t ReadLE32Align(const void* data, XXH_alignment alignment) {
    if (alignment == XXH_unaligned) {
      return ReadLE32(data);
    } else {
      return *static_cast<const std::uint32_t*>(data);
    }
  }

  // INLINED
  __forceinline std::uint64_t ReadLE64Align(const void* data, XXH_alignment alignment) {
    if (alignment == XXH_unaligned) {
      return ReadLE64(data);
    } else {
      return *static_cast<const std::uint64_t*>(data);
    }
  }

  // INLINED
  __forceinline std::uint64_t Xorshift64(std::uint64_t value, int bits) { return value ^ (value >> bits); }

  // INLINED
  __forceinline XXH128_hash_t Mult64To128(std::uint64_t lhs, std::uint64_t rhs) {
    std::uint64_t const loLo = XXH_mult32to64(lhs & 0xFFFFFFFF, rhs & 0xFFFFFFFF);
    std::uint64_t const hiLo = XXH_mult32to64(lhs >> 32, rhs & 0xFFFFFFFF);
    std::uint64_t const loHi = XXH_mult32to64(lhs & 0xFFFFFFFF, rhs >> 32);
    std::uint64_t const hiHi = XXH_mult32to64(lhs >> 32, rhs >> 32);

    std::uint64_t const cross = (loLo >> 32) + (hiLo & 0xFFFFFFFF) + loHi;
    std::uint64_t const upper = (hiLo >> 32) + (cross >> 32) + hiHi;
    std::uint64_t const lower = (cross << 32) | (loLo & 0xFFFFFFFF);

    XXH128_hash_t r128;
    r128.low64 = lower;
    r128.high64 = upper;
    return r128;
  }

  // INLINED
  __forceinline std::uint64_t Mul128Fold64(std::uint64_t lhs, std::uint64_t rhs) {
    XXH128_hash_t product = Mult64To128(lhs, rhs);
    return product.low64 ^ product.high64;
  }

  // INLINED
  __forceinline std::uint64_t Avalanche64b3(std::uint64_t hash) {
    hash = Xorshift64(hash, 37);
    hash *= XXH_PRIME_MX1;
    hash = Xorshift64(hash, 32);
    return hash;
  }

  // INLINED
  __forceinline std::uint64_t Len1to3_64b(const std::uint8_t* input, std::size_t length, const std::uint8_t* secret,
                                          std::uint64_t seed) {
    std::uint8_t const c1 = input[0];
    std::uint8_t const c2 = input[length >> 1];
    std::uint8_t const c3 = input[length - 1];
    std::uint32_t const combined = (static_cast<std::uint32_t>(c1) << 16) | (static_cast<std::uint32_t>(c2) << 24) |
                                   (static_cast<std::uint32_t>(c3) << 0) |
                                   (static_cast<std::uint32_t>(length) << 8);
    std::uint64_t const bitflip = (ReadLE32(secret) ^ ReadLE32(secret + 4)) + seed;
    std::uint64_t const keyed = static_cast<std::uint64_t>(combined) ^ bitflip;
    return XXH64_avalanche(keyed);
  }

  // INLINED
  __forceinline std::uint64_t Len4to8_64b(const std::uint8_t* input, std::size_t length, const std::uint8_t* secret,
                                          std::uint64_t seed) {
    seed ^= static_cast<std::uint64_t>(XXH_swap32(static_cast<std::uint32_t>(seed))) << 32;
    std::uint32_t const input1 = ReadLE32(input);
    std::uint32_t const input2 = ReadLE32(input + length - 4);
    std::uint64_t const bitflip = (ReadLE64(secret + 8) ^ ReadLE64(secret + 16)) - seed;
    std::uint64_t const input64 = input2 + (static_cast<std::uint64_t>(input1) << 32);
    std::uint64_t const keyed = input64 ^ bitflip;
    return XXH3_rrmxmx(keyed, length);
  }

  // INLINED
  __forceinline std::uint64_t Len9to16_64b(const std::uint8_t* input, std::size_t length, const std::uint8_t* secret,
                                           std::uint64_t seed) {
    std::uint64_t const bitflip1 = (ReadLE64(secret + 24) ^ ReadLE64(secret + 32)) + seed;
    std::uint64_t const bitflip2 = (ReadLE64(secret + 40) ^ ReadLE64(secret + 48)) - seed;
    std::uint64_t const inputLo = ReadLE64(input) ^ bitflip1;
    std::uint64_t const inputHi = ReadLE64(input + length - 8) ^ bitflip2;
    std::uint64_t const acc = length + XXH_swap64(inputLo) + inputHi + Mul128Fold64(inputLo, inputHi);
    return Avalanche64b3(acc);
  }

  // INLINED
  __forceinline std::uint64_t Len0to16_64b(const std::uint8_t* input, std::size_t length, const std::uint8_t* secret,
                                           std::uint64_t seed) {
    if (length > 8) return Len9to16_64b(input, length, secret, seed);
    if (length >= 4) return Len4to8_64b(input, length, secret, seed);
    if (length) return Len1to3_64b(input, length, secret, seed);
    return XXH64_avalanche(seed ^ (ReadLE64(secret + 56) ^ ReadLE64(secret + 64)));
  }

  // INLINED
  __forceinline std::uint64_t Mix16B(const std::uint8_t* input, const std::uint8_t* secret, std::uint64_t seed) {
    std::uint64_t const inputLo = ReadLE64(input);
    std::uint64_t const inputHi = ReadLE64(input + 8);
    std::uint64_t const secretHi = ReadLE64(secret + 8);
    std::uint64_t const secretLo = ReadLE64(secret);
    return Mul128Fold64(inputLo ^ (secretLo + seed), inputHi ^ (secretHi - seed));
  }

  // INLINED
  __forceinline std::uint64_t Len17to128_64b(const std::uint8_t* input, std::size_t length, const std::uint8_t* secret,
                                             std::size_t secretSize, std::uint64_t seed) {
    (void)secretSize;
    std::uint64_t acc = length * XXH_PRIME64_1;
    if (length > 32) {
      if (length > 64) {
        if (length > 96) {
          acc += Mix16B(input + 48, secret + 96, seed);
          acc += Mix16B(input + length - 64, secret + 112, seed);
        }
        acc += Mix16B(input + 32, secret + 64, seed);
        acc += Mix16B(input + length - 48, secret + 80, seed);
      }
      acc += Mix16B(input + 16, secret + 32, seed);
      acc += Mix16B(input + length - 32, secret + 48, seed);
    }
    acc += Mix16B(input + 0, secret + 0, seed);
    acc += Mix16B(input + length - 16, secret + 16, seed);
    return Avalanche64b3(acc);
  }

  // INLINED
  __forceinline void Accumulate512(void* acc, const void* input, const void* secret) {
    __m128i* const xacc = static_cast<__m128i*>(acc);
    const __m128i* const xinput = static_cast<const __m128i*>(input);
    const __m128i* const xsecret = static_cast<const __m128i*>(secret);

    std::size_t i;
    for (i = 0; i < XXH_STRIPE_LEN / sizeof(__m128i); i++) {
      __m128i const accVec = xacc[i];
      __m128i const dataVec = _mm_loadu_si128(xinput + i);
      __m128i const keyVec = _mm_loadu_si128(xsecret + i);
      __m128i const dataKey = _mm_xor_si128(dataVec, keyVec);
      __m128i const dataKeyLo = _mm_shuffle_epi32(dataKey, _MM_SHUFFLE(0, 3, 0, 1));
      __m128i const product = _mm_mul_epu32(dataKey, dataKeyLo);
      __m128i const dataSwap = _mm_shuffle_epi32(dataVec, _MM_SHUFFLE(1, 0, 3, 2));
      __m128i const sum = _mm_add_epi64(accVec, dataSwap);
      xacc[i] = _mm_add_epi64(product, sum);
    }
  }

  // INLINED
  __forceinline void ScrambleAcc(void* acc, const void* secret) {
    __m128i* const xacc = static_cast<__m128i*>(acc);
    const __m128i* const xsecret = static_cast<const __m128i*>(secret);
    const __m128i prime32 = _mm_set1_epi32(static_cast<int>(XXH_PRIME32_1));

    std::size_t i;
    for (i = 0; i < XXH_STRIPE_LEN / sizeof(__m128i); i++) {
      __m128i const accVec = xacc[i];
      __m128i const shifted = _mm_srli_epi64(accVec, 47);
      __m128i const dataVec = _mm_xor_si128(accVec, shifted);
      __m128i const keyVec = _mm_loadu_si128(xsecret + i);
      __m128i const dataKey = _mm_xor_si128(dataVec, keyVec);
      __m128i const dataKeyHi = _mm_shuffle_epi32(dataKey, _MM_SHUFFLE(0, 3, 0, 1));
      __m128i const prodLo = _mm_mul_epu32(dataKey, prime32);
      __m128i const prodHi = _mm_mul_epu32(dataKeyHi, prime32);
      xacc[i] = _mm_add_epi64(prodLo, _mm_slli_epi64(prodHi, 32));
    }
  }

  // INLINED
  __forceinline void InitCustomSecret(void* customSecret, std::uint64_t seed64) {
    int const nbRounds = XXH_SECRET_DEFAULT_SIZE / sizeof(__m128i);
    __m128i const seed = _mm_set_epi64x(static_cast<long long>(0U - seed64), static_cast<long long>(seed64));
    int i;

    const void* const src16 = kSecret;
    __m128i* dst16 = static_cast<__m128i*>(customSecret);

    for (i = 0; i < nbRounds; ++i) {
      dst16[i] = _mm_add_epi64(_mm_load_si128(static_cast<const __m128i*>(src16) + i), seed);
    }
  }

  // INLINED
  __forceinline void Accumulate(std::uint64_t* acc, const std::uint8_t* input, const std::uint8_t* secret,
                                std::size_t nbStripes, XXH3_f_accumulate_512 f_acc512) {
    (void)f_acc512;
    std::size_t n;
    for (n = 0; n < nbStripes; n++) {
      const std::uint8_t* const in = input + n * XXH_STRIPE_LEN;
      _mm_prefetch(reinterpret_cast<const char*>(in + XXH_PREFETCH_DIST), _MM_HINT_T0);
      Accumulate512(acc, in, secret + n * XXH_SECRET_CONSUME_RATE);
    }
  }

  // INLINED
  __forceinline void HashLongInternalLoop(std::uint64_t* acc, const std::uint8_t* input, std::size_t length,
                                          const std::uint8_t* secret, std::size_t secretSize,
                                          XXH3_f_accumulate_512 f_acc512, XXH3_f_scrambleAcc f_scramble) {
    (void)f_scramble;
    std::size_t const nbStripesPerBlock = (secretSize - XXH_STRIPE_LEN) / XXH_SECRET_CONSUME_RATE;
    std::size_t const blockLength = XXH_STRIPE_LEN * nbStripesPerBlock;
    std::size_t const nbBlocks = (length - 1) / blockLength;

    std::size_t n;

    for (n = 0; n < nbBlocks; n++) {
      Accumulate(acc, input + n * blockLength, secret, nbStripesPerBlock, f_acc512);
      ScrambleAcc(acc, secret + secretSize - XXH_STRIPE_LEN);
    }

    std::size_t const nbStripes = ((length - 1) - (blockLength * nbBlocks)) / XXH_STRIPE_LEN;
    Accumulate(acc, input + nbBlocks * blockLength, secret, nbStripes, f_acc512);

    const std::uint8_t* const lastStripe = input + length - XXH_STRIPE_LEN;
    Accumulate512(acc, lastStripe, secret + secretSize - XXH_STRIPE_LEN - XXH_SECRET_LASTACC_START);
  }

  // INLINED
  __forceinline std::uint64_t Mix2Accs(const std::uint64_t* acc, const std::uint8_t* secret) {
    std::uint64_t const secretHi = ReadLE64(secret + 8);
    std::uint64_t const secretLo = ReadLE64(secret);
    return Mul128Fold64(acc[0] ^ secretLo, acc[1] ^ secretHi);
  }

  // INLINED
  __forceinline std::uint64_t HashLong64bInternal(const void* input, std::size_t length, const void* secret,
                                                  std::size_t secretSize, XXH3_f_accumulate_512 f_acc512,
                                                  XXH3_f_scrambleAcc f_scramble) {
    __declspec(align(16)) std::uint64_t acc[XXH_ACC_NB] = {XXH_PRIME32_3, XXH_PRIME64_1, XXH_PRIME64_2, XXH_PRIME64_3,
                                                           XXH_PRIME64_4, XXH_PRIME32_2, XXH_PRIME64_5, XXH_PRIME32_1};

    HashLongInternalLoop(acc, static_cast<const std::uint8_t*>(input), length, static_cast<const std::uint8_t*>(secret),
                         secretSize, f_acc512, f_scramble);

    return XXH3_mergeAccs(acc, static_cast<const std::uint8_t*>(secret) + XXH_SECRET_MERGEACCS_START,
                          static_cast<std::uint64_t>(length) * XXH_PRIME64_1);
  }

  // INLINED
  __forceinline std::uint64_t HashLong64bWithSecret(const void* input, std::size_t length, std::uint64_t seed,
                                                    const void* secret, std::size_t secretSize) {
    (void)seed;
    return HashLong64bInternal(input, length, secret, secretSize, Accumulate512, ScrambleAcc);
  }

  // INLINED
  __forceinline std::uint64_t HashLong64bWithSeedInternal(const void* input, std::size_t length, std::uint64_t seed,
                                                          XXH3_f_accumulate_512 f_acc512, XXH3_f_scrambleAcc f_scramble,
                                                          XXH3_f_initCustomSecret f_initSecret) {
    if (seed == 0) return HashLong64bInternal(input, length, kSecret, sizeof(kSecret), f_acc512, f_scramble);
    {
      __declspec(align(16)) unsigned char secret[XXH_SECRET_DEFAULT_SIZE];
      InitCustomSecret(secret, seed);
      return HashLong64bInternal(input, length, secret, sizeof(secret), f_acc512, f_scramble);
    }
  }

  // INLINED
  template <XXH3_hashLong64_f f_hashLong>
  __forceinline std::uint64_t Hash64bitsInternal(const void* input, std::size_t length, std::uint64_t seed,
                                                 const void* secret, std::size_t secretSize) {
    if (length <= 16) {
      return Len0to16_64b(static_cast<const std::uint8_t*>(input), length, static_cast<const std::uint8_t*>(secret),
                          seed);
    }
    if (length <= 128) {
      return Len17to128_64b(static_cast<const std::uint8_t*>(input), length, static_cast<const std::uint8_t*>(secret),
                            secretSize, seed);
    }
    if (length <= XXH3_MIDSIZE_MAX) {
      return XXH3_len_129to240_64b(input, length, secret, secretSize, seed);
    }
    return f_hashLong(input, length, seed, secret, secretSize);
  }

  // INLINED
  __forceinline XXH128_hash_t Len1to3_128b(const std::uint8_t* input, std::size_t length, const std::uint8_t* secret,
                                           std::uint64_t seed) {
    std::uint8_t const c1 = input[0];
    std::uint8_t const c2 = input[length >> 1];
    std::uint8_t const c3 = input[length - 1];
    std::uint32_t const combinedl = (static_cast<std::uint32_t>(c1) << 16) |
                                    (static_cast<std::uint32_t>(c2) << 24) | (static_cast<std::uint32_t>(c3) << 0) |
                                    (static_cast<std::uint32_t>(length) << 8);
    std::uint32_t const combinedh = XXH_rotl32(XXH_swap32(combinedl), 13);
    std::uint64_t const bitflipl = (ReadLE32(secret) ^ ReadLE32(secret + 4)) + seed;
    std::uint64_t const bitfliph = (ReadLE32(secret + 8) ^ ReadLE32(secret + 12)) - seed;
    std::uint64_t const keyedLo = static_cast<std::uint64_t>(combinedl) ^ bitflipl;
    std::uint64_t const keyedHi = static_cast<std::uint64_t>(combinedh) ^ bitfliph;
    XXH128_hash_t h128;
    h128.low64 = XXH64_avalanche(keyedLo);
    h128.high64 = XXH64_avalanche(keyedHi);
    return h128;
  }

  // INLINED
  __forceinline XXH128_hash_t Len4to8_128b(const std::uint8_t* input, std::size_t length, const std::uint8_t* secret,
                                           std::uint64_t seed) {
    seed ^= static_cast<std::uint64_t>(XXH_swap32(static_cast<std::uint32_t>(seed))) << 32;
    std::uint32_t const inputLo = ReadLE32(input);
    std::uint32_t const inputHi = ReadLE32(input + length - 4);
    std::uint64_t const input64 = inputLo + (static_cast<std::uint64_t>(inputHi) << 32);
    std::uint64_t const bitflip = (ReadLE64(secret + 16) ^ ReadLE64(secret + 24)) + seed;
    std::uint64_t const keyed = input64 ^ bitflip;

    XXH128_hash_t m128 = Mult64To128(keyed, XXH_PRIME64_1 + (length << 2));

    m128.high64 += (m128.low64 << 1);
    m128.low64 ^= (m128.high64 >> 3);

    m128.low64 = Xorshift64(m128.low64, 35);
    m128.low64 *= XXH_PRIME_MX2;
    m128.low64 = Xorshift64(m128.low64, 28);
    m128.high64 = Avalanche64b3(m128.high64);
    return m128;
  }

  // INLINED
  __forceinline XXH128_hash_t Len9to16_128b(const std::uint8_t* input, std::size_t length, const std::uint8_t* secret,
                                            std::uint64_t seed) {
    std::uint64_t const bitflipl = (ReadLE64(secret + 32) ^ ReadLE64(secret + 40)) - seed;
    std::uint64_t const bitfliph = (ReadLE64(secret + 48) ^ ReadLE64(secret + 56)) + seed;
    std::uint64_t const inputLo = ReadLE64(input);
    std::uint64_t inputHi = ReadLE64(input + length - 8);
    XXH128_hash_t m128 = Mult64To128(inputLo ^ inputHi ^ bitflipl, XXH_PRIME64_1);

    m128.low64 += static_cast<std::uint64_t>(length - 1) << 54;
    inputHi ^= bitfliph;
    if (sizeof(void*) < sizeof(std::uint64_t)) {
      m128.high64 += (inputHi & 0xFFFFFFFF00000000ULL) + XXH_mult32to64(static_cast<std::uint32_t>(inputHi), XXH_PRIME32_2);
    } else {
      m128.high64 += inputHi + XXH_mult32to64(static_cast<std::uint32_t>(inputHi), XXH_PRIME32_2 - 1);
    }
    m128.low64 ^= XXH_swap64(m128.high64);

    XXH128_hash_t h128 = Mult64To128(m128.low64, XXH_PRIME64_2);
    h128.high64 += m128.high64 * XXH_PRIME64_2;

    h128.low64 = Avalanche64b3(h128.low64);
    h128.high64 = Avalanche64b3(h128.high64);
    return h128;
  }

  // INLINED
  __forceinline XXH128_hash_t Len0to16_128b(const std::uint8_t* input, std::size_t length, const std::uint8_t* secret,
                                            std::uint64_t seed) {
    if (length > 8) return Len9to16_128b(input, length, secret, seed);
    if (length >= 4) return Len4to8_128b(input, length, secret, seed);
    if (length) return Len1to3_128b(input, length, secret, seed);
    XXH128_hash_t h128;
    std::uint64_t const bitflipl = ReadLE64(secret + 64) ^ ReadLE64(secret + 72);
    std::uint64_t const bitfliph = ReadLE64(secret + 80) ^ ReadLE64(secret + 88);
    h128.low64 = XXH64_avalanche(seed ^ bitflipl);
    h128.high64 = XXH64_avalanche(seed ^ bitfliph);
    return h128;
  }

  // INLINED
  __forceinline XXH128_hash_t Mix32B(XXH128_hash_t acc, const std::uint8_t* input1, const std::uint8_t* input2,
                                     const std::uint8_t* secret, std::uint64_t seed) {
    acc.low64 += Mix16B(input1, secret + 0, seed);
    acc.low64 ^= ReadLE64(input2) + ReadLE64(input2 + 8);
    acc.high64 += Mix16B(input2, secret + 16, seed);
    acc.high64 ^= ReadLE64(input1) + ReadLE64(input1 + 8);
    return acc;
  }

  // INLINED
  __forceinline XXH128_hash_t Len17to128_128b(const std::uint8_t* input, std::size_t length, const std::uint8_t* secret,
                                              std::size_t secretSize, std::uint64_t seed) {
    (void)secretSize;
    XXH128_hash_t acc;
    acc.low64 = length * XXH_PRIME64_1;
    acc.high64 = 0;
    if (length > 32) {
      if (length > 64) {
        if (length > 96) {
          acc = Mix32B(acc, input + 48, input + length - 64, secret + 96, seed);
        }
        acc = Mix32B(acc, input + 32, input + length - 48, secret + 64, seed);
      }
      acc = Mix32B(acc, input + 16, input + length - 32, secret + 32, seed);
    }
    acc = Mix32B(acc, input, input + length - 16, secret, seed);

    std::uint64_t const low64 = acc.low64 + acc.high64;
    std::uint64_t const high64 = (acc.low64 * XXH_PRIME64_1) + (acc.high64 * XXH_PRIME64_4) + ((length - seed) * XXH_PRIME64_2);
    XXH128_hash_t h128;
    h128.low64 = Avalanche64b3(low64);
    h128.high64 = static_cast<std::uint64_t>(0) - Avalanche64b3(high64);
    return h128;
  }

  // INLINED
  __forceinline XXH128_hash_t HashLong128bInternal(const void* input, std::size_t length, const std::uint8_t* secret,
                                                   std::size_t secretSize, XXH3_f_accumulate_512 f_acc512,
                                                   XXH3_f_scrambleAcc f_scramble) {
    __declspec(align(16)) std::uint64_t acc[XXH_ACC_NB] = {XXH_PRIME32_3, XXH_PRIME64_1, XXH_PRIME64_2, XXH_PRIME64_3,
                                                           XXH_PRIME64_4, XXH_PRIME32_2, XXH_PRIME64_5, XXH_PRIME32_1};

    HashLongInternalLoop(acc, static_cast<const std::uint8_t*>(input), length, secret, secretSize, f_acc512, f_scramble);

    XXH128_hash_t h128;
    h128.low64 = XXH3_mergeAccs(acc, secret + XXH_SECRET_MERGEACCS_START, static_cast<std::uint64_t>(length) * XXH_PRIME64_1);
    h128.high64 = XXH3_mergeAccs(acc, secret + secretSize - sizeof(acc) - XXH_SECRET_MERGEACCS_START,
                                 ~(static_cast<std::uint64_t>(length) * XXH_PRIME64_2));
    return h128;
  }

  // INLINED
  __forceinline XXH128_hash_t HashLong128bWithSecret(const void* input, std::size_t length, std::uint64_t seed,
                                                     const void* secret, std::size_t secretSize) {
    (void)seed;
    return HashLong128bInternal(input, length, static_cast<const std::uint8_t*>(secret), secretSize, Accumulate512, ScrambleAcc);
  }

  // INLINED
  __forceinline XXH128_hash_t HashLong128bWithSeedInternal(const void* input, std::size_t length, std::uint64_t seed,
                                                           XXH3_f_accumulate_512 f_acc512, XXH3_f_scrambleAcc f_scramble,
                                                           XXH3_f_initCustomSecret f_initSecret) {
    if (seed == 0) return HashLong128bInternal(input, length, kSecret, sizeof(kSecret), f_acc512, f_scramble);
    {
      __declspec(align(16)) unsigned char secret[XXH_SECRET_DEFAULT_SIZE];
      InitCustomSecret(secret, seed);
      return HashLong128bInternal(input, length, secret, sizeof(secret), f_acc512, f_scramble);
    }
  }

  // INLINED
  template <XXH3_hashLong128_f f_hashLong>
  __forceinline XXH128_hash_t Hash128bitsInternal(const void* input, std::size_t length, std::uint64_t seed,
                                                  const void* secret, std::size_t secretSize) {
    if (length <= 16) {
      return Len0to16_128b(static_cast<const std::uint8_t*>(input), length, static_cast<const std::uint8_t*>(secret),
                           seed);
    }
    if (length <= 128) {
      return Len17to128_128b(static_cast<const std::uint8_t*>(input), length, static_cast<const std::uint8_t*>(secret),
                             secretSize, seed);
    }
    if (length <= XXH3_MIDSIZE_MAX) {
      return XXH3_len_129to240_128b(input, length, secret, secretSize, seed);
    }
    return f_hashLong(input, length, seed, secret, secretSize);
  }
}

// OFFSET: 0x004DF8E0
// FUNCTION: fn_00182
std::uint32_t XXH_versionNumber() { return XXH_VERSION_NUMBER; }

// OFFSET: 0x004DF120
// FUNCTION: fn_00179
std::uint64_t XXH64_avalanche(std::uint64_t hash) {
  hash ^= hash >> 33;
  hash *= XXH_PRIME64_2;
  hash ^= hash >> 29;
  hash *= XXH_PRIME64_3;
  hash ^= hash >> 32;
  return hash;
}

// OFFSET: 0x004DF670
// FUNCTION: fn_00181
std::uint64_t XXH64_round(std::uint64_t acc, std::uint64_t input) {
  acc += input * XXH_PRIME64_2;
  acc = XXH_rotl64(acc, 31);
  acc *= XXH_PRIME64_1;
  return acc;
}

// OFFSET: 0x004DF400
// FUNCTION: fn_00180
std::uint64_t XXH64_finalize(std::uint64_t hash, const std::uint8_t* data, std::size_t length, XXH_alignment alignment) {
  length &= 31;

  while (length >= 8) {
    std::uint64_t const k1 = XXH64_round(0, ReadLE64Align(data, alignment));
    data += 8;
    hash ^= k1;
    hash = XXH_rotl64(hash, 27) * XXH_PRIME64_1 + XXH_PRIME64_4;
    length -= 8;
  }

  if (length >= 4) {
    hash ^= static_cast<std::uint64_t>(ReadLE32Align(data, alignment)) * XXH_PRIME64_1;
    data += 4;
    hash = XXH_rotl64(hash, 23) * XXH_PRIME64_2 + XXH_PRIME64_3;
    length -= 4;
  }

  while (length > 0) {
    hash = hash ^ ((*data++) * XXH_PRIME64_5);
    hash = XXH_rotl64(hash, 11) * XXH_PRIME64_1;
    --length;
  }

  return XXH64_avalanche(hash);
}

// OFFSET: 0x004DEC70
// FUNCTION: fn_00178
std::uint64_t XXH3_rrmxmx(std::uint64_t hash, std::uint64_t length) {
  hash ^= XXH_rotl64(hash, 49) ^ XXH_rotl64(hash, 24);
  hash *= XXH_PRIME_MX2;
  hash ^= (hash >> 35) + length;
  hash *= XXH_PRIME_MX2;
  return Xorshift64(hash, 28);
}

// OFFSET: 0x004DEAB0
// FUNCTION: fn_00176
std::uint64_t XXH3_mergeAccs(const std::uint64_t* acc, const void* secret, std::uint64_t start) {
  std::uint64_t result = start;
  const std::uint8_t* currentSecret = static_cast<const std::uint8_t*>(secret);

  for (std::size_t i = 0; i < 4; ++i) {
    result += Mix2Accs(acc + 2 * i, currentSecret + 16 * i);
  }
  return Avalanche64b3(result);
}

// OFFSET: 0x004DE830
// FUNCTION: fn_00175
std::uint64_t XXH3_len_129to240_64b(const void* data, std::size_t length, const void* secret, std::size_t secretSize,
                                    std::uint64_t seed) {
  (void)secretSize;
  const std::uint8_t* input = static_cast<const std::uint8_t*>(data);
  const std::uint8_t* secretBytes = static_cast<const std::uint8_t*>(secret);
  std::uint64_t acc = length * XXH_PRIME64_1;
  int const nbRounds = static_cast<int>(length) / 16;

  for (int i = 0; i < 8; ++i) {
    acc += Mix16B(input + (16 * i), secretBytes + (16 * i), seed);
  }
  acc = Avalanche64b3(acc);

  for (int i = 8; i < nbRounds; ++i) {
    acc += Mix16B(input + (16 * i), secretBytes + (16 * (i - 8)) + XXH3_MIDSIZE_STARTOFFSET, seed);
  }
  acc += Mix16B(input + length - 16, secretBytes + XXH_SECRET_SIZE_MIN - XXH3_MIDSIZE_LASTOFFSET, seed);
  return Avalanche64b3(acc);
}

// OFFSET: 0x004DE270
// FUNCTION: fn_00174
XXH128_hash_t XXH3_len_129to240_128b(const void* data, std::size_t length, const void* secret, std::size_t secretSize,
                                     std::uint64_t seed) {
  (void)secretSize;
  const std::uint8_t* input = static_cast<const std::uint8_t*>(data);
  const std::uint8_t* secretBytes = static_cast<const std::uint8_t*>(secret);
  XXH128_hash_t acc;
  int const nbRounds = static_cast<int>(length) / 32;

  acc.low64 = length * XXH_PRIME64_1;
  acc.high64 = 0;
  for (int i = 0; i < 4; ++i) {
    acc = Mix32B(acc, input + (32 * i), input + (32 * i) + 16, secretBytes + (32 * i), seed);
  }
  acc.low64 = Avalanche64b3(acc.low64);
  acc.high64 = Avalanche64b3(acc.high64);
  for (int i = 4; i < nbRounds; ++i) {
    acc = Mix32B(acc, input + (32 * i), input + (32 * i) + 16,
                 secretBytes + XXH3_MIDSIZE_STARTOFFSET + (32 * (i - 4)), seed);
  }
  acc = Mix32B(acc, input + length - 16, input + length - 32,
               secretBytes + XXH_SECRET_SIZE_MIN - XXH3_MIDSIZE_LASTOFFSET - 16, 0ULL - seed);

  XXH128_hash_t h128;
  h128.low64 = acc.low64 + acc.high64;
  h128.high64 = (acc.low64 * XXH_PRIME64_1) + (acc.high64 * XXH_PRIME64_4) + ((length - seed) * XXH_PRIME64_2);
  h128.low64 = Avalanche64b3(h128.low64);
  h128.high64 = static_cast<std::uint64_t>(0) - Avalanche64b3(h128.high64);
  return h128;
}

// OFFSET: 0x004DEBA0
// FUNCTION: fn_00177
void XXH3_reset_internal(XXH3_state_t* state, std::uint64_t seed, const void* secret, std::size_t secretSize) {
  std::size_t const initStart = offsetof(XXH3_state_t, bufferedSize);
  std::size_t const initLength = offsetof(XXH3_state_t, nbStripesPerBlock) - initStart;

  std::memset(reinterpret_cast<char*>(state) + initStart, 0, initLength);
  state->acc[0] = XXH_PRIME32_3;
  state->acc[1] = XXH_PRIME64_1;
  state->acc[2] = XXH_PRIME64_2;
  state->acc[3] = XXH_PRIME64_3;
  state->acc[4] = XXH_PRIME64_4;
  state->acc[5] = XXH_PRIME32_2;
  state->acc[6] = XXH_PRIME64_5;
  state->acc[7] = XXH_PRIME32_1;
  state->seed = seed;
  state->useSeed = (seed != 0);
  state->extSecret = static_cast<const unsigned char*>(secret);
  state->secretLimit = secretSize - XXH_STRIPE_LEN;
  state->nbStripesPerBlock = state->secretLimit / XXH_SECRET_CONSUME_RATE;
}

// OFFSET: 0x004DD1F0
// FUNCTION: fn_00172
__declspec(noinline) std::uint64_t XXH3_hashLong_64b_default(const void* data, std::size_t length, std::uint64_t seed,
                                                             const void* secret, std::size_t secretSize) {
  (void)seed;
  (void)secret;
  (void)secretSize;
  return HashLong64bInternal(data, length, kSecret, sizeof(kSecret), Accumulate512, ScrambleAcc);
}

// OFFSET: 0x004DDA00
// FUNCTION: fn_00173
__declspec(noinline) std::uint64_t XXH3_hashLong_64b_withSeed(const void* data, std::size_t length, std::uint64_t seed,
                                                              const void* secret, std::size_t secretSize) {
  (void)secret;
  (void)secretSize;
  return HashLong64bWithSeedInternal(data, length, seed, Accumulate512, ScrambleAcc, InitCustomSecret);
}

// OFFSET: 0x004DC090
// FUNCTION: fn_00170
__declspec(noinline) XXH128_hash_t XXH3_hashLong_128b_default(const void* data, std::size_t length, std::uint64_t seed,
                                                              const void* secret, std::size_t secretSize) {
  (void)seed;
  (void)secret;
  (void)secretSize;
  return HashLong128bInternal(data, length, kSecret, sizeof(kSecret), Accumulate512, ScrambleAcc);
}

// OFFSET: 0x004DC930
// FUNCTION: fn_00171
__declspec(noinline) XXH128_hash_t XXH3_hashLong_128b_withSeed(const void* data, std::size_t length, std::uint64_t seed,
                                                               const void* secret, std::size_t secretSize) {
  (void)secret;
  (void)secretSize;
  return HashLong128bWithSeedInternal(data, length, seed, Accumulate512, ScrambleAcc, InitCustomSecret);
}

// OFFSET: 0x004D84B0
// FUNCTION: fn_00167
std::uint64_t XXH3_64bits(const void* data, std::size_t length) {
  return Hash64bitsInternal<XXH3_hashLong_64b_default>(data, length, 0, kSecret, sizeof(kSecret));
}

// OFFSET: 0x004D9F30
// FUNCTION: fn_00168
std::uint64_t XXH3_64bits_withSecret(const void* data, std::size_t length, const void* secret, std::size_t secretSize) {
  return Hash64bitsInternal<HashLong64bWithSecret>(data, length, 0, secret, secretSize);
}

// OFFSET: 0x004DB600
// FUNCTION: fn_00169
std::uint64_t XXH3_64bits_withSeed(const void* data, std::size_t length, std::uint64_t seed) {
  return Hash64bitsInternal<XXH3_hashLong_64b_withSeed>(data, length, seed, kSecret, sizeof(kSecret));
}

// OFFSET: 0x004D3760
// FUNCTION: fn_00164
XXH128_hash_t XXH3_128bits(const void* data, std::size_t length) {
  return Hash128bitsInternal<XXH3_hashLong_128b_default>(data, length, 0, kSecret, sizeof(kSecret));
}

// OFFSET: 0x004D56F0
// FUNCTION: fn_00165
XXH128_hash_t XXH3_128bits_withSecret(const void* data, std::size_t length, const void* secret,
                                      std::size_t secretSize) {
  return Hash128bitsInternal<HashLong128bWithSecret>(data, length, 0, secret, secretSize);
}

// OFFSET: 0x004D7930
// FUNCTION: fn_00166
XXH128_hash_t XXH3_128bits_withSeed(const void* data, std::size_t length, std::uint64_t seed) {
  return Hash128bitsInternal<XXH3_hashLong_128b_withSeed>(data, length, seed, kSecret, sizeof(kSecret));
}