mirror of
https://github.com/rust-lang/rust.git
synced 2024-11-26 16:54:01 +00:00
945 lines
26 KiB
Diff
945 lines
26 KiB
Diff
- // MIR for `subexpression_elimination` before GVN
|
|
+ // MIR for `subexpression_elimination` after GVN
|
|
|
|
fn subexpression_elimination(_1: u64, _2: u64, _3: u64) -> () {
|
|
debug x => _1;
|
|
debug y => _2;
|
|
debug z => _3;
|
|
let mut _0: ();
|
|
let _4: ();
|
|
let mut _5: u64;
|
|
let mut _6: u64;
|
|
let mut _7: u64;
|
|
let _8: ();
|
|
let mut _9: u64;
|
|
let mut _10: u64;
|
|
let mut _11: u64;
|
|
let _12: ();
|
|
let mut _13: u64;
|
|
let mut _14: u64;
|
|
let mut _15: u64;
|
|
let _16: ();
|
|
let mut _17: u64;
|
|
let mut _18: u64;
|
|
let mut _19: u64;
|
|
let mut _20: bool;
|
|
let _21: ();
|
|
let mut _22: u64;
|
|
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: u64;
|
|
let _30: ();
|
|
let mut _31: u64;
|
|
let mut _32: u64;
|
|
let mut _33: u64;
|
|
let _34: ();
|
|
let mut _35: u64;
|
|
let mut _36: u64;
|
|
let mut _37: u64;
|
|
let _38: ();
|
|
let mut _39: u64;
|
|
let mut _40: u64;
|
|
let mut _41: u64;
|
|
let _42: ();
|
|
let mut _43: u64;
|
|
let mut _44: u64;
|
|
let mut _45: u64;
|
|
let _46: ();
|
|
let mut _47: u32;
|
|
let mut _48: u64;
|
|
let _49: ();
|
|
let mut _50: f32;
|
|
let mut _51: u64;
|
|
let _52: ();
|
|
let mut _53: S<u64>;
|
|
let mut _54: u64;
|
|
let _55: ();
|
|
let mut _56: u64;
|
|
let mut _57: S<u64>;
|
|
let mut _58: u64;
|
|
let _59: ();
|
|
let mut _60: u64;
|
|
let mut _61: u64;
|
|
let mut _62: u64;
|
|
let mut _63: u64;
|
|
let mut _64: u64;
|
|
let _65: ();
|
|
let mut _66: u64;
|
|
let mut _67: u64;
|
|
let mut _68: u64;
|
|
let mut _69: u64;
|
|
let mut _70: u64;
|
|
let _71: ();
|
|
let mut _72: u64;
|
|
let mut _73: u64;
|
|
let mut _74: u64;
|
|
let mut _75: u64;
|
|
let mut _76: u64;
|
|
let _77: ();
|
|
let mut _78: u64;
|
|
let mut _79: u64;
|
|
let mut _80: u64;
|
|
let mut _81: u64;
|
|
let mut _82: bool;
|
|
let mut _83: u64;
|
|
let _84: ();
|
|
let mut _85: u64;
|
|
let mut _86: u64;
|
|
let mut _87: u64;
|
|
let mut _88: u64;
|
|
let mut _89: bool;
|
|
let mut _90: u64;
|
|
let _91: ();
|
|
let mut _92: u64;
|
|
let mut _93: u64;
|
|
let mut _94: u64;
|
|
let mut _95: u64;
|
|
let mut _96: u64;
|
|
let _97: ();
|
|
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 mut _106: u64;
|
|
let mut _107: u64;
|
|
let mut _108: u64;
|
|
let _109: ();
|
|
let mut _110: u64;
|
|
let mut _111: u64;
|
|
let mut _112: u64;
|
|
let mut _113: u64;
|
|
let mut _114: u64;
|
|
let _115: ();
|
|
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 mut _123: u64;
|
|
let _124: ();
|
|
let mut _125: u64;
|
|
let mut _126: S<u64>;
|
|
let mut _127: u64;
|
|
let _128: &u64;
|
|
let _129: ();
|
|
let mut _130: u64;
|
|
let mut _131: u64;
|
|
let mut _132: u64;
|
|
let _133: ();
|
|
let mut _134: u64;
|
|
let mut _135: u64;
|
|
let mut _136: u64;
|
|
let _138: ();
|
|
let mut _139: u64;
|
|
let mut _140: u64;
|
|
let mut _141: u64;
|
|
let _142: ();
|
|
let mut _143: u64;
|
|
let mut _144: u64;
|
|
let mut _145: u64;
|
|
let _146: ();
|
|
let _148: ();
|
|
let mut _149: u64;
|
|
let mut _150: u64;
|
|
let mut _151: u64;
|
|
let _152: ();
|
|
let mut _153: u64;
|
|
let mut _154: u64;
|
|
let mut _155: u64;
|
|
let _157: ();
|
|
let mut _158: u64;
|
|
let mut _159: u64;
|
|
let mut _160: u64;
|
|
let _161: ();
|
|
let mut _162: u64;
|
|
let mut _163: u64;
|
|
let mut _164: u64;
|
|
let _166: ();
|
|
let mut _167: u64;
|
|
let mut _168: u64;
|
|
let mut _169: u64;
|
|
let _170: ();
|
|
let mut _171: u64;
|
|
let mut _172: u64;
|
|
let mut _173: u64;
|
|
scope 1 {
|
|
debug a => _128;
|
|
let _137: &mut u64;
|
|
scope 2 {
|
|
debug b => _137;
|
|
let _165: &u64;
|
|
scope 3 {
|
|
let _147: *const u64;
|
|
scope 4 {
|
|
debug c => _147;
|
|
let _156: *mut u64;
|
|
scope 5 {
|
|
debug d => _156;
|
|
}
|
|
}
|
|
}
|
|
scope 6 {
|
|
debug e => _165;
|
|
}
|
|
}
|
|
}
|
|
|
|
bb0: {
|
|
StorageLive(_4);
|
|
- StorageLive(_5);
|
|
+ nop;
|
|
StorageLive(_6);
|
|
_6 = _1;
|
|
StorageLive(_7);
|
|
_7 = _2;
|
|
- _5 = Add(move _6, move _7);
|
|
+ _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);
|
|
+ nop;
|
|
StorageLive(_10);
|
|
_10 = _1;
|
|
StorageLive(_11);
|
|
_11 = _2;
|
|
- _9 = Mul(move _10, move _11);
|
|
+ _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);
|
|
+ nop;
|
|
StorageLive(_14);
|
|
_14 = _1;
|
|
StorageLive(_15);
|
|
_15 = _2;
|
|
- _13 = Sub(move _14, move _15);
|
|
+ _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);
|
|
+ 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);
|
|
+ assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb4, unwind continue];
|
|
}
|
|
|
|
bb4: {
|
|
- _17 = Div(move _18, move _19);
|
|
+ _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);
|
|
+ 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);
|
|
+ _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);
|
|
+ nop;
|
|
StorageLive(_28);
|
|
_28 = _1;
|
|
StorageLive(_29);
|
|
_29 = _2;
|
|
- _27 = BitAnd(move _28, move _29);
|
|
+ _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);
|
|
+ nop;
|
|
StorageLive(_32);
|
|
_32 = _1;
|
|
StorageLive(_33);
|
|
_33 = _2;
|
|
- _31 = BitOr(move _32, move _33);
|
|
+ _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);
|
|
+ nop;
|
|
StorageLive(_36);
|
|
_36 = _1;
|
|
StorageLive(_37);
|
|
_37 = _2;
|
|
- _35 = BitXor(move _36, move _37);
|
|
+ _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);
|
|
+ nop;
|
|
StorageLive(_40);
|
|
_40 = _1;
|
|
StorageLive(_41);
|
|
_41 = _2;
|
|
- _39 = Shl(move _40, move _41);
|
|
+ _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);
|
|
+ nop;
|
|
StorageLive(_44);
|
|
_44 = _1;
|
|
StorageLive(_45);
|
|
_45 = _2;
|
|
- _43 = Shr(move _44, move _45);
|
|
+ _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;
|
|
- _47 = move _48 as u32 (IntToInt);
|
|
+ _47 = _1 as u32 (IntToInt);
|
|
StorageDead(_48);
|
|
_46 = opaque::<u32>(move _47) -> [return: bb13, unwind continue];
|
|
}
|
|
|
|
bb13: {
|
|
StorageDead(_47);
|
|
StorageDead(_46);
|
|
StorageLive(_49);
|
|
StorageLive(_50);
|
|
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];
|
|
}
|
|
|
|
bb14: {
|
|
StorageDead(_50);
|
|
StorageDead(_49);
|
|
StorageLive(_52);
|
|
- StorageLive(_53);
|
|
+ nop;
|
|
StorageLive(_54);
|
|
_54 = _1;
|
|
- _53 = S::<u64>(move _54);
|
|
+ _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;
|
|
- _57 = S::<u64>(move _58);
|
|
+ _57 = _53;
|
|
StorageDead(_58);
|
|
- _56 = (_57.0: u64);
|
|
- _55 = opaque::<u64>(move _56) -> [return: bb16, unwind continue];
|
|
+ _56 = _1;
|
|
+ _55 = opaque::<u64>(_1) -> [return: bb16, unwind continue];
|
|
}
|
|
|
|
bb16: {
|
|
StorageDead(_56);
|
|
StorageDead(_57);
|
|
StorageDead(_55);
|
|
StorageLive(_59);
|
|
StorageLive(_60);
|
|
StorageLive(_61);
|
|
StorageLive(_62);
|
|
_62 = _1;
|
|
StorageLive(_63);
|
|
_63 = _2;
|
|
- _61 = Add(move _62, move _63);
|
|
+ _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);
|
|
_59 = opaque::<u64>(move _60) -> [return: bb17, unwind continue];
|
|
}
|
|
|
|
bb17: {
|
|
StorageDead(_60);
|
|
StorageDead(_59);
|
|
StorageLive(_65);
|
|
StorageLive(_66);
|
|
StorageLive(_67);
|
|
StorageLive(_68);
|
|
_68 = _1;
|
|
StorageLive(_69);
|
|
_69 = _2;
|
|
- _67 = Mul(move _68, move _69);
|
|
+ _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);
|
|
_65 = opaque::<u64>(move _66) -> [return: bb18, unwind continue];
|
|
}
|
|
|
|
bb18: {
|
|
StorageDead(_66);
|
|
StorageDead(_65);
|
|
StorageLive(_71);
|
|
StorageLive(_72);
|
|
StorageLive(_73);
|
|
StorageLive(_74);
|
|
_74 = _1;
|
|
StorageLive(_75);
|
|
_75 = _2;
|
|
- _73 = Sub(move _74, move _75);
|
|
+ _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);
|
|
_71 = opaque::<u64>(move _72) -> [return: bb19, unwind continue];
|
|
}
|
|
|
|
bb19: {
|
|
StorageDead(_72);
|
|
StorageDead(_71);
|
|
StorageLive(_77);
|
|
StorageLive(_78);
|
|
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);
|
|
+ _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);
|
|
_77 = opaque::<u64>(move _78) -> [return: bb21, unwind continue];
|
|
}
|
|
|
|
bb21: {
|
|
StorageDead(_78);
|
|
StorageDead(_77);
|
|
StorageLive(_84);
|
|
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;
|
|
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];
|
|
}
|
|
|
|
bb23: {
|
|
StorageDead(_85);
|
|
StorageDead(_84);
|
|
StorageLive(_91);
|
|
StorageLive(_92);
|
|
StorageLive(_93);
|
|
StorageLive(_94);
|
|
_94 = _1;
|
|
StorageLive(_95);
|
|
_95 = _2;
|
|
- _93 = BitAnd(move _94, move _95);
|
|
+ _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);
|
|
_91 = opaque::<u64>(move _92) -> [return: bb24, unwind continue];
|
|
}
|
|
|
|
bb24: {
|
|
StorageDead(_92);
|
|
StorageDead(_91);
|
|
StorageLive(_97);
|
|
StorageLive(_98);
|
|
StorageLive(_99);
|
|
StorageLive(_100);
|
|
_100 = _1;
|
|
StorageLive(_101);
|
|
_101 = _2;
|
|
- _99 = BitOr(move _100, move _101);
|
|
+ _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);
|
|
_97 = opaque::<u64>(move _98) -> [return: bb25, unwind continue];
|
|
}
|
|
|
|
bb25: {
|
|
StorageDead(_98);
|
|
StorageDead(_97);
|
|
StorageLive(_103);
|
|
StorageLive(_104);
|
|
StorageLive(_105);
|
|
StorageLive(_106);
|
|
_106 = _1;
|
|
StorageLive(_107);
|
|
_107 = _2;
|
|
- _105 = BitXor(move _106, move _107);
|
|
+ _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);
|
|
_103 = opaque::<u64>(move _104) -> [return: bb26, unwind continue];
|
|
}
|
|
|
|
bb26: {
|
|
StorageDead(_104);
|
|
StorageDead(_103);
|
|
StorageLive(_109);
|
|
StorageLive(_110);
|
|
StorageLive(_111);
|
|
StorageLive(_112);
|
|
_112 = _1;
|
|
StorageLive(_113);
|
|
_113 = _2;
|
|
- _111 = Shl(move _112, move _113);
|
|
+ _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);
|
|
_109 = opaque::<u64>(move _110) -> [return: bb27, unwind continue];
|
|
}
|
|
|
|
bb27: {
|
|
StorageDead(_110);
|
|
StorageDead(_109);
|
|
StorageLive(_115);
|
|
StorageLive(_116);
|
|
StorageLive(_117);
|
|
StorageLive(_118);
|
|
_118 = _1;
|
|
StorageLive(_119);
|
|
_119 = _2;
|
|
- _117 = Shr(move _118, move _119);
|
|
+ _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);
|
|
_115 = opaque::<u64>(move _116) -> [return: bb28, unwind continue];
|
|
}
|
|
|
|
bb28: {
|
|
StorageDead(_116);
|
|
StorageDead(_115);
|
|
StorageLive(_121);
|
|
StorageLive(_122);
|
|
StorageLive(_123);
|
|
_123 = _1;
|
|
- _122 = S::<u64>(move _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(_121);
|
|
StorageLive(_124);
|
|
StorageLive(_125);
|
|
StorageLive(_126);
|
|
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);
|
|
+ nop;
|
|
_128 = &_3;
|
|
StorageLive(_129);
|
|
- StorageLive(_130);
|
|
- StorageLive(_131);
|
|
+ nop;
|
|
+ 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];
|
|
}
|
|
|
|
bb31: {
|
|
- StorageDead(_130);
|
|
+ nop;
|
|
StorageDead(_129);
|
|
StorageLive(_133);
|
|
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: {
|
|
StorageDead(_134);
|
|
StorageDead(_133);
|
|
- StorageLive(_137);
|
|
+ nop;
|
|
_137 = &mut _3;
|
|
StorageLive(_138);
|
|
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: {
|
|
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];
|
|
}
|
|
|
|
bb34: {
|
|
StorageDead(_143);
|
|
StorageDead(_142);
|
|
StorageLive(_146);
|
|
- StorageLive(_147);
|
|
+ nop;
|
|
_147 = &raw const _3;
|
|
StorageLive(_148);
|
|
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: {
|
|
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];
|
|
}
|
|
|
|
bb36: {
|
|
StorageDead(_153);
|
|
StorageDead(_152);
|
|
- StorageLive(_156);
|
|
+ nop;
|
|
_156 = &raw mut _3;
|
|
StorageLive(_157);
|
|
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: {
|
|
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];
|
|
}
|
|
|
|
bb38: {
|
|
StorageDead(_162);
|
|
StorageDead(_161);
|
|
_146 = const ();
|
|
- StorageDead(_156);
|
|
- StorageDead(_147);
|
|
+ nop;
|
|
+ nop;
|
|
StorageDead(_146);
|
|
- StorageLive(_165);
|
|
+ nop;
|
|
_165 = &_3;
|
|
StorageLive(_166);
|
|
- StorageLive(_167);
|
|
- StorageLive(_168);
|
|
+ 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];
|
|
+ nop;
|
|
+ _166 = opaque::<u64>(_167) -> [return: bb39, unwind continue];
|
|
}
|
|
|
|
bb39: {
|
|
- StorageDead(_167);
|
|
+ nop;
|
|
StorageDead(_166);
|
|
StorageLive(_170);
|
|
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: {
|
|
StorageDead(_171);
|
|
StorageDead(_170);
|
|
_0 = const ();
|
|
- StorageDead(_165);
|
|
- StorageDead(_137);
|
|
- StorageDead(_128);
|
|
+ nop;
|
|
+ nop;
|
|
+ nop;
|
|
return;
|
|
}
|
|
}
|
|
|