Online Solidity Decompiler

« Decompile another contract

Address

0x8017624c3797be8ca8666e7545768a341253de83 [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.
0x10d1e85c uniswapV2Call(address,uint256,uint256,bytes)
0x4dede3de WBTC()
0x57376198 rescueTokens(address,uint256)
0x5bd717a4 Unknown
0x715018a6 renounceOwnership()
0x8da5cb5b owner()
0x8ed36a4f Unknown
0x9e252f00 rescueETH(uint256)
0xc0c06fef Unknown
0xc90cc44d Unknown
0xeb2c7de3 Unknown
0xf2fde38b transferOwnership(address)
0xf3d3d448 setControllerAddress(address)
0xf77c4791 controller()
0xfd9af456 Unknown

Internal Methods

rescueTokens(arg0, arg1)
func_03AA(arg0, arg1)
rescueETH(arg0, arg1)
func_056E(arg0, arg1) returns (r0)
func_0725(arg0, arg1) returns (r0)
transferOwnership(arg0, arg1)
setControllerAddress(arg0, arg1)
WBTC(arg0) returns (r0)
func_0C9C(arg0, arg1, arg2, arg6) returns (r0)
func_0CFC(arg0, arg1, arg2, arg6) returns (r0)
func_0D58(arg0, arg1, arg2, arg3) returns (r0)
func_0D6F(arg0, arg1, arg2, arg4, arg6, arg7)
renounceOwnership()
owner() returns (r0)
func_0EF0(arg0) returns (r0)
controller(arg0) returns (r0)
func_1080()
func_13C1(arg0, arg1, arg2, arg3)
func_15A5(arg0, arg1, arg2, arg4, arg6, arg7, arg8)
func_18F0(arg0, arg1, arg2, arg3, arg4)
func_1949(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) returns (r0)
func_1BEC(arg0, arg1, arg2, arg3, arg5, arg6, arg7)
func_1D6A() returns (r0)
func_1D6E(arg0) returns (r0, r1)
func_1EDB(arg0, arg1, arg2, arg3) returns (r0)
func_1F7B(arg0, arg1, arg11) returns (r0)
func_1F96(arg0, arg1) returns (r0)
func_1F9C(arg0, arg2, arg4) returns (r0)
func_1FA9(arg0, arg1, arg2, arg4, arg6) returns (r0)
func_2010(arg0, arg2, arg4) returns (r0)
func_201D(arg0, arg1, arg2, arg4, arg6) returns (r0)
func_2154(arg0, arg1) returns (r0)
func_2184(arg0, arg1, arg2) returns (r0)
func_221B(arg0, arg1, arg2, arg3, arg4, arg5)
func_2620(arg0, arg1, arg2) returns (r0, r1, r2)
func_281A(arg0, arg1, arg2, arg8) returns (r0)
func_285B(arg0, arg1, arg2, arg8) returns (r0)
func_28C6(arg0, arg1, arg2, arg9) returns (r0)
func_290A(arg0, arg1, arg2, arg9) returns (r0)
func_2978(arg0, arg1, arg2, arg10) returns (r0)
func_29BC(arg0, arg1, arg2, arg10) returns (r0)
func_2A8E(arg0, arg1)
func_2AC9(arg0, arg1, arg2)
func_2D34(arg0, arg1) returns (r0)
func_2D7F(arg0, arg1) returns (r0)
func_2ED5(arg0, arg1) returns (r0)
func_2EF2(arg0, arg1, arg2, arg3) returns (r0)
func_2FC4(arg0, arg1, arg2) returns (r0)

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x80; var var0 = msg.value; if (var0) { revert(memory[0x00:0x00]); } if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); } var0 = msg.data[0x00:0x20] >> 0xe0; if (0x9e252f00 > var0) { if (0x5bd717a4 > var0) { if (var0 == 0x10d1e85c) { // Dispatch table entry for uniswapV2Call(address,uint256,uint256,bytes) var var1 = 0x0184; var var2 = 0x04; var var3 = msg.data.length - var2; if (var3 < 0x80) { revert(memory[0x00:0x00]); } var temp0 = var2; var2 = msg.data[temp0:temp0 + 0x20] & (0x01 << 0xa0) - 0x01; var temp1 = var3; var3 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20]; var var4 = msg.data[temp0 + 0x40:temp0 + 0x40 + 0x20]; var var6 = temp0; var var5 = var6 + temp1; var var7 = var6 + 0x80; var var8 = msg.data[var6 + 0x60:var6 + 0x60 + 0x20]; if (var8 > 0x01 << 0x20) { revert(memory[0x00:0x00]); } var temp2 = var6 + var8; var8 = temp2; if (var8 + 0x20 > var5) { revert(memory[0x00:0x00]); } var temp3 = var8; var temp4 = msg.data[temp3:temp3 + 0x20]; var8 = temp4; var var9 = var7; var7 = temp3 + 0x20; if ((var8 > 0x01 << 0x20) | (var7 + var8 > var5)) { revert(memory[0x00:0x00]); } var5 = var7; var6 = var8; var7 = 0x00; var8 = var7; var9 = 0x60; var var10 = var9; var var11 = 0x60; var var12 = var5; var var13 = var6; if (var13 < 0xa0) { revert(memory[0x00:0x00]); } var temp5 = var12; var12 = msg.data[temp5:temp5 + 0x20]; var temp6 = var13; var13 = !!msg.data[temp5 + 0x20:temp5 + 0x20 + 0x20]; var var15 = temp5; var var14 = var15 + temp6; var var16 = var15 + 0x60; var var17 = msg.data[var15 + 0x40:var15 + 0x40 + 0x20]; if (var17 > 0x01 << 0x20) { revert(memory[0x00:0x00]); } var temp7 = var15 + var17; var17 = temp7; if (var17 + 0x20 > var14) { revert(memory[0x00:0x00]); } var temp8 = var17; var temp9 = msg.data[temp8:temp8 + 0x20]; var17 = temp9; var var18 = var16; var16 = temp8 + 0x20; if ((var17 > 0x01 << 0x20) | (var16 + var17 * 0x20 > var14)) { revert(memory[0x00:0x00]); } var temp10 = var18; var temp11 = var17; var temp12 = memory[0x40:0x60]; memory[0x40:0x60] = temp12 + temp11 * 0x20 + 0x20; memory[temp12:temp12 + 0x20] = temp11; var temp13 = temp12 + 0x20; var temp14 = temp11 * 0x20; memory[temp13:temp13 + temp14] = msg.data[var16:var16 + temp14]; memory[temp13 + temp14:temp13 + temp14 + 0x20] = 0x00; var temp15 = var14; var14 = temp12; var temp16 = var15; var15 = temp15; var16 = temp16; var17 = temp10 + 0x20; var18 = msg.data[temp10:temp10 + 0x20]; if (var18 > 0x01 << 0x20) { revert(memory[0x00:0x00]); } var temp17 = var16 + var18; var18 = temp17; if (var18 + 0x20 > var15) { revert(memory[0x00:0x00]); } var temp18 = var18; var temp19 = msg.data[temp18:temp18 + 0x20]; var18 = temp19; var temp20 = var17; var17 = temp18 + 0x20; var var19 = temp20; if ((var18 > 0x01 << 0x20) | (var17 + var18 * 0x20 > var15)) { revert(memory[0x00:0x00]); } var temp21 = var19; var temp22 = var18; var temp23 = memory[0x40:0x60]; memory[0x40:0x60] = temp23 + temp22 * 0x20 + 0x20; memory[temp23:temp23 + 0x20] = temp22; var temp24 = temp23 + 0x20; var temp25 = temp22 * 0x20; memory[temp24:temp24 + temp25] = msg.data[var17:var17 + temp25]; memory[temp24 + temp25:temp24 + temp25 + 0x20] = 0x00; var temp26 = var15; var15 = temp23; var temp27 = var16; var16 = temp26; var17 = temp27; var18 = temp21 + 0x20; var19 = msg.data[temp21:temp21 + 0x20]; if (var19 > 0x01 << 0x20) { revert(memory[0x00:0x00]); } var temp28 = var17 + var19; var19 = temp28; if (var19 + 0x20 > var16) { revert(memory[0x00:0x00]); } var temp29 = var19; var temp30 = msg.data[temp29:temp29 + 0x20]; var19 = temp30; var var20 = var18; var18 = temp29 + 0x20; if ((var19 > 0x01 << 0x20) | (var18 + var19 * 0x20 > var16)) { revert(memory[0x00:0x00]); } var temp31 = var19; var temp32 = memory[0x40:0x60]; memory[0x40:0x60] = temp32 + temp31 * 0x20 + 0x20; memory[temp32:temp32 + 0x20] = temp31; var temp33 = temp32 + 0x20; var temp34 = temp31 * 0x20; memory[temp33:temp33 + temp34] = msg.data[var18:var18 + temp34]; memory[temp33 + temp34:temp33 + temp34 + 0x20] = 0x00; var7 = var12; var8 = var13; var9 = var14; var10 = var15; var11 = temp32; if (!var8) { var12 = 0x0af9; var13 = var7; var14 = var9; var15 = var10; var16 = var11; var17 = memory[var14:var14 + 0x20] - 0x01; var18 = 0x00; var19 = var15; var20 = 0x00; if (var20 >= memory[var19:var19 + 0x20]) { assert(); } if (memory[var20 * 0x20 + 0x20 + var19:var20 * 0x20 + 0x20 + var19 + 0x20]) { var19 = var14; var20 = 0x00; if (var20 >= memory[var19:var19 + 0x20]) { assert(); } var temp35 = memory[var20 * 0x20 + 0x20 + var19:var20 * 0x20 + 0x20 + var19 + 0x20] & (0x01 << 0xa0) - 0x01; var19 = temp35; var20 = 0x0dfe1681; var temp36 = memory[0x40:0x60]; memory[temp36:temp36 + 0x20] = (var20 & 0xffffffff) << 0xe0; var var21 = temp36 + 0x04; var var22 = 0x20; var var23 = memory[0x40:0x60]; var var24 = var21 - var23; var var25 = var23; var var26 = var19; var var27 = !address(var26).code.length; if (var27) { revert(memory[0x00:0x00]); } var temp37; temp37, memory[var23:var23 + var22] = address(var26).staticcall.gas(msg.gas)(memory[var25:var25 + var24]); var22 = !temp37; if (!var22) { var19 = memory[0x40:0x60]; var20 = returndata.length; if (var20 < 0x20) { revert(memory[0x00:0x00]); } var19 = memory[var19:var19 + 0x20]; label_1AB4: var18 = var19; var19 = var18 & (0x01 << 0xa0) - 0x01; var20 = 0xa9059cbb; var21 = var14; var22 = 0x01; if (var22 >= memory[var21:var21 + 0x20]) { assert(); } var21 = memory[var22 * 0x20 + 0x20 + var21:var22 * 0x20 + 0x20 + var21 + 0x20]; var22 = var18 & (0x01 << 0xa0) - 0x01; var23 = 0x70a08231; var temp38 = memory[0x40:0x60]; memory[temp38:temp38 + 0x20] = (var23 & 0xffffffff) << 0xe0; var temp39 = temp38 + 0x04; memory[temp39:temp39 + 0x20] = address(this); var24 = temp39 + 0x20; var25 = 0x20; var26 = memory[0x40:0x60]; var27 = var24 - var26; var var28 = var26; var var29 = var22; var var30 = !address(var29).code.length; if (var30) { revert(memory[0x00:0x00]); } var temp40; temp40, memory[var26:var26 + var25] = address(var29).staticcall.gas(msg.gas)(memory[var28:var28 + var27]); var25 = !temp40; if (!var25) { var22 = memory[0x40:0x60]; var23 = returndata.length; if (var23 < 0x20) { revert(memory[0x00:0x00]); } var temp41 = memory[var22:var22 + 0x20]; var temp42 = memory[0x40:0x60]; memory[temp42:temp42 + 0x20] = (var20 << 0xe0) & ~((0x01 << 0xe0) - 0x01); memory[temp42 + 0x04:temp42 + 0x04 + 0x20] = var21 & (0x01 << 0xa0) - 0x01; memory[temp42 + 0x24:temp42 + 0x24 + 0x20] = temp41; var21 = temp42 + 0x44; var22 = 0x20; var23 = memory[0x40:0x60]; var24 = temp42 - var23 + 0x44; var25 = var23; var26 = 0x00; var27 = var19; var28 = !address(var27).code.length; if (var28) { revert(memory[0x00:0x00]); } var temp43; temp43, memory[var23:var23 + var22] = address(var27).call.gas(msg.gas).value(var26)(memory[var25:var25 + var24]); var22 = !temp43; if (!var22) { var19 = memory[0x40:0x60]; var20 = returndata.length; if (var20 < 0x20) { revert(memory[0x00:0x00]); } var19 = 0x01; if (var19 >= var17 + 0x01) { label_1C3D: var19 = 0x00; var20 = var15; var21 = 0x00; if (var21 >= memory[var20:var20 + 0x20]) { assert(); } if (memory[var21 * 0x20 + 0x20 + var20:var21 * 0x20 + 0x20 + var20 + 0x20]) { var20 = var14; var21 = 0x00; if (var21 >= memory[var20:var20 + 0x20]) { assert(); } var temp44 = memory[var21 * 0x20 + 0x20 + var20:var21 * 0x20 + 0x20 + var20 + 0x20] & (0x01 << 0xa0) - 0x01; var20 = temp44; var21 = 0xd21220a7; var temp45 = memory[0x40:0x60]; memory[temp45:temp45 + 0x20] = (var21 & 0xffffffff) << 0xe0; var22 = temp45 + 0x04; var23 = 0x20; var24 = memory[0x40:0x60]; var25 = var22 - var24; var26 = var24; var27 = var20; var28 = !address(var27).code.length; if (var28) { revert(memory[0x00:0x00]); } var temp46; temp46, memory[var24:var24 + var23] = address(var27).staticcall.gas(msg.gas)(memory[var26:var26 + var25]); var23 = !temp46; if (!var23) { var20 = memory[0x40:0x60]; var21 = returndata.length; if (var21 < 0x20) { revert(memory[0x00:0x00]); } var20 = memory[var20:var20 + 0x20]; label_1D51: var temp47 = var20; var19 = temp47; var13 = var13 - 0x01; var20 = 0x1980; var21 = var19; var22 = var14; var23 = 0x00; if (var23 >= memory[var22:var22 + 0x20]) { assert(); } func_18F0(var13, var19, var21, var22, var23); label_1980: var20 = 0x0e97; var21 = var19; var22 = storage[0x05] & (0x01 << 0xa0) - 0x01; var23 = var13; func_2AC9(var21, var22, var23); // Error: Could not resolve jump destination! } else { var temp48 = returndata.length; memory[0x00:0x00 + temp48] = returndata[0x00:0x00 + temp48]; revert(memory[0x00:0x00 + returndata.length]); } } else { var20 = var14; var21 = 0x00; if (var21 >= memory[var20:var20 + 0x20]) { assert(); } var temp49 = memory[var21 * 0x20 + 0x20 + var20:var21 * 0x20 + 0x20 + var20 + 0x20] & (0x01 << 0xa0) - 0x01; var20 = temp49; var21 = 0x0dfe1681; var temp50 = memory[0x40:0x60]; memory[temp50:temp50 + 0x20] = (var21 & 0xffffffff) << 0xe0; var22 = temp50 + 0x04; var23 = 0x20; var24 = memory[0x40:0x60]; var25 = var22 - var24; var26 = var24; var27 = var20; var28 = !address(var27).code.length; if (var28) { revert(memory[0x00:0x00]); } var temp51; temp51, memory[var24:var24 + var23] = address(var27).staticcall.gas(msg.gas)(memory[var26:var26 + var25]); var23 = !temp51; if (!var23) { var20 = memory[0x40:0x60]; var21 = returndata.length; if (var21 < 0x20) { revert(memory[0x00:0x00]); } var20 = memory[var20:var20 + 0x20]; goto label_1D51; } else { var temp52 = returndata.length; memory[0x00:0x00 + temp52] = returndata[0x00:0x00 + temp52]; revert(memory[0x00:0x00 + returndata.length]); } } } else { label_1BDE: var20 = 0x1c35; var21 = var14; var22 = var19; if (var22 >= memory[var21:var21 + 0x20]) { assert(); } func_1BEC(var14, var15, var16, var17, var19, var21, var22); var19 = var19 + 0x01; if (var19 >= var17 + 0x01) { goto label_1C3D; } else { goto label_1BDE; } } } else { var temp53 = returndata.length; memory[0x00:0x00 + temp53] = returndata[0x00:0x00 + temp53]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp54 = returndata.length; memory[0x00:0x00 + temp54] = returndata[0x00:0x00 + temp54]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp55 = returndata.length; memory[0x00:0x00 + temp55] = returndata[0x00:0x00 + temp55]; revert(memory[0x00:0x00 + returndata.length]); } } else { var19 = var14; var20 = 0x00; if (var20 >= memory[var19:var19 + 0x20]) { assert(); } var temp56 = memory[var20 * 0x20 + 0x20 + var19:var20 * 0x20 + 0x20 + var19 + 0x20] & (0x01 << 0xa0) - 0x01; var19 = temp56; var20 = 0xd21220a7; var temp57 = memory[0x40:0x60]; memory[temp57:temp57 + 0x20] = (var20 & 0xffffffff) << 0xe0; var21 = temp57 + 0x04; var22 = 0x20; var23 = memory[0x40:0x60]; var24 = var21 - var23; var25 = var23; var26 = var19; var27 = !address(var26).code.length; if (var27) { revert(memory[0x00:0x00]); } var temp58; temp58, memory[var23:var23 + var22] = address(var26).staticcall.gas(msg.gas)(memory[var25:var25 + var24]); var22 = !temp58; if (!var22) { var19 = memory[0x40:0x60]; var20 = returndata.length; if (var20 < 0x20) { revert(memory[0x00:0x00]); } var19 = memory[var19:var19 + 0x20]; goto label_1AB4; } else { var temp59 = returndata.length; memory[0x00:0x00 + temp59] = returndata[0x00:0x00 + temp59]; revert(memory[0x00:0x00 + returndata.length]); } } } else { var12 = 0x0ae8; var13 = var7; var14 = var9; var15 = var10; var16 = var11; var temp60 = memory[var14:var14 + 0x20]; var temp61 = memory[0x40:0x60]; memory[temp61:temp61 + 0x20] = 0x70a08231 << 0xe0; memory[temp61 + 0x04:temp61 + 0x04 + 0x20] = address(this); var17 = temp60 + ~0x00; var18 = 0x00; var19 = storage[0x03] & (0x01 << 0xa0) - 0x01; var20 = 0x70a08231; var21 = temp61 + 0x24; var22 = 0x20; var23 = memory[0x40:0x60]; var24 = temp61 - var23 + 0x24; var25 = var23; var26 = var18; var27 = var19; var28 = !address(var27).code.length; if (var28) { revert(memory[0x00:0x00]); } var temp62; temp62, memory[var23:var23 + var22] = address(var27).call.gas(msg.gas).value(var26)(memory[var25:var25 + var24]); var22 = !temp62; if (!var22) { var19 = memory[0x40:0x60]; var20 = returndata.length; if (var20 < 0x20) { revert(memory[0x00:0x00]); } var18 = memory[var19:var19 + 0x20]; if (!var18) { var19 = 0x00; var20 = var15; var21 = 0x00; if (var21 >= memory[var20:var20 + 0x20]) { assert(); } if (memory[var21 * 0x20 + 0x20 + var20:var21 * 0x20 + 0x20 + var20 + 0x20]) { var20 = var14; var21 = 0x00; if (var21 >= memory[var20:var20 + 0x20]) { assert(); } var temp63 = memory[var21 * 0x20 + 0x20 + var20:var21 * 0x20 + 0x20 + var20 + 0x20] & (0x01 << 0xa0) - 0x01; var20 = temp63; var21 = 0x0dfe1681; var temp64 = memory[0x40:0x60]; memory[temp64:temp64 + 0x20] = (var21 & 0xffffffff) << 0xe0; var22 = temp64 + 0x04; var23 = 0x20; var24 = memory[0x40:0x60]; var25 = var22 - var24; var26 = var24; var27 = var20; var28 = !address(var27).code.length; if (var28) { revert(memory[0x00:0x00]); } var temp65; temp65, memory[var24:var24 + var23] = address(var27).staticcall.gas(msg.gas)(memory[var26:var26 + var25]); var23 = !temp65; if (!var23) { var20 = memory[0x40:0x60]; var21 = returndata.length; if (var21 < 0x20) { revert(memory[0x00:0x00]); } var temp66 = memory[var20:var20 + 0x20]; var19 = temp66; var20 = 0x1447; var21 = var19; var22 = var14; var23 = 0x01; if (var23 >= memory[var22:var22 + 0x20]) { assert(); } func_13C1(var19, var21, var22, var23); label_1447: label_1449: var19 = 0x01; if (var19 >= var17 + 0x01) { label_171C: var19 = 0x00; var20 = var15; var21 = 0x00; if (var21 >= memory[var20:var20 + 0x20]) { assert(); } if (memory[var21 * 0x20 + 0x20 + var20:var21 * 0x20 + 0x20 + var20 + 0x20]) { var20 = var14; var21 = 0x00; if (var21 >= memory[var20:var20 + 0x20]) { assert(); } var temp67 = memory[var21 * 0x20 + 0x20 + var20:var21 * 0x20 + 0x20 + var20 + 0x20] & (0x01 << 0xa0) - 0x01; var20 = temp67; var21 = 0xd21220a7; var temp68 = memory[0x40:0x60]; memory[temp68:temp68 + 0x20] = (var21 & 0xffffffff) << 0xe0; var22 = temp68 + 0x04; var23 = 0x20; var24 = memory[0x40:0x60]; var25 = var22 - var24; var26 = var24; var27 = var20; var28 = !address(var27).code.length; if (var28) { revert(memory[0x00:0x00]); } var temp69; temp69, memory[var24:var24 + var23] = address(var27).staticcall.gas(msg.gas)(memory[var26:var26 + var25]); var23 = !temp69; if (!var23) { var20 = memory[0x40:0x60]; var21 = returndata.length; if (var21 < 0x20) { revert(memory[0x00:0x00]); } var19 = memory[var20:var20 + 0x20]; var temp70 = (0x01 << 0xa0) - 0x01; if (storage[0x03] & temp70 != var19 & temp70) { label_18D9: var13 = var13 - 0x01; var20 = 0x1980; var21 = var19; var22 = var14; var23 = 0x00; if (var23 >= memory[var22:var22 + 0x20]) { assert(); } func_18F0(var13, var19, var21, var22, var23); goto label_1980; } else { label_184A: var20 = storage[0x03] & (0x01 << 0xa0) - 0x01; var21 = 0xbf376c7a; var22 = address(this); var23 = var16; var24 = var17 + ~0x00; if (var24 >= memory[var23:var23 + 0x20]) { assert(); } var temp71 = memory[var24 * 0x20 + 0x20 + var23:var24 * 0x20 + 0x20 + var23 + 0x20]; var temp72 = memory[0x40:0x60]; memory[temp72:temp72 + 0x20] = (var21 & 0xffffffff) << 0xe0; var temp73 = temp72 + 0x04; memory[temp73:temp73 + 0x20] = var22 & (0x01 << 0xa0) - 0x01; var temp74 = temp73 + 0x20; memory[temp74:temp74 + 0x20] = temp71; var22 = temp74 + 0x20; var23 = 0x00; var24 = memory[0x40:0x60]; var25 = var22 - var24; var26 = var24; var27 = 0x00; var28 = var20; var29 = !address(var28).code.length; if (var29) { revert(memory[0x00:0x00]); } var temp75; temp75, memory[var24:var24 + var23] = address(var28).call.gas(msg.gas).value(var27)(memory[var26:var26 + var25]); var23 = !temp75; if (!var23) { goto label_18D9; } var temp76 = returndata.length; memory[0x00:0x00 + temp76] = returndata[0x00:0x00 + temp76]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp77 = returndata.length; memory[0x00:0x00 + temp77] = returndata[0x00:0x00 + temp77]; revert(memory[0x00:0x00 + returndata.length]); } } else { var20 = var14; var21 = 0x00; if (var21 >= memory[var20:var20 + 0x20]) { assert(); } var temp78 = memory[var21 * 0x20 + 0x20 + var20:var21 * 0x20 + 0x20 + var20 + 0x20] & (0x01 << 0xa0) - 0x01; var20 = temp78; var21 = 0x0dfe1681; var temp79 = memory[0x40:0x60]; memory[temp79:temp79 + 0x20] = (var21 & 0xffffffff) << 0xe0; var22 = temp79 + 0x04; var23 = 0x20; var24 = memory[0x40:0x60]; var25 = var22 - var24; var26 = var24; var27 = var20; var28 = !address(var27).code.length; if (var28) { revert(memory[0x00:0x00]); } var temp80; temp80, memory[var24:var24 + var23] = address(var27).staticcall.gas(msg.gas)(memory[var26:var26 + var25]); var23 = !temp80; if (!var23) { var20 = memory[0x40:0x60]; var21 = returndata.length; if (var21 < 0x20) { revert(memory[0x00:0x00]); } var20 = memory[var20:var20 + 0x20]; var19 = var20; var temp81 = (0x01 << 0xa0) - 0x01; if (storage[0x03] & temp81 != var19 & temp81) { goto label_18D9; } else { goto label_184A; } } else { var temp82 = returndata.length; memory[0x00:0x00 + temp82] = returndata[0x00:0x00 + temp82]; revert(memory[0x00:0x00 + returndata.length]); } } } else { label_1458: var20 = 0x00; var21 = storage[0x01] & (0x01 << 0xa0) - 0x01; var22 = var14; var23 = var19; if (var23 >= memory[var22:var22 + 0x20]) { assert(); } var temp83 = memory[var23 * 0x20 + 0x20 + var22:var23 * 0x20 + 0x20 + var22 + 0x20] & (0x01 << 0xa0) - 0x01 == var21; var20 = temp83; var21 = var20; if (!var21) { label_14A6: if (!var21) { label_1596: var21 = 0x1602; var22 = var14; var23 = var19; if (var23 >= memory[var22:var22 + 0x20]) { assert(); } func_15A5(var14, var15, var16, var17, var19, var22, var23); var21 = var20; if (!var21) { label_1620: if (!var21) { if (!var21) { label_1713: var19 = var19 + 0x01; if (var19 >= var17 + 0x01) { goto label_171C; } else { goto label_1458; } } else { label_1632: var temp84 = memory[0x40:0x60]; memory[temp84:temp84 + 0x20] = 0x70a08231 << 0xe0; memory[temp84 + 0x04:temp84 + 0x04 + 0x20] = address(this); var21 = 0x00; var22 = storage[0x03] & (0x01 << 0xa0) - 0x01; var23 = 0x70a08231; var24 = temp84 + 0x24; var25 = 0x20; var26 = memory[0x40:0x60]; var27 = temp84 - var26 + 0x24; var28 = var26; var29 = var21; var30 = var22; var var31 = !address(var30).code.length; if (var31) { revert(memory[0x00:0x00]); } var temp85; temp85, memory[var26:var26 + var25] = address(var30).call.gas(msg.gas).value(var29)(memory[var28:var28 + var27]); var25 = !temp85; if (!var25) { var22 = memory[0x40:0x60]; var23 = returndata.length; if (var23 < 0x20) { revert(memory[0x00:0x00]); } var temp86 = memory[var22:var22 + 0x20]; var temp87 = memory[0x40:0x60]; memory[temp87:temp87 + 0x20] = 0x6f074d1f << 0xe1; memory[temp87 + 0x04:temp87 + 0x04 + 0x20] = temp86; var21 = temp86; var22 = storage[0x03] & (0x01 << 0xa0) - 0x01; var23 = 0xde0e9a3e; var24 = temp87 + 0x24; var25 = 0x00; var26 = memory[0x40:0x60]; var27 = temp87 - var26 + 0x24; var28 = var26; var29 = var25; var30 = var22; var31 = !address(var30).code.length; if (var31) { revert(memory[0x00:0x00]); } var temp88; temp88, memory[var26:var26 + var25] = address(var30).call.gas(msg.gas).value(var29)(memory[var28:var28 + var27]); var25 = !temp88; if (!var25) { goto label_1713; } var temp89 = returndata.length; memory[0x00:0x00 + temp89] = returndata[0x00:0x00 + temp89]; revert(memory[0x00:0x00 + returndata.length]); } else { var temp90 = returndata.length; memory[0x00:0x00 + temp90] = returndata[0x00:0x00 + temp90]; revert(memory[0x00:0x00 + returndata.length]); } } } else if (var19 == var17) { goto label_1713; } else { goto label_1632; } } else { var21 = var15; var22 = var19; if (var22 >= memory[var21:var21 + 0x20]) { assert(); } var21 = !memory[var22 * 0x20 + 0x20 + var21:var22 * 0x20 + 0x20 + var21 + 0x20]; goto label_1620; } } else { var temp91 = memory[0x40:0x60]; memory[temp91:temp91 + 0x20] = 0x70a08231 << 0xe0; memory[temp91 + 0x04:temp91 + 0x04 + 0x20] = address(this); var21 = 0x00; var22 = storage[0x04] & (0x01 << 0xa0) - 0x01; var23 = 0x70a08231; var24 = temp91 + 0x24; var25 = 0x20; var26 = memory[0x40:0x60]; var27 = temp91 - var26 + 0x24; var28 = var26; var29 = var22; var30 = !address(var29).code.length; if (var30) { revert(memory[0x00:0x00]); } var temp92; temp92, memory[var26:var26 + var25] = address(var29).staticcall.gas(msg.gas)(memory[var28:var28 + var27]); var25 = !temp92; if (!var25) { var22 = memory[0x40:0x60]; var23 = returndata.length; if (var23 < 0x20) { revert(memory[0x00:0x00]); } var temp93 = memory[var22:var22 + 0x20]; var temp94 = memory[0x40:0x60]; memory[temp94:temp94 + 0x20] = 0x5f9bb63d << 0xe1; memory[temp94 + 0x04:temp94 + 0x04 + 0x20] = address(this); memory[temp94 + 0x24:temp94 + 0x24 + 0x20] = temp93; var21 = temp93; var22 = storage[0x03] & (0x01 << 0xa0) - 0x01; var23 = 0xbf376c7a; var24 = temp94 + 0x44; var25 = 0x00; var26 = memory[0x40:0x60]; var27 = temp94 - var26 + 0x44; var28 = var26; var29 = var25; var30 = var22; var31 = !address(var30).code.length; if (var31) { revert(memory[0x00:0x00]); } var temp95; temp95, memory[var26:var26 + var25] = address(var30).call.gas(msg.gas).value(var29)(memory[var28:var28 + var27]); var25 = !temp95; if (!var25) { goto label_1596; } var temp96 = returndata.length; memory[0x00:0x00 + temp96] = returndata[0x00:0x00 + temp96]; revert(memory[0x00:0x00 + returndata.length]); } else { var temp97 = returndata.length; memory[0x00:0x00 + temp97] = returndata[0x00:0x00 + temp97]; revert(memory[0x00:0x00 + returndata.length]); } } } else { var21 = var15; var22 = var19; if (var22 >= memory[var21:var21 + 0x20]) { assert(); } var21 = memory[var22 * 0x20 + 0x20 + var21:var22 * 0x20 + 0x20 + var21 + 0x20]; goto label_14A6; } } } else { var temp98 = returndata.length; memory[0x00:0x00 + temp98] = returndata[0x00:0x00 + temp98]; revert(memory[0x00:0x00 + returndata.length]); } } else { var20 = var14; var21 = 0x00; if (var21 >= memory[var20:var20 + 0x20]) { assert(); } var temp99 = memory[var21 * 0x20 + 0x20 + var20:var21 * 0x20 + 0x20 + var20 + 0x20] & (0x01 << 0xa0) - 0x01; var20 = temp99; var21 = 0xd21220a7; var temp100 = memory[0x40:0x60]; memory[temp100:temp100 + 0x20] = (var21 & 0xffffffff) << 0xe0; var22 = temp100 + 0x04; var23 = 0x20; var24 = memory[0x40:0x60]; var25 = var22 - var24; var26 = var24; var27 = var20; var28 = !address(var27).code.length; if (var28) { revert(memory[0x00:0x00]); } var temp101; temp101, memory[var24:var24 + var23] = address(var27).staticcall.gas(msg.gas)(memory[var26:var26 + var25]); var23 = !temp101; if (!var23) { var20 = memory[0x40:0x60]; var21 = returndata.length; if (var21 < 0x20) { revert(memory[0x00:0x00]); } var20 = memory[var20:var20 + 0x20]; var temp102 = var20; var19 = temp102; var20 = 0x1447; var21 = var19; var22 = var14; var23 = 0x01; if (var23 >= memory[var22:var22 + 0x20]) { assert(); } func_13C1(var19, var21, var22, var23); goto label_1447; } else { var temp103 = returndata.length; memory[0x00:0x00 + temp103] = returndata[0x00:0x00 + temp103]; revert(memory[0x00:0x00 + returndata.length]); } } } else { var temp104 = memory[0x40:0x60]; memory[temp104:temp104 + 0x20] = 0x6f074d1f << 0xe1; memory[temp104 + 0x04:temp104 + 0x04 + 0x20] = var18; var19 = storage[0x03] & (0x01 << 0xa0) - 0x01; var20 = 0xde0e9a3e; var21 = temp104 + 0x24; var22 = 0x00; var23 = memory[0x40:0x60]; var24 = temp104 - var23 + 0x24; var25 = var23; var26 = var22; var27 = var19; var28 = !address(var27).code.length; if (var28) { revert(memory[0x00:0x00]); } var temp105; temp105, memory[var23:var23 + var22] = address(var27).call.gas(msg.gas).value(var26)(memory[var25:var25 + var24]); var22 = !temp105; if (!var22) { var19 = storage[0x04] & (0x01 << 0xa0) - 0x01; var20 = 0xa9059cbb; var21 = var14; var22 = 0x01; if (var22 >= memory[var21:var21 + 0x20]) { assert(); } var temp106 = memory[var22 * 0x20 + 0x20 + var21:var22 * 0x20 + 0x20 + var21 + 0x20]; var temp107 = memory[0x40:0x60]; memory[temp107:temp107 + 0x20] = (var20 & 0xffffffff) << 0xe0; var temp108 = temp107 + 0x04; memory[temp108:temp108 + 0x20] = temp106 & (0x01 << 0xa0) - 0x01; var temp109 = temp108 + 0x20; memory[temp109:temp109 + 0x20] = var18; var21 = temp109 + 0x20; var22 = 0x20; var23 = memory[0x40:0x60]; var24 = var21 - var23; var25 = var23; var26 = 0x00; var27 = var19; var28 = !address(var27).code.length; if (var28) { revert(memory[0x00:0x00]); } var temp110; temp110, memory[var23:var23 + var22] = address(var27).call.gas(msg.gas).value(var26)(memory[var25:var25 + var24]); var22 = !temp110; if (!var22) { var19 = memory[0x40:0x60]; var20 = returndata.length; if (var20 >= 0x20) { goto label_1449; } else { revert(memory[0x00:0x00]); } } else { var temp111 = returndata.length; memory[0x00:0x00 + temp111] = returndata[0x00:0x00 + temp111]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp112 = returndata.length; memory[0x00:0x00 + temp112] = returndata[0x00:0x00 + temp112]; revert(memory[0x00:0x00 + returndata.length]); } } } else { var temp113 = returndata.length; memory[0x00:0x00 + temp113] = returndata[0x00:0x00 + temp113]; revert(memory[0x00:0x00 + returndata.length]); } } } else if (var0 == 0x4dede3de) { // Dispatch table entry for WBTC() var1 = 0x018e; var2 = WBTC(); label_018E: var temp114 = memory[0x40:0x60]; memory[temp114:temp114 + 0x20] = var2 & (0x01 << 0xa0) - 0x01; var temp115 = memory[0x40:0x60]; return memory[temp115:temp115 + temp114 - temp115 + 0x20]; } else if (var0 == 0x57376198) { // Dispatch table entry for rescueTokens(address,uint256) var1 = 0x0184; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } rescueTokens(var2, var3); stop(); } else { revert(memory[0x00:0x00]); } } else if (var0 == 0x5bd717a4) { // Dispatch table entry for 0x5bd717a4 (unknown) var1 = 0x0184; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0xa0) { revert(memory[0x00:0x00]); } var temp116 = var2; var2 = msg.data[temp116:temp116 + 0x20]; var4 = temp116; var3 = var4 + var3; var5 = var4 + 0x40; var6 = msg.data[var4 + 0x20:var4 + 0x20 + 0x20]; if (var6 > 0x01 << 0x20) { revert(memory[0x00:0x00]); } var temp117 = var4 + var6; var6 = temp117; if (var6 + 0x20 > var3) { revert(memory[0x00:0x00]); } var temp118 = var6; var temp119 = msg.data[temp118:temp118 + 0x20]; var6 = temp119; var temp120 = var5; var5 = temp118 + 0x20; var7 = temp120; if ((var6 > 0x01 << 0x20) | (var5 + var6 * 0x20 > var3)) { revert(memory[0x00:0x00]); } var temp121 = var7; var temp122 = var6; var temp123 = memory[0x40:0x60]; memory[0x40:0x60] = temp123 + temp122 * 0x20 + 0x20; memory[temp123:temp123 + 0x20] = temp122; var temp124 = temp123 + 0x20; var temp125 = temp122 * 0x20; memory[temp124:temp124 + temp125] = msg.data[var5:var5 + temp125]; memory[temp124 + temp125:temp124 + temp125 + 0x20] = 0x00; var temp126 = var3; var3 = temp123; var temp127 = var4; var4 = temp126; var5 = temp127; var6 = temp121 + 0x20; var7 = msg.data[temp121:temp121 + 0x20]; if (var7 > 0x01 << 0x20) { revert(memory[0x00:0x00]); } var temp128 = var5 + var7; var7 = temp128; if (var7 + 0x20 > var4) { revert(memory[0x00:0x00]); } var temp129 = var7; var temp130 = msg.data[temp129:temp129 + 0x20]; var7 = temp130; var temp131 = var6; var6 = temp129 + 0x20; var8 = temp131; if ((var7 > 0x01 << 0x20) | (var6 + var7 * 0x20 > var4)) { revert(memory[0x00:0x00]); } var temp132 = var8; var temp133 = var7; var temp134 = memory[0x40:0x60]; memory[0x40:0x60] = temp134 + temp133 * 0x20 + 0x20; memory[temp134:temp134 + 0x20] = temp133; var temp135 = temp134 + 0x20; var temp136 = temp133 * 0x20; memory[temp135:temp135 + temp136] = msg.data[var6:var6 + temp136]; memory[temp135 + temp136:temp135 + temp136 + 0x20] = 0x00; var temp137 = var4; var4 = temp134; var temp138 = var5; var5 = temp137; var6 = temp138; var7 = temp132 + 0x20; var8 = msg.data[temp132:temp132 + 0x20]; if (var8 > 0x01 << 0x20) { revert(memory[0x00:0x00]); } var temp139 = var6 + var8; var8 = temp139; if (var8 + 0x20 > var5) { revert(memory[0x00:0x00]); } var temp140 = var8; var temp141 = msg.data[temp140:temp140 + 0x20]; var8 = temp141; var temp142 = var7; var7 = temp140 + 0x20; var9 = temp142; if ((var8 > 0x01 << 0x20) | (var7 + var8 * 0x20 > var5)) { revert(memory[0x00:0x00]); } var temp143 = var8; var temp144 = memory[0x40:0x60]; memory[0x40:0x60] = temp144 + temp143 * 0x20 + 0x20; memory[temp144:temp144 + 0x20] = temp143; var temp145 = temp144 + 0x20; var temp146 = temp143 * 0x20; memory[temp145:temp145 + temp146] = msg.data[var7:var7 + temp146]; memory[temp145 + temp146:temp145 + temp146 + 0x20] = 0x00; var5 = temp144; var6 = !!msg.data[var9:var9 + 0x20]; var temp147 = memory[0x40:0x60]; var8 = temp147; memory[var8:var8 + 0x20] = 0x02; var7 = 0x60; memory[0x40:0x60] = var7 + var8; var temp148 = var8 + 0x20; memory[temp148:temp148 + 0x20] = 0x60; var9 = 0x02 - 0x01; var10 = temp148 + 0x20; if (!var9) { goto label_0C23; } label_0C10: var temp149 = var10; memory[temp149:temp149 + 0x20] = 0x60; var10 = temp149 + 0x20; var9 = var9 - 0x01; if (var9) { goto label_0C10; } label_0C23: var7 = var8; var8 = 0x0c30; var9 = var3; var8, var9 = func_1D6E(var9); var10 = var7; var11 = 0x00; if (var11 >= memory[var10:var10 + 0x20]) { assert(); } var10 = var11 * 0x20 + 0x20 + var10; var11 = var7; var12 = 0x01; if (var12 >= memory[var11:var11 + 0x20]) { assert(); } memory[var12 * 0x20 + 0x20 + var11:var12 * 0x20 + 0x20 + var11 + 0x20] = var9; memory[var10:var10 + 0x20] = var8; var8 = 0x60; var9 = 0x0c6e; var10 = var2; var11 = var4; var12 = var5; var13 = var7; var9 = func_1EDB(var10, var11, var12, var13); var8 = var9; var9 = 0x00; var10 = var5; var11 = 0x00; if (var11 >= memory[var10:var10 + 0x20]) { assert(); } if (memory[var11 * 0x20 + 0x20 + var10:var11 * 0x20 + 0x20 + var10 + 0x20]) { var10 = 0x0d25; var11 = var2; var12 = var7; var13 = 0x01; if (var13 >= memory[var12:var12 + 0x20]) { assert(); } var10 = func_0CFC(var7, var11, var12, var13); label_0D25: var temp150 = var10; var9 = temp150; var10 = 0x0d78; var11 = var2; var12 = 0x0d6f; var13 = var9; var temp151 = memory[0x40:0x60]; var14 = temp151; memory[0x40:0x60] = var14 + 0x60; memory[var14:var14 + 0x20] = 0x3b; memory[var14 + 0x20:var14 + 0x20 + 0x3b] = code[0x313f:0x317a]; var temp152 = var8; var15 = temp152; var16 = memory[var15:var15 + 0x20] - 0x02; if (var16 >= memory[var15:var15 + 0x20]) { assert(); } var12 = func_0D58(var13, var14, var15, var16); func_0D6F(var3, var5, var6, var8, var11, var12); // Error: Could not resolve jump destination! } else { var10 = 0x0ce6; var11 = var2; var12 = var7; var13 = 0x00; if (var13 >= memory[var12:var12 + 0x20]) { assert(); } var10 = func_0C9C(var7, var11, var12, var13); goto label_0D25; } } else if (var0 == 0x715018a6) { // Dispatch table entry for renounceOwnership() var1 = 0x0184; renounceOwnership(); stop(); } else if (var0 == 0x8da5cb5b) { // Dispatch table entry for owner() var1 = 0x018e; var1 = owner(); goto label_018E; } else if (var0 == 0x8ed36a4f) { // Dispatch table entry for 0x8ed36a4f (unknown) var1 = 0x0184; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x80) { revert(memory[0x00:0x00]); } func_03AA(var2, var3); stop(); } else { revert(memory[0x00:0x00]); } } else if (0xf2fde38b > var0) { if (var0 == 0x9e252f00) { // Dispatch table entry for rescueETH(uint256) var1 = 0x0184; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } rescueETH(var2, var3); stop(); } else if (var0 == 0xc0c06fef) { // Dispatch table entry for 0xc0c06fef (unknown) var1 = 0x06fd; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x60) { revert(memory[0x00:0x00]); } var1 = func_056E(var2, var3); label_06FD: var temp153 = memory[0x40:0x60]; memory[temp153:temp153 + 0x20] = var1; var temp154 = memory[0x40:0x60]; return memory[temp154:temp154 + temp153 - temp154 + 0x20]; } else if (var0 == 0xc90cc44d) { // Dispatch table entry for 0xc90cc44d (unknown) var1 = 0x06fd; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x60) { revert(memory[0x00:0x00]); } var1 = func_0725(var2, var3); goto label_06FD; } else if (var0 == 0xeb2c7de3) { // Dispatch table entry for 0xeb2c7de3 (unknown) var1 = 0x018e; var2 = func_0EF0(); goto label_018E; } else { revert(memory[0x00:0x00]); } } else if (var0 == 0xf2fde38b) { // Dispatch table entry for transferOwnership(address) var1 = 0x0184; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } transferOwnership(var2, var3); stop(); } else if (var0 == 0xf3d3d448) { // Dispatch table entry for setControllerAddress(address) var1 = 0x0184; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } setControllerAddress(var2, var3); stop(); } else if (var0 == 0xf77c4791) { // Dispatch table entry for controller() var1 = 0x018e; var2 = controller(); goto label_018E; } else if (var0 == 0xfd9af456) { // Dispatch table entry for 0xfd9af456 (unknown) var1 = 0x0184; func_1080(); stop(); } else { revert(memory[0x00:0x00]); } } function rescueTokens(var arg0, var arg1) { var temp0 = arg0; arg0 = msg.data[temp0:temp0 + 0x20] & (0x01 << 0xa0) - 0x01; arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20]; var var0 = 0x0b1c; var0 = func_1D6A(); var temp1 = (0x01 << 0xa0) - 0x01; if (var0 & temp1 == temp1 & storage[0x00]) { var0 = arg0 & (0x01 << 0xa0) - 0x01; var var1 = 0xa9059cbb; var var2 = 0x0b83; var2 = owner(); var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = (var1 & 0xffffffff) << 0xe0; var temp3 = temp2 + 0x04; memory[temp3:temp3 + 0x20] = var2 & (0x01 << 0xa0) - 0x01; var temp4 = temp3 + 0x20; memory[temp4:temp4 + 0x20] = arg1; var2 = temp4 + 0x20; var var3 = 0x20; var var4 = memory[0x40:0x60]; var var5 = var2 - var4; var var6 = var4; var var7 = 0x00; var var8 = var0; var var9 = !address(var8).code.length; if (var9) { revert(memory[0x00:0x00]); } var temp5; temp5, memory[var4:var4 + var3] = address(var8).call.gas(msg.gas).value(var7)(memory[var6:var6 + var5]); var3 = !temp5; if (!var3) { var0 = memory[0x40:0x60]; var1 = returndata.length; if (var1 >= 0x20) { return; } else { revert(memory[0x00:0x00]); } } else { var temp6 = returndata.length; memory[0x00:0x00 + temp6] = returndata[0x00:0x00 + temp6]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp7 = memory[0x40:0x60]; memory[temp7:temp7 + 0x20] = 0x461bcd << 0xe5; memory[temp7 + 0x04:temp7 + 0x04 + 0x20] = 0x20; memory[temp7 + 0x24:temp7 + 0x24 + 0x20] = 0x20; var temp8 = memory[0x00:0x20]; memory[0x00:0x20] = code[0x311f:0x313f]; var temp9 = memory[0x00:0x20]; memory[0x00:0x20] = temp8; memory[temp7 + 0x44:temp7 + 0x44 + 0x20] = temp9; var temp10 = memory[0x40:0x60]; revert(memory[temp10:temp10 + temp7 - temp10 + 0x64]); } } function func_03AA(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 > 0x01 << 0x20) { 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 > 0x01 << 0x20) | (var0 + var1 * 0x20 > arg0)) { revert(memory[0x00:0x00]); } var temp6 = var2; var temp7 = var1; var temp8 = memory[0x40:0x60]; memory[0x40:0x60] = temp8 + temp7 * 0x20 + 0x20; memory[temp8:temp8 + 0x20] = temp7; var temp9 = temp8 + 0x20; var temp10 = temp7 * 0x20; memory[temp9:temp9 + temp10] = msg.data[var0:var0 + temp10]; memory[temp9 + temp10:temp9 + temp10 + 0x20] = 0x00; var temp11 = arg0; arg0 = temp8; var temp12 = arg1; arg1 = temp11; var0 = temp12; var1 = temp6 + 0x20; var2 = msg.data[temp6:temp6 + 0x20]; if (var2 > 0x01 << 0x20) { revert(memory[0x00:0x00]); } var temp13 = var0 + var2; var2 = temp13; if (var2 + 0x20 > arg1) { revert(memory[0x00:0x00]); } var temp14 = var2; var temp15 = msg.data[temp14:temp14 + 0x20]; var2 = temp15; var var3 = var1; var1 = temp14 + 0x20; if ((var2 > 0x01 << 0x20) | (var1 + var2 * 0x20 > arg1)) { revert(memory[0x00:0x00]); } var temp16 = var3; var temp17 = var2; var temp18 = memory[0x40:0x60]; memory[0x40:0x60] = temp18 + temp17 * 0x20 + 0x20; memory[temp18:temp18 + 0x20] = temp17; var temp19 = temp18 + 0x20; var temp20 = temp17 * 0x20; memory[temp19:temp19 + temp20] = msg.data[var1:var1 + temp20]; memory[temp19 + temp20:temp19 + temp20 + 0x20] = 0x00; var temp21 = arg1; arg1 = temp18; var temp22 = var0; var0 = temp21; var1 = temp22; var2 = temp16 + 0x20; var3 = msg.data[temp16:temp16 + 0x20]; if (var3 > 0x01 << 0x20) { revert(memory[0x00:0x00]); } var temp23 = var1 + var3; var3 = temp23; if (var3 + 0x20 > var0) { revert(memory[0x00:0x00]); } var temp24 = var3; var temp25 = msg.data[temp24:temp24 + 0x20]; var3 = temp25; var temp26 = var2; var2 = temp24 + 0x20; var var4 = temp26; if ((var3 > 0x01 << 0x20) | (var2 + var3 * 0x20 > var0)) { revert(memory[0x00:0x00]); } var temp27 = var3; var temp28 = memory[0x40:0x60]; memory[0x40:0x60] = temp28 + temp27 * 0x20 + 0x20; memory[temp28:temp28 + 0x20] = temp27; var temp29 = temp28 + 0x20; var temp30 = temp27 * 0x20; memory[temp29:temp29 + temp30] = msg.data[var2:var2 + temp30]; memory[temp29 + temp30:temp29 + temp30 + 0x20] = 0x00; var0 = temp28; var1 = !!msg.data[var4:var4 + 0x20]; var2 = 0x00; var3 = 0x60; var4 = 0x00; var var5 = 0x0e44; var var6 = arg0; var var7 = arg1; var var8 = var0; var5, var6, var7 = func_2620(var6, var7, var8); var4 = var7; var3 = var6; var2 = var5; if (var4 > 0x00) { var5 = 0x0e97; var6 = var2; var7 = var4; var8 = var1; var var9 = arg0; var var10 = var0; var var11 = var3; func_221B(var6, var7, var8, var9, var10, var11); return; } else { var temp31 = memory[0x40:0x60]; memory[temp31:temp31 + 0x20] = 0x461bcd << 0xe5; var temp32 = temp31 + 0x04; var temp33 = temp32 + 0x20; memory[temp32:temp32 + 0x20] = temp33 - temp32; memory[temp33:temp33 + 0x20] = 0x24; var temp34 = temp33 + 0x20; memory[temp34:temp34 + 0x24] = code[0x317a:0x319e]; var temp35 = memory[0x40:0x60]; revert(memory[temp35:temp35 + (temp34 + 0x40) - temp35]); } } function rescueETH(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20]; arg1 = 0x0ebe; var var0 = 0xd5b47b80668840e7164c1d1d81af8a9d9727b421; var var1 = arg0; func_2A8E(var0, var1); } function func_056E(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 > 0x01 << 0x20) { 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 > 0x01 << 0x20) | (var0 + var1 * 0x20 > arg0)) { revert(memory[0x00:0x00]); } var temp6 = var2; var temp7 = var1; var temp8 = memory[0x40:0x60]; memory[0x40:0x60] = temp8 + temp7 * 0x20 + 0x20; memory[temp8:temp8 + 0x20] = temp7; var temp9 = temp8 + 0x20; var temp10 = temp7 * 0x20; memory[temp9:temp9 + temp10] = msg.data[var0:var0 + temp10]; memory[temp9 + temp10:temp9 + temp10 + 0x20] = 0x00; var temp11 = arg0; arg0 = temp8; var temp12 = arg1; arg1 = temp11; var0 = temp12; var1 = temp6 + 0x20; var2 = msg.data[temp6:temp6 + 0x20]; if (var2 > 0x01 << 0x20) { revert(memory[0x00:0x00]); } var temp13 = var0 + var2; var2 = temp13; if (var2 + 0x20 > arg1) { revert(memory[0x00:0x00]); } var temp14 = var2; var temp15 = msg.data[temp14:temp14 + 0x20]; var2 = temp15; var var3 = var1; var1 = temp14 + 0x20; if ((var2 > 0x01 << 0x20) | (var1 + var2 * 0x20 > arg1)) { revert(memory[0x00:0x00]); } var temp16 = var3; var temp17 = var2; var temp18 = memory[0x40:0x60]; memory[0x40:0x60] = temp18 + temp17 * 0x20 + 0x20; memory[temp18:temp18 + 0x20] = temp17; var temp19 = temp18 + 0x20; var temp20 = temp17 * 0x20; memory[temp19:temp19 + temp20] = msg.data[var1:var1 + temp20]; memory[temp19 + temp20:temp19 + temp20 + 0x20] = 0x00; var temp21 = arg1; arg1 = temp18; var temp22 = var0; var0 = temp21; var1 = temp22; var2 = temp16 + 0x20; var3 = msg.data[temp16:temp16 + 0x20]; if (var3 > 0x01 << 0x20) { revert(memory[0x00:0x00]); } var temp23 = var1 + var3; var3 = temp23; if (var3 + 0x20 > var0) { revert(memory[0x00:0x00]); } var temp24 = var3; var temp25 = msg.data[temp24:temp24 + 0x20]; var3 = temp25; var temp26 = var2; var2 = temp24 + 0x20; var var4 = temp26; if ((var3 > 0x01 << 0x20) | (var2 + var3 * 0x20 > var0)) { revert(memory[0x00:0x00]); } var temp27 = var3; var temp28 = memory[0x40:0x60]; memory[0x40:0x60] = temp28 + temp27 * 0x20 + 0x20; memory[temp28:temp28 + 0x20] = temp27; var temp29 = temp28 + 0x20; var temp30 = temp27 * 0x20; memory[temp29:temp29 + temp30] = msg.data[var2:var2 + temp30]; memory[temp29 + temp30:temp29 + temp30 + 0x20] = 0x00; var0 = temp28; var1 = 0x00; var2 = 0x0ece; var3 = arg0; var4 = arg1; var var5 = var0; var2, var3, var4 = func_2620(var3, var4, var5); return var2; } function func_0725(var arg0, var arg1) returns (var r0) { var temp0 = arg0; arg0 = temp0 + arg1; arg1 = temp0; var var0 = arg1 + 0x20; var var1 = msg.data[arg1:arg1 + 0x20]; if (var1 > 0x01 << 0x20) { revert(memory[0x00:0x00]); } var temp1 = arg1 + var1; var1 = temp1; if (var1 + 0x20 > arg0) { revert(memory[0x00:0x00]); } var temp2 = var1; var temp3 = msg.data[temp2:temp2 + 0x20]; var1 = temp3; var var2 = var0; var0 = temp2 + 0x20; if ((var1 > 0x01 << 0x20) | (var0 + var1 * 0x20 > arg0)) { revert(memory[0x00:0x00]); } var temp4 = var2; var temp5 = var1; var temp6 = memory[0x40:0x60]; memory[0x40:0x60] = temp6 + temp5 * 0x20 + 0x20; memory[temp6:temp6 + 0x20] = temp5; var temp7 = temp6 + 0x20; var temp8 = temp5 * 0x20; memory[temp7:temp7 + temp8] = msg.data[var0:var0 + temp8]; memory[temp7 + temp8:temp7 + temp8 + 0x20] = 0x00; var temp9 = arg0; arg0 = temp6; var temp10 = arg1; arg1 = temp9; var0 = temp10; var1 = temp4 + 0x20; var2 = msg.data[temp4:temp4 + 0x20]; if (var2 > 0x01 << 0x20) { 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 > 0x01 << 0x20) | (var1 + var2 * 0x20 > arg1)) { revert(memory[0x00:0x00]); } var temp14 = var3; var temp15 = var2; var temp16 = memory[0x40:0x60]; memory[0x40:0x60] = temp16 + temp15 * 0x20 + 0x20; memory[temp16:temp16 + 0x20] = temp15; var temp17 = temp16 + 0x20; var temp18 = temp15 * 0x20; memory[temp17:temp17 + temp18] = msg.data[var1:var1 + temp18]; memory[temp17 + temp18:temp17 + temp18 + 0x20] = 0x00; var temp19 = arg1; arg1 = temp16; var temp20 = var0; var0 = temp19; var1 = temp20; var2 = temp14 + 0x20; var3 = msg.data[temp14:temp14 + 0x20]; if (var3 > 0x01 << 0x20) { revert(memory[0x00:0x00]); } var temp21 = var1 + var3; var3 = temp21; if (var3 + 0x20 > var0) { revert(memory[0x00:0x00]); } var temp22 = var3; var temp23 = msg.data[temp22:temp22 + 0x20]; var3 = temp23; var temp24 = var2; var2 = temp22 + 0x20; var var4 = temp24; if ((var3 > 0x01 << 0x20) | (var2 + var3 * 0x20 > var0)) { revert(memory[0x00:0x00]); } var temp25 = var3; var temp26 = memory[0x40:0x60]; memory[0x40:0x60] = temp26 + temp25 * 0x20 + 0x20; memory[temp26:temp26 + 0x20] = temp25; var temp27 = temp26 + 0x20; var temp28 = temp25 * 0x20; memory[temp27:temp27 + temp28] = msg.data[var2:var2 + temp28]; memory[temp27 + temp28:temp27 + temp28 + 0x20] = 0x00; var0 = temp26; var1 = 0x00; var2 = 0x0ee6; var3 = arg0; var4 = arg1; var var5 = var0; var2, var3, var4 = func_2620(var3, var4, var5); return var4; } function transferOwnership(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20] & (0x01 << 0xa0) - 0x01; arg1 = 0x0f07; arg1 = func_1D6A(); var temp0 = (0x01 << 0xa0) - 0x01; if (arg1 & temp0 != temp0 & storage[0x00]) { var temp8 = memory[0x40:0x60]; memory[temp8:temp8 + 0x20] = 0x461bcd << 0xe5; memory[temp8 + 0x04:temp8 + 0x04 + 0x20] = 0x20; memory[temp8 + 0x24:temp8 + 0x24 + 0x20] = 0x20; var temp9 = memory[0x00:0x20]; memory[0x00:0x20] = code[0x311f:0x313f]; var temp10 = memory[0x00:0x20]; memory[0x00:0x20] = temp9; memory[temp8 + 0x44:temp8 + 0x44 + 0x20] = temp10; var temp11 = memory[0x40:0x60]; revert(memory[temp11:temp11 + temp8 - temp11 + 0x64]); } else if (arg0 & (0x01 << 0xa0) - 0x01) { var temp1 = (0x01 << 0xa0) - 0x01; var temp2 = arg0; log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); storage[0x00] = (temp2 & (0x01 << 0xa0) - 0x01) | (storage[0x00] & ~((0x01 << 0xa0) - 0x01)); return; } else { var temp3 = memory[0x40:0x60]; memory[temp3:temp3 + 0x20] = 0x461bcd << 0xe5; var temp4 = temp3 + 0x04; var temp5 = temp4 + 0x20; memory[temp4:temp4 + 0x20] = temp5 - temp4; memory[temp5:temp5 + 0x20] = 0x26; var temp6 = temp5 + 0x20; memory[temp6:temp6 + 0x26] = code[0x3084:0x30aa]; var temp7 = memory[0x40:0x60]; revert(memory[temp7:temp7 + (temp6 + 0x40) - temp7]); } } function setControllerAddress(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20] & (0x01 << 0xa0) - 0x01; arg1 = 0x0fff; arg1 = func_1D6A(); var temp0 = (0x01 << 0xa0) - 0x01; if (arg1 & temp0 == temp0 & storage[0x00]) { storage[0x05] = (arg0 & (0x01 << 0xa0) - 0x01) | (storage[0x05] & ~((0x01 << 0xa0) - 0x01)); return; } else { var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x461bcd << 0xe5; memory[temp1 + 0x04:temp1 + 0x04 + 0x20] = 0x20; memory[temp1 + 0x24:temp1 + 0x24 + 0x20] = 0x20; var temp2 = memory[0x00:0x20]; memory[0x00:0x20] = code[0x311f:0x313f]; var temp3 = memory[0x00:0x20]; memory[0x00:0x20] = temp2; memory[temp1 + 0x44:temp1 + 0x44 + 0x20] = temp3; var temp4 = memory[0x40:0x60]; revert(memory[temp4:temp4 + temp1 - temp4 + 0x64]); } } function WBTC() returns (var r0) { return storage[0x02] & (0x01 << 0xa0) - 0x01; } function func_0C9C(var arg0, var arg1, var arg2, var arg3) returns (var r0) { var temp0 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg2 = temp0; arg3 = 0x00; if (arg3 >= memory[arg2:arg2 + 0x20]) { assert(); } arg2 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg3 = arg0; var var0 = 0x01; if (var0 >= memory[arg3:arg3 + 0x20]) { assert(); } var temp1 = memory[var0 * 0x20 + 0x20 + arg3:var0 * 0x20 + 0x20 + arg3 + 0x20]; arg3 = temp1; var0 = 0x00; if (var0 >= memory[arg3:arg3 + 0x20]) { assert(); } arg3 = memory[var0 * 0x20 + 0x20 + arg3:var0 * 0x20 + 0x20 + arg3 + 0x20]; var0 = 0x00; if (arg1 > var0) { var var1 = arg2 > 0x00; if (!var1) { if (var1) { label_2142: var1 = 0x00; var var2 = 0x215a; var var3 = 0x03e8; var var4 = 0x2154; var var5 = arg2; var var6 = arg1; var4 = func_2D7F(var5, var6); var2 = func_2154(var3, var4); var1 = var2; var2 = 0x00; var3 = 0x216e; var4 = 0x03e5; var5 = 0x2154; var6 = arg3; var var7 = arg1; var5 = func_2D34(var6, var7); var3 = func_2154(var4, var5); var2 = var3; var3 = var2; var4 = var1; if (var3) { return var4 / var3; } else { assert(); } } else { label_210C: var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x461bcd << 0xe5; var temp3 = temp2 + 0x04; var temp4 = temp3 + 0x20; memory[temp3:temp3 + 0x20] = temp4 - temp3; memory[temp4:temp4 + 0x20] = 0x28; var temp5 = temp4 + 0x20; memory[temp5:temp5 + 0x28] = code[0x30d6:0x30fe]; var temp6 = memory[0x40:0x60]; revert(memory[temp6:temp6 + (temp5 + 0x40) - temp6]); } } else if (arg3 > 0x00) { goto label_2142; } else { goto label_210C; } } else { var temp7 = memory[0x40:0x60]; memory[temp7:temp7 + 0x20] = 0x461bcd << 0xe5; var temp8 = temp7 + 0x04; var temp9 = temp8 + 0x20; memory[temp8:temp8 + 0x20] = temp9 - temp8; memory[temp9:temp9 + 0x20] = 0x2c; var temp10 = temp9 + 0x20; memory[temp10:temp10 + 0x2c] = code[0x30aa:0x30d6]; var temp11 = memory[0x40:0x60]; revert(memory[temp11:temp11 + (temp10 + 0x40) - temp11]); } } function func_0CFC(var arg0, var arg1, var arg2, var arg3) returns (var r0) { var temp0 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg2 = temp0; arg3 = 0x00; if (arg3 >= memory[arg2:arg2 + 0x20]) { assert(); } arg2 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg3 = arg0; var var0 = 0x00; if (var0 >= memory[arg3:arg3 + 0x20]) { assert(); } var temp1 = memory[var0 * 0x20 + 0x20 + arg3:var0 * 0x20 + 0x20 + arg3 + 0x20]; arg3 = temp1; var0 = 0x00; if (var0 >= memory[arg3:arg3 + 0x20]) { assert(); } arg3 = memory[var0 * 0x20 + 0x20 + arg3:var0 * 0x20 + 0x20 + arg3 + 0x20]; var0 = 0x00; if (arg1 > var0) { var var1 = arg2 > 0x00; if (!var1) { if (var1) { label_2142: var1 = 0x00; var var2 = 0x215a; var var3 = 0x03e8; var var4 = 0x2154; var var5 = arg2; var var6 = arg1; var4 = func_2D7F(var5, var6); var2 = func_2154(var3, var4); var1 = var2; var2 = 0x00; var3 = 0x216e; var4 = 0x03e5; var5 = 0x2154; var6 = arg3; var var7 = arg1; var5 = func_2D34(var6, var7); var3 = func_2154(var4, var5); var2 = var3; var3 = var2; var4 = var1; if (var3) { return var4 / var3; } else { assert(); } } else { label_210C: var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x461bcd << 0xe5; var temp3 = temp2 + 0x04; var temp4 = temp3 + 0x20; memory[temp3:temp3 + 0x20] = temp4 - temp3; memory[temp4:temp4 + 0x20] = 0x28; var temp5 = temp4 + 0x20; memory[temp5:temp5 + 0x28] = code[0x30d6:0x30fe]; var temp6 = memory[0x40:0x60]; revert(memory[temp6:temp6 + (temp5 + 0x40) - temp6]); } } else if (arg3 > 0x00) { goto label_2142; } else { goto label_210C; } } else { var temp7 = memory[0x40:0x60]; memory[temp7:temp7 + 0x20] = 0x461bcd << 0xe5; var temp8 = temp7 + 0x04; var temp9 = temp8 + 0x20; memory[temp8:temp8 + 0x20] = temp9 - temp8; memory[temp9:temp9 + 0x20] = 0x2c; var temp10 = temp9 + 0x20; memory[temp10:temp10 + 0x2c] = code[0x30aa:0x30d6]; var temp11 = memory[0x40:0x60]; revert(memory[temp11:temp11 + (temp10 + 0x40) - temp11]); } } function func_0D58(var arg0, var arg1, var arg2, var arg3) returns (var r0) { var temp0 = arg0; arg0 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; var temp1 = arg1; arg1 = temp0; arg2 = temp1; r0 = func_2184(arg0, arg1, arg2); // Error: Could not resolve method call return address! } function func_0D6F(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5) { var var0 = arg2; var var1 = arg0; var var2 = arg1; var var3 = arg3; func_221B(arg4, arg5, var0, var1, var2, var3); // Error: Could not resolve method call return address! } function renounceOwnership() { var var0 = 0x0d8a; var0 = func_1D6A(); var temp0 = (0x01 << 0xa0) - 0x01; if (var0 & temp0 == temp0 & storage[0x00]) { log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & (0x01 << 0xa0) - 0x01, 0x00]); storage[0x00] = storage[0x00] & ~((0x01 << 0xa0) - 0x01); return; } else { var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x461bcd << 0xe5; memory[temp1 + 0x04:temp1 + 0x04 + 0x20] = 0x20; memory[temp1 + 0x24:temp1 + 0x24 + 0x20] = 0x20; var temp2 = memory[0x00:0x20]; memory[0x00:0x20] = code[0x311f:0x313f]; var temp3 = memory[0x00:0x20]; memory[0x00:0x20] = temp2; memory[temp1 + 0x44:temp1 + 0x44 + 0x20] = temp3; var temp4 = memory[0x40:0x60]; revert(memory[temp4:temp4 + temp1 - temp4 + 0x64]); } } function owner() returns (var r0) { return storage[0x00] & (0x01 << 0xa0) - 0x01; } function func_0EF0() returns (var r0) { return storage[0x01] & (0x01 << 0xa0) - 0x01; } function controller() returns (var r0) { return storage[0x05] & (0x01 << 0xa0) - 0x01; } function func_1080() { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x095ea7b3 << 0xe0; var temp1 = (0x01 << 0xa0) - 0x01; memory[temp0 + 0x04:temp0 + 0x04 + 0x20] = temp1 & storage[0x03]; memory[temp0 + 0x24:temp0 + 0x24 + 0x20] = ~0x00; var var0 = storage[0x04] & temp1; var var1 = 0x095ea7b3; var var2 = temp0 + 0x44; var var3 = 0x20; var var4 = memory[0x40:0x60]; var var5 = temp0 - var4 + 0x44; var var6 = var4; var var7 = 0x00; var var8 = var0; var var9 = !address(var8).code.length; if (var9) { revert(memory[0x00:0x00]); } var temp2; temp2, memory[var4:var4 + var3] = address(var8).call.gas(msg.gas).value(var7)(memory[var6:var6 + var5]); var3 = !temp2; if (!var3) { var0 = memory[0x40:0x60]; var1 = returndata.length; if (var1 >= 0x20) { return; } else { revert(memory[0x00:0x00]); } } else { var temp3 = returndata.length; memory[0x00:0x00 + temp3] = returndata[0x00:0x00 + temp3]; revert(memory[0x00:0x00 + returndata.length]); } } function func_13C1(var arg0, var arg1, var arg2, var arg3) { arg2 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg3 = arg0 & (0x01 << 0xa0) - 0x01; var var0 = 0x70a08231; var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = (var0 & 0xffffffff) << 0xe0; var temp1 = temp0 + 0x04; memory[temp1:temp1 + 0x20] = address(this); var var1 = temp1 + 0x20; var var2 = 0x20; var var3 = memory[0x40:0x60]; var var4 = var1 - var3; var var5 = var3; var var6 = arg3; var var7 = !address(var6).code.length; if (var7) { revert(memory[0x00:0x00]); } var temp2; temp2, memory[var3:var3 + var2] = address(var6).staticcall.gas(msg.gas)(memory[var5:var5 + var4]); var2 = !temp2; if (!var2) { arg3 = memory[0x40:0x60]; var0 = returndata.length; if (var0 < 0x20) { revert(memory[0x00:0x00]); } arg3 = memory[arg3:arg3 + 0x20]; func_2AC9(arg1, arg2, arg3); // Error: Could not resolve method call return address! } else { var temp3 = returndata.length; memory[0x00:0x00 + temp3] = returndata[0x00:0x00 + temp3]; revert(memory[0x00:0x00 + returndata.length]); } } function func_15A5(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5, var arg6) { arg5 = memory[arg6 * 0x20 + 0x20 + arg5:arg6 * 0x20 + 0x20 + arg5 + 0x20]; arg6 = arg2; var var0 = arg4 - 0x01; if (var0 >= memory[arg6:arg6 + 0x20]) { assert(); } arg6 = memory[var0 * 0x20 + 0x20 + arg6:var0 * 0x20 + 0x20 + arg6 + 0x20]; var0 = arg1; var var1 = arg4; if (var1 >= memory[var0:var0 + 0x20]) { assert(); } var0 = memory[var1 * 0x20 + 0x20 + var0:var1 * 0x20 + 0x20 + var0 + 0x20]; if (arg4 == arg3) { var1 = address(this); label_2C33: if (!var0) { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x022c0d9f << 0xe0; memory[temp0 + 0x04:temp0 + 0x04 + 0x20] = 0x00; memory[temp0 + 0x24:temp0 + 0x24 + 0x20] = arg6; var temp1 = (0x01 << 0xa0) - 0x01; memory[temp0 + 0x44:temp0 + 0x44 + 0x20] = temp1 & var1; memory[temp0 + 0x64:temp0 + 0x64 + 0x20] = 0x80; memory[temp0 + 0x84:temp0 + 0x84 + 0x20] = 0x00; var var2 = arg5 & temp1; var var3 = 0x022c0d9f; var var4 = temp0 + 0xc4; var var5 = 0x00; var var6 = memory[0x40:0x60]; var var7 = temp0 - var6 + 0xc4; var var8 = var6; var var9 = var5; var var10 = var2; var var11 = !address(var10).code.length; if (var11) { revert(memory[0x00:0x00]); } var temp2; temp2, memory[var6:var6 + var5] = address(var10).call.gas(msg.gas).value(var9)(memory[var8:var8 + var7]); var5 = !temp2; if (!var5) { return; } var temp3 = returndata.length; memory[0x00:0x00 + temp3] = returndata[0x00:0x00 + temp3]; revert(memory[0x00:0x00 + returndata.length]); } else { var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = 0x022c0d9f << 0xe0; memory[temp4 + 0x04:temp4 + 0x04 + 0x20] = arg6; memory[temp4 + 0x24:temp4 + 0x24 + 0x20] = 0x00; var temp5 = (0x01 << 0xa0) - 0x01; memory[temp4 + 0x44:temp4 + 0x44 + 0x20] = temp5 & var1; memory[temp4 + 0x64:temp4 + 0x64 + 0x20] = 0x80; memory[temp4 + 0x84:temp4 + 0x84 + 0x20] = 0x00; var2 = arg5 & temp5; var3 = 0x022c0d9f; var4 = temp4 + 0xc4; var5 = 0x00; var6 = memory[0x40:0x60]; var7 = temp4 - var6 + 0xc4; var8 = var6; var9 = var5; var10 = var2; var11 = !address(var10).code.length; if (var11) { revert(memory[0x00:0x00]); } var temp6; temp6, memory[var6:var6 + var5] = address(var10).call.gas(msg.gas).value(var9)(memory[var8:var8 + var7]); var5 = !temp6; if (!var5) { return; } var temp7 = returndata.length; memory[0x00:0x00 + temp7] = returndata[0x00:0x00 + temp7]; revert(memory[0x00:0x00 + returndata.length]); } } else { var1 = arg0; var2 = arg4 + 0x01; if (var2 >= memory[var1:var1 + 0x20]) { assert(); } var1 = memory[var2 * 0x20 + 0x20 + var1:var2 * 0x20 + 0x20 + var1 + 0x20]; goto label_2C33; } } function func_18F0(var arg0, var arg1, var arg2, var arg3, var arg4) { arg3 = memory[arg4 * 0x20 + 0x20 + arg3:arg4 * 0x20 + 0x20 + arg3 + 0x20]; arg4 = 0x197b; var var0 = arg0; var var1 = arg1 & (0x01 << 0xa0) - 0x01; var var2 = 0x70a08231; var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = (var2 & 0xffffffff) << 0xe0; var temp1 = temp0 + 0x04; memory[temp1:temp1 + 0x20] = address(this); var var3 = temp1 + 0x20; var var4 = 0x20; var var5 = memory[0x40:0x60]; var var6 = var3 - var5; var var7 = var5; var var8 = var1; var var9 = !address(var8).code.length; if (var9) { revert(memory[0x00:0x00]); } arg4 = func_1949(var0, var1, var2, var3, var4, var5, var6, var7, var8, var9); func_2AC9(arg2, arg3, arg4); // Error: Could not resolve method call return address! } function func_1949(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5, var arg6, var arg7, var arg8, var arg9) returns (var r0) { var temp0; temp0, memory[arg5:arg5 + arg4] = address(arg8).staticcall.gas(msg.gas)(memory[arg7:arg7 + arg6]); arg4 = !temp0; if (!arg4) { arg1 = memory[0x40:0x60]; arg2 = returndata.length; if (arg2 < 0x20) { revert(memory[0x00:0x00]); } var temp1 = arg0; arg0 = memory[arg1:arg1 + 0x20]; arg1 = temp1; r0 = func_2D34(arg0, arg1); // Error: Could not resolve method call return address! } else { var temp2 = returndata.length; memory[0x00:0x00 + temp2] = returndata[0x00:0x00 + temp2]; revert(memory[0x00:0x00 + returndata.length]); } } function func_1BEC(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5, var arg6) { arg5 = memory[arg6 * 0x20 + 0x20 + arg5:arg6 * 0x20 + 0x20 + arg5 + 0x20]; arg6 = arg2; var var0 = arg4 - 0x01; if (var0 >= memory[arg6:arg6 + 0x20]) { assert(); } arg6 = memory[var0 * 0x20 + 0x20 + arg6:var0 * 0x20 + 0x20 + arg6 + 0x20]; var0 = arg1; var var1 = arg4; if (var1 >= memory[var0:var0 + 0x20]) { assert(); } var0 = memory[var1 * 0x20 + 0x20 + var0:var1 * 0x20 + 0x20 + var0 + 0x20]; if (arg4 == arg3) { var1 = address(this); label_2C33: if (!var0) { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x022c0d9f << 0xe0; memory[temp0 + 0x04:temp0 + 0x04 + 0x20] = 0x00; memory[temp0 + 0x24:temp0 + 0x24 + 0x20] = arg6; var temp1 = (0x01 << 0xa0) - 0x01; memory[temp0 + 0x44:temp0 + 0x44 + 0x20] = temp1 & var1; memory[temp0 + 0x64:temp0 + 0x64 + 0x20] = 0x80; memory[temp0 + 0x84:temp0 + 0x84 + 0x20] = 0x00; var var2 = arg5 & temp1; var var3 = 0x022c0d9f; var var4 = temp0 + 0xc4; var var5 = 0x00; var var6 = memory[0x40:0x60]; var var7 = temp0 - var6 + 0xc4; var var8 = var6; var var9 = var5; var var10 = var2; var var11 = !address(var10).code.length; if (var11) { revert(memory[0x00:0x00]); } var temp2; temp2, memory[var6:var6 + var5] = address(var10).call.gas(msg.gas).value(var9)(memory[var8:var8 + var7]); var5 = !temp2; if (!var5) { return; } var temp3 = returndata.length; memory[0x00:0x00 + temp3] = returndata[0x00:0x00 + temp3]; revert(memory[0x00:0x00 + returndata.length]); } else { var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = 0x022c0d9f << 0xe0; memory[temp4 + 0x04:temp4 + 0x04 + 0x20] = arg6; memory[temp4 + 0x24:temp4 + 0x24 + 0x20] = 0x00; var temp5 = (0x01 << 0xa0) - 0x01; memory[temp4 + 0x44:temp4 + 0x44 + 0x20] = temp5 & var1; memory[temp4 + 0x64:temp4 + 0x64 + 0x20] = 0x80; memory[temp4 + 0x84:temp4 + 0x84 + 0x20] = 0x00; var2 = arg5 & temp5; var3 = 0x022c0d9f; var4 = temp4 + 0xc4; var5 = 0x00; var6 = memory[0x40:0x60]; var7 = temp4 - var6 + 0xc4; var8 = var6; var9 = var5; var10 = var2; var11 = !address(var10).code.length; if (var11) { revert(memory[0x00:0x00]); } var temp6; temp6, memory[var6:var6 + var5] = address(var10).call.gas(msg.gas).value(var9)(memory[var8:var8 + var7]); var5 = !temp6; if (!var5) { return; } var temp7 = returndata.length; memory[0x00:0x00 + temp7] = returndata[0x00:0x00 + temp7]; revert(memory[0x00:0x00 + returndata.length]); } } else { var1 = arg0; var2 = arg4 + 0x01; if (var2 >= memory[var1:var1 + 0x20]) { assert(); } var1 = memory[var2 * 0x20 + 0x20 + var1:var2 * 0x20 + 0x20 + var1 + 0x20]; goto label_2C33; } } function func_1D6A() returns (var r0) { return msg.sender; } function func_1D6E(var arg0) returns (var r0, var arg0) { var var0 = 0x60; var var1 = var0; var var2 = memory[arg0:arg0 + 0x20]; var var3 = var2 > 0xffffffffffffffff; if (var3) { revert(memory[0x00:0x00]); } var temp0 = memory[0x40:0x60]; var temp1 = var2; var2 = temp0; var3 = temp1; memory[var2:var2 + 0x20] = var3; memory[0x40:0x60] = var2 + var3 * 0x20 + 0x20; if (!var3) { var0 = var2; var2 = memory[arg0:arg0 + 0x20]; var3 = var2 > 0xffffffffffffffff; if (var3) { revert(memory[0x00:0x00]); } label_1DCE: var temp2 = memory[0x40:0x60]; var temp3 = var2; var3 = temp3; var2 = temp2; memory[var2:var2 + 0x20] = var3; memory[0x40:0x60] = var2 + var3 * 0x20 + 0x20; if (!var3) { var1 = var2; var2 = 0x00; if (var2 >= memory[arg0:arg0 + 0x20]) { label_1ED5: arg0 = var1; r0 = var0; return r0, arg0; } else { label_1E08: var3 = arg0; var var4 = var2; if (var4 >= memory[var3:var3 + 0x20]) { assert(); } var temp4 = memory[var4 * 0x20 + 0x20 + var3:var4 * 0x20 + 0x20 + var3 + 0x20] & (0x01 << 0xa0) - 0x01; var3 = temp4; var4 = 0x0902f1ac; var temp5 = memory[0x40:0x60]; memory[temp5:temp5 + 0x20] = (var4 & 0xffffffff) << 0xe0; var var5 = temp5 + 0x04; var var6 = 0x60; var var7 = memory[0x40:0x60]; var var8 = var5 - var7; var var9 = var7; var var10 = var3; var var11 = !address(var10).code.length; if (var11) { revert(memory[0x00:0x00]); } var temp6; temp6, memory[var7:var7 + var6] = address(var10).staticcall.gas(msg.gas)(memory[var9:var9 + var8]); var6 = !temp6; if (!var6) { var3 = memory[0x40:0x60]; var4 = returndata.length; if (var4 < 0x60) { revert(memory[0x00:0x00]); } var temp7 = var3; var3 = memory[temp7:temp7 + 0x20] & 0xffffffffffffffffffffffffffff; var4 = memory[temp7 + 0x20:temp7 + 0x20 + 0x20] & 0xffffffffffffffffffffffffffff; var5 = var0; var6 = var2; if (var6 >= memory[var5:var5 + 0x20]) { assert(); } var5 = var6 * 0x20 + 0x20 + var5; var6 = var1; var7 = var2; if (var7 >= memory[var6:var6 + 0x20]) { assert(); } memory[var7 * 0x20 + var6 + 0x20:var7 * 0x20 + var6 + 0x20 + 0x20] = var4; memory[var5:var5 + 0x20] = var3; var2 = var2 + 0x01; if (var2 >= memory[arg0:arg0 + 0x20]) { goto label_1ED5; } else { goto label_1E08; } } else { var temp8 = returndata.length; memory[0x00:0x00 + temp8] = returndata[0x00:0x00 + temp8]; revert(memory[0x00:0x00 + returndata.length]); } } } else { var temp9 = var3 * 0x20; memory[var2 + 0x20:var2 + 0x20 + temp9] = msg.data[msg.data.length:msg.data.length + temp9]; var1 = var2; var2 = 0x00; if (var2 >= memory[arg0:arg0 + 0x20]) { goto label_1ED5; } else { goto label_1E08; } } } else { var temp10 = var3 * 0x20; memory[var2 + 0x20:var2 + 0x20 + temp10] = msg.data[msg.data.length:msg.data.length + temp10]; var0 = var2; var2 = memory[arg0:arg0 + 0x20]; var3 = var2 > 0xffffffffffffffff; if (!var3) { goto label_1DCE; } else { revert(memory[0x00:0x00]); } } } function func_1EDB(var arg0, var arg1, var arg2, var arg3) returns (var r0) { var var0 = 0x60; var var1 = memory[arg2:arg2 + 0x20]; var var2 = var1 > 0xffffffffffffffff; if (var2) { revert(memory[0x00:0x00]); } var temp0 = memory[0x40:0x60]; var temp1 = var1; var1 = temp0; var2 = temp1; memory[var1:var1 + 0x20] = var2; memory[0x40:0x60] = var1 + var2 * 0x20 + 0x20; if (!var2) { var0 = var1; var1 = 0x01; if (var1 >= memory[arg2:arg2 + 0x20]) { label_20AE: return var0; } else { label_1F2F: var2 = 0x00; var var3 = arg1; var var4 = var1; if (var4 >= memory[var3:var3 + 0x20]) { assert(); } if (memory[var4 * 0x20 + 0x20 + var3:var4 * 0x20 + 0x20 + var3 + 0x20] <= var2) { var2 = arg2; var3 = var1; if (var3 >= memory[var2:var2 + 0x20]) { assert(); } if (!memory[var3 * 0x20 + 0x20 + var2:var3 * 0x20 + 0x20 + var2 + 0x20]) { var2 = 0x2088; var3 = arg0; var4 = arg3; var var5 = 0x00; if (var5 >= memory[var4:var4 + 0x20]) { assert(); } var2 = func_201D(arg3, var1, var3, var4, var5); arg0 = var2; var2 = arg0; var3 = var0; var4 = var1 - 0x01; if (var4 >= memory[var3:var3 + 0x20]) { assert(); } label_209B: memory[var4 * 0x20 + var3 + 0x20:var4 * 0x20 + var3 + 0x20 + 0x20] = var2; var1 = var1 + 0x01; if (var1 >= memory[arg2:arg2 + 0x20]) { goto label_20AE; } else { goto label_1F2F; } } else { var2 = 0x2045; var3 = arg0; var4 = arg3; var5 = 0x01; if (var5 >= memory[var4:var4 + 0x20]) { assert(); } var2 = func_1FA9(arg3, var1, var3, var4, var5); label_2045: arg0 = var2; label_208B: var2 = arg0; var3 = var0; var4 = var1 - 0x01; if (var4 < memory[var3:var3 + 0x20]) { goto label_209B; } else { assert(); } } } else { var2 = arg2; var3 = var1; if (var3 >= memory[var2:var2 + 0x20]) { assert(); } if (!memory[var3 * 0x20 + 0x20 + var2:var3 * 0x20 + 0x20 + var2 + 0x20]) { var2 = 0x2045; var3 = 0x2010; var4 = 0x03e8; var5 = 0x1f96; var var6 = arg1; var var7 = var1; if (var7 >= memory[var6:var6 + 0x20]) { assert(); } var5 = func_1F7B(arg0, var6, var7); var3 = func_1F96(var4, var5); var2 = func_2010(arg3, var1, var3); goto label_2045; } else { var2 = 0x1ff1; var3 = 0x1f9c; var4 = 0x03e8; var5 = 0x1f96; var6 = arg1; var7 = var1; if (var7 >= memory[var6:var6 + 0x20]) { assert(); } var5 = func_1F7B(arg0, var6, var7); var3 = func_1F96(var4, var5); var2 = func_1F9C(arg3, var1, var3); arg0 = var2; goto label_208B; } } } } else { var temp2 = var2 * 0x20; memory[var1 + 0x20:var1 + 0x20 + temp2] = msg.data[msg.data.length:msg.data.length + temp2]; var0 = var1; var1 = 0x01; if (var1 >= memory[arg2:arg2 + 0x20]) { goto label_20AE; } else { goto label_1F2F; } } } function func_1F7B(var arg0, var arg1, var arg2) returns (var r0) { var temp0 = 0x03e8 - memory[arg2 * 0x20 + 0x20 + arg1:arg2 * 0x20 + 0x20 + arg1 + 0x20]; arg1 = arg0; arg2 = temp0; r0 = func_2D7F(arg1, arg2); // Error: Could not resolve method call return address! } function func_1F96(var arg0, var arg1) returns (var r0) { var temp0 = arg0; arg0 = arg1; arg1 = temp0; var var0 = 0x00; var var1 = 0x2d76; var var2 = arg0; var var3 = arg1; var temp1 = memory[0x40:0x60]; var var4 = temp1; memory[0x40:0x60] = var4 + 0x40; memory[var4:var4 + 0x20] = 0x1a; memory[var4 + 0x20:var4 + 0x20 + 0x20] = 0x536166654d6174683a206469766973696f6e206279207a65726f000000000000; return func_2FC4(var2, var3, var4); } function func_1F9C(var arg0, var arg1, var arg2) returns (var r0) { var var0 = arg0; var var1 = 0x01; if (var1 >= memory[var0:var0 + 0x20]) { assert(); } r0 = func_1FA9(arg0, arg1, arg2, var0, var1); // Error: Could not resolve method call return address! } function func_1FA9(var arg0, var arg1, var arg2, var arg3, var arg4) returns (var r0) { var temp0 = memory[arg4 * 0x20 + 0x20 + arg3:arg4 * 0x20 + 0x20 + arg3 + 0x20]; arg3 = temp0; arg4 = arg1; if (arg4 >= memory[arg3:arg3 + 0x20]) { assert(); } arg3 = memory[arg4 * 0x20 + 0x20 + arg3:arg4 * 0x20 + 0x20 + arg3 + 0x20]; arg4 = arg0; var var0 = 0x00; if (var0 >= memory[arg4:arg4 + 0x20]) { assert(); } var temp1 = memory[var0 * 0x20 + 0x20 + arg4:var0 * 0x20 + 0x20 + arg4 + 0x20]; arg4 = temp1; var0 = arg1; if (var0 >= memory[arg4:arg4 + 0x20]) { assert(); } arg4 = memory[var0 * 0x20 + 0x20 + arg4:var0 * 0x20 + 0x20 + arg4 + 0x20]; var0 = 0x00; if (arg2 > var0) { var var1 = arg3 > 0x00; if (!var1) { if (var1) { label_2EA5: var1 = 0x00; var var2 = 0x2eb3; var var3 = arg2; var var4 = 0x03e5; var2 = func_2D7F(var3, var4); var temp2 = var2; var1 = temp2; var2 = 0x00; var3 = 0x2ec1; var4 = var1; var var5 = arg4; var3 = func_2D7F(var4, var5); var2 = var3; var3 = 0x00; var4 = 0x2edb; var5 = var1; var var6 = 0x2ed5; var var7 = arg3; var var8 = 0x03e8; var6 = func_2D7F(var7, var8); var4 = func_2ED5(var5, var6); var3 = var4; var4 = var3; var5 = var2; if (var4) { return var5 / var4; } else { assert(); } } else { label_2E6F: var temp3 = memory[0x40:0x60]; memory[temp3:temp3 + 0x20] = 0x461bcd << 0xe5; var temp4 = temp3 + 0x04; var temp5 = temp4 + 0x20; memory[temp4:temp4 + 0x20] = temp5 - temp4; memory[temp5:temp5 + 0x20] = 0x28; var temp6 = temp5 + 0x20; memory[temp6:temp6 + 0x28] = code[0x30d6:0x30fe]; var temp7 = memory[0x40:0x60]; revert(memory[temp7:temp7 + (temp6 + 0x40) - temp7]); } } else if (arg4 > 0x00) { goto label_2EA5; } else { goto label_2E6F; } } else { var temp8 = memory[0x40:0x60]; memory[temp8:temp8 + 0x20] = 0x461bcd << 0xe5; var temp9 = temp8 + 0x04; var temp10 = temp9 + 0x20; memory[temp9:temp9 + 0x20] = temp10 - temp9; memory[temp10:temp10 + 0x20] = 0x2b; var temp11 = temp10 + 0x20; memory[temp11:temp11 + 0x2b] = code[0x319e:0x31c9]; var temp12 = memory[0x40:0x60]; revert(memory[temp12:temp12 + (temp11 + 0x40) - temp12]); } } function func_2010(var arg0, var arg1, var arg2) returns (var r0) { var var0 = arg0; var var1 = 0x00; if (var1 >= memory[var0:var0 + 0x20]) { assert(); } r0 = func_201D(arg0, arg1, arg2, var0, var1); // Error: Could not resolve method call return address! } function func_201D(var arg0, var arg1, var arg2, var arg3, var arg4) returns (var r0) { var temp0 = memory[arg4 * 0x20 + 0x20 + arg3:arg4 * 0x20 + 0x20 + arg3 + 0x20]; arg3 = temp0; arg4 = arg1; if (arg4 >= memory[arg3:arg3 + 0x20]) { assert(); } arg3 = memory[arg4 * 0x20 + 0x20 + arg3:arg4 * 0x20 + 0x20 + arg3 + 0x20]; arg4 = arg0; var var0 = 0x01; if (var0 >= memory[arg4:arg4 + 0x20]) { assert(); } var temp1 = memory[var0 * 0x20 + 0x20 + arg4:var0 * 0x20 + 0x20 + arg4 + 0x20]; arg4 = temp1; var0 = arg1; if (var0 >= memory[arg4:arg4 + 0x20]) { assert(); } arg4 = memory[var0 * 0x20 + 0x20 + arg4:var0 * 0x20 + 0x20 + arg4 + 0x20]; var0 = 0x00; if (arg2 > var0) { var var1 = arg3 > 0x00; if (!var1) { if (var1) { label_2EA5: var1 = 0x00; var var2 = 0x2eb3; var var3 = arg2; var var4 = 0x03e5; var2 = func_2D7F(var3, var4); var temp2 = var2; var1 = temp2; var2 = 0x00; var3 = 0x2ec1; var4 = var1; var var5 = arg4; var3 = func_2D7F(var4, var5); var2 = var3; var3 = 0x00; var4 = 0x2edb; var5 = var1; var var6 = 0x2ed5; var var7 = arg3; var var8 = 0x03e8; var6 = func_2D7F(var7, var8); var4 = func_2ED5(var5, var6); var3 = var4; var4 = var3; var5 = var2; if (var4) { return var5 / var4; } else { assert(); } } else { label_2E6F: var temp3 = memory[0x40:0x60]; memory[temp3:temp3 + 0x20] = 0x461bcd << 0xe5; var temp4 = temp3 + 0x04; var temp5 = temp4 + 0x20; memory[temp4:temp4 + 0x20] = temp5 - temp4; memory[temp5:temp5 + 0x20] = 0x28; var temp6 = temp5 + 0x20; memory[temp6:temp6 + 0x28] = code[0x30d6:0x30fe]; var temp7 = memory[0x40:0x60]; revert(memory[temp7:temp7 + (temp6 + 0x40) - temp7]); } } else if (arg4 > 0x00) { goto label_2EA5; } else { goto label_2E6F; } } else { var temp8 = memory[0x40:0x60]; memory[temp8:temp8 + 0x20] = 0x461bcd << 0xe5; var temp9 = temp8 + 0x04; var temp10 = temp9 + 0x20; memory[temp9:temp9 + 0x20] = temp10 - temp9; memory[temp10:temp10 + 0x20] = 0x2b; var temp11 = temp10 + 0x20; memory[temp11:temp11 + 0x2b] = code[0x319e:0x31c9]; var temp12 = memory[0x40:0x60]; revert(memory[temp12:temp12 + (temp11 + 0x40) - temp12]); } } function func_2154(var arg0, var arg1) returns (var r0) { var temp0 = arg0; arg0 = arg1; arg1 = temp0; r0 = func_2D7F(arg0, arg1); // Error: Could not resolve method call return address! } function func_2184(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x00; var var1 = arg2; if (arg1 <= arg0) { return arg0 - arg1; } var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x461bcd << 0xe5; var temp1 = temp0 + 0x04; var var2 = temp1; var var3 = var2; var temp2 = var3 + 0x20; memory[var3:var3 + 0x20] = temp2 - var3; var temp3 = var1; memory[temp2:temp2 + 0x20] = memory[temp3:temp3 + 0x20]; var var4 = temp2 + 0x20; 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_21D8: var temp4 = var6; var4 = temp4 + var4; var5 = temp4 & 0x1f; if (!var5) { var temp5 = memory[0x40:0x60]; revert(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]; revert(memory[temp8:temp8 + (temp7 + 0x20) - temp8]); } } else { label_21C9: var temp9 = var10; memory[temp9 + var8:temp9 + var8 + 0x20] = memory[temp9 + var9:temp9 + var9 + 0x20]; var10 = temp9 + 0x20; if (var10 >= var7) { goto label_21D8; } else { goto label_21C9; } } } function func_221B(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5) { var var0 = arg4; var var1 = 0x00; if (var1 >= memory[var0:var0 + 0x20]) { assert(); } if (!memory[var1 * 0x20 + 0x20 + var0:var1 * 0x20 + 0x20 + var0 + 0x20]) { var0 = arg3; var1 = 0x00; if (var1 >= memory[var0:var0 + 0x20]) { assert(); } var0 = memory[var1 * 0x20 + 0x20 + var0:var1 * 0x20 + 0x20 + var0 + 0x20] & (0x01 << 0xa0) - 0x01; var1 = 0x022c0d9f; var var2 = 0x00; var var3 = arg0; var var4 = address(this); var var5 = arg1; var var6 = arg2; var temp0 = arg3; var var7 = temp0; var var8 = arg4; var var9 = arg5; var temp1 = memory[0x40:0x60] + 0x20; var var10 = temp1; memory[var10:var10 + 0x20] = var5; var temp2 = var10 + 0x20; memory[temp2:temp2 + 0x20] = !!var6; var temp3 = temp2 + 0x20; var var11 = temp3; var var12 = var11 + 0x20; var var13 = var12 + 0x20; var temp4 = var13 + 0x20; memory[var11:var11 + 0x20] = temp4 - var10; memory[temp4:temp4 + 0x20] = memory[var7:var7 + 0x20]; var var14 = temp4 + 0x20; var var15 = var7 + 0x20; var var16 = memory[var7:var7 + 0x20] * 0x20; var var17 = var16; var var18 = var14; var var19 = var15; var var20 = 0x00; if (var20 >= var17) { label_24B0: var temp5 = var16 + var14; memory[var12:var12 + 0x20] = temp5 - var10; var temp6 = var8; memory[temp5:temp5 + 0x20] = memory[temp6:temp6 + 0x20]; var14 = temp5 + 0x20; var15 = temp6 + 0x20; var16 = memory[temp6:temp6 + 0x20] * 0x20; var17 = var16; var18 = var14; var19 = var15; var20 = 0x00; if (var20 >= var17) { label_24EF: var temp7 = var16 + var14; memory[var13:var13 + 0x20] = temp7 - var10; var temp8 = var9; memory[temp7:temp7 + 0x20] = memory[temp8:temp8 + 0x20]; var14 = temp7 + 0x20; var15 = temp8 + 0x20; var16 = memory[temp8:temp8 + 0x20] * 0x20; var17 = var16; var18 = var14; var19 = var15; var20 = 0x00; if (var20 >= var17) { label_252E: var temp9 = var16 + var14; var temp10 = memory[0x40:0x60]; memory[temp10:temp10 + 0x20] = temp9 - temp10 - 0x20; var5 = temp10; memory[0x40:0x60] = temp9; var temp11 = memory[0x40:0x60]; memory[temp11:temp11 + 0x20] = (var1 & 0xffffffff) << 0xe0; var temp12 = temp11 + 0x04; var6 = temp12; memory[var6:var6 + 0x20] = var2; var temp13 = var6 + 0x20; memory[temp13:temp13 + 0x20] = var3; var temp14 = temp13 + 0x20; memory[temp14:temp14 + 0x20] = var4 & (0x01 << 0xa0) - 0x01; var temp15 = temp14 + 0x20; var7 = temp15; var temp16 = var7 + 0x20; memory[var7:var7 + 0x20] = temp16 - var6; memory[temp16:temp16 + 0x20] = memory[var5:var5 + 0x20]; var8 = temp16 + 0x20; var10 = memory[var5:var5 + 0x20]; var9 = var5 + 0x20; var11 = var10; var12 = var8; var13 = var9; var14 = 0x00; if (var14 >= var11) { label_25B5: var temp17 = var10; var8 = temp17 + var8; var9 = temp17 & 0x1f; if (!var9) { var2 = var8; var3 = 0x00; var4 = memory[0x40:0x60]; var5 = var2 - var4; var6 = var4; var7 = 0x00; var8 = var0; var9 = !address(var8).code.length; if (var9) { revert(memory[0x00:0x00]); } label_2604: var temp18; temp18, memory[var4:var4 + var3] = address(var8).call.gas(msg.gas).value(var7)(memory[var6:var6 + var5]); var3 = !temp18; if (!var3) { return; } var temp19 = returndata.length; memory[0x00:0x00 + temp19] = returndata[0x00:0x00 + temp19]; revert(memory[0x00:0x00 + returndata.length]); } else { var temp20 = var9; var temp21 = var8 - temp20; memory[temp21:temp21 + 0x20] = ~(0x0100 ** (0x20 - temp20) - 0x01) & memory[temp21:temp21 + 0x20]; var2 = temp21 + 0x20; var3 = 0x00; var4 = memory[0x40:0x60]; var5 = var2 - var4; var6 = var4; var7 = 0x00; var8 = var0; var9 = !address(var8).code.length; if (!var9) { goto label_2604; } else { revert(memory[0x00:0x00]); } } } else { label_25A6: var temp22 = var14; memory[temp22 + var12:temp22 + var12 + 0x20] = memory[temp22 + var13:temp22 + var13 + 0x20]; var14 = temp22 + 0x20; if (var14 >= var11) { goto label_25B5; } else { goto label_25A6; } } } else { label_251F: var temp23 = var20; memory[temp23 + var18:temp23 + var18 + 0x20] = memory[temp23 + var19:temp23 + var19 + 0x20]; var20 = temp23 + 0x20; if (var20 >= var17) { goto label_252E; } else { goto label_251F; } } } else { label_24E0: var temp24 = var20; memory[temp24 + var18:temp24 + var18 + 0x20] = memory[temp24 + var19:temp24 + var19 + 0x20]; var20 = temp24 + 0x20; if (var20 >= var17) { goto label_24EF; } else { goto label_24E0; } } } else { label_24A1: var temp25 = var20; memory[temp25 + var18:temp25 + var18 + 0x20] = memory[temp25 + var19:temp25 + var19 + 0x20]; var20 = temp25 + 0x20; if (var20 >= var17) { goto label_24B0; } else { goto label_24A1; } } } else { var0 = arg3; var1 = 0x00; if (var1 >= memory[var0:var0 + 0x20]) { assert(); } var0 = memory[var1 * 0x20 + 0x20 + var0:var1 * 0x20 + 0x20 + var0 + 0x20] & (0x01 << 0xa0) - 0x01; var1 = 0x022c0d9f; var2 = arg0; var3 = 0x00; var4 = address(this); var5 = arg1; var6 = arg2; var temp26 = arg3; var7 = temp26; var8 = arg4; var9 = arg5; var temp27 = memory[0x40:0x60] + 0x20; var10 = temp27; memory[var10:var10 + 0x20] = var5; var temp28 = var10 + 0x20; memory[temp28:temp28 + 0x20] = !!var6; var temp29 = temp28 + 0x20; var11 = temp29; var12 = var11 + 0x20; var13 = var12 + 0x20; var temp30 = var13 + 0x20; memory[var11:var11 + 0x20] = temp30 - var10; memory[temp30:temp30 + 0x20] = memory[var7:var7 + 0x20]; var14 = temp30 + 0x20; var15 = var7 + 0x20; var16 = memory[var7:var7 + 0x20] * 0x20; var17 = var16; var18 = var14; var19 = var15; var20 = 0x00; if (var20 >= var17) { label_22BA: var temp31 = var16 + var14; memory[var12:var12 + 0x20] = temp31 - var10; var temp32 = var8; memory[temp31:temp31 + 0x20] = memory[temp32:temp32 + 0x20]; var14 = temp31 + 0x20; var15 = temp32 + 0x20; var16 = memory[temp32:temp32 + 0x20] * 0x20; var17 = var16; var18 = var14; var19 = var15; var20 = 0x00; if (var20 >= var17) { label_22F9: var temp33 = var16 + var14; memory[var13:var13 + 0x20] = temp33 - var10; var temp34 = var9; memory[temp33:temp33 + 0x20] = memory[temp34:temp34 + 0x20]; var14 = temp33 + 0x20; var15 = temp34 + 0x20; var16 = memory[temp34:temp34 + 0x20] * 0x20; var17 = var16; var18 = var14; var19 = var15; var20 = 0x00; if (var20 >= var17) { label_2338: var temp35 = var16 + var14; var temp36 = memory[0x40:0x60]; memory[temp36:temp36 + 0x20] = temp35 - temp36 - 0x20; var5 = temp36; memory[0x40:0x60] = temp35; var temp37 = memory[0x40:0x60]; memory[temp37:temp37 + 0x20] = (var1 & 0xffffffff) << 0xe0; var temp38 = temp37 + 0x04; var6 = temp38; memory[var6:var6 + 0x20] = var2; var temp39 = var6 + 0x20; memory[temp39:temp39 + 0x20] = var3; var temp40 = temp39 + 0x20; memory[temp40:temp40 + 0x20] = var4 & (0x01 << 0xa0) - 0x01; var temp41 = temp40 + 0x20; var7 = temp41; var temp42 = var7 + 0x20; memory[var7:var7 + 0x20] = temp42 - var6; memory[temp42:temp42 + 0x20] = memory[var5:var5 + 0x20]; var8 = temp42 + 0x20; var10 = memory[var5:var5 + 0x20]; var9 = var5 + 0x20; var11 = var10; var12 = var8; var13 = var9; var14 = 0x00; if (var14 >= var11) { label_23BF: var temp43 = var10; var8 = temp43 + var8; var9 = temp43 & 0x1f; if (!var9) { var2 = var8; var3 = 0x00; var4 = memory[0x40:0x60]; var5 = var2 - var4; var6 = var4; var7 = 0x00; var8 = var0; var9 = !address(var8).code.length; if (var9) { revert(memory[0x00:0x00]); } label_240E: var temp44; temp44, memory[var4:var4 + var3] = address(var8).call.gas(msg.gas).value(var7)(memory[var6:var6 + var5]); var3 = !temp44; if (!var3) { return; } var temp45 = returndata.length; memory[0x00:0x00 + temp45] = returndata[0x00:0x00 + temp45]; revert(memory[0x00:0x00 + returndata.length]); } else { var temp46 = var9; var temp47 = var8 - temp46; memory[temp47:temp47 + 0x20] = ~(0x0100 ** (0x20 - temp46) - 0x01) & memory[temp47:temp47 + 0x20]; var2 = temp47 + 0x20; var3 = 0x00; var4 = memory[0x40:0x60]; var5 = var2 - var4; var6 = var4; var7 = 0x00; var8 = var0; var9 = !address(var8).code.length; if (!var9) { goto label_240E; } else { revert(memory[0x00:0x00]); } } } else { label_23B0: var temp48 = var14; memory[temp48 + var12:temp48 + var12 + 0x20] = memory[temp48 + var13:temp48 + var13 + 0x20]; var14 = temp48 + 0x20; if (var14 >= var11) { goto label_23BF; } else { goto label_23B0; } } } else { label_2329: var temp49 = var20; memory[temp49 + var18:temp49 + var18 + 0x20] = memory[temp49 + var19:temp49 + var19 + 0x20]; var20 = temp49 + 0x20; if (var20 >= var17) { goto label_2338; } else { goto label_2329; } } } else { label_22EA: var temp50 = var20; memory[temp50 + var18:temp50 + var18 + 0x20] = memory[temp50 + var19:temp50 + var19 + 0x20]; var20 = temp50 + 0x20; if (var20 >= var17) { goto label_22F9; } else { goto label_22EA; } } } else { label_22AB: var temp51 = var20; memory[temp51 + var18:temp51 + var18 + 0x20] = memory[temp51 + var19:temp51 + var19 + 0x20]; var20 = temp51 + 0x20; if (var20 >= var17) { goto label_22BA; } else { goto label_22AB; } } } } function func_2620(var arg0, var arg1, var arg2) returns (var r0, var arg0, var arg1) { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x02; memory[0x40:0x60] = temp0 + 0x60; var var0 = 0x00; var var1 = 0x60; var var2 = var0; var var3 = var1; var var4 = temp0; var temp1 = var4 + 0x20; memory[temp1:temp1 + 0x20] = 0x60; var var5 = 0x02 - 0x01; var var6 = temp1 + 0x20; if (!var5) { goto label_2652; } label_263F: var temp2 = var6; memory[temp2:temp2 + 0x20] = 0x60; var5 = var5 - 0x01; var6 = temp2 + 0x20; if (var5) { goto label_263F; } label_2652: var3 = var4; var4 = 0x265f; var5 = arg0; var4, var5 = func_1D6E(var5); var6 = var3; var var7 = 0x00; if (var7 >= memory[var6:var6 + 0x20]) { assert(); } var6 = var7 * 0x20 + 0x20 + var6; var7 = var3; var var8 = 0x01; if (var8 >= memory[var7:var7 + 0x20]) { assert(); } memory[var8 * 0x20 + 0x20 + var7:var8 * 0x20 + 0x20 + var7 + 0x20] = var5; memory[var6:var6 + 0x20] = var4; var4 = 0x00; var5 = arg2; var6 = 0x00; if (var6 >= memory[var5:var5 + 0x20]) { assert(); } if (memory[var6 * 0x20 + 0x20 + var5:var6 * 0x20 + 0x20 + var5 + 0x20]) { var5 = 0x03e8; var6 = var3; var7 = 0x00; if (var7 >= memory[var6:var6 + 0x20]) { assert(); } var temp3 = memory[var7 * 0x20 + 0x20 + var6:var7 * 0x20 + 0x20 + var6 + 0x20]; var6 = temp3; var7 = 0x00; if (var7 >= memory[var6:var6 + 0x20]) { assert(); } var6 = memory[var7 * 0x20 + 0x20 + var6:var7 * 0x20 + 0x20 + var6 + 0x20]; if (!var5) { assert(); } var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = 0x02; memory[0x40:0x60] = temp4 + 0x60; var4 = var6 / var5; memory[temp4 + 0x20:temp4 + 0x20 + 0x40] = msg.data[msg.data.length:msg.data.length + 0x40]; var5 = temp4; var6 = 0x00; var7 = var5; var8 = 0x00; if (var8 >= memory[var7:var7 + 0x20]) { assert(); } label_274B: memory[var8 * 0x20 + 0x20 + var7:var8 * 0x20 + 0x20 + var7 + 0x20] = var6; var6 = 0x03e8; var7 = var5; var8 = 0x01; if (var8 >= memory[var7:var7 + 0x20]) { assert(); } memory[var8 * 0x20 + 0x20 + var7:var8 * 0x20 + 0x20 + var7 + 0x20] = var6; if (var0) { label_2A82: arg1 = var2; arg0 = var1; r0 = var0; return r0, arg0, arg1; } else { label_277A: var6 = 0x00; var7 = 0x02; var8 = var5; var var9 = 0x00; if (var9 >= memory[var8:var8 + 0x20]) { assert(); } var8 = memory[var9 * 0x20 + 0x20 + var8:var9 * 0x20 + 0x20 + var8 + 0x20]; var9 = var5; var var10 = 0x01; if (var10 >= memory[var9:var9 + 0x20]) { assert(); } var8 = memory[var10 * 0x20 + 0x20 + var9:var10 * 0x20 + 0x20 + var9 + 0x20] - var8; if (!var7) { assert(); } var7 = var8 / var7; var8 = var5; var9 = 0x00; if (var9 >= memory[var8:var8 + 0x20]) { assert(); } var6 = memory[var9 * 0x20 + 0x20 + var8:var9 * 0x20 + 0x20 + var8 + 0x20] + var7; if (var6 != 0x00) { var7 = 0x00; var8 = arg2; var9 = 0x00; if (var9 >= memory[var8:var8 + 0x20]) { assert(); } if (memory[var9 * 0x20 + 0x20 + var8:var9 * 0x20 + 0x20 + var8 + 0x20]) { var8 = 0x2884; var9 = var6 * var4; var10 = var3; var var11 = 0x01; if (var11 >= memory[var10:var10 + 0x20]) { assert(); } var8 = func_285B(var3, var9, var10, var11); label_2884: var9 = 0x2892; var10 = var6 * var4; var11 = arg1; var var12 = arg2; var var13 = var3; var9 = func_2EF2(var10, var11, var12, var13); var7 = var9 - var8; var8 = 0x00; var9 = arg2; var10 = 0x00; if (var10 >= memory[var9:var9 + 0x20]) { assert(); } if (memory[var10 * 0x20 + 0x20 + var9:var10 * 0x20 + 0x20 + var9 + 0x20]) { var9 = 0x2933; var10 = var6 - 0x01 * var4; var11 = var3; var12 = 0x01; if (var12 >= memory[var11:var11 + 0x20]) { assert(); } var9 = func_290A(var3, var10, var11, var12); label_2933: var10 = 0x2944; var11 = var6 - 0x01 * var4; var12 = arg1; var13 = arg2; var var14 = var3; var10 = func_2EF2(var11, var12, var13, var14); var8 = var10 - var9; var9 = 0x00; var10 = arg2; var11 = 0x00; if (var11 >= memory[var10:var10 + 0x20]) { assert(); } if (memory[var11 * 0x20 + 0x20 + var10:var11 * 0x20 + 0x20 + var10 + 0x20]) { var10 = 0x29e5; var11 = (var6 + 0x01) * var4; var12 = var3; var13 = 0x01; if (var13 >= memory[var12:var12 + 0x20]) { assert(); } var10 = func_29BC(var3, var11, var12, var13); label_29E5: var11 = 0x29f6; var12 = (var6 + 0x01) * var4; var13 = arg1; var14 = arg2; var var15 = var3; var11 = func_2EF2(var12, var13, var14, var15); var9 = var11 - var10; if (var9 i<= var7) { label_2A1F: if (var8 i<= var7) { label_2A45: var10 = var7 i> var9; if (!var10) { if (!var10) { label_2A79: if (var0) { goto label_2A82; } else { goto label_277A; } } else { label_2A59: var2 = var7; var temp5 = var4; var temp6 = var6; var0 = temp6 * temp5; var10 = 0x2a6e; var11 = temp6 * temp5; var12 = arg1; var13 = arg2; var14 = var3; var10 = func_1EDB(var11, var12, var13, var14); var1 = var10; goto label_2A82; } } else if (var7 i<= var8) { goto label_2A79; } else { goto label_2A59; } } else { var10 = var6 - 0x01; var11 = var5; var12 = 0x01; if (var12 >= memory[var11:var11 + 0x20]) { assert(); } memory[var12 * 0x20 + 0x20 + var11:var12 * 0x20 + 0x20 + var11 + 0x20] = var10; goto label_2A45; } } else { var10 = var6 + 0x01; var11 = var5; var12 = 0x00; if (var12 >= memory[var11:var11 + 0x20]) { assert(); } memory[var12 * 0x20 + 0x20 + var11:var12 * 0x20 + 0x20 + var11 + 0x20] = var10; goto label_2A1F; } } else { var10 = 0x29a1; var11 = (var6 + 0x01) * var4; var12 = var3; var13 = 0x00; if (var13 >= memory[var12:var12 + 0x20]) { assert(); } var10 = func_2978(var3, var11, var12, var13); goto label_29E5; } } else { var9 = 0x28ef; var10 = var6 - 0x01 * var4; var11 = var3; var12 = 0x00; if (var12 >= memory[var11:var11 + 0x20]) { assert(); } var9 = func_28C6(var3, var10, var11, var12); goto label_2933; } } else { var8 = 0x2843; var9 = var6 * var4; var10 = var3; var11 = 0x00; if (var11 >= memory[var10:var10 + 0x20]) { assert(); } var8 = func_281A(var3, var9, var10, var11); goto label_2884; } } else { var temp7 = memory[0x40:0x60]; memory[temp7:temp7 + 0x20] = 0x00; memory[0x40:0x60] = temp7 + 0x20; var0 = var4 * var6; var1 = temp7; goto label_2A82; } } } else { var5 = 0x03e8; var6 = var3; var7 = 0x01; if (var7 >= memory[var6:var6 + 0x20]) { assert(); } var temp8 = memory[var7 * 0x20 + 0x20 + var6:var7 * 0x20 + 0x20 + var6 + 0x20]; var6 = temp8; var7 = 0x00; if (var7 >= memory[var6:var6 + 0x20]) { assert(); } var6 = memory[var7 * 0x20 + 0x20 + var6:var7 * 0x20 + 0x20 + var6 + 0x20]; if (!var5) { assert(); } var5 = var6 / var5; var temp9 = memory[0x40:0x60]; memory[temp9:temp9 + 0x20] = 0x02; memory[0x40:0x60] = temp9 + 0x60; var4 = var5; memory[temp9 + 0x20:temp9 + 0x20 + 0x40] = msg.data[msg.data.length:msg.data.length + 0x40]; var5 = temp9; var6 = 0x00; var7 = var5; var8 = 0x00; if (var8 < memory[var7:var7 + 0x20]) { goto label_274B; } else { assert(); } } } function func_281A(var arg0, var arg1, var arg2, var arg3) returns (var r0) { var temp0 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg2 = temp0; arg3 = 0x00; if (arg3 >= memory[arg2:arg2 + 0x20]) { assert(); } arg2 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg3 = arg0; var var0 = 0x01; if (var0 >= memory[arg3:arg3 + 0x20]) { assert(); } var temp1 = memory[var0 * 0x20 + 0x20 + arg3:var0 * 0x20 + 0x20 + arg3 + 0x20]; arg3 = temp1; var0 = 0x00; if (var0 >= memory[arg3:arg3 + 0x20]) { assert(); } arg3 = memory[var0 * 0x20 + 0x20 + arg3:var0 * 0x20 + 0x20 + arg3 + 0x20]; var0 = 0x00; if (arg1 > var0) { var var1 = arg2 > 0x00; if (!var1) { if (var1) { label_2142: var1 = 0x00; var var2 = 0x215a; var var3 = 0x03e8; var var4 = 0x2154; var var5 = arg2; var var6 = arg1; var4 = func_2D7F(var5, var6); var2 = func_2154(var3, var4); var1 = var2; var2 = 0x00; var3 = 0x216e; var4 = 0x03e5; var5 = 0x2154; var6 = arg3; var var7 = arg1; var5 = func_2D34(var6, var7); var3 = func_2154(var4, var5); var2 = var3; var3 = var2; var4 = var1; if (var3) { return var4 / var3; } else { assert(); } } else { label_210C: var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x461bcd << 0xe5; var temp3 = temp2 + 0x04; var temp4 = temp3 + 0x20; memory[temp3:temp3 + 0x20] = temp4 - temp3; memory[temp4:temp4 + 0x20] = 0x28; var temp5 = temp4 + 0x20; memory[temp5:temp5 + 0x28] = code[0x30d6:0x30fe]; var temp6 = memory[0x40:0x60]; revert(memory[temp6:temp6 + (temp5 + 0x40) - temp6]); } } else if (arg3 > 0x00) { goto label_2142; } else { goto label_210C; } } else { var temp7 = memory[0x40:0x60]; memory[temp7:temp7 + 0x20] = 0x461bcd << 0xe5; var temp8 = temp7 + 0x04; var temp9 = temp8 + 0x20; memory[temp8:temp8 + 0x20] = temp9 - temp8; memory[temp9:temp9 + 0x20] = 0x2c; var temp10 = temp9 + 0x20; memory[temp10:temp10 + 0x2c] = code[0x30aa:0x30d6]; var temp11 = memory[0x40:0x60]; revert(memory[temp11:temp11 + (temp10 + 0x40) - temp11]); } } function func_285B(var arg0, var arg1, var arg2, var arg3) returns (var r0) { var temp0 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg2 = temp0; arg3 = 0x00; if (arg3 >= memory[arg2:arg2 + 0x20]) { assert(); } arg2 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg3 = arg0; var var0 = 0x00; if (var0 >= memory[arg3:arg3 + 0x20]) { assert(); } var temp1 = memory[var0 * 0x20 + 0x20 + arg3:var0 * 0x20 + 0x20 + arg3 + 0x20]; arg3 = temp1; var0 = 0x00; if (var0 >= memory[arg3:arg3 + 0x20]) { assert(); } arg3 = memory[var0 * 0x20 + 0x20 + arg3:var0 * 0x20 + 0x20 + arg3 + 0x20]; var0 = 0x00; if (arg1 > var0) { var var1 = arg2 > 0x00; if (!var1) { if (var1) { label_2142: var1 = 0x00; var var2 = 0x215a; var var3 = 0x03e8; var var4 = 0x2154; var var5 = arg2; var var6 = arg1; var4 = func_2D7F(var5, var6); var2 = func_2154(var3, var4); var1 = var2; var2 = 0x00; var3 = 0x216e; var4 = 0x03e5; var5 = 0x2154; var6 = arg3; var var7 = arg1; var5 = func_2D34(var6, var7); var3 = func_2154(var4, var5); var2 = var3; var3 = var2; var4 = var1; if (var3) { return var4 / var3; } else { assert(); } } else { label_210C: var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x461bcd << 0xe5; var temp3 = temp2 + 0x04; var temp4 = temp3 + 0x20; memory[temp3:temp3 + 0x20] = temp4 - temp3; memory[temp4:temp4 + 0x20] = 0x28; var temp5 = temp4 + 0x20; memory[temp5:temp5 + 0x28] = code[0x30d6:0x30fe]; var temp6 = memory[0x40:0x60]; revert(memory[temp6:temp6 + (temp5 + 0x40) - temp6]); } } else if (arg3 > 0x00) { goto label_2142; } else { goto label_210C; } } else { var temp7 = memory[0x40:0x60]; memory[temp7:temp7 + 0x20] = 0x461bcd << 0xe5; var temp8 = temp7 + 0x04; var temp9 = temp8 + 0x20; memory[temp8:temp8 + 0x20] = temp9 - temp8; memory[temp9:temp9 + 0x20] = 0x2c; var temp10 = temp9 + 0x20; memory[temp10:temp10 + 0x2c] = code[0x30aa:0x30d6]; var temp11 = memory[0x40:0x60]; revert(memory[temp11:temp11 + (temp10 + 0x40) - temp11]); } } function func_28C6(var arg0, var arg1, var arg2, var arg3) returns (var r0) { var temp0 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg2 = temp0; arg3 = 0x00; if (arg3 >= memory[arg2:arg2 + 0x20]) { assert(); } arg2 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg3 = arg0; var var0 = 0x01; if (var0 >= memory[arg3:arg3 + 0x20]) { assert(); } var temp1 = memory[var0 * 0x20 + 0x20 + arg3:var0 * 0x20 + 0x20 + arg3 + 0x20]; arg3 = temp1; var0 = 0x00; if (var0 >= memory[arg3:arg3 + 0x20]) { assert(); } arg3 = memory[var0 * 0x20 + 0x20 + arg3:var0 * 0x20 + 0x20 + arg3 + 0x20]; var0 = 0x00; if (arg1 > var0) { var var1 = arg2 > 0x00; if (!var1) { if (var1) { label_2142: var1 = 0x00; var var2 = 0x215a; var var3 = 0x03e8; var var4 = 0x2154; var var5 = arg2; var var6 = arg1; var4 = func_2D7F(var5, var6); var2 = func_2154(var3, var4); var1 = var2; var2 = 0x00; var3 = 0x216e; var4 = 0x03e5; var5 = 0x2154; var6 = arg3; var var7 = arg1; var5 = func_2D34(var6, var7); var3 = func_2154(var4, var5); var2 = var3; var3 = var2; var4 = var1; if (var3) { return var4 / var3; } else { assert(); } } else { label_210C: var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x461bcd << 0xe5; var temp3 = temp2 + 0x04; var temp4 = temp3 + 0x20; memory[temp3:temp3 + 0x20] = temp4 - temp3; memory[temp4:temp4 + 0x20] = 0x28; var temp5 = temp4 + 0x20; memory[temp5:temp5 + 0x28] = code[0x30d6:0x30fe]; var temp6 = memory[0x40:0x60]; revert(memory[temp6:temp6 + (temp5 + 0x40) - temp6]); } } else if (arg3 > 0x00) { goto label_2142; } else { goto label_210C; } } else { var temp7 = memory[0x40:0x60]; memory[temp7:temp7 + 0x20] = 0x461bcd << 0xe5; var temp8 = temp7 + 0x04; var temp9 = temp8 + 0x20; memory[temp8:temp8 + 0x20] = temp9 - temp8; memory[temp9:temp9 + 0x20] = 0x2c; var temp10 = temp9 + 0x20; memory[temp10:temp10 + 0x2c] = code[0x30aa:0x30d6]; var temp11 = memory[0x40:0x60]; revert(memory[temp11:temp11 + (temp10 + 0x40) - temp11]); } } function func_290A(var arg0, var arg1, var arg2, var arg3) returns (var r0) { var temp0 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg2 = temp0; arg3 = 0x00; if (arg3 >= memory[arg2:arg2 + 0x20]) { assert(); } arg2 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg3 = arg0; var var0 = 0x00; if (var0 >= memory[arg3:arg3 + 0x20]) { assert(); } var temp1 = memory[var0 * 0x20 + 0x20 + arg3:var0 * 0x20 + 0x20 + arg3 + 0x20]; arg3 = temp1; var0 = 0x00; if (var0 >= memory[arg3:arg3 + 0x20]) { assert(); } arg3 = memory[var0 * 0x20 + 0x20 + arg3:var0 * 0x20 + 0x20 + arg3 + 0x20]; var0 = 0x00; if (arg1 > var0) { var var1 = arg2 > 0x00; if (!var1) { if (var1) { label_2142: var1 = 0x00; var var2 = 0x215a; var var3 = 0x03e8; var var4 = 0x2154; var var5 = arg2; var var6 = arg1; var4 = func_2D7F(var5, var6); var2 = func_2154(var3, var4); var1 = var2; var2 = 0x00; var3 = 0x216e; var4 = 0x03e5; var5 = 0x2154; var6 = arg3; var var7 = arg1; var5 = func_2D34(var6, var7); var3 = func_2154(var4, var5); var2 = var3; var3 = var2; var4 = var1; if (var3) { return var4 / var3; } else { assert(); } } else { label_210C: var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x461bcd << 0xe5; var temp3 = temp2 + 0x04; var temp4 = temp3 + 0x20; memory[temp3:temp3 + 0x20] = temp4 - temp3; memory[temp4:temp4 + 0x20] = 0x28; var temp5 = temp4 + 0x20; memory[temp5:temp5 + 0x28] = code[0x30d6:0x30fe]; var temp6 = memory[0x40:0x60]; revert(memory[temp6:temp6 + (temp5 + 0x40) - temp6]); } } else if (arg3 > 0x00) { goto label_2142; } else { goto label_210C; } } else { var temp7 = memory[0x40:0x60]; memory[temp7:temp7 + 0x20] = 0x461bcd << 0xe5; var temp8 = temp7 + 0x04; var temp9 = temp8 + 0x20; memory[temp8:temp8 + 0x20] = temp9 - temp8; memory[temp9:temp9 + 0x20] = 0x2c; var temp10 = temp9 + 0x20; memory[temp10:temp10 + 0x2c] = code[0x30aa:0x30d6]; var temp11 = memory[0x40:0x60]; revert(memory[temp11:temp11 + (temp10 + 0x40) - temp11]); } } function func_2978(var arg0, var arg1, var arg2, var arg3) returns (var r0) { var temp0 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg2 = temp0; arg3 = 0x00; if (arg3 >= memory[arg2:arg2 + 0x20]) { assert(); } arg2 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg3 = arg0; var var0 = 0x01; if (var0 >= memory[arg3:arg3 + 0x20]) { assert(); } var temp1 = memory[var0 * 0x20 + 0x20 + arg3:var0 * 0x20 + 0x20 + arg3 + 0x20]; arg3 = temp1; var0 = 0x00; if (var0 >= memory[arg3:arg3 + 0x20]) { assert(); } arg3 = memory[var0 * 0x20 + 0x20 + arg3:var0 * 0x20 + 0x20 + arg3 + 0x20]; var0 = 0x00; if (arg1 > var0) { var var1 = arg2 > 0x00; if (!var1) { if (var1) { label_2142: var1 = 0x00; var var2 = 0x215a; var var3 = 0x03e8; var var4 = 0x2154; var var5 = arg2; var var6 = arg1; var4 = func_2D7F(var5, var6); var2 = func_2154(var3, var4); var1 = var2; var2 = 0x00; var3 = 0x216e; var4 = 0x03e5; var5 = 0x2154; var6 = arg3; var var7 = arg1; var5 = func_2D34(var6, var7); var3 = func_2154(var4, var5); var2 = var3; var3 = var2; var4 = var1; if (var3) { return var4 / var3; } else { assert(); } } else { label_210C: var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x461bcd << 0xe5; var temp3 = temp2 + 0x04; var temp4 = temp3 + 0x20; memory[temp3:temp3 + 0x20] = temp4 - temp3; memory[temp4:temp4 + 0x20] = 0x28; var temp5 = temp4 + 0x20; memory[temp5:temp5 + 0x28] = code[0x30d6:0x30fe]; var temp6 = memory[0x40:0x60]; revert(memory[temp6:temp6 + (temp5 + 0x40) - temp6]); } } else if (arg3 > 0x00) { goto label_2142; } else { goto label_210C; } } else { var temp7 = memory[0x40:0x60]; memory[temp7:temp7 + 0x20] = 0x461bcd << 0xe5; var temp8 = temp7 + 0x04; var temp9 = temp8 + 0x20; memory[temp8:temp8 + 0x20] = temp9 - temp8; memory[temp9:temp9 + 0x20] = 0x2c; var temp10 = temp9 + 0x20; memory[temp10:temp10 + 0x2c] = code[0x30aa:0x30d6]; var temp11 = memory[0x40:0x60]; revert(memory[temp11:temp11 + (temp10 + 0x40) - temp11]); } } function func_29BC(var arg0, var arg1, var arg2, var arg3) returns (var r0) { var temp0 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg2 = temp0; arg3 = 0x00; if (arg3 >= memory[arg2:arg2 + 0x20]) { assert(); } arg2 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg3 = arg0; var var0 = 0x00; if (var0 >= memory[arg3:arg3 + 0x20]) { assert(); } var temp1 = memory[var0 * 0x20 + 0x20 + arg3:var0 * 0x20 + 0x20 + arg3 + 0x20]; arg3 = temp1; var0 = 0x00; if (var0 >= memory[arg3:arg3 + 0x20]) { assert(); } arg3 = memory[var0 * 0x20 + 0x20 + arg3:var0 * 0x20 + 0x20 + arg3 + 0x20]; var0 = 0x00; if (arg1 > var0) { var var1 = arg2 > 0x00; if (!var1) { if (var1) { label_2142: var1 = 0x00; var var2 = 0x215a; var var3 = 0x03e8; var var4 = 0x2154; var var5 = arg2; var var6 = arg1; var4 = func_2D7F(var5, var6); var2 = func_2154(var3, var4); var1 = var2; var2 = 0x00; var3 = 0x216e; var4 = 0x03e5; var5 = 0x2154; var6 = arg3; var var7 = arg1; var5 = func_2D34(var6, var7); var3 = func_2154(var4, var5); var2 = var3; var3 = var2; var4 = var1; if (var3) { return var4 / var3; } else { assert(); } } else { label_210C: var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x461bcd << 0xe5; var temp3 = temp2 + 0x04; var temp4 = temp3 + 0x20; memory[temp3:temp3 + 0x20] = temp4 - temp3; memory[temp4:temp4 + 0x20] = 0x28; var temp5 = temp4 + 0x20; memory[temp5:temp5 + 0x28] = code[0x30d6:0x30fe]; var temp6 = memory[0x40:0x60]; revert(memory[temp6:temp6 + (temp5 + 0x40) - temp6]); } } else if (arg3 > 0x00) { goto label_2142; } else { goto label_210C; } } else { var temp7 = memory[0x40:0x60]; memory[temp7:temp7 + 0x20] = 0x461bcd << 0xe5; var temp8 = temp7 + 0x04; var temp9 = temp8 + 0x20; memory[temp8:temp8 + 0x20] = temp9 - temp8; memory[temp9:temp9 + 0x20] = 0x2c; var temp10 = temp9 + 0x20; memory[temp10:temp10 + 0x2c] = code[0x30aa:0x30d6]; var temp11 = memory[0x40:0x60]; revert(memory[temp11:temp11 + (temp10 + 0x40) - temp11]); } } function func_2A8E(var arg0, var arg1) { var temp0 = memory[0x40:0x60]; var temp1 = arg1; var temp2; temp2, memory[temp0:temp0 + 0x00] = address(arg0 & (0x01 << 0xa0) - 0x01).call.gas(!temp1 * 0x08fc).value(temp1)(memory[temp0:temp0 + 0x00]); var var0 = !temp2; if (!var0) { return; } var temp3 = returndata.length; memory[0x00:0x00 + temp3] = returndata[0x00:0x00 + temp3]; revert(memory[0x00:0x00 + returndata.length]); } function func_2AC9(var arg0, var arg1, var arg2) { var temp0 = memory[0x40:0x60]; var temp1 = (0x01 << 0xa0) - 0x01; memory[temp0 + 0x24:temp0 + 0x24 + 0x20] = temp1 & arg1; memory[temp0 + 0x44:temp0 + 0x44 + 0x20] = arg2; var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = temp0 - temp2 + 0x44; memory[0x40:0x60] = temp0 + 0x64; var temp3 = temp2 + 0x20; memory[temp3:temp3 + 0x20] = (memory[temp3:temp3 + 0x20] & (0x01 << 0xe0) - 0x01) | (0xa9059cbb << 0xe0); var var0 = 0x00; var var1 = 0x60; var var2 = arg0 & temp1; var var3 = temp2; var var4 = memory[0x40:0x60]; var var5 = var4; var var7 = memory[var3:var3 + 0x20]; var var6 = temp3; var var8 = var7; var var9 = var5; var var10 = var6; if (var8 < 0x20) { label_2B46: var temp4 = 0x0100 ** (0x20 - var8) - 0x01; var temp5 = var9; memory[temp5:temp5 + 0x20] = (memory[var10:var10 + 0x20] & ~temp4) | (memory[temp5:temp5 + 0x20] & temp4); var temp6 = memory[0x40:0x60]; var temp7; temp7, memory[temp6:temp6 + 0x00] = address(var2).call.gas(msg.gas)(memory[temp6:temp6 + (var7 + var5) - temp6]); var3 = returndata.length; var4 = var3; if (var4 == 0x00) { var1 = 0x60; var temp8 = var2; var0 = temp8; var2 = var0; if (!var2) { label_2BDB: if (var2) { return; } var temp9 = memory[0x40:0x60]; memory[temp9:temp9 + 0x20] = 0x461bcd << 0xe5; memory[temp9 + 0x04:temp9 + 0x04 + 0x20] = 0x20; memory[temp9 + 0x24:temp9 + 0x24 + 0x20] = 0x1c; memory[temp9 + 0x44:temp9 + 0x44 + 0x20] = 0x4641204578656375746f723a205452414e534645525f4641494c454400000000; var temp10 = memory[0x40:0x60]; revert(memory[temp10:temp10 + temp9 - temp10 + 0x64]); } else { label_2BBA: var2 = !memory[var1:var1 + 0x20]; if (var2) { goto label_2BDB; } var temp11 = var1; var2 = temp11 + 0x20; var3 = memory[temp11:temp11 + 0x20]; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var2 = memory[var2:var2 + 0x20]; goto label_2BDB; } } else { var temp12 = memory[0x40:0x60]; var3 = temp12; memory[0x40:0x60] = var3 + (returndata.length + 0x3f & ~0x1f); memory[var3:var3 + 0x20] = returndata.length; var temp13 = returndata.length; memory[var3 + 0x20:var3 + 0x20 + temp13] = returndata[0x00:0x00 + temp13]; var1 = var3; var temp14 = var2; var0 = temp14; var2 = var0; if (!var2) { goto label_2BDB; } else { goto label_2BBA; } } } else { label_2B30: var temp15 = var10; var temp16 = var9; memory[temp16:temp16 + 0x20] = memory[temp15:temp15 + 0x20]; var8 = var8 + ~0x1f; var9 = temp16 + 0x20; var10 = temp15 + 0x20; if (var8 < 0x20) { goto label_2B46; } else { goto label_2B30; } } } function func_2D34(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x2d76; var var2 = arg0; var var3 = arg1; var temp0 = memory[0x40:0x60]; var var4 = temp0; memory[0x40:0x60] = var4 + 0x40; memory[var4:var4 + 0x20] = 0x1e; memory[var4 + 0x20:var4 + 0x20 + 0x20] = 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000; return func_2184(var2, var3, var4); } function func_2D7F(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (!arg0) { return 0x00; } var var1 = arg1 * arg0; var var2 = arg1; var var3 = arg0; var var4 = var1; if (!var3) { assert(); } if (var4 / var3 == var2) { return var1; } var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x461bcd << 0xe5; var temp1 = temp0 + 0x04; var temp2 = temp1 + 0x20; memory[temp1:temp1 + 0x20] = temp2 - temp1; memory[temp2:temp2 + 0x20] = 0x21; var temp3 = temp2 + 0x20; memory[temp3:temp3 + 0x21] = code[0x30fe:0x311f]; var temp4 = memory[0x40:0x60]; revert(memory[temp4:temp4 + (temp3 + 0x40) - temp4]); } function func_2ED5(var arg0, var arg1) returns (var r0) { var temp0 = arg0; arg0 = arg1; arg1 = temp0; var var0 = 0x00; var temp1 = arg0; var var1 = arg1 + temp1; if (var1 >= temp1) { return var1; } var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x461bcd << 0xe5; memory[temp2 + 0x04:temp2 + 0x04 + 0x20] = 0x20; memory[temp2 + 0x24:temp2 + 0x24 + 0x20] = 0x1b; memory[temp2 + 0x44:temp2 + 0x44 + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000; var temp3 = memory[0x40:0x60]; revert(memory[temp3:temp3 + temp2 - temp3 + 0x64]); } function func_2EF2(var arg0, var arg1, var arg2, var arg3) returns (var r0) { var var0 = 0x00; var var1 = 0x01; if (var1 >= memory[arg2:arg2 + 0x20]) { label_2FBA: return arg0; } else { label_2F01: var var2 = 0x00; var var3 = arg1; var var4 = var1; if (var4 >= memory[var3:var3 + 0x20]) { assert(); } if (memory[var4 * 0x20 + 0x20 + var3:var4 * 0x20 + 0x20 + var3 + 0x20] <= var2) { var2 = arg2; var3 = var1; if (var3 >= memory[var2:var2 + 0x20]) { assert(); } if (!memory[var3 * 0x20 + 0x20 + var2:var3 * 0x20 + 0x20 + var2 + 0x20]) { var2 = 0x2faf; var3 = arg0; var4 = arg3; var var5 = 0x00; if (var5 >= memory[var4:var4 + 0x20]) { assert(); } var2 = func_201D(arg3, var1, var3, var4, var5); arg0 = var2; var1 = var1 + 0x01; label_2EF7: if (var1 >= memory[arg2:arg2 + 0x20]) { goto label_2FBA; } else { goto label_2F01; } } else { var2 = 0x2f6c; var3 = arg0; var4 = arg3; var5 = 0x01; if (var5 >= memory[var4:var4 + 0x20]) { assert(); } var2 = func_1FA9(arg3, var1, var3, var4, var5); label_2F6C: arg0 = var2; label_2FB2: var1 = var1 + 0x01; goto label_2EF7; } } else { var2 = arg2; var3 = var1; if (var3 >= memory[var2:var2 + 0x20]) { assert(); } if (!memory[var3 * 0x20 + 0x20 + var2:var3 * 0x20 + 0x20 + var2 + 0x20]) { var2 = 0x2f6c; var3 = 0x2010; var4 = 0x03e8; var5 = 0x1f96; var var6 = arg1; var var7 = var1; if (var7 >= memory[var6:var6 + 0x20]) { assert(); } var5 = func_1F7B(arg0, var6, var7); var3 = func_1F96(var4, var5); var2 = func_2010(arg3, var1, var3); goto label_2F6C; } else { var2 = 0x2f4d; var3 = 0x1f9c; var4 = 0x03e8; var5 = 0x1f96; var6 = arg1; var7 = var1; if (var7 >= memory[var6:var6 + 0x20]) { assert(); } var5 = func_1F7B(arg0, var6, var7); var3 = func_1F96(var4, var5); var2 = func_1F9C(arg3, var1, var3); arg0 = var2; goto label_2FB2; } } } } function func_2FC4(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x00; var var1 = arg2; if (arg1) { var1 = 0x00; var var2 = arg1; var var3 = arg0; if (var2) { return var3 / var2; } else { assert(); } } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x461bcd << 0xe5; memory[temp0 + 0x04:temp0 + 0x04 + 0x20] = 0x20; var temp1 = var1; memory[temp0 + 0x24:temp0 + 0x24 + 0x20] = memory[temp1:temp1 + 0x20]; var2 = temp0 + 0x04; var3 = var2; var var4 = temp0 + 0x44; var var5 = temp1 + 0x20; var var6 = memory[temp1:temp1 + 0x20]; var var7 = var6; var var8 = var4; var var9 = var5; var var10 = 0x00; if (!var7) { label_21D8: var temp2 = var6; var4 = temp2 + var4; var5 = temp2 & 0x1f; if (!var5) { var temp3 = memory[0x40:0x60]; revert(memory[temp3:temp3 + var4 - temp3]); } else { var temp4 = var5; var temp5 = var4 - temp4; memory[temp5:temp5 + 0x20] = ~(0x0100 ** (0x20 - temp4) - 0x01) & memory[temp5:temp5 + 0x20]; var temp6 = memory[0x40:0x60]; revert(memory[temp6:temp6 + (temp5 + 0x20) - temp6]); } } else { var temp7 = var10; memory[temp7 + var8:temp7 + var8 + 0x20] = memory[temp7 + var9:temp7 + var9 + 0x20]; var10 = temp7 + 0x20; label_21C0: if (var10 >= var7) { goto label_21D8; } var temp8 = var10; memory[temp8 + var8:temp8 + var8 + 0x20] = memory[temp8 + var9:temp8 + var9 + 0x20]; var10 = temp8 + 0x20; goto label_21C0; } } } }

Disassembly

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x00f5 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x00f5, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x9e252f00 0026 11 GT 0027 61 PUSH2 0x0097 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0097, if 0x9e252f00 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x9e252f00 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xf2fde38b 0031 11 GT 0032 61 PUSH2 0x0066 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0066, if 0xf2fde38b > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xf2fde38b > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xf2fde38b 003C 14 EQ 003D 61 PUSH2 0x08bc 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08bc, if 0xf2fde38b == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xf3d3d448 0047 14 EQ 0048 61 PUSH2 0x08e2 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08e2, if 0xf3d3d448 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xf3d3d448 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xf77c4791 0052 14 EQ 0053 61 PUSH2 0x0908 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0908, if 0xf77c4791 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xf77c4791 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xfd9af456 005D 14 EQ 005E 61 PUSH2 0x0910 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0910, if 0xfd9af456 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xfd9af456 == stack[-1] 0062 61 PUSH2 0x00f5 0065 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00f5 label_0066: // Incoming jump from 0x0035, if 0xf2fde38b > stack[-1] // Inputs[1] { @0067 stack[-1] } 0066 5B JUMPDEST 0067 80 DUP1 0068 63 PUSH4 0x9e252f00 006D 14 EQ 006E 61 PUSH2 0x053b 0071 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x053b, if 0x9e252f00 == stack[-1] label_0072: // Incoming jump from 0x0071, if not 0x9e252f00 == stack[-1] // Inputs[1] { @0072 stack[-1] } 0072 80 DUP1 0073 63 PUSH4 0xc0c06fef 0078 14 EQ 0079 61 PUSH2 0x0558 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0558, if 0xc0c06fef == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0xc0c06fef == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0xc90cc44d 0083 14 EQ 0084 61 PUSH2 0x070f 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x070f, if 0xc90cc44d == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xc90cc44d == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xeb2c7de3 008E 14 EQ 008F 61 PUSH2 0x08b4 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08b4, if 0xeb2c7de3 == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xeb2c7de3 == stack[-1] 0093 61 PUSH2 0x00f5 0096 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00f5 label_0097: // Incoming jump from 0x002A, if 0x9e252f00 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0098 stack[-1] } 0097 5B JUMPDEST 0098 80 DUP1 0099 63 PUSH4 0x5bd717a4 009E 11 GT 009F 61 PUSH2 0x00d3 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d3, if 0x5bd717a4 > stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0x5bd717a4 > stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0x5bd717a4 00A9 14 EQ 00AA 61 PUSH2 0x01d6 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d6, if 0x5bd717a4 == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x5bd717a4 == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x715018a6 00B4 14 EQ 00B5 61 PUSH2 0x0384 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0384, if 0x715018a6 == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x715018a6 == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x8da5cb5b 00BF 14 EQ 00C0 61 PUSH2 0x038c 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x038c, if 0x8da5cb5b == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x8ed36a4f 00CA 14 EQ 00CB 61 PUSH2 0x0394 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0394, if 0x8ed36a4f == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x8ed36a4f == stack[-1] 00CF 61 PUSH2 0x00f5 00D2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00f5 label_00D3: // Incoming jump from 0x00A2, if 0x5bd717a4 > stack[-1] // Inputs[1] { @00D4 stack[-1] } 00D3 5B JUMPDEST 00D4 80 DUP1 00D5 63 PUSH4 0x10d1e85c 00DA 14 EQ 00DB 61 PUSH2 0x00fa 00DE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00fa, if 0x10d1e85c == stack[-1] label_00DF: // Incoming jump from 0x00DE, if not 0x10d1e85c == stack[-1] // Inputs[1] { @00DF stack[-1] } 00DF 80 DUP1 00E0 63 PUSH4 0x4dede3de 00E5 14 EQ 00E6 61 PUSH2 0x0186 00E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0186, if 0x4dede3de == stack[-1] label_00EA: // Incoming jump from 0x00E9, if not 0x4dede3de == stack[-1] // Inputs[1] { @00EA stack[-1] } 00EA 80 DUP1 00EB 63 PUSH4 0x57376198 00F0 14 EQ 00F1 61 PUSH2 0x01aa 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01aa, if 0x57376198 == stack[-1] label_00F5: // Incoming jump from 0x00D2 // Incoming jump from 0x0096 // Incoming jump from 0x0065 // Incoming jump from 0x00F4, if not 0x57376198 == stack[-1] // Incoming jump from 0x0019, if msg.data.length < 0x04 // Inputs[1] { @00F9 memory[0x00:0x00] } 00F5 5B JUMPDEST 00F6 60 PUSH1 0x00 00F8 80 DUP1 00F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F9 revert(memory[0x00:0x00]); } // Block terminates label_00FA: // Incoming jump from 0x00DE, if 0x10d1e85c == stack[-1] // Inputs[1] { @0101 msg.data.length } 00FA 5B JUMPDEST 00FB 61 PUSH2 0x0184 00FE 60 PUSH1 0x04 0100 80 DUP1 0101 36 CALLDATASIZE 0102 03 SUB 0103 60 PUSH1 0x80 0105 81 DUP2 0106 10 LT 0107 15 ISZERO 0108 61 PUSH2 0x0110 010B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @00FB stack[0] = 0x0184 // @00FE stack[1] = 0x04 // @0102 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0110, if !(msg.data.length - 0x04 < 0x80) label_010C: // Incoming jump from 0x010B, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @010F memory[0x00:0x00] } 010C 60 PUSH1 0x00 010E 80 DUP1 010F FD *REVERT // Stack delta = +0 // Outputs[1] { @010F revert(memory[0x00:0x00]); } // Block terminates label_0110: // Incoming jump from 0x010B, if !(msg.data.length - 0x04 < 0x80) // Inputs[6] // { // @0119 stack[-2] // @011A msg.data[stack[-2]:stack[-2] + 0x20] // @0121 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0122 stack[-1] // @0127 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0135 msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } 0110 5B JUMPDEST 0111 60 PUSH1 0x01 0113 60 PUSH1 0x01 0115 60 PUSH1 0xa0 0117 1B SHL 0118 03 SUB 0119 82 DUP3 011A 35 CALLDATALOAD 011B 16 AND 011C 91 SWAP2 011D 60 PUSH1 0x20 011F 81 DUP2 0120 01 ADD 0121 35 CALLDATALOAD 0122 91 SWAP2 0123 60 PUSH1 0x40 0125 82 DUP3 0126 01 ADD 0127 35 CALLDATALOAD 0128 91 SWAP2 0129 90 SWAP1 012A 81 DUP2 012B 01 ADD 012C 90 SWAP1 012D 60 PUSH1 0x80 012F 81 DUP2 0130 01 ADD 0131 60 PUSH1 0x60 0133 82 DUP3 0134 01 ADD 0135 35 CALLDATALOAD 0136 60 PUSH1 0x01 0138 60 PUSH1 0x20 013A 1B SHL 013B 81 DUP2 013C 11 GT 013D 15 ISZERO 013E 61 PUSH2 0x0146 0141 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @011C stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0122 stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0128 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @012C stack[1] = stack[-2] + stack[-1] // @012C stack[2] = stack[-2] // @0130 stack[3] = stack[-2] + 0x80 // @0135 stack[4] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x0146, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) label_0142: // Incoming jump from 0x0141, if not !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) // Inputs[1] { @0145 memory[0x00:0x00] } 0142 60 PUSH1 0x00 0144 80 DUP1 0145 FD *REVERT // Stack delta = +0 // Outputs[1] { @0145 revert(memory[0x00:0x00]); } // Block terminates label_0146: // Incoming jump from 0x0141, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0147 stack[-3] // @0148 stack[-1] // @0149 stack[-4] // } 0146 5B JUMPDEST 0147 82 DUP3 0148 01 ADD 0149 83 DUP4 014A 60 PUSH1 0x20 014C 82 DUP3 014D 01 ADD 014E 11 GT 014F 15 ISZERO 0150 61 PUSH2 0x0158 0153 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0148 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0158, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0154: // Incoming jump from 0x0153, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0157 memory[0x00:0x00] } 0154 60 PUSH1 0x00 0156 80 DUP1 0157 FD *REVERT // Stack delta = +0 // Outputs[1] { @0157 revert(memory[0x00:0x00]); } // Block terminates label_0158: // Incoming jump from 0x0153, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0159 stack[-1] // @015A msg.data[stack[-1]:stack[-1] + 0x20] // @015F stack[-2] // @0160 stack[-4] // } 0158 5B JUMPDEST 0159 80 DUP1 015A 35 CALLDATALOAD 015B 90 SWAP1 015C 60 PUSH1 0x20 015E 01 ADD 015F 91 SWAP2 0160 84 DUP5 0161 60 PUSH1 0x01 0163 83 DUP4 0164 02 MUL 0165 84 DUP5 0166 01 ADD 0167 11 GT 0168 60 PUSH1 0x01 016A 60 PUSH1 0x20 016C 1B SHL 016D 83 DUP4 016E 11 GT 016F 17 OR 0170 15 ISZERO 0171 61 PUSH2 0x0179 0174 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @015B stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @015F stack[0] = stack[-2] // @015F stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0179, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0175: // Incoming jump from 0x0174, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0178 memory[0x00:0x00] } 0175 60 PUSH1 0x00 0177 80 DUP1 0178 FD *REVERT // Stack delta = +0 // Outputs[1] { @0178 revert(memory[0x00:0x00]); } // Block terminates label_0179: // Incoming jump from 0x0174, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[4] // { // @017B stack[-2] // @017B stack[-3] // @017C stack[-5] // @017E stack[-4] // } 0179 5B JUMPDEST 017A 50 POP 017B 90 SWAP1 017C 92 SWAP3 017D 50 POP 017E 90 SWAP1 017F 50 POP 0180 61 PUSH2 0x0918 0183 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @017C stack[-5] = stack[-3] // @017E stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x0918 label_0184: // Incoming return from call to 0x03AA at 0x03A5 // Incoming return from call to 0x08F8 at 0x08F3 // Incoming return from call to 0x1080 at 0x0917 // Incoming return from call to 0x0D82 at 0x038B // Incoming return from call to 0x0551 at 0x054C // Incoming return from call to 0x01C0 at 0x01BB // Incoming return from call to 0x08D2 at 0x08CD 0184 5B JUMPDEST 0185 00 *STOP // Stack delta = +0 // Outputs[1] { @0185 stop(); } // Block terminates label_0186: // Incoming jump from 0x00E9, if 0x4dede3de == stack[-1] 0186 5B JUMPDEST 0187 61 PUSH2 0x018e 018A 61 PUSH2 0x0b05 018D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0187 stack[0] = 0x018e } // Block ends with call to 0x0b05, returns to 0x018E label_018E: // Incoming return from call to 0x0E24 at 0x0393 // Incoming return from call to 0x1071 at 0x090F // Incoming return from call to 0x0EF0 at 0x08BB // Incoming return from call to 0x0B05 at 0x018D // Inputs[4] // { // @0192 memory[0x40:0x60] // @019C stack[-1] // @01A0 memory[0x40:0x60] // @01A9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 018E 5B JUMPDEST 018F 60 PUSH1 0x40 0191 80 DUP1 0192 51 MLOAD 0193 60 PUSH1 0x01 0195 60 PUSH1 0x01 0197 60 PUSH1 0xa0 0199 1B SHL 019A 03 SUB 019B 90 SWAP1 019C 92 SWAP3 019D 16 AND 019E 82 DUP3 019F 52 MSTORE 01A0 51 MLOAD 01A1 90 SWAP1 01A2 81 DUP2 01A3 90 SWAP1 01A4 03 SUB 01A5 60 PUSH1 0x20 01A7 01 ADD 01A8 90 SWAP1 01A9 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @019F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @01A9 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_01AA: // Incoming jump from 0x00F4, if 0x57376198 == stack[-1] // Inputs[1] { @01B1 msg.data.length } 01AA 5B JUMPDEST 01AB 61 PUSH2 0x0184 01AE 60 PUSH1 0x04 01B0 80 DUP1 01B1 36 CALLDATASIZE 01B2 03 SUB 01B3 60 PUSH1 0x40 01B5 81 DUP2 01B6 10 LT 01B7 15 ISZERO 01B8 61 PUSH2 0x01c0 01BB 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @01AB stack[0] = 0x0184 // @01AE stack[1] = 0x04 // @01B2 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x01c0, returns to 0x0184, if !(msg.data.length - 0x04 < 0x40) label_01BC: // Incoming jump from 0x01BB, if not !(msg.data.length - 0x04 < 0x40) // 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 call from 0x01BB, returns to 0x0184, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @01CA stack[-2] // @01CB msg.data[stack[-2]:stack[-2] + 0x20] // @01D1 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 01C0 5B JUMPDEST 01C1 50 POP 01C2 60 PUSH1 0x01 01C4 60 PUSH1 0x01 01C6 60 PUSH1 0xa0 01C8 1B SHL 01C9 03 SUB 01CA 81 DUP2 01CB 35 CALLDATALOAD 01CC 16 AND 01CD 90 SWAP1 01CE 60 PUSH1 0x20 01D0 01 ADD 01D1 35 CALLDATALOAD 01D2 61 PUSH2 0x0b14 01D5 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01CD stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @01D1 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0b14 label_01D6: // Incoming jump from 0x00AD, if 0x5bd717a4 == stack[-1] // Inputs[1] { @01DD msg.data.length } 01D6 5B JUMPDEST 01D7 61 PUSH2 0x0184 01DA 60 PUSH1 0x04 01DC 80 DUP1 01DD 36 CALLDATASIZE 01DE 03 SUB 01DF 60 PUSH1 0xa0 01E1 81 DUP2 01E2 10 LT 01E3 15 ISZERO 01E4 61 PUSH2 0x01ec 01E7 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @01D7 stack[0] = 0x0184 // @01DA stack[1] = 0x04 // @01DE stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x01ec, if !(msg.data.length - 0x04 < 0xa0) label_01E8: // Incoming jump from 0x01E7, if not !(msg.data.length - 0x04 < 0xa0) // Inputs[1] { @01EB memory[0x00:0x00] } 01E8 60 PUSH1 0x00 01EA 80 DUP1 01EB FD *REVERT // Stack delta = +0 // Outputs[1] { @01EB revert(memory[0x00:0x00]); } // Block terminates label_01EC: // Incoming jump from 0x01E7, if !(msg.data.length - 0x04 < 0xa0) // Inputs[4] // { // @01ED stack[-2] // @01EE msg.data[stack[-2]:stack[-2] + 0x20] // @01F0 stack[-1] // @01FC msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } 01EC 5B JUMPDEST 01ED 81 DUP2 01EE 35 CALLDATALOAD 01EF 91 SWAP2 01F0 90 SWAP1 01F1 81 DUP2 01F2 01 ADD 01F3 90 SWAP1 01F4 60 PUSH1 0x40 01F6 81 DUP2 01F7 01 ADD 01F8 60 PUSH1 0x20 01FA 82 DUP3 01FB 01 ADD 01FC 35 CALLDATALOAD 01FD 60 PUSH1 0x01 01FF 60 PUSH1 0x20 0201 1B SHL 0202 81 DUP2 0203 11 GT 0204 15 ISZERO 0205 61 PUSH2 0x020d 0208 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @01EF stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @01F3 stack[0] = stack[-2] // @01F3 stack[-1] = stack[-2] + stack[-1] // @01F7 stack[1] = stack[-2] + 0x40 // @01FC stack[2] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x020d, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) label_0209: // Incoming jump from 0x0208, if not !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) // Inputs[1] { @020C memory[0x00:0x00] } 0209 60 PUSH1 0x00 020B 80 DUP1 020C FD *REVERT // Stack delta = +0 // Outputs[1] { @020C revert(memory[0x00:0x00]); } // Block terminates label_020D: // Incoming jump from 0x0208, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @020E stack[-3] // @020F stack[-1] // @0210 stack[-4] // } 020D 5B JUMPDEST 020E 82 DUP3 020F 01 ADD 0210 83 DUP4 0211 60 PUSH1 0x20 0213 82 DUP3 0214 01 ADD 0215 11 GT 0216 15 ISZERO 0217 61 PUSH2 0x021f 021A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @020F stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x021f, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_021B: // Incoming jump from 0x021A, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @021E memory[0x00:0x00] } 021B 60 PUSH1 0x00 021D 80 DUP1 021E FD *REVERT // Stack delta = +0 // Outputs[1] { @021E revert(memory[0x00:0x00]); } // Block terminates label_021F: // Incoming jump from 0x021A, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0220 stack[-1] // @0221 msg.data[stack[-1]:stack[-1] + 0x20] // @0226 stack[-2] // @0227 stack[-4] // } 021F 5B JUMPDEST 0220 80 DUP1 0221 35 CALLDATALOAD 0222 90 SWAP1 0223 60 PUSH1 0x20 0225 01 ADD 0226 91 SWAP2 0227 84 DUP5 0228 60 PUSH1 0x20 022A 83 DUP4 022B 02 MUL 022C 84 DUP5 022D 01 ADD 022E 11 GT 022F 60 PUSH1 0x01 0231 60 PUSH1 0x20 0233 1B SHL 0234 83 DUP4 0235 11 GT 0236 17 OR 0237 15 ISZERO 0238 61 PUSH2 0x0240 023B 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0222 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0226 stack[0] = stack[-2] // @0226 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0240, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_023C: // Incoming jump from 0x023B, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @023F memory[0x00:0x00] } 023C 60 PUSH1 0x00 023E 80 DUP1 023F FD *REVERT // Stack delta = +0 // Outputs[1] { @023F revert(memory[0x00:0x00]); } // Block terminates label_0240: // Incoming jump from 0x023B, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @0241 stack[-1] // @0241 stack[-3] // @0242 stack[-2] // @024D memory[0x40:0x60] // @0267 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0272 stack[-5] // @0273 stack[-4] // @027B msg.data[stack[-1]:stack[-1] + 0x20] // } 0240 5B JUMPDEST 0241 91 SWAP2 0242 90 SWAP1 0243 80 DUP1 0244 80 DUP1 0245 60 PUSH1 0x20 0247 02 MUL 0248 60 PUSH1 0x20 024A 01 ADD 024B 60 PUSH1 0x40 024D 51 MLOAD 024E 90 SWAP1 024F 81 DUP2 0250 01 ADD 0251 60 PUSH1 0x40 0253 52 MSTORE 0254 80 DUP1 0255 93 SWAP4 0256 92 SWAP3 0257 91 SWAP2 0258 90 SWAP1 0259 81 DUP2 025A 81 DUP2 025B 52 MSTORE 025C 60 PUSH1 0x20 025E 01 ADD 025F 83 DUP4 0260 83 DUP4 0261 60 PUSH1 0x20 0263 02 MUL 0264 80 DUP1 0265 82 DUP3 0266 84 DUP5 0267 37 CALLDATACOPY 0268 60 PUSH1 0x00 026A 92 SWAP3 026B 01 ADD 026C 91 SWAP2 026D 90 SWAP1 026E 91 SWAP2 026F 52 MSTORE 0270 50 POP 0271 92 SWAP3 0272 95 SWAP6 0273 94 SWAP5 0274 93 SWAP4 0275 60 PUSH1 0x20 0277 81 DUP2 0278 01 ADD 0279 93 SWAP4 027A 50 POP 027B 35 CALLDATALOAD 027C 91 SWAP2 027D 50 POP 027E 50 POP 027F 60 PUSH1 0x01 0281 60 PUSH1 0x20 0283 1B SHL 0284 81 DUP2 0285 11 GT 0286 15 ISZERO 0287 61 PUSH2 0x028f 028A 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0253 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @025B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0267 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @026F memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @0272 stack[-5] = memory[0x40:0x60] // @0273 stack[-4] = stack[-5] // @0274 stack[-3] = stack[-4] // @0279 stack[-2] = stack[-1] + 0x20 // @027C stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x028f, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_028B: // Incoming jump from 0x028A, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @028E memory[0x00:0x00] } 028B 60 PUSH1 0x00 028D 80 DUP1 028E FD *REVERT // Stack delta = +0 // Outputs[1] { @028E revert(memory[0x00:0x00]); } // Block terminates label_028F: // Incoming jump from 0x028A, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0290 stack[-3] // @0291 stack[-1] // @0292 stack[-4] // } 028F 5B JUMPDEST 0290 82 DUP3 0291 01 ADD 0292 83 DUP4 0293 60 PUSH1 0x20 0295 82 DUP3 0296 01 ADD 0297 11 GT 0298 15 ISZERO 0299 61 PUSH2 0x02a1 029C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0291 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x02a1, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_029D: // Incoming jump from 0x029C, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @02A0 memory[0x00:0x00] } 029D 60 PUSH1 0x00 029F 80 DUP1 02A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @02A0 revert(memory[0x00:0x00]); } // Block terminates label_02A1: // Incoming jump from 0x029C, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @02A2 stack[-1] // @02A3 msg.data[stack[-1]:stack[-1] + 0x20] // @02A8 stack[-2] // @02A9 stack[-4] // } 02A1 5B JUMPDEST 02A2 80 DUP1 02A3 35 CALLDATALOAD 02A4 90 SWAP1 02A5 60 PUSH1 0x20 02A7 01 ADD 02A8 91 SWAP2 02A9 84 DUP5 02AA 60 PUSH1 0x20 02AC 83 DUP4 02AD 02 MUL 02AE 84 DUP5 02AF 01 ADD 02B0 11 GT 02B1 60 PUSH1 0x01 02B3 60 PUSH1 0x20 02B5 1B SHL 02B6 83 DUP4 02B7 11 GT 02B8 17 OR 02B9 15 ISZERO 02BA 61 PUSH2 0x02c2 02BD 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @02A4 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @02A8 stack[0] = stack[-2] // @02A8 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x02c2, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_02BE: // Incoming jump from 0x02BD, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @02C1 memory[0x00:0x00] } 02BE 60 PUSH1 0x00 02C0 80 DUP1 02C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @02C1 revert(memory[0x00:0x00]); } // Block terminates label_02C2: // Incoming jump from 0x02BD, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @02C3 stack[-1] // @02C3 stack[-3] // @02C4 stack[-2] // @02CF memory[0x40:0x60] // @02E9 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @02F4 stack[-5] // @02F5 stack[-4] // @02FD msg.data[stack[-1]:stack[-1] + 0x20] // } 02C2 5B JUMPDEST 02C3 91 SWAP2 02C4 90 SWAP1 02C5 80 DUP1 02C6 80 DUP1 02C7 60 PUSH1 0x20 02C9 02 MUL 02CA 60 PUSH1 0x20 02CC 01 ADD 02CD 60 PUSH1 0x40 02CF 51 MLOAD 02D0 90 SWAP1 02D1 81 DUP2 02D2 01 ADD 02D3 60 PUSH1 0x40 02D5 52 MSTORE 02D6 80 DUP1 02D7 93 SWAP4 02D8 92 SWAP3 02D9 91 SWAP2 02DA 90 SWAP1 02DB 81 DUP2 02DC 81 DUP2 02DD 52 MSTORE 02DE 60 PUSH1 0x20 02E0 01 ADD 02E1 83 DUP4 02E2 83 DUP4 02E3 60 PUSH1 0x20 02E5 02 MUL 02E6 80 DUP1 02E7 82 DUP3 02E8 84 DUP5 02E9 37 CALLDATACOPY 02EA 60 PUSH1 0x00 02EC 92 SWAP3 02ED 01 ADD 02EE 91 SWAP2 02EF 90 SWAP1 02F0 91 SWAP2 02F1 52 MSTORE 02F2 50 POP 02F3 92 SWAP3 02F4 95 SWAP6 02F5 94 SWAP5 02F6 93 SWAP4 02F7 60 PUSH1 0x20 02F9 81 DUP2 02FA 01 ADD 02FB 93 SWAP4 02FC 50 POP 02FD 35 CALLDATALOAD 02FE 91 SWAP2 02FF 50 POP 0300 50 POP 0301 60 PUSH1 0x01 0303 60 PUSH1 0x20 0305 1B SHL 0306 81 DUP2 0307 11 GT 0308 15 ISZERO 0309 61 PUSH2 0x0311 030C 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @02D5 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @02DD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @02E9 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @02F1 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @02F4 stack[-5] = memory[0x40:0x60] // @02F5 stack[-4] = stack[-5] // @02F6 stack[-3] = stack[-4] // @02FB stack[-2] = stack[-1] + 0x20 // @02FE stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0311, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_030D: // Incoming jump from 0x030C, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0310 memory[0x00:0x00] } 030D 60 PUSH1 0x00 030F 80 DUP1 0310 FD *REVERT // Stack delta = +0 // Outputs[1] { @0310 revert(memory[0x00:0x00]); } // Block terminates label_0311: // Incoming jump from 0x030C, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0312 stack[-3] // @0313 stack[-1] // @0314 stack[-4] // } 0311 5B JUMPDEST 0312 82 DUP3 0313 01 ADD 0314 83 DUP4 0315 60 PUSH1 0x20 0317 82 DUP3 0318 01 ADD 0319 11 GT 031A 15 ISZERO 031B 61 PUSH2 0x0323 031E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0313 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0323, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_031F: // Incoming jump from 0x031E, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0322 memory[0x00:0x00] } 031F 60 PUSH1 0x00 0321 80 DUP1 0322 FD *REVERT // Stack delta = +0 // Outputs[1] { @0322 revert(memory[0x00:0x00]); } // Block terminates label_0323: // Incoming jump from 0x031E, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0324 stack[-1] // @0325 msg.data[stack[-1]:stack[-1] + 0x20] // @032A stack[-2] // @032B stack[-4] // } 0323 5B JUMPDEST 0324 80 DUP1 0325 35 CALLDATALOAD 0326 90 SWAP1 0327 60 PUSH1 0x20 0329 01 ADD 032A 91 SWAP2 032B 84 DUP5 032C 60 PUSH1 0x20 032E 83 DUP4 032F 02 MUL 0330 84 DUP5 0331 01 ADD 0332 11 GT 0333 60 PUSH1 0x01 0335 60 PUSH1 0x20 0337 1B SHL 0338 83 DUP4 0339 11 GT 033A 17 OR 033B 15 ISZERO 033C 61 PUSH2 0x0344 033F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0326 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @032A stack[0] = stack[-2] // @032A stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0344, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0340: // Incoming jump from 0x033F, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0343 memory[0x00:0x00] } 0340 60 PUSH1 0x00 0342 80 DUP1 0343 FD *REVERT // Stack delta = +0 // Outputs[1] { @0343 revert(memory[0x00:0x00]); } // Block terminates label_0344: // Incoming jump from 0x033F, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @0345 stack[-1] // @0345 stack[-3] // @0346 stack[-2] // @0351 memory[0x40:0x60] // @036B msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0376 stack[-5] // @037B msg.data[stack[-1]:stack[-1] + 0x20] // @037E stack[-4] // } 0344 5B JUMPDEST 0345 91 SWAP2 0346 90 SWAP1 0347 80 DUP1 0348 80 DUP1 0349 60 PUSH1 0x20 034B 02 MUL 034C 60 PUSH1 0x20 034E 01 ADD 034F 60 PUSH1 0x40 0351 51 MLOAD 0352 90 SWAP1 0353 81 DUP2 0354 01 ADD 0355 60 PUSH1 0x40 0357 52 MSTORE 0358 80 DUP1 0359 93 SWAP4 035A 92 SWAP3 035B 91 SWAP2 035C 90 SWAP1 035D 81 DUP2 035E 81 DUP2 035F 52 MSTORE 0360 60 PUSH1 0x20 0362 01 ADD 0363 83 DUP4 0364 83 DUP4 0365 60 PUSH1 0x20 0367 02 MUL 0368 80 DUP1 0369 82 DUP3 036A 84 DUP5 036B 37 CALLDATACOPY 036C 60 PUSH1 0x00 036E 92 SWAP3 036F 01 ADD 0370 91 SWAP2 0371 90 SWAP1 0372 91 SWAP2 0373 52 MSTORE 0374 50 POP 0375 92 SWAP3 0376 95 SWAP6 0377 50 POP 0378 50 POP 0379 50 POP 037A 50 POP 037B 35 CALLDATALOAD 037C 15 ISZERO 037D 15 ISZERO 037E 90 SWAP1 037F 50 POP 0380 61 PUSH2 0x0bfa 0383 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @0357 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @035F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @036B memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0373 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @0376 stack[-5] = memory[0x40:0x60] // @037E stack[-4] = !!msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x0bfa label_0384: // Incoming jump from 0x00B8, if 0x715018a6 == stack[-1] 0384 5B JUMPDEST 0385 61 PUSH2 0x0184 0388 61 PUSH2 0x0d82 038B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0385 stack[0] = 0x0184 } // Block ends with call to 0x0d82, returns to 0x0184 label_038C: // Incoming jump from 0x00C3, if 0x8da5cb5b == stack[-1] 038C 5B JUMPDEST 038D 61 PUSH2 0x018e 0390 61 PUSH2 0x0e24 0393 56 *JUMP // Stack delta = +1 // Outputs[1] { @038D stack[0] = 0x018e } // Block ends with call to 0x0e24, returns to 0x018E label_0394: // Incoming jump from 0x00CE, if 0x8ed36a4f == stack[-1] // Inputs[1] { @039B msg.data.length } 0394 5B JUMPDEST 0395 61 PUSH2 0x0184 0398 60 PUSH1 0x04 039A 80 DUP1 039B 36 CALLDATASIZE 039C 03 SUB 039D 60 PUSH1 0x80 039F 81 DUP2 03A0 10 LT 03A1 15 ISZERO 03A2 61 PUSH2 0x03aa 03A5 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0395 stack[0] = 0x0184 // @0398 stack[1] = 0x04 // @039C stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03aa, returns to 0x0184, if !(msg.data.length - 0x04 < 0x80) label_03A6: // Incoming jump from 0x03A5, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @03A9 memory[0x00:0x00] } 03A6 60 PUSH1 0x00 03A8 80 DUP1 03A9 FD *REVERT // Stack delta = +0 // Outputs[1] { @03A9 revert(memory[0x00:0x00]); } // Block terminates label_03AA: // Incoming call from 0x03A5, returns to 0x0184, if !(msg.data.length - 0x04 < 0x80) // Inputs[3] // { // @03AB stack[-2] // @03AC stack[-1] // @03B3 msg.data[stack[-2]:stack[-2] + 0x20] // } 03AA 5B JUMPDEST 03AB 81 DUP2 03AC 01 ADD 03AD 90 SWAP1 03AE 60 PUSH1 0x20 03B0 81 DUP2 03B1 01 ADD 03B2 81 DUP2 03B3 35 CALLDATALOAD 03B4 60 PUSH1 0x01 03B6 60 PUSH1 0x20 03B8 1B SHL 03B9 81 DUP2 03BA 11 GT 03BB 15 ISZERO 03BC 61 PUSH2 0x03c4 03BF 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @03AD stack[-1] = stack[-2] // @03AD stack[-2] = stack[-2] + stack[-1] // @03B1 stack[0] = stack[-2] + 0x20 // @03B3 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x03c4, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) label_03C0: // Incoming jump from 0x03BF, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[1] { @03C3 memory[0x00:0x00] } 03C0 60 PUSH1 0x00 03C2 80 DUP1 03C3 FD *REVERT // Stack delta = +0 // Outputs[1] { @03C3 revert(memory[0x00:0x00]); } // Block terminates label_03C4: // Incoming jump from 0x03BF, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @03C5 stack[-3] // @03C6 stack[-1] // @03C7 stack[-4] // } 03C4 5B JUMPDEST 03C5 82 DUP3 03C6 01 ADD 03C7 83 DUP4 03C8 60 PUSH1 0x20 03CA 82 DUP3 03CB 01 ADD 03CC 11 GT 03CD 15 ISZERO 03CE 61 PUSH2 0x03d6 03D1 57 *JUMPI // Stack delta = +0 // Outputs[1] { @03C6 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x03d6, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_03D2: // Incoming jump from 0x03D1, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @03D5 memory[0x00:0x00] } 03D2 60 PUSH1 0x00 03D4 80 DUP1 03D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D5 revert(memory[0x00:0x00]); } // Block terminates label_03D6: // Incoming jump from 0x03D1, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @03D7 stack[-1] // @03D8 msg.data[stack[-1]:stack[-1] + 0x20] // @03DD stack[-2] // @03DE stack[-4] // } 03D6 5B JUMPDEST 03D7 80 DUP1 03D8 35 CALLDATALOAD 03D9 90 SWAP1 03DA 60 PUSH1 0x20 03DC 01 ADD 03DD 91 SWAP2 03DE 84 DUP5 03DF 60 PUSH1 0x20 03E1 83 DUP4 03E2 02 MUL 03E3 84 DUP5 03E4 01 ADD 03E5 11 GT 03E6 60 PUSH1 0x01 03E8 60 PUSH1 0x20 03EA 1B SHL 03EB 83 DUP4 03EC 11 GT 03ED 17 OR 03EE 15 ISZERO 03EF 61 PUSH2 0x03f7 03F2 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @03D9 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @03DD stack[0] = stack[-2] // @03DD stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x03f7, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_03F3: // Incoming jump from 0x03F2, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @03F6 memory[0x00:0x00] } 03F3 60 PUSH1 0x00 03F5 80 DUP1 03F6 FD *REVERT // Stack delta = +0 // Outputs[1] { @03F6 revert(memory[0x00:0x00]); } // Block terminates label_03F7: // Incoming jump from 0x03F2, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @03F8 stack[-3] // @03F8 stack[-1] // @03F9 stack[-2] // @0404 memory[0x40:0x60] // @041E msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0429 stack[-5] // @042A stack[-4] // @0432 msg.data[stack[-1]:stack[-1] + 0x20] // } 03F7 5B JUMPDEST 03F8 91 SWAP2 03F9 90 SWAP1 03FA 80 DUP1 03FB 80 DUP1 03FC 60 PUSH1 0x20 03FE 02 MUL 03FF 60 PUSH1 0x20 0401 01 ADD 0402 60 PUSH1 0x40 0404 51 MLOAD 0405 90 SWAP1 0406 81 DUP2 0407 01 ADD 0408 60 PUSH1 0x40 040A 52 MSTORE 040B 80 DUP1 040C 93 SWAP4 040D 92 SWAP3 040E 91 SWAP2 040F 90 SWAP1 0410 81 DUP2 0411 81 DUP2 0412 52 MSTORE 0413 60 PUSH1 0x20 0415 01 ADD 0416 83 DUP4 0417 83 DUP4 0418 60 PUSH1 0x20 041A 02 MUL 041B 80 DUP1 041C 82 DUP3 041D 84 DUP5 041E 37 CALLDATACOPY 041F 60 PUSH1 0x00 0421 92 SWAP3 0422 01 ADD 0423 91 SWAP2 0424 90 SWAP1 0425 91 SWAP2 0426 52 MSTORE 0427 50 POP 0428 92 SWAP3 0429 95 SWAP6 042A 94 SWAP5 042B 93 SWAP4 042C 60 PUSH1 0x20 042E 81 DUP2 042F 01 ADD 0430 93 SWAP4 0431 50 POP 0432 35 CALLDATALOAD 0433 91 SWAP2 0434 50 POP 0435 50 POP 0436 60 PUSH1 0x01 0438 60 PUSH1 0x20 043A 1B SHL 043B 81 DUP2 043C 11 GT 043D 15 ISZERO 043E 61 PUSH2 0x0446 0441 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @040A memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @0412 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @041E memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0426 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @0429 stack[-5] = memory[0x40:0x60] // @042A stack[-4] = stack[-5] // @042B stack[-3] = stack[-4] // @0430 stack[-2] = stack[-1] + 0x20 // @0433 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0446, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_0442: // Incoming jump from 0x0441, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0445 memory[0x00:0x00] } 0442 60 PUSH1 0x00 0444 80 DUP1 0445 FD *REVERT // Stack delta = +0 // Outputs[1] { @0445 revert(memory[0x00:0x00]); } // Block terminates label_0446: // Incoming jump from 0x0441, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0447 stack[-3] // @0448 stack[-1] // @0449 stack[-4] // } 0446 5B JUMPDEST 0447 82 DUP3 0448 01 ADD 0449 83 DUP4 044A 60 PUSH1 0x20 044C 82 DUP3 044D 01 ADD 044E 11 GT 044F 15 ISZERO 0450 61 PUSH2 0x0458 0453 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0448 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0458, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0454: // Incoming jump from 0x0453, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0457 memory[0x00:0x00] } 0454 60 PUSH1 0x00 0456 80 DUP1 0457 FD *REVERT // Stack delta = +0 // Outputs[1] { @0457 revert(memory[0x00:0x00]); } // Block terminates label_0458: // Incoming jump from 0x0453, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0459 stack[-1] // @045A msg.data[stack[-1]:stack[-1] + 0x20] // @045F stack[-2] // @0460 stack[-4] // } 0458 5B JUMPDEST 0459 80 DUP1 045A 35 CALLDATALOAD 045B 90 SWAP1 045C 60 PUSH1 0x20 045E 01 ADD 045F 91 SWAP2 0460 84 DUP5 0461 60 PUSH1 0x20 0463 83 DUP4 0464 02 MUL 0465 84 DUP5 0466 01 ADD 0467 11 GT 0468 60 PUSH1 0x01 046A 60 PUSH1 0x20 046C 1B SHL 046D 83 DUP4 046E 11 GT 046F 17 OR 0470 15 ISZERO 0471 61 PUSH2 0x0479 0474 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @045B stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @045F stack[0] = stack[-2] // @045F stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0479, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0475: // Incoming jump from 0x0474, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0478 memory[0x00:0x00] } 0475 60 PUSH1 0x00 0477 80 DUP1 0478 FD *REVERT // Stack delta = +0 // Outputs[1] { @0478 revert(memory[0x00:0x00]); } // Block terminates label_0479: // Incoming jump from 0x0474, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @047A stack[-3] // @047A stack[-1] // @047B stack[-2] // @0486 memory[0x40:0x60] // @04A0 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @04AB stack[-5] // @04AC stack[-4] // @04B4 msg.data[stack[-1]:stack[-1] + 0x20] // } 0479 5B JUMPDEST 047A 91 SWAP2 047B 90 SWAP1 047C 80 DUP1 047D 80 DUP1 047E 60 PUSH1 0x20 0480 02 MUL 0481 60 PUSH1 0x20 0483 01 ADD 0484 60 PUSH1 0x40 0486 51 MLOAD 0487 90 SWAP1 0488 81 DUP2 0489 01 ADD 048A 60 PUSH1 0x40 048C 52 MSTORE 048D 80 DUP1 048E 93 SWAP4 048F 92 SWAP3 0490 91 SWAP2 0491 90 SWAP1 0492 81 DUP2 0493 81 DUP2 0494 52 MSTORE 0495 60 PUSH1 0x20 0497 01 ADD 0498 83 DUP4 0499 83 DUP4 049A 60 PUSH1 0x20 049C 02 MUL 049D 80 DUP1 049E 82 DUP3 049F 84 DUP5 04A0 37 CALLDATACOPY 04A1 60 PUSH1 0x00 04A3 92 SWAP3 04A4 01 ADD 04A5 91 SWAP2 04A6 90 SWAP1 04A7 91 SWAP2 04A8 52 MSTORE 04A9 50 POP 04AA 92 SWAP3 04AB 95 SWAP6 04AC 94 SWAP5 04AD 93 SWAP4 04AE 60 PUSH1 0x20 04B0 81 DUP2 04B1 01 ADD 04B2 93 SWAP4 04B3 50 POP 04B4 35 CALLDATALOAD 04B5 91 SWAP2 04B6 50 POP 04B7 50 POP 04B8 60 PUSH1 0x01 04BA 60 PUSH1 0x20 04BC 1B SHL 04BD 81 DUP2 04BE 11 GT 04BF 15 ISZERO 04C0 61 PUSH2 0x04c8 04C3 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @048C memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @0494 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @04A0 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @04A8 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @04AB stack[-5] = memory[0x40:0x60] // @04AC stack[-4] = stack[-5] // @04AD stack[-3] = stack[-4] // @04B2 stack[-2] = stack[-1] + 0x20 // @04B5 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x04c8, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_04C4: // Incoming jump from 0x04C3, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @04C7 memory[0x00:0x00] } 04C4 60 PUSH1 0x00 04C6 80 DUP1 04C7 FD *REVERT // Stack delta = +0 // Outputs[1] { @04C7 revert(memory[0x00:0x00]); } // Block terminates label_04C8: // Incoming jump from 0x04C3, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @04C9 stack[-3] // @04CA stack[-1] // @04CB stack[-4] // } 04C8 5B JUMPDEST 04C9 82 DUP3 04CA 01 ADD 04CB 83 DUP4 04CC 60 PUSH1 0x20 04CE 82 DUP3 04CF 01 ADD 04D0 11 GT 04D1 15 ISZERO 04D2 61 PUSH2 0x04da 04D5 57 *JUMPI // Stack delta = +0 // Outputs[1] { @04CA stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x04da, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_04D6: // Incoming jump from 0x04D5, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @04D9 memory[0x00:0x00] } 04D6 60 PUSH1 0x00 04D8 80 DUP1 04D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D9 revert(memory[0x00:0x00]); } // Block terminates label_04DA: // Incoming jump from 0x04D5, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @04DB stack[-1] // @04DC msg.data[stack[-1]:stack[-1] + 0x20] // @04E1 stack[-2] // @04E2 stack[-4] // } 04DA 5B JUMPDEST 04DB 80 DUP1 04DC 35 CALLDATALOAD 04DD 90 SWAP1 04DE 60 PUSH1 0x20 04E0 01 ADD 04E1 91 SWAP2 04E2 84 DUP5 04E3 60 PUSH1 0x20 04E5 83 DUP4 04E6 02 MUL 04E7 84 DUP5 04E8 01 ADD 04E9 11 GT 04EA 60 PUSH1 0x01 04EC 60 PUSH1 0x20 04EE 1B SHL 04EF 83 DUP4 04F0 11 GT 04F1 17 OR 04F2 15 ISZERO 04F3 61 PUSH2 0x04fb 04F6 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @04DD stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @04E1 stack[0] = stack[-2] // @04E1 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x04fb, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_04F7: // Incoming jump from 0x04F6, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @04FA memory[0x00:0x00] } 04F7 60 PUSH1 0x00 04F9 80 DUP1 04FA FD *REVERT // Stack delta = +0 // Outputs[1] { @04FA revert(memory[0x00:0x00]); } // Block terminates label_04FB: // Incoming jump from 0x04F6, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @04FC stack[-3] // @04FC stack[-1] // @04FD stack[-2] // @0508 memory[0x40:0x60] // @0522 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @052D stack[-5] // @0532 msg.data[stack[-1]:stack[-1] + 0x20] // @0535 stack[-4] // } 04FB 5B JUMPDEST 04FC 91 SWAP2 04FD 90 SWAP1 04FE 80 DUP1 04FF 80 DUP1 0500 60 PUSH1 0x20 0502 02 MUL 0503 60 PUSH1 0x20 0505 01 ADD 0506 60 PUSH1 0x40 0508 51 MLOAD 0509 90 SWAP1 050A 81 DUP2 050B 01 ADD 050C 60 PUSH1 0x40 050E 52 MSTORE 050F 80 DUP1 0510 93 SWAP4 0511 92 SWAP3 0512 91 SWAP2 0513 90 SWAP1 0514 81 DUP2 0515 81 DUP2 0516 52 MSTORE 0517 60 PUSH1 0x20 0519 01 ADD 051A 83 DUP4 051B 83 DUP4 051C 60 PUSH1 0x20 051E 02 MUL 051F 80 DUP1 0520 82 DUP3 0521 84 DUP5 0522 37 CALLDATACOPY 0523 60 PUSH1 0x00 0525 92 SWAP3 0526 01 ADD 0527 91 SWAP2 0528 90 SWAP1 0529 91 SWAP2 052A 52 MSTORE 052B 50 POP 052C 92 SWAP3 052D 95 SWAP6 052E 50 POP 052F 50 POP 0530 50 POP 0531 50 POP 0532 35 CALLDATALOAD 0533 15 ISZERO 0534 15 ISZERO 0535 90 SWAP1 0536 50 POP 0537 61 PUSH2 0x0e33 053A 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @050E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @0516 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0522 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @052A memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @052D stack[-5] = memory[0x40:0x60] // @0535 stack[-4] = !!msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x0e33 label_053B: // Incoming jump from 0x0071, if 0x9e252f00 == stack[-1] // Inputs[1] { @0542 msg.data.length } 053B 5B JUMPDEST 053C 61 PUSH2 0x0184 053F 60 PUSH1 0x04 0541 80 DUP1 0542 36 CALLDATASIZE 0543 03 SUB 0544 60 PUSH1 0x20 0546 81 DUP2 0547 10 LT 0548 15 ISZERO 0549 61 PUSH2 0x0551 054C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @053C stack[0] = 0x0184 // @053F stack[1] = 0x04 // @0543 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0551, returns to 0x0184, if !(msg.data.length - 0x04 < 0x20) label_054D: // Incoming jump from 0x054C, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0550 memory[0x00:0x00] } 054D 60 PUSH1 0x00 054F 80 DUP1 0550 FD *REVERT // Stack delta = +0 // Outputs[1] { @0550 revert(memory[0x00:0x00]); } // Block terminates label_0551: // Incoming call from 0x054C, returns to 0x0184, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0553 stack[-2] // @0553 msg.data[stack[-2]:stack[-2] + 0x20] // } 0551 5B JUMPDEST 0552 50 POP 0553 35 CALLDATALOAD 0554 61 PUSH2 0x0ea0 0557 56 *JUMP // Stack delta = -1 // Outputs[1] { @0553 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0ea0 label_0558: // Incoming jump from 0x007C, if 0xc0c06fef == stack[-1] // Inputs[1] { @055F msg.data.length } 0558 5B JUMPDEST 0559 61 PUSH2 0x06fd 055C 60 PUSH1 0x04 055E 80 DUP1 055F 36 CALLDATASIZE 0560 03 SUB 0561 60 PUSH1 0x60 0563 81 DUP2 0564 10 LT 0565 15 ISZERO 0566 61 PUSH2 0x056e 0569 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0559 stack[0] = 0x06fd // @055C stack[1] = 0x04 // @0560 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x056e, returns to 0x06FD, if !(msg.data.length - 0x04 < 0x60) label_056A: // Incoming jump from 0x0569, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @056D memory[0x00:0x00] } 056A 60 PUSH1 0x00 056C 80 DUP1 056D FD *REVERT // Stack delta = +0 // Outputs[1] { @056D revert(memory[0x00:0x00]); } // Block terminates label_056E: // Incoming call from 0x0569, returns to 0x06FD, if !(msg.data.length - 0x04 < 0x60) // Inputs[3] // { // @056F stack[-2] // @0570 stack[-1] // @0577 msg.data[stack[-2]:stack[-2] + 0x20] // } 056E 5B JUMPDEST 056F 81 DUP2 0570 01 ADD 0571 90 SWAP1 0572 60 PUSH1 0x20 0574 81 DUP2 0575 01 ADD 0576 81 DUP2 0577 35 CALLDATALOAD 0578 60 PUSH1 0x01 057A 60 PUSH1 0x20 057C 1B SHL 057D 81 DUP2 057E 11 GT 057F 15 ISZERO 0580 61 PUSH2 0x0588 0583 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0571 stack[-1] = stack[-2] // @0571 stack[-2] = stack[-2] + stack[-1] // @0575 stack[0] = stack[-2] + 0x20 // @0577 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x0588, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) label_0584: // Incoming jump from 0x0583, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0587 memory[0x00:0x00] } 0584 60 PUSH1 0x00 0586 80 DUP1 0587 FD *REVERT // Stack delta = +0 // Outputs[1] { @0587 revert(memory[0x00:0x00]); } // Block terminates label_0588: // Incoming jump from 0x0583, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0589 stack[-3] // @058A stack[-1] // @058B stack[-4] // } 0588 5B JUMPDEST 0589 82 DUP3 058A 01 ADD 058B 83 DUP4 058C 60 PUSH1 0x20 058E 82 DUP3 058F 01 ADD 0590 11 GT 0591 15 ISZERO 0592 61 PUSH2 0x059a 0595 57 *JUMPI // Stack delta = +0 // Outputs[1] { @058A stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x059a, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0596: // Incoming jump from 0x0595, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0599 memory[0x00:0x00] } 0596 60 PUSH1 0x00 0598 80 DUP1 0599 FD *REVERT // Stack delta = +0 // Outputs[1] { @0599 revert(memory[0x00:0x00]); } // Block terminates label_059A: // Incoming jump from 0x0595, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @059B stack[-1] // @059C msg.data[stack[-1]:stack[-1] + 0x20] // @05A1 stack[-2] // @05A2 stack[-4] // } 059A 5B JUMPDEST 059B 80 DUP1 059C 35 CALLDATALOAD 059D 90 SWAP1 059E 60 PUSH1 0x20 05A0 01 ADD 05A1 91 SWAP2 05A2 84 DUP5 05A3 60 PUSH1 0x20 05A5 83 DUP4 05A6 02 MUL 05A7 84 DUP5 05A8 01 ADD 05A9 11 GT 05AA 60 PUSH1 0x01 05AC 60 PUSH1 0x20 05AE 1B SHL 05AF 83 DUP4 05B0 11 GT 05B1 17 OR 05B2 15 ISZERO 05B3 61 PUSH2 0x05bb 05B6 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @059D stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @05A1 stack[0] = stack[-2] // @05A1 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x05bb, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_05B7: // Incoming jump from 0x05B6, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @05BA memory[0x00:0x00] } 05B7 60 PUSH1 0x00 05B9 80 DUP1 05BA FD *REVERT // Stack delta = +0 // Outputs[1] { @05BA revert(memory[0x00:0x00]); } // Block terminates label_05BB: // Incoming jump from 0x05B6, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @05BC stack[-1] // @05BC stack[-3] // @05BD stack[-2] // @05C8 memory[0x40:0x60] // @05E2 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @05ED stack[-5] // @05EE stack[-4] // @05F6 msg.data[stack[-1]:stack[-1] + 0x20] // } 05BB 5B JUMPDEST 05BC 91 SWAP2 05BD 90 SWAP1 05BE 80 DUP1 05BF 80 DUP1 05C0 60 PUSH1 0x20 05C2 02 MUL 05C3 60 PUSH1 0x20 05C5 01 ADD 05C6 60 PUSH1 0x40 05C8 51 MLOAD 05C9 90 SWAP1 05CA 81 DUP2 05CB 01 ADD 05CC 60 PUSH1 0x40 05CE 52 MSTORE 05CF 80 DUP1 05D0 93 SWAP4 05D1 92 SWAP3 05D2 91 SWAP2 05D3 90 SWAP1 05D4 81 DUP2 05D5 81 DUP2 05D6 52 MSTORE 05D7 60 PUSH1 0x20 05D9 01 ADD 05DA 83 DUP4 05DB 83 DUP4 05DC 60 PUSH1 0x20 05DE 02 MUL 05DF 80 DUP1 05E0 82 DUP3 05E1 84 DUP5 05E2 37 CALLDATACOPY 05E3 60 PUSH1 0x00 05E5 92 SWAP3 05E6 01 ADD 05E7 91 SWAP2 05E8 90 SWAP1 05E9 91 SWAP2 05EA 52 MSTORE 05EB 50 POP 05EC 92 SWAP3 05ED 95 SWAP6 05EE 94 SWAP5 05EF 93 SWAP4 05F0 60 PUSH1 0x20 05F2 81 DUP2 05F3 01 ADD 05F4 93 SWAP4 05F5 50 POP 05F6 35 CALLDATALOAD 05F7 91 SWAP2 05F8 50 POP 05F9 50 POP 05FA 60 PUSH1 0x01 05FC 60 PUSH1 0x20 05FE 1B SHL 05FF 81 DUP2 0600 11 GT 0601 15 ISZERO 0602 61 PUSH2 0x060a 0605 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @05CE memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @05D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @05E2 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @05EA memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @05ED stack[-5] = memory[0x40:0x60] // @05EE stack[-4] = stack[-5] // @05EF stack[-3] = stack[-4] // @05F4 stack[-2] = stack[-1] + 0x20 // @05F7 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x060a, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_0606: // Incoming jump from 0x0605, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0609 memory[0x00:0x00] } 0606 60 PUSH1 0x00 0608 80 DUP1 0609 FD *REVERT // Stack delta = +0 // Outputs[1] { @0609 revert(memory[0x00:0x00]); } // Block terminates label_060A: // Incoming jump from 0x0605, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @060B stack[-3] // @060C stack[-1] // @060D stack[-4] // } 060A 5B JUMPDEST 060B 82 DUP3 060C 01 ADD 060D 83 DUP4 060E 60 PUSH1 0x20 0610 82 DUP3 0611 01 ADD 0612 11 GT 0613 15 ISZERO 0614 61 PUSH2 0x061c 0617 57 *JUMPI // Stack delta = +0 // Outputs[1] { @060C stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x061c, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0618: // Incoming jump from 0x0617, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @061B memory[0x00:0x00] } 0618 60 PUSH1 0x00 061A 80 DUP1 061B FD *REVERT // Stack delta = +0 // Outputs[1] { @061B revert(memory[0x00:0x00]); } // Block terminates label_061C: // Incoming jump from 0x0617, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @061D stack[-1] // @061E msg.data[stack[-1]:stack[-1] + 0x20] // @0623 stack[-2] // @0624 stack[-4] // } 061C 5B JUMPDEST 061D 80 DUP1 061E 35 CALLDATALOAD 061F 90 SWAP1 0620 60 PUSH1 0x20 0622 01 ADD 0623 91 SWAP2 0624 84 DUP5 0625 60 PUSH1 0x20 0627 83 DUP4 0628 02 MUL 0629 84 DUP5 062A 01 ADD 062B 11 GT 062C 60 PUSH1 0x01 062E 60 PUSH1 0x20 0630 1B SHL 0631 83 DUP4 0632 11 GT 0633 17 OR 0634 15 ISZERO 0635 61 PUSH2 0x063d 0638 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @061F stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0623 stack[0] = stack[-2] // @0623 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x063d, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0639: // Incoming jump from 0x0638, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @063C memory[0x00:0x00] } 0639 60 PUSH1 0x00 063B 80 DUP1 063C FD *REVERT // Stack delta = +0 // Outputs[1] { @063C revert(memory[0x00:0x00]); } // Block terminates label_063D: // Incoming jump from 0x0638, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @063E stack[-3] // @063E stack[-1] // @063F stack[-2] // @064A memory[0x40:0x60] // @0664 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @066F stack[-5] // @0670 stack[-4] // @0678 msg.data[stack[-1]:stack[-1] + 0x20] // } 063D 5B JUMPDEST 063E 91 SWAP2 063F 90 SWAP1 0640 80 DUP1 0641 80 DUP1 0642 60 PUSH1 0x20 0644 02 MUL 0645 60 PUSH1 0x20 0647 01 ADD 0648 60 PUSH1 0x40 064A 51 MLOAD 064B 90 SWAP1 064C 81 DUP2 064D 01 ADD 064E 60 PUSH1 0x40 0650 52 MSTORE 0651 80 DUP1 0652 93 SWAP4 0653 92 SWAP3 0654 91 SWAP2 0655 90 SWAP1 0656 81 DUP2 0657 81 DUP2 0658 52 MSTORE 0659 60 PUSH1 0x20 065B 01 ADD 065C 83 DUP4 065D 83 DUP4 065E 60 PUSH1 0x20 0660 02 MUL 0661 80 DUP1 0662 82 DUP3 0663 84 DUP5 0664 37 CALLDATACOPY 0665 60 PUSH1 0x00 0667 92 SWAP3 0668 01 ADD 0669 91 SWAP2 066A 90 SWAP1 066B 91 SWAP2 066C 52 MSTORE 066D 50 POP 066E 92 SWAP3 066F 95 SWAP6 0670 94 SWAP5 0671 93 SWAP4 0672 60 PUSH1 0x20 0674 81 DUP2 0675 01 ADD 0676 93 SWAP4 0677 50 POP 0678 35 CALLDATALOAD 0679 91 SWAP2 067A 50 POP 067B 50 POP 067C 60 PUSH1 0x01 067E 60 PUSH1 0x20 0680 1B SHL 0681 81 DUP2 0682 11 GT 0683 15 ISZERO 0684 61 PUSH2 0x068c 0687 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0650 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @0658 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0664 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @066C memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @066F stack[-5] = memory[0x40:0x60] // @0670 stack[-4] = stack[-5] // @0671 stack[-3] = stack[-4] // @0676 stack[-2] = stack[-1] + 0x20 // @0679 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x068c, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_0688: // Incoming jump from 0x0687, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @068B memory[0x00:0x00] } 0688 60 PUSH1 0x00 068A 80 DUP1 068B FD *REVERT // Stack delta = +0 // Outputs[1] { @068B revert(memory[0x00:0x00]); } // Block terminates label_068C: // Incoming jump from 0x0687, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @068D stack[-3] // @068E stack[-1] // @068F stack[-4] // } 068C 5B JUMPDEST 068D 82 DUP3 068E 01 ADD 068F 83 DUP4 0690 60 PUSH1 0x20 0692 82 DUP3 0693 01 ADD 0694 11 GT 0695 15 ISZERO 0696 61 PUSH2 0x069e 0699 57 *JUMPI // Stack delta = +0 // Outputs[1] { @068E stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x069e, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_069A: // Incoming jump from 0x0699, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @069D memory[0x00:0x00] } 069A 60 PUSH1 0x00 069C 80 DUP1 069D FD *REVERT // Stack delta = +0 // Outputs[1] { @069D revert(memory[0x00:0x00]); } // Block terminates label_069E: // Incoming jump from 0x0699, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @069F stack[-1] // @06A0 msg.data[stack[-1]:stack[-1] + 0x20] // @06A5 stack[-2] // @06A6 stack[-4] // } 069E 5B JUMPDEST 069F 80 DUP1 06A0 35 CALLDATALOAD 06A1 90 SWAP1 06A2 60 PUSH1 0x20 06A4 01 ADD 06A5 91 SWAP2 06A6 84 DUP5 06A7 60 PUSH1 0x20 06A9 83 DUP4 06AA 02 MUL 06AB 84 DUP5 06AC 01 ADD 06AD 11 GT 06AE 60 PUSH1 0x01 06B0 60 PUSH1 0x20 06B2 1B SHL 06B3 83 DUP4 06B4 11 GT 06B5 17 OR 06B6 15 ISZERO 06B7 61 PUSH2 0x06bf 06BA 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @06A1 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @06A5 stack[0] = stack[-2] // @06A5 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x06bf, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_06BB: // Incoming jump from 0x06BA, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @06BE memory[0x00:0x00] } 06BB 60 PUSH1 0x00 06BD 80 DUP1 06BE FD *REVERT // Stack delta = +0 // Outputs[1] { @06BE revert(memory[0x00:0x00]); } // Block terminates label_06BF: // Incoming jump from 0x06BA, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[7] // { // @06C0 stack[-1] // @06C0 stack[-3] // @06C1 stack[-2] // @06CC memory[0x40:0x60] // @06E6 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @06F1 stack[-5] // @06F6 stack[-4] // } 06BF 5B JUMPDEST 06C0 91 SWAP2 06C1 90 SWAP1 06C2 80 DUP1 06C3 80 DUP1 06C4 60 PUSH1 0x20 06C6 02 MUL 06C7 60 PUSH1 0x20 06C9 01 ADD 06CA 60 PUSH1 0x40 06CC 51 MLOAD 06CD 90 SWAP1 06CE 81 DUP2 06CF 01 ADD 06D0 60 PUSH1 0x40 06D2 52 MSTORE 06D3 80 DUP1 06D4 93 SWAP4 06D5 92 SWAP3 06D6 91 SWAP2 06D7 90 SWAP1 06D8 81 DUP2 06D9 81 DUP2 06DA 52 MSTORE 06DB 60 PUSH1 0x20 06DD 01 ADD 06DE 83 DUP4 06DF 83 DUP4 06E0 60 PUSH1 0x20 06E2 02 MUL 06E3 80 DUP1 06E4 82 DUP3 06E5 84 DUP5 06E6 37 CALLDATACOPY 06E7 60 PUSH1 0x00 06E9 92 SWAP3 06EA 01 ADD 06EB 91 SWAP2 06EC 90 SWAP1 06ED 91 SWAP2 06EE 52 MSTORE 06EF 50 POP 06F0 92 SWAP3 06F1 95 SWAP6 06F2 50 POP 06F3 61 PUSH2 0x0ec1 06F6 94 SWAP5 06F7 50 POP 06F8 50 POP 06F9 50 POP 06FA 50 POP 06FB 50 POP 06FC 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @06D2 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @06DA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @06E6 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @06EE memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @06F1 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0ec1 label_06FD: // Incoming return from call to 0x056E at 0x0569 // Incoming return from call to 0x0725 at 0x0720 // Inputs[4] // { // @0701 memory[0x40:0x60] // @0702 stack[-1] // @0705 memory[0x40:0x60] // @070E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 06FD 5B JUMPDEST 06FE 60 PUSH1 0x40 0700 80 DUP1 0701 51 MLOAD 0702 91 SWAP2 0703 82 DUP3 0704 52 MSTORE 0705 51 MLOAD 0706 90 SWAP1 0707 81 DUP2 0708 90 SWAP1 0709 03 SUB 070A 60 PUSH1 0x20 070C 01 ADD 070D 90 SWAP1 070E F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0704 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @070E return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_070F: // Incoming jump from 0x0087, if 0xc90cc44d == stack[-1] // Inputs[1] { @0716 msg.data.length } 070F 5B JUMPDEST 0710 61 PUSH2 0x06fd 0713 60 PUSH1 0x04 0715 80 DUP1 0716 36 CALLDATASIZE 0717 03 SUB 0718 60 PUSH1 0x60 071A 81 DUP2 071B 10 LT 071C 15 ISZERO 071D 61 PUSH2 0x0725 0720 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0710 stack[0] = 0x06fd // @0713 stack[1] = 0x04 // @0717 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0725, returns to 0x06FD, if !(msg.data.length - 0x04 < 0x60) label_0721: // Incoming jump from 0x0720, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0724 memory[0x00:0x00] } 0721 60 PUSH1 0x00 0723 80 DUP1 0724 FD *REVERT // Stack delta = +0 // Outputs[1] { @0724 revert(memory[0x00:0x00]); } // Block terminates label_0725: // Incoming call from 0x0720, returns to 0x06FD, if !(msg.data.length - 0x04 < 0x60) // Inputs[3] // { // @0726 stack[-2] // @0727 stack[-1] // @072E msg.data[stack[-2]:stack[-2] + 0x20] // } 0725 5B JUMPDEST 0726 81 DUP2 0727 01 ADD 0728 90 SWAP1 0729 60 PUSH1 0x20 072B 81 DUP2 072C 01 ADD 072D 81 DUP2 072E 35 CALLDATALOAD 072F 60 PUSH1 0x01 0731 60 PUSH1 0x20 0733 1B SHL 0734 81 DUP2 0735 11 GT 0736 15 ISZERO 0737 61 PUSH2 0x073f 073A 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0728 stack[-1] = stack[-2] // @0728 stack[-2] = stack[-2] + stack[-1] // @072C stack[0] = stack[-2] + 0x20 // @072E stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x073f, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) label_073B: // Incoming jump from 0x073A, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[1] { @073E memory[0x00:0x00] } 073B 60 PUSH1 0x00 073D 80 DUP1 073E FD *REVERT // Stack delta = +0 // Outputs[1] { @073E revert(memory[0x00:0x00]); } // Block terminates label_073F: // Incoming jump from 0x073A, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0740 stack[-3] // @0741 stack[-1] // @0742 stack[-4] // } 073F 5B JUMPDEST 0740 82 DUP3 0741 01 ADD 0742 83 DUP4 0743 60 PUSH1 0x20 0745 82 DUP3 0746 01 ADD 0747 11 GT 0748 15 ISZERO 0749 61 PUSH2 0x0751 074C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0741 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0751, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_074D: // Incoming jump from 0x074C, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0750 memory[0x00:0x00] } 074D 60 PUSH1 0x00 074F 80 DUP1 0750 FD *REVERT // Stack delta = +0 // Outputs[1] { @0750 revert(memory[0x00:0x00]); } // Block terminates label_0751: // Incoming jump from 0x074C, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0752 stack[-1] // @0753 msg.data[stack[-1]:stack[-1] + 0x20] // @0758 stack[-2] // @0759 stack[-4] // } 0751 5B JUMPDEST 0752 80 DUP1 0753 35 CALLDATALOAD 0754 90 SWAP1 0755 60 PUSH1 0x20 0757 01 ADD 0758 91 SWAP2 0759 84 DUP5 075A 60 PUSH1 0x20 075C 83 DUP4 075D 02 MUL 075E 84 DUP5 075F 01 ADD 0760 11 GT 0761 60 PUSH1 0x01 0763 60 PUSH1 0x20 0765 1B SHL 0766 83 DUP4 0767 11 GT 0768 17 OR 0769 15 ISZERO 076A 61 PUSH2 0x0772 076D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0754 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0758 stack[0] = stack[-2] // @0758 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0772, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_076E: // Incoming jump from 0x076D, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0771 memory[0x00:0x00] } 076E 60 PUSH1 0x00 0770 80 DUP1 0771 FD *REVERT // Stack delta = +0 // Outputs[1] { @0771 revert(memory[0x00:0x00]); } // Block terminates label_0772: // Incoming jump from 0x076D, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @0773 stack[-1] // @0773 stack[-3] // @0774 stack[-2] // @077F memory[0x40:0x60] // @0799 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @07A4 stack[-5] // @07A5 stack[-4] // @07AD msg.data[stack[-1]:stack[-1] + 0x20] // } 0772 5B JUMPDEST 0773 91 SWAP2 0774 90 SWAP1 0775 80 DUP1 0776 80 DUP1 0777 60 PUSH1 0x20 0779 02 MUL 077A 60 PUSH1 0x20 077C 01 ADD 077D 60 PUSH1 0x40 077F 51 MLOAD 0780 90 SWAP1 0781 81 DUP2 0782 01 ADD 0783 60 PUSH1 0x40 0785 52 MSTORE 0786 80 DUP1 0787 93 SWAP4 0788 92 SWAP3 0789 91 SWAP2 078A 90 SWAP1 078B 81 DUP2 078C 81 DUP2 078D 52 MSTORE 078E 60 PUSH1 0x20 0790 01 ADD 0791 83 DUP4 0792 83 DUP4 0793 60 PUSH1 0x20 0795 02 MUL 0796 80 DUP1 0797 82 DUP3 0798 84 DUP5 0799 37 CALLDATACOPY 079A 60 PUSH1 0x00 079C 92 SWAP3 079D 01 ADD 079E 91 SWAP2 079F 90 SWAP1 07A0 91 SWAP2 07A1 52 MSTORE 07A2 50 POP 07A3 92 SWAP3 07A4 95 SWAP6 07A5 94 SWAP5 07A6 93 SWAP4 07A7 60 PUSH1 0x20 07A9 81 DUP2 07AA 01 ADD 07AB 93 SWAP4 07AC 50 POP 07AD 35 CALLDATALOAD 07AE 91 SWAP2 07AF 50 POP 07B0 50 POP 07B1 60 PUSH1 0x01 07B3 60 PUSH1 0x20 07B5 1B SHL 07B6 81 DUP2 07B7 11 GT 07B8 15 ISZERO 07B9 61 PUSH2 0x07c1 07BC 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0785 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @078D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0799 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @07A1 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @07A4 stack[-5] = memory[0x40:0x60] // @07A5 stack[-4] = stack[-5] // @07A6 stack[-3] = stack[-4] // @07AB stack[-2] = stack[-1] + 0x20 // @07AE stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x07c1, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_07BD: // Incoming jump from 0x07BC, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @07C0 memory[0x00:0x00] } 07BD 60 PUSH1 0x00 07BF 80 DUP1 07C0 FD *REVERT // Stack delta = +0 // Outputs[1] { @07C0 revert(memory[0x00:0x00]); } // Block terminates label_07C1: // Incoming jump from 0x07BC, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @07C2 stack[-3] // @07C3 stack[-1] // @07C4 stack[-4] // } 07C1 5B JUMPDEST 07C2 82 DUP3 07C3 01 ADD 07C4 83 DUP4 07C5 60 PUSH1 0x20 07C7 82 DUP3 07C8 01 ADD 07C9 11 GT 07CA 15 ISZERO 07CB 61 PUSH2 0x07d3 07CE 57 *JUMPI // Stack delta = +0 // Outputs[1] { @07C3 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x07d3, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_07CF: // Incoming jump from 0x07CE, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @07D2 memory[0x00:0x00] } 07CF 60 PUSH1 0x00 07D1 80 DUP1 07D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @07D2 revert(memory[0x00:0x00]); } // Block terminates label_07D3: // Incoming jump from 0x07CE, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @07D4 stack[-1] // @07D5 msg.data[stack[-1]:stack[-1] + 0x20] // @07DA stack[-2] // @07DB stack[-4] // } 07D3 5B JUMPDEST 07D4 80 DUP1 07D5 35 CALLDATALOAD 07D6 90 SWAP1 07D7 60 PUSH1 0x20 07D9 01 ADD 07DA 91 SWAP2 07DB 84 DUP5 07DC 60 PUSH1 0x20 07DE 83 DUP4 07DF 02 MUL 07E0 84 DUP5 07E1 01 ADD 07E2 11 GT 07E3 60 PUSH1 0x01 07E5 60 PUSH1 0x20 07E7 1B SHL 07E8 83 DUP4 07E9 11 GT 07EA 17 OR 07EB 15 ISZERO 07EC 61 PUSH2 0x07f4 07EF 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @07D6 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @07DA stack[0] = stack[-2] // @07DA stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x07f4, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_07F0: // Incoming jump from 0x07EF, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @07F3 memory[0x00:0x00] } 07F0 60 PUSH1 0x00 07F2 80 DUP1 07F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @07F3 revert(memory[0x00:0x00]); } // Block terminates label_07F4: // Incoming jump from 0x07EF, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @07F5 stack[-1] // @07F5 stack[-3] // @07F6 stack[-2] // @0801 memory[0x40:0x60] // @081B msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0826 stack[-5] // @0827 stack[-4] // @082F msg.data[stack[-1]:stack[-1] + 0x20] // } 07F4 5B JUMPDEST 07F5 91 SWAP2 07F6 90 SWAP1 07F7 80 DUP1 07F8 80 DUP1 07F9 60 PUSH1 0x20 07FB 02 MUL 07FC 60 PUSH1 0x20 07FE 01 ADD 07FF 60 PUSH1 0x40 0801 51 MLOAD 0802 90 SWAP1 0803 81 DUP2 0804 01 ADD 0805 60 PUSH1 0x40 0807 52 MSTORE 0808 80 DUP1 0809 93 SWAP4 080A 92 SWAP3 080B 91 SWAP2 080C 90 SWAP1 080D 81 DUP2 080E 81 DUP2 080F 52 MSTORE 0810 60 PUSH1 0x20 0812 01 ADD 0813 83 DUP4 0814 83 DUP4 0815 60 PUSH1 0x20 0817 02 MUL 0818 80 DUP1 0819 82 DUP3 081A 84 DUP5 081B 37 CALLDATACOPY 081C 60 PUSH1 0x00 081E 92 SWAP3 081F 01 ADD 0820 91 SWAP2 0821 90 SWAP1 0822 91 SWAP2 0823 52 MSTORE 0824 50 POP 0825 92 SWAP3 0826 95 SWAP6 0827 94 SWAP5 0828 93 SWAP4 0829 60 PUSH1 0x20 082B 81 DUP2 082C 01 ADD 082D 93 SWAP4 082E 50 POP 082F 35 CALLDATALOAD 0830 91 SWAP2 0831 50 POP 0832 50 POP 0833 60 PUSH1 0x01 0835 60 PUSH1 0x20 0837 1B SHL 0838 81 DUP2 0839 11 GT 083A 15 ISZERO 083B 61 PUSH2 0x0843 083E 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0807 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @080F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @081B memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0823 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @0826 stack[-5] = memory[0x40:0x60] // @0827 stack[-4] = stack[-5] // @0828 stack[-3] = stack[-4] // @082D stack[-2] = stack[-1] + 0x20 // @0830 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0843, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_083F: // Incoming jump from 0x083E, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0842 memory[0x00:0x00] } 083F 60 PUSH1 0x00 0841 80 DUP1 0842 FD *REVERT // Stack delta = +0 // Outputs[1] { @0842 revert(memory[0x00:0x00]); } // Block terminates label_0843: // Incoming jump from 0x083E, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0844 stack[-3] // @0845 stack[-1] // @0846 stack[-4] // } 0843 5B JUMPDEST 0844 82 DUP3 0845 01 ADD 0846 83 DUP4 0847 60 PUSH1 0x20 0849 82 DUP3 084A 01 ADD 084B 11 GT 084C 15 ISZERO 084D 61 PUSH2 0x0855 0850 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0845 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0855, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0851: // Incoming jump from 0x0850, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0854 memory[0x00:0x00] } 0851 60 PUSH1 0x00 0853 80 DUP1 0854 FD *REVERT // Stack delta = +0 // Outputs[1] { @0854 revert(memory[0x00:0x00]); } // Block terminates label_0855: // Incoming jump from 0x0850, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0856 stack[-1] // @0857 msg.data[stack[-1]:stack[-1] + 0x20] // @085C stack[-2] // @085D stack[-4] // } 0855 5B JUMPDEST 0856 80 DUP1 0857 35 CALLDATALOAD 0858 90 SWAP1 0859 60 PUSH1 0x20 085B 01 ADD 085C 91 SWAP2 085D 84 DUP5 085E 60 PUSH1 0x20 0860 83 DUP4 0861 02 MUL 0862 84 DUP5 0863 01 ADD 0864 11 GT 0865 60 PUSH1 0x01 0867 60 PUSH1 0x20 0869 1B SHL 086A 83 DUP4 086B 11 GT 086C 17 OR 086D 15 ISZERO 086E 61 PUSH2 0x0876 0871 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0858 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @085C stack[0] = stack[-2] // @085C stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0876, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0872: // Incoming jump from 0x0871, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0875 memory[0x00:0x00] } 0872 60 PUSH1 0x00 0874 80 DUP1 0875 FD *REVERT // Stack delta = +0 // Outputs[1] { @0875 revert(memory[0x00:0x00]); } // Block terminates label_0876: // Incoming jump from 0x0871, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[7] // { // @0877 stack[-1] // @0877 stack[-3] // @0878 stack[-2] // @0883 memory[0x40:0x60] // @089D msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @08A8 stack[-5] // @08AD stack[-4] // } 0876 5B JUMPDEST 0877 91 SWAP2 0878 90 SWAP1 0879 80 DUP1 087A 80 DUP1 087B 60 PUSH1 0x20 087D 02 MUL 087E 60 PUSH1 0x20 0880 01 ADD 0881 60 PUSH1 0x40 0883 51 MLOAD 0884 90 SWAP1 0885 81 DUP2 0886 01 ADD 0887 60 PUSH1 0x40 0889 52 MSTORE 088A 80 DUP1 088B 93 SWAP4 088C 92 SWAP3 088D 91 SWAP2 088E 90 SWAP1 088F 81 DUP2 0890 81 DUP2 0891 52 MSTORE 0892 60 PUSH1 0x20 0894 01 ADD 0895 83 DUP4 0896 83 DUP4 0897 60 PUSH1 0x20 0899 02 MUL 089A 80 DUP1 089B 82 DUP3 089C 84 DUP5 089D 37 CALLDATACOPY 089E 60 PUSH1 0x00 08A0 92 SWAP3 08A1 01 ADD 08A2 91 SWAP2 08A3 90 SWAP1 08A4 91 SWAP2 08A5 52 MSTORE 08A6 50 POP 08A7 92 SWAP3 08A8 95 SWAP6 08A9 50 POP 08AA 61 PUSH2 0x0ed9 08AD 94 SWAP5 08AE 50 POP 08AF 50 POP 08B0 50 POP 08B1 50 POP 08B2 50 POP 08B3 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0889 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @0891 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @089D memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @08A5 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @08A8 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0ed9 label_08B4: // Incoming jump from 0x0092, if 0xeb2c7de3 == stack[-1] 08B4 5B JUMPDEST 08B5 61 PUSH2 0x018e 08B8 61 PUSH2 0x0ef0 08BB 56 *JUMP // Stack delta = +1 // Outputs[1] { @08B5 stack[0] = 0x018e } // Block ends with call to 0x0ef0, returns to 0x018E label_08BC: // Incoming jump from 0x0040, if 0xf2fde38b == stack[-1] // Inputs[1] { @08C3 msg.data.length } 08BC 5B JUMPDEST 08BD 61 PUSH2 0x0184 08C0 60 PUSH1 0x04 08C2 80 DUP1 08C3 36 CALLDATASIZE 08C4 03 SUB 08C5 60 PUSH1 0x20 08C7 81 DUP2 08C8 10 LT 08C9 15 ISZERO 08CA 61 PUSH2 0x08d2 08CD 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @08BD stack[0] = 0x0184 // @08C0 stack[1] = 0x04 // @08C4 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x08d2, returns to 0x0184, if !(msg.data.length - 0x04 < 0x20) label_08CE: // Incoming jump from 0x08CD, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @08D1 memory[0x00:0x00] } 08CE 60 PUSH1 0x00 08D0 80 DUP1 08D1 FD *REVERT // Stack delta = +0 // Outputs[1] { @08D1 revert(memory[0x00:0x00]); } // Block terminates label_08D2: // Incoming call from 0x08CD, returns to 0x0184, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @08D4 stack[-2] // @08D4 msg.data[stack[-2]:stack[-2] + 0x20] // } 08D2 5B JUMPDEST 08D3 50 POP 08D4 35 CALLDATALOAD 08D5 60 PUSH1 0x01 08D7 60 PUSH1 0x01 08D9 60 PUSH1 0xa0 08DB 1B SHL 08DC 03 SUB 08DD 16 AND 08DE 61 PUSH2 0x0eff 08E1 56 *JUMP // Stack delta = -1 // Outputs[1] { @08DD stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0eff label_08E2: // Incoming jump from 0x004B, if 0xf3d3d448 == stack[-1] // Inputs[1] { @08E9 msg.data.length } 08E2 5B JUMPDEST 08E3 61 PUSH2 0x0184 08E6 60 PUSH1 0x04 08E8 80 DUP1 08E9 36 CALLDATASIZE 08EA 03 SUB 08EB 60 PUSH1 0x20 08ED 81 DUP2 08EE 10 LT 08EF 15 ISZERO 08F0 61 PUSH2 0x08f8 08F3 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @08E3 stack[0] = 0x0184 // @08E6 stack[1] = 0x04 // @08EA stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x08f8, returns to 0x0184, if !(msg.data.length - 0x04 < 0x20) label_08F4: // Incoming jump from 0x08F3, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @08F7 memory[0x00:0x00] } 08F4 60 PUSH1 0x00 08F6 80 DUP1 08F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @08F7 revert(memory[0x00:0x00]); } // Block terminates label_08F8: // Incoming call from 0x08F3, returns to 0x0184, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @08FA stack[-2] // @08FA msg.data[stack[-2]:stack[-2] + 0x20] // } 08F8 5B JUMPDEST 08F9 50 POP 08FA 35 CALLDATALOAD 08FB 60 PUSH1 0x01 08FD 60 PUSH1 0x01 08FF 60 PUSH1 0xa0 0901 1B SHL 0902 03 SUB 0903 16 AND 0904 61 PUSH2 0x0ff7 0907 56 *JUMP // Stack delta = -1 // Outputs[1] { @0903 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0ff7 label_0908: // Incoming jump from 0x0056, if 0xf77c4791 == stack[-1] 0908 5B JUMPDEST 0909 61 PUSH2 0x018e 090C 61 PUSH2 0x1071 090F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0909 stack[0] = 0x018e } // Block ends with call to 0x1071, returns to 0x018E label_0910: // Incoming jump from 0x0061, if 0xfd9af456 == stack[-1] 0910 5B JUMPDEST 0911 61 PUSH2 0x0184 0914 61 PUSH2 0x1080 0917 56 *JUMP // Stack delta = +1 // Outputs[1] { @0911 stack[0] = 0x0184 } // Block ends with call to 0x1080, returns to 0x0184 label_0918: // Incoming jump from 0x0183 // Inputs[2] // { // @0921 stack[-2] // @0922 stack[-1] // } 0918 5B JUMPDEST 0919 60 PUSH1 0x00 091B 80 DUP1 091C 60 PUSH1 0x60 091E 80 DUP1 091F 60 PUSH1 0x60 0921 86 DUP7 0922 86 DUP7 0923 60 PUSH1 0xa0 0925 81 DUP2 0926 10 LT 0927 15 ISZERO 0928 61 PUSH2 0x0930 092B 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @0919 stack[0] = 0x00 // @091B stack[1] = 0x00 // @091C stack[2] = 0x60 // @091E stack[3] = 0x60 // @091F stack[4] = 0x60 // @0921 stack[5] = stack[-2] // @0922 stack[6] = stack[-1] // } // Block ends with conditional jump to 0x0930, if !(stack[-1] < 0xa0) label_092C: // Incoming jump from 0x092B, if not !(stack[-1] < 0xa0) // Inputs[1] { @092F memory[0x00:0x00] } 092C 60 PUSH1 0x00 092E 80 DUP1 092F FD *REVERT // Stack delta = +0 // Outputs[1] { @092F revert(memory[0x00:0x00]); } // Block terminates label_0930: // Incoming jump from 0x092B, if !(stack[-1] < 0xa0) // Inputs[5] // { // @0931 stack[-2] // @0932 msg.data[stack[-2]:stack[-2] + 0x20] // @0938 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @093B stack[-1] // @0947 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } 0930 5B JUMPDEST 0931 81 DUP2 0932 35 CALLDATALOAD 0933 91 SWAP2 0934 60 PUSH1 0x20 0936 81 DUP2 0937 01 ADD 0938 35 CALLDATALOAD 0939 15 ISZERO 093A 15 ISZERO 093B 91 SWAP2 093C 81 DUP2 093D 01 ADD 093E 90 SWAP1 093F 60 PUSH1 0x60 0941 81 DUP2 0942 01 ADD 0943 60 PUSH1 0x40 0945 82 DUP3 0946 01 ADD 0947 35 CALLDATALOAD 0948 60 PUSH1 0x01 094A 60 PUSH1 0x20 094C 1B SHL 094D 81 DUP2 094E 11 GT 094F 15 ISZERO 0950 61 PUSH2 0x0958 0953 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @0933 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @093B stack[-1] = !!msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @093E stack[0] = stack[-2] + stack[-1] // @093E stack[1] = stack[-2] // @0942 stack[2] = stack[-2] + 0x60 // @0947 stack[3] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x0958, if !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) label_0954: // Incoming jump from 0x0953, if not !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) // Inputs[1] { @0957 memory[0x00:0x00] } 0954 60 PUSH1 0x00 0956 80 DUP1 0957 FD *REVERT // Stack delta = +0 // Outputs[1] { @0957 revert(memory[0x00:0x00]); } // Block terminates label_0958: // Incoming jump from 0x0953, if !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0959 stack[-3] // @095A stack[-1] // @095B stack[-4] // } 0958 5B JUMPDEST 0959 82 DUP3 095A 01 ADD 095B 83 DUP4 095C 60 PUSH1 0x20 095E 82 DUP3 095F 01 ADD 0960 11 GT 0961 15 ISZERO 0962 61 PUSH2 0x096a 0965 57 *JUMPI // Stack delta = +0 // Outputs[1] { @095A stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x096a, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0966: // Incoming jump from 0x0965, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0969 memory[0x00:0x00] } 0966 60 PUSH1 0x00 0968 80 DUP1 0969 FD *REVERT // Stack delta = +0 // Outputs[1] { @0969 revert(memory[0x00:0x00]); } // Block terminates label_096A: // Incoming jump from 0x0965, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @096B stack[-1] // @096C msg.data[stack[-1]:stack[-1] + 0x20] // @0971 stack[-2] // @0972 stack[-4] // } 096A 5B JUMPDEST 096B 80 DUP1 096C 35 CALLDATALOAD 096D 90 SWAP1 096E 60 PUSH1 0x20 0970 01 ADD 0971 91 SWAP2 0972 84 DUP5 0973 60 PUSH1 0x20 0975 83 DUP4 0976 02 MUL 0977 84 DUP5 0978 01 ADD 0979 11 GT 097A 60 PUSH1 0x01 097C 60 PUSH1 0x20 097E 1B SHL 097F 83 DUP4 0980 11 GT 0981 17 OR 0982 15 ISZERO 0983 61 PUSH2 0x098b 0986 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @096D stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0971 stack[0] = stack[-2] // @0971 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x098b, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0987: // Incoming jump from 0x0986, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @098A memory[0x00:0x00] } 0987 60 PUSH1 0x00 0989 80 DUP1 098A FD *REVERT // Stack delta = +0 // Outputs[1] { @098A revert(memory[0x00:0x00]); } // Block terminates label_098B: // Incoming jump from 0x0986, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @098C stack[-1] // @098C stack[-3] // @098D stack[-2] // @0998 memory[0x40:0x60] // @09B2 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @09BD stack[-5] // @09BE stack[-4] // @09C6 msg.data[stack[-1]:stack[-1] + 0x20] // } 098B 5B JUMPDEST 098C 91 SWAP2 098D 90 SWAP1 098E 80 DUP1 098F 80 DUP1 0990 60 PUSH1 0x20 0992 02 MUL 0993 60 PUSH1 0x20 0995 01 ADD 0996 60 PUSH1 0x40 0998 51 MLOAD 0999 90 SWAP1 099A 81 DUP2 099B 01 ADD 099C 60 PUSH1 0x40 099E 52 MSTORE 099F 80 DUP1 09A0 93 SWAP4 09A1 92 SWAP3 09A2 91 SWAP2 09A3 90 SWAP1 09A4 81 DUP2 09A5 81 DUP2 09A6 52 MSTORE 09A7 60 PUSH1 0x20 09A9 01 ADD 09AA 83 DUP4 09AB 83 DUP4 09AC 60 PUSH1 0x20 09AE 02 MUL 09AF 80 DUP1 09B0 82 DUP3 09B1 84 DUP5 09B2 37 CALLDATACOPY 09B3 60 PUSH1 0x00 09B5 92 SWAP3 09B6 01 ADD 09B7 91 SWAP2 09B8 90 SWAP1 09B9 91 SWAP2 09BA 52 MSTORE 09BB 50 POP 09BC 92 SWAP3 09BD 95 SWAP6 09BE 94 SWAP5 09BF 93 SWAP4 09C0 60 PUSH1 0x20 09C2 81 DUP2 09C3 01 ADD 09C4 93 SWAP4 09C5 50 POP 09C6 35 CALLDATALOAD 09C7 91 SWAP2 09C8 50 POP 09C9 50 POP 09CA 60 PUSH1 0x01 09CC 60 PUSH1 0x20 09CE 1B SHL 09CF 81 DUP2 09D0 11 GT 09D1 15 ISZERO 09D2 61 PUSH2 0x09da 09D5 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @099E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @09A6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @09B2 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @09BA memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @09BD stack[-5] = memory[0x40:0x60] // @09BE stack[-4] = stack[-5] // @09BF stack[-3] = stack[-4] // @09C4 stack[-2] = stack[-1] + 0x20 // @09C7 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x09da, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_09D6: // Incoming jump from 0x09D5, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @09D9 memory[0x00:0x00] } 09D6 60 PUSH1 0x00 09D8 80 DUP1 09D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @09D9 revert(memory[0x00:0x00]); } // Block terminates label_09DA: // Incoming jump from 0x09D5, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @09DB stack[-3] // @09DC stack[-1] // @09DD stack[-4] // } 09DA 5B JUMPDEST 09DB 82 DUP3 09DC 01 ADD 09DD 83 DUP4 09DE 60 PUSH1 0x20 09E0 82 DUP3 09E1 01 ADD 09E2 11 GT 09E3 15 ISZERO 09E4 61 PUSH2 0x09ec 09E7 57 *JUMPI // Stack delta = +0 // Outputs[1] { @09DC stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x09ec, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_09E8: // Incoming jump from 0x09E7, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @09EB memory[0x00:0x00] } 09E8 60 PUSH1 0x00 09EA 80 DUP1 09EB FD *REVERT // Stack delta = +0 // Outputs[1] { @09EB revert(memory[0x00:0x00]); } // Block terminates label_09EC: // Incoming jump from 0x09E7, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @09ED stack[-1] // @09EE msg.data[stack[-1]:stack[-1] + 0x20] // @09F3 stack[-2] // @09F4 stack[-4] // } 09EC 5B JUMPDEST 09ED 80 DUP1 09EE 35 CALLDATALOAD 09EF 90 SWAP1 09F0 60 PUSH1 0x20 09F2 01 ADD 09F3 91 SWAP2 09F4 84 DUP5 09F5 60 PUSH1 0x20 09F7 83 DUP4 09F8 02 MUL 09F9 84 DUP5 09FA 01 ADD 09FB 11 GT 09FC 60 PUSH1 0x01 09FE 60 PUSH1 0x20 0A00 1B SHL 0A01 83 DUP4 0A02 11 GT 0A03 17 OR 0A04 15 ISZERO 0A05 61 PUSH2 0x0a0d 0A08 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @09EF stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @09F3 stack[0] = stack[-2] // @09F3 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0a0d, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0A09: // Incoming jump from 0x0A08, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0A0C memory[0x00:0x00] } 0A09 60 PUSH1 0x00 0A0B 80 DUP1 0A0C FD *REVERT // Stack delta = +0 // Outputs[1] { @0A0C revert(memory[0x00:0x00]); } // Block terminates label_0A0D: // Incoming jump from 0x0A08, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @0A0E stack[-3] // @0A0E stack[-1] // @0A0F stack[-2] // @0A1A memory[0x40:0x60] // @0A34 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0A3F stack[-5] // @0A40 stack[-4] // @0A48 msg.data[stack[-1]:stack[-1] + 0x20] // } 0A0D 5B JUMPDEST 0A0E 91 SWAP2 0A0F 90 SWAP1 0A10 80 DUP1 0A11 80 DUP1 0A12 60 PUSH1 0x20 0A14 02 MUL 0A15 60 PUSH1 0x20 0A17 01 ADD 0A18 60 PUSH1 0x40 0A1A 51 MLOAD 0A1B 90 SWAP1 0A1C 81 DUP2 0A1D 01 ADD 0A1E 60 PUSH1 0x40 0A20 52 MSTORE 0A21 80 DUP1 0A22 93 SWAP4 0A23 92 SWAP3 0A24 91 SWAP2 0A25 90 SWAP1 0A26 81 DUP2 0A27 81 DUP2 0A28 52 MSTORE 0A29 60 PUSH1 0x20 0A2B 01 ADD 0A2C 83 DUP4 0A2D 83 DUP4 0A2E 60 PUSH1 0x20 0A30 02 MUL 0A31 80 DUP1 0A32 82 DUP3 0A33 84 DUP5 0A34 37 CALLDATACOPY 0A35 60 PUSH1 0x00 0A37 92 SWAP3 0A38 01 ADD 0A39 91 SWAP2 0A3A 90 SWAP1 0A3B 91 SWAP2 0A3C 52 MSTORE 0A3D 50 POP 0A3E 92 SWAP3 0A3F 95 SWAP6 0A40 94 SWAP5 0A41 93 SWAP4 0A42 60 PUSH1 0x20 0A44 81 DUP2 0A45 01 ADD 0A46 93 SWAP4 0A47 50 POP 0A48 35 CALLDATALOAD 0A49 91 SWAP2 0A4A 50 POP 0A4B 50 POP 0A4C 60 PUSH1 0x01 0A4E 60 PUSH1 0x20 0A50 1B SHL 0A51 81 DUP2 0A52 11 GT 0A53 15 ISZERO 0A54 61 PUSH2 0x0a5c 0A57 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0A20 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @0A28 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0A34 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0A3C memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @0A3F stack[-5] = memory[0x40:0x60] // @0A40 stack[-4] = stack[-5] // @0A41 stack[-3] = stack[-4] // @0A46 stack[-2] = stack[-1] + 0x20 // @0A49 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0a5c, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_0A58: // Incoming jump from 0x0A57, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0A5B memory[0x00:0x00] } 0A58 60 PUSH1 0x00 0A5A 80 DUP1 0A5B FD *REVERT // Stack delta = +0 // Outputs[1] { @0A5B revert(memory[0x00:0x00]); } // Block terminates label_0A5C: // Incoming jump from 0x0A57, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0A5D stack[-3] // @0A5E stack[-1] // @0A5F stack[-4] // } 0A5C 5B JUMPDEST 0A5D 82 DUP3 0A5E 01 ADD 0A5F 83 DUP4 0A60 60 PUSH1 0x20 0A62 82 DUP3 0A63 01 ADD 0A64 11 GT 0A65 15 ISZERO 0A66 61 PUSH2 0x0a6e 0A69 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0A5E stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0a6e, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0A6A: // Incoming jump from 0x0A69, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0A6D memory[0x00:0x00] } 0A6A 60 PUSH1 0x00 0A6C 80 DUP1 0A6D FD *REVERT // Stack delta = +0 // Outputs[1] { @0A6D revert(memory[0x00:0x00]); } // Block terminates label_0A6E: // Incoming jump from 0x0A69, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0A6F stack[-1] // @0A70 msg.data[stack[-1]:stack[-1] + 0x20] // @0A75 stack[-2] // @0A76 stack[-4] // } 0A6E 5B JUMPDEST 0A6F 80 DUP1 0A70 35 CALLDATALOAD 0A71 90 SWAP1 0A72 60 PUSH1 0x20 0A74 01 ADD 0A75 91 SWAP2 0A76 84 DUP5 0A77 60 PUSH1 0x20 0A79 83 DUP4 0A7A 02 MUL 0A7B 84 DUP5 0A7C 01 ADD 0A7D 11 GT 0A7E 60 PUSH1 0x01 0A80 60 PUSH1 0x20 0A82 1B SHL 0A83 83 DUP4 0A84 11 GT 0A85 17 OR 0A86 15 ISZERO 0A87 61 PUSH2 0x0a8f 0A8A 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0A71 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0A75 stack[0] = stack[-2] // @0A75 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0a8f, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0A8B: // Incoming jump from 0x0A8A, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0A8E memory[0x00:0x00] } 0A8B 60 PUSH1 0x00 0A8D 80 DUP1 0A8E FD *REVERT // Stack delta = +0 // Outputs[1] { @0A8E revert(memory[0x00:0x00]); } // Block terminates label_0A8F: // Incoming jump from 0x0A8A, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[14] // { // @0A90 stack[-3] // @0A90 stack[-1] // @0A91 stack[-2] // @0A9C memory[0x40:0x60] // @0AB6 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0AC0 stack[-9] // @0AC1 stack[-14] // @0AC3 stack[-8] // @0AC4 stack[-13] // @0AC6 stack[-7] // @0AC7 stack[-12] // @0AC9 stack[-6] // @0ACA stack[-11] // @0ACD stack[-10] // } 0A8F 5B JUMPDEST 0A90 91 SWAP2 0A91 90 SWAP1 0A92 80 DUP1 0A93 80 DUP1 0A94 60 PUSH1 0x20 0A96 02 MUL 0A97 60 PUSH1 0x20 0A99 01 ADD 0A9A 60 PUSH1 0x40 0A9C 51 MLOAD 0A9D 90 SWAP1 0A9E 81 DUP2 0A9F 01 ADD 0AA0 60 PUSH1 0x40 0AA2 52 MSTORE 0AA3 80 DUP1 0AA4 93 SWAP4 0AA5 92 SWAP3 0AA6 91 SWAP2 0AA7 90 SWAP1 0AA8 81 DUP2 0AA9 81 DUP2 0AAA 52 MSTORE 0AAB 60 PUSH1 0x20 0AAD 01 ADD 0AAE 83 DUP4 0AAF 83 DUP4 0AB0 60 PUSH1 0x20 0AB2 02 MUL 0AB3 80 DUP1 0AB4 82 DUP3 0AB5 84 DUP5 0AB6 37 CALLDATACOPY 0AB7 60 PUSH1 0x00 0AB9 92 SWAP3 0ABA 01 ADD 0ABB 91 SWAP2 0ABC 90 SWAP1 0ABD 91 SWAP2 0ABE 52 MSTORE 0ABF 50 POP 0AC0 99 SWAP10 0AC1 9E SWAP15 0AC2 50 POP 0AC3 97 SWAP8 0AC4 9C SWAP13 0AC5 50 POP 0AC6 95 SWAP6 0AC7 9A SWAP11 0AC8 50 POP 0AC9 93 SWAP4 0ACA 98 SWAP9 0ACB 50 POP 0ACC 92 SWAP3 0ACD 96 SWAP7 0ACE 50 POP 0ACF 50 POP 0AD0 88 DUP9 0AD1 15 ISZERO 0AD2 94 SWAP5 0AD3 50 POP 0AD4 61 PUSH2 0x0aed 0AD7 93 SWAP4 0AD8 50 POP 0AD9 50 POP 0ADA 50 POP 0ADB 50 POP 0ADC 57 *JUMPI // Stack delta = -9 // Outputs[9] // { // @0AA2 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @0AAA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0AB6 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0ABE memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @0AC1 stack[-14] = stack[-9] // @0AC4 stack[-13] = stack[-8] // @0AC7 stack[-12] = stack[-7] // @0ACA stack[-11] = stack[-6] // @0ACD stack[-10] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x0aed, if !stack[-8] label_0ADD: // Incoming jump from 0x0ADC, if not !stack[-8] // Inputs[4] // { // @0AE0 stack[-5] // @0AE1 stack[-3] // @0AE2 stack[-2] // @0AE3 stack[-1] // } 0ADD 61 PUSH2 0x0ae8 0AE0 85 DUP6 0AE1 84 DUP5 0AE2 84 DUP5 0AE3 84 DUP5 0AE4 61 PUSH2 0x1108 0AE7 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0ADD stack[0] = 0x0ae8 // @0AE0 stack[1] = stack[-5] // @0AE1 stack[2] = stack[-3] // @0AE2 stack[3] = stack[-2] // @0AE3 stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x1108 0AE8 5B JUMPDEST 0AE9 61 PUSH2 0x0af9 0AEC 56 *JUMP label_0AED: // Incoming jump from 0x0ADC, if !stack[-8] // Inputs[4] // { // @0AF1 stack[-5] // @0AF2 stack[-3] // @0AF3 stack[-2] // @0AF4 stack[-1] // } 0AED 5B JUMPDEST 0AEE 61 PUSH2 0x0af9 0AF1 85 DUP6 0AF2 84 DUP5 0AF3 84 DUP5 0AF4 84 DUP5 0AF5 61 PUSH2 0x1998 0AF8 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0AEE stack[0] = 0x0af9 // @0AF1 stack[1] = stack[-5] // @0AF2 stack[2] = stack[-3] // @0AF3 stack[3] = stack[-2] // @0AF4 stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x1998 label_0AF9: // Incoming jump from 0x260E, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @0B04 stack[-11] } 0AF9 5B JUMPDEST 0AFA 50 POP 0AFB 50 POP 0AFC 50 POP 0AFD 50 POP 0AFE 50 POP 0AFF 50 POP 0B00 50 POP 0B01 50 POP 0B02 50 POP 0B03 50 POP 0B04 56 *JUMP // Stack delta = -11 // Block ends with unconditional jump to stack[-11] label_0B05: // Incoming call from 0x018D, returns to 0x018E // Inputs[2] // { // @0B08 storage[0x02] // @0B12 stack[-1] // } 0B05 5B JUMPDEST 0B06 60 PUSH1 0x02 0B08 54 SLOAD 0B09 60 PUSH1 0x01 0B0B 60 PUSH1 0x01 0B0D 60 PUSH1 0xa0 0B0F 1B SHL 0B10 03 SUB 0B11 16 AND 0B12 81 DUP2 0B13 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B11 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x02] } // Block ends with unconditional jump to stack[-1] label_0B14: // Incoming jump from 0x01D5 0B14 5B JUMPDEST 0B15 61 PUSH2 0x0b1c 0B18 61 PUSH2 0x1d6a 0B1B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B15 stack[0] = 0x0b1c } // Block ends with call to 0x1d6a, returns to 0x0B1C label_0B1C: // Incoming return from call to 0x1D6A at 0x0B1B // Inputs[2] // { // @0B1F storage[0x00] // @0B2B stack[-1] // } 0B1C 5B JUMPDEST 0B1D 60 PUSH1 0x00 0B1F 54 SLOAD 0B20 60 PUSH1 0x01 0B22 60 PUSH1 0x01 0B24 60 PUSH1 0xa0 0B26 1B SHL 0B27 03 SUB 0B28 90 SWAP1 0B29 81 DUP2 0B2A 16 AND 0B2B 91 SWAP2 0B2C 16 AND 0B2D 14 EQ 0B2E 61 PUSH2 0x0b6c 0B31 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b6c, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x00] label_0B32: // Incoming jump from 0x0B31, if not stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[5] // { // @0B35 memory[0x40:0x60] // @0B50 memory[0x00:0x20] // @0B59 memory[0x00:0x20] // @0B62 memory[0x40:0x60] // @0B6B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0B32 60 PUSH1 0x40 0B34 80 DUP1 0B35 51 MLOAD 0B36 62 PUSH3 0x461bcd 0B3A 60 PUSH1 0xe5 0B3C 1B SHL 0B3D 81 DUP2 0B3E 52 MSTORE 0B3F 60 PUSH1 0x20 0B41 60 PUSH1 0x04 0B43 82 DUP3 0B44 01 ADD 0B45 81 DUP2 0B46 90 SWAP1 0B47 52 MSTORE 0B48 60 PUSH1 0x24 0B4A 82 DUP3 0B4B 01 ADD 0B4C 52 MSTORE 0B4D 60 PUSH1 0x00 0B4F 80 DUP1 0B50 51 MLOAD 0B51 60 PUSH1 0x20 0B53 61 PUSH2 0x311f 0B56 83 DUP4 0B57 39 CODECOPY 0B58 81 DUP2 0B59 51 MLOAD 0B5A 91 SWAP2 0B5B 52 MSTORE 0B5C 60 PUSH1 0x44 0B5E 82 DUP3 0B5F 01 ADD 0B60 52 MSTORE 0B61 90 SWAP1 0B62 51 MLOAD 0B63 90 SWAP1 0B64 81 DUP2 0B65 90 SWAP1 0B66 03 SUB 0B67 60 PUSH1 0x64 0B69 01 ADD 0B6A 90 SWAP1 0B6B FD *REVERT // Stack delta = +0 // Outputs[7] // { // @0B3E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B47 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B4C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0B57 memory[0x00:0x20] = code[0x311f:0x313f] // @0B5B memory[0x00:0x20] = memory[0x00:0x20] // @0B60 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0B6B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0B6C: // Incoming jump from 0x0B31, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @0B6D stack[-2] } 0B6C 5B JUMPDEST 0B6D 81 DUP2 0B6E 60 PUSH1 0x01 0B70 60 PUSH1 0x01 0B72 60 PUSH1 0xa0 0B74 1B SHL 0B75 03 SUB 0B76 16 AND 0B77 63 PUSH4 0xa9059cbb 0B7C 61 PUSH2 0x0b83 0B7F 61 PUSH2 0x0e24 0B82 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B76 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0B77 stack[1] = 0xa9059cbb // @0B7C stack[2] = 0x0b83 // } // Block ends with call to 0x0e24, returns to 0x0B83 label_0B83: // Incoming return from call to 0x0E24 at 0x0B82 // Inputs[7] // { // @0B84 stack[-4] // @0B87 memory[0x40:0x60] // @0B88 stack[-2] // @0B98 stack[-1] // @0BB5 memory[0x40:0x60] // @0BBC stack[-3] // @0BBE address(stack[-3]).code.length // } 0B83 5B JUMPDEST 0B84 83 DUP4 0B85 60 PUSH1 0x40 0B87 51 MLOAD 0B88 83 DUP4 0B89 63 PUSH4 0xffffffff 0B8E 16 AND 0B8F 60 PUSH1 0xe0 0B91 1B SHL 0B92 81 DUP2 0B93 52 MSTORE 0B94 60 PUSH1 0x04 0B96 01 ADD 0B97 80 DUP1 0B98 83 DUP4 0B99 60 PUSH1 0x01 0B9B 60 PUSH1 0x01 0B9D 60 PUSH1 0xa0 0B9F 1B SHL 0BA0 03 SUB 0BA1 16 AND 0BA2 81 DUP2 0BA3 52 MSTORE 0BA4 60 PUSH1 0x20 0BA6 01 ADD 0BA7 82 DUP3 0BA8 81 DUP2 0BA9 52 MSTORE 0BAA 60 PUSH1 0x20 0BAC 01 ADD 0BAD 92 SWAP3 0BAE 50 POP 0BAF 50 POP 0BB0 50 POP 0BB1 60 PUSH1 0x20 0BB3 60 PUSH1 0x40 0BB5 51 MLOAD 0BB6 80 DUP1 0BB7 83 DUP4 0BB8 03 SUB 0BB9 81 DUP2 0BBA 60 PUSH1 0x00 0BBC 87 DUP8 0BBD 80 DUP1 0BBE 3B EXTCODESIZE 0BBF 15 ISZERO 0BC0 80 DUP1 0BC1 15 ISZERO 0BC2 61 PUSH2 0x0bca 0BC5 57 *JUMPI // Stack delta = +7 // Outputs[11] // { // @0B93 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-2]) << 0xe0 // @0BA3 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0BA9 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-4] // @0BAD stack[-1] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @0BB1 stack[0] = 0x20 // @0BB5 stack[1] = memory[0x40:0x60] // @0BB8 stack[2] = (0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0BB9 stack[3] = memory[0x40:0x60] // @0BBA stack[4] = 0x00 // @0BBC stack[5] = stack[-3] // @0BBF stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x0bca, if !!address(stack[-3]).code.length label_0BC6: // Incoming jump from 0x0BC5, if not !!address(stack[-3]).code.length // Inputs[1] { @0BC9 memory[0x00:0x00] } 0BC6 60 PUSH1 0x00 0BC8 80 DUP1 0BC9 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BC9 revert(memory[0x00:0x00]); } // Block terminates label_0BCA: // Incoming jump from 0x0BC5, if !!address(stack[-3]).code.length // Inputs[9] // { // @0BCC msg.gas // @0BCD stack[-3] // @0BCD stack[-7] // @0BCD stack[-4] // @0BCD stack[-6] // @0BCD address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0BCD stack[-2] // @0BCD memory[stack[-4]:stack[-4] + stack[-5]] // @0BCD stack[-5] // } 0BCA 5B JUMPDEST 0BCB 50 POP 0BCC 5A GAS 0BCD F1 CALL 0BCE 15 ISZERO 0BCF 80 DUP1 0BD0 15 ISZERO 0BD1 61 PUSH2 0x0bde 0BD4 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0BCD memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0BCE 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 0x0bde, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0BD5: // Incoming jump from 0x0BD4, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0BD5 returndata.length // @0BD9 returndata[0x00:0x00 + returndata.length] // @0BDA returndata.length // @0BDD memory[0x00:0x00 + returndata.length] // } 0BD5 3D RETURNDATASIZE 0BD6 60 PUSH1 0x00 0BD8 80 DUP1 0BD9 3E RETURNDATACOPY 0BDA 3D RETURNDATASIZE 0BDB 60 PUSH1 0x00 0BDD FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0BD9 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0BDD revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0BDE: // Incoming jump from 0x0BD4, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @0BE5 memory[0x40:0x60] // @0BE6 returndata.length // } 0BDE 5B JUMPDEST 0BDF 50 POP 0BE0 50 POP 0BE1 50 POP 0BE2 50 POP 0BE3 60 PUSH1 0x40 0BE5 51 MLOAD 0BE6 3D RETURNDATASIZE 0BE7 60 PUSH1 0x20 0BE9 81 DUP2 0BEA 10 LT 0BEB 15 ISZERO 0BEC 61 PUSH2 0x0bf4 0BEF 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0BE5 stack[-4] = memory[0x40:0x60] // @0BE6 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0bf4, if !(returndata.length < 0x20) label_0BF0: // Incoming jump from 0x0BEF, if not !(returndata.length < 0x20) // Inputs[1] { @0BF3 memory[0x00:0x00] } 0BF0 60 PUSH1 0x00 0BF2 80 DUP1 0BF3 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BF3 revert(memory[0x00:0x00]); } // Block terminates label_0BF4: // Incoming jump from 0x0BEF, if !(returndata.length < 0x20) // Incoming jump from 0x2CBA // Inputs[1] { @0BF9 stack[-5] } 0BF4 5B JUMPDEST 0BF5 50 POP 0BF6 50 POP 0BF7 50 POP 0BF8 50 POP 0BF9 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0BFA: // Incoming jump from 0x0383 // Inputs[1] { @0BFE memory[0x40:0x60] } 0BFA 5B JUMPDEST 0BFB 60 PUSH1 0x40 0BFD 80 DUP1 0BFE 51 MLOAD 0BFF 60 PUSH1 0x02 0C01 80 DUP1 0C02 82 DUP3 0C03 52 MSTORE 0C04 60 PUSH1 0x60 0C06 82 DUP3 0C07 81 DUP2 0C08 01 ADD 0C09 90 SWAP1 0C0A 93 SWAP4 0C0B 52 MSTORE 0C0C 81 DUP2 0C0D 60 PUSH1 0x20 0C0F 01 ADD 0C10 5B JUMPDEST 0C11 60 PUSH1 0x60 0C13 81 DUP2 0C14 52 MSTORE 0C15 60 PUSH1 0x20 0C17 01 ADD 0C18 90 SWAP1 0C19 60 PUSH1 0x01 0C1B 90 SWAP1 0C1C 03 SUB 0C1D 90 SWAP1 0C1E 81 DUP2 0C1F 61 PUSH2 0x0c10 0C22 57 *JUMPI // Stack delta = +4 // Outputs[7] // { // @0BFE stack[1] = memory[0x40:0x60] // @0C03 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x02 // @0C0A stack[0] = 0x60 // @0C0B memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @0C14 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x60 // @0C1D stack[2] = 0x02 - 0x01 // @0C1D stack[3] = 0x20 + 0x20 + memory[0x40:0x60] // } // Block ends with conditional jump to 0x0c10, if 0x02 - 0x01 label_0C23: // Incoming jump from 0x0C22, if not 0x02 - 0x01 // Incoming jump from 0x0C22, if not stack[-2] - 0x01 // Inputs[5] // { // @0C23 stack[-1] // @0C23 stack[-2] // @0C26 stack[-3] // @0C26 stack[-4] // @0C2B stack[-8] // } 0C23 90 SWAP1 0C24 50 POP 0C25 50 POP 0C26 90 SWAP1 0C27 50 POP 0C28 61 PUSH2 0x0c30 0C2B 85 DUP6 0C2C 61 PUSH2 0x1d6e 0C2F 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0C26 stack[-4] = stack[-3] // @0C28 stack[-3] = 0x0c30 // @0C2B stack[-2] = stack[-8] // } // Block ends with call to 0x1d6e, returns to 0x0C30 label_0C30: // Incoming return from call to 0x1D6E at 0x0C2F // Inputs[2] // { // @0C31 stack[-3] // @0C35 memory[stack[-3]:stack[-3] + 0x20] // } 0C30 5B JUMPDEST 0C31 82 DUP3 0C32 60 PUSH1 0x00 0C34 81 DUP2 0C35 51 MLOAD 0C36 81 DUP2 0C37 10 LT 0C38 61 PUSH2 0x0c3d 0C3B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0C31 stack[0] = stack[-3] // @0C32 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0c3d, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] label_0C3C: // Incoming jump from 0x0C3B, if not 0x00 < memory[stack[-3]:stack[-3] + 0x20] 0C3C FE *ASSERT // Stack delta = +0 // Outputs[1] { @0C3C assert(); } // Block terminates label_0C3D: // Incoming jump from 0x0C3B, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @0C40 stack[-1] // @0C44 stack[-2] // @0C45 stack[-5] // @0C49 memory[stack[-5]:stack[-5] + 0x20] // } 0C3D 5B JUMPDEST 0C3E 60 PUSH1 0x20 0C40 02 MUL 0C41 60 PUSH1 0x20 0C43 01 ADD 0C44 01 ADD 0C45 83 DUP4 0C46 60 PUSH1 0x01 0C48 81 DUP2 0C49 51 MLOAD 0C4A 81 DUP2 0C4B 10 LT 0C4C 61 PUSH2 0x0c51 0C4F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0C44 stack[-2] = 0x20 + 0x20 * stack[-1] + stack[-2] // @0C45 stack[-1] = stack[-5] // @0C46 stack[0] = 0x01 // } // Block ends with conditional jump to 0x0c51, if 0x01 < memory[stack[-5]:stack[-5] + 0x20] label_0C50: // Incoming jump from 0x0C4F, if not 0x01 < memory[stack[-5]:stack[-5] + 0x20] 0C50 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0C50 assert(); } // Block terminates label_0C51: // Incoming jump from 0x0C4F, if 0x01 < memory[stack[-5]:stack[-5] + 0x20] // Inputs[9] // { // @0C54 stack[-1] // @0C58 stack[-2] // @0C59 stack[-4] // @0C5C stack[-5] // @0C5D stack[-3] // @0C66 stack[-11] // @0C67 stack[-9] // @0C68 stack[-8] // @0C69 stack[-6] // } 0C51 5B JUMPDEST 0C52 60 PUSH1 0x20 0C54 02 MUL 0C55 60 PUSH1 0x20 0C57 01 ADD 0C58 01 ADD 0C59 82 DUP3 0C5A 90 SWAP1 0C5B 52 MSTORE 0C5C 82 DUP3 0C5D 90 SWAP1 0C5E 52 MSTORE 0C5F 50 POP 0C60 50 POP 0C61 60 PUSH1 0x60 0C63 61 PUSH2 0x0c6e 0C66 87 DUP8 0C67 86 DUP7 0C68 86 DUP7 0C69 85 DUP6 0C6A 61 PUSH2 0x1edb 0C6D 56 *JUMP // Stack delta = +1 // Outputs[8] // { // @0C5B memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = stack[-4] // @0C5E memory[stack[-3]:stack[-3] + 0x20] = stack[-5] // @0C61 stack[-5] = 0x60 // @0C63 stack[-4] = 0x0c6e // @0C66 stack[-3] = stack[-11] // @0C67 stack[-2] = stack[-9] // @0C68 stack[-1] = stack[-8] // @0C69 stack[0] = stack[-6] // } // Block ends with call to 0x1edb, returns to 0x0C6E label_0C6E: // Incoming return from call to 0x1EDB at 0x0C6D // Inputs[4] // { // @0C6F stack[-2] // @0C6F stack[-1] // @0C73 stack[-5] // @0C77 memory[stack[-5]:stack[-5] + 0x20] // } 0C6E 5B JUMPDEST 0C6F 90 SWAP1 0C70 50 POP 0C71 60 PUSH1 0x00 0C73 84 DUP5 0C74 60 PUSH1 0x00 0C76 81 DUP2 0C77 51 MLOAD 0C78 81 DUP2 0C79 10 LT 0C7A 61 PUSH2 0x0c7f 0C7D 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0C6F stack[-2] = stack[-1] // @0C71 stack[-1] = 0x00 // @0C73 stack[0] = stack[-5] // @0C74 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0c7f, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] label_0C7E: // Incoming jump from 0x0C7D, if not 0x00 < memory[stack[-5]:stack[-5] + 0x20] 0C7E FE *ASSERT // Stack delta = +0 // Outputs[1] { @0C7E assert(); } // Block terminates label_0C7F: // Incoming jump from 0x0C7D, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] // Inputs[3] // { // @0C82 stack[-1] // @0C86 stack[-2] // @0C87 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 0C7F 5B JUMPDEST 0C80 60 PUSH1 0x20 0C82 02 MUL 0C83 60 PUSH1 0x20 0C85 01 ADD 0C86 01 ADD 0C87 51 MLOAD 0C88 61 PUSH2 0x0ceb 0C8B 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0ceb, if memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_0C8C: // Incoming jump from 0x0C8B, if not memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[3] // { // @0C8F stack[-8] // @0C90 stack[-3] // @0C94 memory[stack[-3]:stack[-3] + 0x20] // } 0C8C 61 PUSH2 0x0ce6 0C8F 88 DUP9 0C90 84 DUP5 0C91 60 PUSH1 0x00 0C93 81 DUP2 0C94 51 MLOAD 0C95 81 DUP2 0C96 10 LT 0C97 61 PUSH2 0x0c9c 0C9A 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @0C8C stack[0] = 0x0ce6 // @0C8F stack[1] = stack[-8] // @0C90 stack[2] = stack[-3] // @0C91 stack[3] = 0x00 // } // Block ends with conditional call to 0x0c9c, returns to 0x0CE6, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] label_0C9B: // Incoming jump from 0x0C9A, if not 0x00 < memory[stack[-3]:stack[-3] + 0x20] 0C9B FE *ASSERT // Stack delta = +0 // Outputs[1] { @0C9B assert(); } // Block terminates label_0C9C: // Incoming call from 0x0C9A, returns to 0x0CE6, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @0C9F stack[-1] // @0CA3 stack[-2] // @0CA4 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0CA8 memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // } 0C9C 5B JUMPDEST 0C9D 60 PUSH1 0x20 0C9F 02 MUL 0CA0 60 PUSH1 0x20 0CA2 01 ADD 0CA3 01 ADD 0CA4 51 MLOAD 0CA5 60 PUSH1 0x00 0CA7 81 DUP2 0CA8 51 MLOAD 0CA9 81 DUP2 0CAA 10 LT 0CAB 61 PUSH2 0x0cb0 0CAE 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0CA4 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0CA5 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x0cb0, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] label_0CAF: // Incoming jump from 0x0CAE, if not 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] 0CAF FE *ASSERT // Stack delta = +0 // Outputs[1] { @0CAF assert(); } // Block terminates label_0CB0: // Incoming jump from 0x0CAE, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // Inputs[5] // { // @0CB3 stack[-1] // @0CB7 stack[-2] // @0CB8 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0CB9 stack[-7] // @0CBD memory[stack[-7]:stack[-7] + 0x20] // } 0CB0 5B JUMPDEST 0CB1 60 PUSH1 0x20 0CB3 02 MUL 0CB4 60 PUSH1 0x20 0CB6 01 ADD 0CB7 01 ADD 0CB8 51 MLOAD 0CB9 85 DUP6 0CBA 60 PUSH1 0x01 0CBC 81 DUP2 0CBD 51 MLOAD 0CBE 81 DUP2 0CBF 10 LT 0CC0 61 PUSH2 0x0cc5 0CC3 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0CB8 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0CB9 stack[-1] = stack[-7] // @0CBA stack[0] = 0x01 // } // Block ends with conditional jump to 0x0cc5, if 0x01 < memory[stack[-7]:stack[-7] + 0x20] label_0CC4: // Incoming jump from 0x0CC3, if not 0x01 < memory[stack[-7]:stack[-7] + 0x20] 0CC4 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0CC4 assert(); } // Block terminates label_0CC5: // Incoming jump from 0x299F, if 0x01 < memory[stack[-11]:stack[-11] + 0x20] // Incoming jump from 0x29E3, if 0x00 < memory[stack[-11]:stack[-11] + 0x20] // Incoming jump from 0x2841, if 0x01 < memory[stack[-9]:stack[-9] + 0x20] // Incoming jump from 0x2931, if 0x00 < memory[stack[-10]:stack[-10] + 0x20] // Incoming jump from 0x2882, if 0x00 < memory[stack[-9]:stack[-9] + 0x20] // Incoming jump from 0x0D23, if 0x00 < memory[stack[-7]:stack[-7] + 0x20] // Incoming jump from 0x28ED, if 0x01 < memory[stack[-10]:stack[-10] + 0x20] // Incoming jump from 0x0CC3, if 0x01 < memory[stack[-7]:stack[-7] + 0x20] // Inputs[4] // { // @0CC8 stack[-1] // @0CCC stack[-2] // @0CCD memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0CD1 memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // } 0CC5 5B JUMPDEST 0CC6 60 PUSH1 0x20 0CC8 02 MUL 0CC9 60 PUSH1 0x20 0CCB 01 ADD 0CCC 01 ADD 0CCD 51 MLOAD 0CCE 60 PUSH1 0x00 0CD0 81 DUP2 0CD1 51 MLOAD 0CD2 81 DUP2 0CD3 10 LT 0CD4 61 PUSH2 0x0cd9 0CD7 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0CCD stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0CCE stack[-1] = 0x00 // } // Block ends with conditional jump to 0x0cd9, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] label_0CD8: // Incoming jump from 0x0CD7, if not 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] 0CD8 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0CD8 assert(); } // Block terminates label_0CD9: // Incoming jump from 0x0CD7, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // Inputs[3] // { // @0CDC stack[-1] // @0CE0 stack[-2] // @0CE1 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 0CD9 5B JUMPDEST 0CDA 60 PUSH1 0x20 0CDC 02 MUL 0CDD 60 PUSH1 0x20 0CDF 01 ADD 0CE0 01 ADD 0CE1 51 MLOAD 0CE2 61 PUSH2 0x20b7 0CE5 56 *JUMP // Stack delta = -1 // Outputs[1] { @0CE1 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x20b7 label_0CE6: // Incoming return from call to 0x0C9C at 0x0C9A 0CE6 5B JUMPDEST 0CE7 61 PUSH2 0x0d25 0CEA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d25 label_0CEB: // Incoming jump from 0x0C8B, if memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[3] // { // @0CEF stack[-8] // @0CF0 stack[-3] // @0CF4 memory[stack[-3]:stack[-3] + 0x20] // } 0CEB 5B JUMPDEST 0CEC 61 PUSH2 0x0d25 0CEF 88 DUP9 0CF0 84 DUP5 0CF1 60 PUSH1 0x01 0CF3 81 DUP2 0CF4 51 MLOAD 0CF5 81 DUP2 0CF6 10 LT 0CF7 61 PUSH2 0x0cfc 0CFA 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @0CEC stack[0] = 0x0d25 // @0CEF stack[1] = stack[-8] // @0CF0 stack[2] = stack[-3] // @0CF1 stack[3] = 0x01 // } // Block ends with conditional call to 0x0cfc, returns to 0x0D25, if 0x01 < memory[stack[-3]:stack[-3] + 0x20] label_0CFB: // Incoming jump from 0x0CFA, if not 0x01 < memory[stack[-3]:stack[-3] + 0x20] 0CFB FE *ASSERT // Stack delta = +0 // Outputs[1] { @0CFB assert(); } // Block terminates label_0CFC: // Incoming call from 0x0CFA, returns to 0x0D25, if 0x01 < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @0CFF stack[-1] // @0D03 stack[-2] // @0D04 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0D08 memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // } 0CFC 5B JUMPDEST 0CFD 60 PUSH1 0x20 0CFF 02 MUL 0D00 60 PUSH1 0x20 0D02 01 ADD 0D03 01 ADD 0D04 51 MLOAD 0D05 60 PUSH1 0x00 0D07 81 DUP2 0D08 51 MLOAD 0D09 81 DUP2 0D0A 10 LT 0D0B 61 PUSH2 0x0d10 0D0E 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0D04 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0D05 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x0d10, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] label_0D0F: // Incoming jump from 0x0D0E, if not 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] 0D0F FE *ASSERT // Stack delta = +0 // Outputs[1] { @0D0F assert(); } // Block terminates label_0D10: // Incoming jump from 0x0D0E, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // Inputs[5] // { // @0D13 stack[-1] // @0D17 stack[-2] // @0D18 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0D19 stack[-7] // @0D1D memory[stack[-7]:stack[-7] + 0x20] // } 0D10 5B JUMPDEST 0D11 60 PUSH1 0x20 0D13 02 MUL 0D14 60 PUSH1 0x20 0D16 01 ADD 0D17 01 ADD 0D18 51 MLOAD 0D19 85 DUP6 0D1A 60 PUSH1 0x00 0D1C 81 DUP2 0D1D 51 MLOAD 0D1E 81 DUP2 0D1F 10 LT 0D20 61 PUSH2 0x0cc5 0D23 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0D18 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0D19 stack[-1] = stack[-7] // @0D1A stack[0] = 0x00 // } // Block ends with conditional jump to 0x0cc5, if 0x00 < memory[stack[-7]:stack[-7] + 0x20] label_0D24: // Incoming jump from 0x0D23, if not 0x00 < memory[stack[-7]:stack[-7] + 0x20] 0D24 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0D24 assert(); } // Block terminates label_0D25: // Incoming jump from 0x0CEA // Incoming return from call to 0x0CFC at 0x0CFA // Inputs[7] // { // @0D26 stack[-2] // @0D26 stack[-1] // @0D2B stack[-9] // @0D32 memory[0x40:0x60] // @0D49 stack[-3] // @0D4D memory[stack[-3]:stack[-3] + 0x20] // @0D50 memory[stack[-3]:stack[-3] + 0x20] // } 0D25 5B JUMPDEST 0D26 90 SWAP1 0D27 50 POP 0D28 61 PUSH2 0x0d78 0D2B 88 DUP9 0D2C 61 PUSH2 0x0d6f 0D2F 83 DUP4 0D30 60 PUSH1 0x40 0D32 51 MLOAD 0D33 80 DUP1 0D34 60 PUSH1 0x60 0D36 01 ADD 0D37 60 PUSH1 0x40 0D39 52 MSTORE 0D3A 80 DUP1 0D3B 60 PUSH1 0x3b 0D3D 81 DUP2 0D3E 52 MSTORE 0D3F 60 PUSH1 0x20 0D41 01 ADD 0D42 61 PUSH2 0x313f 0D45 60 PUSH1 0x3b 0D47 91 SWAP2 0D48 39 CODECOPY 0D49 86 DUP7 0D4A 60 PUSH1 0x02 0D4C 88 DUP9 0D4D 51 MLOAD 0D4E 03 SUB 0D4F 81 DUP2 0D50 51 MLOAD 0D51 81 DUP2 0D52 10 LT 0D53 61 PUSH2 0x0d58 0D56 57 *JUMPI // Stack delta = +6 // Outputs[11] // { // @0D26 stack[-2] = stack[-1] // @0D28 stack[-1] = 0x0d78 // @0D2B stack[0] = stack[-9] // @0D2C stack[1] = 0x0d6f // @0D2F stack[2] = stack[-1] // @0D32 stack[3] = memory[0x40:0x60] // @0D39 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @0D3E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3b // @0D48 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x3b] = code[0x313f:0x317a] // @0D49 stack[4] = stack[-3] // @0D4E stack[5] = memory[stack[-3]:stack[-3] + 0x20] - 0x02 // } // Block ends with conditional call to 0x0d58, returns to 0x0D6F, if memory[stack[-3]:stack[-3] + 0x20] - 0x02 < memory[stack[-3]:stack[-3] + 0x20] label_0D57: // Incoming jump from 0x0D56, if not memory[stack[-3]:stack[-3] + 0x20] - 0x02 < memory[stack[-3]:stack[-3] + 0x20] 0D57 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0D57 assert(); } // Block terminates label_0D58: // Incoming call from 0x0D56, returns to 0x0D6F, if memory[stack[-3]:stack[-3] + 0x20] - 0x02 < memory[stack[-3]:stack[-3] + 0x20] // Inputs[5] // { // @0D5B stack[-1] // @0D5F stack[-2] // @0D60 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0D65 stack[-4] // @0D66 stack[-3] // } 0D58 5B JUMPDEST 0D59 60 PUSH1 0x20 0D5B 02 MUL 0D5C 60 PUSH1 0x20 0D5E 01 ADD 0D5F 01 ADD 0D60 51 MLOAD 0D61 61 PUSH2 0x2184 0D64 90 SWAP1 0D65 92 SWAP3 0D66 91 SWAP2 0D67 90 SWAP1 0D68 63 PUSH4 0xffffffff 0D6D 16 AND 0D6E 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0D65 stack[-4] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0D66 stack[-3] = stack[-4] // @0D67 stack[-2] = stack[-3] // } // Block ends with unconditional jump to 0xffffffff & 0x2184 label_0D6F: // Incoming return from call to 0x0D58 at 0x0D56 // Inputs[4] // { // @0D70 stack[-7] // @0D71 stack[-10] // @0D72 stack[-8] // @0D73 stack[-5] // } 0D6F 5B JUMPDEST 0D70 86 DUP7 0D71 8A DUP11 0D72 89 DUP10 0D73 87 DUP8 0D74 61 PUSH2 0x221b 0D77 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D70 stack[0] = stack[-7] // @0D71 stack[1] = stack[-10] // @0D72 stack[2] = stack[-8] // @0D73 stack[3] = stack[-5] // } // Block ends with unconditional jump to 0x221b label_0D78: // Incoming jump from 0x2D2A, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Incoming return from call to 0x0D6F at 0x0D56 // Inputs[1] { @0D81 stack[-9] } 0D78 5B JUMPDEST 0D79 50 POP 0D7A 50 POP 0D7B 50 POP 0D7C 50 POP 0D7D 50 POP 0D7E 50 POP 0D7F 50 POP 0D80 50 POP 0D81 56 *JUMP // Stack delta = -9 // Block ends with unconditional jump to stack[-9] label_0D82: // Incoming call from 0x038B, returns to 0x0184 0D82 5B JUMPDEST 0D83 61 PUSH2 0x0d8a 0D86 61 PUSH2 0x1d6a 0D89 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D83 stack[0] = 0x0d8a } // Block ends with call to 0x1d6a, returns to 0x0D8A label_0D8A: // Incoming return from call to 0x1D6A at 0x0D89 // Inputs[2] // { // @0D8D storage[0x00] // @0D99 stack[-1] // } 0D8A 5B JUMPDEST 0D8B 60 PUSH1 0x00 0D8D 54 SLOAD 0D8E 60 PUSH1 0x01 0D90 60 PUSH1 0x01 0D92 60 PUSH1 0xa0 0D94 1B SHL 0D95 03 SUB 0D96 90 SWAP1 0D97 81 DUP2 0D98 16 AND 0D99 91 SWAP2 0D9A 16 AND 0D9B 14 EQ 0D9C 61 PUSH2 0x0dda 0D9F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0dda, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x00] label_0DA0: // Incoming jump from 0x0D9F, if not stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[5] // { // @0DA3 memory[0x40:0x60] // @0DBE memory[0x00:0x20] // @0DC7 memory[0x00:0x20] // @0DD0 memory[0x40:0x60] // @0DD9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0DA0 60 PUSH1 0x40 0DA2 80 DUP1 0DA3 51 MLOAD 0DA4 62 PUSH3 0x461bcd 0DA8 60 PUSH1 0xe5 0DAA 1B SHL 0DAB 81 DUP2 0DAC 52 MSTORE 0DAD 60 PUSH1 0x20 0DAF 60 PUSH1 0x04 0DB1 82 DUP3 0DB2 01 ADD 0DB3 81 DUP2 0DB4 90 SWAP1 0DB5 52 MSTORE 0DB6 60 PUSH1 0x24 0DB8 82 DUP3 0DB9 01 ADD 0DBA 52 MSTORE 0DBB 60 PUSH1 0x00 0DBD 80 DUP1 0DBE 51 MLOAD 0DBF 60 PUSH1 0x20 0DC1 61 PUSH2 0x311f 0DC4 83 DUP4 0DC5 39 CODECOPY 0DC6 81 DUP2 0DC7 51 MLOAD 0DC8 91 SWAP2 0DC9 52 MSTORE 0DCA 60 PUSH1 0x44 0DCC 82 DUP3 0DCD 01 ADD 0DCE 52 MSTORE 0DCF 90 SWAP1 0DD0 51 MLOAD 0DD1 90 SWAP1 0DD2 81 DUP2 0DD3 90 SWAP1 0DD4 03 SUB 0DD5 60 PUSH1 0x64 0DD7 01 ADD 0DD8 90 SWAP1 0DD9 FD *REVERT // Stack delta = +0 // Outputs[7] // { // @0DAC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DB5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0DBA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0DC5 memory[0x00:0x20] = code[0x311f:0x313f] // @0DC9 memory[0x00:0x20] = memory[0x00:0x20] // @0DCE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0DD9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0DDA: // Incoming jump from 0x0D9F, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[5] // { // @0DDE storage[0x00] // @0DE1 memory[0x40:0x60] // @0E12 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0E16 storage[0x00] // @0E23 stack[-1] // } 0DDA 5B JUMPDEST 0DDB 60 PUSH1 0x00 0DDD 80 DUP1 0DDE 54 SLOAD 0DDF 60 PUSH1 0x40 0DE1 51 MLOAD 0DE2 60 PUSH1 0x01 0DE4 60 PUSH1 0x01 0DE6 60 PUSH1 0xa0 0DE8 1B SHL 0DE9 03 SUB 0DEA 90 SWAP1 0DEB 91 SWAP2 0DEC 16 AND 0DED 90 SWAP1 0DEE 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 0E0F 90 SWAP1 0E10 83 DUP4 0E11 90 SWAP1 0E12 A3 LOG3 0E13 60 PUSH1 0x00 0E15 80 DUP1 0E16 54 SLOAD 0E17 60 PUSH1 0x01 0E19 60 PUSH1 0x01 0E1B 60 PUSH1 0xa0 0E1D 1B SHL 0E1E 03 SUB 0E1F 19 NOT 0E20 16 AND 0E21 90 SWAP1 0E22 55 SSTORE 0E23 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @0E12 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & (0x01 << 0xa0) - 0x01, 0x00]); // @0E22 storage[0x00] = ~((0x01 << 0xa0) - 0x01) & storage[0x00] // } // Block ends with unconditional jump to stack[-1] label_0E24: // Incoming call from 0x0393, returns to 0x018E // Incoming call from 0x0B82, returns to 0x0B83 // Inputs[2] // { // @0E27 storage[0x00] // @0E31 stack[-1] // } 0E24 5B JUMPDEST 0E25 60 PUSH1 0x00 0E27 54 SLOAD 0E28 60 PUSH1 0x01 0E2A 60 PUSH1 0x01 0E2C 60 PUSH1 0xa0 0E2E 1B SHL 0E2F 03 SUB 0E30 16 AND 0E31 90 SWAP1 0E32 56 *JUMP // Stack delta = +0 // Outputs[1] { @0E31 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x00] } // Block ends with unconditional jump to stack[-1] label_0E33: // Incoming jump from 0x053A // Inputs[3] // { // @0E3D stack[-4] // @0E3E stack[-3] // @0E3F stack[-2] // } 0E33 5B JUMPDEST 0E34 60 PUSH1 0x00 0E36 60 PUSH1 0x60 0E38 60 PUSH1 0x00 0E3A 61 PUSH2 0x0e44 0E3D 87 DUP8 0E3E 87 DUP8 0E3F 87 DUP8 0E40 61 PUSH2 0x2620 0E43 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @0E34 stack[0] = 0x00 // @0E36 stack[1] = 0x60 // @0E38 stack[2] = 0x00 // @0E3A stack[3] = 0x0e44 // @0E3D stack[4] = stack[-4] // @0E3E stack[5] = stack[-3] // @0E3F stack[6] = stack[-2] // } // Block ends with call to 0x2620, returns to 0x0E44 label_0E44: // Incoming return from call to 0x2620 at 0x0E43 // Inputs[6] // { // @0E45 stack[-4] // @0E45 stack[-1] // @0E47 stack[-2] // @0E47 stack[-5] // @0E49 stack[-3] // @0E49 stack[-6] // } 0E44 5B JUMPDEST 0E45 92 SWAP3 0E46 50 POP 0E47 92 SWAP3 0E48 50 POP 0E49 92 SWAP3 0E4A 50 POP 0E4B 60 PUSH1 0x00 0E4D 81 DUP2 0E4E 11 GT 0E4F 61 PUSH2 0x0e89 0E52 57 *JUMPI // Stack delta = -3 // Outputs[3] // { // @0E45 stack[-4] = stack[-1] // @0E47 stack[-5] = stack[-2] // @0E49 stack[-6] = stack[-3] // } // Block ends with conditional jump to 0x0e89, if stack[-1] > 0x00 label_0E53: // Incoming jump from 0x0E52, if not stack[-1] > 0x00 // Inputs[3] // { // @0E55 memory[0x40:0x60] // @0E83 memory[0x40:0x60] // @0E88 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0E53 60 PUSH1 0x40 0E55 51 MLOAD 0E56 62 PUSH3 0x461bcd 0E5A 60 PUSH1 0xe5 0E5C 1B SHL 0E5D 81 DUP2 0E5E 52 MSTORE 0E5F 60 PUSH1 0x04 0E61 01 ADD 0E62 80 DUP1 0E63 80 DUP1 0E64 60 PUSH1 0x20 0E66 01 ADD 0E67 82 DUP3 0E68 81 DUP2 0E69 03 SUB 0E6A 82 DUP3 0E6B 52 MSTORE 0E6C 60 PUSH1 0x24 0E6E 81 DUP2 0E6F 52 MSTORE 0E70 60 PUSH1 0x20 0E72 01 ADD 0E73 80 DUP1 0E74 61 PUSH2 0x317a 0E77 60 PUSH1 0x24 0E79 91 SWAP2 0E7A 39 CODECOPY 0E7B 60 PUSH1 0x40 0E7D 01 ADD 0E7E 91 SWAP2 0E7F 50 POP 0E80 50 POP 0E81 60 PUSH1 0x40 0E83 51 MLOAD 0E84 80 DUP1 0E85 91 SWAP2 0E86 03 SUB 0E87 90 SWAP1 0E88 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0E5E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E6B memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0E6F memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x24 // @0E7A memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x24] = code[0x317a:0x319e] // @0E88 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0E89: // Incoming jump from 0x0E52, if stack[-1] > 0x00 // Inputs[6] // { // @0E8D stack[-3] // @0E8E stack[-1] // @0E8F stack[-4] // @0E90 stack[-7] // @0E91 stack[-5] // @0E92 stack[-2] // } 0E89 5B JUMPDEST 0E8A 61 PUSH2 0x0e97 0E8D 83 DUP4 0E8E 82 DUP3 0E8F 86 DUP7 0E90 8A DUP11 0E91 89 DUP10 0E92 87 DUP8 0E93 61 PUSH2 0x221b 0E96 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @0E8A stack[0] = 0x0e97 // @0E8D stack[1] = stack[-3] // @0E8E stack[2] = stack[-1] // @0E8F stack[3] = stack[-4] // @0E90 stack[4] = stack[-7] // @0E91 stack[5] = stack[-5] // @0E92 stack[6] = stack[-2] // } // Block ends with call to 0x221b, returns to 0x0E97 label_0E97: // Incoming return from call to 0x221B at 0x0E96 // Incoming return from call to 0x2AC9 at 0x1997 // Inputs[1] { @0E9F stack[-8] } 0E97 5B JUMPDEST 0E98 50 POP 0E99 50 POP 0E9A 50 POP 0E9B 50 POP 0E9C 50 POP 0E9D 50 POP 0E9E 50 POP 0E9F 56 *JUMP // Stack delta = -8 // Block ends with unconditional jump to stack[-8] label_0EA0: // Incoming jump from 0x0557 // Inputs[1] { @0EB9 stack[-1] } 0EA0 5B JUMPDEST 0EA1 61 PUSH2 0x0ebe 0EA4 73 PUSH20 0xd5b47b80668840e7164c1d1d81af8a9d9727b421 0EB9 82 DUP3 0EBA 61 PUSH2 0x2a8e 0EBD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0EA1 stack[0] = 0x0ebe // @0EA4 stack[1] = 0xd5b47b80668840e7164c1d1d81af8a9d9727b421 // @0EB9 stack[2] = stack[-1] // } // Block ends with call to 0x2a8e, returns to 0x0EBE label_0EBE: // Incoming return from call to 0x2A8E at 0x0EBD // Inputs[1] { @0EC0 stack[-2] } 0EBE 5B JUMPDEST 0EBF 50 POP 0EC0 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0EC1: // Incoming jump from 0x06FC // Inputs[3] // { // @0EC7 stack[-3] // @0EC8 stack[-2] // @0EC9 stack[-1] // } 0EC1 5B JUMPDEST 0EC2 60 PUSH1 0x00 0EC4 61 PUSH2 0x0ece 0EC7 84 DUP5 0EC8 84 DUP5 0EC9 84 DUP5 0ECA 61 PUSH2 0x2620 0ECD 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0EC2 stack[0] = 0x00 // @0EC4 stack[1] = 0x0ece // @0EC7 stack[2] = stack[-3] // @0EC8 stack[3] = stack[-2] // @0EC9 stack[4] = stack[-1] // } // Block ends with call to 0x2620, returns to 0x0ECE label_0ECE: // Incoming return from call to 0x2620 at 0x0ECD // Inputs[4] // { // @0ED0 stack[-2] // @0ED0 stack[-3] // @0ED1 stack[-8] // @0ED2 stack[-7] // } 0ECE 5B JUMPDEST 0ECF 50 POP 0ED0 90 SWAP1 0ED1 95 SWAP6 0ED2 94 SWAP5 0ED3 50 POP 0ED4 50 POP 0ED5 50 POP 0ED6 50 POP 0ED7 50 POP 0ED8 56 *JUMP // Stack delta = -7 // Outputs[1] { @0ED1 stack[-8] = stack[-3] } // Block ends with unconditional jump to stack[-8] label_0ED9: // Incoming jump from 0x08B3 // Inputs[3] // { // @0EDF stack[-3] // @0EE0 stack[-2] // @0EE1 stack[-1] // } 0ED9 5B JUMPDEST 0EDA 60 PUSH1 0x00 0EDC 61 PUSH2 0x0ee6 0EDF 84 DUP5 0EE0 84 DUP5 0EE1 84 DUP5 0EE2 61 PUSH2 0x2620 0EE5 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0EDA stack[0] = 0x00 // @0EDC stack[1] = 0x0ee6 // @0EDF stack[2] = stack[-3] // @0EE0 stack[3] = stack[-2] // @0EE1 stack[4] = stack[-1] // } // Block ends with call to 0x2620, returns to 0x0EE6 label_0EE6: // Incoming return from call to 0x2620 at 0x0EE5 // Inputs[3] // { // @0EE7 stack[-1] // @0EE7 stack[-8] // @0EE8 stack[-7] // } 0EE6 5B JUMPDEST 0EE7 96 SWAP7 0EE8 95 SWAP6 0EE9 50 POP 0EEA 50 POP 0EEB 50 POP 0EEC 50 POP 0EED 50 POP 0EEE 50 POP 0EEF 56 *JUMP // Stack delta = -7 // Outputs[1] { @0EE7 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_0EF0: // Incoming call from 0x08BB, returns to 0x018E // Inputs[2] // { // @0EF3 storage[0x01] // @0EFD stack[-1] // } 0EF0 5B JUMPDEST 0EF1 60 PUSH1 0x01 0EF3 54 SLOAD 0EF4 60 PUSH1 0x01 0EF6 60 PUSH1 0x01 0EF8 60 PUSH1 0xa0 0EFA 1B SHL 0EFB 03 SUB 0EFC 16 AND 0EFD 81 DUP2 0EFE 56 *JUMP // Stack delta = +1 // Outputs[1] { @0EFC stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x01] } // Block ends with unconditional jump to stack[-1] label_0EFF: // Incoming jump from 0x08E1 0EFF 5B JUMPDEST 0F00 61 PUSH2 0x0f07 0F03 61 PUSH2 0x1d6a 0F06 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F00 stack[0] = 0x0f07 } // Block ends with call to 0x1d6a, returns to 0x0F07 label_0F07: // Incoming return from call to 0x1D6A at 0x0F06 // Inputs[2] // { // @0F0A storage[0x00] // @0F16 stack[-1] // } 0F07 5B JUMPDEST 0F08 60 PUSH1 0x00 0F0A 54 SLOAD 0F0B 60 PUSH1 0x01 0F0D 60 PUSH1 0x01 0F0F 60 PUSH1 0xa0 0F11 1B SHL 0F12 03 SUB 0F13 90 SWAP1 0F14 81 DUP2 0F15 16 AND 0F16 91 SWAP2 0F17 16 AND 0F18 14 EQ 0F19 61 PUSH2 0x0f57 0F1C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f57, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x00] label_0F1D: // Incoming jump from 0x0F1C, if not stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[5] // { // @0F20 memory[0x40:0x60] // @0F3B memory[0x00:0x20] // @0F44 memory[0x00:0x20] // @0F4D memory[0x40:0x60] // @0F56 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0F1D 60 PUSH1 0x40 0F1F 80 DUP1 0F20 51 MLOAD 0F21 62 PUSH3 0x461bcd 0F25 60 PUSH1 0xe5 0F27 1B SHL 0F28 81 DUP2 0F29 52 MSTORE 0F2A 60 PUSH1 0x20 0F2C 60 PUSH1 0x04 0F2E 82 DUP3 0F2F 01 ADD 0F30 81 DUP2 0F31 90 SWAP1 0F32 52 MSTORE 0F33 60 PUSH1 0x24 0F35 82 DUP3 0F36 01 ADD 0F37 52 MSTORE 0F38 60 PUSH1 0x00 0F3A 80 DUP1 0F3B 51 MLOAD 0F3C 60 PUSH1 0x20 0F3E 61 PUSH2 0x311f 0F41 83 DUP4 0F42 39 CODECOPY 0F43 81 DUP2 0F44 51 MLOAD 0F45 91 SWAP2 0F46 52 MSTORE 0F47 60 PUSH1 0x44 0F49 82 DUP3 0F4A 01 ADD 0F4B 52 MSTORE 0F4C 90 SWAP1 0F4D 51 MLOAD 0F4E 90 SWAP1 0F4F 81 DUP2 0F50 90 SWAP1 0F51 03 SUB 0F52 60 PUSH1 0x64 0F54 01 ADD 0F55 90 SWAP1 0F56 FD *REVERT // Stack delta = +0 // Outputs[7] // { // @0F29 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F32 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F37 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0F42 memory[0x00:0x20] = code[0x311f:0x313f] // @0F46 memory[0x00:0x20] = memory[0x00:0x20] // @0F4B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @0F56 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0F57: // Incoming jump from 0x0F1C, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @0F60 stack[-1] } 0F57 5B JUMPDEST 0F58 60 PUSH1 0x01 0F5A 60 PUSH1 0x01 0F5C 60 PUSH1 0xa0 0F5E 1B SHL 0F5F 03 SUB 0F60 81 DUP2 0F61 16 AND 0F62 61 PUSH2 0x0f9c 0F65 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f9c, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0F66: // Incoming jump from 0x0F65, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0F68 memory[0x40:0x60] // @0F96 memory[0x40:0x60] // @0F9B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0F66 60 PUSH1 0x40 0F68 51 MLOAD 0F69 62 PUSH3 0x461bcd 0F6D 60 PUSH1 0xe5 0F6F 1B SHL 0F70 81 DUP2 0F71 52 MSTORE 0F72 60 PUSH1 0x04 0F74 01 ADD 0F75 80 DUP1 0F76 80 DUP1 0F77 60 PUSH1 0x20 0F79 01 ADD 0F7A 82 DUP3 0F7B 81 DUP2 0F7C 03 SUB 0F7D 82 DUP3 0F7E 52 MSTORE 0F7F 60 PUSH1 0x26 0F81 81 DUP2 0F82 52 MSTORE 0F83 60 PUSH1 0x20 0F85 01 ADD 0F86 80 DUP1 0F87 61 PUSH2 0x3084 0F8A 60 PUSH1 0x26 0F8C 91 SWAP2 0F8D 39 CODECOPY 0F8E 60 PUSH1 0x40 0F90 01 ADD 0F91 91 SWAP2 0F92 50 POP 0F93 50 POP 0F94 60 PUSH1 0x40 0F96 51 MLOAD 0F97 80 DUP1 0F98 91 SWAP2 0F99 03 SUB 0F9A 90 SWAP1 0F9B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0F71 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F7E memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0F82 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x26 // @0F8D memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x26] = code[0x3084:0x30aa] // @0F9B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0F9C: // Incoming jump from 0x0F65, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @0FA0 storage[0x00] // @0FA3 memory[0x40:0x60] // @0FAD stack[-1] // @0FD5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0FD9 storage[0x00] // @0FF6 stack[-2] // } 0F9C 5B JUMPDEST 0F9D 60 PUSH1 0x00 0F9F 80 DUP1 0FA0 54 SLOAD 0FA1 60 PUSH1 0x40 0FA3 51 MLOAD 0FA4 60 PUSH1 0x01 0FA6 60 PUSH1 0x01 0FA8 60 PUSH1 0xa0 0FAA 1B SHL 0FAB 03 SUB 0FAC 80 DUP1 0FAD 85 DUP6 0FAE 16 AND 0FAF 93 SWAP4 0FB0 92 SWAP3 0FB1 16 AND 0FB2 91 SWAP2 0FB3 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 0FD4 91 SWAP2 0FD5 A3 LOG3 0FD6 60 PUSH1 0x00 0FD8 80 DUP1 0FD9 54 SLOAD 0FDA 60 PUSH1 0x01 0FDC 60 PUSH1 0x01 0FDE 60 PUSH1 0xa0 0FE0 1B SHL 0FE1 03 SUB 0FE2 19 NOT 0FE3 16 AND 0FE4 60 PUSH1 0x01 0FE6 60 PUSH1 0x01 0FE8 60 PUSH1 0xa0 0FEA 1B SHL 0FEB 03 SUB 0FEC 92 SWAP3 0FED 90 SWAP1 0FEE 92 SWAP3 0FEF 16 AND 0FF0 91 SWAP2 0FF1 90 SWAP1 0FF2 91 SWAP2 0FF3 17 OR 0FF4 90 SWAP1 0FF5 55 SSTORE 0FF6 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @0FD5 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // @0FF5 storage[0x00] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x00]) // } // Block ends with unconditional jump to stack[-2] label_0FF7: // Incoming jump from 0x0907 0FF7 5B JUMPDEST 0FF8 61 PUSH2 0x0fff 0FFB 61 PUSH2 0x1d6a 0FFE 56 *JUMP // Stack delta = +1 // Outputs[1] { @0FF8 stack[0] = 0x0fff } // Block ends with call to 0x1d6a, returns to 0x0FFF label_0FFF: // Incoming return from call to 0x1D6A at 0x0FFE // Inputs[2] // { // @1002 storage[0x00] // @100E stack[-1] // } 0FFF 5B JUMPDEST 1000 60 PUSH1 0x00 1002 54 SLOAD 1003 60 PUSH1 0x01 1005 60 PUSH1 0x01 1007 60 PUSH1 0xa0 1009 1B SHL 100A 03 SUB 100B 90 SWAP1 100C 81 DUP2 100D 16 AND 100E 91 SWAP2 100F 16 AND 1010 14 EQ 1011 61 PUSH2 0x104f 1014 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x104f, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x00] label_1015: // Incoming jump from 0x1014, if not stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[5] // { // @1018 memory[0x40:0x60] // @1033 memory[0x00:0x20] // @103C memory[0x00:0x20] // @1045 memory[0x40:0x60] // @104E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1015 60 PUSH1 0x40 1017 80 DUP1 1018 51 MLOAD 1019 62 PUSH3 0x461bcd 101D 60 PUSH1 0xe5 101F 1B SHL 1020 81 DUP2 1021 52 MSTORE 1022 60 PUSH1 0x20 1024 60 PUSH1 0x04 1026 82 DUP3 1027 01 ADD 1028 81 DUP2 1029 90 SWAP1 102A 52 MSTORE 102B 60 PUSH1 0x24 102D 82 DUP3 102E 01 ADD 102F 52 MSTORE 1030 60 PUSH1 0x00 1032 80 DUP1 1033 51 MLOAD 1034 60 PUSH1 0x20 1036 61 PUSH2 0x311f 1039 83 DUP4 103A 39 CODECOPY 103B 81 DUP2 103C 51 MLOAD 103D 91 SWAP2 103E 52 MSTORE 103F 60 PUSH1 0x44 1041 82 DUP3 1042 01 ADD 1043 52 MSTORE 1044 90 SWAP1 1045 51 MLOAD 1046 90 SWAP1 1047 81 DUP2 1048 90 SWAP1 1049 03 SUB 104A 60 PUSH1 0x64 104C 01 ADD 104D 90 SWAP1 104E FD *REVERT // Stack delta = +0 // Outputs[7] // { // @1021 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @102A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @102F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @103A memory[0x00:0x20] = code[0x311f:0x313f] // @103E memory[0x00:0x20] = memory[0x00:0x20] // @1043 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[0x00:0x20] // @104E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_104F: // Incoming jump from 0x1014, if stack[-1] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[3] // { // @1053 storage[0x05] // @1066 stack[-1] // @1070 stack[-2] // } 104F 5B JUMPDEST 1050 60 PUSH1 0x05 1052 80 DUP1 1053 54 SLOAD 1054 60 PUSH1 0x01 1056 60 PUSH1 0x01 1058 60 PUSH1 0xa0 105A 1B SHL 105B 03 SUB 105C 19 NOT 105D 16 AND 105E 60 PUSH1 0x01 1060 60 PUSH1 0x01 1062 60 PUSH1 0xa0 1064 1B SHL 1065 03 SUB 1066 92 SWAP3 1067 90 SWAP1 1068 92 SWAP3 1069 16 AND 106A 91 SWAP2 106B 90 SWAP1 106C 91 SWAP2 106D 17 OR 106E 90 SWAP1 106F 55 SSTORE 1070 56 *JUMP // Stack delta = -2 // Outputs[1] { @106F storage[0x05] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x05]) } // Block ends with unconditional jump to stack[-2] label_1071: // Incoming call from 0x090F, returns to 0x018E // Inputs[2] // { // @1074 storage[0x05] // @107E stack[-1] // } 1071 5B JUMPDEST 1072 60 PUSH1 0x05 1074 54 SLOAD 1075 60 PUSH1 0x01 1077 60 PUSH1 0x01 1079 60 PUSH1 0xa0 107B 1B SHL 107C 03 SUB 107D 16 AND 107E 81 DUP2 107F 56 *JUMP // Stack delta = +1 // Outputs[1] { @107D stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x05] } // Block ends with unconditional jump to stack[-1] label_1080: // Incoming call from 0x0917, returns to 0x0184 // Inputs[5] // { // @1084 storage[0x04] // @1087 storage[0x03] // @108B memory[0x40:0x60] // @10B0 memory[0x40:0x60] // @10CE address(storage[0x04] & (0x01 << 0xa0) - 0x01).code.length // } 1080 5B JUMPDEST 1081 60 PUSH1 0x04 1083 80 DUP1 1084 54 SLOAD 1085 60 PUSH1 0x03 1087 54 SLOAD 1088 60 PUSH1 0x40 108A 80 DUP1 108B 51 MLOAD 108C 63 PUSH4 0x095ea7b3 1091 60 PUSH1 0xe0 1093 1B SHL 1094 81 DUP2 1095 52 MSTORE 1096 60 PUSH1 0x01 1098 60 PUSH1 0x01 109A 60 PUSH1 0xa0 109C 1B SHL 109D 03 SUB 109E 92 SWAP3 109F 83 DUP4 10A0 16 AND 10A1 94 SWAP5 10A2 81 DUP2 10A3 01 ADD 10A4 94 SWAP5 10A5 90 SWAP1 10A6 94 SWAP5 10A7 52 MSTORE 10A8 60 PUSH1 0x00 10AA 19 NOT 10AB 60 PUSH1 0x24 10AD 85 DUP6 10AE 01 ADD 10AF 52 MSTORE 10B0 51 MLOAD 10B1 91 SWAP2 10B2 16 AND 10B3 91 SWAP2 10B4 63 PUSH4 0x095ea7b3 10B9 91 SWAP2 10BA 60 PUSH1 0x44 10BC 80 DUP1 10BD 83 DUP4 10BE 01 ADD 10BF 92 SWAP3 10C0 60 PUSH1 0x20 10C2 92 SWAP3 10C3 91 SWAP2 10C4 90 SWAP1 10C5 82 DUP3 10C6 90 SWAP1 10C7 03 SUB 10C8 01 ADD 10C9 81 DUP2 10CA 60 PUSH1 0x00 10CC 87 DUP8 10CD 80 DUP1 10CE 3B EXTCODESIZE 10CF 15 ISZERO 10D0 80 DUP1 10D1 15 ISZERO 10D2 61 PUSH2 0x10da 10D5 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @1095 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x095ea7b3 << 0xe0 // @10A7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & storage[0x03] // @10AF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = ~0x00 // @10B3 stack[0] = storage[0x04] & (0x01 << 0xa0) - 0x01 // @10B9 stack[1] = 0x095ea7b3 // @10BF stack[2] = memory[0x40:0x60] + 0x44 // @10C2 stack[3] = 0x20 // @10C3 stack[4] = memory[0x40:0x60] // @10C8 stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @10C9 stack[6] = memory[0x40:0x60] // @10CA stack[7] = 0x00 // @10CC stack[8] = storage[0x04] & (0x01 << 0xa0) - 0x01 // @10CF stack[9] = !address(storage[0x04] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x10da, if !!address(storage[0x04] & (0x01 << 0xa0) - 0x01).code.length label_10D6: // Incoming jump from 0x10D5, if not !!address(storage[0x04] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @10D9 memory[0x00:0x00] } 10D6 60 PUSH1 0x00 10D8 80 DUP1 10D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @10D9 revert(memory[0x00:0x00]); } // Block terminates label_10DA: // Incoming jump from 0x10D5, if !!address(storage[0x04] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @10DC msg.gas // @10DD stack[-2] // @10DD stack[-7] // @10DD address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @10DD stack[-3] // @10DD stack[-6] // @10DD stack[-5] // @10DD memory[stack[-4]:stack[-4] + stack[-5]] // @10DD stack[-4] // } 10DA 5B JUMPDEST 10DB 50 POP 10DC 5A GAS 10DD F1 CALL 10DE 15 ISZERO 10DF 80 DUP1 10E0 15 ISZERO 10E1 61 PUSH2 0x10ee 10E4 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @10DD memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @10DE 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 0x10ee, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_10E5: // Incoming jump from 0x10E4, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @10E5 returndata.length // @10E9 returndata[0x00:0x00 + returndata.length] // @10EA returndata.length // @10ED memory[0x00:0x00 + returndata.length] // } 10E5 3D RETURNDATASIZE 10E6 60 PUSH1 0x00 10E8 80 DUP1 10E9 3E RETURNDATACOPY 10EA 3D RETURNDATASIZE 10EB 60 PUSH1 0x00 10ED FD *REVERT // Stack delta = +0 // Outputs[2] // { // @10E9 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @10ED revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_10EE: // Incoming jump from 0x10E4, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @10F5 memory[0x40:0x60] // @10F6 returndata.length // } 10EE 5B JUMPDEST 10EF 50 POP 10F0 50 POP 10F1 50 POP 10F2 50 POP 10F3 60 PUSH1 0x40 10F5 51 MLOAD 10F6 3D RETURNDATASIZE 10F7 60 PUSH1 0x20 10F9 81 DUP2 10FA 10 LT 10FB 15 ISZERO 10FC 61 PUSH2 0x1104 10FF 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @10F5 stack[-4] = memory[0x40:0x60] // @10F6 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1104, if !(returndata.length < 0x20) label_1100: // Incoming jump from 0x10FF, if not !(returndata.length < 0x20) // Inputs[1] { @1103 memory[0x00:0x00] } 1100 60 PUSH1 0x00 1102 80 DUP1 1103 FD *REVERT // Stack delta = +0 // Outputs[1] { @1103 revert(memory[0x00:0x00]); } // Block terminates label_1104: // Incoming jump from 0x10FF, if !(returndata.length < 0x20) // Inputs[1] { @1107 stack[-3] } 1104 5B JUMPDEST 1105 50 POP 1106 50 POP 1107 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_1108: // Incoming jump from 0x0AE7 // Inputs[7] // { // @1109 stack[-3] // @110A memory[stack[-3]:stack[-3] + 0x20] // @110D storage[0x03] // @1111 memory[0x40:0x60] // @111C address(this) // @1123 memory[0x40:0x60] // @1151 address((0x01 << 0xa0) - 0x01 & storage[0x03]).code.length // } 1108 5B JUMPDEST 1109 82 DUP3 110A 51 MLOAD 110B 60 PUSH1 0x03 110D 54 SLOAD 110E 60 PUSH1 0x40 1110 80 DUP1 1111 51 MLOAD 1112 63 PUSH4 0x70a08231 1117 60 PUSH1 0xe0 1119 1B SHL 111A 81 DUP2 111B 52 MSTORE 111C 30 ADDRESS 111D 60 PUSH1 0x04 111F 82 DUP3 1120 01 ADD 1121 52 MSTORE 1122 90 SWAP1 1123 51 MLOAD 1124 60 PUSH1 0x00 1126 19 NOT 1127 90 SWAP1 1128 93 SWAP4 1129 01 ADD 112A 92 SWAP3 112B 60 PUSH1 0x00 112D 92 SWAP3 112E 60 PUSH1 0x01 1130 60 PUSH1 0x01 1132 60 PUSH1 0xa0 1134 1B SHL 1135 03 SUB 1136 16 AND 1137 91 SWAP2 1138 63 PUSH4 0x70a08231 113D 91 SWAP2 113E 60 PUSH1 0x24 1140 80 DUP1 1141 83 DUP4 1142 01 ADD 1143 92 SWAP3 1144 60 PUSH1 0x20 1146 92 SWAP3 1147 91 SWAP2 1148 90 SWAP1 1149 82 DUP3 114A 90 SWAP1 114B 03 SUB 114C 01 ADD 114D 81 DUP2 114E 87 DUP8 114F 87 DUP8 1150 80 DUP1 1151 3B EXTCODESIZE 1152 15 ISZERO 1153 80 DUP1 1154 15 ISZERO 1155 61 PUSH2 0x115d 1158 57 *JUMPI // Stack delta = +12 // Outputs[14] // { // @111B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @1121 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @112A stack[0] = memory[stack[-3]:stack[-3] + 0x20] + ~0x00 // @112D stack[1] = 0x00 // @1137 stack[2] = (0x01 << 0xa0) - 0x01 & storage[0x03] // @113D stack[3] = 0x70a08231 // @1143 stack[4] = memory[0x40:0x60] + 0x24 // @1146 stack[5] = 0x20 // @1147 stack[6] = memory[0x40:0x60] // @114C stack[7] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @114D stack[8] = memory[0x40:0x60] // @114E stack[9] = 0x00 // @114F stack[10] = (0x01 << 0xa0) - 0x01 & storage[0x03] // @1152 stack[11] = !address((0x01 << 0xa0) - 0x01 & storage[0x03]).code.length // } // Block ends with conditional jump to 0x115d, if !!address((0x01 << 0xa0) - 0x01 & storage[0x03]).code.length label_1159: // Incoming jump from 0x1158, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x03]).code.length // Inputs[1] { @115C memory[0x00:0x00] } 1159 60 PUSH1 0x00 115B 80 DUP1 115C FD *REVERT // Stack delta = +0 // Outputs[1] { @115C revert(memory[0x00:0x00]); } // Block terminates label_115D: // Incoming jump from 0x1158, if !!address((0x01 << 0xa0) - 0x01 & storage[0x03]).code.length // Inputs[9] // { // @115F msg.gas // @1160 stack[-3] // @1160 stack[-7] // @1160 stack[-4] // @1160 stack[-6] // @1160 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1160 memory[stack[-4]:stack[-4] + stack[-5]] // @1160 stack[-2] // @1160 stack[-5] // } 115D 5B JUMPDEST 115E 50 POP 115F 5A GAS 1160 F1 CALL 1161 15 ISZERO 1162 80 DUP1 1163 15 ISZERO 1164 61 PUSH2 0x1171 1167 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1160 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1161 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 0x1171, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1168: // Incoming jump from 0x1167, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1168 returndata.length // @116C returndata[0x00:0x00 + returndata.length] // @116D returndata.length // @1170 memory[0x00:0x00 + returndata.length] // } 1168 3D RETURNDATASIZE 1169 60 PUSH1 0x00 116B 80 DUP1 116C 3E RETURNDATACOPY 116D 3D RETURNDATASIZE 116E 60 PUSH1 0x00 1170 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @116C memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1170 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1171: // Incoming jump from 0x1167, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1178 memory[0x40:0x60] // @1179 returndata.length // } 1171 5B JUMPDEST 1172 50 POP 1173 50 POP 1174 50 POP 1175 50 POP 1176 60 PUSH1 0x40 1178 51 MLOAD 1179 3D RETURNDATASIZE 117A 60 PUSH1 0x20 117C 81 DUP2 117D 10 LT 117E 15 ISZERO 117F 61 PUSH2 0x1187 1182 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1178 stack[-4] = memory[0x40:0x60] // @1179 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1187, if !(returndata.length < 0x20) label_1183: // Incoming jump from 0x1182, if not !(returndata.length < 0x20) // Inputs[1] { @1186 memory[0x00:0x00] } 1183 60 PUSH1 0x00 1185 80 DUP1 1186 FD *REVERT // Stack delta = +0 // Outputs[1] { @1186 revert(memory[0x00:0x00]); } // Block terminates label_1187: // Incoming jump from 0x1182, if !(returndata.length < 0x20) // Inputs[3] // { // @1189 stack[-2] // @1189 memory[stack[-2]:stack[-2] + 0x20] // @118A stack[-3] // } 1187 5B JUMPDEST 1188 50 POP 1189 51 MLOAD 118A 90 SWAP1 118B 50 POP 118C 80 DUP1 118D 15 ISZERO 118E 61 PUSH2 0x129b 1191 57 *JUMPI // Stack delta = -2 // Outputs[1] { @118A stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x129b, if !memory[stack[-2]:stack[-2] + 0x20] label_1192: // Incoming jump from 0x1191, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[5] // { // @1194 storage[0x03] // @1198 memory[0x40:0x60] // @11A7 stack[-1] // @11AB memory[0x40:0x60] // @11D2 address(storage[0x03] & (0x01 << 0xa0) - 0x01).code.length // } 1192 60 PUSH1 0x03 1194 54 SLOAD 1195 60 PUSH1 0x40 1197 80 DUP1 1198 51 MLOAD 1199 63 PUSH4 0x6f074d1f 119E 60 PUSH1 0xe1 11A0 1B SHL 11A1 81 DUP2 11A2 52 MSTORE 11A3 60 PUSH1 0x04 11A5 81 DUP2 11A6 01 ADD 11A7 84 DUP5 11A8 90 SWAP1 11A9 52 MSTORE 11AA 90 SWAP1 11AB 51 MLOAD 11AC 60 PUSH1 0x01 11AE 60 PUSH1 0x01 11B0 60 PUSH1 0xa0 11B2 1B SHL 11B3 03 SUB 11B4 90 SWAP1 11B5 92 SWAP3 11B6 16 AND 11B7 91 SWAP2 11B8 63 PUSH4 0xde0e9a3e 11BD 91 SWAP2 11BE 60 PUSH1 0x24 11C0 80 DUP1 11C1 82 DUP3 11C2 01 ADD 11C3 92 SWAP3 11C4 60 PUSH1 0x00 11C6 92 SWAP3 11C7 90 SWAP1 11C8 91 SWAP2 11C9 90 SWAP1 11CA 82 DUP3 11CB 90 SWAP1 11CC 03 SUB 11CD 01 ADD 11CE 81 DUP2 11CF 83 DUP4 11D0 87 DUP8 11D1 80 DUP1 11D2 3B EXTCODESIZE 11D3 15 ISZERO 11D4 80 DUP1 11D5 15 ISZERO 11D6 61 PUSH2 0x11de 11D9 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @11A2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f074d1f << 0xe1 // @11A9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-1] // @11B7 stack[0] = storage[0x03] & (0x01 << 0xa0) - 0x01 // @11BD stack[1] = 0xde0e9a3e // @11C3 stack[2] = memory[0x40:0x60] + 0x24 // @11C6 stack[3] = 0x00 // @11C8 stack[4] = memory[0x40:0x60] // @11CD stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @11CE stack[6] = memory[0x40:0x60] // @11CF stack[7] = 0x00 // @11D0 stack[8] = storage[0x03] & (0x01 << 0xa0) - 0x01 // @11D3 stack[9] = !address(storage[0x03] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x11de, if !!address(storage[0x03] & (0x01 << 0xa0) - 0x01).code.length label_11DA: // Incoming jump from 0x11D9, if not !!address(storage[0x03] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @11DD memory[0x00:0x00] } 11DA 60 PUSH1 0x00 11DC 80 DUP1 11DD FD *REVERT // Stack delta = +0 // Outputs[1] { @11DD revert(memory[0x00:0x00]); } // Block terminates label_11DE: // Incoming jump from 0x11D9, if !!address(storage[0x03] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @11E0 msg.gas // @11E1 stack[-4] // @11E1 stack[-5] // @11E1 stack[-7] // @11E1 stack[-6] // @11E1 memory[stack[-4]:stack[-4] + stack[-5]] // @11E1 stack[-3] // @11E1 stack[-2] // @11E1 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 11DE 5B JUMPDEST 11DF 50 POP 11E0 5A GAS 11E1 F1 CALL 11E2 15 ISZERO 11E3 80 DUP1 11E4 15 ISZERO 11E5 61 PUSH2 0x11f2 11E8 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @11E1 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @11E2 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 0x11f2, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_11E9: // Incoming jump from 0x11E8, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @11E9 returndata.length // @11ED returndata[0x00:0x00 + returndata.length] // @11EE returndata.length // @11F1 memory[0x00:0x00 + returndata.length] // } 11E9 3D RETURNDATASIZE 11EA 60 PUSH1 0x00 11EC 80 DUP1 11ED 3E RETURNDATACOPY 11EE 3D RETURNDATASIZE 11EF 60 PUSH1 0x00 11F1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @11ED memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @11F1 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_11F2: // Incoming jump from 0x11E8, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[5] // { // @11F7 storage[0x04] // @11F8 stack[-9] // @11F9 memory[stack[-9]:stack[-9] + 0x20] // @1205 stack[-4] // @120C stack[-3] // } 11F2 5B JUMPDEST 11F3 50 POP 11F4 50 POP 11F5 60 PUSH1 0x04 11F7 54 SLOAD 11F8 87 DUP8 11F9 51 MLOAD 11FA 60 PUSH1 0x01 11FC 60 PUSH1 0x01 11FE 60 PUSH1 0xa0 1200 1B SHL 1201 03 SUB 1202 90 SWAP1 1203 91 SWAP2 1204 16 AND 1205 92 SWAP3 1206 50 POP 1207 63 PUSH4 0xa9059cbb 120C 91 SWAP2 120D 50 POP 120E 87 DUP8 120F 90 SWAP1 1210 60 PUSH1 0x01 1212 90 SWAP1 1213 81 DUP2 1214 10 LT 1215 61 PUSH2 0x121a 1218 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1205 stack[-4] = storage[0x04] & (0x01 << 0xa0) - 0x01 // @120C stack[-3] = 0xa9059cbb // @120F stack[-2] = stack[-9] // @1212 stack[-1] = 0x01 // } // Block ends with conditional jump to 0x121a, if 0x01 < memory[stack[-9]:stack[-9] + 0x20] label_1219: // Incoming jump from 0x1218, if not 0x01 < memory[stack[-9]:stack[-9] + 0x20] 1219 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1219 assert(); } // Block terminates label_121A: // Incoming jump from 0x1218, if 0x01 < memory[stack[-9]:stack[-9] + 0x20] // Inputs[9] // { // @121D stack[-1] // @1221 stack[-2] // @1222 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1223 stack[-5] // @1226 memory[0x40:0x60] // @1227 stack[-3] // @1254 memory[0x40:0x60] // @125B stack[-4] // @125D address(stack[-4]).code.length // } 121A 5B JUMPDEST 121B 60 PUSH1 0x20 121D 02 MUL 121E 60 PUSH1 0x20 1220 01 ADD 1221 01 ADD 1222 51 MLOAD 1223 83 DUP4 1224 60 PUSH1 0x40 1226 51 MLOAD 1227 83 DUP4 1228 63 PUSH4 0xffffffff 122D 16 AND 122E 60 PUSH1 0xe0 1230 1B SHL 1231 81 DUP2 1232 52 MSTORE 1233 60 PUSH1 0x04 1235 01 ADD 1236 80 DUP1 1237 83 DUP4 1238 60 PUSH1 0x01 123A 60 PUSH1 0x01 123C 60 PUSH1 0xa0 123E 1B SHL 123F 03 SUB 1240 16 AND 1241 81 DUP2 1242 52 MSTORE 1243 60 PUSH1 0x20 1245 01 ADD 1246 82 DUP3 1247 81 DUP2 1248 52 MSTORE 1249 60 PUSH1 0x20 124B 01 ADD 124C 92 SWAP3 124D 50 POP 124E 50 POP 124F 50 POP 1250 60 PUSH1 0x20 1252 60 PUSH1 0x40 1254 51 MLOAD 1255 80 DUP1 1256 83 DUP4 1257 03 SUB 1258 81 DUP2 1259 60 PUSH1 0x00 125B 87 DUP8 125C 80 DUP1 125D 3B EXTCODESIZE 125E 15 ISZERO 125F 80 DUP1 1260 15 ISZERO 1261 61 PUSH2 0x1269 1264 57 *JUMPI // Stack delta = +6 // Outputs[11] // { // @1232 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-3]) << 0xe0 // @1242 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1248 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-5] // @124C stack[-2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1250 stack[-1] = 0x20 // @1254 stack[0] = memory[0x40:0x60] // @1257 stack[1] = (0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1258 stack[2] = memory[0x40:0x60] // @1259 stack[3] = 0x00 // @125B stack[4] = stack[-4] // @125E stack[5] = !address(stack[-4]).code.length // } // Block ends with conditional jump to 0x1269, if !!address(stack[-4]).code.length label_1265: // Incoming jump from 0x1264, if not !!address(stack[-4]).code.length // Inputs[1] { @1268 memory[0x00:0x00] } 1265 60 PUSH1 0x00 1267 80 DUP1 1268 FD *REVERT // Stack delta = +0 // Outputs[1] { @1268 revert(memory[0x00:0x00]); } // Block terminates label_1269: // Incoming jump from 0x1264, if !!address(stack[-4]).code.length // Inputs[9] // { // @126B msg.gas // @126C stack[-3] // @126C stack[-6] // @126C stack[-5] // @126C memory[stack[-4]:stack[-4] + stack[-5]] // @126C stack[-4] // @126C stack[-2] // @126C address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @126C stack[-7] // } 1269 5B JUMPDEST 126A 50 POP 126B 5A GAS 126C F1 CALL 126D 15 ISZERO 126E 80 DUP1 126F 15 ISZERO 1270 61 PUSH2 0x127d 1273 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @126C memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @126D 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 0x127d, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1274: // Incoming jump from 0x1273, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1274 returndata.length // @1278 returndata[0x00:0x00 + returndata.length] // @1279 returndata.length // @127C memory[0x00:0x00 + returndata.length] // } 1274 3D RETURNDATASIZE 1275 60 PUSH1 0x00 1277 80 DUP1 1278 3E RETURNDATACOPY 1279 3D RETURNDATASIZE 127A 60 PUSH1 0x00 127C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1278 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @127C revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_127D: // Incoming jump from 0x1273, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1284 memory[0x40:0x60] // @1285 returndata.length // } 127D 5B JUMPDEST 127E 50 POP 127F 50 POP 1280 50 POP 1281 50 POP 1282 60 PUSH1 0x40 1284 51 MLOAD 1285 3D RETURNDATASIZE 1286 60 PUSH1 0x20 1288 81 DUP2 1289 10 LT 128A 15 ISZERO 128B 61 PUSH2 0x1293 128E 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1284 stack[-4] = memory[0x40:0x60] // @1285 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1293, if !(returndata.length < 0x20) label_128F: // Incoming jump from 0x128E, if not !(returndata.length < 0x20) // Inputs[1] { @1292 memory[0x00:0x00] } 128F 60 PUSH1 0x00 1291 80 DUP1 1292 FD *REVERT // Stack delta = +0 // Outputs[1] { @1292 revert(memory[0x00:0x00]); } // Block terminates label_1293: // Incoming jump from 0x128E, if !(returndata.length < 0x20) // Inputs[1] { @1298 stack[-2] } 1293 5B JUMPDEST 1294 50 POP 1295 61 PUSH2 0x1449 1298 90 SWAP1 1299 50 POP 129A 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to 0x1449 label_129B: // Incoming jump from 0x1191, if !memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @129E stack[-4] // @12A2 memory[stack[-4]:stack[-4] + 0x20] // } 129B 5B JUMPDEST 129C 60 PUSH1 0x00 129E 84 DUP5 129F 60 PUSH1 0x00 12A1 81 DUP2 12A2 51 MLOAD 12A3 81 DUP2 12A4 10 LT 12A5 61 PUSH2 0x12aa 12A8 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @129C stack[0] = 0x00 // @129E stack[1] = stack[-4] // @129F stack[2] = 0x00 // } // Block ends with conditional jump to 0x12aa, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] label_12A9: // Incoming jump from 0x12A8, if not 0x00 < memory[stack[-4]:stack[-4] + 0x20] 12A9 FE *ASSERT // Stack delta = +0 // Outputs[1] { @12A9 assert(); } // Block terminates label_12AA: // Incoming jump from 0x12A8, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[3] // { // @12AD stack[-1] // @12B1 stack[-2] // @12B2 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 12AA 5B JUMPDEST 12AB 60 PUSH1 0x20 12AD 02 MUL 12AE 60 PUSH1 0x20 12B0 01 ADD 12B1 01 ADD 12B2 51 MLOAD 12B3 61 PUSH2 0x1334 12B6 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1334, if memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_12B7: // Incoming jump from 0x12B6, if not memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[2] // { // @12B7 stack[-6] // @12BB memory[stack[-6]:stack[-6] + 0x20] // } 12B7 85 DUP6 12B8 60 PUSH1 0x00 12BA 81 DUP2 12BB 51 MLOAD 12BC 81 DUP2 12BD 10 LT 12BE 61 PUSH2 0x12c3 12C1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @12B7 stack[0] = stack[-6] // @12B8 stack[1] = 0x00 // } // Block ends with conditional jump to 0x12c3, if 0x00 < memory[stack[-6]:stack[-6] + 0x20] label_12C2: // Incoming jump from 0x12C1, if not 0x00 < memory[stack[-6]:stack[-6] + 0x20] 12C2 FE *ASSERT // Stack delta = +0 // Outputs[1] { @12C2 assert(); } // Block terminates label_12C3: // Incoming jump from 0x12C1, if 0x00 < memory[stack[-6]:stack[-6] + 0x20] // Inputs[6] // { // @12C6 stack[-1] // @12CA stack[-2] // @12CB memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @12DC memory[0x40:0x60] // @12F0 memory[0x40:0x60] // @12F7 address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } 12C3 5B JUMPDEST 12C4 60 PUSH1 0x20 12C6 02 MUL 12C7 60 PUSH1 0x20 12C9 01 ADD 12CA 01 ADD 12CB 51 MLOAD 12CC 60 PUSH1 0x01 12CE 60 PUSH1 0x01 12D0 60 PUSH1 0xa0 12D2 1B SHL 12D3 03 SUB 12D4 16 AND 12D5 63 PUSH4 0xd21220a7 12DA 60 PUSH1 0x40 12DC 51 MLOAD 12DD 81 DUP2 12DE 63 PUSH4 0xffffffff 12E3 16 AND 12E4 60 PUSH1 0xe0 12E6 1B SHL 12E7 81 DUP2 12E8 52 MSTORE 12E9 60 PUSH1 0x04 12EB 01 ADD 12EC 60 PUSH1 0x20 12EE 60 PUSH1 0x40 12F0 51 MLOAD 12F1 80 DUP1 12F2 83 DUP4 12F3 03 SUB 12F4 81 DUP2 12F5 86 DUP7 12F6 80 DUP1 12F7 3B EXTCODESIZE 12F8 15 ISZERO 12F9 80 DUP1 12FA 15 ISZERO 12FB 61 PUSH2 0x1303 12FE 57 *JUMPI // Stack delta = +7 // Outputs[10] // { // @12D4 stack[-2] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @12D5 stack[-1] = 0xd21220a7 // @12E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xd21220a7) << 0xe0 // @12EB stack[0] = 0x04 + memory[0x40:0x60] // @12EC stack[1] = 0x20 // @12F0 stack[2] = memory[0x40:0x60] // @12F3 stack[3] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @12F4 stack[4] = memory[0x40:0x60] // @12F5 stack[5] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @12F8 stack[6] = !address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } // Block ends with conditional jump to 0x1303, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length label_12FF: // Incoming jump from 0x12FE, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[1] { @1302 memory[0x00:0x00] } 12FF 60 PUSH1 0x00 1301 80 DUP1 1302 FD *REVERT // Stack delta = +0 // Outputs[1] { @1302 revert(memory[0x00:0x00]); } // Block terminates label_1303: // Incoming jump from 0x12FE, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[8] // { // @1305 msg.gas // @1306 memory[stack[-3]:stack[-3] + stack[-4]] // @1306 stack[-4] // @1306 stack[-3] // @1306 stack[-5] // @1306 stack[-2] // @1306 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1306 stack[-6] // } 1303 5B JUMPDEST 1304 50 POP 1305 5A GAS 1306 FA STATICCALL 1307 15 ISZERO 1308 80 DUP1 1309 15 ISZERO 130A 61 PUSH2 0x1317 130D 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1306 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1307 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1317, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_130E: // Incoming jump from 0x130D, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @130E returndata.length // @1312 returndata[0x00:0x00 + returndata.length] // @1313 returndata.length // @1316 memory[0x00:0x00 + returndata.length] // } 130E 3D RETURNDATASIZE 130F 60 PUSH1 0x00 1311 80 DUP1 1312 3E RETURNDATACOPY 1313 3D RETURNDATASIZE 1314 60 PUSH1 0x00 1316 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1312 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1316 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1317: // Incoming jump from 0x130D, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @131E memory[0x40:0x60] // @131F returndata.length // } 1317 5B JUMPDEST 1318 50 POP 1319 50 POP 131A 50 POP 131B 50 POP 131C 60 PUSH1 0x40 131E 51 MLOAD 131F 3D RETURNDATASIZE 1320 60 PUSH1 0x20 1322 81 DUP2 1323 10 LT 1324 15 ISZERO 1325 61 PUSH2 0x132d 1328 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @131E stack[-4] = memory[0x40:0x60] // @131F stack[-3] = returndata.length // } // Block ends with conditional jump to 0x132d, if !(returndata.length < 0x20) label_1329: // Incoming jump from 0x1328, if not !(returndata.length < 0x20) // Inputs[1] { @132C memory[0x00:0x00] } 1329 60 PUSH1 0x00 132B 80 DUP1 132C FD *REVERT // Stack delta = +0 // Outputs[1] { @132C revert(memory[0x00:0x00]); } // Block terminates label_132D: // Incoming jump from 0x1328, if !(returndata.length < 0x20) // Inputs[2] // { // @132F memory[stack[-2]:stack[-2] + 0x20] // @132F stack[-2] // } 132D 5B JUMPDEST 132E 50 POP 132F 51 MLOAD 1330 61 PUSH2 0x13ae 1333 56 *JUMP // Stack delta = -1 // Outputs[1] { @132F stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x13ae label_1334: // Incoming jump from 0x12B6, if memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[2] // { // @1335 stack[-6] // @1339 memory[stack[-6]:stack[-6] + 0x20] // } 1334 5B JUMPDEST 1335 85 DUP6 1336 60 PUSH1 0x00 1338 81 DUP2 1339 51 MLOAD 133A 81 DUP2 133B 10 LT 133C 61 PUSH2 0x1341 133F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1335 stack[0] = stack[-6] // @1336 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1341, if 0x00 < memory[stack[-6]:stack[-6] + 0x20] label_1340: // Incoming jump from 0x133F, if not 0x00 < memory[stack[-6]:stack[-6] + 0x20] 1340 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1340 assert(); } // Block terminates label_1341: // Incoming jump from 0x133F, if 0x00 < memory[stack[-6]:stack[-6] + 0x20] // Inputs[6] // { // @1344 stack[-1] // @1348 stack[-2] // @1349 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @135A memory[0x40:0x60] // @136E memory[0x40:0x60] // @1375 address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } 1341 5B JUMPDEST 1342 60 PUSH1 0x20 1344 02 MUL 1345 60 PUSH1 0x20 1347 01 ADD 1348 01 ADD 1349 51 MLOAD 134A 60 PUSH1 0x01 134C 60 PUSH1 0x01 134E 60 PUSH1 0xa0 1350 1B SHL 1351 03 SUB 1352 16 AND 1353 63 PUSH4 0x0dfe1681 1358 60 PUSH1 0x40 135A 51 MLOAD 135B 81 DUP2 135C 63 PUSH4 0xffffffff 1361 16 AND 1362 60 PUSH1 0xe0 1364 1B SHL 1365 81 DUP2 1366 52 MSTORE 1367 60 PUSH1 0x04 1369 01 ADD 136A 60 PUSH1 0x20 136C 60 PUSH1 0x40 136E 51 MLOAD 136F 80 DUP1 1370 83 DUP4 1371 03 SUB 1372 81 DUP2 1373 86 DUP7 1374 80 DUP1 1375 3B EXTCODESIZE 1376 15 ISZERO 1377 80 DUP1 1378 15 ISZERO 1379 61 PUSH2 0x1381 137C 57 *JUMPI // Stack delta = +7 // Outputs[10] // { // @1352 stack[-2] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1353 stack[-1] = 0x0dfe1681 // @1366 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x0dfe1681) << 0xe0 // @1369 stack[0] = 0x04 + memory[0x40:0x60] // @136A stack[1] = 0x20 // @136E stack[2] = memory[0x40:0x60] // @1371 stack[3] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1372 stack[4] = memory[0x40:0x60] // @1373 stack[5] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1376 stack[6] = !address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } // Block ends with conditional jump to 0x1381, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length label_137D: // Incoming jump from 0x137C, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[1] { @1380 memory[0x00:0x00] } 137D 60 PUSH1 0x00 137F 80 DUP1 1380 FD *REVERT // Stack delta = +0 // Outputs[1] { @1380 revert(memory[0x00:0x00]); } // Block terminates label_1381: // Incoming jump from 0x137C, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[8] // { // @1383 msg.gas // @1384 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1384 memory[stack[-3]:stack[-3] + stack[-4]] // @1384 stack[-4] // @1384 stack[-5] // @1384 stack[-6] // @1384 stack[-2] // @1384 stack[-3] // } 1381 5B JUMPDEST 1382 50 POP 1383 5A GAS 1384 FA STATICCALL 1385 15 ISZERO 1386 80 DUP1 1387 15 ISZERO 1388 61 PUSH2 0x1395 138B 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1384 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1385 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1395, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_138C: // Incoming jump from 0x138B, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @138C returndata.length // @1390 returndata[0x00:0x00 + returndata.length] // @1391 returndata.length // @1394 memory[0x00:0x00 + returndata.length] // } 138C 3D RETURNDATASIZE 138D 60 PUSH1 0x00 138F 80 DUP1 1390 3E RETURNDATACOPY 1391 3D RETURNDATASIZE 1392 60 PUSH1 0x00 1394 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1390 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1394 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1395: // Incoming jump from 0x138B, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @139C memory[0x40:0x60] // @139D returndata.length // } 1395 5B JUMPDEST 1396 50 POP 1397 50 POP 1398 50 POP 1399 50 POP 139A 60 PUSH1 0x40 139C 51 MLOAD 139D 3D RETURNDATASIZE 139E 60 PUSH1 0x20 13A0 81 DUP2 13A1 10 LT 13A2 15 ISZERO 13A3 61 PUSH2 0x13ab 13A6 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @139C stack[-4] = memory[0x40:0x60] // @139D stack[-3] = returndata.length // } // Block ends with conditional jump to 0x13ab, if !(returndata.length < 0x20) label_13A7: // Incoming jump from 0x13A6, if not !(returndata.length < 0x20) // Inputs[1] { @13AA memory[0x00:0x00] } 13A7 60 PUSH1 0x00 13A9 80 DUP1 13AA FD *REVERT // Stack delta = +0 // Outputs[1] { @13AA revert(memory[0x00:0x00]); } // Block terminates label_13AB: // Incoming jump from 0x13A6, if !(returndata.length < 0x20) // Inputs[5] // { // @13AD memory[stack[-2]:stack[-2] + 0x20] // @13AD stack[-2] // @13AF stack[-3] // @13B5 stack[-8] // @13B9 memory[stack[-8]:stack[-8] + 0x20] // } 13AB 5B JUMPDEST 13AC 50 POP 13AD 51 MLOAD 13AE 5B JUMPDEST 13AF 90 SWAP1 13B0 50 POP 13B1 61 PUSH2 0x1447 13B4 81 DUP2 13B5 87 DUP8 13B6 60 PUSH1 0x01 13B8 81 DUP2 13B9 51 MLOAD 13BA 81 DUP2 13BB 10 LT 13BC 61 PUSH2 0x13c1 13BF 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @13AF stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @13B1 stack[-2] = 0x1447 // @13B4 stack[-1] = memory[stack[-2]:stack[-2] + 0x20] // @13B5 stack[0] = stack[-8] // @13B6 stack[1] = 0x01 // } // Block ends with conditional call to 0x13c1, returns to 0x1447, if 0x01 < memory[stack[-8]:stack[-8] + 0x20] label_13C0: // Incoming jump from 0x13BF, if not 0x01 < memory[stack[-8]:stack[-8] + 0x20] // Incoming jump from 0x13BF, if not 0x01 < memory[stack[-7]:stack[-7] + 0x20] 13C0 FE *ASSERT // Stack delta = +0 // Outputs[1] { @13C0 assert(); } // Block terminates label_13C1: // Incoming call from 0x13BF, returns to 0x1447, if 0x01 < memory[stack[-8]:stack[-8] + 0x20] // Incoming call from 0x13BF, returns to 0x1447, if 0x01 < memory[stack[-7]:stack[-7] + 0x20] // Inputs[8] // { // @13C4 stack[-1] // @13C8 stack[-2] // @13C9 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @13CA stack[-5] // @13D9 address(this) // @13DC memory[0x40:0x60] // @1403 memory[0x40:0x60] // @140A address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // } 13C1 5B JUMPDEST 13C2 60 PUSH1 0x20 13C4 02 MUL 13C5 60 PUSH1 0x20 13C7 01 ADD 13C8 01 ADD 13C9 51 MLOAD 13CA 83 DUP4 13CB 60 PUSH1 0x01 13CD 60 PUSH1 0x01 13CF 60 PUSH1 0xa0 13D1 1B SHL 13D2 03 SUB 13D3 16 AND 13D4 63 PUSH4 0x70a08231 13D9 30 ADDRESS 13DA 60 PUSH1 0x40 13DC 51 MLOAD 13DD 82 DUP3 13DE 63 PUSH4 0xffffffff 13E3 16 AND 13E4 60 PUSH1 0xe0 13E6 1B SHL 13E7 81 DUP2 13E8 52 MSTORE 13E9 60 PUSH1 0x04 13EB 01 ADD 13EC 80 DUP1 13ED 82 DUP3 13EE 60 PUSH1 0x01 13F0 60 PUSH1 0x01 13F2 60 PUSH1 0xa0 13F4 1B SHL 13F5 03 SUB 13F6 16 AND 13F7 81 DUP2 13F8 52 MSTORE 13F9 60 PUSH1 0x20 13FB 01 ADD 13FC 91 SWAP2 13FD 50 POP 13FE 50 POP 13FF 60 PUSH1 0x20 1401 60 PUSH1 0x40 1403 51 MLOAD 1404 80 DUP1 1405 83 DUP4 1406 03 SUB 1407 81 DUP2 1408 86 DUP7 1409 80 DUP1 140A 3B EXTCODESIZE 140B 15 ISZERO 140C 80 DUP1 140D 15 ISZERO 140E 61 PUSH2 0x1416 1411 57 *JUMPI // Stack delta = +8 // Outputs[12] // { // @13C9 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @13D3 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] // @13D4 stack[0] = 0x70a08231 // @13E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x70a08231) << 0xe0 // @13F8 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & address(this) // @13FC stack[1] = 0x20 + 0x04 + memory[0x40:0x60] // @13FF stack[2] = 0x20 // @1403 stack[3] = memory[0x40:0x60] // @1406 stack[4] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1407 stack[5] = memory[0x40:0x60] // @1408 stack[6] = (0x01 << 0xa0) - 0x01 & stack[-5] // @140B stack[7] = !address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // } // Block ends with conditional jump to 0x1416, if !!address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length label_1412: // Incoming jump from 0x1411, if not !!address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // Inputs[1] { @1415 memory[0x00:0x00] } 1412 60 PUSH1 0x00 1414 80 DUP1 1415 FD *REVERT // Stack delta = +0 // Outputs[1] { @1415 revert(memory[0x00:0x00]); } // Block terminates label_1416: // Incoming jump from 0x1411, if !!address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // Inputs[8] // { // @1418 msg.gas // @1419 stack[-5] // @1419 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1419 stack[-4] // @1419 stack[-2] // @1419 stack[-6] // @1419 memory[stack[-3]:stack[-3] + stack[-4]] // @1419 stack[-3] // } 1416 5B JUMPDEST 1417 50 POP 1418 5A GAS 1419 FA STATICCALL 141A 15 ISZERO 141B 80 DUP1 141C 15 ISZERO 141D 61 PUSH2 0x142a 1420 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1419 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @141A stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x142a, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1421: // Incoming jump from 0x1420, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1421 returndata.length // @1425 returndata[0x00:0x00 + returndata.length] // @1426 returndata.length // @1429 memory[0x00:0x00 + returndata.length] // } 1421 3D RETURNDATASIZE 1422 60 PUSH1 0x00 1424 80 DUP1 1425 3E RETURNDATACOPY 1426 3D RETURNDATASIZE 1427 60 PUSH1 0x00 1429 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1425 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1429 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_142A: // Incoming jump from 0x1420, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1431 memory[0x40:0x60] // @1432 returndata.length // } 142A 5B JUMPDEST 142B 50 POP 142C 50 POP 142D 50 POP 142E 50 POP 142F 60 PUSH1 0x40 1431 51 MLOAD 1432 3D RETURNDATASIZE 1433 60 PUSH1 0x20 1435 81 DUP2 1436 10 LT 1437 15 ISZERO 1438 61 PUSH2 0x1440 143B 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1431 stack[-4] = memory[0x40:0x60] // @1432 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1440, if !(returndata.length < 0x20) label_143C: // Incoming jump from 0x143B, if not !(returndata.length < 0x20) // Inputs[1] { @143F memory[0x00:0x00] } 143C 60 PUSH1 0x00 143E 80 DUP1 143F FD *REVERT // Stack delta = +0 // Outputs[1] { @143F revert(memory[0x00:0x00]); } // Block terminates label_1440: // Incoming jump from 0x143B, if !(returndata.length < 0x20) // Inputs[2] // { // @1442 memory[stack[-2]:stack[-2] + 0x20] // @1442 stack[-2] // } 1440 5B JUMPDEST 1441 50 POP 1442 51 MLOAD 1443 61 PUSH2 0x2ac9 1446 56 *JUMP // Stack delta = -1 // Outputs[1] { @1442 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2ac9 label_1447: // Incoming return from call to 0x13C1 at 0x13BF // Incoming return from call to 0x13C1 at 0x13BF 1447 5B JUMPDEST 1448 50 POP // Stack delta = -1 // Block continues label_1449: // Incoming jump from 0x129A // Incoming jump from 0x1448 // Inputs[1] { @144D stack[-2] } 1449 5B JUMPDEST 144A 60 PUSH1 0x01 144C 5B JUMPDEST 144D 82 DUP3 144E 60 PUSH1 0x01 1450 01 ADD 1451 81 DUP2 1452 10 LT 1453 15 ISZERO 1454 61 PUSH2 0x171c 1457 57 *JUMPI // Stack delta = +1 // Outputs[1] { @144A stack[0] = 0x01 } // Block ends with conditional jump to 0x171c, if !(0x01 < 0x01 + stack[-2]) label_1458: // Incoming jump from 0x1457, if not !(0x01 < 0x01 + stack[-2]) // Incoming jump from 0x1457, if not !(stack[-1] < 0x01 + stack[-3]) // Inputs[4] // { // @145A storage[0x01] // @145B stack[-6] // @145C memory[stack[-6]:stack[-6] + 0x20] // @146C stack[-1] // } 1458 60 PUSH1 0x01 145A 54 SLOAD 145B 86 DUP7 145C 51 MLOAD 145D 60 PUSH1 0x00 145F 91 SWAP2 1460 60 PUSH1 0x01 1462 60 PUSH1 0x01 1464 60 PUSH1 0xa0 1466 1B SHL 1467 03 SUB 1468 16 AND 1469 90 SWAP1 146A 88 DUP9 146B 90 SWAP1 146C 84 DUP5 146D 90 SWAP1 146E 81 DUP2 146F 10 LT 1470 61 PUSH2 0x1475 1473 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @145F stack[0] = 0x00 // @1469 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x01] // @146B stack[2] = stack[-6] // @146D stack[3] = stack[-1] // } // Block ends with conditional jump to 0x1475, if stack[-1] < memory[stack[-6]:stack[-6] + 0x20] label_1474: // Incoming jump from 0x1473, if not stack[-1] < memory[stack[-6]:stack[-6] + 0x20] 1474 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1474 assert(); } // Block terminates label_1475: // Incoming jump from 0x1473, if stack[-1] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[5] // { // @1478 stack[-1] // @147C stack[-2] // @147D memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1487 stack[-3] // @1488 stack[-4] // } 1475 5B JUMPDEST 1476 60 PUSH1 0x20 1478 02 MUL 1479 60 PUSH1 0x20 147B 01 ADD 147C 01 ADD 147D 51 MLOAD 147E 60 PUSH1 0x01 1480 60 PUSH1 0x01 1482 60 PUSH1 0xa0 1484 1B SHL 1485 03 SUB 1486 16 AND 1487 14 EQ 1488 90 SWAP1 1489 50 POP 148A 80 DUP1 148B 80 DUP1 148C 15 ISZERO 148D 61 PUSH2 0x14a6 1490 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1488 stack[-4] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] == stack[-3] // @148A stack[-3] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] == stack[-3] // } // Block ends with conditional jump to 0x14a6, if !((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] == stack[-3]) label_1491: // Incoming jump from 0x1490, if not !((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] == stack[-3]) // Inputs[3] // { // @1492 stack[-7] // @1493 stack[-3] // @1495 memory[stack[-7]:stack[-7] + 0x20] // } 1491 50 POP 1492 85 DUP6 1493 82 DUP3 1494 81 DUP2 1495 51 MLOAD 1496 81 DUP2 1497 10 LT 1498 61 PUSH2 0x149d 149B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1492 stack[-1] = stack[-7] // @1493 stack[0] = stack[-3] // } // Block ends with conditional jump to 0x149d, if stack[-3] < memory[stack[-7]:stack[-7] + 0x20] label_149C: // Incoming jump from 0x149B, if not stack[-3] < memory[stack[-7]:stack[-7] + 0x20] 149C FE *ASSERT // Stack delta = +0 // Outputs[1] { @149C assert(); } // Block terminates label_149D: // Incoming jump from 0x149B, if stack[-3] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[3] // { // @14A0 stack[-1] // @14A4 stack[-2] // @14A5 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 149D 5B JUMPDEST 149E 60 PUSH1 0x20 14A0 02 MUL 14A1 60 PUSH1 0x20 14A3 01 ADD 14A4 01 ADD 14A5 51 MLOAD // Stack delta = -1 // Outputs[1] { @14A5 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block continues label_14A6: // Incoming jump from 0x14A5 // Incoming jump from 0x1490, if !((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] == stack[-3]) // Inputs[1] { @14A7 stack[-1] } 14A6 5B JUMPDEST 14A7 15 ISZERO 14A8 61 PUSH2 0x1596 14AB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1596, if !stack[-1] label_14AC: // Incoming jump from 0x14AB, if not !stack[-1] // Inputs[5] // { // @14AF storage[0x04] // @14B3 memory[0x40:0x60] // @14BE address(this) // @14C6 memory[0x40:0x60] // @14EE address(storage[0x04] & (0x01 << 0xa0) - 0x01).code.length // } 14AC 60 PUSH1 0x04 14AE 80 DUP1 14AF 54 SLOAD 14B0 60 PUSH1 0x40 14B2 80 DUP1 14B3 51 MLOAD 14B4 63 PUSH4 0x70a08231 14B9 60 PUSH1 0xe0 14BB 1B SHL 14BC 81 DUP2 14BD 52 MSTORE 14BE 30 ADDRESS 14BF 93 SWAP4 14C0 81 DUP2 14C1 01 ADD 14C2 93 SWAP4 14C3 90 SWAP1 14C4 93 SWAP4 14C5 52 MSTORE 14C6 51 MLOAD 14C7 60 PUSH1 0x00 14C9 92 SWAP3 14CA 60 PUSH1 0x01 14CC 60 PUSH1 0x01 14CE 60 PUSH1 0xa0 14D0 1B SHL 14D1 03 SUB 14D2 90 SWAP1 14D3 92 SWAP3 14D4 16 AND 14D5 91 SWAP2 14D6 63 PUSH4 0x70a08231 14DB 91 SWAP2 14DC 60 PUSH1 0x24 14DE 80 DUP1 14DF 83 DUP4 14E0 01 ADD 14E1 92 SWAP3 14E2 60 PUSH1 0x20 14E4 92 SWAP3 14E5 91 SWAP2 14E6 90 SWAP1 14E7 82 DUP3 14E8 90 SWAP1 14E9 03 SUB 14EA 01 ADD 14EB 81 DUP2 14EC 86 DUP7 14ED 80 DUP1 14EE 3B EXTCODESIZE 14EF 15 ISZERO 14F0 80 DUP1 14F1 15 ISZERO 14F2 61 PUSH2 0x14fa 14F5 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @14BD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @14C5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @14C9 stack[0] = 0x00 // @14D5 stack[1] = storage[0x04] & (0x01 << 0xa0) - 0x01 // @14DB stack[2] = 0x70a08231 // @14E1 stack[3] = memory[0x40:0x60] + 0x24 // @14E4 stack[4] = 0x20 // @14E5 stack[5] = memory[0x40:0x60] // @14EA stack[6] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @14EB stack[7] = memory[0x40:0x60] // @14EC stack[8] = storage[0x04] & (0x01 << 0xa0) - 0x01 // @14EF stack[9] = !address(storage[0x04] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x14fa, if !!address(storage[0x04] & (0x01 << 0xa0) - 0x01).code.length label_14F6: // Incoming jump from 0x14F5, if not !!address(storage[0x04] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @14F9 memory[0x00:0x00] } 14F6 60 PUSH1 0x00 14F8 80 DUP1 14F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @14F9 revert(memory[0x00:0x00]); } // Block terminates label_14FA: // Incoming jump from 0x14F5, if !!address(storage[0x04] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @14FC msg.gas // @14FD stack[-4] // @14FD address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @14FD stack[-2] // @14FD stack[-3] // @14FD memory[stack[-3]:stack[-3] + stack[-4]] // @14FD stack[-6] // @14FD stack[-5] // } 14FA 5B JUMPDEST 14FB 50 POP 14FC 5A GAS 14FD FA STATICCALL 14FE 15 ISZERO 14FF 80 DUP1 1500 15 ISZERO 1501 61 PUSH2 0x150e 1504 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @14FD memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @14FE stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x150e, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1505: // Incoming jump from 0x1504, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1505 returndata.length // @1509 returndata[0x00:0x00 + returndata.length] // @150A returndata.length // @150D memory[0x00:0x00 + returndata.length] // } 1505 3D RETURNDATASIZE 1506 60 PUSH1 0x00 1508 80 DUP1 1509 3E RETURNDATACOPY 150A 3D RETURNDATASIZE 150B 60 PUSH1 0x00 150D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1509 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @150D revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_150E: // Incoming jump from 0x1504, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1515 memory[0x40:0x60] // @1516 returndata.length // } 150E 5B JUMPDEST 150F 50 POP 1510 50 POP 1511 50 POP 1512 50 POP 1513 60 PUSH1 0x40 1515 51 MLOAD 1516 3D RETURNDATASIZE 1517 60 PUSH1 0x20 1519 81 DUP2 151A 10 LT 151B 15 ISZERO 151C 61 PUSH2 0x1524 151F 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1515 stack[-4] = memory[0x40:0x60] // @1516 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1524, if !(returndata.length < 0x20) label_1520: // Incoming jump from 0x151F, if not !(returndata.length < 0x20) // Inputs[1] { @1523 memory[0x00:0x00] } 1520 60 PUSH1 0x00 1522 80 DUP1 1523 FD *REVERT // Stack delta = +0 // Outputs[1] { @1523 revert(memory[0x00:0x00]); } // Block terminates label_1524: // Incoming jump from 0x151F, if !(returndata.length < 0x20) // Inputs[8] // { // @1526 stack[-2] // @1526 memory[stack[-2]:stack[-2] + 0x20] // @1529 storage[0x03] // @152D memory[0x40:0x60] // @1538 address(this) // @1546 memory[0x40:0x60] // @1548 stack[-3] // @1570 address(storage[0x03] & (0x01 << 0xa0) - 0x01).code.length // } 1524 5B JUMPDEST 1525 50 POP 1526 51 MLOAD 1527 60 PUSH1 0x03 1529 54 SLOAD 152A 60 PUSH1 0x40 152C 80 DUP1 152D 51 MLOAD 152E 63 PUSH4 0x5f9bb63d 1533 60 PUSH1 0xe1 1535 1B SHL 1536 81 DUP2 1537 52 MSTORE 1538 30 ADDRESS 1539 60 PUSH1 0x04 153B 82 DUP3 153C 01 ADD 153D 52 MSTORE 153E 60 PUSH1 0x24 1540 81 DUP2 1541 01 ADD 1542 84 DUP5 1543 90 SWAP1 1544 52 MSTORE 1545 90 SWAP1 1546 51 MLOAD 1547 92 SWAP3 1548 93 SWAP4 1549 50 POP 154A 60 PUSH1 0x01 154C 60 PUSH1 0x01 154E 60 PUSH1 0xa0 1550 1B SHL 1551 03 SUB 1552 90 SWAP1 1553 91 SWAP2 1554 16 AND 1555 91 SWAP2 1556 63 PUSH4 0xbf376c7a 155B 91 SWAP2 155C 60 PUSH1 0x44 155E 80 DUP1 155F 82 DUP3 1560 01 ADD 1561 92 SWAP3 1562 60 PUSH1 0x00 1564 92 SWAP3 1565 90 SWAP1 1566 91 SWAP2 1567 90 SWAP1 1568 82 DUP3 1569 90 SWAP1 156A 03 SUB 156B 01 ADD 156C 81 DUP2 156D 83 DUP4 156E 87 DUP8 156F 80 DUP1 1570 3B EXTCODESIZE 1571 15 ISZERO 1572 80 DUP1 1573 15 ISZERO 1574 61 PUSH2 0x157c 1577 57 *JUMPI // Stack delta = +8 // Outputs[14] // { // @1537 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5f9bb63d << 0xe1 // @153D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @1544 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @1548 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @1555 stack[-2] = storage[0x03] & (0x01 << 0xa0) - 0x01 // @155B stack[-1] = 0xbf376c7a // @1561 stack[0] = memory[0x40:0x60] + 0x44 // @1564 stack[1] = 0x00 // @1566 stack[2] = memory[0x40:0x60] // @156B stack[3] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @156C stack[4] = memory[0x40:0x60] // @156D stack[5] = 0x00 // @156E stack[6] = storage[0x03] & (0x01 << 0xa0) - 0x01 // @1571 stack[7] = !address(storage[0x03] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x157c, if !!address(storage[0x03] & (0x01 << 0xa0) - 0x01).code.length label_1578: // Incoming jump from 0x1577, if not !!address(storage[0x03] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @157B memory[0x00:0x00] } 1578 60 PUSH1 0x00 157A 80 DUP1 157B FD *REVERT // Stack delta = +0 // Outputs[1] { @157B revert(memory[0x00:0x00]); } // Block terminates label_157C: // Incoming jump from 0x1577, if !!address(storage[0x03] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @157E msg.gas // @157F stack[-6] // @157F stack[-4] // @157F address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @157F stack[-3] // @157F stack[-5] // @157F memory[stack[-4]:stack[-4] + stack[-5]] // @157F stack[-2] // @157F stack[-7] // } 157C 5B JUMPDEST 157D 50 POP 157E 5A GAS 157F F1 CALL 1580 15 ISZERO 1581 80 DUP1 1582 15 ISZERO 1583 61 PUSH2 0x1590 1586 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @157F memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1580 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 0x1590, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1587: // Incoming jump from 0x1586, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1587 returndata.length // @158B returndata[0x00:0x00 + returndata.length] // @158C returndata.length // @158F memory[0x00:0x00 + returndata.length] // } 1587 3D RETURNDATASIZE 1588 60 PUSH1 0x00 158A 80 DUP1 158B 3E RETURNDATACOPY 158C 3D RETURNDATASIZE 158D 60 PUSH1 0x00 158F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @158B memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @158F revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1590: // Incoming jump from 0x1586, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) 1590 5B JUMPDEST 1591 50 POP 1592 50 POP 1593 50 POP 1594 50 POP 1595 50 POP // Stack delta = -5 // Block continues label_1596: // Incoming jump from 0x14AB, if !stack[-1] // Incoming jump from 0x1595 // Inputs[3] // { // @159A stack[-7] // @159B stack[-2] // @159D memory[stack[-7]:stack[-7] + 0x20] // } 1596 5B JUMPDEST 1597 61 PUSH2 0x1602 159A 87 DUP8 159B 83 DUP4 159C 81 DUP2 159D 51 MLOAD 159E 81 DUP2 159F 10 LT 15A0 61 PUSH2 0x15a5 15A3 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1597 stack[0] = 0x1602 // @159A stack[1] = stack[-7] // @159B stack[2] = stack[-2] // } // Block ends with conditional call to 0x15a5, returns to 0x1602, if stack[-2] < memory[stack[-7]:stack[-7] + 0x20] label_15A4: // Incoming jump from 0x15A3, if not stack[-2] < memory[stack[-7]:stack[-7] + 0x20] 15A4 FE *ASSERT // Stack delta = +0 // Outputs[1] { @15A4 assert(); } // Block terminates label_15A5: // Incoming call from 0x15A3, returns to 0x1602, if stack[-2] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[6] // { // @15A8 stack[-1] // @15AC stack[-2] // @15AD memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @15AE stack[-8] // @15B1 stack[-5] // @15B4 memory[stack[-8]:stack[-8] + 0x20] // } 15A5 5B JUMPDEST 15A6 60 PUSH1 0x20 15A8 02 MUL 15A9 60 PUSH1 0x20 15AB 01 ADD 15AC 01 ADD 15AD 51 MLOAD 15AE 86 DUP7 15AF 60 PUSH1 0x01 15B1 85 DUP6 15B2 03 SUB 15B3 81 DUP2 15B4 51 MLOAD 15B5 81 DUP2 15B6 10 LT 15B7 61 PUSH2 0x15bc 15BA 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @15AD stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @15AE stack[-1] = stack[-8] // @15B2 stack[0] = stack[-5] - 0x01 // } // Block ends with conditional jump to 0x15bc, if stack[-5] - 0x01 < memory[stack[-8]:stack[-8] + 0x20] label_15BB: // Incoming jump from 0x15BA, if not stack[-5] - 0x01 < memory[stack[-8]:stack[-8] + 0x20] 15BB FE *ASSERT // Stack delta = +0 // Outputs[1] { @15BB assert(); } // Block terminates label_15BC: // Incoming jump from 0x15BA, if stack[-5] - 0x01 < memory[stack[-8]:stack[-8] + 0x20] // Inputs[6] // { // @15BF stack[-1] // @15C3 stack[-2] // @15C4 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @15C5 stack[-10] // @15C6 stack[-6] // @15C8 memory[stack[-10]:stack[-10] + 0x20] // } 15BC 5B JUMPDEST 15BD 60 PUSH1 0x20 15BF 02 MUL 15C0 60 PUSH1 0x20 15C2 01 ADD 15C3 01 ADD 15C4 51 MLOAD 15C5 88 DUP9 15C6 85 DUP6 15C7 81 DUP2 15C8 51 MLOAD 15C9 81 DUP2 15CA 10 LT 15CB 61 PUSH2 0x15d0 15CE 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @15C4 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @15C5 stack[-1] = stack[-10] // @15C6 stack[0] = stack[-6] // } // Block ends with conditional jump to 0x15d0, if stack[-6] < memory[stack[-10]:stack[-10] + 0x20] label_15CF: // Incoming jump from 0x15CE, if not stack[-6] < memory[stack[-10]:stack[-10] + 0x20] 15CF FE *ASSERT // Stack delta = +0 // Outputs[1] { @15CF assert(); } // Block terminates label_15D0: // Incoming jump from 0x15CE, if stack[-6] < memory[stack[-10]:stack[-10] + 0x20] // Inputs[5] // { // @15D3 stack[-1] // @15D7 stack[-2] // @15D8 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @15D9 stack[-9] // @15DA stack[-7] // } 15D0 5B JUMPDEST 15D1 60 PUSH1 0x20 15D3 02 MUL 15D4 60 PUSH1 0x20 15D6 01 ADD 15D7 01 ADD 15D8 51 MLOAD 15D9 87 DUP8 15DA 86 DUP7 15DB 14 EQ 15DC 61 PUSH2 0x15fb 15DF 57 *JUMPI // Stack delta = -1 // Outputs[1] { @15D8 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with conditional jump to 0x15fb, if stack[-7] == stack[-9] label_15E0: // Incoming jump from 0x15DF, if not stack[-7] == stack[-9] // Inputs[3] // { // @15E0 stack[-11] // @15E1 stack[-6] // @15E6 memory[stack[-11]:stack[-11] + 0x20] // } 15E0 8A DUP11 15E1 86 DUP7 15E2 60 PUSH1 0x01 15E4 01 ADD 15E5 81 DUP2 15E6 51 MLOAD 15E7 81 DUP2 15E8 10 LT 15E9 61 PUSH2 0x15ee 15EC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @15E0 stack[0] = stack[-11] // @15E4 stack[1] = 0x01 + stack[-6] // } // Block ends with conditional jump to 0x15ee, if 0x01 + stack[-6] < memory[stack[-11]:stack[-11] + 0x20] label_15ED: // Incoming jump from 0x15EC, if not 0x01 + stack[-6] < memory[stack[-11]:stack[-11] + 0x20] 15ED FE *ASSERT // Stack delta = +0 // Outputs[1] { @15ED assert(); } // Block terminates label_15EE: // Incoming jump from 0x1C33, if 0x01 + stack[-5] < memory[stack[-10]:stack[-10] + 0x20] // Incoming jump from 0x15EC, if 0x01 + stack[-6] < memory[stack[-11]:stack[-11] + 0x20] // Inputs[3] // { // @15F1 stack[-1] // @15F5 stack[-2] // @15F6 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 15EE 5B JUMPDEST 15EF 60 PUSH1 0x20 15F1 02 MUL 15F2 60 PUSH1 0x20 15F4 01 ADD 15F5 01 ADD 15F6 51 MLOAD 15F7 61 PUSH2 0x15fd 15FA 56 *JUMP // Stack delta = -1 // Outputs[1] { @15F6 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x15fd label_15FB: // Incoming jump from 0x1C26, if stack[-6] == stack[-8] // Incoming jump from 0x15DF, if stack[-7] == stack[-9] // Inputs[1] { @15FC address(this) } 15FB 5B JUMPDEST 15FC 30 ADDRESS 15FD 5B JUMPDEST 15FE 61 PUSH2 0x2c33 1601 56 *JUMP // Stack delta = +1 // Outputs[1] { @15FC stack[0] = address(this) } // Block ends with unconditional jump to 0x2c33 label_1602: // Incoming return from call to 0x15A5 at 0x15A3 // Inputs[1] { @1603 stack[-1] } 1602 5B JUMPDEST 1603 80 DUP1 1604 80 DUP1 1605 15 ISZERO 1606 61 PUSH2 0x1620 1609 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1603 stack[0] = stack[-1] } // Block ends with conditional jump to 0x1620, if !stack[-1] label_160A: // Incoming jump from 0x1609, if not !stack[-1] // Inputs[3] // { // @160B stack[-7] // @160C stack[-3] // @160E memory[stack[-7]:stack[-7] + 0x20] // } 160A 50 POP 160B 85 DUP6 160C 82 DUP3 160D 81 DUP2 160E 51 MLOAD 160F 81 DUP2 1610 10 LT 1611 61 PUSH2 0x1616 1614 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @160B stack[-1] = stack[-7] // @160C stack[0] = stack[-3] // } // Block ends with conditional jump to 0x1616, if stack[-3] < memory[stack[-7]:stack[-7] + 0x20] label_1615: // Incoming jump from 0x1614, if not stack[-3] < memory[stack[-7]:stack[-7] + 0x20] 1615 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1615 assert(); } // Block terminates label_1616: // Incoming jump from 0x1614, if stack[-3] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[3] // { // @1619 stack[-1] // @161D stack[-2] // @161E memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 1616 5B JUMPDEST 1617 60 PUSH1 0x20 1619 02 MUL 161A 60 PUSH1 0x20 161C 01 ADD 161D 01 ADD 161E 51 MLOAD 161F 15 ISZERO // Stack delta = -1 // Outputs[1] { @161F stack[-2] = !memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block continues label_1620: // Incoming jump from 0x1609, if !stack[-1] // Incoming jump from 0x161F // Inputs[1] { @1621 stack[-1] } 1620 5B JUMPDEST 1621 80 DUP1 1622 15 ISZERO 1623 61 PUSH2 0x162c 1626 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x162c, if !stack[-1] label_1627: // Incoming jump from 0x1626, if not !stack[-1] // Inputs[2] // { // @1628 stack[-5] // @1629 stack[-3] // } 1627 50 POP 1628 83 DUP4 1629 82 DUP3 162A 14 EQ 162B 15 ISZERO 162C 5B JUMPDEST 162D 15 ISZERO 162E 61 PUSH2 0x1713 1631 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1713, if !!(stack[-3] == stack[-5]) label_1632: // Incoming jump from 0x1631, if not !!(stack[-3] == stack[-5]) // Incoming jump from 0x1631, if not !stack[-1] // Inputs[5] // { // @1634 storage[0x03] // @1638 memory[0x40:0x60] // @1643 address(this) // @164A memory[0x40:0x60] // @1671 address((0x01 << 0xa0) - 0x01 & storage[0x03]).code.length // } 1632 60 PUSH1 0x03 1634 54 SLOAD 1635 60 PUSH1 0x40 1637 80 DUP1 1638 51 MLOAD 1639 63 PUSH4 0x70a08231 163E 60 PUSH1 0xe0 1640 1B SHL 1641 81 DUP2 1642 52 MSTORE 1643 30 ADDRESS 1644 60 PUSH1 0x04 1646 82 DUP3 1647 01 ADD 1648 52 MSTORE 1649 90 SWAP1 164A 51 MLOAD 164B 60 PUSH1 0x00 164D 92 SWAP3 164E 60 PUSH1 0x01 1650 60 PUSH1 0x01 1652 60 PUSH1 0xa0 1654 1B SHL 1655 03 SUB 1656 16 AND 1657 91 SWAP2 1658 63 PUSH4 0x70a08231 165D 91 SWAP2 165E 60 PUSH1 0x24 1660 80 DUP1 1661 83 DUP4 1662 01 ADD 1663 92 SWAP3 1664 60 PUSH1 0x20 1666 92 SWAP3 1667 91 SWAP2 1668 90 SWAP1 1669 82 DUP3 166A 90 SWAP1 166B 03 SUB 166C 01 ADD 166D 81 DUP2 166E 87 DUP8 166F 87 DUP8 1670 80 DUP1 1671 3B EXTCODESIZE 1672 15 ISZERO 1673 80 DUP1 1674 15 ISZERO 1675 61 PUSH2 0x167d 1678 57 *JUMPI // Stack delta = +11 // Outputs[13] // { // @1642 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @1648 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @164D stack[0] = 0x00 // @1657 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x03] // @165D stack[2] = 0x70a08231 // @1663 stack[3] = memory[0x40:0x60] + 0x24 // @1666 stack[4] = 0x20 // @1667 stack[5] = memory[0x40:0x60] // @166C stack[6] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @166D stack[7] = memory[0x40:0x60] // @166E stack[8] = 0x00 // @166F stack[9] = (0x01 << 0xa0) - 0x01 & storage[0x03] // @1672 stack[10] = !address((0x01 << 0xa0) - 0x01 & storage[0x03]).code.length // } // Block ends with conditional jump to 0x167d, if !!address((0x01 << 0xa0) - 0x01 & storage[0x03]).code.length label_1679: // Incoming jump from 0x1678, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x03]).code.length // Inputs[1] { @167C memory[0x00:0x00] } 1679 60 PUSH1 0x00 167B 80 DUP1 167C FD *REVERT // Stack delta = +0 // Outputs[1] { @167C revert(memory[0x00:0x00]); } // Block terminates label_167D: // Incoming jump from 0x1678, if !!address((0x01 << 0xa0) - 0x01 & storage[0x03]).code.length // Inputs[9] // { // @167F msg.gas // @1680 stack[-2] // @1680 stack[-7] // @1680 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1680 stack[-6] // @1680 memory[stack[-4]:stack[-4] + stack[-5]] // @1680 stack[-3] // @1680 stack[-5] // @1680 stack[-4] // } 167D 5B JUMPDEST 167E 50 POP 167F 5A GAS 1680 F1 CALL 1681 15 ISZERO 1682 80 DUP1 1683 15 ISZERO 1684 61 PUSH2 0x1691 1687 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1680 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1681 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 0x1691, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1688: // Incoming jump from 0x1687, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1688 returndata.length // @168C returndata[0x00:0x00 + returndata.length] // @168D returndata.length // @1690 memory[0x00:0x00 + returndata.length] // } 1688 3D RETURNDATASIZE 1689 60 PUSH1 0x00 168B 80 DUP1 168C 3E RETURNDATACOPY 168D 3D RETURNDATASIZE 168E 60 PUSH1 0x00 1690 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @168C memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1690 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1691: // Incoming jump from 0x1687, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1698 memory[0x40:0x60] // @1699 returndata.length // } 1691 5B JUMPDEST 1692 50 POP 1693 50 POP 1694 50 POP 1695 50 POP 1696 60 PUSH1 0x40 1698 51 MLOAD 1699 3D RETURNDATASIZE 169A 60 PUSH1 0x20 169C 81 DUP2 169D 10 LT 169E 15 ISZERO 169F 61 PUSH2 0x16a7 16A2 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1698 stack[-4] = memory[0x40:0x60] // @1699 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x16a7, if !(returndata.length < 0x20) label_16A3: // Incoming jump from 0x16A2, if not !(returndata.length < 0x20) // Inputs[1] { @16A6 memory[0x00:0x00] } 16A3 60 PUSH1 0x00 16A5 80 DUP1 16A6 FD *REVERT // Stack delta = +0 // Outputs[1] { @16A6 revert(memory[0x00:0x00]); } // Block terminates label_16A7: // Incoming jump from 0x16A2, if !(returndata.length < 0x20) // Inputs[7] // { // @16A9 stack[-2] // @16A9 memory[stack[-2]:stack[-2] + 0x20] // @16AC storage[0x03] // @16B0 memory[0x40:0x60] // @16C3 memory[0x40:0x60] // @16C5 stack[-3] // @16ED address(storage[0x03] & (0x01 << 0xa0) - 0x01).code.length // } 16A7 5B JUMPDEST 16A8 50 POP 16A9 51 MLOAD 16AA 60 PUSH1 0x03 16AC 54 SLOAD 16AD 60 PUSH1 0x40 16AF 80 DUP1 16B0 51 MLOAD 16B1 63 PUSH4 0x6f074d1f 16B6 60 PUSH1 0xe1 16B8 1B SHL 16B9 81 DUP2 16BA 52 MSTORE 16BB 60 PUSH1 0x04 16BD 81 DUP2 16BE 01 ADD 16BF 84 DUP5 16C0 90 SWAP1 16C1 52 MSTORE 16C2 90 SWAP1 16C3 51 MLOAD 16C4 92 SWAP3 16C5 93 SWAP4 16C6 50 POP 16C7 60 PUSH1 0x01 16C9 60 PUSH1 0x01 16CB 60 PUSH1 0xa0 16CD 1B SHL 16CE 03 SUB 16CF 90 SWAP1 16D0 91 SWAP2 16D1 16 AND 16D2 91 SWAP2 16D3 63 PUSH4 0xde0e9a3e 16D8 91 SWAP2 16D9 60 PUSH1 0x24 16DB 80 DUP1 16DC 82 DUP3 16DD 01 ADD 16DE 92 SWAP3 16DF 60 PUSH1 0x00 16E1 92 SWAP3 16E2 90 SWAP1 16E3 91 SWAP2 16E4 90 SWAP1 16E5 82 DUP3 16E6 90 SWAP1 16E7 03 SUB 16E8 01 ADD 16E9 81 DUP2 16EA 83 DUP4 16EB 87 DUP8 16EC 80 DUP1 16ED 3B EXTCODESIZE 16EE 15 ISZERO 16EF 80 DUP1 16F0 15 ISZERO 16F1 61 PUSH2 0x16f9 16F4 57 *JUMPI // Stack delta = +8 // Outputs[13] // { // @16BA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f074d1f << 0xe1 // @16C1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @16C5 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @16D2 stack[-2] = storage[0x03] & (0x01 << 0xa0) - 0x01 // @16D8 stack[-1] = 0xde0e9a3e // @16DE stack[0] = memory[0x40:0x60] + 0x24 // @16E1 stack[1] = 0x00 // @16E3 stack[2] = memory[0x40:0x60] // @16E8 stack[3] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @16E9 stack[4] = memory[0x40:0x60] // @16EA stack[5] = 0x00 // @16EB stack[6] = storage[0x03] & (0x01 << 0xa0) - 0x01 // @16EE stack[7] = !address(storage[0x03] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x16f9, if !!address(storage[0x03] & (0x01 << 0xa0) - 0x01).code.length label_16F5: // Incoming jump from 0x16F4, if not !!address(storage[0x03] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @16F8 memory[0x00:0x00] } 16F5 60 PUSH1 0x00 16F7 80 DUP1 16F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @16F8 revert(memory[0x00:0x00]); } // Block terminates label_16F9: // Incoming jump from 0x16F4, if !!address(storage[0x03] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @16FB msg.gas // @16FC stack[-4] // @16FC stack[-3] // @16FC stack[-2] // @16FC stack[-5] // @16FC address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @16FC stack[-6] // @16FC stack[-7] // @16FC memory[stack[-4]:stack[-4] + stack[-5]] // } 16F9 5B JUMPDEST 16FA 50 POP 16FB 5A GAS 16FC F1 CALL 16FD 15 ISZERO 16FE 80 DUP1 16FF 15 ISZERO 1700 61 PUSH2 0x170d 1703 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @16FC memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @16FD 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 0x170d, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1704: // Incoming jump from 0x1703, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1704 returndata.length // @1708 returndata[0x00:0x00 + returndata.length] // @1709 returndata.length // @170C memory[0x00:0x00 + returndata.length] // } 1704 3D RETURNDATASIZE 1705 60 PUSH1 0x00 1707 80 DUP1 1708 3E RETURNDATACOPY 1709 3D RETURNDATASIZE 170A 60 PUSH1 0x00 170C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1708 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @170C revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_170D: // Incoming jump from 0x1703, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) 170D 5B JUMPDEST 170E 50 POP 170F 50 POP 1710 50 POP 1711 50 POP 1712 50 POP // Stack delta = -5 // Block continues label_1713: // Incoming jump from 0x1631, if !!(stack[-3] == stack[-5]) // Incoming jump from 0x1712 // Incoming jump from 0x1631, if !stack[-1] // Inputs[1] { @1717 stack[-2] } 1713 5B JUMPDEST 1714 50 POP 1715 60 PUSH1 0x01 1717 01 ADD 1718 61 PUSH2 0x144c 171B 56 *JUMP // Stack delta = -1 // Outputs[1] { @1717 stack[-2] = 0x01 + stack[-2] } // Block ends with unconditional jump to 0x144c label_171C: // Incoming jump from 0x1457, if !(0x01 < 0x01 + stack[-2]) // Incoming jump from 0x1457, if !(stack[-1] < 0x01 + stack[-3]) // Inputs[2] // { // @1720 stack[-5] // @1724 memory[stack[-5]:stack[-5] + 0x20] // } 171C 5B JUMPDEST 171D 50 POP 171E 60 PUSH1 0x00 1720 84 DUP5 1721 60 PUSH1 0x00 1723 81 DUP2 1724 51 MLOAD 1725 81 DUP2 1726 10 LT 1727 61 PUSH2 0x172c 172A 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @171E stack[-1] = 0x00 // @1720 stack[0] = stack[-5] // @1721 stack[1] = 0x00 // } // Block ends with conditional jump to 0x172c, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] label_172B: // Incoming jump from 0x172A, if not 0x00 < memory[stack[-5]:stack[-5] + 0x20] 172B FE *ASSERT // Stack delta = +0 // Outputs[1] { @172B assert(); } // Block terminates label_172C: // Incoming jump from 0x172A, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] // Inputs[3] // { // @172F stack[-1] // @1733 stack[-2] // @1734 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 172C 5B JUMPDEST 172D 60 PUSH1 0x20 172F 02 MUL 1730 60 PUSH1 0x20 1732 01 ADD 1733 01 ADD 1734 51 MLOAD 1735 61 PUSH2 0x17b6 1738 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x17b6, if memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_1739: // Incoming jump from 0x1738, if not memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[2] // { // @1739 stack[-6] // @173D memory[stack[-6]:stack[-6] + 0x20] // } 1739 85 DUP6 173A 60 PUSH1 0x00 173C 81 DUP2 173D 51 MLOAD 173E 81 DUP2 173F 10 LT 1740 61 PUSH2 0x1745 1743 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1739 stack[0] = stack[-6] // @173A stack[1] = 0x00 // } // Block ends with conditional jump to 0x1745, if 0x00 < memory[stack[-6]:stack[-6] + 0x20] label_1744: // Incoming jump from 0x1743, if not 0x00 < memory[stack[-6]:stack[-6] + 0x20] 1744 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1744 assert(); } // Block terminates label_1745: // Incoming jump from 0x1743, if 0x00 < memory[stack[-6]:stack[-6] + 0x20] // Inputs[6] // { // @1748 stack[-1] // @174C stack[-2] // @174D memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @175E memory[0x40:0x60] // @1772 memory[0x40:0x60] // @1779 address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } 1745 5B JUMPDEST 1746 60 PUSH1 0x20 1748 02 MUL 1749 60 PUSH1 0x20 174B 01 ADD 174C 01 ADD 174D 51 MLOAD 174E 60 PUSH1 0x01 1750 60 PUSH1 0x01 1752 60 PUSH1 0xa0 1754 1B SHL 1755 03 SUB 1756 16 AND 1757 63 PUSH4 0x0dfe1681 175C 60 PUSH1 0x40 175E 51 MLOAD 175F 81 DUP2 1760 63 PUSH4 0xffffffff 1765 16 AND 1766 60 PUSH1 0xe0 1768 1B SHL 1769 81 DUP2 176A 52 MSTORE 176B 60 PUSH1 0x04 176D 01 ADD 176E 60 PUSH1 0x20 1770 60 PUSH1 0x40 1772 51 MLOAD 1773 80 DUP1 1774 83 DUP4 1775 03 SUB 1776 81 DUP2 1777 86 DUP7 1778 80 DUP1 1779 3B EXTCODESIZE 177A 15 ISZERO 177B 80 DUP1 177C 15 ISZERO 177D 61 PUSH2 0x1785 1780 57 *JUMPI // Stack delta = +7 // Outputs[10] // { // @1756 stack[-2] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1757 stack[-1] = 0x0dfe1681 // @176A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x0dfe1681) << 0xe0 // @176D stack[0] = 0x04 + memory[0x40:0x60] // @176E stack[1] = 0x20 // @1772 stack[2] = memory[0x40:0x60] // @1775 stack[3] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1776 stack[4] = memory[0x40:0x60] // @1777 stack[5] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @177A stack[6] = !address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } // Block ends with conditional jump to 0x1785, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length label_1781: // Incoming jump from 0x1780, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[1] { @1784 memory[0x00:0x00] } 1781 60 PUSH1 0x00 1783 80 DUP1 1784 FD *REVERT // Stack delta = +0 // Outputs[1] { @1784 revert(memory[0x00:0x00]); } // Block terminates label_1785: // Incoming jump from 0x1780, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[8] // { // @1787 msg.gas // @1788 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1788 memory[stack[-3]:stack[-3] + stack[-4]] // @1788 stack[-4] // @1788 stack[-5] // @1788 stack[-6] // @1788 stack[-2] // @1788 stack[-3] // } 1785 5B JUMPDEST 1786 50 POP 1787 5A GAS 1788 FA STATICCALL 1789 15 ISZERO 178A 80 DUP1 178B 15 ISZERO 178C 61 PUSH2 0x1799 178F 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1788 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1789 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1799, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1790: // Incoming jump from 0x178F, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1790 returndata.length // @1794 returndata[0x00:0x00 + returndata.length] // @1795 returndata.length // @1798 memory[0x00:0x00 + returndata.length] // } 1790 3D RETURNDATASIZE 1791 60 PUSH1 0x00 1793 80 DUP1 1794 3E RETURNDATACOPY 1795 3D RETURNDATASIZE 1796 60 PUSH1 0x00 1798 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1794 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1798 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1799: // Incoming jump from 0x178F, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @17A0 memory[0x40:0x60] // @17A1 returndata.length // } 1799 5B JUMPDEST 179A 50 POP 179B 50 POP 179C 50 POP 179D 50 POP 179E 60 PUSH1 0x40 17A0 51 MLOAD 17A1 3D RETURNDATASIZE 17A2 60 PUSH1 0x20 17A4 81 DUP2 17A5 10 LT 17A6 15 ISZERO 17A7 61 PUSH2 0x17af 17AA 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @17A0 stack[-4] = memory[0x40:0x60] // @17A1 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x17af, if !(returndata.length < 0x20) label_17AB: // Incoming jump from 0x17AA, if not !(returndata.length < 0x20) // Inputs[1] { @17AE memory[0x00:0x00] } 17AB 60 PUSH1 0x00 17AD 80 DUP1 17AE FD *REVERT // Stack delta = +0 // Outputs[1] { @17AE revert(memory[0x00:0x00]); } // Block terminates label_17AF: // Incoming jump from 0x17AA, if !(returndata.length < 0x20) // Inputs[2] // { // @17B1 stack[-2] // @17B1 memory[stack[-2]:stack[-2] + 0x20] // } 17AF 5B JUMPDEST 17B0 50 POP 17B1 51 MLOAD 17B2 61 PUSH2 0x1830 17B5 56 *JUMP // Stack delta = -1 // Outputs[1] { @17B1 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1830 label_17B6: // Incoming jump from 0x1738, if memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[2] // { // @17B7 stack[-6] // @17BB memory[stack[-6]:stack[-6] + 0x20] // } 17B6 5B JUMPDEST 17B7 85 DUP6 17B8 60 PUSH1 0x00 17BA 81 DUP2 17BB 51 MLOAD 17BC 81 DUP2 17BD 10 LT 17BE 61 PUSH2 0x17c3 17C1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @17B7 stack[0] = stack[-6] // @17B8 stack[1] = 0x00 // } // Block ends with conditional jump to 0x17c3, if 0x00 < memory[stack[-6]:stack[-6] + 0x20] label_17C2: // Incoming jump from 0x17C1, if not 0x00 < memory[stack[-6]:stack[-6] + 0x20] 17C2 FE *ASSERT // Stack delta = +0 // Outputs[1] { @17C2 assert(); } // Block terminates label_17C3: // Incoming jump from 0x17C1, if 0x00 < memory[stack[-6]:stack[-6] + 0x20] // Inputs[6] // { // @17C6 stack[-1] // @17CA stack[-2] // @17CB memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @17DC memory[0x40:0x60] // @17F0 memory[0x40:0x60] // @17F7 address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } 17C3 5B JUMPDEST 17C4 60 PUSH1 0x20 17C6 02 MUL 17C7 60 PUSH1 0x20 17C9 01 ADD 17CA 01 ADD 17CB 51 MLOAD 17CC 60 PUSH1 0x01 17CE 60 PUSH1 0x01 17D0 60 PUSH1 0xa0 17D2 1B SHL 17D3 03 SUB 17D4 16 AND 17D5 63 PUSH4 0xd21220a7 17DA 60 PUSH1 0x40 17DC 51 MLOAD 17DD 81 DUP2 17DE 63 PUSH4 0xffffffff 17E3 16 AND 17E4 60 PUSH1 0xe0 17E6 1B SHL 17E7 81 DUP2 17E8 52 MSTORE 17E9 60 PUSH1 0x04 17EB 01 ADD 17EC 60 PUSH1 0x20 17EE 60 PUSH1 0x40 17F0 51 MLOAD 17F1 80 DUP1 17F2 83 DUP4 17F3 03 SUB 17F4 81 DUP2 17F5 86 DUP7 17F6 80 DUP1 17F7 3B EXTCODESIZE 17F8 15 ISZERO 17F9 80 DUP1 17FA 15 ISZERO 17FB 61 PUSH2 0x1803 17FE 57 *JUMPI // Stack delta = +7 // Outputs[10] // { // @17D4 stack[-2] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @17D5 stack[-1] = 0xd21220a7 // @17E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xd21220a7) << 0xe0 // @17EB stack[0] = 0x04 + memory[0x40:0x60] // @17EC stack[1] = 0x20 // @17F0 stack[2] = memory[0x40:0x60] // @17F3 stack[3] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @17F4 stack[4] = memory[0x40:0x60] // @17F5 stack[5] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @17F8 stack[6] = !address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } // Block ends with conditional jump to 0x1803, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length label_17FF: // Incoming jump from 0x17FE, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[1] { @1802 memory[0x00:0x00] } 17FF 60 PUSH1 0x00 1801 80 DUP1 1802 FD *REVERT // Stack delta = +0 // Outputs[1] { @1802 revert(memory[0x00:0x00]); } // Block terminates label_1803: // Incoming jump from 0x17FE, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[8] // { // @1805 msg.gas // @1806 stack[-5] // @1806 stack[-6] // @1806 memory[stack[-3]:stack[-3] + stack[-4]] // @1806 stack[-3] // @1806 stack[-4] // @1806 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1806 stack[-2] // } 1803 5B JUMPDEST 1804 50 POP 1805 5A GAS 1806 FA STATICCALL 1807 15 ISZERO 1808 80 DUP1 1809 15 ISZERO 180A 61 PUSH2 0x1817 180D 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1806 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1807 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1817, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_180E: // Incoming jump from 0x180D, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @180E returndata.length // @1812 returndata[0x00:0x00 + returndata.length] // @1813 returndata.length // @1816 memory[0x00:0x00 + returndata.length] // } 180E 3D RETURNDATASIZE 180F 60 PUSH1 0x00 1811 80 DUP1 1812 3E RETURNDATACOPY 1813 3D RETURNDATASIZE 1814 60 PUSH1 0x00 1816 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1812 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1816 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1817: // Incoming jump from 0x180D, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @181E memory[0x40:0x60] // @181F returndata.length // } 1817 5B JUMPDEST 1818 50 POP 1819 50 POP 181A 50 POP 181B 50 POP 181C 60 PUSH1 0x40 181E 51 MLOAD 181F 3D RETURNDATASIZE 1820 60 PUSH1 0x20 1822 81 DUP2 1823 10 LT 1824 15 ISZERO 1825 61 PUSH2 0x182d 1828 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @181E stack[-4] = memory[0x40:0x60] // @181F stack[-3] = returndata.length // } // Block ends with conditional jump to 0x182d, if !(returndata.length < 0x20) label_1829: // Incoming jump from 0x1828, if not !(returndata.length < 0x20) // Inputs[1] { @182C memory[0x00:0x00] } 1829 60 PUSH1 0x00 182B 80 DUP1 182C FD *REVERT // Stack delta = +0 // Outputs[1] { @182C revert(memory[0x00:0x00]); } // Block terminates label_182D: // Incoming jump from 0x1828, if !(returndata.length < 0x20) // Inputs[4] // { // @182F memory[stack[-2]:stack[-2] + 0x20] // @182F stack[-2] // @1833 storage[0x03] // @1835 stack[-3] // } 182D 5B JUMPDEST 182E 50 POP 182F 51 MLOAD 1830 5B JUMPDEST 1831 60 PUSH1 0x03 1833 54 SLOAD 1834 90 SWAP1 1835 91 SWAP2 1836 50 POP 1837 60 PUSH1 0x01 1839 60 PUSH1 0x01 183B 60 PUSH1 0xa0 183D 1B SHL 183E 03 SUB 183F 80 DUP1 1840 83 DUP4 1841 16 AND 1842 91 SWAP2 1843 16 AND 1844 14 EQ 1845 15 ISZERO 1846 61 PUSH2 0x18d9 1849 57 *JUMPI // Stack delta = -2 // Outputs[1] { @1835 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x18d9, if !(storage[0x03] & (0x01 << 0xa0) - 0x01 == memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01) label_184A: // Incoming jump from 0x1849, if not !(storage[0x03] & (0x01 << 0xa0) - 0x01 == stack[-1] & (0x01 << 0xa0) - 0x01) // Incoming jump from 0x1849, if not !(storage[0x03] & (0x01 << 0xa0) - 0x01 == memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01) // Inputs[5] // { // @184C storage[0x03] // @184D stack[-4] // @184E memory[stack[-4]:stack[-4] + 0x20] // @1861 address(this) // @1868 stack[-3] // } 184A 60 PUSH1 0x03 184C 54 SLOAD 184D 84 DUP5 184E 51 MLOAD 184F 60 PUSH1 0x01 1851 60 PUSH1 0x01 1853 60 PUSH1 0xa0 1855 1B SHL 1856 03 SUB 1857 90 SWAP1 1858 91 SWAP2 1859 16 AND 185A 90 SWAP1 185B 63 PUSH4 0xbf376c7a 1860 90 SWAP1 1861 30 ADDRESS 1862 90 SWAP1 1863 87 DUP8 1864 90 SWAP1 1865 60 PUSH1 0x00 1867 19 NOT 1868 88 DUP9 1869 01 ADD 186A 90 SWAP1 186B 81 DUP2 186C 10 LT 186D 61 PUSH2 0x1872 1870 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @185A stack[0] = storage[0x03] & (0x01 << 0xa0) - 0x01 // @1860 stack[1] = 0xbf376c7a // @1862 stack[2] = address(this) // @1864 stack[3] = stack[-4] // @186A stack[4] = stack[-3] + ~0x00 // } // Block ends with conditional jump to 0x1872, if stack[-3] + ~0x00 < memory[stack[-4]:stack[-4] + 0x20] label_1871: // Incoming jump from 0x1870, if not stack[-3] + ~0x00 < memory[stack[-4]:stack[-4] + 0x20] 1871 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1871 assert(); } // Block terminates label_1872: // Incoming jump from 0x1870, if stack[-3] + ~0x00 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[9] // { // @1875 stack[-1] // @1879 stack[-2] // @187A memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @187D memory[0x40:0x60] // @187E stack[-4] // @188E stack[-3] // @18AB memory[0x40:0x60] // @18B2 stack[-5] // @18B4 address(stack[-5]).code.length // } 1872 5B JUMPDEST 1873 60 PUSH1 0x20 1875 02 MUL 1876 60 PUSH1 0x20 1878 01 ADD 1879 01 ADD 187A 51 MLOAD 187B 60 PUSH1 0x40 187D 51 MLOAD 187E 83 DUP4 187F 63 PUSH4 0xffffffff 1884 16 AND 1885 60 PUSH1 0xe0 1887 1B SHL 1888 81 DUP2 1889 52 MSTORE 188A 60 PUSH1 0x04 188C 01 ADD 188D 80 DUP1 188E 83 DUP4 188F 60 PUSH1 0x01 1891 60 PUSH1 0x01 1893 60 PUSH1 0xa0 1895 1B SHL 1896 03 SUB 1897 16 AND 1898 81 DUP2 1899 52 MSTORE 189A 60 PUSH1 0x20 189C 01 ADD 189D 82 DUP3 189E 81 DUP2 189F 52 MSTORE 18A0 60 PUSH1 0x20 18A2 01 ADD 18A3 92 SWAP3 18A4 50 POP 18A5 50 POP 18A6 50 POP 18A7 60 PUSH1 0x00 18A9 60 PUSH1 0x40 18AB 51 MLOAD 18AC 80 DUP1 18AD 83 DUP4 18AE 03 SUB 18AF 81 DUP2 18B0 60 PUSH1 0x00 18B2 87 DUP8 18B3 80 DUP1 18B4 3B EXTCODESIZE 18B5 15 ISZERO 18B6 80 DUP1 18B7 15 ISZERO 18B8 61 PUSH2 0x18c0 18BB 57 *JUMPI // Stack delta = +5 // Outputs[11] // { // @1889 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-4]) << 0xe0 // @1899 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @189F memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @18A3 stack[-3] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @18A7 stack[-2] = 0x00 // @18AB stack[-1] = memory[0x40:0x60] // @18AE stack[0] = (0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @18AF stack[1] = memory[0x40:0x60] // @18B0 stack[2] = 0x00 // @18B2 stack[3] = stack[-5] // @18B5 stack[4] = !address(stack[-5]).code.length // } // Block ends with conditional jump to 0x18c0, if !!address(stack[-5]).code.length label_18BC: // Incoming jump from 0x18BB, if not !!address(stack[-5]).code.length // Inputs[1] { @18BF memory[0x00:0x00] } 18BC 60 PUSH1 0x00 18BE 80 DUP1 18BF FD *REVERT // Stack delta = +0 // Outputs[1] { @18BF revert(memory[0x00:0x00]); } // Block terminates label_18C0: // Incoming jump from 0x18BB, if !!address(stack[-5]).code.length // Inputs[9] // { // @18C2 msg.gas // @18C3 memory[stack[-4]:stack[-4] + stack[-5]] // @18C3 stack[-4] // @18C3 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @18C3 stack[-2] // @18C3 stack[-7] // @18C3 stack[-3] // @18C3 stack[-6] // @18C3 stack[-5] // } 18C0 5B JUMPDEST 18C1 50 POP 18C2 5A GAS 18C3 F1 CALL 18C4 15 ISZERO 18C5 80 DUP1 18C6 15 ISZERO 18C7 61 PUSH2 0x18d4 18CA 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @18C3 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @18C4 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 0x18d4, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_18CB: // Incoming jump from 0x18CA, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @18CB returndata.length // @18CF returndata[0x00:0x00 + returndata.length] // @18D0 returndata.length // @18D3 memory[0x00:0x00 + returndata.length] // } 18CB 3D RETURNDATASIZE 18CC 60 PUSH1 0x00 18CE 80 DUP1 18CF 3E RETURNDATACOPY 18D0 3D RETURNDATASIZE 18D1 60 PUSH1 0x00 18D3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @18CF memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @18D3 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_18D4: // Incoming jump from 0x18CA, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) 18D4 5B JUMPDEST 18D5 50 POP 18D6 50 POP 18D7 50 POP 18D8 50 POP // Stack delta = -4 // Block continues label_18D9: // Incoming jump from 0x18D8 // Incoming jump from 0x1849, if !(storage[0x03] & (0x01 << 0xa0) - 0x01 == memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01) // Incoming jump from 0x1849, if !(storage[0x03] & (0x01 << 0xa0) - 0x01 == stack[-1] & (0x01 << 0xa0) - 0x01) // Inputs[4] // { // @18DC stack[-7] // @18E3 stack[-1] // @18E4 stack[-6] // @18E8 memory[stack[-6]:stack[-6] + 0x20] // } 18D9 5B JUMPDEST 18DA 60 PUSH1 0x01 18DC 87 DUP8 18DD 03 SUB 18DE 96 SWAP7 18DF 50 POP 18E0 61 PUSH2 0x1980 18E3 81 DUP2 18E4 87 DUP8 18E5 60 PUSH1 0x00 18E7 81 DUP2 18E8 51 MLOAD 18E9 81 DUP2 18EA 10 LT 18EB 61 PUSH2 0x18f0 18EE 57 *JUMPI // Stack delta = +4 // Outputs[5] // { // @18DE stack[-7] = stack[-7] - 0x01 // @18E0 stack[0] = 0x1980 // @18E3 stack[1] = stack[-1] // @18E4 stack[2] = stack[-6] // @18E5 stack[3] = 0x00 // } // Block ends with conditional call to 0x18f0, returns to 0x1980, if 0x00 < memory[stack[-6]:stack[-6] + 0x20] label_18EF: // Incoming jump from 0x18EE, if not 0x00 < memory[stack[-6]:stack[-6] + 0x20] 18EF FE *ASSERT // Stack delta = +0 // Outputs[1] { @18EF assert(); } // Block terminates label_18F0: // Incoming call from 0x1D68, returns to 0x1980, if 0x00 < memory[stack[-7]:stack[-7] + 0x20] // Incoming call from 0x18EE, returns to 0x1980, if 0x00 < memory[stack[-6]:stack[-6] + 0x20] // Inputs[9] // { // @18F3 stack[-1] // @18F7 stack[-2] // @18F8 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @18FC stack[-11] // @18FD stack[-5] // @190C address(this) // @190F memory[0x40:0x60] // @1936 memory[0x40:0x60] // @193D address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // } 18F0 5B JUMPDEST 18F1 60 PUSH1 0x20 18F3 02 MUL 18F4 60 PUSH1 0x20 18F6 01 ADD 18F7 01 ADD 18F8 51 MLOAD 18F9 61 PUSH2 0x197b 18FC 8A DUP11 18FD 85 DUP6 18FE 60 PUSH1 0x01 1900 60 PUSH1 0x01 1902 60 PUSH1 0xa0 1904 1B SHL 1905 03 SUB 1906 16 AND 1907 63 PUSH4 0x70a08231 190C 30 ADDRESS 190D 60 PUSH1 0x40 190F 51 MLOAD 1910 82 DUP3 1911 63 PUSH4 0xffffffff 1916 16 AND 1917 60 PUSH1 0xe0 1919 1B SHL 191A 81 DUP2 191B 52 MSTORE 191C 60 PUSH1 0x04 191E 01 ADD 191F 80 DUP1 1920 82 DUP3 1921 60 PUSH1 0x01 1923 60 PUSH1 0x01 1925 60 PUSH1 0xa0 1927 1B SHL 1928 03 SUB 1929 16 AND 192A 81 DUP2 192B 52 MSTORE 192C 60 PUSH1 0x20 192E 01 ADD 192F 91 SWAP2 1930 50 POP 1931 50 POP 1932 60 PUSH1 0x20 1934 60 PUSH1 0x40 1936 51 MLOAD 1937 80 DUP1 1938 83 DUP4 1939 03 SUB 193A 81 DUP2 193B 86 DUP7 193C 80 DUP1 193D 3B EXTCODESIZE 193E 15 ISZERO 193F 80 DUP1 1940 15 ISZERO 1941 61 PUSH2 0x1949 1944 57 *JUMPI // Stack delta = +10 // Outputs[14] // { // @18F8 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @18F9 stack[-1] = 0x197b // @18FC stack[0] = stack[-11] // @1906 stack[1] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1907 stack[2] = 0x70a08231 // @191B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x70a08231) << 0xe0 // @192B memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & address(this) // @192F stack[3] = 0x20 + 0x04 + memory[0x40:0x60] // @1932 stack[4] = 0x20 // @1936 stack[5] = memory[0x40:0x60] // @1939 stack[6] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @193A stack[7] = memory[0x40:0x60] // @193B stack[8] = (0x01 << 0xa0) - 0x01 & stack[-5] // @193E stack[9] = !address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // } // Block ends with conditional call to 0x1949, returns to 0x197B, if !!address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length label_1945: // Incoming jump from 0x1944, if not !!address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // Inputs[1] { @1948 memory[0x00:0x00] } 1945 60 PUSH1 0x00 1947 80 DUP1 1948 FD *REVERT // Stack delta = +0 // Outputs[1] { @1948 revert(memory[0x00:0x00]); } // Block terminates label_1949: // Incoming call from 0x1944, returns to 0x197B, if !!address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // Inputs[8] // { // @194B msg.gas // @194C stack[-5] // @194C address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @194C stack[-6] // @194C stack[-2] // @194C stack[-4] // @194C memory[stack[-3]:stack[-3] + stack[-4]] // @194C stack[-3] // } 1949 5B JUMPDEST 194A 50 POP 194B 5A GAS 194C FA STATICCALL 194D 15 ISZERO 194E 80 DUP1 194F 15 ISZERO 1950 61 PUSH2 0x195d 1953 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @194C memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @194D stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x195d, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1954: // Incoming jump from 0x1953, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1954 returndata.length // @1958 returndata[0x00:0x00 + returndata.length] // @1959 returndata.length // @195C memory[0x00:0x00 + returndata.length] // } 1954 3D RETURNDATASIZE 1955 60 PUSH1 0x00 1957 80 DUP1 1958 3E RETURNDATACOPY 1959 3D RETURNDATASIZE 195A 60 PUSH1 0x00 195C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1958 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @195C revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_195D: // Incoming jump from 0x1953, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1964 memory[0x40:0x60] // @1965 returndata.length // } 195D 5B JUMPDEST 195E 50 POP 195F 50 POP 1960 50 POP 1961 50 POP 1962 60 PUSH1 0x40 1964 51 MLOAD 1965 3D RETURNDATASIZE 1966 60 PUSH1 0x20 1968 81 DUP2 1969 10 LT 196A 15 ISZERO 196B 61 PUSH2 0x1973 196E 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1964 stack[-4] = memory[0x40:0x60] // @1965 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1973, if !(returndata.length < 0x20) label_196F: // Incoming jump from 0x196E, if not !(returndata.length < 0x20) // Inputs[1] { @1972 memory[0x00:0x00] } 196F 60 PUSH1 0x00 1971 80 DUP1 1972 FD *REVERT // Stack delta = +0 // Outputs[1] { @1972 revert(memory[0x00:0x00]); } // Block terminates label_1973: // Incoming jump from 0x196E, if !(returndata.length < 0x20) // Inputs[3] // { // @1975 memory[stack[-2]:stack[-2] + 0x20] // @1975 stack[-2] // @1976 stack[-3] // } 1973 5B JUMPDEST 1974 50 POP 1975 51 MLOAD 1976 90 SWAP1 1977 61 PUSH2 0x2d34 197A 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1976 stack[-2] = stack[-3] // @1976 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x2d34 label_197B: // Incoming return from call to 0x1949 at 0x1944 197B 5B JUMPDEST 197C 61 PUSH2 0x2ac9 197F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2ac9 label_1980: // Incoming return from call to 0x18F0 at 0x1D68 // Incoming return from call to 0x18F0 at 0x18EE // Inputs[3] // { // @1983 storage[0x05] // @1988 stack[-1] // @1993 stack[-7] // } 1980 5B JUMPDEST 1981 60 PUSH1 0x05 1983 54 SLOAD 1984 61 PUSH2 0x0e97 1987 90 SWAP1 1988 82 DUP3 1989 90 SWAP1 198A 60 PUSH1 0x01 198C 60 PUSH1 0x01 198E 60 PUSH1 0xa0 1990 1B SHL 1991 03 SUB 1992 16 AND 1993 89 DUP10 1994 61 PUSH2 0x2ac9 1997 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1987 stack[0] = 0x0e97 // @1989 stack[1] = stack[-1] // @1992 stack[2] = (0x01 << 0xa0) - 0x01 & storage[0x05] // @1993 stack[3] = stack[-7] // } // Block ends with call to 0x2ac9, returns to 0x0E97 label_1998: // Incoming jump from 0x0AF8 // Inputs[4] // { // @199D stack[-3] // @199E memory[stack[-3]:stack[-3] + 0x20] // @19A4 stack[-2] // @19A8 memory[stack[-2]:stack[-2] + 0x20] // } 1998 5B JUMPDEST 1999 60 PUSH1 0x00 199B 60 PUSH1 0x01 199D 84 DUP5 199E 51 MLOAD 199F 03 SUB 19A0 90 SWAP1 19A1 50 POP 19A2 60 PUSH1 0x00 19A4 83 DUP4 19A5 60 PUSH1 0x00 19A7 81 DUP2 19A8 51 MLOAD 19A9 81 DUP2 19AA 10 LT 19AB 61 PUSH2 0x19b0 19AE 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @19A0 stack[0] = memory[stack[-3]:stack[-3] + 0x20] - 0x01 // @19A2 stack[1] = 0x00 // @19A4 stack[2] = stack[-2] // @19A5 stack[3] = 0x00 // } // Block ends with conditional jump to 0x19b0, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] label_19AF: // Incoming jump from 0x19AE, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] 19AF FE *ASSERT // Stack delta = +0 // Outputs[1] { @19AF assert(); } // Block terminates label_19B0: // Incoming jump from 0x19AE, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @19B3 stack[-1] // @19B7 stack[-2] // @19B8 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 19B0 5B JUMPDEST 19B1 60 PUSH1 0x20 19B3 02 MUL 19B4 60 PUSH1 0x20 19B6 01 ADD 19B7 01 ADD 19B8 51 MLOAD 19B9 61 PUSH2 0x1a3a 19BC 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1a3a, if memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_19BD: // Incoming jump from 0x19BC, if not memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[2] // { // @19BD stack[-5] // @19C1 memory[stack[-5]:stack[-5] + 0x20] // } 19BD 84 DUP5 19BE 60 PUSH1 0x00 19C0 81 DUP2 19C1 51 MLOAD 19C2 81 DUP2 19C3 10 LT 19C4 61 PUSH2 0x19c9 19C7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @19BD stack[0] = stack[-5] // @19BE stack[1] = 0x00 // } // Block ends with conditional jump to 0x19c9, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] label_19C8: // Incoming jump from 0x19C7, if not 0x00 < memory[stack[-5]:stack[-5] + 0x20] 19C8 FE *ASSERT // Stack delta = +0 // Outputs[1] { @19C8 assert(); } // Block terminates label_19C9: // Incoming jump from 0x19C7, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] // Inputs[6] // { // @19CC stack[-1] // @19D0 stack[-2] // @19D1 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @19E2 memory[0x40:0x60] // @19F6 memory[0x40:0x60] // @19FD address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } 19C9 5B JUMPDEST 19CA 60 PUSH1 0x20 19CC 02 MUL 19CD 60 PUSH1 0x20 19CF 01 ADD 19D0 01 ADD 19D1 51 MLOAD 19D2 60 PUSH1 0x01 19D4 60 PUSH1 0x01 19D6 60 PUSH1 0xa0 19D8 1B SHL 19D9 03 SUB 19DA 16 AND 19DB 63 PUSH4 0xd21220a7 19E0 60 PUSH1 0x40 19E2 51 MLOAD 19E3 81 DUP2 19E4 63 PUSH4 0xffffffff 19E9 16 AND 19EA 60 PUSH1 0xe0 19EC 1B SHL 19ED 81 DUP2 19EE 52 MSTORE 19EF 60 PUSH1 0x04 19F1 01 ADD 19F2 60 PUSH1 0x20 19F4 60 PUSH1 0x40 19F6 51 MLOAD 19F7 80 DUP1 19F8 83 DUP4 19F9 03 SUB 19FA 81 DUP2 19FB 86 DUP7 19FC 80 DUP1 19FD 3B EXTCODESIZE 19FE 15 ISZERO 19FF 80 DUP1 1A00 15 ISZERO 1A01 61 PUSH2 0x1a09 1A04 57 *JUMPI // Stack delta = +7 // Outputs[10] // { // @19DA stack[-2] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @19DB stack[-1] = 0xd21220a7 // @19EE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xd21220a7) << 0xe0 // @19F1 stack[0] = 0x04 + memory[0x40:0x60] // @19F2 stack[1] = 0x20 // @19F6 stack[2] = memory[0x40:0x60] // @19F9 stack[3] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @19FA stack[4] = memory[0x40:0x60] // @19FB stack[5] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @19FE stack[6] = !address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } // Block ends with conditional jump to 0x1a09, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length label_1A05: // Incoming jump from 0x1A04, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[1] { @1A08 memory[0x00:0x00] } 1A05 60 PUSH1 0x00 1A07 80 DUP1 1A08 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A08 revert(memory[0x00:0x00]); } // Block terminates label_1A09: // Incoming jump from 0x1A04, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[8] // { // @1A0B msg.gas // @1A0C address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1A0C stack[-4] // @1A0C memory[stack[-3]:stack[-3] + stack[-4]] // @1A0C stack[-5] // @1A0C stack[-2] // @1A0C stack[-3] // @1A0C stack[-6] // } 1A09 5B JUMPDEST 1A0A 50 POP 1A0B 5A GAS 1A0C FA STATICCALL 1A0D 15 ISZERO 1A0E 80 DUP1 1A0F 15 ISZERO 1A10 61 PUSH2 0x1a1d 1A13 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1A0C memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1A0D stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1a1d, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1A14: // Incoming jump from 0x1A13, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1A14 returndata.length // @1A18 returndata[0x00:0x00 + returndata.length] // @1A19 returndata.length // @1A1C memory[0x00:0x00 + returndata.length] // } 1A14 3D RETURNDATASIZE 1A15 60 PUSH1 0x00 1A17 80 DUP1 1A18 3E RETURNDATACOPY 1A19 3D RETURNDATASIZE 1A1A 60 PUSH1 0x00 1A1C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1A18 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1A1C revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1A1D: // Incoming jump from 0x1A13, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1A24 memory[0x40:0x60] // @1A25 returndata.length // } 1A1D 5B JUMPDEST 1A1E 50 POP 1A1F 50 POP 1A20 50 POP 1A21 50 POP 1A22 60 PUSH1 0x40 1A24 51 MLOAD 1A25 3D RETURNDATASIZE 1A26 60 PUSH1 0x20 1A28 81 DUP2 1A29 10 LT 1A2A 15 ISZERO 1A2B 61 PUSH2 0x1a33 1A2E 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1A24 stack[-4] = memory[0x40:0x60] // @1A25 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1a33, if !(returndata.length < 0x20) label_1A2F: // Incoming jump from 0x1A2E, if not !(returndata.length < 0x20) // Inputs[1] { @1A32 memory[0x00:0x00] } 1A2F 60 PUSH1 0x00 1A31 80 DUP1 1A32 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A32 revert(memory[0x00:0x00]); } // Block terminates label_1A33: // Incoming jump from 0x1A2E, if !(returndata.length < 0x20) // Inputs[2] // { // @1A35 stack[-2] // @1A35 memory[stack[-2]:stack[-2] + 0x20] // } 1A33 5B JUMPDEST 1A34 50 POP 1A35 51 MLOAD 1A36 61 PUSH2 0x1ab4 1A39 56 *JUMP // Stack delta = -1 // Outputs[1] { @1A35 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1ab4 label_1A3A: // Incoming jump from 0x19BC, if memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[2] // { // @1A3B stack[-5] // @1A3F memory[stack[-5]:stack[-5] + 0x20] // } 1A3A 5B JUMPDEST 1A3B 84 DUP5 1A3C 60 PUSH1 0x00 1A3E 81 DUP2 1A3F 51 MLOAD 1A40 81 DUP2 1A41 10 LT 1A42 61 PUSH2 0x1a47 1A45 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A3B stack[0] = stack[-5] // @1A3C stack[1] = 0x00 // } // Block ends with conditional jump to 0x1a47, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] label_1A46: // Incoming jump from 0x1A45, if not 0x00 < memory[stack[-5]:stack[-5] + 0x20] 1A46 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1A46 assert(); } // Block terminates label_1A47: // Incoming jump from 0x1A45, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] // Inputs[6] // { // @1A4A stack[-1] // @1A4E stack[-2] // @1A4F memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1A60 memory[0x40:0x60] // @1A74 memory[0x40:0x60] // @1A7B address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } 1A47 5B JUMPDEST 1A48 60 PUSH1 0x20 1A4A 02 MUL 1A4B 60 PUSH1 0x20 1A4D 01 ADD 1A4E 01 ADD 1A4F 51 MLOAD 1A50 60 PUSH1 0x01 1A52 60 PUSH1 0x01 1A54 60 PUSH1 0xa0 1A56 1B SHL 1A57 03 SUB 1A58 16 AND 1A59 63 PUSH4 0x0dfe1681 1A5E 60 PUSH1 0x40 1A60 51 MLOAD 1A61 81 DUP2 1A62 63 PUSH4 0xffffffff 1A67 16 AND 1A68 60 PUSH1 0xe0 1A6A 1B SHL 1A6B 81 DUP2 1A6C 52 MSTORE 1A6D 60 PUSH1 0x04 1A6F 01 ADD 1A70 60 PUSH1 0x20 1A72 60 PUSH1 0x40 1A74 51 MLOAD 1A75 80 DUP1 1A76 83 DUP4 1A77 03 SUB 1A78 81 DUP2 1A79 86 DUP7 1A7A 80 DUP1 1A7B 3B EXTCODESIZE 1A7C 15 ISZERO 1A7D 80 DUP1 1A7E 15 ISZERO 1A7F 61 PUSH2 0x1a87 1A82 57 *JUMPI // Stack delta = +7 // Outputs[10] // { // @1A58 stack[-2] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1A59 stack[-1] = 0x0dfe1681 // @1A6C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x0dfe1681) << 0xe0 // @1A6F stack[0] = 0x04 + memory[0x40:0x60] // @1A70 stack[1] = 0x20 // @1A74 stack[2] = memory[0x40:0x60] // @1A77 stack[3] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1A78 stack[4] = memory[0x40:0x60] // @1A79 stack[5] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1A7C stack[6] = !address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } // Block ends with conditional jump to 0x1a87, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length label_1A83: // Incoming jump from 0x1A82, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[1] { @1A86 memory[0x00:0x00] } 1A83 60 PUSH1 0x00 1A85 80 DUP1 1A86 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A86 revert(memory[0x00:0x00]); } // Block terminates label_1A87: // Incoming jump from 0x1A82, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[8] // { // @1A89 msg.gas // @1A8A stack[-2] // @1A8A stack[-5] // @1A8A memory[stack[-3]:stack[-3] + stack[-4]] // @1A8A stack[-3] // @1A8A address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1A8A stack[-4] // @1A8A stack[-6] // } 1A87 5B JUMPDEST 1A88 50 POP 1A89 5A GAS 1A8A FA STATICCALL 1A8B 15 ISZERO 1A8C 80 DUP1 1A8D 15 ISZERO 1A8E 61 PUSH2 0x1a9b 1A91 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1A8A memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1A8B stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1a9b, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1A92: // Incoming jump from 0x1A91, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1A92 returndata.length // @1A96 returndata[0x00:0x00 + returndata.length] // @1A97 returndata.length // @1A9A memory[0x00:0x00 + returndata.length] // } 1A92 3D RETURNDATASIZE 1A93 60 PUSH1 0x00 1A95 80 DUP1 1A96 3E RETURNDATACOPY 1A97 3D RETURNDATASIZE 1A98 60 PUSH1 0x00 1A9A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1A96 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1A9A revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1A9B: // Incoming jump from 0x1A91, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1AA2 memory[0x40:0x60] // @1AA3 returndata.length // } 1A9B 5B JUMPDEST 1A9C 50 POP 1A9D 50 POP 1A9E 50 POP 1A9F 50 POP 1AA0 60 PUSH1 0x40 1AA2 51 MLOAD 1AA3 3D RETURNDATASIZE 1AA4 60 PUSH1 0x20 1AA6 81 DUP2 1AA7 10 LT 1AA8 15 ISZERO 1AA9 61 PUSH2 0x1ab1 1AAC 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1AA2 stack[-4] = memory[0x40:0x60] // @1AA3 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1ab1, if !(returndata.length < 0x20) label_1AAD: // Incoming jump from 0x1AAC, if not !(returndata.length < 0x20) // Inputs[1] { @1AB0 memory[0x00:0x00] } 1AAD 60 PUSH1 0x00 1AAF 80 DUP1 1AB0 FD *REVERT // Stack delta = +0 // Outputs[1] { @1AB0 revert(memory[0x00:0x00]); } // Block terminates label_1AB1: // Incoming jump from 0x1AAC, if !(returndata.length < 0x20) // Inputs[2] // { // @1AB3 memory[stack[-2]:stack[-2] + 0x20] // @1AB3 stack[-2] // } 1AB1 5B JUMPDEST 1AB2 50 POP 1AB3 51 MLOAD // Stack delta = -1 // Outputs[1] { @1AB3 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block continues label_1AB4: // Incoming jump from 0x1AB3 // Incoming jump from 0x1A39 // Inputs[4] // { // @1AB5 stack[-2] // @1AB5 stack[-1] // @1AC6 stack[-6] // @1ACA memory[stack[-6]:stack[-6] + 0x20] // } 1AB4 5B JUMPDEST 1AB5 90 SWAP1 1AB6 50 POP 1AB7 80 DUP1 1AB8 60 PUSH1 0x01 1ABA 60 PUSH1 0x01 1ABC 60 PUSH1 0xa0 1ABE 1B SHL 1ABF 03 SUB 1AC0 16 AND 1AC1 63 PUSH4 0xa9059cbb 1AC6 86 DUP7 1AC7 60 PUSH1 0x01 1AC9 81 DUP2 1ACA 51 MLOAD 1ACB 81 DUP2 1ACC 10 LT 1ACD 61 PUSH2 0x1ad2 1AD0 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @1AB5 stack[-2] = stack[-1] // @1AC0 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1AC1 stack[0] = 0xa9059cbb // @1AC6 stack[1] = stack[-6] // @1AC7 stack[2] = 0x01 // } // Block ends with conditional jump to 0x1ad2, if 0x01 < memory[stack[-6]:stack[-6] + 0x20] label_1AD1: // Incoming jump from 0x1AD0, if not 0x01 < memory[stack[-6]:stack[-6] + 0x20] 1AD1 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1AD1 assert(); } // Block terminates label_1AD2: // Incoming jump from 0x1AD0, if 0x01 < memory[stack[-6]:stack[-6] + 0x20] // Inputs[8] // { // @1AD5 stack[-1] // @1AD9 stack[-2] // @1ADA memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1ADB stack[-5] // @1AEA address(this) // @1AED memory[0x40:0x60] // @1B14 memory[0x40:0x60] // @1B1B address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // } 1AD2 5B JUMPDEST 1AD3 60 PUSH1 0x20 1AD5 02 MUL 1AD6 60 PUSH1 0x20 1AD8 01 ADD 1AD9 01 ADD 1ADA 51 MLOAD 1ADB 83 DUP4 1ADC 60 PUSH1 0x01 1ADE 60 PUSH1 0x01 1AE0 60 PUSH1 0xa0 1AE2 1B SHL 1AE3 03 SUB 1AE4 16 AND 1AE5 63 PUSH4 0x70a08231 1AEA 30 ADDRESS 1AEB 60 PUSH1 0x40 1AED 51 MLOAD 1AEE 82 DUP3 1AEF 63 PUSH4 0xffffffff 1AF4 16 AND 1AF5 60 PUSH1 0xe0 1AF7 1B SHL 1AF8 81 DUP2 1AF9 52 MSTORE 1AFA 60 PUSH1 0x04 1AFC 01 ADD 1AFD 80 DUP1 1AFE 82 DUP3 1AFF 60 PUSH1 0x01 1B01 60 PUSH1 0x01 1B03 60 PUSH1 0xa0 1B05 1B SHL 1B06 03 SUB 1B07 16 AND 1B08 81 DUP2 1B09 52 MSTORE 1B0A 60 PUSH1 0x20 1B0C 01 ADD 1B0D 91 SWAP2 1B0E 50 POP 1B0F 50 POP 1B10 60 PUSH1 0x20 1B12 60 PUSH1 0x40 1B14 51 MLOAD 1B15 80 DUP1 1B16 83 DUP4 1B17 03 SUB 1B18 81 DUP2 1B19 86 DUP7 1B1A 80 DUP1 1B1B 3B EXTCODESIZE 1B1C 15 ISZERO 1B1D 80 DUP1 1B1E 15 ISZERO 1B1F 61 PUSH2 0x1b27 1B22 57 *JUMPI // Stack delta = +8 // Outputs[12] // { // @1ADA stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1AE4 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1AE5 stack[0] = 0x70a08231 // @1AF9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x70a08231) << 0xe0 // @1B09 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & address(this) // @1B0D stack[1] = 0x20 + 0x04 + memory[0x40:0x60] // @1B10 stack[2] = 0x20 // @1B14 stack[3] = memory[0x40:0x60] // @1B17 stack[4] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1B18 stack[5] = memory[0x40:0x60] // @1B19 stack[6] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1B1C stack[7] = !address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // } // Block ends with conditional jump to 0x1b27, if !!address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length label_1B23: // Incoming jump from 0x1B22, if not !!address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // Inputs[1] { @1B26 memory[0x00:0x00] } 1B23 60 PUSH1 0x00 1B25 80 DUP1 1B26 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B26 revert(memory[0x00:0x00]); } // Block terminates label_1B27: // Incoming jump from 0x1B22, if !!address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // Inputs[8] // { // @1B29 msg.gas // @1B2A stack[-6] // @1B2A stack[-3] // @1B2A stack[-4] // @1B2A memory[stack[-3]:stack[-3] + stack[-4]] // @1B2A stack[-5] // @1B2A address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1B2A stack[-2] // } 1B27 5B JUMPDEST 1B28 50 POP 1B29 5A GAS 1B2A FA STATICCALL 1B2B 15 ISZERO 1B2C 80 DUP1 1B2D 15 ISZERO 1B2E 61 PUSH2 0x1b3b 1B31 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1B2A memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1B2B stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1b3b, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1B32: // Incoming jump from 0x1B31, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1B32 returndata.length // @1B36 returndata[0x00:0x00 + returndata.length] // @1B37 returndata.length // @1B3A memory[0x00:0x00 + returndata.length] // } 1B32 3D RETURNDATASIZE 1B33 60 PUSH1 0x00 1B35 80 DUP1 1B36 3E RETURNDATACOPY 1B37 3D RETURNDATASIZE 1B38 60 PUSH1 0x00 1B3A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1B36 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1B3A revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1B3B: // Incoming jump from 0x1B31, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1B42 memory[0x40:0x60] // @1B43 returndata.length // } 1B3B 5B JUMPDEST 1B3C 50 POP 1B3D 50 POP 1B3E 50 POP 1B3F 50 POP 1B40 60 PUSH1 0x40 1B42 51 MLOAD 1B43 3D RETURNDATASIZE 1B44 60 PUSH1 0x20 1B46 81 DUP2 1B47 10 LT 1B48 15 ISZERO 1B49 61 PUSH2 0x1b51 1B4C 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1B42 stack[-4] = memory[0x40:0x60] // @1B43 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1b51, if !(returndata.length < 0x20) label_1B4D: // Incoming jump from 0x1B4C, if not !(returndata.length < 0x20) // Inputs[1] { @1B50 memory[0x00:0x00] } 1B4D 60 PUSH1 0x00 1B4F 80 DUP1 1B50 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B50 revert(memory[0x00:0x00]); } // Block terminates label_1B51: // Incoming jump from 0x1B4C, if !(returndata.length < 0x20) // Inputs[8] // { // @1B53 memory[stack[-2]:stack[-2] + 0x20] // @1B53 stack[-2] // @1B57 memory[0x40:0x60] // @1B63 stack[-4] // @1B72 stack[-3] // @1B81 memory[0x40:0x60] // @1B94 stack[-5] // @1B96 address(stack[-5]).code.length // } 1B51 5B JUMPDEST 1B52 50 POP 1B53 51 MLOAD 1B54 60 PUSH1 0x40 1B56 80 DUP1 1B57 51 MLOAD 1B58 60 PUSH1 0x01 1B5A 60 PUSH1 0x01 1B5C 60 PUSH1 0xe0 1B5E 1B SHL 1B5F 03 SUB 1B60 19 NOT 1B61 60 PUSH1 0xe0 1B63 86 DUP7 1B64 90 SWAP1 1B65 1B SHL 1B66 16 AND 1B67 81 DUP2 1B68 52 MSTORE 1B69 60 PUSH1 0x01 1B6B 60 PUSH1 0x01 1B6D 60 PUSH1 0xa0 1B6F 1B SHL 1B70 03 SUB 1B71 90 SWAP1 1B72 93 SWAP4 1B73 16 AND 1B74 60 PUSH1 0x04 1B76 84 DUP5 1B77 01 ADD 1B78 52 MSTORE 1B79 60 PUSH1 0x24 1B7B 83 DUP4 1B7C 01 ADD 1B7D 91 SWAP2 1B7E 90 SWAP1 1B7F 91 SWAP2 1B80 52 MSTORE 1B81 51 MLOAD 1B82 60 PUSH1 0x44 1B84 80 DUP1 1B85 83 DUP4 1B86 01 ADD 1B87 92 SWAP3 1B88 60 PUSH1 0x20 1B8A 92 SWAP3 1B8B 91 SWAP2 1B8C 90 SWAP1 1B8D 82 DUP3 1B8E 90 SWAP1 1B8F 03 SUB 1B90 01 ADD 1B91 81 DUP2 1B92 60 PUSH1 0x00 1B94 87 DUP8 1B95 80 DUP1 1B96 3B EXTCODESIZE 1B97 15 ISZERO 1B98 80 DUP1 1B99 15 ISZERO 1B9A 61 PUSH2 0x1ba2 1B9D 57 *JUMPI // Stack delta = +5 // Outputs[11] // { // @1B68 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (stack[-4] << 0xe0) & ~((0x01 << 0xe0) - 0x01) // @1B78 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1B80 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @1B87 stack[-3] = memory[0x40:0x60] + 0x44 // @1B8A stack[-2] = 0x20 // @1B8B stack[-1] = memory[0x40:0x60] // @1B90 stack[0] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @1B91 stack[1] = memory[0x40:0x60] // @1B92 stack[2] = 0x00 // @1B94 stack[3] = stack[-5] // @1B97 stack[4] = !address(stack[-5]).code.length // } // Block ends with conditional jump to 0x1ba2, if !!address(stack[-5]).code.length label_1B9E: // Incoming jump from 0x1B9D, if not !!address(stack[-5]).code.length // Inputs[1] { @1BA1 memory[0x00:0x00] } 1B9E 60 PUSH1 0x00 1BA0 80 DUP1 1BA1 FD *REVERT // Stack delta = +0 // Outputs[1] { @1BA1 revert(memory[0x00:0x00]); } // Block terminates label_1BA2: // Incoming jump from 0x1B9D, if !!address(stack[-5]).code.length // Inputs[9] // { // @1BA4 msg.gas // @1BA5 stack[-7] // @1BA5 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1BA5 stack[-4] // @1BA5 stack[-5] // @1BA5 stack[-3] // @1BA5 stack[-6] // @1BA5 memory[stack[-4]:stack[-4] + stack[-5]] // @1BA5 stack[-2] // } 1BA2 5B JUMPDEST 1BA3 50 POP 1BA4 5A GAS 1BA5 F1 CALL 1BA6 15 ISZERO 1BA7 80 DUP1 1BA8 15 ISZERO 1BA9 61 PUSH2 0x1bb6 1BAC 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1BA5 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1BA6 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 0x1bb6, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1BAD: // Incoming jump from 0x1BAC, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1BAD returndata.length // @1BB1 returndata[0x00:0x00 + returndata.length] // @1BB2 returndata.length // @1BB5 memory[0x00:0x00 + returndata.length] // } 1BAD 3D RETURNDATASIZE 1BAE 60 PUSH1 0x00 1BB0 80 DUP1 1BB1 3E RETURNDATACOPY 1BB2 3D RETURNDATASIZE 1BB3 60 PUSH1 0x00 1BB5 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1BB1 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1BB5 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1BB6: // Incoming jump from 0x1BAC, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1BBD memory[0x40:0x60] // @1BBE returndata.length // } 1BB6 5B JUMPDEST 1BB7 50 POP 1BB8 50 POP 1BB9 50 POP 1BBA 50 POP 1BBB 60 PUSH1 0x40 1BBD 51 MLOAD 1BBE 3D RETURNDATASIZE 1BBF 60 PUSH1 0x20 1BC1 81 DUP2 1BC2 10 LT 1BC3 15 ISZERO 1BC4 61 PUSH2 0x1bcc 1BC7 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1BBD stack[-4] = memory[0x40:0x60] // @1BBE stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1bcc, if !(returndata.length < 0x20) label_1BC8: // Incoming jump from 0x1BC7, if not !(returndata.length < 0x20) // Inputs[1] { @1BCB memory[0x00:0x00] } 1BC8 60 PUSH1 0x00 1BCA 80 DUP1 1BCB FD *REVERT // Stack delta = +0 // Outputs[1] { @1BCB revert(memory[0x00:0x00]); } // Block terminates label_1BCC: // Incoming jump from 0x1BC7, if !(returndata.length < 0x20) // Inputs[2] // { // @1BD0 stack[-2] // @1BD3 stack[-4] // } 1BCC 5B JUMPDEST 1BCD 50 POP 1BCE 60 PUSH1 0x01 1BD0 90 SWAP1 1BD1 50 POP 1BD2 5B JUMPDEST 1BD3 82 DUP3 1BD4 60 PUSH1 0x01 1BD6 01 ADD 1BD7 81 DUP2 1BD8 10 LT 1BD9 15 ISZERO 1BDA 61 PUSH2 0x1c3d 1BDD 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1BD0 stack[-2] = 0x01 } // Block ends with conditional jump to 0x1c3d, if !(0x01 < 0x01 + stack[-4]) label_1BDE: // Incoming jump from 0x1BDD, if not !(0x01 < 0x01 + stack[-4]) // Incoming jump from 0x1BDD, if not !(stack[-1] < 0x01 + stack[-3]) // Inputs[3] // { // @1BE1 stack[-6] // @1BE2 stack[-1] // @1BE4 memory[stack[-6]:stack[-6] + 0x20] // } 1BDE 61 PUSH2 0x1c35 1BE1 86 DUP7 1BE2 82 DUP3 1BE3 81 DUP2 1BE4 51 MLOAD 1BE5 81 DUP2 1BE6 10 LT 1BE7 61 PUSH2 0x1bec 1BEA 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1BDE stack[0] = 0x1c35 // @1BE1 stack[1] = stack[-6] // @1BE2 stack[2] = stack[-1] // } // Block ends with conditional call to 0x1bec, returns to 0x1C35, if stack[-1] < memory[stack[-6]:stack[-6] + 0x20] label_1BEB: // Incoming jump from 0x1BEA, if not stack[-1] < memory[stack[-6]:stack[-6] + 0x20] 1BEB FE *ASSERT // Stack delta = +0 // Outputs[1] { @1BEB assert(); } // Block terminates label_1BEC: // Incoming call from 0x1BEA, returns to 0x1C35, if stack[-1] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[6] // { // @1BEF stack[-1] // @1BF3 stack[-2] // @1BF4 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1BF5 stack[-7] // @1BF8 stack[-4] // @1BFB memory[stack[-7]:stack[-7] + 0x20] // } 1BEC 5B JUMPDEST 1BED 60 PUSH1 0x20 1BEF 02 MUL 1BF0 60 PUSH1 0x20 1BF2 01 ADD 1BF3 01 ADD 1BF4 51 MLOAD 1BF5 85 DUP6 1BF6 60 PUSH1 0x01 1BF8 84 DUP5 1BF9 03 SUB 1BFA 81 DUP2 1BFB 51 MLOAD 1BFC 81 DUP2 1BFD 10 LT 1BFE 61 PUSH2 0x1c03 1C01 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1BF4 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1BF5 stack[-1] = stack[-7] // @1BF9 stack[0] = stack[-4] - 0x01 // } // Block ends with conditional jump to 0x1c03, if stack[-4] - 0x01 < memory[stack[-7]:stack[-7] + 0x20] label_1C02: // Incoming jump from 0x1C01, if not stack[-4] - 0x01 < memory[stack[-7]:stack[-7] + 0x20] 1C02 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1C02 assert(); } // Block terminates label_1C03: // Incoming jump from 0x1C01, if stack[-4] - 0x01 < memory[stack[-7]:stack[-7] + 0x20] // Inputs[6] // { // @1C06 stack[-1] // @1C0A stack[-2] // @1C0B memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1C0C stack[-9] // @1C0D stack[-5] // @1C0F memory[stack[-9]:stack[-9] + 0x20] // } 1C03 5B JUMPDEST 1C04 60 PUSH1 0x20 1C06 02 MUL 1C07 60 PUSH1 0x20 1C09 01 ADD 1C0A 01 ADD 1C0B 51 MLOAD 1C0C 87 DUP8 1C0D 84 DUP5 1C0E 81 DUP2 1C0F 51 MLOAD 1C10 81 DUP2 1C11 10 LT 1C12 61 PUSH2 0x1c17 1C15 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1C0B stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1C0C stack[-1] = stack[-9] // @1C0D stack[0] = stack[-5] // } // Block ends with conditional jump to 0x1c17, if stack[-5] < memory[stack[-9]:stack[-9] + 0x20] label_1C16: // Incoming jump from 0x1C15, if not stack[-5] < memory[stack[-9]:stack[-9] + 0x20] 1C16 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1C16 assert(); } // Block terminates label_1C17: // Incoming jump from 0x1C15, if stack[-5] < memory[stack[-9]:stack[-9] + 0x20] // Inputs[5] // { // @1C1A stack[-1] // @1C1E stack[-2] // @1C1F memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1C20 stack[-8] // @1C21 stack[-6] // } 1C17 5B JUMPDEST 1C18 60 PUSH1 0x20 1C1A 02 MUL 1C1B 60 PUSH1 0x20 1C1D 01 ADD 1C1E 01 ADD 1C1F 51 MLOAD 1C20 86 DUP7 1C21 85 DUP6 1C22 14 EQ 1C23 61 PUSH2 0x15fb 1C26 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1C1F stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with conditional jump to 0x15fb, if stack[-6] == stack[-8] label_1C27: // Incoming jump from 0x1C26, if not stack[-6] == stack[-8] // Inputs[3] // { // @1C27 stack[-10] // @1C28 stack[-5] // @1C2D memory[stack[-10]:stack[-10] + 0x20] // } 1C27 89 DUP10 1C28 85 DUP6 1C29 60 PUSH1 0x01 1C2B 01 ADD 1C2C 81 DUP2 1C2D 51 MLOAD 1C2E 81 DUP2 1C2F 10 LT 1C30 61 PUSH2 0x15ee 1C33 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C27 stack[0] = stack[-10] // @1C2B stack[1] = 0x01 + stack[-5] // } // Block ends with conditional jump to 0x15ee, if 0x01 + stack[-5] < memory[stack[-10]:stack[-10] + 0x20] label_1C34: // Incoming jump from 0x1C33, if not 0x01 + stack[-5] < memory[stack[-10]:stack[-10] + 0x20] 1C34 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1C34 assert(); } // Block terminates label_1C35: // Incoming return from call to 0x1BEC at 0x1BEA // Inputs[1] { @1C38 stack[-1] } 1C35 5B JUMPDEST 1C36 60 PUSH1 0x01 1C38 01 ADD 1C39 61 PUSH2 0x1bd2 1C3C 56 *JUMP // Stack delta = +0 // Outputs[1] { @1C38 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x1bd2 label_1C3D: // Incoming jump from 0x1BDD, if !(0x01 < 0x01 + stack[-4]) // Incoming jump from 0x1BDD, if !(stack[-1] < 0x01 + stack[-3]) // Inputs[2] // { // @1C41 stack[-5] // @1C45 memory[stack[-5]:stack[-5] + 0x20] // } 1C3D 5B JUMPDEST 1C3E 50 POP 1C3F 60 PUSH1 0x00 1C41 84 DUP5 1C42 60 PUSH1 0x00 1C44 81 DUP2 1C45 51 MLOAD 1C46 81 DUP2 1C47 10 LT 1C48 61 PUSH2 0x1c4d 1C4B 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @1C3F stack[-1] = 0x00 // @1C41 stack[0] = stack[-5] // @1C42 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1c4d, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] label_1C4C: // Incoming jump from 0x1C4B, if not 0x00 < memory[stack[-5]:stack[-5] + 0x20] 1C4C FE *ASSERT // Stack delta = +0 // Outputs[1] { @1C4C assert(); } // Block terminates label_1C4D: // Incoming jump from 0x1C4B, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] // Inputs[3] // { // @1C50 stack[-1] // @1C54 stack[-2] // @1C55 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 1C4D 5B JUMPDEST 1C4E 60 PUSH1 0x20 1C50 02 MUL 1C51 60 PUSH1 0x20 1C53 01 ADD 1C54 01 ADD 1C55 51 MLOAD 1C56 61 PUSH2 0x1cd7 1C59 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1cd7, if memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_1C5A: // Incoming jump from 0x1C59, if not memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[2] // { // @1C5A stack[-6] // @1C5E memory[stack[-6]:stack[-6] + 0x20] // } 1C5A 85 DUP6 1C5B 60 PUSH1 0x00 1C5D 81 DUP2 1C5E 51 MLOAD 1C5F 81 DUP2 1C60 10 LT 1C61 61 PUSH2 0x1c66 1C64 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C5A stack[0] = stack[-6] // @1C5B stack[1] = 0x00 // } // Block ends with conditional jump to 0x1c66, if 0x00 < memory[stack[-6]:stack[-6] + 0x20] label_1C65: // Incoming jump from 0x1C64, if not 0x00 < memory[stack[-6]:stack[-6] + 0x20] 1C65 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1C65 assert(); } // Block terminates label_1C66: // Incoming jump from 0x1C64, if 0x00 < memory[stack[-6]:stack[-6] + 0x20] // Inputs[6] // { // @1C69 stack[-1] // @1C6D stack[-2] // @1C6E memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1C7F memory[0x40:0x60] // @1C93 memory[0x40:0x60] // @1C9A address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } 1C66 5B JUMPDEST 1C67 60 PUSH1 0x20 1C69 02 MUL 1C6A 60 PUSH1 0x20 1C6C 01 ADD 1C6D 01 ADD 1C6E 51 MLOAD 1C6F 60 PUSH1 0x01 1C71 60 PUSH1 0x01 1C73 60 PUSH1 0xa0 1C75 1B SHL 1C76 03 SUB 1C77 16 AND 1C78 63 PUSH4 0x0dfe1681 1C7D 60 PUSH1 0x40 1C7F 51 MLOAD 1C80 81 DUP2 1C81 63 PUSH4 0xffffffff 1C86 16 AND 1C87 60 PUSH1 0xe0 1C89 1B SHL 1C8A 81 DUP2 1C8B 52 MSTORE 1C8C 60 PUSH1 0x04 1C8E 01 ADD 1C8F 60 PUSH1 0x20 1C91 60 PUSH1 0x40 1C93 51 MLOAD 1C94 80 DUP1 1C95 83 DUP4 1C96 03 SUB 1C97 81 DUP2 1C98 86 DUP7 1C99 80 DUP1 1C9A 3B EXTCODESIZE 1C9B 15 ISZERO 1C9C 80 DUP1 1C9D 15 ISZERO 1C9E 61 PUSH2 0x1ca6 1CA1 57 *JUMPI // Stack delta = +7 // Outputs[10] // { // @1C77 stack[-2] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1C78 stack[-1] = 0x0dfe1681 // @1C8B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x0dfe1681) << 0xe0 // @1C8E stack[0] = 0x04 + memory[0x40:0x60] // @1C8F stack[1] = 0x20 // @1C93 stack[2] = memory[0x40:0x60] // @1C96 stack[3] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1C97 stack[4] = memory[0x40:0x60] // @1C98 stack[5] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1C9B stack[6] = !address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } // Block ends with conditional jump to 0x1ca6, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length label_1CA2: // Incoming jump from 0x1CA1, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[1] { @1CA5 memory[0x00:0x00] } 1CA2 60 PUSH1 0x00 1CA4 80 DUP1 1CA5 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CA5 revert(memory[0x00:0x00]); } // Block terminates label_1CA6: // Incoming jump from 0x1CA1, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[8] // { // @1CA8 msg.gas // @1CA9 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1CA9 stack[-5] // @1CA9 memory[stack[-3]:stack[-3] + stack[-4]] // @1CA9 stack[-3] // @1CA9 stack[-6] // @1CA9 stack[-4] // @1CA9 stack[-2] // } 1CA6 5B JUMPDEST 1CA7 50 POP 1CA8 5A GAS 1CA9 FA STATICCALL 1CAA 15 ISZERO 1CAB 80 DUP1 1CAC 15 ISZERO 1CAD 61 PUSH2 0x1cba 1CB0 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1CA9 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1CAA stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1cba, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1CB1: // Incoming jump from 0x1CB0, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1CB1 returndata.length // @1CB5 returndata[0x00:0x00 + returndata.length] // @1CB6 returndata.length // @1CB9 memory[0x00:0x00 + returndata.length] // } 1CB1 3D RETURNDATASIZE 1CB2 60 PUSH1 0x00 1CB4 80 DUP1 1CB5 3E RETURNDATACOPY 1CB6 3D RETURNDATASIZE 1CB7 60 PUSH1 0x00 1CB9 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1CB5 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1CB9 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1CBA: // Incoming jump from 0x1CB0, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1CC1 memory[0x40:0x60] // @1CC2 returndata.length // } 1CBA 5B JUMPDEST 1CBB 50 POP 1CBC 50 POP 1CBD 50 POP 1CBE 50 POP 1CBF 60 PUSH1 0x40 1CC1 51 MLOAD 1CC2 3D RETURNDATASIZE 1CC3 60 PUSH1 0x20 1CC5 81 DUP2 1CC6 10 LT 1CC7 15 ISZERO 1CC8 61 PUSH2 0x1cd0 1CCB 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1CC1 stack[-4] = memory[0x40:0x60] // @1CC2 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1cd0, if !(returndata.length < 0x20) label_1CCC: // Incoming jump from 0x1CCB, if not !(returndata.length < 0x20) // Inputs[1] { @1CCF memory[0x00:0x00] } 1CCC 60 PUSH1 0x00 1CCE 80 DUP1 1CCF FD *REVERT // Stack delta = +0 // Outputs[1] { @1CCF revert(memory[0x00:0x00]); } // Block terminates label_1CD0: // Incoming jump from 0x1CCB, if !(returndata.length < 0x20) // Inputs[2] // { // @1CD2 stack[-2] // @1CD2 memory[stack[-2]:stack[-2] + 0x20] // } 1CD0 5B JUMPDEST 1CD1 50 POP 1CD2 51 MLOAD 1CD3 61 PUSH2 0x1d51 1CD6 56 *JUMP // Stack delta = -1 // Outputs[1] { @1CD2 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1d51 label_1CD7: // Incoming jump from 0x1C59, if memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[2] // { // @1CD8 stack[-6] // @1CDC memory[stack[-6]:stack[-6] + 0x20] // } 1CD7 5B JUMPDEST 1CD8 85 DUP6 1CD9 60 PUSH1 0x00 1CDB 81 DUP2 1CDC 51 MLOAD 1CDD 81 DUP2 1CDE 10 LT 1CDF 61 PUSH2 0x1ce4 1CE2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1CD8 stack[0] = stack[-6] // @1CD9 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1ce4, if 0x00 < memory[stack[-6]:stack[-6] + 0x20] label_1CE3: // Incoming jump from 0x1CE2, if not 0x00 < memory[stack[-6]:stack[-6] + 0x20] 1CE3 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1CE3 assert(); } // Block terminates label_1CE4: // Incoming jump from 0x1CE2, if 0x00 < memory[stack[-6]:stack[-6] + 0x20] // Inputs[6] // { // @1CE7 stack[-1] // @1CEB stack[-2] // @1CEC memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1CFD memory[0x40:0x60] // @1D11 memory[0x40:0x60] // @1D18 address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } 1CE4 5B JUMPDEST 1CE5 60 PUSH1 0x20 1CE7 02 MUL 1CE8 60 PUSH1 0x20 1CEA 01 ADD 1CEB 01 ADD 1CEC 51 MLOAD 1CED 60 PUSH1 0x01 1CEF 60 PUSH1 0x01 1CF1 60 PUSH1 0xa0 1CF3 1B SHL 1CF4 03 SUB 1CF5 16 AND 1CF6 63 PUSH4 0xd21220a7 1CFB 60 PUSH1 0x40 1CFD 51 MLOAD 1CFE 81 DUP2 1CFF 63 PUSH4 0xffffffff 1D04 16 AND 1D05 60 PUSH1 0xe0 1D07 1B SHL 1D08 81 DUP2 1D09 52 MSTORE 1D0A 60 PUSH1 0x04 1D0C 01 ADD 1D0D 60 PUSH1 0x20 1D0F 60 PUSH1 0x40 1D11 51 MLOAD 1D12 80 DUP1 1D13 83 DUP4 1D14 03 SUB 1D15 81 DUP2 1D16 86 DUP7 1D17 80 DUP1 1D18 3B EXTCODESIZE 1D19 15 ISZERO 1D1A 80 DUP1 1D1B 15 ISZERO 1D1C 61 PUSH2 0x1d24 1D1F 57 *JUMPI // Stack delta = +7 // Outputs[10] // { // @1CF5 stack[-2] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1CF6 stack[-1] = 0xd21220a7 // @1D09 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xd21220a7) << 0xe0 // @1D0C stack[0] = 0x04 + memory[0x40:0x60] // @1D0D stack[1] = 0x20 // @1D11 stack[2] = memory[0x40:0x60] // @1D14 stack[3] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1D15 stack[4] = memory[0x40:0x60] // @1D16 stack[5] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1D19 stack[6] = !address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } // Block ends with conditional jump to 0x1d24, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length label_1D20: // Incoming jump from 0x1D1F, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[1] { @1D23 memory[0x00:0x00] } 1D20 60 PUSH1 0x00 1D22 80 DUP1 1D23 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D23 revert(memory[0x00:0x00]); } // Block terminates label_1D24: // Incoming jump from 0x1D1F, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[8] // { // @1D26 msg.gas // @1D27 stack[-5] // @1D27 memory[stack[-3]:stack[-3] + stack[-4]] // @1D27 stack[-6] // @1D27 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1D27 stack[-4] // @1D27 stack[-2] // @1D27 stack[-3] // } 1D24 5B JUMPDEST 1D25 50 POP 1D26 5A GAS 1D27 FA STATICCALL 1D28 15 ISZERO 1D29 80 DUP1 1D2A 15 ISZERO 1D2B 61 PUSH2 0x1d38 1D2E 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1D27 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1D28 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1d38, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1D2F: // Incoming jump from 0x1D2E, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1D2F returndata.length // @1D33 returndata[0x00:0x00 + returndata.length] // @1D34 returndata.length // @1D37 memory[0x00:0x00 + returndata.length] // } 1D2F 3D RETURNDATASIZE 1D30 60 PUSH1 0x00 1D32 80 DUP1 1D33 3E RETURNDATACOPY 1D34 3D RETURNDATASIZE 1D35 60 PUSH1 0x00 1D37 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1D33 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1D37 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1D38: // Incoming jump from 0x1D2E, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1D3F memory[0x40:0x60] // @1D40 returndata.length // } 1D38 5B JUMPDEST 1D39 50 POP 1D3A 50 POP 1D3B 50 POP 1D3C 50 POP 1D3D 60 PUSH1 0x40 1D3F 51 MLOAD 1D40 3D RETURNDATASIZE 1D41 60 PUSH1 0x20 1D43 81 DUP2 1D44 10 LT 1D45 15 ISZERO 1D46 61 PUSH2 0x1d4e 1D49 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1D3F stack[-4] = memory[0x40:0x60] // @1D40 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1d4e, if !(returndata.length < 0x20) label_1D4A: // Incoming jump from 0x1D49, if not !(returndata.length < 0x20) // Inputs[1] { @1D4D memory[0x00:0x00] } 1D4A 60 PUSH1 0x00 1D4C 80 DUP1 1D4D FD *REVERT // Stack delta = +0 // Outputs[1] { @1D4D revert(memory[0x00:0x00]); } // Block terminates label_1D4E: // Incoming jump from 0x1D49, if !(returndata.length < 0x20) // Inputs[2] // { // @1D50 stack[-2] // @1D50 memory[stack[-2]:stack[-2] + 0x20] // } 1D4E 5B JUMPDEST 1D4F 50 POP 1D50 51 MLOAD // Stack delta = -1 // Outputs[1] { @1D50 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block continues label_1D51: // Incoming jump from 0x1D50 // Incoming jump from 0x1CD6 // Inputs[5] // { // @1D52 stack[-1] // @1D52 stack[-2] // @1D56 stack[-8] // @1D5E stack[-7] // @1D62 memory[stack[-7]:stack[-7] + 0x20] // } 1D51 5B JUMPDEST 1D52 90 SWAP1 1D53 50 POP 1D54 60 PUSH1 0x01 1D56 87 DUP8 1D57 03 SUB 1D58 96 SWAP7 1D59 50 POP 1D5A 61 PUSH2 0x1980 1D5D 81 DUP2 1D5E 87 DUP8 1D5F 60 PUSH1 0x00 1D61 81 DUP2 1D62 51 MLOAD 1D63 81 DUP2 1D64 10 LT 1D65 61 PUSH2 0x18f0 1D68 57 *JUMPI // Stack delta = +3 // Outputs[6] // { // @1D52 stack[-2] = stack[-1] // @1D58 stack[-8] = stack[-8] - 0x01 // @1D5A stack[-1] = 0x1980 // @1D5D stack[0] = stack[-1] // @1D5E stack[1] = stack[-7] // @1D5F stack[2] = 0x00 // } // Block ends with conditional call to 0x18f0, returns to 0x1980, if 0x00 < memory[stack[-7]:stack[-7] + 0x20] label_1D69: // Incoming jump from 0x1D68, if not 0x00 < memory[stack[-7]:stack[-7] + 0x20] 1D69 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1D69 assert(); } // Block terminates label_1D6A: // Incoming call from 0x0D89, returns to 0x0D8A // Incoming call from 0x0B1B, returns to 0x0B1C // Incoming call from 0x0FFE, returns to 0x0FFF // Incoming call from 0x0F06, returns to 0x0F07 // Inputs[2] // { // @1D6B msg.sender // @1D6C stack[-1] // } 1D6A 5B JUMPDEST 1D6B 33 CALLER 1D6C 90 SWAP1 1D6D 56 *JUMP // Stack delta = +0 // Outputs[1] { @1D6C stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_1D6E: // Incoming call from 0x265E, returns to 0x265F // Incoming call from 0x0C2F, returns to 0x0C30 // Inputs[2] // { // @1D72 stack[-1] // @1D73 memory[stack[-1]:stack[-1] + 0x20] // } 1D6E 5B JUMPDEST 1D6F 60 PUSH1 0x60 1D71 80 DUP1 1D72 82 DUP3 1D73 51 MLOAD 1D74 67 PUSH8 0xffffffffffffffff 1D7D 81 DUP2 1D7E 11 GT 1D7F 80 DUP1 1D80 15 ISZERO 1D81 61 PUSH2 0x1d89 1D84 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1D6F stack[0] = 0x60 // @1D71 stack[1] = 0x60 // @1D73 stack[2] = memory[stack[-1]:stack[-1] + 0x20] // @1D7E stack[3] = memory[stack[-1]:stack[-1] + 0x20] > 0xffffffffffffffff // } // Block ends with conditional jump to 0x1d89, if !(memory[stack[-1]:stack[-1] + 0x20] > 0xffffffffffffffff) label_1D85: // Incoming jump from 0x1D84, if not !(memory[stack[-1]:stack[-1] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1D88 memory[0x00:0x00] } 1D85 60 PUSH1 0x00 1D87 80 DUP1 1D88 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D88 revert(memory[0x00:0x00]); } // Block terminates label_1D89: // Incoming jump from 0x1D84, if !(memory[stack[-1]:stack[-1] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1D8D memory[0x40:0x60] // @1D8E stack[-2] // } 1D89 5B JUMPDEST 1D8A 50 POP 1D8B 60 PUSH1 0x40 1D8D 51 MLOAD 1D8E 90 SWAP1 1D8F 80 DUP1 1D90 82 DUP3 1D91 52 MSTORE 1D92 80 DUP1 1D93 60 PUSH1 0x20 1D95 02 MUL 1D96 60 PUSH1 0x20 1D98 01 ADD 1D99 82 DUP3 1D9A 01 ADD 1D9B 60 PUSH1 0x40 1D9D 52 MSTORE 1D9E 80 DUP1 1D9F 15 ISZERO 1DA0 61 PUSH2 0x1db3 1DA3 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1D8E stack[-2] = memory[0x40:0x60] // @1D8E stack[-1] = stack[-2] // @1D91 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @1D9D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // } // Block ends with conditional jump to 0x1db3, if !stack[-2] label_1DA4: // Incoming jump from 0x1DA3, if not !stack[-2] // Inputs[7] // { // @1DA4 stack[-2] // @1DAA stack[-1] // @1DAD msg.data.length // @1DAF msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @1DB5 stack[-4] // @1DB7 stack[-5] // @1DB8 memory[stack[-5]:stack[-5] + 0x20] // } 1DA4 81 DUP2 1DA5 60 PUSH1 0x20 1DA7 01 ADD 1DA8 60 PUSH1 0x20 1DAA 82 DUP3 1DAB 02 MUL 1DAC 80 DUP1 1DAD 36 CALLDATASIZE 1DAE 83 DUP4 1DAF 37 CALLDATACOPY 1DB0 01 ADD 1DB1 90 SWAP1 1DB2 50 POP 1DB3 5B JUMPDEST 1DB4 50 POP 1DB5 91 SWAP2 1DB6 50 POP 1DB7 82 DUP3 1DB8 51 MLOAD 1DB9 67 PUSH8 0xffffffffffffffff 1DC2 81 DUP2 1DC3 11 GT 1DC4 80 DUP1 1DC5 15 ISZERO 1DC6 61 PUSH2 0x1dce 1DC9 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1DAF memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @1DB5 stack[-4] = stack[-2] // @1DB8 stack[-2] = memory[stack[-5]:stack[-5] + 0x20] // @1DC3 stack[-1] = memory[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff // } // Block ends with conditional jump to 0x1dce, if !(memory[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) label_1DCA: // Incoming jump from 0x1DC9, if not !(memory[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) // Incoming jump from 0x1DC9, if not !(memory[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1DCD memory[0x00:0x00] } 1DCA 60 PUSH1 0x00 1DCC 80 DUP1 1DCD FD *REVERT // Stack delta = +0 // Outputs[1] { @1DCD revert(memory[0x00:0x00]); } // Block terminates label_1DCE: // Incoming jump from 0x1DC9, if !(memory[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) // Incoming jump from 0x1DC9, if !(memory[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1DD2 memory[0x40:0x60] // @1DD3 stack[-2] // } 1DCE 5B JUMPDEST 1DCF 50 POP 1DD0 60 PUSH1 0x40 1DD2 51 MLOAD 1DD3 90 SWAP1 1DD4 80 DUP1 1DD5 82 DUP3 1DD6 52 MSTORE 1DD7 80 DUP1 1DD8 60 PUSH1 0x20 1DDA 02 MUL 1DDB 60 PUSH1 0x20 1DDD 01 ADD 1DDE 82 DUP3 1DDF 01 ADD 1DE0 60 PUSH1 0x40 1DE2 52 MSTORE 1DE3 80 DUP1 1DE4 15 ISZERO 1DE5 61 PUSH2 0x1df8 1DE8 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1DD3 stack[-2] = memory[0x40:0x60] // @1DD3 stack[-1] = stack[-2] // @1DD6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @1DE2 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // } // Block ends with conditional jump to 0x1df8, if !stack[-2] label_1DE9: // Incoming jump from 0x1DE8, if not !stack[-2] // Inputs[7] // { // @1DE9 stack[-2] // @1DEF stack[-1] // @1DF2 msg.data.length // @1DF4 msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @1DFA stack[-3] // @1DFF stack[-5] // @1E00 memory[stack[-5]:stack[-5] + 0x20] // } 1DE9 81 DUP2 1DEA 60 PUSH1 0x20 1DEC 01 ADD 1DED 60 PUSH1 0x20 1DEF 82 DUP3 1DF0 02 MUL 1DF1 80 DUP1 1DF2 36 CALLDATASIZE 1DF3 83 DUP4 1DF4 37 CALLDATACOPY 1DF5 01 ADD 1DF6 90 SWAP1 1DF7 50 POP 1DF8 5B JUMPDEST 1DF9 50 POP 1DFA 90 SWAP1 1DFB 50 POP 1DFC 60 PUSH1 0x00 1DFE 5B JUMPDEST 1DFF 83 DUP4 1E00 51 MLOAD 1E01 81 DUP2 1E02 10 LT 1E03 15 ISZERO 1E04 61 PUSH2 0x1ed5 1E07 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @1DF4 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @1DFA stack[-3] = stack[-2] // @1DFC stack[-2] = 0x00 // } // Block ends with conditional jump to 0x1ed5, if !(0x00 < memory[stack[-5]:stack[-5] + 0x20]) label_1E08: // Incoming jump from 0x1E07, if not !(0x00 < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1E07, if not !(0x00 < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1E07, if not !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[3] // { // @1E08 stack[-4] // @1E09 stack[-1] // @1E0B memory[stack[-4]:stack[-4] + 0x20] // } 1E08 83 DUP4 1E09 81 DUP2 1E0A 81 DUP2 1E0B 51 MLOAD 1E0C 81 DUP2 1E0D 10 LT 1E0E 61 PUSH2 0x1e13 1E11 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E08 stack[0] = stack[-4] // @1E09 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1e13, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] label_1E12: // Incoming jump from 0x1E11, if not stack[-1] < memory[stack[-4]:stack[-4] + 0x20] 1E12 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1E12 assert(); } // Block terminates label_1E13: // Incoming jump from 0x1E11, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[6] // { // @1E16 stack[-1] // @1E1A stack[-2] // @1E1B memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1E2C memory[0x40:0x60] // @1E40 memory[0x40:0x60] // @1E47 address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } 1E13 5B JUMPDEST 1E14 60 PUSH1 0x20 1E16 02 MUL 1E17 60 PUSH1 0x20 1E19 01 ADD 1E1A 01 ADD 1E1B 51 MLOAD 1E1C 60 PUSH1 0x01 1E1E 60 PUSH1 0x01 1E20 60 PUSH1 0xa0 1E22 1B SHL 1E23 03 SUB 1E24 16 AND 1E25 63 PUSH4 0x0902f1ac 1E2A 60 PUSH1 0x40 1E2C 51 MLOAD 1E2D 81 DUP2 1E2E 63 PUSH4 0xffffffff 1E33 16 AND 1E34 60 PUSH1 0xe0 1E36 1B SHL 1E37 81 DUP2 1E38 52 MSTORE 1E39 60 PUSH1 0x04 1E3B 01 ADD 1E3C 60 PUSH1 0x60 1E3E 60 PUSH1 0x40 1E40 51 MLOAD 1E41 80 DUP1 1E42 83 DUP4 1E43 03 SUB 1E44 81 DUP2 1E45 86 DUP7 1E46 80 DUP1 1E47 3B EXTCODESIZE 1E48 15 ISZERO 1E49 80 DUP1 1E4A 15 ISZERO 1E4B 61 PUSH2 0x1e53 1E4E 57 *JUMPI // Stack delta = +7 // Outputs[10] // { // @1E24 stack[-2] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1E25 stack[-1] = 0x0902f1ac // @1E38 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x0902f1ac) << 0xe0 // @1E3B stack[0] = 0x04 + memory[0x40:0x60] // @1E3C stack[1] = 0x60 // @1E40 stack[2] = memory[0x40:0x60] // @1E43 stack[3] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1E44 stack[4] = memory[0x40:0x60] // @1E45 stack[5] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1E48 stack[6] = !address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } // Block ends with conditional jump to 0x1e53, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length label_1E4F: // Incoming jump from 0x1E4E, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[1] { @1E52 memory[0x00:0x00] } 1E4F 60 PUSH1 0x00 1E51 80 DUP1 1E52 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E52 revert(memory[0x00:0x00]); } // Block terminates label_1E53: // Incoming jump from 0x1E4E, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[8] // { // @1E55 msg.gas // @1E56 stack[-6] // @1E56 stack[-4] // @1E56 stack[-2] // @1E56 stack[-3] // @1E56 memory[stack[-3]:stack[-3] + stack[-4]] // @1E56 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1E56 stack[-5] // } 1E53 5B JUMPDEST 1E54 50 POP 1E55 5A GAS 1E56 FA STATICCALL 1E57 15 ISZERO 1E58 80 DUP1 1E59 15 ISZERO 1E5A 61 PUSH2 0x1e67 1E5D 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1E56 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1E57 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1e67, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1E5E: // Incoming jump from 0x1E5D, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1E5E returndata.length // @1E62 returndata[0x00:0x00 + returndata.length] // @1E63 returndata.length // @1E66 memory[0x00:0x00 + returndata.length] // } 1E5E 3D RETURNDATASIZE 1E5F 60 PUSH1 0x00 1E61 80 DUP1 1E62 3E RETURNDATACOPY 1E63 3D RETURNDATASIZE 1E64 60 PUSH1 0x00 1E66 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1E62 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1E66 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1E67: // Incoming jump from 0x1E5D, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1E6E memory[0x40:0x60] // @1E6F returndata.length // } 1E67 5B JUMPDEST 1E68 50 POP 1E69 50 POP 1E6A 50 POP 1E6B 50 POP 1E6C 60 PUSH1 0x40 1E6E 51 MLOAD 1E6F 3D RETURNDATASIZE 1E70 60 PUSH1 0x60 1E72 81 DUP2 1E73 10 LT 1E74 15 ISZERO 1E75 61 PUSH2 0x1e7d 1E78 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1E6E stack[-4] = memory[0x40:0x60] // @1E6F stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1e7d, if !(returndata.length < 0x60) label_1E79: // Incoming jump from 0x1E78, if not !(returndata.length < 0x60) // Inputs[1] { @1E7C memory[0x00:0x00] } 1E79 60 PUSH1 0x00 1E7B 80 DUP1 1E7C FD *REVERT // Stack delta = +0 // Outputs[1] { @1E7C revert(memory[0x00:0x00]); } // Block terminates label_1E7D: // Incoming jump from 0x1E78, if !(returndata.length < 0x60) // Inputs[6] // { // @1E7F stack[-2] // @1E80 memory[stack[-2]:stack[-2] + 0x20] // @1E86 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @1E87 stack[-5] // @1E88 memory[stack[-5]:stack[-5] + 0x20] // @1EA2 stack[-3] // } 1E7D 5B JUMPDEST 1E7E 50 POP 1E7F 80 DUP1 1E80 51 MLOAD 1E81 60 PUSH1 0x20 1E83 90 SWAP1 1E84 91 SWAP2 1E85 01 ADD 1E86 51 MLOAD 1E87 84 DUP5 1E88 51 MLOAD 1E89 6D PUSH14 0xffffffffffffffffffffffffffff 1E98 92 SWAP3 1E99 83 DUP4 1E9A 16 AND 1E9B 92 SWAP3 1E9C 90 SWAP1 1E9D 91 SWAP2 1E9E 16 AND 1E9F 90 SWAP1 1EA0 85 DUP6 1EA1 90 SWAP1 1EA2 84 DUP5 1EA3 90 SWAP1 1EA4 81 DUP2 1EA5 10 LT 1EA6 61 PUSH2 0x1eab 1EA9 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1E9B stack[-2] = 0xffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] // @1E9F stack[-1] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] & 0xffffffffffffffffffffffffffff // @1EA1 stack[0] = stack[-5] // @1EA3 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x1eab, if stack[-3] < memory[stack[-5]:stack[-5] + 0x20] label_1EAA: // Incoming jump from 0x1EA9, if not stack[-3] < memory[stack[-5]:stack[-5] + 0x20] 1EAA FE *ASSERT // Stack delta = +0 // Outputs[1] { @1EAA assert(); } // Block terminates label_1EAB: // Incoming jump from 0x1EA9, if stack[-3] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[5] // { // @1EAE stack[-1] // @1EB2 stack[-2] // @1EB3 stack[-6] // @1EB4 stack[-5] // @1EB6 memory[stack[-6]:stack[-6] + 0x20] // } 1EAB 5B JUMPDEST 1EAC 60 PUSH1 0x20 1EAE 02 MUL 1EAF 60 PUSH1 0x20 1EB1 01 ADD 1EB2 01 ADD 1EB3 84 DUP5 1EB4 84 DUP5 1EB5 81 DUP2 1EB6 51 MLOAD 1EB7 81 DUP2 1EB8 10 LT 1EB9 61 PUSH2 0x1ebe 1EBC 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1EB2 stack[-2] = 0x20 + 0x20 * stack[-1] + stack[-2] // @1EB3 stack[-1] = stack[-6] // @1EB4 stack[0] = stack[-5] // } // Block ends with conditional jump to 0x1ebe, if stack[-5] < memory[stack[-6]:stack[-6] + 0x20] label_1EBD: // Incoming jump from 0x1EBC, if not stack[-5] < memory[stack[-6]:stack[-6] + 0x20] 1EBD FE *ASSERT // Stack delta = +0 // Outputs[1] { @1EBD assert(); } // Block terminates label_1EBE: // Incoming jump from 0x1EBC, if stack[-5] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[6] // { // @1EC1 stack[-1] // @1EC4 stack[-2] // @1EC9 stack[-4] // @1ECA stack[-3] // @1ECD stack[-5] // @1ED0 stack[-6] // } 1EBE 5B JUMPDEST 1EBF 60 PUSH1 0x20 1EC1 90 SWAP1 1EC2 81 DUP2 1EC3 02 MUL 1EC4 91 SWAP2 1EC5 90 SWAP1 1EC6 91 SWAP2 1EC7 01 ADD 1EC8 01 ADD 1EC9 91 SWAP2 1ECA 90 SWAP1 1ECB 91 SWAP2 1ECC 52 MSTORE 1ECD 52 MSTORE 1ECE 60 PUSH1 0x01 1ED0 01 ADD 1ED1 61 PUSH2 0x1dfe 1ED4 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @1ECC memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-4] // @1ECD memory[stack[-3]:stack[-3] + 0x20] = stack[-5] // @1ED0 stack[-6] = 0x01 + stack[-6] // } // Block ends with unconditional jump to 0x1dfe label_1ED5: // Incoming jump from 0x1E07, if !(0x00 < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1E07, if !(0x00 < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1E07, if !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[4] // { // @1ED7 stack[-2] // @1ED7 stack[-4] // @1ED9 stack[-3] // @1ED9 stack[-5] // } 1ED5 5B JUMPDEST 1ED6 50 POP 1ED7 91 SWAP2 1ED8 50 POP 1ED9 91 SWAP2 1EDA 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1ED7 stack[-4] = stack[-2] // @1ED9 stack[-5] = stack[-3] // } // Block ends with unconditional jump to stack[-5] label_1EDB: // Incoming call from 0x0C6D, returns to 0x0C6E // Incoming call from 0x2A6D, returns to 0x2A6E // Inputs[2] // { // @1EDE stack[-2] // @1EDF memory[stack[-2]:stack[-2] + 0x20] // } 1EDB 5B JUMPDEST 1EDC 60 PUSH1 0x60 1EDE 82 DUP3 1EDF 51 MLOAD 1EE0 67 PUSH8 0xffffffffffffffff 1EE9 81 DUP2 1EEA 11 GT 1EEB 80 DUP1 1EEC 15 ISZERO 1EED 61 PUSH2 0x1ef5 1EF0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1EDC stack[0] = 0x60 // @1EDF stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @1EEA stack[2] = memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff // } // Block ends with conditional jump to 0x1ef5, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1EF1: // Incoming jump from 0x1EF0, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1EF4 memory[0x00:0x00] } 1EF1 60 PUSH1 0x00 1EF3 80 DUP1 1EF4 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EF4 revert(memory[0x00:0x00]); } // Block terminates label_1EF5: // Incoming jump from 0x1EF0, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1EF9 memory[0x40:0x60] // @1EFA stack[-2] // } 1EF5 5B JUMPDEST 1EF6 50 POP 1EF7 60 PUSH1 0x40 1EF9 51 MLOAD 1EFA 90 SWAP1 1EFB 80 DUP1 1EFC 82 DUP3 1EFD 52 MSTORE 1EFE 80 DUP1 1EFF 60 PUSH1 0x20 1F01 02 MUL 1F02 60 PUSH1 0x20 1F04 01 ADD 1F05 82 DUP3 1F06 01 ADD 1F07 60 PUSH1 0x40 1F09 52 MSTORE 1F0A 80 DUP1 1F0B 15 ISZERO 1F0C 61 PUSH2 0x1f1f 1F0F 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1EFA stack[-2] = memory[0x40:0x60] // @1EFA stack[-1] = stack[-2] // @1EFD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @1F09 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // } // Block ends with conditional jump to 0x1f1f, if !stack[-2] label_1F10: // Incoming jump from 0x1F0F, if not !stack[-2] // Inputs[7] // { // @1F10 stack[-2] // @1F16 stack[-1] // @1F19 msg.data.length // @1F1B msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @1F21 stack[-3] // @1F26 stack[-5] // @1F27 memory[stack[-5]:stack[-5] + 0x20] // } 1F10 81 DUP2 1F11 60 PUSH1 0x20 1F13 01 ADD 1F14 60 PUSH1 0x20 1F16 82 DUP3 1F17 02 MUL 1F18 80 DUP1 1F19 36 CALLDATASIZE 1F1A 83 DUP4 1F1B 37 CALLDATACOPY 1F1C 01 ADD 1F1D 90 SWAP1 1F1E 50 POP 1F1F 5B JUMPDEST 1F20 50 POP 1F21 90 SWAP1 1F22 50 POP 1F23 60 PUSH1 0x01 1F25 5B JUMPDEST 1F26 83 DUP4 1F27 51 MLOAD 1F28 81 DUP2 1F29 10 LT 1F2A 15 ISZERO 1F2B 61 PUSH2 0x20ae 1F2E 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @1F1B memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @1F21 stack[-3] = stack[-2] // @1F23 stack[-2] = 0x01 // } // Block ends with conditional jump to 0x20ae, if !(0x01 < memory[stack[-5]:stack[-5] + 0x20]) label_1F2F: // Incoming jump from 0x1F2E, if not !(0x01 < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1F2E, if not !(0x01 < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1F2E, if not !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[3] // { // @1F31 stack[-5] // @1F32 stack[-1] // @1F34 memory[stack[-5]:stack[-5] + 0x20] // } 1F2F 60 PUSH1 0x00 1F31 85 DUP6 1F32 82 DUP3 1F33 81 DUP2 1F34 51 MLOAD 1F35 81 DUP2 1F36 10 LT 1F37 61 PUSH2 0x1f3c 1F3A 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1F2F stack[0] = 0x00 // @1F31 stack[1] = stack[-5] // @1F32 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x1f3c, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_1F3B: // Incoming jump from 0x1F3A, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 1F3B FE *ASSERT // Stack delta = +0 // Outputs[1] { @1F3B assert(); } // Block terminates label_1F3C: // Incoming jump from 0x1F3A, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[4] // { // @1F3F stack[-1] // @1F43 stack[-2] // @1F44 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1F45 stack[-3] // } 1F3C 5B JUMPDEST 1F3D 60 PUSH1 0x20 1F3F 02 MUL 1F40 60 PUSH1 0x20 1F42 01 ADD 1F43 01 ADD 1F44 51 MLOAD 1F45 11 GT 1F46 15 ISZERO 1F47 61 PUSH2 0x204d 1F4A 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x204d, if !(memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] > stack[-3]) label_1F4B: // Incoming jump from 0x1F4A, if not !(memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] > stack[-3]) // Inputs[3] // { // @1F4B stack[-4] // @1F4C stack[-1] // @1F4E memory[stack[-4]:stack[-4] + 0x20] // } 1F4B 83 DUP4 1F4C 81 DUP2 1F4D 81 DUP2 1F4E 51 MLOAD 1F4F 81 DUP2 1F50 10 LT 1F51 61 PUSH2 0x1f56 1F54 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1F4B stack[0] = stack[-4] // @1F4C stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1f56, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] label_1F55: // Incoming jump from 0x1F54, if not stack[-1] < memory[stack[-4]:stack[-4] + 0x20] 1F55 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1F55 assert(); } // Block terminates label_1F56: // Incoming jump from 0x1F54, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[3] // { // @1F59 stack[-1] // @1F5D stack[-2] // @1F5E memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 1F56 5B JUMPDEST 1F57 60 PUSH1 0x20 1F59 02 MUL 1F5A 60 PUSH1 0x20 1F5C 01 ADD 1F5D 01 ADD 1F5E 51 MLOAD 1F5F 15 ISZERO 1F60 61 PUSH2 0x1ff8 1F63 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1ff8, if !memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_1F64: // Incoming jump from 0x1F63, if not !memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[3] // { // @1F70 stack[-5] // @1F71 stack[-1] // @1F73 memory[stack[-5]:stack[-5] + 0x20] // } 1F64 61 PUSH2 0x1ff1 1F67 61 PUSH2 0x1f9c 1F6A 61 PUSH2 0x03e8 1F6D 61 PUSH2 0x1f96 1F70 88 DUP9 1F71 85 DUP6 1F72 81 DUP2 1F73 51 MLOAD 1F74 81 DUP2 1F75 10 LT 1F76 61 PUSH2 0x1f7b 1F79 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @1F64 stack[0] = 0x1ff1 // @1F67 stack[1] = 0x1f9c // @1F6A stack[2] = 0x03e8 // @1F6D stack[3] = 0x1f96 // @1F70 stack[4] = stack[-5] // @1F71 stack[5] = stack[-1] // } // Block ends with conditional call to 0x1f7b, returns to 0x1F96, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_1F7A: // Incoming jump from 0x1F79, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 1F7A FE *ASSERT // Stack delta = +0 // Outputs[1] { @1F7A assert(); } // Block terminates label_1F7B: // Incoming call from 0x2F4B, returns to 0x1F96, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Incoming call from 0x200E, returns to 0x1F96, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Incoming call from 0x1F79, returns to 0x1F96, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Incoming call from 0x2F6A, returns to 0x1F96, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[4] // { // @1F7E stack[-1] // @1F82 stack[-2] // @1F83 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1F88 stack[-12] // } 1F7B 5B JUMPDEST 1F7C 60 PUSH1 0x20 1F7E 02 MUL 1F7F 60 PUSH1 0x20 1F81 01 ADD 1F82 01 ADD 1F83 51 MLOAD 1F84 61 PUSH2 0x03e8 1F87 03 SUB 1F88 8A DUP11 1F89 61 PUSH2 0x2d7f 1F8C 90 SWAP1 1F8D 91 SWAP2 1F8E 90 SWAP1 1F8F 63 PUSH4 0xffffffff 1F94 16 AND 1F95 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1F8D stack[-2] = stack[-12] // @1F8E stack[-1] = 0x03e8 - memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0xffffffff & 0x2d7f label_1F96: // Incoming return from call to 0x1F7B at 0x2F4B // Incoming return from call to 0x1F7B at 0x200E // Incoming return from call to 0x1F7B at 0x1F79 // Incoming return from call to 0x1F7B at 0x2F6A // Inputs[2] // { // @1F97 stack[-2] // @1F97 stack[-1] // } 1F96 5B JUMPDEST 1F97 90 SWAP1 1F98 61 PUSH2 0x2dd8 1F9B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1F97 stack[-1] = stack[-2] // @1F97 stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x2dd8 label_1F9C: // Incoming return from call to 0x1F96 at 0x1F79 // Incoming return from call to 0x1F96 at 0x2F4B // Inputs[2] // { // @1F9D stack[-5] // @1FA1 memory[stack[-5]:stack[-5] + 0x20] // } 1F9C 5B JUMPDEST 1F9D 84 DUP5 1F9E 60 PUSH1 0x01 1FA0 81 DUP2 1FA1 51 MLOAD 1FA2 81 DUP2 1FA3 10 LT 1FA4 61 PUSH2 0x1fa9 1FA7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1F9D stack[0] = stack[-5] // @1F9E stack[1] = 0x01 // } // Block ends with conditional jump to 0x1fa9, if 0x01 < memory[stack[-5]:stack[-5] + 0x20] label_1FA8: // Incoming jump from 0x1FA7, if not 0x01 < memory[stack[-5]:stack[-5] + 0x20] 1FA8 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1FA8 assert(); } // Block terminates label_1FA9: // Incoming call from 0x2075, returns to 0x2045, if 0x01 < memory[stack[-3]:stack[-3] + 0x20] // Incoming call from 0x2F9C, returns to 0x2F6C, if 0x01 < memory[stack[-3]:stack[-3] + 0x20] // Incoming jump from 0x1FA7, if 0x01 < memory[stack[-5]:stack[-5] + 0x20] // Inputs[5] // { // @1FAC stack[-1] // @1FB0 stack[-2] // @1FB1 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1FB2 stack[-5] // @1FB4 memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // } 1FA9 5B JUMPDEST 1FAA 60 PUSH1 0x20 1FAC 02 MUL 1FAD 60 PUSH1 0x20 1FAF 01 ADD 1FB0 01 ADD 1FB1 51 MLOAD 1FB2 83 DUP4 1FB3 81 DUP2 1FB4 51 MLOAD 1FB5 81 DUP2 1FB6 10 LT 1FB7 61 PUSH2 0x1fbc 1FBA 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1FB1 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1FB2 stack[-1] = stack[-5] // } // Block ends with conditional jump to 0x1fbc, if stack[-5] < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] label_1FBB: // Incoming jump from 0x1FBA, if not stack[-5] < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] 1FBB FE *ASSERT // Stack delta = +0 // Outputs[1] { @1FBB assert(); } // Block terminates label_1FBC: // Incoming jump from 0x1FBA, if stack[-5] < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // Inputs[5] // { // @1FBF stack[-1] // @1FC3 stack[-2] // @1FC4 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1FC5 stack[-7] // @1FC9 memory[stack[-7]:stack[-7] + 0x20] // } 1FBC 5B JUMPDEST 1FBD 60 PUSH1 0x20 1FBF 02 MUL 1FC0 60 PUSH1 0x20 1FC2 01 ADD 1FC3 01 ADD 1FC4 51 MLOAD 1FC5 85 DUP6 1FC6 60 PUSH1 0x00 1FC8 81 DUP2 1FC9 51 MLOAD 1FCA 81 DUP2 1FCB 10 LT 1FCC 61 PUSH2 0x1fd1 1FCF 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1FC4 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1FC5 stack[-1] = stack[-7] // @1FC6 stack[0] = 0x00 // } // Block ends with conditional jump to 0x1fd1, if 0x00 < memory[stack[-7]:stack[-7] + 0x20] label_1FD0: // Incoming jump from 0x1FCF, if not 0x00 < memory[stack[-7]:stack[-7] + 0x20] 1FD0 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1FD0 assert(); } // Block terminates label_1FD1: // Incoming jump from 0x2043, if 0x01 < memory[stack[-7]:stack[-7] + 0x20] // Incoming jump from 0x1FCF, if 0x00 < memory[stack[-7]:stack[-7] + 0x20] // Inputs[5] // { // @1FD4 stack[-1] // @1FD8 stack[-2] // @1FD9 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1FDA stack[-6] // @1FDC memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // } 1FD1 5B JUMPDEST 1FD2 60 PUSH1 0x20 1FD4 02 MUL 1FD5 60 PUSH1 0x20 1FD7 01 ADD 1FD8 01 ADD 1FD9 51 MLOAD 1FDA 84 DUP5 1FDB 81 DUP2 1FDC 51 MLOAD 1FDD 81 DUP2 1FDE 10 LT 1FDF 61 PUSH2 0x1fe4 1FE2 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1FD9 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1FDA stack[-1] = stack[-6] // } // Block ends with conditional jump to 0x1fe4, if stack[-6] < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] label_1FE3: // Incoming jump from 0x1FE2, if not stack[-6] < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] 1FE3 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1FE3 assert(); } // Block terminates label_1FE4: // Incoming jump from 0x1FE2, if stack[-6] < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // Inputs[3] // { // @1FE7 stack[-1] // @1FEB stack[-2] // @1FEC memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 1FE4 5B JUMPDEST 1FE5 60 PUSH1 0x20 1FE7 02 MUL 1FE8 60 PUSH1 0x20 1FEA 01 ADD 1FEB 01 ADD 1FEC 51 MLOAD 1FED 61 PUSH2 0x2e1a 1FF0 56 *JUMP // Stack delta = -1 // Outputs[1] { @1FEC stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2e1a label_1FF1: // Incoming return from call to 0x1F9C at 0x1F79 // Inputs[2] // { // @1FF2 stack[-7] // @1FF2 stack[-1] // } 1FF1 5B JUMPDEST 1FF2 95 SWAP6 1FF3 50 POP 1FF4 61 PUSH2 0x2048 1FF7 56 *JUMP // Stack delta = -1 // Outputs[1] { @1FF2 stack[-7] = stack[-1] } // Block ends with unconditional jump to 0x2048 label_1FF8: // Incoming jump from 0x1F63, if !memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[3] // { // @2005 stack[-5] // @2006 stack[-1] // @2008 memory[stack[-5]:stack[-5] + 0x20] // } 1FF8 5B JUMPDEST 1FF9 61 PUSH2 0x2045 1FFC 61 PUSH2 0x2010 1FFF 61 PUSH2 0x03e8 2002 61 PUSH2 0x1f96 2005 88 DUP9 2006 85 DUP6 2007 81 DUP2 2008 51 MLOAD 2009 81 DUP2 200A 10 LT 200B 61 PUSH2 0x1f7b 200E 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @1FF9 stack[0] = 0x2045 // @1FFC stack[1] = 0x2010 // @1FFF stack[2] = 0x03e8 // @2002 stack[3] = 0x1f96 // @2005 stack[4] = stack[-5] // @2006 stack[5] = stack[-1] // } // Block ends with conditional call to 0x1f7b, returns to 0x1F96, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_200F: // Incoming jump from 0x200E, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 200F FE *ASSERT // Stack delta = +0 // Outputs[1] { @200F assert(); } // Block terminates label_2010: // Incoming return from call to 0x1F96 at 0x2F6A // Incoming return from call to 0x1F96 at 0x200E // Inputs[2] // { // @2011 stack[-5] // @2015 memory[stack[-5]:stack[-5] + 0x20] // } 2010 5B JUMPDEST 2011 84 DUP5 2012 60 PUSH1 0x00 2014 81 DUP2 2015 51 MLOAD 2016 81 DUP2 2017 10 LT 2018 61 PUSH2 0x201d 201B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2011 stack[0] = stack[-5] // @2012 stack[1] = 0x00 // } // Block ends with conditional jump to 0x201d, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] label_201C: // Incoming jump from 0x201B, if not 0x00 < memory[stack[-5]:stack[-5] + 0x20] 201C FE *ASSERT // Stack delta = +0 // Outputs[1] { @201C assert(); } // Block terminates label_201D: // Incoming call from 0x2086, returns to 0x2088, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] // Incoming call from 0x2FAD, returns to 0x2FAF, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] // Incoming jump from 0x201B, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] // Inputs[5] // { // @2020 stack[-1] // @2024 stack[-2] // @2025 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2026 stack[-5] // @2028 memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // } 201D 5B JUMPDEST 201E 60 PUSH1 0x20 2020 02 MUL 2021 60 PUSH1 0x20 2023 01 ADD 2024 01 ADD 2025 51 MLOAD 2026 83 DUP4 2027 81 DUP2 2028 51 MLOAD 2029 81 DUP2 202A 10 LT 202B 61 PUSH2 0x2030 202E 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2025 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2026 stack[-1] = stack[-5] // } // Block ends with conditional jump to 0x2030, if stack[-5] < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] label_202F: // Incoming jump from 0x202E, if not stack[-5] < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] 202F FE *ASSERT // Stack delta = +0 // Outputs[1] { @202F assert(); } // Block terminates label_2030: // Incoming jump from 0x202E, if stack[-5] < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // Inputs[5] // { // @2033 stack[-1] // @2037 stack[-2] // @2038 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2039 stack[-7] // @203D memory[stack[-7]:stack[-7] + 0x20] // } 2030 5B JUMPDEST 2031 60 PUSH1 0x20 2033 02 MUL 2034 60 PUSH1 0x20 2036 01 ADD 2037 01 ADD 2038 51 MLOAD 2039 85 DUP6 203A 60 PUSH1 0x01 203C 81 DUP2 203D 51 MLOAD 203E 81 DUP2 203F 10 LT 2040 61 PUSH2 0x1fd1 2043 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2038 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2039 stack[-1] = stack[-7] // @203A stack[0] = 0x01 // } // Block ends with conditional jump to 0x1fd1, if 0x01 < memory[stack[-7]:stack[-7] + 0x20] label_2044: // Incoming jump from 0x2043, if not 0x01 < memory[stack[-7]:stack[-7] + 0x20] 2044 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2044 assert(); } // Block terminates label_2045: // Incoming return from call to 0x1FA9 at 0x2075 // Incoming return from call to 0x2010 at 0x200E // Inputs[2] // { // @2046 stack[-1] // @2046 stack[-7] // } 2045 5B JUMPDEST 2046 95 SWAP6 2047 50 POP 2048 5B JUMPDEST 2049 61 PUSH2 0x208b 204C 56 *JUMP // Stack delta = -1 // Outputs[1] { @2046 stack[-7] = stack[-1] } // Block ends with unconditional jump to 0x208b label_204D: // Incoming jump from 0x1F4A, if !(memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] > stack[-3]) // Inputs[3] // { // @204E stack[-4] // @204F stack[-1] // @2051 memory[stack[-4]:stack[-4] + 0x20] // } 204D 5B JUMPDEST 204E 83 DUP4 204F 81 DUP2 2050 81 DUP2 2051 51 MLOAD 2052 81 DUP2 2053 10 LT 2054 61 PUSH2 0x2059 2057 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @204E stack[0] = stack[-4] // @204F stack[1] = stack[-1] // } // Block ends with conditional jump to 0x2059, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] label_2058: // Incoming jump from 0x2057, if not stack[-1] < memory[stack[-4]:stack[-4] + 0x20] 2058 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2058 assert(); } // Block terminates label_2059: // Incoming jump from 0x2057, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[3] // { // @205C stack[-1] // @2060 stack[-2] // @2061 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 2059 5B JUMPDEST 205A 60 PUSH1 0x20 205C 02 MUL 205D 60 PUSH1 0x20 205F 01 ADD 2060 01 ADD 2061 51 MLOAD 2062 15 ISZERO 2063 61 PUSH2 0x2077 2066 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2077, if !memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_2067: // Incoming jump from 0x2066, if not !memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[3] // { // @206A stack[-6] // @206B stack[-3] // @206F memory[stack[-3]:stack[-3] + 0x20] // } 2067 61 PUSH2 0x2045 206A 86 DUP7 206B 84 DUP5 206C 60 PUSH1 0x01 206E 81 DUP2 206F 51 MLOAD 2070 81 DUP2 2071 10 LT 2072 61 PUSH2 0x1fa9 2075 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2067 stack[0] = 0x2045 // @206A stack[1] = stack[-6] // @206B stack[2] = stack[-3] // @206C stack[3] = 0x01 // } // Block ends with conditional call to 0x1fa9, returns to 0x2045, if 0x01 < memory[stack[-3]:stack[-3] + 0x20] label_2076: // Incoming jump from 0x2075, if not 0x01 < memory[stack[-3]:stack[-3] + 0x20] 2076 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2076 assert(); } // Block terminates label_2077: // Incoming jump from 0x2066, if !memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[3] // { // @207B stack[-6] // @207C stack[-3] // @2080 memory[stack[-3]:stack[-3] + 0x20] // } 2077 5B JUMPDEST 2078 61 PUSH2 0x2088 207B 86 DUP7 207C 84 DUP5 207D 60 PUSH1 0x00 207F 81 DUP2 2080 51 MLOAD 2081 81 DUP2 2082 10 LT 2083 61 PUSH2 0x201d 2086 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2078 stack[0] = 0x2088 // @207B stack[1] = stack[-6] // @207C stack[2] = stack[-3] // @207D stack[3] = 0x00 // } // Block ends with conditional call to 0x201d, returns to 0x2088, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] label_2087: // Incoming jump from 0x2086, if not 0x00 < memory[stack[-3]:stack[-3] + 0x20] 2087 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2087 assert(); } // Block terminates label_2088: // Incoming return from call to 0x201D at 0x2086 // Inputs[5] // { // @2089 stack[-1] // @2089 stack[-7] // @208D stack[-3] // @2090 stack[-2] // @2093 memory[stack[-3]:stack[-3] + 0x20] // } 2088 5B JUMPDEST 2089 95 SWAP6 208A 50 POP 208B 5B JUMPDEST 208C 85 DUP6 208D 82 DUP3 208E 60 PUSH1 0x01 2090 83 DUP4 2091 03 SUB 2092 81 DUP2 2093 51 MLOAD 2094 81 DUP2 2095 10 LT 2096 61 PUSH2 0x209b 2099 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @2089 stack[-7] = stack[-1] // @208C stack[-1] = stack[-1] // @208D stack[0] = stack[-3] // @2091 stack[1] = stack[-2] - 0x01 // } // Block ends with conditional jump to 0x209b, if stack[-2] - 0x01 < memory[stack[-3]:stack[-3] + 0x20] label_209A: // Incoming jump from 0x2099, if not stack[-2] - 0x01 < memory[stack[-3]:stack[-3] + 0x20] // Incoming jump from 0x2099, if not stack[-1] - 0x01 < memory[stack[-2]:stack[-2] + 0x20] 209A FE *ASSERT // Stack delta = +0 // Outputs[1] { @209A assert(); } // Block terminates label_209B: // Incoming jump from 0x2099, if stack[-2] - 0x01 < memory[stack[-3]:stack[-3] + 0x20] // Incoming jump from 0x2099, if stack[-1] - 0x01 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @209E stack[-1] // @20A1 stack[-2] // @20A6 stack[-3] // @20A9 stack[-4] // } 209B 5B JUMPDEST 209C 60 PUSH1 0x20 209E 90 SWAP1 209F 81 DUP2 20A0 02 MUL 20A1 91 SWAP2 20A2 90 SWAP1 20A3 91 SWAP2 20A4 01 ADD 20A5 01 ADD 20A6 52 MSTORE 20A7 60 PUSH1 0x01 20A9 01 ADD 20AA 61 PUSH2 0x1f25 20AD 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @20A6 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @20A9 stack[-4] = 0x01 + stack[-4] // } // Block ends with unconditional jump to 0x1f25 label_20AE: // Incoming jump from 0x1F2E, if !(0x01 < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1F2E, if !(0x01 < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1F2E, if !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[3] // { // @20B0 stack[-7] // @20B0 stack[-2] // @20B1 stack[-6] // } 20AE 5B JUMPDEST 20AF 50 POP 20B0 94 SWAP5 20B1 93 SWAP4 20B2 50 POP 20B3 50 POP 20B4 50 POP 20B5 50 POP 20B6 56 *JUMP // Stack delta = -6 // Outputs[1] { @20B0 stack[-7] = stack[-2] } // Block ends with unconditional jump to stack[-7] label_20B7: // Incoming jump from 0x0CE5 // Inputs[1] { @20BB stack[-3] } 20B7 5B JUMPDEST 20B8 60 PUSH1 0x00 20BA 80 DUP1 20BB 84 DUP5 20BC 11 GT 20BD 61 PUSH2 0x20f7 20C0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20B8 stack[0] = 0x00 } // Block ends with conditional jump to 0x20f7, if stack[-3] > 0x00 label_20C1: // Incoming jump from 0x20C0, if not stack[-3] > 0x00 // Inputs[3] // { // @20C3 memory[0x40:0x60] // @20F1 memory[0x40:0x60] // @20F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 20C1 60 PUSH1 0x40 20C3 51 MLOAD 20C4 62 PUSH3 0x461bcd 20C8 60 PUSH1 0xe5 20CA 1B SHL 20CB 81 DUP2 20CC 52 MSTORE 20CD 60 PUSH1 0x04 20CF 01 ADD 20D0 80 DUP1 20D1 80 DUP1 20D2 60 PUSH1 0x20 20D4 01 ADD 20D5 82 DUP3 20D6 81 DUP2 20D7 03 SUB 20D8 82 DUP3 20D9 52 MSTORE 20DA 60 PUSH1 0x2c 20DC 81 DUP2 20DD 52 MSTORE 20DE 60 PUSH1 0x20 20E0 01 ADD 20E1 80 DUP1 20E2 61 PUSH2 0x30aa 20E5 60 PUSH1 0x2c 20E7 91 SWAP2 20E8 39 CODECOPY 20E9 60 PUSH1 0x40 20EB 01 ADD 20EC 91 SWAP2 20ED 50 POP 20EE 50 POP 20EF 60 PUSH1 0x40 20F1 51 MLOAD 20F2 80 DUP1 20F3 91 SWAP2 20F4 03 SUB 20F5 90 SWAP1 20F6 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @20CC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @20D9 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @20DD memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @20E8 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x30aa:0x30d6] // @20F6 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_20F7: // Incoming jump from 0x20C0, if stack[-3] > 0x00 // Inputs[1] { @20FA stack[-3] } 20F7 5B JUMPDEST 20F8 60 PUSH1 0x00 20FA 83 DUP4 20FB 11 GT 20FC 80 DUP1 20FD 15 ISZERO 20FE 61 PUSH2 0x2107 2101 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20FB stack[0] = stack[-3] > 0x00 } // Block ends with conditional jump to 0x2107, if !(stack[-3] > 0x00) label_2102: // Incoming jump from 0x2101, if not !(stack[-3] > 0x00) // Inputs[1] { @2105 stack[-3] } 2102 50 POP 2103 60 PUSH1 0x00 2105 82 DUP3 2106 11 GT 2107 5B JUMPDEST 2108 61 PUSH2 0x2142 210B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2142, if stack[-3] > 0x00 label_210C: // Incoming jump from 0x210B, if not stack[-3] > 0x00 // Incoming jump from 0x210B, if not stack[-1] // Inputs[3] // { // @210E memory[0x40:0x60] // @213C memory[0x40:0x60] // @2141 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 210C 60 PUSH1 0x40 210E 51 MLOAD 210F 62 PUSH3 0x461bcd 2113 60 PUSH1 0xe5 2115 1B SHL 2116 81 DUP2 2117 52 MSTORE 2118 60 PUSH1 0x04 211A 01 ADD 211B 80 DUP1 211C 80 DUP1 211D 60 PUSH1 0x20 211F 01 ADD 2120 82 DUP3 2121 81 DUP2 2122 03 SUB 2123 82 DUP3 2124 52 MSTORE 2125 60 PUSH1 0x28 2127 81 DUP2 2128 52 MSTORE 2129 60 PUSH1 0x20 212B 01 ADD 212C 80 DUP1 212D 61 PUSH2 0x30d6 2130 60 PUSH1 0x28 2132 91 SWAP2 2133 39 CODECOPY 2134 60 PUSH1 0x40 2136 01 ADD 2137 91 SWAP2 2138 50 POP 2139 50 POP 213A 60 PUSH1 0x40 213C 51 MLOAD 213D 80 DUP1 213E 91 SWAP2 213F 03 SUB 2140 90 SWAP1 2141 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2117 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2124 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2128 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x28 // @2133 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x28] = code[0x30d6:0x30fe] // @2141 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2142: // Incoming jump from 0x210B, if stack[-3] > 0x00 // Incoming jump from 0x210B, if stack[-1] // Inputs[2] // { // @214E stack[-3] // @214F stack[-4] // } 2142 5B JUMPDEST 2143 60 PUSH1 0x00 2145 61 PUSH2 0x215a 2148 61 PUSH2 0x03e8 214B 61 PUSH2 0x2154 214E 86 DUP7 214F 88 DUP9 2150 61 PUSH2 0x2d7f 2153 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2143 stack[0] = 0x00 // @2145 stack[1] = 0x215a // @2148 stack[2] = 0x03e8 // @214B stack[3] = 0x2154 // @214E stack[4] = stack[-3] // @214F stack[5] = stack[-4] // } // Block ends with call to 0x2d7f, returns to 0x2154 label_2154: // Incoming return from call to 0x2D7F at 0x2153 // Incoming return from call to 0x2D34 at 0x216D // Inputs[2] // { // @2155 stack[-2] // @2155 stack[-1] // } 2154 5B JUMPDEST 2155 90 SWAP1 2156 61 PUSH2 0x2d7f 2159 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2155 stack[-1] = stack[-2] // @2155 stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x2d7f label_215A: // Incoming return from call to 0x2154 at 0x2153 // Inputs[4] // { // @215B stack[-1] // @215B stack[-2] // @2168 stack[-4] // @2169 stack[-6] // } 215A 5B JUMPDEST 215B 90 SWAP1 215C 50 POP 215D 60 PUSH1 0x00 215F 61 PUSH2 0x216e 2162 61 PUSH2 0x03e5 2165 61 PUSH2 0x2154 2168 86 DUP7 2169 89 DUP10 216A 61 PUSH2 0x2d34 216D 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @215B stack[-2] = stack[-1] // @215D stack[-1] = 0x00 // @215F stack[0] = 0x216e // @2162 stack[1] = 0x03e5 // @2165 stack[2] = 0x2154 // @2168 stack[3] = stack[-4] // @2169 stack[4] = stack[-6] // } // Block ends with call to 0x2d34, returns to 0x2154 label_216E: // Incoming return from call to 0x2154 at 0x216D // Inputs[3] // { // @216F stack[-2] // @216F stack[-1] // @2172 stack[-3] // } 216E 5B JUMPDEST 216F 90 SWAP1 2170 50 POP 2171 80 DUP1 2172 82 DUP3 2173 81 DUP2 2174 61 PUSH2 0x2179 2177 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @216F stack[-2] = stack[-1] // @2171 stack[-1] = stack[-1] // @2172 stack[0] = stack[-3] // } // Block ends with conditional jump to 0x2179, if stack[-1] label_2178: // Incoming jump from 0x2177, if not stack[-1] 2178 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2178 assert(); } // Block terminates label_2179: // Incoming jump from 0x2177, if stack[-1] // Inputs[4] // { // @217A stack[-2] // @217A stack[-1] // @217B stack[-9] // @217C stack[-8] // } 2179 5B JUMPDEST 217A 04 DIV 217B 96 SWAP7 217C 95 SWAP6 217D 50 POP 217E 50 POP 217F 50 POP 2180 50 POP 2181 50 POP 2182 50 POP 2183 56 *JUMP // Stack delta = -8 // Outputs[1] { @217B stack[-9] = stack[-1] / stack[-2] } // Block ends with unconditional jump to stack[-9] label_2184: // Incoming call from 0x2D75, returns to 0x2D76 // Incoming jump from 0x0D6E // Inputs[3] // { // @2187 stack[-1] // @2188 stack[-3] // @2189 stack[-2] // } 2184 5B JUMPDEST 2185 60 PUSH1 0x00 2187 81 DUP2 2188 84 DUP5 2189 84 DUP5 218A 11 GT 218B 15 ISZERO 218C 61 PUSH2 0x2213 218F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2185 stack[0] = 0x00 // @2187 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x2213, if !(stack[-2] > stack[-3]) label_2190: // Incoming jump from 0x218F, if not !(stack[-2] > stack[-3]) // Inputs[4] // { // @2192 memory[0x40:0x60] // @21A9 stack[-1] // @21AC memory[stack[-1]:stack[-1] + 0x20] // @21B5 memory[stack[-1]:stack[-1] + 0x20] // } 2190 60 PUSH1 0x40 2192 51 MLOAD 2193 62 PUSH3 0x461bcd 2197 60 PUSH1 0xe5 2199 1B SHL 219A 81 DUP2 219B 52 MSTORE 219C 60 PUSH1 0x04 219E 01 ADD 219F 80 DUP1 21A0 80 DUP1 21A1 60 PUSH1 0x20 21A3 01 ADD 21A4 82 DUP3 21A5 81 DUP2 21A6 03 SUB 21A7 82 DUP3 21A8 52 MSTORE 21A9 83 DUP4 21AA 81 DUP2 21AB 81 DUP2 21AC 51 MLOAD 21AD 81 DUP2 21AE 52 MSTORE 21AF 60 PUSH1 0x20 21B1 01 ADD 21B2 91 SWAP2 21B3 50 POP 21B4 80 DUP1 21B5 51 MLOAD 21B6 90 SWAP1 21B7 60 PUSH1 0x20 21B9 01 ADD 21BA 90 SWAP1 21BB 80 DUP1 21BC 83 DUP4 21BD 83 DUP4 21BE 60 PUSH1 0x00 21C0 5B JUMPDEST 21C1 83 DUP4 21C2 81 DUP2 21C3 10 LT 21C4 15 ISZERO 21C5 61 PUSH2 0x21d8 21C8 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @219B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @219E stack[0] = 0x04 + memory[0x40:0x60] // @219F stack[1] = 0x04 + memory[0x40:0x60] // @21A8 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @21AE memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @21B2 stack[2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @21BA stack[3] = 0x20 + stack[-1] // @21BA stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @21BB stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @21BC stack[6] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @21BD stack[7] = 0x20 + stack[-1] // @21BE stack[8] = 0x00 // } // Block ends with conditional jump to 0x21d8, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_21C9: // Incoming jump from 0x21C8, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x21C8, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @21C9 stack[-2] // @21CA stack[-1] // @21CC memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @21CD stack[-3] // } 21C9 81 DUP2 21CA 81 DUP2 21CB 01 ADD 21CC 51 MLOAD 21CD 83 DUP4 21CE 82 DUP3 21CF 01 ADD 21D0 52 MSTORE 21D1 60 PUSH1 0x20 21D3 01 ADD 21D4 61 PUSH2 0x21c0 21D7 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @21D0 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @21D3 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x21c0 label_21D8: // Incoming jump from 0x21C8, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x3003, if !memory[stack[-1]:stack[-1] + 0x20] // Incoming jump from 0x21C8, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @21DD stack[-5] // @21DD stack[-6] // @21DF stack[-7] // } 21D8 5B JUMPDEST 21D9 50 POP 21DA 50 POP 21DB 50 POP 21DC 50 POP 21DD 90 SWAP1 21DE 50 POP 21DF 90 SWAP1 21E0 81 DUP2 21E1 01 ADD 21E2 90 SWAP1 21E3 60 PUSH1 0x1f 21E5 16 AND 21E6 80 DUP1 21E7 15 ISZERO 21E8 61 PUSH2 0x2205 21EB 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @21E2 stack[-7] = stack[-5] + stack[-7] // @21E5 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x2205, if !(0x1f & stack[-5]) label_21EC: // Incoming jump from 0x21EB, if not !(0x1f & stack[-5]) // Inputs[6] // { // @21EC stack[-1] // @21ED stack[-2] // @21F0 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @2207 stack[-5] // @220D memory[0x40:0x60] // @2212 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 21EC 80 DUP1 21ED 82 DUP3 21EE 03 SUB 21EF 80 DUP1 21F0 51 MLOAD 21F1 60 PUSH1 0x01 21F3 83 DUP4 21F4 60 PUSH1 0x20 21F6 03 SUB 21F7 61 PUSH2 0x0100 21FA 0A EXP 21FB 03 SUB 21FC 19 NOT 21FD 16 AND 21FE 81 DUP2 21FF 52 MSTORE 2200 60 PUSH1 0x20 2202 01 ADD 2203 91 SWAP2 2204 50 POP 2205 5B JUMPDEST 2206 50 POP 2207 92 SWAP3 2208 50 POP 2209 50 POP 220A 50 POP 220B 60 PUSH1 0x40 220D 51 MLOAD 220E 80 DUP1 220F 91 SWAP2 2210 03 SUB 2211 90 SWAP1 2212 FD *REVERT // Stack delta = -5 // Outputs[2] // { // @21FF 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] // @2212 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]); // } // Block terminates label_2213: // Incoming jump from 0x218F, if !(stack[-2] > stack[-3]) // Inputs[3] // { // @2217 stack[-4] // @2217 stack[-5] // @2219 stack[-6] // } 2213 5B JUMPDEST 2214 50 POP 2215 50 POP 2216 50 POP 2217 90 SWAP1 2218 03 SUB 2219 90 SWAP1 221A 56 *JUMP // Stack delta = -5 // Outputs[1] { @2219 stack[-6] = stack[-5] - stack[-4] } // Block ends with unconditional jump to stack[-6] label_221B: // Incoming call from 0x0E96, returns to 0x0E97 // Incoming jump from 0x0D77 // Inputs[2] // { // @221C stack[-2] // @2220 memory[stack[-2]:stack[-2] + 0x20] // } 221B 5B JUMPDEST 221C 81 DUP2 221D 60 PUSH1 0x00 221F 81 DUP2 2220 51 MLOAD 2221 81 DUP2 2222 10 LT 2223 61 PUSH2 0x2228 2226 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @221C stack[0] = stack[-2] // @221D stack[1] = 0x00 // } // Block ends with conditional jump to 0x2228, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] label_2227: // Incoming jump from 0x2226, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] 2227 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2227 assert(); } // Block terminates label_2228: // Incoming jump from 0x2226, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @222B stack[-1] // @222F stack[-2] // @2230 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 2228 5B JUMPDEST 2229 60 PUSH1 0x20 222B 02 MUL 222C 60 PUSH1 0x20 222E 01 ADD 222F 01 ADD 2230 51 MLOAD 2231 15 ISZERO 2232 61 PUSH2 0x242b 2235 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x242b, if !memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_2236: // Incoming jump from 0x2235, if not !memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[2] // { // @2236 stack[-3] // @223A memory[stack[-3]:stack[-3] + 0x20] // } 2236 82 DUP3 2237 60 PUSH1 0x00 2239 81 DUP2 223A 51 MLOAD 223B 81 DUP2 223C 10 LT 223D 61 PUSH2 0x2242 2240 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2236 stack[0] = stack[-3] // @2237 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2242, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] label_2241: // Incoming jump from 0x2240, if not 0x00 < memory[stack[-3]:stack[-3] + 0x20] 2241 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2241 assert(); } // Block terminates label_2242: // Incoming jump from 0x2240, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] // Inputs[13] // { // @2245 stack[-1] // @2249 stack[-2] // @224A memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2259 stack[-8] // @225C address(this) // @225D stack[-7] // @225E stack[-6] // @225F stack[-5] // @2260 stack[-4] // @2261 stack[-3] // @2264 memory[0x40:0x60] // @228B memory[stack[-5]:stack[-5] + 0x20] // @2294 memory[stack[-5]:stack[-5] + 0x20] // } 2242 5B JUMPDEST 2243 60 PUSH1 0x20 2245 02 MUL 2246 60 PUSH1 0x20 2248 01 ADD 2249 01 ADD 224A 51 MLOAD 224B 60 PUSH1 0x01 224D 60 PUSH1 0x01 224F 60 PUSH1 0xa0 2251 1B SHL 2252 03 SUB 2253 16 AND 2254 63 PUSH4 0x022c0d9f 2259 87 DUP8 225A 60 PUSH1 0x00 225C 30 ADDRESS 225D 89 DUP10 225E 89 DUP10 225F 89 DUP10 2260 89 DUP10 2261 89 DUP10 2262 60 PUSH1 0x40 2264 51 MLOAD 2265 60 PUSH1 0x20 2267 01 ADD 2268 80 DUP1 2269 86 DUP7 226A 81 DUP2 226B 52 MSTORE 226C 60 PUSH1 0x20 226E 01 ADD 226F 85 DUP6 2270 15 ISZERO 2271 15 ISZERO 2272 81 DUP2 2273 52 MSTORE 2274 60 PUSH1 0x20 2276 01 ADD 2277 80 DUP1 2278 60 PUSH1 0x20 227A 01 ADD 227B 80 DUP1 227C 60 PUSH1 0x20 227E 01 ADD 227F 80 DUP1 2280 60 PUSH1 0x20 2282 01 ADD 2283 84 DUP5 2284 81 DUP2 2285 03 SUB 2286 84 DUP5 2287 52 MSTORE 2288 87 DUP8 2289 81 DUP2 228A 81 DUP2 228B 51 MLOAD 228C 81 DUP2 228D 52 MSTORE 228E 60 PUSH1 0x20 2290 01 ADD 2291 91 SWAP2 2292 50 POP 2293 80 DUP1 2294 51 MLOAD 2295 90 SWAP1 2296 60 PUSH1 0x20 2298 01 ADD 2299 90 SWAP1 229A 60 PUSH1 0x20 229C 02 MUL 229D 80 DUP1 229E 83 DUP4 229F 83 DUP4 22A0 60 PUSH1 0x00 22A2 5B JUMPDEST 22A3 83 DUP4 22A4 81 DUP2 22A5 10 LT 22A6 15 ISZERO 22A7 61 PUSH2 0x22ba 22AA 57 *JUMPI // Stack delta = +19 // Outputs[25] // { // @2253 stack[-2] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2254 stack[-1] = 0x022c0d9f // @2259 stack[0] = stack[-8] // @225A stack[1] = 0x00 // @225C stack[2] = address(this) // @225D stack[3] = stack[-7] // @225E stack[4] = stack[-6] // @225F stack[5] = stack[-5] // @2260 stack[6] = stack[-4] // @2261 stack[7] = stack[-3] // @2267 stack[8] = 0x20 + memory[0x40:0x60] // @226B memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-7] // @2273 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = !!stack[-6] // @2276 stack[9] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @227A stack[10] = 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @227E stack[11] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @2287 memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - (0x20 + memory[0x40:0x60]) // @228D memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-5]:stack[-5] + 0x20] // @2291 stack[12] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @2299 stack[13] = 0x20 + stack[-5] // @229C stack[14] = 0x20 * memory[stack[-5]:stack[-5] + 0x20] // @229D stack[15] = 0x20 * memory[stack[-5]:stack[-5] + 0x20] // @229E stack[16] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @229F stack[17] = 0x20 + stack[-5] // @22A0 stack[18] = 0x00 // } // Block ends with conditional jump to 0x22ba, if !(0x00 < 0x20 * memory[stack[-5]:stack[-5] + 0x20]) label_22AB: // Incoming jump from 0x22AA, if not !(0x00 < 0x20 * memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x22AA, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @22AB stack[-2] // @22AC stack[-1] // @22AE memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @22AF stack[-3] // } 22AB 81 DUP2 22AC 81 DUP2 22AD 01 ADD 22AE 51 MLOAD 22AF 83 DUP4 22B0 82 DUP3 22B1 01 ADD 22B2 52 MSTORE 22B3 60 PUSH1 0x20 22B5 01 ADD 22B6 61 PUSH2 0x22a2 22B9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @22B2 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @22B5 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x22a2 label_22BA: // Incoming jump from 0x22AA, if !(0x00 < 0x20 * memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x22AA, if !(stack[-1] < stack[-4]) // Inputs[8] // { // @22BF stack[-5] // @22BF stack[-6] // @22C1 stack[-7] // @22C2 stack[-11] // @22C5 stack[-9] // @22C7 stack[-13] // @22CA memory[stack[-13]:stack[-13] + 0x20] // @22D3 memory[stack[-13]:stack[-13] + 0x20] // } 22BA 5B JUMPDEST 22BB 50 POP 22BC 50 POP 22BD 50 POP 22BE 50 POP 22BF 90 SWAP1 22C0 50 POP 22C1 01 ADD 22C2 84 DUP5 22C3 81 DUP2 22C4 03 SUB 22C5 83 DUP4 22C6 52 MSTORE 22C7 86 DUP7 22C8 81 DUP2 22C9 81 DUP2 22CA 51 MLOAD 22CB 81 DUP2 22CC 52 MSTORE 22CD 60 PUSH1 0x20 22CF 01 ADD 22D0 91 SWAP2 22D1 50 POP 22D2 80 DUP1 22D3 51 MLOAD 22D4 90 SWAP1 22D5 60 PUSH1 0x20 22D7 01 ADD 22D8 90 SWAP1 22D9 60 PUSH1 0x20 22DB 02 MUL 22DC 80 DUP1 22DD 83 DUP4 22DE 83 DUP4 22DF 60 PUSH1 0x00 22E1 5B JUMPDEST 22E2 83 DUP4 22E3 81 DUP2 22E4 10 LT 22E5 15 ISZERO 22E6 61 PUSH2 0x22f9 22E9 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @22C6 memory[stack[-9]:stack[-9] + 0x20] = (stack[-5] + stack[-7]) - stack[-11] // @22CC memory[stack[-5] + stack[-7]:stack[-5] + stack[-7] + 0x20] = memory[stack[-13]:stack[-13] + 0x20] // @22D0 stack[-7] = 0x20 + stack[-5] + stack[-7] // @22D8 stack[-6] = 0x20 + stack[-13] // @22DB stack[-5] = 0x20 * memory[stack[-13]:stack[-13] + 0x20] // @22DC stack[-4] = 0x20 * memory[stack[-13]:stack[-13] + 0x20] // @22DD stack[-3] = 0x20 + stack[-5] + stack[-7] // @22DE stack[-2] = 0x20 + stack[-13] // @22DF stack[-1] = 0x00 // } // Block ends with conditional jump to 0x22f9, if !(0x00 < 0x20 * memory[stack[-13]:stack[-13] + 0x20]) label_22EA: // Incoming jump from 0x22E9, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x22E9, if not !(0x00 < 0x20 * memory[stack[-13]:stack[-13] + 0x20]) // Inputs[4] // { // @22EA stack[-2] // @22EB stack[-1] // @22ED memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @22EE stack[-3] // } 22EA 81 DUP2 22EB 81 DUP2 22EC 01 ADD 22ED 51 MLOAD 22EE 83 DUP4 22EF 82 DUP3 22F0 01 ADD 22F1 52 MSTORE 22F2 60 PUSH1 0x20 22F4 01 ADD 22F5 61 PUSH2 0x22e1 22F8 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @22F1 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @22F4 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x22e1 label_22F9: // Incoming jump from 0x22E9, if !(stack[-1] < stack[-4]) // Incoming jump from 0x22E9, if !(0x00 < 0x20 * memory[stack[-13]:stack[-13] + 0x20]) // Inputs[8] // { // @22FE stack[-6] // @22FE stack[-5] // @2300 stack[-7] // @2301 stack[-11] // @2304 stack[-8] // @2306 stack[-12] // @2309 memory[stack[-12]:stack[-12] + 0x20] // @2312 memory[stack[-12]:stack[-12] + 0x20] // } 22F9 5B JUMPDEST 22FA 50 POP 22FB 50 POP 22FC 50 POP 22FD 50 POP 22FE 90 SWAP1 22FF 50 POP 2300 01 ADD 2301 84 DUP5 2302 81 DUP2 2303 03 SUB 2304 82 DUP3 2305 52 MSTORE 2306 85 DUP6 2307 81 DUP2 2308 81 DUP2 2309 51 MLOAD 230A 81 DUP2 230B 52 MSTORE 230C 60 PUSH1 0x20 230E 01 ADD 230F 91 SWAP2 2310 50 POP 2311 80 DUP1 2312 51 MLOAD 2313 90 SWAP1 2314 60 PUSH1 0x20 2316 01 ADD 2317 90 SWAP1 2318 60 PUSH1 0x20 231A 02 MUL 231B 80 DUP1 231C 83 DUP4 231D 83 DUP4 231E 60 PUSH1 0x00 2320 5B JUMPDEST 2321 83 DUP4 2322 81 DUP2 2323 10 LT 2324 15 ISZERO 2325 61 PUSH2 0x2338 2328 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @2305 memory[stack[-8]:stack[-8] + 0x20] = (stack[-5] + stack[-7]) - stack[-11] // @230B memory[stack[-5] + stack[-7]:stack[-5] + stack[-7] + 0x20] = memory[stack[-12]:stack[-12] + 0x20] // @230F stack[-7] = 0x20 + stack[-5] + stack[-7] // @2317 stack[-6] = 0x20 + stack[-12] // @231A stack[-5] = 0x20 * memory[stack[-12]:stack[-12] + 0x20] // @231B stack[-4] = 0x20 * memory[stack[-12]:stack[-12] + 0x20] // @231C stack[-3] = 0x20 + stack[-5] + stack[-7] // @231D stack[-2] = 0x20 + stack[-12] // @231E stack[-1] = 0x00 // } // Block ends with conditional jump to 0x2338, if !(0x00 < 0x20 * memory[stack[-12]:stack[-12] + 0x20]) label_2329: // Incoming jump from 0x2328, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x2328, if not !(0x00 < 0x20 * memory[stack[-12]:stack[-12] + 0x20]) // Inputs[4] // { // @2329 stack[-2] // @232A stack[-1] // @232C memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @232D stack[-3] // } 2329 81 DUP2 232A 81 DUP2 232B 01 ADD 232C 51 MLOAD 232D 83 DUP4 232E 82 DUP3 232F 01 ADD 2330 52 MSTORE 2331 60 PUSH1 0x20 2333 01 ADD 2334 61 PUSH2 0x2320 2337 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2330 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2333 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x2320 label_2338: // Incoming jump from 0x2328, if !(stack[-1] < stack[-4]) // Incoming jump from 0x2328, if !(0x00 < 0x20 * memory[stack[-12]:stack[-12] + 0x20]) // Inputs[12] // { // @233D stack[-5] // @233D stack[-6] // @233F stack[-7] // @2340 stack[-16] // @234C memory[0x40:0x60] // @235B memory[0x40:0x60] // @235C stack[-20] // @236C stack[-19] // @2372 stack[-18] // @2378 stack[-17] // @2393 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @239C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 2338 5B JUMPDEST 2339 50 POP 233A 50 POP 233B 50 POP 233C 50 POP 233D 90 SWAP1 233E 50 POP 233F 01 ADD 2340 98 SWAP9 2341 50 POP 2342 50 POP 2343 50 POP 2344 50 POP 2345 50 POP 2346 50 POP 2347 50 POP 2348 50 POP 2349 50 POP 234A 60 PUSH1 0x40 234C 51 MLOAD 234D 60 PUSH1 0x20 234F 81 DUP2 2350 83 DUP4 2351 03 SUB 2352 03 SUB 2353 81 DUP2 2354 52 MSTORE 2355 90 SWAP1 2356 60 PUSH1 0x40 2358 52 MSTORE 2359 60 PUSH1 0x40 235B 51 MLOAD 235C 85 DUP6 235D 63 PUSH4 0xffffffff 2362 16 AND 2363 60 PUSH1 0xe0 2365 1B SHL 2366 81 DUP2 2367 52 MSTORE 2368 60 PUSH1 0x04 236A 01 ADD 236B 80 DUP1 236C 85 DUP6 236D 81 DUP2 236E 52 MSTORE 236F 60 PUSH1 0x20 2371 01 ADD 2372 84 DUP5 2373 81 DUP2 2374 52 MSTORE 2375 60 PUSH1 0x20 2377 01 ADD 2378 83 DUP4 2379 60 PUSH1 0x01 237B 60 PUSH1 0x01 237D 60 PUSH1 0xa0 237F 1B SHL 2380 03 SUB 2381 16 AND 2382 81 DUP2 2383 52 MSTORE 2384 60 PUSH1 0x20 2386 01 ADD 2387 80 DUP1 2388 60 PUSH1 0x20 238A 01 ADD 238B 82 DUP3 238C 81 DUP2 238D 03 SUB 238E 82 DUP3 238F 52 MSTORE 2390 83 DUP4 2391 81 DUP2 2392 81 DUP2 2393 51 MLOAD 2394 81 DUP2 2395 52 MSTORE 2396 60 PUSH1 0x20 2398 01 ADD 2399 91 SWAP2 239A 50 POP 239B 80 DUP1 239C 51 MLOAD 239D 90 SWAP1 239E 60 PUSH1 0x20 23A0 01 ADD 23A1 90 SWAP1 23A2 80 DUP1 23A3 83 DUP4 23A4 83 DUP4 23A5 60 PUSH1 0x00 23A7 5B JUMPDEST 23A8 83 DUP4 23A9 81 DUP2 23AA 10 LT 23AB 15 ISZERO 23AC 61 PUSH2 0x23bf 23AF 57 *JUMPI // Stack delta = -6 // Outputs[18] // { // @2354 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (stack[-5] + stack[-7]) - memory[0x40:0x60] - 0x20 // @2355 stack[-16] = memory[0x40:0x60] // @2358 memory[0x40:0x60] = stack[-5] + stack[-7] // @2367 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-20]) << 0xe0 // @236A stack[-15] = 0x04 + memory[0x40:0x60] // @236E memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-19] // @2374 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-18] // @2383 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-17] // @2386 stack[-14] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @238F memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2395 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2399 stack[-13] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @23A1 stack[-11] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @23A1 stack[-12] = 0x20 + memory[0x40:0x60] // @23A2 stack[-10] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @23A3 stack[-9] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @23A4 stack[-8] = 0x20 + memory[0x40:0x60] // @23A5 stack[-7] = 0x00 // } // Block ends with conditional jump to 0x23bf, if !(0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) label_23B0: // Incoming jump from 0x23AF, if not !(0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) // Incoming jump from 0x23AF, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @23B0 stack[-2] // @23B1 stack[-1] // @23B3 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @23B4 stack[-3] // } 23B0 81 DUP2 23B1 81 DUP2 23B2 01 ADD 23B3 51 MLOAD 23B4 83 DUP4 23B5 82 DUP3 23B6 01 ADD 23B7 52 MSTORE 23B8 60 PUSH1 0x20 23BA 01 ADD 23BB 61 PUSH2 0x23a7 23BE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @23B7 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @23BA stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x23a7 label_23BF: // Incoming jump from 0x23AF, if !(0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) // Incoming jump from 0x23AF, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @23C4 stack[-6] // @23C4 stack[-5] // @23C6 stack[-7] // } 23BF 5B JUMPDEST 23C0 50 POP 23C1 50 POP 23C2 50 POP 23C3 50 POP 23C4 90 SWAP1 23C5 50 POP 23C6 90 SWAP1 23C7 81 DUP2 23C8 01 ADD 23C9 90 SWAP1 23CA 60 PUSH1 0x1f 23CC 16 AND 23CD 80 DUP1 23CE 15 ISZERO 23CF 61 PUSH2 0x23ec 23D2 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @23C9 stack[-7] = stack[-5] + stack[-7] // @23CC stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x23ec, if !(0x1f & stack[-5]) label_23D3: // Incoming jump from 0x23D2, if not !(0x1f & stack[-5]) // Inputs[7] // { // @23D3 stack[-1] // @23D4 stack[-2] // @23D7 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @23EE stack[-8] // @23F9 memory[0x40:0x60] // @2400 stack[-10] // @2402 address(stack[-10]).code.length // } 23D3 80 DUP1 23D4 82 DUP3 23D5 03 SUB 23D6 80 DUP1 23D7 51 MLOAD 23D8 60 PUSH1 0x01 23DA 83 DUP4 23DB 60 PUSH1 0x20 23DD 03 SUB 23DE 61 PUSH2 0x0100 23E1 0A EXP 23E2 03 SUB 23E3 19 NOT 23E4 16 AND 23E5 81 DUP2 23E6 52 MSTORE 23E7 60 PUSH1 0x20 23E9 01 ADD 23EA 91 SWAP2 23EB 50 POP 23EC 5B JUMPDEST 23ED 50 POP 23EE 95 SWAP6 23EF 50 POP 23F0 50 POP 23F1 50 POP 23F2 50 POP 23F3 50 POP 23F4 50 POP 23F5 60 PUSH1 0x00 23F7 60 PUSH1 0x40 23F9 51 MLOAD 23FA 80 DUP1 23FB 83 DUP4 23FC 03 SUB 23FD 81 DUP2 23FE 60 PUSH1 0x00 2400 87 DUP8 2401 80 DUP1 2402 3B EXTCODESIZE 2403 15 ISZERO 2404 80 DUP1 2405 15 ISZERO 2406 61 PUSH2 0x240e 2409 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @23E6 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] // @23EE stack[-8] = 0x20 + (stack[-2] - stack[-1]) // @23F5 stack[-7] = 0x00 // @23F9 stack[-6] = memory[0x40:0x60] // @23FC stack[-5] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @23FD stack[-4] = memory[0x40:0x60] // @23FE stack[-3] = 0x00 // @2400 stack[-2] = stack[-10] // @2403 stack[-1] = !address(stack[-10]).code.length // } // Block ends with conditional jump to 0x240e, if !!address(stack[-10]).code.length label_240A: // Incoming jump from 0x2409, if not !!address(stack[-10]).code.length // Incoming jump from 0x2409, if not !!address(stack[-10]).code.length // Inputs[1] { @240D memory[0x00:0x00] } 240A 60 PUSH1 0x00 240C 80 DUP1 240D FD *REVERT // Stack delta = +0 // Outputs[1] { @240D revert(memory[0x00:0x00]); } // Block terminates label_240E: // Incoming jump from 0x2409, if !!address(stack[-10]).code.length // Incoming jump from 0x2409, if !!address(stack[-10]).code.length // Inputs[9] // { // @2410 msg.gas // @2411 stack[-6] // @2411 stack[-4] // @2411 stack[-7] // @2411 stack[-3] // @2411 stack[-5] // @2411 memory[stack[-4]:stack[-4] + stack[-5]] // @2411 stack[-2] // @2411 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 240E 5B JUMPDEST 240F 50 POP 2410 5A GAS 2411 F1 CALL 2412 15 ISZERO 2413 80 DUP1 2414 15 ISZERO 2415 61 PUSH2 0x2422 2418 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @2411 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2412 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 0x2422, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_2419: // Incoming jump from 0x2418, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @2419 returndata.length // @241D returndata[0x00:0x00 + returndata.length] // @241E returndata.length // @2421 memory[0x00:0x00 + returndata.length] // } 2419 3D RETURNDATASIZE 241A 60 PUSH1 0x00 241C 80 DUP1 241D 3E RETURNDATACOPY 241E 3D RETURNDATASIZE 241F 60 PUSH1 0x00 2421 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @241D memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2421 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2422: // Incoming jump from 0x2418, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) 2422 5B JUMPDEST 2423 50 POP 2424 50 POP 2425 50 POP 2426 50 POP 2427 61 PUSH2 0x2618 242A 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to 0x2618 label_242B: // Incoming jump from 0x2235, if !memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[2] // { // @242C stack[-3] // @2430 memory[stack[-3]:stack[-3] + 0x20] // } 242B 5B JUMPDEST 242C 82 DUP3 242D 60 PUSH1 0x00 242F 81 DUP2 2430 51 MLOAD 2431 81 DUP2 2432 10 LT 2433 61 PUSH2 0x2438 2436 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @242C stack[0] = stack[-3] // @242D stack[1] = 0x00 // } // Block ends with conditional jump to 0x2438, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] label_2437: // Incoming jump from 0x2436, if not 0x00 < memory[stack[-3]:stack[-3] + 0x20] 2437 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2437 assert(); } // Block terminates label_2438: // Incoming jump from 0x2436, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] // Inputs[13] // { // @243B stack[-1] // @243F stack[-2] // @2440 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2451 stack[-8] // @2452 address(this) // @2453 stack[-7] // @2454 stack[-6] // @2455 stack[-5] // @2456 stack[-4] // @2457 stack[-3] // @245A memory[0x40:0x60] // @2481 memory[stack[-5]:stack[-5] + 0x20] // @248A memory[stack[-5]:stack[-5] + 0x20] // } 2438 5B JUMPDEST 2439 60 PUSH1 0x20 243B 02 MUL 243C 60 PUSH1 0x20 243E 01 ADD 243F 01 ADD 2440 51 MLOAD 2441 60 PUSH1 0x01 2443 60 PUSH1 0x01 2445 60 PUSH1 0xa0 2447 1B SHL 2448 03 SUB 2449 16 AND 244A 63 PUSH4 0x022c0d9f 244F 60 PUSH1 0x00 2451 88 DUP9 2452 30 ADDRESS 2453 89 DUP10 2454 89 DUP10 2455 89 DUP10 2456 89 DUP10 2457 89 DUP10 2458 60 PUSH1 0x40 245A 51 MLOAD 245B 60 PUSH1 0x20 245D 01 ADD 245E 80 DUP1 245F 86 DUP7 2460 81 DUP2 2461 52 MSTORE 2462 60 PUSH1 0x20 2464 01 ADD 2465 85 DUP6 2466 15 ISZERO 2467 15 ISZERO 2468 81 DUP2 2469 52 MSTORE 246A 60 PUSH1 0x20 246C 01 ADD 246D 80 DUP1 246E 60 PUSH1 0x20 2470 01 ADD 2471 80 DUP1 2472 60 PUSH1 0x20 2474 01 ADD 2475 80 DUP1 2476 60 PUSH1 0x20 2478 01 ADD 2479 84 DUP5 247A 81 DUP2 247B 03 SUB 247C 84 DUP5 247D 52 MSTORE 247E 87 DUP8 247F 81 DUP2 2480 81 DUP2 2481 51 MLOAD 2482 81 DUP2 2483 52 MSTORE 2484 60 PUSH1 0x20 2486 01 ADD 2487 91 SWAP2 2488 50 POP 2489 80 DUP1 248A 51 MLOAD 248B 90 SWAP1 248C 60 PUSH1 0x20 248E 01 ADD 248F 90 SWAP1 2490 60 PUSH1 0x20 2492 02 MUL 2493 80 DUP1 2494 83 DUP4 2495 83 DUP4 2496 60 PUSH1 0x00 2498 5B JUMPDEST 2499 83 DUP4 249A 81 DUP2 249B 10 LT 249C 15 ISZERO 249D 61 PUSH2 0x24b0 24A0 57 *JUMPI // Stack delta = +19 // Outputs[25] // { // @2449 stack[-2] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @244A stack[-1] = 0x022c0d9f // @244F stack[0] = 0x00 // @2451 stack[1] = stack[-8] // @2452 stack[2] = address(this) // @2453 stack[3] = stack[-7] // @2454 stack[4] = stack[-6] // @2455 stack[5] = stack[-5] // @2456 stack[6] = stack[-4] // @2457 stack[7] = stack[-3] // @245D stack[8] = 0x20 + memory[0x40:0x60] // @2461 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-7] // @2469 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = !!stack[-6] // @246C stack[9] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @2470 stack[10] = 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @2474 stack[11] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @247D memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - (0x20 + memory[0x40:0x60]) // @2483 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-5]:stack[-5] + 0x20] // @2487 stack[12] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @248F stack[13] = 0x20 + stack[-5] // @2492 stack[14] = 0x20 * memory[stack[-5]:stack[-5] + 0x20] // @2493 stack[15] = 0x20 * memory[stack[-5]:stack[-5] + 0x20] // @2494 stack[16] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @2495 stack[17] = 0x20 + stack[-5] // @2496 stack[18] = 0x00 // } // Block ends with conditional jump to 0x24b0, if !(0x00 < 0x20 * memory[stack[-5]:stack[-5] + 0x20]) label_24A1: // Incoming jump from 0x24A0, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x24A0, if not !(0x00 < 0x20 * memory[stack[-5]:stack[-5] + 0x20]) // Inputs[4] // { // @24A1 stack[-2] // @24A2 stack[-1] // @24A4 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @24A5 stack[-3] // } 24A1 81 DUP2 24A2 81 DUP2 24A3 01 ADD 24A4 51 MLOAD 24A5 83 DUP4 24A6 82 DUP3 24A7 01 ADD 24A8 52 MSTORE 24A9 60 PUSH1 0x20 24AB 01 ADD 24AC 61 PUSH2 0x2498 24AF 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @24A8 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @24AB stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x2498 label_24B0: // Incoming jump from 0x24A0, if !(stack[-1] < stack[-4]) // Incoming jump from 0x24A0, if !(0x00 < 0x20 * memory[stack[-5]:stack[-5] + 0x20]) // Inputs[8] // { // @24B5 stack[-6] // @24B5 stack[-5] // @24B7 stack[-7] // @24B8 stack[-11] // @24BB stack[-9] // @24BD stack[-13] // @24C0 memory[stack[-13]:stack[-13] + 0x20] // @24C9 memory[stack[-13]:stack[-13] + 0x20] // } 24B0 5B JUMPDEST 24B1 50 POP 24B2 50 POP 24B3 50 POP 24B4 50 POP 24B5 90 SWAP1 24B6 50 POP 24B7 01 ADD 24B8 84 DUP5 24B9 81 DUP2 24BA 03 SUB 24BB 83 DUP4 24BC 52 MSTORE 24BD 86 DUP7 24BE 81 DUP2 24BF 81 DUP2 24C0 51 MLOAD 24C1 81 DUP2 24C2 52 MSTORE 24C3 60 PUSH1 0x20 24C5 01 ADD 24C6 91 SWAP2 24C7 50 POP 24C8 80 DUP1 24C9 51 MLOAD 24CA 90 SWAP1 24CB 60 PUSH1 0x20 24CD 01 ADD 24CE 90 SWAP1 24CF 60 PUSH1 0x20 24D1 02 MUL 24D2 80 DUP1 24D3 83 DUP4 24D4 83 DUP4 24D5 60 PUSH1 0x00 24D7 5B JUMPDEST 24D8 83 DUP4 24D9 81 DUP2 24DA 10 LT 24DB 15 ISZERO 24DC 61 PUSH2 0x24ef 24DF 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @24BC memory[stack[-9]:stack[-9] + 0x20] = (stack[-5] + stack[-7]) - stack[-11] // @24C2 memory[stack[-5] + stack[-7]:stack[-5] + stack[-7] + 0x20] = memory[stack[-13]:stack[-13] + 0x20] // @24C6 stack[-7] = 0x20 + stack[-5] + stack[-7] // @24CE stack[-6] = 0x20 + stack[-13] // @24D1 stack[-5] = 0x20 * memory[stack[-13]:stack[-13] + 0x20] // @24D2 stack[-4] = 0x20 * memory[stack[-13]:stack[-13] + 0x20] // @24D3 stack[-3] = 0x20 + stack[-5] + stack[-7] // @24D4 stack[-2] = 0x20 + stack[-13] // @24D5 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x24ef, if !(0x00 < 0x20 * memory[stack[-13]:stack[-13] + 0x20]) label_24E0: // Incoming jump from 0x24DF, if not !(0x00 < 0x20 * memory[stack[-13]:stack[-13] + 0x20]) // Incoming jump from 0x24DF, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @24E0 stack[-2] // @24E1 stack[-1] // @24E3 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @24E4 stack[-3] // } 24E0 81 DUP2 24E1 81 DUP2 24E2 01 ADD 24E3 51 MLOAD 24E4 83 DUP4 24E5 82 DUP3 24E6 01 ADD 24E7 52 MSTORE 24E8 60 PUSH1 0x20 24EA 01 ADD 24EB 61 PUSH2 0x24d7 24EE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @24E7 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @24EA stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x24d7 label_24EF: // Incoming jump from 0x24DF, if !(0x00 < 0x20 * memory[stack[-13]:stack[-13] + 0x20]) // Incoming jump from 0x24DF, if !(stack[-1] < stack[-4]) // Inputs[8] // { // @24F4 stack[-6] // @24F4 stack[-5] // @24F6 stack[-7] // @24F7 stack[-11] // @24FA stack[-8] // @24FC stack[-12] // @24FF memory[stack[-12]:stack[-12] + 0x20] // @2508 memory[stack[-12]:stack[-12] + 0x20] // } 24EF 5B JUMPDEST 24F0 50 POP 24F1 50 POP 24F2 50 POP 24F3 50 POP 24F4 90 SWAP1 24F5 50 POP 24F6 01 ADD 24F7 84 DUP5 24F8 81 DUP2 24F9 03 SUB 24FA 82 DUP3 24FB 52 MSTORE 24FC 85 DUP6 24FD 81 DUP2 24FE 81 DUP2 24FF 51 MLOAD 2500 81 DUP2 2501 52 MSTORE 2502 60 PUSH1 0x20 2504 01 ADD 2505 91 SWAP2 2506 50 POP 2507 80 DUP1 2508 51 MLOAD 2509 90 SWAP1 250A 60 PUSH1 0x20 250C 01 ADD 250D 90 SWAP1 250E 60 PUSH1 0x20 2510 02 MUL 2511 80 DUP1 2512 83 DUP4 2513 83 DUP4 2514 60 PUSH1 0x00 2516 5B JUMPDEST 2517 83 DUP4 2518 81 DUP2 2519 10 LT 251A 15 ISZERO 251B 61 PUSH2 0x252e 251E 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @24FB memory[stack[-8]:stack[-8] + 0x20] = (stack[-5] + stack[-7]) - stack[-11] // @2501 memory[stack[-5] + stack[-7]:stack[-5] + stack[-7] + 0x20] = memory[stack[-12]:stack[-12] + 0x20] // @2505 stack[-7] = 0x20 + stack[-5] + stack[-7] // @250D stack[-6] = 0x20 + stack[-12] // @2510 stack[-5] = 0x20 * memory[stack[-12]:stack[-12] + 0x20] // @2511 stack[-4] = 0x20 * memory[stack[-12]:stack[-12] + 0x20] // @2512 stack[-3] = 0x20 + stack[-5] + stack[-7] // @2513 stack[-2] = 0x20 + stack[-12] // @2514 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x252e, if !(0x00 < 0x20 * memory[stack[-12]:stack[-12] + 0x20]) label_251F: // Incoming jump from 0x251E, if not !(0x00 < 0x20 * memory[stack[-12]:stack[-12] + 0x20]) // Incoming jump from 0x251E, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @251F stack[-2] // @2520 stack[-1] // @2522 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2523 stack[-3] // } 251F 81 DUP2 2520 81 DUP2 2521 01 ADD 2522 51 MLOAD 2523 83 DUP4 2524 82 DUP3 2525 01 ADD 2526 52 MSTORE 2527 60 PUSH1 0x20 2529 01 ADD 252A 61 PUSH2 0x2516 252D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2526 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2529 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x2516 label_252E: // Incoming jump from 0x251E, if !(0x00 < 0x20 * memory[stack[-12]:stack[-12] + 0x20]) // Incoming jump from 0x251E, if !(stack[-1] < stack[-4]) // Inputs[12] // { // @2533 stack[-6] // @2533 stack[-5] // @2535 stack[-7] // @2536 stack[-16] // @2542 memory[0x40:0x60] // @2551 memory[0x40:0x60] // @2552 stack[-20] // @2562 stack[-19] // @2568 stack[-18] // @256E stack[-17] // @2589 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2592 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 252E 5B JUMPDEST 252F 50 POP 2530 50 POP 2531 50 POP 2532 50 POP 2533 90 SWAP1 2534 50 POP 2535 01 ADD 2536 98 SWAP9 2537 50 POP 2538 50 POP 2539 50 POP 253A 50 POP 253B 50 POP 253C 50 POP 253D 50 POP 253E 50 POP 253F 50 POP 2540 60 PUSH1 0x40 2542 51 MLOAD 2543 60 PUSH1 0x20 2545 81 DUP2 2546 83 DUP4 2547 03 SUB 2548 03 SUB 2549 81 DUP2 254A 52 MSTORE 254B 90 SWAP1 254C 60 PUSH1 0x40 254E 52 MSTORE 254F 60 PUSH1 0x40 2551 51 MLOAD 2552 85 DUP6 2553 63 PUSH4 0xffffffff 2558 16 AND 2559 60 PUSH1 0xe0 255B 1B SHL 255C 81 DUP2 255D 52 MSTORE 255E 60 PUSH1 0x04 2560 01 ADD 2561 80 DUP1 2562 85 DUP6 2563 81 DUP2 2564 52 MSTORE 2565 60 PUSH1 0x20 2567 01 ADD 2568 84 DUP5 2569 81 DUP2 256A 52 MSTORE 256B 60 PUSH1 0x20 256D 01 ADD 256E 83 DUP4 256F 60 PUSH1 0x01 2571 60 PUSH1 0x01 2573 60 PUSH1 0xa0 2575 1B SHL 2576 03 SUB 2577 16 AND 2578 81 DUP2 2579 52 MSTORE 257A 60 PUSH1 0x20 257C 01 ADD 257D 80 DUP1 257E 60 PUSH1 0x20 2580 01 ADD 2581 82 DUP3 2582 81 DUP2 2583 03 SUB 2584 82 DUP3 2585 52 MSTORE 2586 83 DUP4 2587 81 DUP2 2588 81 DUP2 2589 51 MLOAD 258A 81 DUP2 258B 52 MSTORE 258C 60 PUSH1 0x20 258E 01 ADD 258F 91 SWAP2 2590 50 POP 2591 80 DUP1 2592 51 MLOAD 2593 90 SWAP1 2594 60 PUSH1 0x20 2596 01 ADD 2597 90 SWAP1 2598 80 DUP1 2599 83 DUP4 259A 83 DUP4 259B 60 PUSH1 0x00 259D 5B JUMPDEST 259E 83 DUP4 259F 81 DUP2 25A0 10 LT 25A1 15 ISZERO 25A2 61 PUSH2 0x25b5 25A5 57 *JUMPI // Stack delta = -6 // Outputs[18] // { // @254A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (stack[-5] + stack[-7]) - memory[0x40:0x60] - 0x20 // @254B stack[-16] = memory[0x40:0x60] // @254E memory[0x40:0x60] = stack[-5] + stack[-7] // @255D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-20]) << 0xe0 // @2560 stack[-15] = 0x04 + memory[0x40:0x60] // @2564 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-19] // @256A memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-18] // @2579 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-17] // @257C stack[-14] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2585 memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @258B memory[0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @258F stack[-13] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2597 stack[-11] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2597 stack[-12] = 0x20 + memory[0x40:0x60] // @2598 stack[-10] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2599 stack[-9] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @259A stack[-8] = 0x20 + memory[0x40:0x60] // @259B stack[-7] = 0x00 // } // Block ends with conditional jump to 0x25b5, if !(0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) label_25A6: // Incoming jump from 0x25A5, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x25A5, if not !(0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) // Inputs[4] // { // @25A6 stack[-2] // @25A7 stack[-1] // @25A9 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @25AA stack[-3] // } 25A6 81 DUP2 25A7 81 DUP2 25A8 01 ADD 25A9 51 MLOAD 25AA 83 DUP4 25AB 82 DUP3 25AC 01 ADD 25AD 52 MSTORE 25AE 60 PUSH1 0x20 25B0 01 ADD 25B1 61 PUSH2 0x259d 25B4 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @25AD memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @25B0 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x259d label_25B5: // Incoming jump from 0x25A5, if !(stack[-1] < stack[-4]) // Incoming jump from 0x25A5, if !(0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) // Inputs[3] // { // @25BA stack[-5] // @25BA stack[-6] // @25BC stack[-7] // } 25B5 5B JUMPDEST 25B6 50 POP 25B7 50 POP 25B8 50 POP 25B9 50 POP 25BA 90 SWAP1 25BB 50 POP 25BC 90 SWAP1 25BD 81 DUP2 25BE 01 ADD 25BF 90 SWAP1 25C0 60 PUSH1 0x1f 25C2 16 AND 25C3 80 DUP1 25C4 15 ISZERO 25C5 61 PUSH2 0x25e2 25C8 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @25BF stack[-7] = stack[-5] + stack[-7] // @25C2 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x25e2, if !(0x1f & stack[-5]) label_25C9: // Incoming jump from 0x25C8, if not !(0x1f & stack[-5]) // Inputs[7] // { // @25C9 stack[-1] // @25CA stack[-2] // @25CD memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @25E4 stack[-8] // @25EF memory[0x40:0x60] // @25F6 stack[-10] // @25F8 address(stack[-10]).code.length // } 25C9 80 DUP1 25CA 82 DUP3 25CB 03 SUB 25CC 80 DUP1 25CD 51 MLOAD 25CE 60 PUSH1 0x01 25D0 83 DUP4 25D1 60 PUSH1 0x20 25D3 03 SUB 25D4 61 PUSH2 0x0100 25D7 0A EXP 25D8 03 SUB 25D9 19 NOT 25DA 16 AND 25DB 81 DUP2 25DC 52 MSTORE 25DD 60 PUSH1 0x20 25DF 01 ADD 25E0 91 SWAP2 25E1 50 POP 25E2 5B JUMPDEST 25E3 50 POP 25E4 95 SWAP6 25E5 50 POP 25E6 50 POP 25E7 50 POP 25E8 50 POP 25E9 50 POP 25EA 50 POP 25EB 60 PUSH1 0x00 25ED 60 PUSH1 0x40 25EF 51 MLOAD 25F0 80 DUP1 25F1 83 DUP4 25F2 03 SUB 25F3 81 DUP2 25F4 60 PUSH1 0x00 25F6 87 DUP8 25F7 80 DUP1 25F8 3B EXTCODESIZE 25F9 15 ISZERO 25FA 80 DUP1 25FB 15 ISZERO 25FC 61 PUSH2 0x2604 25FF 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @25DC 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] // @25E4 stack[-8] = 0x20 + (stack[-2] - stack[-1]) // @25EB stack[-7] = 0x00 // @25EF stack[-6] = memory[0x40:0x60] // @25F2 stack[-5] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @25F3 stack[-4] = memory[0x40:0x60] // @25F4 stack[-3] = 0x00 // @25F6 stack[-2] = stack[-10] // @25F9 stack[-1] = !address(stack[-10]).code.length // } // Block ends with conditional jump to 0x2604, if !!address(stack[-10]).code.length label_2600: // Incoming jump from 0x25FF, if not !!address(stack[-10]).code.length // Incoming jump from 0x25FF, if not !!address(stack[-10]).code.length // Inputs[1] { @2603 memory[0x00:0x00] } 2600 60 PUSH1 0x00 2602 80 DUP1 2603 FD *REVERT // Stack delta = +0 // Outputs[1] { @2603 revert(memory[0x00:0x00]); } // Block terminates label_2604: // Incoming jump from 0x25FF, if !!address(stack[-10]).code.length // Incoming jump from 0x25FF, if !!address(stack[-10]).code.length // Inputs[9] // { // @2606 msg.gas // @2607 stack[-3] // @2607 stack[-6] // @2607 stack[-7] // @2607 memory[stack[-4]:stack[-4] + stack[-5]] // @2607 stack[-2] // @2607 stack[-5] // @2607 stack[-4] // @2607 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 2604 5B JUMPDEST 2605 50 POP 2606 5A GAS 2607 F1 CALL 2608 15 ISZERO 2609 80 DUP1 260A 15 ISZERO 260B 61 PUSH2 0x0af9 260E 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @2607 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2608 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 0x0af9, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_260F: // Incoming jump from 0x260E, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @260F returndata.length // @2613 returndata[0x00:0x00 + returndata.length] // @2614 returndata.length // @2617 memory[0x00:0x00 + returndata.length] // } 260F 3D RETURNDATASIZE 2610 60 PUSH1 0x00 2612 80 DUP1 2613 3E RETURNDATACOPY 2614 3D RETURNDATASIZE 2615 60 PUSH1 0x00 2617 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2613 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2617 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2618: // Incoming jump from 0x242A // Inputs[1] { @261F stack[-7] } 2618 5B JUMPDEST 2619 50 POP 261A 50 POP 261B 50 POP 261C 50 POP 261D 50 POP 261E 50 POP 261F 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_2620: // Incoming call from 0x0E43, returns to 0x0E44 // Incoming call from 0x0ECD, returns to 0x0ECE // Incoming call from 0x0EE5, returns to 0x0EE6 // Inputs[1] { @2624 memory[0x40:0x60] } 2620 5B JUMPDEST 2621 60 PUSH1 0x40 2623 80 DUP1 2624 51 MLOAD 2625 60 PUSH1 0x02 2627 80 DUP1 2628 82 DUP3 2629 52 MSTORE 262A 60 PUSH1 0x60 262C 82 DUP3 262D 81 DUP2 262E 01 ADD 262F 90 SWAP1 2630 93 SWAP4 2631 52 MSTORE 2632 60 PUSH1 0x00 2634 92 SWAP3 2635 91 SWAP2 2636 83 DUP4 2637 91 SWAP2 2638 83 DUP4 2639 91 SWAP2 263A 90 SWAP1 263B 81 DUP2 263C 60 PUSH1 0x20 263E 01 ADD 263F 5B JUMPDEST 2640 60 PUSH1 0x60 2642 81 DUP2 2643 52 MSTORE 2644 60 PUSH1 0x20 2646 01 ADD 2647 90 SWAP1 2648 60 PUSH1 0x01 264A 90 SWAP1 264B 03 SUB 264C 90 SWAP1 264D 81 DUP2 264E 61 PUSH2 0x263f 2651 57 *JUMPI // Stack delta = +7 // Outputs[10] // { // @2629 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x02 // @2631 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @2634 stack[0] = 0x00 // @2635 stack[1] = 0x60 // @2637 stack[2] = 0x00 // @2639 stack[3] = 0x60 // @263A stack[4] = memory[0x40:0x60] // @2643 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x60 // @264C stack[5] = 0x02 - 0x01 // @264C stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // } // Block ends with conditional jump to 0x263f, if 0x02 - 0x01 label_2652: // Incoming jump from 0x2651, if not stack[-2] - 0x01 // Incoming jump from 0x2651, if not 0x02 - 0x01 // Inputs[5] // { // @2652 stack[-1] // @2652 stack[-2] // @2655 stack[-3] // @2655 stack[-4] // @265A stack[-10] // } 2652 90 SWAP1 2653 50 POP 2654 50 POP 2655 90 SWAP1 2656 50 POP 2657 61 PUSH2 0x265f 265A 87 DUP8 265B 61 PUSH2 0x1d6e 265E 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @2655 stack[-4] = stack[-3] // @2657 stack[-3] = 0x265f // @265A stack[-2] = stack[-10] // } // Block ends with call to 0x1d6e, returns to 0x265F label_265F: // Incoming return from call to 0x1D6E at 0x265E // Inputs[2] // { // @2660 stack[-3] // @2664 memory[stack[-3]:stack[-3] + 0x20] // } 265F 5B JUMPDEST 2660 82 DUP3 2661 60 PUSH1 0x00 2663 81 DUP2 2664 51 MLOAD 2665 81 DUP2 2666 10 LT 2667 61 PUSH2 0x266c 266A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2660 stack[0] = stack[-3] // @2661 stack[1] = 0x00 // } // Block ends with conditional jump to 0x266c, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] label_266B: // Incoming jump from 0x266A, if not 0x00 < memory[stack[-3]:stack[-3] + 0x20] 266B FE *ASSERT // Stack delta = +0 // Outputs[1] { @266B assert(); } // Block terminates label_266C: // Incoming jump from 0x266A, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @266F stack[-1] // @2673 stack[-2] // @2674 stack[-5] // @2678 memory[stack[-5]:stack[-5] + 0x20] // } 266C 5B JUMPDEST 266D 60 PUSH1 0x20 266F 02 MUL 2670 60 PUSH1 0x20 2672 01 ADD 2673 01 ADD 2674 83 DUP4 2675 60 PUSH1 0x01 2677 81 DUP2 2678 51 MLOAD 2679 81 DUP2 267A 10 LT 267B 61 PUSH2 0x2680 267E 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2673 stack[-2] = 0x20 + 0x20 * stack[-1] + stack[-2] // @2674 stack[-1] = stack[-5] // @2675 stack[0] = 0x01 // } // Block ends with conditional jump to 0x2680, if 0x01 < memory[stack[-5]:stack[-5] + 0x20] label_267F: // Incoming jump from 0x267E, if not 0x01 < memory[stack[-5]:stack[-5] + 0x20] 267F FE *ASSERT // Stack delta = +0 // Outputs[1] { @267F assert(); } // Block terminates label_2680: // Incoming jump from 0x267E, if 0x01 < memory[stack[-5]:stack[-5] + 0x20] // Inputs[7] // { // @2683 stack[-1] // @2687 stack[-2] // @2688 stack[-4] // @268B stack[-5] // @268C stack[-3] // @2692 stack[-10] // @2696 memory[stack[-10]:stack[-10] + 0x20] // } 2680 5B JUMPDEST 2681 60 PUSH1 0x20 2683 02 MUL 2684 60 PUSH1 0x20 2686 01 ADD 2687 01 ADD 2688 82 DUP3 2689 90 SWAP1 268A 52 MSTORE 268B 82 DUP3 268C 90 SWAP1 268D 52 MSTORE 268E 50 POP 268F 50 POP 2690 60 PUSH1 0x00 2692 85 DUP6 2693 60 PUSH1 0x00 2695 81 DUP2 2696 51 MLOAD 2697 81 DUP2 2698 10 LT 2699 61 PUSH2 0x269e 269C 57 *JUMPI // Stack delta = -2 // Outputs[5] // { // @268A memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = stack[-4] // @268D memory[stack[-3]:stack[-3] + 0x20] = stack[-5] // @2690 stack[-5] = 0x00 // @2692 stack[-4] = stack[-10] // @2693 stack[-3] = 0x00 // } // Block ends with conditional jump to 0x269e, if 0x00 < memory[stack[-10]:stack[-10] + 0x20] label_269D: // Incoming jump from 0x269C, if not 0x00 < memory[stack[-10]:stack[-10] + 0x20] 269D FE *ASSERT // Stack delta = +0 // Outputs[1] { @269D assert(); } // Block terminates label_269E: // Incoming jump from 0x269C, if 0x00 < memory[stack[-10]:stack[-10] + 0x20] // Inputs[3] // { // @26A1 stack[-1] // @26A5 stack[-2] // @26A6 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 269E 5B JUMPDEST 269F 60 PUSH1 0x20 26A1 02 MUL 26A2 60 PUSH1 0x20 26A4 01 ADD 26A5 01 ADD 26A6 51 MLOAD 26A7 61 PUSH2 0x26e3 26AA 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x26e3, if memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_26AB: // Incoming jump from 0x26AA, if not memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[2] // { // @26AE stack[-2] // @26B2 memory[stack[-2]:stack[-2] + 0x20] // } 26AB 61 PUSH2 0x03e8 26AE 82 DUP3 26AF 60 PUSH1 0x01 26B1 81 DUP2 26B2 51 MLOAD 26B3 81 DUP2 26B4 10 LT 26B5 61 PUSH2 0x26ba 26B8 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @26AB stack[0] = 0x03e8 // @26AE stack[1] = stack[-2] // @26AF stack[2] = 0x01 // } // Block ends with conditional jump to 0x26ba, if 0x01 < memory[stack[-2]:stack[-2] + 0x20] label_26B9: // Incoming jump from 0x26B8, if not 0x01 < memory[stack[-2]:stack[-2] + 0x20] 26B9 FE *ASSERT // Stack delta = +0 // Outputs[1] { @26B9 assert(); } // Block terminates label_26BA: // Incoming jump from 0x26B8, if 0x01 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @26BD stack[-1] // @26C1 stack[-2] // @26C2 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @26C6 memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // } 26BA 5B JUMPDEST 26BB 60 PUSH1 0x20 26BD 02 MUL 26BE 60 PUSH1 0x20 26C0 01 ADD 26C1 01 ADD 26C2 51 MLOAD 26C3 60 PUSH1 0x00 26C5 81 DUP2 26C6 51 MLOAD 26C7 81 DUP2 26C8 10 LT 26C9 61 PUSH2 0x26ce 26CC 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @26C2 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @26C3 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x26ce, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] label_26CD: // Incoming jump from 0x26CC, if not 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] 26CD FE *ASSERT // Stack delta = +0 // Outputs[1] { @26CD assert(); } // Block terminates label_26CE: // Incoming jump from 0x26CC, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // Inputs[4] // { // @26D1 stack[-1] // @26D5 stack[-2] // @26D6 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @26D7 stack[-3] // } 26CE 5B JUMPDEST 26CF 60 PUSH1 0x20 26D1 02 MUL 26D2 60 PUSH1 0x20 26D4 01 ADD 26D5 01 ADD 26D6 51 MLOAD 26D7 81 DUP2 26D8 61 PUSH2 0x26dd 26DB 57 *JUMPI // Stack delta = -1 // Outputs[1] { @26D6 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with conditional jump to 0x26dd, if stack[-3] label_26DC: // Incoming jump from 0x26DB, if not stack[-3] 26DC FE *ASSERT // Stack delta = +0 // Outputs[1] { @26DC assert(); } // Block terminates label_26DD: // Incoming jump from 0x26DB, if stack[-3] // Inputs[2] // { // @26DE stack[-2] // @26DE stack[-1] // } 26DD 5B JUMPDEST 26DE 04 DIV 26DF 61 PUSH2 0x2718 26E2 56 *JUMP // Stack delta = -1 // Outputs[1] { @26DE stack[-2] = stack[-1] / stack[-2] } // Block ends with unconditional jump to 0x2718 label_26E3: // Incoming jump from 0x26AA, if memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[2] // { // @26E7 stack[-2] // @26EB memory[stack[-2]:stack[-2] + 0x20] // } 26E3 5B JUMPDEST 26E4 61 PUSH2 0x03e8 26E7 82 DUP3 26E8 60 PUSH1 0x00 26EA 81 DUP2 26EB 51 MLOAD 26EC 81 DUP2 26ED 10 LT 26EE 61 PUSH2 0x26f3 26F1 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @26E4 stack[0] = 0x03e8 // @26E7 stack[1] = stack[-2] // @26E8 stack[2] = 0x00 // } // Block ends with conditional jump to 0x26f3, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] label_26F2: // Incoming jump from 0x26F1, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] 26F2 FE *ASSERT // Stack delta = +0 // Outputs[1] { @26F2 assert(); } // Block terminates label_26F3: // Incoming jump from 0x26F1, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @26F6 stack[-1] // @26FA stack[-2] // @26FB memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @26FF memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // } 26F3 5B JUMPDEST 26F4 60 PUSH1 0x20 26F6 02 MUL 26F7 60 PUSH1 0x20 26F9 01 ADD 26FA 01 ADD 26FB 51 MLOAD 26FC 60 PUSH1 0x00 26FE 81 DUP2 26FF 51 MLOAD 2700 81 DUP2 2701 10 LT 2702 61 PUSH2 0x2707 2705 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @26FB stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @26FC stack[-1] = 0x00 // } // Block ends with conditional jump to 0x2707, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] label_2706: // Incoming jump from 0x2705, if not 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] 2706 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2706 assert(); } // Block terminates label_2707: // Incoming jump from 0x2705, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // Inputs[4] // { // @270A stack[-1] // @270E stack[-2] // @270F memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2710 stack[-3] // } 2707 5B JUMPDEST 2708 60 PUSH1 0x20 270A 02 MUL 270B 60 PUSH1 0x20 270D 01 ADD 270E 01 ADD 270F 51 MLOAD 2710 81 DUP2 2711 61 PUSH2 0x2716 2714 57 *JUMPI // Stack delta = -1 // Outputs[1] { @270F stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with conditional jump to 0x2716, if stack[-3] label_2715: // Incoming jump from 0x2714, if not stack[-3] 2715 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2715 assert(); } // Block terminates label_2716: // Incoming jump from 0x2714, if stack[-3] // Inputs[7] // { // @2717 stack[-2] // @2717 stack[-1] // @271C memory[0x40:0x60] // @272A stack[-3] // @2734 msg.data.length // @2736 msg.data[msg.data.length:msg.data.length + 0x40] // @2743 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 2716 5B JUMPDEST 2717 04 DIV 2718 5B JUMPDEST 2719 60 PUSH1 0x40 271B 80 DUP1 271C 51 MLOAD 271D 60 PUSH1 0x02 271F 80 DUP1 2720 82 DUP3 2721 52 MSTORE 2722 60 PUSH1 0x60 2724 80 DUP1 2725 83 DUP4 2726 01 ADD 2727 84 DUP5 2728 52 MSTORE 2729 93 SWAP4 272A 94 SWAP5 272B 50 POP 272C 90 SWAP1 272D 91 SWAP2 272E 60 PUSH1 0x20 2730 83 DUP4 2731 01 ADD 2732 90 SWAP1 2733 80 DUP1 2734 36 CALLDATASIZE 2735 83 DUP4 2736 37 CALLDATACOPY 2737 01 ADD 2738 90 SWAP1 2739 50 POP 273A 50 POP 273B 90 SWAP1 273C 50 POP 273D 60 PUSH1 0x00 273F 81 DUP2 2740 60 PUSH1 0x00 2742 81 DUP2 2743 51 MLOAD 2744 81 DUP2 2745 10 LT 2746 61 PUSH2 0x274b 2749 57 *JUMPI // Stack delta = +2 // Outputs[8] // { // @2721 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x02 // @2728 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @272A stack[-3] = stack[-1] / stack[-2] // @2736 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x40] = msg.data[msg.data.length:msg.data.length + 0x40] // @273B stack[-2] = memory[0x40:0x60] // @273D stack[-1] = 0x00 // @273F stack[0] = memory[0x40:0x60] // @2740 stack[1] = 0x00 // } // Block ends with conditional jump to 0x274b, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] label_274A: // Incoming jump from 0x2749, if not 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // Incoming jump from 0x2749, if not 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] 274A FE *ASSERT // Stack delta = +0 // Outputs[1] { @274A assert(); } // Block terminates label_274B: // Incoming jump from 0x2749, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // Incoming jump from 0x2749, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // Inputs[5] // { // @274E stack[-1] // @2752 stack[-2] // @2753 stack[-3] // @275B stack[-4] // @275F memory[stack[-4]:stack[-4] + 0x20] // } 274B 5B JUMPDEST 274C 60 PUSH1 0x20 274E 02 MUL 274F 60 PUSH1 0x20 2751 01 ADD 2752 01 ADD 2753 81 DUP2 2754 81 DUP2 2755 52 MSTORE 2756 50 POP 2757 50 POP 2758 61 PUSH2 0x03e8 275B 81 DUP2 275C 60 PUSH1 0x01 275E 81 DUP2 275F 51 MLOAD 2760 81 DUP2 2761 10 LT 2762 61 PUSH2 0x2767 2765 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2755 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] // @2758 stack[-3] = 0x03e8 // @275B stack[-2] = stack[-4] // @275C stack[-1] = 0x01 // } // Block ends with conditional jump to 0x2767, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] label_2766: // Incoming jump from 0x2765, if not 0x01 < memory[stack[-4]:stack[-4] + 0x20] 2766 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2766 assert(); } // Block terminates label_2767: // Incoming jump from 0x2765, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @276A stack[-1] // @276E stack[-2] // @276F stack[-3] // @2775 stack[-9] // } 2767 5B JUMPDEST 2768 60 PUSH1 0x20 276A 02 MUL 276B 60 PUSH1 0x20 276D 01 ADD 276E 01 ADD 276F 81 DUP2 2770 81 DUP2 2771 52 MSTORE 2772 50 POP 2773 50 POP 2774 5B JUMPDEST 2775 85 DUP6 2776 61 PUSH2 0x2a82 2779 57 *JUMPI // Stack delta = -3 // Outputs[1] { @2771 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] } // Block ends with conditional jump to 0x2a82, if stack[-9] label_277A: // Incoming jump from 0x2779, if not stack[-9] // Incoming jump from 0x2779, if not stack[-6] // Inputs[2] // { // @277E stack[-1] // @2782 memory[stack[-1]:stack[-1] + 0x20] // } 277A 60 PUSH1 0x00 277C 60 PUSH1 0x02 277E 82 DUP3 277F 60 PUSH1 0x00 2781 81 DUP2 2782 51 MLOAD 2783 81 DUP2 2784 10 LT 2785 61 PUSH2 0x278a 2788 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @277A stack[0] = 0x00 // @277C stack[1] = 0x02 // @277E stack[2] = stack[-1] // @277F stack[3] = 0x00 // } // Block ends with conditional jump to 0x278a, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] label_2789: // Incoming jump from 0x2788, if not 0x00 < memory[stack[-1]:stack[-1] + 0x20] 2789 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2789 assert(); } // Block terminates label_278A: // Incoming jump from 0x2788, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] // Inputs[5] // { // @278D stack[-1] // @2791 stack[-2] // @2792 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2793 stack[-5] // @2797 memory[stack[-5]:stack[-5] + 0x20] // } 278A 5B JUMPDEST 278B 60 PUSH1 0x20 278D 02 MUL 278E 60 PUSH1 0x20 2790 01 ADD 2791 01 ADD 2792 51 MLOAD 2793 83 DUP4 2794 60 PUSH1 0x01 2796 81 DUP2 2797 51 MLOAD 2798 81 DUP2 2799 10 LT 279A 61 PUSH2 0x279f 279D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2792 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2793 stack[-1] = stack[-5] // @2794 stack[0] = 0x01 // } // Block ends with conditional jump to 0x279f, if 0x01 < memory[stack[-5]:stack[-5] + 0x20] label_279E: // Incoming jump from 0x279D, if not 0x01 < memory[stack[-5]:stack[-5] + 0x20] 279E FE *ASSERT // Stack delta = +0 // Outputs[1] { @279E assert(); } // Block terminates label_279F: // Incoming jump from 0x279D, if 0x01 < memory[stack[-5]:stack[-5] + 0x20] // Inputs[5] // { // @27A2 stack[-1] // @27A6 stack[-2] // @27A7 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @27A8 stack[-3] // @27A9 stack[-4] // } 279F 5B JUMPDEST 27A0 60 PUSH1 0x20 27A2 02 MUL 27A3 60 PUSH1 0x20 27A5 01 ADD 27A6 01 ADD 27A7 51 MLOAD 27A8 03 SUB 27A9 81 DUP2 27AA 61 PUSH2 0x27af 27AD 57 *JUMPI // Stack delta = -2 // Outputs[1] { @27A8 stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] - stack[-3] } // Block ends with conditional jump to 0x27af, if stack[-4] label_27AE: // Incoming jump from 0x27AD, if not stack[-4] 27AE FE *ASSERT // Stack delta = +0 // Outputs[1] { @27AE assert(); } // Block terminates label_27AF: // Incoming jump from 0x27AD, if stack[-4] // Inputs[4] // { // @27B0 stack[-1] // @27B0 stack[-2] // @27B1 stack[-4] // @27B5 memory[stack[-4]:stack[-4] + 0x20] // } 27AF 5B JUMPDEST 27B0 04 DIV 27B1 82 DUP3 27B2 60 PUSH1 0x00 27B4 81 DUP2 27B5 51 MLOAD 27B6 81 DUP2 27B7 10 LT 27B8 61 PUSH2 0x27bd 27BB 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @27B0 stack[-2] = stack[-1] / stack[-2] // @27B1 stack[-1] = stack[-4] // @27B2 stack[0] = 0x00 // } // Block ends with conditional jump to 0x27bd, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] label_27BC: // Incoming jump from 0x27BB, if not 0x00 < memory[stack[-4]:stack[-4] + 0x20] 27BC FE *ASSERT // Stack delta = +0 // Outputs[1] { @27BC assert(); } // Block terminates label_27BD: // Incoming jump from 0x27BB, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[5] // { // @27C0 stack[-1] // @27C4 stack[-2] // @27C5 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @27C6 stack[-3] // @27C7 stack[-4] // } 27BD 5B JUMPDEST 27BE 60 PUSH1 0x20 27C0 02 MUL 27C1 60 PUSH1 0x20 27C3 01 ADD 27C4 01 ADD 27C5 51 MLOAD 27C6 01 ADD 27C7 90 SWAP1 27C8 50 POP 27C9 80 DUP1 27CA 60 PUSH1 0x00 27CC 14 EQ 27CD 15 ISZERO 27CE 61 PUSH2 0x27ec 27D1 57 *JUMPI // Stack delta = -3 // Outputs[1] { @27C7 stack[-4] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + stack[-3] } // Block ends with conditional jump to 0x27ec, if !(0x00 == memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + stack[-3]) label_27D2: // Incoming jump from 0x27D1, if not !(0x00 == memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + stack[-3]) // Inputs[5] // { // @27D5 memory[0x40:0x60] // @27E1 stack[-1] // @27E2 stack[-3] // @27E4 stack[-7] // @27E6 stack[-6] // } 27D2 60 PUSH1 0x40 27D4 80 DUP1 27D5 51 MLOAD 27D6 60 PUSH1 0x00 27D8 81 DUP2 27D9 52 MSTORE 27DA 60 PUSH1 0x20 27DC 81 DUP2 27DD 01 ADD 27DE 90 SWAP1 27DF 91 SWAP2 27E0 52 MSTORE 27E1 90 SWAP1 27E2 83 DUP4 27E3 02 MUL 27E4 96 SWAP7 27E5 50 POP 27E6 94 SWAP5 27E7 50 POP 27E8 61 PUSH2 0x2a82 27EB 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @27D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @27E0 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @27E4 stack[-7] = stack[-3] * stack[-1] // @27E6 stack[-6] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2a82 label_27EC: // Incoming jump from 0x27D1, if !(0x00 == memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + stack[-3]) // Inputs[2] // { // @27EF stack[-8] // @27F3 memory[stack[-8]:stack[-8] + 0x20] // } 27EC 5B JUMPDEST 27ED 60 PUSH1 0x00 27EF 88 DUP9 27F0 60 PUSH1 0x00 27F2 81 DUP2 27F3 51 MLOAD 27F4 81 DUP2 27F5 10 LT 27F6 61 PUSH2 0x27fb 27F9 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @27ED stack[0] = 0x00 // @27EF stack[1] = stack[-8] // @27F0 stack[2] = 0x00 // } // Block ends with conditional jump to 0x27fb, if 0x00 < memory[stack[-8]:stack[-8] + 0x20] label_27FA: // Incoming jump from 0x27F9, if not 0x00 < memory[stack[-8]:stack[-8] + 0x20] 27FA FE *ASSERT // Stack delta = +0 // Outputs[1] { @27FA assert(); } // Block terminates label_27FB: // Incoming jump from 0x27F9, if 0x00 < memory[stack[-8]:stack[-8] + 0x20] // Inputs[3] // { // @27FE stack[-1] // @2802 stack[-2] // @2803 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 27FB 5B JUMPDEST 27FC 60 PUSH1 0x20 27FE 02 MUL 27FF 60 PUSH1 0x20 2801 01 ADD 2802 01 ADD 2803 51 MLOAD 2804 61 PUSH2 0x2848 2807 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2848, if memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_2808: // Incoming jump from 0x2807, if not memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[4] // { // @280B stack[-4] // @280C stack[-2] // @280E stack[-5] // @2812 memory[stack[-5]:stack[-5] + 0x20] // } 2808 61 PUSH2 0x2843 280B 84 DUP5 280C 83 DUP4 280D 02 MUL 280E 86 DUP7 280F 60 PUSH1 0x00 2811 81 DUP2 2812 51 MLOAD 2813 81 DUP2 2814 10 LT 2815 61 PUSH2 0x281a 2818 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2808 stack[0] = 0x2843 // @280D stack[1] = stack[-2] * stack[-4] // @280E stack[2] = stack[-5] // @280F stack[3] = 0x00 // } // Block ends with conditional call to 0x281a, returns to 0x2843, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] label_2819: // Incoming jump from 0x2818, if not 0x00 < memory[stack[-5]:stack[-5] + 0x20] 2819 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2819 assert(); } // Block terminates label_281A: // Incoming call from 0x2818, returns to 0x2843, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] // Inputs[4] // { // @281D stack[-1] // @2821 stack[-2] // @2822 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2826 memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // } 281A 5B JUMPDEST 281B 60 PUSH1 0x20 281D 02 MUL 281E 60 PUSH1 0x20 2820 01 ADD 2821 01 ADD 2822 51 MLOAD 2823 60 PUSH1 0x00 2825 81 DUP2 2826 51 MLOAD 2827 81 DUP2 2828 10 LT 2829 61 PUSH2 0x282e 282C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2822 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2823 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x282e, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] label_282D: // Incoming jump from 0x282C, if not 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] 282D FE *ASSERT // Stack delta = +0 // Outputs[1] { @282D assert(); } // Block terminates label_282E: // Incoming jump from 0x282C, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // Inputs[5] // { // @2831 stack[-1] // @2835 stack[-2] // @2836 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2837 stack[-9] // @283B memory[stack[-9]:stack[-9] + 0x20] // } 282E 5B JUMPDEST 282F 60 PUSH1 0x20 2831 02 MUL 2832 60 PUSH1 0x20 2834 01 ADD 2835 01 ADD 2836 51 MLOAD 2837 87 DUP8 2838 60 PUSH1 0x01 283A 81 DUP2 283B 51 MLOAD 283C 81 DUP2 283D 10 LT 283E 61 PUSH2 0x0cc5 2841 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2836 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2837 stack[-1] = stack[-9] // @2838 stack[0] = 0x01 // } // Block ends with conditional jump to 0x0cc5, if 0x01 < memory[stack[-9]:stack[-9] + 0x20] label_2842: // Incoming jump from 0x2841, if not 0x01 < memory[stack[-9]:stack[-9] + 0x20] 2842 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2842 assert(); } // Block terminates label_2843: // Incoming return from call to 0x281A at 0x2818 2843 5B JUMPDEST 2844 61 PUSH2 0x2884 2847 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2884 label_2848: // Incoming jump from 0x2807, if memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[4] // { // @284C stack[-4] // @284D stack[-2] // @284F stack[-5] // @2853 memory[stack[-5]:stack[-5] + 0x20] // } 2848 5B JUMPDEST 2849 61 PUSH2 0x2884 284C 84 DUP5 284D 83 DUP4 284E 02 MUL 284F 86 DUP7 2850 60 PUSH1 0x01 2852 81 DUP2 2853 51 MLOAD 2854 81 DUP2 2855 10 LT 2856 61 PUSH2 0x285b 2859 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2849 stack[0] = 0x2884 // @284E stack[1] = stack[-2] * stack[-4] // @284F stack[2] = stack[-5] // @2850 stack[3] = 0x01 // } // Block ends with conditional call to 0x285b, returns to 0x2884, if 0x01 < memory[stack[-5]:stack[-5] + 0x20] label_285A: // Incoming jump from 0x2859, if not 0x01 < memory[stack[-5]:stack[-5] + 0x20] 285A FE *ASSERT // Stack delta = +0 // Outputs[1] { @285A assert(); } // Block terminates label_285B: // Incoming call from 0x2859, returns to 0x2884, if 0x01 < memory[stack[-5]:stack[-5] + 0x20] // Inputs[4] // { // @285E stack[-1] // @2862 stack[-2] // @2863 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2867 memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // } 285B 5B JUMPDEST 285C 60 PUSH1 0x20 285E 02 MUL 285F 60 PUSH1 0x20 2861 01 ADD 2862 01 ADD 2863 51 MLOAD 2864 60 PUSH1 0x00 2866 81 DUP2 2867 51 MLOAD 2868 81 DUP2 2869 10 LT 286A 61 PUSH2 0x286f 286D 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2863 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2864 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x286f, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] label_286E: // Incoming jump from 0x286D, if not 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] 286E FE *ASSERT // Stack delta = +0 // Outputs[1] { @286E assert(); } // Block terminates label_286F: // Incoming jump from 0x286D, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // Inputs[5] // { // @2872 stack[-1] // @2876 stack[-2] // @2877 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2878 stack[-9] // @287C memory[stack[-9]:stack[-9] + 0x20] // } 286F 5B JUMPDEST 2870 60 PUSH1 0x20 2872 02 MUL 2873 60 PUSH1 0x20 2875 01 ADD 2876 01 ADD 2877 51 MLOAD 2878 87 DUP8 2879 60 PUSH1 0x00 287B 81 DUP2 287C 51 MLOAD 287D 81 DUP2 287E 10 LT 287F 61 PUSH2 0x0cc5 2882 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2877 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2878 stack[-1] = stack[-9] // @2879 stack[0] = 0x00 // } // Block ends with conditional jump to 0x0cc5, if 0x00 < memory[stack[-9]:stack[-9] + 0x20] label_2883: // Incoming jump from 0x2882, if not 0x00 < memory[stack[-9]:stack[-9] + 0x20] 2883 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2883 assert(); } // Block terminates label_2884: // Incoming jump from 0x2847 // Incoming return from call to 0x285B at 0x2859 // Inputs[5] // { // @2888 stack[-5] // @2889 stack[-3] // @288B stack[-11] // @288C stack[-10] // @288D stack[-6] // } 2884 5B JUMPDEST 2885 61 PUSH2 0x2892 2888 85 DUP6 2889 84 DUP5 288A 02 MUL 288B 8C DUP13 288C 8C DUP13 288D 89 DUP10 288E 61 PUSH2 0x2ef2 2891 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2885 stack[0] = 0x2892 // @288A stack[1] = stack[-3] * stack[-5] // @288B stack[2] = stack[-11] // @288C stack[3] = stack[-10] // @288D stack[4] = stack[-6] // } // Block ends with call to 0x2ef2, returns to 0x2892 label_2892: // Incoming return from call to 0x2EF2 at 0x2891 // Inputs[5] // { // @2893 stack[-2] // @2893 stack[-1] // @2894 stack[-3] // @2898 stack[-11] // @289C memory[stack[-11]:stack[-11] + 0x20] // } 2892 5B JUMPDEST 2893 03 SUB 2894 90 SWAP1 2895 50 POP 2896 60 PUSH1 0x00 2898 89 DUP10 2899 60 PUSH1 0x00 289B 81 DUP2 289C 51 MLOAD 289D 81 DUP2 289E 10 LT 289F 61 PUSH2 0x28a4 28A2 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @2894 stack[-3] = stack[-1] - stack[-2] // @2896 stack[-2] = 0x00 // @2898 stack[-1] = stack[-11] // @2899 stack[0] = 0x00 // } // Block ends with conditional jump to 0x28a4, if 0x00 < memory[stack[-11]:stack[-11] + 0x20] label_28A3: // Incoming jump from 0x28A2, if not 0x00 < memory[stack[-11]:stack[-11] + 0x20] 28A3 FE *ASSERT // Stack delta = +0 // Outputs[1] { @28A3 assert(); } // Block terminates label_28A4: // Incoming jump from 0x28A2, if 0x00 < memory[stack[-11]:stack[-11] + 0x20] // Inputs[3] // { // @28A7 stack[-1] // @28AB stack[-2] // @28AC memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 28A4 5B JUMPDEST 28A5 60 PUSH1 0x20 28A7 02 MUL 28A8 60 PUSH1 0x20 28AA 01 ADD 28AB 01 ADD 28AC 51 MLOAD 28AD 61 PUSH2 0x28f4 28B0 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x28f4, if memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_28B1: // Incoming jump from 0x28B0, if not memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[4] // { // @28B4 stack[-5] // @28B7 stack[-3] // @28BA stack[-6] // @28BE memory[stack[-6]:stack[-6] + 0x20] // } 28B1 61 PUSH2 0x28ef 28B4 85 DUP6 28B5 60 PUSH1 0x01 28B7 85 DUP6 28B8 03 SUB 28B9 02 MUL 28BA 87 DUP8 28BB 60 PUSH1 0x00 28BD 81 DUP2 28BE 51 MLOAD 28BF 81 DUP2 28C0 10 LT 28C1 61 PUSH2 0x28c6 28C4 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @28B1 stack[0] = 0x28ef // @28B9 stack[1] = stack[-3] - 0x01 * stack[-5] // @28BA stack[2] = stack[-6] // @28BB stack[3] = 0x00 // } // Block ends with conditional call to 0x28c6, returns to 0x28EF, if 0x00 < memory[stack[-6]:stack[-6] + 0x20] label_28C5: // Incoming jump from 0x28C4, if not 0x00 < memory[stack[-6]:stack[-6] + 0x20] 28C5 FE *ASSERT // Stack delta = +0 // Outputs[1] { @28C5 assert(); } // Block terminates label_28C6: // Incoming call from 0x28C4, returns to 0x28EF, if 0x00 < memory[stack[-6]:stack[-6] + 0x20] // Inputs[4] // { // @28C9 stack[-1] // @28CD stack[-2] // @28CE memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @28D2 memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // } 28C6 5B JUMPDEST 28C7 60 PUSH1 0x20 28C9 02 MUL 28CA 60 PUSH1 0x20 28CC 01 ADD 28CD 01 ADD 28CE 51 MLOAD 28CF 60 PUSH1 0x00 28D1 81 DUP2 28D2 51 MLOAD 28D3 81 DUP2 28D4 10 LT 28D5 61 PUSH2 0x28da 28D8 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @28CE stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @28CF stack[-1] = 0x00 // } // Block ends with conditional jump to 0x28da, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] label_28D9: // Incoming jump from 0x28D8, if not 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] 28D9 FE *ASSERT // Stack delta = +0 // Outputs[1] { @28D9 assert(); } // Block terminates label_28DA: // Incoming jump from 0x28D8, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // Inputs[5] // { // @28DD stack[-1] // @28E1 stack[-2] // @28E2 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @28E3 stack[-10] // @28E7 memory[stack[-10]:stack[-10] + 0x20] // } 28DA 5B JUMPDEST 28DB 60 PUSH1 0x20 28DD 02 MUL 28DE 60 PUSH1 0x20 28E0 01 ADD 28E1 01 ADD 28E2 51 MLOAD 28E3 88 DUP9 28E4 60 PUSH1 0x01 28E6 81 DUP2 28E7 51 MLOAD 28E8 81 DUP2 28E9 10 LT 28EA 61 PUSH2 0x0cc5 28ED 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @28E2 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @28E3 stack[-1] = stack[-10] // @28E4 stack[0] = 0x01 // } // Block ends with conditional jump to 0x0cc5, if 0x01 < memory[stack[-10]:stack[-10] + 0x20] label_28EE: // Incoming jump from 0x28ED, if not 0x01 < memory[stack[-10]:stack[-10] + 0x20] 28EE FE *ASSERT // Stack delta = +0 // Outputs[1] { @28EE assert(); } // Block terminates label_28EF: // Incoming return from call to 0x28C6 at 0x28C4 28EF 5B JUMPDEST 28F0 61 PUSH2 0x2933 28F3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2933 label_28F4: // Incoming jump from 0x28B0, if memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[4] // { // @28F8 stack[-5] // @28FB stack[-3] // @28FE stack[-6] // @2902 memory[stack[-6]:stack[-6] + 0x20] // } 28F4 5B JUMPDEST 28F5 61 PUSH2 0x2933 28F8 85 DUP6 28F9 60 PUSH1 0x01 28FB 85 DUP6 28FC 03 SUB 28FD 02 MUL 28FE 87 DUP8 28FF 60 PUSH1 0x01 2901 81 DUP2 2902 51 MLOAD 2903 81 DUP2 2904 10 LT 2905 61 PUSH2 0x290a 2908 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @28F5 stack[0] = 0x2933 // @28FD stack[1] = stack[-3] - 0x01 * stack[-5] // @28FE stack[2] = stack[-6] // @28FF stack[3] = 0x01 // } // Block ends with conditional call to 0x290a, returns to 0x2933, if 0x01 < memory[stack[-6]:stack[-6] + 0x20] label_2909: // Incoming jump from 0x2908, if not 0x01 < memory[stack[-6]:stack[-6] + 0x20] 2909 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2909 assert(); } // Block terminates label_290A: // Incoming call from 0x2908, returns to 0x2933, if 0x01 < memory[stack[-6]:stack[-6] + 0x20] // Inputs[4] // { // @290D stack[-1] // @2911 stack[-2] // @2912 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2916 memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // } 290A 5B JUMPDEST 290B 60 PUSH1 0x20 290D 02 MUL 290E 60 PUSH1 0x20 2910 01 ADD 2911 01 ADD 2912 51 MLOAD 2913 60 PUSH1 0x00 2915 81 DUP2 2916 51 MLOAD 2917 81 DUP2 2918 10 LT 2919 61 PUSH2 0x291e 291C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2912 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2913 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x291e, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] label_291D: // Incoming jump from 0x291C, if not 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] 291D FE *ASSERT // Stack delta = +0 // Outputs[1] { @291D assert(); } // Block terminates label_291E: // Incoming jump from 0x291C, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // Inputs[5] // { // @2921 stack[-1] // @2925 stack[-2] // @2926 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2927 stack[-10] // @292B memory[stack[-10]:stack[-10] + 0x20] // } 291E 5B JUMPDEST 291F 60 PUSH1 0x20 2921 02 MUL 2922 60 PUSH1 0x20 2924 01 ADD 2925 01 ADD 2926 51 MLOAD 2927 88 DUP9 2928 60 PUSH1 0x00 292A 81 DUP2 292B 51 MLOAD 292C 81 DUP2 292D 10 LT 292E 61 PUSH2 0x0cc5 2931 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2926 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2927 stack[-1] = stack[-10] // @2928 stack[0] = 0x00 // } // Block ends with conditional jump to 0x0cc5, if 0x00 < memory[stack[-10]:stack[-10] + 0x20] label_2932: // Incoming jump from 0x2931, if not 0x00 < memory[stack[-10]:stack[-10] + 0x20] 2932 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2932 assert(); } // Block terminates label_2933: // Incoming return from call to 0x290A at 0x2908 // Incoming jump from 0x28F3 // Inputs[5] // { // @2937 stack[-6] // @293A stack[-4] // @293D stack[-12] // @293E stack[-11] // @293F stack[-7] // } 2933 5B JUMPDEST 2934 61 PUSH2 0x2944 2937 86 DUP7 2938 60 PUSH1 0x01 293A 86 DUP7 293B 03 SUB 293C 02 MUL 293D 8D DUP14 293E 8D DUP14 293F 8A DUP11 2940 61 PUSH2 0x2ef2 2943 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2934 stack[0] = 0x2944 // @293C stack[1] = stack[-4] - 0x01 * stack[-6] // @293D stack[2] = stack[-12] // @293E stack[3] = stack[-11] // @293F stack[4] = stack[-7] // } // Block ends with call to 0x2ef2, returns to 0x2944 label_2944: // Incoming return from call to 0x2EF2 at 0x2943 // Inputs[5] // { // @2945 stack[-1] // @2945 stack[-2] // @2946 stack[-3] // @294A stack[-12] // @294E memory[stack[-12]:stack[-12] + 0x20] // } 2944 5B JUMPDEST 2945 03 SUB 2946 90 SWAP1 2947 50 POP 2948 60 PUSH1 0x00 294A 8A DUP11 294B 60 PUSH1 0x00 294D 81 DUP2 294E 51 MLOAD 294F 81 DUP2 2950 10 LT 2951 61 PUSH2 0x2956 2954 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @2946 stack[-3] = stack[-1] - stack[-2] // @2948 stack[-2] = 0x00 // @294A stack[-1] = stack[-12] // @294B stack[0] = 0x00 // } // Block ends with conditional jump to 0x2956, if 0x00 < memory[stack[-12]:stack[-12] + 0x20] label_2955: // Incoming jump from 0x2954, if not 0x00 < memory[stack[-12]:stack[-12] + 0x20] 2955 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2955 assert(); } // Block terminates label_2956: // Incoming jump from 0x2954, if 0x00 < memory[stack[-12]:stack[-12] + 0x20] // Inputs[3] // { // @2959 stack[-1] // @295D stack[-2] // @295E memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 2956 5B JUMPDEST 2957 60 PUSH1 0x20 2959 02 MUL 295A 60 PUSH1 0x20 295C 01 ADD 295D 01 ADD 295E 51 MLOAD 295F 61 PUSH2 0x29a6 2962 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x29a6, if memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_2963: // Incoming jump from 0x2962, if not memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[4] // { // @2966 stack[-6] // @2967 stack[-4] // @296C stack[-7] // @2970 memory[stack[-7]:stack[-7] + 0x20] // } 2963 61 PUSH2 0x29a1 2966 86 DUP7 2967 85 DUP6 2968 60 PUSH1 0x01 296A 01 ADD 296B 02 MUL 296C 88 DUP9 296D 60 PUSH1 0x00 296F 81 DUP2 2970 51 MLOAD 2971 81 DUP2 2972 10 LT 2973 61 PUSH2 0x2978 2976 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2963 stack[0] = 0x29a1 // @296B stack[1] = (0x01 + stack[-4]) * stack[-6] // @296C stack[2] = stack[-7] // @296D stack[3] = 0x00 // } // Block ends with conditional call to 0x2978, returns to 0x29A1, if 0x00 < memory[stack[-7]:stack[-7] + 0x20] label_2977: // Incoming jump from 0x2976, if not 0x00 < memory[stack[-7]:stack[-7] + 0x20] 2977 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2977 assert(); } // Block terminates label_2978: // Incoming call from 0x2976, returns to 0x29A1, if 0x00 < memory[stack[-7]:stack[-7] + 0x20] // Inputs[4] // { // @297B stack[-1] // @297F stack[-2] // @2980 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2984 memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // } 2978 5B JUMPDEST 2979 60 PUSH1 0x20 297B 02 MUL 297C 60 PUSH1 0x20 297E 01 ADD 297F 01 ADD 2980 51 MLOAD 2981 60 PUSH1 0x00 2983 81 DUP2 2984 51 MLOAD 2985 81 DUP2 2986 10 LT 2987 61 PUSH2 0x298c 298A 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2980 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2981 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x298c, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] label_298B: // Incoming jump from 0x298A, if not 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] 298B FE *ASSERT // Stack delta = +0 // Outputs[1] { @298B assert(); } // Block terminates label_298C: // Incoming jump from 0x298A, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // Inputs[5] // { // @298F stack[-1] // @2993 stack[-2] // @2994 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2995 stack[-11] // @2999 memory[stack[-11]:stack[-11] + 0x20] // } 298C 5B JUMPDEST 298D 60 PUSH1 0x20 298F 02 MUL 2990 60 PUSH1 0x20 2992 01 ADD 2993 01 ADD 2994 51 MLOAD 2995 89 DUP10 2996 60 PUSH1 0x01 2998 81 DUP2 2999 51 MLOAD 299A 81 DUP2 299B 10 LT 299C 61 PUSH2 0x0cc5 299F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2994 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2995 stack[-1] = stack[-11] // @2996 stack[0] = 0x01 // } // Block ends with conditional jump to 0x0cc5, if 0x01 < memory[stack[-11]:stack[-11] + 0x20] label_29A0: // Incoming jump from 0x299F, if not 0x01 < memory[stack[-11]:stack[-11] + 0x20] 29A0 FE *ASSERT // Stack delta = +0 // Outputs[1] { @29A0 assert(); } // Block terminates label_29A1: // Incoming return from call to 0x2978 at 0x2976 29A1 5B JUMPDEST 29A2 61 PUSH2 0x29e5 29A5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x29e5 label_29A6: // Incoming jump from 0x2962, if memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[4] // { // @29AA stack[-6] // @29AB stack[-4] // @29B0 stack[-7] // @29B4 memory[stack[-7]:stack[-7] + 0x20] // } 29A6 5B JUMPDEST 29A7 61 PUSH2 0x29e5 29AA 86 DUP7 29AB 85 DUP6 29AC 60 PUSH1 0x01 29AE 01 ADD 29AF 02 MUL 29B0 88 DUP9 29B1 60 PUSH1 0x01 29B3 81 DUP2 29B4 51 MLOAD 29B5 81 DUP2 29B6 10 LT 29B7 61 PUSH2 0x29bc 29BA 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @29A7 stack[0] = 0x29e5 // @29AF stack[1] = (0x01 + stack[-4]) * stack[-6] // @29B0 stack[2] = stack[-7] // @29B1 stack[3] = 0x01 // } // Block ends with conditional call to 0x29bc, returns to 0x29E5, if 0x01 < memory[stack[-7]:stack[-7] + 0x20] label_29BB: // Incoming jump from 0x29BA, if not 0x01 < memory[stack[-7]:stack[-7] + 0x20] 29BB FE *ASSERT // Stack delta = +0 // Outputs[1] { @29BB assert(); } // Block terminates label_29BC: // Incoming call from 0x29BA, returns to 0x29E5, if 0x01 < memory[stack[-7]:stack[-7] + 0x20] // Inputs[4] // { // @29BF stack[-1] // @29C3 stack[-2] // @29C4 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @29C8 memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // } 29BC 5B JUMPDEST 29BD 60 PUSH1 0x20 29BF 02 MUL 29C0 60 PUSH1 0x20 29C2 01 ADD 29C3 01 ADD 29C4 51 MLOAD 29C5 60 PUSH1 0x00 29C7 81 DUP2 29C8 51 MLOAD 29C9 81 DUP2 29CA 10 LT 29CB 61 PUSH2 0x29d0 29CE 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @29C4 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @29C5 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x29d0, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] label_29CF: // Incoming jump from 0x29CE, if not 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] 29CF FE *ASSERT // Stack delta = +0 // Outputs[1] { @29CF assert(); } // Block terminates label_29D0: // Incoming jump from 0x29CE, if 0x00 < memory[memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]:memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] + 0x20] // Inputs[5] // { // @29D3 stack[-1] // @29D7 stack[-2] // @29D8 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @29D9 stack[-11] // @29DD memory[stack[-11]:stack[-11] + 0x20] // } 29D0 5B JUMPDEST 29D1 60 PUSH1 0x20 29D3 02 MUL 29D4 60 PUSH1 0x20 29D6 01 ADD 29D7 01 ADD 29D8 51 MLOAD 29D9 89 DUP10 29DA 60 PUSH1 0x00 29DC 81 DUP2 29DD 51 MLOAD 29DE 81 DUP2 29DF 10 LT 29E0 61 PUSH2 0x0cc5 29E3 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @29D8 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @29D9 stack[-1] = stack[-11] // @29DA stack[0] = 0x00 // } // Block ends with conditional jump to 0x0cc5, if 0x00 < memory[stack[-11]:stack[-11] + 0x20] label_29E4: // Incoming jump from 0x29E3, if not 0x00 < memory[stack[-11]:stack[-11] + 0x20] 29E4 FE *ASSERT // Stack delta = +0 // Outputs[1] { @29E4 assert(); } // Block terminates label_29E5: // Incoming jump from 0x29A5 // Incoming return from call to 0x29BC at 0x29BA // Inputs[5] // { // @29E9 stack[-7] // @29EA stack[-5] // @29EF stack[-13] // @29F0 stack[-12] // @29F1 stack[-8] // } 29E5 5B JUMPDEST 29E6 61 PUSH2 0x29f6 29E9 87 DUP8 29EA 86 DUP7 29EB 60 PUSH1 0x01 29ED 01 ADD 29EE 02 MUL 29EF 8E DUP15 29F0 8E DUP15 29F1 8B DUP12 29F2 61 PUSH2 0x2ef2 29F5 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @29E6 stack[0] = 0x29f6 // @29EE stack[1] = (0x01 + stack[-5]) * stack[-7] // @29EF stack[2] = stack[-13] // @29F0 stack[3] = stack[-12] // @29F1 stack[4] = stack[-8] // } // Block ends with call to 0x2ef2, returns to 0x29F6 label_29F6: // Incoming return from call to 0x2EF2 at 0x29F5 // Inputs[4] // { // @29F7 stack[-2] // @29F7 stack[-1] // @29F8 stack[-3] // @29FA stack[-5] // } 29F6 5B JUMPDEST 29F7 03 SUB 29F8 90 SWAP1 29F9 50 POP 29FA 82 DUP3 29FB 81 DUP2 29FC 13 SGT 29FD 15 ISZERO 29FE 61 PUSH2 0x2a1f 2A01 57 *JUMPI // Stack delta = -2 // Outputs[1] { @29F8 stack[-3] = stack[-1] - stack[-2] } // Block ends with conditional jump to 0x2a1f, if !(stack[-1] - stack[-2] i> stack[-5]) label_2A02: // Incoming jump from 0x2A01, if not !(stack[-1] - stack[-2] i> stack[-5]) // Inputs[3] // { // @2A02 stack[-4] // @2A06 stack[-5] // @2A0A memory[stack[-5]:stack[-5] + 0x20] // } 2A02 83 DUP4 2A03 60 PUSH1 0x01 2A05 01 ADD 2A06 85 DUP6 2A07 60 PUSH1 0x00 2A09 81 DUP2 2A0A 51 MLOAD 2A0B 81 DUP2 2A0C 10 LT 2A0D 61 PUSH2 0x2a12 2A10 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2A05 stack[0] = 0x01 + stack[-4] // @2A06 stack[1] = stack[-5] // @2A07 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2a12, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] label_2A11: // Incoming jump from 0x2A10, if not 0x00 < memory[stack[-5]:stack[-5] + 0x20] 2A11 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2A11 assert(); } // Block terminates label_2A12: // Incoming jump from 0x2A10, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] // Inputs[3] // { // @2A15 stack[-1] // @2A19 stack[-2] // @2A1A stack[-3] // } 2A12 5B JUMPDEST 2A13 60 PUSH1 0x20 2A15 02 MUL 2A16 60 PUSH1 0x20 2A18 01 ADD 2A19 01 ADD 2A1A 81 DUP2 2A1B 81 DUP2 2A1C 52 MSTORE 2A1D 50 POP 2A1E 50 POP // Stack delta = -3 // Outputs[1] { @2A1C memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] } // Block continues label_2A1F: // Incoming jump from 0x2A1E // Incoming jump from 0x2A01, if !(stack[-1] - stack[-2] i> stack[-5]) // Inputs[2] // { // @2A20 stack[-3] // @2A21 stack[-2] // } 2A1F 5B JUMPDEST 2A20 82 DUP3 2A21 82 DUP3 2A22 13 SGT 2A23 15 ISZERO 2A24 61 PUSH2 0x2a45 2A27 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2a45, if !(stack[-2] i> stack[-3]) label_2A28: // Incoming jump from 0x2A27, if not !(stack[-2] i> stack[-3]) // Inputs[3] // { // @2A2A stack[-4] // @2A2C stack[-5] // @2A30 memory[stack[-5]:stack[-5] + 0x20] // } 2A28 60 PUSH1 0x01 2A2A 84 DUP5 2A2B 03 SUB 2A2C 85 DUP6 2A2D 60 PUSH1 0x01 2A2F 81 DUP2 2A30 51 MLOAD 2A31 81 DUP2 2A32 10 LT 2A33 61 PUSH2 0x2a38 2A36 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2A2B stack[0] = stack[-4] - 0x01 // @2A2C stack[1] = stack[-5] // @2A2D stack[2] = 0x01 // } // Block ends with conditional jump to 0x2a38, if 0x01 < memory[stack[-5]:stack[-5] + 0x20] label_2A37: // Incoming jump from 0x2A36, if not 0x01 < memory[stack[-5]:stack[-5] + 0x20] 2A37 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2A37 assert(); } // Block terminates label_2A38: // Incoming jump from 0x2A36, if 0x01 < memory[stack[-5]:stack[-5] + 0x20] // Inputs[3] // { // @2A3B stack[-1] // @2A3F stack[-2] // @2A40 stack[-3] // } 2A38 5B JUMPDEST 2A39 60 PUSH1 0x20 2A3B 02 MUL 2A3C 60 PUSH1 0x20 2A3E 01 ADD 2A3F 01 ADD 2A40 81 DUP2 2A41 81 DUP2 2A42 52 MSTORE 2A43 50 POP 2A44 50 POP // Stack delta = -3 // Outputs[1] { @2A42 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] } // Block continues label_2A45: // Incoming jump from 0x2A44 // Incoming jump from 0x2A27, if !(stack[-2] i> stack[-3]) // Inputs[2] // { // @2A46 stack[-1] // @2A47 stack[-3] // } 2A45 5B JUMPDEST 2A46 80 DUP1 2A47 83 DUP4 2A48 13 SGT 2A49 80 DUP1 2A4A 15 ISZERO 2A4B 61 PUSH2 0x2a53 2A4E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A48 stack[0] = stack[-3] i> stack[-1] } // Block ends with conditional jump to 0x2a53, if !(stack[-3] i> stack[-1]) label_2A4F: // Incoming jump from 0x2A4E, if not !(stack[-3] i> stack[-1]) // Inputs[2] // { // @2A50 stack[-3] // @2A51 stack[-4] // } 2A4F 50 POP 2A50 81 DUP2 2A51 83 DUP4 2A52 13 SGT 2A53 5B JUMPDEST 2A54 15 ISZERO 2A55 61 PUSH2 0x2a79 2A58 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2a79, if !(stack[-4] i> stack[-3]) label_2A59: // Incoming jump from 0x2A58, if not !stack[-1] // Incoming jump from 0x2A58, if not !(stack[-4] i> stack[-3]) // Inputs[8] // { // @2A59 stack[-3] // @2A5A stack[-8] // @2A5C stack[-6] // @2A5D stack[-4] // @2A5F stack[-10] // @2A67 stack[-12] // @2A68 stack[-11] // @2A69 stack[-7] // } 2A59 82 DUP3 2A5A 97 SWAP8 2A5B 50 POP 2A5C 85 DUP6 2A5D 84 DUP5 2A5E 02 MUL 2A5F 99 SWAP10 2A60 50 POP 2A61 61 PUSH2 0x2a6e 2A64 86 DUP7 2A65 85 DUP6 2A66 02 MUL 2A67 8D DUP14 2A68 8D DUP14 2A69 8A DUP11 2A6A 61 PUSH2 0x1edb 2A6D 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @2A5A stack[-8] = stack[-3] // @2A5F stack[-10] = stack[-4] * stack[-6] // @2A61 stack[0] = 0x2a6e // @2A66 stack[1] = stack[-4] * stack[-6] // @2A67 stack[2] = stack[-12] // @2A68 stack[3] = stack[-11] // @2A69 stack[4] = stack[-7] // } // Block ends with call to 0x1edb, returns to 0x2A6E label_2A6E: // Incoming return from call to 0x1EDB at 0x2A6D // Inputs[2] // { // @2A6F stack[-10] // @2A6F stack[-1] // } 2A6E 5B JUMPDEST 2A6F 98 SWAP9 2A70 50 POP 2A71 50 POP 2A72 50 POP 2A73 50 POP 2A74 50 POP 2A75 61 PUSH2 0x2a82 2A78 56 *JUMP // Stack delta = -5 // Outputs[1] { @2A6F stack[-10] = stack[-1] } // Block ends with unconditional jump to 0x2a82 label_2A79: // Incoming jump from 0x2A58, if !stack[-1] // Incoming jump from 0x2A58, if !(stack[-4] i> stack[-3]) 2A79 5B JUMPDEST 2A7A 50 POP 2A7B 50 POP 2A7C 50 POP 2A7D 50 POP 2A7E 61 PUSH2 0x2774 2A81 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to 0x2774 label_2A82: // Incoming jump from 0x2779, if stack[-9] // Incoming jump from 0x2779, if stack[-6] // Incoming jump from 0x27EB // Incoming jump from 0x2A78 // Inputs[7] // { // @2A86 stack[-4] // @2A86 stack[-8] // @2A88 stack[-9] // @2A88 stack[-5] // @2A8A stack[-6] // @2A8A stack[-10] // @2A8B stack[-7] // } 2A82 5B JUMPDEST 2A83 50 POP 2A84 50 POP 2A85 50 POP 2A86 93 SWAP4 2A87 50 POP 2A88 93 SWAP4 2A89 50 POP 2A8A 93 SWAP4 2A8B 90 SWAP1 2A8C 50 POP 2A8D 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @2A86 stack[-8] = stack[-4] // @2A88 stack[-9] = stack[-5] // @2A8A stack[-10] = stack[-6] // } // Block ends with unconditional jump to stack[-10] label_2A8E: // Incoming call from 0x0EBD, returns to 0x0EBE // Inputs[5] // { // @2A91 memory[0x40:0x60] // @2A9A stack[-2] // @2A9D stack[-1] // @2AAE address(stack[-2] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @2AAE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // } 2A8E 5B JUMPDEST 2A8F 60 PUSH1 0x40 2A91 51 MLOAD 2A92 60 PUSH1 0x01 2A94 60 PUSH1 0x01 2A96 60 PUSH1 0xa0 2A98 1B SHL 2A99 03 SUB 2A9A 83 DUP4 2A9B 16 AND 2A9C 90 SWAP1 2A9D 82 DUP3 2A9E 15 ISZERO 2A9F 61 PUSH2 0x08fc 2AA2 02 MUL 2AA3 90 SWAP1 2AA4 83 DUP4 2AA5 90 SWAP1 2AA6 60 PUSH1 0x00 2AA8 81 DUP2 2AA9 81 DUP2 2AAA 81 DUP2 2AAB 85 DUP6 2AAC 88 DUP9 2AAD 88 DUP9 2AAE F1 CALL 2AAF 93 SWAP4 2AB0 50 POP 2AB1 50 POP 2AB2 50 POP 2AB3 50 POP 2AB4 15 ISZERO 2AB5 80 DUP1 2AB6 15 ISZERO 2AB7 61 PUSH2 0x2ac4 2ABA 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @2AAE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-2] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @2AB4 stack[0] = !address(stack[-2] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } // Block ends with conditional jump to 0x2ac4, if !!address(stack[-2] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_2ABB: // Incoming jump from 0x2ABA, if not !!address(stack[-2] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[4] // { // @2ABB returndata.length // @2ABF returndata[0x00:0x00 + returndata.length] // @2AC0 returndata.length // @2AC3 memory[0x00:0x00 + returndata.length] // } 2ABB 3D RETURNDATASIZE 2ABC 60 PUSH1 0x00 2ABE 80 DUP1 2ABF 3E RETURNDATACOPY 2AC0 3D RETURNDATASIZE 2AC1 60 PUSH1 0x00 2AC3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2ABF memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2AC3 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2AC4: // Incoming jump from 0x2ABA, if !!address(stack[-2] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[1] { @2AC8 stack[-4] } 2AC4 5B JUMPDEST 2AC5 50 POP 2AC6 50 POP 2AC7 50 POP 2AC8 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_2AC9: // Incoming call from 0x1997, returns to 0x0E97 // Incoming jump from 0x1446 // Incoming jump from 0x197F // Inputs[8] // { // @2ACD memory[0x40:0x60] // @2AD6 stack[-2] // @2AE3 stack[-1] // @2AE7 memory[0x40:0x60] // @2AFC memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @2B12 memory[0x40:0x60] // @2B14 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2B1C stack[-3] // } 2AC9 5B JUMPDEST 2ACA 60 PUSH1 0x40 2ACC 80 DUP1 2ACD 51 MLOAD 2ACE 60 PUSH1 0x01 2AD0 60 PUSH1 0x01 2AD2 60 PUSH1 0xa0 2AD4 1B SHL 2AD5 03 SUB 2AD6 84 DUP5 2AD7 81 DUP2 2AD8 16 AND 2AD9 60 PUSH1 0x24 2ADB 83 DUP4 2ADC 01 ADD 2ADD 52 MSTORE 2ADE 60 PUSH1 0x44 2AE0 80 DUP1 2AE1 83 DUP4 2AE2 01 ADD 2AE3 85 DUP6 2AE4 90 SWAP1 2AE5 52 MSTORE 2AE6 83 DUP4 2AE7 51 MLOAD 2AE8 80 DUP1 2AE9 84 DUP5 2AEA 03 SUB 2AEB 90 SWAP1 2AEC 91 SWAP2 2AED 01 ADD 2AEE 81 DUP2 2AEF 52 MSTORE 2AF0 60 PUSH1 0x64 2AF2 90 SWAP1 2AF3 92 SWAP3 2AF4 01 ADD 2AF5 83 DUP4 2AF6 52 MSTORE 2AF7 60 PUSH1 0x20 2AF9 82 DUP3 2AFA 01 ADD 2AFB 80 DUP1 2AFC 51 MLOAD 2AFD 60 PUSH1 0x01 2AFF 60 PUSH1 0x01 2B01 60 PUSH1 0xe0 2B03 1B SHL 2B04 03 SUB 2B05 16 AND 2B06 63 PUSH4 0xa9059cbb 2B0B 60 PUSH1 0xe0 2B0D 1B SHL 2B0E 17 OR 2B0F 81 DUP2 2B10 52 MSTORE 2B11 92 SWAP3 2B12 51 MLOAD 2B13 82 DUP3 2B14 51 MLOAD 2B15 60 PUSH1 0x00 2B17 94 SWAP5 2B18 60 PUSH1 0x60 2B1A 94 SWAP5 2B1B 93 SWAP4 2B1C 89 DUP10 2B1D 16 AND 2B1E 93 SWAP4 2B1F 92 SWAP3 2B20 91 SWAP2 2B21 82 DUP3 2B22 91 SWAP2 2B23 90 SWAP1 2B24 80 DUP1 2B25 83 DUP4 2B26 83 DUP4 2B27 5B JUMPDEST 2B28 60 PUSH1 0x20 2B2A 83 DUP4 2B2B 10 LT 2B2C 61 PUSH2 0x2b46 2B2F 57 *JUMPI // Stack delta = +11 // Outputs[16] // { // @2ADD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @2AE5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-1] // @2AEF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x44 + (memory[0x40:0x60] - memory[0x40:0x60]) // @2AF6 memory[0x40:0x60] = memory[0x40:0x60] + 0x64 // @2B10 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0xa9059cbb << 0xe0) | ((0x01 << 0xe0) - 0x01 & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]) // @2B17 stack[0] = 0x00 // @2B1A stack[1] = 0x60 // @2B1E stack[2] = stack[-3] & (0x01 << 0xa0) - 0x01 // @2B1F stack[3] = memory[0x40:0x60] // @2B20 stack[4] = memory[0x40:0x60] // @2B22 stack[5] = memory[0x40:0x60] // @2B23 stack[6] = memory[0x40:0x60] + 0x20 // @2B23 stack[7] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2B24 stack[8] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2B25 stack[9] = memory[0x40:0x60] // @2B26 stack[10] = memory[0x40:0x60] + 0x20 // } // Block ends with conditional jump to 0x2b46, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 label_2B30: // Incoming jump from 0x2B2F, if not stack[-3] < 0x20 // Incoming jump from 0x2B2F, if not memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[4] // { // @2B30 stack[-1] // @2B31 memory[stack[-1]:stack[-1] + 0x20] // @2B32 stack[-2] // @2B38 stack[-3] // } 2B30 80 DUP1 2B31 51 MLOAD 2B32 82 DUP3 2B33 52 MSTORE 2B34 60 PUSH1 0x1f 2B36 19 NOT 2B37 90 SWAP1 2B38 92 SWAP3 2B39 01 ADD 2B3A 91 SWAP2 2B3B 60 PUSH1 0x20 2B3D 91 SWAP2 2B3E 82 DUP3 2B3F 01 ADD 2B40 91 SWAP2 2B41 01 ADD 2B42 61 PUSH2 0x2b27 2B45 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2B33 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @2B3A stack[-3] = stack[-3] + ~0x1f // @2B40 stack[-2] = 0x20 + stack[-2] // @2B41 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x2b27 label_2B46: // Incoming jump from 0x2B2F, if stack[-3] < 0x20 // Incoming jump from 0x2B2F, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[15] // { // @2B49 stack[-3] // @2B54 stack[-1] // @2B55 memory[stack[-1]:stack[-1] + 0x20] // @2B58 stack[-2] // @2B59 memory[stack[-2]:stack[-2] + 0x20] // @2B66 stack[-4] // @2B66 stack[-5] // @2B68 stack[-6] // @2B69 stack[-8] // @2B70 memory[0x40:0x60] // @2B77 stack[-9] // @2B78 msg.gas // @2B79 memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]] // @2B79 address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @2B7D returndata.length // } 2B46 5B JUMPDEST 2B47 60 PUSH1 0x01 2B49 83 DUP4 2B4A 60 PUSH1 0x20 2B4C 03 SUB 2B4D 61 PUSH2 0x0100 2B50 0A EXP 2B51 03 SUB 2B52 80 DUP1 2B53 19 NOT 2B54 82 DUP3 2B55 51 MLOAD 2B56 16 AND 2B57 81 DUP2 2B58 84 DUP5 2B59 51 MLOAD 2B5A 16 AND 2B5B 80 DUP1 2B5C 82 DUP3 2B5D 17 OR 2B5E 85 DUP6 2B5F 52 MSTORE 2B60 50 POP 2B61 50 POP 2B62 50 POP 2B63 50 POP 2B64 50 POP 2B65 50 POP 2B66 90 SWAP1 2B67 50 POP 2B68 01 ADD 2B69 91 SWAP2 2B6A 50 POP 2B6B 50 POP 2B6C 60 PUSH1 0x00 2B6E 60 PUSH1 0x40 2B70 51 MLOAD 2B71 80 DUP1 2B72 83 DUP4 2B73 03 SUB 2B74 81 DUP2 2B75 60 PUSH1 0x00 2B77 86 DUP7 2B78 5A GAS 2B79 F1 CALL 2B7A 91 SWAP2 2B7B 50 POP 2B7C 50 POP 2B7D 3D RETURNDATASIZE 2B7E 80 DUP1 2B7F 60 PUSH1 0x00 2B81 81 DUP2 2B82 14 EQ 2B83 61 PUSH2 0x2ba8 2B86 57 *JUMPI // Stack delta = -6 // Outputs[5] // { // @2B5F memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @2B79 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @2B7A stack[-9] = address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @2B7D stack[-8] = returndata.length // @2B7E stack[-7] = returndata.length // } // Block ends with conditional jump to 0x2ba8, if returndata.length == 0x00 label_2B87: // Incoming jump from 0x2B86, if not returndata.length == 0x00 // Inputs[6] // { // @2B89 memory[0x40:0x60] // @2B8A stack[-2] // @2B91 returndata.length // @2B99 returndata.length // @2B9C returndata.length // @2BA3 returndata[0x00:0x00 + returndata.length] // } 2B87 60 PUSH1 0x40 2B89 51 MLOAD 2B8A 91 SWAP2 2B8B 50 POP 2B8C 60 PUSH1 0x1f 2B8E 19 NOT 2B8F 60 PUSH1 0x3f 2B91 3D RETURNDATASIZE 2B92 01 ADD 2B93 16 AND 2B94 82 DUP3 2B95 01 ADD 2B96 60 PUSH1 0x40 2B98 52 MSTORE 2B99 3D RETURNDATASIZE 2B9A 82 DUP3 2B9B 52 MSTORE 2B9C 3D RETURNDATASIZE 2B9D 60 PUSH1 0x00 2B9F 60 PUSH1 0x20 2BA1 84 DUP5 2BA2 01 ADD 2BA3 3E RETURNDATACOPY 2BA4 61 PUSH2 0x2bad 2BA7 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2B8A stack[-2] = memory[0x40:0x60] // @2B98 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @2B9B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @2BA3 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x2bad label_2BA8: // Incoming jump from 0x2B86, if returndata.length == 0x00 // Inputs[4] // { // @2BAB stack[-2] // @2BAF stack[-4] // @2BB1 stack[-3] // @2BB1 stack[-5] // } 2BA8 5B JUMPDEST 2BA9 60 PUSH1 0x60 2BAB 91 SWAP2 2BAC 50 POP 2BAD 5B JUMPDEST 2BAE 50 POP 2BAF 91 SWAP2 2BB0 50 POP 2BB1 91 SWAP2 2BB2 50 POP 2BB3 81 DUP2 2BB4 80 DUP1 2BB5 15 ISZERO 2BB6 61 PUSH2 0x2bdb 2BB9 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @2BAF stack[-4] = 0x60 // @2BB1 stack[-5] = stack[-3] // @2BB3 stack[-3] = stack[-3] // } // Block ends with conditional jump to 0x2bdb, if !stack[-3] label_2BBA: // Incoming jump from 0x2BB9, if not !stack[-3] // Incoming jump from 0x2BB9, if not !stack[-3] // Inputs[2] // { // @2BBB stack[-2] // @2BBC memory[stack[-2]:stack[-2] + 0x20] // } 2BBA 50 POP 2BBB 80 DUP1 2BBC 51 MLOAD 2BBD 15 ISZERO 2BBE 80 DUP1 2BBF 61 PUSH2 0x2bdb 2BC2 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2BBD stack[-1] = !memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2bdb, if !memory[stack[-2]:stack[-2] + 0x20] label_2BC3: // Incoming jump from 0x2BC2, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @2BC4 stack[-2] // @2BCA memory[stack[-2]:stack[-2] + 0x20] // } 2BC3 50 POP 2BC4 80 DUP1 2BC5 80 DUP1 2BC6 60 PUSH1 0x20 2BC8 01 ADD 2BC9 90 SWAP1 2BCA 51 MLOAD 2BCB 60 PUSH1 0x20 2BCD 81 DUP2 2BCE 10 LT 2BCF 15 ISZERO 2BD0 61 PUSH2 0x2bd8 2BD3 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @2BC9 stack[-1] = 0x20 + stack[-2] // @2BCA stack[0] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x2bd8, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) label_2BD4: // Incoming jump from 0x2BD3, if not !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[1] { @2BD7 memory[0x00:0x00] } 2BD4 60 PUSH1 0x00 2BD6 80 DUP1 2BD7 FD *REVERT // Stack delta = +0 // Outputs[1] { @2BD7 revert(memory[0x00:0x00]); } // Block terminates label_2BD8: // Incoming jump from 0x2BD3, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[2] // { // @2BDA stack[-2] // @2BDA memory[stack[-2]:stack[-2] + 0x20] // } 2BD8 5B JUMPDEST 2BD9 50 POP 2BDA 51 MLOAD // Stack delta = -1 // Outputs[1] { @2BDA stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block continues label_2BDB: // Incoming jump from 0x2BDA // Incoming jump from 0x2BB9, if !stack[-3] // Incoming jump from 0x2BC2, if !memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x2BB9, if !stack[-3] // Inputs[1] { @2BDF stack[-1] } 2BDB 5B JUMPDEST 2BDC 61 PUSH2 0x2c2c 2BDF 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2c2c, if stack[-1] label_2BE0: // Incoming jump from 0x2BDF, if not stack[-1] // Inputs[3] // { // @2BE3 memory[0x40:0x60] // @2C22 memory[0x40:0x60] // @2C2B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2BE0 60 PUSH1 0x40 2BE2 80 DUP1 2BE3 51 MLOAD 2BE4 62 PUSH3 0x461bcd 2BE8 60 PUSH1 0xe5 2BEA 1B SHL 2BEB 81 DUP2 2BEC 52 MSTORE 2BED 60 PUSH1 0x20 2BEF 60 PUSH1 0x04 2BF1 82 DUP3 2BF2 01 ADD 2BF3 52 MSTORE 2BF4 60 PUSH1 0x1c 2BF6 60 PUSH1 0x24 2BF8 82 DUP3 2BF9 01 ADD 2BFA 52 MSTORE 2BFB 7F PUSH32 0x4641204578656375746f723a205452414e534645525f4641494c454400000000 2C1C 60 PUSH1 0x44 2C1E 82 DUP3 2C1F 01 ADD 2C20 52 MSTORE 2C21 90 SWAP1 2C22 51 MLOAD 2C23 90 SWAP1 2C24 81 DUP2 2C25 90 SWAP1 2C26 03 SUB 2C27 60 PUSH1 0x64 2C29 01 ADD 2C2A 90 SWAP1 2C2B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2BEC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2BF3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2BFA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1c // @2C20 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4641204578656375746f723a205452414e534645525f4641494c454400000000 // @2C2B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2C2C: // Incoming jump from 0x2BDF, if stack[-1] // Inputs[1] { @2C32 stack[-6] } 2C2C 5B JUMPDEST 2C2D 50 POP 2C2E 50 POP 2C2F 50 POP 2C30 50 POP 2C31 50 POP 2C32 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_2C33: // Incoming jump from 0x1601 // Incoming jump from 0x1601 // Inputs[1] { @2C34 stack[-2] } 2C33 5B JUMPDEST 2C34 81 DUP2 2C35 15 ISZERO 2C36 61 PUSH2 0x2cbb 2C39 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2cbb, if !stack[-2] label_2C3A: // Incoming jump from 0x2C39, if not !stack[-2] // Inputs[6] // { // @2C3D memory[0x40:0x60] // @2C4C stack[-3] // @2C60 stack[-1] // @2C77 memory[0x40:0x60] // @2C79 stack[-4] // @2C92 address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // } 2C3A 60 PUSH1 0x40 2C3C 80 DUP1 2C3D 51 MLOAD 2C3E 63 PUSH4 0x022c0d9f 2C43 60 PUSH1 0xe0 2C45 1B SHL 2C46 81 DUP2 2C47 52 MSTORE 2C48 60 PUSH1 0x04 2C4A 81 DUP2 2C4B 01 ADD 2C4C 85 DUP6 2C4D 90 SWAP1 2C4E 52 MSTORE 2C4F 60 PUSH1 0x00 2C51 60 PUSH1 0x24 2C53 82 DUP3 2C54 01 ADD 2C55 81 DUP2 2C56 90 SWAP1 2C57 52 MSTORE 2C58 60 PUSH1 0x01 2C5A 60 PUSH1 0x01 2C5C 60 PUSH1 0xa0 2C5E 1B SHL 2C5F 03 SUB 2C60 84 DUP5 2C61 81 DUP2 2C62 16 AND 2C63 60 PUSH1 0x44 2C65 84 DUP5 2C66 01 ADD 2C67 52 MSTORE 2C68 60 PUSH1 0x80 2C6A 60 PUSH1 0x64 2C6C 84 DUP5 2C6D 01 ADD 2C6E 52 MSTORE 2C6F 60 PUSH1 0x84 2C71 83 DUP4 2C72 01 ADD 2C73 82 DUP3 2C74 90 SWAP1 2C75 52 MSTORE 2C76 92 SWAP3 2C77 51 MLOAD 2C78 92 SWAP3 2C79 87 DUP8 2C7A 16 AND 2C7B 92 SWAP3 2C7C 63 PUSH4 0x022c0d9f 2C81 92 SWAP3 2C82 60 PUSH1 0xc4 2C84 80 DUP1 2C85 82 DUP3 2C86 01 ADD 2C87 93 SWAP4 2C88 92 SWAP3 2C89 91 SWAP2 2C8A 82 DUP3 2C8B 90 SWAP1 2C8C 03 SUB 2C8D 01 ADD 2C8E 81 DUP2 2C8F 83 DUP4 2C90 87 DUP8 2C91 80 DUP1 2C92 3B EXTCODESIZE 2C93 15 ISZERO 2C94 80 DUP1 2C95 15 ISZERO 2C96 61 PUSH2 0x2c9e 2C99 57 *JUMPI // Stack delta = +10 // Outputs[16] // { // @2C47 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x022c0d9f << 0xe0 // @2C4E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-3] // @2C57 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x00 // @2C67 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @2C6E memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x80 // @2C75 memory[memory[0x40:0x60] + 0x84:memory[0x40:0x60] + 0x84 + 0x20] = 0x00 // @2C7B stack[0] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2C81 stack[1] = 0x022c0d9f // @2C87 stack[2] = memory[0x40:0x60] + 0xc4 // @2C88 stack[3] = 0x00 // @2C89 stack[4] = memory[0x40:0x60] // @2C8D stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0xc4 // @2C8E stack[6] = memory[0x40:0x60] // @2C8F stack[7] = 0x00 // @2C90 stack[8] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2C93 stack[9] = !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x2c9e, if !!address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length label_2C9A: // Incoming jump from 0x2C99, if not !!address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @2C9D memory[0x00:0x00] } 2C9A 60 PUSH1 0x00 2C9C 80 DUP1 2C9D FD *REVERT // Stack delta = +0 // Outputs[1] { @2C9D revert(memory[0x00:0x00]); } // Block terminates label_2C9E: // Incoming jump from 0x2C99, if !!address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @2CA0 msg.gas // @2CA1 stack[-4] // @2CA1 stack[-3] // @2CA1 stack[-2] // @2CA1 memory[stack[-4]:stack[-4] + stack[-5]] // @2CA1 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2CA1 stack[-6] // @2CA1 stack[-7] // @2CA1 stack[-5] // } 2C9E 5B JUMPDEST 2C9F 50 POP 2CA0 5A GAS 2CA1 F1 CALL 2CA2 15 ISZERO 2CA3 80 DUP1 2CA4 15 ISZERO 2CA5 61 PUSH2 0x2cb2 2CA8 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @2CA1 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2CA2 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 0x2cb2, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_2CA9: // Incoming jump from 0x2CA8, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @2CA9 returndata.length // @2CAD returndata[0x00:0x00 + returndata.length] // @2CAE returndata.length // @2CB1 memory[0x00:0x00 + returndata.length] // } 2CA9 3D RETURNDATASIZE 2CAA 60 PUSH1 0x00 2CAC 80 DUP1 2CAD 3E RETURNDATACOPY 2CAE 3D RETURNDATASIZE 2CAF 60 PUSH1 0x00 2CB1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2CAD memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2CB1 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2CB2: // Incoming jump from 0x2CA8, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) 2CB2 5B JUMPDEST 2CB3 50 POP 2CB4 50 POP 2CB5 50 POP 2CB6 50 POP 2CB7 61 PUSH2 0x0bf4 2CBA 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to 0x0bf4 label_2CBB: // Incoming jump from 0x2C39, if !stack[-2] // Inputs[6] // { // @2CBF memory[0x40:0x60] // @2CD7 stack[-3] // @2CE2 stack[-1] // @2CF9 memory[0x40:0x60] // @2CFB stack[-4] // @2D14 address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // } 2CBB 5B JUMPDEST 2CBC 60 PUSH1 0x40 2CBE 80 DUP1 2CBF 51 MLOAD 2CC0 63 PUSH4 0x022c0d9f 2CC5 60 PUSH1 0xe0 2CC7 1B SHL 2CC8 81 DUP2 2CC9 52 MSTORE 2CCA 60 PUSH1 0x00 2CCC 60 PUSH1 0x04 2CCE 82 DUP3 2CCF 01 ADD 2CD0 81 DUP2 2CD1 90 SWAP1 2CD2 52 MSTORE 2CD3 60 PUSH1 0x24 2CD5 82 DUP3 2CD6 01 ADD 2CD7 86 DUP7 2CD8 90 SWAP1 2CD9 52 MSTORE 2CDA 60 PUSH1 0x01 2CDC 60 PUSH1 0x01 2CDE 60 PUSH1 0xa0 2CE0 1B SHL 2CE1 03 SUB 2CE2 84 DUP5 2CE3 81 DUP2 2CE4 16 AND 2CE5 60 PUSH1 0x44 2CE7 84 DUP5 2CE8 01 ADD 2CE9 52 MSTORE 2CEA 60 PUSH1 0x80 2CEC 60 PUSH1 0x64 2CEE 84 DUP5 2CEF 01 ADD 2CF0 52 MSTORE 2CF1 60 PUSH1 0x84 2CF3 83 DUP4 2CF4 01 ADD 2CF5 82 DUP3 2CF6 90 SWAP1 2CF7 52 MSTORE 2CF8 92 SWAP3 2CF9 51 MLOAD 2CFA 92 SWAP3 2CFB 87 DUP8 2CFC 16 AND 2CFD 92 SWAP3 2CFE 63 PUSH4 0x022c0d9f 2D03 92 SWAP3 2D04 60 PUSH1 0xc4 2D06 80 DUP1 2D07 82 DUP3 2D08 01 ADD 2D09 93 SWAP4 2D0A 92 SWAP3 2D0B 91 SWAP2 2D0C 82 DUP3 2D0D 90 SWAP1 2D0E 03 SUB 2D0F 01 ADD 2D10 81 DUP2 2D11 83 DUP4 2D12 87 DUP8 2D13 80 DUP1 2D14 3B EXTCODESIZE 2D15 15 ISZERO 2D16 80 DUP1 2D17 15 ISZERO 2D18 61 PUSH2 0x2d20 2D1B 57 *JUMPI // Stack delta = +10 // Outputs[16] // { // @2CC9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x022c0d9f << 0xe0 // @2CD2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x00 // @2CD9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-3] // @2CE9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @2CF0 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x80 // @2CF7 memory[memory[0x40:0x60] + 0x84:memory[0x40:0x60] + 0x84 + 0x20] = 0x00 // @2CFD stack[0] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2D03 stack[1] = 0x022c0d9f // @2D09 stack[2] = memory[0x40:0x60] + 0xc4 // @2D0A stack[3] = 0x00 // @2D0B stack[4] = memory[0x40:0x60] // @2D0F stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0xc4 // @2D10 stack[6] = memory[0x40:0x60] // @2D11 stack[7] = 0x00 // @2D12 stack[8] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2D15 stack[9] = !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x2d20, if !!address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length label_2D1C: // Incoming jump from 0x2D1B, if not !!address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @2D1F memory[0x00:0x00] } 2D1C 60 PUSH1 0x00 2D1E 80 DUP1 2D1F FD *REVERT // Stack delta = +0 // Outputs[1] { @2D1F revert(memory[0x00:0x00]); } // Block terminates label_2D20: // Incoming jump from 0x2D1B, if !!address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @2D22 msg.gas // @2D23 stack[-5] // @2D23 stack[-2] // @2D23 memory[stack[-4]:stack[-4] + stack[-5]] // @2D23 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2D23 stack[-6] // @2D23 stack[-4] // @2D23 stack[-3] // @2D23 stack[-7] // } 2D20 5B JUMPDEST 2D21 50 POP 2D22 5A GAS 2D23 F1 CALL 2D24 15 ISZERO 2D25 80 DUP1 2D26 15 ISZERO 2D27 61 PUSH2 0x0d78 2D2A 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @2D23 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2D24 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 0x0d78, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_2D2B: // Incoming jump from 0x2D2A, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @2D2B returndata.length // @2D2F returndata[0x00:0x00 + returndata.length] // @2D30 returndata.length // @2D33 memory[0x00:0x00 + returndata.length] // } 2D2B 3D RETURNDATASIZE 2D2C 60 PUSH1 0x00 2D2E 80 DUP1 2D2F 3E RETURNDATACOPY 2D30 3D RETURNDATASIZE 2D31 60 PUSH1 0x00 2D33 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2D2F memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2D33 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2D34: // Incoming call from 0x216D, returns to 0x2154 // Incoming jump from 0x197A // Inputs[3] // { // @2D3A stack[-2] // @2D3B stack[-1] // @2D3E memory[0x40:0x60] // } 2D34 5B JUMPDEST 2D35 60 PUSH1 0x00 2D37 61 PUSH2 0x2d76 2D3A 83 DUP4 2D3B 83 DUP4 2D3C 60 PUSH1 0x40 2D3E 51 MLOAD 2D3F 80 DUP1 2D40 60 PUSH1 0x40 2D42 01 ADD 2D43 60 PUSH1 0x40 2D45 52 MSTORE 2D46 80 DUP1 2D47 60 PUSH1 0x1e 2D49 81 DUP2 2D4A 52 MSTORE 2D4B 60 PUSH1 0x20 2D4D 01 ADD 2D4E 7F PUSH32 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 2D6F 81 DUP2 2D70 52 MSTORE 2D71 50 POP 2D72 61 PUSH2 0x2184 2D75 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @2D35 stack[0] = 0x00 // @2D37 stack[1] = 0x2d76 // @2D3A stack[2] = stack[-2] // @2D3B stack[3] = stack[-1] // @2D3E stack[4] = memory[0x40:0x60] // @2D45 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @2D4A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1e // @2D70 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 // } // Block ends with call to 0x2184, returns to 0x2D76 label_2D76: // Incoming return from call to 0x2184 at 0x2D75 // Incoming jump from 0x2DA1, if stack[-1] / stack[-2] == stack[-3] // Incoming jump from 0x3036, if !(stack[-1] + stack[-2] < stack[-2]) // Incoming return from call to 0x2FC4 at 0x2E19 // Inputs[4] // { // @2D77 stack[-1] // @2D77 stack[-2] // @2D7A stack[-5] // @2D7B stack[-4] // } 2D76 5B JUMPDEST 2D77 90 SWAP1 2D78 50 POP 2D79 5B JUMPDEST 2D7A 92 SWAP3 2D7B 91 SWAP2 2D7C 50 POP 2D7D 50 POP 2D7E 56 *JUMP // Stack delta = -4 // Outputs[1] { @2D7A stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_2D7F: // Incoming call from 0x2153, returns to 0x2154 // Incoming call from 0x2ED4, returns to 0x2ED5 // Incoming jump from 0x1F95 // Incoming call from 0x2EB2, returns to 0x2EB3 // Incoming call from 0x2EC0, returns to 0x2EC1 // Incoming jump from 0x2159 // Inputs[1] { @2D82 stack[-2] } 2D7F 5B JUMPDEST 2D80 60 PUSH1 0x00 2D82 82 DUP3 2D83 61 PUSH2 0x2d8e 2D86 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2D80 stack[0] = 0x00 } // Block ends with conditional jump to 0x2d8e, if stack[-2] label_2D87: // Incoming jump from 0x2D86, if not stack[-2] 2D87 50 POP 2D88 60 PUSH1 0x00 2D8A 61 PUSH2 0x2d79 2D8D 56 *JUMP // Stack delta = +0 // Outputs[1] { @2D88 stack[-1] = 0x00 } // Block ends with unconditional jump to 0x2d79 label_2D8E: // Incoming jump from 0x2D86, if stack[-2] // Inputs[2] // { // @2D8F stack[-3] // @2D90 stack[-2] // } 2D8E 5B JUMPDEST 2D8F 82 DUP3 2D90 82 DUP3 2D91 02 MUL 2D92 82 DUP3 2D93 84 DUP5 2D94 82 DUP3 2D95 81 DUP2 2D96 61 PUSH2 0x2d9b 2D99 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2D91 stack[0] = stack[-2] * stack[-3] // @2D92 stack[1] = stack[-2] // @2D93 stack[2] = stack[-3] // @2D94 stack[3] = stack[-2] * stack[-3] // } // Block ends with conditional jump to 0x2d9b, if stack[-3] label_2D9A: // Incoming jump from 0x2D99, if not stack[-3] 2D9A FE *ASSERT // Stack delta = +0 // Outputs[1] { @2D9A assert(); } // Block terminates label_2D9B: // Incoming jump from 0x2D99, if stack[-3] // Inputs[3] // { // @2D9C stack[-2] // @2D9C stack[-1] // @2D9D stack[-3] // } 2D9B 5B JUMPDEST 2D9C 04 DIV 2D9D 14 EQ 2D9E 61 PUSH2 0x2d76 2DA1 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x2d76, if stack[-1] / stack[-2] == stack[-3] label_2DA2: // Incoming jump from 0x2DA1, if not stack[-1] / stack[-2] == stack[-3] // Inputs[3] // { // @2DA4 memory[0x40:0x60] // @2DD2 memory[0x40:0x60] // @2DD7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2DA2 60 PUSH1 0x40 2DA4 51 MLOAD 2DA5 62 PUSH3 0x461bcd 2DA9 60 PUSH1 0xe5 2DAB 1B SHL 2DAC 81 DUP2 2DAD 52 MSTORE 2DAE 60 PUSH1 0x04 2DB0 01 ADD 2DB1 80 DUP1 2DB2 80 DUP1 2DB3 60 PUSH1 0x20 2DB5 01 ADD 2DB6 82 DUP3 2DB7 81 DUP2 2DB8 03 SUB 2DB9 82 DUP3 2DBA 52 MSTORE 2DBB 60 PUSH1 0x21 2DBD 81 DUP2 2DBE 52 MSTORE 2DBF 60 PUSH1 0x20 2DC1 01 ADD 2DC2 80 DUP1 2DC3 61 PUSH2 0x30fe 2DC6 60 PUSH1 0x21 2DC8 91 SWAP2 2DC9 39 CODECOPY 2DCA 60 PUSH1 0x40 2DCC 01 ADD 2DCD 91 SWAP2 2DCE 50 POP 2DCF 50 POP 2DD0 60 PUSH1 0x40 2DD2 51 MLOAD 2DD3 80 DUP1 2DD4 91 SWAP2 2DD5 03 SUB 2DD6 90 SWAP1 2DD7 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2DAD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2DBA memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2DBE memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x21 // @2DC9 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x21] = code[0x30fe:0x311f] // @2DD7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2DD8: // Incoming jump from 0x1F9B // Inputs[3] // { // @2DDE stack[-2] // @2DDF stack[-1] // @2DE2 memory[0x40:0x60] // } 2DD8 5B JUMPDEST 2DD9 60 PUSH1 0x00 2DDB 61 PUSH2 0x2d76 2DDE 83 DUP4 2DDF 83 DUP4 2DE0 60 PUSH1 0x40 2DE2 51 MLOAD 2DE3 80 DUP1 2DE4 60 PUSH1 0x40 2DE6 01 ADD 2DE7 60 PUSH1 0x40 2DE9 52 MSTORE 2DEA 80 DUP1 2DEB 60 PUSH1 0x1a 2DED 81 DUP2 2DEE 52 MSTORE 2DEF 60 PUSH1 0x20 2DF1 01 ADD 2DF2 7F PUSH32 0x536166654d6174683a206469766973696f6e206279207a65726f000000000000 2E13 81 DUP2 2E14 52 MSTORE 2E15 50 POP 2E16 61 PUSH2 0x2fc4 2E19 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @2DD9 stack[0] = 0x00 // @2DDB stack[1] = 0x2d76 // @2DDE stack[2] = stack[-2] // @2DDF stack[3] = stack[-1] // @2DE2 stack[4] = memory[0x40:0x60] // @2DE9 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @2DEE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1a // @2E14 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x536166654d6174683a206469766973696f6e206279207a65726f000000000000 // } // Block ends with call to 0x2fc4, returns to 0x2D76 label_2E1A: // Incoming jump from 0x1FF0 // Inputs[1] { @2E1E stack[-3] } 2E1A 5B JUMPDEST 2E1B 60 PUSH1 0x00 2E1D 80 DUP1 2E1E 84 DUP5 2E1F 11 GT 2E20 61 PUSH2 0x2e5a 2E23 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2E1B stack[0] = 0x00 } // Block ends with conditional jump to 0x2e5a, if stack[-3] > 0x00 label_2E24: // Incoming jump from 0x2E23, if not stack[-3] > 0x00 // Inputs[3] // { // @2E26 memory[0x40:0x60] // @2E54 memory[0x40:0x60] // @2E59 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2E24 60 PUSH1 0x40 2E26 51 MLOAD 2E27 62 PUSH3 0x461bcd 2E2B 60 PUSH1 0xe5 2E2D 1B SHL 2E2E 81 DUP2 2E2F 52 MSTORE 2E30 60 PUSH1 0x04 2E32 01 ADD 2E33 80 DUP1 2E34 80 DUP1 2E35 60 PUSH1 0x20 2E37 01 ADD 2E38 82 DUP3 2E39 81 DUP2 2E3A 03 SUB 2E3B 82 DUP3 2E3C 52 MSTORE 2E3D 60 PUSH1 0x2b 2E3F 81 DUP2 2E40 52 MSTORE 2E41 60 PUSH1 0x20 2E43 01 ADD 2E44 80 DUP1 2E45 61 PUSH2 0x319e 2E48 60 PUSH1 0x2b 2E4A 91 SWAP2 2E4B 39 CODECOPY 2E4C 60 PUSH1 0x40 2E4E 01 ADD 2E4F 91 SWAP2 2E50 50 POP 2E51 50 POP 2E52 60 PUSH1 0x40 2E54 51 MLOAD 2E55 80 DUP1 2E56 91 SWAP2 2E57 03 SUB 2E58 90 SWAP1 2E59 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2E2F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2E3C memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2E40 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2b // @2E4B memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2b] = code[0x319e:0x31c9] // @2E59 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2E5A: // Incoming jump from 0x2E23, if stack[-3] > 0x00 // Inputs[1] { @2E5D stack[-3] } 2E5A 5B JUMPDEST 2E5B 60 PUSH1 0x00 2E5D 83 DUP4 2E5E 11 GT 2E5F 80 DUP1 2E60 15 ISZERO 2E61 61 PUSH2 0x2e6a 2E64 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2E5E stack[0] = stack[-3] > 0x00 } // Block ends with conditional jump to 0x2e6a, if !(stack[-3] > 0x00) label_2E65: // Incoming jump from 0x2E64, if not !(stack[-3] > 0x00) // Inputs[1] { @2E68 stack[-3] } 2E65 50 POP 2E66 60 PUSH1 0x00 2E68 82 DUP3 2E69 11 GT 2E6A 5B JUMPDEST 2E6B 61 PUSH2 0x2ea5 2E6E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2ea5, if stack[-3] > 0x00 label_2E6F: // Incoming jump from 0x2E6E, if not stack[-1] // Incoming jump from 0x2E6E, if not stack[-3] > 0x00 // Inputs[3] // { // @2E71 memory[0x40:0x60] // @2E9F memory[0x40:0x60] // @2EA4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2E6F 60 PUSH1 0x40 2E71 51 MLOAD 2E72 62 PUSH3 0x461bcd 2E76 60 PUSH1 0xe5 2E78 1B SHL 2E79 81 DUP2 2E7A 52 MSTORE 2E7B 60 PUSH1 0x04 2E7D 01 ADD 2E7E 80 DUP1 2E7F 80 DUP1 2E80 60 PUSH1 0x20 2E82 01 ADD 2E83 82 DUP3 2E84 81 DUP2 2E85 03 SUB 2E86 82 DUP3 2E87 52 MSTORE 2E88 60 PUSH1 0x28 2E8A 81 DUP2 2E8B 52 MSTORE 2E8C 60 PUSH1 0x20 2E8E 01 ADD 2E8F 80 DUP1 2E90 61 PUSH2 0x30d6 2E93 60 PUSH1 0x28 2E95 91 SWAP2 2E96 39 CODECOPY 2E97 60 PUSH1 0x40 2E99 01 ADD 2E9A 91 SWAP2 2E9B 50 POP 2E9C 50 POP 2E9D 60 PUSH1 0x40 2E9F 51 MLOAD 2EA0 80 DUP1 2EA1 91 SWAP2 2EA2 03 SUB 2EA3 90 SWAP1 2EA4 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2E7A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2E87 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2E8B memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x28 // @2E96 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x28] = code[0x30d6:0x30fe] // @2EA4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2EA5: // Incoming jump from 0x2E6E, if stack[-1] // Incoming jump from 0x2E6E, if stack[-3] > 0x00 // Inputs[1] { @2EAB stack[-4] } 2EA5 5B JUMPDEST 2EA6 60 PUSH1 0x00 2EA8 61 PUSH2 0x2eb3 2EAB 85 DUP6 2EAC 61 PUSH2 0x03e5 2EAF 61 PUSH2 0x2d7f 2EB2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2EA6 stack[0] = 0x00 // @2EA8 stack[1] = 0x2eb3 // @2EAB stack[2] = stack[-4] // @2EAC stack[3] = 0x03e5 // } // Block ends with call to 0x2d7f, returns to 0x2EB3 label_2EB3: // Incoming return from call to 0x2D7F at 0x2EB2 // Inputs[3] // { // @2EB4 stack[-2] // @2EB4 stack[-1] // @2EBC stack[-4] // } 2EB3 5B JUMPDEST 2EB4 90 SWAP1 2EB5 50 POP 2EB6 60 PUSH1 0x00 2EB8 61 PUSH2 0x2ec1 2EBB 82 DUP3 2EBC 85 DUP6 2EBD 61 PUSH2 0x2d7f 2EC0 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @2EB4 stack[-2] = stack[-1] // @2EB6 stack[-1] = 0x00 // @2EB8 stack[0] = 0x2ec1 // @2EBB stack[1] = stack[-1] // @2EBC stack[2] = stack[-4] // } // Block ends with call to 0x2d7f, returns to 0x2EC1 label_2EC1: // Incoming return from call to 0x2D7F at 0x2EC0 // Inputs[4] // { // @2EC2 stack[-2] // @2EC2 stack[-1] // @2EC9 stack[-3] // @2ECD stack[-6] // } 2EC1 5B JUMPDEST 2EC2 90 SWAP1 2EC3 50 POP 2EC4 60 PUSH1 0x00 2EC6 61 PUSH2 0x2edb 2EC9 83 DUP4 2ECA 61 PUSH2 0x2ed5 2ECD 88 DUP9 2ECE 61 PUSH2 0x03e8 2ED1 61 PUSH2 0x2d7f 2ED4 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @2EC2 stack[-2] = stack[-1] // @2EC4 stack[-1] = 0x00 // @2EC6 stack[0] = 0x2edb // @2EC9 stack[1] = stack[-3] // @2ECA stack[2] = 0x2ed5 // @2ECD stack[3] = stack[-6] // @2ECE stack[4] = 0x03e8 // } // Block ends with call to 0x2d7f, returns to 0x2ED5 label_2ED5: // Incoming return from call to 0x2D7F at 0x2ED4 // Inputs[2] // { // @2ED6 stack[-1] // @2ED6 stack[-2] // } 2ED5 5B JUMPDEST 2ED6 90 SWAP1 2ED7 61 PUSH2 0x3029 2EDA 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2ED6 stack[-1] = stack[-2] // @2ED6 stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x3029 label_2EDB: // Incoming return from call to 0x2ED5 at 0x2ED4 // Inputs[3] // { // @2EDC stack[-2] // @2EDC stack[-1] // @2EDF stack[-3] // } 2EDB 5B JUMPDEST 2EDC 90 SWAP1 2EDD 50 POP 2EDE 80 DUP1 2EDF 82 DUP3 2EE0 81 DUP2 2EE1 61 PUSH2 0x2ee6 2EE4 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2EDC stack[-2] = stack[-1] // @2EDE stack[-1] = stack[-1] // @2EDF stack[0] = stack[-3] // } // Block ends with conditional jump to 0x2ee6, if stack[-1] label_2EE5: // Incoming jump from 0x2EE4, if not stack[-1] 2EE5 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2EE5 assert(); } // Block terminates label_2EE6: // Incoming jump from 0x2EE4, if stack[-1] // Inputs[4] // { // @2EE7 stack[-2] // @2EE7 stack[-1] // @2EE8 stack[-10] // @2EE9 stack[-9] // } 2EE6 5B JUMPDEST 2EE7 04 DIV 2EE8 97 SWAP8 2EE9 96 SWAP7 2EEA 50 POP 2EEB 50 POP 2EEC 50 POP 2EED 50 POP 2EEE 50 POP 2EEF 50 POP 2EF0 50 POP 2EF1 56 *JUMP // Stack delta = -9 // Outputs[1] { @2EE8 stack[-10] = stack[-1] / stack[-2] } // Block ends with unconditional jump to stack[-10] label_2EF2: // Incoming call from 0x2943, returns to 0x2944 // Incoming call from 0x2891, returns to 0x2892 // Incoming call from 0x29F5, returns to 0x29F6 // Inputs[2] // { // @2EF8 stack[-2] // @2EF9 memory[stack[-2]:stack[-2] + 0x20] // } 2EF2 5B JUMPDEST 2EF3 60 PUSH1 0x00 2EF5 60 PUSH1 0x01 2EF7 5B JUMPDEST 2EF8 83 DUP4 2EF9 51 MLOAD 2EFA 81 DUP2 2EFB 10 LT 2EFC 15 ISZERO 2EFD 61 PUSH2 0x2fba 2F00 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2EF3 stack[0] = 0x00 // @2EF5 stack[1] = 0x01 // } // Block ends with conditional jump to 0x2fba, if !(0x01 < memory[stack[-2]:stack[-2] + 0x20]) label_2F01: // Incoming jump from 0x2F00, if not !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x2F00, if not !(0x01 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @2F03 stack[-5] // @2F04 stack[-1] // @2F06 memory[stack[-5]:stack[-5] + 0x20] // } 2F01 60 PUSH1 0x00 2F03 85 DUP6 2F04 82 DUP3 2F05 81 DUP2 2F06 51 MLOAD 2F07 81 DUP2 2F08 10 LT 2F09 61 PUSH2 0x2f0e 2F0C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2F01 stack[0] = 0x00 // @2F03 stack[1] = stack[-5] // @2F04 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x2f0e, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_2F0D: // Incoming jump from 0x2F0C, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 2F0D FE *ASSERT // Stack delta = +0 // Outputs[1] { @2F0D assert(); } // Block terminates label_2F0E: // Incoming jump from 0x2F0C, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[4] // { // @2F11 stack[-1] // @2F15 stack[-2] // @2F16 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2F17 stack[-3] // } 2F0E 5B JUMPDEST 2F0F 60 PUSH1 0x20 2F11 02 MUL 2F12 60 PUSH1 0x20 2F14 01 ADD 2F15 01 ADD 2F16 51 MLOAD 2F17 11 GT 2F18 15 ISZERO 2F19 61 PUSH2 0x2f74 2F1C 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x2f74, if !(memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] > stack[-3]) label_2F1D: // Incoming jump from 0x2F1C, if not !(memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] > stack[-3]) // Inputs[3] // { // @2F1D stack[-4] // @2F1E stack[-1] // @2F20 memory[stack[-4]:stack[-4] + 0x20] // } 2F1D 83 DUP4 2F1E 81 DUP2 2F1F 81 DUP2 2F20 51 MLOAD 2F21 81 DUP2 2F22 10 LT 2F23 61 PUSH2 0x2f28 2F26 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2F1D stack[0] = stack[-4] // @2F1E stack[1] = stack[-1] // } // Block ends with conditional jump to 0x2f28, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] label_2F27: // Incoming jump from 0x2F26, if not stack[-1] < memory[stack[-4]:stack[-4] + 0x20] 2F27 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2F27 assert(); } // Block terminates label_2F28: // Incoming jump from 0x2F26, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[3] // { // @2F2B stack[-1] // @2F2F stack[-2] // @2F30 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 2F28 5B JUMPDEST 2F29 60 PUSH1 0x20 2F2B 02 MUL 2F2C 60 PUSH1 0x20 2F2E 01 ADD 2F2F 01 ADD 2F30 51 MLOAD 2F31 15 ISZERO 2F32 61 PUSH2 0x2f54 2F35 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2f54, if !memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_2F36: // Incoming jump from 0x2F35, if not !memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[3] // { // @2F42 stack[-5] // @2F43 stack[-1] // @2F45 memory[stack[-5]:stack[-5] + 0x20] // } 2F36 61 PUSH2 0x2f4d 2F39 61 PUSH2 0x1f9c 2F3C 61 PUSH2 0x03e8 2F3F 61 PUSH2 0x1f96 2F42 88 DUP9 2F43 85 DUP6 2F44 81 DUP2 2F45 51 MLOAD 2F46 81 DUP2 2F47 10 LT 2F48 61 PUSH2 0x1f7b 2F4B 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @2F36 stack[0] = 0x2f4d // @2F39 stack[1] = 0x1f9c // @2F3C stack[2] = 0x03e8 // @2F3F stack[3] = 0x1f96 // @2F42 stack[4] = stack[-5] // @2F43 stack[5] = stack[-1] // } // Block ends with conditional call to 0x1f7b, returns to 0x1F96, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_2F4C: // Incoming jump from 0x2F4B, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 2F4C FE *ASSERT // Stack delta = +0 // Outputs[1] { @2F4C assert(); } // Block terminates label_2F4D: // Incoming return from call to 0x1F9C at 0x2F4B // Inputs[2] // { // @2F4E stack[-1] // @2F4E stack[-7] // } 2F4D 5B JUMPDEST 2F4E 95 SWAP6 2F4F 50 POP 2F50 61 PUSH2 0x2f6f 2F53 56 *JUMP // Stack delta = -1 // Outputs[1] { @2F4E stack[-7] = stack[-1] } // Block ends with unconditional jump to 0x2f6f label_2F54: // Incoming jump from 0x2F35, if !memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[3] // { // @2F61 stack[-5] // @2F62 stack[-1] // @2F64 memory[stack[-5]:stack[-5] + 0x20] // } 2F54 5B JUMPDEST 2F55 61 PUSH2 0x2f6c 2F58 61 PUSH2 0x2010 2F5B 61 PUSH2 0x03e8 2F5E 61 PUSH2 0x1f96 2F61 88 DUP9 2F62 85 DUP6 2F63 81 DUP2 2F64 51 MLOAD 2F65 81 DUP2 2F66 10 LT 2F67 61 PUSH2 0x1f7b 2F6A 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @2F55 stack[0] = 0x2f6c // @2F58 stack[1] = 0x2010 // @2F5B stack[2] = 0x03e8 // @2F5E stack[3] = 0x1f96 // @2F61 stack[4] = stack[-5] // @2F62 stack[5] = stack[-1] // } // Block ends with conditional call to 0x1f7b, returns to 0x1F96, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_2F6B: // Incoming jump from 0x2F6A, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 2F6B FE *ASSERT // Stack delta = +0 // Outputs[1] { @2F6B assert(); } // Block terminates label_2F6C: // Incoming return from call to 0x1FA9 at 0x2F9C // Incoming return from call to 0x2010 at 0x2F6A // Inputs[2] // { // @2F6D stack[-7] // @2F6D stack[-1] // } 2F6C 5B JUMPDEST 2F6D 95 SWAP6 2F6E 50 POP 2F6F 5B JUMPDEST 2F70 61 PUSH2 0x2fb2 2F73 56 *JUMP // Stack delta = -1 // Outputs[1] { @2F6D stack[-7] = stack[-1] } // Block ends with unconditional jump to 0x2fb2 label_2F74: // Incoming jump from 0x2F1C, if !(memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] > stack[-3]) // Inputs[3] // { // @2F75 stack[-4] // @2F76 stack[-1] // @2F78 memory[stack[-4]:stack[-4] + 0x20] // } 2F74 5B JUMPDEST 2F75 83 DUP4 2F76 81 DUP2 2F77 81 DUP2 2F78 51 MLOAD 2F79 81 DUP2 2F7A 10 LT 2F7B 61 PUSH2 0x2f80 2F7E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2F75 stack[0] = stack[-4] // @2F76 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x2f80, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] label_2F7F: // Incoming jump from 0x2F7E, if not stack[-1] < memory[stack[-4]:stack[-4] + 0x20] 2F7F FE *ASSERT // Stack delta = +0 // Outputs[1] { @2F7F assert(); } // Block terminates label_2F80: // Incoming jump from 0x2F7E, if stack[-1] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[3] // { // @2F83 stack[-1] // @2F87 stack[-2] // @2F88 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 2F80 5B JUMPDEST 2F81 60 PUSH1 0x20 2F83 02 MUL 2F84 60 PUSH1 0x20 2F86 01 ADD 2F87 01 ADD 2F88 51 MLOAD 2F89 15 ISZERO 2F8A 61 PUSH2 0x2f9e 2F8D 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2f9e, if !memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_2F8E: // Incoming jump from 0x2F8D, if not !memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[3] // { // @2F91 stack[-6] // @2F92 stack[-3] // @2F96 memory[stack[-3]:stack[-3] + 0x20] // } 2F8E 61 PUSH2 0x2f6c 2F91 86 DUP7 2F92 84 DUP5 2F93 60 PUSH1 0x01 2F95 81 DUP2 2F96 51 MLOAD 2F97 81 DUP2 2F98 10 LT 2F99 61 PUSH2 0x1fa9 2F9C 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2F8E stack[0] = 0x2f6c // @2F91 stack[1] = stack[-6] // @2F92 stack[2] = stack[-3] // @2F93 stack[3] = 0x01 // } // Block ends with conditional call to 0x1fa9, returns to 0x2F6C, if 0x01 < memory[stack[-3]:stack[-3] + 0x20] label_2F9D: // Incoming jump from 0x2F9C, if not 0x01 < memory[stack[-3]:stack[-3] + 0x20] 2F9D FE *ASSERT // Stack delta = +0 // Outputs[1] { @2F9D assert(); } // Block terminates label_2F9E: // Incoming jump from 0x2F8D, if !memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[3] // { // @2FA2 stack[-6] // @2FA3 stack[-3] // @2FA7 memory[stack[-3]:stack[-3] + 0x20] // } 2F9E 5B JUMPDEST 2F9F 61 PUSH2 0x2faf 2FA2 86 DUP7 2FA3 84 DUP5 2FA4 60 PUSH1 0x00 2FA6 81 DUP2 2FA7 51 MLOAD 2FA8 81 DUP2 2FA9 10 LT 2FAA 61 PUSH2 0x201d 2FAD 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2F9F stack[0] = 0x2faf // @2FA2 stack[1] = stack[-6] // @2FA3 stack[2] = stack[-3] // @2FA4 stack[3] = 0x00 // } // Block ends with conditional call to 0x201d, returns to 0x2FAF, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] label_2FAE: // Incoming jump from 0x2FAD, if not 0x00 < memory[stack[-3]:stack[-3] + 0x20] 2FAE FE *ASSERT // Stack delta = +0 // Outputs[1] { @2FAE assert(); } // Block terminates label_2FAF: // Incoming return from call to 0x201D at 0x2FAD // Inputs[3] // { // @2FB0 stack[-7] // @2FB0 stack[-1] // @2FB5 stack[-2] // } 2FAF 5B JUMPDEST 2FB0 95 SWAP6 2FB1 50 POP 2FB2 5B JUMPDEST 2FB3 60 PUSH1 0x01 2FB5 01 ADD 2FB6 61 PUSH2 0x2ef7 2FB9 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2FB0 stack[-7] = stack[-1] // @2FB5 stack[-2] = 0x01 + stack[-2] // } // Block ends with unconditional jump to 0x2ef7 label_2FBA: // Incoming jump from 0x2F00, if !(stack[-1] < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x2F00, if !(0x01 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @2FBC stack[-6] // @2FBC stack[-2] // @2FBD stack[-7] // } 2FBA 5B JUMPDEST 2FBB 50 POP 2FBC 93 SWAP4 2FBD 94 SWAP5 2FBE 93 SWAP4 2FBF 50 POP 2FC0 50 POP 2FC1 50 POP 2FC2 50 POP 2FC3 56 *JUMP // Stack delta = -6 // Outputs[1] { @2FBD stack[-7] = stack[-6] } // Block ends with unconditional jump to stack[-7] label_2FC4: // Incoming call from 0x2E19, returns to 0x2D76 // Inputs[2] // { // @2FC7 stack[-1] // @2FC8 stack[-2] // } 2FC4 5B JUMPDEST 2FC5 60 PUSH1 0x00 2FC7 81 DUP2 2FC8 83 DUP4 2FC9 61 PUSH2 0x3013 2FCC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2FC5 stack[0] = 0x00 // @2FC7 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x3013, if stack[-2] label_2FCD: // Incoming jump from 0x2FCC, if not stack[-2] // Inputs[4] // { // @2FCF memory[0x40:0x60] // @2FE2 stack[-1] // @2FE3 memory[stack[-1]:stack[-1] + 0x20] // @2FEA memory[stack[-1]:stack[-1] + 0x20] // } 2FCD 60 PUSH1 0x40 2FCF 51 MLOAD 2FD0 62 PUSH3 0x461bcd 2FD4 60 PUSH1 0xe5 2FD6 1B SHL 2FD7 81 DUP2 2FD8 52 MSTORE 2FD9 60 PUSH1 0x20 2FDB 60 PUSH1 0x04 2FDD 82 DUP3 2FDE 01 ADD 2FDF 81 DUP2 2FE0 81 DUP2 2FE1 52 MSTORE 2FE2 83 DUP4 2FE3 51 MLOAD 2FE4 60 PUSH1 0x24 2FE6 84 DUP5 2FE7 01 ADD 2FE8 52 MSTORE 2FE9 83 DUP4 2FEA 51 MLOAD 2FEB 90 SWAP1 2FEC 92 SWAP3 2FED 83 DUP4 2FEE 92 SWAP3 2FEF 60 PUSH1 0x44 2FF1 90 SWAP1 2FF2 91 SWAP2 2FF3 01 ADD 2FF4 91 SWAP2 2FF5 90 SWAP1 2FF6 85 DUP6 2FF7 01 ADD 2FF8 90 SWAP1 2FF9 80 DUP1 2FFA 83 DUP4 2FFB 83 DUP4 2FFC 60 PUSH1 0x00 2FFE 83 DUP4 2FFF 15 ISZERO 3000 61 PUSH2 0x21d8 3003 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @2FD8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2FE1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2FE8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @2FEC stack[0] = memory[0x40:0x60] + 0x04 // @2FEE stack[1] = memory[0x40:0x60] + 0x04 // @2FF4 stack[2] = memory[0x40:0x60] + 0x44 // @2FF8 stack[3] = stack[-1] + 0x20 // @2FF8 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @2FF9 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @2FFA stack[6] = memory[0x40:0x60] + 0x44 // @2FFB stack[7] = stack[-1] + 0x20 // @2FFC stack[8] = 0x00 // } // Block ends with conditional jump to 0x21d8, if !memory[stack[-1]:stack[-1] + 0x20] label_3004: // Incoming jump from 0x3003, if not !memory[stack[-1]:stack[-1] + 0x20] // Inputs[4] // { // @3004 stack[-2] // @3005 stack[-1] // @3007 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @3008 stack[-3] // } 3004 81 DUP2 3005 81 DUP2 3006 01 ADD 3007 51 MLOAD 3008 83 DUP4 3009 82 DUP3 300A 01 ADD 300B 52 MSTORE 300C 60 PUSH1 0x20 300E 01 ADD 300F 61 PUSH2 0x21c0 3012 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @300B memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @300E stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x21c0 label_3013: // Incoming jump from 0x2FCC, if stack[-2] // Inputs[2] // { // @3017 stack[-4] // @3018 stack[-5] // } 3013 5B JUMPDEST 3014 50 POP 3015 60 PUSH1 0x00 3017 83 DUP4 3018 85 DUP6 3019 81 DUP2 301A 61 PUSH2 0x301f 301D 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @3015 stack[-1] = 0x00 // @3017 stack[0] = stack[-4] // @3018 stack[1] = stack[-5] // } // Block ends with conditional jump to 0x301f, if stack[-4] label_301E: // Incoming jump from 0x301D, if not stack[-4] 301E FE *ASSERT // Stack delta = +0 // Outputs[1] { @301E assert(); } // Block terminates label_301F: // Incoming jump from 0x301D, if stack[-4] // Inputs[4] // { // @3020 stack[-2] // @3020 stack[-1] // @3021 stack[-8] // @3022 stack[-7] // } 301F 5B JUMPDEST 3020 04 DIV 3021 95 SWAP6 3022 94 SWAP5 3023 50 POP 3024 50 POP 3025 50 POP 3026 50 POP 3027 50 POP 3028 56 *JUMP // Stack delta = -7 // Outputs[1] { @3021 stack[-8] = stack[-1] / stack[-2] } // Block ends with unconditional jump to stack[-8] label_3029: // Incoming jump from 0x2EDA // Inputs[2] // { // @302C stack[-2] // @302D stack[-1] // } 3029 5B JUMPDEST 302A 60 PUSH1 0x00 302C 82 DUP3 302D 82 DUP3 302E 01 ADD 302F 83 DUP4 3030 81 DUP2 3031 10 LT 3032 15 ISZERO 3033 61 PUSH2 0x2d76 3036 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @302A stack[0] = 0x00 // @302E stack[1] = stack[-1] + stack[-2] // } // Block ends with conditional jump to 0x2d76, if !(stack[-1] + stack[-2] < stack[-2]) label_3037: // Incoming jump from 0x3036, if not !(stack[-1] + stack[-2] < stack[-2]) // Inputs[3] // { // @303A memory[0x40:0x60] // @3079 memory[0x40:0x60] // @3082 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3037 60 PUSH1 0x40 3039 80 DUP1 303A 51 MLOAD 303B 62 PUSH3 0x461bcd 303F 60 PUSH1 0xe5 3041 1B SHL 3042 81 DUP2 3043 52 MSTORE 3044 60 PUSH1 0x20 3046 60 PUSH1 0x04 3048 82 DUP3 3049 01 ADD 304A 52 MSTORE 304B 60 PUSH1 0x1b 304D 60 PUSH1 0x24 304F 82 DUP3 3050 01 ADD 3051 52 MSTORE 3052 7F PUSH32 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 3073 60 PUSH1 0x44 3075 82 DUP3 3076 01 ADD 3077 52 MSTORE 3078 90 SWAP1 3079 51 MLOAD 307A 90 SWAP1 307B 81 DUP2 307C 90 SWAP1 307D 03 SUB 307E 60 PUSH1 0x64 3080 01 ADD 3081 90 SWAP1 3082 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3043 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @304A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3051 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1b // @3077 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 // @3082 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates 3083 FE *ASSERT 3084 4F 4F 3085 77 PUSH24 0x6e61626c653a206e6577206f776e65722069732074686520 309E 7A PUSH27 0x65726f2061646472657373556e697377617056324c696272617279 30BA 3A GASPRICE 30BB 20 SHA3 30BC 49 49 30BD 4E 4E 30BE 53 MSTORE8 30BF 55 SSTORE 30C0 46 CHAINID 30C1 46 CHAINID 30C2 49 49 30C3 43 NUMBER 30C4 49 49 30C5 45 GASLIMIT 30C6 4E 4E 30C7 54 SLOAD 30C8 5F PUSH0 30C9 4F 4F 30CA 55 SSTORE 30CB 54 SLOAD 30CC 50 POP 30CD 55 SSTORE 30CE 54 SLOAD 30CF 5F PUSH0 30D0 41 COINBASE 30D1 4D 4D 30D2 4F 4F 30D3 55 SSTORE 30D4 4E 4E 30D5 54 SLOAD 30D6 55 SSTORE 30D7 6E PUSH15 0x697377617056324c6962726172793a 30E7 20 SHA3 30E8 49 49 30E9 4E 4E 30EA 53 MSTORE8 30EB 55 SSTORE 30EC 46 CHAINID 30ED 46 CHAINID 30EE 49 49 30EF 43 NUMBER 30F0 49 49 30F1 45 GASLIMIT 30F2 4E 4E 30F3 54 SLOAD 30F4 5F PUSH0 30F5 4C 4C 30F6 49 49 30F7 51 MLOAD 30F8 55 SSTORE 30F9 49 49 30FA 44 DIFFICULTY 30FB 49 49 30FC 54 SLOAD 30FD 59 MSIZE 30FE 53 MSTORE8 30FF 61 PUSH2 0x6665 3102 4D 4D 3103 61 PUSH2 0x7468 3106 3A GASPRICE 3107 20 SHA3 3108 6D PUSH14 0x756c7469706c69636174696f6e20 3117 6F PUSH16 0x766572666c6f774f776e61626c653a20 3128 63 PUSH4 0x616c6c65 312D 72 PUSH19 0x206973206e6f7420746865206f776e65724641 3141 20 SHA3 3142 45 GASLIMIT 3143 78 PUSH25 0x656375746f723a20426f72726f7720616d6f756e7420776974 315D 68 PUSH9 0x207468617420706174 3167 68 PUSH9 0x206973206e6f742070 3171 72 PUSH19 0x6f66697461626c654641204578656375746f72 3185 3A GASPRICE 3186 20 SHA3 3187 53 MSTORE8 3188 74 PUSH21 0x726174656779206e6f742070726f66697461626c65 319E 55 SSTORE 319F 6E PUSH15 0x697377617056324c6962726172793a 31AF 20 SHA3 31B0 49 49 31B1 4E 4E 31B2 53 MSTORE8 31B3 55 SSTORE 31B4 46 CHAINID 31B5 46 CHAINID 31B6 49 49 31B7 43 NUMBER 31B8 49 49 31B9 45 GASLIMIT 31BA 4E 4E 31BB 54 SLOAD 31BC 5F PUSH0 31BD 49 49 31BE 4E 4E 31BF 50 POP 31C0 55 SSTORE 31C1 54 SLOAD 31C2 5F PUSH0 31C3 41 COINBASE 31C4 4D 4D 31C5 4F 4F 31C6 55 SSTORE 31C7 4E 4E 31C8 54 SLOAD 31C9 A2 LOG2 31CA 64 PUSH5 0x6970667358 31D0 22 22 31D1 12 SLT 31D2 20 SHA3 31D3 AF AF 31D4 91 SWAP2 31D5 3F EXTCODEHASH 31D6 6D PUSH14 0x6182ef0e99c15a574a5de933c734 31E5 A1 LOG1 31E6 D7 D7 31E7 5B JUMPDEST 31E8 6D PUSH14 0x324e6525f11a734b94ad64736f6c 31F7 63 PUSH4 0x4300060c 31FC 00 *STOP 31FD 33 CALLER
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]