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

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.