diff --git a/Cargo.lock b/Cargo.lock
index e6b0b0f14f1..7a4ebbff8d1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3485,6 +3485,7 @@ dependencies = [
  "cfg-if",
  "chrono",
  "fxhash",
+ "glob",
  "im",
  "iter-extended",
  "noirc_errors",
diff --git a/compiler/noirc_evaluator/Cargo.toml b/compiler/noirc_evaluator/Cargo.toml
index f9cc2e7b3bf..35f426d08ec 100644
--- a/compiler/noirc_evaluator/Cargo.toml
+++ b/compiler/noirc_evaluator/Cargo.toml
@@ -39,6 +39,7 @@ similar-asserts.workspace = true
 tracing-test = "0.2.5"
 num-traits.workspace = true
 test-case.workspace = true
+glob = "0.3.2"
 
 [features]
 bn254 = ["noirc_frontend/bn254"]
diff --git a/compiler/noirc_evaluator/src/ssa/opt/array_set.rs b/compiler/noirc_evaluator/src/ssa/opt/array_set.rs
index 7bef8e7b1ae..9355c10a565 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/array_set.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/array_set.rs
@@ -191,7 +191,14 @@ fn make_mutable(
 
 #[cfg(test)]
 mod tests {
-    use crate::ssa::{Ssa, opt::assert_normalized_ssa_equals};
+    use crate::ssa::Ssa;
+
+    use crate::ssa::{opt::assert_normalized_ssa_equals, opt::run_snapshots};
+
+    #[test]
+    fn array_set_optimization_snapshots() {
+        run_snapshots("array_set_optimizations", Ssa::array_set_optimization);
+    }
 
     #[test]
     fn array_set_in_loop_with_conditional_clone() {
diff --git a/compiler/noirc_evaluator/src/ssa/opt/as_slice_length.rs b/compiler/noirc_evaluator/src/ssa/opt/as_slice_length.rs
index c6cdffd3bc3..18ff8170f01 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/as_slice_length.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/as_slice_length.rs
@@ -78,10 +78,15 @@ fn replace_known_slice_lengths(
 
 #[cfg(test)]
 mod test {
-    use crate::ssa::opt::assert_normalized_ssa_equals;
+    use crate::ssa::opt::{assert_normalized_ssa_equals, run_snapshots};
 
     use super::Ssa;
 
+    #[test]
+    fn as_slice_length_snapshots() {
+        run_snapshots("as_slice_optimization", Ssa::as_slice_optimization);
+    }
+
     #[test]
     fn as_slice_length_optimization() {
         // In this code we expect `return v2` to be replaced with `return u32 3` because
diff --git a/compiler/noirc_evaluator/src/ssa/opt/assert_constant.rs b/compiler/noirc_evaluator/src/ssa/opt/assert_constant.rs
index 192c0f59344..186f510c8a8 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/assert_constant.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/assert_constant.rs
@@ -132,3 +132,15 @@ fn evaluate_static_assert(
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::ssa::opt::run_snapshots;
+
+    #[test]
+    fn assert_constant_snapshots() {
+        run_snapshots("static_assert_and_assert_constant", |ssa| {
+            ssa.evaluate_static_assert_and_assert_constant().unwrap()
+        });
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/basic_conditional.rs b/compiler/noirc_evaluator/src/ssa/opt/basic_conditional.rs
index a534e394b78..12cc01fdf9b 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/basic_conditional.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/basic_conditional.rs
@@ -387,7 +387,15 @@ impl Context<'_> {
 
 #[cfg(test)]
 mod test {
-    use crate::ssa::{Ssa, opt::assert_normalized_ssa_equals};
+    use crate::ssa::{
+        Ssa,
+        opt::{assert_normalized_ssa_equals, run_snapshots},
+    };
+
+    #[test]
+    fn flatten_basic_conditional_snapshots() {
+        run_snapshots("simplify_conditionals_for_unconstrained", Ssa::flatten_basic_conditionals);
+    }
 
     #[test]
     fn basic_jmpif() {
diff --git a/compiler/noirc_evaluator/src/ssa/opt/brillig_array_gets.rs b/compiler/noirc_evaluator/src/ssa/opt/brillig_array_gets.rs
index c5d485dd161..abb41a57ea8 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/brillig_array_gets.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/brillig_array_gets.rs
@@ -84,10 +84,15 @@ impl Function {
 
 #[cfg(test)]
 mod tests {
-    use crate::ssa::opt::assert_normalized_ssa_equals;
+    use crate::ssa::opt::{assert_normalized_ssa_equals, run_snapshots};
 
     use super::Ssa;
 
+    #[test]
+    fn brillig_array_gets_snapshots() {
+        run_snapshots("brillig_array_get_optimizations", Ssa::brillig_array_gets);
+    }
+
     #[test]
     fn offset_array_get_constant_index() {
         let src = "
diff --git a/compiler/noirc_evaluator/src/ssa/opt/brillig_entry_points.rs b/compiler/noirc_evaluator/src/ssa/opt/brillig_entry_points.rs
index a2844a59997..527aefa479e 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/brillig_entry_points.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/brillig_entry_points.rs
@@ -296,10 +296,15 @@ pub(crate) fn build_inner_call_to_entry_points(
 
 #[cfg(test)]
 mod tests {
-    use crate::ssa::opt::assert_normalized_ssa_equals;
+    use crate::ssa::opt::{assert_normalized_ssa_equals, run_snapshots};
 
     use super::Ssa;
 
+    #[test]
+    fn brillig_entry_point_analysis_snapshots() {
+        run_snapshots("brillig_entry_point_analysis", Ssa::brillig_entry_point_analysis);
+    }
+
     #[test]
     fn duplicate_inner_call_with_multiple_entry_points() {
         let src = "
diff --git a/compiler/noirc_evaluator/src/ssa/opt/check_u128_mul_overflow.rs b/compiler/noirc_evaluator/src/ssa/opt/check_u128_mul_overflow.rs
index ae0c0f1e103..09b73f2f8e9 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/check_u128_mul_overflow.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/check_u128_mul_overflow.rs
@@ -134,7 +134,15 @@ fn check_u128_mul_overflow(
 
 #[cfg(test)]
 mod tests {
-    use crate::ssa::{opt::assert_normalized_ssa_equals, ssa_gen::Ssa};
+    use crate::ssa::{
+        opt::{assert_normalized_ssa_equals, run_snapshots},
+        ssa_gen::Ssa,
+    };
+
+    #[test]
+    fn check_u128_mul_overflow_snapshots() {
+        run_snapshots("check_u128_mul_overflow", Ssa::check_u128_mul_overflow);
+    }
 
     #[test]
     fn does_not_insert_check_if_lhs_is_less_than_two_pow_64() {
diff --git a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
index 6b3693096d8..b2a642f230d 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/constant_folding.rs
@@ -943,10 +943,20 @@ mod test {
                 map::Id,
                 types::{NumericType, Type},
             },
-            opt::assert_normalized_ssa_equals,
+            opt::{assert_normalized_ssa_equals, run_snapshots},
         },
     };
 
+    #[test]
+    fn fold_constants_snapshots() {
+        run_snapshots("constant_folding", Ssa::fold_constants);
+    }
+
+    #[test]
+    fn fold_constraints_snapshots() {
+        run_snapshots("constraint_folding", Ssa::fold_constants_using_constraints);
+    }
+
     #[test]
     fn simple_constant_fold() {
         // After constructing this IR, we set the value of v0 to 2.
diff --git a/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs b/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
index 851918a497c..c32c4ce0af7 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/defunctionalize.rs
@@ -439,10 +439,16 @@ fn build_return_block(
 
 #[cfg(test)]
 mod tests {
-    use crate::ssa::opt::assert_normalized_ssa_equals;
+
+    use crate::ssa::opt::{assert_normalized_ssa_equals, run_snapshots};
 
     use super::Ssa;
 
+    #[test]
+    fn defunctionalize_snapshots() {
+        run_snapshots("defunctionalization", Ssa::defunctionalize);
+    }
+
     #[test]
     fn apply_inherits_caller_runtime() {
         // Extracted from `execution_success/brillig_fns_as_values` with `--force-brillig`
diff --git a/compiler/noirc_evaluator/src/ssa/opt/die.rs b/compiler/noirc_evaluator/src/ssa/opt/die.rs
index 5c732c210b1..9451555af26 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/die.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/die.rs
@@ -839,9 +839,14 @@ mod test {
             map::Id,
             types::{NumericType, Type},
         },
-        opt::assert_normalized_ssa_equals,
+        opt::{assert_normalized_ssa_equals, run_snapshots},
     };
 
+    #[test]
+    fn die_snapshots() {
+        run_snapshots("dead_instruction_elimination", Ssa::dead_instruction_elimination);
+    }
+
     #[test]
     fn dead_instruction_elimination() {
         let src = "
diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
index a25e3db2b08..5df87780666 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
@@ -859,9 +859,14 @@ mod test {
             instruction::{Instruction, TerminatorInstruction},
             value::{Value, ValueId},
         },
-        opt::assert_normalized_ssa_equals,
+        opt::{assert_normalized_ssa_equals, run_snapshots},
     };
 
+    #[test]
+    fn flatten_cfg_snapshots() {
+        run_snapshots("flattening", Ssa::flatten_cfg);
+    }
+
     #[test]
     fn basic_jmpif() {
         let src = "
diff --git a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
index 161eea182d6..0b827388e07 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs
@@ -797,9 +797,17 @@ mod test {
             map::Id,
             types::{NumericType, Type},
         },
-        opt::{assert_normalized_ssa_equals, inlining::inline_info::compute_bottom_up_order},
+        opt::{
+            assert_normalized_ssa_equals, inlining::inline_info::compute_bottom_up_order,
+            run_snapshots,
+        },
     };
 
+    #[test]
+    fn inlining_snapshots() {
+        run_snapshots("inlining", |ssa| ssa.inline_functions(i64::MAX));
+    }
+
     #[test]
     fn basic_inlining() {
         // fn foo {
diff --git a/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs b/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs
index 3708c34368d..391e8450098 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs
@@ -550,7 +550,12 @@ fn can_be_hoisted(
 #[cfg(test)]
 mod test {
     use crate::ssa::Ssa;
-    use crate::ssa::opt::assert_normalized_ssa_equals;
+    use crate::ssa::opt::{assert_normalized_ssa_equals, run_snapshots};
+
+    #[test]
+    fn loop_invariant_snapshots() {
+        run_snapshots("loop_invariant_code_motion", Ssa::loop_invariant_code_motion);
+    }
 
     #[test]
     fn simple_loop_invariant_code_motion() {
diff --git a/compiler/noirc_evaluator/src/ssa/opt/make_constrain_not_equal.rs b/compiler/noirc_evaluator/src/ssa/opt/make_constrain_not_equal.rs
index 28e59f92429..1b90e46b167 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/make_constrain_not_equal.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/make_constrain_not_equal.rs
@@ -70,3 +70,14 @@ impl Function {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+
+    use crate::ssa::{opt::run_snapshots, ssa_gen::Ssa};
+
+    #[test]
+    fn constrain_not_equal_snapshots() {
+        run_snapshots("adding_constrain_not_equal", Ssa::make_constrain_not_equal_instructions);
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
index 9d4dc99d392..846df262214 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs
@@ -681,9 +681,14 @@ mod tests {
             map::Id,
             types::Type,
         },
-        opt::assert_normalized_ssa_equals,
+        opt::{assert_normalized_ssa_equals, run_snapshots},
     };
 
+    #[test]
+    fn mem2reg_snapshots() {
+        run_snapshots("mem2reg", Ssa::mem2reg);
+    }
+
     #[test]
     fn test_simple() {
         // fn func() {
diff --git a/compiler/noirc_evaluator/src/ssa/opt/mod.rs b/compiler/noirc_evaluator/src/ssa/opt/mod.rs
index 27e0bf29679..2ccb2b17574 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/mod.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/mod.rs
@@ -79,3 +79,35 @@ pub(crate) fn assert_normalized_ssa_equals(mut ssa: super::Ssa, expected: &str)
     println!("Got:\n~~~\n{ssa}\n~~~");
     similar_asserts::assert_eq!(expected_ssa, ssa);
 }
+
+#[cfg(test)]
+fn run_snapshots(snapshot_title: &str, f: fn(super::ssa_gen::Ssa) -> super::ssa_gen::Ssa) {
+    use super::ssa_gen::Ssa;
+
+    let inputs = glob::glob(&format!("src/ssa/opt/snapshots/**/[0-9][0-9]_{snapshot_title}*"))
+        .expect("Failed to read glob pattern");
+
+    let mut empty_glob = true;
+    for path in inputs {
+        empty_glob = false;
+        let path = path.unwrap();
+
+        let index = &path.file_name().unwrap().to_str().unwrap()[0..2];
+        let next_index = index.parse::<u32>().unwrap() + 1;
+        let glob_pattern = format!("{}/{next_index:02}_*", path.parent().unwrap().display());
+        let output_file = glob::glob(&glob_pattern)
+            .expect("Failed to read glob pattern")
+            .next()
+            .unwrap()
+            .unwrap();
+
+        let src = std::fs::read_to_string(&path).unwrap();
+        let expected = std::fs::read_to_string(&output_file).unwrap();
+
+        let ssa = Ssa::from_str(&src).unwrap();
+
+        let ssa = f(ssa);
+        assert_normalized_ssa_equals(ssa, &expected);
+    }
+    assert!(!empty_glob, "Glob was empty");
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/preprocess_fns.rs b/compiler/noirc_evaluator/src/ssa/opt/preprocess_fns.rs
index 6fa1e88ee2d..49a9613fa84 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/preprocess_fns.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/preprocess_fns.rs
@@ -69,3 +69,14 @@ impl Ssa {
         self.remove_unreachable_functions()
     }
 }
+
+#[cfg(test)]
+mod tests {
+
+    use crate::ssa::opt::run_snapshots;
+
+    #[test]
+    fn preprocess_fns_snapshots() {
+        run_snapshots("preprocessing_functions", |ssa| ssa.preprocess_functions(i64::MAX));
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/pure.rs b/compiler/noirc_evaluator/src/ssa/opt/pure.rs
index b975413fc2e..88c1da3bd2b 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/pure.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/pure.rs
@@ -279,7 +279,16 @@ fn build_call_graph(
 
 #[cfg(test)]
 mod test {
-    use crate::ssa::{ir::function::FunctionId, opt::pure::Purity, ssa_gen::Ssa};
+    use crate::ssa::{
+        ir::function::FunctionId,
+        opt::{pure::Purity, run_snapshots},
+        ssa_gen::Ssa,
+    };
+
+    #[test]
+    fn purity_analysis_snapshots() {
+        run_snapshots("purity_analysis", Ssa::purity_analysis);
+    }
 
     #[test]
     fn classify_functions() {
diff --git a/compiler/noirc_evaluator/src/ssa/opt/rc.rs b/compiler/noirc_evaluator/src/ssa/opt/rc.rs
index 5fa60c7a3ec..a56433a0bef 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/rc.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/rc.rs
@@ -156,9 +156,15 @@ mod test {
 
     use crate::ssa::{
         ir::{basic_block::BasicBlockId, dfg::DataFlowGraph, instruction::Instruction},
+        opt::run_snapshots,
         ssa_gen::Ssa,
     };
 
+    #[test]
+    fn rc_snapshots() {
+        run_snapshots("removing_paired_rc_inc_&_rc_decs", Ssa::remove_paired_rc);
+    }
+
     fn count_inc_rcs(block: BasicBlockId, dfg: &DataFlowGraph) -> usize {
         dfg[block]
             .instructions()
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
index b4427a1c91b..5d5fe62b1ec 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs
@@ -381,3 +381,13 @@ impl Context<'_> {
         result
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::ssa::{opt::run_snapshots, ssa_gen::Ssa};
+
+    #[test]
+    fn remove_bit_shifts_snapshots() {
+        run_snapshots("removing_bit_shifts", Ssa::remove_bit_shifts);
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
index 3dcc54360ad..2093e2417fb 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_enable_side_effects.rs
@@ -207,8 +207,15 @@ mod test {
             map::Id,
             types::{NumericType, Type},
         },
+        opt::run_snapshots,
+        ssa_gen::Ssa,
     };
 
+    #[test]
+    fn remove_enable_side_effects_snapshots() {
+        run_snapshots("enablesideeffectsif_removal", Ssa::remove_enable_side_effects);
+    }
+
     #[test]
     fn remove_chains_of_same_condition() {
         //  acir(inline) fn main f0 {
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
index 94b0c1d0a85..cb57e65b51a 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_if_else.rs
@@ -241,3 +241,13 @@ fn slice_capacity_change(
         | Intrinsic::FieldLessThan => SizeChange::None,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::ssa::{opt::run_snapshots, ssa_gen::Ssa};
+
+    #[test]
+    fn remove_if_else_snapshots() {
+        run_snapshots("remove_ifelse", Ssa::remove_if_else);
+    }
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_truncate_after_range_check.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_truncate_after_range_check.rs
index 7655ca1943b..54b62affc50 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_truncate_after_range_check.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_truncate_after_range_check.rs
@@ -79,7 +79,15 @@ impl Function {
 
 #[cfg(test)]
 mod tests {
-    use crate::ssa::{opt::assert_normalized_ssa_equals, ssa_gen::Ssa};
+    use crate::ssa::{
+        opt::{assert_normalized_ssa_equals, run_snapshots},
+        ssa_gen::Ssa,
+    };
+
+    #[test]
+    fn remove_truncate_after_range_check_snapshots() {
+        run_snapshots("removing_truncate_after_rangecheck", Ssa::remove_truncate_after_range_check);
+    }
 
     #[test]
     fn removes_truncate_after_range_check_with_same_bit_size() {
diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable.rs
index 9b80b3a4d23..dfe64ec04a4 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable.rs
@@ -85,10 +85,15 @@ fn used_functions(func: &Function) -> BTreeSet<FunctionId> {
 
 #[cfg(test)]
 mod tests {
-    use crate::ssa::opt::assert_normalized_ssa_equals;
+    use crate::ssa::opt::{assert_normalized_ssa_equals, run_snapshots};
 
     use super::Ssa;
 
+    #[test]
+    fn remove_unreachable_functions_snapshots() {
+        run_snapshots("removing_unreachable_functions", Ssa::remove_unreachable_functions);
+    }
+
     #[test]
     fn remove_unused_brillig() {
         let src = "
diff --git a/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
index 3d812870c06..c526c93c8bf 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs
@@ -302,10 +302,15 @@ mod test {
             map::Id,
             types::Type,
         },
-        opt::assert_normalized_ssa_equals,
+        opt::{assert_normalized_ssa_equals, run_snapshots},
     };
     use acvm::acir::AcirField;
 
+    #[test]
+    fn simplify_cfg_snapshots() {
+        run_snapshots("simplifying", Ssa::simplify_cfg);
+    }
+
     #[test]
     fn inline_blocks() {
         // fn main {
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/00_initial_ssa b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/00_initial_ssa
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/01_removing_unreachable_functions_1 b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/01_removing_unreachable_functions_1
new file mode 100644
index 00000000000..50ba94caab6
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/01_removing_unreachable_functions_1
@@ -0,0 +1,53 @@
+acir(inline) fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v30 = shr v0, v2
+    v32 = eq v30, u128 3086
+    constrain v30 == u128 3086
+    v33 = shl v0, v2
+    v35 = lt v2, u8 128
+    constrain v35 == u1 1, "attempt to bit-shift with overflow"
+    v37 = truncate v33 to 128 bits, max_bit_size: 129
+    v39 = eq v33, u128 49380
+    constrain v33 == u128 49380
+    v40 = lt v0, v1
+    constrain v40 == u1 1
+    v41 = lt v1, v0
+    v42 = not v41
+    constrain v41 == u1 0
+    v44 = eq v0, v1
+    v45 = not v44
+    constrain v44 == u1 0
+    v46 = lt v0, v1
+    constrain v46 == u1 1
+    v47 = lt v1, v0
+    v48 = not v47
+    constrain v47 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/02_defunctionalization b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/02_defunctionalization
new file mode 100644
index 00000000000..50ba94caab6
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/02_defunctionalization
@@ -0,0 +1,53 @@
+acir(inline) fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v30 = shr v0, v2
+    v32 = eq v30, u128 3086
+    constrain v30 == u128 3086
+    v33 = shl v0, v2
+    v35 = lt v2, u8 128
+    constrain v35 == u1 1, "attempt to bit-shift with overflow"
+    v37 = truncate v33 to 128 bits, max_bit_size: 129
+    v39 = eq v33, u128 49380
+    constrain v33 == u128 49380
+    v40 = lt v0, v1
+    constrain v40 == u1 1
+    v41 = lt v1, v0
+    v42 = not v41
+    constrain v41 == u1 0
+    v44 = eq v0, v1
+    v45 = not v44
+    constrain v44 == u1 0
+    v46 = lt v0, v1
+    constrain v46 == u1 1
+    v47 = lt v1, v0
+    v48 = not v47
+    constrain v47 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/03_inlining_simple_functions b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/03_inlining_simple_functions
new file mode 100644
index 00000000000..50ba94caab6
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/03_inlining_simple_functions
@@ -0,0 +1,53 @@
+acir(inline) fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v30 = shr v0, v2
+    v32 = eq v30, u128 3086
+    constrain v30 == u128 3086
+    v33 = shl v0, v2
+    v35 = lt v2, u8 128
+    constrain v35 == u1 1, "attempt to bit-shift with overflow"
+    v37 = truncate v33 to 128 bits, max_bit_size: 129
+    v39 = eq v33, u128 49380
+    constrain v33 == u128 49380
+    v40 = lt v0, v1
+    constrain v40 == u1 1
+    v41 = lt v1, v0
+    v42 = not v41
+    constrain v41 == u1 0
+    v44 = eq v0, v1
+    v45 = not v44
+    constrain v44 == u1 0
+    v46 = lt v0, v1
+    constrain v46 == u1 1
+    v47 = lt v1, v0
+    v48 = not v47
+    constrain v47 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/04_removing_paired_rc_inc_&_rc_decs b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/04_removing_paired_rc_inc_&_rc_decs
new file mode 100644
index 00000000000..50ba94caab6
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/04_removing_paired_rc_inc_&_rc_decs
@@ -0,0 +1,53 @@
+acir(inline) fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v30 = shr v0, v2
+    v32 = eq v30, u128 3086
+    constrain v30 == u128 3086
+    v33 = shl v0, v2
+    v35 = lt v2, u8 128
+    constrain v35 == u1 1, "attempt to bit-shift with overflow"
+    v37 = truncate v33 to 128 bits, max_bit_size: 129
+    v39 = eq v33, u128 49380
+    constrain v33 == u128 49380
+    v40 = lt v0, v1
+    constrain v40 == u1 1
+    v41 = lt v1, v0
+    v42 = not v41
+    constrain v41 == u1 0
+    v44 = eq v0, v1
+    v45 = not v44
+    constrain v44 == u1 0
+    v46 = lt v0, v1
+    constrain v46 == u1 1
+    v47 = lt v1, v0
+    v48 = not v47
+    constrain v47 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/05_preprocessing_functions b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/05_preprocessing_functions
new file mode 100644
index 00000000000..50ba94caab6
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/05_preprocessing_functions
@@ -0,0 +1,53 @@
+acir(inline) fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v30 = shr v0, v2
+    v32 = eq v30, u128 3086
+    constrain v30 == u128 3086
+    v33 = shl v0, v2
+    v35 = lt v2, u8 128
+    constrain v35 == u1 1, "attempt to bit-shift with overflow"
+    v37 = truncate v33 to 128 bits, max_bit_size: 129
+    v39 = eq v33, u128 49380
+    constrain v33 == u128 49380
+    v40 = lt v0, v1
+    constrain v40 == u1 1
+    v41 = lt v1, v0
+    v42 = not v41
+    constrain v41 == u1 0
+    v44 = eq v0, v1
+    v45 = not v44
+    constrain v44 == u1 0
+    v46 = lt v0, v1
+    constrain v46 == u1 1
+    v47 = lt v1, v0
+    v48 = not v47
+    constrain v47 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/06_inlining_1 b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/06_inlining_1
new file mode 100644
index 00000000000..50ba94caab6
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/06_inlining_1
@@ -0,0 +1,53 @@
+acir(inline) fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v30 = shr v0, v2
+    v32 = eq v30, u128 3086
+    constrain v30 == u128 3086
+    v33 = shl v0, v2
+    v35 = lt v2, u8 128
+    constrain v35 == u1 1, "attempt to bit-shift with overflow"
+    v37 = truncate v33 to 128 bits, max_bit_size: 129
+    v39 = eq v33, u128 49380
+    constrain v33 == u128 49380
+    v40 = lt v0, v1
+    constrain v40 == u1 1
+    v41 = lt v1, v0
+    v42 = not v41
+    constrain v41 == u1 0
+    v44 = eq v0, v1
+    v45 = not v44
+    constrain v44 == u1 0
+    v46 = lt v0, v1
+    constrain v46 == u1 1
+    v47 = lt v1, v0
+    v48 = not v47
+    constrain v47 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/07_mem2reg_2 b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/07_mem2reg_2
new file mode 100644
index 00000000000..50ba94caab6
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/07_mem2reg_2
@@ -0,0 +1,53 @@
+acir(inline) fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v30 = shr v0, v2
+    v32 = eq v30, u128 3086
+    constrain v30 == u128 3086
+    v33 = shl v0, v2
+    v35 = lt v2, u8 128
+    constrain v35 == u1 1, "attempt to bit-shift with overflow"
+    v37 = truncate v33 to 128 bits, max_bit_size: 129
+    v39 = eq v33, u128 49380
+    constrain v33 == u128 49380
+    v40 = lt v0, v1
+    constrain v40 == u1 1
+    v41 = lt v1, v0
+    v42 = not v41
+    constrain v41 == u1 0
+    v44 = eq v0, v1
+    v45 = not v44
+    constrain v44 == u1 0
+    v46 = lt v0, v1
+    constrain v46 == u1 1
+    v47 = lt v1, v0
+    v48 = not v47
+    constrain v47 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/08_simplifying_1 b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/08_simplifying_1
new file mode 100644
index 00000000000..50ba94caab6
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/08_simplifying_1
@@ -0,0 +1,53 @@
+acir(inline) fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v30 = shr v0, v2
+    v32 = eq v30, u128 3086
+    constrain v30 == u128 3086
+    v33 = shl v0, v2
+    v35 = lt v2, u8 128
+    constrain v35 == u1 1, "attempt to bit-shift with overflow"
+    v37 = truncate v33 to 128 bits, max_bit_size: 129
+    v39 = eq v33, u128 49380
+    constrain v33 == u128 49380
+    v40 = lt v0, v1
+    constrain v40 == u1 1
+    v41 = lt v1, v0
+    v42 = not v41
+    constrain v41 == u1 0
+    v44 = eq v0, v1
+    v45 = not v44
+    constrain v44 == u1 0
+    v46 = lt v0, v1
+    constrain v46 == u1 1
+    v47 = lt v1, v0
+    v48 = not v47
+    constrain v47 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/09_as_slice_optimization b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/09_as_slice_optimization
new file mode 100644
index 00000000000..50ba94caab6
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/09_as_slice_optimization
@@ -0,0 +1,53 @@
+acir(inline) fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v30 = shr v0, v2
+    v32 = eq v30, u128 3086
+    constrain v30 == u128 3086
+    v33 = shl v0, v2
+    v35 = lt v2, u8 128
+    constrain v35 == u1 1, "attempt to bit-shift with overflow"
+    v37 = truncate v33 to 128 bits, max_bit_size: 129
+    v39 = eq v33, u128 49380
+    constrain v33 == u128 49380
+    v40 = lt v0, v1
+    constrain v40 == u1 1
+    v41 = lt v1, v0
+    v42 = not v41
+    constrain v41 == u1 0
+    v44 = eq v0, v1
+    v45 = not v44
+    constrain v44 == u1 0
+    v46 = lt v0, v1
+    constrain v46 == u1 1
+    v47 = lt v1, v0
+    v48 = not v47
+    constrain v47 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/10_removing_unreachable_functions_2 b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/10_removing_unreachable_functions_2
new file mode 100644
index 00000000000..50ba94caab6
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/10_removing_unreachable_functions_2
@@ -0,0 +1,53 @@
+acir(inline) fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v30 = shr v0, v2
+    v32 = eq v30, u128 3086
+    constrain v30 == u128 3086
+    v33 = shl v0, v2
+    v35 = lt v2, u8 128
+    constrain v35 == u1 1, "attempt to bit-shift with overflow"
+    v37 = truncate v33 to 128 bits, max_bit_size: 129
+    v39 = eq v33, u128 49380
+    constrain v33 == u128 49380
+    v40 = lt v0, v1
+    constrain v40 == u1 1
+    v41 = lt v1, v0
+    v42 = not v41
+    constrain v41 == u1 0
+    v44 = eq v0, v1
+    v45 = not v44
+    constrain v44 == u1 0
+    v46 = lt v0, v1
+    constrain v46 == u1 1
+    v47 = lt v1, v0
+    v48 = not v47
+    constrain v47 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/11_static_assert_and_assert_constant b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/11_static_assert_and_assert_constant
new file mode 100644
index 00000000000..50ba94caab6
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/11_static_assert_and_assert_constant
@@ -0,0 +1,53 @@
+acir(inline) fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v30 = shr v0, v2
+    v32 = eq v30, u128 3086
+    constrain v30 == u128 3086
+    v33 = shl v0, v2
+    v35 = lt v2, u8 128
+    constrain v35 == u1 1, "attempt to bit-shift with overflow"
+    v37 = truncate v33 to 128 bits, max_bit_size: 129
+    v39 = eq v33, u128 49380
+    constrain v33 == u128 49380
+    v40 = lt v0, v1
+    constrain v40 == u1 1
+    v41 = lt v1, v0
+    v42 = not v41
+    constrain v41 == u1 0
+    v44 = eq v0, v1
+    v45 = not v44
+    constrain v44 == u1 0
+    v46 = lt v0, v1
+    constrain v46 == u1 1
+    v47 = lt v1, v0
+    v48 = not v47
+    constrain v47 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/12_purity_analysis b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/12_purity_analysis
new file mode 100644
index 00000000000..50ba94caab6
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/12_purity_analysis
@@ -0,0 +1,53 @@
+acir(inline) fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v30 = shr v0, v2
+    v32 = eq v30, u128 3086
+    constrain v30 == u128 3086
+    v33 = shl v0, v2
+    v35 = lt v2, u8 128
+    constrain v35 == u1 1, "attempt to bit-shift with overflow"
+    v37 = truncate v33 to 128 bits, max_bit_size: 129
+    v39 = eq v33, u128 49380
+    constrain v33 == u128 49380
+    v40 = lt v0, v1
+    constrain v40 == u1 1
+    v41 = lt v1, v0
+    v42 = not v41
+    constrain v41 == u1 0
+    v44 = eq v0, v1
+    v45 = not v44
+    constrain v44 == u1 0
+    v46 = lt v0, v1
+    constrain v46 == u1 1
+    v47 = lt v1, v0
+    v48 = not v47
+    constrain v47 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/13_loop_invariant_code_motion b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/13_loop_invariant_code_motion
new file mode 100644
index 00000000000..513ba0e84e3
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/13_loop_invariant_code_motion
@@ -0,0 +1,53 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v30 = shr v0, v2
+    v32 = eq v30, u128 3086
+    constrain v30 == u128 3086
+    v33 = shl v0, v2
+    v35 = lt v2, u8 128
+    constrain v35 == u1 1, "attempt to bit-shift with overflow"
+    v37 = truncate v33 to 128 bits, max_bit_size: 129
+    v39 = eq v33, u128 49380
+    constrain v33 == u128 49380
+    v40 = lt v0, v1
+    constrain v40 == u1 1
+    v41 = lt v1, v0
+    v42 = not v41
+    constrain v41 == u1 0
+    v44 = eq v0, v1
+    v45 = not v44
+    constrain v44 == u1 0
+    v46 = lt v0, v1
+    constrain v46 == u1 1
+    v47 = lt v1, v0
+    v48 = not v47
+    constrain v47 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/14_unrolling b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/14_unrolling
new file mode 100644
index 00000000000..513ba0e84e3
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/14_unrolling
@@ -0,0 +1,53 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v30 = shr v0, v2
+    v32 = eq v30, u128 3086
+    constrain v30 == u128 3086
+    v33 = shl v0, v2
+    v35 = lt v2, u8 128
+    constrain v35 == u1 1, "attempt to bit-shift with overflow"
+    v37 = truncate v33 to 128 bits, max_bit_size: 129
+    v39 = eq v33, u128 49380
+    constrain v33 == u128 49380
+    v40 = lt v0, v1
+    constrain v40 == u1 1
+    v41 = lt v1, v0
+    v42 = not v41
+    constrain v41 == u1 0
+    v44 = eq v0, v1
+    v45 = not v44
+    constrain v44 == u1 0
+    v46 = lt v0, v1
+    constrain v46 == u1 1
+    v47 = lt v1, v0
+    v48 = not v47
+    constrain v47 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/15_simplifying_2 b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/15_simplifying_2
new file mode 100644
index 00000000000..513ba0e84e3
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/15_simplifying_2
@@ -0,0 +1,53 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v30 = shr v0, v2
+    v32 = eq v30, u128 3086
+    constrain v30 == u128 3086
+    v33 = shl v0, v2
+    v35 = lt v2, u8 128
+    constrain v35 == u1 1, "attempt to bit-shift with overflow"
+    v37 = truncate v33 to 128 bits, max_bit_size: 129
+    v39 = eq v33, u128 49380
+    constrain v33 == u128 49380
+    v40 = lt v0, v1
+    constrain v40 == u1 1
+    v41 = lt v1, v0
+    v42 = not v41
+    constrain v41 == u1 0
+    v44 = eq v0, v1
+    v45 = not v44
+    constrain v44 == u1 0
+    v46 = lt v0, v1
+    constrain v46 == u1 1
+    v47 = lt v1, v0
+    v48 = not v47
+    constrain v47 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/16_mem2reg_3 b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/16_mem2reg_3
new file mode 100644
index 00000000000..513ba0e84e3
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/16_mem2reg_3
@@ -0,0 +1,53 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v30 = shr v0, v2
+    v32 = eq v30, u128 3086
+    constrain v30 == u128 3086
+    v33 = shl v0, v2
+    v35 = lt v2, u8 128
+    constrain v35 == u1 1, "attempt to bit-shift with overflow"
+    v37 = truncate v33 to 128 bits, max_bit_size: 129
+    v39 = eq v33, u128 49380
+    constrain v33 == u128 49380
+    v40 = lt v0, v1
+    constrain v40 == u1 1
+    v41 = lt v1, v0
+    v42 = not v41
+    constrain v41 == u1 0
+    v44 = eq v0, v1
+    v45 = not v44
+    constrain v44 == u1 0
+    v46 = lt v0, v1
+    constrain v46 == u1 1
+    v47 = lt v1, v0
+    v48 = not v47
+    constrain v47 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/17_flattening b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/17_flattening
new file mode 100644
index 00000000000..513ba0e84e3
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/17_flattening
@@ -0,0 +1,53 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v30 = shr v0, v2
+    v32 = eq v30, u128 3086
+    constrain v30 == u128 3086
+    v33 = shl v0, v2
+    v35 = lt v2, u8 128
+    constrain v35 == u1 1, "attempt to bit-shift with overflow"
+    v37 = truncate v33 to 128 bits, max_bit_size: 129
+    v39 = eq v33, u128 49380
+    constrain v33 == u128 49380
+    v40 = lt v0, v1
+    constrain v40 == u1 1
+    v41 = lt v1, v0
+    v42 = not v41
+    constrain v41 == u1 0
+    v44 = eq v0, v1
+    v45 = not v44
+    constrain v44 == u1 0
+    v46 = lt v0, v1
+    constrain v46 == u1 1
+    v47 = lt v1, v0
+    v48 = not v47
+    constrain v47 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/18_removing_bit_shifts b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/18_removing_bit_shifts
new file mode 100644
index 00000000000..513ba0e84e3
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/18_removing_bit_shifts
@@ -0,0 +1,53 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v30 = shr v0, v2
+    v32 = eq v30, u128 3086
+    constrain v30 == u128 3086
+    v33 = shl v0, v2
+    v35 = lt v2, u8 128
+    constrain v35 == u1 1, "attempt to bit-shift with overflow"
+    v37 = truncate v33 to 128 bits, max_bit_size: 129
+    v39 = eq v33, u128 49380
+    constrain v33 == u128 49380
+    v40 = lt v0, v1
+    constrain v40 == u1 1
+    v41 = lt v1, v0
+    v42 = not v41
+    constrain v41 == u1 0
+    v44 = eq v0, v1
+    v45 = not v44
+    constrain v44 == u1 0
+    v46 = lt v0, v1
+    constrain v46 == u1 1
+    v47 = lt v1, v0
+    v48 = not v47
+    constrain v47 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/19_mem2reg_4 b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/19_mem2reg_4
new file mode 100644
index 00000000000..94ca8e2a516
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/19_mem2reg_4
@@ -0,0 +1,209 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v31 = call to_le_bits(v2) -> [u1; 8]
+    v33 = array_get v31, index Field 7 -> u1
+    v34 = not v33
+    v35 = cast v33 as Field
+    v36 = cast v34 as Field
+    v38 = mul Field 2, v35
+    v39 = add v38, v36
+    v40 = mul v39, v39
+    v41 = mul v40, Field 2
+    v43 = array_get v31, index Field 6 -> u1
+    v44 = not v43
+    v45 = cast v43 as Field
+    v46 = cast v44 as Field
+    v47 = mul v41, v45
+    v48 = mul v40, v46
+    v49 = add v47, v48
+    v50 = mul v49, v49
+    v51 = mul v50, Field 2
+    v53 = array_get v31, index Field 5 -> u1
+    v54 = not v53
+    v55 = cast v53 as Field
+    v56 = cast v54 as Field
+    v57 = mul v51, v55
+    v58 = mul v50, v56
+    v59 = add v57, v58
+    v60 = mul v59, v59
+    v61 = mul v60, Field 2
+    v63 = array_get v31, index Field 4 -> u1
+    v64 = not v63
+    v65 = cast v63 as Field
+    v66 = cast v64 as Field
+    v67 = mul v61, v65
+    v68 = mul v60, v66
+    v69 = add v67, v68
+    v70 = mul v69, v69
+    v71 = mul v70, Field 2
+    v73 = array_get v31, index Field 3 -> u1
+    v74 = not v73
+    v75 = cast v73 as Field
+    v76 = cast v74 as Field
+    v77 = mul v71, v75
+    v78 = mul v70, v76
+    v79 = add v77, v78
+    v80 = mul v79, v79
+    v81 = mul v80, Field 2
+    v82 = array_get v31, index Field 2 -> u1
+    v83 = not v82
+    v84 = cast v82 as Field
+    v85 = cast v83 as Field
+    v86 = mul v81, v84
+    v87 = mul v80, v85
+    v88 = add v86, v87
+    v89 = mul v88, v88
+    v90 = mul v89, Field 2
+    v92 = array_get v31, index Field 1 -> u1
+    v93 = not v92
+    v94 = cast v92 as Field
+    v95 = cast v93 as Field
+    v96 = mul v90, v94
+    v97 = mul v89, v95
+    v98 = add v96, v97
+    v99 = mul v98, v98
+    v100 = mul v99, Field 2
+    v102 = array_get v31, index Field 0 -> u1
+    v103 = not v102
+    v104 = cast v102 as Field
+    v105 = cast v103 as Field
+    v106 = mul v100, v104
+    v107 = mul v99, v105
+    v108 = add v106, v107
+    v110 = lt v2, u8 128
+    v111 = not v110
+    v112 = cast v110 as Field
+    v113 = cast v111 as Field
+    v114 = mul v112, v108
+    v116 = mul v113, Field 340282366920938463463374607431768211455
+    v117 = add v114, v116
+    v118 = cast v117 as u128
+    v119 = div v0, v118
+    v121 = eq v119, u128 3086
+    constrain v119 == u128 3086
+    v122 = lt v2, u8 128
+    v123 = cast v122 as u128
+    v124 = call to_le_bits(v2) -> [u1; 8]
+    v125 = array_get v124, index Field 7 -> u1
+    v126 = not v125
+    v127 = cast v125 as Field
+    v128 = cast v126 as Field
+    v129 = mul Field 2, v127
+    v130 = add v129, v128
+    v131 = mul v130, v130
+    v132 = mul v131, Field 2
+    v133 = array_get v124, index Field 6 -> u1
+    v134 = not v133
+    v135 = cast v133 as Field
+    v136 = cast v134 as Field
+    v137 = mul v132, v135
+    v138 = mul v131, v136
+    v139 = add v137, v138
+    v140 = mul v139, v139
+    v141 = mul v140, Field 2
+    v142 = array_get v124, index Field 5 -> u1
+    v143 = not v142
+    v144 = cast v142 as Field
+    v145 = cast v143 as Field
+    v146 = mul v141, v144
+    v147 = mul v140, v145
+    v148 = add v146, v147
+    v149 = mul v148, v148
+    v150 = mul v149, Field 2
+    v151 = array_get v124, index Field 4 -> u1
+    v152 = not v151
+    v153 = cast v151 as Field
+    v154 = cast v152 as Field
+    v155 = mul v150, v153
+    v156 = mul v149, v154
+    v157 = add v155, v156
+    v158 = mul v157, v157
+    v159 = mul v158, Field 2
+    v160 = array_get v124, index Field 3 -> u1
+    v161 = not v160
+    v162 = cast v160 as Field
+    v163 = cast v161 as Field
+    v164 = mul v159, v162
+    v165 = mul v158, v163
+    v166 = add v164, v165
+    v167 = mul v166, v166
+    v168 = mul v167, Field 2
+    v169 = array_get v124, index Field 2 -> u1
+    v170 = not v169
+    v171 = cast v169 as Field
+    v172 = cast v170 as Field
+    v173 = mul v168, v171
+    v174 = mul v167, v172
+    v175 = add v173, v174
+    v176 = mul v175, v175
+    v177 = mul v176, Field 2
+    v178 = array_get v124, index Field 1 -> u1
+    v179 = not v178
+    v180 = cast v178 as Field
+    v181 = cast v179 as Field
+    v182 = mul v177, v180
+    v183 = mul v176, v181
+    v184 = add v182, v183
+    v185 = mul v184, v184
+    v186 = mul v185, Field 2
+    v187 = array_get v124, index Field 0 -> u1
+    v188 = not v187
+    v189 = cast v187 as Field
+    v190 = cast v188 as Field
+    v191 = mul v186, v189
+    v192 = mul v185, v190
+    v193 = add v191, v192
+    v194 = cast v193 as u128
+    v195 = unchecked_mul v123, v194
+    v196 = cast v0 as Field
+    v197 = cast v195 as Field
+    v198 = mul v196, v197
+    v199 = truncate v198 to 128 bits, max_bit_size: 254
+    v200 = cast v199 as u128
+    v201 = lt v2, u8 128
+    constrain v201 == u1 1, "attempt to bit-shift with overflow"
+    v203 = truncate v200 to 128 bits, max_bit_size: 129
+    v205 = eq v200, u128 49380
+    constrain v200 == u128 49380
+    v206 = lt v0, v1
+    constrain v206 == u1 1
+    v207 = lt v1, v0
+    v208 = not v207
+    constrain v207 == u1 0
+    v210 = eq v0, v1
+    v211 = not v210
+    constrain v210 == u1 0
+    v212 = lt v0, v1
+    constrain v212 == u1 1
+    v213 = lt v1, v0
+    v214 = not v213
+    constrain v213 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/20_inlining_2 b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/20_inlining_2
new file mode 100644
index 00000000000..94ca8e2a516
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/20_inlining_2
@@ -0,0 +1,209 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v31 = call to_le_bits(v2) -> [u1; 8]
+    v33 = array_get v31, index Field 7 -> u1
+    v34 = not v33
+    v35 = cast v33 as Field
+    v36 = cast v34 as Field
+    v38 = mul Field 2, v35
+    v39 = add v38, v36
+    v40 = mul v39, v39
+    v41 = mul v40, Field 2
+    v43 = array_get v31, index Field 6 -> u1
+    v44 = not v43
+    v45 = cast v43 as Field
+    v46 = cast v44 as Field
+    v47 = mul v41, v45
+    v48 = mul v40, v46
+    v49 = add v47, v48
+    v50 = mul v49, v49
+    v51 = mul v50, Field 2
+    v53 = array_get v31, index Field 5 -> u1
+    v54 = not v53
+    v55 = cast v53 as Field
+    v56 = cast v54 as Field
+    v57 = mul v51, v55
+    v58 = mul v50, v56
+    v59 = add v57, v58
+    v60 = mul v59, v59
+    v61 = mul v60, Field 2
+    v63 = array_get v31, index Field 4 -> u1
+    v64 = not v63
+    v65 = cast v63 as Field
+    v66 = cast v64 as Field
+    v67 = mul v61, v65
+    v68 = mul v60, v66
+    v69 = add v67, v68
+    v70 = mul v69, v69
+    v71 = mul v70, Field 2
+    v73 = array_get v31, index Field 3 -> u1
+    v74 = not v73
+    v75 = cast v73 as Field
+    v76 = cast v74 as Field
+    v77 = mul v71, v75
+    v78 = mul v70, v76
+    v79 = add v77, v78
+    v80 = mul v79, v79
+    v81 = mul v80, Field 2
+    v82 = array_get v31, index Field 2 -> u1
+    v83 = not v82
+    v84 = cast v82 as Field
+    v85 = cast v83 as Field
+    v86 = mul v81, v84
+    v87 = mul v80, v85
+    v88 = add v86, v87
+    v89 = mul v88, v88
+    v90 = mul v89, Field 2
+    v92 = array_get v31, index Field 1 -> u1
+    v93 = not v92
+    v94 = cast v92 as Field
+    v95 = cast v93 as Field
+    v96 = mul v90, v94
+    v97 = mul v89, v95
+    v98 = add v96, v97
+    v99 = mul v98, v98
+    v100 = mul v99, Field 2
+    v102 = array_get v31, index Field 0 -> u1
+    v103 = not v102
+    v104 = cast v102 as Field
+    v105 = cast v103 as Field
+    v106 = mul v100, v104
+    v107 = mul v99, v105
+    v108 = add v106, v107
+    v110 = lt v2, u8 128
+    v111 = not v110
+    v112 = cast v110 as Field
+    v113 = cast v111 as Field
+    v114 = mul v112, v108
+    v116 = mul v113, Field 340282366920938463463374607431768211455
+    v117 = add v114, v116
+    v118 = cast v117 as u128
+    v119 = div v0, v118
+    v121 = eq v119, u128 3086
+    constrain v119 == u128 3086
+    v122 = lt v2, u8 128
+    v123 = cast v122 as u128
+    v124 = call to_le_bits(v2) -> [u1; 8]
+    v125 = array_get v124, index Field 7 -> u1
+    v126 = not v125
+    v127 = cast v125 as Field
+    v128 = cast v126 as Field
+    v129 = mul Field 2, v127
+    v130 = add v129, v128
+    v131 = mul v130, v130
+    v132 = mul v131, Field 2
+    v133 = array_get v124, index Field 6 -> u1
+    v134 = not v133
+    v135 = cast v133 as Field
+    v136 = cast v134 as Field
+    v137 = mul v132, v135
+    v138 = mul v131, v136
+    v139 = add v137, v138
+    v140 = mul v139, v139
+    v141 = mul v140, Field 2
+    v142 = array_get v124, index Field 5 -> u1
+    v143 = not v142
+    v144 = cast v142 as Field
+    v145 = cast v143 as Field
+    v146 = mul v141, v144
+    v147 = mul v140, v145
+    v148 = add v146, v147
+    v149 = mul v148, v148
+    v150 = mul v149, Field 2
+    v151 = array_get v124, index Field 4 -> u1
+    v152 = not v151
+    v153 = cast v151 as Field
+    v154 = cast v152 as Field
+    v155 = mul v150, v153
+    v156 = mul v149, v154
+    v157 = add v155, v156
+    v158 = mul v157, v157
+    v159 = mul v158, Field 2
+    v160 = array_get v124, index Field 3 -> u1
+    v161 = not v160
+    v162 = cast v160 as Field
+    v163 = cast v161 as Field
+    v164 = mul v159, v162
+    v165 = mul v158, v163
+    v166 = add v164, v165
+    v167 = mul v166, v166
+    v168 = mul v167, Field 2
+    v169 = array_get v124, index Field 2 -> u1
+    v170 = not v169
+    v171 = cast v169 as Field
+    v172 = cast v170 as Field
+    v173 = mul v168, v171
+    v174 = mul v167, v172
+    v175 = add v173, v174
+    v176 = mul v175, v175
+    v177 = mul v176, Field 2
+    v178 = array_get v124, index Field 1 -> u1
+    v179 = not v178
+    v180 = cast v178 as Field
+    v181 = cast v179 as Field
+    v182 = mul v177, v180
+    v183 = mul v176, v181
+    v184 = add v182, v183
+    v185 = mul v184, v184
+    v186 = mul v185, Field 2
+    v187 = array_get v124, index Field 0 -> u1
+    v188 = not v187
+    v189 = cast v187 as Field
+    v190 = cast v188 as Field
+    v191 = mul v186, v189
+    v192 = mul v185, v190
+    v193 = add v191, v192
+    v194 = cast v193 as u128
+    v195 = unchecked_mul v123, v194
+    v196 = cast v0 as Field
+    v197 = cast v195 as Field
+    v198 = mul v196, v197
+    v199 = truncate v198 to 128 bits, max_bit_size: 254
+    v200 = cast v199 as u128
+    v201 = lt v2, u8 128
+    constrain v201 == u1 1, "attempt to bit-shift with overflow"
+    v203 = truncate v200 to 128 bits, max_bit_size: 129
+    v205 = eq v200, u128 49380
+    constrain v200 == u128 49380
+    v206 = lt v0, v1
+    constrain v206 == u1 1
+    v207 = lt v1, v0
+    v208 = not v207
+    constrain v207 == u1 0
+    v210 = eq v0, v1
+    v211 = not v210
+    constrain v210 == u1 0
+    v212 = lt v0, v1
+    constrain v212 == u1 1
+    v213 = lt v1, v0
+    v214 = not v213
+    constrain v213 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/21_remove_ifelse b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/21_remove_ifelse
new file mode 100644
index 00000000000..94ca8e2a516
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/21_remove_ifelse
@@ -0,0 +1,209 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v31 = call to_le_bits(v2) -> [u1; 8]
+    v33 = array_get v31, index Field 7 -> u1
+    v34 = not v33
+    v35 = cast v33 as Field
+    v36 = cast v34 as Field
+    v38 = mul Field 2, v35
+    v39 = add v38, v36
+    v40 = mul v39, v39
+    v41 = mul v40, Field 2
+    v43 = array_get v31, index Field 6 -> u1
+    v44 = not v43
+    v45 = cast v43 as Field
+    v46 = cast v44 as Field
+    v47 = mul v41, v45
+    v48 = mul v40, v46
+    v49 = add v47, v48
+    v50 = mul v49, v49
+    v51 = mul v50, Field 2
+    v53 = array_get v31, index Field 5 -> u1
+    v54 = not v53
+    v55 = cast v53 as Field
+    v56 = cast v54 as Field
+    v57 = mul v51, v55
+    v58 = mul v50, v56
+    v59 = add v57, v58
+    v60 = mul v59, v59
+    v61 = mul v60, Field 2
+    v63 = array_get v31, index Field 4 -> u1
+    v64 = not v63
+    v65 = cast v63 as Field
+    v66 = cast v64 as Field
+    v67 = mul v61, v65
+    v68 = mul v60, v66
+    v69 = add v67, v68
+    v70 = mul v69, v69
+    v71 = mul v70, Field 2
+    v73 = array_get v31, index Field 3 -> u1
+    v74 = not v73
+    v75 = cast v73 as Field
+    v76 = cast v74 as Field
+    v77 = mul v71, v75
+    v78 = mul v70, v76
+    v79 = add v77, v78
+    v80 = mul v79, v79
+    v81 = mul v80, Field 2
+    v82 = array_get v31, index Field 2 -> u1
+    v83 = not v82
+    v84 = cast v82 as Field
+    v85 = cast v83 as Field
+    v86 = mul v81, v84
+    v87 = mul v80, v85
+    v88 = add v86, v87
+    v89 = mul v88, v88
+    v90 = mul v89, Field 2
+    v92 = array_get v31, index Field 1 -> u1
+    v93 = not v92
+    v94 = cast v92 as Field
+    v95 = cast v93 as Field
+    v96 = mul v90, v94
+    v97 = mul v89, v95
+    v98 = add v96, v97
+    v99 = mul v98, v98
+    v100 = mul v99, Field 2
+    v102 = array_get v31, index Field 0 -> u1
+    v103 = not v102
+    v104 = cast v102 as Field
+    v105 = cast v103 as Field
+    v106 = mul v100, v104
+    v107 = mul v99, v105
+    v108 = add v106, v107
+    v110 = lt v2, u8 128
+    v111 = not v110
+    v112 = cast v110 as Field
+    v113 = cast v111 as Field
+    v114 = mul v112, v108
+    v116 = mul v113, Field 340282366920938463463374607431768211455
+    v117 = add v114, v116
+    v118 = cast v117 as u128
+    v119 = div v0, v118
+    v121 = eq v119, u128 3086
+    constrain v119 == u128 3086
+    v122 = lt v2, u8 128
+    v123 = cast v122 as u128
+    v124 = call to_le_bits(v2) -> [u1; 8]
+    v125 = array_get v124, index Field 7 -> u1
+    v126 = not v125
+    v127 = cast v125 as Field
+    v128 = cast v126 as Field
+    v129 = mul Field 2, v127
+    v130 = add v129, v128
+    v131 = mul v130, v130
+    v132 = mul v131, Field 2
+    v133 = array_get v124, index Field 6 -> u1
+    v134 = not v133
+    v135 = cast v133 as Field
+    v136 = cast v134 as Field
+    v137 = mul v132, v135
+    v138 = mul v131, v136
+    v139 = add v137, v138
+    v140 = mul v139, v139
+    v141 = mul v140, Field 2
+    v142 = array_get v124, index Field 5 -> u1
+    v143 = not v142
+    v144 = cast v142 as Field
+    v145 = cast v143 as Field
+    v146 = mul v141, v144
+    v147 = mul v140, v145
+    v148 = add v146, v147
+    v149 = mul v148, v148
+    v150 = mul v149, Field 2
+    v151 = array_get v124, index Field 4 -> u1
+    v152 = not v151
+    v153 = cast v151 as Field
+    v154 = cast v152 as Field
+    v155 = mul v150, v153
+    v156 = mul v149, v154
+    v157 = add v155, v156
+    v158 = mul v157, v157
+    v159 = mul v158, Field 2
+    v160 = array_get v124, index Field 3 -> u1
+    v161 = not v160
+    v162 = cast v160 as Field
+    v163 = cast v161 as Field
+    v164 = mul v159, v162
+    v165 = mul v158, v163
+    v166 = add v164, v165
+    v167 = mul v166, v166
+    v168 = mul v167, Field 2
+    v169 = array_get v124, index Field 2 -> u1
+    v170 = not v169
+    v171 = cast v169 as Field
+    v172 = cast v170 as Field
+    v173 = mul v168, v171
+    v174 = mul v167, v172
+    v175 = add v173, v174
+    v176 = mul v175, v175
+    v177 = mul v176, Field 2
+    v178 = array_get v124, index Field 1 -> u1
+    v179 = not v178
+    v180 = cast v178 as Field
+    v181 = cast v179 as Field
+    v182 = mul v177, v180
+    v183 = mul v176, v181
+    v184 = add v182, v183
+    v185 = mul v184, v184
+    v186 = mul v185, Field 2
+    v187 = array_get v124, index Field 0 -> u1
+    v188 = not v187
+    v189 = cast v187 as Field
+    v190 = cast v188 as Field
+    v191 = mul v186, v189
+    v192 = mul v185, v190
+    v193 = add v191, v192
+    v194 = cast v193 as u128
+    v195 = unchecked_mul v123, v194
+    v196 = cast v0 as Field
+    v197 = cast v195 as Field
+    v198 = mul v196, v197
+    v199 = truncate v198 to 128 bits, max_bit_size: 254
+    v200 = cast v199 as u128
+    v201 = lt v2, u8 128
+    constrain v201 == u1 1, "attempt to bit-shift with overflow"
+    v203 = truncate v200 to 128 bits, max_bit_size: 129
+    v205 = eq v200, u128 49380
+    constrain v200 == u128 49380
+    v206 = lt v0, v1
+    constrain v206 == u1 1
+    v207 = lt v1, v0
+    v208 = not v207
+    constrain v207 == u1 0
+    v210 = eq v0, v1
+    v211 = not v210
+    constrain v210 == u1 0
+    v212 = lt v0, v1
+    constrain v212 == u1 1
+    v213 = lt v1, v0
+    v214 = not v213
+    constrain v213 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/22_purity_analysis_2 b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/22_purity_analysis_2
new file mode 100644
index 00000000000..94ca8e2a516
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/22_purity_analysis_2
@@ -0,0 +1,209 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v31 = call to_le_bits(v2) -> [u1; 8]
+    v33 = array_get v31, index Field 7 -> u1
+    v34 = not v33
+    v35 = cast v33 as Field
+    v36 = cast v34 as Field
+    v38 = mul Field 2, v35
+    v39 = add v38, v36
+    v40 = mul v39, v39
+    v41 = mul v40, Field 2
+    v43 = array_get v31, index Field 6 -> u1
+    v44 = not v43
+    v45 = cast v43 as Field
+    v46 = cast v44 as Field
+    v47 = mul v41, v45
+    v48 = mul v40, v46
+    v49 = add v47, v48
+    v50 = mul v49, v49
+    v51 = mul v50, Field 2
+    v53 = array_get v31, index Field 5 -> u1
+    v54 = not v53
+    v55 = cast v53 as Field
+    v56 = cast v54 as Field
+    v57 = mul v51, v55
+    v58 = mul v50, v56
+    v59 = add v57, v58
+    v60 = mul v59, v59
+    v61 = mul v60, Field 2
+    v63 = array_get v31, index Field 4 -> u1
+    v64 = not v63
+    v65 = cast v63 as Field
+    v66 = cast v64 as Field
+    v67 = mul v61, v65
+    v68 = mul v60, v66
+    v69 = add v67, v68
+    v70 = mul v69, v69
+    v71 = mul v70, Field 2
+    v73 = array_get v31, index Field 3 -> u1
+    v74 = not v73
+    v75 = cast v73 as Field
+    v76 = cast v74 as Field
+    v77 = mul v71, v75
+    v78 = mul v70, v76
+    v79 = add v77, v78
+    v80 = mul v79, v79
+    v81 = mul v80, Field 2
+    v82 = array_get v31, index Field 2 -> u1
+    v83 = not v82
+    v84 = cast v82 as Field
+    v85 = cast v83 as Field
+    v86 = mul v81, v84
+    v87 = mul v80, v85
+    v88 = add v86, v87
+    v89 = mul v88, v88
+    v90 = mul v89, Field 2
+    v92 = array_get v31, index Field 1 -> u1
+    v93 = not v92
+    v94 = cast v92 as Field
+    v95 = cast v93 as Field
+    v96 = mul v90, v94
+    v97 = mul v89, v95
+    v98 = add v96, v97
+    v99 = mul v98, v98
+    v100 = mul v99, Field 2
+    v102 = array_get v31, index Field 0 -> u1
+    v103 = not v102
+    v104 = cast v102 as Field
+    v105 = cast v103 as Field
+    v106 = mul v100, v104
+    v107 = mul v99, v105
+    v108 = add v106, v107
+    v110 = lt v2, u8 128
+    v111 = not v110
+    v112 = cast v110 as Field
+    v113 = cast v111 as Field
+    v114 = mul v112, v108
+    v116 = mul v113, Field 340282366920938463463374607431768211455
+    v117 = add v114, v116
+    v118 = cast v117 as u128
+    v119 = div v0, v118
+    v121 = eq v119, u128 3086
+    constrain v119 == u128 3086
+    v122 = lt v2, u8 128
+    v123 = cast v122 as u128
+    v124 = call to_le_bits(v2) -> [u1; 8]
+    v125 = array_get v124, index Field 7 -> u1
+    v126 = not v125
+    v127 = cast v125 as Field
+    v128 = cast v126 as Field
+    v129 = mul Field 2, v127
+    v130 = add v129, v128
+    v131 = mul v130, v130
+    v132 = mul v131, Field 2
+    v133 = array_get v124, index Field 6 -> u1
+    v134 = not v133
+    v135 = cast v133 as Field
+    v136 = cast v134 as Field
+    v137 = mul v132, v135
+    v138 = mul v131, v136
+    v139 = add v137, v138
+    v140 = mul v139, v139
+    v141 = mul v140, Field 2
+    v142 = array_get v124, index Field 5 -> u1
+    v143 = not v142
+    v144 = cast v142 as Field
+    v145 = cast v143 as Field
+    v146 = mul v141, v144
+    v147 = mul v140, v145
+    v148 = add v146, v147
+    v149 = mul v148, v148
+    v150 = mul v149, Field 2
+    v151 = array_get v124, index Field 4 -> u1
+    v152 = not v151
+    v153 = cast v151 as Field
+    v154 = cast v152 as Field
+    v155 = mul v150, v153
+    v156 = mul v149, v154
+    v157 = add v155, v156
+    v158 = mul v157, v157
+    v159 = mul v158, Field 2
+    v160 = array_get v124, index Field 3 -> u1
+    v161 = not v160
+    v162 = cast v160 as Field
+    v163 = cast v161 as Field
+    v164 = mul v159, v162
+    v165 = mul v158, v163
+    v166 = add v164, v165
+    v167 = mul v166, v166
+    v168 = mul v167, Field 2
+    v169 = array_get v124, index Field 2 -> u1
+    v170 = not v169
+    v171 = cast v169 as Field
+    v172 = cast v170 as Field
+    v173 = mul v168, v171
+    v174 = mul v167, v172
+    v175 = add v173, v174
+    v176 = mul v175, v175
+    v177 = mul v176, Field 2
+    v178 = array_get v124, index Field 1 -> u1
+    v179 = not v178
+    v180 = cast v178 as Field
+    v181 = cast v179 as Field
+    v182 = mul v177, v180
+    v183 = mul v176, v181
+    v184 = add v182, v183
+    v185 = mul v184, v184
+    v186 = mul v185, Field 2
+    v187 = array_get v124, index Field 0 -> u1
+    v188 = not v187
+    v189 = cast v187 as Field
+    v190 = cast v188 as Field
+    v191 = mul v186, v189
+    v192 = mul v185, v190
+    v193 = add v191, v192
+    v194 = cast v193 as u128
+    v195 = unchecked_mul v123, v194
+    v196 = cast v0 as Field
+    v197 = cast v195 as Field
+    v198 = mul v196, v197
+    v199 = truncate v198 to 128 bits, max_bit_size: 254
+    v200 = cast v199 as u128
+    v201 = lt v2, u8 128
+    constrain v201 == u1 1, "attempt to bit-shift with overflow"
+    v203 = truncate v200 to 128 bits, max_bit_size: 129
+    v205 = eq v200, u128 49380
+    constrain v200 == u128 49380
+    v206 = lt v0, v1
+    constrain v206 == u1 1
+    v207 = lt v1, v0
+    v208 = not v207
+    constrain v207 == u1 0
+    v210 = eq v0, v1
+    v211 = not v210
+    constrain v210 == u1 0
+    v212 = lt v0, v1
+    constrain v212 == u1 1
+    v213 = lt v1, v0
+    v214 = not v213
+    constrain v213 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/23_constant_folding b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/23_constant_folding
new file mode 100644
index 00000000000..94ca8e2a516
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/23_constant_folding
@@ -0,0 +1,209 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v31 = call to_le_bits(v2) -> [u1; 8]
+    v33 = array_get v31, index Field 7 -> u1
+    v34 = not v33
+    v35 = cast v33 as Field
+    v36 = cast v34 as Field
+    v38 = mul Field 2, v35
+    v39 = add v38, v36
+    v40 = mul v39, v39
+    v41 = mul v40, Field 2
+    v43 = array_get v31, index Field 6 -> u1
+    v44 = not v43
+    v45 = cast v43 as Field
+    v46 = cast v44 as Field
+    v47 = mul v41, v45
+    v48 = mul v40, v46
+    v49 = add v47, v48
+    v50 = mul v49, v49
+    v51 = mul v50, Field 2
+    v53 = array_get v31, index Field 5 -> u1
+    v54 = not v53
+    v55 = cast v53 as Field
+    v56 = cast v54 as Field
+    v57 = mul v51, v55
+    v58 = mul v50, v56
+    v59 = add v57, v58
+    v60 = mul v59, v59
+    v61 = mul v60, Field 2
+    v63 = array_get v31, index Field 4 -> u1
+    v64 = not v63
+    v65 = cast v63 as Field
+    v66 = cast v64 as Field
+    v67 = mul v61, v65
+    v68 = mul v60, v66
+    v69 = add v67, v68
+    v70 = mul v69, v69
+    v71 = mul v70, Field 2
+    v73 = array_get v31, index Field 3 -> u1
+    v74 = not v73
+    v75 = cast v73 as Field
+    v76 = cast v74 as Field
+    v77 = mul v71, v75
+    v78 = mul v70, v76
+    v79 = add v77, v78
+    v80 = mul v79, v79
+    v81 = mul v80, Field 2
+    v82 = array_get v31, index Field 2 -> u1
+    v83 = not v82
+    v84 = cast v82 as Field
+    v85 = cast v83 as Field
+    v86 = mul v81, v84
+    v87 = mul v80, v85
+    v88 = add v86, v87
+    v89 = mul v88, v88
+    v90 = mul v89, Field 2
+    v92 = array_get v31, index Field 1 -> u1
+    v93 = not v92
+    v94 = cast v92 as Field
+    v95 = cast v93 as Field
+    v96 = mul v90, v94
+    v97 = mul v89, v95
+    v98 = add v96, v97
+    v99 = mul v98, v98
+    v100 = mul v99, Field 2
+    v102 = array_get v31, index Field 0 -> u1
+    v103 = not v102
+    v104 = cast v102 as Field
+    v105 = cast v103 as Field
+    v106 = mul v100, v104
+    v107 = mul v99, v105
+    v108 = add v106, v107
+    v110 = lt v2, u8 128
+    v111 = not v110
+    v112 = cast v110 as Field
+    v113 = cast v111 as Field
+    v114 = mul v112, v108
+    v116 = mul v113, Field 340282366920938463463374607431768211455
+    v117 = add v114, v116
+    v118 = cast v117 as u128
+    v119 = div v0, v118
+    v121 = eq v119, u128 3086
+    constrain v119 == u128 3086
+    v122 = lt v2, u8 128
+    v123 = cast v122 as u128
+    v124 = call to_le_bits(v2) -> [u1; 8]
+    v125 = array_get v124, index Field 7 -> u1
+    v126 = not v125
+    v127 = cast v125 as Field
+    v128 = cast v126 as Field
+    v129 = mul Field 2, v127
+    v130 = add v129, v128
+    v131 = mul v130, v130
+    v132 = mul v131, Field 2
+    v133 = array_get v124, index Field 6 -> u1
+    v134 = not v133
+    v135 = cast v133 as Field
+    v136 = cast v134 as Field
+    v137 = mul v132, v135
+    v138 = mul v131, v136
+    v139 = add v137, v138
+    v140 = mul v139, v139
+    v141 = mul v140, Field 2
+    v142 = array_get v124, index Field 5 -> u1
+    v143 = not v142
+    v144 = cast v142 as Field
+    v145 = cast v143 as Field
+    v146 = mul v141, v144
+    v147 = mul v140, v145
+    v148 = add v146, v147
+    v149 = mul v148, v148
+    v150 = mul v149, Field 2
+    v151 = array_get v124, index Field 4 -> u1
+    v152 = not v151
+    v153 = cast v151 as Field
+    v154 = cast v152 as Field
+    v155 = mul v150, v153
+    v156 = mul v149, v154
+    v157 = add v155, v156
+    v158 = mul v157, v157
+    v159 = mul v158, Field 2
+    v160 = array_get v124, index Field 3 -> u1
+    v161 = not v160
+    v162 = cast v160 as Field
+    v163 = cast v161 as Field
+    v164 = mul v159, v162
+    v165 = mul v158, v163
+    v166 = add v164, v165
+    v167 = mul v166, v166
+    v168 = mul v167, Field 2
+    v169 = array_get v124, index Field 2 -> u1
+    v170 = not v169
+    v171 = cast v169 as Field
+    v172 = cast v170 as Field
+    v173 = mul v168, v171
+    v174 = mul v167, v172
+    v175 = add v173, v174
+    v176 = mul v175, v175
+    v177 = mul v176, Field 2
+    v178 = array_get v124, index Field 1 -> u1
+    v179 = not v178
+    v180 = cast v178 as Field
+    v181 = cast v179 as Field
+    v182 = mul v177, v180
+    v183 = mul v176, v181
+    v184 = add v182, v183
+    v185 = mul v184, v184
+    v186 = mul v185, Field 2
+    v187 = array_get v124, index Field 0 -> u1
+    v188 = not v187
+    v189 = cast v187 as Field
+    v190 = cast v188 as Field
+    v191 = mul v186, v189
+    v192 = mul v185, v190
+    v193 = add v191, v192
+    v194 = cast v193 as u128
+    v195 = unchecked_mul v123, v194
+    v196 = cast v0 as Field
+    v197 = cast v195 as Field
+    v198 = mul v196, v197
+    v199 = truncate v198 to 128 bits, max_bit_size: 254
+    v200 = cast v199 as u128
+    v201 = lt v2, u8 128
+    constrain v201 == u1 1, "attempt to bit-shift with overflow"
+    v203 = truncate v200 to 128 bits, max_bit_size: 129
+    v205 = eq v200, u128 49380
+    constrain v200 == u128 49380
+    v206 = lt v0, v1
+    constrain v206 == u1 1
+    v207 = lt v1, v0
+    v208 = not v207
+    constrain v207 == u1 0
+    v210 = eq v0, v1
+    v211 = not v210
+    constrain v210 == u1 0
+    v212 = lt v0, v1
+    constrain v212 == u1 1
+    v213 = lt v1, v0
+    v214 = not v213
+    constrain v213 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/24_simplify_conditionals_for_unconstrained b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/24_simplify_conditionals_for_unconstrained
new file mode 100644
index 00000000000..eaeb47fd918
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/24_simplify_conditionals_for_unconstrained
@@ -0,0 +1,204 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v31 = call to_le_bits(v2) -> [u1; 8]
+    v33 = array_get v31, index Field 7 -> u1
+    v34 = not v33
+    v35 = cast v33 as Field
+    v36 = cast v34 as Field
+    v38 = mul Field 2, v35
+    v39 = add v38, v36
+    v40 = mul v39, v39
+    v41 = mul v40, Field 2
+    v43 = array_get v31, index Field 6 -> u1
+    v44 = not v43
+    v45 = cast v43 as Field
+    v46 = cast v44 as Field
+    v47 = mul v41, v45
+    v48 = mul v40, v46
+    v49 = add v47, v48
+    v50 = mul v49, v49
+    v51 = mul v50, Field 2
+    v53 = array_get v31, index Field 5 -> u1
+    v54 = not v53
+    v55 = cast v53 as Field
+    v56 = cast v54 as Field
+    v57 = mul v51, v55
+    v58 = mul v50, v56
+    v59 = add v57, v58
+    v60 = mul v59, v59
+    v61 = mul v60, Field 2
+    v63 = array_get v31, index Field 4 -> u1
+    v64 = not v63
+    v65 = cast v63 as Field
+    v66 = cast v64 as Field
+    v67 = mul v61, v65
+    v68 = mul v60, v66
+    v69 = add v67, v68
+    v70 = mul v69, v69
+    v71 = mul v70, Field 2
+    v73 = array_get v31, index Field 3 -> u1
+    v74 = not v73
+    v75 = cast v73 as Field
+    v76 = cast v74 as Field
+    v77 = mul v71, v75
+    v78 = mul v70, v76
+    v79 = add v77, v78
+    v80 = mul v79, v79
+    v81 = mul v80, Field 2
+    v82 = array_get v31, index Field 2 -> u1
+    v83 = not v82
+    v84 = cast v82 as Field
+    v85 = cast v83 as Field
+    v86 = mul v81, v84
+    v87 = mul v80, v85
+    v88 = add v86, v87
+    v89 = mul v88, v88
+    v90 = mul v89, Field 2
+    v92 = array_get v31, index Field 1 -> u1
+    v93 = not v92
+    v94 = cast v92 as Field
+    v95 = cast v93 as Field
+    v96 = mul v90, v94
+    v97 = mul v89, v95
+    v98 = add v96, v97
+    v99 = mul v98, v98
+    v100 = mul v99, Field 2
+    v102 = array_get v31, index Field 0 -> u1
+    v103 = not v102
+    v104 = cast v102 as Field
+    v105 = cast v103 as Field
+    v106 = mul v100, v104
+    v107 = mul v99, v105
+    v108 = add v106, v107
+    v110 = lt v2, u8 128
+    v111 = not v110
+    v112 = cast v110 as Field
+    v113 = cast v111 as Field
+    v114 = mul v112, v108
+    v116 = mul v113, Field 340282366920938463463374607431768211455
+    v117 = add v114, v116
+    v118 = cast v117 as u128
+    v119 = div v0, v118
+    v121 = eq v119, u128 3086
+    constrain v119 == u128 3086
+    v122 = cast v110 as u128
+    v123 = call to_le_bits(v2) -> [u1; 8]
+    v124 = array_get v123, index Field 7 -> u1
+    v125 = not v124
+    v126 = cast v124 as Field
+    v127 = cast v125 as Field
+    v128 = mul Field 2, v126
+    v129 = add v128, v127
+    v130 = mul v129, v129
+    v131 = mul v130, Field 2
+    v132 = array_get v123, index Field 6 -> u1
+    v133 = not v132
+    v134 = cast v132 as Field
+    v135 = cast v133 as Field
+    v136 = mul v131, v134
+    v137 = mul v130, v135
+    v138 = add v136, v137
+    v139 = mul v138, v138
+    v140 = mul v139, Field 2
+    v141 = array_get v123, index Field 5 -> u1
+    v142 = not v141
+    v143 = cast v141 as Field
+    v144 = cast v142 as Field
+    v145 = mul v140, v143
+    v146 = mul v139, v144
+    v147 = add v145, v146
+    v148 = mul v147, v147
+    v149 = mul v148, Field 2
+    v150 = array_get v123, index Field 4 -> u1
+    v151 = not v150
+    v152 = cast v150 as Field
+    v153 = cast v151 as Field
+    v154 = mul v149, v152
+    v155 = mul v148, v153
+    v156 = add v154, v155
+    v157 = mul v156, v156
+    v158 = mul v157, Field 2
+    v159 = array_get v123, index Field 3 -> u1
+    v160 = not v159
+    v161 = cast v159 as Field
+    v162 = cast v160 as Field
+    v163 = mul v158, v161
+    v164 = mul v157, v162
+    v165 = add v163, v164
+    v166 = mul v165, v165
+    v167 = mul v166, Field 2
+    v168 = array_get v123, index Field 2 -> u1
+    v169 = not v168
+    v170 = cast v168 as Field
+    v171 = cast v169 as Field
+    v172 = mul v167, v170
+    v173 = mul v166, v171
+    v174 = add v172, v173
+    v175 = mul v174, v174
+    v176 = mul v175, Field 2
+    v177 = array_get v123, index Field 1 -> u1
+    v178 = not v177
+    v179 = cast v177 as Field
+    v180 = cast v178 as Field
+    v181 = mul v176, v179
+    v182 = mul v175, v180
+    v183 = add v181, v182
+    v184 = mul v183, v183
+    v185 = mul v184, Field 2
+    v186 = array_get v123, index Field 0 -> u1
+    v187 = not v186
+    v188 = cast v186 as Field
+    v189 = cast v187 as Field
+    v190 = mul v185, v188
+    v191 = mul v184, v189
+    v192 = add v190, v191
+    v193 = cast v192 as u128
+    v194 = unchecked_mul v122, v193
+    v195 = cast v0 as Field
+    v196 = cast v194 as Field
+    v197 = mul v195, v196
+    v198 = truncate v197 to 128 bits, max_bit_size: 254
+    v199 = cast v198 as u128
+    constrain v110 == u1 1, "attempt to bit-shift with overflow"
+    v201 = truncate v199 to 128 bits, max_bit_size: 129
+    v203 = eq v199, u128 49380
+    constrain v199 == u128 49380
+    v204 = lt v0, v1
+    constrain v204 == u1 1
+    v205 = lt v1, v0
+    v206 = not v205
+    constrain v205 == u1 0
+    v208 = eq v0, v1
+    v209 = not v208
+    constrain v208 == u1 0
+    constrain v204 == u1 1
+    constrain v205 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/25_enablesideeffectsif_removal b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/25_enablesideeffectsif_removal
new file mode 100644
index 00000000000..eaeb47fd918
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/25_enablesideeffectsif_removal
@@ -0,0 +1,204 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v31 = call to_le_bits(v2) -> [u1; 8]
+    v33 = array_get v31, index Field 7 -> u1
+    v34 = not v33
+    v35 = cast v33 as Field
+    v36 = cast v34 as Field
+    v38 = mul Field 2, v35
+    v39 = add v38, v36
+    v40 = mul v39, v39
+    v41 = mul v40, Field 2
+    v43 = array_get v31, index Field 6 -> u1
+    v44 = not v43
+    v45 = cast v43 as Field
+    v46 = cast v44 as Field
+    v47 = mul v41, v45
+    v48 = mul v40, v46
+    v49 = add v47, v48
+    v50 = mul v49, v49
+    v51 = mul v50, Field 2
+    v53 = array_get v31, index Field 5 -> u1
+    v54 = not v53
+    v55 = cast v53 as Field
+    v56 = cast v54 as Field
+    v57 = mul v51, v55
+    v58 = mul v50, v56
+    v59 = add v57, v58
+    v60 = mul v59, v59
+    v61 = mul v60, Field 2
+    v63 = array_get v31, index Field 4 -> u1
+    v64 = not v63
+    v65 = cast v63 as Field
+    v66 = cast v64 as Field
+    v67 = mul v61, v65
+    v68 = mul v60, v66
+    v69 = add v67, v68
+    v70 = mul v69, v69
+    v71 = mul v70, Field 2
+    v73 = array_get v31, index Field 3 -> u1
+    v74 = not v73
+    v75 = cast v73 as Field
+    v76 = cast v74 as Field
+    v77 = mul v71, v75
+    v78 = mul v70, v76
+    v79 = add v77, v78
+    v80 = mul v79, v79
+    v81 = mul v80, Field 2
+    v82 = array_get v31, index Field 2 -> u1
+    v83 = not v82
+    v84 = cast v82 as Field
+    v85 = cast v83 as Field
+    v86 = mul v81, v84
+    v87 = mul v80, v85
+    v88 = add v86, v87
+    v89 = mul v88, v88
+    v90 = mul v89, Field 2
+    v92 = array_get v31, index Field 1 -> u1
+    v93 = not v92
+    v94 = cast v92 as Field
+    v95 = cast v93 as Field
+    v96 = mul v90, v94
+    v97 = mul v89, v95
+    v98 = add v96, v97
+    v99 = mul v98, v98
+    v100 = mul v99, Field 2
+    v102 = array_get v31, index Field 0 -> u1
+    v103 = not v102
+    v104 = cast v102 as Field
+    v105 = cast v103 as Field
+    v106 = mul v100, v104
+    v107 = mul v99, v105
+    v108 = add v106, v107
+    v110 = lt v2, u8 128
+    v111 = not v110
+    v112 = cast v110 as Field
+    v113 = cast v111 as Field
+    v114 = mul v112, v108
+    v116 = mul v113, Field 340282366920938463463374607431768211455
+    v117 = add v114, v116
+    v118 = cast v117 as u128
+    v119 = div v0, v118
+    v121 = eq v119, u128 3086
+    constrain v119 == u128 3086
+    v122 = cast v110 as u128
+    v123 = call to_le_bits(v2) -> [u1; 8]
+    v124 = array_get v123, index Field 7 -> u1
+    v125 = not v124
+    v126 = cast v124 as Field
+    v127 = cast v125 as Field
+    v128 = mul Field 2, v126
+    v129 = add v128, v127
+    v130 = mul v129, v129
+    v131 = mul v130, Field 2
+    v132 = array_get v123, index Field 6 -> u1
+    v133 = not v132
+    v134 = cast v132 as Field
+    v135 = cast v133 as Field
+    v136 = mul v131, v134
+    v137 = mul v130, v135
+    v138 = add v136, v137
+    v139 = mul v138, v138
+    v140 = mul v139, Field 2
+    v141 = array_get v123, index Field 5 -> u1
+    v142 = not v141
+    v143 = cast v141 as Field
+    v144 = cast v142 as Field
+    v145 = mul v140, v143
+    v146 = mul v139, v144
+    v147 = add v145, v146
+    v148 = mul v147, v147
+    v149 = mul v148, Field 2
+    v150 = array_get v123, index Field 4 -> u1
+    v151 = not v150
+    v152 = cast v150 as Field
+    v153 = cast v151 as Field
+    v154 = mul v149, v152
+    v155 = mul v148, v153
+    v156 = add v154, v155
+    v157 = mul v156, v156
+    v158 = mul v157, Field 2
+    v159 = array_get v123, index Field 3 -> u1
+    v160 = not v159
+    v161 = cast v159 as Field
+    v162 = cast v160 as Field
+    v163 = mul v158, v161
+    v164 = mul v157, v162
+    v165 = add v163, v164
+    v166 = mul v165, v165
+    v167 = mul v166, Field 2
+    v168 = array_get v123, index Field 2 -> u1
+    v169 = not v168
+    v170 = cast v168 as Field
+    v171 = cast v169 as Field
+    v172 = mul v167, v170
+    v173 = mul v166, v171
+    v174 = add v172, v173
+    v175 = mul v174, v174
+    v176 = mul v175, Field 2
+    v177 = array_get v123, index Field 1 -> u1
+    v178 = not v177
+    v179 = cast v177 as Field
+    v180 = cast v178 as Field
+    v181 = mul v176, v179
+    v182 = mul v175, v180
+    v183 = add v181, v182
+    v184 = mul v183, v183
+    v185 = mul v184, Field 2
+    v186 = array_get v123, index Field 0 -> u1
+    v187 = not v186
+    v188 = cast v186 as Field
+    v189 = cast v187 as Field
+    v190 = mul v185, v188
+    v191 = mul v184, v189
+    v192 = add v190, v191
+    v193 = cast v192 as u128
+    v194 = unchecked_mul v122, v193
+    v195 = cast v0 as Field
+    v196 = cast v194 as Field
+    v197 = mul v195, v196
+    v198 = truncate v197 to 128 bits, max_bit_size: 254
+    v199 = cast v198 as u128
+    constrain v110 == u1 1, "attempt to bit-shift with overflow"
+    v201 = truncate v199 to 128 bits, max_bit_size: 129
+    v203 = eq v199, u128 49380
+    constrain v199 == u128 49380
+    v204 = lt v0, v1
+    constrain v204 == u1 1
+    v205 = lt v1, v0
+    v206 = not v205
+    constrain v205 == u1 0
+    v208 = eq v0, v1
+    v209 = not v208
+    constrain v208 == u1 0
+    constrain v204 == u1 1
+    constrain v205 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/26_constraint_folding b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/26_constraint_folding
new file mode 100644
index 00000000000..eaeb47fd918
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/26_constraint_folding
@@ -0,0 +1,204 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v31 = call to_le_bits(v2) -> [u1; 8]
+    v33 = array_get v31, index Field 7 -> u1
+    v34 = not v33
+    v35 = cast v33 as Field
+    v36 = cast v34 as Field
+    v38 = mul Field 2, v35
+    v39 = add v38, v36
+    v40 = mul v39, v39
+    v41 = mul v40, Field 2
+    v43 = array_get v31, index Field 6 -> u1
+    v44 = not v43
+    v45 = cast v43 as Field
+    v46 = cast v44 as Field
+    v47 = mul v41, v45
+    v48 = mul v40, v46
+    v49 = add v47, v48
+    v50 = mul v49, v49
+    v51 = mul v50, Field 2
+    v53 = array_get v31, index Field 5 -> u1
+    v54 = not v53
+    v55 = cast v53 as Field
+    v56 = cast v54 as Field
+    v57 = mul v51, v55
+    v58 = mul v50, v56
+    v59 = add v57, v58
+    v60 = mul v59, v59
+    v61 = mul v60, Field 2
+    v63 = array_get v31, index Field 4 -> u1
+    v64 = not v63
+    v65 = cast v63 as Field
+    v66 = cast v64 as Field
+    v67 = mul v61, v65
+    v68 = mul v60, v66
+    v69 = add v67, v68
+    v70 = mul v69, v69
+    v71 = mul v70, Field 2
+    v73 = array_get v31, index Field 3 -> u1
+    v74 = not v73
+    v75 = cast v73 as Field
+    v76 = cast v74 as Field
+    v77 = mul v71, v75
+    v78 = mul v70, v76
+    v79 = add v77, v78
+    v80 = mul v79, v79
+    v81 = mul v80, Field 2
+    v82 = array_get v31, index Field 2 -> u1
+    v83 = not v82
+    v84 = cast v82 as Field
+    v85 = cast v83 as Field
+    v86 = mul v81, v84
+    v87 = mul v80, v85
+    v88 = add v86, v87
+    v89 = mul v88, v88
+    v90 = mul v89, Field 2
+    v92 = array_get v31, index Field 1 -> u1
+    v93 = not v92
+    v94 = cast v92 as Field
+    v95 = cast v93 as Field
+    v96 = mul v90, v94
+    v97 = mul v89, v95
+    v98 = add v96, v97
+    v99 = mul v98, v98
+    v100 = mul v99, Field 2
+    v102 = array_get v31, index Field 0 -> u1
+    v103 = not v102
+    v104 = cast v102 as Field
+    v105 = cast v103 as Field
+    v106 = mul v100, v104
+    v107 = mul v99, v105
+    v108 = add v106, v107
+    v110 = lt v2, u8 128
+    v111 = not v110
+    v112 = cast v110 as Field
+    v113 = cast v111 as Field
+    v114 = mul v112, v108
+    v116 = mul v113, Field 340282366920938463463374607431768211455
+    v117 = add v114, v116
+    v118 = cast v117 as u128
+    v119 = div v0, v118
+    v121 = eq v119, u128 3086
+    constrain v119 == u128 3086
+    v122 = cast v110 as u128
+    v123 = call to_le_bits(v2) -> [u1; 8]
+    v124 = array_get v123, index Field 7 -> u1
+    v125 = not v124
+    v126 = cast v124 as Field
+    v127 = cast v125 as Field
+    v128 = mul Field 2, v126
+    v129 = add v128, v127
+    v130 = mul v129, v129
+    v131 = mul v130, Field 2
+    v132 = array_get v123, index Field 6 -> u1
+    v133 = not v132
+    v134 = cast v132 as Field
+    v135 = cast v133 as Field
+    v136 = mul v131, v134
+    v137 = mul v130, v135
+    v138 = add v136, v137
+    v139 = mul v138, v138
+    v140 = mul v139, Field 2
+    v141 = array_get v123, index Field 5 -> u1
+    v142 = not v141
+    v143 = cast v141 as Field
+    v144 = cast v142 as Field
+    v145 = mul v140, v143
+    v146 = mul v139, v144
+    v147 = add v145, v146
+    v148 = mul v147, v147
+    v149 = mul v148, Field 2
+    v150 = array_get v123, index Field 4 -> u1
+    v151 = not v150
+    v152 = cast v150 as Field
+    v153 = cast v151 as Field
+    v154 = mul v149, v152
+    v155 = mul v148, v153
+    v156 = add v154, v155
+    v157 = mul v156, v156
+    v158 = mul v157, Field 2
+    v159 = array_get v123, index Field 3 -> u1
+    v160 = not v159
+    v161 = cast v159 as Field
+    v162 = cast v160 as Field
+    v163 = mul v158, v161
+    v164 = mul v157, v162
+    v165 = add v163, v164
+    v166 = mul v165, v165
+    v167 = mul v166, Field 2
+    v168 = array_get v123, index Field 2 -> u1
+    v169 = not v168
+    v170 = cast v168 as Field
+    v171 = cast v169 as Field
+    v172 = mul v167, v170
+    v173 = mul v166, v171
+    v174 = add v172, v173
+    v175 = mul v174, v174
+    v176 = mul v175, Field 2
+    v177 = array_get v123, index Field 1 -> u1
+    v178 = not v177
+    v179 = cast v177 as Field
+    v180 = cast v178 as Field
+    v181 = mul v176, v179
+    v182 = mul v175, v180
+    v183 = add v181, v182
+    v184 = mul v183, v183
+    v185 = mul v184, Field 2
+    v186 = array_get v123, index Field 0 -> u1
+    v187 = not v186
+    v188 = cast v186 as Field
+    v189 = cast v187 as Field
+    v190 = mul v185, v188
+    v191 = mul v184, v189
+    v192 = add v190, v191
+    v193 = cast v192 as u128
+    v194 = unchecked_mul v122, v193
+    v195 = cast v0 as Field
+    v196 = cast v194 as Field
+    v197 = mul v195, v196
+    v198 = truncate v197 to 128 bits, max_bit_size: 254
+    v199 = cast v198 as u128
+    constrain v110 == u1 1, "attempt to bit-shift with overflow"
+    v201 = truncate v199 to 128 bits, max_bit_size: 129
+    v203 = eq v199, u128 49380
+    constrain v199 == u128 49380
+    v204 = lt v0, v1
+    constrain v204 == u1 1
+    v205 = lt v1, v0
+    v206 = not v205
+    constrain v205 == u1 0
+    v208 = eq v0, v1
+    v209 = not v208
+    constrain v208 == u1 0
+    constrain v204 == u1 1
+    constrain v205 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/27_adding_constrain_not_equal b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/27_adding_constrain_not_equal
new file mode 100644
index 00000000000..efdab7fb7a1
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/27_adding_constrain_not_equal
@@ -0,0 +1,132 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v31 = call to_le_bits(v2) -> [u1; 8]
+    v33 = array_get v31, index Field 7 -> u1
+    v34 = not v33
+    v35 = cast v33 as Field
+    v36 = cast v34 as Field
+    v38 = mul Field 2, v35
+    v39 = add v38, v36
+    v40 = mul v39, v39
+    v41 = mul v40, Field 2
+    v43 = array_get v31, index Field 6 -> u1
+    v44 = not v43
+    v45 = cast v43 as Field
+    v46 = cast v44 as Field
+    v47 = mul v41, v45
+    v48 = mul v40, v46
+    v49 = add v47, v48
+    v50 = mul v49, v49
+    v51 = mul v50, Field 2
+    v53 = array_get v31, index Field 5 -> u1
+    v54 = not v53
+    v55 = cast v53 as Field
+    v56 = cast v54 as Field
+    v57 = mul v51, v55
+    v58 = mul v50, v56
+    v59 = add v57, v58
+    v60 = mul v59, v59
+    v61 = mul v60, Field 2
+    v63 = array_get v31, index Field 4 -> u1
+    v64 = not v63
+    v65 = cast v63 as Field
+    v66 = cast v64 as Field
+    v67 = mul v61, v65
+    v68 = mul v60, v66
+    v69 = add v67, v68
+    v70 = mul v69, v69
+    v71 = mul v70, Field 2
+    v73 = array_get v31, index Field 3 -> u1
+    v74 = not v73
+    v75 = cast v73 as Field
+    v76 = cast v74 as Field
+    v77 = mul v71, v75
+    v78 = mul v70, v76
+    v79 = add v77, v78
+    v80 = mul v79, v79
+    v81 = mul v80, Field 2
+    v82 = array_get v31, index Field 2 -> u1
+    v83 = not v82
+    v84 = cast v82 as Field
+    v85 = cast v83 as Field
+    v86 = mul v81, v84
+    v87 = mul v80, v85
+    v88 = add v86, v87
+    v89 = mul v88, v88
+    v90 = mul v89, Field 2
+    v92 = array_get v31, index Field 1 -> u1
+    v93 = not v92
+    v94 = cast v92 as Field
+    v95 = cast v93 as Field
+    v96 = mul v90, v94
+    v97 = mul v89, v95
+    v98 = add v96, v97
+    v99 = mul v98, v98
+    v100 = mul v99, Field 2
+    v102 = array_get v31, index Field 0 -> u1
+    v103 = not v102
+    v104 = cast v102 as Field
+    v105 = cast v103 as Field
+    v106 = mul v100, v104
+    v107 = mul v99, v105
+    v108 = add v106, v107
+    v110 = lt v2, u8 128
+    v111 = not v110
+    v112 = cast v110 as Field
+    v113 = cast v111 as Field
+    v114 = mul v112, v108
+    v116 = mul v113, Field 340282366920938463463374607431768211455
+    v117 = add v114, v116
+    v118 = cast v117 as u128
+    v119 = div v0, v118
+    v121 = eq v119, u128 3086
+    constrain v119 == u128 3086
+    v122 = cast v110 as u128
+    v123 = cast v108 as u128
+    v124 = unchecked_mul v122, v123
+    v125 = cast v0 as Field
+    v126 = cast v124 as Field
+    v127 = mul v125, v126
+    v128 = truncate v127 to 128 bits, max_bit_size: 254
+    v129 = cast v128 as u128
+    constrain v110 == u1 1, "attempt to bit-shift with overflow"
+    v131 = truncate v129 to 128 bits, max_bit_size: 129
+    v133 = eq v129, u128 49380
+    constrain v129 == u128 49380
+    v134 = lt v0, v1
+    constrain v134 == u1 1
+    v135 = lt v1, v0
+    v136 = not v135
+    constrain v135 == u1 0
+    v138 = eq v0, v1
+    v139 = not v138
+    constrain v138 == u1 0
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/28_check_u128_mul_overflow b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/28_check_u128_mul_overflow
new file mode 100644
index 00000000000..67a256669ce
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/28_check_u128_mul_overflow
@@ -0,0 +1,132 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v12 = div v1, v0
+    v14 = eq v12, u128 190
+    constrain v12 == u128 190
+    v15 = mod v1, v0
+    v17 = eq v15, u128 128
+    constrain v15 == u128 128
+    v18 = not v0
+    v20 = eq v18, u128 340282366920938463463374607431768199110
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v21 = xor v0, v1
+    v23 = eq v21, u128 2358007
+    constrain v21 == u128 2358007
+    v24 = and v0, v1
+    v26 = eq v24, u128 8
+    constrain v24 == u128 8
+    v27 = or v0, v1
+    v29 = eq v27, u128 2358015
+    constrain v27 == u128 2358015
+    v31 = call to_le_bits(v2) -> [u1; 8]
+    v33 = array_get v31, index Field 7 -> u1
+    v34 = not v33
+    v35 = cast v33 as Field
+    v36 = cast v34 as Field
+    v38 = mul Field 2, v35
+    v39 = add v38, v36
+    v40 = mul v39, v39
+    v41 = mul v40, Field 2
+    v43 = array_get v31, index Field 6 -> u1
+    v44 = not v43
+    v45 = cast v43 as Field
+    v46 = cast v44 as Field
+    v47 = mul v41, v45
+    v48 = mul v40, v46
+    v49 = add v47, v48
+    v50 = mul v49, v49
+    v51 = mul v50, Field 2
+    v53 = array_get v31, index Field 5 -> u1
+    v54 = not v53
+    v55 = cast v53 as Field
+    v56 = cast v54 as Field
+    v57 = mul v51, v55
+    v58 = mul v50, v56
+    v59 = add v57, v58
+    v60 = mul v59, v59
+    v61 = mul v60, Field 2
+    v63 = array_get v31, index Field 4 -> u1
+    v64 = not v63
+    v65 = cast v63 as Field
+    v66 = cast v64 as Field
+    v67 = mul v61, v65
+    v68 = mul v60, v66
+    v69 = add v67, v68
+    v70 = mul v69, v69
+    v71 = mul v70, Field 2
+    v73 = array_get v31, index Field 3 -> u1
+    v74 = not v73
+    v75 = cast v73 as Field
+    v76 = cast v74 as Field
+    v77 = mul v71, v75
+    v78 = mul v70, v76
+    v79 = add v77, v78
+    v80 = mul v79, v79
+    v81 = mul v80, Field 2
+    v82 = array_get v31, index Field 2 -> u1
+    v83 = not v82
+    v84 = cast v82 as Field
+    v85 = cast v83 as Field
+    v86 = mul v81, v84
+    v87 = mul v80, v85
+    v88 = add v86, v87
+    v89 = mul v88, v88
+    v90 = mul v89, Field 2
+    v92 = array_get v31, index Field 1 -> u1
+    v93 = not v92
+    v94 = cast v92 as Field
+    v95 = cast v93 as Field
+    v96 = mul v90, v94
+    v97 = mul v89, v95
+    v98 = add v96, v97
+    v99 = mul v98, v98
+    v100 = mul v99, Field 2
+    v102 = array_get v31, index Field 0 -> u1
+    v103 = not v102
+    v104 = cast v102 as Field
+    v105 = cast v103 as Field
+    v106 = mul v100, v104
+    v107 = mul v99, v105
+    v108 = add v106, v107
+    v110 = lt v2, u8 128
+    v111 = not v110
+    v112 = cast v110 as Field
+    v113 = cast v111 as Field
+    v114 = mul v112, v108
+    v116 = mul v113, Field 340282366920938463463374607431768211455
+    v117 = add v114, v116
+    v118 = cast v117 as u128
+    v119 = div v0, v118
+    v121 = eq v119, u128 3086
+    constrain v119 == u128 3086
+    v122 = cast v110 as u128
+    v123 = cast v108 as u128
+    v124 = unchecked_mul v122, v123
+    v125 = cast v0 as Field
+    v126 = cast v124 as Field
+    v127 = mul v125, v126
+    v128 = truncate v127 to 128 bits, max_bit_size: 254
+    v129 = cast v128 as u128
+    constrain v110 == u1 1, "attempt to bit-shift with overflow"
+    v131 = truncate v129 to 128 bits, max_bit_size: 129
+    v133 = eq v129, u128 49380
+    constrain v129 == u128 49380
+    v134 = lt v0, v1
+    constrain v134 == u1 1
+    v135 = lt v1, v0
+    v136 = not v135
+    constrain v135 == u1 0
+    v138 = eq v0, v1
+    v139 = not v138
+    constrain v0 != v1
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/29_dead_instruction_elimination_1 b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/29_dead_instruction_elimination_1
new file mode 100644
index 00000000000..d9cce7eb679
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/29_dead_instruction_elimination_1
@@ -0,0 +1,136 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    v5 = eq v3, u128 2358023
+    constrain v3 == u128 2358023
+    v6 = sub v1, v0
+    v8 = eq v6, u128 2333333
+    constrain v6 == u128 2333333
+    v9 = mul v0, v1
+    v11 = div v0, u128 18446744073709551616
+    v12 = div v1, u128 18446744073709551616
+    v13 = unchecked_mul v11, v12
+    constrain v13 == u128 0, "attempt to multiply with overflow"
+    v16 = eq v9, u128 28957394910
+    constrain v9 == u128 28957394910
+    v17 = div v1, v0
+    v19 = eq v17, u128 190
+    constrain v17 == u128 190
+    v20 = mod v1, v0
+    v22 = eq v20, u128 128
+    constrain v20 == u128 128
+    v23 = not v0
+    v25 = eq v23, u128 340282366920938463463374607431768199110
+    constrain v23 == u128 340282366920938463463374607431768199110
+    v26 = xor v0, v1
+    v28 = eq v26, u128 2358007
+    constrain v26 == u128 2358007
+    v29 = and v0, v1
+    v31 = eq v29, u128 8
+    constrain v29 == u128 8
+    v32 = or v0, v1
+    v34 = eq v32, u128 2358015
+    constrain v32 == u128 2358015
+    v36 = call to_le_bits(v2) -> [u1; 8]
+    v38 = array_get v36, index Field 7 -> u1
+    v39 = not v38
+    v40 = cast v38 as Field
+    v41 = cast v39 as Field
+    v43 = mul Field 2, v40
+    v44 = add v43, v41
+    v45 = mul v44, v44
+    v46 = mul v45, Field 2
+    v48 = array_get v36, index Field 6 -> u1
+    v49 = not v48
+    v50 = cast v48 as Field
+    v51 = cast v49 as Field
+    v52 = mul v46, v50
+    v53 = mul v45, v51
+    v54 = add v52, v53
+    v55 = mul v54, v54
+    v56 = mul v55, Field 2
+    v58 = array_get v36, index Field 5 -> u1
+    v59 = not v58
+    v60 = cast v58 as Field
+    v61 = cast v59 as Field
+    v62 = mul v56, v60
+    v63 = mul v55, v61
+    v64 = add v62, v63
+    v65 = mul v64, v64
+    v66 = mul v65, Field 2
+    v68 = array_get v36, index Field 4 -> u1
+    v69 = not v68
+    v70 = cast v68 as Field
+    v71 = cast v69 as Field
+    v72 = mul v66, v70
+    v73 = mul v65, v71
+    v74 = add v72, v73
+    v75 = mul v74, v74
+    v76 = mul v75, Field 2
+    v78 = array_get v36, index Field 3 -> u1
+    v79 = not v78
+    v80 = cast v78 as Field
+    v81 = cast v79 as Field
+    v82 = mul v76, v80
+    v83 = mul v75, v81
+    v84 = add v82, v83
+    v85 = mul v84, v84
+    v86 = mul v85, Field 2
+    v87 = array_get v36, index Field 2 -> u1
+    v88 = not v87
+    v89 = cast v87 as Field
+    v90 = cast v88 as Field
+    v91 = mul v86, v89
+    v92 = mul v85, v90
+    v93 = add v91, v92
+    v94 = mul v93, v93
+    v95 = mul v94, Field 2
+    v97 = array_get v36, index Field 1 -> u1
+    v98 = not v97
+    v99 = cast v97 as Field
+    v100 = cast v98 as Field
+    v101 = mul v95, v99
+    v102 = mul v94, v100
+    v103 = add v101, v102
+    v104 = mul v103, v103
+    v105 = mul v104, Field 2
+    v107 = array_get v36, index Field 0 -> u1
+    v108 = not v107
+    v109 = cast v107 as Field
+    v110 = cast v108 as Field
+    v111 = mul v105, v109
+    v112 = mul v104, v110
+    v113 = add v111, v112
+    v115 = lt v2, u8 128
+    v116 = not v115
+    v117 = cast v115 as Field
+    v118 = cast v116 as Field
+    v119 = mul v117, v113
+    v121 = mul v118, Field 340282366920938463463374607431768211455
+    v122 = add v119, v121
+    v123 = cast v122 as u128
+    v124 = div v0, v123
+    v126 = eq v124, u128 3086
+    constrain v124 == u128 3086
+    v127 = cast v115 as u128
+    v128 = cast v113 as u128
+    v129 = unchecked_mul v127, v128
+    v130 = cast v0 as Field
+    v131 = cast v129 as Field
+    v132 = mul v130, v131
+    v133 = truncate v132 to 128 bits, max_bit_size: 254
+    v134 = cast v133 as u128
+    constrain v115 == u1 1, "attempt to bit-shift with overflow"
+    v136 = truncate v134 to 128 bits, max_bit_size: 129
+    v138 = eq v134, u128 49380
+    constrain v134 == u128 49380
+    v139 = lt v0, v1
+    constrain v139 == u1 1
+    v140 = lt v1, v0
+    v141 = not v140
+    constrain v140 == u1 0
+    v143 = eq v0, v1
+    v144 = not v143
+    constrain v0 != v1
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/30_simplifying_3 b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/30_simplifying_3
new file mode 100644
index 00000000000..6ea56db03bc
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/30_simplifying_3
@@ -0,0 +1,121 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    constrain v3 == u128 2358023
+    v5 = sub v1, v0
+    constrain v5 == u128 2333333
+    v7 = mul v0, v1
+    v9 = div v0, u128 18446744073709551616
+    v10 = div v1, u128 18446744073709551616
+    v11 = unchecked_mul v9, v10
+    constrain v11 == u128 0, "attempt to multiply with overflow"
+    constrain v7 == u128 28957394910
+    v14 = div v1, v0
+    constrain v14 == u128 190
+    v16 = mod v1, v0
+    constrain v16 == u128 128
+    v18 = not v0
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v20 = xor v0, v1
+    constrain v20 == u128 2358007
+    v22 = and v0, v1
+    constrain v22 == u128 8
+    v24 = or v0, v1
+    constrain v24 == u128 2358015
+    v27 = call to_le_bits(v2) -> [u1; 8]
+    v29 = array_get v27, index Field 7 -> u1
+    v30 = not v29
+    v31 = cast v29 as Field
+    v32 = cast v30 as Field
+    v34 = mul Field 2, v31
+    v35 = add v34, v32
+    v36 = mul v35, v35
+    v37 = mul v36, Field 2
+    v39 = array_get v27, index Field 6 -> u1
+    v40 = not v39
+    v41 = cast v39 as Field
+    v42 = cast v40 as Field
+    v43 = mul v37, v41
+    v44 = mul v36, v42
+    v45 = add v43, v44
+    v46 = mul v45, v45
+    v47 = mul v46, Field 2
+    v49 = array_get v27, index Field 5 -> u1
+    v50 = not v49
+    v51 = cast v49 as Field
+    v52 = cast v50 as Field
+    v53 = mul v47, v51
+    v54 = mul v46, v52
+    v55 = add v53, v54
+    v56 = mul v55, v55
+    v57 = mul v56, Field 2
+    v59 = array_get v27, index Field 4 -> u1
+    v60 = not v59
+    v61 = cast v59 as Field
+    v62 = cast v60 as Field
+    v63 = mul v57, v61
+    v64 = mul v56, v62
+    v65 = add v63, v64
+    v66 = mul v65, v65
+    v67 = mul v66, Field 2
+    v69 = array_get v27, index Field 3 -> u1
+    v70 = not v69
+    v71 = cast v69 as Field
+    v72 = cast v70 as Field
+    v73 = mul v67, v71
+    v74 = mul v66, v72
+    v75 = add v73, v74
+    v76 = mul v75, v75
+    v77 = mul v76, Field 2
+    v78 = array_get v27, index Field 2 -> u1
+    v79 = not v78
+    v80 = cast v78 as Field
+    v81 = cast v79 as Field
+    v82 = mul v77, v80
+    v83 = mul v76, v81
+    v84 = add v82, v83
+    v85 = mul v84, v84
+    v86 = mul v85, Field 2
+    v88 = array_get v27, index Field 1 -> u1
+    v89 = not v88
+    v90 = cast v88 as Field
+    v91 = cast v89 as Field
+    v92 = mul v86, v90
+    v93 = mul v85, v91
+    v94 = add v92, v93
+    v95 = mul v94, v94
+    v96 = mul v95, Field 2
+    v98 = array_get v27, index Field 0 -> u1
+    v99 = not v98
+    v100 = cast v98 as Field
+    v101 = cast v99 as Field
+    v102 = mul v96, v100
+    v103 = mul v95, v101
+    v104 = add v102, v103
+    v106 = lt v2, u8 128
+    v107 = not v106
+    v108 = cast v106 as Field
+    v109 = cast v107 as Field
+    v110 = mul v108, v104
+    v112 = mul v109, Field 340282366920938463463374607431768211455
+    v113 = add v110, v112
+    v114 = cast v113 as u128
+    v115 = div v0, v114
+    constrain v115 == u128 3086
+    v117 = cast v106 as u128
+    v118 = cast v104 as u128
+    v119 = unchecked_mul v117, v118
+    v120 = cast v0 as Field
+    v121 = cast v119 as Field
+    v122 = mul v120, v121
+    v123 = truncate v122 to 128 bits, max_bit_size: 254
+    v124 = cast v123 as u128
+    constrain v106 == u1 1, "attempt to bit-shift with overflow"
+    constrain v124 == u128 49380
+    v127 = lt v0, v1
+    constrain v127 == u1 1
+    v128 = lt v1, v0
+    constrain v128 == u1 0
+    constrain v0 != v1
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/31_array_set_optimizations b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/31_array_set_optimizations
new file mode 100644
index 00000000000..6ea56db03bc
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/31_array_set_optimizations
@@ -0,0 +1,121 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    constrain v3 == u128 2358023
+    v5 = sub v1, v0
+    constrain v5 == u128 2333333
+    v7 = mul v0, v1
+    v9 = div v0, u128 18446744073709551616
+    v10 = div v1, u128 18446744073709551616
+    v11 = unchecked_mul v9, v10
+    constrain v11 == u128 0, "attempt to multiply with overflow"
+    constrain v7 == u128 28957394910
+    v14 = div v1, v0
+    constrain v14 == u128 190
+    v16 = mod v1, v0
+    constrain v16 == u128 128
+    v18 = not v0
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v20 = xor v0, v1
+    constrain v20 == u128 2358007
+    v22 = and v0, v1
+    constrain v22 == u128 8
+    v24 = or v0, v1
+    constrain v24 == u128 2358015
+    v27 = call to_le_bits(v2) -> [u1; 8]
+    v29 = array_get v27, index Field 7 -> u1
+    v30 = not v29
+    v31 = cast v29 as Field
+    v32 = cast v30 as Field
+    v34 = mul Field 2, v31
+    v35 = add v34, v32
+    v36 = mul v35, v35
+    v37 = mul v36, Field 2
+    v39 = array_get v27, index Field 6 -> u1
+    v40 = not v39
+    v41 = cast v39 as Field
+    v42 = cast v40 as Field
+    v43 = mul v37, v41
+    v44 = mul v36, v42
+    v45 = add v43, v44
+    v46 = mul v45, v45
+    v47 = mul v46, Field 2
+    v49 = array_get v27, index Field 5 -> u1
+    v50 = not v49
+    v51 = cast v49 as Field
+    v52 = cast v50 as Field
+    v53 = mul v47, v51
+    v54 = mul v46, v52
+    v55 = add v53, v54
+    v56 = mul v55, v55
+    v57 = mul v56, Field 2
+    v59 = array_get v27, index Field 4 -> u1
+    v60 = not v59
+    v61 = cast v59 as Field
+    v62 = cast v60 as Field
+    v63 = mul v57, v61
+    v64 = mul v56, v62
+    v65 = add v63, v64
+    v66 = mul v65, v65
+    v67 = mul v66, Field 2
+    v69 = array_get v27, index Field 3 -> u1
+    v70 = not v69
+    v71 = cast v69 as Field
+    v72 = cast v70 as Field
+    v73 = mul v67, v71
+    v74 = mul v66, v72
+    v75 = add v73, v74
+    v76 = mul v75, v75
+    v77 = mul v76, Field 2
+    v78 = array_get v27, index Field 2 -> u1
+    v79 = not v78
+    v80 = cast v78 as Field
+    v81 = cast v79 as Field
+    v82 = mul v77, v80
+    v83 = mul v76, v81
+    v84 = add v82, v83
+    v85 = mul v84, v84
+    v86 = mul v85, Field 2
+    v88 = array_get v27, index Field 1 -> u1
+    v89 = not v88
+    v90 = cast v88 as Field
+    v91 = cast v89 as Field
+    v92 = mul v86, v90
+    v93 = mul v85, v91
+    v94 = add v92, v93
+    v95 = mul v94, v94
+    v96 = mul v95, Field 2
+    v98 = array_get v27, index Field 0 -> u1
+    v99 = not v98
+    v100 = cast v98 as Field
+    v101 = cast v99 as Field
+    v102 = mul v96, v100
+    v103 = mul v95, v101
+    v104 = add v102, v103
+    v106 = lt v2, u8 128
+    v107 = not v106
+    v108 = cast v106 as Field
+    v109 = cast v107 as Field
+    v110 = mul v108, v104
+    v112 = mul v109, Field 340282366920938463463374607431768211455
+    v113 = add v110, v112
+    v114 = cast v113 as u128
+    v115 = div v0, v114
+    constrain v115 == u128 3086
+    v117 = cast v106 as u128
+    v118 = cast v104 as u128
+    v119 = unchecked_mul v117, v118
+    v120 = cast v0 as Field
+    v121 = cast v119 as Field
+    v122 = mul v120, v121
+    v123 = truncate v122 to 128 bits, max_bit_size: 254
+    v124 = cast v123 as u128
+    constrain v106 == u1 1, "attempt to bit-shift with overflow"
+    constrain v124 == u128 49380
+    v127 = lt v0, v1
+    constrain v127 == u1 1
+    v128 = lt v1, v0
+    constrain v128 == u1 0
+    constrain v0 != v1
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/32_brillig_entry_point_analysis b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/32_brillig_entry_point_analysis
new file mode 100644
index 00000000000..6ea56db03bc
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/32_brillig_entry_point_analysis
@@ -0,0 +1,121 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    constrain v3 == u128 2358023
+    v5 = sub v1, v0
+    constrain v5 == u128 2333333
+    v7 = mul v0, v1
+    v9 = div v0, u128 18446744073709551616
+    v10 = div v1, u128 18446744073709551616
+    v11 = unchecked_mul v9, v10
+    constrain v11 == u128 0, "attempt to multiply with overflow"
+    constrain v7 == u128 28957394910
+    v14 = div v1, v0
+    constrain v14 == u128 190
+    v16 = mod v1, v0
+    constrain v16 == u128 128
+    v18 = not v0
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v20 = xor v0, v1
+    constrain v20 == u128 2358007
+    v22 = and v0, v1
+    constrain v22 == u128 8
+    v24 = or v0, v1
+    constrain v24 == u128 2358015
+    v27 = call to_le_bits(v2) -> [u1; 8]
+    v29 = array_get v27, index Field 7 -> u1
+    v30 = not v29
+    v31 = cast v29 as Field
+    v32 = cast v30 as Field
+    v34 = mul Field 2, v31
+    v35 = add v34, v32
+    v36 = mul v35, v35
+    v37 = mul v36, Field 2
+    v39 = array_get v27, index Field 6 -> u1
+    v40 = not v39
+    v41 = cast v39 as Field
+    v42 = cast v40 as Field
+    v43 = mul v37, v41
+    v44 = mul v36, v42
+    v45 = add v43, v44
+    v46 = mul v45, v45
+    v47 = mul v46, Field 2
+    v49 = array_get v27, index Field 5 -> u1
+    v50 = not v49
+    v51 = cast v49 as Field
+    v52 = cast v50 as Field
+    v53 = mul v47, v51
+    v54 = mul v46, v52
+    v55 = add v53, v54
+    v56 = mul v55, v55
+    v57 = mul v56, Field 2
+    v59 = array_get v27, index Field 4 -> u1
+    v60 = not v59
+    v61 = cast v59 as Field
+    v62 = cast v60 as Field
+    v63 = mul v57, v61
+    v64 = mul v56, v62
+    v65 = add v63, v64
+    v66 = mul v65, v65
+    v67 = mul v66, Field 2
+    v69 = array_get v27, index Field 3 -> u1
+    v70 = not v69
+    v71 = cast v69 as Field
+    v72 = cast v70 as Field
+    v73 = mul v67, v71
+    v74 = mul v66, v72
+    v75 = add v73, v74
+    v76 = mul v75, v75
+    v77 = mul v76, Field 2
+    v78 = array_get v27, index Field 2 -> u1
+    v79 = not v78
+    v80 = cast v78 as Field
+    v81 = cast v79 as Field
+    v82 = mul v77, v80
+    v83 = mul v76, v81
+    v84 = add v82, v83
+    v85 = mul v84, v84
+    v86 = mul v85, Field 2
+    v88 = array_get v27, index Field 1 -> u1
+    v89 = not v88
+    v90 = cast v88 as Field
+    v91 = cast v89 as Field
+    v92 = mul v86, v90
+    v93 = mul v85, v91
+    v94 = add v92, v93
+    v95 = mul v94, v94
+    v96 = mul v95, Field 2
+    v98 = array_get v27, index Field 0 -> u1
+    v99 = not v98
+    v100 = cast v98 as Field
+    v101 = cast v99 as Field
+    v102 = mul v96, v100
+    v103 = mul v95, v101
+    v104 = add v102, v103
+    v106 = lt v2, u8 128
+    v107 = not v106
+    v108 = cast v106 as Field
+    v109 = cast v107 as Field
+    v110 = mul v108, v104
+    v112 = mul v109, Field 340282366920938463463374607431768211455
+    v113 = add v110, v112
+    v114 = cast v113 as u128
+    v115 = div v0, v114
+    constrain v115 == u128 3086
+    v117 = cast v106 as u128
+    v118 = cast v104 as u128
+    v119 = unchecked_mul v117, v118
+    v120 = cast v0 as Field
+    v121 = cast v119 as Field
+    v122 = mul v120, v121
+    v123 = truncate v122 to 128 bits, max_bit_size: 254
+    v124 = cast v123 as u128
+    constrain v106 == u1 1, "attempt to bit-shift with overflow"
+    constrain v124 == u128 49380
+    v127 = lt v0, v1
+    constrain v127 == u1 1
+    v128 = lt v1, v0
+    constrain v128 == u1 0
+    constrain v0 != v1
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/33_removing_unreachable_functions_3 b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/33_removing_unreachable_functions_3
new file mode 100644
index 00000000000..6ea56db03bc
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/33_removing_unreachable_functions_3
@@ -0,0 +1,121 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    constrain v3 == u128 2358023
+    v5 = sub v1, v0
+    constrain v5 == u128 2333333
+    v7 = mul v0, v1
+    v9 = div v0, u128 18446744073709551616
+    v10 = div v1, u128 18446744073709551616
+    v11 = unchecked_mul v9, v10
+    constrain v11 == u128 0, "attempt to multiply with overflow"
+    constrain v7 == u128 28957394910
+    v14 = div v1, v0
+    constrain v14 == u128 190
+    v16 = mod v1, v0
+    constrain v16 == u128 128
+    v18 = not v0
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v20 = xor v0, v1
+    constrain v20 == u128 2358007
+    v22 = and v0, v1
+    constrain v22 == u128 8
+    v24 = or v0, v1
+    constrain v24 == u128 2358015
+    v27 = call to_le_bits(v2) -> [u1; 8]
+    v29 = array_get v27, index Field 7 -> u1
+    v30 = not v29
+    v31 = cast v29 as Field
+    v32 = cast v30 as Field
+    v34 = mul Field 2, v31
+    v35 = add v34, v32
+    v36 = mul v35, v35
+    v37 = mul v36, Field 2
+    v39 = array_get v27, index Field 6 -> u1
+    v40 = not v39
+    v41 = cast v39 as Field
+    v42 = cast v40 as Field
+    v43 = mul v37, v41
+    v44 = mul v36, v42
+    v45 = add v43, v44
+    v46 = mul v45, v45
+    v47 = mul v46, Field 2
+    v49 = array_get v27, index Field 5 -> u1
+    v50 = not v49
+    v51 = cast v49 as Field
+    v52 = cast v50 as Field
+    v53 = mul v47, v51
+    v54 = mul v46, v52
+    v55 = add v53, v54
+    v56 = mul v55, v55
+    v57 = mul v56, Field 2
+    v59 = array_get v27, index Field 4 -> u1
+    v60 = not v59
+    v61 = cast v59 as Field
+    v62 = cast v60 as Field
+    v63 = mul v57, v61
+    v64 = mul v56, v62
+    v65 = add v63, v64
+    v66 = mul v65, v65
+    v67 = mul v66, Field 2
+    v69 = array_get v27, index Field 3 -> u1
+    v70 = not v69
+    v71 = cast v69 as Field
+    v72 = cast v70 as Field
+    v73 = mul v67, v71
+    v74 = mul v66, v72
+    v75 = add v73, v74
+    v76 = mul v75, v75
+    v77 = mul v76, Field 2
+    v78 = array_get v27, index Field 2 -> u1
+    v79 = not v78
+    v80 = cast v78 as Field
+    v81 = cast v79 as Field
+    v82 = mul v77, v80
+    v83 = mul v76, v81
+    v84 = add v82, v83
+    v85 = mul v84, v84
+    v86 = mul v85, Field 2
+    v88 = array_get v27, index Field 1 -> u1
+    v89 = not v88
+    v90 = cast v88 as Field
+    v91 = cast v89 as Field
+    v92 = mul v86, v90
+    v93 = mul v85, v91
+    v94 = add v92, v93
+    v95 = mul v94, v94
+    v96 = mul v95, Field 2
+    v98 = array_get v27, index Field 0 -> u1
+    v99 = not v98
+    v100 = cast v98 as Field
+    v101 = cast v99 as Field
+    v102 = mul v96, v100
+    v103 = mul v95, v101
+    v104 = add v102, v103
+    v106 = lt v2, u8 128
+    v107 = not v106
+    v108 = cast v106 as Field
+    v109 = cast v107 as Field
+    v110 = mul v108, v104
+    v112 = mul v109, Field 340282366920938463463374607431768211455
+    v113 = add v110, v112
+    v114 = cast v113 as u128
+    v115 = div v0, v114
+    constrain v115 == u128 3086
+    v117 = cast v106 as u128
+    v118 = cast v104 as u128
+    v119 = unchecked_mul v117, v118
+    v120 = cast v0 as Field
+    v121 = cast v119 as Field
+    v122 = mul v120, v121
+    v123 = truncate v122 to 128 bits, max_bit_size: 254
+    v124 = cast v123 as u128
+    constrain v106 == u1 1, "attempt to bit-shift with overflow"
+    constrain v124 == u128 49380
+    v127 = lt v0, v1
+    constrain v127 == u1 1
+    v128 = lt v1, v0
+    constrain v128 == u1 0
+    constrain v0 != v1
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/34_removing_truncate_after_rangecheck b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/34_removing_truncate_after_rangecheck
new file mode 100644
index 00000000000..6ea56db03bc
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/34_removing_truncate_after_rangecheck
@@ -0,0 +1,121 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    constrain v3 == u128 2358023
+    v5 = sub v1, v0
+    constrain v5 == u128 2333333
+    v7 = mul v0, v1
+    v9 = div v0, u128 18446744073709551616
+    v10 = div v1, u128 18446744073709551616
+    v11 = unchecked_mul v9, v10
+    constrain v11 == u128 0, "attempt to multiply with overflow"
+    constrain v7 == u128 28957394910
+    v14 = div v1, v0
+    constrain v14 == u128 190
+    v16 = mod v1, v0
+    constrain v16 == u128 128
+    v18 = not v0
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v20 = xor v0, v1
+    constrain v20 == u128 2358007
+    v22 = and v0, v1
+    constrain v22 == u128 8
+    v24 = or v0, v1
+    constrain v24 == u128 2358015
+    v27 = call to_le_bits(v2) -> [u1; 8]
+    v29 = array_get v27, index Field 7 -> u1
+    v30 = not v29
+    v31 = cast v29 as Field
+    v32 = cast v30 as Field
+    v34 = mul Field 2, v31
+    v35 = add v34, v32
+    v36 = mul v35, v35
+    v37 = mul v36, Field 2
+    v39 = array_get v27, index Field 6 -> u1
+    v40 = not v39
+    v41 = cast v39 as Field
+    v42 = cast v40 as Field
+    v43 = mul v37, v41
+    v44 = mul v36, v42
+    v45 = add v43, v44
+    v46 = mul v45, v45
+    v47 = mul v46, Field 2
+    v49 = array_get v27, index Field 5 -> u1
+    v50 = not v49
+    v51 = cast v49 as Field
+    v52 = cast v50 as Field
+    v53 = mul v47, v51
+    v54 = mul v46, v52
+    v55 = add v53, v54
+    v56 = mul v55, v55
+    v57 = mul v56, Field 2
+    v59 = array_get v27, index Field 4 -> u1
+    v60 = not v59
+    v61 = cast v59 as Field
+    v62 = cast v60 as Field
+    v63 = mul v57, v61
+    v64 = mul v56, v62
+    v65 = add v63, v64
+    v66 = mul v65, v65
+    v67 = mul v66, Field 2
+    v69 = array_get v27, index Field 3 -> u1
+    v70 = not v69
+    v71 = cast v69 as Field
+    v72 = cast v70 as Field
+    v73 = mul v67, v71
+    v74 = mul v66, v72
+    v75 = add v73, v74
+    v76 = mul v75, v75
+    v77 = mul v76, Field 2
+    v78 = array_get v27, index Field 2 -> u1
+    v79 = not v78
+    v80 = cast v78 as Field
+    v81 = cast v79 as Field
+    v82 = mul v77, v80
+    v83 = mul v76, v81
+    v84 = add v82, v83
+    v85 = mul v84, v84
+    v86 = mul v85, Field 2
+    v88 = array_get v27, index Field 1 -> u1
+    v89 = not v88
+    v90 = cast v88 as Field
+    v91 = cast v89 as Field
+    v92 = mul v86, v90
+    v93 = mul v85, v91
+    v94 = add v92, v93
+    v95 = mul v94, v94
+    v96 = mul v95, Field 2
+    v98 = array_get v27, index Field 0 -> u1
+    v99 = not v98
+    v100 = cast v98 as Field
+    v101 = cast v99 as Field
+    v102 = mul v96, v100
+    v103 = mul v95, v101
+    v104 = add v102, v103
+    v106 = lt v2, u8 128
+    v107 = not v106
+    v108 = cast v106 as Field
+    v109 = cast v107 as Field
+    v110 = mul v108, v104
+    v112 = mul v109, Field 340282366920938463463374607431768211455
+    v113 = add v110, v112
+    v114 = cast v113 as u128
+    v115 = div v0, v114
+    constrain v115 == u128 3086
+    v117 = cast v106 as u128
+    v118 = cast v104 as u128
+    v119 = unchecked_mul v117, v118
+    v120 = cast v0 as Field
+    v121 = cast v119 as Field
+    v122 = mul v120, v121
+    v123 = truncate v122 to 128 bits, max_bit_size: 254
+    v124 = cast v123 as u128
+    constrain v106 == u1 1, "attempt to bit-shift with overflow"
+    constrain v124 == u128 49380
+    v127 = lt v0, v1
+    constrain v127 == u1 1
+    v128 = lt v1, v0
+    constrain v128 == u1 0
+    constrain v0 != v1
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/35_brillig_array_get_optimizations b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/35_brillig_array_get_optimizations
new file mode 100644
index 00000000000..6ea56db03bc
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/35_brillig_array_get_optimizations
@@ -0,0 +1,121 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    constrain v3 == u128 2358023
+    v5 = sub v1, v0
+    constrain v5 == u128 2333333
+    v7 = mul v0, v1
+    v9 = div v0, u128 18446744073709551616
+    v10 = div v1, u128 18446744073709551616
+    v11 = unchecked_mul v9, v10
+    constrain v11 == u128 0, "attempt to multiply with overflow"
+    constrain v7 == u128 28957394910
+    v14 = div v1, v0
+    constrain v14 == u128 190
+    v16 = mod v1, v0
+    constrain v16 == u128 128
+    v18 = not v0
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v20 = xor v0, v1
+    constrain v20 == u128 2358007
+    v22 = and v0, v1
+    constrain v22 == u128 8
+    v24 = or v0, v1
+    constrain v24 == u128 2358015
+    v27 = call to_le_bits(v2) -> [u1; 8]
+    v29 = array_get v27, index Field 7 -> u1
+    v30 = not v29
+    v31 = cast v29 as Field
+    v32 = cast v30 as Field
+    v34 = mul Field 2, v31
+    v35 = add v34, v32
+    v36 = mul v35, v35
+    v37 = mul v36, Field 2
+    v39 = array_get v27, index Field 6 -> u1
+    v40 = not v39
+    v41 = cast v39 as Field
+    v42 = cast v40 as Field
+    v43 = mul v37, v41
+    v44 = mul v36, v42
+    v45 = add v43, v44
+    v46 = mul v45, v45
+    v47 = mul v46, Field 2
+    v49 = array_get v27, index Field 5 -> u1
+    v50 = not v49
+    v51 = cast v49 as Field
+    v52 = cast v50 as Field
+    v53 = mul v47, v51
+    v54 = mul v46, v52
+    v55 = add v53, v54
+    v56 = mul v55, v55
+    v57 = mul v56, Field 2
+    v59 = array_get v27, index Field 4 -> u1
+    v60 = not v59
+    v61 = cast v59 as Field
+    v62 = cast v60 as Field
+    v63 = mul v57, v61
+    v64 = mul v56, v62
+    v65 = add v63, v64
+    v66 = mul v65, v65
+    v67 = mul v66, Field 2
+    v69 = array_get v27, index Field 3 -> u1
+    v70 = not v69
+    v71 = cast v69 as Field
+    v72 = cast v70 as Field
+    v73 = mul v67, v71
+    v74 = mul v66, v72
+    v75 = add v73, v74
+    v76 = mul v75, v75
+    v77 = mul v76, Field 2
+    v78 = array_get v27, index Field 2 -> u1
+    v79 = not v78
+    v80 = cast v78 as Field
+    v81 = cast v79 as Field
+    v82 = mul v77, v80
+    v83 = mul v76, v81
+    v84 = add v82, v83
+    v85 = mul v84, v84
+    v86 = mul v85, Field 2
+    v88 = array_get v27, index Field 1 -> u1
+    v89 = not v88
+    v90 = cast v88 as Field
+    v91 = cast v89 as Field
+    v92 = mul v86, v90
+    v93 = mul v85, v91
+    v94 = add v92, v93
+    v95 = mul v94, v94
+    v96 = mul v95, Field 2
+    v98 = array_get v27, index Field 0 -> u1
+    v99 = not v98
+    v100 = cast v98 as Field
+    v101 = cast v99 as Field
+    v102 = mul v96, v100
+    v103 = mul v95, v101
+    v104 = add v102, v103
+    v106 = lt v2, u8 128
+    v107 = not v106
+    v108 = cast v106 as Field
+    v109 = cast v107 as Field
+    v110 = mul v108, v104
+    v112 = mul v109, Field 340282366920938463463374607431768211455
+    v113 = add v110, v112
+    v114 = cast v113 as u128
+    v115 = div v0, v114
+    constrain v115 == u128 3086
+    v117 = cast v106 as u128
+    v118 = cast v104 as u128
+    v119 = unchecked_mul v117, v118
+    v120 = cast v0 as Field
+    v121 = cast v119 as Field
+    v122 = mul v120, v121
+    v123 = truncate v122 to 128 bits, max_bit_size: 254
+    v124 = cast v123 as u128
+    constrain v106 == u1 1, "attempt to bit-shift with overflow"
+    constrain v124 == u128 49380
+    v127 = lt v0, v1
+    constrain v127 == u1 1
+    v128 = lt v1, v0
+    constrain v128 == u1 0
+    constrain v0 != v1
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/36_dead_instruction_elimination_2 b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/36_dead_instruction_elimination_2
new file mode 100644
index 00000000000..6ea56db03bc
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/36_dead_instruction_elimination_2
@@ -0,0 +1,121 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    constrain v3 == u128 2358023
+    v5 = sub v1, v0
+    constrain v5 == u128 2333333
+    v7 = mul v0, v1
+    v9 = div v0, u128 18446744073709551616
+    v10 = div v1, u128 18446744073709551616
+    v11 = unchecked_mul v9, v10
+    constrain v11 == u128 0, "attempt to multiply with overflow"
+    constrain v7 == u128 28957394910
+    v14 = div v1, v0
+    constrain v14 == u128 190
+    v16 = mod v1, v0
+    constrain v16 == u128 128
+    v18 = not v0
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v20 = xor v0, v1
+    constrain v20 == u128 2358007
+    v22 = and v0, v1
+    constrain v22 == u128 8
+    v24 = or v0, v1
+    constrain v24 == u128 2358015
+    v27 = call to_le_bits(v2) -> [u1; 8]
+    v29 = array_get v27, index Field 7 -> u1
+    v30 = not v29
+    v31 = cast v29 as Field
+    v32 = cast v30 as Field
+    v34 = mul Field 2, v31
+    v35 = add v34, v32
+    v36 = mul v35, v35
+    v37 = mul v36, Field 2
+    v39 = array_get v27, index Field 6 -> u1
+    v40 = not v39
+    v41 = cast v39 as Field
+    v42 = cast v40 as Field
+    v43 = mul v37, v41
+    v44 = mul v36, v42
+    v45 = add v43, v44
+    v46 = mul v45, v45
+    v47 = mul v46, Field 2
+    v49 = array_get v27, index Field 5 -> u1
+    v50 = not v49
+    v51 = cast v49 as Field
+    v52 = cast v50 as Field
+    v53 = mul v47, v51
+    v54 = mul v46, v52
+    v55 = add v53, v54
+    v56 = mul v55, v55
+    v57 = mul v56, Field 2
+    v59 = array_get v27, index Field 4 -> u1
+    v60 = not v59
+    v61 = cast v59 as Field
+    v62 = cast v60 as Field
+    v63 = mul v57, v61
+    v64 = mul v56, v62
+    v65 = add v63, v64
+    v66 = mul v65, v65
+    v67 = mul v66, Field 2
+    v69 = array_get v27, index Field 3 -> u1
+    v70 = not v69
+    v71 = cast v69 as Field
+    v72 = cast v70 as Field
+    v73 = mul v67, v71
+    v74 = mul v66, v72
+    v75 = add v73, v74
+    v76 = mul v75, v75
+    v77 = mul v76, Field 2
+    v78 = array_get v27, index Field 2 -> u1
+    v79 = not v78
+    v80 = cast v78 as Field
+    v81 = cast v79 as Field
+    v82 = mul v77, v80
+    v83 = mul v76, v81
+    v84 = add v82, v83
+    v85 = mul v84, v84
+    v86 = mul v85, Field 2
+    v88 = array_get v27, index Field 1 -> u1
+    v89 = not v88
+    v90 = cast v88 as Field
+    v91 = cast v89 as Field
+    v92 = mul v86, v90
+    v93 = mul v85, v91
+    v94 = add v92, v93
+    v95 = mul v94, v94
+    v96 = mul v95, Field 2
+    v98 = array_get v27, index Field 0 -> u1
+    v99 = not v98
+    v100 = cast v98 as Field
+    v101 = cast v99 as Field
+    v102 = mul v96, v100
+    v103 = mul v95, v101
+    v104 = add v102, v103
+    v106 = lt v2, u8 128
+    v107 = not v106
+    v108 = cast v106 as Field
+    v109 = cast v107 as Field
+    v110 = mul v108, v104
+    v112 = mul v109, Field 340282366920938463463374607431768211455
+    v113 = add v110, v112
+    v114 = cast v113 as u128
+    v115 = div v0, v114
+    constrain v115 == u128 3086
+    v117 = cast v106 as u128
+    v118 = cast v104 as u128
+    v119 = unchecked_mul v117, v118
+    v120 = cast v0 as Field
+    v121 = cast v119 as Field
+    v122 = mul v120, v121
+    v123 = truncate v122 to 128 bits, max_bit_size: 254
+    v124 = cast v123 as u128
+    constrain v106 == u1 1, "attempt to bit-shift with overflow"
+    constrain v124 == u128 49380
+    v127 = lt v0, v1
+    constrain v127 == u1 1
+    v128 = lt v1, v0
+    constrain v128 == u1 0
+    constrain v0 != v1
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/37_inlining_brillig_calls_inlining b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/37_inlining_brillig_calls_inlining
new file mode 100644
index 00000000000..6ea56db03bc
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/37_inlining_brillig_calls_inlining
@@ -0,0 +1,121 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    constrain v3 == u128 2358023
+    v5 = sub v1, v0
+    constrain v5 == u128 2333333
+    v7 = mul v0, v1
+    v9 = div v0, u128 18446744073709551616
+    v10 = div v1, u128 18446744073709551616
+    v11 = unchecked_mul v9, v10
+    constrain v11 == u128 0, "attempt to multiply with overflow"
+    constrain v7 == u128 28957394910
+    v14 = div v1, v0
+    constrain v14 == u128 190
+    v16 = mod v1, v0
+    constrain v16 == u128 128
+    v18 = not v0
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v20 = xor v0, v1
+    constrain v20 == u128 2358007
+    v22 = and v0, v1
+    constrain v22 == u128 8
+    v24 = or v0, v1
+    constrain v24 == u128 2358015
+    v27 = call to_le_bits(v2) -> [u1; 8]
+    v29 = array_get v27, index Field 7 -> u1
+    v30 = not v29
+    v31 = cast v29 as Field
+    v32 = cast v30 as Field
+    v34 = mul Field 2, v31
+    v35 = add v34, v32
+    v36 = mul v35, v35
+    v37 = mul v36, Field 2
+    v39 = array_get v27, index Field 6 -> u1
+    v40 = not v39
+    v41 = cast v39 as Field
+    v42 = cast v40 as Field
+    v43 = mul v37, v41
+    v44 = mul v36, v42
+    v45 = add v43, v44
+    v46 = mul v45, v45
+    v47 = mul v46, Field 2
+    v49 = array_get v27, index Field 5 -> u1
+    v50 = not v49
+    v51 = cast v49 as Field
+    v52 = cast v50 as Field
+    v53 = mul v47, v51
+    v54 = mul v46, v52
+    v55 = add v53, v54
+    v56 = mul v55, v55
+    v57 = mul v56, Field 2
+    v59 = array_get v27, index Field 4 -> u1
+    v60 = not v59
+    v61 = cast v59 as Field
+    v62 = cast v60 as Field
+    v63 = mul v57, v61
+    v64 = mul v56, v62
+    v65 = add v63, v64
+    v66 = mul v65, v65
+    v67 = mul v66, Field 2
+    v69 = array_get v27, index Field 3 -> u1
+    v70 = not v69
+    v71 = cast v69 as Field
+    v72 = cast v70 as Field
+    v73 = mul v67, v71
+    v74 = mul v66, v72
+    v75 = add v73, v74
+    v76 = mul v75, v75
+    v77 = mul v76, Field 2
+    v78 = array_get v27, index Field 2 -> u1
+    v79 = not v78
+    v80 = cast v78 as Field
+    v81 = cast v79 as Field
+    v82 = mul v77, v80
+    v83 = mul v76, v81
+    v84 = add v82, v83
+    v85 = mul v84, v84
+    v86 = mul v85, Field 2
+    v88 = array_get v27, index Field 1 -> u1
+    v89 = not v88
+    v90 = cast v88 as Field
+    v91 = cast v89 as Field
+    v92 = mul v86, v90
+    v93 = mul v85, v91
+    v94 = add v92, v93
+    v95 = mul v94, v94
+    v96 = mul v95, Field 2
+    v98 = array_get v27, index Field 0 -> u1
+    v99 = not v98
+    v100 = cast v98 as Field
+    v101 = cast v99 as Field
+    v102 = mul v96, v100
+    v103 = mul v95, v101
+    v104 = add v102, v103
+    v106 = lt v2, u8 128
+    v107 = not v106
+    v108 = cast v106 as Field
+    v109 = cast v107 as Field
+    v110 = mul v108, v104
+    v112 = mul v109, Field 340282366920938463463374607431768211455
+    v113 = add v110, v112
+    v114 = cast v113 as u128
+    v115 = div v0, v114
+    constrain v115 == u128 3086
+    v117 = cast v106 as u128
+    v118 = cast v104 as u128
+    v119 = unchecked_mul v117, v118
+    v120 = cast v0 as Field
+    v121 = cast v119 as Field
+    v122 = mul v120, v121
+    v123 = truncate v122 to 128 bits, max_bit_size: 254
+    v124 = cast v123 as u128
+    constrain v106 == u1 1, "attempt to bit-shift with overflow"
+    constrain v124 == u128 49380
+    v127 = lt v0, v1
+    constrain v127 == u1 1
+    v128 = lt v1, v0
+    constrain v128 == u1 0
+    constrain v0 != v1
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/38_removing_unreachable_functions_4 b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/38_removing_unreachable_functions_4
new file mode 100644
index 00000000000..6ea56db03bc
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/38_removing_unreachable_functions_4
@@ -0,0 +1,121 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    constrain v3 == u128 2358023
+    v5 = sub v1, v0
+    constrain v5 == u128 2333333
+    v7 = mul v0, v1
+    v9 = div v0, u128 18446744073709551616
+    v10 = div v1, u128 18446744073709551616
+    v11 = unchecked_mul v9, v10
+    constrain v11 == u128 0, "attempt to multiply with overflow"
+    constrain v7 == u128 28957394910
+    v14 = div v1, v0
+    constrain v14 == u128 190
+    v16 = mod v1, v0
+    constrain v16 == u128 128
+    v18 = not v0
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v20 = xor v0, v1
+    constrain v20 == u128 2358007
+    v22 = and v0, v1
+    constrain v22 == u128 8
+    v24 = or v0, v1
+    constrain v24 == u128 2358015
+    v27 = call to_le_bits(v2) -> [u1; 8]
+    v29 = array_get v27, index Field 7 -> u1
+    v30 = not v29
+    v31 = cast v29 as Field
+    v32 = cast v30 as Field
+    v34 = mul Field 2, v31
+    v35 = add v34, v32
+    v36 = mul v35, v35
+    v37 = mul v36, Field 2
+    v39 = array_get v27, index Field 6 -> u1
+    v40 = not v39
+    v41 = cast v39 as Field
+    v42 = cast v40 as Field
+    v43 = mul v37, v41
+    v44 = mul v36, v42
+    v45 = add v43, v44
+    v46 = mul v45, v45
+    v47 = mul v46, Field 2
+    v49 = array_get v27, index Field 5 -> u1
+    v50 = not v49
+    v51 = cast v49 as Field
+    v52 = cast v50 as Field
+    v53 = mul v47, v51
+    v54 = mul v46, v52
+    v55 = add v53, v54
+    v56 = mul v55, v55
+    v57 = mul v56, Field 2
+    v59 = array_get v27, index Field 4 -> u1
+    v60 = not v59
+    v61 = cast v59 as Field
+    v62 = cast v60 as Field
+    v63 = mul v57, v61
+    v64 = mul v56, v62
+    v65 = add v63, v64
+    v66 = mul v65, v65
+    v67 = mul v66, Field 2
+    v69 = array_get v27, index Field 3 -> u1
+    v70 = not v69
+    v71 = cast v69 as Field
+    v72 = cast v70 as Field
+    v73 = mul v67, v71
+    v74 = mul v66, v72
+    v75 = add v73, v74
+    v76 = mul v75, v75
+    v77 = mul v76, Field 2
+    v78 = array_get v27, index Field 2 -> u1
+    v79 = not v78
+    v80 = cast v78 as Field
+    v81 = cast v79 as Field
+    v82 = mul v77, v80
+    v83 = mul v76, v81
+    v84 = add v82, v83
+    v85 = mul v84, v84
+    v86 = mul v85, Field 2
+    v88 = array_get v27, index Field 1 -> u1
+    v89 = not v88
+    v90 = cast v88 as Field
+    v91 = cast v89 as Field
+    v92 = mul v86, v90
+    v93 = mul v85, v91
+    v94 = add v92, v93
+    v95 = mul v94, v94
+    v96 = mul v95, Field 2
+    v98 = array_get v27, index Field 0 -> u1
+    v99 = not v98
+    v100 = cast v98 as Field
+    v101 = cast v99 as Field
+    v102 = mul v96, v100
+    v103 = mul v95, v101
+    v104 = add v102, v103
+    v106 = lt v2, u8 128
+    v107 = not v106
+    v108 = cast v106 as Field
+    v109 = cast v107 as Field
+    v110 = mul v108, v104
+    v112 = mul v109, Field 340282366920938463463374607431768211455
+    v113 = add v110, v112
+    v114 = cast v113 as u128
+    v115 = div v0, v114
+    constrain v115 == u128 3086
+    v117 = cast v106 as u128
+    v118 = cast v104 as u128
+    v119 = unchecked_mul v117, v118
+    v120 = cast v0 as Field
+    v121 = cast v119 as Field
+    v122 = mul v120, v121
+    v123 = truncate v122 to 128 bits, max_bit_size: 254
+    v124 = cast v123 as u128
+    constrain v106 == u1 1, "attempt to bit-shift with overflow"
+    constrain v124 == u128 49380
+    v127 = lt v0, v1
+    constrain v127 == u1 1
+    v128 = lt v1, v0
+    constrain v128 == u1 0
+    constrain v0 != v1
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/39_dead_instruction_elimination_3 b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/39_dead_instruction_elimination_3
new file mode 100644
index 00000000000..6ea56db03bc
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/39_dead_instruction_elimination_3
@@ -0,0 +1,121 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    constrain v3 == u128 2358023
+    v5 = sub v1, v0
+    constrain v5 == u128 2333333
+    v7 = mul v0, v1
+    v9 = div v0, u128 18446744073709551616
+    v10 = div v1, u128 18446744073709551616
+    v11 = unchecked_mul v9, v10
+    constrain v11 == u128 0, "attempt to multiply with overflow"
+    constrain v7 == u128 28957394910
+    v14 = div v1, v0
+    constrain v14 == u128 190
+    v16 = mod v1, v0
+    constrain v16 == u128 128
+    v18 = not v0
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v20 = xor v0, v1
+    constrain v20 == u128 2358007
+    v22 = and v0, v1
+    constrain v22 == u128 8
+    v24 = or v0, v1
+    constrain v24 == u128 2358015
+    v27 = call to_le_bits(v2) -> [u1; 8]
+    v29 = array_get v27, index Field 7 -> u1
+    v30 = not v29
+    v31 = cast v29 as Field
+    v32 = cast v30 as Field
+    v34 = mul Field 2, v31
+    v35 = add v34, v32
+    v36 = mul v35, v35
+    v37 = mul v36, Field 2
+    v39 = array_get v27, index Field 6 -> u1
+    v40 = not v39
+    v41 = cast v39 as Field
+    v42 = cast v40 as Field
+    v43 = mul v37, v41
+    v44 = mul v36, v42
+    v45 = add v43, v44
+    v46 = mul v45, v45
+    v47 = mul v46, Field 2
+    v49 = array_get v27, index Field 5 -> u1
+    v50 = not v49
+    v51 = cast v49 as Field
+    v52 = cast v50 as Field
+    v53 = mul v47, v51
+    v54 = mul v46, v52
+    v55 = add v53, v54
+    v56 = mul v55, v55
+    v57 = mul v56, Field 2
+    v59 = array_get v27, index Field 4 -> u1
+    v60 = not v59
+    v61 = cast v59 as Field
+    v62 = cast v60 as Field
+    v63 = mul v57, v61
+    v64 = mul v56, v62
+    v65 = add v63, v64
+    v66 = mul v65, v65
+    v67 = mul v66, Field 2
+    v69 = array_get v27, index Field 3 -> u1
+    v70 = not v69
+    v71 = cast v69 as Field
+    v72 = cast v70 as Field
+    v73 = mul v67, v71
+    v74 = mul v66, v72
+    v75 = add v73, v74
+    v76 = mul v75, v75
+    v77 = mul v76, Field 2
+    v78 = array_get v27, index Field 2 -> u1
+    v79 = not v78
+    v80 = cast v78 as Field
+    v81 = cast v79 as Field
+    v82 = mul v77, v80
+    v83 = mul v76, v81
+    v84 = add v82, v83
+    v85 = mul v84, v84
+    v86 = mul v85, Field 2
+    v88 = array_get v27, index Field 1 -> u1
+    v89 = not v88
+    v90 = cast v88 as Field
+    v91 = cast v89 as Field
+    v92 = mul v86, v90
+    v93 = mul v85, v91
+    v94 = add v92, v93
+    v95 = mul v94, v94
+    v96 = mul v95, Field 2
+    v98 = array_get v27, index Field 0 -> u1
+    v99 = not v98
+    v100 = cast v98 as Field
+    v101 = cast v99 as Field
+    v102 = mul v96, v100
+    v103 = mul v95, v101
+    v104 = add v102, v103
+    v106 = lt v2, u8 128
+    v107 = not v106
+    v108 = cast v106 as Field
+    v109 = cast v107 as Field
+    v110 = mul v108, v104
+    v112 = mul v109, Field 340282366920938463463374607431768211455
+    v113 = add v110, v112
+    v114 = cast v113 as u128
+    v115 = div v0, v114
+    constrain v115 == u128 3086
+    v117 = cast v106 as u128
+    v118 = cast v104 as u128
+    v119 = unchecked_mul v117, v118
+    v120 = cast v0 as Field
+    v121 = cast v119 as Field
+    v122 = mul v120, v121
+    v123 = truncate v122 to 128 bits, max_bit_size: 254
+    v124 = cast v123 as u128
+    constrain v106 == u1 1, "attempt to bit-shift with overflow"
+    constrain v124 == u128 49380
+    v127 = lt v0, v1
+    constrain v127 == u1 1
+    v128 = lt v1, v0
+    constrain v128 == u1 0
+    constrain v0 != v1
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/40_} b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/40_}
new file mode 100644
index 00000000000..6ea56db03bc
--- /dev/null
+++ b/compiler/noirc_evaluator/src/ssa/opt/snapshots/execution_success/u128_type/40_}
@@ -0,0 +1,121 @@
+acir(inline) predicate_pure fn main f0 {
+  b0(v0: u128, v1: u128, v2: u8):
+    v3 = add v0, v1
+    constrain v3 == u128 2358023
+    v5 = sub v1, v0
+    constrain v5 == u128 2333333
+    v7 = mul v0, v1
+    v9 = div v0, u128 18446744073709551616
+    v10 = div v1, u128 18446744073709551616
+    v11 = unchecked_mul v9, v10
+    constrain v11 == u128 0, "attempt to multiply with overflow"
+    constrain v7 == u128 28957394910
+    v14 = div v1, v0
+    constrain v14 == u128 190
+    v16 = mod v1, v0
+    constrain v16 == u128 128
+    v18 = not v0
+    constrain v18 == u128 340282366920938463463374607431768199110
+    v20 = xor v0, v1
+    constrain v20 == u128 2358007
+    v22 = and v0, v1
+    constrain v22 == u128 8
+    v24 = or v0, v1
+    constrain v24 == u128 2358015
+    v27 = call to_le_bits(v2) -> [u1; 8]
+    v29 = array_get v27, index Field 7 -> u1
+    v30 = not v29
+    v31 = cast v29 as Field
+    v32 = cast v30 as Field
+    v34 = mul Field 2, v31
+    v35 = add v34, v32
+    v36 = mul v35, v35
+    v37 = mul v36, Field 2
+    v39 = array_get v27, index Field 6 -> u1
+    v40 = not v39
+    v41 = cast v39 as Field
+    v42 = cast v40 as Field
+    v43 = mul v37, v41
+    v44 = mul v36, v42
+    v45 = add v43, v44
+    v46 = mul v45, v45
+    v47 = mul v46, Field 2
+    v49 = array_get v27, index Field 5 -> u1
+    v50 = not v49
+    v51 = cast v49 as Field
+    v52 = cast v50 as Field
+    v53 = mul v47, v51
+    v54 = mul v46, v52
+    v55 = add v53, v54
+    v56 = mul v55, v55
+    v57 = mul v56, Field 2
+    v59 = array_get v27, index Field 4 -> u1
+    v60 = not v59
+    v61 = cast v59 as Field
+    v62 = cast v60 as Field
+    v63 = mul v57, v61
+    v64 = mul v56, v62
+    v65 = add v63, v64
+    v66 = mul v65, v65
+    v67 = mul v66, Field 2
+    v69 = array_get v27, index Field 3 -> u1
+    v70 = not v69
+    v71 = cast v69 as Field
+    v72 = cast v70 as Field
+    v73 = mul v67, v71
+    v74 = mul v66, v72
+    v75 = add v73, v74
+    v76 = mul v75, v75
+    v77 = mul v76, Field 2
+    v78 = array_get v27, index Field 2 -> u1
+    v79 = not v78
+    v80 = cast v78 as Field
+    v81 = cast v79 as Field
+    v82 = mul v77, v80
+    v83 = mul v76, v81
+    v84 = add v82, v83
+    v85 = mul v84, v84
+    v86 = mul v85, Field 2
+    v88 = array_get v27, index Field 1 -> u1
+    v89 = not v88
+    v90 = cast v88 as Field
+    v91 = cast v89 as Field
+    v92 = mul v86, v90
+    v93 = mul v85, v91
+    v94 = add v92, v93
+    v95 = mul v94, v94
+    v96 = mul v95, Field 2
+    v98 = array_get v27, index Field 0 -> u1
+    v99 = not v98
+    v100 = cast v98 as Field
+    v101 = cast v99 as Field
+    v102 = mul v96, v100
+    v103 = mul v95, v101
+    v104 = add v102, v103
+    v106 = lt v2, u8 128
+    v107 = not v106
+    v108 = cast v106 as Field
+    v109 = cast v107 as Field
+    v110 = mul v108, v104
+    v112 = mul v109, Field 340282366920938463463374607431768211455
+    v113 = add v110, v112
+    v114 = cast v113 as u128
+    v115 = div v0, v114
+    constrain v115 == u128 3086
+    v117 = cast v106 as u128
+    v118 = cast v104 as u128
+    v119 = unchecked_mul v117, v118
+    v120 = cast v0 as Field
+    v121 = cast v119 as Field
+    v122 = mul v120, v121
+    v123 = truncate v122 to 128 bits, max_bit_size: 254
+    v124 = cast v123 as u128
+    constrain v106 == u1 1, "attempt to bit-shift with overflow"
+    constrain v124 == u128 49380
+    v127 = lt v0, v1
+    constrain v127 == u1 1
+    v128 = lt v1, v0
+    constrain v128 == u1 0
+    constrain v0 != v1
+    return
+}
diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
index 013a76a423f..49b564c9728 100644
--- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
+++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
@@ -1033,10 +1033,16 @@ mod tests {
     use test_case::test_case;
 
     use crate::errors::RuntimeError;
+    use crate::ssa::opt::run_snapshots;
     use crate::ssa::{Ssa, ir::value::ValueId, opt::assert_normalized_ssa_equals};
 
     use super::{BoilerplateStats, Loops, is_new_size_ok};
 
+    #[test]
+    fn unrolling_snapshots() {
+        run_snapshots("unrolling", |ssa| ssa.unroll_loops_iteratively(None).unwrap());
+    }
+
     /// Tries to unroll all loops in each SSA function once, calling the `Function` directly,
     /// bypassing the iterative loop done by the SSA which does further optimisations.
     ///
diff --git a/test_programs/create_snapshots.sh b/test_programs/create_snapshots.sh
new file mode 100755
index 00000000000..5496b04f0e8
--- /dev/null
+++ b/test_programs/create_snapshots.sh
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+set -e
+
+
+SSA=$(nargo --program-dir $1 compile --show-ssa)
+
+tmp=$(mktemp -d -p .)
+trap "rm -rf $tmp" EXIT
+
+csplit -z --prefix=$tmp/ - "/fn main/" "{*}" <<<"$SSA" >> /dev/null
+
+OUT_DIR=../compiler/noirc_evaluator/src/ssa/opt/snapshots/$1
+mkdir -p $OUT_DIR
+
+NUM=0
+LAST="NONE"
+for file in $(ls $tmp); do
+    firstline=$(sed 's/://g;s/`//g;s/After //g;s/(1st)/1/g;s/(2nd)/2/g;s/(3rd)/3/g;s/(4th)/4/g;s/ /_/g;' <<<$(tail -1 $tmp/$file))
+    CURRENT=$(tr '[:upper:]' '[:lower:]' <<<$firstline)
+
+    sed '$d' $tmp/$file | sed -e :a -e '/^\n*$/{$d;N;};/\n$/ba'  > $OUT_DIR/$(printf '%02d' $NUM)_$CURRENT
+    LAST=$CURRENT
+    NUM=$(($NUM + 1))
+done
+
+