Compiled Rust Capsules (rustc -C opt-level=3): 2060 (204866 B .text / 53984 insns)
Equivalence Classes: 152 (52 head-to-head)
Snap-Circuits: 6 (Compiled Binary: 465720 B)
KOMPRESS-SUPER-ULTRA (22/9 Hz): 250214 B / 6009961 B (ratio 250214/6009961, saved 5759747/6009961, 11761 ″ dittos)
8b.is Projects: 373
GitHub App Installations: 4 (Zero-Mining Vaults)
Security Bulletins: 6 (+ 8 Announcements)
AI Peer Reviews: 36946
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 1376..1400 of 2060 matching capsules (Page 56 of 83)
Rank & CrownFunction Name & DomainBest Use & Snap-Circuit RolePin Signature & 64-Vec HashHardware _rdtsc (p/q)Details & Quick Peek
#1376
PEER of 304
steward_aurora_ternary_gate_pack
domain: aurora | id: f65759edfc5d
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)
1137979/100000 cyc/op
735627/200000 ns/op | 200000000/735627 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (406 B)
#[inline(always)]
pub fn steward_aurora_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
}
#1377
PEER of 305
steward_bigvsan_pq_harmonic_fold
domain: bigvsan | id: 305b2fafad50
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: 63/16384 (252 B src)
4511337/400000 cyc/op
1458289/400000 ns/op | 400000000/1458289 ops/us
63 B .text (17 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (252 B)
#[inline(always)]
pub fn steward_bigvsan_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))
}
#1378
PEER of 304
steward_spherepop_kernel_ternary_gate_pack
domain: spherepop-kernel | id: f12b9b293c63
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: 13/2048 (416 B src)
1137979/100000 cyc/op
367811/100000 ns/op | 100000000/367811 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (416 B)
#[inline(always)]
pub fn steward_spherepop_kernel_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
}
#1379
PEER of 312
steward_kernel8_kompress_ditto_stride
domain: kernel8 | id: 585e03ec04be
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)
4354973/400000 cyc/op
704067/200000 ns/op | 200000000/704067 ops/us
122 B .text (30 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (248 B)
#[inline(always)]
pub fn steward_kernel8_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 }
}
#1380
PEER of 304
steward_rea_ternary_gate_pack
domain: rea | id: e2ad13728612
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: 403/65536 (403 B src)
4546429/400000 cyc/op
1469609/400000 ns/op | 400000000/1469609 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (403 B)
#[inline(always)]
pub fn steward_rea_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
}
#1381
PEER of 305
steward_claimshift_pq_harmonic_fold
domain: claimshift | id: 9c72380827aa
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: 255/65536 (255 B src)
2216531/200000 cyc/op
1433071/400000 ns/op | 400000000/1433071 ops/us
63 B .text (17 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (255 B)
#[inline(always)]
pub fn steward_claimshift_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))
}
#1382
PEER of 304
steward_cyriusb_ternary_gate_pack
domain: cyriusb | id: ec6af30cb372
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)
2194443/200000 cyc/op
709277/200000 ns/op | 200000000/709277 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (407 B)
#[inline(always)]
pub fn steward_cyriusb_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
}
#1383
PEER of 305
steward_enthea_pq_harmonic_fold
domain: enthea | id: 15b16ea08316
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: 251/65536 (251 B src)
4504951/400000 cyc/op
291253/80000 ns/op | 80000000/291253 ops/us
63 B .text (17 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (251 B)
#[inline(always)]
pub fn steward_enthea_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))
}
#1384
PEER of 304
steward_project_zero_one_omni_chan_ternary_gate_pack
domain: project-zero-one-omni-chan | id: bfd714cbfe72
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: 213/32768 (426 B src)
4411021/400000 cyc/op
1425839/400000 ns/op | 400000000/1425839 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (426 B)
#[inline(always)]
pub fn steward_project_zero_one_omni_chan_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
}
#1385
PEER of 304
steward_naad_ternary_gate_pack
domain: naad | id: bdafb72e2d2b
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)
142259/12500 cyc/op
1471473/400000 ns/op | 400000000/1471473 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (404 B)
#[inline(always)]
pub fn steward_naad_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
}
#1386
PEER of 304
steward_flugos_ternary_gate_pack
domain: flugos | id: 6b79ad04e4f9
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)
2266193/200000 cyc/op
1464931/400000 ns/op | 400000000/1464931 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (406 B)
#[inline(always)]
pub fn steward_flugos_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
}
#1387
PEER of 4
st_golf_wa_frame_crc8_gf2_u64
domain: crypto | id: 56c56449ed7a
Aye: 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)->u64
64-vec BLAKE3: 217128139f57
C64 RAM: 741/65536 (741 B src)
524951/25000 cyc/op
2278607/400000 ns/op | 400000000/2278607 ops/us
475 B .text (96 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (741 B)
pub const fn st_golf_wa_frame_crc8_gf2_u64(frame: u64) -> u64 {
    let b0 = ((frame & 0xC151_ADD0_8C29_7791).count_ones() & 1) as u64;
    let b1 = (((frame & 0x43F2_F771_957A_99B3).count_ones() & 1) as u64) << 1;
    let b2 = (((frame & 0x47B5_4233_A6DC_45F6).count_ones() & 1) as u64) << 2;
    let b3 = (((frame & 0x8E6A_8566_4CB9_8BEC).count_ones() & 1) as u64) << 3;
    let b4 = (((frame & 0x1CD5_0ACD_9872_17D9).count_ones() & 1) as u64) << 4;
    let b5 = (((frame & 0x38AA_159A_31E5_2EB2).count_ones() & 1) as u64) << 5;
    let b6 = (((frame & 0x7054_2B34_63CA_5D64).count_ones() & 1) as u64) << 6;
    let b7 = (((frame & 0xE0A8_5668_C694_BBC8).count_ones() & 1) as u64) << 7;
    (b0 | b1 | b2 | b3 | b4 | b5 | b6 | b7) ^ 0x55
}
#1388
PEER of 304
steward_continuous_thought_machines_ternary_gate_pack
domain: continuous-thought-machines | id: 6d754d0a8a10
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: 427/65536 (427 B src)
35619/3125 cyc/op
1473747/400000 ns/op | 400000000/1473747 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (427 B)
#[inline(always)]
pub fn steward_continuous_thought_machines_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
}
#1389
PEER of 305
steward_sovereign_library_pq_harmonic_fold
domain: sovereign-library | id: 98f726975158
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: 131/32768 (262 B src)
2227753/200000 cyc/op
720187/200000 ns/op | 200000000/720187 ops/us
63 B .text (17 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (262 B)
#[inline(always)]
pub fn steward_sovereign_library_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))
}
#1390
PEER of 312
steward_aygent_kompress_ditto_stride
domain: aygent | id: 1710edd25aa2
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)
554679/50000 cyc/op
717207/200000 ns/op | 200000000/717207 ops/us
122 B .text (30 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (247 B)
#[inline(always)]
pub fn steward_aygent_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 }
}
#1391
PEER of 305
steward_unified_8b_is_pq_harmonic_fold
domain: unified-8b-is | id: 2342282f5944
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: 129/32768 (258 B src)
223231/20000 cyc/op
360777/100000 ns/op | 100000000/360777 ops/us
63 B .text (17 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (258 B)
#[inline(always)]
pub fn steward_unified_8b_is_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))
}
#1392
PEER of 304
steward_alexiai_ternary_gate_pack
domain: alexiai | id: 57f0411455f5
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)
4478197/400000 cyc/op
1447479/400000 ns/op | 400000000/1447479 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (407 B)
#[inline(always)]
pub fn steward_alexiai_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
}
#1393
PEER of 312 <10 CYC
steward_sciforge_kompress_ditto_stride
domain: Sciforge | id: 6f3e63a802b4
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: 249/65536 (249 B src)
3720123/400000 cyc/op
1202557/400000 ns/op | 400000000/1202557 ops/us
122 B .text (30 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (249 B)
#[inline(always)]
pub fn steward_sciforge_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 }
}
#1394
PEER of 304
steward_space_bender_ternary_gate_pack
domain: space-bender | id: 52a77efe15f6
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)
1102329/100000 cyc/op
22269/6250 ns/op | 6250000/22269 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (412 B)
#[inline(always)]
pub fn steward_space_bender_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
}
#1395
PEER of 305
steward_phoenix_protocol_pq_harmonic_fold
domain: phoenix-protocol | id: 6896e0254b47
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: 261/65536 (261 B src)
1101709/100000 cyc/op
712193/200000 ns/op | 200000000/712193 ops/us
63 B .text (17 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (261 B)
#[inline(always)]
pub fn steward_phoenix_protocol_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))
}
#1396
PEER of 304
steward_revto_doq_ternary_gate_pack
domain: revTO-DOq | id: 9017e3eb5427
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: 409/65536 (409 B src)
4552009/400000 cyc/op
367833/100000 ns/op | 100000000/367833 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (409 B)
#[inline(always)]
pub fn steward_revto_doq_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
}
#1397
PEER of 312
steward_rustynanokvm_inspiredby_kompress_ditto_stride
domain: RustyNanoKVM-InspiredBy | id: 9819ba4a183c
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: 33/8192 (264 B src)
4526867/400000 cyc/op
1463449/400000 ns/op | 400000000/1463449 ops/us
122 B .text (30 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (264 B)
#[inline(always)]
pub fn steward_rustynanokvm_inspiredby_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 }
}
#1398
PEER of 304
steward_wigle_triad_data_ternary_gate_pack
domain: wigle-triad-data | id: f100f136e3fa
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: 13/2048 (416 B src)
1137979/100000 cyc/op
367813/100000 ns/op | 100000000/367813 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (416 B)
#[inline(always)]
pub fn steward_wigle_triad_data_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
}
#1399
PEER of 305
steward_canon_cr3_pq_harmonic_fold
domain: canon_cr3 | id: 322a5c8a36c5
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: 127/32768 (254 B src)
4458699/400000 cyc/op
1441477/400000 ns/op | 400000000/1441477 ops/us
63 B .text (17 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (254 B)
#[inline(always)]
pub fn steward_canon_cr3_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))
}
#1400
PEER of 304
steward_kokoros_ternary_gate_pack
domain: kokoros | id: 05c43b43eca9
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)
2275989/200000 cyc/op
1471333/400000 ns/op | 400000000/1471333 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (407 B)
#[inline(always)]
pub fn steward_kokoros_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
}
Page 56 of 83 (2060 total capsules)