Online Solidity Decompiler

« Decompile another contract

Address

0x62613aa9594d0116b5ca23acd37dddac90c67e5c [etherscan.io | etherchain.org]

Public Methods

No public methods detected.

Internal Methods

func_0295(arg0, arg1, arg2, arg3, arg4)
func_0623(arg0, arg1, arg4)
func_084E(arg0) returns (r0)
func_0E8E(arg0, arg1, arg2) returns (r0, r1, r2)
func_102F(arg0, arg1, arg2) returns (r0, r1, r2)
func_1650(arg0, arg1) returns (r0)
func_1971(arg0, arg1, arg2)
func_1FB4(arg0, arg1) returns (r0, r1, r2)
func_20E2(arg0) returns (r0)
func_20F2() returns (r0)
func_211A() returns (r0)
func_213D(arg0, arg1) returns (r0)
func_219B(arg0) returns (r0, r1, r2)
func_21D2(arg0, arg1) returns (r0, r1)
func_2203(arg0)
func_224E(arg0)
func_226A(arg0, arg1)
func_22AB(arg0) returns (r0)
func_22E5(arg0, arg1) returns (r0)
func_232C(arg0) returns (r0, r1, r2, r3, r4)
func_2434(arg0) returns (r0)
func_244C(arg0, arg1, arg2) returns (r0)
func_24C3() returns (r0)
func_24F3(arg0, arg1, arg2, arg3) returns (r0)
func_25F2(arg0, arg1) returns (r0)
func_268A(arg0, arg1, arg2) returns (r0)
func_26C7(arg0, arg1, arg2, arg3, arg4, arg5) returns (r0)
func_277C(arg0, arg1, arg2, arg3, arg4, arg5, arg6) returns (r0)
func_2833()
func_2850(arg0) returns (r0)

Decompilation

This might be constructor bytecode - to get at the deployed contract, go back and remove the constructor prefix, usually up to the next 6060 or 6080.
contract Contract { function main() { memory[0x40:0x60] = 0x80; var var0 = 0x04; var var1 = 0x40; if (msg.data.length < var0) { revert(memory[0x00:0x00]); } var temp0 = var0; var0 = 0x00; var var3 = temp0; var var2 = msg.data[var0:var0 + 0x20] >> 0xe0; if (var2 == 0xfdd58e) { if (msg.value) { label_0172: var temp1 = var0; revert(memory[temp1:temp1 + temp1]); } else if (msg.data.length + ~0x03 i< var1) { goto label_0172; } else { var2 = var1; var1 = 0x20; var3 = 0x20eb; var var4 = 0x20e2; var4 = func_20F2(); var3 = func_20E2(var4); var temp2 = memory[var2:var2 + 0x20]; memory[temp2:temp2 + 0x20] = var3; return memory[temp2:temp2 + var1]; } } else if (var2 == 0x01ffc9a7) { var2 = var3; if (msg.value) { label_079A: var temp3 = var0; revert(memory[temp3:temp3 + temp3]); } else if (msg.data.length + ~0x03 i< 0x20) { goto label_079A; } else { var temp4 = msg.data[var2:var2 + 0x20]; var2 = var1; var1 = temp4 & 0xffffffff00000000000000000000000000000000000000000000000000000000; if (temp4 - var1) { goto label_079A; } var0 = 0x20; var temp5 = var1 == 0x01ffc9a700000000000000000000000000000000000000000000000000000000; var3 = var1; var1 = temp5; if (var1) { goto label_205E; } var1 = var3 == 0xd9b67a2600000000000000000000000000000000000000000000000000000000; label_205E: if (var1) { goto label_2065; } var1 = var3 == 0x0e89341c00000000000000000000000000000000000000000000000000000000; var3 = code.length; label_2065: var temp6 = memory[var2:var2 + 0x20]; memory[temp6:temp6 + 0x20] = !!var1; return memory[temp6:temp6 + var0]; } } else if (var2 == 0x06fdde03) { if (msg.value) { goto label_0172; } if (msg.data.length + ~0x03 i< var0) { goto label_0172; } var temp7 = memory[var1:var1 + 0x20]; var2 = temp7; var3 = var1; var1 = 0x0ec8; var4 = 0x1fb4; var var5 = var2; func_2203(var5); var1, var2, var3 = func_1FB4(var2, var3); label_0EC8: return memory[var1:var1 + var3 - var2]; } else if (var2 == 0x0e89341c) { var temp8 = var1; var1 = var3; var2 = temp8; if (msg.value) { goto label_079A; } var temp9 = var1; var1 = 0x20; var3 = temp9; if (msg.data.length + ~0x03 i< var1) { label_0DA0: var temp10 = var0; revert(memory[temp10:temp10 + temp10]); } else { var temp11 = var0; memory[temp11:temp11 + 0x20] = msg.data[var3:var3 + 0x20]; memory[var1:var1 + 0x20] = 0x02; var temp12 = var2; var0 = memory[temp12:temp12 + 0x20]; var4 = temp11; var3 = var0; var5 = keccak256(memory[var4:var4 + temp12]); var var7 = var4; var var6 = storage[var5]; var var8 = 0x1edd; var var9 = var6; var8 = func_2850(var9); var temp13 = var8; var temp14 = var5; var5 = temp13; var8 = temp14; memory[var3:var3 + 0x20] = var5; var temp15 = var6; var6 = 0x01; var var10 = var1; var var11 = temp15; var9 = var11 & var6; if (var9 == 0x00) { var temp16 = var3; var temp17 = var10; memory[temp17 + temp16:temp17 + temp16 + 0x20] = var11 & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00; var4 = temp17 + temp16 + (!!var5 << 0x05); var5 = temp16; var6 = 0x102f; var7 = 0x0ec8; var8 = code.length; label_1EFB: var9 = var3; var10 = var1; var11 = 0x0ec8; var var12 = var2; var var13 = 0x102f; var var14 = var4 - var9; var var15 = var9; func_226A(var14, var15); var9, var10, var11 = func_102F(var9, var10, var12); goto label_0EC8; } else if (var9 == 0x01) { var4 = var1; var temp18 = var7; var temp19 = var5; var5 = temp18; var temp20 = var6; var6 = temp19; var7 = temp20; memory[var5:var5 + 0x20] = var8; var8 = keccak256(memory[var5:var5 + var4]); if (var5 >= var6) { goto label_1F21; } label_1F33: var temp21 = var8; var temp22 = var5; var temp23 = var4; memory[temp23 + var0 + temp22:temp23 + var0 + temp22 + 0x20] = storage[temp21]; var3 = var0; var4 = var1; var5 = temp22 + temp23; var8 = var7 + temp21; if (var5 < var6) { goto label_1F33; } label_1F21: var4 = var3 + var5 + var4; var5 = var3; var6 = 0x102f; var7 = 0x0ec8; var8 = code.length; goto label_1EFB; } else { goto label_1EFB; } } } else if (var2 == 0x1102fb57) { if (msg.value) { goto label_0172; } if (msg.data.length + ~0x03 i< var0) { goto label_0172; } var temp24 = memory[var1:var1 + 0x20]; memory[temp24:temp24 + 0x20] = storage[var0] & 0xffffffffffffffffffffffffffffffffffffffff; return memory[temp24:temp24 + 0x20]; } else if (var2 == 0x156e29f6) { var temp25 = var1; var1 = var3; var2 = temp25; if (msg.value) { goto label_079A; } var3 = 0x1b6d; var4 = msg.data.length; var3, var4, var5 = func_219B(var4); var temp26 = var5; var5 = var4; var4 = temp26; var temp27 = var2; var2 = var3; var3 = 0xffffffffffffffffffffffffffffffffffffffff; var6 = temp27; if (!(msg.sender - (storage[var0] & var3))) { goto label_1B92; } if (!(msg.sender - (storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] & var3))) { label_1B92: var7 = var3; var3 = memory[var6:var6 + 0x20]; var8 = 0x1b9e; var9 = var3; func_224E(var9); memory[var3:var3 + 0x20] = var0; if (var5 > 0x7fffffffffffffffffffffff) { label_076F: var temp28 = var0; memory[temp28:temp28 + 0x20] = 0x8ceeefe200000000000000000000000000000000000000000000000000000000; revert(memory[temp28:temp28 + var1]); } else if (!(var2 & var7)) { var temp29 = var0; memory[temp29:temp29 + 0x20] = 0x2e07630000000000000000000000000000000000000000000000000000000000; revert(memory[temp29:temp29 + var1]); } else if (!var4) { var temp30 = var0; memory[temp30:temp30 + 0x20] = 0xb562e8dd00000000000000000000000000000000000000000000000000000000; revert(memory[temp30:temp30 + var1]); } else { var temp31 = var5; memory[0x00:0x20] = ((var2 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp31 >> 0x03) | (0x07 << 0xfd); var temp32 = (temp31 << 0x05) & 0xe0; var7 = (storage[keccak256(memory[0x00:0x20])] & (0xffff << temp32)) >> temp32; var temp33 = var7; var temp34 = temp33 + var4; var8 = temp34; var7 = 0xffff; var9 = temp33; if (var8 > var7) { label_0684: var temp35 = var0; memory[temp35:temp35 + 0x20] = 0xb6cdf5d000000000000000000000000000000000000000000000000000000000; revert(memory[temp35:temp35 + var1]); } else if (var8 < var9) { label_1DCB: var temp36 = var0; memory[temp36:temp36 + 0x20] = 0xb6cdf5d000000000000000000000000000000000000000000000000000000000; revert(memory[temp36:temp36 + var1]); } else { var temp37 = var5; memory[0x00:0x20] = ((var2 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp37 >> 0x03) | (0x07 << 0xfd); var temp38 = keccak256(memory[0x00:0x20]); memory[0x00:0x20] = temp38; var temp39 = (temp37 << 0x05) & 0xe0; storage[temp38] = (~(0xffff << temp39) & storage[temp38]) | (var8 << temp39); var temp40 = var5; memory[0x00:0x20] = ((var2 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp40 >> 0x03) | (0x07 << 0xfd); var temp41 = (temp40 << 0x05) & 0xe0; var8 = ((storage[keccak256(memory[0x00:0x20])] & (0xffff0000 << temp41)) >> temp41) >> 0x10; var temp42 = var7; var7 = var8 + var4; if (var7 > temp42) { goto label_1DCB; } if (var7 < var8) { var temp43 = var0; memory[temp43:temp43 + 0x20] = 0xb6cdf5d000000000000000000000000000000000000000000000000000000000; revert(memory[temp43:temp43 + var1]); } else { var temp44 = var6; var6 = var2; var8 = temp44; var temp45 = var7; var7 = var0; var temp46 = var5; memory[0x00:0x20] = ((var6 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp46 >> 0x03) | (0x07 << 0xfd); var temp47 = keccak256(memory[0x00:0x20]); memory[0x00:0x20] = temp47; var temp48 = (temp46 << 0x05) & 0xe0; storage[temp47] = (~(0xffff0000 << temp48) & storage[temp47]) | ((temp45 << 0x10) << temp48); var temp49 = var8; var temp50 = memory[temp49:temp49 + 0x20]; memory[temp50:temp50 + 0x20] = var5; memory[temp50 + 0x20:temp50 + 0x20 + 0x20] = var4; log(memory[temp50:temp50 + temp49], [0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62, msg.sender, stack[-2], stack[-3]]); if (address(var2).code.length) { var temp51 = var2; var2 = 0x1d97; var6 = temp51; var2 = func_24F3(var3, var4, var5, var6); if (!var2) { label_0534: var temp52 = var0; memory[temp52:temp52 + 0x20] = 0x9c05499b00000000000000000000000000000000000000000000000000000000; revert(memory[temp52:temp52 + var1]); } else { var2 = var1; var3 = var2; var4 = var3; var5 = var4; var temp53 = var0; return memory[temp53:temp53 + temp53]; } } else { var temp54 = var0; return memory[temp54:temp54 + temp54]; } } } } } else { var temp55 = memory[var6:var6 + 0x20]; memory[temp55:temp55 + 0x20] = 0xea8e4eb500000000000000000000000000000000000000000000000000000000; revert(memory[temp55:temp55 + var1]); } } else if (var2 == 0x25692962) { var4 = var0; if (msg.data.length + ~0x03 i< var4) { label_082B: var temp56 = var4; revert(memory[temp56:temp56 + temp56]); } else { memory[0x0c:0x2c] = 0x389a75e1; var temp57 = var4; memory[temp57:temp57 + 0x20] = msg.sender; storage[keccak256(memory[0x0c:0x2c])] = block.timestamp + 0x02a300; log(memory[temp57:temp57 + temp57], [0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d, msg.sender]); return memory[temp57:temp57 + temp57]; } } else if (var2 == 0x2eb2c2d6) { var temp58 = var1; var1 = var3; var2 = temp58; if (msg.value) { goto label_079A; } if (msg.data.length + ~0x03 i< 0xa0) { goto label_079A; } var3 = 0x16e9; var3 = func_20F2(); var temp59 = var2; var2 = var3; var3 = temp59; var4 = 0x16f2; var4 = func_211A(); var5 = 0xffffffffffffffff; var6 = msg.data[0x44:0x64]; if (var6 > var5) { label_11FF: var temp60 = var0; revert(memory[temp60:temp60 + temp60]); } else { var temp61 = var6; var6 = 0x1712; var7 = msg.data.length; var8 = var1 + temp61; var6, var7 = func_21D2(var7, var8); var temp62 = var6; var6 = var7; var7 = temp62; var8 = msg.data[0x64:0x84]; if (var8 > var5) { label_16A3: var temp63 = var0; revert(memory[temp63:temp63 + temp63]); } else { var temp64 = var8; var8 = 0x172a; var9 = msg.data.length; var10 = var1 + temp64; var8, var9 = func_21D2(var9, var10); var temp65 = var4; var4 = var9; var temp66 = var8; var8 = temp65; var temp67 = var5; var5 = temp66; var9 = msg.data[0x84:0xa4]; if (var9 > temp67) { var temp68 = var0; revert(memory[temp68:temp68 + temp68]); } else { var temp69 = var9; var9 = 0x1744; var10 = msg.data.length; var11 = var1 + temp69; var9 = func_22E5(var10, var11); var temp70 = var9; var9 = var3; var3 = temp70; var10 = var8 & 0xffffffffffffffffffffffffffffffffffffffff; var11 = 0xffffffffffffffffffffffffffffffffffffffff; if (!var10) { var temp71 = var0; memory[temp71:temp71 + 0x20] = 0xea553b3400000000000000000000000000000000000000000000000000000000; revert(memory[temp71:temp71 + var1]); } else if (var6 - var4) { var temp72 = var0; memory[temp72:temp72 + 0x20] = 0xa24a13a600000000000000000000000000000000000000000000000000000000; revert(memory[temp72:temp72 + var1]); } else { var temp73 = var2 & var11; var temp74 = var10; var10 = temp73; var11 = temp74; if (!(var10 - msg.sender)) { goto label_1776; } memory[0x00:0x20] = var2 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = msg.sender | 0xd000000000000000000000000000000000000000000000000000000000000000; var temp75 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = temp75; if (storage[temp75]) { label_1776: var temp76 = var9; var9 = var8; var temp77 = var10; var10 = var2; var temp78 = var11; var11 = temp76; var12 = temp78 != temp77; var13 = var0; if (var13 >= var6) { goto label_1788; } label_1809: var temp79 = var11; var11 = var13; var9 = temp79; var10 = var12; var12 = 0x1819; var13 = var11; var14 = var6; var15 = var7; var12 = func_244C(var13, var14, var15); var12 = msg.data[var12:var12 + 0x20]; var13 = 0x1825; var14 = var11; var15 = var4; var var16 = var5; var13 = func_244C(var14, var15, var16); var temp80 = msg.data[var13:var13 + 0x20]; var temp81 = var12; var13 = temp81; var12 = temp80; if (var13 > 0x7fffffffffffffffffffffff) { var temp82 = var0; memory[temp82:temp82 + 0x20] = 0x8ceeefe200000000000000000000000000000000000000000000000000000000; revert(memory[temp82:temp82 + var1]); } else { var temp83 = var13; memory[0x00:0x20] = ((var2 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp83 >> 0x03) | (0x07 << 0xfd); var temp84 = (temp83 << 0x05) & 0xe0; var14 = (storage[keccak256(memory[0x00:0x20])] & (0xffff << temp84)) >> temp84; var temp85 = var14; var temp86 = var12; var14 = temp86; var12 = temp85; if (var14 > var12) { var temp87 = var0; memory[temp87:temp87 + 0x20] = 0x169b037b00000000000000000000000000000000000000000000000000000000; revert(memory[temp87:temp87 + var1]); } else if (var10) { var15 = var14; var temp88 = var13; memory[0x00:0x20] = ((var8 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp88 >> 0x03) | (0x07 << 0xfd); var temp89 = (temp88 << 0x05) & 0xe0; var16 = (storage[keccak256(memory[0x00:0x20])] & (0xffff << temp89)) >> temp89; var temp90 = var16 + var15; var15 = var12; var12 = temp90; if (var12 > 0xffff) { var temp91 = var0; memory[temp91:temp91 + 0x20] = 0xb6cdf5d000000000000000000000000000000000000000000000000000000000; revert(memory[temp91:temp91 + var1]); } else { var temp92 = var15; var temp93 = var13; var15 = temp93; var temp94 = var11; var11 = 0x01; var temp95 = var12; var12 = temp94; var temp96 = var14; var14 = temp95; var13 = 0x19cb; memory[0x00:0x20] = ((var2 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (var15 >> 0x03) | (0x07 << 0xfd); var temp97 = keccak256(memory[0x00:0x20]); memory[0x00:0x20] = temp97; var temp98 = (var15 << 0x05) & 0xe0; storage[temp97] = (~(0xffff << temp98) & storage[temp97]) | (temp92 - temp96 << temp98); func_1971(var8, var14, var15); var temp99 = var11; var11 = var12; var12 = temp99; var13 = code.length; var14 = var13; label_189A: var temp100 = var11 + 0x01; var11 = var9; var12 = var10; var9 = var8; var13 = temp100; var10 = var2; if (var13 < var6) { goto label_1809; } label_1788: var temp101 = var11; var temp102 = memory[temp101:temp101 + 0x20]; memory[temp102:temp102 + 0x20] = temp101; var temp103 = var6; var temp104 = temp103 << 0x05; memory[temp102 + 0x20:temp102 + 0x20 + 0x20] = temp104 + 0x60; memory[temp102 + temp101:temp102 + temp101 + 0x20] = temp103; memory[temp102 + 0x60:temp102 + 0x60 + temp104] = msg.data[var7:var7 + temp104]; var temp105 = temp102 + temp104; var temp106 = var4; memory[temp105 + 0x60:temp105 + 0x60 + 0x20] = temp106; var temp107 = temp106 << 0x05; memory[temp105 + 0x80:temp105 + 0x80 + temp107] = msg.data[var5:var5 + temp107]; log(memory[temp102:temp102 + (temp106 << 0x06) + 0x80], [0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb, msg.sender, stack[-4], stack[-5]]); if (address(var8).code.length) { var temp108 = var2; var2 = 0x17f9; var9 = temp108; var2 = func_277C(var3, var4, var5, var6, var7, var8, var9); if (!var2) { goto label_0534; } var2 = var1; var3 = var2; var4 = var3; var5 = var4; var6 = var5; var7 = var6; var8 = var7; var temp109 = var0; return memory[temp109:temp109 + temp109]; } else { var temp110 = var0; return memory[temp110:temp110 + temp110]; } } } else { goto label_189A; } } } else { var temp111 = var0; memory[temp111:temp111 + 0x20] = 0x59c896be00000000000000000000000000000000000000000000000000000000; revert(memory[temp111:temp111 + var1]); } } } } } } else if (var2 == 0x4e1273f4) { var2 = var0; if (msg.value) { goto label_0172; } if (msg.data.length + ~0x03 i< var1) { goto label_0172; } var4 = var2; var2 = 0xffffffffffffffff; var5 = msg.data[var3:var3 + 0x20]; if (var5 > var2) { goto label_0172; } var temp112 = var5; var5 = 0x154d; var6 = msg.data.length; var7 = var3 + temp112; var5, var6 = func_21D2(var6, var7); var temp113 = var4; var4 = var6; var temp114 = var5; var5 = temp113; var temp115 = var2; var2 = temp114; var6 = 0x24; var7 = msg.data[var6:var6 + 0x20]; if (var7 > temp115) { goto label_079A; } var temp116 = var7; var7 = 0x1569; var8 = msg.data.length; var9 = var3 + temp116; var7, var8 = func_21D2(var8, var9); var temp117 = var8; var temp118 = var2; var2 = temp117; var temp119 = var7; var7 = temp118; var temp120 = var3; var3 = temp119; var8 = temp120; if (var4 - var2) { var temp121 = var5; memory[temp121:temp121 + 0x20] = 0xa24a13a600000000000000000000000000000000000000000000000000000000; revert(memory[temp121:temp121 + var8]); } else { var9 = 0x1581; var temp122 = var1; var1 = var4; var temp123 = var2; var2 = temp122; var temp124 = var3; var3 = temp123; var temp125 = var5; var5 = temp124; var10 = var1; var4 = temp125; var9 = func_2434(var10); var temp126 = var9; var9 = var5; var10 = 0x158e; var5 = memory[var2:var2 + 0x20]; var11 = temp126; var12 = var5; func_226A(var11, var12); memory[var5:var5 + 0x20] = var1; var10 = 0x159a; var11 = var1; var10 = func_2434(var11); var temp127 = var10; var10 = var3; var temp128 = var1; var11 = temp128; var1 = 0x20; var3 = var5 + var1; var temp129 = temp127 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0; memory[var3:var3 + temp129] = msg.data[msg.data.length:msg.data.length + temp129]; var12 = var4; if (var12 >= var11) { goto label_15D1; } label_1612: var13 = 0x1623; var14 = var12; var15 = var11; var temp130 = var4; var4 = var1; var temp131 = var5; var5 = temp130; var temp132 = var3; var3 = temp131; var temp133 = var2; var2 = temp132; var1 = temp133; var16 = var7; var13 = func_244C(var14, var15, var16); var temp134 = msg.data[var13:var13 + 0x20]; var13 = temp134; if (var13 - (var13 & 0xffffffffffffffffffffffffffffffffffffffff)) { goto label_16A3; } var14 = var13; var13 = 0x1657; var15 = 0x1650; var16 = var12; var var17 = var10; var var18 = var9; var15 = func_244C(var16, var17, var18); var13 = func_1650(var14, var15); if (var12 >= memory[var3:var3 + 0x20]) { var temp135 = var5; memory[temp135:temp135 + 0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[var8:var8 + 0x20] = 0x32; revert(memory[temp135:temp135 + var6]); } else { var temp136 = var12; var temp137 = var3; memory[var4 + temp137 + (temp136 << 0x05):var4 + temp137 + (temp136 << 0x05) + 0x20] = var13; var temp138 = var1; var1 = var4; var temp139 = var2; var2 = temp138; var3 = temp139; var temp140 = var5; var5 = temp137; var4 = temp140; var12 = temp136 + 0x01; if (var12 < var11) { goto label_1612; } label_15D1: var temp141 = var2; var temp142 = memory[temp141:temp141 + 0x20]; var temp143 = var1; var1 = temp142; var6 = temp143; var2 = var1; memory[var2:var2 + 0x20] = var6; var temp144 = memory[var5:var5 + 0x20]; var5 = temp144; memory[var2 + var6:var2 + var6 + 0x20] = var5; var temp145 = var3; var3 = var2 + temp141; var temp146 = var4; var4 = temp145; var7 = temp146; if (var7 >= var5) { goto label_15F4; } label_15FB: var temp147 = var4; var temp148 = var3; memory[temp148:temp148 + 0x20] = memory[temp147:temp147 + 0x20]; var2 = var1; var temp149 = var6; var3 = temp149 + temp148; var4 = temp149 + temp147; var7 = var7 + 0x01; if (var7 < var5) { goto label_15FB; } label_15F4: return memory[var1:var1 + var3 - var2]; } } } else if (var2 == 0x54d1f13d) { var4 = var0; if (msg.data.length + ~0x03 i< var4) { goto label_082B; } memory[0x0c:0x2c] = 0x389a75e1; var temp150 = var4; memory[temp150:temp150 + 0x20] = msg.sender; storage[keccak256(memory[0x0c:0x2c])] = temp150; log(memory[temp150:temp150 + temp150], [0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92, msg.sender]); return memory[temp150:temp150 + temp150]; } else if (var2 == 0x6b20c454) { var4 = var0; var5 = var1; if (msg.value) { goto label_0172; } var6 = 0x1259; var7 = msg.data.length; var6, var7, var8, var9, var10 = func_232C(var7); var temp151 = var7; var7 = var10; var temp152 = var9; var9 = temp151; var temp153 = var8; var8 = temp152; var10 = var3; var3 = temp153; var11 = 0x01; var12 = 0xffffffffffffffffffffffffffffffffffffffff; if (!(msg.sender - (storage[var11] & var12))) { goto label_1280; } if (!(msg.sender - (storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] & var12))) { label_1280: if (!(var6 & var12)) { var temp154 = var4; memory[temp154:temp154 + 0x20] = 0xb817eee700000000000000000000000000000000000000000000000000000000; revert(memory[temp154:temp154 + var10]); } else if (var3 - var7) { var temp155 = var4; memory[temp155:temp155 + 0x20] = 0xa24a13a600000000000000000000000000000000000000000000000000000000; revert(memory[temp155:temp155 + var10]); } else { var12 = var4; var13 = memory[var5:var5 + 0x20]; var14 = 0x129a; var15 = var13; func_224E(var15); memory[var13:var13 + 0x20] = var12; var12 = var4; if (var12 >= var3) { goto label_12A5; } label_1312: var13 = 0x131d; var14 = var12; var15 = var3; var16 = var9; var13 = func_244C(var14, var15, var16); var13 = msg.data[var13:var13 + 0x20]; var14 = 0x1329; var15 = var12; var16 = var7; var17 = var8; var14 = func_244C(var15, var16, var17); var14 = msg.data[var14:var14 + 0x20]; if (var13 > 0x7fffffffffffffffffffffff) { var temp156 = var4; memory[temp156:temp156 + 0x20] = 0x8ceeefe200000000000000000000000000000000000000000000000000000000; revert(memory[temp156:temp156 + var10]); } else { var temp157 = var13; memory[0x00:0x20] = ((var6 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp157 >> 0x03) | (0x07 << 0xfd); var temp158 = (temp157 << 0x05) & 0xe0; var15 = (storage[keccak256(memory[0x00:0x20])] & (0xffff << temp158)) >> temp158; if (var14 > var15) { var temp159 = var4; memory[temp159:temp159 + 0x20] = 0x588569f700000000000000000000000000000000000000000000000000000000; revert(memory[temp159:temp159 + var10]); } else { var temp160 = var13; var temp161 = var12; var12 = var11; var13 = temp161; memory[0x00:0x20] = ((var6 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp160 >> 0x03) | (0x07 << 0xfd); var temp162 = keccak256(memory[0x00:0x20]); memory[0x00:0x20] = temp162; var temp163 = (temp160 << 0x05) & 0xe0; storage[temp162] = (~(0xffff << temp163) & storage[temp162]) | (var15 - var14 << temp163); var12 = var13 + var12; if (var12 < var3) { goto label_1312; } label_12A5: var12 = var4; var13 = 0x02ca; var temp164 = var5; var temp165 = var7; var temp166 = var3; var temp167 = memory[temp164:temp164 + 0x20]; memory[temp167:temp167 + 0x20] = temp164; var temp168 = temp166 << 0x05; memory[temp167 + 0x20:temp167 + 0x20 + 0x20] = temp168 + 0x60; memory[temp167 + temp164:temp167 + temp164 + 0x20] = temp166; memory[temp167 + 0x60:temp167 + 0x60 + temp168] = msg.data[var9:var9 + temp168]; var temp169 = temp167 + temp168; memory[temp169 + 0x60:temp169 + 0x60 + 0x20] = temp165; var temp170 = temp165 << 0x05; memory[temp169 + 0x80:temp169 + 0x80 + temp170] = msg.data[var8:var8 + temp170]; log(memory[temp167:temp167 + (temp165 << 0x06) + 0x80], [0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb, msg.sender, stack[-7], stack[-9]]); var14 = memory[temp164:temp164 + 0x20]; func_224E(var14); label_02CA: var temp171 = var12; return memory[temp171:temp171 + temp171]; } } } } else { var temp172 = memory[var5:var5 + 0x20]; memory[temp172:temp172 + 0x20] = 0xea8e4eb500000000000000000000000000000000000000000000000000000000; revert(memory[temp172:temp172 + var10]); } } else if (var2 == 0x715018a6) { var4 = var0; if (msg.data.length + ~0x03 i< var4) { goto label_082B; } var5 = 0x1217; func_2833(); var temp173 = var4; var temp174 = ~0x8b78c6d8; log(memory[temp173:temp173 + temp173], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927], stack[-1]]); storage[temp174] = temp173; return memory[temp173:temp173 + temp173]; } else if (var2 == 0x862440e2) { var temp175 = var1; var1 = var3; var2 = temp175; if (msg.value) { goto label_079A; } if (msg.data.length + ~0x03 i< var2) { goto label_079A; } var temp176 = var1; var1 = msg.data[temp176:temp176 + 0x20]; var3 = 0x24; var4 = msg.data[var3:var3 + 0x20]; var6 = temp176; var5 = 0xffffffffffffffff; if (var4 > var5) { goto label_11FF; } if (var4 + 0x23 i>= msg.data.length) { goto label_11FF; } var temp177 = var5; var5 = msg.data[var4 + var6:var4 + var6 + 0x20]; if (var5 > temp177) { label_11FB: var temp178 = var0; revert(memory[temp178:temp178 + temp178]); } else if (var4 + var5 + var3 > msg.data.length) { goto label_11FB; } else { var6 = 0x0f5a; func_2833(); var temp179 = var0; memory[temp179:temp179 + 0x20] = var1; var6 = var5; var temp180 = var3; var3 = 0x20; var7 = temp180; memory[var3:var3 + 0x20] = 0x02; var8 = var4; var4 = keccak256(memory[temp179:temp179 + var2]); var9 = 0x0f73; var10 = storage[var4]; var9 = func_2850(var10); if (var9 <= 0x1f) { goto label_0F7C; } var temp181 = var9; var temp182 = var7; var7 = var8; var6 = temp182; var temp183 = var0; memory[temp183:temp183 + 0x20] = var4; var temp184 = var3; var9 = keccak256(memory[temp183:temp183 + temp184]); var temp185 = var5; var8 = var9 + (temp185 + 0x1f >> 0x05); var10 = temp181; if (temp185 >= temp184) { goto label_11C7; } var8 = var9; var10 = var10; var9 = var8; label_11C7: var temp186 = var6; var6 = var5; var temp187 = var7; var7 = temp186; var temp188 = var8; var8 = temp187; var temp189 = (var10 + 0x1f >> 0x05) + var9; var10 = temp188; var9 = temp189; if (var10 >= var9) { goto label_11DE; } label_11E3: var temp190 = var10; storage[temp190] = var0; var6 = var5; var10 = temp190 + 0x01; if (var10 < var9) { goto label_11E3; } label_11DE: label_0F7C: var9 = var8; var8 = var0; if ((var6 > 0x1f) == 0x01) { var temp191 = var7; var7 = var9; var temp192 = var8; var8 = temp191; var temp193 = var6 & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0; var9 = temp192; var temp194 = var0; memory[temp194:temp194 + 0x20] = var4; var6 = keccak256(memory[temp194:temp194 + var3]); var10 = temp193; var11 = temp194; var12 = var3; if (var11 >= var10) { goto label_113B; } label_1193: var temp195 = var9; var temp196 = var6; var temp197 = var12; storage[temp196] = msg.data[var7 + temp195 + var8:var7 + temp195 + var8 + 0x20]; var6 = temp196 + 0x01; var9 = temp195 + temp197; var11 = var11 + temp197; var12 = var3; if (var11 < var10) { goto label_1193; } label_113B: var temp198 = var10; var10 = var9; var temp199 = var5; var5 = 0x01; var temp200 = var6; var6 = temp199; var temp201 = var7; var7 = temp200; var temp202 = var8; var8 = temp201; var9 = temp202; if (temp198 >= var6) { goto label_114B; } storage[var7] = msg.data[var8 + var10 + var9:var8 + var10 + var9 + 0x20] & ~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> ((var6 << 0x03) & 0xf8)); var7 = code.length; var8 = var7; var9 = var8; var10 = var9; label_114B: var temp203 = var5; storage[var4] = (var6 << temp203) + temp203; label_0FC4: var temp204 = var0; memory[temp204:temp204 + 0x20] = var1; memory[var3:var3 + 0x20] = 0x02; var temp205 = var2; var4 = temp205; var2 = memory[var4:var4 + 0x20]; var6 = keccak256(memory[temp204:temp204 + var4]); var5 = temp204; var7 = storage[var6]; var8 = 0x0fdf; var9 = var7; var8 = func_2850(var9); memory[var2:var2 + 0x20] = var8; var temp206 = var6; var6 = var8; var8 = temp206; var temp207 = var7; var7 = 0x01; var10 = temp207; var9 = var7 & var10; if (!var9) { var temp208 = var3; var temp209 = var2; memory[temp209 + temp208:temp209 + temp208 + 0x20] = var10 & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00; var5 = temp208 + temp209 + (!!var6 << 0x05); var6 = var4; var7 = 0x102f; var8 = 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b; label_0FF9: var temp210 = var2; var temp211 = var3; var3 = temp210; var6 = var4; var4 = temp211; var7 = 0x102f; var2 = 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b; var temp212 = var5; var5 = 0x103e; var8 = temp212 - var3; var9 = var3; func_226A(var8, var9); var3, var4, var5 = func_102F(var3, var4, var6); log(memory[var3:var3 + var5 - var4], [stack[-4], stack[-5]]); var temp213 = var0; return memory[temp213:temp213 + temp213]; } else if (var9 == 0x01) { var temp214 = var0; memory[temp214:temp214 + 0x20] = var8; var8 = keccak256(memory[temp214:temp214 + var3]); var5 = temp214; if (var5 >= var6) { goto label_1055; } label_1085: var temp215 = var8; var temp216 = var5; var temp217 = var3; memory[temp217 + temp216 + var2:temp217 + temp216 + var2 + 0x20] = storage[temp215]; var5 = temp217 + temp216; var8 = var7 + temp215; if (var5 < var6) { goto label_1085; } label_1055: var5 = var3 + var2 + var5; var6 = var4; var7 = 0x102f; var8 = 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b; goto label_0FF9; } else { goto label_0FF9; } } else { var6 = var0; if (!var6) { goto label_0F91; } var6 = msg.data[var9 + var8 + var7:var9 + var8 + var7 + 0x20]; var7 = code.length; var8 = var7; var9 = var8; label_0F91: var temp218 = var5; storage[var4] = (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (temp218 << 0x03)) & var6) | (temp218 << 0x01); goto label_0FC4; } } } else if (var2 == 0x8da5cb5b) { if (msg.value) { goto label_0172; } if (msg.data.length + ~0x03 i< var0) { goto label_0172; } var temp219 = memory[var1:var1 + 0x20]; memory[temp219:temp219 + 0x20] = storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] & 0xffffffffffffffffffffffffffffffffffffffff; return memory[temp219:temp219 + 0x20]; } else if (var2 == 0x95d89b41) { var temp220 = var1; var1 = var3; var2 = temp220; if (msg.value) { goto label_079A; } if (msg.data.length + ~0x03 i< var0) { goto label_079A; } var0 = 0x0ec8; var3 = var1; var1 = memory[var2:var2 + 0x20]; var4 = 0x0e8e; var5 = var1; func_2203(var5); var0, var1, var2 = func_0E8E(var1, var2, var3); goto label_0EC8; } else if (var2 == 0x96a1521e) { var4 = var0; if (msg.value) { goto label_082B; } if (msg.data.length + ~0x03 i< 0x20) { goto label_082B; } var5 = 0xffffffffffffffffffffffffffffffffffffffff; var6 = 0x0e35; var6 = func_20F2(); var7 = 0x0e3d; func_2833(); storage[0x01] = (storage[0x01] & 0xffffffffffffffffffffffff0000000000000000000000000000000000000000) | (var6 & var5); var temp221 = var4; return memory[temp221:temp221 + temp221]; } else if (var2 == 0x9a604a7a) { var4 = var0; if (msg.value) { goto label_082B; } if (msg.data.length + ~0x03 i< 0x20) { goto label_082B; } var5 = 0xffffffffffffffffffffffffffffffffffffffff; var6 = 0x0dd3; var6 = func_20F2(); var7 = 0x0ddb; func_2833(); var temp222 = var4; storage[temp222] = (storage[temp222] & 0xffffffffffffffffffffffff0000000000000000000000000000000000000000) | (var6 & var5); return memory[temp222:temp222 + temp222]; } else if (var2 == 0xa22cb465) { if (msg.value) { goto label_0172; } if (msg.data.length + ~0x03 i< var1) { goto label_0172; } var2 = 0x0d22; var2 = func_20F2(); var temp223 = msg.data[0x24:0x44]; var3 = var2; var2 = temp223; if (var2 - !!var2) { goto label_0DA0; } var temp224 = var0; memory[temp224:temp224 + 0x20] = msg.sender; var temp225 = var3 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp225 | 0xd000000000000000000000000000000000000000000000000000000000000000; var temp226 = keccak256(memory[temp224:temp224 + var1]); var temp227 = var2; memory[0x20:0x40] = temp227; storage[temp226] = temp227; log(memory[0x20:0x40], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); return memory[temp224:temp224 + temp224]; } else if (var2 == 0xd81d0a15) { var2 = var3; if (msg.value) { goto label_079A; } var3 = 0x08f2; var4 = msg.data.length; var3, var4, var5, var6, var7 = func_232C(var4); var temp228 = var4; var4 = var7; var7 = temp228; var temp229 = var1; var1 = var3; var temp230 = var6; var6 = var5; var5 = temp230; var8 = temp229; var3 = 0xffffffffffffffffffffffffffffffffffffffff; if (!(msg.sender - (storage[var0] & var3))) { goto label_091A; } if (!(msg.sender - (storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] & var3))) { label_091A: var9 = var3; var3 = memory[var8:var8 + 0x20]; var10 = 0x0926; var11 = var3; func_224E(var11); memory[var3:var3 + 0x20] = var0; if (!(var1 & var9)) { var temp231 = var0; memory[temp231:temp231 + 0x20] = 0x2e07630000000000000000000000000000000000000000000000000000000000; revert(memory[temp231:temp231 + var2]); } else if (var6 - var4) { var temp232 = var0; memory[temp232:temp232 + 0x20] = 0xa24a13a600000000000000000000000000000000000000000000000000000000; revert(memory[temp232:temp232 + var2]); } else { var9 = var8; var8 = var0; var10 = var8; if (var10 >= var6) { goto label_0943; } label_09C7: var temp233 = var10; var temp234 = var9; var9 = temp233; var8 = temp234; var10 = 0x09d5; var11 = var9; var12 = var6; var13 = var7; var10 = func_244C(var11, var12, var13); var10 = msg.data[var10:var10 + 0x20]; var11 = 0x09e1; var12 = var9; var13 = var4; var14 = var5; var11 = func_244C(var12, var13, var14); var temp235 = msg.data[var11:var11 + 0x20]; var temp236 = var10; var11 = temp236; var10 = temp235; if (var11 > 0x7fffffffffffffffffffffff) { var temp237 = var0; memory[temp237:temp237 + 0x20] = 0x8ceeefe200000000000000000000000000000000000000000000000000000000; revert(memory[temp237:temp237 + var2]); } else if (!var10) { var temp238 = var0; memory[temp238:temp238 + 0x20] = 0xb562e8dd00000000000000000000000000000000000000000000000000000000; revert(memory[temp238:temp238 + var2]); } else { var temp239 = var11; memory[0x00:0x20] = ((var1 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp239 >> 0x03) | (0x07 << 0xfd); var temp240 = (temp239 << 0x05) & 0xe0; var12 = (storage[keccak256(memory[0x00:0x20])] & (0xffff << temp240)) >> temp240; var temp241 = var12; var12 = var10; var temp242 = temp241 + var12; var13 = temp242; var14 = temp241; var10 = 0xffff; if (var13 > var10) { var temp243 = var0; memory[temp243:temp243 + 0x20] = 0xb6cdf5d000000000000000000000000000000000000000000000000000000000; revert(memory[temp243:temp243 + var2]); } else if (var13 < var14) { var temp244 = var0; memory[temp244:temp244 + 0x20] = 0xb6cdf5d000000000000000000000000000000000000000000000000000000000; revert(memory[temp244:temp244 + var2]); } else { var temp245 = var11; memory[0x00:0x20] = ((var1 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp245 >> 0x03) | (0x07 << 0xfd); var temp246 = keccak256(memory[0x00:0x20]); memory[0x00:0x20] = temp246; var temp247 = (temp245 << 0x05) & 0xe0; storage[temp246] = (~(0xffff << temp247) & storage[temp246]) | (var13 << temp247); var temp248 = var11; memory[0x00:0x20] = ((var1 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp248 >> 0x03) | (0x07 << 0xfd); var temp249 = (temp248 << 0x05) & 0xe0; var13 = ((storage[keccak256(memory[0x00:0x20])] & (0xffff0000 << temp249)) >> temp249) >> 0x10; var temp250 = var12; var12 = var13; var temp251 = var10; var10 = var12 + temp250; if (var10 > temp251) { var temp252 = var0; memory[temp252:temp252 + 0x20] = 0xb6cdf5d000000000000000000000000000000000000000000000000000000000; revert(memory[temp252:temp252 + var2]); } else if (var10 < var12) { var temp253 = var0; memory[temp253:temp253 + 0x20] = 0xb6cdf5d000000000000000000000000000000000000000000000000000000000; revert(memory[temp253:temp253 + var2]); } else { var temp254 = var11; var11 = var9; var temp255 = var10; var10 = 0x01; var temp256 = var8; var8 = var0; var9 = temp256; memory[0x00:0x20] = ((var1 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp254 >> 0x03) | (0x07 << 0xfd); var temp257 = keccak256(memory[0x00:0x20]); memory[0x00:0x20] = temp257; var temp258 = (temp254 << 0x05) & 0xe0; storage[temp257] = (~(0xffff0000 << temp258) & storage[temp257]) | ((temp255 << 0x10) << temp258); var10 = var11 + var10; if (var10 < var6) { goto label_09C7; } label_0943: var temp259 = var9; var temp260 = var1; var temp261 = var2; var2 = temp260; var1 = temp261; var temp262 = memory[temp259:temp259 + 0x20]; memory[temp262:temp262 + 0x20] = temp259; var temp263 = var6; var temp264 = temp263 << 0x05; memory[temp262 + 0x20:temp262 + 0x20 + 0x20] = temp264 + 0x60; memory[temp262 + temp259:temp262 + temp259 + 0x20] = temp263; memory[temp262 + 0x60:temp262 + 0x60 + temp264] = msg.data[var7:var7 + temp264]; var temp265 = temp262 + temp264; var temp266 = var4; memory[temp265 + 0x60:temp265 + 0x60 + 0x20] = temp266; var temp267 = temp266 << 0x05; memory[temp265 + 0x80:temp265 + 0x80 + temp267] = msg.data[var5:var5 + temp267]; log(memory[temp262:temp262 + (temp266 << 0x06) + 0x80], [0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb, msg.sender, stack[-3], stack[-10]]); if (address(var2).code.length) { var temp268 = var2; var2 = 0x09b8; var8 = temp268; var2 = func_26C7(var3, var4, var5, var6, var7, var8); if (!var2) { goto label_0534; } var2 = var1; var3 = var2; var4 = var3; var5 = var4; var6 = var5; var7 = var6; var temp269 = var0; return memory[temp269:temp269 + temp269]; } else { var temp270 = var0; return memory[temp270:temp270 + temp270]; } } } } } } else { var temp271 = memory[var8:var8 + 0x20]; memory[temp271:temp271 + 0x20] = 0xea8e4eb500000000000000000000000000000000000000000000000000000000; revert(memory[temp271:temp271 + var2]); } } else if (var2 == 0xe8ca3bbb) { if (msg.value) { goto label_0172; } if (msg.data.length + ~0x03 i< var0) { goto label_0172; } var temp272 = memory[var1:var1 + 0x20]; memory[temp272:temp272 + 0x20] = storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff; return memory[temp272:temp272 + 0x20]; } else if (var2 == 0xe985e9c5) { if (msg.value) { goto label_0172; } if (msg.data.length + ~0x03 i< var1) { goto label_0172; } var2 = var1; var1 = 0x20; var3 = 0x08a4; var4 = 0x084e; var4 = func_20F2(); var3 = func_084E(var4); var temp273 = memory[var2:var2 + 0x20]; memory[temp273:temp273 + 0x20] = !!var3; return memory[temp273:temp273 + var1]; } else if (var2 == 0xf04e283e) { var4 = var0; if (msg.data.length + ~0x03 i< 0x20) { goto label_082B; } var5 = 0x07b3; var5 = func_20F2(); var6 = 0x07bb; func_2833(); memory[0x0c:0x2c] = 0x389a75e1; memory[var4:var4 + 0x20] = var5; var6 = var3; var3 = keccak256(memory[0x0c:0x2c]); if (block.timestamp > storage[var3]) { memory[var4:var4 + 0x20] = 0x6f5e8818; revert(memory[0x1c:0x1c + var6]); } else { var temp274 = var4; storage[var3] = temp274; var temp275 = var5 & 0xffffffffffffffffffffffffffffffffffffffff; var temp276 = ~0x8b78c6d8; log(memory[temp274:temp274 + temp274], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927], stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); storage[temp276] = temp275; return memory[temp274:temp274 + temp274]; } } else if (var2 == 0xf242432a) { var temp277 = var1; var1 = var3; var2 = temp277; if (msg.value) { goto label_079A; } if (msg.data.length + ~0x03 i< 0xa0) { goto label_079A; } var3 = 0x040f; var3 = func_20F2(); var temp278 = var2; var2 = var3; var3 = temp278; var4 = 0x0418; var4 = func_211A(); var5 = msg.data[0x44:0x64]; var6 = var4; var4 = msg.data[0x64:0x84]; var7 = msg.data[0x84:0xa4]; if (var7 > 0xffffffffffffffff) { var temp279 = var0; revert(memory[temp279:temp279 + temp279]); } else { var temp280 = var7; var7 = 0x043e; var8 = msg.data.length; var9 = var1 + temp280; var7 = func_22E5(var8, var9); var temp281 = var3; var3 = var7; var7 = temp281; if (var5 > 0x7fffffffffffffffffffffff) { goto label_076F; } var8 = var6 & 0xffffffffffffffffffffffffffffffffffffffff; var9 = 0xffffffffffffffffffffffffffffffffffffffff; if (!var8) { var temp282 = var0; memory[temp282:temp282 + 0x20] = 0xea553b3400000000000000000000000000000000000000000000000000000000; revert(memory[temp282:temp282 + var1]); } else { var temp283 = var2 & var9; var temp284 = var8; var8 = temp283; var9 = temp284; if (!(var8 - msg.sender)) { goto label_047C; } memory[0x00:0x20] = var2 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = msg.sender | 0xd000000000000000000000000000000000000000000000000000000000000000; var temp285 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = temp285; if (storage[temp285]) { label_047C: var temp286 = var5; memory[0x00:0x20] = ((var2 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp286 >> 0x03) | (0x07 << 0xfd); var temp287 = (temp286 << 0x05) & 0xe0; var10 = (storage[keccak256(memory[0x00:0x20])] & (0xffff << temp287)) >> temp287; var temp288 = var10; var10 = var8; var8 = temp288; if (var4 > var8) { var temp289 = var0; memory[temp289:temp289 + 0x20] = 0x169b037b00000000000000000000000000000000000000000000000000000000; revert(memory[temp289:temp289 + var1]); } else { var temp290 = var10; var10 = var8; var temp291 = var7; var7 = var6; var temp292 = var9; var9 = temp291; var8 = var2; if (!(temp290 - temp292)) { goto label_04E2; } var8 = var10; var temp293 = var7; var7 = var9; var temp294 = var5; var9 = var4; memory[0x00:0x20] = ((temp293 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp294 >> 0x03) | (0x07 << 0xfd); var temp295 = (temp294 << 0x05) & 0xe0; var10 = (storage[keccak256(memory[0x00:0x20])] & (0xffff << temp295)) >> temp295; var temp296 = var10 + var9; var9 = var8; var8 = temp296; if (var8 > 0xffff) { goto label_0684; } var temp297 = var9; var9 = var7; var10 = 0x067e; var11 = var8; var8 = var2; var7 = var6; var temp298 = var5; memory[0x00:0x20] = ((var8 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp298 >> 0x03) | (0x07 << 0xfd); var temp299 = keccak256(memory[0x00:0x20]); memory[0x00:0x20] = temp299; var temp300 = (temp298 << 0x05) & 0xe0; storage[temp299] = (~(0xffff << temp300) & storage[temp299]) | (temp297 - var4 << temp300); func_0623(var5, var7, var11); var10 = code.length; label_04E2: var temp301 = var9; var temp302 = memory[temp301:temp301 + 0x20]; memory[temp302:temp302 + 0x20] = var5; memory[temp302 + 0x20:temp302 + 0x20 + 0x20] = var4; log(memory[temp302:temp302 + temp301], [0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62, msg.sender, stack[-3], stack[-4]]); if (address(var6).code.length) { var temp303 = var2; var2 = 0x0526; var7 = temp303; var temp304 = var7; var7 = var6; var temp305 = var4; var9 = 0x00; var temp306 = var5; var5 = 0x20; var temp307 = var3; var temp308 = memory[0x40:0x60]; var11 = temp308; var4 = var11; var12 = 0x2568; var6 = var4; var8 = var6; var3 = 0xf23a6e6100000000000000000000000000000000000000000000000000000000; memory[var8:var8 + 0x20] = var3; memory[var8 + 0x04:var8 + 0x04 + 0x20] = msg.sender; var10 = 0xffffffffffffffffffffffffffffffffffffffff; memory[var8 + 0x24:var8 + 0x24 + 0x20] = temp304 & var10; memory[var8 + 0x44:var8 + 0x44 + 0x20] = temp306; memory[var8 + 0x64:var8 + 0x64 + 0x20] = temp305; memory[var8 + 0x84:var8 + 0x84 + 0x20] = 0xa0; var14 = temp307; var13 = var8 + 0xa4; var12 = func_213D(var13, var14); var temp309; temp309, memory[var6:var6 + var5] = address(var7 & var10).call.gas(msg.gas).value(var9)(memory[var8:var8 + var12 - var11]); var temp310 = var4; var4 = 0x00; var6 = temp310; if (!temp309) { goto label_2576; } var temp311 = var5; var5 = 0x2604; var4 = temp311; var7 = 0x20; if (var7 > returndata.length) { var7 = returndata.length; var5 = func_25F2(var6, var7); // Error: Could not resolve method call return address! } else { var5 = func_25F2(var6, var7); var temp312 = var5; var5 = var4; var4 = temp312; var6 = code.length; label_2576: if (var5) { var2 = var4 & 0xffffffff00000000000000000000000000000000000000000000000000000000 == var3; // Error: Could not resolve jump destination! } else { var5 = 0x2583; var5 = func_24C3(); label_2583: if (!memory[var5:var5 + 0x20]) { memory[0x00:0x20] = 0x9c05499b00000000000000000000000000000000000000000000000000000000; revert(memory[0x00:0x04]); } else { var temp313 = var5; revert(memory[temp313 + 0x20:temp313 + 0x20 + memory[temp313:temp313 + 0x20]]); } } } } else { var temp314 = var0; return memory[temp314:temp314 + temp314]; } } } else { var temp315 = var0; memory[temp315:temp315 + 0x20] = 0x59c896be00000000000000000000000000000000000000000000000000000000; revert(memory[temp315:temp315 + var1]); } } } } else if (var2 == 0xf2fde38b) { var4 = var3; var3 = var0; if (msg.data.length + ~0x03 i< 0x20) { goto label_0172; } var5 = 0x038e; var5 = func_20F2(); var temp316 = var5; var5 = var4; var4 = temp316; var6 = 0x0397; func_2833(); if (!(var4 << 0x60)) { memory[var3:var3 + 0x20] = 0x7448fbae; revert(memory[0x1c:0x1c + var5]); } else { var temp317 = var4 & 0xffffffffffffffffffffffffffffffffffffffff; var temp318 = ~0x8b78c6d8; var temp319 = var3; log(memory[temp319:temp319 + temp319], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927], stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); storage[temp318] = temp317; return memory[temp319:temp319 + temp319]; } } else if (var2 == 0xf5298aca) { var4 = var0; var5 = var1; if (msg.value) { goto label_0172; } var6 = 0x0186; var7 = msg.data.length; var6, var7, var8 = func_219B(var7); var temp320 = var7; var7 = var8; var temp321 = var6; var6 = temp320; var temp322 = var3; var3 = temp321; var8 = temp322; var9 = 0xffffffffffffffffffffffffffffffffffffffff; if (!(msg.sender - (storage[0x01] & var9))) { goto label_01AA; } if (!(msg.sender - (storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] & var9))) { label_01AA: if (var6 > 0x7fffffffffffffffffffffff) { var temp323 = var4; memory[temp323:temp323 + 0x20] = 0x8ceeefe200000000000000000000000000000000000000000000000000000000; revert(memory[temp323:temp323 + var8]); } else if (!(var3 & var9)) { var temp324 = var4; memory[temp324:temp324 + 0x20] = 0xb817eee700000000000000000000000000000000000000000000000000000000; revert(memory[temp324:temp324 + var8]); } else { var9 = var4; var10 = memory[var5:var5 + 0x20]; var11 = 0x01d0; var12 = var10; func_224E(var12); memory[var10:var10 + 0x20] = var9; var temp325 = var6; memory[0x00:0x20] = ((var3 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp325 >> 0x03) | (0x07 << 0xfd); var temp326 = (temp325 << 0x05) & 0xe0; var9 = (storage[keccak256(memory[0x00:0x20])] & (0xffff << temp326)) >> temp326; var temp327 = var9; var9 = var8; var8 = temp327; if (var7 > var8) { var temp328 = var4; memory[temp328:temp328 + 0x20] = 0x588569f700000000000000000000000000000000000000000000000000000000; revert(memory[temp328:temp328 + var9]); } else { var temp329 = var8; var temp330 = var6; var8 = temp330; var temp331 = var7; var9 = temp331; var temp332 = var4; var temp333 = var3; var3 = temp332; var7 = temp333; var4 = 0x02ca; var6 = var3; memory[0x00:0x20] = ((var7 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (var8 >> 0x03) | (0x07 << 0xfd); var temp334 = keccak256(memory[0x00:0x20]); memory[0x00:0x20] = temp334; var temp335 = (var8 << 0x05) & 0xe0; storage[temp334] = (~(0xffff << temp335) & storage[temp334]) | (temp329 - var9 << temp335); func_0295(var5, var6, var7, var8, var9); goto label_02CA; } } } else { var temp336 = memory[var5:var5 + 0x20]; memory[temp336:temp336 + 0x20] = 0xea8e4eb500000000000000000000000000000000000000000000000000000000; revert(memory[temp336:temp336 + var8]); } } else if (var2 == 0xfee81cf4) { if (msg.value) { goto label_0172; } if (msg.data.length + ~0x03 i< 0x20) { goto label_0172; } var2 = var0; var0 = 0x20; var3 = 0x015c; var3 = func_20F2(); memory[0x0c:0x2c] = 0x389a75e1; memory[var2:var2 + 0x20] = var3; var temp337 = var0; var temp338 = memory[var1:var1 + 0x20]; memory[temp338:temp338 + 0x20] = storage[keccak256(memory[0x0c:0x0c + temp337])]; return memory[temp338:temp338 + temp337]; } else { revert(memory[0x00:0x00]); } } function func_0295(var arg0, var arg1, var arg2, var arg3, var arg4) { var temp0 = arg0; var temp1 = memory[temp0:temp0 + 0x20]; memory[temp1:temp1 + 0x20] = arg3; memory[temp1 + 0x20:temp1 + 0x20 + 0x20] = arg4; log(memory[temp1:temp1 + temp0], [0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62, msg.sender, stack[-3], stack[-4]]); arg0 = memory[temp0:temp0 + 0x20]; func_224E(arg0); // Error: Could not resolve method call return address! } function func_0623(var arg0, var arg1, var arg2) { var temp0 = arg0; memory[0x00:0x20] = ((arg1 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp0 >> 0x03) | (0x07 << 0xfd); var temp1 = keccak256(memory[0x00:0x20]); memory[0x00:0x20] = temp1; var temp2 = (temp0 << 0x05) & 0xe0; storage[temp1] = (~(0xffff << temp2) & storage[temp1]) | (arg2 << temp2); } function func_084E(var arg0) returns (var r0) { var var0 = 0x0856; var0 = func_211A(); memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = (var0 & 0xffffffffffffffffffffffffffffffffffffffff) | 0xd000000000000000000000000000000000000000000000000000000000000000; var temp0 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = temp0; return storage[temp0]; } function func_0E8E(var arg0, var arg1, var arg2) returns (var r0, var arg0, var arg1) { var temp0 = arg0; memory[temp0:temp0 + 0x20] = arg2; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x54434b5400000000000000000000000000000000000000000000000000000000; var temp1 = memory[arg1:arg1 + 0x20]; arg1 = r0; r0 = temp1; arg0 = r0; memory[arg0:arg0 + 0x20] = 0x20; var var0 = temp0; arg2 = arg0 + 0x20; arg1 = func_213D(arg2, var0); // Error: Could not resolve method call return address! } function func_102F(var arg0, var arg1, var arg2) returns (var arg0, var arg1, var r2) { var temp0 = memory[arg2:arg2 + 0x20]; var temp1 = arg0; arg0 = temp0; var temp2 = arg1; arg1 = arg0; memory[arg1:arg1 + 0x20] = temp2; arg2 = arg1 + temp2; var var0 = temp1; r2 = func_213D(arg2, var0); // Error: Could not resolve method call return address! } function func_1650(var arg0, var arg1) returns (var r0) { var temp0 = arg0; arg0 = msg.data[arg1:arg1 + 0x20]; arg1 = temp0; var temp1 = arg1; arg1 = arg0; arg0 = temp1; if (!(arg0 & 0xffffffffffffffffffffffffffffffffffffffff)) { memory[0x00:0x20] = 0x8f4eb60400000000000000000000000000000000000000000000000000000000; revert(memory[0x00:0x04]); } else { var temp2 = arg1; memory[0x00:0x20] = ((arg0 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp2 >> 0x03) | (0x07 << 0xfd); var temp3 = (temp2 << 0x05) & 0xe0; return (storage[keccak256(memory[0x00:0x20])] & (0xffff << temp3)) >> temp3; } } function func_1971(var arg0, var arg1, var arg2) { var temp0 = arg2; memory[0x00:0x20] = ((arg0 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp0 >> 0x03) | (0x07 << 0xfd); var temp1 = keccak256(memory[0x00:0x20]); memory[0x00:0x20] = temp1; var temp2 = (temp0 << 0x05) & 0xe0; storage[temp1] = (~(0xffff << temp2) & storage[temp1]) | (arg1 << temp2); } function func_1FB4(var arg0, var arg1) returns (var r0, var arg0, var arg1) { var temp0 = arg0; memory[temp0:temp0 + 0x20] = 0x09; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x4269645469636b65740000000000000000000000000000000000000000000000; var temp1 = memory[arg1:arg1 + 0x20]; var temp2 = r0; r0 = temp1; arg1 = temp2; arg0 = r0; memory[arg0:arg0 + 0x20] = 0x20; var var1 = temp0; var var0 = arg0 + 0x20; arg1 = func_213D(var0, var1); // Error: Could not resolve method call return address! } function func_20E2(var arg0) returns (var r0) { var temp0 = arg0; arg0 = msg.data[0x24:0x44]; var var0 = temp0; var temp1 = var0; var0 = arg0; arg0 = temp1; if (!(arg0 & 0xffffffffffffffffffffffffffffffffffffffff)) { memory[0x00:0x20] = 0x8f4eb60400000000000000000000000000000000000000000000000000000000; revert(memory[0x00:0x04]); } else { var temp2 = var0; memory[0x00:0x20] = ((arg0 << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (temp2 >> 0x03) | (0x07 << 0xfd); var temp3 = (temp2 << 0x05) & 0xe0; return (storage[keccak256(memory[0x00:0x20])] & (0xffff << temp3)) >> temp3; } } function func_20F2() returns (var r0) { var temp0 = msg.data[0x04:0x24]; var var0 = r0; r0 = temp0; if (r0 - (r0 & 0xffffffffffffffffffffffffffffffffffffffff)) { revert(memory[0x00:0x00]); } else { return r0; } } function func_211A() returns (var r0) { var temp0 = msg.data[0x24:0x44]; var var0 = r0; r0 = temp0; if (r0 - (r0 & 0xffffffffffffffffffffffffffffffffffffffff)) { revert(memory[0x00:0x00]); } else { return r0; } } function func_213D(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var temp1 = arg0; arg0 = r0; arg1 = temp1; var temp2 = memory[temp0:temp0 + 0x20]; r0 = temp2; var var0 = temp0; memory[arg1:arg1 + 0x20] = r0; var var1 = 0x00; if (var1 >= r0) { goto label_2150; } label_2187: var temp3 = var1; memory[temp3 + arg1 + 0x20:temp3 + arg1 + 0x20 + 0x20] = memory[var0 + temp3 + 0x20:var0 + temp3 + 0x20 + 0x20]; var1 = temp3 + 0x20; if (var1 < r0) { goto label_2187; } label_2150: var temp4 = r0; var temp5 = arg1; memory[temp5 + temp4 + 0x20:temp5 + temp4 + 0x20 + 0x20] = 0x00; return (temp4 + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + temp5 + 0x20; } function func_219B(var arg0) returns (var r0, var arg0, var r2) { if (arg0 + ~0x03 i< 0x60) { revert(memory[0x00:0x00]); } var temp0 = msg.data[0x04:0x24]; arg0 = temp0; if (arg0 - (arg0 & 0xffffffffffffffffffffffffffffffffffffffff)) { revert(memory[0x00:0x00]); } r0 = arg0; arg0 = msg.data[0x24:0x44]; r2 = msg.data[0x44:0x64]; return r0, arg0, r2; } function func_21D2(var arg0, var arg1) returns (var r0, var arg0) { var temp0 = arg1; arg1 = r0; r0 = temp0; if (r0 + 0x1f i>= arg0) { revert(memory[0x00:0x00]); } var var0 = arg0; arg0 = msg.data[r0:r0 + 0x20]; if (arg0 > 0xffffffffffffffff) { revert(memory[0x00:0x00]); } var temp1 = r0; r0 = temp1 + 0x20; if ((arg0 << 0x05) + temp1 + 0x20 > var0) { revert(memory[0x00:0x00]); } else { return r0, arg0; } } function func_2203(var arg0) { var temp0 = arg0; var temp1 = temp0 + 0x40; arg0 = temp1; if ((arg0 > 0xffffffffffffffff) | (arg0 < temp0)) { memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x41; revert(memory[0x00:0x24]); } else { memory[0x40:0x60] = arg0; return; } } function func_224E(var arg0) { var temp0 = arg0; var temp1 = temp0 + 0x20; arg0 = temp1; if ((arg0 > 0xffffffffffffffff) | (arg0 < temp0)) { memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x41; revert(memory[0x00:0x24]); } else { memory[0x40:0x60] = arg0; return; } } function func_226A(var arg0, var arg1) { var temp0 = arg1; var temp1 = temp0 + (arg0 + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0); arg0 = temp1; if ((arg0 > 0xffffffffffffffff) | (arg0 < temp0)) { memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x41; revert(memory[0x00:0x24]); } else { memory[0x40:0x60] = arg0; return; } } function func_22AB(var arg0) returns (var r0) { if (arg0 <= 0xffffffffffffffff) { return (arg0 + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + 0x20; } memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x41; revert(memory[0x00:0x24]); } function func_22E5(var arg0, var arg1) returns (var r0) { if (arg1 + 0x1f i>= arg0) { revert(memory[0x00:0x00]); } var temp0 = arg1; var temp1 = msg.data[temp0:temp0 + 0x20]; arg1 = temp1; var var0 = temp0; var var1 = 0x22fc; var var2 = arg1; var1 = func_22AB(var2); var temp2 = var1; var1 = arg0; var2 = 0x230a; arg0 = memory[0x40:0x60]; var var3 = temp2; var var4 = arg0; func_226A(var3, var4); var temp3 = arg1; memory[arg0:arg0 + 0x20] = temp3; if (var0 + temp3 + 0x20 > var1) { revert(memory[0x00:0x00]); } var temp4 = arg1; var temp5 = arg0; memory[temp5 + 0x20:temp5 + 0x20 + temp4] = msg.data[var0 + 0x20:var0 + 0x20 + temp4]; memory[temp5 + temp4 + 0x20:temp5 + temp4 + 0x20 + 0x20] = 0x00; return temp5; } function func_232C(var arg0) returns (var r0, var arg0, var r2, var r3, var r4) { var temp0 = arg0; arg0 = r0; r0 = temp0; if (r0 + ~0x03 i< 0x60) { revert(memory[0x00:0x00]); } var temp1 = msg.data[0x04:0x24]; r2 = temp1; if (r2 - (r2 & 0xffffffffffffffffffffffffffffffffffffffff)) { revert(memory[0x00:0x00]); } var temp2 = r0; r0 = r2; r2 = temp2; var temp3 = arg0; arg0 = 0xffffffffffffffff; r3 = temp3; r4 = msg.data[0x24:0x44]; if (r4 > arg0) { revert(memory[0x00:0x00]); } var var3 = r2; var temp4 = r4; r4 = 0x237b; var var4 = temp4 + 0x04; r4, var3 = func_21D2(var3, var4); var temp5 = var3; var temp6 = arg0; arg0 = r4; var3 = r2; r2 = temp5; r4 = msg.data[0x44:0x64]; if (r4 > temp6) { revert(memory[0x00:0x00]); } var temp7 = r4; r4 = 0x2395; var4 = temp7 + 0x04; r4, var3 = func_21D2(var3, var4); var temp8 = r4; r4 = var3; r3 = temp8; return r0, arg0, r2, r3, r4; } function func_2434(var arg0) returns (var r0) { if (arg0 <= 0xffffffffffffffff) { return (arg0 << 0x05) + 0x20; } memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x41; revert(memory[0x00:0x24]); } function func_244C(var arg0, var arg1, var arg2) returns (var r0) { var temp0 = arg0; arg0 = arg2; var temp1 = arg1; arg1 = temp0; if (arg1 < temp1) { return (arg1 << 0x05) + arg0; } memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x32; revert(memory[0x00:0x24]); } function func_24C3() returns (var r0) { if (!returndata.length) { return 0x60; } var temp0 = r0; r0 = returndata.length; var var0 = temp0; var var1 = 0x24d4; var var2 = r0; var1 = func_22AB(var2); var temp1 = var1; var1 = r0; var2 = 0x24e2; r0 = memory[0x40:0x60]; var var3 = temp1; var var4 = r0; func_226A(var3, var4); var temp2 = r0; memory[temp2:temp2 + 0x20] = var1; var temp3 = returndata.length; memory[temp2 + 0x20:temp2 + 0x20 + temp3] = returndata[0x00:0x00 + temp3]; return r0; } function func_24F3(var arg0, var arg1, var arg2, var arg3) returns (var r0) { var temp0 = arg0; var temp1 = arg2; arg2 = 0x20; var var0 = arg3; var temp2 = arg1; var var2 = 0x00; var var3 = 0xffffffffffffffffffffffffffffffffffffffff; var temp3 = memory[0x40:0x60]; var var4 = temp3; arg1 = var4; var var5 = 0x2568; arg3 = arg1; var var1 = arg3; arg0 = 0xf23a6e6100000000000000000000000000000000000000000000000000000000; memory[var1:var1 + 0x20] = arg0; memory[var1 + 0x04:var1 + 0x04 + 0x20] = msg.sender; memory[var1 + 0x24:var1 + 0x24 + 0x20] = var2; memory[var1 + 0x44:var1 + 0x44 + 0x20] = temp1; memory[var1 + 0x64:var1 + 0x64 + 0x20] = temp2; memory[var1 + 0x84:var1 + 0x84 + 0x20] = 0xa0; var var6 = var1 + 0xa4; var var7 = temp0; var5 = func_213D(var6, var7); var temp4; temp4, memory[arg3:arg3 + arg2] = address(var0 & var3).call.gas(msg.gas).value(var2)(memory[var1:var1 + var5 - var4]); var temp5 = arg1; arg1 = 0x00; arg3 = temp5; if (!temp4) { goto label_2576; } var temp6 = arg2; arg2 = 0x2604; arg1 = temp6; var0 = 0x20; if (var0 > returndata.length) { var0 = returndata.length; arg2 = func_25F2(arg3, var0); // Error: Could not resolve method call return address! } else { arg2 = func_25F2(arg3, var0); var temp7 = arg2; arg2 = arg1; arg1 = temp7; arg3 = code.length; label_2576: if (arg2) { return arg1 & 0xffffffff00000000000000000000000000000000000000000000000000000000 == arg0; } arg2 = 0x2583; arg2 = func_24C3(); label_2583: if (!memory[arg2:arg2 + 0x20]) { memory[0x00:0x20] = 0x9c05499b00000000000000000000000000000000000000000000000000000000; revert(memory[0x00:0x04]); } else { var temp8 = arg2; revert(memory[temp8 + 0x20:temp8 + 0x20 + memory[temp8:temp8 + 0x20]]); } } } function func_25F2(var arg0, var arg1) returns (var r0) { var var0 = 0x25fc; var var1 = arg1; var var2 = arg0; func_226A(var1, var2); var temp0 = arg0; arg0 = temp0 + arg1; arg1 = temp0; var temp1 = arg0; arg0 = arg1; if (temp1 - arg0 i< 0x20) { revert(memory[0x00:0x00]); } var temp2 = memory[arg0:arg0 + 0x20]; arg0 = temp2; if (arg0 - (arg0 & 0xffffffff00000000000000000000000000000000000000000000000000000000)) { revert(memory[0x00:0x00]); } else { return arg0; } } function func_268A(var arg0, var arg1, var arg2) returns (var r0) { var temp0 = arg1; arg1 = arg2; var temp1 = arg0; arg0 = temp0; arg2 = temp1; memory[arg2:arg2 + 0x20] = arg0; if (arg0 > 0x07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } var temp2 = arg0 << 0x05; var temp3 = arg2; memory[temp3 + 0x20:temp3 + 0x20 + temp2] = msg.data[arg1:arg1 + temp2]; return temp3 + temp2 + 0x20; } function func_26C7(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5) returns (var r0) { var temp0 = arg2; arg2 = arg5; var temp1 = arg3; arg5 = arg0; var temp2 = memory[0x40:0x60]; var var0 = arg1; arg1 = temp2; var var1 = temp0; arg3 = arg1; var temp3 = arg4; arg4 = arg3; arg0 = 0xbc197c8100000000000000000000000000000000000000000000000000000000; memory[arg4:arg4 + 0x20] = arg0; memory[arg4 + 0x04:arg4 + 0x04 + 0x20] = msg.sender; memory[arg4 + 0x24:arg4 + 0x24 + 0x20] = 0x00; memory[arg4 + 0x44:arg4 + 0x44 + 0x20] = 0xa0; var var3 = arg4 + 0xa4; var var4 = temp1; var var5 = temp3; var var2 = 0x271b; var2 = func_268A(var3, var4, var5); var temp4 = var0; var0 = ~0x03; var3 = temp4; var temp5 = arg4; memory[temp5 + 0x64:temp5 + 0x64 + 0x20] = var2 - temp5 + var0; var temp6 = var1; var1 = 0x2732; var4 = temp6; var1 = func_268A(var2, var3, var4); var temp7 = var0; var0 = var1; var temp8 = arg4; memory[temp8 + 0x84:temp8 + 0x84 + 0x20] = var0 - temp8 + temp7; var1 = arg5; arg5 = 0x2745; arg5 = func_213D(var0, var1); var temp9 = arg3; var temp10; temp10, memory[temp9:temp9 + 0x20] = address(arg2 & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(msg.gas)(memory[temp9:temp9 + arg5 - arg4]); arg3 = arg1; arg1 = 0x00; if (temp10) { var temp11 = arg2; arg2 = 0x2604; arg1 = temp11; arg4 = 0x20; if (arg4 > returndata.length) { arg4 = returndata.length; arg2 = func_25F2(arg3, arg4); // Error: Could not resolve method call return address! } else { arg2 = func_25F2(arg3, arg4); var temp12 = arg2; arg2 = arg1; arg1 = temp12; arg3 = code.length; if (arg2) { label_25BC: return arg1 & 0xffffffff00000000000000000000000000000000000000000000000000000000 == arg0; } else { arg2 = 0x2583; arg2 = func_24C3(); label_2583: if (!memory[arg2:arg2 + 0x20]) { memory[0x00:0x20] = 0x9c05499b00000000000000000000000000000000000000000000000000000000; revert(memory[0x00:0x04]); } else { var temp13 = arg2; revert(memory[temp13 + 0x20:temp13 + 0x20 + memory[temp13:temp13 + 0x20]]); } } } } else if (arg2) { goto label_25BC; } else { arg2 = 0x2583; arg2 = func_24C3(); goto label_2583; } } function func_277C(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5, var arg6) returns (var r0) { var temp0 = arg4; var temp1 = arg6; var temp2 = arg2; arg2 = arg5; var temp3 = arg3; arg6 = arg0; var temp4 = memory[0x40:0x60]; var temp5 = arg1; arg1 = temp4; var var0 = temp5; arg3 = arg1; var var1 = temp2; arg5 = arg3; arg0 = 0xbc197c8100000000000000000000000000000000000000000000000000000000; memory[arg5:arg5 + 0x20] = arg0; memory[arg5 + 0x04:arg5 + 0x04 + 0x20] = msg.sender; arg4 = 0xffffffffffffffffffffffffffffffffffffffff; memory[arg5 + 0x24:arg5 + 0x24 + 0x20] = temp1 & arg4; memory[arg5 + 0x44:arg5 + 0x44 + 0x20] = 0xa0; var var3 = arg5 + 0xa4; var var4 = temp3; var var2 = 0x27e7; var var5 = temp0; var2 = func_268A(var3, var4, var5); var temp6 = var0; var0 = ~0x03; var3 = temp6; var temp7 = arg5; memory[temp7 + 0x64:temp7 + 0x64 + 0x20] = var2 - temp7 + var0; var temp8 = var1; var1 = 0x27fe; var4 = temp8; var1 = func_268A(var2, var3, var4); var temp9 = var0; var0 = var1; var temp10 = arg5; memory[temp10 + 0x84:temp10 + 0x84 + 0x20] = var0 - temp10 + temp9; var1 = arg6; arg6 = 0x2811; arg6 = func_213D(var0, var1); var temp11 = arg3; var temp12; temp12, memory[temp11:temp11 + 0x20] = address(arg2 & arg4).call.gas(msg.gas)(memory[temp11:temp11 + arg6 - arg5]); var temp13 = arg1; arg1 = 0x00; arg3 = temp13; if (temp12) { var temp14 = arg2; arg2 = 0x2604; arg1 = temp14; arg4 = 0x20; if (arg4 > returndata.length) { arg4 = returndata.length; arg2 = func_25F2(arg3, arg4); // Error: Could not resolve method call return address! } else { arg2 = func_25F2(arg3, arg4); var temp15 = arg2; arg2 = arg1; arg1 = temp15; arg3 = code.length; if (arg2) { label_25BC: return arg1 & 0xffffffff00000000000000000000000000000000000000000000000000000000 == arg0; } else { arg2 = 0x2583; arg2 = func_24C3(); label_2583: if (!memory[arg2:arg2 + 0x20]) { memory[0x00:0x20] = 0x9c05499b00000000000000000000000000000000000000000000000000000000; revert(memory[0x00:0x04]); } else { var temp16 = arg2; revert(memory[temp16 + 0x20:temp16 + 0x20 + memory[temp16:temp16 + 0x20]]); } } } } else if (arg2) { goto label_25BC; } else { arg2 = 0x2583; arg2 = func_24C3(); goto label_2583; } } function func_2833() { if (!(msg.sender - storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927])) { return; } memory[0x00:0x20] = 0x82b42900; revert(memory[0x1c:0x20]); } function func_2850(var arg0) returns (var r0) { var temp0 = arg0; arg0 = r0; r0 = temp0 >> 0x01; var var0 = temp0 & 0x01; if (var0) { goto label_285F; } r0 = r0 & 0x7f; var0 = var0; label_285F: if ((r0 < 0x20) != var0) { return r0; } memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x22; revert(memory[0x00:0x24]); } }

Disassembly

label_0000: // Inputs[1] { @000A msg.data.length } 0000 60 PUSH1 0x40 0002 60 PUSH1 0x80 0004 81 DUP2 0005 52 MSTORE 0006 60 PUSH1 0x04 0008 90 SWAP1 0009 81 DUP2 000A 36 CALLDATASIZE 000B 10 LT 000C 15 ISZERO 000D 61 PUSH2 0x0015 0010 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0005 memory[0x40:0x60] = 0x80 // @0008 stack[0] = 0x04 // @0008 stack[1] = 0x40 // } // Block ends with conditional jump to 0x0015, if !(msg.data.length < 0x04) label_0011: // Incoming jump from 0x0010, if not !(msg.data.length < 0x04) // Inputs[1] { @0014 memory[0x00:0x00] } 0011 60 PUSH1 0x00 0013 80 DUP1 0014 FD *REVERT // Stack delta = +0 // Outputs[1] { @0014 revert(memory[0x00:0x00]); } // Block terminates label_0015: // Incoming jump from 0x0010, if !(msg.data.length < 0x04) // Inputs[2] // { // @0018 stack[-2] // @001A msg.data[0x00:0x20] // } 0015 5B JUMPDEST 0016 60 PUSH1 0x00 0018 91 SWAP2 0019 82 DUP3 001A 35 CALLDATALOAD 001B 60 PUSH1 0xe0 001D 1C SHR 001E 90 SWAP1 001F 81 DUP2 0020 62 PUSH3 0xfdd58e 0024 14 EQ 0025 61 PUSH2 0x20c2 0028 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0018 stack[-2] = 0x00 // @001E stack[1] = stack[-2] // @001E stack[0] = msg.data[0x00:0x20] >> 0xe0 // } // Block ends with conditional jump to 0x20c2, if 0xfdd58e == msg.data[0x00:0x20] >> 0xe0 label_0029: // Incoming jump from 0x0028, if not 0xfdd58e == msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0029 stack[-2] } 0029 81 DUP2 002A 63 PUSH4 0x01ffc9a7 002F 14 EQ 0030 61 PUSH2 0x1ff0 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ff0, if 0x01ffc9a7 == stack[-2] label_0034: // Incoming jump from 0x0033, if not 0x01ffc9a7 == stack[-2] // Inputs[1] { @0034 stack[-2] } 0034 81 DUP2 0035 63 PUSH4 0x06fdde03 003A 14 EQ 003B 61 PUSH2 0x1f93 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f93, if 0x06fdde03 == stack[-2] label_003F: // Incoming jump from 0x003E, if not 0x06fdde03 == stack[-2] // Inputs[1] { @003F stack[-2] } 003F 81 DUP2 0040 63 PUSH4 0x0e89341c 0045 14 EQ 0046 61 PUSH2 0x1eab 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1eab, if 0x0e89341c == stack[-2] label_004A: // Incoming jump from 0x0049, if not 0x0e89341c == stack[-2] // Inputs[1] { @004A stack[-2] } 004A 81 DUP2 004B 63 PUSH4 0x1102fb57 0050 14 EQ 0051 61 PUSH2 0x1e78 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e78, if 0x1102fb57 == stack[-2] label_0055: // Incoming jump from 0x0054, if not 0x1102fb57 == stack[-2] // Inputs[1] { @0055 stack[-2] } 0055 81 DUP2 0056 63 PUSH4 0x156e29f6 005B 14 EQ 005C 61 PUSH2 0x1b5c 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b5c, if 0x156e29f6 == stack[-2] label_0060: // Incoming jump from 0x005F, if not 0x156e29f6 == stack[-2] // Inputs[1] { @0060 stack[-2] } 0060 81 DUP2 0061 63 PUSH4 0x25692962 0066 14 EQ 0067 61 PUSH2 0x1b11 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b11, if 0x25692962 == stack[-2] label_006B: // Incoming jump from 0x006A, if not 0x25692962 == stack[-2] // Inputs[1] { @006B stack[-2] } 006B 81 DUP2 006C 63 PUSH4 0x2eb2c2d6 0071 14 EQ 0072 61 PUSH2 0x16cd 0075 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x16cd, if 0x2eb2c2d6 == stack[-2] label_0076: // Incoming jump from 0x0075, if not 0x2eb2c2d6 == stack[-2] // Inputs[1] { @0076 stack[-2] } 0076 81 DUP2 0077 63 PUSH4 0x4e1273f4 007C 14 EQ 007D 61 PUSH2 0x151a 0080 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x151a, if 0x4e1273f4 == stack[-2] label_0081: // Incoming jump from 0x0080, if not 0x4e1273f4 == stack[-2] // Inputs[1] { @0081 stack[-2] } 0081 81 DUP2 0082 63 PUSH4 0x54d1f13d 0087 14 EQ 0088 61 PUSH2 0x14d4 008B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14d4, if 0x54d1f13d == stack[-2] label_008C: // Incoming jump from 0x008B, if not 0x54d1f13d == stack[-2] // Inputs[1] { @008C stack[-2] } 008C 81 DUP2 008D 63 PUSH4 0x6b20c454 0092 14 EQ 0093 61 PUSH2 0x1249 0096 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1249, if 0x6b20c454 == stack[-2] label_0097: // Incoming jump from 0x0096, if not 0x6b20c454 == stack[-2] // Inputs[1] { @0097 stack[-2] } 0097 81 DUP2 0098 63 PUSH4 0x715018a6 009D 14 EQ 009E 61 PUSH2 0x1203 00A1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1203, if 0x715018a6 == stack[-2] label_00A2: // Incoming jump from 0x00A1, if not 0x715018a6 == stack[-2] // Inputs[1] { @00A2 stack[-2] } 00A2 81 DUP2 00A3 63 PUSH4 0x862440e2 00A8 14 EQ 00A9 61 PUSH2 0x0f05 00AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f05, if 0x862440e2 == stack[-2] label_00AD: // Incoming jump from 0x00AC, if not 0x862440e2 == stack[-2] // Inputs[1] { @00AD stack[-2] } 00AD 81 DUP2 00AE 63 PUSH4 0x8da5cb5b 00B3 14 EQ 00B4 61 PUSH2 0x0ecc 00B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ecc, if 0x8da5cb5b == stack[-2] label_00B8: // Incoming jump from 0x00B7, if not 0x8da5cb5b == stack[-2] // Inputs[1] { @00B8 stack[-2] } 00B8 81 DUP2 00B9 63 PUSH4 0x95d89b41 00BE 14 EQ 00BF 61 PUSH2 0x0e6a 00C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e6a, if 0x95d89b41 == stack[-2] label_00C3: // Incoming jump from 0x00C2, if not 0x95d89b41 == stack[-2] // Inputs[1] { @00C3 stack[-2] } 00C3 81 DUP2 00C4 63 PUSH4 0x96a1521e 00C9 14 EQ 00CA 61 PUSH2 0x0e06 00CD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e06, if 0x96a1521e == stack[-2] label_00CE: // Incoming jump from 0x00CD, if not 0x96a1521e == stack[-2] // Inputs[1] { @00CE stack[-2] } 00CE 81 DUP2 00CF 63 PUSH4 0x9a604a7a 00D4 14 EQ 00D5 61 PUSH2 0x0da4 00D8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0da4, if 0x9a604a7a == stack[-2] label_00D9: // Incoming jump from 0x00D8, if not 0x9a604a7a == stack[-2] // Inputs[1] { @00D9 stack[-2] } 00D9 81 DUP2 00DA 63 PUSH4 0xa22cb465 00DF 14 EQ 00E0 61 PUSH2 0x0d08 00E3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d08, if 0xa22cb465 == stack[-2] label_00E4: // Incoming jump from 0x00E3, if not 0xa22cb465 == stack[-2] // Inputs[1] { @00E4 stack[-2] } 00E4 81 DUP2 00E5 63 PUSH4 0xd81d0a15 00EA 14 EQ 00EB 61 PUSH2 0x08e2 00EE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08e2, if 0xd81d0a15 == stack[-2] label_00EF: // Incoming jump from 0x00EE, if not 0xd81d0a15 == stack[-2] // Inputs[1] { @00EF stack[-2] } 00EF 81 DUP2 00F0 63 PUSH4 0xe8ca3bbb 00F5 14 EQ 00F6 61 PUSH2 0x08ad 00F9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08ad, if 0xe8ca3bbb == stack[-2] label_00FA: // Incoming jump from 0x00F9, if not 0xe8ca3bbb == stack[-2] // Inputs[1] { @00FA stack[-2] } 00FA 81 DUP2 00FB 63 PUSH4 0xe985e9c5 0100 14 EQ 0101 61 PUSH2 0x082e 0104 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x082e, if 0xe985e9c5 == stack[-2] label_0105: // Incoming jump from 0x0104, if not 0xe985e9c5 == stack[-2] // Inputs[1] { @0105 stack[-2] } 0105 81 DUP2 0106 63 PUSH4 0xf04e283e 010B 14 EQ 010C 61 PUSH2 0x079e 010F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x079e, if 0xf04e283e == stack[-2] label_0110: // Incoming jump from 0x010F, if not 0xf04e283e == stack[-2] // Inputs[1] { @0110 stack[-2] } 0110 81 DUP2 0111 63 PUSH4 0xf242432a 0116 14 EQ 0117 61 PUSH2 0x03f3 011A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f3, if 0xf242432a == stack[-2] label_011B: // Incoming jump from 0x011A, if not 0xf242432a == stack[-2] // Inputs[1] { @011B stack[-2] } 011B 81 DUP2 011C 63 PUSH4 0xf2fde38b 0121 14 EQ 0122 61 PUSH2 0x0378 0125 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0378, if 0xf2fde38b == stack[-2] label_0126: // Incoming jump from 0x0125, if not 0xf2fde38b == stack[-2] // Inputs[1] { @0126 stack[-2] } 0126 81 DUP2 0127 63 PUSH4 0xf5298aca 012C 14 EQ 012D 61 PUSH2 0x0176 0130 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0176, if 0xf5298aca == stack[-2] label_0131: // Incoming jump from 0x0130, if not 0xf5298aca == stack[-2] // Inputs[1] { @0137 stack[-2] } 0131 50 POP 0132 63 PUSH4 0xfee81cf4 0137 14 EQ 0138 61 PUSH2 0x0140 013B 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0140, if 0xfee81cf4 == stack[-2] label_013C: // Incoming jump from 0x013B, if not 0xfee81cf4 == stack[-2] // Inputs[1] { @013F memory[0x00:0x00] } 013C 60 PUSH1 0x00 013E 80 DUP1 013F FD *REVERT // Stack delta = +0 // Outputs[1] { @013F revert(memory[0x00:0x00]); } // Block terminates label_0140: // Incoming jump from 0x013B, if 0xfee81cf4 == stack[-2] // Inputs[1] { @0141 msg.value } 0140 5B JUMPDEST 0141 34 CALLVALUE 0142 61 PUSH2 0x0172 0145 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0172, if msg.value label_0146: // Incoming jump from 0x0145, if not msg.value // Inputs[1] { @014B msg.data.length } 0146 60 PUSH1 0x20 0148 60 PUSH1 0x03 014A 19 NOT 014B 36 CALLDATASIZE 014C 01 ADD 014D 12 SLT 014E 61 PUSH2 0x0172 0151 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0172, if msg.data.length + ~0x03 i< 0x20 label_0152: // Incoming jump from 0x0151, if not msg.data.length + ~0x03 i< 0x20 // Inputs[1] { @0154 stack[-2] } 0152 60 PUSH1 0x20 0154 91 SWAP2 0155 61 PUSH2 0x015c 0158 61 PUSH2 0x20f2 015B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0154 stack[0] = stack[-2] // @0154 stack[-2] = 0x20 // @0155 stack[1] = 0x015c // } // Block ends with call to 0x20f2, returns to 0x015C label_015C: // Incoming return from call to 0x20F2 at 0x015B // Inputs[8] // { // @015D stack[-2] // @015D stack[-1] // @0167 stack[-4] // @016A memory[0x0c:0x0c + stack[-4]] // @016B storage[keccak256(memory[0x0c:0x0c + stack[-4]])] // @016C stack[-3] // @016D memory[stack[-3]:stack[-3] + 0x20] // @0171 memory[memory[stack[-3]:stack[-3] + 0x20]:memory[stack[-3]:stack[-3] + 0x20] + stack[-4]] // } 015C 5B JUMPDEST 015D 90 SWAP1 015E 63 PUSH4 0x389a75e1 0163 60 PUSH1 0x0c 0165 52 MSTORE 0166 52 MSTORE 0167 81 DUP2 0168 60 PUSH1 0x0c 016A 20 SHA3 016B 54 SLOAD 016C 90 SWAP1 016D 51 MLOAD 016E 90 SWAP1 016F 81 DUP2 0170 52 MSTORE 0171 F3 *RETURN // Stack delta = -4 // Outputs[4] // { // @0165 memory[0x0c:0x2c] = 0x389a75e1 // @0166 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @0170 memory[memory[stack[-3]:stack[-3] + 0x20]:memory[stack[-3]:stack[-3] + 0x20] + 0x20] = storage[keccak256(memory[0x0c:0x0c + stack[-4]])] // @0171 return memory[memory[stack[-3]:stack[-3] + 0x20]:memory[stack[-3]:stack[-3] + 0x20] + stack[-4]]; // } // Block terminates label_0172: // Incoming jump from 0x017D, if msg.value // Incoming jump from 0x20C9, if msg.value // Incoming jump from 0x0145, if msg.value // Incoming jump from 0x0386, if msg.data.length + ~0x03 i< 0x20 // Incoming jump from 0x0D0F, if msg.value // Incoming jump from 0x152D, if msg.data.length + ~0x03 i< stack[-3] // Incoming jump from 0x0840, if msg.data.length + ~0x03 i< stack[-1] // Incoming jump from 0x0EDE, if msg.data.length + ~0x03 i< stack[-2] // Incoming jump from 0x0ED3, if msg.value // Incoming jump from 0x20D4, if msg.data.length + ~0x03 i< stack[-1] // Incoming jump from 0x0835, if msg.value // Incoming jump from 0x1FA5, if msg.data.length + ~0x03 i< stack[-2] // Incoming jump from 0x08B4, if msg.value // Incoming jump from 0x08BF, if msg.data.length + ~0x03 i< stack[-2] // Incoming jump from 0x0D1A, if msg.data.length + ~0x03 i< stack[-1] // Incoming jump from 0x1F9A, if msg.value // Incoming jump from 0x1540, if msg.data[stack[-1]:stack[-1] + 0x20] > 0xffffffffffffffff // Incoming jump from 0x1E7F, if msg.value // Incoming jump from 0x0151, if msg.data.length + ~0x03 i< 0x20 // Incoming jump from 0x1E8A, if msg.data.length + ~0x03 i< stack[-2] // Incoming jump from 0x1250, if msg.value // Incoming jump from 0x1522, if msg.value // Inputs[2] // { // @0174 stack[-2] // @0175 memory[stack[-2]:stack[-2] + stack[-2]] // } 0172 5B JUMPDEST 0173 50 POP 0174 80 DUP1 0175 FD *REVERT // Stack delta = -2 // Outputs[1] { @0175 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_0176: // Incoming jump from 0x0130, if 0xf5298aca == stack[-2] // Inputs[3] // { // @0177 stack[-4] // @0178 stack[-3] // @0179 msg.value // } 0176 5B JUMPDEST 0177 83 DUP4 0178 83 DUP4 0179 34 CALLVALUE 017A 61 PUSH2 0x0172 017D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0177 stack[0] = stack[-4] // @0178 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x0172, if msg.value label_017E: // Incoming jump from 0x017D, if not msg.value // Inputs[1] { @0181 msg.data.length } 017E 61 PUSH2 0x0186 0181 36 CALLDATASIZE 0182 61 PUSH2 0x219b 0185 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @017E stack[0] = 0x0186 // @0181 stack[1] = msg.data.length // } // Block ends with call to 0x219b, returns to 0x0186 label_0186: // Incoming return from call to 0x219B at 0x0185 // Inputs[6] // { // @0187 stack[-2] // @0187 stack[-1] // @0188 stack[-3] // @0189 stack[-6] // @01A2 storage[0x01] // @01A4 msg.sender // } 0186 5B JUMPDEST 0187 90 SWAP1 0188 91 SWAP2 0189 94 SWAP5 018A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 019F 80 DUP1 01A0 60 PUSH1 0x01 01A2 54 SLOAD 01A3 16 AND 01A4 33 CALLER 01A5 03 SUB 01A6 61 PUSH2 0x0340 01A9 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @0187 stack[-2] = stack[-1] // @0188 stack[-3] = stack[-2] // @0189 stack[-1] = stack[-6] // @0189 stack[-6] = stack[-3] // @018A stack[0] = 0xffffffffffffffffffffffffffffffffffffffff // } // Block ends with conditional jump to 0x0340, if msg.sender - (storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) label_01AA: // Incoming jump from 0x0350, if !(msg.sender - (storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] & stack[-1])) // Incoming jump from 0x01A9, if not msg.sender - (storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[1] { @01B8 stack[-4] } 01AA 5B JUMPDEST 01AB 6B PUSH12 0x7fffffffffffffffffffffff 01B8 84 DUP5 01B9 11 GT 01BA 61 PUSH2 0x0319 01BD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0319, if stack[-4] > 0x7fffffffffffffffffffffff label_01BE: // Incoming jump from 0x01BD, if not stack[-4] > 0x7fffffffffffffffffffffff // Inputs[2] // { // @01BE stack[-7] // @01BF stack[-1] // } 01BE 86 DUP7 01BF 16 AND 01C0 15 ISZERO 01C1 61 PUSH2 0x02f3 01C4 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x02f3, if !(stack[-7] & stack[-1]) label_01C5: // Incoming jump from 0x01C4, if not !(stack[-7] & stack[-1]) // Inputs[3] // { // @01C5 stack[-5] // @01C6 stack[-4] // @01C7 memory[stack[-4]:stack[-4] + 0x20] // } 01C5 84 DUP5 01C6 84 DUP5 01C7 51 MLOAD 01C8 61 PUSH2 0x01d0 01CB 81 DUP2 01CC 61 PUSH2 0x224e 01CF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01C5 stack[0] = stack[-5] // @01C7 stack[1] = memory[stack[-4]:stack[-4] + 0x20] // @01C8 stack[2] = 0x01d0 // @01CB stack[3] = memory[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x224e, returns to 0x01D0 label_01D0: // Incoming return from call to 0x224E at 0x01CF // Inputs[6] // { // @01D1 stack[-2] // @01D1 stack[-1] // @01D5 stack[-5] // @01D6 stack[-8] // @021C memory[0x00:0x20] // @021D storage[keccak256(memory[0x00:0x20])] // } 01D0 5B JUMPDEST 01D1 52 MSTORE 01D2 61 PUSH2 0x0223 01D5 83 DUP4 01D6 87 DUP8 01D7 90 SWAP1 01D8 60 PUSH1 0xe0 01DA 91 SWAP2 01DB 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 01FC 82 DUP3 01FD 60 PUSH1 0x03 01FF 1C SHR 0200 91 SWAP2 0201 60 PUSH1 0x5c 0203 1B SHL 0204 16 AND 0205 17 OR 0206 60 PUSH1 0x07 0208 60 PUSH1 0xfd 020A 1B SHL 020B 17 OR 020C 60 PUSH1 0x00 020E 52 MSTORE 020F 60 PUSH1 0x05 0211 1B SHL 0212 16 AND 0213 61 PUSH2 0xffff 0216 81 DUP2 0217 1B SHL 0218 60 PUSH1 0x20 021A 60 PUSH1 0x00 021C 20 SHA3 021D 54 SLOAD 021E 16 AND 021F 90 SWAP1 0220 1C SHR 0221 90 SWAP1 0222 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @01D1 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @020E memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-8] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-5] >> 0x03) // @0221 stack[-2] = (storage[keccak256(memory[0x00:0x20])] & (0xffff << ((stack[-5] << 0x05) & 0xe0))) >> ((stack[-5] << 0x05) & 0xe0) // } // Block ends with unconditional jump to 0x0223 label_0223: // Incoming jump from 0x0222 // Inputs[3] // { // @0224 stack[-1] // @0224 stack[-2] // @0226 stack[-3] // } 0223 5B JUMPDEST 0224 90 SWAP1 0225 81 DUP2 0226 83 DUP4 0227 11 GT 0228 61 PUSH2 0x02cd 022B 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0224 stack[-1] = stack[-2] // @0224 stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x02cd, if stack[-3] > stack[-1] label_022C: // Incoming jump from 0x022B, if not stack[-3] > stack[-1] // Inputs[7] // { // @022D stack[-2] // @022D stack[-4] // @022E stack[-3] // @0232 stack[-6] // @0233 stack[-7] // @027A memory[0x00:0x20] // @0289 storage[keccak256(memory[0x00:0x20])] // } 022C 50 POP 022D 91 SWAP2 022E 81 DUP2 022F 61 PUSH2 0x0295 0232 86 DUP7 0233 97 SWAP8 0234 93 SWAP4 0235 61 PUSH2 0x02ca 0238 97 SWAP8 0239 95 SWAP6 023A 03 SUB 023B 83 DUP4 023C 85 DUP6 023D 91 SWAP2 023E 90 SWAP1 023F 91 SWAP2 0240 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 0261 83 DUP4 0262 60 PUSH1 0x03 0264 1C SHR 0265 91 SWAP2 0266 60 PUSH1 0x5c 0268 1B SHL 0269 16 AND 026A 17 OR 026B 60 PUSH1 0x07 026D 60 PUSH1 0xfd 026F 1B SHL 0270 17 OR 0271 60 PUSH1 0x00 0273 52 MSTORE 0274 60 PUSH1 0xe0 0276 60 PUSH1 0x20 0278 60 PUSH1 0x00 027A 20 SHA3 027B 92 SWAP3 027C 83 DUP4 027D 60 PUSH1 0x00 027F 52 MSTORE 0280 60 PUSH1 0x05 0282 1B SHL 0283 16 AND 0284 90 SWAP1 0285 61 PUSH2 0xffff 0288 83 DUP4 0289 54 SLOAD 028A 91 SWAP2 028B 83 DUP4 028C 1B SHL 028D 92 SWAP3 028E 1B SHL 028F 19 NOT 0290 16 AND 0291 17 OR 0292 90 SWAP1 0293 55 SSTORE 0294 56 *JUMP // Stack delta = +0 // Outputs[9] // { // @022D stack[-2] = stack[-4] // @022E stack[-1] = stack[-3] // @0233 stack[-7] = stack[-6] // @0234 stack[-3] = stack[-7] // @0238 stack[-6] = 0x02ca // @0239 stack[-4] = stack[-6] // @0273 memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-7] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-4] >> 0x03) // @027F memory[0x00:0x20] = keccak256(memory[0x00:0x20]) // @0293 storage[keccak256(memory[0x00:0x20])] = (~(0xffff << ((stack[-4] << 0x05) & 0xe0)) & storage[keccak256(memory[0x00:0x20])]) | (stack[-2] - stack[-3] << ((stack[-4] << 0x05) & 0xe0)) // } // Block ends with call to 0x0295, returns to 0x02CA label_0295: // Incoming call from 0x0294, returns to 0x02CA // Inputs[9] // { // @0296 stack[-5] // @0297 memory[stack[-5]:stack[-5] + 0x20] // @0298 stack[-2] // @029F stack[-1] // @02C2 msg.sender // @02C4 memory[memory[stack[-5]:stack[-5] + 0x20]:memory[stack[-5]:stack[-5] + 0x20] + stack[-5]] // @02C4 stack[-3] // @02C4 stack[-4] // @02C5 memory[stack[-5]:stack[-5] + 0x20] // } 0295 5B JUMPDEST 0296 84 DUP5 0297 51 MLOAD 0298 91 SWAP2 0299 82 DUP3 029A 52 MSTORE 029B 60 PUSH1 0x20 029D 82 DUP3 029E 01 ADD 029F 52 MSTORE 02A0 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 02C1 84 DUP5 02C2 33 CALLER 02C3 92 SWAP3 02C4 A4 LOG4 02C5 51 MLOAD 02C6 61 PUSH2 0x224e 02C9 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @029A memory[memory[stack[-5]:stack[-5] + 0x20]:memory[stack[-5]:stack[-5] + 0x20] + 0x20] = stack[-2] // @029F memory[memory[stack[-5]:stack[-5] + 0x20] + 0x20:memory[stack[-5]:stack[-5] + 0x20] + 0x20 + 0x20] = stack[-1] // @02C4 log(memory[memory[stack[-5]:stack[-5] + 0x20]:memory[stack[-5]:stack[-5] + 0x20] + stack[-5]], [0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62, msg.sender, stack[-3], stack[-4]]); // @02C5 stack[-5] = memory[stack[-5]:stack[-5] + 0x20] // } // Block ends with unconditional jump to 0x224e label_02CA: // Incoming return from call to 0x0295 at 0x0294 // Incoming return from call to 0x224E at 0x1311 // Inputs[2] // { // @02CB stack[-1] // @02CC memory[stack[-1]:stack[-1] + stack[-1]] // } 02CA 5B JUMPDEST 02CB 80 DUP1 02CC F3 *RETURN // Stack delta = -1 // Outputs[1] { @02CC return memory[stack[-1]:stack[-1] + stack[-1]]; } // Block terminates label_02CD: // Incoming jump from 0x022B, if stack[-3] > stack[-1] // Inputs[3] // { // @02CE stack[-6] // @02F2 memory[stack[-6]:stack[-6] + stack[-1]] // @02F2 stack[-1] // } 02CD 5B JUMPDEST 02CE 85 DUP6 02CF 7F PUSH32 0x588569f700000000000000000000000000000000000000000000000000000000 02F0 81 DUP2 02F1 52 MSTORE 02F2 FD *REVERT // Stack delta = -1 // Outputs[2] // { // @02F1 memory[stack[-6]:stack[-6] + 0x20] = 0x588569f700000000000000000000000000000000000000000000000000000000 // @02F2 revert(memory[stack[-6]:stack[-6] + stack[-1]]); // } // Block terminates label_02F3: // Incoming jump from 0x01C4, if !(stack[-7] & stack[-1]) // Inputs[3] // { // @02F4 stack[-5] // @0318 memory[stack[-5]:stack[-5] + stack[-1]] // @0318 stack[-1] // } 02F3 5B JUMPDEST 02F4 84 DUP5 02F5 7F PUSH32 0xb817eee700000000000000000000000000000000000000000000000000000000 0316 81 DUP2 0317 52 MSTORE 0318 FD *REVERT // Stack delta = -1 // Outputs[2] // { // @0317 memory[stack[-5]:stack[-5] + 0x20] = 0xb817eee700000000000000000000000000000000000000000000000000000000 // @0318 revert(memory[stack[-5]:stack[-5] + stack[-1]]); // } // Block terminates label_0319: // Incoming jump from 0x01BD, if stack[-4] > 0x7fffffffffffffffffffffff // Inputs[3] // { // @031B stack[-6] // @033F stack[-2] // @033F memory[stack[-6]:stack[-6] + stack[-2]] // } 0319 5B JUMPDEST 031A 50 POP 031B 84 DUP5 031C 7F PUSH32 0x8ceeefe200000000000000000000000000000000000000000000000000000000 033D 81 DUP2 033E 52 MSTORE 033F FD *REVERT // Stack delta = -2 // Outputs[2] // { // @033E memory[stack[-6]:stack[-6] + 0x20] = 0x8ceeefe200000000000000000000000000000000000000000000000000000000 // @033F revert(memory[stack[-6]:stack[-6] + stack[-2]]); // } // Block terminates label_0340: // Incoming jump from 0x01A9, if msg.sender - (storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[3] // { // @0341 stack[-1] // @0348 storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] // @034A msg.sender // } 0340 5B JUMPDEST 0341 80 DUP1 0342 63 PUSH4 0x8b78c6d8 0347 19 NOT 0348 54 SLOAD 0349 16 AND 034A 33 CALLER 034B 03 SUB 034C 15 ISZERO 034D 61 PUSH2 0x01aa 0350 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01aa, if !(msg.sender - (storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] & stack[-1])) label_0351: // Incoming jump from 0x0350, if not !(msg.sender - (storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] & stack[-1])) // Inputs[4] // { // @0352 stack[-5] // @0353 memory[stack[-5]:stack[-5] + 0x20] // @0377 memory[memory[stack[-5]:stack[-5] + 0x20]:memory[stack[-5]:stack[-5] + 0x20] + stack[-2]] // @0377 stack[-2] // } 0351 50 POP 0352 83 DUP4 0353 51 MLOAD 0354 7F PUSH32 0xea8e4eb500000000000000000000000000000000000000000000000000000000 0375 81 DUP2 0376 52 MSTORE 0377 FD *REVERT // Stack delta = -2 // Outputs[2] // { // @0376 memory[memory[stack[-5]:stack[-5] + 0x20]:memory[stack[-5]:stack[-5] + 0x20] + 0x20] = 0xea8e4eb500000000000000000000000000000000000000000000000000000000 // @0377 revert(memory[memory[stack[-5]:stack[-5] + 0x20]:memory[stack[-5]:stack[-5] + 0x20] + stack[-2]]); // } // Block terminates label_0378: // Incoming jump from 0x0125, if 0xf2fde38b == stack[-2] // Inputs[3] // { // @0379 stack[-4] // @037A stack[-1] // @0380 msg.data.length // } 0378 5B JUMPDEST 0379 83 DUP4 037A 90 SWAP1 037B 60 PUSH1 0x20 037D 60 PUSH1 0x03 037F 19 NOT 0380 36 CALLDATASIZE 0381 01 ADD 0382 12 SLT 0383 61 PUSH2 0x0172 0386 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @037A stack[0] = stack[-1] // @037A stack[-1] = stack[-4] // } // Block ends with conditional jump to 0x0172, if msg.data.length + ~0x03 i< 0x20 label_0387: // Incoming jump from 0x0386, if not msg.data.length + ~0x03 i< 0x20 0387 61 PUSH2 0x038e 038A 61 PUSH2 0x20f2 038D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0387 stack[0] = 0x038e } // Block ends with call to 0x20f2, returns to 0x038E label_038E: // Incoming return from call to 0x20F2 at 0x038D // Inputs[2] // { // @038F stack[-1] // @038F stack[-2] // } 038E 5B JUMPDEST 038F 90 SWAP1 0390 61 PUSH2 0x0397 0393 61 PUSH2 0x2833 0396 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @038F stack[-2] = stack[-1] // @038F stack[-1] = stack[-2] // @0390 stack[0] = 0x0397 // } // Block ends with call to 0x2833, returns to 0x0397 label_0397: // Incoming return from call to 0x2833 at 0x0396 // Inputs[1] { @0398 stack[-2] } 0397 5B JUMPDEST 0398 81 DUP2 0399 60 PUSH1 0x60 039B 1B SHL 039C 15 ISZERO 039D 61 PUSH2 0x03e8 03A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e8, if !(stack[-2] << 0x60) label_03A1: // Incoming jump from 0x03A0, if not !(stack[-2] << 0x60) // Inputs[5] // { // @03B7 stack[-2] // @03C0 storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] // @03E2 stack[-3] // @03E4 memory[stack[-3]:stack[-3] + stack[-3]] // @03E7 memory[stack[-3]:stack[-3] + stack[-3]] // } 03A1 50 POP 03A2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03B7 16 AND 03B8 63 PUSH4 0x8b78c6d8 03BD 19 NOT 03BE 81 DUP2 03BF 81 DUP2 03C0 54 SLOAD 03C1 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 03E2 85 DUP6 03E3 80 DUP1 03E4 A3 LOG3 03E5 55 SSTORE 03E6 80 DUP1 03E7 F3 *RETURN // Stack delta = -3 // Outputs[3] // { // @03E4 log(memory[stack[-3]:stack[-3] + stack[-3]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927], stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // @03E5 storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @03E7 return memory[stack[-3]:stack[-3] + stack[-3]]; // } // Block terminates label_03E8: // Incoming jump from 0x03A0, if !(stack[-2] << 0x60) // Inputs[3] // { // @03EE stack[-3] // @03F2 memory[0x1c:0x1c + stack[-1]] // @03F2 stack[-1] // } 03E8 5B JUMPDEST 03E9 63 PUSH4 0x7448fbae 03EE 83 DUP4 03EF 52 MSTORE 03F0 60 PUSH1 0x1c 03F2 FD *REVERT // Stack delta = -1 // Outputs[2] // { // @03EF memory[stack[-3]:stack[-3] + 0x20] = 0x7448fbae // @03F2 revert(memory[0x1c:0x1c + stack[-1]]); // } // Block terminates label_03F3: // Incoming jump from 0x011A, if 0xf242432a == stack[-2] // Inputs[4] // { // @03F4 stack[-3] // @03F4 stack[-1] // @03F5 stack[-2] // @03F7 msg.value // } 03F3 5B JUMPDEST 03F4 91 SWAP2 03F5 90 SWAP1 03F6 50 POP 03F7 34 CALLVALUE 03F8 61 PUSH2 0x079a 03FB 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @03F4 stack[-3] = stack[-1] // @03F5 stack[-2] = stack[-3] // } // Block ends with conditional jump to 0x079a, if msg.value label_03FC: // Incoming jump from 0x03FB, if not msg.value // Inputs[1] { @0401 msg.data.length } 03FC 60 PUSH1 0xa0 03FE 60 PUSH1 0x03 0400 19 NOT 0401 36 CALLDATASIZE 0402 01 ADD 0403 12 SLT 0404 61 PUSH2 0x079a 0407 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x079a, if msg.data.length + ~0x03 i< 0xa0 label_0408: // Incoming jump from 0x0407, if not msg.data.length + ~0x03 i< 0xa0 0408 61 PUSH2 0x040f 040B 61 PUSH2 0x20f2 040E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0408 stack[0] = 0x040f } // Block ends with call to 0x20f2, returns to 0x040F label_040F: // Incoming return from call to 0x20F2 at 0x040E // Inputs[2] // { // @0410 stack[-1] // @0410 stack[-2] // } 040F 5B JUMPDEST 0410 90 SWAP1 0411 61 PUSH2 0x0418 0414 61 PUSH2 0x211a 0417 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0410 stack[-2] = stack[-1] // @0410 stack[-1] = stack[-2] // @0411 stack[0] = 0x0418 // } // Block ends with call to 0x211a, returns to 0x0418 label_0418: // Incoming return from call to 0x211A at 0x0417 // Inputs[4] // { // @041B msg.data[0x44:0x64] // @041E msg.data[0x64:0x84] // @041F stack[-1] // @0422 msg.data[0x84:0xa4] // } 0418 5B JUMPDEST 0419 60 PUSH1 0x44 041B 35 CALLDATALOAD 041C 60 PUSH1 0x64 041E 35 CALLDATALOAD 041F 91 SWAP2 0420 60 PUSH1 0x84 0422 35 CALLDATALOAD 0423 67 PUSH8 0xffffffffffffffff 042C 81 DUP2 042D 11 GT 042E 61 PUSH2 0x0796 0431 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @041B stack[0] = msg.data[0x44:0x64] // @041F stack[1] = stack[-1] // @041F stack[-1] = msg.data[0x64:0x84] // @0422 stack[2] = msg.data[0x84:0xa4] // } // Block ends with conditional jump to 0x0796, if msg.data[0x84:0xa4] > 0xffffffffffffffff label_0432: // Incoming jump from 0x0431, if not msg.data[0x84:0xa4] > 0xffffffffffffffff // Inputs[3] // { // @0435 stack[-1] // @0436 msg.data.length // @0438 stack[-7] // } 0432 61 PUSH2 0x043e 0435 90 SWAP1 0436 36 CALLDATASIZE 0437 90 SWAP1 0438 88 DUP9 0439 01 ADD 043A 61 PUSH2 0x22e5 043D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0435 stack[-1] = 0x043e // @0437 stack[0] = msg.data.length // @0439 stack[1] = stack[-7] + stack[-1] // } // Block ends with call to 0x22e5, returns to 0x043E label_043E: // Incoming return from call to 0x22E5 at 0x043D // Inputs[3] // { // @043F stack[-5] // @043F stack[-1] // @044D stack[-3] // } 043E 5B JUMPDEST 043F 93 SWAP4 0440 6B PUSH12 0x7fffffffffffffffffffffff 044D 83 DUP4 044E 11 GT 044F 61 PUSH2 0x076f 0452 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @043F stack[-5] = stack[-1] // @043F stack[-1] = stack[-5] // } // Block ends with conditional jump to 0x076f, if stack[-3] > 0x7fffffffffffffffffffffff label_0453: // Incoming jump from 0x0452, if not stack[-3] > 0x7fffffffffffffffffffffff // Inputs[1] { @0469 stack[-2] } 0453 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0468 80 DUP1 0469 83 DUP4 046A 16 AND 046B 90 SWAP1 046C 81 DUP2 046D 15 ISZERO 046E 61 PUSH2 0x0748 0471 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @046B stack[0] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @046B stack[1] = 0xffffffffffffffffffffffffffffffffffffffff // } // Block ends with conditional jump to 0x0748, if !(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff) label_0472: // Incoming jump from 0x0471, if not !(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[4] // { // @0472 stack[-8] // @0473 stack[-1] // @0474 stack[-2] // @0475 msg.sender // } 0472 87 DUP8 0473 16 AND 0474 90 SWAP1 0475 33 CALLER 0476 82 DUP3 0477 03 SUB 0478 61 PUSH2 0x06d2 047B 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0474 stack[-1] = stack[-2] // @0474 stack[-2] = stack[-8] & stack[-1] // } // Block ends with conditional jump to 0x06d2, if (stack[-8] & stack[-1]) - msg.sender label_047C: // Incoming jump from 0x0721, if storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x047B, if not (stack[-8] & stack[-1]) - msg.sender // Inputs[4] // { // @0480 stack[-5] // @0481 stack[-8] // @04C7 memory[0x00:0x20] // @04C8 storage[keccak256(memory[0x00:0x20])] // } 047C 5B JUMPDEST 047D 61 PUSH2 0x04ce 0480 85 DUP6 0481 89 DUP10 0482 90 SWAP1 0483 60 PUSH1 0xe0 0485 91 SWAP2 0486 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 04A7 82 DUP3 04A8 60 PUSH1 0x03 04AA 1C SHR 04AB 91 SWAP2 04AC 60 PUSH1 0x5c 04AE 1B SHL 04AF 16 AND 04B0 17 OR 04B1 60 PUSH1 0x07 04B3 60 PUSH1 0xfd 04B5 1B SHL 04B6 17 OR 04B7 60 PUSH1 0x00 04B9 52 MSTORE 04BA 60 PUSH1 0x05 04BC 1B SHL 04BD 16 AND 04BE 61 PUSH2 0xffff 04C1 81 DUP2 04C2 1B SHL 04C3 60 PUSH1 0x20 04C5 60 PUSH1 0x00 04C7 20 SHA3 04C8 54 SLOAD 04C9 16 AND 04CA 90 SWAP1 04CB 1C SHR 04CC 90 SWAP1 04CD 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04B9 memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-8] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-5] >> 0x03) // @04CC stack[0] = (storage[keccak256(memory[0x00:0x20])] & (0xffff << ((stack[-5] << 0x05) & 0xe0))) >> ((stack[-5] << 0x05) & 0xe0) // } // Block ends with unconditional jump to 0x04ce label_04CE: // Incoming jump from 0x04CD // Inputs[3] // { // @04CF stack[-1] // @04CF stack[-3] // @04D1 stack[-7] // } 04CE 5B JUMPDEST 04CF 91 SWAP2 04D0 82 DUP3 04D1 87 DUP8 04D2 11 GT 04D3 61 PUSH2 0x06ab 04D6 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @04CF stack[-1] = stack[-3] // @04CF stack[-3] = stack[-1] // } // Block ends with conditional jump to 0x06ab, if stack[-7] > stack[-1] label_04D7: // Incoming jump from 0x04D6, if not stack[-7] > stack[-1] // Inputs[6] // { // @04D7 stack[-1] // @04D7 stack[-3] // @04D8 stack[-5] // @04D9 stack[-4] // @04DA stack[-2] // @04DB stack[-9] // } 04D7 91 SWAP2 04D8 84 DUP5 04D9 93 SWAP4 04DA 91 SWAP2 04DB 89 DUP10 04DC 93 SWAP4 04DD 03 SUB 04DE 61 PUSH2 0x055a 04E1 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @04D7 stack[-1] = stack[-3] // @04D9 stack[-4] = stack[-5] // @04DA stack[-2] = stack[-4] // @04DC stack[-3] = stack[-9] // } // Block ends with conditional jump to 0x055a, if stack[-1] - stack[-2] label_04E2: // Incoming jump from 0x04E1, if not stack[-1] - stack[-2] // Incoming jump from 0x0683 // Inputs[10] // { // @0505 stack[-2] // @0506 memory[stack[-2]:stack[-2] + 0x20] // @0508 stack[-6] // @050B stack[-7] // @0511 msg.sender // @0513 stack[-4] // @0513 memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + stack[-2]] // @0513 stack[-3] // @0514 stack[-5] // @0515 address(stack[-5]).code.length // } 04E2 5B JUMPDEST 04E3 50 POP 04E4 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 0505 81 DUP2 0506 51 MLOAD 0507 91 SWAP2 0508 86 DUP7 0509 83 DUP4 050A 52 MSTORE 050B 87 DUP8 050C 60 PUSH1 0x20 050E 84 DUP5 050F 01 ADD 0510 52 MSTORE 0511 33 CALLER 0512 92 SWAP3 0513 A4 LOG4 0514 80 DUP1 0515 3B EXTCODESIZE 0516 61 PUSH2 0x051d 0519 57 *JUMPI // Stack delta = -4 // Outputs[3] // { // @050A memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + 0x20] = stack[-6] // @0510 memory[memory[stack[-2]:stack[-2] + 0x20] + 0x20:memory[stack[-2]:stack[-2] + 0x20] + 0x20 + 0x20] = stack[-7] // @0513 log(memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + stack[-2]], [0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62, msg.sender, stack[-3], stack[-4]]); // } // Block ends with conditional jump to 0x051d, if address(stack[-5]).code.length label_051A: // Incoming jump from 0x0519, if not address(stack[-5]).code.length // Inputs[2] // { // @051A stack[-7] // @051C memory[stack[-7]:stack[-7] + stack[-7]] // } 051A 86 DUP7 051B 80 DUP1 051C F3 *RETURN // Stack delta = +0 // Outputs[1] { @051C return memory[stack[-7]:stack[-7] + stack[-7]]; } // Block terminates label_051D: // Incoming jump from 0x0519, if address(stack[-5]).code.length // Inputs[1] { @0521 stack[-5] } 051D 5B JUMPDEST 051E 61 PUSH2 0x0526 0521 94 SWAP5 0522 61 PUSH2 0x2612 0525 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0521 stack[0] = stack[-5] // @0521 stack[-5] = 0x0526 // } // Block ends with unconditional jump to 0x2612 0526 5B JUMPDEST 0527 15 ISZERO 0528 61 PUSH2 0x0534 052B 57 *JUMPI 052C 80 DUP1 052D 80 DUP1 052E 80 DUP1 052F 80 DUP1 0530 80 DUP1 0531 86 DUP7 0532 80 DUP1 0533 F3 *RETURN label_0534: // Incoming jump from 0x1D9C, if !stack[-1] // Incoming jump from 0x17FE, if !stack[-1] // Incoming jump from 0x09BD, if !stack[-1] // Inputs[3] // { // @0535 stack[-2] // @0535 stack[-1] // @0559 memory[stack[-2]:stack[-2] + stack[-1]] // } 0534 5B JUMPDEST 0535 90 SWAP1 0536 7F PUSH32 0x9c05499b00000000000000000000000000000000000000000000000000000000 0557 81 DUP2 0558 52 MSTORE 0559 FD *REVERT // Stack delta = -2 // Outputs[2] // { // @0558 memory[stack[-2]:stack[-2] + 0x20] = 0x9c05499b00000000000000000000000000000000000000000000000000000000 // @0559 revert(memory[stack[-2]:stack[-2] + stack[-1]]); // } // Block terminates label_055A: // Incoming jump from 0x04E1, if stack[-1] - stack[-2] // Inputs[8] // { // @055B stack[-1] // @055B stack[-3] // @055D stack[-2] // @055D stack[-4] // @0561 stack[-6] // @0562 stack[-7] // @05A9 memory[0x00:0x20] // @05AA storage[keccak256(memory[0x00:0x20])] // } 055A 5B JUMPDEST 055B 91 SWAP2 055C 50 POP 055D 91 SWAP2 055E 61 PUSH2 0x05b0 0561 85 DUP6 0562 87 DUP8 0563 92 SWAP3 0564 90 SWAP1 0565 60 PUSH1 0xe0 0567 91 SWAP2 0568 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 0589 82 DUP3 058A 60 PUSH1 0x03 058C 1C SHR 058D 91 SWAP2 058E 60 PUSH1 0x5c 0590 1B SHL 0591 16 AND 0592 17 OR 0593 60 PUSH1 0x07 0595 60 PUSH1 0xfd 0597 1B SHL 0598 17 OR 0599 60 PUSH1 0x00 059B 52 MSTORE 059C 60 PUSH1 0x05 059E 1B SHL 059F 16 AND 05A0 61 PUSH2 0xffff 05A3 81 DUP2 05A4 1B SHL 05A5 60 PUSH1 0x20 05A7 60 PUSH1 0x00 05A9 20 SHA3 05AA 54 SLOAD 05AB 16 AND 05AC 90 SWAP1 05AD 1C SHR 05AE 90 SWAP1 05AF 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @055B stack[-3] = stack[-1] // @055D stack[-4] = stack[-2] // @0563 stack[-2] = stack[-7] // @059B memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-4] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-6] >> 0x03) // @05AE stack[-1] = (storage[keccak256(memory[0x00:0x20])] & (0xffff << ((stack[-6] << 0x05) & 0xe0))) >> ((stack[-6] << 0x05) & 0xe0) // } // Block ends with unconditional jump to 0x05b0 label_05B0: // Incoming jump from 0x05AF // Inputs[3] // { // @05B1 stack[-2] // @05B1 stack[-1] // @05B2 stack[-3] // } 05B0 5B JUMPDEST 05B1 01 ADD 05B2 90 SWAP1 05B3 61 PUSH2 0xffff 05B6 82 DUP3 05B7 11 GT 05B8 61 PUSH2 0x0684 05BB 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @05B2 stack[-2] = stack[-3] // @05B2 stack[-3] = stack[-1] + stack[-2] // } // Block ends with conditional jump to 0x0684, if stack[-1] + stack[-2] > 0xffff label_05BC: // Incoming jump from 0x05BB, if not stack[-1] + stack[-2] > 0xffff // Inputs[9] // { // @05BC stack[-3] // @05BC stack[-1] // @05C0 stack[-8] // @05C1 stack[-2] // @05C5 stack[-6] // @05C6 stack[-4] // @05C9 stack[-5] // @0608 memory[0x00:0x20] // @0617 storage[keccak256(memory[0x00:0x20])] // } 05BC 91 SWAP2 05BD 61 PUSH2 0x067e 05C0 88 DUP9 05C1 92 SWAP3 05C2 61 PUSH2 0x0623 05C5 88 DUP9 05C6 87 DUP8 05C7 96 SWAP7 05C8 03 SUB 05C9 88 DUP9 05CA 86 DUP7 05CB 91 SWAP2 05CC 90 SWAP1 05CD 91 SWAP2 05CE 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 05EF 83 DUP4 05F0 60 PUSH1 0x03 05F2 1C SHR 05F3 91 SWAP2 05F4 60 PUSH1 0x5c 05F6 1B SHL 05F7 16 AND 05F8 17 OR 05F9 60 PUSH1 0x07 05FB 60 PUSH1 0xfd 05FD 1B SHL 05FE 17 OR 05FF 60 PUSH1 0x00 0601 52 MSTORE 0602 60 PUSH1 0xe0 0604 60 PUSH1 0x20 0606 60 PUSH1 0x00 0608 20 SHA3 0609 92 SWAP3 060A 83 DUP4 060B 60 PUSH1 0x00 060D 52 MSTORE 060E 60 PUSH1 0x05 0610 1B SHL 0611 16 AND 0612 90 SWAP1 0613 61 PUSH2 0xffff 0616 83 DUP4 0617 54 SLOAD 0618 91 SWAP2 0619 83 DUP4 061A 1B SHL 061B 92 SWAP3 061C 1B SHL 061D 19 NOT 061E 16 AND 061F 17 OR 0620 90 SWAP1 0621 55 SSTORE 0622 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @05BC stack[-1] = stack[-3] // @05BD stack[0] = 0x067e // @05C1 stack[1] = stack[-2] // @05C1 stack[-2] = stack[-8] // @05C7 stack[-3] = stack[-4] // @0601 memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-8] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-5] >> 0x03) // @060D memory[0x00:0x20] = keccak256(memory[0x00:0x20]) // @0621 storage[keccak256(memory[0x00:0x20])] = (~(0xffff << ((stack[-5] << 0x05) & 0xe0)) & storage[keccak256(memory[0x00:0x20])]) | (stack[-1] - stack[-6] << ((stack[-5] << 0x05) & 0xe0)) // } // Block ends with call to 0x0623, returns to 0x067E label_0623: // Incoming call from 0x0622, returns to 0x067E // Inputs[6] // { // @0624 stack[-7] // @0625 stack[-5] // @0626 stack[-1] // @0663 memory[0x00:0x20] // @0672 storage[keccak256(memory[0x00:0x20])] // @067D stack[-2] // } 0623 5B JUMPDEST 0624 86 DUP7 0625 85 DUP6 0626 91 SWAP2 0627 90 SWAP1 0628 91 SWAP2 0629 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 064A 83 DUP4 064B 60 PUSH1 0x03 064D 1C SHR 064E 91 SWAP2 064F 60 PUSH1 0x5c 0651 1B SHL 0652 16 AND 0653 17 OR 0654 60 PUSH1 0x07 0656 60 PUSH1 0xfd 0658 1B SHL 0659 17 OR 065A 60 PUSH1 0x00 065C 52 MSTORE 065D 60 PUSH1 0xe0 065F 60 PUSH1 0x20 0661 60 PUSH1 0x00 0663 20 SHA3 0664 92 SWAP3 0665 83 DUP4 0666 60 PUSH1 0x00 0668 52 MSTORE 0669 60 PUSH1 0x05 066B 1B SHL 066C 16 AND 066D 90 SWAP1 066E 61 PUSH2 0xffff 0671 83 DUP4 0672 54 SLOAD 0673 91 SWAP2 0674 83 DUP4 0675 1B SHL 0676 92 SWAP3 0677 1B SHL 0678 19 NOT 0679 16 AND 067A 17 OR 067B 90 SWAP1 067C 55 SSTORE 067D 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @065C memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-5] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-7] >> 0x03) // @0668 memory[0x00:0x20] = keccak256(memory[0x00:0x20]) // @067C storage[keccak256(memory[0x00:0x20])] = (~(0xffff << ((stack[-7] << 0x05) & 0xe0)) & storage[keccak256(memory[0x00:0x20])]) | (stack[-1] << ((stack[-7] << 0x05) & 0xe0)) // } // Block ends with unconditional jump to stack[-2] label_067E: // Incoming return from call to 0x0623 at 0x0622 // Inputs[1] { @067F code.length } 067E 5B JUMPDEST 067F 38 CODESIZE 0680 61 PUSH2 0x04e2 0683 56 *JUMP // Stack delta = +1 // Outputs[1] { @067F stack[0] = code.length } // Block ends with unconditional jump to 0x04e2 label_0684: // Incoming jump from 0x05BB, if stack[-1] + stack[-2] > 0xffff // Incoming jump from 0x1C21, if stack[-1] + stack[-4] > 0xffff // Inputs[3] // { // @0685 stack[-9] // @0686 stack[-10] // @06AA memory[stack[-10]:stack[-10] + stack[-9]] // } 0684 5B JUMPDEST 0685 88 DUP9 0686 8A DUP11 0687 7F PUSH32 0xb6cdf5d000000000000000000000000000000000000000000000000000000000 06A8 81 DUP2 06A9 52 MSTORE 06AA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @06A9 memory[stack[-10]:stack[-10] + 0x20] = 0xb6cdf5d000000000000000000000000000000000000000000000000000000000 // @06AA revert(memory[stack[-10]:stack[-10] + stack[-9]]); // } // Block terminates label_06AB: // Incoming jump from 0x04D6, if stack[-7] > stack[-1] // Inputs[3] // { // @06AC stack[-10] // @06AD stack[-11] // @06D1 memory[stack[-11]:stack[-11] + stack[-10]] // } 06AB 5B JUMPDEST 06AC 89 DUP10 06AD 8B DUP12 06AE 7F PUSH32 0x169b037b00000000000000000000000000000000000000000000000000000000 06CF 81 DUP2 06D0 52 MSTORE 06D1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @06D0 memory[stack[-11]:stack[-11] + 0x20] = 0x169b037b00000000000000000000000000000000000000000000000000000000 // @06D1 revert(memory[stack[-11]:stack[-11] + stack[-10]]); // } // Block terminates label_06D2: // Incoming jump from 0x047B, if (stack[-8] & stack[-1]) - msg.sender // Inputs[4] // { // @06E8 stack[-8] // @0710 msg.sender // @0718 memory[0x00:0x40] // @071D storage[keccak256(memory[0x00:0x40])] // } 06D2 5B JUMPDEST 06D3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06E8 88 DUP9 06E9 16 AND 06EA 60 PUSH1 0x00 06EC 90 SWAP1 06ED 81 DUP2 06EE 52 MSTORE 06EF 7F PUSH32 0xd000000000000000000000000000000000000000000000000000000000000000 0710 33 CALLER 0711 17 OR 0712 60 PUSH1 0x20 0714 52 MSTORE 0715 60 PUSH1 0x40 0717 81 DUP2 0718 20 SHA3 0719 90 SWAP1 071A 81 DUP2 071B 90 SWAP1 071C 52 MSTORE 071D 54 SLOAD 071E 61 PUSH2 0x047c 0721 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @06EE memory[0x00:0x20] = stack[-8] & 0xffffffffffffffffffffffffffffffffffffffff // @0714 memory[0x20:0x40] = msg.sender | 0xd000000000000000000000000000000000000000000000000000000000000000 // @071C memory[0x00:0x20] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x047c, if storage[keccak256(memory[0x00:0x40])] label_0722: // Incoming jump from 0x0721, if not storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @0722 stack[-9] // @0723 stack[-10] // @0747 memory[stack[-10]:stack[-10] + stack[-9]] // } 0722 88 DUP9 0723 8A DUP11 0724 7F PUSH32 0x59c896be00000000000000000000000000000000000000000000000000000000 0745 81 DUP2 0746 52 MSTORE 0747 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0746 memory[stack[-10]:stack[-10] + 0x20] = 0x59c896be00000000000000000000000000000000000000000000000000000000 // @0747 revert(memory[stack[-10]:stack[-10] + stack[-9]]); // } // Block terminates label_0748: // Incoming jump from 0x0471, if !(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[3] // { // @0749 stack[-9] // @074A stack[-10] // @076E memory[stack[-10]:stack[-10] + stack[-9]] // } 0748 5B JUMPDEST 0749 88 DUP9 074A 8A DUP11 074B 7F PUSH32 0xea553b3400000000000000000000000000000000000000000000000000000000 076C 81 DUP2 076D 52 MSTORE 076E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @076D memory[stack[-10]:stack[-10] + 0x20] = 0xea553b3400000000000000000000000000000000000000000000000000000000 // @076E revert(memory[stack[-10]:stack[-10] + stack[-9]]); // } // Block terminates label_076F: // Incoming jump from 0x0452, if stack[-3] > 0x7fffffffffffffffffffffff // Incoming jump from 0x1BB4, if stack[-3] > 0x7fffffffffffffffffffffff // Inputs[3] // { // @0770 stack[-7] // @0771 stack[-8] // @0795 memory[stack[-8]:stack[-8] + stack[-7]] // } 076F 5B JUMPDEST 0770 86 DUP7 0771 88 DUP9 0772 7F PUSH32 0x8ceeefe200000000000000000000000000000000000000000000000000000000 0793 81 DUP2 0794 52 MSTORE 0795 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0794 memory[stack[-8]:stack[-8] + 0x20] = 0x8ceeefe200000000000000000000000000000000000000000000000000000000 // @0795 revert(memory[stack[-8]:stack[-8] + stack[-7]]); // } // Block terminates label_0796: // Incoming jump from 0x0431, if msg.data[0x84:0xa4] > 0xffffffffffffffff // Inputs[2] // { // @0797 stack[-8] // @0799 memory[stack[-8]:stack[-8] + stack[-8]] // } 0796 5B JUMPDEST 0797 87 DUP8 0798 80 DUP1 0799 FD *REVERT // Stack delta = +0 // Outputs[1] { @0799 revert(memory[stack[-8]:stack[-8] + stack[-8]]); } // Block terminates label_079A: // Incoming jump from 0x1FF7, if msg.value // Incoming jump from 0x16D5, if msg.value // Incoming jump from 0x0F18, if msg.data.length + ~0x03 i< stack[-1] // Incoming jump from 0x1B64, if msg.value // Incoming jump from 0x1EB3, if msg.value // Incoming jump from 0x202F, if msg.data[stack[-1]:stack[-1] + 0x20] - (msg.data[stack[-1]:stack[-1] + 0x20] & 0xffffffff00000000000000000000000000000000000000000000000000000000) // Incoming jump from 0x03FB, if msg.value // Incoming jump from 0x16E1, if msg.data.length + ~0x03 i< 0xa0 // Incoming jump from 0x0E7D, if msg.data.length + ~0x03 i< stack[-3] // Incoming jump from 0x08E9, if msg.value // Incoming jump from 0x155C, if msg.data[0x24:0x44] > stack[-5] // Incoming jump from 0x2003, if msg.data.length + ~0x03 i< 0x20 // Incoming jump from 0x0E72, if msg.value // Incoming jump from 0x0407, if msg.data.length + ~0x03 i< 0xa0 // Incoming jump from 0x0F0D, if msg.value // Inputs[2] // { // @079B stack[-3] // @079D memory[stack[-3]:stack[-3] + stack[-3]] // } 079A 5B JUMPDEST 079B 82 DUP3 079C 80 DUP1 079D FD *REVERT // Stack delta = +0 // Outputs[1] { @079D revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_079E: // Incoming jump from 0x010F, if 0xf04e283e == stack[-2] // Inputs[2] // { // @079F stack[-4] // @07A5 msg.data.length // } 079E 5B JUMPDEST 079F 83 DUP4 07A0 60 PUSH1 0x20 07A2 60 PUSH1 0x03 07A4 19 NOT 07A5 36 CALLDATASIZE 07A6 01 ADD 07A7 12 SLT 07A8 61 PUSH2 0x082b 07AB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @079F stack[0] = stack[-4] } // Block ends with conditional jump to 0x082b, if msg.data.length + ~0x03 i< 0x20 label_07AC: // Incoming jump from 0x07AB, if not msg.data.length + ~0x03 i< 0x20 07AC 61 PUSH2 0x07b3 07AF 61 PUSH2 0x20f2 07B2 56 *JUMP // Stack delta = +1 // Outputs[1] { @07AC stack[0] = 0x07b3 } // Block ends with call to 0x20f2, returns to 0x07B3 label_07B3: // Incoming return from call to 0x20F2 at 0x07B2 07B3 5B JUMPDEST 07B4 61 PUSH2 0x07bb 07B7 61 PUSH2 0x2833 07BA 56 *JUMP // Stack delta = +1 // Outputs[1] { @07B4 stack[0] = 0x07bb } // Block ends with call to 0x2833, returns to 0x07BB label_07BB: // Incoming return from call to 0x2833 at 0x07BA // Inputs[6] // { // @07C4 stack[-1] // @07C5 stack[-2] // @07CB memory[0x0c:0x2c] // @07CC stack[-3] // @07CE storage[keccak256(memory[0x0c:0x2c])] // @07CF block.timestamp // } 07BB 5B JUMPDEST 07BC 63 PUSH4 0x389a75e1 07C1 60 PUSH1 0x0c 07C3 52 MSTORE 07C4 80 DUP1 07C5 82 DUP3 07C6 52 MSTORE 07C7 60 PUSH1 0x20 07C9 60 PUSH1 0x0c 07CB 20 SHA3 07CC 92 SWAP3 07CD 83 DUP4 07CE 54 SLOAD 07CF 42 TIMESTAMP 07D0 11 GT 07D1 61 PUSH2 0x0820 07D4 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @07C3 memory[0x0c:0x2c] = 0x389a75e1 // @07C6 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @07CC stack[0] = stack[-3] // @07CC stack[-3] = keccak256(memory[0x0c:0x2c]) // } // Block ends with conditional jump to 0x0820, if block.timestamp > storage[keccak256(memory[0x0c:0x2c])] label_07D5: // Incoming jump from 0x07D4, if not block.timestamp > storage[keccak256(memory[0x0c:0x2c])] // Inputs[6] // { // @07D6 stack[-3] // @07ED stack[-4] // @07EF stack[-2] // @07F8 storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] // @081C memory[stack[-3]:stack[-3] + stack[-3]] // @081F memory[stack[-3]:stack[-3] + stack[-3]] // } 07D5 50 POP 07D6 81 DUP2 07D7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07EC 92 SWAP3 07ED 93 SWAP4 07EE 55 SSTORE 07EF 16 AND 07F0 63 PUSH4 0x8b78c6d8 07F5 19 NOT 07F6 81 DUP2 07F7 81 DUP2 07F8 54 SLOAD 07F9 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 081A 85 DUP6 081B 80 DUP1 081C A3 LOG3 081D 55 SSTORE 081E 80 DUP1 081F F3 *RETURN // Stack delta = -4 // Outputs[4] // { // @07EE storage[stack[-4]] = stack[-3] // @081C log(memory[stack[-3]:stack[-3] + stack[-3]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927], stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // @081D storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @081F return memory[stack[-3]:stack[-3] + stack[-3]]; // } // Block terminates label_0820: // Incoming jump from 0x07D4, if block.timestamp > storage[keccak256(memory[0x0c:0x2c])] // Inputs[3] // { // @0826 stack[-3] // @082A stack[-1] // @082A memory[0x1c:0x1c + stack[-1]] // } 0820 5B JUMPDEST 0821 63 PUSH4 0x6f5e8818 0826 83 DUP4 0827 52 MSTORE 0828 60 PUSH1 0x1c 082A FD *REVERT // Stack delta = -1 // Outputs[2] // { // @0827 memory[stack[-3]:stack[-3] + 0x20] = 0x6f5e8818 // @082A revert(memory[0x1c:0x1c + stack[-1]]); // } // Block terminates label_082B: // Incoming jump from 0x0E0C, if msg.value // Incoming jump from 0x07AB, if msg.data.length + ~0x03 i< 0x20 // Incoming jump from 0x1B1D, if msg.data.length + ~0x03 i< stack[-4] // Incoming jump from 0x0E18, if msg.data.length + ~0x03 i< 0x20 // Incoming jump from 0x0DAA, if msg.value // Incoming jump from 0x14E0, if msg.data.length + ~0x03 i< stack[-4] // Incoming jump from 0x120F, if msg.data.length + ~0x03 i< stack[-4] // Incoming jump from 0x0DB6, if msg.data.length + ~0x03 i< 0x20 // Inputs[2] // { // @082C stack[-1] // @082D memory[stack[-1]:stack[-1] + stack[-1]] // } 082B 5B JUMPDEST 082C 80 DUP1 082D FD *REVERT // Stack delta = -1 // Outputs[1] { @082D revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_082E: // Incoming jump from 0x0104, if 0xe985e9c5 == stack[-2] // Inputs[1] { @0831 msg.value } 082E 5B JUMPDEST 082F 50 POP 0830 50 POP 0831 34 CALLVALUE 0832 61 PUSH2 0x0172 0835 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0172, if msg.value label_0836: // Incoming jump from 0x0835, if not msg.value // Inputs[2] // { // @0836 stack[-1] // @083A msg.data.length // } 0836 80 DUP1 0837 60 PUSH1 0x03 0839 19 NOT 083A 36 CALLDATASIZE 083B 01 ADD 083C 12 SLT 083D 61 PUSH2 0x0172 0840 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0172, if msg.data.length + ~0x03 i< stack[-1] label_0841: // Incoming jump from 0x0840, if not msg.data.length + ~0x03 i< stack[-1] // Inputs[1] { @0843 stack[-1] } 0841 60 PUSH1 0x20 0843 90 SWAP1 0844 61 PUSH2 0x08a4 0847 61 PUSH2 0x084e 084A 61 PUSH2 0x20f2 084D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0843 stack[0] = stack[-1] // @0843 stack[-1] = 0x20 // @0844 stack[1] = 0x08a4 // @0847 stack[2] = 0x084e // } // Block ends with call to 0x20f2, returns to 0x084E label_084E: // Incoming return from call to 0x20F2 at 0x084D 084E 5B JUMPDEST 084F 61 PUSH2 0x0856 0852 61 PUSH2 0x211a 0855 56 *JUMP // Stack delta = +1 // Outputs[1] { @084F stack[0] = 0x0856 } // Block ends with call to 0x211a, returns to 0x0856 label_0856: // Incoming return from call to 0x211A at 0x0855 // Inputs[5] // { // @086D stack[-2] // @0872 stack[-1] // @089C memory[0x00:0x40] // @08A1 storage[keccak256(memory[0x00:0x40])] // @08A2 stack[-3] // } 0856 5B JUMPDEST 0857 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 086C 80 DUP1 086D 92 SWAP3 086E 16 AND 086F 60 PUSH1 0x00 0871 52 MSTORE 0872 16 AND 0873 7F PUSH32 0xd000000000000000000000000000000000000000000000000000000000000000 0894 17 OR 0895 60 PUSH1 0x20 0897 52 MSTORE 0898 60 PUSH1 0x40 089A 60 PUSH1 0x00 089C 20 SHA3 089D 80 DUP1 089E 60 PUSH1 0x00 08A0 52 MSTORE 08A1 54 SLOAD 08A2 90 SWAP1 08A3 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @0871 memory[0x00:0x20] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @0897 memory[0x20:0x40] = 0xd000000000000000000000000000000000000000000000000000000000000000 | (stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff) // @08A0 memory[0x00:0x20] = keccak256(memory[0x00:0x40]) // @08A2 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_08A4: // Incoming return from call to 0x084E at 0x084D // Inputs[5] // { // @08A5 stack[-1] // @08A5 stack[-2] // @08A6 memory[stack[-2]:stack[-2] + 0x20] // @08AC memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + stack[-3]] // @08AC stack[-3] // } 08A4 5B JUMPDEST 08A5 90 SWAP1 08A6 51 MLOAD 08A7 90 SWAP1 08A8 15 ISZERO 08A9 15 ISZERO 08AA 81 DUP2 08AB 52 MSTORE 08AC F3 *RETURN // Stack delta = -3 // Outputs[2] // { // @08AB memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + 0x20] = !!stack[-1] // @08AC return memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + stack[-3]]; // } // Block terminates label_08AD: // Incoming jump from 0x00F9, if 0xe8ca3bbb == stack[-2] // Inputs[1] { @08B0 msg.value } 08AD 5B JUMPDEST 08AE 50 POP 08AF 50 POP 08B0 34 CALLVALUE 08B1 61 PUSH2 0x0172 08B4 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0172, if msg.value label_08B5: // Incoming jump from 0x08B4, if not msg.value // Inputs[2] // { // @08B5 stack[-2] // @08B9 msg.data.length // } 08B5 81 DUP2 08B6 60 PUSH1 0x03 08B8 19 NOT 08B9 36 CALLDATASIZE 08BA 01 ADD 08BB 12 SLT 08BC 61 PUSH2 0x0172 08BF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0172, if msg.data.length + ~0x03 i< stack[-2] label_08C0: // Incoming jump from 0x08BF, if not msg.data.length + ~0x03 i< stack[-2] // Inputs[4] // { // @08C2 stack[-1] // @08DA storage[0x01] // @08DD memory[stack[-1]:stack[-1] + 0x20] // @08E1 memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + 0x20] // } 08C0 60 PUSH1 0x20 08C2 90 SWAP1 08C3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08D8 60 PUSH1 0x01 08DA 54 SLOAD 08DB 16 AND 08DC 90 SWAP1 08DD 51 MLOAD 08DE 90 SWAP1 08DF 81 DUP2 08E0 52 MSTORE 08E1 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @08E0 memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + 0x20] = storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff // @08E1 return memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + 0x20]; // } // Block terminates label_08E2: // Incoming jump from 0x00EE, if 0xd81d0a15 == stack[-2] // Inputs[3] // { // @08E3 stack[-1] // @08E3 stack[-2] // @08E5 msg.value // } 08E2 5B JUMPDEST 08E3 90 SWAP1 08E4 50 POP 08E5 34 CALLVALUE 08E6 61 PUSH2 0x079a 08E9 57 *JUMPI // Stack delta = -1 // Outputs[1] { @08E3 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x079a, if msg.value label_08EA: // Incoming jump from 0x08E9, if not msg.value // Inputs[1] { @08ED msg.data.length } 08EA 61 PUSH2 0x08f2 08ED 36 CALLDATASIZE 08EE 61 PUSH2 0x232c 08F1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @08EA stack[0] = 0x08f2 // @08ED stack[1] = msg.data.length // } // Block ends with call to 0x232c, returns to 0x08F2 label_08F2: // Incoming return from call to 0x232C at 0x08F1 // Inputs[9] // { // @08F3 stack[-1] // @08F3 stack[-4] // @0909 stack[-7] // @090A stack[-5] // @090C stack[-3] // @090D stack[-2] // @0911 stack[-8] // @0912 storage[stack[-8]] // @0914 msg.sender // } 08F2 5B JUMPDEST 08F3 92 SWAP3 08F4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0909 96 SWAP7 090A 94 SWAP5 090B 96 SWAP7 090C 92 SWAP3 090D 91 SWAP2 090E 92 SWAP3 090F 94 SWAP5 0910 85 DUP6 0911 89 DUP10 0912 54 SLOAD 0913 16 AND 0914 33 CALLER 0915 03 SUB 0916 61 PUSH2 0x0cd0 0919 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @08F3 stack[-4] = stack[-1] // @08F3 stack[-1] = stack[-4] // @090B stack[-7] = stack[-5] // @090D stack[-2] = stack[-3] // @090E stack[-3] = stack[-2] // @090F stack[-5] = 0xffffffffffffffffffffffffffffffffffffffff // @090F stack[0] = stack[-7] // } // Block ends with conditional jump to 0x0cd0, if msg.sender - (storage[stack[-8]] & 0xffffffffffffffffffffffffffffffffffffffff) label_091A: // Incoming jump from 0x0CE0, if !(msg.sender - (storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] & stack[-6])) // Incoming jump from 0x0919, if not msg.sender - (storage[stack[-8]] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[3] // { // @091B stack[-1] // @091C memory[stack[-1]:stack[-1] + 0x20] // @091D stack[-6] // } 091A 5B JUMPDEST 091B 80 DUP1 091C 51 MLOAD 091D 95 SWAP6 091E 61 PUSH2 0x0926 0921 87 DUP8 0922 61 PUSH2 0x224e 0925 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @091D stack[0] = stack[-6] // @091D stack[-6] = memory[stack[-1]:stack[-1] + 0x20] // @091E stack[1] = 0x0926 // @0921 stack[2] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x224e, returns to 0x0926 label_0926: // Incoming return from call to 0x224E at 0x0925 // Inputs[4] // { // @0927 stack[-10] // @0928 stack[-7] // @092A stack[-9] // @092B stack[-1] // } 0926 5B JUMPDEST 0927 89 DUP10 0928 87 DUP8 0929 52 MSTORE 092A 88 DUP9 092B 16 AND 092C 15 ISZERO 092D 61 PUSH2 0x0ca9 0930 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0929 memory[stack[-7]:stack[-7] + 0x20] = stack[-10] } // Block ends with conditional jump to 0x0ca9, if !(stack[-9] & stack[-1]) label_0931: // Incoming jump from 0x0930, if not !(stack[-9] & stack[-1]) // Inputs[2] // { // @0931 stack[-5] // @0932 stack[-3] // } 0931 84 DUP5 0932 83 DUP4 0933 03 SUB 0934 61 PUSH2 0x0c82 0937 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c82, if stack[-3] - stack[-5] label_0938: // Incoming jump from 0x0937, if not stack[-3] - stack[-5] // Inputs[3] // { // @0938 stack[-9] // @0939 stack[-1] // @093C stack[-3] // } 0938 88 DUP9 0939 90 SWAP1 093A 81 DUP2 093B 5B JUMPDEST 093C 84 DUP5 093D 81 DUP2 093E 10 LT 093F 61 PUSH2 0x09c7 0942 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0939 stack[0] = stack[-1] // @0939 stack[-1] = stack[-9] // @093A stack[1] = stack[-9] // } // Block ends with conditional jump to 0x09c7, if stack[-9] < stack[-3] label_0943: // Incoming jump from 0x0942, if not stack[-9] < stack[-3] // Incoming jump from 0x0942, if not stack[-1] < stack[-5] // Inputs[14] // { // @0944 stack[-3] // @0944 stack[-2] // @0946 stack[-10] // @0947 stack[-9] // @094A memory[stack[-2]:stack[-2] + 0x20] // @094F stack[-5] // @0962 stack[-4] // @0967 msg.data[stack[-4]:stack[-4] + stack[-5] << 0x05] // @096A stack[-7] // @0970 stack[-6] // @0979 msg.data[stack[-6]:stack[-6] + stack[-7] << 0x05] // @099B msg.sender // @09A5 memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + 0x80 + (stack[-7] << 0x06)] // @09A7 address(stack[-10]).code.length // } 0943 50 POP 0944 90 SWAP1 0945 81 DUP2 0946 89 DUP10 0947 98 SWAP9 0948 99 SWAP10 0949 92 SWAP3 094A 51 MLOAD 094B 90 SWAP1 094C 80 DUP1 094D 82 DUP3 094E 52 MSTORE 094F 85 DUP6 0950 80 DUP1 0951 60 PUSH1 0x05 0953 1B SHL 0954 91 SWAP2 0955 82 DUP3 0956 60 PUSH1 0x60 0958 01 ADD 0959 60 PUSH1 0x20 095B 85 DUP6 095C 01 ADD 095D 52 MSTORE 095E 83 DUP4 095F 01 ADD 0960 52 MSTORE 0961 80 DUP1 0962 85 DUP6 0963 60 PUSH1 0x60 0965 84 DUP5 0966 01 ADD 0967 37 CALLDATACOPY 0968 81 DUP2 0969 01 ADD 096A 87 DUP8 096B 60 PUSH1 0x60 096D 82 DUP3 096E 01 ADD 096F 52 MSTORE 0970 86 DUP7 0971 60 PUSH1 0x80 0973 89 DUP10 0974 60 PUSH1 0x05 0976 1B SHL 0977 92 SWAP3 0978 01 ADD 0979 37 CALLDATACOPY 097A 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 099B 33 CALLER 099C 91 SWAP2 099D 88 DUP9 099E 60 PUSH1 0x06 09A0 1B SHL 09A1 60 PUSH1 0x80 09A3 01 ADD 09A4 90 SWAP1 09A5 A4 LOG4 09A6 85 DUP6 09A7 3B EXTCODESIZE 09A8 61 PUSH2 0x09af 09AB 57 *JUMPI // Stack delta = -3 // Outputs[9] // { // @0947 stack[-9] = stack[-10] // @0948 stack[-10] = stack[-9] // @094E memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + 0x20] = stack[-2] // @095D memory[memory[stack[-2]:stack[-2] + 0x20] + 0x20:memory[stack[-2]:stack[-2] + 0x20] + 0x20 + 0x20] = 0x60 + (stack[-5] << 0x05) // @0960 memory[memory[stack[-2]:stack[-2] + 0x20] + stack[-2]:memory[stack[-2]:stack[-2] + 0x20] + stack[-2] + 0x20] = stack[-5] // @0967 memory[memory[stack[-2]:stack[-2] + 0x20] + 0x60:memory[stack[-2]:stack[-2] + 0x20] + 0x60 + stack[-5] << 0x05] = msg.data[stack[-4]:stack[-4] + stack[-5] << 0x05] // @096F memory[memory[stack[-2]:stack[-2] + 0x20] + (stack[-5] << 0x05) + 0x60:memory[stack[-2]:stack[-2] + 0x20] + (stack[-5] << 0x05) + 0x60 + 0x20] = stack[-7] // @0979 memory[memory[stack[-2]:stack[-2] + 0x20] + (stack[-5] << 0x05) + 0x80:memory[stack[-2]:stack[-2] + 0x20] + (stack[-5] << 0x05) + 0x80 + stack[-7] << 0x05] = msg.data[stack[-6]:stack[-6] + stack[-7] << 0x05] // @09A5 log(memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + 0x80 + (stack[-7] << 0x06)], [0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb, msg.sender, stack[-3], stack[-10]]); // } // Block ends with conditional jump to 0x09af, if address(stack[-10]).code.length label_09AC: // Incoming jump from 0x09AB, if not address(stack[-10]).code.length // Inputs[2] // { // @09AC stack[-8] // @09AE memory[stack[-8]:stack[-8] + stack[-8]] // } 09AC 87 DUP8 09AD 80 DUP1 09AE F3 *RETURN // Stack delta = +0 // Outputs[1] { @09AE return memory[stack[-8]:stack[-8] + stack[-8]]; } // Block terminates label_09AF: // Incoming jump from 0x09AB, if address(stack[-10]).code.length // Inputs[1] { @09B3 stack[-6] } 09AF 5B JUMPDEST 09B0 61 PUSH2 0x09b8 09B3 95 SWAP6 09B4 61 PUSH2 0x26c7 09B7 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @09B3 stack[0] = stack[-6] // @09B3 stack[-6] = 0x09b8 // } // Block ends with call to 0x26c7, returns to 0x09B8 label_09B8: // Incoming return from call to 0x26C7 at 0x09B7 // Inputs[1] { @09B9 stack[-1] } 09B8 5B JUMPDEST 09B9 15 ISZERO 09BA 61 PUSH2 0x0534 09BD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0534, if !stack[-1] label_09BE: // Incoming jump from 0x09BD, if not !stack[-1] // Inputs[3] // { // @09BE stack[-1] // @09C4 stack[-2] // @09C6 memory[stack[-2]:stack[-2] + stack[-2]] // } 09BE 80 DUP1 09BF 80 DUP1 09C0 80 DUP1 09C1 80 DUP1 09C2 80 DUP1 09C3 80 DUP1 09C4 87 DUP8 09C5 80 DUP1 09C6 F3 *RETURN // Stack delta = +6 // Outputs[7] // { // @09BE stack[0] = stack[-1] // @09BF stack[1] = stack[-1] // @09C0 stack[2] = stack[-1] // @09C1 stack[3] = stack[-1] // @09C2 stack[4] = stack[-1] // @09C3 stack[5] = stack[-1] // @09C6 return memory[stack[-2]:stack[-2] + stack[-2]]; // } // Block terminates label_09C7: // Incoming jump from 0x0942, if stack[-9] < stack[-3] // Incoming jump from 0x0942, if stack[-1] < stack[-5] // Inputs[5] // { // @09C8 stack[-2] // @09C8 stack[-1] // @09C9 stack[-3] // @09CF stack[-5] // @09D0 stack[-4] // } 09C7 5B JUMPDEST 09C8 90 SWAP1 09C9 91 SWAP2 09CA 50 POP 09CB 61 PUSH2 0x09d5 09CE 81 DUP2 09CF 85 DUP6 09D0 85 DUP6 09D1 61 PUSH2 0x244c 09D4 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @09C8 stack[-2] = stack[-1] // @09C9 stack[-3] = stack[-2] // @09CB stack[-1] = 0x09d5 // @09CE stack[0] = stack[-1] // @09CF stack[1] = stack[-5] // @09D0 stack[2] = stack[-4] // } // Block ends with call to 0x244c, returns to 0x09D5 label_09D5: // Incoming return from call to 0x244C at 0x09D4 // Inputs[5] // { // @09D6 stack[-1] // @09D6 msg.data[stack[-1]:stack[-1] + 0x20] // @09DA stack[-2] // @09DB stack[-7] // @09DC stack[-6] // } 09D5 5B JUMPDEST 09D6 35 CALLDATALOAD 09D7 61 PUSH2 0x09e1 09DA 82 DUP3 09DB 88 DUP9 09DC 88 DUP9 09DD 61 PUSH2 0x244c 09E0 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @09D6 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @09D7 stack[0] = 0x09e1 // @09DA stack[1] = stack[-2] // @09DB stack[2] = stack[-7] // @09DC stack[3] = stack[-6] // } // Block ends with call to 0x244c, returns to 0x09E1 label_09E1: // Incoming return from call to 0x244C at 0x09E0 // Inputs[3] // { // @09E2 stack[-1] // @09E2 msg.data[stack[-1]:stack[-1] + 0x20] // @09E3 stack[-2] // } 09E1 5B JUMPDEST 09E2 35 CALLDATALOAD 09E3 90 SWAP1 09E4 6B PUSH12 0x7fffffffffffffffffffffff 09F1 81 DUP2 09F2 11 GT 09F3 61 PUSH2 0x0c5b 09F6 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @09E3 stack[-1] = stack[-2] // @09E3 stack[-2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0c5b, if stack[-2] > 0x7fffffffffffffffffffffff label_09F7: // Incoming jump from 0x09F6, if not stack[-2] > 0x7fffffffffffffffffffffff // Inputs[1] { @09F7 stack[-2] } 09F7 81 DUP2 09F8 15 ISZERO 09F9 61 PUSH2 0x0c34 09FC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c34, if !stack[-2] label_09FD: // Incoming jump from 0x09FC, if not !stack[-2] // Inputs[4] // { // @0A00 stack[-1] // @0A01 stack[-11] // @0A47 memory[0x00:0x20] // @0A48 storage[keccak256(memory[0x00:0x20])] // } 09FD 61 PUSH2 0x0a4e 0A00 81 DUP2 0A01 8C DUP13 0A02 90 SWAP1 0A03 60 PUSH1 0xe0 0A05 91 SWAP2 0A06 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 0A27 82 DUP3 0A28 60 PUSH1 0x03 0A2A 1C SHR 0A2B 91 SWAP2 0A2C 60 PUSH1 0x5c 0A2E 1B SHL 0A2F 16 AND 0A30 17 OR 0A31 60 PUSH1 0x07 0A33 60 PUSH1 0xfd 0A35 1B SHL 0A36 17 OR 0A37 60 PUSH1 0x00 0A39 52 MSTORE 0A3A 60 PUSH1 0x05 0A3C 1B SHL 0A3D 16 AND 0A3E 61 PUSH2 0xffff 0A41 81 DUP2 0A42 1B SHL 0A43 60 PUSH1 0x20 0A45 60 PUSH1 0x00 0A47 20 SHA3 0A48 54 SLOAD 0A49 16 AND 0A4A 90 SWAP1 0A4B 1C SHR 0A4C 90 SWAP1 0A4D 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0A39 memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-11] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-1] >> 0x03) // @0A4C stack[0] = (storage[keccak256(memory[0x00:0x20])] & (0xffff << ((stack[-1] << 0x05) & 0xe0))) >> ((stack[-1] << 0x05) & 0xe0) // } // Block ends with unconditional jump to 0x0a4e label_0A4E: // Incoming jump from 0x0A4D // Inputs[2] // { // @0A4F stack[-3] // @0A4F stack[-1] // } 0A4E 5B JUMPDEST 0A4F 91 SWAP2 0A50 80 DUP1 0A51 83 DUP4 0A52 01 ADD 0A53 61 PUSH2 0xffff 0A56 93 SWAP4 0A57 84 DUP5 0A58 82 DUP3 0A59 11 GT 0A5A 61 PUSH2 0x0c0d 0A5D 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0A4F stack[-1] = stack[-3] // @0A52 stack[0] = stack[-1] + stack[-3] // @0A56 stack[-3] = 0xffff // @0A56 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x0c0d, if stack[-1] + stack[-3] > 0xffff label_0A5E: // Incoming jump from 0x0A5D, if not stack[-1] + stack[-3] > 0xffff // Inputs[2] // { // @0A5E stack[-2] // @0A5F stack[-1] // } 0A5E 81 DUP2 0A5F 10 LT 0A60 61 PUSH2 0x0be6 0A63 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0be6, if stack[-2] < stack[-1] label_0A64: // Incoming jump from 0x0A63, if not stack[-2] < stack[-1] // Inputs[5] // { // @0A67 stack[-1] // @0A68 stack[-3] // @0A69 stack[-13] // @0AA7 memory[0x00:0x20] // @0AB6 storage[keccak256(memory[0x00:0x20])] // } 0A64 61 PUSH2 0x0ac2 0A67 90 SWAP1 0A68 83 DUP4 0A69 8E DUP15 0A6A 91 SWAP2 0A6B 90 SWAP1 0A6C 91 SWAP2 0A6D 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 0A8E 83 DUP4 0A8F 60 PUSH1 0x03 0A91 1C SHR 0A92 91 SWAP2 0A93 60 PUSH1 0x5c 0A95 1B SHL 0A96 16 AND 0A97 17 OR 0A98 60 PUSH1 0x07 0A9A 60 PUSH1 0xfd 0A9C 1B SHL 0A9D 17 OR 0A9E 60 PUSH1 0x00 0AA0 52 MSTORE 0AA1 60 PUSH1 0xe0 0AA3 60 PUSH1 0x20 0AA5 60 PUSH1 0x00 0AA7 20 SHA3 0AA8 92 SWAP3 0AA9 83 DUP4 0AAA 60 PUSH1 0x00 0AAC 52 MSTORE 0AAD 60 PUSH1 0x05 0AAF 1B SHL 0AB0 16 AND 0AB1 90 SWAP1 0AB2 61 PUSH2 0xffff 0AB5 83 DUP4 0AB6 54 SLOAD 0AB7 91 SWAP2 0AB8 83 DUP4 0AB9 1B SHL 0ABA 92 SWAP3 0ABB 1B SHL 0ABC 19 NOT 0ABD 16 AND 0ABE 17 OR 0ABF 90 SWAP1 0AC0 55 SSTORE 0AC1 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0AA0 memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-13] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-3] >> 0x03) // @0AAC memory[0x00:0x20] = keccak256(memory[0x00:0x20]) // @0AC0 storage[keccak256(memory[0x00:0x20])] = (~(0xffff << ((stack[-3] << 0x05) & 0xe0)) & storage[keccak256(memory[0x00:0x20])]) | (stack[-1] << ((stack[-3] << 0x05) & 0xe0)) // } // Block ends with unconditional jump to 0x0ac2 label_0AC2: // Incoming jump from 0x0AC1 // Inputs[4] // { // @0AC6 stack[-2] // @0AC7 stack[-12] // @0B0F memory[0x00:0x20] // @0B10 storage[keccak256(memory[0x00:0x20])] // } 0AC2 5B JUMPDEST 0AC3 61 PUSH2 0x0b19 0AC6 82 DUP3 0AC7 8D DUP14 0AC8 90 SWAP1 0AC9 60 PUSH1 0xe0 0ACB 91 SWAP2 0ACC 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 0AED 82 DUP3 0AEE 60 PUSH1 0x03 0AF0 1C SHR 0AF1 91 SWAP2 0AF2 60 PUSH1 0x5c 0AF4 1B SHL 0AF5 16 AND 0AF6 17 OR 0AF7 60 PUSH1 0x07 0AF9 60 PUSH1 0xfd 0AFB 1B SHL 0AFC 17 OR 0AFD 60 PUSH1 0x00 0AFF 52 MSTORE 0B00 60 PUSH1 0x05 0B02 1B SHL 0B03 16 AND 0B04 63 PUSH4 0xffff0000 0B09 81 DUP2 0B0A 1B SHL 0B0B 60 PUSH1 0x20 0B0D 60 PUSH1 0x00 0B0F 20 SHA3 0B10 54 SLOAD 0B11 16 AND 0B12 90 SWAP1 0B13 1C SHR 0B14 60 PUSH1 0x10 0B16 1C SHR 0B17 90 SWAP1 0B18 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0AFF memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-12] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-2] >> 0x03) // @0B17 stack[0] = ((storage[keccak256(memory[0x00:0x20])] & (0xffff0000 << ((stack[-2] << 0x05) & 0xe0))) >> ((stack[-2] << 0x05) & 0xe0)) >> 0x10 // } // Block ends with unconditional jump to 0x0b19 label_0B19: // Incoming jump from 0x0B18 // Inputs[3] // { // @0B1A stack[-1] // @0B1A stack[-2] // @0B1D stack[-4] // } 0B19 5B JUMPDEST 0B1A 90 SWAP1 0B1B 81 DUP2 0B1C 01 ADD 0B1D 92 SWAP3 0B1E 83 DUP4 0B1F 11 GT 0B20 61 PUSH2 0x0bbf 0B23 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0B1A stack[-2] = stack[-1] // @0B1D stack[-4] = stack[-1] + stack[-2] // } // Block ends with conditional jump to 0x0bbf, if stack[-1] + stack[-2] > stack[-4] label_0B24: // Incoming jump from 0x0B23, if not stack[-1] + stack[-2] > stack[-4] // Inputs[2] // { // @0B24 stack[-3] // @0B25 stack[-1] // } 0B24 82 DUP3 0B25 10 LT 0B26 61 PUSH2 0x0b98 0B29 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b98, if stack[-3] < stack[-1] label_0B2A: // Incoming jump from 0x0B29, if not stack[-3] < stack[-1] // Inputs[8] // { // @0B2A stack[-1] // @0B2A stack[-3] // @0B30 stack[-2] // @0B31 stack[-12] // @0B32 stack[-4] // @0B34 stack[-11] // @0B72 memory[0x00:0x20] // @0B83 storage[keccak256(memory[0x00:0x20])] // } 0B2A 91 SWAP2 0B2B 61 PUSH2 0x0b92 0B2E 60 PUSH1 0x01 0B30 92 SWAP3 0B31 8D DUP14 0B32 95 SWAP6 0B33 94 SWAP5 0B34 8D DUP14 0B35 91 SWAP2 0B36 90 SWAP1 0B37 91 SWAP2 0B38 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 0B59 83 DUP4 0B5A 60 PUSH1 0x03 0B5C 1C SHR 0B5D 91 SWAP2 0B5E 60 PUSH1 0x5c 0B60 1B SHL 0B61 16 AND 0B62 17 OR 0B63 60 PUSH1 0x07 0B65 60 PUSH1 0xfd 0B67 1B SHL 0B68 17 OR 0B69 60 PUSH1 0x00 0B6B 52 MSTORE 0B6C 60 PUSH1 0xe0 0B6E 60 PUSH1 0x20 0B70 60 PUSH1 0x00 0B72 20 SHA3 0B73 92 SWAP3 0B74 83 DUP4 0B75 60 PUSH1 0x00 0B77 52 MSTORE 0B78 60 PUSH1 0x05 0B7A 1B SHL 0B7B 16 AND 0B7C 90 SWAP1 0B7D 63 PUSH4 0xffff0000 0B82 83 DUP4 0B83 54 SLOAD 0B84 91 SWAP2 0B85 60 PUSH1 0x10 0B87 1B SHL 0B88 83 DUP4 0B89 1B SHL 0B8A 92 SWAP3 0B8B 1B SHL 0B8C 19 NOT 0B8D 16 AND 0B8E 17 OR 0B8F 90 SWAP1 0B90 55 SSTORE 0B91 56 *JUMP // Stack delta = +0 // Outputs[7] // { // @0B2A stack[-1] = stack[-3] // @0B30 stack[-2] = 0x01 // @0B32 stack[-4] = stack[-12] // @0B33 stack[-3] = stack[-4] // @0B6B memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-11] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-1] >> 0x03) // @0B77 memory[0x00:0x20] = keccak256(memory[0x00:0x20]) // @0B90 storage[keccak256(memory[0x00:0x20])] = (~(0xffff0000 << ((stack[-1] << 0x05) & 0xe0)) & storage[keccak256(memory[0x00:0x20])]) | ((stack[-2] << 0x10) << ((stack[-1] << 0x05) & 0xe0)) // } // Block ends with unconditional jump to 0x0b92 label_0B92: // Incoming jump from 0x0B91 // Inputs[2] // { // @0B93 stack[-1] // @0B93 stack[-2] // } 0B92 5B JUMPDEST 0B93 01 ADD 0B94 61 PUSH2 0x093b 0B97 56 *JUMP // Stack delta = -1 // Outputs[1] { @0B93 stack[-2] = stack[-1] + stack[-2] } // Block ends with unconditional jump to 0x093b label_0B98: // Incoming jump from 0x0B29, if stack[-3] < stack[-1] // Inputs[3] // { // @0B99 stack[-10] // @0B9A stack[-12] // @0BBE memory[stack[-12]:stack[-12] + stack[-10]] // } 0B98 5B JUMPDEST 0B99 89 DUP10 0B9A 8C DUP13 0B9B 7F PUSH32 0xb6cdf5d000000000000000000000000000000000000000000000000000000000 0BBC 81 DUP2 0BBD 52 MSTORE 0BBE FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0BBD memory[stack[-12]:stack[-12] + 0x20] = 0xb6cdf5d000000000000000000000000000000000000000000000000000000000 // @0BBE revert(memory[stack[-12]:stack[-12] + stack[-10]]); // } // Block terminates label_0BBF: // Incoming jump from 0x0B23, if stack[-1] + stack[-2] > stack[-4] // Inputs[3] // { // @0BC0 stack[-11] // @0BC1 stack[-13] // @0BE5 memory[stack[-13]:stack[-13] + stack[-11]] // } 0BBF 5B JUMPDEST 0BC0 8A DUP11 0BC1 8D DUP14 0BC2 7F PUSH32 0xb6cdf5d000000000000000000000000000000000000000000000000000000000 0BE3 81 DUP2 0BE4 52 MSTORE 0BE5 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0BE4 memory[stack[-13]:stack[-13] + 0x20] = 0xb6cdf5d000000000000000000000000000000000000000000000000000000000 // @0BE5 revert(memory[stack[-13]:stack[-13] + stack[-11]]); // } // Block terminates label_0BE6: // Incoming jump from 0x0A63, if stack[-2] < stack[-1] // Inputs[3] // { // @0BE7 stack[-12] // @0BE8 stack[-14] // @0C0C memory[stack[-14]:stack[-14] + stack[-12]] // } 0BE6 5B JUMPDEST 0BE7 8B DUP12 0BE8 8E DUP15 0BE9 7F PUSH32 0xb6cdf5d000000000000000000000000000000000000000000000000000000000 0C0A 81 DUP2 0C0B 52 MSTORE 0C0C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C0B memory[stack[-14]:stack[-14] + 0x20] = 0xb6cdf5d000000000000000000000000000000000000000000000000000000000 // @0C0C revert(memory[stack[-14]:stack[-14] + stack[-12]]); // } // Block terminates label_0C0D: // Incoming jump from 0x0A5D, if stack[-1] + stack[-3] > 0xffff // Inputs[3] // { // @0C0E stack[-13] // @0C0F stack[-15] // @0C33 memory[stack[-15]:stack[-15] + stack[-13]] // } 0C0D 5B JUMPDEST 0C0E 8C DUP13 0C0F 8F DUP16 0C10 7F PUSH32 0xb6cdf5d000000000000000000000000000000000000000000000000000000000 0C31 81 DUP2 0C32 52 MSTORE 0C33 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C32 memory[stack[-15]:stack[-15] + 0x20] = 0xb6cdf5d000000000000000000000000000000000000000000000000000000000 // @0C33 revert(memory[stack[-15]:stack[-15] + stack[-13]]); // } // Block terminates label_0C34: // Incoming jump from 0x09FC, if !stack[-2] // Inputs[3] // { // @0C35 stack[-10] // @0C36 stack[-12] // @0C5A memory[stack[-12]:stack[-12] + stack[-10]] // } 0C34 5B JUMPDEST 0C35 89 DUP10 0C36 8C DUP13 0C37 7F PUSH32 0xb562e8dd00000000000000000000000000000000000000000000000000000000 0C58 81 DUP2 0C59 52 MSTORE 0C5A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C59 memory[stack[-12]:stack[-12] + 0x20] = 0xb562e8dd00000000000000000000000000000000000000000000000000000000 // @0C5A revert(memory[stack[-12]:stack[-12] + stack[-10]]); // } // Block terminates label_0C5B: // Incoming jump from 0x09F6, if stack[-2] > 0x7fffffffffffffffffffffff // Inputs[3] // { // @0C5C stack[-10] // @0C5D stack[-12] // @0C81 memory[stack[-12]:stack[-12] + stack[-10]] // } 0C5B 5B JUMPDEST 0C5C 89 DUP10 0C5D 8C DUP13 0C5E 7F PUSH32 0x8ceeefe200000000000000000000000000000000000000000000000000000000 0C7F 81 DUP2 0C80 52 MSTORE 0C81 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C80 memory[stack[-12]:stack[-12] + 0x20] = 0x8ceeefe200000000000000000000000000000000000000000000000000000000 // @0C81 revert(memory[stack[-12]:stack[-12] + stack[-10]]); // } // Block terminates label_0C82: // Incoming jump from 0x0937, if stack[-3] - stack[-5] // Inputs[3] // { // @0C83 stack[-7] // @0C84 stack[-9] // @0CA8 memory[stack[-9]:stack[-9] + stack[-7]] // } 0C82 5B JUMPDEST 0C83 86 DUP7 0C84 89 DUP10 0C85 7F PUSH32 0xa24a13a600000000000000000000000000000000000000000000000000000000 0CA6 81 DUP2 0CA7 52 MSTORE 0CA8 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0CA7 memory[stack[-9]:stack[-9] + 0x20] = 0xa24a13a600000000000000000000000000000000000000000000000000000000 // @0CA8 revert(memory[stack[-9]:stack[-9] + stack[-7]]); // } // Block terminates label_0CA9: // Incoming jump from 0x0930, if !(stack[-9] & stack[-1]) // Inputs[3] // { // @0CAA stack[-7] // @0CAB stack[-9] // @0CCF memory[stack[-9]:stack[-9] + stack[-7]] // } 0CA9 5B JUMPDEST 0CAA 86 DUP7 0CAB 89 DUP10 0CAC 7F PUSH32 0x2e07630000000000000000000000000000000000000000000000000000000000 0CCD 81 DUP2 0CCE 52 MSTORE 0CCF FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0CCE memory[stack[-9]:stack[-9] + 0x20] = 0x2e07630000000000000000000000000000000000000000000000000000000000 // @0CCF revert(memory[stack[-9]:stack[-9] + stack[-7]]); // } // Block terminates label_0CD0: // Incoming jump from 0x0919, if msg.sender - (storage[stack[-8]] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[3] // { // @0CD1 stack[-6] // @0CD8 storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] // @0CDA msg.sender // } 0CD0 5B JUMPDEST 0CD1 85 DUP6 0CD2 63 PUSH4 0x8b78c6d8 0CD7 19 NOT 0CD8 54 SLOAD 0CD9 16 AND 0CDA 33 CALLER 0CDB 03 SUB 0CDC 15 ISZERO 0CDD 61 PUSH2 0x091a 0CE0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x091a, if !(msg.sender - (storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] & stack[-6])) label_0CE1: // Incoming jump from 0x0CE0, if not !(msg.sender - (storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] & stack[-6])) // Inputs[4] // { // @0CE1 stack[-7] // @0CE2 stack[-1] // @0CE3 memory[stack[-1]:stack[-1] + 0x20] // @0D07 memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + stack[-7]] // } 0CE1 86 DUP7 0CE2 90 SWAP1 0CE3 51 MLOAD 0CE4 7F PUSH32 0xea8e4eb500000000000000000000000000000000000000000000000000000000 0D05 81 DUP2 0D06 52 MSTORE 0D07 FD *REVERT // Stack delta = -1 // Outputs[2] // { // @0D06 memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + 0x20] = 0xea8e4eb500000000000000000000000000000000000000000000000000000000 // @0D07 revert(memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + stack[-7]]); // } // Block terminates label_0D08: // Incoming jump from 0x00E3, if 0xa22cb465 == stack[-2] // Inputs[1] { @0D0B msg.value } 0D08 5B JUMPDEST 0D09 50 POP 0D0A 50 POP 0D0B 34 CALLVALUE 0D0C 61 PUSH2 0x0172 0D0F 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0172, if msg.value label_0D10: // Incoming jump from 0x0D0F, if not msg.value // Inputs[2] // { // @0D10 stack[-1] // @0D14 msg.data.length // } 0D10 80 DUP1 0D11 60 PUSH1 0x03 0D13 19 NOT 0D14 36 CALLDATASIZE 0D15 01 ADD 0D16 12 SLT 0D17 61 PUSH2 0x0172 0D1A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0172, if msg.data.length + ~0x03 i< stack[-1] label_0D1B: // Incoming jump from 0x0D1A, if not msg.data.length + ~0x03 i< stack[-1] 0D1B 61 PUSH2 0x0d22 0D1E 61 PUSH2 0x20f2 0D21 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D1B stack[0] = 0x0d22 } // Block ends with call to 0x20f2, returns to 0x0D22 label_0D22: // Incoming return from call to 0x20F2 at 0x0D21 // Inputs[2] // { // @0D25 msg.data[0x24:0x44] // @0D26 stack[-1] // } 0D22 5B JUMPDEST 0D23 60 PUSH1 0x24 0D25 35 CALLDATALOAD 0D26 90 SWAP1 0D27 81 DUP2 0D28 15 ISZERO 0D29 15 ISZERO 0D2A 82 DUP3 0D2B 03 SUB 0D2C 61 PUSH2 0x0da0 0D2F 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0D26 stack[0] = stack[-1] // @0D26 stack[-1] = msg.data[0x24:0x44] // } // Block ends with conditional jump to 0x0da0, if msg.data[0x24:0x44] - !!msg.data[0x24:0x44] label_0D30: // Incoming jump from 0x0D2F, if not msg.data[0x24:0x44] - !!msg.data[0x24:0x44] // Inputs[9] // { // @0D45 stack[-1] // @0D46 msg.sender // @0D47 stack[-4] // @0D4A stack[-3] // @0D72 memory[stack[-4]:stack[-4] + stack[-3]] // @0D73 stack[-2] // @0D78 msg.sender // @0D9D memory[0x20:0x40] // @0D9F memory[stack[-4]:stack[-4] + stack[-4]] // } 0D30 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D45 90 SWAP1 0D46 33 CALLER 0D47 85 DUP6 0D48 52 MSTORE 0D49 16 AND 0D4A 91 SWAP2 0D4B 82 DUP3 0D4C 7F PUSH32 0xd000000000000000000000000000000000000000000000000000000000000000 0D6D 17 OR 0D6E 60 PUSH1 0x20 0D70 52 MSTORE 0D71 83 DUP4 0D72 20 SHA3 0D73 81 DUP2 0D74 60 PUSH1 0x20 0D76 52 MSTORE 0D77 55 SSTORE 0D78 33 CALLER 0D79 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0D9A 60 PUSH1 0x20 0D9C 80 DUP1 0D9D A3 LOG3 0D9E 80 DUP1 0D9F F3 *RETURN // Stack delta = -4 // Outputs[6] // { // @0D48 memory[stack[-4]:stack[-4] + 0x20] = msg.sender // @0D70 memory[0x20:0x40] = 0xd000000000000000000000000000000000000000000000000000000000000000 | (stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff) // @0D76 memory[0x20:0x40] = stack[-2] // @0D77 storage[keccak256(memory[stack[-4]:stack[-4] + stack[-3]])] = stack[-2] // @0D9D log(memory[0x20:0x40], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); // @0D9F return memory[stack[-4]:stack[-4] + stack[-4]]; // } // Block terminates label_0DA0: // Incoming jump from 0x1EC1, if msg.data.length + ~0x03 i< 0x20 // Incoming jump from 0x0D2F, if msg.data[0x24:0x44] - !!msg.data[0x24:0x44] // Inputs[2] // { // @0DA1 stack[-4] // @0DA3 memory[stack[-4]:stack[-4] + stack[-4]] // } 0DA0 5B JUMPDEST 0DA1 83 DUP4 0DA2 80 DUP1 0DA3 FD *REVERT // Stack delta = +0 // Outputs[1] { @0DA3 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_0DA4: // Incoming jump from 0x00D8, if 0x9a604a7a == stack[-2] // Inputs[2] // { // @0DA5 stack[-4] // @0DA6 msg.value // } 0DA4 5B JUMPDEST 0DA5 83 DUP4 0DA6 34 CALLVALUE 0DA7 61 PUSH2 0x082b 0DAA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0DA5 stack[0] = stack[-4] } // Block ends with conditional jump to 0x082b, if msg.value label_0DAB: // Incoming jump from 0x0DAA, if not msg.value // Inputs[1] { @0DB0 msg.data.length } 0DAB 60 PUSH1 0x20 0DAD 60 PUSH1 0x03 0DAF 19 NOT 0DB0 36 CALLDATASIZE 0DB1 01 ADD 0DB2 12 SLT 0DB3 61 PUSH2 0x082b 0DB6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x082b, if msg.data.length + ~0x03 i< 0x20 label_0DB7: // Incoming jump from 0x0DB6, if not msg.data.length + ~0x03 i< 0x20 0DB7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DCC 61 PUSH2 0x0dd3 0DCF 61 PUSH2 0x20f2 0DD2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0DB7 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff // @0DCC stack[1] = 0x0dd3 // } // Block ends with call to 0x20f2, returns to 0x0DD3 label_0DD3: // Incoming return from call to 0x20F2 at 0x0DD2 0DD3 5B JUMPDEST 0DD4 61 PUSH2 0x0ddb 0DD7 61 PUSH2 0x2833 0DDA 56 *JUMP // Stack delta = +1 // Outputs[1] { @0DD4 stack[0] = 0x0ddb } // Block ends with call to 0x2833, returns to 0x0DDB label_0DDB: // Incoming return from call to 0x2833 at 0x0DDA // Inputs[5] // { // @0DDC stack[-2] // @0DDC stack[-1] // @0DFE stack[-3] // @0DFF storage[stack[-3]] // @0E05 memory[stack[-3]:stack[-3] + stack[-3]] // } 0DDB 5B JUMPDEST 0DDC 16 AND 0DDD 7F PUSH32 0xffffffffffffffffffffffff0000000000000000000000000000000000000000 0DFE 82 DUP3 0DFF 54 SLOAD 0E00 16 AND 0E01 17 OR 0E02 81 DUP2 0E03 55 SSTORE 0E04 80 DUP1 0E05 F3 *RETURN // Stack delta = -3 // Outputs[2] // { // @0E03 storage[stack[-3]] = (storage[stack[-3]] & 0xffffffffffffffffffffffff0000000000000000000000000000000000000000) | (stack[-1] & stack[-2]) // @0E05 return memory[stack[-3]:stack[-3] + stack[-3]]; // } // Block terminates label_0E06: // Incoming jump from 0x00CD, if 0x96a1521e == stack[-2] // Inputs[2] // { // @0E07 stack[-4] // @0E08 msg.value // } 0E06 5B JUMPDEST 0E07 83 DUP4 0E08 34 CALLVALUE 0E09 61 PUSH2 0x082b 0E0C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E07 stack[0] = stack[-4] } // Block ends with conditional jump to 0x082b, if msg.value label_0E0D: // Incoming jump from 0x0E0C, if not msg.value // Inputs[1] { @0E12 msg.data.length } 0E0D 60 PUSH1 0x20 0E0F 60 PUSH1 0x03 0E11 19 NOT 0E12 36 CALLDATASIZE 0E13 01 ADD 0E14 12 SLT 0E15 61 PUSH2 0x082b 0E18 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x082b, if msg.data.length + ~0x03 i< 0x20 label_0E19: // Incoming jump from 0x0E18, if not msg.data.length + ~0x03 i< 0x20 0E19 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E2E 61 PUSH2 0x0e35 0E31 61 PUSH2 0x20f2 0E34 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0E19 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff // @0E2E stack[1] = 0x0e35 // } // Block ends with call to 0x20f2, returns to 0x0E35 label_0E35: // Incoming return from call to 0x20F2 at 0x0E34 0E35 5B JUMPDEST 0E36 61 PUSH2 0x0e3d 0E39 61 PUSH2 0x2833 0E3C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E36 stack[0] = 0x0e3d } // Block ends with call to 0x2833, returns to 0x0E3D label_0E3D: // Incoming return from call to 0x2833 at 0x0E3C // Inputs[5] // { // @0E3E stack[-2] // @0E3E stack[-1] // @0E62 storage[0x01] // @0E68 stack[-3] // @0E69 memory[stack[-3]:stack[-3] + stack[-3]] // } 0E3D 5B JUMPDEST 0E3E 16 AND 0E3F 7F PUSH32 0xffffffffffffffffffffffff0000000000000000000000000000000000000000 0E60 60 PUSH1 0x01 0E62 54 SLOAD 0E63 16 AND 0E64 17 OR 0E65 60 PUSH1 0x01 0E67 55 SSTORE 0E68 80 DUP1 0E69 F3 *RETURN // Stack delta = -3 // Outputs[2] // { // @0E67 storage[0x01] = (storage[0x01] & 0xffffffffffffffffffffffff0000000000000000000000000000000000000000) | (stack[-1] & stack[-2]) // @0E69 return memory[stack[-3]:stack[-3] + stack[-3]]; // } // Block terminates label_0E6A: // Incoming jump from 0x00C2, if 0x95d89b41 == stack[-2] // Inputs[4] // { // @0E6B stack[-3] // @0E6B stack[-1] // @0E6C stack[-2] // @0E6E msg.value // } 0E6A 5B JUMPDEST 0E6B 91 SWAP2 0E6C 90 SWAP1 0E6D 50 POP 0E6E 34 CALLVALUE 0E6F 61 PUSH2 0x079a 0E72 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0E6B stack[-3] = stack[-1] // @0E6C stack[-2] = stack[-3] // } // Block ends with conditional jump to 0x079a, if msg.value label_0E73: // Incoming jump from 0x0E72, if not msg.value // Inputs[2] // { // @0E73 stack[-3] // @0E77 msg.data.length // } 0E73 82 DUP3 0E74 60 PUSH1 0x03 0E76 19 NOT 0E77 36 CALLDATASIZE 0E78 01 ADD 0E79 12 SLT 0E7A 61 PUSH2 0x079a 0E7D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x079a, if msg.data.length + ~0x03 i< stack[-3] label_0E7E: // Incoming jump from 0x0E7D, if not msg.data.length + ~0x03 i< stack[-3] // Inputs[4] // { // @0E81 stack[-3] // @0E83 stack[-1] // @0E84 memory[stack[-1]:stack[-1] + 0x20] // @0E85 stack[-2] // } 0E7E 61 PUSH2 0x0ec8 0E81 92 SWAP3 0E82 50 POP 0E83 80 DUP1 0E84 51 MLOAD 0E85 91 SWAP2 0E86 61 PUSH2 0x0e8e 0E89 83 DUP4 0E8A 61 PUSH2 0x2203 0E8D 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0E81 stack[-3] = 0x0ec8 // @0E85 stack[0] = stack[-2] // @0E85 stack[-2] = memory[stack[-1]:stack[-1] + 0x20] // @0E86 stack[1] = 0x0e8e // @0E89 stack[2] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x2203, returns to 0x0E8E label_0E8E: // Incoming return from call to 0x2203 at 0x0E8D // Inputs[5] // { // @0E8F stack[-3] // @0E90 stack[-1] // @0EB7 stack[-2] // @0EB7 memory[stack[-2]:stack[-2] + 0x20] // @0EB8 stack[-4] // } 0E8E 5B JUMPDEST 0E8F 82 DUP3 0E90 52 MSTORE 0E91 7F PUSH32 0x54434b5400000000000000000000000000000000000000000000000000000000 0EB2 60 PUSH1 0x20 0EB4 83 DUP4 0EB5 01 ADD 0EB6 52 MSTORE 0EB7 51 MLOAD 0EB8 91 SWAP2 0EB9 82 DUP3 0EBA 91 SWAP2 0EBB 60 PUSH1 0x20 0EBD 83 DUP4 0EBE 52 MSTORE 0EBF 60 PUSH1 0x20 0EC1 83 DUP4 0EC2 01 ADD 0EC3 90 SWAP1 0EC4 61 PUSH2 0x213d 0EC7 56 *JUMP // Stack delta = +1 // Outputs[8] // { // @0E90 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] // @0EB6 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = 0x54434b5400000000000000000000000000000000000000000000000000000000 // @0EB8 stack[-2] = stack[-4] // @0EB8 stack[-4] = memory[stack[-2]:stack[-2] + 0x20] // @0EBA stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @0EBE memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + 0x20] = 0x20 // @0EC3 stack[-1] = memory[stack[-2]:stack[-2] + 0x20] + 0x20 // @0EC3 stack[0] = stack[-3] // } // Block ends with unconditional jump to 0x213d label_0EC8: // Incoming return from call to 0x1FB4 at 0x1FB3 // Incoming return from call to 0x102F at 0x1F0C // Incoming return from call to 0x0E8E at 0x0E8D // Inputs[4] // { // @0EC9 stack[-2] // @0EC9 stack[-1] // @0ECA stack[-3] // @0ECB memory[stack[-3]:stack[-3] + stack[-1] - stack[-2]] // } 0EC8 5B JUMPDEST 0EC9 03 SUB 0ECA 90 SWAP1 0ECB F3 *RETURN // Stack delta = -3 // Outputs[1] { @0ECB return memory[stack[-3]:stack[-3] + stack[-1] - stack[-2]]; } // Block terminates label_0ECC: // Incoming jump from 0x00B7, if 0x8da5cb5b == stack[-2] // Inputs[1] { @0ECF msg.value } 0ECC 5B JUMPDEST 0ECD 50 POP 0ECE 50 POP 0ECF 34 CALLVALUE 0ED0 61 PUSH2 0x0172 0ED3 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0172, if msg.value label_0ED4: // Incoming jump from 0x0ED3, if not msg.value // Inputs[2] // { // @0ED4 stack[-2] // @0ED8 msg.data.length // } 0ED4 81 DUP2 0ED5 60 PUSH1 0x03 0ED7 19 NOT 0ED8 36 CALLDATASIZE 0ED9 01 ADD 0EDA 12 SLT 0EDB 61 PUSH2 0x0172 0EDE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0172, if msg.data.length + ~0x03 i< stack[-2] label_0EDF: // Incoming jump from 0x0EDE, if not msg.data.length + ~0x03 i< stack[-2] // Inputs[4] // { // @0EE1 stack[-1] // @0EFD storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] // @0EFF memory[stack[-1]:stack[-1] + 0x20] // @0F04 memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + 0x20] // } 0EDF 60 PUSH1 0x20 0EE1 90 SWAP1 0EE2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EF7 63 PUSH4 0x8b78c6d8 0EFC 19 NOT 0EFD 54 SLOAD 0EFE 91 SWAP2 0EFF 51 MLOAD 0F00 91 SWAP2 0F01 16 AND 0F02 81 DUP2 0F03 52 MSTORE 0F04 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0F03 memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + 0x20] = storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] & 0xffffffffffffffffffffffffffffffffffffffff // @0F04 return memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + 0x20]; // } // Block terminates label_0F05: // Incoming jump from 0x00AC, if 0x862440e2 == stack[-2] // Inputs[4] // { // @0F06 stack[-3] // @0F06 stack[-1] // @0F07 stack[-2] // @0F09 msg.value // } 0F05 5B JUMPDEST 0F06 91 SWAP2 0F07 90 SWAP1 0F08 50 POP 0F09 34 CALLVALUE 0F0A 61 PUSH2 0x079a 0F0D 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0F06 stack[-3] = stack[-1] // @0F07 stack[-2] = stack[-3] // } // Block ends with conditional jump to 0x079a, if msg.value label_0F0E: // Incoming jump from 0x0F0D, if not msg.value // Inputs[2] // { // @0F0E stack[-1] // @0F12 msg.data.length // } 0F0E 80 DUP1 0F0F 60 PUSH1 0x03 0F11 19 NOT 0F12 36 CALLDATASIZE 0F13 01 ADD 0F14 12 SLT 0F15 61 PUSH2 0x079a 0F18 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x079a, if msg.data.length + ~0x03 i< stack[-1] label_0F19: // Incoming jump from 0x0F18, if not msg.data.length + ~0x03 i< stack[-1] // Inputs[3] // { // @0F19 stack[-2] // @0F1A msg.data[stack[-2]:stack[-2] + 0x20] // @0F20 msg.data[0x24:0x44] // } 0F19 81 DUP2 0F1A 35 CALLDATALOAD 0F1B 91 SWAP2 0F1C 60 PUSH1 0x24 0F1E 90 SWAP1 0F1F 81 DUP2 0F20 35 CALLDATALOAD 0F21 90 SWAP1 0F22 67 PUSH8 0xffffffffffffffff 0F2B 90 SWAP1 0F2C 81 DUP2 0F2D 83 DUP4 0F2E 11 GT 0F2F 61 PUSH2 0x11ff 0F32 57 *JUMPI // Stack delta = +4 // Outputs[5] // { // @0F1B stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0F1E stack[0] = 0x24 // @0F21 stack[1] = msg.data[0x24:0x44] // @0F2B stack[3] = stack[-2] // @0F2B stack[2] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x11ff, if msg.data[0x24:0x44] > 0xffffffffffffffff label_0F33: // Incoming jump from 0x0F32, if not msg.data[0x24:0x44] > 0xffffffffffffffff // Inputs[2] // { // @0F33 msg.data.length // @0F36 stack[-3] // } 0F33 36 CALLDATASIZE 0F34 60 PUSH1 0x23 0F36 84 DUP5 0F37 01 ADD 0F38 12 SLT 0F39 15 ISZERO 0F3A 61 PUSH2 0x11ff 0F3D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11ff, if !(stack[-3] + 0x23 i< msg.data.length) label_0F3E: // Incoming jump from 0x0F3D, if not !(stack[-3] + 0x23 i< msg.data.length) // Inputs[4] // { // @0F3E stack[-3] // @0F3F stack[-1] // @0F40 msg.data[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] // @0F41 stack[-2] // } 0F3E 82 DUP3 0F3F 01 ADD 0F40 35 CALLDATALOAD 0F41 90 SWAP1 0F42 81 DUP2 0F43 11 GT 0F44 61 PUSH2 0x11fb 0F47 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0F41 stack[-2] = msg.data[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] } // Block ends with conditional jump to 0x11fb, if msg.data[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] > stack[-2] label_0F48: // Incoming jump from 0x0F47, if not msg.data[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] > stack[-2] // Inputs[4] // { // @0F48 msg.data.length // @0F49 stack[-3] // @0F4A stack[-1] // @0F4B stack[-2] // } 0F48 36 CALLDATASIZE 0F49 83 DUP4 0F4A 82 DUP3 0F4B 84 DUP5 0F4C 01 ADD 0F4D 01 ADD 0F4E 11 GT 0F4F 61 PUSH2 0x11fb 0F52 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11fb, if stack[-2] + stack[-1] + stack[-3] > msg.data.length label_0F53: // Incoming jump from 0x0F52, if not stack[-2] + stack[-1] + stack[-3] > msg.data.length 0F53 61 PUSH2 0x0f5a 0F56 61 PUSH2 0x2833 0F59 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F53 stack[0] = 0x0f5a } // Block ends with call to 0x2833, returns to 0x0F5A label_0F5A: // Incoming return from call to 0x2833 at 0x0F59 // Inputs[8] // { // @0F5B stack[-5] // @0F5C stack[-6] // @0F5E stack[-1] // @0F61 stack[-3] // @0F66 stack[-4] // @0F68 memory[stack[-6]:stack[-6] + stack[-4]] // @0F69 stack[-2] // @0F6E storage[keccak256(memory[stack[-6]:stack[-6] + stack[-4]])] // } 0F5A 5B JUMPDEST 0F5B 84 DUP5 0F5C 86 DUP7 0F5D 52 MSTORE 0F5E 80 DUP1 0F5F 60 PUSH1 0x20 0F61 93 SWAP4 0F62 60 PUSH1 0x02 0F64 85 DUP6 0F65 52 MSTORE 0F66 85 DUP6 0F67 88 DUP9 0F68 20 SHA3 0F69 93 SWAP4 0F6A 61 PUSH2 0x0f73 0F6D 85 DUP6 0F6E 54 SLOAD 0F6F 61 PUSH2 0x2850 0F72 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0F5D memory[stack[-6]:stack[-6] + 0x20] = stack[-5] // @0F5E stack[0] = stack[-1] // @0F61 stack[1] = stack[-3] // @0F61 stack[-3] = 0x20 // @0F65 memory[0x20:0x40] = 0x02 // @0F69 stack[-2] = keccak256(memory[stack[-6]:stack[-6] + stack[-4]]) // @0F69 stack[2] = stack[-2] // @0F6A stack[3] = 0x0f73 // @0F6E stack[4] = storage[keccak256(memory[stack[-6]:stack[-6] + stack[-4]])] // } // Block ends with call to 0x2850, returns to 0x0F73 label_0F73: // Incoming return from call to 0x2850 at 0x0F72 // Inputs[1] { @0F76 stack[-1] } 0F73 5B JUMPDEST 0F74 60 PUSH1 0x1f 0F76 81 DUP2 0F77 11 GT 0F78 61 PUSH2 0x11ab 0F7B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11ab, if stack[-1] > 0x1f label_0F7C: // Incoming jump from 0x11E2 // Incoming jump from 0x0F7B, if not stack[-1] > 0x1f // Inputs[3] // { // @0F7E stack[-10] // @0F7F stack[-2] // @0F82 stack[-4] // } 0F7C 5B JUMPDEST 0F7D 50 POP 0F7E 88 DUP9 0F7F 90 SWAP1 0F80 60 PUSH1 0x1f 0F82 84 DUP5 0F83 11 GT 0F84 60 PUSH1 0x01 0F86 14 EQ 0F87 61 PUSH2 0x1103 0F8A 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0F7F stack[-1] = stack[-2] // @0F7F stack[-2] = stack[-10] // } // Block ends with conditional jump to 0x1103, if 0x01 == (stack[-4] > 0x1f) label_0F8B: // Incoming jump from 0x0F8A, if not 0x01 == (stack[-4] > 0x1f) // Inputs[2] // { // @0F8B stack[-10] // @0F8C stack[-4] // } 0F8B 89 DUP10 0F8C 93 SWAP4 0F8D 61 PUSH2 0x10f6 0F90 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0F8C stack[-4] = stack[-10] } // Block ends with conditional jump to 0x10f6, if stack[-4] label_0F91: // Incoming jump from 0x1102 // Incoming jump from 0x0F90, if not stack[-4] // Inputs[3] // { // @0FB6 stack[-5] // @0FC0 stack[-4] // @0FC2 stack[-6] // } 0F91 5B JUMPDEST 0F92 50 POP 0F93 50 POP 0F94 50 POP 0F95 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0FB6 82 DUP3 0FB7 60 PUSH1 0x01 0FB9 1B SHL 0FBA 92 SWAP3 0FBB 60 PUSH1 0x03 0FBD 1B SHL 0FBE 1C SHR 0FBF 19 NOT 0FC0 16 AND 0FC1 17 OR 0FC2 90 SWAP1 0FC3 55 SSTORE // Stack delta = -6 // Outputs[1] { @0FC3 storage[stack[-6]] = (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (stack[-5] << 0x03)) & stack[-4]) | (stack[-5] << 0x01) } // Block continues label_0FC4: // Incoming jump from 0x1158 // Incoming jump from 0x0FC3 // Inputs[7] // { // @0FC5 stack[-3] // @0FC6 stack[-4] // @0FCA stack[-1] // @0FCC stack[-2] // @0FCE memory[stack[-4]:stack[-4] + stack[-2]] // @0FD1 memory[stack[-2]:stack[-2] + 0x20] // @0FD6 storage[keccak256(memory[stack[-4]:stack[-4] + stack[-2]])] // } 0FC4 5B JUMPDEST 0FC5 82 DUP3 0FC6 84 DUP5 0FC7 52 MSTORE 0FC8 60 PUSH1 0x02 0FCA 81 DUP2 0FCB 52 MSTORE 0FCC 81 DUP2 0FCD 84 DUP5 0FCE 20 SHA3 0FCF 91 SWAP2 0FD0 80 DUP1 0FD1 51 MLOAD 0FD2 92 SWAP3 0FD3 85 DUP6 0FD4 90 SWAP1 0FD5 80 DUP1 0FD6 54 SLOAD 0FD7 61 PUSH2 0x0fdf 0FDA 81 DUP2 0FDB 61 PUSH2 0x2850 0FDE 56 *JUMP // Stack delta = +6 // Outputs[9] // { // @0FC7 memory[stack[-4]:stack[-4] + 0x20] = stack[-3] // @0FCB memory[stack[-1]:stack[-1] + 0x20] = 0x02 // @0FCF stack[0] = stack[-2] // @0FD2 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] // @0FD4 stack[2] = keccak256(memory[stack[-4]:stack[-4] + stack[-2]]) // @0FD4 stack[1] = stack[-4] // @0FD6 stack[3] = storage[keccak256(memory[stack[-4]:stack[-4] + stack[-2]])] // @0FD7 stack[4] = 0x0fdf // @0FDA stack[5] = storage[keccak256(memory[stack[-4]:stack[-4] + stack[-2]])] // } // Block ends with call to 0x2850, returns to 0x0FDF label_0FDF: // Incoming return from call to 0x2850 at 0x0FDE // Inputs[4] // { // @0FE0 stack[-1] // @0FE1 stack[-7] // @0FE3 stack[-3] // @0FE6 stack[-2] // } 0FDF 5B JUMPDEST 0FE0 80 DUP1 0FE1 87 DUP8 0FE2 52 MSTORE 0FE3 91 SWAP2 0FE4 60 PUSH1 0x01 0FE6 91 SWAP2 0FE7 80 DUP1 0FE8 83 DUP4 0FE9 16 AND 0FEA 90 SWAP1 0FEB 81 DUP2 0FEC 15 ISZERO 0FED 61 PUSH2 0x1098 0FF0 57 *JUMPI // Stack delta = +2 // Outputs[6] // { // @0FE2 memory[stack[-7]:stack[-7] + 0x20] = stack[-1] // @0FE3 stack[-1] = stack[-3] // @0FE3 stack[-3] = stack[-1] // @0FE6 stack[-2] = 0x01 // @0FEA stack[0] = 0x01 & stack[-2] // @0FEA stack[1] = stack[-2] // } // Block ends with conditional jump to 0x1098, if !(0x01 & stack[-2]) label_0FF1: // Incoming jump from 0x0FF0, if not !(0x01 & stack[-2]) // Inputs[1] { @0FF4 stack[-2] } 0FF1 50 POP 0FF2 60 PUSH1 0x01 0FF4 14 EQ 0FF5 61 PUSH2 0x1044 0FF8 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1044, if 0x01 == stack[-2] label_0FF9: // Incoming jump from 0x1084 // Incoming jump from 0x10F5 // Incoming jump from 0x0FF8, if not 0x01 == stack[-2] // Inputs[4] // { // @0FFD stack[-7] // @0FFE stack[-6] // @0FFF stack[-5] // @1028 stack[-4] // } 0FF9 5B JUMPDEST 0FFA 50 POP 0FFB 50 POP 0FFC 50 POP 0FFD 83 DUP4 0FFE 92 SWAP3 0FFF 91 SWAP2 1000 61 PUSH2 0x102f 1003 7F PUSH32 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b 1024 95 SWAP6 1025 61 PUSH2 0x103e 1028 93 SWAP4 1029 03 SUB 102A 85 DUP6 102B 61 PUSH2 0x226a 102E 56 *JUMP // Stack delta = +1 // Outputs[8] // { // @0FFE stack[-6] = stack[-7] // @0FFF stack[-5] = stack[-6] // @0FFF stack[-3] = stack[-5] // @1000 stack[-2] = 0x102f // @1024 stack[-7] = 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b // @1028 stack[-4] = 0x103e // @1029 stack[-1] = stack[-4] - stack[-7] // @102A stack[0] = stack[-7] // } // Block ends with call to 0x226a, returns to 0x102F label_102F: // Incoming return from call to 0x226A at 0x102E // Incoming return from call to 0x226A at 0x1F0C // Inputs[4] // { // @1030 stack[-1] // @1030 memory[stack[-1]:stack[-1] + 0x20] // @1031 stack[-4] // @1032 stack[-3] // } 102F 5B JUMPDEST 1030 51 MLOAD 1031 92 SWAP3 1032 82 DUP3 1033 84 DUP5 1034 93 SWAP4 1035 84 DUP5 1036 52 MSTORE 1037 83 DUP4 1038 01 ADD 1039 90 SWAP1 103A 61 PUSH2 0x213d 103D 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1031 stack[-4] = memory[stack[-1]:stack[-1] + 0x20] // @1034 stack[-3] = memory[stack[-1]:stack[-1] + 0x20] // @1036 memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + 0x20] = stack[-3] // @1039 stack[0] = stack[-4] // @1039 stack[-1] = memory[stack[-1]:stack[-1] + 0x20] + stack[-3] // } // Block ends with unconditional jump to 0x213d label_103E: // Incoming return from call to 0x102F at 0x102E // Inputs[8] // { // @103F stack[-1] // @103F stack[-2] // @1040 stack[-3] // @1041 stack[-4] // @1041 memory[stack[-3]:stack[-3] + stack[-1] - stack[-2]] // @1041 stack[-5] // @1042 stack[-6] // @1043 memory[stack[-6]:stack[-6] + stack[-6]] // } 103E 5B JUMPDEST 103F 03 SUB 1040 90 SWAP1 1041 A2 LOG2 1042 80 DUP1 1043 F3 *RETURN // Stack delta = -6 // Outputs[2] // { // @1041 log(memory[stack[-3]:stack[-3] + stack[-1] - stack[-2]], [stack[-4], stack[-5]]); // @1043 return memory[stack[-6]:stack[-6] + stack[-6]]; // } // Block terminates label_1044: // Incoming jump from 0x0FF8, if 0x01 == stack[-2] // Inputs[6] // { // @1045 stack[-9] // @1046 stack[-1] // @1047 stack[-6] // @1049 memory[stack[-9]:stack[-9] + stack[-6]] // @104B stack[-4] // @104E stack[-3] // } 1044 5B JUMPDEST 1045 88 DUP9 1046 52 MSTORE 1047 84 DUP5 1048 88 DUP9 1049 20 SHA3 104A 88 DUP9 104B 93 SWAP4 104C 50 POP 104D 5B JUMPDEST 104E 82 DUP3 104F 84 DUP5 1050 10 LT 1051 61 PUSH2 0x1085 1054 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1046 memory[stack[-9]:stack[-9] + 0x20] = stack[-1] // @1049 stack[-1] = keccak256(memory[stack[-9]:stack[-9] + stack[-6]]) // @104B stack[-4] = stack[-9] // } // Block ends with conditional jump to 0x1085, if stack[-9] < stack[-3] label_1055: // Incoming jump from 0x1054, if not stack[-9] < stack[-3] // Incoming jump from 0x1054, if not stack[-4] < stack[-3] // Inputs[4] // { // @1058 stack[-7] // @1059 stack[-4] // @105A stack[-6] // @105C stack[-5] // } 1055 50 POP 1056 50 POP 1057 50 POP 1058 83 DUP4 1059 01 ADD 105A 82 DUP3 105B 01 ADD 105C 81 DUP2 105D 61 PUSH2 0x102f 1060 7F PUSH32 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b 1081 61 PUSH2 0x0ff9 1084 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @105B stack[-4] = stack[-6] + stack[-7] + stack[-4] // @105C stack[-3] = stack[-5] // @105D stack[-2] = 0x102f // @1060 stack[-1] = 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b // } // Block ends with unconditional jump to 0x0ff9 label_1085: // Incoming jump from 0x1054, if stack[-9] < stack[-3] // Incoming jump from 0x1054, if stack[-4] < stack[-3] // Inputs[6] // { // @1086 stack[-1] // @1087 storage[stack[-1]] // @1088 stack[-7] // @1089 stack[-4] // @108B stack[-6] // @1092 stack[-2] // } 1085 5B JUMPDEST 1086 80 DUP1 1087 54 SLOAD 1088 87 DUP8 1089 85 DUP6 108A 01 ADD 108B 87 DUP8 108C 01 ADD 108D 52 MSTORE 108E 92 SWAP3 108F 85 DUP6 1090 01 ADD 1091 92 SWAP3 1092 81 DUP2 1093 01 ADD 1094 61 PUSH2 0x104d 1097 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @108D memory[stack[-6] + stack[-4] + stack[-7]:stack[-6] + stack[-4] + stack[-7] + 0x20] = storage[stack[-1]] // @1091 stack[-4] = stack[-6] + stack[-4] // @1093 stack[-1] = stack[-2] + stack[-1] // } // Block ends with unconditional jump to 0x104d label_1098: // Incoming jump from 0x0FF0, if !(0x01 & stack[-2]) // Inputs[6] // { // @10BA stack[-1] // @10BB stack[-8] // @10BC stack[-9] // @10C2 stack[-5] // @10CB stack[-6] // @10CD stack[-7] // } 1098 5B JUMPDEST 1099 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 10BA 16 AND 10BB 87 DUP8 10BC 89 DUP10 10BD 01 ADD 10BE 52 MSTORE 10BF 50 POP 10C0 50 POP 10C1 50 POP 10C2 15 ISZERO 10C3 15 ISZERO 10C4 60 PUSH1 0x05 10C6 1B SHL 10C7 84 DUP5 10C8 01 ADD 10C9 83 DUP4 10CA 01 ADD 10CB 90 SWAP1 10CC 50 POP 10CD 81 DUP2 10CE 61 PUSH2 0x102f 10D1 7F PUSH32 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b 10F2 61 PUSH2 0x0ff9 10F5 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @10BE memory[stack[-9] + stack[-8]:stack[-9] + stack[-8] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & stack[-1] // @10CB stack[-6] = stack[-8] + stack[-9] + (!!stack[-5] << 0x05) // @10CD stack[-5] = stack[-7] // @10CE stack[-4] = 0x102f // @10D1 stack[-3] = 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b // } // Block ends with unconditional jump to 0x0ff9 label_10F6: // Incoming jump from 0x0F90, if stack[-4] // Inputs[6] // { // @10F7 stack[-2] // @10F7 stack[-1] // @10F8 stack[-3] // @10F9 msg.data[stack[-1] + stack[-2] + stack[-3]:stack[-1] + stack[-2] + stack[-3] + 0x20] // @10FA stack[-4] // @10FC code.length // } 10F6 5B JUMPDEST 10F7 01 ADD 10F8 01 ADD 10F9 35 CALLDATALOAD 10FA 90 SWAP1 10FB 50 POP 10FC 38 CODESIZE 10FD 80 DUP1 10FE 80 DUP1 10FF 61 PUSH2 0x0f91 1102 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @10FA stack[-4] = msg.data[stack[-1] + stack[-2] + stack[-3]:stack[-1] + stack[-2] + stack[-3] + 0x20] // @10FC stack[-3] = code.length // @10FD stack[-2] = code.length // @10FE stack[-1] = code.length // } // Block ends with unconditional jump to 0x0f91 label_1103: // Incoming jump from 0x0F8A, if 0x01 == (stack[-4] > 0x1f) // Inputs[8] // { // @1104 stack[-1] // @1104 stack[-3] // @1105 stack[-2] // @1106 stack[-4] // @112A stack[-6] // @112B stack[-10] // @112D stack[-7] // @112F memory[stack[-10]:stack[-10] + stack[-7]] // } 1103 5B JUMPDEST 1104 91 SWAP2 1105 90 SWAP1 1106 92 SWAP3 1107 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 1128 16 AND 1129 92 SWAP3 112A 85 DUP6 112B 8A DUP11 112C 52 MSTORE 112D 86 DUP7 112E 8A DUP11 112F 20 SHA3 1130 93 SWAP4 1131 8A DUP11 1132 5B JUMPDEST 1133 88 DUP9 1134 82 DUP3 1135 82 DUP3 1136 10 LT 1137 61 PUSH2 0x1193 113A 57 *JUMPI // Stack delta = +3 // Outputs[8] // { // @1104 stack[-3] = stack[-1] // @1105 stack[-2] = stack[-3] // @1129 stack[-1] = stack[-2] // @112C memory[stack[-10]:stack[-10] + 0x20] = stack[-6] // @1130 stack[-4] = keccak256(memory[stack[-10]:stack[-10] + stack[-7]]) // @1130 stack[0] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & stack[-4] // @1131 stack[1] = stack[-10] // @1133 stack[2] = stack[-7] // } // Block ends with conditional jump to 0x1193, if stack[-10] < 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & stack[-4] label_113B: // Incoming jump from 0x113A, if not stack[-1] < stack[-2] // Incoming jump from 0x113A, if not stack[-10] < 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & stack[-4] // Inputs[6] // { // @113D stack[-4] // @113D stack[-3] // @113E stack[-8] // @1142 stack[-7] // @1143 stack[-6] // @1144 stack[-5] // } 113B 50 POP 113C 50 POP 113D 90 SWAP1 113E 85 DUP6 113F 60 PUSH1 0x01 1141 96 SWAP7 1142 95 SWAP6 1143 94 SWAP5 1144 93 SWAP4 1145 92 SWAP3 1146 10 LT 1147 61 PUSH2 0x1159 114A 57 *JUMPI // Stack delta = -2 // Outputs[6] // { // @113D stack[-3] = stack[-4] // @1141 stack[-8] = 0x01 // @1142 stack[-7] = stack[-8] // @1143 stack[-6] = stack[-7] // @1144 stack[-5] = stack[-6] // @1145 stack[-4] = stack[-5] // } // Block ends with conditional jump to 0x1159, if stack[-3] < stack[-8] label_114B: // Incoming jump from 0x114A, if not stack[-3] < stack[-8] // Incoming jump from 0x1192 // Inputs[3] // { // @1150 stack[-6] // @1151 stack[-5] // @1153 stack[-7] // } 114B 5B JUMPDEST 114C 50 POP 114D 50 POP 114E 50 POP 114F 50 POP 1150 81 DUP2 1151 1B SHL 1152 01 ADD 1153 90 SWAP1 1154 55 SSTORE 1155 61 PUSH2 0x0fc4 1158 56 *JUMP // Stack delta = -7 // Outputs[1] { @1154 storage[stack[-7]] = (stack[-5] << stack[-6]) + stack[-6] } // Block ends with unconditional jump to 0x0fc4 label_1159: // Incoming jump from 0x114A, if stack[-3] < stack[-8] // Inputs[7] // { // @117D stack[-5] // @1184 stack[-3] // @1185 stack[-1] // @1186 stack[-2] // @1187 msg.data[stack[-3] + stack[-1] + stack[-2]:stack[-3] + stack[-1] + stack[-2] + 0x20] // @1189 stack[-4] // @118B code.length // } 1159 5B JUMPDEST 115A 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 117B 60 PUSH1 0xf8 117D 86 DUP7 117E 60 PUSH1 0x03 1180 1B SHL 1181 16 AND 1182 1C SHR 1183 19 NOT 1184 92 SWAP3 1185 01 ADD 1186 01 ADD 1187 35 CALLDATALOAD 1188 16 AND 1189 90 SWAP1 118A 55 SSTORE 118B 38 CODESIZE 118C 80 DUP1 118D 80 DUP1 118E 80 DUP1 118F 61 PUSH2 0x114b 1192 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @118A storage[stack[-4]] = msg.data[stack[-3] + stack[-1] + stack[-2]:stack[-3] + stack[-1] + stack[-2] + 0x20] & ~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> ((stack[-5] << 0x03) & 0xf8)) // @118B stack[-4] = code.length // @118C stack[-3] = code.length // @118D stack[-2] = code.length // @118E stack[-1] = code.length // } // Block ends with unconditional jump to 0x114b label_1193: // Incoming jump from 0x113A, if stack[-1] < stack[-2] // Incoming jump from 0x113A, if stack[-10] < 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & stack[-4] // Inputs[7] // { // @1196 stack[-4] // @1197 stack[-7] // @1198 stack[-5] // @1199 stack[-1] // @119A stack[-2] // @119C stack[-6] // @119F msg.data[stack[-6] + stack[-4] + stack[-5]:stack[-6] + stack[-4] + stack[-5] + 0x20] // } 1193 5B JUMPDEST 1194 60 PUSH1 0x01 1196 84 DUP5 1197 97 SWAP8 1198 86 DUP7 1199 83 DUP4 119A 94 SWAP5 119B 96 SWAP7 119C 89 DUP10 119D 01 ADD 119E 01 ADD 119F 35 CALLDATALOAD 11A0 81 DUP2 11A1 55 SSTORE 11A2 01 ADD 11A3 96 SWAP7 11A4 01 ADD 11A5 92 SWAP3 11A6 01 ADD 11A7 61 PUSH2 0x1132 11AA 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @11A1 storage[stack[-7]] = msg.data[stack[-6] + stack[-4] + stack[-5]:stack[-6] + stack[-4] + stack[-5] + 0x20] // @11A3 stack[-7] = stack[-7] + 0x01 // @11A5 stack[-4] = stack[-4] + stack[-1] // @11A6 stack[-2] = stack[-2] + stack[-1] // } // Block ends with unconditional jump to 0x1132 label_11AB: // Incoming jump from 0x0F7B, if stack[-1] > 0x1f // Inputs[9] // { // @11AC stack[-2] // @11AC stack[-1] // @11AD stack[-3] // @11AE stack[-4] // @11B0 stack[-6] // @11B1 stack[-10] // @11B3 stack[-7] // @11B5 memory[stack[-10]:stack[-10] + stack[-7]] // @11B8 stack[-5] // } 11AB 5B JUMPDEST 11AC 90 SWAP1 11AD 91 SWAP2 11AE 92 SWAP3 11AF 50 POP 11B0 84 DUP5 11B1 89 DUP10 11B2 52 MSTORE 11B3 85 DUP6 11B4 89 DUP10 11B5 20 SHA3 11B6 60 PUSH1 0x1f 11B8 85 DUP6 11B9 01 ADD 11BA 60 PUSH1 0x05 11BC 1C SHR 11BD 81 DUP2 11BE 01 ADD 11BF 91 SWAP2 11C0 87 DUP8 11C1 86 DUP7 11C2 10 LT 11C3 61 PUSH2 0x11f1 11C6 57 *JUMPI // Stack delta = +1 // Outputs[6] // { // @11AD stack[-3] = stack[-2] // @11AE stack[-4] = stack[-3] // @11B2 memory[stack[-10]:stack[-10] + 0x20] = stack[-6] // @11B5 stack[-1] = keccak256(memory[stack[-10]:stack[-10] + stack[-7]]) // @11BF stack[0] = stack[-1] // @11BF stack[-2] = keccak256(memory[stack[-10]:stack[-10] + stack[-7]]) + (stack[-5] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x11f1, if stack[-5] < stack[-7] label_11C7: // Incoming jump from 0x11FA // Incoming jump from 0x11C6, if not stack[-5] < stack[-7] // Inputs[6] // { // @11C8 stack[-2] // @11C8 stack[-1] // @11CB stack[-6] // @11CC stack[-5] // @11CD stack[-4] // @11CE stack[-3] // } 11C7 5B JUMPDEST 11C8 90 SWAP1 11C9 60 PUSH1 0x1f 11CB 86 DUP7 11CC 95 SWAP6 11CD 94 SWAP5 11CE 93 SWAP4 11CF 92 SWAP3 11D0 01 ADD 11D1 60 PUSH1 0x05 11D3 1C SHR 11D4 01 ADD 11D5 90 SWAP1 11D6 5B JUMPDEST 11D7 81 DUP2 11D8 81 DUP2 11D9 10 LT 11DA 61 PUSH2 0x11e3 11DD 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @11CC stack[-5] = stack[-6] // @11CD stack[-4] = stack[-5] // @11CE stack[-3] = stack[-4] // @11D5 stack[-2] = (stack[-1] + 0x1f >> 0x05) + stack[-2] // @11D5 stack[-1] = stack[-3] // } // Block ends with conditional jump to 0x11e3, if stack[-3] < (stack[-1] + 0x1f >> 0x05) + stack[-2] label_11DE: // Incoming jump from 0x11DD, if not stack[-3] < (stack[-1] + 0x1f >> 0x05) + stack[-2] // Incoming jump from 0x11DD, if not stack[-1] < stack[-2] 11DE 50 POP 11DF 61 PUSH2 0x0f7c 11E2 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x0f7c label_11E3: // Incoming jump from 0x11DD, if stack[-3] < (stack[-1] + 0x1f >> 0x05) + stack[-2] // Incoming jump from 0x11DD, if stack[-1] < stack[-2] // Inputs[4] // { // @11E4 stack[-11] // @11E5 stack[-1] // @11E7 stack[-6] // @11E8 stack[-5] // } 11E3 5B JUMPDEST 11E4 8A DUP11 11E5 81 DUP2 11E6 55 SSTORE 11E7 85 DUP6 11E8 94 SWAP5 11E9 50 POP 11EA 60 PUSH1 0x01 11EC 01 ADD 11ED 61 PUSH2 0x11d6 11F0 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @11E6 storage[stack[-1]] = stack[-11] // @11E8 stack[-5] = stack[-6] // @11EC stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x11d6 label_11F1: // Incoming jump from 0x11C6, if stack[-5] < stack[-7] // Inputs[3] // { // @11F2 stack[-1] // @11F2 stack[-2] // @11F3 stack[-3] // } 11F1 5B JUMPDEST 11F2 90 SWAP1 11F3 91 SWAP2 11F4 50 POP 11F5 81 DUP2 11F6 90 SWAP1 11F7 61 PUSH2 0x11c7 11FA 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @11F3 stack[-3] = stack[-2] // @11F6 stack[-1] = stack[-1] // @11F6 stack[-2] = stack[-2] // } // Block ends with unconditional jump to 0x11c7 label_11FB: // Incoming jump from 0x0F47, if msg.data[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] > stack[-2] // Incoming jump from 0x0F52, if stack[-2] + stack[-1] + stack[-3] > msg.data.length // Inputs[2] // { // @11FC stack[-6] // @11FE memory[stack[-6]:stack[-6] + stack[-6]] // } 11FB 5B JUMPDEST 11FC 85 DUP6 11FD 80 DUP1 11FE FD *REVERT // Stack delta = +0 // Outputs[1] { @11FE revert(memory[stack[-6]:stack[-6] + stack[-6]]); } // Block terminates label_11FF: // Incoming jump from 0x1705, if msg.data[0x44:0x64] > 0xffffffffffffffff // Incoming jump from 0x0F3D, if !(stack[-3] + 0x23 i< msg.data.length) // Incoming jump from 0x0F32, if msg.data[0x24:0x44] > 0xffffffffffffffff // Inputs[2] // { // @1200 stack[-7] // @1202 memory[stack[-7]:stack[-7] + stack[-7]] // } 11FF 5B JUMPDEST 1200 86 DUP7 1201 80 DUP1 1202 FD *REVERT // Stack delta = +0 // Outputs[1] { @1202 revert(memory[stack[-7]:stack[-7] + stack[-7]]); } // Block terminates label_1203: // Incoming jump from 0x00A1, if 0x715018a6 == stack[-2] // Inputs[2] // { // @1204 stack[-4] // @1209 msg.data.length // } 1203 5B JUMPDEST 1204 83 DUP4 1205 80 DUP1 1206 60 PUSH1 0x03 1208 19 NOT 1209 36 CALLDATASIZE 120A 01 ADD 120B 12 SLT 120C 61 PUSH2 0x082b 120F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1204 stack[0] = stack[-4] } // Block ends with conditional jump to 0x082b, if msg.data.length + ~0x03 i< stack[-4] label_1210: // Incoming jump from 0x120F, if not msg.data.length + ~0x03 i< stack[-4] 1210 61 PUSH2 0x1217 1213 61 PUSH2 0x2833 1216 56 *JUMP // Stack delta = +1 // Outputs[1] { @1210 stack[0] = 0x1217 } // Block ends with call to 0x2833, returns to 0x1217 label_1217: // Incoming return from call to 0x2833 at 0x1216 // Inputs[4] // { // @1218 stack[-1] // @1221 storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] // @1245 memory[stack[-1]:stack[-1] + stack[-1]] // @1248 memory[stack[-1]:stack[-1] + stack[-1]] // } 1217 5B JUMPDEST 1218 80 DUP1 1219 63 PUSH4 0x8b78c6d8 121E 19 NOT 121F 81 DUP2 1220 81 DUP2 1221 54 SLOAD 1222 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1243 82 DUP3 1244 80 DUP1 1245 A3 LOG3 1246 55 SSTORE 1247 80 DUP1 1248 F3 *RETURN // Stack delta = -1 // Outputs[3] // { // @1245 log(memory[stack[-1]:stack[-1] + stack[-1]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927], stack[-1]]); // @1246 storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] = stack[-1] // @1248 return memory[stack[-1]:stack[-1] + stack[-1]]; // } // Block terminates label_1249: // Incoming jump from 0x0096, if 0x6b20c454 == stack[-2] // Inputs[3] // { // @124A stack[-4] // @124B stack[-3] // @124C msg.value // } 1249 5B JUMPDEST 124A 83 DUP4 124B 83 DUP4 124C 34 CALLVALUE 124D 61 PUSH2 0x0172 1250 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @124A stack[0] = stack[-4] // @124B stack[1] = stack[-3] // } // Block ends with conditional jump to 0x0172, if msg.value label_1251: // Incoming jump from 0x1250, if not msg.value // Inputs[1] { @1254 msg.data.length } 1251 61 PUSH2 0x1259 1254 36 CALLDATASIZE 1255 61 PUSH2 0x232c 1258 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1251 stack[0] = 0x1259 // @1254 stack[1] = msg.data.length // } // Block ends with call to 0x232c, returns to 0x1259 label_1259: // Incoming return from call to 0x232C at 0x1258 // Inputs[7] // { // @125A stack[-4] // @125A stack[-1] // @125B stack[-2] // @125C stack[-3] // @125D stack[-8] // @1278 storage[0x01] // @127A msg.sender // } 1259 5B JUMPDEST 125A 92 SWAP3 125B 90 SWAP1 125C 91 SWAP2 125D 96 SWAP7 125E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1273 60 PUSH1 0x01 1275 90 SWAP1 1276 80 DUP1 1277 82 DUP3 1278 54 SLOAD 1279 16 AND 127A 33 CALLER 127B 03 SUB 127C 61 PUSH2 0x149c 127F 57 *JUMPI // Stack delta = +2 // Outputs[7] // { // @125A stack[-4] = stack[-1] // @125B stack[-2] = stack[-4] // @125C stack[-3] = stack[-2] // @125D stack[-1] = stack[-8] // @125D stack[-8] = stack[-3] // @1275 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff // @1275 stack[0] = 0x01 // } // Block ends with conditional jump to 0x149c, if msg.sender - (storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) label_1280: // Incoming jump from 0x127F, if not msg.sender - (storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) // Incoming jump from 0x14AC, if !(msg.sender - (storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] & stack[-1])) // Inputs[2] // { // @1281 stack[-7] // @1282 stack[-1] // } 1280 5B JUMPDEST 1281 86 DUP7 1282 16 AND 1283 15 ISZERO 1284 61 PUSH2 0x1475 1287 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1475, if !(stack[-7] & stack[-1]) label_1288: // Incoming jump from 0x1287, if not !(stack[-7] & stack[-1]) // Inputs[2] // { // @1288 stack[-5] // @1289 stack[-9] // } 1288 84 DUP5 1289 89 DUP10 128A 03 SUB 128B 61 PUSH2 0x144e 128E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x144e, if stack[-9] - stack[-5] label_128F: // Incoming jump from 0x128E, if not stack[-9] - stack[-5] // Inputs[3] // { // @128F stack[-8] // @1290 stack[-7] // @1291 memory[stack[-7]:stack[-7] + 0x20] // } 128F 87 DUP8 1290 87 DUP8 1291 51 MLOAD 1292 61 PUSH2 0x129a 1295 81 DUP2 1296 61 PUSH2 0x224e 1299 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @128F stack[0] = stack[-8] // @1291 stack[1] = memory[stack[-7]:stack[-7] + 0x20] // @1292 stack[2] = 0x129a // @1295 stack[3] = memory[stack[-7]:stack[-7] + 0x20] // } // Block ends with call to 0x224e, returns to 0x129A label_129A: // Incoming return from call to 0x224E at 0x1299 // Inputs[4] // { // @129B stack[-2] // @129B stack[-1] // @129C stack[-10] // @129E stack[-11] // } 129A 5B JUMPDEST 129B 52 MSTORE 129C 87 DUP8 129D 5B JUMPDEST 129E 89 DUP10 129F 81 DUP2 12A0 10 LT 12A1 61 PUSH2 0x1312 12A4 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @129B memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @129C stack[-2] = stack[-10] // } // Block ends with conditional jump to 0x1312, if stack[-10] < stack[-11] label_12A5: // Incoming jump from 0x12A4, if not stack[-1] < stack[-10] // Incoming jump from 0x12A4, if not stack[-10] < stack[-11] // Inputs[13] // { // @12A6 stack[-9] // @12AA stack[-8] // @12AC stack[-7] // @12AD stack[-6] // @12CF stack[-10] // @12D0 stack[-5] // @12D1 stack[-4] // @12D3 memory[stack[-8]:stack[-8] + 0x20] // @12F0 msg.data[stack[-4]:stack[-4] + stack[-10] << 0x05] // @1302 msg.data[stack[-5]:stack[-5] + stack[-6] << 0x05] // @1303 msg.sender // @130C memory[memory[stack[-8]:stack[-8] + 0x20]:memory[stack[-8]:stack[-8] + 0x20] + 0x80 + (stack[-6] << 0x06)] // @130D memory[stack[-8]:stack[-8] + 0x20] // } 12A5 50 POP 12A6 87 DUP8 12A7 61 PUSH2 0x02ca 12AA 88 DUP9 12AB 82 DUP3 12AC 89 DUP10 12AD 89 DUP10 12AE 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 12CF 8F DUP16 12D0 8B DUP12 12D1 8B DUP12 12D2 87 DUP8 12D3 51 MLOAD 12D4 92 SWAP3 12D5 88 DUP9 12D6 84 DUP5 12D7 52 MSTORE 12D8 80 DUP1 12D9 60 PUSH1 0x05 12DB 1B SHL 12DC 91 SWAP2 12DD 82 DUP3 12DE 91 SWAP2 12DF 82 DUP3 12E0 60 PUSH1 0x60 12E2 01 ADD 12E3 60 PUSH1 0x20 12E5 87 DUP8 12E6 01 ADD 12E7 52 MSTORE 12E8 8A DUP11 12E9 86 DUP7 12EA 01 ADD 12EB 52 MSTORE 12EC 60 PUSH1 0x60 12EE 85 DUP6 12EF 01 ADD 12F0 37 CALLDATACOPY 12F1 82 DUP3 12F2 01 ADD 12F3 90 SWAP1 12F4 84 DUP5 12F5 60 PUSH1 0x60 12F7 83 DUP4 12F8 01 ADD 12F9 52 MSTORE 12FA 60 PUSH1 0x80 12FC 85 DUP6 12FD 60 PUSH1 0x05 12FF 1B SHL 1300 92 SWAP3 1301 01 ADD 1302 37 CALLDATACOPY 1303 33 CALLER 1304 92 SWAP3 1305 60 PUSH1 0x06 1307 1B SHL 1308 60 PUSH1 0x80 130A 01 ADD 130B 90 SWAP1 130C A4 LOG4 130D 51 MLOAD 130E 61 PUSH2 0x224e 1311 56 *JUMP // Stack delta = +2 // Outputs[10] // { // @12A6 stack[-1] = stack[-9] // @12A7 stack[0] = 0x02ca // @12D7 memory[memory[stack[-8]:stack[-8] + 0x20]:memory[stack[-8]:stack[-8] + 0x20] + 0x20] = stack[-8] // @12E7 memory[memory[stack[-8]:stack[-8] + 0x20] + 0x20:memory[stack[-8]:stack[-8] + 0x20] + 0x20 + 0x20] = 0x60 + (stack[-10] << 0x05) // @12EB memory[memory[stack[-8]:stack[-8] + 0x20] + stack[-8]:memory[stack[-8]:stack[-8] + 0x20] + stack[-8] + 0x20] = stack[-10] // @12F0 memory[memory[stack[-8]:stack[-8] + 0x20] + 0x60:memory[stack[-8]:stack[-8] + 0x20] + 0x60 + stack[-10] << 0x05] = msg.data[stack[-4]:stack[-4] + stack[-10] << 0x05] // @12F9 memory[memory[stack[-8]:stack[-8] + 0x20] + (stack[-10] << 0x05) + 0x60:memory[stack[-8]:stack[-8] + 0x20] + (stack[-10] << 0x05) + 0x60 + 0x20] = stack[-6] // @1302 memory[memory[stack[-8]:stack[-8] + 0x20] + (stack[-10] << 0x05) + 0x80:memory[stack[-8]:stack[-8] + 0x20] + (stack[-10] << 0x05) + 0x80 + stack[-6] << 0x05] = msg.data[stack[-5]:stack[-5] + stack[-6] << 0x05] // @130C log(memory[memory[stack[-8]:stack[-8] + 0x20]:memory[stack[-8]:stack[-8] + 0x20] + 0x80 + (stack[-6] << 0x06)], [0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb, msg.sender, stack[-7], stack[-9]]); // @130D stack[1] = memory[stack[-8]:stack[-8] + 0x20] // } // Block ends with call to 0x224e, returns to 0x02CA label_1312: // Incoming jump from 0x12A4, if stack[-1] < stack[-10] // Incoming jump from 0x12A4, if stack[-10] < stack[-11] // Inputs[3] // { // @1316 stack[-1] // @1317 stack[-10] // @1318 stack[-4] // } 1312 5B JUMPDEST 1313 61 PUSH2 0x131d 1316 81 DUP2 1317 8B DUP12 1318 86 DUP7 1319 61 PUSH2 0x244c 131C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1313 stack[0] = 0x131d // @1316 stack[1] = stack[-1] // @1317 stack[2] = stack[-10] // @1318 stack[3] = stack[-4] // } // Block ends with call to 0x244c, returns to 0x131D label_131D: // Incoming return from call to 0x244C at 0x131C // Inputs[5] // { // @131E msg.data[stack[-1]:stack[-1] + 0x20] // @131E stack[-1] // @1322 stack[-2] // @1323 stack[-7] // @1324 stack[-6] // } 131D 5B JUMPDEST 131E 35 CALLDATALOAD 131F 61 PUSH2 0x1329 1322 82 DUP3 1323 88 DUP9 1324 88 DUP9 1325 61 PUSH2 0x244c 1328 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @131E stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @131F stack[0] = 0x1329 // @1322 stack[1] = stack[-2] // @1323 stack[2] = stack[-7] // @1324 stack[3] = stack[-6] // } // Block ends with call to 0x244c, returns to 0x1329 label_1329: // Incoming return from call to 0x244C at 0x1328 // Inputs[3] // { // @132A stack[-1] // @132A msg.data[stack[-1]:stack[-1] + 0x20] // @1338 stack[-2] // } 1329 5B JUMPDEST 132A 35 CALLDATALOAD 132B 6B PUSH12 0x7fffffffffffffffffffffff 1338 82 DUP3 1339 11 GT 133A 61 PUSH2 0x1427 133D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @132A stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1427, if stack[-2] > 0x7fffffffffffffffffffffff label_133E: // Incoming jump from 0x133D, if not stack[-2] > 0x7fffffffffffffffffffffff // Inputs[4] // { // @1341 stack[-2] // @1342 stack[-9] // @1388 memory[0x00:0x20] // @1389 storage[keccak256(memory[0x00:0x20])] // } 133E 61 PUSH2 0x138f 1341 82 DUP3 1342 8A DUP11 1343 90 SWAP1 1344 60 PUSH1 0xe0 1346 91 SWAP2 1347 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 1368 82 DUP3 1369 60 PUSH1 0x03 136B 1C SHR 136C 91 SWAP2 136D 60 PUSH1 0x5c 136F 1B SHL 1370 16 AND 1371 17 OR 1372 60 PUSH1 0x07 1374 60 PUSH1 0xfd 1376 1B SHL 1377 17 OR 1378 60 PUSH1 0x00 137A 52 MSTORE 137B 60 PUSH1 0x05 137D 1B SHL 137E 16 AND 137F 61 PUSH2 0xffff 1382 81 DUP2 1383 1B SHL 1384 60 PUSH1 0x20 1386 60 PUSH1 0x00 1388 20 SHA3 1389 54 SLOAD 138A 16 AND 138B 90 SWAP1 138C 1C SHR 138D 90 SWAP1 138E 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @137A memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-9] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-2] >> 0x03) // @138D stack[0] = (storage[keccak256(memory[0x00:0x20])] & (0xffff << ((stack[-2] << 0x05) & 0xe0))) >> ((stack[-2] << 0x05) & 0xe0) // } // Block ends with unconditional jump to 0x138f label_138F: // Incoming jump from 0x138E // Inputs[2] // { // @1390 stack[-1] // @1391 stack[-2] // } 138F 5B JUMPDEST 1390 80 DUP1 1391 82 DUP3 1392 11 GT 1393 61 PUSH2 0x1400 1396 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1400, if stack[-2] > stack[-1] label_1397: // Incoming jump from 0x1396, if not stack[-2] > stack[-1] // Inputs[8] // { // @1397 stack[-1] // @1397 stack[-3] // @139B stack[-2] // @139C stack[-5] // @139D stack[-4] // @13A1 stack[-10] // @13DF memory[0x00:0x20] // @13EE storage[keccak256(memory[0x00:0x20])] // } 1397 91 SWAP2 1398 61 PUSH2 0x13fa 139B 91 SWAP2 139C 85 DUP6 139D 94 SWAP5 139E 93 SWAP4 139F 03 SUB 13A0 90 SWAP1 13A1 8A DUP11 13A2 91 SWAP2 13A3 90 SWAP1 13A4 91 SWAP2 13A5 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 13C6 83 DUP4 13C7 60 PUSH1 0x03 13C9 1C SHR 13CA 91 SWAP2 13CB 60 PUSH1 0x5c 13CD 1B SHL 13CE 16 AND 13CF 17 OR 13D0 60 PUSH1 0x07 13D2 60 PUSH1 0xfd 13D4 1B SHL 13D5 17 OR 13D6 60 PUSH1 0x00 13D8 52 MSTORE 13D9 60 PUSH1 0xe0 13DB 60 PUSH1 0x20 13DD 60 PUSH1 0x00 13DF 20 SHA3 13E0 92 SWAP3 13E1 83 DUP4 13E2 60 PUSH1 0x00 13E4 52 MSTORE 13E5 60 PUSH1 0x05 13E7 1B SHL 13E8 16 AND 13E9 90 SWAP1 13EA 61 PUSH2 0xffff 13ED 83 DUP4 13EE 54 SLOAD 13EF 91 SWAP2 13F0 83 DUP4 13F1 1B SHL 13F2 92 SWAP3 13F3 1B SHL 13F4 19 NOT 13F5 16 AND 13F6 17 OR 13F7 90 SWAP1 13F8 55 SSTORE 13F9 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @139D stack[-4] = stack[-5] // @139E stack[-3] = stack[-4] // @13D8 memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-10] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-3] >> 0x03) // @13E4 memory[0x00:0x20] = keccak256(memory[0x00:0x20]) // @13F8 storage[keccak256(memory[0x00:0x20])] = (~(0xffff << ((stack[-3] << 0x05) & 0xe0)) & storage[keccak256(memory[0x00:0x20])]) | (stack[-1] - stack[-2] << ((stack[-3] << 0x05) & 0xe0)) // } // Block ends with unconditional jump to 0x13fa label_13FA: // Incoming jump from 0x13F9 // Inputs[2] // { // @13FB stack[-2] // @13FB stack[-1] // } 13FA 5B JUMPDEST 13FB 01 ADD 13FC 61 PUSH2 0x129d 13FF 56 *JUMP // Stack delta = -1 // Outputs[1] { @13FB stack[-2] = stack[-1] + stack[-2] } // Block ends with unconditional jump to 0x129d label_1400: // Incoming jump from 0x1396, if stack[-2] > stack[-1] // Inputs[3] // { // @1401 stack[-6] // @1402 stack[-12] // @1426 memory[stack[-12]:stack[-12] + stack[-6]] // } 1400 5B JUMPDEST 1401 85 DUP6 1402 8C DUP13 1403 7F PUSH32 0x588569f700000000000000000000000000000000000000000000000000000000 1424 81 DUP2 1425 52 MSTORE 1426 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1425 memory[stack[-12]:stack[-12] + 0x20] = 0x588569f700000000000000000000000000000000000000000000000000000000 // @1426 revert(memory[stack[-12]:stack[-12] + stack[-6]]); // } // Block terminates label_1427: // Incoming jump from 0x133D, if stack[-2] > 0x7fffffffffffffffffffffff // Inputs[3] // { // @1428 stack[-5] // @1429 stack[-11] // @144D memory[stack[-11]:stack[-11] + stack[-5]] // } 1427 5B JUMPDEST 1428 84 DUP5 1429 8B DUP12 142A 7F PUSH32 0x8ceeefe200000000000000000000000000000000000000000000000000000000 144B 81 DUP2 144C 52 MSTORE 144D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @144C memory[stack[-11]:stack[-11] + 0x20] = 0x8ceeefe200000000000000000000000000000000000000000000000000000000 // @144D revert(memory[stack[-11]:stack[-11] + stack[-5]]); // } // Block terminates label_144E: // Incoming jump from 0x128E, if stack[-9] - stack[-5] // Inputs[3] // { // @1450 stack[-8] // @1474 stack[-2] // @1474 memory[stack[-8]:stack[-8] + stack[-2]] // } 144E 5B JUMPDEST 144F 50 POP 1450 86 DUP7 1451 7F PUSH32 0xa24a13a600000000000000000000000000000000000000000000000000000000 1472 81 DUP2 1473 52 MSTORE 1474 FD *REVERT // Stack delta = -2 // Outputs[2] // { // @1473 memory[stack[-8]:stack[-8] + 0x20] = 0xa24a13a600000000000000000000000000000000000000000000000000000000 // @1474 revert(memory[stack[-8]:stack[-8] + stack[-2]]); // } // Block terminates label_1475: // Incoming jump from 0x1287, if !(stack[-7] & stack[-1]) // Inputs[3] // { // @1477 stack[-8] // @149B memory[stack[-8]:stack[-8] + stack[-2]] // @149B stack[-2] // } 1475 5B JUMPDEST 1476 50 POP 1477 86 DUP7 1478 7F PUSH32 0xb817eee700000000000000000000000000000000000000000000000000000000 1499 81 DUP2 149A 52 MSTORE 149B FD *REVERT // Stack delta = -2 // Outputs[2] // { // @149A memory[stack[-8]:stack[-8] + 0x20] = 0xb817eee700000000000000000000000000000000000000000000000000000000 // @149B revert(memory[stack[-8]:stack[-8] + stack[-2]]); // } // Block terminates label_149C: // Incoming jump from 0x127F, if msg.sender - (storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[3] // { // @149D stack[-1] // @14A4 storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] // @14A6 msg.sender // } 149C 5B JUMPDEST 149D 80 DUP1 149E 63 PUSH4 0x8b78c6d8 14A3 19 NOT 14A4 54 SLOAD 14A5 16 AND 14A6 33 CALLER 14A7 03 SUB 14A8 15 ISZERO 14A9 61 PUSH2 0x1280 14AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1280, if !(msg.sender - (storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] & stack[-1])) label_14AD: // Incoming jump from 0x14AC, if not !(msg.sender - (storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] & stack[-1])) // Inputs[4] // { // @14AD stack[-3] // @14AE stack[-8] // @14AF memory[stack[-8]:stack[-8] + 0x20] // @14D3 memory[memory[stack[-8]:stack[-8] + 0x20]:memory[stack[-8]:stack[-8] + 0x20] + stack[-3]] // } 14AD 82 DUP3 14AE 88 DUP9 14AF 51 MLOAD 14B0 7F PUSH32 0xea8e4eb500000000000000000000000000000000000000000000000000000000 14D1 81 DUP2 14D2 52 MSTORE 14D3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @14D2 memory[memory[stack[-8]:stack[-8] + 0x20]:memory[stack[-8]:stack[-8] + 0x20] + 0x20] = 0xea8e4eb500000000000000000000000000000000000000000000000000000000 // @14D3 revert(memory[memory[stack[-8]:stack[-8] + 0x20]:memory[stack[-8]:stack[-8] + 0x20] + stack[-3]]); // } // Block terminates label_14D4: // Incoming jump from 0x008B, if 0x54d1f13d == stack[-2] // Inputs[2] // { // @14D5 stack[-4] // @14DA msg.data.length // } 14D4 5B JUMPDEST 14D5 83 DUP4 14D6 80 DUP1 14D7 60 PUSH1 0x03 14D9 19 NOT 14DA 36 CALLDATASIZE 14DB 01 ADD 14DC 12 SLT 14DD 61 PUSH2 0x082b 14E0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @14D5 stack[0] = stack[-4] } // Block ends with conditional jump to 0x082b, if msg.data.length + ~0x03 i< stack[-4] label_14E1: // Incoming jump from 0x14E0, if not msg.data.length + ~0x03 i< stack[-4] // Inputs[6] // { // @14E9 msg.sender // @14EA stack[-1] // @14F1 memory[0x0c:0x2c] // @14F3 msg.sender // @1517 memory[stack[-1]:stack[-1] + stack[-1]] // @1519 memory[stack[-1]:stack[-1] + stack[-1]] // } 14E1 63 PUSH4 0x389a75e1 14E6 60 PUSH1 0x0c 14E8 52 MSTORE 14E9 33 CALLER 14EA 81 DUP2 14EB 52 MSTORE 14EC 80 DUP1 14ED 60 PUSH1 0x20 14EF 60 PUSH1 0x0c 14F1 20 SHA3 14F2 55 SSTORE 14F3 33 CALLER 14F4 7F PUSH32 0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92 1515 82 DUP3 1516 80 DUP1 1517 A2 LOG2 1518 80 DUP1 1519 F3 *RETURN // Stack delta = -1 // Outputs[5] // { // @14E8 memory[0x0c:0x2c] = 0x389a75e1 // @14EB memory[stack[-1]:stack[-1] + 0x20] = msg.sender // @14F2 storage[keccak256(memory[0x0c:0x2c])] = stack[-1] // @1517 log(memory[stack[-1]:stack[-1] + stack[-1]], [0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92, msg.sender]); // @1519 return memory[stack[-1]:stack[-1] + stack[-1]]; // } // Block terminates label_151A: // Incoming jump from 0x0080, if 0x4e1273f4 == stack[-2] // Inputs[3] // { // @151B stack[-4] // @151C stack[-2] // @151E msg.value // } 151A 5B JUMPDEST 151B 83 DUP4 151C 91 SWAP2 151D 50 POP 151E 34 CALLVALUE 151F 61 PUSH2 0x0172 1522 57 *JUMPI // Stack delta = +0 // Outputs[1] { @151C stack[-2] = stack[-4] } // Block ends with conditional jump to 0x0172, if msg.value label_1523: // Incoming jump from 0x1522, if not msg.value // Inputs[2] // { // @1523 stack[-3] // @1527 msg.data.length // } 1523 82 DUP3 1524 60 PUSH1 0x03 1526 19 NOT 1527 36 CALLDATASIZE 1528 01 ADD 1529 12 SLT 152A 61 PUSH2 0x0172 152D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0172, if msg.data.length + ~0x03 i< stack[-3] label_152E: // Incoming jump from 0x152D, if not msg.data.length + ~0x03 i< stack[-3] // Inputs[3] // { // @1537 stack[-2] // @1538 stack[-1] // @1539 msg.data[stack[-1]:stack[-1] + 0x20] // } 152E 67 PUSH8 0xffffffffffffffff 1537 91 SWAP2 1538 81 DUP2 1539 35 CALLDATALOAD 153A 83 DUP4 153B 81 DUP2 153C 11 GT 153D 61 PUSH2 0x0172 1540 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @1537 stack[0] = stack[-2] // @1537 stack[-2] = 0xffffffffffffffff // @1539 stack[1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0172, if msg.data[stack[-1]:stack[-1] + 0x20] > 0xffffffffffffffff label_1541: // Incoming jump from 0x1540, if not msg.data[stack[-1]:stack[-1] + 0x20] > 0xffffffffffffffff // Inputs[3] // { // @1544 stack[-1] // @1545 msg.data.length // @1547 stack[-3] // } 1541 61 PUSH2 0x154d 1544 90 SWAP1 1545 36 CALLDATASIZE 1546 90 SWAP1 1547 84 DUP5 1548 01 ADD 1549 61 PUSH2 0x21d2 154C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1544 stack[-1] = 0x154d // @1546 stack[0] = msg.data.length // @1548 stack[1] = stack[-3] + stack[-1] // } // Block ends with call to 0x21d2, returns to 0x154D label_154D: // Incoming return from call to 0x21D2 at 0x154C // Inputs[5] // { // @154E stack[-1] // @154E stack[-3] // @154F stack[-2] // @1550 stack[-5] // @1555 msg.data[0x24:0x44] // } 154D 5B JUMPDEST 154E 91 SWAP2 154F 90 SWAP1 1550 93 SWAP4 1551 60 PUSH1 0x24 1553 90 SWAP1 1554 81 DUP2 1555 35 CALLDATALOAD 1556 90 SWAP1 1557 81 DUP2 1558 11 GT 1559 61 PUSH2 0x079a 155C 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @154E stack[-3] = stack[-1] // @154F stack[-2] = stack[-3] // @1550 stack[-5] = stack[-2] // @1553 stack[-1] = 0x24 // @1556 stack[0] = msg.data[0x24:0x44] // } // Block ends with conditional jump to 0x079a, if msg.data[0x24:0x44] > stack[-5] label_155D: // Incoming jump from 0x155C, if not msg.data[0x24:0x44] > stack[-5] // Inputs[3] // { // @1560 stack[-1] // @1561 msg.data.length // @1563 stack[-5] // } 155D 61 PUSH2 0x1569 1560 90 SWAP1 1561 36 CALLDATASIZE 1562 90 SWAP1 1563 86 DUP7 1564 01 ADD 1565 61 PUSH2 0x21d2 1568 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1560 stack[-1] = 0x1569 // @1562 stack[0] = msg.data.length // @1564 stack[1] = stack[-5] + stack[-1] // } // Block ends with call to 0x21d2, returns to 0x1569 label_1569: // Incoming return from call to 0x21D2 at 0x1568 // Inputs[5] // { // @156A stack[-1] // @156A stack[-7] // @156B stack[-2] // @156C stack[-6] // @156E stack[-5] // } 1569 5B JUMPDEST 156A 95 SWAP6 156B 90 SWAP1 156C 94 SWAP5 156D 86 DUP7 156E 85 DUP6 156F 03 SUB 1570 61 PUSH2 0x16a7 1573 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @156A stack[-7] = stack[-1] // @156B stack[-2] = stack[-7] // @156C stack[-1] = stack[-6] // @156C stack[-6] = stack[-2] // } // Block ends with conditional jump to 0x16a7, if stack[-5] - stack[-1] label_1574: // Incoming jump from 0x1573, if not stack[-5] - stack[-1] // Inputs[5] // { // @1577 stack[-5] // @1578 stack[-8] // @1579 stack[-7] // @157A stack[-6] // @157B stack[-4] // } 1574 61 PUSH2 0x1581 1577 85 DUP6 1578 98 SWAP9 1579 97 SWAP8 157A 96 SWAP7 157B 94 SWAP5 157C 95 SWAP6 157D 61 PUSH2 0x2434 1580 56 *JUMP // Stack delta = +2 // Outputs[7] // { // @1574 stack[0] = 0x1581 // @1578 stack[-8] = stack[-5] // @1579 stack[-7] = stack[-8] // @157A stack[-6] = stack[-7] // @157B stack[-4] = stack[-6] // @157C stack[1] = stack[-5] // @157C stack[-5] = stack[-4] // } // Block ends with call to 0x2434, returns to 0x1581 label_1581: // Incoming return from call to 0x2434 at 0x1580 // Inputs[4] // { // @1582 stack[-5] // @1582 stack[-1] // @1586 stack[-8] // @1587 memory[stack[-8]:stack[-8] + 0x20] // } 1581 5B JUMPDEST 1582 93 SWAP4 1583 61 PUSH2 0x158e 1586 88 DUP9 1587 51 MLOAD 1588 95 SWAP6 1589 86 DUP7 158A 61 PUSH2 0x226a 158D 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1582 stack[-1] = stack[-5] // @1583 stack[0] = 0x158e // @1588 stack[-5] = memory[stack[-8]:stack[-8] + 0x20] // @1588 stack[1] = stack[-1] // @1589 stack[2] = memory[stack[-8]:stack[-8] + 0x20] // } // Block ends with call to 0x226a, returns to 0x158E label_158E: // Incoming return from call to 0x226A at 0x158D // Inputs[2] // { // @158F stack[-9] // @1590 stack[-5] // } 158E 5B JUMPDEST 158F 88 DUP9 1590 85 DUP6 1591 52 MSTORE 1592 61 PUSH2 0x159a 1595 89 DUP10 1596 61 PUSH2 0x2434 1599 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1591 memory[stack[-5]:stack[-5] + 0x20] = stack[-9] // @1592 stack[0] = 0x159a // @1595 stack[1] = stack[-9] // } // Block ends with call to 0x2434, returns to 0x159A label_159A: // Incoming return from call to 0x2434 at 0x1599 // Inputs[7] // { // @159B stack[-1] // @159B stack[-8] // @159E stack[-10] // @15C1 stack[-6] // @15C5 msg.data.length // @15C7 msg.data[msg.data.length:msg.data.length + stack[-1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0] // @15C8 stack[-7] // } 159A 5B JUMPDEST 159B 96 SWAP7 159C 60 PUSH1 0x20 159E 99 SWAP10 159F 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 15C0 8B DUP12 15C1 88 DUP9 15C2 01 ADD 15C3 99 SWAP10 15C4 01 ADD 15C5 36 CALLDATASIZE 15C6 8A DUP11 15C7 37 CALLDATACOPY 15C8 87 DUP8 15C9 5B JUMPDEST 15CA 81 DUP2 15CB 81 DUP2 15CC 10 LT 15CD 61 PUSH2 0x1612 15D0 57 *JUMPI // Stack delta = +2 // Outputs[6] // { // @159B stack[-1] = stack[-8] // @159E stack[-10] = 0x20 // @159E stack[0] = stack[-10] // @15C3 stack[-8] = stack[-6] + 0x20 // @15C7 memory[stack[-6] + 0x20:stack[-6] + 0x20 + stack[-1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0] = msg.data[msg.data.length:msg.data.length + stack[-1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0] // @15C8 stack[1] = stack[-7] // } // Block ends with conditional jump to 0x1612, if stack[-7] < stack[-10] label_15D1: // Incoming jump from 0x15D0, if not stack[-1] < stack[-2] // Incoming jump from 0x15D0, if not stack[-7] < stack[-10] // Inputs[7] // { // @15D8 stack[-11] // @15D9 memory[stack[-11]:stack[-11] + 0x20] // @15DA stack[-12] // @15E0 stack[-8] // @15E4 memory[stack[-8]:stack[-8] + 0x20] // @15EA stack[-10] // @15EB stack[-9] // } 15D1 50 POP 15D2 50 POP 15D3 50 POP 15D4 50 POP 15D5 50 POP 15D6 50 POP 15D7 50 POP 15D8 83 DUP4 15D9 51 MLOAD 15DA 94 SWAP5 15DB 85 DUP6 15DC 94 SWAP5 15DD 81 DUP2 15DE 86 DUP7 15DF 01 ADD 15E0 92 SWAP3 15E1 82 DUP3 15E2 87 DUP8 15E3 52 MSTORE 15E4 51 MLOAD 15E5 80 DUP1 15E6 93 SWAP4 15E7 52 MSTORE 15E8 85 DUP6 15E9 01 ADD 15EA 93 SWAP4 15EB 92 SWAP3 15EC 5B JUMPDEST 15ED 82 DUP3 15EE 81 DUP2 15EF 10 LT 15F0 61 PUSH2 0x15fb 15F3 57 *JUMPI // Stack delta = -5 // Outputs[9] // { // @15DA stack[-12] = memory[stack[-11]:stack[-11] + 0x20] // @15DA stack[-7] = stack[-12] // @15DC stack[-11] = memory[stack[-11]:stack[-11] + 0x20] // @15E3 memory[memory[stack[-11]:stack[-11] + 0x20]:memory[stack[-11]:stack[-11] + 0x20] + 0x20] = stack[-12] // @15E6 stack[-8] = memory[stack[-8]:stack[-8] + 0x20] // @15E7 memory[memory[stack[-11]:stack[-11] + 0x20] + stack[-12]:memory[stack[-11]:stack[-11] + 0x20] + stack[-12] + 0x20] = memory[stack[-8]:stack[-8] + 0x20] // @15EA stack[-10] = memory[stack[-11]:stack[-11] + 0x20] + stack[-11] // @15EB stack[-9] = stack[-10] // @15EB stack[-6] = stack[-9] // } // Block ends with conditional jump to 0x15fb, if stack[-9] < memory[stack[-8]:stack[-8] + 0x20] label_15F4: // Incoming jump from 0x15F3, if not stack[-1] < stack[-3] // Incoming jump from 0x15F3, if not stack[-9] < memory[stack[-8]:stack[-8] + 0x20] // Inputs[4] // { // @15F8 stack[-5] // @15F8 stack[-6] // @15F9 stack[-7] // @15FA memory[stack[-7]:stack[-7] + stack[-5] - stack[-6]] // } 15F4 50 POP 15F5 50 POP 15F6 50 POP 15F7 50 POP 15F8 03 SUB 15F9 90 SWAP1 15FA F3 *RETURN // Stack delta = -7 // Outputs[1] { @15FA return memory[stack[-7]:stack[-7] + stack[-5] - stack[-6]]; } // Block terminates label_15FB: // Incoming jump from 0x15F3, if stack[-1] < stack[-3] // Incoming jump from 0x15F3, if stack[-9] < memory[stack[-8]:stack[-8] + 0x20] // Inputs[7] // { // @15FC stack[-4] // @15FD memory[stack[-4]:stack[-4] + 0x20] // @15FE stack[-5] // @1600 stack[-7] // @1601 stack[-6] // @1603 stack[-1] // @1604 stack[-2] // } 15FB 5B JUMPDEST 15FC 83 DUP4 15FD 51 MLOAD 15FE 85 DUP6 15FF 52 MSTORE 1600 86 DUP7 1601 95 SWAP6 1602 50 POP 1603 93 SWAP4 1604 81 DUP2 1605 01 ADD 1606 93 SWAP4 1607 92 SWAP3 1608 81 DUP2 1609 01 ADD 160A 92 SWAP3 160B 60 PUSH1 0x01 160D 01 ADD 160E 61 PUSH2 0x15ec 1611 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @15FF memory[stack[-5]:stack[-5] + 0x20] = memory[stack[-4]:stack[-4] + 0x20] // @1601 stack[-6] = stack[-7] // @1606 stack[-5] = stack[-2] + stack[-5] // @160A stack[-4] = stack[-2] + stack[-4] // @160D stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x15ec label_1612: // Incoming jump from 0x15D0, if stack[-1] < stack[-2] // Incoming jump from 0x15D0, if stack[-7] < stack[-10] // Inputs[8] // { // @1616 stack[-1] // @1617 stack[-2] // @1618 stack[-6] // @1619 stack[-12] // @161A stack[-9] // @161B stack[-8] // @161C stack[-10] // @161D stack[-11] // } 1612 5B JUMPDEST 1613 61 PUSH2 0x1623 1616 81 DUP2 1617 83 DUP4 1618 88 DUP9 1619 9E SWAP15 161A 9B SWAP12 161B 9A SWAP11 161C 9C SWAP13 161D 9D SWAP14 161E 9E SWAP15 161F 61 PUSH2 0x244c 1622 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @1613 stack[0] = 0x1623 // @1616 stack[1] = stack[-1] // @1617 stack[2] = stack[-2] // @161A stack[-9] = stack[-12] // @161B stack[-8] = stack[-9] // @161C stack[-10] = stack[-8] // @161D stack[-11] = stack[-10] // @161E stack[-12] = stack[-11] // @161E stack[3] = stack[-6] // } // Block ends with call to 0x244c, returns to 0x1623 label_1623: // Incoming return from call to 0x244C at 0x1622 // Inputs[2] // { // @1624 msg.data[stack[-1]:stack[-1] + 0x20] // @1624 stack[-1] // } 1623 5B JUMPDEST 1624 35 CALLDATALOAD 1625 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 163A 81 DUP2 163B 16 AND 163C 81 DUP2 163D 03 SUB 163E 61 PUSH2 0x16a3 1641 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1624 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x16a3, if msg.data[stack[-1]:stack[-1] + 0x20] - (msg.data[stack[-1]:stack[-1] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff) label_1642: // Incoming jump from 0x1641, if not msg.data[stack[-1]:stack[-1] + 0x20] - (msg.data[stack[-1]:stack[-1] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[4] // { // @1645 stack[-1] // @1649 stack[-2] // @164A stack[-4] // @164B stack[-5] // } 1642 61 PUSH2 0x1657 1645 90 SWAP1 1646 61 PUSH2 0x1650 1649 83 DUP4 164A 86 DUP7 164B 88 DUP9 164C 61 PUSH2 0x244c 164F 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @1645 stack[0] = stack[-1] // @1645 stack[-1] = 0x1657 // @1646 stack[1] = 0x1650 // @1649 stack[2] = stack[-2] // @164A stack[3] = stack[-4] // @164B stack[4] = stack[-5] // } // Block ends with call to 0x244c, returns to 0x1650 label_1650: // Incoming return from call to 0x244C at 0x164F // Inputs[3] // { // @1651 stack[-1] // @1651 msg.data[stack[-1]:stack[-1] + 0x20] // @1652 stack[-2] // } 1650 5B JUMPDEST 1651 35 CALLDATALOAD 1652 90 SWAP1 1653 61 PUSH2 0x2399 1656 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1652 stack[-1] = stack[-2] // @1652 stack[-2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x2399 label_1657: // Incoming return from call to 0x1650 at 0x164F // Inputs[3] // { // @1658 stack[-11] // @1659 memory[stack[-11]:stack[-11] + 0x20] // @165A stack[-2] // } 1657 5B JUMPDEST 1658 8A DUP11 1659 51 MLOAD 165A 82 DUP3 165B 10 LT 165C 15 ISZERO 165D 61 PUSH2 0x1678 1660 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1678, if !(stack[-2] < memory[stack[-11]:stack[-11] + 0x20]) label_1661: // Incoming jump from 0x1660, if not !(stack[-2] < memory[stack[-11]:stack[-11] + 0x20]) // Inputs[7] // { // @1663 stack[-2] // @1666 stack[-11] // @1668 stack[-10] // @166A stack[-1] // @166C stack[-13] // @166D stack[-12] // @166F stack[-9] // } 1661 60 PUSH1 0x05 1663 82 DUP3 1664 90 SWAP1 1665 1B SHL 1666 8B DUP12 1667 01 ADD 1668 8A DUP11 1669 01 ADD 166A 52 MSTORE 166B 97 SWAP8 166C 9A SWAP11 166D 99 SWAP10 166E 98 SWAP9 166F 96 SWAP7 1670 97 SWAP8 1671 60 PUSH1 0x01 1673 01 ADD 1674 61 PUSH2 0x15c9 1677 56 *JUMP // Stack delta = -1 // Outputs[7] // { // @166A memory[stack[-10] + stack[-11] + (stack[-2] << 0x05):stack[-10] + stack[-11] + (stack[-2] << 0x05) + 0x20] = stack[-1] // @166C stack[-13] = stack[-10] // @166D stack[-12] = stack[-13] // @166E stack[-11] = stack[-12] // @166F stack[-9] = stack[-11] // @1670 stack[-10] = stack[-9] // @1673 stack[-2] = 0x01 + stack[-2] // } // Block ends with unconditional jump to 0x15c9 label_1678: // Incoming jump from 0x1660, if !(stack[-2] < memory[stack[-11]:stack[-11] + 0x20]) // Inputs[4] // { // @1679 stack[-8] // @167A stack[-9] // @167D stack[-6] // @16A2 memory[stack[-9]:stack[-9] + stack[-8]] // } 1678 5B JUMPDEST 1679 87 DUP8 167A 89 DUP10 167B 60 PUSH1 0x32 167D 88 DUP9 167E 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 169F 83 DUP4 16A0 52 MSTORE 16A1 52 MSTORE 16A2 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @16A0 memory[stack[-9]:stack[-9] + 0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @16A1 memory[stack[-6]:stack[-6] + 0x20] = 0x32 // @16A2 revert(memory[stack[-9]:stack[-9] + stack[-8]]); // } // Block terminates label_16A3: // Incoming jump from 0x1641, if msg.data[stack[-1]:stack[-1] + 0x20] - (msg.data[stack[-1]:stack[-1] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff) // Incoming jump from 0x171D, if msg.data[0x64:0x84] > stack[-3] // Inputs[2] // { // @16A4 stack[-9] // @16A6 memory[stack[-9]:stack[-9] + stack[-9]] // } 16A3 5B JUMPDEST 16A4 88 DUP9 16A5 80 DUP1 16A6 FD *REVERT // Stack delta = +0 // Outputs[1] { @16A6 revert(memory[stack[-9]:stack[-9] + stack[-9]]); } // Block terminates label_16A7: // Incoming jump from 0x1573, if stack[-5] - stack[-1] // Inputs[3] // { // @16A8 stack[-4] // @16CC memory[stack[-4]:stack[-4] + stack[-1]] // @16CC stack[-1] // } 16A7 5B JUMPDEST 16A8 83 DUP4 16A9 7F PUSH32 0xa24a13a600000000000000000000000000000000000000000000000000000000 16CA 81 DUP2 16CB 52 MSTORE 16CC FD *REVERT // Stack delta = -1 // Outputs[2] // { // @16CB memory[stack[-4]:stack[-4] + 0x20] = 0xa24a13a600000000000000000000000000000000000000000000000000000000 // @16CC revert(memory[stack[-4]:stack[-4] + stack[-1]]); // } // Block terminates label_16CD: // Incoming jump from 0x0075, if 0x2eb2c2d6 == stack[-2] // Inputs[4] // { // @16CE stack[-1] // @16CE stack[-3] // @16CF stack[-2] // @16D1 msg.value // } 16CD 5B JUMPDEST 16CE 91 SWAP2 16CF 90 SWAP1 16D0 50 POP 16D1 34 CALLVALUE 16D2 61 PUSH2 0x079a 16D5 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @16CE stack[-3] = stack[-1] // @16CF stack[-2] = stack[-3] // } // Block ends with conditional jump to 0x079a, if msg.value label_16D6: // Incoming jump from 0x16D5, if not msg.value // Inputs[1] { @16DB msg.data.length } 16D6 60 PUSH1 0xa0 16D8 60 PUSH1 0x03 16DA 19 NOT 16DB 36 CALLDATASIZE 16DC 01 ADD 16DD 12 SLT 16DE 61 PUSH2 0x079a 16E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x079a, if msg.data.length + ~0x03 i< 0xa0 label_16E2: // Incoming jump from 0x16E1, if not msg.data.length + ~0x03 i< 0xa0 16E2 61 PUSH2 0x16e9 16E5 61 PUSH2 0x20f2 16E8 56 *JUMP // Stack delta = +1 // Outputs[1] { @16E2 stack[0] = 0x16e9 } // Block ends with call to 0x20f2, returns to 0x16E9 label_16E9: // Incoming return from call to 0x20F2 at 0x16E8 // Inputs[2] // { // @16EA stack[-2] // @16EA stack[-1] // } 16E9 5B JUMPDEST 16EA 90 SWAP1 16EB 61 PUSH2 0x16f2 16EE 61 PUSH2 0x211a 16F1 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @16EA stack[-2] = stack[-1] // @16EA stack[-1] = stack[-2] // @16EB stack[0] = 0x16f2 // } // Block ends with call to 0x211a, returns to 0x16F2 label_16F2: // Incoming return from call to 0x211A at 0x16F1 // Inputs[1] { @16FE msg.data[0x44:0x64] } 16F2 5B JUMPDEST 16F3 67 PUSH8 0xffffffffffffffff 16FC 60 PUSH1 0x44 16FE 35 CALLDATALOAD 16FF 81 DUP2 1700 81 DUP2 1701 11 GT 1702 61 PUSH2 0x11ff 1705 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @16F3 stack[0] = 0xffffffffffffffff // @16FE stack[1] = msg.data[0x44:0x64] // } // Block ends with conditional jump to 0x11ff, if msg.data[0x44:0x64] > 0xffffffffffffffff label_1706: // Incoming jump from 0x1705, if not msg.data[0x44:0x64] > 0xffffffffffffffff // Inputs[3] // { // @1709 stack[-1] // @170A msg.data.length // @170C stack[-6] // } 1706 61 PUSH2 0x1712 1709 90 SWAP1 170A 36 CALLDATASIZE 170B 90 SWAP1 170C 87 DUP8 170D 01 ADD 170E 61 PUSH2 0x21d2 1711 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1709 stack[-1] = 0x1712 // @170B stack[0] = msg.data.length // @170D stack[1] = stack[-6] + stack[-1] // } // Block ends with call to 0x21d2, returns to 0x1712 label_1712: // Incoming return from call to 0x21D2 at 0x1711 // Inputs[4] // { // @1713 stack[-2] // @1713 stack[-1] // @1716 msg.data[0x64:0x84] // @1717 stack[-3] // } 1712 5B JUMPDEST 1713 90 SWAP1 1714 60 PUSH1 0x64 1716 35 CALLDATALOAD 1717 83 DUP4 1718 81 DUP2 1719 11 GT 171A 61 PUSH2 0x16a3 171D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1713 stack[-2] = stack[-1] // @1713 stack[-1] = stack[-2] // @1716 stack[0] = msg.data[0x64:0x84] // } // Block ends with conditional jump to 0x16a3, if msg.data[0x64:0x84] > stack[-3] label_171E: // Incoming jump from 0x171D, if not msg.data[0x64:0x84] > stack[-3] // Inputs[3] // { // @1721 stack[-1] // @1722 msg.data.length // @1724 stack[-8] // } 171E 61 PUSH2 0x172a 1721 90 SWAP1 1722 36 CALLDATASIZE 1723 90 SWAP1 1724 89 DUP10 1725 01 ADD 1726 61 PUSH2 0x21d2 1729 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1721 stack[-1] = 0x172a // @1723 stack[0] = msg.data.length // @1725 stack[1] = stack[-8] + stack[-1] // } // Block ends with call to 0x21d2, returns to 0x172A label_172A: // Incoming return from call to 0x21D2 at 0x1729 // Inputs[5] // { // @172B stack[-6] // @172B stack[-1] // @172C stack[-2] // @172D stack[-5] // @1730 msg.data[0x84:0xa4] // } 172A 5B JUMPDEST 172B 94 SWAP5 172C 90 SWAP1 172D 93 SWAP4 172E 60 PUSH1 0x84 1730 35 CALLDATALOAD 1731 90 SWAP1 1732 81 DUP2 1733 11 GT 1734 61 PUSH2 0x1b0d 1737 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @172B stack[-6] = stack[-1] // @172C stack[-2] = stack[-6] // @172D stack[-5] = stack[-2] // @1731 stack[-1] = msg.data[0x84:0xa4] // } // Block ends with conditional jump to 0x1b0d, if msg.data[0x84:0xa4] > stack[-5] label_1738: // Incoming jump from 0x1737, if not msg.data[0x84:0xa4] > stack[-5] // Inputs[3] // { // @173B stack[-1] // @173C msg.data.length // @173E stack[-9] // } 1738 61 PUSH2 0x1744 173B 90 SWAP1 173C 36 CALLDATASIZE 173D 90 SWAP1 173E 8A DUP11 173F 01 ADD 1740 61 PUSH2 0x22e5 1743 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @173B stack[-1] = 0x1744 // @173D stack[0] = msg.data.length // @173F stack[1] = stack[-9] + stack[-1] // } // Block ends with call to 0x22e5, returns to 0x1744 label_1744: // Incoming return from call to 0x22E5 at 0x1743 // Inputs[3] // { // @1745 stack[-7] // @1745 stack[-1] // @175C stack[-2] // } 1744 5B JUMPDEST 1745 95 SWAP6 1746 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 175B 80 DUP1 175C 83 DUP4 175D 16 AND 175E 90 SWAP1 175F 81 DUP2 1760 15 ISZERO 1761 61 PUSH2 0x1ae6 1764 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1745 stack[-1] = stack[-7] // @1745 stack[-7] = stack[-1] // @175E stack[1] = 0xffffffffffffffffffffffffffffffffffffffff // @175E stack[0] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // } // Block ends with conditional jump to 0x1ae6, if !(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff) label_1765: // Incoming jump from 0x1764, if not !(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[2] // { // @1765 stack[-8] // @1766 stack[-6] // } 1765 87 DUP8 1766 86 DUP7 1767 03 SUB 1768 61 PUSH2 0x1abf 176B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1abf, if stack[-6] - stack[-8] label_176C: // Incoming jump from 0x176B, if not stack[-6] - stack[-8] // Inputs[4] // { // @176C stack[-10] // @176D stack[-1] // @176E stack[-2] // @176F msg.sender // } 176C 89 DUP10 176D 16 AND 176E 90 SWAP1 176F 33 CALLER 1770 82 DUP3 1771 03 SUB 1772 61 PUSH2 0x1a49 1775 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @176E stack[-1] = stack[-2] // @176E stack[-2] = stack[-10] & stack[-1] // } // Block ends with conditional jump to 0x1a49, if (stack[-10] & stack[-1]) - msg.sender label_1776: // Incoming jump from 0x1A98, if storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x1775, if not (stack[-10] & stack[-1]) - msg.sender // Inputs[7] // { // @1777 stack[-4] // @1778 stack[-3] // @1779 stack[-10] // @177A stack[-2] // @177C stack[-1] // @177F stack[-12] // @1781 stack[-6] // } 1776 5B JUMPDEST 1777 83 DUP4 1778 92 SWAP3 1779 8A DUP11 177A 92 SWAP3 177B 90 SWAP1 177C 91 SWAP2 177D 14 EQ 177E 15 ISZERO 177F 8C DUP13 1780 5B JUMPDEST 1781 87 DUP8 1782 81 DUP2 1783 10 LT 1784 61 PUSH2 0x1809 1787 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @1778 stack[-3] = stack[-4] // @177A stack[-2] = stack[-10] // @177C stack[-1] = stack[-3] // @177E stack[0] = !(stack[-1] == stack[-2]) // @177F stack[1] = stack[-12] // } // Block ends with conditional jump to 0x1809, if stack[-12] < stack[-6] label_1788: // Incoming jump from 0x1787, if not stack[-12] < stack[-6] // Incoming jump from 0x1787, if not stack[-1] < stack[-8] // Inputs[14] // { // @178A stack[-3] // @178B memory[stack[-3]:stack[-3] + 0x20] // @1790 stack[-8] // @17A3 stack[-7] // @17A8 msg.data[stack[-7]:stack[-7] + stack[-8] << 0x05] // @17AB stack[-10] // @17B1 stack[-9] // @17BA msg.data[stack[-9]:stack[-9] + stack[-10] << 0x05] // @17DC msg.sender // @17E6 stack[-5] // @17E6 memory[memory[stack[-3]:stack[-3] + 0x20]:memory[stack[-3]:stack[-3] + 0x20] + 0x80 + (stack[-10] << 0x06)] // @17E6 stack[-4] // @17E7 stack[-6] // @17E8 address(stack[-6]).code.length // } 1788 50 POP 1789 50 POP 178A 80 DUP1 178B 51 MLOAD 178C 90 SWAP1 178D 80 DUP1 178E 82 DUP3 178F 52 MSTORE 1790 86 DUP7 1791 80 DUP1 1792 60 PUSH1 0x05 1794 1B SHL 1795 91 SWAP2 1796 82 DUP3 1797 60 PUSH1 0x60 1799 01 ADD 179A 60 PUSH1 0x20 179C 85 DUP6 179D 01 ADD 179E 52 MSTORE 179F 83 DUP4 17A0 01 ADD 17A1 52 MSTORE 17A2 80 DUP1 17A3 86 DUP7 17A4 60 PUSH1 0x60 17A6 84 DUP5 17A7 01 ADD 17A8 37 CALLDATACOPY 17A9 81 DUP2 17AA 01 ADD 17AB 88 DUP9 17AC 60 PUSH1 0x60 17AE 82 DUP3 17AF 01 ADD 17B0 52 MSTORE 17B1 87 DUP8 17B2 60 PUSH1 0x80 17B4 8A DUP11 17B5 60 PUSH1 0x05 17B7 1B SHL 17B8 92 SWAP3 17B9 01 ADD 17BA 37 CALLDATACOPY 17BB 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 17DC 33 CALLER 17DD 91 SWAP2 17DE 89 DUP10 17DF 60 PUSH1 0x06 17E1 1B SHL 17E2 60 PUSH1 0x80 17E4 01 ADD 17E5 90 SWAP1 17E6 A4 LOG4 17E7 80 DUP1 17E8 3B EXTCODESIZE 17E9 61 PUSH2 0x17f0 17EC 57 *JUMPI // Stack delta = -5 // Outputs[7] // { // @178F memory[memory[stack[-3]:stack[-3] + 0x20]:memory[stack[-3]:stack[-3] + 0x20] + 0x20] = stack[-3] // @179E memory[memory[stack[-3]:stack[-3] + 0x20] + 0x20:memory[stack[-3]:stack[-3] + 0x20] + 0x20 + 0x20] = 0x60 + (stack[-8] << 0x05) // @17A1 memory[memory[stack[-3]:stack[-3] + 0x20] + stack[-3]:memory[stack[-3]:stack[-3] + 0x20] + stack[-3] + 0x20] = stack[-8] // @17A8 memory[memory[stack[-3]:stack[-3] + 0x20] + 0x60:memory[stack[-3]:stack[-3] + 0x20] + 0x60 + stack[-8] << 0x05] = msg.data[stack[-7]:stack[-7] + stack[-8] << 0x05] // @17B0 memory[memory[stack[-3]:stack[-3] + 0x20] + (stack[-8] << 0x05) + 0x60:memory[stack[-3]:stack[-3] + 0x20] + (stack[-8] << 0x05) + 0x60 + 0x20] = stack[-10] // @17BA memory[memory[stack[-3]:stack[-3] + 0x20] + (stack[-8] << 0x05) + 0x80:memory[stack[-3]:stack[-3] + 0x20] + (stack[-8] << 0x05) + 0x80 + stack[-10] << 0x05] = msg.data[stack[-9]:stack[-9] + stack[-10] << 0x05] // @17E6 log(memory[memory[stack[-3]:stack[-3] + 0x20]:memory[stack[-3]:stack[-3] + 0x20] + 0x80 + (stack[-10] << 0x06)], [0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb, msg.sender, stack[-4], stack[-5]]); // } // Block ends with conditional jump to 0x17f0, if address(stack[-6]).code.length label_17ED: // Incoming jump from 0x17EC, if not address(stack[-6]).code.length // Inputs[2] // { // @17ED stack[-9] // @17EF memory[stack[-9]:stack[-9] + stack[-9]] // } 17ED 88 DUP9 17EE 80 DUP1 17EF F3 *RETURN // Stack delta = +0 // Outputs[1] { @17EF return memory[stack[-9]:stack[-9] + stack[-9]]; } // Block terminates label_17F0: // Incoming jump from 0x17EC, if address(stack[-6]).code.length // Inputs[1] { @17F4 stack[-7] } 17F0 5B JUMPDEST 17F1 61 PUSH2 0x17f9 17F4 96 SWAP7 17F5 61 PUSH2 0x277c 17F8 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @17F4 stack[0] = stack[-7] // @17F4 stack[-7] = 0x17f9 // } // Block ends with call to 0x277c, returns to 0x17F9 label_17F9: // Incoming return from call to 0x277C at 0x17F8 // Inputs[1] { @17FA stack[-1] } 17F9 5B JUMPDEST 17FA 15 ISZERO 17FB 61 PUSH2 0x0534 17FE 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0534, if !stack[-1] label_17FF: // Incoming jump from 0x17FE, if not !stack[-1] // Inputs[3] // { // @17FF stack[-1] // @1806 stack[-2] // @1808 memory[stack[-2]:stack[-2] + stack[-2]] // } 17FF 80 DUP1 1800 80 DUP1 1801 80 DUP1 1802 80 DUP1 1803 80 DUP1 1804 80 DUP1 1805 80 DUP1 1806 88 DUP9 1807 80 DUP1 1808 F3 *RETURN // Stack delta = +7 // Outputs[8] // { // @17FF stack[0] = stack[-1] // @1800 stack[1] = stack[-1] // @1801 stack[2] = stack[-1] // @1802 stack[3] = stack[-1] // @1803 stack[4] = stack[-1] // @1804 stack[5] = stack[-1] // @1805 stack[6] = stack[-1] // @1808 return memory[stack[-2]:stack[-2] + stack[-2]]; // } // Block terminates label_1809: // Incoming jump from 0x1787, if stack[-12] < stack[-6] // Incoming jump from 0x1787, if stack[-1] < stack[-8] // Inputs[7] // { // @180A stack[-3] // @180A stack[-1] // @180B stack[-5] // @180D stack[-2] // @180D stack[-4] // @1813 stack[-8] // @1814 stack[-7] // } 1809 5B JUMPDEST 180A 91 SWAP2 180B 93 SWAP4 180C 50 POP 180D 91 SWAP2 180E 50 POP 180F 61 PUSH2 0x1819 1812 81 DUP2 1813 87 DUP8 1814 87 DUP8 1815 61 PUSH2 0x244c 1818 56 *JUMP // Stack delta = +2 // Outputs[7] // { // @180A stack[-3] = stack[-1] // @180B stack[-5] = stack[-3] // @180D stack[-4] = stack[-2] // @180F stack[-2] = 0x1819 // @1812 stack[-1] = stack[-1] // @1813 stack[0] = stack[-8] // @1814 stack[1] = stack[-7] // } // Block ends with call to 0x244c, returns to 0x1819 label_1819: // Incoming return from call to 0x244C at 0x1818 // Inputs[5] // { // @181A stack[-1] // @181A msg.data[stack[-1]:stack[-1] + 0x20] // @181E stack[-2] // @181F stack[-9] // @1820 stack[-8] // } 1819 5B JUMPDEST 181A 35 CALLDATALOAD 181B 61 PUSH2 0x1825 181E 82 DUP3 181F 8A DUP11 1820 8A DUP11 1821 61 PUSH2 0x244c 1824 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @181A stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @181B stack[0] = 0x1825 // @181E stack[1] = stack[-2] // @181F stack[2] = stack[-9] // @1820 stack[3] = stack[-8] // } // Block ends with call to 0x244c, returns to 0x1825 label_1825: // Incoming return from call to 0x244C at 0x1824 // Inputs[3] // { // @1826 stack[-1] // @1826 msg.data[stack[-1]:stack[-1] + 0x20] // @1827 stack[-2] // } 1825 5B JUMPDEST 1826 35 CALLDATALOAD 1827 90 SWAP1 1828 6B PUSH12 0x7fffffffffffffffffffffff 1835 81 DUP2 1836 11 GT 1837 61 PUSH2 0x1a22 183A 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1827 stack[-1] = stack[-2] // @1827 stack[-2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x1a22, if stack[-2] > 0x7fffffffffffffffffffffff label_183B: // Incoming jump from 0x183A, if not stack[-2] > 0x7fffffffffffffffffffffff // Inputs[4] // { // @183E stack[-1] // @183F stack[-12] // @1885 memory[0x00:0x20] // @1886 storage[keccak256(memory[0x00:0x20])] // } 183B 61 PUSH2 0x188c 183E 81 DUP2 183F 8D DUP14 1840 90 SWAP1 1841 60 PUSH1 0xe0 1843 91 SWAP2 1844 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 1865 82 DUP3 1866 60 PUSH1 0x03 1868 1C SHR 1869 91 SWAP2 186A 60 PUSH1 0x5c 186C 1B SHL 186D 16 AND 186E 17 OR 186F 60 PUSH1 0x07 1871 60 PUSH1 0xfd 1873 1B SHL 1874 17 OR 1875 60 PUSH1 0x00 1877 52 MSTORE 1878 60 PUSH1 0x05 187A 1B SHL 187B 16 AND 187C 61 PUSH2 0xffff 187F 81 DUP2 1880 1B SHL 1881 60 PUSH1 0x20 1883 60 PUSH1 0x00 1885 20 SHA3 1886 54 SLOAD 1887 16 AND 1888 90 SWAP1 1889 1C SHR 188A 90 SWAP1 188B 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1877 memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-12] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-1] >> 0x03) // @188A stack[0] = (storage[keccak256(memory[0x00:0x20])] & (0xffff << ((stack[-1] << 0x05) & 0xe0))) >> ((stack[-1] << 0x05) & 0xe0) // } // Block ends with unconditional jump to 0x188c label_188C: // Incoming jump from 0x188B // Inputs[2] // { // @188D stack[-1] // @188D stack[-3] // } 188C 5B JUMPDEST 188D 91 SWAP2 188E 82 DUP3 188F 81 DUP2 1890 11 GT 1891 61 PUSH2 0x19fb 1894 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @188D stack[-1] = stack[-3] // @188D stack[-3] = stack[-1] // } // Block ends with conditional jump to 0x19fb, if stack[-3] > stack[-1] label_1895: // Incoming jump from 0x1894, if not stack[-3] > stack[-1] // Inputs[1] { @1895 stack[-5] } 1895 84 DUP5 1896 61 PUSH2 0x18ab 1899 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x18ab, if stack[-5] label_189A: // Incoming jump from 0x1899, if not stack[-5] // Incoming jump from 0x19D2 // Inputs[5] // { // @18A0 stack[-4] // @18A1 stack[-5] // @18A2 stack[-6] // @18A3 stack[-7] // @18A5 stack[-13] // } 189A 5B JUMPDEST 189B 50 POP 189C 50 POP 189D 50 POP 189E 60 PUSH1 0x01 18A0 01 ADD 18A1 90 SWAP1 18A2 91 SWAP2 18A3 83 DUP4 18A4 92 SWAP3 18A5 8A DUP11 18A6 92 SWAP3 18A7 61 PUSH2 0x1780 18AA 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @18A2 stack[-4] = stack[-6] // @18A4 stack[-6] = stack[-7] // @18A4 stack[-3] = stack[-5] // @18A6 stack[-5] = stack[-13] // @18A6 stack[-2] = 0x01 + stack[-4] // } // Block ends with unconditional jump to 0x1780 label_18AB: // Incoming jump from 0x1899, if stack[-5] // Inputs[5] // { // @18AC stack[-1] // @18B0 stack[-2] // @18B1 stack[-7] // @18F7 memory[0x00:0x20] // @18F8 storage[keccak256(memory[0x00:0x20])] // } 18AB 5B JUMPDEST 18AC 80 DUP1 18AD 61 PUSH2 0x18fe 18B0 83 DUP4 18B1 89 DUP10 18B2 90 SWAP1 18B3 60 PUSH1 0xe0 18B5 91 SWAP2 18B6 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 18D7 82 DUP3 18D8 60 PUSH1 0x03 18DA 1C SHR 18DB 91 SWAP2 18DC 60 PUSH1 0x5c 18DE 1B SHL 18DF 16 AND 18E0 17 OR 18E1 60 PUSH1 0x07 18E3 60 PUSH1 0xfd 18E5 1B SHL 18E6 17 OR 18E7 60 PUSH1 0x00 18E9 52 MSTORE 18EA 60 PUSH1 0x05 18EC 1B SHL 18ED 16 AND 18EE 61 PUSH2 0xffff 18F1 81 DUP2 18F2 1B SHL 18F3 60 PUSH1 0x20 18F5 60 PUSH1 0x00 18F7 20 SHA3 18F8 54 SLOAD 18F9 16 AND 18FA 90 SWAP1 18FB 1C SHR 18FC 90 SWAP1 18FD 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @18AC stack[0] = stack[-1] // @18E9 memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-7] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-2] >> 0x03) // @18FC stack[1] = (storage[keccak256(memory[0x00:0x20])] & (0xffff << ((stack[-2] << 0x05) & 0xe0))) >> ((stack[-2] << 0x05) & 0xe0) // } // Block ends with unconditional jump to 0x18fe label_18FE: // Incoming jump from 0x18FD // Inputs[3] // { // @18FF stack[-2] // @18FF stack[-1] // @1900 stack[-5] // } 18FE 5B JUMPDEST 18FF 01 ADD 1900 92 SWAP3 1901 61 PUSH2 0xffff 1904 84 DUP5 1905 11 GT 1906 61 PUSH2 0x19d3 1909 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1900 stack[-2] = stack[-5] // @1900 stack[-5] = stack[-1] + stack[-2] // } // Block ends with conditional jump to 0x19d3, if stack[-1] + stack[-2] > 0xffff label_190A: // Incoming jump from 0x1909, if not stack[-1] + stack[-2] > 0xffff // Inputs[8] // { // @190A stack[-1] // @190A stack[-3] // @190E stack[-14] // @1912 stack[-5] // @1913 stack[-4] // @1914 stack[-2] // @1956 memory[0x00:0x20] // @1965 storage[keccak256(memory[0x00:0x20])] // } 190A 91 SWAP2 190B 61 PUSH2 0x1971 190E 8E DUP15 190F 82 DUP3 1910 60 PUSH1 0x01 1912 97 SWAP8 1913 96 SWAP7 1914 94 SWAP5 1915 61 PUSH2 0x19cb 1918 96 SWAP7 1919 03 SUB 191A 90 SWAP1 191B 91 SWAP2 191C 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 193D 83 DUP4 193E 60 PUSH1 0x03 1940 1C SHR 1941 91 SWAP2 1942 60 PUSH1 0x5c 1944 1B SHL 1945 16 AND 1946 17 OR 1947 60 PUSH1 0x07 1949 60 PUSH1 0xfd 194B 1B SHL 194C 17 OR 194D 60 PUSH1 0x00 194F 52 MSTORE 1950 60 PUSH1 0xe0 1952 60 PUSH1 0x20 1954 60 PUSH1 0x00 1956 20 SHA3 1957 92 SWAP3 1958 83 DUP4 1959 60 PUSH1 0x00 195B 52 MSTORE 195C 60 PUSH1 0x05 195E 1B SHL 195F 16 AND 1960 90 SWAP1 1961 61 PUSH2 0xffff 1964 83 DUP4 1965 54 SLOAD 1966 91 SWAP2 1967 83 DUP4 1968 1B SHL 1969 92 SWAP3 196A 1B SHL 196B 19 NOT 196C 16 AND 196D 17 OR 196E 90 SWAP1 196F 55 SSTORE 1970 56 *JUMP // Stack delta = +0 // Outputs[8] // { // @190A stack[-1] = stack[-3] // @1912 stack[-5] = 0x01 // @1913 stack[-4] = stack[-5] // @1914 stack[-2] = stack[-4] // @1918 stack[-3] = 0x19cb // @194F memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-14] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-3] >> 0x03) // @195B memory[0x00:0x20] = keccak256(memory[0x00:0x20]) // @196F storage[keccak256(memory[0x00:0x20])] = (~(0xffff << ((stack[-3] << 0x05) & 0xe0)) & storage[keccak256(memory[0x00:0x20])]) | (stack[-1] - stack[-2] << ((stack[-3] << 0x05) & 0xe0)) // } // Block ends with call to 0x1971, returns to 0x19CB label_1971: // Incoming call from 0x1970, returns to 0x19CB // Inputs[6] // { // @1972 stack[-8] // @1973 stack[-2] // @1974 stack[-1] // @19B0 memory[0x00:0x20] // @19BF storage[keccak256(memory[0x00:0x20])] // @19CA stack[-3] // } 1971 5B JUMPDEST 1972 87 DUP8 1973 91 SWAP2 1974 90 SWAP1 1975 91 SWAP2 1976 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 1997 83 DUP4 1998 60 PUSH1 0x03 199A 1C SHR 199B 91 SWAP2 199C 60 PUSH1 0x5c 199E 1B SHL 199F 16 AND 19A0 17 OR 19A1 60 PUSH1 0x07 19A3 60 PUSH1 0xfd 19A5 1B SHL 19A6 17 OR 19A7 60 PUSH1 0x00 19A9 52 MSTORE 19AA 60 PUSH1 0xe0 19AC 60 PUSH1 0x20 19AE 60 PUSH1 0x00 19B0 20 SHA3 19B1 92 SWAP3 19B2 83 DUP4 19B3 60 PUSH1 0x00 19B5 52 MSTORE 19B6 60 PUSH1 0x05 19B8 1B SHL 19B9 16 AND 19BA 90 SWAP1 19BB 61 PUSH2 0xffff 19BE 83 DUP4 19BF 54 SLOAD 19C0 91 SWAP2 19C1 83 DUP4 19C2 1B SHL 19C3 92 SWAP3 19C4 1B SHL 19C5 19 NOT 19C6 16 AND 19C7 17 OR 19C8 90 SWAP1 19C9 55 SSTORE 19CA 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @19A9 memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-8] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-1] >> 0x03) // @19B5 memory[0x00:0x20] = keccak256(memory[0x00:0x20]) // @19C9 storage[keccak256(memory[0x00:0x20])] = (~(0xffff << ((stack[-1] << 0x05) & 0xe0)) & storage[keccak256(memory[0x00:0x20])]) | (stack[-2] << ((stack[-1] << 0x05) & 0xe0)) // } // Block ends with unconditional jump to stack[-3] label_19CB: // Incoming return from call to 0x1971 at 0x1970 // Inputs[3] // { // @19CC stack[-2] // @19CC stack[-1] // @19CD code.length // } 19CB 5B JUMPDEST 19CC 90 SWAP1 19CD 38 CODESIZE 19CE 80 DUP1 19CF 61 PUSH2 0x189a 19D2 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @19CC stack[-2] = stack[-1] // @19CC stack[-1] = stack[-2] // @19CD stack[0] = code.length // @19CE stack[1] = code.length // } // Block ends with unconditional jump to 0x189a label_19D3: // Incoming jump from 0x1909, if stack[-1] + stack[-2] > 0xffff // Inputs[3] // { // @19D5 stack[-15] // @19D6 stack[-16] // @19FA memory[stack[-16]:stack[-16] + stack[-15]] // } 19D3 5B JUMPDEST 19D4 50 POP 19D5 8D DUP14 19D6 8F DUP16 19D7 7F PUSH32 0xb6cdf5d000000000000000000000000000000000000000000000000000000000 19F8 81 DUP2 19F9 52 MSTORE 19FA FD *REVERT // Stack delta = -1 // Outputs[2] // { // @19F9 memory[stack[-16]:stack[-16] + 0x20] = 0xb6cdf5d000000000000000000000000000000000000000000000000000000000 // @19FA revert(memory[stack[-16]:stack[-16] + stack[-15]]); // } // Block terminates label_19FB: // Incoming jump from 0x1894, if stack[-3] > stack[-1] // Inputs[3] // { // @19FC stack[-14] // @19FD stack[-15] // @1A21 memory[stack[-15]:stack[-15] + stack[-14]] // } 19FB 5B JUMPDEST 19FC 8D DUP14 19FD 8F DUP16 19FE 7F PUSH32 0x169b037b00000000000000000000000000000000000000000000000000000000 1A1F 81 DUP2 1A20 52 MSTORE 1A21 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1A20 memory[stack[-15]:stack[-15] + 0x20] = 0x169b037b00000000000000000000000000000000000000000000000000000000 // @1A21 revert(memory[stack[-15]:stack[-15] + stack[-14]]); // } // Block terminates label_1A22: // Incoming jump from 0x183A, if stack[-2] > 0x7fffffffffffffffffffffff // Inputs[3] // { // @1A23 stack[-13] // @1A24 stack[-14] // @1A48 memory[stack[-14]:stack[-14] + stack[-13]] // } 1A22 5B JUMPDEST 1A23 8C DUP13 1A24 8E DUP15 1A25 7F PUSH32 0x8ceeefe200000000000000000000000000000000000000000000000000000000 1A46 81 DUP2 1A47 52 MSTORE 1A48 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1A47 memory[stack[-14]:stack[-14] + 0x20] = 0x8ceeefe200000000000000000000000000000000000000000000000000000000 // @1A48 revert(memory[stack[-14]:stack[-14] + stack[-13]]); // } // Block terminates label_1A49: // Incoming jump from 0x1775, if (stack[-10] & stack[-1]) - msg.sender // Inputs[4] // { // @1A5F stack[-10] // @1A87 msg.sender // @1A8F memory[0x00:0x40] // @1A94 storage[keccak256(memory[0x00:0x40])] // } 1A49 5B JUMPDEST 1A4A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A5F 8A DUP11 1A60 16 AND 1A61 60 PUSH1 0x00 1A63 90 SWAP1 1A64 81 DUP2 1A65 52 MSTORE 1A66 7F PUSH32 0xd000000000000000000000000000000000000000000000000000000000000000 1A87 33 CALLER 1A88 17 OR 1A89 60 PUSH1 0x20 1A8B 52 MSTORE 1A8C 60 PUSH1 0x40 1A8E 81 DUP2 1A8F 20 SHA3 1A90 90 SWAP1 1A91 81 DUP2 1A92 90 SWAP1 1A93 52 MSTORE 1A94 54 SLOAD 1A95 61 PUSH2 0x1776 1A98 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1A65 memory[0x00:0x20] = stack[-10] & 0xffffffffffffffffffffffffffffffffffffffff // @1A8B memory[0x20:0x40] = msg.sender | 0xd000000000000000000000000000000000000000000000000000000000000000 // @1A93 memory[0x00:0x20] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x1776, if storage[keccak256(memory[0x00:0x40])] label_1A99: // Incoming jump from 0x1A98, if not storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @1A99 stack[-11] // @1A9A stack[-12] // @1ABE memory[stack[-12]:stack[-12] + stack[-11]] // } 1A99 8A DUP11 1A9A 8C DUP13 1A9B 7F PUSH32 0x59c896be00000000000000000000000000000000000000000000000000000000 1ABC 81 DUP2 1ABD 52 MSTORE 1ABE FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1ABD memory[stack[-12]:stack[-12] + 0x20] = 0x59c896be00000000000000000000000000000000000000000000000000000000 // @1ABE revert(memory[stack[-12]:stack[-12] + stack[-11]]); // } // Block terminates label_1ABF: // Incoming jump from 0x176B, if stack[-6] - stack[-8] // Inputs[3] // { // @1AC0 stack[-11] // @1AC1 stack[-12] // @1AE5 memory[stack[-12]:stack[-12] + stack[-11]] // } 1ABF 5B JUMPDEST 1AC0 8A DUP11 1AC1 8C DUP13 1AC2 7F PUSH32 0xa24a13a600000000000000000000000000000000000000000000000000000000 1AE3 81 DUP2 1AE4 52 MSTORE 1AE5 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1AE4 memory[stack[-12]:stack[-12] + 0x20] = 0xa24a13a600000000000000000000000000000000000000000000000000000000 // @1AE5 revert(memory[stack[-12]:stack[-12] + stack[-11]]); // } // Block terminates label_1AE6: // Incoming jump from 0x1764, if !(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[3] // { // @1AE7 stack[-11] // @1AE8 stack[-12] // @1B0C memory[stack[-12]:stack[-12] + stack[-11]] // } 1AE6 5B JUMPDEST 1AE7 8A DUP11 1AE8 8C DUP13 1AE9 7F PUSH32 0xea553b3400000000000000000000000000000000000000000000000000000000 1B0A 81 DUP2 1B0B 52 MSTORE 1B0C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1B0B memory[stack[-12]:stack[-12] + 0x20] = 0xea553b3400000000000000000000000000000000000000000000000000000000 // @1B0C revert(memory[stack[-12]:stack[-12] + stack[-11]]); // } // Block terminates label_1B0D: // Incoming jump from 0x1737, if msg.data[0x84:0xa4] > stack[-5] // Inputs[2] // { // @1B0E stack[-10] // @1B10 memory[stack[-10]:stack[-10] + stack[-10]] // } 1B0D 5B JUMPDEST 1B0E 89 DUP10 1B0F 80 DUP1 1B10 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B10 revert(memory[stack[-10]:stack[-10] + stack[-10]]); } // Block terminates label_1B11: // Incoming jump from 0x006A, if 0x25692962 == stack[-2] // Inputs[2] // { // @1B12 stack[-4] // @1B17 msg.data.length // } 1B11 5B JUMPDEST 1B12 83 DUP4 1B13 80 DUP1 1B14 60 PUSH1 0x03 1B16 19 NOT 1B17 36 CALLDATASIZE 1B18 01 ADD 1B19 12 SLT 1B1A 61 PUSH2 0x082b 1B1D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B12 stack[0] = stack[-4] } // Block ends with conditional jump to 0x082b, if msg.data.length + ~0x03 i< stack[-4] label_1B1E: // Incoming jump from 0x1B1D, if not msg.data.length + ~0x03 i< stack[-4] // Inputs[7] // { // @1B26 msg.sender // @1B27 stack[-1] // @1B2D block.timestamp // @1B33 memory[0x0c:0x2c] // @1B35 msg.sender // @1B59 memory[stack[-1]:stack[-1] + stack[-1]] // @1B5B memory[stack[-1]:stack[-1] + stack[-1]] // } 1B1E 63 PUSH4 0x389a75e1 1B23 60 PUSH1 0x0c 1B25 52 MSTORE 1B26 33 CALLER 1B27 81 DUP2 1B28 52 MSTORE 1B29 62 PUSH3 0x02a300 1B2D 42 TIMESTAMP 1B2E 01 ADD 1B2F 60 PUSH1 0x20 1B31 60 PUSH1 0x0c 1B33 20 SHA3 1B34 55 SSTORE 1B35 33 CALLER 1B36 7F PUSH32 0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d 1B57 82 DUP3 1B58 80 DUP1 1B59 A2 LOG2 1B5A 80 DUP1 1B5B F3 *RETURN // Stack delta = -1 // Outputs[5] // { // @1B25 memory[0x0c:0x2c] = 0x389a75e1 // @1B28 memory[stack[-1]:stack[-1] + 0x20] = msg.sender // @1B34 storage[keccak256(memory[0x0c:0x2c])] = block.timestamp + 0x02a300 // @1B59 log(memory[stack[-1]:stack[-1] + stack[-1]], [0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d, msg.sender]); // @1B5B return memory[stack[-1]:stack[-1] + stack[-1]]; // } // Block terminates label_1B5C: // Incoming jump from 0x005F, if 0x156e29f6 == stack[-2] // Inputs[4] // { // @1B5D stack[-1] // @1B5D stack[-3] // @1B5E stack[-2] // @1B60 msg.value // } 1B5C 5B JUMPDEST 1B5D 91 SWAP2 1B5E 90 SWAP1 1B5F 50 POP 1B60 34 CALLVALUE 1B61 61 PUSH2 0x079a 1B64 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1B5D stack[-3] = stack[-1] // @1B5E stack[-2] = stack[-3] // } // Block ends with conditional jump to 0x079a, if msg.value label_1B65: // Incoming jump from 0x1B64, if not msg.value // Inputs[1] { @1B68 msg.data.length } 1B65 61 PUSH2 0x1b6d 1B68 36 CALLDATASIZE 1B69 61 PUSH2 0x219b 1B6C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1B65 stack[0] = 0x1b6d // @1B68 stack[1] = msg.data.length // } // Block ends with call to 0x219b, returns to 0x1B6D label_1B6D: // Incoming return from call to 0x219B at 0x1B6C // Inputs[7] // { // @1B6E stack[-2] // @1B6E stack[-1] // @1B84 stack[-4] // @1B85 stack[-3] // @1B89 stack[-6] // @1B8A storage[stack[-6]] // @1B8C msg.sender // } 1B6D 5B JUMPDEST 1B6E 90 SWAP1 1B6F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B84 93 SWAP4 1B85 92 SWAP3 1B86 93 SWAP4 1B87 92 SWAP3 1B88 83 DUP4 1B89 87 DUP8 1B8A 54 SLOAD 1B8B 16 AND 1B8C 33 CALLER 1B8D 03 SUB 1B8E 61 PUSH2 0x1e40 1B91 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @1B6E stack[-1] = stack[-2] // @1B6E stack[-2] = stack[-1] // @1B86 stack[-4] = stack[-3] // @1B87 stack[0] = stack[-4] // @1B87 stack[-3] = 0xffffffffffffffffffffffffffffffffffffffff // } // Block ends with conditional jump to 0x1e40, if msg.sender - (storage[stack[-6]] & 0xffffffffffffffffffffffffffffffffffffffff) label_1B92: // Incoming jump from 0x1E50, if !(msg.sender - (storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] & stack[-4])) // Incoming jump from 0x1B91, if not msg.sender - (storage[stack[-6]] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[3] // { // @1B93 stack[-1] // @1B94 memory[stack[-1]:stack[-1] + 0x20] // @1B95 stack[-4] // } 1B92 5B JUMPDEST 1B93 80 DUP1 1B94 51 MLOAD 1B95 93 SWAP4 1B96 61 PUSH2 0x1b9e 1B99 85 DUP6 1B9A 61 PUSH2 0x224e 1B9D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1B95 stack[0] = stack[-4] // @1B95 stack[-4] = memory[stack[-1]:stack[-1] + 0x20] // @1B96 stack[1] = 0x1b9e // @1B99 stack[2] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x224e, returns to 0x1B9E label_1B9E: // Incoming return from call to 0x224E at 0x1B9D // Inputs[3] // { // @1B9F stack[-8] // @1BA0 stack[-5] // @1BAF stack[-3] // } 1B9E 5B JUMPDEST 1B9F 87 DUP8 1BA0 85 DUP6 1BA1 52 MSTORE 1BA2 6B PUSH12 0x7fffffffffffffffffffffff 1BAF 83 DUP4 1BB0 11 GT 1BB1 61 PUSH2 0x076f 1BB4 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1BA1 memory[stack[-5]:stack[-5] + 0x20] = stack[-8] } // Block ends with conditional jump to 0x076f, if stack[-3] > 0x7fffffffffffffffffffffff label_1BB5: // Incoming jump from 0x1BB4, if not stack[-3] > 0x7fffffffffffffffffffffff // Inputs[2] // { // @1BB5 stack[-6] // @1BB6 stack[-1] // } 1BB5 85 DUP6 1BB6 16 AND 1BB7 15 ISZERO 1BB8 61 PUSH2 0x1e19 1BBB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1e19, if !(stack[-6] & stack[-1]) label_1BBC: // Incoming jump from 0x1BBB, if not !(stack[-6] & stack[-1]) // Inputs[1] { @1BBC stack[-3] } 1BBC 82 DUP3 1BBD 15 ISZERO 1BBE 61 PUSH2 0x1df2 1BC1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1df2, if !stack[-3] label_1BC2: // Incoming jump from 0x1BC1, if not !stack[-3] // Inputs[4] // { // @1BC5 stack[-2] // @1BC6 stack[-5] // @1C0C memory[0x00:0x20] // @1C0D storage[keccak256(memory[0x00:0x20])] // } 1BC2 61 PUSH2 0x1c13 1BC5 82 DUP3 1BC6 86 DUP7 1BC7 90 SWAP1 1BC8 60 PUSH1 0xe0 1BCA 91 SWAP2 1BCB 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 1BEC 82 DUP3 1BED 60 PUSH1 0x03 1BEF 1C SHR 1BF0 91 SWAP2 1BF1 60 PUSH1 0x5c 1BF3 1B SHL 1BF4 16 AND 1BF5 17 OR 1BF6 60 PUSH1 0x07 1BF8 60 PUSH1 0xfd 1BFA 1B SHL 1BFB 17 OR 1BFC 60 PUSH1 0x00 1BFE 52 MSTORE 1BFF 60 PUSH1 0x05 1C01 1B SHL 1C02 16 AND 1C03 61 PUSH2 0xffff 1C06 81 DUP2 1C07 1B SHL 1C08 60 PUSH1 0x20 1C0A 60 PUSH1 0x00 1C0C 20 SHA3 1C0D 54 SLOAD 1C0E 16 AND 1C0F 90 SWAP1 1C10 1C SHR 1C11 90 SWAP1 1C12 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1BFE memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-5] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-2] >> 0x03) // @1C11 stack[0] = (storage[keccak256(memory[0x00:0x20])] & (0xffff << ((stack[-2] << 0x05) & 0xe0))) >> ((stack[-2] << 0x05) & 0xe0) // } // Block ends with unconditional jump to 0x1c13 label_1C13: // Incoming jump from 0x1C12 // Inputs[2] // { // @1C14 stack[-4] // @1C15 stack[-1] // } 1C13 5B JUMPDEST 1C14 83 DUP4 1C15 81 DUP2 1C16 01 ADD 1C17 61 PUSH2 0xffff 1C1A 91 SWAP2 1C1B 82 DUP3 1C1C 82 DUP3 1C1D 11 GT 1C1E 61 PUSH2 0x0684 1C21 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @1C16 stack[0] = stack[-1] + stack[-4] // @1C1A stack[1] = stack[-1] // @1C1A stack[-1] = 0xffff // } // Block ends with conditional jump to 0x0684, if stack[-1] + stack[-4] > 0xffff label_1C22: // Incoming jump from 0x1C21, if not stack[-1] + stack[-4] > 0xffff // Inputs[2] // { // @1C22 stack[-2] // @1C23 stack[-1] // } 1C22 81 DUP2 1C23 10 LT 1C24 61 PUSH2 0x1dcb 1C27 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1dcb, if stack[-2] < stack[-1] label_1C28: // Incoming jump from 0x1C27, if not stack[-2] < stack[-1] // Inputs[5] // { // @1C2B stack[-1] // @1C2C stack[-4] // @1C2D stack[-7] // @1C6B memory[0x00:0x20] // @1C7A storage[keccak256(memory[0x00:0x20])] // } 1C28 61 PUSH2 0x1c86 1C2B 90 SWAP1 1C2C 84 DUP5 1C2D 88 DUP9 1C2E 91 SWAP2 1C2F 90 SWAP1 1C30 91 SWAP2 1C31 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 1C52 83 DUP4 1C53 60 PUSH1 0x03 1C55 1C SHR 1C56 91 SWAP2 1C57 60 PUSH1 0x5c 1C59 1B SHL 1C5A 16 AND 1C5B 17 OR 1C5C 60 PUSH1 0x07 1C5E 60 PUSH1 0xfd 1C60 1B SHL 1C61 17 OR 1C62 60 PUSH1 0x00 1C64 52 MSTORE 1C65 60 PUSH1 0xe0 1C67 60 PUSH1 0x20 1C69 60 PUSH1 0x00 1C6B 20 SHA3 1C6C 92 SWAP3 1C6D 83 DUP4 1C6E 60 PUSH1 0x00 1C70 52 MSTORE 1C71 60 PUSH1 0x05 1C73 1B SHL 1C74 16 AND 1C75 90 SWAP1 1C76 61 PUSH2 0xffff 1C79 83 DUP4 1C7A 54 SLOAD 1C7B 91 SWAP2 1C7C 83 DUP4 1C7D 1B SHL 1C7E 92 SWAP3 1C7F 1B SHL 1C80 19 NOT 1C81 16 AND 1C82 17 OR 1C83 90 SWAP1 1C84 55 SSTORE 1C85 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1C64 memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-7] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-4] >> 0x03) // @1C70 memory[0x00:0x20] = keccak256(memory[0x00:0x20]) // @1C84 storage[keccak256(memory[0x00:0x20])] = (~(0xffff << ((stack[-4] << 0x05) & 0xe0)) & storage[keccak256(memory[0x00:0x20])]) | (stack[-1] << ((stack[-4] << 0x05) & 0xe0)) // } // Block ends with unconditional jump to 0x1c86 label_1C86: // Incoming jump from 0x1C85 // Inputs[4] // { // @1C8A stack[-3] // @1C8B stack[-6] // @1CD3 memory[0x00:0x20] // @1CD4 storage[keccak256(memory[0x00:0x20])] // } 1C86 5B JUMPDEST 1C87 61 PUSH2 0x1cdd 1C8A 83 DUP4 1C8B 87 DUP8 1C8C 90 SWAP1 1C8D 60 PUSH1 0xe0 1C8F 91 SWAP2 1C90 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 1CB1 82 DUP3 1CB2 60 PUSH1 0x03 1CB4 1C SHR 1CB5 91 SWAP2 1CB6 60 PUSH1 0x5c 1CB8 1B SHL 1CB9 16 AND 1CBA 17 OR 1CBB 60 PUSH1 0x07 1CBD 60 PUSH1 0xfd 1CBF 1B SHL 1CC0 17 OR 1CC1 60 PUSH1 0x00 1CC3 52 MSTORE 1CC4 60 PUSH1 0x05 1CC6 1B SHL 1CC7 16 AND 1CC8 63 PUSH4 0xffff0000 1CCD 81 DUP2 1CCE 1B SHL 1CCF 60 PUSH1 0x20 1CD1 60 PUSH1 0x00 1CD3 20 SHA3 1CD4 54 SLOAD 1CD5 16 AND 1CD6 90 SWAP1 1CD7 1C SHR 1CD8 60 PUSH1 0x10 1CDA 1C SHR 1CDB 90 SWAP1 1CDC 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1CC3 memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-6] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-3] >> 0x03) // @1CDB stack[0] = ((storage[keccak256(memory[0x00:0x20])] & (0xffff0000 << ((stack[-3] << 0x05) & 0xe0))) >> ((stack[-3] << 0x05) & 0xe0)) >> 0x10 // } // Block ends with unconditional jump to 0x1cdd label_1CDD: // Incoming jump from 0x1CDC // Inputs[3] // { // @1CDE stack[-5] // @1CDF stack[-1] // @1CE1 stack[-2] // } 1CDD 5B JUMPDEST 1CDE 84 DUP5 1CDF 81 DUP2 1CE0 01 ADD 1CE1 91 SWAP2 1CE2 82 DUP3 1CE3 11 GT 1CE4 61 PUSH2 0x1dcb 1CE7 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1CE1 stack[-2] = stack[-1] + stack[-5] } // Block ends with conditional jump to 0x1dcb, if stack[-1] + stack[-5] > stack[-2] label_1CE8: // Incoming jump from 0x1CE7, if not stack[-1] + stack[-5] > stack[-2] // Inputs[2] // { // @1CE8 stack[-2] // @1CE9 stack[-1] // } 1CE8 81 DUP2 1CE9 10 LT 1CEA 61 PUSH2 0x1da4 1CED 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1da4, if stack[-2] < stack[-1] label_1CEE: // Incoming jump from 0x1CED, if not stack[-2] < stack[-1] // Inputs[7] // { // @1CEE stack[-6] // @1CEF stack[-2] // @1CF3 stack[-8] // @1CF4 stack[-1] // @1CF5 stack[-3] // @1D34 memory[0x00:0x20] // @1D45 storage[keccak256(memory[0x00:0x20])] // } 1CEE 85 DUP6 1CEF 91 SWAP2 1CF0 61 PUSH2 0x1d54 1CF3 89 DUP10 1CF4 92 SWAP3 1CF5 85 DUP6 1CF6 85 DUP6 1CF7 91 SWAP2 1CF8 90 SWAP1 1CF9 91 SWAP2 1CFA 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 1D1B 83 DUP4 1D1C 60 PUSH1 0x03 1D1E 1C SHR 1D1F 91 SWAP2 1D20 60 PUSH1 0x5c 1D22 1B SHL 1D23 16 AND 1D24 17 OR 1D25 60 PUSH1 0x07 1D27 60 PUSH1 0xfd 1D29 1B SHL 1D2A 17 OR 1D2B 60 PUSH1 0x00 1D2D 52 MSTORE 1D2E 60 PUSH1 0xe0 1D30 60 PUSH1 0x20 1D32 60 PUSH1 0x00 1D34 20 SHA3 1D35 92 SWAP3 1D36 83 DUP4 1D37 60 PUSH1 0x00 1D39 52 MSTORE 1D3A 60 PUSH1 0x05 1D3C 1B SHL 1D3D 16 AND 1D3E 90 SWAP1 1D3F 63 PUSH4 0xffff0000 1D44 83 DUP4 1D45 54 SLOAD 1D46 91 SWAP2 1D47 60 PUSH1 0x10 1D49 1B SHL 1D4A 83 DUP4 1D4B 1B SHL 1D4C 92 SWAP3 1D4D 1B SHL 1D4E 19 NOT 1D4F 16 AND 1D50 17 OR 1D51 90 SWAP1 1D52 55 SSTORE 1D53 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1CEF stack[-2] = stack[-6] // @1CEF stack[0] = stack[-2] // @1CF4 stack[-1] = stack[-8] // @1D2D memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-6] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-3] >> 0x03) // @1D39 memory[0x00:0x20] = keccak256(memory[0x00:0x20]) // @1D52 storage[keccak256(memory[0x00:0x20])] = (~(0xffff0000 << ((stack[-3] << 0x05) & 0xe0)) & storage[keccak256(memory[0x00:0x20])]) | ((stack[-1] << 0x10) << ((stack[-3] << 0x05) & 0xe0)) // } // Block ends with unconditional jump to 0x1d54 label_1D54: // Incoming jump from 0x1D53 // Inputs[10] // { // @1D76 stack[-1] // @1D77 memory[stack[-1]:stack[-1] + 0x20] // @1D79 stack[-4] // @1D7C stack[-5] // @1D82 msg.sender // @1D84 memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + stack[-1]] // @1D84 stack[-2] // @1D84 stack[-3] // @1D85 stack[-7] // @1D86 address(stack[-7]).code.length // } 1D54 5B JUMPDEST 1D55 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 1D76 81 DUP2 1D77 51 MLOAD 1D78 91 SWAP2 1D79 85 DUP6 1D7A 83 DUP4 1D7B 52 MSTORE 1D7C 86 DUP7 1D7D 60 PUSH1 0x20 1D7F 84 DUP5 1D80 01 ADD 1D81 52 MSTORE 1D82 33 CALLER 1D83 92 SWAP3 1D84 A4 LOG4 1D85 83 DUP4 1D86 3B EXTCODESIZE 1D87 61 PUSH2 0x1d8e 1D8A 57 *JUMPI // Stack delta = -3 // Outputs[3] // { // @1D7B memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + 0x20] = stack[-4] // @1D81 memory[memory[stack[-1]:stack[-1] + 0x20] + 0x20:memory[stack[-1]:stack[-1] + 0x20] + 0x20 + 0x20] = stack[-5] // @1D84 log(memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + stack[-1]], [0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62, msg.sender, stack[-2], stack[-3]]); // } // Block ends with conditional jump to 0x1d8e, if address(stack[-7]).code.length label_1D8B: // Incoming jump from 0x1D8A, if not address(stack[-7]).code.length // Inputs[2] // { // @1D8B stack[-6] // @1D8D memory[stack[-6]:stack[-6] + stack[-6]] // } 1D8B 85 DUP6 1D8C 80 DUP1 1D8D F3 *RETURN // Stack delta = +0 // Outputs[1] { @1D8D return memory[stack[-6]:stack[-6] + stack[-6]]; } // Block terminates label_1D8E: // Incoming jump from 0x1D8A, if address(stack[-7]).code.length // Inputs[1] { @1D92 stack[-4] } 1D8E 5B JUMPDEST 1D8F 61 PUSH2 0x1d97 1D92 93 SWAP4 1D93 61 PUSH2 0x24f3 1D96 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1D92 stack[0] = stack[-4] // @1D92 stack[-4] = 0x1d97 // } // Block ends with call to 0x24f3, returns to 0x1D97 label_1D97: // Incoming return from call to 0x24F3 at 0x1D96 // Inputs[1] { @1D98 stack[-1] } 1D97 5B JUMPDEST 1D98 15 ISZERO 1D99 61 PUSH2 0x0534 1D9C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0534, if !stack[-1] label_1D9D: // Incoming jump from 0x1D9C, if not !stack[-1] // Inputs[3] // { // @1D9D stack[-1] // @1DA1 stack[-2] // @1DA3 memory[stack[-2]:stack[-2] + stack[-2]] // } 1D9D 80 DUP1 1D9E 80 DUP1 1D9F 80 DUP1 1DA0 80 DUP1 1DA1 85 DUP6 1DA2 80 DUP1 1DA3 F3 *RETURN // Stack delta = +4 // Outputs[5] // { // @1D9D stack[0] = stack[-1] // @1D9E stack[1] = stack[-1] // @1D9F stack[2] = stack[-1] // @1DA0 stack[3] = stack[-1] // @1DA3 return memory[stack[-2]:stack[-2] + stack[-2]]; // } // Block terminates label_1DA4: // Incoming jump from 0x1CED, if stack[-2] < stack[-1] // Inputs[3] // { // @1DA5 stack[-7] // @1DA6 stack[-8] // @1DCA memory[stack[-8]:stack[-8] + stack[-7]] // } 1DA4 5B JUMPDEST 1DA5 86 DUP7 1DA6 88 DUP9 1DA7 7F PUSH32 0xb6cdf5d000000000000000000000000000000000000000000000000000000000 1DC8 81 DUP2 1DC9 52 MSTORE 1DCA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1DC9 memory[stack[-8]:stack[-8] + 0x20] = 0xb6cdf5d000000000000000000000000000000000000000000000000000000000 // @1DCA revert(memory[stack[-8]:stack[-8] + stack[-7]]); // } // Block terminates label_1DCB: // Incoming jump from 0x1CE7, if stack[-1] + stack[-5] > stack[-2] // Incoming jump from 0x1C27, if stack[-2] < stack[-1] // Inputs[3] // { // @1DCC stack[-8] // @1DCD stack[-9] // @1DF1 memory[stack[-9]:stack[-9] + stack[-8]] // } 1DCB 5B JUMPDEST 1DCC 87 DUP8 1DCD 89 DUP10 1DCE 7F PUSH32 0xb6cdf5d000000000000000000000000000000000000000000000000000000000 1DEF 81 DUP2 1DF0 52 MSTORE 1DF1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1DF0 memory[stack[-9]:stack[-9] + 0x20] = 0xb6cdf5d000000000000000000000000000000000000000000000000000000000 // @1DF1 revert(memory[stack[-9]:stack[-9] + stack[-8]]); // } // Block terminates label_1DF2: // Incoming jump from 0x1BC1, if !stack[-3] // Inputs[3] // { // @1DF3 stack[-6] // @1DF4 stack[-7] // @1E18 memory[stack[-7]:stack[-7] + stack[-6]] // } 1DF2 5B JUMPDEST 1DF3 85 DUP6 1DF4 87 DUP8 1DF5 7F PUSH32 0xb562e8dd00000000000000000000000000000000000000000000000000000000 1E16 81 DUP2 1E17 52 MSTORE 1E18 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1E17 memory[stack[-7]:stack[-7] + 0x20] = 0xb562e8dd00000000000000000000000000000000000000000000000000000000 // @1E18 revert(memory[stack[-7]:stack[-7] + stack[-6]]); // } // Block terminates label_1E19: // Incoming jump from 0x1BBB, if !(stack[-6] & stack[-1]) // Inputs[3] // { // @1E1A stack[-6] // @1E1B stack[-7] // @1E3F memory[stack[-7]:stack[-7] + stack[-6]] // } 1E19 5B JUMPDEST 1E1A 85 DUP6 1E1B 87 DUP8 1E1C 7F PUSH32 0x2e07630000000000000000000000000000000000000000000000000000000000 1E3D 81 DUP2 1E3E 52 MSTORE 1E3F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1E3E memory[stack[-7]:stack[-7] + 0x20] = 0x2e07630000000000000000000000000000000000000000000000000000000000 // @1E3F revert(memory[stack[-7]:stack[-7] + stack[-6]]); // } // Block terminates label_1E40: // Incoming jump from 0x1B91, if msg.sender - (storage[stack[-6]] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[3] // { // @1E41 stack[-4] // @1E48 storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] // @1E4A msg.sender // } 1E40 5B JUMPDEST 1E41 83 DUP4 1E42 63 PUSH4 0x8b78c6d8 1E47 19 NOT 1E48 54 SLOAD 1E49 16 AND 1E4A 33 CALLER 1E4B 03 SUB 1E4C 15 ISZERO 1E4D 61 PUSH2 0x1b92 1E50 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b92, if !(msg.sender - (storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] & stack[-4])) label_1E51: // Incoming jump from 0x1E50, if not !(msg.sender - (storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] & stack[-4])) // Inputs[4] // { // @1E51 stack[-6] // @1E52 stack[-1] // @1E53 memory[stack[-1]:stack[-1] + 0x20] // @1E77 memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + stack[-6]] // } 1E51 85 DUP6 1E52 90 SWAP1 1E53 51 MLOAD 1E54 7F PUSH32 0xea8e4eb500000000000000000000000000000000000000000000000000000000 1E75 81 DUP2 1E76 52 MSTORE 1E77 FD *REVERT // Stack delta = -1 // Outputs[2] // { // @1E76 memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + 0x20] = 0xea8e4eb500000000000000000000000000000000000000000000000000000000 // @1E77 revert(memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + stack[-6]]); // } // Block terminates label_1E78: // Incoming jump from 0x0054, if 0x1102fb57 == stack[-2] // Inputs[1] { @1E7B msg.value } 1E78 5B JUMPDEST 1E79 50 POP 1E7A 50 POP 1E7B 34 CALLVALUE 1E7C 61 PUSH2 0x0172 1E7F 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0172, if msg.value label_1E80: // Incoming jump from 0x1E7F, if not msg.value // Inputs[2] // { // @1E80 stack[-2] // @1E84 msg.data.length // } 1E80 81 DUP2 1E81 60 PUSH1 0x03 1E83 19 NOT 1E84 36 CALLDATASIZE 1E85 01 ADD 1E86 12 SLT 1E87 61 PUSH2 0x0172 1E8A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0172, if msg.data.length + ~0x03 i< stack[-2] label_1E8B: // Incoming jump from 0x1E8A, if not msg.data.length + ~0x03 i< stack[-2] // Inputs[5] // { // @1EA2 stack[-2] // @1EA3 storage[stack[-2]] // @1EA5 stack[-1] // @1EA6 memory[stack[-1]:stack[-1] + 0x20] // @1EAA memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + 0x20] // } 1E8B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EA0 60 PUSH1 0x20 1EA2 92 SWAP3 1EA3 54 SLOAD 1EA4 16 AND 1EA5 90 SWAP1 1EA6 51 MLOAD 1EA7 90 SWAP1 1EA8 81 DUP2 1EA9 52 MSTORE 1EAA F3 *RETURN // Stack delta = -2 // Outputs[2] // { // @1EA9 memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + 0x20] = storage[stack[-2]] & 0xffffffffffffffffffffffffffffffffffffffff // @1EAA return memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + 0x20]; // } // Block terminates label_1EAB: // Incoming jump from 0x0049, if 0x0e89341c == stack[-2] // Inputs[4] // { // @1EAC stack[-1] // @1EAC stack[-3] // @1EAD stack[-2] // @1EAF msg.value // } 1EAB 5B JUMPDEST 1EAC 91 SWAP2 1EAD 90 SWAP1 1EAE 50 POP 1EAF 34 CALLVALUE 1EB0 61 PUSH2 0x079a 1EB3 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1EAC stack[-3] = stack[-1] // @1EAD stack[-2] = stack[-3] // } // Block ends with conditional jump to 0x079a, if msg.value label_1EB4: // Incoming jump from 0x1EB3, if not msg.value // Inputs[2] // { // @1EB6 stack[-2] // @1EBB msg.data.length // } 1EB4 60 PUSH1 0x20 1EB6 91 SWAP2 1EB7 82 DUP3 1EB8 60 PUSH1 0x03 1EBA 19 NOT 1EBB 36 CALLDATASIZE 1EBC 01 ADD 1EBD 12 SLT 1EBE 61 PUSH2 0x0da0 1EC1 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1EB6 stack[0] = stack[-2] // @1EB6 stack[-2] = 0x20 // } // Block ends with conditional jump to 0x0da0, if msg.data.length + ~0x03 i< 0x20 label_1EC2: // Incoming jump from 0x1EC1, if not msg.data.length + ~0x03 i< 0x20 // Inputs[8] // { // @1EC2 msg.data[stack[-1]:stack[-1] + 0x20] // @1EC2 stack[-1] // @1EC3 stack[-4] // @1EC7 stack[-3] // @1EC9 stack[-2] // @1ECB memory[stack[-4]:stack[-4] + stack[-2]] // @1ECD memory[stack[-2]:stack[-2] + 0x20] // @1ED3 storage[keccak256(memory[stack[-4]:stack[-4] + stack[-2]])] // } 1EC2 35 CALLDATALOAD 1EC3 83 DUP4 1EC4 52 MSTORE 1EC5 60 PUSH1 0x02 1EC7 82 DUP3 1EC8 52 MSTORE 1EC9 80 DUP1 1ECA 83 DUP4 1ECB 20 SHA3 1ECC 81 DUP2 1ECD 51 MLOAD 1ECE 93 SWAP4 1ECF 84 DUP5 1ED0 91 SWAP2 1ED1 81 DUP2 1ED2 81 DUP2 1ED3 54 SLOAD 1ED4 90 SWAP1 1ED5 61 PUSH2 0x1edd 1ED8 82 DUP3 1ED9 61 PUSH2 0x2850 1EDC 56 *JUMP // Stack delta = +6 // Outputs[10] // { // @1EC4 memory[stack[-4]:stack[-4] + 0x20] = msg.data[stack[-1]:stack[-1] + 0x20] // @1EC8 memory[stack[-3]:stack[-3] + 0x20] = 0x02 // @1ECE stack[0] = stack[-4] // @1ECE stack[-4] = memory[stack[-2]:stack[-2] + 0x20] // @1ED0 stack[-1] = memory[stack[-2]:stack[-2] + 0x20] // @1ED0 stack[1] = keccak256(memory[stack[-4]:stack[-4] + stack[-2]]) // @1ED4 stack[3] = stack[-4] // @1ED4 stack[2] = storage[keccak256(memory[stack[-4]:stack[-4] + stack[-2]])] // @1ED5 stack[4] = 0x1edd // @1ED8 stack[5] = storage[keccak256(memory[stack[-4]:stack[-4] + stack[-2]])] // } // Block ends with call to 0x2850, returns to 0x1EDD label_1EDD: // Incoming return from call to 0x2850 at 0x1EDC // Inputs[5] // { // @1EDE stack[-1] // @1EDE stack[-4] // @1EE0 stack[-6] // @1EE4 stack[-3] // @1EE5 stack[-8] // } 1EDD 5B JUMPDEST 1EDE 92 SWAP3 1EDF 83 DUP4 1EE0 86 DUP7 1EE1 52 MSTORE 1EE2 60 PUSH1 0x01 1EE4 92 SWAP3 1EE5 88 DUP9 1EE6 84 DUP5 1EE7 82 DUP3 1EE8 16 AND 1EE9 91 SWAP2 1EEA 82 DUP3 1EEB 60 PUSH1 0x00 1EED 14 EQ 1EEE 61 PUSH2 0x1f4b 1EF1 57 *JUMPI // Stack delta = +3 // Outputs[7] // { // @1EDE stack[-4] = stack[-1] // @1EDE stack[-1] = stack[-4] // @1EE1 memory[stack[-6]:stack[-6] + 0x20] = stack[-1] // @1EE4 stack[-3] = 0x01 // @1EE5 stack[1] = stack[-8] // @1EE9 stack[0] = stack[-3] & 0x01 // @1EE9 stack[2] = stack[-3] // } // Block ends with conditional jump to 0x1f4b, if 0x00 == stack[-3] & 0x01 label_1EF2: // Incoming jump from 0x1EF1, if not 0x00 == stack[-3] & 0x01 // Inputs[1] { @1EF6 stack[-3] } 1EF2 50 POP 1EF3 50 POP 1EF4 60 PUSH1 0x01 1EF6 14 EQ 1EF7 61 PUSH2 0x1f0d 1EFA 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x1f0d, if 0x01 == stack[-3] label_1EFB: // Incoming jump from 0x1EFA, if not 0x01 == stack[-3] // Incoming jump from 0x1F92 // Incoming jump from 0x1F32 // Inputs[4] // { // @1EFC stack[-6] // @1EFD stack[-8] // @1F01 stack[-7] // @1F06 stack[-5] // } 1EFB 5B JUMPDEST 1EFC 85 DUP6 1EFD 88 DUP9 1EFE 61 PUSH2 0x0ec8 1F01 89 DUP10 1F02 61 PUSH2 0x102f 1F05 84 DUP5 1F06 8A DUP11 1F07 03 SUB 1F08 85 DUP6 1F09 61 PUSH2 0x226a 1F0C 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @1EFC stack[0] = stack[-6] // @1EFD stack[1] = stack[-8] // @1EFE stack[2] = 0x0ec8 // @1F01 stack[3] = stack[-7] // @1F02 stack[4] = 0x102f // @1F07 stack[5] = stack[-5] - stack[-6] // @1F08 stack[6] = stack[-6] // } // Block ends with call to 0x226a, returns to 0x102F label_1F0D: // Incoming jump from 0x1EFA, if 0x01 == stack[-3] // Inputs[7] // { // @1F0E stack[-8] // @1F0F stack[-5] // @1F11 stack[-2] // @1F12 stack[-4] // @1F13 stack[-3] // @1F15 stack[-1] // @1F18 memory[stack[-2]:stack[-2] + stack[-8]] // } 1F0D 5B JUMPDEST 1F0E 87 DUP8 1F0F 94 SWAP5 1F10 50 POP 1F11 81 DUP2 1F12 93 SWAP4 1F13 92 SWAP3 1F14 91 SWAP2 1F15 52 MSTORE 1F16 83 DUP4 1F17 83 DUP4 1F18 20 SHA3 1F19 5B JUMPDEST 1F1A 82 DUP3 1F1B 84 DUP5 1F1C 10 LT 1F1D 61 PUSH2 0x1f33 1F20 57 *JUMPI // Stack delta = +0 // Outputs[6] // { // @1F0F stack[-5] = stack[-8] // @1F12 stack[-4] = stack[-2] // @1F13 stack[-3] = stack[-4] // @1F14 stack[-2] = stack[-3] // @1F15 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @1F18 stack[-1] = keccak256(memory[stack[-2]:stack[-2] + stack[-8]]) // } // Block ends with conditional jump to 0x1f33, if stack[-2] < stack[-4] label_1F21: // Incoming jump from 0x1F20, if not stack[-2] < stack[-4] // Incoming jump from 0x1F20, if not stack[-4] < stack[-3] // Inputs[4] // { // @1F24 stack[-6] // @1F25 stack[-4] // @1F26 stack[-5] // @1F2E code.length // } 1F21 50 POP 1F22 50 POP 1F23 50 POP 1F24 82 DUP3 1F25 01 ADD 1F26 01 ADD 1F27 81 DUP2 1F28 61 PUSH2 0x102f 1F2B 61 PUSH2 0x0ec8 1F2E 38 CODESIZE 1F2F 61 PUSH2 0x1efb 1F32 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @1F26 stack[-5] = stack[-6] + stack[-4] + stack[-5] // @1F27 stack[-4] = stack[-6] // @1F28 stack[-3] = 0x102f // @1F2B stack[-2] = 0x0ec8 // @1F2E stack[-1] = code.length // } // Block ends with unconditional jump to 0x1efb label_1F33: // Incoming jump from 0x1F20, if stack[-2] < stack[-4] // Incoming jump from 0x1F20, if stack[-4] < stack[-3] // Inputs[8] // { // @1F34 stack[-1] // @1F35 storage[stack[-1]] // @1F36 stack[-4] // @1F37 stack[-9] // @1F39 stack[-5] // @1F3D stack[-6] // @1F3F stack[-8] // @1F45 stack[-2] // } 1F33 5B JUMPDEST 1F34 80 DUP1 1F35 54 SLOAD 1F36 84 DUP5 1F37 8A DUP11 1F38 01 ADD 1F39 86 DUP7 1F3A 01 ADD 1F3B 52 MSTORE 1F3C 88 DUP9 1F3D 95 SWAP6 1F3E 50 POP 1F3F 87 DUP8 1F40 94 SWAP5 1F41 90 SWAP1 1F42 93 SWAP4 1F43 01 ADD 1F44 92 SWAP3 1F45 81 DUP2 1F46 01 ADD 1F47 61 PUSH2 0x1f19 1F4A 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @1F3B memory[stack[-5] + stack[-9] + stack[-4]:stack[-5] + stack[-9] + stack[-4] + 0x20] = storage[stack[-1]] // @1F3D stack[-6] = stack[-9] // @1F40 stack[-5] = stack[-8] // @1F44 stack[-4] = stack[-4] + stack[-5] // @1F46 stack[-1] = stack[-2] + stack[-1] // } // Block ends with unconditional jump to 0x1f19 label_1F4B: // Incoming jump from 0x1EF1, if 0x00 == stack[-3] & 0x01 // Inputs[10] // { // @1F6D stack[-1] // @1F6E stack[-9] // @1F6F stack[-2] // @1F72 stack[-7] // @1F7A stack[-3] // @1F7D stack[-8] // @1F85 stack[-6] // @1F8A stack[-5] // @1F8C code.length // @1F8D stack[-4] // } 1F4B 5B JUMPDEST 1F4C 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 1F6D 16 AND 1F6E 88 DUP9 1F6F 82 DUP3 1F70 01 ADD 1F71 52 MSTORE 1F72 94 SWAP5 1F73 15 ISZERO 1F74 15 ISZERO 1F75 60 PUSH1 0x05 1F77 1B SHL 1F78 87 DUP8 1F79 01 ADD 1F7A 90 SWAP1 1F7B 94 SWAP5 1F7C 01 ADD 1F7D 94 SWAP5 1F7E 50 POP 1F7F 85 DUP6 1F80 93 SWAP4 1F81 50 POP 1F82 61 PUSH2 0x102f 1F85 92 SWAP3 1F86 50 POP 1F87 61 PUSH2 0x0ec8 1F8A 91 SWAP2 1F8B 50 POP 1F8C 38 CODESIZE 1F8D 90 SWAP1 1F8E 50 POP 1F8F 61 PUSH2 0x1efb 1F92 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @1F71 memory[stack[-2] + stack[-9]:stack[-2] + stack[-9] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & stack[-1] // @1F7D stack[-8] = stack[-2] + stack[-9] + (!!stack[-7] << 0x05) // @1F80 stack[-7] = stack[-9] // @1F85 stack[-6] = 0x102f // @1F8A stack[-5] = 0x0ec8 // @1F8D stack[-4] = code.length // } // Block ends with unconditional jump to 0x1efb label_1F93: // Incoming jump from 0x003E, if 0x06fdde03 == stack[-2] // Inputs[1] { @1F96 msg.value } 1F93 5B JUMPDEST 1F94 50 POP 1F95 50 POP 1F96 34 CALLVALUE 1F97 61 PUSH2 0x0172 1F9A 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0172, if msg.value label_1F9B: // Incoming jump from 0x1F9A, if not msg.value // Inputs[2] // { // @1F9B stack[-2] // @1F9F msg.data.length // } 1F9B 81 DUP2 1F9C 60 PUSH1 0x03 1F9E 19 NOT 1F9F 36 CALLDATASIZE 1FA0 01 ADD 1FA1 12 SLT 1FA2 61 PUSH2 0x0172 1FA5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0172, if msg.data.length + ~0x03 i< stack[-2] label_1FA6: // Incoming jump from 0x1FA5, if not msg.data.length + ~0x03 i< stack[-2] // Inputs[2] // { // @1FA6 stack[-1] // @1FA7 memory[stack[-1]:stack[-1] + 0x20] // } 1FA6 80 DUP1 1FA7 51 MLOAD 1FA8 61 PUSH2 0x0ec8 1FAB 91 SWAP2 1FAC 61 PUSH2 0x1fb4 1FAF 82 DUP3 1FB0 61 PUSH2 0x2203 1FB3 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1FA7 stack[0] = memory[stack[-1]:stack[-1] + 0x20] // @1FAB stack[1] = stack[-1] // @1FAB stack[-1] = 0x0ec8 // @1FAC stack[2] = 0x1fb4 // @1FAF stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x2203, returns to 0x1FB4 label_1FB4: // Incoming return from call to 0x2203 at 0x1FB3 // Inputs[4] // { // @1FB7 stack[-2] // @1FDF memory[stack[-1]:stack[-1] + 0x20] // @1FDF stack[-1] // @1FE0 stack[-3] // } 1FB4 5B JUMPDEST 1FB5 60 PUSH1 0x09 1FB7 82 DUP3 1FB8 52 MSTORE 1FB9 7F PUSH32 0x4269645469636b65740000000000000000000000000000000000000000000000 1FDA 60 PUSH1 0x20 1FDC 83 DUP4 1FDD 01 ADD 1FDE 52 MSTORE 1FDF 51 MLOAD 1FE0 91 SWAP2 1FE1 82 DUP3 1FE2 91 SWAP2 1FE3 60 PUSH1 0x20 1FE5 83 DUP4 1FE6 52 MSTORE 1FE7 60 PUSH1 0x20 1FE9 83 DUP4 1FEA 01 ADD 1FEB 90 SWAP1 1FEC 61 PUSH2 0x213d 1FEF 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @1FB8 memory[stack[-2]:stack[-2] + 0x20] = 0x09 // @1FDE memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = 0x4269645469636b65740000000000000000000000000000000000000000000000 // @1FE0 stack[-1] = stack[-3] // @1FE0 stack[-3] = memory[stack[-1]:stack[-1] + 0x20] // @1FE2 stack[-2] = memory[stack[-1]:stack[-1] + 0x20] // @1FE6 memory[memory[stack[-1]:stack[-1] + 0x20]:memory[stack[-1]:stack[-1] + 0x20] + 0x20] = 0x20 // @1FEB stack[1] = stack[-2] // @1FEB stack[0] = memory[stack[-1]:stack[-1] + 0x20] + 0x20 // } // Block ends with unconditional jump to 0x213d label_1FF0: // Incoming jump from 0x0033, if 0x01ffc9a7 == stack[-2] // Inputs[3] // { // @1FF1 stack[-2] // @1FF1 stack[-1] // @1FF3 msg.value // } 1FF0 5B JUMPDEST 1FF1 90 SWAP1 1FF2 50 POP 1FF3 34 CALLVALUE 1FF4 61 PUSH2 0x079a 1FF7 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1FF1 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x079a, if msg.value label_1FF8: // Incoming jump from 0x1FF7, if not msg.value // Inputs[1] { @1FFD msg.data.length } 1FF8 60 PUSH1 0x20 1FFA 60 PUSH1 0x03 1FFC 19 NOT 1FFD 36 CALLDATASIZE 1FFE 01 ADD 1FFF 12 SLT 2000 61 PUSH2 0x079a 2003 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x079a, if msg.data.length + ~0x03 i< 0x20 label_2004: // Incoming jump from 0x2003, if not msg.data.length + ~0x03 i< 0x20 // Inputs[3] // { // @2004 msg.data[stack[-1]:stack[-1] + 0x20] // @2004 stack[-1] // @2005 stack[-2] // } 2004 35 CALLDATALOAD 2005 90 SWAP1 2006 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 2027 82 DUP3 2028 16 AND 2029 80 DUP1 202A 92 SWAP3 202B 03 SUB 202C 61 PUSH2 0x079a 202F 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2005 stack[-1] = stack[-2] // @202A stack[-2] = msg.data[stack[-1]:stack[-1] + 0x20] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // } // Block ends with conditional jump to 0x079a, if msg.data[stack[-1]:stack[-1] + 0x20] - (msg.data[stack[-1]:stack[-1] + 0x20] & 0xffffffff00000000000000000000000000000000000000000000000000000000) label_2030: // Incoming jump from 0x202F, if not msg.data[stack[-1]:stack[-1] + 0x20] - (msg.data[stack[-1]:stack[-1] + 0x20] & 0xffffffff00000000000000000000000000000000000000000000000000000000) // Inputs[2] // { // @2032 stack[-3] // @2055 stack[-2] // } 2030 60 PUSH1 0x20 2032 92 SWAP3 2033 50 POP 2034 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 2055 82 DUP3 2056 14 EQ 2057 91 SWAP2 2058 82 DUP3 2059 15 ISZERO 205A 61 PUSH2 0x2098 205D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2032 stack[-3] = 0x20 // @2057 stack[-2] = stack[-2] == 0x01ffc9a700000000000000000000000000000000000000000000000000000000 // @2057 stack[0] = stack[-2] // } // Block ends with conditional jump to 0x2098, if !(stack[-2] == 0x01ffc9a700000000000000000000000000000000000000000000000000000000) label_205E: // Incoming jump from 0x20C1 // Incoming jump from 0x205D, if not !(stack[-2] == 0x01ffc9a700000000000000000000000000000000000000000000000000000000) // Inputs[1] { @205F stack[-3] } 205E 5B JUMPDEST 205F 82 DUP3 2060 15 ISZERO 2061 61 PUSH2 0x206e 2064 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x206e, if !stack[-3] label_2065: // Incoming jump from 0x2097 // Incoming jump from 0x2064, if not !stack[-3] // Inputs[5] // { // @2067 memory[stack[-2]:stack[-2] + 0x20] // @2067 stack[-2] // @2068 stack[-3] // @206D stack[-4] // @206D memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + stack[-4]] // } 2065 5B JUMPDEST 2066 50 POP 2067 51 MLOAD 2068 90 SWAP1 2069 15 ISZERO 206A 15 ISZERO 206B 81 DUP2 206C 52 MSTORE 206D F3 *RETURN // Stack delta = -4 // Outputs[2] // { // @206C memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + 0x20] = !!stack[-3] // @206D return memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + stack[-4]]; // } // Block terminates label_206E: // Incoming jump from 0x2064, if !stack[-3] // Inputs[3] // { // @2090 stack[-1] // @2091 stack[-3] // @2093 code.length // } 206E 5B JUMPDEST 206F 7F PUSH32 0x0e89341c00000000000000000000000000000000000000000000000000000000 2090 14 EQ 2091 91 SWAP2 2092 50 POP 2093 38 CODESIZE 2094 61 PUSH2 0x2065 2097 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2091 stack[-3] = 0x0e89341c00000000000000000000000000000000000000000000000000000000 == stack[-1] // @2093 stack[-1] = code.length // } // Block ends with unconditional jump to 0x2065 label_2098: // Incoming jump from 0x205D, if !(stack[-2] == 0x01ffc9a700000000000000000000000000000000000000000000000000000000) // Inputs[2] // { // @20BA stack[-1] // @20BC stack[-3] // } 2098 5B JUMPDEST 2099 7F PUSH32 0xd9b67a2600000000000000000000000000000000000000000000000000000000 20BA 81 DUP2 20BB 14 EQ 20BC 92 SWAP3 20BD 50 POP 20BE 61 PUSH2 0x205e 20C1 56 *JUMP // Stack delta = +0 // Outputs[1] { @20BC stack[-3] = stack[-1] == 0xd9b67a2600000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to 0x205e label_20C2: // Incoming jump from 0x0028, if 0xfdd58e == msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @20C5 msg.value } 20C2 5B JUMPDEST 20C3 50 POP 20C4 50 POP 20C5 34 CALLVALUE 20C6 61 PUSH2 0x0172 20C9 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0172, if msg.value label_20CA: // Incoming jump from 0x20C9, if not msg.value // Inputs[2] // { // @20CA stack[-1] // @20CE msg.data.length // } 20CA 80 DUP1 20CB 60 PUSH1 0x03 20CD 19 NOT 20CE 36 CALLDATASIZE 20CF 01 ADD 20D0 12 SLT 20D1 61 PUSH2 0x0172 20D4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0172, if msg.data.length + ~0x03 i< stack[-1] label_20D5: // Incoming jump from 0x20D4, if not msg.data.length + ~0x03 i< stack[-1] // Inputs[1] { @20D7 stack[-1] } 20D5 60 PUSH1 0x20 20D7 90 SWAP1 20D8 61 PUSH2 0x20eb 20DB 61 PUSH2 0x20e2 20DE 61 PUSH2 0x20f2 20E1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @20D7 stack[0] = stack[-1] // @20D7 stack[-1] = 0x20 // @20D8 stack[1] = 0x20eb // @20DB stack[2] = 0x20e2 // } // Block ends with call to 0x20f2, returns to 0x20E2 label_20E2: // Incoming return from call to 0x20F2 at 0x20E1 // Inputs[2] // { // @20E5 msg.data[0x24:0x44] // @20E6 stack[-1] // } 20E2 5B JUMPDEST 20E3 60 PUSH1 0x24 20E5 35 CALLDATALOAD 20E6 90 SWAP1 20E7 61 PUSH2 0x2399 20EA 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @20E6 stack[0] = stack[-1] // @20E6 stack[-1] = msg.data[0x24:0x44] // } // Block ends with unconditional jump to 0x2399 label_20EB: // Incoming return from call to 0x20E2 at 0x20E1 // Inputs[5] // { // @20EC stack[-2] // @20EC stack[-1] // @20ED memory[stack[-2]:stack[-2] + 0x20] // @20F1 stack[-3] // @20F1 memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + stack[-3]] // } 20EB 5B JUMPDEST 20EC 90 SWAP1 20ED 51 MLOAD 20EE 90 SWAP1 20EF 81 DUP2 20F0 52 MSTORE 20F1 F3 *RETURN // Stack delta = -3 // Outputs[2] // { // @20F0 memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + 0x20] = stack[-1] // @20F1 return memory[memory[stack[-2]:stack[-2] + 0x20]:memory[stack[-2]:stack[-2] + 0x20] + stack[-3]]; // } // Block terminates label_20F2: // Incoming call from 0x038D, returns to 0x038E // Incoming call from 0x0DD2, returns to 0x0DD3 // Incoming call from 0x0E34, returns to 0x0E35 // Incoming call from 0x07B2, returns to 0x07B3 // Incoming call from 0x015B, returns to 0x015C // Incoming call from 0x20E1, returns to 0x20E2 // Incoming call from 0x040E, returns to 0x040F // Incoming call from 0x16E8, returns to 0x16E9 // Incoming call from 0x0D21, returns to 0x0D22 // Incoming call from 0x084D, returns to 0x084E // Inputs[2] // { // @20F5 msg.data[0x04:0x24] // @20F6 stack[-1] // } 20F2 5B JUMPDEST 20F3 60 PUSH1 0x04 20F5 35 CALLDATALOAD 20F6 90 SWAP1 20F7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 210C 82 DUP3 210D 16 AND 210E 82 DUP3 210F 03 SUB 2110 61 PUSH2 0x2115 2113 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @20F6 stack[0] = stack[-1] // @20F6 stack[-1] = msg.data[0x04:0x24] // } // Block ends with conditional jump to 0x2115, if msg.data[0x04:0x24] - (msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff) label_2114: // Incoming jump from 0x2113, if not msg.data[0x04:0x24] - (msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[1] { @2114 stack[-1] } 2114 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_2115: // Incoming jump from 0x2339, if stack[-1] + ~0x03 i< 0x60 // Incoming jump from 0x2318, if stack[-2] + stack[-3] + 0x20 > stack[-1] // Incoming jump from 0x24C0, if memory[stack[-1]:stack[-1] + 0x20] - (memory[stack[-1]:stack[-1] + 0x20] & 0xffffffff00000000000000000000000000000000000000000000000000000000) // Incoming jump from 0x2496, if stack[-2] - stack[-1] i< 0x20 // Incoming jump from 0x21DE, if !(stack[-1] + 0x1f i< stack[-2]) // Incoming jump from 0x22F0, if !(stack[-1] + 0x1f i< stack[-2]) // Incoming jump from 0x21F0, if msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff // Incoming jump from 0x2113, if msg.data[0x04:0x24] - (msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff) // Incoming jump from 0x2389, if msg.data[0x44:0x64] > stack[-5] // Incoming jump from 0x236E, if msg.data[0x24:0x44] > 0xffffffffffffffff // Incoming jump from 0x2201, if (stack[-3] << 0x05) + stack[-4] + 0x20 > stack[-1] // Incoming jump from 0x2359, if msg.data[0x04:0x24] - (msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff) // Incoming jump from 0x213B, if msg.data[0x24:0x44] - (msg.data[0x24:0x44] & 0xffffffffffffffffffffffffffffffffffffffff) // Incoming jump from 0x26B6, if stack[-2] > 0x07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // Incoming jump from 0x21A7, if stack[-1] + ~0x03 i< 0x60 // Incoming jump from 0x21C7, if msg.data[0x04:0x24] - (msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[1] { @2119 memory[0x00:0x00] } 2115 5B JUMPDEST 2116 60 PUSH1 0x00 2118 80 DUP1 2119 FD *REVERT // Stack delta = +0 // Outputs[1] { @2119 revert(memory[0x00:0x00]); } // Block terminates label_211A: // Incoming call from 0x0417, returns to 0x0418 // Incoming call from 0x16F1, returns to 0x16F2 // Incoming call from 0x0855, returns to 0x0856 // Inputs[2] // { // @211D msg.data[0x24:0x44] // @211E stack[-1] // } 211A 5B JUMPDEST 211B 60 PUSH1 0x24 211D 35 CALLDATALOAD 211E 90 SWAP1 211F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2134 82 DUP3 2135 16 AND 2136 82 DUP3 2137 03 SUB 2138 61 PUSH2 0x2115 213B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @211E stack[0] = stack[-1] // @211E stack[-1] = msg.data[0x24:0x44] // } // Block ends with conditional jump to 0x2115, if msg.data[0x24:0x44] - (msg.data[0x24:0x44] & 0xffffffffffffffffffffffffffffffffffffffff) label_213C: // Incoming jump from 0x213B, if not msg.data[0x24:0x44] - (msg.data[0x24:0x44] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[1] { @213C stack[-1] } 213C 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_213D: // Incoming call from 0x2810, returns to 0x2811 // Incoming call from 0x2567, returns to 0x2568 // Incoming call from 0x2689, returns to 0x2568 // Incoming call from 0x2744, returns to 0x2745 // Incoming jump from 0x1FEF // Incoming jump from 0x0EC7 // Incoming jump from 0x103D // Inputs[4] // { // @213E stack[-3] // @213E stack[-1] // @213F stack[-2] // @2141 memory[stack[-1]:stack[-1] + 0x20] // } 213D 5B JUMPDEST 213E 91 SWAP2 213F 90 SWAP1 2140 82 DUP3 2141 51 MLOAD 2142 92 SWAP3 2143 83 DUP4 2144 82 DUP3 2145 52 MSTORE 2146 60 PUSH1 0x00 2148 5B JUMPDEST 2149 84 DUP5 214A 81 DUP2 214B 10 LT 214C 61 PUSH2 0x2187 214F 57 *JUMPI // Stack delta = +2 // Outputs[6] // { // @213F stack[-1] = stack[-2] // @213F stack[-2] = stack[-3] // @2142 stack[0] = stack[-1] // @2142 stack[-3] = memory[stack[-1]:stack[-1] + 0x20] // @2145 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @2146 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2187, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] label_2150: // Incoming jump from 0x214F, if not 0x00 < memory[stack[-1]:stack[-1] + 0x20] // Incoming jump from 0x214F, if not stack[-1] < stack[-5] // Inputs[3] // { // @2175 stack[-5] // @217B stack[-4] // @217D stack[-3] // } 2150 50 POP 2151 50 POP 2152 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 2173 60 PUSH1 0x1f 2175 84 DUP5 2176 60 PUSH1 0x00 2178 60 PUSH1 0x20 217A 80 DUP1 217B 96 SWAP7 217C 97 SWAP8 217D 86 DUP7 217E 01 ADD 217F 01 ADD 2180 52 MSTORE 2181 01 ADD 2182 16 AND 2183 01 ADD 2184 01 ADD 2185 90 SWAP1 2186 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2180 memory[stack[-3] + stack[-5] + 0x20:stack[-3] + stack[-5] + 0x20 + 0x20] = 0x00 // @2185 stack[-5] = (stack[-5] + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + stack[-3] + 0x20 // } // Block ends with unconditional jump to stack[-4] label_2187: // Incoming jump from 0x214F, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] // Incoming jump from 0x214F, if stack[-1] < stack[-5] // Inputs[4] // { // @218A stack[-1] // @218B stack[-2] // @218F memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @2190 stack[-3] // } 2187 5B JUMPDEST 2188 60 PUSH1 0x20 218A 81 DUP2 218B 83 DUP4 218C 01 ADD 218D 81 DUP2 218E 01 ADD 218F 51 MLOAD 2190 84 DUP5 2191 83 DUP4 2192 01 ADD 2193 82 DUP3 2194 01 ADD 2195 52 MSTORE 2196 01 ADD 2197 61 PUSH2 0x2148 219A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2195 memory[0x20 + stack[-1] + stack[-3]:0x20 + stack[-1] + stack[-3] + 0x20] = memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @2196 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x2148 label_219B: // Incoming call from 0x1B6C, returns to 0x1B6D // Incoming call from 0x0185, returns to 0x0186 // Inputs[1] { @21A1 stack[-1] } 219B 5B JUMPDEST 219C 60 PUSH1 0x03 219E 19 NOT 219F 60 PUSH1 0x60 21A1 91 SWAP2 21A2 01 ADD 21A3 12 SLT 21A4 61 PUSH2 0x2115 21A7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2115, if stack[-1] + ~0x03 i< 0x60 label_21A8: // Incoming jump from 0x21A7, if not stack[-1] + ~0x03 i< 0x60 // Inputs[1] { @21AA msg.data[0x04:0x24] } 21A8 60 PUSH1 0x04 21AA 35 CALLDATALOAD 21AB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21C0 81 DUP2 21C1 16 AND 21C2 81 DUP2 21C3 03 SUB 21C4 61 PUSH2 0x2115 21C7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @21AA stack[0] = msg.data[0x04:0x24] } // Block ends with conditional jump to 0x2115, if msg.data[0x04:0x24] - (msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff) label_21C8: // Incoming jump from 0x21C7, if not msg.data[0x04:0x24] - (msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[4] // { // @21C8 stack[-1] // @21C8 stack[-2] // @21CB msg.data[0x24:0x44] // @21CF msg.data[0x44:0x64] // } 21C8 90 SWAP1 21C9 60 PUSH1 0x24 21CB 35 CALLDATALOAD 21CC 90 SWAP1 21CD 60 PUSH1 0x44 21CF 35 CALLDATALOAD 21D0 90 SWAP1 21D1 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @21C8 stack[-2] = stack[-1] // @21CC stack[-1] = msg.data[0x24:0x44] // @21D0 stack[0] = msg.data[0x44:0x64] // } // Block ends with unconditional jump to stack[-2] label_21D2: // Incoming call from 0x2394, returns to 0x2395 // Incoming call from 0x1729, returns to 0x172A // Incoming call from 0x237A, returns to 0x237B // Incoming call from 0x1568, returns to 0x1569 // Incoming call from 0x154C, returns to 0x154D // Incoming call from 0x1711, returns to 0x1712 // Inputs[3] // { // @21D3 stack[-3] // @21D3 stack[-1] // @21D4 stack[-2] // } 21D2 5B JUMPDEST 21D3 91 SWAP2 21D4 81 DUP2 21D5 60 PUSH1 0x1f 21D7 84 DUP5 21D8 01 ADD 21D9 12 SLT 21DA 15 ISZERO 21DB 61 PUSH2 0x2115 21DE 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @21D3 stack[-1] = stack[-3] // @21D3 stack[-3] = stack[-1] // } // Block ends with conditional jump to 0x2115, if !(stack[-1] + 0x1f i< stack[-2]) label_21DF: // Incoming jump from 0x21DE, if not !(stack[-1] + 0x1f i< stack[-2]) // Inputs[3] // { // @21DF stack[-3] // @21E0 msg.data[stack[-3]:stack[-3] + 0x20] // @21E1 stack[-2] // } 21DF 82 DUP3 21E0 35 CALLDATALOAD 21E1 91 SWAP2 21E2 67 PUSH8 0xffffffffffffffff 21EB 83 DUP4 21EC 11 GT 21ED 61 PUSH2 0x2115 21F0 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @21E1 stack[0] = stack[-2] // @21E1 stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with conditional jump to 0x2115, if msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff label_21F1: // Incoming jump from 0x21F0, if not msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff // Inputs[3] // { // @21F4 stack[-4] // @21F7 stack[-3] // @21FD stack[-1] // } 21F1 60 PUSH1 0x20 21F3 80 DUP1 21F4 85 DUP6 21F5 01 ADD 21F6 94 SWAP5 21F7 84 DUP5 21F8 60 PUSH1 0x05 21FA 1B SHL 21FB 01 ADD 21FC 01 ADD 21FD 11 GT 21FE 61 PUSH2 0x2115 2201 57 *JUMPI // Stack delta = -1 // Outputs[1] { @21F6 stack[-4] = stack[-4] + 0x20 } // Block ends with conditional jump to 0x2115, if (stack[-3] << 0x05) + stack[-4] + 0x20 > stack[-1] label_2202: // Incoming jump from 0x2201, if not (stack[-3] << 0x05) + stack[-4] + 0x20 > stack[-1] // Inputs[1] { @2202 stack[-1] } 2202 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_2203: // Incoming call from 0x0E8D, returns to 0x0E8E // Incoming call from 0x1FB3, returns to 0x1FB4 // Inputs[1] { @2206 stack[-1] } 2203 5B JUMPDEST 2204 60 PUSH1 0x40 2206 81 DUP2 2207 01 ADD 2208 90 SWAP1 2209 81 DUP2 220A 10 LT 220B 67 PUSH8 0xffffffffffffffff 2214 82 DUP3 2215 11 GT 2216 17 OR 2217 61 PUSH2 0x221f 221A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2208 stack[-1] = stack[-1] + 0x40 } // Block ends with conditional jump to 0x221f, if (stack[-1] + 0x40 > 0xffffffffffffffff) | (stack[-1] + 0x40 < stack[-1]) label_221B: // Incoming jump from 0x221A, if not (stack[-1] + 0x40 > 0xffffffffffffffff) | (stack[-1] + 0x40 < stack[-1]) // Inputs[2] // { // @221D stack[-1] // @221E stack[-2] // } 221B 60 PUSH1 0x40 221D 52 MSTORE 221E 56 *JUMP // Stack delta = -2 // Outputs[1] { @221D memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_221F: // Incoming jump from 0x22A6, if (stack[-1] + (stack[-2] + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < stack[-1]) // Incoming jump from 0x22BA, if stack[-1] > 0xffffffffffffffff // Incoming jump from 0x2443, if stack[-1] > 0xffffffffffffffff // Incoming jump from 0x221A, if (stack[-1] + 0x40 > 0xffffffffffffffff) | (stack[-1] + 0x40 < stack[-1]) // Incoming jump from 0x2265, if (stack[-1] + 0x20 > 0xffffffffffffffff) | (stack[-1] + 0x20 < stack[-1]) // Inputs[1] { @224D memory[0x00:0x24] } 221F 5B JUMPDEST 2220 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 2241 60 PUSH1 0x00 2243 52 MSTORE 2244 60 PUSH1 0x41 2246 60 PUSH1 0x04 2248 52 MSTORE 2249 60 PUSH1 0x24 224B 60 PUSH1 0x00 224D FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2243 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @2248 memory[0x04:0x24] = 0x41 // @224D revert(memory[0x00:0x24]); // } // Block terminates label_224E: // Incoming call from 0x0925, returns to 0x0926 // Incoming call from 0x1B9D, returns to 0x1B9E // Incoming call from 0x01CF, returns to 0x01D0 // Incoming call from 0x1299, returns to 0x129A // Incoming jump from 0x02C9 // Incoming call from 0x1311, returns to 0x02CA // Inputs[1] { @2251 stack[-1] } 224E 5B JUMPDEST 224F 60 PUSH1 0x20 2251 81 DUP2 2252 01 ADD 2253 90 SWAP1 2254 81 DUP2 2255 10 LT 2256 67 PUSH8 0xffffffffffffffff 225F 82 DUP3 2260 11 GT 2261 17 OR 2262 61 PUSH2 0x221f 2265 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2253 stack[-1] = stack[-1] + 0x20 } // Block ends with conditional jump to 0x221f, if (stack[-1] + 0x20 > 0xffffffffffffffff) | (stack[-1] + 0x20 < stack[-1]) label_2266: // Incoming jump from 0x2265, if not (stack[-1] + 0x20 > 0xffffffffffffffff) | (stack[-1] + 0x20 < stack[-1]) // Inputs[2] // { // @2268 stack[-1] // @2269 stack[-2] // } 2266 60 PUSH1 0x40 2268 52 MSTORE 2269 56 *JUMP // Stack delta = -2 // Outputs[1] { @2268 memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_226A: // Incoming call from 0x24E1, returns to 0x24E2 // Incoming call from 0x102E, returns to 0x102F // Incoming call from 0x158D, returns to 0x158E // Incoming call from 0x1F0C, returns to 0x102F // Incoming call from 0x2309, returns to 0x230A // Incoming call from 0x25FB, returns to 0x25FC // Inputs[2] // { // @226B stack[-1] // @226B stack[-2] // } 226A 5B JUMPDEST 226B 90 SWAP1 226C 60 PUSH1 0x1f 226E 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 228F 91 SWAP2 2290 01 ADD 2291 16 AND 2292 81 DUP2 2293 01 ADD 2294 90 SWAP1 2295 81 DUP2 2296 10 LT 2297 67 PUSH8 0xffffffffffffffff 22A0 82 DUP3 22A1 11 GT 22A2 17 OR 22A3 61 PUSH2 0x221f 22A6 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2294 stack[-2] = stack[-1] + (stack[-2] + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) } // Block ends with conditional jump to 0x221f, if (stack[-1] + (stack[-2] + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < stack[-1]) label_22A7: // Incoming jump from 0x22A6, if not (stack[-1] + (stack[-2] + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > 0xffffffffffffffff) | (stack[-1] + (stack[-2] + 0x1f & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < stack[-1]) // Inputs[2] // { // @22A9 stack[-1] // @22AA stack[-2] // } 22A7 60 PUSH1 0x40 22A9 52 MSTORE 22AA 56 *JUMP // Stack delta = -2 // Outputs[1] { @22A9 memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_22AB: // Incoming call from 0x24D3, returns to 0x24D4 // Incoming call from 0x22FB, returns to 0x22FC // Inputs[1] { @22B5 stack[-1] } 22AB 5B JUMPDEST 22AC 67 PUSH8 0xffffffffffffffff 22B5 81 DUP2 22B6 11 GT 22B7 61 PUSH2 0x221f 22BA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x221f, if stack[-1] > 0xffffffffffffffff label_22BB: // Incoming jump from 0x22BA, if not stack[-1] > 0xffffffffffffffff // Inputs[2] // { // @22BD stack[-1] // @22E3 stack[-2] // } 22BB 60 PUSH1 0x1f 22BD 01 ADD 22BE 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 22DF 16 AND 22E0 60 PUSH1 0x20 22E2 01 ADD 22E3 90 SWAP1 22E4 56 *JUMP // Stack delta = -1 // Outputs[1] { @22E3 stack[-2] = 0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & 0x1f + stack[-1]) } // Block ends with unconditional jump to stack[-2] label_22E5: // Incoming call from 0x043D, returns to 0x043E // Incoming call from 0x1743, returns to 0x1744 // Inputs[2] // { // @22E6 stack[-2] // @22E9 stack[-1] // } 22E5 5B JUMPDEST 22E6 81 DUP2 22E7 60 PUSH1 0x1f 22E9 82 DUP3 22EA 01 ADD 22EB 12 SLT 22EC 15 ISZERO 22ED 61 PUSH2 0x2115 22F0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2115, if !(stack[-1] + 0x1f i< stack[-2]) label_22F1: // Incoming jump from 0x22F0, if not !(stack[-1] + 0x1f i< stack[-2]) // Inputs[2] // { // @22F1 stack[-1] // @22F2 msg.data[stack[-1]:stack[-1] + 0x20] // } 22F1 80 DUP1 22F2 35 CALLDATALOAD 22F3 90 SWAP1 22F4 61 PUSH2 0x22fc 22F7 82 DUP3 22F8 61 PUSH2 0x22ab 22FB 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @22F3 stack[0] = stack[-1] // @22F3 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @22F4 stack[1] = 0x22fc // @22F7 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x22ab, returns to 0x22FC label_22FC: // Incoming return from call to 0x22AB at 0x22FB // Inputs[3] // { // @22FD stack[-4] // @22FD stack[-1] // @2303 memory[0x40:0x60] // } 22FC 5B JUMPDEST 22FD 92 SWAP3 22FE 61 PUSH2 0x230a 2301 60 PUSH1 0x40 2303 51 MLOAD 2304 94 SWAP5 2305 85 DUP6 2306 61 PUSH2 0x226a 2309 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @22FD stack[-1] = stack[-4] // @22FE stack[0] = 0x230a // @2304 stack[-4] = memory[0x40:0x60] // @2304 stack[1] = stack[-1] // @2305 stack[2] = memory[0x40:0x60] // } // Block ends with call to 0x226a, returns to 0x230A label_230A: // Incoming return from call to 0x226A at 0x2309 // Inputs[4] // { // @230B stack[-3] // @230C stack[-4] // @2311 stack[-2] // @2314 stack[-1] // } 230A 5B JUMPDEST 230B 82 DUP3 230C 84 DUP5 230D 52 MSTORE 230E 60 PUSH1 0x20 2310 83 DUP4 2311 83 DUP4 2312 01 ADD 2313 01 ADD 2314 11 GT 2315 61 PUSH2 0x2115 2318 57 *JUMPI // Stack delta = -1 // Outputs[1] { @230D memory[stack[-4]:stack[-4] + 0x20] = stack[-3] } // Block ends with conditional jump to 0x2115, if stack[-2] + stack[-3] + 0x20 > stack[-1] label_2319: // Incoming jump from 0x2318, if not stack[-2] + stack[-3] + 0x20 > stack[-1] // Inputs[5] // { // @2319 stack[-2] // @2320 stack[-1] // @2323 stack[-3] // @2325 msg.data[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-2]] // @232A stack[-4] // } 2319 81 DUP2 231A 60 PUSH1 0x00 231C 92 SWAP3 231D 60 PUSH1 0x20 231F 80 DUP1 2320 93 SWAP4 2321 01 ADD 2322 83 DUP4 2323 86 DUP7 2324 01 ADD 2325 37 CALLDATACOPY 2326 83 DUP4 2327 01 ADD 2328 01 ADD 2329 52 MSTORE 232A 90 SWAP1 232B 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @2325 memory[stack[-3] + 0x20:stack[-3] + 0x20 + stack[-2]] = msg.data[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-2]] // @2329 memory[stack[-3] + stack[-2] + 0x20:stack[-3] + stack[-2] + 0x20 + 0x20] = 0x00 // @232A stack[-4] = stack[-3] // } // Block ends with unconditional jump to stack[-4] label_232C: // Incoming call from 0x08F1, returns to 0x08F2 // Incoming call from 0x1258, returns to 0x1259 // Inputs[2] // { // @232D stack[-2] // @232D stack[-1] // } 232C 5B JUMPDEST 232D 90 SWAP1 232E 60 PUSH1 0x60 2330 60 PUSH1 0x03 2332 19 NOT 2333 83 DUP4 2334 01 ADD 2335 12 SLT 2336 61 PUSH2 0x2115 2339 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @232D stack[-1] = stack[-2] // @232D stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x2115, if stack[-1] + ~0x03 i< 0x60 label_233A: // Incoming jump from 0x2339, if not stack[-1] + ~0x03 i< 0x60 // Inputs[1] { @233C msg.data[0x04:0x24] } 233A 60 PUSH1 0x04 233C 35 CALLDATALOAD 233D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2352 81 DUP2 2353 16 AND 2354 81 DUP2 2355 03 SUB 2356 61 PUSH2 0x2115 2359 57 *JUMPI // Stack delta = +1 // Outputs[1] { @233C stack[0] = msg.data[0x04:0x24] } // Block ends with conditional jump to 0x2115, if msg.data[0x04:0x24] - (msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff) label_235A: // Incoming jump from 0x2359, if not msg.data[0x04:0x24] - (msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[4] // { // @235A stack[-1] // @235A stack[-3] // @2364 stack[-2] // @2367 msg.data[0x24:0x44] // } 235A 91 SWAP2 235B 67 PUSH8 0xffffffffffffffff 2364 91 SWAP2 2365 60 PUSH1 0x24 2367 35 CALLDATALOAD 2368 83 DUP4 2369 81 DUP2 236A 11 GT 236B 61 PUSH2 0x2115 236E 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @235A stack[-3] = stack[-1] // @235A stack[-1] = stack[-3] // @2364 stack[-2] = 0xffffffffffffffff // @2364 stack[0] = stack[-2] // @2367 stack[1] = msg.data[0x24:0x44] // } // Block ends with conditional jump to 0x2115, if msg.data[0x24:0x44] > 0xffffffffffffffff label_236F: // Incoming jump from 0x236E, if not msg.data[0x24:0x44] > 0xffffffffffffffff // Inputs[2] // { // @236F stack[-3] // @2373 stack[-1] // } 236F 82 DUP3 2370 61 PUSH2 0x237b 2373 91 SWAP2 2374 60 PUSH1 0x04 2376 01 ADD 2377 61 PUSH2 0x21d2 237A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @236F stack[0] = stack[-3] // @2373 stack[-1] = 0x237b // @2376 stack[1] = 0x04 + stack[-1] // } // Block ends with call to 0x21d2, returns to 0x237B label_237B: // Incoming return from call to 0x21D2 at 0x237A // Inputs[5] // { // @237C stack[-1] // @237C stack[-5] // @237D stack[-2] // @237F stack[-4] // @2382 msg.data[0x44:0x64] // } 237B 5B JUMPDEST 237C 93 SWAP4 237D 90 SWAP1 237E 93 SWAP4 237F 92 SWAP3 2380 60 PUSH1 0x44 2382 35 CALLDATALOAD 2383 91 SWAP2 2384 82 DUP3 2385 11 GT 2386 61 PUSH2 0x2115 2389 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @237E stack[-5] = stack[-2] // @237F stack[-1] = stack[-4] // @237F stack[-4] = stack[-1] // @2383 stack[-2] = msg.data[0x44:0x64] // } // Block ends with conditional jump to 0x2115, if msg.data[0x44:0x64] > stack[-5] label_238A: // Incoming jump from 0x2389, if not msg.data[0x44:0x64] > stack[-5] // Inputs[1] { @238D stack[-2] } 238A 61 PUSH2 0x2395 238D 91 SWAP2 238E 60 PUSH1 0x04 2390 01 ADD 2391 61 PUSH2 0x21d2 2394 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @238D stack[-2] = 0x2395 // @2390 stack[0] = 0x04 + stack[-2] // } // Block ends with call to 0x21d2, returns to 0x2395 label_2395: // Incoming return from call to 0x21D2 at 0x2394 // Inputs[3] // { // @2396 stack[-1] // @2396 stack[-2] // @2397 stack[-3] // } 2395 5B JUMPDEST 2396 90 SWAP1 2397 91 SWAP2 2398 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2396 stack[-2] = stack[-1] // @2397 stack[-3] = stack[-2] // } // Block ends with unconditional jump to stack[-3] label_2399: // Incoming jump from 0x1656 // Incoming jump from 0x20EA // Inputs[2] // { // @239A stack[-1] // @239A stack[-2] // } 2399 5B JUMPDEST 239A 90 SWAP1 239B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 23B0 82 DUP3 23B1 16 AND 23B2 15 ISZERO 23B3 61 PUSH2 0x240a 23B6 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @239A stack[-1] = stack[-2] // @239A stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x240a, if !(stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff) label_23B7: // Incoming jump from 0x23B6, if not !(stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[4] // { // @23BA stack[-2] // @23BB stack[-1] // @2400 memory[0x00:0x20] // @2401 storage[keccak256(memory[0x00:0x20])] // } 23B7 61 PUSH2 0x2407 23BA 91 SWAP2 23BB 90 SWAP1 23BC 60 PUSH1 0xe0 23BE 91 SWAP2 23BF 7F PUSH32 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000 23E0 82 DUP3 23E1 60 PUSH1 0x03 23E3 1C SHR 23E4 91 SWAP2 23E5 60 PUSH1 0x5c 23E7 1B SHL 23E8 16 AND 23E9 17 OR 23EA 60 PUSH1 0x07 23EC 60 PUSH1 0xfd 23EE 1B SHL 23EF 17 OR 23F0 60 PUSH1 0x00 23F2 52 MSTORE 23F3 60 PUSH1 0x05 23F5 1B SHL 23F6 16 AND 23F7 61 PUSH2 0xffff 23FA 81 DUP2 23FB 1B SHL 23FC 60 PUSH1 0x20 23FE 60 PUSH1 0x00 2400 20 SHA3 2401 54 SLOAD 2402 16 AND 2403 90 SWAP1 2404 1C SHR 2405 90 SWAP1 2406 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @23F2 memory[0x00:0x20] = (0x07 << 0xfd) | ((stack[-2] << 0x5c) & 0x0ffffffffffffffffffffffffffffffffffffffff00000000000000000000000) | (stack[-1] >> 0x03) // @2405 stack[-2] = (storage[keccak256(memory[0x00:0x20])] & (0xffff << ((stack[-1] << 0x05) & 0xe0))) >> ((stack[-1] << 0x05) & 0xe0) // } // Block ends with unconditional jump to 0x2407 label_2407: // Incoming jump from 0x2406 // Inputs[2] // { // @2408 stack[-1] // @2408 stack[-2] // } 2407 5B JUMPDEST 2408 90 SWAP1 2409 56 *JUMP // Stack delta = -1 // Outputs[1] { @2408 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_240A: // Incoming jump from 0x23B6, if !(stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[1] { @2433 memory[0x00:0x04] } 240A 5B JUMPDEST 240B 7F PUSH32 0x8f4eb60400000000000000000000000000000000000000000000000000000000 242C 60 PUSH1 0x00 242E 52 MSTORE 242F 60 PUSH1 0x04 2431 60 PUSH1 0x00 2433 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @242E memory[0x00:0x20] = 0x8f4eb60400000000000000000000000000000000000000000000000000000000 // @2433 revert(memory[0x00:0x04]); // } // Block terminates label_2434: // Incoming call from 0x1599, returns to 0x159A // Incoming call from 0x1580, returns to 0x1581 // Inputs[1] { @243E stack[-1] } 2434 5B JUMPDEST 2435 67 PUSH8 0xffffffffffffffff 243E 81 DUP2 243F 11 GT 2440 61 PUSH2 0x221f 2443 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x221f, if stack[-1] > 0xffffffffffffffff label_2444: // Incoming jump from 0x2443, if not stack[-1] > 0xffffffffffffffff // Inputs[2] // { // @2446 stack[-1] // @244A stack[-2] // } 2444 60 PUSH1 0x05 2446 1B SHL 2447 60 PUSH1 0x20 2449 01 ADD 244A 90 SWAP1 244B 56 *JUMP // Stack delta = -1 // Outputs[1] { @244A stack[-2] = 0x20 + (stack[-1] << 0x05) } // Block ends with unconditional jump to stack[-2] label_244C: // Incoming call from 0x1622, returns to 0x1623 // Incoming call from 0x09D4, returns to 0x09D5 // Incoming call from 0x09E0, returns to 0x09E1 // Incoming call from 0x1818, returns to 0x1819 // Incoming call from 0x131C, returns to 0x131D // Incoming call from 0x1328, returns to 0x1329 // Incoming call from 0x164F, returns to 0x1650 // Incoming call from 0x1824, returns to 0x1825 // Inputs[3] // { // @244D stack[-1] // @244D stack[-3] // @244E stack[-2] // } 244C 5B JUMPDEST 244D 91 SWAP2 244E 90 SWAP1 244F 81 DUP2 2450 10 LT 2451 15 ISZERO 2452 61 PUSH2 0x245c 2455 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @244D stack[-3] = stack[-1] // @244E stack[-2] = stack[-3] // } // Block ends with conditional jump to 0x245c, if !(stack[-3] < stack[-2]) label_2456: // Incoming jump from 0x2455, if not !(stack[-3] < stack[-2]) // Inputs[3] // { // @2458 stack[-1] // @2459 stack[-2] // @245A stack[-3] // } 2456 60 PUSH1 0x05 2458 1B SHL 2459 01 ADD 245A 90 SWAP1 245B 56 *JUMP // Stack delta = -2 // Outputs[1] { @245A stack[-3] = (stack[-1] << 0x05) + stack[-2] } // Block ends with unconditional jump to stack[-3] label_245C: // Incoming jump from 0x2455, if !(stack[-3] < stack[-2]) // Inputs[1] { @248A memory[0x00:0x24] } 245C 5B JUMPDEST 245D 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 247E 60 PUSH1 0x00 2480 52 MSTORE 2481 60 PUSH1 0x32 2483 60 PUSH1 0x04 2485 52 MSTORE 2486 60 PUSH1 0x24 2488 60 PUSH1 0x00 248A FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2480 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @2485 memory[0x04:0x24] = 0x32 // @248A revert(memory[0x00:0x24]); // } // Block terminates label_248B: // Incoming jump from 0x2603 // Inputs[2] // { // @248C stack[-1] // @248C stack[-2] // } 248B 5B JUMPDEST 248C 90 SWAP1 248D 81 DUP2 248E 60 PUSH1 0x20 2490 91 SWAP2 2491 03 SUB 2492 12 SLT 2493 61 PUSH2 0x2115 2496 57 *JUMPI // Stack delta = -1 // Outputs[1] { @248C stack[-2] = stack[-1] } // Block ends with conditional jump to 0x2115, if stack[-2] - stack[-1] i< 0x20 label_2497: // Incoming jump from 0x2496, if not stack[-2] - stack[-1] i< 0x20 // Inputs[2] // { // @2497 memory[stack[-1]:stack[-1] + 0x20] // @2497 stack[-1] // } 2497 51 MLOAD 2498 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 24B9 81 DUP2 24BA 16 AND 24BB 81 DUP2 24BC 03 SUB 24BD 61 PUSH2 0x2115 24C0 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2497 stack[-1] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x2115, if memory[stack[-1]:stack[-1] + 0x20] - (memory[stack[-1]:stack[-1] + 0x20] & 0xffffffff00000000000000000000000000000000000000000000000000000000) label_24C1: // Incoming jump from 0x24C0, if not memory[stack[-1]:stack[-1] + 0x20] - (memory[stack[-1]:stack[-1] + 0x20] & 0xffffffff00000000000000000000000000000000000000000000000000000000) // Inputs[2] // { // @24C1 stack[-2] // @24C1 stack[-1] // } 24C1 90 SWAP1 24C2 56 *JUMP // Stack delta = -1 // Outputs[1] { @24C1 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_24C3: // Incoming call from 0x277B, returns to 0x2583 // Incoming call from 0x2582, returns to 0x2583 // Incoming call from 0x2832, returns to 0x2583 // Inputs[1] { @24C4 returndata.length } 24C3 5B JUMPDEST 24C4 3D RETURNDATASIZE 24C5 15 ISZERO 24C6 61 PUSH2 0x24ee 24C9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x24ee, if !returndata.length label_24CA: // Incoming jump from 0x24C9, if not !returndata.length // Inputs[2] // { // @24CA returndata.length // @24CB stack[-1] // } 24CA 3D RETURNDATASIZE 24CB 90 SWAP1 24CC 61 PUSH2 0x24d4 24CF 82 DUP3 24D0 61 PUSH2 0x22ab 24D3 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @24CB stack[0] = stack[-1] // @24CB stack[-1] = returndata.length // @24CC stack[1] = 0x24d4 // @24CF stack[2] = returndata.length // } // Block ends with call to 0x22ab, returns to 0x24D4 label_24D4: // Incoming return from call to 0x22AB at 0x24D3 // Inputs[3] // { // @24D5 stack[-3] // @24D5 stack[-1] // @24DB memory[0x40:0x60] // } 24D4 5B JUMPDEST 24D5 91 SWAP2 24D6 61 PUSH2 0x24e2 24D9 60 PUSH1 0x40 24DB 51 MLOAD 24DC 93 SWAP4 24DD 84 DUP5 24DE 61 PUSH2 0x226a 24E1 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @24D5 stack[-1] = stack[-3] // @24D6 stack[0] = 0x24e2 // @24DC stack[-3] = memory[0x40:0x60] // @24DC stack[1] = stack[-1] // @24DD stack[2] = memory[0x40:0x60] // } // Block ends with call to 0x226a, returns to 0x24E2 label_24E2: // Incoming return from call to 0x226A at 0x24E1 // Inputs[5] // { // @24E3 stack[-3] // @24E4 stack[-1] // @24E5 returndata.length // @24EC returndata[0x00:0x00 + returndata.length] // @24ED stack[-2] // } 24E2 5B JUMPDEST 24E3 82 DUP3 24E4 52 MSTORE 24E5 3D RETURNDATASIZE 24E6 60 PUSH1 0x00 24E8 60 PUSH1 0x20 24EA 84 DUP5 24EB 01 ADD 24EC 3E RETURNDATACOPY 24ED 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @24E4 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] // @24EC memory[stack[-3] + 0x20:stack[-3] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to stack[-2] label_24EE: // Incoming jump from 0x24C9, if !returndata.length // Inputs[1] { @24F1 stack[-1] } 24EE 5B JUMPDEST 24EF 60 PUSH1 0x60 24F1 90 SWAP1 24F2 56 *JUMP // Stack delta = +0 // Outputs[1] { @24F1 stack[-1] = 0x60 } // Block ends with unconditional jump to stack[-1] label_24F3: // Incoming call from 0x1D96, returns to 0x1D97 // Inputs[6] // { // @24F4 stack[-1] // @24F4 stack[-4] // @24F7 stack[-2] // @24FC stack[-3] // @2516 memory[0x40:0x60] // @2542 msg.sender // } 24F3 5B JUMPDEST 24F4 92 SWAP3 24F5 60 PUSH1 0x20 24F7 91 SWAP2 24F8 93 SWAP4 24F9 61 PUSH2 0x2568 24FC 93 SWAP4 24FD 60 PUSH1 0x00 24FF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2514 60 PUSH1 0x40 2516 51 MLOAD 2517 80 DUP1 2518 97 SWAP8 2519 81 DUP2 251A 96 SWAP7 251B 82 DUP3 251C 95 SWAP6 251D 7F PUSH32 0xf23a6e6100000000000000000000000000000000000000000000000000000000 253E 9B SWAP12 253F 8C DUP13 2540 85 DUP6 2541 52 MSTORE 2542 33 CALLER 2543 60 PUSH1 0x04 2545 86 DUP7 2546 01 ADD 2547 52 MSTORE 2548 86 DUP7 2549 60 PUSH1 0x24 254B 86 DUP7 254C 01 ADD 254D 52 MSTORE 254E 60 PUSH1 0x44 2550 85 DUP6 2551 01 ADD 2552 52 MSTORE 2553 60 PUSH1 0x64 2555 84 DUP5 2556 01 ADD 2557 52 MSTORE 2558 60 PUSH1 0xa0 255A 60 PUSH1 0x84 255C 84 DUP5 255D 01 ADD 255E 52 MSTORE 255F 60 PUSH1 0xa4 2561 83 DUP4 2562 01 ADD 2563 90 SWAP1 2564 61 PUSH2 0x213d 2567 56 *JUMP // Stack delta = +8 // Outputs[18] // { // @24F7 stack[-2] = 0x20 // @24F8 stack[0] = stack[-1] // @24FD stack[2] = 0x00 // @24FF stack[3] = 0xffffffffffffffffffffffffffffffffffffffff // @2516 stack[4] = memory[0x40:0x60] // @2518 stack[5] = 0x2568 // @2518 stack[-3] = memory[0x40:0x60] // @251A stack[-1] = memory[0x40:0x60] // @251C stack[1] = memory[0x40:0x60] // @253E stack[-4] = 0xf23a6e6100000000000000000000000000000000000000000000000000000000 // @2541 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xf23a6e6100000000000000000000000000000000000000000000000000000000 // @2547 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @254D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x00 // @2552 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-2] // @2557 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = stack[-3] // @255E memory[memory[0x40:0x60] + 0x84:memory[0x40:0x60] + 0x84 + 0x20] = 0xa0 // @2563 stack[7] = stack[-4] // @2563 stack[6] = memory[0x40:0x60] + 0xa4 // } // Block ends with call to 0x213d, returns to 0x2568 label_2568: // Incoming return from call to 0x213D at 0x2567 // Incoming return from call to 0x213D at 0x2689 // Inputs[12] // { // @2569 stack[-2] // @2569 stack[-1] // @256A stack[-6] // @256B stack[-3] // @256C msg.gas // @256D stack[-8] // @256D address(stack[-6] & stack[-3]).call.gas(msg.gas).value(stack[-4])(memory[stack[-5]:stack[-5] + stack[-1] - stack[-2]]) // @256D stack[-7] // @256D stack[-4] // @256D stack[-5] // @256D memory[stack[-5]:stack[-5] + stack[-1] - stack[-2]] // @2570 stack[-9] // } 2568 5B JUMPDEST 2569 03 SUB 256A 93 SWAP4 256B 16 AND 256C 5A GAS 256D F1 CALL 256E 60 PUSH1 0x00 2570 91 SWAP2 2571 81 DUP2 2572 61 PUSH2 0x25e2 2575 57 *JUMPI // Stack delta = -6 // Outputs[4] // { // @256D memory[stack[-7]:stack[-7] + stack[-8]] = address(stack[-6] & stack[-3]).call.gas(msg.gas).value(stack[-4])(memory[stack[-5]:stack[-5] + stack[-1] - stack[-2]]) // @256D stack[-8] = address(stack[-6] & stack[-3]).call.gas(msg.gas).value(stack[-4])(memory[stack[-5]:stack[-5] + stack[-1] - stack[-2]]) // @2570 stack[-7] = stack[-9] // @2570 stack[-9] = 0x00 // } // Block ends with conditional jump to 0x25e2, if address(stack[-6] & stack[-3]).call.gas(msg.gas).value(stack[-4])(memory[stack[-5]:stack[-5] + stack[-1] - stack[-2]]) label_2576: // Incoming jump from 0x260A // Incoming jump from 0x2575, if not address(stack[-6] & stack[-3]).call.gas(msg.gas).value(stack[-4])(memory[stack[-5]:stack[-5] + stack[-1] - stack[-2]]) // Inputs[1] { @257B stack[-2] } 2576 5B JUMPDEST 2577 50 POP 2578 61 PUSH2 0x25bc 257B 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x25bc, if stack[-2] label_257C: // Incoming jump from 0x257B, if not stack[-2] 257C 61 PUSH2 0x2583 257F 61 PUSH2 0x24c3 2582 56 *JUMP // Stack delta = +1 // Outputs[1] { @257C stack[0] = 0x2583 } // Block ends with call to 0x24c3, returns to 0x2583 label_2583: // Incoming return from call to 0x24C3 at 0x277B // Incoming return from call to 0x24C3 at 0x2582 // Incoming return from call to 0x24C3 at 0x2582 // Incoming return from call to 0x24C3 at 0x2832 // Inputs[2] // { // @2584 stack[-1] // @2585 memory[stack[-1]:stack[-1] + 0x20] // } 2583 5B JUMPDEST 2584 80 DUP1 2585 51 MLOAD 2586 15 ISZERO 2587 61 PUSH2 0x2592 258A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2592, if !memory[stack[-1]:stack[-1] + 0x20] label_258B: // Incoming jump from 0x258A, if not !memory[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @258B stack[-1] // @258C memory[stack[-1]:stack[-1] + 0x20] // @2591 memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 258B 80 DUP1 258C 51 MLOAD 258D 90 SWAP1 258E 60 PUSH1 0x20 2590 01 ADD 2591 FD *REVERT // Stack delta = -1 // Outputs[1] { @2591 revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_2592: // Incoming jump from 0x258A, if !memory[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @25BB memory[0x00:0x04] } 2592 5B JUMPDEST 2593 7F PUSH32 0x9c05499b00000000000000000000000000000000000000000000000000000000 25B4 60 PUSH1 0x00 25B6 52 MSTORE 25B7 60 PUSH1 0x04 25B9 60 PUSH1 0x00 25BB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @25B6 memory[0x00:0x20] = 0x9c05499b00000000000000000000000000000000000000000000000000000000 // @25BB revert(memory[0x00:0x04]); // } // Block terminates label_25BC: // Incoming jump from 0x257B, if stack[-2] // Incoming jump from 0x2774, if stack[-2] // Incoming jump from 0x282B, if stack[-2] // Inputs[3] // { // @25DE stack[-1] // @25DF stack[-2] // @25E0 stack[-3] // } 25BC 5B JUMPDEST 25BD 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 25DE 16 AND 25DF 14 EQ 25E0 90 SWAP1 25E1 56 *JUMP // Stack delta = -2 // Outputs[1] { @25E0 stack[-3] = 0xffffffff00000000000000000000000000000000000000000000000000000000 & stack[-1] == stack[-2] } // Block ends with unconditional jump to stack[-3] label_25E2: // Incoming jump from 0x2826, if address(stack[-5] & stack[-3]).call.gas(msg.gas)(memory[stack[-4]:stack[-4] + stack[-1] - stack[-2]]) // Incoming jump from 0x276F, if address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).call.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-1] - stack[-2]]) // Incoming jump from 0x2575, if address(stack[-6] & stack[-3]).call.gas(msg.gas).value(stack[-4])(memory[stack[-5]:stack[-5] + stack[-1] - stack[-2]]) // Inputs[3] // { // @25E6 stack[-2] // @25E7 stack[-3] // @25EB returndata.length // } 25E2 5B JUMPDEST 25E3 61 PUSH2 0x2604 25E6 91 SWAP2 25E7 92 SWAP3 25E8 50 POP 25E9 60 PUSH1 0x20 25EB 3D RETURNDATASIZE 25EC 81 DUP2 25ED 11 GT 25EE 61 PUSH2 0x260b 25F1 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @25E6 stack[-2] = 0x2604 // @25E7 stack[-3] = stack[-2] // @25E9 stack[0] = 0x20 // } // Block ends with conditional jump to 0x260b, if 0x20 > returndata.length label_25F2: // Incoming call from 0x25F1, returns to 0x2604, if not 0x20 > returndata.length // Incoming jump from 0x2611 // Inputs[2] // { // @25F6 stack[-1] // @25F7 stack[-2] // } 25F2 5B JUMPDEST 25F3 61 PUSH2 0x25fc 25F6 81 DUP2 25F7 83 DUP4 25F8 61 PUSH2 0x226a 25FB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @25F3 stack[0] = 0x25fc // @25F6 stack[1] = stack[-1] // @25F7 stack[2] = stack[-2] // } // Block ends with call to 0x226a, returns to 0x25FC label_25FC: // Incoming return from call to 0x226A at 0x25FB // Inputs[2] // { // @25FD stack[-2] // @25FE stack[-1] // } 25FC 5B JUMPDEST 25FD 81 DUP2 25FE 01 ADD 25FF 90 SWAP1 2600 61 PUSH2 0x248b 2603 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @25FF stack[-1] = stack[-2] // @25FF stack[-2] = stack[-2] + stack[-1] // } // Block ends with unconditional jump to 0x248b label_2604: // Incoming return from call to 0x25F2 at 0x25F1 // Inputs[3] // { // @2605 stack[-2] // @2605 stack[-1] // @2606 code.length // } 2604 5B JUMPDEST 2605 90 SWAP1 2606 38 CODESIZE 2607 61 PUSH2 0x2576 260A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2605 stack[-2] = stack[-1] // @2605 stack[-1] = stack[-2] // @2606 stack[0] = code.length // } // Block ends with unconditional jump to 0x2576 label_260B: // Incoming jump from 0x25F1, if 0x20 > returndata.length // Inputs[1] { @260D returndata.length } 260B 5B JUMPDEST 260C 50 POP 260D 3D RETURNDATASIZE 260E 61 PUSH2 0x25f2 2611 56 *JUMP // Stack delta = +0 // Outputs[1] { @260D stack[-1] = returndata.length } // Block ends with unconditional jump to 0x25f2 label_2612: // Incoming jump from 0x0525 // Inputs[7] // { // @2613 stack[-1] // @2613 stack[-2] // @2617 stack[-4] // @261C stack[-3] // @261D stack[-5] // @2621 memory[0x40:0x60] // @264D msg.sender // } 2612 5B JUMPDEST 2613 90 SWAP1 2614 61 PUSH2 0x2568 2617 93 SWAP4 2618 60 PUSH1 0x00 261A 60 PUSH1 0x20 261C 94 SWAP5 261D 96 SWAP7 261E 93 SWAP4 261F 60 PUSH1 0x40 2621 51 MLOAD 2622 80 DUP1 2623 97 SWAP8 2624 81 DUP2 2625 96 SWAP7 2626 82 DUP3 2627 95 SWAP6 2628 7F PUSH32 0xf23a6e6100000000000000000000000000000000000000000000000000000000 2649 9B SWAP12 264A 8C DUP13 264B 85 DUP6 264C 52 MSTORE 264D 33 CALLER 264E 60 PUSH1 0x04 2650 86 DUP7 2651 01 ADD 2652 52 MSTORE 2653 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2668 80 DUP1 2669 96 SWAP7 266A 16 AND 266B 60 PUSH1 0x24 266D 86 DUP7 266E 01 ADD 266F 52 MSTORE 2670 60 PUSH1 0x44 2672 85 DUP6 2673 01 ADD 2674 52 MSTORE 2675 60 PUSH1 0x64 2677 84 DUP5 2678 01 ADD 2679 52 MSTORE 267A 60 PUSH1 0xa0 267C 60 PUSH1 0x84 267E 84 DUP5 267F 01 ADD 2680 52 MSTORE 2681 60 PUSH1 0xa4 2683 83 DUP4 2684 01 ADD 2685 90 SWAP1 2686 61 PUSH2 0x213d 2689 56 *JUMP // Stack delta = +7 // Outputs[18] // { // @2613 stack[-1] = stack[-2] // @2618 stack[1] = 0x00 // @261C stack[-3] = 0x20 // @2621 stack[3] = memory[0x40:0x60] // @2623 stack[4] = 0x2568 // @2623 stack[-4] = memory[0x40:0x60] // @2625 stack[-2] = memory[0x40:0x60] // @2627 stack[0] = memory[0x40:0x60] // @2649 stack[-5] = 0xf23a6e6100000000000000000000000000000000000000000000000000000000 // @264C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xf23a6e6100000000000000000000000000000000000000000000000000000000 // @2652 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @2669 stack[2] = 0xffffffffffffffffffffffffffffffffffffffff // @266F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // @2674 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-3] // @2679 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = stack[-4] // @2680 memory[memory[0x40:0x60] + 0x84:memory[0x40:0x60] + 0x84 + 0x20] = 0xa0 // @2685 stack[5] = memory[0x40:0x60] + 0xa4 // @2685 stack[6] = stack[-5] // } // Block ends with call to 0x213d, returns to 0x2568 label_268A: // Incoming call from 0x27FD, returns to 0x27FE // Incoming call from 0x2731, returns to 0x2732 // Incoming call from 0x271A, returns to 0x271B // Incoming call from 0x27E6, returns to 0x27E7 // Inputs[3] // { // @268B stack[-2] // @268B stack[-1] // @268C stack[-3] // } 268A 5B JUMPDEST 268B 90 SWAP1 268C 91 SWAP2 268D 82 DUP3 268E 81 DUP2 268F 52 MSTORE 2690 7F PUSH32 0x07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 26B1 83 DUP4 26B2 11 GT 26B3 61 PUSH2 0x2115 26B6 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @268B stack[-2] = stack[-1] // @268C stack[-1] = stack[-3] // @268C stack[-3] = stack[-2] // @268F memory[stack[-3]:stack[-3] + 0x20] = stack[-2] // } // Block ends with conditional jump to 0x2115, if stack[-2] > 0x07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff label_26B7: // Incoming jump from 0x26B6, if not stack[-2] > 0x07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // Inputs[5] // { // @26B9 stack[-3] // @26BE stack[-2] // @26C0 stack[-1] // @26C2 msg.data[stack[-2]:stack[-2] + stack[-3] << 0x05] // @26C5 stack[-4] // } 26B7 60 PUSH1 0x20 26B9 92 SWAP3 26BA 60 PUSH1 0x05 26BC 1B SHL 26BD 80 DUP1 26BE 92 SWAP3 26BF 84 DUP5 26C0 83 DUP4 26C1 01 ADD 26C2 37 CALLDATACOPY 26C3 01 ADD 26C4 01 ADD 26C5 90 SWAP1 26C6 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @26C2 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-3] << 0x05] = msg.data[stack[-2]:stack[-2] + stack[-3] << 0x05] // @26C5 stack[-4] = stack[-1] + (stack[-3] << 0x05) + 0x20 // } // Block ends with unconditional jump to stack[-4] label_26C7: // Incoming call from 0x09B7, returns to 0x09B8 // Inputs[8] // { // @26C8 stack[-1] // @26C8 stack[-4] // @26C9 stack[-3] // @26CA stack[-6] // @26CD memory[0x40:0x60] // @26CE stack[-5] // @26D2 stack[-2] // @26F8 msg.sender // } 26C7 5B JUMPDEST 26C8 92 SWAP3 26C9 91 SWAP2 26CA 94 SWAP5 26CB 60 PUSH1 0x40 26CD 51 MLOAD 26CE 94 SWAP5 26CF 85 DUP6 26D0 93 SWAP4 26D1 84 DUP5 26D2 93 SWAP4 26D3 7F PUSH32 0xbc197c8100000000000000000000000000000000000000000000000000000000 26F4 98 SWAP9 26F5 89 DUP10 26F6 86 DUP7 26F7 52 MSTORE 26F8 33 CALLER 26F9 60 PUSH1 0x04 26FB 87 DUP8 26FC 01 ADD 26FD 52 MSTORE 26FE 60 PUSH1 0x24 2700 86 DUP7 2701 01 ADD 2702 60 PUSH1 0x00 2704 90 SWAP1 2705 52 MSTORE 2706 60 PUSH1 0x44 2708 86 DUP7 2709 01 ADD 270A 60 PUSH1 0xa0 270C 90 SWAP1 270D 52 MSTORE 270E 60 PUSH1 0xa4 2710 86 DUP7 2711 01 ADD 2712 90 SWAP1 2713 61 PUSH2 0x271b 2716 92 SWAP3 2717 61 PUSH2 0x268a 271A 56 *JUMP // Stack delta = +6 // Outputs[16] // { // @26C8 stack[-4] = stack[-1] // @26CA stack[-1] = stack[-6] // @26CE stack[0] = stack[-5] // @26CE stack[-5] = memory[0x40:0x60] // @26D0 stack[-3] = memory[0x40:0x60] // @26D0 stack[1] = stack[-4] // @26D2 stack[-2] = memory[0x40:0x60] // @26F4 stack[-6] = 0xbc197c8100000000000000000000000000000000000000000000000000000000 // @26F7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xbc197c8100000000000000000000000000000000000000000000000000000000 // @26FD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @2705 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x00 // @270D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0xa0 // @2712 stack[4] = stack[-3] // @2712 stack[3] = memory[0x40:0x60] + 0xa4 // @2716 stack[2] = 0x271b // @2716 stack[5] = stack[-2] // } // Block ends with call to 0x268a, returns to 0x271B label_271B: // Incoming return from call to 0x268A at 0x271A // Inputs[4] // { // @271F stack[-3] // @2721 stack[-5] // @2722 stack[-1] // @272D stack[-2] // } 271B 5B JUMPDEST 271C 60 PUSH1 0x03 271E 19 NOT 271F 92 SWAP3 2720 83 DUP4 2721 86 DUP7 2722 83 DUP4 2723 03 SUB 2724 01 ADD 2725 60 PUSH1 0x64 2727 87 DUP8 2728 01 ADD 2729 52 MSTORE 272A 61 PUSH2 0x2732 272D 92 SWAP3 272E 61 PUSH2 0x268a 2731 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @271F stack[-3] = ~0x03 // @271F stack[0] = stack[-3] // @2729 memory[stack[-5] + 0x64:stack[-5] + 0x64 + 0x20] = stack[-1] - stack[-5] + ~0x03 // @272D stack[-2] = 0x2732 // @272D stack[1] = stack[-2] // } // Block ends with call to 0x268a, returns to 0x2732 label_2732: // Incoming return from call to 0x268A at 0x2731 // Inputs[4] // { // @2733 stack[-2] // @2733 stack[-1] // @2734 stack[-4] // @2740 stack[-3] // } 2732 5B JUMPDEST 2733 90 SWAP1 2734 83 DUP4 2735 82 DUP3 2736 03 SUB 2737 01 ADD 2738 60 PUSH1 0x84 273A 84 DUP5 273B 01 ADD 273C 52 MSTORE 273D 61 PUSH2 0x2745 2740 91 SWAP2 2741 61 PUSH2 0x213d 2744 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2733 stack[-2] = stack[-1] // @273C memory[stack[-4] + 0x84:stack[-4] + 0x84 + 0x20] = stack[-1] - stack[-4] + stack[-2] // @2740 stack[-1] = stack[-3] // @2740 stack[-3] = 0x2745 // } // Block ends with call to 0x213d, returns to 0x2745 label_2745: // Incoming return from call to 0x213D at 0x2744 // Inputs[8] // { // @2746 stack[-1] // @2746 stack[-2] // @2747 stack[-4] // @275F stack[-3] // @2760 msg.gas // @2767 memory[stack[-3]:stack[-3] + stack[-1] - stack[-2]] // @2767 address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).call.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-1] - stack[-2]]) // @276A stack[-5] // } 2745 5B JUMPDEST 2746 03 SUB 2747 91 SWAP2 2748 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 275D 16 AND 275E 91 SWAP2 275F 81 DUP2 2760 5A GAS 2761 60 PUSH1 0x20 2763 94 SWAP5 2764 60 PUSH1 0x00 2766 91 SWAP2 2767 F1 CALL 2768 60 PUSH1 0x00 276A 91 SWAP2 276B 81 DUP2 276C 61 PUSH2 0x25e2 276F 57 *JUMPI // Stack delta = -2 // Outputs[4] // { // @2767 memory[stack[-3]:stack[-3] + 0x20] = address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).call.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-1] - stack[-2]]) // @2767 stack[-4] = address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).call.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-1] - stack[-2]]) // @276A stack[-3] = stack[-5] // @276A stack[-5] = 0x00 // } // Block ends with conditional jump to 0x25e2, if address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).call.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-1] - stack[-2]]) label_2770: // Incoming jump from 0x276F, if not address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).call.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-1] - stack[-2]]) // Inputs[1] { @2774 stack[-2] } 2770 50 POP 2771 61 PUSH2 0x25bc 2774 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x25bc, if stack[-2] label_2775: // Incoming jump from 0x2774, if not stack[-2] 2775 61 PUSH2 0x2583 2778 61 PUSH2 0x24c3 277B 56 *JUMP // Stack delta = +1 // Outputs[1] { @2775 stack[0] = 0x2583 } // Block ends with call to 0x24c3, returns to 0x2583 label_277C: // Incoming call from 0x17F8, returns to 0x17F9 // Inputs[9] // { // @277D stack[-3] // @277D stack[-1] // @277E stack[-2] // @277F stack[-5] // @2780 stack[-4] // @2781 stack[-7] // @2784 memory[0x40:0x60] // @2785 stack[-6] // @27AF msg.sender // } 277C 5B JUMPDEST 277D 91 SWAP2 277E 90 SWAP1 277F 93 SWAP4 2780 92 SWAP3 2781 95 SWAP6 2782 60 PUSH1 0x40 2784 51 MLOAD 2785 95 SWAP6 2786 86 DUP7 2787 94 SWAP5 2788 85 DUP6 2789 93 SWAP4 278A 7F PUSH32 0xbc197c8100000000000000000000000000000000000000000000000000000000 27AB 99 SWAP10 27AC 8A DUP11 27AD 86 DUP7 27AE 52 MSTORE 27AF 33 CALLER 27B0 60 PUSH1 0x04 27B2 87 DUP8 27B3 01 ADD 27B4 52 MSTORE 27B5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 27CA 80 DUP1 27CB 97 SWAP8 27CC 16 AND 27CD 60 PUSH1 0x24 27CF 87 DUP8 27D0 01 ADD 27D1 52 MSTORE 27D2 60 PUSH1 0x44 27D4 86 DUP7 27D5 01 ADD 27D6 60 PUSH1 0xa0 27D8 90 SWAP1 27D9 52 MSTORE 27DA 60 PUSH1 0xa4 27DC 86 DUP7 27DD 01 ADD 27DE 90 SWAP1 27DF 61 PUSH2 0x27e7 27E2 92 SWAP3 27E3 61 PUSH2 0x268a 27E6 56 *JUMP // Stack delta = +6 // Outputs[17] // { // @277F stack[-5] = stack[-2] // @2781 stack[-1] = stack[-7] // @2785 stack[0] = stack[-6] // @2785 stack[-6] = memory[0x40:0x60] // @2787 stack[-4] = memory[0x40:0x60] // @2787 stack[1] = stack[-5] // @2789 stack[-2] = memory[0x40:0x60] // @27AB stack[-7] = 0xbc197c8100000000000000000000000000000000000000000000000000000000 // @27AE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xbc197c8100000000000000000000000000000000000000000000000000000000 // @27B4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @27CB stack[-3] = 0xffffffffffffffffffffffffffffffffffffffff // @27D1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // @27D9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0xa0 // @27DE stack[4] = stack[-4] // @27DE stack[3] = memory[0x40:0x60] + 0xa4 // @27E2 stack[2] = 0x27e7 // @27E2 stack[5] = stack[-3] // } // Block ends with call to 0x268a, returns to 0x27E7 label_27E7: // Incoming return from call to 0x268A at 0x27E6 // Inputs[4] // { // @27EB stack[-3] // @27ED stack[-5] // @27EE stack[-1] // @27F9 stack[-2] // } 27E7 5B JUMPDEST 27E8 60 PUSH1 0x03 27EA 19 NOT 27EB 92 SWAP3 27EC 83 DUP4 27ED 86 DUP7 27EE 83 DUP4 27EF 03 SUB 27F0 01 ADD 27F1 60 PUSH1 0x64 27F3 87 DUP8 27F4 01 ADD 27F5 52 MSTORE 27F6 61 PUSH2 0x27fe 27F9 92 SWAP3 27FA 61 PUSH2 0x268a 27FD 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @27EB stack[-3] = ~0x03 // @27EB stack[0] = stack[-3] // @27F5 memory[stack[-5] + 0x64:stack[-5] + 0x64 + 0x20] = stack[-1] - stack[-5] + ~0x03 // @27F9 stack[-2] = 0x27fe // @27F9 stack[1] = stack[-2] // } // Block ends with call to 0x268a, returns to 0x27FE label_27FE: // Incoming return from call to 0x268A at 0x27FD // Inputs[4] // { // @27FF stack[-2] // @27FF stack[-1] // @2800 stack[-4] // @280C stack[-3] // } 27FE 5B JUMPDEST 27FF 90 SWAP1 2800 83 DUP4 2801 82 DUP3 2802 03 SUB 2803 01 ADD 2804 60 PUSH1 0x84 2806 84 DUP5 2807 01 ADD 2808 52 MSTORE 2809 61 PUSH2 0x2811 280C 91 SWAP2 280D 61 PUSH2 0x213d 2810 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @27FF stack[-2] = stack[-1] // @2808 memory[stack[-4] + 0x84:stack[-4] + 0x84 + 0x20] = stack[-1] - stack[-4] + stack[-2] // @280C stack[-1] = stack[-3] // @280C stack[-3] = 0x2811 // } // Block ends with call to 0x213d, returns to 0x2811 label_2811: // Incoming return from call to 0x213D at 0x2810 // Inputs[9] // { // @2812 stack[-2] // @2812 stack[-1] // @2813 stack[-5] // @2814 stack[-3] // @2816 stack[-4] // @2817 msg.gas // @281E address(stack[-5] & stack[-3]).call.gas(msg.gas)(memory[stack[-4]:stack[-4] + stack[-1] - stack[-2]]) // @281E memory[stack[-4]:stack[-4] + stack[-1] - stack[-2]] // @2821 stack[-6] // } 2811 5B JUMPDEST 2812 03 SUB 2813 92 SWAP3 2814 16 AND 2815 91 SWAP2 2816 81 DUP2 2817 5A GAS 2818 60 PUSH1 0x20 281A 94 SWAP5 281B 60 PUSH1 0x00 281D 91 SWAP2 281E F1 CALL 281F 60 PUSH1 0x00 2821 91 SWAP2 2822 81 DUP2 2823 61 PUSH2 0x25e2 2826 57 *JUMPI // Stack delta = -3 // Outputs[4] // { // @281E memory[stack[-4]:stack[-4] + 0x20] = address(stack[-5] & stack[-3]).call.gas(msg.gas)(memory[stack[-4]:stack[-4] + stack[-1] - stack[-2]]) // @281E stack[-5] = address(stack[-5] & stack[-3]).call.gas(msg.gas)(memory[stack[-4]:stack[-4] + stack[-1] - stack[-2]]) // @2821 stack[-4] = stack[-6] // @2821 stack[-6] = 0x00 // } // Block ends with conditional jump to 0x25e2, if address(stack[-5] & stack[-3]).call.gas(msg.gas)(memory[stack[-4]:stack[-4] + stack[-1] - stack[-2]]) label_2827: // Incoming jump from 0x2826, if not address(stack[-5] & stack[-3]).call.gas(msg.gas)(memory[stack[-4]:stack[-4] + stack[-1] - stack[-2]]) // Inputs[1] { @282B stack[-2] } 2827 50 POP 2828 61 PUSH2 0x25bc 282B 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x25bc, if stack[-2] label_282C: // Incoming jump from 0x282B, if not stack[-2] 282C 61 PUSH2 0x2583 282F 61 PUSH2 0x24c3 2832 56 *JUMP // Stack delta = +1 // Outputs[1] { @282C stack[0] = 0x2583 } // Block ends with call to 0x24c3, returns to 0x2583 label_2833: // Incoming call from 0x0E3C, returns to 0x0E3D // Incoming call from 0x07BA, returns to 0x07BB // Incoming call from 0x0F59, returns to 0x0F5A // Incoming call from 0x1216, returns to 0x1217 // Incoming call from 0x0DDA, returns to 0x0DDB // Incoming call from 0x0396, returns to 0x0397 // Inputs[2] // { // @283A storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] // @283B msg.sender // } 2833 5B JUMPDEST 2834 63 PUSH4 0x8b78c6d8 2839 19 NOT 283A 54 SLOAD 283B 33 CALLER 283C 03 SUB 283D 61 PUSH2 0x2842 2840 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2842, if msg.sender - storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] label_2841: // Incoming jump from 0x2840, if not msg.sender - storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] // Inputs[1] { @2841 stack[-1] } 2841 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_2842: // Incoming jump from 0x2840, if msg.sender - storage[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927] // Inputs[1] { @284F memory[0x1c:0x20] } 2842 5B JUMPDEST 2843 63 PUSH4 0x82b42900 2848 60 PUSH1 0x00 284A 52 MSTORE 284B 60 PUSH1 0x04 284D 60 PUSH1 0x1c 284F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @284A memory[0x00:0x20] = 0x82b42900 // @284F revert(memory[0x1c:0x20]); // } // Block terminates label_2850: // Incoming call from 0x0FDE, returns to 0x0FDF // Incoming call from 0x0F72, returns to 0x0F73 // Incoming call from 0x1EDC, returns to 0x1EDD // Inputs[2] // { // @2851 stack[-2] // @2851 stack[-1] // } 2850 5B JUMPDEST 2851 90 SWAP1 2852 60 PUSH1 0x01 2854 82 DUP3 2855 81 DUP2 2856 1C SHR 2857 92 SWAP3 2858 16 AND 2859 80 DUP1 285A 15 ISZERO 285B 61 PUSH2 0x2899 285E 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2851 stack[-1] = stack[-2] // @2857 stack[-2] = stack[-1] >> 0x01 // @2858 stack[0] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x2899, if !(stack[-1] & 0x01) label_285F: // Incoming jump from 0x285E, if not !(stack[-1] & 0x01) // Incoming jump from 0x28A2 // Inputs[2] // { // @2862 stack[-3] // @2864 stack[-1] // } 285F 5B JUMPDEST 2860 60 PUSH1 0x20 2862 83 DUP4 2863 10 LT 2864 14 EQ 2865 61 PUSH2 0x286a 2868 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x286a, if (stack[-3] < 0x20) == stack[-1] label_2869: // Incoming jump from 0x2868, if not (stack[-3] < 0x20) == stack[-1] // Inputs[1] { @2869 stack[-1] } 2869 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_286A: // Incoming jump from 0x2868, if (stack[-3] < 0x20) == stack[-1] // Inputs[1] { @2898 memory[0x00:0x24] } 286A 5B JUMPDEST 286B 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 288C 60 PUSH1 0x00 288E 52 MSTORE 288F 60 PUSH1 0x22 2891 60 PUSH1 0x04 2893 52 MSTORE 2894 60 PUSH1 0x24 2896 60 PUSH1 0x00 2898 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @288E memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @2893 memory[0x04:0x24] = 0x22 // @2898 revert(memory[0x00:0x24]); // } // Block terminates label_2899: // Incoming jump from 0x285E, if !(stack[-1] & 0x01) // Inputs[2] // { // @289A stack[-1] // @289A stack[-3] // } 2899 5B JUMPDEST 289A 91 SWAP2 289B 60 PUSH1 0x7f 289D 16 AND 289E 91 SWAP2 289F 61 PUSH2 0x285f 28A2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @289E stack[-1] = stack[-1] // @289E stack[-3] = 0x7f & stack[-3] // } // Block ends with unconditional jump to 0x285f 28A3 FE *ASSERT 28A4 A2 LOG2 28A5 64 PUSH5 0x6970667358 28AB 22 22 28AC 12 SLT 28AD 20 SHA3 28AE C6 C6 28AF 2B 2B 28B0 6C PUSH13 0x4a774668339bc3342fc2ff8127 28BE E9 E9 28BF 44 DIFFICULTY 28C0 F8 F8 28C1 02 MUL 28C2 18 XOR 28C3 ED ED 28C4 B3 B3 28C5 7A PUSH27 0xd890391eac9d27ab64736f6c63430008140033
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]