SMhasher

Alternative timings with a fast AMD EPYC 9554P 64-Core Processor (Server from 2024)

Hash function MiB/sec cycl./hash cycl./map size Quality problems
donothing32 13553281.72 4.00 - 13 test NOP
donothing64 13541357.62 4.00 - 13 test NOP
donothing128 13541295.40 4.00 - 13 test NOP
NOP_OAAT_read64 13331965.84 6.00 - 47 test NOP
BadHash 864.19 57.97 - 47 test FAIL
sumhash 24548.68 21.89 - 363 test FAIL
sumhash32 100902.82 12.90 - 863 UB, test FAIL
multiply_shift 7545.64 17.13 113.71 (1) 345 fails all tests
pair_multiply_shift 8074.03 27.09 114.46 (1) 609 fails all tests

crc32 431.31 114.96 135.40 (1) 422 insecure, 8590x collisions, distrib
md5_32 394.22 528.58 666.88 (1) 4419
md5_64 394.25 536.05 667.01 (1) 4419
md5-128 394.26 542.95 676.78 (1) 4419
sha1_32 695.43 392.33 564.22 (1) 5126 Sanity, Cyclic low32, collisions, 36.6% distrib
sha1_64 696.39 401.69 571.37 (1) 5126 Sanity, Cyclic low32, collisions, 36.6% distrib
sha1-160 695.69 454.58 610.97 (1) 5126 Comb/Cyclic low32
sha2-224 237.47 846.90 1016.77 (1) Cyclic low32
sha2-224_64 237.61 848.43 1014.99 (2) Cyclic low32
sha2-256 238.66 843.58 1007.11 (1)
sha2-256_64 237.48 846.18 1015.99 (2)
sha1ni 1830.17 145.19 264.69 (1) 989 insecure,sanity, Permutation, Zeroes, amd epyc only
sha1ni_32 1830.19 137.47 276.48 (0) 989 insecure,sanity, Permutation, Zeroes, TwoBytes, amd epyc only
sha2ni-256 1716.21 154.79 277.64 (1) 4241 insecure,sanity, Permutation, Zeroes, amd epyc only
sha2ni-256_64 1716.59 147.99 270.44 (1) 4241 insecure,sanity, Permutation, Zeroes, TwoBytes, amd epyc only
blake3_c 1801.36 315.27 445.99 (16) no 32bit portability
rmd128 355.57 550.15 704.03 (1)
rmd160 187.93 1006.90 1186.82 (2)
rmd256 394.80 503.14 656.81 (2)
edonr224 622.92 344.19 468.41 (1)
edonr256 622.52 343.77 465.60 (2)
blake2s-128 165.10 1167.72 1343.40 (1)
blake2s-160 165.01 1174.44 1362.35 (8)
blake2s-224 165.08 1175.12 1343.20 (2)
blake2s-256 165.02 1176.59 1384.37 (1)
blake2s-256_64 165.14 1180.71 1357.44 (1)
blake2b-160 282.59 1351.97 1545.04 (1)
blake2b-224 282.57 1352.01 1524.89 (2)
blake2b-256 282.41 1353.61 1536.79 (1) Sparse high 32-bit
blake2b-256_64 282.18 1408.58 1543.69 (1)
asconhashv12 194.41 675.45 705.48 (1) 6490
asconhashv12_64 194.44 323.58 330.37 (1) 4341
sha3-256 170.38 2333.11 2562.86 (18) PerlinNoise
sha3-256_64 170.43 2335.55 2564.19 (10) PerlinNoise
hasshe2 2884.74 58.16 172.95 (2) 445 Permutation,TwoBytes,Zeroes,Seed
poly_1_mersenne 1730.25 42.07 156.71 (1) 479 fails most tests
poly_2_mersenne 1730.22 49.00 161.78 (1) 479
poly_3_mersenne 1730.20 55.46 168.07 (1) 479
poly_4_mersenne 1730.17 62.80 173.56 (1) 479
tabulation32 36432.72 22.93 150.62 (1) 848 collisions
tabulation 7883.27 27.87 128.94 (1) 554
crc32_hw 9223.35 24.11 142.62 (1) 653 insecure, 100% bias, collisions, distrib, machine-specific (SSE4.2/NEON)
crc32_hw1 26518.72 30.22 139.68 (1) 671 insecure, 100% bias, collisions, distrib, machine-specific (x86 SSE4.2)
crc64_hw 9223.54 23.83 109.81 (0) 652 insecure, 100% bias, collisions, distrib, machine-specific (SSE4.2/NEON)
crc32_pclmul 11163.01 83.31 291.51 (3) 481 insecure, 100% bias, collisions, distrib, machine-specific (x86 PCLMUL)
crc64_jones1 insecure, 100% bias, collisions, distrib
crc64_jones2 insecure, 100% bias, collisions, distrib
crc64_jones3 insecure, 100% bias, collisions, distrib
crc64_jones insecure, 100% bias, collisions, distrib
o1hash 13351023.10 9.09 101.49 (1) 101 insecure, zeros, fails all tests
fibonacci 100430.65 14.91 422.62 (1) 1692 UB, zeros, fails all tests
FNV1a 863.68 59.48 132.37 (1) 204 zeros, fails all tests
FNV1A_Totenschiff 6918.90 16.80 144.67 (0) 270 UB, zeros, fails all tests
FNV1A_Pippip_Yurii 6918.75 18.20 145.23 (1) 147 UB, sanity, fails all tests
FNV1a_YT 17678.60 20.43 143.28 (1) 321 UB, fails all tests
FNV2 6919.24 22.07 92.51 (1) 278 fails all tests
FNV64 863.89 59.83 74.41 (1) 79 fails all tests
FNV128 431.31 121.85 133.73 (1) 171 fails all tests
k-hash32 14854.89 39.41 161.51 (1) 808 UB, insecure, zeros, fails all tests
k-hash64 14133.90 28.97 145.11 (1) 609 UB, insecure, zeros, fails all tests
fletcher2 24835.03 11.26 188.60 (0) 248 UB, fails all tests
fletcher4 24828.96 11.25 188.82 (1) 371 UB, fails all tests
bernstein 1153.57 44.91 134.59 (1) 41 fails all tests
sdbm 863.92 57.36 132.34 (0) 41 fails all tests
x17 1153.56 46.44 135.52 (1) 79 99.98% bias, fails all tests
libiberty 692.16 69.72 132.77 (1) 37 insecure, 100% bias, fails all tests
gcc 692.16 70.70 133.84 (1) 39 insecure, 100% bias, fails all tests
JenkinsOOAT 692.15 91.26 138.71 (1) 153 53.5% bias, fails all tests
JenkinsOOAT_perl 692.16 77.17 136.62 (1) 65 1.5-11.5% bias, 7.2x collisions, LongNeighbors
MicroOAAT 1153.56 46.67 135.28 (1) 68 100% bias, distrib
beamsplitter 534.89 827.06 858.12 (1) UB, too many bad seeds
discohash 2951.62 222.03 343.63 (4) 1294
pearsonhash64 431.42 117.50 83.31 (1) Avalanche, Seed, SSSE3 only. broken MSVC
pearsonhash128 431.40 120.54 85.08 (1) Avalanche, Seed, SSSE3 only. broken MSVC
pearsonhash256 424.97 124.59 94.41 (0) Avalanche, Seed, SSSE3 only. broken MSVC
VHASH_32 13868.74 49.88 185.85 (1) 1231 sanity, Seed, MomentChi2
VHASH_64 13863.00 49.90 170.18 (1) 1231 sanity, Seed, Sparse
farsh32 54178.84 46.31 173.01 (1) 944 insecure: AppendedZeroes, collisions+bias, MomentChi2, LongNeighbors
farsh64 27066.10 88.09 214.66 (1) 944 insecure: AppendedZeroes, collisions+bias, MomentChi2, LongNeighbors
farsh128 13584.69 175.25 232.81 (2) ??
farsh256 6796.97 347.33 402.81 (1) ??
jodyhash32 2768.30 25.57 146.20 (1) 102 bias, collisions, distr, LongNeighbors
jodyhash64 6105.17 22.53 117.98 (1) 118 bias, collisions, distr, LongNeighbors
lookup3 2965.98 26.94 146.43 (1) 341 UB, 28% bias, collisions, 30% distr
superfast 2306.92 36.88 147.52 (1) 210 UB, bad seed 0, 91% bias, 5273.01x collisions, 37% distr, BIC
MurmurOAAT 575.29 86.71 135.26 (1) 47 collisions, 99.998% distr., BIC, bad seed 0, LongNeighbors
Crap8 3460.12 25.97 147.54 (1) 342 UB, 2.42% bias, collisions, 2% distrib
Murmur1 2306.94 36.14 153.79 (1) UB, fails all tests, 1 bad seed
Murmur2 3459.81 30.22 151.61 (1) 358 UB, 1 bad seed, 1.7% bias, 81x coll, 1.7% distrib, BIC
Murmur2A 3459.66 34.28 155.44 (1) 407 UB, 1 bad seed, 12.7% bias, LongNeighbors
Murmur2B 6916.77 26.88 98.73 (0) 433 UB, 1.8% bias, collisions, 3.4% distrib, BIC
Murmur2C 4611.63 36.97 120.91 (1) 444 UB, 2^32 bad seeds, 91% bias, collisions, distr, BIC, LongNeighbors
Murmur3A 3295.17 36.50 155.47 (1) 351 UB, Moment Chi2 69
PMurHash32 3372.02 36.67 154.57 (1) 1862 Moment Chi2 69
Murmur3C 4710.48 44.19 143.79 (1) 859 UB, LongNeighbors, DiffDist
PMPML_32 12125.08 31.59 157.83 (1) 1084 Avalanche >512, unseeded: Seed, MomentChi2
PMPML_64 18188.37 31.12 129.21 (1) 1305 unseeded: Seed, MomentChi2
xxHash32 6914.13 37.53 158.27 (1) 738 LongNeighbors, collisions with 4bit diff, MomentChi2 220
metrohash64_1 18482.90 29.23 123.22 (1) 624 UB, LongNeighbors, BIC, MomentChi2
metrohash64_2 18586.39 29.80 123.42 (1) 627 UB, LongNeighbors
metrohash64crc_1 24893.20 32.23 126.27 (1) 632 UB, cyclic collisions 8 byte, BIC, MomentChi2, machine-specific (SSE4.2/NEON)
metrohash64crc_2 24896.87 32.23 126.58 (1) 632 UB, cyclic collisions 8 byte, BIC, machine-specific (SSE4.2/NEON)
metrohash128_1 20149.03 64.51 172.86 (1) 773 UB, LongNeighbors
metrohash128_2 20148.75 64.43 172.38 (1) 773 UB, LongNeighbors
cmetrohash64_1o 14841.28 30.60 124.64 (1) 3506 LongNeighbors, MomentChi2
cmetrohash64_1 18548.74 29.23 123.28 (0) 652 LongNeighbors, BIC, MomentChi2
cmetrohash64_2 18504.62 29.80 124.87 (1) 655 LongNeighbors
City64noSeed 15796.05 21.72 117.22 (1) 1038 Avalanche, Sparse, TwoBytes, MomentChi2, Seed
City64 15791.05 33.49 128.12 (1) 1120 Sparse, TwoBytes
t1ha1_64be 13826.44 20.37 120.27 (1) 555 Avalanche
t1ha0_32le 7905.20 36.06 123.51 (0) 509 Sparse, LongNeighbors
t1ha0_32be 7545.50 37.72 123.94 (1) 533 Sparse, LongNeighbors
t1ha2_stream 15786.58 56.76 159.22 (1) 1665 Sparse, Permutation, LongNeighbors
t1ha2_stream128 15783.13 71.63 174.11 (1) 1665 Sparse, Permutation, LongNeighbors
aesnihash 6150.19 42.24 153.76 (1) 1209 fails many tests, machine-specific (x64 AES-NI)
aesni-hash-peterrk 28435.27 28.83 126.43 (2) machine-specific (x64 AES-NI)
falkhash 66674.45 83.69 197.94 (1) 264 Sparse, LongNeighbors, machine-specific (x64 AES-NI)
MeowHash 41878.94 57.37 173.31 (1) 1764 Sparse, machine-specific (x64 AES-NI)
MeowHash64low 41883.34 57.32 174.01 (1) 1764 Sparse, machine-specific (x64 AES-NI)
MeowHash32low 41888.75 57.42 183.70 (1) 1764 Sparse, machine-specific (x64 AES-NI)
t1ha1_64le 16532.27 19.71 119.32 (1) 517 Avalanche
tifuhash_64 172.43 416.72 328.84 (2) 276
floppsyhash 170.71 482.13 405.13 (1) 623
chaskey 1496.38 89.69 187.58 (1) 1609 PerlinNoise
SipHash 1327.84 106.92 206.44 (1) 1071
HalfSipHash 1537.94 57.21 168.21 (1) 700 zeroes
GoodOAAT 1153.55 54.36 136.28 (1) 237
pearsonbhash64 1977.41 83.26 133.74 (1) 683
pearsonbhash128 1977.36 95.75 140.26 (1) 1134
pearsonbhash256 1977.35 96.98 141.75 (0) 844
prvhash64_64m 3459.93 34.36 126.31 (1) 349
prvhash64_64 3365.90 35.25 127.63 (1) 384
prvhash64_128 3952.65 53.25 156.32 (1) 718
prvhash64s_64 6496.17 231.86 325.00 (1) 2640
prvhash64s_128 6694.05 303.41 388.48 (1) 2799
SipHash13 2511.96 78.33 184.19 (1) 778 0.9% bias
discohash1 2869.00 177.16 281.62 (1) 1294 bad seeds
discohash1-128 2858.71 213.13 318.91 (1) 1294
discohash2 2861.12 179.98 280.35 (1) 1294
discohash2-128 2867.73 214.01 318.93 (1) 1294
discoNONG 3114.34 390.56 497.82 (1) bad seeds
TSip 5425.34 39.88 148.19 (1) 519 !msvc
aesni 29051.53 28.63 126.17 (1) 519 machine-specific (x64 AES-NI)
aesni-low 29025.66 28.63 125.00 (1) 519 machine-specific (x64 AES-NI)
seahash 7502.74 41.48 142.39 (1) 871 PerlinNoise, !msvc
seahash32low 7502.82 41.49 170.74 (1) 871 PerlinNoise, !msvc
clhash 25785.60 52.77 167.66 (1) 1809 PerlinNoise, machine-specific (SSE4.2/NEON)
HighwayHash64 6242.58 99.55 248.41 (3) 2546
Murmur3F 7504.25 45.69 93.19 (1) 699 UB
fasthash32 6914.05 28.43 146.59 (1) 566 UB
fasthash64 6914.27 26.68 101.37 (1) 509 UB, Moment Chi2 5159 !
MUM 12875.18 26.63 121.17 (1) 1912 UB, too many bad seeds, machine-specific (32/64 differs)
MUMlow 12777.24 26.62 151.29 (1) 1912 UB, 5 bad seeds
xmsx32 2306.94 35.55 151.34 (1) 192 2 bad seeds
mirhash 4180.23 26.69 121.08 (1) 1112 2^36 bad seeds, UB, LongNeighbors, machine-specific (32/64 differs)
mirhash32low 4174.90 26.71 152.31 (1) 1112 4 bad seeds, UB, Cyclic, LongNeighbors, machine-specific (32/64 differs)
mirhashstrict 3256.34 38.89 127.81 (1) 1112
mirhashstrict32low 3256.34 39.29 160.31 (1) 1112 1 bad seed, MomentChi2 9
mx3 7903.35 36.63 107.46 (1) 734 UB
pengyhash 16751.80 50.45 156.07 (1) 421
City32 5499.33 42.69 159.11 (1) 1319
City64low 15791.46 33.34 159.78 (1) 1120
City128 15862.57 74.78 182.38 (1) 1841
CityCrc128 18368.79 75.35 181.49 (1) 295
CityCrc256 18385.35 159.50 351.06 (1)
FarmHash32 29054.45 33.34 160.20 (1) 11489 machine-specific (x64 SSE4/AVX/NEON)
FarmHash64 15787.68 33.47 128.34 (1) 3758
FarmHash128 14744.81 60.16 149.85 (1) 163
farmhash32_c 28997.29 33.34 161.92 (1) 762 machine-specific (x64 SSE4/AVX/NEON)
farmhash64_c 15787.06 33.47 128.43 (1) 3688
farmhash128_c 14708.80 61.24 149.39 (1) 1890
metrohash64 18557.69 29.63 124.03 (1) 624 LongNeighbors
metrohash128 14950.62 63.70 173.05 (1) 624 UB
metrohash128crc_1 24882.45 68.24 177.15 (1) 723 UB, machine-specific (SSE4.2/NEON)
metrohash128crc_2 24883.09 68.23 177.39 (1) 723 UB, machine-specific (SSE4.2/NEON)
xxHash64 10056.45 37.32 130.57 (1) 1999
Spooky32 16149.79 35.01 156.25 (1) 2221 UB
Spooky64 16149.92 34.96 125.91 (1) 2221 UB
Spooky128 16150.36 48.58 136.77 (1) 2221 UB
SpookyV2_32 16144.83 35.92 158.32 (1) 2069
SpookyV2_64 16145.87 35.89 126.17 (1) 2069
SpookyV2_128 16144.31 49.90 137.70 (1) 2069
t1ha2_atonce 15793.75 26.50 123.56 (0) 541
t1ha2_atonce128 15790.56 49.34 145.55 (1) 613 LongNeighbors
t1ha0_aes_noavx 31307.59 27.00 123.67 (1) 925 LongNeighbors, machine-specific (x86 AES-NI)
t1ha0_aes_avx1 31329.37 26.51 123.17 (1) 843 LongNeighbors, machine-specific (x64 AVX)
t1ha0_aes_avx2 80055.05 26.52 124.04 (1) 792 LongNeighbors, machine-specific (x64 AVX2)
ahash64 10923.49 31.33 528.54 (14) 412 rust
xxh3 45761.99 20.57 115.13 (1) 744 Moment Chi2 14974, BIC
xxh3low 45985.28 20.57 149.19 (1) 756 Moment Chi2 1.8e+9 !
xxh128 45404.59 22.72 118.73 (1) 1012 Moment Chi2 14974
xxh128low 45594.05 22.65 118.31 (1) 1012 Moment Chi2 14974, BIC
MeowHash 41878.94 57.37 173.31 (1) 1764 Sparse low32, machine-specific (x64 AES-NI)
MeowHash32low 41888.75 57.42 183.70 (1) 1764 Sparse, machine-specific (x64 AES-NI)
wyhash 24518.95 18.90 108.28 (1) 474
wyhash32 2532.89 37.95 222.17 (4) 426 4 bad and broken seeds, 32-bit
wyhash32low 24515.98 18.91 145.84 (1) 474 5 bad seeds
w1hash 16950.31 24.53 115.22 (1)
rapidhash 24480.16 20.11 110.33 (1) 574
rapidhash_unrolled 24198.19 19.58 109.39 (1) 782
umash32 40085.27 28.59 152.60 (1) 1530
umash32_hi 40050.05 29.18 152.17 (1) 1530
umash64 40087.20 28.12 121.30 (1) 1530
umash128 25929.94 28.61 123.04 (1) 1530
halftime_hash64 7407.72 80.64 187.80 (1) 1530
halftime_hash128 22952.87 70.56 192.21 (1) 1530
halftime_hash256 40050.39 77.73 201.87 (1) 1530
halftime_hash512 40355.03 89.53 213.99 (1) 1530
nmhash32 26048.40 41.39 161.78 (1) 2445
nmhash32x 26004.41 31.23 149.38 (1) 1494
k-hashv32 7439.70 49.75 168.97 (1) 1280
k-hashv64 7463.67 48.83 142.47 (1) 1279
komihash 18957.78 23.26 116.93 (1) 728
polymur 14155.48 32.45 123.59 (1) 1128
gxhash32 736 AES only
gxhash64 103530.08 27.00 147.16 (1) 720 AES only
Other timings:

Summary

I added some SSE assisted hashes and fast intel/arm CRC32-C and AES HW variants, but not the fastest crcutil yet. See our crcutil results. See also the old https://code.google.com/p/smhasher/w/list.

So the fastest hash functions on x86_64 without quality problems are:

Hash functions for symbol tables or hash tables typically use 32 bit hashes, for databases, file systems and file checksums typically 64 or 128bit, for crypto now starting with 256 bit.

Typical median key size in perl5 is 20, the most common 4. Similar for all other dynamic languages. See github.com/rurban/perl-hash-stats

When used in a hash table the instruction cache will usually beat the CPU and throughput measured here. In my tests the smallest FNV1A beats the fastest crc32_hw1 with Perl 5 hash tables. Even if those worse hash functions will lead to more collisions, the overall speed advantage and inline-ability beats the slightly worse quality. See e.g. A Seven-Dimensional Analysis of Hashing Methods and its Implications on Query Processing for a concise overview of the best hash table strategies, confirming that the simplest Mult hashing (bernstein, FNV*, x17, sdbm) always beat "better" hash functions (Tabulation, Murmur, Farm, ...) when used in a hash table.

The fast hash functions tested here are recommendable as fast for file digests and maybe bigger databases, but not for 32bit hash tables. The "Quality problems" lead to less uniform distribution, i.e. more collisions and worse performance, but are rarely related to real security attacks, just the 2nd sanity zeroes test against \0 invariance is security relevant.

Columns

MiB/sec: The average of the Bulk key speed test for alignments 0-7 with 262144-byte keys. The higher the better.

cycl./hash: The average of the Small key speed test for 1-31 byte keys. The smaller the better.

cycl./map: The result of the Hashmap test for /usr/dict/words with std::unordered_map get queries, with the standard deviation in brackets. This tests the inlinability of the hash function (see size). The smaller the better.

size: The object size in byte on AMD64. This affects the inlinability in e.g. hash tables. The smaller the better.

Quality problems: See the failures in the linked doc. The less the better.

Other

SECURITY

The hash table attacks described in SipHash against City, Murmur or Perl JenkinsOAAT or at Hash Function Lounge are not included here.

Such an attack avoidance cannot be the problem of the hash function, but only the hash table collision resolution scheme. You can attack every single hash function, even the best and most secure if you detect the seed, e.g. from language (mis-)features, side-channel attacks, collision timings and independly the sort-order, so you need to protect your collision handling scheme from the worst-case O(n), i.e. separate chaining with linked lists. Linked lists chaining allows high load factors, but is very cache-unfriendly. The only recommendable linked list scheme is inlining the key or hash into the array. Nowadays everybody uses fast open addressing, even if the load factor needs to be ~50%, unless you use Cuckoo Hashing.

I.e. the usage of SipHash for their hash table in Python 3.4, ruby, rust, systemd, OpenDNS, Haskell and OpenBSD is pure security theatre. SipHash is not secure enough for security purposes and not fast enough for general usage. Brute-force generation of ~32k collisions need 2-4m for all these hashes. siphash being the slowest needs max 4m, other typically max 2m30s, with <10s for practical 16k collision attacks with all hash functions. Using Murmur is usually slower than a simple Mult, even in the worst case. Provable secure is only uniform hashing, i.e. 2-5 independent Mult or Tabulation, or using a guaranteed logarithmic collision scheme (a tree) or a linear collision scheme, such as Robin Hood or Cockoo hashing with collision counting.

One more note regarding security: Nowadays even SHA1 can be solved in a solver, like Z3 (or faster ones) for practical hash table collision attacks (i.e. 14-20 bits). All hash functions with less than 160 bits tested here cannot be considered "secure" at all.

The '' vulnerability attack with binary keys is tested in the 2nd Sanity Zero test.

CRYPTO

The official NIST hash function testsuite does not do such extensive statistical tests, to search for weak ranges in the bits. Also crypto does not change the initial state, which we do here for our random 32bit seed. Crypto mostly cares about unreversable key -> hash functions without changing the initial fixed state and timings/sidechannel attacks.

The NIST "Cryptographic Algorithm Validation Program" (CAVP) involves the testing of the implementations of FIPS-approved and NIST-recommended cryptographic algorithms. During the NIST SHA-3 competition, the testing methodology was borrowed from the "CAVP", as the KATs and MCTs of the SHA-3 Competition Test Suite were based on the CAVP tests for SHA-2. In addition to this, the “Extremely Long Message Test,” not present in the CAVP for SHA-2, required the submitters to generate the hash value corresponding to a message with a length of 1 GiB. “NIST - Cryptographic Algorithm Validation Program (CAVP),” June 2017. Available: http://csrc.nist.gov/groups/STM/cavp (No testing source code provided, just high-level descriptions)

Two other independent third party testsuites found an extensive number of bugs and weaknesses in the SHA3 candidates. "Finding Bugs in Cryptographic Hash Function Implementations", Nicky Mouha, Mohammad S Raunak, D. Richard Kuhn, and Raghu Kacker, 2017. https://eprint.iacr.org/2017/891.pdf

Maybe independent researchers should come together to do a better public SHA-4 round, based on better and more testing methods, open source code for the tests, and using standard industry practices, such as valgrind, address-sanitizer and ubsan to detect obvious bugs.

PROBLEMS

Typical undefined behaviour (UB) problems: