{"id":13466213,"url":"https://github.com/vnmakarov/mum-hash","last_synced_at":"2026-03-07T00:30:57.753Z","repository":{"id":44373297,"uuid":"58295823","full_name":"vnmakarov/mum-hash","owner":"vnmakarov","description":"Hashing functions and PRNGs based on them","archived":false,"fork":false,"pushed_at":"2025-11-28T21:56:21.000Z","size":1881,"stargazers_count":166,"open_issues_count":9,"forks_count":14,"subscribers_count":11,"default_branch":"master","last_synced_at":"2025-12-01T00:45:30.238Z","etag":null,"topics":["cryptographic-hash-functions","hash-functions","mum","random-number-generators"],"latest_commit_sha":null,"homepage":"","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/vnmakarov.png","metadata":{"files":{"readme":"README.md","changelog":"ChangeLog","contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2016-05-08T04:02:51.000Z","updated_at":"2025-11-28T21:56:24.000Z","dependencies_parsed_at":"2025-03-29T02:13:28.982Z","dependency_job_id":null,"html_url":"https://github.com/vnmakarov/mum-hash","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/vnmakarov/mum-hash","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vnmakarov%2Fmum-hash","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vnmakarov%2Fmum-hash/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vnmakarov%2Fmum-hash/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vnmakarov%2Fmum-hash/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/vnmakarov","download_url":"https://codeload.github.com/vnmakarov/mum-hash/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vnmakarov%2Fmum-hash/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":30204154,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-03-06T19:07:06.838Z","status":"ssl_error","status_checked_at":"2026-03-06T18:57:34.882Z","response_time":250,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.6:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["cryptographic-hash-functions","hash-functions","mum","random-number-generators"],"created_at":"2024-07-31T15:00:41.012Z","updated_at":"2026-03-07T00:30:57.710Z","avatar_url":"https://github.com/vnmakarov.png","language":"C++","funding_links":[],"categories":["C"],"sub_categories":[],"readme":"# **Update (Nov. 28, 2025): Implemented collision attack prevention in VMUM and MUM-V3**\n* The attack is described in Issue#18\n* The code in question looks like\n```\n    state ^= _vmum (data[i] ^ _vmum_factors[i], data[i + 1] ^ _vmum_factors[i + 1]));\n```\n  It is easy to generate data which makes the 1st operand of `_vmum`\n  to be zero.  In this case whatever the second operand is, the hash\n  will be generated the same.  So an adversary can generate a lot of\n  data with the same hash\n* This is pretty common code mistake for a few fast hash-functions. At\n  least I found the same vulnerability in [wyhash](https://github.com/wangyi-fudan/wyhash/blob/46cebe9dc4e51f94d0dca287733bc5a94f76a10d/wyhash.h#L130) and [rapidhash](https://github.com/Nicoshev/rapidhash/blob/d60698faa10916879f85b2799bfdc6996b94c2b7/rapidhash.h#L383)\n* After the code change, the safe variants of VMUM and MUM hashes are\n  switched on by default.  If you want previous variants, please use\n  macros VMUM_V1 and MUM_V3 correspondingly.  I believe there are still\n  cases when they can be used, e.g. for hash tables in compilers.\n* The fix consist of checking _vmum operands on zero and use nonzero value instead\n  * all checks are implemented to avoid branch instruction generations to keep hash calculation pipeline going\n  * still the checks increase length of critical paths of calculation\n  * in most cases, new versions of VMUM and MUM generates the same hashes as the previous versions\n* The fix results in slowing down hash speeds by about **10%** according to my benchmarks\n  * I updated all benchmark data related to the new versions of VMUM and MUM below\n\t\n# MUM Hash\n* MUM hash is a **fast non-cryptographic hash function**\n  suitable for different hash table implementations\n* MUM means **MU**ltiply and **M**ix\n  * It is a name of the base transformation on which hashing is implemented\n  * Modern processors have a fast logic to do long number multiplications\n  * It is very attractive to use it for fast hashing\n    * For example, 64x64-bit multiplication can do the same work as 32\n      shifts and additions\n  * I'd like to call it Multiply and Reduce.  Unfortunately, MUR\n    (MUltiply and Rotate) is already taken for famous hashing\n    technique designed by Austin Appleby\n  * I've chosen the name also as the first release happened on Mother's day\n* To use mum you just need one header file (mum.h)\n* MUM hash passes **all** [SMHasher](https://github.com/aappleby/smhasher) tests\n  * For comparison, only 4 out of 15 non-cryptographic hash functions\n    in SMHasher passes the tests, e.g. well known FNV, Murmur2,\n    Lookup, and Superfast hashes fail the tests\n* MUM V3 hash does not pass the following tests of a more rigourous\n  version of [SMHasher](https://github.com/rurban/smhasher):\n  * It fails on Perlin noise and bad seeds tests.  It means it still\n    qualitative enough for the most applications\n  * To make MUM V3 to pass the Rurban SMHasher, macro `MUM_QUALITY` has been\n    added.  Compilation with this defined macro makes MUM V3 to pass\n    all tests of Rurban SMHasher.  The slowdown is about 5% in average\n    or 10% at most on keys of length 8.  It also results in generating\n    a target independent hash\n* For historic reasons mum.h contains code for older version V1 and\n  V2.  You can switch them on by defining macros **MUM_V1** and **MUM_V2**\n* MUM algorithm is **simpler** than the VMUM one\n* MUM is specifically **designed to be fast on 64-bit CPUs**\n  * Still MUM will work for 32-bit CPUs and it will be sometimes\n    faster than Spooky and City\n* MUM has a **fast startup**.  It is particular good to hash small keys\n  which are prevalent in hash table applications\n\n# MUM implementation details\n\n* Input 64-bit data is randomized by 64x64-\u003e128 bit multiplication and mixing\n  high- and low-parts of the multiplication result by using addition.\n  The result is mixed with the current internal state by using XOR\n  * Instead of addition for mixing high- and low- parts, XOR could be\n    used\n    * Using addition instead of XOR improves performance by about\n      10% on Haswell and Power7\n* Factor numbers, randomly generated with an equal probability of their\n  bit values, are used for the multiplication\n* When all factors are used once, the internal state is randomized, and the same\n  factors are used again for subsequent data randomization\n* The main loop is formed to be **unrolled** by the compiler to benefit from the\n  the compiler instruction scheduling optimization and OOO\n  (out-of-order) instruction execution in modern CPUs\n* MUM code does not contain assembly (asm) code anymore. This makes MUM less\n  machine-dependent.  To have efficient mum implementation, the\n  compiler should support 128-bit integer\n  extension (true for GCC and Clang on many targets)\n\n# VMUM Hash\n* VMUM is a vector variant of mum hashing (see below)\n  * It uses target SIMD instructions (insns)\n  * In comparison with mum v3, vmum considerably (up to 3 times) improves the speed\n    of hashing mid-range (32 to 256 bytes) to long-range (more 256 bytes) length keys\n  * As with previous mum hashing, to use vmum you just need one header\n    file (vmum.h)\n  * vmum source code is considerably smaller than that of extremely\n    fast xxHash3 and th1ha2 and competes with them on hashing speed\n  * vmum passes a more rigorous version of\n    [SMHasher](https://github.com/rurban/smhasher)\n   \n# VMUM implementation details\n* For long keys vmum uses vector insns:\n  * AVX2 256-bit vector insns on x86-64\n  * Neon 128-bit vector insns on aarch64\n  * Altivec 128-bit vector insns on ppc64\n  * There is a scalar emulation of the vector insns, too, for other targets\n\t* This could be useful for understanding used the vector\n      operations used\n* You can add usage of vector insns for other targets.  For this you\n    just need to add small functions `_vmum_update_block`,\n    `_vmum_zero_block`, and `_vmum_fold_block`\n  * For the beneficial usage of vector insns the target should have unsigned `32 x 32-bit -\u003e\n    64-bit` vector multiplication\n* To run vector insns in parallel on OOO CPUs, two vmum code loops are formed\n  to be **unrolled** by the compiler into one basic block\n* I experimented a lot with other vector insns and found that the usage of\n  carry-less (sometimes called polynomial) vector multiplication insns does not work\n  well enough for hashing\n\n# VMUM and MUM benchmarking vs other famous hash functions\n\n* Here are the results of benchmarking VMUM and MUM with the fastest\n  non-cryptographic hash functions I know:\n  * Google City64 (sources are taken from SMHasher)\n  * Bob Jenkins Spooky (sources are taken from SMHasher)\n  * Yann Collet's xxHash3 (sources are taken from the\n    [original repository](https://github.com/Cyan4973/xxHash))\n* I also added J. Aumasson and D. Bernstein's\n  [SipHash24](https://github.com/veorq/SipHash) for the comparison as it\n  is a popular choice for hash table implementation these days\n* A [metro hash](https://github.com/jandrewrogers/MetroHash)\n  was added as people asked and as metro hash is\n  claimed to be the fastest hash function\n    * metro hash is not portable as others functions as it does not deal\n      with the unaligned accesses problem on some targets\n    * metro hash will produce different hash for LE/BE targets\n* Measurements were done on 4 different architecture machines:\n  * AMD Ryzen 9900X\n  * Intel i5-1300K\n  * IBM Power10\n  * Apple M4 10 cores (mac mini)\n* Hashing 10,000 of 16MB keys (bulk)\n* Hashing 1,280M keys for all other length keys\n* Each test was run 3 times and the minimal time was taken\n  * GCC-14.2.1 was used on AMD and M4 machine, GCC-12.3.1 on Intel\n    machine, GCC-11.5.0 was used on Power10\n  * `-O3` was used for all compilations\n  * The keys were generated by `rand` calls\n  * The keys were aligned to see a hashing speed better and to permit runs for Metro\n  * Some people complaint that my comparison is unfair as most hash functions are not inlined\n    * I believe that the interface is the part of the implementation.  So when\n      the interface does not provide an easy way for inlining, it is an\n      implementation pitfall\n    * Still to address the complaints I added `-flto` for benchmarking all hash\n      functions excluding MUM and VMUM.  This option makes cross-file inlining\n* Here are graphs summarizing the measurements:\n\n![AMD](./benchmarks/amd.png)\n\n![INTEL](./benchmarks/intel.png)\n\n![M4](./benchmarks/m4.png)\n\n![Power10](./benchmarks/power10.png)\n\n* Exact numbers are given in the last section\n\n# SMhasher Speed Measurements\n\n* SMhasher also measures hash speeds.  It uses the CPU cycle counter (__rtdc)\n  * __rtdc-based measurements might be inaccurate for a small number of\n    executed insns as the process can migrate, not all insns can\n    retire, and CPU freq can be different.  That is why I prefer long\n    running benchmarks\n* Here are the results on AMD Ryzen 9900X for the fastest quality hashes\n  (chosen according to SMhasher bulk speed results from https://github.com/rurban/smhasher)\n* More GB/sec is better.  Less cycles/hash is better\n* Some hashes are based on the use of x86\\_64 AES insns and are less portable.\n  They are marked by \"Yes\" in the AES column \n* The SLOC column gives the source code lines to implement the hash\n  \n| Hash            | AES  | Bulk Speed (256KB): GB/s |Av. Speed on keys (1-32 bytes): cycles/hash| SLOC|\n|:----------------|:----:|-------------------------:|------------------------------------------:|----:|\n|VMUM-V2          |  -   |  103.7                   | 16.4                                      |459  |\n|VMUM-V1          |  -   |  143.5                   | 16.8                                      |459  |\n|MUM-V4           |  -   |   28.6                   | 15.8                                      |291  |\n|MUM-V3           |  -   |   40.4                   | 16.3                                      |291  |\n|xxh3             |  -   |   66.6                   | 17.6                                      |965  |\n|umash64          |  -   |   63.1                   | 25.4                                      |1097 |\n|FarmHash32       |  -   |   39.8                   | 32.6                                      |1423 |\n|wyhash           |  -   |   39.3                   | 18.3                                      | 194 |\n|clhash           |  -   |   38.4                   | 51.7                                      | 366 |\n|t1ha2\\_atonce    |  -   |   34.7                   | 25.5                                      |2262 |\n|t1ha0\\_aes\\_avx2 | Yes  |  128.9                   | 25.0                                      |2262 |\n|gxhash64         | Yes  |  197.1                   | 27.9                                      | 274 |\n|aesni            | Yes  |   38.7                   | 28.5                                      | 132 |\n\n\n# Using cryptographic vs. non-cryptographic hash function\n  * People worrying about denial attacks based on generating hash\n    collisions started to use cryptographic hash functions in hash tables\n  * Cryptographic functions are very slow\n    * *sha1* is about 20-30 times slower than MUM and City on the bulk speed tests\n    * The new fastest cryptographic hash function *SipHash* is up to 10\n      times slower\n  * MUM and VMUM are also *resistant* to preimage attack (finding a\n    key with a given hash) \n    * To make hard moving to previous state values we use mostly 1-to-1 one way\n      function `lo(x*C) + hi(x*C)` where C is a constant.  Brute force\n      solution of equation `f(x) = a` probably requires `2^63` tries.\n      Another used function equation `x ^ y = a` has a `2^64`\n      solutions.  It complicates finding the overal solution further\n  * If somebody is not convinced, you can use **randomly chosen\n    multiplication constants** (see functions `mum_hash_randomize` and\n    `vmum_hash_randomize`).\n    Finding a key with a given hash even if you know a key with such\n    a hash probably will be close to finding two or more solutions of\n    *Diophantine* equations\n  * If somebody is still not convinced, you can implement hash tables\n    to **recognize the attack and rebuild** the table using the MUM function\n    with the new multiplication constants\n  * Analogous approach can be used if you use weak hash function as\n    MurMur or City.  Instead of using cryptographic hash functions\n    **all the time**, hash tables can be implemented to recognize the\n    attack and rebuild the table and start using a cryptographic hash\n    function\n  * This approach solves the speed problem and permits us to switch easily to a new\n    cryptographic hash function if a flaw is found in the old one, e.g., switching from\n    SipHash to SHA2\n  \n# How to use [V]MUM\n* Please just include file `[v]mum.h` into your C/C++ program and use the following functions:\n  * optional `[v]mum_hash_randomize` for choosing multiplication constants randomly\n  * `[v]mum_hash_init`, `[v]mum_hash_step`, and `[v]mum_hash_finish` for hashing complex data structures\n  * `[v]mum_hash64` for hashing a 64-bit data\n  * `[v]mum_hash` for hashing any continuous block of data\n  * Compile `vmum.h` with other code using options switching on vector\n    insns if necessary (e.g. -mavx2 for x86\\_64)\n* To compare MUM and VMUM speed with other hash functions on your machine go to\n  the directory `benchmarks` and run a script `./bench.sh`\n* The script will compile source files and run the tests printing the\n  results as a markdown table\n\n# Crypto-hash function MUM512\n  * [V]MUM is not designed to be a crypto-hash\n    * The key (seed) and state are only 64-bit which are not crypto-level ones\n    * The result can be different for different targets (BE/LE\n      machines, 32- and 64-bit machines) as for other hash functions, e.g. City (hash can be\n      different on SSE4.2 nad non SSE4.2 targets) or Spooky (BE/LE machines)\n      * If you need the same MUM hash independent on the target, please\n        define macro `[V]MUM_TARGET_INDEPENDENT_HASH`.  Defining the\n        macro affects the performace only on big-endian targets or\n        targets without int128 support\n  * There is a variant of MUM called MUM512 which can be a **candidate**\n    for a crypto-hash function and keyed crypto-hash function and\n    might be interesting for researchers\n    * The **key** is **256**-bit\n    * The **state** and the **output** are **512**-bit\n    * The **block** size is **512**-bit\n    * It uses 128x128-\u003e256-bit multiplication which is analogous to about\n      64 shifts and additions for 128-bit block word instead of 80\n      rounds of shifts, additions, logical operations for 512-bit block\n      in sha2-512.\n  * It is **only a candidate** for a crypto hash function\n    * I did not make any differential crypto-analysis or investigated\n      probabilities of different attacks on the hash function (sorry, it\n      is too big job)\n      * I might be do this in the future as I am interested in\n        differential characteristics of the MUM512 base transformation\n        step (128x128-bit multiplications with addition of high and\n        low 128-bit parts)\n      * I am also interested in the right choice of the multiplication constants\n      * May be somebody will do the analysis.  I will be glad to hear anything.\n        Who knows, may be it can be easily broken as Nimbus cipher.\n    * The current code might be also vulnerable to timing attack on\n      systems with varying multiplication instruction latency time.\n      There is no code for now to prevent it\n  * To compare the MUM512 speed with the speed of SHA-2 (SHA512) and\n    SHA-3 (SHA3-512) go to the directory `benchmarks` and run a script `./bench-crypto.sh`\n    * SHA-2 and SHA-3 code is taken from [RHash](https://github.com/rhash/RHash.git)\n  * Blake2 crypto-hash from [github.com/BLAKE2/BLAKE2](https://github.com/BLAKE2/BLAKE2)\n    was added for comparison.  I use sse version of 64-bit Blake2 (blake2b).\n  * Here is the speed of the crypto hash functions on AMD 9900X:\n\n|                        | MUM512 | SHA2  |  SHA3  | Blake2B|\n:------------------------|-------:|------:|-------:|-------:|\n10 bytes (20 M texts)    | 0.27s  | 0.27s |  0.44s |  0.81s |\n100 bytes (20 M texts)   | 0.36s  | 0.25s |  0.84s |  0.84s |\n1000 bytes (20 M texts)  | 1.21s  | 2.08s | 5.63s  |  3.70s |\n10000 bytes (5 M texts)  | 5.60s  | 5.05s | 14.07s |  7.99s |\n\n# Pseudo-random generators\n  * Files `mum-prng.h` and `mum512-prng.h` provide pseudo-random\n    functions based on MUM and MUM512 hash functions\n  * All PRNGs passed *NIST Statistical Test Suite for Random and\n    Pseudorandom Number Generators for Cryptographic Applications*\n    (version 2.2.1) with 1000 bitstreams each containing 1M bits\n    * Although MUM PRNG passed the test, it is not a cryptographically\n      secure PRNG as is the hash function used for it\n  * To compare the PRNG speeds go to\n    the directory `benchmarks` and run a script `./bench-prng.sh`\n  * For the comparison I wrote crypto-secured Blum Blum Shub PRNG\n    (file `bbs-prng.h`) and PRNGs based on fast cryto-level hash\n    functions in ChaCha stream cipher (file `chacha-prng.h`) and\n    SipHash24 (file `sip24-prng.h`).\n    * The additional PRNGs also pass the Statistical Test Suite\n  * For the comparison I also added the fastest PRNGs\n    * [xoroshiro128+](http://xoroshiro.di.unimi.it/xoroshiro128plus.c)\n    * [xoroshiro128**](http://xoroshiro.di.unimi.it/xoroshiro128starstar.c)\n    * [xoshiro256+](http://xoroshiro.di.unimi.it/xoshiro256plus.c)\n    * [xoshiro256**](http://xoroshiro.di.unimi.it/xoshiro256starstar.c)\n    * [xoshiro512**](http://xoroshiro.di.unimi.it/xoshiro512starstar.c)\n    * As recommended the first numbers generated by splitmix64 were used as a seed\n  * I had no intention to tune MUM based PRNG first but\n    after adding xoroshiro128+ and finding how fast it is, I've decided\n    to speedup MUM PRNG\n    * I added code to calculate a few PRNs at once to calculate them in parallel\n    * I added AVX2 version functions to use the faster `MULX` instruction\n    * The new version also passed NIST Statistical Test Suite.  It was\n      tested even on bigger data (10K bitstreams each containing 10M\n      bits).  The test took several days on i7-4790K\n    * The new version is **almost 2 times** faster than the old one and MUM PRN\n      speed became almost the same as xoroshiro/xoshiro ones\n      * All xoroshiro/xoshiro and MUM PRNG functions are inlined in the benchmark program\n      * Both code without inlining will be visibly slower and the speed\n        difference will be negligible as one PRN calculation takes\n        only about **3-4 machine cycle** for xoroshiro/xoshiro and MUM PRN.\n  * **Update Nov.2 2019**: I found that MUM PRNG fails practrand on 512GB.  So I modified it.\n    Instead of basically 16 independent PRNGs with 64-bit state, I made it one PRNG with 1024-bit state.\n    I also managed to speed up MUM PRNG by 15%.\n  * All PRNG were tested by [practrand](http://pracrand.sourceforge.net/) with\n    4TB PRNG generated stream (it took a few days)\n      * **GLIBC RAND, xoroshiro128+, xoshiro256+, and xoshiro512+ failed** on the first stages of practrand\n      * The rest of the PRNGs passed\n      * BBS PRNG was tested by only 64GB stream because it is too slow\n  * Here is the speed of the PRNGs in millions generated PRNs\n    per second:\n\n|  M prns/sec  | AMD 9900X   |Intel i5-1360K| Apple M4    | Power10  |\n:--------------|------------:|-------------:|------------:|---------:|\nBBS            | 0.0886      | 0.0827       | 0.122       | 0.021    |\nChaCha         | 357.68      | 184.80       | 262.81      |  83.20   |\nSipHash24      | 702.10      | 567.43       | 760.13      | 231.48   |\nMUM512         |  91.54      | 179.62       | 268.04      |  44.28   |\nMUM            |1947.27      |1620.65       |2263.68      | 694.42   |\nXOSHIRO128**   |1797.02      |1386.87       |1095.37      | 477.67   |\nXOSHIRO256**   |1866.35      |1364.85       |1466.15      | 607.65   |\nXOSHIRO512**   |1663.86      |1235.15       |1423.90      | 631.90   |\nGLIBC RAND     | 115.57      | 101.48       | 228.99      |  33.66   |\nXOROSHIRO128+  |1786.62      |1299.59       |1296.48      | 549.85   |\nXOSHIRO256+    |2321.99      |1720.67       |1690.96      | 711.41   |\nXOSHIRO512+    |1808.81      |1525.18       |1659.76      | 717.12   |\n\n# Table results for hash speed measurements\n* Here are table variants of my measurements for people wanting the\n  exact numbers.  The tables also contain time spent for hashing.\n  \n* AMD Ryzen 9900X:\n\n| Length    |  VMUM-V2  |  VMUM-V1  |  MUM-V4   |  MUM-V3   |  Spooky   |   City    |  xxHash3  |   t1ha2   | SipHash24 |   Metro   |\n|:----------|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|\n|   3 bytes |1.00  4.57s|0.98  4.67s|0.98  4.64s|0.97  4.73s|0.76  6.01s|0.60  7.61s|0.94  4.84s|0.61  7.47s|0.61  7.51s|0.69  6.67s|\n|   4 bytes |1.00  2.77s|1.00  2.78s|1.09  2.55s|1.09  2.55s|0.55  5.08s|0.39  7.15s|0.71  3.92s|0.69  4.03s|0.44  6.24s|0.75  3.69s|\n|   5 bytes |1.00  4.63s|1.00  4.64s|1.00  4.62s|1.00  4.63s|0.80  5.78s|0.65  7.07s|0.88  5.28s|0.62  7.41s|0.61  7.59s|0.88  5.24s|\n|   6 bytes |1.00  4.57s|1.00  4.56s|1.00  4.57s|1.00  4.56s|0.77  5.93s|0.65  7.06s|0.87  5.24s|0.62  7.38s|0.58  7.87s|0.87  5.24s|\n|   7 bytes |1.00  4.84s|1.01  4.80s|1.01  4.80s|1.01  4.79s|0.79  6.15s|0.69  7.06s|0.92  5.24s|0.66  7.38s|0.60  8.10s|0.76  6.38s|\n|   8 bytes |1.00  2.74s|1.00  2.74s|1.09  2.51s|1.09  2.51s|0.54  5.03s|0.39  7.06s|0.52  5.24s|0.69  3.97s|0.33  8.29s|0.75  3.67s|\n|   9 bytes |1.00  3.01s|1.08  2.78s|1.07  2.82s|1.06  2.83s|0.59  5.06s|0.27 11.03s|0.45  6.66s|0.41  7.37s|0.36  8.29s|0.60  5.04s|\n|  10 bytes |1.00  3.01s|1.08  2.78s|1.08  2.79s|1.04  2.89s|0.59  5.08s|0.27 11.02s|0.45  6.66s|0.41  7.36s|0.36  8.34s|0.60  5.05s|\n|  11 bytes |1.00  3.01s|1.08  2.79s|1.08  2.79s|1.08  2.78s|0.59  5.08s|0.27 11.04s|0.45  6.67s|0.41  7.37s|0.36  8.32s|0.49  6.20s|\n|  12 bytes |1.00  3.01s|1.09  2.77s|1.07  2.81s|1.07  2.82s|0.59  5.06s|0.27 11.03s|0.45  6.66s|0.41  7.35s|0.36  8.30s|0.60  5.02s|\n|  13 bytes |1.00  2.98s|1.08  2.77s|1.05  2.83s|1.08  2.77s|0.59  5.02s|0.27 10.94s|0.45  6.61s|0.41  7.28s|0.36  8.21s|0.48  6.15s|\n|  14 bytes |1.00  2.96s|1.08  2.74s|1.08  2.75s|1.08  2.74s|0.59  5.01s|0.27 10.95s|0.45  6.60s|0.41  7.29s|0.36  8.21s|0.48  6.16s|\n|  15 bytes |1.00  2.98s|1.09  2.74s|1.08  2.77s|1.06  2.80s|0.59  5.01s|0.27 10.93s|0.45  6.61s|0.41  7.29s|0.36  8.21s|0.41  7.28s|\n|  16 bytes |1.00  2.98s|1.09  2.74s|1.09  2.73s|1.09  2.73s|0.27 10.94s|0.41  7.28s|0.93  3.19s|0.59  5.08s|0.29 10.31s|0.62  4.78s|\n|  32 bytes |1.00  3.28s|1.08  3.05s|1.00  3.27s|0.98  3.34s|0.30 10.95s|0.40  8.19s|1.03  3.19s|0.44  7.50s|0.23 14.39s|0.33  9.82s|\n|  64 bytes |1.00  3.89s|1.09  3.58s|0.87  4.47s|0.85  4.58s|0.23 16.63s|0.47  8.36s|1.22  3.19s|0.68  5.69s|0.17 22.59s|0.37 10.49s|\n|  96 bytes |1.00  4.55s|1.08  4.20s|0.79  5.79s|0.78  5.83s|0.20 22.31s|0.36 12.54s|1.43  3.19s|0.66  6.88s|0.15 31.11s|0.40 11.27s|\n| 128 bytes |1.00  6.32s|1.40  4.52s|0.91  6.92s|0.90  7.06s|0.23 27.99s|0.50 12.54s|1.98  3.19s|0.83  7.57s|0.16 39.35s|0.53 11.85s|\n| 192 bytes |1.00  8.55s|1.29  6.63s|0.90  9.46s|0.99  8.65s|0.36 23.81s|0.59 14.48s|1.25  6.83s|0.88  9.74s|0.15 55.96s|0.65 13.21s|\n| 256 bytes |1.00 10.98s|1.38  7.95s|0.92 11.98s|1.06 10.32s|0.45 24.22s|0.66 16.71s|0.79 13.86s|0.92 11.89s|0.15 74.12s|0.75 14.57s|\n| 512 bytes |1.00 14.42s|1.12 12.91s|0.65 22.33s|0.79 18.16s|0.41 35.30s|0.53 26.98s|0.91 15.92s|0.69 21.04s|0.10 140.39s|0.63 22.76s|\n|1024 bytes |1.00 17.13s|1.09 15.75s|0.37 46.54s|0.50 34.26s|0.32 53.76s|0.38 45.34s|0.88 19.50s|0.44 38.78s|0.06 272.94s|0.44 39.07s|\n| Bulk      |1.00  1.70s|1.36  1.25s|0.31  5.57s|0.44  3.85s|0.33  5.13s|0.34  4.94s|1.18  1.44s|0.37  4.62s|0.05 33.88s|0.40  4.26s|\n| Average   |1.00       |1.11       |0.93       |0.96       |0.50       |0.43       |0.85       |0.58       |0.31       |0.59       |\n| Geomean   |1.00       |1.10       |0.90       |0.93       |0.46       |0.41       |0.77       |0.55       |0.26       |0.56       |\n\n* Intel i5-13600K:\n\n| Length    |  VMUM-V2  |  VMUM-V1  |  MUM-V4   |  MUM-V3   |  Spooky   |   City    |  xxHash3  |   t1ha2   | SipHash24 |   Metro   |\n|:----------|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|\n|   3 bytes |1.00  4.67s|1.02  4.59s|1.03  4.53s|1.03  4.53s|0.67  6.94s|0.58  8.05s|0.93  5.03s|0.50  9.31s|0.47  9.93s|0.69  6.79s|\n|   4 bytes |1.00  4.27s|1.00  4.27s|1.06  4.02s|1.06  4.02s|0.73  5.86s|0.51  8.37s|0.75  5.70s|0.77  5.58s|0.52  8.17s|0.81  5.28s|\n|   5 bytes |1.00  4.66s|1.02  4.59s|1.03  4.53s|1.03  4.53s|0.73  6.37s|0.57  8.17s|0.82  5.70s|0.50  9.31s|0.44 10.49s|0.69  6.79s|\n|   6 bytes |1.00  4.67s|1.02  4.56s|1.03  4.53s|1.03  4.53s|0.69  6.76s|0.57  8.17s|0.82  5.69s|0.50  9.31s|0.43 10.95s|0.69  6.79s|\n|   7 bytes |1.00  4.87s|1.00  4.89s|1.01  4.83s|1.01  4.83s|0.69  7.02s|0.60  8.17s|0.85  5.70s|0.52  9.31s|0.45 10.89s|0.69  7.04s|\n|   8 bytes |1.00  4.27s|1.00  4.28s|1.55  2.76s|1.55  2.76s|0.76  5.60s|0.53  8.08s|0.75  5.69s|0.99  4.30s|0.39 10.88s|1.06  4.02s|\n|   9 bytes |1.00  4.53s|1.06  4.29s|1.50  3.02s|1.50  3.01s|0.81  5.60s|0.33 13.59s|0.53  8.58s|0.48  9.51s|0.42 10.88s|0.82  5.53s|\n|  10 bytes |1.00  4.54s|1.06  4.29s|1.50  3.02s|1.51  3.01s|0.81  5.60s|0.33 13.59s|0.53  8.58s|0.48  9.51s|0.42 10.88s|0.82  5.53s|\n|  11 bytes |1.00  4.52s|1.06  4.27s|1.50  3.02s|1.50  3.02s|0.81  5.60s|0.33 13.59s|0.53  8.58s|0.48  9.51s|0.42 10.88s|0.67  6.79s|\n|  12 bytes |1.00  4.54s|1.06  4.29s|1.50  3.02s|1.51  3.01s|0.81  5.60s|0.33 13.59s|0.53  8.58s|0.48  9.51s|0.42 10.88s|0.82  5.53s|\n|  13 bytes |1.00  4.52s|1.06  4.28s|1.49  3.03s|1.50  3.02s|0.81  5.60s|0.33 13.59s|0.53  8.59s|0.48  9.51s|0.42 10.88s|0.67  6.79s|\n|  14 bytes |1.00  4.52s|1.06  4.27s|1.49  3.03s|1.50  3.02s|0.81  5.60s|0.33 13.59s|0.53  8.59s|0.48  9.51s|0.42 10.88s|0.67  6.79s|\n|  15 bytes |1.00  4.53s|1.06  4.29s|1.50  3.02s|1.50  3.02s|0.81  5.60s|0.33 13.59s|0.53  8.58s|0.48  9.51s|0.42 10.88s|0.56  8.05s|\n|  16 bytes |1.00  4.52s|1.06  4.28s|1.50  3.02s|1.50  3.01s|0.37 12.13s|0.56  8.05s|0.89  5.07s|0.85  5.29s|0.34 13.43s|0.83  5.46s|\n|  32 bytes |1.00  4.79s|1.05  4.58s|1.30  3.69s|1.33  3.59s|0.39 12.38s|0.51  9.39s|0.94  5.10s|0.67  7.15s|0.25 18.92s|0.43 11.07s|\n|  64 bytes |1.00  5.46s|1.06  5.15s|1.14  4.78s|1.11  4.91s|0.29 18.66s|0.58  9.36s|1.06  5.13s|0.88  6.22s|0.17 31.57s|0.46 11.83s|\n|  96 bytes |1.00  6.43s|1.10  5.83s|0.84  7.68s|0.84  7.67s|0.26 25.17s|0.46 13.88s|1.23  5.23s|0.85  7.60s|0.15 42.71s|0.51 12.70s|\n| 128 bytes |1.00  7.92s|1.25  6.36s|0.84  9.42s|0.86  9.19s|0.25 31.62s|0.57 13.87s|1.51  5.24s|0.91  8.67s|0.15 53.88s|0.59 13.51s|\n| 192 bytes |1.00 11.52s|1.43  8.06s|1.05 11.02s|1.08 10.68s|0.39 29.49s|0.71 16.25s|1.23  9.34s|1.03 11.18s|0.15 76.23s|0.76 15.07s|\n| 256 bytes |1.00 14.26s|1.60  8.89s|1.04 13.65s|1.18 12.11s|0.48 29.86s|0.75 19.06s|0.91 15.64s|1.03 13.82s|0.15 97.67s|0.85 16.68s|\n| 512 bytes |1.00 15.93s|1.04 15.31s|0.62 25.67s|0.81 19.65s|0.35 45.39s|0.46 34.70s|0.96 16.68s|0.58 27.38s|0.09 186.04s|0.53 29.86s|\n|1024 bytes |1.00 20.96s|1.08 19.32s|0.42 49.61s|0.56 37.74s|0.29 71.66s|0.34 61.75s|0.84 24.92s|0.42 49.86s|0.06 362.59s|0.36 58.67s|\n| Bulk      |1.00  3.13s|1.09  2.86s|0.40  7.77s|0.61  5.17s|0.40  7.78s|0.42  7.37s|0.87  3.60s|0.49  6.38s|0.07 45.99s|0.45  6.88s|\n| Average   |1.00       |1.10       |1.15       |1.18       |0.58       |0.48       |0.83       |0.65       |0.31       |0.67       |\n| Geomean   |1.00       |1.09       |1.08       |1.13       |0.54       |0.46       |0.79       |0.62       |0.26       |0.65       |\n\n* Apple M4:\n\n| Length    |  VMUM-V2  |  VMUM-V1  |  MUM-V4   |  MUM-V3   |  Spooky   |   City    |  xxHash3  |   t1ha2   | SipHash24 |   Metro   |\n|:----------|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|\n|   3 bytes |1.00  5.15s|1.02  5.03s|1.03  5.02s|1.02  5.03s|0.69  7.50s|0.52  9.91s|0.87  5.92s|1.08  4.77s|0.51 10.01s|0.63  8.17s|\n|   4 bytes |1.00  4.70s|1.01  4.66s|1.08  4.36s|1.08  4.36s|0.69  6.78s|0.49  9.64s|0.70  6.71s|0.99  4.77s|0.52  9.03s|0.73  6.41s|\n|   5 bytes |1.00  5.05s|1.00  5.03s|1.01  5.01s|1.01  5.01s|0.71  7.08s|0.52  9.64s|0.74  6.78s|1.06  4.77s|0.49 10.38s|0.62  8.17s|\n|   6 bytes |1.00  5.15s|1.02  5.03s|1.04  4.95s|1.04  4.95s|0.69  7.49s|0.53  9.64s|0.76  6.78s|1.08  4.76s|0.49 10.51s|0.63  8.17s|\n|   7 bytes |1.00  5.52s|1.03  5.34s|1.04  5.32s|1.04  5.32s|0.71  7.82s|0.57  9.64s|0.81  6.79s|1.16  4.76s|0.51 10.77s|0.65  8.46s|\n|   8 bytes |1.00  3.07s|1.02  3.02s|1.16  2.65s|1.16  2.65s|0.47  6.49s|0.32  9.64s|0.46  6.71s|0.68  4.53s|0.26 11.69s|0.66  4.66s|\n|   9 bytes |1.00  3.26s|1.07  3.04s|1.03  3.17s|1.03  3.18s|0.50  6.48s|0.27 11.96s|0.56  5.85s|0.55  5.98s|0.28 11.69s|0.51  6.41s|\n|  10 bytes |1.00  3.27s|1.08  3.03s|1.08  3.02s|1.08  3.02s|0.50  6.48s|0.27 11.96s|0.56  5.85s|0.55  5.98s|0.28 11.69s|0.51  6.41s|\n|  11 bytes |1.00  3.38s|1.10  3.07s|1.11  3.05s|1.07  3.15s|0.52  6.48s|0.28 11.96s|0.58  5.85s|0.57  5.98s|0.29 11.69s|0.43  7.87s|\n|  12 bytes |1.00  3.39s|1.08  3.13s|1.13  3.00s|1.13  3.00s|0.52  6.48s|0.28 11.96s|0.58  5.85s|0.57  5.98s|0.29 11.69s|0.53  6.41s|\n|  13 bytes |1.00  3.33s|1.08  3.08s|1.10  3.04s|1.10  3.04s|0.51  6.48s|0.28 11.95s|0.57  5.85s|0.56  5.98s|0.28 11.69s|0.42  7.87s|\n|  14 bytes |1.00  3.31s|1.09  3.05s|1.10  3.02s|1.09  3.03s|0.51  6.48s|0.28 11.96s|0.56  5.86s|0.55  5.98s|0.28 11.69s|0.42  7.87s|\n|  15 bytes |1.00  3.32s|1.06  3.12s|1.08  3.07s|1.08  3.07s|0.51  6.48s|0.28 11.96s|0.57  5.85s|0.56  5.98s|0.28 11.69s|0.36  9.33s|\n|  16 bytes |1.00  3.30s|1.10  3.00s|1.07  3.07s|1.07  3.08s|0.23 14.08s|0.35  9.33s|0.85  3.87s|0.55  5.98s|0.23 14.58s|0.54  6.12s|\n|  32 bytes |1.00  3.66s|1.07  3.42s|1.01  3.64s|1.00  3.65s|0.26 14.07s|0.35 10.51s|0.96  3.80s|0.41  9.03s|0.18 20.66s|0.29 12.57s|\n|  64 bytes |1.00  4.42s|1.09  4.07s|0.89  4.99s|0.89  4.99s|0.21 21.37s|0.41 10.84s|1.17  3.79s|0.62  7.11s|0.13 33.90s|0.33 13.44s|\n|  96 bytes |1.00  5.16s|1.07  4.82s|0.82  6.27s|0.84  6.17s|0.18 28.70s|0.32 16.19s|1.36  3.80s|0.60  8.57s|0.11 45.54s|0.36 14.34s|\n| 128 bytes |1.00  6.87s|1.13  6.08s|0.91  7.55s|0.93  7.40s|0.19 35.99s|0.42 16.19s|1.81  3.80s|0.72  9.53s|0.12 59.49s|0.45 15.22s|\n| 192 bytes |1.00  8.65s|1.12  7.69s|0.82 10.60s|0.88  9.86s|0.27 31.55s|0.46 18.64s|0.88  9.86s|0.71 12.16s|0.10 84.13s|0.51 16.99s|\n| 256 bytes |1.00  9.39s|1.30  7.20s|0.71 13.24s|0.76 12.29s|0.29 32.11s|0.44 21.28s|0.71 13.19s|0.63 14.87s|0.09 106.82s|0.50 18.77s|\n| 512 bytes |1.00 14.79s|1.07 13.76s|0.69 21.33s|0.92 15.99s|0.29 50.41s|0.40 37.15s|0.91 16.28s|0.49 30.25s|0.07 204.80s|0.46 31.88s|\n|1024 bytes |1.00 27.83s|1.56 17.79s|0.65 43.07s|1.04 26.70s|0.35 78.46s|0.44 62.77s|1.14 24.39s|0.51 54.28s|0.07 399.61s|0.55 50.90s|\n| Bulk      |1.00  3.45s|1.39  2.49s|0.58  6.00s|1.13  3.06s|0.44  7.83s|0.51  6.70s|1.19  2.89s|0.54  6.36s|0.07 50.68s|0.67  5.13s|\n| Average   |1.00       |1.11       |0.96       |1.02       |0.45       |0.39       |0.84       |0.68       |0.26       |0.51       |\n| Geomean   |1.00       |1.10       |0.95       |1.01       |0.41       |0.38       |0.79       |0.66       |0.21       |0.50       |\n\n* IBM Power10:\n\n| Length    |  VMUM-V2  |  VMUM-V1  |  MUM-V4   |  MUM-V3   |  Spooky   |   City    |  xxHash3  |   t1ha2   | SipHash24 |   Metro   |\n|:----------|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|:---------:|\n|   3 bytes |1.00 11.52s|1.00 11.53s|1.03 11.18s|1.03 11.21s|0.68 16.87s|0.61 18.95s|0.95 12.16s|1.09 10.57s|0.52 22.13s|0.66 17.35s|\n|   4 bytes |1.00 10.86s|1.00 10.87s|1.07 10.19s|1.07 10.19s|0.72 15.18s|0.54 20.22s|0.89 12.27s|1.03 10.58s|0.51 21.13s|0.88 12.40s|\n|   5 bytes |1.00 11.53s|0.98 11.73s|1.03 11.17s|1.03 11.17s|0.71 16.24s|0.55 20.91s|0.90 12.76s|1.09 10.58s|0.49 23.74s|0.66 17.35s|\n|   6 bytes |1.00 11.52s|0.98 11.73s|1.03 11.17s|1.03 11.18s|0.68 16.87s|0.55 20.92s|0.90 12.76s|1.09 10.58s|0.48 23.91s|0.66 17.36s|\n|   7 bytes |1.00 12.23s|1.02 11.96s|0.98 12.51s|1.03 11.84s|0.69 17.69s|0.58 20.92s|0.96 12.76s|1.16 10.56s|0.50 24.38s|0.56 22.01s|\n|   8 bytes |1.00 10.85s|1.00 10.86s|1.06 10.19s|1.07 10.18s|0.76 14.27s|0.52 20.92s|0.85 12.75s|1.05 10.32s|0.37 29.14s|1.10  9.86s|\n|   9 bytes |1.00 11.54s|1.06 10.87s|1.06 10.85s|1.06 10.85s|0.79 14.55s|0.40 28.92s|0.72 16.11s|0.84 13.73s|0.40 29.08s|0.84 13.80s|\n|  10 bytes |1.00 11.53s|1.06 10.87s|1.06 10.85s|1.06 10.85s|0.79 14.54s|0.40 28.92s|0.72 16.10s|0.84 13.72s|0.40 29.17s|0.84 13.79s|\n|  11 bytes |1.00 11.22s|1.03 10.87s|1.03 10.85s|1.03 10.85s|0.77 14.55s|0.39 28.90s|0.70 16.11s|0.82 13.72s|0.38 29.21s|0.66 17.08s|\n|  12 bytes |1.00 11.53s|1.06 10.86s|1.06 10.86s|1.06 10.85s|0.79 14.54s|0.40 28.92s|0.72 16.11s|0.84 13.72s|0.40 29.13s|0.84 13.80s|\n|  13 bytes |1.00 11.23s|1.03 10.87s|1.04 10.85s|1.04 10.85s|0.77 14.56s|0.39 28.91s|0.70 16.11s|0.82 13.72s|0.39 29.14s|0.66 17.09s|\n|  14 bytes |1.00 11.23s|1.03 10.88s|1.03 10.87s|1.04 10.84s|0.77 14.55s|0.39 28.92s|0.70 16.11s|0.82 13.71s|0.38 29.20s|0.66 17.09s|\n|  15 bytes |1.00 11.53s|1.06 10.88s|1.06 10.89s|1.06 10.89s|0.79 14.56s|0.40 28.91s|0.72 16.11s|0.84 13.72s|0.40 29.17s|0.57 20.38s|\n|  16 bytes |1.00 12.20s|1.12 10.91s|1.12 10.85s|1.12 10.89s|0.44 27.70s|0.61 20.05s|1.36  8.96s|0.89 13.72s|0.31 39.95s|1.00 12.16s|\n|  32 bytes |1.00 12.92s|1.11 11.59s|1.06 12.22s|1.06 12.22s|0.45 28.63s|0.58 22.34s|1.57  8.23s|0.64 20.32s|0.24 54.90s|0.52 24.97s|\n|  64 bytes |1.00 14.54s|1.11 13.09s|0.97 15.02s|0.96 15.07s|0.35 41.29s|0.62 23.31s|1.70  8.54s|0.90 16.20s|0.16 88.17s|0.54 26.78s|\n|  96 bytes |1.00 15.93s|1.13 14.07s|0.82 19.44s|0.96 16.64s|0.29 54.32s|0.45 35.33s|1.93  8.24s|0.81 19.57s|0.13 119.66s|0.55 28.81s|\n| 128 bytes |1.00 16.71s|1.08 15.47s|0.75 22.21s|0.86 19.52s|0.24 68.72s|0.47 35.31s|2.03  8.22s|0.77 21.78s|0.11 156.55s|0.54 30.78s|\n| 192 bytes |1.00 21.98s|1.16 18.99s|0.83 26.51s|0.83 26.60s|0.36 60.97s|0.53 41.32s|0.76 28.78s|0.76 29.01s|0.11 195.56s|0.62 35.17s|\n| 256 bytes |1.00 22.31s|1.25 17.89s|0.73 30.47s|0.76 29.34s|0.36 62.61s|0.47 47.41s|0.67 33.50s|0.64 35.02s|0.09 252.22s|0.57 39.10s|\n| 512 bytes |1.00 33.65s|1.19 28.16s|0.71 47.60s|0.74 45.60s|0.33 100.76s|0.46 73.34s|0.73 46.38s|0.56 60.20s|0.07 483.42s|0.60 55.93s|\n|1024 bytes |1.00 56.70s|1.41 40.15s|0.69 81.61s|0.73 78.10s|0.34 167.11s|0.45 126.45s|0.80 70.61s|0.49 116.16s|0.06 944.76s|0.45 127.01s|\n| Bulk      |1.00  6.75s|1.42  4.75s|0.70  9.62s|0.67 10.01s|0.38 17.80s|0.49 13.74s|0.93  7.27s|0.49 13.91s|0.06 118.69s|0.46 14.52s|\n| Average   |1.00       |1.10       |0.95       |0.97       |0.58       |0.49       |1.00       |0.84       |0.30       |0.67       |\n| Geomean   |1.00       |1.09       |0.94       |0.96       |0.54       |0.48       |0.93       |0.82       |0.24       |0.65       |\n\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fvnmakarov%2Fmum-hash","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fvnmakarov%2Fmum-hash","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fvnmakarov%2Fmum-hash/lists"}