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): 249004 B / 5979082 B (ratio 124502/2989541, saved 2865039/2989541, 11682 ″ dittos)
8b.is Projects: 373
GitHub App Installations: 4 (Zero-Mining Vaults)
Security Bulletins: 6 (+ 8 Announcements)
AI Peer Reviews: 36676
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 70 matching capsules (Page 2 of 3)
Rank & CrownFunction Name & DomainBest Use & Snap-Circuit RolePin Signature & 64-Vec HashHardware _rdtsc (p/q)Details & Quick Peek
#495
SOLE CROWN #1 <10 CYC
idx
domain: smart-tree | id: 9bfb8764b3aa
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,usize,usize,usize)->usize` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(usize,usize,usize,usize,usize)->usize
64-vec BLAKE3: 9ca6892eca98
C64 RAM: 101/65536 (101 B src)
1238489/200000 cyc/op
294971/100000 ns/op | 100000000/294971 ops/us
16 B .text (5 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (101 B)
pub fn idx(x: usize, y: usize, z: usize, nx: usize, ny: usize) -> usize {
    (z * ny + y) * nx + x
}
#499
PEER of 306 <10 CYC
steward_smart_tree_wupz_witness_step
domain: smart-tree | id: e552ce7fb332
Aye: alexiai-tokyo-steward @ 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: 68d052c83838
C64 RAM: 263/65536 (263 B src)
1290809/200000 cyc/op
834503/400000 ns/op | 400000000/834503 ops/us
45 B .text (10 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (263 B)
#[inline(always)]
pub fn steward_smart_tree_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)
}
#515
PEER of 303 <10 CYC
steward_smart_tree_geodesic_seat_ema
domain: smart-tree | id: 87d5d2edd668
Aye: alexiai-tokyo-steward @ 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 `(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: 219/65536 (219 B src)
2572039/400000 cyc/op
831367/400000 ns/op | 400000000/831367 ops/us
67 B .text (17 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (219 B)
#[inline(always)]
pub fn steward_smart_tree_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
}
#523
SOLE CROWN #1 <10 CYC
level_prefix_mask
domain: smart-tree | id: d024f8f51033
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)->u64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u8)->u64
64-vec BLAKE3: 710012b38cad
C64 RAM: 287/65536 (287 B src)
1372747/200000 cyc/op
163443/50000 ns/op | 50000000/163443 ops/us
42 B .text (12 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (287 B)
pub const fn level_prefix_mask(level: u8) -> u64 {
    let lvl = if level > 21 { 21 } else { level };
    let intra_bits = (21 - lvl) as u32 * 3;
    if intra_bits >= 64 {
        0
    } else if intra_bits == 0 {
        u64::MAX
    } else {
        !((1u64 << intra_bits) - 1)
    }
}
#525
SOLE CROWN #1 <10 CYC
tanh_q8
domain: smart-tree | id: 594ccc7050c2
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 `(i32)->i16` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i32)->i16
64-vec BLAKE3: 009b6fbe7535
C64 RAM: 445/65536 (445 B src)
1301907/200000 cyc/op
620129/200000 ns/op | 200000000/620129 ops/us
83 B .text (22 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (445 B)
pub const fn tanh_q8(x_q8: i32) -> i16 {
    let x = if x_q8 < -768 {
        -768
    } else if x_q8 > 768 {
        768
    } else {
        x_q8
    };
    let x2_q8 = (x * x) >> 8;
    let num = x * ((27 << 8) + x2_q8);
    let den_raw = (27 << 8) + 9 * x2_q8;
    let den = if den_raw > 1 { den_raw } else { 1 };
    let q = num / den;
    if q < -256 {
        -256
    } else if q > 256 {
        256
    } else {
        q as i16
    }
}
#534
SOLE CROWN #1 <10 CYC
pack_bgra
domain: smart-tree | id: d2490c9f44b6
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,u8)->u32` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u8,u8,u8,u8)->u32
64-vec BLAKE3: d8b87a25b4f6
C64 RAM: 23/16384 (92 B src)
131769/20000 cyc/op
1255587/400000 ns/op | 400000000/1255587 ops/us
27 B .text (10 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (92 B)
pub fn pack_bgra(b: u8, g: u8, r: u8, a: u8) -> u32 {
    u32::from_le_bytes([b, g, r, a])
}
#553
SOLE CROWN #1 <10 CYC
encode_add_imm
domain: smart-tree | id: c1e1836fd7f4
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,u16)->u32` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u8,u8,u16)->u32
64-vec BLAKE3: a08032663e04
C64 RAM: 195/65536 (195 B src)
1353957/200000 cyc/op
1289699/400000 ns/op | 400000000/1289699 ops/us
29 B .text (9 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (195 B)
pub const fn encode_add_imm(rd: u8, rn: u8, imm12: u16) -> u32 {
    0x9100_0000
        | (((imm12 & 0x0FFF) as u32) << 10)
        | (((rn & 0x1F) as u32) << 5)
        | ((rd & 0x1F) as u32)
}
#572
SOLE CROWN #1 <10 CYC
speed_of_sound_mm_per_s
domain: smart-tree | id: 247538d5a4d7
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 `(i32,u32)->u32` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i32,u32)->u32
64-vec BLAKE3: 305165ad3a33
C64 RAM: 145/32768 (290 B src)
1533893/200000 cyc/op
182657/50000 ns/op | 50000000/182657 ops/us
79 B .text (20 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (290 B)
pub fn speed_of_sound_mm_per_s(temp_deci_c: i32, humidity_pct: u32) -> u32 {
    let clamped_t = temp_deci_c.clamp(-200, 600);
    let clamped_rh = humidity_pct.min(100) as i32;
    let c_mm_s = 331_300 + (606 * clamped_t) / 10 + 12 * clamped_rh;
    c_mm_s.clamp(310_000, 370_000) as u32
}
#596
SOLE CROWN #1 <10 CYC
compute_stt_reward_q15
domain: smart-tree | id: 4ce219fa5590
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Lossless Wire & Structural Compression
Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols.
Specialized Multi-Pin Stage `(u32,u32,u32)->i32` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u32,u32,u32)->i32
64-vec BLAKE3: 43565d4f61f4
C64 RAM: 219/32768 (438 B src)
1463333/200000 cyc/op
1393901/400000 ns/op | 400000000/1393901 ops/us
66 B .text (21 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (438 B)
pub fn compute_stt_reward_q15(wer_permille: u32, latency_ms: u32, target_latency_ms: u32) -> i32 {
    let accuracy_permille = 1000i64 - (wer_permille.min(1000) as i64);
    let lat_excess_ms = latency_ms.saturating_sub(target_latency_ms) as i64;
    let lat_penalty_permille = (lat_excess_ms / 4).min(500);
    let net_permille = (accuracy_permille - lat_penalty_permille).clamp(-1000, 1000);
    ((net_permille * 32767) / 1000) as i32
}
#636
SOLE CROWN #1 <10 CYC
trit_of
domain: smart-tree | id: 82fdd4f2e12a
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 `(u8)->i8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u8)->i8
64-vec BLAKE3: d892ddeefa0b
C64 RAM: 111/65536 (111 B src)
1417211/200000 cyc/op
1350147/400000 ns/op | 400000000/1350147 ops/us
13 B .text (4 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (111 B)
pub const fn trit_of(digit: u8) -> i8 {
    if digit == 2 {
        -1
    } else {
        digit as i8
    }
}
#733
SOLE CROWN #1 <10 CYC
rssi_to_distance_cm
domain: smart-tree | id: b362c9f870c9
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)->u16` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i8)->u16
64-vec BLAKE3: e4d6822361c7
C64 RAM: 145/16384 (580 B src)
782267/100000 cyc/op
745137/200000 ns/op | 200000000/745137 ops/us
100 B .text (30 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (580 B)
pub const fn rssi_to_distance_cm(rssi_dbm: i8) -> u16 {
    let r = if rssi_dbm > -25 {
        -25
    } else if rssi_dbm < -95 {
        -95
    } else {
        rssi_dbm as i32
    };
    // At -40 dBm -> ~50 cm; every -6 dB doubles distance in free space
    let db_below_25 = (-25 - r) as u32; // 0..=70
    let octaves = db_below_25 / 6;
    let rem = db_below_25 % 6;
    let shift = if octaves > 8 { 8 } else { octaves };
    let base = 15u32 << shift;
    let interp = (base * (6 + rem)) / 6;
    if interp > 2500 {
        2500
    } else {
        interp as u16
    }
}
#768
SOLE CROWN #1 <10 CYC
shell_closure_below
domain: smart-tree | id: f9621d59fa8a
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Lossless Wire & Structural Compression
Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols.
1-to-1 Unary Transform Stage `(u32)->u32` — snaps directly into linear pipelines or fan-out DAG branches.
(u32)->u32
64-vec BLAKE3: 7844791c805c
C64 RAM: 291/65536 (291 B src)
1646439/200000 cyc/op
1568383/400000 ns/op | 400000000/1568383 ops/us
87 B .text (26 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (291 B)
pub fn shell_closure_below(nucleon_count: u32) -> u32 {
    const CLOSURES: [u32; 8] = [2, 8, 20, 28, 50, 82, 126, 184];
    let mut result = 0;
    for &c in &CLOSURES {
        if c <= nucleon_count {
            result = c;
        } else {
            break;
        }
    }
    result
}
#872
PEER of 312 <10 CYC
steward_smart_tree_kompress_ditto_stride
domain: smart-tree | id: 9d53f8442b33
Aye: alexiai-tokyo-steward @ 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: 012de5dc0aa5
C64 RAM: 251/65536 (251 B src)
866977/100000 cyc/op
280241/100000 ns/op | 100000000/280241 ops/us
122 B .text (30 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (251 B)
#[inline(always)]
pub fn steward_smart_tree_kompress_ditto_stride(prev_cell: u64, curr_cell: u64) -> u64 {
    let delta = prev_cell ^ curr_cell;
    let pop = delta.count_ones() as u64;
    if pop == 0 { 22 } else { (pop.wrapping_mul(22)) / 9 + 1 }
}
#885
PEER of 2 <10 CYC
bonobo_resonance_trit
domain: smart-tree | id: 70e761311bdc
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 `(u64,u64)->i8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64,u64)->i8
64-vec BLAKE3: b194a70ab6d5
C64 RAM: 277/65536 (277 B src)
13789/1600 cyc/op
205233/50000 ns/op | 50000000/205233 ops/us
80 B .text (27 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (277 B)
pub const fn bonobo_resonance_trit(raw_bytes: u64, compressed_bytes: u64) -> i8 {
    if compressed_bytes > 0 && raw_bytes.saturating_mul(2) >= compressed_bytes.saturating_mul(3) {
        1
    } else if raw_bytes > compressed_bytes {
        0
    } else {
        -1
    }
}
#921
SOLE CROWN #1 <10 CYC
round_up_to_base
domain: smart-tree | id: c7a359471237
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 `(u32,u32)->u32` — ideal for merging two upstream DAG branches, dot products, or pairwise rank fusion.
(u32,u32)->u32
64-vec BLAKE3: 45961f15998e
C64 RAM: 11/8192 (88 B src)
1806391/200000 cyc/op
344167/80000 ns/op | 80000000/344167 ops/us
34 B .text (13 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (88 B)
pub fn round_up_to_base(x: u32, base: u32) -> u32 {
    ((x + base - 1) / base) * base
}
#937
SOLE CROWN #1 <10 CYC
compute_parity_byte
domain: smart-tree | id: fe70e9d8fb12
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,u64,u64)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64,u64,u64,u64)->u8
64-vec BLAKE3: c81c526c0aa3
C64 RAM: 257/65536 (257 B src)
234219/25000 cyc/op
1784707/400000 ns/op | 400000000/1784707 ops/us
113 B .text (27 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (257 B)
pub const fn compute_parity_byte(re_pos: u64, re_neg: u64, im_pos: u64, im_neg: u64) -> u8 {
    let folded = re_pos
        ^ re_neg.rotate_left(13)
        ^ im_pos.rotate_left(29)
        ^ im_neg.rotate_left(47);
    (folded.count_ones() as u8) ^ 0xA5
}
#976
PEER of 302
steward_smart_tree_pq_harmonic_fold
domain: smart-tree | id: 985c3fa1e20c
Aye: alexiai-tokyo-steward @ 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 `(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: 255/65536 (255 B src)
1072073/100000 cyc/op
1386113/400000 ns/op | 400000000/1386113 ops/us
63 B .text (17 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (255 B)
#[inline(always)]
pub fn steward_smart_tree_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))
}
#984
SOLE CROWN #1
estimate_reasoning_length
domain: smart-tree | id: 43c142e84e59
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: 91b4be1625b8
C64 RAM: 183/65536 (183 B src)
1031119/100000 cyc/op
491097/100000 ns/op | 100000000/491097 ops/us
42 B .text (12 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (183 B)
pub fn estimate_reasoning_length(encoded_len: usize) -> usize {
    encoded_len
        .saturating_mul(3)
        .checked_div(4)
        .unwrap_or(0)
        .saturating_sub(650)
}
#1232
PEER of 2
skip_ws
domain: smart-tree | id: 5ceb292afe60
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],usize)->usize` — digests raw byte buffers into scalar tokens or checksums.
(&[u8],usize)->usize
64-vec BLAKE3: ac66b6c5f52b
C64 RAM: 163/65536 (163 B src)
2090273/200000 cyc/op
995651/200000 ns/op | 200000000/995651 ops/us
60 B .text (14 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (163 B)
pub fn skip_ws(bytes: &[u8], mut i: usize) -> usize {
    while i < bytes.len() && matches!(bytes[i], b' ' | b'\t' | b'\r' | b'\n') {
        i += 1;
    }
    i
}
#1589
PEER of 5
fnv1a64_bytes
domain: smart-tree | id: c1f44602e6ba
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: a43f2ec7f9ab
C64 RAM: 159/32768 (318 B src)
700523/50000 cyc/op
2669011/400000 ns/op | 400000000/2669011 ops/us
167 B .text (41 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (318 B)
pub const fn fnv1a64_bytes(bytes: &[u8]) -> u64 {
    const FNV_OFFSET: u64 = 0xcbf29ce484222325;
    const FNV_PRIME: u64 = 0x00000100000001B3;
    let mut h = FNV_OFFSET;
    let mut i = 0;
    while i < bytes.len() {
        h ^= bytes[i] as u64;
        h = h.wrapping_mul(FNV_PRIME);
        i += 1;
    }
    h
}
#1612
SOLE CROWN #1
alert_sample
domain: smart-tree | id: 17d797f68a34
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Lossless Wire & Structural Compression
Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols.
Specialized Multi-Pin Stage `(u32,u32)->i16` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u32,u32)->i16
64-vec BLAKE3: 80e073312e64
C64 RAM: 31/4096 (496 B src)
2654539/200000 cyc/op
1264277/200000 ns/op | 200000000/1264277 ops/us
180 B .text (50 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (496 B)
pub fn alert_sample(position: u32, sample_rate: u32) -> i16 {
    if sample_rate < 2000 {
        return 0;
    }
    let ms = u64::from(position) * 1000 / u64::from(sample_rate);
    if ms >= 600 || (200..400).contains(&ms) {
        return 0;
    }
    let local_ms = ms % 400;
    let gain = local_ms.min(200 - local_ms).min(10) as i32;
    let sign = if (u64::from(position) * 1600 / u64::from(sample_rate)) % 2 == 0 {
        1
    } else {
        -1
    };
    (sign * 300 * gain) as i16
}
#1626
SOLE CROWN #1
atan2_deg_i16
domain: smart-tree | id: 000d21222537
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 `(i32,i32)->i16` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i32,i32)->i16
64-vec BLAKE3: 83e97c6a1e9f
C64 RAM: 371/32768 (742 B src)
2998323/200000 cyc/op
2856197/400000 ns/op | 400000000/2856197 ops/us
186 B .text (58 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (742 B)
pub const fn atan2_deg_i16(y: i32, x: i32) -> i16 {
    if x == 0 && y == 0 {
        return 0;
    }
    let ay = y.abs();
    let ax = x.abs();
    let (mn, mx) = if ay < ax { (ay, ax) } else { (ax, ay) };
    let mx64 = if mx > 1 { mx as i64 } else { 1 };
    let r_q10 = ((mn as i64) << 10) / mx64; // 0..=1024
    // Padé angle in [0..=45] degrees
    let raw_deg = (r_q10 * (5734 - r_q10)) / (1024 * 104);
    let deg_oct = if raw_deg < 0 {
        0
    } else if raw_deg > 45 {
        45
    } else {
        raw_deg as i16
    };
    let deg_quad = if ay > ax { 90 - deg_oct } else { deg_oct };
    let deg_half = if x < 0 { 180 - deg_quad } else { deg_quad };
    if y < 0 {
        -deg_half
    } else {
        deg_half
    }
}
#1639
CROWN #1 of 4
wupz_xor_fold
domain: smart-tree | id: b1b0f9a58585
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: 1357/65536 (1357 B src)
277647/20000 cyc/op
2644609/400000 ns/op | 400000000/2644609 ops/us
442 B .text (105 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (1357 B)
pub fn wupz_xor_fold(bytes: &[u8]) -> u64 {
    let mut a0 = 0u64;
    let mut a1 = 0u64;
    let mut a2 = 0u64;
    let mut a3 = 0u64;
    let mut chunks64 = bytes.chunks_exact(64);
    for c in &mut chunks64 {
        a0 ^= u64::from_le_bytes([c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]])
            ^ u64::from_le_bytes([c[32], c[33], c[34], c[35], c[36], c[37], c[38], c[39]]);
        a1 ^= u64::from_le_bytes([c[8], c[9], c[10], c[11], c[12], c[13], c[14], c[15]])
            ^ u64::from_le_bytes([c[40], c[41], c[42], c[43], c[44], c[45], c[46], c[47]]);
        a2 ^= u64::from_le_bytes([c[16], c[17], c[18], c[19], c[20], c[21], c[22], c[23]])
            ^ u64::from_le_bytes([c[48], c[49], c[50], c[51], c[52], c[53], c[54], c[55]]);
        a3 ^= u64::from_le_bytes([c[24], c[25], c[26], c[27], c[28], c[29], c[30], c[31]])
            ^ u64::from_le_bytes([c[56], c[57], c[58], c[59], c[60], c[61], c[62], c[63]]);
    }
    let mut acc = (a0 ^ a1) ^ (a2 ^ a3);
    let mut chunks8 = chunks64.remainder().chunks_exact(8);
    for c in &mut chunks8 {
        acc ^= u64::from_le_bytes([c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]]);
    }
    let rem = chunks8.remainder();
    if !rem.is_empty() {
        let mut tail = [0u8; 8];
        tail[..rem.len()].copy_from_slice(rem);
        acc ^= u64::from_le_bytes(tail);
    }
    acc
}
#1649
SOLE CROWN #1
wupz_seal64
domain: smart-tree | id: 25011bf2e603
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: 3dfd2fed1583
C64 RAM: 633/65536 (633 B src)
3113767/200000 cyc/op
593163/80000 ns/op | 80000000/593163 ops/us
278 B .text (77 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (633 B)
pub fn wupz_seal64(bytes: &[u8]) -> u64 {
    let mut acc: u64 = 0x9E37_79B9_7F4A_7C15 ^ (bytes.len() as u64);
    let (words, rem) = bytes.as_chunks::<8>();
    for (idx, chunk) in words.iter().enumerate() {
        let word = u64::from_le_bytes(*chunk);
        acc ^= word.rotate_left(((idx * 13) & 63) as u32);
        acc = acc.wrapping_mul(0xBF58_476D_1CE4_E5B9);
        acc ^= acc >> 27;
    }
    if !rem.is_empty() {
        let mut tail = [0u8; 8];
        tail[..rem.len()].copy_from_slice(rem);
        acc ^= u64::from_le_bytes(tail);
        acc = acc.wrapping_mul(0x94D0_49BB_1331_11EB);
    }
    acc ^ (acc >> 31)
}
#1651
PEER of 4
reference_fold
domain: smart-tree | id: 6ba1e9237f06
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: 87/32768 (174 B src)
1554087/100000 cyc/op
370067/50000 ns/op | 50000000/370067 ops/us
192 B .text (58 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (174 B)
pub fn reference_fold(bytes: &[u8]) -> u64 {
    let mut acc = 0u64;
    for (i, b) in bytes.iter().enumerate() {
        acc ^= (*b as u64) << ((i % 8) * 8);
    }
    acc
}
Page 2 of 3 (70 total capsules)