rustc -C opt-level=3): 2049 (203973 B .text / 53737 insns)22/9 Hz): 249004 B / 5979082 B (ratio 124502/2989541, saved 2865039/2989541, 11682 ″ dittos)| Rank & Crown | Function Name & Domain | Best Use & Snap-Circuit Role | Pin Signature & 64-Vec Hash | Hardware _rdtsc (p/q) | Details & Quick Peek |
|---|---|---|---|---|---|
| #495 SOLE CROWN #1 <10 CYC | idx domain: smart-tree | id: 9bfb8764b3aaAye: 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)->usize64-vec BLAKE3: 9ca6892eca98C64 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: e552ce7fb332Aye: 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)->u6464-vec BLAKE3: 68d052c83838C64 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: 87d5d2edd668Aye: 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)->i6464-vec BLAKE3: f79426b0bb51C64 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: d024f8f51033Aye: 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)->u6464-vec BLAKE3: 710012b38cadC64 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: 594ccc7050c2Aye: 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)->i1664-vec BLAKE3: 009b6fbe7535C64 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: d2490c9f44b6Aye: 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)->u3264-vec BLAKE3: d8b87a25b4f6C64 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: c1e1836fd7f4Aye: 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)->u3264-vec BLAKE3: a08032663e04C64 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: 247538d5a4d7Aye: 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)->u3264-vec BLAKE3: 305165ad3a33C64 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: 4ce219fa5590Aye: 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)->i3264-vec BLAKE3: 43565d4f61f4C64 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: 82fdd4f2e12aAye: 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)->i864-vec BLAKE3: d892ddeefa0bC64 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: b362c9f870c9Aye: 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)->u1664-vec BLAKE3: e4d6822361c7C64 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: f9621d59fa8aAye: 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)->u3264-vec BLAKE3: 7844791c805cC64 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: 9d53f8442b33Aye: 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)->u6464-vec BLAKE3: 012de5dc0aa5C64 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: 70e761311bdcAye: 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)->i864-vec BLAKE3: b194a70ab6d5C64 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: c7a359471237Aye: 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)->u3264-vec BLAKE3: 45961f15998eC64 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: fe70e9d8fb12Aye: 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)->u864-vec BLAKE3: c81c526c0aa3C64 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: 985c3fa1e20cAye: 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)->i6464-vec BLAKE3: f3c9e53b4edeC64 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: 43c142e84e59Aye: 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: 91b4be1625b8C64 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: 5ceb292afe60Aye: 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)->usize64-vec BLAKE3: ac66b6c5f52bC64 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: c1f44602e6baAye: 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: 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: 17d797f68a34Aye: 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)->i1664-vec BLAKE3: 80e073312e64C64 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: 000d21222537Aye: 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)->i1664-vec BLAKE3: 83e97c6a1e9fC64 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: b1b0f9a58585Aye: 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: f2befb3850c8C64 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: 25011bf2e603Aye: 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: 3dfd2fed1583C64 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: 6ba1e9237f06Aye: 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: f2befb3850c8C64 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
} |