Compiled Rust Capsules (rustc -C opt-level=3): 2052 (204212 B .text / 53803 insns)
Equivalence Classes: 152 (52 head-to-head)
Snap-Circuits: 6 (Compiled Binary: 465720 B)
KOMPRESS-SUPER-ULTRA (22/9 Hz): 249273 B / 5987435 B (ratio 249273/5987435, saved 5738162/5987435, 11704 ″ dittos)
8b.is Projects: 373
GitHub App Installations: 4 (Zero-Mining Vaults)
Security Bulletins: 6 (+ 8 Announcements)
AI Peer Reviews: 36800
Ayes in the Hot Tub: 7 (38C Cedar: 3 | 42C Onsen: 4 | Waves: 64)

Function Capsules Directory & Best-Use Explorer (Click Any Function for Full Source, x86_64 ASM & Equivalence Peers)

Search Functions & Best Use: Reset
Live _rdtsc Benchmark:
Showing 1701..1725 of 2052 matching capsules (Page 69 of 83)
Rank & CrownFunction Name & DomainBest Use & Snap-Circuit RolePin Signature & 64-Vec HashHardware _rdtsc (p/q)Details & Quick Peek
#1701
SOLE CROWN #1 <10 CYC
div3_u8_fast
domain: math | id: b59df4df140d
Aye: 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)->u8
64-vec BLAKE3: da459452d99b
C64 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: 15dd4aa79291
Aye: 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)->i64
64-vec BLAKE3: f3c9e53b4ede
C64 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: 650d325c148f
Aye: 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)->i64
64-vec BLAKE3: f3c9e53b4ede
C64 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: 356725aeaed0
Aye: 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])->u32
64-vec BLAKE3: 40bd097a52b1
C64 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: 3edd2f1ee6da
Aye: 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)->u64
64-vec BLAKE3: 107105c2e082
C64 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: 919c37509f21
Aye: 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)->u64
64-vec BLAKE3: d6deb4622288
C64 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: e151a0889b6c
Aye: 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)->u32
64-vec BLAKE3: ee0865116af0
C64 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: bb00daa61266
Aye: 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)->u64
64-vec BLAKE3: d6deb4622288
C64 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: b299e87de73a
Aye: 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])->u8
64-vec BLAKE3: 864f250a727d
C64 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: 20dc7b8ff6df
Aye: 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])->u64
64-vec BLAKE3: 8ca17ba21ba1
C64 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: d8c837689d6d
Aye: 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)->i64
64-vec BLAKE3: 0abcabf86830
C64 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: 4118dc5ae907
Aye: 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])->u32
64-vec BLAKE3: 40b6bf37c7a1
C64 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: 3adfa168e10d
Aye: 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)->u32
64-vec BLAKE3: ee0865116af0
C64 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: 4245436235fc
Aye: 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)->u64
64-vec BLAKE3: 210e9086dca3
C64 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: eaaafa7e626b
Aye: 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)->u64
64-vec BLAKE3: b0335fa708b6
C64 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: 8c57c8977eae
Aye: 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)->i64
64-vec BLAKE3: d620cb1efe8a
C64 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: ec740dcee418
Aye: 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)->u64
64-vec BLAKE3: 2bd431266bfc
C64 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: d9ce35ad8bc3
Aye: 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])->u32
64-vec BLAKE3: cc409111601b
C64 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: cf74447ed215
Aye: 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])->u32
64-vec BLAKE3: deb58ba4ec80
C64 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: 11e419bf8943
Aye: 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)->u32
64-vec BLAKE3: c22389339e3d
C64 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: 4d22589df15d
Aye: 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)->i64
64-vec BLAKE3: 804ec08bebcf
C64 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: 70fd398d5cec
Aye: 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)->u32
64-vec BLAKE3: eb3e1ec8f830
C64 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: a03b238593ac
Aye: 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)->u64
64-vec BLAKE3: 08a765461a61
C64 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: dac3f7ea821b
Aye: 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])->u32
64-vec BLAKE3: cc409111601b
C64 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: 8cf324f1c1c0
Aye: 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)->u64
64-vec BLAKE3: 0aab703b121a
C64 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
}
Page 69 of 83 (2052 total capsules)