rustc -C opt-level=3): 2049 (203973 B .text / 53737 insns)22/9 Hz): 248859 B / 5979025 B (ratio 19143/459925, saved 440782/459925, 11708 ″ dittos)| Rank & Crown | Function Name & Domain | Best Use & Snap-Circuit Role | Pin Signature & 64-Vec Hash | Hardware _rdtsc (p/q) | Details & Quick Peek |
|---|---|---|---|---|---|
| #2 CROWN #1 of 5 <10 CYC | fnv64_1a domain: smart-tree-x86_64 | id: 1dcf2f5ffc27Aye: 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])->u6464-vec BLAKE3: a43f2ec7f9abC64 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: 87992ac8869bAye: 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)->u6464-vec BLAKE3: 22317c08f10eC64 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: 2961ade4605bAye: 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)->u6464-vec BLAKE3: c8748439c46fC64 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: 36e236cb0c64Aye: 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)->u864-vec BLAKE3: 8f88bdd8fa04C64 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: c24cb66f3eb2Aye: 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)->i3264-vec BLAKE3: fe9b823c34baC64 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: 044a535449e0Aye: 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)->u864-vec BLAKE3: af453fc63278C64 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: 65b9382b58fbAye: 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)->i864-vec BLAKE3: 7d69a0c8ad71C64 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: d52e987d0145Aye: 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)->u1664-vec BLAKE3: d1f153685f1aC64 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: 56f445b8f237Aye: 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)->u1664-vec BLAKE3: 5264d5b0a97eC64 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: 337de5b014f5Aye: 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)->i1664-vec BLAKE3: b205fd5ad400C64 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: 6af09389e8e9Aye: 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)->i864-vec BLAKE3: fd5753da6279C64 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: a453ae184639Aye: 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)->usize64-vec BLAKE3: c9268f44f097C64 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: d3652761ffeaAye: 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)->i3264-vec BLAKE3: a7f5f440f3baC64 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: 337da90c1eeeAye: 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)->i3264-vec BLAKE3: d28b8de47a8dC64 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: 34750981dc46Aye: 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)->u3264-vec BLAKE3: 8fda92bf1449C64 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: 2da3790ba6a3Aye: 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)->i3264-vec BLAKE3: db9aabfdb4deC64 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: 8eff2ef0bdd2Aye: 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)->u864-vec BLAKE3: 8f88bdd8fa04C64 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: 892ad4d7846aAye: 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)->u6464-vec BLAKE3: 8a3cf509c877C64 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: 2dd83c858706Aye: 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)->u6464-vec BLAKE3: 0e3924283963C64 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: df236abba949Aye: 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)->i6464-vec BLAKE3: c90b338be5e4C64 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: 8d851c97dde8Aye: 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)->u3264-vec BLAKE3: 8c88fd23aabeC64 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: 1b2105f916acAye: 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)->i864-vec BLAKE3: 9dc6d5653e80C64 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: 200d27359944Aye: 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)->u3264-vec BLAKE3: bc7110c1dcedC64 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: 7ba23b762491Aye: 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)->u864-vec BLAKE3: 8a73c2ecf045C64 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: 5288e62685faAye: 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)->u3264-vec BLAKE3: 3dabd4462715C64 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)
} |