Do not remove unused definitions inside GVN.

1 files changed, 273 insertions, 220 deletions

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 68b05290719..fb2c089827d 100644
--- a/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff
@@ -197,61 +197,68 @@
       bb0: {
           StorageLive(_4);
 -         StorageLive(_5);
--         StorageLive(_6);
--         _6 = _1;
--         StorageLive(_7);
--         _7 = _2;
++         nop;
+          StorageLive(_6);
+          _6 = _1;
+          StorageLive(_7);
+          _7 = _2;
 -         _5 = Add(move _6, move _7);
--         StorageDead(_7);
--         StorageDead(_6);
--         _4 = opaque::<u64>(move _5) -> [return: bb1, unwind continue];
 +         _5 = Add(_1, _2);
+          StorageDead(_7);
+          StorageDead(_6);
+-         _4 = opaque::<u64>(move _5) -> [return: bb1, unwind continue];
 +         _4 = opaque::<u64>(_5) -> [return: bb1, unwind continue];
       }
   
       bb1: {
 -         StorageDead(_5);
++         nop;
           StorageDead(_4);
           StorageLive(_8);
 -         StorageLive(_9);
--         StorageLive(_10);
--         _10 = _1;
--         StorageLive(_11);
--         _11 = _2;
++         nop;
+          StorageLive(_10);
+          _10 = _1;
+          StorageLive(_11);
+          _11 = _2;
 -         _9 = Mul(move _10, move _11);
--         StorageDead(_11);
--         StorageDead(_10);
--         _8 = opaque::<u64>(move _9) -> [return: bb2, unwind continue];
 +         _9 = Mul(_1, _2);
+          StorageDead(_11);
+          StorageDead(_10);
+-         _8 = opaque::<u64>(move _9) -> [return: bb2, unwind continue];
 +         _8 = opaque::<u64>(_9) -> [return: bb2, unwind continue];
       }
   
       bb2: {
 -         StorageDead(_9);
++         nop;
           StorageDead(_8);
           StorageLive(_12);
 -         StorageLive(_13);
--         StorageLive(_14);
--         _14 = _1;
--         StorageLive(_15);
--         _15 = _2;
++         nop;
+          StorageLive(_14);
+          _14 = _1;
+          StorageLive(_15);
+          _15 = _2;
 -         _13 = Sub(move _14, move _15);
--         StorageDead(_15);
--         StorageDead(_14);
--         _12 = opaque::<u64>(move _13) -> [return: bb3, unwind continue];
 +         _13 = Sub(_1, _2);
+          StorageDead(_15);
+          StorageDead(_14);
+-         _12 = opaque::<u64>(move _13) -> [return: bb3, unwind continue];
 +         _12 = opaque::<u64>(_13) -> [return: bb3, unwind continue];
       }
   
       bb3: {
 -         StorageDead(_13);
++         nop;
           StorageDead(_12);
           StorageLive(_16);
 -         StorageLive(_17);
--         StorageLive(_18);
--         _18 = _1;
--         StorageLive(_19);
--         _19 = _2;
++         nop;
+          StorageLive(_18);
+          _18 = _1;
+          StorageLive(_19);
+          _19 = _2;
 -         _20 = Eq(_19, const 0_u64);
 -         assert(!move _20, "attempt to divide `{}` by zero", _18) -> [success: bb4, unwind continue];
 +         _20 = Eq(_2, const 0_u64);
@@ -260,131 +267,145 @@
   
       bb4: {
 -         _17 = Div(move _18, move _19);
--         StorageDead(_19);
--         StorageDead(_18);
--         _16 = opaque::<u64>(move _17) -> [return: bb5, unwind continue];
 +         _17 = Div(_1, _2);
+          StorageDead(_19);
+          StorageDead(_18);
+-         _16 = opaque::<u64>(move _17) -> [return: bb5, unwind continue];
 +         _16 = opaque::<u64>(_17) -> [return: bb5, unwind continue];
       }
   
       bb5: {
 -         StorageDead(_17);
++         nop;
           StorageDead(_16);
           StorageLive(_21);
 -         StorageLive(_22);
--         StorageLive(_23);
--         _23 = _1;
--         StorageLive(_24);
--         _24 = _2;
++         nop;
+          StorageLive(_23);
+          _23 = _1;
+          StorageLive(_24);
+          _24 = _2;
 -         _25 = Eq(_24, const 0_u64);
 -         assert(!move _25, "attempt to calculate the remainder of `{}` with a divisor of zero", _23) -> [success: bb6, unwind continue];
++         _25 = _20;
 +         assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb6, unwind continue];
       }
   
       bb6: {
 -         _22 = Rem(move _23, move _24);
--         StorageDead(_24);
--         StorageDead(_23);
--         _21 = opaque::<u64>(move _22) -> [return: bb7, unwind continue];
 +         _22 = Rem(_1, _2);
+          StorageDead(_24);
+          StorageDead(_23);
+-         _21 = opaque::<u64>(move _22) -> [return: bb7, unwind continue];
 +         _21 = opaque::<u64>(_22) -> [return: bb7, unwind continue];
       }
   
       bb7: {
 -         StorageDead(_22);
++         nop;
           StorageDead(_21);
           StorageLive(_26);
 -         StorageLive(_27);
--         StorageLive(_28);
--         _28 = _1;
--         StorageLive(_29);
--         _29 = _2;
++         nop;
+          StorageLive(_28);
+          _28 = _1;
+          StorageLive(_29);
+          _29 = _2;
 -         _27 = BitAnd(move _28, move _29);
--         StorageDead(_29);
--         StorageDead(_28);
--         _26 = opaque::<u64>(move _27) -> [return: bb8, unwind continue];
 +         _27 = BitAnd(_1, _2);
+          StorageDead(_29);
+          StorageDead(_28);
+-         _26 = opaque::<u64>(move _27) -> [return: bb8, unwind continue];
 +         _26 = opaque::<u64>(_27) -> [return: bb8, unwind continue];
       }
   
       bb8: {
 -         StorageDead(_27);
++         nop;
           StorageDead(_26);
           StorageLive(_30);
 -         StorageLive(_31);
--         StorageLive(_32);
--         _32 = _1;
--         StorageLive(_33);
--         _33 = _2;
++         nop;
+          StorageLive(_32);
+          _32 = _1;
+          StorageLive(_33);
+          _33 = _2;
 -         _31 = BitOr(move _32, move _33);
--         StorageDead(_33);
--         StorageDead(_32);
--         _30 = opaque::<u64>(move _31) -> [return: bb9, unwind continue];
 +         _31 = BitOr(_1, _2);
+          StorageDead(_33);
+          StorageDead(_32);
+-         _30 = opaque::<u64>(move _31) -> [return: bb9, unwind continue];
 +         _30 = opaque::<u64>(_31) -> [return: bb9, unwind continue];
       }
   
       bb9: {
 -         StorageDead(_31);
++         nop;
           StorageDead(_30);
           StorageLive(_34);
 -         StorageLive(_35);
--         StorageLive(_36);
--         _36 = _1;
--         StorageLive(_37);
--         _37 = _2;
++         nop;
+          StorageLive(_36);
+          _36 = _1;
+          StorageLive(_37);
+          _37 = _2;
 -         _35 = BitXor(move _36, move _37);
--         StorageDead(_37);
--         StorageDead(_36);
--         _34 = opaque::<u64>(move _35) -> [return: bb10, unwind continue];
 +         _35 = BitXor(_1, _2);
+          StorageDead(_37);
+          StorageDead(_36);
+-         _34 = opaque::<u64>(move _35) -> [return: bb10, unwind continue];
 +         _34 = opaque::<u64>(_35) -> [return: bb10, unwind continue];
       }
   
       bb10: {
 -         StorageDead(_35);
++         nop;
           StorageDead(_34);
           StorageLive(_38);
 -         StorageLive(_39);
--         StorageLive(_40);
--         _40 = _1;
--         StorageLive(_41);
--         _41 = _2;
++         nop;
+          StorageLive(_40);
+          _40 = _1;
+          StorageLive(_41);
+          _41 = _2;
 -         _39 = Shl(move _40, move _41);
--         StorageDead(_41);
--         StorageDead(_40);
--         _38 = opaque::<u64>(move _39) -> [return: bb11, unwind continue];
 +         _39 = Shl(_1, _2);
+          StorageDead(_41);
+          StorageDead(_40);
+-         _38 = opaque::<u64>(move _39) -> [return: bb11, unwind continue];
 +         _38 = opaque::<u64>(_39) -> [return: bb11, unwind continue];
       }
   
       bb11: {
 -         StorageDead(_39);
++         nop;
           StorageDead(_38);
           StorageLive(_42);
 -         StorageLive(_43);
--         StorageLive(_44);
--         _44 = _1;
--         StorageLive(_45);
--         _45 = _2;
++         nop;
+          StorageLive(_44);
+          _44 = _1;
+          StorageLive(_45);
+          _45 = _2;
 -         _43 = Shr(move _44, move _45);
--         StorageDead(_45);
--         StorageDead(_44);
--         _42 = opaque::<u64>(move _43) -> [return: bb12, unwind continue];
 +         _43 = Shr(_1, _2);
+          StorageDead(_45);
+          StorageDead(_44);
+-         _42 = opaque::<u64>(move _43) -> [return: bb12, unwind continue];
 +         _42 = opaque::<u64>(_43) -> [return: bb12, unwind continue];
       }
   
       bb12: {
 -         StorageDead(_43);
++         nop;
           StorageDead(_42);
           StorageLive(_46);
           StorageLive(_47);
--         StorageLive(_48);
--         _48 = _1;
+          StorageLive(_48);
+          _48 = _1;
 -         _47 = move _48 as u32 (IntToInt);
--         StorageDead(_48);
 +         _47 = _1 as u32 (IntToInt);
+          StorageDead(_48);
           _46 = opaque::<u32>(move _47) -> [return: bb13, unwind continue];
       }
   
@@ -393,11 +414,11 @@
           StorageDead(_46);
           StorageLive(_49);
           StorageLive(_50);
--         StorageLive(_51);
--         _51 = _1;
+          StorageLive(_51);
+          _51 = _1;
 -         _50 = move _51 as f32 (IntToFloat);
--         StorageDead(_51);
 +         _50 = _1 as f32 (IntToFloat);
+          StorageDead(_51);
           _49 = opaque::<f32>(move _50) -> [return: bb14, unwind continue];
       }
   
@@ -406,25 +427,29 @@
           StorageDead(_49);
           StorageLive(_52);
 -         StorageLive(_53);
--         StorageLive(_54);
--         _54 = _1;
++         nop;
+          StorageLive(_54);
+          _54 = _1;
 -         _53 = S::<u64>(move _54);
--         StorageDead(_54);
--         _52 = opaque::<S<u64>>(move _53) -> [return: bb15, unwind continue];
 +         _53 = S::<u64>(_1);
+          StorageDead(_54);
+-         _52 = opaque::<S<u64>>(move _53) -> [return: bb15, unwind continue];
 +         _52 = opaque::<S<u64>>(_53) -> [return: bb15, unwind continue];
       }
   
       bb15: {
 -         StorageDead(_53);
++         nop;
           StorageDead(_52);
           StorageLive(_55);
 -         StorageLive(_56);
--         StorageLive(_57);
--         StorageLive(_58);
--         _58 = _1;
++         nop;
+          StorageLive(_57);
+          StorageLive(_58);
+          _58 = _1;
 -         _57 = S::<u64>(move _58);
--         StorageDead(_58);
++         _57 = _53;
+          StorageDead(_58);
 -         _56 = (_57.0: u64);
 -         _55 = opaque::<u64>(move _56) -> [return: bb16, unwind continue];
 +         _56 = (_53.0: u64);
@@ -433,24 +458,26 @@
   
       bb16: {
 -         StorageDead(_56);
--         StorageDead(_57);
++         nop;
+          StorageDead(_57);
           StorageDead(_55);
           StorageLive(_59);
           StorageLive(_60);
--         StorageLive(_61);
--         StorageLive(_62);
--         _62 = _1;
--         StorageLive(_63);
--         _63 = _2;
+          StorageLive(_61);
+          StorageLive(_62);
+          _62 = _1;
+          StorageLive(_63);
+          _63 = _2;
 -         _61 = Add(move _62, move _63);
--         StorageDead(_63);
--         StorageDead(_62);
++         _61 = _5;
+          StorageDead(_63);
+          StorageDead(_62);
           StorageLive(_64);
           _64 = _3;
 -         _60 = Add(move _61, move _64);
 +         _60 = Add(_5, move _64);
           StorageDead(_64);
--         StorageDead(_61);
+          StorageDead(_61);
           _59 = opaque::<u64>(move _60) -> [return: bb17, unwind continue];
       }
   
@@ -459,20 +486,21 @@
           StorageDead(_59);
           StorageLive(_65);
           StorageLive(_66);
--         StorageLive(_67);
--         StorageLive(_68);
--         _68 = _1;
--         StorageLive(_69);
--         _69 = _2;
+          StorageLive(_67);
+          StorageLive(_68);
+          _68 = _1;
+          StorageLive(_69);
+          _69 = _2;
 -         _67 = Mul(move _68, move _69);
--         StorageDead(_69);
--         StorageDead(_68);
++         _67 = _9;
+          StorageDead(_69);
+          StorageDead(_68);
           StorageLive(_70);
           _70 = _3;
 -         _66 = Add(move _67, move _70);
 +         _66 = Add(_9, move _70);
           StorageDead(_70);
--         StorageDead(_67);
+          StorageDead(_67);
           _65 = opaque::<u64>(move _66) -> [return: bb18, unwind continue];
       }
   
@@ -481,20 +509,21 @@
           StorageDead(_65);
           StorageLive(_71);
           StorageLive(_72);
--         StorageLive(_73);
--         StorageLive(_74);
--         _74 = _1;
--         StorageLive(_75);
--         _75 = _2;
+          StorageLive(_73);
+          StorageLive(_74);
+          _74 = _1;
+          StorageLive(_75);
+          _75 = _2;
 -         _73 = Sub(move _74, move _75);
--         StorageDead(_75);
--         StorageDead(_74);
++         _73 = _13;
+          StorageDead(_75);
+          StorageDead(_74);
           StorageLive(_76);
           _76 = _3;
 -         _72 = Add(move _73, move _76);
 +         _72 = Add(_13, move _76);
           StorageDead(_76);
--         StorageDead(_73);
+          StorageDead(_73);
           _71 = opaque::<u64>(move _72) -> [return: bb19, unwind continue];
       }
   
@@ -503,26 +532,28 @@
           StorageDead(_71);
           StorageLive(_77);
           StorageLive(_78);
--         StorageLive(_79);
--         StorageLive(_80);
--         _80 = _1;
--         StorageLive(_81);
--         _81 = _2;
+          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];
       }
   
       bb20: {
 -         _79 = Div(move _80, move _81);
--         StorageDead(_81);
--         StorageDead(_80);
++         _79 = _17;
+          StorageDead(_81);
+          StorageDead(_80);
           StorageLive(_83);
           _83 = _3;
 -         _78 = Add(move _79, move _83);
 +         _78 = Add(_17, move _83);
           StorageDead(_83);
--         StorageDead(_79);
+          StorageDead(_79);
           _77 = opaque::<u64>(move _78) -> [return: bb21, unwind continue];
       }
   
@@ -531,26 +562,28 @@
           StorageDead(_77);
           StorageLive(_84);
           StorageLive(_85);
--         StorageLive(_86);
--         StorageLive(_87);
--         _87 = _1;
--         StorageLive(_88);
--         _88 = _2;
+          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);
--         StorageDead(_88);
--         StorageDead(_87);
++         _86 = _22;
+          StorageDead(_88);
+          StorageDead(_87);
           StorageLive(_90);
           _90 = _3;
 -         _85 = Add(move _86, move _90);
 +         _85 = Add(_22, move _90);
           StorageDead(_90);
--         StorageDead(_86);
+          StorageDead(_86);
           _84 = opaque::<u64>(move _85) -> [return: bb23, unwind continue];
       }
   
@@ -559,20 +592,21 @@
           StorageDead(_84);
           StorageLive(_91);
           StorageLive(_92);
--         StorageLive(_93);
--         StorageLive(_94);
--         _94 = _1;
--         StorageLive(_95);
--         _95 = _2;
+          StorageLive(_93);
+          StorageLive(_94);
+          _94 = _1;
+          StorageLive(_95);
+          _95 = _2;
 -         _93 = BitAnd(move _94, move _95);
--         StorageDead(_95);
--         StorageDead(_94);
++         _93 = _27;
+          StorageDead(_95);
+          StorageDead(_94);
           StorageLive(_96);
           _96 = _3;
 -         _92 = Add(move _93, move _96);
 +         _92 = Add(_27, move _96);
           StorageDead(_96);
--         StorageDead(_93);
+          StorageDead(_93);
           _91 = opaque::<u64>(move _92) -> [return: bb24, unwind continue];
       }
   
@@ -581,20 +615,21 @@
           StorageDead(_91);
           StorageLive(_97);
           StorageLive(_98);
--         StorageLive(_99);
--         StorageLive(_100);
--         _100 = _1;
--         StorageLive(_101);
--         _101 = _2;
+          StorageLive(_99);
+          StorageLive(_100);
+          _100 = _1;
+          StorageLive(_101);
+          _101 = _2;
 -         _99 = BitOr(move _100, move _101);
--         StorageDead(_101);
--         StorageDead(_100);
++         _99 = _31;
+          StorageDead(_101);
+          StorageDead(_100);
           StorageLive(_102);
           _102 = _3;
 -         _98 = Add(move _99, move _102);
 +         _98 = Add(_31, move _102);
           StorageDead(_102);
--         StorageDead(_99);
+          StorageDead(_99);
           _97 = opaque::<u64>(move _98) -> [return: bb25, unwind continue];
       }
   
@@ -603,20 +638,21 @@
           StorageDead(_97);
           StorageLive(_103);
           StorageLive(_104);
--         StorageLive(_105);
--         StorageLive(_106);
--         _106 = _1;
--         StorageLive(_107);
--         _107 = _2;
+          StorageLive(_105);
+          StorageLive(_106);
+          _106 = _1;
+          StorageLive(_107);
+          _107 = _2;
 -         _105 = BitXor(move _106, move _107);
--         StorageDead(_107);
--         StorageDead(_106);
++         _105 = _35;
+          StorageDead(_107);
+          StorageDead(_106);
           StorageLive(_108);
           _108 = _3;
 -         _104 = Add(move _105, move _108);
 +         _104 = Add(_35, move _108);
           StorageDead(_108);
--         StorageDead(_105);
+          StorageDead(_105);
           _103 = opaque::<u64>(move _104) -> [return: bb26, unwind continue];
       }
   
@@ -625,20 +661,21 @@
           StorageDead(_103);
           StorageLive(_109);
           StorageLive(_110);
--         StorageLive(_111);
--         StorageLive(_112);
--         _112 = _1;
--         StorageLive(_113);
--         _113 = _2;
+          StorageLive(_111);
+          StorageLive(_112);
+          _112 = _1;
+          StorageLive(_113);
+          _113 = _2;
 -         _111 = Shl(move _112, move _113);
--         StorageDead(_113);
--         StorageDead(_112);
++         _111 = _39;
+          StorageDead(_113);
+          StorageDead(_112);
           StorageLive(_114);
           _114 = _3;
 -         _110 = Add(move _111, move _114);
 +         _110 = Add(_39, move _114);
           StorageDead(_114);
--         StorageDead(_111);
+          StorageDead(_111);
           _109 = opaque::<u64>(move _110) -> [return: bb27, unwind continue];
       }
   
@@ -647,20 +684,21 @@
           StorageDead(_109);
           StorageLive(_115);
           StorageLive(_116);
--         StorageLive(_117);
--         StorageLive(_118);
--         _118 = _1;
--         StorageLive(_119);
--         _119 = _2;
+          StorageLive(_117);
+          StorageLive(_118);
+          _118 = _1;
+          StorageLive(_119);
+          _119 = _2;
 -         _117 = Shr(move _118, move _119);
--         StorageDead(_119);
--         StorageDead(_118);
++         _117 = _43;
+          StorageDead(_119);
+          StorageDead(_118);
           StorageLive(_120);
           _120 = _3;
 -         _116 = Add(move _117, move _120);
 +         _116 = Add(_43, move _120);
           StorageDead(_120);
--         StorageDead(_117);
+          StorageDead(_117);
           _115 = opaque::<u64>(move _116) -> [return: bb28, unwind continue];
       }
   
@@ -668,68 +706,77 @@
           StorageDead(_116);
           StorageDead(_115);
           StorageLive(_121);
--         StorageLive(_122);
--         StorageLive(_123);
--         _123 = _1;
+          StorageLive(_122);
+          StorageLive(_123);
+          _123 = _1;
 -         _122 = S::<u64>(move _123);
--         StorageDead(_123);
++         _122 = _53;
+          StorageDead(_123);
 -         _121 = opaque::<S<u64>>(move _122) -> [return: bb29, unwind continue];
 +         _121 = opaque::<S<u64>>(_53) -> [return: bb29, unwind continue];
       }
   
       bb29: {
--         StorageDead(_122);
+          StorageDead(_122);
           StorageDead(_121);
           StorageLive(_124);
--         StorageLive(_125);
--         StorageLive(_126);
--         StorageLive(_127);
--         _127 = _1;
+          StorageLive(_125);
+          StorageLive(_126);
+          StorageLive(_127);
+          _127 = _1;
 -         _126 = S::<u64>(move _127);
--         StorageDead(_127);
++         _126 = _53;
+          StorageDead(_127);
 -         _125 = (_126.0: u64);
 -         _124 = opaque::<u64>(move _125) -> [return: bb30, unwind continue];
++         _125 = _56;
 +         _124 = opaque::<u64>(_56) -> [return: bb30, unwind continue];
       }
   
       bb30: {
--         StorageDead(_125);
--         StorageDead(_126);
+          StorageDead(_125);
+          StorageDead(_126);
           StorageDead(_124);
           StorageLive(_128);
           _128 = &_3;
           StorageLive(_129);
 -         StorageLive(_130);
 -         StorageLive(_131);
++         nop;
++         nop;
           _131 = (*_128);
--         StorageLive(_132);
--         _132 = _1;
+          StorageLive(_132);
+          _132 = _1;
 -         _130 = Add(move _131, move _132);
--         StorageDead(_132);
++         _130 = Add(_131, _1);
+          StorageDead(_132);
 -         StorageDead(_131);
 -         _129 = opaque::<u64>(move _130) -> [return: bb31, unwind continue];
-+         _130 = Add(_131, _1);
++         nop;
 +         _129 = opaque::<u64>(_130) -> [return: bb31, unwind continue];
       }
   
       bb31: {
 -         StorageDead(_130);
++         nop;
           StorageDead(_129);
           StorageLive(_133);
--         StorageLive(_134);
--         StorageLive(_135);
+          StorageLive(_134);
+          StorageLive(_135);
 -         _135 = (*_128);
--         StorageLive(_136);
--         _136 = _1;
++         _135 = _131;
+          StorageLive(_136);
+          _136 = _1;
 -         _134 = Add(move _135, move _136);
--         StorageDead(_136);
--         StorageDead(_135);
++         _134 = _130;
+          StorageDead(_136);
+          StorageDead(_135);
 -         _133 = opaque::<u64>(move _134) -> [return: bb32, unwind continue];
 +         _133 = opaque::<u64>(_130) -> [return: bb32, unwind continue];
       }
   
       bb32: {
--         StorageDead(_134);
+          StorageDead(_134);
           StorageDead(_133);
           StorageLive(_137);
           _137 = &mut _3;
@@ -737,11 +784,11 @@
           StorageLive(_139);
           StorageLive(_140);
           _140 = (*_137);
--         StorageLive(_141);
--         _141 = _1;
+          StorageLive(_141);
+          _141 = _1;
 -         _139 = Add(move _140, move _141);
--         StorageDead(_141);
 +         _139 = Add(move _140, _1);
+          StorageDead(_141);
           StorageDead(_140);
           _138 = opaque::<u64>(move _139) -> [return: bb33, unwind continue];
       }
@@ -753,11 +800,11 @@
           StorageLive(_143);
           StorageLive(_144);
           _144 = (*_137);
--         StorageLive(_145);
--         _145 = _1;
+          StorageLive(_145);
+          _145 = _1;
 -         _143 = Add(move _144, move _145);
--         StorageDead(_145);
 +         _143 = Add(move _144, _1);
+          StorageDead(_145);
           StorageDead(_144);
           _142 = opaque::<u64>(move _143) -> [return: bb34, unwind continue];
       }
@@ -765,18 +812,18 @@
       bb34: {
           StorageDead(_143);
           StorageDead(_142);
--         StorageLive(_146);
+          StorageLive(_146);
           StorageLive(_147);
           _147 = &raw const _3;
           StorageLive(_148);
           StorageLive(_149);
           StorageLive(_150);
           _150 = (*_147);
--         StorageLive(_151);
--         _151 = _1;
+          StorageLive(_151);
+          _151 = _1;
 -         _149 = Add(move _150, move _151);
--         StorageDead(_151);
 +         _149 = Add(move _150, _1);
+          StorageDead(_151);
           StorageDead(_150);
           _148 = opaque::<u64>(move _149) -> [return: bb35, unwind continue];
       }
@@ -788,11 +835,11 @@
           StorageLive(_153);
           StorageLive(_154);
           _154 = (*_147);
--         StorageLive(_155);
--         _155 = _1;
+          StorageLive(_155);
+          _155 = _1;
 -         _153 = Add(move _154, move _155);
--         StorageDead(_155);
 +         _153 = Add(move _154, _1);
+          StorageDead(_155);
           StorageDead(_154);
           _152 = opaque::<u64>(move _153) -> [return: bb36, unwind continue];
       }
@@ -806,11 +853,11 @@
           StorageLive(_158);
           StorageLive(_159);
           _159 = (*_156);
--         StorageLive(_160);
--         _160 = _1;
+          StorageLive(_160);
+          _160 = _1;
 -         _158 = Add(move _159, move _160);
--         StorageDead(_160);
 +         _158 = Add(move _159, _1);
+          StorageDead(_160);
           StorageDead(_159);
           _157 = opaque::<u64>(move _158) -> [return: bb37, unwind continue];
       }
@@ -822,11 +869,11 @@
           StorageLive(_162);
           StorageLive(_163);
           _163 = (*_156);
--         StorageLive(_164);
--         _164 = _1;
+          StorageLive(_164);
+          _164 = _1;
 -         _162 = Add(move _163, move _164);
--         StorageDead(_164);
 +         _162 = Add(move _163, _1);
+          StorageDead(_164);
           StorageDead(_163);
           _161 = opaque::<u64>(move _162) -> [return: bb38, unwind continue];
       }
@@ -834,44 +881,50 @@
       bb38: {
           StorageDead(_162);
           StorageDead(_161);
--         _146 = const ();
+          _146 = const ();
           StorageDead(_156);
           StorageDead(_147);
--         StorageDead(_146);
+          StorageDead(_146);
           StorageLive(_165);
           _165 = &_3;
           StorageLive(_166);
 -         StorageLive(_167);
 -         StorageLive(_168);
++         nop;
++         nop;
           _168 = (*_165);
--         StorageLive(_169);
--         _169 = _1;
+          StorageLive(_169);
+          _169 = _1;
 -         _167 = Add(move _168, move _169);
--         StorageDead(_169);
++         _167 = Add(_168, _1);
+          StorageDead(_169);
 -         StorageDead(_168);
 -         _166 = opaque::<u64>(move _167) -> [return: bb39, unwind continue];
-+         _167 = Add(_168, _1);
++         nop;
 +         _166 = opaque::<u64>(_167) -> [return: bb39, unwind continue];
       }
   
       bb39: {
 -         StorageDead(_167);
++         nop;
           StorageDead(_166);
           StorageLive(_170);
--         StorageLive(_171);
--         StorageLive(_172);
+          StorageLive(_171);
+          StorageLive(_172);
 -         _172 = (*_165);
--         StorageLive(_173);
--         _173 = _1;
++         _172 = _168;
+          StorageLive(_173);
+          _173 = _1;
 -         _171 = Add(move _172, move _173);
--         StorageDead(_173);
--         StorageDead(_172);
++         _171 = _167;
+          StorageDead(_173);
+          StorageDead(_172);
 -         _170 = opaque::<u64>(move _171) -> [return: bb40, unwind continue];
 +         _170 = opaque::<u64>(_167) -> [return: bb40, unwind continue];
       }
   
       bb40: {
--         StorageDead(_171);
+          StorageDead(_171);
           StorageDead(_170);
           _0 = const ();
           StorageDead(_165);