955 lines
27 KiB
Diff
955 lines
27 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 _63: ();
|
|
let mut _64: u64;
|
|
let mut _65: u64;
|
|
let mut _66: u64;
|
|
let _67: ();
|
|
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: bool;
|
|
let _76: ();
|
|
let mut _77: u64;
|
|
let mut _78: u64;
|
|
let mut _79: u64;
|
|
let mut _80: bool;
|
|
let _81: ();
|
|
let mut _82: u64;
|
|
let mut _83: u64;
|
|
let mut _84: u64;
|
|
let _85: ();
|
|
let mut _86: u64;
|
|
let mut _87: u64;
|
|
let mut _88: u64;
|
|
let _89: ();
|
|
let mut _90: u64;
|
|
let mut _91: u64;
|
|
let mut _92: u64;
|
|
let _93: ();
|
|
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 _101: ();
|
|
let mut _102: u32;
|
|
let mut _103: u64;
|
|
let _104: ();
|
|
let mut _105: f32;
|
|
let mut _106: u64;
|
|
let _107: ();
|
|
let mut _108: S<u64>;
|
|
let mut _109: u64;
|
|
let _110: ();
|
|
let mut _111: u64;
|
|
let mut _112: S<u64>;
|
|
let mut _113: u64;
|
|
let _114: ();
|
|
let mut _115: u64;
|
|
let mut _116: u64;
|
|
let mut _117: u64;
|
|
let mut _118: u64;
|
|
let mut _119: u64;
|
|
let _120: ();
|
|
let mut _121: u64;
|
|
let mut _122: u64;
|
|
let mut _123: u64;
|
|
let mut _124: u64;
|
|
let mut _125: u64;
|
|
let _126: &u64;
|
|
let _127: ();
|
|
let mut _128: u64;
|
|
let mut _129: u64;
|
|
let mut _130: u64;
|
|
let _131: ();
|
|
let mut _132: u64;
|
|
let mut _133: u64;
|
|
let mut _134: u64;
|
|
let _136: ();
|
|
let mut _137: u64;
|
|
let mut _138: u64;
|
|
let mut _139: u64;
|
|
let _140: ();
|
|
let mut _141: u64;
|
|
let mut _142: u64;
|
|
let mut _143: u64;
|
|
let _144: ();
|
|
let _146: ();
|
|
let mut _147: u64;
|
|
let mut _148: u64;
|
|
let mut _149: u64;
|
|
let _150: ();
|
|
let mut _151: u64;
|
|
let mut _152: u64;
|
|
let mut _153: u64;
|
|
let _155: ();
|
|
let mut _156: u64;
|
|
let mut _157: u64;
|
|
let mut _158: u64;
|
|
let _159: ();
|
|
let mut _160: u64;
|
|
let mut _161: u64;
|
|
let mut _162: u64;
|
|
let _164: ();
|
|
let mut _165: u64;
|
|
let mut _166: u64;
|
|
let mut _167: u64;
|
|
let _168: ();
|
|
let mut _169: u64;
|
|
let mut _170: u64;
|
|
let mut _171: u64;
|
|
scope 1 {
|
|
debug a => _126;
|
|
let _135: &mut u64;
|
|
scope 2 {
|
|
debug b => _135;
|
|
let _145: *const u64;
|
|
let _163: &u64;
|
|
scope 3 {
|
|
debug c => _145;
|
|
let _154: *mut u64;
|
|
scope 4 {
|
|
debug d => _154;
|
|
}
|
|
}
|
|
scope 5 {
|
|
debug e => _163;
|
|
}
|
|
}
|
|
}
|
|
|
|
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 unreachable];
|
|
+ _4 = opaque::<u64>(_5) -> [return: bb1, unwind unreachable];
|
|
}
|
|
|
|
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 unreachable];
|
|
+ _8 = opaque::<u64>(_9) -> [return: bb2, unwind unreachable];
|
|
}
|
|
|
|
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 unreachable];
|
|
+ _12 = opaque::<u64>(_13) -> [return: bb3, unwind unreachable];
|
|
}
|
|
|
|
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 unreachable];
|
|
+ _20 = Eq(_2, const 0_u64);
|
|
+ assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb4, unwind unreachable];
|
|
}
|
|
|
|
bb4: {
|
|
- _17 = Div(move _18, move _19);
|
|
+ _17 = Div(_1, _2);
|
|
StorageDead(_19);
|
|
StorageDead(_18);
|
|
- _16 = opaque::<u64>(move _17) -> [return: bb5, unwind unreachable];
|
|
+ _16 = opaque::<u64>(_17) -> [return: bb5, unwind unreachable];
|
|
}
|
|
|
|
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 unreachable];
|
|
+ _25 = _20;
|
|
+ assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb6, unwind unreachable];
|
|
}
|
|
|
|
bb6: {
|
|
- _22 = Rem(move _23, move _24);
|
|
+ _22 = Rem(_1, _2);
|
|
StorageDead(_24);
|
|
StorageDead(_23);
|
|
- _21 = opaque::<u64>(move _22) -> [return: bb7, unwind unreachable];
|
|
+ _21 = opaque::<u64>(_22) -> [return: bb7, unwind unreachable];
|
|
}
|
|
|
|
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 unreachable];
|
|
+ _26 = opaque::<u64>(_27) -> [return: bb8, unwind unreachable];
|
|
}
|
|
|
|
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 unreachable];
|
|
+ _30 = opaque::<u64>(_31) -> [return: bb9, unwind unreachable];
|
|
}
|
|
|
|
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 unreachable];
|
|
+ _34 = opaque::<u64>(_35) -> [return: bb10, unwind unreachable];
|
|
}
|
|
|
|
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 unreachable];
|
|
+ _38 = opaque::<u64>(_39) -> [return: bb11, unwind unreachable];
|
|
}
|
|
|
|
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 unreachable];
|
|
+ _42 = opaque::<u64>(_43) -> [return: bb12, unwind unreachable];
|
|
}
|
|
|
|
bb12: {
|
|
- StorageDead(_43);
|
|
+ nop;
|
|
StorageDead(_42);
|
|
StorageLive(_46);
|
|
- 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>(_47) -> [return: bb13, unwind unreachable];
|
|
}
|
|
|
|
bb13: {
|
|
- StorageDead(_47);
|
|
+ nop;
|
|
StorageDead(_46);
|
|
StorageLive(_49);
|
|
- 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>(_50) -> [return: bb14, unwind unreachable];
|
|
}
|
|
|
|
bb14: {
|
|
- StorageDead(_50);
|
|
+ nop;
|
|
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 unreachable];
|
|
+ _52 = opaque::<S<u64>>(_53) -> [return: bb15, unwind unreachable];
|
|
}
|
|
|
|
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 unreachable];
|
|
+ _56 = _1;
|
|
+ _55 = opaque::<u64>(_1) -> [return: bb16, unwind unreachable];
|
|
}
|
|
|
|
bb16: {
|
|
StorageDead(_56);
|
|
StorageDead(_57);
|
|
StorageDead(_55);
|
|
StorageLive(_59);
|
|
StorageLive(_60);
|
|
StorageLive(_61);
|
|
_61 = _1;
|
|
StorageLive(_62);
|
|
_62 = _2;
|
|
- _60 = Add(move _61, move _62);
|
|
+ _60 = _5;
|
|
StorageDead(_62);
|
|
StorageDead(_61);
|
|
- _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);
|
|
StorageLive(_69);
|
|
_69 = _1;
|
|
StorageLive(_70);
|
|
_70 = _2;
|
|
- _68 = Sub(move _69, move _70);
|
|
+ _68 = _13;
|
|
StorageDead(_70);
|
|
StorageDead(_69);
|
|
- _67 = opaque::<u64>(move _68) -> [return: bb19, unwind unreachable];
|
|
+ _67 = opaque::<u64>(_13) -> [return: bb19, unwind unreachable];
|
|
}
|
|
|
|
bb19: {
|
|
StorageDead(_68);
|
|
StorageDead(_67);
|
|
StorageLive(_71);
|
|
StorageLive(_72);
|
|
StorageLive(_73);
|
|
_73 = _1;
|
|
StorageLive(_74);
|
|
_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);
|
|
StorageDead(_73);
|
|
- _71 = opaque::<u64>(move _72) -> [return: bb21, unwind unreachable];
|
|
+ _71 = opaque::<u64>(_17) -> [return: bb21, unwind unreachable];
|
|
}
|
|
|
|
bb21: {
|
|
StorageDead(_72);
|
|
StorageDead(_71);
|
|
StorageLive(_76);
|
|
StorageLive(_77);
|
|
StorageLive(_78);
|
|
_78 = _1;
|
|
StorageLive(_79);
|
|
_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];
|
|
}
|
|
|
|
bb22: {
|
|
- _77 = Rem(move _78, move _79);
|
|
+ _77 = _22;
|
|
StorageDead(_79);
|
|
StorageDead(_78);
|
|
- _76 = opaque::<u64>(move _77) -> [return: bb23, unwind unreachable];
|
|
+ _76 = opaque::<u64>(_22) -> [return: bb23, unwind unreachable];
|
|
}
|
|
|
|
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;
|
|
- _86 = BitOr(move _87, move _88);
|
|
+ _86 = _31;
|
|
StorageDead(_88);
|
|
StorageDead(_87);
|
|
- _85 = opaque::<u64>(move _86) -> [return: bb25, unwind unreachable];
|
|
+ _85 = opaque::<u64>(_31) -> [return: bb25, unwind unreachable];
|
|
}
|
|
|
|
bb25: {
|
|
StorageDead(_86);
|
|
StorageDead(_85);
|
|
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);
|
|
StorageLive(_95);
|
|
_95 = _1;
|
|
StorageLive(_96);
|
|
_96 = _2;
|
|
- _94 = Shl(move _95, move _96);
|
|
+ _94 = _39;
|
|
StorageDead(_96);
|
|
StorageDead(_95);
|
|
- _93 = opaque::<u64>(move _94) -> [return: bb27, unwind unreachable];
|
|
+ _93 = opaque::<u64>(_39) -> [return: bb27, unwind unreachable];
|
|
}
|
|
|
|
bb27: {
|
|
StorageDead(_94);
|
|
StorageDead(_93);
|
|
StorageLive(_97);
|
|
StorageLive(_98);
|
|
StorageLive(_99);
|
|
_99 = _1;
|
|
StorageLive(_100);
|
|
_100 = _2;
|
|
- _98 = Shr(move _99, move _100);
|
|
+ _98 = _43;
|
|
StorageDead(_100);
|
|
StorageDead(_99);
|
|
- _97 = opaque::<u64>(move _98) -> [return: bb28, unwind unreachable];
|
|
+ _97 = opaque::<u64>(_43) -> [return: bb28, unwind unreachable];
|
|
}
|
|
|
|
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;
|
|
- _105 = move _106 as f32 (IntToFloat);
|
|
+ _105 = _50;
|
|
StorageDead(_106);
|
|
- _104 = opaque::<f32>(move _105) -> [return: bb30, unwind unreachable];
|
|
+ _104 = opaque::<f32>(_50) -> [return: bb30, unwind unreachable];
|
|
}
|
|
|
|
bb30: {
|
|
StorageDead(_105);
|
|
StorageDead(_104);
|
|
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);
|
|
StorageLive(_113);
|
|
_113 = _1;
|
|
- _112 = S::<u64>(move _113);
|
|
+ _112 = _53;
|
|
StorageDead(_113);
|
|
- _111 = (_112.0: u64);
|
|
- _110 = opaque::<u64>(move _111) -> [return: bb32, unwind unreachable];
|
|
+ _111 = _1;
|
|
+ _110 = opaque::<u64>(_1) -> [return: bb32, unwind unreachable];
|
|
}
|
|
|
|
bb32: {
|
|
StorageDead(_111);
|
|
StorageDead(_112);
|
|
StorageDead(_110);
|
|
StorageLive(_114);
|
|
- StorageLive(_115);
|
|
+ nop;
|
|
StorageLive(_116);
|
|
StorageLive(_117);
|
|
_117 = _1;
|
|
StorageLive(_118);
|
|
_118 = _2;
|
|
- _116 = Mul(move _117, move _118);
|
|
+ _116 = _9;
|
|
StorageDead(_118);
|
|
StorageDead(_117);
|
|
StorageLive(_119);
|
|
_119 = _2;
|
|
- _115 = Sub(move _116, move _119);
|
|
+ _115 = Sub(_9, _2);
|
|
StorageDead(_119);
|
|
StorageDead(_116);
|
|
- _114 = opaque::<u64>(move _115) -> [return: bb33, unwind unreachable];
|
|
+ _114 = opaque::<u64>(_115) -> [return: bb33, unwind unreachable];
|
|
}
|
|
|
|
bb33: {
|
|
- StorageDead(_115);
|
|
+ nop;
|
|
StorageDead(_114);
|
|
StorageLive(_120);
|
|
StorageLive(_121);
|
|
StorageLive(_122);
|
|
StorageLive(_123);
|
|
_123 = _1;
|
|
StorageLive(_124);
|
|
_124 = _2;
|
|
- _122 = Mul(move _123, move _124);
|
|
+ _122 = _9;
|
|
StorageDead(_124);
|
|
StorageDead(_123);
|
|
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];
|
|
}
|
|
|
|
bb34: {
|
|
StorageDead(_121);
|
|
StorageDead(_120);
|
|
StorageLive(_126);
|
|
_126 = &_3;
|
|
StorageLive(_127);
|
|
- StorageLive(_128);
|
|
- StorageLive(_129);
|
|
+ nop;
|
|
+ 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;
|
|
+ _127 = opaque::<u64>(_128) -> [return: bb35, unwind unreachable];
|
|
}
|
|
|
|
bb35: {
|
|
- StorageDead(_128);
|
|
+ nop;
|
|
StorageDead(_127);
|
|
StorageLive(_131);
|
|
StorageLive(_132);
|
|
StorageLive(_133);
|
|
- _133 = (*_126);
|
|
+ _133 = _129;
|
|
StorageLive(_134);
|
|
_134 = _1;
|
|
- _132 = Add(move _133, move _134);
|
|
+ _132 = _128;
|
|
StorageDead(_134);
|
|
StorageDead(_133);
|
|
- _131 = opaque::<u64>(move _132) -> [return: bb36, unwind unreachable];
|
|
+ _131 = opaque::<u64>(_128) -> [return: bb36, unwind unreachable];
|
|
}
|
|
|
|
bb36: {
|
|
StorageDead(_132);
|
|
StorageDead(_131);
|
|
StorageLive(_135);
|
|
_135 = &mut _3;
|
|
StorageLive(_136);
|
|
StorageLive(_137);
|
|
StorageLive(_138);
|
|
_138 = (*_135);
|
|
StorageLive(_139);
|
|
_139 = _1;
|
|
- _137 = Add(move _138, move _139);
|
|
+ _137 = Add(move _138, _1);
|
|
StorageDead(_139);
|
|
StorageDead(_138);
|
|
_136 = opaque::<u64>(move _137) -> [return: bb37, unwind unreachable];
|
|
}
|
|
|
|
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);
|
|
_140 = opaque::<u64>(move _141) -> [return: bb38, unwind unreachable];
|
|
}
|
|
|
|
bb38: {
|
|
StorageDead(_141);
|
|
StorageDead(_140);
|
|
StorageLive(_144);
|
|
StorageLive(_145);
|
|
_145 = &raw const _3;
|
|
StorageLive(_146);
|
|
StorageLive(_147);
|
|
StorageLive(_148);
|
|
_148 = (*_145);
|
|
StorageLive(_149);
|
|
_149 = _1;
|
|
- _147 = Add(move _148, move _149);
|
|
+ _147 = Add(move _148, _1);
|
|
StorageDead(_149);
|
|
StorageDead(_148);
|
|
_146 = opaque::<u64>(move _147) -> [return: bb39, unwind unreachable];
|
|
}
|
|
|
|
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);
|
|
_150 = opaque::<u64>(move _151) -> [return: bb40, unwind unreachable];
|
|
}
|
|
|
|
bb40: {
|
|
StorageDead(_151);
|
|
StorageDead(_150);
|
|
StorageLive(_154);
|
|
_154 = &raw mut _3;
|
|
StorageLive(_155);
|
|
StorageLive(_156);
|
|
StorageLive(_157);
|
|
_157 = (*_154);
|
|
StorageLive(_158);
|
|
_158 = _1;
|
|
- _156 = Add(move _157, move _158);
|
|
+ _156 = Add(move _157, _1);
|
|
StorageDead(_158);
|
|
StorageDead(_157);
|
|
_155 = opaque::<u64>(move _156) -> [return: bb41, unwind unreachable];
|
|
}
|
|
|
|
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);
|
|
_159 = opaque::<u64>(move _160) -> [return: bb42, unwind unreachable];
|
|
}
|
|
|
|
bb42: {
|
|
StorageDead(_160);
|
|
StorageDead(_159);
|
|
_144 = const ();
|
|
StorageDead(_154);
|
|
StorageDead(_145);
|
|
StorageDead(_144);
|
|
StorageLive(_163);
|
|
_163 = &_3;
|
|
StorageLive(_164);
|
|
- StorageLive(_165);
|
|
- StorageLive(_166);
|
|
+ nop;
|
|
+ nop;
|
|
_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;
|
|
+ _164 = opaque::<u64>(_165) -> [return: bb43, unwind unreachable];
|
|
}
|
|
|
|
bb43: {
|
|
- StorageDead(_165);
|
|
+ nop;
|
|
StorageDead(_164);
|
|
StorageLive(_168);
|
|
StorageLive(_169);
|
|
StorageLive(_170);
|
|
- _170 = (*_163);
|
|
+ _170 = _166;
|
|
StorageLive(_171);
|
|
_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(_163);
|
|
StorageDead(_135);
|
|
StorageDead(_126);
|
|
return;
|
|
}
|
|
}
|
|
|