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 1..25 of 70 matching capsules (Page 1 of 3)
Rank & CrownFunction Name & DomainBest Use & Snap-Circuit RolePin Signature & 64-Vec HashHardware _rdtsc (p/q)Details & Quick Peek
#2
CROWN #1 of 5 <10 CYC
fnv64_1a
domain: smart-tree-x86_64 | id: 1dcf2f5ffc27
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: 31/8192 (248 B src)
482141/200000 cyc/op
523321/800000 ns/op | 800000000/523321 ops/us
167 B .text (41 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (248 B)
pub const fn fnv64_1a(bytes: &[u8]) -> u64 {
    let mut hash = 0xcbf29ce484222325u64;
    let mut i = 0;
    while i < bytes.len() {
        hash ^= bytes[i] as u64;
        hash = hash.wrapping_mul(0x100000001b3);
        i += 1;
    }
    hash
}
#4
PEER of 3 <10 CYC
isqrt_u64
domain: smart-tree-x86_64 | id: 87992ac8869b
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Lossless Wire & Structural Compression
Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols.
1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: 22317c08f10e
C64 RAM: 73/16384 (292 B src)
968409/400000 cyc/op
525559/800000 ns/op | 800000000/525559 ops/us
122 B .text (39 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (292 B)
pub const fn isqrt_u64(x: u64) -> u64 {
    if x < 2 {
        return x;
    }
    let shift = (64 - x.leading_zeros()).div_ceil(2);
    let mut g = 1u64 << shift;
    loop {
        let next = (g + x / g) >> 1;
        if next >= g {
            return g;
        }
        g = next;
    }
}
#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 }
        }
#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
}
#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
}
#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 }
}
#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
    }
}
#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
}
#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()
}
#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
}
#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
}
#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
}
#241
SOLE CROWN #1 <10 CYC
clamp_i64
domain: smart-tree | id: df236abba949
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 `(i64,i64,i64)->i64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i64,i64,i64)->i64
64-vec BLAKE3: c90b338be5e4
C64 RAM: 167/65536 (167 B src)
502331/100000 cyc/op
957213/400000 ns/op | 400000000/957213 ops/us
18 B .text (6 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (167 B)
pub const fn clamp_i64(v: i64, min_v: i64, max_v: i64) -> i64 {
    if v < min_v {
        min_v
    } else if v > max_v {
        max_v
    } else {
        v
    }
}
#244
SOLE CROWN #1 <10 CYC
zigzag_i32
domain: smart-tree | id: 8d851c97dde8
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` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i32)->u32
64-vec BLAKE3: 8c88fd23aabe
C64 RAM: 35/32768 (70 B src)
221247/40000 cyc/op
526901/200000 ns/op | 200000000/526901 ops/us
9 B .text (4 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (70 B)
pub fn zigzag_i32(x: i32) -> u32 {
    ((x << 1) ^ (x >> 31)) as u32
}
#259
SOLE CROWN #1 <10 CYC
quant_tern_trit_pq
domain: smart-tree | id: 1b2105f916ac
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)->i8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i64,i64)->i8
64-vec BLAKE3: 9dc6d5653e80
C64 RAM: 63/16384 (252 B src)
109833/20000 cyc/op
523197/200000 ns/op | 200000000/523197 ops/us
53 B .text (17 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (252 B)
pub const fn quant_tern_trit_pq(p_x: i64, q: i64) -> i8 {
    let q_abs = if q < 0 { -q } else { q };
    let lhs = p_x * 100;
    let rhs = 33 * q_abs;
    if lhs >= rhs {
        1
    } else if lhs <= -rhs {
        -1
    } else {
        0
    }
}
#383
SOLE CROWN #1 <10 CYC
evaluate_stroke_kinematics_q15
domain: smart-tree | id: 200d27359944
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 `(u16,u16)->u32` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u16,u16)->u32
64-vec BLAKE3: bc7110c1dced
C64 RAM: 441/65536 (441 B src)
1234501/200000 cyc/op
235211/80000 ns/op | 80000000/235211 ops/us
67 B .text (20 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (441 B)
pub const fn evaluate_stroke_kinematics_q15(handle_mm: u16, seat_mm: u16) -> u32 {
    let h = if handle_mm > 1_600 {
        1_600u32
    } else {
        handle_mm as u32
    };
    let s = if seat_mm > 1_200 {
        1_200u32
    } else {
        seat_mm as u32
    };
    let lhs = h * 3;
    let rhs = s * 4;
    let diff = lhs.abs_diff(rhs);
    let penalty = if diff * 4 >= 32_768 { 32_768 } else { diff * 4 };
    32_768 - penalty
}
#478
PEER of 2 <10 CYC
freq_to_channel
domain: smart-tree | id: 7ba23b762491
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)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u32)->u8
64-vec BLAKE3: 8a73c2ecf045
C64 RAM: 227/16384 (908 B src)
669763/100000 cyc/op
319039/100000 ns/op | 100000000/319039 ops/us
526 B .text (156 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (908 B)
pub fn freq_to_channel(freq: u32) -> u8 {
    match freq {
        2412 => 1,
        2417 => 2,
        2422 => 3,
        2427 => 4,
        2432 => 5,
        2437 => 6,
        2442 => 7,
        2447 => 8,
        2452 => 9,
        2457 => 10,
        2462 => 11,
        2467 => 12,
        2472 => 13,
        2484 => 14,
        // 5GHz channels (simplified)
        5180 => 36,
        5200 => 40,
        5220 => 44,
        5240 => 48,
        5260 => 52,
        5280 => 56,
        5300 => 60,
        5320 => 64,
        5500 => 100,
        5520 => 104,
        5540 => 108,
        5560 => 112,
        5580 => 116,
        5600 => 120,
        5620 => 124,
        5640 => 128,
        5660 => 132,
        5680 => 136,
        5700 => 140,
        5720 => 144,
        5745 => 149,
        5765 => 153,
        5785 => 157,
        5805 => 161,
        5825 => 165,
        _ => 0,
    }
}
#490
SOLE CROWN #1 <10 CYC
fnv1a_byte
domain: smart-tree | id: 5288e62685fa
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,u8)->u32` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u32,u8)->u32
64-vec BLAKE3: 3dabd4462715
C64 RAM: 45/32768 (90 B src)
641309/100000 cyc/op
1222057/400000 ns/op | 400000000/1222057 ops/us
13 B .text (4 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (90 B)
pub fn fnv1a_byte(h: u32, b: u8) -> u32 {
    (h ^ (b as u32)).wrapping_mul(0x0100_0193)
}
Page 1 of 3 (70 total capsules)