From 51411de876c6df3e85bc66a68d38ee03fcc1d120 Mon Sep 17 00:00:00 2001
From: Richard Bair <rbair23@users.noreply.github.com>
Date: Mon, 4 Aug 2025 13:16:22 -0700
Subject: [PATCH 01/17] Fix poor hashing distribution in Bytes.

We have a really great hashing algorithm in the Hiero
Consensus Node in the NonCryptographicHashing file. This PR
brings it over here, but leaves it package private. A separate
PR should make it public and possibly move it somewhere else.
And a future PR should fix all other hashCode() implementations,
including for generated PBJ objects.

Signed-off-by: Richard Bair <rbair23@users.noreply.github.com>
---
 .../hedera/pbj/runtime/io/buffer/Bytes.java   |   6 +-
 .../io/buffer/NonCryptographicHashing.java    | 730 ++++++++++++++++++
 2 files changed, 731 insertions(+), 5 deletions(-)
 create mode 100644 pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashing.java

diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/Bytes.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/Bytes.java
index 59aee2c6..98a42292 100644
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/Bytes.java
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/Bytes.java
@@ -537,11 +537,7 @@ public boolean equals(@Nullable final Object o) {
     @Override
     public int hashCode() {
         if (hashCode == 0) {
-            int h = 1;
-            for (int i = start + length - 1; i >= start; i--) {
-                h = 31 * h + UnsafeUtils.getArrayByteNoChecks(buffer, i);
-            }
-            hashCode = h;
+            hashCode = NonCryptographicHashing.hash64(buffer, start, length);
         }
         return hashCode;
     }
diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashing.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashing.java
new file mode 100644
index 00000000..a0b9808e
--- /dev/null
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashing.java
@@ -0,0 +1,730 @@
+package com.hedera.pbj.runtime.io.buffer;
+
+/**
+ * <p>
+ * This class contains a collection of methods for hashing basic data types.
+ * Hashes are not cryptographically secure, and are intended to be used when
+ * implementing {@link Object#hashCode()} or similar functionality.
+ * </p>
+ *
+ * <p>
+ * This class provides a large number of methods with different signatures, the goal being to avoid the
+ * creation of arrays to pass a variable number of arguments. Hashing happens a lot and needs to be fast,
+ * so if we can avoid lots of extra allocations it is worthwhile.
+ * </p>
+ */
+final class NonCryptographicHashing {
+
+    private NonCryptographicHashing() {}
+
+    /**
+     * <p>
+     * Data types that can be hashed.
+     * </p>
+     *
+     * <p>
+     * WARNING: only add to the end of this list.
+     * Do not change or remove or reorder any existing elements, or it will change the hashes.
+     * </p>
+     */
+    private enum DataType {
+        LONG,
+        LONG_ARRAY,
+        BYTE_ARRAY,
+        STRING
+    }
+
+    /**
+     * For every hash, mix in a long derived from the data type and the length of the data.
+     * This causes the hashes for different data types and different lengths of data to differ
+     * with moderately high probability.
+     *
+     * @param type
+     * 		the type of the data
+     * @param length
+     * 		the length of the data
+     * @return a long to mix into the hash
+     */
+    private static long computeMixin(@NonNull final DataType type, final long length) {
+        return ((long) type.ordinal()) | (length << 32);
+    }
+
+    /**
+     * Generates a non-cryptographic 64 bit hash for 1 long.
+     *
+     * @param x0
+     * 		a long
+     * @return a non-cryptographic long hash
+     */
+    public static long hash64(final long x0) {
+        return perm64(perm64(computeMixin(DataType.LONG, 1)) ^ x0);
+    }
+
+    /**
+     * Generates a non-cryptographic 64 bit hash for 2 longs.
+     *
+     * @param x0
+     * 		a long
+     * @param x1
+     * 		a long
+     * @return a non-cryptographic long hash
+     */
+    public static long hash64(final long x0, final long x1) {
+        return perm64(perm64(perm64(computeMixin(DataType.LONG, 2)) ^ x0) ^ x1);
+    }
+
+    /**
+     * Generates a non-cryptographic 64 bit hash for 3 longs.
+     *
+     * @param x0
+     * 		a long
+     * @param x1
+     * 		a long
+     * @param x2
+     * 		a long
+     * @return a non-cryptographic long hash
+     */
+    public static long hash64(final long x0, final long x1, final long x2) {
+        return perm64(perm64(perm64(perm64(computeMixin(DataType.LONG, 3)) ^ x0) ^ x1) ^ x2);
+    }
+
+    /**
+     * Generates a non-cryptographic 64 bit hash for 4 longs.
+     *
+     * @param x0
+     * 		a long
+     * @param x1
+     * 		a long
+     * @param x2
+     * 		a long
+     * @param x3
+     * 		a long
+     * @return a non-cryptographic long hash
+     */
+    public static long hash64(final long x0, final long x1, final long x2, final long x3) {
+        return perm64(perm64(perm64(perm64(perm64(computeMixin(DataType.LONG, 4)) ^ x0) ^ x1) ^ x2) ^ x3);
+    }
+
+    /**
+     * Generates a non-cryptographic 64 bit hash for 5 longs.
+     *
+     * @param x0
+     * 		a long
+     * @param x1
+     * 		a long
+     * @param x2
+     * 		a long
+     * @param x3
+     * 		a long
+     * @param x4
+     * 		a long
+     * @return a non-cryptographic long hash
+     */
+    public static long hash64(final long x0, final long x1, final long x2, final long x3, final long x4) {
+        return perm64(perm64(perm64(perm64(perm64(perm64(computeMixin(DataType.LONG, 5)) ^ x0) ^ x1) ^ x2) ^ x3) ^ x4);
+    }
+
+    /**
+     * Generates a non-cryptographic 64 bit hash for 6 longs.
+     *
+     * @param x0
+     * 		a long
+     * @param x1
+     * 		a long
+     * @param x2
+     * 		a long
+     * @param x3
+     * 		a long
+     * @param x4
+     * 		a long
+     * @param x5
+     * 		a long
+     * @return a non-cryptographic long hash
+     */
+    public static long hash64(
+            final long x0, final long x1, final long x2, final long x3, final long x4, final long x5) {
+        return perm64(
+                perm64(perm64(perm64(perm64(perm64(perm64(computeMixin(DataType.LONG, 6)) ^ x0) ^ x1) ^ x2) ^ x3) ^ x4)
+                        ^ x5);
+    }
+
+    /**
+     * Generates a non-cryptographic 64 bit hash for 7 longs.
+     *
+     * @param x0
+     * 		a long
+     * @param x1
+     * 		a long
+     * @param x2
+     * 		a long
+     * @param x3
+     * 		a long
+     * @param x4
+     * 		a long
+     * @param x5
+     * 		a long
+     * @param x6
+     * 		a long
+     * @return a non-cryptographic long hash
+     */
+    public static long hash64(
+            final long x0, final long x1, final long x2, final long x3, final long x4, final long x5, final long x6) {
+        return perm64(
+                perm64(perm64(perm64(perm64(perm64(perm64(perm64(computeMixin(DataType.LONG, 7)) ^ x0) ^ x1) ^ x2) ^ x3)
+                        ^ x4)
+                        ^ x5)
+                        ^ x6);
+    }
+
+    /**
+     * Generates a non-cryptographic 64 bit hash for 8 longs.
+     *
+     * @param x0
+     * 		a long
+     * @param x1
+     * 		a long
+     * @param x2
+     * 		a long
+     * @param x3
+     * 		a long
+     * @param x4
+     * 		a long
+     * @param x5
+     * 		a long
+     * @param x6
+     * 		a long
+     * @param x7
+     * 		a long
+     * @return a non-cryptographic long hash
+     */
+    public static long hash64(
+            final long x0,
+            final long x1,
+            final long x2,
+            final long x3,
+            final long x4,
+            final long x5,
+            final long x6,
+            final long x7) {
+        return perm64(
+                perm64(perm64(perm64(perm64(perm64(perm64(perm64(perm64(computeMixin(DataType.LONG, 8)) ^ x0) ^ x1)
+                        ^ x2)
+                        ^ x3)
+                        ^ x4)
+                        ^ x5)
+                        ^ x6)
+                        ^ x7);
+    }
+
+    /**
+     * Generates a non-cryptographic 64 bit hash for 9 longs.
+     *
+     * @param x0
+     * 		a long
+     * @param x1
+     * 		a long
+     * @param x2
+     * 		a long
+     * @param x3
+     * 		a long
+     * @param x4
+     * 		a long
+     * @param x5
+     * 		a long
+     * @param x6
+     * 		a long
+     * @param x7
+     * 		a long
+     * @param x8
+     * 		a long
+     * @return a non-cryptographic long hash
+     */
+    public static long hash64(
+            final long x0,
+            final long x1,
+            final long x2,
+            final long x3,
+            final long x4,
+            final long x5,
+            final long x6,
+            final long x7,
+            final long x8) {
+        return perm64(
+                perm64(perm64(perm64(perm64(perm64(perm64(perm64(perm64(perm64(computeMixin(DataType.LONG, 9)) ^ x0)
+                        ^ x1)
+                        ^ x2)
+                        ^ x3)
+                        ^ x4)
+                        ^ x5)
+                        ^ x6)
+                        ^ x7)
+                        ^ x8);
+    }
+
+    /**
+     * Generates a non-cryptographic 64 bit hash for 10 longs.
+     *
+     * @param x0
+     * 		a long
+     * @param x1
+     * 		a long
+     * @param x2
+     * 		a long
+     * @param x3
+     * 		a long
+     * @param x4
+     * 		a long
+     * @param x5
+     * 		a long
+     * @param x6
+     * 		a long
+     * @param x7
+     * 		a long
+     * @param x8
+     * 		a long
+     * @param x9
+     * 		a long
+     * @return a non-cryptographic long hash
+     */
+    public static long hash64(
+            final long x0,
+            final long x1,
+            final long x2,
+            final long x3,
+            final long x4,
+            final long x5,
+            final long x6,
+            final long x7,
+            final long x8,
+            final long x9) {
+        return perm64(
+                perm64(perm64(perm64(perm64(perm64(perm64(perm64(perm64(perm64(perm64(computeMixin(DataType.LONG, 10))
+                        ^ x0)
+                        ^ x1)
+                        ^ x2)
+                        ^ x3)
+                        ^ x4)
+                        ^ x5)
+                        ^ x6)
+                        ^ x7)
+                        ^ x8)
+                        ^ x9);
+    }
+
+    /**
+     * Generates a non-cryptographic 64 bit hash for an array of longs.
+     *
+     * @param x
+     * 		an array of longs
+     * @return a non-cryptographic integer hash
+     */
+    public static long hash64(@NonNull final long... x) {
+        long t = perm64(computeMixin(DataType.LONG_ARRAY, x.length));
+        for (final long l : x) {
+            t = perm64(t ^ l);
+        }
+        return t;
+    }
+
+    /**
+     * Generates a non-cryptographic 32 bit hash for 1 long.
+     *
+     * @param x0
+     * 		a long
+     * @return a non-cryptographic integer hash
+     */
+    public static int hash32(final long x0) {
+
+        return (int) hash64(x0);
+    }
+
+    /**
+     * Generates a non-cryptographic 32 bit hash for 2 longs.
+     *
+     * @param x0
+     * 		a long
+     * @param x1
+     * 		a long
+     * @return a non-cryptographic integer hash
+     */
+    public static int hash32(final long x0, final long x1) {
+        return (int) hash64(x0, x1);
+    }
+
+    /**
+     * Generates a non-cryptographic 32 bit hash for 3 longs.
+     *
+     * @param x0
+     * 		a long
+     * @param x1
+     * 		a long
+     * @param x2
+     * 		a long
+     * @return a non-cryptographic integer hash
+     */
+    public static int hash32(final long x0, final long x1, final long x2) {
+        return (int) hash64(x0, x1, x2);
+    }
+
+    /**
+     * Generates a non-cryptographic 32 bit hash for 4 longs.
+     *
+     * @param x0
+     * 		a long
+     * @param x1
+     * 		a long
+     * @param x2
+     * 		a long
+     * @param x3
+     * 		a long
+     * @return a non-cryptographic integer hash
+     */
+    public static int hash32(final long x0, final long x1, final long x2, final long x3) {
+        return (int) hash64(x0, x1, x2, x3);
+    }
+
+    /**
+     * Generates a non-cryptographic 32 bit hash for 5 longs.
+     *
+     * @param x0
+     * 		a long
+     * @param x1
+     * 		a long
+     * @param x2
+     * 		a long
+     * @param x3
+     * 		a long
+     * @param x4
+     * 		a long
+     * @return a non-cryptographic integer hash
+     */
+    public static int hash32(final long x0, final long x1, final long x2, final long x3, final long x4) {
+        return (int) hash64(x0, x1, x2, x3, x4);
+    }
+
+    /**
+     * Generates a non-cryptographic 32 bit hash for 6 longs.
+     *
+     * @param x0
+     * 		a long
+     * @param x1
+     * 		a long
+     * @param x2
+     * 		a long
+     * @param x3
+     * 		a long
+     * @param x4
+     * 		a long
+     * @param x5
+     * 		a long
+     * @return a non-cryptographic integer hash
+     */
+    public static int hash32(final long x0, final long x1, final long x2, final long x3, final long x4, final long x5) {
+        return (int) hash64(x0, x1, x2, x3, x4, x5);
+    }
+
+    /**
+     * Generates a non-cryptographic 32 bit hash for 7 longs.
+     *
+     * @param x0
+     * 		a long
+     * @param x1
+     * 		a long
+     * @param x2
+     * 		a long
+     * @param x3
+     * 		a long
+     * @param x4
+     * 		a long
+     * @param x5
+     * 		a long
+     * @param x6
+     * 		a long
+     * @return a non-cryptographic integer hash
+     */
+    public static int hash32(
+            final long x0, final long x1, final long x2, final long x3, final long x4, final long x5, final long x6) {
+        return (int) hash64(x0, x1, x2, x3, x4, x5, x6);
+    }
+
+    /**
+     * Generates a non-cryptographic 32 bit hash for 8 longs.
+     *
+     * @param x0
+     * 		a long
+     * @param x1
+     * 		a long
+     * @param x2
+     * 		a long
+     * @param x3
+     * 		a long
+     * @param x4
+     * 		a long
+     * @param x5
+     * 		a long
+     * @param x6
+     * 		a long
+     * @param x7
+     * 		a long
+     * @return a non-cryptographic integer hash
+     */
+    public static int hash32(
+            final long x0,
+            final long x1,
+            final long x2,
+            final long x3,
+            final long x4,
+            final long x5,
+            final long x6,
+            final long x7) {
+        return (int) hash64(x0, x1, x2, x3, x4, x5, x6, x7);
+    }
+
+    /**
+     * Generates a non-cryptographic 32 bit hash for 9 longs.
+     *
+     * @param x0
+     * 		a long
+     * @param x1
+     * 		a long
+     * @param x2
+     * 		a long
+     * @param x3
+     * 		a long
+     * @param x4
+     * 		a long
+     * @param x5
+     * 		a long
+     * @param x6
+     * 		a long
+     * @param x7
+     * 		a long
+     * @param x8
+     * 		a long
+     * @return a non-cryptographic integer hash
+     */
+    public static int hash32(
+            final long x0,
+            final long x1,
+            final long x2,
+            final long x3,
+            final long x4,
+            final long x5,
+            final long x6,
+            final long x7,
+            final long x8) {
+        return (int) hash64(x0, x1, x2, x3, x4, x5, x6, x7, x8);
+    }
+
+    /**
+     * Generates a non-cryptographic 32 bit hash for 10 longs.
+     *
+     * @param x0
+     * 		a long
+     * @param x1
+     * 		a long
+     * @param x2
+     * 		a long
+     * @param x3
+     * 		a long
+     * @param x4
+     * 		a long
+     * @param x5
+     * 		a long
+     * @param x6
+     * 		a long
+     * @param x7
+     * 		a long
+     * @param x8
+     * 		a long
+     * @param x9
+     * 		a long
+     * @return a non-cryptographic integer hash
+     */
+    public static int hash32(
+            final long x0,
+            final long x1,
+            final long x2,
+            final long x3,
+            final long x4,
+            final long x5,
+            final long x6,
+            final long x7,
+            final long x8,
+            final long x9) {
+        return (int) hash64(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+    }
+
+    /**
+     * Generates a non-cryptographic 32 bit hash for an array of longs.
+     *
+     * @param x
+     * 		an array of longs
+     * @return a non-cryptographic integer hash
+     */
+    public static int hash32(@NonNull final long... x) {
+        return (int) hash64(x);
+    }
+
+    /**
+     * Generates a non-cryptographic 64 bit hash for a byte array.
+     *
+     * @param bytes
+     * 		a byte array
+     * @return a non-cryptographic long hash
+     */
+    public static long hash64(@NonNull final byte[] bytes) {
+        return hash64(bytes, 0, bytes.length);
+    }
+
+    /**
+     * Generates a non-cryptographic 64 bit hash for a byte array.
+     *
+     * @param bytes
+     * 		a byte array
+     * @param start
+     *         the start index in the byte array
+     * @param length
+     *         the number of bytes to hash
+     * @return a non-cryptographic long hash
+     */
+    public static long hash64(@NonNull final byte[] bytes, int start, int length) {
+        long hash = perm64(computeMixin(DataType.BYTE_ARRAY, length));
+        for (int i = start; i < length; i += 8) {
+            hash = perm64(hash ^ byteArrayToLong(bytes, i));
+        }
+        return hash;
+    }
+
+    /**
+     * Generates a non-cryptographic 32 bit hash for a byte array.
+     *
+     * @param bytes
+     * 		a byte array
+     * @return a non-cryptographic int hash
+     */
+    public static long hash32(@NonNull final byte[] bytes) {
+        return (int) hash64(bytes);
+    }
+
+    /**
+     * Generates a non-cryptographic 64 bit hash from the normalized bytes of a string.
+     *
+     * @param string
+     * 		a string
+     * @return a non-cryptographic long hash
+     */
+    public static long hash64(@NonNull final String string) {
+        final byte[] bytes = getNormalisedStringBytes(string);
+
+        long hash = perm64(computeMixin(DataType.STRING, bytes.length));
+        for (int i = 0; i < bytes.length; i += 8) {
+            hash = perm64(hash ^ byteArrayToLong(bytes, i));
+        }
+        return hash;
+    }
+
+    /**
+     * Generates a non-cryptographic 32 bit hash for a string.
+     *
+     * @param string
+     * 		a string
+     * @return a non-cryptographic int hash
+     */
+    public static int hash32(@NonNull final String string) {
+        return (int) hash64(string);
+    }
+
+    /**
+     * <p>
+     * A permutation (invertible function) on 64 bits.
+     * The constants were found by automated search, to
+     * optimize avalanche. Avalanche means that for a
+     * random number x, flipping bit i of x has about a
+     * 50 percent chance of flipping bit j of perm64(x).
+     * For each possible pair (i,j), this function achieves
+     * a probability between 49.8 and 50.2 percent.
+     * </p>
+     *
+     * <p>
+     * Leemon wrote this, it's magic and does magic things. Like holy molly does
+     * this algorithm resolve some nasty hash collisions for troublesome data sets.
+     * Don't mess with this method.
+     *
+     * <p>
+     * Warning: there currently exist production use cases that will break if this hashing algorithm is changed.
+     * If modifications to this hashing algorithm are ever required, we will need to "fork" this class and leave
+     * the old algorithm intact.
+     */
+    private static long perm64(long x) {
+
+        // This is necessary so that 0 does not hash to 0.
+        // As a side effect this constant will hash to 0.
+        // It was randomly generated (not using Java),
+        // so that it will occur in practice less often than more
+        // common numbers like 0 or -1 or Long.MAX_VALUE.
+        x ^= 0x5e8a016a5eb99c18L;
+
+        // Shifts: {30, 27, 16, 20, 5, 18, 10, 24, 30}
+        x += x << 30;
+        x ^= x >>> 27;
+        x += x << 16;
+        x ^= x >>> 20;
+        x += x << 5;
+        x ^= x >>> 18;
+        x += x << 10;
+        x ^= x >>> 24;
+        x += x << 30;
+        return x;
+    }
+
+    /**
+     * Return a long derived from the 8 bytes data[position]...data[position+7], big endian. If the byte array is not
+     * long enough, zeros are substituted for the missing bytes.
+     *
+     * @param data     an array of bytes
+     * @param position the first byte in the array to use
+     * @return the 8 bytes starting at position, converted to a long, big endian
+     */
+    public static long byteArrayToLong(final byte[] data, final int position) {
+        if (data.length > position + 8) {
+            // Hard coded constants are used instead of a for loop to reduce the arithmetic required at runtime
+            return ((data[position] & 0xffL) << (8 * 7))
+                    + ((data[position + 1] & 0xffL) << (8 * 6))
+                    + ((data[position + 2] & 0xffL) << (8 * 5))
+                    + ((data[position + 3] & 0xffL) << (8 * 4))
+                    + ((data[position + 4] & 0xffL) << (8 * 3))
+                    + ((data[position + 5] & 0xffL) << (8 * 2))
+                    + ((data[position + 6] & 0xffL) << (8))
+                    + (data[position + 7] & 0xffL);
+        } else {
+            // There isn't enough data to fill the long, so pad with zeros.
+            long result = 0;
+            for (int offset = 0; offset < 8; offset++) {
+                final int index = position + offset;
+                if (index >= data.length) {
+                    break;
+                }
+                result += (data[index] & 0xffL) << (8 * (7 - offset));
+            }
+            return result;
+        }
+    }
+
+    /**
+     * Normalizes the string in accordance with the Swirlds default normalization method (NFD) and returns the bytes of
+     * that normalized String encoded in the Swirlds default charset (UTF8). This is important for having a consistent
+     * method of converting Strings to bytes that will guarantee that two identical strings will have an identical byte
+     * representation
+     *
+     * @param s the String to be converted to bytes
+     * @return a byte representation of the String
+     */
+    @Nullable
+    public static byte[] getNormalisedStringBytes(final String s) {
+        if (s == null) {
+            return null;
+        }
+        return Normalizer.normalize(s, Normalizer.Form.NFD).getBytes(CommonUtils.DEFAULT_CHARSET);
+    }
+}

From 253d7349fe25f55ecac1d72f2db2bdf863ded7c9 Mon Sep 17 00:00:00 2001
From: Richard Bair <rbair23@users.noreply.github.com>
Date: Mon, 4 Aug 2025 14:15:34 -0700
Subject: [PATCH 02/17] Add tests and make compile.

Signed-off-by: Richard Bair <rbair23@users.noreply.github.com>
---
 .../hedera/pbj/runtime/io/buffer/Bytes.java   |   2 +-
 .../io/buffer/NonCryptographicHashing.java    |  84 +--
 .../io/buffer/NonCryptographicHashTest.java   | 586 ++++++++++++++++++
 3 files changed, 634 insertions(+), 38 deletions(-)
 create mode 100644 pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashTest.java

diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/Bytes.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/Bytes.java
index 98a42292..b4a61e70 100644
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/Bytes.java
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/Bytes.java
@@ -537,7 +537,7 @@ public boolean equals(@Nullable final Object o) {
     @Override
     public int hashCode() {
         if (hashCode == 0) {
-            hashCode = NonCryptographicHashing.hash64(buffer, start, length);
+            hashCode = (int) NonCryptographicHashing.hash64(buffer, start, length);
         }
         return hashCode;
     }
diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashing.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashing.java
index a0b9808e..9a46eedf 100644
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashing.java
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashing.java
@@ -1,5 +1,11 @@
 package com.hedera.pbj.runtime.io.buffer;
 
+import com.hedera.pbj.runtime.io.UnsafeUtils;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import edu.umd.cs.findbugs.annotations.Nullable;
+import java.nio.charset.StandardCharsets;
+import java.text.Normalizer;
+
 /**
  * <p>
  * This class contains a collection of methods for hashing basic data types.
@@ -50,7 +56,7 @@ private static long computeMixin(@NonNull final DataType type, final long length
     }
 
     /**
-     * Generates a non-cryptographic 64 bit hash for 1 long.
+     * Generates a non-cryptographic 64-bit hash for 1 long.
      *
      * @param x0
      * 		a long
@@ -61,7 +67,7 @@ public static long hash64(final long x0) {
     }
 
     /**
-     * Generates a non-cryptographic 64 bit hash for 2 longs.
+     * Generates a non-cryptographic 64-bit hash for 2 longs.
      *
      * @param x0
      * 		a long
@@ -74,7 +80,7 @@ public static long hash64(final long x0, final long x1) {
     }
 
     /**
-     * Generates a non-cryptographic 64 bit hash for 3 longs.
+     * Generates a non-cryptographic 64-bit hash for 3 longs.
      *
      * @param x0
      * 		a long
@@ -89,7 +95,7 @@ public static long hash64(final long x0, final long x1, final long x2) {
     }
 
     /**
-     * Generates a non-cryptographic 64 bit hash for 4 longs.
+     * Generates a non-cryptographic 64-bit hash for 4 longs.
      *
      * @param x0
      * 		a long
@@ -106,7 +112,7 @@ public static long hash64(final long x0, final long x1, final long x2, final lon
     }
 
     /**
-     * Generates a non-cryptographic 64 bit hash for 5 longs.
+     * Generates a non-cryptographic 64-bit hash for 5 longs.
      *
      * @param x0
      * 		a long
@@ -125,7 +131,7 @@ public static long hash64(final long x0, final long x1, final long x2, final lon
     }
 
     /**
-     * Generates a non-cryptographic 64 bit hash for 6 longs.
+     * Generates a non-cryptographic 64-bit hash for 6 longs.
      *
      * @param x0
      * 		a long
@@ -149,7 +155,7 @@ public static long hash64(
     }
 
     /**
-     * Generates a non-cryptographic 64 bit hash for 7 longs.
+     * Generates a non-cryptographic 64-bit hash for 7 longs.
      *
      * @param x0
      * 		a long
@@ -177,7 +183,7 @@ public static long hash64(
     }
 
     /**
-     * Generates a non-cryptographic 64 bit hash for 8 longs.
+     * Generates a non-cryptographic 64-bit hash for 8 longs.
      *
      * @param x0
      * 		a long
@@ -217,7 +223,7 @@ public static long hash64(
     }
 
     /**
-     * Generates a non-cryptographic 64 bit hash for 9 longs.
+     * Generates a non-cryptographic 64-bit hash for 9 longs.
      *
      * @param x0
      * 		a long
@@ -262,7 +268,7 @@ public static long hash64(
     }
 
     /**
-     * Generates a non-cryptographic 64 bit hash for 10 longs.
+     * Generates a non-cryptographic 64-bit hash for 10 longs.
      *
      * @param x0
      * 		a long
@@ -312,7 +318,7 @@ public static long hash64(
     }
 
     /**
-     * Generates a non-cryptographic 64 bit hash for an array of longs.
+     * Generates a non-cryptographic 64-bit hash for an array of longs.
      *
      * @param x
      * 		an array of longs
@@ -327,7 +333,7 @@ public static long hash64(@NonNull final long... x) {
     }
 
     /**
-     * Generates a non-cryptographic 32 bit hash for 1 long.
+     * Generates a non-cryptographic 32-bit hash for 1 long.
      *
      * @param x0
      * 		a long
@@ -339,7 +345,7 @@ public static int hash32(final long x0) {
     }
 
     /**
-     * Generates a non-cryptographic 32 bit hash for 2 longs.
+     * Generates a non-cryptographic 32-bit hash for 2 longs.
      *
      * @param x0
      * 		a long
@@ -352,7 +358,7 @@ public static int hash32(final long x0, final long x1) {
     }
 
     /**
-     * Generates a non-cryptographic 32 bit hash for 3 longs.
+     * Generates a non-cryptographic 32-bit hash for 3 longs.
      *
      * @param x0
      * 		a long
@@ -367,7 +373,7 @@ public static int hash32(final long x0, final long x1, final long x2) {
     }
 
     /**
-     * Generates a non-cryptographic 32 bit hash for 4 longs.
+     * Generates a non-cryptographic 32-bit hash for 4 longs.
      *
      * @param x0
      * 		a long
@@ -384,7 +390,7 @@ public static int hash32(final long x0, final long x1, final long x2, final long
     }
 
     /**
-     * Generates a non-cryptographic 32 bit hash for 5 longs.
+     * Generates a non-cryptographic 32-bit hash for 5 longs.
      *
      * @param x0
      * 		a long
@@ -403,7 +409,7 @@ public static int hash32(final long x0, final long x1, final long x2, final long
     }
 
     /**
-     * Generates a non-cryptographic 32 bit hash for 6 longs.
+     * Generates a non-cryptographic 32-bit hash for 6 longs.
      *
      * @param x0
      * 		a long
@@ -424,7 +430,7 @@ public static int hash32(final long x0, final long x1, final long x2, final long
     }
 
     /**
-     * Generates a non-cryptographic 32 bit hash for 7 longs.
+     * Generates a non-cryptographic 32-bit hash for 7 longs.
      *
      * @param x0
      * 		a long
@@ -448,7 +454,7 @@ public static int hash32(
     }
 
     /**
-     * Generates a non-cryptographic 32 bit hash for 8 longs.
+     * Generates a non-cryptographic 32-bit hash for 8 longs.
      *
      * @param x0
      * 		a long
@@ -481,7 +487,7 @@ public static int hash32(
     }
 
     /**
-     * Generates a non-cryptographic 32 bit hash for 9 longs.
+     * Generates a non-cryptographic 32-bit hash for 9 longs.
      *
      * @param x0
      * 		a long
@@ -517,7 +523,7 @@ public static int hash32(
     }
 
     /**
-     * Generates a non-cryptographic 32 bit hash for 10 longs.
+     * Generates a non-cryptographic 32-bit hash for 10 longs.
      *
      * @param x0
      * 		a long
@@ -556,7 +562,7 @@ public static int hash32(
     }
 
     /**
-     * Generates a non-cryptographic 32 bit hash for an array of longs.
+     * Generates a non-cryptographic 32-bit hash for an array of longs.
      *
      * @param x
      * 		an array of longs
@@ -567,7 +573,7 @@ public static int hash32(@NonNull final long... x) {
     }
 
     /**
-     * Generates a non-cryptographic 64 bit hash for a byte array.
+     * Generates a non-cryptographic 64-bit hash for a byte array.
      *
      * @param bytes
      * 		a byte array
@@ -578,7 +584,7 @@ public static long hash64(@NonNull final byte[] bytes) {
     }
 
     /**
-     * Generates a non-cryptographic 64 bit hash for a byte array.
+     * Generates a non-cryptographic 64-bit hash for a byte array.
      *
      * @param bytes
      * 		a byte array
@@ -590,9 +596,14 @@ public static long hash64(@NonNull final byte[] bytes) {
      */
     public static long hash64(@NonNull final byte[] bytes, int start, int length) {
         long hash = perm64(computeMixin(DataType.BYTE_ARRAY, length));
-        for (int i = start; i < length; i += 8) {
+        int i = start;
+        for (; i < length; i += 8) {
             hash = perm64(hash ^ byteArrayToLong(bytes, i));
         }
+
+        if (i != start + length) {
+            hash = perm64(hash ^ 0xFF00000000000000L);
+        }
         return hash;
     }
 
@@ -618,9 +629,14 @@ public static long hash64(@NonNull final String string) {
         final byte[] bytes = getNormalisedStringBytes(string);
 
         long hash = perm64(computeMixin(DataType.STRING, bytes.length));
-        for (int i = 0; i < bytes.length; i += 8) {
+        int i = 0;
+        for (; i < bytes.length; i += 8) {
             hash = perm64(hash ^ byteArrayToLong(bytes, i));
         }
+
+        if (i != bytes.length) {
+            hash = perm64(hash ^ 0xFF00000000000000L);
+        }
         return hash;
     }
 
@@ -688,21 +704,15 @@ private static long perm64(long x) {
      */
     public static long byteArrayToLong(final byte[] data, final int position) {
         if (data.length > position + 8) {
-            // Hard coded constants are used instead of a for loop to reduce the arithmetic required at runtime
-            return ((data[position] & 0xffL) << (8 * 7))
-                    + ((data[position + 1] & 0xffL) << (8 * 6))
-                    + ((data[position + 2] & 0xffL) << (8 * 5))
-                    + ((data[position + 3] & 0xffL) << (8 * 4))
-                    + ((data[position + 4] & 0xffL) << (8 * 3))
-                    + ((data[position + 5] & 0xffL) << (8 * 2))
-                    + ((data[position + 6] & 0xffL) << (8))
-                    + (data[position + 7] & 0xffL);
+            // Fast path: there is enough data to fill the long.
+            return UnsafeUtils.getLong(data, position);
         } else {
-            // There isn't enough data to fill the long, so pad with zeros.
+            // There isn't enough data to fill the long, so pad with 0xFF followed by zeros.
             long result = 0;
             for (int offset = 0; offset < 8; offset++) {
                 final int index = position + offset;
                 if (index >= data.length) {
+                    result += 0xFFL << 8 * (7 - offset);
                     break;
                 }
                 result += (data[index] & 0xffL) << (8 * (7 - offset));
@@ -725,6 +735,6 @@ public static byte[] getNormalisedStringBytes(final String s) {
         if (s == null) {
             return null;
         }
-        return Normalizer.normalize(s, Normalizer.Form.NFD).getBytes(CommonUtils.DEFAULT_CHARSET);
+        return Normalizer.normalize(s, Normalizer.Form.NFD).getBytes(StandardCharsets.UTF_8);
     }
 }
diff --git a/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashTest.java b/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashTest.java
new file mode 100644
index 00000000..588a7bb0
--- /dev/null
+++ b/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashTest.java
@@ -0,0 +1,586 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.runtime.io.buffer;
+
+import static com.hedera.pbj.runtime.io.buffer.NonCryptographicHashing.hash32;
+import static com.hedera.pbj.runtime.io.buffer.NonCryptographicHashing.hash64;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+
+import edu.umd.cs.findbugs.annotations.NonNull;
+import java.util.Random;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+@DisplayName("Non-Cryptographic Hash Test")
+class NonCryptographicHashTest {
+
+    /**
+     * This test does not attempt to verify statistical properties of the hash functions.
+     * Its purpose is to ensure that none of the methods cause a crash.
+     */
+    @DisplayName("Test hash32")
+    @Test
+    void testHash32() {
+        final long seed = 842025;
+        final Random random = new Random(seed);
+
+        assertDoesNotThrow(() -> {
+            hash32(random.nextInt());
+            hash32(random.nextInt(), random.nextInt());
+            hash32(random.nextInt(), random.nextInt(), random.nextInt());
+            hash32(random.nextInt(), random.nextInt(), random.nextInt(), random.nextInt());
+            hash32(random.nextInt(), random.nextInt(), random.nextInt(), random.nextInt(), random.nextInt());
+            hash32(
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt());
+            hash32(
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt());
+            hash32(
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt());
+            hash32(
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt());
+            hash32(
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt());
+            hash32(
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt());
+            hash32(
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt());
+
+            hash32(random.nextLong());
+            hash32(random.nextLong(), random.nextLong());
+            hash32(random.nextLong(), random.nextLong(), random.nextLong());
+            hash32(random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong());
+            hash32(random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong());
+            hash32(
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong());
+            hash32(
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong());
+            hash32(
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong());
+            hash32(
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong());
+            hash32(
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong());
+            hash32(
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong());
+            hash32(
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong());
+
+            for (int i = 0; i < 100; i++) {
+                final byte[] bytes = new byte[i];
+                hash32(bytes);
+
+                final String string = randomString(random, i);
+                hash32(string);
+            }
+        });
+    }
+
+    /**
+     * This test does not attempt to verify statistical properties of the hash functions.
+     * Its purpose is to ensure that none of the methods cause a crash.
+     */
+    @DisplayName("Test hash64")
+    @Test
+    void testHash64() {
+        final long seed = 842025;
+        final Random random = new Random(seed);
+
+        assertDoesNotThrow(() -> {
+            hash64(random.nextInt());
+            hash64(random.nextInt(), random.nextInt());
+            hash64(random.nextInt(), random.nextInt(), random.nextInt());
+            hash64(random.nextInt(), random.nextInt(), random.nextInt(), random.nextInt());
+            hash64(random.nextInt(), random.nextInt(), random.nextInt(), random.nextInt(), random.nextInt());
+            hash64(
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt());
+            hash64(
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt());
+            hash64(
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt());
+            hash64(
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt());
+            hash64(
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt());
+            hash64(
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt());
+            hash64(
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt(),
+                    random.nextInt());
+
+            hash64(random.nextLong());
+            hash64(random.nextLong(), random.nextLong());
+            hash64(random.nextLong(), random.nextLong(), random.nextLong());
+            hash64(random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong());
+            hash64(random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong());
+            hash64(
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong());
+            hash64(
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong());
+            hash64(
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong());
+            hash64(
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong());
+            hash64(
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong());
+            hash64(
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong());
+            hash64(
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong(),
+                    random.nextLong());
+
+            for (int i = 0; i < 100; i++) {
+                final byte[] bytes = new byte[i];
+                hash64(bytes);
+
+                final String string = randomString(random, i);
+                hash64(string);
+            }
+        });
+    }
+
+    @DisplayName("Hashes Are Not Degenerate 32")
+    @Test
+    void hashesAreNonDegenerate32() {
+        final long seed = 842025;
+        final Random random = new Random(seed);
+
+        assertNotEquals(0, hash32(0));
+        assertNotEquals(0, hash32(0, 0));
+        assertNotEquals(0, hash32(0, 0, 0));
+        assertNotEquals(0, hash32(0, 0, 0));
+        assertNotEquals(0, hash32(0, 0, 0, 0));
+        assertNotEquals(0, hash32(0, 0, 0, 0, 0));
+        assertNotEquals(0, hash32(0, 0, 0, 0, 0, 0));
+        assertNotEquals(0, hash32(0, 0, 0, 0, 0, 0, 0));
+        assertNotEquals(0, hash32(0, 0, 0, 0, 0, 0, 0, 0));
+        assertNotEquals(0, hash32(0, 0, 0, 0, 0, 0, 0, 0, 0));
+        assertNotEquals(0, hash32(0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+        assertNotEquals(0, hash32(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+
+        assertNotEquals(0, hash32(random.nextLong()));
+        assertNotEquals(0, hash32(random.nextLong(), random.nextLong()));
+        assertNotEquals(0, hash32(random.nextLong(), random.nextLong(), random.nextLong()));
+        assertNotEquals(0, hash32(random.nextLong(), random.nextLong(), random.nextLong()));
+        assertNotEquals(0, hash32(random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong()));
+        assertNotEquals(
+                0,
+                hash32(random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong()));
+        assertNotEquals(
+                0,
+                hash32(
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong()));
+        assertNotEquals(
+                0,
+                hash32(
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong()));
+        assertNotEquals(
+                0,
+                hash32(
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong()));
+        assertNotEquals(
+                0,
+                hash32(
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong()));
+        assertNotEquals(
+                0,
+                hash32(
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong()));
+        assertNotEquals(
+                0,
+                hash32(
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong()));
+
+        for (int i = 0; i < 100; i++) {
+            final byte[] bytes = new byte[i];
+            assertNotEquals(0, hash32(bytes), "Hashes should be non-degenerate");
+
+            final String string = randomString(random, i);
+            assertNotEquals(0, hash32(string), "Hashes should be non-degenerate");
+        }
+    }
+
+    @DisplayName("Hashes Are Not Degenerate 64")
+    @Test
+    void hashesAreNonDegenerate64() {
+        final long seed = 842025;
+        final Random random = new Random(seed);
+
+        assertNotEquals(0, hash64(0));
+        assertNotEquals(0, hash64(0, 0));
+        assertNotEquals(0, hash64(0, 0, 0));
+        assertNotEquals(0, hash64(0, 0, 0));
+        assertNotEquals(0, hash64(0, 0, 0, 0));
+        assertNotEquals(0, hash64(0, 0, 0, 0, 0));
+        assertNotEquals(0, hash64(0, 0, 0, 0, 0, 0));
+        assertNotEquals(0, hash64(0, 0, 0, 0, 0, 0, 0));
+        assertNotEquals(0, hash64(0, 0, 0, 0, 0, 0, 0, 0));
+        assertNotEquals(0, hash64(0, 0, 0, 0, 0, 0, 0, 0, 0));
+        assertNotEquals(0, hash64(0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+        assertNotEquals(0, hash64(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+
+        assertNotEquals(0, hash64(random.nextLong()));
+        assertNotEquals(0, hash64(random.nextLong(), random.nextLong()));
+        assertNotEquals(0, hash64(random.nextLong(), random.nextLong(), random.nextLong()));
+        assertNotEquals(0, hash64(random.nextLong(), random.nextLong(), random.nextLong()));
+        assertNotEquals(0, hash64(random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong()));
+        assertNotEquals(
+                0,
+                hash64(random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong()));
+        assertNotEquals(
+                0,
+                hash64(
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong()));
+        assertNotEquals(
+                0,
+                hash64(
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong()));
+        assertNotEquals(
+                0,
+                hash64(
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong()));
+        assertNotEquals(
+                0,
+                hash64(
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong()));
+        assertNotEquals(
+                0,
+                hash64(
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong()));
+        assertNotEquals(
+                0,
+                hash64(
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong(),
+                        random.nextLong()));
+
+        for (int i = 0; i < 100; i++) {
+            final byte[] bytes = new byte[i];
+            assertNotEquals(0, hash64(bytes), "Hashes should be non-degenerate");
+
+            final String string = randomString(random, i);
+            assertNotEquals(0, hash64(string), "Hashes should be non-degenerate");
+        }
+    }
+
+    public static @NonNull String randomString(@NonNull final Random random, final int length) {
+        final int LEFT_LIMIT = 48; // numeral '0'
+        final int RIGHT_LIMIT = 122; // letter 'z'
+
+        return random.ints(LEFT_LIMIT, RIGHT_LIMIT + 1)
+                .filter(i -> (i <= 57 || i >= 65) && (i <= 90 || i >= 97))
+                .limit(length)
+                .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
+                .toString();
+    }
+
+}

From 25a035e078dde067774ab7ab4c585827b7be8bfc Mon Sep 17 00:00:00 2001
From: Richard Bair <rbair23@users.noreply.github.com>
Date: Mon, 4 Aug 2025 14:58:03 -0700
Subject: [PATCH 03/17] Remove specialized code and string

Signed-off-by: Richard Bair <rbair23@users.noreply.github.com>
---
 .../io/buffer/NonCryptographicHashing.java    | 64 +------------------
 1 file changed, 2 insertions(+), 62 deletions(-)

diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashing.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashing.java
index 9a46eedf..89b40788 100644
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashing.java
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashing.java
@@ -2,9 +2,6 @@
 
 import com.hedera.pbj.runtime.io.UnsafeUtils;
 import edu.umd.cs.findbugs.annotations.NonNull;
-import edu.umd.cs.findbugs.annotations.Nullable;
-import java.nio.charset.StandardCharsets;
-import java.text.Normalizer;
 
 /**
  * <p>
@@ -596,14 +593,9 @@ public static long hash64(@NonNull final byte[] bytes) {
      */
     public static long hash64(@NonNull final byte[] bytes, int start, int length) {
         long hash = perm64(computeMixin(DataType.BYTE_ARRAY, length));
-        int i = start;
-        for (; i < length; i += 8) {
+        for (int i = start; i < length; i += 8) {
             hash = perm64(hash ^ byteArrayToLong(bytes, i));
         }
-
-        if (i != start + length) {
-            hash = perm64(hash ^ 0xFF00000000000000L);
-        }
         return hash;
     }
 
@@ -618,39 +610,6 @@ public static long hash32(@NonNull final byte[] bytes) {
         return (int) hash64(bytes);
     }
 
-    /**
-     * Generates a non-cryptographic 64 bit hash from the normalized bytes of a string.
-     *
-     * @param string
-     * 		a string
-     * @return a non-cryptographic long hash
-     */
-    public static long hash64(@NonNull final String string) {
-        final byte[] bytes = getNormalisedStringBytes(string);
-
-        long hash = perm64(computeMixin(DataType.STRING, bytes.length));
-        int i = 0;
-        for (; i < bytes.length; i += 8) {
-            hash = perm64(hash ^ byteArrayToLong(bytes, i));
-        }
-
-        if (i != bytes.length) {
-            hash = perm64(hash ^ 0xFF00000000000000L);
-        }
-        return hash;
-    }
-
-    /**
-     * Generates a non-cryptographic 32 bit hash for a string.
-     *
-     * @param string
-     * 		a string
-     * @return a non-cryptographic int hash
-     */
-    public static int hash32(@NonNull final String string) {
-        return (int) hash64(string);
-    }
-
     /**
      * <p>
      * A permutation (invertible function) on 64 bits.
@@ -704,15 +663,13 @@ private static long perm64(long x) {
      */
     public static long byteArrayToLong(final byte[] data, final int position) {
         if (data.length > position + 8) {
-            // Fast path: there is enough data to fill the long.
             return UnsafeUtils.getLong(data, position);
         } else {
-            // There isn't enough data to fill the long, so pad with 0xFF followed by zeros.
+            // There isn't enough data to fill the long, so pad with zeros.
             long result = 0;
             for (int offset = 0; offset < 8; offset++) {
                 final int index = position + offset;
                 if (index >= data.length) {
-                    result += 0xFFL << 8 * (7 - offset);
                     break;
                 }
                 result += (data[index] & 0xffL) << (8 * (7 - offset));
@@ -720,21 +677,4 @@ public static long byteArrayToLong(final byte[] data, final int position) {
             return result;
         }
     }
-
-    /**
-     * Normalizes the string in accordance with the Swirlds default normalization method (NFD) and returns the bytes of
-     * that normalized String encoded in the Swirlds default charset (UTF8). This is important for having a consistent
-     * method of converting Strings to bytes that will guarantee that two identical strings will have an identical byte
-     * representation
-     *
-     * @param s the String to be converted to bytes
-     * @return a byte representation of the String
-     */
-    @Nullable
-    public static byte[] getNormalisedStringBytes(final String s) {
-        if (s == null) {
-            return null;
-        }
-        return Normalizer.normalize(s, Normalizer.Form.NFD).getBytes(StandardCharsets.UTF_8);
-    }
 }

From e8abcf51ab00fc8df7ebeeb18659afb96c1ed7e6 Mon Sep 17 00:00:00 2001
From: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
Date: Mon, 4 Aug 2025 15:18:27 -0700
Subject: [PATCH 04/17] Move NonCryptographicHashing to public runtime ready
 for use in generated code and cleanup unneeded methods

Signed-off-by: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
---
 .../pbj/runtime/NonCryptographicHashing.java  | 121 ++++
 .../hedera/pbj/runtime/io/buffer/Bytes.java   |   9 +-
 .../io/buffer/NonCryptographicHashing.java    | 680 ------------------
 .../pbj/runtime/NonCryptographicHashTest.java |  49 ++
 .../io/buffer/NonCryptographicHashTest.java   | 586 ---------------
 5 files changed, 175 insertions(+), 1270 deletions(-)
 create mode 100644 pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
 delete mode 100644 pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashing.java
 create mode 100644 pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
 delete mode 100644 pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashTest.java

diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
new file mode 100644
index 00000000..14beb35f
--- /dev/null
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
@@ -0,0 +1,121 @@
+package com.hedera.pbj.runtime;
+
+import com.hedera.pbj.runtime.io.UnsafeUtils;
+import edu.umd.cs.findbugs.annotations.NonNull;
+
+/**
+ * This class contains a collection of methods for hashing basic data types.
+ * Hashes are not cryptographically secure, and are intended to be used when
+ * implementing {@link Object#hashCode()} or similar functionality.
+ */
+public final class NonCryptographicHashing {
+    // This class is not meant to be instantiated.
+    private NonCryptographicHashing() {}
+
+    /**
+     * Generates a non-cryptographic 64-bit hash for 1 long.
+     *
+     * @param x0 a single long
+     * @return a non-cryptographic long hash
+     */
+    public static long hash64(final long x0) {
+        return perm64(x0);
+    }
+
+    /**
+     * Generates a non-cryptographic 64-bit hash for a byte array.
+     *
+     * @param bytes
+     * 		a byte array
+     * @return a non-cryptographic long hash
+     */
+    public static long hash64(@NonNull final byte[] bytes) {
+        return hash64(bytes, 0, bytes.length);
+    }
+
+    /**
+     * Generates a non-cryptographic 64-bit hash for a byte array.
+     *
+     * @param bytes
+     * 		a byte array
+     * @param start
+     *         the start index in the byte array
+     * @param length
+     *         the number of bytes to hash
+     * @return a non-cryptographic long hash
+     */
+    public static long hash64(@NonNull final byte[] bytes, int start, int length) {
+        long hash = perm64(length);
+        for (int i = start; i < length; i += 8) {
+            hash = perm64(hash ^ byteArrayToLong(bytes, i));
+        }
+        return hash;
+    }
+
+    /**
+     * <p>
+     * A permutation (invertible function) on 64 bits.
+     * The constants were found by automated search, to
+     * optimize avalanche. Avalanche means that for a
+     * random number x, flipping bit i of x has about a
+     * 50 percent chance of flipping bit j of perm64(x).
+     * For each possible pair (i,j), this function achieves
+     * a probability between 49.8 and 50.2 percent.
+     * </p>
+     *
+     * <p>
+     * Leemon wrote this, it's magic and does magic things. Like holy molly does
+     * this algorithm resolve some nasty hash collisions for troublesome data sets.
+     * Don't mess with this method.
+     *
+     * <p>
+     * Warning: there currently exist production use cases that will break if this hashing algorithm is changed.
+     * If modifications to this hashing algorithm are ever required, we will need to "fork" this class and leave
+     * the old algorithm intact.
+     */
+    private static long perm64(long x) {
+        // This is necessary so that 0 does not hash to 0.
+        // As a side effect, this constant will hash to 0.
+        // It was randomly generated (not using Java),
+        // so that it will occur in practice less often than more
+        // common numbers like 0 or -1 or Long.MAX_VALUE.
+        x ^= 0x5e8a016a5eb99c18L;
+
+        // Shifts: {30, 27, 16, 20, 5, 18, 10, 24, 30}
+        x += x << 30;
+        x ^= x >>> 27;
+        x += x << 16;
+        x ^= x >>> 20;
+        x += x << 5;
+        x ^= x >>> 18;
+        x += x << 10;
+        x ^= x >>> 24;
+        x += x << 30;
+        return x;
+    }
+
+    /**
+     * Return a long derived from the 8 bytes data[position]...data[position+7], big endian. If the byte array is not
+     * long enough, zeros are substituted for the missing bytes.
+     *
+     * @param data     an array of bytes
+     * @param position the first byte in the array to use
+     * @return the 8 bytes starting at position, converted to a long, big endian
+     */
+    public static long byteArrayToLong(final byte[] data, final int position) {
+        if (data.length > position + 8) {
+            return UnsafeUtils.getLong(data, position);
+        } else {
+            // There isn't enough data to fill the long, so pad with zeros.
+            long result = 0;
+            for (int offset = 0; offset < 8; offset++) {
+                final int index = position + offset;
+                if (index >= data.length) {
+                    break;
+                }
+                result += (data[index] & 0xffL) << (8 * (7 - offset));
+            }
+            return result;
+        }
+    }
+}
diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/Bytes.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/Bytes.java
index b4a61e70..6307fac2 100644
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/Bytes.java
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/Bytes.java
@@ -3,6 +3,7 @@
 
 import static java.util.Objects.requireNonNull;
 
+import com.hedera.pbj.runtime.NonCryptographicHashing;
 import com.hedera.pbj.runtime.io.DataEncodingException;
 import com.hedera.pbj.runtime.io.ReadableSequentialData;
 import com.hedera.pbj.runtime.io.UnsafeUtils;
@@ -111,7 +112,7 @@ private Bytes(@NonNull final byte[] data, final int offset, final int length) {
 
     /**
      * Create a new {@link Bytes} over the contents of the given byte array. This does not copy data it just
-     * wraps so any changes to array's contents will be visible in the returned result.
+     * wraps, so any changes to array's contents will be visible in the returned result.
      *
      * @param byteArray The byte array to wrap
      * @return new {@link Bytes} with same contents as byte array
@@ -192,9 +193,9 @@ public static Bytes merge(@NonNull final Bytes bytes1, @NonNull final Bytes byte
     /**
      * Returns the first byte offset of {@code needle} inside {@code haystack},
      * or –1 if it is not present.
-     *
-     * Offsets are *relative to the start of the Bytes slice*, so 0 means
-     * “starts exactly at haystack.start”.
+     * <p>
+     * Offsets are <b>relative to the start of the Bytes slice</b>, so 0 means “starts exactly at haystack.start”.
+     * </p>
      */
     public static int indexOf(@NonNull final Bytes haystack, @NonNull final Bytes needle) {
         requireNonNull(haystack);
diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashing.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashing.java
deleted file mode 100644
index 89b40788..00000000
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashing.java
+++ /dev/null
@@ -1,680 +0,0 @@
-package com.hedera.pbj.runtime.io.buffer;
-
-import com.hedera.pbj.runtime.io.UnsafeUtils;
-import edu.umd.cs.findbugs.annotations.NonNull;
-
-/**
- * <p>
- * This class contains a collection of methods for hashing basic data types.
- * Hashes are not cryptographically secure, and are intended to be used when
- * implementing {@link Object#hashCode()} or similar functionality.
- * </p>
- *
- * <p>
- * This class provides a large number of methods with different signatures, the goal being to avoid the
- * creation of arrays to pass a variable number of arguments. Hashing happens a lot and needs to be fast,
- * so if we can avoid lots of extra allocations it is worthwhile.
- * </p>
- */
-final class NonCryptographicHashing {
-
-    private NonCryptographicHashing() {}
-
-    /**
-     * <p>
-     * Data types that can be hashed.
-     * </p>
-     *
-     * <p>
-     * WARNING: only add to the end of this list.
-     * Do not change or remove or reorder any existing elements, or it will change the hashes.
-     * </p>
-     */
-    private enum DataType {
-        LONG,
-        LONG_ARRAY,
-        BYTE_ARRAY,
-        STRING
-    }
-
-    /**
-     * For every hash, mix in a long derived from the data type and the length of the data.
-     * This causes the hashes for different data types and different lengths of data to differ
-     * with moderately high probability.
-     *
-     * @param type
-     * 		the type of the data
-     * @param length
-     * 		the length of the data
-     * @return a long to mix into the hash
-     */
-    private static long computeMixin(@NonNull final DataType type, final long length) {
-        return ((long) type.ordinal()) | (length << 32);
-    }
-
-    /**
-     * Generates a non-cryptographic 64-bit hash for 1 long.
-     *
-     * @param x0
-     * 		a long
-     * @return a non-cryptographic long hash
-     */
-    public static long hash64(final long x0) {
-        return perm64(perm64(computeMixin(DataType.LONG, 1)) ^ x0);
-    }
-
-    /**
-     * Generates a non-cryptographic 64-bit hash for 2 longs.
-     *
-     * @param x0
-     * 		a long
-     * @param x1
-     * 		a long
-     * @return a non-cryptographic long hash
-     */
-    public static long hash64(final long x0, final long x1) {
-        return perm64(perm64(perm64(computeMixin(DataType.LONG, 2)) ^ x0) ^ x1);
-    }
-
-    /**
-     * Generates a non-cryptographic 64-bit hash for 3 longs.
-     *
-     * @param x0
-     * 		a long
-     * @param x1
-     * 		a long
-     * @param x2
-     * 		a long
-     * @return a non-cryptographic long hash
-     */
-    public static long hash64(final long x0, final long x1, final long x2) {
-        return perm64(perm64(perm64(perm64(computeMixin(DataType.LONG, 3)) ^ x0) ^ x1) ^ x2);
-    }
-
-    /**
-     * Generates a non-cryptographic 64-bit hash for 4 longs.
-     *
-     * @param x0
-     * 		a long
-     * @param x1
-     * 		a long
-     * @param x2
-     * 		a long
-     * @param x3
-     * 		a long
-     * @return a non-cryptographic long hash
-     */
-    public static long hash64(final long x0, final long x1, final long x2, final long x3) {
-        return perm64(perm64(perm64(perm64(perm64(computeMixin(DataType.LONG, 4)) ^ x0) ^ x1) ^ x2) ^ x3);
-    }
-
-    /**
-     * Generates a non-cryptographic 64-bit hash for 5 longs.
-     *
-     * @param x0
-     * 		a long
-     * @param x1
-     * 		a long
-     * @param x2
-     * 		a long
-     * @param x3
-     * 		a long
-     * @param x4
-     * 		a long
-     * @return a non-cryptographic long hash
-     */
-    public static long hash64(final long x0, final long x1, final long x2, final long x3, final long x4) {
-        return perm64(perm64(perm64(perm64(perm64(perm64(computeMixin(DataType.LONG, 5)) ^ x0) ^ x1) ^ x2) ^ x3) ^ x4);
-    }
-
-    /**
-     * Generates a non-cryptographic 64-bit hash for 6 longs.
-     *
-     * @param x0
-     * 		a long
-     * @param x1
-     * 		a long
-     * @param x2
-     * 		a long
-     * @param x3
-     * 		a long
-     * @param x4
-     * 		a long
-     * @param x5
-     * 		a long
-     * @return a non-cryptographic long hash
-     */
-    public static long hash64(
-            final long x0, final long x1, final long x2, final long x3, final long x4, final long x5) {
-        return perm64(
-                perm64(perm64(perm64(perm64(perm64(perm64(computeMixin(DataType.LONG, 6)) ^ x0) ^ x1) ^ x2) ^ x3) ^ x4)
-                        ^ x5);
-    }
-
-    /**
-     * Generates a non-cryptographic 64-bit hash for 7 longs.
-     *
-     * @param x0
-     * 		a long
-     * @param x1
-     * 		a long
-     * @param x2
-     * 		a long
-     * @param x3
-     * 		a long
-     * @param x4
-     * 		a long
-     * @param x5
-     * 		a long
-     * @param x6
-     * 		a long
-     * @return a non-cryptographic long hash
-     */
-    public static long hash64(
-            final long x0, final long x1, final long x2, final long x3, final long x4, final long x5, final long x6) {
-        return perm64(
-                perm64(perm64(perm64(perm64(perm64(perm64(perm64(computeMixin(DataType.LONG, 7)) ^ x0) ^ x1) ^ x2) ^ x3)
-                        ^ x4)
-                        ^ x5)
-                        ^ x6);
-    }
-
-    /**
-     * Generates a non-cryptographic 64-bit hash for 8 longs.
-     *
-     * @param x0
-     * 		a long
-     * @param x1
-     * 		a long
-     * @param x2
-     * 		a long
-     * @param x3
-     * 		a long
-     * @param x4
-     * 		a long
-     * @param x5
-     * 		a long
-     * @param x6
-     * 		a long
-     * @param x7
-     * 		a long
-     * @return a non-cryptographic long hash
-     */
-    public static long hash64(
-            final long x0,
-            final long x1,
-            final long x2,
-            final long x3,
-            final long x4,
-            final long x5,
-            final long x6,
-            final long x7) {
-        return perm64(
-                perm64(perm64(perm64(perm64(perm64(perm64(perm64(perm64(computeMixin(DataType.LONG, 8)) ^ x0) ^ x1)
-                        ^ x2)
-                        ^ x3)
-                        ^ x4)
-                        ^ x5)
-                        ^ x6)
-                        ^ x7);
-    }
-
-    /**
-     * Generates a non-cryptographic 64-bit hash for 9 longs.
-     *
-     * @param x0
-     * 		a long
-     * @param x1
-     * 		a long
-     * @param x2
-     * 		a long
-     * @param x3
-     * 		a long
-     * @param x4
-     * 		a long
-     * @param x5
-     * 		a long
-     * @param x6
-     * 		a long
-     * @param x7
-     * 		a long
-     * @param x8
-     * 		a long
-     * @return a non-cryptographic long hash
-     */
-    public static long hash64(
-            final long x0,
-            final long x1,
-            final long x2,
-            final long x3,
-            final long x4,
-            final long x5,
-            final long x6,
-            final long x7,
-            final long x8) {
-        return perm64(
-                perm64(perm64(perm64(perm64(perm64(perm64(perm64(perm64(perm64(computeMixin(DataType.LONG, 9)) ^ x0)
-                        ^ x1)
-                        ^ x2)
-                        ^ x3)
-                        ^ x4)
-                        ^ x5)
-                        ^ x6)
-                        ^ x7)
-                        ^ x8);
-    }
-
-    /**
-     * Generates a non-cryptographic 64-bit hash for 10 longs.
-     *
-     * @param x0
-     * 		a long
-     * @param x1
-     * 		a long
-     * @param x2
-     * 		a long
-     * @param x3
-     * 		a long
-     * @param x4
-     * 		a long
-     * @param x5
-     * 		a long
-     * @param x6
-     * 		a long
-     * @param x7
-     * 		a long
-     * @param x8
-     * 		a long
-     * @param x9
-     * 		a long
-     * @return a non-cryptographic long hash
-     */
-    public static long hash64(
-            final long x0,
-            final long x1,
-            final long x2,
-            final long x3,
-            final long x4,
-            final long x5,
-            final long x6,
-            final long x7,
-            final long x8,
-            final long x9) {
-        return perm64(
-                perm64(perm64(perm64(perm64(perm64(perm64(perm64(perm64(perm64(perm64(computeMixin(DataType.LONG, 10))
-                        ^ x0)
-                        ^ x1)
-                        ^ x2)
-                        ^ x3)
-                        ^ x4)
-                        ^ x5)
-                        ^ x6)
-                        ^ x7)
-                        ^ x8)
-                        ^ x9);
-    }
-
-    /**
-     * Generates a non-cryptographic 64-bit hash for an array of longs.
-     *
-     * @param x
-     * 		an array of longs
-     * @return a non-cryptographic integer hash
-     */
-    public static long hash64(@NonNull final long... x) {
-        long t = perm64(computeMixin(DataType.LONG_ARRAY, x.length));
-        for (final long l : x) {
-            t = perm64(t ^ l);
-        }
-        return t;
-    }
-
-    /**
-     * Generates a non-cryptographic 32-bit hash for 1 long.
-     *
-     * @param x0
-     * 		a long
-     * @return a non-cryptographic integer hash
-     */
-    public static int hash32(final long x0) {
-
-        return (int) hash64(x0);
-    }
-
-    /**
-     * Generates a non-cryptographic 32-bit hash for 2 longs.
-     *
-     * @param x0
-     * 		a long
-     * @param x1
-     * 		a long
-     * @return a non-cryptographic integer hash
-     */
-    public static int hash32(final long x0, final long x1) {
-        return (int) hash64(x0, x1);
-    }
-
-    /**
-     * Generates a non-cryptographic 32-bit hash for 3 longs.
-     *
-     * @param x0
-     * 		a long
-     * @param x1
-     * 		a long
-     * @param x2
-     * 		a long
-     * @return a non-cryptographic integer hash
-     */
-    public static int hash32(final long x0, final long x1, final long x2) {
-        return (int) hash64(x0, x1, x2);
-    }
-
-    /**
-     * Generates a non-cryptographic 32-bit hash for 4 longs.
-     *
-     * @param x0
-     * 		a long
-     * @param x1
-     * 		a long
-     * @param x2
-     * 		a long
-     * @param x3
-     * 		a long
-     * @return a non-cryptographic integer hash
-     */
-    public static int hash32(final long x0, final long x1, final long x2, final long x3) {
-        return (int) hash64(x0, x1, x2, x3);
-    }
-
-    /**
-     * Generates a non-cryptographic 32-bit hash for 5 longs.
-     *
-     * @param x0
-     * 		a long
-     * @param x1
-     * 		a long
-     * @param x2
-     * 		a long
-     * @param x3
-     * 		a long
-     * @param x4
-     * 		a long
-     * @return a non-cryptographic integer hash
-     */
-    public static int hash32(final long x0, final long x1, final long x2, final long x3, final long x4) {
-        return (int) hash64(x0, x1, x2, x3, x4);
-    }
-
-    /**
-     * Generates a non-cryptographic 32-bit hash for 6 longs.
-     *
-     * @param x0
-     * 		a long
-     * @param x1
-     * 		a long
-     * @param x2
-     * 		a long
-     * @param x3
-     * 		a long
-     * @param x4
-     * 		a long
-     * @param x5
-     * 		a long
-     * @return a non-cryptographic integer hash
-     */
-    public static int hash32(final long x0, final long x1, final long x2, final long x3, final long x4, final long x5) {
-        return (int) hash64(x0, x1, x2, x3, x4, x5);
-    }
-
-    /**
-     * Generates a non-cryptographic 32-bit hash for 7 longs.
-     *
-     * @param x0
-     * 		a long
-     * @param x1
-     * 		a long
-     * @param x2
-     * 		a long
-     * @param x3
-     * 		a long
-     * @param x4
-     * 		a long
-     * @param x5
-     * 		a long
-     * @param x6
-     * 		a long
-     * @return a non-cryptographic integer hash
-     */
-    public static int hash32(
-            final long x0, final long x1, final long x2, final long x3, final long x4, final long x5, final long x6) {
-        return (int) hash64(x0, x1, x2, x3, x4, x5, x6);
-    }
-
-    /**
-     * Generates a non-cryptographic 32-bit hash for 8 longs.
-     *
-     * @param x0
-     * 		a long
-     * @param x1
-     * 		a long
-     * @param x2
-     * 		a long
-     * @param x3
-     * 		a long
-     * @param x4
-     * 		a long
-     * @param x5
-     * 		a long
-     * @param x6
-     * 		a long
-     * @param x7
-     * 		a long
-     * @return a non-cryptographic integer hash
-     */
-    public static int hash32(
-            final long x0,
-            final long x1,
-            final long x2,
-            final long x3,
-            final long x4,
-            final long x5,
-            final long x6,
-            final long x7) {
-        return (int) hash64(x0, x1, x2, x3, x4, x5, x6, x7);
-    }
-
-    /**
-     * Generates a non-cryptographic 32-bit hash for 9 longs.
-     *
-     * @param x0
-     * 		a long
-     * @param x1
-     * 		a long
-     * @param x2
-     * 		a long
-     * @param x3
-     * 		a long
-     * @param x4
-     * 		a long
-     * @param x5
-     * 		a long
-     * @param x6
-     * 		a long
-     * @param x7
-     * 		a long
-     * @param x8
-     * 		a long
-     * @return a non-cryptographic integer hash
-     */
-    public static int hash32(
-            final long x0,
-            final long x1,
-            final long x2,
-            final long x3,
-            final long x4,
-            final long x5,
-            final long x6,
-            final long x7,
-            final long x8) {
-        return (int) hash64(x0, x1, x2, x3, x4, x5, x6, x7, x8);
-    }
-
-    /**
-     * Generates a non-cryptographic 32-bit hash for 10 longs.
-     *
-     * @param x0
-     * 		a long
-     * @param x1
-     * 		a long
-     * @param x2
-     * 		a long
-     * @param x3
-     * 		a long
-     * @param x4
-     * 		a long
-     * @param x5
-     * 		a long
-     * @param x6
-     * 		a long
-     * @param x7
-     * 		a long
-     * @param x8
-     * 		a long
-     * @param x9
-     * 		a long
-     * @return a non-cryptographic integer hash
-     */
-    public static int hash32(
-            final long x0,
-            final long x1,
-            final long x2,
-            final long x3,
-            final long x4,
-            final long x5,
-            final long x6,
-            final long x7,
-            final long x8,
-            final long x9) {
-        return (int) hash64(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
-    }
-
-    /**
-     * Generates a non-cryptographic 32-bit hash for an array of longs.
-     *
-     * @param x
-     * 		an array of longs
-     * @return a non-cryptographic integer hash
-     */
-    public static int hash32(@NonNull final long... x) {
-        return (int) hash64(x);
-    }
-
-    /**
-     * Generates a non-cryptographic 64-bit hash for a byte array.
-     *
-     * @param bytes
-     * 		a byte array
-     * @return a non-cryptographic long hash
-     */
-    public static long hash64(@NonNull final byte[] bytes) {
-        return hash64(bytes, 0, bytes.length);
-    }
-
-    /**
-     * Generates a non-cryptographic 64-bit hash for a byte array.
-     *
-     * @param bytes
-     * 		a byte array
-     * @param start
-     *         the start index in the byte array
-     * @param length
-     *         the number of bytes to hash
-     * @return a non-cryptographic long hash
-     */
-    public static long hash64(@NonNull final byte[] bytes, int start, int length) {
-        long hash = perm64(computeMixin(DataType.BYTE_ARRAY, length));
-        for (int i = start; i < length; i += 8) {
-            hash = perm64(hash ^ byteArrayToLong(bytes, i));
-        }
-        return hash;
-    }
-
-    /**
-     * Generates a non-cryptographic 32 bit hash for a byte array.
-     *
-     * @param bytes
-     * 		a byte array
-     * @return a non-cryptographic int hash
-     */
-    public static long hash32(@NonNull final byte[] bytes) {
-        return (int) hash64(bytes);
-    }
-
-    /**
-     * <p>
-     * A permutation (invertible function) on 64 bits.
-     * The constants were found by automated search, to
-     * optimize avalanche. Avalanche means that for a
-     * random number x, flipping bit i of x has about a
-     * 50 percent chance of flipping bit j of perm64(x).
-     * For each possible pair (i,j), this function achieves
-     * a probability between 49.8 and 50.2 percent.
-     * </p>
-     *
-     * <p>
-     * Leemon wrote this, it's magic and does magic things. Like holy molly does
-     * this algorithm resolve some nasty hash collisions for troublesome data sets.
-     * Don't mess with this method.
-     *
-     * <p>
-     * Warning: there currently exist production use cases that will break if this hashing algorithm is changed.
-     * If modifications to this hashing algorithm are ever required, we will need to "fork" this class and leave
-     * the old algorithm intact.
-     */
-    private static long perm64(long x) {
-
-        // This is necessary so that 0 does not hash to 0.
-        // As a side effect this constant will hash to 0.
-        // It was randomly generated (not using Java),
-        // so that it will occur in practice less often than more
-        // common numbers like 0 or -1 or Long.MAX_VALUE.
-        x ^= 0x5e8a016a5eb99c18L;
-
-        // Shifts: {30, 27, 16, 20, 5, 18, 10, 24, 30}
-        x += x << 30;
-        x ^= x >>> 27;
-        x += x << 16;
-        x ^= x >>> 20;
-        x += x << 5;
-        x ^= x >>> 18;
-        x += x << 10;
-        x ^= x >>> 24;
-        x += x << 30;
-        return x;
-    }
-
-    /**
-     * Return a long derived from the 8 bytes data[position]...data[position+7], big endian. If the byte array is not
-     * long enough, zeros are substituted for the missing bytes.
-     *
-     * @param data     an array of bytes
-     * @param position the first byte in the array to use
-     * @return the 8 bytes starting at position, converted to a long, big endian
-     */
-    public static long byteArrayToLong(final byte[] data, final int position) {
-        if (data.length > position + 8) {
-            return UnsafeUtils.getLong(data, position);
-        } else {
-            // There isn't enough data to fill the long, so pad with zeros.
-            long result = 0;
-            for (int offset = 0; offset < 8; offset++) {
-                final int index = position + offset;
-                if (index >= data.length) {
-                    break;
-                }
-                result += (data[index] & 0xffL) << (8 * (7 - offset));
-            }
-            return result;
-        }
-    }
-}
diff --git a/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java b/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
new file mode 100644
index 00000000..d8874dc0
--- /dev/null
+++ b/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.runtime;
+
+import static com.hedera.pbj.runtime.NonCryptographicHashing.hash64;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+
+import java.util.Random;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+@DisplayName("Non-Cryptographic Hash Test")
+class NonCryptographicHashTest {
+    /**
+     * This test does not attempt to verify statistical properties of the hash functions.
+     * Its purpose is to ensure that none of the methods cause a crash.
+     */
+    @DisplayName("Test hash64")
+    @Test
+    void testHash64() {
+        final long seed = 842025;
+        final Random random = new Random(seed);
+
+        assertDoesNotThrow(() -> {
+            hash64(random.nextLong());
+
+            for (int i = 0; i < 100; i++) {
+                final byte[] bytes = new byte[i];
+                hash64(bytes);
+            }
+        });
+    }
+
+
+    @DisplayName("Hashes Are Not Degenerate 64")
+    @Test
+    void hashesAreNonDegenerate64() {
+        final long seed = 842025;
+        final Random random = new Random(seed);
+
+        assertNotEquals(0, hash64(0));
+        assertNotEquals(0, hash64(random.nextLong()));
+
+        for (int i = 0; i < 100; i++) {
+            final byte[] bytes = new byte[i];
+            assertNotEquals(0, hash64(bytes), "Hashes should be non-degenerate");
+        }
+    }
+}
diff --git a/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashTest.java b/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashTest.java
deleted file mode 100644
index 588a7bb0..00000000
--- a/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/io/buffer/NonCryptographicHashTest.java
+++ /dev/null
@@ -1,586 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-package com.hedera.pbj.runtime.io.buffer;
-
-import static com.hedera.pbj.runtime.io.buffer.NonCryptographicHashing.hash32;
-import static com.hedera.pbj.runtime.io.buffer.NonCryptographicHashing.hash64;
-import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
-import static org.junit.jupiter.api.Assertions.assertNotEquals;
-
-import edu.umd.cs.findbugs.annotations.NonNull;
-import java.util.Random;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-
-@DisplayName("Non-Cryptographic Hash Test")
-class NonCryptographicHashTest {
-
-    /**
-     * This test does not attempt to verify statistical properties of the hash functions.
-     * Its purpose is to ensure that none of the methods cause a crash.
-     */
-    @DisplayName("Test hash32")
-    @Test
-    void testHash32() {
-        final long seed = 842025;
-        final Random random = new Random(seed);
-
-        assertDoesNotThrow(() -> {
-            hash32(random.nextInt());
-            hash32(random.nextInt(), random.nextInt());
-            hash32(random.nextInt(), random.nextInt(), random.nextInt());
-            hash32(random.nextInt(), random.nextInt(), random.nextInt(), random.nextInt());
-            hash32(random.nextInt(), random.nextInt(), random.nextInt(), random.nextInt(), random.nextInt());
-            hash32(
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt());
-            hash32(
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt());
-            hash32(
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt());
-            hash32(
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt());
-            hash32(
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt());
-            hash32(
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt());
-            hash32(
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt());
-
-            hash32(random.nextLong());
-            hash32(random.nextLong(), random.nextLong());
-            hash32(random.nextLong(), random.nextLong(), random.nextLong());
-            hash32(random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong());
-            hash32(random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong());
-            hash32(
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong());
-            hash32(
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong());
-            hash32(
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong());
-            hash32(
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong());
-            hash32(
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong());
-            hash32(
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong());
-            hash32(
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong());
-
-            for (int i = 0; i < 100; i++) {
-                final byte[] bytes = new byte[i];
-                hash32(bytes);
-
-                final String string = randomString(random, i);
-                hash32(string);
-            }
-        });
-    }
-
-    /**
-     * This test does not attempt to verify statistical properties of the hash functions.
-     * Its purpose is to ensure that none of the methods cause a crash.
-     */
-    @DisplayName("Test hash64")
-    @Test
-    void testHash64() {
-        final long seed = 842025;
-        final Random random = new Random(seed);
-
-        assertDoesNotThrow(() -> {
-            hash64(random.nextInt());
-            hash64(random.nextInt(), random.nextInt());
-            hash64(random.nextInt(), random.nextInt(), random.nextInt());
-            hash64(random.nextInt(), random.nextInt(), random.nextInt(), random.nextInt());
-            hash64(random.nextInt(), random.nextInt(), random.nextInt(), random.nextInt(), random.nextInt());
-            hash64(
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt());
-            hash64(
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt());
-            hash64(
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt());
-            hash64(
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt());
-            hash64(
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt());
-            hash64(
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt());
-            hash64(
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt(),
-                    random.nextInt());
-
-            hash64(random.nextLong());
-            hash64(random.nextLong(), random.nextLong());
-            hash64(random.nextLong(), random.nextLong(), random.nextLong());
-            hash64(random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong());
-            hash64(random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong());
-            hash64(
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong());
-            hash64(
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong());
-            hash64(
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong());
-            hash64(
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong());
-            hash64(
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong());
-            hash64(
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong());
-            hash64(
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong(),
-                    random.nextLong());
-
-            for (int i = 0; i < 100; i++) {
-                final byte[] bytes = new byte[i];
-                hash64(bytes);
-
-                final String string = randomString(random, i);
-                hash64(string);
-            }
-        });
-    }
-
-    @DisplayName("Hashes Are Not Degenerate 32")
-    @Test
-    void hashesAreNonDegenerate32() {
-        final long seed = 842025;
-        final Random random = new Random(seed);
-
-        assertNotEquals(0, hash32(0));
-        assertNotEquals(0, hash32(0, 0));
-        assertNotEquals(0, hash32(0, 0, 0));
-        assertNotEquals(0, hash32(0, 0, 0));
-        assertNotEquals(0, hash32(0, 0, 0, 0));
-        assertNotEquals(0, hash32(0, 0, 0, 0, 0));
-        assertNotEquals(0, hash32(0, 0, 0, 0, 0, 0));
-        assertNotEquals(0, hash32(0, 0, 0, 0, 0, 0, 0));
-        assertNotEquals(0, hash32(0, 0, 0, 0, 0, 0, 0, 0));
-        assertNotEquals(0, hash32(0, 0, 0, 0, 0, 0, 0, 0, 0));
-        assertNotEquals(0, hash32(0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
-        assertNotEquals(0, hash32(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
-
-        assertNotEquals(0, hash32(random.nextLong()));
-        assertNotEquals(0, hash32(random.nextLong(), random.nextLong()));
-        assertNotEquals(0, hash32(random.nextLong(), random.nextLong(), random.nextLong()));
-        assertNotEquals(0, hash32(random.nextLong(), random.nextLong(), random.nextLong()));
-        assertNotEquals(0, hash32(random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong()));
-        assertNotEquals(
-                0,
-                hash32(random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong()));
-        assertNotEquals(
-                0,
-                hash32(
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong()));
-        assertNotEquals(
-                0,
-                hash32(
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong()));
-        assertNotEquals(
-                0,
-                hash32(
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong()));
-        assertNotEquals(
-                0,
-                hash32(
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong()));
-        assertNotEquals(
-                0,
-                hash32(
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong()));
-        assertNotEquals(
-                0,
-                hash32(
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong()));
-
-        for (int i = 0; i < 100; i++) {
-            final byte[] bytes = new byte[i];
-            assertNotEquals(0, hash32(bytes), "Hashes should be non-degenerate");
-
-            final String string = randomString(random, i);
-            assertNotEquals(0, hash32(string), "Hashes should be non-degenerate");
-        }
-    }
-
-    @DisplayName("Hashes Are Not Degenerate 64")
-    @Test
-    void hashesAreNonDegenerate64() {
-        final long seed = 842025;
-        final Random random = new Random(seed);
-
-        assertNotEquals(0, hash64(0));
-        assertNotEquals(0, hash64(0, 0));
-        assertNotEquals(0, hash64(0, 0, 0));
-        assertNotEquals(0, hash64(0, 0, 0));
-        assertNotEquals(0, hash64(0, 0, 0, 0));
-        assertNotEquals(0, hash64(0, 0, 0, 0, 0));
-        assertNotEquals(0, hash64(0, 0, 0, 0, 0, 0));
-        assertNotEquals(0, hash64(0, 0, 0, 0, 0, 0, 0));
-        assertNotEquals(0, hash64(0, 0, 0, 0, 0, 0, 0, 0));
-        assertNotEquals(0, hash64(0, 0, 0, 0, 0, 0, 0, 0, 0));
-        assertNotEquals(0, hash64(0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
-        assertNotEquals(0, hash64(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
-
-        assertNotEquals(0, hash64(random.nextLong()));
-        assertNotEquals(0, hash64(random.nextLong(), random.nextLong()));
-        assertNotEquals(0, hash64(random.nextLong(), random.nextLong(), random.nextLong()));
-        assertNotEquals(0, hash64(random.nextLong(), random.nextLong(), random.nextLong()));
-        assertNotEquals(0, hash64(random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong()));
-        assertNotEquals(
-                0,
-                hash64(random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong(), random.nextLong()));
-        assertNotEquals(
-                0,
-                hash64(
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong()));
-        assertNotEquals(
-                0,
-                hash64(
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong()));
-        assertNotEquals(
-                0,
-                hash64(
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong()));
-        assertNotEquals(
-                0,
-                hash64(
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong()));
-        assertNotEquals(
-                0,
-                hash64(
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong()));
-        assertNotEquals(
-                0,
-                hash64(
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong(),
-                        random.nextLong()));
-
-        for (int i = 0; i < 100; i++) {
-            final byte[] bytes = new byte[i];
-            assertNotEquals(0, hash64(bytes), "Hashes should be non-degenerate");
-
-            final String string = randomString(random, i);
-            assertNotEquals(0, hash64(string), "Hashes should be non-degenerate");
-        }
-    }
-
-    public static @NonNull String randomString(@NonNull final Random random, final int length) {
-        final int LEFT_LIMIT = 48; // numeral '0'
-        final int RIGHT_LIMIT = 122; // letter 'z'
-
-        return random.ints(LEFT_LIMIT, RIGHT_LIMIT + 1)
-                .filter(i -> (i <= 57 || i >= 65) && (i <= 90 || i >= 97))
-                .limit(length)
-                .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
-                .toString();
-    }
-
-}

From e75ea4effa9aebc3b82f99af2c2564426293d68b Mon Sep 17 00:00:00 2001
From: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
Date: Mon, 4 Aug 2025 15:50:48 -0700
Subject: [PATCH 05/17] Use NonCryptographicHashing for BufferedData

Signed-off-by: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
---
 .../pbj/runtime/NonCryptographicHashing.java  | 29 +++++++++++++++++++
 .../pbj/runtime/io/buffer/BufferedData.java   |  5 ++--
 2 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
index 14beb35f..16db3400 100644
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
@@ -2,6 +2,7 @@
 
 import com.hedera.pbj.runtime.io.UnsafeUtils;
 import edu.umd.cs.findbugs.annotations.NonNull;
+import java.nio.ByteBuffer;
 
 /**
  * This class contains a collection of methods for hashing basic data types.
@@ -52,6 +53,34 @@ public static long hash64(@NonNull final byte[] bytes, int start, int length) {
         return hash;
     }
 
+    /**
+     * Generates a non-cryptographic 64-bit hash for a ByteBuffer covering all bytes from position to limit.
+     *
+     * @param buf a byte buffer to compute the hash from
+     * @return a non-cryptographic long hash
+     */
+    public static long hash64(@NonNull final ByteBuffer buf) {
+        long hash = perm64(buf.remaining());
+        final int p = buf.position();
+        final int l = buf.limit();
+        for (int i = p; i < l; i += 8) {
+            final int remaining = l - i;
+            if (remaining < 8) {
+                // If there are less than 8 bytes remaining, we need to pad with zeros.
+                long value = 0;
+                for (int j = 0; j < remaining; j++) {
+                    value |= (UnsafeUtils.getHeapBufferByteNoChecks(buf, i + j) & 0xffL) << (8 * (7 - j));
+                }
+                hash = perm64(hash ^ value);
+                break;
+            } else {
+                // If there are 8 or more bytes remaining, we can read a full long.
+                hash = perm64(hash ^ buf.getLong(i));
+            }
+        }
+        return hash;
+    }
+
     /**
      * <p>
      * A permutation (invertible function) on 64 bits.
diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/BufferedData.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/BufferedData.java
index 43929d5b..b152bbfd 100644
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/BufferedData.java
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/BufferedData.java
@@ -3,6 +3,7 @@
 
 import static java.nio.ByteOrder.BIG_ENDIAN;
 
+import com.hedera.pbj.runtime.NonCryptographicHashing;
 import com.hedera.pbj.runtime.io.ReadableSequentialData;
 import com.hedera.pbj.runtime.io.WritableSequentialData;
 import edu.umd.cs.findbugs.annotations.NonNull;
@@ -230,13 +231,13 @@ public boolean equals(final Object o) {
     }
 
     /**
-     * Get hash based on contents of this buffer
+     * Get hash based on the contents of this buffer
      *
      * @return hash code
      */
     @Override
     public int hashCode() {
-        return buffer.hashCode();
+        return (int)NonCryptographicHashing.hash64(buffer);
     }
 
     // ================================================================================================================

From d94518fffa88d545298bbf2aa8e1525449c554be Mon Sep 17 00:00:00 2001
From: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
Date: Mon, 4 Aug 2025 16:47:50 -0700
Subject: [PATCH 06/17] Add NonCryptographicHashing benchmark

Signed-off-by: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
---
 .../jmh/NonCryptographicHashingBench.java     | 125 ++++++++++++++++++
 1 file changed, 125 insertions(+)
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java

diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java
new file mode 100644
index 00000000..e55a9283
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java
@@ -0,0 +1,125 @@
+package com.hedera.pbj.integration.jmh;
+
+import com.hedera.pbj.runtime.NonCryptographicHashing;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
+
+@SuppressWarnings("unused")
+@State(Scope.Benchmark)
+@Fork(1)
+@Warmup(iterations = 4, time = 4)
+@Measurement(iterations = 10, time = 4)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@BenchmarkMode(Mode.AverageTime)
+public class NonCryptographicHashingBench {
+    public static final int DATA_SIZE = 10; // Size of the byte array to hash
+    public static final int SAMPLES = 1000;
+
+    private Random random;
+    private byte[][] sampleBytes;
+
+
+    @Setup
+    public void setup() {
+        random =new Random(6351384163846453326L);
+        sampleBytes = new byte[SAMPLES][DATA_SIZE];
+        for (int i = 0; i < SAMPLES; i++) {
+            sampleBytes[i] = new byte[DATA_SIZE];
+            random.nextBytes(sampleBytes[i]);
+        }
+    }
+
+    @Benchmark
+    public void hashCodeOriginal(Blackhole blackhole){
+        byte[] bytes = sampleBytes[random.nextInt(SAMPLES)];
+        blackhole.consume(oldBytesHashCode(bytes,0,DATA_SIZE));
+    }
+
+    @Benchmark
+    public void hashCodeNonCryptographicHashing(Blackhole blackhole){
+        byte[] bytes = sampleBytes[random.nextInt(SAMPLES)];
+        blackhole.consume(NonCryptographicHashing.hash64(bytes, 0, DATA_SIZE));
+    }
+
+    @Benchmark
+    public void hashCodeNonCryptographicHashingVarHandle(Blackhole blackhole){
+        byte[] bytes = sampleBytes[random.nextInt(SAMPLES)];
+        blackhole.consume(hash64VarHandle(bytes, 0, DATA_SIZE));
+    }
+
+
+    /**
+     * Old hashcode implementation for Bytes from before it used NonCryptographicHashing. Slightly different as it is
+     * done from outside the Bytes class.
+     */
+    public int oldBytesHashCode(@NonNull final byte[] bytes, int start, int length) {
+        int h = 1;
+        for (int i = length - 1; i >= start; i--) {
+            h = 31 * h + bytes[i];
+        }
+        return h;
+    }
+
+    public static long hash64VarHandle(@NonNull final byte[] bytes, int start, int length) {
+        long hash = perm64(length);
+        for (int i = start; i < length; i += 8) {
+            hash = perm64(hash ^ byteArrayToLong(bytes, i));
+        }
+        return hash;
+    }
+
+    private static long perm64(long x) {
+        // This is necessary so that 0 does not hash to 0.
+        // As a side effect, this constant will hash to 0.
+        // It was randomly generated (not using Java),
+        // so that it will occur in practice less often than more
+        // common numbers like 0 or -1 or Long.MAX_VALUE.
+        x ^= 0x5e8a016a5eb99c18L;
+
+        // Shifts: {30, 27, 16, 20, 5, 18, 10, 24, 30}
+        x += x << 30;
+        x ^= x >>> 27;
+        x += x << 16;
+        x ^= x >>> 20;
+        x += x << 5;
+        x ^= x >>> 18;
+        x += x << 10;
+        x ^= x >>> 24;
+        x += x << 30;
+        return x;
+    }
+
+    public static long byteArrayToLong(final byte[] data, final int position) {
+        if (data.length > position + 8) {
+            return (long) vh.get(data, position);
+        } else {
+            // There isn't enough data to fill the long, so pad with zeros.
+            long result = 0;
+            for (int offset = 0; offset < 8; offset++) {
+                final int index = position + offset;
+                if (index >= data.length) {
+                    break;
+                }
+                result += (data[index] & 0xffL) << (8 * (7 - offset));
+            }
+            return result;
+        }
+    }
+
+    private static final VarHandle vh = MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.BIG_ENDIAN);
+}

From 5551e7ec3549f64e149897b34179dfa5b71a249d Mon Sep 17 00:00:00 2001
From: Richard Bair <rbair23@users.noreply.github.com>
Date: Tue, 5 Aug 2025 11:55:31 -0700
Subject: [PATCH 07/17] Added tests, changed impl. Faster. Simpler.

Signed-off-by: Richard Bair <rbair23@users.noreply.github.com>
---
 .../pbj/runtime/NonCryptographicHashing.java  |  93 +++---
 .../hedera/pbj/runtime/io/UnsafeUtils.java    |  42 ++-
 .../pbj/runtime/NonCryptographicHashTest.java | 292 +++++++++++++++++-
 3 files changed, 371 insertions(+), 56 deletions(-)

diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
index 16db3400..6d9022b4 100644
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
@@ -35,21 +35,44 @@ public static long hash64(@NonNull final byte[] bytes) {
     }
 
     /**
-     * Generates a non-cryptographic 64-bit hash for a byte array.
+     * Generates a non-cryptographic 64-bit hash for contents of the given byte array within indexes position
+     * (inclusive) and position + length (exclusive).
      *
-     * @param bytes
-     * 		a byte array
-     * @param start
-     *         the start index in the byte array
+     * @param bytes A byte array. Must not be null. Can be empty.
+     * @param position The starting position within the byte array to begin hashing from. Must be non-negative,
+     *                 and must be less than the length of the array, and position + length must also be
+     *                 less than or equal to the length of the array.
      * @param length
-     *         the number of bytes to hash
+     *         The number of bytes to hash. Must be non-negative, and must be such that position + length
+     *         is less than or equal to the length of the byte array.
+     *
      * @return a non-cryptographic long hash
      */
-    public static long hash64(@NonNull final byte[] bytes, int start, int length) {
-        long hash = perm64(length);
-        for (int i = start; i < length; i += 8) {
-            hash = perm64(hash ^ byteArrayToLong(bytes, i));
+    public static long hash64(@NonNull final byte[] bytes, final int position, final int length) {
+        // Accumulate the hash in 64-bit chunks. If the length is not a multiple of 8, then read
+        // as many complete 8 byte chunks as possible.
+        long hash = 0;
+        int i = position;
+        int end = position + length - 7;
+        for (; i < end; i += 8) {
+            // TODO Jasper change this to use a VarHandle so we get native or reverse order as needed
+            hash = perm64(hash ^ UnsafeUtils.getLongNoChecksNativeOrder(bytes, i));
         }
+
+        // Construct a trailing long. If the segment of the byte array we read was exactly a multiple of 8 bytes,
+        // then we will append "0x00000000000000FF" to the end of the hash. If we had 1 byte remaining, then
+        // we will append "0x000000000000FFXX" where XX is the value of the last byte, and so on.
+        long tail = 0x00000000000000FF;
+        int start = i;
+        i = position + length - 1;
+        for (; i >= start; i--) {
+            tail <<= 8;
+            tail |= (bytes[i] & 0xFFL); // Mask to ensure we only get the last 8 bits.
+        }
+
+        // Combine the tail with the previous hash.
+        hash = perm64(hash ^ tail);
+
         return hash;
     }
 
@@ -83,30 +106,19 @@ public static long hash64(@NonNull final ByteBuffer buf) {
 
     /**
      * <p>
-     * A permutation (invertible function) on 64 bits.
-     * The constants were found by automated search, to
-     * optimize avalanche. Avalanche means that for a
-     * random number x, flipping bit i of x has about a
-     * 50 percent chance of flipping bit j of perm64(x).
-     * For each possible pair (i,j), this function achieves
+     * A permutation (invertible function) on 64 bits. The constants were found by automated search, to
+     * optimize avalanche. Avalanche means that for a random number x, flipping bit i of x has about a
+     * 50 percent chance of flipping bit j of perm64(x). For each possible pair (i,j), this function achieves
      * a probability between 49.8 and 50.2 percent.
-     * </p>
-     *
-     * <p>
-     * Leemon wrote this, it's magic and does magic things. Like holy molly does
-     * this algorithm resolve some nasty hash collisions for troublesome data sets.
-     * Don't mess with this method.
      *
      * <p>
      * Warning: there currently exist production use cases that will break if this hashing algorithm is changed.
-     * If modifications to this hashing algorithm are ever required, we will need to "fork" this class and leave
-     * the old algorithm intact.
+     * If modifications to this hashing algorithm are ever required, they must be raised with the maintainers
+     * of the Hiero Consensus Node and probably the Hiero Technical Steering Committee.
      */
     private static long perm64(long x) {
-        // This is necessary so that 0 does not hash to 0.
-        // As a side effect, this constant will hash to 0.
-        // It was randomly generated (not using Java),
-        // so that it will occur in practice less often than more
+        // This is necessary so that 0 does not hash to 0. As a side effect, this constant will hash to 0.
+        // It was randomly generated (not using Java), so that it will occur in practice less often than more
         // common numbers like 0 or -1 or Long.MAX_VALUE.
         x ^= 0x5e8a016a5eb99c18L;
 
@@ -122,29 +134,4 @@ private static long perm64(long x) {
         x += x << 30;
         return x;
     }
-
-    /**
-     * Return a long derived from the 8 bytes data[position]...data[position+7], big endian. If the byte array is not
-     * long enough, zeros are substituted for the missing bytes.
-     *
-     * @param data     an array of bytes
-     * @param position the first byte in the array to use
-     * @return the 8 bytes starting at position, converted to a long, big endian
-     */
-    public static long byteArrayToLong(final byte[] data, final int position) {
-        if (data.length > position + 8) {
-            return UnsafeUtils.getLong(data, position);
-        } else {
-            // There isn't enough data to fill the long, so pad with zeros.
-            long result = 0;
-            for (int offset = 0; offset < 8; offset++) {
-                final int index = position + offset;
-                if (index >= data.length) {
-                    break;
-                }
-                result += (data[index] & 0xffL) << (8 * (7 - offset));
-            }
-            return result;
-        }
-    }
 }
diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java
index aa7a4bc2..37ab38f1 100644
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java
@@ -139,8 +139,48 @@ public static long getLong(final byte[] arr, final int offset) {
         if (arr.length < offset + Long.BYTES) {
             throw new BufferUnderflowException();
         }
+        return getLongNoChecks(arr, offset);
+    }
+
+    /**
+     * Reads a long from the given array starting at the given offset. Array bytes are
+     * interpreted in BIG_ENDIAN order.
+     *
+     * @param arr The byte array
+     * @param offset The offset to read a long at
+     * @return The long number
+     * @throws java.nio.BufferOverflowException If array length is less than offset + long bytes
+     */
+    public static long getLongNoChecks(final byte[] arr, final long offset) {
+        return NEED_CHANGE_BYTE_ORDER ? getLongNoChecksReverseOrder(arr, offset) :
+                getLongNoChecksNativeOrder(arr, offset);
+    }
+
+    /**
+     * Reads a long from the given array starting at the given offset. Array bytes are
+     * interpreted in BIG_ENDIAN order.
+     *
+     * @param arr The byte array
+     * @param offset The offset to read a long at
+     * @return The long number
+     * @throws java.nio.BufferOverflowException If array length is less than offset + long bytes
+     */
+    public static long getLongNoChecksNativeOrder(final byte[] arr, final long offset) {
+        return UNSAFE.getLong(arr, BYTE_ARRAY_BASE_OFFSET + offset);
+    }
+
+    /**
+     * Reads a long from the given array starting at the given offset. Array bytes are
+     * interpreted in BIG_ENDIAN order.
+     *
+     * @param arr The byte array
+     * @param offset The offset to read a long at
+     * @return The long number
+     * @throws java.nio.BufferOverflowException If array length is less than offset + long bytes
+     */
+    public static long getLongNoChecksReverseOrder(final byte[] arr, final long offset) {
         final long value = UNSAFE.getLong(arr, BYTE_ARRAY_BASE_OFFSET + offset);
-        return NEED_CHANGE_BYTE_ORDER ? Long.reverseBytes(value) : value;
+        return Long.reverseBytes(value);
     }
 
     /**
diff --git a/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java b/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
index d8874dc0..5e989e0e 100644
--- a/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
+++ b/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
@@ -3,20 +3,308 @@
 
 import static com.hedera.pbj.runtime.NonCryptographicHashing.hash64;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import com.hedera.pbj.runtime.io.UnsafeUtils;
+import java.nio.ByteBuffer;
+import java.util.HashSet;
 import java.util.Random;
+import java.util.Set;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
 @DisplayName("Non-Cryptographic Hash Test")
 class NonCryptographicHashTest {
+    //      * TEST: what happens if position > length of the byte array?
+    //     * TEST: what happens if position < 0?
+    //     * TEST: what happens if length < 0?
+    //     * TEST: what happens if position + length > byte array length?
+    //     * TEST: what happens if the byte array is 0? (with length = 0 and position = 0. Anything else is illegal with byte array 0).
+
+    /**
+     * Test the hash64(long) method with known values. The computation is very simple to do with any
+     * calculator,
+     */
+    @Test
+    @DisplayName("Test Hash64(long) Long with Known Values")
+    void testHash64Long() {
+        assertEquals(605873356528442819L, NonCryptographicHashing.hash64(0L));
+        assertEquals(4748194389872103055L, NonCryptographicHashing.hash64(1L));
+        assertEquals(5797980124308584942L, NonCryptographicHashing.hash64(-1L));
+        assertEquals(6218562537029544279L, NonCryptographicHashing.hash64(1234567890123456789L));
+    }
+
+    /**
+     * Test the hash64(byte[]) method with an empty byte array. This computation is also very simple
+     * to do with any calculator, and the result is known. We want to show that hashing an empty
+     * array is OK.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[]) Empty Array")
+    void testHash64ByteArrayEmpty() {
+        assertEquals(3230899725752021667L, NonCryptographicHashing.hash64(new byte[0]));
+    }
+
+    /**
+     * Test the hash64(byte[], int, int) method with an empty byte array, position 0, and length 0.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[], int, int) Empty Array with Valid Position and Length")
+    void testHash64ByteArrayEmptyWithPositionAndLength() {
+        assertEquals(3230899725752021667L, NonCryptographicHashing.hash64(new byte[0], 0, 0));
+    }
+
+    /**
+     * Test the hash64(byte[], int, int) method with position > length of the byte array.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[], int, int) Position Exceeds Array Length")
+    @Disabled("Disabled for now. I don't want to do the check and slow things down. Do we care about this?")
+    void testHash64ByteArrayPositionExceedsLength() {
+        byte[] arr = new byte[5];
+        // At the moment just returns the hash of 255.
+        assertThrows(IndexOutOfBoundsException.class, () -> NonCryptographicHashing.hash64(arr, 6, 0));
+    }
+
+    /**
+     * Test the hash64(byte[], int, int) method with position < 0.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[], int, int) Negative Position")
+    @Disabled("Disabled for now. I don't want to do the check and slow things down. Do we care about this?")
+    void testHash64ByteArrayNegativePosition() {
+        byte[] arr = new byte[5];
+        // At the moment just returns the hash of 255.
+        assertThrows(IndexOutOfBoundsException.class, () -> NonCryptographicHashing.hash64(arr, -1, 0));
+    }
+
+    /**
+     * Test the hash64(byte[], int, int) method with length < 0.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[], int, int) Negative Length")
+    @Disabled("Disabled for now. I don't want to do the check and slow things down. Do we care about this?")
+    void testHash64ByteArrayNegativeLength() {
+        byte[] arr = new byte[5];
+        // At the moment just returns the hash of 255.
+        assertThrows(IllegalArgumentException.class, () -> NonCryptographicHashing.hash64(arr, 0, -1));
+    }
+
+    /**
+     * Test the hash64(byte[], int, int) method with position + length > byte array length.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[], int, int) Position Plus Length Exceeds Array Length")
+    void testHash64ByteArrayPositionPlusLengthExceeds() {
+        byte[] arr = new byte[5];
+        assertThrows(IndexOutOfBoundsException.class, () -> NonCryptographicHashing.hash64(arr, 2, 4));
+    }
+
+    /**
+     * Test the hash64(byte[]) method with a one-byte array. This shows what happens if we have less than 8 bytes.
+     * The constant was found by calculating by hand the expected result.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[]) with array less than 8 bytes")
+    void testHash64ByteArrayLessThan8Bytes() {
+        byte[] arr = {(byte) 1};
+        assertEquals(1450858126797791778L, NonCryptographicHashing.hash64(arr));
+    }
+
+    /**
+     * Test the hash64(byte[]) method with an 8-byte array. This shows what happens if we test with exactly 8 bytes.
+     * The constant was found by calculating by hand the expected result.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[]) with 8 bytes")
+    void testHash64ByteArray8Bytes() {
+        byte[] arr = {(byte) 1, (byte) 2, (byte) 3, (byte) 4,
+                (byte) 5, (byte) 6, (byte) 7, (byte) 8};
+
+        assertEquals(-5416501487484278819L, NonCryptographicHashing.hash64(arr));
+    }
+
+    /**
+     * Test the hash64(byte[]) method with a 12-byte array. This shows what happens if we test with more than
+     * 8 bytes, but not a multiple of 8. The constant was found by calculating by hand the expected result.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[]) with larger non-multiple of 8 bytes")
+    void testHash64ByteArrayMoreThan8ButNotMultipleOf8Bytes() {
+        byte[] arr = {(byte) 1, (byte) 2, (byte) 3, (byte) 4,
+                (byte) 5, (byte) 6, (byte) 7, (byte) 8,
+                (byte) 9, (byte) 10, (byte) 11, (byte) 12};
+
+        assertEquals(8717726722998256023L, NonCryptographicHashing.hash64(arr));
+    }
+
+    /**
+     * Test the hash64(byte[]) method with a 16-byte array. This shows what happens for arrays that are a multiple of 8.
+     * The constant was found by calculating by hand the expected result.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[]) with multiple of 8 bytes")
+    void testHash64ByteArrayMultipleOf8Bytes() {
+        byte[] arr = {(byte) 1, (byte) 2, (byte) 3, (byte) 4,
+                (byte) 5, (byte) 6, (byte) 7, (byte) 8,
+                (byte) 9, (byte) 10, (byte) 11, (byte) 12,
+                (byte) 13, (byte) 14, (byte) 15, (byte) 16};
+
+        assertEquals(-5797446293423483272L, NonCryptographicHashing.hash64(arr));
+    }
+
+    /**
+     * While not comprehensive, this test provides a basic sanity check that if you are given two arrays of different
+     * lengths, but they both have the same high byte set and all other bytes are zero, then they generate different
+     * hashes.
+     */
+    @Test
+    @DisplayName("Test arrays of various lengths with high byte set and all else zero do not collide")
+    void testLeadingOneHasNoCollisions() {
+        Set<Long> hashes = new HashSet<>();
+        for (int len = 1; len <= 16; len++) {
+            byte[] leadingOne = new byte[len];
+            long h1 = NonCryptographicHashing.hash64(leadingOne);
+            assertTrue(hashes.add(h1)); // asserts each is unique
+        }
+    }
+
+    /**
+     * While not comprehensive, this test provides a basic sanity check that if you are given two arrays of different
+     * lengths, but they both have all bytes set to 1, then they generate different hashes.
+     */
+    @Test
+    void testAllOnesHasNoCollisions() {
+        Set<Long> hashes = new HashSet<>();
+        for (int len = 1; len <= 16; len++) {
+            byte[] allOnes = new byte[len];
+            for (int i = 0; i < len; i++) allOnes[i] = (byte) 0xFF;
+            long h1 = NonCryptographicHashing.hash64(allOnes);
+            assertTrue(hashes.add(h1)); // asserts each is unique
+        }
+    }
+
+    /**
+     * This test checks that the hash64 method does not produce collisions for small arrays.
+     * It verifies that all possible byte combinations for arrays of length 1 and 2 produce unique hashes.
+     */
+    @Test
+    @DisplayName("Test No Collisions for Small Arrays")
+    void testNoCollisionsSmallArrays() {
+        // Length 1: all 256
+        Set<Long> set1 = new HashSet<>();
+        for (int i = 0; i < 256; i++) {
+            byte[] ba = {(byte) i};
+            assertTrue(set1.add(NonCryptographicHashing.hash64(ba)));
+        }
+
+        // Length 2: all 65536
+        Set<Long> set2 = new HashSet<>();
+        for (int i = 0; i < 256; i++) {
+            for (int j = 0; j < 256; j++) {
+                byte[] ba = {(byte) i, (byte) j};
+                assertTrue(set2.add(NonCryptographicHashing.hash64(ba)));
+            }
+        }
+    }
+
+    /**
+     * This test checks that the hash64 method does not produce collisions for larger sets of data.
+     * It verifies that all possible byte combinations up to the number 100,000 produce unique hashes.
+     */
+    @Test
+    @DisplayName("Test No Collisions for Large Sets")
+    void testNoCollisionsLargeSet() {
+        final int num = 100_000;
+        Set<Long> set = new HashSet<>();
+        for (int i = 0; i < num; i++) {
+            byte[] ba = ByteBuffer.allocate(4).putInt(i).array();
+            assertTrue(set.add(NonCryptographicHashing.hash64(ba)));
+        }
+    }
+
+    @Test
+    @DisplayName("Test Collisions with non-random data")
+    void testLowCollisionsLargeSet() {
+        // Given an 8 byte array, try changing only the first 2 bytes, and see if we get collisions.
+        // A bad hash function would produce many collisions here. Then try again but changing out the middle
+        // 2 bytes. And do the same for the last 2 bytes.
+        final Set<Long> firstBytesSet = new HashSet<>();
+        final Set<Long> middleBytesSet = new HashSet<>();
+        final Set<Long> lastBytesSet = new HashSet<>();
+        final byte[] arr = { (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04,
+                             (byte) 0x05, (byte) 0x06, (byte) 0x07, (byte) 0x08 };
+        for (int i = 0; i < 256; i++) {
+            for (int j = 0; j < 256; j++) {
+                // Change the first two bytes
+                arr[6] = (byte) 0x07; // Reset last two bytes
+                arr[7] = (byte) 0x08; // Reset last two bytes
+                arr[0] = (byte) i;
+                arr[1] = (byte) j;
+                long hash1 = NonCryptographicHashing.hash64(arr);
+                assertTrue(firstBytesSet.add(hash1), "Collision found with first two bytes: iteration=" + i + ", long=" + Long.toHexString(UnsafeUtils.getLong(arr, 0)));
+
+                // Change the middle two bytes
+                arr[0] = (byte) 0x01; // Reset first two bytes
+                arr[1] = (byte) 0x02; // Reset first two bytes
+                arr[3] = (byte) i;
+                arr[4] = (byte) j;
+                long hash2 = NonCryptographicHashing.hash64(arr);
+                assertTrue(middleBytesSet.add(hash2), "Collision found with middle two bytes: iteration=" + i + ", long=" + Long.toHexString(UnsafeUtils.getLong(arr, 0)));
+
+                // Change the last two bytes
+                arr[3] = (byte) 0x03; // Reset middle two bytes
+                arr[4] = (byte) 0x04; // Reset middle two bytes
+                arr[6] = (byte) i;
+                arr[7] = (byte) j;
+                long hash3 = NonCryptographicHashing.hash64(arr);
+                assertTrue(lastBytesSet.add(hash3), "Collision found with last two bytes: iteration=" + i + ", long=" + Long.toHexString(UnsafeUtils.getLong(arr, 0)));
+            }
+        }
+    }
+
+    /**
+     * Checks that hashing a byte array with an offset produces the same result as hashing the same bytes directly.
+     */
+    @Test
+    @DisplayName("Test Hash with Offset")
+    void testHashWithOffset() {
+        byte[] large = new byte[255];
+        for (int i = 0; i < large.length; i++) {
+            large[i] = (byte) i;
+        }
+
+        // Try every subset where the start is changing but the length includes the last byte.
+        for (int i = 0; i < large.length; i++) {
+            int length = large.length - i;
+            byte[] subset = new byte[length];
+            System.arraycopy(large, i, subset, 0, length);
+            long expected = NonCryptographicHashing.hash64(subset);
+            long actual = NonCryptographicHashing.hash64(large, i, length);
+            assertEquals(expected, actual, "Hash with offset where start changes: " + i);
+        }
+
+        // Try every subset where the start is always 0 but the length is changing.
+        for (int i = 0; i < large.length; i++) {
+            int length = large.length - i;
+            byte[] subset = new byte[length];
+            System.arraycopy(large, 0, subset, 0, length);
+            long expected = NonCryptographicHashing.hash64(subset);
+            long actual = NonCryptographicHashing.hash64(large, 0, length);
+            assertEquals(expected, actual, "Hash with offset where length changes: " + i);
+        }
+    }
+
     /**
      * This test does not attempt to verify statistical properties of the hash functions.
      * Its purpose is to ensure that none of the methods cause a crash.
      */
-    @DisplayName("Test hash64")
     @Test
+    @DisplayName("Test hash64")
     void testHash64() {
         final long seed = 842025;
         final Random random = new Random(seed);
@@ -32,8 +320,8 @@ void testHash64() {
     }
 
 
-    @DisplayName("Hashes Are Not Degenerate 64")
     @Test
+    @DisplayName("Hashes Are Not Degenerate 64")
     void hashesAreNonDegenerate64() {
         final long seed = 842025;
         final Random random = new Random(seed);

From 7555c18b72004656ecab4016a8648f79c9b7a272 Mon Sep 17 00:00:00 2001
From: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
Date: Tue, 5 Aug 2025 13:17:19 -0700
Subject: [PATCH 08/17] Add NonCryptographicHashing benchmark and tests as well
 as competitive algorithms for testing

Signed-off-by: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
---
 .../hedera/pbj/runtime/io/UnsafeUtils.java    |  27 +-
 .../pbj/runtime/NonCryptographicHashTest.java | 337 -----------------
 .../jmh/NonCryptographicHashingBench.java     | 140 +++----
 .../pbj/integration/jmh/hashing/CityHash.java | 356 ++++++++++++++++++
 .../integration/jmh/hashing/FasterLeemon.java |  81 ++++
 .../integration/jmh/hashing/HashFunction.java |   7 +
 .../jmh/hashing/JavaStyleHashing.java         |  33 ++
 .../NonCryptographicHashQuality4ByteTest.java | 118 ++++++
 .../NonCryptographicHashQualityTest.java      |  49 +++
 .../pbj/integration/jmh/hashing/XxHash.java   | 153 ++++++++
 .../pbj/integration/jmh/hashing/Xxh3.java     | 189 ++++++++++
 11 files changed, 1061 insertions(+), 429 deletions(-)
 delete mode 100644 pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CityHash.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/FasterLeemon.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/HashFunction.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/JavaStyleHashing.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTest.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQualityTest.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/XxHash.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/Xxh3.java

diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java
index 37ab38f1..4268133e 100644
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java
@@ -11,7 +11,8 @@
 /**
  * A set of utility methods on top of sun.misc.Unsafe
  */
-public class UnsafeUtils {
+@SuppressWarnings("GrazieInspection")
+public final class UnsafeUtils {
 
     private static final Unsafe UNSAFE;
 
@@ -126,6 +127,18 @@ public static int getInt(final byte[] arr, final int offset) {
         return NEED_CHANGE_BYTE_ORDER ? Integer.reverseBytes(value) : value;
     }
 
+    /**
+     * Reads an integer from the given array starting at the given offset. Array bytes are
+     * interpreted in NATIVE order.
+     *
+     * @param arr The byte array
+     * @param offset The offset to read an integer at
+     * @return The integer number
+     */
+    public static int getIntUnsafeNative(final byte[] arr, final int offset) {
+        return UNSAFE.getInt(arr, BYTE_ARRAY_BASE_OFFSET + offset);
+    }
+
     /**
      * Reads a long from the given array starting at the given offset. Array bytes are
      * interpreted in BIG_ENDIAN order.
@@ -183,6 +196,18 @@ public static long getLongNoChecksReverseOrder(final byte[] arr, final long offs
         return Long.reverseBytes(value);
     }
 
+    /**
+     * Reads a long from the given array starting at the given offset. Array bytes are
+     * interpreted in NATIVE order.
+     *
+     * @param arr The byte array
+     * @param offset The offset to read a long at
+     * @return The long number
+     */
+    public static long getLongUnsafeNative(final byte[] arr, final int offset) {
+        return UNSAFE.getLong(arr, BYTE_ARRAY_BASE_OFFSET + offset);
+    }
+
     /**
      * Copies heap byte buffer bytes to a given byte array. May only be called for heap
      * byte buffers
diff --git a/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java b/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
deleted file mode 100644
index 5e989e0e..00000000
--- a/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
+++ /dev/null
@@ -1,337 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-package com.hedera.pbj.runtime;
-
-import static com.hedera.pbj.runtime.NonCryptographicHashing.hash64;
-import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotEquals;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-import com.hedera.pbj.runtime.io.UnsafeUtils;
-import java.nio.ByteBuffer;
-import java.util.HashSet;
-import java.util.Random;
-import java.util.Set;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-
-@DisplayName("Non-Cryptographic Hash Test")
-class NonCryptographicHashTest {
-    //      * TEST: what happens if position > length of the byte array?
-    //     * TEST: what happens if position < 0?
-    //     * TEST: what happens if length < 0?
-    //     * TEST: what happens if position + length > byte array length?
-    //     * TEST: what happens if the byte array is 0? (with length = 0 and position = 0. Anything else is illegal with byte array 0).
-
-    /**
-     * Test the hash64(long) method with known values. The computation is very simple to do with any
-     * calculator,
-     */
-    @Test
-    @DisplayName("Test Hash64(long) Long with Known Values")
-    void testHash64Long() {
-        assertEquals(605873356528442819L, NonCryptographicHashing.hash64(0L));
-        assertEquals(4748194389872103055L, NonCryptographicHashing.hash64(1L));
-        assertEquals(5797980124308584942L, NonCryptographicHashing.hash64(-1L));
-        assertEquals(6218562537029544279L, NonCryptographicHashing.hash64(1234567890123456789L));
-    }
-
-    /**
-     * Test the hash64(byte[]) method with an empty byte array. This computation is also very simple
-     * to do with any calculator, and the result is known. We want to show that hashing an empty
-     * array is OK.
-     */
-    @Test
-    @DisplayName("Test Hash64(byte[]) Empty Array")
-    void testHash64ByteArrayEmpty() {
-        assertEquals(3230899725752021667L, NonCryptographicHashing.hash64(new byte[0]));
-    }
-
-    /**
-     * Test the hash64(byte[], int, int) method with an empty byte array, position 0, and length 0.
-     */
-    @Test
-    @DisplayName("Test Hash64(byte[], int, int) Empty Array with Valid Position and Length")
-    void testHash64ByteArrayEmptyWithPositionAndLength() {
-        assertEquals(3230899725752021667L, NonCryptographicHashing.hash64(new byte[0], 0, 0));
-    }
-
-    /**
-     * Test the hash64(byte[], int, int) method with position > length of the byte array.
-     */
-    @Test
-    @DisplayName("Test Hash64(byte[], int, int) Position Exceeds Array Length")
-    @Disabled("Disabled for now. I don't want to do the check and slow things down. Do we care about this?")
-    void testHash64ByteArrayPositionExceedsLength() {
-        byte[] arr = new byte[5];
-        // At the moment just returns the hash of 255.
-        assertThrows(IndexOutOfBoundsException.class, () -> NonCryptographicHashing.hash64(arr, 6, 0));
-    }
-
-    /**
-     * Test the hash64(byte[], int, int) method with position < 0.
-     */
-    @Test
-    @DisplayName("Test Hash64(byte[], int, int) Negative Position")
-    @Disabled("Disabled for now. I don't want to do the check and slow things down. Do we care about this?")
-    void testHash64ByteArrayNegativePosition() {
-        byte[] arr = new byte[5];
-        // At the moment just returns the hash of 255.
-        assertThrows(IndexOutOfBoundsException.class, () -> NonCryptographicHashing.hash64(arr, -1, 0));
-    }
-
-    /**
-     * Test the hash64(byte[], int, int) method with length < 0.
-     */
-    @Test
-    @DisplayName("Test Hash64(byte[], int, int) Negative Length")
-    @Disabled("Disabled for now. I don't want to do the check and slow things down. Do we care about this?")
-    void testHash64ByteArrayNegativeLength() {
-        byte[] arr = new byte[5];
-        // At the moment just returns the hash of 255.
-        assertThrows(IllegalArgumentException.class, () -> NonCryptographicHashing.hash64(arr, 0, -1));
-    }
-
-    /**
-     * Test the hash64(byte[], int, int) method with position + length > byte array length.
-     */
-    @Test
-    @DisplayName("Test Hash64(byte[], int, int) Position Plus Length Exceeds Array Length")
-    void testHash64ByteArrayPositionPlusLengthExceeds() {
-        byte[] arr = new byte[5];
-        assertThrows(IndexOutOfBoundsException.class, () -> NonCryptographicHashing.hash64(arr, 2, 4));
-    }
-
-    /**
-     * Test the hash64(byte[]) method with a one-byte array. This shows what happens if we have less than 8 bytes.
-     * The constant was found by calculating by hand the expected result.
-     */
-    @Test
-    @DisplayName("Test Hash64(byte[]) with array less than 8 bytes")
-    void testHash64ByteArrayLessThan8Bytes() {
-        byte[] arr = {(byte) 1};
-        assertEquals(1450858126797791778L, NonCryptographicHashing.hash64(arr));
-    }
-
-    /**
-     * Test the hash64(byte[]) method with an 8-byte array. This shows what happens if we test with exactly 8 bytes.
-     * The constant was found by calculating by hand the expected result.
-     */
-    @Test
-    @DisplayName("Test Hash64(byte[]) with 8 bytes")
-    void testHash64ByteArray8Bytes() {
-        byte[] arr = {(byte) 1, (byte) 2, (byte) 3, (byte) 4,
-                (byte) 5, (byte) 6, (byte) 7, (byte) 8};
-
-        assertEquals(-5416501487484278819L, NonCryptographicHashing.hash64(arr));
-    }
-
-    /**
-     * Test the hash64(byte[]) method with a 12-byte array. This shows what happens if we test with more than
-     * 8 bytes, but not a multiple of 8. The constant was found by calculating by hand the expected result.
-     */
-    @Test
-    @DisplayName("Test Hash64(byte[]) with larger non-multiple of 8 bytes")
-    void testHash64ByteArrayMoreThan8ButNotMultipleOf8Bytes() {
-        byte[] arr = {(byte) 1, (byte) 2, (byte) 3, (byte) 4,
-                (byte) 5, (byte) 6, (byte) 7, (byte) 8,
-                (byte) 9, (byte) 10, (byte) 11, (byte) 12};
-
-        assertEquals(8717726722998256023L, NonCryptographicHashing.hash64(arr));
-    }
-
-    /**
-     * Test the hash64(byte[]) method with a 16-byte array. This shows what happens for arrays that are a multiple of 8.
-     * The constant was found by calculating by hand the expected result.
-     */
-    @Test
-    @DisplayName("Test Hash64(byte[]) with multiple of 8 bytes")
-    void testHash64ByteArrayMultipleOf8Bytes() {
-        byte[] arr = {(byte) 1, (byte) 2, (byte) 3, (byte) 4,
-                (byte) 5, (byte) 6, (byte) 7, (byte) 8,
-                (byte) 9, (byte) 10, (byte) 11, (byte) 12,
-                (byte) 13, (byte) 14, (byte) 15, (byte) 16};
-
-        assertEquals(-5797446293423483272L, NonCryptographicHashing.hash64(arr));
-    }
-
-    /**
-     * While not comprehensive, this test provides a basic sanity check that if you are given two arrays of different
-     * lengths, but they both have the same high byte set and all other bytes are zero, then they generate different
-     * hashes.
-     */
-    @Test
-    @DisplayName("Test arrays of various lengths with high byte set and all else zero do not collide")
-    void testLeadingOneHasNoCollisions() {
-        Set<Long> hashes = new HashSet<>();
-        for (int len = 1; len <= 16; len++) {
-            byte[] leadingOne = new byte[len];
-            long h1 = NonCryptographicHashing.hash64(leadingOne);
-            assertTrue(hashes.add(h1)); // asserts each is unique
-        }
-    }
-
-    /**
-     * While not comprehensive, this test provides a basic sanity check that if you are given two arrays of different
-     * lengths, but they both have all bytes set to 1, then they generate different hashes.
-     */
-    @Test
-    void testAllOnesHasNoCollisions() {
-        Set<Long> hashes = new HashSet<>();
-        for (int len = 1; len <= 16; len++) {
-            byte[] allOnes = new byte[len];
-            for (int i = 0; i < len; i++) allOnes[i] = (byte) 0xFF;
-            long h1 = NonCryptographicHashing.hash64(allOnes);
-            assertTrue(hashes.add(h1)); // asserts each is unique
-        }
-    }
-
-    /**
-     * This test checks that the hash64 method does not produce collisions for small arrays.
-     * It verifies that all possible byte combinations for arrays of length 1 and 2 produce unique hashes.
-     */
-    @Test
-    @DisplayName("Test No Collisions for Small Arrays")
-    void testNoCollisionsSmallArrays() {
-        // Length 1: all 256
-        Set<Long> set1 = new HashSet<>();
-        for (int i = 0; i < 256; i++) {
-            byte[] ba = {(byte) i};
-            assertTrue(set1.add(NonCryptographicHashing.hash64(ba)));
-        }
-
-        // Length 2: all 65536
-        Set<Long> set2 = new HashSet<>();
-        for (int i = 0; i < 256; i++) {
-            for (int j = 0; j < 256; j++) {
-                byte[] ba = {(byte) i, (byte) j};
-                assertTrue(set2.add(NonCryptographicHashing.hash64(ba)));
-            }
-        }
-    }
-
-    /**
-     * This test checks that the hash64 method does not produce collisions for larger sets of data.
-     * It verifies that all possible byte combinations up to the number 100,000 produce unique hashes.
-     */
-    @Test
-    @DisplayName("Test No Collisions for Large Sets")
-    void testNoCollisionsLargeSet() {
-        final int num = 100_000;
-        Set<Long> set = new HashSet<>();
-        for (int i = 0; i < num; i++) {
-            byte[] ba = ByteBuffer.allocate(4).putInt(i).array();
-            assertTrue(set.add(NonCryptographicHashing.hash64(ba)));
-        }
-    }
-
-    @Test
-    @DisplayName("Test Collisions with non-random data")
-    void testLowCollisionsLargeSet() {
-        // Given an 8 byte array, try changing only the first 2 bytes, and see if we get collisions.
-        // A bad hash function would produce many collisions here. Then try again but changing out the middle
-        // 2 bytes. And do the same for the last 2 bytes.
-        final Set<Long> firstBytesSet = new HashSet<>();
-        final Set<Long> middleBytesSet = new HashSet<>();
-        final Set<Long> lastBytesSet = new HashSet<>();
-        final byte[] arr = { (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04,
-                             (byte) 0x05, (byte) 0x06, (byte) 0x07, (byte) 0x08 };
-        for (int i = 0; i < 256; i++) {
-            for (int j = 0; j < 256; j++) {
-                // Change the first two bytes
-                arr[6] = (byte) 0x07; // Reset last two bytes
-                arr[7] = (byte) 0x08; // Reset last two bytes
-                arr[0] = (byte) i;
-                arr[1] = (byte) j;
-                long hash1 = NonCryptographicHashing.hash64(arr);
-                assertTrue(firstBytesSet.add(hash1), "Collision found with first two bytes: iteration=" + i + ", long=" + Long.toHexString(UnsafeUtils.getLong(arr, 0)));
-
-                // Change the middle two bytes
-                arr[0] = (byte) 0x01; // Reset first two bytes
-                arr[1] = (byte) 0x02; // Reset first two bytes
-                arr[3] = (byte) i;
-                arr[4] = (byte) j;
-                long hash2 = NonCryptographicHashing.hash64(arr);
-                assertTrue(middleBytesSet.add(hash2), "Collision found with middle two bytes: iteration=" + i + ", long=" + Long.toHexString(UnsafeUtils.getLong(arr, 0)));
-
-                // Change the last two bytes
-                arr[3] = (byte) 0x03; // Reset middle two bytes
-                arr[4] = (byte) 0x04; // Reset middle two bytes
-                arr[6] = (byte) i;
-                arr[7] = (byte) j;
-                long hash3 = NonCryptographicHashing.hash64(arr);
-                assertTrue(lastBytesSet.add(hash3), "Collision found with last two bytes: iteration=" + i + ", long=" + Long.toHexString(UnsafeUtils.getLong(arr, 0)));
-            }
-        }
-    }
-
-    /**
-     * Checks that hashing a byte array with an offset produces the same result as hashing the same bytes directly.
-     */
-    @Test
-    @DisplayName("Test Hash with Offset")
-    void testHashWithOffset() {
-        byte[] large = new byte[255];
-        for (int i = 0; i < large.length; i++) {
-            large[i] = (byte) i;
-        }
-
-        // Try every subset where the start is changing but the length includes the last byte.
-        for (int i = 0; i < large.length; i++) {
-            int length = large.length - i;
-            byte[] subset = new byte[length];
-            System.arraycopy(large, i, subset, 0, length);
-            long expected = NonCryptographicHashing.hash64(subset);
-            long actual = NonCryptographicHashing.hash64(large, i, length);
-            assertEquals(expected, actual, "Hash with offset where start changes: " + i);
-        }
-
-        // Try every subset where the start is always 0 but the length is changing.
-        for (int i = 0; i < large.length; i++) {
-            int length = large.length - i;
-            byte[] subset = new byte[length];
-            System.arraycopy(large, 0, subset, 0, length);
-            long expected = NonCryptographicHashing.hash64(subset);
-            long actual = NonCryptographicHashing.hash64(large, 0, length);
-            assertEquals(expected, actual, "Hash with offset where length changes: " + i);
-        }
-    }
-
-    /**
-     * This test does not attempt to verify statistical properties of the hash functions.
-     * Its purpose is to ensure that none of the methods cause a crash.
-     */
-    @Test
-    @DisplayName("Test hash64")
-    void testHash64() {
-        final long seed = 842025;
-        final Random random = new Random(seed);
-
-        assertDoesNotThrow(() -> {
-            hash64(random.nextLong());
-
-            for (int i = 0; i < 100; i++) {
-                final byte[] bytes = new byte[i];
-                hash64(bytes);
-            }
-        });
-    }
-
-
-    @Test
-    @DisplayName("Hashes Are Not Degenerate 64")
-    void hashesAreNonDegenerate64() {
-        final long seed = 842025;
-        final Random random = new Random(seed);
-
-        assertNotEquals(0, hash64(0));
-        assertNotEquals(0, hash64(random.nextLong()));
-
-        for (int i = 0; i < 100; i++) {
-            final byte[] bytes = new byte[i];
-            assertNotEquals(0, hash64(bytes), "Hashes should be non-degenerate");
-        }
-    }
-}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java
index e55a9283..6645eb70 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java
@@ -1,18 +1,24 @@
 package com.hedera.pbj.integration.jmh;
 
+import com.hedera.pbj.integration.jmh.hashing.CityHash;
+import com.hedera.pbj.integration.jmh.hashing.FasterLeemon;
+import com.hedera.pbj.integration.jmh.hashing.HashFunction;
+import com.hedera.pbj.integration.jmh.hashing.JavaStyleHashing;
+import com.hedera.pbj.integration.jmh.hashing.XxHash;
+import com.hedera.pbj.integration.jmh.hashing.Xxh3;
 import com.hedera.pbj.runtime.NonCryptographicHashing;
-import edu.umd.cs.findbugs.annotations.NonNull;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
+import java.util.List;
 import java.util.Random;
 import java.util.concurrent.TimeUnit;
+import java.util.stream.IntStream;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
 import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Level;
 import org.openjdk.jmh.annotations.Measurement;
 import org.openjdk.jmh.annotations.Mode;
 import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
 import org.openjdk.jmh.annotations.Scope;
 import org.openjdk.jmh.annotations.Setup;
 import org.openjdk.jmh.annotations.State;
@@ -22,104 +28,56 @@
 @SuppressWarnings("unused")
 @State(Scope.Benchmark)
 @Fork(1)
-@Warmup(iterations = 4, time = 4)
-@Measurement(iterations = 10, time = 4)
+@Warmup(iterations = 4, time = 2)
+@Measurement(iterations = 4, time = 2)
 @OutputTimeUnit(TimeUnit.NANOSECONDS)
 @BenchmarkMode(Mode.AverageTime)
 public class NonCryptographicHashingBench {
-    public static final int DATA_SIZE = 10; // Size of the byte array to hash
-    public static final int SAMPLES = 1000;
+    public static final int SAMPLES = 10_000;
+    public enum HashAlgorithm {
+        LEEMON(NonCryptographicHashing::hash64),
+        FASTER_LEEMON(FasterLeemon::hash64),
+        JAVA_31(JavaStyleHashing::hash31),
+        JAVA_255(JavaStyleHashing::hash255),
+        JAVA_256(JavaStyleHashing::hash256),
+        XXHASH_32(XxHash::xxHashCode),
+        XXHASH_64(XxHash::xxHashCodeFast),
+        XXH3(Xxh3::xxh3HashCode),
+        CITY_HASH(CityHash::cityHash64);
+        public final HashFunction function;
 
-    private Random random;
-    private byte[][] sampleBytes;
-
-
-    @Setup
-    public void setup() {
-        random =new Random(6351384163846453326L);
-        sampleBytes = new byte[SAMPLES][DATA_SIZE];
-        for (int i = 0; i < SAMPLES; i++) {
-            sampleBytes[i] = new byte[DATA_SIZE];
-            random.nextBytes(sampleBytes[i]);
+        HashAlgorithm(HashFunction function) {
+            this.function = function;
         }
     }
 
-    @Benchmark
-    public void hashCodeOriginal(Blackhole blackhole){
-        byte[] bytes = sampleBytes[random.nextInt(SAMPLES)];
-        blackhole.consume(oldBytesHashCode(bytes,0,DATA_SIZE));
-    }
-
-    @Benchmark
-    public void hashCodeNonCryptographicHashing(Blackhole blackhole){
-        byte[] bytes = sampleBytes[random.nextInt(SAMPLES)];
-        blackhole.consume(NonCryptographicHashing.hash64(bytes, 0, DATA_SIZE));
-    }
-
-    @Benchmark
-    public void hashCodeNonCryptographicHashingVarHandle(Blackhole blackhole){
-        byte[] bytes = sampleBytes[random.nextInt(SAMPLES)];
-        blackhole.consume(hash64VarHandle(bytes, 0, DATA_SIZE));
-    }
+    @Param({"4", "8", "9", "12", "40", "60", "1000"})
+    public int dataSize;
+    @Param({"LEEMON", "FASTER_LEEMON", "JAVA_31", "JAVA_255", "JAVA_256", "XXHASH_32",
+            "XXHASH_64", "XXH3", "CITY_HASH"})
+    public HashAlgorithm hashAlgorithm;
 
+    private Random random;
+    private List<byte[]> sampleBytes;
 
-    /**
-     * Old hashcode implementation for Bytes from before it used NonCryptographicHashing. Slightly different as it is
-     * done from outside the Bytes class.
-     */
-    public int oldBytesHashCode(@NonNull final byte[] bytes, int start, int length) {
-        int h = 1;
-        for (int i = length - 1; i >= start; i--) {
-            h = 31 * h + bytes[i];
-        }
-        return h;
-    }
-
-    public static long hash64VarHandle(@NonNull final byte[] bytes, int start, int length) {
-        long hash = perm64(length);
-        for (int i = start; i < length; i += 8) {
-            hash = perm64(hash ^ byteArrayToLong(bytes, i));
-        }
-        return hash;
-    }
-
-    private static long perm64(long x) {
-        // This is necessary so that 0 does not hash to 0.
-        // As a side effect, this constant will hash to 0.
-        // It was randomly generated (not using Java),
-        // so that it will occur in practice less often than more
-        // common numbers like 0 or -1 or Long.MAX_VALUE.
-        x ^= 0x5e8a016a5eb99c18L;
-
-        // Shifts: {30, 27, 16, 20, 5, 18, 10, 24, 30}
-        x += x << 30;
-        x ^= x >>> 27;
-        x += x << 16;
-        x ^= x >>> 20;
-        x += x << 5;
-        x ^= x >>> 18;
-        x += x << 10;
-        x ^= x >>> 24;
-        x += x << 30;
-        return x;
+    @Setup(Level.Trial)
+    public void setup() {
+        random =new Random(6351384163846453326L);
+        sampleBytes = IntStream.range(0, SAMPLES)
+                .mapToObj(i -> {
+                    final byte[] bytes = new byte[dataSize];
+                    random.nextBytes(bytes);
+                    return bytes;
+                }).distinct().toList();
     }
 
-    public static long byteArrayToLong(final byte[] data, final int position) {
-        if (data.length > position + 8) {
-            return (long) vh.get(data, position);
-        } else {
-            // There isn't enough data to fill the long, so pad with zeros.
-            long result = 0;
-            for (int offset = 0; offset < 8; offset++) {
-                final int index = position + offset;
-                if (index >= data.length) {
-                    break;
-                }
-                result += (data[index] & 0xffL) << (8 * (7 - offset));
-            }
-            return result;
+    @Benchmark
+    public void testHashing(Blackhole blackhole) {
+        long sum = 0;
+        for (final byte[] bytes : sampleBytes) {
+            long hash = hashAlgorithm.function.applyAsLong(bytes, 0, dataSize);
+            sum += hash;
         }
+        blackhole.consume(sum);
     }
-
-    private static final VarHandle vh = MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.BIG_ENDIAN);
 }
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CityHash.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CityHash.java
new file mode 100644
index 00000000..be86e690
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CityHash.java
@@ -0,0 +1,356 @@
+package com.hedera.pbj.integration.jmh.hashing;
+
+import com.hedera.pbj.runtime.io.UnsafeUtils;
+
+/**
+ * @author tamtam180 - kirscheless at gmail.com
+ * @see http://google-opensource.blogspot.jp/2011/04/introducing-cityhash.html
+ * @see http://code.google.com/p/cityhash/
+ */
+public class CityHash {
+
+    private static final long k0 = 0xc3a5c85c97cb3127L;
+    private static final long k1 = 0xb492b66fbe98f273L;
+    private static final long k2 = 0x9ae16a3b2f90404fL;
+    private static final long k3 = 0xc949d7c7509e6557L;
+//
+//    private static long toLongLE(byte[] b, int i) {
+//        return (((long) b[i + 7] << 56) +
+//                ((long) (b[i + 6] & 255) << 48) +
+//                ((long) (b[i + 5] & 255) << 40) +
+//                ((long) (b[i + 4] & 255) << 32) +
+//                ((long) (b[i + 3] & 255) << 24) +
+//                ((b[i + 2] & 255) << 16) +
+//                ((b[i + 1] & 255) << 8) +
+//                ((b[i + 0] & 255) << 0));
+//    }
+    private static long toLongLE(byte[] b, int i) {
+        return UnsafeUtils.getLongUnsafeNative(b, i);
+    }
+
+//    private static int toIntLE(byte[] b, int i) {
+//        return (((b[i + 3] & 255) << 24) + ((b[i + 2] & 255) << 16) + ((b[i + 1] & 255) << 8) + ((b[i + 0] & 255) << 0));
+//    }
+    private static int toIntLE(byte[] b, int i) {
+        return UnsafeUtils.getIntUnsafeNative(b, i);
+    }
+
+    private static long fetch64(byte[] s, int pos) {
+        return toLongLE(s, pos);
+    }
+
+    private static int fetch32(byte[] s, int pos) {
+        return toIntLE(s, pos);
+    }
+
+    private static long rotate(long val, int shift) {
+        return shift == 0 ? val : (val >>> shift) | (val << (64 - shift));
+    }
+
+    private static long rotateByAtLeast1(long val, int shift) {
+        return (val >>> shift) | (val << (64 - shift));
+    }
+
+    private static long shiftMix(long val) {
+        return val ^ (val >>> 47);
+    }
+
+    private static final long kMul = 0x9ddfea08eb382d69L;
+
+    private static long hash128to64(long u, long v) {
+        long a = (u ^ v) * kMul;
+        a ^= (a >>> 47);
+        long b = (v ^ a) * kMul;
+        b ^= (b >>> 47);
+        b *= kMul;
+        return b;
+    }
+
+    private static long hashLen16(long u, long v) {
+        return hash128to64(u, v);
+    }
+
+    private static long hashLen0to16(byte[] s, int pos, int len) {
+        if (len > 8) {
+            long a = fetch64(s, pos + 0);
+            long b = fetch64(s, pos + len - 8);
+            return hashLen16(a, rotateByAtLeast1(b + len, len)) ^ b;
+        }
+        if (len >= 4) {
+            long a = 0xffffffffL & fetch32(s, pos + 0);
+            return hashLen16((a << 3) + len, 0xffffffffL & fetch32(s, pos + len - 4));
+        }
+        if (len > 0) {
+            int a = s[pos + 0] & 0xFF;
+            int b = s[pos + (len >>> 1)] & 0xFF;
+            int c = s[pos + len - 1] & 0xFF;
+            int y = a + (b << 8);
+            int z = len + (c << 2);
+            return shiftMix(y * k2 ^ z * k3) * k2;
+        }
+        return k2;
+    }
+
+    private static long hashLen17to32(byte[] s, int pos, int len) {
+        long a = fetch64(s, pos + 0) * k1;
+        long b = fetch64(s, pos + 8);
+        long c = fetch64(s, pos + len - 8) * k2;
+        long d = fetch64(s, pos + len - 16) * k0;
+        return hashLen16(
+                rotate(a - b, 43) + rotate(c, 30) + d,
+                a + rotate(b ^ k3, 20) - c + len
+        );
+    }
+
+    private static long[] weakHashLen32WithSeeds(
+            long w, long x, long y, long z,
+            long a, long b) {
+
+        a += w;
+        b = rotate(b + a + z, 21);
+        long c = a;
+        a += x;
+        a += y;
+        b += rotate(a, 44);
+        return new long[]{a + z, b + c};
+    }
+
+    private static long[] weakHashLen32WithSeeds(byte[] s, int pos, long a, long b) {
+        return weakHashLen32WithSeeds(
+                fetch64(s, pos + 0),
+                fetch64(s, pos + 8),
+                fetch64(s, pos + 16),
+                fetch64(s, pos + 24),
+                a,
+                b
+        );
+    }
+
+    private static long hashLen33to64(byte[] s, int pos, int len) {
+
+        long z = fetch64(s, pos + 24);
+        long a = fetch64(s, pos + 0) + (fetch64(s, pos + len - 16) + len) * k0;
+        long b = rotate(a + z, 52);
+        long c = rotate(a, 37);
+
+        a += fetch64(s, pos + 8);
+        c += rotate(a, 7);
+        a += fetch64(s, pos + 16);
+
+        long vf = a + z;
+        long vs = b + rotate(a, 31) + c;
+
+        a = fetch64(s, pos + 16) + fetch64(s, pos + len - 32);
+        z = fetch64(s, pos + len - 8);
+        b = rotate(a + z, 52);
+        c = rotate(a, 37);
+        a += fetch64(s, pos + len - 24);
+        c += rotate(a, 7);
+        a += fetch64(s, pos + len - 16);
+
+        long wf = a + z;
+        long ws = b + rotate(a, 31) + c;
+        long r = shiftMix((vf + ws) * k2 + (wf + vs) * k0);
+
+        return shiftMix(r * k0 + vs) * k2;
+
+    }
+
+    public static String cityHash64Hex(byte[] s, int pos, int len) {
+        long l = cityHash64(s, pos, len);
+
+        return Long.toHexString(l);
+    }
+
+    public static String cityHash64WithSeedHex(byte[] s, int pos, int len, long seed) {
+        long l = cityHash64WithSeed(s, pos, len, seed);
+
+        return Long.toHexString(l);
+    }
+
+    public static String cityHash64WithSeedsHex(byte[] s, int pos, int len, long seed0, long seed1) {
+        long l = cityHash64WithSeeds(s, pos, len, seed0, seed1);
+
+        return Long.toHexString(l);
+    }
+
+    public static long cityHash64(byte[] s, int pos, int len) {
+
+        if (len <= 32) {
+            if (len <= 16) {
+                return hashLen0to16(s, pos, len);
+            } else {
+                return hashLen17to32(s, pos, len);
+            }
+        } else if (len <= 64) {
+            return hashLen33to64(s, pos, len);
+        }
+
+        long x = fetch64(s, pos + len - 40);
+        long y = fetch64(s, pos + len - 16) + fetch64(s, pos + len - 56);
+        long z = hashLen16(fetch64(s, pos + len - 48) + len, fetch64(s, pos + len - 24));
+
+        long[] v = weakHashLen32WithSeeds(s, pos + len - 64, len, z);
+        long[] w = weakHashLen32WithSeeds(s, pos + len - 32, y + k1, x);
+        x = x * k1 + fetch64(s, pos + 0);
+
+        len = (len - 1) & (~63);
+        do {
+            x = rotate(x + y + v[0] + fetch64(s, pos + 8), 37) * k1;
+            y = rotate(y + v[1] + fetch64(s, pos + 48), 42) * k1;
+            x ^= w[1];
+            y += v[0] + fetch64(s, pos + 40);
+            z = rotate(z + w[0], 33) * k1;
+            v = weakHashLen32WithSeeds(s, pos + 0, v[1] * k1, x + w[0]);
+            w = weakHashLen32WithSeeds(s, pos + 32, z + w[1], y + fetch64(s, pos + 16));
+            {
+                long swap = z;
+                z = x;
+                x = swap;
+            }
+            pos += 64;
+            len -= 64;
+        } while (len != 0);
+
+        return hashLen16(
+                hashLen16(v[0], w[0]) + shiftMix(y) * k1 + z,
+                hashLen16(v[1], w[1]) + x
+        );
+
+    }
+
+    public static long cityHash64WithSeed(byte[] s, int pos, int len, long seed) {
+        return cityHash64WithSeeds(s, pos, len, k2, seed);
+    }
+
+    public static long cityHash64WithSeeds(byte[] s, int pos, int len, long seed0, long seed1) {
+        return hashLen16(cityHash64(s, pos, len) - seed0, seed1);
+    }
+
+    public static long[] cityMurmur(byte[] s, int pos, int len, long seed0, long seed1) {
+
+        long a = seed0;
+        long b = seed1;
+        long c = 0;
+        long d = 0;
+
+        int l = len - 16;
+        if (l <= 0) {
+            a = shiftMix(a * k1) * k1;
+            c = b * k1 + hashLen0to16(s, pos, len);
+            d = shiftMix(a + (len >= 8 ? fetch64(s, pos + 0) : c));
+        } else {
+
+            c = hashLen16(fetch64(s, pos + len - 8) + k1, a);
+            d = hashLen16(b + len, c + fetch64(s, pos + len - 16));
+            a += d;
+
+            do {
+                a ^= shiftMix(fetch64(s, pos + 0) * k1) * k1;
+                a *= k1;
+                b ^= a;
+                c ^= shiftMix(fetch64(s, pos + 8) * k1) * k1;
+                c *= k1;
+                d ^= c;
+                pos += 16;
+                l -= 16;
+            } while (l > 0);
+        }
+
+        a = hashLen16(a, c);
+        b = hashLen16(d, b);
+
+        return new long[]{a ^ b, hashLen16(b, a)};
+
+    }
+
+    public static long[] cityHash128WithSeed(byte[] s, int pos, int len, long seed0, long seed1) {
+
+        if (len < 128) {
+            return cityMurmur(s, pos, len, seed0, seed1);
+        }
+
+        long[] v = new long[2], w = new long[2];
+        long x = seed0;
+        long y = seed1;
+        long z = k1 * len;
+
+        v[0] = rotate(y ^ k1, 49) * k1 + fetch64(s, pos);
+        v[1] = rotate(v[0], 42) * k1 + fetch64(s, pos + 8);
+        w[0] = rotate(y + z, 35) * k1 + x;
+        w[1] = rotate(x + fetch64(s, pos + 88), 53) * k1;
+
+        do {
+            x = rotate(x + y + v[0] + fetch64(s, pos + 8), 37) * k1;
+            y = rotate(y + v[1] + fetch64(s, pos + 48), 42) * k1;
+
+            x ^= w[1];
+            y += v[0] + fetch64(s, pos + 40);
+            z = rotate(z + w[0], 33) * k1;
+            v = weakHashLen32WithSeeds(s, pos + 0, v[1] * k1, x + w[0]);
+            w = weakHashLen32WithSeeds(s, pos + 32, z + w[1], y + fetch64(s, pos + 16));
+            {
+                long swap = z;
+                z = x;
+                x = swap;
+            }
+            pos += 64;
+            x = rotate(x + y + v[0] + fetch64(s, pos + 8), 37) * k1;
+            y = rotate(y + v[1] + fetch64(s, pos + 48), 42) * k1;
+            x ^= w[1];
+            y += v[0] + fetch64(s, pos + 40);
+            z = rotate(z + w[0], 33) * k1;
+            v = weakHashLen32WithSeeds(s, pos, v[1] * k1, x + w[0]);
+            w = weakHashLen32WithSeeds(s, pos + 32, z + w[1], y + fetch64(s, pos + 16));
+            {
+                long swap = z;
+                z = x;
+                x = swap;
+            }
+            pos += 64;
+            len -= 128;
+        } while (len >= 128);
+
+        x += rotate(v[0] + z, 49) * k0;
+        z += rotate(w[0], 37) * k0;
+
+        for (int tail_done = 0; tail_done < len; ) {
+            tail_done += 32;
+            y = rotate(x + y, 42) * k0 + v[1];
+            w[0] += fetch64(s, pos + len - tail_done + 16);
+            x = x * k0 + w[0];
+            z += w[1] + fetch64(s, pos + len - tail_done);
+            w[1] += v[0];
+            v = weakHashLen32WithSeeds(s, pos + len - tail_done, v[0] + z, v[1]);
+        }
+
+        x = hashLen16(x, v[0]);
+        y = hashLen16(y + z, w[0]);
+
+        return new long[]{
+                hashLen16(x + v[1], w[1]) + y,
+                hashLen16(x + w[1], y + v[1])
+        };
+
+    }
+
+    public static long[] cityHash128(byte[] s, int pos, int len) {
+
+        if (len >= 16) {
+            return cityHash128WithSeed(
+                    s, pos + 16,
+                    len - 16,
+                    fetch64(s, pos + 0) ^ k3,
+                    fetch64(s, pos + 8)
+            );
+        } else if (len >= 8) {
+            return cityHash128WithSeed(
+                    new byte[0], 0, 0,
+                    fetch64(s, pos + 0) ^ (len * k0),
+                    fetch64(s, pos + len - 8) ^ k1
+            );
+        } else {
+            return cityHash128WithSeed(s, pos, len, k0, k1);
+        }
+    }
+}
\ No newline at end of file
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/FasterLeemon.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/FasterLeemon.java
new file mode 100644
index 00000000..a64c0f2c
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/FasterLeemon.java
@@ -0,0 +1,81 @@
+package com.hedera.pbj.integration.jmh.hashing;
+
+import com.hedera.pbj.runtime.io.UnsafeUtils;
+import edu.umd.cs.findbugs.annotations.NonNull;
+
+/**
+ * Performs a non-cryptographic 64-bit hash function based on the Leemon algorithm.
+ */
+public final class FasterLeemon {
+    /**
+     * Generates a non-cryptographic 64-bit hash for a byte array.
+     *
+     * @param bytes
+     * 		a byte array
+     * @param start
+     *         the start index in the byte array
+     * @param length
+     *         the number of bytes to hash
+     * @return a non-cryptographic long hash
+     */
+    public static long hash64(@NonNull final byte[] bytes, final int start, final int length) {
+        long hash = 0;
+        int i = start;
+        for (; i < start + length - 7; i += 8) {
+            hash = perm64(hash ^ UnsafeUtils.getLongUnsafeNative(bytes, i));
+        }
+
+        long tail = 0xFF;
+        for (; i < start + length; i++) {
+            tail <<= 8;
+            tail |= bytes[i];
+        }
+        hash = perm64(hash ^ tail);
+
+        return hash;
+    }
+
+    private static long perm64(long x) {
+        // This is necessary so that 0 does not hash to 0.
+        // As a side effect, this constant will hash to 0.
+        // It was randomly generated (not using Java),
+        // so that it will occur in practice less often than more
+        // common numbers like 0 or -1 or Long.MAX_VALUE.
+        x ^= 0x5e8a016a5eb99c18L;
+
+        // Shifts: {30, 27, 16, 20, 5, 18, 10, 24, 30}
+        x += x << 30;
+        x ^= x >>> 27;
+        x += x << 16;
+        x ^= x >>> 20;
+        x += x << 5;
+        x ^= x >>> 18;
+        x += x << 10;
+        x ^= x >>> 24;
+        x += x << 30;
+        return x;
+    }
+
+// Sample vectorized version commented out for now, as it requires JDK 21+ and the vector API is still incubating.
+//    /**
+//     * Vectorized version for processing multiple long values in parallel.
+//     * This can be useful when hashing multiple values or for internal operations.
+//     */
+//    private static LongVector perm64Vector(LongVector v) {
+//        // Apply the XOR constant
+//        v = v.lanewise(VectorOperators.XOR, XOR_CONSTANT);
+//
+//        // Perform the permutation operations using vector operations
+//        v = v.add(v.lanewise(VectorOperators.LSHL, 30));
+//        v = v.lanewise(VectorOperators.XOR, v.lanewise(VectorOperators.LSHR, 27));
+//        v = v.add(v.lanewise(VectorOperators.LSHL, 16));
+//        v = v.lanewise(VectorOperators.XOR, v.lanewise(VectorOperators.LSHR, 20));
+//        v = v.add(v.lanewise(VectorOperators.LSHL, 5));
+//        v = v.lanewise(VectorOperators.XOR, v.lanewise(VectorOperators.LSHR, 18));
+//        v = v.add(v.lanewise(VectorOperators.LSHL, 10));
+//        v = v.lanewise(VectorOperators.XOR, v.lanewise(VectorOperators.LSHR, 24));
+//        v = v.add(v.lanewise(VectorOperators.LSHL, 30));
+//
+//        return v;
+//    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/HashFunction.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/HashFunction.java
new file mode 100644
index 00000000..5913fa3d
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/HashFunction.java
@@ -0,0 +1,7 @@
+package com.hedera.pbj.integration.jmh.hashing;
+
+import edu.umd.cs.findbugs.annotations.NonNull;
+
+public interface HashFunction {
+    long applyAsLong(@NonNull final byte[] bytes, int start, int length);
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/JavaStyleHashing.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/JavaStyleHashing.java
new file mode 100644
index 00000000..758ebc62
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/JavaStyleHashing.java
@@ -0,0 +1,33 @@
+package com.hedera.pbj.integration.jmh.hashing;
+
+import edu.umd.cs.findbugs.annotations.NonNull;
+
+/**
+ * Versions of the traditional Java-style hashing algorithms with different multiplier constants. The 31 constant is
+ * what is used in JDK hashCode() methods, while 255 and 256 are interesting alternatives.
+ */
+public class JavaStyleHashing {
+    public static int hash31(@NonNull final byte[] bytes, int start, int length) {
+        int h = 1;
+        for (int i = length - 1; i >= start; i--) {
+            h = 31 * h + bytes[i];
+        }
+        return h;
+    }
+
+    public static int hash255(@NonNull final byte[] bytes, int start, int length) {
+        int h = 1;
+        for (int i = length - 1; i >= start; i--) {
+            h = 255 * h + bytes[i];
+        }
+        return h;
+    }
+
+    public static int hash256(@NonNull final byte[] bytes, int start, int length) {
+        int h = 1;
+        for (int i = length - 1; i >= start; i--) {
+            h =256 * h + bytes[i];
+        }
+        return h;
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTest.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTest.java
new file mode 100644
index 00000000..9e3d32de
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTest.java
@@ -0,0 +1,118 @@
+package com.hedera.pbj.integration.jmh.hashing;
+
+import com.hedera.pbj.integration.jmh.NonCryptographicHashingBench;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+
+/**
+ * A test to evaluate the quality of non-cryptographic hash functions
+ * by checking how many unique hashes can be generated from 4-byte inputs.
+ * It runs through all combinations of 4 bytes (256^4 = 4,294,967,296 combinations).
+ */
+public final class NonCryptographicHashQuality4ByteTest {
+    public static void main(String[] args) {
+        System.out.println("Testing non-cryptographic hash quality - 4 bytes, 4 billion inputs");
+        for (var hashAlgorithm : NonCryptographicHashingBench.HashAlgorithm.values()) {
+            System.out.println("Testing " + hashAlgorithm.name()+ " ====================================");
+            testHashQuality4Bytes(hashAlgorithm);
+        }
+    }
+
+    private static void testHashQuality4Bytes(NonCryptographicHashingBench.HashAlgorithm hashAlgorithm) {
+        final long START_TIME = System.currentTimeMillis();
+        final LongBitSet bits = new LongBitSet(4_294_967_296L); // 4 billion bits
+        final byte[] ba = new byte[6];
+        for (int i = 0; i < 256; i++) {
+            // print progress as percentage, overwriting the same line
+                System.out.printf("\r       Progress: %d%%", (i * 100) / 256);
+                System.out.flush();
+            for (int j = 0; j < 256; j++) {
+                for (int k = 0; k < 256; k++) {
+                    for (int l = 0; l < 256; l++) {
+                        ba[0] = (byte) i;
+                        ba[1] = (byte) j;
+                        ba[2] = (byte) k;
+                        ba[3] = (byte) l;
+                        long hash = hashAlgorithm.function.applyAsLong(ba, 0, 4);
+                        int bucket = (int) hash;
+                        bits.setBit(bucket & 0xFFFFFFFFL); // Use only the lower 32 bits
+                    }
+                }
+            }
+        }
+
+        // Check that we have a reasonable number of bits set.
+        long numUniqueHashes = bits.cardinality();
+        long expectedUniqueHashes = 256L * 256 * 256 * 256; // 4-byte combinations
+        long hashCollisions = expectedUniqueHashes - numUniqueHashes;
+        final long END_TIME = System.currentTimeMillis();
+        System.out.printf("       Number of unique hashes: %,d, hash collisions: %,d, time taken: %.3f seconds%n",
+                numUniqueHashes, hashCollisions,  (END_TIME - START_TIME) / 1000.0);
+    }
+
+    /**
+     * A simple long bit set implementation that uses an array of longs to represent bits.
+     */
+    static final class LongBitSet {
+        private static final int BITS_PER_LONG = 64;
+        private static final int SHIFT = 6; // log2(64)
+        private static final long MASK = 0x3FL; // 63
+
+        private final long[] bits;
+        private final long maxBits;
+
+        private static final VarHandle BITS_HANDLE;
+
+        static {
+            try {
+                BITS_HANDLE = MethodHandles.arrayElementVarHandle(long[].class);
+            } catch (Exception e) {
+                throw new ExceptionInInitializerError(e);
+            }
+        }
+
+        public LongBitSet(long size) {
+            // Round up to next power of 2
+            long numLongs = size / BITS_PER_LONG;
+            this.bits = new long[(int) numLongs];
+            this.maxBits = size;
+        }
+
+        public void setBit(long index) {
+            if (index < 0 || index >= maxBits) {
+                throw new IndexOutOfBoundsException("index: " + index);
+            }
+
+            int longIndex = (int) (index >>> SHIFT);
+            long bitMask = 1L << (index & MASK);
+
+            bits[longIndex] |= bitMask;
+        }
+
+        public void setBitThreadSafe(long index) {
+            if (index < 0 || index >= maxBits) {
+                throw new IndexOutOfBoundsException("index: " + index);
+            }
+
+            int longIndex = (int) (index >>> SHIFT);
+            long bitMask = 1L << (index & MASK);
+
+            long current;
+            do {
+                current = (long) BITS_HANDLE.getVolatile(bits, longIndex);
+                if ((current & bitMask) != 0) {
+                    return; // Already set
+                }
+            } while (!BITS_HANDLE.compareAndSet(bits, longIndex, current, current | bitMask));
+        }
+
+        public long cardinality() {
+            long count = 0;
+            for (long value : bits) {
+                count += Long.bitCount(value);
+            }
+            return count;
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQualityTest.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQualityTest.java
new file mode 100644
index 00000000..2abf4a3c
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQualityTest.java
@@ -0,0 +1,49 @@
+package com.hedera.pbj.integration.jmh.hashing;
+
+import com.hedera.pbj.integration.jmh.NonCryptographicHashingBench;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * A test to evaluate the quality of non-cryptographic hash functions
+ * by checking how many unique hashes can be generated from 11-byte inputs.
+ * It runs through all 500 million combinations.
+ */
+public final class NonCryptographicHashQualityTest {
+    public static void main(String[] args) {
+        System.out.println("Testing non-cryptographic hash quality - 11 bytes, 500 million inputs");
+        for (var hashAlgorithm : NonCryptographicHashingBench.HashAlgorithm.values()) {
+            System.out.println("Testing " + hashAlgorithm.name()+ " ====================================");
+            testHashQuality11Bytes2Billion(hashAlgorithm);
+        }
+    }
+
+    private static void testHashQuality11Bytes2Billion(NonCryptographicHashingBench.HashAlgorithm hashAlgorithm) {
+        final long START_TIME = System.currentTimeMillis();
+        final long NUM_INPUTS = 500_000_000L; // 500 million inputs
+        final int NUM_BYTES = 11; // 11 bytes = 88 bits of data input
+        final Set<Long> hashes = new HashSet<>();
+        final byte[] ba = new byte[NUM_BYTES];
+
+        for (long i = 0; i < NUM_INPUTS; i++) {
+            if (i % 10_000_000 == 0) {
+                System.out.printf("\r       Progress: %.2f%%", (i * 100.0) / NUM_INPUTS);
+                System.out.flush();
+            }
+            long value = i;
+            for (int j = 0; j < NUM_BYTES; j++) {
+                // Map each byte to 1..255 (never zero)
+                ba[j] = (byte) ((value % 255) + 1);
+                value /= 255;
+            }
+            final long hash = hashAlgorithm.function.applyAsLong(ba, 0, NUM_BYTES);
+            hashes.add(hash);
+        }
+
+        long numUniqueHashes = hashes.size();
+        long hashCollisions = NUM_INPUTS - numUniqueHashes;
+        final long END_TIME = System.currentTimeMillis();
+        System.out.printf("       Number of unique hashes: %,d, hash collisions: %,d, time taken: %.3f seconds%n",
+                numUniqueHashes, hashCollisions, (END_TIME - START_TIME) / 1000.0);
+    }
+}
\ No newline at end of file
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/XxHash.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/XxHash.java
new file mode 100644
index 00000000..5d38c82a
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/XxHash.java
@@ -0,0 +1,153 @@
+package com.hedera.pbj.integration.jmh.hashing;
+
+import edu.umd.cs.findbugs.annotations.NonNull;
+
+public class XxHash {
+
+    public static int xxHashCodeFast(@NonNull final byte[] bytes, int start, int length) {
+        final long PRIME1 = 0x9E3779B185EBCA87L;
+        final long PRIME2 = 0xC2B2AE3D27D4EB4FL;
+        final long PRIME3 = 0x165667B19E3779F9L;
+        final long PRIME4 = 0x85EBCA776C2B2AE1L;
+        final long PRIME5 = 0x27D4EB2F165667C5L;
+
+        final int seed = 0;
+        final int end = start + length;
+        long h64;
+
+        if (length >= 32) {
+            final int limit = end - 32;
+            long v1 = seed + PRIME1 + PRIME2;
+            long v2 = seed + PRIME2;
+            long v3 = seed;
+            long v4 = seed - PRIME1;
+
+            do {
+                v1 = Long.rotateLeft(v1 + getLong(bytes, start) * PRIME2, 31) * PRIME1;
+                start += 8;
+                v2 = Long.rotateLeft(v2 + getLong(bytes, start) * PRIME2, 31) * PRIME1;
+                start += 8;
+                v3 = Long.rotateLeft(v3 + getLong(bytes, start) * PRIME2, 31) * PRIME1;
+                start += 8;
+                v4 = Long.rotateLeft(v4 + getLong(bytes, start) * PRIME2, 31) * PRIME1;
+                start += 8;
+            } while (start <= limit);
+
+            h64 = Long.rotateLeft(v1, 1) + Long.rotateLeft(v2, 7) +
+                    Long.rotateLeft(v3, 12) + Long.rotateLeft(v4, 18);
+
+            h64 = (h64 ^ Long.rotateLeft(v1 * PRIME2, 31) * PRIME1) * PRIME1 + PRIME4;
+            h64 = (h64 ^ Long.rotateLeft(v2 * PRIME2, 31) * PRIME1) * PRIME1 + PRIME4;
+            h64 = (h64 ^ Long.rotateLeft(v3 * PRIME2, 31) * PRIME1) * PRIME1 + PRIME4;
+            h64 = (h64 ^ Long.rotateLeft(v4 * PRIME2, 31) * PRIME1) * PRIME1 + PRIME4;
+        } else {
+            h64 = seed + PRIME5;
+        }
+
+        h64 += length;
+
+        while (start <= end - 8) {
+            h64 = Long.rotateLeft(h64 ^ Long.rotateLeft(getLong(bytes, start) * PRIME2, 31) * PRIME1, 27) * PRIME1 + PRIME4;
+            start += 8;
+        }
+
+        if (start <= end - 4) {
+            h64 = Long.rotateLeft(h64 ^ (getInt(bytes, start) * PRIME1), 23) * PRIME2 + PRIME3;
+            start += 4;
+        }
+
+        while (start < end) {
+            h64 = Long.rotateLeft(h64 ^ ((bytes[start] & 0xFF) * PRIME5), 11) * PRIME1;
+            start++;
+        }
+
+        h64 ^= h64 >>> 33;
+        h64 *= PRIME2;
+        h64 ^= h64 >>> 29;
+        h64 *= PRIME3;
+        h64 ^= h64 >>> 32;
+
+//        return (int)(h64 ^ (h64 >>> 32));
+        return (int) h64;
+    }
+
+    private static long getLong(byte[] bytes, int offset) {
+        return (bytes[offset] & 0xFFL) |
+                ((bytes[offset + 1] & 0xFFL) << 8) |
+                ((bytes[offset + 2] & 0xFFL) << 16) |
+                ((bytes[offset + 3] & 0xFFL) << 24) |
+                ((bytes[offset + 4] & 0xFFL) << 32) |
+                ((bytes[offset + 5] & 0xFFL) << 40) |
+                ((bytes[offset + 6] & 0xFFL) << 48) |
+                ((bytes[offset + 7] & 0xFFL) << 56);
+    }
+
+
+
+    public static int xxHashCode(@NonNull final byte[] bytes, int start, int length) {
+        final int PRIME1 = 0x9E3779B1;
+        final int PRIME2 = 0x85EBCA77;
+        final int PRIME3 = 0xC2B2AE3D;
+        final int PRIME4 = 0x27D4EB2F;
+        final int PRIME5 = 0x165667B1;
+
+        final int seed = 0; // You can make this a parameter if needed
+        final int end = start + length;
+        int h32;
+
+        if (length >= 16) {
+            final int limit = end - 16;
+            int v1 = seed + PRIME1 + PRIME2;
+            int v2 = seed + PRIME2;
+            int v3 = seed;
+            int v4 = seed - PRIME1;
+
+            do {
+                v1 = rotateLeft(v1 + getInt(bytes, start) * PRIME2, 13) * PRIME1;
+                start += 4;
+                v2 = rotateLeft(v2 + getInt(bytes, start) * PRIME2, 13) * PRIME1;
+                start += 4;
+                v3 = rotateLeft(v3 + getInt(bytes, start) * PRIME2, 13) * PRIME1;
+                start += 4;
+                v4 = rotateLeft(v4 + getInt(bytes, start) * PRIME2, 13) * PRIME1;
+                start += 4;
+            } while (start <= limit);
+
+            h32 = rotateLeft(v1, 1) + rotateLeft(v2, 7) +
+                    rotateLeft(v3, 12) + rotateLeft(v4, 18);
+        } else {
+            h32 = seed + PRIME5;
+        }
+
+        h32 += length;
+
+        while (start <= end - 4) {
+            h32 = rotateLeft(h32 + getInt(bytes, start) * PRIME3, 17) * PRIME4;
+            start += 4;
+        }
+
+        while (start < end) {
+            h32 = rotateLeft(h32 + (bytes[start] & 0xFF) * PRIME5, 11) * PRIME1;
+            start++;
+        }
+
+        h32 ^= h32 >>> 15;
+        h32 *= PRIME2;
+        h32 ^= h32 >>> 13;
+        h32 *= PRIME3;
+        h32 ^= h32 >>> 16;
+
+        return h32;
+    }
+
+    private static int rotateLeft(int value, int shift) {
+        return (value << shift) | (value >>> (32 - shift));
+    }
+
+    private static int getInt(byte[] bytes, int offset) {
+        return (bytes[offset] & 0xFF) |
+                ((bytes[offset + 1] & 0xFF) << 8) |
+                ((bytes[offset + 2] & 0xFF) << 16) |
+                ((bytes[offset + 3] & 0xFF) << 24);
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/Xxh3.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/Xxh3.java
new file mode 100644
index 00000000..286ecc83
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/Xxh3.java
@@ -0,0 +1,189 @@
+package com.hedera.pbj.integration.jmh.hashing;
+
+import edu.umd.cs.findbugs.annotations.NonNull;
+
+public final class Xxh3 {
+    public static int xxh3HashCode(@NonNull final byte[] bytes, int start, int length) {
+        if (length <= 16) {
+            return xxh3_len_0to16(bytes, start, length);
+        } else if (length <= 128) {
+            return xxh3_len_17to128(bytes, start, length);
+        } else if (length <= 240) {
+            return xxh3_len_129to240(bytes, start, length);
+        } else {
+            return xxh3_hashLong(bytes, start, length);
+        }
+    }
+
+    private static final long XXH_PRIME32_1 = 0x9E3779B1L;
+    private static final long XXH_PRIME32_2 = 0x85EBCA77L;
+    private static final long XXH_PRIME32_3 = 0xC2B2AE3DL;
+    private static final long XXH_PRIME64_1 = 0x9E3779B185EBCA87L;
+    private static final long XXH_PRIME64_2 = 0xC2B2AE3D27D4EB4FL;
+    private static final long XXH_PRIME64_3 = 0x165667B19E3779F9L;
+    private static final long XXH_PRIME64_4 = 0x85EBCA776C2B2AE1L;
+    private static final long XXH_PRIME64_5 = 0x27D4EB2F165667C5L;
+
+    private static final long XXH3_AVALANCHE_CONST = 0x165667919E3779F9L;
+    private static final long XXH3_MUL_CONST = 0x9FB21C651E98DF25L;
+
+    private static int xxh3_len_0to16(byte[] bytes, int start, int length) {
+        if (length >= 9) {
+            long inputLo = getLong(bytes, start);
+            long inputHi = getLong(bytes, start + length - 8);
+            long bitflip = (XXH_PRIME32_1 - 1) ^ (XXH_PRIME32_2 - 1);
+            long acc = length + Long.reverseBytes(inputLo) + inputHi + (inputLo ^ inputHi ^ bitflip) * XXH_PRIME64_1;
+            acc = xxh3_avalanche(acc);
+            return (int)(acc ^ (acc >>> 32));
+        } else if (length >= 4) {
+            long input1 = getInt(bytes, start) & 0xFFFFFFFFL;
+            long input2 = getInt(bytes, start + length - 4) & 0xFFFFFFFFL;
+            long bitflip = (XXH_PRIME32_1 - 1) ^ (XXH_PRIME32_2 - 1);
+            long keyed = input2 + (input1 << 32);
+            long acc = length + keyed + (keyed ^ bitflip) * XXH_PRIME64_1;
+            acc = xxh3_avalanche(acc);
+            return (int)(acc ^ (acc >>> 32));
+        } else if (length > 0) {
+            int c1 = bytes[start] & 0xFF;
+            int c2 = bytes[start + (length >> 1)] & 0xFF;
+            int c3 = bytes[start + length - 1] & 0xFF;
+            long combined = c1 + (c2 << 8) + (c3 << 16) + (length << 24);
+            long bitflip = (XXH_PRIME32_1 - 1) ^ (XXH_PRIME32_2 - 1);
+            long acc = combined ^ bitflip;
+            acc *= XXH_PRIME64_1;
+            acc = xxh3_avalanche(acc);
+            return (int)(acc ^ (acc >>> 32));
+        }
+        return 0x2D06800B; // XXH3 empty hash
+    }
+
+    private static int xxh3_len_17to128(byte[] bytes, int start, int length) {
+        long acc = length * XXH_PRIME64_1;
+
+        if (length >= 32) {
+            if (length >= 64) {
+                if (length >= 96) {
+                    acc += xxh3_mix16B(bytes, start + 48, XXH_PRIME32_1, XXH_PRIME32_2);
+                    acc += xxh3_mix16B(bytes, start + length - 64, 0, 0);
+                }
+                acc += xxh3_mix16B(bytes, start + 32, XXH_PRIME32_2, XXH_PRIME32_1);
+                acc += xxh3_mix16B(bytes, start + length - 48, 0, 0);
+            }
+            acc += xxh3_mix16B(bytes, start + 16, 0, 0);
+            acc += xxh3_mix16B(bytes, start + length - 32, XXH_PRIME32_1, XXH_PRIME32_2);
+        }
+
+        acc += xxh3_mix16B(bytes, start, XXH_PRIME32_1, XXH_PRIME32_2);
+        acc += xxh3_mix16B(bytes, start + length - 16, 0, 0);
+
+        acc = xxh3_avalanche(acc);
+        return (int)(acc ^ (acc >>> 32));
+    }
+
+    private static int xxh3_len_129to240(byte[] bytes, int start, int length) {
+        long acc = length * XXH_PRIME64_1;
+        int nbRounds = length / 32;
+
+        for (int i = 0; i < 4; i++) {
+            acc += xxh3_mix16B(bytes, start + 16 * i, XXH_PRIME32_1, XXH_PRIME32_2);
+        }
+        acc = xxh3_avalanche(acc);
+
+        for (int i = 4; i < nbRounds; i++) {
+            acc += xxh3_mix16B(bytes, start + 16 * i, XXH_PRIME32_2, XXH_PRIME32_1);
+        }
+
+        acc += xxh3_mix16B(bytes, start + length - 16, 0, 0);
+        acc = xxh3_avalanche(acc);
+        return (int)(acc ^ (acc >>> 32));
+    }
+
+    private static int xxh3_hashLong(byte[] bytes, int start, int length) {
+        long acc0 = XXH_PRIME32_3;
+        long acc1 = XXH_PRIME64_1;
+        long acc2 = XXH_PRIME64_2;
+        long acc3 = XXH_PRIME64_3;
+        long acc4 = XXH_PRIME64_4;
+        long acc5 = XXH_PRIME64_5;
+        long acc6 = XXH_PRIME32_2;
+        long acc7 = XXH_PRIME32_1;
+
+        int nbBlocks = (length - 1) / 64;
+
+        for (int n = 0; n < nbBlocks; n++) {
+            int dataPtr = start + n * 64;
+            acc0 = xxh3_accumulate_512(acc0, dataPtr, bytes, 0);
+            acc1 = xxh3_accumulate_512(acc1, dataPtr, bytes, 1);
+            acc2 = xxh3_accumulate_512(acc2, dataPtr, bytes, 2);
+            acc3 = xxh3_accumulate_512(acc3, dataPtr, bytes, 3);
+            acc4 = xxh3_accumulate_512(acc4, dataPtr, bytes, 4);
+            acc5 = xxh3_accumulate_512(acc5, dataPtr, bytes, 5);
+            acc6 = xxh3_accumulate_512(acc6, dataPtr, bytes, 6);
+            acc7 = xxh3_accumulate_512(acc7, dataPtr, bytes, 7);
+        }
+
+        long result = length * XXH_PRIME64_1;
+        result += xxh3_mergeAccs(acc0, acc1, acc2, acc3, acc4, acc5, acc6, acc7);
+
+        int lastBlockPtr = start + length - 64;
+        result += xxh3_mix16B(bytes, lastBlockPtr, 0, 0);
+        result += xxh3_mix16B(bytes, lastBlockPtr + 16, XXH_PRIME32_1, XXH_PRIME32_2);
+        result += xxh3_mix16B(bytes, lastBlockPtr + 32, XXH_PRIME32_2, XXH_PRIME32_1);
+        result += xxh3_mix16B(bytes, lastBlockPtr + 48, 0, 0);
+
+        result = xxh3_avalanche(result);
+        return (int)(result ^ (result >>> 32));
+    }
+
+    private static long xxh3_accumulate_512(long acc, int dataPtr, byte[] bytes, int lane) {
+        long data = getLong(bytes, dataPtr + lane * 8);
+        long key = XXH_PRIME32_1 + XXH_PRIME32_2 * lane;
+        return acc + data * key;
+    }
+
+    private static long xxh3_mix16B(byte[] bytes, int ptr, long seed1, long seed2) {
+        long input1 = getLong(bytes, ptr);
+        long input2 = getLong(bytes, ptr + 8);
+        return xxh3_mul128_fold64(input1 ^ (seed1 + XXH_PRIME32_1), input2 ^ (seed2 + XXH_PRIME32_2));
+    }
+
+    private static long xxh3_mul128_fold64(long lhs, long rhs) {
+        long hi = Math.multiplyHigh(lhs, rhs);
+        long lo = lhs * rhs;
+        return lo ^ hi;
+    }
+
+    private static long xxh3_avalanche(long h64) {
+        h64 ^= h64 >>> 37;
+        h64 *= XXH3_AVALANCHE_CONST;
+        h64 ^= h64 >>> 32;
+        return h64;
+    }
+
+    private static long xxh3_mergeAccs(long acc0, long acc1, long acc2, long acc3,
+            long acc4, long acc5, long acc6, long acc7) {
+        long result = (acc0 ^ acc1) + (acc2 ^ acc3) + (acc4 ^ acc5) + (acc6 ^ acc7);
+        result = (result >>> 47) ^ result;
+        result *= XXH3_MUL_CONST;
+        result ^= result >>> 32;
+        return result;
+    }
+
+    private static long getLong(byte[] bytes, int offset) {
+        return (bytes[offset] & 0xFFL) |
+                ((bytes[offset + 1] & 0xFFL) << 8) |
+                ((bytes[offset + 2] & 0xFFL) << 16) |
+                ((bytes[offset + 3] & 0xFFL) << 24) |
+                ((bytes[offset + 4] & 0xFFL) << 32) |
+                ((bytes[offset + 5] & 0xFFL) << 40) |
+                ((bytes[offset + 6] & 0xFFL) << 48) |
+                ((bytes[offset + 7] & 0xFFL) << 56);
+    }
+
+    private static int getInt(byte[] bytes, int offset) {
+        return (bytes[offset] & 0xFF) |
+                ((bytes[offset + 1] & 0xFF) << 8) |
+                ((bytes[offset + 2] & 0xFF) << 16) |
+                ((bytes[offset + 3] & 0xFF) << 24);
+    }
+}

From 4f9203e70ee5cc8cd0a15d993c1be74da2b22176 Mon Sep 17 00:00:00 2001
From: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
Date: Tue, 5 Aug 2025 13:18:07 -0700
Subject: [PATCH 09/17] Applied Spotless

Signed-off-by: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
---
 .../pbj/runtime/NonCryptographicHashing.java  |  1 +
 .../hedera/pbj/runtime/io/UnsafeUtils.java    |  5 +-
 .../pbj/runtime/io/buffer/BufferedData.java   |  2 +-
 .../jmh/NonCryptographicHashingBench.java     | 13 ++-
 .../pbj/integration/jmh/hashing/CityHash.java | 79 ++++++-------------
 .../integration/jmh/hashing/FasterLeemon.java | 45 +++++------
 .../integration/jmh/hashing/HashFunction.java |  1 +
 .../jmh/hashing/JavaStyleHashing.java         |  3 +-
 .../NonCryptographicHashQuality4ByteTest.java | 15 ++--
 .../NonCryptographicHashQualityTest.java      |  8 +-
 .../pbj/integration/jmh/hashing/XxHash.java   | 38 +++++----
 .../pbj/integration/jmh/hashing/Xxh3.java     | 41 +++++-----
 12 files changed, 118 insertions(+), 133 deletions(-)

diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
index 6d9022b4..946dd947 100644
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: Apache-2.0
 package com.hedera.pbj.runtime;
 
 import com.hedera.pbj.runtime.io.UnsafeUtils;
diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java
index 4268133e..decc12b0 100644
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java
@@ -165,8 +165,9 @@ public static long getLong(final byte[] arr, final int offset) {
      * @throws java.nio.BufferOverflowException If array length is less than offset + long bytes
      */
     public static long getLongNoChecks(final byte[] arr, final long offset) {
-        return NEED_CHANGE_BYTE_ORDER ? getLongNoChecksReverseOrder(arr, offset) :
-                getLongNoChecksNativeOrder(arr, offset);
+        return NEED_CHANGE_BYTE_ORDER
+                ? getLongNoChecksReverseOrder(arr, offset)
+                : getLongNoChecksNativeOrder(arr, offset);
     }
 
     /**
diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/BufferedData.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/BufferedData.java
index b152bbfd..f8cd2c9d 100644
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/BufferedData.java
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/buffer/BufferedData.java
@@ -237,7 +237,7 @@ public boolean equals(final Object o) {
      */
     @Override
     public int hashCode() {
-        return (int)NonCryptographicHashing.hash64(buffer);
+        return (int) NonCryptographicHashing.hash64(buffer);
     }
 
     // ================================================================================================================
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java
index 6645eb70..60cdcaea 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: Apache-2.0
 package com.hedera.pbj.integration.jmh;
 
 import com.hedera.pbj.integration.jmh.hashing.CityHash;
@@ -34,6 +35,7 @@
 @BenchmarkMode(Mode.AverageTime)
 public class NonCryptographicHashingBench {
     public static final int SAMPLES = 10_000;
+
     public enum HashAlgorithm {
         LEEMON(NonCryptographicHashing::hash64),
         FASTER_LEEMON(FasterLeemon::hash64),
@@ -53,8 +55,9 @@ public enum HashAlgorithm {
 
     @Param({"4", "8", "9", "12", "40", "60", "1000"})
     public int dataSize;
-    @Param({"LEEMON", "FASTER_LEEMON", "JAVA_31", "JAVA_255", "JAVA_256", "XXHASH_32",
-            "XXHASH_64", "XXH3", "CITY_HASH"})
+
+    @Param({"LEEMON", "FASTER_LEEMON", "JAVA_31", "JAVA_255", "JAVA_256", "XXHASH_32", "XXHASH_64", "XXH3", "CITY_HASH"
+    })
     public HashAlgorithm hashAlgorithm;
 
     private Random random;
@@ -62,13 +65,15 @@ public enum HashAlgorithm {
 
     @Setup(Level.Trial)
     public void setup() {
-        random =new Random(6351384163846453326L);
+        random = new Random(6351384163846453326L);
         sampleBytes = IntStream.range(0, SAMPLES)
                 .mapToObj(i -> {
                     final byte[] bytes = new byte[dataSize];
                     random.nextBytes(bytes);
                     return bytes;
-                }).distinct().toList();
+                })
+                .distinct()
+                .toList();
     }
 
     @Benchmark
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CityHash.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CityHash.java
index be86e690..2b06b6a9 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CityHash.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CityHash.java
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: Apache-2.0
 package com.hedera.pbj.integration.jmh.hashing;
 
 import com.hedera.pbj.runtime.io.UnsafeUtils;
@@ -13,24 +14,25 @@ public class CityHash {
     private static final long k1 = 0xb492b66fbe98f273L;
     private static final long k2 = 0x9ae16a3b2f90404fL;
     private static final long k3 = 0xc949d7c7509e6557L;
-//
-//    private static long toLongLE(byte[] b, int i) {
-//        return (((long) b[i + 7] << 56) +
-//                ((long) (b[i + 6] & 255) << 48) +
-//                ((long) (b[i + 5] & 255) << 40) +
-//                ((long) (b[i + 4] & 255) << 32) +
-//                ((long) (b[i + 3] & 255) << 24) +
-//                ((b[i + 2] & 255) << 16) +
-//                ((b[i + 1] & 255) << 8) +
-//                ((b[i + 0] & 255) << 0));
-//    }
+    //
+    //    private static long toLongLE(byte[] b, int i) {
+    //        return (((long) b[i + 7] << 56) +
+    //                ((long) (b[i + 6] & 255) << 48) +
+    //                ((long) (b[i + 5] & 255) << 40) +
+    //                ((long) (b[i + 4] & 255) << 32) +
+    //                ((long) (b[i + 3] & 255) << 24) +
+    //                ((b[i + 2] & 255) << 16) +
+    //                ((b[i + 1] & 255) << 8) +
+    //                ((b[i + 0] & 255) << 0));
+    //    }
     private static long toLongLE(byte[] b, int i) {
         return UnsafeUtils.getLongUnsafeNative(b, i);
     }
 
-//    private static int toIntLE(byte[] b, int i) {
-//        return (((b[i + 3] & 255) << 24) + ((b[i + 2] & 255) << 16) + ((b[i + 1] & 255) << 8) + ((b[i + 0] & 255) << 0));
-//    }
+    //    private static int toIntLE(byte[] b, int i) {
+    //        return (((b[i + 3] & 255) << 24) + ((b[i + 2] & 255) << 16) + ((b[i + 1] & 255) << 8) + ((b[i + 0] & 255)
+    // << 0));
+    //    }
     private static int toIntLE(byte[] b, int i) {
         return UnsafeUtils.getIntUnsafeNative(b, i);
     }
@@ -96,15 +98,10 @@ private static long hashLen17to32(byte[] s, int pos, int len) {
         long b = fetch64(s, pos + 8);
         long c = fetch64(s, pos + len - 8) * k2;
         long d = fetch64(s, pos + len - 16) * k0;
-        return hashLen16(
-                rotate(a - b, 43) + rotate(c, 30) + d,
-                a + rotate(b ^ k3, 20) - c + len
-        );
+        return hashLen16(rotate(a - b, 43) + rotate(c, 30) + d, a + rotate(b ^ k3, 20) - c + len);
     }
 
-    private static long[] weakHashLen32WithSeeds(
-            long w, long x, long y, long z,
-            long a, long b) {
+    private static long[] weakHashLen32WithSeeds(long w, long x, long y, long z, long a, long b) {
 
         a += w;
         b = rotate(b + a + z, 21);
@@ -112,18 +109,12 @@ private static long[] weakHashLen32WithSeeds(
         a += x;
         a += y;
         b += rotate(a, 44);
-        return new long[]{a + z, b + c};
+        return new long[] {a + z, b + c};
     }
 
     private static long[] weakHashLen32WithSeeds(byte[] s, int pos, long a, long b) {
         return weakHashLen32WithSeeds(
-                fetch64(s, pos + 0),
-                fetch64(s, pos + 8),
-                fetch64(s, pos + 16),
-                fetch64(s, pos + 24),
-                a,
-                b
-        );
+                fetch64(s, pos + 0), fetch64(s, pos + 8), fetch64(s, pos + 16), fetch64(s, pos + 24), a, b);
     }
 
     private static long hashLen33to64(byte[] s, int pos, int len) {
@@ -153,7 +144,6 @@ private static long hashLen33to64(byte[] s, int pos, int len) {
         long r = shiftMix((vf + ws) * k2 + (wf + vs) * k0);
 
         return shiftMix(r * k0 + vs) * k2;
-
     }
 
     public static String cityHash64Hex(byte[] s, int pos, int len) {
@@ -212,11 +202,7 @@ public static long cityHash64(byte[] s, int pos, int len) {
             len -= 64;
         } while (len != 0);
 
-        return hashLen16(
-                hashLen16(v[0], w[0]) + shiftMix(y) * k1 + z,
-                hashLen16(v[1], w[1]) + x
-        );
-
+        return hashLen16(hashLen16(v[0], w[0]) + shiftMix(y) * k1 + z, hashLen16(v[1], w[1]) + x);
     }
 
     public static long cityHash64WithSeed(byte[] s, int pos, int len, long seed) {
@@ -260,8 +246,7 @@ public static long[] cityMurmur(byte[] s, int pos, int len, long seed0, long see
         a = hashLen16(a, c);
         b = hashLen16(d, b);
 
-        return new long[]{a ^ b, hashLen16(b, a)};
-
+        return new long[] {a ^ b, hashLen16(b, a)};
     }
 
     public static long[] cityHash128WithSeed(byte[] s, int pos, int len, long seed0, long seed1) {
@@ -327,30 +312,18 @@ public static long[] cityHash128WithSeed(byte[] s, int pos, int len, long seed0,
         x = hashLen16(x, v[0]);
         y = hashLen16(y + z, w[0]);
 
-        return new long[]{
-                hashLen16(x + v[1], w[1]) + y,
-                hashLen16(x + w[1], y + v[1])
-        };
-
+        return new long[] {hashLen16(x + v[1], w[1]) + y, hashLen16(x + w[1], y + v[1])};
     }
 
     public static long[] cityHash128(byte[] s, int pos, int len) {
 
         if (len >= 16) {
-            return cityHash128WithSeed(
-                    s, pos + 16,
-                    len - 16,
-                    fetch64(s, pos + 0) ^ k3,
-                    fetch64(s, pos + 8)
-            );
+            return cityHash128WithSeed(s, pos + 16, len - 16, fetch64(s, pos + 0) ^ k3, fetch64(s, pos + 8));
         } else if (len >= 8) {
             return cityHash128WithSeed(
-                    new byte[0], 0, 0,
-                    fetch64(s, pos + 0) ^ (len * k0),
-                    fetch64(s, pos + len - 8) ^ k1
-            );
+                    new byte[0], 0, 0, fetch64(s, pos + 0) ^ (len * k0), fetch64(s, pos + len - 8) ^ k1);
         } else {
             return cityHash128WithSeed(s, pos, len, k0, k1);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/FasterLeemon.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/FasterLeemon.java
index a64c0f2c..586931fa 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/FasterLeemon.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/FasterLeemon.java
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: Apache-2.0
 package com.hedera.pbj.integration.jmh.hashing;
 
 import com.hedera.pbj.runtime.io.UnsafeUtils;
@@ -56,26 +57,26 @@ private static long perm64(long x) {
         return x;
     }
 
-// Sample vectorized version commented out for now, as it requires JDK 21+ and the vector API is still incubating.
-//    /**
-//     * Vectorized version for processing multiple long values in parallel.
-//     * This can be useful when hashing multiple values or for internal operations.
-//     */
-//    private static LongVector perm64Vector(LongVector v) {
-//        // Apply the XOR constant
-//        v = v.lanewise(VectorOperators.XOR, XOR_CONSTANT);
-//
-//        // Perform the permutation operations using vector operations
-//        v = v.add(v.lanewise(VectorOperators.LSHL, 30));
-//        v = v.lanewise(VectorOperators.XOR, v.lanewise(VectorOperators.LSHR, 27));
-//        v = v.add(v.lanewise(VectorOperators.LSHL, 16));
-//        v = v.lanewise(VectorOperators.XOR, v.lanewise(VectorOperators.LSHR, 20));
-//        v = v.add(v.lanewise(VectorOperators.LSHL, 5));
-//        v = v.lanewise(VectorOperators.XOR, v.lanewise(VectorOperators.LSHR, 18));
-//        v = v.add(v.lanewise(VectorOperators.LSHL, 10));
-//        v = v.lanewise(VectorOperators.XOR, v.lanewise(VectorOperators.LSHR, 24));
-//        v = v.add(v.lanewise(VectorOperators.LSHL, 30));
-//
-//        return v;
-//    }
+    // Sample vectorized version commented out for now, as it requires JDK 21+ and the vector API is still incubating.
+    //    /**
+    //     * Vectorized version for processing multiple long values in parallel.
+    //     * This can be useful when hashing multiple values or for internal operations.
+    //     */
+    //    private static LongVector perm64Vector(LongVector v) {
+    //        // Apply the XOR constant
+    //        v = v.lanewise(VectorOperators.XOR, XOR_CONSTANT);
+    //
+    //        // Perform the permutation operations using vector operations
+    //        v = v.add(v.lanewise(VectorOperators.LSHL, 30));
+    //        v = v.lanewise(VectorOperators.XOR, v.lanewise(VectorOperators.LSHR, 27));
+    //        v = v.add(v.lanewise(VectorOperators.LSHL, 16));
+    //        v = v.lanewise(VectorOperators.XOR, v.lanewise(VectorOperators.LSHR, 20));
+    //        v = v.add(v.lanewise(VectorOperators.LSHL, 5));
+    //        v = v.lanewise(VectorOperators.XOR, v.lanewise(VectorOperators.LSHR, 18));
+    //        v = v.add(v.lanewise(VectorOperators.LSHL, 10));
+    //        v = v.lanewise(VectorOperators.XOR, v.lanewise(VectorOperators.LSHR, 24));
+    //        v = v.add(v.lanewise(VectorOperators.LSHL, 30));
+    //
+    //        return v;
+    //    }
 }
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/HashFunction.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/HashFunction.java
index 5913fa3d..3d543582 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/HashFunction.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/HashFunction.java
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: Apache-2.0
 package com.hedera.pbj.integration.jmh.hashing;
 
 import edu.umd.cs.findbugs.annotations.NonNull;
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/JavaStyleHashing.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/JavaStyleHashing.java
index 758ebc62..1bff5a94 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/JavaStyleHashing.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/JavaStyleHashing.java
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: Apache-2.0
 package com.hedera.pbj.integration.jmh.hashing;
 
 import edu.umd.cs.findbugs.annotations.NonNull;
@@ -26,7 +27,7 @@ public static int hash255(@NonNull final byte[] bytes, int start, int length) {
     public static int hash256(@NonNull final byte[] bytes, int start, int length) {
         int h = 1;
         for (int i = length - 1; i >= start; i--) {
-            h =256 * h + bytes[i];
+            h = 256 * h + bytes[i];
         }
         return h;
     }
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTest.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTest.java
index 9e3d32de..989bedaa 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTest.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTest.java
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: Apache-2.0
 package com.hedera.pbj.integration.jmh.hashing;
 
 import com.hedera.pbj.integration.jmh.NonCryptographicHashingBench;
@@ -13,7 +14,7 @@ public final class NonCryptographicHashQuality4ByteTest {
     public static void main(String[] args) {
         System.out.println("Testing non-cryptographic hash quality - 4 bytes, 4 billion inputs");
         for (var hashAlgorithm : NonCryptographicHashingBench.HashAlgorithm.values()) {
-            System.out.println("Testing " + hashAlgorithm.name()+ " ====================================");
+            System.out.println("Testing " + hashAlgorithm.name() + " ====================================");
             testHashQuality4Bytes(hashAlgorithm);
         }
     }
@@ -24,8 +25,8 @@ private static void testHashQuality4Bytes(NonCryptographicHashingBench.HashAlgor
         final byte[] ba = new byte[6];
         for (int i = 0; i < 256; i++) {
             // print progress as percentage, overwriting the same line
-                System.out.printf("\r       Progress: %d%%", (i * 100) / 256);
-                System.out.flush();
+            System.out.printf("\r       Progress: %d%%", (i * 100) / 256);
+            System.out.flush();
             for (int j = 0; j < 256; j++) {
                 for (int k = 0; k < 256; k++) {
                     for (int l = 0; l < 256; l++) {
@@ -46,8 +47,9 @@ private static void testHashQuality4Bytes(NonCryptographicHashingBench.HashAlgor
         long expectedUniqueHashes = 256L * 256 * 256 * 256; // 4-byte combinations
         long hashCollisions = expectedUniqueHashes - numUniqueHashes;
         final long END_TIME = System.currentTimeMillis();
-        System.out.printf("       Number of unique hashes: %,d, hash collisions: %,d, time taken: %.3f seconds%n",
-                numUniqueHashes, hashCollisions,  (END_TIME - START_TIME) / 1000.0);
+        System.out.printf(
+                "       Number of unique hashes: %,d, hash collisions: %,d, time taken: %.3f seconds%n",
+                numUniqueHashes, hashCollisions, (END_TIME - START_TIME) / 1000.0);
     }
 
     /**
@@ -114,5 +116,4 @@ public long cardinality() {
             return count;
         }
     }
-
-}
\ No newline at end of file
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQualityTest.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQualityTest.java
index 2abf4a3c..a1d3ea0a 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQualityTest.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQualityTest.java
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: Apache-2.0
 package com.hedera.pbj.integration.jmh.hashing;
 
 import com.hedera.pbj.integration.jmh.NonCryptographicHashingBench;
@@ -13,7 +14,7 @@ public final class NonCryptographicHashQualityTest {
     public static void main(String[] args) {
         System.out.println("Testing non-cryptographic hash quality - 11 bytes, 500 million inputs");
         for (var hashAlgorithm : NonCryptographicHashingBench.HashAlgorithm.values()) {
-            System.out.println("Testing " + hashAlgorithm.name()+ " ====================================");
+            System.out.println("Testing " + hashAlgorithm.name() + " ====================================");
             testHashQuality11Bytes2Billion(hashAlgorithm);
         }
     }
@@ -43,7 +44,8 @@ private static void testHashQuality11Bytes2Billion(NonCryptographicHashingBench.
         long numUniqueHashes = hashes.size();
         long hashCollisions = NUM_INPUTS - numUniqueHashes;
         final long END_TIME = System.currentTimeMillis();
-        System.out.printf("       Number of unique hashes: %,d, hash collisions: %,d, time taken: %.3f seconds%n",
+        System.out.printf(
+                "       Number of unique hashes: %,d, hash collisions: %,d, time taken: %.3f seconds%n",
                 numUniqueHashes, hashCollisions, (END_TIME - START_TIME) / 1000.0);
     }
-}
\ No newline at end of file
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/XxHash.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/XxHash.java
index 5d38c82a..3412c1b3 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/XxHash.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/XxHash.java
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: Apache-2.0
 package com.hedera.pbj.integration.jmh.hashing;
 
 import edu.umd.cs.findbugs.annotations.NonNull;
@@ -33,8 +34,7 @@ public static int xxHashCodeFast(@NonNull final byte[] bytes, int start, int len
                 start += 8;
             } while (start <= limit);
 
-            h64 = Long.rotateLeft(v1, 1) + Long.rotateLeft(v2, 7) +
-                    Long.rotateLeft(v3, 12) + Long.rotateLeft(v4, 18);
+            h64 = Long.rotateLeft(v1, 1) + Long.rotateLeft(v2, 7) + Long.rotateLeft(v3, 12) + Long.rotateLeft(v4, 18);
 
             h64 = (h64 ^ Long.rotateLeft(v1 * PRIME2, 31) * PRIME1) * PRIME1 + PRIME4;
             h64 = (h64 ^ Long.rotateLeft(v2 * PRIME2, 31) * PRIME1) * PRIME1 + PRIME4;
@@ -47,7 +47,8 @@ public static int xxHashCodeFast(@NonNull final byte[] bytes, int start, int len
         h64 += length;
 
         while (start <= end - 8) {
-            h64 = Long.rotateLeft(h64 ^ Long.rotateLeft(getLong(bytes, start) * PRIME2, 31) * PRIME1, 27) * PRIME1 + PRIME4;
+            h64 = Long.rotateLeft(h64 ^ Long.rotateLeft(getLong(bytes, start) * PRIME2, 31) * PRIME1, 27) * PRIME1
+                    + PRIME4;
             start += 8;
         }
 
@@ -67,23 +68,21 @@ public static int xxHashCodeFast(@NonNull final byte[] bytes, int start, int len
         h64 *= PRIME3;
         h64 ^= h64 >>> 32;
 
-//        return (int)(h64 ^ (h64 >>> 32));
+        //        return (int)(h64 ^ (h64 >>> 32));
         return (int) h64;
     }
 
     private static long getLong(byte[] bytes, int offset) {
-        return (bytes[offset] & 0xFFL) |
-                ((bytes[offset + 1] & 0xFFL) << 8) |
-                ((bytes[offset + 2] & 0xFFL) << 16) |
-                ((bytes[offset + 3] & 0xFFL) << 24) |
-                ((bytes[offset + 4] & 0xFFL) << 32) |
-                ((bytes[offset + 5] & 0xFFL) << 40) |
-                ((bytes[offset + 6] & 0xFFL) << 48) |
-                ((bytes[offset + 7] & 0xFFL) << 56);
+        return (bytes[offset] & 0xFFL)
+                | ((bytes[offset + 1] & 0xFFL) << 8)
+                | ((bytes[offset + 2] & 0xFFL) << 16)
+                | ((bytes[offset + 3] & 0xFFL) << 24)
+                | ((bytes[offset + 4] & 0xFFL) << 32)
+                | ((bytes[offset + 5] & 0xFFL) << 40)
+                | ((bytes[offset + 6] & 0xFFL) << 48)
+                | ((bytes[offset + 7] & 0xFFL) << 56);
     }
 
-
-
     public static int xxHashCode(@NonNull final byte[] bytes, int start, int length) {
         final int PRIME1 = 0x9E3779B1;
         final int PRIME2 = 0x85EBCA77;
@@ -113,8 +112,7 @@ public static int xxHashCode(@NonNull final byte[] bytes, int start, int length)
                 start += 4;
             } while (start <= limit);
 
-            h32 = rotateLeft(v1, 1) + rotateLeft(v2, 7) +
-                    rotateLeft(v3, 12) + rotateLeft(v4, 18);
+            h32 = rotateLeft(v1, 1) + rotateLeft(v2, 7) + rotateLeft(v3, 12) + rotateLeft(v4, 18);
         } else {
             h32 = seed + PRIME5;
         }
@@ -145,9 +143,9 @@ private static int rotateLeft(int value, int shift) {
     }
 
     private static int getInt(byte[] bytes, int offset) {
-        return (bytes[offset] & 0xFF) |
-                ((bytes[offset + 1] & 0xFF) << 8) |
-                ((bytes[offset + 2] & 0xFF) << 16) |
-                ((bytes[offset + 3] & 0xFF) << 24);
+        return (bytes[offset] & 0xFF)
+                | ((bytes[offset + 1] & 0xFF) << 8)
+                | ((bytes[offset + 2] & 0xFF) << 16)
+                | ((bytes[offset + 3] & 0xFF) << 24);
     }
 }
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/Xxh3.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/Xxh3.java
index 286ecc83..87994684 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/Xxh3.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/Xxh3.java
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: Apache-2.0
 package com.hedera.pbj.integration.jmh.hashing;
 
 import edu.umd.cs.findbugs.annotations.NonNull;
@@ -34,7 +35,7 @@ private static int xxh3_len_0to16(byte[] bytes, int start, int length) {
             long bitflip = (XXH_PRIME32_1 - 1) ^ (XXH_PRIME32_2 - 1);
             long acc = length + Long.reverseBytes(inputLo) + inputHi + (inputLo ^ inputHi ^ bitflip) * XXH_PRIME64_1;
             acc = xxh3_avalanche(acc);
-            return (int)(acc ^ (acc >>> 32));
+            return (int) (acc ^ (acc >>> 32));
         } else if (length >= 4) {
             long input1 = getInt(bytes, start) & 0xFFFFFFFFL;
             long input2 = getInt(bytes, start + length - 4) & 0xFFFFFFFFL;
@@ -42,7 +43,7 @@ private static int xxh3_len_0to16(byte[] bytes, int start, int length) {
             long keyed = input2 + (input1 << 32);
             long acc = length + keyed + (keyed ^ bitflip) * XXH_PRIME64_1;
             acc = xxh3_avalanche(acc);
-            return (int)(acc ^ (acc >>> 32));
+            return (int) (acc ^ (acc >>> 32));
         } else if (length > 0) {
             int c1 = bytes[start] & 0xFF;
             int c2 = bytes[start + (length >> 1)] & 0xFF;
@@ -52,7 +53,7 @@ private static int xxh3_len_0to16(byte[] bytes, int start, int length) {
             long acc = combined ^ bitflip;
             acc *= XXH_PRIME64_1;
             acc = xxh3_avalanche(acc);
-            return (int)(acc ^ (acc >>> 32));
+            return (int) (acc ^ (acc >>> 32));
         }
         return 0x2D06800B; // XXH3 empty hash
     }
@@ -77,7 +78,7 @@ private static int xxh3_len_17to128(byte[] bytes, int start, int length) {
         acc += xxh3_mix16B(bytes, start + length - 16, 0, 0);
 
         acc = xxh3_avalanche(acc);
-        return (int)(acc ^ (acc >>> 32));
+        return (int) (acc ^ (acc >>> 32));
     }
 
     private static int xxh3_len_129to240(byte[] bytes, int start, int length) {
@@ -95,7 +96,7 @@ private static int xxh3_len_129to240(byte[] bytes, int start, int length) {
 
         acc += xxh3_mix16B(bytes, start + length - 16, 0, 0);
         acc = xxh3_avalanche(acc);
-        return (int)(acc ^ (acc >>> 32));
+        return (int) (acc ^ (acc >>> 32));
     }
 
     private static int xxh3_hashLong(byte[] bytes, int start, int length) {
@@ -132,7 +133,7 @@ private static int xxh3_hashLong(byte[] bytes, int start, int length) {
         result += xxh3_mix16B(bytes, lastBlockPtr + 48, 0, 0);
 
         result = xxh3_avalanche(result);
-        return (int)(result ^ (result >>> 32));
+        return (int) (result ^ (result >>> 32));
     }
 
     private static long xxh3_accumulate_512(long acc, int dataPtr, byte[] bytes, int lane) {
@@ -160,8 +161,8 @@ private static long xxh3_avalanche(long h64) {
         return h64;
     }
 
-    private static long xxh3_mergeAccs(long acc0, long acc1, long acc2, long acc3,
-            long acc4, long acc5, long acc6, long acc7) {
+    private static long xxh3_mergeAccs(
+            long acc0, long acc1, long acc2, long acc3, long acc4, long acc5, long acc6, long acc7) {
         long result = (acc0 ^ acc1) + (acc2 ^ acc3) + (acc4 ^ acc5) + (acc6 ^ acc7);
         result = (result >>> 47) ^ result;
         result *= XXH3_MUL_CONST;
@@ -170,20 +171,20 @@ private static long xxh3_mergeAccs(long acc0, long acc1, long acc2, long acc3,
     }
 
     private static long getLong(byte[] bytes, int offset) {
-        return (bytes[offset] & 0xFFL) |
-                ((bytes[offset + 1] & 0xFFL) << 8) |
-                ((bytes[offset + 2] & 0xFFL) << 16) |
-                ((bytes[offset + 3] & 0xFFL) << 24) |
-                ((bytes[offset + 4] & 0xFFL) << 32) |
-                ((bytes[offset + 5] & 0xFFL) << 40) |
-                ((bytes[offset + 6] & 0xFFL) << 48) |
-                ((bytes[offset + 7] & 0xFFL) << 56);
+        return (bytes[offset] & 0xFFL)
+                | ((bytes[offset + 1] & 0xFFL) << 8)
+                | ((bytes[offset + 2] & 0xFFL) << 16)
+                | ((bytes[offset + 3] & 0xFFL) << 24)
+                | ((bytes[offset + 4] & 0xFFL) << 32)
+                | ((bytes[offset + 5] & 0xFFL) << 40)
+                | ((bytes[offset + 6] & 0xFFL) << 48)
+                | ((bytes[offset + 7] & 0xFFL) << 56);
     }
 
     private static int getInt(byte[] bytes, int offset) {
-        return (bytes[offset] & 0xFF) |
-                ((bytes[offset + 1] & 0xFF) << 8) |
-                ((bytes[offset + 2] & 0xFF) << 16) |
-                ((bytes[offset + 3] & 0xFF) << 24);
+        return (bytes[offset] & 0xFF)
+                | ((bytes[offset + 1] & 0xFF) << 8)
+                | ((bytes[offset + 2] & 0xFF) << 16)
+                | ((bytes[offset + 3] & 0xFF) << 24);
     }
 }

From faf7079c24f4e85e99b9465544ec436950e8a45b Mon Sep 17 00:00:00 2001
From: Richard Bair <rbair23@users.noreply.github.com>
Date: Tue, 5 Aug 2025 13:42:38 -0700
Subject: [PATCH 10/17] One fix, default hash to 1 instead of 0 in hash64 for
 byte arrays.

Signed-off-by: Richard Bair <rbair23@users.noreply.github.com>
---
 .../pbj/runtime/NonCryptographicHashing.java  |   6 +-
 .../pbj/runtime/NonCryptographicHashTest.java | 331 ++++++++++++++++++
 2 files changed, 334 insertions(+), 3 deletions(-)
 create mode 100644 pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java

diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
index 946dd947..2037ee4e 100644
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
@@ -52,7 +52,7 @@ public static long hash64(@NonNull final byte[] bytes) {
     public static long hash64(@NonNull final byte[] bytes, final int position, final int length) {
         // Accumulate the hash in 64-bit chunks. If the length is not a multiple of 8, then read
         // as many complete 8 byte chunks as possible.
-        long hash = 0;
+        long hash = 1;
         int i = position;
         int end = position + length - 7;
         for (; i < end; i += 8) {
@@ -63,12 +63,12 @@ public static long hash64(@NonNull final byte[] bytes, final int position, final
         // Construct a trailing long. If the segment of the byte array we read was exactly a multiple of 8 bytes,
         // then we will append "0x00000000000000FF" to the end of the hash. If we had 1 byte remaining, then
         // we will append "0x000000000000FFXX" where XX is the value of the last byte, and so on.
-        long tail = 0x00000000000000FF;
+        long tail = 0xFF;
         int start = i;
         i = position + length - 1;
         for (; i >= start; i--) {
             tail <<= 8;
-            tail |= (bytes[i] & 0xFFL); // Mask to ensure we only get the last 8 bits.
+            tail ^= (bytes[i] & 0xFFL); // Mask to ensure we only get the last 8 bits.
         }
 
         // Combine the tail with the previous hash.
diff --git a/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java b/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
new file mode 100644
index 00000000..b69a12f2
--- /dev/null
+++ b/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
@@ -0,0 +1,331 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.runtime;
+
+import static com.hedera.pbj.runtime.NonCryptographicHashing.hash64;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import com.hedera.pbj.runtime.io.UnsafeUtils;
+import java.nio.ByteBuffer;
+import java.util.HashSet;
+import java.util.Random;
+import java.util.Set;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+@DisplayName("Non-Cryptographic Hash Test")
+class NonCryptographicHashTest {
+    /**
+     * Test the hash64(long) method with known values. The computation is very simple to do with any
+     * calculator,
+     */
+    @Test
+    @DisplayName("Test Hash64(long) Long with Known Values")
+    void testHash64Long() {
+        assertEquals(605873356528442819L, NonCryptographicHashing.hash64(0L));
+        assertEquals(4748194389872103055L, NonCryptographicHashing.hash64(1L));
+        assertEquals(5797980124308584942L, NonCryptographicHashing.hash64(-1L));
+        assertEquals(6218562537029544279L, NonCryptographicHashing.hash64(1234567890123456789L));
+    }
+
+    /**
+     * Test the hash64(byte[]) method with an empty byte array. This computation is also very simple
+     * to do with any calculator, and the result is known. We want to show that hashing an empty
+     * array is OK.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[]) Empty Array")
+    void testHash64ByteArrayEmpty() {
+        assertEquals(2903670678409729503L, NonCryptographicHashing.hash64(new byte[0]));
+    }
+
+    /**
+     * Test the hash64(byte[], int, int) method with an empty byte array, position 0, and length 0.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[], int, int) Empty Array with Valid Position and Length")
+    void testHash64ByteArrayEmptyWithPositionAndLength() {
+        assertEquals(2903670678409729503L, NonCryptographicHashing.hash64(new byte[0], 0, 0));
+    }
+
+    /**
+     * Test the hash64(byte[], int, int) method with position > length of the byte array.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[], int, int) Position Exceeds Array Length")
+    @Disabled("Disabled for now. I don't want to do the check and slow things down. Do we care about this?")
+    void testHash64ByteArrayPositionExceedsLength() {
+        byte[] arr = new byte[5];
+        // At the moment just returns the hash of 255.
+        assertThrows(IndexOutOfBoundsException.class, () -> NonCryptographicHashing.hash64(arr, 6, 0));
+    }
+
+    /**
+     * Test the hash64(byte[], int, int) method with position < 0.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[], int, int) Negative Position")
+    @Disabled("Disabled for now. I don't want to do the check and slow things down. Do we care about this?")
+    void testHash64ByteArrayNegativePosition() {
+        byte[] arr = new byte[5];
+        // At the moment just returns the hash of 255.
+        assertThrows(IndexOutOfBoundsException.class, () -> NonCryptographicHashing.hash64(arr, -1, 0));
+    }
+
+    /**
+     * Test the hash64(byte[], int, int) method with length < 0.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[], int, int) Negative Length")
+    @Disabled("Disabled for now. I don't want to do the check and slow things down. Do we care about this?")
+    void testHash64ByteArrayNegativeLength() {
+        byte[] arr = new byte[5];
+        // At the moment just returns the hash of 255.
+        assertThrows(IllegalArgumentException.class, () -> NonCryptographicHashing.hash64(arr, 0, -1));
+    }
+
+    /**
+     * Test the hash64(byte[], int, int) method with position + length > byte array length.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[], int, int) Position Plus Length Exceeds Array Length")
+    void testHash64ByteArrayPositionPlusLengthExceeds() {
+        byte[] arr = new byte[5];
+        assertThrows(IndexOutOfBoundsException.class, () -> NonCryptographicHashing.hash64(arr, 2, 4));
+    }
+
+    /**
+     * Test the hash64(byte[]) method with a one-byte array. This shows what happens if we have less than 8 bytes.
+     * The constant was found by calculating by hand the expected result.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[]) with array less than 8 bytes")
+    void testHash64ByteArrayLessThan8Bytes() {
+        byte[] arr = {(byte) 1};
+        assertEquals(3532887395273621549L, NonCryptographicHashing.hash64(arr));
+    }
+
+    /**
+     * Test the hash64(byte[]) method with an 8-byte array. This shows what happens if we test with exactly 8 bytes.
+     * The constant was found by calculating by hand the expected result.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[]) with 8 bytes")
+    void testHash64ByteArray8Bytes() {
+        byte[] arr = {(byte) 1, (byte) 2, (byte) 3, (byte) 4,
+                (byte) 5, (byte) 6, (byte) 7, (byte) 8};
+
+        assertEquals(8350451599110236880L, NonCryptographicHashing.hash64(arr));
+    }
+
+    /**
+     * Test the hash64(byte[]) method with a 12-byte array. This shows what happens if we test with more than
+     * 8 bytes, but not a multiple of 8. The constant was found by calculating by hand the expected result.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[]) with larger non-multiple of 8 bytes")
+    void testHash64ByteArrayMoreThan8ButNotMultipleOf8Bytes() {
+        byte[] arr = {(byte) 1, (byte) 2, (byte) 3, (byte) 4,
+                (byte) 5, (byte) 6, (byte) 7, (byte) 8,
+                (byte) 9, (byte) 10, (byte) 11, (byte) 12};
+
+        assertEquals(4316537784988356653L, NonCryptographicHashing.hash64(arr));
+    }
+
+    /**
+     * Test the hash64(byte[]) method with a 16-byte array. This shows what happens for arrays that are a multiple of 8.
+     * The constant was found by calculating by hand the expected result.
+     */
+    @Test
+    @DisplayName("Test Hash64(byte[]) with multiple of 8 bytes")
+    void testHash64ByteArrayMultipleOf8Bytes() {
+        byte[] arr = {(byte) 1, (byte) 2, (byte) 3, (byte) 4,
+                (byte) 5, (byte) 6, (byte) 7, (byte) 8,
+                (byte) 9, (byte) 10, (byte) 11, (byte) 12,
+                (byte) 13, (byte) 14, (byte) 15, (byte) 16};
+
+        assertEquals(4734248821214862750L, NonCryptographicHashing.hash64(arr));
+    }
+
+    /**
+     * While not comprehensive, this test provides a basic sanity check that if you are given two arrays of different
+     * lengths, but they both have the same high byte set and all other bytes are zero, then they generate different
+     * hashes.
+     */
+    @Test
+    @DisplayName("Test arrays of various lengths with high byte set and all else zero do not collide")
+    void testLeadingOneHasNoCollisions() {
+        Set<Long> hashes = new HashSet<>();
+        for (int len = 1; len <= 16; len++) {
+            byte[] leadingOne = new byte[len];
+            long h1 = NonCryptographicHashing.hash64(leadingOne);
+            assertTrue(hashes.add(h1)); // asserts each is unique
+        }
+    }
+
+    /**
+     * While not comprehensive, this test provides a basic sanity check that if you are given two arrays of different
+     * lengths, but they both have all bytes set to 1, then they generate different hashes.
+     */
+    @Test
+    void testAllOnesHasNoCollisions() {
+        Set<Long> hashes = new HashSet<>();
+        for (int len = 1; len <= 16; len++) {
+            byte[] allOnes = new byte[len];
+            for (int i = 0; i < len; i++) allOnes[i] = (byte) 0xFF;
+            long h1 = NonCryptographicHashing.hash64(allOnes);
+            assertTrue(hashes.add(h1)); // asserts each is unique
+        }
+    }
+
+    /**
+     * This test checks that the hash64 method does not produce collisions for small arrays.
+     * It verifies that all possible byte combinations for arrays of length 1 and 2 produce unique hashes.
+     */
+    @Test
+    @DisplayName("Test No Collisions for Small Arrays")
+    void testNoCollisionsSmallArrays() {
+        // Length 1: all 256
+        Set<Long> set1 = new HashSet<>();
+        for (int i = 0; i < 256; i++) {
+            byte[] ba = {(byte) i};
+            assertTrue(set1.add(NonCryptographicHashing.hash64(ba)));
+        }
+
+        // Length 2: all 65536
+        Set<Long> set2 = new HashSet<>();
+        for (int i = 0; i < 256; i++) {
+            for (int j = 0; j < 256; j++) {
+                byte[] ba = {(byte) i, (byte) j};
+                assertTrue(set2.add(NonCryptographicHashing.hash64(ba)));
+            }
+        }
+    }
+
+    /**
+     * This test checks that the hash64 method does not produce collisions for larger sets of data.
+     * It verifies that all possible byte combinations up to the number 100,000 produce unique hashes.
+     */
+    @Test
+    @DisplayName("Test No Collisions for Large Sets")
+    void testNoCollisionsLargeSet() {
+        final int num = 100_000;
+        Set<Long> set = new HashSet<>();
+        for (int i = 0; i < num; i++) {
+            byte[] ba = ByteBuffer.allocate(4).putInt(i).array();
+            assertTrue(set.add(NonCryptographicHashing.hash64(ba)));
+        }
+    }
+
+    @Test
+    @DisplayName("Test Collisions with non-random data")
+    void testLowCollisionsLargeSet() {
+        // Given an 8 byte array, try changing only the first 2 bytes, and see if we get collisions.
+        // A bad hash function would produce many collisions here. Then try again but changing out the middle
+        // 2 bytes. And do the same for the last 2 bytes.
+        final Set<Long> firstBytesSet = new HashSet<>();
+        final Set<Long> middleBytesSet = new HashSet<>();
+        final Set<Long> lastBytesSet = new HashSet<>();
+        final byte[] arr = { (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04,
+                             (byte) 0x05, (byte) 0x06, (byte) 0x07, (byte) 0x08 };
+        for (int i = 0; i < 256; i++) {
+            for (int j = 0; j < 256; j++) {
+                // Change the first two bytes
+                arr[6] = (byte) 0x07; // Reset last two bytes
+                arr[7] = (byte) 0x08; // Reset last two bytes
+                arr[0] = (byte) i;
+                arr[1] = (byte) j;
+                long hash1 = NonCryptographicHashing.hash64(arr);
+                assertTrue(firstBytesSet.add(hash1), "Collision found with first two bytes: iteration=" + i + ", long=" + Long.toHexString(UnsafeUtils.getLong(arr, 0)));
+
+                // Change the middle two bytes
+                arr[0] = (byte) 0x01; // Reset first two bytes
+                arr[1] = (byte) 0x02; // Reset first two bytes
+                arr[3] = (byte) i;
+                arr[4] = (byte) j;
+                long hash2 = NonCryptographicHashing.hash64(arr);
+                assertTrue(middleBytesSet.add(hash2), "Collision found with middle two bytes: iteration=" + i + ", long=" + Long.toHexString(UnsafeUtils.getLong(arr, 0)));
+
+                // Change the last two bytes
+                arr[3] = (byte) 0x03; // Reset middle two bytes
+                arr[4] = (byte) 0x04; // Reset middle two bytes
+                arr[6] = (byte) i;
+                arr[7] = (byte) j;
+                long hash3 = NonCryptographicHashing.hash64(arr);
+                assertTrue(lastBytesSet.add(hash3), "Collision found with last two bytes: iteration=" + i + ", long=" + Long.toHexString(UnsafeUtils.getLong(arr, 0)));
+            }
+        }
+    }
+
+    /**
+     * Checks that hashing a byte array with an offset produces the same result as hashing the same bytes directly.
+     */
+    @Test
+    @DisplayName("Test Hash with Offset")
+    void testHashWithOffset() {
+        byte[] large = new byte[255];
+        for (int i = 0; i < large.length; i++) {
+            large[i] = (byte) i;
+        }
+
+        // Try every subset where the start is changing but the length includes the last byte.
+        for (int i = 0; i < large.length; i++) {
+            int length = large.length - i;
+            byte[] subset = new byte[length];
+            System.arraycopy(large, i, subset, 0, length);
+            long expected = NonCryptographicHashing.hash64(subset);
+            long actual = NonCryptographicHashing.hash64(large, i, length);
+            assertEquals(expected, actual, "Hash with offset where start changes: " + i);
+        }
+
+        // Try every subset where the start is always 0 but the length is changing.
+        for (int i = 0; i < large.length; i++) {
+            int length = large.length - i;
+            byte[] subset = new byte[length];
+            System.arraycopy(large, 0, subset, 0, length);
+            long expected = NonCryptographicHashing.hash64(subset);
+            long actual = NonCryptographicHashing.hash64(large, 0, length);
+            assertEquals(expected, actual, "Hash with offset where length changes: " + i);
+        }
+    }
+
+    /**
+     * This test does not attempt to verify statistical properties of the hash functions.
+     * Its purpose is to ensure that none of the methods cause a crash.
+     */
+    @Test
+    @DisplayName("Test hash64")
+    void testHash64() {
+        final long seed = 842025;
+        final Random random = new Random(seed);
+
+        assertDoesNotThrow(() -> {
+            hash64(random.nextLong());
+
+            for (int i = 0; i < 100; i++) {
+                final byte[] bytes = new byte[i];
+                hash64(bytes);
+            }
+        });
+    }
+
+
+    @Test
+    @DisplayName("Hashes Are Not Degenerate 64")
+    void hashesAreNonDegenerate64() {
+        final long seed = 842025;
+        final Random random = new Random(seed);
+
+        assertNotEquals(0, hash64(0));
+        assertNotEquals(0, hash64(random.nextLong()));
+
+        for (int i = 0; i < 100; i++) {
+            final byte[] bytes = new byte[i];
+            assertNotEquals(0, hash64(bytes), "Hashes should be non-degenerate");
+        }
+    }
+}

From d50aa933087b441c0eed3376e698a4efcbdfb6cf Mon Sep 17 00:00:00 2001
From: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
Date: Tue, 5 Aug 2025 15:49:21 -0700
Subject: [PATCH 11/17] Applied Spotless

Signed-off-by: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
---
 .../pbj/runtime/NonCryptographicHashTest.java | 40 ++++++++++++-------
 1 file changed, 25 insertions(+), 15 deletions(-)

diff --git a/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java b/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
index b69a12f2..afc47c91 100644
--- a/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
+++ b/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
@@ -116,8 +116,7 @@ void testHash64ByteArrayLessThan8Bytes() {
     @Test
     @DisplayName("Test Hash64(byte[]) with 8 bytes")
     void testHash64ByteArray8Bytes() {
-        byte[] arr = {(byte) 1, (byte) 2, (byte) 3, (byte) 4,
-                (byte) 5, (byte) 6, (byte) 7, (byte) 8};
+        byte[] arr = {(byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 5, (byte) 6, (byte) 7, (byte) 8};
 
         assertEquals(8350451599110236880L, NonCryptographicHashing.hash64(arr));
     }
@@ -129,9 +128,10 @@ void testHash64ByteArray8Bytes() {
     @Test
     @DisplayName("Test Hash64(byte[]) with larger non-multiple of 8 bytes")
     void testHash64ByteArrayMoreThan8ButNotMultipleOf8Bytes() {
-        byte[] arr = {(byte) 1, (byte) 2, (byte) 3, (byte) 4,
-                (byte) 5, (byte) 6, (byte) 7, (byte) 8,
-                (byte) 9, (byte) 10, (byte) 11, (byte) 12};
+        byte[] arr = {
+            (byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 5, (byte) 6, (byte) 7, (byte) 8, (byte) 9, (byte) 10,
+            (byte) 11, (byte) 12
+        };
 
         assertEquals(4316537784988356653L, NonCryptographicHashing.hash64(arr));
     }
@@ -143,10 +143,10 @@ void testHash64ByteArrayMoreThan8ButNotMultipleOf8Bytes() {
     @Test
     @DisplayName("Test Hash64(byte[]) with multiple of 8 bytes")
     void testHash64ByteArrayMultipleOf8Bytes() {
-        byte[] arr = {(byte) 1, (byte) 2, (byte) 3, (byte) 4,
-                (byte) 5, (byte) 6, (byte) 7, (byte) 8,
-                (byte) 9, (byte) 10, (byte) 11, (byte) 12,
-                (byte) 13, (byte) 14, (byte) 15, (byte) 16};
+        byte[] arr = {
+            (byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 5, (byte) 6, (byte) 7, (byte) 8, (byte) 9, (byte) 10,
+            (byte) 11, (byte) 12, (byte) 13, (byte) 14, (byte) 15, (byte) 16
+        };
 
         assertEquals(4734248821214862750L, NonCryptographicHashing.hash64(arr));
     }
@@ -230,8 +230,10 @@ void testLowCollisionsLargeSet() {
         final Set<Long> firstBytesSet = new HashSet<>();
         final Set<Long> middleBytesSet = new HashSet<>();
         final Set<Long> lastBytesSet = new HashSet<>();
-        final byte[] arr = { (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04,
-                             (byte) 0x05, (byte) 0x06, (byte) 0x07, (byte) 0x08 };
+        final byte[] arr = {
+            (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04,
+            (byte) 0x05, (byte) 0x06, (byte) 0x07, (byte) 0x08
+        };
         for (int i = 0; i < 256; i++) {
             for (int j = 0; j < 256; j++) {
                 // Change the first two bytes
@@ -240,7 +242,10 @@ void testLowCollisionsLargeSet() {
                 arr[0] = (byte) i;
                 arr[1] = (byte) j;
                 long hash1 = NonCryptographicHashing.hash64(arr);
-                assertTrue(firstBytesSet.add(hash1), "Collision found with first two bytes: iteration=" + i + ", long=" + Long.toHexString(UnsafeUtils.getLong(arr, 0)));
+                assertTrue(
+                        firstBytesSet.add(hash1),
+                        "Collision found with first two bytes: iteration=" + i + ", long="
+                                + Long.toHexString(UnsafeUtils.getLong(arr, 0)));
 
                 // Change the middle two bytes
                 arr[0] = (byte) 0x01; // Reset first two bytes
@@ -248,7 +253,10 @@ void testLowCollisionsLargeSet() {
                 arr[3] = (byte) i;
                 arr[4] = (byte) j;
                 long hash2 = NonCryptographicHashing.hash64(arr);
-                assertTrue(middleBytesSet.add(hash2), "Collision found with middle two bytes: iteration=" + i + ", long=" + Long.toHexString(UnsafeUtils.getLong(arr, 0)));
+                assertTrue(
+                        middleBytesSet.add(hash2),
+                        "Collision found with middle two bytes: iteration=" + i + ", long="
+                                + Long.toHexString(UnsafeUtils.getLong(arr, 0)));
 
                 // Change the last two bytes
                 arr[3] = (byte) 0x03; // Reset middle two bytes
@@ -256,7 +264,10 @@ void testLowCollisionsLargeSet() {
                 arr[6] = (byte) i;
                 arr[7] = (byte) j;
                 long hash3 = NonCryptographicHashing.hash64(arr);
-                assertTrue(lastBytesSet.add(hash3), "Collision found with last two bytes: iteration=" + i + ", long=" + Long.toHexString(UnsafeUtils.getLong(arr, 0)));
+                assertTrue(
+                        lastBytesSet.add(hash3),
+                        "Collision found with last two bytes: iteration=" + i + ", long="
+                                + Long.toHexString(UnsafeUtils.getLong(arr, 0)));
             }
         }
     }
@@ -313,7 +324,6 @@ void testHash64() {
         });
     }
 
-
     @Test
     @DisplayName("Hashes Are Not Degenerate 64")
     void hashesAreNonDegenerate64() {

From d53c660938fa558e4fa8f588eb438a2fbdc46bd9 Mon Sep 17 00:00:00 2001
From: Richard Bair <rbair23@users.noreply.github.com>
Date: Tue, 5 Aug 2025 16:38:20 -0700
Subject: [PATCH 12/17] Add a possible hash32 variant of the algorithm

Signed-off-by: Richard Bair <rbair23@users.noreply.github.com>
---
 .../pbj/runtime/NonCryptographicHashing.java  | 60 +++++++++++++++++--
 .../hedera/pbj/runtime/io/UnsafeUtils.java    |  2 +-
 .../pbj/runtime/NonCryptographicHashTest.java | 19 +++---
 3 files changed, 69 insertions(+), 12 deletions(-)

diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
index 2037ee4e..674d3b8c 100644
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
@@ -14,6 +14,58 @@ public final class NonCryptographicHashing {
     // This class is not meant to be instantiated.
     private NonCryptographicHashing() {}
 
+    public static int hash32(@NonNull final byte[] bytes) {
+        return hash32(bytes, 0, bytes.length);
+    }
+
+    public static int hash32(@NonNull final byte[] bytes, final int position, final int length) {
+        // Accumulate the hash in 32-bit chunks. If the length is not a multiple of 4, then read
+        // as many complete 4 byte chunks as possible.
+        int hash = 1;
+        int i = position;
+        int end = position + length - 3;
+        for (; i < end; i += 4) {
+            // TODO Jasper change this to use a VarHandle so we get native or reverse order as needed
+            hash = perm32(hash ^ UnsafeUtils.getIntUnsafeNative(bytes, i));
+        }
+
+        // Construct a trailing int. If the segment of the byte array we read was exactly a multiple of 4 bytes,
+        // then we will append "0x0000007F" to the end of the hash. If we had 1 byte remaining, then
+        // we will append "0x00007FXX" where XX is the value of the last byte, and so on.
+        int tail = 0x7F;
+        int start = i;
+        i = position + length - 1;
+        for (; i >= start; i--) {
+            tail <<= 8;
+            tail ^= bytes[i];
+        }
+
+        // Combine the tail with the previous hash.
+        hash = perm32(hash ^ tail);
+
+        return hash;
+    }
+
+    private static int perm32(int x) {
+        // This is necessary so that 0 does not hash to 0. As a side effect, this constant will hash to 0.
+        // It was randomly generated (not using Java), so that it will occur in practice less often than more
+        // common numbers like 0 or -1 or Integer.MAX_VALUE.
+        x ^= 0x5e8a016a;
+
+        // Shifts: {30, 27, 16, 20, 5, 18, 10, 24, 30}
+        x += x << 30;
+        x ^= x >>> 27;
+        x += x << 16;
+        x ^= x >>> 20;
+        x += x << 5;
+        x ^= x >>> 18;
+        x += x << 10;
+        x ^= x >>> 24;
+        x += x << 30;
+        return x;
+    }
+
+
     /**
      * Generates a non-cryptographic 64-bit hash for 1 long.
      *
@@ -61,14 +113,14 @@ public static long hash64(@NonNull final byte[] bytes, final int position, final
         }
 
         // Construct a trailing long. If the segment of the byte array we read was exactly a multiple of 8 bytes,
-        // then we will append "0x00000000000000FF" to the end of the hash. If we had 1 byte remaining, then
-        // we will append "0x000000000000FFXX" where XX is the value of the last byte, and so on.
-        long tail = 0xFF;
+        // then we will append "0x000000000000007F" to the end of the hash. If we had 1 byte remaining, then
+        // we will append "0x0000000000007FXX" where XX is the value of the last byte, and so on.
+        long tail = 0x7F;
         int start = i;
         i = position + length - 1;
         for (; i >= start; i--) {
             tail <<= 8;
-            tail ^= (bytes[i] & 0xFFL); // Mask to ensure we only get the last 8 bits.
+            tail ^= bytes[i];
         }
 
         // Combine the tail with the previous hash.
diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java
index decc12b0..abab54bd 100644
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java
@@ -135,7 +135,7 @@ public static int getInt(final byte[] arr, final int offset) {
      * @param offset The offset to read an integer at
      * @return The integer number
      */
-    public static int getIntUnsafeNative(final byte[] arr, final int offset) {
+    public static int getIntUnsafeNative(final byte[] arr, final long offset) {
         return UNSAFE.getInt(arr, BYTE_ARRAY_BASE_OFFSET + offset);
     }
 
diff --git a/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java b/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
index afc47c91..17035270 100644
--- a/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
+++ b/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
@@ -10,7 +10,9 @@
 
 import com.hedera.pbj.runtime.io.UnsafeUtils;
 import java.nio.ByteBuffer;
+import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Map;
 import java.util.Random;
 import java.util.Set;
 import org.junit.jupiter.api.Disabled;
@@ -40,7 +42,7 @@ void testHash64Long() {
     @Test
     @DisplayName("Test Hash64(byte[]) Empty Array")
     void testHash64ByteArrayEmpty() {
-        assertEquals(2903670678409729503L, NonCryptographicHashing.hash64(new byte[0]));
+        assertEquals(-6996494465910161660L, NonCryptographicHashing.hash64(new byte[0]));
     }
 
     /**
@@ -49,7 +51,7 @@ void testHash64ByteArrayEmpty() {
     @Test
     @DisplayName("Test Hash64(byte[], int, int) Empty Array with Valid Position and Length")
     void testHash64ByteArrayEmptyWithPositionAndLength() {
-        assertEquals(2903670678409729503L, NonCryptographicHashing.hash64(new byte[0], 0, 0));
+        assertEquals(-6996494465910161660L, NonCryptographicHashing.hash64(new byte[0], 0, 0));
     }
 
     /**
@@ -106,7 +108,7 @@ void testHash64ByteArrayPositionPlusLengthExceeds() {
     @DisplayName("Test Hash64(byte[]) with array less than 8 bytes")
     void testHash64ByteArrayLessThan8Bytes() {
         byte[] arr = {(byte) 1};
-        assertEquals(3532887395273621549L, NonCryptographicHashing.hash64(arr));
+        assertEquals(1343923460066354394L, NonCryptographicHashing.hash64(arr));
     }
 
     /**
@@ -118,7 +120,7 @@ void testHash64ByteArrayLessThan8Bytes() {
     void testHash64ByteArray8Bytes() {
         byte[] arr = {(byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 5, (byte) 6, (byte) 7, (byte) 8};
 
-        assertEquals(8350451599110236880L, NonCryptographicHashing.hash64(arr));
+        assertEquals(-3104306485754735749L, NonCryptographicHashing.hash64(arr));
     }
 
     /**
@@ -133,7 +135,7 @@ void testHash64ByteArrayMoreThan8ButNotMultipleOf8Bytes() {
             (byte) 11, (byte) 12
         };
 
-        assertEquals(4316537784988356653L, NonCryptographicHashing.hash64(arr));
+        assertEquals(3639540625541984507L, NonCryptographicHashing.hash64(arr));
     }
 
     /**
@@ -148,7 +150,7 @@ void testHash64ByteArrayMultipleOf8Bytes() {
             (byte) 11, (byte) 12, (byte) 13, (byte) 14, (byte) 15, (byte) 16
         };
 
-        assertEquals(4734248821214862750L, NonCryptographicHashing.hash64(arr));
+        assertEquals(7790396302089317864L, NonCryptographicHashing.hash64(arr));
     }
 
     /**
@@ -173,12 +175,15 @@ void testLeadingOneHasNoCollisions() {
      */
     @Test
     void testAllOnesHasNoCollisions() {
+        Map<Long, Integer> collisions = new HashMap<>();
         Set<Long> hashes = new HashSet<>();
         for (int len = 1; len <= 16; len++) {
             byte[] allOnes = new byte[len];
             for (int i = 0; i < len; i++) allOnes[i] = (byte) 0xFF;
             long h1 = NonCryptographicHashing.hash64(allOnes);
-            assertTrue(hashes.add(h1)); // asserts each is unique
+            if (!collisions.containsKey(h1)) collisions.put(h1, len);
+            assertTrue(hashes.add(h1), "Found duplicate hash on iteration " + len
+                    + " collided with " + collisions.get(h1)); // asserts each is unique
         }
     }
 

From 6bf145cbf5a2072f681de7030d5b0e1602a95785 Mon Sep 17 00:00:00 2001
From: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
Date: Tue, 5 Aug 2025 17:33:45 -0700
Subject: [PATCH 13/17] Fixed unsafe, added bucket distribution test, added
 leemon hash32 to other tests

Signed-off-by: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
---
 .../pbj/runtime/NonCryptographicHashing.java  |  7 +-
 .../hedera/pbj/runtime/io/UnsafeUtils.java    | 47 +++---------
 .../pbj/runtime/NonCryptographicHashTest.java |  6 +-
 .../jmh/NonCryptographicHashingBench.java     |  1 +
 .../pbj/integration/jmh/hashing/CityHash.java |  4 +-
 .../integration/jmh/hashing/FasterLeemon.java |  2 +-
 ...ashQuality4ByteTestBucketDistribution.java | 74 +++++++++++++++++++
 7 files changed, 95 insertions(+), 46 deletions(-)
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTestBucketDistribution.java

diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
index 674d3b8c..504d08ba 100644
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
@@ -25,8 +25,7 @@ public static int hash32(@NonNull final byte[] bytes, final int position, final
         int i = position;
         int end = position + length - 3;
         for (; i < end; i += 4) {
-            // TODO Jasper change this to use a VarHandle so we get native or reverse order as needed
-            hash = perm32(hash ^ UnsafeUtils.getIntUnsafeNative(bytes, i));
+            hash = perm32(hash ^ UnsafeUtils.getIntUnsafeLittleEndian(bytes, i));
         }
 
         // Construct a trailing int. If the segment of the byte array we read was exactly a multiple of 4 bytes,
@@ -65,7 +64,6 @@ private static int perm32(int x) {
         return x;
     }
 
-
     /**
      * Generates a non-cryptographic 64-bit hash for 1 long.
      *
@@ -108,8 +106,7 @@ public static long hash64(@NonNull final byte[] bytes, final int position, final
         int i = position;
         int end = position + length - 7;
         for (; i < end; i += 8) {
-            // TODO Jasper change this to use a VarHandle so we get native or reverse order as needed
-            hash = perm64(hash ^ UnsafeUtils.getLongNoChecksNativeOrder(bytes, i));
+            hash = perm64(hash ^ UnsafeUtils.getLongNoChecksLittleEndian(bytes, i));
         }
 
         // Construct a trailing long. If the segment of the byte array we read was exactly a multiple of 8 bytes,
diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java
index abab54bd..0a830fa4 100644
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/io/UnsafeUtils.java
@@ -20,7 +20,7 @@ public final class UnsafeUtils {
      * Java and PBJ use BIG_ENDIAN, while native byte order used by Unsafe may or may not
      * be BIG_ENDIAN. This flag indicates that if they don't match
      */
-    private static final boolean NEED_CHANGE_BYTE_ORDER;
+    private static final boolean MACHINE_IS_LITTLE_ENDIAN;
 
     /**
      * Field offset of the byte[] class
@@ -38,7 +38,7 @@ public final class UnsafeUtils {
             final Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe");
             theUnsafeField.setAccessible(true);
             UNSAFE = (Unsafe) theUnsafeField.get(null);
-            NEED_CHANGE_BYTE_ORDER = ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN;
+            MACHINE_IS_LITTLE_ENDIAN = ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN;
             BYTE_ARRAY_BASE_OFFSET = UNSAFE.arrayBaseOffset(byte[].class);
             final Field addressField = Buffer.class.getDeclaredField("address");
             DIRECT_BYTEBUFFER_ADDRESS_OFFSET = UNSAFE.objectFieldOffset(addressField);
@@ -124,7 +124,7 @@ public static int getInt(final byte[] arr, final int offset) {
             throw new BufferUnderflowException();
         }
         final int value = UNSAFE.getInt(arr, BYTE_ARRAY_BASE_OFFSET + offset);
-        return NEED_CHANGE_BYTE_ORDER ? Integer.reverseBytes(value) : value;
+        return MACHINE_IS_LITTLE_ENDIAN ? Integer.reverseBytes(value) : value;
     }
 
     /**
@@ -135,8 +135,9 @@ public static int getInt(final byte[] arr, final int offset) {
      * @param offset The offset to read an integer at
      * @return The integer number
      */
-    public static int getIntUnsafeNative(final byte[] arr, final long offset) {
-        return UNSAFE.getInt(arr, BYTE_ARRAY_BASE_OFFSET + offset);
+    public static int getIntUnsafeLittleEndian(final byte[] arr, final long offset) {
+        final int value = UNSAFE.getInt(arr, BYTE_ARRAY_BASE_OFFSET + offset);
+        return MACHINE_IS_LITTLE_ENDIAN ? value : Integer.reverseBytes(value);
     }
 
     /**
@@ -165,48 +166,22 @@ public static long getLong(final byte[] arr, final int offset) {
      * @throws java.nio.BufferOverflowException If array length is less than offset + long bytes
      */
     public static long getLongNoChecks(final byte[] arr, final long offset) {
-        return NEED_CHANGE_BYTE_ORDER
-                ? getLongNoChecksReverseOrder(arr, offset)
-                : getLongNoChecksNativeOrder(arr, offset);
-    }
-
-    /**
-     * Reads a long from the given array starting at the given offset. Array bytes are
-     * interpreted in BIG_ENDIAN order.
-     *
-     * @param arr The byte array
-     * @param offset The offset to read a long at
-     * @return The long number
-     * @throws java.nio.BufferOverflowException If array length is less than offset + long bytes
-     */
-    public static long getLongNoChecksNativeOrder(final byte[] arr, final long offset) {
-        return UNSAFE.getLong(arr, BYTE_ARRAY_BASE_OFFSET + offset);
+        final long value = UNSAFE.getLong(arr, BYTE_ARRAY_BASE_OFFSET + offset);
+        return MACHINE_IS_LITTLE_ENDIAN ? Long.reverseBytes(value) : value;
     }
 
     /**
      * Reads a long from the given array starting at the given offset. Array bytes are
-     * interpreted in BIG_ENDIAN order.
+     * interpreted in LITTLE_ENDIAN order.
      *
      * @param arr The byte array
      * @param offset The offset to read a long at
      * @return The long number
      * @throws java.nio.BufferOverflowException If array length is less than offset + long bytes
      */
-    public static long getLongNoChecksReverseOrder(final byte[] arr, final long offset) {
+    public static long getLongNoChecksLittleEndian(final byte[] arr, final long offset) {
         final long value = UNSAFE.getLong(arr, BYTE_ARRAY_BASE_OFFSET + offset);
-        return Long.reverseBytes(value);
-    }
-
-    /**
-     * Reads a long from the given array starting at the given offset. Array bytes are
-     * interpreted in NATIVE order.
-     *
-     * @param arr The byte array
-     * @param offset The offset to read a long at
-     * @return The long number
-     */
-    public static long getLongUnsafeNative(final byte[] arr, final int offset) {
-        return UNSAFE.getLong(arr, BYTE_ARRAY_BASE_OFFSET + offset);
+        return MACHINE_IS_LITTLE_ENDIAN ? value : Long.reverseBytes(value);
     }
 
     /**
diff --git a/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java b/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
index 17035270..3c5d2dcc 100644
--- a/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
+++ b/pbj-core/pbj-runtime/src/test/java/com/hedera/pbj/runtime/NonCryptographicHashTest.java
@@ -182,8 +182,10 @@ void testAllOnesHasNoCollisions() {
             for (int i = 0; i < len; i++) allOnes[i] = (byte) 0xFF;
             long h1 = NonCryptographicHashing.hash64(allOnes);
             if (!collisions.containsKey(h1)) collisions.put(h1, len);
-            assertTrue(hashes.add(h1), "Found duplicate hash on iteration " + len
-                    + " collided with " + collisions.get(h1)); // asserts each is unique
+            assertTrue(
+                    hashes.add(h1),
+                    "Found duplicate hash on iteration " + len + " collided with "
+                            + collisions.get(h1)); // asserts each is unique
         }
     }
 
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java
index 60cdcaea..8c3ca916 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java
@@ -38,6 +38,7 @@ public class NonCryptographicHashingBench {
 
     public enum HashAlgorithm {
         LEEMON(NonCryptographicHashing::hash64),
+        LEEMON_32(NonCryptographicHashing::hash32),
         FASTER_LEEMON(FasterLeemon::hash64),
         JAVA_31(JavaStyleHashing::hash31),
         JAVA_255(JavaStyleHashing::hash255),
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CityHash.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CityHash.java
index 2b06b6a9..53ade2a8 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CityHash.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CityHash.java
@@ -26,7 +26,7 @@ public class CityHash {
     //                ((b[i + 0] & 255) << 0));
     //    }
     private static long toLongLE(byte[] b, int i) {
-        return UnsafeUtils.getLongUnsafeNative(b, i);
+        return UnsafeUtils.getLongNoChecksLittleEndian(b, i);
     }
 
     //    private static int toIntLE(byte[] b, int i) {
@@ -34,7 +34,7 @@ private static long toLongLE(byte[] b, int i) {
     // << 0));
     //    }
     private static int toIntLE(byte[] b, int i) {
-        return UnsafeUtils.getIntUnsafeNative(b, i);
+        return UnsafeUtils.getIntUnsafeLittleEndian(b, i);
     }
 
     private static long fetch64(byte[] s, int pos) {
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/FasterLeemon.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/FasterLeemon.java
index 586931fa..49e0cf08 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/FasterLeemon.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/FasterLeemon.java
@@ -23,7 +23,7 @@ public static long hash64(@NonNull final byte[] bytes, final int start, final in
         long hash = 0;
         int i = start;
         for (; i < start + length - 7; i += 8) {
-            hash = perm64(hash ^ UnsafeUtils.getLongUnsafeNative(bytes, i));
+            hash = perm64(hash ^ UnsafeUtils.getLongNoChecksLittleEndian(bytes, i));
         }
 
         long tail = 0xFF;
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTestBucketDistribution.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTestBucketDistribution.java
new file mode 100644
index 00000000..5e71beda
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTestBucketDistribution.java
@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing;
+
+import com.hedera.pbj.integration.jmh.NonCryptographicHashingBench;
+import java.util.Arrays;
+import java.util.Map;
+
+/**
+ * A test to evaluate the quality of non-cryptographic hash functions
+ * by checking how many unique hashes can be generated from 4-byte inputs.
+ * It runs through all combinations of 4 bytes (256^4 = 4,294,967,296 combinations).
+ */
+public final class NonCryptographicHashQuality4ByteTestBucketDistribution {
+    public static void main(String[] args) {
+        System.out.println("Testing non-cryptographic hash quality - 4 bytes, 4 billion inputs");
+        for (var hashAlgorithm : NonCryptographicHashingBench.HashAlgorithm.values()) {
+            System.out.println("Testing " + hashAlgorithm.name() + " ====================================");
+            testHashQuality4Bytes(hashAlgorithm);
+        }
+    }
+
+    private static void testHashQuality4Bytes(NonCryptographicHashingBench.HashAlgorithm hashAlgorithm) {
+        final long START_TIME = System.currentTimeMillis();
+        final int[] bucketCounts = new int[33_554_432]; // 2^25 33 million buckets
+        final byte[] ba = new byte[4];
+        for (int i = 0; i < 256; i++) {
+            // print progress as percentage, overwriting the same line
+            System.out.printf("\r       Progress: %d%%", (i * 100) / 256);
+            System.out.flush();
+            for (int j = 0; j < 256; j++) {
+                for (int k = 0; k < 256; k++) {
+                    for (int l = 0; l < 256; l++) {
+                        ba[0] = (byte) i;
+                        ba[1] = (byte) j;
+                        ba[2] = (byte) k;
+                        ba[3] = (byte) l;
+                        long hash64 = hashAlgorithm.function.applyAsLong(ba, 0, 4);
+                        int hash32 = (int) hash64;
+                        long bucket = computeBucketIndex(hash32) ;
+                        bucketCounts[(int)bucket]++;
+                    }
+                }
+            }
+        }
+        // print the distribution of hash buckets sorted by bucket index
+        // convert the bucketCounts into the number of buckets with each count
+        Map<Integer,Integer> bucketDistribution = Arrays.stream(bucketCounts)
+                .boxed()
+                .collect(java.util.stream.Collectors.toMap(
+//                        count -> count/1000, // Group counts by 1000 for better readability
+                        count -> count,
+                        count -> 1,
+                        Integer::sum
+                ));
+        System.out.println("\n       Bucket distribution:");
+        bucketDistribution.entrySet().stream()
+                .sorted(Map.Entry.comparingByKey())
+                .forEach(entry -> System.out.printf("       Count %d: %d buckets%n", entry.getKey(), entry.getValue()));
+
+    }
+
+
+    /**
+     * Computes which bucket a key with the given hash falls. Depends on the fact the numOfBuckets
+     * is a power of two. Based on same calculation that is used in java HashMap.
+     *
+     * @param keyHash the int hash for key
+     * @return the index of the bucket that key falls in
+     */
+    private static int computeBucketIndex(final int keyHash) {
+        return (33_554_432 - 1) & keyHash;
+    }
+
+}

From 7122a6be7fbec1ba1008b360d8cdcc364881d2fa Mon Sep 17 00:00:00 2001
From: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
Date: Tue, 5 Aug 2025 17:43:12 -0700
Subject: [PATCH 14/17] Test app cleanup

Signed-off-by: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
---
 ...ashQuality4ByteTestBucketDistribution.java | 26 ++++++++-----------
 1 file changed, 11 insertions(+), 15 deletions(-)

diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTestBucketDistribution.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTestBucketDistribution.java
index 5e71beda..ce129027 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTestBucketDistribution.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTestBucketDistribution.java
@@ -11,6 +11,9 @@
  * It runs through all combinations of 4 bytes (256^4 = 4,294,967,296 combinations).
  */
 public final class NonCryptographicHashQuality4ByteTestBucketDistribution {
+    private static final int NUM_BUCKETS = 33_554_432; // 2^25 33 million buckets
+
+
     public static void main(String[] args) {
         System.out.println("Testing non-cryptographic hash quality - 4 bytes, 4 billion inputs");
         for (var hashAlgorithm : NonCryptographicHashingBench.HashAlgorithm.values()) {
@@ -20,8 +23,7 @@ public static void main(String[] args) {
     }
 
     private static void testHashQuality4Bytes(NonCryptographicHashingBench.HashAlgorithm hashAlgorithm) {
-        final long START_TIME = System.currentTimeMillis();
-        final int[] bucketCounts = new int[33_554_432]; // 2^25 33 million buckets
+        final int[] bucketCounts = new int[NUM_BUCKETS]; // 2^25 33 million buckets
         final byte[] ba = new byte[4];
         for (int i = 0; i < 256; i++) {
             // print progress as percentage, overwriting the same line
@@ -36,31 +38,26 @@ private static void testHashQuality4Bytes(NonCryptographicHashingBench.HashAlgor
                         ba[3] = (byte) l;
                         long hash64 = hashAlgorithm.function.applyAsLong(ba, 0, 4);
                         int hash32 = (int) hash64;
-                        long bucket = computeBucketIndex(hash32) ;
-                        bucketCounts[(int)bucket]++;
+                        long bucket = computeBucketIndex(hash32);
+                        bucketCounts[(int) bucket]++;
                     }
                 }
             }
         }
         // print the distribution of hash buckets sorted by bucket index
         // convert the bucketCounts into the number of buckets with each count
-        Map<Integer,Integer> bucketDistribution = Arrays.stream(bucketCounts)
+        Map<Integer, Integer> bucketDistribution = Arrays.stream(bucketCounts)
                 .boxed()
-                .collect(java.util.stream.Collectors.toMap(
-//                        count -> count/1000, // Group counts by 1000 for better readability
-                        count -> count,
-                        count -> 1,
-                        Integer::sum
-                ));
+                .collect(java.util.stream.Collectors.toMap(count -> count, count -> 1, Integer::sum));
         System.out.println("\n       Bucket distribution:");
         bucketDistribution.entrySet().stream()
                 .sorted(Map.Entry.comparingByKey())
                 .forEach(entry -> System.out.printf("       Count %d: %d buckets%n", entry.getKey(), entry.getValue()));
-
     }
 
-
     /**
+     * <p>Code direct from HalfDiskHashMap, only change is NUM_BUCKETS</p>
+     *
      * Computes which bucket a key with the given hash falls. Depends on the fact the numOfBuckets
      * is a power of two. Based on same calculation that is used in java HashMap.
      *
@@ -68,7 +65,6 @@ private static void testHashQuality4Bytes(NonCryptographicHashingBench.HashAlgor
      * @return the index of the bucket that key falls in
      */
     private static int computeBucketIndex(final int keyHash) {
-        return (33_554_432 - 1) & keyHash;
+        return (NUM_BUCKETS - 1) & keyHash;
     }
-
 }

From aeea20943a63a430766f82ff41b90e2fa5f44365 Mon Sep 17 00:00:00 2001
From: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
Date: Tue, 12 Aug 2025 10:08:18 -0700
Subject: [PATCH 15/17] Added lots more hashing algorithms and tests

Signed-off-by: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
---
 .../pbj/compiler/impl/LookupHelper.java       |    2 +-
 .../pbj/runtime/NonCryptographicHashing.java  |   86 ++
 .../jmh/NonCryptographicHashingBench.java     |   89 --
 .../pbj/integration/jmh/hashing/CityHash.java |  329 -----
 .../jmh/hashing/CountingArray.java            |  143 +++
 .../integration/jmh/hashing/FasterLeemon.java |   82 --
 .../integration/jmh/hashing/LongBitSet.java   |   75 ++
 .../NonCryptographicHashQuality4ByteTest.java |  119 --
 .../NonCryptographicHashQualityTest.java      |   51 -
 .../hashing/NonCryptographicHashingBench.java |  172 +++
 .../jmh/hashing/functions/CityHash.java       |  171 +++
 .../jmh/hashing/functions/CityHashUnsafe.java |  168 +++
 .../hashing/functions/CityHashVarHandle.java  |  168 +++
 .../jmh/hashing/functions/FarmHash.java       |  189 +++
 .../jmh/hashing/functions/Guava.java          |   30 +
 .../jmh/hashing/functions/HighwayHash.java    |  330 +++++
 .../{ => functions}/JavaStyleHashing.java     |   10 +-
 .../jmh/hashing/functions/LeemonMurmur.java   |   61 +
 .../jmh/hashing/functions/Md5.java            |   32 +
 .../jmh/hashing/functions/MetroHash64.java    |  173 +++
 .../hashing/functions/MetroHash64Array.java   |  180 +++
 .../jmh/hashing/functions/Murmur3Fast.java    |  403 ++++++
 .../jmh/hashing/functions/Murmur3OpenHFT.java |  176 +++
 .../jmh/hashing/functions/MurmurHash3.java    |   78 ++
 .../jmh/hashing/functions/OlegHash.java       |   54 +
 .../jmh/hashing/functions/RapidHash3.java     |  181 +++
 .../jmh/hashing/functions/Sha256.java         |   31 +
 .../jmh/hashing/functions/XXH3OpenHFT.java    | 1136 +++++++++++++++++
 .../jmh/hashing/functions/XXH3OpenHFT2.java   |  425 ++++++
 .../jmh/hashing/{ => functions}/XxHash.java   |    2 +-
 .../jmh/hashing/functions/XxHashRichard.java  |   73 ++
 .../{Xxh3.java => functions/Xxh3ai.java}      |    4 +-
 ...NonCryptographicHashQuality11ByteTest.java |  124 ++
 .../NonCryptographicHashQuality4ByteTest.java |   56 +
 ...ashQuality4ByteTestBucketDistribution.java |   27 +-
 ...NonCryptographicHashQualityOneBitTest.java |   66 +
 ...nCryptographicHashQualityStateKeyTest.java |  261 ++++
 .../NonCryptographicHashQualityTest.java      |   96 ++
 .../scripts_plot_hash_bucket_histograms.py    |  186 +++
 ...ts_plot_hash_bucket_histograms_Version3.py |  230 ++++
 .../src/main/proto/teststate.proto            |   20 +
 41 files changed, 5604 insertions(+), 685 deletions(-)
 delete mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java
 delete mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CityHash.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CountingArray.java
 delete mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/FasterLeemon.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/LongBitSet.java
 delete mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTest.java
 delete mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQualityTest.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashingBench.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/CityHash.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/CityHashUnsafe.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/CityHashVarHandle.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/FarmHash.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Guava.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/HighwayHash.java
 rename pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/{ => functions}/JavaStyleHashing.java (78%)
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/LeemonMurmur.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Md5.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/MetroHash64.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/MetroHash64Array.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Murmur3Fast.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Murmur3OpenHFT.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/MurmurHash3.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/OlegHash.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/RapidHash3.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Sha256.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XXH3OpenHFT.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XXH3OpenHFT2.java
 rename pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/{ => functions}/XxHash.java (98%)
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XxHashRichard.java
 rename pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/{Xxh3.java => functions/Xxh3ai.java} (98%)
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQuality11ByteTest.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQuality4ByteTest.java
 rename pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/{ => qualitytest}/NonCryptographicHashQuality4ByteTestBucketDistribution.java (72%)
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQualityOneBitTest.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQualityStateKeyTest.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQualityTest.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/scripts_plot_hash_bucket_histograms.py
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/scripts_plot_hash_bucket_histograms_Version3.py
 create mode 100644 pbj-integration-tests/src/main/proto/teststate.proto

diff --git a/pbj-core/pbj-compiler/src/main/java/com/hedera/pbj/compiler/impl/LookupHelper.java b/pbj-core/pbj-compiler/src/main/java/com/hedera/pbj/compiler/impl/LookupHelper.java
index 8d3efdf6..47d81182 100644
--- a/pbj-core/pbj-compiler/src/main/java/com/hedera/pbj/compiler/impl/LookupHelper.java
+++ b/pbj-core/pbj-compiler/src/main/java/com/hedera/pbj/compiler/impl/LookupHelper.java
@@ -252,7 +252,7 @@ public String getFullyQualifiedProtoName(final File protoSrcFile, final ParserRu
         final Object[] importsArray =
                 protoFileImports.get(protoSrcFile.getAbsolutePath()).toArray();
         final String importsString = Arrays.toString(importsArray);
-        throw new PbjCompilerException(FAILED_TO_FIND_MSG_TYPE_MESSAGE.formatted(context, protoSrcFile, importsString));
+        throw new PbjCompilerException(FAILED_TO_FIND_MSG_TYPE_MESSAGE.formatted(context.getText(), protoSrcFile, importsString));
     }
 
     /**
diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
index 504d08ba..455283f3 100644
--- a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/NonCryptographicHashing.java
@@ -19,8 +19,54 @@ public static int hash32(@NonNull final byte[] bytes) {
     }
 
     public static int hash32(@NonNull final byte[] bytes, final int position, final int length) {
+        int hash = 1;
+        int i = position;
+        int end = position + length - 31;
+        // fast loop for large byte arrays
+        for (; i < end; i += 32) {
+            int int1 = UnsafeUtils.getIntUnsafeLittleEndian(bytes, i);
+            int int2 = UnsafeUtils.getIntUnsafeLittleEndian(bytes, i + 4);
+            int int3 = UnsafeUtils.getIntUnsafeLittleEndian(bytes, i + 8);
+            int int4 = UnsafeUtils.getIntUnsafeLittleEndian(bytes, i + 12);
+            int int5 = UnsafeUtils.getIntUnsafeLittleEndian(bytes, i + 16);
+            int int6 = UnsafeUtils.getIntUnsafeLittleEndian(bytes, i + 20);
+            int int7 = UnsafeUtils.getIntUnsafeLittleEndian(bytes, i + 24);
+            int int8 = UnsafeUtils.getIntUnsafeLittleEndian(bytes, i + 28);
+            hash = perm32(hash ^ int1);
+            hash = perm32(hash ^ int2);
+            hash = perm32(hash ^ int3);
+            hash = perm32(hash ^ int4);
+            hash = perm32(hash ^ int5);
+            hash = perm32(hash ^ int6);
+            hash = perm32(hash ^ int7);
+            hash = perm32(hash ^ int8);
+        }
+
         // Accumulate the hash in 32-bit chunks. If the length is not a multiple of 4, then read
         // as many complete 4 byte chunks as possible.
+        end = position + length - 3;
+        for (; i < end; i += 4) {
+            hash = perm32(hash ^ UnsafeUtils.getIntUnsafeLittleEndian(bytes, i));
+        }
+
+        // Construct a trailing int. If the segment of the byte array we read was exactly a multiple of 4 bytes,
+        // then we will append "0x0000007F" to the end of the hash. If we had 1 byte remaining, then
+        // we will append "0x00007FXX" where XX is the value of the last byte, and so on.
+        int tail = 0x7F;
+        int start = i;
+        i = position + length - 1;
+        for (; i >= start; i--) {
+            tail <<= 8;
+            tail ^= bytes[i];
+        }
+
+        // Combine the tail with the previous hash.
+        hash = perm32(hash ^ tail);
+
+        return hash;
+    }
+
+    public static int hash32old(@NonNull final byte[] bytes, final int position, final int length) {
         int hash = 1;
         int i = position;
         int end = position + length - 3;
@@ -85,6 +131,46 @@ public static long hash64(@NonNull final byte[] bytes) {
         return hash64(bytes, 0, bytes.length);
     }
 
+    /**
+     * Generates a non-cryptographic 64-bit hash for contents of the given byte array within indexes position
+     * (inclusive) and position + length (exclusive).
+     *
+     * @param bytes A byte array. Must not be null. Can be empty.
+     * @param position The starting position within the byte array to begin hashing from. Must be non-negative,
+     *                 and must be less than the length of the array, and position + length must also be
+     *                 less than or equal to the length of the array.
+     * @param length
+     *         The number of bytes to hash. Must be non-negative, and must be such that position + length
+     *         is less than or equal to the length of the byte array.
+     *
+     * @return a non-cryptographic long hash
+     */
+    public static int hash64xor32(@NonNull final byte[] bytes, final int position, final int length) {
+        long hash64 = hash64(bytes, position, length);
+        // Return the upper 32 XOR lower 32 bits of the hash.
+        return (int) ((hash64 >>> 32) ^ (hash64 & 0xFFFFFFFFL));
+    }
+
+    /**
+     * Generates a non-cryptographic 64-bit hash for contents of the given byte array within indexes position
+     * (inclusive) and position + length (exclusive).
+     *
+     * @param bytes A byte array. Must not be null. Can be empty.
+     * @param position The starting position within the byte array to begin hashing from. Must be non-negative,
+     *                 and must be less than the length of the array, and position + length must also be
+     *                 less than or equal to the length of the array.
+     * @param length
+     *         The number of bytes to hash. Must be non-negative, and must be such that position + length
+     *         is less than or equal to the length of the byte array.
+     *
+     * @return a non-cryptographic long hash
+     */
+    public static int hash64upper32(@NonNull final byte[] bytes, final int position, final int length) {
+        long hash64 = hash64(bytes, position, length);
+        // Return the upper 32 bits of the hash.
+        return (int) ((hash64 >>> 32) & 0xFFFFFFFFL);
+    }
+
     /**
      * Generates a non-cryptographic 64-bit hash for contents of the given byte array within indexes position
      * (inclusive) and position + length (exclusive).
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java
deleted file mode 100644
index 8c3ca916..00000000
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/NonCryptographicHashingBench.java
+++ /dev/null
@@ -1,89 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-package com.hedera.pbj.integration.jmh;
-
-import com.hedera.pbj.integration.jmh.hashing.CityHash;
-import com.hedera.pbj.integration.jmh.hashing.FasterLeemon;
-import com.hedera.pbj.integration.jmh.hashing.HashFunction;
-import com.hedera.pbj.integration.jmh.hashing.JavaStyleHashing;
-import com.hedera.pbj.integration.jmh.hashing.XxHash;
-import com.hedera.pbj.integration.jmh.hashing.Xxh3;
-import com.hedera.pbj.runtime.NonCryptographicHashing;
-import java.util.List;
-import java.util.Random;
-import java.util.concurrent.TimeUnit;
-import java.util.stream.IntStream;
-import org.openjdk.jmh.annotations.Benchmark;
-import org.openjdk.jmh.annotations.BenchmarkMode;
-import org.openjdk.jmh.annotations.Fork;
-import org.openjdk.jmh.annotations.Level;
-import org.openjdk.jmh.annotations.Measurement;
-import org.openjdk.jmh.annotations.Mode;
-import org.openjdk.jmh.annotations.OutputTimeUnit;
-import org.openjdk.jmh.annotations.Param;
-import org.openjdk.jmh.annotations.Scope;
-import org.openjdk.jmh.annotations.Setup;
-import org.openjdk.jmh.annotations.State;
-import org.openjdk.jmh.annotations.Warmup;
-import org.openjdk.jmh.infra.Blackhole;
-
-@SuppressWarnings("unused")
-@State(Scope.Benchmark)
-@Fork(1)
-@Warmup(iterations = 4, time = 2)
-@Measurement(iterations = 4, time = 2)
-@OutputTimeUnit(TimeUnit.NANOSECONDS)
-@BenchmarkMode(Mode.AverageTime)
-public class NonCryptographicHashingBench {
-    public static final int SAMPLES = 10_000;
-
-    public enum HashAlgorithm {
-        LEEMON(NonCryptographicHashing::hash64),
-        LEEMON_32(NonCryptographicHashing::hash32),
-        FASTER_LEEMON(FasterLeemon::hash64),
-        JAVA_31(JavaStyleHashing::hash31),
-        JAVA_255(JavaStyleHashing::hash255),
-        JAVA_256(JavaStyleHashing::hash256),
-        XXHASH_32(XxHash::xxHashCode),
-        XXHASH_64(XxHash::xxHashCodeFast),
-        XXH3(Xxh3::xxh3HashCode),
-        CITY_HASH(CityHash::cityHash64);
-        public final HashFunction function;
-
-        HashAlgorithm(HashFunction function) {
-            this.function = function;
-        }
-    }
-
-    @Param({"4", "8", "9", "12", "40", "60", "1000"})
-    public int dataSize;
-
-    @Param({"LEEMON", "FASTER_LEEMON", "JAVA_31", "JAVA_255", "JAVA_256", "XXHASH_32", "XXHASH_64", "XXH3", "CITY_HASH"
-    })
-    public HashAlgorithm hashAlgorithm;
-
-    private Random random;
-    private List<byte[]> sampleBytes;
-
-    @Setup(Level.Trial)
-    public void setup() {
-        random = new Random(6351384163846453326L);
-        sampleBytes = IntStream.range(0, SAMPLES)
-                .mapToObj(i -> {
-                    final byte[] bytes = new byte[dataSize];
-                    random.nextBytes(bytes);
-                    return bytes;
-                })
-                .distinct()
-                .toList();
-    }
-
-    @Benchmark
-    public void testHashing(Blackhole blackhole) {
-        long sum = 0;
-        for (final byte[] bytes : sampleBytes) {
-            long hash = hashAlgorithm.function.applyAsLong(bytes, 0, dataSize);
-            sum += hash;
-        }
-        blackhole.consume(sum);
-    }
-}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CityHash.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CityHash.java
deleted file mode 100644
index 53ade2a8..00000000
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CityHash.java
+++ /dev/null
@@ -1,329 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-package com.hedera.pbj.integration.jmh.hashing;
-
-import com.hedera.pbj.runtime.io.UnsafeUtils;
-
-/**
- * @author tamtam180 - kirscheless at gmail.com
- * @see http://google-opensource.blogspot.jp/2011/04/introducing-cityhash.html
- * @see http://code.google.com/p/cityhash/
- */
-public class CityHash {
-
-    private static final long k0 = 0xc3a5c85c97cb3127L;
-    private static final long k1 = 0xb492b66fbe98f273L;
-    private static final long k2 = 0x9ae16a3b2f90404fL;
-    private static final long k3 = 0xc949d7c7509e6557L;
-    //
-    //    private static long toLongLE(byte[] b, int i) {
-    //        return (((long) b[i + 7] << 56) +
-    //                ((long) (b[i + 6] & 255) << 48) +
-    //                ((long) (b[i + 5] & 255) << 40) +
-    //                ((long) (b[i + 4] & 255) << 32) +
-    //                ((long) (b[i + 3] & 255) << 24) +
-    //                ((b[i + 2] & 255) << 16) +
-    //                ((b[i + 1] & 255) << 8) +
-    //                ((b[i + 0] & 255) << 0));
-    //    }
-    private static long toLongLE(byte[] b, int i) {
-        return UnsafeUtils.getLongNoChecksLittleEndian(b, i);
-    }
-
-    //    private static int toIntLE(byte[] b, int i) {
-    //        return (((b[i + 3] & 255) << 24) + ((b[i + 2] & 255) << 16) + ((b[i + 1] & 255) << 8) + ((b[i + 0] & 255)
-    // << 0));
-    //    }
-    private static int toIntLE(byte[] b, int i) {
-        return UnsafeUtils.getIntUnsafeLittleEndian(b, i);
-    }
-
-    private static long fetch64(byte[] s, int pos) {
-        return toLongLE(s, pos);
-    }
-
-    private static int fetch32(byte[] s, int pos) {
-        return toIntLE(s, pos);
-    }
-
-    private static long rotate(long val, int shift) {
-        return shift == 0 ? val : (val >>> shift) | (val << (64 - shift));
-    }
-
-    private static long rotateByAtLeast1(long val, int shift) {
-        return (val >>> shift) | (val << (64 - shift));
-    }
-
-    private static long shiftMix(long val) {
-        return val ^ (val >>> 47);
-    }
-
-    private static final long kMul = 0x9ddfea08eb382d69L;
-
-    private static long hash128to64(long u, long v) {
-        long a = (u ^ v) * kMul;
-        a ^= (a >>> 47);
-        long b = (v ^ a) * kMul;
-        b ^= (b >>> 47);
-        b *= kMul;
-        return b;
-    }
-
-    private static long hashLen16(long u, long v) {
-        return hash128to64(u, v);
-    }
-
-    private static long hashLen0to16(byte[] s, int pos, int len) {
-        if (len > 8) {
-            long a = fetch64(s, pos + 0);
-            long b = fetch64(s, pos + len - 8);
-            return hashLen16(a, rotateByAtLeast1(b + len, len)) ^ b;
-        }
-        if (len >= 4) {
-            long a = 0xffffffffL & fetch32(s, pos + 0);
-            return hashLen16((a << 3) + len, 0xffffffffL & fetch32(s, pos + len - 4));
-        }
-        if (len > 0) {
-            int a = s[pos + 0] & 0xFF;
-            int b = s[pos + (len >>> 1)] & 0xFF;
-            int c = s[pos + len - 1] & 0xFF;
-            int y = a + (b << 8);
-            int z = len + (c << 2);
-            return shiftMix(y * k2 ^ z * k3) * k2;
-        }
-        return k2;
-    }
-
-    private static long hashLen17to32(byte[] s, int pos, int len) {
-        long a = fetch64(s, pos + 0) * k1;
-        long b = fetch64(s, pos + 8);
-        long c = fetch64(s, pos + len - 8) * k2;
-        long d = fetch64(s, pos + len - 16) * k0;
-        return hashLen16(rotate(a - b, 43) + rotate(c, 30) + d, a + rotate(b ^ k3, 20) - c + len);
-    }
-
-    private static long[] weakHashLen32WithSeeds(long w, long x, long y, long z, long a, long b) {
-
-        a += w;
-        b = rotate(b + a + z, 21);
-        long c = a;
-        a += x;
-        a += y;
-        b += rotate(a, 44);
-        return new long[] {a + z, b + c};
-    }
-
-    private static long[] weakHashLen32WithSeeds(byte[] s, int pos, long a, long b) {
-        return weakHashLen32WithSeeds(
-                fetch64(s, pos + 0), fetch64(s, pos + 8), fetch64(s, pos + 16), fetch64(s, pos + 24), a, b);
-    }
-
-    private static long hashLen33to64(byte[] s, int pos, int len) {
-
-        long z = fetch64(s, pos + 24);
-        long a = fetch64(s, pos + 0) + (fetch64(s, pos + len - 16) + len) * k0;
-        long b = rotate(a + z, 52);
-        long c = rotate(a, 37);
-
-        a += fetch64(s, pos + 8);
-        c += rotate(a, 7);
-        a += fetch64(s, pos + 16);
-
-        long vf = a + z;
-        long vs = b + rotate(a, 31) + c;
-
-        a = fetch64(s, pos + 16) + fetch64(s, pos + len - 32);
-        z = fetch64(s, pos + len - 8);
-        b = rotate(a + z, 52);
-        c = rotate(a, 37);
-        a += fetch64(s, pos + len - 24);
-        c += rotate(a, 7);
-        a += fetch64(s, pos + len - 16);
-
-        long wf = a + z;
-        long ws = b + rotate(a, 31) + c;
-        long r = shiftMix((vf + ws) * k2 + (wf + vs) * k0);
-
-        return shiftMix(r * k0 + vs) * k2;
-    }
-
-    public static String cityHash64Hex(byte[] s, int pos, int len) {
-        long l = cityHash64(s, pos, len);
-
-        return Long.toHexString(l);
-    }
-
-    public static String cityHash64WithSeedHex(byte[] s, int pos, int len, long seed) {
-        long l = cityHash64WithSeed(s, pos, len, seed);
-
-        return Long.toHexString(l);
-    }
-
-    public static String cityHash64WithSeedsHex(byte[] s, int pos, int len, long seed0, long seed1) {
-        long l = cityHash64WithSeeds(s, pos, len, seed0, seed1);
-
-        return Long.toHexString(l);
-    }
-
-    public static long cityHash64(byte[] s, int pos, int len) {
-
-        if (len <= 32) {
-            if (len <= 16) {
-                return hashLen0to16(s, pos, len);
-            } else {
-                return hashLen17to32(s, pos, len);
-            }
-        } else if (len <= 64) {
-            return hashLen33to64(s, pos, len);
-        }
-
-        long x = fetch64(s, pos + len - 40);
-        long y = fetch64(s, pos + len - 16) + fetch64(s, pos + len - 56);
-        long z = hashLen16(fetch64(s, pos + len - 48) + len, fetch64(s, pos + len - 24));
-
-        long[] v = weakHashLen32WithSeeds(s, pos + len - 64, len, z);
-        long[] w = weakHashLen32WithSeeds(s, pos + len - 32, y + k1, x);
-        x = x * k1 + fetch64(s, pos + 0);
-
-        len = (len - 1) & (~63);
-        do {
-            x = rotate(x + y + v[0] + fetch64(s, pos + 8), 37) * k1;
-            y = rotate(y + v[1] + fetch64(s, pos + 48), 42) * k1;
-            x ^= w[1];
-            y += v[0] + fetch64(s, pos + 40);
-            z = rotate(z + w[0], 33) * k1;
-            v = weakHashLen32WithSeeds(s, pos + 0, v[1] * k1, x + w[0]);
-            w = weakHashLen32WithSeeds(s, pos + 32, z + w[1], y + fetch64(s, pos + 16));
-            {
-                long swap = z;
-                z = x;
-                x = swap;
-            }
-            pos += 64;
-            len -= 64;
-        } while (len != 0);
-
-        return hashLen16(hashLen16(v[0], w[0]) + shiftMix(y) * k1 + z, hashLen16(v[1], w[1]) + x);
-    }
-
-    public static long cityHash64WithSeed(byte[] s, int pos, int len, long seed) {
-        return cityHash64WithSeeds(s, pos, len, k2, seed);
-    }
-
-    public static long cityHash64WithSeeds(byte[] s, int pos, int len, long seed0, long seed1) {
-        return hashLen16(cityHash64(s, pos, len) - seed0, seed1);
-    }
-
-    public static long[] cityMurmur(byte[] s, int pos, int len, long seed0, long seed1) {
-
-        long a = seed0;
-        long b = seed1;
-        long c = 0;
-        long d = 0;
-
-        int l = len - 16;
-        if (l <= 0) {
-            a = shiftMix(a * k1) * k1;
-            c = b * k1 + hashLen0to16(s, pos, len);
-            d = shiftMix(a + (len >= 8 ? fetch64(s, pos + 0) : c));
-        } else {
-
-            c = hashLen16(fetch64(s, pos + len - 8) + k1, a);
-            d = hashLen16(b + len, c + fetch64(s, pos + len - 16));
-            a += d;
-
-            do {
-                a ^= shiftMix(fetch64(s, pos + 0) * k1) * k1;
-                a *= k1;
-                b ^= a;
-                c ^= shiftMix(fetch64(s, pos + 8) * k1) * k1;
-                c *= k1;
-                d ^= c;
-                pos += 16;
-                l -= 16;
-            } while (l > 0);
-        }
-
-        a = hashLen16(a, c);
-        b = hashLen16(d, b);
-
-        return new long[] {a ^ b, hashLen16(b, a)};
-    }
-
-    public static long[] cityHash128WithSeed(byte[] s, int pos, int len, long seed0, long seed1) {
-
-        if (len < 128) {
-            return cityMurmur(s, pos, len, seed0, seed1);
-        }
-
-        long[] v = new long[2], w = new long[2];
-        long x = seed0;
-        long y = seed1;
-        long z = k1 * len;
-
-        v[0] = rotate(y ^ k1, 49) * k1 + fetch64(s, pos);
-        v[1] = rotate(v[0], 42) * k1 + fetch64(s, pos + 8);
-        w[0] = rotate(y + z, 35) * k1 + x;
-        w[1] = rotate(x + fetch64(s, pos + 88), 53) * k1;
-
-        do {
-            x = rotate(x + y + v[0] + fetch64(s, pos + 8), 37) * k1;
-            y = rotate(y + v[1] + fetch64(s, pos + 48), 42) * k1;
-
-            x ^= w[1];
-            y += v[0] + fetch64(s, pos + 40);
-            z = rotate(z + w[0], 33) * k1;
-            v = weakHashLen32WithSeeds(s, pos + 0, v[1] * k1, x + w[0]);
-            w = weakHashLen32WithSeeds(s, pos + 32, z + w[1], y + fetch64(s, pos + 16));
-            {
-                long swap = z;
-                z = x;
-                x = swap;
-            }
-            pos += 64;
-            x = rotate(x + y + v[0] + fetch64(s, pos + 8), 37) * k1;
-            y = rotate(y + v[1] + fetch64(s, pos + 48), 42) * k1;
-            x ^= w[1];
-            y += v[0] + fetch64(s, pos + 40);
-            z = rotate(z + w[0], 33) * k1;
-            v = weakHashLen32WithSeeds(s, pos, v[1] * k1, x + w[0]);
-            w = weakHashLen32WithSeeds(s, pos + 32, z + w[1], y + fetch64(s, pos + 16));
-            {
-                long swap = z;
-                z = x;
-                x = swap;
-            }
-            pos += 64;
-            len -= 128;
-        } while (len >= 128);
-
-        x += rotate(v[0] + z, 49) * k0;
-        z += rotate(w[0], 37) * k0;
-
-        for (int tail_done = 0; tail_done < len; ) {
-            tail_done += 32;
-            y = rotate(x + y, 42) * k0 + v[1];
-            w[0] += fetch64(s, pos + len - tail_done + 16);
-            x = x * k0 + w[0];
-            z += w[1] + fetch64(s, pos + len - tail_done);
-            w[1] += v[0];
-            v = weakHashLen32WithSeeds(s, pos + len - tail_done, v[0] + z, v[1]);
-        }
-
-        x = hashLen16(x, v[0]);
-        y = hashLen16(y + z, w[0]);
-
-        return new long[] {hashLen16(x + v[1], w[1]) + y, hashLen16(x + w[1], y + v[1])};
-    }
-
-    public static long[] cityHash128(byte[] s, int pos, int len) {
-
-        if (len >= 16) {
-            return cityHash128WithSeed(s, pos + 16, len - 16, fetch64(s, pos + 0) ^ k3, fetch64(s, pos + 8));
-        } else if (len >= 8) {
-            return cityHash128WithSeed(
-                    new byte[0], 0, 0, fetch64(s, pos + 0) ^ (len * k0), fetch64(s, pos + len - 8) ^ k1);
-        } else {
-            return cityHash128WithSeed(s, pos, len, k0, k1);
-        }
-    }
-}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CountingArray.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CountingArray.java
new file mode 100644
index 00000000..ff7c5bcc
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/CountingArray.java
@@ -0,0 +1,143 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.IntStream;
+
+/**
+ * An array that counts occurrences of indices in the range [0, 4,294,967,295]. It uses 4 byte arrays to store counts
+ * up to 250 and an overflow map for counts above 250.
+ */
+public final class CountingArray {
+    /** Maximum value for the index, 2^32 */
+    private static final long MAX_VALUE = 4_294_967_296L; // 2^32
+    /** 4x 1 GB arrays to split the integer space into 4 parts */
+    private final byte[][] counts = new byte[4][1_073_741_824];
+    /** Overflow map for counts above 250 */
+    private final Map<Long, Integer> overflowMap = new HashMap<>();
+
+    /**
+     * Clears all the counts
+     */
+    public void clear() {
+        for (byte[] subArray : counts) {
+            Arrays.fill(subArray, (byte) 0);
+        }
+        overflowMap.clear();
+    }
+
+    /**
+     * Returns the number of counts greater than zero across all indices.
+     * This includes counts in the overflow map.
+     *
+     * @return the number of counts greater than zero
+     */
+    public long numberOfGreaterThanZeroCounts() {
+        long count = Arrays.stream(counts)
+                .parallel()
+                .mapToLong(subArray ->
+                        // Count values > 0 and <= 250 in each subArray
+                        IntStream.range(0, subArray.length)
+                                .map(i -> Byte.toUnsignedInt(subArray[i]))
+                                .filter(unsignedValue -> unsignedValue > 0 && unsignedValue <= 250)
+                                .count())
+                .sum();
+        return count
+                + overflowMap.values().stream().mapToLong(Integer::longValue).sum();
+    }
+
+    /**
+     * Returns the number of counts greater than zero across all indices.
+     * This includes counts in the overflow map.
+     *
+     * @return the number of counts greater than one
+     */
+    public long numberOfGreaterThanOneCounts() {
+        long count = Arrays.stream(counts)
+                .parallel()
+                .mapToLong(subArray ->
+                        // Count values > 1 and <= 250 in each subArray
+                        IntStream.range(0, subArray.length)
+                                .map(i -> Byte.toUnsignedInt(subArray[i]))
+                                .filter(unsignedValue -> unsignedValue > 1 && unsignedValue <= 250)
+                                .count())
+                .sum();
+        return count
+                + overflowMap.values().stream().mapToLong(Integer::longValue).sum();
+    }
+
+    /**
+     * Returns the number of 0 counts across all indices.
+     *
+     * @return the number of zero counts
+     */
+    public long numberOfZeroCounts() {
+        long count = 0;
+        for (byte[] subArray : counts) {
+            for (byte b : subArray) {
+                if (b == 0) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+
+    /**
+     * Increments the count for the given index.
+     *
+     * @param index the index to increment, must be in the range [0, 4,294,967,295]
+     */
+    public void increment(long index) {
+        if (index < 0 || index >= MAX_VALUE) {
+            throw new IndexOutOfBoundsException("index: " + index);
+        }
+        int subArrayIndex = (int) (index >>> 30); // 2^30 = 1 GB
+        int indexInSubArray = (int) (index & 0x3FFFFFFF); // 2^30 - 1
+        byte[] subArray = counts[subArrayIndex];
+        int currentValueUnsigned = Byte.toUnsignedInt(subArray[indexInSubArray]);
+        if (currentValueUnsigned <= 250) {
+            // Increment the count in the sub-array using value as unsigned byte
+            final int newValueUnsigned = (currentValueUnsigned + 1) & 0xFF; // wrap at 255
+            subArray[indexInSubArray] = (byte) newValueUnsigned;
+        } else {
+            // Handle overflow
+            subArray[indexInSubArray] = Byte.MIN_VALUE; // marker for overflow
+            overflowMap.compute(index, (key, value) -> value == null ? 250 : value + 1);
+        }
+    }
+
+    /**
+     * Prints the statistics of the counts, including the number of occurrences for each value from 0 to 250,
+     * and the overflow counts.
+     */
+    public void printStats(final StringBuilder resultStr) {
+        // count up number of bytes with each value 0 to 250
+        long[] valueCounts = new long[251]; // 0 to 250
+        for (byte[] subArray : counts) {
+            for (byte b : subArray) {
+                int unsignedValue = Byte.toUnsignedInt(b);
+                if (unsignedValue <= 250) {
+                    valueCounts[unsignedValue]++;
+                }
+            }
+        }
+        // print the counts
+        resultStr.append("       Counts:");
+        for (int i = 0; i <= 250; i++) {
+            long count = valueCounts[i];
+            if (count > 0) {
+                resultStr.append(String.format("  %d=%,d", i, count));
+            }
+        }
+        // print overflow map sorted by index
+        resultStr.append("\n       Overflow counts: " + overflowMap.size());
+        //        overflowMap.entrySet().stream()
+        //                .sorted(Map.Entry.comparingByKey())
+        //                .forEach(entry -> resultStr.append(String.format("  %d=%,d", entry.getKey(),
+        // entry.getValue())));
+        resultStr.append("\n");
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/FasterLeemon.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/FasterLeemon.java
deleted file mode 100644
index 49e0cf08..00000000
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/FasterLeemon.java
+++ /dev/null
@@ -1,82 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-package com.hedera.pbj.integration.jmh.hashing;
-
-import com.hedera.pbj.runtime.io.UnsafeUtils;
-import edu.umd.cs.findbugs.annotations.NonNull;
-
-/**
- * Performs a non-cryptographic 64-bit hash function based on the Leemon algorithm.
- */
-public final class FasterLeemon {
-    /**
-     * Generates a non-cryptographic 64-bit hash for a byte array.
-     *
-     * @param bytes
-     * 		a byte array
-     * @param start
-     *         the start index in the byte array
-     * @param length
-     *         the number of bytes to hash
-     * @return a non-cryptographic long hash
-     */
-    public static long hash64(@NonNull final byte[] bytes, final int start, final int length) {
-        long hash = 0;
-        int i = start;
-        for (; i < start + length - 7; i += 8) {
-            hash = perm64(hash ^ UnsafeUtils.getLongNoChecksLittleEndian(bytes, i));
-        }
-
-        long tail = 0xFF;
-        for (; i < start + length; i++) {
-            tail <<= 8;
-            tail |= bytes[i];
-        }
-        hash = perm64(hash ^ tail);
-
-        return hash;
-    }
-
-    private static long perm64(long x) {
-        // This is necessary so that 0 does not hash to 0.
-        // As a side effect, this constant will hash to 0.
-        // It was randomly generated (not using Java),
-        // so that it will occur in practice less often than more
-        // common numbers like 0 or -1 or Long.MAX_VALUE.
-        x ^= 0x5e8a016a5eb99c18L;
-
-        // Shifts: {30, 27, 16, 20, 5, 18, 10, 24, 30}
-        x += x << 30;
-        x ^= x >>> 27;
-        x += x << 16;
-        x ^= x >>> 20;
-        x += x << 5;
-        x ^= x >>> 18;
-        x += x << 10;
-        x ^= x >>> 24;
-        x += x << 30;
-        return x;
-    }
-
-    // Sample vectorized version commented out for now, as it requires JDK 21+ and the vector API is still incubating.
-    //    /**
-    //     * Vectorized version for processing multiple long values in parallel.
-    //     * This can be useful when hashing multiple values or for internal operations.
-    //     */
-    //    private static LongVector perm64Vector(LongVector v) {
-    //        // Apply the XOR constant
-    //        v = v.lanewise(VectorOperators.XOR, XOR_CONSTANT);
-    //
-    //        // Perform the permutation operations using vector operations
-    //        v = v.add(v.lanewise(VectorOperators.LSHL, 30));
-    //        v = v.lanewise(VectorOperators.XOR, v.lanewise(VectorOperators.LSHR, 27));
-    //        v = v.add(v.lanewise(VectorOperators.LSHL, 16));
-    //        v = v.lanewise(VectorOperators.XOR, v.lanewise(VectorOperators.LSHR, 20));
-    //        v = v.add(v.lanewise(VectorOperators.LSHL, 5));
-    //        v = v.lanewise(VectorOperators.XOR, v.lanewise(VectorOperators.LSHR, 18));
-    //        v = v.add(v.lanewise(VectorOperators.LSHL, 10));
-    //        v = v.lanewise(VectorOperators.XOR, v.lanewise(VectorOperators.LSHR, 24));
-    //        v = v.add(v.lanewise(VectorOperators.LSHL, 30));
-    //
-    //        return v;
-    //    }
-}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/LongBitSet.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/LongBitSet.java
new file mode 100644
index 00000000..3c242b46
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/LongBitSet.java
@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+import java.util.Arrays;
+
+/**
+ * A simple long bit set implementation that uses an array of longs to represent bits.
+ */
+public final class LongBitSet {
+    private static final int BITS_PER_LONG = 64;
+    private static final int SHIFT = 6; // log2(64)
+    private static final long MASK = 0x3FL; // 63
+
+    private final long[] bits;
+    private final long maxBits;
+
+    private static final VarHandle BITS_HANDLE;
+
+    static {
+        try {
+            BITS_HANDLE = MethodHandles.arrayElementVarHandle(long[].class);
+        } catch (Exception e) {
+            throw new ExceptionInInitializerError(e);
+        }
+    }
+
+    public LongBitSet(long size) {
+        // Round up to next power of 2
+        long numLongs = size / BITS_PER_LONG;
+        this.bits = new long[(int) numLongs];
+        this.maxBits = size;
+    }
+
+    public void clear() {
+        Arrays.fill(bits, 0L);
+    }
+
+    public void setBit(long index) {
+        if (index < 0 || index >= maxBits) {
+            throw new IndexOutOfBoundsException("index: " + index);
+        }
+
+        int longIndex = (int) (index >>> SHIFT);
+        long bitMask = 1L << (index & MASK);
+
+        bits[longIndex] |= bitMask;
+    }
+
+    public void setBitThreadSafe(long index) {
+        if (index < 0 || index >= maxBits) {
+            throw new IndexOutOfBoundsException("index: " + index);
+        }
+
+        int longIndex = (int) (index >>> SHIFT);
+        long bitMask = 1L << (index & MASK);
+
+        long current;
+        do {
+            current = (long) BITS_HANDLE.getVolatile(bits, longIndex);
+            if ((current & bitMask) != 0) {
+                return; // Already set
+            }
+        } while (!BITS_HANDLE.compareAndSet(bits, longIndex, current, current | bitMask));
+    }
+
+    public long cardinality() {
+        long count = 0;
+        for (long value : bits) {
+            count += Long.bitCount(value);
+        }
+        return count;
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTest.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTest.java
deleted file mode 100644
index 989bedaa..00000000
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTest.java
+++ /dev/null
@@ -1,119 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-package com.hedera.pbj.integration.jmh.hashing;
-
-import com.hedera.pbj.integration.jmh.NonCryptographicHashingBench;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.VarHandle;
-
-/**
- * A test to evaluate the quality of non-cryptographic hash functions
- * by checking how many unique hashes can be generated from 4-byte inputs.
- * It runs through all combinations of 4 bytes (256^4 = 4,294,967,296 combinations).
- */
-public final class NonCryptographicHashQuality4ByteTest {
-    public static void main(String[] args) {
-        System.out.println("Testing non-cryptographic hash quality - 4 bytes, 4 billion inputs");
-        for (var hashAlgorithm : NonCryptographicHashingBench.HashAlgorithm.values()) {
-            System.out.println("Testing " + hashAlgorithm.name() + " ====================================");
-            testHashQuality4Bytes(hashAlgorithm);
-        }
-    }
-
-    private static void testHashQuality4Bytes(NonCryptographicHashingBench.HashAlgorithm hashAlgorithm) {
-        final long START_TIME = System.currentTimeMillis();
-        final LongBitSet bits = new LongBitSet(4_294_967_296L); // 4 billion bits
-        final byte[] ba = new byte[6];
-        for (int i = 0; i < 256; i++) {
-            // print progress as percentage, overwriting the same line
-            System.out.printf("\r       Progress: %d%%", (i * 100) / 256);
-            System.out.flush();
-            for (int j = 0; j < 256; j++) {
-                for (int k = 0; k < 256; k++) {
-                    for (int l = 0; l < 256; l++) {
-                        ba[0] = (byte) i;
-                        ba[1] = (byte) j;
-                        ba[2] = (byte) k;
-                        ba[3] = (byte) l;
-                        long hash = hashAlgorithm.function.applyAsLong(ba, 0, 4);
-                        int bucket = (int) hash;
-                        bits.setBit(bucket & 0xFFFFFFFFL); // Use only the lower 32 bits
-                    }
-                }
-            }
-        }
-
-        // Check that we have a reasonable number of bits set.
-        long numUniqueHashes = bits.cardinality();
-        long expectedUniqueHashes = 256L * 256 * 256 * 256; // 4-byte combinations
-        long hashCollisions = expectedUniqueHashes - numUniqueHashes;
-        final long END_TIME = System.currentTimeMillis();
-        System.out.printf(
-                "       Number of unique hashes: %,d, hash collisions: %,d, time taken: %.3f seconds%n",
-                numUniqueHashes, hashCollisions, (END_TIME - START_TIME) / 1000.0);
-    }
-
-    /**
-     * A simple long bit set implementation that uses an array of longs to represent bits.
-     */
-    static final class LongBitSet {
-        private static final int BITS_PER_LONG = 64;
-        private static final int SHIFT = 6; // log2(64)
-        private static final long MASK = 0x3FL; // 63
-
-        private final long[] bits;
-        private final long maxBits;
-
-        private static final VarHandle BITS_HANDLE;
-
-        static {
-            try {
-                BITS_HANDLE = MethodHandles.arrayElementVarHandle(long[].class);
-            } catch (Exception e) {
-                throw new ExceptionInInitializerError(e);
-            }
-        }
-
-        public LongBitSet(long size) {
-            // Round up to next power of 2
-            long numLongs = size / BITS_PER_LONG;
-            this.bits = new long[(int) numLongs];
-            this.maxBits = size;
-        }
-
-        public void setBit(long index) {
-            if (index < 0 || index >= maxBits) {
-                throw new IndexOutOfBoundsException("index: " + index);
-            }
-
-            int longIndex = (int) (index >>> SHIFT);
-            long bitMask = 1L << (index & MASK);
-
-            bits[longIndex] |= bitMask;
-        }
-
-        public void setBitThreadSafe(long index) {
-            if (index < 0 || index >= maxBits) {
-                throw new IndexOutOfBoundsException("index: " + index);
-            }
-
-            int longIndex = (int) (index >>> SHIFT);
-            long bitMask = 1L << (index & MASK);
-
-            long current;
-            do {
-                current = (long) BITS_HANDLE.getVolatile(bits, longIndex);
-                if ((current & bitMask) != 0) {
-                    return; // Already set
-                }
-            } while (!BITS_HANDLE.compareAndSet(bits, longIndex, current, current | bitMask));
-        }
-
-        public long cardinality() {
-            long count = 0;
-            for (long value : bits) {
-                count += Long.bitCount(value);
-            }
-            return count;
-        }
-    }
-}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQualityTest.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQualityTest.java
deleted file mode 100644
index a1d3ea0a..00000000
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQualityTest.java
+++ /dev/null
@@ -1,51 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-package com.hedera.pbj.integration.jmh.hashing;
-
-import com.hedera.pbj.integration.jmh.NonCryptographicHashingBench;
-import java.util.HashSet;
-import java.util.Set;
-
-/**
- * A test to evaluate the quality of non-cryptographic hash functions
- * by checking how many unique hashes can be generated from 11-byte inputs.
- * It runs through all 500 million combinations.
- */
-public final class NonCryptographicHashQualityTest {
-    public static void main(String[] args) {
-        System.out.println("Testing non-cryptographic hash quality - 11 bytes, 500 million inputs");
-        for (var hashAlgorithm : NonCryptographicHashingBench.HashAlgorithm.values()) {
-            System.out.println("Testing " + hashAlgorithm.name() + " ====================================");
-            testHashQuality11Bytes2Billion(hashAlgorithm);
-        }
-    }
-
-    private static void testHashQuality11Bytes2Billion(NonCryptographicHashingBench.HashAlgorithm hashAlgorithm) {
-        final long START_TIME = System.currentTimeMillis();
-        final long NUM_INPUTS = 500_000_000L; // 500 million inputs
-        final int NUM_BYTES = 11; // 11 bytes = 88 bits of data input
-        final Set<Long> hashes = new HashSet<>();
-        final byte[] ba = new byte[NUM_BYTES];
-
-        for (long i = 0; i < NUM_INPUTS; i++) {
-            if (i % 10_000_000 == 0) {
-                System.out.printf("\r       Progress: %.2f%%", (i * 100.0) / NUM_INPUTS);
-                System.out.flush();
-            }
-            long value = i;
-            for (int j = 0; j < NUM_BYTES; j++) {
-                // Map each byte to 1..255 (never zero)
-                ba[j] = (byte) ((value % 255) + 1);
-                value /= 255;
-            }
-            final long hash = hashAlgorithm.function.applyAsLong(ba, 0, NUM_BYTES);
-            hashes.add(hash);
-        }
-
-        long numUniqueHashes = hashes.size();
-        long hashCollisions = NUM_INPUTS - numUniqueHashes;
-        final long END_TIME = System.currentTimeMillis();
-        System.out.printf(
-                "       Number of unique hashes: %,d, hash collisions: %,d, time taken: %.3f seconds%n",
-                numUniqueHashes, hashCollisions, (END_TIME - START_TIME) / 1000.0);
-    }
-}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashingBench.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashingBench.java
new file mode 100644
index 00000000..89566b5a
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashingBench.java
@@ -0,0 +1,172 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing;
+
+import com.hedera.pbj.integration.jmh.hashing.functions.CityHash;
+import com.hedera.pbj.integration.jmh.hashing.functions.CityHashUnsafe;
+import com.hedera.pbj.integration.jmh.hashing.functions.CityHashVarHandle;
+import com.hedera.pbj.integration.jmh.hashing.functions.FarmHash;
+import com.hedera.pbj.integration.jmh.hashing.functions.Guava;
+import com.hedera.pbj.integration.jmh.hashing.functions.HighwayHash;
+import com.hedera.pbj.integration.jmh.hashing.functions.JavaStyleHashing;
+import com.hedera.pbj.integration.jmh.hashing.functions.LeemonMurmur;
+import com.hedera.pbj.integration.jmh.hashing.functions.LuceneMurmur3;
+import com.hedera.pbj.integration.jmh.hashing.functions.Md5;
+import com.hedera.pbj.integration.jmh.hashing.functions.MetroHash64;
+import com.hedera.pbj.integration.jmh.hashing.functions.Murmur3Fast;
+import com.hedera.pbj.integration.jmh.hashing.functions.Murmur3OpenHFT;
+import com.hedera.pbj.integration.jmh.hashing.functions.MurmurHash3;
+import com.hedera.pbj.integration.jmh.hashing.functions.OlegHash;
+import com.hedera.pbj.integration.jmh.hashing.functions.RapidHash3;
+import com.hedera.pbj.integration.jmh.hashing.functions.Sha256;
+import com.hedera.pbj.integration.jmh.hashing.functions.XXH3OpenHFT;
+import com.hedera.pbj.integration.jmh.hashing.functions.XXH3OpenHFT2;
+import com.hedera.pbj.integration.jmh.hashing.functions.XxHash;
+import com.hedera.pbj.integration.jmh.hashing.functions.XxHashRichard;
+import com.hedera.pbj.integration.jmh.hashing.functions.Xxh3AiCPort;
+import com.hedera.pbj.integration.jmh.hashing.functions.Xxh3ai;
+import com.hedera.pbj.runtime.NonCryptographicHashing;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.IntStream;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Level;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OperationsPerInvocation;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
+
+@SuppressWarnings("unused")
+@State(Scope.Benchmark)
+@Fork(1)
+@Warmup(iterations = 6, time = 2)
+@Measurement(iterations = 4, time = 2)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@BenchmarkMode(Mode.AverageTime)
+public class NonCryptographicHashingBench {
+    public static final int SAMPLES = 10_000;
+
+    public enum HashAlgorithm {
+        MURMUR_3_FAST(Murmur3Fast::hash64),
+        FARM_HASH(FarmHash::hash64),
+        METRO_HASH(MetroHash64::hash64),
+        MURMUR_OPENHFT(Murmur3OpenHFT::hash64),
+        LEEMON_MURMUR(LeemonMurmur::hash64),
+        GUAVA_FARM_HASH(Guava::farmHash),
+        XXH3_OHFT2(XXH3OpenHFT2::hash64),
+        HIGHWAY_HASH_GOOGLE(HighwayHash::hash64),
+        LEEMON_64(NonCryptographicHashing::hash64),
+        LEEMON_64_XOR_32(NonCryptographicHashing::hash64xor32),
+        LEEMON_64_UPPER_32(NonCryptographicHashing::hash64upper32),
+        CITY_HASH(CityHash::cityHash64),
+        CITY_HASH_UNSAFE(CityHashUnsafe::cityHash64),
+        CITY_HASH_VAR(CityHashVarHandle::cityHash64),
+        LEEMON_32(NonCryptographicHashing::hash32),
+        MURMUR_HASH_3_32(MurmurHash3::murmurhash3_x86_32),
+        OLEG_32(OlegHash::hash32),
+        OLEG_32_2(OlegHash::hash32_2),
+        OLEG_64(OlegHash::hash64),
+        JAVA_31(JavaStyleHashing::hash31),
+        JAVA_255(JavaStyleHashing::hash255),
+        JAVA_256(JavaStyleHashing::hash256),
+        JAVA_257(JavaStyleHashing::hash257),
+        XXHASH_32(XxHash::xxHashCode),
+        XXHASH_RICHARD(XxHashRichard::hash),
+        XXHASH_64(XxHash::xxHashCodeFast),
+        XXH3_AI(Xxh3ai::xxh3HashCode),
+        XXH3_OHFT(XXH3OpenHFT::hash64),
+        XXH3_AI_C_PORT(Xxh3AiCPort::xxh3_64bits),
+        RAPID_HASH_3(RapidHash3::hashBytesToLong),
+        SHA_256(Sha256::hash32),
+        MD5(Md5::hash32),
+        MURMUR_3_32_GUAVA(Guava::murmurhash3_x86_32),
+        SIP_24_GUAVA(Guava::sipHash24),
+        LUCENE_MURMUR3(LuceneMurmur3::murmurhash3_x86_32),
+        LUCENE_MURMUR3_128(LuceneMurmur3::murmurhash3_x64_128),
+        ;
+
+        public final HashFunction function;
+
+        HashAlgorithm(HashFunction function) {
+            this.function = function;
+        }
+    }
+
+    @Param({"4", "8", "9", "12", "40", "60", "1000"})
+    public int dataSize;
+
+    @Param({
+        "MURMUR_3_FAST",
+        "FARM_HASH",
+        "METRO_HASH",
+        "MURMUR_OPENHFT",
+        "LEEMON_MURMUR",
+        "GUAVA_FARM_HASH",
+        "XXH3_OHFT2",
+        "HIGHWAY_HASH_GOOGLE",
+        "LEEMON_64",
+        "LEEMON_64_XOR_32",
+        "LEEMON_64_UPPER_32",
+        "CITY_HASH",
+        "CITY_HASH_UNSAFE",
+        "CITY_HASH_VAR",
+        "LEEMON_32",
+        "MURMUR_HASH_3_32",
+        "OLEG_32",
+        "OLEG_32_2",
+        "OLEG_64",
+        "JAVA_31",
+        "JAVA_255",
+        "JAVA_256",
+        "JAVA_257",
+        "XXHASH_32",
+        "XXHASH_RICHARD",
+        "XXHASH_64",
+        "XXH3_AI",
+        "XXH3_OHFT",
+        "RAPID_HASH_3",
+        "SHA_256",
+        "MD5",
+        "MURMUR_3_32_GUAVA",
+        "SIP_24_GUAVA",
+        "LUCENE_MURMUR3",
+        "LUCENE_MURMUR3_128",
+        "XXH3_AI_C_PORT"
+    })
+    public HashAlgorithm hashAlgorithm;
+
+    private Random random;
+    private List<byte[]> sampleBytes;
+
+    @Setup(Level.Trial)
+    public void setup() {
+        random = new Random(6351384163846453326L);
+        sampleBytes = IntStream.range(0, SAMPLES)
+                .mapToObj(i -> {
+                    final byte[] bytes = new byte[dataSize];
+                    random.nextBytes(bytes);
+                    return bytes;
+                })
+                .distinct()
+                .toList();
+    }
+
+    @Benchmark
+    @OperationsPerInvocation(SAMPLES)
+    public void testHashing(Blackhole blackhole) {
+        long sum = 0;
+        for (final byte[] bytes : sampleBytes) {
+            long hash = hashAlgorithm.function.applyAsLong(bytes, 0, dataSize);
+            sum += hash;
+        }
+        blackhole.consume(sum);
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/CityHash.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/CityHash.java
new file mode 100644
index 00000000..24c7b6fc
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/CityHash.java
@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+/**
+ * CityHash implementation in Java. CityHash is a family of hash functions developed by Google, designed to be fast and
+ * efficient for hashing strings and byte arrays. Based on Apache code from tamtam180 - kirscheless at gmail.com
+ *
+ * @see <a href="https://gist.github.com/andriimartynov/bae6b8b2e8a3ecaace61">Original Java Port Source</a>
+ * @see <a href="https://opensource.googleblog.com/2011/04/introducing-cityhash.html">Blog on CityHash</a>
+ * @see <a href="https://code.google.com/p/cityhash/">CityHash Original Code</a>
+ */
+public class CityHash {
+    private static final long k0 = 0xc3a5c85c97cb3127L;
+    private static final long k1 = 0xb492b66fbe98f273L;
+    private static final long k2 = 0x9ae16a3b2f90404fL;
+    private static final long k3 = 0xc949d7c7509e6557L;
+
+    private static long fetch64(byte[] s, int pos) {
+        return (((long) s[pos + 7] << 56)
+                + ((long) (s[pos + 6] & 255) << 48)
+                + ((long) (s[pos + 5] & 255) << 40)
+                + ((long) (s[pos + 4] & 255) << 32)
+                + ((long) (s[pos + 3] & 255) << 24)
+                + ((s[pos + 2] & 255) << 16)
+                + ((s[pos + 1] & 255) << 8)
+                + ((s[pos + 0] & 255) << 0));
+    }
+
+    private static int fetch32(byte[] s, int pos) {
+        return (((s[pos + 3] & 255) << 24) + ((s[pos + 2] & 255) << 16) + ((s[pos + 1] & 255) << 8) + ((s[pos] & 255)));
+    }
+
+    private static long rotate(long val, int shift) {
+        return shift == 0 ? val : (val >>> shift) | (val << (64 - shift));
+    }
+
+    private static long rotateByAtLeast1(long val, int shift) {
+        return (val >>> shift) | (val << (64 - shift));
+    }
+
+    private static long shiftMix(long val) {
+        return val ^ (val >>> 47);
+    }
+
+    private static final long kMul = 0x9ddfea08eb382d69L;
+
+    private static long hash128to64(long u, long v) {
+        long a = (u ^ v) * kMul;
+        a ^= (a >>> 47);
+        long b = (v ^ a) * kMul;
+        b ^= (b >>> 47);
+        b *= kMul;
+        return b;
+    }
+
+    private static long hashLen16(long u, long v) {
+        return hash128to64(u, v);
+    }
+
+    private static long hashLen0to16(byte[] s, int pos, int len) {
+        if (len > 8) {
+            long a = fetch64(s, pos);
+            long b = fetch64(s, pos + len - 8);
+            return hashLen16(a, rotateByAtLeast1(b + len, len)) ^ b;
+        }
+        if (len >= 4) {
+            long a = 0xffffffffL & fetch32(s, pos);
+            return hashLen16((a << 3) + len, 0xffffffffL & fetch32(s, pos + len - 4));
+        }
+        if (len > 0) {
+            int a = s[pos] & 0xFF;
+            int b = s[pos + (len >>> 1)] & 0xFF;
+            int c = s[pos + len - 1] & 0xFF;
+            int y = a + (b << 8);
+            int z = len + (c << 2);
+            return shiftMix(y * k2 ^ z * k3) * k2;
+        }
+        return k2;
+    }
+
+    private static long hashLen17to32(byte[] s, int pos, int len) {
+        long a = fetch64(s, pos + 0) * k1;
+        long b = fetch64(s, pos + 8);
+        long c = fetch64(s, pos + len - 8) * k2;
+        long d = fetch64(s, pos + len - 16) * k0;
+        return hashLen16(rotate(a - b, 43) + rotate(c, 30) + d, a + rotate(b ^ k3, 20) - c + len);
+    }
+
+    private static long[] weakHashLen32WithSeeds(long w, long x, long y, long z, long a, long b) {
+        a += w;
+        b = rotate(b + a + z, 21);
+        long c = a;
+        a += x;
+        a += y;
+        b += rotate(a, 44);
+        return new long[] {a + z, b + c};
+    }
+
+    private static long[] weakHashLen32WithSeeds(byte[] s, int pos, long a, long b) {
+        return weakHashLen32WithSeeds(
+                fetch64(s, pos + 0), fetch64(s, pos + 8), fetch64(s, pos + 16), fetch64(s, pos + 24), a, b);
+    }
+
+    private static long hashLen33to64(byte[] s, int pos, int len) {
+
+        long z = fetch64(s, pos + 24);
+        long a = fetch64(s, pos + 0) + (fetch64(s, pos + len - 16) + len) * k0;
+        long b = rotate(a + z, 52);
+        long c = rotate(a, 37);
+
+        a += fetch64(s, pos + 8);
+        c += rotate(a, 7);
+        a += fetch64(s, pos + 16);
+
+        long vf = a + z;
+        long vs = b + rotate(a, 31) + c;
+
+        a = fetch64(s, pos + 16) + fetch64(s, pos + len - 32);
+        z = fetch64(s, pos + len - 8);
+        b = rotate(a + z, 52);
+        c = rotate(a, 37);
+        a += fetch64(s, pos + len - 24);
+        c += rotate(a, 7);
+        a += fetch64(s, pos + len - 16);
+
+        long wf = a + z;
+        long ws = b + rotate(a, 31) + c;
+        long r = shiftMix((vf + ws) * k2 + (wf + vs) * k0);
+
+        return shiftMix(r * k0 + vs) * k2;
+    }
+
+    public static long cityHash64(byte[] s, int pos, int len) {
+        if (len <= 32) {
+            if (len <= 16) {
+                return hashLen0to16(s, pos, len);
+            } else {
+                return hashLen17to32(s, pos, len);
+            }
+        } else if (len <= 64) {
+            return hashLen33to64(s, pos, len);
+        }
+
+        long x = fetch64(s, pos + len - 40);
+        long y = fetch64(s, pos + len - 16) + fetch64(s, pos + len - 56);
+        long z = hashLen16(fetch64(s, pos + len - 48) + len, fetch64(s, pos + len - 24));
+
+        long[] v = weakHashLen32WithSeeds(s, pos + len - 64, len, z);
+        long[] w = weakHashLen32WithSeeds(s, pos + len - 32, y + k1, x);
+        x = x * k1 + fetch64(s, pos + 0);
+
+        len = (len - 1) & (~63);
+        do {
+            x = rotate(x + y + v[0] + fetch64(s, pos + 8), 37) * k1;
+            y = rotate(y + v[1] + fetch64(s, pos + 48), 42) * k1;
+            x ^= w[1];
+            y += v[0] + fetch64(s, pos + 40);
+            z = rotate(z + w[0], 33) * k1;
+            v = weakHashLen32WithSeeds(s, pos + 0, v[1] * k1, x + w[0]);
+            w = weakHashLen32WithSeeds(s, pos + 32, z + w[1], y + fetch64(s, pos + 16));
+            {
+                long swap = z;
+                z = x;
+                x = swap;
+            }
+            pos += 64;
+            len -= 64;
+        } while (len != 0);
+        return hashLen16(hashLen16(v[0], w[0]) + shiftMix(y) * k1 + z, hashLen16(v[1], w[1]) + x);
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/CityHashUnsafe.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/CityHashUnsafe.java
new file mode 100644
index 00000000..db102ec4
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/CityHashUnsafe.java
@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+import com.hedera.pbj.runtime.io.UnsafeUtils;
+
+/**
+ * CityHash implementation in Java. CityHash is a family of hash functions developed by Google, designed to be fast and
+ * efficient for hashing strings and byte arrays. Based on Apache code from tamtam180 - kirscheless at gmail.com
+ *
+ * @see <a href="https://gist.github.com/andriimartynov/bae6b8b2e8a3ecaace61">Original Java Port Source</a>
+ * @see <a href="https://opensource.googleblog.com/2011/04/introducing-cityhash.html">Blog on CityHash</a>
+ * @see <a href="https://code.google.com/p/cityhash/">CityHash Original Code</a>
+ */
+public class CityHashUnsafe {
+    private static final long k0 = 0xc3a5c85c97cb3127L;
+    private static final long k1 = 0xb492b66fbe98f273L;
+    private static final long k2 = 0x9ae16a3b2f90404fL;
+    private static final long k3 = 0xc949d7c7509e6557L;
+
+    private static long rotate(long val, int shift) {
+        return shift == 0 ? val : (val >>> shift) | (val << (64 - shift));
+    }
+
+    private static long rotateByAtLeast1(long val, int shift) {
+        return (val >>> shift) | (val << (64 - shift));
+    }
+
+    private static long shiftMix(long val) {
+        return val ^ (val >>> 47);
+    }
+
+    private static final long kMul = 0x9ddfea08eb382d69L;
+
+    private static long hash128to64(long u, long v) {
+        long a = (u ^ v) * kMul;
+        a ^= (a >>> 47);
+        long b = (v ^ a) * kMul;
+        b ^= (b >>> 47);
+        b *= kMul;
+        return b;
+    }
+
+    private static long hashLen16(long u, long v) {
+        return hash128to64(u, v);
+    }
+
+    private static long hashLen0to16(byte[] s, int pos, int len) {
+        if (len > 8) {
+            long a = UnsafeUtils.getLongNoChecksLittleEndian(s, pos);
+            long b = UnsafeUtils.getLongNoChecksLittleEndian(s, pos + len - 8);
+            return hashLen16(a, rotateByAtLeast1(b + len, len)) ^ b;
+        }
+        if (len >= 4) {
+            long a = 0xffffffffL & UnsafeUtils.getIntUnsafeLittleEndian(s, pos);
+            return hashLen16((a << 3) + len, 0xffffffffL & UnsafeUtils.getIntUnsafeLittleEndian(s, pos + len - 4));
+        }
+        if (len > 0) {
+            int a = s[pos] & 0xFF;
+            int b = s[pos + (len >>> 1)] & 0xFF;
+            int c = s[pos + len - 1] & 0xFF;
+            int y = a + (b << 8);
+            int z = len + (c << 2);
+            return shiftMix(y * k2 ^ z * k3) * k2;
+        }
+        return k2;
+    }
+
+    private static long hashLen17to32(byte[] s, int pos, int len) {
+        long a = UnsafeUtils.getLongNoChecksLittleEndian(s, pos) * k1;
+        long b = UnsafeUtils.getLongNoChecksLittleEndian(s, pos + 8);
+        long c = UnsafeUtils.getLongNoChecksLittleEndian(s, pos + len - 8) * k2;
+        long d = UnsafeUtils.getLongNoChecksLittleEndian(s, pos + len - 16) * k0;
+        return hashLen16(rotate(a - b, 43) + rotate(c, 30) + d, a + rotate(b ^ k3, 20) - c + len);
+    }
+
+    private static long[] weakHashLen32WithSeeds(long w, long x, long y, long z, long a, long b) {
+        a += w;
+        b = rotate(b + a + z, 21);
+        long c = a;
+        a += x;
+        a += y;
+        b += rotate(a, 44);
+        return new long[] {a + z, b + c};
+    }
+
+    private static long[] weakHashLen32WithSeeds(byte[] s, int pos, long a, long b) {
+        return weakHashLen32WithSeeds(
+                UnsafeUtils.getLongNoChecksLittleEndian(s, pos),
+                UnsafeUtils.getLongNoChecksLittleEndian(s, pos + 8),
+                UnsafeUtils.getLongNoChecksLittleEndian(s, pos + 16),
+                UnsafeUtils.getLongNoChecksLittleEndian(s, pos + 24),
+                a,
+                b);
+    }
+
+    private static long hashLen33to64(byte[] s, int pos, int len) {
+
+        long z = UnsafeUtils.getLongNoChecksLittleEndian(s, pos + 24);
+        long a = UnsafeUtils.getLongNoChecksLittleEndian(s, pos)
+                + (UnsafeUtils.getLongNoChecksLittleEndian(s, pos + len - 16) + len) * k0;
+        long b = rotate(a + z, 52);
+        long c = rotate(a, 37);
+
+        a += UnsafeUtils.getLongNoChecksLittleEndian(s, pos + 8);
+        c += rotate(a, 7);
+        a += UnsafeUtils.getLongNoChecksLittleEndian(s, pos + 16);
+
+        long vf = a + z;
+        long vs = b + rotate(a, 31) + c;
+
+        a = UnsafeUtils.getLongNoChecksLittleEndian(s, pos + 16)
+                + UnsafeUtils.getLongNoChecksLittleEndian(s, pos + len - 32);
+        z = UnsafeUtils.getLongNoChecksLittleEndian(s, pos + len - 8);
+        b = rotate(a + z, 52);
+        c = rotate(a, 37);
+        a += UnsafeUtils.getLongNoChecksLittleEndian(s, pos + len - 24);
+        c += rotate(a, 7);
+        a += UnsafeUtils.getLongNoChecksLittleEndian(s, pos + len - 16);
+
+        long wf = a + z;
+        long ws = b + rotate(a, 31) + c;
+        long r = shiftMix((vf + ws) * k2 + (wf + vs) * k0);
+
+        return shiftMix(r * k0 + vs) * k2;
+    }
+
+    public static long cityHash64(byte[] s, int pos, int len) {
+        if (len <= 32) {
+            if (len <= 16) {
+                return hashLen0to16(s, pos, len);
+            } else {
+                return hashLen17to32(s, pos, len);
+            }
+        } else if (len <= 64) {
+            return hashLen33to64(s, pos, len);
+        }
+
+        long x = UnsafeUtils.getLongNoChecksLittleEndian(s, pos + len - 40);
+        long y = UnsafeUtils.getLongNoChecksLittleEndian(s, pos + len - 16)
+                + UnsafeUtils.getLongNoChecksLittleEndian(s, pos + len - 56);
+        long z = hashLen16(
+                UnsafeUtils.getLongNoChecksLittleEndian(s, pos + len - 48) + len,
+                UnsafeUtils.getLongNoChecksLittleEndian(s, pos + len - 24));
+
+        long[] v = weakHashLen32WithSeeds(s, pos + len - 64, len, z);
+        long[] w = weakHashLen32WithSeeds(s, pos + len - 32, y + k1, x);
+        x = x * k1 + UnsafeUtils.getLongNoChecksLittleEndian(s, pos);
+
+        len = (len - 1) & (~63);
+        do {
+            x = rotate(x + y + v[0] + UnsafeUtils.getLongNoChecksLittleEndian(s, pos + 8), 37) * k1;
+            y = rotate(y + v[1] + UnsafeUtils.getLongNoChecksLittleEndian(s, pos + 48), 42) * k1;
+            x ^= w[1];
+            y += v[0] + UnsafeUtils.getLongNoChecksLittleEndian(s, pos + 40);
+            z = rotate(z + w[0], 33) * k1;
+            v = weakHashLen32WithSeeds(s, pos, v[1] * k1, x + w[0]);
+            w = weakHashLen32WithSeeds(s, pos + 32, z + w[1], y + UnsafeUtils.getLongNoChecksLittleEndian(s, pos + 16));
+            {
+                long swap = z;
+                z = x;
+                x = swap;
+            }
+            pos += 64;
+            len -= 64;
+        } while (len != 0);
+        return hashLen16(hashLen16(v[0], w[0]) + shiftMix(y) * k1 + z, hashLen16(v[1], w[1]) + x);
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/CityHashVarHandle.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/CityHashVarHandle.java
new file mode 100644
index 00000000..91a204f0
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/CityHashVarHandle.java
@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+
+/**
+ * CityHash implementation in Java. CityHash is a family of hash functions developed by Google, designed to be fast and
+ * efficient for hashing strings and byte arrays. Based on Apache code from tamtam180 - kirscheless at gmail.com
+ *
+ * @see <a href="https://gist.github.com/andriimartynov/bae6b8b2e8a3ecaace61">Original Java Port Source</a>
+ * @see <a href="https://opensource.googleblog.com/2011/04/introducing-cityhash.html">Blog on CityHash</a>
+ * @see <a href="https://code.google.com/p/cityhash/">CityHash Original Code</a>
+ */
+public class CityHashVarHandle {
+    private static final VarHandle LONG_HANDLE =
+            MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.LITTLE_ENDIAN);
+    private static final VarHandle INT_HANDLE =
+            MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN);
+    private static final long k0 = 0xc3a5c85c97cb3127L;
+    private static final long k1 = 0xb492b66fbe98f273L;
+    private static final long k2 = 0x9ae16a3b2f90404fL;
+    private static final long k3 = 0xc949d7c7509e6557L;
+
+    private static long rotate(long val, int shift) {
+        return shift == 0 ? val : (val >>> shift) | (val << (64 - shift));
+    }
+
+    private static long rotateByAtLeast1(long val, int shift) {
+        return (val >>> shift) | (val << (64 - shift));
+    }
+
+    private static long shiftMix(long val) {
+        return val ^ (val >>> 47);
+    }
+
+    private static final long kMul = 0x9ddfea08eb382d69L;
+
+    private static long hash128to64(long u, long v) {
+        long a = (u ^ v) * kMul;
+        a ^= (a >>> 47);
+        long b = (v ^ a) * kMul;
+        b ^= (b >>> 47);
+        b *= kMul;
+        return b;
+    }
+
+    private static long hashLen16(long u, long v) {
+        return hash128to64(u, v);
+    }
+
+    private static long hashLen0to16(byte[] s, int pos, int len) {
+        if (len > 8) {
+            long a = (long) LONG_HANDLE.get(s, pos + 0);
+            long b = (long) LONG_HANDLE.get(s, pos + len - 8);
+            return hashLen16(a, rotateByAtLeast1(b + len, len)) ^ b;
+        }
+        if (len >= 4) {
+            long a = 0xffffffffL & (int) INT_HANDLE.get(s, pos);
+            return hashLen16((a << 3) + len, 0xffffffffL & (int) INT_HANDLE.get(s, pos + len - 4));
+        }
+        if (len > 0) {
+            int a = s[pos] & 0xFF;
+            int b = s[pos + (len >>> 1)] & 0xFF;
+            int c = s[pos + len - 1] & 0xFF;
+            int y = a + (b << 8);
+            int z = len + (c << 2);
+            return shiftMix(y * k2 ^ z * k3) * k2;
+        }
+        return k2;
+    }
+
+    private static long hashLen17to32(byte[] s, int pos, int len) {
+        long a = (long) LONG_HANDLE.get(s, pos) * k1;
+        long b = (long) LONG_HANDLE.get(s, pos + 8);
+        long c = (long) LONG_HANDLE.get(s, pos + len - 8) * k2;
+        long d = (long) LONG_HANDLE.get(s, pos + len - 16) * k0;
+        return hashLen16(rotate(a - b, 43) + rotate(c, 30) + d, a + rotate(b ^ k3, 20) - c + len);
+    }
+
+    private static long[] weakHashLen32WithSeeds(long w, long x, long y, long z, long a, long b) {
+        a += w;
+        b = rotate(b + a + z, 21);
+        long c = a;
+        a += x;
+        a += y;
+        b += rotate(a, 44);
+        return new long[] {a + z, b + c};
+    }
+
+    private static long[] weakHashLen32WithSeeds(byte[] s, int pos, long a, long b) {
+        return weakHashLen32WithSeeds(
+                (long) LONG_HANDLE.get(s, pos),
+                (long) LONG_HANDLE.get(s, pos + 8),
+                (long) LONG_HANDLE.get(s, pos + 16),
+                (long) LONG_HANDLE.get(s, pos + 24),
+                a,
+                b);
+    }
+
+    private static long hashLen33to64(byte[] s, int pos, int len) {
+        long z = (long) LONG_HANDLE.get(s, pos + 24);
+        long a = (long) LONG_HANDLE.get(s, pos) + ((long) LONG_HANDLE.get(s, pos + len - 16) + len) * k0;
+        long b = rotate(a + z, 52);
+        long c = rotate(a, 37);
+
+        a += (long) LONG_HANDLE.get(s, pos + 8);
+        c += rotate(a, 7);
+        a += (long) LONG_HANDLE.get(s, pos + 16);
+
+        long vf = a + z;
+        long vs = b + rotate(a, 31) + c;
+
+        a = (long) LONG_HANDLE.get(s, pos + 16) + (long) LONG_HANDLE.get(s, pos + len - 32);
+        z = (long) LONG_HANDLE.get(s, pos + len - 8);
+        b = rotate(a + z, 52);
+        c = rotate(a, 37);
+        a += (long) LONG_HANDLE.get(s, pos + len - 24);
+        c += rotate(a, 7);
+        a += (long) LONG_HANDLE.get(s, pos + len - 16);
+
+        long wf = a + z;
+        long ws = b + rotate(a, 31) + c;
+        long r = shiftMix((vf + ws) * k2 + (wf + vs) * k0);
+
+        return shiftMix(r * k0 + vs) * k2;
+    }
+
+    public static long cityHash64(byte[] s, int pos, int len) {
+        if (len <= 32) {
+            if (len <= 16) {
+                return hashLen0to16(s, pos, len);
+            } else {
+                return hashLen17to32(s, pos, len);
+            }
+        } else if (len <= 64) {
+            return hashLen33to64(s, pos, len);
+        }
+
+        long x = (long) LONG_HANDLE.get(s, pos + len - 40);
+        long y = (long) LONG_HANDLE.get(s, pos + len - 16) + (long) LONG_HANDLE.get(s, pos + len - 56);
+        long z = hashLen16((long) LONG_HANDLE.get(s, pos + len - 48) + len, (long) LONG_HANDLE.get(s, pos + len - 24));
+
+        long[] v = weakHashLen32WithSeeds(s, pos + len - 64, len, z);
+        long[] w = weakHashLen32WithSeeds(s, pos + len - 32, y + k1, x);
+        x = x * k1 + (long) LONG_HANDLE.get(s, pos);
+
+        len = (len - 1) & (~63);
+        do {
+            x = rotate(x + y + v[0] + (long) LONG_HANDLE.get(s, pos + 8), 37) * k1;
+            y = rotate(y + v[1] + (long) LONG_HANDLE.get(s, pos + 48), 42) * k1;
+            x ^= w[1];
+            y += v[0] + (long) LONG_HANDLE.get(s, pos + 40);
+            z = rotate(z + w[0], 33) * k1;
+            v = weakHashLen32WithSeeds(s, pos, v[1] * k1, x + w[0]);
+            w = weakHashLen32WithSeeds(s, pos + 32, z + w[1], y + (long) LONG_HANDLE.get(s, pos + 16));
+            {
+                long swap = z;
+                z = x;
+                x = swap;
+            }
+            pos += 64;
+            len -= 64;
+        } while (len != 0);
+        return hashLen16(hashLen16(v[0], w[0]) + shiftMix(y) * k1 + z, hashLen16(v[1], w[1]) + x);
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/FarmHash.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/FarmHash.java
new file mode 100644
index 00000000..532d8eec
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/FarmHash.java
@@ -0,0 +1,189 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+import static java.lang.Long.rotateRight;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+
+/**
+ * Port of Google Guava FarmHash with no dependencies and using VarHandle. Also object allocation is avoided.
+ */
+@SuppressWarnings("DuplicatedCode")
+public final class FarmHash {
+    private static final VarHandle LONG_HANDLE =
+            MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.LITTLE_ENDIAN);
+    // Some primes between 2^63 and 2^64 for various uses.
+    private static final long K0 = 0xc3a5c85c97cb3127L;
+    private static final long K1 = 0xb492b66fbe98f273L;
+    private static final long K2 = 0x9ae16a3b2f90404fL;
+
+    public static long hash64(byte[] bytes, int offset, int length) {
+        if (length <= 16) {
+            return hashLength0to16(bytes, offset, length);
+        } else if (length <= 32) {
+            return hashLength17to32(bytes, offset, length);
+        } else if (length <= 64) {
+            return hashLength33To64(bytes, offset, length);
+        } else {
+            return hashLength65Plus(bytes, offset, length);
+        }
+    }
+
+    private static long shiftMix(long val) {
+        return val ^ (val >>> 47);
+    }
+
+    private static long hashLength16(long u, long v, long mul) {
+        long a = (u ^ v) * mul;
+        a ^= (a >>> 47);
+        long b = (v ^ a) * mul;
+        b ^= (b >>> 47);
+        b *= mul;
+        return b;
+    }
+
+    /**
+     * Computes intermediate hash of 32 bytes of byte array from the given offset. Results are
+     * returned in the output array because when we last measured, this was 12% faster than allocating
+     * new arrays every time.
+     */
+    private static void weakHashLength32WithSeeds(byte[] bytes, int offset, long seedA, long seedB, long[] output) {
+        long part1 = load64(bytes, offset);
+        long part2 = load64(bytes, offset + 8);
+        long part3 = load64(bytes, offset + 16);
+        long part4 = load64(bytes, offset + 24);
+
+        seedA += part1;
+        seedB = rotateRight(seedB + seedA + part4, 21);
+        long c = seedA;
+        seedA += part2;
+        seedA += part3;
+        seedB += rotateRight(seedA, 44);
+        output[0] = seedA + part4;
+        output[1] = seedB + c;
+    }
+
+    private static long hashLength0to16(byte[] bytes, int offset, int length) {
+        if (length >= 8) {
+            long mul = K2 + length * 2L;
+            long a = load64(bytes, offset) + K2;
+            long b = load64(bytes, offset + length - 8);
+            long c = rotateRight(b, 37) * mul + a;
+            long d = (rotateRight(a, 25) + b) * mul;
+            return hashLength16(c, d, mul);
+        }
+        if (length >= 4) {
+            long mul = K2 + length * 2;
+            long a = load32(bytes, offset) & 0xFFFFFFFFL;
+            return hashLength16(length + (a << 3), load32(bytes, offset + length - 4) & 0xFFFFFFFFL, mul);
+        }
+        if (length > 0) {
+            byte a = bytes[offset];
+            byte b = bytes[offset + (length >> 1)];
+            byte c = bytes[offset + (length - 1)];
+            int y = (a & 0xFF) + ((b & 0xFF) << 8);
+            int z = length + ((c & 0xFF) << 2);
+            return shiftMix(y * K2 ^ z * K0) * K2;
+        }
+        return K2;
+    }
+
+    private static long hashLength17to32(byte[] bytes, int offset, int length) {
+        long mul = K2 + length * 2L;
+        long a = load64(bytes, offset) * K1;
+        long b = load64(bytes, offset + 8);
+        long c = load64(bytes, offset + length - 8) * mul;
+        long d = load64(bytes, offset + length - 16) * K2;
+        return hashLength16(rotateRight(a + b, 43) + rotateRight(c, 30) + d, a + rotateRight(b + K2, 18) + c, mul);
+    }
+
+    private static long hashLength33To64(byte[] bytes, int offset, int length) {
+        long mul = K2 + length * 2L;
+        long a = load64(bytes, offset) * K2;
+        long b = load64(bytes, offset + 8);
+        long c = load64(bytes, offset + length - 8) * mul;
+        long d = load64(bytes, offset + length - 16) * K2;
+        long y = rotateRight(a + b, 43) + rotateRight(c, 30) + d;
+        long z = hashLength16(y, a + rotateRight(b + K2, 18) + c, mul);
+        long e = load64(bytes, offset + 16) * mul;
+        long f = load64(bytes, offset + 24);
+        long g = (y + load64(bytes, offset + length - 32)) * mul;
+        long h = (z + load64(bytes, offset + length - 24)) * mul;
+        return hashLength16(rotateRight(e + f, 43) + rotateRight(g, 30) + h, e + rotateRight(f + a, 18) + g, mul);
+    }
+
+    /*
+     * Compute an 8-byte hash of a byte array of length greater than 64 bytes.
+     */
+    private static long hashLength65Plus(byte[] bytes, int offset, int length) {
+        int seed = 81;
+        // For strings over 64 bytes we loop. Internal state consists of 56 bytes: v, w, x, y, and z.
+        long x = seed;
+        @SuppressWarnings("ConstantOverflow")
+        long y = seed * K1 + 113;
+        long z = shiftMix(y * K2 + 113) * K2;
+        long[] v = new long[2];
+        long[] w = new long[2];
+        x = x * K2 + load64(bytes, offset);
+
+        // Set end so that after the loop we have 1 to 64 bytes left to process.
+        int end = offset + ((length - 1) / 64) * 64;
+        int last64offset = end + ((length - 1) & 63) - 63;
+        do {
+            x = rotateRight(x + y + v[0] + load64(bytes, offset + 8), 37) * K1;
+            y = rotateRight(y + v[1] + load64(bytes, offset + 48), 42) * K1;
+            x ^= w[1];
+            y += v[0] + load64(bytes, offset + 40);
+            z = rotateRight(z + w[0], 33) * K1;
+            weakHashLength32WithSeeds(bytes, offset, v[1] * K1, x + w[0], v);
+            weakHashLength32WithSeeds(bytes, offset + 32, z + w[1], y + load64(bytes, offset + 16), w);
+            long tmp = x;
+            x = z;
+            z = tmp;
+            offset += 64;
+        } while (offset != end);
+        long mul = K1 + ((z & 0xFF) << 1);
+        // Operate on the last 64 bytes of input.
+        offset = last64offset;
+        w[0] += ((length - 1) & 63);
+        v[0] += w[0];
+        w[0] += v[0];
+        x = rotateRight(x + y + v[0] + load64(bytes, offset + 8), 37) * mul;
+        y = rotateRight(y + v[1] + load64(bytes, offset + 48), 42) * mul;
+        x ^= w[1] * 9;
+        y += v[0] * 9 + load64(bytes, offset + 40);
+        z = rotateRight(z + w[0], 33) * mul;
+        weakHashLength32WithSeeds(bytes, offset, v[1] * mul, x + w[0], v);
+        weakHashLength32WithSeeds(bytes, offset + 32, z + w[1], y + load64(bytes, offset + 16), w);
+        return hashLength16(
+                hashLength16(v[0], w[0], mul) + shiftMix(y) * K0 + x, hashLength16(v[1], w[1], mul) + z, mul);
+    }
+
+    /**
+     * Reads a 64 bit long in little-endian order from the given byte array at the specified offset.
+     * *
+     * @param input the object to access
+     * @param offset offset to the first byte to read within the byte sequence represented
+     * @return a 64 bit long value, little-endian encoded
+     */
+    private static long load64(final byte[] input, final int offset) {
+        return (long) LONG_HANDLE.get(input, offset);
+    }
+
+    /**
+     * Load 4 bytes from the provided array at the indicated offset.
+     *
+     * @param source the input bytes
+     * @param offset the offset into the array at which to start
+     * @return the value found in the array in the form of a long
+     */
+    private static int load32(byte[] source, int offset) {
+        // This is faster than using VarHandle for 4 bytes
+        return (source[offset] & 0xFF)
+                | ((source[offset + 1] & 0xFF) << 8)
+                | ((source[offset + 2] & 0xFF) << 16)
+                | ((source[offset + 3] & 0xFF) << 24);
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Guava.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Guava.java
new file mode 100644
index 00000000..48dfae8a
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Guava.java
@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+import com.google.common.hash.Hashing;
+
+/**
+ * Guava hashing functions using the Guava library. So they can be easily used in JMH benchmarks or other tests.
+ * <p>
+ * This class provides methods to compute MurmurHash3 and SipHash24 hashes using Guava's Hashing utilities.
+ * </p>
+ */
+public final class Guava {
+
+    public static int murmurhash3_x86_32(byte[] data, int offset, int len) {
+        return Hashing.murmur3_32_fixed().hashBytes(data, offset, len).asInt();
+    }
+
+    public static int sipHash24(byte[] data, int offset, int len) {
+        return Hashing.sipHash24().hashBytes(data, offset, len).asInt();
+    }
+
+    public static int farmHash(byte[] data, int offset, int len) {
+        return Hashing.farmHashFingerprint64().hashBytes(data, offset, len).asInt();
+    }
+
+    public static void main(String[] args) {
+        byte[] data = new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        farmHash(data, 0, data.length);
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/HighwayHash.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/HighwayHash.java
new file mode 100644
index 00000000..74146dc9
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/HighwayHash.java
@@ -0,0 +1,330 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+/**
+ * HighwayHash algorithm. See <a href="https://github.com/google/highwayhash">
+ * HighwayHash on GitHub</a>
+ */
+public final class HighwayHash {
+    private final long[] v0 = new long[4];
+    private final long[] v1 = new long[4];
+    private final long[] mul0 = new long[4];
+    private final long[] mul1 = new long[4];
+    private boolean done = false;
+
+    /**
+     * @param key0 first 8 bytes of the key
+     * @param key1 next 8 bytes of the key
+     * @param key2 next 8 bytes of the key
+     * @param key3 last 8 bytes of the key
+     */
+    public HighwayHash(long key0, long key1, long key2, long key3) {
+        reset(key0, key1, key2, key3);
+    }
+
+    /**
+     * @param key array of size 4 with the key to initialize the hash with
+     */
+    public HighwayHash(long[] key) {
+        if (key.length != 4) {
+            throw new IllegalArgumentException(String.format("Key length (%s) must be 4", key.length));
+        }
+        reset(key[0], key[1], key[2], key[3]);
+    }
+
+    /**
+     * Updates the hash with 32 bytes of data. If you can read 4 long values
+     * from your data efficiently, prefer using update() instead for more speed.
+     * @param packet data array which has a length of at least pos + 32
+     * @param pos position in the array to read the first of 32 bytes from
+     */
+    public void updatePacket(byte[] packet, int pos) {
+        if (pos < 0) {
+            throw new IllegalArgumentException(String.format("Pos (%s) must be positive", pos));
+        }
+        if (pos + 32 > packet.length) {
+            throw new IllegalArgumentException("packet must have at least 32 bytes after pos");
+        }
+        long a0 = read64(packet, pos + 0);
+        long a1 = read64(packet, pos + 8);
+        long a2 = read64(packet, pos + 16);
+        long a3 = read64(packet, pos + 24);
+        update(a0, a1, a2, a3);
+    }
+
+    /**
+     * Updates the hash with 32 bytes of data given as 4 longs. This function is
+     * more efficient than updatePacket when you can use it.
+     * @param a0 first 8 bytes in little endian 64-bit long
+     * @param a1 next 8 bytes in little endian 64-bit long
+     * @param a2 next 8 bytes in little endian 64-bit long
+     * @param a3 last 8 bytes in little endian 64-bit long
+     */
+    public void update(long a0, long a1, long a2, long a3) {
+        if (done) {
+            throw new IllegalStateException("Can compute a hash only once per instance");
+        }
+        v1[0] += mul0[0] + a0;
+        v1[1] += mul0[1] + a1;
+        v1[2] += mul0[2] + a2;
+        v1[3] += mul0[3] + a3;
+        for (int i = 0; i < 4; ++i) {
+            mul0[i] ^= (v1[i] & 0xffffffffL) * (v0[i] >>> 32);
+            v0[i] += mul1[i];
+            mul1[i] ^= (v0[i] & 0xffffffffL) * (v1[i] >>> 32);
+        }
+        v0[0] += zipperMerge0(v1[1], v1[0]);
+        v0[1] += zipperMerge1(v1[1], v1[0]);
+        v0[2] += zipperMerge0(v1[3], v1[2]);
+        v0[3] += zipperMerge1(v1[3], v1[2]);
+        v1[0] += zipperMerge0(v0[1], v0[0]);
+        v1[1] += zipperMerge1(v0[1], v0[0]);
+        v1[2] += zipperMerge0(v0[3], v0[2]);
+        v1[3] += zipperMerge1(v0[3], v0[2]);
+    }
+
+    /**
+     * Updates the hash with the last 1 to 31 bytes of the data. You must use
+     * updatePacket first per 32 bytes of the data, if and only if 1 to 31 bytes
+     * of the data are not processed after that, updateRemainder must be used for
+     * those final bytes.
+     * @param bytes data array which has a length of at least pos + size_mod32
+     * @param pos position in the array to start reading size_mod32 bytes from
+     * @param size_mod32 the amount of bytes to read
+     */
+    public void updateRemainder(byte[] bytes, int pos, int size_mod32) {
+        if (pos < 0) {
+            throw new IllegalArgumentException(String.format("Pos (%s) must be positive", pos));
+        }
+        if (size_mod32 < 0 || size_mod32 >= 32) {
+            throw new IllegalArgumentException(String.format("size_mod32 (%s) must be between 0 and 31", size_mod32));
+        }
+        if (pos + size_mod32 > bytes.length) {
+            throw new IllegalArgumentException("bytes must have at least size_mod32 bytes after pos");
+        }
+        int size_mod4 = size_mod32 & 3;
+        int remainder = size_mod32 & ~3;
+        byte[] packet = new byte[32];
+        for (int i = 0; i < 4; ++i) {
+            v0[i] += ((long) size_mod32 << 32) + size_mod32;
+        }
+        rotate32By(size_mod32, v1);
+        for (int i = 0; i < remainder; i++) {
+            packet[i] = bytes[pos + i];
+        }
+        if ((size_mod32 & 16) != 0) {
+            for (int i = 0; i < 4; i++) {
+                packet[28 + i] = bytes[pos + remainder + i + size_mod4 - 4];
+            }
+        } else {
+            if (size_mod4 != 0) {
+                packet[16 + 0] = bytes[pos + remainder + 0];
+                packet[16 + 1] = bytes[pos + remainder + (size_mod4 >>> 1)];
+                packet[16 + 2] = bytes[pos + remainder + (size_mod4 - 1)];
+            }
+        }
+        updatePacket(packet, 0);
+    }
+
+    /**
+     * Computes the hash value after all bytes were processed. Invalidates the
+     * state.
+     *
+     * NOTE: The 64-bit HighwayHash algorithm is declared stable and no longer subject to change.
+     *
+     * @return 64-bit hash
+     */
+    public long finalize64() {
+        permuteAndUpdate();
+        permuteAndUpdate();
+        permuteAndUpdate();
+        permuteAndUpdate();
+        done = true;
+        return v0[0] + v1[0] + mul0[0] + mul1[0];
+    }
+
+    /**
+     * Computes the hash value after all bytes were processed. Invalidates the state.
+     *
+     * @return array of size 2 containing 128-bit hash
+     */
+    public long[] finalize128() {
+        permuteAndUpdate();
+        permuteAndUpdate();
+        permuteAndUpdate();
+        permuteAndUpdate();
+        permuteAndUpdate();
+        permuteAndUpdate();
+        done = true;
+        long[] hash = new long[2];
+        hash[0] = v0[0] + mul0[0] + v1[2] + mul1[2];
+        hash[1] = v0[1] + mul0[1] + v1[3] + mul1[3];
+        return hash;
+    }
+
+    /**
+     * Computes the hash value after all bytes were processed. Invalidates the state.
+     *
+     * @return array of size 4 containing 256-bit hash
+     */
+    public long[] finalize256() {
+        permuteAndUpdate();
+        permuteAndUpdate();
+        permuteAndUpdate();
+        permuteAndUpdate();
+        permuteAndUpdate();
+        permuteAndUpdate();
+        permuteAndUpdate();
+        permuteAndUpdate();
+        permuteAndUpdate();
+        permuteAndUpdate();
+        done = true;
+        long[] hash = new long[4];
+        modularReduction(v1[1] + mul1[1], v1[0] + mul1[0], v0[1] + mul0[1], v0[0] + mul0[0], hash, 0);
+        modularReduction(v1[3] + mul1[3], v1[2] + mul1[2], v0[3] + mul0[3], v0[2] + mul0[2], hash, 2);
+        return hash;
+    }
+
+    private void reset(long key0, long key1, long key2, long key3) {
+        mul0[0] = 0xdbe6d5d5fe4cce2fL;
+        mul0[1] = 0xa4093822299f31d0L;
+        mul0[2] = 0x13198a2e03707344L;
+        mul0[3] = 0x243f6a8885a308d3L;
+        mul1[0] = 0x3bd39e10cb0ef593L;
+        mul1[1] = 0xc0acf169b5f18a8cL;
+        mul1[2] = 0xbe5466cf34e90c6cL;
+        mul1[3] = 0x452821e638d01377L;
+        v0[0] = mul0[0] ^ key0;
+        v0[1] = mul0[1] ^ key1;
+        v0[2] = mul0[2] ^ key2;
+        v0[3] = mul0[3] ^ key3;
+        v1[0] = mul1[0] ^ ((key0 >>> 32) | (key0 << 32));
+        v1[1] = mul1[1] ^ ((key1 >>> 32) | (key1 << 32));
+        v1[2] = mul1[2] ^ ((key2 >>> 32) | (key2 << 32));
+        v1[3] = mul1[3] ^ ((key3 >>> 32) | (key3 << 32));
+    }
+
+    private long zipperMerge0(long v1, long v0) {
+        return (((v0 & 0xff000000L) | (v1 & 0xff00000000L)) >>> 24)
+                | (((v0 & 0xff0000000000L) | (v1 & 0xff000000000000L)) >>> 16)
+                | (v0 & 0xff0000L)
+                | ((v0 & 0xff00L) << 32)
+                | ((v1 & 0xff00000000000000L) >>> 8)
+                | (v0 << 56);
+    }
+
+    private long zipperMerge1(long v1, long v0) {
+        return (((v1 & 0xff000000L) | (v0 & 0xff00000000L)) >>> 24)
+                | (v1 & 0xff0000L)
+                | ((v1 & 0xff0000000000L) >>> 16)
+                | ((v1 & 0xff00L) << 24)
+                | ((v0 & 0xff000000000000L) >>> 8)
+                | ((v1 & 0xffL) << 48)
+                | (v0 & 0xff00000000000000L);
+    }
+
+    private long read64(byte[] src, int pos) {
+        // Mask with 0xffL so that it is 0..255 as long (byte can only be -128..127)
+        return (src[pos] & 0xffL)
+                | ((src[pos + 1] & 0xffL) << 8)
+                | ((src[pos + 2] & 0xffL) << 16)
+                | ((src[pos + 3] & 0xffL) << 24)
+                | ((src[pos + 4] & 0xffL) << 32)
+                | ((src[pos + 5] & 0xffL) << 40)
+                | ((src[pos + 6] & 0xffL) << 48)
+                | ((src[pos + 7] & 0xffL) << 56);
+    }
+
+    private void rotate32By(long count, long[] lanes) {
+        for (int i = 0; i < 4; ++i) {
+            long half0 = (lanes[i] & 0xffffffffL);
+            long half1 = (lanes[i] >>> 32) & 0xffffffffL;
+            lanes[i] = ((half0 << count) & 0xffffffffL) | (half0 >>> (32 - count));
+            lanes[i] |= ((((half1 << count) & 0xffffffffL) | (half1 >>> (32 - count)))) << 32;
+        }
+    }
+
+    private void permuteAndUpdate() {
+        update(
+                (v0[2] >>> 32) | (v0[2] << 32),
+                (v0[3] >>> 32) | (v0[3] << 32),
+                (v0[0] >>> 32) | (v0[0] << 32),
+                (v0[1] >>> 32) | (v0[1] << 32));
+    }
+
+    private void modularReduction(long a3_unmasked, long a2, long a1, long a0, long[] hash, int pos) {
+        long a3 = a3_unmasked & 0x3FFFFFFFFFFFFFFFL;
+        hash[pos + 1] = a1 ^ ((a3 << 1) | (a2 >>> 63)) ^ ((a3 << 2) | (a2 >>> 62));
+        hash[pos] = a0 ^ (a2 << 1) ^ (a2 << 2);
+    }
+
+    //////////////////////////////////////////////////////////////////////////////
+
+    /**
+     * NOTE: The 64-bit HighwayHash algorithm is declared stable and no longer subject to change.
+     *
+     * @param data array with data bytes
+     * @param offset position of first byte of data to read from
+     * @param length number of bytes from data to read
+     * @param key array of size 4 with the key to initialize the hash with
+     * @return 64-bit hash for the given data
+     */
+    public static long hash64(byte[] data, int offset, int length, long[] key) {
+        HighwayHash h = new HighwayHash(key);
+        h.processAll(data, offset, length);
+        return h.finalize64();
+    }
+
+    /**
+     * @param data array with data bytes
+     * @param offset position of first byte of data to read from
+     * @param length number of bytes from data to read
+     * @param key array of size 4 with the key to initialize the hash with
+     * @return array of size 2 containing 128-bit hash for the given data
+     */
+    public static long[] hash128(byte[] data, int offset, int length, long[] key) {
+        HighwayHash h = new HighwayHash(key);
+        h.processAll(data, offset, length);
+        return h.finalize128();
+    }
+
+    /**
+     * @param data array with data bytes
+     * @param offset position of first byte of data to read from
+     * @param length number of bytes from data to read
+     * @param key array of size 4 with the key to initialize the hash with
+     * @return array of size 4 containing 256-bit hash for the given data
+     */
+    public static long[] hash256(byte[] data, int offset, int length, long[] key) {
+        HighwayHash h = new HighwayHash(key);
+        h.processAll(data, offset, length);
+        return h.finalize256();
+    }
+
+    private void processAll(byte[] data, int offset, int length) {
+        int i;
+        for (i = 0; i + 32 <= length; i += 32) {
+            updatePacket(data, offset + i);
+        }
+        if ((length & 31) != 0) {
+            updateRemainder(data, offset + i, length & 31);
+        }
+    }
+
+    /**
+     * NOTE: The 64-bit HighwayHash algorithm is declared stable and no longer subject to change.
+     *
+     * @param data array with data bytes
+     * @param offset position of first byte of data to read from
+     * @param length number of bytes from data to read
+     * @return 64-bit hash for the given data
+     */
+    public static long hash64(byte[] data, int offset, int length) {
+        HighwayHash h = new HighwayHash(KEY);
+        h.processAll(data, offset, length);
+        return h.finalize64();
+    }
+
+    // TODO what is best key for HighwayHash?
+    private static final long[] KEY = {1, 2, 3, 4};
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/JavaStyleHashing.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/JavaStyleHashing.java
similarity index 78%
rename from pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/JavaStyleHashing.java
rename to pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/JavaStyleHashing.java
index 1bff5a94..33b94c73 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/JavaStyleHashing.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/JavaStyleHashing.java
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
-package com.hedera.pbj.integration.jmh.hashing;
+package com.hedera.pbj.integration.jmh.hashing.functions;
 
 import edu.umd.cs.findbugs.annotations.NonNull;
 
@@ -31,4 +31,12 @@ public static int hash256(@NonNull final byte[] bytes, int start, int length) {
         }
         return h;
     }
+
+    public static int hash257(@NonNull final byte[] bytes, int start, int length) {
+        int h = 1;
+        for (int i = length - 1; i >= start; i--) {
+            h = 257 * h + bytes[i];
+        }
+        return h;
+    }
 }
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/LeemonMurmur.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/LeemonMurmur.java
new file mode 100644
index 00000000..b0928ae5
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/LeemonMurmur.java
@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+import com.hedera.pbj.runtime.io.UnsafeUtils;
+import edu.umd.cs.findbugs.annotations.NonNull;
+
+/**
+ * Non-cryptographic 64-bit hash function based on Leemon's hash64 with murmurHash3 mixer function.
+ */
+public class LeemonMurmur {
+
+    /**
+     * Generates a non-cryptographic 64-bit hash for contents of the given byte array within indexes position
+     * (inclusive) and position + length (exclusive).
+     *
+     * @param bytes A byte array. Must not be null. Can be empty.
+     * @param position The starting position within the byte array to begin hashing from. Must be non-negative,
+     *                 and must be less than the length of the array, and position + length must also be
+     *                 less than or equal to the length of the array.
+     * @param length
+     *         The number of bytes to hash. Must be non-negative, and must be such that position + length
+     *         is less than or equal to the length of the byte array.
+     *
+     * @return a non-cryptographic long hash
+     */
+    public static long hash64(@NonNull final byte[] bytes, final int position, final int length) {
+        // Accumulate the hash in 64-bit chunks. If the length is not a multiple of 8, then read
+        // as many complete 8 byte chunks as possible.
+        long hash = 1;
+        int i = position;
+        int end = position + length - 7;
+        for (; i < end; i += 8) {
+            hash = murmurHash3Mixer(hash ^ UnsafeUtils.getLongNoChecksLittleEndian(bytes, i));
+        }
+
+        // Construct a trailing long. If the segment of the byte array we read was exactly a multiple of 8 bytes,
+        // then we will append "0x000000000000007F" to the end of the hash. If we had 1 byte remaining, then
+        // we will append "0x0000000000007FXX" where XX is the value of the last byte, and so on.
+        long tail = 0x7F;
+        int start = i;
+        i = position + length - 1;
+        for (; i >= start; i--) {
+            tail <<= 8;
+            tail ^= bytes[i];
+        }
+
+        // Combine the tail with the previous hash.
+        hash = murmurHash3Mixer(hash ^ tail);
+
+        return hash;
+    }
+
+    private static long murmurHash3Mixer(long key) {
+        key ^= (key >> 33);
+        key *= 0xff51afd7ed558ccdL;
+        key ^= (key >> 33);
+        key *= 0xc4ceb9fe1a85ec53L;
+        key ^= (key >> 33);
+        return key;
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Md5.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Md5.java
new file mode 100644
index 00000000..d529b33a
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Md5.java
@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+import java.security.DigestException;
+import java.security.MessageDigest;
+
+/**
+ * Non-thread-safe MD5 implementation of HashFunction. Takes the lower 32 bits of the hash as integer.
+ */
+public class Md5 {
+    private static MessageDigest md5;
+    private static byte[] hash;
+
+    static {
+        try {
+            md5 = MessageDigest.getInstance("MD5");
+            hash = new byte[md5.getDigestLength()];
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to initialize MD5", e);
+        }
+    }
+
+    public static int hash32(byte[] data, int offset, int len) {
+        md5.update(data, offset, len);
+        try {
+            md5.digest(hash, 0, hash.length);
+        } catch (DigestException e) {
+            throw new RuntimeException(e);
+        }
+        return ((hash[0] & 0xFF) << 24) | ((hash[1] & 0xFF) << 16) | ((hash[2] & 0xFF) << 8) | (hash[3] & 0xFF);
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/MetroHash64.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/MetroHash64.java
new file mode 100644
index 00000000..92c30c65
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/MetroHash64.java
@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+/*
+ * Copyright (c) 2016 Marius Posta
+ *
+ * Licensed under the Apache 2 license:
+ * http://www.apache.org/licenses/LICENSE-2.0.txt
+ */
+
+import java.nio.ByteBuffer;
+
+public class MetroHash64 {
+
+    public final long seed;
+    private long v0, v1, v2, v3;
+    private long nChunks;
+    private long hash;
+
+    /**
+     * Initializes a MetroHash64 state with the given seed.
+     */
+    public MetroHash64(long seed) {
+        this.seed = seed;
+        reset();
+    }
+
+    public static long hash64(byte[] data, int offset, int length) {
+        MetroHash64 hash64 = new MetroHash64(0);
+        ByteBuffer input = ByteBuffer.wrap(data, offset, length);
+        hash64.reset();
+        while (input.remaining() >= 32) {
+            hash64.partialApply32ByteChunk(input);
+        }
+        return hash64.partialApplyRemaining(input).get();
+    }
+
+    /**
+     * Current hash value.
+     */
+    public long get() {
+        return hash;
+    }
+
+    public MetroHash64 reset() {
+        v0 = v1 = v2 = v3 = hash = (seed + K2) * K0;
+        nChunks = 0;
+        return this;
+    }
+
+    public MetroHash64 partialApply32ByteChunk(ByteBuffer partialInput) {
+        assert partialInput.remaining() >= 32;
+        v0 += grab8(partialInput) * K0;
+        v0 = rotr64(v0, 29) + v2;
+        v1 += grab8(partialInput) * K1;
+        v1 = rotr64(v1, 29) + v3;
+        v2 += grab8(partialInput) * K2;
+        v2 = rotr64(v2, 29) + v0;
+        v3 += grab8(partialInput) * K3;
+        v3 = rotr64(v3, 29) + v1;
+        ++nChunks;
+        return this;
+    }
+
+    public MetroHash64 partialApplyRemaining(ByteBuffer partialInput) {
+        assert partialInput.remaining() < 32;
+        if (nChunks > 0) {
+            metroHash64_32();
+        }
+        if (partialInput.remaining() >= 16) {
+            metroHash64_16(partialInput);
+        }
+        if (partialInput.remaining() >= 8) {
+            metroHash64_8(partialInput);
+        }
+        if (partialInput.remaining() >= 4) {
+            metroHash64_4(partialInput);
+        }
+        if (partialInput.remaining() >= 2) {
+            metroHash64_2(partialInput);
+        }
+        if (partialInput.remaining() >= 1) {
+            metroHash64_1(partialInput);
+        }
+        hash ^= rotr64(hash, 28);
+        hash *= K0;
+        hash ^= rotr64(hash, 29);
+        return this;
+    }
+
+    private static final long K0 = 0xD6D018F5L;
+    private static final long K1 = 0xA2AA033BL;
+    private static final long K2 = 0x62992FC1L;
+    private static final long K3 = 0x30BC5B29L;
+
+    private void metroHash64_32() {
+        v2 ^= rotr64(((v0 + v3) * K0) + v1, 37) * K1;
+        v3 ^= rotr64(((v1 + v2) * K1) + v0, 37) * K0;
+        v0 ^= rotr64(((v0 + v2) * K0) + v3, 37) * K1;
+        v1 ^= rotr64(((v1 + v3) * K1) + v2, 37) * K0;
+        hash += v0 ^ v1;
+    }
+
+    private void metroHash64_16(ByteBuffer bb) {
+        v0 = hash + grab8(bb) * K2;
+        v0 = rotr64(v0, 29) * K3;
+        v1 = hash + grab8(bb) * K2;
+        v1 = rotr64(v1, 29) * K3;
+        v0 ^= rotr64(v0 * K0, 21) + v1;
+        v1 ^= rotr64(v1 * K3, 21) + v0;
+        hash += v1;
+    }
+
+    private void metroHash64_8(ByteBuffer bb) {
+        hash += grab8(bb) * K3;
+        hash ^= rotr64(hash, 55) * K1;
+    }
+
+    private void metroHash64_4(ByteBuffer bb) {
+        hash += grab4(bb) * K3;
+        hash ^= rotr64(hash, 26) * K1;
+    }
+
+    private void metroHash64_2(ByteBuffer bb) {
+        hash += grab2(bb) * K3;
+        hash ^= rotr64(hash, 48) * K1;
+    }
+
+    private void metroHash64_1(ByteBuffer bb) {
+        hash += grab1(bb) * K3;
+        hash ^= rotr64(hash, 37) * K1;
+    }
+
+    static long rotr64(long x, int r) {
+        return (x >>> r) | (x << (64 - r));
+    }
+
+    static long grab1(ByteBuffer bb) {
+        return ((long) bb.get() & 0xFFL);
+    }
+
+    static long grab2(ByteBuffer bb) {
+        final long v0 = bb.get();
+        final long v1 = bb.get();
+        return (v0 & 0xFFL) | (v1 & 0xFFL) << 8;
+    }
+
+    static long grab4(ByteBuffer bb) {
+        final long v0 = bb.get();
+        final long v1 = bb.get();
+        final long v2 = bb.get();
+        final long v3 = bb.get();
+        return (v0 & 0xFFL) | (v1 & 0xFFL) << 8 | (v2 & 0xFFL) << 16 | (v3 & 0xFFL) << 24;
+    }
+
+    static long grab8(ByteBuffer bb) {
+        final long v0 = bb.get();
+        final long v1 = bb.get();
+        final long v2 = bb.get();
+        final long v3 = bb.get();
+        final long v4 = bb.get();
+        final long v5 = bb.get();
+        final long v6 = bb.get();
+        final long v7 = bb.get();
+        return (v0 & 0xFFL)
+                | (v1 & 0xFFL) << 8
+                | (v2 & 0xFFL) << 16
+                | (v3 & 0xFFL) << 24
+                | (v4 & 0xFFL) << 32
+                | (v5 & 0xFFL) << 40
+                | (v6 & 0xFFL) << 48
+                | (v7 & 0xFFL) << 56;
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/MetroHash64Array.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/MetroHash64Array.java
new file mode 100644
index 00000000..06b0f108
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/MetroHash64Array.java
@@ -0,0 +1,180 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+/*
+ * Copyright (c) 2016 Marius Posta
+ *
+ * Licensed under the Apache 2 license:
+ * http://www.apache.org/licenses/LICENSE-2.0.txt
+ */
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+public class MetroHash64Array {
+    private static final VarHandle LONG_HANDLE =
+            MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.LITTLE_ENDIAN);
+    private static final VarHandle INT_HANDLE =
+            MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN);
+
+    public final long seed;
+    private long v0, v1, v2, v3;
+    private long nChunks;
+    private long hash;
+
+    /**
+     * Initializes a MetroHash64 state with the given seed.
+     */
+    public MetroHash64Array(long seed) {
+        this.seed = seed;
+        reset();
+    }
+
+    public static long hash64(byte[] data, int offset, int length) {
+        MetroHash64Array hash64 = new MetroHash64Array(0);
+        ByteBuffer input = ByteBuffer.wrap(data, offset, length);
+        hash64.reset();
+        while (input.remaining() >= 32) {
+            hash64.partialApply32ByteChunk(input);
+        }
+        return hash64.partialApplyRemaining(input).get();
+    }
+
+    /**
+     * Current hash value.
+     */
+    public long get() {
+        return hash;
+    }
+
+    public MetroHash64Array reset() {
+        v0 = v1 = v2 = v3 = hash = (seed + K2) * K0;
+        nChunks = 0;
+        return this;
+    }
+
+    public MetroHash64Array partialApply32ByteChunk(ByteBuffer partialInput) {
+        assert partialInput.remaining() >= 32;
+        v0 += grab8(partialInput) * K0;
+        v0 = rotr64(v0, 29) + v2;
+        v1 += grab8(partialInput) * K1;
+        v1 = rotr64(v1, 29) + v3;
+        v2 += grab8(partialInput) * K2;
+        v2 = rotr64(v2, 29) + v0;
+        v3 += grab8(partialInput) * K3;
+        v3 = rotr64(v3, 29) + v1;
+        ++nChunks;
+        return this;
+    }
+
+    public MetroHash64Array partialApplyRemaining(ByteBuffer partialInput) {
+        assert partialInput.remaining() < 32;
+        if (nChunks > 0) {
+            metroHash64_32();
+        }
+        if (partialInput.remaining() >= 16) {
+            metroHash64_16(partialInput);
+        }
+        if (partialInput.remaining() >= 8) {
+            metroHash64_8(partialInput);
+        }
+        if (partialInput.remaining() >= 4) {
+            metroHash64_4(partialInput);
+        }
+        if (partialInput.remaining() >= 2) {
+            metroHash64_2(partialInput);
+        }
+        if (partialInput.remaining() >= 1) {
+            metroHash64_1(partialInput);
+        }
+        hash ^= rotr64(hash, 28);
+        hash *= K0;
+        hash ^= rotr64(hash, 29);
+        return this;
+    }
+
+    private static final long K0 = 0xD6D018F5L;
+    private static final long K1 = 0xA2AA033BL;
+    private static final long K2 = 0x62992FC1L;
+    private static final long K3 = 0x30BC5B29L;
+
+    private void metroHash64_32() {
+        v2 ^= rotr64(((v0 + v3) * K0) + v1, 37) * K1;
+        v3 ^= rotr64(((v1 + v2) * K1) + v0, 37) * K0;
+        v0 ^= rotr64(((v0 + v2) * K0) + v3, 37) * K1;
+        v1 ^= rotr64(((v1 + v3) * K1) + v2, 37) * K0;
+        hash += v0 ^ v1;
+    }
+
+    private void metroHash64_16(ByteBuffer bb) {
+        v0 = hash + grab8(bb) * K2;
+        v0 = rotr64(v0, 29) * K3;
+        v1 = hash + grab8(bb) * K2;
+        v1 = rotr64(v1, 29) * K3;
+        v0 ^= rotr64(v0 * K0, 21) + v1;
+        v1 ^= rotr64(v1 * K3, 21) + v0;
+        hash += v1;
+    }
+
+    private void metroHash64_8(ByteBuffer bb) {
+        hash += grab8(bb) * K3;
+        hash ^= rotr64(hash, 55) * K1;
+    }
+
+    private void metroHash64_4(ByteBuffer bb) {
+        hash += grab4(bb) * K3;
+        hash ^= rotr64(hash, 26) * K1;
+    }
+
+    private void metroHash64_2(ByteBuffer bb) {
+        hash += grab2(bb) * K3;
+        hash ^= rotr64(hash, 48) * K1;
+    }
+
+    private void metroHash64_1(ByteBuffer bb) {
+        hash += grab1(bb) * K3;
+        hash ^= rotr64(hash, 37) * K1;
+    }
+
+    static long rotr64(long x, int r) {
+        return (x >>> r) | (x << (64 - r));
+    }
+
+    static long grab1(ByteBuffer bb) {
+        return ((long) bb.get() & 0xFFL);
+    }
+
+    static long grab2(ByteBuffer bb) {
+        final long v0 = bb.get();
+        final long v1 = bb.get();
+        return (v0 & 0xFFL) | (v1 & 0xFFL) << 8;
+    }
+
+    static long grab4(ByteBuffer bb) {
+        final long v0 = bb.get();
+        final long v1 = bb.get();
+        final long v2 = bb.get();
+        final long v3 = bb.get();
+        return (v0 & 0xFFL) | (v1 & 0xFFL) << 8 | (v2 & 0xFFL) << 16 | (v3 & 0xFFL) << 24;
+    }
+
+    static long grab8(ByteBuffer bb) {
+        final long v0 = bb.get();
+        final long v1 = bb.get();
+        final long v2 = bb.get();
+        final long v3 = bb.get();
+        final long v4 = bb.get();
+        final long v5 = bb.get();
+        final long v6 = bb.get();
+        final long v7 = bb.get();
+        return (v0 & 0xFFL)
+                | (v1 & 0xFFL) << 8
+                | (v2 & 0xFFL) << 16
+                | (v3 & 0xFFL) << 24
+                | (v4 & 0xFFL) << 32
+                | (v5 & 0xFFL) << 40
+                | (v6 & 0xFFL) << 48
+                | (v7 & 0xFFL) << 56;
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Murmur3Fast.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Murmur3Fast.java
new file mode 100644
index 00000000..636fbcb5
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Murmur3Fast.java
@@ -0,0 +1,403 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+
+/**
+ * ChatGPT Highly optimized MurmurHash3 x64 128-bit variant folded to 64 bits (h1 + h2),
+ * seed fixed at 1 to match Murmur3OpenHFT.hash64(...). Produces identical results
+ * (bit-for-bit) to the OpenHFT implementation for all inputs while targeting lower latency.
+ *
+ * Design choices:
+ * - Specialized fast paths for <=16 and <=32 bytes.
+ * - 32-byte unrolled main loop (two 16-byte blocks per iteration).
+ * - Inlined mixK1 / mixK2 logic.
+ * - Tail switch identical in semantics to canonical implementation.
+ * - Uses VarHandle little-endian views for aligned-ish bulk loads.
+ *
+ * Public domain (matching original Murmur3 licensing spirit).
+ */
+public final class Murmur3Fast {
+    private static final long SEED = 1L;
+    private static final VarHandle LONG_HANDLE =
+            MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.LITTLE_ENDIAN);
+
+    private static final long C1 = 0x87c37b91114253d5L;
+    private static final long C2 = 0x4cf5ad432745937fL;
+
+    private Murmur3Fast() {}
+
+    /**
+     * Compute MurmurHash3 x64 128-bit variant folded to a single 64-bit value (h1 + h2),
+     * identical to OpenHFT MurmurHash_3.hash128(...).low() + high() approach used there.
+     *
+     * @param data   byte array
+     * @param offset starting offset
+     * @param length number of bytes
+     * @return 64-bit hash
+     */
+    @SuppressWarnings("fallthrough")
+    public static long hash64(byte[] data, int offset, int length) {
+        // Fast paths for very small inputs (avoid loop / extra branches)
+        if (length <= 16) {
+            return smallHash16(data, offset, length);
+        }
+        if (length <= 32) {
+            return smallHash32(data, offset, length);
+        }
+
+        long h1 = SEED;
+        long h2 = SEED;
+
+        int pos = offset;
+        int end = offset + length;
+        int remaining = length;
+
+        // Process 32 bytes per iteration (two standard 16-byte Murmur blocks)
+        while (remaining >= 32) {
+            // First 16 bytes
+            long k1 = load64(data, pos);
+            long k2 = load64(data, pos + 8);
+            pos += 16;
+            remaining -= 16;
+
+            // mix block into h1/h2 (inlined mixK1/k2)
+            k1 *= C1;
+            k1 = Long.rotateLeft(k1, 31);
+            k1 *= C2;
+            h1 ^= k1;
+            h1 = Long.rotateLeft(h1, 27);
+            h1 += h2;
+            h1 = h1 * 5 + 0x52dce729L;
+
+            k2 *= C2;
+            k2 = Long.rotateLeft(k2, 33);
+            k2 *= C1;
+            h2 ^= k2;
+            h2 = Long.rotateLeft(h2, 31);
+            h2 += h1;
+            h2 = h2 * 5 + 0x38495ab5L;
+
+            // Second 16 bytes (only if we still have at least 16; we already knew remaining >=16 at top)
+            k1 = load64(data, pos);
+            k2 = load64(data, pos + 8);
+            pos += 16;
+            remaining -= 16;
+
+            k1 *= C1;
+            k1 = Long.rotateLeft(k1, 31);
+            k1 *= C2;
+            h1 ^= k1;
+            h1 = Long.rotateLeft(h1, 27);
+            h1 += h2;
+            h1 = h1 * 5 + 0x52dce729L;
+
+            k2 *= C2;
+            k2 = Long.rotateLeft(k2, 33);
+            k2 *= C1;
+            h2 ^= k2;
+            h2 = Long.rotateLeft(h2, 31);
+            h2 += h1;
+            h2 = h2 * 5 + 0x38495ab5L;
+        }
+
+        // Any leftover full 16-byte block
+        while (remaining >= 16) {
+            long k1 = load64(data, pos);
+            long k2 = load64(data, pos + 8);
+            pos += 16;
+            remaining -= 16;
+
+            k1 *= C1;
+            k1 = Long.rotateLeft(k1, 31);
+            k1 *= C2;
+            h1 ^= k1;
+            h1 = Long.rotateLeft(h1, 27);
+            h1 += h2;
+            h1 = h1 * 5 + 0x52dce729L;
+
+            k2 *= C2;
+            k2 = Long.rotateLeft(k2, 33);
+            k2 *= C1;
+            h2 ^= k2;
+            h2 = Long.rotateLeft(h2, 31);
+            h2 += h1;
+            h2 = h2 * 5 + 0x38495ab5L;
+        }
+
+        // Tail (0..15 bytes)
+        if (remaining > 0) {
+            long k1 = 0;
+            long k2 = 0;
+            // Build identical to canonical switch on remaining
+            switch (remaining) {
+                case 15:
+                    k2 ^= (long) (data[pos + 14] & 0xFF) << 48;
+                case 14:
+                    k2 ^= (long) (data[pos + 13] & 0xFF) << 40;
+                case 13:
+                    k2 ^= (long) (data[pos + 12] & 0xFF) << 32;
+                case 12:
+                    k2 ^= (long) (data[pos + 11] & 0xFF) << 24;
+                case 11:
+                    k2 ^= (long) (data[pos + 10] & 0xFF) << 16;
+                case 10:
+                    k2 ^= (long) (data[pos + 9] & 0xFF) << 8;
+                case 9:
+                    k2 ^= (long) (data[pos + 8] & 0xFF);
+                case 8:
+                    k1 ^= load64(data, pos);
+                    break;
+                case 7:
+                    k1 ^= (long) (data[pos + 6] & 0xFF) << 48;
+                case 6:
+                    k1 ^= (long) (data[pos + 5] & 0xFF) << 40;
+                case 5:
+                    k1 ^= (long) (data[pos + 4] & 0xFF) << 32;
+                case 4:
+                    k1 ^= (load32(data, pos) & 0xFFFFFFFFL);
+                    break;
+                case 3:
+                    k1 ^= (long) (data[pos + 2] & 0xFF) << 16;
+                case 2:
+                    k1 ^= (long) (data[pos + 1] & 0xFF) << 8;
+                case 1:
+                    k1 ^= (long) (data[pos] & 0xFF);
+                case 0:
+                    break;
+                default: // unreachable
+            }
+
+            if (remaining > 8) {
+                k2 *= C2;
+                k2 = Long.rotateLeft(k2, 33);
+                k2 *= C1;
+                h2 ^= k2;
+            }
+            if (remaining > 0) {
+                k1 *= C1;
+                k1 = Long.rotateLeft(k1, 31);
+                k1 *= C2;
+                h1 ^= k1;
+            }
+        }
+
+        // Finalization (same sequence)
+        h1 ^= length;
+        h2 ^= length;
+        h1 += h2;
+        h2 += h1;
+
+        h1 = fmix64(h1);
+        h2 = fmix64(h2);
+
+        return h1 + h2;
+    }
+
+    /* ------------ Small-size specialized paths ------------ */
+
+    // For length 1..16 (or 0) – interpret as pure tail on empty loop.
+    private static long smallHash16(byte[] data, int offset, int length) {
+        long h1 = SEED;
+        long h2 = SEED;
+
+        if (length == 0) {
+            // finalize directly
+            h1 ^= 0;
+            h2 ^= 0;
+            h1 += h2;
+            h2 += h1;
+            h1 = fmix64(h1);
+            h2 = fmix64(h2);
+            return h1 + h2;
+        }
+
+        long k1 = 0;
+        long k2 = 0;
+        // For len > 8, part goes to k2 just like standard tail
+        if (length > 8) {
+            int tailOff = offset + length - 8;
+            k2 = load64LEPartial(data, tailOff, length - 8); // build k2 from last (length-8) bytes
+            k1 = load64LEPartial(data, offset, 8);
+        } else {
+            k1 = load64LEPartial(data, offset, length);
+        }
+
+        if (length > 8) {
+            k2 *= C2;
+            k2 = Long.rotateLeft(k2, 33);
+            k2 *= C1;
+            h2 ^= k2;
+        }
+        k1 *= C1;
+        k1 = Long.rotateLeft(k1, 31);
+        k1 *= C2;
+        h1 ^= k1;
+
+        h1 ^= length;
+        h2 ^= length;
+        h1 += h2;
+        h2 += h1;
+        h1 = fmix64(h1);
+        h2 = fmix64(h2);
+        return h1 + h2;
+    }
+
+    // For 17..32 bytes: process first 16 as a block, rest as tail
+    @SuppressWarnings("fallthrough")
+    private static long smallHash32(byte[] data, int offset, int length) {
+        long h1 = SEED;
+        long h2 = SEED;
+
+        // First 16 bytes block
+        long k1 = load64(data, offset);
+        long k2 = load64(data, offset + 8);
+
+        k1 *= C1;
+        k1 = Long.rotateLeft(k1, 31);
+        k1 *= C2;
+        h1 ^= k1;
+        h1 = Long.rotateLeft(h1, 27);
+        h1 += h2;
+        h1 = h1 * 5 + 0x52dce729L;
+
+        k2 *= C2;
+        k2 = Long.rotateLeft(k2, 33);
+        k2 *= C1;
+        h2 ^= k2;
+        h2 = Long.rotateLeft(h2, 31);
+        h2 += h1;
+        h2 = h2 * 5 + 0x38495ab5L;
+
+        int remaining = length - 16;
+        if (remaining > 0) {
+            int pos = offset + 16;
+            long t1 = 0;
+            long t2 = 0; // will remain zero (we know remaining <=16)
+
+            // Construct t1 from remaining bytes
+            // Use switch like canonical tail (remaining 1..16)
+            switch (remaining) {
+                case 15:
+                    t2 ^= (long) (data[pos + 14] & 0xFF) << 48;
+                case 14:
+                    t2 ^= (long) (data[pos + 13] & 0xFF) << 40;
+                case 13:
+                    t2 ^= (long) (data[pos + 12] & 0xFF) << 32;
+                case 12:
+                    t2 ^= (long) (data[pos + 11] & 0xFF) << 24;
+                case 11:
+                    t2 ^= (long) (data[pos + 10] & 0xFF) << 16;
+                case 10:
+                    t2 ^= (long) (data[pos + 9] & 0xFF) << 8;
+                case 9:
+                    t2 ^= (long) (data[pos + 8] & 0xFF);
+                case 8:
+                    t1 ^= load64(data, pos);
+                    break;
+                case 7:
+                    t1 ^= (long) (data[pos + 6] & 0xFF) << 48;
+                case 6:
+                    t1 ^= (long) (data[pos + 5] & 0xFF) << 40;
+                case 5:
+                    t1 ^= (long) (data[pos + 4] & 0xFF) << 32;
+                case 4:
+                    t1 ^= (load32(data, pos) & 0xFFFFFFFFL);
+                    break;
+                case 3:
+                    t1 ^= (long) (data[pos + 2] & 0xFF) << 16;
+                case 2:
+                    t1 ^= (long) (data[pos + 1] & 0xFF) << 8;
+                case 1:
+                    t1 ^= (long) (data[pos] & 0xFF);
+                case 0:
+                    break;
+            }
+
+            if (remaining > 8) {
+                t2 *= C2;
+                t2 = Long.rotateLeft(t2, 33);
+                t2 *= C1;
+                h2 ^= t2;
+            }
+            if (remaining > 0) {
+                t1 *= C1;
+                t1 = Long.rotateLeft(t1, 31);
+                t1 *= C2;
+                h1 ^= t1;
+            }
+        }
+
+        h1 ^= length;
+        h2 ^= length;
+        h1 += h2;
+        h2 += h1;
+        h1 = fmix64(h1);
+        h2 = fmix64(h2);
+        return h1 + h2;
+    }
+
+    /* ------------ Helpers ------------ */
+
+    private static long fmix64(long k) {
+        k ^= k >>> 33;
+        k *= 0xff51afd7ed558ccdL;
+        k ^= k >>> 33;
+        k *= 0xc4ceb9fe1a85ec53L;
+        k ^= k >>> 33;
+        return k;
+    }
+
+    private static long load64(byte[] a, int off) {
+        return (long) LONG_HANDLE.get(a, off);
+    }
+
+    /**
+     * Load 4 bytes from the provided array at the indicated offset.
+     *
+     * @param source the input bytes
+     * @param offset the offset into the array at which to start
+     * @return the value found in the array in the form of a long
+     */
+    private static int load32(byte[] source, int offset) {
+        // This is faster than using VarHandle for 4 bytes
+        return (source[offset] & 0xFF)
+                | ((source[offset + 1] & 0xFF) << 8)
+                | ((source[offset + 2] & 0xFF) << 16)
+                | ((source[offset + 3] & 0xFF) << 24);
+    }
+
+    /**
+     * Assemble up to 8 bytes (count 1..8) little-endian into a long.
+     * When count==8 you should prefer load64 for speed; this is only for partial tails.
+     */
+    @SuppressWarnings("fallthrough")
+    private static long load64LEPartial(byte[] a, int off, int count) {
+        long r = 0;
+        // Unrolled up to 8 for speed (count <=8 guaranteed)
+        switch (count) {
+            case 8:
+                r |= (long) (a[off + 7] & 0xFF) << 56;
+            case 7:
+                r |= (long) (a[off + 6] & 0xFF) << 48;
+            case 6:
+                r |= (long) (a[off + 5] & 0xFF) << 40;
+            case 5:
+                r |= (long) (a[off + 4] & 0xFF) << 32;
+            case 4:
+                r |= (long) (a[off + 3] & 0xFF) << 24;
+            case 3:
+                r |= (long) (a[off + 2] & 0xFF) << 16;
+            case 2:
+                r |= (long) (a[off + 1] & 0xFF) << 8;
+            case 1:
+                r |= (a[off] & 0xFF);
+            case 0:
+                break;
+            default: // not possible
+        }
+        return r;
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Murmur3OpenHFT.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Murmur3OpenHFT.java
new file mode 100644
index 00000000..2e29b73a
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Murmur3OpenHFT.java
@@ -0,0 +1,176 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+
+/**
+ * MurmurHash3 implementation in Java, specifically the OpenHFT variant but ported to use VarHandles and hard coded to
+ * byte[] inputs.
+ *
+ * @see <a href="https://github.com/OpenHFT/Zero-Allocation-Hashing/blob/ea/src/main/java/net/openhft/hashing/MurmurHash_3.java">
+ *      Original OpenHFT MurmurHash3 Source</a>
+ */
+public final class Murmur3OpenHFT {
+    private static final long SEED = 1L; // Default seed value
+    private static final VarHandle LONG_HANDLE =
+            MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.LITTLE_ENDIAN);
+
+    private static final long C1 = 0x87c37b91114253d5L;
+    private static final long C2 = 0x4cf5ad432745937fL;
+
+    @SuppressWarnings("fallthrough")
+    public static long hash64(final byte[] input, int offset, final long length) {
+        long h1 = SEED;
+        long h2 = SEED;
+        long remaining = length;
+        while (remaining >= 16L) {
+            long k1 = i64(input, offset);
+            long k2 = i64(input, offset + 8L);
+            offset += 16;
+            remaining -= 16L;
+            h1 ^= mixK1(k1);
+
+            h1 = Long.rotateLeft(h1, 27);
+            h1 += h2;
+            h1 = h1 * 5L + 0x52dce729L;
+
+            h2 ^= mixK2(k2);
+
+            h2 = Long.rotateLeft(h2, 31);
+            h2 += h1;
+            h2 = h2 * 5L + 0x38495ab5L;
+        }
+
+        if (remaining > 0L) {
+            long k1 = 0L;
+            long k2 = 0L;
+            switch ((int) remaining) {
+                case 15:
+                    k2 ^= ((long) u8(input, offset + 14L)) << 48; // fall through
+                case 14:
+                    k2 ^= ((long) u8(input, offset + 13L)) << 40; // fall through
+                case 13:
+                    k2 ^= ((long) u8(input, offset + 12L)) << 32; // fall through
+                case 12:
+                    k2 ^= ((long) u8(input, offset + 11L)) << 24; // fall through
+                case 11:
+                    k2 ^= ((long) u8(input, offset + 10L)) << 16; // fall through
+                case 10:
+                    k2 ^= ((long) u8(input, offset + 9L)) << 8; // fall through
+                case 9:
+                    k2 ^= ((long) u8(input, offset + 8L)); // fall through
+                case 8:
+                    k1 ^= i64(input, offset);
+                    break;
+                case 7:
+                    k1 ^= ((long) u8(input, offset + 6L)) << 48; // fall through
+                case 6:
+                    k1 ^= ((long) u8(input, offset + 5L)) << 40; // fall through
+                case 5:
+                    k1 ^= ((long) u8(input, offset + 4L)) << 32; // fall through
+                case 4:
+                    k1 ^= u32(input, offset);
+                    break;
+                case 3:
+                    k1 ^= ((long) u8(input, offset + 2L)) << 16; // fall through
+                case 2:
+                    k1 ^= ((long) u8(input, offset + 1L)) << 8; // fall through
+                case 1:
+                    k1 ^= u8(input, offset);
+                case 0:
+                    break;
+                default:
+                    throw new AssertionError("Should never get here.");
+            }
+            h1 ^= mixK1(k1);
+            h2 ^= mixK2(k2);
+        }
+        return finalize(length, h1, h2);
+    }
+
+    private static long finalize(long length, long h1, long h2) {
+        h1 ^= length;
+        h2 ^= length;
+        h1 += h2;
+        h2 += h1;
+        h1 = fmix64(h1);
+        h2 = fmix64(h2);
+        return h1 + h2;
+    }
+
+    private static long fmix64(long k) {
+        k ^= k >>> 33;
+        k *= 0xff51afd7ed558ccdL;
+        k ^= k >>> 33;
+        k *= 0xc4ceb9fe1a85ec53L;
+        k ^= k >>> 33;
+        return k;
+    }
+
+    private static long mixK1(long k1) {
+        k1 *= C1;
+        k1 = Long.rotateLeft(k1, 31);
+        k1 *= C2;
+        return k1;
+    }
+
+    private static long mixK2(long k2) {
+        k2 *= C2;
+        k2 = Long.rotateLeft(k2, 33);
+        k2 *= C1;
+        return k2;
+    }
+
+    /**
+     * Reads a 64 bit long in little-endian order from the given byte array at the specified offset.
+     * *
+     * @param input the object to access
+     * @param offset offset to the first byte to read within the byte sequence represented
+     * @return a 64 bit long value, little-endian encoded
+     */
+    private static long i64(final byte[] input, final long offset) {
+        return (long) LONG_HANDLE.get(input, (int) offset);
+    }
+
+    /**
+     * Reads an unsigned byte from the given byte array at the specified offset.
+     *
+     * @param input the object to access
+     * @param offset offset to the byte to read within the byte sequence represented
+     * by the given object
+     * @return a byte by the given {@code offset}, interpreted as unsigned
+     */
+    private static int u8(final byte[] input, final long offset) {
+        return Byte.toUnsignedInt(input[(int) offset]);
+    }
+
+    //
+    //    /**
+    //     * Shortcut for {@code getInt(input, offset) & 0xFFFFFFFFL}. Could be implemented more
+    //     * efficiently.
+    //     *
+    //     * @param input the object to access
+    //     * @param offset offset to the first byte to read within the byte sequence represented
+    //     * by the given object
+    //     * @return four bytes as an unsigned int value, little-endian encoded
+    //     */
+    //    private static long u32(final byte[] input, final long offset) {
+    //        return (long) INT_HANDLE.get(input, (int)offset) & 0xFFFFFFFFL;
+    //    }
+    /**
+     * Load 4 bytes from the provided array at the indicated offset.
+     *
+     * @param source the input bytes
+     * @param offset the offset into the array at which to start
+     * @return the value found in the array in the form of a long
+     */
+    private static int u32(byte[] source, int offset) {
+        // This is faster than using VarHandle for 4 bytes
+        return (source[offset] & 0xFF)
+                | ((source[offset + 1] & 0xFF) << 8)
+                | ((source[offset + 2] & 0xFF) << 16)
+                | ((source[offset + 3] & 0xFF) << 24);
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/MurmurHash3.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/MurmurHash3.java
new file mode 100644
index 00000000..7fa0794b
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/MurmurHash3.java
@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+/**
+ * The MurmurHash3 algorithm was created by Austin Appleby and placed in the public domain.
+ * This java port was authored by Yonik Seeley and also placed into the public domain.
+ * It has been modified by Konstantin Sobolev and, you guessed it, also placed in the public domain.
+ * The author hereby disclaims copyright to this source code.
+ * <p>
+ * This produces exactly the same hash values as the final C++
+ * version of MurmurHash3 and is thus suitable for producing the same hash values across
+ * platforms.
+ * </p>
+ *
+ * @see <a href="https://github.com/eprst/murmur3/blob/master/src/main/java/com/github/eprst/murmur3/MurmurHash3.java">
+ *      Original Java Port Source</a>
+ */
+@SuppressWarnings("fallthrough")
+public final class MurmurHash3 {
+    private static final int c1 = 0xcc9e2d51;
+    private static final int c2 = 0x1b873593;
+
+    /**
+     * Computes the MurmurHash3_x86_32 hash of the given byte array, using seed of 1.
+     *
+     * @param data   the byte array to hash
+     * @param offset the starting offset in the byte array
+     * @param len    the length of the data to hash
+     * @return the computed hash value
+     */
+    public static int murmurhash3_x86_32(byte[] data, int offset, int len) {
+        int h1 = 1;
+        int roundedEnd = offset + (len & 0xfffffffc); // round down to 4 byte block
+
+        for (int i = offset; i < roundedEnd; i += 4) {
+            // little endian load order
+            int k1 =
+                    (data[i] & 0xff) | ((data[i + 1] & 0xff) << 8) | ((data[i + 2] & 0xff) << 16) | (data[i + 3] << 24);
+            k1 *= c1;
+            k1 = (k1 << 15) | (k1 >>> 17); // ROTL32(k1,15);
+            k1 *= c2;
+
+            h1 ^= k1;
+            h1 = (h1 << 13) | (h1 >>> 19); // ROTL32(h1,13);
+            h1 = h1 * 5 + 0xe6546b64;
+        }
+
+        // tail
+        int k1 = 0;
+
+        switch (len & 0x03) {
+            case 3:
+                k1 = (data[roundedEnd + 2] & 0xff) << 16;
+            // fall through
+            case 2:
+                k1 |= (data[roundedEnd + 1] & 0xff) << 8;
+            // fall through
+            case 1:
+                k1 |= (data[roundedEnd] & 0xff);
+                k1 *= c1;
+                k1 = (k1 << 15) | (k1 >>> 17); // ROTL32(k1,15);
+                k1 *= c2;
+                h1 ^= k1;
+        }
+
+        // finalization
+        h1 ^= len;
+
+        // fmix(h1);
+        h1 ^= h1 >>> 16;
+        h1 *= 0x85ebca6b;
+        h1 ^= h1 >>> 13;
+        h1 *= 0xc2b2ae35;
+        h1 ^= h1 >>> 16;
+
+        return h1;
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/OlegHash.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/OlegHash.java
new file mode 100644
index 00000000..e0d4e39b
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/OlegHash.java
@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+import edu.umd.cs.findbugs.annotations.NonNull;
+
+public class OlegHash {
+    static final int[] preHashed;
+
+    static {
+        preHashed = new int[256];
+        for (int b = 0; b < 256; ++b) {
+            int hash = 0;
+            for (int m = 1 << 7; m != 0; m >>= 1) {
+                hash <<= 1;
+                if ((b & m) != 0) {
+                    hash ^= 0x8b;
+                }
+            }
+            preHashed[b] = hash;
+        }
+    }
+
+    public static int hash32(@NonNull final byte[] bytes, final int start, final int length) {
+        int hash = 0;
+        for (int i = start; i < start + length; ++i) {
+            hash = (hash << 8) ^ preHashed[(hash >> 24) & 0xff] ^ (bytes[i] & 0xff);
+        }
+        return hash;
+    }
+
+    public static int hash32_2old(byte[] bytes, final int start, final int length) {
+        int hash = 0;
+        for (int i = start; i < start + length; ++i) {
+            hash = (hash << 8) + (hash >>> 24) + (bytes[i] & 0xff);
+        }
+        return hash;
+    }
+
+    public static int hash32_2(byte[] bytes, final int start, final int length) {
+        int hash = 0;
+        for (int i = start; i < start + length; ++i) {
+            hash = (hash << 8) + (hash >>> 24) * 3 + (bytes[i] & 0xff);
+        }
+        return hash;
+    }
+
+    public static long hash64(@NonNull final byte[] bytes, final int start, final int length) {
+        long hash = 0;
+        for (int i = start; i < start + length; ++i) {
+            hash = (hash << 8) + (hash >>> 56) + (bytes[i] & 0xff);
+        }
+        return hash;
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/RapidHash3.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/RapidHash3.java
new file mode 100644
index 00000000..9ec07202
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/RapidHash3.java
@@ -0,0 +1,181 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+
+/**
+ * Minimalized port of https://github.com/dynatrace-oss/hash4j/blob/main/src/main/java/com/dynatrace/hash4j/hashing/Rapidhash3.java
+ *
+ * This file includes a Java port of the Rapidhash algorithm originally published
+ * at https://github.com/Nicoshev/rapidhash under the following license:
+ *
+ * Copyright 2025 Nicolas De Carli
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+public final class RapidHash3 {
+    private static final VarHandle LONG_HANDLE =
+            MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.LITTLE_ENDIAN);
+    private static final VarHandle INT_HANDLE =
+            MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN);
+
+    private static final long SEC0 = 0x2d358dccaa6c78a5L;
+    private static final long SEC1 = 0x8bb84b93962eacc9L;
+    private static final long SEC2 = 0x4b33a62ed433d4a3L;
+    private static final long SEC3 = 0x4d5a2da51de1aa47L;
+    private static final long SEC4 = 0xa0761d6478bd642fL;
+    private static final long SEC5 = 0xe7037ed1a0b428dbL;
+    private static final long SEC6 = 0x90ed1765281c388cL;
+    private static final long SEC7 = 0xaaaaaaaaaaaaaaaaL;
+
+    private static final long SEED;
+
+    static {
+        final long startSeed = 0L;
+        SEED = startSeed ^ mix(startSeed ^ SEC2, SEC1);
+    }
+
+    /**
+     * Returns the most significant 64 bits of the unsigned 128-bit product of two unsigned 64-bit
+     * factors as a long.
+     *
+     * @param x the first value
+     * @param y the second value
+     * @return the result
+     */
+    private static long unsignedMultiplyHigh(long x, long y) {
+        return Math.multiplyHigh(x, y) + ((x >> 63) & y) + ((y >> 63) & x);
+    }
+
+    private static long mix(long a, long b) {
+        long x = a * b;
+        long y = unsignedMultiplyHigh(a, b);
+        return x ^ y;
+    }
+
+    /**
+     * Reads a {@code long} value from a byte array with given offset.
+     *
+     * @param b a byte array
+     * @param off an offset
+     * @return the read value
+     */
+    private static long getLong(byte[] b, int off) {
+        return (long) LONG_HANDLE.get(b, off);
+    }
+
+    /**
+     * Reads an {@code int} value from a byte array with given offset.
+     *
+     * @param b a byte array
+     * @param off an offset
+     * @return the read value
+     */
+    public static int getInt(byte[] b, int off) {
+        return (int) INT_HANDLE.get(b, off);
+    }
+
+    /**
+     * Hashes the given byte array to a long value using the RapidHash3 algorithm.
+     *
+     * @param input the byte array to hash
+     * @param off the offset in the byte array to start hashing from
+     * @param len the length of the byte array to hash
+     * @return the resulting hash as a long value
+     */
+    public static long hashBytesToLong(byte[] input, int off, int len) {
+        long see0 = SEED;
+        long a;
+        long b;
+        if (len <= 16) {
+            if (len >= 4) {
+                if (len >= 8) {
+                    a = getLong(input, off);
+                    b = getLong(input, off + len - 8);
+                } else {
+                    b = getInt(input, off) & 0xFFFFFFFFL;
+                    a = getInt(input, off + len - 4) & 0xFFFFFFFFL;
+                }
+                a ^= len;
+                see0 ^= len;
+            } else if (len > 0) {
+                a = ((input[off] & 0xFFL) << 45) ^ (input[off + len - 1] & 0xFFL) ^ len;
+                b = input[off + (len >> 1)] & 0xFFL;
+            } else {
+                a = 0;
+                b = 0;
+            }
+        } else {
+            long see1 = see0;
+            long see2 = see0;
+            long see3 = see0;
+            long see4 = see0;
+            long see5 = see0;
+            long see6 = see0;
+            if (len > 112) {
+                do {
+                    see0 = mix(getLong(input, off) ^ SEC0, getLong(input, off + 8) ^ see0);
+                    see1 = mix(getLong(input, off + 16) ^ SEC1, getLong(input, off + 24) ^ see1);
+                    see2 = mix(getLong(input, off + 32) ^ SEC2, getLong(input, off + 40) ^ see2);
+                    see3 = mix(getLong(input, off + 48) ^ SEC3, getLong(input, off + 56) ^ see3);
+                    see4 = mix(getLong(input, off + 64) ^ SEC4, getLong(input, off + 72) ^ see4);
+                    see5 = mix(getLong(input, off + 80) ^ SEC5, getLong(input, off + 88) ^ see5);
+                    see6 = mix(getLong(input, off + 96) ^ SEC6, getLong(input, off + 104) ^ see6);
+                    off += 112;
+                    len -= 112;
+                } while (len > 112);
+                see0 ^= see1;
+                see2 ^= see3;
+                see4 ^= see5;
+                see0 ^= see6;
+                see2 ^= see4;
+                see0 ^= see2;
+            }
+            if (len > 16) {
+                see0 = mix(getLong(input, off) ^ SEC2, getLong(input, off + 8) ^ see0);
+                if (len > 32) {
+                    see0 = mix(getLong(input, off + 16) ^ SEC2, getLong(input, off + 24) ^ see0);
+                    if (len > 48) {
+                        see0 = mix(getLong(input, off + 32) ^ SEC1, getLong(input, off + 40) ^ see0);
+                        if (len > 64) {
+                            see0 = mix(getLong(input, off + 48) ^ SEC1, getLong(input, off + 56) ^ see0);
+                            if (len > 80) {
+                                see0 = mix(getLong(input, off + 64) ^ SEC2, getLong(input, off + 72) ^ see0);
+                                if (len > 96) {
+                                    see0 = mix(getLong(input, off + 80) ^ SEC1, getLong(input, off + 88) ^ see0);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            a = getLong(input, off + len - 16);
+            b = getLong(input, off + len - 8);
+        }
+        long a1 = a;
+        long b1 = b;
+        long len1 = len;
+        len1 ^= SEC1;
+        a1 ^= len1;
+        b1 ^= see0;
+        return mix((a1 * b1) ^ SEC7, unsignedMultiplyHigh(a1, b1) ^ len1);
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Sha256.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Sha256.java
new file mode 100644
index 00000000..baaef951
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Sha256.java
@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+import java.security.DigestException;
+import java.security.MessageDigest;
+
+/**
+ * Non-thread-safe SHA-256 implementation of HashFunction. Takes the lower 32 bits of the hash as integer.
+ */
+public class Sha256 {
+    private static MessageDigest sha256;
+    private static byte[] hash = new byte[32]; // SHA-256 produces a 32-byte hash
+
+    static {
+        try {
+            sha256 = MessageDigest.getInstance("SHA-256");
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to initialize SHA-256", e);
+        }
+    }
+
+    public static int hash32(byte[] data, int offset, int len) {
+        sha256.update(data, offset, len);
+        try {
+            sha256.digest(hash, 0, hash.length);
+        } catch (DigestException e) {
+            throw new RuntimeException(e);
+        }
+        return ((hash[0] & 0xFF) << 24) | ((hash[1] & 0xFF) << 16) | ((hash[2] & 0xFF) << 8) | (hash[3] & 0xFF);
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XXH3OpenHFT.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XXH3OpenHFT.java
new file mode 100644
index 00000000..f86648c4
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XXH3OpenHFT.java
@@ -0,0 +1,1136 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+import static java.nio.ByteOrder.BIG_ENDIAN;
+import static java.nio.ByteOrder.LITTLE_ENDIAN;
+import static java.nio.ByteOrder.nativeOrder;
+
+import java.lang.reflect.Field;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import sun.misc.Unsafe;
+
+/**
+ * XXH3 is a non-cryptographic hash function designed for speed and quality. Ported from
+ * <a href="https://github.com/OpenHFT/Zero-Allocation-Hashing/tree/ea">OpenHFT</a>.
+ * Adapted version of XXH3 implementation from <a href="https://github.com/Cyan4973/xxHash">xxHash</a>.
+ * This implementation provides endian-independent hash values, but it's slower on big-endian platforms.
+ */
+public class XXH3OpenHFT {
+    private static final Access<Object> unsafeLE = UnsafeAccess.INSTANCE.byteOrder(null, LITTLE_ENDIAN);
+
+    /*! Pseudorandom secret taken directly from FARSH. */
+    private static final byte[] XXH3_kSecret = {
+        (byte) 0xb8, (byte) 0xfe, (byte) 0x6c, (byte) 0x39, (byte) 0x23, (byte) 0xa4, (byte) 0x4b, (byte) 0xbe,
+                (byte) 0x7c, (byte) 0x01, (byte) 0x81, (byte) 0x2c, (byte) 0xf7, (byte) 0x21, (byte) 0xad, (byte) 0x1c,
+        (byte) 0xde, (byte) 0xd4, (byte) 0x6d, (byte) 0xe9, (byte) 0x83, (byte) 0x90, (byte) 0x97, (byte) 0xdb,
+                (byte) 0x72, (byte) 0x40, (byte) 0xa4, (byte) 0xa4, (byte) 0xb7, (byte) 0xb3, (byte) 0x67, (byte) 0x1f,
+        (byte) 0xcb, (byte) 0x79, (byte) 0xe6, (byte) 0x4e, (byte) 0xcc, (byte) 0xc0, (byte) 0xe5, (byte) 0x78,
+                (byte) 0x82, (byte) 0x5a, (byte) 0xd0, (byte) 0x7d, (byte) 0xcc, (byte) 0xff, (byte) 0x72, (byte) 0x21,
+        (byte) 0xb8, (byte) 0x08, (byte) 0x46, (byte) 0x74, (byte) 0xf7, (byte) 0x43, (byte) 0x24, (byte) 0x8e,
+                (byte) 0xe0, (byte) 0x35, (byte) 0x90, (byte) 0xe6, (byte) 0x81, (byte) 0x3a, (byte) 0x26, (byte) 0x4c,
+        (byte) 0x3c, (byte) 0x28, (byte) 0x52, (byte) 0xbb, (byte) 0x91, (byte) 0xc3, (byte) 0x00, (byte) 0xcb,
+                (byte) 0x88, (byte) 0xd0, (byte) 0x65, (byte) 0x8b, (byte) 0x1b, (byte) 0x53, (byte) 0x2e, (byte) 0xa3,
+        (byte) 0x71, (byte) 0x64, (byte) 0x48, (byte) 0x97, (byte) 0xa2, (byte) 0x0d, (byte) 0xf9, (byte) 0x4e,
+                (byte) 0x38, (byte) 0x19, (byte) 0xef, (byte) 0x46, (byte) 0xa9, (byte) 0xde, (byte) 0xac, (byte) 0xd8,
+        (byte) 0xa8, (byte) 0xfa, (byte) 0x76, (byte) 0x3f, (byte) 0xe3, (byte) 0x9c, (byte) 0x34, (byte) 0x3f,
+                (byte) 0xf9, (byte) 0xdc, (byte) 0xbb, (byte) 0xc7, (byte) 0xc7, (byte) 0x0b, (byte) 0x4f, (byte) 0x1d,
+        (byte) 0x8a, (byte) 0x51, (byte) 0xe0, (byte) 0x4b, (byte) 0xcd, (byte) 0xb4, (byte) 0x59, (byte) 0x31,
+                (byte) 0xc8, (byte) 0x9f, (byte) 0x7e, (byte) 0xc9, (byte) 0xd9, (byte) 0x78, (byte) 0x73, (byte) 0x64,
+        (byte) 0xea, (byte) 0xc5, (byte) 0xac, (byte) 0x83, (byte) 0x34, (byte) 0xd3, (byte) 0xeb, (byte) 0xc3,
+                (byte) 0xc5, (byte) 0x81, (byte) 0xa0, (byte) 0xff, (byte) 0xfa, (byte) 0x13, (byte) 0x63, (byte) 0xeb,
+        (byte) 0x17, (byte) 0x0d, (byte) 0xdd, (byte) 0x51, (byte) 0xb7, (byte) 0xf0, (byte) 0xda, (byte) 0x49,
+                (byte) 0xd3, (byte) 0x16, (byte) 0x55, (byte) 0x26, (byte) 0x29, (byte) 0xd4, (byte) 0x68, (byte) 0x9e,
+        (byte) 0x2b, (byte) 0x16, (byte) 0xbe, (byte) 0x58, (byte) 0x7d, (byte) 0x47, (byte) 0xa1, (byte) 0xfc,
+                (byte) 0x8f, (byte) 0xf8, (byte) 0xb8, (byte) 0xd1, (byte) 0x7a, (byte) 0xd0, (byte) 0x31, (byte) 0xce,
+        (byte) 0x45, (byte) 0xcb, (byte) 0x3a, (byte) 0x8f, (byte) 0x95, (byte) 0x16, (byte) 0x04, (byte) 0x28,
+                (byte) 0xaf, (byte) 0xd7, (byte) 0xfb, (byte) 0xca, (byte) 0xbb, (byte) 0x4b, (byte) 0x40, (byte) 0x7e,
+    };
+
+    // Primes
+    private static final long XXH_PRIME32_1 = 0x9E3779B1L; /*!< 0b10011110001101110111100110110001 */
+    private static final long XXH_PRIME32_2 = 0x85EBCA77L; /*!< 0b10000101111010111100101001110111 */
+    private static final long XXH_PRIME32_3 = 0xC2B2AE3DL; /*!< 0b11000010101100101010111000111101 */
+
+    private static final long XXH_PRIME64_1 =
+            0x9E3779B185EBCA87L; /*!< 0b1001111000110111011110011011000110000101111010111100101010000111 */
+    private static final long XXH_PRIME64_2 =
+            0xC2B2AE3D27D4EB4FL; /*!< 0b1100001010110010101011100011110100100111110101001110101101001111 */
+    private static final long XXH_PRIME64_3 =
+            0x165667B19E3779F9L; /*!< 0b0001011001010110011001111011000110011110001101110111100111111001 */
+    private static final long XXH_PRIME64_4 =
+            0x85EBCA77C2B2AE63L; /*!< 0b1000010111101011110010100111011111000010101100101010111001100011 */
+    private static final long XXH_PRIME64_5 =
+            0x27D4EB2F165667C5L; /*!< 0b0010011111010100111010110010111100010110010101100110011111000101 */
+
+    // only support fixed size secret
+    private static final long nbStripesPerBlock = (192 - 64) / 8;
+    private static final long block_len = 64 * nbStripesPerBlock;
+
+    private static long unsignedLongMulXorFold(final long lhs, final long rhs) {
+        // The Grade School method of multiplication is a hair faster in Java, primarily used here
+        // because the implementation is simpler.
+        final long lhs_l = lhs & 0xFFFFFFFFL;
+        final long lhs_h = lhs >>> 32;
+        final long rhs_l = rhs & 0xFFFFFFFFL;
+        final long rhs_h = rhs >>> 32;
+        final long lo_lo = lhs_l * rhs_l;
+        final long hi_lo = lhs_h * rhs_l;
+        final long lo_hi = lhs_l * rhs_h;
+        final long hi_hi = lhs_h * rhs_h;
+
+        // Add the products together. This will never overflow.
+        final long cross = (lo_lo >>> 32) + (hi_lo & 0xFFFFFFFFL) + lo_hi;
+        final long upper = (hi_lo >>> 32) + (cross >>> 32) + hi_hi;
+        final long lower = (cross << 32) | (lo_lo & 0xFFFFFFFFL);
+        return lower ^ upper;
+    }
+
+    private static long XXH64_avalanche(long h64) {
+        h64 ^= h64 >>> 33;
+        h64 *= XXH_PRIME64_2;
+        h64 ^= h64 >>> 29;
+        h64 *= XXH_PRIME64_3;
+        return h64 ^ (h64 >>> 32);
+    }
+
+    private static long XXH3_avalanche(long h64) {
+        h64 ^= h64 >>> 37;
+        h64 *= 0x165667919E3779F9L;
+        return h64 ^ (h64 >>> 32);
+    }
+
+    private static long XXH3_rrmxmx(long h64, final long length) {
+        h64 ^= Long.rotateLeft(h64, 49) ^ Long.rotateLeft(h64, 24);
+        h64 *= 0x9FB21C651E98DF25L;
+        h64 ^= (h64 >>> 35) + length;
+        h64 *= 0x9FB21C651E98DF25L;
+        return h64 ^ (h64 >>> 28);
+    }
+
+    private static <T> long XXH3_mix16B(
+            final long seed, final T input, final Access<T> access, final long offIn, final long offSec) {
+        final long input_lo = access.i64(input, offIn);
+        final long input_hi = access.i64(input, offIn + 8);
+        return unsignedLongMulXorFold(
+                input_lo ^ (unsafeLE.i64(XXH3_kSecret, offSec) + seed),
+                input_hi ^ (unsafeLE.i64(XXH3_kSecret, offSec + 8) - seed));
+    }
+
+    private static long XXH3_mix2Accs(final long acc_lh, final long acc_rh, final byte[] secret, final long offSec) {
+        return unsignedLongMulXorFold(acc_lh ^ unsafeLE.i64(secret, offSec), acc_rh ^ unsafeLE.i64(secret, offSec + 8));
+    }
+
+    public static long hash64(byte[] bytes, int offset, int length) {
+        return XXH3_64bits_internal(0, XXH3_kSecret, bytes, UnsafeAccess.INSTANCE, offset, length);
+    }
+
+    private static <T> long XXH3_64bits_internal(
+            final long seed,
+            final byte[] secret,
+            final T input,
+            final Access<T> access,
+            final long off,
+            final long length) {
+        if (length <= 16) {
+            // XXH3_len_0to16_64b
+            if (length > 8) {
+                // XXH3_len_9to16_64b
+                final long bitflip1 = (unsafeLE.i64(XXH3_kSecret, 24 + UnsafeAccess.BYTE_BASE)
+                                ^ unsafeLE.i64(XXH3_kSecret, 32 + UnsafeAccess.BYTE_BASE))
+                        + seed;
+                final long bitflip2 = (unsafeLE.i64(XXH3_kSecret, 40 + UnsafeAccess.BYTE_BASE)
+                                ^ unsafeLE.i64(XXH3_kSecret, 48 + UnsafeAccess.BYTE_BASE))
+                        - seed;
+                final long input_lo = access.i64(input, off) ^ bitflip1;
+                final long input_hi = access.i64(input, off + length - 8) ^ bitflip2;
+                final long acc =
+                        length + Long.reverseBytes(input_lo) + input_hi + unsignedLongMulXorFold(input_lo, input_hi);
+                return XXH3_avalanche(acc);
+            }
+            if (length >= 4) {
+                // XXH3_len_4to8_64b
+                long s = seed ^ Long.reverseBytes(seed & 0xFFFFFFFFL);
+                final long input1 = (long) access.i32(input, off); // high int will be shifted
+                final long input2 = access.u32(input, off + length - 4);
+                final long bitflip = (unsafeLE.i64(XXH3_kSecret, 8 + UnsafeAccess.BYTE_BASE)
+                                ^ unsafeLE.i64(XXH3_kSecret, 16 + UnsafeAccess.BYTE_BASE))
+                        - s;
+                final long keyed = (input2 + (input1 << 32)) ^ bitflip;
+                return XXH3_rrmxmx(keyed, length);
+            }
+            if (length != 0) {
+                // XXH3_len_1to3_64b
+                final int c1 = access.u8(input, off + 0);
+                final int c2 = access.i8(input, off + (length >> 1)); // high 3 bytes will be shifted
+                final int c3 = access.u8(input, off + length - 1);
+                final long combined = Primitives.unsignedInt((c1 << 16) | (c2 << 24) | c3 | ((int) length << 8));
+                final long bitflip = Primitives.unsignedInt(unsafeLE.i32(XXH3_kSecret, UnsafeAccess.BYTE_BASE)
+                                ^ unsafeLE.i32(XXH3_kSecret, 4 + UnsafeAccess.BYTE_BASE))
+                        + seed;
+                return XXH64_avalanche(combined ^ bitflip);
+            }
+            return XXH64_avalanche(seed
+                    ^ unsafeLE.i64(XXH3_kSecret, 56 + UnsafeAccess.BYTE_BASE)
+                    ^ unsafeLE.i64(XXH3_kSecret, 64 + UnsafeAccess.BYTE_BASE));
+        }
+        if (length <= 128) {
+            // XXH3_len_17to128_64b
+            long acc = length * XXH_PRIME64_1;
+
+            if (length > 32) {
+                if (length > 64) {
+                    if (length > 96) {
+                        acc += XXH3_mix16B(seed, input, access, off + 48, UnsafeAccess.BYTE_BASE + 96);
+                        acc += XXH3_mix16B(seed, input, access, off + length - 64, UnsafeAccess.BYTE_BASE + 112);
+                    }
+                    acc += XXH3_mix16B(seed, input, access, off + 32, UnsafeAccess.BYTE_BASE + 64);
+                    acc += XXH3_mix16B(seed, input, access, off + length - 48, UnsafeAccess.BYTE_BASE + 80);
+                }
+                acc += XXH3_mix16B(seed, input, access, off + 16, UnsafeAccess.BYTE_BASE + 32);
+                acc += XXH3_mix16B(seed, input, access, off + length - 32, UnsafeAccess.BYTE_BASE + 48);
+            }
+            acc += XXH3_mix16B(seed, input, access, off, UnsafeAccess.BYTE_BASE);
+            acc += XXH3_mix16B(seed, input, access, off + length - 16, UnsafeAccess.BYTE_BASE + 16);
+
+            return XXH3_avalanche(acc);
+        }
+        if (length <= 240) {
+            // XXH3_len_129to240_64b
+            long acc = length * XXH_PRIME64_1;
+            final int nbRounds = (int) length / 16;
+            int i = 0;
+            for (; i < 8; ++i) {
+                acc += XXH3_mix16B(seed, input, access, off + 16 * i, UnsafeAccess.BYTE_BASE + 16 * i);
+            }
+            acc = XXH3_avalanche(acc);
+
+            for (; i < nbRounds; ++i) {
+                acc += XXH3_mix16B(seed, input, access, off + 16 * i, UnsafeAccess.BYTE_BASE + 16 * (i - 8) + 3);
+            }
+
+            /* last bytes */
+            acc += XXH3_mix16B(seed, input, access, off + length - 16, UnsafeAccess.BYTE_BASE + 136 - 17);
+            return XXH3_avalanche(acc);
+        }
+
+        // XXH3_hashLong_64b_internal
+        long acc_0 = XXH_PRIME32_3;
+        long acc_1 = XXH_PRIME64_1;
+        long acc_2 = XXH_PRIME64_2;
+        long acc_3 = XXH_PRIME64_3;
+        long acc_4 = XXH_PRIME64_4;
+        long acc_5 = XXH_PRIME32_2;
+        long acc_6 = XXH_PRIME64_5;
+        long acc_7 = XXH_PRIME32_1;
+
+        // XXH3_hashLong_internal_loop
+        final long nb_blocks = (length - 1) / block_len;
+        for (long n = 0; n < nb_blocks; n++) {
+            // XXH3_accumulate
+            final long offBlock = off + n * block_len;
+            for (long s = 0; s < nbStripesPerBlock; s++) {
+                // XXH3_accumulate_512
+                final long offStripe = offBlock + s * 64;
+                final long offSec = s * 8;
+                {
+                    final long data_val_0 = access.i64(input, offStripe + 8 * 0);
+                    final long data_val_1 = access.i64(input, offStripe + 8 * 1);
+                    final long data_key_0 = data_val_0 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 0);
+                    final long data_key_1 = data_val_1 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 1);
+                    /* swap adjacent lanes */
+                    acc_0 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+                    acc_1 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+                }
+                {
+                    final long data_val_0 = access.i64(input, offStripe + 8 * 2);
+                    final long data_val_1 = access.i64(input, offStripe + 8 * 3);
+                    final long data_key_0 = data_val_0 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 2);
+                    final long data_key_1 = data_val_1 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 3);
+                    /* swap adjacent lanes */
+                    acc_2 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+                    acc_3 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+                }
+                {
+                    final long data_val_0 = access.i64(input, offStripe + 8 * 4);
+                    final long data_val_1 = access.i64(input, offStripe + 8 * 5);
+                    final long data_key_0 = data_val_0 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 4);
+                    final long data_key_1 = data_val_1 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 5);
+                    /* swap adjacent lanes */
+                    acc_4 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+                    acc_5 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+                }
+                {
+                    final long data_val_0 = access.i64(input, offStripe + 8 * 6);
+                    final long data_val_1 = access.i64(input, offStripe + 8 * 7);
+                    final long data_key_0 = data_val_0 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 6);
+                    final long data_key_1 = data_val_1 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 7);
+                    /* swap adjacent lanes */
+                    acc_6 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+                    acc_7 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+                }
+            }
+
+            // XXH3_scrambleAcc_scalar
+            final long offSec = UnsafeAccess.BYTE_BASE + 192 - 64;
+            acc_0 = (acc_0 ^ (acc_0 >>> 47) ^ unsafeLE.i64(secret, offSec + 8 * 0)) * XXH_PRIME32_1;
+            acc_1 = (acc_1 ^ (acc_1 >>> 47) ^ unsafeLE.i64(secret, offSec + 8 * 1)) * XXH_PRIME32_1;
+            acc_2 = (acc_2 ^ (acc_2 >>> 47) ^ unsafeLE.i64(secret, offSec + 8 * 2)) * XXH_PRIME32_1;
+            acc_3 = (acc_3 ^ (acc_3 >>> 47) ^ unsafeLE.i64(secret, offSec + 8 * 3)) * XXH_PRIME32_1;
+            acc_4 = (acc_4 ^ (acc_4 >>> 47) ^ unsafeLE.i64(secret, offSec + 8 * 4)) * XXH_PRIME32_1;
+            acc_5 = (acc_5 ^ (acc_5 >>> 47) ^ unsafeLE.i64(secret, offSec + 8 * 5)) * XXH_PRIME32_1;
+            acc_6 = (acc_6 ^ (acc_6 >>> 47) ^ unsafeLE.i64(secret, offSec + 8 * 6)) * XXH_PRIME32_1;
+            acc_7 = (acc_7 ^ (acc_7 >>> 47) ^ unsafeLE.i64(secret, offSec + 8 * 7)) * XXH_PRIME32_1;
+        }
+
+        /* last partial block */
+        final long nbStripes = ((length - 1) - (block_len * nb_blocks)) / 64;
+        final long offBlock = off + block_len * nb_blocks;
+        for (long s = 0; s < nbStripes; s++) {
+            // XXH3_accumulate_512
+            final long offStripe = offBlock + s * 64;
+            final long offSec = s * 8;
+            {
+                final long data_val_0 = access.i64(input, offStripe + 8 * 0);
+                final long data_val_1 = access.i64(input, offStripe + 8 * 1);
+                final long data_key_0 = data_val_0 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 0);
+                final long data_key_1 = data_val_1 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 1);
+                /* swap adjacent lanes */
+                acc_0 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+                acc_1 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+            }
+            {
+                final long data_val_0 = access.i64(input, offStripe + 8 * 2);
+                final long data_val_1 = access.i64(input, offStripe + 8 * 3);
+                final long data_key_0 = data_val_0 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 2);
+                final long data_key_1 = data_val_1 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 3);
+                /* swap adjacent lanes */
+                acc_2 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+                acc_3 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+            }
+            {
+                final long data_val_0 = access.i64(input, offStripe + 8 * 4);
+                final long data_val_1 = access.i64(input, offStripe + 8 * 5);
+                final long data_key_0 = data_val_0 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 4);
+                final long data_key_1 = data_val_1 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 5);
+                /* swap adjacent lanes */
+                acc_4 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+                acc_5 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+            }
+            {
+                final long data_val_0 = access.i64(input, offStripe + 8 * 6);
+                final long data_val_1 = access.i64(input, offStripe + 8 * 7);
+                final long data_key_0 = data_val_0 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 6);
+                final long data_key_1 = data_val_1 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 7);
+                /* swap adjacent lanes */
+                acc_6 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+                acc_7 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+            }
+        }
+
+        /* last stripe */
+        // XXH3_accumulate_512
+        final long offStripe = off + length - 64;
+        final long offSec = 192 - 64 - 7;
+        {
+            final long data_val_0 = access.i64(input, offStripe + 8 * 0);
+            final long data_val_1 = access.i64(input, offStripe + 8 * 1);
+            final long data_key_0 = data_val_0 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 0);
+            final long data_key_1 = data_val_1 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 1);
+            /* swap adjacent lanes */
+            acc_0 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+            acc_1 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+        }
+        {
+            final long data_val_0 = access.i64(input, offStripe + 8 * 2);
+            final long data_val_1 = access.i64(input, offStripe + 8 * 3);
+            final long data_key_0 = data_val_0 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 2);
+            final long data_key_1 = data_val_1 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 3);
+            /* swap adjacent lanes */
+            acc_2 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+            acc_3 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+        }
+        {
+            final long data_val_0 = access.i64(input, offStripe + 8 * 4);
+            final long data_val_1 = access.i64(input, offStripe + 8 * 5);
+            final long data_key_0 = data_val_0 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 4);
+            final long data_key_1 = data_val_1 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 5);
+            /* swap adjacent lanes */
+            acc_4 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+            acc_5 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+        }
+        {
+            final long data_val_0 = access.i64(input, offStripe + 8 * 6);
+            final long data_val_1 = access.i64(input, offStripe + 8 * 7);
+            final long data_key_0 = data_val_0 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 6);
+            final long data_key_1 = data_val_1 ^ unsafeLE.i64(secret, UnsafeAccess.BYTE_BASE + offSec + 8 * 7);
+            /* swap adjacent lanes */
+            acc_6 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+            acc_7 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+        }
+
+        // XXH3_mergeAccs
+        final long result64 = length * XXH_PRIME64_1
+                + XXH3_mix2Accs(acc_0, acc_1, secret, UnsafeAccess.BYTE_BASE + 11)
+                + XXH3_mix2Accs(acc_2, acc_3, secret, UnsafeAccess.BYTE_BASE + 11 + 16)
+                + XXH3_mix2Accs(acc_4, acc_5, secret, UnsafeAccess.BYTE_BASE + 11 + 16 * 2)
+                + XXH3_mix2Accs(acc_6, acc_7, secret, UnsafeAccess.BYTE_BASE + 11 + 16 * 3);
+
+        return XXH3_avalanche(result64);
+    }
+
+    public abstract static class CharSequenceAccess extends Access<CharSequence> {
+
+        static CharSequenceAccess charSequenceAccess(ByteOrder order) {
+            return order == LITTLE_ENDIAN
+                    ? LittleEndianCharSequenceAccess.INSTANCE
+                    : BigEndianCharSequenceAccess.INSTANCE;
+        }
+
+        static CharSequenceAccess nativeCharSequenceAccess() {
+            return charSequenceAccess(nativeOrder());
+        }
+
+        private static int ix(long offset) {
+            return (int) (offset >> 1);
+        }
+
+        protected static long getLong(
+                CharSequence input,
+                long offset,
+                int char0Off,
+                int char1Off,
+                int char2Off,
+                int char3Off,
+                int char4Off,
+                int delta) {
+            final int base = ix(offset);
+            if (0 == ((int) offset & 1)) {
+                final long char0 = input.charAt(base + char0Off);
+                final long char1 = input.charAt(base + char1Off);
+                final long char2 = input.charAt(base + char2Off);
+                final long char3 = input.charAt(base + char3Off);
+                return char0 | (char1 << 16) | (char2 << 32) | (char3 << 48);
+            } else {
+                final long char0 = input.charAt(base + char0Off + delta) >>> 8;
+                final long char1 = input.charAt(base + char1Off + delta);
+                final long char2 = input.charAt(base + char2Off + delta);
+                final long char3 = input.charAt(base + char3Off + delta);
+                final long char4 = input.charAt(base + char4Off);
+                return char0 | (char1 << 8) | (char2 << 24) | (char3 << 40) | (char4 << 56);
+            }
+        }
+
+        protected static long getUnsignedInt(
+                CharSequence input, long offset, int char0Off, int char1Off, int char2Off, int delta) {
+            final int base = ix(offset);
+            if (0 == ((int) offset & 1)) {
+                final long char0 = input.charAt(base + char0Off);
+                final long char1 = input.charAt(base + char1Off);
+                return char0 | (char1 << 16);
+            } else {
+                final long char0 = input.charAt(base + char0Off + delta) >>> 8;
+                final long char1 = input.charAt(base + char1Off + delta);
+                final long char2 = UnsafeAccess.unsignedByte(input.charAt(base + char2Off));
+                return char0 | (char1 << 8) | (char2 << 24);
+            }
+        }
+
+        protected static char getUnsignedShort(CharSequence input, long offset, int char1Off, int delta) {
+            if (0 == ((int) offset & 1)) {
+                return input.charAt(ix(offset));
+            } else {
+                final int base = ix(offset);
+                final int char0 = input.charAt(base + delta) >>> 8;
+                final int char1 = input.charAt(base + char1Off);
+                return (char) (char0 | (char1 << 8));
+            }
+        }
+
+        protected static int getUnsignedByte(CharSequence input, long offset, int shift) {
+            return UnsafeAccess.unsignedByte(input.charAt(ix(offset)) >> shift);
+        }
+
+        private CharSequenceAccess() {}
+
+        @Override
+        public int getInt(CharSequence input, long offset) {
+            return (int) getUnsignedInt(input, offset);
+        }
+
+        @Override
+        public int getShort(CharSequence input, long offset) {
+            return (int) (short) getUnsignedShort(input, offset);
+        }
+
+        @Override
+        public int getByte(CharSequence input, long offset) {
+            return (int) (byte) getUnsignedByte(input, offset);
+        }
+    }
+
+    static final class Primitives {
+
+        private Primitives() {}
+
+        static final boolean NATIVE_LITTLE_ENDIAN = nativeOrder() == LITTLE_ENDIAN;
+
+        static long unsignedInt(int i) {
+            return i & 0xFFFFFFFFL;
+        }
+
+        static int unsignedShort(int s) {
+            return s & 0xFFFF;
+        }
+
+        static int unsignedByte(int b) {
+            return b & 0xFF;
+        }
+
+        private static final ByteOrderHelper H2LE =
+                NATIVE_LITTLE_ENDIAN ? new ByteOrderHelper() : new ByteOrderHelperReverse();
+        private static final ByteOrderHelper H2BE =
+                NATIVE_LITTLE_ENDIAN ? new ByteOrderHelperReverse() : new ByteOrderHelper();
+
+        static long nativeToLittleEndian(final long v) {
+            return H2LE.adjustByteOrder(v);
+        }
+
+        static int nativeToLittleEndian(final int v) {
+            return H2LE.adjustByteOrder(v);
+        }
+
+        static short nativeToLittleEndian(final short v) {
+            return H2LE.adjustByteOrder(v);
+        }
+
+        static char nativeToLittleEndian(final char v) {
+            return H2LE.adjustByteOrder(v);
+        }
+
+        static long nativeToBigEndian(final long v) {
+            return H2BE.adjustByteOrder(v);
+        }
+
+        static int nativeToBigEndian(final int v) {
+            return H2BE.adjustByteOrder(v);
+        }
+
+        static short nativeToBigEndian(final short v) {
+            return H2BE.adjustByteOrder(v);
+        }
+
+        static char nativeToBigEndian(final char v) {
+            return H2BE.adjustByteOrder(v);
+        }
+
+        private static class ByteOrderHelper {
+            long adjustByteOrder(final long v) {
+                return v;
+            }
+
+            int adjustByteOrder(final int v) {
+                return v;
+            }
+
+            short adjustByteOrder(final short v) {
+                return v;
+            }
+
+            char adjustByteOrder(final char v) {
+                return v;
+            }
+        }
+
+        private static class ByteOrderHelperReverse extends ByteOrderHelper {
+            long adjustByteOrder(final long v) {
+                return Long.reverseBytes(v);
+            }
+
+            int adjustByteOrder(final int v) {
+                return Integer.reverseBytes(v);
+            }
+
+            short adjustByteOrder(final short v) {
+                return Short.reverseBytes(v);
+            }
+
+            char adjustByteOrder(final char v) {
+                return Character.reverseBytes(v);
+            }
+        }
+    }
+
+    private static class LittleEndianCharSequenceAccess extends CharSequenceAccess {
+        private static final CharSequenceAccess INSTANCE = new LittleEndianCharSequenceAccess();
+        private static final Access<CharSequence> INSTANCE_REVERSE = Access.newDefaultReverseAccess(INSTANCE);
+
+        private LittleEndianCharSequenceAccess() {}
+
+        @Override
+        public long getLong(CharSequence input, long offset) {
+            return getLong(input, offset, 0, 1, 2, 3, 4, 0);
+        }
+
+        @Override
+        public long getUnsignedInt(CharSequence input, long offset) {
+            return getUnsignedInt(input, offset, 0, 1, 2, 0);
+        }
+
+        @Override
+        public int getUnsignedShort(CharSequence input, long offset) {
+            return getUnsignedShort(input, offset, 1, 0);
+        }
+
+        @Override
+        public int getUnsignedByte(CharSequence input, long offset) {
+            return getUnsignedByte(input, offset, ((int) offset & 1) << 3);
+        }
+
+        @Override
+        public ByteOrder byteOrder(CharSequence input) {
+            return LITTLE_ENDIAN;
+        }
+
+        @Override
+        protected Access<CharSequence> reverseAccess() {
+            return INSTANCE_REVERSE;
+        }
+    }
+
+    private static class BigEndianCharSequenceAccess extends CharSequenceAccess {
+        private static final CharSequenceAccess INSTANCE = new BigEndianCharSequenceAccess();
+        private static final Access<CharSequence> INSTANCE_REVERSE = Access.newDefaultReverseAccess(INSTANCE);
+
+        private BigEndianCharSequenceAccess() {}
+
+        @Override
+        public long getLong(CharSequence input, long offset) {
+            return getLong(input, offset, 3, 2, 1, 0, 0, 1);
+        }
+
+        @Override
+        public long getUnsignedInt(CharSequence input, long offset) {
+            return getUnsignedInt(input, offset, 1, 0, 0, 1);
+        }
+
+        @Override
+        public int getUnsignedShort(CharSequence input, long offset) {
+            return getUnsignedShort(input, offset, 0, 1);
+        }
+
+        @Override
+        public int getUnsignedByte(CharSequence input, long offset) {
+            return getUnsignedByte(input, offset, (((int) offset & 1) ^ 1) << 3);
+        }
+
+        @Override
+        public ByteOrder byteOrder(CharSequence input) {
+            return BIG_ENDIAN;
+        }
+
+        @Override
+        protected Access<CharSequence> reverseAccess() {
+            return INSTANCE_REVERSE;
+        }
+    }
+
+    private abstract static class Access<T> {
+
+        /**
+         * Returns the {@code Access} delegating {@code getXXX(input, offset)} methods to {@code
+         * sun.misc.Unsafe.getXXX(input, offset)}.
+         *
+         * <p>Usage example: <pre>{@code
+         * class Pair {
+         *     long first, second;
+         *
+         *     static final long pairDataOffset =
+         *         theUnsafe.objectFieldOffset(Pair.class.getDeclaredField("first"));
+         *
+         *     static long hashPair(Pair pair, LongHashFunction hashFunction) {
+         *         return hashFunction.hash(pair, Access.unsafe(), pairDataOffset, 16L);
+         *     }
+         * }}</pre>
+         *
+         * @param <T> the type of objects to access
+         * @return the unsafe memory {@code Access}
+         */
+        @SuppressWarnings("unchecked")
+        public static <T> Access<T> unsafe() {
+            return (Access<T>) UnsafeAccess.INSTANCE;
+        }
+
+        /**
+         * Returns the {@code Access} to any {@link ByteBuffer}.
+         *
+         * @return the {@code Access} to {@link ByteBuffer}s
+         */
+        public static Access<ByteBuffer> toByteBuffer() {
+            return ByteBufferAccess.INSTANCE;
+        }
+
+        /**
+         * Returns the {@code Access} to {@link CharSequence}s backed by {@linkplain
+         * ByteOrder#nativeOrder() native} {@code char} reads, typically from {@code char[]} array.
+         *
+         * <p>Usage example:<pre>{@code
+         * static long hashStringBuffer(StringBuffer buffer, LongHashFunction hashFunction) {
+         *     return hashFunction.hash(buffer, Access.toNativeCharSequence(),
+         *         // * 2L because length is passed in bytes, not chars
+         *         0L, buffer.length() * 2L);
+         * }}</pre>
+         *
+         * <p>This method is a shortcut for {@code Access.toCharSequence(ByteOrder.nativeOrder())}.
+         *
+         * @param <T> the {@code CharSequence} subtype (backed by native {@code char reads}) to access
+         * @return the {@code Access} to {@link CharSequence}s backed by native {@code char} reads
+         * @see #toCharSequence(ByteOrder)
+         */
+        @SuppressWarnings("unchecked")
+        public static <T extends CharSequence> Access<T> toNativeCharSequence() {
+            return (Access<T>) CharSequenceAccess.nativeCharSequenceAccess();
+        }
+
+        /**
+         * Returns the {@code Access} to {@link CharSequence}s backed by {@code char} reads made in
+         * the specified byte order.
+         *
+         * <p>Usage example:<pre>{@code
+         * static long hashCharBuffer(CharBuffer buffer, LongHashFunction hashFunction) {
+         *     return hashFunction.hash(buffer, Access.toCharSequence(buffer.order()),
+         *         // * 2L because length is passed in bytes, not chars
+         *         0L, buffer.length() * 2L);
+         * }}</pre>
+         *
+         * @param backingOrder the byte order of {@code char} reads backing
+         * {@code CharSequences} to access
+         * @return the {@code Access} to {@link CharSequence}s backed by {@code char} reads made in
+         * the specified byte order
+         * @param <T> the {@code CharSequence} subtype to access
+         * @see #toNativeCharSequence()
+         */
+        @SuppressWarnings("unchecked")
+        public static <T extends CharSequence> Access<T> toCharSequence(ByteOrder backingOrder) {
+            return (Access<T>) CharSequenceAccess.charSequenceAccess(backingOrder);
+        }
+
+        /**
+         * Constructor for use in subclasses.
+         */
+        protected Access() {}
+
+        /**
+         * Reads {@code [offset, offset + 7]} bytes of the byte sequence represented by the given
+         * {@code input} as a single {@code long} value.
+         *
+         * @param input the object to access
+         * @param offset offset to the first byte to read within the byte sequence represented
+         * by the given object
+         * @return eight bytes as a {@code long} value, in {@linkplain #byteOrder(Object) the expected
+         * order}
+         */
+        public long getLong(T input, long offset) {
+            if (byteOrder(input) == LITTLE_ENDIAN) {
+                return getUnsignedInt(input, offset) | (getUnsignedInt(input, offset + 4L) << 32);
+            } else {
+                return getUnsignedInt(input, offset + 4L) | (getUnsignedInt(input, offset) << 32);
+            }
+        }
+
+        /**
+         * Shortcut for {@code getInt(input, offset) & 0xFFFFFFFFL}. Could be implemented more
+         * efficiently.
+         *
+         * @param input the object to access
+         * @param offset offset to the first byte to read within the byte sequence represented
+         * by the given object
+         * @return four bytes as an unsigned int value, in {@linkplain #byteOrder(Object) the expected
+         * order}
+         */
+        public long getUnsignedInt(T input, long offset) {
+            return ((long) getInt(input, offset)) & 0xFFFFFFFFL;
+        }
+
+        /**
+         * Reads {@code [offset, offset + 3]} bytes of the byte sequence represented by the given
+         * {@code input} as a single {@code int} value.
+         *
+         * @param input the object to access
+         * @param offset offset to the first byte to read within the byte sequence represented
+         * by the given object
+         * @return four bytes as an {@code int} value, in {@linkplain #byteOrder(Object) the expected
+         * order}
+         */
+        public int getInt(T input, long offset) {
+            if (byteOrder(input) == LITTLE_ENDIAN) {
+                return getUnsignedShort(input, offset) | (getUnsignedShort(input, offset + 2L) << 16);
+            } else {
+                return getUnsignedShort(input, offset + 2L) | (getUnsignedShort(input, offset) << 16);
+            }
+        }
+
+        /**
+         * Shortcut for {@code getShort(input, offset) & 0xFFFF}. Could be implemented more
+         * efficiently.
+         *
+         * @param input the object to access
+         * @param offset offset to the first byte to read within the byte sequence represented
+         * by the given object
+         * @return two bytes as an unsigned short value, in {@linkplain #byteOrder(Object) the expected
+         * order}
+         */
+        public int getUnsignedShort(T input, long offset) {
+            if (byteOrder(input) == LITTLE_ENDIAN) {
+                return getUnsignedByte(input, offset) | (getUnsignedByte(input, offset + 1L) << 8);
+            } else {
+                return getUnsignedByte(input, offset + 1L) | (getUnsignedByte(input, offset) << 8);
+            }
+        }
+
+        /**
+         * Reads {@code [offset, offset + 1]} bytes of the byte sequence represented by the given
+         * {@code input} as a single {@code short} value, returned widened to {@code int}.
+         *
+         * @param input the object to access
+         * @param offset offset to the first byte to read within the byte sequence represented
+         * by the given object
+         * @return two bytes as a {@code short} value, in {@linkplain #byteOrder(Object) the expected
+         * order}, widened to {@code int}
+         */
+        public int getShort(T input, long offset) {
+            return (int) (short) getUnsignedShort(input, offset);
+        }
+
+        /**
+         * Shortcut for {@code getByte(input, offset) & 0xFF}. Could be implemented more efficiently.
+         *
+         * @param input the object to access
+         * @param offset offset to the byte to read within the byte sequence represented
+         * by the given object
+         * @return a byte by the given {@code offset}, interpreted as unsigned
+         */
+        public int getUnsignedByte(T input, long offset) {
+            return getByte(input, offset) & 0xFF;
+        }
+
+        /**
+         * Reads a single byte at the given {@code offset} in the byte sequence represented by the given
+         * {@code input}, returned widened to {@code int}.
+         *
+         * @param input the object to access
+         * @param offset offset to the byte to read within the byte sequence represented
+         * by the given object
+         * @return a byte by the given {@code offset}, widened to {@code int}
+         */
+        public abstract int getByte(T input, long offset);
+
+        // short names
+        public long i64(final T input, final long offset) {
+            return getLong(input, offset);
+        }
+
+        public long u32(final T input, final long offset) {
+            return getUnsignedInt(input, offset);
+        }
+
+        public int i32(final T input, final long offset) {
+            return getInt(input, offset);
+        }
+
+        public int u16(final T input, final long offset) {
+            return getUnsignedShort(input, offset);
+        }
+
+        public int i16(final T input, final long offset) {
+            return getShort(input, offset);
+        }
+
+        public int u8(final T input, final long offset) {
+            return getUnsignedByte(input, offset);
+        }
+
+        public int i8(final T input, final long offset) {
+            return getByte(input, offset);
+        }
+
+        /**
+         * The byte order in which all multi-byte {@code getXXX()} reads from the given {@code input}
+         * are performed.
+         *
+         * @param input the accessed object
+         * @return the byte order of all multi-byte reads from the given {@code input}
+         */
+        public abstract ByteOrder byteOrder(T input);
+
+        /**
+         * Get {@code this} or the reversed access object for reading the input as fixed
+         * byte order of {@code byteOrder}.
+         *
+         * @param input the accessed object
+         * @param byteOrder the byte order to be used for reading the {@code input}
+         * @return a {@code Access} object which will read the {@code input} with the
+         * byte order of {@code byteOrder}.
+         */
+        public Access<T> byteOrder(final T input, final ByteOrder byteOrder) {
+            return byteOrder(input) == byteOrder ? this : reverseAccess();
+        }
+
+        /**
+         * Get the {@code Access} object with a different byte order. This method should
+         * always return a fixed reference.
+         */
+        protected abstract Access<T> reverseAccess();
+
+        /**
+         * Get or create the reverse byte order {@code Access} object for {@code access}.
+         */
+        static <T> Access<T> newDefaultReverseAccess(final Access<T> access) {
+            return access instanceof ReverseAccess ? access.reverseAccess() : new ReverseAccess<T>(access);
+        }
+
+        /**
+         * The default reverse byte order delegating {@code Access} class.
+         */
+        private static class ReverseAccess<T> extends Access<T> {
+            final Access<T> access;
+
+            private ReverseAccess(final Access<T> access) {
+                this.access = access;
+            }
+
+            @Override
+            public long getLong(final T input, final long offset) {
+                return Long.reverseBytes(access.getLong(input, offset));
+            }
+
+            @Override
+            public long getUnsignedInt(final T input, final long offset) {
+                return Long.reverseBytes(access.getUnsignedInt(input, offset)) >>> 32;
+            }
+
+            @Override
+            public int getInt(final T input, final long offset) {
+                return Integer.reverseBytes(access.getInt(input, offset));
+            }
+
+            @Override
+            public int getUnsignedShort(final T input, final long offset) {
+                return Integer.reverseBytes(access.getUnsignedShort(input, offset)) >>> 16;
+            }
+
+            @Override
+            public int getShort(final T input, final long offset) {
+                return Integer.reverseBytes(access.getShort(input, offset)) >> 16;
+            }
+
+            @Override
+            public int getUnsignedByte(final T input, final long offset) {
+                return access.getUnsignedByte(input, offset);
+            }
+
+            @Override
+            public int getByte(final T input, final long offset) {
+                return access.getByte(input, offset);
+            }
+
+            @Override
+            public ByteOrder byteOrder(final T input) {
+                return LITTLE_ENDIAN == access.byteOrder(input) ? BIG_ENDIAN : LITTLE_ENDIAN;
+            }
+
+            @Override
+            protected Access<T> reverseAccess() {
+                return access;
+            }
+        }
+    }
+
+    private static class UnsafeAccess extends Access<Object> {
+        static final UnsafeAccess INSTANCE;
+        private static final Access<Object> INSTANCE_NON_NATIVE;
+        static final boolean NATIVE_LITTLE_ENDIAN = nativeOrder() == LITTLE_ENDIAN;
+
+        // for test only
+        static final UnsafeAccess OLD_INSTANCE =
+                NATIVE_LITTLE_ENDIAN ? new OldUnsafeAccessLittleEndian() : new OldUnsafeAccessBigEndian();
+
+        static final Unsafe UNSAFE;
+
+        static final long BOOLEAN_BASE;
+        static final long BYTE_BASE;
+        static final long CHAR_BASE;
+        static final long SHORT_BASE;
+        static final long INT_BASE;
+        static final long LONG_BASE;
+
+        static final byte TRUE_BYTE_VALUE;
+        static final byte FALSE_BYTE_VALUE;
+
+        static {
+            try {
+                Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
+                theUnsafe.setAccessible(true);
+                UNSAFE = (Unsafe) theUnsafe.get(null);
+
+                BOOLEAN_BASE = UNSAFE.arrayBaseOffset(boolean[].class);
+                BYTE_BASE = UNSAFE.arrayBaseOffset(byte[].class);
+                CHAR_BASE = UNSAFE.arrayBaseOffset(char[].class);
+                SHORT_BASE = UNSAFE.arrayBaseOffset(short[].class);
+                INT_BASE = UNSAFE.arrayBaseOffset(int[].class);
+                LONG_BASE = UNSAFE.arrayBaseOffset(long[].class);
+
+                TRUE_BYTE_VALUE = (byte) UNSAFE.getInt(new boolean[] {true, true, true, true}, BOOLEAN_BASE);
+                FALSE_BYTE_VALUE = (byte) UNSAFE.getInt(new boolean[] {false, false, false, false}, BOOLEAN_BASE);
+            } catch (final Exception e) {
+                throw new AssertionError(e);
+            }
+
+            boolean hasGetByte = true;
+            try {
+                UNSAFE.getByte(new byte[1], BYTE_BASE);
+            } catch (final Throwable ignore) {
+                // Unsafe in pre-Nougat Android does not have getByte(), fall back to workround
+                hasGetByte = false;
+            }
+
+            INSTANCE = hasGetByte ? new UnsafeAccess() : OLD_INSTANCE;
+            INSTANCE_NON_NATIVE = Access.newDefaultReverseAccess(INSTANCE);
+        }
+
+        private UnsafeAccess() {}
+
+        static long unsignedInt(int i) {
+            return i & 0xFFFFFFFFL;
+        }
+
+        static int unsignedShort(int s) {
+            return s & 0xFFFF;
+        }
+
+        static int unsignedByte(int b) {
+            return b & 0xFF;
+        }
+
+        @Override
+        public long getLong(Object input, long offset) {
+            return UNSAFE.getLong(input, offset);
+        }
+
+        @Override
+        public long getUnsignedInt(Object input, long offset) {
+            return unsignedInt(getInt(input, offset));
+        }
+
+        @Override
+        public int getInt(Object input, long offset) {
+            return UNSAFE.getInt(input, offset);
+        }
+
+        @Override
+        public int getUnsignedShort(Object input, long offset) {
+            return unsignedShort(getShort(input, offset));
+        }
+
+        @Override
+        public int getShort(Object input, long offset) {
+            return UNSAFE.getShort(input, offset);
+        }
+
+        @Override
+        public int getUnsignedByte(Object input, long offset) {
+            return unsignedByte(getByte(input, offset));
+        }
+
+        @Override
+        public int getByte(Object input, long offset) {
+            return UNSAFE.getByte(input, offset);
+        }
+
+        @Override
+        public ByteOrder byteOrder(Object input) {
+            return nativeOrder();
+        }
+
+        @Override
+        protected Access<Object> reverseAccess() {
+            return INSTANCE_NON_NATIVE;
+        }
+
+        private static class OldUnsafeAccessLittleEndian extends UnsafeAccess {
+            @Override
+            public int getShort(final Object input, final long offset) {
+                return UNSAFE.getInt(input, offset - 2) >> 16;
+            }
+
+            @Override
+            public int getByte(final Object input, final long offset) {
+                return UNSAFE.getInt(input, offset - 3) >> 24;
+            }
+        }
+
+        private static class OldUnsafeAccessBigEndian extends UnsafeAccess {
+            @Override
+            public int getShort(final Object input, final long offset) {
+                return (int) (short) UNSAFE.getInt(input, offset - 2);
+            }
+
+            @Override
+            public int getByte(final Object input, final long offset) {
+                return (int) (byte) UNSAFE.getInt(input, offset - 3);
+            }
+        }
+    }
+
+    public static final class ByteBufferAccess extends Access<ByteBuffer> {
+        public static final ByteBufferAccess INSTANCE = new ByteBufferAccess();
+        private static final Access<ByteBuffer> INSTANCE_REVERSE = Access.newDefaultReverseAccess(INSTANCE);
+
+        private ByteBufferAccess() {}
+
+        @Override
+        public long getLong(ByteBuffer input, long offset) {
+            return input.getLong((int) offset);
+        }
+
+        @Override
+        public long getUnsignedInt(ByteBuffer input, long offset) {
+            return UnsafeAccess.unsignedInt(getInt(input, offset));
+        }
+
+        @Override
+        public int getInt(ByteBuffer input, long offset) {
+            return input.getInt((int) offset);
+        }
+
+        @Override
+        public int getUnsignedShort(ByteBuffer input, long offset) {
+            return UnsafeAccess.unsignedShort(getShort(input, offset));
+        }
+
+        @Override
+        public int getShort(ByteBuffer input, long offset) {
+            return input.getShort((int) offset);
+        }
+
+        @Override
+        public int getUnsignedByte(ByteBuffer input, long offset) {
+            return UnsafeAccess.unsignedByte(getByte(input, offset));
+        }
+
+        @Override
+        public int getByte(ByteBuffer input, long offset) {
+            return input.get((int) offset);
+        }
+
+        @Override
+        public ByteOrder byteOrder(ByteBuffer input) {
+            return input.order();
+        }
+
+        @Override
+        public Access<ByteBuffer> reverseAccess() {
+            return INSTANCE_REVERSE;
+        }
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XXH3OpenHFT2.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XXH3OpenHFT2.java
new file mode 100644
index 00000000..be34b5dd
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XXH3OpenHFT2.java
@@ -0,0 +1,425 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+
+/**
+ * XXH3 is a non-cryptographic hash function designed for speed and quality. Ported from
+ * <a href="https://github.com/OpenHFT/Zero-Allocation-Hashing/tree/ea">OpenHFT</a> with dependencies removed and
+ * cleaned up to be minimal.
+ * <p>
+ * Adapted version of XXH3 implementation from <a href="https://github.com/Cyan4973/xxHash">xxHash</a>.
+ * This implementation provides endian-independent hash values, but it's slower on big-endian platforms.
+ * </p>
+ */
+@SuppressWarnings("DuplicatedCode")
+public final class XXH3OpenHFT2 {
+    private static final long SEED = 0L; // Default seed value
+    private static final VarHandle LONG_HANDLE =
+            MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.LITTLE_ENDIAN);
+    /*! Pseudorandom secret taken directly from FARSH. */
+    private static final byte[] XXH3_kSecret = {
+        (byte) 0xb8, (byte) 0xfe, (byte) 0x6c, (byte) 0x39, (byte) 0x23, (byte) 0xa4, (byte) 0x4b, (byte) 0xbe,
+                (byte) 0x7c, (byte) 0x01, (byte) 0x81, (byte) 0x2c, (byte) 0xf7, (byte) 0x21, (byte) 0xad, (byte) 0x1c,
+        (byte) 0xde, (byte) 0xd4, (byte) 0x6d, (byte) 0xe9, (byte) 0x83, (byte) 0x90, (byte) 0x97, (byte) 0xdb,
+                (byte) 0x72, (byte) 0x40, (byte) 0xa4, (byte) 0xa4, (byte) 0xb7, (byte) 0xb3, (byte) 0x67, (byte) 0x1f,
+        (byte) 0xcb, (byte) 0x79, (byte) 0xe6, (byte) 0x4e, (byte) 0xcc, (byte) 0xc0, (byte) 0xe5, (byte) 0x78,
+                (byte) 0x82, (byte) 0x5a, (byte) 0xd0, (byte) 0x7d, (byte) 0xcc, (byte) 0xff, (byte) 0x72, (byte) 0x21,
+        (byte) 0xb8, (byte) 0x08, (byte) 0x46, (byte) 0x74, (byte) 0xf7, (byte) 0x43, (byte) 0x24, (byte) 0x8e,
+                (byte) 0xe0, (byte) 0x35, (byte) 0x90, (byte) 0xe6, (byte) 0x81, (byte) 0x3a, (byte) 0x26, (byte) 0x4c,
+        (byte) 0x3c, (byte) 0x28, (byte) 0x52, (byte) 0xbb, (byte) 0x91, (byte) 0xc3, (byte) 0x00, (byte) 0xcb,
+                (byte) 0x88, (byte) 0xd0, (byte) 0x65, (byte) 0x8b, (byte) 0x1b, (byte) 0x53, (byte) 0x2e, (byte) 0xa3,
+        (byte) 0x71, (byte) 0x64, (byte) 0x48, (byte) 0x97, (byte) 0xa2, (byte) 0x0d, (byte) 0xf9, (byte) 0x4e,
+                (byte) 0x38, (byte) 0x19, (byte) 0xef, (byte) 0x46, (byte) 0xa9, (byte) 0xde, (byte) 0xac, (byte) 0xd8,
+        (byte) 0xa8, (byte) 0xfa, (byte) 0x76, (byte) 0x3f, (byte) 0xe3, (byte) 0x9c, (byte) 0x34, (byte) 0x3f,
+                (byte) 0xf9, (byte) 0xdc, (byte) 0xbb, (byte) 0xc7, (byte) 0xc7, (byte) 0x0b, (byte) 0x4f, (byte) 0x1d,
+        (byte) 0x8a, (byte) 0x51, (byte) 0xe0, (byte) 0x4b, (byte) 0xcd, (byte) 0xb4, (byte) 0x59, (byte) 0x31,
+                (byte) 0xc8, (byte) 0x9f, (byte) 0x7e, (byte) 0xc9, (byte) 0xd9, (byte) 0x78, (byte) 0x73, (byte) 0x64,
+        (byte) 0xea, (byte) 0xc5, (byte) 0xac, (byte) 0x83, (byte) 0x34, (byte) 0xd3, (byte) 0xeb, (byte) 0xc3,
+                (byte) 0xc5, (byte) 0x81, (byte) 0xa0, (byte) 0xff, (byte) 0xfa, (byte) 0x13, (byte) 0x63, (byte) 0xeb,
+        (byte) 0x17, (byte) 0x0d, (byte) 0xdd, (byte) 0x51, (byte) 0xb7, (byte) 0xf0, (byte) 0xda, (byte) 0x49,
+                (byte) 0xd3, (byte) 0x16, (byte) 0x55, (byte) 0x26, (byte) 0x29, (byte) 0xd4, (byte) 0x68, (byte) 0x9e,
+        (byte) 0x2b, (byte) 0x16, (byte) 0xbe, (byte) 0x58, (byte) 0x7d, (byte) 0x47, (byte) 0xa1, (byte) 0xfc,
+                (byte) 0x8f, (byte) 0xf8, (byte) 0xb8, (byte) 0xd1, (byte) 0x7a, (byte) 0xd0, (byte) 0x31, (byte) 0xce,
+        (byte) 0x45, (byte) 0xcb, (byte) 0x3a, (byte) 0x8f, (byte) 0x95, (byte) 0x16, (byte) 0x04, (byte) 0x28,
+                (byte) 0xaf, (byte) 0xd7, (byte) 0xfb, (byte) 0xca, (byte) 0xbb, (byte) 0x4b, (byte) 0x40, (byte) 0x7e,
+    };
+    // Primes
+    private static final long XXH_PRIME32_1 = 0x9E3779B1L; /*!< 0b10011110001101110111100110110001 */
+    private static final long XXH_PRIME32_2 = 0x85EBCA77L; /*!< 0b10000101111010111100101001110111 */
+    private static final long XXH_PRIME32_3 = 0xC2B2AE3DL; /*!< 0b11000010101100101010111000111101 */
+    private static final long XXH_PRIME64_1 =
+            0x9E3779B185EBCA87L; /*!< 0b1001111000110111011110011011000110000101111010111100101010000111 */
+    private static final long XXH_PRIME64_2 =
+            0xC2B2AE3D27D4EB4FL; /*!< 0b1100001010110010101011100011110100100111110101001110101101001111 */
+    private static final long XXH_PRIME64_3 =
+            0x165667B19E3779F9L; /*!< 0b0001011001010110011001111011000110011110001101110111100111111001 */
+    private static final long XXH_PRIME64_4 =
+            0x85EBCA77C2B2AE63L; /*!< 0b1000010111101011110010100111011111000010101100101010111001100011 */
+    private static final long XXH_PRIME64_5 =
+            0x27D4EB2F165667C5L; /*!< 0b0010011111010100111010110010111100010110010101100110011111000101 */
+    // only support fixed size secret
+    private static final long nbStripesPerBlock = (192 - 64) / 8;
+    private static final long block_len = 64 * nbStripesPerBlock;
+
+    private static long unsignedLongMulXorFold(final long lhs, final long rhs) {
+        // The Grade School method of multiplication is a hair faster in Java, primarily used here
+        // because the implementation is simpler.
+        final long lhs_l = lhs & 0xFFFFFFFFL;
+        final long lhs_h = lhs >>> 32;
+        final long rhs_l = rhs & 0xFFFFFFFFL;
+        final long rhs_h = rhs >>> 32;
+        final long lo_lo = lhs_l * rhs_l;
+        final long hi_lo = lhs_h * rhs_l;
+        final long lo_hi = lhs_l * rhs_h;
+        final long hi_hi = lhs_h * rhs_h;
+
+        // Add the products together. This will never overflow.
+        final long cross = (lo_lo >>> 32) + (hi_lo & 0xFFFFFFFFL) + lo_hi;
+        final long upper = (hi_lo >>> 32) + (cross >>> 32) + hi_hi;
+        final long lower = (cross << 32) | (lo_lo & 0xFFFFFFFFL);
+        return lower ^ upper;
+    }
+
+    private static long XXH64_avalanche(long h64) {
+        h64 ^= h64 >>> 33;
+        h64 *= XXH_PRIME64_2;
+        h64 ^= h64 >>> 29;
+        h64 *= XXH_PRIME64_3;
+        return h64 ^ (h64 >>> 32);
+    }
+
+    private static long XXH3_avalanche(long h64) {
+        h64 ^= h64 >>> 37;
+        h64 *= 0x165667919E3779F9L;
+        return h64 ^ (h64 >>> 32);
+    }
+
+    private static long XXH3_rrmxmx(long h64, final long length) {
+        h64 ^= Long.rotateLeft(h64, 49) ^ Long.rotateLeft(h64, 24);
+        h64 *= 0x9FB21C651E98DF25L;
+        h64 ^= (h64 >>> 35) + length;
+        h64 *= 0x9FB21C651E98DF25L;
+        return h64 ^ (h64 >>> 28);
+    }
+
+    private static long XXH3_mix16B(final byte[] input, final int offIn, final int offSec) {
+        final long input_lo = i64(input, offIn);
+        final long input_hi = i64(input, offIn + 8);
+        return unsignedLongMulXorFold(
+                input_lo ^ (i64(XXH3_kSecret, offSec) + SEED), input_hi ^ (i64(XXH3_kSecret, offSec + 8) - SEED));
+    }
+
+    private static long XXH3_mix2Accs(final long acc_lh, final long acc_rh, final long offSec) {
+        return unsignedLongMulXorFold(acc_lh ^ i64(XXH3_kSecret, offSec), acc_rh ^ i64(XXH3_kSecret, offSec + 8));
+    }
+
+    public static long hash64(final byte[] input, final int off, final int length) {
+        if (length <= 16) {
+            // XXH3_len_0to16_64b
+            if (length > 8) {
+                // XXH3_len_9to16_64b
+                final long bitflip1 = (i64(XXH3_kSecret, 24) ^ i64(XXH3_kSecret, 32)) + SEED;
+                final long bitflip2 = (i64(XXH3_kSecret, 40) ^ i64(XXH3_kSecret, 48)) - SEED;
+                final long input_lo = i64(input, off) ^ bitflip1;
+                final long input_hi = i64(input, off + length - 8) ^ bitflip2;
+                final long acc =
+                        length + Long.reverseBytes(input_lo) + input_hi + unsignedLongMulXorFold(input_lo, input_hi);
+                return XXH3_avalanche(acc);
+            }
+            if (length >= 4) {
+                // XXH3_len_4to8_64b
+                long s = SEED ^ Long.reverseBytes(SEED & 0xFFFFFFFFL);
+                final long input1 = i32(input, off); // high int will be shifted
+                final long input2 = u32(input, off + length - 4);
+                final long bitflip = (i64(XXH3_kSecret, 8) ^ i64(XXH3_kSecret, 16)) - s;
+                final long keyed = (input2 + (input1 << 32)) ^ bitflip;
+                return XXH3_rrmxmx(keyed, length);
+            }
+            if (length != 0) {
+                // XXH3_len_1to3_64b
+                final int c1 = u8(input, off);
+                final int c2 = i8(input, off + (length >> 1)); // high 3 bytes will be shifted
+                final int c3 = u8(input, off + length - 1);
+                final long combined = unsignedInt((c1 << 16) | (c2 << 24) | c3 | (length << 8));
+                final long bitflip = unsignedInt(i32(XXH3_kSecret, 0) ^ i32(XXH3_kSecret, 4)) + SEED;
+                return XXH64_avalanche(combined ^ bitflip);
+            }
+            return XXH64_avalanche(SEED ^ i64(XXH3_kSecret, 56) ^ i64(XXH3_kSecret, 64));
+        }
+        if (length <= 128) {
+            // XXH3_len_17to128_64b
+            long acc = length * XXH_PRIME64_1;
+
+            if (length > 32) {
+                if (length > 64) {
+                    if (length > 96) {
+                        acc += XXH3_mix16B(input, off + 48, 96);
+                        acc += XXH3_mix16B(input, off + length - 64, 112);
+                    }
+                    acc += XXH3_mix16B(input, off + 32, 64);
+                    acc += XXH3_mix16B(input, off + length - 48, 80);
+                }
+                acc += XXH3_mix16B(input, off + 16, 32);
+                acc += XXH3_mix16B(input, off + length - 32, 48);
+            }
+            acc += XXH3_mix16B(input, off, 0);
+            acc += XXH3_mix16B(input, off + length - 16, 16);
+
+            return XXH3_avalanche(acc);
+        }
+        if (length <= 240) {
+            // XXH3_len_129to240_64b
+            long acc = length * XXH_PRIME64_1;
+            final int nbRounds = length / 16;
+            int i = 0;
+            for (; i < 8; ++i) {
+                acc += XXH3_mix16B(input, off + 16 * i, 16 * i);
+            }
+            acc = XXH3_avalanche(acc);
+
+            for (; i < nbRounds; ++i) {
+                acc += XXH3_mix16B(input, off + 16 * i, 16 * (i - 8) + 3);
+            }
+
+            /* last bytes */
+            acc += XXH3_mix16B(input, off + length - 16, 136 - 17);
+            return XXH3_avalanche(acc);
+        }
+
+        // XXH3_hashLong_64b_internal
+        long acc_0 = XXH_PRIME32_3;
+        long acc_1 = XXH_PRIME64_1;
+        long acc_2 = XXH_PRIME64_2;
+        long acc_3 = XXH_PRIME64_3;
+        long acc_4 = XXH_PRIME64_4;
+        long acc_5 = XXH_PRIME32_2;
+        long acc_6 = XXH_PRIME64_5;
+        long acc_7 = XXH_PRIME32_1;
+
+        // XXH3_hashLong_internal_loop
+        final long nb_blocks = (length - 1) / block_len;
+        for (long n = 0; n < nb_blocks; n++) {
+            // XXH3_accumulate
+            final long offBlock = off + n * block_len;
+            for (long s = 0; s < nbStripesPerBlock; s++) {
+                // XXH3_accumulate_512
+                final long offStripe = offBlock + s * 64;
+                final long offSec = s * 8;
+                {
+                    final long data_val_0 = i64(input, offStripe);
+                    final long data_val_1 = i64(input, offStripe + 8);
+                    final long data_key_0 = data_val_0 ^ i64(XXH3_kSecret, offSec);
+                    final long data_key_1 = data_val_1 ^ i64(XXH3_kSecret, offSec + 8);
+                    /* swap adjacent lanes */
+                    acc_0 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+                    acc_1 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+                }
+                {
+                    final long data_val_0 = i64(input, offStripe + 8 * 2);
+                    final long data_val_1 = i64(input, offStripe + 8 * 3);
+                    final long data_key_0 = data_val_0 ^ i64(XXH3_kSecret, offSec + 8 * 2);
+                    final long data_key_1 = data_val_1 ^ i64(XXH3_kSecret, offSec + 8 * 3);
+                    /* swap adjacent lanes */
+                    acc_2 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+                    acc_3 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+                }
+                {
+                    final long data_val_0 = i64(input, offStripe + 8 * 4);
+                    final long data_val_1 = i64(input, offStripe + 8 * 5);
+                    final long data_key_0 = data_val_0 ^ i64(XXH3_kSecret, offSec + 8 * 4);
+                    final long data_key_1 = data_val_1 ^ i64(XXH3_kSecret, offSec + 8 * 5);
+                    /* swap adjacent lanes */
+                    acc_4 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+                    acc_5 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+                }
+                {
+                    final long data_val_0 = i64(input, offStripe + 8 * 6);
+                    final long data_val_1 = i64(input, offStripe + 8 * 7);
+                    final long data_key_0 = data_val_0 ^ i64(XXH3_kSecret, offSec + 8 * 6);
+                    final long data_key_1 = data_val_1 ^ i64(XXH3_kSecret, offSec + 8 * 7);
+                    /* swap adjacent lanes */
+                    acc_6 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+                    acc_7 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+                }
+            }
+
+            // XXH3_scrambleAcc_scalar
+            final long offSec = 192 - 64;
+            acc_0 = (acc_0 ^ (acc_0 >>> 47) ^ i64(XXH3_kSecret, offSec)) * XXH_PRIME32_1;
+            acc_1 = (acc_1 ^ (acc_1 >>> 47) ^ i64(XXH3_kSecret, offSec + 8)) * XXH_PRIME32_1;
+            acc_2 = (acc_2 ^ (acc_2 >>> 47) ^ i64(XXH3_kSecret, offSec + 8 * 2)) * XXH_PRIME32_1;
+            acc_3 = (acc_3 ^ (acc_3 >>> 47) ^ i64(XXH3_kSecret, offSec + 8 * 3)) * XXH_PRIME32_1;
+            acc_4 = (acc_4 ^ (acc_4 >>> 47) ^ i64(XXH3_kSecret, offSec + 8 * 4)) * XXH_PRIME32_1;
+            acc_5 = (acc_5 ^ (acc_5 >>> 47) ^ i64(XXH3_kSecret, offSec + 8 * 5)) * XXH_PRIME32_1;
+            acc_6 = (acc_6 ^ (acc_6 >>> 47) ^ i64(XXH3_kSecret, offSec + 8 * 6)) * XXH_PRIME32_1;
+            acc_7 = (acc_7 ^ (acc_7 >>> 47) ^ i64(XXH3_kSecret, offSec + 8 * 7)) * XXH_PRIME32_1;
+        }
+
+        /* last partial block */
+        final long nbStripes = ((length - 1) - (block_len * nb_blocks)) / 64;
+        final long offBlock = off + block_len * nb_blocks;
+        for (long s = 0; s < nbStripes; s++) {
+            // XXH3_accumulate_512
+            final long offStripe = offBlock + s * 64;
+            final long offSec = s * 8;
+            {
+                final long data_val_0 = i64(input, offStripe);
+                final long data_val_1 = i64(input, offStripe + 8);
+                final long data_key_0 = data_val_0 ^ i64(XXH3_kSecret, offSec);
+                final long data_key_1 = data_val_1 ^ i64(XXH3_kSecret, offSec + 8);
+                /* swap adjacent lanes */
+                acc_0 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+                acc_1 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+            }
+            {
+                final long data_val_0 = i64(input, offStripe + 8 * 2);
+                final long data_val_1 = i64(input, offStripe + 8 * 3);
+                final long data_key_0 = data_val_0 ^ i64(XXH3_kSecret, offSec + 8 * 2);
+                final long data_key_1 = data_val_1 ^ i64(XXH3_kSecret, offSec + 8 * 3);
+                /* swap adjacent lanes */
+                acc_2 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+                acc_3 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+            }
+            {
+                final long data_val_0 = i64(input, offStripe + 8 * 4);
+                final long data_val_1 = i64(input, offStripe + 8 * 5);
+                final long data_key_0 = data_val_0 ^ i64(XXH3_kSecret, offSec + 8 * 4);
+                final long data_key_1 = data_val_1 ^ i64(XXH3_kSecret, offSec + 8 * 5);
+                /* swap adjacent lanes */
+                acc_4 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+                acc_5 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+            }
+            {
+                final long data_val_0 = i64(input, offStripe + 8 * 6);
+                final long data_val_1 = i64(input, offStripe + 8 * 7);
+                final long data_key_0 = data_val_0 ^ i64(XXH3_kSecret, offSec + 8 * 6);
+                final long data_key_1 = data_val_1 ^ i64(XXH3_kSecret, offSec + 8 * 7);
+                /* swap adjacent lanes */
+                acc_6 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+                acc_7 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+            }
+        }
+
+        /* last stripe */
+        // XXH3_accumulate_512
+        final long offStripe = off + length - 64;
+        final long offSec = 192 - 64 - 7;
+        {
+            final long data_val_0 = i64(input, offStripe);
+            final long data_val_1 = i64(input, offStripe + 8);
+            final long data_key_0 = data_val_0 ^ i64(XXH3_kSecret, offSec);
+            final long data_key_1 = data_val_1 ^ i64(XXH3_kSecret, offSec + 8);
+            /* swap adjacent lanes */
+            acc_0 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+            acc_1 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+        }
+        {
+            final long data_val_0 = i64(input, offStripe + 8 * 2);
+            final long data_val_1 = i64(input, offStripe + 8 * 3);
+            final long data_key_0 = data_val_0 ^ i64(XXH3_kSecret, offSec + 8 * 2);
+            final long data_key_1 = data_val_1 ^ i64(XXH3_kSecret, offSec + 8 * 3);
+            /* swap adjacent lanes */
+            acc_2 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+            acc_3 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+        }
+        {
+            final long data_val_0 = i64(input, offStripe + 8 * 4);
+            final long data_val_1 = i64(input, offStripe + 8 * 5);
+            final long data_key_0 = data_val_0 ^ i64(XXH3_kSecret, offSec + 8 * 4);
+            final long data_key_1 = data_val_1 ^ i64(XXH3_kSecret, offSec + 8 * 5);
+            /* swap adjacent lanes */
+            acc_4 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+            acc_5 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+        }
+        {
+            final long data_val_0 = i64(input, offStripe + 8 * 6);
+            final long data_val_1 = i64(input, offStripe + 8 * 7);
+            final long data_key_0 = data_val_0 ^ i64(XXH3_kSecret, offSec + 8 * 6);
+            final long data_key_1 = data_val_1 ^ i64(XXH3_kSecret, offSec + 8 * 7);
+            /* swap adjacent lanes */
+            acc_6 += data_val_1 + (0xFFFFFFFFL & data_key_0) * (data_key_0 >>> 32);
+            acc_7 += data_val_0 + (0xFFFFFFFFL & data_key_1) * (data_key_1 >>> 32);
+        }
+
+        // XXH3_mergeAccs
+        final long result64 = length * XXH_PRIME64_1
+                + XXH3_mix2Accs(acc_0, acc_1, 11)
+                + XXH3_mix2Accs(acc_2, acc_3, 11 + 16)
+                + XXH3_mix2Accs(acc_4, acc_5, 11 + 16 * 2)
+                + XXH3_mix2Accs(acc_6, acc_7, 11 + 16 * 3);
+
+        return XXH3_avalanche(result64);
+    }
+
+    static long unsignedInt(int i) {
+        return i & 0xFFFFFFFFL;
+    }
+
+    /**
+     * Reads a 64 bit long in little-endian order from the given byte array at the specified offset.
+     * *
+     * @param input the object to access
+     * @param offset offset to the first byte to read within the byte sequence represented
+     * @return a 64 bit long value, little-endian encoded
+     */
+    private static long i64(final byte[] input, final long offset) {
+        return (long) LONG_HANDLE.get(input, (int) offset);
+    }
+
+    /**
+     * Reads an unsigned byte from the given byte array at the specified offset.
+     *
+     * @param input the object to access
+     * @param offset offset to the byte to read within the byte sequence represented
+     * by the given object
+     * @return a byte by the given {@code offset}, interpreted as unsigned
+     */
+    private static int u8(final byte[] input, final long offset) {
+        return Byte.toUnsignedInt(input[(int) offset]);
+    }
+
+    /**
+     * Reads an unsigned byte from the given byte array at the specified offset.
+     *
+     * @param input the object to access
+     * @param offset offset to the byte to read within the byte sequence represented
+     * by the given object
+     * @return a byte by the given {@code offset}, interpreted as unsigned
+     */
+    private static int i8(final byte[] input, final long offset) {
+        return input[(int) offset];
+    }
+
+    /**
+     * Load 4 bytes from the provided array at the indicated offset.
+     *
+     * @param source the input bytes
+     * @param offset the offset into the array at which to start
+     * @return the value found in the array in the form of a long
+     */
+    private static int u32(byte[] source, int offset) {
+        // This is faster than using VarHandle for 4 bytes
+        return (source[offset] & 0xFF)
+                | ((source[offset + 1] & 0xFF) << 8)
+                | ((source[offset + 2] & 0xFF) << 16)
+                | ((source[offset + 3] & 0xFF) << 24);
+    }
+
+    /**
+     * Load 4 bytes from the provided array at the indicated offset.
+     *
+     * @param source the input bytes
+     * @param offset the offset into the array at which to start
+     * @return the value found in the array in the form of a long
+     */
+    private static int i32(byte[] source, int offset) {
+        // This is faster than using VarHandle for 4 bytes
+        return (source[offset] & 0xFF)
+                | ((source[offset + 1] & 0xFF) << 8)
+                | ((source[offset + 2] & 0xFF) << 16)
+                | ((source[offset + 3] & 0xFF) << 24);
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/XxHash.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XxHash.java
similarity index 98%
rename from pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/XxHash.java
rename to pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XxHash.java
index 3412c1b3..61e5246c 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/XxHash.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XxHash.java
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
-package com.hedera.pbj.integration.jmh.hashing;
+package com.hedera.pbj.integration.jmh.hashing.functions;
 
 import edu.umd.cs.findbugs.annotations.NonNull;
 
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XxHashRichard.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XxHashRichard.java
new file mode 100644
index 00000000..552ae75c
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XxHashRichard.java
@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+
+public final class XxHashRichard {
+    private static final VarHandle INT_HANDLE =
+            MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN);
+    static final int SEED = 0;
+    static final int PRIME1 = 0x9E3779B1;
+    static final int PRIME2 = 0x85EBCA77;
+    static final int PRIME3 = 0xC2B2AE3D;
+    static final int PRIME4 = 0x27D4EB2F;
+    static final int PRIME5 = 0x165667B1;
+
+    public static int hash(byte[] data, int offset, int length) {
+        int end = offset + length;
+        int h32;
+        if (data.length >= 16) {
+            int limit = end - 16;
+            int v1 = SEED + PRIME1 + PRIME2;
+            int v2 = SEED + PRIME2;
+            int v3 = SEED;
+            int v4 = SEED - PRIME1;
+
+            do {
+                v1 += (int) INT_HANDLE.get(data, offset) * PRIME2;
+                v1 = Integer.rotateLeft(v1, 13);
+                v1 *= PRIME1;
+                offset += 4;
+                v2 += (int) INT_HANDLE.get(data, offset) * PRIME2;
+                v2 = Integer.rotateLeft(v2, 13);
+                v2 *= PRIME1;
+                offset += 4;
+                v3 += (int) INT_HANDLE.get(data, offset) * PRIME2;
+                v3 = Integer.rotateLeft(v3, 13);
+                v3 *= PRIME1;
+                offset += 4;
+                v4 += (int) INT_HANDLE.get(data, offset) * PRIME2;
+                v4 = Integer.rotateLeft(v4, 13);
+                v4 *= PRIME1;
+                offset += 4;
+            } while (offset <= limit);
+
+            h32 = Integer.rotateLeft(v1, 1)
+                    + Integer.rotateLeft(v2, 7)
+                    + Integer.rotateLeft(v3, 12)
+                    + Integer.rotateLeft(v4, 18);
+        } else {
+            h32 = SEED + PRIME5;
+        }
+
+        for (h32 += data.length; offset <= end - 4; offset += 4) {
+            h32 += (int) INT_HANDLE.get(data, offset) * PRIME3;
+            h32 = Integer.rotateLeft(h32, 17) * PRIME4;
+        }
+
+        while (offset < end) {
+            h32 += (data[offset] & 255) * PRIME5;
+            h32 = Integer.rotateLeft(h32, 11) * PRIME1;
+            ++offset;
+        }
+
+        h32 ^= h32 >>> 15;
+        h32 *= PRIME2;
+        h32 ^= h32 >>> 13;
+        h32 *= PRIME3;
+        h32 ^= h32 >>> 16;
+        return h32;
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/Xxh3.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Xxh3ai.java
similarity index 98%
rename from pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/Xxh3.java
rename to pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Xxh3ai.java
index 87994684..e0a1f6c9 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/Xxh3.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Xxh3ai.java
@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
-package com.hedera.pbj.integration.jmh.hashing;
+package com.hedera.pbj.integration.jmh.hashing.functions;
 
 import edu.umd.cs.findbugs.annotations.NonNull;
 
-public final class Xxh3 {
+public final class Xxh3ai {
     public static int xxh3HashCode(@NonNull final byte[] bytes, int start, int length) {
         if (length <= 16) {
             return xxh3_len_0to16(bytes, start, length);
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQuality11ByteTest.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQuality11ByteTest.java
new file mode 100644
index 00000000..95beb8aa
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQuality11ByteTest.java
@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.qualitytest;
+
+import com.hedera.pbj.integration.jmh.hashing.CountingArray;
+import com.hedera.pbj.integration.jmh.hashing.NonCryptographicHashingBench.HashAlgorithm;
+import java.util.Arrays;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ForkJoinPool;
+
+/**
+ * A test to evaluate the quality of non-cryptographic hash functions by checking how many unique hashes can be
+ * generated from 4.5 billion 11-byte inputs.
+ */
+public final class NonCryptographicHashQuality11ByteTest {
+    private static final int NUM_BUCKETS = 33_554_432; // 2^25 33 million buckets
+
+    public static void main(String[] args) throws ExecutionException, InterruptedException {
+        System.out.println("Testing non-cryptographic hash quality - 11 bytes, 4.5 billion inputs");
+        try (ForkJoinPool customPool = new ForkJoinPool(4)) { // limit to 4 threads
+            customPool
+                    .submit(() -> Arrays.stream(HashAlgorithm.values())
+                            .parallel()
+                            .forEach(hashAlgorithm -> {
+                                final CountingArray counts = new CountingArray(); // 4 billion counts
+                                System.out.println("Testing " + hashAlgorithm.name() + "...");
+                                testHashQuality4Bytes(hashAlgorithm, counts);
+                            }))
+                    .get(); // handle exceptions as needed
+        }
+    }
+
+    private static void testHashQuality4Bytes(HashAlgorithm hashAlgorithm, CountingArray counts) {
+        final long START_TIME = System.currentTimeMillis();
+        final long NUM_INPUTS = 4_500_000_000L; // 4.5 billion inputs
+        final int NUM_BYTES = 11; // 11 bytes = 88 bits of data input
+        final byte[] ba = new byte[NUM_BYTES];
+        final int[] bucketCounts = new int[NUM_BUCKETS]; // 2^25 33 million buckets
+
+        for (long i = 0; i < NUM_INPUTS; i++) {
+            if (i % 10_000_000 == 0) {
+                System.out.printf("\r       Progress: %.2f%%", (i * 100.0) / NUM_INPUTS);
+                System.out.flush();
+            }
+
+            // Cascading increment - like an odometer
+            // This ensures values are in batches and every byte changes
+            boolean carry = true;
+            for (int j = 0; j < NUM_BYTES && carry; j++) {
+                if (ba[j] == (byte) 255) {
+                    ba[j] = 1; // Reset to 1 (avoid 0)
+                    carry = true; // Continue to next byte
+                } else {
+                    ba[j]++;
+                    carry = false; // No carry needed
+                }
+            }
+
+            final int hash32 = (int) hashAlgorithm.function.applyAsLong(ba, 0, NUM_BYTES);
+            counts.increment(Integer.toUnsignedLong(hash32));
+            long bucket = computeBucketIndex(hash32);
+            bucketCounts[(int) bucket]++;
+        }
+
+        long numUniqueHashes = counts.numberOfGreaterThanZeroCounts();
+        long hashCollisions = counts.numberOfGreaterThanOneCounts();
+        double collisionRate = (double) hashCollisions / NUM_INPUTS * 100;
+        final long END_TIME = System.currentTimeMillis();
+        StringBuilder resultStr = new StringBuilder(String.format(
+                "%n%s => Number of unique hashes: %,d, hash collisions: %,d, collision rate: %.2f%% time taken: %.3f seconds%n",
+                hashAlgorithm.name(),
+                numUniqueHashes,
+                hashCollisions,
+                collisionRate,
+                (END_TIME - START_TIME) / 1000.0));
+        counts.printStats(resultStr);
+        // print the distribution of hash buckets sorted by bucket index
+        // convert the bucketCounts into the number of buckets with each count
+        Map<String, Integer> bucketDistribution = Arrays.stream(bucketCounts)
+                .mapToObj(count -> {
+                    if (count == 0) {
+                        return "0";
+                    } else if (count <= 10) {
+                        return "1->10";
+                    } else if (count <= 100) {
+                        return "11->100";
+                    } else if (count <= 1000) {
+                        return "101->1,000";
+                    } else if (count <= 10000) {
+                        return "1,001->10,000";
+                    } else if (count <= 100_000) {
+                        return "10,001->100,000";
+                    } else if (count <= 250_000) {
+                        return "100,001->250,000";
+                    } else if (count <= 500_000) {
+                        return "250,001->500,000";
+                    } else {
+                        return "500,000+";
+                    }
+                })
+                .collect(java.util.stream.Collectors.toMap(count -> count, count -> 1, Integer::sum));
+        resultStr.append("      Bucket distribution: ");
+        bucketDistribution.forEach((category, count) -> {
+            resultStr.append(String.format("  %s=%,d", category, count));
+        });
+        resultStr.append("\n");
+        // print the total number of buckets
+        System.out.print(resultStr);
+        System.out.flush();
+    }
+
+    /**
+     * <p>Code direct from HalfDiskHashMap, only change is NUM_BUCKETS</p>
+     *
+     * Computes which bucket a key with the given hash falls. Depends on the fact the numOfBuckets
+     * is a power of two. Based on same calculation that is used in java HashMap.
+     *
+     * @param keyHash the int hash for key
+     * @return the index of the bucket that key falls in
+     */
+    private static int computeBucketIndex(final int keyHash) {
+        return (NUM_BUCKETS - 1) & keyHash;
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQuality4ByteTest.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQuality4ByteTest.java
new file mode 100644
index 00000000..3356cd7e
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQuality4ByteTest.java
@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.qualitytest;
+
+import com.hedera.pbj.integration.jmh.hashing.LongBitSet;
+import com.hedera.pbj.integration.jmh.hashing.NonCryptographicHashingBench;
+import java.util.Arrays;
+
+/**
+ * A test to evaluate the quality of non-cryptographic hash functions
+ * by checking how many unique hashes can be generated from 4-byte inputs.
+ * It runs through all combinations of 4 bytes (256^4 = 4,294,967,296 combinations).
+ */
+public final class NonCryptographicHashQuality4ByteTest {
+    public static void main(String[] args) {
+        System.out.println("Testing non-cryptographic hash quality - 4 bytes, 4 billion inputs");
+        Arrays.stream(NonCryptographicHashingBench.HashAlgorithm.values())
+                .parallel()
+                .forEach(hashAlgorithm -> {
+                    System.out.println("Testing " + hashAlgorithm.name() + "...");
+                    testHashQuality4Bytes(hashAlgorithm);
+                });
+    }
+
+    private static void testHashQuality4Bytes(NonCryptographicHashingBench.HashAlgorithm hashAlgorithm) {
+        final long START_TIME = System.currentTimeMillis();
+        final LongBitSet bits = new LongBitSet(4_294_967_296L); // 4 billion bits
+        final byte[] ba = new byte[6];
+        for (int i = 0; i < 256; i++) {
+            // print progress as percentage, overwriting the same line
+            System.out.printf("\r       Progress: %d%%", (i * 100) / 256);
+            System.out.flush();
+            for (int j = 0; j < 256; j++) {
+                for (int k = 0; k < 256; k++) {
+                    for (int l = 0; l < 256; l++) {
+                        ba[0] = (byte) i;
+                        ba[1] = (byte) j;
+                        ba[2] = (byte) k;
+                        ba[3] = (byte) l;
+                        long hash = hashAlgorithm.function.applyAsLong(ba, 0, 4);
+                        int bucket = (int) hash;
+                        bits.setBit(bucket & 0xFFFFFFFFL); // Use only the lower 32 bits
+                    }
+                }
+            }
+        }
+
+        // Check that we have a reasonable number of bits set.
+        long numUniqueHashes = bits.cardinality();
+        long expectedUniqueHashes = 256L * 256 * 256 * 256; // 4-byte combinations
+        long hashCollisions = expectedUniqueHashes - numUniqueHashes;
+        final long END_TIME = System.currentTimeMillis();
+        System.out.printf(
+                "%n%-25s => Number of unique hashes: %,d, hash collisions: %,d, time taken: %.3f seconds%n",
+                hashAlgorithm.name(), numUniqueHashes, hashCollisions, (END_TIME - START_TIME) / 1000.0);
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTestBucketDistribution.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQuality4ByteTestBucketDistribution.java
similarity index 72%
rename from pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTestBucketDistribution.java
rename to pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQuality4ByteTestBucketDistribution.java
index ce129027..e52e798a 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashQuality4ByteTestBucketDistribution.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQuality4ByteTestBucketDistribution.java
@@ -1,8 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
-package com.hedera.pbj.integration.jmh.hashing;
+package com.hedera.pbj.integration.jmh.hashing.qualitytest;
 
-import com.hedera.pbj.integration.jmh.NonCryptographicHashingBench;
+import com.hedera.pbj.integration.jmh.hashing.NonCryptographicHashingBench;
 import java.util.Arrays;
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -13,16 +14,20 @@
 public final class NonCryptographicHashQuality4ByteTestBucketDistribution {
     private static final int NUM_BUCKETS = 33_554_432; // 2^25 33 million buckets
 
-
     public static void main(String[] args) {
         System.out.println("Testing non-cryptographic hash quality - 4 bytes, 4 billion inputs");
-        for (var hashAlgorithm : NonCryptographicHashingBench.HashAlgorithm.values()) {
-            System.out.println("Testing " + hashAlgorithm.name() + " ====================================");
-            testHashQuality4Bytes(hashAlgorithm);
-        }
+        List<String> results = Arrays.stream(NonCryptographicHashingBench.HashAlgorithm.values())
+                .parallel()
+                .map(hashAlgorithm -> {
+                    System.out.println("Testing " + hashAlgorithm.name() + "...");
+                    return testHashQuality4Bytes(hashAlgorithm);
+                })
+                .toList();
+        // Print all results
+        results.forEach(System.out::println);
     }
 
-    private static void testHashQuality4Bytes(NonCryptographicHashingBench.HashAlgorithm hashAlgorithm) {
+    private static String testHashQuality4Bytes(NonCryptographicHashingBench.HashAlgorithm hashAlgorithm) {
         final int[] bucketCounts = new int[NUM_BUCKETS]; // 2^25 33 million buckets
         final byte[] ba = new byte[4];
         for (int i = 0; i < 256; i++) {
@@ -49,10 +54,12 @@ private static void testHashQuality4Bytes(NonCryptographicHashingBench.HashAlgor
         Map<Integer, Integer> bucketDistribution = Arrays.stream(bucketCounts)
                 .boxed()
                 .collect(java.util.stream.Collectors.toMap(count -> count, count -> 1, Integer::sum));
-        System.out.println("\n       Bucket distribution:");
+        StringBuilder resultStr = new StringBuilder(hashAlgorithm.name() + " Bucket distribution:\n");
         bucketDistribution.entrySet().stream()
                 .sorted(Map.Entry.comparingByKey())
-                .forEach(entry -> System.out.printf("       Count %d: %d buckets%n", entry.getKey(), entry.getValue()));
+                .forEach(entry -> resultStr.append(
+                        String.format("       Count %d: %d buckets%n", entry.getKey(), entry.getValue())));
+        return resultStr.toString();
     }
 
     /**
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQualityOneBitTest.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQualityOneBitTest.java
new file mode 100644
index 00000000..100a7c6b
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQualityOneBitTest.java
@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.qualitytest;
+
+import com.hedera.pbj.integration.jmh.hashing.CountingArray;
+import com.hedera.pbj.integration.jmh.hashing.NonCryptographicHashingBench.HashAlgorithm;
+
+/**
+ * A test to evaluate the quality of non-cryptographic hash functions by checking 1MB of zeros with one bit moving
+ * through it.
+ */
+@SuppressWarnings("DuplicatedCode")
+public final class NonCryptographicHashQualityOneBitTest {
+    public static void main(String[] args) {
+        System.out.println("Testing non-cryptographic hash quality - 1 MB of zeros with one bit moving through it");
+        final CountingArray[] counts = new CountingArray[HashAlgorithm.values().length];
+        for (int i = 0; i < counts.length; i++) {
+            counts[i] = new CountingArray(); // 4 billion counts
+        }
+        final byte[] bigArray = new byte[1024 * 1024]; // 1MB of zeros
+        final long[] TIMES = new long[HashAlgorithm.values().length];
+
+        final long NUM_INPUTS = bigArray.length;
+        double percent = 0;
+        for (int i = 0; i < bigArray.length; i++) {
+            if (i % 100 == 0) {
+                double progress = (i * 100.0) / NUM_INPUTS;
+                System.out.printf("\r       Progress: %.2f%%", progress);
+                System.out.flush();
+                if (progress > (percent + 10)) {
+                    printResults(counts, NUM_INPUTS, TIMES);
+                    percent += 10;
+                }
+            }
+            bigArray[i] = 1; // set a bit to 1
+            for (int h = 0; h < HashAlgorithm.values().length; h++) {
+                final HashAlgorithm hashAlgorithm = HashAlgorithm.values()[h];
+                final long startTime = System.nanoTime();
+                final int hash = (int) hashAlgorithm.function.applyAsLong(bigArray, 0, bigArray.length);
+                final long endTime = System.nanoTime();
+                TIMES[h] += (endTime - startTime);
+                counts[h].increment(Integer.toUnsignedLong(hash));
+            }
+            bigArray[i] = 0; // set a bit back to 0
+        }
+
+        printResults(counts, NUM_INPUTS, TIMES);
+    }
+
+    private static void printResults(CountingArray[] counts, long NUM_INPUTS, long[] TIMES) {
+        final HashAlgorithm[] algorithms = HashAlgorithm.values();
+        for (int h = 0; h < algorithms.length; h++) {
+            final HashAlgorithm hashAlgorithm = algorithms[h];
+            long numUniqueHashes = counts[h].numberOfGreaterThanZeroCounts();
+            long hashCollisions = counts[h].numberOfGreaterThanOneCounts();
+            double collisionRate = (double) hashCollisions / NUM_INPUTS * 100;
+            double timeTaken = TIMES[h] / 1_000_000_000.0; // convert to seconds
+            System.out.print("\n");
+            System.out.printf(
+                    "%20s --> Number of unique hashes: %,d, hash collisions: %,d, collision rate: %.2f%% time taken: %.3f seconds%n",
+                    hashAlgorithm.name(), numUniqueHashes, hashCollisions, collisionRate, timeTaken);
+            StringBuilder resultStr = new StringBuilder();
+            counts[h].printStats(resultStr);
+            System.out.print(resultStr);
+        }
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQualityStateKeyTest.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQualityStateKeyTest.java
new file mode 100644
index 00000000..93563606
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQualityStateKeyTest.java
@@ -0,0 +1,261 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.qualitytest;
+
+import com.hedera.hapi.node.base.AccountID;
+import com.hedera.hapi.node.base.NftID;
+import com.hedera.hapi.node.base.TokenID;
+import com.hedera.hapi.node.state.common.EntityIDPair;
+import com.hedera.pbj.integration.jmh.hashing.CountingArray;
+import com.hedera.pbj.integration.jmh.hashing.NonCryptographicHashingBench.HashAlgorithm;
+import com.hedera.pbj.runtime.io.buffer.BufferedData;
+import com.hedera.pbj.test.proto.java.teststate.pbj.integration.tests.StateKey;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.channels.FileChannel;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Arrays;
+import java.util.Map;
+import java.util.Random;
+import java.util.concurrent.ForkJoinPool;
+
+/**
+ * A test to evaluate the quality of non-cryptographic hash functions by checking how many unique hashes can be
+ * generated from 4.5 billion StateKey inputs.
+ */
+public final class NonCryptographicHashQualityStateKeyTest {
+    private static final int NUM_BUCKETS = 33_554_432; // 2^25 33 million buckets
+    // Where to place result files
+    private static final Path OUTPUT_ROOT = Path.of("hash_quality_results");
+
+    public static void main(String[] args) throws Exception {
+        final Path outputDir = createOutputDirectory();
+        System.out.println("Testing non-cryptographic hash quality - Random StateKeys, 4.5 billion inputs");
+        try (ForkJoinPool customPool = new ForkJoinPool(4)) { // limit to 4 threads
+            //
+            //            customPool.submit(() ->
+            //                    Arrays.stream(HashAlgorithm.values())
+            ////                            .parallel()
+            //                            .forEach(hashAlgorithm -> {
+            //                                final CountingArray counts = new CountingArray(); // 4 billion counts
+            //                                System.out.println("Testing " + hashAlgorithm.name() + "...");
+            //                                try {
+            //                                    testHashQuality4Bytes(hashAlgorithm, counts, outputDir);
+            //                                } catch (IOException e) {
+            //                                    e.printStackTrace();
+            //                                    throw new RuntimeException(e);
+            //                                }
+            //                            })
+            //            ).get(); // handle exceptions as needed
+            final CountingArray counts = new CountingArray(); // 4 billion counts
+            testHashQuality4Bytes(HashAlgorithm.JAVA_257, counts, outputDir);
+        }
+    }
+
+    private static void testHashQuality4Bytes(HashAlgorithm hashAlgorithm, CountingArray counts, final Path outputDir)
+            throws IOException {
+        final long START_TIME = System.currentTimeMillis();
+        final long NUM_INPUTS = 4_500_000_000L; // 4.5 billion inputs
+        //        final long NUM_INPUTS = 50_000_000L; // 4.5 billion inputs
+        final byte[] bufferArray = new byte[1024];
+        final BufferedData bufferedData = BufferedData.wrap(bufferArray);
+        final int[] bucketCounts = new int[NUM_BUCKETS]; // 2^25 33 million buckets
+        final Random random = new Random(2518643515415654L); // Seed for reproducibility
+        long lengthSum = 0;
+        long minLength = Integer.MAX_VALUE;
+        long maxLength = Integer.MIN_VALUE;
+
+        for (long i = 0; i < NUM_INPUTS; i++) {
+            if (i % 10_000_000 == 0) {
+                long averageLength = lengthSum / (i + 1);
+                System.out.printf(
+                        "\r       Progress: %.2f%% Length: avg=%,d, min=%,d, max=%,d",
+                        (i * 100.0) / NUM_INPUTS, averageLength, minLength, maxLength);
+                System.out.flush();
+            }
+            // create a sample StateKey that will be hashed
+            StateKey stateKey =
+                    switch (random.nextInt(4)) {
+                        case 0 ->
+                            StateKey.newBuilder()
+                                    .accountId(AccountID.newBuilder().accountNum(i))
+                                    .build();
+                        case 1 ->
+                            StateKey.newBuilder()
+                                    .tokenId(TokenID.newBuilder().tokenNum(i))
+                                    .build();
+                        case 2 ->
+                            StateKey.newBuilder()
+                                    .entityIdPair(EntityIDPair.newBuilder()
+                                            .accountId(AccountID.newBuilder().accountNum(i))
+                                            .tokenId(TokenID.newBuilder().tokenNum(i)))
+                                    .build();
+                        case 3 ->
+                            StateKey.newBuilder()
+                                    .nftId(NftID.newBuilder()
+                                            .tokenId(TokenID.newBuilder().tokenNum(i))
+                                            .serialNumber(random.nextLong(1_000_000)))
+                                    .build();
+                        default -> throw new IllegalStateException("Unexpected value: ");
+                    };
+            bufferedData.position(0);
+            StateKey.PROTOBUF.write(stateKey, bufferedData);
+            int lengthWritten = (int) bufferedData.position();
+            lengthSum += lengthWritten;
+            if (lengthWritten < minLength) {
+                minLength = lengthWritten;
+            }
+            if (lengthWritten > maxLength) {
+                maxLength = lengthWritten;
+            }
+
+            final int hash32 = (int) hashAlgorithm.function.applyAsLong(bufferArray, 0, lengthWritten);
+            counts.increment(Integer.toUnsignedLong(hash32));
+            long bucket = computeBucketIndex(hash32);
+            bucketCounts[(int) bucket]++;
+        }
+
+        long numUniqueHashes = counts.numberOfGreaterThanZeroCounts();
+        long hashCollisions = counts.numberOfGreaterThanOneCounts();
+        double collisionRate = (double) hashCollisions / NUM_INPUTS * 100;
+        final long END_TIME = System.currentTimeMillis();
+        StringBuilder resultStr = new StringBuilder(String.format(
+                "%n%s => Number of unique hashes: %,d, hash collisions: %,d, collision rate: %.2f%% time taken: %.3f seconds%n",
+                hashAlgorithm.name(),
+                numUniqueHashes,
+                hashCollisions,
+                collisionRate,
+                (END_TIME - START_TIME) / 1000.0));
+        counts.printStats(resultStr);
+        // print the distribution of hash buckets sorted by bucket index
+        // convert the bucketCounts into the number of buckets with each count
+        Map<String, Integer> bucketDistribution = Arrays.stream(bucketCounts)
+                .mapToObj(count -> {
+                    if (count == 0) {
+                        return "0";
+                    } else if (count <= 10) {
+                        return "1->10";
+                    } else if (count <= 100) {
+                        return "11->100";
+                    } else if (count <= 1000) {
+                        return "101->1,000";
+                    } else if (count <= 10000) {
+                        return "1,001->10,000";
+                    } else if (count <= 100_000) {
+                        return "10,001->100,000";
+                    } else if (count <= 250_000) {
+                        return "100,001->250,000";
+                    } else if (count <= 500_000) {
+                        return "250,001->500,000";
+                    } else {
+                        return "500,000+";
+                    }
+                })
+                .collect(java.util.stream.Collectors.toMap(count -> count, count -> 1, Integer::sum));
+        resultStr.append("      Bucket distribution: ");
+        bucketDistribution.forEach((category, count) -> {
+            resultStr.append(String.format("  %s=%,d", category, count));
+        });
+        resultStr.append("\n");
+        // print the total number of buckets
+        System.out.print(resultStr);
+        System.out.flush();
+
+        // Export detailed per-bucket counts for plotting
+        exportBucketCounts(outputDir, hashAlgorithm.name(), bucketCounts, NUM_INPUTS, NUM_BUCKETS);
+    }
+
+    /**
+     * <p>Code direct from HalfDiskHashMap, only change is NUM_BUCKETS</p>
+     *
+     * Computes which bucket a key with the given hash falls. Depends on the fact the numOfBuckets
+     * is a power of two. Based on same calculation that is used in java HashMap.
+     *
+     * @param keyHash the int hash for key
+     * @return the index of the bucket that key falls in
+     */
+    private static int computeBucketIndex(final int keyHash) {
+        return (NUM_BUCKETS - 1) & keyHash;
+    }
+    /**
+     * Creates a timestamped output directory like:
+     *   hash_quality_results/run_YYYYMMDD_HHMMSSZ
+     */
+    private static Path createOutputDirectory() throws IOException {
+        final String ts = DateTimeFormatter.ofPattern("yyyyMMdd_HHmmssX").format(ZonedDateTime.now(ZoneOffset.UTC));
+        final Path dir = OUTPUT_ROOT.resolve("run_" + ts);
+        Files.createDirectories(dir);
+        return dir;
+    }
+
+    /**
+     * Exports the per-bucket counts in a compact binary format and writes a sidecar JSON metadata file.
+     *
+     * Format:
+     * - Data file: <ALG>_counts_i32_le.bin (little-endian 32-bit signed ints), length == numBuckets.
+     * - Metadata:  <ALG>.meta.json
+     */
+    private static void exportBucketCounts(
+            final Path outputDir,
+            final String algorithmName,
+            final int[] bucketCounts,
+            final long numInputs,
+            final int numBuckets)
+            throws IOException {
+        final String safeAlg = algorithmName.replaceAll("[^A-Za-z0-9_.-]", "_");
+        final Path dataFile = outputDir.resolve(safeAlg + "_counts_i32_le.bin");
+        final Path metaFile = outputDir.resolve(safeAlg + ".meta.json");
+
+        // Write binary counts in little-endian in chunks to avoid large buffers
+        final int chunkSize = 1_048_576; // 1M ints (~4 MiB)
+        try (FileChannel ch = FileChannel.open(
+                dataFile, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.WRITE)) {
+            final ByteBuffer buf =
+                    ByteBuffer.allocateDirect(chunkSize * Integer.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+            int written = 0;
+            while (written < numBuckets) {
+                buf.clear();
+                final int end = Math.min(written + chunkSize, numBuckets);
+                for (int i = written; i < end; i++) {
+                    buf.putInt(bucketCounts[i]);
+                }
+                buf.flip();
+                while (buf.hasRemaining()) {
+                    ch.write(buf);
+                }
+                written = end;
+            }
+            ch.force(true);
+        }
+
+        // Metadata JSON
+        final double lambda = (double) numInputs / (double) numBuckets;
+        final String metaJson = "{\n" + "  \"algorithm\": \""
+                + escapeJson(algorithmName) + "\",\n" + "  \"numBuckets\": "
+                + numBuckets + ",\n" + "  \"numInputs\": "
+                + numInputs + ",\n" + "  \"hashBits\": 32,\n"
+                + "  \"bucketIndexFormula\": \"(NUM_BUCKETS - 1) & hash\",\n"
+                + "  \"countsFile\": \""
+                + escapeJson(dataFile.getFileName().toString()) + "\",\n" + "  \"countsDtype\": \"int32\",\n"
+                + "  \"endianness\": \"little\",\n"
+                + "  \"expectedMeanPerBucket\": "
+                + String.format("%.6f", lambda) + "\n" + "}\n";
+        Files.writeString(
+                metaFile,
+                metaJson,
+                StandardCharsets.UTF_8,
+                StandardOpenOption.CREATE,
+                StandardOpenOption.TRUNCATE_EXISTING,
+                StandardOpenOption.WRITE);
+    }
+
+    private static String escapeJson(String s) {
+        return s.replace("\\", "\\\\").replace("\"", "\\\"");
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQualityTest.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQualityTest.java
new file mode 100644
index 00000000..e6335833
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQualityTest.java
@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.qualitytest;
+
+import com.hedera.pbj.integration.jmh.hashing.NonCryptographicHashingBench;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * A test to evaluate the quality of non-cryptographic hash functions
+ * by checking how many unique hashes can be generated from 11-byte inputs.
+ * It runs through all 500 million combinations.
+ */
+public final class NonCryptographicHashQualityTest {
+    public static void main(String[] args) {
+        System.out.println("Testing non-cryptographic hash quality - 11 bytes, 500 million inputs");
+        for (var hashAlgorithm : NonCryptographicHashingBench.HashAlgorithm.values()) {
+            System.out.println("Testing " + hashAlgorithm.name() + " ====================================");
+            testHashQuality11Bytes2BillionInt(hashAlgorithm);
+        }
+        System.out.println("Testing non-cryptographic hash quality - 11 bytes, 500 million inputs");
+        for (var hashAlgorithm : NonCryptographicHashingBench.HashAlgorithm.values()) {
+            System.out.println("Testing " + hashAlgorithm.name() + " ====================================");
+            testHashQuality11Bytes2Billion(hashAlgorithm);
+        }
+    }
+
+    private static void testHashQuality11Bytes2Billion(NonCryptographicHashingBench.HashAlgorithm hashAlgorithm) {
+        final long START_TIME = System.currentTimeMillis();
+        final long NUM_INPUTS = 500_000_000L; // 500 million inputs
+        final int NUM_BYTES = 11; // 11 bytes = 88 bits of data input
+        final Set<Long> hashes = new HashSet<>();
+        final byte[] ba = new byte[NUM_BYTES];
+
+        for (long i = 0; i < NUM_INPUTS; i++) {
+            if (i % 10_000_000 == 0) {
+                System.out.printf("\r       Progress: %.2f%%", (i * 100.0) / NUM_INPUTS);
+                System.out.flush();
+            }
+            long value = i;
+            for (int j = 0; j < NUM_BYTES; j++) {
+                // Map each byte to 1..255 (never zero)
+                ba[j] = (byte) ((value % 255) + 1);
+                value /= 255;
+            }
+            final long hash = hashAlgorithm.function.applyAsLong(ba, 0, NUM_BYTES);
+            hashes.add(hash);
+        }
+
+        long numUniqueHashes = hashes.size();
+        long hashCollisions = NUM_INPUTS - numUniqueHashes;
+        final long END_TIME = System.currentTimeMillis();
+        System.out.printf(
+                "       Number of unique hashes: %,d, hash collisions: %,d, time taken: %.3f seconds%n",
+                numUniqueHashes, hashCollisions, (END_TIME - START_TIME) / 1000.0);
+    }
+
+    private static void testHashQuality11Bytes2BillionInt(NonCryptographicHashingBench.HashAlgorithm hashAlgorithm) {
+        final long START_TIME = System.currentTimeMillis();
+        final long NUM_INPUTS = 500_000_000L; // 500 million inputs
+        final int NUM_BYTES = 11; // 11 bytes = 88 bits of data input
+        final int NUM_OF_CHANGES_PER_ROUND_PER_BYTE =
+                15; // the number of changes per byte in each round before moving to the next byte
+        final Set<Integer> hashes = new HashSet<>();
+        final byte[] ba = new byte[NUM_BYTES];
+
+        for (long i = 0; i < NUM_INPUTS; i++) {
+            if (i % 10_000_000 == 0) {
+                System.out.printf("\r       Progress: %.2f%%", (i * 100.0) / NUM_INPUTS);
+                System.out.flush();
+            }
+
+            // Cascading increment - like an odometer
+            // This ensures values are in batches and every byte changes
+            boolean carry = true;
+            for (int j = 0; j < NUM_BYTES && carry; j++) {
+                if (ba[j] == (byte) 255) {
+                    ba[j] = 1; // Reset to 1 (avoid 0)
+                    carry = true; // Continue to next byte
+                } else {
+                    ba[j]++;
+                    carry = false; // No carry needed
+                }
+            }
+
+            final int hash = (int) hashAlgorithm.function.applyAsLong(ba, 0, NUM_BYTES);
+            hashes.add(hash);
+        }
+
+        long numUniqueHashes = hashes.size();
+        long hashCollisions = NUM_INPUTS - numUniqueHashes;
+        final long END_TIME = System.currentTimeMillis();
+        System.out.printf(
+                "       Number of unique hashes: %,d, hash collisions: %,d, time taken: %.3f seconds%n",
+                numUniqueHashes, hashCollisions, (END_TIME - START_TIME) / 1000.0);
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/scripts_plot_hash_bucket_histograms.py b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/scripts_plot_hash_bucket_histograms.py
new file mode 100644
index 00000000..b587b079
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/scripts_plot_hash_bucket_histograms.py
@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+"""
+Reads per-algorithm per-bucket counts exported by NonCryptographicHashQualityStateKeyTest
+and plots bucket-occupancy histograms suitable for comparing hash quality.
+
+Input format (per algorithm):
+  - <ALG>.meta.json         : metadata with fields {algorithm, numBuckets, numInputs, countsFile, countsDtype, endianness}
+  - <ALG>_counts_i32_le.bin : little-endian int32 array of length numBuckets with counts per bucket
+
+Usage:
+  python scripts/plot_hash_bucket_histograms.py /path/to/hash_quality_results/run_YYYYMMDD_HHMMSSZ [--max-k 400] [--overlay] [--logy]
+
+Outputs:
+  - One PNG per algorithm: hist_<ALG>.png
+  - If --overlay: a combined overlay PNG: hist_overlay.png
+"""
+import argparse
+import glob
+import json
+import math
+import os
+from pathlib import Path
+from typing import Dict, Any, List, Tuple
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+def load_algorithm(meta_path: Path) -> Tuple[Dict[str, Any], np.ndarray]:
+    with open(meta_path, "r", encoding="utf-8") as f:
+        meta = json.load(f)
+    counts_file = meta_path.parent / meta["countsFile"]
+    dtype = np.int32
+    if str(meta.get("endianness", "little")).lower().startswith("little"):
+        dtype = np.dtype("<i4")
+    elif str(meta.get("endianness", "little")).lower().startswith("big"):
+        dtype = np.dtype(">i4")
+    counts = np.fromfile(counts_file, dtype=dtype)
+    if counts.size != int(meta["numBuckets"]):
+        raise ValueError(f"Counts size {counts.size} != numBuckets {meta['numBuckets']} for {meta_path}")
+    return meta, counts
+
+
+def poisson_expected_counts(max_k: int, lam: float, num_buckets: int) -> np.ndarray:
+    """
+    Compute expected number of buckets with exactly k items for k=0..max_k under Poisson(lam).
+    Uses stable recurrence: P(k+1) = P(k) * lam / (k+1)
+    """
+    exp_counts = np.zeros(max_k + 1, dtype=np.float64)
+    p = math.exp(-lam)  # P(0)
+    exp_counts[0] = p * num_buckets
+    for k in range(0, max_k):
+        p = p * lam / (k + 1)
+        exp_counts[k + 1] = p * num_buckets
+    return exp_counts
+
+
+def compute_hist(counts: np.ndarray, max_k: int = None) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Returns (k_values, num_buckets_with_k) for k in [0..max_k]
+    """
+    hist = np.bincount(counts.astype(np.int64))
+    if max_k is None:
+        max_k = len(hist) - 1
+    else:
+        max_k = min(max_k, len(hist) - 1)
+    k = np.arange(0, max_k + 1, dtype=np.int64)
+    y = hist[: (max_k + 1)]
+    return k, y
+
+
+def plot_per_algorithm(
+    meta: Dict[str, Any],
+    k: np.ndarray,
+    y: np.ndarray,
+    out_dir: Path,
+    show_poisson: bool = True,
+    logy: bool = False,
+):
+    alg = meta["algorithm"]
+    num_buckets = int(meta["numBuckets"])
+    num_inputs = int(meta["numInputs"])
+    lam = num_inputs / num_buckets
+
+    fig, ax = plt.subplots(figsize=(10, 6))
+    ax.bar(k, y, width=1.0, color="#4e79a7", alpha=0.7, label=f"Observed ({alg})", edgecolor="none")
+
+    if show_poisson:
+        y_exp = poisson_expected_counts(k.max(), lam, num_buckets)
+        ax.plot(k, y_exp, color="#e15759", linewidth=2.0, label=f"Poisson λ={lam:.2f}")
+
+    ax.set_title(f"Bucket occupancy histogram — {alg}\n(numInputs={num_inputs:,}, numBuckets={num_buckets:,}, λ≈{lam:.2f})")
+    ax.set_xlabel("Items per bucket (k)")
+    ax.set_ylabel("Number of buckets with exactly k items")
+    if logy:
+        ax.set_yscale("log")
+        ax.set_ylabel("Number of buckets (log scale)")
+    ax.grid(True, which="both", axis="y", linestyle=":", alpha=0.5)
+    ax.legend()
+    fig.tight_layout()
+    out_path = out_dir / f"hist_{sanitize_filename(alg)}.png"
+    fig.savefig(out_path, dpi=150)
+    plt.close(fig)
+
+
+def plot_overlay(
+    alg_results: List[Tuple[Dict[str, Any], np.ndarray, np.ndarray]],
+    out_dir: Path,
+    normalize: bool = True,
+    logy: bool = False,
+):
+    """
+    Overlays histograms as lines for quick comparison.
+    If normalize=True, y is fraction of buckets instead of absolute count.
+    """
+    fig, ax = plt.subplots(figsize=(11, 7))
+    for meta, k, y in alg_results:
+        label = meta["algorithm"]
+        if normalize:
+            y_plot = y / y.sum()  # fraction of buckets
+            ax.set_ylabel("Fraction of buckets with exactly k items")
+        else:
+            y_plot = y
+            ax.set_ylabel("Number of buckets with exactly k items")
+        ax.plot(k, y_plot, linewidth=1.8, label=label)
+    ax.set_xlabel("Items per bucket (k)")
+    if logy:
+        ax.set_yscale("log")
+    ax.set_title("Bucket occupancy histograms — overlay")
+    ax.grid(True, which="both", axis="y", linestyle=":", alpha=0.5)
+    ax.legend()
+    fig.tight_layout()
+    out_path = out_dir / "hist_overlay.png"
+    fig.savefig(out_path, dpi=150)
+    plt.close(fig)
+
+
+def sanitize_filename(s: str) -> str:
+    return "".join(c if c.isalnum() or c in "._-" else "_" for c in s)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("results_dir", type=str, help="Path to run directory (hash_quality_results/run_YYYYMMDD_HHMMSSZ)")
+    parser.add_argument("--max-k", type=int, default=None, help="Maximum k to plot (default: auto up to max observed)")
+    parser.add_argument("--overlay", action="store_true", help="Also produce a combined overlay plot")
+    parser.add_argument("--logy", action="store_true", help="Use logarithmic y-axis")
+    args = parser.parse_args()
+
+    run_dir = Path(args.results_dir)
+    if not run_dir.exists():
+        raise SystemExit(f"Directory not found: {run_dir}")
+
+    meta_files = sorted(glob.glob(str(run_dir / "*.meta.json")))
+    if not meta_files:
+        raise SystemExit(f"No *.meta.json files found in {run_dir}")
+
+    # Create an output subdir for plots
+    out_dir = run_dir / "plots"
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    overlay_data: List[Tuple[Dict[str, Any], np.ndarray, np.ndarray]] = []
+
+    for meta_path_str in meta_files:
+        meta_path = Path(meta_path_str)
+        meta, counts = load_algorithm(meta_path)
+        k, y = compute_hist(counts, max_k=args.max_k)
+        plot_per_algorithm(meta, k, y, out_dir, show_poisson=True, logy=args.logy)
+        overlay_data.append((meta, k, y))
+
+    if args.overlay:
+        # Align k-range across algorithms to the minimum common max_k
+        min_max_k = min(int(k[-1]) for _, k, _ in overlay_data)
+        aligned = []
+        for meta, k, y in overlay_data:
+            if int(k[-1]) > min_max_k:
+                aligned.append((meta, k[: min_max_k + 1], y[: min_max_k + 1]))
+            else:
+                aligned.append((meta, k, y))
+        plot_overlay(aligned, out_dir, normalize=True, logy=args.logy)
+
+    print(f"Done. Plots written to: {out_dir}")
+
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/scripts_plot_hash_bucket_histograms_Version3.py b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/scripts_plot_hash_bucket_histograms_Version3.py
new file mode 100644
index 00000000..3f0146d0
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/scripts_plot_hash_bucket_histograms_Version3.py
@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""
+Reads per-algorithm per-bucket counts exported by NonCryptographicHashQualityStateKeyTest
+and plots bucket-occupancy histograms suitable for comparing hash quality.
+
+Input format (per algorithm):
+  - <ALG>.meta.json         : metadata with fields {algorithm, numBuckets, numInputs, countsFile, countsDtype, endianness}
+  - <ALG>_counts_i32_le.bin : little-endian int32 array of length numBuckets with counts per bucket
+
+Usage:
+  python scripts/plot_hash_bucket_histograms.py /path/to/hash_quality_results/run_YYYYMMDD_HHMMSSZ
+      [--max-k 400] [--overlay] [--logy]
+      [--dpi 300] [--figsize 12x7] [--format svg] [--transparent] [--tight]
+
+Outputs:
+  - One image per algorithm: hist_<ALG>.<format>
+  - If --overlay: a combined overlay image: hist_overlay.<format>
+"""
+import argparse
+import glob
+import json
+import math
+from pathlib import Path
+from typing import Dict, Any, List, Tuple
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+def load_algorithm(meta_path: Path) -> Tuple[Dict[str, Any], np.ndarray]:
+    with open(meta_path, "r", encoding="utf-8") as f:
+        meta = json.load(f)
+    counts_file = meta_path.parent / meta["countsFile"]
+    dtype = np.int32
+    if str(meta.get("endianness", "little")).lower().startswith("little"):
+        dtype = np.dtype("<i4")
+    elif str(meta.get("endianness", "little")).lower().startswith("big"):
+        dtype = np.dtype(">i4")
+    counts = np.fromfile(counts_file, dtype=dtype)
+    if counts.size != int(meta["numBuckets"]):
+        raise ValueError(f"Counts size {counts.size} != numBuckets {meta['numBuckets']} for {meta_path}")
+    return meta, counts
+
+
+def poisson_expected_counts(max_k: int, lam: float, num_buckets: int) -> np.ndarray:
+    """
+    Compute expected number of buckets with exactly k items for k=0..max_k under Poisson(lam).
+    Uses stable recurrence: P(k+1) = P(k) * lam / (k+1)
+    """
+    exp_counts = np.zeros(max_k + 1, dtype=np.float64)
+    p = math.exp(-lam)  # P(0)
+    exp_counts[0] = p * num_buckets
+    for k in range(0, max_k):
+        p = p * lam / (k + 1)
+        exp_counts[k + 1] = p * num_buckets
+    return exp_counts
+
+
+def compute_hist(counts: np.ndarray, max_k: int = None) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Returns (k_values, num_buckets_with_k) for k in [0..max_k]
+    """
+    hist = np.bincount(counts.astype(np.int64))
+    if max_k is None:
+        max_k = len(hist) - 1
+    else:
+        max_k = min(max_k, len(hist) - 1)
+    k = np.arange(0, max_k + 1, dtype=np.int64)
+    y = hist[: (max_k + 1)]
+    return k, y
+
+
+def plot_per_algorithm(
+    meta: Dict[str, Any],
+    k: np.ndarray,
+    y: np.ndarray,
+    out_dir: Path,
+    show_poisson: bool = True,
+    logy: bool = False,
+    figsize: Tuple[float, float] = (10.0, 6.0),
+    dpi: int = 300,
+    fmt: str = "png",
+    transparent: bool = False,
+    tight: bool = False,
+):
+    alg = meta["algorithm"]
+    num_buckets = int(meta["numBuckets"])
+    num_inputs = int(meta["numInputs"])
+    lam = num_inputs / num_buckets
+
+    fig, ax = plt.subplots(figsize=figsize)
+    ax.bar(k, y, width=1.0, color="#4e79a7", alpha=0.7, label=f"Observed ({alg})", edgecolor="none")
+
+    if show_poisson:
+        y_exp = poisson_expected_counts(k.max(), lam, num_buckets)
+        ax.plot(k, y_exp, color="#e15759", linewidth=2.0, label=f"Poisson λ={lam:.2f}")
+
+    ax.set_title(f"Bucket occupancy histogram — {alg}\n(numInputs={num_inputs:,}, numBuckets={num_buckets:,}, λ≈{lam:.2f})")
+    ax.set_xlabel("Items per bucket (k)")
+    ax.set_ylabel("Number of buckets with exactly k items")
+    if logy:
+        ax.set_yscale("log")
+        ax.set_ylabel("Number of buckets (log scale)")
+    ax.grid(True, which="both", axis="y", linestyle=":", alpha=0.5)
+    ax.legend()
+    if tight:
+        fig.tight_layout()
+
+    out_path = out_dir / f"hist_{sanitize_filename(alg)}.{fmt}"
+    fig.savefig(out_path, dpi=dpi, format=fmt, transparent=transparent, bbox_inches="tight" if tight else None)
+    plt.close(fig)
+
+
+def plot_overlay(
+    alg_results: List[Tuple[Dict[str, Any], np.ndarray, np.ndarray]],
+    out_dir: Path,
+    normalize: bool = True,
+    logy: bool = False,
+    figsize: Tuple[float, float] = (11.0, 7.0),
+    dpi: int = 300,
+    fmt: str = "png",
+    transparent: bool = False,
+    tight: bool = False,
+):
+    """
+    Overlays histograms as lines for quick comparison.
+    If normalize=True, y is fraction of buckets instead of absolute count.
+    """
+    fig, ax = plt.subplots(figsize=figsize)
+    for meta, k, y in alg_results:
+        label = meta["algorithm"]
+        if normalize:
+            y_plot = y / y.sum() if y.sum() > 0 else y
+            ax.set_ylabel("Fraction of buckets with exactly k items")
+        else:
+            y_plot = y
+            ax.set_ylabel("Number of buckets with exactly k items")
+        ax.plot(k, y_plot, linewidth=1.8, label=label)
+    ax.set_xlabel("Items per bucket (k)")
+    if logy:
+        ax.set_yscale("log")
+    ax.set_title("Bucket occupancy histograms — overlay")
+    ax.grid(True, which="both", axis="y", linestyle=":", alpha=0.5)
+    ax.legend()
+    if tight:
+        fig.tight_layout()
+    out_path = out_dir / f"hist_overlay.{fmt}"
+    fig.savefig(out_path, dpi=dpi, format=fmt, transparent=transparent, bbox_inches="tight" if tight else None)
+    plt.close(fig)
+
+
+def sanitize_filename(s: str) -> str:
+    return "".join(c if c.isalnum() or c in "._-" else "_" for c in s)
+
+
+def parse_figsize(s: str) -> Tuple[float, float]:
+    try:
+        w, h = s.lower().replace(" ", "").split("x", 1)
+        return float(w), float(h)
+    except Exception:
+        raise argparse.ArgumentTypeError("figsize must be in the form WIDTHxHEIGHT, e.g., 12x7")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("results_dir", type=str, help="Path to run directory (hash_quality_results/run_YYYYMMDD_HHMMSSZ)")
+    parser.add_argument("--max-k", type=int, default=None, help="Maximum k to plot (default: auto up to max observed)")
+    parser.add_argument("--overlay", action="store_true", help="Also produce a combined overlay plot")
+    parser.add_argument("--logy", action="store_true", help="Use logarithmic y-axis")
+
+    # Export/quality options
+    parser.add_argument("--dpi", type=int, default=300, help="Output DPI for raster formats (PNG/JPG). Default: 300")
+    parser.add_argument("--figsize", type=parse_figsize, default=(10.0, 6.0),
+                        help="Figure size in inches as WxH, e.g., 12x7. Default: 10x6")
+    parser.add_argument("--overlay-figsize", type=parse_figsize, default=(11.0, 7.0),
+                        help="Overlay figure size in inches as WxH. Default: 11x7")
+    parser.add_argument("--format", type=str, default="png",
+                        choices=["png", "svg", "pdf", "jpg", "jpeg"],
+                        help="Output image format. For infinite scalability, use svg or pdf. Default: png")
+    parser.add_argument("--transparent", action="store_true", help="Save with transparent background")
+    parser.add_argument("--tight", action="store_true", help="Use tight layout and bbox_inches='tight'")
+    args = parser.parse_args()
+
+    run_dir = Path(args.results_dir)
+    if not run_dir.exists():
+        raise SystemExit(f"Directory not found: {run_dir}")
+
+    meta_files = sorted(glob.glob(str(run_dir / "*.meta.json")))
+    if not meta_files:
+        raise SystemExit(f"No *.meta.json files found in {run_dir}")
+
+    # Create an output subdir for plots
+    out_dir = run_dir / "plots"
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    overlay_data: List[Tuple[Dict[str, Any], np.ndarray, np.ndarray]] = []
+
+    for meta_path_str in meta_files:
+        meta_path = Path(meta_path_str)
+        meta, counts = load_algorithm(meta_path)
+        k, y = compute_hist(counts, max_k=args.max_k)
+        plot_per_algorithm(
+            meta, k, y, out_dir,
+            show_poisson=True, logy=args.logy,
+            figsize=args.figsize, dpi=args.dpi, fmt=args.format,
+            transparent=args.transparent, tight=args.tight
+        )
+        overlay_data.append((meta, k, y))
+
+    if args.overlay:
+        # Align k-range across algorithms to the minimum common max_k
+        min_max_k = min(int(k[-1]) for _, k, _ in overlay_data)
+        aligned = []
+        for meta, k, y in overlay_data:
+            if int(k[-1]) > min_max_k:
+                aligned.append((meta, k[: min_max_k + 1], y[: min_max_k + 1]))
+            else:
+                aligned.append((meta, k, y))
+        plot_overlay(
+            aligned, out_dir,
+            normalize=True, logy=args.logy,
+            figsize=args.overlay_figsize, dpi=args.dpi, fmt=args.format,
+            transparent=args.transparent, tight=args.tight
+        )
+
+    print(f"Done. Plots written to: {out_dir}")
+
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/pbj-integration-tests/src/main/proto/teststate.proto b/pbj-integration-tests/src/main/proto/teststate.proto
new file mode 100644
index 00000000..4ab79e29
--- /dev/null
+++ b/pbj-integration-tests/src/main/proto/teststate.proto
@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+syntax = "proto3";
+
+package proto;
+
+import "basic_types.proto";
+import "state/common.proto";
+
+option java_package = "com.hedera.pbj.test.proto.java.teststate";
+option java_multiple_files = true;
+// <<<pbj.java_package = "com.hedera.pbj.test.proto.pbj.teststate">>> This comment is special code for setting PBJ Compiler java package
+
+message StateKey {
+  oneof key {
+    AccountID account_id = 1;
+    TokenID token_id = 2;
+    EntityIDPair entity_id_pair = 3;
+    NftID nft_id = 4;
+  }
+}

From 067152a9343c647e8e7b8d8d339694533d5de656 Mon Sep 17 00:00:00 2001
From: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
Date: Tue, 12 Aug 2025 10:25:40 -0700
Subject: [PATCH 16/17] Added missing file

Signed-off-by: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
---
 .../jmh/hashing/functions/LuceneMurmur3.java  | 215 ++++++++++++++++++
 1 file changed, 215 insertions(+)
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/LuceneMurmur3.java

diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/LuceneMurmur3.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/LuceneMurmur3.java
new file mode 100644
index 00000000..7b35f59d
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/LuceneMurmur3.java
@@ -0,0 +1,215 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+
+/**
+ * MurmurHash3 is a port of the MurmurHash3 algorithm, which is a non-cryptographic hash function. From Apache Lucene
+ * project.
+ *
+ * @see <a href="https://github.com/apache/lucene/blob/78a622d6075b785b5e5e10eb0be7c17e641204ea/lucene/core/src/java/org/apache/lucene/util/StringHelper.java">
+ * Apache Lucene StringHelper</a>
+ */
+public abstract class LuceneMurmur3 {
+    private static final int SEED = 1; // Default seed value
+    private static final VarHandle VH_LE_LONG =
+            MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.LITTLE_ENDIAN);
+    private static final VarHandle VH_LE_INT =
+            MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN);
+    /**
+     * Returns the MurmurHash3_x86_32 hash. Original source/tests at
+     * <a href="https://github.com/yonik/java_util/">...</a>
+     */
+    @SuppressWarnings("fallthrough")
+    public static int murmurhash3_x86_32(byte[] data, int offset, int len) {
+        final int c1 = 0xcc9e2d51;
+        final int c2 = 0x1b873593;
+
+        int h1 = SEED;
+        int roundedEnd = offset + (len & 0xfffffffc); // round down to 4 byte block
+
+        for (int i = offset; i < roundedEnd; i += 4) {
+            // little endian load order
+            int k1 = (int) VH_LE_INT.get(data, i);
+            k1 *= c1;
+            k1 = Integer.rotateLeft(k1, 15);
+            k1 *= c2;
+
+            h1 ^= k1;
+            h1 = Integer.rotateLeft(h1, 13);
+            h1 = h1 * 5 + 0xe6546b64;
+        }
+
+        // tail
+        int k1 = 0;
+
+        switch (len & 0x03) {
+            case 3:
+                k1 = (data[roundedEnd + 2] & 0xff) << 16;
+            // fallthrough
+            case 2:
+                k1 |= (data[roundedEnd + 1] & 0xff) << 8;
+            // fallthrough
+            case 1:
+                k1 |= (data[roundedEnd] & 0xff);
+                k1 *= c1;
+                k1 = Integer.rotateLeft(k1, 15);
+                k1 *= c2;
+                h1 ^= k1;
+        }
+
+        // finalization
+        h1 ^= len;
+
+        // fmix(h1);
+        h1 ^= h1 >>> 16;
+        h1 *= 0x85ebca6b;
+        h1 ^= h1 >>> 13;
+        h1 *= 0xc2b2ae35;
+        h1 ^= h1 >>> 16;
+
+        return h1;
+    }
+
+    /**
+     * Generates 128-bit hash from the byte array with the given offset, length and seed.
+     *
+     * <p>The code is adopted from Apache Commons (<a
+     * href="https://commons.apache.org/proper/commons-codec/jacoco/org.apache.commons.codec.digest/MurmurHash3.java.html">link</a>)
+     *
+     * @param data The input byte array
+     * @param offset The first element of array
+     * @param length The length of array
+     * @param seed The initial seed value
+     * @return The 128-bit hash (2 longs)
+     */
+    public static long[] murmurhash3_x64_128(final byte[] data, final int offset, final int length, final int seed) {
+        // Use an unsigned 32-bit integer as the seed
+        return murmurhash3_x64_128(data, offset, length, seed & 0xFFFFFFFFL);
+    }
+
+    public static long murmurhash3_x64_128(final byte[] data, final int offset, final int length) {
+        // Use an unsigned 32-bit integer as the seed
+        return murmurhash3_x64_128(data, offset, length, SEED & 0xFFFFFFFFL)[0];
+    }
+
+    @SuppressWarnings("fallthrough")
+    private static long[] murmurhash3_x64_128(final byte[] data, final int offset, final int length, final long seed) {
+        long h1 = seed;
+        long h2 = seed;
+        final int nblocks = length >> 4;
+
+        // Constants for 128-bit variant
+        final long C1 = 0x87c37b91114253d5L;
+        final long C2 = 0x4cf5ad432745937fL;
+        final int R1 = 31;
+        final int R2 = 27;
+        final int R3 = 33;
+        final int M = 5;
+        final int N1 = 0x52dce729;
+        final int N2 = 0x38495ab5;
+
+        // body
+        for (int i = 0; i < nblocks; i++) {
+            final int index = offset + (i << 4);
+            long k1 = (long) VH_LE_LONG.get(data, index);
+            long k2 = (long) VH_LE_LONG.get(data, index + 8);
+
+            // mix functions for k1
+            k1 *= C1;
+            k1 = Long.rotateLeft(k1, R1);
+            k1 *= C2;
+            h1 ^= k1;
+            h1 = Long.rotateLeft(h1, R2);
+            h1 += h2;
+            h1 = h1 * M + N1;
+
+            // mix functions for k2
+            k2 *= C2;
+            k2 = Long.rotateLeft(k2, R3);
+            k2 *= C1;
+            h2 ^= k2;
+            h2 = Long.rotateLeft(h2, R1);
+            h2 += h1;
+            h2 = h2 * M + N2;
+        }
+
+        // tail
+        long k1 = 0;
+        long k2 = 0;
+        final int index = offset + (nblocks << 4);
+        switch (length & 0x0F) {
+            case 15:
+                k2 ^= ((long) data[index + 14] & 0xff) << 48;
+            case 14:
+                k2 ^= ((long) data[index + 13] & 0xff) << 40;
+            case 13:
+                k2 ^= ((long) data[index + 12] & 0xff) << 32;
+            case 12:
+                k2 ^= ((long) data[index + 11] & 0xff) << 24;
+            case 11:
+                k2 ^= ((long) data[index + 10] & 0xff) << 16;
+            case 10:
+                k2 ^= ((long) data[index + 9] & 0xff) << 8;
+            case 9:
+                k2 ^= data[index + 8] & 0xff;
+                k2 *= C2;
+                k2 = Long.rotateLeft(k2, R3);
+                k2 *= C1;
+                h2 ^= k2;
+
+            case 8:
+                k1 ^= ((long) data[index + 7] & 0xff) << 56;
+            case 7:
+                k1 ^= ((long) data[index + 6] & 0xff) << 48;
+            case 6:
+                k1 ^= ((long) data[index + 5] & 0xff) << 40;
+            case 5:
+                k1 ^= ((long) data[index + 4] & 0xff) << 32;
+            case 4:
+                k1 ^= ((long) data[index + 3] & 0xff) << 24;
+            case 3:
+                k1 ^= ((long) data[index + 2] & 0xff) << 16;
+            case 2:
+                k1 ^= ((long) data[index + 1] & 0xff) << 8;
+            case 1:
+                k1 ^= data[index] & 0xff;
+                k1 *= C1;
+                k1 = Long.rotateLeft(k1, R1);
+                k1 *= C2;
+                h1 ^= k1;
+        }
+
+        // finalization
+        h1 ^= length;
+        h2 ^= length;
+
+        h1 += h2;
+        h2 += h1;
+
+        h1 = fmix64(h1);
+        h2 = fmix64(h2);
+
+        h1 += h2;
+        h2 += h1;
+
+        return new long[] {h1, h2};
+    }
+
+    /**
+     * Performs the final avalanche mix step of the 64-bit hash function.
+     *
+     * @param hash The current hash
+     * @return The final hash
+     */
+    private static long fmix64(long hash) {
+        hash ^= (hash >>> 33);
+        hash *= 0xff51afd7ed558ccdL;
+        hash ^= (hash >>> 33);
+        hash *= 0xc4ceb9fe1a85ec53L;
+        hash ^= (hash >>> 33);
+        return hash;
+    }
+}

From 601cd94b1375e18522301293f265eb6b7d60677c Mon Sep 17 00:00:00 2001
From: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
Date: Mon, 18 Aug 2025 16:52:12 -0700
Subject: [PATCH 17/17] Added more code and tests

Signed-off-by: Jasper Potts <1466205+jasperpotts@users.noreply.github.com>
---
 .../runtime/hashing/AbstractHashStream.java   | 1365 +++++++++++++++++
 .../pbj/runtime/hashing/ByteArrayUtil.java    |  147 ++
 .../hedera/pbj/runtime/hashing/HashSink.java  |  571 +++++++
 .../pbj/runtime/hashing/HashStream.java       |  127 ++
 .../hedera/pbj/runtime/hashing/XXH3_64.java   | 1001 ++++++++++++
 pbj-integration-tests/build.gradle.kts        |   15 +-
 .../gradle/modules.properties                 |    6 +
 .../hashing/NonCryptographicHashingBench.java |   19 +-
 .../pbj/integration/jmh/hashing/XxhTest.java  |  107 ++
 .../jmh/hashing/functions/CityHash.java       |    8 +
 .../jmh/hashing/functions/Hash4j.java         |   29 +
 .../jmh/hashing/functions/XXH3OpenHFT2.java   |   11 +-
 .../jmh/hashing/functions/XxHash.java         |    3 +
 .../jmh/hashing/functions/Xxh3AiCPort.java    |  264 ++++
 .../jmh/hashing/functions/Xxh3Lz4.java        |   20 +
 .../hashing/functions/XxhSumCommandLine.java  |   79 +
 ...nCryptographicHashQualityStateKeyTest.java |    2 +-
 17 files changed, 3765 insertions(+), 9 deletions(-)
 create mode 100644 pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/AbstractHashStream.java
 create mode 100644 pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/ByteArrayUtil.java
 create mode 100644 pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/HashSink.java
 create mode 100644 pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/HashStream.java
 create mode 100644 pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/XXH3_64.java
 create mode 100644 pbj-integration-tests/gradle/modules.properties
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/XxhTest.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Hash4j.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Xxh3AiCPort.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Xxh3Lz4.java
 create mode 100644 pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XxhSumCommandLine.java

diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/AbstractHashStream.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/AbstractHashStream.java
new file mode 100644
index 00000000..56ccfdb2
--- /dev/null
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/AbstractHashStream.java
@@ -0,0 +1,1365 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.runtime.hashing;
+
+import static com.hedera.pbj.runtime.hashing.ByteArrayUtil.getChar;
+import static com.hedera.pbj.runtime.hashing.ByteArrayUtil.getInt;
+import static com.hedera.pbj.runtime.hashing.ByteArrayUtil.getLong;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+import java.util.function.ToLongFunction;
+
+interface AbstractHashStream extends HashStream {
+
+    @Override
+    default HashStream putBoolean(boolean v) {
+        putByte((byte) (v ? 1 : 0));
+        return this;
+    }
+
+    @Override
+    default HashStream putBooleans(boolean[] x) {
+        return putBooleans(x, 0, x.length);
+    }
+
+    @Override
+    default HashStream putBooleans(boolean[] x, int off, int len) {
+        int end = len + off;
+        while (off <= end - 8) {
+            long b0 = (x[off] ? 1L : 0L) << (0);
+            long b1 = (x[off + 1] ? 1L : 0L) << (8);
+            long b2 = (x[off + 2] ? 1L : 0L) << (8 * 2);
+            long b3 = (x[off + 3] ? 1L : 0L) << (8 * 3);
+            long b4 = (x[off + 4] ? 1L : 0L) << (8 * 4);
+            long b5 = (x[off + 5] ? 1L : 0L) << (8 * 5);
+            long b6 = (x[off + 6] ? 1L : 0L) << (8 * 6);
+            long b7 = (x[off + 7] ? 1L : 0L) << (8 * 7);
+            putLong(b0 | b1 | b2 | b3 | b4 | b5 | b6 | b7);
+            off += 8;
+        }
+        if (off <= end - 4) {
+            int b0 = (x[off] ? 1 : 0) << (0);
+            int b1 = (x[off + 1] ? 1 : 0) << (8);
+            int b2 = (x[off + 2] ? 1 : 0) << (8 * 2);
+            int b3 = (x[off + 3] ? 1 : 0) << (8 * 3);
+            putInt(b0 | b1 | b2 | b3);
+            off += 4;
+        }
+        if (off <= end - 2) {
+            int b0 = (x[off] ? 1 : 0) << (0);
+            int b1 = (x[off + 1] ? 1 : 0) << (8);
+            putChar((char) (b0 | b1));
+            off += 2;
+        }
+        if (off < end) {
+            putBoolean(x[off]);
+        }
+        return this;
+    }
+
+    @Override
+    default HashStream putBooleanArray(boolean[] x) {
+        return putBooleans(x).putInt(x.length);
+    }
+
+    @Override
+    default HashStream putBytes(byte[] b) {
+        putBytes(b, 0, b.length);
+        return this;
+    }
+
+    @Override
+    default HashStream putBytes(byte[] b, int off, int len) {
+        int end = len + off;
+        while (off <= end - 8) {
+            putLong(getLong(b, off));
+            off += 8;
+        }
+        if (off <= end - 4) {
+            putInt(getInt(b, off));
+            off += 4;
+        }
+        if (off <= end - 2) {
+            putChar(getChar(b, off));
+            off += 2;
+        }
+        if (off < end) {
+            putByte(b[off]);
+        }
+        return this;
+    }
+
+    @Override
+    default HashStream putByteArray(byte[] x) {
+        return putBytes(x).putInt(x.length);
+    }
+
+    @Override
+    default HashStream putChar(char v) {
+        putShort((short) v);
+        return this;
+    }
+
+    @Override
+    default HashStream putChars(char[] x) {
+        return putChars(x, 0, x.length);
+    }
+
+    @Override
+    default HashStream putChars(char[] x, int off, int len) {
+        int end = len + off;
+        while (off <= end - 4) {
+            long b0 = (long) x[off] << (0);
+            long b1 = (long) x[off + 1] << (16);
+            long b2 = (long) x[off + 2] << (16 * 2);
+            long b3 = (long) x[off + 3] << (16 * 3);
+            putLong(b0 | b1 | b2 | b3);
+            off += 4;
+        }
+        if (off <= end - 2) {
+            int b0 = x[off] << (0);
+            int b1 = x[off + 1] << (16);
+            putInt(b0 | b1);
+            off += 2;
+        }
+        if (off < end) {
+            putChar(x[off]);
+        }
+        return this;
+    }
+
+    @Override
+    default HashStream putChars(CharSequence s) {
+        int end = s.length();
+        int off = 0;
+        while (off <= end - 4) {
+            putLong(getLong(s, off));
+            off += 4;
+        }
+        if (off <= end - 2) {
+            putInt(getInt(s, off));
+            off += 2;
+        }
+        if (off < end) {
+            putChar(s.charAt(off));
+        }
+        return this;
+    }
+
+    @Override
+    default HashStream putCharArray(char[] x) {
+        return putChars(x).putInt(x.length);
+    }
+
+    @Override
+    default HashStream putString(String s) {
+        putChars(s);
+        putInt(s.length());
+        return this;
+    }
+
+    @Override
+    default HashStream putShort(short v) {
+        putByte((byte) v);
+        putByte((byte) (v >>> 8));
+        return this;
+    }
+
+    @Override
+    default HashStream putShortArray(short[] x) {
+        return putShorts(x).putInt(x.length);
+    }
+
+    @Override
+    default HashStream putShorts(short[] x) {
+        return putShorts(x, 0, x.length);
+    }
+
+    @Override
+    default HashStream putShorts(short[] x, int off, int len) {
+        int end = off + len;
+        while (off <= end - 4) {
+            long b0 = (x[off] & 0xFFFFL) << (0);
+            long b1 = (x[off + 1] & 0xFFFFL) << (16);
+            long b2 = (x[off + 2] & 0xFFFFL) << (16 * 2);
+            long b3 = (x[off + 3] & 0xFFFFL) << (16 * 3);
+            putLong(b0 | b1 | b2 | b3);
+            off += 4;
+        }
+        if (off <= end - 2) {
+            int b0 = (x[off] & 0xFFFF) << (0);
+            int b1 = (x[off + 1] & 0xFFFF) << (16);
+            putInt(b0 | b1);
+            off += 2;
+        }
+        if (off < end) {
+            putShort(x[off]);
+        }
+        return this;
+    }
+
+    @Override
+    default HashStream putInt(int v) {
+        putByte((byte) v);
+        putByte((byte) (v >>> 8));
+        putByte((byte) (v >>> 16));
+        putByte((byte) (v >>> 24));
+        return this;
+    }
+
+    @Override
+    default HashStream putIntArray(int[] x) {
+        return putInts(x).putInt(x.length);
+    }
+
+    @Override
+    default HashStream putInts(int[] x) {
+        return putInts(x, 0, x.length);
+    }
+
+    @Override
+    default HashStream putInts(int[] x, int off, int len) {
+        int end = off + len;
+        while (off <= end - 2) {
+            long b0 = x[off] & 0xFFFFFFFFL;
+            long b1 = (long) x[off + 1] << 32;
+            putLong(b0 | b1);
+            off += 2;
+        }
+        if (off < end) {
+            putInt(x[off]);
+        }
+        return this;
+    }
+
+    @Override
+    default HashStream putLong(long v) {
+        putInt((int) v);
+        putInt((int) (v >> 32));
+        return this;
+    }
+
+    @Override
+    default HashStream putLongArray(long[] x) {
+        return putLongs(x).putInt(x.length);
+    }
+
+    @Override
+    default HashStream putLongs(long[] x) {
+        return putLongs(x, 0, x.length);
+    }
+
+    @Override
+    default HashStream putLongs(long[] x, int off, int len) {
+        for (int i = 0; i < len; ++i) {
+            putLong(x[off + i]);
+        }
+        return this;
+    }
+
+    @Override
+    default HashStream putFloat(float v) {
+        putInt(Float.floatToRawIntBits(v));
+        return this;
+    }
+
+    @Override
+    default HashStream putFloats(float[] x) {
+        return putFloats(x, 0, x.length);
+    }
+
+    @Override
+    default HashStream putFloats(float[] x, int off, int len) {
+        int end = off + len;
+        while (off <= end - 2) {
+            long b0 = Float.floatToRawIntBits(x[off]) & 0xFFFFFFFFL;
+            long b1 = (long) Float.floatToRawIntBits(x[off + 1]) << 32;
+            putLong(b0 | b1);
+            off += 2;
+        }
+        if (off < end) {
+            putFloat(x[off]);
+        }
+        return this;
+    }
+
+    @Override
+    default HashStream putFloatArray(float[] x) {
+        return putFloats(x).putInt(x.length);
+    }
+
+    @Override
+    default HashStream putDouble(double v) {
+        putLong(Double.doubleToRawLongBits(v));
+        return this;
+    }
+
+    @Override
+    default HashStream putDoubleArray(double[] x) {
+        return putDoubles(x).putInt(x.length);
+    }
+
+    @Override
+    default HashStream putDoubles(double[] x) {
+        return putDoubles(x, 0, x.length);
+    }
+
+    @Override
+    default HashStream putDoubles(double[] x, int off, int len) {
+        for (int i = 0; i < len; ++i) {
+            putDouble(x[off + i]);
+        }
+        return this;
+    }
+
+    private void putSorted(long l0, long l1) {
+        if (l1 <= l0) {
+            long t = l0;
+            l0 = l1;
+            l1 = t;
+        }
+        putLong(l0);
+        putLong(l1);
+    }
+
+    private void putSorted(long l0, long l1, long l2) {
+        if (l0 > l1) {
+            long t = l0;
+            l0 = l1;
+            l1 = t;
+        }
+        if (l0 > l2) {
+            long t = l0;
+            l0 = l2;
+            l2 = t;
+        }
+        if (l1 > l2) {
+            long t = l1;
+            l1 = l2;
+            l2 = t;
+        }
+        putLong(l0);
+        putLong(l1);
+        putLong(l2);
+    }
+
+    private void putSorted(long l0, long l1, long l2, long l3) {
+        if (l0 > l1) {
+            long t = l0;
+            l0 = l1;
+            l1 = t;
+        }
+        if (l2 > l3) {
+            long t = l2;
+            l2 = l3;
+            l3 = t;
+        }
+        if (l0 > l2) {
+            long t = l0;
+            l0 = l2;
+            l2 = t;
+        }
+        if (l1 > l3) {
+            long t = l1;
+            l1 = l3;
+            l3 = t;
+        }
+        if (l1 > l2) {
+            long t = l1;
+            l1 = l2;
+            l2 = t;
+        }
+        putLong(l0);
+        putLong(l1);
+        putLong(l2);
+        putLong(l3);
+    }
+
+    private void putSorted(long l0, long l1, long l2, long l3, long l4) {
+        // generated from http://pages.ripco.net/~jgamble/nw.html
+        if (l0 > l1) {
+            long t = l0;
+            l0 = l1;
+            l1 = t;
+        }
+        if (l3 > l4) {
+            long t = l3;
+            l3 = l4;
+            l4 = t;
+        }
+        if (l2 > l4) {
+            long t = l2;
+            l2 = l4;
+            l4 = t;
+        }
+        if (l2 > l3) {
+            long t = l2;
+            l2 = l3;
+            l3 = t;
+        }
+        if (l1 > l4) {
+            long t = l1;
+            l1 = l4;
+            l4 = t;
+        }
+        if (l0 > l3) {
+            long t = l0;
+            l0 = l3;
+            l3 = t;
+        }
+        if (l0 > l2) {
+            long t = l0;
+            l0 = l2;
+            l2 = t;
+        }
+        if (l1 > l3) {
+            long t = l1;
+            l1 = l3;
+            l3 = t;
+        }
+        if (l1 > l2) {
+            long t = l1;
+            l1 = l2;
+            l2 = t;
+        }
+        putLong(l0);
+        putLong(l1);
+        putLong(l2);
+        putLong(l3);
+        putLong(l4);
+    }
+
+    private void putSorted(long l0, long l1, long l2, long l3, long l4, long l5) {
+        // generated from http://pages.ripco.net/~jgamble/nw.html
+        if (l1 > l2) {
+            long t = l1;
+            l1 = l2;
+            l2 = t;
+        }
+        if (l4 > l5) {
+            long t = l4;
+            l4 = l5;
+            l5 = t;
+        }
+        if (l0 > l2) {
+            long t = l0;
+            l0 = l2;
+            l2 = t;
+        }
+        if (l3 > l5) {
+            long t = l3;
+            l3 = l5;
+            l5 = t;
+        }
+        if (l0 > l1) {
+            long t = l0;
+            l0 = l1;
+            l1 = t;
+        }
+        if (l3 > l4) {
+            long t = l3;
+            l3 = l4;
+            l4 = t;
+        }
+        if (l2 > l5) {
+            long t = l2;
+            l2 = l5;
+            l5 = t;
+        }
+        if (l0 > l3) {
+            long t = l0;
+            l0 = l3;
+            l3 = t;
+        }
+        if (l1 > l4) {
+            long t = l1;
+            l1 = l4;
+            l4 = t;
+        }
+        if (l2 > l4) {
+            long t = l2;
+            l2 = l4;
+            l4 = t;
+        }
+        if (l1 > l3) {
+            long t = l1;
+            l1 = l3;
+            l3 = t;
+        }
+        if (l2 > l3) {
+            long t = l2;
+            l2 = l3;
+            l3 = t;
+        }
+        putLong(l0);
+        putLong(l1);
+        putLong(l2);
+        putLong(l3);
+        putLong(l4);
+        putLong(l5);
+    }
+
+    private void putSorted(long l0, long l1, long l2, long l3, long l4, long l5, long l6) {
+        // generated from http://pages.ripco.net/~jgamble/nw.html
+        if (l1 > l2) {
+            long t = l1;
+            l1 = l2;
+            l2 = t;
+        }
+        if (l3 > l4) {
+            long t = l3;
+            l3 = l4;
+            l4 = t;
+        }
+        if (l5 > l6) {
+            long t = l5;
+            l5 = l6;
+            l6 = t;
+        }
+        if (l0 > l2) {
+            long t = l0;
+            l0 = l2;
+            l2 = t;
+        }
+        if (l3 > l5) {
+            long t = l3;
+            l3 = l5;
+            l5 = t;
+        }
+        if (l4 > l6) {
+            long t = l4;
+            l4 = l6;
+            l6 = t;
+        }
+        if (l0 > l1) {
+            long t = l0;
+            l0 = l1;
+            l1 = t;
+        }
+        if (l4 > l5) {
+            long t = l4;
+            l4 = l5;
+            l5 = t;
+        }
+        if (l2 > l6) {
+            long t = l2;
+            l2 = l6;
+            l6 = t;
+        }
+        if (l0 > l4) {
+            long t = l0;
+            l0 = l4;
+            l4 = t;
+        }
+        if (l1 > l5) {
+            long t = l1;
+            l1 = l5;
+            l5 = t;
+        }
+        if (l0 > l3) {
+            long t = l0;
+            l0 = l3;
+            l3 = t;
+        }
+        if (l2 > l5) {
+            long t = l2;
+            l2 = l5;
+            l5 = t;
+        }
+        if (l1 > l3) {
+            long t = l1;
+            l1 = l3;
+            l3 = t;
+        }
+        if (l2 > l4) {
+            long t = l2;
+            l2 = l4;
+            l4 = t;
+        }
+        if (l2 > l3) {
+            long t = l2;
+            l2 = l3;
+            l3 = t;
+        }
+        putLong(l0);
+        putLong(l1);
+        putLong(l2);
+        putLong(l3);
+        putLong(l4);
+        putLong(l5);
+        putLong(l6);
+    }
+
+    private void putSorted(long l0, long l1, long l2, long l3, long l4, long l5, long l6, long l7) {
+        // generated from http://pages.ripco.net/~jgamble/nw.html
+        if (l0 > l1) {
+            long t = l0;
+            l0 = l1;
+            l1 = t;
+        }
+        if (l2 > l3) {
+            long t = l2;
+            l2 = l3;
+            l3 = t;
+        }
+        if (l4 > l5) {
+            long t = l4;
+            l4 = l5;
+            l5 = t;
+        }
+        if (l6 > l7) {
+            long t = l6;
+            l6 = l7;
+            l7 = t;
+        }
+        if (l0 > l2) {
+            long t = l0;
+            l0 = l2;
+            l2 = t;
+        }
+        if (l1 > l3) {
+            long t = l1;
+            l1 = l3;
+            l3 = t;
+        }
+        if (l4 > l6) {
+            long t = l4;
+            l4 = l6;
+            l6 = t;
+        }
+        if (l5 > l7) {
+            long t = l5;
+            l5 = l7;
+            l7 = t;
+        }
+        if (l1 > l2) {
+            long t = l1;
+            l1 = l2;
+            l2 = t;
+        }
+        if (l5 > l6) {
+            long t = l5;
+            l5 = l6;
+            l6 = t;
+        }
+        if (l0 > l4) {
+            long t = l0;
+            l0 = l4;
+            l4 = t;
+        }
+        if (l3 > l7) {
+            long t = l3;
+            l3 = l7;
+            l7 = t;
+        }
+        if (l1 > l5) {
+            long t = l1;
+            l1 = l5;
+            l5 = t;
+        }
+        if (l2 > l6) {
+            long t = l2;
+            l2 = l6;
+            l6 = t;
+        }
+        if (l1 > l4) {
+            long t = l1;
+            l1 = l4;
+            l4 = t;
+        }
+        if (l3 > l6) {
+            long t = l3;
+            l3 = l6;
+            l6 = t;
+        }
+        if (l2 > l4) {
+            long t = l2;
+            l2 = l4;
+            l4 = t;
+        }
+        if (l3 > l5) {
+            long t = l3;
+            l3 = l5;
+            l5 = t;
+        }
+        if (l3 > l4) {
+            long t = l3;
+            l3 = l4;
+            l4 = t;
+        }
+        putLong(l0);
+        putLong(l1);
+        putLong(l2);
+        putLong(l3);
+        putLong(l4);
+        putLong(l5);
+        putLong(l6);
+        putLong(l7);
+    }
+
+    private void putSorted(long l0, long l1, long l2, long l3, long l4, long l5, long l6, long l7, long l8) {
+        // generated from http://pages.ripco.net/~jgamble/nw.html
+        if (l0 > l1) {
+            long t = l0;
+            l0 = l1;
+            l1 = t;
+        }
+        if (l3 > l4) {
+            long t = l3;
+            l3 = l4;
+            l4 = t;
+        }
+        if (l6 > l7) {
+            long t = l6;
+            l6 = l7;
+            l7 = t;
+        }
+        if (l1 > l2) {
+            long t = l1;
+            l1 = l2;
+            l2 = t;
+        }
+        if (l4 > l5) {
+            long t = l4;
+            l4 = l5;
+            l5 = t;
+        }
+        if (l7 > l8) {
+            long t = l7;
+            l7 = l8;
+            l8 = t;
+        }
+        if (l0 > l1) {
+            long t = l0;
+            l0 = l1;
+            l1 = t;
+        }
+        if (l3 > l4) {
+            long t = l3;
+            l3 = l4;
+            l4 = t;
+        }
+        if (l6 > l7) {
+            long t = l6;
+            l6 = l7;
+            l7 = t;
+        }
+        if (l2 > l5) {
+            long t = l2;
+            l2 = l5;
+            l5 = t;
+        }
+        if (l0 > l3) {
+            long t = l0;
+            l0 = l3;
+            l3 = t;
+        }
+        if (l1 > l4) {
+            long t = l1;
+            l1 = l4;
+            l4 = t;
+        }
+        if (l5 > l8) {
+            long t = l5;
+            l5 = l8;
+            l8 = t;
+        }
+        if (l3 > l6) {
+            long t = l3;
+            l3 = l6;
+            l6 = t;
+        }
+        if (l4 > l7) {
+            long t = l4;
+            l4 = l7;
+            l7 = t;
+        }
+        if (l2 > l5) {
+            long t = l2;
+            l2 = l5;
+            l5 = t;
+        }
+        if (l0 > l3) {
+            long t = l0;
+            l0 = l3;
+            l3 = t;
+        }
+        if (l1 > l4) {
+            long t = l1;
+            l1 = l4;
+            l4 = t;
+        }
+        if (l5 > l7) {
+            long t = l5;
+            l5 = l7;
+            l7 = t;
+        }
+        if (l2 > l6) {
+            long t = l2;
+            l2 = l6;
+            l6 = t;
+        }
+        if (l1 > l3) {
+            long t = l1;
+            l1 = l3;
+            l3 = t;
+        }
+        if (l4 > l6) {
+            long t = l4;
+            l4 = l6;
+            l6 = t;
+        }
+        if (l2 > l4) {
+            long t = l2;
+            l2 = l4;
+            l4 = t;
+        }
+        if (l5 > l6) {
+            long t = l5;
+            l5 = l6;
+            l6 = t;
+        }
+        if (l2 > l3) {
+            long t = l2;
+            l2 = l3;
+            l3 = t;
+        }
+        putLong(l0);
+        putLong(l1);
+        putLong(l2);
+        putLong(l3);
+        putLong(l4);
+        putLong(l5);
+        putLong(l6);
+        putLong(l7);
+        putLong(l8);
+    }
+
+    private void putSorted(long l0, long l1, long l2, long l3, long l4, long l5, long l6, long l7, long l8, long l9) {
+        // generated from http://pages.ripco.net/~jgamble/nw.html
+        if (l4 > l9) {
+            long t = l4;
+            l4 = l9;
+            l9 = t;
+        }
+        if (l3 > l8) {
+            long t = l3;
+            l3 = l8;
+            l8 = t;
+        }
+        if (l2 > l7) {
+            long t = l2;
+            l2 = l7;
+            l7 = t;
+        }
+        if (l1 > l6) {
+            long t = l1;
+            l1 = l6;
+            l6 = t;
+        }
+        if (l0 > l5) {
+            long t = l0;
+            l0 = l5;
+            l5 = t;
+        }
+        if (l1 > l4) {
+            long t = l1;
+            l1 = l4;
+            l4 = t;
+        }
+        if (l6 > l9) {
+            long t = l6;
+            l6 = l9;
+            l9 = t;
+        }
+        if (l0 > l3) {
+            long t = l0;
+            l0 = l3;
+            l3 = t;
+        }
+        if (l5 > l8) {
+            long t = l5;
+            l5 = l8;
+            l8 = t;
+        }
+        if (l0 > l2) {
+            long t = l0;
+            l0 = l2;
+            l2 = t;
+        }
+        if (l3 > l6) {
+            long t = l3;
+            l3 = l6;
+            l6 = t;
+        }
+        if (l7 > l9) {
+            long t = l7;
+            l7 = l9;
+            l9 = t;
+        }
+        if (l0 > l1) {
+            long t = l0;
+            l0 = l1;
+            l1 = t;
+        }
+        if (l2 > l4) {
+            long t = l2;
+            l2 = l4;
+            l4 = t;
+        }
+        if (l5 > l7) {
+            long t = l5;
+            l5 = l7;
+            l7 = t;
+        }
+        if (l8 > l9) {
+            long t = l8;
+            l8 = l9;
+            l9 = t;
+        }
+        if (l1 > l2) {
+            long t = l1;
+            l1 = l2;
+            l2 = t;
+        }
+        if (l4 > l6) {
+            long t = l4;
+            l4 = l6;
+            l6 = t;
+        }
+        if (l7 > l8) {
+            long t = l7;
+            l7 = l8;
+            l8 = t;
+        }
+        if (l3 > l5) {
+            long t = l3;
+            l3 = l5;
+            l5 = t;
+        }
+        if (l2 > l5) {
+            long t = l2;
+            l2 = l5;
+            l5 = t;
+        }
+        if (l6 > l8) {
+            long t = l6;
+            l6 = l8;
+            l8 = t;
+        }
+        if (l1 > l3) {
+            long t = l1;
+            l1 = l3;
+            l3 = t;
+        }
+        if (l4 > l7) {
+            long t = l4;
+            l4 = l7;
+            l7 = t;
+        }
+        if (l2 > l3) {
+            long t = l2;
+            l2 = l3;
+            l3 = t;
+        }
+        if (l6 > l7) {
+            long t = l6;
+            l6 = l7;
+            l7 = t;
+        }
+        if (l3 > l4) {
+            long t = l3;
+            l3 = l4;
+            l4 = t;
+        }
+        if (l5 > l6) {
+            long t = l5;
+            l5 = l6;
+            l6 = t;
+        }
+        if (l4 > l5) {
+            long t = l4;
+            l4 = l5;
+            l5 = t;
+        }
+        putLong(l0);
+        putLong(l1);
+        putLong(l2);
+        putLong(l3);
+        putLong(l4);
+        putLong(l5);
+        putLong(l6);
+        putLong(l7);
+        putLong(l8);
+        putLong(l9);
+    }
+
+    private <T> void putUnorderedRandomAccessList(final List<T> data, final ToLongFunction<? super T> elementHasher) {
+
+        int size = data.size();
+
+        // for data sizes up to 10 there are fast implementations to avoid the allocation of an array
+        // used for sorting
+        switch (size) {
+            case 0:
+                break;
+            case 1:
+                {
+                    long elementHash0 = elementHasher.applyAsLong(data.getFirst());
+                    putLong(elementHash0);
+                }
+                break;
+            case 2:
+                {
+                    long elementHash0 = elementHasher.applyAsLong(data.get(0));
+                    long elementHash1 = elementHasher.applyAsLong(data.get(1));
+                    putSorted(elementHash0, elementHash1);
+                }
+                break;
+            case 3:
+                {
+                    long elementHash0 = elementHasher.applyAsLong(data.get(0));
+                    long elementHash1 = elementHasher.applyAsLong(data.get(1));
+                    long elementHash2 = elementHasher.applyAsLong(data.get(2));
+                    putSorted(elementHash0, elementHash1, elementHash2);
+                }
+                break;
+            case 4:
+                {
+                    long elementHash0 = elementHasher.applyAsLong(data.get(0));
+                    long elementHash1 = elementHasher.applyAsLong(data.get(1));
+                    long elementHash2 = elementHasher.applyAsLong(data.get(2));
+                    long elementHash3 = elementHasher.applyAsLong(data.get(3));
+                    putSorted(elementHash0, elementHash1, elementHash2, elementHash3);
+                }
+                break;
+            case 5:
+                {
+                    long elementHash0 = elementHasher.applyAsLong(data.get(0));
+                    long elementHash1 = elementHasher.applyAsLong(data.get(1));
+                    long elementHash2 = elementHasher.applyAsLong(data.get(2));
+                    long elementHash3 = elementHasher.applyAsLong(data.get(3));
+                    long elementHash4 = elementHasher.applyAsLong(data.get(4));
+                    putSorted(elementHash0, elementHash1, elementHash2, elementHash3, elementHash4);
+                }
+                break;
+            case 6:
+                {
+                    long elementHash0 = elementHasher.applyAsLong(data.get(0));
+                    long elementHash1 = elementHasher.applyAsLong(data.get(1));
+                    long elementHash2 = elementHasher.applyAsLong(data.get(2));
+                    long elementHash3 = elementHasher.applyAsLong(data.get(3));
+                    long elementHash4 = elementHasher.applyAsLong(data.get(4));
+                    long elementHash5 = elementHasher.applyAsLong(data.get(5));
+                    putSorted(elementHash0, elementHash1, elementHash2, elementHash3, elementHash4, elementHash5);
+                }
+                break;
+            case 7:
+                {
+                    long elementHash0 = elementHasher.applyAsLong(data.get(0));
+                    long elementHash1 = elementHasher.applyAsLong(data.get(1));
+                    long elementHash2 = elementHasher.applyAsLong(data.get(2));
+                    long elementHash3 = elementHasher.applyAsLong(data.get(3));
+                    long elementHash4 = elementHasher.applyAsLong(data.get(4));
+                    long elementHash5 = elementHasher.applyAsLong(data.get(5));
+                    long elementHash6 = elementHasher.applyAsLong(data.get(6));
+                    putSorted(
+                            elementHash0,
+                            elementHash1,
+                            elementHash2,
+                            elementHash3,
+                            elementHash4,
+                            elementHash5,
+                            elementHash6);
+                }
+                break;
+            case 8:
+                {
+                    long elementHash0 = elementHasher.applyAsLong(data.get(0));
+                    long elementHash1 = elementHasher.applyAsLong(data.get(1));
+                    long elementHash2 = elementHasher.applyAsLong(data.get(2));
+                    long elementHash3 = elementHasher.applyAsLong(data.get(3));
+                    long elementHash4 = elementHasher.applyAsLong(data.get(4));
+                    long elementHash5 = elementHasher.applyAsLong(data.get(5));
+                    long elementHash6 = elementHasher.applyAsLong(data.get(6));
+                    long elementHash7 = elementHasher.applyAsLong(data.get(7));
+                    putSorted(
+                            elementHash0,
+                            elementHash1,
+                            elementHash2,
+                            elementHash3,
+                            elementHash4,
+                            elementHash5,
+                            elementHash6,
+                            elementHash7);
+                }
+                break;
+            case 9:
+                {
+                    long elementHash0 = elementHasher.applyAsLong(data.get(0));
+                    long elementHash1 = elementHasher.applyAsLong(data.get(1));
+                    long elementHash2 = elementHasher.applyAsLong(data.get(2));
+                    long elementHash3 = elementHasher.applyAsLong(data.get(3));
+                    long elementHash4 = elementHasher.applyAsLong(data.get(4));
+                    long elementHash5 = elementHasher.applyAsLong(data.get(5));
+                    long elementHash6 = elementHasher.applyAsLong(data.get(6));
+                    long elementHash7 = elementHasher.applyAsLong(data.get(7));
+                    long elementHash8 = elementHasher.applyAsLong(data.get(8));
+                    putSorted(
+                            elementHash0,
+                            elementHash1,
+                            elementHash2,
+                            elementHash3,
+                            elementHash4,
+                            elementHash5,
+                            elementHash6,
+                            elementHash7,
+                            elementHash8);
+                }
+                break;
+            case 10:
+                {
+                    long elementHash0 = elementHasher.applyAsLong(data.get(0));
+                    long elementHash1 = elementHasher.applyAsLong(data.get(1));
+                    long elementHash2 = elementHasher.applyAsLong(data.get(2));
+                    long elementHash3 = elementHasher.applyAsLong(data.get(3));
+                    long elementHash4 = elementHasher.applyAsLong(data.get(4));
+                    long elementHash5 = elementHasher.applyAsLong(data.get(5));
+                    long elementHash6 = elementHasher.applyAsLong(data.get(6));
+                    long elementHash7 = elementHasher.applyAsLong(data.get(7));
+                    long elementHash8 = elementHasher.applyAsLong(data.get(8));
+                    long elementHash9 = elementHasher.applyAsLong(data.get(9));
+                    putSorted(
+                            elementHash0,
+                            elementHash1,
+                            elementHash2,
+                            elementHash3,
+                            elementHash4,
+                            elementHash5,
+                            elementHash6,
+                            elementHash7,
+                            elementHash8,
+                            elementHash9);
+                }
+                break;
+            default: {
+                long[] elementHashes = new long[size];
+                for (int i = 0; i < size; ++i) {
+                    elementHashes[i] = elementHasher.applyAsLong(data.get(i));
+                }
+                Arrays.sort(elementHashes, 0, size);
+                putLongs(elementHashes, 0, size);
+            }
+        }
+        putInt(size);
+    }
+
+    private <T> void putUnorderedCollection(final Collection<T> data, final ToLongFunction<? super T> elementHasher) {
+
+        int size = data.size();
+
+        // for data sizes up to 10 there are fast implementations to avoid the allocation of an array
+        // used for sorting
+        switch (size) {
+            case 0:
+                break;
+            case 1:
+                {
+                    Iterator<T> it = data.iterator();
+                    long elementHash0 = elementHasher.applyAsLong(it.next());
+                    putLong(elementHash0);
+                }
+                break;
+            case 2:
+                {
+                    Iterator<T> it = data.iterator();
+                    long elementHash0 = elementHasher.applyAsLong(it.next());
+                    long elementHash1 = elementHasher.applyAsLong(it.next());
+                    putSorted(elementHash0, elementHash1);
+                }
+                break;
+            case 3:
+                {
+                    Iterator<T> it = data.iterator();
+                    long elementHash0 = elementHasher.applyAsLong(it.next());
+                    long elementHash1 = elementHasher.applyAsLong(it.next());
+                    long elementHash2 = elementHasher.applyAsLong(it.next());
+                    putSorted(elementHash0, elementHash1, elementHash2);
+                }
+                break;
+            case 4:
+                {
+                    Iterator<T> it = data.iterator();
+                    long elementHash0 = elementHasher.applyAsLong(it.next());
+                    long elementHash1 = elementHasher.applyAsLong(it.next());
+                    long elementHash2 = elementHasher.applyAsLong(it.next());
+                    long elementHash3 = elementHasher.applyAsLong(it.next());
+                    putSorted(elementHash0, elementHash1, elementHash2, elementHash3);
+                }
+                break;
+            case 5:
+                {
+                    Iterator<T> it = data.iterator();
+                    long elementHash0 = elementHasher.applyAsLong(it.next());
+                    long elementHash1 = elementHasher.applyAsLong(it.next());
+                    long elementHash2 = elementHasher.applyAsLong(it.next());
+                    long elementHash3 = elementHasher.applyAsLong(it.next());
+                    long elementHash4 = elementHasher.applyAsLong(it.next());
+                    putSorted(elementHash0, elementHash1, elementHash2, elementHash3, elementHash4);
+                }
+                break;
+            case 6:
+                {
+                    Iterator<T> it = data.iterator();
+                    long elementHash0 = elementHasher.applyAsLong(it.next());
+                    long elementHash1 = elementHasher.applyAsLong(it.next());
+                    long elementHash2 = elementHasher.applyAsLong(it.next());
+                    long elementHash3 = elementHasher.applyAsLong(it.next());
+                    long elementHash4 = elementHasher.applyAsLong(it.next());
+                    long elementHash5 = elementHasher.applyAsLong(it.next());
+                    putSorted(elementHash0, elementHash1, elementHash2, elementHash3, elementHash4, elementHash5);
+                }
+                break;
+            case 7:
+                {
+                    Iterator<T> it = data.iterator();
+                    long elementHash0 = elementHasher.applyAsLong(it.next());
+                    long elementHash1 = elementHasher.applyAsLong(it.next());
+                    long elementHash2 = elementHasher.applyAsLong(it.next());
+                    long elementHash3 = elementHasher.applyAsLong(it.next());
+                    long elementHash4 = elementHasher.applyAsLong(it.next());
+                    long elementHash5 = elementHasher.applyAsLong(it.next());
+                    long elementHash6 = elementHasher.applyAsLong(it.next());
+                    putSorted(
+                            elementHash0,
+                            elementHash1,
+                            elementHash2,
+                            elementHash3,
+                            elementHash4,
+                            elementHash5,
+                            elementHash6);
+                }
+                break;
+            case 8:
+                {
+                    Iterator<T> it = data.iterator();
+                    long elementHash0 = elementHasher.applyAsLong(it.next());
+                    long elementHash1 = elementHasher.applyAsLong(it.next());
+                    long elementHash2 = elementHasher.applyAsLong(it.next());
+                    long elementHash3 = elementHasher.applyAsLong(it.next());
+                    long elementHash4 = elementHasher.applyAsLong(it.next());
+                    long elementHash5 = elementHasher.applyAsLong(it.next());
+                    long elementHash6 = elementHasher.applyAsLong(it.next());
+                    long elementHash7 = elementHasher.applyAsLong(it.next());
+                    putSorted(
+                            elementHash0,
+                            elementHash1,
+                            elementHash2,
+                            elementHash3,
+                            elementHash4,
+                            elementHash5,
+                            elementHash6,
+                            elementHash7);
+                }
+                break;
+            case 9:
+                {
+                    Iterator<T> it = data.iterator();
+                    long elementHash0 = elementHasher.applyAsLong(it.next());
+                    long elementHash1 = elementHasher.applyAsLong(it.next());
+                    long elementHash2 = elementHasher.applyAsLong(it.next());
+                    long elementHash3 = elementHasher.applyAsLong(it.next());
+                    long elementHash4 = elementHasher.applyAsLong(it.next());
+                    long elementHash5 = elementHasher.applyAsLong(it.next());
+                    long elementHash6 = elementHasher.applyAsLong(it.next());
+                    long elementHash7 = elementHasher.applyAsLong(it.next());
+                    long elementHash8 = elementHasher.applyAsLong(it.next());
+                    putSorted(
+                            elementHash0,
+                            elementHash1,
+                            elementHash2,
+                            elementHash3,
+                            elementHash4,
+                            elementHash5,
+                            elementHash6,
+                            elementHash7,
+                            elementHash8);
+                }
+                break;
+            case 10:
+                {
+                    Iterator<T> it = data.iterator();
+                    long elementHash0 = elementHasher.applyAsLong(it.next());
+                    long elementHash1 = elementHasher.applyAsLong(it.next());
+                    long elementHash2 = elementHasher.applyAsLong(it.next());
+                    long elementHash3 = elementHasher.applyAsLong(it.next());
+                    long elementHash4 = elementHasher.applyAsLong(it.next());
+                    long elementHash5 = elementHasher.applyAsLong(it.next());
+                    long elementHash6 = elementHasher.applyAsLong(it.next());
+                    long elementHash7 = elementHasher.applyAsLong(it.next());
+                    long elementHash8 = elementHasher.applyAsLong(it.next());
+                    long elementHash9 = elementHasher.applyAsLong(it.next());
+                    putSorted(
+                            elementHash0,
+                            elementHash1,
+                            elementHash2,
+                            elementHash3,
+                            elementHash4,
+                            elementHash5,
+                            elementHash6,
+                            elementHash7,
+                            elementHash8,
+                            elementHash9);
+                }
+                break;
+            default: {
+                Iterator<T> it = data.iterator();
+                long[] elementHashes = new long[size];
+                for (int i = 0; i < size; ++i) {
+                    elementHashes[i] = elementHasher.applyAsLong(it.next());
+                }
+                Arrays.sort(elementHashes, 0, size);
+                putLongs(elementHashes, 0, size);
+            }
+        }
+        putInt(size);
+    }
+
+    @Override
+    default HashStream putOptionalInt(OptionalInt v) {
+        if (v.isPresent()) {
+            putInt(v.getAsInt());
+            putBoolean(true);
+        } else {
+            putBoolean(false);
+        }
+        return this;
+    }
+
+    @Override
+    default HashStream putOptionalLong(OptionalLong v) {
+        if (v.isPresent()) {
+            putLong(v.getAsLong());
+            putBoolean(true);
+        } else {
+            putBoolean(false);
+        }
+        return this;
+    }
+
+    @Override
+    default HashStream putOptionalDouble(OptionalDouble v) {
+        if (v.isPresent()) {
+            putDouble(v.getAsDouble());
+            putBoolean(true);
+        } else {
+            putBoolean(false);
+        }
+        return this;
+    }
+}
diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/ByteArrayUtil.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/ByteArrayUtil.java
new file mode 100644
index 00000000..c339385b
--- /dev/null
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/ByteArrayUtil.java
@@ -0,0 +1,147 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.runtime.hashing;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+
+/** Utility class for byte arrays. */
+ final class ByteArrayUtil {
+
+    private static final VarHandle LONG_HANDLE =
+            MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.LITTLE_ENDIAN);
+    private static final VarHandle INT_HANDLE =
+            MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN);
+    private static final VarHandle SHORT_HANDLE =
+            MethodHandles.byteArrayViewVarHandle(short[].class, ByteOrder.LITTLE_ENDIAN);
+    private static final VarHandle CHAR_HANDLE =
+            MethodHandles.byteArrayViewVarHandle(char[].class, ByteOrder.LITTLE_ENDIAN);
+
+    private ByteArrayUtil() {}
+
+    /**
+     * Reads a {@code char} from a byte array with given offset.
+     *
+     * @param b a byte array
+     * @param off an offset
+     * @return the read character
+     */
+    public static char getChar(byte[] b, int off) {
+        return (char) CHAR_HANDLE.get(b, off);
+    }
+
+    /**
+     * Reads an {@code int} value from a byte array with given offset.
+     *
+     * @param b a byte array
+     * @param off an offset
+     * @return the read value
+     */
+    public static int getInt(byte[] b, int off) {
+        return (int) INT_HANDLE.get(b, off);
+    }
+
+    /**
+     * Reads a {@code long} value from a byte array with given offset.
+     *
+     * @param b a byte array
+     * @param off an offset
+     * @return the read value
+     */
+    public static long getLong(byte[] b, int off) {
+        return (long) LONG_HANDLE.get(b, off);
+    }
+
+    /**
+     * Writes a {@code long} value to a byte array with given offset.
+     *
+     * @param b a byte array
+     * @param off an offset
+     * @param v a value
+     */
+    public static void setLong(byte[] b, int off, long v) {
+        LONG_HANDLE.set(b, off, v);
+    }
+
+    /**
+     * Writes an {@code int} value to a byte array with given offset.
+     *
+     * @param b a byte array
+     * @param off an offset
+     * @param v a value
+     */
+    public static void setInt(byte[] b, int off, int v) {
+        INT_HANDLE.set(b, off, v);
+    }
+
+    /**
+     * Writes a {@code short} value to a byte array with given offset.
+     *
+     * @param b a byte array
+     * @param off an offset
+     * @param v a value
+     */
+    public static void setShort(byte[] b, int off, short v) {
+        SHORT_HANDLE.set(b, off, v);
+    }
+
+    /**
+     * Reads a {@code long} value from a {@link CharSequence} with given offset.
+     *
+     * @param charSequence a char sequence
+     * @param off an offset
+     * @return the value
+     */
+    public static long getLong(CharSequence charSequence, int off) {
+        return (long) charSequence.charAt(off)
+                | ((long) charSequence.charAt(off + 1) << 16)
+                | ((long) charSequence.charAt(off + 2) << 32)
+                | ((long) charSequence.charAt(off + 3) << 48);
+    }
+
+    /**
+     * Reads an {@code int} value from a {@link CharSequence} with given offset.
+     *
+     * @param charSequence a char sequence
+     * @param off an offset
+     * @return the value
+     */
+    public static int getInt(CharSequence charSequence, int off) {
+        return (int) charSequence.charAt(off) | ((int) charSequence.charAt(off + 1) << 16);
+    }
+
+    /**
+     * Writes a {@code char} to a byte array with given offset.
+     *
+     * @param b a byte array
+     * @param off an offset
+     * @param v a character
+     */
+    public static void setChar(byte[] b, int off, char v) {
+        CHAR_HANDLE.set(b, off, v);
+    }
+
+    /**
+     * Copies a given number of characters from a {@link CharSequence} into a byte array.
+     *
+     * @param charSequence a char sequence
+     * @param offetCharSequence an offset for the char sequence
+     * @param byteArray a byte array
+     * @param offsetByteArray an offset for the byte array
+     * @param numChars the number of characters to copy
+     */
+    public static void copyCharsToByteArray(
+            CharSequence charSequence, int offetCharSequence, byte[] byteArray, int offsetByteArray, int numChars) {
+        for (int charIdx = 0; charIdx <= numChars - 4; charIdx += 4) {
+            setLong(byteArray, offsetByteArray + (charIdx << 1), getLong(charSequence, offetCharSequence + charIdx));
+        }
+        if ((numChars & 2) != 0) {
+            int charIdx = numChars & 0xFFFFFFFC;
+            setInt(byteArray, offsetByteArray + (charIdx << 1), getInt(charSequence, offetCharSequence + charIdx));
+        }
+        if ((numChars & 1) != 0) {
+            int charIdx = numChars & 0xFFFFFFFE;
+            setChar(byteArray, offsetByteArray + (charIdx << 1), charSequence.charAt(offetCharSequence + charIdx));
+        }
+    }
+}
diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/HashSink.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/HashSink.java
new file mode 100644
index 00000000..980143a0
--- /dev/null
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/HashSink.java
@@ -0,0 +1,571 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.runtime.hashing;
+
+import java.util.*;
+
+/** A sink that accepts various data types contributing to the hash computation. */
+public interface HashSink {
+
+    /**
+     * Adds a <code>byte</code> value to the hash computation.
+     *
+     * @param v the value
+     * @return this
+     */
+    HashSink putByte(byte v);
+
+    /**
+     * Adds all elements of a {@code byte} array to the hash computation.
+     *
+     * <p>Unlike {@link #putByteArray} this method does not add the length of the array.
+     *
+     * <p>If the array has variable length, and it is just one of many variable-length fields of the
+     * object for which a hash value is calculated, it is highly recommended to also incorporate the
+     * length of the array to improve the hash quality and decrease the chance of hash collisions.
+     *
+     * <p>Equivalent to <br>
+     * {@code putBytes(x, 0, x.length);}
+     *
+     * @param x the array
+     * @return this
+     */
+    HashSink putBytes(byte[] x);
+
+    /**
+     * Adds <code>len</code> elements of the given {@code byte} array to the hash computation.
+     *
+     * <p>Equivalent to <br>
+     * {@code for (int i = 0; i < len; i++) putByte(x[off + i]);}
+     *
+     * @param x the array
+     * @param off the start offset in the array
+     * @param len the number of elements
+     * @return this
+     */
+    HashSink putBytes(byte[] x, int off, int len);
+
+    /**
+     * Adds a {@code byte} array to the hash computation.
+     *
+     * <p>This method includes the length information. In this way,
+     *
+     * <p>{@code hashSink.putByteArray(new byte[]{1, 2}).putByteArray(new byte[]{3})}
+     *
+     * <p>and
+     *
+     * <p>{@code hashSink.putByteArray(new byte[]{1}).putByteArray(new byte[]{2, 3})}
+     *
+     * <p>will be different contributions to the hash value computation.
+     *
+     * <p>Equivalent to <br>
+     * {@code putBytes(x).putInt(x.length);}
+     *
+     * @param x the boolean array
+     * @return this
+     */
+    HashSink putByteArray(byte[] x);
+
+    /**
+     * Adds a <code>boolean</code> value to the hash computation.
+     *
+     * <p>Equivalent to <br>
+     * {@code putByte(v ? 1 : 0);}
+     *
+     * @param v the value
+     * @return this
+     */
+    HashSink putBoolean(boolean v);
+
+    /**
+     * Adds all elements of a {@code boolean} array to the hash computation.
+     *
+     * <p>Unlike {@link #putBooleanArray} this method does not add the length of the array.
+     *
+     * <p>If the array has variable length, and it is just one of many variable-length fields of the
+     * object for which a hash value is calculated, it is highly recommended to also incorporate the
+     * length of the array to improve the hash quality and decrease the chance of hash collisions.
+     *
+     * <p>Equivalent to <br>
+     * {@code putBooleans(x, 0, x.length);}
+     *
+     * @param x the array
+     * @return this
+     */
+    HashSink putBooleans(boolean[] x);
+
+    /**
+     * Adds <code>len</code> elements of the given {@code boolean} array to the hash computation.
+     *
+     * <p>Equivalent to <br>
+     * {@code for (int i = 0; i < len; i++) putBoolean(x[off + i]);}
+     *
+     * @param x the array
+     * @param off the start offset in the array
+     * @param len the number of elements
+     * @return this
+     */
+    HashSink putBooleans(boolean[] x, int off, int len);
+
+    /**
+     * Adds a {@code boolean} array to the hash computation.
+     *
+     * <p>This method includes the length information. In this way,
+     *
+     * <p>{@code hashSink.putBooleanArray(new boolean[]{true, false}).putBooleanArray(new
+     * boolean[]{true})}
+     *
+     * <p>and
+     *
+     * <p>{@code hashSink.putBooleanArray(new boolean[]{true}).putBooleanArray(new boolean[]{false,
+     * true})}
+     *
+     * <p>will be different contributions to the hash value computation.
+     *
+     * <p>Equivalent to <br>
+     * {@code putBooleans(x).putInt(x.length);}
+     *
+     * @param x the boolean array
+     * @return this
+     */
+    HashSink putBooleanArray(boolean[] x);
+
+    /**
+     * Adds a <code>short</code> value to the hash computation using little-endian byte order.
+     *
+     * @param v the value
+     * @return this
+     */
+    HashSink putShort(short v);
+
+    /**
+     * Adds all elements of a {@code short} array to the hash computation.
+     *
+     * <p>Unlike {@link #putShortArray} this method does not add the length of the array.
+     *
+     * <p>If the array has variable length, and it is just one of many variable-length fields of the
+     * object for which a hash value is calculated, it is highly recommended to also incorporate the
+     * length of the array to improve the hash quality and decrease the chance of hash collisions.
+     *
+     * <p>Equivalent to <br>
+     * {@code putShorts(x, 0, x.length);}
+     *
+     * @param x the array
+     * @return this
+     */
+    HashSink putShorts(short[] x);
+
+    /**
+     * Adds <code>len</code> elements of the given {@code short} array to the hash computation.
+     *
+     * <p>Equivalent to <br>
+     * {@code for (int i = 0; i < len; i++) putShort(x[off + i]);}
+     *
+     * @param x the array
+     * @param off the start offset in the array
+     * @param len the number of elements
+     * @return this
+     */
+    HashSink putShorts(short[] x, int off, int len);
+
+    /**
+     * Adds a {@code short} array to the hash computation.
+     *
+     * <p>This method includes the length information. In this way,
+     *
+     * <p>{@code hashSink.putShortArray(new short[]{1, 2}).putShortArray}{@code (new short[]{3})}
+     *
+     * <p>and
+     *
+     * <p>{@code hashSink.putShortArray}{@code (new short[]{1}).putShortArray}{@code (new short[]{2,
+     * 3})}
+     *
+     * <p>will be different contributions to the hash value computation.
+     *
+     * <p>Equivalent to <br>
+     * {@code putShorts(x).putInt(x.length);}
+     *
+     * @param x the short array
+     * @return this
+     */
+    HashSink putShortArray(short[] x);
+
+    /**
+     * Adds a <code>char</code> value to the hash computation using little-endian byte order.
+     *
+     * @param v the value
+     * @return this
+     */
+    HashSink putChar(char v);
+
+    /**
+     * Adds all elements of a {@code char} array to the hash computation.
+     *
+     * <p>Unlike {@link #putCharArray} this method does not add the length of the array.
+     *
+     * <p>If the array has variable length, and it is just one of many variable-length fields of the
+     * object for which a hash value is calculated, it is highly recommended to also incorporate the
+     * length of the array to improve the hash quality and decrease the chance of hash collisions.
+     *
+     * <p>Equivalent to <br>
+     * {@code putChars(x, 0, x.length);}
+     *
+     * @param x the array
+     * @return this
+     */
+    HashSink putChars(char[] x);
+
+    /**
+     * Adds <code>len</code> elements of the given {@code char} array to the hash computation.
+     *
+     * <p>Equivalent to <br>
+     * {@code for (int i = 0; i < len; i++) putChar(x[off + i]);}
+     *
+     * @param x the array
+     * @param off the start offset in the array
+     * @param len the number of elements
+     * @return this
+     */
+    HashSink putChars(char[] x, int off, int len);
+
+    /**
+     * Adds chars to the hash computation.
+     *
+     * <p>This method does not include the length information. In this way,
+     *
+     * <p>{@code hashSink.putChars}{@code ("AB").putChars}{@code ("C")}
+     *
+     * <p>and
+     *
+     * <p>{@code hashSink.putChars}{@code ("A").putChars}{@code ("BC")}
+     *
+     * <p>will be equivalent contributions to the hash value computation.
+     *
+     * <p>Equivalent to <br>
+     * {@code for (int i = 0; i < s.length(); ++i) putChar(s.charAt(i));}
+     *
+     * @param c a char sequence
+     * @return this
+     */
+    HashSink putChars(CharSequence c);
+
+    /**
+     * Adds a {@code char} array to the hash computation.
+     *
+     * <p>This method includes the length information. In this way,
+     *
+     * <p>{@code hashSink.putCharArray(new char[]{'A', 'B'}).putCharArray(new char[]{'C'})}
+     *
+     * <p>and
+     *
+     * <p>{@code hashSink.putCharArray(new char[]{'A'}).putCharArray(new char[]{'B', 'C'})}
+     *
+     * <p>will be different contributions to the hash value computation.
+     *
+     * <p>Equivalent to <br>
+     * {@code putChars(x).putInt(x.length);}
+     *
+     * @param x the char array
+     * @return this
+     */
+    HashSink putCharArray(char[] x);
+
+    /**
+     * Adds a string to the hash computation.
+     *
+     * <p>This method includes the length information. In this way,
+     *
+     * <p>{@code hashSink.putString}{@code ("AB").putString}{@code ("C")}
+     *
+     * <p>and
+     *
+     * <p>{@code hashSink.putString}{@code ("A").putString}{@code ("BC")}
+     *
+     * <p>will be different contributions to the hash value computation.
+     *
+     * <p>Equivalent to <br>
+     * {@code putChars(s).putInt(s.length());}
+     *
+     * @param s the string
+     * @return this
+     */
+    HashSink putString(String s);
+
+    /**
+     * Adds an <code>int</code> value to the hash computation using little-endian byte order.
+     *
+     * @param v the value
+     * @return this
+     */
+    HashSink putInt(int v);
+
+    /**
+     * Adds all elements of an {@code int} array to the hash computation.
+     *
+     * <p>Unlike {@link #putIntArray} this method does not add the length of the array.
+     *
+     * <p>If the array has variable length, and it is just one of many variable-length fields of the
+     * object for which a hash value is calculated, it is highly recommended to also incorporate the
+     * length of the array to improve the hash quality and decrease the chance of hash collisions.
+     *
+     * <p>Equivalent to <br>
+     * {@code putInts(x, 0, x.length);}
+     *
+     * @param x the array
+     * @return this
+     */
+    HashSink putInts(int[] x);
+
+    /**
+     * Adds <code>len</code> elements of the given {@code int} array to the hash computation.
+     *
+     * <p>Equivalent to <br>
+     * {@code for (int i = 0; i < len; i++) putInt(x[off + i]);}
+     *
+     * @param x the array
+     * @param off the start offset in the array
+     * @param len the number of elements
+     * @return this
+     */
+    HashSink putInts(int[] x, int off, int len);
+
+    /**
+     * Adds an {@code int} array to the hash computation.
+     *
+     * <p>This method includes the length information. In this way,
+     *
+     * <p>{@code hashSink.putIntArray}{@code (new int[]{1, 2}).putIntArray}{@code (new int[]{3})}
+     *
+     * <p>and
+     *
+     * <p>{@code hashSink.putIntArray}{@code (new int[]{1}).putIntArray}{@code (new int[]{2, 3})}
+     *
+     * <p>will be different contributions to the hash value computation.
+     *
+     * <p>Equivalent to <br>
+     * {@code }{@code putInts(x).putInt(x.length);}
+     *
+     * @param x the int array
+     * @return this
+     */
+    HashSink putIntArray(int[] x);
+
+    /**
+     * Adds along <code>long</code> value to the hash computation using little-endian byte order.
+     *
+     * @param v the value
+     * @return this
+     */
+    HashSink putLong(long v);
+
+    /**
+     * Adds all elements of a {@code long} array to the hash computation.
+     *
+     * <p>Unlike {@link #putLongArray} this method does not add the length of the array.
+     *
+     * <p>If the array has variable length, and it is just one of many variable-length fields of the
+     * object for which a hash value is calculated, it is highly recommended to also incorporate the
+     * length of the array to improve the hash quality and decrease the chance of hash collisions.
+     *
+     * <p>Equivalent to <br>
+     * {@code putLongs(x, 0, x.length);}
+     *
+     * @param x the array
+     * @return this
+     */
+    HashSink putLongs(long[] x);
+
+    /**
+     * Adds <code>len</code> elements of the given {@code long} array to the hash computation.
+     *
+     * <p>Equivalent to <br>
+     * {@code for (int i = 0; i < len; i++) putLong(x[off + i]);}
+     *
+     * @param x the array
+     * @param off the start offset in the array
+     * @param len the number of elements
+     * @return this
+     */
+    HashSink putLongs(long[] x, int off, int len);
+
+    /**
+     * Adds a {@code long} array to the hash computation.
+     *
+     * <p>This method includes the length information. In this way,
+     *
+     * <p>{@code hashSink.putLongArray}{@code (new long[]{1, 2}).putLongArray}{@code (new long[]{3})}
+     *
+     * <p>and
+     *
+     * <p>{@code hashSink.putLongArray}{@code (new long[]{1}).putLongArray}{@code (new long[]{2, 3})}
+     *
+     * <p>will be different contributions to the hash value computation.
+     *
+     * <p>Equivalent to <br>
+     * {@code putLongs(x).putInt(x.length);}
+     *
+     * @param x the int array
+     * @return this
+     */
+    HashSink putLongArray(long[] x);
+
+    /**
+     * Adds a <code>float</code> value to the hash computation using little-endian byte order.
+     *
+     * <p>Equivalent to <br>
+     * {@code putInt(Float.floatToRawIntBits(v));}
+     *
+     * @param v the value
+     * @return this
+     */
+    HashSink putFloat(float v);
+
+    /**
+     * Adds all elements of a {@code float} array to the hash computation.
+     *
+     * <p>Unlike {@link #putFloatArray} this method does not add the length of the array.
+     *
+     * <p>If the array has variable length, and it is just one of many variable-length fields of the
+     * object for which a hash value is calculated, it is highly recommended to also incorporate the
+     * length of the array to improve the hash quality and decrease the chance of hash collisions.
+     *
+     * <p>Equivalent to <br>
+     * {@code putFloats(x, 0, x.length);}
+     *
+     * @param x the array
+     * @return this
+     */
+    HashSink putFloats(float[] x);
+
+    /**
+     * Adds <code>len</code> elements of the given {@code float} array to the hash computation.
+     *
+     * <p>Equivalent to <br>
+     * {@code for (int i = 0; i < len; i++) putFloat(x[off + i]);}
+     *
+     * @param x the array
+     * @param off the start offset in the array
+     * @param len the number of elements
+     * @return this
+     */
+    HashSink putFloats(float[] x, int off, int len);
+
+    /**
+     * Adds a {@code float} array to the hash computation.
+     *
+     * <p>This method includes the length information. In this way,
+     *
+     * <p>{@code hashSink.putFloatArray(new float[]{1, 2}).putFloatArray(new float[]{3})}
+     *
+     * <p>and
+     *
+     * <p>{@code hashSink.putFloatArray(new float[]{1}).putFloatArray(new float[]{2, 3})}
+     *
+     * <p>will be different contributions to the hash value computation.
+     *
+     * <p>Equivalent to <br>
+     * {@code putFloats(x).putInt(x.length);}
+     *
+     * @param x the float array
+     * @return this
+     */
+    HashSink putFloatArray(float[] x);
+
+    /**
+     * Adds a <code>double</code> value to the hash computation using little-endian byte order.
+     *
+     * <p>Equivalent to <br>
+     * {@code putLong(Double.doubleToRawLongBits(v));}
+     *
+     * @param v the value
+     * @return this
+     */
+    HashSink putDouble(double v);
+
+    /**
+     * Adds all elements of a {@code double} array to the hash computation.
+     *
+     * <p>Unlike {@link #putDoubleArray} this method does not add the length of the array.
+     *
+     * <p>If the array has variable length, and it is just one of many variable-length fields of the
+     * object for which a hash value is calculated, it is highly recommended to also incorporate the
+     * length of the array to improve the hash quality and decrease the chance of hash collisions.
+     *
+     * <p>Equivalent to <br>
+     * {@code putDoubles(x, 0, x.length);}
+     *
+     * @param x the array
+     * @return this
+     */
+    HashSink putDoubles(double[] x);
+
+    /**
+     * Adds <code>len</code> elements of the given {@code double} array to the hash computation.
+     *
+     * <p>Equivalent to <br>
+     * {@code for (int i = 0; i < len; i++) putDouble(x[off + i]);}
+     *
+     * @param x the array
+     * @param off the start offset in the array
+     * @param len the number of elements
+     * @return this
+     */
+    HashSink putDoubles(double[] x, int off, int len);
+
+    /**
+     * Adds a {@code double} array to the hash computation.
+     *
+     * <p>This method includes the length information. In this way,
+     *
+     * <p>{@code hashSink.putDoubleArray(new double[]{1, 2}).putDoubleArray(new double[]{3})}
+     *
+     * <p>and
+     *
+     * <p>{@code hashSink.putDoubleArray(new double[]{1}).putDoubleArray(new double[]{2, 3})}
+     *
+     * <p>will be different contributions to the hash value computation.
+     *
+     * <p>Equivalent to <br>
+     * {@code putDoubles(x).putInt(x.length);}
+     *
+     * @param x the double array
+     * @return this
+     */
+    HashSink putDoubleArray(double[] x);
+    //
+    //  /**
+    //   * Adds an unordered {@link Iterable} (e.g. {@link Set}) to the hash computation.
+    //   *
+    //   * @param data the iterable
+    //   * @param elementHashFunction 64-bit hash function used for individual elements
+    //   * @param <T> the element type
+    //   * @return this
+    //   * @throws OutOfMemoryError if the allocation of a long array, that is able to keep a 64-bit hash
+    //   *     for each element in the Iterable, fails
+    //   */
+    //  <T> HashSink putUnorderedIterable(
+    //      Iterable<T> data, ToLongFunction<? super T> elementHashFunction);
+
+    /**
+     * Adds an {@link OptionalInt} to the hash computation.
+     *
+     * @param v the optional value
+     * @return this
+     */
+    HashSink putOptionalInt(OptionalInt v);
+
+    /**
+     * Adds an {@link OptionalLong} to the hash computation.
+     *
+     * @param v the optional value
+     * @return this
+     */
+    HashSink putOptionalLong(OptionalLong v);
+
+    /**
+     * Adds an {@link OptionalDouble} to the hash computation.
+     *
+     * @param v the optional value
+     * @return this
+     */
+    HashSink putOptionalDouble(OptionalDouble v);
+}
diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/HashStream.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/HashStream.java
new file mode 100644
index 00000000..7b929b07
--- /dev/null
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/HashStream.java
@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.runtime.hashing;
+
+import java.util.*;
+
+interface HashStream extends HashSink {
+
+    @Override
+    HashStream putByte(byte v);
+
+    @Override
+    HashStream putBytes(byte[] x);
+
+    @Override
+    HashStream putBytes(byte[] x, int off, int len);
+
+    @Override
+    HashStream putByteArray(byte[] x);
+
+    @Override
+    HashStream putBoolean(boolean v);
+
+    @Override
+    HashStream putBooleans(boolean[] x);
+
+    @Override
+    HashStream putBooleans(boolean[] x, int off, int len);
+
+    @Override
+    HashStream putBooleanArray(boolean[] x);
+
+    @Override
+    HashStream putShort(short v);
+
+    @Override
+    HashStream putShorts(short[] x);
+
+    @Override
+    HashStream putShorts(short[] x, int off, int len);
+
+    @Override
+    HashStream putShortArray(short[] x);
+
+    @Override
+    HashStream putChar(char v);
+
+    @Override
+    HashStream putChars(char[] x);
+
+    @Override
+    HashStream putChars(char[] x, int off, int len);
+
+    @Override
+    HashStream putChars(CharSequence c);
+
+    @Override
+    HashStream putCharArray(char[] x);
+
+    @Override
+    HashStream putString(String s);
+
+    @Override
+    HashStream putInt(int v);
+
+    @Override
+    HashStream putInts(int[] x);
+
+    @Override
+    HashStream putInts(int[] x, int off, int len);
+
+    @Override
+    HashStream putIntArray(int[] x);
+
+    @Override
+    HashStream putLong(long v);
+
+    @Override
+    HashStream putLongs(long[] x);
+
+    @Override
+    HashStream putLongs(long[] x, int off, int len);
+
+    @Override
+    HashStream putLongArray(long[] x);
+
+    @Override
+    HashStream putFloat(float v);
+
+    @Override
+    HashStream putFloats(float[] x);
+
+    @Override
+    HashStream putFloats(float[] x, int off, int len);
+
+    @Override
+    HashStream putFloatArray(float[] x);
+
+    @Override
+    HashStream putDouble(double v);
+
+    @Override
+    HashStream putDoubles(double[] x);
+
+    @Override
+    HashStream putDoubles(double[] x, int off, int len);
+
+    @Override
+    HashStream putDoubleArray(double[] x);
+
+    @Override
+    HashStream putOptionalInt(OptionalInt v);
+
+    @Override
+    HashStream putOptionalLong(OptionalLong v);
+
+    @Override
+    HashStream putOptionalDouble(OptionalDouble v);
+
+    /**
+     * Resets the hash stream.
+     *
+     * <p>This allows to reuse this instance for new hash computations.
+     *
+     * @return this
+     */
+    HashStream reset();
+}
diff --git a/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/XXH3_64.java b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/XXH3_64.java
new file mode 100644
index 00000000..7e0be4b7
--- /dev/null
+++ b/pbj-core/pbj-runtime/src/main/java/com/hedera/pbj/runtime/hashing/XXH3_64.java
@@ -0,0 +1,1001 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.runtime.hashing;
+
+import static com.hedera.pbj.runtime.hashing.ByteArrayUtil.*;
+
+@SuppressWarnings({"DuplicatedCode", "NumericOverflow"})
+public class XXH3_64 {
+    private static final XXH3_64 DEFAULT_HASHER_INSTANCE = new XXH3_64(0);
+
+    public static long hash_xxh3_64(final byte[] bytes, int start, int length) {
+        return DEFAULT_HASHER_INSTANCE.hashBytesToLong(bytes, start, length);
+    }
+
+    private static final int BLOCK_LEN_EXP = 10;
+    private static final long SECRET_00 = 0xbe4ba423396cfeb8L;
+    private static final long SECRET_01 = 0x1cad21f72c81017cL;
+    private static final long SECRET_02 = 0xdb979083e96dd4deL;
+    private static final long SECRET_03 = 0x1f67b3b7a4a44072L;
+    private static final long SECRET_04 = 0x78e5c0cc4ee679cbL;
+    private static final long SECRET_05 = 0x2172ffcc7dd05a82L;
+    private static final long SECRET_06 = 0x8e2443f7744608b8L;
+    private static final long SECRET_07 = 0x4c263a81e69035e0L;
+    private static final long SECRET_08 = 0xcb00c391bb52283cL;
+    private static final long SECRET_09 = 0xa32e531b8b65d088L;
+    private static final long SECRET_10 = 0x4ef90da297486471L;
+    private static final long SECRET_11 = 0xd8acdea946ef1938L;
+    private static final long SECRET_12 = 0x3f349ce33f76faa8L;
+    private static final long SECRET_13 = 0x1d4f0bc7c7bbdcf9L;
+    private static final long SECRET_14 = 0x3159b4cd4be0518aL;
+    private static final long SECRET_15 = 0x647378d9c97e9fc8L;
+    private static final long SECRET_16 = 0xc3ebd33483acc5eaL;
+    private static final long SECRET_17 = 0xeb6313faffa081c5L;
+    private static final long SECRET_18 = 0x49daf0b751dd0d17L;
+    private static final long SECRET_19 = 0x9e68d429265516d3L;
+    private static final long SECRET_20 = 0xfca1477d58be162bL;
+    private static final long SECRET_21 = 0xce31d07ad1b8f88fL;
+    private static final long SECRET_22 = 0x280416958f3acb45L;
+    private static final long SECRET_23 = 0x7e404bbbcafbd7afL;
+    private static final long INIT_ACC_0 = 0x00000000C2B2AE3DL;
+    private static final long INIT_ACC_1 = 0x9E3779B185EBCA87L;
+    private static final long INIT_ACC_2 = 0xC2B2AE3D27D4EB4FL;
+    private static final long INIT_ACC_3 = 0x165667B19E3779F9L;
+    private static final long INIT_ACC_4 = 0x85EBCA77C2B2AE63L;
+    private static final long INIT_ACC_5 = 0x0000000085EBCA77L;
+    private static final long INIT_ACC_6 = 0x27D4EB2F165667C5L;
+    private static final long INIT_ACC_7 = 0x000000009E3779B1L;
+
+    private final long secret00;
+    private final long secret01;
+    private final long secret02;
+    private final long secret03;
+    private final long secret04;
+    private final long secret05;
+    private final long secret06;
+    private final long secret07;
+    private final long secret08;
+    private final long secret09;
+    private final long secret10;
+    private final long secret11;
+    private final long secret12;
+    private final long secret13;
+    private final long secret14;
+    private final long secret15;
+    private final long secret16;
+    private final long secret17;
+    private final long secret18;
+    private final long secret19;
+    private final long secret20;
+    private final long secret21;
+    private final long secret22;
+    private final long secret23;
+
+    private final long[] secret;
+
+    private final long secShift00;
+    private final long secShift01;
+    private final long secShift02;
+    private final long secShift03;
+    private final long secShift04;
+    private final long secShift05;
+    private final long secShift06;
+    private final long secShift07;
+    private final long secShift08;
+    private final long secShift09;
+    private final long secShift10;
+    private final long secShift11;
+
+    private final long secShift16;
+    private final long secShift17;
+    private final long secShift18;
+    private final long secShift19;
+    private final long secShift20;
+    private final long secShift21;
+    private final long secShift22;
+    private final long secShift23;
+
+    private final long secShiftFinal0;
+    private final long secShiftFinal1;
+    private final long secShiftFinal2;
+    private final long secShiftFinal3;
+    private final long secShiftFinal4;
+    private final long secShiftFinal5;
+    private final long secShiftFinal6;
+    private final long secShiftFinal7;
+    private final long secShift12;
+    private final long secShift13;
+    private final long secShift14;
+    private final long secShift15;
+    private final long bitflip00;
+    private final long bitflip12;
+    private final long bitflip34;
+    private final long bitflip56;
+    private final long hash0;
+
+    @SuppressWarnings("NumericOverflow")
+    private XXH3_64(long seed) {
+        this.secret00 = SECRET_00 + seed;
+        this.secret01 = SECRET_01 - seed;
+        this.secret02 = SECRET_02 + seed;
+        this.secret03 = SECRET_03 - seed;
+        this.secret04 = SECRET_04 + seed;
+        this.secret05 = SECRET_05 - seed;
+        this.secret06 = SECRET_06 + seed;
+        this.secret07 = SECRET_07 - seed;
+        this.secret08 = SECRET_08 + seed;
+        this.secret09 = SECRET_09 - seed;
+        this.secret10 = SECRET_10 + seed;
+        this.secret11 = SECRET_11 - seed;
+        this.secret12 = SECRET_12 + seed;
+        this.secret13 = SECRET_13 - seed;
+        this.secret14 = SECRET_14 + seed;
+        this.secret15 = SECRET_15 - seed;
+        this.secret16 = SECRET_16 + seed;
+        this.secret17 = SECRET_17 - seed;
+        this.secret18 = SECRET_18 + seed;
+        this.secret19 = SECRET_19 - seed;
+        this.secret20 = SECRET_20 + seed;
+        this.secret21 = SECRET_21 - seed;
+        this.secret22 = SECRET_22 + seed;
+        this.secret23 = SECRET_23 - seed;
+
+        this.secShift00 = (SECRET_00 >>> 24) + (SECRET_01 << 40) + seed;
+        this.secShift01 = (SECRET_01 >>> 24) + (SECRET_02 << 40) - seed;
+        this.secShift02 = (SECRET_02 >>> 24) + (SECRET_03 << 40) + seed;
+        this.secShift03 = (SECRET_03 >>> 24) + (SECRET_04 << 40) - seed;
+        this.secShift04 = (SECRET_04 >>> 24) + (SECRET_05 << 40) + seed;
+        this.secShift05 = (SECRET_05 >>> 24) + (SECRET_06 << 40) - seed;
+        this.secShift06 = (SECRET_06 >>> 24) + (SECRET_07 << 40) + seed;
+        this.secShift07 = (SECRET_07 >>> 24) + (SECRET_08 << 40) - seed;
+        this.secShift08 = (SECRET_08 >>> 24) + (SECRET_09 << 40) + seed;
+        this.secShift09 = (SECRET_09 >>> 24) + (SECRET_10 << 40) - seed;
+        this.secShift10 = (SECRET_10 >>> 24) + (SECRET_11 << 40) + seed;
+        this.secShift11 = (SECRET_11 >>> 24) + (SECRET_12 << 40) - seed;
+
+        this.secShift16 = secret15 >>> 8 | secret16 << 56;
+        this.secShift17 = secret16 >>> 8 | secret17 << 56;
+        this.secShift18 = secret17 >>> 8 | secret18 << 56;
+        this.secShift19 = secret18 >>> 8 | secret19 << 56;
+        this.secShift20 = secret19 >>> 8 | secret20 << 56;
+        this.secShift21 = secret20 >>> 8 | secret21 << 56;
+        this.secShift22 = secret21 >>> 8 | secret22 << 56;
+        this.secShift23 = secret22 >>> 8 | secret23 << 56;
+
+        this.secShiftFinal0 = secret01 >>> 24 | secret02 << 40;
+        this.secShiftFinal1 = secret02 >>> 24 | secret03 << 40;
+        this.secShiftFinal2 = secret03 >>> 24 | secret04 << 40;
+        this.secShiftFinal3 = secret04 >>> 24 | secret05 << 40;
+        this.secShiftFinal4 = secret05 >>> 24 | secret06 << 40;
+        this.secShiftFinal5 = secret06 >>> 24 | secret07 << 40;
+        this.secShiftFinal6 = secret07 >>> 24 | secret08 << 40;
+        this.secShiftFinal7 = secret08 >>> 24 | secret09 << 40;
+
+        this.secret = new long[] {
+            secret00, secret01, secret02, secret03, secret04, secret05, secret06, secret07,
+            secret08, secret09, secret10, secret11, secret12, secret13, secret14, secret15,
+            secret16, secret17, secret18, secret19, secret20, secret21, secret22, secret23
+        };
+
+        this.secShift12 = (SECRET_12 >>> 24) + (SECRET_13 << 40) + seed;
+        this.secShift13 = (SECRET_13 >>> 24) + (SECRET_14 << 40) - seed;
+        this.secShift14 = (SECRET_14 >>> 56) + (SECRET_15 << 8) + seed;
+        this.secShift15 = (SECRET_15 >>> 56) + (SECRET_16 << 8) - seed;
+
+        this.bitflip00 = ((SECRET_00 >>> 32) ^ (SECRET_00 & 0xFFFFFFFFL)) + seed;
+        this.bitflip12 = (SECRET_01 ^ SECRET_02) - (seed ^ Long.reverseBytes(seed & 0xFFFFFFFFL));
+        this.bitflip34 = (SECRET_03 ^ SECRET_04) + seed;
+        this.bitflip56 = (SECRET_05 ^ SECRET_06) - seed;
+
+        this.hash0 = avalanche64(seed ^ (SECRET_07 ^ SECRET_08));
+    }
+
+    private static long rrmxmx(long h64, final long length) {
+        h64 ^= Long.rotateLeft(h64, 49) ^ Long.rotateLeft(h64, 24);
+        h64 *= 0x9FB21C651E98DF25L;
+        h64 ^= (h64 >>> 35) + length;
+        h64 *= 0x9FB21C651E98DF25L;
+        return h64 ^ (h64 >>> 28);
+    }
+
+    private static long mix16B(final byte[] input, final int offIn, final long sec0, final long sec1) {
+        long lo = getLong(input, offIn);
+        long hi = getLong(input, offIn + 8);
+        return mix2Accs(lo, hi, sec0, sec1);
+    }
+
+    private static long mix16B(final CharSequence input, final int offIn, final long sec0, final long sec1) {
+        long lo = getLong(input, offIn);
+        long hi = getLong(input, offIn + 4);
+        return mix2Accs(lo, hi, sec0, sec1);
+    }
+
+    private static long avalanche64(long h64) {
+        h64 ^= h64 >>> 33;
+        h64 *= INIT_ACC_2;
+        h64 ^= h64 >>> 29;
+        h64 *= INIT_ACC_3;
+        return h64 ^ (h64 >>> 32);
+    }
+
+    private static long avalanche3(long h64) {
+        h64 ^= h64 >>> 37;
+        h64 *= 0x165667919E3779F9L;
+        return h64 ^ (h64 >>> 32);
+    }
+
+    private static long mix2Accs(final long lh, final long rh, long sec0, long sec8) {
+        return mix(lh ^ sec0, rh ^ sec8);
+    }
+
+    private static long contrib(long a, long b) {
+        long k = a ^ b;
+        return (0xFFFFFFFFL & k) * (k >>> 32);
+    }
+
+    private static long mixAcc(long acc, long sec) {
+        return (acc ^ (acc >>> 47) ^ sec) * INIT_ACC_7;
+    }
+
+    private static long mix(long a, long b) {
+        long x = a * b;
+        long y = Math.unsignedMultiplyHigh(a, b);
+        return x ^ y;
+    }
+
+    /**
+     * Starts a hash stream.
+     *
+     * @return a new {@link HashStream} instance
+     */
+    public HashStream hashStream() {
+        return new HashStreamImplBase();
+    }
+
+    /**
+     * Hashes a byte array to a 64-bit {@code long} value.
+     *
+     * <p>Equivalent to {@code hashToLong(input, (b, f) -> f.putBytes(b, off, len))}.
+     *
+     * @param input the byte array
+     * @param off the offset
+     * @param length the length
+     * @return the hash value
+     */
+    public long hashBytesToLong(final byte[] input, final int off, final int length) {
+        if (length <= 16) {
+            if (length > 8) {
+                long lo = getLong(input, off) ^ bitflip34;
+                long hi = getLong(input, off + length - 8) ^ bitflip56;
+                long acc = length + Long.reverseBytes(lo) + hi + mix(lo, hi);
+                return avalanche3(acc);
+            }
+            if (length >= 4) {
+                long input1 = getInt(input, off);
+                long input2 = getInt(input, off + length - 4);
+                long keyed = (input2 & 0xFFFFFFFFL) ^ (input1 << 32) ^ bitflip12;
+                return XXH3_64.rrmxmx(keyed, length);
+            }
+            if (length != 0) {
+                int c1 = input[off] & 0xFF;
+                int c2 = input[off + (length >> 1)];
+                int c3 = input[off + length - 1] & 0xFF;
+                long combined = ((c1 << 16) | (c2 << 24) | c3 | ((long) length << 8)) & 0xFFFFFFFFL;
+                return avalanche64(combined ^ bitflip00);
+            }
+            return hash0;
+        }
+        if (length <= 128) {
+            long acc = length * INIT_ACC_1;
+
+            if (length > 32) {
+                if (length > 64) {
+                    if (length > 96) {
+                        acc += XXH3_64.mix16B(input, off + 48, secret12, secret13);
+                        acc += XXH3_64.mix16B(input, off + length - 64, secret14, secret15);
+                    }
+                    acc += XXH3_64.mix16B(input, off + 32, secret08, secret09);
+                    acc += XXH3_64.mix16B(input, off + length - 48, secret10, secret11);
+                }
+                acc += XXH3_64.mix16B(input, off + 16, secret04, secret05);
+                acc += XXH3_64.mix16B(input, off + length - 32, secret06, secret07);
+            }
+            acc += XXH3_64.mix16B(input, off, secret00, secret01);
+            acc += XXH3_64.mix16B(input, off + length - 16, secret02, secret03);
+
+            return avalanche3(acc);
+        }
+        if (length <= 240) {
+            long acc = length * INIT_ACC_1;
+            acc += XXH3_64.mix16B(input, off, secret00, secret01);
+            acc += XXH3_64.mix16B(input, off + 16, secret02, secret03);
+            acc += XXH3_64.mix16B(input, off + 16 * 2, secret04, secret05);
+            acc += XXH3_64.mix16B(input, off + 16 * 3, secret06, secret07);
+            acc += XXH3_64.mix16B(input, off + 16 * 4, secret08, secret09);
+            acc += XXH3_64.mix16B(input, off + 16 * 5, secret10, secret11);
+            acc += XXH3_64.mix16B(input, off + 16 * 6, secret12, secret13);
+            acc += XXH3_64.mix16B(input, off + 16 * 7, secret14, secret15);
+
+            acc = avalanche3(acc);
+
+            if (length >= 144) {
+                acc += XXH3_64.mix16B(input, off + 128, secShift00, secShift01);
+                if (length >= 160) {
+                    acc += XXH3_64.mix16B(input, off + 144, secShift02, secShift03);
+                    if (length >= 176) {
+                        acc += XXH3_64.mix16B(input, off + 160, secShift04, secShift05);
+                        if (length >= 192) {
+                            acc += XXH3_64.mix16B(input, off + 176, secShift06, secShift07);
+                            if (length >= 208) {
+                                acc += XXH3_64.mix16B(input, off + 192, secShift08, secShift09);
+                                if (length >= 224) {
+                                    acc += XXH3_64.mix16B(input, off + 208, secShift10, secShift11);
+                                    if (length >= 240) acc += XXH3_64.mix16B(input, off + 224, secShift12, secShift13);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            acc += XXH3_64.mix16B(input, off + length - 16, secShift14, secShift15);
+            return avalanche3(acc);
+        }
+
+        long acc0 = INIT_ACC_0;
+        long acc1 = INIT_ACC_1;
+        long acc2 = INIT_ACC_2;
+        long acc3 = INIT_ACC_3;
+        long acc4 = INIT_ACC_4;
+        long acc5 = INIT_ACC_5;
+        long acc6 = INIT_ACC_6;
+        long acc7 = INIT_ACC_7;
+
+        final int nbBlocks = (length - 1) >>> BLOCK_LEN_EXP;
+        for (int n = 0; n < nbBlocks; n++) {
+            final int offBlock = off + (n << BLOCK_LEN_EXP);
+            for (int s = 0; s < 16; s += 1) {
+                int offStripe = offBlock + (s << 6);
+
+                long b0 = getLong(input, offStripe);
+                long b1 = getLong(input, offStripe + 8);
+                long b2 = getLong(input, offStripe + 8 * 2);
+                long b3 = getLong(input, offStripe + 8 * 3);
+                long b4 = getLong(input, offStripe + 8 * 4);
+                long b5 = getLong(input, offStripe + 8 * 5);
+                long b6 = getLong(input, offStripe + 8 * 6);
+                long b7 = getLong(input, offStripe + 8 * 7);
+
+                acc0 += b1 + contrib(b0, secret[s]);
+                acc1 += b0 + contrib(b1, secret[s + 1]);
+                acc2 += b3 + contrib(b2, secret[s + 2]);
+                acc3 += b2 + contrib(b3, secret[s + 3]);
+                acc4 += b5 + contrib(b4, secret[s + 4]);
+                acc5 += b4 + contrib(b5, secret[s + 5]);
+                acc6 += b7 + contrib(b6, secret[s + 6]);
+                acc7 += b6 + contrib(b7, secret[s + 7]);
+            }
+
+            acc0 = mixAcc(acc0, secret16);
+            acc1 = mixAcc(acc1, secret17);
+            acc2 = mixAcc(acc2, secret18);
+            acc3 = mixAcc(acc3, secret19);
+            acc4 = mixAcc(acc4, secret20);
+            acc5 = mixAcc(acc5, secret21);
+            acc6 = mixAcc(acc6, secret22);
+            acc7 = mixAcc(acc7, secret23);
+        }
+
+        final int nbStripes = ((length - 1) - (nbBlocks << BLOCK_LEN_EXP)) >>> 6;
+        final int offBlock = off + (nbBlocks << BLOCK_LEN_EXP);
+        for (int s = 0; s < nbStripes; s++) {
+            int offStripe = offBlock + (s << 6);
+
+            long b0 = getLong(input, offStripe);
+            long b1 = getLong(input, offStripe + 8);
+            long b2 = getLong(input, offStripe + 8 * 2);
+            long b3 = getLong(input, offStripe + 8 * 3);
+            long b4 = getLong(input, offStripe + 8 * 4);
+            long b5 = getLong(input, offStripe + 8 * 5);
+            long b6 = getLong(input, offStripe + 8 * 6);
+            long b7 = getLong(input, offStripe + 8 * 7);
+
+            acc0 += b1 + contrib(b0, secret[s]);
+            acc1 += b0 + contrib(b1, secret[s + 1]);
+            acc2 += b3 + contrib(b2, secret[s + 2]);
+            acc3 += b2 + contrib(b3, secret[s + 3]);
+            acc4 += b5 + contrib(b4, secret[s + 4]);
+            acc5 += b4 + contrib(b5, secret[s + 5]);
+            acc6 += b7 + contrib(b6, secret[s + 6]);
+            acc7 += b6 + contrib(b7, secret[s + 7]);
+        }
+
+        {
+            int offStripe = off + length - 64;
+
+            long b0 = getLong(input, offStripe);
+            long b1 = getLong(input, offStripe + 8);
+            long b2 = getLong(input, offStripe + 8 * 2);
+            long b3 = getLong(input, offStripe + 8 * 3);
+            long b4 = getLong(input, offStripe + 8 * 4);
+            long b5 = getLong(input, offStripe + 8 * 5);
+            long b6 = getLong(input, offStripe + 8 * 6);
+            long b7 = getLong(input, offStripe + 8 * 7);
+
+            acc0 += b1 + contrib(b0, secShift16);
+            acc1 += b0 + contrib(b1, secShift17);
+            acc2 += b3 + contrib(b2, secShift18);
+            acc3 += b2 + contrib(b3, secShift19);
+            acc4 += b5 + contrib(b4, secShift20);
+            acc5 += b4 + contrib(b5, secShift21);
+            acc6 += b7 + contrib(b6, secShift22);
+            acc7 += b6 + contrib(b7, secShift23);
+        }
+
+        return finalizeHash(length, acc0, acc1, acc2, acc3, acc4, acc5, acc6, acc7);
+    }
+
+    private long finalizeHash(
+            long length, long acc0, long acc1, long acc2, long acc3, long acc4, long acc5, long acc6, long acc7) {
+
+        long result64 = length * INIT_ACC_1
+                + mix2Accs(acc0, acc1, secShiftFinal0, secShiftFinal1)
+                + mix2Accs(acc2, acc3, secShiftFinal2, secShiftFinal3)
+                + mix2Accs(acc4, acc5, secShiftFinal4, secShiftFinal5)
+                + mix2Accs(acc6, acc7, secShiftFinal6, secShiftFinal7);
+
+        return avalanche3(result64);
+    }
+
+    public long hashCharsToLong(CharSequence charSequence) {
+
+        int len = charSequence.length();
+
+        if (len <= 8) {
+            if (len > 4) {
+                long lo = getLong(charSequence, 0) ^ bitflip34;
+                long hi = getLong(charSequence, len - 4) ^ bitflip56;
+                long acc = (len << 1) + Long.reverseBytes(lo) + hi + mix(lo, hi);
+                return avalanche3(acc);
+            }
+            if (len >= 2) {
+                long input1 = getInt(charSequence, 0);
+                long input2 = getInt(charSequence, len - 2);
+                long keyed = (input2 & 0xFFFFFFFFL) ^ (input1 << 32) ^ bitflip12;
+                return XXH3_64.rrmxmx(keyed, len << 1);
+            }
+            if (len != 0) {
+                long c = charSequence.charAt(0);
+                long combined = (c << 16) | (c >>> 8) | 512L;
+                return avalanche64(combined ^ bitflip00);
+            }
+            return hash0;
+        }
+        if (len <= 64) {
+            long acc = len * (INIT_ACC_1 << 1);
+
+            if (len > 16) {
+                if (len > 32) {
+                    if (len > 48) {
+                        acc += XXH3_64.mix16B(charSequence, 24, secret12, secret13);
+                        acc += XXH3_64.mix16B(charSequence, len - 32, secret14, secret15);
+                    }
+                    acc += XXH3_64.mix16B(charSequence, 16, secret08, secret09);
+                    acc += XXH3_64.mix16B(charSequence, len - 24, secret10, secret11);
+                }
+                acc += XXH3_64.mix16B(charSequence, 8, secret04, secret05);
+                acc += XXH3_64.mix16B(charSequence, len - 16, secret06, secret07);
+            }
+            acc += XXH3_64.mix16B(charSequence, 0, secret00, secret01);
+            acc += XXH3_64.mix16B(charSequence, len - 8, secret02, secret03);
+
+            return avalanche3(acc);
+        }
+        if (len <= 120) {
+            long acc = len * (INIT_ACC_1 << 1);
+            acc += XXH3_64.mix16B(charSequence, 0, secret00, secret01);
+            acc += XXH3_64.mix16B(charSequence, 8, secret02, secret03);
+            acc += XXH3_64.mix16B(charSequence, 16, secret04, secret05);
+            acc += XXH3_64.mix16B(charSequence, 24, secret06, secret07);
+            acc += XXH3_64.mix16B(charSequence, 32, secret08, secret09);
+            acc += XXH3_64.mix16B(charSequence, 40, secret10, secret11);
+            acc += XXH3_64.mix16B(charSequence, 48, secret12, secret13);
+            acc += XXH3_64.mix16B(charSequence, 56, secret14, secret15);
+
+            acc = avalanche3(acc);
+
+            if (len >= 72) {
+                acc += XXH3_64.mix16B(charSequence, 64, secShift00, secShift01);
+                if (len >= 80) {
+                    acc += XXH3_64.mix16B(charSequence, 72, secShift02, secShift03);
+                    if (len >= 88) {
+                        acc += XXH3_64.mix16B(charSequence, 80, secShift04, secShift05);
+                        if (len >= 96) {
+                            acc += XXH3_64.mix16B(charSequence, 88, secShift06, secShift07);
+                            if (len >= 104) {
+                                acc += XXH3_64.mix16B(charSequence, 96, secShift08, secShift09);
+                                if (len >= 112) {
+                                    acc += XXH3_64.mix16B(charSequence, 104, secShift10, secShift11);
+                                    if (len >= 120) acc += XXH3_64.mix16B(charSequence, 112, secShift12, secShift13);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            acc += XXH3_64.mix16B(charSequence, len - 8, secShift14, secShift15);
+            return avalanche3(acc);
+        }
+
+        long acc0 = INIT_ACC_0;
+        long acc1 = INIT_ACC_1;
+        long acc2 = INIT_ACC_2;
+        long acc3 = INIT_ACC_3;
+        long acc4 = INIT_ACC_4;
+        long acc5 = INIT_ACC_5;
+        long acc6 = INIT_ACC_6;
+        long acc7 = INIT_ACC_7;
+
+        final int nbBlocks = (len - 1) >>> (BLOCK_LEN_EXP - 1);
+        for (int n = 0; n < nbBlocks; n++) {
+            final int offBlock = n << (BLOCK_LEN_EXP - 1);
+            for (int s = 0; s < 16; s += 1) {
+                int offStripe = offBlock + (s << 5);
+
+                long b0 = getLong(charSequence, offStripe);
+                long b1 = getLong(charSequence, offStripe + 4);
+                long b2 = getLong(charSequence, offStripe + 4 * 2);
+                long b3 = getLong(charSequence, offStripe + 4 * 3);
+                long b4 = getLong(charSequence, offStripe + 4 * 4);
+                long b5 = getLong(charSequence, offStripe + 4 * 5);
+                long b6 = getLong(charSequence, offStripe + 4 * 6);
+                long b7 = getLong(charSequence, offStripe + 4 * 7);
+
+                acc0 += b1 + contrib(b0, secret[s]);
+                acc1 += b0 + contrib(b1, secret[s + 1]);
+                acc2 += b3 + contrib(b2, secret[s + 2]);
+                acc3 += b2 + contrib(b3, secret[s + 3]);
+                acc4 += b5 + contrib(b4, secret[s + 4]);
+                acc5 += b4 + contrib(b5, secret[s + 5]);
+                acc6 += b7 + contrib(b6, secret[s + 6]);
+                acc7 += b6 + contrib(b7, secret[s + 7]);
+            }
+
+            acc0 = mixAcc(acc0, secret16);
+            acc1 = mixAcc(acc1, secret17);
+            acc2 = mixAcc(acc2, secret18);
+            acc3 = mixAcc(acc3, secret19);
+            acc4 = mixAcc(acc4, secret20);
+            acc5 = mixAcc(acc5, secret21);
+            acc6 = mixAcc(acc6, secret22);
+            acc7 = mixAcc(acc7, secret23);
+        }
+
+        final int nbStripes = ((len - 1) - (nbBlocks << (BLOCK_LEN_EXP - 1))) >>> 5;
+        final int offBlock = nbBlocks << (BLOCK_LEN_EXP - 1);
+        for (int s = 0; s < nbStripes; s++) {
+            int offStripe = offBlock + (s << 5);
+
+            long b0 = getLong(charSequence, offStripe);
+            long b1 = getLong(charSequence, offStripe + 4);
+            long b2 = getLong(charSequence, offStripe + 4 * 2);
+            long b3 = getLong(charSequence, offStripe + 4 * 3);
+            long b4 = getLong(charSequence, offStripe + 4 * 4);
+            long b5 = getLong(charSequence, offStripe + 4 * 5);
+            long b6 = getLong(charSequence, offStripe + 4 * 6);
+            long b7 = getLong(charSequence, offStripe + 4 * 7);
+
+            acc0 += b1 + contrib(b0, secret[s]);
+            acc1 += b0 + contrib(b1, secret[s + 1]);
+            acc2 += b3 + contrib(b2, secret[s + 2]);
+            acc3 += b2 + contrib(b3, secret[s + 3]);
+            acc4 += b5 + contrib(b4, secret[s + 4]);
+            acc5 += b4 + contrib(b5, secret[s + 5]);
+            acc6 += b7 + contrib(b6, secret[s + 6]);
+            acc7 += b6 + contrib(b7, secret[s + 7]);
+        }
+
+        {
+            int offStripe = len - 32;
+
+            long b0 = getLong(charSequence, offStripe);
+            long b1 = getLong(charSequence, offStripe + 4);
+            long b2 = getLong(charSequence, offStripe + 4 * 2);
+            long b3 = getLong(charSequence, offStripe + 4 * 3);
+            long b4 = getLong(charSequence, offStripe + 4 * 4);
+            long b5 = getLong(charSequence, offStripe + 4 * 5);
+            long b6 = getLong(charSequence, offStripe + 4 * 6);
+            long b7 = getLong(charSequence, offStripe + 4 * 7);
+
+            acc0 += b1 + contrib(b0, secShift16);
+            acc1 += b0 + contrib(b1, secShift17);
+            acc2 += b3 + contrib(b2, secShift18);
+            acc3 += b2 + contrib(b3, secShift19);
+            acc4 += b5 + contrib(b4, secShift20);
+            acc5 += b4 + contrib(b5, secShift21);
+            acc6 += b7 + contrib(b6, secShift22);
+            acc7 += b6 + contrib(b7, secShift23);
+        }
+
+        return finalizeHash((long) len << 1, acc0, acc1, acc2, acc3, acc4, acc5, acc6, acc7);
+    }
+
+    private class HashStreamImplBase implements HashStream, AbstractHashStream {
+        private static final int BULK_SIZE = 256;
+        private static final int BULK_SIZE_HALF = 128;
+        private static final int BULK_SIZE_MASK = BULK_SIZE - 1;
+
+        private long acc0 = INIT_ACC_0;
+        private long acc1 = INIT_ACC_1;
+        private long acc2 = INIT_ACC_2;
+        private long acc3 = INIT_ACC_3;
+        private long acc4 = INIT_ACC_4;
+        private long acc5 = INIT_ACC_5;
+        private long acc6 = INIT_ACC_6;
+        private long acc7 = INIT_ACC_7;
+        private final byte[] buffer = new byte[BULK_SIZE + 8];
+        private int offset = 0;
+        private long byteCount = 0;
+
+        private void putByteImpl(byte v) {
+            if (offset >= BULK_SIZE) {
+                processBuffer();
+                offset -= BULK_SIZE;
+            }
+            buffer[offset] = v;
+            offset += 1;
+            byteCount += 1;
+        }
+
+        private void putShortImpl(short v) {
+            setShort(buffer, offset, v);
+            if (offset >= BULK_SIZE - 1) {
+                processBuffer();
+                offset -= BULK_SIZE;
+                setShort(buffer, 0, (short) (v >>> (-offset << 3)));
+            }
+            offset += 2;
+            byteCount += 2;
+        }
+
+        private void putCharImpl(char v) {
+            setChar(buffer, offset, v);
+            if (offset >= BULK_SIZE - 1) {
+                processBuffer();
+                offset -= BULK_SIZE;
+                setChar(buffer, 0, (char) (v >>> (-offset << 3)));
+            }
+            offset += 2;
+            byteCount += 2;
+        }
+
+        private void putIntImpl(int v) {
+            setInt(buffer, offset, v);
+            if (offset >= BULK_SIZE - 3) {
+                processBuffer();
+                offset -= BULK_SIZE;
+                setInt(buffer, 0, v >>> (-offset << 3));
+            }
+            offset += 4;
+            byteCount += 4;
+        }
+
+        private void putLongImpl(long v) {
+            setLong(buffer, offset, v);
+            if (offset >= BULK_SIZE - 7) {
+                processBuffer();
+                offset -= BULK_SIZE;
+                setLong(buffer, 0, v >>> (-offset << 3));
+            }
+            offset += 8;
+            byteCount += 8;
+        }
+
+        private void putBytesImpl(byte[] b, int off, final int len) {
+            int remaining = len;
+            final int x = BULK_SIZE - offset;
+            if (len > x) {
+                int s = (int) ((byteCount - 1) >>> 6) & 12;
+                if (offset > 0) {
+                    System.arraycopy(b, off, buffer, offset, x);
+                    processBuffer(0, buffer, s);
+                    offset = 0;
+                    off += x;
+                    remaining -= x;
+                }
+                if (remaining > BULK_SIZE) {
+                    do {
+                        s += 4;
+                        s &= 12;
+                        processBuffer(off, b, s);
+                        off += BULK_SIZE;
+                        remaining -= BULK_SIZE;
+                    } while (remaining > BULK_SIZE);
+                    if (remaining < 64) {
+                        int l = 64 - remaining;
+                        System.arraycopy(b, off - l, buffer, BULK_SIZE - l, l);
+                    }
+                }
+            }
+            System.arraycopy(b, off, buffer, offset, remaining);
+            offset += remaining;
+            byteCount += len;
+        }
+
+        private void putCharsImpl(CharSequence c) {
+            int off = 0;
+            int remaining = c.length();
+            final int x = BULK_SIZE_HALF - (offset >>> 1);
+            if ((offset & 1) == 0) {
+                if (c.length() > x) {
+                    int s = (int) ((byteCount - 1) >>> 6) & 12;
+                    if (offset > 0) {
+                        copyCharsToByteArray(c, 0, buffer, offset, x);
+                        processBuffer(0, buffer, s);
+                        offset = 0;
+                        off += x;
+                        remaining -= x;
+                    }
+                    if (remaining > BULK_SIZE_HALF) {
+                        do {
+                            s += 4;
+                            s &= 12;
+                            processBuffer(off, c, s);
+                            off += BULK_SIZE_HALF;
+                            remaining -= BULK_SIZE_HALF;
+                        } while (remaining > BULK_SIZE_HALF);
+                        if (remaining < 32) {
+                            int l = 32 - remaining;
+                            copyCharsToByteArray(c, off - l, buffer, BULK_SIZE - (l << 1), l);
+                        }
+                    }
+                }
+            } else {
+                if (c.length() >= x) {
+                    long extraByte;
+                    int s = (int) ((byteCount - 1) >>> 6) & 12;
+                    copyCharsToByteArray(c, 0, buffer, offset, x);
+                    extraByte = buffer[BULK_SIZE] & 0xFFL;
+                    processBuffer(0, buffer, s);
+                    offset = 1;
+                    off += x;
+                    remaining -= x;
+                    if (remaining >= BULK_SIZE_HALF) {
+                        do {
+                            s += 4;
+                            s &= 12;
+                            extraByte = processBuffer(off, c, s, extraByte);
+                            off += BULK_SIZE_HALF;
+                            remaining -= BULK_SIZE_HALF;
+                        } while (remaining >= BULK_SIZE_HALF);
+                        if (remaining < 32) {
+                            int l = 32 - remaining;
+                            copyCharsToByteArray(c, off - l, buffer, BULK_SIZE + 1 - (l << 1), l);
+                        }
+                    }
+                    buffer[0] = (byte) extraByte;
+                }
+            }
+            copyCharsToByteArray(c, off, buffer, offset, remaining);
+            offset += remaining << 1;
+            byteCount += (long) c.length() << 1;
+        }
+
+        protected void resetImpl() {
+            acc0 = INIT_ACC_0;
+            acc1 = INIT_ACC_1;
+            acc2 = INIT_ACC_2;
+            acc3 = INIT_ACC_3;
+            acc4 = INIT_ACC_4;
+            acc5 = INIT_ACC_5;
+            acc6 = INIT_ACC_6;
+            acc7 = INIT_ACC_7;
+            offset = 0;
+            byteCount = 0;
+        }
+
+        private void processBuffer() {
+            int s = (int) ((byteCount - 1) >>> 6) & 12;
+            processBuffer(0, buffer, s);
+        }
+
+        private void mixAcc() {
+            acc0 = XXH3_64.mixAcc(acc0, secret16);
+            acc1 = XXH3_64.mixAcc(acc1, secret17);
+            acc2 = XXH3_64.mixAcc(acc2, secret18);
+            acc3 = XXH3_64.mixAcc(acc3, secret19);
+            acc4 = XXH3_64.mixAcc(acc4, secret20);
+            acc5 = XXH3_64.mixAcc(acc5, secret21);
+            acc6 = XXH3_64.mixAcc(acc6, secret22);
+            acc7 = XXH3_64.mixAcc(acc7, secret23);
+        }
+
+        private void processBuffer(int off, byte[] buffer, int s) {
+            for (int i = 0; i < 4; ++i) {
+                int o = off + (i << 6);
+                long b0 = getLong(buffer, o);
+                long b1 = getLong(buffer, o + 8);
+                long b2 = getLong(buffer, o + 8 * 2);
+                long b3 = getLong(buffer, o + 8 * 3);
+                long b4 = getLong(buffer, o + 8 * 4);
+                long b5 = getLong(buffer, o + 8 * 5);
+                long b6 = getLong(buffer, o + 8 * 6);
+                long b7 = getLong(buffer, o + 8 * 7);
+                processBuffer(b0, b1, b2, b3, b4, b5, b6, b7, s + i);
+            }
+            if (s == 12) {
+                mixAcc();
+            }
+        }
+
+        private void processBuffer(int off, CharSequence c, int s) {
+            for (int i = 0; i < 4; ++i) {
+                int o = off + (i << 5);
+                long b0 = getLong(c, o);
+                long b1 = getLong(c, o + 4);
+                long b2 = getLong(c, o + 4 * 2);
+                long b3 = getLong(c, o + 4 * 3);
+                long b4 = getLong(c, o + 4 * 4);
+                long b5 = getLong(c, o + 4 * 5);
+                long b6 = getLong(c, o + 4 * 6);
+                long b7 = getLong(c, o + 4 * 7);
+                processBuffer(b0, b1, b2, b3, b4, b5, b6, b7, s + i);
+            }
+            if (s == 12) {
+                mixAcc();
+            }
+        }
+
+        private long processBuffer(int off, CharSequence c, int s, long extraByte) {
+
+            for (int i = 0; i < 4; ++i) {
+                int o = off + (i << 5);
+
+                long b0 = getLong(c, o);
+                long b1 = getLong(c, o + 4);
+                long b2 = getLong(c, o + 4 * 2);
+                long b3 = getLong(c, o + 4 * 3);
+                long b4 = getLong(c, o + 4 * 4);
+                long b5 = getLong(c, o + 4 * 5);
+                long b6 = getLong(c, o + 4 * 6);
+                long b7 = getLong(c, o + 4 * 7);
+
+                long y = b7 >>> 56;
+                b7 = (b6 >>> 56) | (b7 << 8);
+                b6 = (b5 >>> 56) | (b6 << 8);
+                b5 = (b4 >>> 56) | (b5 << 8);
+                b4 = (b3 >>> 56) | (b4 << 8);
+                b3 = (b2 >>> 56) | (b3 << 8);
+                b2 = (b1 >>> 56) | (b2 << 8);
+                b1 = (b0 >>> 56) | (b1 << 8);
+                b0 = extraByte | (b0 << 8);
+                extraByte = y;
+
+                processBuffer(b0, b1, b2, b3, b4, b5, b6, b7, s + i);
+            }
+            if (s == 12) {
+                mixAcc();
+            }
+
+            return extraByte;
+        }
+
+        private void processBuffer(long b0, long b1, long b2, long b3, long b4, long b5, long b6, long b7, int s) {
+            acc0 += b1 + contrib(b0, secret[s]);
+            acc1 += b0 + contrib(b1, secret[s + 1]);
+            acc2 += b3 + contrib(b2, secret[s + 2]);
+            acc3 += b2 + contrib(b3, secret[s + 3]);
+            acc4 += b5 + contrib(b4, secret[s + 4]);
+            acc5 += b4 + contrib(b5, secret[s + 5]);
+            acc6 += b7 + contrib(b6, secret[s + 6]);
+            acc7 += b6 + contrib(b7, secret[s + 7]);
+        }
+
+        public long getAsLong() {
+            if (byteCount >= 0 && byteCount <= BULK_SIZE) {
+                return hashBytesToLong(buffer, 0, (int) byteCount);
+            }
+            setLong(buffer, BULK_SIZE, getLong(buffer, 0));
+
+            long acc0Loc = acc0;
+            long acc1Loc = acc1;
+            long acc2Loc = acc2;
+            long acc3Loc = acc3;
+            long acc4Loc = acc4;
+            long acc5Loc = acc5;
+            long acc6Loc = acc6;
+            long acc7Loc = acc7;
+
+            for (int off = 0, s = (((int) byteCount - 1) >>> 6) & 12;
+                    off + 64 <= (((int) byteCount - 1) & BULK_SIZE_MASK);
+                    off += 64, s += 1) {
+
+                long b0 = getLong(buffer, off);
+                long b1 = getLong(buffer, off + 8);
+                long b2 = getLong(buffer, off + 8 * 2);
+                long b3 = getLong(buffer, off + 8 * 3);
+                long b4 = getLong(buffer, off + 8 * 4);
+                long b5 = getLong(buffer, off + 8 * 5);
+                long b6 = getLong(buffer, off + 8 * 6);
+                long b7 = getLong(buffer, off + 8 * 7);
+
+                acc0Loc += b1 + contrib(b0, secret[s]);
+                acc1Loc += b0 + contrib(b1, secret[s + 1]);
+                acc2Loc += b3 + contrib(b2, secret[s + 2]);
+                acc3Loc += b2 + contrib(b3, secret[s + 3]);
+                acc4Loc += b5 + contrib(b4, secret[s + 4]);
+                acc5Loc += b4 + contrib(b5, secret[s + 5]);
+                acc6Loc += b7 + contrib(b6, secret[s + 6]);
+                acc7Loc += b6 + contrib(b7, secret[s + 7]);
+            }
+
+            {
+                long b0 = getLong(buffer, (offset - (64)) & BULK_SIZE_MASK);
+                long b1 = getLong(buffer, (offset - (64 - 8)) & BULK_SIZE_MASK);
+                long b2 = getLong(buffer, (offset - (64 - 8 * 2)) & BULK_SIZE_MASK);
+                long b3 = getLong(buffer, (offset - (64 - 8 * 3)) & BULK_SIZE_MASK);
+                long b4 = getLong(buffer, (offset - (64 - 8 * 4)) & BULK_SIZE_MASK);
+                long b5 = getLong(buffer, (offset - (64 - 8 * 5)) & BULK_SIZE_MASK);
+                long b6 = getLong(buffer, (offset - (64 - 8 * 6)) & BULK_SIZE_MASK);
+                long b7 = getLong(buffer, (offset - (64 - 8 * 7)) & BULK_SIZE_MASK);
+
+                acc0Loc += b1 + contrib(b0, secShift16);
+                acc1Loc += b0 + contrib(b1, secShift17);
+                acc2Loc += b3 + contrib(b2, secShift18);
+                acc3Loc += b2 + contrib(b3, secShift19);
+                acc4Loc += b5 + contrib(b4, secShift20);
+                acc5Loc += b4 + contrib(b5, secShift21);
+                acc6Loc += b7 + contrib(b6, secShift22);
+                acc7Loc += b6 + contrib(b7, secShift23);
+            }
+
+            return finalizeHash(byteCount, acc0Loc, acc1Loc, acc2Loc, acc3Loc, acc4Loc, acc5Loc, acc6Loc, acc7Loc);
+        }
+
+        @Override
+        public HashStream putByte(byte v) {
+            putByteImpl(v);
+            return this;
+        }
+
+        @Override
+        public HashStream putShort(short v) {
+            putShortImpl(v);
+            return this;
+        }
+
+        @Override
+        public HashStream putChar(char v) {
+            putCharImpl(v);
+            return this;
+        }
+
+        @Override
+        public HashStream putInt(int v) {
+            putIntImpl(v);
+            return this;
+        }
+
+        @Override
+        public HashStream putLong(long v) {
+            putLongImpl(v);
+            return this;
+        }
+
+        @Override
+        public HashStream putBytes(byte[] b, int off, final int len) {
+            putBytesImpl(b, off, len);
+            return this;
+        }
+
+        @Override
+        public HashStream putChars(CharSequence c) {
+            putCharsImpl(c);
+            return this;
+        }
+
+        @Override
+        public HashStream reset() {
+            resetImpl();
+            return this;
+        }
+    }
+}
diff --git a/pbj-integration-tests/build.gradle.kts b/pbj-integration-tests/build.gradle.kts
index 31913083..1b21018c 100644
--- a/pbj-integration-tests/build.gradle.kts
+++ b/pbj-integration-tests/build.gradle.kts
@@ -44,6 +44,8 @@ testModuleInfo {
     requires("io.helidon.common")
     requires("io.helidon.common.tls")
     requires("io.helidon.webclient.api")
+    requires("org.lz4.java")
+    requires("hash4j")
     runtimeOnly("io.helidon.webclient.http2")
     requires("io.helidon.webserver")
     runtimeOnly("io.grpc.netty")
@@ -52,6 +54,8 @@ testModuleInfo {
 }
 
 jmhModuleInfo {
+    requires("org.lz4.java")
+    requires("hash4j")
     requires("com.hedera.pbj.runtime")
     requires("com.google.protobuf.util")
 }
@@ -64,12 +68,19 @@ configurations.testRuntimeClasspath {
 }
 
 // IMPROVE: Test code should not have a direct dependency to 'com.hedera.pbj.compiler'
-dependencies { testImplementation("com.hedera.pbj:pbj-compiler") { isTransitive = false } }
+dependencies {
+    testImplementation("com.hedera.pbj:pbj-compiler") { isTransitive = false }
+    implementation("org.lz4:lz4-java:1.8.0")
+    implementation("com.dynatrace.hash4j:hash4j:0.25.0")
+}
 
 dependencyAnalysis { issues { all { onAny { exclude("com.hedera.pbj:pbj-compiler") } } } }
 
 // IMPROVE: JMH code should not depend on test code
-jmh { includeTests = true }
+jmh {
+    includeTests = true
+    includes = listOf("com.hedera.pbj.integration.jmh.hashing.NonCryptographicHashingBench")
+}
 
 // Avoid a clash with Google protoc models when .proto files don't specify `pbj.java_package`:
 pbj { javaPackageSuffix = ".pbj.integration.tests" }
diff --git a/pbj-integration-tests/gradle/modules.properties b/pbj-integration-tests/gradle/modules.properties
new file mode 100644
index 00000000..460eae7d
--- /dev/null
+++ b/pbj-integration-tests/gradle/modules.properties
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+
+# Jars that are not yet modules used in the integration tests.
+com.google.api.gax=com.google.api:gax
+org.lz4.java=org.lz4:lz4-java
+hash4j=com.dynatrace.hash4j:hash4j
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashingBench.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashingBench.java
index 89566b5a..446099c7 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashingBench.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/NonCryptographicHashingBench.java
@@ -6,6 +6,7 @@
 import com.hedera.pbj.integration.jmh.hashing.functions.CityHashVarHandle;
 import com.hedera.pbj.integration.jmh.hashing.functions.FarmHash;
 import com.hedera.pbj.integration.jmh.hashing.functions.Guava;
+import com.hedera.pbj.integration.jmh.hashing.functions.Hash4j;
 import com.hedera.pbj.integration.jmh.hashing.functions.HighwayHash;
 import com.hedera.pbj.integration.jmh.hashing.functions.JavaStyleHashing;
 import com.hedera.pbj.integration.jmh.hashing.functions.LeemonMurmur;
@@ -23,8 +24,10 @@
 import com.hedera.pbj.integration.jmh.hashing.functions.XxHash;
 import com.hedera.pbj.integration.jmh.hashing.functions.XxHashRichard;
 import com.hedera.pbj.integration.jmh.hashing.functions.Xxh3AiCPort;
+import com.hedera.pbj.integration.jmh.hashing.functions.Xxh3Lz4;
 import com.hedera.pbj.integration.jmh.hashing.functions.Xxh3ai;
 import com.hedera.pbj.runtime.NonCryptographicHashing;
+import com.hedera.pbj.runtime.hashing.XXH3_64;
 import java.util.List;
 import java.util.Random;
 import java.util.concurrent.TimeUnit;
@@ -91,6 +94,13 @@ public enum HashAlgorithm {
         SIP_24_GUAVA(Guava::sipHash24),
         LUCENE_MURMUR3(LuceneMurmur3::murmurhash3_x86_32),
         LUCENE_MURMUR3_128(LuceneMurmur3::murmurhash3_x64_128),
+        XXH64_LZ4_JAVA(Xxh3Lz4::xxh_64bits_java),
+        XXH64_LZ4_NATIVE(Xxh3Lz4::xxh_64bits_native),
+        FARM_HASH_NA_HASH4J(Hash4j::hash_farm_hash),
+        FARM_HASH_UO_HASH4J(Hash4j::hash_farm_hash_uo),
+        XXH3_64_HASH4J(Hash4j::hash_xxh3_64),
+        MURMUR3_HASH4J(Hash4j::hash_murmur_3_32),
+        XXH3_64_PBJ(XXH3_64::hash_xxh3_64),
         ;
 
         public final HashFunction function;
@@ -139,7 +149,14 @@ public enum HashAlgorithm {
         "SIP_24_GUAVA",
         "LUCENE_MURMUR3",
         "LUCENE_MURMUR3_128",
-        "XXH3_AI_C_PORT"
+        "XXH3_AI_C_PORT",
+        "XXH64_LZ4_JAVA",
+        "XXH64_LZ4_NATIVE",
+        "FARM_HASH_NA_HASH4J",
+        "FARM_HASH_UO_HASH4J",
+        "XXH3_64_HASH4J",
+        "MURMUR3_HASH4J",
+        "XXH3_64_PBJ",
     })
     public HashAlgorithm hashAlgorithm;
 
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/XxhTest.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/XxhTest.java
new file mode 100644
index 00000000..1cdc800f
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/XxhTest.java
@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing;
+
+import com.hedera.pbj.integration.jmh.hashing.functions.XXH3OpenHFT;
+import com.hedera.pbj.integration.jmh.hashing.functions.XXH3OpenHFT2;
+import com.hedera.pbj.integration.jmh.hashing.functions.Xxh3AiCPort;
+import com.hedera.pbj.integration.jmh.hashing.functions.Xxh3Lz4;
+import com.hedera.pbj.integration.jmh.hashing.functions.Xxh3ai;
+import com.hedera.pbj.integration.jmh.hashing.functions.XxhSumCommandLine;
+import com.hedera.pbj.runtime.hashing.XXH3_64;
+import java.util.HexFormat;
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.IntStream;
+
+public class XxhTest {
+    public static void main3(String[] args) {
+        // test with a large random data set
+        Random random = new Random(18971947891479L);
+        final AtomicBoolean allMatch = new AtomicBoolean(true);
+        IntStream.range(0, 5_000)
+                                .parallel()
+                .forEach(i -> {
+                    byte[] randomData = new byte[1 + random.nextInt(50)];
+                    //            byte[] randomData = new byte[1 + random.nextInt(10)];
+                    random.nextBytes(randomData);
+                    long testCodeHashResult = XXH3_64.hash_xxh3_64(randomData, 0, randomData.length);
+                    long referenceExpectedHash = XxhSumCommandLine.hashXxh3_64(randomData, 0, randomData.length);
+                    if (testCodeHashResult != referenceExpectedHash) {
+                        System.err.printf(
+                                "Mismatch for random data %d: Input: %s, Expected xxhsum: %016x, Xxh3AiCPort: %016x %n",
+                                i, HexFormat.of().formatHex(randomData), referenceExpectedHash, testCodeHashResult);
+                        allMatch.set(false);
+                    }
+                });
+        if (allMatch.get()) {
+            System.out.println("All random data hashes match!");
+        } else {
+            System.err.println("Some random data hashes did not match!");
+        }
+    }
+
+    public static void main(String[] args) {
+        // compare hashes with other implementations
+        byte[] data = "hello world".getBytes();
+        System.out.println("Input data: " + HexFormat.of().formatHex(data));
+        long hash64 = Xxh3AiCPort.xxh3_64bits(data, 0, data.length);
+        long hash64_lz4_java = Xxh3Lz4.xxh_64bits_java(data, 0, data.length);
+        long hash64_lz4_native = Xxh3Lz4.xxh_64bits_native(data, 0, data.length);
+        long hash64ai = Xxh3ai.xxh3HashCode(data, 0, data.length);
+        long hash64OpenHFT = XXH3OpenHFT.hash64(data, 0, data.length);
+        long hash64OpenHFT2 = XXH3OpenHFT2.hash64(data, 0, data.length);
+        long hashSumXxh_64 = XxhSumCommandLine.hashXxh_64(data, 0, data.length);
+        long hashSumXxh3_64 = XxhSumCommandLine.hashXxh3_64(data, 0, data.length);
+        long hashXxh3Pbj = XXH3_64.hash_xxh3_64(data, 0, data.length);
+        // print hashes in hex
+        System.out.printf("XXH3 64-bit hash:                %016x%n", hash64);
+        System.out.printf("XXH3 64-bit hash (LZ4 Java):     %016x%n", hash64_lz4_java);
+        System.out.printf("XXH3 64-bit hash (LZ4 Native):   %016x%n", hash64_lz4_native);
+        System.out.printf("XXH3 64-bit ai hash:             %016x%n", hash64ai);
+        System.out.printf("XXH3 OpenHFT 64-bit hash:        %016x%n", hash64OpenHFT);
+        System.out.printf("XXH3 OpenHFT2 64-bit hash:       %016x%n", hash64OpenHFT2);
+        System.out.printf("XXH3 xxhsum 64-bit hash:         %016x%n", hashSumXxh_64);
+        System.out.printf("XXH3 xxhsum 64-bit hash (XXH3):  %016x%n", hashSumXxh3_64);
+        System.out.printf("XXH3 PBJ 64-bit hash:            %016x%n", hashXxh3Pbj);
+
+        // test with a large random data set
+        Random random = new Random(18971947891479L);
+        for (int i = 0; i < 10; i++) {
+            byte[] randomData = new byte[1 + random.nextInt(1023)];
+            random.nextBytes(randomData);
+            long hash64Random = Xxh3AiCPort.xxh3_64bits(randomData, 0, randomData.length);
+            long hash64aiRandom = Xxh3ai.xxh3HashCode(randomData, 0, randomData.length);
+            long hash64OpenHFTRandom = XXH3OpenHFT.hash64(randomData, 0, randomData.length);
+            long hash64OpenHFT2Random = XXH3OpenHFT2.hash64(randomData, 0, randomData.length);
+            long hashSumXxh_64Random = XxhSumCommandLine.hashXxh_64(randomData, 0, randomData.length);
+            long hashSumXxh3_64Random = XxhSumCommandLine.hashXxh3_64(randomData, 0, randomData.length);
+            System.out.printf(
+                    "Random data %d: expected xxh64: %016x expected xxh3_64: %016x -- XXH3 64-bit: %016x, ai: %016x, OpenHFT: %016x, OpenHFT2: %016x%n",
+                    i,
+                    hashSumXxh_64Random,
+                    hashSumXxh3_64Random,
+                    hash64Random,
+                    hash64aiRandom,
+                    hash64OpenHFTRandom,
+                    hash64OpenHFT2Random);
+        }
+        final AtomicBoolean allMatch = new AtomicBoolean(true);
+        IntStream.range(0, 100).parallel().forEach(i -> {
+            byte[] randomData = new byte[1 + random.nextInt(1023)];
+            random.nextBytes(randomData);
+            long hash64OpenHFT2Random = XXH3OpenHFT2.hash64(randomData, 0, randomData.length);
+            long hashSumXxh3_64Random = XxhSumCommandLine.hashXxh3_64(randomData, 0, randomData.length);
+            if (hash64OpenHFT2Random != hashSumXxh3_64Random) {
+                System.err.printf(
+                        "Mismatch for random data %d: Input: %s, Expected xxhsum: %016x, OpenHFT2: %016x %n",
+                        i, HexFormat.of().formatHex(randomData), hashSumXxh3_64Random, hash64OpenHFT2Random);
+                allMatch.set(false);
+            }
+        });
+        if (allMatch.get()) {
+            System.out.println("All random data hashes match!");
+        } else {
+            System.err.println("Some random data hashes did not match!");
+        }
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/CityHash.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/CityHash.java
index 24c7b6fc..508c6442 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/CityHash.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/CityHash.java
@@ -168,4 +168,12 @@ public static long cityHash64(byte[] s, int pos, int len) {
         } while (len != 0);
         return hashLen16(hashLen16(v[0], w[0]) + shiftMix(y) * k1 + z, hashLen16(v[1], w[1]) + x);
     }
+    public static void main(String[] args) {
+        int x = 0;
+        for(int i = 0; i < 100; i++) {
+            int pairCount = i/2;
+            int pairCount2 = x++ >> 1;
+            System.out.println(i+" -> pairCount = " + pairCount+ ", pairCount2 = " + pairCount2+" (($xx_fieldCount & 1) == 0)="+((i & 1) == 0));
+        }
+    }
 }
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Hash4j.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Hash4j.java
new file mode 100644
index 00000000..0ac09bf6
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Hash4j.java
@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+import com.dynatrace.hash4j.hashing.Hasher32;
+import com.dynatrace.hash4j.hashing.Hasher64;
+import com.dynatrace.hash4j.hashing.Hashing;
+
+public class Hash4j {
+    private static final Hasher64 XXH_3_64 = Hashing.xxh3_64(0);
+    private static final Hasher64 FARM_HASH_NA = Hashing.farmHashNa();
+    private static final Hasher64 FARM_HASH_UO = Hashing.farmHashUo();
+    private static final Hasher32 MURMUR3 = Hashing.murmur3_32();
+
+    public static long hash_xxh3_64(final byte[] bytes, int start, int length) {
+        return XXH_3_64.hashBytesToLong(bytes, start, length);
+    }
+
+    public static long hash_farm_hash(final byte[] bytes, int start, int length) {
+        return FARM_HASH_NA.hashBytesToLong(bytes, start, length);
+    }
+
+    public static long hash_farm_hash_uo(final byte[] bytes, int start, int length) {
+        return FARM_HASH_UO.hashBytesToLong(bytes, start, length);
+    }
+
+    public static int hash_murmur_3_32(final byte[] bytes, int start, int length) {
+        return MURMUR3.hashBytesToInt(bytes, start, length);
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XXH3OpenHFT2.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XXH3OpenHFT2.java
index be34b5dd..95885132 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XXH3OpenHFT2.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XXH3OpenHFT2.java
@@ -132,18 +132,19 @@ public static long hash64(final byte[] input, final int off, final int length) {
             if (length >= 4) {
                 // XXH3_len_4to8_64b
                 long s = SEED ^ Long.reverseBytes(SEED & 0xFFFFFFFFL);
-                final long input1 = i32(input, off); // high int will be shifted
-                final long input2 = u32(input, off + length - 4);
+                final long input1 = u32(input, off); // first 4 bytes
+                final long input2 = u32(input, off + length - 4); // last 4 bytes
                 final long bitflip = (i64(XXH3_kSecret, 8) ^ i64(XXH3_kSecret, 16)) - s;
-                final long keyed = (input2 + (input1 << 32)) ^ bitflip;
+                final long keyed = (((input1 & 0xFFFFFFFFL) << 32) | (input2 & 0xFFFFFFFFL)) ^ bitflip;
                 return XXH3_rrmxmx(keyed, length);
             }
             if (length != 0) {
                 // XXH3_len_1to3_64b
                 final int c1 = u8(input, off);
-                final int c2 = i8(input, off + (length >> 1)); // high 3 bytes will be shifted
+                final int c2 = u8(input, off + (length >> 1));
                 final int c3 = u8(input, off + length - 1);
-                final long combined = unsignedInt((c1 << 16) | (c2 << 24) | c3 | (length << 8));
+                final long combined =
+                        ((c1 & 0xFFL) << 16) | ((c2 & 0xFFL) << 24) | ((c3 & 0xFFL)) | ((long) length << 8);
                 final long bitflip = unsignedInt(i32(XXH3_kSecret, 0) ^ i32(XXH3_kSecret, 4)) + SEED;
                 return XXH64_avalanche(combined ^ bitflip);
             }
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XxHash.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XxHash.java
index 61e5246c..0dd5b60d 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XxHash.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XxHash.java
@@ -3,6 +3,9 @@
 
 import edu.umd.cs.findbugs.annotations.NonNull;
 
+/**
+ * AI written port of the xxHash 32bit algorithm
+ */
 public class XxHash {
 
     public static int xxHashCodeFast(@NonNull final byte[] bytes, int start, int length) {
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Xxh3AiCPort.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Xxh3AiCPort.java
new file mode 100644
index 00000000..89fa4e20
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Xxh3AiCPort.java
@@ -0,0 +1,264 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+
+/**
+ * Java port of XXH3 hash functions from xxHash library.
+ * Implements both 32-bit and 64-bit variants with optimized paths for different input sizes.
+ */
+public final class Xxh3AiCPort {
+    private static final VarHandle LONG_HANDLE =
+            MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.LITTLE_ENDIAN);
+
+    // XXH3 constants
+    private static final long XXH_PRIME32_1 = 0x9E3779B1L;
+    private static final long XXH_PRIME32_2 = 0x85EBCA77L;
+    private static final long XXH_PRIME32_3 = 0xC2B2AE3DL;
+    private static final long XXH_PRIME64_1 = 0x9E3779B185EBCA87L;
+    private static final long XXH_PRIME64_2 = 0xC2B2AE3D27D4EB4FL;
+    private static final long XXH_PRIME64_3 = 0x165667B19E3779F9L;
+    private static final long XXH_PRIME64_4 = 0x85EBCA77C2B2AE63L;
+    private static final long XXH_PRIME64_5 = 0x27D4EB2F165667C5L;
+
+    private static final long PRIME_MX1 = 0x165667919E3779F9L;
+    private static final long PRIME_MX2 = 0x9FB21C651E98DF25L;
+
+    private static final int XXH_STRIPE_LEN = 64;
+    private static final int XXH3_MIDSIZE_MAX = 240;
+    private static final int XXH3_SECRET_SIZE_MIN = 136;
+
+    // Default secret (first 192 bytes from XXH3_kSecret)
+    private static final byte[] XXH3_SECRET = {
+        (byte) 0xb8, (byte) 0xfe, (byte) 0x6c, (byte) 0x39, (byte) 0x23, (byte) 0xa4, (byte) 0x4b, (byte) 0xbe,
+        (byte) 0x7c, (byte) 0x01, (byte) 0x81, (byte) 0x2c, (byte) 0xf7, (byte) 0x21, (byte) 0xad, (byte) 0x1c,
+        (byte) 0xde, (byte) 0xd4, (byte) 0x6d, (byte) 0xe9, (byte) 0x83, (byte) 0x90, (byte) 0x97, (byte) 0xdb,
+        (byte) 0x72, (byte) 0x40, (byte) 0xa4, (byte) 0xa4, (byte) 0xb7, (byte) 0xb3, (byte) 0x67, (byte) 0x1f,
+        (byte) 0xcb, (byte) 0x79, (byte) 0xe6, (byte) 0x4e, (byte) 0xcc, (byte) 0xc0, (byte) 0xe5, (byte) 0x78,
+        (byte) 0x82, (byte) 0x5a, (byte) 0xd0, (byte) 0x7d, (byte) 0xcc, (byte) 0xff, (byte) 0x72, (byte) 0x21,
+        (byte) 0xb8, (byte) 0x08, (byte) 0x46, (byte) 0x74, (byte) 0xf7, (byte) 0x43, (byte) 0x24, (byte) 0x8e,
+        (byte) 0xe0, (byte) 0x35, (byte) 0x90, (byte) 0xe6, (byte) 0x81, (byte) 0x3a, (byte) 0x26, (byte) 0x4c,
+        (byte) 0x3c, (byte) 0x28, (byte) 0x52, (byte) 0xbb, (byte) 0x91, (byte) 0xc3, (byte) 0x00, (byte) 0xcb,
+        (byte) 0x88, (byte) 0xd0, (byte) 0x65, (byte) 0x8b, (byte) 0x1b, (byte) 0x53, (byte) 0x2e, (byte) 0xa3,
+        (byte) 0x71, (byte) 0x64, (byte) 0x48, (byte) 0x97, (byte) 0xa2, (byte) 0x0d, (byte) 0xf9, (byte) 0x4e,
+        (byte) 0x38, (byte) 0x19, (byte) 0xef, (byte) 0x46, (byte) 0xa9, (byte) 0xde, (byte) 0xac, (byte) 0xd8,
+        (byte) 0xa8, (byte) 0xfa, (byte) 0x76, (byte) 0x3f, (byte) 0xe3, (byte) 0x9c, (byte) 0x34, (byte) 0x3f,
+        (byte) 0xf9, (byte) 0xdc, (byte) 0xbb, (byte) 0xc7, (byte) 0xc7, (byte) 0x0b, (byte) 0x4f, (byte) 0x1d,
+        (byte) 0x8a, (byte) 0x51, (byte) 0xe0, (byte) 0x4b, (byte) 0xcd, (byte) 0xb4, (byte) 0x59, (byte) 0x31,
+        (byte) 0xc8, (byte) 0x9f, (byte) 0x7e, (byte) 0xc9, (byte) 0xd9, (byte) 0x78, (byte) 0x73, (byte) 0x64,
+        (byte) 0xea, (byte) 0xc5, (byte) 0xac, (byte) 0x83, (byte) 0x34, (byte) 0xd3, (byte) 0xeb, (byte) 0xc3,
+        (byte) 0xc5, (byte) 0x81, (byte) 0xa0, (byte) 0xff, (byte) 0xfa, (byte) 0x13, (byte) 0x63, (byte) 0xeb,
+        (byte) 0x17, (byte) 0x0d, (byte) 0xdd, (byte) 0x51, (byte) 0xb7, (byte) 0xf0, (byte) 0xda, (byte) 0x49,
+        (byte) 0xd3, (byte) 0x16, (byte) 0x55, (byte) 0x26, (byte) 0x29, (byte) 0xd4, (byte) 0x68, (byte) 0x9e,
+        (byte) 0x2b, (byte) 0x16, (byte) 0xbe, (byte) 0x58, (byte) 0x7d, (byte) 0x47, (byte) 0xa1, (byte) 0xfc,
+        (byte) 0x8f, (byte) 0xf8, (byte) 0xb8, (byte) 0xd1, (byte) 0x7a, (byte) 0xd0, (byte) 0x31, (byte) 0xce,
+        (byte) 0x45, (byte) 0xcb, (byte) 0x3a, (byte) 0x8f, (byte) 0x95, (byte) 0x16, (byte) 0x04, (byte) 0x28,
+        (byte) 0xaf, (byte) 0xd7, (byte) 0xfb, (byte) 0xca, (byte) 0xbb, (byte) 0x4b, (byte) 0x40, (byte) 0x7e
+    };
+
+    private Xxh3AiCPort() {} // Utility class
+
+    // Utility methods for reading little-endian values
+    private static long readLE64(byte[] data, int offset) {
+        return (long) LONG_HANDLE.get(data, offset);
+    }
+
+    private static int readLE32(byte[] data, int offset) {
+        // This is faster than using VarHandle for 4 bytes
+        return (data[offset] & 0xFF)
+                | ((data[offset + 1] & 0xFF) << 8)
+                | ((data[offset + 2] & 0xFF) << 16)
+                | ((data[offset + 3] & 0xFF) << 24);
+    }
+
+    // Bit rotation utilities
+    private static long rotateLeft(long value, int amount) {
+        return (value << amount) | (value >>> (64 - amount));
+    }
+
+    // Avalanche function
+    private static long avalanche(long h64) {
+        h64 ^= h64 >>> 37;
+        h64 *= PRIME_MX1;
+        h64 ^= h64 >>> 32;
+        return h64;
+    }
+
+    // rrmxmx function for 4-8 byte inputs
+    private static long rrmxmx(long h64, long len) {
+        h64 ^= rotateLeft(h64, 49) ^ rotateLeft(h64, 24);
+        h64 *= PRIME_MX2;
+        h64 ^= (h64 >>> 35) + len;
+        h64 *= PRIME_MX2;
+        h64 ^= h64 >>> 28;
+        return h64;
+    }
+
+    // 128-bit multiplication (high 64 bits)
+    private static long mult64to128High(long a, long b) {
+        long a_lo = a & 0xFFFFFFFFL;
+        long a_hi = a >>> 32;
+        long b_lo = b & 0xFFFFFFFFL;
+        long b_hi = b >>> 32;
+
+        long p0 = a_lo * b_lo;
+        long p1 = a_lo * b_hi;
+        long p2 = a_hi * b_lo;
+        long p3 = a_hi * b_hi;
+
+        long carry = ((p0 >>> 32) + (p1 & 0xFFFFFFFFL) + (p2 & 0xFFFFFFFFL)) >>> 32;
+        return p3 + (p1 >>> 32) + (p2 >>> 32) + carry;
+    }
+
+    // Mix 16 bytes
+    private static long mix16B(byte[] input, int inputOffset, byte[] secret, int secretOffset, long seed) {
+        long input_lo = readLE64(input, inputOffset);
+        long input_hi = readLE64(input, inputOffset + 8);
+        return mult128FoldTo64(
+                input_lo ^ (readLE64(secret, secretOffset) + seed),
+                input_hi ^ (readLE64(secret, secretOffset + 8) - seed));
+    }
+
+    private static long mult128FoldTo64(long lhs, long rhs) {
+        long product_high = mult64to128High(lhs, rhs);
+        return (lhs * rhs) ^ product_high;
+    }
+
+    // XXH3 64-bit hash for 0-16 bytes
+    private static long xxh3_len_0to16_64b(byte[] input, int offset, int len, byte[] secret, long seed) {
+        if (len > 8) return xxh3_len_9to16_64b(input, offset, len, secret, seed);
+        if (len >= 4) return xxh3_len_4to8_64b(input, offset, len, secret, seed);
+        if (len > 0) return xxh3_len_1to3_64b(input, offset, len, secret, seed);
+        return avalanche(seed ^ readLE64(secret, 56) ^ readLE64(secret, 64));
+    }
+
+    private static long xxh3_len_1to3_64b(byte[] input, int offset, int len, byte[] secret, long seed) {
+        int c1 = input[offset] & 0xFF;
+        int c2 = input[offset + (len >> 1)] & 0xFF;
+        int c3 = input[offset + len - 1] & 0xFF;
+        int combined = ((c1 << 16) | (c2 << 24) | c3) + len;
+        long bitflip = (readLE64(secret, 0) ^ readLE64(secret, 8)) + seed;
+        long keyed = (combined & 0xFFFFFFFFL) ^ bitflip;
+        return avalanche(keyed);
+    }
+
+    private static long xxh3_len_4to8_64b(byte[] input, int offset, int len, byte[] secret, long seed) {
+        seed ^= (Long.reverseBytes(seed & 0xFFFFFFFFL)) << 32;
+        int input_lo = readLE32(input, offset);
+        int input_hi = readLE32(input, offset + len - 4);
+        long input_64 = (input_lo & 0xFFFFFFFFL) + (((long) input_hi) << 32);
+        long bitflip = (readLE64(secret, 16) ^ readLE64(secret, 24)) + seed;
+        long keyed = input_64 ^ bitflip;
+        return rrmxmx(keyed, len);
+    }
+
+    private static long xxh3_len_9to16_64b(byte[] input, int offset, int len, byte[] secret, long seed) {
+        long bitflipl = (readLE64(secret, 32) ^ readLE64(secret, 40)) + seed;
+        long bitfliph = (readLE64(secret, 48) ^ readLE64(secret, 56)) - seed;
+        long input_lo = readLE64(input, offset) ^ bitflipl;
+        long input_hi = readLE64(input, offset + len - 8) ^ bitfliph;
+        long acc = len + Long.reverseBytes(input_lo) + input_hi + mult128FoldTo64(input_lo, input_hi);
+        return avalanche(acc);
+    }
+
+    // XXH3 64-bit hash for 17-128 bytes
+    private static long xxh3_len_17to128_64b(byte[] input, int offset, int len, byte[] secret, long seed) {
+        long acc = (len & 0xFFFFFFFFL) * XXH_PRIME64_1;
+
+        if (len > 32) {
+            if (len > 64) {
+                if (len > 96) {
+                    acc += mix16B(input, offset + 48, secret, 96, seed);
+                    acc += mix16B(input, offset + len - 64, secret, 112, seed);
+                }
+                acc += mix16B(input, offset + 32, secret, 64, seed);
+                acc += mix16B(input, offset + len - 48, secret, 80, seed);
+            }
+            acc += mix16B(input, offset + 16, secret, 32, seed);
+            acc += mix16B(input, offset + len - 32, secret, 48, seed);
+        }
+        acc += mix16B(input, offset, secret, 0, seed);
+        acc += mix16B(input, offset + len - 16, secret, 16, seed);
+
+        return avalanche(acc);
+    }
+
+    // XXH3 64-bit hash for 129-240 bytes
+    private static long xxh3_len_129to240_64b(byte[] input, int offset, int len, byte[] secret, long seed) {
+        long acc = (len & 0xFFFFFFFFL) * XXH_PRIME64_1;
+
+        int nbRounds = len / 16;
+        for (int i = 0; i < 8; i++) {
+            acc += mix16B(input, offset + 16 * i, secret, 16 * i, seed);
+        }
+        acc = avalanche(acc);
+
+        for (int i = 8; i < nbRounds; i++) {
+            acc += mix16B(input, offset + 16 * i, secret, 16 * (i - 8) + 3, seed);
+        }
+
+        // Last 16 bytes
+        acc += mix16B(input, offset + len - 16, secret, XXH3_SECRET_SIZE_MIN - 17, seed);
+        return avalanche(acc);
+    }
+
+    /**
+     * Compute XXH3 64-bit hash
+     */
+    public static long xxh3_64bits(byte[] input, int offset, int len) {
+        return xxh3_64bits(input, offset, len, 0);
+    }
+
+    public static long xxh3_64bits(byte[] input, int offset, int len, long seed) {
+        if (len <= 16) {
+            return xxh3_len_0to16_64b(input, offset, len, XXH3_SECRET, seed);
+        }
+        if (len <= 128) {
+            return xxh3_len_17to128_64b(input, offset, len, XXH3_SECRET, seed);
+        }
+        if (len <= XXH3_MIDSIZE_MAX) {
+            return xxh3_len_129to240_64b(input, offset, len, XXH3_SECRET, seed);
+        }
+        // For lengths > 240, we would need the full streaming implementation
+        // This is a simplified version that processes in chunks
+        return xxh3_hashLong_64b(input, offset, len, XXH3_SECRET, seed);
+    }
+
+    // Simplified long hash implementation
+    private static long xxh3_hashLong_64b(byte[] input, int offset, int len, byte[] secret, long seed) {
+        // For now, fallback to processing as smaller chunks
+        // This is not optimal but ensures correctness
+        long acc = 0;
+        int pos = offset;
+        int remaining = len;
+
+        // Process 240-byte chunks
+        while (remaining > XXH3_MIDSIZE_MAX) {
+            acc = rotateLeft(acc, 7);
+            acc += xxh3_len_129to240_64b(input, pos, XXH3_MIDSIZE_MAX, secret, seed);
+            pos += XXH3_MIDSIZE_MAX;
+            remaining -= XXH3_MIDSIZE_MAX;
+        }
+
+        // Process final chunk
+        if (remaining > 0) {
+            acc = rotateLeft(acc, 11);
+            acc += xxh3_64bits(input, pos, remaining, seed);
+        }
+
+        return avalanche(acc);
+    }
+
+    /**
+     * Compute XXH3 32-bit hash (truncated 64-bit result)
+     */
+    public static int xxh3_32bits(byte[] input) {
+        return xxh3_32bits(input, 0, input.length, 0);
+    }
+
+    public static int xxh3_32bits(byte[] input, int offset, int len, long seed) {
+        return (int) xxh3_64bits(input, offset, len, seed);
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Xxh3Lz4.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Xxh3Lz4.java
new file mode 100644
index 00000000..4304fefa
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/Xxh3Lz4.java
@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+import net.jpountz.xxhash.XXHash64;
+import net.jpountz.xxhash.XXHashFactory;
+
+public class Xxh3Lz4 {
+    private static final XXHashFactory JAVA_FACTORY = XXHashFactory.fastestJavaInstance();
+    private static final XXHashFactory NATIVE_FACTORY = XXHashFactory.nativeInstance();
+    private static final XXHash64 JAVA_HASH_64 = JAVA_FACTORY.hash64();
+    private static final XXHash64 NATIVE_HASH_64 = NATIVE_FACTORY.hash64();
+
+    public static long xxh_64bits_java(final byte[] bytes, int start, int length) {
+        return JAVA_HASH_64.hash(bytes, start, length, 0);
+    }
+
+    public static long xxh_64bits_native(final byte[] bytes, int start, int length) {
+        return NATIVE_HASH_64.hash(bytes, start, length, 0);
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XxhSumCommandLine.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XxhSumCommandLine.java
new file mode 100644
index 00000000..c0453aeb
--- /dev/null
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/functions/XxhSumCommandLine.java
@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: Apache-2.0
+package com.hedera.pbj.integration.jmh.hashing.functions;
+
+import java.io.IOException;
+
+/**
+ * Wrapper around the `xxhsum` command line utility to compute a 64-bit hash.
+ */
+public class XxhSumCommandLine {
+
+    public static long hashXxh_32(final byte[] bytes, int start, int length) {
+        final String resultString = xxhsum(0, bytes, start, length);
+        final String resultHexString = resultString.substring(0, resultString.indexOf(' '));
+        return Long.parseUnsignedLong(resultHexString, 16);
+    }
+
+    public static long hashXxh_64(final byte[] bytes, int start, int length) {
+        final String resultString = xxhsum(1, bytes, start, length);
+        final String resultHexString = resultString.substring(0, resultString.indexOf(' '));
+        return Long.parseUnsignedLong(resultHexString, 16);
+    }
+
+    public static long[] hashXxh3_128(final byte[] bytes, int start, int length) {
+        final String resultString = xxhsum(2, bytes, start, length);
+        final String first64bit = resultString.substring(0, 16);
+        final String second64bit = resultString.substring(16, 32);
+        return new long[] {Long.parseUnsignedLong(first64bit, 16), Long.parseUnsignedLong(second64bit, 16)};
+    }
+
+    public static long hashXxh3_64(final byte[] bytes, int start, int length) {
+        final String resultString = xxhsum(3, bytes, start, length);
+        final String resultHexString = resultString.substring(resultString.indexOf('_') + 1, resultString.indexOf(' '));
+        return Long.parseUnsignedLong(resultHexString, 16);
+    }
+
+    private static String xxhsum(final int algorithm, final byte[] bytes, int start, int length) {
+        ProcessBuilder pb = new ProcessBuilder("xxhsum", "-H" + algorithm, "-");
+        Process process = null;
+        try {
+            process = pb.start();
+            // Write input and close output to signal EOF to xxhsum
+            try (var out = process.getOutputStream()) {
+                out.write(bytes, start, length);
+                out.flush();
+            }
+            // Read result from input stream
+            String resultString;
+            try (var in = process.getInputStream()) {
+                var resultBytes = in.readAllBytes();
+                resultString = new String(resultBytes).trim();
+            }
+            // Drain error stream to avoid blocking
+            try (var err = process.getErrorStream()) {
+                var errorBytes = err.readAllBytes();
+                if (errorBytes.length > 0) {
+                    String errorString = new String(errorBytes).trim();
+                    if (!errorString.isEmpty()) {
+                        throw new RuntimeException("Error from xxhsum: " + errorString);
+                    }
+                }
+            }
+            process.waitFor();
+            return resultString;
+        } catch (IOException | InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static void main(String[] args) {
+        long testHash = hashXxh_32("helloworld".getBytes(), 0, "helloworld".getBytes().length);
+        System.out.println("hashXxh_32 = " + testHash);
+        testHash = hashXxh_64("helloworld".getBytes(), 0, "helloworld".getBytes().length);
+        System.out.println("hashXxh_64 = " + testHash);
+        testHash = hashXxh3_64("helloworld".getBytes(), 0, "helloworld".getBytes().length);
+        System.out.println("hashXxh3_64 = " + testHash);
+        long[] testHash128 = hashXxh3_128("helloworld".getBytes(), 0, "helloworld".getBytes().length);
+        System.out.println("hashXxh3_128 = " + testHash128[0] + ", " + testHash128[1]);
+    }
+}
diff --git a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQualityStateKeyTest.java b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQualityStateKeyTest.java
index 93563606..d6e6edd2 100644
--- a/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQualityStateKeyTest.java
+++ b/pbj-integration-tests/src/jmh/java/com/hedera/pbj/integration/jmh/hashing/qualitytest/NonCryptographicHashQualityStateKeyTest.java
@@ -54,7 +54,7 @@ public static void main(String[] args) throws Exception {
             //                            })
             //            ).get(); // handle exceptions as needed
             final CountingArray counts = new CountingArray(); // 4 billion counts
-            testHashQuality4Bytes(HashAlgorithm.JAVA_257, counts, outputDir);
+            testHashQuality4Bytes(HashAlgorithm.XXH3_64_PBJ, counts, outputDir);
         }
     }