From 5b69cfeeb3ccb128669a6e41dfd4496ce0ffb048 Mon Sep 17 00:00:00 2001 From: DOSAYGO Development Team Date: Mon, 30 Dec 2024 21:04:37 +0800 Subject: [PATCH 01/12] RS new --- rain-changes.patch | 2 +- rainstorm-new-changes.patch | 83 +++++++++++++++++++++++++++++++++++++ 2 files changed, 84 insertions(+), 1 deletion(-) create mode 100644 rainstorm-new-changes.patch diff --git a/rain-changes.patch b/rain-changes.patch index b1bdf3d..839a3d4 100644 --- a/rain-changes.patch +++ b/rain-changes.patch @@ -1,7 +1,7 @@ # This patch explores changes to enhance the mixing of rainbow (prompted by Reiner Pope) # and changes to enhance the non invertibility of rainstorm (even given complete state information) # prompted by orlp's 'breaking hash functions' write up: https://orlp.net/blog/breaking-hash-functions/#trivial-fixed-seed-wyhash-multicollisions -# +# the rainstorm passes all diff --git a/hashes/rainbow.cpp b/hashes/rainbow.cpp index 51adfd06..96b44ee5 100644 --- a/hashes/rainbow.cpp diff --git a/rainstorm-new-changes.patch b/rainstorm-new-changes.patch new file mode 100644 index 0000000..6196af7 --- /dev/null +++ b/rainstorm-new-changes.patch @@ -0,0 +1,83 @@ +diff --git a/hashes/rainbow.cpp b/hashes/rainbow.cpp +index 51adfd06..96b44ee5 100644 +--- a/hashes/rainbow.cpp ++++ b/hashes/rainbow.cpp +@@ -71,7 +71,7 @@ static inline void mixB( uint64_t * s, uint64_t iv ) { + b = ROTR64(b, 23); + b *= S; + +- s[1] = a; s[2] = b; ++ s[1] = b; s[2] = a; + } + + template +diff --git a/hashes/rainstorm.cpp b/hashes/rainstorm.cpp +index 789ebfc7..399fd483 100644 +--- a/hashes/rainstorm.cpp ++++ b/hashes/rainstorm.cpp +@@ -101,6 +101,7 @@ static void rainstorm( const void * in, const size_t len, const seed_t seed, voi + + uint64_t temp[8]; + uint64_t lenRemaining = len; ++ uint64_t ctr = CTR_LEFT + CTR_RIGHT; + + // Process 512-bit blocks + while (lenRemaining >= 64) { +@@ -112,6 +113,23 @@ static void rainstorm( const void * in, const size_t len, const seed_t seed, voi + weakfunc(h, temp, i & 1); + } + ++ int bits = __builtin_popcount(h[h[3] & 15]); ++ ++ if ((bits % 3) == 0) { ++ ctr = CTR_LEFT + CTR_RIGHT; ++ } else { ++ ctr ^= h[h[7] & 15]; ++ } ++ ++ for (int i = 0, j = 8; i < 8; i++, j++) { ++ ctr += h[i]; ++ h[i] -= h[j] ^ ctr; ++ } ++ for (int i = 8, j = 0; j < 8; i++, j++) { ++ ctr += h[i]; ++ h[i] -= h[j] ^ ctr; ++ } ++ + data += 64; + lenRemaining -= 64; + } +@@ -155,7 +173,7 @@ REGISTER_FAMILY(rainstorm, + ); + + REGISTER_HASH(rainstorm, +- $.desc = "Rainstorm v0.0.6", ++ $.desc = "Rainstorm v1.3.1", + $.impl_flags = + FLAG_IMPL_ROTATE | + FLAG_IMPL_SLOW | +@@ -168,7 +186,7 @@ REGISTER_HASH(rainstorm, + ); + + REGISTER_HASH(rainstorm_128, +- $.desc = "Rainstorm 128-bit v0.0.6", ++ $.desc = "Rainstorm 128-bit v1.3.1", + $.impl_flags = + FLAG_IMPL_ROTATE | + FLAG_IMPL_SLOW | +@@ -181,13 +199,13 @@ REGISTER_HASH(rainstorm_128, + ); + + REGISTER_HASH(rainstorm_256, +- $.desc = "Rainstorm 256-bit v0.0.6", ++ $.desc = "Rainstorm 256-bit v1.3.1", + $.impl_flags = + FLAG_IMPL_ROTATE | + FLAG_IMPL_SLOW | + FLAG_IMPL_LICENSE_APACHE2, + $.bits = 256, +- $.verification_LE = 0x8BDBF180, ++ $.verification_LE = 0x3A047441, + $.verification_BE = 0xA08B2DEB, + $.hashfn_native = rainstorm<256, false>, + $.hashfn_bswap = rainstorm<256, true> From 22bde307780efc6671fd17199c4d9be9dfd70c8f Mon Sep 17 00:00:00 2001 From: DOSAYGO Development Team Date: Mon, 30 Dec 2024 21:46:58 +0800 Subject: [PATCH 02/12] ok --- .../hash-to-block-to-hash-construction.md | 384 ++++++++++++++++++ .../updates/rain-changes.patch | 0 .../updates/rainstorm-new-changes.patch | 0 3 files changed, 384 insertions(+) create mode 100644 research/updates/hash-to-block-to-hash-construction.md rename rain-changes.patch => research/updates/rain-changes.patch (100%) rename rainstorm-new-changes.patch => research/updates/rainstorm-new-changes.patch (100%) diff --git a/research/updates/hash-to-block-to-hash-construction.md b/research/updates/hash-to-block-to-hash-construction.md new file mode 100644 index 0000000..1ece4d6 --- /dev/null +++ b/research/updates/hash-to-block-to-hash-construction.md @@ -0,0 +1,384 @@ +1. **Standard Constructions: Block Cipher to Cryptographic Hash** +2. **Custom Block Cipher Construction from a Non-Cryptographic Hash Function** +3. **Combining the Constructions: Enhancing Security** +4. **Cryptographic Analysis with Mathematical Rigor** +5. **Potential Attacks and Vulnerabilities** +6. **Conclusion and Recommendations** + +--- + +## 1. Standard Constructions: Block Cipher to Cryptographic Hash + +### 1.1 Davies-Meyer Construction + +The Davies-Meyer (DM) construction is a well-known method to build a cryptographic hash function from a block cipher. Given a block cipher $` E_k `$ that maps a key $` k `$ and a block $` M `$ to a ciphertext $` C `$, the DM construction defines the compression function $` h `$ as follows: + +```math +h(H_{i-1}, M_i) = E_{M_i}(H_{i-1}) \oplus H_{i-1} +``` + +- **Parameters**: + - $` H_{i-1} `$: The previous hash state (output of the previous compression). + - $` M_i `$: The current message block. + - $` E_{M_i} `$: The block cipher encryption function with key $` M_i `$. + - $` \oplus `$: Bitwise XOR operation. + +- **Initialization**: + - $` H_0 `$: An initial vector (IV) of appropriate size. + +- **Hash Computation**: + - For each message block $` M_i `$, compute $` H_i = h(H_{i-1}, M_i) `$. + - The final hash is $` H_n `$, where $` n `$ is the number of blocks. + +### 1.2 Merkle-Damgård Construction + +Another standard method is the Merkle-Damgård (MD) construction, which can use various compression functions, including those derived from block ciphers. The general form is: + +```math +H_i = f(H_{i-1}, M_i) +``` + +Where $` f `$ is a compression function that combines the previous hash state with the current message block. While DM is a specific instance of MD using block ciphers, MD can also employ other primitives. + +--- + +## 2. Custom Block Cipher Construction from a Non-Cryptographic Hash Function + +Your proposal involves constructing a block cipher from a non-cryptographic (good mixing) hash function $` H `$. Let's formalize this construction mathematically and provide pseudocode. + +### 2.1 Block Cipher Construction + +#### **Encryption Process** + +Given: +- **Key**: $` K `$ (fixed-length bitstring) +- **Plaintext Block**: $` P `$ (fixed-length bitstring) +- **Nonce**: $` N `$ (variable-length bitstring, typically random or sequential) + +**Steps**: +1. **Concatenation**: $` K \| N `$ +2. **Hashing**: Compute $` D = H(K \| N) `$ +3. **Check for Inclusion**: Verify if all bytes of $` P `$ are present in $` D `$ +4. **Index Extraction**: If present, record the indices $` \{i_1, i_2, \ldots, i_m\} `$ where each byte of $` P `$ appears in $` D `$ +5. **Output**: $` C = (N, \{i_j\}) `$ + +If not all bytes are present, iterate with a new nonce $` N' `$. + +#### **Decryption Process** + +Given: +- **Key**: $` K `$ +- **Ciphertext**: $` C = (N, \{i_j\}) `$ + +**Steps**: +1. **Concatenation**: $` K \| N `$ +2. **Hashing**: Compute $` D = H(K \| N) `$ +3. **Byte Extraction**: Extract bytes at indices $` \{i_j\} `$ from $` D `$ +4. **Reconstruct Plaintext**: $` P = \{D[i_1], D[i_2], \ldots, D[i_m]\} `$ + +**Pseudocode for Encryption:** + +```python +def encrypt(K, P, H): + while True: + N = generate_nonce() + D = H(K + N) + indices = find_indices(D, P) + if indices is not None: + return (N, indices) +``` + +**Pseudocode for Decryption:** + +```python +def decrypt(K, C, H): + N, indices = C + D = H(K + N) + P = extract_bytes(D, indices) + return P +``` + +### 2.2 Mathematical Representation + +Let: +- $` H: \{0,1\}^* \rightarrow \{0,1\}^n `$ be the hash function. +- $` P = p_1 p_2 \ldots p_m `$, where $` p_j \in \{0,1\}^b `$ (byte length $` b `$). + +**Encryption Equation:** + +```math +\begin{aligned} +& \text{Find } N \in \{0,1\}^* \text{ such that } \forall p_j \in P, \exists i_j \text{ with } D[i_j] = p_j \\ +& D = H(K \| N) \\ +& C = (N, \{i_j\}) +\end{aligned} +``` + +**Decryption Equation:** + +```math +P = \{ D[i_j] \mid j = 1, 2, \ldots, m \} +``` + +--- + +## 3. Combining the Constructions: Enhancing Security + +Once we have a block cipher $` E `$ constructed from the non-cryptographic hash $` H `$, we can employ the Davies-Meyer (or another) construction to build a cryptographic hash function $` G `$. + +### 3.1 Combined Construction + +```math +G(H_{i-1}, M_i) = E_{M_i}(H_{i-1}) \oplus H_{i-1} +``` + +Where: +- $` E_{M_i} `$ is the block cipher constructed from $` H `$ as described above. +- $` H_{i-1} `$ is the previous hash state. +- $` M_i `$ is the current message block. + +### 3.2 Mathematical Formulation + +Assume: +- $` E_{M_i}(H_{i-1}) = (N_i, \{j_k\}) `$, where $` N_i `$ is the nonce found during encryption, and $` \{j_k\} `$ are the indices corresponding to the plaintext block. + +The hash state update becomes: + +```math +H_i = E_{M_i}(H_{i-1}) \oplus H_{i-1} +``` + +Given the construction of $` E `$, this can be expanded as: + +```math +H_i = (N_i, \{j_k\}) \oplus H_{i-1} +``` + +*Note*: The XOR operation here is conceptual; in practice, the combination of nonce and indices would need to be encoded into a fixed-size block compatible with $` H_{i-1} `$. + +--- + +## 4. Cryptographic Analysis with Mathematical Rigor + +### 4.1 Security Goals + +For the resulting hash function $` G `$ to be cryptographically secure, it must satisfy: + +1. **Preimage Resistance**: Given $` h `$, finding $` (H_{i-1}, M_i) `$ such that $` G(H_{i-1}, M_i) = h `$ should be computationally infeasible. + +2. **Second Preimage Resistance**: Given $` (H_{i-1}, M_i) `$, finding $` M_i' \neq M_i `$ such that $` G(H_{i-1}, M_i) = G(H_{i-1}, M_i') `$ should be hard. + +3. **Collision Resistance**: Finding any two distinct inputs $` (H_{i-1}, M_i) `$ and $` (H_{j-1}, M_j) `$ such that $` G(H_{i-1}, M_i) = G(H_{j-1}, M_j) `$ should be difficult. + +### 4.2 Analyzing the Block Cipher $` E `$ + +#### **Invertibility and Attack Surface** + +The block cipher $` E `$ constructed from $` H `$ is invertible by design, as per your construction. However, the security of $` E `$ depends on: + +1. **Difficulty of Finding $` N `$ Given $` P `$ and $` K `$**: The encryption step involves finding a nonce $` N `$ such that $` H(K \| N) `$ contains $` P `$. If $` H `$ is non-cryptographic, this process might be susceptible to preimage or structure-based attacks. + +2. **Uniqueness and Randomness of $` N `$**: If the selection of $` N `$ can be predicted or if $` H `$ introduces biases, the block cipher $` E `$ may leak information about $` K `$ or $` P `$. + +3. **Resistance to Differential and Linear Cryptanalysis**: The non-cryptographic nature of $` H `$ may introduce patterns or linear relations that can be exploited. + +#### **Mathematical Vulnerabilities** + +Let’s consider the following potential vulnerabilities: + +1. **Linearity**: + + If $` H `$ exhibits linear properties, such as: + + ```math + H(a \| N_1) \oplus H(b \| N_2) = H(a \oplus b \| N_1 \oplus N_2) + ``` + + Then, attackers can exploit this linearity to find relationships between different ciphertexts. + +2. **Differential Behavior**: + + If small changes in $` K `$ or $` N `$ lead to predictable changes in $` D = H(K \| N) `$, then differential attacks can be mounted. + +### 4.3 Impact on the Hash Function $` G `$ + +Even if $` E `$ has certain vulnerabilities, the hash function $` G `$ might inherit or amplify these issues. For example: + +1. **Collision Propagation**: + + If $` E `$ is prone to collisions, then $` G `$ will also be susceptible since $` G `$ relies on $` E `$ to process each message block. + +2. **Preimage and Second Preimage**: + + Weaknesses in $` E `$ directly translate to weaknesses in finding preimages for $` G `$. + +--- + +## 5. Potential Attacks and Vulnerabilities + +Let's explore specific attack vectors that could compromise the security of the proposed hash function $` G `$. + +### 5.1 Preimage Attack + +**Goal**: Given a hash output $` h `$, find a message $` M `$ such that $` G(\text{IV}, M) = h `$. + +**Attack Steps**: + +1. **Target**: Identify a specific $` H_i = h `$ by reversing the hash function. +2. **Exploitation**: Use the invertibility of $` E `$ to reverse-engineer $` N `$ and $` \{j_k\} `$ from $` h `$. +3. **Reconstruction**: Once $` N `$ is found, reconstruct $` K `$ or $` P `$ by exploiting structural weaknesses in $` H `$. + +**Mathematical Formulation**: + +Given $` H_i = (N_i, \{j_k\}) \oplus H_{i-1} = h `$, solve for $` N_i `$ and $` \{j_k\} `$: + +```math +(N_i, \{j_k\}) = h \oplus H_{i-1} +``` + +Since $` H `$ is non-cryptographic and invertible, if $` H `$ is weak, this equation might be solvable without exhaustive search. + +### 5.2 Collision Attack + +**Goal**: Find two distinct messages $` M `$ and $` M' `$ such that $` G(\text{IV}, M) = G(\text{IV}, M') `$. + +**Attack Steps**: + +1. **Collision in $` E `$**: Find two different message blocks $` M `$ and $` M' `$ that produce the same $` E_{M}(H_{i-1}) `$. + +2. **Hash Collision**: Since $` G `$ relies on $` E `$, a collision in $` E `$ leads directly to a collision in $` G `$. + +**Mathematical Formulation**: + +Find $` M \neq M' `$ such that: + +```math +E_{M}(H_{i-1}) \oplus H_{i-1} = E_{M'}(H_{i-1}) \oplus H_{i-1} +``` + +Which simplifies to: + +```math +E_{M}(H_{i-1}) = E_{M'}(H_{i-1}) +``` + +If $` E `$ is weak, finding such $` M `$ and $` M' `$ becomes feasible. + +### 5.3 Linear Cryptanalysis + +**Goal**: Exploit linear approximations between the plaintext, ciphertext, and key. + +**Attack Steps**: + +1. **Identify Linear Relations**: Discover equations where certain linear combinations of plaintext bits, ciphertext bits, and key bits hold with higher probability. + +2. **Statistics Gathering**: Collect a large number of plaintext-ciphertext pairs to find biases in these linear relations. + +3. **Solve for Key Bits**: Use the biases to derive information about the key $` K `$. + +**Mathematical Example**: + +Suppose $` H `$ satisfies: + +```math +H(K \| N) = a(K) \cdot N + b(K) +``` + +for some linear functions $` a `$ and $` b `$. Then, + +```math +E_M(H_{i-1}) = (N, \{j_k\}) = H(K \| N) \implies (N, \{j_k\}) = a(K) \cdot N + b(K) +``` + +This linear relationship can be exploited to solve for $` K `$. + +### 5.4 Differential Cryptanalysis + +**Goal**: Analyze how differences in input pairs affect the resultant difference at the output. + +**Attack Steps**: + +1. **Choose Differing Inputs**: Select two nonces $` N `$ and $` N' = N \oplus \Delta N `$. + +2. **Analyze Output Differences**: Compute $` D = H(K \| N) `$ and $` D' = H(K \| N') `$ and analyze $` \Delta D = D \oplus D' `$. + +3. **Propagate Differences**: Observe how differences in $` D `$ affect the indices $` \{j_k\} `$ and consequently the hash state $` H_i `$. + +**Mathematical Formulation**: + +Given $` \Delta N = N \oplus N' `$: + +```math +\Delta D = H(K \| N) \oplus H(K \| N') = H(K \| N) \oplus H(K \| N \oplus \Delta N) +``` + +If $` H `$ is linear or has predictable differential patterns, $` \Delta D `$ can reveal information about $` K `$ or $` N `$. + +--- + +## 6. Conclusion and Recommendations + +### 6.1 Summary of Findings + +- **Invertibility vs. Security**: While invertibility in the state transformation avoids entropy loss and ensures long cycles, it inherently introduces vulnerabilities that are exploitable, especially if the underlying hash function $` H `$ lacks cryptographic robustness. + +- **Dependence on $` H `$**: The security of both the custom block cipher $` E `$ and the resulting hash function $` G `$ heavily depends on the cryptographic strength of $` H `$. Non-cryptographic hashes typically fail to provide properties like preimage resistance, collision resistance, and diffusion, making them unsuitable as foundations for cryptographic constructions. + +- **Potential for Enhanced Security**: Standard constructions like Davies-Meyer rely on the assumption that the underlying block cipher is secure. Introducing a weak block cipher undermines this assumption, and standard transformations do not inherently compensate for the block cipher's deficiencies. + +### 6.2 Recommendations + +1. **Use Cryptographic Hash Functions**: Instead of starting with a non-cryptographic hash $` H `$, employ a cryptographic hash function that satisfies necessary security properties. This foundation is crucial for building secure cryptographic primitives. + +2. **Enhance Block Cipher Security**: If you wish to proceed with constructing a block cipher from a hash function, incorporate additional cryptographic mechanisms to mitigate weaknesses. For example: + - **Nonlinearity**: Introduce nonlinear transformations to disrupt linear patterns. + - **S-boxes**: Utilize substitution boxes to obscure input-output relations. + - **Multiple Rounds**: Apply multiple hashing iterations with varying nonces and transformations to increase complexity. + +3. **Formal Security Proofs**: Develop rigorous mathematical proofs or reductions that demonstrate the security properties of the combined construction $` G `$, ensuring that vulnerabilities in $` E `$ do not propagate to $` G `$. + +4. **Prototype and Analyze**: Implement the proposed construction and subject it to standard cryptanalytic evaluations. Practical testing can reveal vulnerabilities not apparent in theoretical analysis. + +5. **Community Review**: Engage with the cryptographic community for peer review. Independent analysis is vital for identifying and addressing potential security flaws. + +6. **Avoid Reinventing Primitives**: Given the maturity of existing cryptographic hash functions and block cipher constructions, carefully evaluate whether a new construction offers significant advantages over established standards. + +--- + +## Appendices + +### Appendix A: Pseudocode for Attack Scenarios + +#### A.1 Preimage Attack Example + +```python +def preimage_attack(target_hash, H, K): + for N in nonce_space(): + D = H(K + N) + if D_contains_target(D, target_hash): + indices = extract_indices(D, target_hash) + return (N, indices) + return None +``` + +*Explanation*: Iterate over possible nonces $` N `$, compute $` D = H(K \| N) `$, and check if $` D `$ contains the target hash. If found, return the corresponding $` N `$ and indices. + +#### A.2 Collision Attack Example + +```python +def collision_attack(G, H, K, message_pairs): + hash_map = {} + for (M1, M2) in message_pairs: + H1 = G(H, K, M1) + H2 = G(H, K, M2) + if H1 == H2: + return (M1, M2) + hash_map[H1] = M1 + return None +``` + +*Explanation*: Generate hash outputs for different message pairs and check for collisions by comparing hash outputs. + +--- + +By incorporating detailed mathematical descriptions, pseudocode, and a thorough cryptographic analysis, this response aims to provide a comprehensive evaluation of your proposed construction. The analysis highlights significant vulnerabilities stemming from the use of a non-cryptographic hash function and underscores the importance of leveraging well-established cryptographic primitives to ensure security. diff --git a/rain-changes.patch b/research/updates/rain-changes.patch similarity index 100% rename from rain-changes.patch rename to research/updates/rain-changes.patch diff --git a/rainstorm-new-changes.patch b/research/updates/rainstorm-new-changes.patch similarity index 100% rename from rainstorm-new-changes.patch rename to research/updates/rainstorm-new-changes.patch From 1cc9062de823a7625301dd30462c2e82bf663d78 Mon Sep 17 00:00:00 2001 From: DOSAYGO Development Team Date: Mon, 30 Dec 2024 21:47:51 +0800 Subject: [PATCH 03/12] good --- research/updates/hash-to-block-to-hash-construction.md | 2 -- 1 file changed, 2 deletions(-) diff --git a/research/updates/hash-to-block-to-hash-construction.md b/research/updates/hash-to-block-to-hash-construction.md index 1ece4d6..b89299c 100644 --- a/research/updates/hash-to-block-to-hash-construction.md +++ b/research/updates/hash-to-block-to-hash-construction.md @@ -379,6 +379,4 @@ def collision_attack(G, H, K, message_pairs): *Explanation*: Generate hash outputs for different message pairs and check for collisions by comparing hash outputs. ---- -By incorporating detailed mathematical descriptions, pseudocode, and a thorough cryptographic analysis, this response aims to provide a comprehensive evaluation of your proposed construction. The analysis highlights significant vulnerabilities stemming from the use of a non-cryptographic hash function and underscores the importance of leveraging well-established cryptographic primitives to ensure security. From e799e7ee6c1c35ffd4673c91980f12cdd390890a Mon Sep 17 00:00:00 2001 From: DOSAYGO Development Team Date: Mon, 30 Dec 2024 23:07:04 +0800 Subject: [PATCH 04/12] Results for rainstorm variant diff loaded at commit here 1cc906 --- .../updates/rainstorm-variant-results.txt | 5636 +++++++++++++++++ 1 file changed, 5636 insertions(+) create mode 100644 research/updates/rainstorm-variant-results.txt diff --git a/research/updates/rainstorm-variant-results.txt b/research/updates/rainstorm-variant-results.txt new file mode 100644 index 0000000..89b4043 --- /dev/null +++ b/research/updates/rainstorm-variant-results.txt @@ -0,0 +1,5636 @@ +cris@MacBook-Air:~/smhasher3$ ./build/SMHasher3 --ncpu=8 --test=All --extra rainstorm-256 +------------------------------------------------------------------------------- +--- Testing rainstorm-256 "Rainstorm 256-bit v1.3.1" + +[[[ Sanity Tests ]]] + +Verification value LE 0x59CCB2BE ...... PASS +Running sanity check 1 .......... PASS +Running sanity check 2 .......... PASS +Running append zeroes test .......... PASS +Running prepend zeroes test .......... PASS +Running thread-safety test 1 .......... PASS +Running thread-safety test 2 .......... PASS + +[[[ Speed Tests ]]] + +Small key speed test - [1, 31]-byte keys + 1-byte keys - 1.57 cycles/hash + 2-byte keys - 1.58 cycles/hash + 3-byte keys - 1.57 cycles/hash + 4-byte keys - 1.58 cycles/hash + 5-byte keys - 1.58 cycles/hash + 6-byte keys - 1.54 cycles/hash + 7-byte keys - 1.52 cycles/hash + 8-byte keys - 1.59 cycles/hash + 9-byte keys - 1.56 cycles/hash + 10-byte keys - 1.58 cycles/hash + 11-byte keys - 1.60 cycles/hash + 12-byte keys - 1.60 cycles/hash + 13-byte keys - 1.54 cycles/hash + 14-byte keys - 1.53 cycles/hash + 15-byte keys - 1.41 cycles/hash + 16-byte keys - 1.58 cycles/hash + 17-byte keys - 1.59 cycles/hash + 18-byte keys - 1.58 cycles/hash + 19-byte keys - 1.61 cycles/hash + 20-byte keys - 1.54 cycles/hash + 21-byte keys - 1.55 cycles/hash + 22-byte keys - 1.41 cycles/hash + 23-byte keys - 1.39 cycles/hash + 24-byte keys - 1.59 cycles/hash + 25-byte keys - 1.59 cycles/hash + 26-byte keys - 1.58 cycles/hash + 27-byte keys - 1.54 cycles/hash + 28-byte keys - 1.54 cycles/hash + 29-byte keys - 1.44 cycles/hash + 30-byte keys - 1.41 cycles/hash + 31-byte keys - 1.38 cycles/hash +Average - 1.54 cycles/hash + rnd-byte keys - 1.56 cycles/hash + +Bulk speed test - 262144-byte keys +Alignment 7 - 71.53 bytes/cycle - 233.15 GiB/sec @ 3.5 ghz +Alignment 6 - 71.55 bytes/cycle - 233.21 GiB/sec @ 3.5 ghz +Alignment 5 - 71.27 bytes/cycle - 232.33 GiB/sec @ 3.5 ghz +Alignment 4 - 71.41 bytes/cycle - 232.77 GiB/sec @ 3.5 ghz +Alignment 3 - 71.29 bytes/cycle - 232.39 GiB/sec @ 3.5 ghz +Alignment 2 - 71.43 bytes/cycle - 232.83 GiB/sec @ 3.5 ghz +Alignment 1 - 71.39 bytes/cycle - 232.70 GiB/sec @ 3.5 ghz +Alignment 0 - 71.35 bytes/cycle - 232.58 GiB/sec @ 3.5 ghz +Average - 71.40 bytes/cycle - 232.74 GiB/sec @ 3.5 ghz +Alignment rnd - 71.20 bytes/cycle - 232.07 GiB/sec @ 3.5 ghz + +Bulk speed test - [262017, 262144]-byte keys +Alignment 7 - 70.70 bytes/cycle - 230.47 GiB/sec @ 3.5 ghz +Alignment 6 - 70.80 bytes/cycle - 230.79 GiB/sec @ 3.5 ghz +Alignment 5 - 70.73 bytes/cycle - 230.55 GiB/sec @ 3.5 ghz +Alignment 4 - 70.70 bytes/cycle - 230.47 GiB/sec @ 3.5 ghz +Alignment 3 - 70.69 bytes/cycle - 230.44 GiB/sec @ 3.5 ghz +Alignment 2 - 70.69 bytes/cycle - 230.41 GiB/sec @ 3.5 ghz +Alignment 1 - 70.76 bytes/cycle - 230.64 GiB/sec @ 3.5 ghz +Alignment 0 - 70.78 bytes/cycle - 230.73 GiB/sec @ 3.5 ghz +Average - 70.73 bytes/cycle - 230.56 GiB/sec @ 3.5 ghz +Alignment rnd - 70.33 bytes/cycle - 229.25 GiB/sec @ 3.5 ghz + +[[[ 'Hashmap' Speed Tests ]]] + +std::unordered_map +Init std HashMapTest: 4.525 cycles/op (792291 inserts, 1% deletions) +Running std HashMapTest: 3.681 cycles/op (0.0 stdv) + +greg7mdp/parallel-hashmap +Init fast HashMapTest: 2.284 cycles/op (792291 inserts, 1% deletions) +Running fast HashMapTest: 3.887 cycles/op (0.0 stdv) + +[[[ Avalanche Tests ]]] + +Testing 3-byte keys, 300000 reps..................max is 0.743% at bit 17 -> out 77 (^ 2) +Testing 4-byte keys, 300000 reps..................max is 0.905% at bit 0 -> out 255 (^ 7) +Testing 5-byte keys, 300000 reps..................max is 0.839% at bit 3 -> out 209 (^ 4) +Testing 6-byte keys, 300000 reps..................max is 0.825% at bit 47 -> out 223 (^ 3) +Testing 7-byte keys, 300000 reps..................max is 0.683% at bit 6 -> out 21 (^ 0) +Testing 8-byte keys, 300000 reps..................max is 0.718% at bit 37 -> out 9 (^ 0) +Testing 9-byte keys, 300000 reps..................max is 0.747% at bit 69 -> out 91 (^ 0) +Testing 10-byte keys, 300000 reps..................max is 0.720% at bit 18 -> out 51 (^ 0) +Testing 12-byte keys, 300000 reps..................max is 0.757% at bit 14 -> out 70 (^ 0) +Testing 16-byte keys, 300000 reps..................max is 0.847% at bit 75 -> out 162 (^ 3) +Testing 20-byte keys, 300000 reps..................max is 0.755% at bit 134 -> out 217 (^ 0) +Testing 24-byte keys, 300000 reps..................max is 0.893% at bit 88 -> out 7 (^ 4) +Testing 28-byte keys, 300000 reps..................max is 0.816% at bit 156 -> out 233 (^ 1) +Testing 32-byte keys, 300000 reps..................max is 0.920% at bit 231 -> out 209 (^ 5) +Testing 40-byte keys, 300000 reps..................max is 0.737% at bit 306 -> out 195 (^ 0) +Testing 48-byte keys, 300000 reps..................max is 0.911% at bit 86 -> out 64 (^ 4) +Testing 56-byte keys, 300000 reps..................max is 0.784% at bit 97 -> out 90 (^ 0) +Testing 64-byte keys, 300000 reps..................max is 0.857% at bit 350 -> out 165 (^ 1) +Testing 128-byte keys, 300000 reps..................max is 0.865% at bit 373 -> out 110 (^ 1) +Testing 160-byte keys, 300000 reps..................max is 0.865% at bit 603 -> out 35 (^ 0) +Testing 192-byte keys, 300000 reps..................max is 0.863% at bit 358 -> out 57 (^ 0) + + +[[[ BIC 'Bit Independence Criteria' Tests ]]] + +Testing 3-byte keys, 200000 reps............max 0.0120 at bit 0 -> out ( 8, 67) (^ 4) +Testing 8-byte keys, 200000 reps............max 0.0111 at bit 39 -> out (216,246) (^ 0) +Testing 11-byte keys, 200000 reps............max 0.0113 at bit 70 -> out (217,255) (^ 0) +Testing 15-byte keys, 200000 reps............max 0.0116 at bit 72 -> out (146,250) (^ 0) + + +[[[ Keyset 'Zeroes' Tests ]]] + +Keyset 'Zeroes' - 204800 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 4.9, actual 6 (1.229x) (^ 1) +Testing all collisions (low 32-bit) - Expected 4.9, actual 6 (1.229x) (^ 1) +Testing all collisions (high 27-bit) - Expected 156.2, actual 149 (0.954x) (^ 0) +Testing all collisions (low 27-bit) - Expected 156.2, actual 186 (1.191x) (^ 6) +Testing all collisions (high 16..30 bits) - Worst is 30 bits: 23/20 (1.178x) (^ 0) +Testing all collisions (low 16..30 bits) - Worst is 27 bits: 186/156 (1.191x) (^ 2) +Testing distribution (any 8..15 bits) - Worst bias is 15 bits at bit 210: 0.566x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 4.9, actual 4 (0.819x) (^ 0) +Testing all collisions (low 32-bit) - Expected 4.9, actual 5 (1.000x) (^ 1) +Testing all collisions (high 27-bit) - Expected 156.2, actual 168 (1.076x) (^ 2) +Testing all collisions (low 27-bit) - Expected 156.2, actual 164 (1.050x) (^ 1) +Testing all collisions (high 16..30 bits) - Worst is 27 bits: 168/156 (1.076x) (^ 0) +Testing all collisions (low 16..30 bits) - Worst is 29 bits: 52/39 (1.331x) (^ 1) +Testing distribution (any 8..15 bits) - Worst bias is 11 bits at bit 177: 0.904x (^ 5) + + +[[[ Keyset 'Cyclic' Tests ]]] + +Keyset 'Cyclic' - 4 cycles of 3 bytes - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 121 (1.039x) (^ 1) +Testing all collisions (low 32-bit) - Expected 116.4, actual 121 (1.039x) (^ 1) +Testing all collisions (high 16..35 bits) - Worst is 35 bits: 20/15 (1.374x) (^ 0) +Testing all collisions (low 16..35 bits) - Worst is 34 bits: 33/29 (1.134x) (^ 0) + +Keyset 'Cyclic' - 4 cycles of 4 bytes - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 109 (0.936x) (^ 0) +Testing all collisions (low 32-bit) - Expected 116.4, actual 116 (1.000x) (^ 0) +Testing all collisions (high 16..35 bits) - Worst is 29 bits: 964/931 (1.036x) (^ 0) +Testing all collisions (low 16..35 bits) - Worst is 34 bits: 38/29 (1.306x) (^ 0) + +Keyset 'Cyclic' - 4 cycles of 5 bytes - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 93 (0.799x) (^ 0) +Testing all collisions (low 32-bit) - Expected 116.4, actual 128 (1.100x) (^ 2) +Testing all collisions (high 16..35 bits) - Worst is 28 bits: 1936/1860 (1.041x) (^ 0) +Testing all collisions (low 16..35 bits) - Worst is 25 bits: 14910/14754 (1.011x) (^ 0) + +Keyset 'Cyclic' - 4 cycles of 8 bytes - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 112 (0.962x) (^ 0) +Testing all collisions (low 32-bit) - Expected 116.4, actual 116 (1.000x) (^ 0) +Testing all collisions (high 16..35 bits) - Worst is 22 bits: 110659/110274 (1.003x) (^ 0) +Testing all collisions (low 16..35 bits) - Worst is 23 bits: 57595/57305 (1.005x) (^ 0) + +Keyset 'Cyclic' - 8 cycles of 3 bytes - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 122 (1.048x) (^ 1) +Testing all collisions (low 32-bit) - Expected 116.4, actual 131 (1.125x) (^ 3) +Testing all collisions (high 16..35 bits) - Worst is 25 bits: 14837/14754 (1.006x) (^ 0) +Testing all collisions (low 16..35 bits) - Worst is 34 bits: 43/29 (1.477x) (^ 2) + +Keyset 'Cyclic' - 8 cycles of 4 bytes - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 119 (1.022x) (^ 1) +Testing all collisions (low 32-bit) - Expected 116.4, actual 154 (1.323x) (^10) +Testing all collisions (high 16..35 bits) - Worst is 35 bits: 18/15 (1.237x) (^ 0) +Testing all collisions (low 16..35 bits) - Worst is 32 bits: 154/116 (1.323x) (^ 6) + +Keyset 'Cyclic' - 8 cycles of 5 bytes - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 132 (1.134x) (^ 3) +Testing all collisions (low 32-bit) - Expected 116.4, actual 124 (1.065x) (^ 1) +Testing all collisions (high 16..35 bits) - Worst is 32 bits: 132/116 (1.134x) (^ 0) +Testing all collisions (low 16..35 bits) - Worst is 27 bits: 3804/3716 (1.024x) (^ 0) + +Keyset 'Cyclic' - 8 cycles of 8 bytes - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 113 (0.971x) (^ 0) +Testing all collisions (low 32-bit) - Expected 116.4, actual 105 (0.902x) (^ 0) +Testing all collisions (high 16..35 bits) - Worst is 26 bits: 7530/7414 (1.016x) (^ 0) +Testing all collisions (low 16..35 bits) - Worst is 27 bits: 3787/3716 (1.019x) (^ 0) + +Keyset 'Cyclic' - 12 cycles of 3 bytes - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 106 (0.911x) (^ 0) +Testing all collisions (low 32-bit) - Expected 116.4, actual 102 (0.876x) (^ 0) +Testing all collisions (high 16..35 bits) - Worst is 29 bits: 950/931 (1.021x) (^ 0) +Testing all collisions (low 16..35 bits) - Worst is 21 bits: 204790/204642 (1.001x) (^ 0) + +Keyset 'Cyclic' - 12 cycles of 4 bytes - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 103 (0.885x) (^ 0) +Testing all collisions (low 32-bit) - Expected 116.4, actual 149 (1.280x) (^ 8) +Testing all collisions (high 16..35 bits) - Worst is 23 bits: 57669/57305 (1.006x) (^ 0) +Testing all collisions (low 16..35 bits) - Worst is 32 bits: 149/116 (1.280x) (^ 4) + +Keyset 'Cyclic' - 12 cycles of 5 bytes - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 102 (0.876x) (^ 0) +Testing all collisions (low 32-bit) - Expected 116.4, actual 127 (1.091x) (^ 2) +Testing all collisions (high 16..35 bits) - Worst is 23 bits: 57579/57305 (1.005x) (^ 0) +Testing all collisions (low 16..35 bits) - Worst is 28 bits: 1965/1860 (1.056x) (^ 2) + +Keyset 'Cyclic' - 12 cycles of 8 bytes - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 117 (1.000x) (^ 1) +Testing all collisions (low 32-bit) - Expected 116.4, actual 110 (0.945x) (^ 0) +Testing all collisions (high 16..35 bits) - Worst is 25 bits: 14936/14754 (1.012x) (^ 0) +Testing all collisions (low 16..35 bits) - Worst is 23 bits: 57868/57305 (1.010x) (^ 2) + +Keyset 'Cyclic' - 16 cycles of 3 bytes - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 115 (0.988x) (^ 0) +Testing all collisions (low 32-bit) - Expected 116.4, actual 99 (0.850x) (^ 0) +Testing all collisions (high 16..35 bits) - Worst is 35 bits: 25/15 (1.718x) (^ 2) +Testing all collisions (low 16..35 bits) - Worst is 30 bits: 483/466 (1.038x) (^ 0) + +Keyset 'Cyclic' - 16 cycles of 4 bytes - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 104 (0.893x) (^ 0) +Testing all collisions (low 32-bit) - Expected 116.4, actual 120 (1.031x) (^ 1) +Testing all collisions (high 16..35 bits) - Worst is 34 bits: 33/29 (1.134x) (^ 0) +Testing all collisions (low 16..35 bits) - Worst is 28 bits: 1931/1860 (1.038x) (^ 0) + +Keyset 'Cyclic' - 16 cycles of 5 bytes - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 98 (0.842x) (^ 0) +Testing all collisions (low 32-bit) - Expected 116.4, actual 113 (0.971x) (^ 0) +Testing all collisions (high 16..35 bits) - Worst is 35 bits: 19/15 (1.306x) (^ 0) +Testing all collisions (low 16..35 bits) - Worst is 20 bits: 356070/355464 (1.002x) (^ 0) + +Keyset 'Cyclic' - 16 cycles of 8 bytes - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 122 (1.048x) (^ 1) +Testing all collisions (low 32-bit) - Expected 116.4, actual 114 (0.979x) (^ 0) +Testing all collisions (high 16..35 bits) - Worst is 29 bits: 1010/931 (1.085x) (^ 3) +Testing all collisions (low 16..35 bits) - Worst is 24 bits: 29492/29219 (1.009x) (^ 0) + + +[[[ Keyset 'Sparse' Tests ]]] + +Keyset 'Sparse' - 2-byte keys with up to 6 bits set - 14893 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 20-bit) - Expected 105.3, actual 110 (1.045x) (^ 1) +Testing all collisions (low 20-bit) - Expected 105.3, actual 106 (1.000x) (^ 1) +Testing all collisions (high 10..23 bits) - Worst is 15 bits: 2992/2925 (1.023x) (^ 0) +Testing all collisions (low 10..23 bits) - Worst is 16 bits: 1635/1571 (1.041x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 20-bit) - Expected 105.3, actual 100 (0.950x) (^ 0) +Testing all collisions (low 20-bit) - Expected 105.3, actual 109 (1.036x) (^ 1) +Testing all collisions (high 10..23 bits) - Worst is 23 bits: 20/13 (1.514x) (^ 0) +Testing all collisions (low 10..23 bits) - Worst is 16 bits: 1625/1571 (1.034x) (^ 0) + +Keyset 'Sparse' - 3-byte keys with up to 4 bits set - 12951 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 19-bit) - Expected 158.6, actual 138 (0.870x) (^ 0) +Testing all collisions (low 19-bit) - Expected 158.6, actual 151 (0.952x) (^ 0) +Testing all collisions (high 10..22 bits) - Worst is 22 bits: 20/20 (1.001x) (^ 0) +Testing all collisions (low 10..22 bits) - Worst is 12 bits: 9044/9028 (1.002x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 19-bit) - Expected 158.6, actual 125 (0.788x) (^ 0) +Testing all collisions (low 19-bit) - Expected 158.6, actual 145 (0.914x) (^ 0) +Testing all collisions (high 10..22 bits) - Worst is 14 bits: 4023/3999 (1.006x) (^ 0) +Testing all collisions (low 10..22 bits) - Worst is 22 bits: 23/20 (1.152x) (^ 0) + +Keyset 'Sparse' - 4-byte keys with up to 4 bits set - 41449 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 0.2, actual 0 (0.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 0.2, actual 0 (0.000x) (^ 0) +Testing all collisions (high 23-bit) - Expected 102.2, actual 107 (1.047x) (^ 1) +Testing all collisions (low 23-bit) - Expected 102.2, actual 120 (1.174x) (^ 4) +Testing all collisions (high 12..26 bits) - Worst is 16 bits: 10789/10731 (1.005x) (^ 0) +Testing all collisions (low 12..26 bits) - Worst is 22 bits: 229/204 (1.122x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 0.2, actual 0 (0.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 0.2, actual 0 (0.000x) (^ 0) +Testing all collisions (high 23-bit) - Expected 102.2, actual 102 (1.000x) (^ 0) +Testing all collisions (low 23-bit) - Expected 102.2, actual 95 (0.929x) (^ 0) +Testing all collisions (high 12..26 bits) - Worst is 20 bits: 825/809 (1.020x) (^ 0) +Testing all collisions (low 12..26 bits) - Worst is 17 bits: 6022/5914 (1.018x) (^ 0) + +Keyset 'Sparse' - 5-byte keys with up to 4 bits set - 102091 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 1.2, actual 1 (1.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 1.2, actual 1 (1.000x) (^ 0) +Testing all collisions (high 25-bit) - Expected 155.1, actual 165 (1.063x) (^ 2) +Testing all collisions (low 25-bit) - Expected 155.1, actual 182 (1.173x) (^ 5) +Testing all collisions (high 13..28 bits) - Worst is 27 bits: 51/39 (1.314x) (^ 1) +Testing all collisions (low 13..28 bits) - Worst is 20 bits: 4973/4812 (1.033x) (^ 2) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 1.2, actual 1 (1.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 1.2, actual 3 (2.473x) (^ 2) +Testing all collisions (high 25-bit) - Expected 155.1, actual 145 (0.935x) (^ 0) +Testing all collisions (low 25-bit) - Expected 155.1, actual 147 (0.947x) (^ 0) +Testing all collisions (high 13..28 bits) - Worst is 28 bits: 22/19 (1.133x) (^ 0) +Testing all collisions (low 13..28 bits) - Worst is 20 bits: 4881/4812 (1.014x) (^ 0) + +Keyset 'Sparse' - 6-byte keys with up to 3 bits set - 18473 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 20-bit) - Expected 161.8, actual 153 (0.946x) (^ 0) +Testing all collisions (low 20-bit) - Expected 161.8, actual 173 (1.069x) (^ 2) +Testing all collisions (high 11..24 bits) - Worst is 19 bits: 335/322 (1.042x) (^ 0) +Testing all collisions (low 11..24 bits) - Worst is 20 bits: 173/162 (1.069x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 0.0, actual 1 (25.17x) (^ 3) +Testing all collisions (high 20-bit) - Expected 161.8, actual 185 (1.144x) (^ 4) +Testing all collisions (low 20-bit) - Expected 161.8, actual 141 (0.872x) (^ 0) +Testing all collisions (high 11..24 bits) - Worst is 20 bits: 185/162 (1.144x) (^ 1) +Testing all collisions (low 11..24 bits) - Worst is 15 bits: 4394/4352 (1.010x) (^ 0) + +Keyset 'Sparse' - 7-byte keys with up to 3 bits set - 29317 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 0.1, actual 0 (0.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 0.1, actual 0 (0.000x) (^ 0) +Testing all collisions (high 22-bit) - Expected 102.2, actual 88 (0.861x) (^ 0) +Testing all collisions (low 22-bit) - Expected 102.2, actual 105 (1.027x) (^ 1) +Testing all collisions (high 11..25 bits) - Worst is 11 bits: 27269/27269 (1.000x) (^ 0) +Testing all collisions (low 11..25 bits) - Worst is 18 bits: 1694/1580 (1.072x) (^ 4) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 0.1, actual 0 (0.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 0.1, actual 0 (0.000x) (^ 0) +Testing all collisions (high 22-bit) - Expected 102.2, actual 107 (1.047x) (^ 1) +Testing all collisions (low 22-bit) - Expected 102.2, actual 104 (1.017x) (^ 1) +Testing all collisions (high 11..25 bits) - Worst is 20 bits: 422/406 (1.039x) (^ 0) +Testing all collisions (low 11..25 bits) - Worst is 25 bits: 19/13 (1.484x) (^ 0) + +Keyset 'Sparse' - 8-byte keys with up to 3 bits set - 43745 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 0.2, actual 1 (1.000x) (^ 1) +Testing all collisions (low 32-bit) - Expected 0.2, actual 1 (1.000x) (^ 1) +Testing all collisions (high 23-bit) - Expected 113.9, actual 101 (0.887x) (^ 0) +Testing all collisions (low 23-bit) - Expected 113.9, actual 102 (0.896x) (^ 0) +Testing all collisions (high 12..26 bits) - Worst is 16 bits: 11927/11828 (1.008x) (^ 0) +Testing all collisions (low 12..26 bits) - Worst is 15 bits: 19612/19600 (1.001x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 0.2, actual 1 (1.000x) (^ 1) +Testing all collisions (low 32-bit) - Expected 0.2, actual 0 (0.000x) (^ 0) +Testing all collisions (high 23-bit) - Expected 113.9, actual 112 (0.984x) (^ 0) +Testing all collisions (low 23-bit) - Expected 113.9, actual 129 (1.133x) (^ 3) +Testing all collisions (high 12..26 bits) - Worst is 26 bits: 18/14 (1.263x) (^ 0) +Testing all collisions (low 12..26 bits) - Worst is 26 bits: 27/14 (1.894x) (^ 5) + +Keyset 'Sparse' - 9-byte keys with up to 3 bits set - 62269 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 0.5, actual 0 (0.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 0.5, actual 1 (1.000x) (^ 1) +Testing all collisions (high 24-bit) - Expected 115.4, actual 113 (0.979x) (^ 0) +Testing all collisions (low 24-bit) - Expected 115.4, actual 122 (1.057x) (^ 1) +Testing all collisions (high 12..27 bits) - Worst is 23 bits: 256/231 (1.110x) (^ 0) +Testing all collisions (low 12..27 bits) - Worst is 23 bits: 243/231 (1.054x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 0.5, actual 0 (0.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 0.5, actual 0 (0.000x) (^ 0) +Testing all collisions (high 24-bit) - Expected 115.4, actual 131 (1.135x) (^ 3) +Testing all collisions (low 24-bit) - Expected 115.4, actual 91 (0.788x) (^ 0) +Testing all collisions (high 12..27 bits) - Worst is 23 bits: 258/231 (1.119x) (^ 1) +Testing all collisions (low 12..27 bits) - Worst is 12 bits: 58173/58173 (1.000x) (^ 0) + +Keyset 'Sparse' - 10-byte keys with up to 3 bits set - 85401 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 0.8, actual 1 (1.000x) (^ 1) +Testing all collisions (low 32-bit) - Expected 0.8, actual 4 (4.711x) (^ 5) +Testing all collisions (high 25-bit) - Expected 108.6, actual 126 (1.160x) (^ 4) +Testing all collisions (low 25-bit) - Expected 108.6, actual 94 (0.866x) (^ 0) +Testing all collisions (high 13..28 bits) - Worst is 25 bits: 126/109 (1.160x) (^ 0) +Testing all collisions (low 13..28 bits) - Worst is 22 bits: 903/864 (1.046x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 0.8, actual 0 (0.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 0.8, actual 0 (0.000x) (^ 0) +Testing all collisions (high 25-bit) - Expected 108.6, actual 109 (1.000x) (^ 1) +Testing all collisions (low 25-bit) - Expected 108.6, actual 101 (0.930x) (^ 0) +Testing all collisions (high 13..28 bits) - Worst is 22 bits: 890/864 (1.031x) (^ 0) +Testing all collisions (low 13..28 bits) - Worst is 22 bits: 907/864 (1.050x) (^ 0) + +Keyset 'Sparse' - 11-byte keys with up to 3 bits set - 113653 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 1.5, actual 2 (1.000x) (^ 1) +Testing all collisions (low 32-bit) - Expected 1.5, actual 2 (1.000x) (^ 1) +Testing all collisions (high 25-bit) - Expected 192.3, actual 195 (1.014x) (^ 1) +Testing all collisions (low 25-bit) - Expected 192.3, actual 176 (0.915x) (^ 0) +Testing all collisions (high 13..29 bits) - Worst is 26 bits: 115/96 (1.196x) (^ 1) +Testing all collisions (low 13..29 bits) - Worst is 13 bits: 105461/105461 (1.000x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 1.5, actual 2 (1.000x) (^ 1) +Testing all collisions (low 32-bit) - Expected 1.5, actual 2 (1.000x) (^ 1) +Testing all collisions (high 25-bit) - Expected 192.3, actual 190 (0.988x) (^ 0) +Testing all collisions (low 25-bit) - Expected 192.3, actual 184 (0.957x) (^ 0) +Testing all collisions (high 13..29 bits) - Worst is 28 bits: 34/24 (1.413x) (^ 1) +Testing all collisions (low 13..29 bits) - Worst is 21 bits: 3049/3025 (1.008x) (^ 0) + +Keyset 'Sparse' - 12-byte keys with up to 3 bits set - 147537 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2.5, actual 7 (2.762x) (^ 5) +Testing all collisions (low 32-bit) - Expected 2.5, actual 3 (1.000x) (^ 1) +Testing all collisions (high 26-bit) - Expected 162.1, actual 166 (1.024x) (^ 1) +Testing all collisions (low 26-bit) - Expected 162.1, actual 162 (1.000x) (^ 0) +Testing all collisions (high 13..30 bits) - Worst is 30 bits: 17/10 (1.677x) (^ 1) +Testing all collisions (low 13..30 bits) - Worst is 29 bits: 25/20 (1.233x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2.5, actual 4 (1.579x) (^ 1) +Testing all collisions (low 32-bit) - Expected 2.5, actual 3 (1.000x) (^ 1) +Testing all collisions (high 26-bit) - Expected 162.1, actual 165 (1.018x) (^ 1) +Testing all collisions (low 26-bit) - Expected 162.1, actual 148 (0.913x) (^ 0) +Testing all collisions (high 13..30 bits) - Worst is 20 bits: 10033/9909 (1.012x) (^ 0) +Testing all collisions (low 13..30 bits) - Worst is 17 bits: 59007/58991 (1.000x) (^ 0) + +Keyset 'Sparse' - 13-byte keys with up to 3 bits set - 187565 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 4.1, actual 3 (0.733x) (^ 0) +Testing all collisions (low 32-bit) - Expected 4.1, actual 5 (1.221x) (^ 1) +Testing all collisions (high 27-bit) - Expected 131.0, actual 132 (1.008x) (^ 1) +Testing all collisions (low 27-bit) - Expected 131.0, actual 124 (0.947x) (^ 0) +Testing all collisions (high 14..30 bits) - Worst is 23 bits: 2091/2081 (1.005x) (^ 0) +Testing all collisions (low 14..30 bits) - Worst is 30 bits: 28/16 (1.709x) (^ 3) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 4.1, actual 2 (0.488x) (^ 0) +Testing all collisions (low 32-bit) - Expected 4.1, actual 2 (0.488x) (^ 0) +Testing all collisions (high 27-bit) - Expected 131.0, actual 144 (1.099x) (^ 2) +Testing all collisions (low 27-bit) - Expected 131.0, actual 117 (0.893x) (^ 0) +Testing all collisions (high 14..30 bits) - Worst is 19 bits: 30109/29883 (1.008x) (^ 0) +Testing all collisions (low 14..30 bits) - Worst is 21 bits: 8388/8143 (1.030x) (^ 4) + +Keyset 'Sparse' - 14-byte keys with up to 3 bits set - 234249 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 6.4, actual 7 (1.000x) (^ 1) +Testing all collisions (low 32-bit) - Expected 6.4, actual 11 (1.722x) (^ 3) +Testing all collisions (high 28-bit) - Expected 102.2, actual 94 (0.920x) (^ 0) +Testing all collisions (low 28-bit) - Expected 102.2, actual 113 (1.106x) (^ 2) +Testing all collisions (high 14..31 bits) - Worst is 19 bits: 45451/45335 (1.003x) (^ 0) +Testing all collisions (low 14..31 bits) - Worst is 29 bits: 63/51 (1.233x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 6.4, actual 5 (0.783x) (^ 0) +Testing all collisions (low 32-bit) - Expected 6.4, actual 4 (0.626x) (^ 0) +Testing all collisions (high 28-bit) - Expected 102.2, actual 95 (0.930x) (^ 0) +Testing all collisions (low 28-bit) - Expected 102.2, actual 94 (0.920x) (^ 0) +Testing all collisions (high 14..31 bits) - Worst is 22 bits: 6512/6421 (1.014x) (^ 0) +Testing all collisions (low 14..31 bits) - Worst is 27 bits: 228/204 (1.116x) (^ 0) + +Keyset 'Sparse' - 2-byte keys with up to 10 bits set - 58651 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 0.4, actual 0 (0.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 0.4, actual 0 (0.000x) (^ 0) +Testing all collisions (high 24-bit) - Expected 102.4, actual 97 (0.947x) (^ 0) +Testing all collisions (low 24-bit) - Expected 102.4, actual 102 (1.000x) (^ 0) +Testing all collisions (high 12..27 bits) - Worst is 12 bits: 54555/54555 (1.000x) (^ 0) +Testing all collisions (low 12..27 bits) - Worst is 22 bits: 437/408 (1.071x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 0.4, actual 0 (0.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 0.4, actual 0 (0.000x) (^ 0) +Testing all collisions (high 24-bit) - Expected 102.4, actual 85 (0.830x) (^ 0) +Testing all collisions (low 24-bit) - Expected 102.4, actual 88 (0.859x) (^ 0) +Testing all collisions (high 12..27 bits) - Worst is 21 bits: 849/813 (1.045x) (^ 0) +Testing all collisions (low 12..27 bits) - Worst is 14 bits: 42747/42724 (1.001x) (^ 0) + +Keyset 'Sparse' - 3-byte keys with up to 20 bits set - 16774891 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 146 (1.141x) (^ 3) +Testing all collisions (low 40-bit) - Expected 128.0, actual 125 (0.977x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32716.3, actual 32698 (0.999x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32716.3, actual 32671 (0.999x) (^ 0) +Testing all collisions (high 20..43 bits) - Worst is 41 bits: 77/64 (1.203x) (^ 0) +Testing all collisions (low 20..43 bits) - Worst is 42 bits: 36/32 (1.125x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 131 (1.024x) (^ 1) +Testing all collisions (low 40-bit) - Expected 128.0, actual 143 (1.118x) (^ 3) +Testing all collisions (high 32-bit) - Expected 32716.3, actual 32410 (0.991x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32716.3, actual 32613 (0.997x) (^ 0) +Testing all collisions (high 20..43 bits) - Worst is 24 bits: 6172107/6170523 (1.000x) (^ 0) +Testing all collisions (low 20..43 bits) - Worst is 39 bits: 281/256 (1.098x) (^ 0) + +Keyset 'Sparse' - 4-byte keys with up to 9 bits set - 43081973 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 43-bit) - Expected 105.5, actual 110 (1.043x) (^ 1) +Testing all collisions (low 43-bit) - Expected 105.5, actual 90 (0.853x) (^ 0) +Testing all collisions (high 32-bit) - Expected 215352.7, actual 215250 (1.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 215352.7, actual 214306 (0.995x) (^ 0) +Testing all collisions (high 21..46 bits) - Worst is 41 bits: 451/422 (1.069x) (^ 0) +Testing all collisions (low 21..46 bits) - Worst is 26 bits: 11291016/11289412 (1.000x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 43-bit) - Expected 105.5, actual 100 (0.948x) (^ 0) +Testing all collisions (low 43-bit) - Expected 105.5, actual 106 (1.000x) (^ 1) +Testing all collisions (high 32-bit) - Expected 215352.7, actual 215123 (0.999x) (^ 0) +Testing all collisions (low 32-bit) - Expected 215352.7, actual 215965 (1.003x) (^ 3) +Testing all collisions (high 21..46 bits) - Worst is 34 bits: 54094/53973 (1.002x) (^ 0) +Testing all collisions (low 21..46 bits) - Worst is 39 bits: 1771/1688 (1.049x) (^ 1) + +Keyset 'Sparse' - 5-byte keys with up to 7 bits set - 23242039 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 41-bit) - Expected 122.8, actual 93 (0.757x) (^ 0) +Testing all collisions (low 41-bit) - Expected 122.8, actual 122 (0.993x) (^ 0) +Testing all collisions (high 32-bit) - Expected 62773.4, actual 63018 (1.004x) (^ 2) +Testing all collisions (low 32-bit) - Expected 62773.4, actual 62609 (0.997x) (^ 0) +Testing all collisions (high 20..44 bits) - Worst is 27 bits: 1902901/1901074 (1.001x) (^ 0) +Testing all collisions (low 20..44 bits) - Worst is 33 bits: 31532/31415 (1.004x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 41-bit) - Expected 122.8, actual 121 (0.985x) (^ 0) +Testing all collisions (low 41-bit) - Expected 122.8, actual 130 (1.058x) (^ 1) +Testing all collisions (high 32-bit) - Expected 62773.4, actual 62871 (1.002x) (^ 1) +Testing all collisions (low 32-bit) - Expected 62773.4, actual 62724 (0.999x) (^ 0) +Testing all collisions (high 20..44 bits) - Worst is 28 bits: 979842/977765 (1.002x) (^ 1) +Testing all collisions (low 20..44 bits) - Worst is 37 bits: 2058/1965 (1.047x) (^ 1) + +Keyset 'Sparse' - 6-byte keys with up to 7 bits set - 87825941 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 45-bit) - Expected 109.6, actual 107 (0.976x) (^ 0) +Testing all collisions (low 45-bit) - Expected 109.6, actual 95 (0.867x) (^ 0) +Testing all collisions (high 32-bit) - Expected 891868.0, actual 891136 (0.999x) (^ 0) +Testing all collisions (low 32-bit) - Expected 891868.0, actual 892255 (1.000x) (^ 1) +Testing all collisions (high 22..48 bits) - Worst is 28 bits: 12923561/12920646 (1.000x) (^ 0) +Testing all collisions (low 22..48 bits) - Worst is 29 bits: 6813311/6807448 (1.001x) (^ 1) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 45-bit) - Expected 109.6, actual 116 (1.058x) (^ 1) +Testing all collisions (low 45-bit) - Expected 109.6, actual 108 (0.985x) (^ 0) +Testing all collisions (high 32-bit) - Expected 891868.0, actual 890720 (0.999x) (^ 0) +Testing all collisions (low 32-bit) - Expected 891868.0, actual 893326 (1.002x) (^ 4) +Testing all collisions (high 22..48 bits) - Worst is 45 bits: 116/110 (1.058x) (^ 0) +Testing all collisions (low 22..48 bits) - Worst is 33 bits: 449070/447452 (1.004x) (^ 2) + +Keyset 'Sparse' - 7-byte keys with up to 6 bits set - 36684859 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 42-bit) - Expected 153.0, actual 146 (0.954x) (^ 0) +Testing all collisions (low 42-bit) - Expected 153.0, actual 163 (1.065x) (^ 2) +Testing all collisions (high 32-bit) - Expected 156224.2, actual 156554 (1.002x) (^ 2) +Testing all collisions (low 32-bit) - Expected 156224.2, actual 155492 (0.995x) (^ 0) +Testing all collisions (high 21..45 bits) - Worst is 39 bits: 1293/1224 (1.056x) (^ 1) +Testing all collisions (low 21..45 bits) - Worst is 43 bits: 86/76 (1.124x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 42-bit) - Expected 153.0, actual 147 (0.961x) (^ 0) +Testing all collisions (low 42-bit) - Expected 153.0, actual 168 (1.098x) (^ 3) +Testing all collisions (high 32-bit) - Expected 156224.2, actual 156229 (1.000x) (^ 1) +Testing all collisions (low 32-bit) - Expected 156224.2, actual 156446 (1.001x) (^ 1) +Testing all collisions (high 21..45 bits) - Worst is 36 bits: 9851/9790 (1.006x) (^ 0) +Testing all collisions (low 21..45 bits) - Worst is 39 bits: 1287/1224 (1.052x) (^ 0) + +Keyset 'Sparse' - 8-byte keys with up to 6 bits set - 83278001 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 44-bit) - Expected 197.1, actual 192 (0.974x) (^ 0) +Testing all collisions (low 44-bit) - Expected 197.1, actual 218 (1.106x) (^ 3) +Testing all collisions (high 32-bit) - Expected 802173.5, actual 802646 (1.001x) (^ 1) +Testing all collisions (low 32-bit) - Expected 802173.5, actual 803697 (1.002x) (^ 4) +Testing all collisions (high 22..48 bits) - Worst is 31 bits: 1594812/1594061 (1.000x) (^ 0) +Testing all collisions (low 22..48 bits) - Worst is 32 bits: 803697/802174 (1.002x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 44-bit) - Expected 197.1, actual 218 (1.106x) (^ 3) +Testing all collisions (low 44-bit) - Expected 197.1, actual 198 (1.005x) (^ 1) +Testing all collisions (high 32-bit) - Expected 802173.5, actual 803053 (1.001x) (^ 2) +Testing all collisions (low 32-bit) - Expected 802173.5, actual 803755 (1.002x) (^ 4) +Testing all collisions (high 22..48 bits) - Worst is 45 bits: 123/99 (1.248x) (^ 2) +Testing all collisions (low 22..48 bits) - Worst is 31 bits: 1596622/1594061 (1.002x) (^ 1) + +Keyset 'Sparse' - 9-byte keys with up to 5 bits set - 15082603 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 103.4, actual 110 (1.063x) (^ 1) +Testing all collisions (low 40-bit) - Expected 103.4, actual 104 (1.005x) (^ 1) +Testing all collisions (high 32-bit) - Expected 26451.8, actual 26461 (1.000x) (^ 1) +Testing all collisions (low 32-bit) - Expected 26451.8, actual 26438 (0.999x) (^ 0) +Testing all collisions (high 20..43 bits) - Worst is 36 bits: 1758/1655 (1.062x) (^ 2) +Testing all collisions (low 20..43 bits) - Worst is 34 bits: 6771/6619 (1.023x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 103.4, actual 97 (0.938x) (^ 0) +Testing all collisions (low 40-bit) - Expected 103.4, actual 98 (0.947x) (^ 0) +Testing all collisions (high 32-bit) - Expected 26451.8, actual 26448 (1.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 26451.8, actual 26894 (1.017x) (^ 8) +Testing all collisions (high 20..43 bits) - Worst is 26 bits: 1575770/1574745 (1.001x) (^ 0) +Testing all collisions (low 20..43 bits) - Worst is 32 bits: 26894/26452 (1.017x) (^ 3) + +Keyset 'Sparse' - 12-byte keys with up to 5 bits set - 64593561 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 44-bit) - Expected 118.6, actual 125 (1.054x) (^ 1) +Testing all collisions (low 44-bit) - Expected 118.6, actual 106 (0.894x) (^ 0) +Testing all collisions (high 32-bit) - Expected 483297.1, actual 484959 (1.003x) (^ 6) +Testing all collisions (low 32-bit) - Expected 483297.1, actual 481904 (0.997x) (^ 0) +Testing all collisions (high 22..47 bits) - Worst is 30 bits: 1908802/1904511 (1.002x) (^ 5) +Testing all collisions (low 22..47 bits) - Worst is 41 bits: 975/949 (1.028x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 44-bit) - Expected 118.6, actual 94 (0.793x) (^ 0) +Testing all collisions (low 44-bit) - Expected 118.6, actual 114 (0.961x) (^ 0) +Testing all collisions (high 32-bit) - Expected 483297.1, actual 482864 (0.999x) (^ 0) +Testing all collisions (low 32-bit) - Expected 483297.1, actual 482501 (0.998x) (^ 0) +Testing all collisions (high 22..47 bits) - Worst is 39 bits: 3809/3795 (1.004x) (^ 0) +Testing all collisions (low 22..47 bits) - Worst is 26 bits: 23119772/23115556 (1.000x) (^ 0) + +Keyset 'Sparse' - 14-byte keys with up to 4 bits set - 6445069 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 37-bit) - Expected 151.1, actual 156 (1.032x) (^ 1) +Testing all collisions (low 37-bit) - Expected 151.1, actual 139 (0.920x) (^ 0) +Testing all collisions (high 32-bit) - Expected 4833.3, actual 4782 (0.989x) (^ 0) +Testing all collisions (low 32-bit) - Expected 4833.3, actual 4827 (0.999x) (^ 0) +Testing all collisions (high 18..40 bits) - Worst is 27 bits: 152627/152297 (1.002x) (^ 0) +Testing all collisions (low 18..40 bits) - Worst is 27 bits: 153219/152297 (1.006x) (^ 2) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 37-bit) - Expected 151.1, actual 153 (1.012x) (^ 1) +Testing all collisions (low 37-bit) - Expected 151.1, actual 160 (1.059x) (^ 2) +Testing all collisions (high 32-bit) - Expected 4833.3, actual 4968 (1.028x) (^ 5) +Testing all collisions (low 32-bit) - Expected 4833.3, actual 4853 (1.004x) (^ 1) +Testing all collisions (high 18..40 bits) - Worst is 35 bits: 679/604 (1.123x) (^ 4) +Testing all collisions (low 18..40 bits) - Worst is 38 bits: 85/76 (1.125x) (^ 0) + +Keyset 'Sparse' - 16-byte keys with up to 4 bits set - 11017633 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 39-bit) - Expected 110.4, actual 127 (1.150x) (^ 3) +Testing all collisions (low 39-bit) - Expected 110.4, actual 100 (0.906x) (^ 0) +Testing all collisions (high 32-bit) - Expected 14119.4, actual 14052 (0.995x) (^ 0) +Testing all collisions (low 32-bit) - Expected 14119.4, actual 14260 (1.010x) (^ 3) +Testing all collisions (high 19..42 bits) - Worst is 42 bits: 23/14 (1.667x) (^ 1) +Testing all collisions (low 19..42 bits) - Worst is 31 bits: 28455/28215 (1.009x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 39-bit) - Expected 110.4, actual 108 (0.978x) (^ 0) +Testing all collisions (low 39-bit) - Expected 110.4, actual 128 (1.159x) (^ 4) +Testing all collisions (high 32-bit) - Expected 14119.4, actual 13966 (0.989x) (^ 0) +Testing all collisions (low 32-bit) - Expected 14119.4, actual 14055 (0.995x) (^ 0) +Testing all collisions (high 19..42 bits) - Worst is 40 bits: 63/55 (1.141x) (^ 0) +Testing all collisions (low 19..42 bits) - Worst is 39 bits: 128/110 (1.159x) (^ 0) + +Keyset 'Sparse' - 18-byte keys with up to 4 bits set - 17676661 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 142.1, actual 145 (1.020x) (^ 1) +Testing all collisions (low 40-bit) - Expected 142.1, actual 132 (0.929x) (^ 0) +Testing all collisions (high 32-bit) - Expected 36325.8, actual 36187 (0.996x) (^ 0) +Testing all collisions (low 32-bit) - Expected 36325.8, actual 36305 (0.999x) (^ 0) +Testing all collisions (high 20..43 bits) - Worst is 36 bits: 2318/2273 (1.020x) (^ 0) +Testing all collisions (low 20..43 bits) - Worst is 29 bits: 288528/287837 (1.002x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 142.1, actual 124 (0.873x) (^ 0) +Testing all collisions (low 40-bit) - Expected 142.1, actual 133 (0.936x) (^ 0) +Testing all collisions (high 32-bit) - Expected 36325.8, actual 36401 (1.002x) (^ 1) +Testing all collisions (low 32-bit) - Expected 36325.8, actual 36006 (0.991x) (^ 0) +Testing all collisions (high 20..43 bits) - Worst is 25 bits: 3936992/3935727 (1.000x) (^ 0) +Testing all collisions (low 20..43 bits) - Worst is 41 bits: 77/71 (1.084x) (^ 0) + +Keyset 'Sparse' - 24-byte keys with up to 4 bits set - 56050289 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 43-bit) - Expected 178.6, actual 173 (0.969x) (^ 0) +Testing all collisions (low 43-bit) - Expected 178.6, actual 195 (1.092x) (^ 3) +Testing all collisions (high 32-bit) - Expected 364148.6, actual 363857 (0.999x) (^ 0) +Testing all collisions (low 32-bit) - Expected 364148.6, actual 362986 (0.997x) (^ 0) +Testing all collisions (high 21..47 bits) - Worst is 45 bits: 57/45 (1.277x) (^ 0) +Testing all collisions (low 21..47 bits) - Worst is 43 bits: 195/179 (1.092x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 43-bit) - Expected 178.6, actual 201 (1.126x) (^ 4) +Testing all collisions (low 43-bit) - Expected 178.6, actual 207 (1.159x) (^ 5) +Testing all collisions (high 32-bit) - Expected 364148.6, actual 363435 (0.998x) (^ 0) +Testing all collisions (low 32-bit) - Expected 364148.6, actual 364379 (1.001x) (^ 1) +Testing all collisions (high 21..47 bits) - Worst is 39 bits: 2980/2857 (1.043x) (^ 1) +Testing all collisions (low 21..47 bits) - Worst is 43 bits: 207/179 (1.159x) (^ 1) + +Keyset 'Sparse' - 26-byte keys with up to 4 bits set - 77260613 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 44-bit) - Expected 169.7, actual 164 (0.967x) (^ 0) +Testing all collisions (low 44-bit) - Expected 169.7, actual 160 (0.943x) (^ 0) +Testing all collisions (high 32-bit) - Expected 690758.5, actual 691687 (1.001x) (^ 2) +Testing all collisions (low 32-bit) - Expected 690758.5, actual 690577 (1.000x) (^ 0) +Testing all collisions (high 22..48 bits) - Worst is 31 bits: 1375006/1373295 (1.001x) (^ 0) +Testing all collisions (low 22..48 bits) - Worst is 29 bits: 5302962/5301902 (1.000x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 44-bit) - Expected 169.7, actual 188 (1.108x) (^ 3) +Testing all collisions (low 44-bit) - Expected 169.7, actual 173 (1.020x) (^ 1) +Testing all collisions (high 32-bit) - Expected 690758.5, actual 690738 (1.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 690758.5, actual 690402 (0.999x) (^ 0) +Testing all collisions (high 22..48 bits) - Worst is 44 bits: 188/170 (1.108x) (^ 0) +Testing all collisions (low 22..48 bits) - Worst is 33 bits: 346983/346414 (1.002x) (^ 0) + +Keyset 'Sparse' - 32-byte keys with up to 3 bits set - 2796417 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 35-bit) - Expected 113.8, actual 114 (1.000x) (^ 1) +Testing all collisions (low 35-bit) - Expected 113.8, actual 119 (1.046x) (^ 1) +Testing all collisions (high 32-bit) - Expected 910.2, actual 882 (0.969x) (^ 0) +Testing all collisions (low 32-bit) - Expected 910.2, actual 909 (0.999x) (^ 0) +Testing all collisions (high 17..38 bits) - Worst is 29 bits: 7355/7270 (1.012x) (^ 0) +Testing all collisions (low 17..38 bits) - Worst is 31 bits: 1872/1820 (1.029x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 35-bit) - Expected 113.8, actual 119 (1.046x) (^ 1) +Testing all collisions (low 35-bit) - Expected 113.8, actual 113 (0.993x) (^ 0) +Testing all collisions (high 32-bit) - Expected 910.2, actual 893 (0.981x) (^ 0) +Testing all collisions (low 32-bit) - Expected 910.2, actual 900 (0.989x) (^ 0) +Testing all collisions (high 17..38 bits) - Worst is 23 bits: 419634/418356 (1.003x) (^ 1) +Testing all collisions (low 17..38 bits) - Worst is 25 bits: 114003/113356 (1.006x) (^ 1) + +Keyset 'Sparse' - 48-byte keys with up to 3 bits set - 9437505 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 162.0, actual 154 (0.951x) (^ 0) +Testing all collisions (low 38-bit) - Expected 162.0, actual 139 (0.858x) (^ 0) +Testing all collisions (high 32-bit) - Expected 10361.1, actual 10424 (1.006x) (^ 1) +Testing all collisions (low 32-bit) - Expected 10361.1, actual 10263 (0.991x) (^ 0) +Testing all collisions (high 19..42 bits) - Worst is 28 bits: 164235/163972 (1.002x) (^ 0) +Testing all collisions (low 19..42 bits) - Worst is 25 bits: 1212474/1211045 (1.001x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 162.0, actual 152 (0.938x) (^ 0) +Testing all collisions (low 38-bit) - Expected 162.0, actual 184 (1.136x) (^ 4) +Testing all collisions (high 32-bit) - Expected 10361.1, actual 10407 (1.004x) (^ 1) +Testing all collisions (low 32-bit) - Expected 10361.1, actual 10372 (1.001x) (^ 1) +Testing all collisions (high 19..42 bits) - Worst is 31 bits: 20916/20707 (1.010x) (^ 0) +Testing all collisions (low 19..42 bits) - Worst is 30 bits: 41860/41354 (1.012x) (^ 2) + +Keyset 'Sparse' - 64-byte keys with up to 3 bits set - 22370049 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 41-bit) - Expected 113.8, actual 123 (1.081x) (^ 2) +Testing all collisions (low 41-bit) - Expected 113.8, actual 106 (0.932x) (^ 0) +Testing all collisions (high 32-bit) - Expected 58155.4, actual 58561 (1.007x) (^ 4) +Testing all collisions (low 32-bit) - Expected 58155.4, actual 57930 (0.996x) (^ 0) +Testing all collisions (high 20..44 bits) - Worst is 32 bits: 58561/58155 (1.007x) (^ 0) +Testing all collisions (low 20..44 bits) - Worst is 35 bits: 7355/7280 (1.010x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 41-bit) - Expected 113.8, actual 93 (0.817x) (^ 0) +Testing all collisions (low 41-bit) - Expected 113.8, actual 106 (0.932x) (^ 0) +Testing all collisions (high 32-bit) - Expected 58155.4, actual 58695 (1.009x) (^ 6) +Testing all collisions (low 32-bit) - Expected 58155.4, actual 58213 (1.001x) (^ 1) +Testing all collisions (high 20..44 bits) - Worst is 31 bits: 116985/116109 (1.008x) (^ 3) +Testing all collisions (low 20..44 bits) - Worst is 37 bits: 1886/1820 (1.036x) (^ 0) + +Keyset 'Sparse' - 96-byte keys with up to 3 bits set - 75498113 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 44-bit) - Expected 162.0, actual 153 (0.944x) (^ 0) +Testing all collisions (low 44-bit) - Expected 162.0, actual 143 (0.883x) (^ 0) +Testing all collisions (high 32-bit) - Expected 659692.2, actual 658766 (0.999x) (^ 0) +Testing all collisions (low 32-bit) - Expected 659692.2, actual 658998 (0.999x) (^ 0) +Testing all collisions (high 22..48 bits) - Worst is 38 bits: 10444/10367 (1.007x) (^ 0) +Testing all collisions (low 22..48 bits) - Worst is 26 bits: 30177566/30176099 (1.000x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 44-bit) - Expected 162.0, actual 162 (1.000x) (^ 0) +Testing all collisions (low 44-bit) - Expected 162.0, actual 174 (1.074x) (^ 2) +Testing all collisions (high 32-bit) - Expected 659692.2, actual 658919 (0.999x) (^ 0) +Testing all collisions (low 32-bit) - Expected 659692.2, actual 658602 (0.998x) (^ 0) +Testing all collisions (high 22..48 bits) - Worst is 47 bits: 33/20 (1.630x) (^ 2) +Testing all collisions (low 22..48 bits) - Worst is 43 bits: 341/324 (1.052x) (^ 0) + +Keyset 'Sparse' - 128-byte keys with up to 2 bits set - 524801 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32.1, actual 29 (0.905x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32.1, actual 23 (0.717x) (^ 0) +Testing all collisions (high 30-bit) - Expected 128.2, actual 141 (1.100x) (^ 2) +Testing all collisions (low 30-bit) - Expected 128.2, actual 132 (1.029x) (^ 1) +Testing all collisions (high 15..33 bits) - Worst is 29 bits: 289/256 (1.127x) (^ 1) +Testing all collisions (low 15..33 bits) - Worst is 23 bits: 16219/16079 (1.009x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32.1, actual 33 (1.029x) (^ 1) +Testing all collisions (low 32-bit) - Expected 32.1, actual 32 (1.000x) (^ 0) +Testing all collisions (high 30-bit) - Expected 128.2, actual 131 (1.022x) (^ 1) +Testing all collisions (low 30-bit) - Expected 128.2, actual 122 (0.951x) (^ 0) +Testing all collisions (high 15..33 bits) - Worst is 22 bits: 31751/31505 (1.008x) (^ 0) +Testing all collisions (low 15..33 bits) - Worst is 26 bits: 2125/2047 (1.038x) (^ 0) + +Keyset 'Sparse' - 256-byte keys with up to 2 bits set - 2098177 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 34-bit) - Expected 128.1, actual 134 (1.046x) (^ 1) +Testing all collisions (low 34-bit) - Expected 128.1, actual 121 (0.944x) (^ 0) +Testing all collisions (high 32-bit) - Expected 512.4, actual 472 (0.921x) (^ 0) +Testing all collisions (low 32-bit) - Expected 512.4, actual 502 (0.980x) (^ 0) +Testing all collisions (high 17..37 bits) - Worst is 37 bits: 22/16 (1.374x) (^ 0) +Testing all collisions (low 17..37 bits) - Worst is 25 bits: 64681/64254 (1.007x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 34-bit) - Expected 128.1, actual 113 (0.882x) (^ 0) +Testing all collisions (low 34-bit) - Expected 128.1, actual 145 (1.132x) (^ 3) +Testing all collisions (high 32-bit) - Expected 512.4, actual 510 (0.995x) (^ 0) +Testing all collisions (low 32-bit) - Expected 512.4, actual 525 (1.025x) (^ 1) +Testing all collisions (high 17..37 bits) - Worst is 17 bits: 1967105/1967105 (1.000x) (^ 0) +Testing all collisions (low 17..37 bits) - Worst is 27 bits: 16516/16315 (1.012x) (^ 0) + +Keyset 'Sparse' - 512-byte keys with up to 2 bits set - 8390657 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 128.1, actual 138 (1.078x) (^ 2) +Testing all collisions (low 38-bit) - Expected 128.1, actual 129 (1.007x) (^ 1) +Testing all collisions (high 32-bit) - Expected 8190.7, actual 8182 (0.999x) (^ 0) +Testing all collisions (low 32-bit) - Expected 8190.7, actual 8189 (1.000x) (^ 0) +Testing all collisions (high 19..41 bits) - Worst is 30 bits: 33004/32699 (1.009x) (^ 0) +Testing all collisions (low 19..41 bits) - Worst is 34 bits: 2078/2049 (1.014x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 128.1, actual 125 (0.976x) (^ 0) +Testing all collisions (low 38-bit) - Expected 128.1, actual 135 (1.054x) (^ 1) +Testing all collisions (high 32-bit) - Expected 8190.7, actual 8223 (1.004x) (^ 1) +Testing all collisions (low 32-bit) - Expected 8190.7, actual 8229 (1.005x) (^ 1) +Testing all collisions (high 19..41 bits) - Worst is 26 bits: 503618/503349 (1.001x) (^ 0) +Testing all collisions (low 19..41 bits) - Worst is 39 bits: 73/64 (1.140x) (^ 0) + +Keyset 'Sparse' - 1024-byte keys with up to 2 bits set - 33558529 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 42-bit) - Expected 128.0, actual 148 (1.156x) (^ 4) +Testing all collisions (low 42-bit) - Expected 128.0, actual 144 (1.125x) (^ 3) +Testing all collisions (high 32-bit) - Expected 130763.2, actual 131056 (1.002x) (^ 2) +Testing all collisions (low 32-bit) - Expected 130763.2, actual 130822 (1.000x) (^ 1) +Testing all collisions (high 21..45 bits) - Worst is 40 bits: 580/512 (1.133x) (^ 4) +Testing all collisions (low 21..45 bits) - Worst is 43 bits: 81/64 (1.265x) (^ 1) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 42-bit) - Expected 128.0, actual 129 (1.008x) (^ 1) +Testing all collisions (low 42-bit) - Expected 128.0, actual 123 (0.961x) (^ 0) +Testing all collisions (high 32-bit) - Expected 130763.2, actual 131188 (1.003x) (^ 3) +Testing all collisions (low 32-bit) - Expected 130763.2, actual 130334 (0.997x) (^ 0) +Testing all collisions (high 21..45 bits) - Worst is 37 bits: 4233/4097 (1.033x) (^ 1) +Testing all collisions (low 21..45 bits) - Worst is 38 bits: 2106/2048 (1.028x) (^ 0) + +Keyset 'Sparse' - 1280-byte keys with up to 2 bits set - 52433921 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 43-bit) - Expected 156.3, actual 136 (0.870x) (^ 0) +Testing all collisions (low 43-bit) - Expected 156.3, actual 166 (1.062x) (^ 2) +Testing all collisions (high 32-bit) - Expected 318764.0, actual 318240 (0.998x) (^ 0) +Testing all collisions (low 32-bit) - Expected 318764.0, actual 318505 (0.999x) (^ 0) +Testing all collisions (high 21..46 bits) - Worst is 35 bits: 40068/39987 (1.002x) (^ 0) +Testing all collisions (low 21..46 bits) - Worst is 29 bits: 2480499/2479139 (1.001x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 43-bit) - Expected 156.3, actual 152 (0.973x) (^ 0) +Testing all collisions (low 43-bit) - Expected 156.3, actual 154 (0.985x) (^ 0) +Testing all collisions (high 32-bit) - Expected 318764.0, actual 319070 (1.001x) (^ 1) +Testing all collisions (low 32-bit) - Expected 318764.0, actual 319130 (1.001x) (^ 1) +Testing all collisions (high 21..46 bits) - Worst is 46 bits: 29/20 (1.485x) (^ 0) +Testing all collisions (low 21..46 bits) - Worst is 30 bits: 1262557/1259663 (1.002x) (^ 3) + +Keyset 'Sparse' - 1536-byte keys with up to 2 bits set - 75503617 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 44-bit) - Expected 162.0, actual 182 (1.123x) (^ 3) +Testing all collisions (low 44-bit) - Expected 162.0, actual 181 (1.117x) (^ 3) +Testing all collisions (high 32-bit) - Expected 659788.1, actual 659735 (1.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 659788.1, actual 661169 (1.002x) (^ 4) +Testing all collisions (high 22..48 bits) - Worst is 46 bits: 57/41 (1.407x) (^ 2) +Testing all collisions (low 22..48 bits) - Worst is 34 bits: 166427/165672 (1.005x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 44-bit) - Expected 162.0, actual 167 (1.031x) (^ 1) +Testing all collisions (low 44-bit) - Expected 162.0, actual 153 (0.944x) (^ 0) +Testing all collisions (high 32-bit) - Expected 659788.1, actual 660466 (1.001x) (^ 2) +Testing all collisions (low 32-bit) - Expected 659788.1, actual 658557 (0.998x) (^ 0) +Testing all collisions (high 22..48 bits) - Worst is 33 bits: 331732/330860 (1.003x) (^ 0) +Testing all collisions (low 22..48 bits) - Worst is 39 bits: 5283/5185 (1.019x) (^ 0) + +Keyset 'Sparse' - 2048-byte keys with up to 2 bits set - 134225921 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 46-bit) - Expected 128.0, actual 132 (1.031x) (^ 1) +Testing all collisions (low 46-bit) - Expected 128.0, actual 138 (1.078x) (^ 2) +Testing all collisions (high 32-bit) - Expected 2075728.3, actual 2076227 (1.000x) (^ 1) +Testing all collisions (low 32-bit) - Expected 2075728.3, actual 2076575 (1.000x) (^ 1) +Testing all collisions (high 23..49 bits) - Worst is 49 bits: 24/16 (1.500x) (^ 0) +Testing all collisions (low 23..49 bits) - Worst is 35 bits: 262583/261835 (1.003x) (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 46-bit) - Expected 128.0, actual 123 (0.961x) (^ 0) +Testing all collisions (low 46-bit) - Expected 128.0, actual 127 (0.992x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2075728.3, actual 2074318 (0.999x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2075728.3, actual 2075275 (1.000x) (^ 0) +Testing all collisions (high 23..49 bits) - Worst is 49 bits: 20/16 (1.250x) (^ 0) +Testing all collisions (low 23..49 bits) - Worst is 40 bits: 8318/8193 (1.015x) (^ 0) + + +[[[ Keyset 'Permutation' Tests ]]] + +Keyset 'Combination 4-bytes [3 low bits; LE]' - up to 7 blocks from a set of 8 - 2396744 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 34-bit) - Expected 167.2, actual 147 (0.879x) (^ 0) +Testing all collisions (low 34-bit) - Expected 167.2, actual 155 (0.927x) (^ 0) +Testing all collisions (high 32-bit) - Expected 668.6, actual 620 (0.927x) (^ 0) +Testing all collisions (low 32-bit) - Expected 668.6, actual 644 (0.963x) (^ 0) +Testing all collisions (high 19..38 bits) - Worst is 23 bits: 312755/311985 (1.002x) (^ 0) +Testing all collisions (low 19..38 bits) - Worst is 37 bits: 24/21 (1.148x) (^ 0) +Testing distribution (any 8..18 bits) - Worst bias is 17 bits at bit 21: 0.737x (^ 5) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 34-bit) - Expected 167.2, actual 146 (0.873x) (^ 0) +Testing all collisions (low 34-bit) - Expected 167.2, actual 178 (1.065x) (^ 2) +Testing all collisions (high 32-bit) - Expected 668.6, actual 686 (1.026x) (^ 1) +Testing all collisions (low 32-bit) - Expected 668.6, actual 714 (1.068x) (^ 4) +Testing all collisions (high 19..38 bits) - Worst is 24 bits: 164032/163327 (1.004x) (^ 0) +Testing all collisions (low 19..38 bits) - Worst is 32 bits: 714/669 (1.068x) (^ 0) +Testing distribution (any 8..18 bits) - Worst bias is 16 bits at bit 245: 0.660x (^ 2) + +Keyset 'Combination 4-bytes [3 low bits; BE]' - up to 7 blocks from a set of 8 - 2396744 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 34-bit) - Expected 167.2, actual 163 (0.975x) (^ 0) +Testing all collisions (low 34-bit) - Expected 167.2, actual 162 (0.969x) (^ 0) +Testing all collisions (high 32-bit) - Expected 668.6, actual 666 (0.996x) (^ 0) +Testing all collisions (low 32-bit) - Expected 668.6, actual 661 (0.989x) (^ 0) +Testing all collisions (high 19..38 bits) - Worst is 33 bits: 342/334 (1.023x) (^ 0) +Testing all collisions (low 19..38 bits) - Worst is 21 bits: 968985/968388 (1.001x) (^ 0) +Testing distribution (any 8..18 bits) - Worst bias is 17 bits at bit 107: 0.518x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 34-bit) - Expected 167.2, actual 164 (0.981x) (^ 0) +Testing all collisions (low 34-bit) - Expected 167.2, actual 169 (1.011x) (^ 1) +Testing all collisions (high 32-bit) - Expected 668.6, actual 653 (0.977x) (^ 0) +Testing all collisions (low 32-bit) - Expected 668.6, actual 714 (1.068x) (^ 4) +Testing all collisions (high 19..38 bits) - Worst is 37 bits: 27/21 (1.292x) (^ 0) +Testing all collisions (low 19..38 bits) - Worst is 32 bits: 714/669 (1.068x) (^ 0) +Testing distribution (any 8..18 bits) - Worst bias is 17 bits at bit 55: 0.618x (^ 1) + +Keyset 'Combination 4-bytes [3 high bits; LE]' - up to 7 blocks from a set of 8 - 2396744 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 34-bit) - Expected 167.2, actual 176 (1.053x) (^ 1) +Testing all collisions (low 34-bit) - Expected 167.2, actual 168 (1.005x) (^ 1) +Testing all collisions (high 32-bit) - Expected 668.6, actual 708 (1.059x) (^ 3) +Testing all collisions (low 32-bit) - Expected 668.6, actual 655 (0.980x) (^ 0) +Testing all collisions (high 19..38 bits) - Worst is 33 bits: 375/334 (1.122x) (^ 1) +Testing all collisions (low 19..38 bits) - Worst is 38 bits: 15/10 (1.436x) (^ 0) +Testing distribution (any 8..18 bits) - Worst bias is 9 bits at bit 75: 0.892x (^ 2) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 34-bit) - Expected 167.2, actual 173 (1.035x) (^ 1) +Testing all collisions (low 34-bit) - Expected 167.2, actual 157 (0.939x) (^ 0) +Testing all collisions (high 32-bit) - Expected 668.6, actual 668 (0.999x) (^ 0) +Testing all collisions (low 32-bit) - Expected 668.6, actual 691 (1.033x) (^ 2) +Testing all collisions (high 19..38 bits) - Worst is 37 bits: 31/21 (1.483x) (^ 1) +Testing all collisions (low 19..38 bits) - Worst is 24 bits: 164023/163327 (1.004x) (^ 0) +Testing distribution (any 8..18 bits) - Worst bias is 12 bits at bit 10: 0.720x (^ 1) + +Keyset 'Combination 4-bytes [3 high bits; BE]' - up to 7 blocks from a set of 8 - 2396744 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 34-bit) - Expected 167.2, actual 188 (1.125x) (^ 4) +Testing all collisions (low 34-bit) - Expected 167.2, actual 138 (0.825x) (^ 0) +Testing all collisions (high 32-bit) - Expected 668.6, actual 737 (1.102x) (^ 7) +Testing all collisions (low 32-bit) - Expected 668.6, actual 640 (0.957x) (^ 0) +Testing all collisions (high 19..38 bits) - Worst is 32 bits: 737/669 (1.102x) (^ 3) +Testing all collisions (low 19..38 bits) - Worst is 25 bits: 84052/83596 (1.005x) (^ 0) +Testing distribution (any 8..18 bits) - Worst bias is 14 bits at bit 102: 0.651x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 34-bit) - Expected 167.2, actual 161 (0.963x) (^ 0) +Testing all collisions (low 34-bit) - Expected 167.2, actual 176 (1.053x) (^ 1) +Testing all collisions (high 32-bit) - Expected 668.6, actual 652 (0.975x) (^ 0) +Testing all collisions (low 32-bit) - Expected 668.6, actual 641 (0.959x) (^ 0) +Testing all collisions (high 19..38 bits) - Worst is 29 bits: 5451/5342 (1.020x) (^ 0) +Testing all collisions (low 19..38 bits) - Worst is 35 bits: 102/84 (1.220x) (^ 1) +Testing distribution (any 8..18 bits) - Worst bias is 15 bits at bit 78: 0.527x (^ 0) + +Keyset 'Combination 4-bytes [3 high+low bits; LE]' - up to 6 blocks from a set of 15 - 12204240 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 39-bit) - Expected 135.5, actual 144 (1.063x) (^ 2) +Testing all collisions (low 39-bit) - Expected 135.5, actual 147 (1.085x) (^ 2) +Testing all collisions (high 32-bit) - Expected 17322.9, actual 17513 (1.011x) (^ 3) +Testing all collisions (low 32-bit) - Expected 17322.9, actual 17311 (0.999x) (^ 0) +Testing all collisions (high 22..42 bits) - Worst is 42 bits: 31/17 (1.831x) (^ 4) +Testing all collisions (low 22..42 bits) - Worst is 40 bits: 80/68 (1.181x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 14 bits at bit 217: 0.549x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 39-bit) - Expected 135.5, actual 145 (1.070x) (^ 2) +Testing all collisions (low 39-bit) - Expected 135.5, actual 124 (0.915x) (^ 0) +Testing all collisions (high 32-bit) - Expected 17322.9, actual 17145 (0.990x) (^ 0) +Testing all collisions (low 32-bit) - Expected 17322.9, actual 17088 (0.986x) (^ 0) +Testing all collisions (high 22..42 bits) - Worst is 23 bits: 5776107/5773813 (1.000x) (^ 0) +Testing all collisions (low 22..42 bits) - Worst is 41 bits: 36/34 (1.063x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 20 bits at bit 118: 0.593x (^ 1) + +Keyset 'Combination 4-bytes [3 high+low bits; BE]' - up to 6 blocks from a set of 15 - 12204240 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 39-bit) - Expected 135.5, actual 113 (0.834x) (^ 0) +Testing all collisions (low 39-bit) - Expected 135.5, actual 124 (0.915x) (^ 0) +Testing all collisions (high 32-bit) - Expected 17322.9, actual 17169 (0.991x) (^ 0) +Testing all collisions (low 32-bit) - Expected 17322.9, actual 17364 (1.002x) (^ 1) +Testing all collisions (high 22..42 bits) - Worst is 24 bits: 3535012/3532925 (1.001x) (^ 0) +Testing all collisions (low 22..42 bits) - Worst is 32 bits: 17364/17323 (1.002x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 12 bits at bit 214: 0.672x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 39-bit) - Expected 135.5, actual 138 (1.019x) (^ 1) +Testing all collisions (low 39-bit) - Expected 135.5, actual 149 (1.100x) (^ 2) +Testing all collisions (high 32-bit) - Expected 17322.9, actual 17236 (0.995x) (^ 0) +Testing all collisions (low 32-bit) - Expected 17322.9, actual 17491 (1.010x) (^ 3) +Testing all collisions (high 22..42 bits) - Worst is 42 bits: 26/17 (1.535x) (^ 1) +Testing all collisions (low 22..42 bits) - Worst is 29 bits: 138407/137669 (1.005x) (^ 1) +Testing distribution (any 8..21 bits) - Worst bias is 14 bits at bit 57: 0.642x (^ 0) + +Keyset 'Combination 4-bytes [0, low bit; LE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 108 (0.844x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 142 (1.109x) (^ 3) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32545 (0.994x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32785 (1.002x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 28 bits: 513624/513534 (1.000x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 42 bits: 43/32 (1.344x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 14 bits at bit 200: 0.553x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 119 (0.930x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 141 (1.102x) (^ 2) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32837 (1.003x) (^ 1) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32877 (1.005x) (^ 2) +Testing all collisions (high 22..43 bits) - Worst is 37 bits: 1100/1024 (1.074x) (^ 2) +Testing all collisions (low 22..43 bits) - Worst is 37 bits: 1104/1024 (1.078x) (^ 2) +Testing distribution (any 8..21 bits) - Worst bias is 9 bits at bit 188: 0.868x (^ 1) + +Keyset 'Combination 4-bytes [0, low bit; BE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 114 (0.891x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 127 (0.992x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32433 (0.991x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32975 (1.008x) (^ 3) +Testing all collisions (high 22..43 bits) - Worst is 35 bits: 4133/4095 (1.009x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 31 bits: 65754/65366 (1.006x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 16 bits at bit 136: 0.688x (^ 2) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 142 (1.109x) (^ 3) +Testing all collisions (low 40-bit) - Expected 128.0, actual 134 (1.047x) (^ 1) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32673 (0.998x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32860 (1.004x) (^ 2) +Testing all collisions (high 22..43 bits) - Worst is 25 bits: 3577797/3574575 (1.001x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 38 bits: 534/512 (1.043x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 12 bits at bit 111: 0.854x (^ 4) + +Keyset 'Combination 4-bytes [0, high bit; LE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 121 (0.945x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 137 (1.070x) (^ 2) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32733 (1.000x) (^ 1) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32518 (0.994x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 35 bits: 4128/4095 (1.008x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 43 bits: 23/16 (1.438x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 13 bits at bit 217: 0.791x (^ 3) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 159 (1.242x) (^ 7) +Testing all collisions (low 40-bit) - Expected 128.0, actual 112 (0.875x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32862 (1.004x) (^ 2) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32675 (0.998x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 40 bits: 159/128 (1.242x) (^ 3) +Testing all collisions (low 22..43 bits) - Worst is 29 bits: 260059/259434 (1.002x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 9 bits at bit 123: 0.939x (^ 3) + +Keyset 'Combination 4-bytes [0, high bit; BE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 141 (1.102x) (^ 2) +Testing all collisions (low 40-bit) - Expected 128.0, actual 136 (1.063x) (^ 1) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32434 (0.991x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32933 (1.006x) (^ 2) +Testing all collisions (high 22..43 bits) - Worst is 26 bits: 1934644/1932787 (1.001x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 41 bits: 82/64 (1.281x) (^ 1) +Testing distribution (any 8..21 bits) - Worst bias is 17 bits at bit 24: 0.555x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 127 (0.992x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 132 (1.031x) (^ 1) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32790 (1.002x) (^ 1) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 33155 (1.013x) (^ 6) +Testing all collisions (high 22..43 bits) - Worst is 38 bits: 523/512 (1.022x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 32 bits: 33155/32725 (1.013x) (^ 2) +Testing distribution (any 8..21 bits) - Worst bias is 14 bits at bit 223: 0.635x (^ 0) + +Keyset 'Combination 8-bytes [0, low bit; LE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 131 (1.023x) (^ 1) +Testing all collisions (low 40-bit) - Expected 128.0, actual 116 (0.906x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32771 (1.001x) (^ 1) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32681 (0.999x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 37 bits: 1073/1024 (1.048x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 27 bits: 1008577/1006217 (1.002x) (^ 2) +Testing distribution (any 8..21 bits) - Worst bias is 9 bits at bit 88: 1.055x (^ 6) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 134 (1.047x) (^ 1) +Testing all collisions (low 40-bit) - Expected 128.0, actual 137 (1.070x) (^ 2) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32695 (0.999x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32221 (0.985x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 24 bits: 6175091/6171991 (1.001x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 26 bits: 1934865/1932787 (1.001x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 15 bits at bit 127: 0.682x (^ 1) + +Keyset 'Combination 8-bytes [0, low bit; BE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 131 (1.023x) (^ 1) +Testing all collisions (low 40-bit) - Expected 128.0, actual 134 (1.047x) (^ 1) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32595 (0.996x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32855 (1.004x) (^ 2) +Testing all collisions (high 22..43 bits) - Worst is 38 bits: 550/512 (1.074x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 41 bits: 85/64 (1.328x) (^ 2) +Testing distribution (any 8..21 bits) - Worst bias is 21 bits at bit 210: 0.501x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 118 (0.922x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 142 (1.109x) (^ 3) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32778 (1.002x) (^ 1) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 33028 (1.009x) (^ 4) +Testing all collisions (high 22..43 bits) - Worst is 29 bits: 260704/259434 (1.005x) (^ 2) +Testing all collisions (low 22..43 bits) - Worst is 32 bits: 33028/32725 (1.009x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 21 bits at bit 206: 0.573x (^ 1) + +Keyset 'Combination 8-bytes [0, high bit; LE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 123 (0.961x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 133 (1.039x) (^ 1) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32556 (0.995x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32633 (0.997x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 27 bits: 1007128/1006217 (1.001x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 37 bits: 1077/1024 (1.052x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 13 bits at bit 90: 0.617x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 154 (1.203x) (^ 6) +Testing all collisions (low 40-bit) - Expected 128.0, actual 139 (1.086x) (^ 2) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 33173 (1.014x) (^ 7) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32750 (1.001x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 31 bits: 66165/65366 (1.012x) (^ 5) +Testing all collisions (low 22..43 bits) - Worst is 43 bits: 22/16 (1.375x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 19 bits at bit 67: 0.526x (^ 0) + +Keyset 'Combination 8-bytes [0, high bit; BE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 133 (1.039x) (^ 1) +Testing all collisions (low 40-bit) - Expected 128.0, actual 153 (1.195x) (^ 5) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32524 (0.994x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32765 (1.001x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 37 bits: 1059/1024 (1.034x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 39 bits: 300/256 (1.172x) (^ 3) +Testing distribution (any 8..21 bits) - Worst bias is 11 bits at bit 229: 0.691x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 118 (0.922x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 107 (0.836x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32520 (0.994x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32752 (1.001x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 25 bits: 3575522/3574575 (1.000x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 35 bits: 4166/4095 (1.017x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 21 bits at bit 176: 0.483x (^ 0) + +Keyset 'Combination 16-bytes [0, low bit; LE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 138 (1.078x) (^ 2) +Testing all collisions (low 40-bit) - Expected 128.0, actual 133 (1.039x) (^ 1) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32599 (0.996x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32954 (1.007x) (^ 3) +Testing all collisions (high 22..43 bits) - Worst is 42 bits: 46/32 (1.438x) (^ 2) +Testing all collisions (low 22..43 bits) - Worst is 39 bits: 280/256 (1.094x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 18 bits at bit 50: 0.502x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 129 (1.008x) (^ 1) +Testing all collisions (low 40-bit) - Expected 128.0, actual 120 (0.938x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32353 (0.989x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32632 (0.997x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 42 bits: 36/32 (1.125x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 29 bits: 259551/259434 (1.000x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 21 bits at bit 185: 0.558x (^ 1) + +Keyset 'Combination 16-bytes [0, low bit; BE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 150 (1.172x) (^ 4) +Testing all collisions (low 40-bit) - Expected 128.0, actual 155 (1.211x) (^ 6) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32871 (1.004x) (^ 2) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32726 (1.000x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 34 bits: 8406/8189 (1.026x) (^ 2) +Testing all collisions (low 22..43 bits) - Worst is 40 bits: 155/128 (1.211x) (^ 2) +Testing distribution (any 8..21 bits) - Worst bias is 14 bits at bit 9: 0.668x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 119 (0.930x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 127 (0.992x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32668 (0.998x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32870 (1.004x) (^ 2) +Testing all collisions (high 22..43 bits) - Worst is 28 bits: 514743/513534 (1.002x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 34 bits: 8292/8189 (1.013x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 9 bits at bit 26: 0.892x (^ 2) + +Keyset 'Combination 16-bytes [0, high bit; LE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 133 (1.039x) (^ 1) +Testing all collisions (low 40-bit) - Expected 128.0, actual 121 (0.945x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32761 (1.001x) (^ 1) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32525 (0.994x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 34 bits: 8295/8189 (1.013x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 24 bits: 6173909/6171991 (1.000x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 15 bits at bit 122: 0.559x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 123 (0.961x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 136 (1.063x) (^ 1) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32854 (1.004x) (^ 2) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32940 (1.007x) (^ 3) +Testing all collisions (high 22..43 bits) - Worst is 30 bits: 130946/130392 (1.004x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 32 bits: 32940/32725 (1.007x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 14 bits at bit 167: 0.657x (^ 0) + +Keyset 'Combination 16-bytes [0, high bit; BE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 126 (0.984x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 154 (1.203x) (^ 6) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32775 (1.002x) (^ 1) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32793 (1.002x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 33 bits: 16546/16373 (1.011x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 41 bits: 86/64 (1.344x) (^ 3) +Testing distribution (any 8..21 bits) - Worst bias is 8 bits at bit 87: 0.814x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 132 (1.031x) (^ 1) +Testing all collisions (low 40-bit) - Expected 128.0, actual 133 (1.039x) (^ 1) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32722 (1.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32708 (0.999x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 39 bits: 273/256 (1.066x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 27 bits: 1007988/1006217 (1.002x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 15 bits at bit 225: 0.602x (^ 0) + +Keyset 'Combination 32-bytes [0, low bit; LE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 128 (1.000x) (^ 1) +Testing all collisions (low 40-bit) - Expected 128.0, actual 138 (1.078x) (^ 2) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32653 (0.998x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32749 (1.001x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 26 bits: 1933979/1932787 (1.001x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 33 bits: 16609/16373 (1.014x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 19 bits at bit 53: 0.571x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 129 (1.008x) (^ 1) +Testing all collisions (low 40-bit) - Expected 128.0, actual 127 (0.992x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32666 (0.998x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32629 (0.997x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 26 bits: 1934153/1932787 (1.001x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 36 bits: 2155/2048 (1.052x) (^ 2) +Testing distribution (any 8..21 bits) - Worst bias is 11 bits at bit 36: 0.625x (^ 0) + +Keyset 'Combination 32-bytes [0, low bit; BE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 129 (1.008x) (^ 1) +Testing all collisions (low 40-bit) - Expected 128.0, actual 123 (0.961x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32853 (1.004x) (^ 2) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32552 (0.995x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 35 bits: 4245/4095 (1.037x) (^ 2) +Testing all collisions (low 22..43 bits) - Worst is 24 bits: 6175441/6171991 (1.001x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 20 bits at bit 122: 0.568x (^ 1) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 104 (0.813x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 126 (0.984x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32452 (0.992x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32845 (1.004x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 30 bits: 130707/130392 (1.002x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 36 bits: 2124/2048 (1.037x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 19 bits at bit 91: 0.586x (^ 1) + +Keyset 'Combination 32-bytes [0, high bit; LE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 126 (0.984x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 139 (1.086x) (^ 2) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32790 (1.002x) (^ 1) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32860 (1.004x) (^ 2) +Testing all collisions (high 22..43 bits) - Worst is 43 bits: 19/16 (1.188x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 38 bits: 550/512 (1.074x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 21 bits at bit 161: 0.449x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 146 (1.141x) (^ 3) +Testing all collisions (low 40-bit) - Expected 128.0, actual 154 (1.203x) (^ 6) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32780 (1.002x) (^ 1) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32805 (1.002x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 34 bits: 8366/8189 (1.022x) (^ 1) +Testing all collisions (low 22..43 bits) - Worst is 29 bits: 260935/259434 (1.006x) (^ 4) +Testing distribution (any 8..21 bits) - Worst bias is 21 bits at bit 4: 0.556x (^ 1) + +Keyset 'Combination 32-bytes [0, high bit; BE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 135 (1.055x) (^ 1) +Testing all collisions (low 40-bit) - Expected 128.0, actual 124 (0.969x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32624 (0.997x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32998 (1.008x) (^ 3) +Testing all collisions (high 22..43 bits) - Worst is 41 bits: 75/64 (1.172x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 32 bits: 32998/32725 (1.008x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 16 bits at bit 142: 0.652x (^ 1) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 137 (1.070x) (^ 2) +Testing all collisions (low 40-bit) - Expected 128.0, actual 118 (0.922x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32582 (0.996x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32439 (0.991x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 43 bits: 22/16 (1.375x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 31 bits: 65530/65366 (1.003x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 15 bits at bit 44: 0.601x (^ 0) + +Keyset 'Combination 64-bytes [0, low bit; LE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 125 (0.977x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 133 (1.039x) (^ 1) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 33086 (1.011x) (^ 5) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32709 (0.999x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 32 bits: 33086/32725 (1.011x) (^ 1) +Testing all collisions (low 22..43 bits) - Worst is 26 bits: 1935147/1932787 (1.001x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 10 bits at bit 124: 0.864x (^ 2) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 130 (1.016x) (^ 1) +Testing all collisions (low 40-bit) - Expected 128.0, actual 119 (0.930x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32790 (1.002x) (^ 1) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32568 (0.995x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 28 bits: 514284/513534 (1.001x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 35 bits: 4139/4095 (1.011x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 12 bits at bit 90: 0.853x (^ 4) + +Keyset 'Combination 64-bytes [0, low bit; BE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 135 (1.055x) (^ 1) +Testing all collisions (low 40-bit) - Expected 128.0, actual 132 (1.031x) (^ 1) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32710 (1.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32612 (0.997x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 38 bits: 559/512 (1.092x) (^ 1) +Testing all collisions (low 22..43 bits) - Worst is 37 bits: 1048/1024 (1.023x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 10 bits at bit 218: 0.889x (^ 3) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 137 (1.070x) (^ 2) +Testing all collisions (low 40-bit) - Expected 128.0, actual 136 (1.063x) (^ 1) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32804 (1.002x) (^ 1) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32533 (0.994x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 39 bits: 279/256 (1.090x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 30 bits: 130816/130392 (1.003x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 18 bits at bit 208: 0.541x (^ 0) + +Keyset 'Combination 64-bytes [0, high bit; LE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 105 (0.820x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 122 (0.953x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32462 (0.992x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32793 (1.002x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 27 bits: 1007207/1006217 (1.001x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 24 bits: 6173151/6171991 (1.000x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 14 bits at bit 189: 0.550x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 106 (0.828x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 116 (0.906x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 33188 (1.014x) (^ 7) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32652 (0.998x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 30 bits: 131427/130392 (1.008x) (^ 4) +Testing all collisions (low 22..43 bits) - Worst is 28 bits: 514702/513534 (1.002x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 11 bits at bit 203: 0.792x (^ 1) + +Keyset 'Combination 64-bytes [0, high bit; BE]' - up to 23 blocks from a set of 2 - 16777214 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 127 (0.992x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 147 (1.148x) (^ 4) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32939 (1.007x) (^ 3) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32793 (1.002x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 38 bits: 558/512 (1.090x) (^ 1) +Testing all collisions (low 22..43 bits) - Worst is 40 bits: 147/128 (1.148x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 12 bits at bit 47: 0.696x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 127 (0.992x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 135 (1.055x) (^ 1) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32299 (0.987x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32755 (1.001x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 37 bits: 1059/1024 (1.034x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 43 bits: 23/16 (1.438x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 15 bits at bit 202: 0.693x (^ 2) + + +[[[ Keyset 'Text' Tests ]]] + +Keyset 'Dict' - dictionary words - 528194 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32.5, actual 23 (0.708x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32.5, actual 22 (0.677x) (^ 0) +Testing all collisions (high 30-bit) - Expected 129.9, actual 132 (1.016x) (^ 1) +Testing all collisions (low 30-bit) - Expected 129.9, actual 111 (0.855x) (^ 0) +Testing all collisions (high 17..33 bits) - Worst is 25 bits: 4196/4136 (1.015x) (^ 0) +Testing all collisions (low 17..33 bits) - Worst is 21 bits: 61503/61266 (1.004x) (^ 0) +Testing distribution (any 8..16 bits) - Worst bias is 10 bits at bit 247: 0.757x (^ 0) + +Keyset 'TextNum' - numbers in text form without commas - 10000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 181.9, actual 165 (0.907x) (^ 0) +Testing all collisions (low 38-bit) - Expected 181.9, actual 178 (0.979x) (^ 0) +Testing all collisions (high 32-bit) - Expected 11632.5, actual 11777 (1.012x) (^ 3) +Testing all collisions (low 32-bit) - Expected 11632.5, actual 11705 (1.006x) (^ 1) +Testing all collisions (high 21..42 bits) - Worst is 33 bits: 5937/5819 (1.020x) (^ 0) +Testing all collisions (low 21..42 bits) - Worst is 31 bits: 23369/23247 (1.005x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 9 bits at bit 242: 0.855x (^ 1) + +Keyset 'TextNum' - numbers in text form with commas - 10000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 181.9, actual 161 (0.885x) (^ 0) +Testing all collisions (low 38-bit) - Expected 181.9, actual 196 (1.078x) (^ 2) +Testing all collisions (high 32-bit) - Expected 11632.5, actual 11622 (0.999x) (^ 0) +Testing all collisions (low 32-bit) - Expected 11632.5, actual 11684 (1.004x) (^ 1) +Testing all collisions (high 21..42 bits) - Worst is 27 bits: 364254/363447 (1.002x) (^ 0) +Testing all collisions (low 21..42 bits) - Worst is 37 bits: 413/364 (1.135x) (^ 2) +Testing distribution (any 8..20 bits) - Worst bias is 20 bits at bit 134: 0.502x (^ 0) + +Keyset 'Text' - keys of form "FXXXXB" - 15752961 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 112.8, actual 107 (0.948x) (^ 0) +Testing all collisions (low 40-bit) - Expected 112.8, actual 112 (0.992x) (^ 0) +Testing all collisions (high 32-bit) - Expected 28853.8, actual 29151 (1.010x) (^ 4) +Testing all collisions (low 32-bit) - Expected 28853.8, actual 28775 (0.997x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 32 bits: 29151/28854 (1.010x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 34 bits: 7313/7220 (1.013x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 12 bits at bit 111: 0.704x (^ 0) + +Keyset 'Text' - keys of form "FBXXXX" - 15752961 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 112.8, actual 135 (1.196x) (^ 5) +Testing all collisions (low 40-bit) - Expected 112.8, actual 134 (1.187x) (^ 5) +Testing all collisions (high 32-bit) - Expected 28853.8, actual 29132 (1.010x) (^ 4) +Testing all collisions (low 32-bit) - Expected 28853.8, actual 28715 (0.995x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 41 bits: 74/56 (1.311x) (^ 1) +Testing all collisions (low 22..43 bits) - Worst is 41 bits: 72/56 (1.276x) (^ 1) +Testing distribution (any 8..21 bits) - Worst bias is 9 bits at bit 244: 0.804x (^ 0) + +Keyset 'Text' - keys of form "XXXXFB" - 15752961 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 112.8, actual 117 (1.037x) (^ 1) +Testing all collisions (low 40-bit) - Expected 112.8, actual 112 (0.992x) (^ 0) +Testing all collisions (high 32-bit) - Expected 28853.8, actual 28868 (1.000x) (^ 1) +Testing all collisions (low 32-bit) - Expected 28853.8, actual 28502 (0.988x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 26 bits: 1714092/1712342 (1.001x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 28 bits: 453885/453315 (1.001x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 17 bits at bit 69: 0.551x (^ 0) + +Keyset 'Text' - keys of form "FooXXXXBar" - 15752961 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 112.8, actual 127 (1.125x) (^ 3) +Testing all collisions (low 40-bit) - Expected 112.8, actual 118 (1.046x) (^ 1) +Testing all collisions (high 32-bit) - Expected 28853.8, actual 29059 (1.007x) (^ 3) +Testing all collisions (low 32-bit) - Expected 28853.8, actual 28993 (1.005x) (^ 2) +Testing all collisions (high 22..43 bits) - Worst is 40 bits: 127/113 (1.125x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 30 bits: 115850/114993 (1.007x) (^ 3) +Testing distribution (any 8..21 bits) - Worst bias is 21 bits at bit 134: 0.617x (^ 3) + +Keyset 'Text' - keys of form "FooBarXXXX" - 15752961 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 112.8, actual 99 (0.877x) (^ 0) +Testing all collisions (low 40-bit) - Expected 112.8, actual 119 (1.055x) (^ 1) +Testing all collisions (high 32-bit) - Expected 28853.8, actual 28700 (0.995x) (^ 0) +Testing all collisions (low 32-bit) - Expected 28853.8, actual 28934 (1.003x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 35 bits: 3644/3611 (1.009x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 29 bits: 229565/228869 (1.003x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 14 bits at bit 98: 0.760x (^ 3) + +Keyset 'Text' - keys of form "XXXXFooBar" - 15752961 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 112.8, actual 103 (0.913x) (^ 0) +Testing all collisions (low 40-bit) - Expected 112.8, actual 120 (1.063x) (^ 1) +Testing all collisions (high 32-bit) - Expected 28853.8, actual 28927 (1.003x) (^ 1) +Testing all collisions (low 32-bit) - Expected 28853.8, actual 28972 (1.004x) (^ 2) +Testing all collisions (high 22..43 bits) - Worst is 26 bits: 1714410/1712342 (1.001x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 37 bits: 949/903 (1.051x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 9 bits at bit 80: 0.828x (^ 0) + +Keyset 'Text' - keys of form "FooooXXXXBaaar" - 15752961 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 112.8, actual 114 (1.010x) (^ 1) +Testing all collisions (low 40-bit) - Expected 112.8, actual 104 (0.922x) (^ 0) +Testing all collisions (high 32-bit) - Expected 28853.8, actual 28659 (0.993x) (^ 0) +Testing all collisions (low 32-bit) - Expected 28853.8, actual 29042 (1.007x) (^ 2) +Testing all collisions (high 22..43 bits) - Worst is 42 bits: 35/28 (1.241x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 35 bits: 3718/3611 (1.030x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 18 bits at bit 195: 0.552x (^ 0) + +Keyset 'Text' - keys of form "FooooBaaarXXXX" - 15752961 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 112.8, actual 124 (1.099x) (^ 2) +Testing all collisions (low 40-bit) - Expected 112.8, actual 105 (0.930x) (^ 0) +Testing all collisions (high 32-bit) - Expected 28853.8, actual 29241 (1.013x) (^ 6) +Testing all collisions (low 32-bit) - Expected 28853.8, actual 28633 (0.992x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 37 bits: 981/903 (1.087x) (^ 3) +Testing all collisions (low 22..43 bits) - Worst is 37 bits: 953/903 (1.056x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 13 bits at bit 86: 0.716x (^ 1) + +Keyset 'Text' - keys of form "XXXXFooooBaaar" - 15752961 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 112.8, actual 120 (1.063x) (^ 1) +Testing all collisions (low 40-bit) - Expected 112.8, actual 116 (1.028x) (^ 1) +Testing all collisions (high 32-bit) - Expected 28853.8, actual 29065 (1.007x) (^ 3) +Testing all collisions (low 32-bit) - Expected 28853.8, actual 28731 (0.996x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 37 bits: 962/903 (1.066x) (^ 1) +Testing all collisions (low 22..43 bits) - Worst is 42 bits: 34/28 (1.205x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 21 bits at bit 54: 0.551x (^ 1) + +Keyset 'Text' - keys of form "FooooooXXXXBaaaaar" - 15752961 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 112.8, actual 110 (0.975x) (^ 0) +Testing all collisions (low 40-bit) - Expected 112.8, actual 127 (1.125x) (^ 3) +Testing all collisions (high 32-bit) - Expected 28853.8, actual 29109 (1.009x) (^ 3) +Testing all collisions (low 32-bit) - Expected 28853.8, actual 28895 (1.001x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 32 bits: 29109/28854 (1.009x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 42 bits: 36/28 (1.276x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 17 bits at bit 212: 0.670x (^ 2) + +Keyset 'Text' - keys of form "FooooooBaaaaarXXXX" - 15752961 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 112.8, actual 115 (1.019x) (^ 1) +Testing all collisions (low 40-bit) - Expected 112.8, actual 114 (1.010x) (^ 1) +Testing all collisions (high 32-bit) - Expected 28853.8, actual 28640 (0.993x) (^ 0) +Testing all collisions (low 32-bit) - Expected 28853.8, actual 28857 (1.000x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 39 bits: 241/226 (1.068x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 29 bits: 229564/228869 (1.003x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 19 bits at bit 153: 0.687x (^ 4) + +Keyset 'Text' - keys of form "XXXXFooooooBaaaaar" - 15752961 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 112.8, actual 121 (1.072x) (^ 2) +Testing all collisions (low 40-bit) - Expected 112.8, actual 107 (0.948x) (^ 0) +Testing all collisions (high 32-bit) - Expected 28853.8, actual 28741 (0.996x) (^ 0) +Testing all collisions (low 32-bit) - Expected 28853.8, actual 28934 (1.003x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 42 bits: 36/28 (1.276x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 42 bits: 42/28 (1.489x) (^ 2) +Testing distribution (any 8..21 bits) - Worst bias is 20 bits at bit 59: 0.544x (^ 0) + +Keyset 'Text' - keys of form "FooooooooXXXXBaaaaaaar" - 15752961 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 112.8, actual 105 (0.930x) (^ 0) +Testing all collisions (low 40-bit) - Expected 112.8, actual 99 (0.877x) (^ 0) +Testing all collisions (high 32-bit) - Expected 28853.8, actual 28744 (0.996x) (^ 0) +Testing all collisions (low 32-bit) - Expected 28853.8, actual 28729 (0.996x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 35 bits: 3659/3611 (1.013x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 28 bits: 454076/453315 (1.002x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 20 bits at bit 83: 0.707x (^ 6) + +Keyset 'Text' - keys of form "FooooooooBaaaaaaarXXXX" - 15752961 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 112.8, actual 127 (1.125x) (^ 3) +Testing all collisions (low 40-bit) - Expected 112.8, actual 109 (0.966x) (^ 0) +Testing all collisions (high 32-bit) - Expected 28853.8, actual 28791 (0.998x) (^ 0) +Testing all collisions (low 32-bit) - Expected 28853.8, actual 28780 (0.997x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 41 bits: 69/56 (1.223x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 29 bits: 229472/228869 (1.003x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 15 bits at bit 76: 0.655x (^ 1) + +Keyset 'Text' - keys of form "XXXXFooooooooBaaaaaaar" - 15752961 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 112.8, actual 116 (1.028x) (^ 1) +Testing all collisions (low 40-bit) - Expected 112.8, actual 115 (1.019x) (^ 1) +Testing all collisions (high 32-bit) - Expected 28853.8, actual 28714 (0.995x) (^ 0) +Testing all collisions (low 32-bit) - Expected 28853.8, actual 28723 (0.995x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 28 bits: 454916/453315 (1.004x) (^ 2) +Testing all collisions (low 22..43 bits) - Worst is 35 bits: 3665/3611 (1.015x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 14 bits at bit 156: 0.696x (^ 1) + +Keyset 'Text' - keys of form "FooooooooooXXXXBaaaaaaaaar" - 15752961 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 112.8, actual 111 (0.984x) (^ 0) +Testing all collisions (low 40-bit) - Expected 112.8, actual 99 (0.877x) (^ 0) +Testing all collisions (high 32-bit) - Expected 28853.8, actual 28653 (0.993x) (^ 0) +Testing all collisions (low 32-bit) - Expected 28853.8, actual 29057 (1.007x) (^ 3) +Testing all collisions (high 22..43 bits) - Worst is 41 bits: 59/56 (1.046x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 33 bits: 14597/14436 (1.011x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 10 bits at bit 77: 0.805x (^ 1) + +Keyset 'Text' - keys of form "FooooooooooBaaaaaaaaarXXXX" - 15752961 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 112.8, actual 122 (1.081x) (^ 2) +Testing all collisions (low 40-bit) - Expected 112.8, actual 129 (1.143x) (^ 3) +Testing all collisions (high 32-bit) - Expected 28853.8, actual 28903 (1.002x) (^ 1) +Testing all collisions (low 32-bit) - Expected 28853.8, actual 28906 (1.002x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 41 bits: 69/56 (1.223x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 33 bits: 14748/14436 (1.022x) (^ 3) +Testing distribution (any 8..21 bits) - Worst bias is 9 bits at bit 201: 0.903x (^ 2) + +Keyset 'Text' - keys of form "XXXXFooooooooooBaaaaaaaaar" - 15752961 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 112.8, actual 106 (0.939x) (^ 0) +Testing all collisions (low 40-bit) - Expected 112.8, actual 116 (1.028x) (^ 1) +Testing all collisions (high 32-bit) - Expected 28853.8, actual 28680 (0.994x) (^ 0) +Testing all collisions (low 32-bit) - Expected 28853.8, actual 28741 (0.996x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 27 bits: 890103/889322 (1.001x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 36 bits: 1859/1805 (1.030x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 11 bits at bit 154: 0.698x (^ 0) + +Keyset 'Words' - 1-4 random chars from alnum charset - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 110 (0.945x) (^ 0) +Testing all collisions (low 32-bit) - Expected 116.4, actual 128 (1.100x) (^ 2) +Testing all collisions (high 18..35 bits) - Worst is 21 bits: 205014/204642 (1.002x) (^ 0) +Testing all collisions (low 18..35 bits) - Worst is 33 bits: 67/58 (1.151x) (^ 0) +Testing distribution (any 8..17 bits) - Worst bias is 9 bits at bit 32: 0.803x (^ 0) + +Keyset 'Words' - 5-8 random chars from alnum charset - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 126 (1.082x) (^ 2) +Testing all collisions (low 32-bit) - Expected 116.4, actual 117 (1.000x) (^ 1) +Testing all collisions (high 18..35 bits) - Worst is 31 bits: 250/233 (1.074x) (^ 0) +Testing all collisions (low 18..35 bits) - Worst is 34 bits: 30/29 (1.031x) (^ 0) +Testing distribution (any 8..17 bits) - Worst bias is 13 bits at bit 167: 0.714x (^ 1) + +Keyset 'Words' - 1-16 random chars from alnum charset - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 109 (0.936x) (^ 0) +Testing all collisions (low 32-bit) - Expected 116.4, actual 124 (1.065x) (^ 1) +Testing all collisions (high 18..35 bits) - Worst is 27 bits: 3769/3716 (1.014x) (^ 0) +Testing all collisions (low 18..35 bits) - Worst is 25 bits: 15082/14754 (1.022x) (^ 3) +Testing distribution (any 8..17 bits) - Worst bias is 16 bits at bit 142: 0.577x (^ 0) + +Keyset 'Words' - 1-32 random chars from alnum charset - 1000000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 116.4, actual 131 (1.125x) (^ 3) +Testing all collisions (low 32-bit) - Expected 116.4, actual 100 (0.859x) (^ 0) +Testing all collisions (high 18..35 bits) - Worst is 27 bits: 3808/3716 (1.025x) (^ 0) +Testing all collisions (low 18..35 bits) - Worst is 21 bits: 205083/204642 (1.002x) (^ 0) +Testing distribution (any 8..17 bits) - Worst bias is 12 bits at bit 141: 0.560x (^ 0) + +Keyset 'Long' - 1968-2128 random chars from alnum charset - varying first 80 chars - 4960000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 179.0, actual 179 (1.000x) (^ 1) +Testing all collisions (low 36-bit) - Expected 179.0, actual 162 (0.905x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2862.9, actual 2744 (0.958x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2862.9, actual 2951 (1.031x) (^ 4) +Testing all collisions (high 20..40 bits) - Worst is 39 bits: 28/22 (1.251x) (^ 0) +Testing all collisions (low 20..40 bits) - Worst is 27 bits: 91359/90529 (1.009x) (^ 4) +Testing distribution (any 8..19 bits) - Worst bias is 19 bits at bit 195: 0.552x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 179.0, actual 200 (1.117x) (^ 3) +Testing all collisions (low 36-bit) - Expected 179.0, actual 173 (0.967x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2862.9, actual 2871 (1.003x) (^ 1) +Testing all collisions (low 32-bit) - Expected 2862.9, actual 2811 (0.982x) (^ 0) +Testing all collisions (high 20..40 bits) - Worst is 36 bits: 200/179 (1.117x) (^ 0) +Testing all collisions (low 20..40 bits) - Worst is 24 bits: 666444/665971 (1.001x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 19 bits at bit 205: 0.572x (^ 1) + +Keyset 'Long' - 1968-2128 random chars from alnum charset - varying last 80 chars - 4960000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 179.0, actual 167 (0.933x) (^ 0) +Testing all collisions (low 36-bit) - Expected 179.0, actual 167 (0.933x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2862.9, actual 2799 (0.978x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2862.9, actual 2837 (0.991x) (^ 0) +Testing all collisions (high 20..40 bits) - Worst is 26 bits: 179612/178863 (1.004x) (^ 0) +Testing all collisions (low 20..40 bits) - Worst is 39 bits: 33/22 (1.475x) (^ 1) +Testing distribution (any 8..19 bits) - Worst bias is 11 bits at bit 199: 0.703x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 179.0, actual 178 (0.994x) (^ 0) +Testing all collisions (low 36-bit) - Expected 179.0, actual 179 (1.000x) (^ 1) +Testing all collisions (high 32-bit) - Expected 2862.9, actual 2776 (0.970x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2862.9, actual 2874 (1.004x) (^ 1) +Testing all collisions (high 20..40 bits) - Worst is 35 bits: 371/358 (1.036x) (^ 0) +Testing all collisions (low 20..40 bits) - Worst is 30 bits: 11569/11438 (1.011x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 15 bits at bit 171: 0.651x (^ 1) + +Keyset 'Long' - 4016-4176 random chars from alnum charset - varying first 80 chars - 4960000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 179.0, actual 170 (0.950x) (^ 0) +Testing all collisions (low 36-bit) - Expected 179.0, actual 163 (0.911x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2862.9, actual 2867 (1.001x) (^ 1) +Testing all collisions (low 32-bit) - Expected 2862.9, actual 2829 (0.988x) (^ 0) +Testing all collisions (high 20..40 bits) - Worst is 25 bits: 349615/349177 (1.001x) (^ 0) +Testing all collisions (low 20..40 bits) - Worst is 25 bits: 350061/349177 (1.003x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 12 bits at bit 201: 0.628x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 179.0, actual 174 (0.972x) (^ 0) +Testing all collisions (low 36-bit) - Expected 179.0, actual 189 (1.056x) (^ 2) +Testing all collisions (high 32-bit) - Expected 2862.9, actual 2874 (1.004x) (^ 1) +Testing all collisions (low 32-bit) - Expected 2862.9, actual 2943 (1.028x) (^ 3) +Testing all collisions (high 20..40 bits) - Worst is 33 bits: 1459/1432 (1.019x) (^ 0) +Testing all collisions (low 20..40 bits) - Worst is 35 bits: 412/358 (1.151x) (^ 4) +Testing distribution (any 8..19 bits) - Worst bias is 9 bits at bit 53: 0.734x (^ 0) + +Keyset 'Long' - 4016-4176 random chars from alnum charset - varying last 80 chars - 4960000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 179.0, actual 189 (1.056x) (^ 2) +Testing all collisions (low 36-bit) - Expected 179.0, actual 195 (1.089x) (^ 2) +Testing all collisions (high 32-bit) - Expected 2862.9, actual 2875 (1.004x) (^ 1) +Testing all collisions (low 32-bit) - Expected 2862.9, actual 2800 (0.978x) (^ 0) +Testing all collisions (high 20..40 bits) - Worst is 34 bits: 744/716 (1.039x) (^ 0) +Testing all collisions (low 20..40 bits) - Worst is 37 bits: 110/89 (1.229x) (^ 1) +Testing distribution (any 8..19 bits) - Worst bias is 16 bits at bit 173: 0.635x (^ 1) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 179.0, actual 165 (0.922x) (^ 0) +Testing all collisions (low 36-bit) - Expected 179.0, actual 203 (1.134x) (^ 4) +Testing all collisions (high 32-bit) - Expected 2862.9, actual 2788 (0.974x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2862.9, actual 2951 (1.031x) (^ 4) +Testing all collisions (high 20..40 bits) - Worst is 29 bits: 23067/22842 (1.010x) (^ 0) +Testing all collisions (low 20..40 bits) - Worst is 33 bits: 1516/1432 (1.059x) (^ 1) +Testing distribution (any 8..19 bits) - Worst bias is 19 bits at bit 100: 0.571x (^ 1) + +Keyset 'Long' - 8112-8272 random chars from alnum charset - varying first 80 chars - 4960000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 179.0, actual 169 (0.944x) (^ 0) +Testing all collisions (low 36-bit) - Expected 179.0, actual 181 (1.011x) (^ 1) +Testing all collisions (high 32-bit) - Expected 2862.9, actual 2890 (1.009x) (^ 1) +Testing all collisions (low 32-bit) - Expected 2862.9, actual 2869 (1.002x) (^ 1) +Testing all collisions (high 20..40 bits) - Worst is 31 bits: 5775/5724 (1.009x) (^ 0) +Testing all collisions (low 20..40 bits) - Worst is 26 bits: 179514/178863 (1.004x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 8 bits at bit 188: 0.895x (^ 1) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 179.0, actual 182 (1.017x) (^ 1) +Testing all collisions (low 36-bit) - Expected 179.0, actual 161 (0.899x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2862.9, actual 2881 (1.006x) (^ 1) +Testing all collisions (low 32-bit) - Expected 2862.9, actual 2766 (0.966x) (^ 0) +Testing all collisions (high 20..40 bits) - Worst is 35 bits: 379/358 (1.059x) (^ 0) +Testing all collisions (low 20..40 bits) - Worst is 39 bits: 24/22 (1.073x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 13 bits at bit 241: 0.634x (^ 0) + +Keyset 'Long' - 8112-8272 random chars from alnum charset - varying last 80 chars - 4960000 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 179.0, actual 177 (0.989x) (^ 0) +Testing all collisions (low 36-bit) - Expected 179.0, actual 195 (1.089x) (^ 2) +Testing all collisions (high 32-bit) - Expected 2862.9, actual 2770 (0.968x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2862.9, actual 2889 (1.009x) (^ 1) +Testing all collisions (high 20..40 bits) - Worst is 39 bits: 24/22 (1.073x) (^ 0) +Testing all collisions (low 20..40 bits) - Worst is 37 bits: 102/89 (1.140x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 8 bits at bit 203: 0.762x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 179.0, actual 167 (0.933x) (^ 0) +Testing all collisions (low 36-bit) - Expected 179.0, actual 191 (1.067x) (^ 2) +Testing all collisions (high 32-bit) - Expected 2862.9, actual 2778 (0.970x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2862.9, actual 2855 (0.997x) (^ 0) +Testing all collisions (high 20..40 bits) - Worst is 27 bits: 90699/90529 (1.002x) (^ 0) +Testing all collisions (low 20..40 bits) - Worst is 30 bits: 11581/11438 (1.012x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 19 bits at bit 129: 0.516x (^ 0) + + +[[[ Keyset 'TwoBytes' Tests ]]] + +Keyset 'TwoBytes' - all [2, 20]-byte keys with 1 or 2 non-zero bytes - 86536545 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 45-bit) - Expected 106.4, actual 103 (0.968x) (^ 0) +Testing all collisions (low 45-bit) - Expected 106.4, actual 98 (0.921x) (^ 0) +Testing all collisions (high 32-bit) - Expected 865959.1, actual 866663 (1.001x) (^ 2) +Testing all collisions (low 32-bit) - Expected 865959.1, actual 865328 (0.999x) (^ 0) +Testing all collisions (high 25..48 bits) - Worst is 29 bits: 6617430/6614183 (1.000x) (^ 0) +Testing all collisions (low 25..48 bits) - Worst is 31 bits: 1720974/1720383 (1.000x) (^ 0) +Testing distribution (any 8..24 bits) - Worst bias is 19 bits at bit 87: 0.494x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 45-bit) - Expected 106.4, actual 112 (1.052x) (^ 1) +Testing all collisions (low 45-bit) - Expected 106.4, actual 109 (1.024x) (^ 1) +Testing all collisions (high 32-bit) - Expected 865959.1, actual 866162 (1.000x) (^ 1) +Testing all collisions (low 32-bit) - Expected 865959.1, actual 866345 (1.000x) (^ 1) +Testing all collisions (high 25..48 bits) - Worst is 47 bits: 34/27 (1.278x) (^ 0) +Testing all collisions (low 25..48 bits) - Worst is 38 bits: 13812/13620 (1.014x) (^ 0) +Testing distribution (any 8..24 bits) - Worst bias is 15 bits at bit 218: 0.699x (^ 2) + +Keyset 'TwoBytes' - all 32-byte keys with 1 or 2 non-zero bytes - 32260560 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 42-bit) - Expected 118.3, actual 108 (0.913x) (^ 0) +Testing all collisions (low 42-bit) - Expected 118.3, actual 132 (1.116x) (^ 3) +Testing all collisions (high 32-bit) - Expected 120855.7, actual 120868 (1.000x) (^ 1) +Testing all collisions (low 32-bit) - Expected 120855.7, actual 120904 (1.000x) (^ 1) +Testing all collisions (high 23..45 bits) - Worst is 39 bits: 991/947 (1.047x) (^ 0) +Testing all collisions (low 23..45 bits) - Worst is 29 bits: 951776/950142 (1.002x) (^ 0) +Testing distribution (any 8..22 bits) - Worst bias is 22 bits at bit 24: 0.588x (^ 2) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 42-bit) - Expected 118.3, actual 119 (1.006x) (^ 1) +Testing all collisions (low 42-bit) - Expected 118.3, actual 135 (1.141x) (^ 3) +Testing all collisions (high 32-bit) - Expected 120855.7, actual 120946 (1.001x) (^ 1) +Testing all collisions (low 32-bit) - Expected 120855.7, actual 121033 (1.001x) (^ 1) +Testing all collisions (high 23..45 bits) - Worst is 44 bits: 37/30 (1.251x) (^ 0) +Testing all collisions (low 23..45 bits) - Worst is 38 bits: 1963/1893 (1.037x) (^ 0) +Testing distribution (any 8..22 bits) - Worst bias is 21 bits at bit 154: 0.620x (^ 3) + +Keyset 'OneByte ' - all 1024-byte keys with 1 non-zero byte - 261120 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 7.9, actual 7 (0.882x) (^ 0) +Testing all collisions (low 32-bit) - Expected 7.9, actual 9 (1.134x) (^ 1) +Testing all collisions (high 28-bit) - Expected 127.0, actual 141 (1.111x) (^ 3) +Testing all collisions (low 28-bit) - Expected 127.0, actual 137 (1.079x) (^ 2) +Testing all collisions (high 16..31 bits) - Worst is 24 bits: 2113/2022 (1.045x) (^ 1) +Testing all collisions (low 16..31 bits) - Worst is 23 bits: 4200/4022 (1.044x) (^ 4) +Testing distribution (any 8..15 bits) - Worst bias is 12 bits at bit 233: 0.645x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 7.9, actual 3 (0.378x) (^ 0) +Testing all collisions (low 32-bit) - Expected 7.9, actual 7 (0.882x) (^ 0) +Testing all collisions (high 28-bit) - Expected 127.0, actual 109 (0.859x) (^ 0) +Testing all collisions (low 28-bit) - Expected 127.0, actual 141 (1.111x) (^ 3) +Testing all collisions (high 16..31 bits) - Worst is 23 bits: 4088/4022 (1.016x) (^ 0) +Testing all collisions (low 16..31 bits) - Worst is 29 bits: 83/63 (1.307x) (^ 2) +Testing distribution (any 8..15 bits) - Worst bias is 10 bits at bit 248: 0.639x (^ 0) + +Keyset 'OneByte ' - all 2048-byte keys with 1 non-zero byte - 522240 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 31.7, actual 29 (0.913x) (^ 0) +Testing all collisions (low 32-bit) - Expected 31.7, actual 44 (1.386x) (^ 5) +Testing all collisions (high 30-bit) - Expected 127.0, actual 129 (1.016x) (^ 1) +Testing all collisions (low 30-bit) - Expected 127.0, actual 139 (1.095x) (^ 2) +Testing all collisions (high 17..33 bits) - Worst is 26 bits: 2050/2027 (1.011x) (^ 0) +Testing all collisions (low 17..33 bits) - Worst is 33 bits: 27/16 (1.701x) (^ 3) +Testing distribution (any 8..16 bits) - Worst bias is 14 bits at bit 87: 0.652x (^ 1) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 31.7, actual 35 (1.102x) (^ 1) +Testing all collisions (low 32-bit) - Expected 31.7, actual 33 (1.039x) (^ 1) +Testing all collisions (high 30-bit) - Expected 127.0, actual 147 (1.158x) (^ 4) +Testing all collisions (low 30-bit) - Expected 127.0, actual 124 (0.977x) (^ 0) +Testing all collisions (high 17..33 bits) - Worst is 24 bits: 8198/8044 (1.019x) (^ 0) +Testing all collisions (low 17..33 bits) - Worst is 29 bits: 265/254 (1.044x) (^ 0) +Testing distribution (any 8..16 bits) - Worst bias is 13 bits at bit 203: 0.512x (^ 0) + +Keyset 'OneByte ' - all 4096-byte keys with 1 non-zero byte - 1044480 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 127.0, actual 136 (1.071x) (^ 2) +Testing all collisions (low 32-bit) - Expected 127.0, actual 117 (0.921x) (^ 0) +Testing all collisions (high 18..35 bits) - Worst is 31 bits: 277/254 (1.091x) (^ 0) +Testing all collisions (low 18..35 bits) - Worst is 26 bits: 8230/8086 (1.018x) (^ 0) +Testing distribution (any 8..17 bits) - Worst bias is 16 bits at bit 51: 0.577x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 127.0, actual 136 (1.071x) (^ 2) +Testing all collisions (low 32-bit) - Expected 127.0, actual 110 (0.866x) (^ 0) +Testing all collisions (high 18..35 bits) - Worst is 26 bits: 8271/8086 (1.023x) (^ 1) +Testing all collisions (low 18..35 bits) - Worst is 28 bits: 2059/2029 (1.015x) (^ 0) +Testing distribution (any 8..17 bits) - Worst bias is 8 bits at bit 126: 0.688x (^ 0) + + +[[[ Keyset 'PerlinNoise' Tests ]]] + +Generating coordinates from 2-byte keys - 16777216 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 111 (0.867x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 128 (1.000x) (^ 1) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32871 (1.004x) (^ 2) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32638 (0.997x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 30 bits: 131015/130392 (1.005x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 28 bits: 515518/513534 (1.004x) (^ 4) +Testing distribution (any 8..21 bits) - Worst bias is 9 bits at bit 80: 0.836x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 106 (0.828x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 142 (1.109x) (^ 3) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32839 (1.003x) (^ 1) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32734 (1.000x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 31 bits: 65622/65366 (1.004x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 42 bits: 48/32 (1.500x) (^ 3) +Testing distribution (any 8..21 bits) - Worst bias is 13 bits at bit 42: 0.661x (^ 0) +---Analyzing additional differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 152 (1.188x) (^ 5) +Testing all collisions (low 40-bit) - Expected 128.0, actual 133 (1.039x) (^ 1) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32760 (1.001x) (^ 1) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32604 (0.996x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 43 bits: 30/16 (1.875x) (^ 5) +Testing all collisions (low 22..43 bits) - Worst is 40 bits: 133/128 (1.039x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 9 bits at bit 217: 0.750x (^ 0) + +Generating coordinates from 4-byte keys - 16777216 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 114 (0.891x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 131 (1.023x) (^ 1) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32457 (0.992x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32841 (1.004x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 26 bits: 1934171/1932788 (1.001x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 30 bits: 130820/130392 (1.003x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 20 bits at bit 52: 0.624x (^ 2) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 128 (1.000x) (^ 1) +Testing all collisions (low 40-bit) - Expected 128.0, actual 130 (1.016x) (^ 1) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32811 (1.003x) (^ 1) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32936 (1.006x) (^ 3) +Testing all collisions (high 22..43 bits) - Worst is 35 bits: 4231/4095 (1.033x) (^ 1) +Testing all collisions (low 22..43 bits) - Worst is 37 bits: 1077/1024 (1.052x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 12 bits at bit 141: 0.752x (^ 1) +---Analyzing additional differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 141 (1.102x) (^ 2) +Testing all collisions (low 40-bit) - Expected 128.0, actual 133 (1.039x) (^ 1) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32978 (1.008x) (^ 3) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32626 (0.997x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 32 bits: 32978/32725 (1.008x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 42 bits: 39/32 (1.219x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 16 bits at bit 216: 0.566x (^ 0) + +Generating coordinates from 8-byte keys - 16777216 keys +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 124 (0.969x) (^ 0) +Testing all collisions (low 40-bit) - Expected 128.0, actual 131 (1.023x) (^ 1) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32462 (0.992x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32652 (0.998x) (^ 0) +Testing all collisions (high 22..43 bits) - Worst is 43 bits: 23/16 (1.438x) (^ 0) +Testing all collisions (low 22..43 bits) - Worst is 35 bits: 4195/4095 (1.024x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 14 bits at bit 237: 0.736x (^ 2) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 153 (1.195x) (^ 5) +Testing all collisions (low 40-bit) - Expected 128.0, actual 140 (1.094x) (^ 2) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32723 (1.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32847 (1.004x) (^ 1) +Testing all collisions (high 22..43 bits) - Worst is 27 bits: 1008725/1006217 (1.002x) (^ 2) +Testing all collisions (low 22..43 bits) - Worst is 26 bits: 1936009/1932788 (1.002x) (^ 2) +Testing distribution (any 8..21 bits) - Worst bias is 19 bits at bit 146: 0.530x (^ 0) +---Analyzing additional differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 128.0, actual 138 (1.078x) (^ 2) +Testing all collisions (low 40-bit) - Expected 128.0, actual 117 (0.914x) (^ 0) +Testing all collisions (high 32-bit) - Expected 32725.4, actual 32854 (1.004x) (^ 2) +Testing all collisions (low 32-bit) - Expected 32725.4, actual 32938 (1.006x) (^ 3) +Testing all collisions (high 22..43 bits) - Worst is 34 bits: 8422/8189 (1.028x) (^ 3) +Testing all collisions (low 22..43 bits) - Worst is 35 bits: 4199/4095 (1.025x) (^ 0) +Testing distribution (any 8..21 bits) - Worst bias is 15 bits at bit 96: 0.613x (^ 0) + + +[[[ Keyset 'Bitflip' Tests ]]] + +Testing 3-byte keys, 2097152 reps.................... 0 failed, worst is key bit 12 +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 117 (0.914x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 124 (0.969x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 1945 (0.950x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2046 (0.999x) (^ 0) +Testing all collisions (high 20..39 bits) - Worst is 39 bits: 19/16 (1.188x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 23 bits: 894641/893644 (1.001x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 19 bits at bit 181: 0.549x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 34-bit) - Expected 128.0, actual 132 (1.031x) (^ 1) +Testing all collisions (low 34-bit) - Expected 128.0, actual 156 (1.219x) (^ 6) +Testing all collisions (high 32-bit) - Expected 511.9, actual 489 (0.955x) (^ 0) +Testing all collisions (low 32-bit) - Expected 511.9, actual 587 (1.147x) (^10) +Testing all collisions (high 19..37 bits) - Worst is 28 bits: 8427/8171 (1.031x) (^ 4) +Testing all collisions (low 19..37 bits) - Worst is 32 bits: 587/512 (1.147x) (^ 6) +Testing distribution (any 8..18 bits) - Worst bias is 13 bits at bit 32: 0.611x (^ 0) + +Testing 4-byte keys, 2097152 reps.................... 0 failed, worst is key bit 12 +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 152 (1.188x) (^ 5) +Testing all collisions (low 36-bit) - Expected 128.0, actual 141 (1.102x) (^ 2) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 1998 (0.976x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2117 (1.034x) (^ 3) +Testing all collisions (high 20..39 bits) - Worst is 36 bits: 152/128 (1.188x) (^ 1) +Testing all collisions (low 20..39 bits) - Worst is 39 bits: 25/16 (1.563x) (^ 1) +Testing distribution (any 8..19 bits) - Worst bias is 18 bits at bit 163: 0.576x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 34-bit) - Expected 128.0, actual 145 (1.133x) (^ 3) +Testing all collisions (low 34-bit) - Expected 128.0, actual 138 (1.078x) (^ 2) +Testing all collisions (high 32-bit) - Expected 511.9, actual 517 (1.010x) (^ 1) +Testing all collisions (low 32-bit) - Expected 511.9, actual 550 (1.074x) (^ 4) +Testing all collisions (high 19..37 bits) - Worst is 24 bits: 126735/125777 (1.008x) (^ 3) +Testing all collisions (low 19..37 bits) - Worst is 26 bits: 32812/32429 (1.012x) (^ 1) +Testing distribution (any 8..18 bits) - Worst bias is 9 bits at bit 112: 0.966x (^ 4) + +Testing 8-byte keys, 2097152 reps.................... 0 failed, worst is key bit 4 +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 144 (1.125x) (^ 3) +Testing all collisions (low 36-bit) - Expected 128.0, actual 148 (1.156x) (^ 4) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2065 (1.009x) (^ 1) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2148 (1.049x) (^ 6) +Testing all collisions (high 20..39 bits) - Worst is 31 bits: 4235/4093 (1.035x) (^ 2) +Testing all collisions (low 20..39 bits) - Worst is 35 bits: 302/256 (1.180x) (^ 4) +Testing distribution (any 8..19 bits) - Worst bias is 18 bits at bit 9: 0.551x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 34-bit) - Expected 128.0, actual 150 (1.172x) (^ 4) +Testing all collisions (low 34-bit) - Expected 128.0, actual 125 (0.977x) (^ 0) +Testing all collisions (high 32-bit) - Expected 511.9, actual 507 (0.990x) (^ 0) +Testing all collisions (low 32-bit) - Expected 511.9, actual 526 (1.028x) (^ 1) +Testing all collisions (high 19..37 bits) - Worst is 34 bits: 150/128 (1.172x) (^ 1) +Testing all collisions (low 19..37 bits) - Worst is 37 bits: 26/16 (1.625x) (^ 2) +Testing distribution (any 8..18 bits) - Worst bias is 16 bits at bit 52: 0.586x (^ 0) + +Testing 20-byte keys, 2097152 reps....... +............. 0 failed, worst is key bit 121 +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 151 (1.180x) (^ 5) +Testing all collisions (low 36-bit) - Expected 128.0, actual 110 (0.859x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2148 (1.049x) (^ 6) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2063 (1.008x) (^ 1) +Testing all collisions (high 20..39 bits) - Worst is 34 bits: 604/512 (1.180x) (^10) +Testing all collisions (low 20..39 bits) - Worst is 25 bits: 252669/251554 (1.004x) (^ 2) +Testing distribution (any 8..19 bits) - Worst bias is 8 bits at bit 18: 0.783x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 34-bit) - Expected 128.0, actual 120 (0.938x) (^ 0) +Testing all collisions (low 34-bit) - Expected 128.0, actual 148 (1.156x) (^ 4) +Testing all collisions (high 32-bit) - Expected 511.9, actual 491 (0.959x) (^ 0) +Testing all collisions (low 32-bit) - Expected 511.9, actual 530 (1.035x) (^ 2) +Testing all collisions (high 19..37 bits) - Worst is 22 bits: 447603/446822 (1.002x) (^ 0) +Testing all collisions (low 19..37 bits) - Worst is 34 bits: 148/128 (1.156x) (^ 0) +Testing distribution (any 8..18 bits) - Worst bias is 12 bits at bit 114: 0.904x (^ 6) + +Testing 32-byte keys, 2097152 reps.................... 0 failed, worst is key bit 51 +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 138 (1.078x) (^ 2) +Testing all collisions (low 36-bit) - Expected 128.0, actual 159 (1.242x) (^ 7) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2034 (0.993x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2017 (0.985x) (^ 0) +Testing all collisions (high 20..39 bits) - Worst is 36 bits: 138/128 (1.078x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 36 bits: 159/128 (1.242x) (^ 3) +Testing distribution (any 8..19 bits) - Worst bias is 12 bits at bit 72: 0.747x (^ 1) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 34-bit) - Expected 128.0, actual 131 (1.023x) (^ 1) +Testing all collisions (low 34-bit) - Expected 128.0, actual 145 (1.133x) (^ 3) +Testing all collisions (high 32-bit) - Expected 511.9, actual 524 (1.024x) (^ 1) +Testing all collisions (low 32-bit) - Expected 511.9, actual 557 (1.088x) (^ 5) +Testing all collisions (high 19..37 bits) - Worst is 35 bits: 71/64 (1.109x) (^ 0) +Testing all collisions (low 19..37 bits) - Worst is 31 bits: 1090/1024 (1.065x) (^ 1) +Testing distribution (any 8..18 bits) - Worst bias is 14 bits at bit 232: 0.936x (^ 9) + + +[[[ Seed 'Zeroes' Tests ]]] + +Keyset 'SeedZeroes' - up to 1280-byte keys, seeds with up to 2 set bits - 4160 seeds - 5324800 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 37-bit) - Expected 103.1, actual 101 (0.979x) (^ 0) +Testing all collisions (low 37-bit) - Expected 103.1, actual 96 (0.931x) (^ 0) +Testing all collisions (high 32-bit) - Expected 3299.4, actual 3235 (0.980x) (^ 0) +Testing all collisions (low 32-bit) - Expected 3299.4, actual 3213 (0.974x) (^ 0) +Testing all collisions (high 21..40 bits) - Worst is 38 bits: 54/52 (1.047x) (^ 0) +Testing all collisions (low 21..40 bits) - Worst is 21 bits: 3393191/3393198 (1.000x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 16 bits at bit 241: 0.656x (^ 1) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 37-bit) - Expected 103.1, actual 93 (0.902x) (^ 0) +Testing all collisions (low 37-bit) - Expected 103.1, actual 123 (1.192x) (^ 4) +Testing all collisions (high 32-bit) - Expected 3299.4, actual 3219 (0.976x) (^ 0) +Testing all collisions (low 32-bit) - Expected 3299.4, actual 3309 (1.003x) (^ 1) +Testing all collisions (high 21..40 bits) - Worst is 29 bits: 26440/26319 (1.005x) (^ 0) +Testing all collisions (low 21..40 bits) - Worst is 34 bits: 908/825 (1.100x) (^ 4) +Testing distribution (any 8..20 bits) - Worst bias is 11 bits at bit 119: 0.825x (^ 2) +---Analyzing additional differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 37-bit) - Expected 103.1, actual 85 (0.824x) (^ 0) +Testing all collisions (low 37-bit) - Expected 103.1, actual 102 (0.989x) (^ 0) +Testing all collisions (high 32-bit) - Expected 3299.4, actual 3327 (1.008x) (^ 1) +Testing all collisions (low 32-bit) - Expected 3299.4, actual 3396 (1.029x) (^ 4) +Testing all collisions (high 21..40 bits) - Worst is 29 bits: 26740/26319 (1.016x) (^ 3) +Testing all collisions (low 21..40 bits) - Worst is 32 bits: 3396/3299 (1.029x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 16 bits at bit 148: 0.626x (^ 1) + +Keyset 'SeedZeroes' - up to 8448-byte keys, seeds with up to 2 set bits - 4160 seeds - 35143680 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 42-bit) - Expected 140.4, actual 156 (1.111x) (^ 3) +Testing all collisions (low 42-bit) - Expected 140.4, actual 125 (0.890x) (^ 0) +Testing all collisions (high 32-bit) - Expected 143390.7, actual 143796 (1.003x) (^ 2) +Testing all collisions (low 32-bit) - Expected 143390.7, actual 142827 (0.996x) (^ 0) +Testing all collisions (high 23..45 bits) - Worst is 38 bits: 2332/2246 (1.038x) (^ 0) +Testing all collisions (low 23..45 bits) - Worst is 23 bits: 26882101/26882198 (1.000x) (^ 0) +Testing distribution (any 8..22 bits) - Worst bias is 13 bits at bit 181: 0.685x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 42-bit) - Expected 140.4, actual 126 (0.897x) (^ 0) +Testing all collisions (low 42-bit) - Expected 140.4, actual 142 (1.011x) (^ 1) +Testing all collisions (high 32-bit) - Expected 143390.7, actual 142911 (0.997x) (^ 0) +Testing all collisions (low 32-bit) - Expected 143390.7, actual 143298 (0.999x) (^ 0) +Testing all collisions (high 23..45 bits) - Worst is 28 bits: 2204668/2203319 (1.001x) (^ 0) +Testing all collisions (low 23..45 bits) - Worst is 28 bits: 2205249/2203319 (1.001x) (^ 0) +Testing distribution (any 8..22 bits) - Worst bias is 8 bits at bit 129: 0.768x (^ 0) +---Analyzing additional differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 42-bit) - Expected 140.4, actual 147 (1.047x) (^ 1) +Testing all collisions (low 42-bit) - Expected 140.4, actual 152 (1.083x) (^ 2) +Testing all collisions (high 32-bit) - Expected 143390.7, actual 143694 (1.002x) (^ 2) +Testing all collisions (low 32-bit) - Expected 143390.7, actual 143194 (0.999x) (^ 0) +Testing all collisions (high 23..45 bits) - Worst is 45 bits: 32/18 (1.823x) (^ 4) +Testing all collisions (low 23..45 bits) - Worst is 44 bits: 44/35 (1.253x) (^ 0) +Testing distribution (any 8..22 bits) - +Worst bias is 19 bits at bit 212: 0.608x (^ 1) + + +[[[ Keyset 'SeedSparse' Tests ]]] + +Keyset 'SeedSparse' - 2-byte keys - seeds with up to 5 bits set - 8303633 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 132 (1.052x) (^ 1) +Testing all collisions (low 38-bit) - Expected 125.4, actual 131 (1.045x) (^ 1) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 8160 (1.017x) (^ 4) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 8050 (1.004x) (^ 1) +Testing all collisions (high 21..41 bits) - Worst is 37 bits: 286/251 (1.140x) (^ 1) +Testing all collisions (low 21..41 bits) - Worst is 41 bits: 26/16 (1.658x) (^ 2) +Testing distribution (any 8..20 bits) - Worst bias is 14 bits at bit 40: 0.560x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 133 (1.060x) (^ 1) +Testing all collisions (low 38-bit) - Expected 125.4, actual 130 (1.037x) (^ 1) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 8040 (1.002x) (^ 1) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 7976 (0.994x) (^ 0) +Testing all collisions (high 21..41 bits) - Worst is 36 bits: 530/502 (1.056x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 25 bits: 948318/947681 (1.001x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 18 bits at bit 224: 0.529x (^ 0) + +Keyset 'SeedSparse' - 3-byte keys - seeds with up to 5 bits set - 8303633 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 127 (1.013x) (^ 1) +Testing all collisions (low 38-bit) - Expected 125.4, actual 134 (1.068x) (^ 2) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 7901 (0.985x) (^ 0) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 8082 (1.008x) (^ 1) +Testing all collisions (high 21..41 bits) - Worst is 40 bits: 39/31 (1.244x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 29 bits: 64330/63885 (1.007x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 19 bits at bit 24: 0.597x (^ 1) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 133 (1.060x) (^ 1) +Testing all collisions (low 38-bit) - Expected 125.4, actual 135 (1.076x) (^ 2) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 7875 (0.982x) (^ 0) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 8048 (1.003x) (^ 1) +Testing all collisions (high 21..41 bits) - Worst is 40 bits: 41/31 (1.308x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 37 bits: 271/251 (1.080x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 17 bits at bit 193: 0.567x (^ 0) + +Keyset 'SeedSparse' - 6-byte keys - seeds with up to 5 bits set - 8303633 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 114 (0.909x) (^ 0) +Testing all collisions (low 38-bit) - Expected 125.4, actual 112 (0.893x) (^ 0) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 8080 (1.007x) (^ 1) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 7974 (0.994x) (^ 0) +Testing all collisions (high 21..41 bits) - Worst is 33 bits: 4134/4012 (1.030x) (^ 1) +Testing all collisions (low 21..41 bits) - Worst is 29 bits: 64133/63885 (1.004x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 9 bits at bit 159: 0.818x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 127 (1.013x) (^ 1) +Testing all collisions (low 38-bit) - Expected 125.4, actual 130 (1.037x) (^ 1) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 8110 (1.011x) (^ 2) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 8043 (1.003x) (^ 1) +Testing all collisions (high 21..41 bits) - Worst is 32 bits: 8110/8022 (1.011x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 33 bits: 4107/4012 (1.024x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 13 bits at bit 207: 0.571x (^ 0) + +Keyset 'SeedSparse' - 15-byte keys - seeds with up to 5 bits set - 8303633 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 116 (0.925x) (^ 0) +Testing all collisions (low 38-bit) - Expected 125.4, actual 135 (1.076x) (^ 2) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 7972 (0.994x) (^ 0) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 8163 (1.018x) (^ 4) +Testing all collisions (high 21..41 bits) - Worst is 41 bits: 20/16 (1.276x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 29 bits: 64499/63885 (1.010x) (^ 2) +Testing distribution (any 8..20 bits) - Worst bias is 18 bits at bit 116: 0.582x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 142 (1.132x) (^ 3) +Testing all collisions (low 38-bit) - Expected 125.4, actual 114 (0.909x) (^ 0) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 8029 (1.001x) (^ 1) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 8004 (0.998x) (^ 0) +Testing all collisions (high 21..41 bits) - Worst is 37 bits: 280/251 (1.116x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 30 bits: 32195/32025 (1.005x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 14 bits at bit 153: 0.578x (^ 0) + +Keyset 'SeedSparse' - 18-byte keys - seeds with up to 5 bits set - 8303633 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 122 (0.973x) (^ 0) +Testing all collisions (low 38-bit) - Expected 125.4, actual 126 (1.005x) (^ 1) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 8130 (1.014x) (^ 3) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 8064 (1.005x) (^ 1) +Testing all collisions (high 21..41 bits) - Worst is 27 bits: 252769/251644 (1.004x) (^ 2) +Testing all collisions (low 21..41 bits) - Worst is 29 bits: 64173/63885 (1.005x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 17 bits at bit 147: 0.581x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 123 (0.981x) (^ 0) +Testing all collisions (low 38-bit) - Expected 125.4, actual 147 (1.172x) (^ 4) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 7986 (0.996x) (^ 0) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 8095 (1.009x) (^ 2) +Testing all collisions (high 21..41 bits) - Worst is 34 bits: 2091/2006 (1.042x) (^ 1) +Testing all collisions (low 21..41 bits) - Worst is 38 bits: 147/125 (1.172x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 16 bits at bit 6: 0.661x (^ 1) + +Keyset 'SeedSparse' - 31-byte keys - seeds with up to 5 bits set - 8303633 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 117 (0.933x) (^ 0) +Testing all collisions (low 38-bit) - Expected 125.4, actual 141 (1.124x) (^ 3) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 8027 (1.001x) (^ 1) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 7893 (0.984x) (^ 0) +Testing all collisions (high 21..41 bits) - Worst is 40 bits: 38/31 (1.212x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 29 bits: 64228/63885 (1.005x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 13 bits at bit 173: 0.821x (^ 4) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 125 (1.000x) (^ 0) +Testing all collisions (low 38-bit) - Expected 125.4, actual 128 (1.021x) (^ 1) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 7903 (0.985x) (^ 0) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 8103 (1.010x) (^ 2) +Testing all collisions (high 21..41 bits) - Worst is 40 bits: 42/31 (1.340x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 30 bits: 32205/32025 (1.006x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 17 bits at bit 153: 0.530x (^ 0) + +Keyset 'SeedSparse' - 52-byte keys - seeds with up to 5 bits set - 8303633 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 117 (0.933x) (^ 0) +Testing all collisions (low 38-bit) - Expected 125.4, actual 141 (1.124x) (^ 3) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 8017 (0.999x) (^ 0) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 8091 (1.009x) (^ 2) +Testing all collisions (high 21..41 bits) - Worst is 41 bits: 22/16 (1.403x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 35 bits: 1054/1003 (1.051x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 9 bits at bit 30: 0.801x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 118 (0.941x) (^ 0) +Testing all collisions (low 38-bit) - Expected 125.4, actual 129 (1.029x) (^ 1) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 8019 (1.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 8156 (1.017x) (^ 3) +Testing all collisions (high 21..41 bits) - Worst is 33 bits: 4091/4012 (1.020x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 30 bits: 32372/32025 (1.011x) (^ 1) +Testing distribution (any 8..20 bits) - Worst bias is 14 bits at bit 113: 0.547x (^ 0) + +Keyset 'SeedSparse' - 80-byte keys - seeds with up to 5 bits set - 8303633 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 127 (1.013x) (^ 1) +Testing all collisions (low 38-bit) - Expected 125.4, actual 117 (0.933x) (^ 0) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 8079 (1.007x) (^ 1) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 7948 (0.991x) (^ 0) +Testing all collisions (high 21..41 bits) - Worst is 27 bits: 252401/251644 (1.003x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 24 bits: 1755201/1753983 (1.001x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 17 bits at bit 82: 0.595x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 122 (0.973x) (^ 0) +Testing all collisions (low 38-bit) - Expected 125.4, actual 100 (0.797x) (^ 0) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 7913 (0.986x) (^ 0) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 8016 (0.999x) (^ 0) +Testing all collisions (high 21..41 bits) - Worst is 26 bits: 494589/493171 (1.003x) (^ 1) +Testing all collisions (low 21..41 bits) - Worst is 30 bits: 32264/32025 (1.007x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 9 bits at bit 172: 0.812x (^ 0) + +Keyset 'SeedSparse' - 200-byte keys - seeds with up to 5 bits set - 8303633 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 120 (0.957x) (^ 0) +Testing all collisions (low 38-bit) - Expected 125.4, actual 134 (1.068x) (^ 2) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 7875 (0.982x) (^ 0) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 8074 (1.007x) (^ 1) +Testing all collisions (high 21..41 bits) - Worst is 23 bits: 3032774/3032441 (1.000x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 41 bits: 21/16 (1.340x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 17 bits at bit 181: 0.613x (^ 1) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 117 (0.933x) (^ 0) +Testing all collisions (low 38-bit) - Expected 125.4, actual 116 (0.925x) (^ 0) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 8022 (1.000x) (^ 1) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 8036 (1.002x) (^ 1) +Testing all collisions (high 21..41 bits) - Worst is 28 bits: 127532/127116 (1.003x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 34 bits: 2069/2006 (1.031x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 9 bits at bit 232: 0.850x (^ 1) + +Keyset 'SeedSparse' - 1025-byte keys - seeds with up to 5 bits set - 8303633 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 120 (0.957x) (^ 0) +Testing all collisions (low 38-bit) - Expected 125.4, actual 118 (0.941x) (^ 0) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 7995 (0.997x) (^ 0) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 8077 (1.007x) (^ 1) +Testing all collisions (high 21..41 bits) - Worst is 25 bits: 948260/947681 (1.001x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 31 bits: 16170/16033 (1.009x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 20 bits at bit 183: 0.516x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 125.4, actual 131 (1.045x) (^ 1) +Testing all collisions (low 38-bit) - Expected 125.4, actual 120 (0.957x) (^ 0) +Testing all collisions (high 32-bit) - Expected 8021.7, actual 7992 (0.996x) (^ 0) +Testing all collisions (low 32-bit) - Expected 8021.7, actual 8098 (1.010x) (^ 2) +Testing all collisions (high 21..41 bits) - Worst is 23 bits: 3035612/3032441 (1.001x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 32 bits: 8098/8022 (1.010x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 14 bits at bit 42: 0.608x (^ 0) + + +[[[ Seed BlockLength Tests ]]] + +Seeds have up to 2 bits set, 4-byte blocks have up to 2 bits set + +Keyset 'SeedBlockLen' - 8-byte keys with block at offsets [0..4, by 4s] - 2196480 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 34-bit) - Expected 140.4, actual 135 (0.961x) (^ 0) +Testing all collisions (low 34-bit) - Expected 140.4, actual 140 (1.000x) (^ 0) +Testing all collisions (high 32-bit) - Expected 561.6, actual 563 (1.003x) (^ 1) +Testing all collisions (low 32-bit) - Expected 561.6, actual 551 (0.981x) (^ 0) +Testing all collisions (high 19..37 bits) - Worst is 31 bits: 1163/1123 (1.036x) (^ 0) +Testing all collisions (low 19..37 bits) - Worst is 37 bits: 19/18 (1.083x) (^ 0) +Testing distribution (any 8..18 bits) - Worst bias is 14 bits at bit 197: 0.708x (^ 2) + +Keyset 'SeedBlockLen' - 9-byte keys with block at offsets [0..4, by 4s] - 2196480 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 34-bit) - Expected 140.4, actual 153 (1.090x) (^ 2) +Testing all collisions (low 34-bit) - Expected 140.4, actual 148 (1.054x) (^ 1) +Testing all collisions (high 32-bit) - Expected 561.6, actual 595 (1.060x) (^ 3) +Testing all collisions (low 32-bit) - Expected 561.6, actual 591 (1.052x) (^ 3) +Testing all collisions (high 19..37 bits) - Worst is 36 bits: 46/35 (1.310x) (^ 0) +Testing all collisions (low 19..37 bits) - Worst is 30 bits: 2349/2245 (1.046x) (^ 1) +Testing distribution (any 8..18 bits) - Worst bias is 13 bits at bit 23: 0.638x (^ 0) + +Keyset 'SeedBlockLen' - 10-byte keys with block at offsets [0..4, by 4s] - 2196480 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 34-bit) - Expected 140.4, actual 143 (1.018x) (^ 1) +Testing all collisions (low 34-bit) - Expected 140.4, actual 133 (0.947x) (^ 0) +Testing all collisions (high 32-bit) - Expected 561.6, actual 593 (1.056x) (^ 3) +Testing all collisions (low 32-bit) - Expected 561.6, actual 526 (0.937x) (^ 0) +Testing all collisions (high 19..37 bits) - Worst is 37 bits: 26/18 (1.481x) (^ 0) +Testing all collisions (low 19..37 bits) - Worst is 23 bits: 264428/264026 (1.002x) (^ 0) +Testing distribution (any 8..18 bits) - Worst bias is 12 bits at bit 59: 0.806x (^ 3) + +Keyset 'SeedBlockLen' - 11-byte keys with block at offsets [0..4, by 4s] - 2196480 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 34-bit) - Expected 140.4, actual 148 (1.054x) (^ 1) +Testing all collisions (low 34-bit) - Expected 140.4, actual 133 (0.947x) (^ 0) +Testing all collisions (high 32-bit) - Expected 561.6, actual 607 (1.081x) (^ 5) +Testing all collisions (low 32-bit) - Expected 561.6, actual 602 (1.072x) (^ 4) +Testing all collisions (high 19..37 bits) - Worst is 32 bits: 607/562 (1.081x) (^ 1) +Testing all collisions (low 19..37 bits) - Worst is 32 bits: 602/562 (1.072x) (^ 0) +Testing distribution (any 8..18 bits) - Worst bias is 9 bits at bit 21: 0.900x (^ 2) + +Keyset 'SeedBlockLen' - 12-byte keys with block at offsets [0..8, by 4s] - 3294720 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 35-bit) - Expected 158.0, actual 146 (0.924x) (^ 0) +Testing all collisions (low 35-bit) - Expected 158.0, actual 143 (0.905x) (^ 0) +Testing all collisions (high 32-bit) - Expected 1263.4, actual 1241 (0.982x) (^ 0) +Testing all collisions (low 32-bit) - Expected 1263.4, actual 1276 (1.010x) (^ 1) +Testing all collisions (high 20..38 bits) - Worst is 27 bits: 40311/40110 (1.005x) (^ 0) +Testing all collisions (low 20..38 bits) - Worst is 24 bits: 303703/303333 (1.001x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 10 bits at bit 133: 0.933x (^ 4) + +Keyset 'SeedBlockLen' - 13-byte keys with block at offsets [0..8, by 4s] - 3294720 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 35-bit) - Expected 158.0, actual 172 (1.089x) (^ 2) +Testing all collisions (low 35-bit) - Expected 158.0, actual 148 (0.937x) (^ 0) +Testing all collisions (high 32-bit) - Expected 1263.4, actual 1229 (0.973x) (^ 0) +Testing all collisions (low 32-bit) - Expected 1263.4, actual 1291 (1.022x) (^ 2) +Testing all collisions (high 20..38 bits) - Worst is 35 bits: 172/158 (1.089x) (^ 0) +Testing all collisions (low 20..38 bits) - Worst is 26 bits: 80072/79570 (1.006x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 14 bits at bit 96: 0.648x (^ 0) + +Keyset 'SeedBlockLen' - 14-byte keys with block at offsets [0..8, by 4s] - 3294720 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 35-bit) - Expected 158.0, actual 141 (0.893x) (^ 0) +Testing all collisions (low 35-bit) - Expected 158.0, actual 182 (1.152x) (^ 4) +Testing all collisions (high 32-bit) - Expected 1263.4, actual 1242 (0.983x) (^ 0) +Testing all collisions (low 32-bit) - Expected 1263.4, actual 1323 (1.047x) (^ 4) +Testing all collisions (high 20..38 bits) - Worst is 20 bits: 2291461/2291434 (1.000x) (^ 0) +Testing all collisions (low 20..38 bits) - Worst is 26 bits: 80181/79570 (1.008x) (^ 1) +Testing distribution (any 8..19 bits) - Worst bias is 9 bits at bit 174: 0.960x (^ 3) + +Keyset 'SeedBlockLen' - 15-byte keys with block at offsets [0..8, by 4s] - 3294720 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 35-bit) - Expected 158.0, actual 156 (0.988x) (^ 0) +Testing all collisions (low 35-bit) - Expected 158.0, actual 144 (0.912x) (^ 0) +Testing all collisions (high 32-bit) - Expected 1263.4, actual 1266 (1.002x) (^ 1) +Testing all collisions (low 32-bit) - Expected 1263.4, actual 1263 (1.000x) (^ 0) +Testing all collisions (high 20..38 bits) - Worst is 36 bits: 95/79 (1.203x) (^ 0) +Testing all collisions (low 20..38 bits) - Worst is 21 bits: 1634380/1633415 (1.001x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 18 bits at bit 76: 0.556x (^ 0) + +Keyset 'SeedBlockLen' - 16-byte keys with block at offsets [0..12, by 4s] - 4392960 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 140.4, actual 107 (0.762x) (^ 0) +Testing all collisions (low 36-bit) - Expected 140.4, actual 134 (0.954x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2245.8, actual 2178 (0.970x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2245.8, actual 2229 (0.993x) (^ 0) +Testing all collisions (high 20..39 bits) - Worst is 23 bits: 973474/973224 (1.000x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 39 bits: 25/18 (1.424x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 10 bits at bit 194: 0.696x (^ 0) + +Keyset 'SeedBlockLen' - 17-byte keys with block at offsets [0..12, by 4s] - 4392960 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 140.4, actual 139 (0.990x) (^ 0) +Testing all collisions (low 36-bit) - Expected 140.4, actual 143 (1.018x) (^ 1) +Testing all collisions (high 32-bit) - Expected 2245.8, actual 2171 (0.967x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2245.8, actual 2230 (0.993x) (^ 0) +Testing all collisions (high 20..39 bits) - Worst is 27 bits: 71484/71113 (1.005x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 37 bits: 80/70 (1.140x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 14 bits at bit 251: 0.592x (^ 0) + +Keyset 'SeedBlockLen' - 18-byte keys with block at offsets [0..12, by 4s] - 4392960 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 140.4, actual 157 (1.118x) (^ 3) +Testing all collisions (low 36-bit) - Expected 140.4, actual 164 (1.168x) (^ 5) +Testing all collisions (high 32-bit) - Expected 2245.8, actual 2284 (1.017x) (^ 2) +Testing all collisions (low 32-bit) - Expected 2245.8, actual 2235 (0.995x) (^ 0) +Testing all collisions (high 20..39 bits) - Worst is 35 bits: 312/281 (1.111x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 38 bits: 54/35 (1.538x) (^ 4) +Testing distribution (any 8..19 bits) - Worst bias is 10 bits at bit 95: 0.936x (^ 4) + +Keyset 'SeedBlockLen' - 19-byte keys with block at offsets [0..12, by 4s] - 4392960 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 140.4, actual 151 (1.075x) (^ 2) +Testing all collisions (low 36-bit) - Expected 140.4, actual 134 (0.954x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2245.8, actual 2242 (0.998x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2245.8, actual 2281 (1.016x) (^ 2) +Testing all collisions (high 20..39 bits) - Worst is 39 bits: 24/18 (1.367x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 31 bits: 4547/4490 (1.013x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 16 bits at bit 193: 0.634x (^ 1) + +Keyset 'SeedBlockLen' - 20-byte keys with block at offsets [0..16, by 4s] - 5491200 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 37-bit) - Expected 109.7, actual 97 (0.884x) (^ 0) +Testing all collisions (low 37-bit) - Expected 109.7, actual 84 (0.766x) (^ 0) +Testing all collisions (high 32-bit) - Expected 3508.8, actual 3505 (0.999x) (^ 0) +Testing all collisions (low 32-bit) - Expected 3508.8, actual 3503 (0.998x) (^ 0) +Testing all collisions (high 21..40 bits) - Worst is 24 bits: 809227/808120 (1.001x) (^ 0) +Testing all collisions (low 21..40 bits) - Worst is 30 bits: 14148/14017 (1.009x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 12 bits at bit 19: 0.712x (^ 0) + +Keyset 'SeedBlockLen' - 21-byte keys with block at offsets [0..16, by 4s] - 5491200 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 37-bit) - Expected 109.7, actual 111 (1.012x) (^ 1) +Testing all collisions (low 37-bit) - Expected 109.7, actual 96 (0.875x) (^ 0) +Testing all collisions (high 32-bit) - Expected 3508.8, actual 3463 (0.987x) (^ 0) +Testing all collisions (low 32-bit) - Expected 3508.8, actual 3473 (0.990x) (^ 0) +Testing all collisions (high 21..40 bits) - Worst is 30 bits: 14134/14017 (1.008x) (^ 0) +Testing all collisions (low 21..40 bits) - Worst is 25 bits: 426438/425779 (1.002x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 16 bits at bit 240: 0.537x (^ 0) + +Keyset 'SeedBlockLen' - 22-byte keys with block at offsets [0..16, by 4s] - 5491200 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 37-bit) - Expected 109.7, actual 132 (1.203x) (^ 5) +Testing all collisions (low 37-bit) - Expected 109.7, actual 105 (0.957x) (^ 0) +Testing all collisions (high 32-bit) - Expected 3508.8, actual 3509 (1.000x) (^ 1) +Testing all collisions (low 32-bit) - Expected 3508.8, actual 3516 (1.002x) (^ 1) +Testing all collisions (high 21..40 bits) - Worst is 37 bits: 132/110 (1.203x) (^ 1) +Testing all collisions (low 21..40 bits) - Worst is 33 bits: 1785/1755 (1.017x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 9 bits at bit 19: 0.750x (^ 0) + +Keyset 'SeedBlockLen' - 23-byte keys with block at offsets [0..16, by 4s] - 5491200 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 37-bit) - Expected 109.7, actual 103 (0.939x) (^ 0) +Testing all collisions (low 37-bit) - Expected 109.7, actual 97 (0.884x) (^ 0) +Testing all collisions (high 32-bit) - Expected 3508.8, actual 3479 (0.992x) (^ 0) +Testing all collisions (low 32-bit) - Expected 3508.8, actual 3518 (1.003x) (^ 1) +Testing all collisions (high 21..40 bits) - Worst is 29 bits: 28287/27987 (1.011x) (^ 0) +Testing all collisions (low 21..40 bits) - Worst is 27 bits: 111399/110813 (1.005x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 18 bits at bit 131: 0.538x (^ 0) + +Keyset 'SeedBlockLen' - 24-byte keys with block at offsets [0..20, by 4s] - 6589440 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 37-bit) - Expected 158.0, actual 174 (1.102x) (^ 3) +Testing all collisions (low 37-bit) - Expected 158.0, actual 143 (0.905x) (^ 0) +Testing all collisions (high 32-bit) - Expected 5052.3, actual 5034 (0.996x) (^ 0) +Testing all collisions (low 32-bit) - Expected 5052.3, actual 5072 (1.004x) (^ 1) +Testing all collisions (high 21..40 bits) - Worst is 36 bits: 351/316 (1.111x) (^ 1) +Testing all collisions (low 21..40 bits) - Worst is 27 bits: 159694/159140 (1.003x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 18 bits at bit 247: 0.573x (^ 0) + +Keyset 'SeedBlockLen' - 25-byte keys with block at offsets [0..20, by 4s] - 6589440 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 37-bit) - Expected 158.0, actual 166 (1.051x) (^ 1) +Testing all collisions (low 37-bit) - Expected 158.0, actual 189 (1.196x) (^ 6) +Testing all collisions (high 32-bit) - Expected 5052.3, actual 5002 (0.990x) (^ 0) +Testing all collisions (low 32-bit) - Expected 5052.3, actual 5011 (0.992x) (^ 0) +Testing all collisions (high 21..40 bits) - Worst is 26 bits: 314410/313176 (1.004x) (^ 2) +Testing all collisions (low 21..40 bits) - Worst is 37 bits: 189/158 (1.196x) (^ 2) +Testing distribution (any 8..20 bits) - Worst bias is 8 bits at bit 138: 0.785x (^ 0) + +Keyset 'SeedBlockLen' - 26-byte keys with block at offsets [0..20, by 4s] - 6589440 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 37-bit) - Expected 158.0, actual 138 (0.874x) (^ 0) +Testing all collisions (low 37-bit) - Expected 158.0, actual 147 (0.931x) (^ 0) +Testing all collisions (high 32-bit) - Expected 5052.3, actual 5087 (1.007x) (^ 1) +Testing all collisions (low 32-bit) - Expected 5052.3, actual 5046 (0.999x) (^ 0) +Testing all collisions (high 21..40 bits) - Worst is 28 bits: 80827/80220 (1.008x) (^ 1) +Testing all collisions (low 21..40 bits) - Worst is 25 bits: 607858/606665 (1.002x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 11 bits at bit 6: 0.728x (^ 0) + +Keyset 'SeedBlockLen' - 27-byte keys with block at offsets [0..20, by 4s] - 6589440 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 37-bit) - Expected 158.0, actual 179 (1.133x) (^ 4) +Testing all collisions (low 37-bit) - Expected 158.0, actual 135 (0.855x) (^ 0) +Testing all collisions (high 32-bit) - Expected 5052.3, actual 5021 (0.994x) (^ 0) +Testing all collisions (low 32-bit) - Expected 5052.3, actual 5028 (0.995x) (^ 0) +Testing all collisions (high 21..40 bits) - Worst is 39 bits: 53/39 (1.342x) (^ 1) +Testing all collisions (low 21..40 bits) - Worst is 24 bits: 1141202/1140031 (1.001x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 13 bits at bit 100: 0.619x (^ 0) + +Keyset 'SeedBlockLen' - 28-byte keys with block at offsets [0..24, by 4s] - 7687680 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 107.5, actual 110 (1.023x) (^ 1) +Testing all collisions (low 38-bit) - Expected 107.5, actual 121 (1.126x) (^ 3) +Testing all collisions (high 32-bit) - Expected 6876.1, actual 6885 (1.001x) (^ 1) +Testing all collisions (low 32-bit) - Expected 6876.1, actual 6874 (1.000x) (^ 0) +Testing all collisions (high 21..41 bits) - Worst is 30 bits: 27626/27455 (1.006x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 39 bits: 72/54 (1.340x) (^ 2) +Testing distribution (any 8..20 bits) - Worst bias is 18 bits at bit 207: 0.572x (^ 0) + +Keyset 'SeedBlockLen' - 29-byte keys with block at offsets [0..24, by 4s] - 7687680 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 107.5, actual 100 (0.930x) (^ 0) +Testing all collisions (low 38-bit) - Expected 107.5, actual 123 (1.144x) (^ 3) +Testing all collisions (high 32-bit) - Expected 6876.1, actual 6826 (0.993x) (^ 0) +Testing all collisions (low 32-bit) - Expected 6876.1, actual 6930 (1.008x) (^ 1) +Testing all collisions (high 21..41 bits) - Worst is 30 bits: 27762/27455 (1.011x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 29 bits: 55209/54780 (1.008x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 16 bits at bit 57: 0.552x (^ 0) + +Keyset 'SeedBlockLen' - 30-byte keys with block at offsets [0..24, by 4s] - 7687680 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 107.5, actual 108 (1.000x) (^ 1) +Testing all collisions (low 38-bit) - Expected 107.5, actual 112 (1.042x) (^ 1) +Testing all collisions (high 32-bit) - Expected 6876.1, actual 6919 (1.006x) (^ 1) +Testing all collisions (low 32-bit) - Expected 6876.1, actual 6677 (0.971x) (^ 0) +Testing all collisions (high 21..41 bits) - Worst is 30 bits: 27592/27455 (1.005x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 38 bits: 112/108 (1.042x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 18 bits at bit 236: 0.450x (^ 0) + +Keyset 'SeedBlockLen' - 31-byte keys with block at offsets [0..24, by 4s] - 7687680 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 107.5, actual 130 (1.209x) (^ 5) +Testing all collisions (low 38-bit) - Expected 107.5, actual 113 (1.051x) (^ 1) +Testing all collisions (high 32-bit) - Expected 6876.1, actual 6954 (1.011x) (^ 2) +Testing all collisions (low 32-bit) - Expected 6876.1, actual 6881 (1.001x) (^ 1) +Testing all collisions (high 21..41 bits) - Worst is 31 bits: 14029/13744 (1.021x) (^ 2) +Testing all collisions (low 21..41 bits) - Worst is 33 bits: 3513/3439 (1.021x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 15 bits at bit 189: 0.617x (^ 0) + +Keyset 'SeedBlockLen' - 32-byte keys with block at offsets [0..28, by 4s] - 8785920 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 140.4, actual 131 (0.933x) (^ 0) +Testing all collisions (low 38-bit) - Expected 140.4, actual 137 (0.976x) (^ 0) +Testing all collisions (high 32-bit) - Expected 8980.3, actual 8997 (1.002x) (^ 1) +Testing all collisions (low 32-bit) - Expected 8980.3, actual 8850 (0.985x) (^ 0) +Testing all collisions (high 21..41 bits) - Worst is 26 bits: 552217/550830 (1.003x) (^ 1) +Testing all collisions (low 21..41 bits) - Worst is 23 bits: 3341028/3340553 (1.000x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 18 bits at bit 240: 0.585x (^ 0) + +Keyset 'SeedBlockLen' - 33-byte keys with block at offsets [0..28, by 4s] - 8785920 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 140.4, actual 137 (0.976x) (^ 0) +Testing all collisions (low 38-bit) - Expected 140.4, actual 143 (1.018x) (^ 1) +Testing all collisions (high 32-bit) - Expected 8980.3, actual 9039 (1.007x) (^ 1) +Testing all collisions (low 32-bit) - Expected 8980.3, actual 9131 (1.017x) (^ 4) +Testing all collisions (high 21..41 bits) - Worst is 34 bits: 2298/2246 (1.023x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 36 bits: 609/562 (1.084x) (^ 1) +Testing distribution (any 8..20 bits) - Worst bias is 20 bits at bit 193: 0.498x (^ 0) + +Keyset 'SeedBlockLen' - 34-byte keys with block at offsets [0..28, by 4s] - 8785920 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 140.4, actual 128 (0.912x) (^ 0) +Testing all collisions (low 38-bit) - Expected 140.4, actual 159 (1.132x) (^ 3) +Testing all collisions (high 32-bit) - Expected 8980.3, actual 9033 (1.006x) (^ 1) +Testing all collisions (low 32-bit) - Expected 8980.3, actual 9054 (1.008x) (^ 2) +Testing all collisions (high 21..41 bits) - Worst is 29 bits: 71795/71500 (1.004x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 37 bits: 320/281 (1.140x) (^ 2) +Testing distribution (any 8..20 bits) - Worst bias is 9 bits at bit 11: 0.783x (^ 0) + +Keyset 'SeedBlockLen' - 35-byte keys with block at offsets [0..28, by 4s] - 8785920 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 140.4, actual 124 (0.883x) (^ 0) +Testing all collisions (low 38-bit) - Expected 140.4, actual 137 (0.976x) (^ 0) +Testing all collisions (high 32-bit) - Expected 8980.3, actual 8944 (0.996x) (^ 0) +Testing all collisions (low 32-bit) - Expected 8980.3, actual 9173 (1.021x) (^ 5) +Testing all collisions (high 21..41 bits) - Worst is 34 bits: 2265/2246 (1.008x) (^ 0) +Testing all collisions (low 21..41 bits) - Worst is 32 bits: 9173/8980 (1.021x) (^ 1) +Testing distribution (any 8..20 bits) - Worst bias is 11 bits at bit 250: 0.655x (^ 0) + +Keyset 'SeedBlockLen' - 36-byte keys with block at offsets [0..32, by 4s] - 9884160 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 177.7, actual 157 (0.883x) (^ 0) +Testing all collisions (low 38-bit) - Expected 177.7, actual 197 (1.109x) (^ 3) +Testing all collisions (high 32-bit) - Expected 11364.7, actual 11293 (0.994x) (^ 0) +Testing all collisions (low 32-bit) - Expected 11364.7, actual 11277 (0.992x) (^ 0) +Testing all collisions (high 21..42 bits) - Worst is 23 bits: 4078672/4077621 (1.000x) (^ 0) +Testing all collisions (low 21..42 bits) - Worst is 37 bits: 400/355 (1.125x) (^ 2) +Testing distribution (any 8..20 bits) - Worst bias is 11 bits at bit 238: 0.686x (^ 0) + +Keyset 'SeedBlockLen' - 37-byte keys with block at offsets [0..32, by 4s] - 9884160 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 177.7, actual 175 (0.985x) (^ 0) +Testing all collisions (low 38-bit) - Expected 177.7, actual 157 (0.883x) (^ 0) +Testing all collisions (high 32-bit) - Expected 11364.7, actual 11479 (1.010x) (^ 2) +Testing all collisions (low 32-bit) - Expected 11364.7, actual 11291 (0.994x) (^ 0) +Testing all collisions (high 21..42 bits) - Worst is 30 bits: 45603/45354 (1.005x) (^ 0) +Testing all collisions (low 21..42 bits) - Worst is 23 bits: 4078224/4077621 (1.000x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 9 bits at bit 26: 0.918x (^ 2) + +Keyset 'SeedBlockLen' - 38-byte keys with block at offsets [0..32, by 4s] - 9884160 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 177.7, actual 169 (0.951x) (^ 0) +Testing all collisions (low 38-bit) - Expected 177.7, actual 191 (1.075x) (^ 2) +Testing all collisions (high 32-bit) - Expected 11364.7, actual 11457 (1.008x) (^ 2) +Testing all collisions (low 32-bit) - Expected 11364.7, actual 11443 (1.007x) (^ 2) +Testing all collisions (high 21..42 bits) - Worst is 31 bits: 22858/22712 (1.006x) (^ 0) +Testing all collisions (low 21..42 bits) - Worst is 42 bits: 21/11 (1.891x) (^ 3) +Testing distribution (any 8..20 bits) - Worst bias is 11 bits at bit 206: 0.650x (^ 0) + +Keyset 'SeedBlockLen' - 39-byte keys with block at offsets [0..32, by 4s] - 9884160 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 38-bit) - Expected 177.7, actual 185 (1.041x) (^ 1) +Testing all collisions (low 38-bit) - Expected 177.7, actual 169 (0.951x) (^ 0) +Testing all collisions (high 32-bit) - Expected 11364.7, actual 11374 (1.001x) (^ 1) +Testing all collisions (low 32-bit) - Expected 11364.7, actual 11307 (0.995x) (^ 0) +Testing all collisions (high 21..42 bits) - Worst is 25 bits: 1324880/1322784 (1.002x) (^ 0) +Testing all collisions (low 21..42 bits) - Worst is 29 bits: 90653/90431 (1.002x) (^ 0) +Testing distribution (any 8..20 bits) - Worst bias is 8 bits at bit 195: 0.867x (^ 0) + + +[[[ Seed BlockOffset Tests ]]] + +Seeds have up to 2 bits set, 4-byte blocks have up to 2 bits set + +Keyset 'SeedBlockOffset' - [4..31]-byte keys with block at offset 0 - 30750720 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 42-bit) - Expected 107.5, actual 108 (1.000x) (^ 1) +Testing all collisions (low 42-bit) - Expected 107.5, actual 96 (0.893x) (^ 0) +Testing all collisions (high 32-bit) - Expected 109820.9, actual 109786 (1.000x) (^ 0) +Testing all collisions (low 32-bit) - Expected 109820.9, actual 109573 (0.998x) (^ 0) +Testing all collisions (high 23..45 bits) - Worst is 25 bits: 10618117/10616019 (1.000x) (^ 0) +Testing all collisions (low 23..45 bits) - Worst is 39 bits: 882/860 (1.026x) (^ 0) +Testing distribution (any 8..22 bits) - Worst bias is 12 bits at bit 242: 0.743x (^ 1) + +Keyset 'SeedBlockOffset' - [5..31]-byte keys with block at offset 1 - 29652480 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 41-bit) - Expected 199.9, actual 204 (1.020x) (^ 1) +Testing all collisions (low 41-bit) - Expected 199.9, actual 214 (1.070x) (^ 2) +Testing all collisions (high 32-bit) - Expected 102125.3, actual 102215 (1.001x) (^ 1) +Testing all collisions (low 32-bit) - Expected 102125.3, actual 102365 (1.002x) (^ 2) +Testing all collisions (high 23..45 bits) - Worst is 40 bits: 418/400 (1.045x) (^ 0) +Testing all collisions (low 23..45 bits) - Worst is 42 bits: 115/100 (1.150x) (^ 0) +Testing distribution (any 8..22 bits) - Worst bias is 11 bits at bit 209: 0.733x (^ 0) + +Keyset 'SeedBlockOffset' - [6..31]-byte keys with block at offset 2 - 28554240 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 41-bit) - Expected 185.4, actual 199 (1.073x) (^ 2) +Testing all collisions (low 41-bit) - Expected 185.4, actual 212 (1.144x) (^ 5) +Testing all collisions (high 32-bit) - Expected 94708.6, actual 94637 (0.999x) (^ 0) +Testing all collisions (low 32-bit) - Expected 94708.6, actual 95001 (1.003x) (^ 2) +Testing all collisions (high 23..45 bits) - Worst is 45 bits: 20/12 (1.726x) (^ 1) +Testing all collisions (low 23..45 bits) - Worst is 33 bits: 48037/47407 (1.013x) (^ 4) +Testing distribution (any 8..22 bits) - Worst bias is 11 bits at bit 17: 0.909x (^ 4) + +Keyset 'SeedBlockOffset' - [7..31]-byte keys with block at offset 3 - 27456000 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 41-bit) - Expected 171.4, actual 169 (0.986x) (^ 0) +Testing all collisions (low 41-bit) - Expected 171.4, actual 158 (0.922x) (^ 0) +Testing all collisions (high 32-bit) - Expected 87570.9, actual 86675 (0.990x) (^ 0) +Testing all collisions (low 32-bit) - Expected 87570.9, actual 87313 (0.997x) (^ 0) +Testing all collisions (high 23..45 bits) - Worst is 39 bits: 716/686 (1.044x) (^ 0) +Testing all collisions (low 23..45 bits) - Worst is 26 bits: 4926384/4922880 (1.001x) (^ 0) +Testing distribution (any 8..22 bits) - Worst bias is 10 bits at bit 224: 0.952x (^ 4) + +Keyset 'SeedBlockOffset' - [8..31]-byte keys with block at offset 4 - 26357760 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 41-bit) - Expected 158.0, actual 148 (0.937x) (^ 0) +Testing all collisions (low 41-bit) - Expected 158.0, actual 124 (0.785x) (^ 0) +Testing all collisions (high 32-bit) - Expected 80712.2, actual 80351 (0.996x) (^ 0) +Testing all collisions (low 32-bit) - Expected 80712.2, actual 81105 (1.005x) (^ 3) +Testing all collisions (high 23..44 bits) - Worst is 26 bits: 4564251/4560126 (1.001x) (^ 1) +Testing all collisions (low 23..44 bits) - Worst is 31 bits: 161707/161095 (1.004x) (^ 0) +Testing distribution (any 8..22 bits) - Worst bias is 10 bits at bit 234: 0.845x (^ 1) + +Keyset 'SeedBlockOffset' - [9..31]-byte keys with block at offset 5 - 25259520 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 41-bit) - Expected 145.1, actual 136 (0.937x) (^ 0) +Testing all collisions (low 41-bit) - Expected 145.1, actual 142 (0.979x) (^ 0) +Testing all collisions (high 32-bit) - Expected 74132.6, actual 73890 (0.997x) (^ 0) +Testing all collisions (low 32-bit) - Expected 74132.6, actual 74790 (1.009x) (^ 6) +Testing all collisions (high 23..44 bits) - Worst is 35 bits: 9374/9282 (1.010x) (^ 0) +Testing all collisions (low 23..44 bits) - Worst is 31 bits: 148934/147975 (1.006x) (^ 2) +Testing distribution (any 8..22 bits) - Worst bias is 11 bits at bit 13: 0.686x (^ 0) + +Keyset 'SeedBlockOffset' - [10..31]-byte keys with block at offset 6 - 24161280 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 41-bit) - Expected 132.7, actual 138 (1.040x) (^ 1) +Testing all collisions (low 41-bit) - Expected 132.7, actual 143 (1.077x) (^ 2) +Testing all collisions (high 32-bit) - Expected 67832.2, actual 67484 (0.995x) (^ 0) +Testing all collisions (low 32-bit) - Expected 67832.2, actual 68119 (1.004x) (^ 2) +Testing all collisions (high 23..44 bits) - Worst is 42 bits: 77/66 (1.160x) (^ 0) +Testing all collisions (low 23..44 bits) - Worst is 35 bits: 8645/8493 (1.018x) (^ 0) +Testing distribution (any 8..22 bits) - Worst bias is 10 bits at bit 236: 0.808x (^ 1) + +Keyset 'SeedBlockOffset' - [11..31]-byte keys with block at offset 7 - 23063040 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 41-bit) - Expected 120.9, actual 105 (0.868x) (^ 0) +Testing all collisions (low 41-bit) - Expected 120.9, actual 121 (1.000x) (^ 1) +Testing all collisions (high 32-bit) - Expected 61811.1, actual 61638 (0.997x) (^ 0) +Testing all collisions (low 32-bit) - Expected 61811.1, actual 62105 (1.005x) (^ 3) +Testing all collisions (high 23..44 bits) - Worst is 35 bits: 7812/7738 (1.009x) (^ 0) +Testing all collisions (low 23..44 bits) - Worst is 35 bits: 7865/7738 (1.016x) (^ 0) +Testing distribution (any 8..22 bits) - Worst bias is 15 bits at bit 154: 0.691x (^ 1) + +Keyset 'SeedBlockOffset' - [12..31]-byte keys with block at offset 8 - 21964800 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 41-bit) - Expected 109.7, actual 108 (0.985x) (^ 0) +Testing all collisions (low 41-bit) - Expected 109.7, actual 111 (1.012x) (^ 1) +Testing all collisions (high 32-bit) - Expected 56069.2, actual 56028 (0.999x) (^ 0) +Testing all collisions (low 32-bit) - Expected 56069.2, actual 56096 (1.000x) (^ 1) +Testing all collisions (high 23..44 bits) - Worst is 44 bits: 19/14 (1.386x) (^ 0) +Testing all collisions (low 23..44 bits) - Worst is 36 bits: 3590/3510 (1.023x) (^ 0) +Testing distribution (any 8..22 bits) - Worst bias is 14 bits at bit 60: 0.721x (^ 2) + +Keyset 'SeedBlockOffset' - [13..31]-byte keys with block at offset 9 - 20866560 hashes +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 40-bit) - Expected 198.0, actual 215 (1.086x) (^ 3) +Testing all collisions (low 40-bit) - Expected 198.0, actual 227 (1.146x) (^ 5) +Testing all collisions (high 32-bit) - Expected 50606.8, actual 50716 (1.002x) (^ 1) +Testing all collisions (low 32-bit) - Expected 50606.8, actual 50400 (0.996x) (^ 0) +Testing all collisions (high 22..44 bits) - Worst is 34 bits: 12940/12667 (1.022x) (^ 2) +Testing all collisions (low 22..44 bits) - Worst is 40 bits: 227/198 (1.146x) (^ 1) +Testing distribution (any 8..21 bits) - Worst bias is 10 bits at bit 101: 0.775x (^ 0) + + +[[[ Keyset 'Seed' Tests ]]] + +Keyset 'Seed' - 2-byte keys - 4194304 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 100 (0.781x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 127 (0.992x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 1985 (0.970x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2117 (1.034x) (^ 3) +Testing all collisions (high 20..39 bits) - Worst is 22 bits: 1543975/1542998 (1.001x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 32 bits: 2117/2047 (1.034x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 10 bits at bit 208: 0.716x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 123 (0.961x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 125 (0.977x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 1975 (0.965x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2003 (0.978x) (^ 0) +Testing all collisions (high 20..39 bits) - Worst is 28 bits: 32769/32598 (1.005x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 34 bits: 520/512 (1.016x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 18 bits at bit 96: 0.509x (^ 0) +---Analyzing additional differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 109 (0.852x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 132 (1.031x) (^ 1) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 1978 (0.966x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 1958 (0.956x) (^ 0) +Testing all collisions (high 20..39 bits) - Worst is 28 bits: 32805/32598 (1.006x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 29 bits: 16442/16341 (1.006x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 18 bits at bit 64: 0.512x (^ 0) + +Keyset 'Seed' - 3-byte keys - 4194304 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 130 (1.016x) (^ 1) +Testing all collisions (low 36-bit) - Expected 128.0, actual 138 (1.078x) (^ 2) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2040 (0.996x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2043 (0.998x) (^ 0) +Testing all collisions (high 20..39 bits) - Worst is 31 bits: 4155/4093 (1.015x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 37 bits: 74/64 (1.156x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 8 bits at bit 87: 0.936x (^ 2) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 127 (0.992x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 144 (1.125x) (^ 3) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2079 (1.015x) (^ 2) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2066 (1.009x) (^ 1) +Testing all collisions (high 20..39 bits) - Worst is 25 bits: 252212/251554 (1.003x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 34 bits: 556/512 (1.086x) (^ 1) +Testing distribution (any 8..19 bits) - Worst bias is 19 bits at bit 201: 0.632x (^ 2) +---Analyzing additional differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 120 (0.938x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 129 (1.008x) (^ 1) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 1985 (0.970x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2105 (1.028x) (^ 3) +Testing all collisions (high 20..39 bits) - Worst is 29 bits: 16431/16341 (1.005x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 32 bits: 2105/2047 (1.028x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 12 bits at bit 156: 0.639x (^ 0) + +Keyset 'Seed' - 6-byte keys - 4194304 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 132 (1.031x) (^ 1) +Testing all collisions (low 36-bit) - Expected 128.0, actual 121 (0.945x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2055 (1.004x) (^ 1) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2075 (1.014x) (^ 1) +Testing all collisions (high 20..39 bits) - Worst is 29 bits: 16592/16341 (1.015x) (^ 1) +Testing all collisions (low 20..39 bits) - Worst is 25 bits: 252182/251554 (1.002x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 16 bits at bit 176: 0.563x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 149 (1.164x) (^ 4) +Testing all collisions (low 36-bit) - Expected 128.0, actual 128 (1.000x) (^ 1) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2068 (1.010x) (^ 1) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2067 (1.010x) (^ 1) +Testing all collisions (high 20..39 bits) - Worst is 36 bits: 149/128 (1.164x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 30 bits: 8348/8181 (1.020x) (^ 1) +Testing distribution (any 8..19 bits) - Worst bias is 12 bits at bit 253: 0.624x (^ 0) +---Analyzing additional differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 121 (0.945x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 138 (1.078x) (^ 2) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2060 (1.006x) (^ 1) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2048 (1.000x) (^ 1) +Testing all collisions (high 20..39 bits) - Worst is 32 bits: 2060/2047 (1.006x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 34 bits: 549/512 (1.072x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 8 bits at bit 20: 0.974x (^ 2) + +Keyset 'Seed' - 15-byte keys - 4194304 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 142 (1.109x) (^ 3) +Testing all collisions (low 36-bit) - Expected 128.0, actual 100 (0.781x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2089 (1.020x) (^ 2) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2086 (1.019x) (^ 2) +Testing all collisions (high 20..39 bits) - Worst is 37 bits: 79/64 (1.234x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 23 bits: 894585/893644 (1.001x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 19 bits at bit 92: 0.531x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 134 (1.047x) (^ 1) +Testing all collisions (low 36-bit) - Expected 128.0, actual 134 (1.047x) (^ 1) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 1965 (0.960x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2082 (1.017x) (^ 2) +Testing all collisions (high 20..39 bits) - Worst is 36 bits: 134/128 (1.047x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 37 bits: 76/64 (1.188x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 10 bits at bit 11: 0.826x (^ 1) +---Analyzing additional differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 126 (0.984x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 131 (1.023x) (^ 1) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2086 (1.019x) (^ 2) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2007 (0.980x) (^ 0) +Testing all collisions (high 20..39 bits) - Worst is 33 bits: 1071/1024 (1.046x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 39 bits: 20/16 (1.250x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 16 bits at bit 165: 0.713x (^ 3) + +Keyset 'Seed' - 18-byte keys - 4194304 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 127 (0.992x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 120 (0.938x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2045 (0.999x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2037 (0.995x) (^ 0) +Testing all collisions (high 20..39 bits) - Worst is 20 bits: 3164953/3164933 (1.000x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 30 bits: 8365/8181 (1.022x) (^ 1) +Testing distribution (any 8..19 bits) - Worst bias is 17 bits at bit 47: 0.716x (^ 4) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 141 (1.102x) (^ 2) +Testing all collisions (low 36-bit) - Expected 128.0, actual 141 (1.102x) (^ 2) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 1985 (0.970x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2111 (1.031x) (^ 3) +Testing all collisions (high 20..39 bits) - Worst is 37 bits: 81/64 (1.266x) (^ 1) +Testing all collisions (low 20..39 bits) - Worst is 29 bits: 16586/16341 (1.015x) (^ 1) +Testing distribution (any 8..19 bits) - Worst bias is 12 bits at bit 101: 0.744x (^ 1) +---Analyzing additional differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 114 (0.891x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 133 (1.039x) (^ 1) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2028 (0.991x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2077 (1.014x) (^ 1) +Testing all collisions (high 20..39 bits) - Worst is 25 bits: 252151/251554 (1.002x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 28 bits: 32717/32598 (1.004x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 9 bits at bit 117: 0.801x (^ 0) + +Keyset 'Seed' - 31-byte keys - 4194304 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 120 (0.938x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 116 (0.906x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2074 (1.013x) (^ 1) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 1985 (0.970x) (^ 0) +Testing all collisions (high 20..39 bits) - Worst is 28 bits: 32824/32598 (1.007x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 22 bits: 1544315/1542998 (1.001x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 10 bits at bit 121: 0.780x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 114 (0.891x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 119 (0.930x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 1968 (0.961x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2031 (0.992x) (^ 0) +Testing all collisions (high 20..39 bits) - Worst is 22 bits: 1544069/1542998 (1.001x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 27 bits: 65146/64859 (1.004x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 17 bits at bit 27: 0.607x (^ 1) +---Analyzing additional differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 117 (0.914x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 126 (0.984x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2018 (0.986x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2100 (1.026x) (^ 2) +Testing all collisions (high 20..39 bits) - Worst is 23 bits: 894372/893644 (1.001x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 32 bits: 2100/2047 (1.026x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 14 bits at bit 216: 0.611x (^ 0) + +Keyset 'Seed' - 52-byte keys - 4194304 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 117 (0.914x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 129 (1.008x) (^ 1) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2011 (0.982x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2067 (1.010x) (^ 1) +Testing all collisions (high 20..39 bits) - Worst is 23 bits: 894989/893644 (1.002x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 24 bits: 484278/483197 (1.002x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 8 bits at bit 215: 0.851x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 122 (0.953x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 120 (0.938x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2072 (1.012x) (^ 1) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2020 (0.987x) (^ 0) +Testing all collisions (high 20..39 bits) - Worst is 26 bits: 129063/128383 (1.005x) (^ 1) +Testing all collisions (low 20..39 bits) - Worst is 29 bits: 16510/16341 (1.010x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 17 bits at bit 31: 0.496x (^ 0) +---Analyzing additional differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 118 (0.922x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 118 (0.922x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2037 (0.995x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2024 (0.989x) (^ 0) +Testing all collisions (high 20..39 bits) - Worst is 28 bits: 32949/32598 (1.011x) (^ 1) +Testing all collisions (low 20..39 bits) - Worst is 22 bits: 1543376/1542998 (1.000x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 15 bits at bit 39: 0.628x (^ 0) + +Keyset 'Seed' - 80-byte keys - 4194304 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 130 (1.016x) (^ 1) +Testing all collisions (low 36-bit) - Expected 128.0, actual 123 (0.961x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2049 (1.001x) (^ 1) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2061 (1.007x) (^ 1) +Testing all collisions (high 20..39 bits) - Worst is 33 bits: 1075/1024 (1.050x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 31 bits: 4147/4093 (1.013x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 9 bits at bit 184: 1.121x (^ 8) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 100 (0.781x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 136 (1.063x) (^ 1) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2073 (1.013x) (^ 1) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2068 (1.010x) (^ 1) +Testing all collisions (high 20..39 bits) - Worst is 24 bits: 484385/483197 (1.002x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 27 bits: 65252/64859 (1.006x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 12 bits at bit 9: 0.658x (^ 0) +---Analyzing additional differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 111 (0.867x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 157 (1.227x) (^ 7) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2112 (1.032x) (^ 3) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2033 (0.993x) (^ 0) +Testing all collisions (high 20..39 bits) - Worst is 32 bits: 2112/2047 (1.032x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 36 bits: 157/128 (1.227x) (^ 2) +Testing distribution (any 8..19 bits) - Worst bias is 12 bits at bit 141: 0.872x (^ 5) + +Keyset 'Seed' - 200-byte keys - 4194304 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 131 (1.023x) (^ 1) +Testing all collisions (low 36-bit) - Expected 128.0, actual 125 (0.977x) (^ 0) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2054 (1.003x) (^ 1) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2124 (1.037x) (^ 4) +Testing all collisions (high 20..39 bits) - Worst is 25 bits: 252247/251554 (1.003x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 32 bits: 2124/2047 (1.037x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 14 bits at bit 249: 0.691x (^ 1) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 137 (1.070x) (^ 2) +Testing all collisions (low 36-bit) - Expected 128.0, actual 136 (1.063x) (^ 1) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2096 (1.024x) (^ 2) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2081 (1.016x) (^ 2) +Testing all collisions (high 20..39 bits) - Worst is 25 bits: 252460/251554 (1.004x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 30 bits: 8295/8181 (1.014x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 11 bits at bit 81: 0.763x (^ 1) +---Analyzing additional differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 139 (1.086x) (^ 2) +Testing all collisions (low 36-bit) - Expected 128.0, actual 134 (1.047x) (^ 1) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2002 (0.978x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2054 (1.003x) (^ 1) +Testing all collisions (high 20..39 bits) - Worst is 24 bits: 484493/483197 (1.003x) (^ 1) +Testing all collisions (low 20..39 bits) - Worst is 28 bits: 32903/32598 (1.009x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 18 bits at bit 120: 0.567x (^ 0) + +Keyset 'Seed' - 1025-byte keys - 4194304 seeds +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 117 (0.914x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 137 (1.070x) (^ 2) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2076 (1.014x) (^ 1) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2090 (1.021x) (^ 2) +Testing all collisions (high 20..39 bits) - Worst is 32 bits: 2076/2047 (1.014x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 35 bits: 285/256 (1.113x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 8 bits at bit 40: 0.790x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 103 (0.805x) (^ 0) +Testing all collisions (low 36-bit) - Expected 128.0, actual 138 (1.078x) (^ 2) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 1985 (0.970x) (^ 0) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2085 (1.018x) (^ 2) +Testing all collisions (high 20..39 bits) - Worst is 28 bits: 32999/32598 (1.012x) (^ 2) +Testing all collisions (low 20..39 bits) - Worst is 35 bits: 270/256 (1.055x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 18 bits at bit 225: 0.493x (^ 0) +---Analyzing additional differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 36-bit) - Expected 128.0, actual 135 (1.055x) (^ 1) +Testing all collisions (low 36-bit) - Expected 128.0, actual 135 (1.055x) (^ 1) +Testing all collisions (high 32-bit) - Expected 2047.3, actual 2052 (1.002x) (^ 1) +Testing all collisions (low 32-bit) - Expected 2047.3, actual 2050 (1.001x) (^ 1) +Testing all collisions (high 20..39 bits) - Worst is 34 bits: 538/512 (1.051x) (^ 0) +Testing all collisions (low 20..39 bits) - Worst is 36 bits: 135/128 (1.055x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 9 bits at bit 229: 0.893x (^ 2) + + +[[[ Seed Avalanche Tests ]]] + +Testing 3-byte keys, 300000 reps..................max is 0.769% at bit 1 -> out 22 (^ 1) +Testing 4-byte keys, 300000 reps..................max is 0.653% at bit 22 -> out 3 (^ 0) +Testing 6-byte keys, 300000 reps..................max is 0.824% at bit 49 -> out 214 (^ 3) +Testing 8-byte keys, 300000 reps..................max is 0.717% at bit 9 -> out 21 (^ 0) +Testing 12-byte keys, 300000 reps..................max is 0.687% at bit 33 -> out 210 (^ 0) +Testing 16-byte keys, 300000 reps..................max is 0.707% at bit 39 -> out 63 (^ 0) +Testing 20-byte keys, 300000 reps..................max is 0.699% at bit 21 -> out 213 (^ 0) +Testing 24-byte keys, 300000 reps..................max is 0.669% at bit 20 -> out 152 (^ 0) +Testing 28-byte keys, 300000 reps..................max is 0.743% at bit 16 -> out 205 (^ 0) +Testing 32-byte keys, 300000 reps..................max is 0.723% at bit 54 -> out 213 (^ 0) +Testing 64-byte keys, 300000 reps..................max is 0.793% at bit 39 -> out 253 (^ 2) +Testing 128-byte keys, 300000 reps..................max is 0.786% at bit 24 -> out 234 (^ 2) + + +[[[ Seed 'Bit Independence Criteria' Tests ]]] + +Testing 3-byte keys, 200000 reps............max 0.0112 at bit 34 -> out ( 39,198) (^ 0) +Testing 8-byte keys, 200000 reps............max 0.0120 at bit 41 -> out ( 36,154) (^ 2) +Testing 11-byte keys, 200000 reps............max 0.0108 at bit 61 -> out (191,208) (^ 0) +Testing 15-byte keys, 200000 reps............max 0.0108 at bit 7 -> out (188,238) (^ 0) + + +[[[ Seed Bitflip Tests ]]] + +Testing 3-byte keys, 64-bit seeds, 1572864 reps.......... 0 failed, worst is seed bit 1 +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 35-bit) - Expected 144.0, actual 139 (0.965x) (^ 0) +Testing all collisions (low 35-bit) - Expected 144.0, actual 129 (0.896x) (^ 0) +Testing all collisions (high 32-bit) - Expected 1151.7, actual 1118 (0.971x) (^ 0) +Testing all collisions (low 32-bit) - Expected 1151.7, actual 1219 (1.058x) (^ 5) +Testing all collisions (high 20..38 bits) - Worst is 27 bits: 37026/36578 (1.012x) (^ 2) +Testing all collisions (low 20..38 bits) - Worst is 32 bits: 1219/1152 (1.058x) (^ 1) +Testing distribution (any 8..19 bits) - Worst bias is 10 bits at bit 180: 0.845x (^ 2) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 33-bit) - Expected 144.0, actual 154 (1.070x) (^ 2) +Testing all collisions (low 33-bit) - Expected 144.0, actual 171 (1.188x) (^ 5) +Testing all collisions (high 32-bit) - Expected 288.0, actual 299 (1.038x) (^ 1) +Testing all collisions (low 32-bit) - Expected 288.0, actual 333 (1.156x) (^ 7) +Testing all collisions (high 19..36 bits) - Worst is 28 bits: 4664/4599 (1.014x) (^ 0) +Testing all collisions (low 19..36 bits) - Worst is 32 bits: 333/288 (1.156x) (^ 3) +Testing distribution (any 8..18 bits) - Worst bias is 9 bits at bit 178: 0.831x (^ 1) + +Testing 4-byte keys, 64-bit seeds, 1572864 reps.......... 0 failed, worst is seed bit 51 +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 35-bit) - Expected 144.0, actual 138 (0.958x) (^ 0) +Testing all collisions (low 35-bit) - Expected 144.0, actual 159 (1.104x) (^ 3) +Testing all collisions (high 32-bit) - Expected 1151.7, actual 1181 (1.025x) (^ 2) +Testing all collisions (low 32-bit) - Expected 1151.7, actual 1189 (1.032x) (^ 2) +Testing all collisions (high 20..38 bits) - Worst is 30 bits: 4686/4604 (1.018x) (^ 0) +Testing all collisions (low 20..38 bits) - Worst is 33 bits: 623/576 (1.082x) (^ 1) +Testing distribution (any 8..19 bits) - Worst bias is 19 bits at bit 71: 0.530x (^ 0) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 33-bit) - Expected 144.0, actual 182 (1.264x) (^ 9) +Testing all collisions (low 33-bit) - Expected 144.0, actual 172 (1.195x) (^ 6) +Testing all collisions (high 32-bit) - Expected 288.0, actual 328 (1.139x) (^ 6) +Testing all collisions (low 32-bit) - Expected 288.0, actual 317 (1.101x) (^ 4) +Testing all collisions (high 19..36 bits) - Worst is 33 bits: 182/144 (1.264x) (^ 5) +Testing all collisions (low 19..36 bits) - Worst is 34 bits: 93/72 (1.292x) (^ 2) +Testing distribution (any 8..18 bits) - Worst bias is 9 bits at bit 25: 0.805x (^ 0) + +Testing 8-byte keys, 64-bit seeds, 1572864 reps.......... 0 failed, worst is seed bit 12 +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 35-bit) - Expected 144.0, actual 169 (1.174x) (^ 5) +Testing all collisions (low 35-bit) - Expected 144.0, actual 129 (0.896x) (^ 0) +Testing all collisions (high 32-bit) - Expected 1151.7, actual 1263 (1.097x) (^10) +Testing all collisions (low 32-bit) - Expected 1151.7, actual 1168 (1.014x) (^ 1) +Testing all collisions (high 20..38 bits) - Worst is 32 bits: 1263/1152 (1.097x) (^ 6) +Testing all collisions (low 20..38 bits) - Worst is 25 bits: 143545/142954 (1.004x) (^ 0) +Testing distribution (any 8..19 bits) - Worst bias is 8 bits at bit 141: 0.899x (^ 1) +---Analyzing differential distribution +Testing all collisions ( 256-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 224-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 160-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 128-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (low 64-bit) - Expected 0.0, actual 0 (1.000x) (^ 0) +Testing all collisions (high 33-bit) - Expected 144.0, actual 148 (1.028x) (^ 1) +Testing all collisions (low 33-bit) - Expected 144.0, actual 153 (1.063x) (^ 2) +Testing all collisions (high 32-bit) - Expected 288.0, actual 283 (0.983x) (^ 0) +Testing all collisions (low 32-bit) - Expected 288.0, actual 294 (1.021x) (^ 1) +Testing all collisions (high 19..36 bits) - Worst is 30 bits: 1187/1151 (1.031x) (^ 0) +Testing all collisions (low 19..36 bits) - Worst is 24 bits: 71851/71477 (1.005x) (^ 0) +Testing distribution (any 8..18 bits) - Worst bias is 12 bits at bit 44: 0.789x (^ 2) + + +---------------------------------------------------------------------------------------------- +-log2(p-value) summary: + + 0 1 2 3 4 5 6 7 8 9 10 11 12 + ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- + 23058 2705 1156 680 320 157 98 43 18 8 12 1 0 + + 13 14 15 16 17 18 19 20 21 22 23 24 25+ + ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- + 1 0 0 0 0 0 0 0 0 0 0 0 0 + +---------------------------------------------------------------------------------------------- +Summary for: rainstorm-256 +Overall result: pass ( 240 / 240 passed) + +---------------------------------------------------------------------------------------------- +Verification value is 0x00000001 - Testing took 4286.779630 seconds + From 4bd82bedd666ecee17bf9521f9731e17cf684b21 Mon Sep 17 00:00:00 2001 From: DOSAYGO Development Team Date: Mon, 30 Dec 2024 23:23:27 +0800 Subject: [PATCH 05/12] ok --- TODO | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/TODO b/TODO index be0be41..137948a 100644 --- a/TODO +++ b/TODO @@ -1,7 +1,10 @@ cipher improvement -- implement a js version of enc / dec +- add true scatter (P can be in any order). - schedule K into block keys via XOF +- implement a js version of enc / dec +- test research construct + weak hash -- digest mining construction --> block cipher --- davies meyer construction ---> strong hash Later maybe - parallelization for cipher mining efficiency From 5e1b0336f417afc79c39cf55cc43f53d8eba421a Mon Sep 17 00:00:00 2001 From: DOSAYGO Development Team Date: Tue, 31 Dec 2024 12:43:23 +0800 Subject: [PATCH 06/12] Series and scatter mode are now properly implemented --- Makefile | 2 +- src/rainsum.cpp | 128 ++++++++++++++++++++++++++++++++++++------------ 2 files changed, 99 insertions(+), 31 deletions(-) diff --git a/Makefile b/Makefile index 11570d6..bbe30f4 100644 --- a/Makefile +++ b/Makefile @@ -1,5 +1,5 @@ CXX = clang++ -CXXFLAGS = -std=c++17 -Wall -Wextra -pedantic -O3 +CXXFLAGS = -std=c++20 -Wall -Wextra -pedantic -O3 CXXFLAGS += -isysroot $(shell xcrun --show-sdk-path) CXXFLAGS += -fuse-ld=ld -lz DEPFLAGS = -MMD -MF $(@:.o=.d) diff --git a/src/rainsum.cpp b/src/rainsum.cpp index 68e7d81..4dc87c7 100644 --- a/src/rainsum.cpp +++ b/src/rainsum.cpp @@ -18,25 +18,16 @@ #include "tool.h" // for invokeHash, etc. -// ------------------------------------------------------------------ -// Helper functions for mining -// ------------------------------------------------------------------ -/* -static std::vector hexToBytes(const std::string& hexstr) { - if (hexstr.size() % 2 != 0) { - throw std::runtime_error("Hex prefix must have even length."); - } - std::vector bytes(hexstr.size() / 2); - for (size_t i = 0; i < bytes.size(); ++i) { - unsigned int val = 0; - std::stringstream ss; - ss << std::hex << hexstr.substr(i * 2, 2); - ss >> val; - bytes[i] = static_cast(val); +template +std::ostream& operator<<(std::ostream& os, const std::vector& vec) { + os << "["; + for (size_t i = 0; i < vec.size(); ++i) { + if (i > 0) os << ", "; + os << vec[i]; } - return bytes; + os << "]"; + return os; } -*/ inline bool hasPrefix(const std::vector& hash_output, const std::vector& prefix_bytes) { if (prefix_bytes.size() > hash_output.size()) return false; @@ -443,7 +434,6 @@ std::vector decompressData(const std::vector& data) { return decompressed; } - static void puzzleEncryptFileWithHeader( const std::string &inFilename, const std::string &outFilename, @@ -479,7 +469,8 @@ static void puzzleEncryptFileWithHeader( uint8_t searchModeEnum = 0x00; // Default to 'prefix' if (searchMode == "prefix") searchModeEnum = 0x00; else if (searchMode == "sequence") searchModeEnum = 0x01; - else if (searchMode == "series" || searchMode == "scatter") searchModeEnum = 0x02; // Treat 'series' same as 'scatter' + else if (searchMode == "series" ) searchModeEnum = 0x02; + else if (searchMode == "scatter") searchModeEnum = 0x03; else { throw std::runtime_error("Invalid search mode: " + searchMode); } @@ -507,13 +498,16 @@ static void puzzleEncryptFileWithHeader( // Partition plaintext into blocks size_t totalBlocks = (plainData.size() + blockSize - 1) / blockSize; - std::vector hashOut(hash_size / 8); + uint8_t hashBytes = hash_size / 8; + std::vector hashOut(hashBytes); std::vector keyBuf(key.begin(), key.end()); // Prepare random generator for nonce std::mt19937_64 rng(std::random_device{}()); std::uniform_int_distribution dist; + static std::vector> reverseMap(256); + size_t remaining = originalSize; for (size_t blockIndex = 0; blockIndex < totalBlocks; blockIndex++) { @@ -529,6 +523,7 @@ static void puzzleEncryptFileWithHeader( std::vector chosenNonce(nonceSize, 0); std::vector scatterIndices(thisBlockSize, 0); // Changed to uint8_t + for (uint64_t tries = 0; ; tries++) { // No fixed MAX_TRIES // Generate random nonce for (size_t i = 0; i < nonceSize; i++) { @@ -562,12 +557,13 @@ static void puzzleEncryptFileWithHeader( } } } - else if (searchModeEnum == 0x02) { // Series/Scatter + else if (searchModeEnum == 0x02) { // Series - block is in order bool allFound = true; usedIndices.reset(); // Clear used indices for the current block + auto it = hashOut.begin(); + for (size_t byteIdx = 0; byteIdx < thisBlockSize; byteIdx++) { - auto it = hashOut.begin(); // Loop to find a valid index for the current byte while (it != hashOut.end()) { @@ -596,6 +592,78 @@ static void puzzleEncryptFileWithHeader( if (allFound) { found = true; + // Optional debug output for scatterIndices + std::cout << "Series Indices: "; + for (const auto& idx : scatterIndices) { + std::cout << static_cast(idx) << " "; + } + std::cout << std::endl; + } + } + else if (searchModeEnum == 0x03) { // Scatter - block is in any order + /* + bool allFound = true; + usedIndices.reset(); // Clear used indices for the current block + scatterIndices.resize(thisBlockSize, 0); // Ensure size and initialization + + for (size_t byteIdx = 0; byteIdx < thisBlockSize; byteIdx++) { + uint8_t targetByte = block[byteIdx]; + bool foundMatch = false; + + // Search for the first unused index in hashOut + for (size_t i = 0; i < hashOut.size(); i++) { + if (hashOut[i] == targetByte && !usedIndices.test(i)) { + scatterIndices[byteIdx] = static_cast(i); // Store the index + usedIndices.set(i); // Mark this index as used + foundMatch = true; + break; + } + } + + // If no match was found for this byte, fail out + if (!foundMatch) { + allFound = false; + break; + } + } + + if (allFound) { + found = true; + } + */ + // Reset reverseMap for the current hashOut (faster than above) + for (auto& vec : reverseMap) { + vec.clear(); + } + for (size_t i = 0; i < hashOut.size(); ++i) { + reverseMap[hashOut[i]].push_back(static_cast(i)); + } + + bool allFound = true; + scatterIndices.resize(thisBlockSize, 0); // Ensure size and initialization + + for (size_t byteIdx = 0; byteIdx < thisBlockSize; ++byteIdx) { + uint8_t targetByte = block[byteIdx]; + + // Check if the byte exists in reverseMap and has available indices + if (!reverseMap[targetByte].empty()) { + scatterIndices[byteIdx] = reverseMap[targetByte].back(); // Use the last index + reverseMap[targetByte].pop_back(); // Remove the used index + } else { + allFound = false; + break; // Fail out early if mapping fails + } + } + + if (allFound) { + found = true; + + // Optional debug output for scatterIndices + std::cout << "Scatter Indices: "; + for (const auto& idx : scatterIndices) { + std::cout << static_cast(idx) << " "; + } + std::cout << std::endl; } } @@ -616,10 +684,10 @@ static void puzzleEncryptFileWithHeader( // Write nonce and indices fout.write(reinterpret_cast(chosenNonce.data()), nonceSize); - if (searchModeEnum == 0x02) { // Series/Scatter + if (searchModeEnum == 0x02 || searchModeEnum == 0x03) { // Series or Scatter // Write each index as uint8_t fout.write(reinterpret_cast(scatterIndices.data()), scatterIndices.size() * sizeof(uint8_t)); - } + } else { // Prefix/Sequence // Write single start index uint8_t startIndex = scatterIndices[0]; @@ -708,7 +776,7 @@ static void puzzleDecryptFileWithHeader( // Read indices based on search mode std::vector scatterIndices; uint8_t startIndex = 0; - if (searchModeEnum == 0x02) { // Series/Scatter + if (searchModeEnum == 0x02 || searchModeEnum == 0x03) { // Series/Scatter scatterIndices.resize(thisBlockSize); std::memcpy(scatterIndices.data(), &cipherData[cipherOffset], thisBlockSize * sizeof(uint8_t)); cipherOffset += thisBlockSize * sizeof(uint8_t); @@ -730,7 +798,7 @@ static void puzzleDecryptFileWithHeader( throw std::runtime_error("[Dec] Start index out of bounds in sequence mode."); } block.assign(hashOut.begin() + startIndex, hashOut.begin() + startIndex + thisBlockSize); - } else if (searchModeEnum == 0x02) { // Series/Scatter + } else if (searchModeEnum == 0x02 || searchModeEnum == 0x03) { // Series/Scatter block.reserve(thisBlockSize); for (size_t j = 0; j < thisBlockSize; j++) { uint8_t idx = scatterIndices[j]; @@ -781,15 +849,15 @@ int main(int argc, char** argv) { cxxopts::value()->default_value("digest")) ("v,version", "Print version") ("a,algorithm", "Specify the hash algorithm to use (rainbow, rainstorm)", - cxxopts::value()->default_value("bow")) + cxxopts::value()->default_value("storm")) ("s,size", "Specify the size of the hash (e.g., 64, 128, 256, 512)", - cxxopts::value()->default_value("256")) + cxxopts::value()->default_value("512")) ("block-size", "Block size in bytes for puzzle-based encryption (1-255)", cxxopts::value()->default_value("3")) ("n,nonce-size", "Size of the nonce in bytes (1-255)", - cxxopts::value()->default_value("8")) + cxxopts::value()->default_value("14")) ("search-mode", "Search mode: prefix, sequence, series, scatter", - cxxopts::value()->default_value("prefix")) + cxxopts::value()->default_value("scatter")) ("o,output-file", "Output file", cxxopts::value()->default_value("/dev/stdout")) ("t,test-vectors", "Calculate the hash of the standard test vectors", From 5edadcc13f3b70e44703efcb58ff9c40c23ae647 Mon Sep 17 00:00:00 2001 From: DOSAYGO Development Team Date: Tue, 31 Dec 2024 12:43:42 +0800 Subject: [PATCH 07/12] ok --- TODO | 1 - 1 file changed, 1 deletion(-) diff --git a/TODO b/TODO index 137948a..4a160a8 100644 --- a/TODO +++ b/TODO @@ -1,6 +1,5 @@ cipher improvement -- add true scatter (P can be in any order). - schedule K into block keys via XOF - implement a js version of enc / dec - test research construct From 37529b506c43ba9a2b19e6e0d9f65176fbd31298 Mon Sep 17 00:00:00 2001 From: DOSAYGO Development Team Date: Tue, 31 Dec 2024 12:58:28 +0800 Subject: [PATCH 08/12] ok --- scripts/vectors.sh | 8 +- src/rainsum.cpp | 251 +++++++++++++++++++++++++-------------------- src/tool.h | 7 +- 3 files changed, 151 insertions(+), 115 deletions(-) diff --git a/scripts/vectors.sh b/scripts/vectors.sh index 0f9b904..542db03 100755 --- a/scripts/vectors.sh +++ b/scripts/vectors.sh @@ -3,11 +3,11 @@ echo "RAIN HASHES" echo "C++ test vectors" echo "Rainbow test vectors:" -./rainsum --test-vectors +./rainsum --test-vectors -a bow -s 256 echo "Rainstorm test vectors:" -./rainsum --test-vectors -a storm +./rainsum --test-vectors -a storm -s 256 echo "JavaScript/WASM test vectors" echo "Rainbow test vectors:" -./js/rainsum.mjs --test-vectors +./js/rainsum.mjs --test-vectors -a bow -s 256 echo "Rainstorm test vectors:" -./js/rainsum.mjs --test-vectors -a storm +./js/rainsum.mjs --test-vectors -a storm -s 256 diff --git a/src/rainsum.cpp b/src/rainsum.cpp index 4dc87c7..6955e74 100644 --- a/src/rainsum.cpp +++ b/src/rainsum.cpp @@ -17,6 +17,8 @@ #include #include "tool.h" // for invokeHash, etc. +// Add a forward declaration for our new function +static void puzzleShowFileInfo(const std::string &inFilename); template std::ostream& operator<<(std::ostream& os, const std::vector& vec) { @@ -443,7 +445,8 @@ static void puzzleEncryptFileWithHeader( uint64_t seed, size_t blockSize, size_t nonceSize, - const std::string &searchMode + const std::string &searchMode, + bool verbose // NEW: pass this flag in ) { // Open input file std::ifstream fin(inFilename, std::ios::binary); @@ -461,7 +464,7 @@ static void puzzleEncryptFileWithHeader( } // Write header - uint32_t magicNumber = 0x52435259; // "RCRY" + uint32_t magicNumber = MagicNumber; uint8_t version = 0x01; uint8_t blockSize8 = static_cast(blockSize); uint8_t nonceSize8 = static_cast(nonceSize); @@ -513,7 +516,7 @@ static void puzzleEncryptFileWithHeader( for (size_t blockIndex = 0; blockIndex < totalBlocks; blockIndex++) { std::bitset<64> usedIndices; size_t thisBlockSize = std::min(blockSize, remaining); - remaining -= thisBlockSize; // Corrected subtraction + remaining -= thisBlockSize; std::vector block( plainData.begin() + blockIndex * blockSize, plainData.begin() + blockIndex * blockSize + thisBlockSize @@ -521,10 +524,9 @@ static void puzzleEncryptFileWithHeader( bool found = false; std::vector chosenNonce(nonceSize, 0); - std::vector scatterIndices(thisBlockSize, 0); // Changed to uint8_t + std::vector scatterIndices(thisBlockSize, 0); - - for (uint64_t tries = 0; ; tries++) { // No fixed MAX_TRIES + for (uint64_t tries = 0; ; tries++) { // Generate random nonce for (size_t i = 0; i < nonceSize; i++) { chosenNonce[i] = static_cast(dist(rng) & 0xFF); @@ -540,98 +542,60 @@ static void puzzleEncryptFileWithHeader( if (searchModeEnum == 0x00) { // Prefix if (hashOut.size() >= thisBlockSize && std::equal(block.begin(), block.end(), hashOut.begin())) { - // Found at the front - scatterIndices.assign(thisBlockSize, 0); // All indices are 0 + scatterIndices.assign(thisBlockSize, 0); found = true; } } else if (searchModeEnum == 0x01) { // Sequence - // Search for block as a contiguous substring - uint8_t startIdx = 0; for (size_t i = 0; i <= hashOut.size() - thisBlockSize; i++) { if (std::equal(block.begin(), block.end(), hashOut.begin() + i)) { - startIdx = static_cast(i); // Ensure it fits in uint8_t - scatterIndices.assign(thisBlockSize, startIdx); // All bytes share the same start index + uint8_t startIdx = static_cast(i); + scatterIndices.assign(thisBlockSize, startIdx); found = true; break; } } } - else if (searchModeEnum == 0x02) { // Series - block is in order + else if (searchModeEnum == 0x02) { // Series bool allFound = true; - usedIndices.reset(); // Clear used indices for the current block - + usedIndices.reset(); auto it = hashOut.begin(); for (size_t byteIdx = 0; byteIdx < thisBlockSize; byteIdx++) { - - // Loop to find a valid index for the current byte while (it != hashOut.end()) { - // Find the next occurrence of block[byteIdx] it = std::find(it, hashOut.end(), block[byteIdx]); - - if (it != hashOut.end()) { // Found a match + if (it != hashOut.end()) { uint8_t idx = static_cast(std::distance(hashOut.begin(), it)); - - if (!usedIndices.test(idx)) { // Ensure the index is not already used - scatterIndices[byteIdx] = idx; // Store the index - usedIndices.set(idx); // Mark it as used - break; // Exit loop for this byte + if (!usedIndices.test(idx)) { + scatterIndices[byteIdx] = idx; + usedIndices.set(idx); + ++it; + break; } - - // Advance to the next position for further search ++it; + } else { + allFound = false; + break; } } - - if (it == hashOut.end()) { // No valid index found for this byte - allFound = false; + if (!allFound) { break; } } if (allFound) { found = true; - // Optional debug output for scatterIndices - std::cout << "Series Indices: "; - for (const auto& idx : scatterIndices) { + // Only print if verbose + if (verbose) { + std::cout << "Series Indices: "; + for (const auto& idx : scatterIndices) { std::cout << static_cast(idx) << " "; + } + std::cout << std::endl; } - std::cout << std::endl; } - } - else if (searchModeEnum == 0x03) { // Scatter - block is in any order - /* - bool allFound = true; - usedIndices.reset(); // Clear used indices for the current block - scatterIndices.resize(thisBlockSize, 0); // Ensure size and initialization - - for (size_t byteIdx = 0; byteIdx < thisBlockSize; byteIdx++) { - uint8_t targetByte = block[byteIdx]; - bool foundMatch = false; - - // Search for the first unused index in hashOut - for (size_t i = 0; i < hashOut.size(); i++) { - if (hashOut[i] == targetByte && !usedIndices.test(i)) { - scatterIndices[byteIdx] = static_cast(i); // Store the index - usedIndices.set(i); // Mark this index as used - foundMatch = true; - break; - } - } - - // If no match was found for this byte, fail out - if (!foundMatch) { - allFound = false; - break; - } - } - - if (allFound) { - found = true; - } - */ - // Reset reverseMap for the current hashOut (faster than above) + } + else if (searchModeEnum == 0x03) { // Scatter for (auto& vec : reverseMap) { vec.clear(); } @@ -640,56 +604,45 @@ static void puzzleEncryptFileWithHeader( } bool allFound = true; - scatterIndices.resize(thisBlockSize, 0); // Ensure size and initialization + scatterIndices.resize(thisBlockSize, 0); for (size_t byteIdx = 0; byteIdx < thisBlockSize; ++byteIdx) { uint8_t targetByte = block[byteIdx]; - // Check if the byte exists in reverseMap and has available indices if (!reverseMap[targetByte].empty()) { - scatterIndices[byteIdx] = reverseMap[targetByte].back(); // Use the last index - reverseMap[targetByte].pop_back(); // Remove the used index + scatterIndices[byteIdx] = reverseMap[targetByte].back(); + reverseMap[targetByte].pop_back(); } else { allFound = false; - break; // Fail out early if mapping fails + break; } } if (allFound) { found = true; - - // Optional debug output for scatterIndices - std::cout << "Scatter Indices: "; - for (const auto& idx : scatterIndices) { + // Only print if verbose + if (verbose) { + std::cout << "Scatter Indices: "; + for (const auto& idx : scatterIndices) { std::cout << static_cast(idx) << " "; + } + std::cout << std::endl; } - std::cout << std::endl; } } if (found) break; - // Optional: Implement a maximum number of tries to prevent infinite loops - // Example: - /* - if (tries > MAX_TRIES) { - throw std::runtime_error("Failed to find a suitable nonce for block " + std::to_string(blockIndex)); - } - */ - - if (tries % 1'000'000 == 0) { + if (tries % 1000000 == 0) { std::cerr << "\r[Enc] Block " << blockIndex << ", " << tries << " tries... " << std::flush; } } // Write nonce and indices fout.write(reinterpret_cast(chosenNonce.data()), nonceSize); - if (searchModeEnum == 0x02 || searchModeEnum == 0x03) { // Series or Scatter - // Write each index as uint8_t - fout.write(reinterpret_cast(scatterIndices.data()), scatterIndices.size() * sizeof(uint8_t)); - } - else { // Prefix/Sequence - // Write single start index + if (searchModeEnum == 0x02 || searchModeEnum == 0x03) { + fout.write(reinterpret_cast(scatterIndices.data()), scatterIndices.size()); + } else { uint8_t startIndex = scatterIndices[0]; fout.write(reinterpret_cast(&startIndex), sizeof(startIndex)); } @@ -734,7 +687,7 @@ static void puzzleDecryptFileWithHeader( fin.read(reinterpret_cast(&searchModeEnum), sizeof(searchModeEnum)); fin.read(reinterpret_cast(&originalSize), sizeof(originalSize)); - if (magicNumber != 0x52435259) { // "RCRY" + if (magicNumber != MagicNumber) { // "RCRY" throw std::runtime_error("Invalid magic number in header."); } @@ -760,7 +713,7 @@ static void puzzleDecryptFileWithHeader( // Prepare to reconstruct plaintext std::vector keyBuf(key.begin(), key.end()); std::vector hashOut(hash_size / 8); - std::vector plaintextAccumulated; // Collect all decrypted blocks + std::vector plaintextAccumulated; size_t recoveredSoFar = 0; @@ -776,13 +729,13 @@ static void puzzleDecryptFileWithHeader( // Read indices based on search mode std::vector scatterIndices; uint8_t startIndex = 0; - if (searchModeEnum == 0x02 || searchModeEnum == 0x03) { // Series/Scatter + if (searchModeEnum == 0x02 || searchModeEnum == 0x03) { scatterIndices.resize(thisBlockSize); - std::memcpy(scatterIndices.data(), &cipherData[cipherOffset], thisBlockSize * sizeof(uint8_t)); - cipherOffset += thisBlockSize * sizeof(uint8_t); - } else { // Prefix/Sequence - std::memcpy(&startIndex, &cipherData[cipherOffset], sizeof(uint8_t)); - cipherOffset += sizeof(uint8_t); + std::memcpy(scatterIndices.data(), &cipherData[cipherOffset], thisBlockSize); + cipherOffset += thisBlockSize; + } else { + std::memcpy(&startIndex, &cipherData[cipherOffset], 1); + cipherOffset += 1; } // Recompute the hash @@ -790,7 +743,7 @@ static void puzzleDecryptFileWithHeader( trial.insert(trial.end(), storedNonce.begin(), storedNonce.end()); invokeHash(algot, seed, trial, hashOut, hash_size); - // Reconstruct plaintext block based on search mode + // Reconstruct plaintext block if (searchModeEnum == 0x00) { // Prefix block.assign(hashOut.begin(), hashOut.begin() + thisBlockSize); } else if (searchModeEnum == 0x01) { // Sequence @@ -811,7 +764,6 @@ static void puzzleDecryptFileWithHeader( throw std::runtime_error("Invalid search mode enum in decryption."); } - // Append block to accumulated plaintext plaintextAccumulated.insert(plaintextAccumulated.end(), block.begin(), block.end()); recoveredSoFar += thisBlockSize; @@ -822,10 +774,10 @@ static void puzzleDecryptFileWithHeader( std::cout << "\n[Dec] Ciphertext blocks decrypted successfully.\n"; - // Decompress accumulated plaintext + // Decompress std::vector decompressedData = decompressData(plaintextAccumulated); - // Write decompressed data to the output file + // Write to output std::ofstream fout(outFilename, std::ios::binary); if (!fout.is_open()) { throw std::runtime_error("Cannot open output file for decompressed plaintext: " + outFilename); @@ -837,6 +789,69 @@ static void puzzleDecryptFileWithHeader( std::cout << "[Dec] Decompressed plaintext written to: " << outFilename << "\n"; } +// NEW: Just read the file header and display metadata +static void puzzleShowFileInfo(const std::string &inFilename) { + std::ifstream fin(inFilename, std::ios::binary); + if (!fin.is_open()) { + throw std::runtime_error("Cannot open file: " + inFilename); + } + + uint32_t magicNumber; + uint8_t version; + uint8_t blockSize; + uint8_t nonceSize; + uint16_t hash_size; + uint8_t hashNameLength; + std::string hashName; + uint8_t searchModeEnum; + uint64_t originalSize; + + fin.read(reinterpret_cast(&magicNumber), sizeof(magicNumber)); + fin.read(reinterpret_cast(&version), sizeof(version)); + fin.read(reinterpret_cast(&blockSize), sizeof(blockSize)); + fin.read(reinterpret_cast(&nonceSize), sizeof(nonceSize)); + fin.read(reinterpret_cast(&hash_size), sizeof(hash_size)); + fin.read(reinterpret_cast(&hashNameLength), sizeof(hashNameLength)); + + if (!fin.good()) { + throw std::runtime_error("File too small or truncated header."); + } + + hashName.resize(hashNameLength); + fin.read(&hashName[0], hashNameLength); + fin.read(reinterpret_cast(&searchModeEnum), sizeof(searchModeEnum)); + fin.read(reinterpret_cast(&originalSize), sizeof(originalSize)); + + fin.close(); + + if (magicNumber != MagicNumber) { + throw std::runtime_error("Invalid magic number (not an RCRY file)."); + } + + std::string searchMode; + switch (searchModeEnum) { + case 0x00: searchMode = "prefix"; break; + case 0x01: searchMode = "sequence"; break; + case 0x02: searchMode = "series"; break; + case 0x03: searchMode = "scatter"; break; + default: searchMode = "unknown"; break; + } + + size_t totalBlocks = (originalSize + blockSize - 1) / blockSize; + + std::cout << "=== File Header Info ===\n"; + std::cout << "Magic: RCRY (0x" << std::hex << magicNumber << std::dec << ")\n"; + std::cout << "Version: " << static_cast(version) << "\n"; + std::cout << "Block Size: " << static_cast(blockSize) << "\n"; + std::cout << "Nonce Size: " << static_cast(nonceSize) << "\n"; + std::cout << "Hash Size: " << hash_size << " bits\n"; + std::cout << "Hash Algorithm: " << hashName << "\n"; + std::cout << "Search Mode: " << searchMode << "\n"; + std::cout << "Compressed Plaintext Size: " << originalSize << " bytes\n"; + std::cout << "Total Blocks: " << totalBlocks << "\n"; + std::cout << "========================\n"; +} + // The main function int main(int argc, char** argv) { try { @@ -845,7 +860,7 @@ int main(int argc, char** argv) { // Define command-line options options.add_options() - ("m,mode", "Mode: digest, stream, enc, dec", + ("m,mode", "Mode: digest, stream, enc, dec, info", cxxopts::value()->default_value("digest")) ("v,version", "Print version") ("a,algorithm", "Specify the hash algorithm to use (rainbow, rainstorm)", @@ -874,6 +889,9 @@ int main(int argc, char** argv) { // Encrypt / Decrypt options ("P,password", "Encryption/Decryption password", cxxopts::value()->default_value("")) + // NEW: verbose + ("verbose", "Enable verbose output for series/scatter indices", + cxxopts::value()->default_value("false")) ("h,help", "Print usage"); // Parse command-line options @@ -928,6 +946,7 @@ int main(int argc, char** argv) { else if (modeStr == "stream") mode = Mode::Stream; else if (modeStr == "enc") mode = Mode::Enc; else if (modeStr == "dec") mode = Mode::Dec; + else if (modeStr == "info") mode = Mode::Info; // NEW else throw std::runtime_error("Invalid mode: " + modeStr); // Determine Hash Algorithm @@ -939,6 +958,9 @@ int main(int argc, char** argv) { // Validate Hash Size based on Algorithm if (algot == HashAlgorithm::Rainbow) { + if (hash_size == 512) { + hash_size = 256; + } if (hash_size != 64 && hash_size != 128 && hash_size != 256) { throw std::runtime_error("Invalid size for Rainbow (must be 64, 128, or 256)."); } @@ -981,6 +1003,8 @@ int main(int argc, char** argv) { std::string password = result["password"].as(); + // NEW: verbose + bool verbose = result["verbose"].as(); // Handle Mining Modes if (mine_mode != MineMode::None) { @@ -1021,6 +1045,15 @@ int main(int argc, char** argv) { } } + // If mode == info, just show header info + if (mode == Mode::Info) { + if (inpath.empty()) { + throw std::runtime_error("No input file specified for info mode."); + } + puzzleShowFileInfo(inpath); + return 0; + } + // Normal Hashing or Encryption/Decryption std::string outpath = result["output-file"].as(); @@ -1065,7 +1098,7 @@ int main(int argc, char** argv) { // We'll write ciphertext to inpath + ".rc" std::string encFile = inpath + ".rc"; - puzzleEncryptFileWithHeader(inpath, encFile, key, algot, hash_size, seed, blockSize, nonceSize, searchMode); + puzzleEncryptFileWithHeader(inpath, encFile, key, algot, hash_size, seed, blockSize, nonceSize, searchMode, verbose); std::cout << "[Enc] Wrote encrypted file to: " << encFile << "\n"; } else if (mode == Mode::Dec) { @@ -1090,8 +1123,8 @@ int main(int argc, char** argv) { return 0; } catch (const cxxopts::exceptions::exception& e) { - std::cerr << "Error parsing options: " << e.what() << "\n"; - return 1; + std::cerr << "Error parsing options: " << e.what() << "\n"; + return 1; } catch (const std::bad_cast &e) { std::cerr << "Bad cast during option parsing: " << e.what() << "\n"; @@ -1103,5 +1136,3 @@ int main(int argc, char** argv) { } } - - diff --git a/src/tool.h b/src/tool.h index 9072f50..b296a2a 100644 --- a/src/tool.h +++ b/src/tool.h @@ -15,11 +15,14 @@ #define VERSION "1.3.0" +uint32_t MagicNumber = 0x59524352; // RCRY + enum class Mode { Digest, Stream, Enc, // added - Dec // added + Dec, // added + Info }; std::string modeToString(const Mode& mode) { @@ -28,6 +31,7 @@ std::string modeToString(const Mode& mode) { case Mode::Stream: return "Stream"; case Mode::Enc: return "Enc"; // added case Mode::Dec: return "Dec"; // added + case Mode::Info: return "Info"; default: throw std::runtime_error("Unknown hash mode"); } } @@ -39,6 +43,7 @@ std::istream& operator>>(std::istream& in, Mode& mode) { else if (token == "stream") mode = Mode::Stream; else if (token == "enc") mode = Mode::Enc; // added else if (token == "dec") mode = Mode::Dec; // added + else if (token == "info") mode = Mode::Info; else in.setstate(std::ios_base::failbit); return in; } From e998740e33ee17f00c2bc17c37aadee0221bbd56 Mon Sep 17 00:00:00 2001 From: DOSAYGO Development Team Date: Tue, 31 Dec 2024 13:14:26 +0800 Subject: [PATCH 09/12] slightly faster map scatter --- src/rainsum.cpp | 98 +++++++++++++++++++++++++++++++++++++------------ src/tool.h | 6 ++- 2 files changed, 79 insertions(+), 25 deletions(-) diff --git a/src/rainsum.cpp b/src/rainsum.cpp index 6955e74..0f46de5 100644 --- a/src/rainsum.cpp +++ b/src/rainsum.cpp @@ -474,6 +474,7 @@ static void puzzleEncryptFileWithHeader( else if (searchMode == "sequence") searchModeEnum = 0x01; else if (searchMode == "series" ) searchModeEnum = 0x02; else if (searchMode == "scatter") searchModeEnum = 0x03; + else if (searchMode == "mapscatter") searchModeEnum = 0x04; else { throw std::runtime_error("Invalid search mode: " + searchMode); } @@ -509,7 +510,8 @@ static void puzzleEncryptFileWithHeader( std::mt19937_64 rng(std::random_device{}()); std::uniform_int_distribution dist; - static std::vector> reverseMap(256); + static uint8_t reverseMap[256][64]; + static uint8_t reverseMapCount[256]; size_t remaining = originalSize; @@ -569,7 +571,6 @@ static void puzzleEncryptFileWithHeader( if (!usedIndices.test(idx)) { scatterIndices[byteIdx] = idx; usedIndices.set(idx); - ++it; break; } ++it; @@ -578,7 +579,8 @@ static void puzzleEncryptFileWithHeader( break; } } - if (!allFound) { + if (it == hashOut.end()) { // No valid index found for this byte + allFound = false; break; } } @@ -596,23 +598,27 @@ static void puzzleEncryptFileWithHeader( } } else if (searchModeEnum == 0x03) { // Scatter - for (auto& vec : reverseMap) { - vec.clear(); - } - for (size_t i = 0; i < hashOut.size(); ++i) { - reverseMap[hashOut[i]].push_back(static_cast(i)); - } - bool allFound = true; - scatterIndices.resize(thisBlockSize, 0); - - for (size_t byteIdx = 0; byteIdx < thisBlockSize; ++byteIdx) { - uint8_t targetByte = block[byteIdx]; + usedIndices.reset(); - if (!reverseMap[targetByte].empty()) { - scatterIndices[byteIdx] = reverseMap[targetByte].back(); - reverseMap[targetByte].pop_back(); - } else { + for (size_t byteIdx = 0; byteIdx < thisBlockSize; byteIdx++) { + auto it = hashOut.begin(); + while (it != hashOut.end()) { + it = std::find(it, hashOut.end(), block[byteIdx]); + if (it != hashOut.end()) { + uint8_t idx = static_cast(std::distance(hashOut.begin(), it)); + if (!usedIndices.test(idx)) { + scatterIndices[byteIdx] = idx; + usedIndices.set(idx); + break; + } + ++it; + } else { + allFound = false; + break; + } + } + if (it == hashOut.end()) { // No valid index found for this byte allFound = false; break; } @@ -622,7 +628,7 @@ static void puzzleEncryptFileWithHeader( found = true; // Only print if verbose if (verbose) { - std::cout << "Scatter Indices: "; + std::cout << "Series Indices: "; for (const auto& idx : scatterIndices) { std::cout << static_cast(idx) << " "; } @@ -630,6 +636,49 @@ static void puzzleEncryptFileWithHeader( } } } + else if (searchModeEnum == 0x04) { // MapScatter + for (int i = 0; i < 256; i++) { + reverseMapCount[i] = 0; + } + + // Fill the map with all positions of each byte + for (uint8_t i = 0; i < hashOut.size(); i++) { + uint8_t b = hashOut[i]; + // reverseMapCount[b] is how many times we've seen byte 'b' so far + // store the index i in reverseMap[b] at position reverseMapCount[b], then increment + reverseMap[b][ reverseMapCount[b] ] = i; + reverseMapCount[b]++; + } + + bool allFound = true; + scatterIndices.resize(thisBlockSize); + + // For each byte in the plaintext block, pop an index from the “map” + for (size_t byteIdx = 0; byteIdx < thisBlockSize; ++byteIdx) { + uint8_t targetByte = block[byteIdx]; + + // If reverseMapCount[targetByte] == 0, there's no more positions that match + if (reverseMapCount[targetByte] == 0) { + allFound = false; + break; + } + + // ScatterIndices picks the “last” one from that bucket + reverseMapCount[targetByte]--; + scatterIndices[byteIdx] = reverseMap[targetByte][ reverseMapCount[targetByte] ]; + } + + if (allFound) { + found = true; + if (verbose) { + std::cout << "Scatter Indices: "; + for (auto idx : scatterIndices) { + std::cout << (int)idx << " "; + } + std::cout << std::endl; + } + } + } if (found) break; @@ -640,7 +689,7 @@ static void puzzleEncryptFileWithHeader( // Write nonce and indices fout.write(reinterpret_cast(chosenNonce.data()), nonceSize); - if (searchModeEnum == 0x02 || searchModeEnum == 0x03) { + if (searchModeEnum == 0x02 || searchModeEnum == 0x03 || searchModeEnum == 0x04) { fout.write(reinterpret_cast(scatterIndices.data()), scatterIndices.size()); } else { uint8_t startIndex = scatterIndices[0]; @@ -729,7 +778,7 @@ static void puzzleDecryptFileWithHeader( // Read indices based on search mode std::vector scatterIndices; uint8_t startIndex = 0; - if (searchModeEnum == 0x02 || searchModeEnum == 0x03) { + if (searchModeEnum == 0x02 || searchModeEnum == 0x03 || searchModeEnum == 0x04) { scatterIndices.resize(thisBlockSize); std::memcpy(scatterIndices.data(), &cipherData[cipherOffset], thisBlockSize); cipherOffset += thisBlockSize; @@ -751,7 +800,7 @@ static void puzzleDecryptFileWithHeader( throw std::runtime_error("[Dec] Start index out of bounds in sequence mode."); } block.assign(hashOut.begin() + startIndex, hashOut.begin() + startIndex + thisBlockSize); - } else if (searchModeEnum == 0x02 || searchModeEnum == 0x03) { // Series/Scatter + } else if (searchModeEnum == 0x02 || searchModeEnum == 0x03 || searchModeEnum == 0x04) { // Series/Scatter block.reserve(thisBlockSize); for (size_t j = 0; j < thisBlockSize; j++) { uint8_t idx = scatterIndices[j]; @@ -834,6 +883,7 @@ static void puzzleShowFileInfo(const std::string &inFilename) { case 0x01: searchMode = "sequence"; break; case 0x02: searchMode = "series"; break; case 0x03: searchMode = "scatter"; break; + case 0x04: searchMode = "mapscatter"; break; default: searchMode = "unknown"; break; } @@ -871,7 +921,7 @@ int main(int argc, char** argv) { cxxopts::value()->default_value("3")) ("n,nonce-size", "Size of the nonce in bytes (1-255)", cxxopts::value()->default_value("14")) - ("search-mode", "Search mode: prefix, sequence, series, scatter", + ("search-mode", "Search mode: prefix, sequence, series, scatter, mapscatter", cxxopts::value()->default_value("scatter")) ("o,output-file", "Output file", cxxopts::value()->default_value("/dev/stdout")) @@ -928,7 +978,7 @@ int main(int argc, char** argv) { // Search Mode std::string searchMode = result["search-mode"].as(); if (searchMode != "prefix" && searchMode != "sequence" && - searchMode != "series" && searchMode != "scatter") { + searchMode != "series" && searchMode != "scatter" && searchMode != "mapscatter") { throw std::runtime_error("Invalid search mode: " + searchMode); } diff --git a/src/tool.h b/src/tool.h index b296a2a..d11d80c 100644 --- a/src/tool.h +++ b/src/tool.h @@ -90,7 +90,8 @@ enum SearchMode { Prefix, Sequence, Series, - Scatter + Scatter, + MapScatter }; std::string searchModeToString(const SearchMode& mode) { @@ -99,6 +100,7 @@ std::string searchModeToString(const SearchMode& mode) { case SearchMode::Sequence: return "Sequence"; case SearchMode::Series: return "Series"; // added case SearchMode::Scatter: return "Scatter"; // added + case SearchMode::MapScatter: return "MapScatter"; // added default: throw std::runtime_error("Unknown search mode"); } } @@ -114,6 +116,8 @@ std::istream& operator>>(std::istream& in, SearchMode& mode) { mode = SearchMode::Series; } else if (token == "Scatter" ) { mode = SearchMode::Scatter; + } else if (token == "MapScatter" ) { + mode = SearchMode::MapScatter; } else { in.setstate(std::ios_base::failbit); } From 08ca16cce814bf3a99bab91aa9ddb45793012b71 Mon Sep 17 00:00:00 2001 From: DOSAYGO Development Team Date: Tue, 31 Dec 2024 13:24:17 +0800 Subject: [PATCH 10/12] Not implementation for speed --- src/rainsum.cpp | 72 ++++++++++++++++++++++++------------------------- 1 file changed, 35 insertions(+), 37 deletions(-) diff --git a/src/rainsum.cpp b/src/rainsum.cpp index 0f46de5..e879741 100644 --- a/src/rainsum.cpp +++ b/src/rainsum.cpp @@ -510,8 +510,8 @@ static void puzzleEncryptFileWithHeader( std::mt19937_64 rng(std::random_device{}()); std::uniform_int_distribution dist; - static uint8_t reverseMap[256][64]; - static uint8_t reverseMapCount[256]; + static uint8_t reverseMap[256 * 64]; + static uint8_t reverseMapOffsets[256]; size_t remaining = originalSize; @@ -637,47 +637,45 @@ static void puzzleEncryptFileWithHeader( } } else if (searchModeEnum == 0x04) { // MapScatter - for (int i = 0; i < 256; i++) { - reverseMapCount[i] = 0; + // Reset offsets + std::fill(std::begin(reverseMapOffsets), std::end(reverseMapOffsets), 0); + + // Fill the map with all positions of each byte in hashOut + for (uint8_t i = 0; i < hashOut.size(); i++) { + uint8_t b = hashOut[i]; + reverseMap[b * 64 + reverseMapOffsets[b]] = i; // Store the index + reverseMapOffsets[b]++; + } + + bool allFound = true; + + // Match each byte in the plaintext block + for (size_t byteIdx = 0; byteIdx < thisBlockSize; ++byteIdx) { + uint8_t targetByte = block[byteIdx]; + + // If reverseMapOffsets[targetByte] == 0, there are no more matches + if (reverseMapOffsets[targetByte] == 0) { + allFound = false; + break; } - // Fill the map with all positions of each byte - for (uint8_t i = 0; i < hashOut.size(); i++) { - uint8_t b = hashOut[i]; - // reverseMapCount[b] is how many times we've seen byte 'b' so far - // store the index i in reverseMap[b] at position reverseMapCount[b], then increment - reverseMap[b][ reverseMapCount[b] ] = i; - reverseMapCount[b]++; - } - - bool allFound = true; - scatterIndices.resize(thisBlockSize); + // Get the last match and decrement offset + reverseMapOffsets[targetByte]--; + scatterIndices[byteIdx] = (reverseMap[targetByte * 64 + reverseMapOffsets[targetByte]]); + } - // For each byte in the plaintext block, pop an index from the “map” - for (size_t byteIdx = 0; byteIdx < thisBlockSize; ++byteIdx) { - uint8_t targetByte = block[byteIdx]; - - // If reverseMapCount[targetByte] == 0, there's no more positions that match - if (reverseMapCount[targetByte] == 0) { - allFound = false; - break; - } + if (allFound) { + found = true; - // ScatterIndices picks the “last” one from that bucket - reverseMapCount[targetByte]--; - scatterIndices[byteIdx] = reverseMap[targetByte][ reverseMapCount[targetByte] ]; - } - - if (allFound) { - found = true; - if (verbose) { - std::cout << "Scatter Indices: "; - for (auto idx : scatterIndices) { - std::cout << (int)idx << " "; - } - std::cout << std::endl; + // Optional: Print scatter indices if verbose + if (verbose) { + std::cout << "Scatter Indices: "; + for (auto idx : scatterIndices) { + std::cout << static_cast(idx) << " "; } + std::cout << std::endl; } + } } if (found) break; From ca816fdfca2f682cb6903e31176d7e861b8882cb Mon Sep 17 00:00:00 2001 From: DOSAYGO Development Team Date: Tue, 31 Dec 2024 13:25:45 +0800 Subject: [PATCH 11/12] ok --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index dbd2387..3c4d882 100644 --- a/README.md +++ b/README.md @@ -17,9 +17,11 @@ This repository features the **Rainbow** and **Rainstorm** hash functions (collectively, **Rain Hashes**), created by [Cris](https://github.com/o0101) at [DOSAYGO](https://github.com/dosyago) and licensed under Apache-2.0. All size variants of both hashes pass **all tests in SMHasher3**. Relevant [results](results) are available in the `results/` directory, or at the [SMHasher3 GitLab repository](https://gitlab.com/fwojcik/smhasher3/-/blob/main/results/README.md). The CLI tool API is similar to standard tools like `sha256sum`, but with more switches to select algorithm and digest length. The hashes produce digests ranging from 64 through to 512 bits wide. See the table below for details. The codebase includes: + - A C++ reference implementation - A WASM port (for Node.js and browser environments) - A Makefile for building all targets +- An experimental cryptosystem based on [plaintext mining ciphers](https://dosaygo-research.github.io/rain/paper/cipher-note.pdf) | Algorithm | Speed | Hash Size | Purpose | Core Mixing Function | Security | |-----------|--------------------|------------------|--------------------------------------|---------------------------------------------------|---------------------------------| From e9076c85edc83ac13b42b007633fa25e90cdc8a0 Mon Sep 17 00:00:00 2001 From: DOSAYGO Development Team Date: Tue, 31 Dec 2024 14:27:52 +0800 Subject: [PATCH 12/12] Deterministic works great --- .DS_Store | Bin 8196 -> 8196 bytes src/rainsum.cpp | 25 ++++++++++++++++++++----- 2 files changed, 20 insertions(+), 5 deletions(-) diff --git a/.DS_Store b/.DS_Store index 9450cbd31fb44c90123f2e9726ae885a716156ad..7d7b4650cb000b52e96e1ac37b85c945e501389f 100644 GIT binary patch delta 29 lcmZp1XmOa}¥U^hRb!e$-;X_n3EJP(*RvrGJC2LOu62?78B delta 152 zcmZp1XmOa}C7U^hRb%4Qw`X_k5xhH{2PhGK@?oOHwB+l~2JdUyy-p_5ub50ibRM21W*j&C5jMxB-~0B=G dist; + uint64_t nonceCounter = 0; // Counter for deterministic nonce static uint8_t reverseMap[256 * 64]; static uint8_t reverseMapOffsets[256]; @@ -529,9 +531,17 @@ static void puzzleEncryptFileWithHeader( std::vector scatterIndices(thisBlockSize, 0); for (uint64_t tries = 0; ; tries++) { - // Generate random nonce - for (size_t i = 0; i < nonceSize; i++) { - chosenNonce[i] = static_cast(dist(rng) & 0xFF); + if (deterministicNonce) { + // Incremental counter for nonce + for (size_t i = 0; i < nonceSize; i++) { + chosenNonce[i] = static_cast((nonceCounter >> (i * 8)) & 0xFF); + } + nonceCounter++; + } else { + // Random bytes for nonce + for (size_t i = 0; i < nonceSize; i++) { + chosenNonce[i] = dist(rng); + } } // Build trial buffer @@ -919,6 +929,8 @@ int main(int argc, char** argv) { cxxopts::value()->default_value("3")) ("n,nonce-size", "Size of the nonce in bytes (1-255)", cxxopts::value()->default_value("14")) + ("deterministic-nonce", "Use a deterministic counter for nonce generation", + cxxopts::value()->default_value("false")) ("search-mode", "Search mode: prefix, sequence, series, scatter, mapscatter", cxxopts::value()->default_value("scatter")) ("o,output-file", "Output file", @@ -973,6 +985,9 @@ int main(int argc, char** argv) { throw std::runtime_error("Nonce size must be between 1 and 255 bytes."); } + // Nonce nature + bool deterministicNonce = result["deterministic-nonce"].as(); + // Search Mode std::string searchMode = result["search-mode"].as(); if (searchMode != "prefix" && searchMode != "sequence" && @@ -1146,7 +1161,7 @@ int main(int argc, char** argv) { // We'll write ciphertext to inpath + ".rc" std::string encFile = inpath + ".rc"; - puzzleEncryptFileWithHeader(inpath, encFile, key, algot, hash_size, seed, blockSize, nonceSize, searchMode, verbose); + puzzleEncryptFileWithHeader(inpath, encFile, key, algot, hash_size, seed, blockSize, nonceSize, searchMode, verbose, deterministicNonce); std::cout << "[Enc] Wrote encrypted file to: " << encFile << "\n"; } else if (mode == Mode::Dec) {