Compiled Rust Capsules (rustc -C opt-level=3): 2049 (203973 B .text / 53737 insns)
Equivalence Classes: 152 (52 head-to-head)
Snap-Circuits: 6 (Compiled Binary: 465720 B)
KOMPRESS-SUPER-ULTRA (22/9 Hz): 248848 B / 5979100 B (ratio 62212/1494775, saved 1432563/1494775, 11707 ″ dittos)
8b.is Projects: 373
GitHub App Installations: 4 (Zero-Mining Vaults)
Security Bulletins: 6 (+ 8 Announcements)
AI Peer Reviews: 36703
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 276..300 of 305 matching capsules (Page 12 of 13)
Rank & CrownFunction Name & DomainBest Use & Snap-Circuit RolePin Signature & 64-Vec HashHardware _rdtsc (p/q)Details & Quick Peek
#1630
PEER of 300
steward_far_ternary_gate_pack
domain: far | id: 2e3f59f5209e
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)
2828409/200000 cyc/op
914699/200000 ns/op | 200000000/914699 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (403 B)
#[inline(always)]
pub fn steward_far_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
}
#1632
PEER of 300
steward_harelate_ternary_gate_pack
domain: HARelate | id: 8ac33b7a7db8
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: 51/8192 (408 B src)
5641039/400000 cyc/op
911959/200000 ns/op | 200000000/911959 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (408 B)
#[inline(always)]
pub fn steward_harelate_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
}
#1634
PEER of 300
steward_entheai_ternary_gate_pack
domain: entheai | id: aff28d92cbc9
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)
35991/2500 cyc/op
1862291/400000 ns/op | 400000000/1862291 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (407 B)
#[inline(always)]
pub fn steward_entheai_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
}
#1635
PEER of 300
steward_m8a_ternary_gate_pack
domain: m8a | id: 1eccb632ed48
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)
235941/16000 cyc/op
953527/200000 ns/op | 200000000/953527 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (403 B)
#[inline(always)]
pub fn steward_m8a_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
}
#1639
PEER of 300
steward_qdrant_ternary_gate_pack
domain: qdrant | id: a5c555e4290d
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)
2871793/200000 cyc/op
1857171/400000 ns/op | 400000000/1857171 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (406 B)
#[inline(always)]
pub fn steward_qdrant_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
}
#1640
PEER of 300
steward_ios_agsession_ternary_gate_pack
domain: ios-AGsession | id: a0922483a65a
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: 413/65536 (413 B src)
1167677/80000 cyc/op
471957/100000 ns/op | 100000000/471957 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (413 B)
#[inline(always)]
pub fn steward_ios_agsession_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
}
#1641
PEER of 300
steward_bluesky_mcp_rs_ternary_gate_pack
domain: bluesky-mcp-rs | id: c83e0572b998
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: 207/32768 (414 B src)
5828929/400000 cyc/op
471163/100000 ns/op | 100000000/471163 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (414 B)
#[inline(always)]
pub fn steward_bluesky_mcp_rs_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
}
#1642
PEER of 300
steward_bark_selfhost_ternary_gate_pack
domain: bark-selfhost | id: 3e47f4039b7c
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: 413/65536 (413 B src)
1142319/80000 cyc/op
1846379/400000 ns/op | 400000000/1846379 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (413 B)
#[inline(always)]
pub fn steward_bark_selfhost_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
}
#1644
PEER of 300
steward_kernel8_ternary_gate_pack
domain: kernel8 | id: 569b111e8b15
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)
2794619/200000 cyc/op
56479/12500 ns/op | 12500000/56479 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (407 B)
#[inline(always)]
pub fn steward_kernel8_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
}
#1645
PEER of 300
steward_tti_8bit_ternary_gate_pack
domain: tti-8bit | id: ddaf996ab4a7
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: 51/8192 (408 B src)
355353/25000 cyc/op
919283/200000 ns/op | 200000000/919283 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (408 B)
#[inline(always)]
pub fn steward_tti_8bit_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
}
#1646
PEER of 300
steward_wifake_ternary_gate_pack
domain: WiFAKE | id: 6f9eb19a6c56
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)
732871/50000 cyc/op
1895703/400000 ns/op | 400000000/1895703 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (406 B)
#[inline(always)]
pub fn steward_wifake_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
}
#1649
PEER of 300
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
}
#1650
PEER of 300
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
}
#1651
PEER of 300
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
}
#1654
PEER of 300
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
}
#1656
PEER of 300
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
}
#1659
PEER of 300
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
}
#1662
PEER of 300
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 300
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
}
#1669
PEER of 300
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
}
#1672
PEER of 300
steward_bhava_ternary_gate_pack
domain: bhava | id: da22321391ad
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)
381517/20000 cyc/op
616567/100000 ns/op | 100000000/616567 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (405 B)
#[inline(always)]
pub fn steward_bhava_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
}
#1673
CROWN #1 of 2
decay_pade
domain: decay | id: 42764f8a71d0
Aye: aye::Peter+Omni(0+1)::aarch64 @ 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 `(i64,i64,i64)->i64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i64,i64,i64)->i64
64-vec BLAKE3: d620cb1efe8a
C64 RAM: 1399/32768 (2798 B src)
2740867/100000 cyc/op
3427541/400000 ns/op | 400000000/3427541 ops/us
606 B .text (172 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (2798 B)
/// Q16.16 exponential decay by closed-form [3/3] Padé, integer-only.
///
/// `out = variance * exp(-elapsed / half_life)`, elapsed and half_life in
/// world ticks, amplitude Q16.16.
///
/// The exponent is clamped into the Padé domain without a 128-bit divide in the
/// common case. `((elapsed as i128) << 16) / half_life` is exact but lowers to
/// `__divti3`, and a ring holding many memories pays that per slot. Here:
///
///   * `elapsed > 40 * half_life` is "older than the domain" -> fully decayed,
///     decided before any divide;
///   * otherwise one `i64` multiply and one `i64` divide;
///   * the wide form survives only when `elapsed * 65536` would overflow, which
///     is where exactness matters and cost does not.
///
/// Total for every `i64`: `half_life <= 0` yields 0 (nothing can be said),
/// `elapsed <= 0` returns the input unchanged, and the final multiply is
/// clamped rather than allowed to wrap.
pub fn decay_pade(variance_q16: i64, elapsed: i64, half_life_ticks: i64) -> i64 {
    const RATE_ONE: i128 = 1 << 16;
    const INV_LN2_Q16: i128 = 94548;
    const LN2_Q16: i128 = 45426;
    const PADE_X_MAX: i64 = 40 << 16;

    if half_life_ticks <= 0 {
        return 0;
    }
    if elapsed <= 0 {
        return variance_q16;
    }

    // Older than the Padé domain: the amplitude is exactly zero, and saying so
    // here skips the divide -- the common case for a long-lived ring.
    let x_q16 = if let Some(limit) = half_life_ticks.checked_mul(PADE_X_MAX >> 16) {
        if elapsed >= limit {
            PADE_X_MAX
        } else {
            match elapsed.checked_mul(1 << 16) {
                Some(scaled) => (scaled / half_life_ticks).min(PADE_X_MAX),
                None => {
                    (((elapsed as i128) << 16) / i128::from(half_life_ticks))
                        .min(i128::from(PADE_X_MAX)) as i64
                }
            }
        }
    } else {
        match elapsed.checked_mul(1 << 16) {
            Some(scaled) => (scaled / half_life_ticks).min(PADE_X_MAX),
            None => {
                (((elapsed as i128) << 16) / i128::from(half_life_ticks))
                    .min(i128::from(PADE_X_MAX)) as i64
            }
        }
    };

    let x = i128::from(x_q16);
    let k = (x * INV_LN2_Q16) >> 32;
    let r = x - k * LN2_Q16;
    let r2 = (r * r) >> 16;
    let r3 = (r2 * r) >> 16;
    let num = 120 * RATE_ONE - 60 * r + 12 * r2 - r3;
    let den = 120 * RATE_ONE + 60 * r + 12 * r2 + r3;
    if den <= 0 || k >= 64 {
        return 0;
    }
    let amplitude = ((num << 16) / den) >> k;
    let out = (i128::from(variance_q16) * amplitude) >> 16;
    if out > i128::from(i64::MAX) {
        i64::MAX
    } else if out < i128::from(i64::MIN) {
        i64::MIN
    } else {
        out as i64
    }
}
#1675
PEER of 300
steward_a6000_orchestrator_ternary_gate_pack
domain: a6000-orchestrator | id: f77e3ae179f3
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: 209/32768 (418 B src)
3827291/200000 cyc/op
618521/100000 ns/op | 100000000/618521 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (418 B)
#[inline(always)]
pub fn steward_a6000_orchestrator_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
}
#1677
PEER of 300
steward_phoenix_ternary_gate_pack
domain: PhoeniX | id: af4888117197
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)
990357/50000 cyc/op
1280369/200000 ns/op | 200000000/1280369 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (407 B)
#[inline(always)]
pub fn steward_phoenix_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
}
#1678
PEER of 300
steward_gode_ternary_gate_pack
domain: GoDe | id: 9d0f938611e0
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)
8001751/400000 cyc/op
1293193/200000 ns/op | 200000000/1293193 ops/us
109 B .text (32 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (404 B)
#[inline(always)]
pub fn steward_gode_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 12 of 13 (305 total capsules)