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 51..75 of 2049 matching capsules (Page 3 of 82)
Rank & CrownFunction Name & DomainBest Use & Snap-Circuit RolePin Signature & 64-Vec HashHardware _rdtsc (p/q)Details & Quick Peek
#51
CROWN #1 of 2 <10 CYC
st_golf_aurora_mopd2_distill_loss_q15_u64
domain: aurora-mopd2 | id: 78104ea09e7d
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,u64)->u64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64,u64,u64)->u64
64-vec BLAKE3: c98418af6c87
C64 RAM: 43/8192 (344 B src)
291299/40000 cyc/op
790293/400000 ns/op | 400000000/790293 ops/us
125 B .text (33 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (344 B)
pub const fn st_golf_aurora_mopd2_distill_loss_q15_u64(student_q15: u64, mimo_teacher_q15: u64, audio8_teacher_q15: u64) -> u64 {
    let dm = student_q15.abs_diff(mimo_teacher_q15);
    let da = student_q15.abs_diff(audio8_teacher_q15);
    let w = (dm.saturating_mul(60) + da.saturating_mul(40)) / 100;
    if w > 32767 { 32767 } else { w }
}
#52
SOLE CROWN #1 <10 CYC
clamp_trit
domain: smart-tree | id: 65b9382b58fb
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 `(i8)->i8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i8)->i8
64-vec BLAKE3: 7d69a0c8ad71
C64 RAM: 127/65536 (127 B src)
83471/20000 cyc/op
15903/8000 ns/op | 8000000/15903 ops/us
12 B .text (5 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (127 B)
pub const fn clamp_trit(v: i8) -> i8 {
    if v > 0 {
        1
    } else if v < 0 {
        -1
    } else {
        0
    }
}
#53
SOLE CROWN #1 <10 CYC
rds_data_from_word
domain: smart-tree | id: d52e987d0145
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)->u16` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u32)->u16
64-vec BLAKE3: d1f153685f1a
C64 RAM: 43/32768 (86 B src)
40197/10000 cyc/op
765833/400000 ns/op | 400000000/765833 ops/us
6 B .text (3 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (86 B)
pub fn rds_data_from_word(word26: u32) -> u16 {
    ((word26 >> 10) & 0xFFFF) as u16
}
#54
SOLE CROWN #1 <10 CYC
plan_rows_for
domain: smart-tree | id: 56f445b8f237
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,u16)->u16` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(usize,u16)->u16
64-vec BLAKE3: 5264d5b0a97e
C64 RAM: 145/65536 (145 B src)
81583/20000 cyc/op
777181/400000 ns/op | 400000000/777181 ops/us
17 B .text (8 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (145 B)
pub fn plan_rows_for(plan_len: usize, cap: u16) -> u16 {
    if plan_len == 0 {
        0
    } else {
        (plan_len as u16).min(cap)
    }
}
#55
SOLE CROWN #1 <10 CYC
rssi_from_raw
domain: smart-tree | id: 337de5b014f5
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)->i16` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u32)->i16
64-vec BLAKE3: b205fd5ad400
C64 RAM: 127/65536 (127 B src)
160353/40000 cyc/op
381921/200000 ns/op | 200000000/381921 ops/us
21 B .text (7 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (127 B)
pub fn rssi_from_raw(raw: u32) -> i16 {
    if raw == 99 || raw == 0 {
        return -120;
    }
    -113 + (raw as i16 * 2)
}
#56
PEER of 2 <10 CYC
kleene_nand
domain: smart-tree | id: 6af09389e8e9
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 `(i8,i8)->i8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i8,i8)->i8
64-vec BLAKE3: fd5753da6279
C64 RAM: 3/2048 (96 B src)
403171/100000 cyc/op
768283/400000 ns/op | 400000000/768283 ops/us
11 B .text (5 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (96 B)
pub fn kleene_nand(a: i8, b: i8) -> i8 {
    let m = a.min(b);
    if m == 0 { 0 } else { -m }
}
#57
SOLE CROWN #1 <10 CYC
outreach_cadence_delay_hours
domain: routing | id: 443fb2c94474
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.
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: 4085c4d96154
C64 RAM: 401/65536 (401 B src)
2450767/400000 cyc/op
396087/200000 ns/op | 200000000/396087 ops/us
46 B .text (14 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (401 B)
pub fn outreach_cadence_delay_hours(touch_index: u64, track_kind: u64) -> u64 {
    let base_hours = if touch_index == 0 {
        0
    } else if touch_index == 1 {
        24
    } else if touch_index == 2 {
        72
    } else {
        168
    };
    if track_kind == 0 {
        base_hours / 2
    } else if track_kind == 2 {
        (base_hours * 3) / 4
    } else {
        base_hours
    }
}
#58
CROWN #1 of 3 <10 CYC
st_golf_kompress_ditto_mask_swar_u64
domain: kompress-super-ultra | id: 0de0a3583ee6
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
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: 481/65536 (481 B src)
174931/25000 cyc/op
759369/400000 ns/op | 400000000/759369 ops/us
143 B .text (30 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (481 B)
pub const fn st_golf_kompress_ditto_mask_swar_u64(prev_row: u64, curr_row: u64) -> u64 {
    let d = prev_row ^ curr_row;
    let m7f = 0x7F7F_7F7F_7F7F_7F7F;
    let b = (!((((d & m7f) + m7f) | d) | m7f)) >> 7;
    let ditto_mask = b.wrapping_mul(0x0102_0408_1020_4080) >> 56;
    let ditto_count = b.count_ones() as u64;
    let residual = curr_row & !(b * 0xFF) & 0x00FF_FFFF_FFFF_FFFF;
    let tag = (ditto_count * 1254) >> 9;
    residual | ((ditto_mask ^ (tag << 4)) << 56)
}
#59
CROWN #1 of 2 <10 CYC
st_golf_aurora_grpo_advantage_q15_u64
domain: aurora-grpo | id: d5676684960a
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,u64)->u64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64,u64,u64)->u64
64-vec BLAKE3: def87c32b8b1
C64 RAM: 27/4096 (432 B src)
383779/50000 cyc/op
832947/400000 ns/op | 400000000/832947 ops/us
134 B .text (41 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (432 B)
pub const fn st_golf_aurora_grpo_advantage_q15_u64(reward_q15: u64, mean_q15: u64, std_q15: u64) -> u64 {
    let denom = if std_q15 == 0 { 1 } else { std_q15 };
    let diff = reward_q15.abs_diff(mean_q15);
    let scaled = diff.saturating_mul(4096) / denom;
    if reward_q15 >= mean_q15 {
        32768 + if scaled > 32767 { 32767 } else { scaled }
    } else {
        32768 - if scaled > 32768 { 32768 } else { scaled }
    }
}
#60
SOLE CROWN #1 <10 CYC
voice_waveform_envelope_bin
domain: signal | id: 43bc0f308e21
Aye: aye-aurora-8b-voice @ 432Hz
Fixed-Point Audio, Speech & DSP
Integer-only digital signal filtering, harmonic resonator stepping, and prosody envelope generation with zero IEEE-754 drift.
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: a041790531e6
C64 RAM: 63/16384 (252 B src)
81963/12500 cyc/op
423889/200000 ns/op | 200000000/423889 ops/us
66 B .text (18 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (252 B)
pub fn voice_waveform_envelope_bin(sample_energy: u64, bin_index: u64) -> u64 {
    let idx = bin_index % 64;
    let base_amp = 40 + (sample_energy % 175);
    if idx < 4 || idx >= 60 {
        24 + (base_amp / 3)
    } else {
        base_amp
    }
}
#61
SOLE CROWN #1 <10 CYC
tokens_for_bytes
domain: smart-tree | id: a453ae184639
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: c9268f44f097
C64 RAM: 1/1024 (64 B src)
801739/200000 cyc/op
763737/400000 ns/op | 400000000/763737 ops/us
8 B .text (3 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (64 B)
pub fn tokens_for_bytes(bytes: usize) -> usize {
    bytes / 4
}
#62
SOLE CROWN #1 <10 CYC
power_q30_to_deci_dbfs
domain: smart-tree | id: d3652761ffea
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)->i32` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64)->i32
64-vec BLAKE3: a7f5f440f3ba
C64 RAM: 387/32768 (774 B src)
801813/200000 cyc/op
152763/80000 ns/op | 80000000/152763 ops/us
123 B .text (35 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (774 B)
pub const fn power_q30_to_deci_dbfs(power_q30: u64) -> i32 {
    if power_q30 == 0 {
        return -800;
    }
    const FULL_SCALE_Q30: u64 = 1u64 << 30;
    if power_q30 >= FULL_SCALE_Q30 {
        return 0;
    }
    let lz = power_q30.leading_zeros();
    let bit_pos = 63u32.saturating_sub(lz);
    let shift = if bit_pos >= 3 { bit_pos - 3 } else { 0 };
    let mant_idx = ((power_q30 >> shift) & 0x7) as usize;
    const MANT_CENTI_DB: [i32; 8] = [0, 51, 97, 138, 176, 211, 243, 273];
    let steps_below_30 = (30i32 - bit_pos as i32) * 1000;
    let centi_db = -((steps_below_30 * 301) / 1000) + MANT_CENTI_DB[mant_idx];
    let deci_db = centi_db / 10;
    if deci_db < -800 {
        -800
    } else if deci_db > 0 {
        0
    } else {
        deci_db
    }
}
#63
CROWN #1 of 302 <10 CYC
st_golf_steward_mlx_quant_mcp_pq_harmonic_fold_i64
domain: mlx-quant | id: 6210dd4cee0e
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.
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: 277/65536 (277 B src)
801227/100000 cyc/op
869487/400000 ns/op | 400000000/869487 ops/us
102 B .text (28 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (277 B)
pub const fn st_golf_steward_mlx_quant_mcp_pq_harmonic_fold_i64(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(if den < 1 { 1 } else { den })
}
#64
SOLE CROWN #1 <10 CYC
clamp_max_tokens
domain: smart-tree | id: 337da90c1eee
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)->i32` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u32)->i32
64-vec BLAKE3: d28b8de47a8d
C64 RAM: 47/32768 (94 B src)
32401/8000 cyc/op
771809/400000 ns/op | 400000000/771809 ops/us
15 B .text (4 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (94 B)
pub fn clamp_max_tokens(max_tokens: u32) -> i32 {
    max_tokens.min(i32::MAX as u32) as i32
}
#65
SOLE CROWN #1 <10 CYC
rssi_to_trit
domain: databomb-0-x86_64 | id: 0b8a4101d216
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)->i8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i64)->i8
64-vec BLAKE3: 4b435eaea35b
C64 RAM: 151/65536 (151 B src)
100223/25000 cyc/op
763781/400000 ns/op | 400000000/763781 ops/us
21 B .text (7 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (151 B)
pub fn rssi_to_trit(rssi_dbm: i64) -> i8 {
    if rssi_dbm >= -68 {
        1
    } else if rssi_dbm >= -80 {
        0
    } else {
        -1
    }
}
#66
SOLE CROWN #1 <10 CYC
hamming_distance
domain: smart-tree | id: 34750981dc46
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,u64)->u32` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64,u64)->u32
64-vec BLAKE3: 8fda92bf1449
C64 RAM: 75/65536 (75 B src)
960779/200000 cyc/op
11441/5000 ns/op | 5000000/11441 ops/us
93 B .text (21 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (75 B)
pub fn hamming_distance(a: u64, b: u64) -> u32 {
    (a ^ b).count_ones()
}
#67
SOLE CROWN #1 <10 CYC
pack5_trits_u8
domain: zerocpu | id: 13ddc68f8edc
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 `(i8,i8,i8,i8,i8)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i8,i8,i8,i8,i8)->u8
64-vec BLAKE3: 0ea07187a730
C64 RAM: 325/65536 (325 B src)
2887733/400000 cyc/op
902541/400000 ns/op | 400000000/902541 ops/us
69 B .text (17 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (325 B)
pub fn pack5_trits_u8(t0: i8, t1: i8, t2: i8, t3: i8, t4: i8) -> u8 {
    let mut byte: u16 = 0;
    byte += ((t0 as i16 + 1) as u16) * 1;
    byte += ((t1 as i16 + 1) as u16) * 3;
    byte += ((t2 as i16 + 1) as u16) * 9;
    byte += ((t3 as i16 + 1) as u16) * 27;
    byte += ((t4 as i16 + 1) as u16) * 81;
    byte as u8
}
#68
SOLE CROWN #1 <10 CYC
log2_q5_u64
domain: smart-tree | id: 2da3790ba6a3
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)->i32` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64)->i32
64-vec BLAKE3: db9aabfdb4de
C64 RAM: 295/65536 (295 B src)
952133/200000 cyc/op
181393/80000 ns/op | 80000000/181393 ops/us
51 B .text (17 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (295 B)
pub fn log2_q5_u64(n: u64) -> i32 {
    let lz = n.leading_zeros() as i32;
    let int_bits = 63 - lz;
    let shift = 64 - lz - 1 - 5;
    let frac: i32 = if shift >= 0 {
        ((n >> shift) & 0x1F) as i32
    } else {
        ((n << (-shift)) & 0x1F) as i32
    };
    int_bits * 32 + frac
}
#69
SOLE CROWN #1 <10 CYC
encode_nec_ir
domain: flugos-x86_64 | id: ebc7d9fbdf0f
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 `(u8,u8)->u32` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u8,u8)->u32
64-vec BLAKE3: 10248af3aa4c
C64 RAM: 193/65536 (193 B src)
519409/100000 cyc/op
15463/6250 ns/op | 6250000/15463 ops/us
38 B .text (13 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (193 B)
pub const fn encode_nec_ir(addr: u8, cmd: u8) -> u32 {
    let n_addr = !addr;
    let n_cmd = !cmd;
    (addr as u32) | ((n_addr as u32) << 8) | ((cmd as u32) << 16) | ((n_cmd as u32) << 24)
}
#70
SOLE CROWN #1 <10 CYC
aurora_fir_5tap_decimate_q15
domain: signal | id: 900b91244e71
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.
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: 05ed184dc4e4
C64 RAM: 191/65536 (191 B src)
604903/80000 cyc/op
977633/400000 ns/op | 400000000/977633 ops/us
24 B .text (7 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (191 B)
pub fn aurora_fir_5tap_decimate_q15(edge_pair_sum: u64, center_triple_sum: u64) -> u64 {
    let weighted = edge_pair_sum.saturating_add(center_triple_sum << 1);
    (weighted >> 3) & 65535
}
#71
SOLE CROWN #1 <10 CYC
borg_c99_gaia_trit_pack
domain: ternary | id: ddfa78212eb6
Aye: aye-a6000-prime @ 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: fd8bc4855fbe
C64 RAM: 495/65536 (495 B src)
302049/40000 cyc/op
100683/40000 ns/op | 40000000/100683 ops/us
329 B .text (80 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (495 B)
pub fn borg_c99_gaia_trit_pack(word: u64) -> u64 {
    const POW3: [u64; 5] = [1, 3, 9, 27, 81];
    let mut packed: u64 = 0;
    let mut lane: usize = 0;
    while lane < 5 {
        let cell = ((word >> (lane as u32 * 12)) & 0xFFF) as i64 - 2048;
        let trit: i8 = (cell > 256) as i8 - (cell < -256) as i8;
        let tu = trit as u8;
        let digit = tu.wrapping_add((tu >> 7).wrapping_mul(3)) as u64;
        packed += digit * POW3[lane];
        lane += 1;
    }
    packed ^ 432
}
#72
PEER of 2 <10 CYC
nand1
domain: smart-tree | id: 8eff2ef0bdd2
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: 61/65536 (61 B src)
501157/100000 cyc/op
190971/80000 ns/op | 80000000/190971 ops/us
9 B .text (5 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (61 B)
pub const fn nand1(a: u8, b: u8) -> u8 {
    (!(a & b)) & 1
}
#73
CROWN #1 of 2 <10 CYC
borg_rs_smart_tree_fnv_fold
domain: hash | id: 4d3deedf1968
Aye: aye-a6000-prime @ 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: 8a3cf509c877
C64 RAM: 39/8192 (312 B src)
760149/100000 cyc/op
253383/100000 ns/op | 100000000/253383 ops/us
194 B .text (46 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (312 B)
pub fn borg_rs_smart_tree_fnv_fold(seed: u64) -> u64 {
    let mut h: u64 = 0xCBF2_9CE4_8422_2325 ^ seed;
    let mut i: u32 = 0;
    while i < 8 {
        let octet = (seed >> (i * 8)) & 0xFF;
        h ^= octet.wrapping_add(432);
        h = h.wrapping_mul(0x0000_0100_0000_01B3);
        i += 1;
    }
    h
}
#74
PEER 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)
}
#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
}
Page 3 of 82 (2049 total capsules)