rustc -C opt-level=3): 2049 (203973 B .text / 53737 insns)22/9 Hz): 248968 B / 5979078 B (ratio 124484/2989539, saved 2865055/2989539, 11684 ″ dittos)| Rank & Crown | Function Name & Domain | Best Use & Snap-Circuit Role | Pin Signature & 64-Vec Hash | Hardware _rdtsc (p/q) | Details & Quick Peek |
|---|---|---|---|---|---|
| #1 SOLE CROWN #1 <10 CYC | zeno_world_field_factored_step domain: math | id: 4e51b4eb686cAye: aye-omni-zeno @ 432Hz | Deterministic Sovereign Compute Kernel Pure-Rust C64-bounded integer transformation kernel verified across 64 canonical test vectors for deterministic Snap-Circuit composition. Specialized Multi-Pin Stage `(i64,i64,i64,i64,i64,i64,i64,i64,i64)->i64` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (i64,i64,i64,i64,i64,i64,i64,i64,i64)->i6464-vec BLAKE3: 1209d71eb9fbC64 RAM: 847/65536 (847 B src) | 1/1 cyc/op 1/2 ns/op | 2000/1 ops/us 301 B .text (88 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (847 B)pub fn zeno_world_field_factored_step(phi_q16: i64, v_q16: i64, s_q16: i64, z_q16: i64, forcing_phi: i64, forcing_v: i64, z_hat: i64, energy_upper: i64, observed_locked: i64) -> i64 {
let cand_phi = (phi_q16 + (forcing_phi >> 2)).max(4096);
let cand_v = v_q16 + forcing_v;
let cand_s = if observed_locked != 0 {
(s_q16 - (s_q16 >> 3)).max(0)
} else {
s_q16 + forcing_phi.abs()
};
let cand_z = if observed_locked == 0 { z_q16 + z_hat } else { z_q16 };
let phi_u = (cand_phi >> 8).abs();
let v_u = (cand_v >> 8).abs();
let e_cand = (phi_u.saturating_mul(phi_u).saturating_add(v_u.saturating_mul(v_u))) >> 1;
let proj_v = if e_cand > energy_upper && e_cand > 0 {
(cand_v.saturating_mul(energy_upper)) / e_cand
} else {
cand_v
};
cand_phi ^ proj_v ^ cand_s ^ cand_z
} |
| #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
} |
| #3 CROWN #1 of 3 <10 CYC | isqrt_u64 domain: ayecast-x86_64 | id: 7f1678af7926Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Exact Integer Number Theory & Transcendentals Hardware-verified modular arithmetic, integer roots, and combinatorial invariants for exact rational math engines and cryptographic primitives. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 22317c08f10eC64 RAM: 19/8192 (152 B src) | 482603/200000 cyc/op 261913/400000 ns/op | 400000000/261913 ops/us 115 B .text (34 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (152 B)pub const fn isqrt_u64(n: u64) -> u64 { if n < 2 { return n; } let mut x = n; let mut y = (x + 1) >> 1; while y < x { x = y; y = (x + n / x) >> 1; } x } |
| #4 PEER of 3 <10 CYC | isqrt_u64 domain: smart-tree-x86_64 | id: 87992ac8869bAye: 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. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 22317c08f10eC64 RAM: 73/16384 (292 B src) | 968409/400000 cyc/op 525559/800000 ns/op | 800000000/525559 ops/us 122 B .text (39 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (292 B)pub const fn isqrt_u64(x: u64) -> u64 {
if x < 2 {
return x;
}
let shift = (64 - x.leading_zeros()).div_ceil(2);
let mut g = 1u64 << shift;
loop {
let next = (g + x / g) >> 1;
if next >= g {
return g;
}
g = next;
}
} |
| #5 CROWN #1 of 2 <10 CYC | compute_rgba8_byte_length_checked domain: ayecast-x86_64 | id: 61042e4026d0Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | SWAR Pixel Processing & Vision Kernels Branchless in-register pixel averaging, color-space conversion, and edge gradient filtering for zero-copy framebuffers. Specialized Multi-Pin Stage `(u32,u32)->u64` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (u32,u32)->u6464-vec BLAKE3: 287e252eb2a8C64 RAM: 277/65536 (277 B src) | 241321/100000 cyc/op 26193/40000 ns/op | 40000000/26193 ops/us 41 B .text (12 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (277 B)pub const fn compute_rgba8_byte_length_checked(width: u32, height: u32) -> u64 { const MAX_IMAGE_BYTE_LENGTH: u64 = 2_147_483_647; let total = 4u64.saturating_mul(width as u64).saturating_mul(height as u64); if total == 0 || total > MAX_IMAGE_BYTE_LENGTH { 0 } else { total } } |
| #6 CROWN #1 of 312 <10 CYC | st_golf_isqrt_salience_step_u64 domain: space-bender | id: 40c10facbd4eAye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Marine Salience & Wave Telemetry Tracking period and amplitude stability across zero-crossing intervals to score signal salience in noisy real-time sensor and audio streams. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 0aab703b121aC64 RAM: 223/65536 (223 B src) | 534251/200000 cyc/op 289927/400000 ns/op | 400000000/289927 ops/us 35 B .text (10 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (223 B)pub const fn st_golf_isqrt_salience_step_u64(energy_q15: u64) -> u64 {
let x = if energy_q15 == 0 {
1
} else {
((energy_q15 | 1).wrapping_add(5_588_277)) >> 12
};
(x.wrapping_mul(432)) >> 4
} |
| #7 SOLE CROWN #1 <10 CYC | velocity_16_to_7 domain: dhvani-x86_64 | id: 91fd42fcd569Aye: 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. Specialized Multi-Pin Stage `(u16)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (u16)->u864-vec BLAKE3: 99df7320a3acC64 RAM: 15/16384 (60 B src) | 9661/4000 cyc/op 262151/400000 ns/op | 400000000/262151 ops/us 7 B .text (3 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (60 B)pub fn velocity_16_to_7(v: u16) -> u8 {
(v >> 9) as u8
} |
| #8 CROWN #1 of 2 <10 CYC | integer_parabolic_sine_q15 domain: ayecast-x86_64 | id: 30b936d46850Aye: 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. 1-to-1 Unary Transform Stage `(i64)->i64` — snaps directly into linear pipelines or fan-out DAG branches. | (i64)->i6464-vec BLAKE3: dbb136b48837C64 RAM: 135/32768 (270 B src) | 40063/12500 cyc/op 347849/400000 ns/op | 400000000/347849 ops/us 34 B .text (11 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (270 B)pub const fn integer_parabolic_sine_q15(phase_u16: i64) -> i64 {
let p = phase_u16 & 0xFFFF;
let half = p & 0x7FFF;
// Parabolic arch 4 * x * (32768 - x) / 32768
let arch = (half * (32768 - half)) >> 13;
if (p & 0x8000) != 0 { -arch } else { arch }
} |
| #9 CROWN #1 of 2 <10 CYC | st_golf_borg_swift_midi_harmonic_step_u64 domain: borg-midi | id: bd13172809faAye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Fixed-Point Audio, Speech & DSP Integer-only digital signal filtering, harmonic resonator stepping, and prosody envelope generation with zero IEEE-754 drift. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: c4e328dd687eC64 RAM: 75/32768 (150 B src) | 640971/200000 cyc/op 173913/200000 ns/op | 200000000/173913 ops/us 35 B .text (10 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (150 B)pub const fn st_golf_borg_swift_midi_harmonic_step_u64(note: u64) -> u64 {
(((note & 0x7F) * 432 + ((note >> 8) & 0x7F) * 528) ^ 0x1B0) & 0xFFFF
} |
| #10 CROWN #1 of 2 <10 CYC | st_golf_borg_rs_qwave_triad_phase_u64 domain: borg-qwave | id: ddc22df819ebAye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Marine Salience & Wave Telemetry Stepping 2D wave-grid Laplacian interference and harmonic phase accumulators for wave-based associative memory state updates. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 7294724d11a0C64 RAM: 21/8192 (168 B src) | 643287/200000 cyc/op 349121/400000 ns/op | 400000000/349121 ops/us 49 B .text (11 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (168 B)pub const fn st_golf_borg_rs_qwave_triad_phase_u64(phase: u64) -> u64 {
(((phase.wrapping_mul(11).wrapping_add(528) / 9) ^ 432).rotate_left(7)) ^ (phase & 0xFFFF)
} |
| #11 SOLE CROWN #1 <10 CYC | velocity_7_to_16 domain: dhvani-x86_64 | id: 0e6c4ae2751bAye: 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. Specialized Multi-Pin Stage `(u8)->u16` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (u8)->u1664-vec BLAKE3: e21c3d39cf5aC64 RAM: 69/32768 (138 B src) | 659201/200000 cyc/op 357723/400000 ns/op | 400000000/357723 ops/us 32 B .text (12 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (138 B)pub fn velocity_7_to_16(v: u8) -> u16 {
if v == 0 {
return 0;
}
let v = v as u16;
(v << 9) | (v << 2) | (v >> 5)
} |
| #12 SOLE CROWN #1 <10 CYC | avalanche64 domain: qwave-x86_64 | id: b4e497cc46c8Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Marine Salience & Wave Telemetry Stepping 2D wave-grid Laplacian interference and harmonic phase accumulators for wave-based associative memory state updates. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 0e9198342660C64 RAM: 113/32768 (226 B src) | 137659/50000 cyc/op 179277/200000 ns/op | 200000000/179277 ops/us 70 B .text (18 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (226 B)pub const fn avalanche64(mut x: u64) -> u64 {
x ^= x >> 30;
x = x.wrapping_mul(0xbf58_476d_1ce4_e5b9);
x ^= x >> 27;
x = x.wrapping_mul(0x94d0_49bb_1331_11eb);
x ^= x >> 31;
if x == 0 { 1 } else { x }
} |
| #13 CROWN #1 of 2 <10 CYC | st_golf_voice_ogg_crc32_step_u64 domain: signal | id: 29847d4f9b52Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Cryptographic Mixing, Checksums & Wire Integrity Fast wire-speed packet checksum verification, case-folded label hashing, and frame integrity sealing on network ingress paths. 2-to-1 Binary Combiner / Join Stage `(u64,u64)->u64` — ideal for merging two upstream DAG branches, dot products, or pairwise rank fusion. | (u64,u64)->u6464-vec BLAKE3: 7eddb231efdfC64 RAM: 521/65536 (521 B src) | 360563/100000 cyc/op 9783/10000 ns/op | 10000000/9783 ops/us 35 B .text (12 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (521 B)pub const fn st_golf_voice_ogg_crc32_step_u64(crc: u64, byte_val: u64) -> u64 {
const T: [u32; 16] = [
0x0000_0000, 0x04C1_1DB7, 0x0982_3B6E, 0x0D43_26D9,
0x1304_76DC, 0x17C5_6B6B, 0x1A86_4DB2, 0x1E47_5005,
0x2608_EDB8, 0x22C9_F00F, 0x2F8A_D6D6, 0x2B4B_CB61,
0x350C_9B64, 0x31CD_86D3, 0x3C8E_A00A, 0x384F_BDBD,
];
let mut c = ((crc as u32) ^ (((byte_val as u32) & 0xFF) << 24));
c = (c << 4) ^ T[(c >> 28) as usize];
c = (c << 4) ^ T[(c >> 28) as usize];
c as u64
} |
| #14 SOLE CROWN #1 <10 CYC | saturate_trit_i64 domain: ternary | id: 9bb078d59c28Aye: aye::Peter+Omni(0+1)::aarch64 @ 432Hz | Balanced Ternary & b158 Quantization Packing and unpacking balanced ternary (-1, 0, +1) activation lanes into dense 64-bit registers for C64-constrained inference pipelines. Specialized Multi-Pin Stage `(i64)->i8` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (i64)->i864-vec BLAKE3: 479f392c99dcC64 RAM: 19/4096 (304 B src) | 1323467/400000 cyc/op 206833/200000 ns/op | 200000000/206833 ops/us 12 B .text (5 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (304 B)pub fn saturate_trit_i64(value: i64) -> i8 {
// Project an arbitrary accumulator onto the ternary alphabet {-1, 0, +1}.
// Branch-free: two arithmetic compares compiled to cmp/setcc pairs.
if value > 1 {
1
} else if value < -1 {
-1
} else {
value as i8
}
} |
| #15 SOLE CROWN #1 <10 CYC | saturate_i8_i64 domain: zerocpu | id: 78c8596dbdfaAye: aye::Peter+Omni(0+1)::aarch64 @ 432Hz | Deterministic Sovereign Compute Kernel Pure-Rust C64-bounded integer transformation kernel verified across 64 canonical test vectors for deterministic Snap-Circuit composition. 1-to-1 Unary Transform Stage `(i64)->i64` — snaps directly into linear pipelines or fan-out DAG branches. | (i64)->i6464-vec BLAKE3: 1151dcd3ad83C64 RAM: 117/65536 (117 B src) | 1324001/400000 cyc/op 41379/40000 ns/op | 40000000/41379 ops/us 29 B .text (7 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (117 B)pub fn saturate_i8_i64(value: i64) -> i64 {
if value < -128 { -128 } else if value > 127 { 127 } else { value }
} |
| #16 SOLE CROWN #1 <10 CYC | binary_search_branchless_u64 domain: search | id: bf95176a63b0Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Zero-Copy Scanning, Parsing & Codec Primitives High-throughput byte-slice scanning, delimiter discovery, and wire-safe ASCII/hex transcoding inside bounded 64KB memory pages. 2-to-1 Binary Combiner / Join Stage `(u64,u64)->u64` — ideal for merging two upstream DAG branches, dot products, or pairwise rank fusion. | (u64,u64)->u6464-vec BLAKE3: cf5c070c0e46C64 RAM: 55/8192 (440 B src) | 878401/400000 cyc/op 52307/50000 ns/op | 50000000/52307 ops/us 77 B .text (26 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (440 B)#[inline(always)]
pub fn binary_search_branchless_u64(packed_sorted: u64, needle: u64) -> u64 {
let mut base: u32 = 0;
let mid4 = (packed_sorted >> ((base + 4) * 8)) & 0xFF;
base += ((needle >= mid4) as u32) * 4;
let mid2 = (packed_sorted >> ((base + 2) * 8)) & 0xFF;
base += ((needle >= mid2) as u32) * 2;
let mid1 = (packed_sorted >> ((base + 1) * 8)) & 0xFF;
base += (needle >= mid1) as u32;
base as u64
} |
| #17 CROWN #1 of 2 <10 CYC | st_golf_borg_py_onecomp_trit_quant_i64 domain: borg-onecomp | id: 1897b7b27af6Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Balanced Ternary & b158 Quantization Packing and unpacking balanced ternary (-1, 0, +1) activation lanes into dense 64-bit registers for C64-constrained inference pipelines. 1-to-1 Unary Transform Stage `(i64)->i64` — snaps directly into linear pipelines or fan-out DAG branches. | (i64)->i6464-vec BLAKE3: 50b2d2c3e49fC64 RAM: 213/65536 (213 B src) | 100151/25000 cyc/op 217381/200000 ns/op | 200000000/217381 ops/us 46 B .text (13 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (213 B)pub const fn st_golf_borg_py_onecomp_trit_quant_i64(sample: i64) -> i64 {
let s = sample.wrapping_mul(158) >> 7;
let trit = ((s > 64) as i64) - ((s < -64) as i64);
(s & 0xFF).wrapping_add(trit * 432)
} |
| #18 PEER of 2 <10 CYC | compute_rgba8_byte_length_checked domain: ayecast-x86_64 | id: caf4491ff0d6Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | SWAR Pixel Processing & Vision Kernels Branchless in-register pixel averaging, color-space conversion, and edge gradient filtering for zero-copy framebuffers. Specialized Multi-Pin Stage `(u32,u32)->u64` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (u32,u32)->u6464-vec BLAKE3: 287e252eb2a8C64 RAM: 331/65536 (331 B src) | 801311/200000 cyc/op 217433/200000 ns/op | 200000000/217433 ops/us 41 B .text (12 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (331 B)pub const fn compute_rgba8_byte_length_checked(width: u32, height: u32) -> u64 {
const MAX_IMAGE_BYTE_LENGTH: u64 = 2_147_483_647;
let total = 4u64
.saturating_mul(width as u64)
.saturating_mul(height as u64);
if total == 0 || total > MAX_IMAGE_BYTE_LENGTH {
0
} else {
total
}
} |
| #19 PEER of 2 <10 CYC | integer_parabolic_sine_q15 domain: ayecast-x86_64 | id: b93cf5da5da8Aye: 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. 1-to-1 Unary Transform Stage `(i64)->i64` — snaps directly into linear pipelines or fan-out DAG branches. | (i64)->i6464-vec BLAKE3: dbb136b48837C64 RAM: 51/16384 (204 B src) | 571659/200000 cyc/op 155163/200000 ns/op | 200000000/155163 ops/us 34 B .text (11 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (204 B)pub const fn integer_parabolic_sine_q15(phase_u16: i64) -> i64 { let p = phase_u16 & 0xFFFF; let half = p & 0x7FFF; let arch = (half * (32768 - half)) >> 13; if (p & 0x8000) != 0 { -arch } else { arch } } |
| #20 CROWN #1 of 2 <10 CYC | tnand domain: ternary | id: b0b7b00d6353Aye: aye::Peter+Omni(0+1)::aarch64 @ 432Hz | Balanced Ternary & b158 Quantization Packing and unpacking balanced ternary (-1, 0, +1) activation lanes into dense 64-bit registers for C64-constrained inference pipelines. Specialized Multi-Pin Stage `(i8,i8)->i8` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (i8,i8)->i864-vec BLAKE3: fd5753da6279C64 RAM: 21/16384 (84 B src) | 784867/200000 cyc/op 24527/20000 ns/op | 20000000/24527 ops/us 11 B .text (5 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (84 B)pub fn tnand(a: i8, b: i8) -> i8 {
let lo = if a < b { a } else { b };
-lo
} |
| #21 CROWN #1 of 2 <10 CYC | st_golf_borg_go_gaia_fold_432_i64 domain: borg-gaia | id: b4686e7edcc4Aye: 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. Signed/Unsigned Bridge Adapter `(u64)->i64` — converts between bipolar wave/PCM domains and unsigned packed bitstreams. | (u64)->i6464-vec BLAKE3: 0f8b34085d0fC64 RAM: 55/16384 (220 B src) | 60097/12500 cyc/op 3261/2500 ns/op | 2500000/3261 ops/us 73 B .text (17 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (220 B)pub const fn st_golf_borg_go_gaia_fold_432_i64(freq: u64) -> i64 {
const LUT: [i64; 3] = [0, 528, -528];
let triad = (freq.wrapping_mul(11) / 9) ^ 432;
(triad as i64).wrapping_add(LUT[(triad % 3) as usize])
} |
| #22 SOLE CROWN #1 <10 CYC | splitmix64 domain: ayecast-x86_64 | id: ba8b4fd5d497Aye: 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. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 602d684c8b03C64 RAM: 233/65536 (233 B src) | 480713/100000 cyc/op 521693/400000 ns/op | 400000000/521693 ops/us 72 B .text (16 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (233 B)pub const fn splitmix64(mut x: u64) -> u64 {
x = x.wrapping_add(0x9E37_79B9_7F4A_7C15);
x = (x ^ (x >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
x = (x ^ (x >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
x ^ (x >> 31)
} |
| #23 SOLE CROWN #1 <10 CYC | simhash_matching_bits_64 domain: ayecast-x86_64 | id: c8465faadd40Aye: 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. Specialized Multi-Pin Stage `(u64,u64)->u32` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (u64,u64)->u3264-vec BLAKE3: b6e8c49a12b2C64 RAM: 107/65536 (107 B src) | 982399/200000 cyc/op 133267/100000 ns/op | 100000000/133267 ops/us 100 B .text (23 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (107 B)pub const fn simhash_matching_bits_64(a: u64, b: u64) -> u32 { 64u32.saturating_sub((a ^ b).count_ones()) } |
| #24 SOLE CROWN #1 <10 CYC | calculate_auto_hex_len domain: g8t-x86_64 | id: b93cfea1144eAye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Zero-Copy Scanning, Parsing & Codec Primitives High-throughput byte-slice scanning, delimiter discovery, and wire-safe ASCII/hex transcoding inside bounded 64KB memory pages. Specialized Multi-Pin Stage `(u64)->usize` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (u64)->usize64-vec BLAKE3: 2cb89abbea4aC64 RAM: 177/65536 (177 B src) | 58083/20000 cyc/op 276647/200000 ns/op | 200000000/276647 ops/us 33 B .text (11 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (177 B)pub fn calculate_auto_hex_len(num_packed_objects: u64) -> usize {
let mut len = 64 - num_packed_objects.leading_zeros();
len = len.div_ceil(2);
len.max(7) as usize
} |
| #25 SOLE CROWN #1 <10 CYC | hutter_uleb128_encode_u64 domain: hutter | id: 2d2f71b39d42Aye: 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. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 398a2f2d8912C64 RAM: 479/65536 (479 B src) | 150837/50000 cyc/op 28741/20000 ns/op | 20000000/28741 ops/us 130 B .text (34 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (479 B)#[inline(always)] pub fn hutter_uleb128_encode_u64(val: u64) -> u64 { let v = val & 0x0FFF_FFFFu64; let b0 = (v & 0x7F) | if v >= (1 << 7) { 0x80 } else { 0 }; let b1 = ((v >> 7) & 0x7F) | if v >= (1 << 14) { 0x80 } else { 0 }; let b2 = ((v >> 14) & 0x7F) | if v >= (1 << 21) { 0x80 } else { 0 }; let b3 = (v >> 21) & 0x7F; let len = 1u64 + ((v >= (1 << 7)) as u64) + ((v >= (1 << 14)) as u64) + ((v >= (1 << 21)) as u64); b0 | (b1 << 8) | (b2 << 16) | (b3 << 24) | (len << 32) } |