stuff

res/07_weird_assembly_machine.sage

@@ -31,7 +31,7 @@ g = reduce(lambda a, b: a * X + b, [num_to_poly(a) for a in data[128:]])
 
 fg = f(g)
 fgi = Ti([fg[i] for i in range(0, fg.degree())])
-fgj = Tj([fg[j] for i in range(0, fg.degree())])
+fgj = Tj([fg[i] for i in range(0, fg.degree())])
 
 print("\n\n======= f(g(x)) =======")
 for i in reversed(range(0, 64)):

src/bin/07_weird_assembly_machine.rs

@@ -40,30 +40,28 @@ const FG_DATA_EVEN: &[u64] = &[
 
 const FG_DATA_ODD: &[u64] = &[131072, 18446744073709551615];
 
-const N: u64 = 10000069100000000;
+const N: u64 = 10000117800000000;
-const X: u64 = 12686800874197952081;
+const X: u64 = 5905739161907566595;
 
 fn main() {
-    fn do_something(mut n: u64, x: u64) -> u64 {
-        if x <= n {
-            n += 1;
-        }
-        x.wrapping_sub(n)
-    }
-
     compute_async(|tx| {
         let mut n = N;
         let mut x = X;
 
         loop {
             n += 1;
-            x = f(x);
+            x = sub(f(x), n);
-            x = do_something(n, x);
+
-            for _ in 1..100_000_000 {
+            fn foo(n: u64, mut x: u64, k: u64) -> (u64, u64) {
-                x = fg(x);
+                for i in 1..=k {
-                n += 1;
+                    x = sub(fg(x), n + i);
-                x = do_something(n, x);
                 }
+                (n + k, x)
+            }
+
+            (n, x) = foo(n, x, 1_000_000);
+
+
             x = g(x);
 
             tx.send((n, x)).unwrap();
@@ -79,8 +77,28 @@ fn g(x: u64) -> u64 {
     evaluate(x, &DATA[128..], &DATA[128..])
 }
 
+fn add(a: u64, b: u64) -> u64 {
+    let (result, overflow) = a.overflowing_add(b);
+    result + overflow as u64
+}
+
+fn sub(x: u64, mut n: u64) -> u64 {
+    if x <= n {
+        n += 1;
+    }
+    x.wrapping_sub(n)
+}
+
 fn fg(x: u64) -> u64 {
-    evaluate(x, FG_DATA_EVEN, FG_DATA_ODD)
+    !x.rotate_left(17)
+    // evaluate(x, FG_DATA_EVEN, FG_DATA_ODD)
+}
+
+fn fg_n(mut x: u64, n: u64) -> u64 {
+    for _ in 0..n {
+        x = fg(x);
+    }
+    x
 }
 
 fn evaluate(x: u64, data_even: &[u64], data_odd: &[u64]) -> u64 {