How to Optimize Rust for Slowness: Inspired by New Turing Machine Results

Here is the [final function in Python](https://towardsdatascience.com/how-to-optimize-your-python-p...): (Regular Python `int` is arbitrary precision, but immutable, so I use `gmpy2.xmpz` instead.)

    def tetrate(a, tetrate_acc):
        assert is_valid_other(a), "not a valid other"
        assert is_valid_accumulator(tetrate_acc), "not a valid accumulator"
        assert a > 0, "we don't define 0↑↑b"

        exponentiate_acc = xmpz(1)
        for _ in count_down(tetrate_acc):
            multiply_acc = xmpz(1)
            for _ in count_down(exponentiate_acc):
                add_acc = xmpz(0)
                for _ in count_down(multiply_acc):
                    for _ in range(a):
                        add_acc += 1
                multiply_acc = add_acc
            exponentiate_acc = multiply_acc
        return exponentiate_acc

    fn tetrate(a: u32, acc: &mut BigUint) {
        assert!(a > 0, "we don’t define 0↑↑b");

        let mut exp = BigUint::from(1u32);
        for () in acc.count_down() {
            let mut mul = BigUint::from(1u32);
            for () in exp.count_down() {
                let mut add = BigUint::ZERO;
                for () in mul.count_down() {
                    for _ in 0..a {
                        add += 1u32;
                    }
                }
                mul = add;
            }
            exp = mul;
        }
        *acc = exp;
    }

Python version: https://towardsdatascience.com/how-to-optimize-your-python-p...

    If our only goal is to run forever, the solution is immediate:

    ```rs
    fn main() {
        loop {}
    }
    ```

tricky tricky- I think this stops well before 10^^15 due to the limits of 64 bit addressing

Sorry for commenting on the form but that picture is bit too much for me. (Not because how it was produced.)

If you can’t make it useful. It always can be used to write horrible examples hihi

[flagged]