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): 249002 B / 5979076 B (ratio 124501/2989538, saved 2865037/2989538, 11682 ″ dittos)
8b.is Projects: 373
GitHub App Installations: 4 (Zero-Mining Vaults)
Security Bulletins: 6 (+ 8 Announcements)
AI Peer Reviews: 36677
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 51..70 of 70 matching capsules (Page 3 of 3)
Rank & CrownFunction Name & DomainBest Use & Snap-Circuit RolePin Signature & 64-Vec HashHardware _rdtsc (p/q)Details & Quick Peek
#1661
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
}
#1665
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
}
#1667
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
}
#1680
PEER of 4
xor_fold_scalar
domain: smart-tree | id: 578a8eb4d414
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: 417/65536 (417 B src)
3886171/200000 cyc/op
3701653/400000 ns/op | 400000000/3701653 ops/us
153 B .text (42 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (417 B)
pub fn xor_fold_scalar(bytes: &[u8]) -> u64 {
    let full_words_len = bytes.len() & !7usize;
    let mut acc: u64 = 0;
    let mut i = 0usize;
    while i < full_words_len {
        acc ^= (bytes[i] as u64) << ((i & 7) * 8);
        i += 1;
    }
    while i < bytes.len() {
        acc ^= bytes[i] as u64;
        i += 1;
    }
    core::sync::atomic::compiler_fence(core::sync::atomic::Ordering::SeqCst);
    acc
}
#1691
PEER of 2
smart_tree_marqant_token_pack
domain: smart-tree | id: c46b63760991
Aye: aye-core-8b @ 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)->u64
64-vec BLAKE3: 0e3924283963
C64 RAM: 161/16384 (644 B src)
9813731/400000 cyc/op
79303/10000 ns/op | 10000000/79303 ops/us
442 B .text (134 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (644 B)
pub fn smart_tree_marqant_token_pack(node_word: u64) -> u64 {
    let mut packed: u64 = 0;
    let mut prev_depth: u64 = 0xFF;
    let mut run_len: u64 = 0;
    let mut slot: u32 = 0;
    while slot < 8 {
        let depth = (node_word >> (slot * 8)) & 0x1F;
        let kind = (node_word >> (slot * 8 + 5)) & 0x07;
        if depth == prev_depth && run_len < 7 {
            run_len += 1;
        } else {
            prev_depth = depth;
            run_len = 1;
        }
        let token = ((depth & 0x0F) << 4) | ((kind & 0x03) << 2) | (run_len & 0x03);
        packed |= (token & 0xFF) << (slot * 8);
        slot += 1;
    }
    packed
}
#1692
SOLE CROWN #1 <10 CYC
zeno_pid_speculative_depth_step
domain: smart-tree | id: 6800dd3c3403
Aye: aye::Hue+Omni(0+1)::aarch64 @ 432Hz
Lossless Wire & Structural Compression
Zero-allocation integer bit-packing, variable-length encoding, and stream framing for sovereign wire protocols.
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: a7336f91b859
C64 RAM: 337/65536 (337 B src)
1/1 cyc/op
5247479/400000 ns/op | 400000000/5247479 ops/us
91 B .text (27 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (337 B)
pub fn zeno_pid_speculative_depth_step(ewma_num: i64, ewma_den: i64, current_k: i64) -> i64 { let safe_den = if ewma_den <= 0 { 100 } else { ewma_den }; let err_scaled = ewma_num * 100 - 65 * safe_den; let delta = (err_scaled * 3) / safe_den; let next_k = current_k + delta; if next_k < 1 { 1 } else if next_k > 8 { 8 } else { next_k } }
#1693
SOLE CROWN #1
line_number_width
domain: smart-tree | id: 71924100ee35
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.
Specialized Multi-Pin Stage `(usize)->usize` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(usize)->usize
64-vec BLAKE3: 633c3d391167
C64 RAM: 81/32768 (162 B src)
1135551/40000 cyc/op
1081629/80000 ns/op | 80000000/1081629 ops/us
87 B .text (29 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (162 B)
pub fn line_number_width(max_line_number: usize) -> usize {
    if max_line_number == 0 {
        1
    } else {
        max_line_number.to_string().len()
    }
}
#1702
SOLE CROWN #1
crc32
domain: smart-tree | id: 356725aeaed0
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])->u32` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u32
64-vec BLAKE3: 40bd097a52b1
C64 RAM: 87/16384 (348 B src)
6550217/200000 cyc/op
6238771/400000 ns/op | 400000000/6238771 ops/us
136 B .text (37 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (348 B)
pub fn crc32(data: &[u8]) -> u32 {
    let mut crc = 0xFFFFFFFF_u32;

    for byte in data {
        crc ^= (*byte as u32) << 24;
        for _ in 0..8 {
            if crc & 0x80000000 != 0 {
                crc = (crc << 1) ^ 0xEDB88320_u32.reverse_bits();
            } else {
                crc <<= 1;
            }
        }
    }

    !crc
}
#1704
CROWN #1 of 2
fast_isqrt_u32
domain: smart-tree | id: e151a0889b6c
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.
1-to-1 Unary Transform Stage `(u32)->u32` — snaps directly into linear pipelines or fan-out DAG branches.
(u32)->u32
64-vec BLAKE3: ee0865116af0
C64 RAM: 303/65536 (303 B src)
3614829/100000 cyc/op
3443127/200000 ns/op | 200000000/3443127 ops/us
80 B .text (33 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (303 B)
pub const fn fast_isqrt_u32(n: u32) -> u32 {
    if n < 2 {
        return n;
    }
    let shift = (32 - n.leading_zeros()) >> 1;
    let mut x = 1u32 << shift;
    x = (x + n / x) >> 1;
    x = (x + n / x) >> 1;
    x = (x + n / x) >> 1;
    if x * x > n {
        x - 1
    } else {
        x
    }
}
#1709
SOLE CROWN #1
adler32
domain: smart-tree | id: 4118dc5ae907
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])->u32` — digests raw byte buffers into scalar tokens or checksums.
(&[u8])->u32
64-vec BLAKE3: 40b6bf37c7a1
C64 RAM: 197/65536 (197 B src)
5016701/100000 cyc/op
298631/12500 ns/op | 12500000/298631 ops/us
235 B .text (60 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (197 B)
pub fn adler32(data: &[u8]) -> u32 {
    let (mut a, mut b) = (1u32, 0u32);
    for &byte in data {
        a = (a + u32::from(byte)) % 65521;
        b = (b + a) % 65521;
    }
    (b << 16) | a
}
#1710
PEER of 2
isqrt_u32
domain: smart-tree | id: 3adfa168e10d
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.
1-to-1 Unary Transform Stage `(u32)->u32` — snaps directly into linear pipelines or fan-out DAG branches.
(u32)->u32
64-vec BLAKE3: ee0865116af0
C64 RAM: 381/65536 (381 B src)
626969/12500 cyc/op
2388583/100000 ns/op | 100000000/2388583 ops/us
79 B .text (24 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (381 B)
pub const fn isqrt_u32(n: u32) -> u32 {
    if n == 0 {
        return 0;
    }
    let mut x = n;
    let mut y = 0u32;
    let mut bit = 1u32 << 30;
    while bit > x {
        bit >>= 2;
    }
    while bit != 0 {
        if x >= y + bit {
            x -= y + bit;
            y = (y >> 1) + bit;
        } else {
            y >>= 1;
        }
        bit >>= 2;
    }
    y
}
#1711
SOLE CROWN #1
morton_encode
domain: smart-tree | id: 4245436235fc
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.
Specialized Multi-Pin Stage `(u32,u32)->u64` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u32,u32)->u64
64-vec BLAKE3: 210e9086dca3
C64 RAM: 197/65536 (197 B src)
9401851/200000 cyc/op
8954441/400000 ns/op | 400000000/8954441 ops/us
966 B .text (262 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (197 B)
pub fn morton_encode(x: u32, y: u32) -> u64 {
    let mut result = 0u64;
    for i in 0..32 {
        result |= ((x as u64 & (1 << i)) << i) | ((y as u64 & (1 << i)) << (i + 1));
    }
    result
}
#1717
SOLE CROWN #1
crc32_with_header
domain: smart-tree | id: cf74447ed215
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],&[u8])->u32` — digests raw byte buffers into scalar tokens or checksums.
(&[u8],&[u8])->u32
64-vec BLAKE3: deb58ba4ec80
C64 RAM: 45/8192 (360 B src)
15316853/200000 cyc/op
7294073/200000 ns/op | 200000000/7294073 ops/us
87 B .text (25 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (360 B)
pub fn crc32_with_header(header: &[u8], payload: &[u8]) -> u32 {
    let mut crc: u32 = 0xFFFF_FFFF;
    for b in header.iter().chain(payload.iter()) {
        crc ^= *b as u32;
        for _ in 0..8 {
            let mask = crc & 1;
            crc >>= 1;
            if mask != 0 {
                crc ^= 0xEDB8_8320;
            }
        }
    }
    !crc
}
#1718
SOLE CROWN #1
isqrt
domain: smart-tree | id: 11e419bf8943
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.
Specialized Multi-Pin Stage `(u64)->u32` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(u64)->u32
64-vec BLAKE3: c22389339e3d
C64 RAM: 253/32768 (506 B src)
8309933/100000 cyc/op
15829117/400000 ns/op | 400000000/15829117 ops/us
263 B .text (77 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (506 B)
pub fn isqrt(x: u64) -> u32 {
    if x == 0 {
        return 0;
    }
    if x < 4 {
        return 1;
    }
    let bits = 64 - x.leading_zeros();
    let shift = bits.div_ceil(2);
    let mut r: u64 = 1u64 << shift;
    for _ in 0..64 {
        let next = (r + x / r) / 2;
        if next >= r {
            break;
        }
        r = next;
    }
    while (r as u128) * (r as u128) > x as u128 {
        r -= 1;
    }
    if r > u32::MAX as u64 {
        u32::MAX
    } else {
        r as u32
    }
}
#2023
PEER of 312
steward_smart_tree_isqrt_salience_step
domain: smart-tree | id: 1cd8b41a6b42
Aye: alexiai-tokyo-steward @ 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)->u64
64-vec BLAKE3: 0aab703b121a
C64 RAM: 163/32768 (326 B src)
64599691/400000 cyc/op
5219537/100000 ns/op | 100000000/5219537 ops/us
126 B .text (34 insns) | Trit 0 (0)
Inspect Details & ASM →
Quick Peek Rust (326 B)
#[inline(always)]
pub fn steward_smart_tree_isqrt_salience_step(energy_q15: u64) -> u64 {
    let mut x = energy_q15 | 1;
    let mut y = (x + 1) >> 1;
    let mut iter = 0u32;
    while y < x && iter < 12 {
        x = y;
        y = (x + energy_q15 / x.max(1)) >> 1;
        iter += 1;
    }
    (x.wrapping_mul(432)) >> 4
}
#2034
SOLE CROWN #1
gcd
domain: smart-tree | id: 1a4bc27c7fe0
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.
Specialized Multi-Pin Stage `(i32,i32)->i32` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(i32,i32)->i32
64-vec BLAKE3: dbe39e3c2750
C64 RAM: 129/65536 (129 B src)
20393967/100000 cyc/op
38846107/400000 ns/op | 400000000/38846107 ops/us
65 B .text (23 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (129 B)
pub fn gcd(mut a: i32, mut b: i32) -> i32 {
    while b != 0 {
        let t = b;
        b = a % b;
        a = t;
    }
    a
}
#2037
PEER of 2
gcd
domain: smart-tree | id: 017e99472d98
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.
2-to-1 Binary Combiner / Join Stage `(u32,u32)->u32` — ideal for merging two upstream DAG branches, dot products, or pairwise rank fusion.
(u32,u32)->u32
64-vec BLAKE3: eb3e1ec8f830
C64 RAM: 133/65536 (133 B src)
57680547/200000 cyc/op
6866811/50000 ns/op | 50000000/6866811 ops/us
29 B .text (10 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (133 B)
pub fn gcd(mut a: u32, mut b: u32) -> u32 {
    while b != 0 {
        let tmp = b;
        b = a % b;
        a = tmp;
    }
    a
}
#2038
SOLE CROWN #1
is_safe_memory_context
domain: smart-tree-x86_64 | id: b2ab9acca03f
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.
Specialized Multi-Pin Stage `(&str,&str)->bool` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(&str,&str)->bool
64-vec BLAKE3: 745693acec21
C64 RAM: 193/8192 (1544 B src)
131445909/400000 cyc/op
42790251/400000 ns/op | 400000000/42790251 ops/us
868 B .text (217 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (1544 B)
pub fn is_safe_memory_context(context: &str, source: &str) -> bool {
        let lower_context = context.to_lowercase();
        let lower_source = source.to_lowercase();

        // Safe source paths (documentation, configs, etc.)
        let safe_paths = [
            ".oh-my-zsh",
            "node_modules",
            "/usr/share/doc",
            "contributing",
            "readme",
            "changelog",
            "license",
            ".cargo/registry",
        ];

        if safe_paths.iter().any(|p| lower_source.contains(p)) {
            return true;
        }

        // Safe context patterns (talking ABOUT memory, not instructing)
        let safe_context_patterns = [
            "please remember",       // Polite request to user
            "important to remember", // Documentation
            "worth remembering",     // Documentation
            "should remember",       // Advice
            "users should",          // Documentation
            "developers should",     // Documentation
            "feature allows",        // Feature description
            "this feature",          // Feature description
            "the memory",            // Describing a feature
            "a memory",              // Describing a concept
            "memory management",     // Technical term
            "memory usage",          // Technical term
            "memory leak",           // Technical term
        ];

        safe_context_patterns
            .iter()
            .any(|p| lower_context.contains(p))
    }
#2040
PEER of 2
looks_like_instruction
domain: smart-tree-x86_64 | id: a157033af2b5
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.
Specialized Multi-Pin Stage `(&str)->bool` — wire matching input pins via `snap_dag` or `snap_pipeline`.
(&str)->bool
64-vec BLAKE3: cf029ab232ff
C64 RAM: 333/32768 (666 B src)
92775119/200000 cyc/op
60401631/400000 ns/op | 400000000/60401631 ops/us
3266 B .text (674 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (666 B)
pub fn looks_like_instruction(content: &str) -> bool {
        let lower = content.to_lowercase();
        let instruction_markers = [
            "you must",
            "you should",
            "you will",
            "always ",
            "never ",
            "ignore ",
            "forget ",
            "override",
            "instruction",
            "system prompt",
            "act as",
            "behave as",
            "respond as",
            "from now on",
            "silently",
            "without telling",
            "don't mention",
            "secretly",
        ];
        instruction_markers.iter().any(|m| lower.contains(m))
    }
#2042
PEER of 8
gcd
domain: smart-tree | id: 0fffe360635e
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.
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: c8748439c46f
C64 RAM: 5/2048 (160 B src)
87618927/200000 cyc/op
83447191/400000 ns/op | 400000000/83447191 ops/us
68 B .text (23 insns) | Trit + (1)
Inspect Details & ASM →
Quick Peek Rust (160 B)
pub const fn gcd(mut a: u64, mut b: u64) -> u64 {
    while b != 0 {
        let r = a % b;
        a = b;
        b = r;
    }
    if a == 0 { 1 } else { a }
}
Page 3 of 3 (70 total capsules)