rustc -C opt-level=3): 2049 (203973 B .text / 53737 insns)22/9 Hz): 248869 B / 5979051 B (ratio 248869/5979051, saved 5730182/5979051, 11695 ″ dittos)| Rank & Crown | Function Name & Domain | Best Use & Snap-Circuit Role | Pin Signature & 64-Vec Hash | Hardware _rdtsc (p/q) | Details & Quick Peek |
|---|---|---|---|---|---|
| #2 CROWN #1 of 5 <10 CYC | fnv64_1a domain: smart-tree-x86_64 | id: 1dcf2f5ffc27Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Lossless Wire & Structural Compression Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols. Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums. | (&[u8])->u6464-vec BLAKE3: a43f2ec7f9abC64 RAM: 31/8192 (248 B src) | 482141/200000 cyc/op 523321/800000 ns/op | 800000000/523321 ops/us 167 B .text (41 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (248 B)pub const fn fnv64_1a(bytes: &[u8]) -> u64 {
let mut hash = 0xcbf29ce484222325u64;
let mut i = 0;
while i < bytes.len() {
hash ^= bytes[i] as u64;
hash = hash.wrapping_mul(0x100000001b3);
i += 1;
}
hash
} |
| #1029 SOLE CROWN #1 | prompt_boundary_sig64 domain: eightb-agy-fanout-x86_64 | id: 71673b91d46bAye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Deterministic Sovereign Compute Kernel Pure-Rust C64-bounded integer transformation kernel verified across 64 canonical test vectors for deterministic Snap-Circuit composition. Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums. | (&[u8])->u6464-vec BLAKE3: 90fd53e27e35C64 RAM: 503/65536 (503 B src) | 1005941/100000 cyc/op 1916661/400000 ns/op | 400000000/1916661 ops/us 55 B .text (20 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (503 B)pub const fn prompt_boundary_sig64(bytes: &[u8]) -> u64 {
let n = bytes.len();
if n == 0 {
return 0;
}
let head = if n >= 4 {
u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]) as u64
} else {
(bytes[0] as u64) | ((bytes[n - 1] as u64) << 8)
};
let tail = if n >= 4 {
u32::from_le_bytes([bytes[n - 4], bytes[n - 3], bytes[n - 2], bytes[n - 1]]) as u64
} else {
(bytes[n - 1] as u64) << 16
};
(head << 32) | tail
} |
| #1589 PEER of 5 | fnv1a64_bytes domain: smart-tree | id: c1f44602e6baAye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Lossless Wire & Structural Compression Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols. Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums. | (&[u8])->u6464-vec BLAKE3: a43f2ec7f9abC64 RAM: 159/32768 (318 B src) | 700523/50000 cyc/op 2669011/400000 ns/op | 400000000/2669011 ops/us 167 B .text (41 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (318 B)pub const fn fnv1a64_bytes(bytes: &[u8]) -> u64 {
const FNV_OFFSET: u64 = 0xcbf29ce484222325;
const FNV_PRIME: u64 = 0x00000100000001B3;
let mut h = FNV_OFFSET;
let mut i = 0;
while i < bytes.len() {
h ^= bytes[i] as u64;
h = h.wrapping_mul(FNV_PRIME);
i += 1;
}
h
} |
| #1638 CROWN #1 of 4 | wupz_xor_fold domain: smart-tree | id: b1b0f9a58585Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Lossless Wire & Structural Compression Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols. Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums. | (&[u8])->u6464-vec BLAKE3: f2befb3850c8C64 RAM: 1357/65536 (1357 B src) | 277647/20000 cyc/op 2644609/400000 ns/op | 400000000/2644609 ops/us 442 B .text (105 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (1357 B)pub fn wupz_xor_fold(bytes: &[u8]) -> u64 {
let mut a0 = 0u64;
let mut a1 = 0u64;
let mut a2 = 0u64;
let mut a3 = 0u64;
let mut chunks64 = bytes.chunks_exact(64);
for c in &mut chunks64 {
a0 ^= u64::from_le_bytes([c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]])
^ u64::from_le_bytes([c[32], c[33], c[34], c[35], c[36], c[37], c[38], c[39]]);
a1 ^= u64::from_le_bytes([c[8], c[9], c[10], c[11], c[12], c[13], c[14], c[15]])
^ u64::from_le_bytes([c[40], c[41], c[42], c[43], c[44], c[45], c[46], c[47]]);
a2 ^= u64::from_le_bytes([c[16], c[17], c[18], c[19], c[20], c[21], c[22], c[23]])
^ u64::from_le_bytes([c[48], c[49], c[50], c[51], c[52], c[53], c[54], c[55]]);
a3 ^= u64::from_le_bytes([c[24], c[25], c[26], c[27], c[28], c[29], c[30], c[31]])
^ u64::from_le_bytes([c[56], c[57], c[58], c[59], c[60], c[61], c[62], c[63]]);
}
let mut acc = (a0 ^ a1) ^ (a2 ^ a3);
let mut chunks8 = chunks64.remainder().chunks_exact(8);
for c in &mut chunks8 {
acc ^= u64::from_le_bytes([c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]]);
}
let rem = chunks8.remainder();
if !rem.is_empty() {
let mut tail = [0u8; 8];
tail[..rem.len()].copy_from_slice(rem);
acc ^= u64::from_le_bytes(tail);
}
acc
} |
| #1648 SOLE CROWN #1 | wupz_seal64 domain: smart-tree | id: 25011bf2e603Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Lossless Wire & Structural Compression Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols. Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums. | (&[u8])->u6464-vec BLAKE3: 3dfd2fed1583C64 RAM: 633/65536 (633 B src) | 3113767/200000 cyc/op 593163/80000 ns/op | 80000000/593163 ops/us 278 B .text (77 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (633 B)pub fn wupz_seal64(bytes: &[u8]) -> u64 {
let mut acc: u64 = 0x9E37_79B9_7F4A_7C15 ^ (bytes.len() as u64);
let (words, rem) = bytes.as_chunks::<8>();
for (idx, chunk) in words.iter().enumerate() {
let word = u64::from_le_bytes(*chunk);
acc ^= word.rotate_left(((idx * 13) & 63) as u32);
acc = acc.wrapping_mul(0xBF58_476D_1CE4_E5B9);
acc ^= acc >> 27;
}
if !rem.is_empty() {
let mut tail = [0u8; 8];
tail[..rem.len()].copy_from_slice(rem);
acc ^= u64::from_le_bytes(tail);
acc = acc.wrapping_mul(0x94D0_49BB_1331_11EB);
}
acc ^ (acc >> 31)
} |
| #1649 PEER of 4 | reference_fold domain: smart-tree | id: 6ba1e9237f06Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Lossless Wire & Structural Compression Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols. Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums. | (&[u8])->u6464-vec BLAKE3: f2befb3850c8C64 RAM: 87/32768 (174 B src) | 1554087/100000 cyc/op 370067/50000 ns/op | 50000000/370067 ops/us 192 B .text (58 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (174 B)pub fn reference_fold(bytes: &[u8]) -> u64 {
let mut acc = 0u64;
for (i, b) in bytes.iter().enumerate() {
acc ^= (*b as u64) << ((i % 8) * 8);
}
acc
} |
| #1664 PEER of 5 | fnv1a64 domain: smart-tree | id: bdd403ed1815Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Lossless Wire & Structural Compression Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols. Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums. | (&[u8])->u6464-vec BLAKE3: a43f2ec7f9abC64 RAM: 45/16384 (180 B src) | 3422669/200000 cyc/op 815119/100000 ns/op | 100000000/815119 ops/us 199 B .text (49 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (180 B)pub fn fnv1a64(bytes: &[u8]) -> u64 {
let mut h: u64 = 0xcbf29ce484222325;
for &b in bytes {
h ^= b as u64;
h = h.wrapping_mul(0x100000001b3);
}
h
} |
| #1666 PEER of 5 | fnv1a domain: smart-tree | id: db9abc61f5ccAye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Lossless Wire & Structural Compression Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols. Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums. | (&[u8])->u6464-vec BLAKE3: a43f2ec7f9abC64 RAM: 89/32768 (178 B src) | 3421281/200000 cyc/op 1629479/200000 ns/op | 200000000/1629479 ops/us 199 B .text (49 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (178 B)pub fn fnv1a(bytes: &[u8]) -> u64 {
let mut h: u64 = 0xcbf29ce484222325;
for &b in bytes {
h ^= b as u64;
h = h.wrapping_mul(0x100000001b3);
}
h
} |
| #1676 PEER of 4 | wupz_xor_fold_bytes domain: 8b-is-x86_64 | id: 6062182496eaAye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Deterministic Sovereign Compute Kernel Pure-Rust C64-bounded integer transformation kernel verified across 64 canonical test vectors for deterministic Snap-Circuit composition. Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums. | (&[u8])->u6464-vec BLAKE3: f2befb3850c8C64 RAM: 259/32768 (518 B src) | 91627/5000 cyc/op 698261/80000 ns/op | 80000000/698261 ops/us 512 B .text (121 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (518 B)pub const fn wupz_xor_fold_bytes(bytes: &[u8]) -> u64 {
let mut acc: u64 = 0;
let mut i = 0;
while i + 8 <= bytes.len() {
let w = u64::from_le_bytes([
bytes[i],
bytes[i + 1],
bytes[i + 2],
bytes[i + 3],
bytes[i + 4],
bytes[i + 5],
bytes[i + 6],
bytes[i + 7],
]);
acc ^= w;
i += 8;
}
while i < bytes.len() {
acc ^= bytes[i] as u64;
i += 1;
}
acc
} |
| #1679 PEER of 4 | xor_fold_scalar domain: smart-tree | id: 578a8eb4d414Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Lossless Wire & Structural Compression Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols. Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums. | (&[u8])->u6464-vec BLAKE3: f2befb3850c8C64 RAM: 417/65536 (417 B src) | 3886171/200000 cyc/op 3701653/400000 ns/op | 400000000/3701653 ops/us 153 B .text (42 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (417 B)pub fn xor_fold_scalar(bytes: &[u8]) -> u64 {
let full_words_len = bytes.len() & !7usize;
let mut acc: u64 = 0;
let mut i = 0usize;
while i < full_words_len {
acc ^= (bytes[i] as u64) << ((i & 7) * 8);
i += 1;
}
while i < bytes.len() {
acc ^= bytes[i] as u64;
i += 1;
}
core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
acc
} |
| #1681 PEER of 5 | fnv1a_64 domain: ayecast-x86_64 | id: 21e3d1405e1dAye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Cryptographic Mixing, Checksums & Wire Integrity High-avalanche 64-bit bijection mixing, deterministic PRNG state stepping, and keyed hash partitioning for hash tables and content addressing. Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums. | (&[u8])->u6464-vec BLAKE3: a43f2ec7f9abC64 RAM: 123/32768 (246 B src) | 790411/20000 cyc/op 4288537/400000 ns/op | 400000000/4288537 ops/us 167 B .text (41 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (246 B)pub const fn fnv1a_64(bytes: &[u8]) -> u64 {
let mut h: u64 = 0xCBF2_9CE4_8422_2325;
let mut i = 0;
while i < bytes.len() {
h ^= bytes[i] as u64;
h = h.wrapping_mul(0x0000_0100_0000_01B3);
i += 1;
}
h
} |