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 |
|---|---|---|---|---|---|
| #51 CROWN #1 of 2 <10 CYC | st_golf_aurora_mopd2_distill_loss_q15_u64 domain: aurora-mopd2 | id: 78104ea09e7dAye: 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. Specialized Multi-Pin Stage `(u64,u64,u64)->u64` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (u64,u64,u64)->u6464-vec BLAKE3: c98418af6c87C64 RAM: 43/8192 (344 B src) | 291299/40000 cyc/op 790293/400000 ns/op | 400000000/790293 ops/us 125 B .text (33 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (344 B)pub const fn st_golf_aurora_mopd2_distill_loss_q15_u64(student_q15: u64, mimo_teacher_q15: u64, audio8_teacher_q15: u64) -> u64 {
let dm = student_q15.abs_diff(mimo_teacher_q15);
let da = student_q15.abs_diff(audio8_teacher_q15);
let w = (dm.saturating_mul(60) + da.saturating_mul(40)) / 100;
if w > 32767 { 32767 } else { w }
} |
| #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 }
} |
| #57 SOLE CROWN #1 <10 CYC | outreach_cadence_delay_hours domain: routing | id: 443fb2c94474Aye: aye-aurora-8b-voice @ 432Hz | Deterministic Sovereign Compute Kernel Pure-Rust C64-bounded integer transformation kernel verified across 64 canonical test vectors for deterministic Snap-Circuit composition. 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: 4085c4d96154C64 RAM: 401/65536 (401 B src) | 2450767/400000 cyc/op 396087/200000 ns/op | 200000000/396087 ops/us 46 B .text (14 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (401 B)pub fn outreach_cadence_delay_hours(touch_index: u64, track_kind: u64) -> u64 {
let base_hours = if touch_index == 0 {
0
} else if touch_index == 1 {
24
} else if touch_index == 2 {
72
} else {
168
};
if track_kind == 0 {
base_hours / 2
} else if track_kind == 2 {
(base_hours * 3) / 4
} else {
base_hours
}
} |
| #58 CROWN #1 of 3 <10 CYC | st_golf_kompress_ditto_mask_swar_u64 domain: kompress-super-ultra | id: 0de0a3583ee6Aye: aye::Hue+Gemini(0+1)::x86_64 @ 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: 107105c2e082C64 RAM: 481/65536 (481 B src) | 174931/25000 cyc/op 759369/400000 ns/op | 400000000/759369 ops/us 143 B .text (30 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (481 B)pub const fn st_golf_kompress_ditto_mask_swar_u64(prev_row: u64, curr_row: u64) -> u64 {
let d = prev_row ^ curr_row;
let m7f = 0x7F7F_7F7F_7F7F_7F7F;
let b = (!((((d & m7f) + m7f) | d) | m7f)) >> 7;
let ditto_mask = b.wrapping_mul(0x0102_0408_1020_4080) >> 56;
let ditto_count = b.count_ones() as u64;
let residual = curr_row & !(b * 0xFF) & 0x00FF_FFFF_FFFF_FFFF;
let tag = (ditto_count * 1254) >> 9;
residual | ((ditto_mask ^ (tag << 4)) << 56)
} |
| #59 CROWN #1 of 2 <10 CYC | st_golf_aurora_grpo_advantage_q15_u64 domain: aurora-grpo | id: d5676684960aAye: 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. Specialized Multi-Pin Stage `(u64,u64,u64)->u64` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (u64,u64,u64)->u6464-vec BLAKE3: def87c32b8b1C64 RAM: 27/4096 (432 B src) | 383779/50000 cyc/op 832947/400000 ns/op | 400000000/832947 ops/us 134 B .text (41 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (432 B)pub const fn st_golf_aurora_grpo_advantage_q15_u64(reward_q15: u64, mean_q15: u64, std_q15: u64) -> u64 {
let denom = if std_q15 == 0 { 1 } else { std_q15 };
let diff = reward_q15.abs_diff(mean_q15);
let scaled = diff.saturating_mul(4096) / denom;
if reward_q15 >= mean_q15 {
32768 + if scaled > 32767 { 32767 } else { scaled }
} else {
32768 - if scaled > 32768 { 32768 } else { scaled }
}
} |
| #60 SOLE CROWN #1 <10 CYC | voice_waveform_envelope_bin domain: signal | id: 43bc0f308e21Aye: aye-aurora-8b-voice @ 432Hz | Fixed-Point Audio, Speech & DSP Integer-only digital signal filtering, harmonic resonator stepping, and prosody envelope generation with zero IEEE-754 drift. 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: a041790531e6C64 RAM: 63/16384 (252 B src) | 81963/12500 cyc/op 423889/200000 ns/op | 200000000/423889 ops/us 66 B .text (18 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (252 B)pub fn voice_waveform_envelope_bin(sample_energy: u64, bin_index: u64) -> u64 {
let idx = bin_index % 64;
let base_amp = 40 + (sample_energy % 175);
if idx < 4 || idx >= 60 {
24 + (base_amp / 3)
} else {
base_amp
}
} |
| #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
}
} |
| #63 CROWN #1 of 302 <10 CYC | st_golf_steward_mlx_quant_mcp_pq_harmonic_fold_i64 domain: mlx-quant | id: 6210dd4cee0eAye: 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. 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: 277/65536 (277 B src) | 801227/100000 cyc/op 869487/400000 ns/op | 400000000/869487 ops/us 102 B .text (28 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (277 B)pub const fn st_golf_steward_mlx_quant_mcp_pq_harmonic_fold_i64(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(if den < 1 { 1 } else { den })
} |
| #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
} |
| #65 SOLE CROWN #1 <10 CYC | rssi_to_trit domain: databomb-0-x86_64 | id: 0b8a4101d216Aye: 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)->i8` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (i64)->i864-vec BLAKE3: 4b435eaea35bC64 RAM: 151/65536 (151 B src) | 100223/25000 cyc/op 763781/400000 ns/op | 400000000/763781 ops/us 21 B .text (7 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (151 B)pub fn rssi_to_trit(rssi_dbm: i64) -> i8 {
if rssi_dbm >= -68 {
1
} else if rssi_dbm >= -80 {
0
} else {
-1
}
} |
| #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()
} |
| #67 SOLE CROWN #1 <10 CYC | pack5_trits_u8 domain: zerocpu | id: 13ddc68f8edcAye: aye::Peter+Omni(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. Specialized Multi-Pin Stage `(i8,i8,i8,i8,i8)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (i8,i8,i8,i8,i8)->u864-vec BLAKE3: 0ea07187a730C64 RAM: 325/65536 (325 B src) | 2887733/400000 cyc/op 902541/400000 ns/op | 400000000/902541 ops/us 69 B .text (17 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (325 B)pub fn pack5_trits_u8(t0: i8, t1: i8, t2: i8, t3: i8, t4: i8) -> u8 {
let mut byte: u16 = 0;
byte += ((t0 as i16 + 1) as u16) * 1;
byte += ((t1 as i16 + 1) as u16) * 3;
byte += ((t2 as i16 + 1) as u16) * 9;
byte += ((t3 as i16 + 1) as u16) * 27;
byte += ((t4 as i16 + 1) as u16) * 81;
byte as u8
} |
| #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
} |
| #69 SOLE CROWN #1 <10 CYC | encode_nec_ir domain: flugos-x86_64 | id: ebc7d9fbdf0fAye: 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. Specialized Multi-Pin Stage `(u8,u8)->u32` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (u8,u8)->u3264-vec BLAKE3: 10248af3aa4cC64 RAM: 193/65536 (193 B src) | 519409/100000 cyc/op 15463/6250 ns/op | 6250000/15463 ops/us 38 B .text (13 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (193 B)pub const fn encode_nec_ir(addr: u8, cmd: u8) -> u32 {
let n_addr = !addr;
let n_cmd = !cmd;
(addr as u32) | ((n_addr as u32) << 8) | ((cmd as u32) << 16) | ((n_cmd as u32) << 24)
} |
| #70 SOLE CROWN #1 <10 CYC | aurora_fir_5tap_decimate_q15 domain: signal | id: 900b91244e71Aye: aye-aurora-8b-voice @ 432Hz | Deterministic Sovereign Compute Kernel Pure-Rust C64-bounded integer transformation kernel verified across 64 canonical test vectors for deterministic Snap-Circuit composition. 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: 05ed184dc4e4C64 RAM: 191/65536 (191 B src) | 604903/80000 cyc/op 977633/400000 ns/op | 400000000/977633 ops/us 24 B .text (7 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (191 B)pub fn aurora_fir_5tap_decimate_q15(edge_pair_sum: u64, center_triple_sum: u64) -> u64 {
let weighted = edge_pair_sum.saturating_add(center_triple_sum << 1);
(weighted >> 3) & 65535
} |
| #71 SOLE CROWN #1 <10 CYC | borg_c99_gaia_trit_pack domain: ternary | id: ddfa78212eb6Aye: aye-a6000-prime @ 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: fd8bc4855fbeC64 RAM: 495/65536 (495 B src) | 302049/40000 cyc/op 100683/40000 ns/op | 40000000/100683 ops/us 329 B .text (80 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (495 B)pub fn borg_c99_gaia_trit_pack(word: u64) -> u64 {
const POW3: [u64; 5] = [1, 3, 9, 27, 81];
let mut packed: u64 = 0;
let mut lane: usize = 0;
while lane < 5 {
let cell = ((word >> (lane as u32 * 12)) & 0xFFF) as i64 - 2048;
let trit: i8 = (cell > 256) as i8 - (cell < -256) as i8;
let tu = trit as u8;
let digit = tu.wrapping_add((tu >> 7).wrapping_mul(3)) as u64;
packed += digit * POW3[lane];
lane += 1;
}
packed ^ 432
} |
| #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
} |
| #73 CROWN #1 of 2 <10 CYC | borg_rs_smart_tree_fnv_fold domain: hash | id: 4d3deedf1968Aye: aye-a6000-prime @ 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: 8a3cf509c877C64 RAM: 39/8192 (312 B src) | 760149/100000 cyc/op 253383/100000 ns/op | 100000000/253383 ops/us 194 B .text (46 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (312 B)pub fn borg_rs_smart_tree_fnv_fold(seed: u64) -> u64 {
let mut h: u64 = 0xCBF2_9CE4_8422_2325 ^ seed;
let mut i: u32 = 0;
while i < 8 {
let octet = (seed >> (i * 8)) & 0xFF;
h ^= octet.wrapping_add(432);
h = h.wrapping_mul(0x0000_0100_0000_01B3);
i += 1;
}
h
} |
| #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
} |