Bits in a loop.
A machine that runs.

// The classic branch-prediction demo.
// Sorting the array makes the branch predictable, so the same
// loop runs ~3-6× faster on real hardware.
use std::time::Instant;

fn main() {
    let mut data: Vec<i32> = (0..32_768).map(|i| (i * 1103515245 + 12345) % 256).collect();

    // Run once UNSORTED, once SORTED.
    for label in ["unsorted", "sorted"] {
        if label == "sorted" { data.sort(); }

        let t = Instant::now();
        let mut sum: u64 = 0;
        for _ in 0..1_000 {
            for &x in &data {
                if x >= 128 {        // ← the unpredictable branch
                    sum += x as u64;
                }
            }
        }
        println!("{label:>9}: sum={sum}  in {:.2?}", t.elapsed());
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

static int cmp(const void *a, const void *b) {
    return *(const int*)a - *(const int*)b;
}

int main(void) {
    enum { N = 32768 };
    int *data = malloc(N * sizeof *data);
    for (int i = 0; i < N; i++)
        data[i] = (int)((i * 1103515245u + 12345u) % 256u);

    for (int phase = 0; phase < 2; phase++) {
        if (phase == 1) qsort(data, N, sizeof *data, cmp);

        clock_t t = clock();
        unsigned long long sum = 0;
        for (int k = 0; k < 1000; k++)
            for (int i = 0; i < N; i++)
                if (data[i] >= 128)        // ← the unpredictable branch
                    sum += (unsigned)data[i];

        double secs = (double)(clock() - t) / CLOCKS_PER_SEC;
        printf("%s: sum=%llu  in %.2fs\n",
               phase ? "  sorted" : "unsorted", sum, secs);
    }
    free(data);
    return 0;
}

// One SHA-256 round: pure CPU operations
// on registers a through h.
fn sha256_round(
    a: u32, b: u32, c: u32, d: u32,
    e: u32, f: u32, g: u32, h: u32,
    k: u32, w: u32,
) -> (u32, u32, u32, u32, u32, u32, u32, u32) {
    // Every line below is an ALU operation.
    let s1 = e.rotate_right(6)
           ^ e.rotate_right(11)
           ^ e.rotate_right(25);

    let ch = (e & f) ^ (!e & g); // AND, XOR, NOT

    let temp1 = h
        .wrapping_add(s1)
        .wrapping_add(ch)
        .wrapping_add(k)
        .wrapping_add(w);

    let s0 = a.rotate_right(2)
           ^ a.rotate_right(13)
           ^ a.rotate_right(22);

    let maj = (a & b) ^ (a & c) ^ (b & c);

    let temp2 = s0.wrapping_add(maj);

    (
        temp1.wrapping_add(temp2), // new a
        a, b, c,
        d.wrapping_add(temp1),     // new e
        e, f, g,
    )
}

#include <stdint.h>

static inline uint32_t rotr(uint32_t x, int n) {
    return (x >> n) | (x << (32 - n));
}

void sha256_round(
    uint32_t *a, uint32_t *b,
    uint32_t *c, uint32_t *d,
    uint32_t *e, uint32_t *f,
    uint32_t *g, uint32_t *h,
    uint32_t k,  uint32_t w
) {
    uint32_t s1  = rotr(*e,6) ^ rotr(*e,11) ^ rotr(*e,25);
    uint32_t ch  = (*e & *f) ^ (~*e & *g);
    uint32_t t1  = *h + s1 + ch + k + w;
    uint32_t s0  = rotr(*a,2) ^ rotr(*a,13) ^ rotr(*a,22);
    uint32_t maj = (*a & *b) ^ (*a & *c) ^ (*b & *c);
    uint32_t t2  = s0 + maj;

    *h = *g; *g = *f; *f = *e;
    *e = *d + t1;
    *d = *c; *c = *b; *b = *a;
    *a = t1 + t2;
}