rustc -C opt-level=3): 2049 (203973 B .text / 53737 insns)22/9 Hz): 248859 B / 5979044 B (ratio 248859/5979044, saved 5730185/5979044, 11700 ″ dittos)| Rank & Crown | Function Name & Domain | Best Use & Snap-Circuit Role | Pin Signature & 64-Vec Hash | Hardware _rdtsc (p/q) | Details & Quick Peek |
|---|---|---|---|---|---|
| #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 } |
| #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 } } |
| #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 }
} |
| #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 } } |
| #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()) } |
| #26 CROWN #1 of 2 <10 CYC | ilog2_1p_q4 domain: ayecast-x86_64 | id: b8e9f4987afcAye: 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. Specialized Multi-Pin Stage `(u64)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (u64)->u864-vec BLAKE3: 7726ce57c243C64 RAM: 39/8192 (312 B src) | 1074443/200000 cyc/op 116609/80000 ns/op | 80000000/116609 ops/us 78 B .text (25 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (312 B)pub const fn ilog2_1p_q4(v: u64) -> u8 { let x = v.saturating_add(1); let lz = x.leading_zeros(); let exp = 63u32.saturating_sub(lz); let mantissa = if exp >= 4 { ((x >> (exp - 4)) & 0x0F) as u32 } else { ((x << (4 - exp)) & 0x0F) as u32 }; let q4 = (exp << 4) | mantissa; if q4 > 255 { 255 } else { q4 as u8 } } |
| #27 PEER of 2 <10 CYC | ilog2_1p_q4 domain: ayecast-x86_64 | id: 539985bf48ceAye: 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. Specialized Multi-Pin Stage `(u64)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (u64)->u864-vec BLAKE3: 7726ce57c243C64 RAM: 45/8192 (360 B src) | 268503/50000 cyc/op 23311/16000 ns/op | 16000000/23311 ops/us 78 B .text (25 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (360 B)pub const fn ilog2_1p_q4(v: u64) -> u8 {
let x = v.saturating_add(1);
let lz = x.leading_zeros();
let exp = 63u32.saturating_sub(lz);
let mantissa = if exp >= 4 {
((x >> (exp - 4)) & 0x0F) as u32
} else {
((x << (4 - exp)) & 0x0F) as u32
};
let q4 = (exp << 4) | mantissa;
if q4 > 255 { 255 } else { q4 as u8 }
} |
| #30 CROWN #1 of 8 <10 CYC | gcd_u64 domain: ayecast-x86_64 | id: 019267d65d2cAye: 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. 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: c8748439c46fC64 RAM: 1/512 (128 B src) | 1049187/200000 cyc/op 113863/80000 ns/op | 80000000/113863 ops/us 68 B .text (23 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (128 B)pub const fn gcd_u64(mut a: u64, mut b: u64) -> u64 { while b != 0 { let r = a % b; a = b; b = r; } if a == 0 { 1 } else { a } } |
| #32 CROWN #1 of 2 <10 CYC | servo_hang_monitor_level domain: ayecast-x86_64 | id: 13c9bfa060f3Aye: 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 `(u64,u64,bool)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (u64,u64,bool)->u864-vec BLAKE3: 7dd53efdd5b7C64 RAM: 69/16384 (276 B src) | 281177/50000 cyc/op 610281/400000 ns/op | 400000000/610281 ops/us 35 B .text (12 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (276 B)pub const fn servo_hang_monitor_level(last_activity_ms: u64, now_ms: u64, waiting_for_io: bool) -> u8 { if waiting_for_io || now_ms <= last_activity_ms { return 0; } let elapsed = now_ms - last_activity_ms; if elapsed >= 5_000 { 2 } else if elapsed >= 1_000 { 1 } else { 0 } } |
| #33 PEER of 2 <10 CYC | servo_hang_monitor_level domain: ayecast-x86_64 | id: 8eca2362e481Aye: 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 `(u64,u64,bool)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (u64,u64,bool)->u864-vec BLAKE3: 7dd53efdd5b7C64 RAM: 351/65536 (351 B src) | 7077/1250 cyc/op 307207/200000 ns/op | 200000000/307207 ops/us 35 B .text (12 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (351 B)pub const fn servo_hang_monitor_level(
last_activity_ms: u64,
now_ms: u64,
waiting_for_io: bool,
) -> u8 {
if waiting_for_io || now_ms <= last_activity_ms {
return 0;
}
let elapsed = now_ms - last_activity_ms;
if elapsed >= 5_000 {
2
} else if elapsed >= 1_000 {
1
} else {
0
}
} |
| #41 SOLE CROWN #1 <10 CYC | phoenix_decay_q15 domain: ayecast-x86_64 | id: e38128c8e801Aye: 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 `(u64,u64)->u16` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (u64,u64)->u1664-vec BLAKE3: 8dda8119f2d6C64 RAM: 87/16384 (348 B src) | 1300123/200000 cyc/op 14109/8000 ns/op | 8000000/14109 ops/us 95 B .text (27 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (348 B)pub const fn phoenix_decay_q15(t_sec: u64, tau_sec: u64) -> u16 { if tau_sec == 0 { return 32_768; } let tau = (if tau_sec > 1_000_000 { 1_000_000 } else { tau_sec }) as u128; let t = (if t_sec > 10_000_000 { 10_000_000 } else { t_sec }) as u128; let num = 4 * tau * tau * 32_768; let den = 4 * tau * tau + 4 * tau * t + t * t; (num / den) as u16 } |
| #443 SOLE CROWN #1 | unpack_5_trits_base243 domain: ayecast-x86_64 | id: 07eff900be76Aye: 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. Specialized Multi-Pin Stage `(u8)->[i8;5]` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (u8)->[i8;5]64-vec BLAKE3: 862195839af1C64 RAM: 71/16384 (284 B src) | 2303721/200000 cyc/op 624979/200000 ns/op | 200000000/624979 ops/us 147 B .text (48 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (284 B)pub const fn unpack_5_trits_base243(byte: u8) -> [i8; 5] {
let mut v = if byte >= 243 { 242 } else { byte };
let mut out = [0i8; 5];
let mut i = 0;
while i < 5 {
let rem = v % 3;
out[i] = (rem as i8) - 1;
v /= 3;
i += 1;
}
out
} |
| #798 SOLE CROWN #1 | step_babbage_cubic_8x_i32 domain: ayecast-x86_64 | id: 6d1c05f66367Aye: 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 `(i32,i32,i32,i32)->[i32;8]` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (i32,i32,i32,i32)->[i32;8]64-vec BLAKE3: 7ecac38e7957C64 RAM: 967/65536 (967 B src) | 394233/25000 cyc/op 427801/100000 ns/op | 100000000/427801 ops/us 270 B .text (80 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (967 B)pub const fn step_babbage_cubic_8x_i32(p0: i32, p1: i32, p2: i32, p3: i32) -> [i32; 8] {
let x0 = p0 as i64;
let x1 = p1 as i64;
let x2 = p2 as i64;
let x3 = p3 as i64;
// Catmull-Rom polynomial coefficients scaled by 2 * 512 = 1024 (t = k/8, k=0..7)
let c0 = 2 * x1;
let c1 = x2 - x0;
let c2 = 2 * x0 - 5 * x1 + 4 * x2 - x3;
let c3 = -x0 + 3 * x1 - 3 * x2 + x3;
// Evaluate at k = 0, 1, 2, 3 to seed Babbage forward differences (d1, d2, d3)
let f0 = c0 * 512;
let f1 = c0 * 512 + c1 * 64 + c2 * 8 + c3;
let f2 = c0 * 512 + c1 * 128 + c2 * 32 + c3 * 8;
let f3 = c0 * 512 + c1 * 192 + c2 * 72 + c3 * 27;
let mut y = f0;
let mut d1 = f1 - f0;
let mut d2 = (f2 - f1) - d1;
let d3 = f3 - 3 * f2 + 3 * f1 - f0;
let mut out = [0i32; 8];
let mut k = 0;
while k < 8 {
out[k] = (y >> 10) as i32;
y += d1;
d1 += d2;
d2 += d3;
k += 1;
}
out
} |
| #948 SOLE CROWN #1 | pack_5_trits_base243 domain: ayecast-x86_64 | id: a32f83726652Aye: 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. Specialized Multi-Pin Stage `([i8;5])->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`. | ([i8;5])->u864-vec BLAKE3: 8a9c47d14f73C64 RAM: 379/65536 (379 B src) | 3767491/200000 cyc/op 2044161/400000 ns/op | 400000000/2044161 ops/us 156 B .text (50 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (379 B)pub const fn pack_5_trits_base243(trits: [i8; 5]) -> u8 {
let mut acc: u16 = 0;
let mut pow3: u16 = 1;
let mut i = 0;
while i < 5 {
let digit: u16 = if trits[i] < 0 {
0
} else if trits[i] > 0 {
2
} else {
1
};
acc += digit * pow3;
pow3 *= 3;
i += 1;
}
acc as u8
} |
| #1548 CROWN #1 of 2 | compute_window_energy_i16 domain: ayecast-x86_64 | id: 47793527a516Aye: 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 `(&[i16])->u64` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (&[i16])->u6464-vec BLAKE3: f158fb26515cC64 RAM: 247/65536 (247 B src) | 453173/20000 cyc/op 1229421/200000 ns/op | 200000000/1229421 ops/us 130 B .text (36 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (247 B)pub fn compute_window_energy_i16(window: &[i16]) -> u64 {
let mut sum: u64 = 0;
let mut i = 0;
while i < window.len() {
let s = window[i] as i64;
sum = sum.saturating_add((s * s) as u64);
i += 1;
}
sum
} |
| #1553 PEER of 2 | compute_window_energy_i16 domain: ayecast-x86_64 | id: b92f040b68b0Aye: 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 `(&[i16])->u64` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (&[i16])->u6464-vec BLAKE3: f158fb26515cC64 RAM: 203/65536 (203 B src) | 4546649/200000 cyc/op 616727/100000 ns/op | 100000000/616727 ops/us 130 B .text (36 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (203 B)pub fn compute_window_energy_i16(window: &[i16]) -> u64 { let mut sum: u64 = 0; let mut i = 0; while i < window.len() { let s = window[i] as i64; sum = sum.saturating_add((s * s) as u64); i += 1; } sum } |
| #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
} |
| #1684 CROWN #1 of 2 | is_dropped_legacy_web_feature domain: ayecast-x86_64 | id: c63d21901bd3Aye: 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 `(&str)->bool` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (&str)->bool64-vec BLAKE3: cf029ab232ffC64 RAM: 27/4096 (432 B src) | 8644891/200000 cyc/op 1172609/100000 ns/op | 100000000/1172609 ops/us 1311 B .text (331 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (432 B)pub fn is_dropped_legacy_web_feature(feature_or_tag: &str) -> bool {
let lower = feature_or_tag.trim().to_ascii_lowercase();
matches!(
lower.as_str(),
"frameset"
| "frame"
| "applet"
| "marquee"
| "blink"
| "keygen"
| "document.write"
| "xpath"
| "xslt"
| "websql"
| "quirks-mode"
)
} |
| #1715 CROWN #1 of 2 | crc32_ieee domain: ayecast-x86_64 | id: d9ce35ad8bc3Aye: 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. Slice Ingress / Scanner Stage `(&[u8])->u32` — digests raw byte buffers into scalar tokens or checksums. | (&[u8])->u3264-vec BLAKE3: cc409111601bC64 RAM: 187/32768 (374 B src) | 26681929/200000 cyc/op 14476559/400000 ns/op | 400000000/14476559 ops/us 178 B .text (49 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (374 B)pub const fn crc32_ieee(data: &[u8]) -> u32 {
let mut crc: u32 = 0xFFFF_FFFF;
let mut i = 0;
while i < data.len() {
crc ^= data[i] as u32;
let mut bit = 0;
while bit < 8 {
let mask = (crc & 1).wrapping_neg();
crc = (crc >> 1) ^ (0xEDB8_8320 & mask);
bit += 1;
}
i += 1;
}
!crc
} |
| #2035 PEER of 3 | isqrt_u64 domain: ayecast-x86_64 | id: 701c3bcfc01cAye: 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: 51/16384 (204 B src) | 288519/625 cyc/op 10018371/80000 ns/op | 80000000/10018371 ops/us 115 B .text (34 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (204 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
} |
| #2036 PEER of 8 | gcd_u64 domain: ayecast-x86_64 | id: 6ac4c0cf31dbAye: 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. 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: c8748439c46fC64 RAM: 41/16384 (164 B src) | 193134903/400000 cyc/op 52398841/400000 ns/op | 400000000/52398841 ops/us 68 B .text (23 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (164 B)pub const fn gcd_u64(mut a: u64, mut b: u64) -> u64 {
while b != 0 {
let r = a % b;
a = b;
b = r;
}
if a == 0 { 1 } else { a }
} |