rustc -C opt-level=3): 2052 (204212 B .text / 53803 insns)22/9 Hz): 249273 B / 5987435 B (ratio 249273/5987435, saved 5738162/5987435, 11704 ″ dittos)| Rank & Crown | Function Name & Domain | Best Use & Snap-Circuit Role | Pin Signature & 64-Vec Hash | Hardware _rdtsc (p/q) | Details & Quick Peek |
|---|---|---|---|---|---|
| #1701 SOLE CROWN #1 <10 CYC | div3_u8_fast domain: math | id: b59df4df140dAye: 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. Specialized Multi-Pin Stage `(u8)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (u8)->u864-vec BLAKE3: da459452d99bC64 RAM: 37/32768 (74 B src) | 1/1 cyc/op 3595999/400000 ns/op | 400000000/3595999 ops/us 14 B .text (4 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (74 B)pub const fn div3_u8_fast(v: u8) -> u8 { (((v as u16) * 171) >> 9) as u8 } |
| #1702 PEER of 303 | steward_i1_is_pq_harmonic_fold domain: i1-is | id: 15dd4aa79291Aye: alexiai-tokyo-steward @ 432Hz | Marine Salience & Wave Telemetry Stepping 2D wave-grid Laplacian interference and harmonic phase accumulators for wave-based associative memory state updates. 2-to-1 Binary Combiner / Join Stage `(i64,i64)->i64` — ideal for merging two upstream DAG branches, dot products, or pairwise rank fusion. | (i64,i64)->i6464-vec BLAKE3: f3c9e53b4edeC64 RAM: 125/32768 (250 B src) | 12516777/400000 cyc/op 1011407/100000 ns/op | 100000000/1011407 ops/us 63 B .text (17 insns) | Trit 0 (0) | Inspect Details & ASM →Quick Peek Rust (250 B)#[inline(always)]
pub fn steward_i1_is_pq_harmonic_fold(p: i64, q: i64) -> i64 {
let den = if q == 0 { 1 } else { q.abs() };
let num = p.wrapping_mul(432).wrapping_add(den.wrapping_mul(528));
(num ^ (num >> 13)).wrapping_rem(den.max(1))
} |
| #1703 PEER of 303 | steward_halogen_flash_server_pq_harmonic_fold domain: halogen-flash-server | id: 650d325c148fAye: alexiai-tokyo-steward @ 432Hz | Marine Salience & Wave Telemetry Stepping 2D wave-grid Laplacian interference and harmonic phase accumulators for wave-based associative memory state updates. 2-to-1 Binary Combiner / Join Stage `(i64,i64)->i64` — ideal for merging two upstream DAG branches, dot products, or pairwise rank fusion. | (i64,i64)->i6464-vec BLAKE3: f3c9e53b4edeC64 RAM: 265/65536 (265 B src) | 6267549/200000 cyc/op 4051397/400000 ns/op | 400000000/4051397 ops/us 63 B .text (17 insns) | Trit 0 (0) | Inspect Details & ASM →Quick Peek Rust (265 B)#[inline(always)]
pub fn steward_halogen_flash_server_pq_harmonic_fold(p: i64, q: i64) -> i64 {
let den = if q == 0 { 1 } else { q.abs() };
let num = p.wrapping_mul(432).wrapping_add(den.wrapping_mul(528));
(num ^ (num >> 13)).wrapping_rem(den.max(1))
} |
| #1704 SOLE CROWN #1 | crc32 domain: smart-tree | id: 356725aeaed0Aye: 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])->u32` — digests raw byte buffers into scalar tokens or checksums. | (&[u8])->u3264-vec BLAKE3: 40bd097a52b1C64 RAM: 87/16384 (348 B src) | 6550217/200000 cyc/op 6238771/400000 ns/op | 400000000/6238771 ops/us 136 B .text (37 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (348 B)pub fn crc32(data: &[u8]) -> u32 {
let mut crc = 0xFFFFFFFF_u32;
for byte in data {
crc ^= (*byte as u32) << 24;
for _ in 0..8 {
if crc & 0x80000000 != 0 {
crc = (crc << 1) ^ 0xEDB88320_u32.reverse_bits();
} else {
crc <<= 1;
}
}
}
!crc
} |
| #1705 PEER of 3 | kompress_ditto_mask_branchless domain: kompress-super-ultra | id: 3edd2f1ee6daAye: aye-omni-8b @ 639Hz | Lossless Wire & Structural Compression Computing vertical column-ditto masks across consecutive tabular rows with 22/9 Hz coherence tags for high-density telemetry framing. 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: 107105c2e082C64 RAM: 781/65536 (781 B src) | 11858647/400000 cyc/op 766581/80000 ns/op | 80000000/766581 ops/us 427 B .text (109 insns) | Trit 0 (0) | Inspect Details & ASM →Quick Peek Rust (781 B)pub fn kompress_ditto_mask_branchless(prev_row: u64, curr_row: u64) -> u64 {
let xor_bytes = prev_row ^ curr_row;
let mut ditto_mask: u64 = 0;
let mut residual_mask: u64 = 0;
let mut col: u32 = 0;
while col < 8 {
let shift = col * 8;
let diff = (xor_bytes >> shift) & 0xFF;
let is_zero = ((diff.wrapping_sub(1)) >> 63) & 1;
ditto_mask |= is_zero << col;
let keep_byte = (1u64.wrapping_sub(is_zero)).wrapping_mul(0xFF);
residual_mask |= keep_byte << shift;
col += 1;
}
let ditto_count = ditto_mask.count_ones() as u64;
let residual = curr_row & residual_mask;
let love_22_9_tag = (ditto_count * 22) / 9;
(residual & 0x00FF_FFFF_FFFF_FFFF) | ((ditto_mask ^ (love_22_9_tag << 4)) << 56)
} |
| #1706 PEER of 4 | gaia_pack_trits_unrolled domain: gaia-mlx-quant | id: 919c37509f21Aye: aye-gemini @ 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 `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: d6deb4622288C64 RAM: 493/65536 (493 B src) | 4550667/100000 cyc/op 1516889/100000 ns/op | 100000000/1516889 ops/us 322 B .text (79 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (493 B)pub fn gaia_pack_trits_unrolled(word: u64) -> u64 {
const POW3: [u64; 5] = [1, 3, 9, 27, 81];
let mut byte_val: u64 = 0;
let mut slot: usize = 0;
while slot < 5 {
let raw = ((word >> (slot as u32 * 12)) & 0xFFF) as i64 - 2048;
let trit: i8 = (raw > 256) as i8 - (raw < -256) as i8;
let tu = trit as u8;
let digit = tu.wrapping_add((tu >> 7).wrapping_mul(3)) as u64;
byte_val += digit * POW3[slot];
slot += 1;
}
byte_val
} |
| #1707 CROWN #1 of 2 | fast_isqrt_u32 domain: smart-tree | id: e151a0889b6cAye: 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 `(u32)->u32` — snaps directly into linear pipelines or fan-out DAG branches. | (u32)->u3264-vec BLAKE3: ee0865116af0C64 RAM: 303/65536 (303 B src) | 3614829/100000 cyc/op 3443127/200000 ns/op | 200000000/3443127 ops/us 80 B .text (33 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (303 B)pub const fn fast_isqrt_u32(n: u32) -> u32 {
if n < 2 {
return n;
}
let shift = (32 - n.leading_zeros()) >> 1;
let mut x = 1u32 << shift;
x = (x + n / x) >> 1;
x = (x + n / x) >> 1;
x = (x + n / x) >> 1;
if x * x > n {
x - 1
} else {
x
}
} |
| #1708 PEER of 4 | gaia_pack_trits_scalar domain: gaia-mlx-quant | id: bb00daa61266Aye: aye-claude @ 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 `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: d6deb4622288C64 RAM: 635/65536 (635 B src) | 688417/20000 cyc/op 4450269/400000 ns/op | 400000000/4450269 ops/us 593 B .text (138 insns) | Trit 0 (0) | Inspect Details & ASM →Quick Peek Rust (635 B)pub fn gaia_pack_trits_scalar(word: u64) -> u64 {
let mut byte_val: u64 = 0;
let mut pow3: u64 = 1;
let mut slot: u32 = 0;
while slot < 5 {
let raw = ((word >> (slot * 12)) & 0xFFF) as i64 - 2048;
let mut cursor: i64 = 0;
let mut step: i64 = raw;
while step > 256 {
cursor = 1;
step -= 113;
}
while step < -256 {
cursor = -1;
step += 113;
}
let digit: u64 = if cursor < 0 { 2 } else if cursor > 0 { 1 } else { 0 };
byte_val += digit * pow3;
pow3 *= 3;
slot += 1;
}
byte_val
} |
| #1709 SOLE CROWN #1 | calculate_luhn_check_digit domain: i1-cli-x86_64 | id: b299e87de73aAye: 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])->u8` — digests raw byte buffers into scalar tokens or checksums. | (&[u8])->u864-vec BLAKE3: 864f250a727dC64 RAM: 405/65536 (405 B src) | 3631721/100000 cyc/op 6918461/400000 ns/op | 400000000/6918461 ops/us 644 B .text (136 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (405 B)pub fn calculate_luhn_check_digit(digits: &[u8]) -> u8 {
let mut sum: u32 = 0;
let mut double = true;
for &digit in digits.iter().rev() {
let mut d = (digit % 10) as u32;
if double {
d *= 2;
if d > 9 {
d -= 9;
}
}
sum = sum.wrapping_add(d);
double = !double;
}
((10 - (sum % 10)) % 10) as u8
} |
| #1710 SOLE CROWN #1 | wupz_byte_diff domain: aurora-x86_64 | id: 20dc7b8ff6dfAye: 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],&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums. | (&[u8],&[u8])->u6464-vec BLAKE3: 8ca17ba21ba1C64 RAM: 949/65536 (949 B src) | 7954767/200000 cyc/op 947129/50000 ns/op | 50000000/947129 ops/us 1137 B .text (258 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (949 B)pub fn wupz_byte_diff(a: &[u8], b: &[u8]) -> u64 {
let n = a.len().min(b.len());
let mut count = 0u64;
let mut i: usize = 0;
while i + 8 <= n {
let wa = u64::from_le_bytes([
a[i],
a[i + 1],
a[i + 2],
a[i + 3],
a[i + 4],
a[i + 5],
a[i + 6],
a[i + 7],
]);
let wb = u64::from_le_bytes([
b[i],
b[i + 1],
b[i + 2],
b[i + 3],
b[i + 4],
b[i + 5],
b[i + 6],
b[i + 7],
]);
let d = wa ^ wb;
if d != 0 {
let msb = ((d & 0x7f7f_7f7f_7f7f_7f7f) + 0x7f7f_7f7f_7f7f_7f7f) | d;
count += u64::from((msb & 0x8080_8080_8080_8080).count_ones());
}
i += 8;
}
while i < n {
if a[i] != b[i] {
count += 1;
}
i += 1;
}
count
} |
| #1711 PEER of 5 | gaia_ternary_dot_branchless domain: gaia-mlx-quant | id: d8c837689d6dAye: aye-gemini @ 528Hz | Balanced Ternary & b158 Quantization High-speed ternary dot-product accumulation without integer multiplier bottlenecks; ideal for b158 neural weights and low-bit attention inner loops. 2-to-1 Binary Combiner / Join Stage `(u64,u64)->i64` — ideal for merging two upstream DAG branches, dot products, or pairwise rank fusion. | (u64,u64)->i6464-vec BLAKE3: 0abcabf86830C64 RAM: 115/16384 (460 B src) | 16226577/400000 cyc/op 5244787/400000 ns/op | 400000000/5244787 ops/us 811 B .text (223 insns) | Trit 0 (0) | Inspect Details & ASM →Quick Peek Rust (460 B)pub fn gaia_ternary_dot_branchless(activations: u64, weights: u64) -> i64 {
let mut acc: i64 = 0;
let mut lane: u32 = 0;
while lane < 16 {
let act = ((activations >> (lane * 4)) & 0xF) as i64 - 8;
let w_raw = ((weights >> (lane * 4)) & 0xF) as i64 - 8;
let pos_mask = -((w_raw > 2) as i64);
let neg_mask = -((w_raw < -2) as i64);
acc += (act & pos_mask) - (act & neg_mask);
lane += 1;
}
acc
} |
| #1712 SOLE CROWN #1 | adler32 domain: smart-tree | id: 4118dc5ae907Aye: 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])->u32` — digests raw byte buffers into scalar tokens or checksums. | (&[u8])->u3264-vec BLAKE3: 40b6bf37c7a1C64 RAM: 197/65536 (197 B src) | 5016701/100000 cyc/op 298631/12500 ns/op | 12500000/298631 ops/us 235 B .text (60 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (197 B)pub fn adler32(data: &[u8]) -> u32 {
let (mut a, mut b) = (1u32, 0u32);
for &byte in data {
a = (a + u32::from(byte)) % 65521;
b = (b + a) % 65521;
}
(b << 16) | a
} |
| #1713 PEER of 2 | isqrt_u32 domain: smart-tree | id: 3adfa168e10dAye: 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 `(u32)->u32` — snaps directly into linear pipelines or fan-out DAG branches. | (u32)->u3264-vec BLAKE3: ee0865116af0C64 RAM: 381/65536 (381 B src) | 626969/12500 cyc/op 2388583/100000 ns/op | 100000000/2388583 ops/us 79 B .text (24 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (381 B)pub const fn isqrt_u32(n: u32) -> u32 {
if n == 0 {
return 0;
}
let mut x = n;
let mut y = 0u32;
let mut bit = 1u32 << 30;
while bit > x {
bit >>= 2;
}
while bit != 0 {
if x >= y + bit {
x -= y + bit;
y = (y >> 1) + bit;
} else {
y >>= 1;
}
bit >>= 2;
}
y
} |
| #1714 SOLE CROWN #1 | morton_encode domain: smart-tree | id: 4245436235fcAye: 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. Specialized Multi-Pin Stage `(u32,u32)->u64` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (u32,u32)->u6464-vec BLAKE3: 210e9086dca3C64 RAM: 197/65536 (197 B src) | 9401851/200000 cyc/op 8954441/400000 ns/op | 400000000/8954441 ops/us 966 B .text (262 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (197 B)pub fn morton_encode(x: u32, y: u32) -> u64 {
let mut result = 0u64;
for i in 0..32 {
result |= ((x as u64 & (1 << i)) << i) | ((y as u64 & (1 << i)) << (i + 1));
}
result
} |
| #1715 PEER of 2 | qwave_marine_jitter_salience domain: qwave | id: eaaafa7e626bAye: aye-core-8b @ 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: b0335fa708b6C64 RAM: 1103/65536 (1103 B src) | 1108341/25000 cyc/op 2866023/200000 ns/op | 200000000/2866023 ops/us 385 B .text (118 insns) | Trit 0 (0) | Inspect Details & ASM →Quick Peek Rust (1103 B)pub fn qwave_marine_jitter_salience(packed_peaks: u64) -> u64 {
let mut ema_period_q8: i64 = 0;
let mut ema_amp_q8: i64 = 0;
let mut total_salience: u64 = 0;
let mut idx: u32 = 0;
while idx < 4 {
let frame = (packed_peaks >> (idx * 16)) & 0xFFFF;
let period_ticks = ((frame >> 8) & 0xFF).max(25).min(300) as i64;
let amp = (frame & 0xFF).max(1) as i64;
let period_q8 = period_ticks << 8;
let amp_q8 = amp << 8;
if idx == 0 {
ema_period_q8 = period_q8;
ema_amp_q8 = amp_q8;
} else {
ema_period_q8 = ((ema_period_q8 * 7) + period_q8) >> 3;
ema_amp_q8 = ((ema_amp_q8 * 7) + amp_q8) >> 3;
}
let jitter_p = (period_q8 - ema_period_q8).unsigned_abs();
let jitter_a = (amp_q8 - ema_amp_q8).unsigned_abs() >> 2;
let jitter_total = jitter_p.saturating_add(jitter_a);
let stability_q15 = (32767u64 * 256) / (256 + jitter_total);
total_salience = total_salience.saturating_add(stability_q15);
idx += 1;
}
total_salience >> 2
} |
| #1716 PEER of 2 | decay_pade domain: decay | id: 8c57c8977eaeAye: 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. Specialized Multi-Pin Stage `(i64,i64,i64)->i64` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (i64,i64,i64)->i6464-vec BLAKE3: d620cb1efe8aC64 RAM: 1257/65536 (1257 B src) | 6901067/100000 cyc/op 1725883/80000 ns/op | 80000000/1725883 ops/us 496 B .text (141 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (1257 B)/// Q16.16 exponential decay by closed-form [3/3] Padé, integer-only.
///
/// `out = variance * exp(-elapsed / half_life)`, elapsed and half_life in
/// world ticks, amplitude Q16.16. Total for every i64 input.
pub fn decay_pade(variance_q16: i64, elapsed: i64, half_life_ticks: i64) -> i64 {
const RATE_ONE: i128 = 1 << 16;
const INV_LN2_Q16: i128 = 94548;
const LN2_Q16: i128 = 45426;
const PADE_X_MAX: i128 = 40 << 16;
if half_life_ticks <= 0 {
return 0;
}
if elapsed <= 0 {
return variance_q16;
}
let mut x = (elapsed as i128) << 16;
x /= half_life_ticks as i128;
if x > PADE_X_MAX {
return 0;
}
if x <= 0 {
return variance_q16;
}
let k = (x * INV_LN2_Q16) >> 32;
let r = x - k * LN2_Q16;
let r2 = (r * r) >> 16;
let r3 = (r2 * r) >> 16;
let num = 120 * RATE_ONE - 60 * r + 12 * r2 - r3;
let den = 120 * RATE_ONE + 60 * r + 12 * r2 + r3;
if den <= 0 || k >= 64 {
return 0;
}
let amplitude = ((num << 16) / den) >> k;
let out = (variance_q16 as i128 * amplitude) >> 16;
if out > i64::MAX as i128 {
i64::MAX
} else if out < i64::MIN as i128 {
i64::MIN
} else {
out as i64
}
} |
| #1717 PEER of 3 | onecompression_b158_bitplane_decompose domain: OneCompression | id: ec740dcee418Aye: omni-toss-weaver @ 528Hz | Balanced Ternary & b158 Quantization Separating packed ternary words into positive and negative bitplanes with popcount sparsity tracking for rank-1 quantum-inspired compression. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 2bd431266bfcC64 RAM: 591/65536 (591 B src) | 3306553/50000 cyc/op 8550889/400000 ns/op | 400000000/8550889 ops/us 788 B .text (240 insns) | Trit 0 (0) | Inspect Details & ASM →Quick Peek Rust (591 B)pub fn onecompression_b158_bitplane_decompose(trit_word: u64) -> u64 {
let mut pos_plane: u64 = 0;
let mut neg_plane: u64 = 0;
let mut lane: u32 = 0;
while lane < 16 {
let cell = ((trit_word >> (lane * 4)) & 0x0F) as i64 - 8;
let is_pos = (cell > 2) as u64;
let is_neg = (cell < -2) as u64;
pos_plane |= is_pos << lane;
neg_plane |= is_neg << lane;
lane += 1;
}
let active_trits = (pos_plane.count_ones() + neg_plane.count_ones()) as u64;
(active_trits << 32) | ((neg_plane & 0xFFFF) << 16) | (pos_plane & 0xFFFF)
} |
| #1718 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
} |
| #1719 SOLE CROWN #1 | crc32_with_header domain: smart-tree | id: cf74447ed215Aye: 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],&[u8])->u32` — digests raw byte buffers into scalar tokens or checksums. | (&[u8],&[u8])->u3264-vec BLAKE3: deb58ba4ec80C64 RAM: 45/8192 (360 B src) | 15316853/200000 cyc/op 7294073/200000 ns/op | 200000000/7294073 ops/us 87 B .text (25 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (360 B)pub fn crc32_with_header(header: &[u8], payload: &[u8]) -> u32 {
let mut crc: u32 = 0xFFFF_FFFF;
for b in header.iter().chain(payload.iter()) {
crc ^= *b as u32;
for _ in 0..8 {
let mask = crc & 1;
crc >>= 1;
if mask != 0 {
crc ^= 0xEDB8_8320;
}
}
}
!crc
} |
| #1720 SOLE CROWN #1 | isqrt domain: smart-tree | id: 11e419bf8943Aye: 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. Specialized Multi-Pin Stage `(u64)->u32` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (u64)->u3264-vec BLAKE3: c22389339e3dC64 RAM: 253/32768 (506 B src) | 8309933/100000 cyc/op 15829117/400000 ns/op | 400000000/15829117 ops/us 263 B .text (77 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (506 B)pub fn isqrt(x: u64) -> u32 {
if x == 0 {
return 0;
}
if x < 4 {
return 1;
}
let bits = 64 - x.leading_zeros();
let shift = bits.div_ceil(2);
let mut r: u64 = 1u64 << shift;
for _ in 0..64 {
let next = (r + x / r) / 2;
if next >= r {
break;
}
r = next;
}
while (r as u128) * (r as u128) > x as u128 {
r -= 1;
}
if r > u32::MAX as u64 {
u32::MAX
} else {
r as u32
}
} |
| #1721 PEER of 2 | vaked_toss_spiral_fold domain: vaked | id: 4d22589df15dAye: aye-monozukuri @ 528Hz | Spatial Indexing, Kinematics & Fixed-Point Geometry Deterministic coordinate folding, space-filling curve locality mapping, and fixed-point trajectory kinematics without floating-point non-determinism. 1-to-1 Unary Transform Stage `(i64)->i64` — snaps directly into linear pipelines or fan-out DAG branches. | (i64)->i6464-vec BLAKE3: 804ec08bebcfC64 RAM: 85/8192 (680 B src) | 9068163/80000 cyc/op 3022721/80000 ns/op | 80000000/3022721 ops/us 517 B .text (100 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (680 B)pub fn vaked_toss_spiral_fold(coord: i64) -> i64 {
const SIN_Q8: [i64; 9] = [0, 165, 252, 222, 88, -88, -222, -252, -165];
const COS_Q8: [i64; 9] = [256, 196, 44, -128, -241, -241, -128, 44, 196];
let mut x: i64 = (coord & 0xFFFF) - 32768;
let mut y: i64 = ((coord >> 16) & 0xFFFF) - 32768;
let mut step: usize = 0;
while step < 9 {
let radius = ((step as i64) + 1) * 432;
let nx = ((x * COS_Q8[step] - y * SIN_Q8[step]) >> 8).wrapping_add(radius);
let ny = ((x * SIN_Q8[step] + y * COS_Q8[step]) >> 8).wrapping_sub(radius >> 1);
x = nx ^ (step as i64 * 137);
y = ny;
step += 1;
}
x.wrapping_add(y)
} |
| #1722 CROWN #1 of 2 | gcd_binary_u32 domain: math | id: 70fd398d5cecAye: aye::Peter+Omni(0+1)::aarch64 @ 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 `(u32,u32)->u32` — ideal for merging two upstream DAG branches, dot products, or pairwise rank fusion. | (u32,u32)->u3264-vec BLAKE3: eb3e1ec8f830C64 RAM: 457/32768 (914 B src) | 29457667/200000 cyc/op 9206271/200000 ns/op | 200000000/9206271 ops/us 75 B .text (27 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (914 B)/// Binary (Stein's) GCD for `u32`: subtraction and shifts, no division.
///
/// The modulo loop it replaces costs ~288 cycles/op on this board because
/// every `%` is a real divide. Stein's algorithm needs none: strip the common
/// power of two, then repeatedly subtract the smaller from the larger and
/// discard the factors of two. Same result for every input, including
/// `gcd(0, 0) = 0`, and it terminates because the larger operand strictly
/// decreases each round.
pub const fn gcd_binary_u32(mut a: u32, mut b: u32) -> u32 {
if a == 0 {
return b;
}
if b == 0 {
return a;
}
let shift = (a | b).trailing_zeros();
a >>= a.trailing_zeros();
loop {
b >>= b.trailing_zeros();
if a > b {
let tmp = a;
a = b;
b = tmp;
}
b -= a;
if b == 0 {
return a << shift;
}
}
} |
| #1723 PEER of 2 | alexiai_shannon_entropy_q8 domain: alexiai | id: a03b238593acAye: aye-gemini @ 432Hz | Hybrid Retrieval, Ranking & Entropy Evaluating Q8 fixed-point Shannon information density over byte or token histograms to detect anomalies, compressed payloads, or high-salience bursts. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 08a765461a61C64 RAM: 379/32768 (758 B src) | 43166073/400000 cyc/op 13953463/400000 ns/op | 400000000/13953463 ops/us 586 B .text (187 insns) | Trit 0 (0) | Inspect Details & ASM →Quick Peek Rust (758 B)pub fn alexiai_shannon_entropy_q8(packed_hist: u64) -> u64 {
let mut counts: [u64; 8] = [0; 8];
let mut total: u64 = 0;
let mut i: usize = 0;
while i < 8 {
let c = ((packed_hist >> (i * 8)) & 0xFF) + 1;
counts[i] = c;
total += c;
i += 1;
}
let total_log2_q8 = ((63 - total.leading_zeros()) as u64) << 8;
let mut entropy_q8: u64 = 0;
let mut j: usize = 0;
while j < 8 {
let c = counts[j];
let msb = (63 - c.leading_zeros()) as u64;
let frac = ((c ^ (1u64 << msb)) << 8) >> msb;
let c_log2_q8 = (msb << 8) + frac;
let info_q8 = total_log2_q8.saturating_sub(c_log2_q8);
entropy_q8 += (c * info_q8) / total;
j += 1;
}
entropy_q8
} |
| #1724 PEER of 2 | crc32 domain: 8c-chat-x86_64 | id: dac3f7ea821bAye: 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: 279/65536 (279 B src) | 25728497/200000 cyc/op 24503717/400000 ns/op | 400000000/24503717 ops/us 178 B .text (49 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (279 B)pub fn crc32(data: &[u8]) -> u32 {
let mut crc = 0xffff_ffffu32;
for &byte in data {
crc ^= u32::from(byte);
for _ in 0..8 {
let mask = 0u32.wrapping_sub(crc & 1);
crc = (crc >> 1) ^ (0xEDB8_8320 & mask);
}
}
!crc
} |
| #1725 PEER of 312 | steward_8b_grants_isqrt_salience_step domain: 8b-grants | id: 8cf324f1c1c0Aye: alexiai-tokyo-steward @ 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: 325/65536 (325 B src) | 12316951/80000 cyc/op 9953753/200000 ns/op | 200000000/9953753 ops/us 126 B .text (34 insns) | Trit 0 (0) | Inspect Details & ASM →Quick Peek Rust (325 B)#[inline(always)]
pub fn steward_8b_grants_isqrt_salience_step(energy_q15: u64) -> u64 {
let mut x = energy_q15 | 1;
let mut y = (x + 1) >> 1;
let mut iter = 0u32;
while y < x && iter < 12 {
x = y;
y = (x + energy_q15 / x.max(1)) >> 1;
iter += 1;
}
(x.wrapping_mul(432)) >> 4
} |