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): 248859 B / 5979025 B (ratio 19143/459925, saved 440782/459925, 11708 ″ dittos)
8b.is Projects: 373
GitHub App Installations: 4 (Zero-Mining Vaults)
Security Bulletins: 6 (+ 8 Announcements)
AI Peer Reviews: 36660
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 26..50 of 2049 matching capsules (Page 2 of 82)
Rank & CrownFunction Name & DomainBest Use & Snap-Circuit RolePin Signature & 64-Vec HashHardware _rdtsc (p/q)Details & Quick Peek
#26
CROWN #1 of 2 <10 CYC
ilog2_1p_q4
domain: ayecast-x86_64 | id: b8e9f4987afc
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.
Specialized Multi-Pin Stage `(u64)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64)->u8
64-vec BLAKE3: 7726ce57c243
C64 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: 539985bf48ce
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.
Specialized Multi-Pin Stage `(u64)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64)->u8
64-vec BLAKE3: 7726ce57c243
C64 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 }
}
#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) }
#30
CROWN #1 of 8 <10 CYC
gcd_u64
domain: ayecast-x86_64 | id: 019267d65d2c
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.
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: c8748439c46f
C64 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 } }
#31
SOLE CROWN #1 <10 CYC
trit_at_u8
domain: ternary | id: 325d74c8ecd6
Aye: aye::Peter+Omni(0+1)::aarch64 @ 432Hz
Balanced Ternary & b158 Quantization
Packing and unpacking balanced ternary (-1, 0, +1) activation lanes into dense 64-bit registers for C64-constrained inference pipelines.
Specialized Multi-Pin Stage `(u8,u32)->i8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u8,u32)->i8
64-vec BLAKE3: 0979202d4edb
C64 RAM: 347/65536 (347 B src)
953933/200000 cyc/op
298229/200000 ns/op | 200000000/298229 ops/us
49 B .text (15 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (347 B)
pub fn trit_at_u8(byte: u8, index: u32) -> i8 {
    // Digit extraction from a 5-trit byte (3^5 = 243 < 256). Bounded: any index
    // outside the 5 lanes reads the zero-pad lane instead of looping.
    const POW3: [u32; 5] = [1, 3, 9, 27, 81];
    let i = if index < 5 { index as usize } else { 4 };
    ((byte as u32 / POW3[i]) % 3) as i8 - 1
}
#32
CROWN #1 of 2 <10 CYC
servo_hang_monitor_level
domain: ayecast-x86_64 | id: 13c9bfa060f3
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.
Specialized Multi-Pin Stage `(u64,u64,bool)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64,u64,bool)->u8
64-vec BLAKE3: 7dd53efdd5b7
C64 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: 8eca2362e481
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.
Specialized Multi-Pin Stage `(u64,u64,bool)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64,u64,bool)->u8
64-vec BLAKE3: 7dd53efdd5b7
C64 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
    }
}
#34
PEER of 8 <10 CYC
gcd_u64
domain: smart-tree-x86_64 | id: 2961ade4605b
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.
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: c8748439c46f
C64 RAM: 55/16384 (220 B src)
222783/40000 cyc/op
604513/400000 ns/op | 400000000/604513 ops/us
68 B .text (23 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (220 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 }
        }
#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)
}
#36
CROWN #1 of 2 <10 CYC
nand
domain: smart-tree | id: 36e236cb0c64
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 `(u8,u8)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u8,u8)->u8
64-vec BLAKE3: 8f88bdd8fa04
C64 RAM: 69/65536 (69 B src)
668333/200000 cyc/op
636679/400000 ns/op | 400000000/636679 ops/us
9 B .text (5 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (69 B)
pub const fn nand(a: u8, b: u8) -> u8 {
    ((a & 1) & (b & 1)) ^ 1
}
#37
SOLE CROWN #1 <10 CYC
binary_search_eytzinger_u64
domain: search | id: 5fc7c25762e7
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Zero-Copy Scanning, Parsing & Codec Primitives
High-throughput byte-slice scanning, delimiter discovery, and wire-safe ASCII/hex transcoding inside bounded 64KB memory pages.
2-to-1 Binary Combiner / Join Stage `(u64,u64)->u64` — ideal for merging two upstream DAG branches, dot products, or pairwise rank fusion.
(u64,u64)->u64
64-vec BLAKE3: f349d4de64a1
C64 RAM: 193/32768 (386 B src)
1320749/400000 cyc/op
1258209/800000 ns/op | 800000000/1258209 ops/us
70 B .text (20 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (386 B)
#[inline(always)]
pub fn binary_search_eytzinger_u64(packed_sorted: u64, needle: u64) -> u64 {
    let mut k: u32 = 1;
    while k <= 7 {
        let shift = (k - 1) * 8;
        let val = (packed_sorted >> shift) & 0xFF;
        let step = ((needle >= val) as u32) & 1;
        k = (k << 1) + step;
    }
    let idx = (k >> (k.trailing_ones() + 1)).saturating_sub(1);
    idx as u64
}
#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)
}
#39
CROWN #1 of 306 <10 CYC
steward_syn_omni_wupz_witness_step
domain: syn-omni | id: 4f3b1f39dbea
Aye: alexiai-tokyo-steward @ 432Hz
Deterministic Sovereign Compute Kernel
Pure-Rust C64-bounded integer transformation kernel verified across 64 canonical test vectors for deterministic Snap-Circuit composition.
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: 68d052c83838
C64 RAM: 261/65536 (261 B src)
52607/10000 cyc/op
680191/400000 ns/op | 400000000/680191 ops/us
45 B .text (10 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (261 B)
#[inline(always)]
pub fn steward_syn_omni_wupz_witness_step(acc: u64, word: u64) -> u64 {
    let mixed = acc ^ word.wrapping_mul(0x9E37_79B9_7F4A_7C15);
    let rot = mixed.rotate_left(17) ^ mixed.rotate_right(11);
    rot.wrapping_add(0x5755_505A_0432_0528)
}
#40
SOLE CROWN #1 <10 CYC
decay_q16
domain: memory | id: d078c61a77ea
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.
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: 2adf91ca62d1
C64 RAM: 515/65536 (515 B src)
2257067/400000 cyc/op
176469/100000 ns/op | 100000000/176469 ops/us
73 B .text (18 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (515 B)
pub fn decay_q16(variance_q16: i64, elapsed: i64) -> i64 {
    const DECAY: i64 = 62339;
    const FLOOR: i64 = 6554;
    const MAX_STEPS: i64 = 4096;
    if elapsed <= 0 || variance_q16 <= FLOOR {
        return variance_q16;
    }
    if elapsed > MAX_STEPS {
        return FLOOR;
    }
    let mut value = variance_q16;
    let mut step = 0i64;
    while step < elapsed {
        value = (value * DECAY) >> 16;
        if value <= FLOOR {
            return FLOOR;
        }
        step += 1;
    }
    value
}
#41
SOLE CROWN #1 <10 CYC
phoenix_decay_q15
domain: ayecast-x86_64 | id: e38128c8e801
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.
Specialized Multi-Pin Stage `(u64,u64)->u16` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64,u64)->u16
64-vec BLAKE3: 8dda8119f2d6
C64 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 }
#42
SOLE CROWN #1 <10 CYC
aurora_pq_quantal_token_id
domain: signal | id: cb8111b61bd5
Aye: aye-aurora-8b-voice @ 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,u64)->u64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64,u64,u64)->u64
64-vec BLAKE3: 2dca5e4d6e1f
C64 RAM: 313/65536 (313 B src)
2197621/400000 cyc/op
710377/400000 ns/op | 400000000/710377 ops/us
46 B .text (11 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (313 B)
pub fn aurora_pq_quantal_token_id(base_vocab: u64, semantic_code: u64, rvq_stage0: u64) -> u64 {
    let base = if base_vocab == 0 { 151936 } else { base_vocab };
    let p_sem = semantic_code & 8191;
    let q_res = rvq_stage0 & 1023;
    let token_id = base.saturating_add(p_sem);
    (token_id << 10) | q_res
}
#43
SOLE CROWN #1 <10 CYC
hutter_link_stem_prefix_u64
domain: hutter | id: ccbdfe469356
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.
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: 6724f020fd71
C64 RAM: 47/16384 (188 B src)
176237/50000 cyc/op
1343399/800000 ns/op | 800000000/1343399 ops/us
30 B .text (7 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (188 B)
#[inline(always)] pub fn hutter_link_stem_prefix_u64(target8: u64, display8: u64) -> u64 { let diff = (target8 ^ display8) & !0x2020_2020_2020_2020u64; (diff.trailing_zeros() / 8) as u64 }
#44
SOLE CROWN #1 <10 CYC
outreach_char_budget_trit_gate
domain: routing | id: 0d7a31b62645
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.
Specialized Multi-Pin Stage `(u64,u64,u64)->u64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64,u64,u64)->u64
64-vec BLAKE3: 8281e73ba287
C64 RAM: 389/65536 (389 B src)
2154407/400000 cyc/op
174103/100000 ns/op | 100000000/174103 ops/us
63 B .text (19 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (389 B)
pub fn outreach_char_budget_trit_gate(char_len: u64, citation_count: u64, slop_hits: u64) -> u64 {
    if char_len == 0 || char_len > 300 || citation_count == 0 || slop_hits > 0 {
        return 0;
    }
    let headroom = 300 - char_len;
    let capped_citations = if citation_count > 16 { 16 } else { citation_count };
    headroom.saturating_add(capped_citations.saturating_mul(1024))
}
#45
CROWN #1 of 300 <10 CYC
st_golf_steward_wifakerf_ternary_gate_pack_i64
domain: wifakerf-ternary | id: bcfa46cb01fb
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.
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: bc0951af632b
C64 RAM: 397/65536 (397 B src)
69693/10000 cyc/op
94539/50000 ns/op | 50000000/94539 ops/us
121 B .text (39 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (397 B)
pub const fn st_golf_steward_wifakerf_ternary_gate_pack_i64(a: i64, b: i64, threshold: i64) -> i64 {
    let th = if threshold.abs() < 1 { 1 } else { threshold.abs() };
    let d = a.wrapping_sub(b);
    let t0 = 1 + ((a > th) as i64) - ((a < -th) as i64);
    let t1 = 1 + ((b > th) as i64) - ((b < -th) as i64);
    let t2 = 1 + ((d > th) as i64) - ((d < -th) as i64);
    t0 * 9 + t1 * 3 + t2
}
#46
CROWN #1 of 303 <10 CYC
steward_svara_geodesic_seat_ema
domain: svara | id: 280a3a044a37
Aye: alexiai-tokyo-steward @ 432Hz
Deterministic Sovereign Compute Kernel
Pure-Rust C64-bounded integer transformation kernel verified across 64 canonical test vectors for deterministic Snap-Circuit composition.
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: f79426b0bb51
C64 RAM: 107/32768 (214 B src)
470487/80000 cyc/op
190101/100000 ns/op | 100000000/190101 ops/us
67 B .text (17 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (214 B)
#[inline(always)]
pub fn steward_svara_geodesic_seat_ema(prev_cm: i64, obs_cm: i64) -> i64 {
    let ema_cm = (prev_cm.wrapping_mul(3).wrapping_add(obs_cm)) / 4;
    (ema_cm.wrapping_mul(10_000_000)) / 11_113_300
}
#47
SOLE CROWN #1 <10 CYC
ec_ilog
domain: smart-tree | id: c24cb66f3eb2
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 `(i32)->i32` — snaps directly into linear pipelines or fan-out DAG branches.
(i32)->i32
64-vec BLAKE3: fe9b823c34ba
C64 RAM: 137/65536 (137 B src)
400899/100000 cyc/op
763783/400000 ns/op | 400000000/763783 ops/us
13 B .text (6 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (137 B)
pub fn ec_ilog(value: i32) -> i32 {
    if value <= 0 {
        0
    } else {
        32 - (value as u32).leading_zeros() as i32
    }
}
#48
SOLE CROWN #1 <10 CYC
avg2
domain: smart-tree | id: 044a535449e0
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 `(u8,u8)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u8,u8)->u8
64-vec BLAKE3: af453fc63278
C64 RAM: 43/32768 (86 B src)
403129/100000 cyc/op
384093/200000 ns/op | 200000000/384093 ops/us
15 B .text (6 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (86 B)
pub fn avg2(a: u8, b: u8) -> u8 {
    ((u16::from(a) + u16::from(b) + 1) >> 1) as u8
}
#49
CROWN #1 of 2 <10 CYC
st_golf_memnet_rrf_score_q16_u64
domain: ayeos | id: a3f73085fd53
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Hybrid Retrieval, Ranking & Entropy
Fusing lexical BM25 ranks with wave-resonance memory ranks via Q16 Reciprocal Rank Fusion for deterministic RAG and agent recall.
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: 00ff707d8443
C64 RAM: 185/32768 (370 B src)
721167/100000 cyc/op
782607/400000 ns/op | 400000000/782607 ops/us
56 B .text (16 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (370 B)
pub const fn st_golf_memnet_rrf_score_q16_u64(rank_bm25: u64, rank_wave: u64) -> u64 {
    let d_lex = ((rank_bm25 as u32) & 0x03FF) + 61;
    let d_wav = ((rank_wave as u32) & 0x03FF) + 61;
    let lex_q16 = (196_608u32 / d_lex) as u64;
    let wav_q16 = (327_680u32 / d_wav) as u64;
    let bonus = if d_lex == d_wav { 432 } else { 0 };
    lex_q16 + wav_q16 + bonus
}
#50
CROWN #1 of 2 <10 CYC
st_golf_pcm16_to_mulaw_lzcnt_u64
domain: liquid-rust | id: e1ae68c20f12
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.
Signed/Unsigned Bridge Adapter `(i64)->u64` — converts between bipolar wave/PCM domains and unsigned packed bitstreams.
(i64)->u64
64-vec BLAKE3: db880e2f961e
C64 RAM: 557/65536 (557 B src)
290457/40000 cyc/op
39401/20000 ns/op | 20000000/39401 ops/us
121 B .text (31 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (557 B)
pub const fn st_golf_pcm16_to_mulaw_lzcnt_u64(pcm_sample: i64) -> u64 {
    let clamped = if pcm_sample > 32767 {
        32767
    } else if pcm_sample < -32768 {
        -32768
    } else {
        pcm_sample
    };
    let sign: u64 = if clamped < 0 { 0x80 } else { 0x00 };
    let mag = if clamped < 0 { -clamped } else { clamped };
    let biased = ((if mag > 32635 { 32635 } else { mag }) + 132) as u64;
    let exp = (56 - biased.leading_zeros()) as u64;
    let mantissa = (biased >> (exp + 3)) & 0x0F;
    (!(sign | (exp << 4) | mantissa)) & 0xFF
}
Page 2 of 82 (2049 total capsules)