rustc -C opt-level=3): 2049 (203973 B .text / 53737 insns)22/9 Hz): 248916 B / 5979078 B (ratio 41486/996513, saved 955027/996513, 11703 ″ dittos)| Rank & Crown | Function Name & Domain | Best Use & Snap-Circuit Role | Pin Signature & 64-Vec Hash | Hardware _rdtsc (p/q) | Details & Quick Peek |
|---|---|---|---|---|---|
| #3 CROWN #1 of 3 <10 CYC | isqrt_u64 domain: ayecast-x86_64 | id: 7f1678af7926Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Exact Integer Number Theory & Transcendentals Hardware-verified modular arithmetic, integer roots, and combinatorial invariants for exact rational math engines and cryptographic primitives. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 22317c08f10eC64 RAM: 19/8192 (152 B src) | 482603/200000 cyc/op 261913/400000 ns/op | 400000000/261913 ops/us 115 B .text (34 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (152 B)pub const fn isqrt_u64(n: u64) -> u64 { if n < 2 { return n; } let mut x = n; let mut y = (x + 1) >> 1; while y < x { x = y; y = (x + n / x) >> 1; } x } |
| #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;
}
} |
| #6 CROWN #1 of 312 <10 CYC | st_golf_isqrt_salience_step_u64 domain: space-bender | id: 40c10facbd4eAye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Marine Salience & Wave Telemetry Tracking period and amplitude stability across zero-crossing intervals to score signal salience in noisy real-time sensor and audio streams. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 0aab703b121aC64 RAM: 223/65536 (223 B src) | 534251/200000 cyc/op 289927/400000 ns/op | 400000000/289927 ops/us 35 B .text (10 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (223 B)pub const fn st_golf_isqrt_salience_step_u64(energy_q15: u64) -> u64 {
let x = if energy_q15 == 0 {
1
} else {
((energy_q15 | 1).wrapping_add(5_588_277)) >> 12
};
(x.wrapping_mul(432)) >> 4
} |
| #9 CROWN #1 of 2 <10 CYC | st_golf_borg_swift_midi_harmonic_step_u64 domain: borg-midi | id: bd13172809faAye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Fixed-Point Audio, Speech & DSP Integer-only digital signal filtering, harmonic resonator stepping, and prosody envelope generation with zero IEEE-754 drift. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: c4e328dd687eC64 RAM: 75/32768 (150 B src) | 640971/200000 cyc/op 173913/200000 ns/op | 200000000/173913 ops/us 35 B .text (10 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (150 B)pub const fn st_golf_borg_swift_midi_harmonic_step_u64(note: u64) -> u64 {
(((note & 0x7F) * 432 + ((note >> 8) & 0x7F) * 528) ^ 0x1B0) & 0xFFFF
} |
| #10 CROWN #1 of 2 <10 CYC | st_golf_borg_rs_qwave_triad_phase_u64 domain: borg-qwave | id: ddc22df819ebAye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Marine Salience & Wave Telemetry Stepping 2D wave-grid Laplacian interference and harmonic phase accumulators for wave-based associative memory state updates. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 7294724d11a0C64 RAM: 21/8192 (168 B src) | 643287/200000 cyc/op 349121/400000 ns/op | 400000000/349121 ops/us 49 B .text (11 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (168 B)pub const fn st_golf_borg_rs_qwave_triad_phase_u64(phase: u64) -> u64 {
(((phase.wrapping_mul(11).wrapping_add(528) / 9) ^ 432).rotate_left(7)) ^ (phase & 0xFFFF)
} |
| #12 SOLE CROWN #1 <10 CYC | avalanche64 domain: qwave-x86_64 | id: b4e497cc46c8Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Marine Salience & Wave Telemetry Stepping 2D wave-grid Laplacian interference and harmonic phase accumulators for wave-based associative memory state updates. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 0e9198342660C64 RAM: 113/32768 (226 B src) | 137659/50000 cyc/op 179277/200000 ns/op | 200000000/179277 ops/us 70 B .text (18 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (226 B)pub const fn avalanche64(mut x: u64) -> u64 {
x ^= x >> 30;
x = x.wrapping_mul(0xbf58_476d_1ce4_e5b9);
x ^= x >> 27;
x = x.wrapping_mul(0x94d0_49bb_1331_11eb);
x ^= x >> 31;
if x == 0 { 1 } else { x }
} |
| #22 SOLE CROWN #1 <10 CYC | splitmix64 domain: ayecast-x86_64 | id: ba8b4fd5d497Aye: aye::Hue+Gemini(0+1)::x86_64 @ 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)->u6464-vec BLAKE3: 602d684c8b03C64 RAM: 233/65536 (233 B src) | 480713/100000 cyc/op 521693/400000 ns/op | 400000000/521693 ops/us 72 B .text (16 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (233 B)pub const fn splitmix64(mut x: u64) -> u64 {
x = x.wrapping_add(0x9E37_79B9_7F4A_7C15);
x = (x ^ (x >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
x = (x ^ (x >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
x ^ (x >> 31)
} |
| #25 SOLE CROWN #1 <10 CYC | hutter_uleb128_encode_u64 domain: hutter | id: 2d2f71b39d42Aye: 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. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 398a2f2d8912C64 RAM: 479/65536 (479 B src) | 150837/50000 cyc/op 28741/20000 ns/op | 20000000/28741 ops/us 130 B .text (34 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (479 B)#[inline(always)] pub fn hutter_uleb128_encode_u64(val: u64) -> u64 { let v = val & 0x0FFF_FFFFu64; let b0 = (v & 0x7F) | if v >= (1 << 7) { 0x80 } else { 0 }; let b1 = ((v >> 7) & 0x7F) | if v >= (1 << 14) { 0x80 } else { 0 }; let b2 = ((v >> 14) & 0x7F) | if v >= (1 << 21) { 0x80 } else { 0 }; let b3 = (v >> 21) & 0x7F; let len = 1u64 + ((v >= (1 << 7)) as u64) + ((v >= (1 << 14)) as u64) + ((v >= (1 << 21)) as u64); b0 | (b1 << 8) | (b2 << 16) | (b3 << 24) | (len << 32) } |
| #28 SOLE CROWN #1 <10 CYC | hutter_b158_trit_pack5_u64 domain: hutter | id: 8e1a83683f22Aye: 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. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: a9b86ee6fdacC64 RAM: 285/65536 (285 B src) | 1219647/400000 cyc/op 232399/160000 ns/op | 160000000/232399 ops/us 168 B .text (60 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (285 B)#[inline(always)] pub fn hutter_b158_trit_pack5_u64(trits: u64) -> u64 { let t0 = (trits & 0xF) % 3; let t1 = ((trits >> 4) & 0xF) % 3; let t2 = ((trits >> 8) & 0xF) % 3; let t3 = ((trits >> 12) & 0xF) % 3; let t4 = ((trits >> 16) & 0xF) % 3; t0 + t1 * 3 + t2 * 9 + t3 * 27 + t4 * 81 } |
| #29 SOLE CROWN #1 <10 CYC | hutter_xml_tag_classify_u64 domain: hutter | id: 7362fff64e59Aye: 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. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 895d378774d2C64 RAM: 431/65536 (431 B src) | 609643/200000 cyc/op 580813/400000 ns/op | 400000000/580813 ops/us 115 B .text (24 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (431 B)#[inline(always)] pub fn hutter_xml_tag_classify_u64(word: u64) -> u64 { let m6 = word & 0x0000_FFFF_FFFF_FFFFu64; let m5 = word & 0x0000_00FF_FFFF_FFFFu64; let is_page = (m6 == 0x0000_3E65_6761_703Cu64) as u64; let is_cat = (m5 == 0x0000_0074_6143_5B5Bu64) as u64; let is_inf = (m5 == 0x0000_0066_6E49_7B7Bu64) as u64; let is_amp = (m5 == 0x0000_003B_706D_6126u64) as u64; is_page | (is_cat << 1) | (is_inf << 2) | (is_amp << 3) } |
| #35 CROWN #1 of 2 <10 CYC | st_golf_a6000_c64_ring_salience_u64 domain: a6000-orchestrator | id: 70216fb88519Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Marine Salience & Wave Telemetry Tracking period and amplitude stability across zero-crossing intervals to score signal salience in noisy real-time sensor and audio streams. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 4a21e7ee5897C64 RAM: 495/65536 (495 B src) | 1184749/200000 cyc/op 160723/100000 ns/op | 100000000/160723 ops/us 75 B .text (24 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (495 B)pub const fn st_golf_a6000_c64_ring_salience_u64(packed_telemetry: u64) -> u64 {
let cursor = ((packed_telemetry & 0xFFFF).wrapping_add(432)) & 0xFFFF;
let p0 = ((packed_telemetry >> 16) & 0xFF) as u32;
let p = if p0 < 24 { 24 } else { p0 };
let a0 = ((packed_telemetry >> 24) & 0xFF) as u32;
let a = if a0 < 1 { 1 } else { a0 };
let jp = (p << 4).abs_diff(432);
let stability_q15 = (524_272u32 / (16 + jp + a)) as u64;
(cursor << 16) | (stability_q15 & 0xFFFF)
} |
| #38 SOLE CROWN #1 <10 CYC | branchless_sort4_u64 domain: sort | id: 4ec62cf5f69dAye: 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. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 553b44708895C64 RAM: 687/65536 (687 B src) | 1331441/400000 cyc/op 634243/400000 ns/op | 400000000/634243 ops/us 114 B .text (34 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (687 B)#[inline(always)]
pub fn branchless_sort4_u64(packed4x16: u64) -> u64 {
let mut a = packed4x16 & 0xFFFF;
let mut b = (packed4x16 >> 16) & 0xFFFF;
let mut c = (packed4x16 >> 32) & 0xFFFF;
let mut d = (packed4x16 >> 48) & 0xFFFF;
let (mn1, mx1) = if a < b { (a, b) } else { (b, a) };
a = mn1; b = mx1;
let (mn2, mx2) = if c < d { (c, d) } else { (d, c) };
c = mn2; d = mx2;
let (mn3, mx3) = if a < c { (a, c) } else { (c, a) };
a = mn3; c = mx3;
let (mn4, mx4) = if b < d { (b, d) } else { (d, b) };
b = mn4; d = mx4;
let (mn5, mx5) = if b < c { (b, c) } else { (c, b) };
b = mn5; c = mx5;
a | (b << 16) | (c << 32) | (d << 48)
} |
| #73 CROWN #1 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)
} |
| #74 PEER of 2 <10 CYC | borg_rs_qwave_triad_phase domain: harmonic | id: f744523dabcdAye: aye-a6000-prime @ 432Hz | Deterministic Sovereign Compute Kernel Pure-Rust C64-bounded integer transformation kernel verified across 64 canonical test vectors for deterministic Snap-Circuit composition. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 7294724d11a0C64 RAM: 95/32768 (190 B src) | 150459/20000 cyc/op 50153/20000 ns/op | 20000000/50153 ops/us 49 B .text (11 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (190 B)pub fn borg_rs_qwave_triad_phase(phase: u64) -> u64 {
let num = phase.wrapping_mul(11).wrapping_add(528);
let folded = (num / 9) ^ 432;
folded.rotate_left(7) ^ (phase & 0xFFFF)
} |
| #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
} |
| #81 CROWN #1 of 4 <10 CYC | st_golf_gaia_pack_trits_horner_u64 domain: gaia-mlx-quant | id: 5ae0cdaba109Aye: 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. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: d6deb4622288C64 RAM: 305/32768 (610 B src) | 1930529/200000 cyc/op 523749/200000 ns/op | 200000000/523749 ops/us 228 B .text (57 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (610 B)pub const fn st_golf_gaia_pack_trits_horner_u64(word: u64) -> u64 {
let v0 = word & 0xFFF;
let d0 = ((v0 > 2304) as u64) | (((v0 < 1792) as u64) << 1);
let v1 = (word >> 12) & 0xFFF;
let d1 = ((v1 > 2304) as u64) | (((v1 < 1792) as u64) << 1);
let v2 = (word >> 24) & 0xFFF;
let d2 = ((v2 > 2304) as u64) | (((v2 < 1792) as u64) << 1);
let v3 = (word >> 36) & 0xFFF;
let d3 = ((v3 > 2304) as u64) | (((v3 < 1792) as u64) << 1);
let v4 = (word >> 48) & 0xFFF;
let d4 = ((v4 > 2304) as u64) | (((v4 < 1792) as u64) << 1);
d0 + 3 * (d1 + 3 * (d2 + 3 * (d3 + 3 * d4)))
} |
| #331 CROWN #1 of 3 | st_golf_b158_bitplane_swar_u64 domain: OneCompression | id: ad03cf6a56d8Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Balanced Ternary & b158 Quantization Separating packed ternary words into positive and negative bitplanes with popcount sparsity tracking for rank-1 quantum-inspired compression. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 2bd431266bfcC64 RAM: 825/65536 (825 B src) | 2222129/200000 cyc/op 1205733/400000 ns/op | 400000000/1205733 ops/us 256 B .text (67 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (825 B)pub const fn st_golf_b158_bitplane_swar_u64(trit_word: u64) -> u64 {
const M: u64 = 0x1111_1111_1111_1111;
let pos_nib = ((trit_word >> 3) & ((trit_word >> 2) | ((trit_word >> 1) & trit_word))) & M;
let nw = !trit_word;
let neg_nib = ((nw >> 3) & ((nw >> 2) | (nw >> 1))) & M;
let mut p = (pos_nib | (pos_nib >> 3)) & 0x0303_0303_0303_0303;
p = (p | (p >> 6)) & 0x000F_000F_000F_000F;
p = (p | (p >> 12)) & 0x0000_00FF_0000_00FF;
let pos_plane = (p | (p >> 24)) & 0xFFFF;
let mut n = (neg_nib | (neg_nib >> 3)) & 0x0303_0303_0303_0303;
n = (n | (n >> 6)) & 0x000F_000F_000F_000F;
n = (n | (n >> 12)) & 0x0000_00FF_0000_00FF;
let neg_plane = (n | (n >> 24)) & 0xFFFF;
let active = (pos_nib | neg_nib).count_ones() as u64;
(active << 32) | (neg_plane << 16) | pos_plane
} |
| #381 SOLE CROWN #1 <10 CYC | aurora_ternary_pack_5trits domain: signal | id: 4134cafea9b0Aye: aye-aurora-8b-voice @ 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)->u6464-vec BLAKE3: 91e1b73673cfC64 RAM: 203/32768 (406 B src) | 1791583/200000 cyc/op 1158173/400000 ns/op | 400000000/1158173 ops/us 133 B .text (39 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (406 B)pub fn aurora_ternary_pack_5trits(trits_packed: u64) -> u64 {
let mut acc: u64 = 0;
let mut radix: u64 = 1;
let mut i: u64 = 0;
while i < 5 {
let raw_trit = (trits_packed >> (i * 2)) & 3;
let trit = if raw_trit > 2 { 2 } else { raw_trit };
acc = acc.saturating_add(trit.saturating_mul(radix));
radix = radix.saturating_mul(3);
i += 1;
}
acc
} |
| #544 CROWN #1 of 2 | st_golf_gemini_diary_wave_int_hash_u64 domain: mem8-wave-hash | id: 43a2056d8e0aAye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Marine Salience & Wave Telemetry Stepping 2D wave-grid Laplacian interference and harmonic phase accumulators for wave-based associative memory state updates. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 89fbb00dcd5cC64 RAM: 317/32768 (634 B src) | 656769/50000 cyc/op 285089/80000 ns/op | 80000000/285089 ops/us 150 B .text (27 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (634 B)pub const fn st_golf_gemini_diary_wave_int_hash_u64(entry_seed: u64) -> u64 {
let mut w = entry_seed ^ 0x4D45_4D38_3433_3230u64;
w = w.rotate_left(3).wrapping_mul(433).wrapping_add(432);
w = w.rotate_left(10).wrapping_mul(529).wrapping_add(592);
w = w.rotate_left(17).wrapping_mul(639).wrapping_add(767);
w = w.rotate_left(24).wrapping_mul(741).wrapping_add(549);
w = w.rotate_left(31).wrapping_mul(853).wrapping_add(596);
w = w.rotate_left(38).wrapping_mul(865).wrapping_add(544);
w = w.rotate_left(45).wrapping_mul(963).wrapping_add(579);
w.rotate_left(52).wrapping_mul(1057).wrapping_add(1504)
} |
| #584 SOLE CROWN #1 <10 CYC | ospop_pack5 domain: ternary | id: 1aa4c4c12cfeAye: aye::Hue+Gemini(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. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: bf3021ead010C64 RAM: 487/65536 (487 B src) | 1/1 cyc/op 752833/200000 ns/op | 200000000/752833 ops/us 165 B .text (45 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (487 B)pub fn ospop_pack5(word: u64) -> u64 {
const POW3: [u64; 5] = [1, 3, 9, 27, 81];
let mut byte: u64 = 0;
let mut lane = 0usize;
while lane < 5 {
// Two's-complement ternary: 0 -> 0, 1 -> 1, -1 -> 255 (0xFF)
let tu = ((word >> (lane * 8)) as u8) as i64;
let trit = if tu > 1 { 1 } else if tu == 255 || tu == 0xFF { -1 } else { tu as i8 };
let digit = (trit + 1) as u64;
byte += digit * POW3[lane];
lane += 1;
}
byte
} |
| #640 CROWN #1 of 3 | st_golf_dns_wire_checksum_swar_u64 domain: i1-dns | id: 1afe57bbc6e5Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Cryptographic Mixing, Checksums & Wire Integrity Fast wire-speed packet checksum verification, case-folded label hashing, and frame integrity sealing on network ingress paths. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 86b658a2c9dfC64 RAM: 1069/65536 (1069 B src) | 1515371/100000 cyc/op 1644437/400000 ns/op | 400000000/1644437 ops/us 266 B .text (69 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (1069 B)pub const fn st_golf_dns_wire_checksum_swar_u64(label_word: u64) -> u64 {
const P: u64 = 0x0000_0100_0000_01B3;
let m7f = 0x7F7F_7F7F_7F7F_7F7F;
let low7 = label_word & m7f;
let ge65 = low7 + 0x3F3F_3F3F_3F3F_3F3F;
let gt90 = low7 + 0x2525_2525_2525_2525;
let is_upper = ((ge65 & !gt90 & !label_word) & 0x8080_8080_8080_8080) >> 2;
let w = label_word | is_upper;
let mut fnv: u64 = 0xCBF2_9CE4_8422_2325;
fnv = (fnv ^ (w & 0xFF)).wrapping_mul(P);
fnv = (fnv ^ ((w >> 8) & 0xFF)).wrapping_mul(P);
fnv = (fnv ^ ((w >> 16) & 0xFF)).wrapping_mul(P);
fnv = (fnv ^ ((w >> 24) & 0xFF)).wrapping_mul(P);
fnv = (fnv ^ ((w >> 32) & 0xFF)).wrapping_mul(P);
fnv = (fnv ^ ((w >> 40) & 0xFF)).wrapping_mul(P);
fnv = (fnv ^ ((w >> 48) & 0xFF)).wrapping_mul(P);
fnv = (fnv ^ (w >> 56)).wrapping_mul(P);
let mut s = 0x8B15 + (w & 0xFFFF) + ((w >> 16) & 0xFFFF) + ((w >> 32) & 0xFFFF) + (w >> 48);
s = (s & 0xFFFF) + (s >> 16);
s = (s & 0xFFFF) + (s >> 16);
(fnv & 0xFFFF_FFFF_FFFF_0000) | ((!s) & 0xFFFF)
} |
| #651 PEER of 3 | st_golf_dns_wire_checksum_swar_u64 domain: i1-dns | id: d85983bb6572Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Cryptographic Mixing, Checksums & Wire Integrity Fast wire-speed packet checksum verification, case-folded label hashing, and frame integrity sealing on network ingress paths. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 86b658a2c9dfC64 RAM: 791/65536 (791 B src) | 3028411/200000 cyc/op 410793/100000 ns/op | 100000000/410793 ops/us 266 B .text (69 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (791 B)pub const fn st_golf_dns_wire_checksum_swar_u64(label_word: u64) -> u64 {
let m7f = 0x7F7F_7F7F_7F7F_7F7F;
let low7 = label_word & m7f;
let ge65 = low7 + 0x3F3F_3F3F_3F3F_3F3F;
let gt90 = low7 + 0x2525_2525_2525_2525;
let is_upper = ((ge65 & !gt90 & !label_word) & 0x8080_8080_8080_8080) >> 2;
let w = label_word | is_upper;
let p: u64 = 0x0000_0100_0000_01B3;
let mut fnv: u64 = 0xCBF2_9CE4_8422_2325;
let mut shift: u32 = 0;
while shift < 64 {
fnv = (fnv ^ ((w >> shift) & 0xFF)).wrapping_mul(p);
shift += 8;
}
let mut s = 0x8B15 + (w & 0xFFFF) + ((w >> 16) & 0xFFFF) + ((w >> 32) & 0xFFFF) + (w >> 48);
s = (s & 0xFFFF) + (s >> 16);
s = (s & 0xFFFF) + (s >> 16);
(fnv & 0xFFFF_FFFF_FFFF_0000) | ((!s) & 0xFFFF)
} |
| #1018 CROWN #1 of 4 | st_golf_wa_frame_crc8_gf2_u64 domain: crypto | id: 0d79a70a508eAye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Cryptographic Mixing, Checksums & Wire Integrity Fast wire-speed packet checksum verification, case-folded label hashing, and frame integrity sealing on network ingress paths. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 217128139f57C64 RAM: 877/65536 (877 B src) | 3720449/200000 cyc/op 126171/25000 ns/op | 25000000/126171 ops/us 246 B .text (63 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (877 B)pub const fn st_golf_wa_frame_crc8_gf2_u64(frame: u64) -> u64 {
let s = frame ^ 0x5A;
let ev = s & 0x00FF_00FF_00FF_00FF;
let od = (s >> 8) & 0x00FF_00FF_00FF_00FF;
let t = ev ^ (ev << 1) ^ (ev << 2);
let th = (t >> 8) & 0x0003_0003_0003_0003;
let p = (t ^ th ^ (th << 1) ^ (th << 2) ^ od) & 0x00FF_00FF_00FF_00FF;
let pev = p & 0x0000_00FF_0000_00FF;
let pod = (p >> 16) & 0x0000_00FF_0000_00FF;
let u = pev ^ (pev << 2) ^ (pev << 4);
let uh = (u >> 8) & 0x0000_000F_0000_000F;
let q = (u ^ uh ^ (uh << 1) ^ (uh << 2) ^ pod) & 0x0000_00FF_0000_00FF;
let q0 = q & 0xFF;
let v = (q0 << 1) ^ (q0 << 2) ^ (q0 << 4);
let vh = (v >> 8) & 0xF;
let r = (v ^ vh ^ (vh << 1) ^ (vh << 2) ^ ((q >> 32) & 0xFF)) & 0xFF;
let w = r ^ (r << 1) ^ (r << 2);
let wh = (w >> 8) & 3;
(w ^ wh ^ (wh << 1) ^ (wh << 2)) & 0xFF
} |
| #1082 PEER of 2 | borg_swift_midi_harmonic_step domain: audio | id: f921538ddfdaAye: aye-a6000-prime @ 432Hz | Fixed-Point Audio, Speech & DSP Integer-only digital signal filtering, harmonic resonator stepping, and prosody envelope generation with zero IEEE-754 drift. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: c4e328dd687eC64 RAM: 13/4096 (208 B src) | 3231453/200000 cyc/op 1077151/200000 ns/op | 200000000/1077151 ops/us 35 B .text (10 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (208 B)pub fn borg_swift_midi_harmonic_step(note: u64) -> u64 {
let pitch = (note & 0x7F).wrapping_mul(432);
let vel = ((note >> 8) & 0x7F).wrapping_mul(528);
(pitch.wrapping_add(vel) ^ 0x1B0) & 0xFFFF
} |
| #1191 PEER of 3 | st_golf_b158_bitplane_swar_u64 domain: OneCompression | id: 82481a0614b3Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz | Balanced Ternary & b158 Quantization Separating packed ternary words into positive and negative bitplanes with popcount sparsity tracking for rank-1 quantum-inspired compression. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 2bd431266bfcC64 RAM: 99/8192 (792 B src) | 802421/40000 cyc/op 2177019/400000 ns/op | 400000000/2177019 ops/us 231 B .text (56 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (792 B)pub const fn st_golf_b158_bitplane_swar_u64(trit_word: u64) -> u64 {
const M: u64 = 0x1111_1111_1111_1111;
const GATHER: u64 = 0x0001_0010_0100_1000;
let pos_nib = ((trit_word >> 3) & ((trit_word >> 2) | ((trit_word >> 1) & trit_word))) & M;
let nw = !trit_word;
let neg_nib = ((nw >> 3) & ((nw >> 2) | (nw >> 1))) & M;
let p2 = (pos_nib | (pos_nib >> 3)) & 0x0303_0303_0303_0303;
let p4 = (p2 | (p2 >> 6)) & 0x000F_000F_000F_000F;
let pos_plane = p4.wrapping_mul(GATHER) >> 48;
let n2 = (neg_nib | (neg_nib >> 3)) & 0x0303_0303_0303_0303;
let n4 = (n2 | (n2 >> 6)) & 0x000F_000F_000F_000F;
let neg_plane = n4.wrapping_mul(GATHER) >> 48;
let active = (pos_nib | neg_nib).count_ones() as u64;
(active << 32) | (neg_plane << 16) | pos_plane
} |