From 1cf9fe6f6e345a0991bf6e667f1d621f1067ebde Mon Sep 17 00:00:00 2001
From: Anjali Pal <anjalip@cs.washington.edu>
Date: Mon, 17 Feb 2025 15:42:19 -0800
Subject: [PATCH 01/14] jacobi-1d

---
 .../passing/polybench/stencils/jacobi-1d.rs   | 67 +++++++++++++++++++
 1 file changed, 67 insertions(+)
 create mode 100644 benchmarks/passing/polybench/stencils/jacobi-1d.rs

diff --git a/benchmarks/passing/polybench/stencils/jacobi-1d.rs b/benchmarks/passing/polybench/stencils/jacobi-1d.rs
new file mode 100644
index 000000000..6f776a424
--- /dev/null
+++ b/benchmarks/passing/polybench/stencils/jacobi-1d.rs
@@ -0,0 +1,67 @@
+fn init_array(n: i64, nf: f64, a: &mut [f64; 400], b: &mut [f64; 400]) {
+    let mut i: i64 = 0;
+    let mut fi: f64 = 0.0;
+    while i < n {
+        a[i as usize] = (fi + 2.0) / nf;
+        b[i as usize] = (fi + 3.0) / nf;
+        i += 1;
+        fi += 1.0;
+    }
+}
+
+// Can't print multiple results on nightly
+// fn print_array(n: i64, a: &[f64; 400]) {
+//     let mut i: i64 = 0;
+//     while i < n {
+//         let x: f64 = a[i as usize];
+//         println!("{} ", x);
+//         i += 1;
+//     }
+// }
+
+fn sum_array(n: i64, a: &[f64; 400]) -> f64 {
+    let mut i: i64 = 0;
+    let mut sum: f64 = 0.0;
+    while i < n {
+        sum += a[i as usize];
+        i += 1;
+    }
+    return sum;
+}
+
+fn kernel_jacobi_1d(tsteps: i64, n: i64, a: &mut [f64; 400], b: &mut [f64; 400]) {
+    let mut t: i64 = 0;
+    while t < tsteps {
+        let mut i: i64 = 1;
+        while i < n - 1 {
+            b[i as usize] = 0.33333 * (a[(i - 1) as usize] + a[i as usize] + a[(i + 1) as usize]);
+            i += 1;
+        }
+        i = 1;
+        while i < n - 1 {
+            a[i as usize] = 0.33333 * (b[(i - 1) as usize] + b[i as usize] + b[(i + 1) as usize]);
+            i += 1;
+        }
+        t += 1;
+    }
+}
+
+fn main() {
+    let n: i64 = 400;
+    let nf: f64 = 400.0;
+    let tsteps: i64 = 100;
+
+    let mut a: [f64; 400] = [0.0; 400];
+    let mut b: [f64; 400] = [0.0; 400];
+
+    init_array(n, nf, &mut a, &mut b);
+    kernel_jacobi_1d(tsteps, n, &mut a, &mut b);
+    // print_array(n, &a);
+
+    let res: f64 = sum_array(n, &a);
+
+    drop(a);
+    drop(b);
+
+    println!("{}", res);
+}

From f14da76e7875afa75eb7ff3496593dd1bfb413b4 Mon Sep 17 00:00:00 2001
From: Anjali Pal <anjalip@cs.washington.edu>
Date: Mon, 17 Feb 2025 15:59:53 -0800
Subject: [PATCH 02/14] jacobi-2d

---
 .../passing/polybench/stencils/jacobi-2d.rs   | 118 ++++++++++++++++++
 1 file changed, 118 insertions(+)
 create mode 100644 benchmarks/passing/polybench/stencils/jacobi-2d.rs

diff --git a/benchmarks/passing/polybench/stencils/jacobi-2d.rs b/benchmarks/passing/polybench/stencils/jacobi-2d.rs
new file mode 100644
index 000000000..1625482a2
--- /dev/null
+++ b/benchmarks/passing/polybench/stencils/jacobi-2d.rs
@@ -0,0 +1,118 @@
+fn init_array(n: i64, nf: f64, a: &mut [[f64; 250]; 250], b: &mut [[f64; 250]; 250]) {
+    let mut i: i64 = 0;
+    let mut fi: f64 = 0.0;
+    while i < n {
+        let mut j: i64 = 0;
+        let mut fj: f64 = 0.0;
+        while j < n {
+            a[i as usize][j as usize] = ((fi * (fj + 2.0)) + 2.0) / nf;
+            b[i as usize][j as usize] = ((fi * (fj + 3.0)) + 3.0) / nf;
+            j += 1;
+            fj += 1.0;
+        }
+        i += 1;
+        fi += 1.0;
+    }
+}
+
+fn sum_array(n: i64, a: &[[f64; 250]; 250]) -> f64 {
+    let mut sum: f64 = 0.0;
+    let mut i: i64 = 0;
+    while i < n {
+        let mut j: i64 = 0;
+        while j < n {
+            let x: f64 = a[i as usize][j as usize];
+            sum += x;
+            j += 1;
+        }
+        i += 1;
+    }
+    return sum;
+}
+
+// Can't print on nightly
+// fn print_array(n: i64, a: &[[f64; 250]; 250]) {
+//     let mut i: i64 = 0;
+//     while i < n {
+//         let mut j: i64 = 0;
+//         while j < n {
+//             let x: f64 = a[i as usize][j as usize];
+//             println!("{} ", x);
+//             j += 1;
+//         }
+//         i += 1;
+//     }
+// }
+
+fn kernel_jacobi_2d(tsteps: i64, n: i64, a: &mut [[f64; 250]; 250], b: &mut [[f64; 250]; 250]) {
+    let mut t: i64 = 0;
+    while t < tsteps {
+        let mut i: i64 = 1;
+        while i < n - 1 {
+            let mut j: i64 = 1;
+            while j < n - 1 {
+                b[i as usize][j as usize] = 0.2
+                    * (a[i as usize][j as usize]
+                        + a[i as usize][(j - 1) as usize]
+                        + a[i as usize][(j + 1) as usize]
+                        + a[(i + 1) as usize][j as usize]
+                        + a[(i - 1) as usize][j as usize]);
+                j += 1;
+            }
+            i += 1;
+        }
+
+        i = 1;
+        while i < n - 1 {
+            let mut j: i64 = 1;
+            while j < n - 1 {
+                a[i as usize][j as usize] = 0.2
+                    * (b[i as usize][j as usize]
+                        + b[i as usize][(j - 1) as usize]
+                        + b[i as usize][(j + 1) as usize]
+                        + b[(i + 1) as usize][j as usize]
+                        + b[(i - 1) as usize][j as usize]);
+                j += 1;
+            }
+            i += 1;
+        }
+        t += 1;
+    }
+}
+
+fn main() {
+    let n: i64 = 250;
+    let mut nf: f64 = 250.0;
+    let tsteps: i64 = 100;
+
+    let mut dummy: [f64; 250] = [0.0; 250];
+
+    let mut a: [[f64; 250]; 250] = [dummy; 250];
+    let mut b: [[f64; 250]; 250] = [dummy; 250];
+
+    // Init
+    let mut i: i64 = 0;
+    while i < n {
+        a[i] = [0.0; 250];
+        b[i] = [0.0; 250];
+        i += 1;
+    }
+
+    init_array(n, nf, &mut a, &mut b);
+    kernel_jacobi_2d(tsteps, n, &mut a, &mut b);
+    // print_array(n, &a);
+    let res: f64 = sum_array(n, &a);
+
+    // Drop
+    drop(dummy);
+    i = 0;
+    while i < n {
+        drop(a[i]);
+        drop(b[i]);
+        i += 1;
+    }
+    drop(a);
+    drop(b);
+
+    println!("{}", res);
+}

From df495f76c7cf1bd458f4d23831c0e1020b779267 Mon Sep 17 00:00:00 2001
From: Anjali Pal <anjalip@cs.washington.edu>
Date: Mon, 17 Feb 2025 22:24:27 -0800
Subject: [PATCH 03/14] adi and heat-3d

---
 benchmarks/passing/polybench/stencils/adi.rs  | 126 ++++++++++++++
 .../passing/polybench/stencils/heat-3d.rs     | 157 ++++++++++++++++++
 .../passing/polybench/stencils/jacobi-1d.rs   |  17 +-
 .../passing/polybench/stencils/jacobi-2d.rs   |  18 +-
 4 files changed, 291 insertions(+), 27 deletions(-)
 create mode 100644 benchmarks/passing/polybench/stencils/adi.rs
 create mode 100644 benchmarks/passing/polybench/stencils/heat-3d.rs

diff --git a/benchmarks/passing/polybench/stencils/adi.rs b/benchmarks/passing/polybench/stencils/adi.rs
new file mode 100644
index 000000000..e13123db6
--- /dev/null
+++ b/benchmarks/passing/polybench/stencils/adi.rs
@@ -0,0 +1,126 @@
+fn init_array(n: i64, nf: f64, u: &mut [[f64; 200]; 200]) {
+    let mut i: i64 = 0;
+    let mut fi: f64 = 0.0;
+    while i < n {
+        let mut j: i64 = 0;
+        let mut fj: f64 = 0.0;
+        while j < n {
+            u[i as usize][j as usize] = (fi + (nf - fj)) / nf;
+            j += 1;
+            fj += 1.0;
+        }
+        i += 1;
+        fi += 1.0;
+    }
+}
+
+fn sum_array(n: i64, u: &[[f64; 200]; 200]) -> f64 {
+    let mut sum: f64 = 0.0;
+    let mut i: i64 = 0;
+    while i < n {
+        let mut j: i64 = 0;
+        while j < n {
+            let x: f64 = u[i as usize][j as usize];
+            // Can't print multiple things on nightly.
+            // Uncomment to run locally to check output.
+            // println!("{} ", x);
+            sum += x;
+            j += 1;
+        }
+        i += 1;
+    }
+    return sum;
+}
+
+fn kernel_adi(
+    tsteps: i64,
+    tstepsf: f64,
+    n: i64,
+    nf: f64,
+    u: &mut [[f64; 200]; 200],
+    v: &mut [[f64; 200]; 200],
+    p: &mut [[f64; 200]; 200],
+    q: &mut [[f64; 200]; 200],
+) {
+    let dx: f64 = 1.0 / nf;
+    let dy: f64 = 1.0 / nf;
+    let dt: f64 = 1.0 / tstepsf;
+    let b1: f64 = 2.0;
+    let b2: f64 = 1.0;
+    let mul1: f64 = b1 * dt / (dx * dx);
+    let mul2: f64 = b2 * dt / (dy * dy);
+
+    let a: f64 = -mul1 / 2.0;
+    let b: f64 = 1.0 + mul1;
+    let c: f64 = a;
+    let d: f64 = -mul2 / 2.0;
+    let e: f64 = 1.0 + mul2;
+    let f: f64 = d;
+
+    let mut t: i64 = 1;
+    while t <= tsteps {
+        let mut i: i64 = 1;
+        while i < n - 1 {
+            v[0][i as usize] = 1.0;
+            p[i as usize][0] = 0.0;
+            q[i as usize][0] = v[0][i as usize];
+            let mut j: i64 = 1;
+            while j < n - 1 {
+                p[i as usize][j as usize] = -c / (a * p[i as usize][(j - 1) as usize] + b);
+                q[i as usize][j as usize] = (-d * u[j as usize][(i - 1) as usize]
+                    + (1.0 + 2.0 * d) * u[j as usize][i as usize]
+                    - f * u[j as usize][(i + 1) as usize]
+                    - a * q[i as usize][(j - 1) as usize])
+                    / (a * p[i as usize][(j - 1) as usize] + b);
+                j += 1;
+            }
+            i += 1;
+        }
+        t += 1;
+    }
+}
+
+fn main() {
+    let n: i64 = 200;
+    let nf: f64 = 200.0;
+    let tsteps: i64 = 100;
+    let tstepsf: f64 = 100.0;
+
+    let mut dummy: [f64; 200] = [0.0; 200];
+
+    let mut u: [[f64; 200]; 200] = [dummy; 200];
+    let mut v: [[f64; 200]; 200] = [dummy; 200];
+    let mut p: [[f64; 200]; 200] = [dummy; 200];
+    let mut q: [[f64; 200]; 200] = [dummy; 200];
+
+    // Init
+    let mut i: i64 = 0;
+    while i < n {
+        u[i] = [0.0; 200];
+        v[i] = [0.0; 200];
+        p[i] = [0.0; 200];
+        q[i] = [0.0; 200];
+        i += 1;
+    }
+
+    init_array(n, nf, &mut u);
+    kernel_adi(tsteps, tstepsf, n, nf, &mut u, &mut v, &mut p, &mut q);
+    let res: f64 = sum_array(n, &u);
+
+    // Drop
+    drop(dummy);
+    i = 0;
+    while i < n {
+        drop(u[i]);
+        drop(v[i]);
+        drop(p[i]);
+        drop(q[i]);
+        i += 1;
+    }
+    drop(u);
+    drop(v);
+    drop(p);
+    drop(q);
+
+    println!("{}", res);
+}
diff --git a/benchmarks/passing/polybench/stencils/heat-3d.rs b/benchmarks/passing/polybench/stencils/heat-3d.rs
new file mode 100644
index 000000000..9f9732193
--- /dev/null
+++ b/benchmarks/passing/polybench/stencils/heat-3d.rs
@@ -0,0 +1,157 @@
+fn init_array(n: i64, nf: f64, a: &mut [[[f64; 40]; 40]; 40], b: &mut [[[f64; 40]; 40]; 40]) {
+    let mut i: i64 = 0;
+    let mut fi: f64 = 0.0;
+    while i < n {
+        let mut j: i64 = 0;
+        let mut fj: f64 = 0.0;
+        while j < n {
+            let mut k: i64 = 0;
+            let mut fk: f64 = 0.0;
+            while k < n {
+                a[i as usize][j as usize][k as usize] = (fi + fj + (nf - fk)) * 10.0 / nf;
+                b[i as usize][j as usize][k as usize] = a[i as usize][j as usize][k as usize];
+                k += 1;
+                fk += 1.0;
+            }
+            j += 1;
+            fj += 1.0;
+        }
+        i += 1;
+        fi += 1.0;
+    }
+}
+
+fn sum_array(n: i64, a: &[[[f64; 40]; 40]; 40]) -> f64 {
+    let mut sum: f64 = 0.0;
+    let mut i: i64 = 0;
+    while i < n {
+        let mut j: i64 = 0;
+        while j < n {
+            let mut k: i64 = 0;
+            while k < n {
+                let x: f64 = a[i as usize][j as usize][k as usize];
+                // Can't print multiple things on nightly.
+                // Uncomment to run locally to check output.
+                // println!("{} ", x);
+                sum += x;
+                k += 1;
+            }
+            j += 1;
+        }
+        i += 1;
+    }
+    return sum;
+}
+
+fn kernel_heat_3d(
+    tsteps: i64,
+    n: i64,
+    a: &mut [[[f64; 40]; 40]; 40],
+    b: &mut [[[f64; 40]; 40]; 40],
+) {
+    let mut t: i64 = 1;
+    while t <= tsteps {
+        let mut i: i64 = 1;
+        while i < n - 1 {
+            let mut j: i64 = 1;
+            while j < n - 1 {
+                let mut k: i64 = 1;
+                while k < n - 1 {
+                    b[i as usize][j as usize][k as usize] = 0.125
+                        * (a[(i + 1) as usize][j as usize][k as usize]
+                            - 2.0 * a[i as usize][j as usize][k as usize]
+                            + a[(i - 1) as usize][j as usize][k as usize])
+                        + 0.125
+                            * (a[i as usize][(j + 1) as usize][k as usize]
+                                - 2.0 * a[i as usize][j as usize][k as usize]
+                                + a[i as usize][(j - 1) as usize][k as usize])
+                        + 0.125
+                            * (a[i as usize][j as usize][(k + 1) as usize]
+                                - 2.0 * a[i as usize][j as usize][k as usize]
+                                + a[i as usize][j as usize][(k - 1) as usize])
+                        + a[i as usize][j as usize][k as usize];
+                    k += 1;
+                }
+                j += 1;
+            }
+            i += 1;
+        }
+
+        i = 1;
+        while i < n - 1 {
+            let mut j: i64 = 1;
+            while j < n - 1 {
+                let mut k: i64 = 1;
+                while k < n - 1 {
+                    a[i as usize][j as usize][k as usize] = 0.125
+                        * (b[(i + 1) as usize][j as usize][k as usize]
+                            - 2.0 * b[i as usize][j as usize][k as usize]
+                            + b[(i - 1) as usize][j as usize][k as usize])
+                        + 0.125
+                            * (b[i as usize][(j + 1) as usize][k as usize]
+                                - 2.0 * b[i as usize][j as usize][k as usize]
+                                + b[i as usize][(j - 1) as usize][k as usize])
+                        + 0.125
+                            * (b[i as usize][j as usize][(k + 1) as usize]
+                                - 2.0 * b[i as usize][j as usize][k as usize]
+                                + b[i as usize][j as usize][(k - 1) as usize])
+                        + b[i as usize][j as usize][k as usize];
+                    k += 1;
+                }
+                j += 1;
+            }
+            i += 1;
+        }
+        t += 1;
+    }
+}
+
+fn main() {
+    let n: i64 = 40;
+    let nf: f64 = 40.0;
+    let tsteps: i64 = 400;
+
+    let inner_dummy: [f64; 40] = [0.0; 40];
+    let dummy: [[f64; 40]; 40] = [inner_dummy; 40];
+    let mut a: [[[f64; 40]; 40]; 40] = [dummy; 40];
+    let mut b: [[[f64; 40]; 40]; 40] = [dummy; 40];
+
+    let mut i: i64 = 0;
+    while i < n {
+        let a_elt: [[f64; 40]; 40] = [inner_dummy; 40];
+        let b_elt: [[f64; 40]; 40] = [inner_dummy; 40];
+        let mut j: i64 = 0;
+        while j < n {
+            a_elt[j] = [0.0; 40];
+            b_elt[j] = [0.0; 40];
+            j += 1;
+        }
+        a[i] = a_elt;
+        b[i] = b_elt;
+        i += 1;
+    }
+
+    init_array(n, nf, &mut a, &mut b);
+    kernel_heat_3d(tsteps, n, &mut a, &mut b);
+    let res: f64 = sum_array(n, &a);
+
+    // Drop
+    drop(inner_dummy);
+    drop(dummy);
+    i = 0;
+    while i < n {
+        j = 0;
+        while j < n {
+            drop(a[i][j]);
+            drop(b[i][j]);
+            j += 1;
+        }
+        drop(a[i]);
+        drop(b[i]);
+        i += 1;
+    }
+    drop(a);
+    drop(b);
+
+    println!("{}", res);
+}
diff --git a/benchmarks/passing/polybench/stencils/jacobi-1d.rs b/benchmarks/passing/polybench/stencils/jacobi-1d.rs
index 6f776a424..399e3bb21 100644
--- a/benchmarks/passing/polybench/stencils/jacobi-1d.rs
+++ b/benchmarks/passing/polybench/stencils/jacobi-1d.rs
@@ -9,21 +9,15 @@ fn init_array(n: i64, nf: f64, a: &mut [f64; 400], b: &mut [f64; 400]) {
     }
 }
 
-// Can't print multiple results on nightly
-// fn print_array(n: i64, a: &[f64; 400]) {
-//     let mut i: i64 = 0;
-//     while i < n {
-//         let x: f64 = a[i as usize];
-//         println!("{} ", x);
-//         i += 1;
-//     }
-// }
-
 fn sum_array(n: i64, a: &[f64; 400]) -> f64 {
     let mut i: i64 = 0;
     let mut sum: f64 = 0.0;
     while i < n {
-        sum += a[i as usize];
+        let x: f64 = a[i as usize];
+        // Can't print multiple things on nightly.
+        // Uncomment to run locally to check output.
+        // println!("{} ", x);
+        sum += x;
         i += 1;
     }
     return sum;
@@ -56,7 +50,6 @@ fn main() {
 
     init_array(n, nf, &mut a, &mut b);
     kernel_jacobi_1d(tsteps, n, &mut a, &mut b);
-    // print_array(n, &a);
 
     let res: f64 = sum_array(n, &a);
 
diff --git a/benchmarks/passing/polybench/stencils/jacobi-2d.rs b/benchmarks/passing/polybench/stencils/jacobi-2d.rs
index 1625482a2..aa2c2c9c6 100644
--- a/benchmarks/passing/polybench/stencils/jacobi-2d.rs
+++ b/benchmarks/passing/polybench/stencils/jacobi-2d.rs
@@ -22,6 +22,9 @@ fn sum_array(n: i64, a: &[[f64; 250]; 250]) -> f64 {
         let mut j: i64 = 0;
         while j < n {
             let x: f64 = a[i as usize][j as usize];
+            // Can't print multiple things on nightly.
+            // Uncomment to run locally to check output.
+            // println!("{} ", x);
             sum += x;
             j += 1;
         }
@@ -30,20 +33,6 @@ fn sum_array(n: i64, a: &[[f64; 250]; 250]) -> f64 {
     return sum;
 }
 
-// Can't print on nightly
-// fn print_array(n: i64, a: &[[f64; 250]; 250]) {
-//     let mut i: i64 = 0;
-//     while i < n {
-//         let mut j: i64 = 0;
-//         while j < n {
-//             let x: f64 = a[i as usize][j as usize];
-//             println!("{} ", x);
-//             j += 1;
-//         }
-//         i += 1;
-//     }
-// }
-
 fn kernel_jacobi_2d(tsteps: i64, n: i64, a: &mut [[f64; 250]; 250], b: &mut [[f64; 250]; 250]) {
     let mut t: i64 = 0;
     while t < tsteps {
@@ -100,7 +89,6 @@ fn main() {
 
     init_array(n, nf, &mut a, &mut b);
     kernel_jacobi_2d(tsteps, n, &mut a, &mut b);
-    // print_array(n, &a);
     let res: f64 = sum_array(n, &a);
 
     // Drop

From 7e41cbf1f02579b49be7ffd4cd21363d417f04a1 Mon Sep 17 00:00:00 2001
From: Anjali Pal <anjalip@cs.washington.edu>
Date: Tue, 18 Feb 2025 09:55:26 -0800
Subject: [PATCH 04/14] Create seidel-2d.rs

---
 .../passing/polybench/stencils/seidel-2d.rs   | 89 +++++++++++++++++++
 1 file changed, 89 insertions(+)
 create mode 100644 benchmarks/passing/polybench/stencils/seidel-2d.rs

diff --git a/benchmarks/passing/polybench/stencils/seidel-2d.rs b/benchmarks/passing/polybench/stencils/seidel-2d.rs
new file mode 100644
index 000000000..4a48e5fa5
--- /dev/null
+++ b/benchmarks/passing/polybench/stencils/seidel-2d.rs
@@ -0,0 +1,89 @@
+fn init_array(n: i64, nf: f64, a: &mut [[f64; 400]; 400]) {
+    let mut i: i64 = 0;
+    let mut fi: f64 = 0.0;
+    while i < n {
+        let mut j: i64 = 0;
+        let mut fj: f64 = 0.0;
+        while j < n {
+            a[i as usize][j as usize] = (fi * (fj + 2.0) + 2.0) / nf;
+            j += 1;
+            fj += 1.0;
+        }
+        i += 1;
+        fi += 1.0;
+    }
+}
+
+fn sum_array(n: i64, a: &[[f64; 400]; 400]) -> f64 {
+    let mut sum: f64 = 0.0;
+    let mut i: i64 = 0;
+    while i < n {
+        let mut j: i64 = 0;
+        while j < n {
+            let x: f64 = a[i as usize][j as usize];
+            // Can't print multiple things on nightly.
+            // Uncomment to run locally to check output.
+            // println!("{} ", x);
+            sum += x;
+            j += 1;
+        }
+        i += 1;
+    }
+    return sum;
+}
+
+fn kernel_seidel_2d(tsteps: i64, n: i64, a: &mut [[f64; 400]; 400]) {
+    let mut t: i64 = 0;
+    while t < tsteps {
+        let mut i: i64 = 1;
+        while i < n - 1 {
+            let mut j: i64 = 1;
+            while j < n - 1 {
+                a[i as usize][j as usize] = (a[(i - 1) as usize][(j - 1) as usize]
+                    + a[(i - 1) as usize][j as usize]
+                    + a[(i - 1) as usize][(j + 1) as usize]
+                    + a[i as usize][(j - 1) as usize]
+                    + a[i as usize][j as usize]
+                    + a[i as usize][(j + 1) as usize]
+                    + a[(i + 1) as usize][(j - 1) as usize]
+                    + a[(i + 1) as usize][j as usize]
+                    + a[(i + 1) as usize][(j + 1) as usize])
+                    / 9.0;
+                j += 1;
+            }
+            i += 1;
+        }
+        t += 1;
+    }
+}
+
+fn main() {
+    let n: i64 = 400;
+    let nf: f64 = 400.0;
+    let tsteps: i64 = 100;
+
+    let dummy: [f64; 400] = [0.0; 400];
+    let mut a: [[f64; 400]; 400] = [dummy; 400];
+
+    // Init
+    let mut i: i64 = 0;
+    while i < n {
+        a[i] = [0.0; 400];
+        i += 1;
+    }
+    drop(dummy);
+
+    init_array(n, nf, &mut a);
+    kernel_seidel_2d(tsteps, n, &mut a);
+    let res: f64 = sum_array(n, &a);
+
+    // Drop
+    i = 0;
+    while i < n {
+        drop(a[i]);
+        i += 1;
+    }
+    drop(a);
+
+    println!("{}", res);
+}

From 31f6382462766df12bfc3e4699efa60ecc4624dd Mon Sep 17 00:00:00 2001
From: Anjali Pal <anjalip@cs.washington.edu>
Date: Tue, 18 Feb 2025 21:41:39 -0800
Subject: [PATCH 05/14] Create floyd-warshall.rs

---
 .../polybench/medley/floyd-warshall.rs        | 85 +++++++++++++++++++
 1 file changed, 85 insertions(+)
 create mode 100644 benchmarks/passing/polybench/medley/floyd-warshall.rs

diff --git a/benchmarks/passing/polybench/medley/floyd-warshall.rs b/benchmarks/passing/polybench/medley/floyd-warshall.rs
new file mode 100644
index 000000000..7f8cff4e2
--- /dev/null
+++ b/benchmarks/passing/polybench/medley/floyd-warshall.rs
@@ -0,0 +1,85 @@
+fn modulo(a: i64, b: i64) -> i64 {
+    let div: i64 = a / b; // Integer division
+    let remainder: i64 = a - (div * b); // Compute remainder manually
+    if remainder < 0 {
+        return remainder + b; // Ensure non-negative result
+    } else {
+        return remainder;
+    }
+}
+
+fn init_array(n: i64, path: &mut [[i64; 500]; 500]) {
+    let mut i: i64 = 0;
+    while i < n {
+        let mut j: i64 = 0;
+        while j < n {
+            path[i as usize][j as usize] = modulo(i * j, 7) + 1;
+            if modulo(i + j, 13) == 0 || modulo(i + j, 7) == 0 || modulo(i + j, 11) == 0 {
+                path[i as usize][j as usize] = 999;
+            }
+            j += 1;
+        }
+        i += 1;
+    }
+}
+
+fn print_array(n: i64, path: &[[i64; 500]; 500]) {
+    let mut i: i64 = 0;
+    while i < n {
+        let mut j: i64 = 0;
+        while j < n {
+            let x: i64 = path[i as usize][j as usize];
+            println!("{} ", x);
+            j += 1;
+        }
+        i += 1;
+    }
+}
+
+fn kernel_floyd_warshall(n: i64, path: &mut [[i64; 500]; 500]) {
+    let mut k: i64 = 0;
+    while k < n {
+        let mut i: i64 = 0;
+        while i < n {
+            let mut j: i64 = 0;
+            while j < n {
+                if path[i as usize][j as usize]
+                    > path[i as usize][k as usize] + path[k as usize][j as usize]
+                {
+                    path[i as usize][j as usize] =
+                        path[i as usize][k as usize] + path[k as usize][j as usize];
+                }
+                j += 1;
+            }
+            i += 1;
+        }
+        k += 1;
+    }
+}
+
+fn main() {
+    let n: i64 = 500;
+
+    let dummy: [i64; 500] = [0; 500];
+    let mut path: [[i64; 500]; 500] = [dummy; 500];
+
+    // Init
+    let mut i: i64 = 0;
+    while i < n {
+        path[i] = [0; 500];
+        i += 1;
+    }
+    drop(dummy);
+
+    init_array(n, &mut path);
+    kernel_floyd_warshall(n, &mut path);
+    print_array(n, &path);
+
+    // Drop
+    i = 0;
+    while i < n {
+        drop(path[i]);
+        i += 1;
+    }
+    drop(path);
+}

From cd4e3f0c53b0b0bdae72d11375088a092d5cba41 Mon Sep 17 00:00:00 2001
From: Anjali Pal <anjalip@cs.washington.edu>
Date: Tue, 18 Feb 2025 21:53:15 -0800
Subject: [PATCH 06/14] Nussinov

---
 .../polybench/medley/floyd-warshall.rs        |  13 +-
 .../passing/polybench/medley/nussinov.rs      | 136 ++++++++++++++++++
 res/nussinov.out                              |   1 +
 3 files changed, 147 insertions(+), 3 deletions(-)
 create mode 100644 benchmarks/passing/polybench/medley/nussinov.rs
 create mode 100644 res/nussinov.out

diff --git a/benchmarks/passing/polybench/medley/floyd-warshall.rs b/benchmarks/passing/polybench/medley/floyd-warshall.rs
index 7f8cff4e2..9d3f96285 100644
--- a/benchmarks/passing/polybench/medley/floyd-warshall.rs
+++ b/benchmarks/passing/polybench/medley/floyd-warshall.rs
@@ -23,17 +23,22 @@ fn init_array(n: i64, path: &mut [[i64; 500]; 500]) {
     }
 }
 
-fn print_array(n: i64, path: &[[i64; 500]; 500]) {
+fn sum_array(n: i64, path: &[[i64; 500]; 500]) -> i64 {
+    let mut sum: i64 = 0;
     let mut i: i64 = 0;
     while i < n {
         let mut j: i64 = 0;
         while j < n {
             let x: i64 = path[i as usize][j as usize];
-            println!("{} ", x);
+            // Can't print multiple things on nightly.
+            // Uncomment to run locally to check output.
+            // println!("{} ", x);
+            sum += x;
             j += 1;
         }
         i += 1;
     }
+    return sum;
 }
 
 fn kernel_floyd_warshall(n: i64, path: &mut [[i64; 500]; 500]) {
@@ -73,7 +78,7 @@ fn main() {
 
     init_array(n, &mut path);
     kernel_floyd_warshall(n, &mut path);
-    print_array(n, &path);
+    let res: i64 = sum_array(n, &path);
 
     // Drop
     i = 0;
@@ -82,4 +87,6 @@ fn main() {
         i += 1;
     }
     drop(path);
+
+    println!("{}", res);
 }
diff --git a/benchmarks/passing/polybench/medley/nussinov.rs b/benchmarks/passing/polybench/medley/nussinov.rs
new file mode 100644
index 000000000..8d614fbf8
--- /dev/null
+++ b/benchmarks/passing/polybench/medley/nussinov.rs
@@ -0,0 +1,136 @@
+fn modulo(a: i64, b: i64) -> i64 {
+    let div: i64 = a / b; // Integer division
+    let remainder: i64 = a - (div * b); // Compute remainder manually
+    if remainder < 0 {
+        return remainder + b; // Ensure non-negative result
+    } else {
+        return remainder;
+    }
+}
+
+fn max_score(s1: i64, s2: i64) -> i64 {
+    if s1 >= s2 {
+        return s1;
+    } else {
+        return s2;
+    }
+}
+
+fn match_base(b1: i64, b2: i64) -> i64 {
+    if (b1 + b2) == 3 {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+fn init_array(n: i64, seq: &mut [i64; 500], table: &mut [[i64; 500]; 500]) {
+    let mut i: i64 = 0;
+    while i < n {
+        seq[i as usize] = modulo(i + 1, 4);
+        i += 1;
+    }
+
+    i = 0;
+    while i < n {
+        let mut j: i64 = 0;
+        while j < n {
+            table[i as usize][j as usize] = 0;
+            j += 1;
+        }
+        i += 1;
+    }
+}
+
+fn sum_array(n: i64, table: &[[i64; 500]; 500]) -> i64 {
+    let mut sum: i64 = 0;
+    let mut i: i64 = 0;
+    while i < n {
+        let mut j: i64 = i;
+        while j < n {
+            let x: i64 = table[i as usize][j as usize];
+            // Can't print multiple things on nightly.
+            // Uncomment to run locally to check output.
+            // println!("{} ", x);
+            sum += x;
+            j += 1;
+        }
+        i += 1;
+    }
+    return sum;
+}
+
+fn kernel_nussinov(n: i64, seq: &mut [i64; 500], table: &mut [[i64; 500]; 500]) {
+    let mut i: i64 = n - 1;
+    while i >= 0 {
+        let mut j: i64 = i + 1;
+        while j < n {
+            if j - 1 >= 0 {
+                table[i as usize][j as usize] = max_score(
+                    table[i as usize][j as usize],
+                    table[i as usize][(j - 1) as usize],
+                );
+            }
+            if i + 1 < n {
+                table[i as usize][j as usize] = max_score(
+                    table[i as usize][j as usize],
+                    table[(i + 1) as usize][j as usize],
+                );
+            }
+            if j - 1 >= 0 && i + 1 < n {
+                if i < j - 1 {
+                    table[i as usize][j as usize] = max_score(
+                        table[i as usize][j as usize],
+                        table[(i + 1) as usize][(j - 1) as usize]
+                            + match_base(seq[i as usize], seq[j as usize]),
+                    );
+                } else {
+                    table[i as usize][j as usize] = max_score(
+                        table[i as usize][j as usize],
+                        table[(i + 1) as usize][(j - 1) as usize],
+                    );
+                }
+            }
+            let mut k: i64 = i + 1;
+            while k < j {
+                table[i as usize][j as usize] = max_score(
+                    table[i as usize][j as usize],
+                    table[i as usize][k as usize] + table[(k + 1) as usize][j as usize],
+                );
+                k += 1;
+            }
+            j += 1;
+        }
+        i -= 1;
+    }
+}
+
+fn main() {
+    let n: i64 = 500;
+    let mut seq: [i64; 500] = [0; 500];
+    let dummy: [i64; 500] = [0; 500];
+    let mut table: [[i64; 500]; 500] = [dummy; 500];
+
+    // Init
+    let mut i: i64 = 0;
+    while i < n {
+        table[i] = [0; 500];
+        i += 1;
+    }
+    drop(dummy);
+
+    init_array(n, &mut seq, &mut table);
+    kernel_nussinov(n, &mut seq, &mut table);
+    let res: i64 = sum_array(n, &table);
+
+    // Drop
+    drop(seq);
+    i = 0;
+    while i < n {
+        drop(table[i]);
+        i += 1;
+    }
+    drop(table);
+
+    println!("{}", res);
+}
diff --git a/res/nussinov.out b/res/nussinov.out
new file mode 100644
index 000000000..e271f4dfa
--- /dev/null
+++ b/res/nussinov.out
@@ -0,0 +1 @@
+10292124.00 

From 780bec67b3363edae6a433396263af9831578654 Mon Sep 17 00:00:00 2001
From: Anjali Pal <anjalip@cs.washington.edu>
Date: Wed, 19 Feb 2025 11:45:34 -0800
Subject: [PATCH 07/14] Create correlation.rs

---
 .../polybench/datamining/correlation.rs       | 190 ++++++++++++++++++
 1 file changed, 190 insertions(+)
 create mode 100644 benchmarks/passing/polybench/datamining/correlation.rs

diff --git a/benchmarks/passing/polybench/datamining/correlation.rs b/benchmarks/passing/polybench/datamining/correlation.rs
new file mode 100644
index 000000000..bbfadef41
--- /dev/null
+++ b/benchmarks/passing/polybench/datamining/correlation.rs
@@ -0,0 +1,190 @@
+fn custom_sqrt(x: f64) -> f64 {
+    let mut guess: f64 = x / 2.0;
+    let mut i: i64 = 0;
+    while i < 10 {
+        guess = (guess + x / guess) / 2.0;
+        i += 1;
+    }
+    return guess;
+}
+
+fn init_array(m: i64, mf: f64, n: i64, data: &mut [[f64; 240]; 260]) {
+    let mut i: i64 = 0;
+    let mut fi: f64 = 0.0;
+    while i < n {
+        let mut j: i64 = 0;
+        let mut fj: f64 = 0.0;
+        while j < m {
+            let x: f64 = (fi * fj) / mf + fi;
+            data[i as usize][j as usize] = x;
+            j += 1;
+            fj += 1.0;
+        }
+        i += 1;
+        fi += 1.0;
+    }
+}
+
+fn print_array(m: i64, corr: &[[f64; 240]; 240]) {
+    let mut i: i64 = 0;
+    while i < m {
+        let mut j: i64 = 0;
+        while j < m {
+            let x: f64 = corr[i as usize][j as usize];
+            println!("{} ", x);
+            j += 1;
+        }
+        i += 1;
+    }
+}
+
+fn print_data(data: &[[f64; 240]; 260]) {
+    let mut i: i64 = 0;
+    while i < 260 {
+        let mut j: i64 = 0;
+        while j < 240 {
+            let x: f64 = data[i as usize][j as usize];
+            println!("{} ", x);
+            j += 1;
+        }
+        i += 1;
+    }
+}
+
+fn print_mean(m: i64, mean: &[f64; 240]) {
+    let mut i: i64 = 0;
+    while i < m {
+        let x: f64 = mean[i];
+        println!("{}", x);
+        i += 1;
+    }
+}
+
+fn print_stddev(m: i64, stddev: &[f64; 240]) {
+    let mut i: i64 = 0;
+    while i < m {
+        let x: f64 = stddev[i];
+        println!("{}", x);
+        i += 1;
+    }
+}
+
+fn kernel_correlation(
+    m: i64,
+    n: i64,
+    nf: f64,
+    data: &mut [[f64; 240]; 260],
+    corr: &mut [[f64; 240]; 240],
+    mean: &mut [f64; 240],
+    stddev: &mut [f64; 240],
+) {
+    let eps: f64 = 0.1;
+    let mut j: i64 = 0;
+    while j < m {
+        mean[j as usize] = 0.0;
+        let mut i: i64 = 0;
+        while i < n {
+            mean[j as usize] = mean[j as usize] + data[i as usize][j as usize];
+
+            i += 1;
+        }
+
+        mean[j as usize] = mean[j as usize] / nf;
+
+        j += 1;
+    }
+
+    j = 0;
+    while j < m {
+        stddev[j as usize] = 0.0;
+        let mut i: i64 = 0;
+        while i < n {
+            stddev[j as usize] = stddev[j as usize]
+                + (data[i as usize][j as usize] - mean[j as usize])
+                    * (data[i as usize][j as usize] - mean[j as usize]);
+            i += 1;
+        }
+        stddev[j as usize] = stddev[j as usize] / nf;
+        stddev[j as usize] = custom_sqrt(stddev[j as usize]);
+        if stddev[j as usize] <= eps {
+            stddev[j as usize] = 1.0;
+        }
+        j += 1;
+    }
+
+    let mut i: i64 = 0;
+    while i < n {
+        j = 0;
+        while j < m {
+            data[i as usize][j as usize] = data[i as usize][j as usize] - mean[j as usize];
+            data[i as usize][j as usize] =
+                data[i as usize][j as usize] / (custom_sqrt(nf) * stddev[j as usize]);
+            j += 1;
+        }
+        i += 1;
+    }
+
+    i = 0;
+    while i < m - 1 {
+        corr[i as usize][i as usize] = 1.0;
+        j = i + 1;
+        while j < m {
+            corr[i as usize][j as usize] = 0.0;
+            let mut k: i64 = 0;
+            while k < n {
+                corr[i as usize][j as usize] = corr[i as usize][j as usize]
+                    + data[k as usize][i as usize] * data[k as usize][j as usize];
+                k += 1;
+            }
+            corr[j as usize][i as usize] = corr[i as usize][j as usize];
+            j += 1;
+        }
+        i += 1;
+    }
+    corr[(m - 1) as usize][(m - 1) as usize] = 1.0;
+}
+
+fn main() {
+    let n: i64 = 260;
+    let nf: f64 = 260.0;
+    let m: i64 = 240;
+    let mf: f64 = 240.0;
+    let mut dummy: [f64; 240] = [0.0; 240];
+    let mut data: [[f64; 240]; 260] = [dummy; 260];
+    let mut corr: [[f64; 240]; 240] = [dummy; 240];
+    let mut mean: [f64; 240] = [0.0; 240];
+    let mut stddev: [f64; 240] = [0.0; 240];
+
+    // Init
+    let mut i: i64 = 0;
+    while i < n {
+        data[i] = [0.0; 240];
+        i += 1;
+    }
+    i = 0;
+    while i < m {
+        corr[i] = [0.0; 240];
+        i += 1;
+    }
+    drop(dummy);
+
+    init_array(m, mf, n, &mut data);
+    kernel_correlation(m, n, nf, &mut data, &mut corr, &mut mean, &mut stddev);
+    print_array(m, &corr);
+
+    // Drop
+    i = 0;
+    while i < n {
+        drop(data[i]);
+        i += 1;
+    }
+    i = 0;
+    while i < m {
+        drop(corr[i]);
+        i += 1;
+    }
+    drop(data);
+    drop(corr);
+    drop(mean);
+    drop(stddev);
+}

From a1acba2729562ac593e1ae7a023d36952c1ad13a Mon Sep 17 00:00:00 2001
From: Anjali Pal <anjalip@cs.washington.edu>
Date: Wed, 19 Feb 2025 12:29:47 -0800
Subject: [PATCH 08/14] Covariance

---
 .../polybench/datamining/correlation.rs       |  44 ++----
 .../polybench/datamining/covariance.rs        | 128 ++++++++++++++++++
 2 files changed, 138 insertions(+), 34 deletions(-)
 create mode 100644 benchmarks/passing/polybench/datamining/covariance.rs

diff --git a/benchmarks/passing/polybench/datamining/correlation.rs b/benchmarks/passing/polybench/datamining/correlation.rs
index bbfadef41..388c64eb3 100644
--- a/benchmarks/passing/polybench/datamining/correlation.rs
+++ b/benchmarks/passing/polybench/datamining/correlation.rs
@@ -25,48 +25,22 @@ fn init_array(m: i64, mf: f64, n: i64, data: &mut [[f64; 240]; 260]) {
     }
 }
 
-fn print_array(m: i64, corr: &[[f64; 240]; 240]) {
+fn sum_array(m: i64, corr: &[[f64; 240]; 240]) -> f64 {
+    let mut sum: f64 = 0.0;
     let mut i: i64 = 0;
     while i < m {
         let mut j: i64 = 0;
         while j < m {
             let x: f64 = corr[i as usize][j as usize];
-            println!("{} ", x);
+            // Can't print multiple things on nightly.
+            // Uncomment to run locally to check output.
+            // println!("{} ", x);
+            sum += x;
             j += 1;
         }
         i += 1;
     }
-}
-
-fn print_data(data: &[[f64; 240]; 260]) {
-    let mut i: i64 = 0;
-    while i < 260 {
-        let mut j: i64 = 0;
-        while j < 240 {
-            let x: f64 = data[i as usize][j as usize];
-            println!("{} ", x);
-            j += 1;
-        }
-        i += 1;
-    }
-}
-
-fn print_mean(m: i64, mean: &[f64; 240]) {
-    let mut i: i64 = 0;
-    while i < m {
-        let x: f64 = mean[i];
-        println!("{}", x);
-        i += 1;
-    }
-}
-
-fn print_stddev(m: i64, stddev: &[f64; 240]) {
-    let mut i: i64 = 0;
-    while i < m {
-        let x: f64 = stddev[i];
-        println!("{}", x);
-        i += 1;
-    }
+    return sum;
 }
 
 fn kernel_correlation(
@@ -170,7 +144,7 @@ fn main() {
 
     init_array(m, mf, n, &mut data);
     kernel_correlation(m, n, nf, &mut data, &mut corr, &mut mean, &mut stddev);
-    print_array(m, &corr);
+    let res: f64 = sum_array(m, &corr);
 
     // Drop
     i = 0;
@@ -187,4 +161,6 @@ fn main() {
     drop(corr);
     drop(mean);
     drop(stddev);
+
+    println!("{}", res);
 }
diff --git a/benchmarks/passing/polybench/datamining/covariance.rs b/benchmarks/passing/polybench/datamining/covariance.rs
new file mode 100644
index 000000000..40b58a0c7
--- /dev/null
+++ b/benchmarks/passing/polybench/datamining/covariance.rs
@@ -0,0 +1,128 @@
+fn init_array(m: i64, mf: f64, n: i64, data: &mut [[f64; 240]; 260]) {
+    let mut i: i64 = 0;
+    let mut fi: f64 = 0.0;
+    while i < n {
+        let mut j: i64 = 0;
+        let mut fj: f64 = 0.0;
+        while j < m {
+            data[i as usize][j as usize] = (fi * fj) / mf;
+            j += 1;
+            fj += 1.0;
+        }
+        i += 1;
+        fi += 1.0;
+    }
+}
+
+fn sum_array(m: i64, cov: &[[f64; 240]; 240]) -> f64 {
+    let mut sum: f64 = 0.0;
+    let mut i: i64 = 0;
+    while i < m {
+        let mut j: i64 = 0;
+        while j < m {
+            let x: f64 = cov[i as usize][j as usize];
+            // Can't print multiple things on nightly.
+            // Uncomment to run locally to check output.
+            // println!("{} ", x);
+            sum += x;
+            j += 1;
+        }
+        i += 1;
+    }
+    return sum;
+}
+
+fn kernel_covariance(
+    m: i64,
+    n: i64,
+    nf: f64,
+    data: &mut [[f64; 240]; 260],
+    cov: &mut [[f64; 240]; 240],
+    mean: &mut [f64; 240],
+) {
+    let mut j: i64 = 0;
+    while j < m {
+        mean[j as usize] = 0.0;
+        let mut i: i64 = 0;
+        while i < n {
+            let dij: f64 = data[i as usize][j as usize];
+            mean[j as usize] = mean[j as usize] + dij;
+            i += 1;
+        }
+        mean[j as usize] = mean[j as usize] / nf;
+        j += 1;
+    }
+
+    let mut i: i64 = 0;
+    while i < n {
+        j = 0;
+        while j < m {
+            data[i as usize][j as usize] = data[i as usize][j as usize] - mean[j as usize];
+            j += 1;
+        }
+        i += 1;
+    }
+
+    i = 0;
+    while i < m {
+        j = i;
+        while j < m {
+            cov[i as usize][j as usize] = 0.0;
+            let mut k: i64 = 0;
+            while k < n {
+                cov[i as usize][j as usize] = cov[i as usize][j as usize]
+                    + data[k as usize][i as usize] * data[k as usize][j as usize];
+                k += 1;
+            }
+            cov[i as usize][j as usize] = cov[i as usize][j as usize] / (nf - 1.0);
+            cov[j as usize][i as usize] = cov[i as usize][j as usize];
+            j += 1;
+        }
+        i += 1;
+    }
+}
+
+fn main() {
+    let n: i64 = 260;
+    let nf: f64 = 260.0;
+    let m: i64 = 240;
+    let mf: f64 = 240.0;
+    let dummy: [f64; 240] = [0.0; 240];
+    let mut data: [[f64; 240]; 260] = [dummy; 260];
+    let mut cov: [[f64; 240]; 240] = [dummy; 240];
+    let mut mean: [f64; 240] = [0.0; 240];
+
+    // Init
+    let mut i: i64 = 0;
+    while i < n {
+        data[i] = [0.0; 240];
+        i += 1;
+    }
+    i = 0;
+    while i < m {
+        cov[i] = [0.0; 240];
+        i += 1;
+    }
+    drop(dummy);
+
+    init_array(m, mf, n, &mut data);
+    kernel_covariance(m, n, nf, &mut data, &mut cov, &mut mean);
+    let res: f64 = sum_array(m, &cov);
+
+    // Drop
+    i = 0;
+    while i < n {
+        drop(data[i]);
+        i += 1;
+    }
+    i = 0;
+    while i < m {
+        drop(cov[i]);
+        i += 1;
+    }
+    drop(data);
+    drop(cov);
+    drop(mean);
+
+    println!("{}", res);
+}

From 924f299b2dbf3caabdae78858d305dfb8a7e6caa Mon Sep 17 00:00:00 2001
From: Anjali Pal <anjalip@cs.washington.edu>
Date: Wed, 19 Feb 2025 15:57:51 -0800
Subject: [PATCH 09/14] last two!

---
 .../passing/polybench/medley/deriche.rs       | 226 ++++++++++++++++++
 .../passing/polybench/stencils/fdtd-2d.rs     | 186 ++++++++++++++
 2 files changed, 412 insertions(+)
 create mode 100644 benchmarks/passing/polybench/medley/deriche.rs
 create mode 100644 benchmarks/passing/polybench/stencils/fdtd-2d.rs

diff --git a/benchmarks/passing/polybench/medley/deriche.rs b/benchmarks/passing/polybench/medley/deriche.rs
new file mode 100644
index 000000000..df5c93aeb
--- /dev/null
+++ b/benchmarks/passing/polybench/medley/deriche.rs
@@ -0,0 +1,226 @@
+fn modulo(a: f64, b: f64) -> f64 {
+    let mut remainder: f64 = a;
+    while remainder >= b {
+        remainder -= b;
+    }
+    while remainder < 0.0 {
+        remainder += b;
+    }
+    return remainder;
+}
+
+fn init_array(w: i64, h: i64, img_in: &mut [[f64; 480]; 720], img_out: &mut [[f64; 480]; 720]) {
+    let mut i: i64 = 0;
+    let mut fi: f64 = 0.0;
+    while i < w {
+        let mut j: i64 = 0;
+        let mut fj: f64 = 0.0;
+        while j < h {
+            img_in[i as usize][j as usize] = modulo((313.0 * fi + 991.0 * fj), 65536.0) / 65535.0;
+            j += 1;
+            fj += 1.0;
+        }
+        i += 1;
+        fi += 1.0;
+    }
+}
+
+fn sum_array(w: i64, h: i64, arr: &[[f64; 480]; 720]) -> f64 {
+    let mut sum: f64 = 0.0;
+    let mut i: i64 = 0;
+    while i < w {
+        let mut j: i64 = 0;
+        while j < h {
+            let x: f64 = arr[i as usize][j as usize];
+            // Can't print multiple things on nightly.
+            // Uncomment to run locally to check output.
+            // println!("{} ", x);
+            sum += x;
+            j += 1;
+        }
+        i += 1;
+    }
+    return sum;
+}
+
+fn custom_exp(x: f64) -> f64 {
+    let mut result: f64 = 1.0;
+    let mut term: f64 = 1.0;
+    let mut n: i64 = 1;
+    let mut nf: f64 = 1.0;
+    while n < 20 {
+        term *= x / nf;
+        result += term;
+        n += 1;
+        nf += 1.0;
+    }
+    return result;
+}
+
+fn kernel_deriche(
+    w: i64,
+    h: i64,
+    alpha: f64,
+    img_in: &mut [[f64; 480]; 720],
+    img_out: &mut [[f64; 480]; 720],
+    y1: &mut [[f64; 480]; 720],
+    y2: &mut [[f64; 480]; 720],
+) {
+    let k: f64 = (1.0 - custom_exp(-alpha)) * (1.0 - custom_exp(-alpha))
+        / (1.0 + 2.0 * alpha * custom_exp(-alpha) - custom_exp(2.0 * alpha));
+    let a1: f64 = k;
+    let a2: f64 = k * custom_exp(-alpha) * (alpha - 1.0);
+    let a3: f64 = k * custom_exp(-alpha) * (alpha + 1.0);
+    let a4: f64 = -k * custom_exp(-2.0 * alpha);
+    let a5: f64 = a1;
+    let a6: f64 = a2;
+    let a7: f64 = a3;
+    let a480: f64 = a4;
+    // Doing this in our subset of rust is kinda tricky...
+    // Luckily, we know alpha is 0.25, so it's just 2^(-.25)
+    // let b1: f64 = pow(2.0, -alpha);
+    let b1: f64 = 0.84089641525;
+    let b2: f64 = -custom_exp(-2.0 * alpha);
+    let c1: f64 = 1.0;
+    let c2: f64 = 1.0;
+
+    let mut i: i64 = 0;
+    while i < w {
+        let mut ym1: f64 = 0.0;
+        let mut ym2: f64 = 0.0;
+        let mut xm1: f64 = 0.0;
+        let mut j: i64 = 0;
+        while j < h {
+            y1[i as usize][j as usize] =
+                a1 * img_in[i as usize][j as usize] + a2 * xm1 + b1 * ym1 + b2 * ym2;
+            xm1 = img_in[i as usize][j as usize];
+            ym2 = ym1;
+            ym1 = y1[i as usize][j as usize];
+            j += 1;
+        }
+        i += 1;
+    }
+
+    i = 0;
+    while i < w {
+        let mut xp1: f64 = 0.0;
+        let mut xp2: f64 = 0.0;
+        let mut yp1: f64 = 0.0;
+        let mut yp2: f64 = 0.0;
+        let mut j: i64 = h - 1;
+        while j >= 0 {
+            y2[i as usize][j as usize] = a3 * xp1 + a4 * xp2 + b1 * yp1 + b2 * yp2;
+
+            // the following line doesn't work if you don't multiply by 1.0
+            // this shouldn't be necessary!! rs2bril bug probably
+            xp2 = xp1 * 1.0;
+            xp1 = img_in[i as usize][j as usize];
+
+            yp2 = yp1 * 1.0;
+            yp1 = y2[i][j];
+
+            j -= 1;
+        }
+        i += 1;
+    }
+
+    i = 0;
+    while i < w {
+        let mut j: i64 = 0;
+        while j < h {
+            img_out[i as usize][j as usize] =
+                c1 * (y1[i as usize][j as usize] + y2[i as usize][j as usize]);
+            j += 1;
+        }
+        i += 1;
+    }
+
+    let mut j: i64 = 0;
+    while j < h {
+        let mut tm1: f64 = 0.0;
+        let mut ym1: f64 = 0.0;
+        let mut ym2: f64 = 0.0;
+        i = 0;
+        while i < w {
+            y1[i as usize][j as usize] =
+                a5 * img_out[i as usize][j as usize] + a6 * tm1 + b1 * ym1 + b2 * ym2;
+            tm1 = img_out[i as usize][j as usize] * 1.0;
+            ym2 = ym1 * 1.0;
+            ym1 = y1[i as usize][j as usize] * 1.0;
+            i += 1;
+        }
+        j += 1;
+    }
+
+    j = 0;
+    while j < h {
+        let mut tp1: f64 = 0.0;
+        let mut tp2: f64 = 0.0;
+        let mut yp1: f64 = 0.0;
+        let mut yp2: f64 = 0.0;
+        i = w - 1;
+        while i >= 0 {
+            y2[i as usize][j as usize] = a7 * tp1 + a480 * tp2 + b1 * yp1 + b2 * yp2;
+            tp2 = tp1 * 1.0;
+            tp1 = img_out[i as usize][j as usize] * 1.0;
+            yp2 = yp1 * 1.0;
+            yp1 = y2[i as usize][j as usize] * 1.0;
+            i -= 1;
+        }
+        j += 1;
+    }
+
+    i = 0;
+    while i < w {
+        let mut j: i64 = 0;
+        while j < h {
+            img_out[i as usize][j as usize] =
+                c2 * (y1[i as usize][j as usize] + y2[i as usize][j as usize]);
+            j += 1;
+        }
+        i += 1;
+    }
+}
+
+fn main() {
+    let w: i64 = 720;
+    let h: i64 = 480;
+    let mut alpha: f64 = 0.25;
+    let dummy: [f64; 480] = [0.0; 480];
+    let mut img_in: [[f64; 480]; 720] = [dummy; 720];
+    let mut img_out: [[f64; 480]; 720] = [dummy; 720];
+    let mut y1: [[f64; 480]; 720] = [dummy; 720];
+    let mut y2: [[f64; 480]; 720] = [dummy; 720];
+
+    // Init
+    let mut i: i64 = 0;
+    while i < w {
+        img_in[i] = [0.0; 480];
+        img_out[i] = [0.0; 480];
+        y1[i] = [0.0; 480];
+        y2[i] = [0.0; 480];
+        i += 1;
+    }
+    drop(dummy);
+
+    init_array(w, h, &mut img_in, &mut img_out);
+
+    kernel_deriche(w, h, alpha, &img_in, &mut img_out, &mut y1, &mut y2);
+    let res: f64 = sum_array(w, h, &img_out);
+
+    // Drop
+    i = 0;
+    while i < w {
+        drop(img_in[i]);
+        drop(img_out[i]);
+        drop(y1[i]);
+        drop(y2[i]);
+        i += 1;
+    }
+    drop(img_in);
+    drop(img_out);
+    drop(y1);
+    drop(y2);
+
+    println!("{}", res);
+}
diff --git a/benchmarks/passing/polybench/stencils/fdtd-2d.rs b/benchmarks/passing/polybench/stencils/fdtd-2d.rs
new file mode 100644
index 000000000..c3d9e0f1c
--- /dev/null
+++ b/benchmarks/passing/polybench/stencils/fdtd-2d.rs
@@ -0,0 +1,186 @@
+fn init_array(
+    tmax: i64,
+    nx: i64,
+    nxf: f64,
+    ny: i64,
+    nyf: f64,
+    fict: &mut [f64; 40],
+    ex: &mut [[f64; 80]; 60],
+    ey: &mut [[f64; 80]; 60],
+    hz: &mut [[f64; 80]; 60],
+) {
+    let mut i: i64 = 0;
+    let mut fi: f64 = 0.0;
+    while i < tmax {
+        fict[i as usize] = fi;
+        i += 1;
+        fi += 1.0;
+    }
+
+    i = 0;
+    fi = 0.0;
+    while i < nx {
+        let mut j: i64 = 0;
+        let mut fj: f64 = 0.0;
+        while j < ny {
+            ex[i as usize][j as usize] = (fi * (fj + 1.0)) / nxf;
+            ey[i as usize][j as usize] = (fi * (fj + 2.0)) / nyf;
+            hz[i as usize][j as usize] = (fi * (fj + 3.0)) / nxf;
+            j += 1;
+            fj += 1.0;
+        }
+        i += 1;
+        fi += 1.0;
+    }
+}
+
+fn kernel_fdtd_2d(
+    tmax: i64,
+    nx: i64,
+    ny: i64,
+    fict: &[f64; 40],
+    ex: &mut [[f64; 80]; 60],
+    ey: &mut [[f64; 80]; 60],
+    hz: &mut [[f64; 80]; 60],
+) {
+    let mut t: i64 = 0;
+    while t < tmax {
+        let mut j: i64 = 0;
+        while j < ny {
+            ey[0][j as usize] = fict[t as usize];
+            j += 1;
+        }
+
+        let mut i: i64 = 1;
+        while i < nx {
+            j = 0;
+            while j < ny {
+                ey[i as usize][j as usize] = ey[i as usize][j as usize]
+                    - (0.5 * (hz[i as usize][j as usize] - hz[(i - 1) as usize][j as usize]));
+                j += 1;
+            }
+            i += 1;
+        }
+
+        i = 0;
+        while i < nx {
+            j = 1;
+            while j < ny {
+                ex[i as usize][j as usize] = ex[i as usize][j as usize]
+                    - (0.5 * (hz[i as usize][j as usize] - hz[i as usize][(j - 1) as usize]));
+                j += 1;
+            }
+            i += 1;
+        }
+
+        i = 0;
+        while i < nx - 1 {
+            j = 0;
+            while j < ny - 1 {
+                hz[i as usize][j as usize] = hz[i as usize][j as usize]
+                    - (0.7
+                        * (ex[i as usize][(j + 1) as usize] - ex[i as usize][j as usize]
+                            + ey[(i + 1) as usize][j as usize]
+                            - ey[i as usize][j as usize]));
+                j += 1;
+            }
+            i += 1;
+        }
+
+        t += 1;
+    }
+}
+
+fn sum_array(
+    nx: i64,
+    ny: i64,
+    ex: &[[f64; 80]; 60],
+    ey: &[[f64; 80]; 60],
+    hz: &[[f64; 80]; 60],
+) -> f64 {
+    let mut sum: f64 = 0.0;
+    let mut i: i64 = 0;
+    while i < nx {
+        let mut j: i64 = 0;
+        while j < ny {
+            let x: f64 = ex[i as usize][j as usize];
+            // Can't print multiple things on nightly.
+            // Uncomment to run locally to check output.
+            // println!("{} ", x);
+            sum += x;
+            j += 1;
+        }
+        i += 1;
+    }
+
+    i = 0;
+    while i < nx {
+        let mut j: i64 = 0;
+        while j < ny {
+            let x: f64 = ey[i as usize][j as usize];
+            // Can't print multiple things on nightly.
+            // Uncomment to run locally to check output.
+            // println!("{} ", x);
+            sum += x;
+            j += 1;
+        }
+        i += 1;
+    }
+
+    i = 0;
+    while i < nx {
+        let mut j: i64 = 0;
+        while j < ny {
+            let x: f64 = hz[i as usize][j as usize];
+            // Can't print multiple things on nightly.
+            // Uncomment to run locally to check output.
+            // println!("{} ", x);
+            sum += x;
+            j += 1;
+        }
+        i += 1;
+    }
+}
+
+fn main() {
+    let tmax: i64 = 40;
+    let nx: i64 = 60;
+    let nxf: f64 = 60.0;
+    let ny: i64 = 80;
+    let nyf: f64 = 80.0;
+
+    let dummy: [f64; 80] = [0.0; 80];
+    let mut fict: [f64; 40] = [0.0; 40];
+    let mut ex: [[f64; 80]; 60] = [dummy; 60];
+    let mut ey: [[f64; 80]; 60] = [dummy; 60];
+    let mut hz: [[f64; 80]; 60] = [dummy; 60];
+
+    // Init
+    let mut i: i64 = 0;
+    while i < nx {
+        ex[i] = [0.0; 80];
+        ey[i] = [0.0; 80];
+        hz[i] = [0.0; 80];
+        i += 1;
+    }
+    drop(dummy);
+
+    init_array(tmax, nx, nxf, ny, nyf, &mut fict, &mut ex, &mut ey, &mut hz);
+    kernel_fdtd_2d(tmax, nx, ny, &fict, &mut ex, &mut ey, &mut hz);
+    let res: f64 = sum_array(nx, ny, &ex, &ey, &hz);
+
+    // Drop
+    i = 0;
+    while i < nx {
+        drop(ex[i]);
+        drop(ey[i]);
+        drop(hz[i]);
+        i += 1;
+    }
+    drop(fict);
+    drop(ex);
+    drop(ey);
+    drop(hz);
+
+    println!("{}", res);
+}

From e421266ad63d4e1c3798ec8be96398241c1d7228 Mon Sep 17 00:00:00 2001
From: Anjali Pal <anjalip@cs.washington.edu>
Date: Thu, 20 Feb 2025 09:53:10 -0800
Subject: [PATCH 10/14] small instead of medium

---
 .../polybench/datamining/correlation.rs       | 34 ++++++++---------
 .../polybench/datamining/covariance.rs        | 30 +++++++--------
 .../passing/polybench/medley/deriche.rs       | 38 +++++++++----------
 .../polybench/medley/floyd-warshall.rs        | 14 +++----
 .../passing/polybench/medley/nussinov.rs      | 16 ++++----
 benchmarks/passing/polybench/stencils/adi.rs  | 38 +++++++++----------
 .../passing/polybench/stencils/heat-3d.rs     | 30 +++++++--------
 .../passing/polybench/stencils/jacobi-1d.rs   | 16 ++++----
 .../passing/polybench/stencils/jacobi-2d.rs   | 22 +++++------
 .../passing/polybench/stencils/seidel-2d.rs   | 18 ++++-----
 10 files changed, 128 insertions(+), 128 deletions(-)

diff --git a/benchmarks/passing/polybench/datamining/correlation.rs b/benchmarks/passing/polybench/datamining/correlation.rs
index 388c64eb3..5c2a96f15 100644
--- a/benchmarks/passing/polybench/datamining/correlation.rs
+++ b/benchmarks/passing/polybench/datamining/correlation.rs
@@ -8,7 +8,7 @@ fn custom_sqrt(x: f64) -> f64 {
     return guess;
 }
 
-fn init_array(m: i64, mf: f64, n: i64, data: &mut [[f64; 240]; 260]) {
+fn init_array(m: i64, mf: f64, n: i64, data: &mut [[f64; 80]; 100]) {
     let mut i: i64 = 0;
     let mut fi: f64 = 0.0;
     while i < n {
@@ -25,7 +25,7 @@ fn init_array(m: i64, mf: f64, n: i64, data: &mut [[f64; 240]; 260]) {
     }
 }
 
-fn sum_array(m: i64, corr: &[[f64; 240]; 240]) -> f64 {
+fn sum_array(m: i64, corr: &[[f64; 80]; 80]) -> f64 {
     let mut sum: f64 = 0.0;
     let mut i: i64 = 0;
     while i < m {
@@ -47,10 +47,10 @@ fn kernel_correlation(
     m: i64,
     n: i64,
     nf: f64,
-    data: &mut [[f64; 240]; 260],
-    corr: &mut [[f64; 240]; 240],
-    mean: &mut [f64; 240],
-    stddev: &mut [f64; 240],
+    data: &mut [[f64; 80]; 100],
+    corr: &mut [[f64; 80]; 80],
+    mean: &mut [f64; 80],
+    stddev: &mut [f64; 80],
 ) {
     let eps: f64 = 0.1;
     let mut j: i64 = 0;
@@ -119,25 +119,25 @@ fn kernel_correlation(
 }
 
 fn main() {
-    let n: i64 = 260;
-    let nf: f64 = 260.0;
-    let m: i64 = 240;
-    let mf: f64 = 240.0;
-    let mut dummy: [f64; 240] = [0.0; 240];
-    let mut data: [[f64; 240]; 260] = [dummy; 260];
-    let mut corr: [[f64; 240]; 240] = [dummy; 240];
-    let mut mean: [f64; 240] = [0.0; 240];
-    let mut stddev: [f64; 240] = [0.0; 240];
+    let n: i64 = 100;
+    let nf: f64 = 100.0;
+    let m: i64 = 80;
+    let mf: f64 = 80.0;
+    let mut dummy: [f64; 80] = [0.0; 80];
+    let mut data: [[f64; 80]; 100] = [dummy; 100];
+    let mut corr: [[f64; 80]; 80] = [dummy; 80];
+    let mut mean: [f64; 80] = [0.0; 80];
+    let mut stddev: [f64; 80] = [0.0; 80];
 
     // Init
     let mut i: i64 = 0;
     while i < n {
-        data[i] = [0.0; 240];
+        data[i] = [0.0; 80];
         i += 1;
     }
     i = 0;
     while i < m {
-        corr[i] = [0.0; 240];
+        corr[i] = [0.0; 80];
         i += 1;
     }
     drop(dummy);
diff --git a/benchmarks/passing/polybench/datamining/covariance.rs b/benchmarks/passing/polybench/datamining/covariance.rs
index 40b58a0c7..b41428fec 100644
--- a/benchmarks/passing/polybench/datamining/covariance.rs
+++ b/benchmarks/passing/polybench/datamining/covariance.rs
@@ -1,4 +1,4 @@
-fn init_array(m: i64, mf: f64, n: i64, data: &mut [[f64; 240]; 260]) {
+fn init_array(m: i64, mf: f64, n: i64, data: &mut [[f64; 80]; 100]) {
     let mut i: i64 = 0;
     let mut fi: f64 = 0.0;
     while i < n {
@@ -14,7 +14,7 @@ fn init_array(m: i64, mf: f64, n: i64, data: &mut [[f64; 240]; 260]) {
     }
 }
 
-fn sum_array(m: i64, cov: &[[f64; 240]; 240]) -> f64 {
+fn sum_array(m: i64, cov: &[[f64; 80]; 80]) -> f64 {
     let mut sum: f64 = 0.0;
     let mut i: i64 = 0;
     while i < m {
@@ -36,9 +36,9 @@ fn kernel_covariance(
     m: i64,
     n: i64,
     nf: f64,
-    data: &mut [[f64; 240]; 260],
-    cov: &mut [[f64; 240]; 240],
-    mean: &mut [f64; 240],
+    data: &mut [[f64; 80]; 100],
+    cov: &mut [[f64; 80]; 80],
+    mean: &mut [f64; 80],
 ) {
     let mut j: i64 = 0;
     while j < m {
@@ -83,24 +83,24 @@ fn kernel_covariance(
 }
 
 fn main() {
-    let n: i64 = 260;
-    let nf: f64 = 260.0;
-    let m: i64 = 240;
-    let mf: f64 = 240.0;
-    let dummy: [f64; 240] = [0.0; 240];
-    let mut data: [[f64; 240]; 260] = [dummy; 260];
-    let mut cov: [[f64; 240]; 240] = [dummy; 240];
-    let mut mean: [f64; 240] = [0.0; 240];
+    let n: i64 = 100;
+    let nf: f64 = 100.0;
+    let m: i64 = 80;
+    let mf: f64 = 80.0;
+    let dummy: [f64; 80] = [0.0; 80];
+    let mut data: [[f64; 80]; 100] = [dummy; 100];
+    let mut cov: [[f64; 80]; 80] = [dummy; 80];
+    let mut mean: [f64; 80] = [0.0; 80];
 
     // Init
     let mut i: i64 = 0;
     while i < n {
-        data[i] = [0.0; 240];
+        data[i] = [0.0; 80];
         i += 1;
     }
     i = 0;
     while i < m {
-        cov[i] = [0.0; 240];
+        cov[i] = [0.0; 80];
         i += 1;
     }
     drop(dummy);
diff --git a/benchmarks/passing/polybench/medley/deriche.rs b/benchmarks/passing/polybench/medley/deriche.rs
index df5c93aeb..2e04ef860 100644
--- a/benchmarks/passing/polybench/medley/deriche.rs
+++ b/benchmarks/passing/polybench/medley/deriche.rs
@@ -9,7 +9,7 @@ fn modulo(a: f64, b: f64) -> f64 {
     return remainder;
 }
 
-fn init_array(w: i64, h: i64, img_in: &mut [[f64; 480]; 720], img_out: &mut [[f64; 480]; 720]) {
+fn init_array(w: i64, h: i64, img_in: &mut [[f64; 128]; 192], img_out: &mut [[f64; 128]; 192]) {
     let mut i: i64 = 0;
     let mut fi: f64 = 0.0;
     while i < w {
@@ -25,7 +25,7 @@ fn init_array(w: i64, h: i64, img_in: &mut [[f64; 480]; 720], img_out: &mut [[f6
     }
 }
 
-fn sum_array(w: i64, h: i64, arr: &[[f64; 480]; 720]) -> f64 {
+fn sum_array(w: i64, h: i64, arr: &[[f64; 128]; 192]) -> f64 {
     let mut sum: f64 = 0.0;
     let mut i: i64 = 0;
     while i < w {
@@ -61,10 +61,10 @@ fn kernel_deriche(
     w: i64,
     h: i64,
     alpha: f64,
-    img_in: &mut [[f64; 480]; 720],
-    img_out: &mut [[f64; 480]; 720],
-    y1: &mut [[f64; 480]; 720],
-    y2: &mut [[f64; 480]; 720],
+    img_in: &mut [[f64; 128]; 192],
+    img_out: &mut [[f64; 128]; 192],
+    y1: &mut [[f64; 128]; 192],
+    y2: &mut [[f64; 128]; 192],
 ) {
     let k: f64 = (1.0 - custom_exp(-alpha)) * (1.0 - custom_exp(-alpha))
         / (1.0 + 2.0 * alpha * custom_exp(-alpha) - custom_exp(2.0 * alpha));
@@ -75,7 +75,7 @@ fn kernel_deriche(
     let a5: f64 = a1;
     let a6: f64 = a2;
     let a7: f64 = a3;
-    let a480: f64 = a4;
+    let a8: f64 = a4;
     // Doing this in our subset of rust is kinda tricky...
     // Luckily, we know alpha is 0.25, so it's just 2^(-.25)
     // let b1: f64 = pow(2.0, -alpha);
@@ -160,7 +160,7 @@ fn kernel_deriche(
         let mut yp2: f64 = 0.0;
         i = w - 1;
         while i >= 0 {
-            y2[i as usize][j as usize] = a7 * tp1 + a480 * tp2 + b1 * yp1 + b2 * yp2;
+            y2[i as usize][j as usize] = a7 * tp1 + a8 * tp2 + b1 * yp1 + b2 * yp2;
             tp2 = tp1 * 1.0;
             tp1 = img_out[i as usize][j as usize] * 1.0;
             yp2 = yp1 * 1.0;
@@ -183,22 +183,22 @@ fn kernel_deriche(
 }
 
 fn main() {
-    let w: i64 = 720;
-    let h: i64 = 480;
+    let w: i64 = 192;
+    let h: i64 = 128;
     let mut alpha: f64 = 0.25;
-    let dummy: [f64; 480] = [0.0; 480];
-    let mut img_in: [[f64; 480]; 720] = [dummy; 720];
-    let mut img_out: [[f64; 480]; 720] = [dummy; 720];
-    let mut y1: [[f64; 480]; 720] = [dummy; 720];
-    let mut y2: [[f64; 480]; 720] = [dummy; 720];
+    let dummy: [f64; 128] = [0.0; 128];
+    let mut img_in: [[f64; 128]; 192] = [dummy; 192];
+    let mut img_out: [[f64; 128]; 192] = [dummy; 192];
+    let mut y1: [[f64; 128]; 192] = [dummy; 192];
+    let mut y2: [[f64; 128]; 192] = [dummy; 192];
 
     // Init
     let mut i: i64 = 0;
     while i < w {
-        img_in[i] = [0.0; 480];
-        img_out[i] = [0.0; 480];
-        y1[i] = [0.0; 480];
-        y2[i] = [0.0; 480];
+        img_in[i] = [0.0; 128];
+        img_out[i] = [0.0; 128];
+        y1[i] = [0.0; 128];
+        y2[i] = [0.0; 128];
         i += 1;
     }
     drop(dummy);
diff --git a/benchmarks/passing/polybench/medley/floyd-warshall.rs b/benchmarks/passing/polybench/medley/floyd-warshall.rs
index 9d3f96285..b0353eb3c 100644
--- a/benchmarks/passing/polybench/medley/floyd-warshall.rs
+++ b/benchmarks/passing/polybench/medley/floyd-warshall.rs
@@ -8,7 +8,7 @@ fn modulo(a: i64, b: i64) -> i64 {
     }
 }
 
-fn init_array(n: i64, path: &mut [[i64; 500]; 500]) {
+fn init_array(n: i64, path: &mut [[i64; 180]; 180]) {
     let mut i: i64 = 0;
     while i < n {
         let mut j: i64 = 0;
@@ -23,7 +23,7 @@ fn init_array(n: i64, path: &mut [[i64; 500]; 500]) {
     }
 }
 
-fn sum_array(n: i64, path: &[[i64; 500]; 500]) -> i64 {
+fn sum_array(n: i64, path: &[[i64; 180]; 180]) -> i64 {
     let mut sum: i64 = 0;
     let mut i: i64 = 0;
     while i < n {
@@ -41,7 +41,7 @@ fn sum_array(n: i64, path: &[[i64; 500]; 500]) -> i64 {
     return sum;
 }
 
-fn kernel_floyd_warshall(n: i64, path: &mut [[i64; 500]; 500]) {
+fn kernel_floyd_warshall(n: i64, path: &mut [[i64; 180]; 180]) {
     let mut k: i64 = 0;
     while k < n {
         let mut i: i64 = 0;
@@ -63,15 +63,15 @@ fn kernel_floyd_warshall(n: i64, path: &mut [[i64; 500]; 500]) {
 }
 
 fn main() {
-    let n: i64 = 500;
+    let n: i64 = 180;
 
-    let dummy: [i64; 500] = [0; 500];
-    let mut path: [[i64; 500]; 500] = [dummy; 500];
+    let dummy: [i64; 180] = [0; 180];
+    let mut path: [[i64; 180]; 180] = [dummy; 180];
 
     // Init
     let mut i: i64 = 0;
     while i < n {
-        path[i] = [0; 500];
+        path[i] = [0; 180];
         i += 1;
     }
     drop(dummy);
diff --git a/benchmarks/passing/polybench/medley/nussinov.rs b/benchmarks/passing/polybench/medley/nussinov.rs
index 8d614fbf8..afff3c59c 100644
--- a/benchmarks/passing/polybench/medley/nussinov.rs
+++ b/benchmarks/passing/polybench/medley/nussinov.rs
@@ -24,7 +24,7 @@ fn match_base(b1: i64, b2: i64) -> i64 {
     }
 }
 
-fn init_array(n: i64, seq: &mut [i64; 500], table: &mut [[i64; 500]; 500]) {
+fn init_array(n: i64, seq: &mut [i64; 180], table: &mut [[i64; 180]; 180]) {
     let mut i: i64 = 0;
     while i < n {
         seq[i as usize] = modulo(i + 1, 4);
@@ -42,7 +42,7 @@ fn init_array(n: i64, seq: &mut [i64; 500], table: &mut [[i64; 500]; 500]) {
     }
 }
 
-fn sum_array(n: i64, table: &[[i64; 500]; 500]) -> i64 {
+fn sum_array(n: i64, table: &[[i64; 180]; 180]) -> i64 {
     let mut sum: i64 = 0;
     let mut i: i64 = 0;
     while i < n {
@@ -60,7 +60,7 @@ fn sum_array(n: i64, table: &[[i64; 500]; 500]) -> i64 {
     return sum;
 }
 
-fn kernel_nussinov(n: i64, seq: &mut [i64; 500], table: &mut [[i64; 500]; 500]) {
+fn kernel_nussinov(n: i64, seq: &mut [i64; 180], table: &mut [[i64; 180]; 180]) {
     let mut i: i64 = n - 1;
     while i >= 0 {
         let mut j: i64 = i + 1;
@@ -106,15 +106,15 @@ fn kernel_nussinov(n: i64, seq: &mut [i64; 500], table: &mut [[i64; 500]; 500])
 }
 
 fn main() {
-    let n: i64 = 500;
-    let mut seq: [i64; 500] = [0; 500];
-    let dummy: [i64; 500] = [0; 500];
-    let mut table: [[i64; 500]; 500] = [dummy; 500];
+    let n: i64 = 180;
+    let mut seq: [i64; 180] = [0; 180];
+    let dummy: [i64; 180] = [0; 180];
+    let mut table: [[i64; 180]; 180] = [dummy; 180];
 
     // Init
     let mut i: i64 = 0;
     while i < n {
-        table[i] = [0; 500];
+        table[i] = [0; 180];
         i += 1;
     }
     drop(dummy);
diff --git a/benchmarks/passing/polybench/stencils/adi.rs b/benchmarks/passing/polybench/stencils/adi.rs
index e13123db6..09831e733 100644
--- a/benchmarks/passing/polybench/stencils/adi.rs
+++ b/benchmarks/passing/polybench/stencils/adi.rs
@@ -1,4 +1,4 @@
-fn init_array(n: i64, nf: f64, u: &mut [[f64; 200]; 200]) {
+fn init_array(n: i64, nf: f64, u: &mut [[f64; 60]; 60]) {
     let mut i: i64 = 0;
     let mut fi: f64 = 0.0;
     while i < n {
@@ -14,7 +14,7 @@ fn init_array(n: i64, nf: f64, u: &mut [[f64; 200]; 200]) {
     }
 }
 
-fn sum_array(n: i64, u: &[[f64; 200]; 200]) -> f64 {
+fn sum_array(n: i64, u: &[[f64; 60]; 60]) -> f64 {
     let mut sum: f64 = 0.0;
     let mut i: i64 = 0;
     while i < n {
@@ -37,10 +37,10 @@ fn kernel_adi(
     tstepsf: f64,
     n: i64,
     nf: f64,
-    u: &mut [[f64; 200]; 200],
-    v: &mut [[f64; 200]; 200],
-    p: &mut [[f64; 200]; 200],
-    q: &mut [[f64; 200]; 200],
+    u: &mut [[f64; 60]; 60],
+    v: &mut [[f64; 60]; 60],
+    p: &mut [[f64; 60]; 60],
+    q: &mut [[f64; 60]; 60],
 ) {
     let dx: f64 = 1.0 / nf;
     let dy: f64 = 1.0 / nf;
@@ -81,25 +81,25 @@ fn kernel_adi(
 }
 
 fn main() {
-    let n: i64 = 200;
-    let nf: f64 = 200.0;
-    let tsteps: i64 = 100;
-    let tstepsf: f64 = 100.0;
+    let n: i64 = 60;
+    let nf: f64 = 60.0;
+    let tsteps: i64 = 40;
+    let tstepsf: f64 = 40.0;
 
-    let mut dummy: [f64; 200] = [0.0; 200];
+    let mut dummy: [f64; 60] = [0.0; 60];
 
-    let mut u: [[f64; 200]; 200] = [dummy; 200];
-    let mut v: [[f64; 200]; 200] = [dummy; 200];
-    let mut p: [[f64; 200]; 200] = [dummy; 200];
-    let mut q: [[f64; 200]; 200] = [dummy; 200];
+    let mut u: [[f64; 60]; 60] = [dummy; 60];
+    let mut v: [[f64; 60]; 60] = [dummy; 60];
+    let mut p: [[f64; 60]; 60] = [dummy; 60];
+    let mut q: [[f64; 60]; 60] = [dummy; 60];
 
     // Init
     let mut i: i64 = 0;
     while i < n {
-        u[i] = [0.0; 200];
-        v[i] = [0.0; 200];
-        p[i] = [0.0; 200];
-        q[i] = [0.0; 200];
+        u[i] = [0.0; 60];
+        v[i] = [0.0; 60];
+        p[i] = [0.0; 60];
+        q[i] = [0.0; 60];
         i += 1;
     }
 
diff --git a/benchmarks/passing/polybench/stencils/heat-3d.rs b/benchmarks/passing/polybench/stencils/heat-3d.rs
index 9f9732193..667391fb7 100644
--- a/benchmarks/passing/polybench/stencils/heat-3d.rs
+++ b/benchmarks/passing/polybench/stencils/heat-3d.rs
@@ -1,4 +1,4 @@
-fn init_array(n: i64, nf: f64, a: &mut [[[f64; 40]; 40]; 40], b: &mut [[[f64; 40]; 40]; 40]) {
+fn init_array(n: i64, nf: f64, a: &mut [[[f64; 20]; 20]; 20], b: &mut [[[f64; 20]; 20]; 20]) {
     let mut i: i64 = 0;
     let mut fi: f64 = 0.0;
     while i < n {
@@ -21,7 +21,7 @@ fn init_array(n: i64, nf: f64, a: &mut [[[f64; 40]; 40]; 40], b: &mut [[[f64; 40
     }
 }
 
-fn sum_array(n: i64, a: &[[[f64; 40]; 40]; 40]) -> f64 {
+fn sum_array(n: i64, a: &[[[f64; 20]; 20]; 20]) -> f64 {
     let mut sum: f64 = 0.0;
     let mut i: i64 = 0;
     while i < n {
@@ -46,8 +46,8 @@ fn sum_array(n: i64, a: &[[[f64; 40]; 40]; 40]) -> f64 {
 fn kernel_heat_3d(
     tsteps: i64,
     n: i64,
-    a: &mut [[[f64; 40]; 40]; 40],
-    b: &mut [[[f64; 40]; 40]; 40],
+    a: &mut [[[f64; 20]; 20]; 20],
+    b: &mut [[[f64; 20]; 20]; 20],
 ) {
     let mut t: i64 = 1;
     while t <= tsteps {
@@ -107,23 +107,23 @@ fn kernel_heat_3d(
 }
 
 fn main() {
-    let n: i64 = 40;
-    let nf: f64 = 40.0;
-    let tsteps: i64 = 400;
+    let n: i64 = 20;
+    let nf: f64 = 20.0;
+    let tsteps: i64 = 40;
 
-    let inner_dummy: [f64; 40] = [0.0; 40];
-    let dummy: [[f64; 40]; 40] = [inner_dummy; 40];
-    let mut a: [[[f64; 40]; 40]; 40] = [dummy; 40];
-    let mut b: [[[f64; 40]; 40]; 40] = [dummy; 40];
+    let inner_dummy: [f64; 20] = [0.0; 20];
+    let dummy: [[f64; 20]; 20] = [inner_dummy; 20];
+    let mut a: [[[f64; 20]; 20]; 20] = [dummy; 20];
+    let mut b: [[[f64; 20]; 20]; 20] = [dummy; 20];
 
     let mut i: i64 = 0;
     while i < n {
-        let a_elt: [[f64; 40]; 40] = [inner_dummy; 40];
-        let b_elt: [[f64; 40]; 40] = [inner_dummy; 40];
+        let a_elt: [[f64; 20]; 20] = [inner_dummy; 20];
+        let b_elt: [[f64; 20]; 20] = [inner_dummy; 20];
         let mut j: i64 = 0;
         while j < n {
-            a_elt[j] = [0.0; 40];
-            b_elt[j] = [0.0; 40];
+            a_elt[j] = [0.0; 20];
+            b_elt[j] = [0.0; 20];
             j += 1;
         }
         a[i] = a_elt;
diff --git a/benchmarks/passing/polybench/stencils/jacobi-1d.rs b/benchmarks/passing/polybench/stencils/jacobi-1d.rs
index 399e3bb21..31226c782 100644
--- a/benchmarks/passing/polybench/stencils/jacobi-1d.rs
+++ b/benchmarks/passing/polybench/stencils/jacobi-1d.rs
@@ -1,4 +1,4 @@
-fn init_array(n: i64, nf: f64, a: &mut [f64; 400], b: &mut [f64; 400]) {
+fn init_array(n: i64, nf: f64, a: &mut [f64; 120], b: &mut [f64; 120]) {
     let mut i: i64 = 0;
     let mut fi: f64 = 0.0;
     while i < n {
@@ -9,7 +9,7 @@ fn init_array(n: i64, nf: f64, a: &mut [f64; 400], b: &mut [f64; 400]) {
     }
 }
 
-fn sum_array(n: i64, a: &[f64; 400]) -> f64 {
+fn sum_array(n: i64, a: &[f64; 120]) -> f64 {
     let mut i: i64 = 0;
     let mut sum: f64 = 0.0;
     while i < n {
@@ -23,7 +23,7 @@ fn sum_array(n: i64, a: &[f64; 400]) -> f64 {
     return sum;
 }
 
-fn kernel_jacobi_1d(tsteps: i64, n: i64, a: &mut [f64; 400], b: &mut [f64; 400]) {
+fn kernel_jacobi_1d(tsteps: i64, n: i64, a: &mut [f64; 120], b: &mut [f64; 120]) {
     let mut t: i64 = 0;
     while t < tsteps {
         let mut i: i64 = 1;
@@ -41,12 +41,12 @@ fn kernel_jacobi_1d(tsteps: i64, n: i64, a: &mut [f64; 400], b: &mut [f64; 400])
 }
 
 fn main() {
-    let n: i64 = 400;
-    let nf: f64 = 400.0;
-    let tsteps: i64 = 100;
+    let n: i64 = 120;
+    let nf: f64 = 120.0;
+    let tsteps: i64 = 40;
 
-    let mut a: [f64; 400] = [0.0; 400];
-    let mut b: [f64; 400] = [0.0; 400];
+    let mut a: [f64; 120] = [0.0; 120];
+    let mut b: [f64; 120] = [0.0; 120];
 
     init_array(n, nf, &mut a, &mut b);
     kernel_jacobi_1d(tsteps, n, &mut a, &mut b);
diff --git a/benchmarks/passing/polybench/stencils/jacobi-2d.rs b/benchmarks/passing/polybench/stencils/jacobi-2d.rs
index aa2c2c9c6..659ef6d60 100644
--- a/benchmarks/passing/polybench/stencils/jacobi-2d.rs
+++ b/benchmarks/passing/polybench/stencils/jacobi-2d.rs
@@ -1,4 +1,4 @@
-fn init_array(n: i64, nf: f64, a: &mut [[f64; 250]; 250], b: &mut [[f64; 250]; 250]) {
+fn init_array(n: i64, nf: f64, a: &mut [[f64; 90]; 90], b: &mut [[f64; 90]; 90]) {
     let mut i: i64 = 0;
     let mut fi: f64 = 0.0;
     while i < n {
@@ -15,7 +15,7 @@ fn init_array(n: i64, nf: f64, a: &mut [[f64; 250]; 250], b: &mut [[f64; 250]; 2
     }
 }
 
-fn sum_array(n: i64, a: &[[f64; 250]; 250]) -> f64 {
+fn sum_array(n: i64, a: &[[f64; 90]; 90]) -> f64 {
     let mut sum: f64 = 0.0;
     let mut i: i64 = 0;
     while i < n {
@@ -33,7 +33,7 @@ fn sum_array(n: i64, a: &[[f64; 250]; 250]) -> f64 {
     return sum;
 }
 
-fn kernel_jacobi_2d(tsteps: i64, n: i64, a: &mut [[f64; 250]; 250], b: &mut [[f64; 250]; 250]) {
+fn kernel_jacobi_2d(tsteps: i64, n: i64, a: &mut [[f64; 90]; 90], b: &mut [[f64; 90]; 90]) {
     let mut t: i64 = 0;
     while t < tsteps {
         let mut i: i64 = 1;
@@ -70,20 +70,20 @@ fn kernel_jacobi_2d(tsteps: i64, n: i64, a: &mut [[f64; 250]; 250], b: &mut [[f6
 }
 
 fn main() {
-    let n: i64 = 250;
-    let mut nf: f64 = 250.0;
-    let tsteps: i64 = 100;
+    let n: i64 = 90;
+    let mut nf: f64 = 90.0;
+    let tsteps: i64 = 40;
 
-    let mut dummy: [f64; 250] = [0.0; 250];
+    let mut dummy: [f64; 90] = [0.0; 90];
 
-    let mut a: [[f64; 250]; 250] = [dummy; 250];
-    let mut b: [[f64; 250]; 250] = [dummy; 250];
+    let mut a: [[f64; 90]; 90] = [dummy; 90];
+    let mut b: [[f64; 90]; 90] = [dummy; 90];
 
     // Init
     let mut i: i64 = 0;
     while i < n {
-        a[i] = [0.0; 250];
-        b[i] = [0.0; 250];
+        a[i] = [0.0; 90];
+        b[i] = [0.0; 90];
         i += 1;
     }
 
diff --git a/benchmarks/passing/polybench/stencils/seidel-2d.rs b/benchmarks/passing/polybench/stencils/seidel-2d.rs
index 4a48e5fa5..b59c9653a 100644
--- a/benchmarks/passing/polybench/stencils/seidel-2d.rs
+++ b/benchmarks/passing/polybench/stencils/seidel-2d.rs
@@ -1,4 +1,4 @@
-fn init_array(n: i64, nf: f64, a: &mut [[f64; 400]; 400]) {
+fn init_array(n: i64, nf: f64, a: &mut [[f64; 120]; 120]) {
     let mut i: i64 = 0;
     let mut fi: f64 = 0.0;
     while i < n {
@@ -14,7 +14,7 @@ fn init_array(n: i64, nf: f64, a: &mut [[f64; 400]; 400]) {
     }
 }
 
-fn sum_array(n: i64, a: &[[f64; 400]; 400]) -> f64 {
+fn sum_array(n: i64, a: &[[f64; 120]; 120]) -> f64 {
     let mut sum: f64 = 0.0;
     let mut i: i64 = 0;
     while i < n {
@@ -32,7 +32,7 @@ fn sum_array(n: i64, a: &[[f64; 400]; 400]) -> f64 {
     return sum;
 }
 
-fn kernel_seidel_2d(tsteps: i64, n: i64, a: &mut [[f64; 400]; 400]) {
+fn kernel_seidel_2d(tsteps: i64, n: i64, a: &mut [[f64; 120]; 120]) {
     let mut t: i64 = 0;
     while t < tsteps {
         let mut i: i64 = 1;
@@ -58,17 +58,17 @@ fn kernel_seidel_2d(tsteps: i64, n: i64, a: &mut [[f64; 400]; 400]) {
 }
 
 fn main() {
-    let n: i64 = 400;
-    let nf: f64 = 400.0;
-    let tsteps: i64 = 100;
+    let n: i64 = 120;
+    let nf: f64 = 120.0;
+    let tsteps: i64 = 40;
 
-    let dummy: [f64; 400] = [0.0; 400];
-    let mut a: [[f64; 400]; 400] = [dummy; 400];
+    let dummy: [f64; 120] = [0.0; 120];
+    let mut a: [[f64; 120]; 120] = [dummy; 120];
 
     // Init
     let mut i: i64 = 0;
     while i < n {
-        a[i] = [0.0; 400];
+        a[i] = [0.0; 120];
         i += 1;
     }
     drop(dummy);

From 2bd84f7c9b796d667908694bd3e41c1a9e10c671 Mon Sep 17 00:00:00 2001
From: Anjali Pal <anjalip@cs.washington.edu>
Date: Sat, 22 Feb 2025 11:55:23 -0800
Subject: [PATCH 11/14] probably fix fdtd

---
 .../passing/polybench/stencils/fdtd-2d.rs     |  7 ++--
 post.py                                       | 28 ++++++++++++++
 run                                           | 37 +++++++++++++++++++
 3 files changed, 69 insertions(+), 3 deletions(-)
 create mode 100644 post.py
 create mode 100755 run

diff --git a/benchmarks/passing/polybench/stencils/fdtd-2d.rs b/benchmarks/passing/polybench/stencils/fdtd-2d.rs
index c3d9e0f1c..6a9d93ce7 100644
--- a/benchmarks/passing/polybench/stencils/fdtd-2d.rs
+++ b/benchmarks/passing/polybench/stencils/fdtd-2d.rs
@@ -100,8 +100,8 @@ fn sum_array(
 ) -> f64 {
     let mut sum: f64 = 0.0;
     let mut i: i64 = 0;
+    let mut j: i64 = 0;
     while i < nx {
-        let mut j: i64 = 0;
         while j < ny {
             let x: f64 = ex[i as usize][j as usize];
             // Can't print multiple things on nightly.
@@ -114,8 +114,8 @@ fn sum_array(
     }
 
     i = 0;
+    j = 0;
     while i < nx {
-        let mut j: i64 = 0;
         while j < ny {
             let x: f64 = ey[i as usize][j as usize];
             // Can't print multiple things on nightly.
@@ -128,8 +128,8 @@ fn sum_array(
     }
 
     i = 0;
+    j = 0;
     while i < nx {
-        let mut j: i64 = 0;
         while j < ny {
             let x: f64 = hz[i as usize][j as usize];
             // Can't print multiple things on nightly.
@@ -140,6 +140,7 @@ fn sum_array(
         }
         i += 1;
     }
+    return sum;
 }
 
 fn main() {
diff --git a/post.py b/post.py
new file mode 100644
index 000000000..3e49d83d0
--- /dev/null
+++ b/post.py
@@ -0,0 +1,28 @@
+import sys
+
+def process_file(filename):
+    try:
+        # Read the file contents
+        with open(filename, 'r') as file:
+            numbers = file.readlines()
+
+        # Convert to float, round to two decimal places, and format as strings
+        rounded_numbers = [f"{float(num.strip()):.2f}" for num in numbers if num.strip()]
+
+        # Group numbers into lines of 20
+        formatted_lines = [" ".join(rounded_numbers[i:i+20]) + " " for i in range(0, len(rounded_numbers), 20)]
+
+        # Write the processed numbers back to the file
+        with open(filename, 'w') as file:
+            file.write("\n".join(formatted_lines) + "\n")
+    
+    except Exception as e:
+        print(f"Error processing file {filename}: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("Usage: python3 post.py <filename>")
+        sys.exit(1)
+    
+    process_file(sys.argv[1])
diff --git a/run b/run
new file mode 100755
index 000000000..a85e635b4
--- /dev/null
+++ b/run
@@ -0,0 +1,37 @@
+#!/bin/bash
+
+# Define an array of category-filename pairs
+declare -a pairs=(
+    # "datamining correlation"
+    # "datamining covariance"
+    # "medley deriche"
+    # "medley floyd-warshall"
+    # "medley nussinov"
+    # "stencils adi"
+    "stencils fdtd-2d"
+    # "stencils heat-3d"
+    # "stencils jacobi-1d"
+    # "stencils jacobi-2d"
+    # "stencils seidel-2d"
+)
+
+# Loop through each pair
+for pair in "${pairs[@]}"; do
+    # Split the pair into category and filename
+    CATEGORY=$(echo $pair | awk '{print $1}')
+    FILENAME=$(echo $pair | awk '{print $2}')
+
+    echo "Running benchmark for CATEGORY: $CATEGORY, FILENAME: $FILENAME"
+
+    # Run the cargo command and redirect output
+    cargo run --release "benchmarks/passing/polybench/${CATEGORY}/${FILENAME}.rs" --interp > "small/${FILENAME}.out"
+
+    # Check if cargo run was successful
+    if [ $? -ne 0 ]; then
+        echo "Error: Cargo run failed for $CATEGORY/$FILENAME."
+        continue  # Skip to the next iteration
+    fi
+
+    # Run the post-processing script on the output file
+    python3 post.py "small/${FILENAME}.out"
+done
\ No newline at end of file

From 7f2e9c12bdc6eac734cb72df25ab895446f54e31 Mon Sep 17 00:00:00 2001
From: Anjali Pal <anjalip@cs.washington.edu>
Date: Sat, 22 Feb 2025 12:33:18 -0800
Subject: [PATCH 12/14] make returns explicit

---
 benchmarks/passing/polybench/medley/floyd-warshall.rs | 6 ++++--
 benchmarks/passing/polybench/medley/nussinov.rs       | 6 ++++--
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/benchmarks/passing/polybench/medley/floyd-warshall.rs b/benchmarks/passing/polybench/medley/floyd-warshall.rs
index b0353eb3c..d69d2098e 100644
--- a/benchmarks/passing/polybench/medley/floyd-warshall.rs
+++ b/benchmarks/passing/polybench/medley/floyd-warshall.rs
@@ -1,11 +1,13 @@
 fn modulo(a: i64, b: i64) -> i64 {
     let div: i64 = a / b; // Integer division
     let remainder: i64 = a - (div * b); // Compute remainder manually
+    let mut res: i64 = 0;
     if remainder < 0 {
-        return remainder + b; // Ensure non-negative result
+        res = remainder + b; // Ensure non-negative result
     } else {
-        return remainder;
+        res = remainder;
     }
+    return res;
 }
 
 fn init_array(n: i64, path: &mut [[i64; 180]; 180]) {
diff --git a/benchmarks/passing/polybench/medley/nussinov.rs b/benchmarks/passing/polybench/medley/nussinov.rs
index afff3c59c..657b736c6 100644
--- a/benchmarks/passing/polybench/medley/nussinov.rs
+++ b/benchmarks/passing/polybench/medley/nussinov.rs
@@ -1,11 +1,13 @@
 fn modulo(a: i64, b: i64) -> i64 {
     let div: i64 = a / b; // Integer division
     let remainder: i64 = a - (div * b); // Compute remainder manually
+    let mut res: i64 = 0;
     if remainder < 0 {
-        return remainder + b; // Ensure non-negative result
+        res = remainder + b; // Ensure non-negative result
     } else {
-        return remainder;
+        res = remainder;
     }
+    return res;
 }
 
 fn max_score(s1: i64, s2: i64) -> i64 {

From 3019f9c86533e318f6cd99d3957b9d033a11a10e Mon Sep 17 00:00:00 2001
From: Anjali Pal <anjalip@cs.washington.edu>
Date: Sat, 22 Feb 2025 13:05:56 -0800
Subject: [PATCH 13/14] oops one more

---
 benchmarks/passing/polybench/medley/nussinov.rs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/benchmarks/passing/polybench/medley/nussinov.rs b/benchmarks/passing/polybench/medley/nussinov.rs
index 657b736c6..f5733d456 100644
--- a/benchmarks/passing/polybench/medley/nussinov.rs
+++ b/benchmarks/passing/polybench/medley/nussinov.rs
@@ -11,19 +11,23 @@ fn modulo(a: i64, b: i64) -> i64 {
 }
 
 fn max_score(s1: i64, s2: i64) -> i64 {
+    let mut res: i64 = 0;
     if s1 >= s2 {
-        return s1;
+        res = s1;
     } else {
-        return s2;
+        res = s2;
     }
+    return res;
 }
 
 fn match_base(b1: i64, b2: i64) -> i64 {
+    let mut res: i64 = 0;
     if (b1 + b2) == 3 {
-        return 1;
+        res = 1;
     } else {
-        return 0;
+        res = 0;
     }
+    return res;
 }
 
 fn init_array(n: i64, seq: &mut [i64; 180], table: &mut [[i64; 180]; 180]) {

From bd5b0eaf68a44926746f438cad47d4285d9fa9d5 Mon Sep 17 00:00:00 2001
From: Anjali Pal <anjalip@cs.washington.edu>
Date: Sat, 22 Feb 2025 13:59:42 -0800
Subject: [PATCH 14/14] oops

---
 post.py          | 28 ----------------------------
 res/nussinov.out |  1 -
 run              | 37 -------------------------------------
 3 files changed, 66 deletions(-)
 delete mode 100644 post.py
 delete mode 100644 res/nussinov.out
 delete mode 100755 run

diff --git a/post.py b/post.py
deleted file mode 100644
index 3e49d83d0..000000000
--- a/post.py
+++ /dev/null
@@ -1,28 +0,0 @@
-import sys
-
-def process_file(filename):
-    try:
-        # Read the file contents
-        with open(filename, 'r') as file:
-            numbers = file.readlines()
-
-        # Convert to float, round to two decimal places, and format as strings
-        rounded_numbers = [f"{float(num.strip()):.2f}" for num in numbers if num.strip()]
-
-        # Group numbers into lines of 20
-        formatted_lines = [" ".join(rounded_numbers[i:i+20]) + " " for i in range(0, len(rounded_numbers), 20)]
-
-        # Write the processed numbers back to the file
-        with open(filename, 'w') as file:
-            file.write("\n".join(formatted_lines) + "\n")
-    
-    except Exception as e:
-        print(f"Error processing file {filename}: {e}")
-        sys.exit(1)
-
-if __name__ == "__main__":
-    if len(sys.argv) != 2:
-        print("Usage: python3 post.py <filename>")
-        sys.exit(1)
-    
-    process_file(sys.argv[1])
diff --git a/res/nussinov.out b/res/nussinov.out
deleted file mode 100644
index e271f4dfa..000000000
--- a/res/nussinov.out
+++ /dev/null
@@ -1 +0,0 @@
-10292124.00 
diff --git a/run b/run
deleted file mode 100755
index a85e635b4..000000000
--- a/run
+++ /dev/null
@@ -1,37 +0,0 @@
-#!/bin/bash
-
-# Define an array of category-filename pairs
-declare -a pairs=(
-    # "datamining correlation"
-    # "datamining covariance"
-    # "medley deriche"
-    # "medley floyd-warshall"
-    # "medley nussinov"
-    # "stencils adi"
-    "stencils fdtd-2d"
-    # "stencils heat-3d"
-    # "stencils jacobi-1d"
-    # "stencils jacobi-2d"
-    # "stencils seidel-2d"
-)
-
-# Loop through each pair
-for pair in "${pairs[@]}"; do
-    # Split the pair into category and filename
-    CATEGORY=$(echo $pair | awk '{print $1}')
-    FILENAME=$(echo $pair | awk '{print $2}')
-
-    echo "Running benchmark for CATEGORY: $CATEGORY, FILENAME: $FILENAME"
-
-    # Run the cargo command and redirect output
-    cargo run --release "benchmarks/passing/polybench/${CATEGORY}/${FILENAME}.rs" --interp > "small/${FILENAME}.out"
-
-    # Check if cargo run was successful
-    if [ $? -ne 0 ]; then
-        echo "Error: Cargo run failed for $CATEGORY/$FILENAME."
-        continue  # Skip to the next iteration
-    fi
-
-    # Run the post-processing script on the output file
-    python3 post.py "small/${FILENAME}.out"
-done
\ No newline at end of file