﻿ The construction of bit mixers

# The construct of a bit mixer

Jon Maiga, 2020-07-20

A hash functions’ task is to encode data into a fixed sized key. A good hash should produce a random uniform distribution and at the same time be as fast as possible.

In this article I will investigate a component of what sometimes referred to as bit mixers, avalanche forcers or finalizers. Those are usually applied as a last step after some data stream has been hashed. The mixer of my interest takes a 64-bit word and outputs another hashed 64-bit word on the form

uint64_t hash(uint64_t);


As an example let’s look into the famous murmur3 finalizer

uint64_t murmur3(uint64_t k) {
k ^= k >> 33;
k *= 0xff51afd7ed558ccdull;
k ^= k >> 33;
k *= 0xc4ceb9fe1a85ec53ull;
k ^= k >> 33;
return k;
}


It’s composed of three xor-shift with two intermediate multiplications. It also has five constants, three for the shifts and two for the multiplications.

To measure how good a hash function is one could run different tests such as the avalanche tests. Clearly you will get different output if you for example exchange the constants in the function above - what is the optimal permutation? This is something that can be automated, see for example better bit mixing.

Now let’s look at the fast-hash mix function:

uint64_t fast_hash(uint64 h) {
h ^= h >> 23;
h *= 0x2127599bf4325c37ULL;
h ^= h >> 47;
return h;
}


The format is the same as for the murmur3 hash but with less operations, this seems to be a very common configuration (xor-shifts and multiplications).

One that is a bit different is Pelle Evensen rrmxmx mixer and its offsprings

uint64_t rrmxmx(uint64_t v) {
v ^= ror64(v, 49) ^ ror64(v, 24);
v *= 0x9FB21C651E98DF25L;
v ^= v >> 28;
v *= 0x9FB21C651E98DF25L;
return v ^ (v >> 28);
}


Here rotates are used instead of xor-shifts and apparently it has good impact on the results. The construct is similar, shifts/rors interleaved with multiplications.

What made me curious is the structure of how the mixing happens, are there other schemes that are as good and fast? Or is this “the” construct? There are plenty of other bitwise operations one could throw into the mix, are they no good?

An interesting aspect is that it’s possible to achieve guaranteed collision free hashes if the key size is equal or larger than the input size. For example, $hash(x)=x$ will have no collisions (but horribly fail the avalanche test). To guarantee that a hash is collision free it’s enough to show the function is reversible. That is,it’s possible to compute the input from the output (hash key). E.g. $hash(x)=y$, then $hash^{-1}(y)=x$. Certain operations, such as addition, subtraction, xor, multiplication with odd constants and xor-shift are reversible. This probably explains why we don’t usually see irreversible operations such as bitwise | and & in the mixers. For more information on reversible operations see The Pluto Scarab and a post by Daniel Lemire.

EDIT: Here are two follow up posts tuning bit mixers and the mx3 mix/prng/hash functions.

EDIT: Pelle Evensen was kind to give me some feedback so I’ve added a few corrections and supplementary information in the article below. Also, he introduced me to the RRC test which is a complement to just running a counter based mixer to PractRand, which his awesome mixer nasam passes to at least $2^{42}$ bytes.

## Exploring constructs

I figured I will deploy my previous work on procedurally generated programs for number sequences to search for different mixer functions. The idea is to procedurally generate hash functions, execute them and see if they are viable. After looking around I found that Chris Wellons has done something similar.

### Setup

I will specify a list of operations and constants, (xor, mul, 33, etc) and generate programs (stack machines) that represent hash functions. The programs will be found in a depth first search and to narrow down the search space some simple pruning will be done. For example one only need to explore one path for commutative operators ($a+b=b+a$). To limit the search space further I will in addition to primitive operations (xor, add, mul) also use composites for example, xor-shift-right (x^=x>>c).

I will view the selection of constants as a micro optimization problem (it’s not!), and restrict the search to a few constants taken from well known bit mixers. Similarly I will select a few smaller constants for the shifts/rotates.

As we search deeper, I will need to remove some operations to narrow the search space. I will do this a bit arbitrary, removing operators that doesn’t seem to give much or appear redundant.

The stack machines are built with postfix notation. To read them process from left to right, for example, $(3-4)\cdot2$ can be written in postfix as 3 4 - 2 *, push 3 on stack, push 4 on stack, subtraction pops 2 from stack and pushes back the result, the stack is now -1. Then push 2 on the stack then mul pops both -1 and 2 from the stack and pushes the product -2 and we are done. It’s a very compact and convenient notation and no need to specify precedence with parentheses!

Programs will be grouped by it’s operator set, depth and number of multiplications. The tables at the end will show the “best” program in each group.

### Fitness

During the search the programs will be executed and exposed to a fast and simple avalanche test, programs that passes will be added to a list of candidates. When the search is done, a more extensive test will be run on the found programs (bit independence criterion).

As a measure of goodness I will select programs that minimizes the standard deviation of the bit independence bias, having disregarding all programs (except reference programs) with a mean bias larger than a certain value.

For the PractRand settings I blindly used the same as Pelle Evensen: RNG_test.exe stdin64 -tf 2 -te 0 -multithreaded -tlmax 1TB -tlmin 1KB For this test the mixer was used as a prng where it’s state was the counting numbers, starting with 0 and incrementing by one for the next number to mix. I believe this is referred to as gamma is one.

### Columns

mixer # #muls bic_std bic_mean bic_max sac_max pract_rand comment
mixer in postfix number of instructions number of multiplications bias bias bias bias PractRand result comment

By an instruction I loosely mean or a primitive operation, such as xor that is usually compiled to one instruction. I will also count a constant as an instruction, but xor-shift right is counted as two instructions (see table at the end).

## Summary of the search

After tinkering about I decided to present the result in increasing complexity measured as number of instructions. I will single out the top performers and any interesting programs/constructions found. I will name programs as they are laid out, e.g. xmx represent xor-shift right, multiply, xor-shift right.

### 7 instructions

As a curiosity, the most compact mixer construction to pass the low bar avalanche tests has 7 instructions and is on the form

x c2 mul 59 ror c2 mul


The performance of this mixer is not very good considering it has two multiplications just like murmur3 and split mix. It will fail PractRand at $2^{13}$.

### 8 instructions

After expanding the search to 8 instructions it can squeeze xor-shift right and alikes into the mix. The most promising construction

x c1 mul 56 xsr c2 mul


seems a level better than the runner up with that uses asr or ssr instead or xsr.

mixer # #muls bic_std bic_mean bic_max sac_max pract_rand comment
x c1 mul 56 xsr c2 mul 8 2 17.9072 0.271816 100 7.26375 14
c2 x c1 mul 59 asr mul 8 2 36.5798 1.52001 100 10.7081 12

If you want to give this a go here is the code (c1 and c2 are the constants from split mix).

// x c1 mul 56 xsr c2 mul
uint64_t mxm(uint64_t x) {
x *= 0xbf58476d1ce4e5b9ull;
x ^= x >> 56;
x *= 0x94d049bb133111ebull;
return x;
}


In the table at the end it’s also possible to see that neg and inv mixed in the programs with 7 instructions doesn’t improve anything.

### 9 instructions

With 9 instructions we get our first useful 1 multiplication mixers, just like reference programs fast-hash and xxh3. Among the found, the most promising is

x 23 xsr c3 mul 23 xsr


which has exactly the same construction as the reference programs.

mixer # #muls bic_std bic_mean bic_max sac_max pract_rand comment
x 23 xsr c3 mul 23 xsr 9 1 43.4295 3.1524 100 12.245 14
x 37 xsr C mul 32 xsr 9 1 51.0669 2.35476 100 18.2312 14? xxh3
x 23 xsr c5 mul 47 xsr 9 1 54.1262 3.82302 100 28.1047 12 fast hash

I think they all are in the same ballpark. PractRand fails at $2^{14}$ for all I tested in this category (although I am not entirely sure how to interpret the result of xxh3, it stopped at $2^{14}$ but I didn’t see a FAIL message?).

We can also see that exchanging one of the xor-shifts for add shift doesn’t affect the result a lot like it did earlier when the program only had one xor-shift.

// x 23 xsr c3 mul 23 xsr
uint64_t xmx(uint64_t x) {
x ^= x >> 23;
x *= 0xff51afd7ed558ccdull;
x ^= x >> 23;
return x;
}


Again for programs with two multiplications we see that inv and neg doesn’t do much, e.g. x c2 mul 56 xsr c1 mul neg.

Also here the first 3 multiplication mixer show up x c1 mul 56 ror c1 mul c2 mul however the performance is not good. Maybe because multiplication will only affect bits from the lowest power of two and up, so after a multiplication it’s probably a good idea to shift it down and mix with xor.

### 11 instructions

With 11 instructions we can finally start to lower the bit independence criterion bias, so far it has remained almost untouched at 100%. The first construction to get it close to 85% is x c2 mul 32 xsr c1 mul 32 asr and x c2 mul 32 xsr c1 mul 32 xsr (almost same score).

mixer # #muls bic_std bic_mean bic_max sac_max pract_rand comment
x 30 xsr c1 mul 27 xsr c2 mul 31 xsr 14 2 2.25399 0.045874 8.4 0.604688 19 split mix
x 33 xsr c3 mul 33 xsr c4 mul 33 xsr 14 2 2.2854 0.00397949 8.8 0.823438 17 murmur3
x c3 mul 47 xsr c1 mul 32 xsr 11 2 7.94327 0.374375 84.48 9.11813 17
x c3 mul 32 xsr c3 mul 32 asr 11 2 8.18966 0.041416 85 16.5544 18

The found programs have 3 instructions less than murmur3 and splitmix, but PractRand-wise they are comparable:

// x c3 mul 32 xsr c3 mul 32 asr
uint64_t mxma(uint64_t x) {
x *= 0xff51afd7ed558ccdull;
x ^= x >> 32;
x *= 0xff51afd7ed558ccdull;
x += x >> 32;
return x;
}
// x c3 mul 47 xsr c1 mul 32 xsr
uint64_t mxmx(uint64_t x) {
x *= 0xff51afd7ed558ccdull;
x ^= x >> 47;
x *= 0xbf58476d1ce4e5b9ull;
x ^= x >> 32;
return x;
}


### 12 instructions

Here we do a noticeable improvement on 1 multiplication mixers by introducing Pelle Evensens’, xrr operation

mixer # #muls bic_std bic_mean bic_max sac_max pract_rand comment
x 32 xsr c3 mul 47 23 xrr 12 1 23.2392 1.19562 80.16 8.02 15
x 23 xsr c3 mul 23 xsr 9 1 43.4295 3.1524 100 12.245 $14$ previous best
inline uint64_t ror64(uint64_t v, int r) {
return (v >> r) | (v << (64 - r));
}

// x 32 xsr c3 mul 47 23 xrr
uint64_t xmrx(uint64_t x) {
x ^= x >> 32;
x *= 0xff51afd7ed558ccdull;
x ^= ror64(x, 47) ^ ror64(x, 23);
return x;
}


(A decent compiler will convert ror64 into a single ror assembly instruction.)

### 13 instructions

With 13 instructions we get our first 3 multiplication that has promising performance x c1 mul 32 xsr c2 mul 32 xsr c2 mul. The construction follows the same recognizable pattern, multiplications interleaved with xor-shift-right. In PractRand it surpasses both split mix and murmur3, with one less instruction, however, it uses three multiplications while the reference programs uses two. A speed test should be conducted to see how it holds up. Also the it has much higher max bit independence bias than the reference programs.

mixer # #muls bic_std bic_mean bic_max sac_max pract_rand comment
x c1 mul 32 xsr c2 mul 32 xsr c2 mul 13 3 2.03301 0.00706055 51.04 0.633125 37
x 30 xsr c1 mul 27 xsr c2 mul 31 xsr 14 2 2.25399 0.045874 8.4 0.604688 19 split mix
x 49 24 xrr c6 mul 28 xsr c6 mul 28 xsr 17 2 2.26088 0.0101074 8.8 0.684375 44 rrmxmx
x 33 xsr c3 mul 33 xsr c4 mul 33 xsr 14 2 2.2854 0.00397949 8.8 0.823438 17 murmur3
// x c1 mul 32 xsr c2 mul 32 xsr c2 mul
uint64_t mxmxm(uint64_t x) {
x *= 0xbf58476d1ce4e5b9ull;
x ^= x >> 32;
x *= 0x94d049bb133111ebull;
x ^= x >> 32;
x *= 0x94d049bb133111ebull;
return x;
}


### 14 instructions

Home of murmur3 and split mix! Here something interesting happen, the search found a program that performs very good in PractRand (which I trust more than my avalanche tests). The found construction is a variant with rrmxmx xrr instruction, x c2 mul 56 32 xrr c3 mul 23 xsr, but with only 14 instructions instead of 17.

mixer # #muls bic_std bic_mean bic_max sac_max pract_rand comment
x 30 xsr c1 mul 27 xsr c2 mul 31 xsr 14 2 2.25399 0.045874 8.4 0.604688 19 split mix
x 49 24 xrr c6 mul 28 xsr c6 mul 28 xsr 17 2 2.26088 0.0101074 8.8 0.684375 44 rrmxmx
x 33 xsr c3 mul 33 xsr c4 mul 33 xsr 14 2 2.2854 0.00397949 8.8 0.823438 17 murmur3
x c2 mul 56 32 xrr c3 mul 23 xsr 14 2 4.16103 0.0774902 67 3.92313 37
inline uint64_t ror64(uint64_t v, int r) {
return (v >> r) | (v << (64 - r));
}
// x c2 mul 56 32 xrr c3 mul 23 xsr
uint64_t mxrmx(uint64_t x) {
x *= 0x94d049bb133111ebull;
x ^= ror64(x, 56) ^ ror64(x, 32);
x *= 0xff51afd7ed558ccdull;
x ^= x >> 23;
return x;
}


The search also managed to find a few similar programs that had about the same behaviour as split mix and murmur3.

### 15+ instructions

Here we get the rrmxmx mixer that has better random properties than both split mix and murmur3. The search did find a lot of programs with seemingly good avalanche properties (often with asr), but all to often, when run in PractRand they don’t correlate very well. So I decided to round up this analysis without digging to deep into programs with more than 14 instructions.

I additionally added (is not visible in the tables at the end):

uint64_t mxmxmx(uint64_t x) {
x *= 0xbf58476d1ce4e5b9ull;
x ^= x >> 32;
x *= 0x94d049bb133111ebull;
x ^= x >> 32;
x *= 0xff51afd7ed558ccdull;
x ^= x >> 32;
return x;
}


as a promising construction that needs more investigation.

## Speed test

Here is a naive speed test, measuring the time while feeding each mixer with random numbers (sorted on second column):

mixer MSVC, i7-4790@4GHz, ms Clang, i7@2GHz (mac), ms PractRand
nop 5033 7911 -
mxm 6738 10809 14
xxh3 6911 11764 14
fast_hash 6939 11418 12
mxma 7001 12312 18
mxmx 7006 11854 17
xmx 7026 11563 14
mxmxm 7736 13356 37
mxrmx 8192 16919 37
xmrx 8241 16574 15
murmur3 8266 12210 17
split mix 8299 12556 19
mxmxmx 8313 12665 >38
rrmxmx 10039 17436 44

The programs with xrr are very slow on my old mac air (2014), I am not sure why.

## Findings

We found a mixer with 13 instructions whereof 3 multiplications that performs better than split mix and murmur3 (PractRand 37 vs 19)

// x c1 mul 32 xsr c2 mul 32 xsr c2 mul
uint64_t mxmxm(uint64_t x) {
x *= 0xbf58476d1ce4e5b9ull;
x ^= x >> 32;
x *= 0x94d049bb133111ebull;
x ^= x >> 32;
x *= 0x94d049bb133111ebull;
return x;
}


Since the search was restricted to two constants, note that the last multiplication uses the same constant as the second. I tested to exchange the last for the first murmur3 constant instead (0xff51afd7ed558ccd) which made it one step further to PractRand 38. One problem here might be that the max bias for the bic test is rather high ~50%, compared to ~8% for the reference programs.

We also found a mixer with 14 instructions that performs better than split mix and murmur3 (again PractRand 37 vs 19), although performance seems to vary between architectures

inline uint64_t ror64(uint64_t v, int r) {
return (v >> r) | (v << (64 - r));
}
// x c2 mul 56 32 xrr c3 mul 23 xsr
uint64_t mxrmx(uint64_t x) {
x *= 0x94d049bb133111ebull;
x ^= ror64(x, 56) ^ ror64(x, 32);
x *= 0xff51afd7ed558ccdull;
x ^= x >> 23;
return x;
}


After having seen the speed table I would also bring forward

// x c1 mul 56 xsr c2 mul
uint64_t mxm(uint64_t x) {
x *= 0xbf58476d1ce4e5b9ull;
x ^= x >> 56;
x *= 0x94d049bb133111ebull;
return x;
}


as a possible replacement for the 1 multiplication mixers in fast hash and xxh3, it seems to be faster and have better avalanche behaviour.

All those should be tested more rigorously accompanied with proper speed test.

The constants are very coarse and could probably be tuned a fair bit. Again, the search space for 64-bit constant is enormous but I think a technique from feature selection in machine learning should be able to accomplish the task. But that is for another day.

## Conclusion

Under the search setup assumptions (selection of operations and of the few constants) here are some learnings.

• Multiplication is the backbone of any bit mixer. In addition to the searches presented in the tables, I did a couple of searches without mul, not one single managed to pass the simple avalanche test.
• Not so unexpected, but xor-shift is powerful, it appears at top in most tables.
• Good avalanche scoring doesn’t imply good random scoring (at not least mine). I would love to find another fast and simple test to complement sac and bic.
• The bitwise & and | almost doesn’t show up at all, I think the reason is twofold, 1) they are not reversible 2) if the operands are randomly distributed the expected outcome of bits set is 25% and 75% respectively, while for xor 50% (consider a truth table).
• Although I found programs that incorporated the input x a second time into the mixer - non of the ones tested in PractRand exhibited good random behavior, for example x x 32 xsr c2 mul xor c1 mul 32 xsr has avalanche score similar to split mix and murmur3, but fails much earlier at PractRand $2^{13}$. This is probably because when the input is xored in again - it only becomes “half baked” at the end.

In the end we found improved variations on existing ones, but no completely different (and well performing) new construction. The existing ones are probably the simplest with good performance (...mx...). To further explore the subject, one would have to expand the search with a bit more pruning and better tests.

Another idea is to identify a test that detects individual reversible operations, then the search could possibly give back single components (e.g. xsr or xrr) that can be put together and give good results.

EDIT 2020-10-14: Pelle pointed out one way to test an operation for reversibility is to construct matrices and calculate their inverse or rank.

Also, the selection of constants comes from well known mixers that utilize the common ...mx... pattern, maybe this has made the search biased towards the same pattern.

Overall, I have a much greater understanding of hashing, this has truly been a great little learning project. I think there is a lot more to learn and if I get time I will push the code to github to make it available.

Posts in series

1. The construction of bit mixers
2. Tuning bit mixers
3. The mx3 mix/prng/hash functions

## Tables

Note that the depth refers to the number of operations in the program. This number is not the same as the number of instructions, for example xor-shift-right is a composite operation but counts as one.

Also, I did not have time to incorporate automatic testing of PractRand so only a few of the ones I’ve been tested are noted below.

### Operations

operation instructions description
xor 1 bitwise xor
shl 1 bitwise shift left
shr 1 bitwise shift right
rol 1 bitwise rotate left
ror 1 bitwise rotate right
sub 1 -
mul 1 *
xsl 2 xor shift left (x ^= x << c)
xsr 2 xor shift right (x ^= x >> c)
xrr 4 x ^ (ror(x, a) ^ ror(x, b))
asr 2 add shift right (x += x >> c)
ssr 2 sub shift right (x -= x >> c)
inv 1 bitwise invert
neg 1 negate
or 1 bitwise or
and 1 bitwise and
c1 1 split mix constant 1
c2 1 split mix constant 2
c3 1 murmur3 constant 1
c4 1 murmur3 constant 2
c5 1 fast hash constant
c6 1 rrmxmx constant

EDIT 2020-08-27: I accidentally used the non-bijective asr/ssr instead of the bijective asl/ssl (thanks Pelle Evensen for pointing that out). If I ever revisit this I will run it with asl/ssl instead.

### Depth 7

search set = {x 5 7 13 23 32 47 49 53 56 59 c1 c2 c3 c4 c5 c6 xor shl shr rol ror add sub mul xsl xsr xrr asr ssr inv neg or and}
time = 1351s
visited programs = 576542474
bic mean cutoff = 4%

mixer # #muls bic_std bic_mean bic_max sac_max pract_rand comment
x c1 mul 56 xsr c2 mul 8 2 17.9072 0.271816 100 7.26375 14
x c2 mul 5 rol c2 mul 7 2 35.9307 2.30274 100 13.1312
x c2 mul 59 ror c2 mul 7 2 35.9307 2.30274 100 13.1312 13
c2 x c1 mul 59 asr mul 8 2 36.5798 1.52001 100 10.7081 12
x c2 mul 59 ssr c2 mul 8 2 36.7579 0.921836 100 10.0913
x c2 mul 59 shr c2 mul 7 2 37.7674 0.121309 100 36.2025
x 23 xsr c3 mul 23 xsr 9 1 43.4295 3.1524 100 12.245 14
c1 x 32 asr mul 23 xsr 9 1 45.7666 2.89114 100 9.79 14
x 32 ssr c3 mul 23 xsr 9 1 46.1016 3.61384 100 14.1487 14
x c1 mul 59 shr 13 sub 7 1 50.3886 0.973086 100 93.6338 10
x 37 xsr C mul 32 xsr 9 1 51.0669 2.35476 100 18.2312 14? xxh3
x 23 xsr c5 mul 47 xsr 9 1 54.1262 3.82302 100 28.1047 12 fast hash
c1 x 32 asr mul 49 asr 9 1 54.9152 3.87457 100 19.7912 12
c5 x 32 asr mul 32 ssr 9 1 55.0455 3.67253 98.4 11.5906
x 32 ssr c1 mul 32 ssr 9 1 55.0666 3.30169 99.32 10.775

### Depth 8

search set = {x 13 23 32 47 56 c1 c2 c3 c4 xor shl shr rol ror add sub mul xsl xsr xrr asr ssr inv neg or and}
time = 3408s
visited programs = 1084550770
bic mean cutoff = 4%

mixer # #muls bic_std bic_mean bic_max sac_max pract_rand comment
x c1 mul 56 47 xrr c4 mul 11 2 12.5043 0.146855 100 4.93125 15
x inv c1 mul 56 xsr c2 mul 9 2 17.7828 0.266602 100 7.195
x c2 mul 56 xsr c1 mul neg 9 2 17.7881 0.310703 100 6.2825
x 32 xsr c3 mul 47 23 xrr 12 1 23.2392 1.19562 80.16 8.02 15
c3 x 32 asr mul 47 23 xrr 12 1 23.8208 1.18066 81.56 7.8825
x 32 ssr c3 mul 47 23 xrr 12 1 25.2278 1.11838 81.44 8.0075
x c2 mul inv 56 ror c2 mul 8 2 38.4341 1.83058 100 9.35562
x neg c2 mul 56 ror c2 mul 8 2 38.5429 1.8362 100 9.28562
x neg c2 mul 56 ssr c2 mul 9 2 38.9329 1.26202 100 11.3856
x c2 mul inv 56 ssr c2 mul 9 2 39.0167 1.23252 100 11.4694
c3 x inv c1 mul 56 asr mul 9 2 39.1043 0.700557 100 16.3444
c2 x c2 mul neg 56 asr mul 9 2 39.2906 0.964141 100 10.8563
x c2 mul 56 shr neg c2 mul 8 2 39.3176 0.392197 100 12.1931
x inv c1 mul 56 shr c2 mul 8 2 39.3476 0.216465 100 11.2025
x c3 mul 47 23 xrr 13 xsl 12 1 40.5538 3.78165 100 84.375
x inv c1 mul 13 rol c3 mul 8 2 41.8803 0.729697 100 15.1719
x c2 mul 13 rol neg c3 mul 8 2 41.8999 0.898633 100 26.0294
x neg 23 xsr c3 mul 23 xsr 10 1 42.8148 3.1123 100 12.5262
x 23 xsr inv c3 mul 23 xsr 10 1 43.4027 3.16371 100 12.2787
c1 x 32 asr mul 23 xsr neg 10 1 45.0234 2.85534 100 9.94437
x 32 ssr c3 mul 23 xsr neg 10 1 45.5573 3.23853 100 13.325
c1 x inv 32 asr mul 23 xsr 10 1 45.6231 2.85826 100 9.69187
x 32 ssr c3 mul 23 xsr inv 10 1 46.1016 3.61384 100 14.1487
x 37 xsr C mul 32 xsr 9 1 51.0669 2.35476 100 18.2312 $2^{14}$? xxh3
x 23 xsr c5 mul 47 xsr 9 1 54.1262 3.82302 100 28.1047 $2^{12}$ fast hash
x 32 ssr c1 mul 32 ssr neg 10 1 55.0424 3.29918 99.32 10.7444
x 32 ssr c1 mul inv 32 ssr 10 1 55.0489 3.29922 99.32 10.7369
c3 x inv 32 asr mul 47 ssr 10 1 55.2102 3.21338 100 16.4112
c3 x neg 32 asr mul 47 ssr 10 1 55.2544 3.24806 100 16.2944
c3 x neg 32 asr mul 47 asr 10 1 55.2814 3.03674 100 15.5819
c3 x inv 32 asr mul 47 asr 10 1 55.3504 2.97169 100 15.3719
x c1 mul 56 ssr 32 and neg 9 1 59.6618 2.25705 100 100

### Depth 9

search set = {x 23 32 47 56 c1 c2 c3 xor shl shr rol ror add mul xsl xsr xrr asr inv neg}
time = 5620s
visited programs = 3225408912
bic mean cutoff = 1%

mixer # #muls bic_std bic_mean bic_max sac_max pract_rand comment
x 30 xsr c1 mul 27 xsr c2 mul 31 xsr 14 2 2.25399 0.045874 8.4 0.604688 19 split mix
x c3 mul 47 xsr c1 mul 32 xsr 11 2 7.94327 0.374375 84.48 9.11813 17
x c3 mul 32 xsr c3 mul 32 asr 11 2 8.18966 0.041416 85 16.5544 18
x c2 mul 56 47 xrr c1 mul neg 12 2 12.447 0.236992 100 3.99125
x inv c1 mul 56 47 xrr c2 mul 12 2 12.7327 0.179326 100 8.32313
x c3 mul 32 ror 23 xsr c3 mul 10 2 13.6545 0.298437 100 10.67
x c3 mul 32 rol 23 xsr c3 mul 10 2 13.6545 0.298437 100 10.67
x 47 23 xrr c3 mul 47 23 xrr 15 1 13.9559 0.517129 65.92 5.2225
x c3 mul 32 shr 23 xsr c3 mul 10 2 14.0911 0.364951 100 10.9763
c1 x c3 mul 23 xsl 56 asr mul 11 2 14.3322 0.360137 100 2.13125
x c3 mul 23 xsl 56 xsr c1 mul 11 2 14.6966 0.401133 100 3.08312
x c3 mul 23 xsl 56 ror c1 mul 10 2 14.812 0.464766 100 3.10813
x c3 mul 23 xsl 56 shr c1 mul 10 2 15.042 0.426865 100 2.79062
x x c1 mul 56 asr xor c2 mul 10 2 15.8734 0.0958203 100 6.07375
x c1 mul 56 xsr c1 mul c2 mul 10 3 17.0535 0.015752 100 7.73875
x c1 mul c1 xor 56 xsr c2 mul 10 2 17.5786 0.208682 100 6.99812
x c2 mul 56 xsr c1 mul c3 add 10 2 17.6734 0.304531 100 6.32125
x x c1 mul 56 ror xor c2 mul 9 2 17.6796 0.253975 100 7.10938
x c2 mul inv 56 xsr c1 mul neg 10 2 17.7587 0.280068 100 6.39063
x c2 mul neg 56 xsr c1 mul neg 10 2 17.7625 0.306797 100 6.63438
x inv c1 mul 56 xsr c2 mul inv 10 2 17.7828 0.266602 100 7.195
x x c1 mul 56 shr xor c2 mul 9 2 18.2581 0.165127 100 7.41062
x 32 asr 23 xsr c1 mul 23 xsr 12 1 21.1963 0.285879 92.44 4.5025 14
x 32 xsr c3 mul 47 23 xrr neg 13 1 22.7745 1.03314 80.16 7.15375
c3 x 32 asr mul 47 23 xrr neg 13 1 23.3102 1.01854 81.56 7.00375
x inv 32 xsr c1 mul 47 23 xrr 13 1 24.9714 0.769209 79.96 7.36125
x 32 asr 23 xsl c1 mul 32 xsr 12 1 25.0961 0.643516 79.32 4.96062
x 32 asr 23 xsl c1 mul 32 asr 12 1 25.2312 0.090752 79.32 3.55437
c3 x inv 32 asr mul 47 32 xrr 13 1 26.6225 0.492793 87.12 5.89625
x c2 add 32 xsr c1 mul 23 xsr 11 1 30.635 0.931533 100 6.54375
x 23 xsr c1 mul 32 xsr 23 xsl 12 1 32.3294 0.548574 100 7.515
c3 x 32 asr xor c3 mul 32 xsr 11 1 33.2242 1.01191 96.2 15.66
x 23 xsr c1 mul 32 xsr 23 xsr 12 1 33.9184 0.437451 98.44 8.58437
c2 x c2 mul 56 ror 56 asr mul 10 2 34.2519 0.271592 100 14.6225
c1 x c2 mul 47 asr 56 asr mul 11 2 34.8206 0.827959 100 8.51812
x c2 add 23 xsr c3 mul 23 asr 11 1 35.2267 0.185713 100 15.7862
c3 x c1 mul 32 rol 23 asr mul 10 2 35.7135 0.0266797 100 14.6256
c3 x c1 mul 23 shr 32 asr mul 10 2 35.9982 0.722393 100 8.5025
c1 x c2 mul 56 asr mul c2 mul 10 3 37.7813 0.685781 100 10.9406
x c1 mul 56 ror c1 mul c2 mul 9 3 37.8879 0.840381 100 10.1694
x c1 mul 56 shr c1 mul c2 mul 9 3 38.08 0.48665 100 10.3994
x c2 mul 23 rol 47 rol c1 mul 9 2 38.1917 0.0621289 100 11.8388
c3 x 23 asr xor c3 mul 23 asr 11 1 38.2589 0.104648 100 17.9606
x c2 mul 32 rol 23 shr c1 mul 9 2 38.4095 0.569014 100 10.0331
x c2 mul 32 ror 23 shr c1 mul 9 2 38.4095 0.569014 100 10.0331
c3 x inv c1 mul neg 56 asr mul 10 2 39.011 0.653887 100 16.4063
c3 x c1 mul c1 add 56 asr mul 10 2 39.011 0.653887 100 16.4063
x inv c1 mul 56 asr inv c3 mul 10 2 39.0703 0.695244 100 16.2119
x c2 mul neg 56 asr neg c2 mul 10 2 39.2767 0.969199 100 10.8306
x c2 mul 56 shr neg c2 mul inv 9 2 39.3176 0.392197 100 12.1931
x inv c1 mul 56 shr c2 mul inv 9 2 39.3476 0.216465 100 11.2025
c2 x x c2 mul 56 shr add mul 9 2 39.3565 0.719453 100 13.0369
x c2 mul neg 56 shr c2 mul neg 9 2 39.3615 0.408945 100 12.1638
x c2 mul 23 shr 32 shr c2 mul 9 2 39.3871 0.376758 100 12.8206
x x c2 mul 56 ror c3 mul add 9 2 39.6542 0.121904 100 18.3106
x 47 rol c2 mul 56 ror c3 mul 9 2 39.7794 0.0743457 100 19.3463
x 56 ror c2 mul 56 ror c3 mul 9 2 39.8056 0.0632617 100 19.1869
x c2 mul neg 56 ror c3 mul neg 9 2 39.8565 0.0129199 100 19.27
x c2 mul inv neg 56 ror c3 mul 9 2 39.8822 0.0368945 100 19.3487
x c2 mul inv 56 ror inv c3 mul 9 2 39.9101 0.0228516 100 19.2244
x x 23 rol xor c1 mul 32 xsr 10 1 43.3692 0.583242 100 12.3087
x x 23 ror xor c1 mul 32 xsr 10 1 43.4885 0.577109 100 12.1175
x x 32 xsr c1 mul xor 23 xsr 11 1 43.6852 0.433711 100 10.5213
x neg 23 xsr c1 mul 32 xsr neg 11 1 44.0235 0.104219 100 12.1244
x 23 xsl 23 ror c1 mul 23 xsr 11 1 44.6055 0.558867 100 17.2788
x neg 23 xsr c1 mul inv 32 xsr 11 1 44.8225 0.120664 100 12.1262
x 23 xsl 32 rol c1 mul 23 xsr 11 1 45.2153 0.662031 100 17.235
x 23 rol 23 xsr c1 mul 32 xsr 11 1 45.5656 0.0900391 100 12.4113
x 23 ror 23 xsr c1 mul 32 xsr 11 1 45.5814 0.0827051 100 12.4563
x inv 23 xsr c1 mul 32 xsr inv 11 1 45.668 0.0881055 100 12.2475
x x 23 shr xor c1 mul 32 xsr 10 1 45.753 0.11748 100 11.905
x 32 xsl 32 shr c1 mul 23 xsr 11 1 46.7171 0.570566 100 6.05063
x x 23 ror xor c2 mul 32 asr 10 1 48.0942 0.454609 100 16.1487
x x 23 rol xor c2 mul 32 asr 10 1 48.156 0.44668 100 16.0906
x 32 asr inv c2 mul 23 xsr neg 11 1 48.6095 0.311689 100 10.0244
c2 x 32 asr mul neg 23 xsr neg 11 1 48.6667 0.371025 100 10.3438
x 32 asr inv c2 mul 23 xsr inv 11 1 49.2568 0.285469 100 10.025
c2 x 23 rol 32 asr mul 23 xsr 11 1 49.3416 0.338057 100 10.3725
c2 x x 32 shr add mul 23 xsr 10 1 49.3629 0.354531 100 10.3413
c2 x 32 asr mul 23 xsr 47 ror 11 1 49.3629 0.354531 100 10.3413
x 23 xsl 47 rol c1 mul 32 asr 11 1 49.4377 0.854121 100 33.5206
c1 x 47 asr mul 23 ror 23 xsl 11 1 49.9892 0.87457 100 35.5725
c1 x x 23 rol add mul 23 xsr 10 1 50.2858 0.68126 100 17.065
c1 x x 23 ror add mul 23 xsr 10 1 50.3296 0.695137 100 17.1275
x x 23 shr xor c2 mul 32 asr 10 1 50.7086 0.0392383 100 16.1994
x 37 xsr C mul 32 xsr 9 1 51.0669 2.35476 100 18.2312 14? xxh3
x 23 xsl 23 shr c1 mul 47 asr 11 1 52.9512 0.351387 100 27.7313
c2 x 32 asr 23 asr mul 56 asr 12 1 55.4752 0.591016 99.72 13.3362
c2 x c2 add 32 asr mul 47 asr 11 1 55.7184 0.990986 100 18.6975
x 23 asr 56 rol c3 mul 23 asr 11 1 55.7537 0.089248 100 76.1
x c3 mul 32 asr 32 ror 23 asr 11 1 55.8784 0.756299 100 74.9762
c2 x neg inv 32 asr mul 47 asr 11 1 56.6127 0.898184 100 19.0175
x inv 23 asr inv c1 mul 32 asr 11 1 56.6641 0.823379 100 12.2369
c1 x neg 23 asr mul neg 32 asr 11 1 56.6641 0.823379 100 12.2369
c1 x x 23 shr add mul 32 asr 10 1 56.8089 0.841523 100 12.0094
c3 x x 32 ror add 56 asr mul 10 1 56.8618 0.655742 100 16.4619
c3 x x 32 rol add 56 asr mul 10 1 56.8618 0.655742 100 16.4619

### Depth 10

search set = {x 23 32 56 c1 c2 c3 xor shr ror mul xsr asr xrr}
time = 1054s
visited programs = 943620965
bic mean cutoff = 0.1%

mixer # #muls bic_std bic_mean bic_max sac_max pract_rand comment
x 30 xsr c1 mul 27 xsr c2 mul 31 xsr 14 2 2.25399 0.045874 8.4 0.604688 19 split mix
x 33 xsr c3 mul 33 xsr c4 mul 33 xsr 14 2 2.2854 0.00397949 8.8 0.823438 17 murmur3
x c2 mul 56 32 xrr c3 mul 23 xsr 14 2 4.16103 0.0774902 67 3.92313
c3 x 32 asr mul 56 32 xrr c2 mul 14 2 4.70004 0.0919434 58.08 1.48813
x c3 mul 56 32 xrr c2 mul c1 mul 13 3 12.6981 0.0547852 100 6.71063
x c2 mul 56 ror c2 mul 56 23 xrr 13 2 12.9351 0.0223633 74.2 5.0225
c3 x 32 asr mul 56 23 xrr 23 asr 15 1 13.0718 0.10707 79 3.45125 18
x 56 xor c1 mul 56 32 xrr c3 mul 13 2 13.1405 0.110586 100 3.88438
x c3 mul 56 32 xrr 56 shr c1 mul 13 2 13.866 0.0636133 100 2.89375
x 23 xsr c2 mul 56 32 xrr 23 asr 15 1 13.8767 0.0110742 87 4.725 16
x 56 23 xrr 32 xsr c1 mul 23 xsr 15 1 16.6114 0.0592773 79.28 3.94625
x x 56 32 xrr c3 mul xor 23 asr 14 1 24.5418 0.076084 100 14.1294 14
x 32 xsr c1 mul 56 32 xrr x xor 14 1 29.1301 0.0265527 82.12 6.88625 12
x 23 xsr 56 ror c2 mul 56 23 xrr 14 1 34.6085 0.0371973 100 8.99938
c3 x 23 asr mul 23 shr 32 23 xrr 14 1 37.5297 0.0490137 100 15.9881
x 56 23 xrr 23 shr c2 mul 32 xsr 14 1 39.1642 0.0792676 100 6.59875

### Depth 11

search set = {x 23 32 56 c1 c2 xor shr ror mul xsr asr xrr}
time = 8676s
visited programs = 5872329366
bic mean cutoff = 0.1%

mixer # #muls bic_std bic_mean bic_max sac_max pract_rand comment
c2 x 23 asr mul 32 xsr c1 mul 32 asr 14 2 1.37188 0.0211523 5.84 0.3625
x 23 xsr c1 mul 32 xsr c2 mul 32 xsr 14 2 1.38106 0.00575195 5.6 0.515
x c1 mul 32 xsr c2 mul 32 xsr c2 mul 13 3 2.03301 0.00706055 51.04 0.633125 34+
x c2 x 32 asr mul xor c1 mul 32 asr 13 2 2.19158 0.0189355 50.64 1.23562 14
x x 32 xsr c2 mul xor c1 mul 32 asr 13 2 2.23839 0.00837891 50.56 1.64 14
x 30 xsr c1 mul 27 xsr c2 mul 31 xsr 14 2 2.25399 0.045874 8.4 0.604688 19 split mix
x 33 xsr c3 mul 33 xsr c4 mul 33 xsr 14 2 2.2854 0.00397949 8.8 0.823438 17 murmur3
x c2 mul 56 32 xrr c1 mul 32 23 xrr 17 2 2.37003 0.0245801 35.8 0.515625
x x 32 xsr c2 mul xor c1 mul 32 xsr 13 2 2.51135 0.000166016 50.56 1.76313 13
x c2 mul 32 ror 23 xsr c2 mul 32 xsr 13 2 5.45574 0.0206934 85.76 0.5475
c2 x c2 mul 56 asr mul 32 xsr c2 mul 13 3 5.8748 0.00841797 73.12 1.88125 14
c1 x 32 asr mul 23 xsr 32 ror c2 mul 13 2 6.13577 0.132754 62.72 2.03125
x 32 xsr c2 mul 23 xsr 32 shr c2 mul 13 2 6.18136 0.0161914 78.92 2.29
x c2 mul 32 xsr c2 mul 56 ror c2 mul 12 3 6.20949 0.0864063 70.68 5.17938
x c1 mul 23 xsr c1 mul 56 shr c2 mul 12 3 6.65757 0.0581055 81.4 8.82062
c1 x 23 asr mul 32 shr 23 xsr c2 mul 13 2 7.06547 0.133799 80.08 2.03
x 32 xsr c1 mul 56 23 xrr 56 32 xrr 18 1 7.47305 0.0228223 44.32 1.98063
x x c2 mul 56 ror xor c1 mul 32 xsr 12 2 8.8014 0.0270801 93.24 5.28812
c2 x 32 asr mul 56 23 xrr 32 23 xrr 18 1 9.0575 0.0328516 51.12 2.925
x x c2 mul 32 shr xor c2 mul 32 xsr 12 2 9.76872 0.170098 91 3.85938
x x c2 mul 56 ror xor c1 mul 32 asr 12 2 10.1573 0.0549512 93.24 8.11438
x c2 x 32 asr mul 32 shr xor c2 mul 12 2 11.4408 0.138555 93.12 2.24313
x c1 mul c2 xor c2 mul 56 xsr c1 mul 12 3 12.7879 0.0407617 100 5.24313
x x c1 mul 56 shr c1 mul xor c2 mul 11 3 13.8526 0.0414551 100 9.12625
x c1 x c1 mul 56 asr mul xor c2 mul 12 3 13.8542 0.0356348 100 9.2475
x x c1 mul 56 ror c1 mul xor c2 mul 11 3 13.8557 0.0391406 100 9.02875
x x 23 ror c1 mul 56 ror xor c2 mul 11 2 16.2872 0.0624902 100 7.495
x c1 mul 32 xsr 32 ror 56 shr c2 mul 12 2 16.6841 0.116309 100 5.84312
x x 23 ror c1 mul 56 shr xor c2 mul 11 2 16.8871 0.0295117 100 7.385
x c1 mul c2 mul c2 mul 56 xsr c2 mul 12 4 18.1874 0.00691406 100 7.22813
x x x c1 mul 56 shr xor c2 mul xor 11 2 18.2581 0.063877 100 5.34938
x 32 asr 23 asr 23 xsr c1 mul 23 xsr 15 1 18.4361 0.0493848 93.4 4.7175
x 32 23 xrr c1 mul 23 ror 56 32 xrr 17 1 20.3267 0.122793 82.08 7.24313
x 32 23 xrr c1 mul 56 32 xrr x xor 17 1 20.3267 0.0215625 82.08 8.07313
x 32 23 xrr 23 shr c1 mul 56 23 xrr 17 1 20.9254 0.0363574 100 5.87875
c2 x 23 asr xor 32 xsr c1 mul 23 xsr 14 1 21.0617 0.0793262 93.64 4.70625
x 56 ror 23 asr 32 xsr c1 mul 23 xsr 14 1 21.13 0.0319531 91.68 4.75563
x x 23 ror 23 asr xor c2 mul 32 xsr 13 1 22.8563 0.0265039 87.28 5.665
x c2 mul 56 ror c2 mul 56 ror c2 mul 11 3 24.4139 0.0749707 88.8 6.72313
x c1 mul 56 ror c1 mul 56 shr c1 mul 11 3 25.59 0.121348 92.72 9.41938
c2 x c1 mul 32 shr c2 mul 56 asr mul 12 3 25.8547 0.0856738 84.44 13.7975
c1 x c1 mul 56 ror c1 mul 56 asr mul 12 3 26.4795 0.0688672 94.24 10.6081
x c1 mul 32 shr c2 mul 56 shr c1 mul 11 3 27.3293 0.064248 88.36 30.13
c2 c1 x c1 mul 23 asr mul 56 asr mul 13 3 28.2474 0.0115234 92.68 7.64125
x x 56 ror 32 asr xor c1 mul 23 asr 13 1 30.1284 0.118467 100 6.23187
c2 x c2 mul 32 asr 23 asr 32 asr mul 14 2 30.3015 0.0266113 93.88 15.5669
x c1 x 23 asr xor c2 mul xor 32 asr 13 1 31.596 0.0538965 100 19.4631
c1 x 32 asr mul 32 asr 56 ror c1 mul 13 2 31.8173 0.0231055 93.32 12.5294
x x 23 shr xor c1 mul 32 xsr 23 asr 13 1 33.9163 0.0936816 98.44 8.7575
c2 x c2 mul 23 shr 32 asr 23 asr mul 13 2 34.037 0.0141016 100 15.95
x c2 mul 32 shr 23 ror c1 mul 32 asr 12 2 34.3852 0.0186914 95.6 16.0456
x 32 ror 23 xsr x xor c2 mul 23 xsr 13 1 35.1116 0.111172 100 7.86063
x 32 xsr x 23 shr xor c1 mul 23 xsr 13 1 36.4814 0.0394727 100 7.66125
x 32 xsr c2 mul 23 xsr 32 ror 32 xsr 14 1 37.1355 0.0222656 100 8.1775
x c1 mul 32 ror 56 ror 32 shr c2 mul 11 2 38.6506 0.0312988 100 10.5006
c2 x c2 mul c2 mul c2 mul 56 asr mul 12 4 39.6048 0.0402051 100 13.5306
x c2 mul 56 shr c2 mul c2 mul c2 mul 11 4 39.6651 0.0341406 100 12.5413
x 32 xsr 56 xsr c2 mul 23 xsr 56 xsr 15 1 39.89 0.027002 100 6.1175
x c1 mul c2 mul 56 ror c1 mul c1 mul 11 4 40.1505 0.00829102 100 11.3575
x x x 23 shr xor c2 mul xor 32 asr 12 1 40.8395 0.093291 100 18.0562
x 23 xsr c2 xor 56 xsr c1 mul 32 xsr 14 1 42.1998 0.0538672 100 9.46375
x x 23 shr xor c1 mul 32 xsr 32 ror 12 1 45.753 0.11748 100 11.905
x 32 xsr 32 ror 23 shr c1 mul 23 xsr 13 1 48.4187 0.0922852 100 17.1937
x x 23 shr xor c2 mul 32 asr 23 ror 12 1 50.7086 0.0392383 100 16.1994
c1 x 23 asr 23 asr mul 32 asr 23 asr 15 1 54.4869 0.00727539 99.44 11.5906
c1 x 32 asr mul 23 asr 32 ror 23 asr 14 1 55.0574 0.0629199 99.92 19.9788

### Depth 12

search set = {x 32 56 c1 c2 xor shr ror mul xsr asr xrr}
time = 6996s
visited programs = 11811979110
bic mean cutoff = 0.1%

mixer # #muls bic_std bic_mean bic_max sac_max pract_rand comment
c1 x 32 asr mul 32 xsr c1 mul 56 32 xrr 17 2 1.38429 0.000878906 5.04 0.385625
x 56 32 xrr c2 mul 32 xsr c2 mul 32 xsr 17 2 1.38942 0.0120801 5.36 0.38375 15
c2 x 56 asr mul 56 32 xrr c1 mul 32 asr 17 2 1.40399 0.0220801 5.76 0.495
x c2 mul 32 xsr c1 mul 56 32 xrr c2 mul 16 3 1.57433 0.0275 28 0.73375
x c2 x 32 asr mul xor c1 mul 56 32 xrr 16 2 1.98975 0.0294336 50.64 1.31812
x x 32 xsr c2 mul xor c2 mul 56 32 xrr 16 2 1.9994 0.0333887 49 0.445625 16
x 30 xsr c1 mul 27 xsr c2 mul 31 xsr 14 2 2.25399 0.045874 8.4 0.604688 19 split mix
x 33 xsr c3 mul 33 xsr c4 mul 33 xsr 14 2 2.2854 0.00397949 8.8 0.823438 17 murmur3
c1 x c1 mul 56 asr mul 56 32 xrr c2 mul 16 3 3.07241 0.0104297 46.92 0.776875
x c1 mul 56 ror c1 mul 56 32 xrr c2 mul 15 3 3.24618 0.0414453 47.12 0.815
x c2 mul 56 32 xrr c2 mul 56 shr c2 mul 15 3 3.58513 0.012002 61.76 4.29375
x 32 xsr c2 mul 56 ror 56 32 xrr c2 mul 16 2 3.8971 0.00410156 54.24 1.16937
c2 x 32 asr mul 56 ror 56 32 xrr c2 mul 16 2 3.98581 0.0328613 55.88 1.28
x 32 xsr c2 mul 56 32 xrr 56 shr c2 mul 16 2 4.18914 0.0458008 54.24 1.635
c2 x 32 asr mul 56 32 xrr 56 shr c2 mul 16 2 4.24509 0.0720703 55.88 1.1775
x x c1 mul 56 ror xor c2 mul 56 32 xrr 15 2 4.67129 0.131748 62.44 2.22625
x x 32 shr xor c2 mul 56 32 xrr c2 mul 15 2 5.66523 0.0466309 75.4 1.72938
x c2 mul c2 xor c1 mul 56 32 xrr c1 mul 15 3 11.5716 0.0934863 100 3.4825
x x 56 32 xrr 32 asr xor c1 mul 32 xsr 17 1 13.1087 0.0180469 44.64 6.00062
c2 x 32 asr mul 32 asr 32 asr 56 32 xrr 18 1 13.6999 0.0163281 72.76 3.02313 16
x 32 xor 56 xor c1 mul 56 32 xrr c2 mul 15 2 14.1656 0.100361 100 7.70375
x 56 ror c1 mul 56 32 xrr c2 mul 32 ror 15 2 14.2582 0.108789 100 7.62
x 32 asr 32 asr 56 32 xrr c2 mul 32 xsr 18 1 14.2819 0.0699316 62.24 3.2475
x c2 mul 56 32 xrr 56 shr c1 mul 32 ror 15 2 14.3563 0.0355176 100 3.45188
x c1 mul 56 32 xrr c2 mul c2 mul c2 mul 15 4 14.4442 0.0334863 100 6.72938
x 32 xsr c1 mul 56 ror 32 asr 56 32 xrr 17 1 17.92 0.0445898 62.08 6.70562
x x 32 asr 56 ror xor c1 mul 56 32 xrr 16 1 18.0544 0.0228906 79.68 4.18562
c2 x 32 asr mul 32 asr 56 32 xrr x xor 17 1 19.2459 0.0575195 79.08 2.98563
x x 32 xsr 56 ror xor c1 mul 56 32 xrr 16 1 26.3019 0.0587598 81 5.95062
c2 x x 32 shr xor 56 asr mul 56 32 xrr 16 1 28.3285 0.0554297 91.08 6.02813
x 32 xsr 56 xsr c1 xor c2 mul 56 32 xrr 17 1 28.3645 0.128066 92.16 5.88625
x x 32 shr xor c1 mul 56 32 xrr x xor 15 1 29.1301 0.0265527 82.12 6.88625
c2 x 56 ror 32 asr 56 asr mul 56 32 xrr 17 1 29.5345 0.116738 91.88 5.87188
x 32 xsr c2 mul 56 32 xrr x 56 shr xor 16 1 31.4077 0.0331738 92.16 6.155
x x 32 shr 56 ror xor c1 mul 56 32 xrr 15 1 31.475 0.0525098 100 7.51125
x 32 ror 56 32 xrr c2 mul 32 xsr 56 xsr 17 1 33.1199 0.0993457 92.44 8.36562
x 56 asr 56 32 xrr 32 shr c1 mul 32 xsr 17 1 35.9565 0.00206055 91.96 14.6125
x 56 32 xrr 32 shr c1 mul 32 shr c2 mul 15 2 36.456 0.0863574 94.68 12.2494
x 56 32 xrr 32 shr c1 mul 56 ror 32 xsr 16 1 42.4414 0.0861328 100 12.9475
x 56 32 xrr 32 shr c1 mul 56 ror 32 asr 16 1 45.5363 0.0506348 99.24 16.0581

### Depth 13

search set = {x 32 56 c2 xor shr mul xsr asr xrr}
time = 9136s
visited programs = 12294125660
bic mean cutoff = 0.1%

mixer # #muls bic_std bic_mean bic_max sac_max pract_rand comment
x 32 xsr c2 mul 56 32 xrr c2 mul 56 32 xrr 20 2 1.3867 0.0180176 5.52 0.410625 20
c2 x 32 asr mul 32 xsr x xor c2 mul 32 asr 16 2 1.38723 0.0040625 6.28 0.399375
c2 x 32 asr mul 56 asr 32 xsr c2 mul 32 asr 17 2 1.38799 0.0209766 5.2 0.495625
c2 x 32 asr mul 56 32 xrr c2 mul 56 32 xrr 20 2 1.38822 0.0295801 5.68 0.381875
c2 x 32 asr mul 32 xsr c2 mul 32 xsr c2 mul 16 3 1.38835 0.00714844 5.28 0.423125
x 32 xsr c2 mul 32 xsr c2 xor c2 mul 32 xsr 16 2 1.39009 0.000644531 5.84 0.515625 15
c2 x c2 x 32 asr mul xor 56 asr mul 32 asr 16 2 1.39066 0.00163086 5.04 0.464375
x x 32 shr xor c2 mul 32 xsr c2 mul 32 asr 15 2 1.39188 0.00208008 5.44 0.5225
x 32 xsr c2 mul c2 mul 32 xsr c2 mul 32 xsr 16 3 1.39321 0.0171191 5.24 0.4125 15
x c2 mul 32 shr c2 mul 32 xsr c2 mul 32 asr 15 3 1.39595 0.0292773 5.84 0.3975
x x c2 mul 56 xsr c2 mul xor c2 mul 32 asr 15 3 1.39894 0.019248 5.36 0.415
x c2 x 32 asr mul xor 32 shr c2 mul 32 asr 15 2 1.3992 0.0267187 5 0.4325
x 32 xsr c2 mul 32 xsr 56 xsr c2 mul 32 xsr 17 2 1.39947 0.00991211 6 0.4825 15
x x 32 xsr c2 mul 32 shr xor c2 mul 32 xsr 15 2 1.40869 0.061748 5.24 0.500625
x x c2 mul 56 xsr c2 mul xor c2 mul 32 xsr 15 3 1.41263 0.00233398 5.36 0.386875
c2 x c2 x 32 asr mul xor c2 mul 56 asr mul 15 3 1.41359 0.00893555 4.8 0.463125
x c2 mul 32 shr c2 mul 32 xsr c2 mul 32 xsr 15 3 1.41563 0.00922852 5.2 0.410625
x x c2 mul 56 shr c2 mul xor c2 mul 32 xsr 14 3 1.43 0.00725586 6 0.646875
x x c2 mul 56 shr c2 mul xor c2 mul 32 asr 14 3 1.45776 0.0109473 6 0.50125
x c2 mul 56 32 xrr c2 mul 56 32 xrr c2 mul 19 3 1.53985 0.0196191 26.24 0.566875
x x 56 32 xrr c2 mul xor c2 mul 56 32 xrr 19 2 1.90933 0.0565723 51.16 0.3725
x c2 mul c2 mul 32 xsr c2 mul 32 xsr c2 mul 15 4 2.01209 0.0181055 51.08 0.42875
x 30 xsr c1 mul 27 xsr c2 mul 31 xsr 14 2 2.25399 0.045874 8.4 0.604688 19 split mix
x 33 xsr c3 mul 33 xsr c4 mul 33 xsr 14 2 2.2854 0.00397949 8.8 0.823438 17 murmur3
x c2 mul 56 32 xrr 56 shr c2 mul 56 32 xrr 19 2 4.64113 0.070918 57.04 3.55
c2 x c2 mul 56 asr mul 32 xsr c2 mul c2 mul 15 4 6.08414 0.0492676 74.52 1.57063
x c2 mul 32 xsr c2 mul c2 mul 56 shr c2 mul 14 4 6.49379 0.02875 72.12 1.40125
x x c2 mul 32 shr xor c2 mul 56 shr c2 mul 13 3 7.19572 0.038623 72.88 3.49562
x 56 32 xrr c2 mul c2 xor 32 asr 56 32 xrr 20 1 10.4176 0.0163379 58.36 2.68125
x 56 asr 56 32 xrr c2 mul 32 asr 56 32 xrr 21 1 13.2534 0.065459 62.8 4.26625
x x c2 mul c2 mul c2 mul 56 asr xor c2 mul 14 4 16.174 0.012002 100 5.74187
x 32 xsr 56 32 xrr c2 mul 32 asr 56 32 xrr 21 1 16.3197 0.126777 62.84 5.09937
x c2 mul 56 xsr c2 mul 32 xor c2 mul c2 mul 14 4 17.6245 0.0142383 100 7.57875
x x c2 mul c2 mul c2 mul 56 shr xor c2 mul 13 4 18.4004 0.0474219 100 7.285
x x x c2 mul 32 xor 56 shr xor c2 mul xor 13 2 18.5358 0.0488672 100 5.43375
c2 x c2 mul 32 shr c2 mul 32 asr 56 asr mul 15 3 23.2586 0.0126758 86.48 7.38375
x 56 32 xrr 56 xsr c2 mul 56 xsr 56 32 xrr 21 1 24.3171 0.0480176 93.2 4.96938
c2 x 32 asr 32 xsr c2 mul 56 shr 56 asr mul 16 2 24.4837 0.0669336 88.52 9.26125
x 32 asr 32 asr 32 xsr c2 mul 32 xsr 32 asr 18 1 24.607 0.0290039 100 5.45062
c2 c2 x c2 mul 56 asr mul c2 mul 56 asr mul 15 4 24.6517 0.0885547 80.32 5.335
c2 c2 x c2 mul 32 asr mul 56 asr mul 32 asr 16 3 25.3028 0.0675 80.56 8.50625
c2 x c2 mul 32 asr 32 asr 32 asr 56 asr mul 17 2 27.5428 0.0125684 87.76 8.96687
x c2 mul c2 mul 32 shr c2 mul 56 shr c2 mul 13 4 27.8226 0.0301758 87.44 6.425
c2 x c2 mul c2 mul 56 asr mul 56 shr c2 mul 14 4 28.1553 0.0598535 93.52 39.9525
x 32 xsr 56 xsr c2 mul 32 shr c2 mul 56 xsr 16 2 34.4245 0.0190723 95.04 9.1275
x c2 mul 32 asr 32 asr 32 shr c2 mul 32 asr 16 2 35.0357 0.000292969 94.96 14.455
c2 x 32 xsr 56 asr xor c2 mul 32 xsr 32 asr 17 1 35.8979 0.0622656 100 8.6075
x 56 32 xrr 56 xor 56 56 xrr c2 mul 32 xsr 20 1 36.1652 0.0957031 91.32 7.52062
x 32 shr x 56 asr xor c2 mul 32 xsr 32 asr 16 1 36.5339 0.050127 100 9.19
c2 c2 x 32 asr xor 32 asr 56 asr mul 32 asr 17 1 41.0743 0.0127051 99.56 45.2156

Written with StackEdit.