*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.*

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.

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.

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.

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).*

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.

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}$.

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.

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.

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;
}
```

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.)

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;
}
```

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.

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.

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.

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.

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**

- The construction of bit mixers
- Tuning bit mixers
- The mx3 mix/prng/hash functions

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.

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 |

add | 1 | + |

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.*

```
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 |

```
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 |

```
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 |

```
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 |

```
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 |

```
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 |

```
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.