Online Solidity Decompiler

« Decompile another contract

Address

0xa57bd00134b2850b2a1c55860c9e9ea100fdd6cf [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.
0x1cff79cd execute(address,bytes)
0x1f6a1eb9 execute(bytes,bytes)
0x60c7d295 cache()
0x65fae35e rely(address)
0x78e111f6 Unknown
0x948f5076 setCache(address)
0x9c52a7f1 deny(address)
0xa90e8731 Unknown
0xbf353dbb wards(address)

Internal Methods

execute(arg0, arg1)
rely(arg0, arg1)
func_0302(arg0, arg1) returns (r0)
setCache(arg0, arg1) returns (r0)
deny(arg0, arg1)
func_04A7(arg0, arg1) returns (r0)
wards(arg0, arg2) returns (r0)
func_0603(arg0, arg1)
cache(arg0) returns (r0)
func_088F(arg0, arg1) returns (r0)

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x80; if (msg.data.length < 0x04) { stop(); } var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000; if (0x78e111f6 > var0) { if (var0 == 0x1cff79cd) { // Dispatch table entry for execute(address,bytes) var var1 = 0x00a3; var var2 = 0x04; var var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } execute(var2, var3); stop(); } else if (var0 == 0x1f6a1eb9) { // Dispatch table entry for execute(bytes,bytes) var1 = 0x00a3; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } execute(var2, var3); stop(); } else if (var0 == 0x60c7d295) { // Dispatch table entry for cache() var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x029d; var2 = cache(); var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = var2 & 0x02 ** 0xa0 - 0x01; var temp1 = memory[0x40:0x60]; return memory[temp1:temp1 + temp0 - temp1 + 0x20]; } else if (var0 == 0x65fae35e) { // Dispatch table entry for rely(address) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x00a3; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } rely(var2, var3); stop(); } else { stop(); } } else if (var0 == 0x78e111f6) { // Dispatch table entry for 0x78e111f6 (unknown) var1 = 0x03a2; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } var1 = func_0302(var2, var3); label_03A2: var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x20; var temp3 = var1; memory[temp2 + 0x20:temp2 + 0x20 + 0x20] = memory[temp3:temp3 + 0x20]; var2 = temp2; var3 = var2; var var4 = var3 + 0x40; var var6 = memory[temp3:temp3 + 0x20]; var var5 = temp3 + 0x20; var var7 = var6; var var8 = var4; var var9 = var5; var var10 = 0x00; if (var10 >= var7) { label_03DC: var temp4 = var6; var4 = temp4 + var4; var5 = temp4 & 0x1f; if (!var5) { var temp5 = memory[0x40:0x60]; return memory[temp5:temp5 + var4 - temp5]; } else { var temp6 = var5; var temp7 = var4 - temp6; memory[temp7:temp7 + 0x20] = ~(0x0100 ** (0x20 - temp6) - 0x01) & memory[temp7:temp7 + 0x20]; var temp8 = memory[0x40:0x60]; return memory[temp8:temp8 + (temp7 + 0x20) - temp8]; } } else { label_03CD: var temp9 = var10; memory[temp9 + var8:temp9 + var8 + 0x20] = memory[temp9 + var9:temp9 + var9 + 0x20]; var10 = temp9 + 0x20; if (var10 >= var7) { goto label_03DC; } else { goto label_03CD; } } } else if (var0 == 0x948f5076) { // Dispatch table entry for setCache(address) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x044a; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var1 = setCache(var2, var3); var temp10 = memory[0x40:0x60]; memory[temp10:temp10 + 0x20] = !!var1; var temp11 = memory[0x40:0x60]; return memory[temp11:temp11 + temp10 - temp11 + 0x20]; } else if (var0 == 0x9c52a7f1) { // Dispatch table entry for deny(address) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x00a3; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } deny(var2, var3); stop(); } else if (var0 == 0xa90e8731) { // Dispatch table entry for 0xa90e8731 (unknown) var1 = 0x03a2; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } var1 = func_04A7(var2, var3); goto label_03A2; } else if (var0 == 0xbf353dbb) { // Dispatch table entry for wards(address) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x05f1; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var2 = wards(var2, var3); var temp12 = memory[0x40:0x60]; memory[temp12:temp12 + 0x20] = var2; var temp13 = memory[0x40:0x60]; return memory[temp13:temp13 + temp12 - temp13 + 0x20]; } else { stop(); } } function execute(var arg0, var arg1) { var temp0 = arg0; arg0 = msg.data[temp0:temp0 + 0x20] & 0x02 ** 0xa0 - 0x01; var var0 = temp0; arg1 = var0 + arg1; var var1 = var0 + 0x40; var var2 = msg.data[var0 + 0x20:var0 + 0x20 + 0x20]; if (var2 > 0x0100000000) { revert(memory[0x00:0x00]); } var temp1 = var0 + var2; var2 = temp1; if (var2 + 0x20 > arg1) { revert(memory[0x00:0x00]); } var temp2 = var2; var temp3 = msg.data[temp2:temp2 + 0x20]; var2 = temp3; var temp4 = var1; var1 = temp2 + 0x20; var var3 = temp4; if ((var2 > 0x0100000000) | (var1 + var2 > arg1)) { revert(memory[0x00:0x00]); } var temp5 = var2; var temp6 = memory[0x40:0x60]; memory[0x40:0x60] = temp6 + (temp5 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp6:temp6 + 0x20] = temp5; var temp7 = temp6 + 0x20; memory[temp7:temp7 + temp5] = msg.data[var1:var1 + temp5]; memory[temp7 + temp5:temp7 + temp5 + 0x20] = 0x00; arg1 = temp6; func_0603(arg0, arg1); // Error: Could not resolve method call return address! } function execute(var arg0, var arg1) { var temp0 = arg0; var temp1 = temp0 + arg1; arg1 = temp0; arg0 = temp1; var var0 = arg1 + 0x20; var var1 = msg.data[arg1:arg1 + 0x20]; if (var1 > 0x0100000000) { revert(memory[0x00:0x00]); } var temp2 = arg1 + var1; var1 = temp2; if (var1 + 0x20 > arg0) { revert(memory[0x00:0x00]); } var temp3 = var1; var temp4 = msg.data[temp3:temp3 + 0x20]; var1 = temp4; var temp5 = var0; var0 = temp3 + 0x20; var var2 = temp5; if ((var1 > 0x0100000000) | (var0 + var1 > arg0)) { revert(memory[0x00:0x00]); } var temp6 = var2; var temp7 = var1; var temp8 = memory[0x40:0x60]; memory[0x40:0x60] = temp8 + (temp7 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp8:temp8 + 0x20] = temp7; var temp9 = temp8 + 0x20; memory[temp9:temp9 + temp7] = msg.data[var0:var0 + temp7]; memory[temp9 + temp7:temp9 + temp7 + 0x20] = 0x00; var temp10 = arg0; arg0 = temp8; var temp11 = arg1; arg1 = temp10; var0 = temp11; var1 = temp6 + 0x20; var2 = msg.data[temp6:temp6 + 0x20]; if (var2 > 0x0100000000) { revert(memory[0x00:0x00]); } var temp12 = var0 + var2; var2 = temp12; if (var2 + 0x20 > arg1) { revert(memory[0x00:0x00]); } var temp13 = var2; var temp14 = msg.data[temp13:temp13 + 0x20]; var2 = temp14; var temp15 = var1; var1 = temp13 + 0x20; var var3 = temp15; if ((var2 > 0x0100000000) | (var1 + var2 > arg1)) { revert(memory[0x00:0x00]); } var temp16 = var2; var temp17 = memory[0x40:0x60]; memory[0x40:0x60] = temp17 + (temp16 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp17:temp17 + 0x20] = temp16; var temp18 = temp17 + 0x20; memory[temp18:temp18 + temp16] = msg.data[var1:var1 + temp16]; memory[temp18 + temp16:temp18 + temp16 + 0x20] = 0x00; arg1 = temp17; var temp19 = memory[0x40:0x60]; memory[temp19:temp19 + 0x20] = 0x8bf4515c00000000000000000000000000000000000000000000000000000000; memory[temp19 + 0x04:temp19 + 0x04 + 0x20] = 0x20; var temp20 = arg0; memory[temp19 + 0x24:temp19 + 0x24 + 0x20] = memory[temp20:temp20 + 0x20]; var0 = 0x00; var1 = storage[0x01] & 0x02 ** 0xa0 - 0x01; var2 = 0x8bf4515c; var3 = temp20; var var4 = temp19 + 0x04; var var5 = var4; var var6 = temp19 + 0x44; var var7 = var3 + 0x20; var var8 = memory[var3:var3 + 0x20]; var var9 = var8; var var10 = var6; var var11 = var7; var var12 = var0; if (var12 >= var9) { label_06BC: var temp21 = var8; var6 = temp21 + var6; var7 = temp21 & 0x1f; if (!var7) { var3 = var6; var4 = 0x20; var5 = memory[0x40:0x60]; var6 = var3 - var5; var7 = var5; var8 = var1; var9 = !address(var8).code.length; if (var9) { revert(memory[0x00:0x00]); } label_0706: var temp22; temp22, memory[var5:var5 + var4] = address(var8).staticcall.gas(msg.gas)(memory[var7:var7 + var6]); var4 = !temp22; if (!var4) { var1 = memory[0x40:0x60]; var2 = returndata.length; if (var2 < 0x20) { revert(memory[0x00:0x00]); } var0 = memory[var1:var1 + 0x20]; if (var0 & 0x02 ** 0xa0 - 0x01) { label_0838: var1 = 0x0842; var2 = var0; var3 = arg1; func_0603(var2, var3); return; } else { var temp23 = memory[0x40:0x60]; memory[temp23:temp23 + 0x20] = 0x7ed0c3b200000000000000000000000000000000000000000000000000000000; var4 = temp23 + 0x04; memory[var4:var4 + 0x20] = 0x20; var temp24 = arg0; memory[temp23 + 0x24:temp23 + 0x24 + 0x20] = memory[temp24:temp24 + 0x20]; var1 = storage[0x01] & 0x02 ** 0xa0 - 0x01; var2 = 0x7ed0c3b2; var3 = temp24; var5 = var4; var6 = temp23 + 0x44; var8 = memory[var3:var3 + 0x20]; var7 = var3 + 0x20; var9 = var8; var10 = var6; var11 = var7; var12 = 0x00; if (var12 >= var9) { label_07BD: var temp25 = var8; var6 = temp25 + var6; var7 = temp25 & 0x1f; if (!var7) { var3 = var6; var4 = 0x20; var5 = memory[0x40:0x60]; var6 = var3 - var5; var7 = var5; var8 = 0x00; var9 = var1; var10 = !address(var9).code.length; if (var10) { revert(memory[0x00:0x00]); } label_0809: var temp26; temp26, memory[var5:var5 + var4] = address(var9).call.gas(msg.gas).value(var8)(memory[var7:var7 + var6]); var4 = !temp26; if (!var4) { var1 = memory[0x40:0x60]; var2 = returndata.length; if (var2 < 0x20) { revert(memory[0x00:0x00]); } var0 = memory[var1:var1 + 0x20]; goto label_0838; } else { var temp27 = returndata.length; memory[0x00:0x00 + temp27] = returndata[0x00:0x00 + temp27]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp28 = var7; var temp29 = var6 - temp28; memory[temp29:temp29 + 0x20] = ~(0x0100 ** (0x20 - temp28) - 0x01) & memory[temp29:temp29 + 0x20]; var3 = temp29 + 0x20; var4 = 0x20; var5 = memory[0x40:0x60]; var6 = var3 - var5; var7 = var5; var8 = 0x00; var9 = var1; var10 = !address(var9).code.length; if (!var10) { goto label_0809; } else { revert(memory[0x00:0x00]); } } } else { label_07AE: var temp30 = var12; memory[temp30 + var10:temp30 + var10 + 0x20] = memory[temp30 + var11:temp30 + var11 + 0x20]; var12 = temp30 + 0x20; if (var12 >= var9) { goto label_07BD; } else { goto label_07AE; } } } } else { var temp31 = returndata.length; memory[0x00:0x00 + temp31] = returndata[0x00:0x00 + temp31]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp32 = var7; var temp33 = var6 - temp32; memory[temp33:temp33 + 0x20] = ~(0x0100 ** (0x20 - temp32) - 0x01) & memory[temp33:temp33 + 0x20]; var3 = temp33 + 0x20; var4 = 0x20; var5 = memory[0x40:0x60]; var6 = var3 - var5; var7 = var5; var8 = var1; var9 = !address(var8).code.length; if (!var9) { goto label_0706; } else { revert(memory[0x00:0x00]); } } } else { label_06AD: var temp34 = var12; memory[temp34 + var10:temp34 + var10 + 0x20] = memory[temp34 + var11:temp34 + var11 + 0x20]; var12 = temp34 + 0x20; if (var12 >= var9) { goto label_06BC; } else { goto label_06AD; } } } function rely(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20] & 0x02 ** 0xa0 - 0x01; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; if (storage[keccak256(memory[0x00:0x40])] != 0x01) { revert(memory[0x00:0x00]); } memory[0x00:0x20] = arg0 & 0x02 ** 0xa0 - 0x01; memory[0x20:0x40] = 0x00; storage[keccak256(memory[0x00:0x40])] = 0x01; } function func_0302(var arg0, var arg1) returns (var r0) { var temp0 = arg0; arg0 = msg.data[temp0:temp0 + 0x20] & 0x02 ** 0xa0 - 0x01; var var0 = temp0; arg1 = var0 + arg1; var var1 = var0 + 0x40; var var2 = msg.data[var0 + 0x20:var0 + 0x20 + 0x20]; if (var2 > 0x0100000000) { revert(memory[0x00:0x00]); } var temp1 = var0 + var2; var2 = temp1; if (var2 + 0x20 > arg1) { revert(memory[0x00:0x00]); } var temp2 = var2; var temp3 = msg.data[temp2:temp2 + 0x20]; var2 = temp3; var temp4 = var1; var1 = temp2 + 0x20; var var3 = temp4; if ((var2 > 0x0100000000) | (var1 + var2 > arg1)) { revert(memory[0x00:0x00]); } var temp5 = var2; var temp6 = memory[0x40:0x60]; memory[0x40:0x60] = temp6 + (temp5 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp6:temp6 + 0x20] = temp5; var temp7 = temp6 + 0x20; memory[temp7:temp7 + temp5] = msg.data[var1:var1 + temp5]; memory[temp7 + temp5:temp7 + temp5 + 0x20] = 0x00; arg1 = temp6; r0 = func_088F(arg0, arg1); // Error: Could not resolve method call return address! } function setCache(var arg0, var arg1) returns (var r0) { arg0 = msg.data[arg0:arg0 + 0x20] & 0x02 ** 0xa0 - 0x01; arg1 = 0x00; memory[arg1:arg1 + 0x20] = msg.sender; memory[0x20:0x40] = arg1; if (storage[keccak256(memory[arg1:arg1 + 0x40])] != 0x01) { revert(memory[0x00:0x00]); } if (arg0 & 0x02 ** 0xa0 - 0x01) { storage[0x01] = (storage[0x01] & ~0xffffffffffffffffffffffffffffffffffffffff) | (arg0 & 0x02 ** 0xa0 - 0x01); return 0x01; } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; memory[temp0 + 0x04:temp0 + 0x04 + 0x20] = 0x20; memory[temp0 + 0x24:temp0 + 0x24 + 0x20] = 0x1f; memory[temp0 + 0x44:temp0 + 0x44 + 0x20] = 0x64732d70726f78792d63616368652d616464726573732d726571756972656400; var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + temp0 - temp1 + 0x64]); } } function deny(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20] & 0x02 ** 0xa0 - 0x01; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; if (storage[keccak256(memory[0x00:0x40])] != 0x01) { revert(memory[0x00:0x00]); } memory[0x00:0x20] = arg0 & 0x02 ** 0xa0 - 0x01; memory[0x20:0x40] = 0x00; storage[keccak256(memory[0x00:0x40])] = 0x00; } function func_04A7(var arg0, var arg1) returns (var r0) { var temp0 = arg0; var temp1 = temp0 + arg1; arg1 = temp0; arg0 = temp1; var var0 = arg1 + 0x20; var var1 = msg.data[arg1:arg1 + 0x20]; if (var1 > 0x0100000000) { revert(memory[0x00:0x00]); } var temp2 = arg1 + var1; var1 = temp2; if (var1 + 0x20 > arg0) { revert(memory[0x00:0x00]); } var temp3 = var1; var temp4 = msg.data[temp3:temp3 + 0x20]; var1 = temp4; var var2 = var0; var0 = temp3 + 0x20; if ((var1 > 0x0100000000) | (var0 + var1 > arg0)) { revert(memory[0x00:0x00]); } var temp5 = var2; var temp6 = var1; var temp7 = memory[0x40:0x60]; memory[0x40:0x60] = temp7 + (temp6 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp7:temp7 + 0x20] = temp6; var temp8 = temp7 + 0x20; memory[temp8:temp8 + temp6] = msg.data[var0:var0 + temp6]; memory[temp8 + temp6:temp8 + temp6 + 0x20] = 0x00; var temp9 = arg0; arg0 = temp7; var temp10 = arg1; arg1 = temp9; var0 = temp10; var1 = temp5 + 0x20; var2 = msg.data[temp5:temp5 + 0x20]; if (var2 > 0x0100000000) { revert(memory[0x00:0x00]); } var temp11 = var0 + var2; var2 = temp11; if (var2 + 0x20 > arg1) { revert(memory[0x00:0x00]); } var temp12 = var2; var temp13 = msg.data[temp12:temp12 + 0x20]; var2 = temp13; var var3 = var1; var1 = temp12 + 0x20; if ((var2 > 0x0100000000) | (var1 + var2 > arg1)) { revert(memory[0x00:0x00]); } var temp14 = var2; var temp15 = memory[0x40:0x60]; memory[0x40:0x60] = temp15 + (temp14 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp15:temp15 + 0x20] = temp14; var temp16 = temp15 + 0x20; memory[temp16:temp16 + temp14] = msg.data[var1:var1 + temp14]; memory[temp16 + temp14:temp16 + temp14 + 0x20] = 0x00; arg1 = temp15; var temp17 = memory[0x40:0x60]; memory[temp17:temp17 + 0x20] = 0x8bf4515c00000000000000000000000000000000000000000000000000000000; memory[temp17 + 0x04:temp17 + 0x04 + 0x20] = 0x20; var temp18 = arg0; memory[temp17 + 0x24:temp17 + 0x24 + 0x20] = memory[temp18:temp18 + 0x20]; var0 = 0x60; var1 = 0x00; var2 = storage[0x01] & 0x02 ** 0xa0 - 0x01; var3 = 0x8bf4515c; var var4 = temp18; var var5 = temp17 + 0x04; var var6 = var5; var var7 = temp17 + 0x44; var var9 = memory[var4:var4 + 0x20]; var var8 = var4 + 0x20; var var10 = var9; var var11 = var7; var var12 = var8; var var13 = var1; if (var13 >= var10) { label_0A73: var temp19 = var9; var7 = temp19 + var7; var8 = temp19 & 0x1f; if (!var8) { var4 = var7; var5 = 0x20; var6 = memory[0x40:0x60]; var7 = var4 - var6; var8 = var6; var9 = var2; var10 = !address(var9).code.length; if (var10) { revert(memory[0x00:0x00]); } label_0ABD: var temp20; temp20, memory[var6:var6 + var5] = address(var9).staticcall.gas(msg.gas)(memory[var8:var8 + var7]); var5 = !temp20; if (!var5) { var2 = memory[0x40:0x60]; var3 = returndata.length; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var1 = memory[var2:var2 + 0x20]; if (var1 & 0x02 ** 0xa0 - 0x01) { label_0BEF: var2 = 0x0bf9; var3 = var1; var4 = arg1; return func_088F(var3, var4); } else { var temp21 = memory[0x40:0x60]; memory[temp21:temp21 + 0x20] = 0x7ed0c3b200000000000000000000000000000000000000000000000000000000; var5 = temp21 + 0x04; memory[var5:var5 + 0x20] = 0x20; var temp22 = arg0; memory[temp21 + 0x24:temp21 + 0x24 + 0x20] = memory[temp22:temp22 + 0x20]; var2 = storage[0x01] & 0x02 ** 0xa0 - 0x01; var3 = 0x7ed0c3b2; var4 = temp22; var6 = var5; var7 = temp21 + 0x44; var8 = var4 + 0x20; var9 = memory[var4:var4 + 0x20]; var10 = var9; var11 = var7; var12 = var8; var13 = 0x00; if (var13 >= var10) { label_0B74: var temp23 = var9; var7 = temp23 + var7; var8 = temp23 & 0x1f; if (!var8) { var4 = var7; var5 = 0x20; var6 = memory[0x40:0x60]; var7 = var4 - var6; var8 = var6; var9 = 0x00; var10 = var2; var11 = !address(var10).code.length; if (var11) { revert(memory[0x00:0x00]); } label_0BC0: var temp24; temp24, memory[var6:var6 + var5] = address(var10).call.gas(msg.gas).value(var9)(memory[var8:var8 + var7]); var5 = !temp24; if (!var5) { var2 = memory[0x40:0x60]; var3 = returndata.length; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var1 = memory[var2:var2 + 0x20]; goto label_0BEF; } else { var temp25 = returndata.length; memory[0x00:0x00 + temp25] = returndata[0x00:0x00 + temp25]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp26 = var8; var temp27 = var7 - temp26; memory[temp27:temp27 + 0x20] = ~(0x0100 ** (0x20 - temp26) - 0x01) & memory[temp27:temp27 + 0x20]; var4 = temp27 + 0x20; var5 = 0x20; var6 = memory[0x40:0x60]; var7 = var4 - var6; var8 = var6; var9 = 0x00; var10 = var2; var11 = !address(var10).code.length; if (!var11) { goto label_0BC0; } else { revert(memory[0x00:0x00]); } } } else { label_0B65: var temp28 = var13; memory[temp28 + var11:temp28 + var11 + 0x20] = memory[temp28 + var12:temp28 + var12 + 0x20]; var13 = temp28 + 0x20; if (var13 >= var10) { goto label_0B74; } else { goto label_0B65; } } } } else { var temp29 = returndata.length; memory[0x00:0x00 + temp29] = returndata[0x00:0x00 + temp29]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp30 = var8; var temp31 = var7 - temp30; memory[temp31:temp31 + 0x20] = ~(0x0100 ** (0x20 - temp30) - 0x01) & memory[temp31:temp31 + 0x20]; var4 = temp31 + 0x20; var5 = 0x20; var6 = memory[0x40:0x60]; var7 = var4 - var6; var8 = var6; var9 = var2; var10 = !address(var9).code.length; if (!var10) { goto label_0ABD; } else { revert(memory[0x00:0x00]); } } } else { label_0A64: var temp32 = var13; memory[temp32 + var11:temp32 + var11 + 0x20] = memory[temp32 + var12:temp32 + var12 + 0x20]; var13 = temp32 + 0x20; if (var13 >= var10) { goto label_0A73; } else { goto label_0A64; } } } function wards(var arg0, var arg1) returns (var arg0) { arg0 = msg.data[arg0:arg0 + 0x20] & 0x02 ** 0xa0 - 0x01; memory[0x20:0x40] = 0x00; memory[0x00:0x20] = arg0; return storage[keccak256(memory[0x00:0x40])]; } function func_0603(var arg0, var arg1) { memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; if (storage[keccak256(memory[0x00:0x40])] != 0x01) { revert(memory[0x00:0x00]); } var temp0 = arg1; var temp1; temp1, memory[0x00:0x00] = address(arg0).delegatecall.gas(msg.gas)(memory[temp0 + 0x20:temp0 + 0x20 + memory[temp0:temp0 + 0x20]]); var var1 = !temp1; if (var1 == 0x01) { revert(memory[0x00:0x00]); } else { return; } } function cache() returns (var r0) { return storage[0x01] & 0x02 ** 0xa0 - 0x01; } function func_088F(var arg0, var arg1) returns (var r0) { memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; var var0 = 0x60; if (storage[keccak256(memory[0x00:0x40])] != 0x01) { revert(memory[0x00:0x00]); } var temp0 = arg1; var temp1; temp1, memory[0x00:0x00] = address(arg0).delegatecall.gas(msg.gas)(memory[temp0 + 0x20:temp0 + 0x20 + memory[temp0:temp0 + 0x20]]); var temp2 = returndata.length; var var2 = temp2; var temp3 = memory[0x40:0x60]; var0 = temp3; memory[0x40:0x60] = var0 + (var2 + 0x20 + 0x1f & ~0x1f); memory[var0:var0 + 0x20] = var2; memory[var0 + 0x20:var0 + 0x20 + var2] = returndata[0x00:0x00 + var2]; var var3 = !temp1; if (var3 == 0x01) { revert(memory[var0 + 0x20:var0 + 0x20 + var2]); } else { return var0; } } }

Disassembly

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x00a3 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x00a3, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 002E 90 SWAP1 002F 04 DIV 0030 80 DUP1 0031 63 PUSH4 0x78e111f6 0036 11 GT 0037 61 PUSH2 0x0076 003A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @002F stack[0] = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x0076, if 0x78e111f6 > msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 label_003B: // Incoming jump from 0x003A, if not 0x78e111f6 > msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @003B stack[-1] } 003B 80 DUP1 003C 63 PUSH4 0x78e111f6 0041 14 EQ 0042 61 PUSH2 0x02ec 0045 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ec, if 0x78e111f6 == stack[-1] label_0046: // Incoming jump from 0x0045, if not 0x78e111f6 == stack[-1] // Inputs[1] { @0046 stack[-1] } 0046 80 DUP1 0047 63 PUSH4 0x948f5076 004C 14 EQ 004D 61 PUSH2 0x0417 0050 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0417, if 0x948f5076 == stack[-1] label_0051: // Incoming jump from 0x0050, if not 0x948f5076 == stack[-1] // Inputs[1] { @0051 stack[-1] } 0051 80 DUP1 0052 63 PUSH4 0x9c52a7f1 0057 14 EQ 0058 61 PUSH2 0x045e 005B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x045e, if 0x9c52a7f1 == stack[-1] label_005C: // Incoming jump from 0x005B, if not 0x9c52a7f1 == stack[-1] // Inputs[1] { @005C stack[-1] } 005C 80 DUP1 005D 63 PUSH4 0xa90e8731 0062 14 EQ 0063 61 PUSH2 0x0491 0066 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0491, if 0xa90e8731 == stack[-1] label_0067: // Incoming jump from 0x0066, if not 0xa90e8731 == stack[-1] // Inputs[1] { @0067 stack[-1] } 0067 80 DUP1 0068 63 PUSH4 0xbf353dbb 006D 14 EQ 006E 61 PUSH2 0x05be 0071 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05be, if 0xbf353dbb == stack[-1] label_0072: // Incoming jump from 0x0071, if not 0xbf353dbb == stack[-1] 0072 61 PUSH2 0x00a3 0075 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00a3 label_0076: // Incoming jump from 0x003A, if 0x78e111f6 > msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0077 stack[-1] } 0076 5B JUMPDEST 0077 80 DUP1 0078 63 PUSH4 0x1cff79cd 007D 14 EQ 007E 61 PUSH2 0x00a5 0081 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a5, if 0x1cff79cd == stack[-1] label_0082: // Incoming jump from 0x0081, if not 0x1cff79cd == stack[-1] // Inputs[1] { @0082 stack[-1] } 0082 80 DUP1 0083 63 PUSH4 0x1f6a1eb9 0088 14 EQ 0089 61 PUSH2 0x015b 008C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x015b, if 0x1f6a1eb9 == stack[-1] label_008D: // Incoming jump from 0x008C, if not 0x1f6a1eb9 == stack[-1] // Inputs[1] { @008D stack[-1] } 008D 80 DUP1 008E 63 PUSH4 0x60c7d295 0093 14 EQ 0094 61 PUSH2 0x0288 0097 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0288, if 0x60c7d295 == stack[-1] label_0098: // Incoming jump from 0x0097, if not 0x60c7d295 == stack[-1] // Inputs[1] { @0098 stack[-1] } 0098 80 DUP1 0099 63 PUSH4 0x65fae35e 009E 14 EQ 009F 61 PUSH2 0x02b9 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b9, if 0x65fae35e == stack[-1] label_00A3: // Incoming jump from 0x0075 // Incoming return from call to 0x0481 at 0x047C // Incoming return from call to 0x02DC at 0x02D7 // Incoming return from call to 0x00BB at 0x00B6 // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x00A2, if not 0x65fae35e == stack[-1] // Incoming return from call to 0x0171 at 0x016C 00A3 5B JUMPDEST 00A4 00 *STOP // Stack delta = +0 // Outputs[1] { @00A4 stop(); } // Block terminates label_00A5: // Incoming jump from 0x0081, if 0x1cff79cd == stack[-1] // Inputs[1] { @00AC msg.data.length } 00A5 5B JUMPDEST 00A6 61 PUSH2 0x00a3 00A9 60 PUSH1 0x04 00AB 80 DUP1 00AC 36 CALLDATASIZE 00AD 03 SUB 00AE 60 PUSH1 0x40 00B0 81 DUP2 00B1 10 LT 00B2 15 ISZERO 00B3 61 PUSH2 0x00bb 00B6 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @00A6 stack[0] = 0x00a3 // @00A9 stack[1] = 0x04 // @00AD stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x00bb, returns to 0x00A3, if !(msg.data.length - 0x04 < 0x40) label_00B7: // Incoming jump from 0x00B6, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @00BA memory[0x00:0x00] } 00B7 60 PUSH1 0x00 00B9 80 DUP1 00BA FD *REVERT // Stack delta = +0 // Outputs[1] { @00BA revert(memory[0x00:0x00]); } // Block terminates label_00BB: // Incoming call from 0x00B6, returns to 0x00A3, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @00C4 stack[-2] // @00C5 msg.data[stack[-2]:stack[-2] + 0x20] // @00C8 stack[-1] // @00D4 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } 00BB 5B JUMPDEST 00BC 60 PUSH1 0x01 00BE 60 PUSH1 0xa0 00C0 60 PUSH1 0x02 00C2 0A EXP 00C3 03 SUB 00C4 82 DUP3 00C5 35 CALLDATALOAD 00C6 16 AND 00C7 91 SWAP2 00C8 90 SWAP1 00C9 81 DUP2 00CA 01 ADD 00CB 90 SWAP1 00CC 60 PUSH1 0x40 00CE 81 DUP2 00CF 01 ADD 00D0 60 PUSH1 0x20 00D2 82 DUP3 00D3 01 ADD 00D4 35 CALLDATALOAD 00D5 64 PUSH5 0x0100000000 00DB 81 DUP2 00DC 11 GT 00DD 15 ISZERO 00DE 61 PUSH2 0x00e6 00E1 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @00C7 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & 0x02 ** 0xa0 - 0x01 // @00CB stack[0] = stack[-2] // @00CB stack[-1] = stack[-2] + stack[-1] // @00CF stack[1] = stack[-2] + 0x40 // @00D4 stack[2] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x00e6, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) label_00E2: // Incoming jump from 0x00E1, if not !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) // Inputs[1] { @00E5 memory[0x00:0x00] } 00E2 60 PUSH1 0x00 00E4 80 DUP1 00E5 FD *REVERT // Stack delta = +0 // Outputs[1] { @00E5 revert(memory[0x00:0x00]); } // Block terminates label_00E6: // Incoming jump from 0x00E1, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) // Inputs[3] // { // @00E7 stack[-3] // @00E8 stack[-1] // @00E9 stack[-4] // } 00E6 5B JUMPDEST 00E7 82 DUP3 00E8 01 ADD 00E9 83 DUP4 00EA 60 PUSH1 0x20 00EC 82 DUP3 00ED 01 ADD 00EE 11 GT 00EF 15 ISZERO 00F0 61 PUSH2 0x00f8 00F3 57 *JUMPI // Stack delta = +0 // Outputs[1] { @00E8 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x00f8, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_00F4: // Incoming jump from 0x00F3, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @00F7 memory[0x00:0x00] } 00F4 60 PUSH1 0x00 00F6 80 DUP1 00F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F7 revert(memory[0x00:0x00]); } // Block terminates label_00F8: // Incoming jump from 0x00F3, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @00F9 stack[-1] // @00FA msg.data[stack[-1]:stack[-1] + 0x20] // @00FF stack[-2] // @0100 stack[-4] // } 00F8 5B JUMPDEST 00F9 80 DUP1 00FA 35 CALLDATALOAD 00FB 90 SWAP1 00FC 60 PUSH1 0x20 00FE 01 ADD 00FF 91 SWAP2 0100 84 DUP5 0101 60 PUSH1 0x01 0103 83 DUP4 0104 02 MUL 0105 84 DUP5 0106 01 ADD 0107 11 GT 0108 64 PUSH5 0x0100000000 010E 83 DUP4 010F 11 GT 0110 17 OR 0111 15 ISZERO 0112 61 PUSH2 0x011a 0115 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @00FB stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @00FF stack[0] = stack[-2] // @00FF stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x011a, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0116: // Incoming jump from 0x0115, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0119 memory[0x00:0x00] } 0116 60 PUSH1 0x00 0118 80 DUP1 0119 FD *REVERT // Stack delta = +0 // Outputs[1] { @0119 revert(memory[0x00:0x00]); } // Block terminates label_011A: // Incoming jump from 0x0115, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @011B stack[-1] // @011B stack[-3] // @011C stack[-2] // @012D memory[0x40:0x60] // @0144 msg.data[stack[-3]:stack[-3] + stack[-2]] // @014F stack[-5] // @0154 stack[-4] // } 011A 5B JUMPDEST 011B 91 SWAP2 011C 90 SWAP1 011D 80 DUP1 011E 80 DUP1 011F 60 PUSH1 0x1f 0121 01 ADD 0122 60 PUSH1 0x20 0124 80 DUP1 0125 91 SWAP2 0126 04 DIV 0127 02 MUL 0128 60 PUSH1 0x20 012A 01 ADD 012B 60 PUSH1 0x40 012D 51 MLOAD 012E 90 SWAP1 012F 81 DUP2 0130 01 ADD 0131 60 PUSH1 0x40 0133 52 MSTORE 0134 80 DUP1 0135 93 SWAP4 0136 92 SWAP3 0137 91 SWAP2 0138 90 SWAP1 0139 81 DUP2 013A 81 DUP2 013B 52 MSTORE 013C 60 PUSH1 0x20 013E 01 ADD 013F 83 DUP4 0140 83 DUP4 0141 80 DUP1 0142 82 DUP3 0143 84 DUP5 0144 37 CALLDATACOPY 0145 60 PUSH1 0x00 0147 92 SWAP3 0148 01 ADD 0149 91 SWAP2 014A 90 SWAP1 014B 91 SWAP2 014C 52 MSTORE 014D 50 POP 014E 92 SWAP3 014F 95 SWAP6 0150 50 POP 0151 61 PUSH2 0x0603 0154 94 SWAP5 0155 50 POP 0156 50 POP 0157 50 POP 0158 50 POP 0159 50 POP 015A 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0133 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @013B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0144 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @014C memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @014F stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0603 label_015B: // Incoming jump from 0x008C, if 0x1f6a1eb9 == stack[-1] // Inputs[1] { @0162 msg.data.length } 015B 5B JUMPDEST 015C 61 PUSH2 0x00a3 015F 60 PUSH1 0x04 0161 80 DUP1 0162 36 CALLDATASIZE 0163 03 SUB 0164 60 PUSH1 0x40 0166 81 DUP2 0167 10 LT 0168 15 ISZERO 0169 61 PUSH2 0x0171 016C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @015C stack[0] = 0x00a3 // @015F stack[1] = 0x04 // @0163 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0171, returns to 0x00A3, if !(msg.data.length - 0x04 < 0x40) label_016D: // Incoming jump from 0x016C, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0170 memory[0x00:0x00] } 016D 60 PUSH1 0x00 016F 80 DUP1 0170 FD *REVERT // Stack delta = +0 // Outputs[1] { @0170 revert(memory[0x00:0x00]); } // Block terminates label_0171: // Incoming call from 0x016C, returns to 0x00A3, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0172 stack[-2] // @0173 stack[-1] // @017A msg.data[stack[-2]:stack[-2] + 0x20] // } 0171 5B JUMPDEST 0172 81 DUP2 0173 01 ADD 0174 90 SWAP1 0175 60 PUSH1 0x20 0177 81 DUP2 0178 01 ADD 0179 81 DUP2 017A 35 CALLDATALOAD 017B 64 PUSH5 0x0100000000 0181 81 DUP2 0182 11 GT 0183 15 ISZERO 0184 61 PUSH2 0x018c 0187 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0174 stack[-1] = stack[-2] // @0174 stack[-2] = stack[-2] + stack[-1] // @0178 stack[0] = stack[-2] + 0x20 // @017A stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x018c, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_0188: // Incoming jump from 0x0187, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @018B memory[0x00:0x00] } 0188 60 PUSH1 0x00 018A 80 DUP1 018B FD *REVERT // Stack delta = +0 // Outputs[1] { @018B revert(memory[0x00:0x00]); } // Block terminates label_018C: // Incoming jump from 0x0187, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @018D stack[-3] // @018E stack[-1] // @018F stack[-4] // } 018C 5B JUMPDEST 018D 82 DUP3 018E 01 ADD 018F 83 DUP4 0190 60 PUSH1 0x20 0192 82 DUP3 0193 01 ADD 0194 11 GT 0195 15 ISZERO 0196 61 PUSH2 0x019e 0199 57 *JUMPI // Stack delta = +0 // Outputs[1] { @018E stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x019e, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_019A: // Incoming jump from 0x0199, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @019D memory[0x00:0x00] } 019A 60 PUSH1 0x00 019C 80 DUP1 019D FD *REVERT // Stack delta = +0 // Outputs[1] { @019D revert(memory[0x00:0x00]); } // Block terminates label_019E: // Incoming jump from 0x0199, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @019F stack[-1] // @01A0 msg.data[stack[-1]:stack[-1] + 0x20] // @01A5 stack[-2] // @01A6 stack[-4] // } 019E 5B JUMPDEST 019F 80 DUP1 01A0 35 CALLDATALOAD 01A1 90 SWAP1 01A2 60 PUSH1 0x20 01A4 01 ADD 01A5 91 SWAP2 01A6 84 DUP5 01A7 60 PUSH1 0x01 01A9 83 DUP4 01AA 02 MUL 01AB 84 DUP5 01AC 01 ADD 01AD 11 GT 01AE 64 PUSH5 0x0100000000 01B4 83 DUP4 01B5 11 GT 01B6 17 OR 01B7 15 ISZERO 01B8 61 PUSH2 0x01c0 01BB 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @01A1 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @01A5 stack[0] = stack[-2] // @01A5 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x01c0, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_01BC: // Incoming jump from 0x01BB, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @01BF memory[0x00:0x00] } 01BC 60 PUSH1 0x00 01BE 80 DUP1 01BF FD *REVERT // Stack delta = +0 // Outputs[1] { @01BF revert(memory[0x00:0x00]); } // Block terminates label_01C0: // Incoming jump from 0x01BB, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[8] // { // @01C1 stack[-1] // @01C1 stack[-3] // @01C2 stack[-2] // @01D3 memory[0x40:0x60] // @01EA msg.data[stack[-3]:stack[-3] + stack[-2]] // @01F5 stack[-5] // @01F6 stack[-4] // @01FE msg.data[stack[-1]:stack[-1] + 0x20] // } 01C0 5B JUMPDEST 01C1 91 SWAP2 01C2 90 SWAP1 01C3 80 DUP1 01C4 80 DUP1 01C5 60 PUSH1 0x1f 01C7 01 ADD 01C8 60 PUSH1 0x20 01CA 80 DUP1 01CB 91 SWAP2 01CC 04 DIV 01CD 02 MUL 01CE 60 PUSH1 0x20 01D0 01 ADD 01D1 60 PUSH1 0x40 01D3 51 MLOAD 01D4 90 SWAP1 01D5 81 DUP2 01D6 01 ADD 01D7 60 PUSH1 0x40 01D9 52 MSTORE 01DA 80 DUP1 01DB 93 SWAP4 01DC 92 SWAP3 01DD 91 SWAP2 01DE 90 SWAP1 01DF 81 DUP2 01E0 81 DUP2 01E1 52 MSTORE 01E2 60 PUSH1 0x20 01E4 01 ADD 01E5 83 DUP4 01E6 83 DUP4 01E7 80 DUP1 01E8 82 DUP3 01E9 84 DUP5 01EA 37 CALLDATACOPY 01EB 60 PUSH1 0x00 01ED 92 SWAP3 01EE 01 ADD 01EF 91 SWAP2 01F0 90 SWAP1 01F1 91 SWAP2 01F2 52 MSTORE 01F3 50 POP 01F4 92 SWAP3 01F5 95 SWAP6 01F6 94 SWAP5 01F7 93 SWAP4 01F8 60 PUSH1 0x20 01FA 81 DUP2 01FB 01 ADD 01FC 93 SWAP4 01FD 50 POP 01FE 35 CALLDATALOAD 01FF 91 SWAP2 0200 50 POP 0201 50 POP 0202 64 PUSH5 0x0100000000 0208 81 DUP2 0209 11 GT 020A 15 ISZERO 020B 61 PUSH2 0x0213 020E 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @01D9 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @01E1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @01EA memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @01F2 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @01F5 stack[-5] = memory[0x40:0x60] // @01F6 stack[-4] = stack[-5] // @01F7 stack[-3] = stack[-4] // @01FC stack[-2] = stack[-1] + 0x20 // @01FF stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0213, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) label_020F: // Incoming jump from 0x020E, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @0212 memory[0x00:0x00] } 020F 60 PUSH1 0x00 0211 80 DUP1 0212 FD *REVERT // Stack delta = +0 // Outputs[1] { @0212 revert(memory[0x00:0x00]); } // Block terminates label_0213: // Incoming jump from 0x020E, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @0214 stack[-3] // @0215 stack[-1] // @0216 stack[-4] // } 0213 5B JUMPDEST 0214 82 DUP3 0215 01 ADD 0216 83 DUP4 0217 60 PUSH1 0x20 0219 82 DUP3 021A 01 ADD 021B 11 GT 021C 15 ISZERO 021D 61 PUSH2 0x0225 0220 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0215 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0225, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0221: // Incoming jump from 0x0220, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0224 memory[0x00:0x00] } 0221 60 PUSH1 0x00 0223 80 DUP1 0224 FD *REVERT // Stack delta = +0 // Outputs[1] { @0224 revert(memory[0x00:0x00]); } // Block terminates label_0225: // Incoming jump from 0x0220, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0226 stack[-1] // @0227 msg.data[stack[-1]:stack[-1] + 0x20] // @022C stack[-2] // @022D stack[-4] // } 0225 5B JUMPDEST 0226 80 DUP1 0227 35 CALLDATALOAD 0228 90 SWAP1 0229 60 PUSH1 0x20 022B 01 ADD 022C 91 SWAP2 022D 84 DUP5 022E 60 PUSH1 0x01 0230 83 DUP4 0231 02 MUL 0232 84 DUP5 0233 01 ADD 0234 11 GT 0235 64 PUSH5 0x0100000000 023B 83 DUP4 023C 11 GT 023D 17 OR 023E 15 ISZERO 023F 61 PUSH2 0x0247 0242 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0228 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @022C stack[0] = stack[-2] // @022C stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0247, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0243: // Incoming jump from 0x0242, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0246 memory[0x00:0x00] } 0243 60 PUSH1 0x00 0245 80 DUP1 0246 FD *REVERT // Stack delta = +0 // Outputs[1] { @0246 revert(memory[0x00:0x00]); } // Block terminates label_0247: // Incoming jump from 0x0242, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @0248 stack[-1] // @0248 stack[-3] // @0249 stack[-2] // @025A memory[0x40:0x60] // @0271 msg.data[stack[-3]:stack[-3] + stack[-2]] // @027C stack[-5] // @0281 stack[-4] // } 0247 5B JUMPDEST 0248 91 SWAP2 0249 90 SWAP1 024A 80 DUP1 024B 80 DUP1 024C 60 PUSH1 0x1f 024E 01 ADD 024F 60 PUSH1 0x20 0251 80 DUP1 0252 91 SWAP2 0253 04 DIV 0254 02 MUL 0255 60 PUSH1 0x20 0257 01 ADD 0258 60 PUSH1 0x40 025A 51 MLOAD 025B 90 SWAP1 025C 81 DUP2 025D 01 ADD 025E 60 PUSH1 0x40 0260 52 MSTORE 0261 80 DUP1 0262 93 SWAP4 0263 92 SWAP3 0264 91 SWAP2 0265 90 SWAP1 0266 81 DUP2 0267 81 DUP2 0268 52 MSTORE 0269 60 PUSH1 0x20 026B 01 ADD 026C 83 DUP4 026D 83 DUP4 026E 80 DUP1 026F 82 DUP3 0270 84 DUP5 0271 37 CALLDATACOPY 0272 60 PUSH1 0x00 0274 92 SWAP3 0275 01 ADD 0276 91 SWAP2 0277 90 SWAP1 0278 91 SWAP2 0279 52 MSTORE 027A 50 POP 027B 92 SWAP3 027C 95 SWAP6 027D 50 POP 027E 61 PUSH2 0x0645 0281 94 SWAP5 0282 50 POP 0283 50 POP 0284 50 POP 0285 50 POP 0286 50 POP 0287 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0260 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0268 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0271 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0279 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @027C stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0645 label_0288: // Incoming jump from 0x0097, if 0x60c7d295 == stack[-1] // Inputs[1] { @0289 msg.value } 0288 5B JUMPDEST 0289 34 CALLVALUE 028A 80 DUP1 028B 15 ISZERO 028C 61 PUSH2 0x0294 028F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0289 stack[0] = msg.value } // Block ends with conditional jump to 0x0294, if !msg.value label_0290: // Incoming jump from 0x028F, if not !msg.value // Inputs[1] { @0293 memory[0x00:0x00] } 0290 60 PUSH1 0x00 0292 80 DUP1 0293 FD *REVERT // Stack delta = +0 // Outputs[1] { @0293 revert(memory[0x00:0x00]); } // Block terminates label_0294: // Incoming jump from 0x028F, if !msg.value 0294 5B JUMPDEST 0295 50 POP 0296 61 PUSH2 0x029d 0299 61 PUSH2 0x0847 029C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0296 stack[-1] = 0x029d } // Block ends with call to 0x0847, returns to 0x029D label_029D: // Incoming return from call to 0x0847 at 0x029C // Inputs[4] // { // @02A1 memory[0x40:0x60] // @02AB stack[-1] // @02AF memory[0x40:0x60] // @02B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 029D 5B JUMPDEST 029E 60 PUSH1 0x40 02A0 80 DUP1 02A1 51 MLOAD 02A2 60 PUSH1 0x01 02A4 60 PUSH1 0xa0 02A6 60 PUSH1 0x02 02A8 0A EXP 02A9 03 SUB 02AA 90 SWAP1 02AB 92 SWAP3 02AC 16 AND 02AD 82 DUP3 02AE 52 MSTORE 02AF 51 MLOAD 02B0 90 SWAP1 02B1 81 DUP2 02B2 90 SWAP1 02B3 03 SUB 02B4 60 PUSH1 0x20 02B6 01 ADD 02B7 90 SWAP1 02B8 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02AE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0x02 ** 0xa0 - 0x01 // @02B8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_02B9: // Incoming jump from 0x00A2, if 0x65fae35e == stack[-1] // Inputs[1] { @02BA msg.value } 02B9 5B JUMPDEST 02BA 34 CALLVALUE 02BB 80 DUP1 02BC 15 ISZERO 02BD 61 PUSH2 0x02c5 02C0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02BA stack[0] = msg.value } // Block ends with conditional jump to 0x02c5, if !msg.value label_02C1: // Incoming jump from 0x02C0, if not !msg.value // Inputs[1] { @02C4 memory[0x00:0x00] } 02C1 60 PUSH1 0x00 02C3 80 DUP1 02C4 FD *REVERT // Stack delta = +0 // Outputs[1] { @02C4 revert(memory[0x00:0x00]); } // Block terminates label_02C5: // Incoming jump from 0x02C0, if !msg.value // Inputs[1] { @02CD msg.data.length } 02C5 5B JUMPDEST 02C6 50 POP 02C7 61 PUSH2 0x00a3 02CA 60 PUSH1 0x04 02CC 80 DUP1 02CD 36 CALLDATASIZE 02CE 03 SUB 02CF 60 PUSH1 0x20 02D1 81 DUP2 02D2 10 LT 02D3 15 ISZERO 02D4 61 PUSH2 0x02dc 02D7 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @02C7 stack[-1] = 0x00a3 // @02CA stack[0] = 0x04 // @02CE stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x02dc, returns to 0x00A3, if !(msg.data.length - 0x04 < 0x20) label_02D8: // Incoming jump from 0x02D7, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @02DB memory[0x00:0x00] } 02D8 60 PUSH1 0x00 02DA 80 DUP1 02DB FD *REVERT // Stack delta = +0 // Outputs[1] { @02DB revert(memory[0x00:0x00]); } // Block terminates label_02DC: // Incoming call from 0x02D7, returns to 0x00A3, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @02DE stack[-2] // @02DE msg.data[stack[-2]:stack[-2] + 0x20] // } 02DC 5B JUMPDEST 02DD 50 POP 02DE 35 CALLDATALOAD 02DF 60 PUSH1 0x01 02E1 60 PUSH1 0xa0 02E3 60 PUSH1 0x02 02E5 0A EXP 02E6 03 SUB 02E7 16 AND 02E8 61 PUSH2 0x0856 02EB 56 *JUMP // Stack delta = -1 // Outputs[1] { @02E7 stack[-2] = 0x02 ** 0xa0 - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0856 label_02EC: // Incoming jump from 0x0045, if 0x78e111f6 == stack[-1] // Inputs[1] { @02F3 msg.data.length } 02EC 5B JUMPDEST 02ED 61 PUSH2 0x03a2 02F0 60 PUSH1 0x04 02F2 80 DUP1 02F3 36 CALLDATASIZE 02F4 03 SUB 02F5 60 PUSH1 0x40 02F7 81 DUP2 02F8 10 LT 02F9 15 ISZERO 02FA 61 PUSH2 0x0302 02FD 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @02ED stack[0] = 0x03a2 // @02F0 stack[1] = 0x04 // @02F4 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0302, returns to 0x03A2, if !(msg.data.length - 0x04 < 0x40) label_02FE: // Incoming jump from 0x02FD, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0301 memory[0x00:0x00] } 02FE 60 PUSH1 0x00 0300 80 DUP1 0301 FD *REVERT // Stack delta = +0 // Outputs[1] { @0301 revert(memory[0x00:0x00]); } // Block terminates label_0302: // Incoming call from 0x02FD, returns to 0x03A2, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @030B stack[-2] // @030C msg.data[stack[-2]:stack[-2] + 0x20] // @030F stack[-1] // @031B msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } 0302 5B JUMPDEST 0303 60 PUSH1 0x01 0305 60 PUSH1 0xa0 0307 60 PUSH1 0x02 0309 0A EXP 030A 03 SUB 030B 82 DUP3 030C 35 CALLDATALOAD 030D 16 AND 030E 91 SWAP2 030F 90 SWAP1 0310 81 DUP2 0311 01 ADD 0312 90 SWAP1 0313 60 PUSH1 0x40 0315 81 DUP2 0316 01 ADD 0317 60 PUSH1 0x20 0319 82 DUP3 031A 01 ADD 031B 35 CALLDATALOAD 031C 64 PUSH5 0x0100000000 0322 81 DUP2 0323 11 GT 0324 15 ISZERO 0325 61 PUSH2 0x032d 0328 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @030E stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & 0x02 ** 0xa0 - 0x01 // @0312 stack[0] = stack[-2] // @0312 stack[-1] = stack[-2] + stack[-1] // @0316 stack[1] = stack[-2] + 0x40 // @031B stack[2] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x032d, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) label_0329: // Incoming jump from 0x0328, if not !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) // Inputs[1] { @032C memory[0x00:0x00] } 0329 60 PUSH1 0x00 032B 80 DUP1 032C FD *REVERT // Stack delta = +0 // Outputs[1] { @032C revert(memory[0x00:0x00]); } // Block terminates label_032D: // Incoming jump from 0x0328, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) // Inputs[3] // { // @032E stack[-3] // @032F stack[-1] // @0330 stack[-4] // } 032D 5B JUMPDEST 032E 82 DUP3 032F 01 ADD 0330 83 DUP4 0331 60 PUSH1 0x20 0333 82 DUP3 0334 01 ADD 0335 11 GT 0336 15 ISZERO 0337 61 PUSH2 0x033f 033A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @032F stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x033f, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_033B: // Incoming jump from 0x033A, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @033E memory[0x00:0x00] } 033B 60 PUSH1 0x00 033D 80 DUP1 033E FD *REVERT // Stack delta = +0 // Outputs[1] { @033E revert(memory[0x00:0x00]); } // Block terminates label_033F: // Incoming jump from 0x033A, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0340 stack[-1] // @0341 msg.data[stack[-1]:stack[-1] + 0x20] // @0346 stack[-2] // @0347 stack[-4] // } 033F 5B JUMPDEST 0340 80 DUP1 0341 35 CALLDATALOAD 0342 90 SWAP1 0343 60 PUSH1 0x20 0345 01 ADD 0346 91 SWAP2 0347 84 DUP5 0348 60 PUSH1 0x01 034A 83 DUP4 034B 02 MUL 034C 84 DUP5 034D 01 ADD 034E 11 GT 034F 64 PUSH5 0x0100000000 0355 83 DUP4 0356 11 GT 0357 17 OR 0358 15 ISZERO 0359 61 PUSH2 0x0361 035C 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0342 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0346 stack[0] = stack[-2] // @0346 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0361, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_035D: // Incoming jump from 0x035C, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0360 memory[0x00:0x00] } 035D 60 PUSH1 0x00 035F 80 DUP1 0360 FD *REVERT // Stack delta = +0 // Outputs[1] { @0360 revert(memory[0x00:0x00]); } // Block terminates label_0361: // Incoming jump from 0x035C, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @0362 stack[-3] // @0362 stack[-1] // @0363 stack[-2] // @0374 memory[0x40:0x60] // @038B msg.data[stack[-3]:stack[-3] + stack[-2]] // @0396 stack[-5] // @039B stack[-4] // } 0361 5B JUMPDEST 0362 91 SWAP2 0363 90 SWAP1 0364 80 DUP1 0365 80 DUP1 0366 60 PUSH1 0x1f 0368 01 ADD 0369 60 PUSH1 0x20 036B 80 DUP1 036C 91 SWAP2 036D 04 DIV 036E 02 MUL 036F 60 PUSH1 0x20 0371 01 ADD 0372 60 PUSH1 0x40 0374 51 MLOAD 0375 90 SWAP1 0376 81 DUP2 0377 01 ADD 0378 60 PUSH1 0x40 037A 52 MSTORE 037B 80 DUP1 037C 93 SWAP4 037D 92 SWAP3 037E 91 SWAP2 037F 90 SWAP1 0380 81 DUP2 0381 81 DUP2 0382 52 MSTORE 0383 60 PUSH1 0x20 0385 01 ADD 0386 83 DUP4 0387 83 DUP4 0388 80 DUP1 0389 82 DUP3 038A 84 DUP5 038B 37 CALLDATACOPY 038C 60 PUSH1 0x00 038E 92 SWAP3 038F 01 ADD 0390 91 SWAP2 0391 90 SWAP1 0392 91 SWAP2 0393 52 MSTORE 0394 50 POP 0395 92 SWAP3 0396 95 SWAP6 0397 50 POP 0398 61 PUSH2 0x088f 039B 94 SWAP5 039C 50 POP 039D 50 POP 039E 50 POP 039F 50 POP 03A0 50 POP 03A1 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @037A memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0382 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @038B memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0393 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0396 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x088f label_03A2: // Incoming return from call to 0x0302 at 0x02FD // Incoming return from call to 0x04A7 at 0x04A2 // Inputs[4] // { // @03A6 memory[0x40:0x60] // @03AC stack[-1] // @03AD memory[stack[-1]:stack[-1] + 0x20] // @03B3 memory[stack[-1]:stack[-1] + 0x20] // } 03A2 5B JUMPDEST 03A3 60 PUSH1 0x40 03A5 80 DUP1 03A6 51 MLOAD 03A7 60 PUSH1 0x20 03A9 80 DUP1 03AA 82 DUP3 03AB 52 MSTORE 03AC 83 DUP4 03AD 51 MLOAD 03AE 81 DUP2 03AF 83 DUP4 03B0 01 ADD 03B1 52 MSTORE 03B2 83 DUP4 03B3 51 MLOAD 03B4 91 SWAP2 03B5 92 SWAP3 03B6 83 DUP4 03B7 92 SWAP3 03B8 90 SWAP1 03B9 83 DUP4 03BA 01 ADD 03BB 91 SWAP2 03BC 85 DUP6 03BD 01 ADD 03BE 90 SWAP1 03BF 80 DUP1 03C0 83 DUP4 03C1 83 DUP4 03C2 60 PUSH1 0x00 03C4 5B JUMPDEST 03C5 83 DUP4 03C6 81 DUP2 03C7 10 LT 03C8 15 ISZERO 03C9 61 PUSH2 0x03dc 03CC 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @03AB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @03B1 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @03B5 stack[0] = memory[0x40:0x60] // @03B7 stack[1] = memory[0x40:0x60] // @03BB stack[2] = memory[0x40:0x60] + 0x40 // @03BE stack[3] = stack[-1] + 0x20 // @03BE stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @03BF stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @03C0 stack[6] = memory[0x40:0x60] + 0x40 // @03C1 stack[7] = stack[-1] + 0x20 // @03C2 stack[8] = 0x00 // } // Block ends with conditional jump to 0x03dc, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_03CD: // Incoming jump from 0x03CC, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x03CC, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @03CD stack[-2] // @03CE stack[-1] // @03D0 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @03D1 stack[-3] // } 03CD 81 DUP2 03CE 81 DUP2 03CF 01 ADD 03D0 51 MLOAD 03D1 83 DUP4 03D2 82 DUP3 03D3 01 ADD 03D4 52 MSTORE 03D5 60 PUSH1 0x20 03D7 01 ADD 03D8 61 PUSH2 0x03c4 03DB 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03D4 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @03D7 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x03c4 label_03DC: // Incoming jump from 0x03CC, if !(stack[-1] < stack[-4]) // Incoming jump from 0x03CC, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @03E1 stack[-6] // @03E1 stack[-5] // @03E3 stack[-7] // } 03DC 5B JUMPDEST 03DD 50 POP 03DE 50 POP 03DF 50 POP 03E0 50 POP 03E1 90 SWAP1 03E2 50 POP 03E3 90 SWAP1 03E4 81 DUP2 03E5 01 ADD 03E6 90 SWAP1 03E7 60 PUSH1 0x1f 03E9 16 AND 03EA 80 DUP1 03EB 15 ISZERO 03EC 61 PUSH2 0x0409 03EF 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @03E6 stack[-7] = stack[-5] + stack[-7] // @03E9 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0409, if !(0x1f & stack[-5]) label_03F0: // Incoming jump from 0x03EF, if not !(0x1f & stack[-5]) // Inputs[6] // { // @03F0 stack[-1] // @03F1 stack[-2] // @03F4 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @040B stack[-5] // @0411 memory[0x40:0x60] // @0416 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 03F0 80 DUP1 03F1 82 DUP3 03F2 03 SUB 03F3 80 DUP1 03F4 51 MLOAD 03F5 60 PUSH1 0x01 03F7 83 DUP4 03F8 60 PUSH1 0x20 03FA 03 SUB 03FB 61 PUSH2 0x0100 03FE 0A EXP 03FF 03 SUB 0400 19 NOT 0401 16 AND 0402 81 DUP2 0403 52 MSTORE 0404 60 PUSH1 0x20 0406 01 ADD 0407 91 SWAP2 0408 50 POP 0409 5B JUMPDEST 040A 50 POP 040B 92 SWAP3 040C 50 POP 040D 50 POP 040E 50 POP 040F 60 PUSH1 0x40 0411 51 MLOAD 0412 80 DUP1 0413 91 SWAP2 0414 03 SUB 0415 90 SWAP1 0416 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0403 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0416 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0417: // Incoming jump from 0x0050, if 0x948f5076 == stack[-1] // Inputs[1] { @0418 msg.value } 0417 5B JUMPDEST 0418 34 CALLVALUE 0419 80 DUP1 041A 15 ISZERO 041B 61 PUSH2 0x0423 041E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0418 stack[0] = msg.value } // Block ends with conditional jump to 0x0423, if !msg.value label_041F: // Incoming jump from 0x041E, if not !msg.value // Inputs[1] { @0422 memory[0x00:0x00] } 041F 60 PUSH1 0x00 0421 80 DUP1 0422 FD *REVERT // Stack delta = +0 // Outputs[1] { @0422 revert(memory[0x00:0x00]); } // Block terminates label_0423: // Incoming jump from 0x041E, if !msg.value // Inputs[1] { @042B msg.data.length } 0423 5B JUMPDEST 0424 50 POP 0425 61 PUSH2 0x044a 0428 60 PUSH1 0x04 042A 80 DUP1 042B 36 CALLDATASIZE 042C 03 SUB 042D 60 PUSH1 0x20 042F 81 DUP2 0430 10 LT 0431 15 ISZERO 0432 61 PUSH2 0x043a 0435 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0425 stack[-1] = 0x044a // @0428 stack[0] = 0x04 // @042C stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x043a, returns to 0x044A, if !(msg.data.length - 0x04 < 0x20) label_0436: // Incoming jump from 0x0435, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0439 memory[0x00:0x00] } 0436 60 PUSH1 0x00 0438 80 DUP1 0439 FD *REVERT // Stack delta = +0 // Outputs[1] { @0439 revert(memory[0x00:0x00]); } // Block terminates label_043A: // Incoming call from 0x0435, returns to 0x044A, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @043C msg.data[stack[-2]:stack[-2] + 0x20] // @043C stack[-2] // } 043A 5B JUMPDEST 043B 50 POP 043C 35 CALLDATALOAD 043D 60 PUSH1 0x01 043F 60 PUSH1 0xa0 0441 60 PUSH1 0x02 0443 0A EXP 0444 03 SUB 0445 16 AND 0446 61 PUSH2 0x08fa 0449 56 *JUMP // Stack delta = -1 // Outputs[1] { @0445 stack[-2] = 0x02 ** 0xa0 - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x08fa label_044A: // Incoming return from call to 0x043A at 0x0435 // Inputs[4] // { // @044E memory[0x40:0x60] // @044F stack[-1] // @0454 memory[0x40:0x60] // @045D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 044A 5B JUMPDEST 044B 60 PUSH1 0x40 044D 80 DUP1 044E 51 MLOAD 044F 91 SWAP2 0450 15 ISZERO 0451 15 ISZERO 0452 82 DUP3 0453 52 MSTORE 0454 51 MLOAD 0455 90 SWAP1 0456 81 DUP2 0457 90 SWAP1 0458 03 SUB 0459 60 PUSH1 0x20 045B 01 ADD 045C 90 SWAP1 045D F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0453 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @045D return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_045E: // Incoming jump from 0x005B, if 0x9c52a7f1 == stack[-1] // Inputs[1] { @045F msg.value } 045E 5B JUMPDEST 045F 34 CALLVALUE 0460 80 DUP1 0461 15 ISZERO 0462 61 PUSH2 0x046a 0465 57 *JUMPI // Stack delta = +1 // Outputs[1] { @045F stack[0] = msg.value } // Block ends with conditional jump to 0x046a, if !msg.value label_0466: // Incoming jump from 0x0465, if not !msg.value // Inputs[1] { @0469 memory[0x00:0x00] } 0466 60 PUSH1 0x00 0468 80 DUP1 0469 FD *REVERT // Stack delta = +0 // Outputs[1] { @0469 revert(memory[0x00:0x00]); } // Block terminates label_046A: // Incoming jump from 0x0465, if !msg.value // Inputs[1] { @0472 msg.data.length } 046A 5B JUMPDEST 046B 50 POP 046C 61 PUSH2 0x00a3 046F 60 PUSH1 0x04 0471 80 DUP1 0472 36 CALLDATASIZE 0473 03 SUB 0474 60 PUSH1 0x20 0476 81 DUP2 0477 10 LT 0478 15 ISZERO 0479 61 PUSH2 0x0481 047C 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @046C stack[-1] = 0x00a3 // @046F stack[0] = 0x04 // @0473 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0481, returns to 0x00A3, if !(msg.data.length - 0x04 < 0x20) label_047D: // Incoming jump from 0x047C, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0480 memory[0x00:0x00] } 047D 60 PUSH1 0x00 047F 80 DUP1 0480 FD *REVERT // Stack delta = +0 // Outputs[1] { @0480 revert(memory[0x00:0x00]); } // Block terminates label_0481: // Incoming call from 0x047C, returns to 0x00A3, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0483 msg.data[stack[-2]:stack[-2] + 0x20] // @0483 stack[-2] // } 0481 5B JUMPDEST 0482 50 POP 0483 35 CALLDATALOAD 0484 60 PUSH1 0x01 0486 60 PUSH1 0xa0 0488 60 PUSH1 0x02 048A 0A EXP 048B 03 SUB 048C 16 AND 048D 61 PUSH2 0x09bd 0490 56 *JUMP // Stack delta = -1 // Outputs[1] { @048C stack[-2] = 0x02 ** 0xa0 - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x09bd label_0491: // Incoming jump from 0x0066, if 0xa90e8731 == stack[-1] // Inputs[1] { @0498 msg.data.length } 0491 5B JUMPDEST 0492 61 PUSH2 0x03a2 0495 60 PUSH1 0x04 0497 80 DUP1 0498 36 CALLDATASIZE 0499 03 SUB 049A 60 PUSH1 0x40 049C 81 DUP2 049D 10 LT 049E 15 ISZERO 049F 61 PUSH2 0x04a7 04A2 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0492 stack[0] = 0x03a2 // @0495 stack[1] = 0x04 // @0499 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04a7, returns to 0x03A2, if !(msg.data.length - 0x04 < 0x40) label_04A3: // Incoming jump from 0x04A2, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @04A6 memory[0x00:0x00] } 04A3 60 PUSH1 0x00 04A5 80 DUP1 04A6 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A6 revert(memory[0x00:0x00]); } // Block terminates label_04A7: // Incoming call from 0x04A2, returns to 0x03A2, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @04A8 stack[-2] // @04A9 stack[-1] // @04B0 msg.data[stack[-2]:stack[-2] + 0x20] // } 04A7 5B JUMPDEST 04A8 81 DUP2 04A9 01 ADD 04AA 90 SWAP1 04AB 60 PUSH1 0x20 04AD 81 DUP2 04AE 01 ADD 04AF 81 DUP2 04B0 35 CALLDATALOAD 04B1 64 PUSH5 0x0100000000 04B7 81 DUP2 04B8 11 GT 04B9 15 ISZERO 04BA 61 PUSH2 0x04c2 04BD 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @04AA stack[-1] = stack[-2] // @04AA stack[-2] = stack[-2] + stack[-1] // @04AE stack[0] = stack[-2] + 0x20 // @04B0 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x04c2, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_04BE: // Incoming jump from 0x04BD, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @04C1 memory[0x00:0x00] } 04BE 60 PUSH1 0x00 04C0 80 DUP1 04C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @04C1 revert(memory[0x00:0x00]); } // Block terminates label_04C2: // Incoming jump from 0x04BD, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @04C3 stack[-3] // @04C4 stack[-1] // @04C5 stack[-4] // } 04C2 5B JUMPDEST 04C3 82 DUP3 04C4 01 ADD 04C5 83 DUP4 04C6 60 PUSH1 0x20 04C8 82 DUP3 04C9 01 ADD 04CA 11 GT 04CB 15 ISZERO 04CC 61 PUSH2 0x04d4 04CF 57 *JUMPI // Stack delta = +0 // Outputs[1] { @04C4 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x04d4, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_04D0: // Incoming jump from 0x04CF, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @04D3 memory[0x00:0x00] } 04D0 60 PUSH1 0x00 04D2 80 DUP1 04D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D3 revert(memory[0x00:0x00]); } // Block terminates label_04D4: // Incoming jump from 0x04CF, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @04D5 stack[-1] // @04D6 msg.data[stack[-1]:stack[-1] + 0x20] // @04DB stack[-2] // @04DC stack[-4] // } 04D4 5B JUMPDEST 04D5 80 DUP1 04D6 35 CALLDATALOAD 04D7 90 SWAP1 04D8 60 PUSH1 0x20 04DA 01 ADD 04DB 91 SWAP2 04DC 84 DUP5 04DD 60 PUSH1 0x01 04DF 83 DUP4 04E0 02 MUL 04E1 84 DUP5 04E2 01 ADD 04E3 11 GT 04E4 64 PUSH5 0x0100000000 04EA 83 DUP4 04EB 11 GT 04EC 17 OR 04ED 15 ISZERO 04EE 61 PUSH2 0x04f6 04F1 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @04D7 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @04DB stack[0] = stack[-2] // @04DB stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x04f6, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_04F2: // Incoming jump from 0x04F1, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @04F5 memory[0x00:0x00] } 04F2 60 PUSH1 0x00 04F4 80 DUP1 04F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F5 revert(memory[0x00:0x00]); } // Block terminates label_04F6: // Incoming jump from 0x04F1, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[8] // { // @04F7 stack[-1] // @04F7 stack[-3] // @04F8 stack[-2] // @0509 memory[0x40:0x60] // @0520 msg.data[stack[-3]:stack[-3] + stack[-2]] // @052B stack[-5] // @052C stack[-4] // @0534 msg.data[stack[-1]:stack[-1] + 0x20] // } 04F6 5B JUMPDEST 04F7 91 SWAP2 04F8 90 SWAP1 04F9 80 DUP1 04FA 80 DUP1 04FB 60 PUSH1 0x1f 04FD 01 ADD 04FE 60 PUSH1 0x20 0500 80 DUP1 0501 91 SWAP2 0502 04 DIV 0503 02 MUL 0504 60 PUSH1 0x20 0506 01 ADD 0507 60 PUSH1 0x40 0509 51 MLOAD 050A 90 SWAP1 050B 81 DUP2 050C 01 ADD 050D 60 PUSH1 0x40 050F 52 MSTORE 0510 80 DUP1 0511 93 SWAP4 0512 92 SWAP3 0513 91 SWAP2 0514 90 SWAP1 0515 81 DUP2 0516 81 DUP2 0517 52 MSTORE 0518 60 PUSH1 0x20 051A 01 ADD 051B 83 DUP4 051C 83 DUP4 051D 80 DUP1 051E 82 DUP3 051F 84 DUP5 0520 37 CALLDATACOPY 0521 60 PUSH1 0x00 0523 92 SWAP3 0524 01 ADD 0525 91 SWAP2 0526 90 SWAP1 0527 91 SWAP2 0528 52 MSTORE 0529 50 POP 052A 92 SWAP3 052B 95 SWAP6 052C 94 SWAP5 052D 93 SWAP4 052E 60 PUSH1 0x20 0530 81 DUP2 0531 01 ADD 0532 93 SWAP4 0533 50 POP 0534 35 CALLDATALOAD 0535 91 SWAP2 0536 50 POP 0537 50 POP 0538 64 PUSH5 0x0100000000 053E 81 DUP2 053F 11 GT 0540 15 ISZERO 0541 61 PUSH2 0x0549 0544 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @050F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0517 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0520 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0528 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @052B stack[-5] = memory[0x40:0x60] // @052C stack[-4] = stack[-5] // @052D stack[-3] = stack[-4] // @0532 stack[-2] = stack[-1] + 0x20 // @0535 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0549, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) label_0545: // Incoming jump from 0x0544, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @0548 memory[0x00:0x00] } 0545 60 PUSH1 0x00 0547 80 DUP1 0548 FD *REVERT // Stack delta = +0 // Outputs[1] { @0548 revert(memory[0x00:0x00]); } // Block terminates label_0549: // Incoming jump from 0x0544, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @054A stack[-3] // @054B stack[-1] // @054C stack[-4] // } 0549 5B JUMPDEST 054A 82 DUP3 054B 01 ADD 054C 83 DUP4 054D 60 PUSH1 0x20 054F 82 DUP3 0550 01 ADD 0551 11 GT 0552 15 ISZERO 0553 61 PUSH2 0x055b 0556 57 *JUMPI // Stack delta = +0 // Outputs[1] { @054B stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x055b, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0557: // Incoming jump from 0x0556, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @055A memory[0x00:0x00] } 0557 60 PUSH1 0x00 0559 80 DUP1 055A FD *REVERT // Stack delta = +0 // Outputs[1] { @055A revert(memory[0x00:0x00]); } // Block terminates label_055B: // Incoming jump from 0x0556, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @055C stack[-1] // @055D msg.data[stack[-1]:stack[-1] + 0x20] // @0562 stack[-2] // @0563 stack[-4] // } 055B 5B JUMPDEST 055C 80 DUP1 055D 35 CALLDATALOAD 055E 90 SWAP1 055F 60 PUSH1 0x20 0561 01 ADD 0562 91 SWAP2 0563 84 DUP5 0564 60 PUSH1 0x01 0566 83 DUP4 0567 02 MUL 0568 84 DUP5 0569 01 ADD 056A 11 GT 056B 64 PUSH5 0x0100000000 0571 83 DUP4 0572 11 GT 0573 17 OR 0574 15 ISZERO 0575 61 PUSH2 0x057d 0578 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @055E stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0562 stack[0] = stack[-2] // @0562 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x057d, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0579: // Incoming jump from 0x0578, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @057C memory[0x00:0x00] } 0579 60 PUSH1 0x00 057B 80 DUP1 057C FD *REVERT // Stack delta = +0 // Outputs[1] { @057C revert(memory[0x00:0x00]); } // Block terminates label_057D: // Incoming jump from 0x0578, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @057E stack[-1] // @057E stack[-3] // @057F stack[-2] // @0590 memory[0x40:0x60] // @05A7 msg.data[stack[-3]:stack[-3] + stack[-2]] // @05B2 stack[-5] // @05B7 stack[-4] // } 057D 5B JUMPDEST 057E 91 SWAP2 057F 90 SWAP1 0580 80 DUP1 0581 80 DUP1 0582 60 PUSH1 0x1f 0584 01 ADD 0585 60 PUSH1 0x20 0587 80 DUP1 0588 91 SWAP2 0589 04 DIV 058A 02 MUL 058B 60 PUSH1 0x20 058D 01 ADD 058E 60 PUSH1 0x40 0590 51 MLOAD 0591 90 SWAP1 0592 81 DUP2 0593 01 ADD 0594 60 PUSH1 0x40 0596 52 MSTORE 0597 80 DUP1 0598 93 SWAP4 0599 92 SWAP3 059A 91 SWAP2 059B 90 SWAP1 059C 81 DUP2 059D 81 DUP2 059E 52 MSTORE 059F 60 PUSH1 0x20 05A1 01 ADD 05A2 83 DUP4 05A3 83 DUP4 05A4 80 DUP1 05A5 82 DUP3 05A6 84 DUP5 05A7 37 CALLDATACOPY 05A8 60 PUSH1 0x00 05AA 92 SWAP3 05AB 01 ADD 05AC 91 SWAP2 05AD 90 SWAP1 05AE 91 SWAP2 05AF 52 MSTORE 05B0 50 POP 05B1 92 SWAP3 05B2 95 SWAP6 05B3 50 POP 05B4 61 PUSH2 0x09f3 05B7 94 SWAP5 05B8 50 POP 05B9 50 POP 05BA 50 POP 05BB 50 POP 05BC 50 POP 05BD 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0596 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @059E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @05A7 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @05AF memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @05B2 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x09f3 label_05BE: // Incoming jump from 0x0071, if 0xbf353dbb == stack[-1] // Inputs[1] { @05BF msg.value } 05BE 5B JUMPDEST 05BF 34 CALLVALUE 05C0 80 DUP1 05C1 15 ISZERO 05C2 61 PUSH2 0x05ca 05C5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05BF stack[0] = msg.value } // Block ends with conditional jump to 0x05ca, if !msg.value label_05C6: // Incoming jump from 0x05C5, if not !msg.value // Inputs[1] { @05C9 memory[0x00:0x00] } 05C6 60 PUSH1 0x00 05C8 80 DUP1 05C9 FD *REVERT // Stack delta = +0 // Outputs[1] { @05C9 revert(memory[0x00:0x00]); } // Block terminates label_05CA: // Incoming jump from 0x05C5, if !msg.value // Inputs[1] { @05D2 msg.data.length } 05CA 5B JUMPDEST 05CB 50 POP 05CC 61 PUSH2 0x05f1 05CF 60 PUSH1 0x04 05D1 80 DUP1 05D2 36 CALLDATASIZE 05D3 03 SUB 05D4 60 PUSH1 0x20 05D6 81 DUP2 05D7 10 LT 05D8 15 ISZERO 05D9 61 PUSH2 0x05e1 05DC 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @05CC stack[-1] = 0x05f1 // @05CF stack[0] = 0x04 // @05D3 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x05e1, returns to 0x05F1, if !(msg.data.length - 0x04 < 0x20) label_05DD: // Incoming jump from 0x05DC, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @05E0 memory[0x00:0x00] } 05DD 60 PUSH1 0x00 05DF 80 DUP1 05E0 FD *REVERT // Stack delta = +0 // Outputs[1] { @05E0 revert(memory[0x00:0x00]); } // Block terminates label_05E1: // Incoming call from 0x05DC, returns to 0x05F1, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @05E3 msg.data[stack[-2]:stack[-2] + 0x20] // @05E3 stack[-2] // } 05E1 5B JUMPDEST 05E2 50 POP 05E3 35 CALLDATALOAD 05E4 60 PUSH1 0x01 05E6 60 PUSH1 0xa0 05E8 60 PUSH1 0x02 05EA 0A EXP 05EB 03 SUB 05EC 16 AND 05ED 61 PUSH2 0x0c01 05F0 56 *JUMP // Stack delta = -1 // Outputs[1] { @05EC stack[-2] = 0x02 ** 0xa0 - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0c01 label_05F1: // Incoming return from call to 0x05E1 at 0x05DC // Inputs[4] // { // @05F5 memory[0x40:0x60] // @05F6 stack[-1] // @05F9 memory[0x40:0x60] // @0602 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 05F1 5B JUMPDEST 05F2 60 PUSH1 0x40 05F4 80 DUP1 05F5 51 MLOAD 05F6 91 SWAP2 05F7 82 DUP3 05F8 52 MSTORE 05F9 51 MLOAD 05FA 90 SWAP1 05FB 81 DUP2 05FC 90 SWAP1 05FD 03 SUB 05FE 60 PUSH1 0x20 0600 01 ADD 0601 90 SWAP1 0602 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @05F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0602 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0603: // Incoming jump from 0x015A // Incoming call from 0x0841, returns to 0x0842 // Inputs[3] // { // @0604 msg.sender // @0612 memory[0x00:0x40] // @0613 storage[keccak256(memory[0x00:0x40])] // } 0603 5B JUMPDEST 0604 33 CALLER 0605 60 PUSH1 0x00 0607 90 SWAP1 0608 81 DUP2 0609 52 MSTORE 060A 60 PUSH1 0x20 060C 81 DUP2 060D 90 SWAP1 060E 52 MSTORE 060F 60 PUSH1 0x40 0611 90 SWAP1 0612 20 SHA3 0613 54 SLOAD 0614 60 PUSH1 0x01 0616 14 EQ 0617 61 PUSH2 0x061f 061A 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0609 memory[0x00:0x20] = msg.sender // @060E memory[0x20:0x40] = 0x00 // } // Block ends with conditional jump to 0x061f, if 0x01 == storage[keccak256(memory[0x00:0x40])] label_061B: // Incoming jump from 0x061A, if not 0x01 == storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @061E memory[0x00:0x00] } 061B 60 PUSH1 0x00 061D 80 DUP1 061E FD *REVERT // Stack delta = +0 // Outputs[1] { @061E revert(memory[0x00:0x00]); } // Block terminates label_061F: // Incoming jump from 0x061A, if 0x01 == storage[keccak256(memory[0x00:0x40])] // Inputs[6] // { // @0623 stack[-1] // @0624 memory[stack[-1]:stack[-1] + 0x20] // @0629 stack[-2] // @062A msg.gas // @062B memory[stack[-1] + 0x20:stack[-1] + 0x20 + memory[stack[-1]:stack[-1] + 0x20]] // @062B address(stack[-2]).delegatecall.gas(msg.gas)(memory[stack[-1] + 0x20:stack[-1] + 0x20 + memory[stack[-1]:stack[-1] + 0x20]]) // } 061F 5B JUMPDEST 0620 60 PUSH1 0x00 0622 80 DUP1 0623 82 DUP3 0624 51 MLOAD 0625 60 PUSH1 0x20 0627 84 DUP5 0628 01 ADD 0629 85 DUP6 062A 5A GAS 062B F4 DELEGATECALL 062C 80 DUP1 062D 15 ISZERO 062E 60 PUSH1 0x01 0630 81 DUP2 0631 14 EQ 0632 61 PUSH2 0x063a 0635 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @062B memory[0x00:0x00] = address(stack[-2]).delegatecall.gas(msg.gas)(memory[stack[-1] + 0x20:stack[-1] + 0x20 + memory[stack[-1]:stack[-1] + 0x20]]) // @062B stack[0] = address(stack[-2]).delegatecall.gas(msg.gas)(memory[stack[-1] + 0x20:stack[-1] + 0x20 + memory[stack[-1]:stack[-1] + 0x20]]) // @062D stack[1] = !address(stack[-2]).delegatecall.gas(msg.gas)(memory[stack[-1] + 0x20:stack[-1] + 0x20 + memory[stack[-1]:stack[-1] + 0x20]]) // } // Block ends with conditional jump to 0x063a, if !address(stack[-2]).delegatecall.gas(msg.gas)(memory[stack[-1] + 0x20:stack[-1] + 0x20 + memory[stack[-1]:stack[-1] + 0x20]]) == 0x01 label_0636: // Incoming jump from 0x0635, if not !address(stack[-2]).delegatecall.gas(msg.gas)(memory[stack[-1] + 0x20:stack[-1] + 0x20 + memory[stack[-1]:stack[-1] + 0x20]]) == 0x01 0636 61 PUSH2 0x063f 0639 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x063f label_063A: // Incoming jump from 0x0635, if !address(stack[-2]).delegatecall.gas(msg.gas)(memory[stack[-1] + 0x20:stack[-1] + 0x20 + memory[stack[-1]:stack[-1] + 0x20]]) == 0x01 // Inputs[1] { @063E memory[0x00:0x00] } 063A 5B JUMPDEST 063B 60 PUSH1 0x00 063D 80 DUP1 063E FD *REVERT // Stack delta = +0 // Outputs[1] { @063E revert(memory[0x00:0x00]); } // Block terminates label_063F: // Incoming jump from 0x0639 // Inputs[1] { @0644 stack[-5] } 063F 5B JUMPDEST 0640 50 POP 0641 50 POP 0642 50 POP 0643 50 POP 0644 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0645: // Incoming jump from 0x0287 // Inputs[5] // { // @0648 storage[0x01] // @064B memory[0x40:0x60] // @0678 stack[-2] // @0679 memory[stack[-2]:stack[-2] + 0x20] // @0680 memory[stack[-2]:stack[-2] + 0x20] // } 0645 5B JUMPDEST 0646 60 PUSH1 0x01 0648 54 SLOAD 0649 60 PUSH1 0x40 064B 51 MLOAD 064C 7F PUSH32 0x8bf4515c00000000000000000000000000000000000000000000000000000000 066D 81 DUP2 066E 52 MSTORE 066F 60 PUSH1 0x20 0671 60 PUSH1 0x04 0673 82 DUP3 0674 01 ADD 0675 81 DUP2 0676 81 DUP2 0677 52 MSTORE 0678 85 DUP6 0679 51 MLOAD 067A 60 PUSH1 0x24 067C 84 DUP5 067D 01 ADD 067E 52 MSTORE 067F 85 DUP6 0680 51 MLOAD 0681 60 PUSH1 0x00 0683 94 SWAP5 0684 60 PUSH1 0x01 0686 60 PUSH1 0xa0 0688 60 PUSH1 0x02 068A 0A EXP 068B 03 SUB 068C 16 AND 068D 93 SWAP4 068E 63 PUSH4 0x8bf4515c 0693 93 SWAP4 0694 88 DUP9 0695 93 SWAP4 0696 92 SWAP3 0697 83 DUP4 0698 92 SWAP3 0699 60 PUSH1 0x44 069B 01 ADD 069C 91 SWAP2 069D 85 DUP6 069E 01 ADD 069F 90 SWAP1 06A0 80 DUP1 06A1 83 DUP4 06A2 83 DUP4 06A3 8B DUP12 06A4 5B JUMPDEST 06A5 83 DUP4 06A6 81 DUP2 06A7 10 LT 06A8 15 ISZERO 06A9 61 PUSH2 0x06bc 06AC 57 *JUMPI // Stack delta = +13 // Outputs[16] // { // @066E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x8bf4515c00000000000000000000000000000000000000000000000000000000 // @0677 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @067E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @0683 stack[0] = 0x00 // @068D stack[1] = 0x02 ** 0xa0 - 0x01 & storage[0x01] // @0693 stack[2] = 0x8bf4515c // @0695 stack[3] = stack[-2] // @0696 stack[4] = memory[0x40:0x60] + 0x04 // @0698 stack[5] = memory[0x40:0x60] + 0x04 // @069C stack[6] = 0x44 + memory[0x40:0x60] // @069F stack[7] = stack[-2] + 0x20 // @069F stack[8] = memory[stack[-2]:stack[-2] + 0x20] // @06A0 stack[9] = memory[stack[-2]:stack[-2] + 0x20] // @06A1 stack[10] = 0x44 + memory[0x40:0x60] // @06A2 stack[11] = stack[-2] + 0x20 // @06A3 stack[12] = 0x00 // } // Block ends with conditional jump to 0x06bc, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_06AD: // Incoming jump from 0x06AC, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x06AC, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[4] // { // @06AD stack[-2] // @06AE stack[-1] // @06B0 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @06B1 stack[-3] // } 06AD 81 DUP2 06AE 81 DUP2 06AF 01 ADD 06B0 51 MLOAD 06B1 83 DUP4 06B2 82 DUP3 06B3 01 ADD 06B4 52 MSTORE 06B5 60 PUSH1 0x20 06B7 01 ADD 06B8 61 PUSH2 0x06a4 06BB 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @06B4 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @06B7 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x06a4 label_06BC: // Incoming jump from 0x06AC, if !(stack[-1] < stack[-4]) // Incoming jump from 0x06AC, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @06C1 stack[-5] // @06C1 stack[-6] // @06C3 stack[-7] // } 06BC 5B JUMPDEST 06BD 50 POP 06BE 50 POP 06BF 50 POP 06C0 50 POP 06C1 90 SWAP1 06C2 50 POP 06C3 90 SWAP1 06C4 81 DUP2 06C5 01 ADD 06C6 90 SWAP1 06C7 60 PUSH1 0x1f 06C9 16 AND 06CA 80 DUP1 06CB 15 ISZERO 06CC 61 PUSH2 0x06e9 06CF 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @06C6 stack[-7] = stack[-5] + stack[-7] // @06C9 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x06e9, if !(0x1f & stack[-5]) label_06D0: // Incoming jump from 0x06CF, if not !(0x1f & stack[-5]) // Inputs[7] // { // @06D0 stack[-1] // @06D1 stack[-2] // @06D4 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @06EB stack[-5] // @06F3 memory[0x40:0x60] // @06F8 stack[-7] // @06FA address(stack[-7]).code.length // } 06D0 80 DUP1 06D1 82 DUP3 06D2 03 SUB 06D3 80 DUP1 06D4 51 MLOAD 06D5 60 PUSH1 0x01 06D7 83 DUP4 06D8 60 PUSH1 0x20 06DA 03 SUB 06DB 61 PUSH2 0x0100 06DE 0A EXP 06DF 03 SUB 06E0 19 NOT 06E1 16 AND 06E2 81 DUP2 06E3 52 MSTORE 06E4 60 PUSH1 0x20 06E6 01 ADD 06E7 91 SWAP2 06E8 50 POP 06E9 5B JUMPDEST 06EA 50 POP 06EB 92 SWAP3 06EC 50 POP 06ED 50 POP 06EE 50 POP 06EF 60 PUSH1 0x20 06F1 60 PUSH1 0x40 06F3 51 MLOAD 06F4 80 DUP1 06F5 83 DUP4 06F6 03 SUB 06F7 81 DUP2 06F8 86 DUP7 06F9 80 DUP1 06FA 3B EXTCODESIZE 06FB 15 ISZERO 06FC 80 DUP1 06FD 15 ISZERO 06FE 61 PUSH2 0x0706 0701 57 *JUMPI // Stack delta = +2 // Outputs[8] // { // @06E3 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @06EB stack[-5] = 0x20 + (stack[-2] - stack[-1]) // @06EF stack[-4] = 0x20 // @06F3 stack[-3] = memory[0x40:0x60] // @06F6 stack[-2] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @06F7 stack[-1] = memory[0x40:0x60] // @06F8 stack[0] = stack[-7] // @06FB stack[1] = !address(stack[-7]).code.length // } // Block ends with conditional jump to 0x0706, if !!address(stack[-7]).code.length label_0702: // Incoming jump from 0x0701, if not !!address(stack[-7]).code.length // Incoming jump from 0x0701, if not !!address(stack[-7]).code.length // Inputs[1] { @0705 memory[0x00:0x00] } 0702 60 PUSH1 0x00 0704 80 DUP1 0705 FD *REVERT // Stack delta = +0 // Outputs[1] { @0705 revert(memory[0x00:0x00]); } // Block terminates label_0706: // Incoming jump from 0x0701, if !!address(stack[-7]).code.length // Incoming jump from 0x0701, if !!address(stack[-7]).code.length // Inputs[8] // { // @0708 msg.gas // @0709 stack[-2] // @0709 stack[-3] // @0709 stack[-6] // @0709 memory[stack[-3]:stack[-3] + stack[-4]] // @0709 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0709 stack[-5] // @0709 stack[-4] // } 0706 5B JUMPDEST 0707 50 POP 0708 5A GAS 0709 FA STATICCALL 070A 15 ISZERO 070B 80 DUP1 070C 15 ISZERO 070D 61 PUSH2 0x071a 0710 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0709 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @070A stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x071a, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0711: // Incoming jump from 0x0710, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0711 returndata.length // @0715 returndata[0x00:0x00 + returndata.length] // @0716 returndata.length // @0719 memory[0x00:0x00 + returndata.length] // } 0711 3D RETURNDATASIZE 0712 60 PUSH1 0x00 0714 80 DUP1 0715 3E RETURNDATACOPY 0716 3D RETURNDATASIZE 0717 60 PUSH1 0x00 0719 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0715 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0719 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_071A: // Incoming jump from 0x0710, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0721 memory[0x40:0x60] // @0722 returndata.length // } 071A 5B JUMPDEST 071B 50 POP 071C 50 POP 071D 50 POP 071E 50 POP 071F 60 PUSH1 0x40 0721 51 MLOAD 0722 3D RETURNDATASIZE 0723 60 PUSH1 0x20 0725 81 DUP2 0726 10 LT 0727 15 ISZERO 0728 61 PUSH2 0x0730 072B 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0721 stack[-4] = memory[0x40:0x60] // @0722 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0730, if !(returndata.length < 0x20) label_072C: // Incoming jump from 0x072B, if not !(returndata.length < 0x20) // Inputs[1] { @072F memory[0x00:0x00] } 072C 60 PUSH1 0x00 072E 80 DUP1 072F FD *REVERT // Stack delta = +0 // Outputs[1] { @072F revert(memory[0x00:0x00]); } // Block terminates label_0730: // Incoming jump from 0x072B, if !(returndata.length < 0x20) // Inputs[3] // { // @0732 stack[-2] // @0732 memory[stack[-2]:stack[-2] + 0x20] // @0733 stack[-3] // } 0730 5B JUMPDEST 0731 50 POP 0732 51 MLOAD 0733 90 SWAP1 0734 50 POP 0735 60 PUSH1 0x01 0737 60 PUSH1 0xa0 0739 60 PUSH1 0x02 073B 0A EXP 073C 03 SUB 073D 81 DUP2 073E 16 AND 073F 15 ISZERO 0740 15 ISZERO 0741 61 PUSH2 0x0838 0744 57 *JUMPI // Stack delta = -2 // Outputs[1] { @0733 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0838, if !!(memory[stack[-2]:stack[-2] + 0x20] & 0x02 ** 0xa0 - 0x01) label_0745: // Incoming jump from 0x0744, if not !!(memory[stack[-2]:stack[-2] + 0x20] & 0x02 ** 0xa0 - 0x01) // Inputs[5] // { // @0747 storage[0x01] // @074A memory[0x40:0x60] // @0777 stack[-3] // @0778 memory[stack[-3]:stack[-3] + 0x20] // @077F memory[stack[-3]:stack[-3] + 0x20] // } 0745 60 PUSH1 0x01 0747 54 SLOAD 0748 60 PUSH1 0x40 074A 51 MLOAD 074B 7F PUSH32 0x7ed0c3b200000000000000000000000000000000000000000000000000000000 076C 81 DUP2 076D 52 MSTORE 076E 60 PUSH1 0x20 0770 60 PUSH1 0x04 0772 82 DUP3 0773 01 ADD 0774 81 DUP2 0775 81 DUP2 0776 52 MSTORE 0777 86 DUP7 0778 51 MLOAD 0779 60 PUSH1 0x24 077B 84 DUP5 077C 01 ADD 077D 52 MSTORE 077E 86 DUP7 077F 51 MLOAD 0780 60 PUSH1 0x01 0782 60 PUSH1 0xa0 0784 60 PUSH1 0x02 0786 0A EXP 0787 03 SUB 0788 90 SWAP1 0789 94 SWAP5 078A 16 AND 078B 93 SWAP4 078C 63 PUSH4 0x7ed0c3b2 0791 93 SWAP4 0792 88 DUP9 0793 93 SWAP4 0794 83 DUP4 0795 92 SWAP3 0796 60 PUSH1 0x44 0798 90 SWAP1 0799 92 SWAP3 079A 01 ADD 079B 91 SWAP2 079C 90 SWAP1 079D 85 DUP6 079E 01 ADD 079F 90 SWAP1 07A0 80 DUP1 07A1 83 DUP4 07A2 83 DUP4 07A3 60 PUSH1 0x00 07A5 5B JUMPDEST 07A6 83 DUP4 07A7 81 DUP2 07A8 10 LT 07A9 15 ISZERO 07AA 61 PUSH2 0x07bd 07AD 57 *JUMPI // Stack delta = +12 // Outputs[15] // { // @076D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x7ed0c3b200000000000000000000000000000000000000000000000000000000 // @0773 stack[3] = memory[0x40:0x60] + 0x04 // @0776 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @077D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = memory[stack[-3]:stack[-3] + 0x20] // @078B stack[0] = storage[0x01] & 0x02 ** 0xa0 - 0x01 // @0791 stack[1] = 0x7ed0c3b2 // @0793 stack[2] = stack[-3] // @0795 stack[4] = memory[0x40:0x60] + 0x04 // @079B stack[5] = memory[0x40:0x60] + 0x44 // @079F stack[6] = stack[-3] + 0x20 // @079F stack[7] = memory[stack[-3]:stack[-3] + 0x20] // @07A0 stack[8] = memory[stack[-3]:stack[-3] + 0x20] // @07A1 stack[9] = memory[0x40:0x60] + 0x44 // @07A2 stack[10] = stack[-3] + 0x20 // @07A3 stack[11] = 0x00 // } // Block ends with conditional jump to 0x07bd, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) label_07AE: // Incoming jump from 0x07AD, if not !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x07AD, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @07AE stack[-2] // @07AF stack[-1] // @07B1 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @07B2 stack[-3] // } 07AE 81 DUP2 07AF 81 DUP2 07B0 01 ADD 07B1 51 MLOAD 07B2 83 DUP4 07B3 82 DUP3 07B4 01 ADD 07B5 52 MSTORE 07B6 60 PUSH1 0x20 07B8 01 ADD 07B9 61 PUSH2 0x07a5 07BC 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @07B5 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @07B8 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x07a5 label_07BD: // Incoming jump from 0x07AD, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x07AD, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @07C2 stack[-6] // @07C2 stack[-5] // @07C4 stack[-7] // } 07BD 5B JUMPDEST 07BE 50 POP 07BF 50 POP 07C0 50 POP 07C1 50 POP 07C2 90 SWAP1 07C3 50 POP 07C4 90 SWAP1 07C5 81 DUP2 07C6 01 ADD 07C7 90 SWAP1 07C8 60 PUSH1 0x1f 07CA 16 AND 07CB 80 DUP1 07CC 15 ISZERO 07CD 61 PUSH2 0x07ea 07D0 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @07C7 stack[-7] = stack[-5] + stack[-7] // @07CA stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x07ea, if !(0x1f & stack[-5]) label_07D1: // Incoming jump from 0x07D0, if not !(0x1f & stack[-5]) // Inputs[7] // { // @07D1 stack[-1] // @07D2 stack[-2] // @07D5 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @07EC stack[-5] // @07F4 memory[0x40:0x60] // @07FB stack[-7] // @07FD address(stack[-7]).code.length // } 07D1 80 DUP1 07D2 82 DUP3 07D3 03 SUB 07D4 80 DUP1 07D5 51 MLOAD 07D6 60 PUSH1 0x01 07D8 83 DUP4 07D9 60 PUSH1 0x20 07DB 03 SUB 07DC 61 PUSH2 0x0100 07DF 0A EXP 07E0 03 SUB 07E1 19 NOT 07E2 16 AND 07E3 81 DUP2 07E4 52 MSTORE 07E5 60 PUSH1 0x20 07E7 01 ADD 07E8 91 SWAP2 07E9 50 POP 07EA 5B JUMPDEST 07EB 50 POP 07EC 92 SWAP3 07ED 50 POP 07EE 50 POP 07EF 50 POP 07F0 60 PUSH1 0x20 07F2 60 PUSH1 0x40 07F4 51 MLOAD 07F5 80 DUP1 07F6 83 DUP4 07F7 03 SUB 07F8 81 DUP2 07F9 60 PUSH1 0x00 07FB 87 DUP8 07FC 80 DUP1 07FD 3B EXTCODESIZE 07FE 15 ISZERO 07FF 80 DUP1 0800 15 ISZERO 0801 61 PUSH2 0x0809 0804 57 *JUMPI // Stack delta = +3 // Outputs[9] // { // @07E4 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @07EC stack[-5] = 0x20 + (stack[-2] - stack[-1]) // @07F0 stack[-4] = 0x20 // @07F4 stack[-3] = memory[0x40:0x60] // @07F7 stack[-2] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @07F8 stack[-1] = memory[0x40:0x60] // @07F9 stack[0] = 0x00 // @07FB stack[1] = stack[-7] // @07FE stack[2] = !address(stack[-7]).code.length // } // Block ends with conditional jump to 0x0809, if !!address(stack[-7]).code.length label_0805: // Incoming jump from 0x0804, if not !!address(stack[-7]).code.length // Incoming jump from 0x0804, if not !!address(stack[-7]).code.length // Inputs[1] { @0808 memory[0x00:0x00] } 0805 60 PUSH1 0x00 0807 80 DUP1 0808 FD *REVERT // Stack delta = +0 // Outputs[1] { @0808 revert(memory[0x00:0x00]); } // Block terminates label_0809: // Incoming jump from 0x0804, if !!address(stack[-7]).code.length // Incoming jump from 0x0804, if !!address(stack[-7]).code.length // Inputs[9] // { // @080B msg.gas // @080C stack[-6] // @080C memory[stack[-4]:stack[-4] + stack[-5]] // @080C address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @080C stack[-5] // @080C stack[-2] // @080C stack[-7] // @080C stack[-4] // @080C stack[-3] // } 0809 5B JUMPDEST 080A 50 POP 080B 5A GAS 080C F1 CALL 080D 15 ISZERO 080E 80 DUP1 080F 15 ISZERO 0810 61 PUSH2 0x081d 0813 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @080C memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @080D stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x081d, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0814: // Incoming jump from 0x0813, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0814 returndata.length // @0818 returndata[0x00:0x00 + returndata.length] // @0819 returndata.length // @081C memory[0x00:0x00 + returndata.length] // } 0814 3D RETURNDATASIZE 0815 60 PUSH1 0x00 0817 80 DUP1 0818 3E RETURNDATACOPY 0819 3D RETURNDATASIZE 081A 60 PUSH1 0x00 081C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0818 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @081C revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_081D: // Incoming jump from 0x0813, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @0824 memory[0x40:0x60] // @0825 returndata.length // } 081D 5B JUMPDEST 081E 50 POP 081F 50 POP 0820 50 POP 0821 50 POP 0822 60 PUSH1 0x40 0824 51 MLOAD 0825 3D RETURNDATASIZE 0826 60 PUSH1 0x20 0828 81 DUP2 0829 10 LT 082A 15 ISZERO 082B 61 PUSH2 0x0833 082E 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0824 stack[-4] = memory[0x40:0x60] // @0825 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0833, if !(returndata.length < 0x20) label_082F: // Incoming jump from 0x082E, if not !(returndata.length < 0x20) // Inputs[1] { @0832 memory[0x00:0x00] } 082F 60 PUSH1 0x00 0831 80 DUP1 0832 FD *REVERT // Stack delta = +0 // Outputs[1] { @0832 revert(memory[0x00:0x00]); } // Block terminates label_0833: // Incoming jump from 0x082E, if !(returndata.length < 0x20) // Inputs[3] // { // @0835 stack[-2] // @0835 memory[stack[-2]:stack[-2] + 0x20] // @0836 stack[-3] // } 0833 5B JUMPDEST 0834 50 POP 0835 51 MLOAD 0836 90 SWAP1 0837 50 POP // Stack delta = -2 // Outputs[1] { @0836 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block continues label_0838: // Incoming jump from 0x0744, if !!(memory[stack[-2]:stack[-2] + 0x20] & 0x02 ** 0xa0 - 0x01) // Incoming jump from 0x0837 // Inputs[2] // { // @083C stack[-1] // @083D stack[-2] // } 0838 5B JUMPDEST 0839 61 PUSH2 0x0842 083C 81 DUP2 083D 83 DUP4 083E 61 PUSH2 0x0603 0841 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0839 stack[0] = 0x0842 // @083C stack[1] = stack[-1] // @083D stack[2] = stack[-2] // } // Block ends with call to 0x0603, returns to 0x0842 label_0842: // Incoming return from call to 0x0603 at 0x0841 // Inputs[1] { @0846 stack[-4] } 0842 5B JUMPDEST 0843 50 POP 0844 50 POP 0845 50 POP 0846 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0847: // Incoming call from 0x029C, returns to 0x029D // Inputs[2] // { // @084A storage[0x01] // @0854 stack[-1] // } 0847 5B JUMPDEST 0848 60 PUSH1 0x01 084A 54 SLOAD 084B 60 PUSH1 0x01 084D 60 PUSH1 0xa0 084F 60 PUSH1 0x02 0851 0A EXP 0852 03 SUB 0853 16 AND 0854 81 DUP2 0855 56 *JUMP // Stack delta = +1 // Outputs[1] { @0853 stack[0] = 0x02 ** 0xa0 - 0x01 & storage[0x01] } // Block ends with unconditional jump to stack[-1] label_0856: // Incoming jump from 0x02EB // Inputs[3] // { // @0857 msg.sender // @0865 memory[0x00:0x40] // @0866 storage[keccak256(memory[0x00:0x40])] // } 0856 5B JUMPDEST 0857 33 CALLER 0858 60 PUSH1 0x00 085A 90 SWAP1 085B 81 DUP2 085C 52 MSTORE 085D 60 PUSH1 0x20 085F 81 DUP2 0860 90 SWAP1 0861 52 MSTORE 0862 60 PUSH1 0x40 0864 90 SWAP1 0865 20 SHA3 0866 54 SLOAD 0867 60 PUSH1 0x01 0869 14 EQ 086A 61 PUSH2 0x0872 086D 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @085C memory[0x00:0x20] = msg.sender // @0861 memory[0x20:0x40] = 0x00 // } // Block ends with conditional jump to 0x0872, if 0x01 == storage[keccak256(memory[0x00:0x40])] label_086E: // Incoming jump from 0x086D, if not 0x01 == storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0871 memory[0x00:0x00] } 086E 60 PUSH1 0x00 0870 80 DUP1 0871 FD *REVERT // Stack delta = +0 // Outputs[1] { @0871 revert(memory[0x00:0x00]); } // Block terminates label_0872: // Incoming jump from 0x086D, if 0x01 == storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @087B stack[-1] // @0889 memory[0x00:0x40] // @088E stack[-2] // } 0872 5B JUMPDEST 0873 60 PUSH1 0x01 0875 60 PUSH1 0xa0 0877 60 PUSH1 0x02 0879 0A EXP 087A 03 SUB 087B 16 AND 087C 60 PUSH1 0x00 087E 90 SWAP1 087F 81 DUP2 0880 52 MSTORE 0881 60 PUSH1 0x20 0883 81 DUP2 0884 90 SWAP1 0885 52 MSTORE 0886 60 PUSH1 0x40 0888 90 SWAP1 0889 20 SHA3 088A 60 PUSH1 0x01 088C 90 SWAP1 088D 55 SSTORE 088E 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0880 memory[0x00:0x20] = 0x02 ** 0xa0 - 0x01 & stack[-1] // @0885 memory[0x20:0x40] = 0x00 // @088D storage[keccak256(memory[0x00:0x40])] = 0x01 // } // Block ends with unconditional jump to stack[-2] label_088F: // Incoming jump from 0x03A1 // Incoming call from 0x0BF8, returns to 0x0BF9 // Inputs[3] // { // @0890 msg.sender // @089E memory[0x00:0x40] // @089F storage[keccak256(memory[0x00:0x40])] // } 088F 5B JUMPDEST 0890 33 CALLER 0891 60 PUSH1 0x00 0893 90 SWAP1 0894 81 DUP2 0895 52 MSTORE 0896 60 PUSH1 0x20 0898 81 DUP2 0899 90 SWAP1 089A 52 MSTORE 089B 60 PUSH1 0x40 089D 90 SWAP1 089E 20 SHA3 089F 54 SLOAD 08A0 60 PUSH1 0x60 08A2 90 SWAP1 08A3 60 PUSH1 0x01 08A5 14 EQ 08A6 61 PUSH2 0x08ae 08A9 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0895 memory[0x00:0x20] = msg.sender // @089A memory[0x20:0x40] = 0x00 // @08A2 stack[0] = 0x60 // } // Block ends with conditional jump to 0x08ae, if 0x01 == storage[keccak256(memory[0x00:0x40])] label_08AA: // Incoming jump from 0x08A9, if not 0x01 == storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @08AD memory[0x00:0x00] } 08AA 60 PUSH1 0x00 08AC 80 DUP1 08AD FD *REVERT // Stack delta = +0 // Outputs[1] { @08AD revert(memory[0x00:0x00]); } // Block terminates label_08AE: // Incoming jump from 0x08A9, if 0x01 == storage[keccak256(memory[0x00:0x40])] // Inputs[10] // { // @08B2 stack[-2] // @08B3 memory[stack[-2]:stack[-2] + 0x20] // @08B8 stack[-3] // @08B9 msg.gas // @08BA memory[stack[-2] + 0x20:stack[-2] + 0x20 + memory[stack[-2]:stack[-2] + 0x20]] // @08BA address(stack[-3]).delegatecall.gas(msg.gas)(memory[stack[-2] + 0x20:stack[-2] + 0x20 + memory[stack[-2]:stack[-2] + 0x20]]) // @08BB returndata.length // @08BE memory[0x40:0x60] // @08BF stack[-1] // @08DB returndata[0x00:0x00 + returndata.length] // } 08AE 5B JUMPDEST 08AF 60 PUSH1 0x00 08B1 80 DUP1 08B2 83 DUP4 08B3 51 MLOAD 08B4 60 PUSH1 0x20 08B6 85 DUP6 08B7 01 ADD 08B8 86 DUP7 08B9 5A GAS 08BA F4 DELEGATECALL 08BB 3D RETURNDATASIZE 08BC 60 PUSH1 0x40 08BE 51 MLOAD 08BF 92 SWAP3 08C0 50 POP 08C1 60 PUSH1 0x1f 08C3 19 NOT 08C4 60 PUSH1 0x1f 08C6 60 PUSH1 0x20 08C8 83 DUP4 08C9 01 ADD 08CA 01 ADD 08CB 16 AND 08CC 83 DUP4 08CD 01 ADD 08CE 60 PUSH1 0x40 08D0 52 MSTORE 08D1 80 DUP1 08D2 83 DUP4 08D3 52 MSTORE 08D4 80 DUP1 08D5 60 PUSH1 0x00 08D7 60 PUSH1 0x20 08D9 85 DUP6 08DA 01 ADD 08DB 3E RETURNDATACOPY 08DC 81 DUP2 08DD 15 ISZERO 08DE 60 PUSH1 0x01 08E0 81 DUP2 08E1 14 EQ 08E2 61 PUSH2 0x08ea 08E5 57 *JUMPI // Stack delta = +3 // Outputs[8] // { // @08BA memory[0x00:0x00] = address(stack[-3]).delegatecall.gas(msg.gas)(memory[stack[-2] + 0x20:stack[-2] + 0x20 + memory[stack[-2]:stack[-2] + 0x20]]) // @08BA stack[0] = address(stack[-3]).delegatecall.gas(msg.gas)(memory[stack[-2] + 0x20:stack[-2] + 0x20 + memory[stack[-2]:stack[-2] + 0x20]]) // @08BB stack[1] = returndata.length // @08BF stack[-1] = memory[0x40:0x60] // @08D0 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x20 + 0x1f & ~0x1f) // @08D3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @08DB memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @08DD stack[2] = !address(stack[-3]).delegatecall.gas(msg.gas)(memory[stack[-2] + 0x20:stack[-2] + 0x20 + memory[stack[-2]:stack[-2] + 0x20]]) // } // Block ends with conditional jump to 0x08ea, if !address(stack[-3]).delegatecall.gas(msg.gas)(memory[stack[-2] + 0x20:stack[-2] + 0x20 + memory[stack[-2]:stack[-2] + 0x20]]) == 0x01 label_08E6: // Incoming jump from 0x08E5, if not !address(stack[-3]).delegatecall.gas(msg.gas)(memory[stack[-2] + 0x20:stack[-2] + 0x20 + memory[stack[-2]:stack[-2] + 0x20]]) == 0x01 08E6 61 PUSH2 0x08f1 08E9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08f1 label_08EA: // Incoming jump from 0x08E5, if !address(stack[-3]).delegatecall.gas(msg.gas)(memory[stack[-2] + 0x20:stack[-2] + 0x20 + memory[stack[-2]:stack[-2] + 0x20]]) == 0x01 // Inputs[3] // { // @08EB stack[-2] // @08EE stack[-4] // @08F0 memory[stack[-4] + 0x20:stack[-4] + 0x20 + stack[-2]] // } 08EA 5B JUMPDEST 08EB 81 DUP2 08EC 60 PUSH1 0x20 08EE 85 DUP6 08EF 01 ADD 08F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @08F0 revert(memory[stack[-4] + 0x20:stack[-4] + 0x20 + stack[-2]]); } // Block terminates label_08F1: // Incoming jump from 0x08E9 // Inputs[3] // { // @08F5 stack[-7] // @08F5 stack[-4] // @08F6 stack[-6] // } 08F1 5B JUMPDEST 08F2 50 POP 08F3 50 POP 08F4 50 POP 08F5 92 SWAP3 08F6 91 SWAP2 08F7 50 POP 08F8 50 POP 08F9 56 *JUMP // Stack delta = -6 // Outputs[1] { @08F5 stack[-7] = stack[-4] } // Block ends with unconditional jump to stack[-7] label_08FA: // Incoming jump from 0x0449 // Inputs[3] // { // @08FB msg.sender // @0909 memory[0x00:0x40] // @090A storage[keccak256(memory[0x00:0x40])] // } 08FA 5B JUMPDEST 08FB 33 CALLER 08FC 60 PUSH1 0x00 08FE 90 SWAP1 08FF 81 DUP2 0900 52 MSTORE 0901 60 PUSH1 0x20 0903 81 DUP2 0904 90 SWAP1 0905 52 MSTORE 0906 60 PUSH1 0x40 0908 81 DUP2 0909 20 SHA3 090A 54 SLOAD 090B 60 PUSH1 0x01 090D 14 EQ 090E 61 PUSH2 0x0916 0911 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @08FE stack[0] = 0x00 // @0900 memory[0x00:0x20] = msg.sender // @0905 memory[0x20:0x40] = 0x00 // } // Block ends with conditional jump to 0x0916, if 0x01 == storage[keccak256(memory[0x00:0x40])] label_0912: // Incoming jump from 0x0911, if not 0x01 == storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0915 memory[0x00:0x00] } 0912 60 PUSH1 0x00 0914 80 DUP1 0915 FD *REVERT // Stack delta = +0 // Outputs[1] { @0915 revert(memory[0x00:0x00]); } // Block terminates label_0916: // Incoming jump from 0x0911, if 0x01 == storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @091F stack[-2] } 0916 5B JUMPDEST 0917 60 PUSH1 0x01 0919 60 PUSH1 0xa0 091B 60 PUSH1 0x02 091D 0A EXP 091E 03 SUB 091F 82 DUP3 0920 16 AND 0921 15 ISZERO 0922 15 ISZERO 0923 61 PUSH2 0x098d 0926 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x098d, if !!(stack[-2] & 0x02 ** 0xa0 - 0x01) label_0927: // Incoming jump from 0x0926, if not !!(stack[-2] & 0x02 ** 0xa0 - 0x01) // Inputs[3] // { // @092A memory[0x40:0x60] // @0983 memory[0x40:0x60] // @098C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0927 60 PUSH1 0x40 0929 80 DUP1 092A 51 MLOAD 092B 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 094C 81 DUP2 094D 52 MSTORE 094E 60 PUSH1 0x20 0950 60 PUSH1 0x04 0952 82 DUP3 0953 01 ADD 0954 52 MSTORE 0955 60 PUSH1 0x1f 0957 60 PUSH1 0x24 0959 82 DUP3 095A 01 ADD 095B 52 MSTORE 095C 7F PUSH32 0x64732d70726f78792d63616368652d616464726573732d726571756972656400 097D 60 PUSH1 0x44 097F 82 DUP3 0980 01 ADD 0981 52 MSTORE 0982 90 SWAP1 0983 51 MLOAD 0984 90 SWAP1 0985 81 DUP2 0986 90 SWAP1 0987 03 SUB 0988 60 PUSH1 0x64 098A 01 ADD 098B 90 SWAP1 098C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @094D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0954 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @095B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @0981 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x64732d70726f78792d63616368652d616464726573732d726571756972656400 // @098C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_098D: // Incoming jump from 0x0926, if !!(stack[-2] & 0x02 ** 0xa0 - 0x01) // Inputs[3] // { // @0992 storage[0x01] // @099B stack[-2] // @09B9 stack[-3] // } 098D 5B JUMPDEST 098E 50 POP 098F 60 PUSH1 0x01 0991 80 DUP1 0992 54 SLOAD 0993 60 PUSH1 0x01 0995 60 PUSH1 0xa0 0997 60 PUSH1 0x02 0999 0A EXP 099A 03 SUB 099B 83 DUP4 099C 16 AND 099D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09B2 19 NOT 09B3 90 SWAP1 09B4 91 SWAP2 09B5 16 AND 09B6 17 OR 09B7 81 DUP2 09B8 55 SSTORE 09B9 91 SWAP2 09BA 90 SWAP1 09BB 50 POP 09BC 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @09B8 storage[0x01] = (storage[0x01] & ~0xffffffffffffffffffffffffffffffffffffffff) | (stack[-2] & 0x02 ** 0xa0 - 0x01) // @09B9 stack[-3] = 0x01 // } // Block ends with unconditional jump to stack[-3] label_09BD: // Incoming jump from 0x0490 // Inputs[3] // { // @09BE msg.sender // @09CC memory[0x00:0x40] // @09CD storage[keccak256(memory[0x00:0x40])] // } 09BD 5B JUMPDEST 09BE 33 CALLER 09BF 60 PUSH1 0x00 09C1 90 SWAP1 09C2 81 DUP2 09C3 52 MSTORE 09C4 60 PUSH1 0x20 09C6 81 DUP2 09C7 90 SWAP1 09C8 52 MSTORE 09C9 60 PUSH1 0x40 09CB 90 SWAP1 09CC 20 SHA3 09CD 54 SLOAD 09CE 60 PUSH1 0x01 09D0 14 EQ 09D1 61 PUSH2 0x09d9 09D4 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @09C3 memory[0x00:0x20] = msg.sender // @09C8 memory[0x20:0x40] = 0x00 // } // Block ends with conditional jump to 0x09d9, if 0x01 == storage[keccak256(memory[0x00:0x40])] label_09D5: // Incoming jump from 0x09D4, if not 0x01 == storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @09D8 memory[0x00:0x00] } 09D5 60 PUSH1 0x00 09D7 80 DUP1 09D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @09D8 revert(memory[0x00:0x00]); } // Block terminates label_09D9: // Incoming jump from 0x09D4, if 0x01 == storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @09E2 stack[-1] // @09F0 memory[0x00:0x40] // @09F2 stack[-2] // } 09D9 5B JUMPDEST 09DA 60 PUSH1 0x01 09DC 60 PUSH1 0xa0 09DE 60 PUSH1 0x02 09E0 0A EXP 09E1 03 SUB 09E2 16 AND 09E3 60 PUSH1 0x00 09E5 90 SWAP1 09E6 81 DUP2 09E7 52 MSTORE 09E8 60 PUSH1 0x20 09EA 81 DUP2 09EB 90 SWAP1 09EC 52 MSTORE 09ED 60 PUSH1 0x40 09EF 81 DUP2 09F0 20 SHA3 09F1 55 SSTORE 09F2 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @09E7 memory[0x00:0x20] = 0x02 ** 0xa0 - 0x01 & stack[-1] // @09EC memory[0x20:0x40] = 0x00 // @09F1 storage[keccak256(memory[0x00:0x40])] = 0x00 // } // Block ends with unconditional jump to stack[-2] label_09F3: // Incoming jump from 0x05BD // Inputs[5] // { // @09F6 storage[0x01] // @09F9 memory[0x40:0x60] // @0A26 stack[-2] // @0A27 memory[stack[-2]:stack[-2] + 0x20] // @0A2E memory[stack[-2]:stack[-2] + 0x20] // } 09F3 5B JUMPDEST 09F4 60 PUSH1 0x01 09F6 54 SLOAD 09F7 60 PUSH1 0x40 09F9 51 MLOAD 09FA 7F PUSH32 0x8bf4515c00000000000000000000000000000000000000000000000000000000 0A1B 81 DUP2 0A1C 52 MSTORE 0A1D 60 PUSH1 0x20 0A1F 60 PUSH1 0x04 0A21 82 DUP3 0A22 01 ADD 0A23 81 DUP2 0A24 81 DUP2 0A25 52 MSTORE 0A26 85 DUP6 0A27 51 MLOAD 0A28 60 PUSH1 0x24 0A2A 84 DUP5 0A2B 01 ADD 0A2C 52 MSTORE 0A2D 85 DUP6 0A2E 51 MLOAD 0A2F 60 PUSH1 0x60 0A31 94 SWAP5 0A32 60 PUSH1 0x00 0A34 94 SWAP5 0A35 60 PUSH1 0x01 0A37 60 PUSH1 0xa0 0A39 60 PUSH1 0x02 0A3B 0A EXP 0A3C 03 SUB 0A3D 90 SWAP1 0A3E 91 SWAP2 0A3F 16 AND 0A40 93 SWAP4 0A41 63 PUSH4 0x8bf4515c 0A46 93 SWAP4 0A47 89 DUP10 0A48 93 SWAP4 0A49 90 SWAP1 0A4A 92 SWAP3 0A4B 83 DUP4 0A4C 92 SWAP3 0A4D 60 PUSH1 0x44 0A4F 90 SWAP1 0A50 91 SWAP2 0A51 01 ADD 0A52 91 SWAP2 0A53 90 SWAP1 0A54 85 DUP6 0A55 01 ADD 0A56 90 SWAP1 0A57 80 DUP1 0A58 83 DUP4 0A59 83 DUP4 0A5A 8B DUP12 0A5B 5B JUMPDEST 0A5C 83 DUP4 0A5D 81 DUP2 0A5E 10 LT 0A5F 15 ISZERO 0A60 61 PUSH2 0x0a73 0A63 57 *JUMPI // Stack delta = +14 // Outputs[17] // { // @0A1C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x8bf4515c00000000000000000000000000000000000000000000000000000000 // @0A25 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A2C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @0A31 stack[0] = 0x60 // @0A34 stack[1] = 0x00 // @0A40 stack[2] = storage[0x01] & 0x02 ** 0xa0 - 0x01 // @0A46 stack[3] = 0x8bf4515c // @0A48 stack[4] = stack[-2] // @0A4A stack[5] = memory[0x40:0x60] + 0x04 // @0A4C stack[6] = memory[0x40:0x60] + 0x04 // @0A52 stack[7] = memory[0x40:0x60] + 0x44 // @0A56 stack[8] = stack[-2] + 0x20 // @0A56 stack[9] = memory[stack[-2]:stack[-2] + 0x20] // @0A57 stack[10] = memory[stack[-2]:stack[-2] + 0x20] // @0A58 stack[11] = memory[0x40:0x60] + 0x44 // @0A59 stack[12] = stack[-2] + 0x20 // @0A5A stack[13] = 0x00 // } // Block ends with conditional jump to 0x0a73, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_0A64: // Incoming jump from 0x0A63, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0A63, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[4] // { // @0A64 stack[-2] // @0A65 stack[-1] // @0A67 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0A68 stack[-3] // } 0A64 81 DUP2 0A65 81 DUP2 0A66 01 ADD 0A67 51 MLOAD 0A68 83 DUP4 0A69 82 DUP3 0A6A 01 ADD 0A6B 52 MSTORE 0A6C 60 PUSH1 0x20 0A6E 01 ADD 0A6F 61 PUSH2 0x0a5b 0A72 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0A6B memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0A6E stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x0a5b label_0A73: // Incoming jump from 0x0A63, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0A63, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @0A78 stack[-6] // @0A78 stack[-5] // @0A7A stack[-7] // } 0A73 5B JUMPDEST 0A74 50 POP 0A75 50 POP 0A76 50 POP 0A77 50 POP 0A78 90 SWAP1 0A79 50 POP 0A7A 90 SWAP1 0A7B 81 DUP2 0A7C 01 ADD 0A7D 90 SWAP1 0A7E 60 PUSH1 0x1f 0A80 16 AND 0A81 80 DUP1 0A82 15 ISZERO 0A83 61 PUSH2 0x0aa0 0A86 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0A7D stack[-7] = stack[-5] + stack[-7] // @0A80 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0aa0, if !(0x1f & stack[-5]) label_0A87: // Incoming jump from 0x0A86, if not !(0x1f & stack[-5]) // Inputs[7] // { // @0A87 stack[-1] // @0A88 stack[-2] // @0A8B memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0AA2 stack[-5] // @0AAA memory[0x40:0x60] // @0AAF stack[-7] // @0AB1 address(stack[-7]).code.length // } 0A87 80 DUP1 0A88 82 DUP3 0A89 03 SUB 0A8A 80 DUP1 0A8B 51 MLOAD 0A8C 60 PUSH1 0x01 0A8E 83 DUP4 0A8F 60 PUSH1 0x20 0A91 03 SUB 0A92 61 PUSH2 0x0100 0A95 0A EXP 0A96 03 SUB 0A97 19 NOT 0A98 16 AND 0A99 81 DUP2 0A9A 52 MSTORE 0A9B 60 PUSH1 0x20 0A9D 01 ADD 0A9E 91 SWAP2 0A9F 50 POP 0AA0 5B JUMPDEST 0AA1 50 POP 0AA2 92 SWAP3 0AA3 50 POP 0AA4 50 POP 0AA5 50 POP 0AA6 60 PUSH1 0x20 0AA8 60 PUSH1 0x40 0AAA 51 MLOAD 0AAB 80 DUP1 0AAC 83 DUP4 0AAD 03 SUB 0AAE 81 DUP2 0AAF 86 DUP7 0AB0 80 DUP1 0AB1 3B EXTCODESIZE 0AB2 15 ISZERO 0AB3 80 DUP1 0AB4 15 ISZERO 0AB5 61 PUSH2 0x0abd 0AB8 57 *JUMPI // Stack delta = +2 // Outputs[8] // { // @0A9A memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0AA2 stack[-5] = 0x20 + (stack[-2] - stack[-1]) // @0AA6 stack[-4] = 0x20 // @0AAA stack[-3] = memory[0x40:0x60] // @0AAD stack[-2] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @0AAE stack[-1] = memory[0x40:0x60] // @0AAF stack[0] = stack[-7] // @0AB2 stack[1] = !address(stack[-7]).code.length // } // Block ends with conditional jump to 0x0abd, if !!address(stack[-7]).code.length label_0AB9: // Incoming jump from 0x0AB8, if not !!address(stack[-7]).code.length // Incoming jump from 0x0AB8, if not !!address(stack[-7]).code.length // Inputs[1] { @0ABC memory[0x00:0x00] } 0AB9 60 PUSH1 0x00 0ABB 80 DUP1 0ABC FD *REVERT // Stack delta = +0 // Outputs[1] { @0ABC revert(memory[0x00:0x00]); } // Block terminates label_0ABD: // Incoming jump from 0x0AB8, if !!address(stack[-7]).code.length // Incoming jump from 0x0AB8, if !!address(stack[-7]).code.length // Inputs[8] // { // @0ABF msg.gas // @0AC0 stack[-3] // @0AC0 stack[-5] // @0AC0 stack[-6] // @0AC0 stack[-4] // @0AC0 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0AC0 memory[stack[-3]:stack[-3] + stack[-4]] // @0AC0 stack[-2] // } 0ABD 5B JUMPDEST 0ABE 50 POP 0ABF 5A GAS 0AC0 FA STATICCALL 0AC1 15 ISZERO 0AC2 80 DUP1 0AC3 15 ISZERO 0AC4 61 PUSH2 0x0ad1 0AC7 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0AC0 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0AC1 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0ad1, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0AC8: // Incoming jump from 0x0AC7, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0AC8 returndata.length // @0ACC returndata[0x00:0x00 + returndata.length] // @0ACD returndata.length // @0AD0 memory[0x00:0x00 + returndata.length] // } 0AC8 3D RETURNDATASIZE 0AC9 60 PUSH1 0x00 0ACB 80 DUP1 0ACC 3E RETURNDATACOPY 0ACD 3D RETURNDATASIZE 0ACE 60 PUSH1 0x00 0AD0 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0ACC memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0AD0 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0AD1: // Incoming jump from 0x0AC7, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0AD8 memory[0x40:0x60] // @0AD9 returndata.length // } 0AD1 5B JUMPDEST 0AD2 50 POP 0AD3 50 POP 0AD4 50 POP 0AD5 50 POP 0AD6 60 PUSH1 0x40 0AD8 51 MLOAD 0AD9 3D RETURNDATASIZE 0ADA 60 PUSH1 0x20 0ADC 81 DUP2 0ADD 10 LT 0ADE 15 ISZERO 0ADF 61 PUSH2 0x0ae7 0AE2 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0AD8 stack[-4] = memory[0x40:0x60] // @0AD9 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0ae7, if !(returndata.length < 0x20) label_0AE3: // Incoming jump from 0x0AE2, if not !(returndata.length < 0x20) // Inputs[1] { @0AE6 memory[0x00:0x00] } 0AE3 60 PUSH1 0x00 0AE5 80 DUP1 0AE6 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AE6 revert(memory[0x00:0x00]); } // Block terminates label_0AE7: // Incoming jump from 0x0AE2, if !(returndata.length < 0x20) // Inputs[3] // { // @0AE9 stack[-2] // @0AE9 memory[stack[-2]:stack[-2] + 0x20] // @0AEA stack[-3] // } 0AE7 5B JUMPDEST 0AE8 50 POP 0AE9 51 MLOAD 0AEA 90 SWAP1 0AEB 50 POP 0AEC 60 PUSH1 0x01 0AEE 60 PUSH1 0xa0 0AF0 60 PUSH1 0x02 0AF2 0A EXP 0AF3 03 SUB 0AF4 81 DUP2 0AF5 16 AND 0AF6 15 ISZERO 0AF7 15 ISZERO 0AF8 61 PUSH2 0x0bef 0AFB 57 *JUMPI // Stack delta = -2 // Outputs[1] { @0AEA stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0bef, if !!(memory[stack[-2]:stack[-2] + 0x20] & 0x02 ** 0xa0 - 0x01) label_0AFC: // Incoming jump from 0x0AFB, if not !!(memory[stack[-2]:stack[-2] + 0x20] & 0x02 ** 0xa0 - 0x01) // Inputs[5] // { // @0AFE storage[0x01] // @0B01 memory[0x40:0x60] // @0B2E stack[-4] // @0B2F memory[stack[-4]:stack[-4] + 0x20] // @0B36 memory[stack[-4]:stack[-4] + 0x20] // } 0AFC 60 PUSH1 0x01 0AFE 54 SLOAD 0AFF 60 PUSH1 0x40 0B01 51 MLOAD 0B02 7F PUSH32 0x7ed0c3b200000000000000000000000000000000000000000000000000000000 0B23 81 DUP2 0B24 52 MSTORE 0B25 60 PUSH1 0x20 0B27 60 PUSH1 0x04 0B29 82 DUP3 0B2A 01 ADD 0B2B 81 DUP2 0B2C 81 DUP2 0B2D 52 MSTORE 0B2E 87 DUP8 0B2F 51 MLOAD 0B30 60 PUSH1 0x24 0B32 84 DUP5 0B33 01 ADD 0B34 52 MSTORE 0B35 87 DUP8 0B36 51 MLOAD 0B37 60 PUSH1 0x01 0B39 60 PUSH1 0xa0 0B3B 60 PUSH1 0x02 0B3D 0A EXP 0B3E 03 SUB 0B3F 90 SWAP1 0B40 94 SWAP5 0B41 16 AND 0B42 93 SWAP4 0B43 63 PUSH4 0x7ed0c3b2 0B48 93 SWAP4 0B49 89 DUP10 0B4A 93 SWAP4 0B4B 83 DUP4 0B4C 92 SWAP3 0B4D 60 PUSH1 0x44 0B4F 90 SWAP1 0B50 92 SWAP3 0B51 01 ADD 0B52 91 SWAP2 0B53 90 SWAP1 0B54 85 DUP6 0B55 01 ADD 0B56 90 SWAP1 0B57 80 DUP1 0B58 83 DUP4 0B59 83 DUP4 0B5A 60 PUSH1 0x00 0B5C 5B JUMPDEST 0B5D 83 DUP4 0B5E 81 DUP2 0B5F 10 LT 0B60 15 ISZERO 0B61 61 PUSH2 0x0b74 0B64 57 *JUMPI // Stack delta = +12 // Outputs[15] // { // @0B24 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x7ed0c3b200000000000000000000000000000000000000000000000000000000 // @0B2A stack[3] = memory[0x40:0x60] + 0x04 // @0B2D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B34 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = memory[stack[-4]:stack[-4] + 0x20] // @0B42 stack[0] = storage[0x01] & 0x02 ** 0xa0 - 0x01 // @0B48 stack[1] = 0x7ed0c3b2 // @0B4A stack[2] = stack[-4] // @0B4C stack[4] = memory[0x40:0x60] + 0x04 // @0B52 stack[5] = memory[0x40:0x60] + 0x44 // @0B56 stack[6] = stack[-4] + 0x20 // @0B56 stack[7] = memory[stack[-4]:stack[-4] + 0x20] // @0B57 stack[8] = memory[stack[-4]:stack[-4] + 0x20] // @0B58 stack[9] = memory[0x40:0x60] + 0x44 // @0B59 stack[10] = stack[-4] + 0x20 // @0B5A stack[11] = 0x00 // } // Block ends with conditional jump to 0x0b74, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) label_0B65: // Incoming jump from 0x0B64, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x0B64, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0B65 stack[-2] // @0B66 stack[-1] // @0B68 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0B69 stack[-3] // } 0B65 81 DUP2 0B66 81 DUP2 0B67 01 ADD 0B68 51 MLOAD 0B69 83 DUP4 0B6A 82 DUP3 0B6B 01 ADD 0B6C 52 MSTORE 0B6D 60 PUSH1 0x20 0B6F 01 ADD 0B70 61 PUSH2 0x0b5c 0B73 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0B6C memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0B6F stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x0b5c label_0B74: // Incoming jump from 0x0B64, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x0B64, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0B79 stack[-6] // @0B79 stack[-5] // @0B7B stack[-7] // } 0B74 5B JUMPDEST 0B75 50 POP 0B76 50 POP 0B77 50 POP 0B78 50 POP 0B79 90 SWAP1 0B7A 50 POP 0B7B 90 SWAP1 0B7C 81 DUP2 0B7D 01 ADD 0B7E 90 SWAP1 0B7F 60 PUSH1 0x1f 0B81 16 AND 0B82 80 DUP1 0B83 15 ISZERO 0B84 61 PUSH2 0x0ba1 0B87 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0B7E stack[-7] = stack[-5] + stack[-7] // @0B81 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0ba1, if !(0x1f & stack[-5]) label_0B88: // Incoming jump from 0x0B87, if not !(0x1f & stack[-5]) // Inputs[7] // { // @0B88 stack[-1] // @0B89 stack[-2] // @0B8C memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0BA3 stack[-5] // @0BAB memory[0x40:0x60] // @0BB2 stack[-7] // @0BB4 address(stack[-7]).code.length // } 0B88 80 DUP1 0B89 82 DUP3 0B8A 03 SUB 0B8B 80 DUP1 0B8C 51 MLOAD 0B8D 60 PUSH1 0x01 0B8F 83 DUP4 0B90 60 PUSH1 0x20 0B92 03 SUB 0B93 61 PUSH2 0x0100 0B96 0A EXP 0B97 03 SUB 0B98 19 NOT 0B99 16 AND 0B9A 81 DUP2 0B9B 52 MSTORE 0B9C 60 PUSH1 0x20 0B9E 01 ADD 0B9F 91 SWAP2 0BA0 50 POP 0BA1 5B JUMPDEST 0BA2 50 POP 0BA3 92 SWAP3 0BA4 50 POP 0BA5 50 POP 0BA6 50 POP 0BA7 60 PUSH1 0x20 0BA9 60 PUSH1 0x40 0BAB 51 MLOAD 0BAC 80 DUP1 0BAD 83 DUP4 0BAE 03 SUB 0BAF 81 DUP2 0BB0 60 PUSH1 0x00 0BB2 87 DUP8 0BB3 80 DUP1 0BB4 3B EXTCODESIZE 0BB5 15 ISZERO 0BB6 80 DUP1 0BB7 15 ISZERO 0BB8 61 PUSH2 0x0bc0 0BBB 57 *JUMPI // Stack delta = +3 // Outputs[9] // { // @0B9B memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0BA3 stack[-5] = 0x20 + (stack[-2] - stack[-1]) // @0BA7 stack[-4] = 0x20 // @0BAB stack[-3] = memory[0x40:0x60] // @0BAE stack[-2] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @0BAF stack[-1] = memory[0x40:0x60] // @0BB0 stack[0] = 0x00 // @0BB2 stack[1] = stack[-7] // @0BB5 stack[2] = !address(stack[-7]).code.length // } // Block ends with conditional jump to 0x0bc0, if !!address(stack[-7]).code.length label_0BBC: // Incoming jump from 0x0BBB, if not !!address(stack[-7]).code.length // Incoming jump from 0x0BBB, if not !!address(stack[-7]).code.length // Inputs[1] { @0BBF memory[0x00:0x00] } 0BBC 60 PUSH1 0x00 0BBE 80 DUP1 0BBF FD *REVERT // Stack delta = +0 // Outputs[1] { @0BBF revert(memory[0x00:0x00]); } // Block terminates label_0BC0: // Incoming jump from 0x0BBB, if !!address(stack[-7]).code.length // Incoming jump from 0x0BBB, if !!address(stack[-7]).code.length // Inputs[9] // { // @0BC2 msg.gas // @0BC3 stack[-4] // @0BC3 stack[-5] // @0BC3 stack[-7] // @0BC3 stack[-6] // @0BC3 memory[stack[-4]:stack[-4] + stack[-5]] // @0BC3 stack[-3] // @0BC3 stack[-2] // @0BC3 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 0BC0 5B JUMPDEST 0BC1 50 POP 0BC2 5A GAS 0BC3 F1 CALL 0BC4 15 ISZERO 0BC5 80 DUP1 0BC6 15 ISZERO 0BC7 61 PUSH2 0x0bd4 0BCA 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0BC3 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0BC4 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x0bd4, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0BCB: // Incoming jump from 0x0BCA, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0BCB returndata.length // @0BCF returndata[0x00:0x00 + returndata.length] // @0BD0 returndata.length // @0BD3 memory[0x00:0x00 + returndata.length] // } 0BCB 3D RETURNDATASIZE 0BCC 60 PUSH1 0x00 0BCE 80 DUP1 0BCF 3E RETURNDATACOPY 0BD0 3D RETURNDATASIZE 0BD1 60 PUSH1 0x00 0BD3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0BCF memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0BD3 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0BD4: // Incoming jump from 0x0BCA, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @0BDB memory[0x40:0x60] // @0BDC returndata.length // } 0BD4 5B JUMPDEST 0BD5 50 POP 0BD6 50 POP 0BD7 50 POP 0BD8 50 POP 0BD9 60 PUSH1 0x40 0BDB 51 MLOAD 0BDC 3D RETURNDATASIZE 0BDD 60 PUSH1 0x20 0BDF 81 DUP2 0BE0 10 LT 0BE1 15 ISZERO 0BE2 61 PUSH2 0x0bea 0BE5 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0BDB stack[-4] = memory[0x40:0x60] // @0BDC stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0bea, if !(returndata.length < 0x20) label_0BE6: // Incoming jump from 0x0BE5, if not !(returndata.length < 0x20) // Inputs[1] { @0BE9 memory[0x00:0x00] } 0BE6 60 PUSH1 0x00 0BE8 80 DUP1 0BE9 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BE9 revert(memory[0x00:0x00]); } // Block terminates label_0BEA: // Incoming jump from 0x0BE5, if !(returndata.length < 0x20) // Inputs[3] // { // @0BEC stack[-2] // @0BEC memory[stack[-2]:stack[-2] + 0x20] // @0BED stack[-3] // } 0BEA 5B JUMPDEST 0BEB 50 POP 0BEC 51 MLOAD 0BED 90 SWAP1 0BEE 50 POP // Stack delta = -2 // Outputs[1] { @0BED stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block continues label_0BEF: // Incoming jump from 0x0BEE // Incoming jump from 0x0AFB, if !!(memory[stack[-2]:stack[-2] + 0x20] & 0x02 ** 0xa0 - 0x01) // Inputs[2] // { // @0BF3 stack[-1] // @0BF4 stack[-3] // } 0BEF 5B JUMPDEST 0BF0 61 PUSH2 0x0bf9 0BF3 81 DUP2 0BF4 84 DUP5 0BF5 61 PUSH2 0x088f 0BF8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BF0 stack[0] = 0x0bf9 // @0BF3 stack[1] = stack[-1] // @0BF4 stack[2] = stack[-3] // } // Block ends with call to 0x088f, returns to 0x0BF9 label_0BF9: // Incoming return from call to 0x088F at 0x0BF8 // Inputs[3] // { // @0BFA stack[-1] // @0BFA stack[-6] // @0BFB stack[-5] // } 0BF9 5B JUMPDEST 0BFA 94 SWAP5 0BFB 93 SWAP4 0BFC 50 POP 0BFD 50 POP 0BFE 50 POP 0BFF 50 POP 0C00 56 *JUMP // Stack delta = -5 // Outputs[1] { @0BFA stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0C01: // Incoming jump from 0x05F0 // Inputs[4] // { // @0C09 stack[-1] // @0C0F memory[0x00:0x40] // @0C10 storage[keccak256(memory[0x00:0x40])] // @0C11 stack[-2] // } 0C01 5B JUMPDEST 0C02 60 PUSH1 0x00 0C04 60 PUSH1 0x20 0C06 81 DUP2 0C07 90 SWAP1 0C08 52 MSTORE 0C09 90 SWAP1 0C0A 81 DUP2 0C0B 52 MSTORE 0C0C 60 PUSH1 0x40 0C0E 90 SWAP1 0C0F 20 SHA3 0C10 54 SLOAD 0C11 81 DUP2 0C12 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0C08 memory[0x20:0x40] = 0x00 // @0C0B memory[0x00:0x20] = stack[-1] // @0C10 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] 0C13 FE *ASSERT 0C14 A1 LOG1 0C15 65 PUSH6 0x627a7a723058 0C1C 20 SHA3 0C1D D2 D2 0C1E CB CB 0C1F 37 CALLDATACOPY 0C20 09 MULMOD 0C21 1B SHL 0C22 9F SWAP16 0C23 EA EA 0C24 78 PUSH25 0x618babf87ea1e2213f2acdaa5676752f200e6d4bdd52ab0800 0C3E 29 29
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]