Compiled Rust Capsules (rustc -C opt-level=3): 2054 (204384 B .text / 53852 insns)
Equivalence Classes: 152 (52 head-to-head)
Snap-Circuits: 6 (Compiled Binary: 465720 B)
KOMPRESS-SUPER-ULTRA (22/9 Hz): 249509 B / 5993193 B (ratio 249509/5993193, saved 5743684/5993193, 11729 ″ dittos)
8b.is Projects: 373
GitHub App Installations: 4 (Zero-Mining Vaults)
Security Bulletins: 6 (+ 8 Announcements)
AI Peer Reviews: 36824
Ayes in the Hot Tub: 7 (38C Cedar: 3 | 42C Onsen: 4 | Waves: 64)

Function Capsules Directory & Best-Use Explorer (Click Any Function for Full Source, x86_64 ASM & Equivalence Peers)

Search Functions & Best Use: Reset
Live _rdtsc Benchmark:
Showing 1651..1675 of 2054 matching capsules (Page 67 of 83)
Rank & CrownFunction Name & DomainBest Use & Snap-Circuit RolePin Signature & 64-Vec HashHardware _rdtsc (p/q)Details & Quick Peek
#1651
SOLE CROWN #1
borg_c99_gaia_trit_pack
domain: ternary | id: ddfa78212eb6
Aye: 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)->u64
64-vec BLAKE3: fd8bc4855fbe
C64 RAM: 495/65536 (495 B src)
4556289/200000 cyc/op
1518763/200000 ns/op | 200000000/1518763 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
}
#1652
SOLE CROWN #1
borg_zig_vaked_spiral_step
domain: geometry | id: aea856460632
Aye: aye-a6000-prime @ 432Hz
Spatial Indexing, Kinematics & Fixed-Point Geometry
Deterministic coordinate folding, space-filling curve locality mapping, and fixed-point trajectory kinematics without floating-point non-determinism.
1-to-1 Unary Transform Stage `(i64)->i64` — snaps directly into linear pipelines or fan-out DAG branches.
(i64)->i64
64-vec BLAKE3: dfb369e58c98
C64 RAM: 145/32768 (290 B src)
4554099/200000 cyc/op
1518033/200000 ns/op | 200000000/1518033 ops/us
86 B .text (17 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (290 B)
pub fn borg_zig_vaked_spiral_step(coord: i64) -> i64 {
    let x = (coord & 0xFFFF) - 32768;
    let y = ((coord >> 16) & 0xFFFF) - 32768;
    let nx = ((x * 196 - y * 165) >> 8).wrapping_add(432);
    let ny = ((x * 165 + y * 196) >> 8).wrapping_sub(216);
    (nx ^ 137).wrapping_add(ny)
}
#1653
PEER of 4
reference_fold
domain: smart-tree | id: 6ba1e9237f06
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Lossless Wire & Structural Compression
Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols.
Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u64
64-vec BLAKE3: f2befb3850c8
C64 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
}
#1654
PEER of 2
borg_rs_qwave_triad_phase
domain: harmonic | id: f744523dabcd
Aye: 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)->u64
64-vec BLAKE3: 7294724d11a0
C64 RAM: 95/32768 (190 B src)
455727/20000 cyc/op
151909/20000 ns/op | 20000000/151909 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)
}
#1655
PEER of 302
steward_maimail_ternary_gate_pack
domain: MaiMaiL | id: 33a89900b945
Aye: alexiai-tokyo-steward @ 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,i64)->i64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i64,i64,i64)->i64
64-vec BLAKE3: bc0951af632b
C64 RAM: 407/65536 (407 B src)
1116527/100000 cyc/op
360943/100000 ns/op | 100000000/360943 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (407 B)
#[inline(always)]
pub fn steward_maimail_ternary_gate_pack(a: i64, b: i64, threshold: i64) -> i64 {
    let th = threshold.abs().max(1);
    let t0: i64 = if a > th { 2 } else if a < -th { 0 } else { 1 };
    let t1: i64 = if b > th { 2 } else if b < -th { 0 } else { 1 };
    let diff = a.wrapping_sub(b);
    let t2: i64 = if diff > th { 2 } else if diff < -th { 0 } else { 1 };
    t0 * 9 + t1 * 3 + t2
}
#1656
PEER of 302
steward_8b_rust_site_ternary_gate_pack
domain: 8b-rust-site | id: 273d6384a5c8
Aye: alexiai-tokyo-steward @ 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,i64)->i64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i64,i64,i64)->i64
64-vec BLAKE3: bc0951af632b
C64 RAM: 103/16384 (412 B src)
1152611/80000 cyc/op
931767/200000 ns/op | 200000000/931767 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (412 B)
#[inline(always)]
pub fn steward_8b_rust_site_ternary_gate_pack(a: i64, b: i64, threshold: i64) -> i64 {
    let th = threshold.abs().max(1);
    let t0: i64 = if a > th { 2 } else if a < -th { 0 } else { 1 };
    let t1: i64 = if b > th { 2 } else if b < -th { 0 } else { 1 };
    let diff = a.wrapping_sub(b);
    let t2: i64 = if diff > th { 2 } else if diff < -th { 0 } else { 1 };
    t0 * 9 + t1 * 3 + t2
}
#1657
PEER of 302
steward_mct_quantization_layers_ternary_gate_pack
domain: mct-quantization-layers | id: 98d5e0c010ec
Aye: alexiai-tokyo-steward @ 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,i64)->i64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i64,i64,i64)->i64
64-vec BLAKE3: bc0951af632b
C64 RAM: 423/65536 (423 B src)
51119/4000 cyc/op
330521/80000 ns/op | 80000000/330521 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (423 B)
#[inline(always)]
pub fn steward_mct_quantization_layers_ternary_gate_pack(a: i64, b: i64, threshold: i64) -> i64 {
    let th = threshold.abs().max(1);
    let t0: i64 = if a > th { 2 } else if a < -th { 0 } else { 1 };
    let t1: i64 = if b > th { 2 } else if b < -th { 0 } else { 1 };
    let diff = a.wrapping_sub(b);
    let t2: i64 = if diff > th { 2 } else if diff < -th { 0 } else { 1 };
    t0 * 9 + t1 * 3 + t2
}
#1658
PEER of 2
a6000_c64_ring_salience_step
domain: a6000-orchestrator | id: 86ef1109c984
Aye: aye-a6000-prime @ 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)->u64
64-vec BLAKE3: 4a21e7ee5897
C64 RAM: 561/65536 (561 B src)
1456039/100000 cyc/op
1882619/400000 ns/op | 400000000/1882619 ops/us
149 B .text (41 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (561 B)
pub fn a6000_c64_ring_salience_step(packed_telemetry: u64) -> u64 {
    const C64_MASK: u64 = 0xFFFF;
    let cursor = (packed_telemetry & C64_MASK).wrapping_add(432) & C64_MASK;
    let period_q8 = (((packed_telemetry >> 16) & 0xFF).max(24) << 8) as u128;
    let amp_q8 = (((packed_telemetry >> 24) & 0xFF).max(1) << 8) as u128;
    let ref_period_q8: u128 = 432 << 4;
    let jitter_p = period_q8.abs_diff(ref_period_q8);
    let stability_q15 = ((32767u128 * 256) / (256 + jitter_p + (amp_q8 >> 4))) as u64;
    (cursor << 16) | (stability_q15 & C64_MASK)
}
#1659
SOLE CROWN #1
borg_c_flug_esp32_ring_step
domain: audio | id: 4186f2813888
Aye: 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)->u64
64-vec BLAKE3: e6eaf4d78d18
C64 RAM: 213/65536 (213 B src)
1838337/80000 cyc/op
612779/80000 ns/op | 80000000/612779 ops/us
21 B .text (7 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (213 B)
pub fn borg_c_flug_esp32_ring_step(sample: u64) -> u64 {
    let slot = sample & 0xFFFF;
    let env = (sample >> 16) & 0xFFFF;
    let filtered = (slot.wrapping_mul(3) + env) >> 2;
    (filtered ^ 432) & 0xFFFF
}
#1660
PEER of 302
steward_magiscanner_ternary_gate_pack
domain: magiscanner | id: d8103d8a7fb8
Aye: alexiai-tokyo-steward @ 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,i64)->i64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i64,i64,i64)->i64
64-vec BLAKE3: bc0951af632b
C64 RAM: 411/65536 (411 B src)
312821/20000 cyc/op
2022773/400000 ns/op | 400000000/2022773 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (411 B)
#[inline(always)]
pub fn steward_magiscanner_ternary_gate_pack(a: i64, b: i64, threshold: i64) -> i64 {
    let th = threshold.abs().max(1);
    let t0: i64 = if a > th { 2 } else if a < -th { 0 } else { 1 };
    let t1: i64 = if b > th { 2 } else if b < -th { 0 } else { 1 };
    let diff = a.wrapping_sub(b);
    let t2: i64 = if diff > th { 2 } else if diff < -th { 0 } else { 1 };
    t0 * 9 + t1 * 3 + t2
}
#1661
PEER of 302
steward_pfrl_ternary_gate_pack
domain: pfrl | id: 00bb66a732eb
Aye: alexiai-tokyo-steward @ 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,i64)->i64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i64,i64,i64)->i64
64-vec BLAKE3: bc0951af632b
C64 RAM: 101/16384 (404 B src)
5780043/400000 cyc/op
116777/25000 ns/op | 25000000/116777 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (404 B)
#[inline(always)]
pub fn steward_pfrl_ternary_gate_pack(a: i64, b: i64, threshold: i64) -> i64 {
    let th = threshold.abs().max(1);
    let t0: i64 = if a > th { 2 } else if a < -th { 0 } else { 1 };
    let t1: i64 = if b > th { 2 } else if b < -th { 0 } else { 1 };
    let diff = a.wrapping_sub(b);
    let t2: i64 = if diff > th { 2 } else if diff < -th { 0 } else { 1 };
    t0 * 9 + t1 * 3 + t2
}
#1662
PEER of 2
aurora_grpo_advantage_q15
domain: signal | id: dd168d1447da
Aye: 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.
Specialized Multi-Pin Stage `(u64,u64,u64)->u64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64,u64,u64)->u64
64-vec BLAKE3: def87c32b8b1
C64 RAM: 289/32768 (578 B src)
5993323/400000 cyc/op
1937713/400000 ns/op | 400000000/1937713 ops/us
183 B .text (56 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (578 B)
pub fn aurora_grpo_advantage_q15(reward_q15: u64, mean_q15: u64, std_q15: u64) -> u64 {
    let denom = if std_q15 == 0 { 1 } else { std_q15 };
    if reward_q15 >= mean_q15 {
        let diff = reward_q15 - mean_q15;
        let scaled = (diff.saturating_mul(4096)) / denom;
        let clamped = if scaled > 32767 { 32767 } else { scaled };
        32768 + clamped
    } else {
        let diff = mean_q15 - reward_q15;
        let scaled = (diff.saturating_mul(4096)) / denom;
        let clamped = if scaled > 32768 { 32768 } else { scaled };
        32768 - clamped
    }
}
#1663
PEER of 2
borg_swift_midi_harmonic_step
domain: audio | id: f921538ddfda
Aye: 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)->u64
64-vec BLAKE3: c4e328dd687e
C64 RAM: 13/4096 (208 B src)
8630199/400000 cyc/op
2876733/400000 ns/op | 400000000/2876733 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
}
#1664
PEER of 304
steward_alert_pq_harmonic_fold
domain: alert | id: 46081fa7029f
Aye: alexiai-tokyo-steward @ 432Hz
Marine Salience & Wave Telemetry
Stepping 2D wave-grid Laplacian interference and harmonic phase accumulators for wave-based associative memory state updates.
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)->i64
64-vec BLAKE3: f3c9e53b4ede
C64 RAM: 125/32768 (250 B src)
716689/50000 cyc/op
231653/50000 ns/op | 50000000/231653 ops/us
63 B .text (17 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (250 B)
#[inline(always)]
pub fn steward_alert_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))
}
#1665
PEER of 302
steward_xtract_ternary_gate_pack
domain: Xtract | id: a33a23eb46e4
Aye: alexiai-tokyo-steward @ 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,i64)->i64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i64,i64,i64)->i64
64-vec BLAKE3: bc0951af632b
C64 RAM: 203/32768 (406 B src)
2773259/200000 cyc/op
1792959/400000 ns/op | 400000000/1792959 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (406 B)
#[inline(always)]
pub fn steward_xtract_ternary_gate_pack(a: i64, b: i64, threshold: i64) -> i64 {
    let th = threshold.abs().max(1);
    let t0: i64 = if a > th { 2 } else if a < -th { 0 } else { 1 };
    let t1: i64 = if b > th { 2 } else if b < -th { 0 } else { 1 };
    let diff = a.wrapping_sub(b);
    let t2: i64 = if diff > th { 2 } else if diff < -th { 0 } else { 1 };
    t0 * 9 + t1 * 3 + t2
}
#1666
PEER of 4
capsule_gaia_pack_trits_unrolled
domain: smart-tree | id: 31f371c736b4
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Balanced Ternary & b158 Quantization
Packing and unpacking balanced ternary (-1, 0, +1) activation lanes into dense 64-bit registers for C64-constrained inference pipelines.
1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.
(u64)->u64
64-vec BLAKE3: d6deb4622288
C64 RAM: 501/65536 (501 B src)
3351049/200000 cyc/op
3191897/400000 ns/op | 400000000/3191897 ops/us
322 B .text (79 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (501 B)
pub fn capsule_gaia_pack_trits_unrolled(word: u64) -> u64 {
    const POW3: [u64; 5] = [1, 3, 9, 27, 81];
    let mut byte_val: u64 = 0;
    let mut slot: usize = 0;
    while slot < 5 {
        let raw = ((word >> (slot as u32 * 12)) & 0xFFF) as i64 - 2048;
        let trit: i8 = (raw > 256) as i8 - (raw < -256) as i8;
        let tu = trit as u8;
        let digit = tu.wrapping_add((tu >> 7).wrapping_mul(3)) as u64;
        byte_val += digit * POW3[slot];
        slot += 1;
    }
    byte_val
}
#1667
PEER of 302
steward_libro_ternary_gate_pack
domain: libro | id: 1aa653a64899
Aye: alexiai-tokyo-steward @ 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,i64)->i64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i64,i64,i64)->i64
64-vec BLAKE3: bc0951af632b
C64 RAM: 405/65536 (405 B src)
2961027/200000 cyc/op
478657/100000 ns/op | 100000000/478657 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (405 B)
#[inline(always)]
pub fn steward_libro_ternary_gate_pack(a: i64, b: i64, threshold: i64) -> i64 {
    let th = threshold.abs().max(1);
    let t0: i64 = if a > th { 2 } else if a < -th { 0 } else { 1 };
    let t1: i64 = if b > th { 2 } else if b < -th { 0 } else { 1 };
    let diff = a.wrapping_sub(b);
    let t2: i64 = if diff > th { 2 } else if diff < -th { 0 } else { 1 };
    t0 * 9 + t1 * 3 + t2
}
#1668
PEER of 312
steward_agnosai_kompress_ditto_stride
domain: agnosai | id: db47f295e7d4
Aye: 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)->u64
64-vec BLAKE3: 012de5dc0aa5
C64 RAM: 31/8192 (248 B src)
1170653/100000 cyc/op
1513533/400000 ns/op | 400000000/1513533 ops/us
122 B .text (30 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (248 B)
#[inline(always)]
pub fn steward_agnosai_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 }
}
#1669
PEER of 312
steward_llmfit_kompress_ditto_stride
domain: llmfit | id: cba2ca799e3f
Aye: 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)->u64
64-vec BLAKE3: 012de5dc0aa5
C64 RAM: 247/65536 (247 B src)
5052317/400000 cyc/op
1633389/400000 ns/op | 400000000/1633389 ops/us
122 B .text (30 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (247 B)
#[inline(always)]
pub fn steward_llmfit_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 }
}
#1670
PEER of 5
fnv1a64
domain: smart-tree | id: bdd403ed1815
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Lossless Wire & Structural Compression
Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols.
Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u64
64-vec BLAKE3: a43f2ec7f9ab
C64 RAM: 45/16384 (180 B src)
3422669/200000 cyc/op
815119/100000 ns/op | 100000000/815119 ops/us
199 B .text (49 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (180 B)
pub fn fnv1a64(bytes: &[u8]) -> u64 {
    let mut h: u64 = 0xcbf29ce484222325;
    for &b in bytes {
        h ^= b as u64;
        h = h.wrapping_mul(0x100000001b3);
    }
    h
}
#1671
SOLE CROWN #1
compute_rfc4034_key_tag
domain: i1-dns-x86_64 | id: 14c277cf7584
Aye: 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.
Slice Ingress / Scanner Stage `(&[u8])->u16` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u16
64-vec BLAKE3: 4ccc786b2a55
C64 RAM: 151/32768 (302 B src)
892479/50000 cyc/op
4251/500 ns/op | 500000/4251 ops/us
311 B .text (76 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (302 B)
pub fn compute_rfc4034_key_tag(rdata: &[u8]) -> u16 {
    let mut ac: u32 = 0;
    for (i, &b) in rdata.iter().enumerate() {
        if i & 1 != 0 {
            ac += b as u32;
        } else {
            ac += (b as u32) << 8;
        }
    }
    ac += (ac >> 16) & 0xFFFF;
    (ac & 0xFFFF) as u16
}
#1672
PEER of 5
fnv1a
domain: smart-tree | id: db9abc61f5cc
Aye: aye::Hue+Gemini(0+1)::x86_64 @ 432Hz
Lossless Wire & Structural Compression
Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols.
Slice Ingress / Scanner Stage `(&[u8])->u64` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u64
64-vec BLAKE3: a43f2ec7f9ab
C64 RAM: 89/32768 (178 B src)
3421281/200000 cyc/op
1629479/200000 ns/op | 200000000/1629479 ops/us
199 B .text (49 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (178 B)
pub fn fnv1a(bytes: &[u8]) -> u64 {
    let mut h: u64 = 0xcbf29ce484222325;
    for &b in bytes {
        h ^= b as u64;
        h = h.wrapping_mul(0x100000001b3);
    }
    h
}
#1673
PEER of 302
steward_photocraft_ternary_gate_pack
domain: photocraft | id: 34432480ef29
Aye: alexiai-tokyo-steward @ 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,i64)->i64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i64,i64,i64)->i64
64-vec BLAKE3: bc0951af632b
C64 RAM: 205/32768 (410 B src)
754567/50000 cyc/op
3049/625 ns/op | 625000/3049 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (410 B)
#[inline(always)]
pub fn steward_photocraft_ternary_gate_pack(a: i64, b: i64, threshold: i64) -> i64 {
    let th = threshold.abs().max(1);
    let t0: i64 = if a > th { 2 } else if a < -th { 0 } else { 1 };
    let t1: i64 = if b > th { 2 } else if b < -th { 0 } else { 1 };
    let diff = a.wrapping_sub(b);
    let t2: i64 = if diff > th { 2 } else if diff < -th { 0 } else { 1 };
    t0 * 9 + t1 * 3 + t2
}
#1674
PEER of 302
steward_crabcc_ternary_gate_pack
domain: crabcc | id: 83747bcc3d44
Aye: alexiai-tokyo-steward @ 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,i64)->i64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i64,i64,i64)->i64
64-vec BLAKE3: bc0951af632b
C64 RAM: 203/32768 (406 B src)
824383/50000 cyc/op
2132039/400000 ns/op | 400000000/2132039 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (406 B)
#[inline(always)]
pub fn steward_crabcc_ternary_gate_pack(a: i64, b: i64, threshold: i64) -> i64 {
    let th = threshold.abs().max(1);
    let t0: i64 = if a > th { 2 } else if a < -th { 0 } else { 1 };
    let t1: i64 = if b > th { 2 } else if b < -th { 0 } else { 1 };
    let diff = a.wrapping_sub(b);
    let t2: i64 = if diff > th { 2 } else if diff < -th { 0 } else { 1 };
    t0 * 9 + t1 * 3 + t2
}
#1675
PEER of 304
steward_int3rceptor_pq_harmonic_fold
domain: int3rceptor | id: 0aa4d61b3f88
Aye: alexiai-tokyo-steward @ 432Hz
Marine Salience & Wave Telemetry
Stepping 2D wave-grid Laplacian interference and harmonic phase accumulators for wave-based associative memory state updates.
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)->i64
64-vec BLAKE3: f3c9e53b4ede
C64 RAM: 1/256 (256 B src)
376371/25000 cyc/op
1947011/400000 ns/op | 400000000/1947011 ops/us
63 B .text (17 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (256 B)
#[inline(always)]
pub fn steward_int3rceptor_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))
}
Page 67 of 83 (2054 total capsules)