/* Copyright (c) 2016-2025

/* This file implements MUM (MUltiply and Mix) hashing. We randomize input data by 64x64-bit

   multiplication and mixing hi- and low-parts of the multiplication result by using an addition and

   then mix it into the current state. We use prime numbers randomly generated with the equal

   probability of their bit values for the multiplication. When all primes are used once, the state

   is randomized and the same prime numbers are used again for data randomization.

   The MUM hashing passes all SMHasher tests. Pseudo Random Number Generator based on MUM also

   passes NIST Statistical Test Suite for Random and Pseudorandom Number Generators for

   Cryptographic Applications (version 2.2.1) with 1000 bitstreams each containing 1M bits. MUM

   hashing is also faster Spooky64 and City64 on small strings (at least upto 512-bit) on Haswell

   and Power7. The MUM bulk speed (speed on very long data) is bigger than Spooky and City on

   Power7. On Haswell the bulk speed is bigger than Spooky one and close to City speed. */

#define _MUM_ATTRIBUTE_UNUSED __attribute__ ((unused))

#define _MUM_INLINE inline __attribute__ ((always_inline))

#define _MUM_INLINE inline

#endif

#if defined(MUM_QUALITY) && !defined(MUM_TARGET_INDEPENDENT_HASH)

#define MUM_TARGET_INDEPENDENT_HASH

/* Macro saying to use 128-bit integers implemented by GCC for some targets. */

/* In GCC uint128_t is defined if HOST_BITS_PER_WIDE_INT >= 64. HOST_WIDE_INT is long if

   HOST_BITS_PER_LONG > HOST_BITS_PER_INT, otherwise int. */

/* Here are different primes randomly generated with the equal probability of their bit values. They

   are used to randomize input values. */

static uint64_t _mum_primes[] = {

/* Multiply 64-bit V and P and return sum of high and low parts of the result. */

static _MUM_INLINE uint64_t _mum (uint64_t v, uint64_t p) {

  /* Implementation of 64x64->128-bit multiplication by four 32x32->64 bit multiplication. */

  uint64_t rh = hv * hp;

  uint64_t rl = lv * lp;

  /* We could ignore a carry bit here if we did not care about the same hash for 32-bit and 64-bit

     targets. */

  /* We could use XOR here too but, for some reasons, on Haswell and Power7 using an addition

     improves hashing performance by 10% for small strings. */

static _MUM_INLINE uint64_t _mum_le (uint64_t v) {

static _MUM_INLINE uint32_t _mum_le32 (uint32_t v) {

static _MUM_INLINE uint64_t _mum_le16 (uint16_t v) {

/* Macro defining how many times the most nested loop in _mum_hash_aligned will be unrolled by the

   compiler (although it can make an own decision:). Use only a constant here to help a compiler to

   unroll a major loop.

   The macro value affects the result hash for strings > 128 bit. The unroll factor greatly affects

   the hashing speed. We prefer the speed. */

#elif defined(MUM_V1) || defined(MUM_V2)

/* Rotate V left by SH. */

static _MUM_INLINE uint64_t _mum_rotl (uint64_t v, int sh) { return v << sh | v >> (64 - sh); }

#if defined(MUM_V1) || defined(MUM_V2) || !defined(MUM_QUALITY)

#define _MUM_TAIL_START(v) 0

#else

#define _MUM_TAIL_START(v) v

#endif

static _MUM_INLINE uint64_t

#if defined(__GNUC__) && !defined(__clang__)

  __attribute__ ((__optimize__ ("unroll-loops")))

#endif

  _mum_hash_aligned (uint64_t start, const void *key, size_t len) {

  while (len > _MUM_UNROLL_FACTOR * sizeof (uint64_t)) {

    /* This loop could be vectorized when we have vector insns for 64x64->128-bit multiplication.

       AVX2 currently only have vector insns for 4 32x32->64-bit multiplication and for 1

       64x64->128-bit multiplication (pclmulqdq). */

#if defined(MUM_V1) || defined(MUM_V2)

                      _mum_le (((uint64_t *) str)[i + 1]) ^ _mum_primes[i + 1]);

    /* We will use the same prime numbers on the next iterations -- randomize the state. */

#if defined(MUM_V1) || defined(MUM_V2) || !defined(MUM_QUALITY)

  for (i = 0; i < n; i++) result ^= _mum (_mum_le (((uint64_t *) str)[i]), _mum_primes[i]);

#else

    result ^= _mum (_mum_le (((uint64_t *) str)[i]) + _mum_primes[i], _mum_primes[i]);

#endif

  len -= n * sizeof (uint64_t);

  str += n * sizeof (uint64_t);

    u64 = _MUM_TAIL_START (_mum_primes[0]) + _mum_le32 (*(uint32_t *) str);

    u64 += _mum_le16 (*(uint16_t *) (str + 4)) << 32;

    u64 += (uint64_t) str[6] << 48;

    u64 = _MUM_TAIL_START (_mum_primes[1]) + _mum_le32 (*(uint32_t *) str);

    u64 += _mum_le16 (*(uint16_t *) (str + 4)) << 32;

    u64 = _MUM_TAIL_START (_mum_primes[2]) + _mum_le32 (*(uint32_t *) str);

    u64 += (uint64_t) str[4] << 32;

    u64 = _MUM_TAIL_START (_mum_primes[3]) + _mum_le32 (*(uint32_t *) str);

    u64 = _MUM_TAIL_START (_mum_primes[4]) + _mum_le16 (*(uint16_t *) str);

    u64 += (uint64_t) str[2] << 16;

    u64 = _MUM_TAIL_START (_mum_primes[5]) + _mum_le16 (*(uint16_t *) str);

    u64 = _MUM_TAIL_START (_mum_primes[6]) + str[0];

/* Final randomization of H. */

static _MUM_INLINE uint64_t _mum_final (uint64_t h) {

#if defined(MUM_V1)

#elif defined(MUM_V2)

#if defined(__x86_64__) || defined(__i386__) || defined(__PPC64__) || defined(__s390__) \

  || defined(__m32c__) || defined(cris) || defined(__CR16__) || defined(__vax__)        \

  || defined(__m68k__) || defined(__aarch64__) || defined(_M_AMD64) || defined(_M_IX86)

/* When we need an aligned access to data being hashed we move part of the unaligned data to an

   aligned block of given size and then process it, repeating processing the data by the block. */

static _MUM_INLINE uint64_t

#if defined(__x86_64__) && defined(__GNUC__) && !defined(__clang__)

  __attribute__ ((__target__ ("inline-all-stringops")))

  _mum_hash_default (const void *key, size_t len, uint64_t seed) {

      memcpy (buf, str, block_len);

static _MUM_INLINE uint64_t _mum_next_factor (void) {

  for (i = 0; i < 8; i++) start = (start << 8) | rand () % 256;

/* Set random multiplicators depending on SEED. */

static _MUM_INLINE void mum_hash_randomize (uint64_t seed) {

/* Start hashing data with SEED. Return the state. */

static _MUM_INLINE uint64_t mum_hash_init (uint64_t seed) { return seed; }

/* Process data KEY with the state H and return the updated state. */

static _MUM_INLINE uint64_t mum_hash_step (uint64_t h, uint64_t key) {

/* Return the result of hashing using the current state H. */

static _MUM_INLINE uint64_t mum_hash_finish (uint64_t h) { return _mum_final (h); }

/* Fast hashing of KEY with SEED. The hash is always the same for the same key on any target. */

static _MUM_INLINE size_t mum_hash64 (uint64_t key, uint64_t seed) {

/* Hash data KEY of length LEN and SEED. The hash depends on the target endianess and the unroll

   factor. */

static _MUM_INLINE uint64_t mum_hash (const void *key, size_t len, uint64_t seed) {