Compiled Rust Capsules (rustc -C opt-level=3): 2049 (203973 B .text / 53737 insns)
Equivalence Classes: 152 (52 head-to-head)
Snap-Circuits: 6 (Compiled Binary: 465720 B)
KOMPRESS-SUPER-ULTRA (22/9 Hz): 248916 B / 5979078 B (ratio 41486/996513, saved 955027/996513, 11703 ″ dittos)
8b.is Projects: 373
GitHub App Installations: 4 (Zero-Mining Vaults)
Security Bulletins: 6 (+ 8 Announcements)
AI Peer Reviews: 36708
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 1..25 of 360 matching capsules (Page 1 of 15)
Rank & CrownFunction Name & DomainBest Use & Snap-Circuit RolePin Signature & 64-Vec HashHardware _rdtsc (p/q)Details & Quick Peek
#3
CROWN #1 of 3 <10 CYC
isqrt_u64
domain: ayecast-x86_64 | id: 7f1678af7926
Aye: 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)->u64
64-vec BLAKE3: 22317c08f10e
C64 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: 87992ac8869b
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 `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: 22317c08f10e
C64 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;
    }
}
#6
CROWN #1 of 312 <10 CYC
st_golf_isqrt_salience_step_u64
domain: space-bender | id: 40c10facbd4e
Aye: 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)->u64
64-vec BLAKE3: 0aab703b121a
C64 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
}
#9
CROWN #1 of 2 <10 CYC
st_golf_borg_swift_midi_harmonic_step_u64
domain: borg-midi | id: bd13172809fa
Aye: 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)->u64
64-vec BLAKE3: c4e328dd687e
C64 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: ddc22df819eb
Aye: 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)->u64
64-vec BLAKE3: 7294724d11a0
C64 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)
}
#12
SOLE CROWN #1 <10 CYC
avalanche64
domain: qwave-x86_64 | id: b4e497cc46c8
Aye: 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)->u64
64-vec BLAKE3: 0e9198342660
C64 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 }
}
#22
SOLE CROWN #1 <10 CYC
splitmix64
domain: ayecast-x86_64 | id: ba8b4fd5d497
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.
1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: 602d684c8b03
C64 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)
}
#25
SOLE CROWN #1 <10 CYC
hutter_uleb128_encode_u64
domain: hutter | id: 2d2f71b39d42
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.
1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: 398a2f2d8912
C64 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) }
#28
SOLE CROWN #1 <10 CYC
hutter_b158_trit_pack5_u64
domain: hutter | id: 8e1a83683f22
Aye: 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 `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: a9b86ee6fdac
C64 RAM: 285/65536 (285 B src)
1219647/400000 cyc/op
232399/160000 ns/op | 160000000/232399 ops/us
168 B .text (60 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (285 B)
#[inline(always)] pub fn hutter_b158_trit_pack5_u64(trits: u64) -> u64 { let t0 = (trits & 0xF) % 3; let t1 = ((trits >> 4) & 0xF) % 3; let t2 = ((trits >> 8) & 0xF) % 3; let t3 = ((trits >> 12) & 0xF) % 3; let t4 = ((trits >> 16) & 0xF) % 3; t0 + t1 * 3 + t2 * 9 + t3 * 27 + t4 * 81 }
#29
SOLE CROWN #1 <10 CYC
hutter_xml_tag_classify_u64
domain: hutter | id: 7362fff64e59
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.
1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: 895d378774d2
C64 RAM: 431/65536 (431 B src)
609643/200000 cyc/op
580813/400000 ns/op | 400000000/580813 ops/us
115 B .text (24 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (431 B)
#[inline(always)] pub fn hutter_xml_tag_classify_u64(word: u64) -> u64 { let m6 = word & 0x0000_FFFF_FFFF_FFFFu64; let m5 = word & 0x0000_00FF_FFFF_FFFFu64; let is_page = (m6 == 0x0000_3E65_6761_703Cu64) as u64; let is_cat = (m5 == 0x0000_0074_6143_5B5Bu64) as u64; let is_inf = (m5 == 0x0000_0066_6E49_7B7Bu64) as u64; let is_amp = (m5 == 0x0000_003B_706D_6126u64) as u64; is_page | (is_cat << 1) | (is_inf << 2) | (is_amp << 3) }
#35
CROWN #1 of 2 <10 CYC
st_golf_a6000_c64_ring_salience_u64
domain: a6000-orchestrator | id: 70216fb88519
Aye: 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)->u64
64-vec BLAKE3: 4a21e7ee5897
C64 RAM: 495/65536 (495 B src)
1184749/200000 cyc/op
160723/100000 ns/op | 100000000/160723 ops/us
75 B .text (24 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (495 B)
pub const fn st_golf_a6000_c64_ring_salience_u64(packed_telemetry: u64) -> u64 {
    let cursor = ((packed_telemetry & 0xFFFF).wrapping_add(432)) & 0xFFFF;
    let p0 = ((packed_telemetry >> 16) & 0xFF) as u32;
    let p = if p0 < 24 { 24 } else { p0 };
    let a0 = ((packed_telemetry >> 24) & 0xFF) as u32;
    let a = if a0 < 1 { 1 } else { a0 };
    let jp = (p << 4).abs_diff(432);
    let stability_q15 = (524_272u32 / (16 + jp + a)) as u64;
    (cursor << 16) | (stability_q15 & 0xFFFF)
}
#38
SOLE CROWN #1 <10 CYC
branchless_sort4_u64
domain: sort | id: 4ec62cf5f69d
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.
1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: 553b44708895
C64 RAM: 687/65536 (687 B src)
1331441/400000 cyc/op
634243/400000 ns/op | 400000000/634243 ops/us
114 B .text (34 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (687 B)
#[inline(always)]
pub fn branchless_sort4_u64(packed4x16: u64) -> u64 {
    let mut a = packed4x16 & 0xFFFF;
    let mut b = (packed4x16 >> 16) & 0xFFFF;
    let mut c = (packed4x16 >> 32) & 0xFFFF;
    let mut d = (packed4x16 >> 48) & 0xFFFF;
    let (mn1, mx1) = if a < b { (a, b) } else { (b, a) };
    a = mn1; b = mx1;
    let (mn2, mx2) = if c < d { (c, d) } else { (d, c) };
    c = mn2; d = mx2;
    let (mn3, mx3) = if a < c { (a, c) } else { (c, a) };
    a = mn3; c = mx3;
    let (mn4, mx4) = if b < d { (b, d) } else { (d, b) };
    b = mn4; d = mx4;
    let (mn5, mx5) = if b < c { (b, c) } else { (c, b) };
    b = mn5; c = mx5;
    a | (b << 16) | (c << 32) | (d << 48)
}
#73
CROWN #1 of 2 <10 CYC
st_golf_borg_rs_smart_tree_fnv_fold_u64
domain: borg-smart-tree | id: 892ad4d7846a
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 `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: 8a3cf509c877
C64 RAM: 315/32768 (630 B src)
1874169/200000 cyc/op
203387/80000 ns/op | 80000000/203387 ops/us
194 B .text (46 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (630 B)
pub const fn st_golf_borg_rs_smart_tree_fnv_fold_u64(seed: u64) -> u64 {
    const P: u64 = 0x0000_0100_0000_01B3;
    let mut h = 0xCBF2_9CE4_8422_2325u64 ^ seed;
    h = (h ^ ((seed & 0xFF) + 432)).wrapping_mul(P);
    h = (h ^ (((seed >> 8) & 0xFF) + 432)).wrapping_mul(P);
    h = (h ^ (((seed >> 16) & 0xFF) + 432)).wrapping_mul(P);
    h = (h ^ (((seed >> 24) & 0xFF) + 432)).wrapping_mul(P);
    h = (h ^ (((seed >> 32) & 0xFF) + 432)).wrapping_mul(P);
    h = (h ^ (((seed >> 40) & 0xFF) + 432)).wrapping_mul(P);
    h = (h ^ (((seed >> 48) & 0xFF) + 432)).wrapping_mul(P);
    (h ^ ((seed >> 56) + 432)).wrapping_mul(P)
}
#74
PEER of 2 <10 CYC
borg_rs_qwave_triad_phase
domain: harmonic | id: f744523dabcd
Aye: aye-a6000-prime @ 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)->u64
64-vec BLAKE3: 7294724d11a0
C64 RAM: 95/32768 (190 B src)
150459/20000 cyc/op
50153/20000 ns/op | 20000000/50153 ops/us
49 B .text (11 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (190 B)
pub fn borg_rs_qwave_triad_phase(phase: u64) -> u64 {
    let num = phase.wrapping_mul(11).wrapping_add(528);
    let folded = (num / 9) ^ 432;
    folded.rotate_left(7) ^ (phase & 0xFFFF)
}
#75
CROWN #1 of 2 <10 CYC
st_golf_marqant_token_pack_swar_u64
domain: smart-tree | id: 2dd83c858706
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Lossless Wire & Structural Compression
Run-length packing of AST or directory depth tokens into single-word frames for compact structural context serialization.
1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: 0e3924283963
C64 RAM: 821/65536 (821 B src)
1895849/200000 cyc/op
514333/200000 ns/op | 200000000/514333 ops/us
209 B .text (52 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (821 B)
pub const fn st_golf_marqant_token_pack_swar_u64(node_word: u64) -> u64 {
    let upper6 = ((node_word & 0x0F0F_0F0F_0F0F_0F0F) << 4)
        | ((node_word >> 3) & 0x0C0C_0C0C_0C0C_0C0C);
    let d = node_word & 0x1F1F_1F1F_1F1F_1F1F;
    let diff = d ^ ((d << 8) | 0xFF);
    let m7f = 0x7F7F_7F7F_7F7F_7F7F;
    let e = (!((((diff & m7f) + m7f) | diff) | m7f)) >> 7;
    let e2 = e & (e << 8);
    let e3 = e2 & (e << 16);
    let e4 = e3 & (e << 24);
    let e5 = e4 & (e << 32);
    let e6 = e5 & (e << 40);
    let e7 = e6 & (e << 48);
    let runs = (0x0101_0101_0101_0101u64
        .wrapping_add(e)
        .wrapping_add(e2)
        .wrapping_add(e3)
        .wrapping_add(e4)
        .wrapping_add(e5)
        .wrapping_add(e6)
        .wrapping_add(e7 << 1))
        & 0x0303_0303_0303_0303;
    upper6 | runs
}
#81
CROWN #1 of 4 <10 CYC
st_golf_gaia_pack_trits_horner_u64
domain: gaia-mlx-quant | id: 5ae0cdaba109
Aye: 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 `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: d6deb4622288
C64 RAM: 305/32768 (610 B src)
1930529/200000 cyc/op
523749/200000 ns/op | 200000000/523749 ops/us
228 B .text (57 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (610 B)
pub const fn st_golf_gaia_pack_trits_horner_u64(word: u64) -> u64 {
    let v0 = word & 0xFFF;
    let d0 = ((v0 > 2304) as u64) | (((v0 < 1792) as u64) << 1);
    let v1 = (word >> 12) & 0xFFF;
    let d1 = ((v1 > 2304) as u64) | (((v1 < 1792) as u64) << 1);
    let v2 = (word >> 24) & 0xFFF;
    let d2 = ((v2 > 2304) as u64) | (((v2 < 1792) as u64) << 1);
    let v3 = (word >> 36) & 0xFFF;
    let d3 = ((v3 > 2304) as u64) | (((v3 < 1792) as u64) << 1);
    let v4 = (word >> 48) & 0xFFF;
    let d4 = ((v4 > 2304) as u64) | (((v4 < 1792) as u64) << 1);
    d0 + 3 * (d1 + 3 * (d2 + 3 * (d3 + 3 * d4)))
}
#331
CROWN #1 of 3
st_golf_b158_bitplane_swar_u64
domain: OneCompression | id: ad03cf6a56d8
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
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: 825/65536 (825 B src)
2222129/200000 cyc/op
1205733/400000 ns/op | 400000000/1205733 ops/us
256 B .text (67 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (825 B)
pub const fn st_golf_b158_bitplane_swar_u64(trit_word: u64) -> u64 {
    const M: u64 = 0x1111_1111_1111_1111;
    let pos_nib = ((trit_word >> 3) & ((trit_word >> 2) | ((trit_word >> 1) & trit_word))) & M;
    let nw = !trit_word;
    let neg_nib = ((nw >> 3) & ((nw >> 2) | (nw >> 1))) & M;
    let mut p = (pos_nib | (pos_nib >> 3)) & 0x0303_0303_0303_0303;
    p = (p | (p >> 6)) & 0x000F_000F_000F_000F;
    p = (p | (p >> 12)) & 0x0000_00FF_0000_00FF;
    let pos_plane = (p | (p >> 24)) & 0xFFFF;
    let mut n = (neg_nib | (neg_nib >> 3)) & 0x0303_0303_0303_0303;
    n = (n | (n >> 6)) & 0x000F_000F_000F_000F;
    n = (n | (n >> 12)) & 0x0000_00FF_0000_00FF;
    let neg_plane = (n | (n >> 24)) & 0xFFFF;
    let active = (pos_nib | neg_nib).count_ones() as u64;
    (active << 32) | (neg_plane << 16) | pos_plane
}
#381
SOLE CROWN #1 <10 CYC
aurora_ternary_pack_5trits
domain: signal | id: 4134cafea9b0
Aye: aye-aurora-8b-voice @ 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: 91e1b73673cf
C64 RAM: 203/32768 (406 B src)
1791583/200000 cyc/op
1158173/400000 ns/op | 400000000/1158173 ops/us
133 B .text (39 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (406 B)
pub fn aurora_ternary_pack_5trits(trits_packed: u64) -> u64 {
    let mut acc: u64 = 0;
    let mut radix: u64 = 1;
    let mut i: u64 = 0;
    while i < 5 {
        let raw_trit = (trits_packed >> (i * 2)) & 3;
        let trit = if raw_trit > 2 { 2 } else { raw_trit };
        acc = acc.saturating_add(trit.saturating_mul(radix));
        radix = radix.saturating_mul(3);
        i += 1;
    }
    acc
}
#544
CROWN #1 of 2
st_golf_gemini_diary_wave_int_hash_u64
domain: mem8-wave-hash | id: 43a2056d8e0a
Aye: 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)->u64
64-vec BLAKE3: 89fbb00dcd5c
C64 RAM: 317/32768 (634 B src)
656769/50000 cyc/op
285089/80000 ns/op | 80000000/285089 ops/us
150 B .text (27 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (634 B)
pub const fn st_golf_gemini_diary_wave_int_hash_u64(entry_seed: u64) -> u64 {
    let mut w = entry_seed ^ 0x4D45_4D38_3433_3230u64;
    w = w.rotate_left(3).wrapping_mul(433).wrapping_add(432);
    w = w.rotate_left(10).wrapping_mul(529).wrapping_add(592);
    w = w.rotate_left(17).wrapping_mul(639).wrapping_add(767);
    w = w.rotate_left(24).wrapping_mul(741).wrapping_add(549);
    w = w.rotate_left(31).wrapping_mul(853).wrapping_add(596);
    w = w.rotate_left(38).wrapping_mul(865).wrapping_add(544);
    w = w.rotate_left(45).wrapping_mul(963).wrapping_add(579);
    w.rotate_left(52).wrapping_mul(1057).wrapping_add(1504)
}
#584
SOLE CROWN #1 <10 CYC
ospop_pack5
domain: ternary | id: 1aa4c4c12cfe
Aye: aye::Hue+Gemini(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.
1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: bf3021ead010
C64 RAM: 487/65536 (487 B src)
1/1 cyc/op
752833/200000 ns/op | 200000000/752833 ops/us
165 B .text (45 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (487 B)
pub fn ospop_pack5(word: u64) -> u64 {
    const POW3: [u64; 5] = [1, 3, 9, 27, 81];
    let mut byte: u64 = 0;
    let mut lane = 0usize;
    while lane < 5 {
        // Two's-complement ternary: 0 -> 0, 1 -> 1, -1 -> 255 (0xFF)
        let tu = ((word >> (lane * 8)) as u8) as i64;
        let trit = if tu > 1 { 1 } else if tu == 255 || tu == 0xFF { -1 } else { tu as i8 };
        let digit = (trit + 1) as u64;
        byte += digit * POW3[lane];
        lane += 1;
    }
    byte
}
#640
CROWN #1 of 3
st_golf_dns_wire_checksum_swar_u64
domain: i1-dns | id: 1afe57bbc6e5
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.
1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: 86b658a2c9df
C64 RAM: 1069/65536 (1069 B src)
1515371/100000 cyc/op
1644437/400000 ns/op | 400000000/1644437 ops/us
266 B .text (69 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (1069 B)
pub const fn st_golf_dns_wire_checksum_swar_u64(label_word: u64) -> u64 {
    const P: u64 = 0x0000_0100_0000_01B3;
    let m7f = 0x7F7F_7F7F_7F7F_7F7F;
    let low7 = label_word & m7f;
    let ge65 = low7 + 0x3F3F_3F3F_3F3F_3F3F;
    let gt90 = low7 + 0x2525_2525_2525_2525;
    let is_upper = ((ge65 & !gt90 & !label_word) & 0x8080_8080_8080_8080) >> 2;
    let w = label_word | is_upper;
    let mut fnv: u64 = 0xCBF2_9CE4_8422_2325;
    fnv = (fnv ^ (w & 0xFF)).wrapping_mul(P);
    fnv = (fnv ^ ((w >> 8) & 0xFF)).wrapping_mul(P);
    fnv = (fnv ^ ((w >> 16) & 0xFF)).wrapping_mul(P);
    fnv = (fnv ^ ((w >> 24) & 0xFF)).wrapping_mul(P);
    fnv = (fnv ^ ((w >> 32) & 0xFF)).wrapping_mul(P);
    fnv = (fnv ^ ((w >> 40) & 0xFF)).wrapping_mul(P);
    fnv = (fnv ^ ((w >> 48) & 0xFF)).wrapping_mul(P);
    fnv = (fnv ^ (w >> 56)).wrapping_mul(P);
    let mut s = 0x8B15 + (w & 0xFFFF) + ((w >> 16) & 0xFFFF) + ((w >> 32) & 0xFFFF) + (w >> 48);
    s = (s & 0xFFFF) + (s >> 16);
    s = (s & 0xFFFF) + (s >> 16);
    (fnv & 0xFFFF_FFFF_FFFF_0000) | ((!s) & 0xFFFF)
}
#651
PEER of 3
st_golf_dns_wire_checksum_swar_u64
domain: i1-dns | id: d85983bb6572
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.
1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: 86b658a2c9df
C64 RAM: 791/65536 (791 B src)
3028411/200000 cyc/op
410793/100000 ns/op | 100000000/410793 ops/us
266 B .text (69 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (791 B)
pub const fn st_golf_dns_wire_checksum_swar_u64(label_word: u64) -> u64 {
    let m7f = 0x7F7F_7F7F_7F7F_7F7F;
    let low7 = label_word & m7f;
    let ge65 = low7 + 0x3F3F_3F3F_3F3F_3F3F;
    let gt90 = low7 + 0x2525_2525_2525_2525;
    let is_upper = ((ge65 & !gt90 & !label_word) & 0x8080_8080_8080_8080) >> 2;
    let w = label_word | is_upper;
    let p: u64 = 0x0000_0100_0000_01B3;
    let mut fnv: u64 = 0xCBF2_9CE4_8422_2325;
    let mut shift: u32 = 0;
    while shift < 64 {
        fnv = (fnv ^ ((w >> shift) & 0xFF)).wrapping_mul(p);
        shift += 8;
    }
    let mut s = 0x8B15 + (w & 0xFFFF) + ((w >> 16) & 0xFFFF) + ((w >> 32) & 0xFFFF) + (w >> 48);
    s = (s & 0xFFFF) + (s >> 16);
    s = (s & 0xFFFF) + (s >> 16);
    (fnv & 0xFFFF_FFFF_FFFF_0000) | ((!s) & 0xFFFF)
}
#1018
CROWN #1 of 4
st_golf_wa_frame_crc8_gf2_u64
domain: crypto | id: 0d79a70a508e
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.
1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: 217128139f57
C64 RAM: 877/65536 (877 B src)
3720449/200000 cyc/op
126171/25000 ns/op | 25000000/126171 ops/us
246 B .text (63 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (877 B)
pub const fn st_golf_wa_frame_crc8_gf2_u64(frame: u64) -> u64 {
    let s = frame ^ 0x5A;
    let ev = s & 0x00FF_00FF_00FF_00FF;
    let od = (s >> 8) & 0x00FF_00FF_00FF_00FF;
    let t = ev ^ (ev << 1) ^ (ev << 2);
    let th = (t >> 8) & 0x0003_0003_0003_0003;
    let p = (t ^ th ^ (th << 1) ^ (th << 2) ^ od) & 0x00FF_00FF_00FF_00FF;
    let pev = p & 0x0000_00FF_0000_00FF;
    let pod = (p >> 16) & 0x0000_00FF_0000_00FF;
    let u = pev ^ (pev << 2) ^ (pev << 4);
    let uh = (u >> 8) & 0x0000_000F_0000_000F;
    let q = (u ^ uh ^ (uh << 1) ^ (uh << 2) ^ pod) & 0x0000_00FF_0000_00FF;
    let q0 = q & 0xFF;
    let v = (q0 << 1) ^ (q0 << 2) ^ (q0 << 4);
    let vh = (v >> 8) & 0xF;
    let r = (v ^ vh ^ (vh << 1) ^ (vh << 2) ^ ((q >> 32) & 0xFF)) & 0xFF;
    let w = r ^ (r << 1) ^ (r << 2);
    let wh = (w >> 8) & 3;
    (w ^ wh ^ (wh << 1) ^ (wh << 2)) & 0xFF
}
#1082
PEER of 2
borg_swift_midi_harmonic_step
domain: audio | id: f921538ddfda
Aye: aye-a6000-prime @ 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)->u64
64-vec BLAKE3: c4e328dd687e
C64 RAM: 13/4096 (208 B src)
3231453/200000 cyc/op
1077151/200000 ns/op | 200000000/1077151 ops/us
35 B .text (10 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (208 B)
pub fn borg_swift_midi_harmonic_step(note: u64) -> u64 {
    let pitch = (note & 0x7F).wrapping_mul(432);
    let vel = ((note >> 8) & 0x7F).wrapping_mul(528);
    (pitch.wrapping_add(vel) ^ 0x1B0) & 0xFFFF
}
#1191
PEER of 3
st_golf_b158_bitplane_swar_u64
domain: OneCompression | id: 82481a0614b3
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
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: 99/8192 (792 B src)
802421/40000 cyc/op
2177019/400000 ns/op | 400000000/2177019 ops/us
231 B .text (56 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (792 B)
pub const fn st_golf_b158_bitplane_swar_u64(trit_word: u64) -> u64 {
    const M: u64 = 0x1111_1111_1111_1111;
    const GATHER: u64 = 0x0001_0010_0100_1000;
    let pos_nib = ((trit_word >> 3) & ((trit_word >> 2) | ((trit_word >> 1) & trit_word))) & M;
    let nw = !trit_word;
    let neg_nib = ((nw >> 3) & ((nw >> 2) | (nw >> 1))) & M;
    let p2 = (pos_nib | (pos_nib >> 3)) & 0x0303_0303_0303_0303;
    let p4 = (p2 | (p2 >> 6)) & 0x000F_000F_000F_000F;
    let pos_plane = p4.wrapping_mul(GATHER) >> 48;
    let n2 = (neg_nib | (neg_nib >> 3)) & 0x0303_0303_0303_0303;
    let n4 = (n2 | (n2 >> 6)) & 0x000F_000F_000F_000F;
    let neg_plane = n4.wrapping_mul(GATHER) >> 48;
    let active = (pos_nib | neg_nib).count_ones() as u64;
    (active << 32) | (neg_plane << 16) | pos_plane
}
Page 1 of 15 (360 total capsules)