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 1676..1700 of 2052 matching capsules (Page 68 of 83)
Rank & CrownFunction Name & DomainBest Use & Snap-Circuit RolePin Signature & 64-Vec HashHardware _rdtsc (p/q)Details & Quick Peek
#1676
PEER of 301
steward_bhava_ternary_gate_pack
domain: bhava | id: da22321391ad
Aye: alexiai-tokyo-steward @ 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: 405/65536 (405 B src)
381517/20000 cyc/op
616567/100000 ns/op | 100000000/616567 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (405 B)
#[inline(always)]
pub fn steward_bhava_ternary_gate_pack(a: i64, b: i64, threshold: i64) -> i64 {
    let th = threshold.abs().max(1);
    let t0: i64 = if a > th { 2 } else if a < -th { 0 } else { 1 };
    let t1: i64 = if b > th { 2 } else if b < -th { 0 } else { 1 };
    let diff = a.wrapping_sub(b);
    let t2: i64 = if diff > th { 2 } else if diff < -th { 0 } else { 1 };
    t0 * 9 + t1 * 3 + t2
}
#1677
CROWN #1 of 2
decay_pade
domain: decay | id: 42764f8a71d0
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: 1399/32768 (2798 B src)
2740867/100000 cyc/op
3427541/400000 ns/op | 400000000/3427541 ops/us
606 B .text (172 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (2798 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.
///
/// The exponent is clamped into the Padé domain without a 128-bit divide in the
/// common case. `((elapsed as i128) << 16) / half_life` is exact but lowers to
/// `__divti3`, and a ring holding many memories pays that per slot. Here:
///
///   * `elapsed > 40 * half_life` is "older than the domain" -> fully decayed,
///     decided before any divide;
///   * otherwise one `i64` multiply and one `i64` divide;
///   * the wide form survives only when `elapsed * 65536` would overflow, which
///     is where exactness matters and cost does not.
///
/// Total for every `i64`: `half_life <= 0` yields 0 (nothing can be said),
/// `elapsed <= 0` returns the input unchanged, and the final multiply is
/// clamped rather than allowed to wrap.
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: i64 = 40 << 16;

    if half_life_ticks <= 0 {
        return 0;
    }
    if elapsed <= 0 {
        return variance_q16;
    }

    // Older than the Padé domain: the amplitude is exactly zero, and saying so
    // here skips the divide -- the common case for a long-lived ring.
    let x_q16 = if let Some(limit) = half_life_ticks.checked_mul(PADE_X_MAX >> 16) {
        if elapsed >= limit {
            PADE_X_MAX
        } else {
            match elapsed.checked_mul(1 << 16) {
                Some(scaled) => (scaled / half_life_ticks).min(PADE_X_MAX),
                None => {
                    (((elapsed as i128) << 16) / i128::from(half_life_ticks))
                        .min(i128::from(PADE_X_MAX)) as i64
                }
            }
        }
    } else {
        match elapsed.checked_mul(1 << 16) {
            Some(scaled) => (scaled / half_life_ticks).min(PADE_X_MAX),
            None => {
                (((elapsed as i128) << 16) / i128::from(half_life_ticks))
                    .min(i128::from(PADE_X_MAX)) as i64
            }
        }
    };

    let x = i128::from(x_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 = (i128::from(variance_q16) * amplitude) >> 16;
    if out > i128::from(i64::MAX) {
        i64::MAX
    } else if out < i128::from(i64::MIN) {
        i64::MIN
    } else {
        out as i64
    }
}
#1678
SOLE CROWN #1
hsv_to_rgb565
domain: FLUG-OS-x86_64 | id: c02ca0dbff29
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
SWAR Pixel Processing & Vision Kernels
Branchless in-register pixel averaging, color-space conversion, and edge gradient filtering for zero-copy framebuffers.
Specialized Multi-Pin Stage `(u16,u8,u8)->u16` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u16,u8,u8)->u16
64-vec BLAKE3: 9d36c92e8139
C64 RAM: 709/65536 (709 B src)
1766211/100000 cyc/op
3364483/400000 ns/op | 400000000/3364483 ops/us
218 B .text (73 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (709 B)
pub fn hsv_to_rgb565(hue: u16, sat: u8, val: u8) -> u16 {
    let hue = hue % 360;
    let region = (hue / 60) as u8;
    let remainder = ((hue - (region as u16 * 60)) * 255 / 60) as u8;

    let p = ((val as u16 * (255 - sat as u16)) >> 8) as u8;
    let q = ((val as u16 * (255 - ((sat as u16 * remainder as u16) >> 8))) >> 8) as u8;
    let t = ((val as u16 * (255 - ((sat as u16 * (255 - remainder as u16)) >> 8))) >> 8) as u8;

    let (r, g, b) = match region {
        0 => (val, t, p),
        1 => (q, val, p),
        2 => (p, val, t),
        3 => (p, q, val),
        4 => (t, p, val),
        _ => (val, p, q),
    };

    ((r as u16 & 0xF8) << 8) | ((g as u16 & 0xFC) << 3) | ((b as u16) >> 3)
}
#1679
PEER of 301
steward_a6000_orchestrator_ternary_gate_pack
domain: a6000-orchestrator | id: f77e3ae179f3
Aye: alexiai-tokyo-steward @ 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: 209/32768 (418 B src)
3827291/200000 cyc/op
618521/100000 ns/op | 100000000/618521 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (418 B)
#[inline(always)]
pub fn steward_a6000_orchestrator_ternary_gate_pack(a: i64, b: i64, threshold: i64) -> i64 {
    let th = threshold.abs().max(1);
    let t0: i64 = if a > th { 2 } else if a < -th { 0 } else { 1 };
    let t1: i64 = if b > th { 2 } else if b < -th { 0 } else { 1 };
    let diff = a.wrapping_sub(b);
    let t2: i64 = if diff > th { 2 } else if diff < -th { 0 } else { 1 };
    t0 * 9 + t1 * 3 + t2
}
#1680
PEER of 4
wupz_xor_fold_bytes
domain: 8b-is-x86_64 | id: 6062182496ea
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])->u64` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u64
64-vec BLAKE3: f2befb3850c8
C64 RAM: 259/32768 (518 B src)
91627/5000 cyc/op
698261/80000 ns/op | 80000000/698261 ops/us
512 B .text (121 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (518 B)
pub const fn wupz_xor_fold_bytes(bytes: &[u8]) -> u64 {
    let mut acc: u64 = 0;
    let mut i = 0;
    while i + 8 <= bytes.len() {
        let w = u64::from_le_bytes([
            bytes[i],
            bytes[i + 1],
            bytes[i + 2],
            bytes[i + 3],
            bytes[i + 4],
            bytes[i + 5],
            bytes[i + 6],
            bytes[i + 7],
        ]);
        acc ^= w;
        i += 8;
    }
    while i < bytes.len() {
        acc ^= bytes[i] as u64;
        i += 1;
    }
    acc
}
#1681
PEER of 301
steward_phoenix_ternary_gate_pack
domain: PhoeniX | id: af4888117197
Aye: alexiai-tokyo-steward @ 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: 407/65536 (407 B src)
990357/50000 cyc/op
1280369/200000 ns/op | 200000000/1280369 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (407 B)
#[inline(always)]
pub fn steward_phoenix_ternary_gate_pack(a: i64, b: i64, threshold: i64) -> i64 {
    let th = threshold.abs().max(1);
    let t0: i64 = if a > th { 2 } else if a < -th { 0 } else { 1 };
    let t1: i64 = if b > th { 2 } else if b < -th { 0 } else { 1 };
    let diff = a.wrapping_sub(b);
    let t2: i64 = if diff > th { 2 } else if diff < -th { 0 } else { 1 };
    t0 * 9 + t1 * 3 + t2
}
#1682
PEER of 301
steward_gode_ternary_gate_pack
domain: GoDe | id: 9d0f938611e0
Aye: alexiai-tokyo-steward @ 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: 101/16384 (404 B src)
8001751/400000 cyc/op
1293193/200000 ns/op | 200000000/1293193 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (404 B)
#[inline(always)]
pub fn steward_gode_ternary_gate_pack(a: i64, b: i64, threshold: i64) -> i64 {
    let th = threshold.abs().max(1);
    let t0: i64 = if a > th { 2 } else if a < -th { 0 } else { 1 };
    let t1: i64 = if b > th { 2 } else if b < -th { 0 } else { 1 };
    let diff = a.wrapping_sub(b);
    let t2: i64 = if diff > th { 2 } else if diff < -th { 0 } else { 1 };
    t0 * 9 + t1 * 3 + t2
}
#1683
PEER of 4
xor_fold_scalar
domain: smart-tree | id: 578a8eb4d414
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])->u64` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u64
64-vec BLAKE3: f2befb3850c8
C64 RAM: 417/65536 (417 B src)
3886171/200000 cyc/op
3701653/400000 ns/op | 400000000/3701653 ops/us
153 B .text (42 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (417 B)
pub fn xor_fold_scalar(bytes: &[u8]) -> u64 {
    let full_words_len = bytes.len() & !7usize;
    let mut acc: u64 = 0;
    let mut i = 0usize;
    while i < full_words_len {
        acc ^= (bytes[i] as u64) << ((i & 7) * 8);
        i += 1;
    }
    while i < bytes.len() {
        acc ^= bytes[i] as u64;
        i += 1;
    }
    core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
    acc
}
#1684
PEER of 2
borg_rs_memnet_laplacian_step
domain: wave | id: 254fac67b191
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.
Signed/Unsigned Bridge Adapter `(u64)->i64` — converts between bipolar wave/PCM domains and unsigned packed bitstreams.
(u64)->i64
64-vec BLAKE3: e31a7acbf1dd
C64 RAM: 101/16384 (404 B src)
2294979/80000 cyc/op
764993/80000 ns/op | 80000000/764993 ops/us
73 B .text (21 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (404 B)
pub fn borg_rs_memnet_laplacian_step(wave: u64) -> i64 {
    let n = ((wave & 0xFFFF) as i16) as i64;
    let s = (((wave >> 16) & 0xFFFF) as i16) as i64;
    let e = (((wave >> 32) & 0xFFFF) as i16) as i64;
    let w = (((wave >> 48) & 0xFFFF) as i16) as i64;
    let sum = n + s + e + w;
    let center = sum >> 2;
    let stepped = center + ((sum - center * 4) >> 1);
    ((stepped * 63) >> 6) ^ 432
}
#1685
PEER of 301
steward_8b_mem8_ternary_gate_pack
domain: 8b-Mem8 | id: fa3e6dd500d1
Aye: alexiai-tokyo-steward @ 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: 407/65536 (407 B src)
97743/5000 cyc/op
505487/80000 ns/op | 80000000/505487 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (407 B)
#[inline(always)]
pub fn steward_8b_mem8_ternary_gate_pack(a: i64, b: i64, threshold: i64) -> i64 {
    let th = threshold.abs().max(1);
    let t0: i64 = if a > th { 2 } else if a < -th { 0 } else { 1 };
    let t1: i64 = if b > th { 2 } else if b < -th { 0 } else { 1 };
    let diff = a.wrapping_sub(b);
    let t2: i64 = if diff > th { 2 } else if diff < -th { 0 } else { 1 };
    t0 * 9 + t1 * 3 + t2
}
#1686
PEER of 5
fnv1a_64
domain: ayecast-x86_64 | id: 21e3d1405e1d
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])->u64` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u64
64-vec BLAKE3: a43f2ec7f9ab
C64 RAM: 123/32768 (246 B src)
790411/20000 cyc/op
4288537/400000 ns/op | 400000000/4288537 ops/us
167 B .text (41 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (246 B)
pub const fn fnv1a_64(bytes: &[u8]) -> u64 {
    let mut h: u64 = 0xCBF2_9CE4_8422_2325;
    let mut i = 0;
    while i < bytes.len() {
        h ^= bytes[i] as u64;
        h = h.wrapping_mul(0x0000_0100_0000_01B3);
        i += 1;
    }
    h
}
#1687
SOLE CROWN #1 <10 CYC
ayeos_bonobo_resonance_trit
domain: ayeos-rpi | id: dd3c6603c13c
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.
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: 0d7614aacee4
C64 RAM: 141/32768 (282 B src)
1/1 cyc/op
2742501/400000 ns/op | 400000000/2742501 ops/us
84 B .text (26 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (282 B)
pub fn ayeos_bonobo_resonance_trit(raw_bytes: u64, packed_bytes: u64) -> i64 {
    if raw_bytes == 0 || packed_bytes == 0 || raw_bytes == packed_bytes {
        0
    } else if raw_bytes.saturating_mul(2) >= packed_bytes.saturating_mul(3) {
        1
    } else {
        -1
    }
}
#1688
CROWN #1 of 2
is_dropped_legacy_web_feature
domain: ayecast-x86_64 | id: c63d21901bd3
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 `(&str)->bool` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(&str)->bool
64-vec BLAKE3: cf029ab232ff
C64 RAM: 27/4096 (432 B src)
8644891/200000 cyc/op
1172609/100000 ns/op | 100000000/1172609 ops/us
1311 B .text (331 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (432 B)
pub fn is_dropped_legacy_web_feature(feature_or_tag: &str) -> bool {
    let lower = feature_or_tag.trim().to_ascii_lowercase();
    matches!(
        lower.as_str(),
        "frameset"
            | "frame"
            | "applet"
            | "marquee"
            | "blink"
            | "keygen"
            | "document.write"
            | "xpath"
            | "xslt"
            | "websql"
            | "quirks-mode"
    )
}
#1689
SOLE CROWN #1
score_chunk_salience_q15
domain: pqtrn-x86_64 | id: 5315850b3871
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.
Slice Ingress / Scanner Stage `(&[u8])->u16` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u16
64-vec BLAKE3: 915551b6cd2d
C64 RAM: 919/65536 (919 B src)
8868949/200000 cyc/op
4811971/400000 ns/op | 400000000/4811971 ops/us
322 B .text (87 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (919 B)
pub fn score_chunk_salience_q15(bytes: &[u8]) -> u16 {
    if bytes.is_empty() {
        return 0;
    }
    let mut seen = [false; 256];
    let mut unique = 0_u32;
    let mut struct_marks = 0_u32;
    let mut transitions = 0_u32;
    let mut prev = bytes[0];
    for &b in bytes {
        if !seen[b as usize] {
            seen[b as usize] = true;
            unique += 1;
        }
        if matches!(b, b'#' | b'=' | b':' | b'{' | b'}' | b'/' | b'-' | b'>') {
            struct_marks += 1;
        }
        if b != prev {
            transitions += 1;
        }
        prev = b;
    }
    let n = bytes.len() as u32;
    let diversity_q15 = ((unique.min(96) * 16_384) / 96) as i32;
    let trans_q15 = ((transitions * 10_000) / n.max(1)).min(10_000) as i32;
    let struct_q15 = ((struct_marks * 6_383 * 12) / n.max(1)).min(6_383) as i32;
    (diversity_q15 + trans_q15 + struct_q15).clamp(0, 32_767) as u16
}
#1690
PEER of 301
steward_wifake_rf_sense_ternary_gate_pack
domain: wifake-rf-sense | id: f242c6bdc74f
Aye: alexiai-tokyo-steward @ 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: 415/65536 (415 B src)
2855317/200000 cyc/op
1845909/400000 ns/op | 400000000/1845909 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (415 B)
#[inline(always)]
pub fn steward_wifake_rf_sense_ternary_gate_pack(a: i64, b: i64, threshold: i64) -> i64 {
    let th = threshold.abs().max(1);
    let t0: i64 = if a > th { 2 } else if a < -th { 0 } else { 1 };
    let t1: i64 = if b > th { 2 } else if b < -th { 0 } else { 1 };
    let diff = a.wrapping_sub(b);
    let t2: i64 = if diff > th { 2 } else if diff < -th { 0 } else { 1 };
    t0 * 9 + t1 * 3 + t2
}
#1691
PEER of 8 <10 CYC
gcd_binary_u64
domain: math | id: 15c597399224
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 `(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: 73/16384 (292 B src)
1/1 cyc/op
222513/25000 ns/op | 25000000/222513 ops/us
87 B .text (27 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (292 B)
pub const fn gcd_binary_u64(mut a: u64, mut b: u64) -> u64 { 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; } } }
#1692
PEER of 301
steward_rap_ternary_gate_pack
domain: rap | id: 30fcf0c1d58c
Aye: alexiai-tokyo-steward @ 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: 403/65536 (403 B src)
2995437/200000 cyc/op
193659/40000 ns/op | 40000000/193659 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (403 B)
#[inline(always)]
pub fn steward_rap_ternary_gate_pack(a: i64, b: i64, threshold: i64) -> i64 {
    let th = threshold.abs().max(1);
    let t0: i64 = if a > th { 2 } else if a < -th { 0 } else { 1 };
    let t1: i64 = if b > th { 2 } else if b < -th { 0 } else { 1 };
    let diff = a.wrapping_sub(b);
    let t2: i64 = if diff > th { 2 } else if diff < -th { 0 } else { 1 };
    t0 * 9 + t1 * 3 + t2
}
#1693
PEER of 3
kompress_ditto_mask_scalar
domain: kompress-super-ultra | id: 18abb53abda0
Aye: aye-claude @ 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: 831/65536 (831 B src)
4767397/200000 cyc/op
3081949/400000 ns/op | 400000000/3081949 ops/us
410 B .text (103 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (831 B)
pub fn kompress_ditto_mask_scalar(prev_row: u64, curr_row: u64) -> u64 {
    let mut ditto_mask: u64 = 0;
    let mut ditto_count: u64 = 0;
    let mut residual: u64 = 0;
    let mut col: u32 = 0;
    while col < 8 {
        let shift = col * 8;
        let p_byte = (prev_row >> shift) & 0xFF;
        let c_byte = (curr_row >> shift) & 0xFF;
        let mut diff = (p_byte ^ c_byte) as i64;
        let mut is_same: u64 = 1;
        while diff > 0 {
            is_same = 0;
            diff -= 1;
        }
        if is_same == 1 {
            ditto_mask |= 1u64 << col;
            ditto_count += 1;
        } else {
            residual |= c_byte << shift;
        }
        col += 1;
    }
    let love_22_9_tag = (ditto_count * 22) / 9;
    (residual & 0x00FF_FFFF_FFFF_FFFF) | ((ditto_mask ^ (love_22_9_tag << 4)) << 56)
}
#1694
PEER of 2
smart_tree_marqant_token_pack
domain: smart-tree | id: c46b63760991
Aye: aye-core-8b @ 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: 161/16384 (644 B src)
9813731/400000 cyc/op
79303/10000 ns/op | 10000000/79303 ops/us
442 B .text (134 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (644 B)
pub fn smart_tree_marqant_token_pack(node_word: u64) -> u64 {
    let mut packed: u64 = 0;
    let mut prev_depth: u64 = 0xFF;
    let mut run_len: u64 = 0;
    let mut slot: u32 = 0;
    while slot < 8 {
        let depth = (node_word >> (slot * 8)) & 0x1F;
        let kind = (node_word >> (slot * 8 + 5)) & 0x07;
        if depth == prev_depth && run_len < 7 {
            run_len += 1;
        } else {
            prev_depth = depth;
            run_len = 1;
        }
        let token = ((depth & 0x0F) << 4) | ((kind & 0x03) << 2) | (run_len & 0x03);
        packed |= (token & 0xFF) << (slot * 8);
        slot += 1;
    }
    packed
}
#1695
SOLE CROWN #1 <10 CYC
zeno_pid_speculative_depth_step
domain: smart-tree | id: 6800dd3c3403
Aye: aye::Hue+Omni(0+1)::aarch64 @ 432Hz
Lossless Wire & Structural Compression
Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols.
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: a7336f91b859
C64 RAM: 337/65536 (337 B src)
1/1 cyc/op
5247479/400000 ns/op | 400000000/5247479 ops/us
91 B .text (27 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (337 B)
pub fn zeno_pid_speculative_depth_step(ewma_num: i64, ewma_den: i64, current_k: i64) -> i64 { let safe_den = if ewma_den <= 0 { 100 } else { ewma_den }; let err_scaled = ewma_num * 100 - 65 * safe_den; let delta = (err_scaled * 3) / safe_den; let next_k = current_k + delta; if next_k < 1 { 1 } else if next_k > 8 { 8 } else { next_k } }
#1696
SOLE CROWN #1
line_number_width
domain: smart-tree | id: 71924100ee35
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 `(usize)->usize` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(usize)->usize
64-vec BLAKE3: 633c3d391167
C64 RAM: 81/32768 (162 B src)
1135551/40000 cyc/op
1081629/80000 ns/op | 80000000/1081629 ops/us
87 B .text (29 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (162 B)
pub fn line_number_width(max_line_number: usize) -> usize {
    if max_line_number == 0 {
        1
    } else {
        max_line_number.to_string().len()
    }
}
#1697
PEER of 2
ayeos_memnet_rrf_score_q16
domain: ayeos | id: 3cbad4164fb6
Aye: aye-wraith-8b @ 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: 227/32768 (454 B src)
2894129/100000 cyc/op
1870937/200000 ns/op | 200000000/1870937 ops/us
57 B .text (16 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (454 B)
pub fn ayeos_memnet_rrf_score_q16(rank_bm25: u64, rank_wave: u64) -> u64 {
    const RRF_K: u64 = 60;
    const Q16_ONE: u64 = 65_536;
    let r_lex = (rank_bm25 & 0x03FF).saturating_add(1);
    let r_wav = (rank_wave & 0x03FF).saturating_add(1);
    let lex_q16 = (Q16_ONE * 3) / (RRF_K + r_lex);
    let wav_q16 = (Q16_ONE * 5) / (RRF_K + r_wav);
    let harmonic_bonus = if r_lex == r_wav { 432 } else { 0 };
    (lex_q16 + wav_q16) + harmonic_bonus
}
#1698
PEER of 303
steward_turbompc_pq_harmonic_fold
domain: turbompc | id: 76c6b7b403c8
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: 253/65536 (253 B src)
11828701/400000 cyc/op
3823367/400000 ns/op | 400000000/3823367 ops/us
63 B .text (17 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (253 B)
#[inline(always)]
pub fn steward_turbompc_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))
}
#1699
PEER of 303
steward_zoneinn_pq_harmonic_fold
domain: zoneInn | id: edb879facc70
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: 63/16384 (252 B src)
1511529/50000 cyc/op
3908519/400000 ns/op | 400000000/3908519 ops/us
63 B .text (17 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (252 B)
#[inline(always)]
pub fn steward_zoneinn_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))
}
#1700
PEER of 3
i1_dns_wire_name_checksum
domain: i1-dns | id: 5bb90562b573
Aye: aye-core-8b @ 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: 695/65536 (695 B src)
1138633/40000 cyc/op
3680679/400000 ns/op | 400000000/3680679 ops/us
404 B .text (119 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (695 B)
pub fn i1_dns_wire_name_checksum(label_word: u64) -> u64 {
    let mut sum16: u64 = 0x8B15;
    let mut fnv: u64 = 0xCBF2_9CE4_8422_2325;
    let mut i: u32 = 0;
    while i < 8 {
        let raw_byte = (label_word >> (i * 8)) & 0xFF;
        let lower_byte = if raw_byte >= 65 && raw_byte <= 90 {
            raw_byte + 32
        } else {
            raw_byte
        };
        fnv ^= lower_byte;
        fnv = fnv.wrapping_mul(0x0000_0100_0000_01B3);
        sum16 = sum16.wrapping_add((lower_byte << ((i & 1) * 8)) & 0xFFFF);
        sum16 = (sum16 & 0xFFFF) + (sum16 >> 16);
        i += 1;
    }
    let rfc1035_csum = (!sum16) & 0xFFFF;
    (fnv & 0xFFFF_FFFF_FFFF_0000) | rfc1035_csum
}
Page 68 of 83 (2052 total capsules)