FileCheck gvn.

11 files changed, 1526 insertions, 1699 deletions

diff --git a/tests/mir-opt/gvn.aggregates.GVN.panic-abort.diff b/tests/mir-opt/gvn.aggregates.GVN.panic-abort.diff
deleted file mode 100644
index b1dae36ab6c..00000000000
--- a/tests/mir-opt/gvn.aggregates.GVN.panic-abort.diff
+++ /dev/null
@@ -1,133 +0,0 @@
-- // MIR for `aggregates` before GVN
-+ // MIR for `aggregates` after GVN
-  
-  fn aggregates() -> () {
-      let mut _0: ();
-      let _1: S<[u8; 0]>;
-      let mut _2: [u8; 0];
-      let mut _4: [u16; 0];
-      let mut _6: ();
-      let mut _8: ();
-      let mut _11: i32;
-      let mut _12: i32;
-      let mut _13: i32;
-      let mut _14: i32;
-      let mut _15: i32;
-      let mut _16: i32;
-      let mut _17: i32;
-      let mut _18: i32;
-      let mut _19: i32;
-      let mut _20: i32;
-      scope 1 {
-          debug a_array => _1;
-          let _3: S<[u16; 0]>;
-          scope 2 {
-              debug b_array => _3;
-              let _5: S<()>;
-              scope 3 {
-                  debug a_tuple => _5;
-                  let _7: S<()>;
-                  scope 4 {
-                      debug b_tuple => _7;
-                      let _9: i32;
-                      scope 5 {
-                          debug val => _9;
-                          let _10: [i32; 10];
-                          scope 6 {
-                              debug array => _10;
-                          }
-                      }
-                  }
-              }
-          }
-      }
-  
-      bb0: {
-          StorageLive(_1);
-          StorageLive(_2);
--         _2 = [];
--         _1 = S::<[u8; 0]>(move _2);
-+         _2 = const [];
-+         _1 = const S::<[u8; 0]>([]);
-          StorageDead(_2);
-          StorageLive(_3);
-          StorageLive(_4);
--         _4 = [];
--         _3 = S::<[u16; 0]>(move _4);
-+         _4 = const [];
-+         _3 = const S::<[u16; 0]>([]);
-          StorageDead(_4);
-          StorageLive(_5);
--         StorageLive(_6);
--         _6 = ();
--         _5 = S::<()>(move _6);
--         StorageDead(_6);
-+         nop;
-+         _6 = const ();
-+         _5 = const S::<()>(());
-+         nop;
-          StorageLive(_7);
-          StorageLive(_8);
--         _8 = ();
--         _7 = S::<()>(move _8);
-+         _8 = const ();
-+         _7 = const S::<()>(());
-          StorageDead(_8);
--         StorageLive(_9);
-+         nop;
-          _9 = const 5_i32;
-          StorageLive(_10);
-          StorageLive(_11);
--         _11 = _9;
-+         _11 = const 5_i32;
-          StorageLive(_12);
--         _12 = _9;
-+         _12 = const 5_i32;
-          StorageLive(_13);
--         _13 = _9;
-+         _13 = const 5_i32;
-          StorageLive(_14);
--         _14 = _9;
-+         _14 = const 5_i32;
-          StorageLive(_15);
--         _15 = _9;
-+         _15 = const 5_i32;
-          StorageLive(_16);
--         _16 = _9;
-+         _16 = const 5_i32;
-          StorageLive(_17);
--         _17 = _9;
-+         _17 = const 5_i32;
-          StorageLive(_18);
--         _18 = _9;
-+         _18 = const 5_i32;
-          StorageLive(_19);
--         _19 = _9;
-+         _19 = const 5_i32;
-          StorageLive(_20);
--         _20 = _9;
--         _10 = [move _11, move _12, move _13, move _14, move _15, move _16, move _17, move _18, move _19, move _20];
-+         _20 = const 5_i32;
-+         _10 = [const 5_i32; 10];
-          StorageDead(_20);
-          StorageDead(_19);
-          StorageDead(_18);
-          StorageDead(_17);
-          StorageDead(_16);
-          StorageDead(_15);
-          StorageDead(_14);
-          StorageDead(_13);
-          StorageDead(_12);
-          StorageDead(_11);
-          _0 = const ();
-          StorageDead(_10);
--         StorageDead(_9);
-+         nop;
-          StorageDead(_7);
-          StorageDead(_5);
-          StorageDead(_3);
-          StorageDead(_1);
-          return;
-      }
-  }
-  
diff --git a/tests/mir-opt/gvn.aggregates.GVN.panic-unwind.diff b/tests/mir-opt/gvn.aggregates.GVN.panic-unwind.diff
deleted file mode 100644
index b1dae36ab6c..00000000000
--- a/tests/mir-opt/gvn.aggregates.GVN.panic-unwind.diff
+++ /dev/null
@@ -1,133 +0,0 @@
-- // MIR for `aggregates` before GVN
-+ // MIR for `aggregates` after GVN
-  
-  fn aggregates() -> () {
-      let mut _0: ();
-      let _1: S<[u8; 0]>;
-      let mut _2: [u8; 0];
-      let mut _4: [u16; 0];
-      let mut _6: ();
-      let mut _8: ();
-      let mut _11: i32;
-      let mut _12: i32;
-      let mut _13: i32;
-      let mut _14: i32;
-      let mut _15: i32;
-      let mut _16: i32;
-      let mut _17: i32;
-      let mut _18: i32;
-      let mut _19: i32;
-      let mut _20: i32;
-      scope 1 {
-          debug a_array => _1;
-          let _3: S<[u16; 0]>;
-          scope 2 {
-              debug b_array => _3;
-              let _5: S<()>;
-              scope 3 {
-                  debug a_tuple => _5;
-                  let _7: S<()>;
-                  scope 4 {
-                      debug b_tuple => _7;
-                      let _9: i32;
-                      scope 5 {
-                          debug val => _9;
-                          let _10: [i32; 10];
-                          scope 6 {
-                              debug array => _10;
-                          }
-                      }
-                  }
-              }
-          }
-      }
-  
-      bb0: {
-          StorageLive(_1);
-          StorageLive(_2);
--         _2 = [];
--         _1 = S::<[u8; 0]>(move _2);
-+         _2 = const [];
-+         _1 = const S::<[u8; 0]>([]);
-          StorageDead(_2);
-          StorageLive(_3);
-          StorageLive(_4);
--         _4 = [];
--         _3 = S::<[u16; 0]>(move _4);
-+         _4 = const [];
-+         _3 = const S::<[u16; 0]>([]);
-          StorageDead(_4);
-          StorageLive(_5);
--         StorageLive(_6);
--         _6 = ();
--         _5 = S::<()>(move _6);
--         StorageDead(_6);
-+         nop;
-+         _6 = const ();
-+         _5 = const S::<()>(());
-+         nop;
-          StorageLive(_7);
-          StorageLive(_8);
--         _8 = ();
--         _7 = S::<()>(move _8);
-+         _8 = const ();
-+         _7 = const S::<()>(());
-          StorageDead(_8);
--         StorageLive(_9);
-+         nop;
-          _9 = const 5_i32;
-          StorageLive(_10);
-          StorageLive(_11);
--         _11 = _9;
-+         _11 = const 5_i32;
-          StorageLive(_12);
--         _12 = _9;
-+         _12 = const 5_i32;
-          StorageLive(_13);
--         _13 = _9;
-+         _13 = const 5_i32;
-          StorageLive(_14);
--         _14 = _9;
-+         _14 = const 5_i32;
-          StorageLive(_15);
--         _15 = _9;
-+         _15 = const 5_i32;
-          StorageLive(_16);
--         _16 = _9;
-+         _16 = const 5_i32;
-          StorageLive(_17);
--         _17 = _9;
-+         _17 = const 5_i32;
-          StorageLive(_18);
--         _18 = _9;
-+         _18 = const 5_i32;
-          StorageLive(_19);
--         _19 = _9;
-+         _19 = const 5_i32;
-          StorageLive(_20);
--         _20 = _9;
--         _10 = [move _11, move _12, move _13, move _14, move _15, move _16, move _17, move _18, move _19, move _20];
-+         _20 = const 5_i32;
-+         _10 = [const 5_i32; 10];
-          StorageDead(_20);
-          StorageDead(_19);
-          StorageDead(_18);
-          StorageDead(_17);
-          StorageDead(_16);
-          StorageDead(_15);
-          StorageDead(_14);
-          StorageDead(_13);
-          StorageDead(_12);
-          StorageDead(_11);
-          _0 = const ();
-          StorageDead(_10);
--         StorageDead(_9);
-+         nop;
-          StorageDead(_7);
-          StorageDead(_5);
-          StorageDead(_3);
-          StorageDead(_1);
-          return;
-      }
-  }
-  
diff --git a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff
index 3efe7abc976..6633df3ae70 100644
--- a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff
@@ -20,57 +20,6 @@
       let mut _15: u64;
       let mut _16: u64;
       let mut _17: (u64, bool);
-      let _18: ();
-      let mut _19: u64;
-      let mut _20: u64;
-      let mut _21: bool;
-      let _22: ();
-      let mut _23: u64;
-      let mut _24: u64;
-      let mut _25: bool;
-      let _26: ();
-      let mut _27: u64;
-      let mut _28: u64;
-      let mut _29: bool;
-      let _30: ();
-      let mut _31: u64;
-      let mut _32: u64;
-      let mut _33: bool;
-      let _34: ();
-      let mut _35: u64;
-      let mut _36: u64;
-      let mut _37: bool;
-      let _38: ();
-      let mut _39: u64;
-      let mut _40: u64;
-      let mut _41: bool;
-      let _42: ();
-      let mut _43: u64;
-      let mut _44: u64;
-      let mut _45: bool;
-      let _46: ();
-      let mut _47: u64;
-      let mut _48: u64;
-      let mut _49: bool;
-      let _50: ();
-      let mut _51: u64;
-      let mut _52: u64;
-      let _53: ();
-      let mut _54: u64;
-      let mut _55: u64;
-      let _56: ();
-      let mut _57: u64;
-      let mut _58: u64;
-      let _59: ();
-      let mut _60: u64;
-      let mut _61: u64;
-      let mut _62: u32;
-      let mut _63: bool;
-      let _64: ();
-      let mut _65: u64;
-      let mut _66: u64;
-      let mut _67: u32;
-      let mut _68: bool;
   
       bb0: {
           StorageLive(_2);
@@ -149,249 +98,6 @@
       bb8: {
           StorageDead(_15);
           StorageDead(_14);
-          StorageLive(_18);
-          StorageLive(_19);
-          StorageLive(_20);
-          _20 = _1;
--         _21 = Eq(const 0_u64, const 0_u64);
--         assert(!move _21, "attempt to divide `{}` by zero", _20) -> [success: bb9, unwind unreachable];
-+         _21 = const true;
-+         assert(!const true, "attempt to divide `{}` by zero", _1) -> [success: bb9, unwind unreachable];
-      }
-  
-      bb9: {
--         _19 = Div(move _20, const 0_u64);
-+         _19 = Div(_1, const 0_u64);
-          StorageDead(_20);
-          _18 = opaque::<u64>(move _19) -> [return: bb10, unwind unreachable];
-      }
-  
-      bb10: {
-          StorageDead(_19);
-          StorageDead(_18);
-          StorageLive(_22);
-          StorageLive(_23);
-          StorageLive(_24);
-          _24 = _1;
--         _25 = Eq(const 1_u64, const 0_u64);
--         assert(!move _25, "attempt to divide `{}` by zero", _24) -> [success: bb11, unwind unreachable];
-+         _25 = const false;
-+         assert(!const false, "attempt to divide `{}` by zero", _1) -> [success: bb11, unwind unreachable];
-      }
-  
-      bb11: {
--         _23 = Div(move _24, const 1_u64);
-+         _23 = Div(_1, const 1_u64);
-          StorageDead(_24);
-          _22 = opaque::<u64>(move _23) -> [return: bb12, unwind unreachable];
-      }
-  
-      bb12: {
-          StorageDead(_23);
-          StorageDead(_22);
-          StorageLive(_26);
-          StorageLive(_27);
-          StorageLive(_28);
-          _28 = _1;
--         _29 = Eq(_28, const 0_u64);
--         assert(!move _29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb13, unwind unreachable];
-+         _29 = Eq(_1, const 0_u64);
-+         assert(!_29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb13, unwind unreachable];
-      }
-  
-      bb13: {
--         _27 = Div(const 0_u64, move _28);
-+         _27 = Div(const 0_u64, _1);
-          StorageDead(_28);
-          _26 = opaque::<u64>(move _27) -> [return: bb14, unwind unreachable];
-      }
-  
-      bb14: {
-          StorageDead(_27);
-          StorageDead(_26);
-          StorageLive(_30);
-          StorageLive(_31);
-          StorageLive(_32);
-          _32 = _1;
--         _33 = Eq(_32, const 0_u64);
--         assert(!move _33, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb15, unwind unreachable];
-+         _33 = _29;
-+         assert(!_29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb15, unwind unreachable];
-      }
-  
-      bb15: {
--         _31 = Div(const 1_u64, move _32);
-+         _31 = Div(const 1_u64, _1);
-          StorageDead(_32);
-          _30 = opaque::<u64>(move _31) -> [return: bb16, unwind unreachable];
-      }
-  
-      bb16: {
-          StorageDead(_31);
-          StorageDead(_30);
-          StorageLive(_34);
-          StorageLive(_35);
-          StorageLive(_36);
-          _36 = _1;
--         _37 = Eq(const 0_u64, const 0_u64);
--         assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", _36) -> [success: bb17, unwind unreachable];
-+         _37 = const true;
-+         assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb17, unwind unreachable];
-      }
-  
-      bb17: {
--         _35 = Rem(move _36, const 0_u64);
-+         _35 = Rem(_1, const 0_u64);
-          StorageDead(_36);
-          _34 = opaque::<u64>(move _35) -> [return: bb18, unwind unreachable];
-      }
-  
-      bb18: {
-          StorageDead(_35);
-          StorageDead(_34);
-          StorageLive(_38);
-          StorageLive(_39);
-          StorageLive(_40);
-          _40 = _1;
--         _41 = Eq(const 1_u64, const 0_u64);
--         assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", _40) -> [success: bb19, unwind unreachable];
-+         _41 = const false;
-+         assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb19, unwind unreachable];
-      }
-  
-      bb19: {
--         _39 = Rem(move _40, const 1_u64);
-+         _39 = Rem(_1, const 1_u64);
-          StorageDead(_40);
-          _38 = opaque::<u64>(move _39) -> [return: bb20, unwind unreachable];
-      }
-  
-      bb20: {
-          StorageDead(_39);
-          StorageDead(_38);
-          StorageLive(_42);
-          StorageLive(_43);
-          StorageLive(_44);
-          _44 = _1;
--         _45 = Eq(_44, const 0_u64);
--         assert(!move _45, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb21, unwind unreachable];
-+         _45 = _29;
-+         assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb21, unwind unreachable];
-      }
-  
-      bb21: {
--         _43 = Rem(const 0_u64, move _44);
-+         _43 = Rem(const 0_u64, _1);
-          StorageDead(_44);
-          _42 = opaque::<u64>(move _43) -> [return: bb22, unwind unreachable];
-      }
-  
-      bb22: {
-          StorageDead(_43);
-          StorageDead(_42);
-          StorageLive(_46);
-          StorageLive(_47);
-          StorageLive(_48);
-          _48 = _1;
--         _49 = Eq(_48, const 0_u64);
--         assert(!move _49, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb23, unwind unreachable];
-+         _49 = _29;
-+         assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb23, unwind unreachable];
-      }
-  
-      bb23: {
--         _47 = Rem(const 1_u64, move _48);
-+         _47 = Rem(const 1_u64, _1);
-          StorageDead(_48);
-          _46 = opaque::<u64>(move _47) -> [return: bb24, unwind unreachable];
-      }
-  
-      bb24: {
-          StorageDead(_47);
-          StorageDead(_46);
-          StorageLive(_50);
-          StorageLive(_51);
-          StorageLive(_52);
-          _52 = _1;
--         _51 = BitAnd(move _52, const 0_u64);
-+         _51 = BitAnd(_1, const 0_u64);
-          StorageDead(_52);
-          _50 = opaque::<u64>(move _51) -> [return: bb25, unwind unreachable];
-      }
-  
-      bb25: {
-          StorageDead(_51);
-          StorageDead(_50);
-          StorageLive(_53);
-          StorageLive(_54);
-          StorageLive(_55);
-          _55 = _1;
--         _54 = BitOr(move _55, const 0_u64);
-+         _54 = BitOr(_1, const 0_u64);
-          StorageDead(_55);
-          _53 = opaque::<u64>(move _54) -> [return: bb26, unwind unreachable];
-      }
-  
-      bb26: {
-          StorageDead(_54);
-          StorageDead(_53);
-          StorageLive(_56);
-          StorageLive(_57);
-          StorageLive(_58);
-          _58 = _1;
--         _57 = BitXor(move _58, const 0_u64);
-+         _57 = BitXor(_1, const 0_u64);
-          StorageDead(_58);
-          _56 = opaque::<u64>(move _57) -> [return: bb27, unwind unreachable];
-      }
-  
-      bb27: {
-          StorageDead(_57);
-          StorageDead(_56);
-          StorageLive(_59);
-          StorageLive(_60);
-          StorageLive(_61);
-          _61 = _1;
--         _62 = const 0_i32 as u32 (IntToInt);
--         _63 = Lt(move _62, const 64_u32);
--         assert(move _63, "attempt to shift right by `{}`, which would overflow", const 0_i32) -> [success: bb28, unwind unreachable];
-+         _62 = const 0_u32;
-+         _63 = const true;
-+         assert(const true, "attempt to shift right by `{}`, which would overflow", const 0_i32) -> [success: bb28, unwind unreachable];
-      }
-  
-      bb28: {
--         _60 = Shr(move _61, const 0_i32);
-+         _60 = Shr(_1, const 0_i32);
-          StorageDead(_61);
-          _59 = opaque::<u64>(move _60) -> [return: bb29, unwind unreachable];
-      }
-  
-      bb29: {
-          StorageDead(_60);
-          StorageDead(_59);
-          StorageLive(_64);
-          StorageLive(_65);
-          StorageLive(_66);
-          _66 = _1;
--         _67 = const 0_i32 as u32 (IntToInt);
--         _68 = Lt(move _67, const 64_u32);
--         assert(move _68, "attempt to shift left by `{}`, which would overflow", const 0_i32) -> [success: bb30, unwind unreachable];
-+         _67 = const 0_u32;
-+         _68 = const true;
-+         assert(const true, "attempt to shift left by `{}`, which would overflow", const 0_i32) -> [success: bb30, unwind unreachable];
-      }
-  
-      bb30: {
--         _65 = Shl(move _66, const 0_i32);
-+         _65 = Shl(_1, const 0_i32);
-          StorageDead(_66);
-          _64 = opaque::<u64>(move _65) -> [return: bb31, unwind unreachable];
-      }
-  
-      bb31: {
-          StorageDead(_65);
-          StorageDead(_64);
           _0 = const ();
           return;
       }
diff --git a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff
index 9fbb8df79a1..d100a77fee5 100644
--- a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff
@@ -20,57 +20,6 @@
       let mut _15: u64;
       let mut _16: u64;
       let mut _17: (u64, bool);
-      let _18: ();
-      let mut _19: u64;
-      let mut _20: u64;
-      let mut _21: bool;
-      let _22: ();
-      let mut _23: u64;
-      let mut _24: u64;
-      let mut _25: bool;
-      let _26: ();
-      let mut _27: u64;
-      let mut _28: u64;
-      let mut _29: bool;
-      let _30: ();
-      let mut _31: u64;
-      let mut _32: u64;
-      let mut _33: bool;
-      let _34: ();
-      let mut _35: u64;
-      let mut _36: u64;
-      let mut _37: bool;
-      let _38: ();
-      let mut _39: u64;
-      let mut _40: u64;
-      let mut _41: bool;
-      let _42: ();
-      let mut _43: u64;
-      let mut _44: u64;
-      let mut _45: bool;
-      let _46: ();
-      let mut _47: u64;
-      let mut _48: u64;
-      let mut _49: bool;
-      let _50: ();
-      let mut _51: u64;
-      let mut _52: u64;
-      let _53: ();
-      let mut _54: u64;
-      let mut _55: u64;
-      let _56: ();
-      let mut _57: u64;
-      let mut _58: u64;
-      let _59: ();
-      let mut _60: u64;
-      let mut _61: u64;
-      let mut _62: u32;
-      let mut _63: bool;
-      let _64: ();
-      let mut _65: u64;
-      let mut _66: u64;
-      let mut _67: u32;
-      let mut _68: bool;
   
       bb0: {
           StorageLive(_2);
@@ -149,249 +98,6 @@
       bb8: {
           StorageDead(_15);
           StorageDead(_14);
-          StorageLive(_18);
-          StorageLive(_19);
-          StorageLive(_20);
-          _20 = _1;
--         _21 = Eq(const 0_u64, const 0_u64);
--         assert(!move _21, "attempt to divide `{}` by zero", _20) -> [success: bb9, unwind continue];
-+         _21 = const true;
-+         assert(!const true, "attempt to divide `{}` by zero", _1) -> [success: bb9, unwind continue];
-      }
-  
-      bb9: {
--         _19 = Div(move _20, const 0_u64);
-+         _19 = Div(_1, const 0_u64);
-          StorageDead(_20);
-          _18 = opaque::<u64>(move _19) -> [return: bb10, unwind continue];
-      }
-  
-      bb10: {
-          StorageDead(_19);
-          StorageDead(_18);
-          StorageLive(_22);
-          StorageLive(_23);
-          StorageLive(_24);
-          _24 = _1;
--         _25 = Eq(const 1_u64, const 0_u64);
--         assert(!move _25, "attempt to divide `{}` by zero", _24) -> [success: bb11, unwind continue];
-+         _25 = const false;
-+         assert(!const false, "attempt to divide `{}` by zero", _1) -> [success: bb11, unwind continue];
-      }
-  
-      bb11: {
--         _23 = Div(move _24, const 1_u64);
-+         _23 = Div(_1, const 1_u64);
-          StorageDead(_24);
-          _22 = opaque::<u64>(move _23) -> [return: bb12, unwind continue];
-      }
-  
-      bb12: {
-          StorageDead(_23);
-          StorageDead(_22);
-          StorageLive(_26);
-          StorageLive(_27);
-          StorageLive(_28);
-          _28 = _1;
--         _29 = Eq(_28, const 0_u64);
--         assert(!move _29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb13, unwind continue];
-+         _29 = Eq(_1, const 0_u64);
-+         assert(!_29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb13, unwind continue];
-      }
-  
-      bb13: {
--         _27 = Div(const 0_u64, move _28);
-+         _27 = Div(const 0_u64, _1);
-          StorageDead(_28);
-          _26 = opaque::<u64>(move _27) -> [return: bb14, unwind continue];
-      }
-  
-      bb14: {
-          StorageDead(_27);
-          StorageDead(_26);
-          StorageLive(_30);
-          StorageLive(_31);
-          StorageLive(_32);
-          _32 = _1;
--         _33 = Eq(_32, const 0_u64);
--         assert(!move _33, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb15, unwind continue];
-+         _33 = _29;
-+         assert(!_29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb15, unwind continue];
-      }
-  
-      bb15: {
--         _31 = Div(const 1_u64, move _32);
-+         _31 = Div(const 1_u64, _1);
-          StorageDead(_32);
-          _30 = opaque::<u64>(move _31) -> [return: bb16, unwind continue];
-      }
-  
-      bb16: {
-          StorageDead(_31);
-          StorageDead(_30);
-          StorageLive(_34);
-          StorageLive(_35);
-          StorageLive(_36);
-          _36 = _1;
--         _37 = Eq(const 0_u64, const 0_u64);
--         assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", _36) -> [success: bb17, unwind continue];
-+         _37 = const true;
-+         assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb17, unwind continue];
-      }
-  
-      bb17: {
--         _35 = Rem(move _36, const 0_u64);
-+         _35 = Rem(_1, const 0_u64);
-          StorageDead(_36);
-          _34 = opaque::<u64>(move _35) -> [return: bb18, unwind continue];
-      }
-  
-      bb18: {
-          StorageDead(_35);
-          StorageDead(_34);
-          StorageLive(_38);
-          StorageLive(_39);
-          StorageLive(_40);
-          _40 = _1;
--         _41 = Eq(const 1_u64, const 0_u64);
--         assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", _40) -> [success: bb19, unwind continue];
-+         _41 = const false;
-+         assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb19, unwind continue];
-      }
-  
-      bb19: {
--         _39 = Rem(move _40, const 1_u64);
-+         _39 = Rem(_1, const 1_u64);
-          StorageDead(_40);
-          _38 = opaque::<u64>(move _39) -> [return: bb20, unwind continue];
-      }
-  
-      bb20: {
-          StorageDead(_39);
-          StorageDead(_38);
-          StorageLive(_42);
-          StorageLive(_43);
-          StorageLive(_44);
-          _44 = _1;
--         _45 = Eq(_44, const 0_u64);
--         assert(!move _45, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb21, unwind continue];
-+         _45 = _29;
-+         assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb21, unwind continue];
-      }
-  
-      bb21: {
--         _43 = Rem(const 0_u64, move _44);
-+         _43 = Rem(const 0_u64, _1);
-          StorageDead(_44);
-          _42 = opaque::<u64>(move _43) -> [return: bb22, unwind continue];
-      }
-  
-      bb22: {
-          StorageDead(_43);
-          StorageDead(_42);
-          StorageLive(_46);
-          StorageLive(_47);
-          StorageLive(_48);
-          _48 = _1;
--         _49 = Eq(_48, const 0_u64);
--         assert(!move _49, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb23, unwind continue];
-+         _49 = _29;
-+         assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb23, unwind continue];
-      }
-  
-      bb23: {
--         _47 = Rem(const 1_u64, move _48);
-+         _47 = Rem(const 1_u64, _1);
-          StorageDead(_48);
-          _46 = opaque::<u64>(move _47) -> [return: bb24, unwind continue];
-      }
-  
-      bb24: {
-          StorageDead(_47);
-          StorageDead(_46);
-          StorageLive(_50);
-          StorageLive(_51);
-          StorageLive(_52);
-          _52 = _1;
--         _51 = BitAnd(move _52, const 0_u64);
-+         _51 = BitAnd(_1, const 0_u64);
-          StorageDead(_52);
-          _50 = opaque::<u64>(move _51) -> [return: bb25, unwind continue];
-      }
-  
-      bb25: {
-          StorageDead(_51);
-          StorageDead(_50);
-          StorageLive(_53);
-          StorageLive(_54);
-          StorageLive(_55);
-          _55 = _1;
--         _54 = BitOr(move _55, const 0_u64);
-+         _54 = BitOr(_1, const 0_u64);
-          StorageDead(_55);
-          _53 = opaque::<u64>(move _54) -> [return: bb26, unwind continue];
-      }
-  
-      bb26: {
-          StorageDead(_54);
-          StorageDead(_53);
-          StorageLive(_56);
-          StorageLive(_57);
-          StorageLive(_58);
-          _58 = _1;
--         _57 = BitXor(move _58, const 0_u64);
-+         _57 = BitXor(_1, const 0_u64);
-          StorageDead(_58);
-          _56 = opaque::<u64>(move _57) -> [return: bb27, unwind continue];
-      }
-  
-      bb27: {
-          StorageDead(_57);
-          StorageDead(_56);
-          StorageLive(_59);
-          StorageLive(_60);
-          StorageLive(_61);
-          _61 = _1;
--         _62 = const 0_i32 as u32 (IntToInt);
--         _63 = Lt(move _62, const 64_u32);
--         assert(move _63, "attempt to shift right by `{}`, which would overflow", const 0_i32) -> [success: bb28, unwind continue];
-+         _62 = const 0_u32;
-+         _63 = const true;
-+         assert(const true, "attempt to shift right by `{}`, which would overflow", const 0_i32) -> [success: bb28, unwind continue];
-      }
-  
-      bb28: {
--         _60 = Shr(move _61, const 0_i32);
-+         _60 = Shr(_1, const 0_i32);
-          StorageDead(_61);
-          _59 = opaque::<u64>(move _60) -> [return: bb29, unwind continue];
-      }
-  
-      bb29: {
-          StorageDead(_60);
-          StorageDead(_59);
-          StorageLive(_64);
-          StorageLive(_65);
-          StorageLive(_66);
-          _66 = _1;
--         _67 = const 0_i32 as u32 (IntToInt);
--         _68 = Lt(move _67, const 64_u32);
--         assert(move _68, "attempt to shift left by `{}`, which would overflow", const 0_i32) -> [success: bb30, unwind continue];
-+         _67 = const 0_u32;
-+         _68 = const true;
-+         assert(const true, "attempt to shift left by `{}`, which would overflow", const 0_i32) -> [success: bb30, unwind continue];
-      }
-  
-      bb30: {
--         _65 = Shl(move _66, const 0_i32);
-+         _65 = Shl(_1, const 0_i32);
-          StorageDead(_66);
-          _64 = opaque::<u64>(move _65) -> [return: bb31, unwind continue];
-      }
-  
-      bb31: {
-          StorageDead(_65);
-          StorageDead(_64);
           _0 = const ();
           return;
       }
diff --git a/tests/mir-opt/gvn.comparison.GVN.panic-abort.diff b/tests/mir-opt/gvn.comparison.GVN.panic-abort.diff
new file mode 100644
index 00000000000..ee3b9da2122
--- /dev/null
+++ b/tests/mir-opt/gvn.comparison.GVN.panic-abort.diff
@@ -0,0 +1,94 @@
+- // MIR for `comparison` before GVN
++ // MIR for `comparison` after GVN
+  
+  fn comparison(_1: u64, _2: u64) -> () {
+      debug x => _1;
+      debug y => _2;
+      let mut _0: ();
+      let _3: ();
+      let mut _4: bool;
+      let mut _5: u64;
+      let mut _6: u64;
+      let _7: ();
+      let mut _8: bool;
+      let mut _9: u64;
+      let mut _10: u64;
+      let _11: ();
+      let mut _12: bool;
+      let mut _13: u64;
+      let mut _14: u64;
+      let _15: ();
+      let mut _16: bool;
+      let mut _17: u64;
+      let mut _18: u64;
+  
+      bb0: {
+          StorageLive(_3);
+          StorageLive(_4);
+          StorageLive(_5);
+          _5 = _1;
+          StorageLive(_6);
+          _6 = _1;
+-         _4 = Eq(move _5, move _6);
++         _4 = Eq(_1, _1);
+          StorageDead(_6);
+          StorageDead(_5);
+          _3 = opaque::<bool>(move _4) -> [return: bb1, unwind unreachable];
+      }
+  
+      bb1: {
+          StorageDead(_4);
+          StorageDead(_3);
+          StorageLive(_7);
+          StorageLive(_8);
+          StorageLive(_9);
+          _9 = _1;
+          StorageLive(_10);
+          _10 = _1;
+-         _8 = Ne(move _9, move _10);
++         _8 = Ne(_1, _1);
+          StorageDead(_10);
+          StorageDead(_9);
+          _7 = opaque::<bool>(move _8) -> [return: bb2, unwind unreachable];
+      }
+  
+      bb2: {
+          StorageDead(_8);
+          StorageDead(_7);
+          StorageLive(_11);
+          StorageLive(_12);
+          StorageLive(_13);
+          _13 = _1;
+          StorageLive(_14);
+          _14 = _2;
+-         _12 = Eq(move _13, move _14);
++         _12 = Eq(_1, _2);
+          StorageDead(_14);
+          StorageDead(_13);
+          _11 = opaque::<bool>(move _12) -> [return: bb3, unwind unreachable];
+      }
+  
+      bb3: {
+          StorageDead(_12);
+          StorageDead(_11);
+          StorageLive(_15);
+          StorageLive(_16);
+          StorageLive(_17);
+          _17 = _1;
+          StorageLive(_18);
+          _18 = _2;
+-         _16 = Ne(move _17, move _18);
++         _16 = Ne(_1, _2);
+          StorageDead(_18);
+          StorageDead(_17);
+          _15 = opaque::<bool>(move _16) -> [return: bb4, unwind unreachable];
+      }
+  
+      bb4: {
+          StorageDead(_16);
+          StorageDead(_15);
+          _0 = const ();
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/gvn.comparison.GVN.panic-unwind.diff b/tests/mir-opt/gvn.comparison.GVN.panic-unwind.diff
new file mode 100644
index 00000000000..a1408fe3434
--- /dev/null
+++ b/tests/mir-opt/gvn.comparison.GVN.panic-unwind.diff
@@ -0,0 +1,94 @@
+- // MIR for `comparison` before GVN
++ // MIR for `comparison` after GVN
+  
+  fn comparison(_1: u64, _2: u64) -> () {
+      debug x => _1;
+      debug y => _2;
+      let mut _0: ();
+      let _3: ();
+      let mut _4: bool;
+      let mut _5: u64;
+      let mut _6: u64;
+      let _7: ();
+      let mut _8: bool;
+      let mut _9: u64;
+      let mut _10: u64;
+      let _11: ();
+      let mut _12: bool;
+      let mut _13: u64;
+      let mut _14: u64;
+      let _15: ();
+      let mut _16: bool;
+      let mut _17: u64;
+      let mut _18: u64;
+  
+      bb0: {
+          StorageLive(_3);
+          StorageLive(_4);
+          StorageLive(_5);
+          _5 = _1;
+          StorageLive(_6);
+          _6 = _1;
+-         _4 = Eq(move _5, move _6);
++         _4 = Eq(_1, _1);
+          StorageDead(_6);
+          StorageDead(_5);
+          _3 = opaque::<bool>(move _4) -> [return: bb1, unwind continue];
+      }
+  
+      bb1: {
+          StorageDead(_4);
+          StorageDead(_3);
+          StorageLive(_7);
+          StorageLive(_8);
+          StorageLive(_9);
+          _9 = _1;
+          StorageLive(_10);
+          _10 = _1;
+-         _8 = Ne(move _9, move _10);
++         _8 = Ne(_1, _1);
+          StorageDead(_10);
+          StorageDead(_9);
+          _7 = opaque::<bool>(move _8) -> [return: bb2, unwind continue];
+      }
+  
+      bb2: {
+          StorageDead(_8);
+          StorageDead(_7);
+          StorageLive(_11);
+          StorageLive(_12);
+          StorageLive(_13);
+          _13 = _1;
+          StorageLive(_14);
+          _14 = _2;
+-         _12 = Eq(move _13, move _14);
++         _12 = Eq(_1, _2);
+          StorageDead(_14);
+          StorageDead(_13);
+          _11 = opaque::<bool>(move _12) -> [return: bb3, unwind continue];
+      }
+  
+      bb3: {
+          StorageDead(_12);
+          StorageDead(_11);
+          StorageLive(_15);
+          StorageLive(_16);
+          StorageLive(_17);
+          _17 = _1;
+          StorageLive(_18);
+          _18 = _2;
+-         _16 = Ne(move _17, move _18);
++         _16 = Ne(_1, _2);
+          StorageDead(_18);
+          StorageDead(_17);
+          _15 = opaque::<bool>(move _16) -> [return: bb4, unwind continue];
+      }
+  
+      bb4: {
+          StorageDead(_16);
+          StorageDead(_15);
+          _0 = const ();
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/gvn.repeat.GVN.panic-abort.diff b/tests/mir-opt/gvn.repeat.GVN.panic-abort.diff
new file mode 100644
index 00000000000..37915f8578d
--- /dev/null
+++ b/tests/mir-opt/gvn.repeat.GVN.panic-abort.diff
@@ -0,0 +1,79 @@
+- // MIR for `repeat` before GVN
++ // MIR for `repeat` after GVN
+  
+  fn repeat() -> () {
+      let mut _0: ();
+      let _1: i32;
+      let mut _3: i32;
+      let mut _4: i32;
+      let mut _5: i32;
+      let mut _6: i32;
+      let mut _7: i32;
+      let mut _8: i32;
+      let mut _9: i32;
+      let mut _10: i32;
+      let mut _11: i32;
+      let mut _12: i32;
+      scope 1 {
+          debug val => _1;
+          let _2: [i32; 10];
+          scope 2 {
+              debug array => _2;
+          }
+      }
+  
+      bb0: {
+-         StorageLive(_1);
++         nop;
+          _1 = const 5_i32;
+          StorageLive(_2);
+          StorageLive(_3);
+-         _3 = _1;
++         _3 = const 5_i32;
+          StorageLive(_4);
+-         _4 = _1;
++         _4 = const 5_i32;
+          StorageLive(_5);
+-         _5 = _1;
++         _5 = const 5_i32;
+          StorageLive(_6);
+-         _6 = _1;
++         _6 = const 5_i32;
+          StorageLive(_7);
+-         _7 = _1;
++         _7 = const 5_i32;
+          StorageLive(_8);
+-         _8 = _1;
++         _8 = const 5_i32;
+          StorageLive(_9);
+-         _9 = _1;
++         _9 = const 5_i32;
+          StorageLive(_10);
+-         _10 = _1;
++         _10 = const 5_i32;
+          StorageLive(_11);
+-         _11 = _1;
++         _11 = const 5_i32;
+          StorageLive(_12);
+-         _12 = _1;
+-         _2 = [move _3, move _4, move _5, move _6, move _7, move _8, move _9, move _10, move _11, move _12];
++         _12 = const 5_i32;
++         _2 = [const 5_i32; 10];
+          StorageDead(_12);
+          StorageDead(_11);
+          StorageDead(_10);
+          StorageDead(_9);
+          StorageDead(_8);
+          StorageDead(_7);
+          StorageDead(_6);
+          StorageDead(_5);
+          StorageDead(_4);
+          StorageDead(_3);
+          _0 = const ();
+          StorageDead(_2);
+-         StorageDead(_1);
++         nop;
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/gvn.repeat.GVN.panic-unwind.diff b/tests/mir-opt/gvn.repeat.GVN.panic-unwind.diff
new file mode 100644
index 00000000000..37915f8578d
--- /dev/null
+++ b/tests/mir-opt/gvn.repeat.GVN.panic-unwind.diff
@@ -0,0 +1,79 @@
+- // MIR for `repeat` before GVN
++ // MIR for `repeat` after GVN
+  
+  fn repeat() -> () {
+      let mut _0: ();
+      let _1: i32;
+      let mut _3: i32;
+      let mut _4: i32;
+      let mut _5: i32;
+      let mut _6: i32;
+      let mut _7: i32;
+      let mut _8: i32;
+      let mut _9: i32;
+      let mut _10: i32;
+      let mut _11: i32;
+      let mut _12: i32;
+      scope 1 {
+          debug val => _1;
+          let _2: [i32; 10];
+          scope 2 {
+              debug array => _2;
+          }
+      }
+  
+      bb0: {
+-         StorageLive(_1);
++         nop;
+          _1 = const 5_i32;
+          StorageLive(_2);
+          StorageLive(_3);
+-         _3 = _1;
++         _3 = const 5_i32;
+          StorageLive(_4);
+-         _4 = _1;
++         _4 = const 5_i32;
+          StorageLive(_5);
+-         _5 = _1;
++         _5 = const 5_i32;
+          StorageLive(_6);
+-         _6 = _1;
++         _6 = const 5_i32;
+          StorageLive(_7);
+-         _7 = _1;
++         _7 = const 5_i32;
+          StorageLive(_8);
+-         _8 = _1;
++         _8 = const 5_i32;
+          StorageLive(_9);
+-         _9 = _1;
++         _9 = const 5_i32;
+          StorageLive(_10);
+-         _10 = _1;
++         _10 = const 5_i32;
+          StorageLive(_11);
+-         _11 = _1;
++         _11 = const 5_i32;
+          StorageLive(_12);
+-         _12 = _1;
+-         _2 = [move _3, move _4, move _5, move _6, move _7, move _8, move _9, move _10, move _11, move _12];
++         _12 = const 5_i32;
++         _2 = [const 5_i32; 10];
+          StorageDead(_12);
+          StorageDead(_11);
+          StorageDead(_10);
+          StorageDead(_9);
+          StorageDead(_8);
+          StorageDead(_7);
+          StorageDead(_6);
+          StorageDead(_5);
+          StorageDead(_4);
+          StorageDead(_3);
+          _0 = const ();
+          StorageDead(_2);
+-         StorageDead(_1);
++         nop;
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/gvn.rs b/tests/mir-opt/gvn.rs
index 55de186edf1..1c14f818044 100644
--- a/tests/mir-opt/gvn.rs
+++ b/tests/mir-opt/gvn.rs
@@ -1,4 +1,3 @@
-// skip-filecheck
 // unit-test: GVN
 // EMIT_MIR_FOR_EACH_PANIC_STRATEGY
 // only-64bit
@@ -15,48 +14,120 @@ use std::mem::transmute;
 struct S<T>(T);
 
 fn subexpression_elimination(x: u64, y: u64, mut z: u64) {
+    // CHECK-LABEL: fn subexpression_elimination(
+
+    // CHECK: [[add:_.*]] = Add(_1, _2);
+    // CHECK: opaque::<u64>([[add]])
     opaque(x + y);
+    // CHECK: [[mul:_.*]] = Mul(_1, _2);
+    // CHECK: opaque::<u64>([[mul]])
     opaque(x * y);
+    // CHECK: [[sub:_.*]] = Sub(_1, _2);
+    // CHECK: opaque::<u64>([[sub]])
     opaque(x - y);
+    // CHECK: [[div:_.*]] = Div(_1, _2);
+    // CHECK: opaque::<u64>([[div]])
     opaque(x / y);
+    // CHECK: [[rem:_.*]] = Rem(_1, _2);
+    // CHECK: opaque::<u64>([[rem]])
     opaque(x % y);
+    // CHECK: [[and:_.*]] = BitAnd(_1, _2);
+    // CHECK: opaque::<u64>([[and]])
     opaque(x & y);
+    // CHECK: [[or:_.*]] = BitOr(_1, _2);
+    // CHECK: opaque::<u64>([[or]])
     opaque(x | y);
+    // CHECK: [[xor:_.*]] = BitXor(_1, _2);
+    // CHECK: opaque::<u64>([[xor]])
     opaque(x ^ y);
+    // CHECK: [[shl:_.*]] = Shl(_1, _2);
+    // CHECK: opaque::<u64>([[shl]])
     opaque(x << y);
+    // CHECK: [[shr:_.*]] = Shr(_1, _2);
+    // CHECK: opaque::<u64>([[shr]])
     opaque(x >> y);
+    // CHECK: [[int:_.*]] = _1 as u32 (IntToInt);
+    // CHECK: opaque::<u32>([[int]])
     opaque(x as u32);
+    // CHECK: [[float:_.*]] = _1 as f32 (IntToFloat);
+    // CHECK: opaque::<f32>([[float]])
     opaque(x as f32);
+    // CHECK: [[wrap:_.*]] = S::<u64>(_1);
+    // CHECK: opaque::<S<u64>>([[wrap]])
     opaque(S(x));
+    // CHECK: opaque::<u64>(_1)
     opaque(S(x).0);
 
     // Those are duplicates to substitute somehow.
-    opaque((x + y) + z);
-    opaque((x * y) + z);
-    opaque((x - y) + z);
-    opaque((x / y) + z);
-    opaque((x % y) + z);
-    opaque((x & y) + z);
-    opaque((x | y) + z);
-    opaque((x ^ y) + z);
-    opaque((x << y) + z);
-    opaque((x >> y) + z);
+    // CHECK: opaque::<u64>([[add]])
+    opaque(x + y);
+    // CHECK: opaque::<u64>([[mul]])
+    opaque(x * y);
+    // CHECK: opaque::<u64>([[sub]])
+    opaque(x - y);
+    // CHECK: opaque::<u64>([[div]])
+    opaque(x / y);
+    // CHECK: opaque::<u64>([[rem]])
+    opaque(x % y);
+    // CHECK: opaque::<u64>([[and]])
+    opaque(x & y);
+    // CHECK: opaque::<u64>([[or]])
+    opaque(x | y);
+    // CHECK: opaque::<u64>([[xor]])
+    opaque(x ^ y);
+    // CHECK: opaque::<u64>([[shl]])
+    opaque(x << y);
+    // CHECK: opaque::<u64>([[shr]])
+    opaque(x >> y);
+    // CHECK: opaque::<u32>([[int]])
+    opaque(x as u32);
+    // CHECK: opaque::<f32>([[float]])
+    opaque(x as f32);
+    // CHECK: opaque::<S<u64>>([[wrap]])
     opaque(S(x));
+    // CHECK: opaque::<u64>(_1)
     opaque(S(x).0);
 
+    // We can substitute through a complex expression.
+    // CHECK: [[compound:_.*]] = Sub([[mul]], _2);
+    // CHECK: opaque::<u64>([[compound]])
+    // CHECK: opaque::<u64>([[compound]])
+    opaque((x * y) - y);
+    opaque((x * y) - y);
+
     // We can substitute through an immutable reference too.
+    // CHECK: [[ref:_.*]] = &_3;
+    // CHECK: [[deref:_.*]] = (*[[ref]]);
+    // CHECK: [[addref:_.*]] = Add([[deref]], _1);
+    // CHECK: opaque::<u64>([[addref]])
+    // CHECK: opaque::<u64>([[addref]])
     let a = &z;
     opaque(*a + x);
     opaque(*a + x);
 
     // But not through a mutable reference or a pointer.
+    // CHECK: [[mut:_.*]] = &mut _3;
+    // CHECK: [[addmut:_.*]] = Add(
+    // CHECK: opaque::<u64>(move [[addmut]])
+    // CHECK: [[addmut2:_.*]] = Add(
+    // CHECK: opaque::<u64>(move [[addmut2]])
     let b = &mut z;
     opaque(*b + x);
     opaque(*b + x);
     unsafe {
+        // CHECK: [[raw:_.*]] = &raw const _3;
+        // CHECK: [[addraw:_.*]] = Add(
+        // CHECK: opaque::<u64>(move [[addraw]])
+        // CHECK: [[addraw2:_.*]] = Add(
+        // CHECK: opaque::<u64>(move [[addraw2]])
         let c = &raw const z;
         opaque(*c + x);
         opaque(*c + x);
+        // CHECK: [[ptr:_.*]] = &raw mut _3;
+        // CHECK: [[addptr:_.*]] = Add(
+        // CHECK: opaque::<u64>(move [[addptr]])
+        // CHECK: [[addptr2:_.*]] = Add(
+        // CHECK: opaque::<u64>(move [[addptr2]])
         let d = &raw mut z;
         opaque(*d + x);
         opaque(*d + x);
@@ -64,12 +135,21 @@ fn subexpression_elimination(x: u64, y: u64, mut z: u64) {
 
     // We can substitute again, but not with the earlier computations.
     // Important: `e` is not `a`!
+    // CHECK: [[ref2:_.*]] = &_3;
+    // CHECK: [[deref2:_.*]] = (*[[ref2]]);
+    // CHECK: [[addref2:_.*]] = Add([[deref2]], _1);
+    // CHECK: opaque::<u64>([[addref2]])
+    // CHECK: opaque::<u64>([[addref2]])
     let e = &z;
     opaque(*e + x);
     opaque(*e + x);
 }
 
 fn wrap_unwrap<T: Copy>(x: T) -> T {
+    // CHECK-LABEL: fn wrap_unwrap(
+    // CHECK: [[some:_.*]] = Option::<T>::Some(_1);
+    // CHECK: switchInt(const 1_isize)
+    // CHECK: _0 = _1;
     match Some(x) {
         Some(y) => y,
         None => panic!(),
@@ -77,155 +157,354 @@ fn wrap_unwrap<T: Copy>(x: T) -> T {
 }
 
 fn repeated_index<T: Copy, const N: usize>(x: T, idx: usize) {
+    // CHECK-LABEL: fn repeated_index(
+    // CHECK: [[a:_.*]] = [_1; N];
     let a = [x; N];
+    // CHECK: opaque::<T>(_1)
     opaque(a[0]);
+    // CHECK: opaque::<T>(_1)
     opaque(a[idx]);
 }
 
+/// Verify symbolic integer arithmetic simplifications.
 fn arithmetic(x: u64) {
+    // CHECK-LABEL: fn arithmetic(
+    // CHECK: [[add:_.*]] = Add(_1, const 0_u64);
+    // CHECK: opaque::<u64>(move [[add]])
     opaque(x + 0);
+    // CHECK: [[sub:_.*]] = Sub(_1, const 0_u64);
+    // CHECK: opaque::<u64>(move [[sub]])
     opaque(x - 0);
+    // CHECK: [[mul0:_.*]] = Mul(_1, const 0_u64);
+    // CHECK: opaque::<u64>(move [[mul0]])
     opaque(x * 0);
+    // CHECK: [[mul1:_.*]] = Mul(_1, const 1_u64);
+    // CHECK: opaque::<u64>(move [[mul1]])
     opaque(x * 1);
+    // CHECK: [[div0:_.*]] = Div(_1, const 0_u64);
+    // CHECK: opaque::<u64>(move [[div0]])
     opaque(x / 0);
+    // CHECK: [[div1:_.*]] = Div(_1, const 1_u64);
+    // CHECK: opaque::<u64>(move [[div1]])
     opaque(x / 1);
+    // CHECK: [[zdiv:_.*]] = Div(const 0_u64, _1);
+    // CHECK: opaque::<u64>(move [[zdiv]])
     opaque(0 / x);
+    // CHECK: [[odiv:_.*]] = Div(const 1_u64, _1);
+    // CHECK: opaque::<u64>(move [[odiv]])
     opaque(1 / x);
+    // CHECK: [[rem0:_.*]] = Rem(_1, const 0_u64);
+    // CHECK: opaque::<u64>(move [[rem0]])
     opaque(x % 0);
+    // CHECK: [[rem1:_.*]] = Rem(_1, const 1_u64);
+    // CHECK: opaque::<u64>(move [[rem1]])
     opaque(x % 1);
+    // CHECK: [[zrem:_.*]] = Rem(const 0_u64, _1);
+    // CHECK: opaque::<u64>(move [[zrem]])
     opaque(0 % x);
+    // CHECK: [[orem:_.*]] = Rem(const 1_u64, _1);
+    // CHECK: opaque::<u64>(move [[orem]])
     opaque(1 % x);
+    // CHECK: [[and:_.*]] = BitAnd(_1, const 0_u64);
+    // CHECK: opaque::<u64>(move [[and]])
     opaque(x & 0);
+    // CHECK: [[or:_.*]] = BitOr(_1, const 0_u64);
+    // CHECK: opaque::<u64>(move [[or]])
     opaque(x | 0);
+    // CHECK: [[xor:_.*]] = BitXor(_1, const 0_u64);
+    // CHECK: opaque::<u64>(move [[xor]])
     opaque(x ^ 0);
+    // CHECK: [[shr:_.*]] = Shr(_1, const 0_i32);
+    // CHECK: opaque::<u64>(move [[shr]])
     opaque(x >> 0);
+    // CHECK: [[shl:_.*]] = Shl(_1, const 0_i32);
+    // CHECK: opaque::<u64>(move [[shl]])
     opaque(x << 0);
 }
 
+fn comparison(x: u64, y: u64) {
+    // CHECK-LABEL: fn comparison(
+    // CHECK: [[eqxx:_.*]] = Eq(_1, _1);
+    // CHECK: opaque::<bool>(move [[eqxx]])
+    opaque(x == x);
+    // CHECK: [[nexx:_.*]] = Ne(_1, _1);
+    // CHECK: opaque::<bool>(move [[nexx]])
+    opaque(x != x);
+    // CHECK: [[eqxy:_.*]] = Eq(_1, _2);
+    // CHECK: opaque::<bool>(move [[eqxy]])
+    opaque(x == y);
+    // CHECK: [[nexy:_.*]] = Ne(_1, _2);
+    // CHECK: opaque::<bool>(move [[nexy]])
+    opaque(x != y);
+}
+
+/// Verify symbolic integer arithmetic simplifications on checked ops.
 #[rustc_inherit_overflow_checks]
 fn arithmetic_checked(x: u64) {
+    // CHECK-LABEL: fn arithmetic_checked(
+    // CHECK: [[cadd:_.*]] = CheckedAdd(_1, const 0_u64);
+    // CHECK: [[add:_.*]] = move ([[cadd]].0: u64);
+    // CHECK: opaque::<u64>(move [[add]])
     opaque(x + 0);
+    // CHECK: [[csub:_.*]] = CheckedSub(_1, const 0_u64);
+    // CHECK: [[sub:_.*]] = move ([[csub]].0: u64);
+    // CHECK: opaque::<u64>(move [[sub]])
     opaque(x - 0);
+    // CHECK: [[cmul0:_.*]] = CheckedMul(_1, const 0_u64);
+    // CHECK: [[mul0:_.*]] = move ([[cmul0]].0: u64);
+    // CHECK: opaque::<u64>(move [[mul0]])
     opaque(x * 0);
+    // CHECK: [[cmul1:_.*]] = CheckedMul(_1, const 1_u64);
+    // CHECK: [[mul1:_.*]] = move ([[cmul1]].0: u64);
+    // CHECK: opaque::<u64>(move [[mul1]])
     opaque(x * 1);
-    opaque(x / 0);
-    opaque(x / 1);
-    opaque(0 / x);
-    opaque(1 / x);
-    opaque(x % 0);
-    opaque(x % 1);
-    opaque(0 % x);
-    opaque(1 % x);
-    opaque(x & 0);
-    opaque(x | 0);
-    opaque(x ^ 0);
-    opaque(x >> 0);
-    opaque(x << 0);
 }
 
+/// Verify that we do not apply arithmetic simplifications on floats.
 fn arithmetic_float(x: f64) {
+    // CHECK-LABEL: fn arithmetic_float(
+    // CHECK: [[add:_.*]] = Add(_1, const 0f64);
+    // CHECK: opaque::<f64>(move [[add]])
     opaque(x + 0.);
+    // CHECK: [[sub:_.*]] = Sub(_1, const 0f64);
+    // CHECK: opaque::<f64>(move [[sub]])
     opaque(x - 0.);
+    // CHECK: [[mul:_.*]] = Mul(_1, const 0f64);
+    // CHECK: opaque::<f64>(move [[mul]])
     opaque(x * 0.);
+    // CHECK: [[div0:_.*]] = Div(_1, const 0f64);
+    // CHECK: opaque::<f64>(move [[div0]])
     opaque(x / 0.);
+    // CHECK: [[zdiv:_.*]] = Div(const 0f64, _1);
+    // CHECK: opaque::<f64>(move [[zdiv]])
     opaque(0. / x);
+    // CHECK: [[rem0:_.*]] = Rem(_1, const 0f64);
+    // CHECK: opaque::<f64>(move [[rem0]])
     opaque(x % 0.);
+    // CHECK: [[zrem:_.*]] = Rem(const 0f64, _1);
+    // CHECK: opaque::<f64>(move [[zrem]])
     opaque(0. % x);
     // Those are not simplifiable to `true`/`false`, thanks to NaNs.
+    // CHECK: [[eq:_.*]] = Eq(_1, _1);
+    // CHECK: opaque::<bool>(move [[eq]])
     opaque(x == x);
+    // CHECK: [[ne:_.*]] = Ne(_1, _1);
+    // CHECK: opaque::<bool>(move [[ne]])
     opaque(x != x);
 }
 
 fn cast() {
+    // CHECK-LABEL: fn cast(
     let i = 1_i64;
     let u = 1_u64;
     let f = 1_f64;
+    // CHECK: opaque::<u8>(const 1_u8)
     opaque(i as u8);
+    // CHECK: opaque::<u16>(const 1_u16)
     opaque(i as u16);
+    // CHECK: opaque::<u32>(const 1_u32)
     opaque(i as u32);
+    // CHECK: opaque::<u64>(const 1_u64)
     opaque(i as u64);
+    // CHECK: opaque::<i8>(const 1_i8)
     opaque(i as i8);
+    // CHECK: opaque::<i16>(const 1_i16)
     opaque(i as i16);
+    // CHECK: opaque::<i32>(const 1_i32)
     opaque(i as i32);
+    // CHECK: opaque::<i64>(const 1_i64)
     opaque(i as i64);
+    // CHECK: opaque::<f32>(const 1f32)
     opaque(i as f32);
+    // CHECK: opaque::<f64>(const 1f64)
     opaque(i as f64);
+    // CHECK: opaque::<u8>(const 1_u8)
     opaque(u as u8);
+    // CHECK: opaque::<u16>(const 1_u16)
     opaque(u as u16);
+    // CHECK: opaque::<u32>(const 1_u32)
     opaque(u as u32);
+    // CHECK: opaque::<u64>(const 1_u64)
     opaque(u as u64);
+    // CHECK: opaque::<i8>(const 1_i8)
     opaque(u as i8);
+    // CHECK: opaque::<i16>(const 1_i16)
     opaque(u as i16);
+    // CHECK: opaque::<i32>(const 1_i32)
     opaque(u as i32);
+    // CHECK: opaque::<i64>(const 1_i64)
     opaque(u as i64);
+    // CHECK: opaque::<f32>(const 1f32)
     opaque(u as f32);
+    // CHECK: opaque::<f64>(const 1f64)
     opaque(u as f64);
+    // CHECK: opaque::<u8>(const 1_u8)
     opaque(f as u8);
+    // CHECK: opaque::<u16>(const 1_u16)
     opaque(f as u16);
+    // CHECK: opaque::<u32>(const 1_u32)
     opaque(f as u32);
+    // CHECK: opaque::<u64>(const 1_u64)
     opaque(f as u64);
+    // CHECK: opaque::<i8>(const 1_i8)
     opaque(f as i8);
+    // CHECK: opaque::<i16>(const 1_i16)
     opaque(f as i16);
+    // CHECK: opaque::<i32>(const 1_i32)
     opaque(f as i32);
+    // CHECK: opaque::<i64>(const 1_i64)
     opaque(f as i64);
+    // CHECK: opaque::<f32>(const 1f32)
     opaque(f as f32);
+    // CHECK: opaque::<f64>(const 1f64)
     opaque(f as f64);
 }
 
 fn multiple_branches(t: bool, x: u8, y: u8) {
+    // CHECK-LABEL: fn multiple_branches(
+    // CHECK: switchInt(_1) -> [0: [[bbf:bb.*]], otherwise: [[bbt:bb.*]]];
     if t {
-        opaque(x + y); // a
-        opaque(x + y); // should reuse a
+        // CHECK: [[bbt]]: {
+        // CHECK: [[a:_.*]] = Add(_2, _3);
+        // CHECK: opaque::<u8>([[a]])
+        // CHECK: opaque::<u8>([[a]])
+        // CHECK: goto -> [[bbc:bb.*]];
+        opaque(x + y);
+        opaque(x + y);
     } else {
-        opaque(x + y); // b
-        opaque(x + y); // shoud reuse b
+        // CHECK: [[bbf]]: {
+        // CHECK: [[b:_.*]] = Add(_2, _3);
+        // CHECK: opaque::<u8>([[b]])
+        // CHECK: opaque::<u8>([[b]])
+        // CHECK: goto -> [[bbc:bb.*]];
+        opaque(x + y);
+        opaque(x + y);
     }
-    opaque(x + y); // c
+    // Neither `a` nor `b` dominate `c`, so we cannot reuse any of them.
+    // CHECK: [[bbc]]: {
+    // CHECK: [[c:_.*]] = Add(_2, _3);
+    // CHECK: opaque::<u8>([[c]])
+    opaque(x + y);
+
+    // `c` dominates both calls, so we can reuse it.
     if t {
-        opaque(x + y); // should reuse c
+        // CHECK: opaque::<u8>([[c]])
+        opaque(x + y);
     } else {
-        opaque(x + y); // should reuse c
+        // CHECK: opaque::<u8>([[c]])
+        opaque(x + y);
     }
 }
 
+/// Verify that we do not reuse a `&raw? mut?` rvalue.
 fn references(mut x: impl Sized) {
+    // CHECK-LABEL: fn references(
+    // CHECK: [[ref1:_.*]] = &_1;
+    // CHECK: opaque::<&impl Sized>(move [[ref1]])
     opaque(&x);
-    opaque(&x); // should not reuse a
+    // CHECK: [[ref2:_.*]] = &_1;
+    // CHECK: opaque::<&impl Sized>(move [[ref2]])
+    opaque(&x);
+    // CHECK: [[ref3:_.*]] = &mut _1;
+    // CHECK: opaque::<&mut impl Sized>(move [[ref3]])
+    opaque(&mut x);
+    // CHECK: [[ref4:_.*]] = &mut _1;
+    // CHECK: opaque::<&mut impl Sized>(move [[ref4]])
     opaque(&mut x);
-    opaque(&mut x); // should not reuse a
+    // CHECK: [[ref5:_.*]] = &raw const _1;
+    // CHECK: opaque::<*const impl Sized>(move [[ref5]])
+    opaque(&raw const x);
+    // CHECK: [[ref6:_.*]] = &raw const _1;
+    // CHECK: opaque::<*const impl Sized>(move [[ref6]])
     opaque(&raw const x);
-    opaque(&raw const x); // should not reuse a
+    // CHECK: [[ref7:_.*]] = &raw mut _1;
+    // CHECK: opaque::<*mut impl Sized>(move [[ref7]])
+    opaque(&raw mut x);
+    // CHECK: [[ref8:_.*]] = &raw mut _1;
+    // CHECK: opaque::<*mut impl Sized>(move [[ref8]])
     opaque(&raw mut x);
-    opaque(&raw mut x); // should not reuse a
 
     let r = &mut x;
-    let s = S(r).0; // Obfuscate `r`.
-    opaque(&*s); // This is `&*r`.
-    opaque(&mut *s); // This is `&*r`.
-    opaque(&raw const *s); // This is `&*r`.
-    opaque(&raw mut *s); // This is `&*r`.
+    let s = S(r).0; // Obfuscate `r`. Following lines should still reborrow `r`.
+    // CHECK: [[ref9:_.*]] = &mut _1;
+    // CHECK: [[ref10:_.*]] = &(*[[ref9]]);
+    // CHECK: opaque::<&impl Sized>(move [[ref10]])
+    opaque(&*s);
+    // CHECK: [[ref11:_.*]] = &mut (*[[ref9]]);
+    // CHECK: opaque::<&mut impl Sized>(move [[ref11]])
+    opaque(&mut *s);
+    // CHECK: [[ref12:_.*]] = &raw const (*[[ref9]]);
+    // CHECK: opaque::<*const impl Sized>(move [[ref12]])
+    opaque(&raw const *s);
+    // CHECK: [[ref12:_.*]] = &raw mut (*[[ref9]]);
+    // CHECK: opaque::<*mut impl Sized>(move [[ref12]])
+    opaque(&raw mut *s);
 }
 
 fn dereferences(t: &mut u32, u: &impl Copy, s: &S<u32>) {
+    // CHECK-LABEL: fn dereferences(
+
+    // Do not reuse dereferences of `&mut`.
+    // CHECK: [[st1:_.*]] = (*_1);
+    // CHECK: opaque::<u32>(move [[st1]])
+    // CHECK: [[st2:_.*]] = (*_1);
+    // CHECK: opaque::<u32>(move [[st2]])
+    opaque(*t);
     opaque(*t);
-    opaque(*t); // this cannot reuse a, as x is &mut.
+
+    // Do not reuse dereferences of `*const`.
+    // CHECK: [[raw:_.*]] = &raw const (*_1);
+    // CHECK: [[st3:_.*]] = (*[[raw]]);
+    // CHECK: opaque::<u32>(move [[st3]])
+    // CHECK: [[st4:_.*]] = (*[[raw]]);
+    // CHECK: opaque::<u32>(move [[st4]])
     let z = &raw const *t;
     unsafe { opaque(*z) };
-    unsafe { opaque(*z) }; // this cannot reuse a, as x is *const.
+    unsafe { opaque(*z) };
+
+    // Do not reuse dereferences of `*mut`.
+    // CHECK: [[ptr:_.*]] = &raw mut (*_1);
+    // CHECK: [[st5:_.*]] = (*[[ptr]]);
+    // CHECK: opaque::<u32>(move [[st5]])
+    // CHECK: [[st6:_.*]] = (*[[ptr]]);
+    // CHECK: opaque::<u32>(move [[st6]])
     let z = &raw mut *t;
     unsafe { opaque(*z) };
-    unsafe { opaque(*z) }; // this cannot reuse a, as x is *mut.
+    unsafe { opaque(*z) };
+
+    // We can reuse dereferences of `&Freeze`.
+    // CHECK: [[ref:_.*]] = &(*_1);
+    // CHECK: [[st7:_.*]] = (*[[ref]]);
+    // CHECK: opaque::<u32>([[st7]])
+    // CHECK: opaque::<u32>([[st7]])
     let z = &*t;
     opaque(*z);
-    opaque(*z); // this can reuse, as `z` is immutable ref, Freeze and Copy.
-    opaque(&*z); // but not for a reborrow.
+    opaque(*z);
+    // But not in reborrows.
+    // CHECK: [[reborrow:_.*]] = &(*[[ref]]);
+    // CHECK: opaque::<&u32>(move [[reborrow]])
+    opaque(&*z);
+
+    // `*u` is not Freeze, so we cannot reuse.
+    // CHECK: [[st8:_.*]] = (*_2);
+    // CHECK: opaque::<impl Copy>(move [[st8]])
+    // CHECK: [[st9:_.*]] = (*_2);
+    // CHECK: opaque::<impl Copy>(move [[st9]])
+    opaque(*u);
     opaque(*u);
-    opaque(*u); // this cannot reuse, as `z` is not Freeze.
+
+    // `*s` is not Copy, by `(*s).0` is, so we can reuse.
+    // CHECK: [[st10:_.*]] = ((*_3).0: u32);
+    // CHECK: opaque::<u32>([[st10]])
+    // CHECK: opaque::<u32>([[st10]])
+    opaque(s.0);
     opaque(s.0);
-    opaque(s.0); // *s is not Copy, by (*s).0 is, so we can reuse.
 }
 
 fn slices() {
+    // CHECK-LABEL: fn slices(
+    // CHECK: {{_.*}} = const "
+    // CHECK-NOT: {{_.*}} = const "
     let s = "my favourite slice"; // This is a `Const::Slice` in MIR.
     opaque(s);
     let t = s; // This should be the same pointer, so cannot be a `Const::Slice`.
@@ -238,6 +517,7 @@ fn slices() {
 
 #[custom_mir(dialect = "analysis")]
 fn duplicate_slice() -> (bool, bool) {
+    // CHECK-LABEL: fn duplicate_slice(
     mir!(
         let au: u128;
         let bu: u128;
@@ -246,41 +526,50 @@ fn duplicate_slice() -> (bool, bool) {
         let c: &str;
         let d: &str;
         {
+            // CHECK: [[a:_.*]] = (const "a",);
+            // CHECK: [[au:_.*]] = ([[a]].0: &str) as u128 (Transmute);
             let a = ("a",);
             Call(au = transmute::<_, u128>(a.0), bb1)
         }
         bb1 = {
+            // CHECK: [[c:_.*]] = identity::<&str>(([[a]].0: &str))
             Call(c = identity(a.0), bb2)
         }
         bb2 = {
+            // CHECK: [[cu:_.*]] = [[c]] as u128 (Transmute);
             Call(cu = transmute::<_, u128>(c), bb3)
         }
         bb3 = {
-            let b = "a"; // This slice is different from `a.0`.
-            Call(bu = transmute::<_, u128>(b), bb4) // Hence `bu` is not `au`.
+            // This slice is different from `a.0`. Hence `bu` is not `au`.
+            // CHECK: [[b:_.*]] = const "a";
+            // CHECK: [[bu:_.*]] = [[b]] as u128 (Transmute);
+            let b = "a";
+            Call(bu = transmute::<_, u128>(b), bb4)
         }
         bb4 = {
-            Call(d = identity(b), bb5) // This returns a copy of `b`, which is not `a`.
+            // This returns a copy of `b`, which is not `a`.
+            // CHECK: [[d:_.*]] = identity::<&str>([[b]])
+            Call(d = identity(b), bb5)
         }
         bb5 = {
+            // CHECK: [[du:_.*]] = [[d]] as u128 (Transmute);
             Call(du = transmute::<_, u128>(d), bb6)
         }
         bb6 = {
-            let direct = au == bu; // Must not fold to `true`...
-            let indirect = cu == du; // ...as this will not.
+            // `direct` must not fold to `true`, as `indirect` will not.
+            // CHECK: = Eq([[au]], [[bu]]);
+            // CHECK: = Eq([[cu]], [[du]]);
+            let direct = au == bu;
+            let indirect = cu == du;
             RET = (direct, indirect);
             Return()
         }
     )
 }
 
-fn aggregates() {
-    let a_array: S<[u8; 0]> = S([]);
-    let b_array: S<[u16; 0]> = S([]); // This must not be merged with `a_array`.
-
-    let a_tuple: S<()> = S(());
-    let b_tuple: S<()> = S(()); // But this can be with `a_tuple`.
-
+fn repeat() {
+    // CHECK-LABEL: fn repeat(
+    // CHECK: = [const 5_i32; 10];
     let val = 5;
     let array = [val, val, val, val, val, val, val, val, val, val];
 }
@@ -290,6 +579,7 @@ fn main() {
     wrap_unwrap(5);
     repeated_index::<u32, 7>(5, 3);
     arithmetic(5);
+    comparison(5, 6);
     arithmetic_checked(5);
     arithmetic_float(5.);
     cast();
@@ -299,7 +589,7 @@ fn main() {
     slices();
     let (direct, indirect) = duplicate_slice();
     assert_eq!(direct, indirect);
-    aggregates();
+    repeat();
 }
 
 #[inline(never)]
@@ -314,6 +604,7 @@ fn identity<T>(x: T) -> T {
 // EMIT_MIR gvn.wrap_unwrap.GVN.diff
 // EMIT_MIR gvn.repeated_index.GVN.diff
 // EMIT_MIR gvn.arithmetic.GVN.diff
+// EMIT_MIR gvn.comparison.GVN.diff
 // EMIT_MIR gvn.arithmetic_checked.GVN.diff
 // EMIT_MIR gvn.arithmetic_float.GVN.diff
 // EMIT_MIR gvn.cast.GVN.diff
@@ -322,4 +613,4 @@ fn identity<T>(x: T) -> T {
 // EMIT_MIR gvn.dereferences.GVN.diff
 // EMIT_MIR gvn.slices.GVN.diff
 // EMIT_MIR gvn.duplicate_slice.GVN.diff
-// EMIT_MIR gvn.aggregates.GVN.diff
+// EMIT_MIR gvn.repeat.GVN.diff
diff --git a/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-abort.diff b/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-abort.diff
index 23ba2559448..0a747d3aef0 100644
--- a/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-abort.diff
@@ -65,11 +65,11 @@
       let mut _60: u64;
       let mut _61: u64;
       let mut _62: u64;
-      let mut _63: u64;
+      let _63: ();
       let mut _64: u64;
-      let _65: ();
+      let mut _65: u64;
       let mut _66: u64;
-      let mut _67: u64;
+      let _67: ();
       let mut _68: u64;
       let mut _69: u64;
       let mut _70: u64;
@@ -77,25 +77,25 @@
       let mut _72: u64;
       let mut _73: u64;
       let mut _74: u64;
-      let mut _75: u64;
-      let mut _76: u64;
-      let _77: ();
+      let mut _75: bool;
+      let _76: ();
+      let mut _77: u64;
       let mut _78: u64;
       let mut _79: u64;
-      let mut _80: u64;
-      let mut _81: u64;
-      let mut _82: bool;
+      let mut _80: bool;
+      let _81: ();
+      let mut _82: u64;
       let mut _83: u64;
-      let _84: ();
-      let mut _85: u64;
+      let mut _84: u64;
+      let _85: ();
       let mut _86: u64;
       let mut _87: u64;
       let mut _88: u64;
-      let mut _89: bool;
+      let _89: ();
       let mut _90: u64;
-      let _91: ();
+      let mut _91: u64;
       let mut _92: u64;
-      let mut _93: u64;
+      let _93: ();
       let mut _94: u64;
       let mut _95: u64;
       let mut _96: u64;
@@ -103,93 +103,91 @@
       let mut _98: u64;
       let mut _99: u64;
       let mut _100: u64;
-      let mut _101: u64;
-      let mut _102: u64;
-      let _103: ();
-      let mut _104: u64;
-      let mut _105: u64;
+      let _101: ();
+      let mut _102: u32;
+      let mut _103: u64;
+      let _104: ();
+      let mut _105: f32;
       let mut _106: u64;
-      let mut _107: u64;
-      let mut _108: u64;
-      let _109: ();
-      let mut _110: u64;
+      let _107: ();
+      let mut _108: S<u64>;
+      let mut _109: u64;
+      let _110: ();
       let mut _111: u64;
-      let mut _112: u64;
+      let mut _112: S<u64>;
       let mut _113: u64;
-      let mut _114: u64;
-      let _115: ();
+      let _114: ();
+      let mut _115: u64;
       let mut _116: u64;
       let mut _117: u64;
       let mut _118: u64;
       let mut _119: u64;
-      let mut _120: u64;
-      let _121: ();
-      let mut _122: S<u64>;
+      let _120: ();
+      let mut _121: u64;
+      let mut _122: u64;
       let mut _123: u64;
-      let _124: ();
+      let mut _124: u64;
       let mut _125: u64;
-      let mut _126: S<u64>;
-      let mut _127: u64;
-      let _128: &u64;
-      let _129: ();
+      let _126: &u64;
+      let _127: ();
+      let mut _128: u64;
+      let mut _129: u64;
       let mut _130: u64;
-      let mut _131: u64;
+      let _131: ();
       let mut _132: u64;
-      let _133: ();
+      let mut _133: u64;
       let mut _134: u64;
-      let mut _135: u64;
-      let mut _136: u64;
-      let _138: ();
+      let _136: ();
+      let mut _137: u64;
+      let mut _138: u64;
       let mut _139: u64;
-      let mut _140: u64;
+      let _140: ();
       let mut _141: u64;
-      let _142: ();
+      let mut _142: u64;
       let mut _143: u64;
-      let mut _144: u64;
-      let mut _145: u64;
+      let _144: ();
       let _146: ();
-      let _148: ();
+      let mut _147: u64;
+      let mut _148: u64;
       let mut _149: u64;
-      let mut _150: u64;
+      let _150: ();
       let mut _151: u64;
-      let _152: ();
+      let mut _152: u64;
       let mut _153: u64;
-      let mut _154: u64;
-      let mut _155: u64;
-      let _157: ();
+      let _155: ();
+      let mut _156: u64;
+      let mut _157: u64;
       let mut _158: u64;
-      let mut _159: u64;
+      let _159: ();
       let mut _160: u64;
-      let _161: ();
+      let mut _161: u64;
       let mut _162: u64;
-      let mut _163: u64;
-      let mut _164: u64;
-      let _166: ();
+      let _164: ();
+      let mut _165: u64;
+      let mut _166: u64;
       let mut _167: u64;
-      let mut _168: u64;
+      let _168: ();
       let mut _169: u64;
-      let _170: ();
+      let mut _170: u64;
       let mut _171: u64;
-      let mut _172: u64;
-      let mut _173: u64;
       scope 1 {
-          debug a => _128;
-          let _137: &mut u64;
+          debug a => _126;
+          let _135: &mut u64;
           scope 2 {
-              debug b => _137;
-              let _165: &u64;
+              debug b => _135;
+              let _163: &u64;
               scope 3 {
-                  let _147: *const u64;
+                  let _145: *const u64;
                   scope 4 {
-                      debug c => _147;
-                      let _156: *mut u64;
+                      debug c => _145;
+                      let _154: *mut u64;
                       scope 5 {
-                          debug d => _156;
+                          debug d => _154;
                       }
                   }
               }
               scope 6 {
-                  debug e => _165;
+                  debug e => _163;
               }
           }
       }
@@ -400,30 +398,36 @@
 +         nop;
           StorageDead(_42);
           StorageLive(_46);
-          StorageLive(_47);
+-         StorageLive(_47);
++         nop;
           StorageLive(_48);
           _48 = _1;
 -         _47 = move _48 as u32 (IntToInt);
 +         _47 = _1 as u32 (IntToInt);
           StorageDead(_48);
-          _46 = opaque::<u32>(move _47) -> [return: bb13, unwind unreachable];
+-         _46 = opaque::<u32>(move _47) -> [return: bb13, unwind unreachable];
++         _46 = opaque::<u32>(_47) -> [return: bb13, unwind unreachable];
       }
   
       bb13: {
-          StorageDead(_47);
+-         StorageDead(_47);
++         nop;
           StorageDead(_46);
           StorageLive(_49);
-          StorageLive(_50);
+-         StorageLive(_50);
++         nop;
           StorageLive(_51);
           _51 = _1;
 -         _50 = move _51 as f32 (IntToFloat);
 +         _50 = _1 as f32 (IntToFloat);
           StorageDead(_51);
-          _49 = opaque::<f32>(move _50) -> [return: bb14, unwind unreachable];
+-         _49 = opaque::<f32>(move _50) -> [return: bb14, unwind unreachable];
++         _49 = opaque::<f32>(_50) -> [return: bb14, unwind unreachable];
       }
   
       bb14: {
-          StorageDead(_50);
+-         StorageDead(_50);
++         nop;
           StorageDead(_49);
           StorageLive(_52);
 -         StorageLive(_53);
@@ -462,479 +466,497 @@
           StorageLive(_59);
           StorageLive(_60);
           StorageLive(_61);
+          _61 = _1;
           StorageLive(_62);
-          _62 = _1;
-          StorageLive(_63);
-          _63 = _2;
--         _61 = Add(move _62, move _63);
-+         _61 = _5;
-          StorageDead(_63);
+          _62 = _2;
+-         _60 = Add(move _61, move _62);
++         _60 = _5;
           StorageDead(_62);
-          StorageLive(_64);
-          _64 = _3;
--         _60 = Add(move _61, move _64);
-+         _60 = Add(_5, move _64);
-          StorageDead(_64);
           StorageDead(_61);
-          _59 = opaque::<u64>(move _60) -> [return: bb17, unwind unreachable];
+-         _59 = opaque::<u64>(move _60) -> [return: bb17, unwind unreachable];
++         _59 = opaque::<u64>(_5) -> [return: bb17, unwind unreachable];
       }
   
       bb17: {
           StorageDead(_60);
           StorageDead(_59);
+          StorageLive(_63);
+          StorageLive(_64);
           StorageLive(_65);
+          _65 = _1;
           StorageLive(_66);
+          _66 = _2;
+-         _64 = Mul(move _65, move _66);
++         _64 = _9;
+          StorageDead(_66);
+          StorageDead(_65);
+-         _63 = opaque::<u64>(move _64) -> [return: bb18, unwind unreachable];
++         _63 = opaque::<u64>(_9) -> [return: bb18, unwind unreachable];
+      }
+  
+      bb18: {
+          StorageDead(_64);
+          StorageDead(_63);
           StorageLive(_67);
           StorageLive(_68);
-          _68 = _1;
           StorageLive(_69);
-          _69 = _2;
--         _67 = Mul(move _68, move _69);
-+         _67 = _9;
-          StorageDead(_69);
-          StorageDead(_68);
+          _69 = _1;
           StorageLive(_70);
-          _70 = _3;
--         _66 = Add(move _67, move _70);
-+         _66 = Add(_9, move _70);
+          _70 = _2;
+-         _68 = Sub(move _69, move _70);
++         _68 = _13;
           StorageDead(_70);
-          StorageDead(_67);
-          _65 = opaque::<u64>(move _66) -> [return: bb18, unwind unreachable];
+          StorageDead(_69);
+-         _67 = opaque::<u64>(move _68) -> [return: bb19, unwind unreachable];
++         _67 = opaque::<u64>(_13) -> [return: bb19, unwind unreachable];
       }
   
-      bb18: {
-          StorageDead(_66);
-          StorageDead(_65);
+      bb19: {
+          StorageDead(_68);
+          StorageDead(_67);
           StorageLive(_71);
           StorageLive(_72);
           StorageLive(_73);
+          _73 = _1;
           StorageLive(_74);
-          _74 = _1;
-          StorageLive(_75);
-          _75 = _2;
--         _73 = Sub(move _74, move _75);
-+         _73 = _13;
-          StorageDead(_75);
+          _74 = _2;
+-         _75 = Eq(_74, const 0_u64);
+-         assert(!move _75, "attempt to divide `{}` by zero", _73) -> [success: bb20, unwind unreachable];
++         _75 = _20;
++         assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb20, unwind unreachable];
+      }
+  
+      bb20: {
+-         _72 = Div(move _73, move _74);
++         _72 = _17;
           StorageDead(_74);
-          StorageLive(_76);
-          _76 = _3;
--         _72 = Add(move _73, move _76);
-+         _72 = Add(_13, move _76);
-          StorageDead(_76);
           StorageDead(_73);
-          _71 = opaque::<u64>(move _72) -> [return: bb19, unwind unreachable];
+-         _71 = opaque::<u64>(move _72) -> [return: bb21, unwind unreachable];
++         _71 = opaque::<u64>(_17) -> [return: bb21, unwind unreachable];
       }
   
-      bb19: {
+      bb21: {
           StorageDead(_72);
           StorageDead(_71);
+          StorageLive(_76);
           StorageLive(_77);
           StorageLive(_78);
+          _78 = _1;
           StorageLive(_79);
-          StorageLive(_80);
-          _80 = _1;
-          StorageLive(_81);
-          _81 = _2;
--         _82 = Eq(_81, const 0_u64);
--         assert(!move _82, "attempt to divide `{}` by zero", _80) -> [success: bb20, unwind unreachable];
-+         _82 = _20;
-+         assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb20, unwind unreachable];
+          _79 = _2;
+-         _80 = Eq(_79, const 0_u64);
+-         assert(!move _80, "attempt to calculate the remainder of `{}` with a divisor of zero", _78) -> [success: bb22, unwind unreachable];
++         _80 = _20;
++         assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb22, unwind unreachable];
       }
   
-      bb20: {
--         _79 = Div(move _80, move _81);
-+         _79 = _17;
-          StorageDead(_81);
-          StorageDead(_80);
-          StorageLive(_83);
-          _83 = _3;
--         _78 = Add(move _79, move _83);
-+         _78 = Add(_17, move _83);
-          StorageDead(_83);
+      bb22: {
+-         _77 = Rem(move _78, move _79);
++         _77 = _22;
           StorageDead(_79);
-          _77 = opaque::<u64>(move _78) -> [return: bb21, unwind unreachable];
+          StorageDead(_78);
+-         _76 = opaque::<u64>(move _77) -> [return: bb23, unwind unreachable];
++         _76 = opaque::<u64>(_22) -> [return: bb23, unwind unreachable];
       }
   
-      bb21: {
-          StorageDead(_78);
+      bb23: {
           StorageDead(_77);
+          StorageDead(_76);
+          StorageLive(_81);
+          StorageLive(_82);
+          StorageLive(_83);
+          _83 = _1;
           StorageLive(_84);
+          _84 = _2;
+-         _82 = BitAnd(move _83, move _84);
++         _82 = _27;
+          StorageDead(_84);
+          StorageDead(_83);
+-         _81 = opaque::<u64>(move _82) -> [return: bb24, unwind unreachable];
++         _81 = opaque::<u64>(_27) -> [return: bb24, unwind unreachable];
+      }
+  
+      bb24: {
+          StorageDead(_82);
+          StorageDead(_81);
           StorageLive(_85);
           StorageLive(_86);
           StorageLive(_87);
           _87 = _1;
           StorageLive(_88);
           _88 = _2;
--         _89 = Eq(_88, const 0_u64);
--         assert(!move _89, "attempt to calculate the remainder of `{}` with a divisor of zero", _87) -> [success: bb22, unwind unreachable];
-+         _89 = _20;
-+         assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb22, unwind unreachable];
-      }
-  
-      bb22: {
--         _86 = Rem(move _87, move _88);
-+         _86 = _22;
+-         _86 = BitOr(move _87, move _88);
++         _86 = _31;
           StorageDead(_88);
           StorageDead(_87);
-          StorageLive(_90);
-          _90 = _3;
--         _85 = Add(move _86, move _90);
-+         _85 = Add(_22, move _90);
-          StorageDead(_90);
-          StorageDead(_86);
-          _84 = opaque::<u64>(move _85) -> [return: bb23, unwind unreachable];
+-         _85 = opaque::<u64>(move _86) -> [return: bb25, unwind unreachable];
++         _85 = opaque::<u64>(_31) -> [return: bb25, unwind unreachable];
       }
   
-      bb23: {
+      bb25: {
+          StorageDead(_86);
           StorageDead(_85);
-          StorageDead(_84);
+          StorageLive(_89);
+          StorageLive(_90);
           StorageLive(_91);
+          _91 = _1;
           StorageLive(_92);
+          _92 = _2;
+-         _90 = BitXor(move _91, move _92);
++         _90 = _35;
+          StorageDead(_92);
+          StorageDead(_91);
+-         _89 = opaque::<u64>(move _90) -> [return: bb26, unwind unreachable];
++         _89 = opaque::<u64>(_35) -> [return: bb26, unwind unreachable];
+      }
+  
+      bb26: {
+          StorageDead(_90);
+          StorageDead(_89);
           StorageLive(_93);
           StorageLive(_94);
-          _94 = _1;
           StorageLive(_95);
-          _95 = _2;
--         _93 = BitAnd(move _94, move _95);
-+         _93 = _27;
-          StorageDead(_95);
-          StorageDead(_94);
+          _95 = _1;
           StorageLive(_96);
-          _96 = _3;
--         _92 = Add(move _93, move _96);
-+         _92 = Add(_27, move _96);
+          _96 = _2;
+-         _94 = Shl(move _95, move _96);
++         _94 = _39;
           StorageDead(_96);
-          StorageDead(_93);
-          _91 = opaque::<u64>(move _92) -> [return: bb24, unwind unreachable];
+          StorageDead(_95);
+-         _93 = opaque::<u64>(move _94) -> [return: bb27, unwind unreachable];
++         _93 = opaque::<u64>(_39) -> [return: bb27, unwind unreachable];
       }
   
-      bb24: {
-          StorageDead(_92);
-          StorageDead(_91);
+      bb27: {
+          StorageDead(_94);
+          StorageDead(_93);
           StorageLive(_97);
           StorageLive(_98);
           StorageLive(_99);
+          _99 = _1;
           StorageLive(_100);
-          _100 = _1;
-          StorageLive(_101);
-          _101 = _2;
--         _99 = BitOr(move _100, move _101);
-+         _99 = _31;
-          StorageDead(_101);
+          _100 = _2;
+-         _98 = Shr(move _99, move _100);
++         _98 = _43;
           StorageDead(_100);
-          StorageLive(_102);
-          _102 = _3;
--         _98 = Add(move _99, move _102);
-+         _98 = Add(_31, move _102);
-          StorageDead(_102);
           StorageDead(_99);
-          _97 = opaque::<u64>(move _98) -> [return: bb25, unwind unreachable];
+-         _97 = opaque::<u64>(move _98) -> [return: bb28, unwind unreachable];
++         _97 = opaque::<u64>(_43) -> [return: bb28, unwind unreachable];
       }
   
-      bb25: {
+      bb28: {
           StorageDead(_98);
           StorageDead(_97);
+          StorageLive(_101);
+          StorageLive(_102);
           StorageLive(_103);
+          _103 = _1;
+-         _102 = move _103 as u32 (IntToInt);
++         _102 = _47;
+          StorageDead(_103);
+-         _101 = opaque::<u32>(move _102) -> [return: bb29, unwind unreachable];
++         _101 = opaque::<u32>(_47) -> [return: bb29, unwind unreachable];
+      }
+  
+      bb29: {
+          StorageDead(_102);
+          StorageDead(_101);
           StorageLive(_104);
           StorageLive(_105);
           StorageLive(_106);
           _106 = _1;
-          StorageLive(_107);
-          _107 = _2;
--         _105 = BitXor(move _106, move _107);
-+         _105 = _35;
-          StorageDead(_107);
+-         _105 = move _106 as f32 (IntToFloat);
++         _105 = _50;
           StorageDead(_106);
-          StorageLive(_108);
-          _108 = _3;
--         _104 = Add(move _105, move _108);
-+         _104 = Add(_35, move _108);
-          StorageDead(_108);
-          StorageDead(_105);
-          _103 = opaque::<u64>(move _104) -> [return: bb26, unwind unreachable];
+-         _104 = opaque::<f32>(move _105) -> [return: bb30, unwind unreachable];
++         _104 = opaque::<f32>(_50) -> [return: bb30, unwind unreachable];
       }
   
-      bb26: {
+      bb30: {
+          StorageDead(_105);
           StorageDead(_104);
-          StorageDead(_103);
+          StorageLive(_107);
+          StorageLive(_108);
           StorageLive(_109);
+          _109 = _1;
+-         _108 = S::<u64>(move _109);
++         _108 = _53;
+          StorageDead(_109);
+-         _107 = opaque::<S<u64>>(move _108) -> [return: bb31, unwind unreachable];
++         _107 = opaque::<S<u64>>(_53) -> [return: bb31, unwind unreachable];
+      }
+  
+      bb31: {
+          StorageDead(_108);
+          StorageDead(_107);
           StorageLive(_110);
           StorageLive(_111);
           StorageLive(_112);
-          _112 = _1;
           StorageLive(_113);
-          _113 = _2;
--         _111 = Shl(move _112, move _113);
-+         _111 = _39;
+          _113 = _1;
+-         _112 = S::<u64>(move _113);
++         _112 = _53;
           StorageDead(_113);
-          StorageDead(_112);
-          StorageLive(_114);
-          _114 = _3;
--         _110 = Add(move _111, move _114);
-+         _110 = Add(_39, move _114);
-          StorageDead(_114);
-          StorageDead(_111);
-          _109 = opaque::<u64>(move _110) -> [return: bb27, unwind unreachable];
+-         _111 = (_112.0: u64);
+-         _110 = opaque::<u64>(move _111) -> [return: bb32, unwind unreachable];
++         _111 = _1;
++         _110 = opaque::<u64>(_1) -> [return: bb32, unwind unreachable];
       }
   
-      bb27: {
+      bb32: {
+          StorageDead(_111);
+          StorageDead(_112);
           StorageDead(_110);
-          StorageDead(_109);
-          StorageLive(_115);
+          StorageLive(_114);
+-         StorageLive(_115);
++         nop;
           StorageLive(_116);
           StorageLive(_117);
+          _117 = _1;
           StorageLive(_118);
-          _118 = _1;
+          _118 = _2;
+-         _116 = Mul(move _117, move _118);
++         _116 = _9;
+          StorageDead(_118);
+          StorageDead(_117);
           StorageLive(_119);
           _119 = _2;
--         _117 = Shr(move _118, move _119);
-+         _117 = _43;
+-         _115 = Sub(move _116, move _119);
++         _115 = Sub(_9, _2);
           StorageDead(_119);
-          StorageDead(_118);
-          StorageLive(_120);
-          _120 = _3;
--         _116 = Add(move _117, move _120);
-+         _116 = Add(_43, move _120);
-          StorageDead(_120);
-          StorageDead(_117);
-          _115 = opaque::<u64>(move _116) -> [return: bb28, unwind unreachable];
+          StorageDead(_116);
+-         _114 = opaque::<u64>(move _115) -> [return: bb33, unwind unreachable];
++         _114 = opaque::<u64>(_115) -> [return: bb33, unwind unreachable];
       }
   
-      bb28: {
-          StorageDead(_116);
-          StorageDead(_115);
+      bb33: {
+-         StorageDead(_115);
++         nop;
+          StorageDead(_114);
+          StorageLive(_120);
           StorageLive(_121);
           StorageLive(_122);
           StorageLive(_123);
           _123 = _1;
--         _122 = S::<u64>(move _123);
-+         _122 = _53;
+          StorageLive(_124);
+          _124 = _2;
+-         _122 = Mul(move _123, move _124);
++         _122 = _9;
+          StorageDead(_124);
           StorageDead(_123);
--         _121 = opaque::<S<u64>>(move _122) -> [return: bb29, unwind unreachable];
-+         _121 = opaque::<S<u64>>(_53) -> [return: bb29, unwind unreachable];
+          StorageLive(_125);
+          _125 = _2;
+-         _121 = Sub(move _122, move _125);
++         _121 = _115;
+          StorageDead(_125);
+          StorageDead(_122);
+-         _120 = opaque::<u64>(move _121) -> [return: bb34, unwind unreachable];
++         _120 = opaque::<u64>(_115) -> [return: bb34, unwind unreachable];
       }
   
-      bb29: {
-          StorageDead(_122);
+      bb34: {
           StorageDead(_121);
-          StorageLive(_124);
-          StorageLive(_125);
-          StorageLive(_126);
+          StorageDead(_120);
+-         StorageLive(_126);
++         nop;
+          _126 = &_3;
           StorageLive(_127);
-          _127 = _1;
--         _126 = S::<u64>(move _127);
-+         _126 = _53;
-          StorageDead(_127);
--         _125 = (_126.0: u64);
--         _124 = opaque::<u64>(move _125) -> [return: bb30, unwind unreachable];
-+         _125 = _1;
-+         _124 = opaque::<u64>(_1) -> [return: bb30, unwind unreachable];
-      }
-  
-      bb30: {
-          StorageDead(_125);
-          StorageDead(_126);
-          StorageDead(_124);
 -         StorageLive(_128);
+-         StorageLive(_129);
 +         nop;
-          _128 = &_3;
-          StorageLive(_129);
--         StorageLive(_130);
--         StorageLive(_131);
 +         nop;
+          _129 = (*_126);
+          StorageLive(_130);
+          _130 = _1;
+-         _128 = Add(move _129, move _130);
++         _128 = Add(_129, _1);
+          StorageDead(_130);
+-         StorageDead(_129);
+-         _127 = opaque::<u64>(move _128) -> [return: bb35, unwind unreachable];
 +         nop;
-          _131 = (*_128);
-          StorageLive(_132);
-          _132 = _1;
--         _130 = Add(move _131, move _132);
-+         _130 = Add(_131, _1);
-          StorageDead(_132);
--         StorageDead(_131);
--         _129 = opaque::<u64>(move _130) -> [return: bb31, unwind unreachable];
-+         nop;
-+         _129 = opaque::<u64>(_130) -> [return: bb31, unwind unreachable];
++         _127 = opaque::<u64>(_128) -> [return: bb35, unwind unreachable];
       }
   
-      bb31: {
--         StorageDead(_130);
+      bb35: {
+-         StorageDead(_128);
 +         nop;
-          StorageDead(_129);
+          StorageDead(_127);
+          StorageLive(_131);
+          StorageLive(_132);
           StorageLive(_133);
+-         _133 = (*_126);
++         _133 = _129;
           StorageLive(_134);
-          StorageLive(_135);
--         _135 = (*_128);
-+         _135 = _131;
-          StorageLive(_136);
-          _136 = _1;
--         _134 = Add(move _135, move _136);
-+         _134 = _130;
-          StorageDead(_136);
-          StorageDead(_135);
--         _133 = opaque::<u64>(move _134) -> [return: bb32, unwind unreachable];
-+         _133 = opaque::<u64>(_130) -> [return: bb32, unwind unreachable];
-      }
-  
-      bb32: {
+          _134 = _1;
+-         _132 = Add(move _133, move _134);
++         _132 = _128;
           StorageDead(_134);
           StorageDead(_133);
--         StorageLive(_137);
+-         _131 = opaque::<u64>(move _132) -> [return: bb36, unwind unreachable];
++         _131 = opaque::<u64>(_128) -> [return: bb36, unwind unreachable];
+      }
+  
+      bb36: {
+          StorageDead(_132);
+          StorageDead(_131);
+-         StorageLive(_135);
 +         nop;
-          _137 = &mut _3;
+          _135 = &mut _3;
+          StorageLive(_136);
+          StorageLive(_137);
           StorageLive(_138);
+          _138 = (*_135);
           StorageLive(_139);
-          StorageLive(_140);
-          _140 = (*_137);
-          StorageLive(_141);
-          _141 = _1;
--         _139 = Add(move _140, move _141);
-+         _139 = Add(move _140, _1);
-          StorageDead(_141);
-          StorageDead(_140);
-          _138 = opaque::<u64>(move _139) -> [return: bb33, unwind unreachable];
-      }
-  
-      bb33: {
+          _139 = _1;
+-         _137 = Add(move _138, move _139);
++         _137 = Add(move _138, _1);
           StorageDead(_139);
           StorageDead(_138);
-          StorageLive(_142);
-          StorageLive(_143);
-          StorageLive(_144);
-          _144 = (*_137);
-          StorageLive(_145);
-          _145 = _1;
--         _143 = Add(move _144, move _145);
-+         _143 = Add(move _144, _1);
-          StorageDead(_145);
-          StorageDead(_144);
-          _142 = opaque::<u64>(move _143) -> [return: bb34, unwind unreachable];
+          _136 = opaque::<u64>(move _137) -> [return: bb37, unwind unreachable];
       }
   
-      bb34: {
+      bb37: {
+          StorageDead(_137);
+          StorageDead(_136);
+          StorageLive(_140);
+          StorageLive(_141);
+          StorageLive(_142);
+          _142 = (*_135);
+          StorageLive(_143);
+          _143 = _1;
+-         _141 = Add(move _142, move _143);
++         _141 = Add(move _142, _1);
           StorageDead(_143);
           StorageDead(_142);
-          StorageLive(_146);
--         StorageLive(_147);
+          _140 = opaque::<u64>(move _141) -> [return: bb38, unwind unreachable];
+      }
+  
+      bb38: {
+          StorageDead(_141);
+          StorageDead(_140);
+          StorageLive(_144);
+-         StorageLive(_145);
 +         nop;
-          _147 = &raw const _3;
+          _145 = &raw const _3;
+          StorageLive(_146);
+          StorageLive(_147);
           StorageLive(_148);
+          _148 = (*_145);
           StorageLive(_149);
-          StorageLive(_150);
-          _150 = (*_147);
-          StorageLive(_151);
-          _151 = _1;
--         _149 = Add(move _150, move _151);
-+         _149 = Add(move _150, _1);
-          StorageDead(_151);
-          StorageDead(_150);
-          _148 = opaque::<u64>(move _149) -> [return: bb35, unwind unreachable];
-      }
-  
-      bb35: {
+          _149 = _1;
+-         _147 = Add(move _148, move _149);
++         _147 = Add(move _148, _1);
           StorageDead(_149);
           StorageDead(_148);
-          StorageLive(_152);
-          StorageLive(_153);
-          StorageLive(_154);
-          _154 = (*_147);
-          StorageLive(_155);
-          _155 = _1;
--         _153 = Add(move _154, move _155);
-+         _153 = Add(move _154, _1);
-          StorageDead(_155);
-          StorageDead(_154);
-          _152 = opaque::<u64>(move _153) -> [return: bb36, unwind unreachable];
+          _146 = opaque::<u64>(move _147) -> [return: bb39, unwind unreachable];
       }
   
-      bb36: {
+      bb39: {
+          StorageDead(_147);
+          StorageDead(_146);
+          StorageLive(_150);
+          StorageLive(_151);
+          StorageLive(_152);
+          _152 = (*_145);
+          StorageLive(_153);
+          _153 = _1;
+-         _151 = Add(move _152, move _153);
++         _151 = Add(move _152, _1);
           StorageDead(_153);
           StorageDead(_152);
--         StorageLive(_156);
+          _150 = opaque::<u64>(move _151) -> [return: bb40, unwind unreachable];
+      }
+  
+      bb40: {
+          StorageDead(_151);
+          StorageDead(_150);
+-         StorageLive(_154);
 +         nop;
-          _156 = &raw mut _3;
+          _154 = &raw mut _3;
+          StorageLive(_155);
+          StorageLive(_156);
           StorageLive(_157);
+          _157 = (*_154);
           StorageLive(_158);
-          StorageLive(_159);
-          _159 = (*_156);
-          StorageLive(_160);
-          _160 = _1;
--         _158 = Add(move _159, move _160);
-+         _158 = Add(move _159, _1);
-          StorageDead(_160);
-          StorageDead(_159);
-          _157 = opaque::<u64>(move _158) -> [return: bb37, unwind unreachable];
-      }
-  
-      bb37: {
+          _158 = _1;
+-         _156 = Add(move _157, move _158);
++         _156 = Add(move _157, _1);
           StorageDead(_158);
           StorageDead(_157);
-          StorageLive(_161);
-          StorageLive(_162);
-          StorageLive(_163);
-          _163 = (*_156);
-          StorageLive(_164);
-          _164 = _1;
--         _162 = Add(move _163, move _164);
-+         _162 = Add(move _163, _1);
-          StorageDead(_164);
-          StorageDead(_163);
-          _161 = opaque::<u64>(move _162) -> [return: bb38, unwind unreachable];
+          _155 = opaque::<u64>(move _156) -> [return: bb41, unwind unreachable];
       }
   
-      bb38: {
+      bb41: {
+          StorageDead(_156);
+          StorageDead(_155);
+          StorageLive(_159);
+          StorageLive(_160);
+          StorageLive(_161);
+          _161 = (*_154);
+          StorageLive(_162);
+          _162 = _1;
+-         _160 = Add(move _161, move _162);
++         _160 = Add(move _161, _1);
           StorageDead(_162);
           StorageDead(_161);
-          _146 = const ();
--         StorageDead(_156);
--         StorageDead(_147);
+          _159 = opaque::<u64>(move _160) -> [return: bb42, unwind unreachable];
+      }
+  
+      bb42: {
+          StorageDead(_160);
+          StorageDead(_159);
+          _144 = const ();
+-         StorageDead(_154);
+-         StorageDead(_145);
 +         nop;
 +         nop;
-          StorageDead(_146);
--         StorageLive(_165);
+          StorageDead(_144);
+-         StorageLive(_163);
 +         nop;
-          _165 = &_3;
-          StorageLive(_166);
--         StorageLive(_167);
--         StorageLive(_168);
+          _163 = &_3;
+          StorageLive(_164);
+-         StorageLive(_165);
+-         StorageLive(_166);
 +         nop;
 +         nop;
-          _168 = (*_165);
-          StorageLive(_169);
-          _169 = _1;
--         _167 = Add(move _168, move _169);
-+         _167 = Add(_168, _1);
-          StorageDead(_169);
--         StorageDead(_168);
--         _166 = opaque::<u64>(move _167) -> [return: bb39, unwind unreachable];
+          _166 = (*_163);
+          StorageLive(_167);
+          _167 = _1;
+-         _165 = Add(move _166, move _167);
++         _165 = Add(_166, _1);
+          StorageDead(_167);
+-         StorageDead(_166);
+-         _164 = opaque::<u64>(move _165) -> [return: bb43, unwind unreachable];
 +         nop;
-+         _166 = opaque::<u64>(_167) -> [return: bb39, unwind unreachable];
++         _164 = opaque::<u64>(_165) -> [return: bb43, unwind unreachable];
       }
   
-      bb39: {
--         StorageDead(_167);
+      bb43: {
+-         StorageDead(_165);
 +         nop;
-          StorageDead(_166);
+          StorageDead(_164);
+          StorageLive(_168);
+          StorageLive(_169);
           StorageLive(_170);
+-         _170 = (*_163);
++         _170 = _166;
           StorageLive(_171);
-          StorageLive(_172);
--         _172 = (*_165);
-+         _172 = _168;
-          StorageLive(_173);
-          _173 = _1;
--         _171 = Add(move _172, move _173);
-+         _171 = _167;
-          StorageDead(_173);
-          StorageDead(_172);
--         _170 = opaque::<u64>(move _171) -> [return: bb40, unwind unreachable];
-+         _170 = opaque::<u64>(_167) -> [return: bb40, unwind unreachable];
-      }
-  
-      bb40: {
+          _171 = _1;
+-         _169 = Add(move _170, move _171);
++         _169 = _165;
           StorageDead(_171);
           StorageDead(_170);
+-         _168 = opaque::<u64>(move _169) -> [return: bb44, unwind unreachable];
++         _168 = opaque::<u64>(_165) -> [return: bb44, unwind unreachable];
+      }
+  
+      bb44: {
+          StorageDead(_169);
+          StorageDead(_168);
           _0 = const ();
--         StorageDead(_165);
--         StorageDead(_137);
--         StorageDead(_128);
+-         StorageDead(_163);
+-         StorageDead(_135);
+-         StorageDead(_126);
 +         nop;
 +         nop;
 +         nop;
diff --git a/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff b/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff
index 062dc6ff561..119a4d9bbe9 100644
--- a/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff
@@ -65,11 +65,11 @@
       let mut _60: u64;
       let mut _61: u64;
       let mut _62: u64;
-      let mut _63: u64;
+      let _63: ();
       let mut _64: u64;
-      let _65: ();
+      let mut _65: u64;
       let mut _66: u64;
-      let mut _67: u64;
+      let _67: ();
       let mut _68: u64;
       let mut _69: u64;
       let mut _70: u64;
@@ -77,25 +77,25 @@
       let mut _72: u64;
       let mut _73: u64;
       let mut _74: u64;
-      let mut _75: u64;
-      let mut _76: u64;
-      let _77: ();
+      let mut _75: bool;
+      let _76: ();
+      let mut _77: u64;
       let mut _78: u64;
       let mut _79: u64;
-      let mut _80: u64;
-      let mut _81: u64;
-      let mut _82: bool;
+      let mut _80: bool;
+      let _81: ();
+      let mut _82: u64;
       let mut _83: u64;
-      let _84: ();
-      let mut _85: u64;
+      let mut _84: u64;
+      let _85: ();
       let mut _86: u64;
       let mut _87: u64;
       let mut _88: u64;
-      let mut _89: bool;
+      let _89: ();
       let mut _90: u64;
-      let _91: ();
+      let mut _91: u64;
       let mut _92: u64;
-      let mut _93: u64;
+      let _93: ();
       let mut _94: u64;
       let mut _95: u64;
       let mut _96: u64;
@@ -103,93 +103,91 @@
       let mut _98: u64;
       let mut _99: u64;
       let mut _100: u64;
-      let mut _101: u64;
-      let mut _102: u64;
-      let _103: ();
-      let mut _104: u64;
-      let mut _105: u64;
+      let _101: ();
+      let mut _102: u32;
+      let mut _103: u64;
+      let _104: ();
+      let mut _105: f32;
       let mut _106: u64;
-      let mut _107: u64;
-      let mut _108: u64;
-      let _109: ();
-      let mut _110: u64;
+      let _107: ();
+      let mut _108: S<u64>;
+      let mut _109: u64;
+      let _110: ();
       let mut _111: u64;
-      let mut _112: u64;
+      let mut _112: S<u64>;
       let mut _113: u64;
-      let mut _114: u64;
-      let _115: ();
+      let _114: ();
+      let mut _115: u64;
       let mut _116: u64;
       let mut _117: u64;
       let mut _118: u64;
       let mut _119: u64;
-      let mut _120: u64;
-      let _121: ();
-      let mut _122: S<u64>;
+      let _120: ();
+      let mut _121: u64;
+      let mut _122: u64;
       let mut _123: u64;
-      let _124: ();
+      let mut _124: u64;
       let mut _125: u64;
-      let mut _126: S<u64>;
-      let mut _127: u64;
-      let _128: &u64;
-      let _129: ();
+      let _126: &u64;
+      let _127: ();
+      let mut _128: u64;
+      let mut _129: u64;
       let mut _130: u64;
-      let mut _131: u64;
+      let _131: ();
       let mut _132: u64;
-      let _133: ();
+      let mut _133: u64;
       let mut _134: u64;
-      let mut _135: u64;
-      let mut _136: u64;
-      let _138: ();
+      let _136: ();
+      let mut _137: u64;
+      let mut _138: u64;
       let mut _139: u64;
-      let mut _140: u64;
+      let _140: ();
       let mut _141: u64;
-      let _142: ();
+      let mut _142: u64;
       let mut _143: u64;
-      let mut _144: u64;
-      let mut _145: u64;
+      let _144: ();
       let _146: ();
-      let _148: ();
+      let mut _147: u64;
+      let mut _148: u64;
       let mut _149: u64;
-      let mut _150: u64;
+      let _150: ();
       let mut _151: u64;
-      let _152: ();
+      let mut _152: u64;
       let mut _153: u64;
-      let mut _154: u64;
-      let mut _155: u64;
-      let _157: ();
+      let _155: ();
+      let mut _156: u64;
+      let mut _157: u64;
       let mut _158: u64;
-      let mut _159: u64;
+      let _159: ();
       let mut _160: u64;
-      let _161: ();
+      let mut _161: u64;
       let mut _162: u64;
-      let mut _163: u64;
-      let mut _164: u64;
-      let _166: ();
+      let _164: ();
+      let mut _165: u64;
+      let mut _166: u64;
       let mut _167: u64;
-      let mut _168: u64;
+      let _168: ();
       let mut _169: u64;
-      let _170: ();
+      let mut _170: u64;
       let mut _171: u64;
-      let mut _172: u64;
-      let mut _173: u64;
       scope 1 {
-          debug a => _128;
-          let _137: &mut u64;
+          debug a => _126;
+          let _135: &mut u64;
           scope 2 {
-              debug b => _137;
-              let _165: &u64;
+              debug b => _135;
+              let _163: &u64;
               scope 3 {
-                  let _147: *const u64;
+                  let _145: *const u64;
                   scope 4 {
-                      debug c => _147;
-                      let _156: *mut u64;
+                      debug c => _145;
+                      let _154: *mut u64;
                       scope 5 {
-                          debug d => _156;
+                          debug d => _154;
                       }
                   }
               }
               scope 6 {
-                  debug e => _165;
+                  debug e => _163;
               }
           }
       }
@@ -400,30 +398,36 @@
 +         nop;
           StorageDead(_42);
           StorageLive(_46);
-          StorageLive(_47);
+-         StorageLive(_47);
++         nop;
           StorageLive(_48);
           _48 = _1;
 -         _47 = move _48 as u32 (IntToInt);
 +         _47 = _1 as u32 (IntToInt);
           StorageDead(_48);
-          _46 = opaque::<u32>(move _47) -> [return: bb13, unwind continue];
+-         _46 = opaque::<u32>(move _47) -> [return: bb13, unwind continue];
++         _46 = opaque::<u32>(_47) -> [return: bb13, unwind continue];
       }
   
       bb13: {
-          StorageDead(_47);
+-         StorageDead(_47);
++         nop;
           StorageDead(_46);
           StorageLive(_49);
-          StorageLive(_50);
+-         StorageLive(_50);
++         nop;
           StorageLive(_51);
           _51 = _1;
 -         _50 = move _51 as f32 (IntToFloat);
 +         _50 = _1 as f32 (IntToFloat);
           StorageDead(_51);
-          _49 = opaque::<f32>(move _50) -> [return: bb14, unwind continue];
+-         _49 = opaque::<f32>(move _50) -> [return: bb14, unwind continue];
++         _49 = opaque::<f32>(_50) -> [return: bb14, unwind continue];
       }
   
       bb14: {
-          StorageDead(_50);
+-         StorageDead(_50);
++         nop;
           StorageDead(_49);
           StorageLive(_52);
 -         StorageLive(_53);
@@ -462,479 +466,497 @@
           StorageLive(_59);
           StorageLive(_60);
           StorageLive(_61);
+          _61 = _1;
           StorageLive(_62);
-          _62 = _1;
-          StorageLive(_63);
-          _63 = _2;
--         _61 = Add(move _62, move _63);
-+         _61 = _5;
-          StorageDead(_63);
+          _62 = _2;
+-         _60 = Add(move _61, move _62);
++         _60 = _5;
           StorageDead(_62);
-          StorageLive(_64);
-          _64 = _3;
--         _60 = Add(move _61, move _64);
-+         _60 = Add(_5, move _64);
-          StorageDead(_64);
           StorageDead(_61);
-          _59 = opaque::<u64>(move _60) -> [return: bb17, unwind continue];
+-         _59 = opaque::<u64>(move _60) -> [return: bb17, unwind continue];
++         _59 = opaque::<u64>(_5) -> [return: bb17, unwind continue];
       }
   
       bb17: {
           StorageDead(_60);
           StorageDead(_59);
+          StorageLive(_63);
+          StorageLive(_64);
           StorageLive(_65);
+          _65 = _1;
           StorageLive(_66);
+          _66 = _2;
+-         _64 = Mul(move _65, move _66);
++         _64 = _9;
+          StorageDead(_66);
+          StorageDead(_65);
+-         _63 = opaque::<u64>(move _64) -> [return: bb18, unwind continue];
++         _63 = opaque::<u64>(_9) -> [return: bb18, unwind continue];
+      }
+  
+      bb18: {
+          StorageDead(_64);
+          StorageDead(_63);
           StorageLive(_67);
           StorageLive(_68);
-          _68 = _1;
           StorageLive(_69);
-          _69 = _2;
--         _67 = Mul(move _68, move _69);
-+         _67 = _9;
-          StorageDead(_69);
-          StorageDead(_68);
+          _69 = _1;
           StorageLive(_70);
-          _70 = _3;
--         _66 = Add(move _67, move _70);
-+         _66 = Add(_9, move _70);
+          _70 = _2;
+-         _68 = Sub(move _69, move _70);
++         _68 = _13;
           StorageDead(_70);
-          StorageDead(_67);
-          _65 = opaque::<u64>(move _66) -> [return: bb18, unwind continue];
+          StorageDead(_69);
+-         _67 = opaque::<u64>(move _68) -> [return: bb19, unwind continue];
++         _67 = opaque::<u64>(_13) -> [return: bb19, unwind continue];
       }
   
-      bb18: {
-          StorageDead(_66);
-          StorageDead(_65);
+      bb19: {
+          StorageDead(_68);
+          StorageDead(_67);
           StorageLive(_71);
           StorageLive(_72);
           StorageLive(_73);
+          _73 = _1;
           StorageLive(_74);
-          _74 = _1;
-          StorageLive(_75);
-          _75 = _2;
--         _73 = Sub(move _74, move _75);
-+         _73 = _13;
-          StorageDead(_75);
+          _74 = _2;
+-         _75 = Eq(_74, const 0_u64);
+-         assert(!move _75, "attempt to divide `{}` by zero", _73) -> [success: bb20, unwind continue];
++         _75 = _20;
++         assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb20, unwind continue];
+      }
+  
+      bb20: {
+-         _72 = Div(move _73, move _74);
++         _72 = _17;
           StorageDead(_74);
-          StorageLive(_76);
-          _76 = _3;
--         _72 = Add(move _73, move _76);
-+         _72 = Add(_13, move _76);
-          StorageDead(_76);
           StorageDead(_73);
-          _71 = opaque::<u64>(move _72) -> [return: bb19, unwind continue];
+-         _71 = opaque::<u64>(move _72) -> [return: bb21, unwind continue];
++         _71 = opaque::<u64>(_17) -> [return: bb21, unwind continue];
       }
   
-      bb19: {
+      bb21: {
           StorageDead(_72);
           StorageDead(_71);
+          StorageLive(_76);
           StorageLive(_77);
           StorageLive(_78);
+          _78 = _1;
           StorageLive(_79);
-          StorageLive(_80);
-          _80 = _1;
-          StorageLive(_81);
-          _81 = _2;
--         _82 = Eq(_81, const 0_u64);
--         assert(!move _82, "attempt to divide `{}` by zero", _80) -> [success: bb20, unwind continue];
-+         _82 = _20;
-+         assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb20, unwind continue];
+          _79 = _2;
+-         _80 = Eq(_79, const 0_u64);
+-         assert(!move _80, "attempt to calculate the remainder of `{}` with a divisor of zero", _78) -> [success: bb22, unwind continue];
++         _80 = _20;
++         assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb22, unwind continue];
       }
   
-      bb20: {
--         _79 = Div(move _80, move _81);
-+         _79 = _17;
-          StorageDead(_81);
-          StorageDead(_80);
-          StorageLive(_83);
-          _83 = _3;
--         _78 = Add(move _79, move _83);
-+         _78 = Add(_17, move _83);
-          StorageDead(_83);
+      bb22: {
+-         _77 = Rem(move _78, move _79);
++         _77 = _22;
           StorageDead(_79);
-          _77 = opaque::<u64>(move _78) -> [return: bb21, unwind continue];
+          StorageDead(_78);
+-         _76 = opaque::<u64>(move _77) -> [return: bb23, unwind continue];
++         _76 = opaque::<u64>(_22) -> [return: bb23, unwind continue];
       }
   
-      bb21: {
-          StorageDead(_78);
+      bb23: {
           StorageDead(_77);
+          StorageDead(_76);
+          StorageLive(_81);
+          StorageLive(_82);
+          StorageLive(_83);
+          _83 = _1;
           StorageLive(_84);
+          _84 = _2;
+-         _82 = BitAnd(move _83, move _84);
++         _82 = _27;
+          StorageDead(_84);
+          StorageDead(_83);
+-         _81 = opaque::<u64>(move _82) -> [return: bb24, unwind continue];
++         _81 = opaque::<u64>(_27) -> [return: bb24, unwind continue];
+      }
+  
+      bb24: {
+          StorageDead(_82);
+          StorageDead(_81);
           StorageLive(_85);
           StorageLive(_86);
           StorageLive(_87);
           _87 = _1;
           StorageLive(_88);
           _88 = _2;
--         _89 = Eq(_88, const 0_u64);
--         assert(!move _89, "attempt to calculate the remainder of `{}` with a divisor of zero", _87) -> [success: bb22, unwind continue];
-+         _89 = _20;
-+         assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb22, unwind continue];
-      }
-  
-      bb22: {
--         _86 = Rem(move _87, move _88);
-+         _86 = _22;
+-         _86 = BitOr(move _87, move _88);
++         _86 = _31;
           StorageDead(_88);
           StorageDead(_87);
-          StorageLive(_90);
-          _90 = _3;
--         _85 = Add(move _86, move _90);
-+         _85 = Add(_22, move _90);
-          StorageDead(_90);
-          StorageDead(_86);
-          _84 = opaque::<u64>(move _85) -> [return: bb23, unwind continue];
+-         _85 = opaque::<u64>(move _86) -> [return: bb25, unwind continue];
++         _85 = opaque::<u64>(_31) -> [return: bb25, unwind continue];
       }
   
-      bb23: {
+      bb25: {
+          StorageDead(_86);
           StorageDead(_85);
-          StorageDead(_84);
+          StorageLive(_89);
+          StorageLive(_90);
           StorageLive(_91);
+          _91 = _1;
           StorageLive(_92);
+          _92 = _2;
+-         _90 = BitXor(move _91, move _92);
++         _90 = _35;
+          StorageDead(_92);
+          StorageDead(_91);
+-         _89 = opaque::<u64>(move _90) -> [return: bb26, unwind continue];
++         _89 = opaque::<u64>(_35) -> [return: bb26, unwind continue];
+      }
+  
+      bb26: {
+          StorageDead(_90);
+          StorageDead(_89);
           StorageLive(_93);
           StorageLive(_94);
-          _94 = _1;
           StorageLive(_95);
-          _95 = _2;
--         _93 = BitAnd(move _94, move _95);
-+         _93 = _27;
-          StorageDead(_95);
-          StorageDead(_94);
+          _95 = _1;
           StorageLive(_96);
-          _96 = _3;
--         _92 = Add(move _93, move _96);
-+         _92 = Add(_27, move _96);
+          _96 = _2;
+-         _94 = Shl(move _95, move _96);
++         _94 = _39;
           StorageDead(_96);
-          StorageDead(_93);
-          _91 = opaque::<u64>(move _92) -> [return: bb24, unwind continue];
+          StorageDead(_95);
+-         _93 = opaque::<u64>(move _94) -> [return: bb27, unwind continue];
++         _93 = opaque::<u64>(_39) -> [return: bb27, unwind continue];
       }
   
-      bb24: {
-          StorageDead(_92);
-          StorageDead(_91);
+      bb27: {
+          StorageDead(_94);
+          StorageDead(_93);
           StorageLive(_97);
           StorageLive(_98);
           StorageLive(_99);
+          _99 = _1;
           StorageLive(_100);
-          _100 = _1;
-          StorageLive(_101);
-          _101 = _2;
--         _99 = BitOr(move _100, move _101);
-+         _99 = _31;
-          StorageDead(_101);
+          _100 = _2;
+-         _98 = Shr(move _99, move _100);
++         _98 = _43;
           StorageDead(_100);
-          StorageLive(_102);
-          _102 = _3;
--         _98 = Add(move _99, move _102);
-+         _98 = Add(_31, move _102);
-          StorageDead(_102);
           StorageDead(_99);
-          _97 = opaque::<u64>(move _98) -> [return: bb25, unwind continue];
+-         _97 = opaque::<u64>(move _98) -> [return: bb28, unwind continue];
++         _97 = opaque::<u64>(_43) -> [return: bb28, unwind continue];
       }
   
-      bb25: {
+      bb28: {
           StorageDead(_98);
           StorageDead(_97);
+          StorageLive(_101);
+          StorageLive(_102);
           StorageLive(_103);
+          _103 = _1;
+-         _102 = move _103 as u32 (IntToInt);
++         _102 = _47;
+          StorageDead(_103);
+-         _101 = opaque::<u32>(move _102) -> [return: bb29, unwind continue];
++         _101 = opaque::<u32>(_47) -> [return: bb29, unwind continue];
+      }
+  
+      bb29: {
+          StorageDead(_102);
+          StorageDead(_101);
           StorageLive(_104);
           StorageLive(_105);
           StorageLive(_106);
           _106 = _1;
-          StorageLive(_107);
-          _107 = _2;
--         _105 = BitXor(move _106, move _107);
-+         _105 = _35;
-          StorageDead(_107);
+-         _105 = move _106 as f32 (IntToFloat);
++         _105 = _50;
           StorageDead(_106);
-          StorageLive(_108);
-          _108 = _3;
--         _104 = Add(move _105, move _108);
-+         _104 = Add(_35, move _108);
-          StorageDead(_108);
-          StorageDead(_105);
-          _103 = opaque::<u64>(move _104) -> [return: bb26, unwind continue];
+-         _104 = opaque::<f32>(move _105) -> [return: bb30, unwind continue];
++         _104 = opaque::<f32>(_50) -> [return: bb30, unwind continue];
       }
   
-      bb26: {
+      bb30: {
+          StorageDead(_105);
           StorageDead(_104);
-          StorageDead(_103);
+          StorageLive(_107);
+          StorageLive(_108);
           StorageLive(_109);
+          _109 = _1;
+-         _108 = S::<u64>(move _109);
++         _108 = _53;
+          StorageDead(_109);
+-         _107 = opaque::<S<u64>>(move _108) -> [return: bb31, unwind continue];
++         _107 = opaque::<S<u64>>(_53) -> [return: bb31, unwind continue];
+      }
+  
+      bb31: {
+          StorageDead(_108);
+          StorageDead(_107);
           StorageLive(_110);
           StorageLive(_111);
           StorageLive(_112);
-          _112 = _1;
           StorageLive(_113);
-          _113 = _2;
--         _111 = Shl(move _112, move _113);
-+         _111 = _39;
+          _113 = _1;
+-         _112 = S::<u64>(move _113);
++         _112 = _53;
           StorageDead(_113);
-          StorageDead(_112);
-          StorageLive(_114);
-          _114 = _3;
--         _110 = Add(move _111, move _114);
-+         _110 = Add(_39, move _114);
-          StorageDead(_114);
-          StorageDead(_111);
-          _109 = opaque::<u64>(move _110) -> [return: bb27, unwind continue];
+-         _111 = (_112.0: u64);
+-         _110 = opaque::<u64>(move _111) -> [return: bb32, unwind continue];
++         _111 = _1;
++         _110 = opaque::<u64>(_1) -> [return: bb32, unwind continue];
       }
   
-      bb27: {
+      bb32: {
+          StorageDead(_111);
+          StorageDead(_112);
           StorageDead(_110);
-          StorageDead(_109);
-          StorageLive(_115);
+          StorageLive(_114);
+-         StorageLive(_115);
++         nop;
           StorageLive(_116);
           StorageLive(_117);
+          _117 = _1;
           StorageLive(_118);
-          _118 = _1;
+          _118 = _2;
+-         _116 = Mul(move _117, move _118);
++         _116 = _9;
+          StorageDead(_118);
+          StorageDead(_117);
           StorageLive(_119);
           _119 = _2;
--         _117 = Shr(move _118, move _119);
-+         _117 = _43;
+-         _115 = Sub(move _116, move _119);
++         _115 = Sub(_9, _2);
           StorageDead(_119);
-          StorageDead(_118);
-          StorageLive(_120);
-          _120 = _3;
--         _116 = Add(move _117, move _120);
-+         _116 = Add(_43, move _120);
-          StorageDead(_120);
-          StorageDead(_117);
-          _115 = opaque::<u64>(move _116) -> [return: bb28, unwind continue];
+          StorageDead(_116);
+-         _114 = opaque::<u64>(move _115) -> [return: bb33, unwind continue];
++         _114 = opaque::<u64>(_115) -> [return: bb33, unwind continue];
       }
   
-      bb28: {
-          StorageDead(_116);
-          StorageDead(_115);
+      bb33: {
+-         StorageDead(_115);
++         nop;
+          StorageDead(_114);
+          StorageLive(_120);
           StorageLive(_121);
           StorageLive(_122);
           StorageLive(_123);
           _123 = _1;
--         _122 = S::<u64>(move _123);
-+         _122 = _53;
+          StorageLive(_124);
+          _124 = _2;
+-         _122 = Mul(move _123, move _124);
++         _122 = _9;
+          StorageDead(_124);
           StorageDead(_123);
--         _121 = opaque::<S<u64>>(move _122) -> [return: bb29, unwind continue];
-+         _121 = opaque::<S<u64>>(_53) -> [return: bb29, unwind continue];
+          StorageLive(_125);
+          _125 = _2;
+-         _121 = Sub(move _122, move _125);
++         _121 = _115;
+          StorageDead(_125);
+          StorageDead(_122);
+-         _120 = opaque::<u64>(move _121) -> [return: bb34, unwind continue];
++         _120 = opaque::<u64>(_115) -> [return: bb34, unwind continue];
       }
   
-      bb29: {
-          StorageDead(_122);
+      bb34: {
           StorageDead(_121);
-          StorageLive(_124);
-          StorageLive(_125);
-          StorageLive(_126);
+          StorageDead(_120);
+-         StorageLive(_126);
++         nop;
+          _126 = &_3;
           StorageLive(_127);
-          _127 = _1;
--         _126 = S::<u64>(move _127);
-+         _126 = _53;
-          StorageDead(_127);
--         _125 = (_126.0: u64);
--         _124 = opaque::<u64>(move _125) -> [return: bb30, unwind continue];
-+         _125 = _1;
-+         _124 = opaque::<u64>(_1) -> [return: bb30, unwind continue];
-      }
-  
-      bb30: {
-          StorageDead(_125);
-          StorageDead(_126);
-          StorageDead(_124);
 -         StorageLive(_128);
+-         StorageLive(_129);
 +         nop;
-          _128 = &_3;
-          StorageLive(_129);
--         StorageLive(_130);
--         StorageLive(_131);
 +         nop;
+          _129 = (*_126);
+          StorageLive(_130);
+          _130 = _1;
+-         _128 = Add(move _129, move _130);
++         _128 = Add(_129, _1);
+          StorageDead(_130);
+-         StorageDead(_129);
+-         _127 = opaque::<u64>(move _128) -> [return: bb35, unwind continue];
 +         nop;
-          _131 = (*_128);
-          StorageLive(_132);
-          _132 = _1;
--         _130 = Add(move _131, move _132);
-+         _130 = Add(_131, _1);
-          StorageDead(_132);
--         StorageDead(_131);
--         _129 = opaque::<u64>(move _130) -> [return: bb31, unwind continue];
-+         nop;
-+         _129 = opaque::<u64>(_130) -> [return: bb31, unwind continue];
++         _127 = opaque::<u64>(_128) -> [return: bb35, unwind continue];
       }
   
-      bb31: {
--         StorageDead(_130);
+      bb35: {
+-         StorageDead(_128);
 +         nop;
-          StorageDead(_129);
+          StorageDead(_127);
+          StorageLive(_131);
+          StorageLive(_132);
           StorageLive(_133);
+-         _133 = (*_126);
++         _133 = _129;
           StorageLive(_134);
-          StorageLive(_135);
--         _135 = (*_128);
-+         _135 = _131;
-          StorageLive(_136);
-          _136 = _1;
--         _134 = Add(move _135, move _136);
-+         _134 = _130;
-          StorageDead(_136);
-          StorageDead(_135);
--         _133 = opaque::<u64>(move _134) -> [return: bb32, unwind continue];
-+         _133 = opaque::<u64>(_130) -> [return: bb32, unwind continue];
-      }
-  
-      bb32: {
+          _134 = _1;
+-         _132 = Add(move _133, move _134);
++         _132 = _128;
           StorageDead(_134);
           StorageDead(_133);
--         StorageLive(_137);
+-         _131 = opaque::<u64>(move _132) -> [return: bb36, unwind continue];
++         _131 = opaque::<u64>(_128) -> [return: bb36, unwind continue];
+      }
+  
+      bb36: {
+          StorageDead(_132);
+          StorageDead(_131);
+-         StorageLive(_135);
 +         nop;
-          _137 = &mut _3;
+          _135 = &mut _3;
+          StorageLive(_136);
+          StorageLive(_137);
           StorageLive(_138);
+          _138 = (*_135);
           StorageLive(_139);
-          StorageLive(_140);
-          _140 = (*_137);
-          StorageLive(_141);
-          _141 = _1;
--         _139 = Add(move _140, move _141);
-+         _139 = Add(move _140, _1);
-          StorageDead(_141);
-          StorageDead(_140);
-          _138 = opaque::<u64>(move _139) -> [return: bb33, unwind continue];
-      }
-  
-      bb33: {
+          _139 = _1;
+-         _137 = Add(move _138, move _139);
++         _137 = Add(move _138, _1);
           StorageDead(_139);
           StorageDead(_138);
-          StorageLive(_142);
-          StorageLive(_143);
-          StorageLive(_144);
-          _144 = (*_137);
-          StorageLive(_145);
-          _145 = _1;
--         _143 = Add(move _144, move _145);
-+         _143 = Add(move _144, _1);
-          StorageDead(_145);
-          StorageDead(_144);
-          _142 = opaque::<u64>(move _143) -> [return: bb34, unwind continue];
+          _136 = opaque::<u64>(move _137) -> [return: bb37, unwind continue];
       }
   
-      bb34: {
+      bb37: {
+          StorageDead(_137);
+          StorageDead(_136);
+          StorageLive(_140);
+          StorageLive(_141);
+          StorageLive(_142);
+          _142 = (*_135);
+          StorageLive(_143);
+          _143 = _1;
+-         _141 = Add(move _142, move _143);
++         _141 = Add(move _142, _1);
           StorageDead(_143);
           StorageDead(_142);
-          StorageLive(_146);
--         StorageLive(_147);
+          _140 = opaque::<u64>(move _141) -> [return: bb38, unwind continue];
+      }
+  
+      bb38: {
+          StorageDead(_141);
+          StorageDead(_140);
+          StorageLive(_144);
+-         StorageLive(_145);
 +         nop;
-          _147 = &raw const _3;
+          _145 = &raw const _3;
+          StorageLive(_146);
+          StorageLive(_147);
           StorageLive(_148);
+          _148 = (*_145);
           StorageLive(_149);
-          StorageLive(_150);
-          _150 = (*_147);
-          StorageLive(_151);
-          _151 = _1;
--         _149 = Add(move _150, move _151);
-+         _149 = Add(move _150, _1);
-          StorageDead(_151);
-          StorageDead(_150);
-          _148 = opaque::<u64>(move _149) -> [return: bb35, unwind continue];
-      }
-  
-      bb35: {
+          _149 = _1;
+-         _147 = Add(move _148, move _149);
++         _147 = Add(move _148, _1);
           StorageDead(_149);
           StorageDead(_148);
-          StorageLive(_152);
-          StorageLive(_153);
-          StorageLive(_154);
-          _154 = (*_147);
-          StorageLive(_155);
-          _155 = _1;
--         _153 = Add(move _154, move _155);
-+         _153 = Add(move _154, _1);
-          StorageDead(_155);
-          StorageDead(_154);
-          _152 = opaque::<u64>(move _153) -> [return: bb36, unwind continue];
+          _146 = opaque::<u64>(move _147) -> [return: bb39, unwind continue];
       }
   
-      bb36: {
+      bb39: {
+          StorageDead(_147);
+          StorageDead(_146);
+          StorageLive(_150);
+          StorageLive(_151);
+          StorageLive(_152);
+          _152 = (*_145);
+          StorageLive(_153);
+          _153 = _1;
+-         _151 = Add(move _152, move _153);
++         _151 = Add(move _152, _1);
           StorageDead(_153);
           StorageDead(_152);
--         StorageLive(_156);
+          _150 = opaque::<u64>(move _151) -> [return: bb40, unwind continue];
+      }
+  
+      bb40: {
+          StorageDead(_151);
+          StorageDead(_150);
+-         StorageLive(_154);
 +         nop;
-          _156 = &raw mut _3;
+          _154 = &raw mut _3;
+          StorageLive(_155);
+          StorageLive(_156);
           StorageLive(_157);
+          _157 = (*_154);
           StorageLive(_158);
-          StorageLive(_159);
-          _159 = (*_156);
-          StorageLive(_160);
-          _160 = _1;
--         _158 = Add(move _159, move _160);
-+         _158 = Add(move _159, _1);
-          StorageDead(_160);
-          StorageDead(_159);
-          _157 = opaque::<u64>(move _158) -> [return: bb37, unwind continue];
-      }
-  
-      bb37: {
+          _158 = _1;
+-         _156 = Add(move _157, move _158);
++         _156 = Add(move _157, _1);
           StorageDead(_158);
           StorageDead(_157);
-          StorageLive(_161);
-          StorageLive(_162);
-          StorageLive(_163);
-          _163 = (*_156);
-          StorageLive(_164);
-          _164 = _1;
--         _162 = Add(move _163, move _164);
-+         _162 = Add(move _163, _1);
-          StorageDead(_164);
-          StorageDead(_163);
-          _161 = opaque::<u64>(move _162) -> [return: bb38, unwind continue];
+          _155 = opaque::<u64>(move _156) -> [return: bb41, unwind continue];
       }
   
-      bb38: {
+      bb41: {
+          StorageDead(_156);
+          StorageDead(_155);
+          StorageLive(_159);
+          StorageLive(_160);
+          StorageLive(_161);
+          _161 = (*_154);
+          StorageLive(_162);
+          _162 = _1;
+-         _160 = Add(move _161, move _162);
++         _160 = Add(move _161, _1);
           StorageDead(_162);
           StorageDead(_161);
-          _146 = const ();
--         StorageDead(_156);
--         StorageDead(_147);
+          _159 = opaque::<u64>(move _160) -> [return: bb42, unwind continue];
+      }
+  
+      bb42: {
+          StorageDead(_160);
+          StorageDead(_159);
+          _144 = const ();
+-         StorageDead(_154);
+-         StorageDead(_145);
 +         nop;
 +         nop;
-          StorageDead(_146);
--         StorageLive(_165);
+          StorageDead(_144);
+-         StorageLive(_163);
 +         nop;
-          _165 = &_3;
-          StorageLive(_166);
--         StorageLive(_167);
--         StorageLive(_168);
+          _163 = &_3;
+          StorageLive(_164);
+-         StorageLive(_165);
+-         StorageLive(_166);
 +         nop;
 +         nop;
-          _168 = (*_165);
-          StorageLive(_169);
-          _169 = _1;
--         _167 = Add(move _168, move _169);
-+         _167 = Add(_168, _1);
-          StorageDead(_169);
--         StorageDead(_168);
--         _166 = opaque::<u64>(move _167) -> [return: bb39, unwind continue];
+          _166 = (*_163);
+          StorageLive(_167);
+          _167 = _1;
+-         _165 = Add(move _166, move _167);
++         _165 = Add(_166, _1);
+          StorageDead(_167);
+-         StorageDead(_166);
+-         _164 = opaque::<u64>(move _165) -> [return: bb43, unwind continue];
 +         nop;
-+         _166 = opaque::<u64>(_167) -> [return: bb39, unwind continue];
++         _164 = opaque::<u64>(_165) -> [return: bb43, unwind continue];
       }
   
-      bb39: {
--         StorageDead(_167);
+      bb43: {
+-         StorageDead(_165);
 +         nop;
-          StorageDead(_166);
+          StorageDead(_164);
+          StorageLive(_168);
+          StorageLive(_169);
           StorageLive(_170);
+-         _170 = (*_163);
++         _170 = _166;
           StorageLive(_171);
-          StorageLive(_172);
--         _172 = (*_165);
-+         _172 = _168;
-          StorageLive(_173);
-          _173 = _1;
--         _171 = Add(move _172, move _173);
-+         _171 = _167;
-          StorageDead(_173);
-          StorageDead(_172);
--         _170 = opaque::<u64>(move _171) -> [return: bb40, unwind continue];
-+         _170 = opaque::<u64>(_167) -> [return: bb40, unwind continue];
-      }
-  
-      bb40: {
+          _171 = _1;
+-         _169 = Add(move _170, move _171);
++         _169 = _165;
           StorageDead(_171);
           StorageDead(_170);
+-         _168 = opaque::<u64>(move _169) -> [return: bb44, unwind continue];
++         _168 = opaque::<u64>(_165) -> [return: bb44, unwind continue];
+      }
+  
+      bb44: {
+          StorageDead(_169);
+          StorageDead(_168);
           _0 = const ();
--         StorageDead(_165);
--         StorageDead(_137);
--         StorageDead(_128);
+-         StorageDead(_163);
+-         StorageDead(_135);
+-         StorageDead(_126);
 +         nop;
 +         nop;
 +         nop;