Online Solidity Decompiler

« Decompile another contract

Address

0xecbbd624859010e9e105a3344df165dba3f7594f [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.
0x054d50d4 getAmountOut(uint256,uint256,uint256)
0x1f00ca74 getAmountsIn(uint256,address[])
0x85f8c259 getAmountIn(uint256,uint256,uint256)
0xad5c4648 WETH()
0xad615dec quote(uint256,uint256,uint256)
0xc45a0155 factory()
0xd06ca61f getAmountsOut(uint256,address[])
0xe8e33700 addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)
0xf305d719 addLiquidityETH(address,uint256,uint256,uint256,address,uint256)

Internal Methods

getAmountsIn(arg0, arg1) returns (r0)
quote(arg0, arg1) returns (r0)
getAmountsOut(arg0, arg1) returns (r0)
addLiquidity(arg1) returns (r0, r1, r2)
addLiquidityETH(arg1) returns (r0, r1, r2)
WETH(arg0) returns (r0)
factory(arg0) returns (r0)
getAmountOut(arg0, arg1, arg2) returns (r0)
func_0A2E(arg0, arg1) returns (r0)
func_0A51(arg0, arg1, arg2) returns (r0)
func_0B2E(arg0, arg1, arg2, arg6, arg8) returns (r0, r1)
func_0B62(arg0, arg1, arg3, arg4) returns (r0)
getAmountIn(arg0, arg1, arg2) returns (r0)
func_0C41(arg0, arg1) returns (r0)
func_0C77(arg0, arg1, arg2) returns (r0)
func_0C8E(arg0, arg1, arg2) returns (r0)
func_0D3A(arg0, arg1, arg2) returns (r0)
func_0E14(arg0, arg1, arg2, arg6, arg8) returns (r0, r1)
func_0E3E(arg0, arg1, arg3, arg4) returns (r0)
func_0E71(arg0, arg1, arg2, arg3, arg4, arg5) returns (r0, r1)
func_10E5(arg0, arg1, arg2, arg3)
func_1242(arg0, arg1)
func_133A(arg0, arg1) returns (r0)
func_13EC(arg0, arg1, arg2) returns (r0, r1)
func_1538(arg0, arg1) returns (r0)
func_1588(arg0, arg1) returns (r0, r1)

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x80; if (msg.data.length >= 0x04) { var var0 = msg.data[0x00:0x20] >> 0xe0; if (0xad615dec > var0) { if (var0 == 0x054d50d4) { // Dispatch table entry for getAmountOut(uint256,uint256,uint256) var var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x00fe; var var2 = 0x04; var var3 = msg.data.length - var2; if (var3 < 0x60) { revert(memory[0x00:0x00]); } var temp0 = var2; var2 = msg.data[temp0:temp0 + 0x20]; var3 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20]; var var4 = msg.data[temp0 + 0x40:temp0 + 0x40 + 0x20]; var var5 = 0x00; var var6 = 0x0453; var var7 = var2; var var8 = var3; var var9 = var4; var6 = getAmountOut(var7, var8, var9); label_0453: var1 = var6; // Error: Could not resolve jump destination! } else if (var0 == 0x1f00ca74) { // Dispatch table entry for getAmountsIn(uint256,address[]) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x01c7; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } var1 = getAmountsIn(var2, var3); label_01C7: var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x20; var temp2 = var1; memory[temp1 + 0x20:temp1 + 0x20 + 0x20] = memory[temp2:temp2 + 0x20]; var2 = temp1; var3 = var2; var4 = var3 + 0x40; var5 = temp2 + 0x20; var6 = memory[temp2:temp2 + 0x20] * 0x20; var7 = var6; var8 = var4; var9 = var5; var var10 = 0x00; if (var10 >= var7) { label_0203: var temp3 = memory[0x40:0x60]; return memory[temp3:temp3 + (var6 + var4) - temp3]; } else { label_01F4: var temp4 = var10; memory[temp4 + var8:temp4 + var8 + 0x20] = memory[temp4 + var9:temp4 + var9 + 0x20]; var10 = temp4 + 0x20; if (var10 >= var7) { goto label_0203; } else { goto label_01F4; } } } else if (var0 == 0x85f8c259) { // Dispatch table entry for getAmountIn(uint256,uint256,uint256) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x00fe; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x60) { revert(memory[0x00:0x00]); } var temp5 = var2; var2 = msg.data[temp5:temp5 + 0x20]; var3 = msg.data[temp5 + 0x20:temp5 + 0x20 + 0x20]; var4 = msg.data[temp5 + 0x40:temp5 + 0x40 + 0x20]; var5 = 0x00; var6 = 0x0453; var7 = var2; var8 = var3; var9 = var4; var6 = getAmountIn(var7, var8, var9); goto label_0453; } else if (var0 == 0xad5c4648) { // Dispatch table entry for WETH() var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0262; var2 = WETH(); label_0262: var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = var2 & (0x01 << 0xa0) - 0x01; var temp7 = memory[0x40:0x60]; return memory[temp7:temp7 + temp6 - temp7 + 0x20]; } else { revert(memory[0x00:0x00]); } } else if (var0 == 0xad615dec) { // Dispatch table entry for quote(uint256,uint256,uint256) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x00fe; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x60) { revert(memory[0x00:0x00]); } var1 = quote(var2, var3); var temp8 = memory[0x40:0x60]; memory[temp8:temp8 + 0x20] = var1; var temp9 = memory[0x40:0x60]; return memory[temp9:temp9 + temp8 - temp9 + 0x20]; } else if (var0 == 0xc45a0155) { // Dispatch table entry for factory() var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0262; var2 = factory(); goto label_0262; } else if (var0 == 0xd06ca61f) { // Dispatch table entry for getAmountsOut(uint256,address[]) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x01c7; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } var1 = getAmountsOut(var2, var3); goto label_01C7; } else if (var0 == 0xe8e33700) { // Dispatch table entry for addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x03e2; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x0100) { revert(memory[0x00:0x00]); } var1, var2, var3 = addLiquidity(var2); label_03E2: var temp10 = memory[0x40:0x60]; memory[temp10:temp10 + 0x20] = var1; memory[temp10 + 0x20:temp10 + 0x20 + 0x20] = var2; memory[temp10 + 0x40:temp10 + 0x40 + 0x20] = var3; var temp11 = memory[0x40:0x60]; return memory[temp11:temp11 + temp10 - temp11 + 0x60]; } else if (var0 == 0xf305d719) { // Dispatch table entry for addLiquidityETH(address,uint256,uint256,uint256,address,uint256) var1 = 0x03e2; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0xc0) { revert(memory[0x00:0x00]); } var1, var2, var3 = addLiquidityETH(var2); goto label_03E2; } else { revert(memory[0x00:0x00]); } } else if (msg.data.length) { revert(memory[0x00:0x00]); } else if (msg.sender == 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 & (0x01 << 0xa0) - 0x01) { stop(); } else { assert(); } } function getAmountsIn(var arg0, var arg1) returns (var r0) { var temp0 = arg0; arg0 = msg.data[temp0:temp0 + 0x20]; var var0 = temp0; arg1 = var0 + arg1; var var1 = var0 + 0x40; var var2 = msg.data[var0 + 0x20:var0 + 0x20 + 0x20]; if (var2 > 0x0100000000) { revert(memory[0x00:0x00]); } var temp1 = var0 + var2; var2 = temp1; if (var2 + 0x20 > arg1) { revert(memory[0x00:0x00]); } var temp2 = var2; var temp3 = msg.data[temp2:temp2 + 0x20]; var2 = temp3; var temp4 = var1; var1 = temp2 + 0x20; var var3 = temp4; if ((var2 > 0x0100000000) | (var1 + var2 * 0x20 > arg1)) { revert(memory[0x00:0x00]); } var temp5 = var2; 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[var1:var1 + temp8]; memory[temp7 + temp8:temp7 + temp8 + 0x20] = 0x00; arg1 = temp6; var0 = 0x60; var1 = 0x0488; var2 = 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2; var3 = arg0; var var4 = arg1; return func_0A51(var2, var3, var4); } function quote(var arg0, var arg1) returns (var r0) { var temp0 = arg0; arg0 = msg.data[temp0:temp0 + 0x20]; arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20]; var var0 = msg.data[temp0 + 0x40:temp0 + 0x40 + 0x20]; var var1 = 0x00; var var2 = 0x0453; var var3 = arg0; var var4 = arg1; var var5 = var0; return func_0C8E(var3, var4, var5); } function getAmountsOut(var arg0, var arg1) returns (var r0) { var temp0 = arg0; arg0 = msg.data[temp0:temp0 + 0x20]; arg1 = temp0 + arg1; var var0 = temp0; var var1 = var0 + 0x40; var var2 = msg.data[var0 + 0x20:var0 + 0x20 + 0x20]; if (var2 > 0x0100000000) { revert(memory[0x00:0x00]); } var temp1 = var0 + var2; var2 = temp1; if (var2 + 0x20 > arg1) { revert(memory[0x00:0x00]); } var temp2 = var2; var temp3 = msg.data[temp2:temp2 + 0x20]; var2 = temp3; var temp4 = var1; var1 = temp2 + 0x20; var var3 = temp4; if ((var2 > 0x0100000000) | (var1 + var2 * 0x20 > arg1)) { revert(memory[0x00:0x00]); } var temp5 = var2; 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[var1:var1 + temp8]; memory[temp7 + temp8:temp7 + temp8 + 0x20] = 0x00; arg1 = temp6; var0 = 0x60; var1 = 0x0488; var2 = 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2; var3 = arg0; var var4 = arg1; return func_0D3A(var2, var3, var4); } function addLiquidity(var arg0) returns (var r0, var arg0, var r2) { var temp0 = (0x01 << 0xa0) - 0x01; var temp1 = arg0; arg0 = temp0 & msg.data[temp1:temp1 + 0x20]; r2 = temp0 & msg.data[temp1 + 0x20:temp1 + 0x20 + 0x20]; var var0 = msg.data[temp1 + 0x40:temp1 + 0x40 + 0x20]; var var1 = msg.data[temp1 + 0x60:temp1 + 0x60 + 0x20]; var var2 = msg.data[temp1 + 0x80:temp1 + 0x80 + 0x20]; var var3 = msg.data[temp1 + 0xa0:temp1 + 0xa0 + 0x20]; var var4 = msg.data[temp1 + 0xc0:temp1 + 0xc0 + 0x20] & temp0; var var5 = msg.data[temp1 + 0xe0:temp1 + 0xe0 + 0x20]; var var6 = 0x00; var var7 = var6; var var8 = 0x00; var var9 = 0x0533; var var10 = arg0; var var11 = r2; var var12 = var0; var var13 = var1; var var14 = var2; var var15 = var3; var9, var10 = func_0E71(var10, var11, var12, var13, var14, var15); var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0xe6a43905 << 0xe0; var temp3 = (0x01 << 0xa0) - 0x01; memory[temp2 + 0x04:temp2 + 0x04 + 0x20] = temp3 & arg0; memory[temp2 + 0x24:temp2 + 0x24 + 0x20] = temp3 & r2; var6 = var9; var7 = var10; var9 = 0x00; var10 = temp3 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2; var11 = 0xe6a43905; var12 = temp2 + 0x44; var13 = 0x20; var14 = memory[0x40:0x60]; var15 = temp2 - var14 + 0x44; var var16 = var14; var var17 = var10; var var18 = !address(var17).code.length; if (var18) { revert(memory[0x00:0x00]); } var temp4; temp4, memory[var14:var14 + var13] = address(var17).staticcall.gas(msg.gas)(memory[var16:var16 + var15]); var13 = !temp4; if (!var13) { var10 = memory[0x40:0x60]; var11 = returndata.length; if (var11 < 0x20) { revert(memory[0x00:0x00]); } var temp5 = memory[var10:var10 + 0x20]; var9 = temp5; var10 = 0x05e8; var11 = arg0; var12 = msg.sender; var13 = var9; var14 = var6; func_10E5(var11, var12, var13, var14); var10 = 0x05f4; var11 = r2; var12 = msg.sender; var13 = var9; var14 = var7; func_10E5(var11, var12, var13, var14); var10 = var9 & (0x01 << 0xa0) - 0x01; var11 = 0x6a627842; var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = (var11 & 0xffffffff) << 0xe0; var temp7 = temp6 + 0x04; memory[temp7:temp7 + 0x20] = var4 & (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01; var12 = temp7 + 0x20; var13 = 0x20; var14 = memory[0x40:0x60]; var15 = var12 - var14; var16 = var14; var17 = 0x00; var18 = var10; var var19 = !address(var18).code.length; if (var19) { revert(memory[0x00:0x00]); } var temp8; temp8, memory[var14:var14 + var13] = address(var18).call.gas(msg.gas).value(var17)(memory[var16:var16 + var15]); var13 = !temp8; if (!var13) { var10 = memory[0x40:0x60]; var11 = returndata.length; if (var11 < 0x20) { revert(memory[0x00:0x00]); } r0 = var6; arg0 = var7; r2 = memory[var10:var10 + 0x20]; return r0, arg0, r2; } else { var temp9 = returndata.length; memory[0x00:0x00 + temp9] = returndata[0x00:0x00 + temp9]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp10 = returndata.length; memory[0x00:0x00 + temp10] = returndata[0x00:0x00 + temp10]; revert(memory[0x00:0x00 + returndata.length]); } } function addLiquidityETH(var arg0) returns (var r0, var arg0, var r2) { var temp0 = (0x01 << 0xa0) - 0x01; var temp1 = arg0; arg0 = temp0 & msg.data[temp1:temp1 + 0x20]; r2 = msg.data[temp1 + 0x20:temp1 + 0x20 + 0x20]; var var0 = msg.data[temp1 + 0x40:temp1 + 0x40 + 0x20]; var var1 = msg.data[temp1 + 0x60:temp1 + 0x60 + 0x20]; var var2 = msg.data[temp1 + 0x80:temp1 + 0x80 + 0x20] & temp0; var var3 = msg.data[temp1 + 0xa0:temp1 + 0xa0 + 0x20]; var var4 = 0x00; var var5 = var4; var var6 = 0x00; var var7 = 0x06bf; var var8 = arg0; var var9 = 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2; var var10 = r2; var var11 = msg.value; var var12 = var0; var var13 = var1; var7, var8 = func_0E71(var8, var9, var10, var11, var12, var13); var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0xe6a43905 << 0xe0; var temp3 = (0x01 << 0xa0) - 0x01; memory[temp2 + 0x04:temp2 + 0x04 + 0x20] = temp3 & arg0; memory[temp2 + 0x24:temp2 + 0x24 + 0x20] = temp3 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2; var4 = var7; var5 = var8; var7 = 0x00; var8 = temp3 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2; var9 = 0xe6a43905; var10 = temp2 + 0x44; var11 = 0x20; var12 = memory[0x40:0x60]; var13 = temp2 - var12 + 0x44; var var14 = var12; var var15 = var8; var var16 = !address(var15).code.length; if (var16) { revert(memory[0x00:0x00]); } var temp4; temp4, memory[var12:var12 + var11] = address(var15).staticcall.gas(msg.gas)(memory[var14:var14 + var13]); var11 = !temp4; if (!var11) { var8 = memory[0x40:0x60]; var9 = returndata.length; if (var9 < 0x20) { revert(memory[0x00:0x00]); } var temp5 = memory[var8:var8 + 0x20]; var7 = temp5; var8 = 0x0794; var9 = arg0; var10 = msg.sender; var11 = var7; var12 = var4; func_10E5(var9, var10, var11, var12); var8 = (0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2; var9 = 0xd0e30db0; var10 = var5; var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = (var9 & 0xffffffff) << 0xe0; var11 = temp6 + 0x04; var12 = 0x00; var13 = memory[0x40:0x60]; var14 = var11 - var13; var15 = var13; var16 = var10; var var17 = var8; var var18 = !address(var17).code.length; if (var18) { revert(memory[0x00:0x00]); } var temp7; temp7, memory[var13:var13 + var12] = address(var17).call.gas(msg.gas).value(var16)(memory[var15:var15 + var14]); var12 = !temp7; if (!var12) { var8 = (0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2; var9 = 0xa9059cbb; var temp8 = memory[0x40:0x60]; memory[temp8:temp8 + 0x20] = (var9 & 0xffffffff) << 0xe0; var temp9 = temp8 + 0x04; memory[temp9:temp9 + 0x20] = var7 & (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01; var temp10 = temp9 + 0x20; memory[temp10:temp10 + 0x20] = var5; var10 = temp10 + 0x20; var11 = 0x20; var12 = memory[0x40:0x60]; var13 = var10 - var12; var14 = var12; var15 = 0x00; var16 = var8; var17 = !address(var16).code.length; if (var17) { revert(memory[0x00:0x00]); } var temp11; temp11, memory[var12:var12 + var11] = address(var16).call.gas(msg.gas).value(var15)(memory[var14:var14 + var13]); var11 = !temp11; if (!var11) { var8 = memory[0x40:0x60]; var9 = returndata.length; if (var9 < 0x20) { revert(memory[0x00:0x00]); } if (!memory[var8:var8 + 0x20]) { assert(); } var8 = var7 & (0x01 << 0xa0) - 0x01; var9 = 0x6a627842; var temp12 = memory[0x40:0x60]; memory[temp12:temp12 + 0x20] = (var9 & 0xffffffff) << 0xe0; var temp13 = temp12 + 0x04; memory[temp13:temp13 + 0x20] = var2 & (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01; var10 = temp13 + 0x20; var11 = 0x20; var12 = memory[0x40:0x60]; var13 = var10 - var12; var14 = var12; var15 = 0x00; var16 = var8; var17 = !address(var16).code.length; if (var17) { revert(memory[0x00:0x00]); } var temp14; temp14, memory[var12:var12 + var11] = address(var16).call.gas(msg.gas).value(var15)(memory[var14:var14 + var13]); var11 = !temp14; if (!var11) { var8 = memory[0x40:0x60]; var9 = returndata.length; if (var9 < 0x20) { revert(memory[0x00:0x00]); } var6 = memory[var8:var8 + 0x20]; if (var5 >= msg.value) { label_0954: r2 = var6; arg0 = var5; r0 = var4; return r0, arg0, r2; } else { var8 = 0x0954; var9 = msg.sender; var10 = msg.value - var5; func_1242(var9, var10); goto label_0954; } } else { var temp15 = returndata.length; memory[0x00:0x00 + temp15] = returndata[0x00:0x00 + temp15]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp16 = returndata.length; memory[0x00:0x00 + temp16] = returndata[0x00:0x00 + temp16]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp17 = returndata.length; memory[0x00:0x00 + temp17] = returndata[0x00:0x00 + temp17]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp18 = returndata.length; memory[0x00:0x00 + temp18] = returndata[0x00:0x00 + temp18]; revert(memory[0x00:0x00 + returndata.length]); } } function WETH() returns (var r0) { return 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2; } function factory() returns (var r0) { return 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2; } function getAmountOut(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x00; if (arg0 > var0) { var var1 = arg1 > 0x00; if (!var1) { if (var1) { label_09EC: var1 = 0x00; var var2 = 0x0a00; var var3 = arg0; var var4 = 0x03e5; var2 = func_133A(var3, var4); var temp0 = var2; var1 = temp0; var2 = 0x00; var3 = 0x0a14; var4 = var1; var var5 = arg2; var3 = func_133A(var4, var5); var2 = var3; var3 = 0x00; var4 = 0x0a3a; var5 = var1; var var6 = 0x0a2e; var var7 = arg1; var var8 = 0x03e8; var6 = func_133A(var7, var8); var4 = func_0A2E(var5, var6); var3 = var4; var4 = var3; var5 = var2; if (var4) { return var5 / var4; } else { assert(); } } else { label_09B6: var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x461bcd << 0xe5; var temp2 = temp1 + 0x04; var temp3 = temp2 + 0x20; memory[temp2:temp2 + 0x20] = temp3 - temp2; memory[temp3:temp3 + 0x20] = 0x28; var temp4 = temp3 + 0x20; memory[temp4:temp4 + 0x28] = code[0x16de:0x1706]; var temp5 = memory[0x40:0x60]; revert(memory[temp5:temp5 + (temp4 + 0x40) - temp5]); } } else if (arg2 > 0x00) { goto label_09EC; } else { goto label_09B6; } } else { var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = 0x461bcd << 0xe5; var temp7 = temp6 + 0x04; var temp8 = temp7 + 0x20; memory[temp7:temp7 + 0x20] = temp8 - temp7; memory[temp8:temp8 + 0x20] = 0x2b; var temp9 = temp8 + 0x20; memory[temp9:temp9 + 0x2b] = code[0x1798:0x17c3]; var temp10 = memory[0x40:0x60]; revert(memory[temp10:temp10 + (temp9 + 0x40) - temp10]); } } function func_0A2E(var arg0, var arg1) returns (var r0) { var temp0 = arg0; arg0 = arg1; arg1 = temp0; var temp1 = arg0; var var0 = temp1 + arg1; if (var0 >= temp1) { return var0; } var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x461bcd << 0xe5; memory[temp2 + 0x04:temp2 + 0x04 + 0x20] = 0x20; memory[temp2 + 0x24:temp2 + 0x24 + 0x20] = 0x14; memory[temp2 + 0x44:temp2 + 0x44 + 0x20] = 0x64732d6d6174682d6164642d6f766572666c6f77 << 0x60; var temp3 = memory[0x40:0x60]; revert(memory[temp3:temp3 + temp2 - temp3 + 0x64]); } function func_0A51(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x60; if (memory[arg2:arg2 + 0x20] >= 0x02) { 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) { var temp2 = var1; var0 = temp2; var1 = arg1; var2 = var0; var var3 = memory[var2:var2 + 0x20] - 0x01; if (var3 >= memory[var2:var2 + 0x20]) { assert(); } label_0B00: memory[var3 * 0x20 + var2 + 0x20:var3 * 0x20 + var2 + 0x20 + 0x20] = var1; var1 = memory[arg2:arg2 + 0x20] + ~0x00; if (!var1) { label_0B96: return var0; } else { label_0B19: var2 = 0x00; var3 = var2; var var4 = 0x0b4f; var var5 = arg0; var var6 = arg2; var var7 = var1 - 0x01; if (var7 >= memory[var6:var6 + 0x20]) { assert(); } var4, var5 = func_0B2E(arg2, var1, var5, var6, var7); var3 = var5; var2 = var4; var4 = 0x0b71; var5 = var0; var6 = var1; if (var6 >= memory[var5:var5 + 0x20]) { assert(); } var4 = func_0B62(var2, var3, var5, var6); var5 = var0; var6 = var1 - 0x01; if (var6 >= memory[var5:var5 + 0x20]) { assert(); } memory[var6 * 0x20 + var5 + 0x20:var6 * 0x20 + var5 + 0x20 + 0x20] = var4; var1 = var1 + ~0x00; if (!var1) { goto label_0B96; } else { goto label_0B19; } } } else { var temp3 = var1; var temp4 = var2 * 0x20; memory[temp3 + 0x20:temp3 + 0x20 + temp4] = msg.data[msg.data.length:msg.data.length + temp4]; var0 = temp3; var1 = arg1; var2 = var0; var3 = memory[var2:var2 + 0x20] - 0x01; if (var3 < memory[var2:var2 + 0x20]) { goto label_0B00; } else { assert(); } } } else { var temp5 = memory[0x40:0x60]; memory[temp5:temp5 + 0x20] = 0x461bcd << 0xe5; memory[temp5 + 0x04:temp5 + 0x04 + 0x20] = 0x20; memory[temp5 + 0x24:temp5 + 0x24 + 0x20] = 0x1e; memory[temp5 + 0x44:temp5 + 0x44 + 0x20] = 0x556e697377617056324c6962726172793a20494e56414c49445f504154480000; var temp6 = memory[0x40:0x60]; revert(memory[temp6:temp6 + temp5 - temp6 + 0x64]); } } function func_0B2E(var arg0, var arg1, var arg2, var arg3, var arg4) returns (var r0, var arg2) { arg3 = memory[arg4 * 0x20 + 0x20 + arg3:arg4 * 0x20 + 0x20 + arg3 + 0x20]; arg4 = arg0; var var0 = arg1; if (var0 >= memory[arg4:arg4 + 0x20]) { assert(); } arg4 = memory[var0 * 0x20 + 0x20 + arg4:var0 * 0x20 + 0x20 + arg4 + 0x20]; r0, arg2 = func_13EC(arg2, arg3, arg4); // Error: Could not resolve method call return address! } function func_0B62(var arg0, var arg1, var arg2, var arg3) returns (var r0) { arg2 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg3 = arg0; var var0 = arg1; r0 = getAmountIn(arg2, arg3, var0); // Error: Could not resolve method call return address! } function getAmountIn(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x00; if (arg0 > var0) { var var1 = arg1 > 0x00; if (!var1) { if (var1) { label_0C29: var1 = 0x00; var var2 = 0x0c4d; var var3 = 0x03e8; var var4 = 0x0c41; var var5 = arg1; var var6 = arg0; var4 = func_133A(var5, var6); var2 = func_0C41(var3, var4); var1 = var2; var2 = 0x00; var3 = 0x0c67; var4 = 0x03e5; var5 = 0x0c41; var6 = arg2; var var7 = arg0; var5 = func_1538(var6, var7); var3 = func_0C41(var4, var5); var temp0 = var3; var2 = temp0; var3 = 0x0c84; var4 = 0x01; var5 = var2; var6 = var1; if (var5) { return func_0C77(var4, var5, var6); } else { assert(); } } else { label_0BF3: var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x461bcd << 0xe5; var temp2 = temp1 + 0x04; var temp3 = temp2 + 0x20; memory[temp2:temp2 + 0x20] = temp3 - temp2; memory[temp3:temp3 + 0x20] = 0x28; var temp4 = temp3 + 0x20; memory[temp4:temp4 + 0x28] = code[0x16de:0x1706]; var temp5 = memory[0x40:0x60]; revert(memory[temp5:temp5 + (temp4 + 0x40) - temp5]); } } else if (arg2 > 0x00) { goto label_0C29; } else { goto label_0BF3; } } else { var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = 0x461bcd << 0xe5; var temp7 = temp6 + 0x04; var temp8 = temp7 + 0x20; memory[temp7:temp7 + 0x20] = temp8 - temp7; memory[temp8:temp8 + 0x20] = 0x2c; var temp9 = temp8 + 0x20; memory[temp9:temp9 + 0x2c] = code[0x1667:0x1693]; var temp10 = memory[0x40:0x60]; revert(memory[temp10:temp10 + (temp9 + 0x40) - temp10]); } } function func_0C41(var arg0, var arg1) returns (var r0) { var temp0 = arg0; arg0 = arg1; arg1 = temp0; r0 = func_133A(arg0, arg1); // Error: Could not resolve method call return address! } function func_0C77(var arg0, var arg1, var arg2) returns (var r0) { var temp0 = arg0; arg0 = arg2 / arg1; arg1 = temp0; var temp1 = arg0; arg2 = temp1 + arg1; if (arg2 >= temp1) { return arg2; } var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x461bcd << 0xe5; memory[temp2 + 0x04:temp2 + 0x04 + 0x20] = 0x20; memory[temp2 + 0x24:temp2 + 0x24 + 0x20] = 0x14; memory[temp2 + 0x44:temp2 + 0x44 + 0x20] = 0x64732d6d6174682d6164642d6f766572666c6f77 << 0x60; var temp3 = memory[0x40:0x60]; revert(memory[temp3:temp3 + temp2 - temp3 + 0x64]); } function func_0C8E(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x00; if (arg0 > var0) { var var1 = arg1 > 0x00; if (!var1) { if (var1) { label_0D19: var1 = arg1; var var2 = 0x0d2a; var var3 = arg0; var var4 = arg2; var2 = func_133A(var3, var4); if (var1) { return var2 / var1; } else { assert(); } } else { label_0CE3: 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] = 0x28; var temp3 = temp2 + 0x20; memory[temp3:temp3 + 0x28] = code[0x16de:0x1706]; var temp4 = memory[0x40:0x60]; revert(memory[temp4:temp4 + (temp3 + 0x40) - temp4]); } } else if (arg2 > 0x00) { goto label_0D19; } else { goto label_0CE3; } } else { var temp5 = memory[0x40:0x60]; memory[temp5:temp5 + 0x20] = 0x461bcd << 0xe5; var temp6 = temp5 + 0x04; var temp7 = temp6 + 0x20; memory[temp6:temp6 + 0x20] = temp7 - temp6; memory[temp7:temp7 + 0x20] = 0x25; var temp8 = temp7 + 0x20; memory[temp8:temp8 + 0x25] = code[0x1706:0x172b]; var temp9 = memory[0x40:0x60]; revert(memory[temp9:temp9 + (temp8 + 0x40) - temp9]); } } function func_0D3A(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x60; if (memory[arg2:arg2 + 0x20] >= 0x02) { 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) { var temp2 = var1; var0 = temp2; var1 = arg1; var2 = var0; var var3 = 0x00; if (var3 >= memory[var2:var2 + 0x20]) { assert(); } label_0DE6: memory[var3 * 0x20 + 0x20 + var2:var3 * 0x20 + 0x20 + var2 + 0x20] = var1; var1 = 0x00; if (var1 >= memory[arg2:arg2 + 0x20] - 0x01) { label_0B96: return var0; } else { label_0E02: var2 = 0x00; var3 = var2; var var4 = 0x0e2b; var var5 = arg0; var var6 = arg2; var var7 = var1; if (var7 >= memory[var6:var6 + 0x20]) { assert(); } var4, var5 = func_0E14(arg2, var1, var5, var6, var7); var3 = var5; var2 = var4; var4 = 0x0e4d; var5 = var0; var6 = var1; if (var6 >= memory[var5:var5 + 0x20]) { assert(); } var4 = func_0E3E(var2, var3, var5, var6); var5 = var0; var6 = var1 + 0x01; if (var6 >= memory[var5:var5 + 0x20]) { assert(); } memory[var6 * 0x20 + var5 + 0x20:var6 * 0x20 + var5 + 0x20 + 0x20] = var4; var1 = var1 + 0x01; if (var1 >= memory[arg2:arg2 + 0x20] - 0x01) { goto label_0B96; } else { goto label_0E02; } } } else { var temp3 = var1; var temp4 = var2 * 0x20; memory[temp3 + 0x20:temp3 + 0x20 + temp4] = msg.data[msg.data.length:msg.data.length + temp4]; var0 = temp3; var1 = arg1; var2 = var0; var3 = 0x00; if (var3 < memory[var2:var2 + 0x20]) { goto label_0DE6; } else { assert(); } } } else { var temp5 = memory[0x40:0x60]; memory[temp5:temp5 + 0x20] = 0x461bcd << 0xe5; memory[temp5 + 0x04:temp5 + 0x04 + 0x20] = 0x20; memory[temp5 + 0x24:temp5 + 0x24 + 0x20] = 0x1e; memory[temp5 + 0x44:temp5 + 0x44 + 0x20] = 0x556e697377617056324c6962726172793a20494e56414c49445f504154480000; var temp6 = memory[0x40:0x60]; revert(memory[temp6:temp6 + temp5 - temp6 + 0x64]); } } function func_0E14(var arg0, var arg1, var arg2, var arg3, var arg4) returns (var r0, var arg2) { arg3 = memory[arg4 * 0x20 + 0x20 + arg3:arg4 * 0x20 + 0x20 + arg3 + 0x20]; arg4 = arg0; var var0 = arg1 + 0x01; if (var0 >= memory[arg4:arg4 + 0x20]) { assert(); } arg4 = memory[var0 * 0x20 + 0x20 + arg4:var0 * 0x20 + 0x20 + arg4 + 0x20]; r0, arg2 = func_13EC(arg2, arg3, arg4); // Error: Could not resolve method call return address! } function func_0E3E(var arg0, var arg1, var arg2, var arg3) returns (var r0) { arg2 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg3 = arg0; var var0 = arg1; r0 = getAmountOut(arg2, arg3, var0); // Error: Could not resolve method call return address! } function func_0E71(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5) returns (var r0, var arg0) { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0xe6a43905 << 0xe0; var temp1 = (0x01 << 0xa0) - 0x01; memory[temp0 + 0x04:temp0 + 0x04 + 0x20] = temp1 & arg0; memory[temp0 + 0x24:temp0 + 0x24 + 0x20] = temp1 & arg1; var var0 = 0x00; var var1 = var0; var var2 = var1; var var3 = temp1 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2; var var4 = 0xe6a43905; var var5 = temp0 + 0x44; var var6 = 0x20; var var7 = memory[0x40:0x60]; var var8 = temp0 - var7 + 0x44; var var9 = var7; var var10 = var3; var var11 = !address(var10).code.length; if (var11) { revert(memory[0x00:0x00]); } var temp2; temp2, memory[var7:var7 + var6] = address(var10).staticcall.gas(msg.gas)(memory[var9:var9 + var8]); var6 = !temp2; if (!var6) { var3 = memory[0x40:0x60]; var4 = returndata.length; if (var4 < 0x20) { revert(memory[0x00:0x00]); } if (memory[var3:var3 + 0x20] & (0x01 << 0xa0) - 0x01 != var2) { label_0FC8: var2 = 0x00; var3 = var2; var4 = 0x0ff6; var5 = 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2; var6 = arg0; var7 = arg1; var4, var5 = func_13EC(var5, var6, var7); var3 = var5; var2 = var4; var temp3 = var2 == 0x00; var4 = temp3; if (!var4) { if (!var4) { label_1018: var4 = 0x00; var5 = 0x1025; var6 = arg2; var7 = var2; var8 = var3; var5 = func_0C8E(var6, var7, var8); var4 = var5; if (var4 > arg3) { var5 = 0x00; var6 = 0x1085; var7 = arg3; var8 = var3; var9 = var2; var6 = func_0C8E(var7, var8, var9); var5 = var6; if (var5 > arg2) { assert(); } if (var5 >= arg4) { var0 = var5; var1 = arg3; label_10D6: label_10D8: arg0 = var1; r0 = var0; return r0, arg0; } else { var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = 0x461bcd << 0xe5; var temp5 = temp4 + 0x04; var temp6 = temp5 + 0x20; memory[temp5:temp5 + 0x20] = temp6 - temp5; memory[temp6:temp6 + 0x20] = 0x26; var temp7 = temp6 + 0x20; memory[temp7:temp7 + 0x26] = code[0x172b:0x1751]; var temp8 = memory[0x40:0x60]; revert(memory[temp8:temp8 + (temp7 + 0x40) - temp8]); } } else if (var4 >= arg5) { var0 = arg2; var1 = var4; var4 = var1; goto label_10D6; } else { var temp9 = memory[0x40:0x60]; memory[temp9:temp9 + 0x20] = 0x461bcd << 0xe5; var temp10 = temp9 + 0x04; var temp11 = temp10 + 0x20; memory[temp10:temp10 + 0x20] = temp11 - temp10; memory[temp11:temp11 + 0x20] = 0x26; var temp12 = temp11 + 0x20; memory[temp12:temp12 + 0x26] = code[0x16b8:0x16de]; var temp13 = memory[0x40:0x60]; revert(memory[temp13:temp13 + (temp12 + 0x40) - temp13]); } } else { label_100E: var0 = arg2; var1 = arg3; goto label_10D8; } } else if (var3) { goto label_1018; } else { goto label_100E; } } else { var temp14 = memory[0x40:0x60]; memory[temp14:temp14 + 0x20] = 0x64e329cb << 0xe1; var temp15 = (0x01 << 0xa0) - 0x01; memory[temp14 + 0x04:temp14 + 0x04 + 0x20] = temp15 & arg0; memory[temp14 + 0x24:temp14 + 0x24 + 0x20] = temp15 & arg1; var2 = temp15 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2; var3 = 0xc9c65396; var4 = temp14 + 0x44; var5 = 0x20; var6 = memory[0x40:0x60]; var7 = temp14 - var6 + 0x44; var8 = var6; var9 = 0x00; var10 = var2; var11 = !address(var10).code.length; if (var11) { revert(memory[0x00:0x00]); } var temp16; temp16, memory[var6:var6 + var5] = address(var10).call.gas(msg.gas).value(var9)(memory[var8:var8 + var7]); var5 = !temp16; if (!var5) { var2 = memory[0x40:0x60]; var3 = returndata.length; if (var3 >= 0x20) { goto label_0FC8; } else { revert(memory[0x00:0x00]); } } else { var temp17 = returndata.length; memory[0x00:0x00 + temp17] = returndata[0x00:0x00 + temp17]; revert(memory[0x00:0x00 + returndata.length]); } } } else { var temp18 = returndata.length; memory[0x00:0x00 + temp18] = returndata[0x00:0x00 + temp18]; revert(memory[0x00:0x00 + returndata.length]); } } function func_10E5(var arg0, var arg1, var arg2, var arg3) { var temp0 = memory[0x40:0x60]; var temp1 = (0x01 << 0xa0) - 0x01; memory[temp0 + 0x24:temp0 + 0x24 + 0x20] = temp1 & arg1; memory[temp0 + 0x44:temp0 + 0x44 + 0x20] = temp1 & arg2; memory[temp0 + 0x64:temp0 + 0x64 + 0x20] = arg3; var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = temp0 - temp2 + 0x64; memory[0x40:0x60] = temp0 + 0x84; var temp3 = temp2 + 0x20; memory[temp3:temp3 + 0x20] = (memory[temp3:temp3 + 0x20] & (0x01 << 0xe0) - 0x01) | (0x23b872dd << 0xe0); var var0 = 0x00; var var1 = 0x60; var var2 = arg0 & temp1; var var3 = temp2; var var4 = memory[0x40:0x60]; var var5 = var4; var var6 = temp3; var var7 = memory[var3:var3 + 0x20]; var var8 = var7; var var9 = var5; var var10 = var6; if (var8 < 0x20) { label_116A: 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_11FF: if (var2) { return; } var temp9 = memory[0x40:0x60]; memory[temp9:temp9 + 0x20] = 0x461bcd << 0xe5; var temp10 = temp9 + 0x04; var temp11 = temp10 + 0x20; memory[temp10:temp10 + 0x20] = temp11 - temp10; memory[temp11:temp11 + 0x20] = 0x24; var temp12 = temp11 + 0x20; memory[temp12:temp12 + 0x24] = code[0x1774:0x1798]; var temp13 = memory[0x40:0x60]; revert(memory[temp13:temp13 + (temp12 + 0x40) - temp13]); } else { label_11DE: var2 = !memory[var1:var1 + 0x20]; if (var2) { goto label_11FF; } var temp14 = var1; var2 = temp14 + 0x20; var3 = memory[temp14:temp14 + 0x20]; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var2 = memory[var2:var2 + 0x20]; goto label_11FF; } } else { var temp15 = memory[0x40:0x60]; var3 = temp15; memory[0x40:0x60] = var3 + (returndata.length + 0x3f & ~0x1f); memory[var3:var3 + 0x20] = returndata.length; var temp16 = returndata.length; memory[var3 + 0x20:var3 + 0x20 + temp16] = returndata[0x00:0x00 + temp16]; var1 = var3; var temp17 = var2; var0 = temp17; var2 = var0; if (!var2) { goto label_11FF; } else { goto label_11DE; } } } else { label_1154: var temp18 = var10; var temp19 = var9; memory[temp19:temp19 + 0x20] = memory[temp18:temp18 + 0x20]; var8 = var8 + ~0x1f; var9 = temp19 + 0x20; var10 = temp18 + 0x20; if (var8 < 0x20) { goto label_116A; } else { goto label_1154; } } } function func_1242(var arg0, var arg1) { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x00; var var0 = 0x00; memory[0x40:0x60] = temp0 + 0x20; var var1 = arg0 & (0x01 << 0xa0) - 0x01; var var2 = arg1; var var3 = temp0; var var4 = memory[0x40:0x60]; var var5 = var4; var var7 = memory[var3:var3 + 0x20]; var var6 = var3 + 0x20; var var8 = var7; var var9 = var5; var var10 = var6; if (var8 < 0x20) { label_128E: var temp1 = 0x0100 ** (0x20 - var8) - 0x01; var temp2 = var9; memory[temp2:temp2 + 0x20] = (memory[var10:var10 + 0x20] & ~temp1) | (memory[temp2:temp2 + 0x20] & temp1); var temp3 = memory[0x40:0x60]; var temp4; temp4, memory[temp3:temp3 + 0x00] = address(var1).call.gas(msg.gas).value(var2)(memory[temp3:temp3 + (var7 + var5) - temp3]); var2 = returndata.length; var3 = var2; if (var3 == 0x00) { var0 = var1; if (var0) { label_1335: return; } else { label_12FF: var temp5 = memory[0x40:0x60]; memory[temp5:temp5 + 0x20] = 0x461bcd << 0xe5; var temp6 = temp5 + 0x04; var temp7 = temp6 + 0x20; memory[temp6:temp6 + 0x20] = temp7 - temp6; memory[temp7:temp7 + 0x20] = 0x23; var temp8 = temp7 + 0x20; memory[temp8:temp8 + 0x23] = code[0x1751:0x1774]; var temp9 = memory[0x40:0x60]; revert(memory[temp9:temp9 + (temp8 + 0x40) - temp9]); } } else { var temp10 = memory[0x40:0x60]; var2 = temp10; memory[0x40:0x60] = var2 + (returndata.length + 0x3f & ~0x1f); memory[var2:var2 + 0x20] = returndata.length; var temp11 = returndata.length; memory[var2 + 0x20:var2 + 0x20 + temp11] = returndata[0x00:0x00 + temp11]; var0 = var1; if (var0) { goto label_1335; } else { goto label_12FF; } } } else { label_1278: var temp12 = var10; var temp13 = var9; memory[temp13:temp13 + 0x20] = memory[temp12:temp12 + 0x20]; var8 = var8 + ~0x1f; var9 = temp13 + 0x20; var10 = temp12 + 0x20; if (var8 < 0x20) { goto label_128E; } else { goto label_1278; } } } function func_133A(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = !arg1; if (var1) { label_1355: if (var1) { return var0; } var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x461bcd << 0xe5; memory[temp0 + 0x04:temp0 + 0x04 + 0x20] = 0x20; memory[temp0 + 0x24:temp0 + 0x24 + 0x20] = 0x14; memory[temp0 + 0x44:temp0 + 0x44 + 0x20] = 0x64732d6d6174682d6d756c2d6f766572666c6f77 << 0x60; var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + temp0 - temp1 + 0x64]); } else { var0 = arg0 * arg1; var1 = arg0; var var2 = arg1; var var3 = var0; if (!var2) { assert(); } var1 = var3 / var2 == var1; goto label_1355; } } function func_13EC(var arg0, var arg1, var arg2) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; var var2 = 0x00; var var3 = 0x13fb; var var4 = arg1; var var5 = arg2; var3, var4 = func_1588(var4, var5); var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0xe6a43905 << 0xe0; var temp1 = (0x01 << 0xa0) - 0x01; memory[temp0 + 0x04:temp0 + 0x04 + 0x20] = temp1 & arg1; memory[temp0 + 0x24:temp0 + 0x24 + 0x20] = temp1 & arg2; var2 = var3; var3 = 0x00; var4 = var3; var5 = arg0 & temp1; var var6 = 0xe6a43905; var var7 = temp0 + 0x44; var var8 = 0x20; var var9 = memory[0x40:0x60]; var var10 = temp0 - var9 + 0x44; var var11 = var9; var var12 = var5; var var13 = !address(var12).code.length; if (var13) { revert(memory[0x00:0x00]); } var temp2; temp2, memory[var9:var9 + var8] = address(var12).staticcall.gas(msg.gas)(memory[var11:var11 + var10]); var8 = !temp2; if (!var8) { var5 = memory[0x40:0x60]; var6 = returndata.length; if (var6 < 0x20) { revert(memory[0x00:0x00]); } var temp3 = memory[var5:var5 + 0x20]; var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = 0x0240bc6b << 0xe2; var5 = temp3 & (0x01 << 0xa0) - 0x01; var6 = 0x0902f1ac; var7 = temp4 + 0x04; var8 = 0x60; var9 = memory[0x40:0x60]; var10 = temp4 - var9 + 0x04; var11 = var9; var12 = var5; var13 = !address(var12).code.length; if (var13) { revert(memory[0x00:0x00]); } var temp5; temp5, memory[var9:var9 + var8] = address(var12).staticcall.gas(msg.gas)(memory[var11:var11 + var10]); var8 = !temp5; if (!var8) { var5 = memory[0x40:0x60]; var6 = returndata.length; if (var6 < 0x60) { revert(memory[0x00:0x00]); } var temp6 = var5; var3 = memory[temp6:temp6 + 0x20] & 0xffffffffffffffffffffffffffff; var4 = memory[temp6 + 0x20:temp6 + 0x20 + 0x20] & 0xffffffffffffffffffffffffffff; var temp7 = (0x01 << 0xa0) - 0x01; if (var2 & temp7 == temp7 & arg1) { r0 = var3; arg0 = var4; return r0, arg0; } else { var5 = var4; var6 = var3; r0 = var5; arg0 = var6; return r0, arg0; } } else { var temp8 = returndata.length; memory[0x00:0x00 + temp8] = returndata[0x00:0x00 + temp8]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp9 = returndata.length; memory[0x00:0x00 + temp9] = returndata[0x00:0x00 + temp9]; revert(memory[0x00:0x00 + returndata.length]); } } function func_1538(var arg0, var arg1) returns (var r0) { var temp0 = arg0; var var0 = temp0 - arg1; if (var0 <= temp0) { return var0; } var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x461bcd << 0xe5; memory[temp1 + 0x04:temp1 + 0x04 + 0x20] = 0x20; memory[temp1 + 0x24:temp1 + 0x24 + 0x20] = 0x15; memory[temp1 + 0x44:temp1 + 0x44 + 0x20] = 0x64732d6d6174682d7375622d756e646572666c6f77 << 0x58; var temp2 = memory[0x40:0x60]; revert(memory[temp2:temp2 + temp1 - temp2 + 0x64]); } function func_1588(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; if (arg0 & (0x01 << 0xa0) - 0x01 == arg1 & (0x01 << 0xa0) - 0x01) { 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] = 0x25; var temp5 = temp4 + 0x20; memory[temp5:temp5 + 0x25] = code[0x1693:0x16b8]; var temp6 = memory[0x40:0x60]; revert(memory[temp6:temp6 + (temp5 + 0x40) - temp6]); } else if (arg0 & (0x01 << 0xa0) - 0x01 < arg1 & (0x01 << 0xa0) - 0x01) { var0 = arg0; var1 = arg1; if (var0 & (0x01 << 0xa0) - 0x01) { label_165F: arg0 = var1; r0 = var0; return r0, arg0; } else { label_1613: var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x461bcd << 0xe5; memory[temp0 + 0x04:temp0 + 0x04 + 0x20] = 0x20; memory[temp0 + 0x24:temp0 + 0x24 + 0x20] = 0x1e; memory[temp0 + 0x44:temp0 + 0x44 + 0x20] = 0x556e697377617056324c6962726172793a205a45524f5f414444524553530000; var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + temp0 - temp1 + 0x64]); } } else { var var2 = arg1; var var3 = arg0; var0 = var2; var1 = var3; if (var0 & (0x01 << 0xa0) - 0x01) { goto label_165F; } else { goto label_1613; } } } }

Disassembly

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x008a 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x008a, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0xad615dec 0019 11 GT 001A 61 PUSH2 0x0059 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0059, if 0xad615dec > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0xad615dec > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xad615dec 0024 14 EQ 0025 61 PUSH2 0x027e 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x027e, if 0xad615dec == stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xad615dec == stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xc45a0155 002F 14 EQ 0030 61 PUSH2 0x02b4 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b4, if 0xc45a0155 == stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xc45a0155 == stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xd06ca61f 003A 14 EQ 003B 61 PUSH2 0x02c9 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c9, if 0xd06ca61f == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xd06ca61f == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe8e33700 0045 14 EQ 0046 61 PUSH2 0x0380 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0380, if 0xe8e33700 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xe8e33700 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xf305d719 0050 14 EQ 0051 61 PUSH2 0x0400 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0400, if 0xf305d719 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xf305d719 == stack[-1] 0055 61 PUSH2 0x00c3 0058 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00c3 label_0059: // Incoming jump from 0x001D, if 0xad615dec > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @005A stack[-1] } 0059 5B JUMPDEST 005A 80 DUP1 005B 63 PUSH4 0x054d50d4 0060 14 EQ 0061 61 PUSH2 0x00c8 0064 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00c8, if 0x054d50d4 == stack[-1] label_0065: // Incoming jump from 0x0064, if not 0x054d50d4 == stack[-1] // Inputs[1] { @0065 stack[-1] } 0065 80 DUP1 0066 63 PUSH4 0x1f00ca74 006B 14 EQ 006C 61 PUSH2 0x0110 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0110, if 0x1f00ca74 == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0x1f00ca74 == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0x85f8c259 0076 14 EQ 0077 61 PUSH2 0x0217 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0217, if 0x85f8c259 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0x85f8c259 == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xad5c4648 0081 14 EQ 0082 61 PUSH2 0x024d 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024d, if 0xad5c4648 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xad5c4648 == stack[-1] 0086 61 PUSH2 0x00c3 0089 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00c3 label_008A: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @008B msg.data.length } 008A 5B JUMPDEST 008B 36 CALLDATASIZE 008C 61 PUSH2 0x00c3 008F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00c3, if msg.data.length label_0090: // Incoming jump from 0x008F, if not msg.data.length // Inputs[1] { @0090 msg.sender } 0090 33 CALLER 0091 60 PUSH1 0x01 0093 60 PUSH1 0x01 0095 60 PUSH1 0xa0 0097 1B SHL 0098 03 SUB 0099 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 00BA 16 AND 00BB 14 EQ 00BC 61 PUSH2 0x00c1 00BF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00c1, if 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 & (0x01 << 0xa0) - 0x01 == msg.sender label_00C0: // Incoming jump from 0x00BF, if not 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 & (0x01 << 0xa0) - 0x01 == msg.sender 00C0 FE *ASSERT // Stack delta = +0 // Outputs[1] { @00C0 assert(); } // Block terminates label_00C1: // Incoming jump from 0x00BF, if 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 & (0x01 << 0xa0) - 0x01 == msg.sender 00C1 5B JUMPDEST 00C2 00 *STOP // Stack delta = +0 // Outputs[1] { @00C2 stop(); } // Block terminates label_00C3: // Incoming jump from 0x008F, if msg.data.length // Incoming jump from 0x0058 // Incoming jump from 0x0089 // Inputs[1] { @00C7 memory[0x00:0x00] } 00C3 5B JUMPDEST 00C4 60 PUSH1 0x00 00C6 80 DUP1 00C7 FD *REVERT // Stack delta = +0 // Outputs[1] { @00C7 revert(memory[0x00:0x00]); } // Block terminates label_00C8: // Incoming jump from 0x0064, if 0x054d50d4 == stack[-1] // Inputs[1] { @00C9 msg.value } 00C8 5B JUMPDEST 00C9 34 CALLVALUE 00CA 80 DUP1 00CB 15 ISZERO 00CC 61 PUSH2 0x00d4 00CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00C9 stack[0] = msg.value } // Block ends with conditional jump to 0x00d4, if !msg.value label_00D0: // Incoming jump from 0x00CF, if not !msg.value // Inputs[1] { @00D3 memory[0x00:0x00] } 00D0 60 PUSH1 0x00 00D2 80 DUP1 00D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @00D3 revert(memory[0x00:0x00]); } // Block terminates label_00D4: // Incoming jump from 0x00CF, if !msg.value // Inputs[1] { @00DC msg.data.length } 00D4 5B JUMPDEST 00D5 50 POP 00D6 61 PUSH2 0x00fe 00D9 60 PUSH1 0x04 00DB 80 DUP1 00DC 36 CALLDATASIZE 00DD 03 SUB 00DE 60 PUSH1 0x60 00E0 81 DUP2 00E1 10 LT 00E2 15 ISZERO 00E3 61 PUSH2 0x00eb 00E6 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @00D6 stack[-1] = 0x00fe // @00D9 stack[0] = 0x04 // @00DD stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x00eb, if !(msg.data.length - 0x04 < 0x60) label_00E7: // Incoming jump from 0x00E6, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @00EA memory[0x00:0x00] } 00E7 60 PUSH1 0x00 00E9 80 DUP1 00EA FD *REVERT // Stack delta = +0 // Outputs[1] { @00EA revert(memory[0x00:0x00]); } // Block terminates label_00EB: // Incoming jump from 0x00E6, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @00ED stack[-2] // @00EE msg.data[stack[-2]:stack[-2] + 0x20] // @00F4 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @00F9 msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 00EB 5B JUMPDEST 00EC 50 POP 00ED 80 DUP1 00EE 35 CALLDATALOAD 00EF 90 SWAP1 00F0 60 PUSH1 0x20 00F2 81 DUP2 00F3 01 ADD 00F4 35 CALLDATALOAD 00F5 90 SWAP1 00F6 60 PUSH1 0x40 00F8 01 ADD 00F9 35 CALLDATALOAD 00FA 61 PUSH2 0x0446 00FD 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @00EF stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @00F5 stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @00F9 stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0446 label_00FE: // Incoming return from call to 0x02A1 at 0x029C // Inputs[4] // { // @0102 memory[0x40:0x60] // @0103 stack[-1] // @0106 memory[0x40:0x60] // @010F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 00FE 5B JUMPDEST 00FF 60 PUSH1 0x40 0101 80 DUP1 0102 51 MLOAD 0103 91 SWAP2 0104 82 DUP3 0105 52 MSTORE 0106 51 MLOAD 0107 90 SWAP1 0108 81 DUP2 0109 90 SWAP1 010A 03 SUB 010B 60 PUSH1 0x20 010D 01 ADD 010E 90 SWAP1 010F F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0105 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @010F return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0110: // Incoming jump from 0x006F, if 0x1f00ca74 == stack[-1] // Inputs[1] { @0111 msg.value } 0110 5B JUMPDEST 0111 34 CALLVALUE 0112 80 DUP1 0113 15 ISZERO 0114 61 PUSH2 0x011c 0117 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0111 stack[0] = msg.value } // Block ends with conditional jump to 0x011c, if !msg.value label_0118: // Incoming jump from 0x0117, if not !msg.value // Inputs[1] { @011B memory[0x00:0x00] } 0118 60 PUSH1 0x00 011A 80 DUP1 011B FD *REVERT // Stack delta = +0 // Outputs[1] { @011B revert(memory[0x00:0x00]); } // Block terminates label_011C: // Incoming jump from 0x0117, if !msg.value // Inputs[1] { @0124 msg.data.length } 011C 5B JUMPDEST 011D 50 POP 011E 61 PUSH2 0x01c7 0121 60 PUSH1 0x04 0123 80 DUP1 0124 36 CALLDATASIZE 0125 03 SUB 0126 60 PUSH1 0x40 0128 81 DUP2 0129 10 LT 012A 15 ISZERO 012B 61 PUSH2 0x0133 012E 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @011E stack[-1] = 0x01c7 // @0121 stack[0] = 0x04 // @0125 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0133, returns to 0x01C7, if !(msg.data.length - 0x04 < 0x40) label_012F: // Incoming jump from 0x012E, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0132 memory[0x00:0x00] } 012F 60 PUSH1 0x00 0131 80 DUP1 0132 FD *REVERT // Stack delta = +0 // Outputs[1] { @0132 revert(memory[0x00:0x00]); } // Block terminates label_0133: // Incoming call from 0x012E, returns to 0x01C7, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0134 stack[-2] // @0135 msg.data[stack[-2]:stack[-2] + 0x20] // @0137 stack[-1] // @0143 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } 0133 5B JUMPDEST 0134 81 DUP2 0135 35 CALLDATALOAD 0136 91 SWAP2 0137 90 SWAP1 0138 81 DUP2 0139 01 ADD 013A 90 SWAP1 013B 60 PUSH1 0x40 013D 81 DUP2 013E 01 ADD 013F 60 PUSH1 0x20 0141 82 DUP3 0142 01 ADD 0143 35 CALLDATALOAD 0144 64 PUSH5 0x0100000000 014A 81 DUP2 014B 11 GT 014C 15 ISZERO 014D 61 PUSH2 0x0155 0150 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @0136 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @013A stack[0] = stack[-2] // @013A stack[-1] = stack[-2] + stack[-1] // @013E stack[1] = stack[-2] + 0x40 // @0143 stack[2] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x0155, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) label_0151: // Incoming jump from 0x0150, if not !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) // Inputs[1] { @0154 memory[0x00:0x00] } 0151 60 PUSH1 0x00 0153 80 DUP1 0154 FD *REVERT // Stack delta = +0 // Outputs[1] { @0154 revert(memory[0x00:0x00]); } // Block terminates label_0155: // Incoming jump from 0x0150, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) // Inputs[3] // { // @0156 stack[-3] // @0157 stack[-1] // @0158 stack[-4] // } 0155 5B JUMPDEST 0156 82 DUP3 0157 01 ADD 0158 83 DUP4 0159 60 PUSH1 0x20 015B 82 DUP3 015C 01 ADD 015D 11 GT 015E 15 ISZERO 015F 61 PUSH2 0x0167 0162 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0157 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0167, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0163: // Incoming jump from 0x0162, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0166 memory[0x00:0x00] } 0163 60 PUSH1 0x00 0165 80 DUP1 0166 FD *REVERT // Stack delta = +0 // Outputs[1] { @0166 revert(memory[0x00:0x00]); } // Block terminates label_0167: // Incoming jump from 0x0162, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0168 stack[-1] // @0169 msg.data[stack[-1]:stack[-1] + 0x20] // @016E stack[-2] // @016F stack[-4] // } 0167 5B JUMPDEST 0168 80 DUP1 0169 35 CALLDATALOAD 016A 90 SWAP1 016B 60 PUSH1 0x20 016D 01 ADD 016E 91 SWAP2 016F 84 DUP5 0170 60 PUSH1 0x20 0172 83 DUP4 0173 02 MUL 0174 84 DUP5 0175 01 ADD 0176 11 GT 0177 64 PUSH5 0x0100000000 017D 83 DUP4 017E 11 GT 017F 17 OR 0180 15 ISZERO 0181 61 PUSH2 0x0189 0184 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @016A stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @016E stack[0] = stack[-2] // @016E stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0189, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0185: // Incoming jump from 0x0184, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0188 memory[0x00:0x00] } 0185 60 PUSH1 0x00 0187 80 DUP1 0188 FD *REVERT // Stack delta = +0 // Outputs[1] { @0188 revert(memory[0x00:0x00]); } // Block terminates label_0189: // Incoming jump from 0x0184, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[7] // { // @018A stack[-3] // @018A stack[-1] // @018B stack[-2] // @0196 memory[0x40:0x60] // @01B0 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @01BB stack[-5] // @01C0 stack[-4] // } 0189 5B JUMPDEST 018A 91 SWAP2 018B 90 SWAP1 018C 80 DUP1 018D 80 DUP1 018E 60 PUSH1 0x20 0190 02 MUL 0191 60 PUSH1 0x20 0193 01 ADD 0194 60 PUSH1 0x40 0196 51 MLOAD 0197 90 SWAP1 0198 81 DUP2 0199 01 ADD 019A 60 PUSH1 0x40 019C 52 MSTORE 019D 80 DUP1 019E 93 SWAP4 019F 92 SWAP3 01A0 91 SWAP2 01A1 90 SWAP1 01A2 81 DUP2 01A3 81 DUP2 01A4 52 MSTORE 01A5 60 PUSH1 0x20 01A7 01 ADD 01A8 83 DUP4 01A9 83 DUP4 01AA 60 PUSH1 0x20 01AC 02 MUL 01AD 80 DUP1 01AE 82 DUP3 01AF 84 DUP5 01B0 37 CALLDATACOPY 01B1 60 PUSH1 0x00 01B3 92 SWAP3 01B4 01 ADD 01B5 91 SWAP2 01B6 90 SWAP1 01B7 91 SWAP2 01B8 52 MSTORE 01B9 50 POP 01BA 92 SWAP3 01BB 95 SWAP6 01BC 50 POP 01BD 61 PUSH2 0x045b 01C0 94 SWAP5 01C1 50 POP 01C2 50 POP 01C3 50 POP 01C4 50 POP 01C5 50 POP 01C6 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @019C memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @01A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @01B0 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @01B8 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @01BB stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x045b label_01C7: // Incoming return from call to 0x0133 at 0x012E // Incoming return from call to 0x02EC at 0x02E7 // Inputs[4] // { // @01CB memory[0x40:0x60] // @01D1 stack[-1] // @01D2 memory[stack[-1]:stack[-1] + 0x20] // @01D8 memory[stack[-1]:stack[-1] + 0x20] // } 01C7 5B JUMPDEST 01C8 60 PUSH1 0x40 01CA 80 DUP1 01CB 51 MLOAD 01CC 60 PUSH1 0x20 01CE 80 DUP1 01CF 82 DUP3 01D0 52 MSTORE 01D1 83 DUP4 01D2 51 MLOAD 01D3 81 DUP2 01D4 83 DUP4 01D5 01 ADD 01D6 52 MSTORE 01D7 83 DUP4 01D8 51 MLOAD 01D9 91 SWAP2 01DA 92 SWAP3 01DB 83 DUP4 01DC 92 SWAP3 01DD 90 SWAP1 01DE 83 DUP4 01DF 01 ADD 01E0 91 SWAP2 01E1 85 DUP6 01E2 81 DUP2 01E3 01 ADD 01E4 91 SWAP2 01E5 02 MUL 01E6 80 DUP1 01E7 83 DUP4 01E8 83 DUP4 01E9 60 PUSH1 0x00 01EB 5B JUMPDEST 01EC 83 DUP4 01ED 81 DUP2 01EE 10 LT 01EF 15 ISZERO 01F0 61 PUSH2 0x0203 01F3 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @01D0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @01D6 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @01DA stack[0] = memory[0x40:0x60] // @01DC stack[1] = memory[0x40:0x60] // @01E0 stack[2] = memory[0x40:0x60] + 0x40 // @01E4 stack[3] = 0x20 + stack[-1] // @01E5 stack[4] = memory[stack[-1]:stack[-1] + 0x20] * 0x20 // @01E6 stack[5] = memory[stack[-1]:stack[-1] + 0x20] * 0x20 // @01E7 stack[6] = memory[0x40:0x60] + 0x40 // @01E8 stack[7] = 0x20 + stack[-1] // @01E9 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0203, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20] * 0x20) label_01F4: // Incoming jump from 0x01F3, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20] * 0x20) // Incoming jump from 0x01F3, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @01F4 stack[-2] // @01F5 stack[-1] // @01F7 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @01F8 stack[-3] // } 01F4 81 DUP2 01F5 81 DUP2 01F6 01 ADD 01F7 51 MLOAD 01F8 83 DUP4 01F9 82 DUP3 01FA 01 ADD 01FB 52 MSTORE 01FC 60 PUSH1 0x20 01FE 01 ADD 01FF 61 PUSH2 0x01eb 0202 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01FB memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @01FE stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x01eb label_0203: // Incoming jump from 0x01F3, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20] * 0x20) // Incoming jump from 0x01F3, if !(stack[-1] < stack[-4]) // Inputs[6] // { // @0208 stack[-5] // @0208 stack[-6] // @020A stack[-7] // @020B stack[-10] // @0211 memory[0x40:0x60] // @0216 memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]] // } 0203 5B JUMPDEST 0204 50 POP 0205 50 POP 0206 50 POP 0207 50 POP 0208 90 SWAP1 0209 50 POP 020A 01 ADD 020B 92 SWAP3 020C 50 POP 020D 50 POP 020E 50 POP 020F 60 PUSH1 0x40 0211 51 MLOAD 0212 80 DUP1 0213 91 SWAP2 0214 03 SUB 0215 90 SWAP1 0216 F3 *RETURN // Stack delta = -10 // Outputs[1] { @0216 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]]; } // Block terminates label_0217: // Incoming jump from 0x007A, if 0x85f8c259 == stack[-1] // Inputs[1] { @0218 msg.value } 0217 5B JUMPDEST 0218 34 CALLVALUE 0219 80 DUP1 021A 15 ISZERO 021B 61 PUSH2 0x0223 021E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0218 stack[0] = msg.value } // Block ends with conditional jump to 0x0223, if !msg.value label_021F: // Incoming jump from 0x021E, if not !msg.value // Inputs[1] { @0222 memory[0x00:0x00] } 021F 60 PUSH1 0x00 0221 80 DUP1 0222 FD *REVERT // Stack delta = +0 // Outputs[1] { @0222 revert(memory[0x00:0x00]); } // Block terminates label_0223: // Incoming jump from 0x021E, if !msg.value // Inputs[1] { @022B msg.data.length } 0223 5B JUMPDEST 0224 50 POP 0225 61 PUSH2 0x00fe 0228 60 PUSH1 0x04 022A 80 DUP1 022B 36 CALLDATASIZE 022C 03 SUB 022D 60 PUSH1 0x60 022F 81 DUP2 0230 10 LT 0231 15 ISZERO 0232 61 PUSH2 0x023a 0235 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0225 stack[-1] = 0x00fe // @0228 stack[0] = 0x04 // @022C stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x023a, if !(msg.data.length - 0x04 < 0x60) label_0236: // Incoming jump from 0x0235, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0239 memory[0x00:0x00] } 0236 60 PUSH1 0x00 0238 80 DUP1 0239 FD *REVERT // Stack delta = +0 // Outputs[1] { @0239 revert(memory[0x00:0x00]); } // Block terminates label_023A: // Incoming jump from 0x0235, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @023C stack[-2] // @023D msg.data[stack[-2]:stack[-2] + 0x20] // @0243 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0248 msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 023A 5B JUMPDEST 023B 50 POP 023C 80 DUP1 023D 35 CALLDATALOAD 023E 90 SWAP1 023F 60 PUSH1 0x20 0241 81 DUP2 0242 01 ADD 0243 35 CALLDATALOAD 0244 90 SWAP1 0245 60 PUSH1 0x40 0247 01 ADD 0248 35 CALLDATALOAD 0249 61 PUSH2 0x0491 024C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @023E stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0244 stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0248 stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0491 label_024D: // Incoming jump from 0x0085, if 0xad5c4648 == stack[-1] // Inputs[1] { @024E msg.value } 024D 5B JUMPDEST 024E 34 CALLVALUE 024F 80 DUP1 0250 15 ISZERO 0251 61 PUSH2 0x0259 0254 57 *JUMPI // Stack delta = +1 // Outputs[1] { @024E stack[0] = msg.value } // Block ends with conditional jump to 0x0259, if !msg.value label_0255: // Incoming jump from 0x0254, if not !msg.value // Inputs[1] { @0258 memory[0x00:0x00] } 0255 60 PUSH1 0x00 0257 80 DUP1 0258 FD *REVERT // Stack delta = +0 // Outputs[1] { @0258 revert(memory[0x00:0x00]); } // Block terminates label_0259: // Incoming jump from 0x0254, if !msg.value 0259 5B JUMPDEST 025A 50 POP 025B 61 PUSH2 0x0262 025E 61 PUSH2 0x049e 0261 56 *JUMP // Stack delta = +0 // Outputs[1] { @025B stack[-1] = 0x0262 } // Block ends with call to 0x049e, returns to 0x0262 label_0262: // Incoming return from call to 0x049E at 0x0261 // Incoming return from call to 0x04CF at 0x02C8 // Inputs[4] // { // @0266 memory[0x40:0x60] // @0270 stack[-1] // @0274 memory[0x40:0x60] // @027D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0262 5B JUMPDEST 0263 60 PUSH1 0x40 0265 80 DUP1 0266 51 MLOAD 0267 60 PUSH1 0x01 0269 60 PUSH1 0x01 026B 60 PUSH1 0xa0 026D 1B SHL 026E 03 SUB 026F 90 SWAP1 0270 92 SWAP3 0271 16 AND 0272 82 DUP3 0273 52 MSTORE 0274 51 MLOAD 0275 90 SWAP1 0276 81 DUP2 0277 90 SWAP1 0278 03 SUB 0279 60 PUSH1 0x20 027B 01 ADD 027C 90 SWAP1 027D F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0273 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @027D return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_027E: // Incoming jump from 0x0028, if 0xad615dec == stack[-1] // Inputs[1] { @027F msg.value } 027E 5B JUMPDEST 027F 34 CALLVALUE 0280 80 DUP1 0281 15 ISZERO 0282 61 PUSH2 0x028a 0285 57 *JUMPI // Stack delta = +1 // Outputs[1] { @027F stack[0] = msg.value } // Block ends with conditional jump to 0x028a, if !msg.value label_0286: // Incoming jump from 0x0285, if not !msg.value // Inputs[1] { @0289 memory[0x00:0x00] } 0286 60 PUSH1 0x00 0288 80 DUP1 0289 FD *REVERT // Stack delta = +0 // Outputs[1] { @0289 revert(memory[0x00:0x00]); } // Block terminates label_028A: // Incoming jump from 0x0285, if !msg.value // Inputs[1] { @0292 msg.data.length } 028A 5B JUMPDEST 028B 50 POP 028C 61 PUSH2 0x00fe 028F 60 PUSH1 0x04 0291 80 DUP1 0292 36 CALLDATASIZE 0293 03 SUB 0294 60 PUSH1 0x60 0296 81 DUP2 0297 10 LT 0298 15 ISZERO 0299 61 PUSH2 0x02a1 029C 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @028C stack[-1] = 0x00fe // @028F stack[0] = 0x04 // @0293 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x02a1, returns to 0x00FE, if !(msg.data.length - 0x04 < 0x60) label_029D: // Incoming jump from 0x029C, if not !(msg.data.length - 0x04 < 0x60) // 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 call from 0x029C, returns to 0x00FE, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @02A3 stack[-2] // @02A4 msg.data[stack[-2]:stack[-2] + 0x20] // @02AA msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @02AF msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 02A1 5B JUMPDEST 02A2 50 POP 02A3 80 DUP1 02A4 35 CALLDATALOAD 02A5 90 SWAP1 02A6 60 PUSH1 0x20 02A8 81 DUP2 02A9 01 ADD 02AA 35 CALLDATALOAD 02AB 90 SWAP1 02AC 60 PUSH1 0x40 02AE 01 ADD 02AF 35 CALLDATALOAD 02B0 61 PUSH2 0x04c2 02B3 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @02A5 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @02AB stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @02AF stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x04c2 label_02B4: // Incoming jump from 0x0033, if 0xc45a0155 == stack[-1] // Inputs[1] { @02B5 msg.value } 02B4 5B JUMPDEST 02B5 34 CALLVALUE 02B6 80 DUP1 02B7 15 ISZERO 02B8 61 PUSH2 0x02c0 02BB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02B5 stack[0] = msg.value } // Block ends with conditional jump to 0x02c0, if !msg.value label_02BC: // Incoming jump from 0x02BB, if not !msg.value // Inputs[1] { @02BF memory[0x00:0x00] } 02BC 60 PUSH1 0x00 02BE 80 DUP1 02BF FD *REVERT // Stack delta = +0 // Outputs[1] { @02BF revert(memory[0x00:0x00]); } // Block terminates label_02C0: // Incoming jump from 0x02BB, if !msg.value 02C0 5B JUMPDEST 02C1 50 POP 02C2 61 PUSH2 0x0262 02C5 61 PUSH2 0x04cf 02C8 56 *JUMP // Stack delta = +0 // Outputs[1] { @02C2 stack[-1] = 0x0262 } // Block ends with call to 0x04cf, returns to 0x0262 label_02C9: // Incoming jump from 0x003E, if 0xd06ca61f == stack[-1] // Inputs[1] { @02CA msg.value } 02C9 5B JUMPDEST 02CA 34 CALLVALUE 02CB 80 DUP1 02CC 15 ISZERO 02CD 61 PUSH2 0x02d5 02D0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02CA stack[0] = msg.value } // Block ends with conditional jump to 0x02d5, if !msg.value label_02D1: // Incoming jump from 0x02D0, if not !msg.value // Inputs[1] { @02D4 memory[0x00:0x00] } 02D1 60 PUSH1 0x00 02D3 80 DUP1 02D4 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D4 revert(memory[0x00:0x00]); } // Block terminates label_02D5: // Incoming jump from 0x02D0, if !msg.value // Inputs[1] { @02DD msg.data.length } 02D5 5B JUMPDEST 02D6 50 POP 02D7 61 PUSH2 0x01c7 02DA 60 PUSH1 0x04 02DC 80 DUP1 02DD 36 CALLDATASIZE 02DE 03 SUB 02DF 60 PUSH1 0x40 02E1 81 DUP2 02E2 10 LT 02E3 15 ISZERO 02E4 61 PUSH2 0x02ec 02E7 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @02D7 stack[-1] = 0x01c7 // @02DA stack[0] = 0x04 // @02DE stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x02ec, returns to 0x01C7, if !(msg.data.length - 0x04 < 0x40) label_02E8: // Incoming jump from 0x02E7, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @02EB memory[0x00:0x00] } 02E8 60 PUSH1 0x00 02EA 80 DUP1 02EB FD *REVERT // Stack delta = +0 // Outputs[1] { @02EB revert(memory[0x00:0x00]); } // Block terminates label_02EC: // Incoming call from 0x02E7, returns to 0x01C7, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @02ED stack[-2] // @02EE msg.data[stack[-2]:stack[-2] + 0x20] // @02F0 stack[-1] // @02FC msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } 02EC 5B JUMPDEST 02ED 81 DUP2 02EE 35 CALLDATALOAD 02EF 91 SWAP2 02F0 90 SWAP1 02F1 81 DUP2 02F2 01 ADD 02F3 90 SWAP1 02F4 60 PUSH1 0x40 02F6 81 DUP2 02F7 01 ADD 02F8 60 PUSH1 0x20 02FA 82 DUP3 02FB 01 ADD 02FC 35 CALLDATALOAD 02FD 64 PUSH5 0x0100000000 0303 81 DUP2 0304 11 GT 0305 15 ISZERO 0306 61 PUSH2 0x030e 0309 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @02EF stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @02F3 stack[0] = stack[-2] // @02F3 stack[-1] = stack[-2] + stack[-1] // @02F7 stack[1] = stack[-2] + 0x40 // @02FC stack[2] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x030e, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) label_030A: // Incoming jump from 0x0309, if not !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) // Inputs[1] { @030D memory[0x00:0x00] } 030A 60 PUSH1 0x00 030C 80 DUP1 030D FD *REVERT // Stack delta = +0 // Outputs[1] { @030D revert(memory[0x00:0x00]); } // Block terminates label_030E: // Incoming jump from 0x0309, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) // Inputs[3] // { // @030F stack[-3] // @0310 stack[-1] // @0311 stack[-4] // } 030E 5B JUMPDEST 030F 82 DUP3 0310 01 ADD 0311 83 DUP4 0312 60 PUSH1 0x20 0314 82 DUP3 0315 01 ADD 0316 11 GT 0317 15 ISZERO 0318 61 PUSH2 0x0320 031B 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0310 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0320, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_031C: // Incoming jump from 0x031B, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @031F memory[0x00:0x00] } 031C 60 PUSH1 0x00 031E 80 DUP1 031F FD *REVERT // Stack delta = +0 // Outputs[1] { @031F revert(memory[0x00:0x00]); } // Block terminates label_0320: // Incoming jump from 0x031B, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0321 stack[-1] // @0322 msg.data[stack[-1]:stack[-1] + 0x20] // @0327 stack[-2] // @0328 stack[-4] // } 0320 5B JUMPDEST 0321 80 DUP1 0322 35 CALLDATALOAD 0323 90 SWAP1 0324 60 PUSH1 0x20 0326 01 ADD 0327 91 SWAP2 0328 84 DUP5 0329 60 PUSH1 0x20 032B 83 DUP4 032C 02 MUL 032D 84 DUP5 032E 01 ADD 032F 11 GT 0330 64 PUSH5 0x0100000000 0336 83 DUP4 0337 11 GT 0338 17 OR 0339 15 ISZERO 033A 61 PUSH2 0x0342 033D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0323 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0327 stack[0] = stack[-2] // @0327 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0342, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_033E: // Incoming jump from 0x033D, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0341 memory[0x00:0x00] } 033E 60 PUSH1 0x00 0340 80 DUP1 0341 FD *REVERT // Stack delta = +0 // Outputs[1] { @0341 revert(memory[0x00:0x00]); } // Block terminates label_0342: // Incoming jump from 0x033D, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[7] // { // @0343 stack[-3] // @0343 stack[-1] // @0344 stack[-2] // @034F memory[0x40:0x60] // @0369 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0374 stack[-5] // @0379 stack[-4] // } 0342 5B JUMPDEST 0343 91 SWAP2 0344 90 SWAP1 0345 80 DUP1 0346 80 DUP1 0347 60 PUSH1 0x20 0349 02 MUL 034A 60 PUSH1 0x20 034C 01 ADD 034D 60 PUSH1 0x40 034F 51 MLOAD 0350 90 SWAP1 0351 81 DUP2 0352 01 ADD 0353 60 PUSH1 0x40 0355 52 MSTORE 0356 80 DUP1 0357 93 SWAP4 0358 92 SWAP3 0359 91 SWAP2 035A 90 SWAP1 035B 81 DUP2 035C 81 DUP2 035D 52 MSTORE 035E 60 PUSH1 0x20 0360 01 ADD 0361 83 DUP4 0362 83 DUP4 0363 60 PUSH1 0x20 0365 02 MUL 0366 80 DUP1 0367 82 DUP3 0368 84 DUP5 0369 37 CALLDATACOPY 036A 60 PUSH1 0x00 036C 92 SWAP3 036D 01 ADD 036E 91 SWAP2 036F 90 SWAP1 0370 91 SWAP2 0371 52 MSTORE 0372 50 POP 0373 92 SWAP3 0374 95 SWAP6 0375 50 POP 0376 61 PUSH2 0x04f3 0379 94 SWAP5 037A 50 POP 037B 50 POP 037C 50 POP 037D 50 POP 037E 50 POP 037F 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0355 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @035D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0369 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0371 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @0374 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x04f3 label_0380: // Incoming jump from 0x0049, if 0xe8e33700 == stack[-1] // Inputs[1] { @0381 msg.value } 0380 5B JUMPDEST 0381 34 CALLVALUE 0382 80 DUP1 0383 15 ISZERO 0384 61 PUSH2 0x038c 0387 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0381 stack[0] = msg.value } // Block ends with conditional jump to 0x038c, if !msg.value label_0388: // Incoming jump from 0x0387, if not !msg.value // Inputs[1] { @038B memory[0x00:0x00] } 0388 60 PUSH1 0x00 038A 80 DUP1 038B FD *REVERT // Stack delta = +0 // Outputs[1] { @038B revert(memory[0x00:0x00]); } // Block terminates label_038C: // Incoming jump from 0x0387, if !msg.value // Inputs[1] { @0394 msg.data.length } 038C 5B JUMPDEST 038D 50 POP 038E 61 PUSH2 0x03e2 0391 60 PUSH1 0x04 0393 80 DUP1 0394 36 CALLDATASIZE 0395 03 SUB 0396 61 PUSH2 0x0100 0399 81 DUP2 039A 10 LT 039B 15 ISZERO 039C 61 PUSH2 0x03a4 039F 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @038E stack[-1] = 0x03e2 // @0391 stack[0] = 0x04 // @0395 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03a4, returns to 0x03E2, if !(msg.data.length - 0x04 < 0x0100) label_03A0: // Incoming jump from 0x039F, if not !(msg.data.length - 0x04 < 0x0100) // Inputs[1] { @03A3 memory[0x00:0x00] } 03A0 60 PUSH1 0x00 03A2 80 DUP1 03A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @03A3 revert(memory[0x00:0x00]); } // Block terminates label_03A4: // Incoming call from 0x039F, returns to 0x03E2, if !(msg.data.length - 0x04 < 0x0100) // Inputs[9] // { // @03AE stack[-2] // @03AF msg.data[stack[-2]:stack[-2] + 0x20] // @03B7 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @03BF msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @03C5 msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @03CB msg.data[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] // @03D1 msg.data[stack[-2] + 0xa0:stack[-2] + 0xa0 + 0x20] // @03D7 msg.data[stack[-2] + 0xc0:stack[-2] + 0xc0 + 0x20] // @03DD msg.data[0xe0 + stack[-2]:0xe0 + stack[-2] + 0x20] // } 03A4 5B JUMPDEST 03A5 50 POP 03A6 60 PUSH1 0x01 03A8 60 PUSH1 0x01 03AA 60 PUSH1 0xa0 03AC 1B SHL 03AD 03 SUB 03AE 81 DUP2 03AF 35 CALLDATALOAD 03B0 81 DUP2 03B1 16 AND 03B2 91 SWAP2 03B3 60 PUSH1 0x20 03B5 81 DUP2 03B6 01 ADD 03B7 35 CALLDATALOAD 03B8 82 DUP3 03B9 16 AND 03BA 91 SWAP2 03BB 60 PUSH1 0x40 03BD 82 DUP3 03BE 01 ADD 03BF 35 CALLDATALOAD 03C0 91 SWAP2 03C1 60 PUSH1 0x60 03C3 81 DUP2 03C4 01 ADD 03C5 35 CALLDATALOAD 03C6 91 SWAP2 03C7 60 PUSH1 0x80 03C9 82 DUP3 03CA 01 ADD 03CB 35 CALLDATALOAD 03CC 91 SWAP2 03CD 60 PUSH1 0xa0 03CF 81 DUP2 03D0 01 ADD 03D1 35 CALLDATALOAD 03D2 91 SWAP2 03D3 60 PUSH1 0xc0 03D5 82 DUP3 03D6 01 ADD 03D7 35 CALLDATALOAD 03D8 16 AND 03D9 90 SWAP1 03DA 60 PUSH1 0xe0 03DC 01 ADD 03DD 35 CALLDATALOAD 03DE 61 PUSH2 0x0520 03E1 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @03B2 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @03BA stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @03C0 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @03C6 stack[1] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @03CC stack[2] = msg.data[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] // @03D2 stack[3] = msg.data[stack[-2] + 0xa0:stack[-2] + 0xa0 + 0x20] // @03D9 stack[4] = msg.data[stack[-2] + 0xc0:stack[-2] + 0xc0 + 0x20] & (0x01 << 0xa0) - 0x01 // @03DD stack[5] = msg.data[0xe0 + stack[-2]:0xe0 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0520 label_03E2: // Incoming return from call to 0x0416 at 0x0411 // Incoming return from call to 0x03A4 at 0x039F // Inputs[6] // { // @03E6 memory[0x40:0x60] // @03E7 stack[-3] // @03EE stack[-2] // @03F5 stack[-1] // @03F6 memory[0x40:0x60] // @03FF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x60 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 03E2 5B JUMPDEST 03E3 60 PUSH1 0x40 03E5 80 DUP1 03E6 51 MLOAD 03E7 93 SWAP4 03E8 84 DUP5 03E9 52 MSTORE 03EA 60 PUSH1 0x20 03EC 84 DUP5 03ED 01 ADD 03EE 92 SWAP3 03EF 90 SWAP1 03F0 92 SWAP3 03F1 52 MSTORE 03F2 82 DUP3 03F3 82 DUP3 03F4 01 ADD 03F5 52 MSTORE 03F6 51 MLOAD 03F7 90 SWAP1 03F8 81 DUP2 03F9 90 SWAP1 03FA 03 SUB 03FB 60 PUSH1 0x60 03FD 01 ADD 03FE 90 SWAP1 03FF F3 *RETURN // Stack delta = -3 // Outputs[4] // { // @03E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @03F1 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-2] // @03F5 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-1] // @03FF return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x60 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0400: // Incoming jump from 0x0054, if 0xf305d719 == stack[-1] // Inputs[1] { @0407 msg.data.length } 0400 5B JUMPDEST 0401 61 PUSH2 0x03e2 0404 60 PUSH1 0x04 0406 80 DUP1 0407 36 CALLDATASIZE 0408 03 SUB 0409 60 PUSH1 0xc0 040B 81 DUP2 040C 10 LT 040D 15 ISZERO 040E 61 PUSH2 0x0416 0411 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0401 stack[0] = 0x03e2 // @0404 stack[1] = 0x04 // @0408 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0416, returns to 0x03E2, if !(msg.data.length - 0x04 < 0xc0) label_0412: // Incoming jump from 0x0411, if not !(msg.data.length - 0x04 < 0xc0) // Inputs[1] { @0415 memory[0x00:0x00] } 0412 60 PUSH1 0x00 0414 80 DUP1 0415 FD *REVERT // Stack delta = +0 // Outputs[1] { @0415 revert(memory[0x00:0x00]); } // Block terminates label_0416: // Incoming call from 0x0411, returns to 0x03E2, if !(msg.data.length - 0x04 < 0xc0) // Inputs[7] // { // @0420 stack[-2] // @0421 msg.data[stack[-2]:stack[-2] + 0x20] // @0429 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @042F msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0435 msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @043B msg.data[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] // @0441 msg.data[0xa0 + stack[-2]:0xa0 + stack[-2] + 0x20] // } 0416 5B JUMPDEST 0417 50 POP 0418 60 PUSH1 0x01 041A 60 PUSH1 0x01 041C 60 PUSH1 0xa0 041E 1B SHL 041F 03 SUB 0420 81 DUP2 0421 35 CALLDATALOAD 0422 81 DUP2 0423 16 AND 0424 91 SWAP2 0425 60 PUSH1 0x20 0427 81 DUP2 0428 01 ADD 0429 35 CALLDATALOAD 042A 91 SWAP2 042B 60 PUSH1 0x40 042D 82 DUP3 042E 01 ADD 042F 35 CALLDATALOAD 0430 91 SWAP2 0431 60 PUSH1 0x60 0433 81 DUP2 0434 01 ADD 0435 35 CALLDATALOAD 0436 91 SWAP2 0437 60 PUSH1 0x80 0439 82 DUP3 043A 01 ADD 043B 35 CALLDATALOAD 043C 16 AND 043D 90 SWAP1 043E 60 PUSH1 0xa0 0440 01 ADD 0441 35 CALLDATALOAD 0442 61 PUSH2 0x068c 0445 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0424 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @042A stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0430 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0436 stack[1] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @043D stack[2] = msg.data[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] & (0x01 << 0xa0) - 0x01 // @0441 stack[3] = msg.data[0xa0 + stack[-2]:0xa0 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x068c label_0446: // Incoming jump from 0x00FD // Inputs[3] // { // @044C stack[-3] // @044D stack[-2] // @044E stack[-1] // } 0446 5B JUMPDEST 0447 60 PUSH1 0x00 0449 61 PUSH2 0x0453 044C 84 DUP5 044D 84 DUP5 044E 84 DUP5 044F 61 PUSH2 0x0961 0452 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0447 stack[0] = 0x00 // @0449 stack[1] = 0x0453 // @044C stack[2] = stack[-3] // @044D stack[3] = stack[-2] // @044E stack[4] = stack[-1] // } // Block ends with call to 0x0961, returns to 0x0453 label_0453: // Incoming return from call to 0x0961 at 0x0452 // Incoming return from call to 0x0B9E at 0x049D // Incoming return from call to 0x0C8E at 0x04CE // Inputs[3] // { // @0454 stack[-1] // @0454 stack[-6] // @0455 stack[-5] // } 0453 5B JUMPDEST 0454 94 SWAP5 0455 93 SWAP4 0456 50 POP 0457 50 POP 0458 50 POP 0459 50 POP 045A 56 *JUMP // Stack delta = -5 // Outputs[1] { @0454 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_045B: // Incoming jump from 0x01C6 // Inputs[2] // { // @0482 stack[-2] // @0483 stack[-1] // } 045B 5B JUMPDEST 045C 60 PUSH1 0x60 045E 61 PUSH2 0x0488 0461 7F PUSH32 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 0482 84 DUP5 0483 84 DUP5 0484 61 PUSH2 0x0a51 0487 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @045C stack[0] = 0x60 // @045E stack[1] = 0x0488 // @0461 stack[2] = 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 // @0482 stack[3] = stack[-2] // @0483 stack[4] = stack[-1] // } // Block ends with call to 0x0a51, returns to 0x0488 label_0488: // Incoming return from call to 0x0A51 at 0x0487 // Incoming return from call to 0x0D3A at 0x051F // Inputs[2] // { // @0489 stack[-1] // @0489 stack[-2] // } 0488 5B JUMPDEST 0489 90 SWAP1 048A 50 POP // Stack delta = -1 // Outputs[1] { @0489 stack[-2] = stack[-1] } // Block continues label_048B: // Incoming jump from 0x1543, if !(stack[-2] - stack[-1] > stack[-2]) // Incoming jump from 0x13A8, if !(stack[-2] + stack[-1] < stack[-2]) // Incoming jump from 0x048A // Incoming jump from 0x1359, if stack[-1] // Inputs[3] // { // @048C stack[-1] // @048C stack[-4] // @048D stack[-3] // } 048B 5B JUMPDEST 048C 92 SWAP3 048D 91 SWAP2 048E 50 POP 048F 50 POP 0490 56 *JUMP // Stack delta = -3 // Outputs[1] { @048C stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0491: // Incoming jump from 0x024C // Inputs[3] // { // @0497 stack[-3] // @0498 stack[-2] // @0499 stack[-1] // } 0491 5B JUMPDEST 0492 60 PUSH1 0x00 0494 61 PUSH2 0x0453 0497 84 DUP5 0498 84 DUP5 0499 84 DUP5 049A 61 PUSH2 0x0b9e 049D 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0492 stack[0] = 0x00 // @0494 stack[1] = 0x0453 // @0497 stack[2] = stack[-3] // @0498 stack[3] = stack[-2] // @0499 stack[4] = stack[-1] // } // Block ends with call to 0x0b9e, returns to 0x0453 label_049E: // Incoming call from 0x0261, returns to 0x0262 // Inputs[1] { @04C0 stack[-1] } 049E 5B JUMPDEST 049F 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 04C0 81 DUP2 04C1 56 *JUMP // Stack delta = +1 // Outputs[1] { @049F stack[0] = 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 } // Block ends with unconditional jump to stack[-1] label_04C2: // Incoming jump from 0x02B3 // Inputs[3] // { // @04C8 stack[-3] // @04C9 stack[-2] // @04CA stack[-1] // } 04C2 5B JUMPDEST 04C3 60 PUSH1 0x00 04C5 61 PUSH2 0x0453 04C8 84 DUP5 04C9 84 DUP5 04CA 84 DUP5 04CB 61 PUSH2 0x0c8e 04CE 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @04C3 stack[0] = 0x00 // @04C5 stack[1] = 0x0453 // @04C8 stack[2] = stack[-3] // @04C9 stack[3] = stack[-2] // @04CA stack[4] = stack[-1] // } // Block ends with call to 0x0c8e, returns to 0x0453 label_04CF: // Incoming call from 0x02C8, returns to 0x0262 // Inputs[1] { @04F1 stack[-1] } 04CF 5B JUMPDEST 04D0 7F PUSH32 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 04F1 81 DUP2 04F2 56 *JUMP // Stack delta = +1 // Outputs[1] { @04D0 stack[0] = 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 } // Block ends with unconditional jump to stack[-1] label_04F3: // Incoming jump from 0x037F // Inputs[2] // { // @051A stack[-2] // @051B stack[-1] // } 04F3 5B JUMPDEST 04F4 60 PUSH1 0x60 04F6 61 PUSH2 0x0488 04F9 7F PUSH32 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 051A 84 DUP5 051B 84 DUP5 051C 61 PUSH2 0x0d3a 051F 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @04F4 stack[0] = 0x60 // @04F6 stack[1] = 0x0488 // @04F9 stack[2] = 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 // @051A stack[3] = stack[-2] // @051B stack[4] = stack[-1] // } // Block ends with call to 0x0d3a, returns to 0x0488 label_0520: // Incoming jump from 0x03E1 // Inputs[6] // { // @0529 stack[-8] // @052A stack[-7] // @052B stack[-6] // @052C stack[-5] // @052D stack[-4] // @052E stack[-3] // } 0520 5B JUMPDEST 0521 60 PUSH1 0x00 0523 80 DUP1 0524 60 PUSH1 0x00 0526 61 PUSH2 0x0533 0529 8B DUP12 052A 8B DUP12 052B 8B DUP12 052C 8B DUP12 052D 8B DUP12 052E 8B DUP12 052F 61 PUSH2 0x0e71 0532 56 *JUMP // Stack delta = +10 // Outputs[10] // { // @0521 stack[0] = 0x00 // @0523 stack[1] = 0x00 // @0524 stack[2] = 0x00 // @0526 stack[3] = 0x0533 // @0529 stack[4] = stack[-8] // @052A stack[5] = stack[-7] // @052B stack[6] = stack[-6] // @052C stack[7] = stack[-5] // @052D stack[8] = stack[-4] // @052E stack[9] = stack[-3] // } // Block ends with call to 0x0e71, returns to 0x0533 label_0533: // Incoming return from call to 0x0E71 at 0x0532 // Inputs[9] // { // @0537 memory[0x40:0x60] // @054A stack[-13] // @0552 stack[-12] // @055B memory[0x40:0x60] // @055C stack[-2] // @055D stack[-5] // @055F stack[-1] // @0560 stack[-4] // @05A2 address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length // } 0533 5B JUMPDEST 0534 60 PUSH1 0x40 0536 80 DUP1 0537 51 MLOAD 0538 63 PUSH4 0xe6a43905 053D 60 PUSH1 0xe0 053F 1B SHL 0540 81 DUP2 0541 52 MSTORE 0542 60 PUSH1 0x01 0544 60 PUSH1 0x01 0546 60 PUSH1 0xa0 0548 1B SHL 0549 03 SUB 054A 8F DUP16 054B 81 DUP2 054C 16 AND 054D 60 PUSH1 0x04 054F 83 DUP4 0550 01 ADD 0551 52 MSTORE 0552 8E DUP15 0553 81 DUP2 0554 16 AND 0555 60 PUSH1 0x24 0557 83 DUP4 0558 01 ADD 0559 52 MSTORE 055A 91 SWAP2 055B 51 MLOAD 055C 93 SWAP4 055D 96 SWAP7 055E 50 POP 055F 91 SWAP2 0560 94 SWAP5 0561 50 POP 0562 60 PUSH1 0x00 0564 92 SWAP3 0565 7F PUSH32 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 0586 90 SWAP1 0587 91 SWAP2 0588 16 AND 0589 91 SWAP2 058A 63 PUSH4 0xe6a43905 058F 91 SWAP2 0590 60 PUSH1 0x44 0592 80 DUP1 0593 83 DUP4 0594 01 ADD 0595 92 SWAP3 0596 60 PUSH1 0x20 0598 92 SWAP3 0599 91 SWAP2 059A 90 SWAP1 059B 82 DUP3 059C 90 SWAP1 059D 03 SUB 059E 01 ADD 059F 81 DUP2 05A0 86 DUP7 05A1 80 DUP1 05A2 3B EXTCODESIZE 05A3 15 ISZERO 05A4 80 DUP1 05A5 15 ISZERO 05A6 61 PUSH2 0x05ae 05A9 57 *JUMPI // Stack delta = +8 // Outputs[15] // { // @0541 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xe6a43905 << 0xe0 // @0551 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-13] // @0559 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-12] // @055D stack[-5] = stack[-2] // @0560 stack[-4] = stack[-1] // @0564 stack[-2] = 0x00 // @0589 stack[-1] = (0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 // @058F stack[0] = 0xe6a43905 // @0595 stack[1] = memory[0x40:0x60] + 0x44 // @0598 stack[2] = 0x20 // @0599 stack[3] = memory[0x40:0x60] // @059E stack[4] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @059F stack[5] = memory[0x40:0x60] // @05A0 stack[6] = (0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 // @05A3 stack[7] = !address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length // } // Block ends with conditional jump to 0x05ae, if !!address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length label_05AA: // Incoming jump from 0x05A9, if not !!address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length // Inputs[1] { @05AD memory[0x00:0x00] } 05AA 60 PUSH1 0x00 05AC 80 DUP1 05AD FD *REVERT // Stack delta = +0 // Outputs[1] { @05AD revert(memory[0x00:0x00]); } // Block terminates label_05AE: // Incoming jump from 0x05A9, if !!address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length // Inputs[8] // { // @05B0 msg.gas // @05B1 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @05B1 stack[-5] // @05B1 memory[stack[-3]:stack[-3] + stack[-4]] // @05B1 stack[-3] // @05B1 stack[-6] // @05B1 stack[-4] // @05B1 stack[-2] // } 05AE 5B JUMPDEST 05AF 50 POP 05B0 5A GAS 05B1 FA STATICCALL 05B2 15 ISZERO 05B3 80 DUP1 05B4 15 ISZERO 05B5 61 PUSH2 0x05c2 05B8 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @05B1 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @05B2 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x05c2, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_05B9: // Incoming jump from 0x05B8, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @05B9 returndata.length // @05BD returndata[0x00:0x00 + returndata.length] // @05BE returndata.length // @05C1 memory[0x00:0x00 + returndata.length] // } 05B9 3D RETURNDATASIZE 05BA 60 PUSH1 0x00 05BC 80 DUP1 05BD 3E RETURNDATACOPY 05BE 3D RETURNDATASIZE 05BF 60 PUSH1 0x00 05C1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @05BD memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @05C1 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_05C2: // Incoming jump from 0x05B8, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @05C9 memory[0x40:0x60] // @05CA returndata.length // } 05C2 5B JUMPDEST 05C3 50 POP 05C4 50 POP 05C5 50 POP 05C6 50 POP 05C7 60 PUSH1 0x40 05C9 51 MLOAD 05CA 3D RETURNDATASIZE 05CB 60 PUSH1 0x20 05CD 81 DUP2 05CE 10 LT 05CF 15 ISZERO 05D0 61 PUSH2 0x05d8 05D3 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @05C9 stack[-4] = memory[0x40:0x60] // @05CA stack[-3] = returndata.length // } // Block ends with conditional jump to 0x05d8, if !(returndata.length < 0x20) label_05D4: // Incoming jump from 0x05D3, if not !(returndata.length < 0x20) // Inputs[1] { @05D7 memory[0x00:0x00] } 05D4 60 PUSH1 0x00 05D6 80 DUP1 05D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @05D7 revert(memory[0x00:0x00]); } // Block terminates label_05D8: // Incoming jump from 0x05D3, if !(returndata.length < 0x20) // Inputs[6] // { // @05DA stack[-2] // @05DA memory[stack[-2]:stack[-2] + 0x20] // @05DB stack[-3] // @05E0 stack[-14] // @05E1 msg.sender // @05E3 stack[-6] // } 05D8 5B JUMPDEST 05D9 50 POP 05DA 51 MLOAD 05DB 90 SWAP1 05DC 50 POP 05DD 61 PUSH2 0x05e8 05E0 8C DUP13 05E1 33 CALLER 05E2 83 DUP4 05E3 87 DUP8 05E4 61 PUSH2 0x10e5 05E7 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @05DB stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @05DD stack[-2] = 0x05e8 // @05E0 stack[-1] = stack[-14] // @05E1 stack[0] = msg.sender // @05E2 stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @05E3 stack[2] = stack[-6] // } // Block ends with call to 0x10e5, returns to 0x05E8 label_05E8: // Incoming return from call to 0x10E5 at 0x05E7 // Inputs[4] // { // @05EC stack[-11] // @05ED msg.sender // @05EE stack[-1] // @05EF stack[-3] // } 05E8 5B JUMPDEST 05E9 61 PUSH2 0x05f4 05EC 8B DUP12 05ED 33 CALLER 05EE 83 DUP4 05EF 86 DUP7 05F0 61 PUSH2 0x10e5 05F3 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @05E9 stack[0] = 0x05f4 // @05EC stack[1] = stack[-11] // @05ED stack[2] = msg.sender // @05EE stack[3] = stack[-1] // @05EF stack[4] = stack[-3] // } // Block ends with call to 0x10e5, returns to 0x05F4 label_05F4: // Incoming return from call to 0x10E5 at 0x05F3 // Inputs[5] // { // @05F5 stack[-1] // @0604 stack[-6] // @0607 memory[0x40:0x60] // @0637 memory[0x40:0x60] // @0640 address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // } 05F4 5B JUMPDEST 05F5 80 DUP1 05F6 60 PUSH1 0x01 05F8 60 PUSH1 0x01 05FA 60 PUSH1 0xa0 05FC 1B SHL 05FD 03 SUB 05FE 16 AND 05FF 63 PUSH4 0x6a627842 0604 87 DUP8 0605 60 PUSH1 0x40 0607 51 MLOAD 0608 82 DUP3 0609 63 PUSH4 0xffffffff 060E 16 AND 060F 60 PUSH1 0xe0 0611 1B SHL 0612 81 DUP2 0613 52 MSTORE 0614 60 PUSH1 0x04 0616 01 ADD 0617 80 DUP1 0618 82 DUP3 0619 60 PUSH1 0x01 061B 60 PUSH1 0x01 061D 60 PUSH1 0xa0 061F 1B SHL 0620 03 SUB 0621 16 AND 0622 60 PUSH1 0x01 0624 60 PUSH1 0x01 0626 60 PUSH1 0xa0 0628 1B SHL 0629 03 SUB 062A 16 AND 062B 81 DUP2 062C 52 MSTORE 062D 60 PUSH1 0x20 062F 01 ADD 0630 91 SWAP2 0631 50 POP 0632 50 POP 0633 60 PUSH1 0x20 0635 60 PUSH1 0x40 0637 51 MLOAD 0638 80 DUP1 0639 83 DUP4 063A 03 SUB 063B 81 DUP2 063C 60 PUSH1 0x00 063E 87 DUP8 063F 80 DUP1 0640 3B EXTCODESIZE 0641 15 ISZERO 0642 80 DUP1 0643 15 ISZERO 0644 61 PUSH2 0x064c 0647 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @05FE stack[0] = (0x01 << 0xa0) - 0x01 & stack[-1] // @05FF stack[1] = 0x6a627842 // @0613 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x6a627842) << 0xe0 // @062C memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-6] // @0630 stack[2] = 0x20 + 0x04 + memory[0x40:0x60] // @0633 stack[3] = 0x20 // @0637 stack[4] = memory[0x40:0x60] // @063A stack[5] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @063B stack[6] = memory[0x40:0x60] // @063C stack[7] = 0x00 // @063E stack[8] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0641 stack[9] = !address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // } // Block ends with conditional jump to 0x064c, if !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length label_0648: // Incoming jump from 0x0647, if not !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // Inputs[1] { @064B memory[0x00:0x00] } 0648 60 PUSH1 0x00 064A 80 DUP1 064B FD *REVERT // Stack delta = +0 // Outputs[1] { @064B revert(memory[0x00:0x00]); } // Block terminates label_064C: // Incoming jump from 0x0647, if !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // Inputs[9] // { // @064E msg.gas // @064F stack[-4] // @064F stack[-7] // @064F address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @064F stack[-6] // @064F memory[stack[-4]:stack[-4] + stack[-5]] // @064F stack[-3] // @064F stack[-2] // @064F stack[-5] // } 064C 5B JUMPDEST 064D 50 POP 064E 5A GAS 064F F1 CALL 0650 15 ISZERO 0651 80 DUP1 0652 15 ISZERO 0653 61 PUSH2 0x0660 0656 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @064F memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0650 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 0x0660, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0657: // Incoming jump from 0x0656, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0657 returndata.length // @065B returndata[0x00:0x00 + returndata.length] // @065C returndata.length // @065F memory[0x00:0x00 + returndata.length] // } 0657 3D RETURNDATASIZE 0658 60 PUSH1 0x00 065A 80 DUP1 065B 3E RETURNDATACOPY 065C 3D RETURNDATASIZE 065D 60 PUSH1 0x00 065F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @065B memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @065F revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0660: // Incoming jump from 0x0656, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @0667 memory[0x40:0x60] // @0668 returndata.length // } 0660 5B JUMPDEST 0661 50 POP 0662 50 POP 0663 50 POP 0664 50 POP 0665 60 PUSH1 0x40 0667 51 MLOAD 0668 3D RETURNDATASIZE 0669 60 PUSH1 0x20 066B 81 DUP2 066C 10 LT 066D 15 ISZERO 066E 61 PUSH2 0x0676 0671 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0667 stack[-4] = memory[0x40:0x60] // @0668 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0676, if !(returndata.length < 0x20) label_0672: // Incoming jump from 0x0671, if not !(returndata.length < 0x20) // Inputs[1] { @0675 memory[0x00:0x00] } 0672 60 PUSH1 0x00 0674 80 DUP1 0675 FD *REVERT // Stack delta = +0 // Outputs[1] { @0675 revert(memory[0x00:0x00]); } // Block terminates label_0676: // Incoming jump from 0x0671, if !(returndata.length < 0x20) // Inputs[10] // { // @0678 memory[stack[-2]:stack[-2] + 0x20] // @0678 stack[-2] // @0679 stack[-6] // @067A stack[-15] // @067B stack[-5] // @067C stack[-14] // @067E stack[-3] // @067F stack[-13] // @0681 stack[-4] // @0682 stack[-12] // } 0676 5B JUMPDEST 0677 50 POP 0678 51 MLOAD 0679 93 SWAP4 067A 9C SWAP13 067B 92 SWAP3 067C 9B SWAP12 067D 50 POP 067E 92 SWAP3 067F 99 SWAP10 0680 50 POP 0681 90 SWAP1 0682 97 SWAP8 0683 50 POP 0684 50 POP 0685 50 POP 0686 50 POP 0687 50 POP 0688 50 POP 0689 50 POP 068A 50 POP 068B 56 *JUMP // Stack delta = -12 // Outputs[3] // { // @067A stack[-15] = stack[-6] // @067C stack[-14] = stack[-5] // @067F stack[-13] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with unconditional jump to stack[-15] label_068C: // Incoming jump from 0x0445 // Inputs[5] // { // @0695 stack[-6] // @06B7 stack[-5] // @06B8 msg.value // @06B9 stack[-4] // @06BA stack[-3] // } 068C 5B JUMPDEST 068D 60 PUSH1 0x00 068F 80 DUP1 0690 60 PUSH1 0x00 0692 61 PUSH2 0x06bf 0695 89 DUP10 0696 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 06B7 8A DUP11 06B8 34 CALLVALUE 06B9 8B DUP12 06BA 8B DUP12 06BB 61 PUSH2 0x0e71 06BE 56 *JUMP // Stack delta = +10 // Outputs[10] // { // @068D stack[0] = 0x00 // @068F stack[1] = 0x00 // @0690 stack[2] = 0x00 // @0692 stack[3] = 0x06bf // @0695 stack[4] = stack[-6] // @0696 stack[5] = 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @06B7 stack[6] = stack[-5] // @06B8 stack[7] = msg.value // @06B9 stack[8] = stack[-4] // @06BA stack[9] = stack[-3] // } // Block ends with call to 0x0e71, returns to 0x06BF label_06BF: // Incoming return from call to 0x0E71 at 0x06BE // Inputs[8] // { // @06C3 memory[0x40:0x60] // @06D6 stack[-11] // @0707 memory[0x40:0x60] // @0708 stack[-2] // @0709 stack[-5] // @070B stack[-1] // @070C stack[-4] // @074E address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length // } 06BF 5B JUMPDEST 06C0 60 PUSH1 0x40 06C2 80 DUP1 06C3 51 MLOAD 06C4 63 PUSH4 0xe6a43905 06C9 60 PUSH1 0xe0 06CB 1B SHL 06CC 81 DUP2 06CD 52 MSTORE 06CE 60 PUSH1 0x01 06D0 60 PUSH1 0x01 06D2 60 PUSH1 0xa0 06D4 1B SHL 06D5 03 SUB 06D6 8D DUP14 06D7 81 DUP2 06D8 16 AND 06D9 60 PUSH1 0x04 06DB 83 DUP4 06DC 01 ADD 06DD 52 MSTORE 06DE 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 06FF 81 DUP2 0700 16 AND 0701 60 PUSH1 0x24 0703 83 DUP4 0704 01 ADD 0705 52 MSTORE 0706 91 SWAP2 0707 51 MLOAD 0708 93 SWAP4 0709 96 SWAP7 070A 50 POP 070B 91 SWAP2 070C 94 SWAP5 070D 50 POP 070E 60 PUSH1 0x00 0710 92 SWAP3 0711 7F PUSH32 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 0732 90 SWAP1 0733 91 SWAP2 0734 16 AND 0735 91 SWAP2 0736 63 PUSH4 0xe6a43905 073B 91 SWAP2 073C 60 PUSH1 0x44 073E 80 DUP1 073F 83 DUP4 0740 01 ADD 0741 92 SWAP3 0742 60 PUSH1 0x20 0744 92 SWAP3 0745 91 SWAP2 0746 90 SWAP1 0747 82 DUP3 0748 90 SWAP1 0749 03 SUB 074A 01 ADD 074B 81 DUP2 074C 86 DUP7 074D 80 DUP1 074E 3B EXTCODESIZE 074F 15 ISZERO 0750 80 DUP1 0751 15 ISZERO 0752 61 PUSH2 0x075a 0755 57 *JUMPI // Stack delta = +8 // Outputs[15] // { // @06CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xe6a43905 << 0xe0 // @06DD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-11] // @0705 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @0709 stack[-5] = stack[-2] // @070C stack[-4] = stack[-1] // @0710 stack[-2] = 0x00 // @0735 stack[-1] = (0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 // @073B stack[0] = 0xe6a43905 // @0741 stack[1] = memory[0x40:0x60] + 0x44 // @0744 stack[2] = 0x20 // @0745 stack[3] = memory[0x40:0x60] // @074A stack[4] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @074B stack[5] = memory[0x40:0x60] // @074C stack[6] = (0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 // @074F stack[7] = !address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length // } // Block ends with conditional jump to 0x075a, if !!address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length label_0756: // Incoming jump from 0x0755, if not !!address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length // Inputs[1] { @0759 memory[0x00:0x00] } 0756 60 PUSH1 0x00 0758 80 DUP1 0759 FD *REVERT // Stack delta = +0 // Outputs[1] { @0759 revert(memory[0x00:0x00]); } // Block terminates label_075A: // Incoming jump from 0x0755, if !!address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length // Inputs[8] // { // @075C msg.gas // @075D stack[-4] // @075D address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @075D stack[-2] // @075D stack[-3] // @075D memory[stack[-3]:stack[-3] + stack[-4]] // @075D stack[-6] // @075D stack[-5] // } 075A 5B JUMPDEST 075B 50 POP 075C 5A GAS 075D FA STATICCALL 075E 15 ISZERO 075F 80 DUP1 0760 15 ISZERO 0761 61 PUSH2 0x076e 0764 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @075D memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @075E stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x076e, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0765: // Incoming jump from 0x0764, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0765 returndata.length // @0769 returndata[0x00:0x00 + returndata.length] // @076A returndata.length // @076D memory[0x00:0x00 + returndata.length] // } 0765 3D RETURNDATASIZE 0766 60 PUSH1 0x00 0768 80 DUP1 0769 3E RETURNDATACOPY 076A 3D RETURNDATASIZE 076B 60 PUSH1 0x00 076D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0769 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @076D revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_076E: // Incoming jump from 0x0764, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0775 memory[0x40:0x60] // @0776 returndata.length // } 076E 5B JUMPDEST 076F 50 POP 0770 50 POP 0771 50 POP 0772 50 POP 0773 60 PUSH1 0x40 0775 51 MLOAD 0776 3D RETURNDATASIZE 0777 60 PUSH1 0x20 0779 81 DUP2 077A 10 LT 077B 15 ISZERO 077C 61 PUSH2 0x0784 077F 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0775 stack[-4] = memory[0x40:0x60] // @0776 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0784, if !(returndata.length < 0x20) label_0780: // Incoming jump from 0x077F, if not !(returndata.length < 0x20) // Inputs[1] { @0783 memory[0x00:0x00] } 0780 60 PUSH1 0x00 0782 80 DUP1 0783 FD *REVERT // Stack delta = +0 // Outputs[1] { @0783 revert(memory[0x00:0x00]); } // Block terminates label_0784: // Incoming jump from 0x077F, if !(returndata.length < 0x20) // Inputs[6] // { // @0786 stack[-2] // @0786 memory[stack[-2]:stack[-2] + 0x20] // @0787 stack[-3] // @078C stack[-12] // @078D msg.sender // @078F stack[-6] // } 0784 5B JUMPDEST 0785 50 POP 0786 51 MLOAD 0787 90 SWAP1 0788 50 POP 0789 61 PUSH2 0x0794 078C 8A DUP11 078D 33 CALLER 078E 83 DUP4 078F 87 DUP8 0790 61 PUSH2 0x10e5 0793 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @0787 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @0789 stack[-2] = 0x0794 // @078C stack[-1] = stack[-12] // @078D stack[0] = msg.sender // @078E stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @078F stack[2] = stack[-6] // } // Block ends with call to 0x10e5, returns to 0x0794 label_0794: // Incoming return from call to 0x10E5 at 0x0793 // Inputs[4] // { // @07C4 stack[-3] // @07C7 memory[0x40:0x60] // @07DB memory[0x40:0x60] // @07E3 address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } 0794 5B JUMPDEST 0795 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 07B6 60 PUSH1 0x01 07B8 60 PUSH1 0x01 07BA 60 PUSH1 0xa0 07BC 1B SHL 07BD 03 SUB 07BE 16 AND 07BF 63 PUSH4 0xd0e30db0 07C4 84 DUP5 07C5 60 PUSH1 0x40 07C7 51 MLOAD 07C8 82 DUP3 07C9 63 PUSH4 0xffffffff 07CE 16 AND 07CF 60 PUSH1 0xe0 07D1 1B SHL 07D2 81 DUP2 07D3 52 MSTORE 07D4 60 PUSH1 0x04 07D6 01 ADD 07D7 60 PUSH1 0x00 07D9 60 PUSH1 0x40 07DB 51 MLOAD 07DC 80 DUP1 07DD 83 DUP4 07DE 03 SUB 07DF 81 DUP2 07E0 85 DUP6 07E1 88 DUP9 07E2 80 DUP1 07E3 3B EXTCODESIZE 07E4 15 ISZERO 07E5 80 DUP1 07E6 15 ISZERO 07E7 61 PUSH2 0x07ef 07EA 57 *JUMPI // Stack delta = +11 // Outputs[12] // { // @07BE stack[0] = (0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @07BF stack[1] = 0xd0e30db0 // @07C4 stack[2] = stack[-3] // @07D3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xd0e30db0) << 0xe0 // @07D6 stack[3] = 0x04 + memory[0x40:0x60] // @07D7 stack[4] = 0x00 // @07DB stack[5] = memory[0x40:0x60] // @07DE stack[6] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @07DF stack[7] = memory[0x40:0x60] // @07E0 stack[8] = stack[-3] // @07E1 stack[9] = (0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @07E4 stack[10] = !address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } // Block ends with conditional jump to 0x07ef, if !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length label_07EB: // Incoming jump from 0x07EA, if not !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[1] { @07EE memory[0x00:0x00] } 07EB 60 PUSH1 0x00 07ED 80 DUP1 07EE FD *REVERT // Stack delta = +0 // Outputs[1] { @07EE revert(memory[0x00:0x00]); } // Block terminates label_07EF: // Incoming jump from 0x07EA, if !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[9] // { // @07F1 msg.gas // @07F2 stack[-4] // @07F2 stack[-7] // @07F2 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @07F2 stack[-6] // @07F2 memory[stack[-4]:stack[-4] + stack[-5]] // @07F2 stack[-3] // @07F2 stack[-2] // @07F2 stack[-5] // } 07EF 5B JUMPDEST 07F0 50 POP 07F1 5A GAS 07F2 F1 CALL 07F3 15 ISZERO 07F4 80 DUP1 07F5 15 ISZERO 07F6 61 PUSH2 0x0803 07F9 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @07F2 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @07F3 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 0x0803, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_07FA: // Incoming jump from 0x07F9, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @07FA returndata.length // @07FE returndata[0x00:0x00 + returndata.length] // @07FF returndata.length // @0802 memory[0x00:0x00 + returndata.length] // } 07FA 3D RETURNDATASIZE 07FB 60 PUSH1 0x00 07FD 80 DUP1 07FE 3E RETURNDATACOPY 07FF 3D RETURNDATASIZE 0800 60 PUSH1 0x00 0802 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @07FE memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0802 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0803: // Incoming jump from 0x07F9, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[5] // { // @0838 stack[-6] // @0839 stack[-8] // @083C memory[0x40:0x60] // @0873 memory[0x40:0x60] // @087C address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } 0803 5B JUMPDEST 0804 50 POP 0805 50 POP 0806 50 POP 0807 50 POP 0808 50 POP 0809 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 082A 60 PUSH1 0x01 082C 60 PUSH1 0x01 082E 60 PUSH1 0xa0 0830 1B SHL 0831 03 SUB 0832 16 AND 0833 63 PUSH4 0xa9059cbb 0838 82 DUP3 0839 85 DUP6 083A 60 PUSH1 0x40 083C 51 MLOAD 083D 83 DUP4 083E 63 PUSH4 0xffffffff 0843 16 AND 0844 60 PUSH1 0xe0 0846 1B SHL 0847 81 DUP2 0848 52 MSTORE 0849 60 PUSH1 0x04 084B 01 ADD 084C 80 DUP1 084D 83 DUP4 084E 60 PUSH1 0x01 0850 60 PUSH1 0x01 0852 60 PUSH1 0xa0 0854 1B SHL 0855 03 SUB 0856 16 AND 0857 60 PUSH1 0x01 0859 60 PUSH1 0x01 085B 60 PUSH1 0xa0 085D 1B SHL 085E 03 SUB 085F 16 AND 0860 81 DUP2 0861 52 MSTORE 0862 60 PUSH1 0x20 0864 01 ADD 0865 82 DUP3 0866 81 DUP2 0867 52 MSTORE 0868 60 PUSH1 0x20 086A 01 ADD 086B 92 SWAP3 086C 50 POP 086D 50 POP 086E 50 POP 086F 60 PUSH1 0x20 0871 60 PUSH1 0x40 0873 51 MLOAD 0874 80 DUP1 0875 83 DUP4 0876 03 SUB 0877 81 DUP2 0878 60 PUSH1 0x00 087A 87 DUP8 087B 80 DUP1 087C 3B EXTCODESIZE 087D 15 ISZERO 087E 80 DUP1 087F 15 ISZERO 0880 61 PUSH2 0x0888 0883 57 *JUMPI // Stack delta = +5 // Outputs[13] // { // @0832 stack[-5] = (0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @0833 stack[-4] = 0xa9059cbb // @0848 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xa9059cbb) << 0xe0 // @0861 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-6] // @0867 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-8] // @086B stack[-3] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @086F stack[-2] = 0x20 // @0873 stack[-1] = memory[0x40:0x60] // @0876 stack[0] = (0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0877 stack[1] = memory[0x40:0x60] // @0878 stack[2] = 0x00 // @087A stack[3] = (0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @087D stack[4] = !address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } // Block ends with conditional jump to 0x0888, if !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length label_0884: // Incoming jump from 0x0883, if not !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[1] { @0887 memory[0x00:0x00] } 0884 60 PUSH1 0x00 0886 80 DUP1 0887 FD *REVERT // Stack delta = +0 // Outputs[1] { @0887 revert(memory[0x00:0x00]); } // Block terminates label_0888: // Incoming jump from 0x0883, if !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[9] // { // @088A msg.gas // @088B stack[-4] // @088B stack[-3] // @088B stack[-5] // @088B stack[-2] // @088B address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @088B stack[-6] // @088B stack[-7] // @088B memory[stack[-4]:stack[-4] + stack[-5]] // } 0888 5B JUMPDEST 0889 50 POP 088A 5A GAS 088B F1 CALL 088C 15 ISZERO 088D 80 DUP1 088E 15 ISZERO 088F 61 PUSH2 0x089c 0892 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @088B memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @088C 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 0x089c, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0893: // Incoming jump from 0x0892, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0893 returndata.length // @0897 returndata[0x00:0x00 + returndata.length] // @0898 returndata.length // @089B memory[0x00:0x00 + returndata.length] // } 0893 3D RETURNDATASIZE 0894 60 PUSH1 0x00 0896 80 DUP1 0897 3E RETURNDATACOPY 0898 3D RETURNDATASIZE 0899 60 PUSH1 0x00 089B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0897 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @089B revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_089C: // Incoming jump from 0x0892, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @08A3 memory[0x40:0x60] // @08A4 returndata.length // } 089C 5B JUMPDEST 089D 50 POP 089E 50 POP 089F 50 POP 08A0 50 POP 08A1 60 PUSH1 0x40 08A3 51 MLOAD 08A4 3D RETURNDATASIZE 08A5 60 PUSH1 0x20 08A7 81 DUP2 08A8 10 LT 08A9 15 ISZERO 08AA 61 PUSH2 0x08b2 08AD 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @08A3 stack[-4] = memory[0x40:0x60] // @08A4 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x08b2, if !(returndata.length < 0x20) label_08AE: // Incoming jump from 0x08AD, if not !(returndata.length < 0x20) // Inputs[1] { @08B1 memory[0x00:0x00] } 08AE 60 PUSH1 0x00 08B0 80 DUP1 08B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @08B1 revert(memory[0x00:0x00]); } // Block terminates label_08B2: // Incoming jump from 0x08AD, if !(returndata.length < 0x20) // Inputs[2] // { // @08B4 memory[stack[-2]:stack[-2] + 0x20] // @08B4 stack[-2] // } 08B2 5B JUMPDEST 08B3 50 POP 08B4 51 MLOAD 08B5 61 PUSH2 0x08ba 08B8 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x08ba, if memory[stack[-2]:stack[-2] + 0x20] label_08B9: // Incoming jump from 0x08B8, if not memory[stack[-2]:stack[-2] + 0x20] 08B9 FE *ASSERT // Stack delta = +0 // Outputs[1] { @08B9 assert(); } // Block terminates label_08BA: // Incoming jump from 0x08B8, if memory[stack[-2]:stack[-2] + 0x20] // Inputs[5] // { // @08BB stack[-1] // @08CA stack[-6] // @08CD memory[0x40:0x60] // @08FD memory[0x40:0x60] // @0906 address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // } 08BA 5B JUMPDEST 08BB 80 DUP1 08BC 60 PUSH1 0x01 08BE 60 PUSH1 0x01 08C0 60 PUSH1 0xa0 08C2 1B SHL 08C3 03 SUB 08C4 16 AND 08C5 63 PUSH4 0x6a627842 08CA 87 DUP8 08CB 60 PUSH1 0x40 08CD 51 MLOAD 08CE 82 DUP3 08CF 63 PUSH4 0xffffffff 08D4 16 AND 08D5 60 PUSH1 0xe0 08D7 1B SHL 08D8 81 DUP2 08D9 52 MSTORE 08DA 60 PUSH1 0x04 08DC 01 ADD 08DD 80 DUP1 08DE 82 DUP3 08DF 60 PUSH1 0x01 08E1 60 PUSH1 0x01 08E3 60 PUSH1 0xa0 08E5 1B SHL 08E6 03 SUB 08E7 16 AND 08E8 60 PUSH1 0x01 08EA 60 PUSH1 0x01 08EC 60 PUSH1 0xa0 08EE 1B SHL 08EF 03 SUB 08F0 16 AND 08F1 81 DUP2 08F2 52 MSTORE 08F3 60 PUSH1 0x20 08F5 01 ADD 08F6 91 SWAP2 08F7 50 POP 08F8 50 POP 08F9 60 PUSH1 0x20 08FB 60 PUSH1 0x40 08FD 51 MLOAD 08FE 80 DUP1 08FF 83 DUP4 0900 03 SUB 0901 81 DUP2 0902 60 PUSH1 0x00 0904 87 DUP8 0905 80 DUP1 0906 3B EXTCODESIZE 0907 15 ISZERO 0908 80 DUP1 0909 15 ISZERO 090A 61 PUSH2 0x0912 090D 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @08C4 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-1] // @08C5 stack[1] = 0x6a627842 // @08D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x6a627842) << 0xe0 // @08F2 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-6] // @08F6 stack[2] = 0x20 + 0x04 + memory[0x40:0x60] // @08F9 stack[3] = 0x20 // @08FD stack[4] = memory[0x40:0x60] // @0900 stack[5] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0901 stack[6] = memory[0x40:0x60] // @0902 stack[7] = 0x00 // @0904 stack[8] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0907 stack[9] = !address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // } // Block ends with conditional jump to 0x0912, if !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length label_090E: // Incoming jump from 0x090D, if not !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // Inputs[1] { @0911 memory[0x00:0x00] } 090E 60 PUSH1 0x00 0910 80 DUP1 0911 FD *REVERT // Stack delta = +0 // Outputs[1] { @0911 revert(memory[0x00:0x00]); } // Block terminates label_0912: // Incoming jump from 0x090D, if !!address((0x01 << 0xa0) - 0x01 & stack[-1]).code.length // Inputs[9] // { // @0914 msg.gas // @0915 stack[-3] // @0915 stack[-6] // @0915 stack[-7] // @0915 memory[stack[-4]:stack[-4] + stack[-5]] // @0915 stack[-2] // @0915 stack[-5] // @0915 stack[-4] // @0915 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 0912 5B JUMPDEST 0913 50 POP 0914 5A GAS 0915 F1 CALL 0916 15 ISZERO 0917 80 DUP1 0918 15 ISZERO 0919 61 PUSH2 0x0926 091C 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0915 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0916 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 0x0926, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_091D: // Incoming jump from 0x091C, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @091D returndata.length // @0921 returndata[0x00:0x00 + returndata.length] // @0922 returndata.length // @0925 memory[0x00:0x00 + returndata.length] // } 091D 3D RETURNDATASIZE 091E 60 PUSH1 0x00 0920 80 DUP1 0921 3E RETURNDATACOPY 0922 3D RETURNDATASIZE 0923 60 PUSH1 0x00 0925 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0921 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0925 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0926: // Incoming jump from 0x091C, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @092D memory[0x40:0x60] // @092E returndata.length // } 0926 5B JUMPDEST 0927 50 POP 0928 50 POP 0929 50 POP 092A 50 POP 092B 60 PUSH1 0x40 092D 51 MLOAD 092E 3D RETURNDATASIZE 092F 60 PUSH1 0x20 0931 81 DUP2 0932 10 LT 0933 15 ISZERO 0934 61 PUSH2 0x093c 0937 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @092D stack[-4] = memory[0x40:0x60] // @092E stack[-3] = returndata.length // } // Block ends with conditional jump to 0x093c, if !(returndata.length < 0x20) label_0938: // Incoming jump from 0x0937, if not !(returndata.length < 0x20) // Inputs[1] { @093B memory[0x00:0x00] } 0938 60 PUSH1 0x00 093A 80 DUP1 093B FD *REVERT // Stack delta = +0 // Outputs[1] { @093B revert(memory[0x00:0x00]); } // Block terminates label_093C: // Incoming jump from 0x0937, if !(returndata.length < 0x20) // Inputs[5] // { // @093E memory[stack[-2]:stack[-2] + 0x20] // @093E stack[-2] // @093F stack[-4] // @0941 msg.value // @0942 stack[-5] // } 093C 5B JUMPDEST 093D 50 POP 093E 51 MLOAD 093F 91 SWAP2 0940 50 POP 0941 34 CALLVALUE 0942 83 DUP4 0943 10 LT 0944 15 ISZERO 0945 61 PUSH2 0x0954 0948 57 *JUMPI // Stack delta = -2 // Outputs[1] { @093F stack[-4] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0954, if !(stack[-5] < msg.value) label_0949: // Incoming jump from 0x0948, if not !(stack[-5] < msg.value) // Inputs[3] // { // @094C msg.sender // @094D stack[-3] // @094E msg.value // } 0949 61 PUSH2 0x0954 094C 33 CALLER 094D 84 DUP5 094E 34 CALLVALUE 094F 03 SUB 0950 61 PUSH2 0x1242 0953 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0949 stack[0] = 0x0954 // @094C stack[1] = msg.sender // @094F stack[2] = msg.value - stack[-3] // } // Block ends with call to 0x1242, returns to 0x0954 label_0954: // Incoming return from call to 0x1242 at 0x0953 // Incoming jump from 0x0948, if !(stack[-5] < msg.value) // Inputs[7] // { // @0956 stack[-9] // @0956 stack[-2] // @0958 stack[-10] // @0958 stack[-3] // @095A stack[-11] // @095A stack[-4] // @095B stack[-8] // } 0954 5B JUMPDEST 0955 50 POP 0956 96 SWAP7 0957 50 POP 0958 96 SWAP7 0959 50 POP 095A 96 SWAP7 095B 93 SWAP4 095C 50 POP 095D 50 POP 095E 50 POP 095F 50 POP 0960 56 *JUMP // Stack delta = -8 // Outputs[3] // { // @0956 stack[-9] = stack[-2] // @0958 stack[-10] = stack[-3] // @095A stack[-11] = stack[-4] // } // Block ends with unconditional jump to stack[-11] label_0961: // Incoming jump from 0x0E4C // Incoming call from 0x0452, returns to 0x0453 // Inputs[1] { @0965 stack[-3] } 0961 5B JUMPDEST 0962 60 PUSH1 0x00 0964 80 DUP1 0965 84 DUP5 0966 11 GT 0967 61 PUSH2 0x09a1 096A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0962 stack[0] = 0x00 } // Block ends with conditional jump to 0x09a1, if stack[-3] > 0x00 label_096B: // Incoming jump from 0x096A, if not stack[-3] > 0x00 // Inputs[3] // { // @096D memory[0x40:0x60] // @099B memory[0x40:0x60] // @09A0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 096B 60 PUSH1 0x40 096D 51 MLOAD 096E 62 PUSH3 0x461bcd 0972 60 PUSH1 0xe5 0974 1B SHL 0975 81 DUP2 0976 52 MSTORE 0977 60 PUSH1 0x04 0979 01 ADD 097A 80 DUP1 097B 80 DUP1 097C 60 PUSH1 0x20 097E 01 ADD 097F 82 DUP3 0980 81 DUP2 0981 03 SUB 0982 82 DUP3 0983 52 MSTORE 0984 60 PUSH1 0x2b 0986 81 DUP2 0987 52 MSTORE 0988 60 PUSH1 0x20 098A 01 ADD 098B 80 DUP1 098C 61 PUSH2 0x1798 098F 60 PUSH1 0x2b 0991 91 SWAP2 0992 39 CODECOPY 0993 60 PUSH1 0x40 0995 01 ADD 0996 91 SWAP2 0997 50 POP 0998 50 POP 0999 60 PUSH1 0x40 099B 51 MLOAD 099C 80 DUP1 099D 91 SWAP2 099E 03 SUB 099F 90 SWAP1 09A0 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0976 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0983 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0987 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2b // @0992 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2b] = code[0x1798:0x17c3] // @09A0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_09A1: // Incoming jump from 0x096A, if stack[-3] > 0x00 // Inputs[1] { @09A4 stack[-3] } 09A1 5B JUMPDEST 09A2 60 PUSH1 0x00 09A4 83 DUP4 09A5 11 GT 09A6 80 DUP1 09A7 15 ISZERO 09A8 61 PUSH2 0x09b1 09AB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @09A5 stack[0] = stack[-3] > 0x00 } // Block ends with conditional jump to 0x09b1, if !(stack[-3] > 0x00) label_09AC: // Incoming jump from 0x09AB, if not !(stack[-3] > 0x00) // Inputs[1] { @09AF stack[-3] } 09AC 50 POP 09AD 60 PUSH1 0x00 09AF 82 DUP3 09B0 11 GT 09B1 5B JUMPDEST 09B2 61 PUSH2 0x09ec 09B5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x09ec, if stack[-3] > 0x00 label_09B6: // Incoming jump from 0x09B5, if not stack[-1] // Incoming jump from 0x09B5, if not stack[-3] > 0x00 // Inputs[3] // { // @09B8 memory[0x40:0x60] // @09E6 memory[0x40:0x60] // @09EB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 09B6 60 PUSH1 0x40 09B8 51 MLOAD 09B9 62 PUSH3 0x461bcd 09BD 60 PUSH1 0xe5 09BF 1B SHL 09C0 81 DUP2 09C1 52 MSTORE 09C2 60 PUSH1 0x04 09C4 01 ADD 09C5 80 DUP1 09C6 80 DUP1 09C7 60 PUSH1 0x20 09C9 01 ADD 09CA 82 DUP3 09CB 81 DUP2 09CC 03 SUB 09CD 82 DUP3 09CE 52 MSTORE 09CF 60 PUSH1 0x28 09D1 81 DUP2 09D2 52 MSTORE 09D3 60 PUSH1 0x20 09D5 01 ADD 09D6 80 DUP1 09D7 61 PUSH2 0x16de 09DA 60 PUSH1 0x28 09DC 91 SWAP2 09DD 39 CODECOPY 09DE 60 PUSH1 0x40 09E0 01 ADD 09E1 91 SWAP2 09E2 50 POP 09E3 50 POP 09E4 60 PUSH1 0x40 09E6 51 MLOAD 09E7 80 DUP1 09E8 91 SWAP2 09E9 03 SUB 09EA 90 SWAP1 09EB FD *REVERT // Stack delta = +0 // Outputs[5] // { // @09C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09CE memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @09D2 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x28 // @09DD memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x28] = code[0x16de:0x1706] // @09EB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_09EC: // Incoming jump from 0x09B5, if stack[-1] // Incoming jump from 0x09B5, if stack[-3] > 0x00 // Inputs[1] { @09F2 stack[-4] } 09EC 5B JUMPDEST 09ED 60 PUSH1 0x00 09EF 61 PUSH2 0x0a00 09F2 85 DUP6 09F3 61 PUSH2 0x03e5 09F6 63 PUSH4 0xffffffff 09FB 61 PUSH2 0x133a 09FE 16 AND 09FF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @09ED stack[0] = 0x00 // @09EF stack[1] = 0x0a00 // @09F2 stack[2] = stack[-4] // @09F3 stack[3] = 0x03e5 // } // Block ends with call to 0x133a & 0xffffffff, returns to 0x0A00 label_0A00: // Incoming return from call to 0x133A at 0x09FF // Inputs[3] // { // @0A01 stack[-1] // @0A01 stack[-2] // @0A09 stack[-4] // } 0A00 5B JUMPDEST 0A01 90 SWAP1 0A02 50 POP 0A03 60 PUSH1 0x00 0A05 61 PUSH2 0x0a14 0A08 82 DUP3 0A09 85 DUP6 0A0A 63 PUSH4 0xffffffff 0A0F 61 PUSH2 0x133a 0A12 16 AND 0A13 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0A01 stack[-2] = stack[-1] // @0A03 stack[-1] = 0x00 // @0A05 stack[0] = 0x0a14 // @0A08 stack[1] = stack[-1] // @0A09 stack[2] = stack[-4] // } // Block ends with call to 0x133a & 0xffffffff, returns to 0x0A14 label_0A14: // Incoming return from call to 0x133A at 0x0A13 // Inputs[4] // { // @0A15 stack[-2] // @0A15 stack[-1] // @0A1C stack[-3] // @0A20 stack[-6] // } 0A14 5B JUMPDEST 0A15 90 SWAP1 0A16 50 POP 0A17 60 PUSH1 0x00 0A19 61 PUSH2 0x0a3a 0A1C 83 DUP4 0A1D 61 PUSH2 0x0a2e 0A20 88 DUP9 0A21 61 PUSH2 0x03e8 0A24 63 PUSH4 0xffffffff 0A29 61 PUSH2 0x133a 0A2C 16 AND 0A2D 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0A15 stack[-2] = stack[-1] // @0A17 stack[-1] = 0x00 // @0A19 stack[0] = 0x0a3a // @0A1C stack[1] = stack[-3] // @0A1D stack[2] = 0x0a2e // @0A20 stack[3] = stack[-6] // @0A21 stack[4] = 0x03e8 // } // Block ends with call to 0x133a & 0xffffffff, returns to 0x0A2E label_0A2E: // Incoming return from call to 0x133A at 0x0A2D // Inputs[2] // { // @0A2F stack[-2] // @0A2F stack[-1] // } 0A2E 5B JUMPDEST 0A2F 90 SWAP1 0A30 63 PUSH4 0xffffffff 0A35 61 PUSH2 0x139d 0A38 16 AND 0A39 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0A2F stack[-1] = stack[-2] // @0A2F stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x139d & 0xffffffff label_0A3A: // Incoming return from call to 0x0A2E at 0x0A2D // Inputs[3] // { // @0A3B stack[-1] // @0A3B stack[-2] // @0A3E stack[-3] // } 0A3A 5B JUMPDEST 0A3B 90 SWAP1 0A3C 50 POP 0A3D 80 DUP1 0A3E 82 DUP3 0A3F 81 DUP2 0A40 61 PUSH2 0x0a45 0A43 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0A3B stack[-2] = stack[-1] // @0A3D stack[-1] = stack[-1] // @0A3E stack[0] = stack[-3] // } // Block ends with conditional jump to 0x0a45, if stack[-1] label_0A44: // Incoming jump from 0x0A43, if not stack[-1] 0A44 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0A44 assert(); } // Block terminates label_0A45: // Incoming jump from 0x0A43, if stack[-1] // Inputs[4] // { // @0A46 stack[-2] // @0A46 stack[-1] // @0A47 stack[-10] // @0A48 stack[-9] // } 0A45 5B JUMPDEST 0A46 04 DIV 0A47 97 SWAP8 0A48 96 SWAP7 0A49 50 POP 0A4A 50 POP 0A4B 50 POP 0A4C 50 POP 0A4D 50 POP 0A4E 50 POP 0A4F 50 POP 0A50 56 *JUMP // Stack delta = -9 // Outputs[1] { @0A47 stack[-10] = stack[-1] / stack[-2] } // Block ends with unconditional jump to stack[-10] label_0A51: // Incoming call from 0x0487, returns to 0x0488 // Inputs[2] // { // @0A56 stack[-1] // @0A57 memory[stack[-1]:stack[-1] + 0x20] // } 0A51 5B JUMPDEST 0A52 60 PUSH1 0x60 0A54 60 PUSH1 0x02 0A56 82 DUP3 0A57 51 MLOAD 0A58 10 LT 0A59 15 ISZERO 0A5A 61 PUSH2 0x0aaa 0A5D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A52 stack[0] = 0x60 } // Block ends with conditional jump to 0x0aaa, if !(memory[stack[-1]:stack[-1] + 0x20] < 0x02) label_0A5E: // Incoming jump from 0x0A5D, if not !(memory[stack[-1]:stack[-1] + 0x20] < 0x02) // Inputs[3] // { // @0A61 memory[0x40:0x60] // @0AA0 memory[0x40:0x60] // @0AA9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0A5E 60 PUSH1 0x40 0A60 80 DUP1 0A61 51 MLOAD 0A62 62 PUSH3 0x461bcd 0A66 60 PUSH1 0xe5 0A68 1B SHL 0A69 81 DUP2 0A6A 52 MSTORE 0A6B 60 PUSH1 0x20 0A6D 60 PUSH1 0x04 0A6F 82 DUP3 0A70 01 ADD 0A71 52 MSTORE 0A72 60 PUSH1 0x1e 0A74 60 PUSH1 0x24 0A76 82 DUP3 0A77 01 ADD 0A78 52 MSTORE 0A79 7F PUSH32 0x556e697377617056324c6962726172793a20494e56414c49445f504154480000 0A9A 60 PUSH1 0x44 0A9C 82 DUP3 0A9D 01 ADD 0A9E 52 MSTORE 0A9F 90 SWAP1 0AA0 51 MLOAD 0AA1 90 SWAP1 0AA2 81 DUP2 0AA3 90 SWAP1 0AA4 03 SUB 0AA5 60 PUSH1 0x64 0AA7 01 ADD 0AA8 90 SWAP1 0AA9 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0A6A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A71 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A78 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @0A9E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x556e697377617056324c6962726172793a20494e56414c49445f504154480000 // @0AA9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0AAA: // Incoming jump from 0x0A5D, if !(memory[stack[-1]:stack[-1] + 0x20] < 0x02) // Inputs[2] // { // @0AAB stack[-2] // @0AAC memory[stack[-2]:stack[-2] + 0x20] // } 0AAA 5B JUMPDEST 0AAB 81 DUP2 0AAC 51 MLOAD 0AAD 67 PUSH8 0xffffffffffffffff 0AB6 81 DUP2 0AB7 11 GT 0AB8 80 DUP1 0AB9 15 ISZERO 0ABA 61 PUSH2 0x0ac2 0ABD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0AAC stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @0AB7 stack[1] = memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff // } // Block ends with conditional jump to 0x0ac2, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_0ABE: // Incoming jump from 0x0ABD, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @0AC1 memory[0x00:0x00] } 0ABE 60 PUSH1 0x00 0AC0 80 DUP1 0AC1 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AC1 revert(memory[0x00:0x00]); } // Block terminates label_0AC2: // Incoming jump from 0x0ABD, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @0AC6 memory[0x40:0x60] // @0AC7 stack[-2] // } 0AC2 5B JUMPDEST 0AC3 50 POP 0AC4 60 PUSH1 0x40 0AC6 51 MLOAD 0AC7 90 SWAP1 0AC8 80 DUP1 0AC9 82 DUP3 0ACA 52 MSTORE 0ACB 80 DUP1 0ACC 60 PUSH1 0x20 0ACE 02 MUL 0ACF 60 PUSH1 0x20 0AD1 01 ADD 0AD2 82 DUP3 0AD3 01 ADD 0AD4 60 PUSH1 0x40 0AD6 52 MSTORE 0AD7 80 DUP1 0AD8 15 ISZERO 0AD9 61 PUSH2 0x0aec 0ADC 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0AC7 stack[-2] = memory[0x40:0x60] // @0AC7 stack[-1] = stack[-2] // @0ACA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0AD6 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // } // Block ends with conditional jump to 0x0aec, if !stack[-2] label_0ADD: // Incoming jump from 0x0ADC, if not !stack[-2] // Inputs[8] // { // @0ADD stack[-2] // @0AE3 stack[-1] // @0AE6 msg.data.length // @0AE8 msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0AEE stack[-3] // @0AF0 stack[-5] // @0AF5 memory[stack[-2]:stack[-2] + 0x20] // @0AF8 memory[stack[-2]:stack[-2] + 0x20] // } 0ADD 81 DUP2 0ADE 60 PUSH1 0x20 0AE0 01 ADD 0AE1 60 PUSH1 0x20 0AE3 82 DUP3 0AE4 02 MUL 0AE5 80 DUP1 0AE6 36 CALLDATASIZE 0AE7 83 DUP4 0AE8 37 CALLDATACOPY 0AE9 01 ADD 0AEA 90 SWAP1 0AEB 50 POP 0AEC 5B JUMPDEST 0AED 50 POP 0AEE 90 SWAP1 0AEF 50 POP 0AF0 82 DUP3 0AF1 81 DUP2 0AF2 60 PUSH1 0x01 0AF4 83 DUP4 0AF5 51 MLOAD 0AF6 03 SUB 0AF7 81 DUP2 0AF8 51 MLOAD 0AF9 81 DUP2 0AFA 10 LT 0AFB 61 PUSH2 0x0b00 0AFE 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @0AE8 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0AEE stack[-3] = stack[-2] // @0AF0 stack[-2] = stack[-5] // @0AF1 stack[-1] = stack[-2] // @0AF6 stack[0] = memory[stack[-2]:stack[-2] + 0x20] - 0x01 // } // Block ends with conditional jump to 0x0b00, if memory[stack[-2]:stack[-2] + 0x20] - 0x01 < memory[stack[-2]:stack[-2] + 0x20] label_0AFF: // Incoming jump from 0x0AFE, if not memory[stack[-2]:stack[-2] + 0x20] - 0x01 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x0AFE, if not memory[stack[-2]:stack[-2] + 0x20] - 0x01 < memory[stack[-2]:stack[-2] + 0x20] 0AFF FE *ASSERT // Stack delta = +0 // Outputs[1] { @0AFF assert(); } // Block terminates label_0B00: // Incoming jump from 0x0AFE, if memory[stack[-2]:stack[-2] + 0x20] - 0x01 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x0AFE, if memory[stack[-2]:stack[-2] + 0x20] - 0x01 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[5] // { // @0B03 stack[-1] // @0B06 stack[-2] // @0B0B stack[-3] // @0B0C stack[-5] // @0B0D memory[stack[-5]:stack[-5] + 0x20] // } 0B00 5B JUMPDEST 0B01 60 PUSH1 0x20 0B03 90 SWAP1 0B04 81 DUP2 0B05 02 MUL 0B06 91 SWAP2 0B07 90 SWAP1 0B08 91 SWAP2 0B09 01 ADD 0B0A 01 ADD 0B0B 52 MSTORE 0B0C 81 DUP2 0B0D 51 MLOAD 0B0E 60 PUSH1 0x00 0B10 19 NOT 0B11 01 ADD 0B12 5B JUMPDEST 0B13 80 DUP1 0B14 15 ISZERO 0B15 61 PUSH2 0x0b96 0B18 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0B0B memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @0B11 stack[-3] = ~0x00 + memory[stack[-5]:stack[-5] + 0x20] // } // Block ends with conditional jump to 0x0b96, if !(~0x00 + memory[stack[-5]:stack[-5] + 0x20]) label_0B19: // Incoming jump from 0x0B18, if not !stack[-1] // Incoming jump from 0x0B18, if not !(~0x00 + memory[stack[-5]:stack[-5] + 0x20]) // Inputs[4] // { // @0B1F stack[-5] // @0B20 stack[-3] // @0B23 stack[-1] // @0B26 memory[stack[-3]:stack[-3] + 0x20] // } 0B19 60 PUSH1 0x00 0B1B 80 DUP1 0B1C 61 PUSH2 0x0b4f 0B1F 87 DUP8 0B20 86 DUP7 0B21 60 PUSH1 0x01 0B23 86 DUP7 0B24 03 SUB 0B25 81 DUP2 0B26 51 MLOAD 0B27 81 DUP2 0B28 10 LT 0B29 61 PUSH2 0x0b2e 0B2C 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @0B19 stack[0] = 0x00 // @0B1B stack[1] = 0x00 // @0B1C stack[2] = 0x0b4f // @0B1F stack[3] = stack[-5] // @0B20 stack[4] = stack[-3] // @0B24 stack[5] = stack[-1] - 0x01 // } // Block ends with conditional call to 0x0b2e, returns to 0x0B4F, if stack[-1] - 0x01 < memory[stack[-3]:stack[-3] + 0x20] label_0B2D: // Incoming jump from 0x0B2C, if not stack[-1] - 0x01 < memory[stack[-3]:stack[-3] + 0x20] 0B2D FE *ASSERT // Stack delta = +0 // Outputs[1] { @0B2D assert(); } // Block terminates label_0B2E: // Incoming call from 0x0B2C, returns to 0x0B4F, if stack[-1] - 0x01 < memory[stack[-3]:stack[-3] + 0x20] // Inputs[6] // { // @0B31 stack[-1] // @0B35 stack[-2] // @0B36 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0B37 stack[-9] // @0B38 stack[-7] // @0B3A memory[stack[-9]:stack[-9] + 0x20] // } 0B2E 5B JUMPDEST 0B2F 60 PUSH1 0x20 0B31 02 MUL 0B32 60 PUSH1 0x20 0B34 01 ADD 0B35 01 ADD 0B36 51 MLOAD 0B37 87 DUP8 0B38 86 DUP7 0B39 81 DUP2 0B3A 51 MLOAD 0B3B 81 DUP2 0B3C 10 LT 0B3D 61 PUSH2 0x0b42 0B40 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0B36 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0B37 stack[-1] = stack[-9] // @0B38 stack[0] = stack[-7] // } // Block ends with conditional jump to 0x0b42, if stack[-7] < memory[stack[-9]:stack[-9] + 0x20] label_0B41: // Incoming jump from 0x0B40, if not stack[-7] < memory[stack[-9]:stack[-9] + 0x20] 0B41 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0B41 assert(); } // Block terminates label_0B42: // Incoming jump from 0x0B40, if stack[-7] < memory[stack[-9]:stack[-9] + 0x20] // Incoming jump from 0x0E29, if 0x01 + stack[-7] < memory[stack[-9]:stack[-9] + 0x20] // Inputs[3] // { // @0B45 stack[-1] // @0B49 stack[-2] // @0B4A memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 0B42 5B JUMPDEST 0B43 60 PUSH1 0x20 0B45 02 MUL 0B46 60 PUSH1 0x20 0B48 01 ADD 0B49 01 ADD 0B4A 51 MLOAD 0B4B 61 PUSH2 0x13ec 0B4E 56 *JUMP // Stack delta = -1 // Outputs[1] { @0B4A stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x13ec label_0B4F: // Incoming return from call to 0x0B2E at 0x0B2C // Inputs[7] // { // @0B50 stack[-3] // @0B50 stack[-1] // @0B52 stack[-2] // @0B52 stack[-4] // @0B57 stack[-6] // @0B58 stack[-5] // @0B5A memory[stack[-6]:stack[-6] + 0x20] // } 0B4F 5B JUMPDEST 0B50 91 SWAP2 0B51 50 POP 0B52 91 SWAP2 0B53 50 POP 0B54 61 PUSH2 0x0b71 0B57 84 DUP5 0B58 84 DUP5 0B59 81 DUP2 0B5A 51 MLOAD 0B5B 81 DUP2 0B5C 10 LT 0B5D 61 PUSH2 0x0b62 0B60 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @0B50 stack[-3] = stack[-1] // @0B52 stack[-4] = stack[-2] // @0B54 stack[-2] = 0x0b71 // @0B57 stack[-1] = stack[-6] // @0B58 stack[0] = stack[-5] // } // Block ends with conditional call to 0x0b62, returns to 0x0B71, if stack[-5] < memory[stack[-6]:stack[-6] + 0x20] label_0B61: // Incoming jump from 0x0B60, if not stack[-5] < memory[stack[-6]:stack[-6] + 0x20] 0B61 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0B61 assert(); } // Block terminates label_0B62: // Incoming call from 0x0B60, returns to 0x0B71, if stack[-5] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[5] // { // @0B65 stack[-1] // @0B69 stack[-2] // @0B6A memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0B6B stack[-5] // @0B6C stack[-4] // } 0B62 5B JUMPDEST 0B63 60 PUSH1 0x20 0B65 02 MUL 0B66 60 PUSH1 0x20 0B68 01 ADD 0B69 01 ADD 0B6A 51 MLOAD 0B6B 83 DUP4 0B6C 83 DUP4 0B6D 61 PUSH2 0x0b9e 0B70 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0B6A stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0B6B stack[-1] = stack[-5] // @0B6C stack[0] = stack[-4] // } // Block ends with unconditional jump to 0x0b9e label_0B71: // Incoming return from call to 0x0B62 at 0x0B60 // Inputs[3] // { // @0B72 stack[-5] // @0B75 stack[-4] // @0B78 memory[stack[-5]:stack[-5] + 0x20] // } 0B71 5B JUMPDEST 0B72 84 DUP5 0B73 60 PUSH1 0x01 0B75 85 DUP6 0B76 03 SUB 0B77 81 DUP2 0B78 51 MLOAD 0B79 81 DUP2 0B7A 10 LT 0B7B 61 PUSH2 0x0b80 0B7E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0B72 stack[0] = stack[-5] // @0B76 stack[1] = stack[-4] - 0x01 // } // Block ends with conditional jump to 0x0b80, if stack[-4] - 0x01 < memory[stack[-5]:stack[-5] + 0x20] label_0B7F: // Incoming jump from 0x0B7E, if not stack[-4] - 0x01 < memory[stack[-5]:stack[-5] + 0x20] 0B7F FE *ASSERT // Stack delta = +0 // Outputs[1] { @0B7F assert(); } // Block terminates label_0B80: // Incoming jump from 0x0B7E, if stack[-4] - 0x01 < memory[stack[-5]:stack[-5] + 0x20] // Inputs[4] // { // @0B83 stack[-1] // @0B86 stack[-2] // @0B8B stack[-3] // @0B91 stack[-6] // } 0B80 5B JUMPDEST 0B81 60 PUSH1 0x20 0B83 90 SWAP1 0B84 81 DUP2 0B85 02 MUL 0B86 91 SWAP2 0B87 90 SWAP1 0B88 91 SWAP2 0B89 01 ADD 0B8A 01 ADD 0B8B 52 MSTORE 0B8C 50 POP 0B8D 50 POP 0B8E 60 PUSH1 0x00 0B90 19 NOT 0B91 01 ADD 0B92 61 PUSH2 0x0b12 0B95 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @0B8B memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @0B91 stack[-6] = ~0x00 + stack[-6] // } // Block ends with unconditional jump to 0x0b12 label_0B96: // Incoming jump from 0x0B18, if !stack[-1] // Incoming jump from 0x0B18, if !(~0x00 + memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x0E01, if !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20] - 0x01) // Incoming jump from 0x0E01, if !(0x00 < memory[stack[-5]:stack[-5] + 0x20] - 0x01) // Inputs[3] // { // @0B98 stack[-6] // @0B98 stack[-2] // @0B99 stack[-5] // } 0B96 5B JUMPDEST 0B97 50 POP 0B98 93 SWAP4 0B99 92 SWAP3 0B9A 50 POP 0B9B 50 POP 0B9C 50 POP 0B9D 56 *JUMP // Stack delta = -5 // Outputs[1] { @0B98 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_0B9E: // Incoming call from 0x049D, returns to 0x0453 // Incoming jump from 0x0B70 // Inputs[1] { @0BA2 stack[-3] } 0B9E 5B JUMPDEST 0B9F 60 PUSH1 0x00 0BA1 80 DUP1 0BA2 84 DUP5 0BA3 11 GT 0BA4 61 PUSH2 0x0bde 0BA7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B9F stack[0] = 0x00 } // Block ends with conditional jump to 0x0bde, if stack[-3] > 0x00 label_0BA8: // Incoming jump from 0x0BA7, if not stack[-3] > 0x00 // Inputs[3] // { // @0BAA memory[0x40:0x60] // @0BD8 memory[0x40:0x60] // @0BDD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0BA8 60 PUSH1 0x40 0BAA 51 MLOAD 0BAB 62 PUSH3 0x461bcd 0BAF 60 PUSH1 0xe5 0BB1 1B SHL 0BB2 81 DUP2 0BB3 52 MSTORE 0BB4 60 PUSH1 0x04 0BB6 01 ADD 0BB7 80 DUP1 0BB8 80 DUP1 0BB9 60 PUSH1 0x20 0BBB 01 ADD 0BBC 82 DUP3 0BBD 81 DUP2 0BBE 03 SUB 0BBF 82 DUP3 0BC0 52 MSTORE 0BC1 60 PUSH1 0x2c 0BC3 81 DUP2 0BC4 52 MSTORE 0BC5 60 PUSH1 0x20 0BC7 01 ADD 0BC8 80 DUP1 0BC9 61 PUSH2 0x1667 0BCC 60 PUSH1 0x2c 0BCE 91 SWAP2 0BCF 39 CODECOPY 0BD0 60 PUSH1 0x40 0BD2 01 ADD 0BD3 91 SWAP2 0BD4 50 POP 0BD5 50 POP 0BD6 60 PUSH1 0x40 0BD8 51 MLOAD 0BD9 80 DUP1 0BDA 91 SWAP2 0BDB 03 SUB 0BDC 90 SWAP1 0BDD FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0BB3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BC0 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0BC4 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @0BCF memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x1667:0x1693] // @0BDD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0BDE: // Incoming jump from 0x0BA7, if stack[-3] > 0x00 // Inputs[1] { @0BE1 stack[-3] } 0BDE 5B JUMPDEST 0BDF 60 PUSH1 0x00 0BE1 83 DUP4 0BE2 11 GT 0BE3 80 DUP1 0BE4 15 ISZERO 0BE5 61 PUSH2 0x0bee 0BE8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BE2 stack[0] = stack[-3] > 0x00 } // Block ends with conditional jump to 0x0bee, if !(stack[-3] > 0x00) label_0BE9: // Incoming jump from 0x0BE8, if not !(stack[-3] > 0x00) // Inputs[1] { @0BEC stack[-3] } 0BE9 50 POP 0BEA 60 PUSH1 0x00 0BEC 82 DUP3 0BED 11 GT 0BEE 5B JUMPDEST 0BEF 61 PUSH2 0x0c29 0BF2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c29, if stack[-3] > 0x00 label_0BF3: // Incoming jump from 0x0BF2, if not stack[-1] // Incoming jump from 0x0BF2, if not stack[-3] > 0x00 // Inputs[3] // { // @0BF5 memory[0x40:0x60] // @0C23 memory[0x40:0x60] // @0C28 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0BF3 60 PUSH1 0x40 0BF5 51 MLOAD 0BF6 62 PUSH3 0x461bcd 0BFA 60 PUSH1 0xe5 0BFC 1B SHL 0BFD 81 DUP2 0BFE 52 MSTORE 0BFF 60 PUSH1 0x04 0C01 01 ADD 0C02 80 DUP1 0C03 80 DUP1 0C04 60 PUSH1 0x20 0C06 01 ADD 0C07 82 DUP3 0C08 81 DUP2 0C09 03 SUB 0C0A 82 DUP3 0C0B 52 MSTORE 0C0C 60 PUSH1 0x28 0C0E 81 DUP2 0C0F 52 MSTORE 0C10 60 PUSH1 0x20 0C12 01 ADD 0C13 80 DUP1 0C14 61 PUSH2 0x16de 0C17 60 PUSH1 0x28 0C19 91 SWAP2 0C1A 39 CODECOPY 0C1B 60 PUSH1 0x40 0C1D 01 ADD 0C1E 91 SWAP2 0C1F 50 POP 0C20 50 POP 0C21 60 PUSH1 0x40 0C23 51 MLOAD 0C24 80 DUP1 0C25 91 SWAP2 0C26 03 SUB 0C27 90 SWAP1 0C28 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0BFE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C0B memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0C0F memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x28 // @0C1A memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x28] = code[0x16de:0x1706] // @0C28 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0C29: // Incoming jump from 0x0BF2, if stack[-1] // Incoming jump from 0x0BF2, if stack[-3] > 0x00 // Inputs[2] // { // @0C35 stack[-3] // @0C36 stack[-4] // } 0C29 5B JUMPDEST 0C2A 60 PUSH1 0x00 0C2C 61 PUSH2 0x0c4d 0C2F 61 PUSH2 0x03e8 0C32 61 PUSH2 0x0c41 0C35 86 DUP7 0C36 88 DUP9 0C37 63 PUSH4 0xffffffff 0C3C 61 PUSH2 0x133a 0C3F 16 AND 0C40 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0C2A stack[0] = 0x00 // @0C2C stack[1] = 0x0c4d // @0C2F stack[2] = 0x03e8 // @0C32 stack[3] = 0x0c41 // @0C35 stack[4] = stack[-3] // @0C36 stack[5] = stack[-4] // } // Block ends with call to 0x133a & 0xffffffff, returns to 0x0C41 label_0C41: // Incoming return from call to 0x133A at 0x0C40 // Incoming return from call to 0x1538 at 0x0C66 // Inputs[2] // { // @0C42 stack[-1] // @0C42 stack[-2] // } 0C41 5B JUMPDEST 0C42 90 SWAP1 0C43 63 PUSH4 0xffffffff 0C48 61 PUSH2 0x133a 0C4B 16 AND 0C4C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0C42 stack[-1] = stack[-2] // @0C42 stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x133a & 0xffffffff label_0C4D: // Incoming return from call to 0x0C41 at 0x0C40 // Inputs[4] // { // @0C4E stack[-2] // @0C4E stack[-1] // @0C5B stack[-4] // @0C5C stack[-6] // } 0C4D 5B JUMPDEST 0C4E 90 SWAP1 0C4F 50 POP 0C50 60 PUSH1 0x00 0C52 61 PUSH2 0x0c67 0C55 61 PUSH2 0x03e5 0C58 61 PUSH2 0x0c41 0C5B 86 DUP7 0C5C 89 DUP10 0C5D 63 PUSH4 0xffffffff 0C62 61 PUSH2 0x1538 0C65 16 AND 0C66 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0C4E stack[-2] = stack[-1] // @0C50 stack[-1] = 0x00 // @0C52 stack[0] = 0x0c67 // @0C55 stack[1] = 0x03e5 // @0C58 stack[2] = 0x0c41 // @0C5B stack[3] = stack[-4] // @0C5C stack[4] = stack[-6] // } // Block ends with call to 0x1538 & 0xffffffff, returns to 0x0C41 label_0C67: // Incoming return from call to 0x0C41 at 0x0C66 // Inputs[3] // { // @0C68 stack[-1] // @0C68 stack[-2] // @0C70 stack[-3] // } 0C67 5B JUMPDEST 0C68 90 SWAP1 0C69 50 POP 0C6A 61 PUSH2 0x0c84 0C6D 60 PUSH1 0x01 0C6F 82 DUP3 0C70 84 DUP5 0C71 81 DUP2 0C72 61 PUSH2 0x0c77 0C75 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @0C68 stack[-2] = stack[-1] // @0C6A stack[-1] = 0x0c84 // @0C6D stack[0] = 0x01 // @0C6F stack[1] = stack[-1] // @0C70 stack[2] = stack[-3] // } // Block ends with conditional call to 0x0c77, returns to 0x0C84, if stack[-1] label_0C76: // Incoming jump from 0x0C75, if not stack[-1] 0C76 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0C76 assert(); } // Block terminates label_0C77: // Incoming call from 0x0C75, returns to 0x0C84, if stack[-1] // Inputs[3] // { // @0C78 stack[-2] // @0C78 stack[-1] // @0C79 stack[-3] // } 0C77 5B JUMPDEST 0C78 04 DIV 0C79 90 SWAP1 0C7A 63 PUSH4 0xffffffff 0C7F 61 PUSH2 0x139d 0C82 16 AND 0C83 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @0C79 stack[-2] = stack[-3] // @0C79 stack[-3] = stack[-1] / stack[-2] // } // Block ends with unconditional jump to 0x139d & 0xffffffff label_0C84: // Incoming return from call to 0x0C77 at 0x0C75 // Inputs[3] // { // @0C85 stack[-8] // @0C85 stack[-1] // @0C86 stack[-7] // } 0C84 5B JUMPDEST 0C85 96 SWAP7 0C86 95 SWAP6 0C87 50 POP 0C88 50 POP 0C89 50 POP 0C8A 50 POP 0C8B 50 POP 0C8C 50 POP 0C8D 56 *JUMP // Stack delta = -7 // Outputs[1] { @0C85 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_0C8E: // Incoming call from 0x1084, returns to 0x1085 // Incoming call from 0x1024, returns to 0x1025 // Incoming call from 0x04CE, returns to 0x0453 // Inputs[1] { @0C92 stack[-3] } 0C8E 5B JUMPDEST 0C8F 60 PUSH1 0x00 0C91 80 DUP1 0C92 84 DUP5 0C93 11 GT 0C94 61 PUSH2 0x0cce 0C97 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C8F stack[0] = 0x00 } // Block ends with conditional jump to 0x0cce, if stack[-3] > 0x00 label_0C98: // Incoming jump from 0x0C97, if not stack[-3] > 0x00 // Inputs[3] // { // @0C9A memory[0x40:0x60] // @0CC8 memory[0x40:0x60] // @0CCD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0C98 60 PUSH1 0x40 0C9A 51 MLOAD 0C9B 62 PUSH3 0x461bcd 0C9F 60 PUSH1 0xe5 0CA1 1B SHL 0CA2 81 DUP2 0CA3 52 MSTORE 0CA4 60 PUSH1 0x04 0CA6 01 ADD 0CA7 80 DUP1 0CA8 80 DUP1 0CA9 60 PUSH1 0x20 0CAB 01 ADD 0CAC 82 DUP3 0CAD 81 DUP2 0CAE 03 SUB 0CAF 82 DUP3 0CB0 52 MSTORE 0CB1 60 PUSH1 0x25 0CB3 81 DUP2 0CB4 52 MSTORE 0CB5 60 PUSH1 0x20 0CB7 01 ADD 0CB8 80 DUP1 0CB9 61 PUSH2 0x1706 0CBC 60 PUSH1 0x25 0CBE 91 SWAP2 0CBF 39 CODECOPY 0CC0 60 PUSH1 0x40 0CC2 01 ADD 0CC3 91 SWAP2 0CC4 50 POP 0CC5 50 POP 0CC6 60 PUSH1 0x40 0CC8 51 MLOAD 0CC9 80 DUP1 0CCA 91 SWAP2 0CCB 03 SUB 0CCC 90 SWAP1 0CCD FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0CA3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CB0 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0CB4 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x25 // @0CBF memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x25] = code[0x1706:0x172b] // @0CCD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0CCE: // Incoming jump from 0x0C97, if stack[-3] > 0x00 // Inputs[1] { @0CD1 stack[-3] } 0CCE 5B JUMPDEST 0CCF 60 PUSH1 0x00 0CD1 83 DUP4 0CD2 11 GT 0CD3 80 DUP1 0CD4 15 ISZERO 0CD5 61 PUSH2 0x0cde 0CD8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0CD2 stack[0] = stack[-3] > 0x00 } // Block ends with conditional jump to 0x0cde, if !(stack[-3] > 0x00) label_0CD9: // Incoming jump from 0x0CD8, if not !(stack[-3] > 0x00) // Inputs[1] { @0CDC stack[-3] } 0CD9 50 POP 0CDA 60 PUSH1 0x00 0CDC 82 DUP3 0CDD 11 GT 0CDE 5B JUMPDEST 0CDF 61 PUSH2 0x0d19 0CE2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0d19, if stack[-3] > 0x00 label_0CE3: // Incoming jump from 0x0CE2, if not stack[-1] // Incoming jump from 0x0CE2, if not stack[-3] > 0x00 // Inputs[3] // { // @0CE5 memory[0x40:0x60] // @0D13 memory[0x40:0x60] // @0D18 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0CE3 60 PUSH1 0x40 0CE5 51 MLOAD 0CE6 62 PUSH3 0x461bcd 0CEA 60 PUSH1 0xe5 0CEC 1B SHL 0CED 81 DUP2 0CEE 52 MSTORE 0CEF 60 PUSH1 0x04 0CF1 01 ADD 0CF2 80 DUP1 0CF3 80 DUP1 0CF4 60 PUSH1 0x20 0CF6 01 ADD 0CF7 82 DUP3 0CF8 81 DUP2 0CF9 03 SUB 0CFA 82 DUP3 0CFB 52 MSTORE 0CFC 60 PUSH1 0x28 0CFE 81 DUP2 0CFF 52 MSTORE 0D00 60 PUSH1 0x20 0D02 01 ADD 0D03 80 DUP1 0D04 61 PUSH2 0x16de 0D07 60 PUSH1 0x28 0D09 91 SWAP2 0D0A 39 CODECOPY 0D0B 60 PUSH1 0x40 0D0D 01 ADD 0D0E 91 SWAP2 0D0F 50 POP 0D10 50 POP 0D11 60 PUSH1 0x40 0D13 51 MLOAD 0D14 80 DUP1 0D15 91 SWAP2 0D16 03 SUB 0D17 90 SWAP1 0D18 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0CEE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CFB memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0CFF memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x28 // @0D0A memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x28] = code[0x16de:0x1706] // @0D18 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0D19: // Incoming jump from 0x0CE2, if stack[-1] // Incoming jump from 0x0CE2, if stack[-3] > 0x00 // Inputs[3] // { // @0D1A stack[-3] // @0D1E stack[-4] // @0D1F stack[-2] // } 0D19 5B JUMPDEST 0D1A 82 DUP3 0D1B 61 PUSH2 0x0d2a 0D1E 85 DUP6 0D1F 84 DUP5 0D20 63 PUSH4 0xffffffff 0D25 61 PUSH2 0x133a 0D28 16 AND 0D29 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D1A stack[0] = stack[-3] // @0D1B stack[1] = 0x0d2a // @0D1E stack[2] = stack[-4] // @0D1F stack[3] = stack[-2] // } // Block ends with call to 0x133a & 0xffffffff, returns to 0x0D2A label_0D2A: // Incoming return from call to 0x133A at 0x0D29 // Inputs[1] { @0D2B stack[-2] } 0D2A 5B JUMPDEST 0D2B 81 DUP2 0D2C 61 PUSH2 0x0d31 0D2F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d31, if stack[-2] label_0D30: // Incoming jump from 0x0D2F, if not stack[-2] 0D30 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0D30 assert(); } // Block terminates label_0D31: // Incoming jump from 0x0D2F, if stack[-2] // Inputs[4] // { // @0D32 stack[-2] // @0D32 stack[-1] // @0D33 stack[-7] // @0D34 stack[-6] // } 0D31 5B JUMPDEST 0D32 04 DIV 0D33 94 SWAP5 0D34 93 SWAP4 0D35 50 POP 0D36 50 POP 0D37 50 POP 0D38 50 POP 0D39 56 *JUMP // Stack delta = -6 // Outputs[1] { @0D33 stack[-7] = stack[-1] / stack[-2] } // Block ends with unconditional jump to stack[-7] label_0D3A: // Incoming call from 0x051F, returns to 0x0488 // Inputs[2] // { // @0D3F stack[-1] // @0D40 memory[stack[-1]:stack[-1] + 0x20] // } 0D3A 5B JUMPDEST 0D3B 60 PUSH1 0x60 0D3D 60 PUSH1 0x02 0D3F 82 DUP3 0D40 51 MLOAD 0D41 10 LT 0D42 15 ISZERO 0D43 61 PUSH2 0x0d93 0D46 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0D3B stack[0] = 0x60 } // Block ends with conditional jump to 0x0d93, if !(memory[stack[-1]:stack[-1] + 0x20] < 0x02) label_0D47: // Incoming jump from 0x0D46, if not !(memory[stack[-1]:stack[-1] + 0x20] < 0x02) // Inputs[3] // { // @0D4A memory[0x40:0x60] // @0D89 memory[0x40:0x60] // @0D92 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0D47 60 PUSH1 0x40 0D49 80 DUP1 0D4A 51 MLOAD 0D4B 62 PUSH3 0x461bcd 0D4F 60 PUSH1 0xe5 0D51 1B SHL 0D52 81 DUP2 0D53 52 MSTORE 0D54 60 PUSH1 0x20 0D56 60 PUSH1 0x04 0D58 82 DUP3 0D59 01 ADD 0D5A 52 MSTORE 0D5B 60 PUSH1 0x1e 0D5D 60 PUSH1 0x24 0D5F 82 DUP3 0D60 01 ADD 0D61 52 MSTORE 0D62 7F PUSH32 0x556e697377617056324c6962726172793a20494e56414c49445f504154480000 0D83 60 PUSH1 0x44 0D85 82 DUP3 0D86 01 ADD 0D87 52 MSTORE 0D88 90 SWAP1 0D89 51 MLOAD 0D8A 90 SWAP1 0D8B 81 DUP2 0D8C 90 SWAP1 0D8D 03 SUB 0D8E 60 PUSH1 0x64 0D90 01 ADD 0D91 90 SWAP1 0D92 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0D53 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D5A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D61 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @0D87 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x556e697377617056324c6962726172793a20494e56414c49445f504154480000 // @0D92 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0D93: // Incoming jump from 0x0D46, if !(memory[stack[-1]:stack[-1] + 0x20] < 0x02) // Inputs[2] // { // @0D94 stack[-2] // @0D95 memory[stack[-2]:stack[-2] + 0x20] // } 0D93 5B JUMPDEST 0D94 81 DUP2 0D95 51 MLOAD 0D96 67 PUSH8 0xffffffffffffffff 0D9F 81 DUP2 0DA0 11 GT 0DA1 80 DUP1 0DA2 15 ISZERO 0DA3 61 PUSH2 0x0dab 0DA6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0D95 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @0DA0 stack[1] = memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff // } // Block ends with conditional jump to 0x0dab, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_0DA7: // Incoming jump from 0x0DA6, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @0DAA memory[0x00:0x00] } 0DA7 60 PUSH1 0x00 0DA9 80 DUP1 0DAA FD *REVERT // Stack delta = +0 // Outputs[1] { @0DAA revert(memory[0x00:0x00]); } // Block terminates label_0DAB: // Incoming jump from 0x0DA6, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @0DAF memory[0x40:0x60] // @0DB0 stack[-2] // } 0DAB 5B JUMPDEST 0DAC 50 POP 0DAD 60 PUSH1 0x40 0DAF 51 MLOAD 0DB0 90 SWAP1 0DB1 80 DUP1 0DB2 82 DUP3 0DB3 52 MSTORE 0DB4 80 DUP1 0DB5 60 PUSH1 0x20 0DB7 02 MUL 0DB8 60 PUSH1 0x20 0DBA 01 ADD 0DBB 82 DUP3 0DBC 01 ADD 0DBD 60 PUSH1 0x40 0DBF 52 MSTORE 0DC0 80 DUP1 0DC1 15 ISZERO 0DC2 61 PUSH2 0x0dd5 0DC5 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0DB0 stack[-2] = memory[0x40:0x60] // @0DB0 stack[-1] = stack[-2] // @0DB3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0DBF memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // } // Block ends with conditional jump to 0x0dd5, if !stack[-2] label_0DC6: // Incoming jump from 0x0DC5, if not !stack[-2] // Inputs[7] // { // @0DC6 stack[-2] // @0DCC stack[-1] // @0DCF msg.data.length // @0DD1 msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0DD7 stack[-3] // @0DD9 stack[-5] // @0DDE memory[stack[-2]:stack[-2] + 0x20] // } 0DC6 81 DUP2 0DC7 60 PUSH1 0x20 0DC9 01 ADD 0DCA 60 PUSH1 0x20 0DCC 82 DUP3 0DCD 02 MUL 0DCE 80 DUP1 0DCF 36 CALLDATASIZE 0DD0 83 DUP4 0DD1 37 CALLDATACOPY 0DD2 01 ADD 0DD3 90 SWAP1 0DD4 50 POP 0DD5 5B JUMPDEST 0DD6 50 POP 0DD7 90 SWAP1 0DD8 50 POP 0DD9 82 DUP3 0DDA 81 DUP2 0DDB 60 PUSH1 0x00 0DDD 81 DUP2 0DDE 51 MLOAD 0DDF 81 DUP2 0DE0 10 LT 0DE1 61 PUSH2 0x0de6 0DE4 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @0DD1 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0DD7 stack[-3] = stack[-2] // @0DD9 stack[-2] = stack[-5] // @0DDA stack[-1] = stack[-2] // @0DDB stack[0] = 0x00 // } // Block ends with conditional jump to 0x0de6, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] label_0DE5: // Incoming jump from 0x0DE4, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x0DE4, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] 0DE5 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0DE5 assert(); } // Block terminates label_0DE6: // Incoming jump from 0x0DE4, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x0DE4, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[5] // { // @0DE9 stack[-1] // @0DED stack[-2] // @0DEE stack[-3] // @0DF8 stack[-5] // @0DF9 memory[stack[-5]:stack[-5] + 0x20] // } 0DE6 5B JUMPDEST 0DE7 60 PUSH1 0x20 0DE9 02 MUL 0DEA 60 PUSH1 0x20 0DEC 01 ADD 0DED 01 ADD 0DEE 81 DUP2 0DEF 81 DUP2 0DF0 52 MSTORE 0DF1 50 POP 0DF2 50 POP 0DF3 60 PUSH1 0x00 0DF5 5B JUMPDEST 0DF6 60 PUSH1 0x01 0DF8 83 DUP4 0DF9 51 MLOAD 0DFA 03 SUB 0DFB 81 DUP2 0DFC 10 LT 0DFD 15 ISZERO 0DFE 61 PUSH2 0x0b96 0E01 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0DF0 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] // @0DF3 stack[-3] = 0x00 // } // Block ends with conditional jump to 0x0b96, if !(0x00 < memory[stack[-5]:stack[-5] + 0x20] - 0x01) label_0E02: // Incoming jump from 0x0E01, if not !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20] - 0x01) // Incoming jump from 0x0E01, if not !(0x00 < memory[stack[-5]:stack[-5] + 0x20] - 0x01) // Inputs[4] // { // @0E08 stack[-5] // @0E09 stack[-3] // @0E0A stack[-1] // @0E0C memory[stack[-3]:stack[-3] + 0x20] // } 0E02 60 PUSH1 0x00 0E04 80 DUP1 0E05 61 PUSH2 0x0e2b 0E08 87 DUP8 0E09 86 DUP7 0E0A 85 DUP6 0E0B 81 DUP2 0E0C 51 MLOAD 0E0D 81 DUP2 0E0E 10 LT 0E0F 61 PUSH2 0x0e14 0E12 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @0E02 stack[0] = 0x00 // @0E04 stack[1] = 0x00 // @0E05 stack[2] = 0x0e2b // @0E08 stack[3] = stack[-5] // @0E09 stack[4] = stack[-3] // @0E0A stack[5] = stack[-1] // } // Block ends with conditional call to 0x0e14, returns to 0x0E2B, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_0E13: // Incoming jump from 0x0E12, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] 0E13 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0E13 assert(); } // Block terminates label_0E14: // Incoming call from 0x0E12, returns to 0x0E2B, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[6] // { // @0E17 stack[-1] // @0E1B stack[-2] // @0E1C memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0E1D stack[-9] // @0E1E stack[-7] // @0E23 memory[stack[-9]:stack[-9] + 0x20] // } 0E14 5B JUMPDEST 0E15 60 PUSH1 0x20 0E17 02 MUL 0E18 60 PUSH1 0x20 0E1A 01 ADD 0E1B 01 ADD 0E1C 51 MLOAD 0E1D 87 DUP8 0E1E 86 DUP7 0E1F 60 PUSH1 0x01 0E21 01 ADD 0E22 81 DUP2 0E23 51 MLOAD 0E24 81 DUP2 0E25 10 LT 0E26 61 PUSH2 0x0b42 0E29 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0E1C stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0E1D stack[-1] = stack[-9] // @0E21 stack[0] = 0x01 + stack[-7] // } // Block ends with conditional jump to 0x0b42, if 0x01 + stack[-7] < memory[stack[-9]:stack[-9] + 0x20] label_0E2A: // Incoming jump from 0x0E29, if not 0x01 + stack[-7] < memory[stack[-9]:stack[-9] + 0x20] 0E2A FE *ASSERT // Stack delta = +0 // Outputs[1] { @0E2A assert(); } // Block terminates label_0E2B: // Incoming return from call to 0x0E14 at 0x0E12 // Inputs[7] // { // @0E2C stack[-1] // @0E2C stack[-3] // @0E2E stack[-4] // @0E2E stack[-2] // @0E33 stack[-6] // @0E34 stack[-5] // @0E36 memory[stack[-6]:stack[-6] + 0x20] // } 0E2B 5B JUMPDEST 0E2C 91 SWAP2 0E2D 50 POP 0E2E 91 SWAP2 0E2F 50 POP 0E30 61 PUSH2 0x0e4d 0E33 84 DUP5 0E34 84 DUP5 0E35 81 DUP2 0E36 51 MLOAD 0E37 81 DUP2 0E38 10 LT 0E39 61 PUSH2 0x0e3e 0E3C 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @0E2C stack[-3] = stack[-1] // @0E2E stack[-4] = stack[-2] // @0E30 stack[-2] = 0x0e4d // @0E33 stack[-1] = stack[-6] // @0E34 stack[0] = stack[-5] // } // Block ends with conditional call to 0x0e3e, returns to 0x0E4D, if stack[-5] < memory[stack[-6]:stack[-6] + 0x20] label_0E3D: // Incoming jump from 0x0E3C, if not stack[-5] < memory[stack[-6]:stack[-6] + 0x20] 0E3D FE *ASSERT // Stack delta = +0 // Outputs[1] { @0E3D assert(); } // Block terminates label_0E3E: // Incoming call from 0x0E3C, returns to 0x0E4D, if stack[-5] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[5] // { // @0E41 stack[-1] // @0E45 stack[-2] // @0E46 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0E47 stack[-5] // @0E48 stack[-4] // } 0E3E 5B JUMPDEST 0E3F 60 PUSH1 0x20 0E41 02 MUL 0E42 60 PUSH1 0x20 0E44 01 ADD 0E45 01 ADD 0E46 51 MLOAD 0E47 83 DUP4 0E48 83 DUP4 0E49 61 PUSH2 0x0961 0E4C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0E46 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0E47 stack[-1] = stack[-5] // @0E48 stack[0] = stack[-4] // } // Block ends with unconditional jump to 0x0961 label_0E4D: // Incoming return from call to 0x0E3E at 0x0E3C // Inputs[3] // { // @0E4E stack[-5] // @0E4F stack[-4] // @0E54 memory[stack[-5]:stack[-5] + 0x20] // } 0E4D 5B JUMPDEST 0E4E 84 DUP5 0E4F 84 DUP5 0E50 60 PUSH1 0x01 0E52 01 ADD 0E53 81 DUP2 0E54 51 MLOAD 0E55 81 DUP2 0E56 10 LT 0E57 61 PUSH2 0x0e5c 0E5A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0E4E stack[0] = stack[-5] // @0E52 stack[1] = 0x01 + stack[-4] // } // Block ends with conditional jump to 0x0e5c, if 0x01 + stack[-4] < memory[stack[-5]:stack[-5] + 0x20] label_0E5B: // Incoming jump from 0x0E5A, if not 0x01 + stack[-4] < memory[stack[-5]:stack[-5] + 0x20] 0E5B FE *ASSERT // Stack delta = +0 // Outputs[1] { @0E5B assert(); } // Block terminates label_0E5C: // Incoming jump from 0x0E5A, if 0x01 + stack[-4] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[4] // { // @0E5F stack[-1] // @0E62 stack[-2] // @0E67 stack[-3] // @0E6C stack[-6] // } 0E5C 5B JUMPDEST 0E5D 60 PUSH1 0x20 0E5F 90 SWAP1 0E60 81 DUP2 0E61 02 MUL 0E62 91 SWAP2 0E63 90 SWAP1 0E64 91 SWAP2 0E65 01 ADD 0E66 01 ADD 0E67 52 MSTORE 0E68 50 POP 0E69 50 POP 0E6A 60 PUSH1 0x01 0E6C 01 ADD 0E6D 61 PUSH2 0x0df5 0E70 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @0E67 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @0E6C stack[-6] = 0x01 + stack[-6] // } // Block ends with unconditional jump to 0x0df5 label_0E71: // Incoming call from 0x06BE, returns to 0x06BF // Incoming call from 0x0532, returns to 0x0533 // Inputs[5] // { // @0E75 memory[0x40:0x60] // @0E88 stack[-6] // @0E90 stack[-5] // @0E99 memory[0x40:0x60] // @0EDF address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length // } 0E71 5B JUMPDEST 0E72 60 PUSH1 0x40 0E74 80 DUP1 0E75 51 MLOAD 0E76 63 PUSH4 0xe6a43905 0E7B 60 PUSH1 0xe0 0E7D 1B SHL 0E7E 81 DUP2 0E7F 52 MSTORE 0E80 60 PUSH1 0x01 0E82 60 PUSH1 0x01 0E84 60 PUSH1 0xa0 0E86 1B SHL 0E87 03 SUB 0E88 88 DUP9 0E89 81 DUP2 0E8A 16 AND 0E8B 60 PUSH1 0x04 0E8D 83 DUP4 0E8E 01 ADD 0E8F 52 MSTORE 0E90 87 DUP8 0E91 81 DUP2 0E92 16 AND 0E93 60 PUSH1 0x24 0E95 83 DUP4 0E96 01 ADD 0E97 52 MSTORE 0E98 91 SWAP2 0E99 51 MLOAD 0E9A 60 PUSH1 0x00 0E9C 92 SWAP3 0E9D 83 DUP4 0E9E 92 SWAP3 0E9F 83 DUP4 0EA0 92 SWAP3 0EA1 7F PUSH32 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 0EC2 90 SWAP1 0EC3 92 SWAP3 0EC4 16 AND 0EC5 91 SWAP2 0EC6 63 PUSH4 0xe6a43905 0ECB 91 SWAP2 0ECC 60 PUSH1 0x44 0ECE 80 DUP1 0ECF 82 DUP3 0ED0 01 ADD 0ED1 92 SWAP3 0ED2 60 PUSH1 0x20 0ED4 92 SWAP3 0ED5 90 SWAP1 0ED6 91 SWAP2 0ED7 90 SWAP1 0ED8 82 DUP3 0ED9 90 SWAP1 0EDA 03 SUB 0EDB 01 ADD 0EDC 81 DUP2 0EDD 86 DUP7 0EDE 80 DUP1 0EDF 3B EXTCODESIZE 0EE0 15 ISZERO 0EE1 80 DUP1 0EE2 15 ISZERO 0EE3 61 PUSH2 0x0eeb 0EE6 57 *JUMPI // Stack delta = +12 // Outputs[15] // { // @0E7F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xe6a43905 << 0xe0 // @0E8F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @0E97 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @0E9C stack[0] = 0x00 // @0E9E stack[1] = 0x00 // @0EA0 stack[2] = 0x00 // @0EC5 stack[3] = (0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 // @0ECB stack[4] = 0xe6a43905 // @0ED1 stack[5] = memory[0x40:0x60] + 0x44 // @0ED4 stack[6] = 0x20 // @0ED6 stack[7] = memory[0x40:0x60] // @0EDB stack[8] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @0EDC stack[9] = memory[0x40:0x60] // @0EDD stack[10] = (0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 // @0EE0 stack[11] = !address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length // } // Block ends with conditional jump to 0x0eeb, if !!address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length label_0EE7: // Incoming jump from 0x0EE6, if not !!address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length // Inputs[1] { @0EEA memory[0x00:0x00] } 0EE7 60 PUSH1 0x00 0EE9 80 DUP1 0EEA FD *REVERT // Stack delta = +0 // Outputs[1] { @0EEA revert(memory[0x00:0x00]); } // Block terminates label_0EEB: // Incoming jump from 0x0EE6, if !!address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length // Inputs[8] // { // @0EED msg.gas // @0EEE stack[-3] // @0EEE stack[-2] // @0EEE stack[-6] // @0EEE memory[stack[-3]:stack[-3] + stack[-4]] // @0EEE address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0EEE stack[-4] // @0EEE stack[-5] // } 0EEB 5B JUMPDEST 0EEC 50 POP 0EED 5A GAS 0EEE FA STATICCALL 0EEF 15 ISZERO 0EF0 80 DUP1 0EF1 15 ISZERO 0EF2 61 PUSH2 0x0eff 0EF5 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0EEE memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0EEF stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0eff, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0EF6: // Incoming jump from 0x0EF5, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0EF6 returndata.length // @0EFA returndata[0x00:0x00 + returndata.length] // @0EFB returndata.length // @0EFE memory[0x00:0x00 + returndata.length] // } 0EF6 3D RETURNDATASIZE 0EF7 60 PUSH1 0x00 0EF9 80 DUP1 0EFA 3E RETURNDATACOPY 0EFB 3D RETURNDATASIZE 0EFC 60 PUSH1 0x00 0EFE FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0EFA memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0EFE revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0EFF: // Incoming jump from 0x0EF5, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0F06 memory[0x40:0x60] // @0F07 returndata.length // } 0EFF 5B JUMPDEST 0F00 50 POP 0F01 50 POP 0F02 50 POP 0F03 50 POP 0F04 60 PUSH1 0x40 0F06 51 MLOAD 0F07 3D RETURNDATASIZE 0F08 60 PUSH1 0x20 0F0A 81 DUP2 0F0B 10 LT 0F0C 15 ISZERO 0F0D 61 PUSH2 0x0f15 0F10 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0F06 stack[-4] = memory[0x40:0x60] // @0F07 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0f15, if !(returndata.length < 0x20) label_0F11: // Incoming jump from 0x0F10, if not !(returndata.length < 0x20) // Inputs[1] { @0F14 memory[0x00:0x00] } 0F11 60 PUSH1 0x00 0F13 80 DUP1 0F14 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F14 revert(memory[0x00:0x00]); } // Block terminates label_0F15: // Incoming jump from 0x0F10, if !(returndata.length < 0x20) // Inputs[3] // { // @0F17 memory[stack[-2]:stack[-2] + 0x20] // @0F17 stack[-2] // @0F21 stack[-3] // } 0F15 5B JUMPDEST 0F16 50 POP 0F17 51 MLOAD 0F18 60 PUSH1 0x01 0F1A 60 PUSH1 0x01 0F1C 60 PUSH1 0xa0 0F1E 1B SHL 0F1F 03 SUB 0F20 16 AND 0F21 14 EQ 0F22 15 ISZERO 0F23 61 PUSH2 0x0fc8 0F26 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x0fc8, if !((0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] == stack[-3]) label_0F27: // Incoming jump from 0x0F26, if not !((0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] == stack[-3]) // Inputs[5] // { // @0F2A memory[0x40:0x60] // @0F3D stack[-8] // @0F45 stack[-7] // @0F4E memory[0x40:0x60] // @0F8F address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length // } 0F27 60 PUSH1 0x40 0F29 80 DUP1 0F2A 51 MLOAD 0F2B 63 PUSH4 0x64e329cb 0F30 60 PUSH1 0xe1 0F32 1B SHL 0F33 81 DUP2 0F34 52 MSTORE 0F35 60 PUSH1 0x01 0F37 60 PUSH1 0x01 0F39 60 PUSH1 0xa0 0F3B 1B SHL 0F3C 03 SUB 0F3D 8A DUP11 0F3E 81 DUP2 0F3F 16 AND 0F40 60 PUSH1 0x04 0F42 83 DUP4 0F43 01 ADD 0F44 52 MSTORE 0F45 89 DUP10 0F46 81 DUP2 0F47 16 AND 0F48 60 PUSH1 0x24 0F4A 83 DUP4 0F4B 01 ADD 0F4C 52 MSTORE 0F4D 91 SWAP2 0F4E 51 MLOAD 0F4F 7F PUSH32 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 0F70 90 SWAP1 0F71 92 SWAP3 0F72 16 AND 0F73 91 SWAP2 0F74 63 PUSH4 0xc9c65396 0F79 91 SWAP2 0F7A 60 PUSH1 0x44 0F7C 80 DUP1 0F7D 82 DUP3 0F7E 01 ADD 0F7F 92 SWAP3 0F80 60 PUSH1 0x20 0F82 92 SWAP3 0F83 90 SWAP1 0F84 91 SWAP2 0F85 90 SWAP1 0F86 82 DUP3 0F87 90 SWAP1 0F88 03 SUB 0F89 01 ADD 0F8A 81 DUP2 0F8B 60 PUSH1 0x00 0F8D 87 DUP8 0F8E 80 DUP1 0F8F 3B EXTCODESIZE 0F90 15 ISZERO 0F91 80 DUP1 0F92 15 ISZERO 0F93 61 PUSH2 0x0f9b 0F96 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @0F34 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x64e329cb << 0xe1 // @0F44 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-8] // @0F4C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-7] // @0F73 stack[0] = (0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 // @0F79 stack[1] = 0xc9c65396 // @0F7F stack[2] = memory[0x40:0x60] + 0x44 // @0F82 stack[3] = 0x20 // @0F84 stack[4] = memory[0x40:0x60] // @0F89 stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @0F8A stack[6] = memory[0x40:0x60] // @0F8B stack[7] = 0x00 // @0F8D stack[8] = (0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 // @0F90 stack[9] = !address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length // } // Block ends with conditional jump to 0x0f9b, if !!address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length label_0F97: // Incoming jump from 0x0F96, if not !!address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length // Inputs[1] { @0F9A memory[0x00:0x00] } 0F97 60 PUSH1 0x00 0F99 80 DUP1 0F9A FD *REVERT // Stack delta = +0 // Outputs[1] { @0F9A revert(memory[0x00:0x00]); } // Block terminates label_0F9B: // Incoming jump from 0x0F96, if !!address((0x01 << 0xa0) - 0x01 & 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2).code.length // Inputs[9] // { // @0F9D msg.gas // @0F9E stack[-6] // @0F9E stack[-7] // @0F9E address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0F9E stack[-3] // @0F9E stack[-2] // @0F9E memory[stack[-4]:stack[-4] + stack[-5]] // @0F9E stack[-4] // @0F9E stack[-5] // } 0F9B 5B JUMPDEST 0F9C 50 POP 0F9D 5A GAS 0F9E F1 CALL 0F9F 15 ISZERO 0FA0 80 DUP1 0FA1 15 ISZERO 0FA2 61 PUSH2 0x0faf 0FA5 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0F9E memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0F9F 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 0x0faf, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0FA6: // Incoming jump from 0x0FA5, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0FA6 returndata.length // @0FAA returndata[0x00:0x00 + returndata.length] // @0FAB returndata.length // @0FAE memory[0x00:0x00 + returndata.length] // } 0FA6 3D RETURNDATASIZE 0FA7 60 PUSH1 0x00 0FA9 80 DUP1 0FAA 3E RETURNDATACOPY 0FAB 3D RETURNDATASIZE 0FAC 60 PUSH1 0x00 0FAE FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0FAA memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0FAE revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0FAF: // Incoming jump from 0x0FA5, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @0FB6 memory[0x40:0x60] // @0FB7 returndata.length // } 0FAF 5B JUMPDEST 0FB0 50 POP 0FB1 50 POP 0FB2 50 POP 0FB3 50 POP 0FB4 60 PUSH1 0x40 0FB6 51 MLOAD 0FB7 3D RETURNDATASIZE 0FB8 60 PUSH1 0x20 0FBA 81 DUP2 0FBB 10 LT 0FBC 15 ISZERO 0FBD 61 PUSH2 0x0fc5 0FC0 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0FB6 stack[-4] = memory[0x40:0x60] // @0FB7 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0fc5, if !(returndata.length < 0x20) label_0FC1: // Incoming jump from 0x0FC0, if not !(returndata.length < 0x20) // Inputs[1] { @0FC4 memory[0x00:0x00] } 0FC1 60 PUSH1 0x00 0FC3 80 DUP1 0FC4 FD *REVERT // Stack delta = +0 // Outputs[1] { @0FC4 revert(memory[0x00:0x00]); } // Block terminates label_0FC5: // Incoming jump from 0x0FC0, if !(returndata.length < 0x20) 0FC5 5B JUMPDEST 0FC6 50 POP 0FC7 50 POP // Stack delta = -2 // Block continues label_0FC8: // Incoming jump from 0x0FC7 // Incoming jump from 0x0F26, if !((0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] == stack[-3]) // Inputs[2] // { // @0FF0 stack[-8] // @0FF1 stack[-7] // } 0FC8 5B JUMPDEST 0FC9 60 PUSH1 0x00 0FCB 80 DUP1 0FCC 61 PUSH2 0x0ff6 0FCF 7F PUSH32 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 0FF0 8B DUP12 0FF1 8B DUP12 0FF2 61 PUSH2 0x13ec 0FF5 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0FC9 stack[0] = 0x00 // @0FCB stack[1] = 0x00 // @0FCC stack[2] = 0x0ff6 // @0FCF stack[3] = 0x00000000000000000000000065ac78b81d0db9d43e594fb4618c346cf467aea2 // @0FF0 stack[4] = stack[-8] // @0FF1 stack[5] = stack[-7] // } // Block ends with call to 0x13ec, returns to 0x0FF6 label_0FF6: // Incoming return from call to 0x13EC at 0x0FF5 // Inputs[4] // { // @0FF7 stack[-1] // @0FF7 stack[-3] // @0FF9 stack[-2] // @0FF9 stack[-4] // } 0FF6 5B JUMPDEST 0FF7 91 SWAP2 0FF8 50 POP 0FF9 91 SWAP2 0FFA 50 POP 0FFB 81 DUP2 0FFC 60 PUSH1 0x00 0FFE 14 EQ 0FFF 80 DUP1 1000 15 ISZERO 1001 61 PUSH2 0x1008 1004 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @0FF7 stack[-3] = stack[-1] // @0FF9 stack[-4] = stack[-2] // @0FFE stack[-2] = 0x00 == stack[-2] // } // Block ends with conditional jump to 0x1008, if !(0x00 == stack[-2]) label_1005: // Incoming jump from 0x1004, if not !(0x00 == stack[-2]) // Inputs[1] { @1006 stack[-2] } 1005 50 POP 1006 80 DUP1 1007 15 ISZERO 1008 5B JUMPDEST 1009 15 ISZERO 100A 61 PUSH2 0x1018 100D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1018, if !!stack[-2] label_100E: // Incoming jump from 0x100D, if not !!stack[-2] // Incoming jump from 0x100D, if not !stack[-1] // Inputs[4] // { // @100E stack[-8] // @100F stack[-4] // @1011 stack[-7] // @1012 stack[-3] // } 100E 87 DUP8 100F 93 SWAP4 1010 50 POP 1011 86 DUP7 1012 92 SWAP3 1013 50 POP 1014 61 PUSH2 0x10d8 1017 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @100F stack[-4] = stack[-8] // @1012 stack[-3] = stack[-7] // } // Block ends with unconditional jump to 0x10d8 label_1018: // Incoming jump from 0x100D, if !!stack[-2] // Incoming jump from 0x100D, if !stack[-1] // Inputs[3] // { // @101E stack[-8] // @101F stack[-2] // @1020 stack[-1] // } 1018 5B JUMPDEST 1019 60 PUSH1 0x00 101B 61 PUSH2 0x1025 101E 89 DUP10 101F 84 DUP5 1020 84 DUP5 1021 61 PUSH2 0x0c8e 1024 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1019 stack[0] = 0x00 // @101B stack[1] = 0x1025 // @101E stack[2] = stack[-8] // @101F stack[3] = stack[-2] // @1020 stack[4] = stack[-1] // } // Block ends with call to 0x0c8e, returns to 0x1025 label_1025: // Incoming return from call to 0x0C8E at 0x1024 // Inputs[3] // { // @1026 stack[-1] // @1026 stack[-2] // @1028 stack[-9] // } 1025 5B JUMPDEST 1026 90 SWAP1 1027 50 POP 1028 87 DUP8 1029 81 DUP2 102A 11 GT 102B 61 PUSH2 0x1078 102E 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1026 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1078, if stack[-1] > stack[-9] label_102F: // Incoming jump from 0x102E, if not stack[-1] > stack[-9] // Inputs[2] // { // @102F stack[-6] // @1030 stack[-1] // } 102F 85 DUP6 1030 81 DUP2 1031 10 LT 1032 15 ISZERO 1033 61 PUSH2 0x106d 1036 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x106d, if !(stack[-1] < stack[-6]) label_1037: // Incoming jump from 0x1036, if not !(stack[-1] < stack[-6]) // Inputs[3] // { // @1039 memory[0x40:0x60] // @1067 memory[0x40:0x60] // @106C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1037 60 PUSH1 0x40 1039 51 MLOAD 103A 62 PUSH3 0x461bcd 103E 60 PUSH1 0xe5 1040 1B SHL 1041 81 DUP2 1042 52 MSTORE 1043 60 PUSH1 0x04 1045 01 ADD 1046 80 DUP1 1047 80 DUP1 1048 60 PUSH1 0x20 104A 01 ADD 104B 82 DUP3 104C 81 DUP2 104D 03 SUB 104E 82 DUP3 104F 52 MSTORE 1050 60 PUSH1 0x26 1052 81 DUP2 1053 52 MSTORE 1054 60 PUSH1 0x20 1056 01 ADD 1057 80 DUP1 1058 61 PUSH2 0x16b8 105B 60 PUSH1 0x26 105D 91 SWAP2 105E 39 CODECOPY 105F 60 PUSH1 0x40 1061 01 ADD 1062 91 SWAP2 1063 50 POP 1064 50 POP 1065 60 PUSH1 0x40 1067 51 MLOAD 1068 80 DUP1 1069 91 SWAP2 106A 03 SUB 106B 90 SWAP1 106C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1042 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @104F memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1053 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x26 // @105E memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x26] = code[0x16b8:0x16de] // @106C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_106D: // Incoming jump from 0x1036, if !(stack[-1] < stack[-6]) // Inputs[4] // { // @106E stack[-9] // @106F stack[-5] // @1071 stack[-4] // @1071 stack[-1] // } 106D 5B JUMPDEST 106E 88 DUP9 106F 94 SWAP5 1070 50 POP 1071 92 SWAP3 1072 50 POP 1073 82 DUP3 1074 61 PUSH2 0x10d6 1077 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @106F stack[-5] = stack[-9] // @1071 stack[-4] = stack[-1] // @1073 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x10d6 label_1078: // Incoming jump from 0x102E, if stack[-1] > stack[-9] // Inputs[3] // { // @107E stack[-8] // @107F stack[-2] // @1080 stack[-3] // } 1078 5B JUMPDEST 1079 60 PUSH1 0x00 107B 61 PUSH2 0x1085 107E 89 DUP10 107F 84 DUP5 1080 86 DUP7 1081 61 PUSH2 0x0c8e 1084 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1079 stack[0] = 0x00 // @107B stack[1] = 0x1085 // @107E stack[2] = stack[-8] // @107F stack[3] = stack[-2] // @1080 stack[4] = stack[-3] // } // Block ends with call to 0x0c8e, returns to 0x1085 label_1085: // Incoming return from call to 0x0C8E at 0x1084 // Inputs[3] // { // @1086 stack[-1] // @1086 stack[-2] // @1088 stack[-11] // } 1085 5B JUMPDEST 1086 90 SWAP1 1087 50 POP 1088 89 DUP10 1089 81 DUP2 108A 11 GT 108B 15 ISZERO 108C 61 PUSH2 0x1091 108F 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1086 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1091, if !(stack[-1] > stack[-11]) label_1090: // Incoming jump from 0x108F, if not !(stack[-1] > stack[-11]) 1090 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1090 assert(); } // Block terminates label_1091: // Incoming jump from 0x108F, if !(stack[-1] > stack[-11]) // Inputs[2] // { // @1092 stack[-8] // @1093 stack[-1] // } 1091 5B JUMPDEST 1092 87 DUP8 1093 81 DUP2 1094 10 LT 1095 15 ISZERO 1096 61 PUSH2 0x10d0 1099 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10d0, if !(stack[-1] < stack[-8]) label_109A: // Incoming jump from 0x1099, if not !(stack[-1] < stack[-8]) // Inputs[3] // { // @109C memory[0x40:0x60] // @10CA memory[0x40:0x60] // @10CF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 109A 60 PUSH1 0x40 109C 51 MLOAD 109D 62 PUSH3 0x461bcd 10A1 60 PUSH1 0xe5 10A3 1B SHL 10A4 81 DUP2 10A5 52 MSTORE 10A6 60 PUSH1 0x04 10A8 01 ADD 10A9 80 DUP1 10AA 80 DUP1 10AB 60 PUSH1 0x20 10AD 01 ADD 10AE 82 DUP3 10AF 81 DUP2 10B0 03 SUB 10B1 82 DUP3 10B2 52 MSTORE 10B3 60 PUSH1 0x26 10B5 81 DUP2 10B6 52 MSTORE 10B7 60 PUSH1 0x20 10B9 01 ADD 10BA 80 DUP1 10BB 61 PUSH2 0x172b 10BE 60 PUSH1 0x26 10C0 91 SWAP2 10C1 39 CODECOPY 10C2 60 PUSH1 0x40 10C4 01 ADD 10C5 91 SWAP2 10C6 50 POP 10C7 50 POP 10C8 60 PUSH1 0x40 10CA 51 MLOAD 10CB 80 DUP1 10CC 91 SWAP2 10CD 03 SUB 10CE 90 SWAP1 10CF FD *REVERT // Stack delta = +0 // Outputs[5] // { // @10A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10B2 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @10B6 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x26 // @10C1 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x26] = code[0x172b:0x1751] // @10CF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_10D0: // Incoming jump from 0x1099, if !(stack[-1] < stack[-8]) // Inputs[4] // { // @10D1 stack[-6] // @10D1 stack[-1] // @10D3 stack[-9] // @10D4 stack[-5] // } 10D0 5B JUMPDEST 10D1 94 SWAP5 10D2 50 POP 10D3 87 DUP8 10D4 93 SWAP4 10D5 50 POP // Stack delta = -1 // Outputs[2] // { // @10D1 stack[-6] = stack[-1] // @10D4 stack[-5] = stack[-9] // } // Block continues label_10D6: // Incoming jump from 0x10D5 // Incoming jump from 0x1077 10D6 5B JUMPDEST 10D7 50 POP // Stack delta = -1 // Block continues label_10D8: // Incoming jump from 0x10D7 // Incoming jump from 0x1017 // Inputs[5] // { // @10DB stack[-3] // @10DB stack[-10] // @10DD stack[-4] // @10DD stack[-11] // @10DE stack[-9] // } 10D8 5B JUMPDEST 10D9 50 POP 10DA 50 POP 10DB 96 SWAP7 10DC 50 POP 10DD 96 SWAP7 10DE 94 SWAP5 10DF 50 POP 10E0 50 POP 10E1 50 POP 10E2 50 POP 10E3 50 POP 10E4 56 *JUMP // Stack delta = -9 // Outputs[2] // { // @10DB stack[-10] = stack[-3] // @10DD stack[-11] = stack[-4] // } // Block ends with unconditional jump to stack[-11] label_10E5: // Incoming call from 0x05E7, returns to 0x05E8 // Incoming call from 0x05F3, returns to 0x05F4 // Incoming call from 0x0793, returns to 0x0794 // Inputs[9] // { // @10E9 memory[0x40:0x60] // @10F2 stack[-3] // @10FA stack[-2] // @1107 stack[-1] // @110B memory[0x40:0x60] // @1120 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @1136 memory[0x40:0x60] // @1138 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1140 stack[-4] // } 10E5 5B JUMPDEST 10E6 60 PUSH1 0x40 10E8 80 DUP1 10E9 51 MLOAD 10EA 60 PUSH1 0x01 10EC 60 PUSH1 0x01 10EE 60 PUSH1 0xa0 10F0 1B SHL 10F1 03 SUB 10F2 85 DUP6 10F3 81 DUP2 10F4 16 AND 10F5 60 PUSH1 0x24 10F7 83 DUP4 10F8 01 ADD 10F9 52 MSTORE 10FA 84 DUP5 10FB 81 DUP2 10FC 16 AND 10FD 60 PUSH1 0x44 10FF 83 DUP4 1100 01 ADD 1101 52 MSTORE 1102 60 PUSH1 0x64 1104 80 DUP1 1105 83 DUP4 1106 01 ADD 1107 85 DUP6 1108 90 SWAP1 1109 52 MSTORE 110A 83 DUP4 110B 51 MLOAD 110C 80 DUP1 110D 84 DUP5 110E 03 SUB 110F 90 SWAP1 1110 91 SWAP2 1111 01 ADD 1112 81 DUP2 1113 52 MSTORE 1114 60 PUSH1 0x84 1116 90 SWAP1 1117 92 SWAP3 1118 01 ADD 1119 83 DUP4 111A 52 MSTORE 111B 60 PUSH1 0x20 111D 82 DUP3 111E 01 ADD 111F 80 DUP1 1120 51 MLOAD 1121 60 PUSH1 0x01 1123 60 PUSH1 0x01 1125 60 PUSH1 0xe0 1127 1B SHL 1128 03 SUB 1129 16 AND 112A 63 PUSH4 0x23b872dd 112F 60 PUSH1 0xe0 1131 1B SHL 1132 17 OR 1133 81 DUP2 1134 52 MSTORE 1135 92 SWAP3 1136 51 MLOAD 1137 82 DUP3 1138 51 MLOAD 1139 60 PUSH1 0x00 113B 94 SWAP5 113C 60 PUSH1 0x60 113E 94 SWAP5 113F 93 SWAP4 1140 8A DUP11 1141 16 AND 1142 93 SWAP4 1143 92 SWAP3 1144 91 SWAP2 1145 82 DUP3 1146 91 SWAP2 1147 90 SWAP1 1148 80 DUP1 1149 83 DUP4 114A 83 DUP4 114B 5B JUMPDEST 114C 60 PUSH1 0x20 114E 83 DUP4 114F 10 LT 1150 61 PUSH2 0x116a 1153 57 *JUMPI // Stack delta = +11 // Outputs[17] // { // @10F9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @1101 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1109 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = stack[-1] // @1113 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x64 + (memory[0x40:0x60] - memory[0x40:0x60]) // @111A memory[0x40:0x60] = memory[0x40:0x60] + 0x84 // @1134 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x23b872dd << 0xe0) | ((0x01 << 0xe0) - 0x01 & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]) // @113B stack[0] = 0x00 // @113E stack[1] = 0x60 // @1142 stack[2] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1143 stack[3] = memory[0x40:0x60] // @1144 stack[4] = memory[0x40:0x60] // @1146 stack[5] = memory[0x40:0x60] // @1147 stack[6] = memory[0x40:0x60] + 0x20 // @1147 stack[7] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1148 stack[8] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1149 stack[9] = memory[0x40:0x60] // @114A stack[10] = memory[0x40:0x60] + 0x20 // } // Block ends with conditional jump to 0x116a, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 label_1154: // Incoming jump from 0x1153, if not stack[-3] < 0x20 // Incoming jump from 0x1153, if not memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[4] // { // @1154 stack[-1] // @1155 memory[stack[-1]:stack[-1] + 0x20] // @1156 stack[-2] // @115C stack[-3] // } 1154 80 DUP1 1155 51 MLOAD 1156 82 DUP3 1157 52 MSTORE 1158 60 PUSH1 0x1f 115A 19 NOT 115B 90 SWAP1 115C 92 SWAP3 115D 01 ADD 115E 91 SWAP2 115F 60 PUSH1 0x20 1161 91 SWAP2 1162 82 DUP3 1163 01 ADD 1164 91 SWAP2 1165 01 ADD 1166 61 PUSH2 0x114b 1169 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1157 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @115E stack[-3] = stack[-3] + ~0x1f // @1164 stack[-2] = 0x20 + stack[-2] // @1165 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x114b label_116A: // Incoming jump from 0x1153, if stack[-3] < 0x20 // Incoming jump from 0x1153, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[15] // { // @116D stack[-3] // @1178 stack[-1] // @1179 memory[stack[-1]:stack[-1] + 0x20] // @117C stack[-2] // @117D memory[stack[-2]:stack[-2] + 0x20] // @118A stack[-5] // @118A stack[-4] // @118C stack[-6] // @118D stack[-8] // @1194 memory[0x40:0x60] // @119B stack[-9] // @119C msg.gas // @119D address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @119D memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]] // @11A1 returndata.length // } 116A 5B JUMPDEST 116B 60 PUSH1 0x01 116D 83 DUP4 116E 60 PUSH1 0x20 1170 03 SUB 1171 61 PUSH2 0x0100 1174 0A EXP 1175 03 SUB 1176 80 DUP1 1177 19 NOT 1178 82 DUP3 1179 51 MLOAD 117A 16 AND 117B 81 DUP2 117C 84 DUP5 117D 51 MLOAD 117E 16 AND 117F 80 DUP1 1180 82 DUP3 1181 17 OR 1182 85 DUP6 1183 52 MSTORE 1184 50 POP 1185 50 POP 1186 50 POP 1187 50 POP 1188 50 POP 1189 50 POP 118A 90 SWAP1 118B 50 POP 118C 01 ADD 118D 91 SWAP2 118E 50 POP 118F 50 POP 1190 60 PUSH1 0x00 1192 60 PUSH1 0x40 1194 51 MLOAD 1195 80 DUP1 1196 83 DUP4 1197 03 SUB 1198 81 DUP2 1199 60 PUSH1 0x00 119B 86 DUP7 119C 5A GAS 119D F1 CALL 119E 91 SWAP2 119F 50 POP 11A0 50 POP 11A1 3D RETURNDATASIZE 11A2 80 DUP1 11A3 60 PUSH1 0x00 11A5 81 DUP2 11A6 14 EQ 11A7 61 PUSH2 0x11cc 11AA 57 *JUMPI // Stack delta = -6 // Outputs[5] // { // @1183 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) // @119D 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]]) // @119E stack[-9] = address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @11A1 stack[-8] = returndata.length // @11A2 stack[-7] = returndata.length // } // Block ends with conditional jump to 0x11cc, if returndata.length == 0x00 label_11AB: // Incoming jump from 0x11AA, if not returndata.length == 0x00 // Inputs[6] // { // @11AD memory[0x40:0x60] // @11AE stack[-2] // @11B5 returndata.length // @11BD returndata.length // @11C0 returndata.length // @11C7 returndata[0x00:0x00 + returndata.length] // } 11AB 60 PUSH1 0x40 11AD 51 MLOAD 11AE 91 SWAP2 11AF 50 POP 11B0 60 PUSH1 0x1f 11B2 19 NOT 11B3 60 PUSH1 0x3f 11B5 3D RETURNDATASIZE 11B6 01 ADD 11B7 16 AND 11B8 82 DUP3 11B9 01 ADD 11BA 60 PUSH1 0x40 11BC 52 MSTORE 11BD 3D RETURNDATASIZE 11BE 82 DUP3 11BF 52 MSTORE 11C0 3D RETURNDATASIZE 11C1 60 PUSH1 0x00 11C3 60 PUSH1 0x20 11C5 84 DUP5 11C6 01 ADD 11C7 3E RETURNDATACOPY 11C8 61 PUSH2 0x11d1 11CB 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @11AE stack[-2] = memory[0x40:0x60] // @11BC memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @11BF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @11C7 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x11d1 label_11CC: // Incoming jump from 0x11AA, if returndata.length == 0x00 // Inputs[4] // { // @11CF stack[-2] // @11D3 stack[-4] // @11D5 stack[-3] // @11D5 stack[-5] // } 11CC 5B JUMPDEST 11CD 60 PUSH1 0x60 11CF 91 SWAP2 11D0 50 POP 11D1 5B JUMPDEST 11D2 50 POP 11D3 91 SWAP2 11D4 50 POP 11D5 91 SWAP2 11D6 50 POP 11D7 81 DUP2 11D8 80 DUP1 11D9 15 ISZERO 11DA 61 PUSH2 0x11ff 11DD 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @11D3 stack[-4] = 0x60 // @11D5 stack[-5] = stack[-3] // @11D7 stack[-3] = stack[-3] // } // Block ends with conditional jump to 0x11ff, if !stack[-3] label_11DE: // Incoming jump from 0x11DD, if not !stack[-3] // Incoming jump from 0x11DD, if not !stack[-3] // Inputs[2] // { // @11DF stack[-2] // @11E0 memory[stack[-2]:stack[-2] + 0x20] // } 11DE 50 POP 11DF 80 DUP1 11E0 51 MLOAD 11E1 15 ISZERO 11E2 80 DUP1 11E3 61 PUSH2 0x11ff 11E6 57 *JUMPI // Stack delta = +0 // Outputs[1] { @11E1 stack[-1] = !memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x11ff, if !memory[stack[-2]:stack[-2] + 0x20] label_11E7: // Incoming jump from 0x11E6, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @11E8 stack[-2] // @11EE memory[stack[-2]:stack[-2] + 0x20] // } 11E7 50 POP 11E8 80 DUP1 11E9 80 DUP1 11EA 60 PUSH1 0x20 11EC 01 ADD 11ED 90 SWAP1 11EE 51 MLOAD 11EF 60 PUSH1 0x20 11F1 81 DUP2 11F2 10 LT 11F3 15 ISZERO 11F4 61 PUSH2 0x11fc 11F7 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @11ED stack[-1] = 0x20 + stack[-2] // @11EE stack[0] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x11fc, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) label_11F8: // Incoming jump from 0x11F7, if not !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[1] { @11FB memory[0x00:0x00] } 11F8 60 PUSH1 0x00 11FA 80 DUP1 11FB FD *REVERT // Stack delta = +0 // Outputs[1] { @11FB revert(memory[0x00:0x00]); } // Block terminates label_11FC: // Incoming jump from 0x11F7, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[2] // { // @11FE memory[stack[-2]:stack[-2] + 0x20] // @11FE stack[-2] // } 11FC 5B JUMPDEST 11FD 50 POP 11FE 51 MLOAD // Stack delta = -1 // Outputs[1] { @11FE stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block continues label_11FF: // Incoming jump from 0x11FE // Incoming jump from 0x11E6, if !memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x11DD, if !stack[-3] // Incoming jump from 0x11DD, if !stack[-3] // Inputs[1] { @1203 stack[-1] } 11FF 5B JUMPDEST 1200 61 PUSH2 0x123a 1203 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x123a, if stack[-1] label_1204: // Incoming jump from 0x1203, if not stack[-1] // Inputs[3] // { // @1206 memory[0x40:0x60] // @1234 memory[0x40:0x60] // @1239 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1204 60 PUSH1 0x40 1206 51 MLOAD 1207 62 PUSH3 0x461bcd 120B 60 PUSH1 0xe5 120D 1B SHL 120E 81 DUP2 120F 52 MSTORE 1210 60 PUSH1 0x04 1212 01 ADD 1213 80 DUP1 1214 80 DUP1 1215 60 PUSH1 0x20 1217 01 ADD 1218 82 DUP3 1219 81 DUP2 121A 03 SUB 121B 82 DUP3 121C 52 MSTORE 121D 60 PUSH1 0x24 121F 81 DUP2 1220 52 MSTORE 1221 60 PUSH1 0x20 1223 01 ADD 1224 80 DUP1 1225 61 PUSH2 0x1774 1228 60 PUSH1 0x24 122A 91 SWAP2 122B 39 CODECOPY 122C 60 PUSH1 0x40 122E 01 ADD 122F 91 SWAP2 1230 50 POP 1231 50 POP 1232 60 PUSH1 0x40 1234 51 MLOAD 1235 80 DUP1 1236 91 SWAP2 1237 03 SUB 1238 90 SWAP1 1239 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @120F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @121C memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1220 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x24 // @122B memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x24] = code[0x1774:0x1798] // @1239 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_123A: // Incoming jump from 0x1203, if stack[-1] // Inputs[1] { @1241 stack[-7] } 123A 5B JUMPDEST 123B 50 POP 123C 50 POP 123D 50 POP 123E 50 POP 123F 50 POP 1240 50 POP 1241 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_1242: // Incoming call from 0x0953, returns to 0x0954 // Inputs[5] // { // @1246 memory[0x40:0x60] // @125B stack[-2] // @125E stack[-1] // @1262 memory[0x40:0x60] // @1266 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 1242 5B JUMPDEST 1243 60 PUSH1 0x40 1245 80 DUP1 1246 51 MLOAD 1247 60 PUSH1 0x00 1249 80 DUP1 124A 82 DUP3 124B 52 MSTORE 124C 60 PUSH1 0x20 124E 82 DUP3 124F 01 ADD 1250 90 SWAP1 1251 92 SWAP3 1252 52 MSTORE 1253 60 PUSH1 0x01 1255 60 PUSH1 0x01 1257 60 PUSH1 0xa0 1259 1B SHL 125A 03 SUB 125B 84 DUP5 125C 16 AND 125D 90 SWAP1 125E 83 DUP4 125F 90 SWAP1 1260 60 PUSH1 0x40 1262 51 MLOAD 1263 80 DUP1 1264 82 DUP3 1265 80 DUP1 1266 51 MLOAD 1267 90 SWAP1 1268 60 PUSH1 0x20 126A 01 ADD 126B 90 SWAP1 126C 80 DUP1 126D 83 DUP4 126E 83 DUP4 126F 5B JUMPDEST 1270 60 PUSH1 0x20 1272 83 DUP4 1273 10 LT 1274 61 PUSH2 0x128e 1277 57 *JUMPI // Stack delta = +11 // Outputs[13] // { // @124B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1251 stack[0] = 0x00 // @1252 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @125D stack[1] = stack[-2] & (0x01 << 0xa0) - 0x01 // @125F stack[2] = stack[-1] // @125F stack[3] = memory[0x40:0x60] // @1262 stack[4] = memory[0x40:0x60] // @1263 stack[5] = memory[0x40:0x60] // @126B stack[6] = 0x20 + memory[0x40:0x60] // @126B stack[7] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @126C stack[8] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @126D stack[9] = memory[0x40:0x60] // @126E stack[10] = 0x20 + memory[0x40:0x60] // } // Block ends with conditional jump to 0x128e, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 label_1278: // Incoming jump from 0x1277, if not stack[-3] < 0x20 // Incoming jump from 0x1277, if not memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[4] // { // @1278 stack[-1] // @1279 memory[stack[-1]:stack[-1] + 0x20] // @127A stack[-2] // @1280 stack[-3] // } 1278 80 DUP1 1279 51 MLOAD 127A 82 DUP3 127B 52 MSTORE 127C 60 PUSH1 0x1f 127E 19 NOT 127F 90 SWAP1 1280 92 SWAP3 1281 01 ADD 1282 91 SWAP2 1283 60 PUSH1 0x20 1285 91 SWAP2 1286 82 DUP3 1287 01 ADD 1288 91 SWAP2 1289 01 ADD 128A 61 PUSH2 0x126f 128D 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @127B memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1282 stack[-3] = stack[-3] + ~0x1f // @1288 stack[-2] = 0x20 + stack[-2] // @1289 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x126f label_128E: // Incoming jump from 0x1277, if stack[-3] < 0x20 // Incoming jump from 0x1277, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[16] // { // @1291 stack[-3] // @129C stack[-1] // @129D memory[stack[-1]:stack[-1] + 0x20] // @12A0 stack[-2] // @12A1 memory[stack[-2]:stack[-2] + 0x20] // @12AE stack[-4] // @12AE stack[-5] // @12B0 stack[-6] // @12B1 stack[-8] // @12B8 memory[0x40:0x60] // @12BD stack[-9] // @12BE stack[-10] // @12BF msg.gas // @12C0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]] // @12C0 address(stack[-10]).call.gas(msg.gas).value(stack[-9])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @12C5 returndata.length // } 128E 5B JUMPDEST 128F 60 PUSH1 0x01 1291 83 DUP4 1292 60 PUSH1 0x20 1294 03 SUB 1295 61 PUSH2 0x0100 1298 0A EXP 1299 03 SUB 129A 80 DUP1 129B 19 NOT 129C 82 DUP3 129D 51 MLOAD 129E 16 AND 129F 81 DUP2 12A0 84 DUP5 12A1 51 MLOAD 12A2 16 AND 12A3 80 DUP1 12A4 82 DUP3 12A5 17 OR 12A6 85 DUP6 12A7 52 MSTORE 12A8 50 POP 12A9 50 POP 12AA 50 POP 12AB 50 POP 12AC 50 POP 12AD 50 POP 12AE 90 SWAP1 12AF 50 POP 12B0 01 ADD 12B1 91 SWAP2 12B2 50 POP 12B3 50 POP 12B4 60 PUSH1 0x00 12B6 60 PUSH1 0x40 12B8 51 MLOAD 12B9 80 DUP1 12BA 83 DUP4 12BB 03 SUB 12BC 81 DUP2 12BD 85 DUP6 12BE 87 DUP8 12BF 5A GAS 12C0 F1 CALL 12C1 92 SWAP3 12C2 50 POP 12C3 50 POP 12C4 50 POP 12C5 3D RETURNDATASIZE 12C6 80 DUP1 12C7 60 PUSH1 0x00 12C9 81 DUP2 12CA 14 EQ 12CB 61 PUSH2 0x12f0 12CE 57 *JUMPI // Stack delta = -7 // Outputs[5] // { // @12A7 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) // @12C0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-10]).call.gas(msg.gas).value(stack[-9])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @12C1 stack[-10] = address(stack[-10]).call.gas(msg.gas).value(stack[-9])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @12C5 stack[-9] = returndata.length // @12C6 stack[-8] = returndata.length // } // Block ends with conditional jump to 0x12f0, if returndata.length == 0x00 label_12CF: // Incoming jump from 0x12CE, if not returndata.length == 0x00 // Inputs[6] // { // @12D1 memory[0x40:0x60] // @12D2 stack[-2] // @12D9 returndata.length // @12E1 returndata.length // @12E4 returndata.length // @12EB returndata[0x00:0x00 + returndata.length] // } 12CF 60 PUSH1 0x40 12D1 51 MLOAD 12D2 91 SWAP2 12D3 50 POP 12D4 60 PUSH1 0x1f 12D6 19 NOT 12D7 60 PUSH1 0x3f 12D9 3D RETURNDATASIZE 12DA 01 ADD 12DB 16 AND 12DC 82 DUP3 12DD 01 ADD 12DE 60 PUSH1 0x40 12E0 52 MSTORE 12E1 3D RETURNDATASIZE 12E2 82 DUP3 12E3 52 MSTORE 12E4 3D RETURNDATASIZE 12E5 60 PUSH1 0x00 12E7 60 PUSH1 0x20 12E9 84 DUP5 12EA 01 ADD 12EB 3E RETURNDATACOPY 12EC 61 PUSH2 0x12f5 12EF 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @12D2 stack[-2] = memory[0x40:0x60] // @12E0 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @12E3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @12EB memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x12f5 label_12F0: // Incoming jump from 0x12CE, if returndata.length == 0x00 // Inputs[3] // { // @12F3 stack[-2] // @12F8 stack[-4] // @12F8 stack[-3] // } 12F0 5B JUMPDEST 12F1 60 PUSH1 0x60 12F3 91 SWAP2 12F4 50 POP 12F5 5B JUMPDEST 12F6 50 POP 12F7 50 POP 12F8 90 SWAP1 12F9 50 POP 12FA 80 DUP1 12FB 61 PUSH2 0x1335 12FE 57 *JUMPI // Stack delta = -3 // Outputs[1] { @12F8 stack[-4] = stack[-3] } // Block ends with conditional jump to 0x1335, if stack[-3] label_12FF: // Incoming jump from 0x12FE, if not stack[-3] // Incoming jump from 0x12FE, if not stack[-3] // Inputs[3] // { // @1301 memory[0x40:0x60] // @132F memory[0x40:0x60] // @1334 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 12FF 60 PUSH1 0x40 1301 51 MLOAD 1302 62 PUSH3 0x461bcd 1306 60 PUSH1 0xe5 1308 1B SHL 1309 81 DUP2 130A 52 MSTORE 130B 60 PUSH1 0x04 130D 01 ADD 130E 80 DUP1 130F 80 DUP1 1310 60 PUSH1 0x20 1312 01 ADD 1313 82 DUP3 1314 81 DUP2 1315 03 SUB 1316 82 DUP3 1317 52 MSTORE 1318 60 PUSH1 0x23 131A 81 DUP2 131B 52 MSTORE 131C 60 PUSH1 0x20 131E 01 ADD 131F 80 DUP1 1320 61 PUSH2 0x1751 1323 60 PUSH1 0x23 1325 91 SWAP2 1326 39 CODECOPY 1327 60 PUSH1 0x40 1329 01 ADD 132A 91 SWAP2 132B 50 POP 132C 50 POP 132D 60 PUSH1 0x40 132F 51 MLOAD 1330 80 DUP1 1331 91 SWAP2 1332 03 SUB 1333 90 SWAP1 1334 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @130A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1317 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @131B memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x23 // @1326 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x23] = code[0x1751:0x1774] // @1334 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1335: // Incoming jump from 0x12FE, if stack[-3] // Incoming jump from 0x12FE, if stack[-3] // Inputs[1] { @1339 stack[-4] } 1335 5B JUMPDEST 1336 50 POP 1337 50 POP 1338 50 POP 1339 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_133A: // Incoming call from 0x0A13, returns to 0x0A14 // Incoming call from 0x0D29, returns to 0x0D2A // Incoming call from 0x0A2D, returns to 0x0A2E // Incoming jump from 0x0C4C // Incoming call from 0x0C40, returns to 0x0C41 // Incoming call from 0x09FF, returns to 0x0A00 // Inputs[1] { @133D stack[-1] } 133A 5B JUMPDEST 133B 60 PUSH1 0x00 133D 81 DUP2 133E 15 ISZERO 133F 80 DUP1 1340 61 PUSH2 0x1355 1343 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @133B stack[0] = 0x00 // @133E stack[1] = !stack[-1] // } // Block ends with conditional jump to 0x1355, if !stack[-1] label_1344: // Incoming jump from 0x1343, if not !stack[-1] // Inputs[2] // { // @1346 stack[-3] // @1347 stack[-4] // } 1344 50 POP 1345 50 POP 1346 80 DUP1 1347 82 DUP3 1348 02 MUL 1349 82 DUP3 134A 82 DUP3 134B 82 DUP3 134C 81 DUP2 134D 61 PUSH2 0x1352 1350 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1348 stack[-2] = stack[-4] * stack[-3] // @1349 stack[-1] = stack[-4] // @134A stack[0] = stack[-3] // @134B stack[1] = stack[-4] * stack[-3] // } // Block ends with conditional jump to 0x1352, if stack[-3] label_1351: // Incoming jump from 0x1350, if not stack[-3] 1351 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1351 assert(); } // Block terminates label_1352: // Incoming jump from 0x1350, if stack[-3] // Inputs[3] // { // @1353 stack[-2] // @1353 stack[-1] // @1354 stack[-3] // } 1352 5B JUMPDEST 1353 04 DIV 1354 14 EQ // Stack delta = -2 // Outputs[1] { @1354 stack[-3] = stack[-1] / stack[-2] == stack[-3] } // Block continues label_1355: // Incoming jump from 0x1354 // Incoming jump from 0x1343, if !stack[-1] // Inputs[1] { @1359 stack[-1] } 1355 5B JUMPDEST 1356 61 PUSH2 0x048b 1359 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x048b, if stack[-1] label_135A: // Incoming jump from 0x1359, if not stack[-1] // Inputs[3] // { // @135D memory[0x40:0x60] // @1393 memory[0x40:0x60] // @139C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 135A 60 PUSH1 0x40 135C 80 DUP1 135D 51 MLOAD 135E 62 PUSH3 0x461bcd 1362 60 PUSH1 0xe5 1364 1B SHL 1365 81 DUP2 1366 52 MSTORE 1367 60 PUSH1 0x20 1369 60 PUSH1 0x04 136B 82 DUP3 136C 01 ADD 136D 52 MSTORE 136E 60 PUSH1 0x14 1370 60 PUSH1 0x24 1372 82 DUP3 1373 01 ADD 1374 52 MSTORE 1375 73 PUSH20 0x64732d6d6174682d6d756c2d6f766572666c6f77 138A 60 PUSH1 0x60 138C 1B SHL 138D 60 PUSH1 0x44 138F 82 DUP3 1390 01 ADD 1391 52 MSTORE 1392 90 SWAP1 1393 51 MLOAD 1394 90 SWAP1 1395 81 DUP2 1396 90 SWAP1 1397 03 SUB 1398 60 PUSH1 0x64 139A 01 ADD 139B 90 SWAP1 139C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1366 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @136D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1374 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @1391 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x64732d6d6174682d6d756c2d6f766572666c6f77 << 0x60 // @139C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_139D: // Incoming jump from 0x0C83 // Incoming jump from 0x0A39 // Inputs[2] // { // @139E stack[-1] // @139F stack[-2] // } 139D 5B JUMPDEST 139E 80 DUP1 139F 82 DUP3 13A0 01 ADD 13A1 82 DUP3 13A2 81 DUP2 13A3 10 LT 13A4 15 ISZERO 13A5 61 PUSH2 0x048b 13A8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @13A0 stack[0] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x048b, if !(stack[-2] + stack[-1] < stack[-2]) label_13A9: // Incoming jump from 0x13A8, if not !(stack[-2] + stack[-1] < stack[-2]) // Inputs[3] // { // @13AC memory[0x40:0x60] // @13E2 memory[0x40:0x60] // @13EB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 13A9 60 PUSH1 0x40 13AB 80 DUP1 13AC 51 MLOAD 13AD 62 PUSH3 0x461bcd 13B1 60 PUSH1 0xe5 13B3 1B SHL 13B4 81 DUP2 13B5 52 MSTORE 13B6 60 PUSH1 0x20 13B8 60 PUSH1 0x04 13BA 82 DUP3 13BB 01 ADD 13BC 52 MSTORE 13BD 60 PUSH1 0x14 13BF 60 PUSH1 0x24 13C1 82 DUP3 13C2 01 ADD 13C3 52 MSTORE 13C4 73 PUSH20 0x64732d6d6174682d6164642d6f766572666c6f77 13D9 60 PUSH1 0x60 13DB 1B SHL 13DC 60 PUSH1 0x44 13DE 82 DUP3 13DF 01 ADD 13E0 52 MSTORE 13E1 90 SWAP1 13E2 51 MLOAD 13E3 90 SWAP1 13E4 81 DUP2 13E5 90 SWAP1 13E6 03 SUB 13E7 60 PUSH1 0x64 13E9 01 ADD 13EA 90 SWAP1 13EB FD *REVERT // Stack delta = +0 // Outputs[5] // { // @13B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13BC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @13C3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @13E0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x64732d6d6174682d6164642d6f766572666c6f77 << 0x60 // @13EB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_13EC: // Incoming jump from 0x0B4E // Incoming call from 0x0FF5, returns to 0x0FF6 // Inputs[2] // { // @13F5 stack[-2] // @13F6 stack[-1] // } 13EC 5B JUMPDEST 13ED 60 PUSH1 0x00 13EF 80 DUP1 13F0 60 PUSH1 0x00 13F2 61 PUSH2 0x13fb 13F5 85 DUP6 13F6 85 DUP6 13F7 61 PUSH2 0x1588 13FA 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @13ED stack[0] = 0x00 // @13EF stack[1] = 0x00 // @13F0 stack[2] = 0x00 // @13F2 stack[3] = 0x13fb // @13F5 stack[4] = stack[-2] // @13F6 stack[5] = stack[-1] // } // Block ends with call to 0x1588, returns to 0x13FB label_13FB: // Incoming return from call to 0x1588 at 0x13FA // Inputs[8] // { // @1400 memory[0x40:0x60] // @1413 stack[-7] // @141B stack[-6] // @1424 memory[0x40:0x60] // @1425 stack[-2] // @1426 stack[-3] // @142D stack[-8] // @1448 address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // } 13FB 5B JUMPDEST 13FC 50 POP 13FD 60 PUSH1 0x40 13FF 80 DUP1 1400 51 MLOAD 1401 63 PUSH4 0xe6a43905 1406 60 PUSH1 0xe0 1408 1B SHL 1409 81 DUP2 140A 52 MSTORE 140B 60 PUSH1 0x01 140D 60 PUSH1 0x01 140F 60 PUSH1 0xa0 1411 1B SHL 1412 03 SUB 1413 88 DUP9 1414 81 DUP2 1415 16 AND 1416 60 PUSH1 0x04 1418 83 DUP4 1419 01 ADD 141A 52 MSTORE 141B 87 DUP8 141C 81 DUP2 141D 16 AND 141E 60 PUSH1 0x24 1420 83 DUP4 1421 01 ADD 1422 52 MSTORE 1423 91 SWAP2 1424 51 MLOAD 1425 92 SWAP3 1426 93 SWAP4 1427 50 POP 1428 60 PUSH1 0x00 142A 92 SWAP3 142B 83 DUP4 142C 92 SWAP3 142D 8A DUP11 142E 16 AND 142F 91 SWAP2 1430 63 PUSH4 0xe6a43905 1435 91 SWAP2 1436 60 PUSH1 0x44 1438 80 DUP1 1439 83 DUP4 143A 01 ADD 143B 92 SWAP3 143C 60 PUSH1 0x20 143E 92 SWAP3 143F 91 SWAP2 1440 90 SWAP1 1441 82 DUP3 1442 90 SWAP1 1443 03 SUB 1444 01 ADD 1445 81 DUP2 1446 86 DUP7 1447 80 DUP1 1448 3B EXTCODESIZE 1449 15 ISZERO 144A 80 DUP1 144B 15 ISZERO 144C 61 PUSH2 0x1454 144F 57 *JUMPI // Stack delta = +9 // Outputs[15] // { // @140A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xe6a43905 << 0xe0 // @141A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-7] // @1422 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @1426 stack[-3] = stack[-2] // @142A stack[-2] = 0x00 // @142C stack[-1] = 0x00 // @142F stack[0] = stack[-8] & (0x01 << 0xa0) - 0x01 // @1435 stack[1] = 0xe6a43905 // @143B stack[2] = memory[0x40:0x60] + 0x44 // @143E stack[3] = 0x20 // @143F stack[4] = memory[0x40:0x60] // @1444 stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @1445 stack[6] = memory[0x40:0x60] // @1446 stack[7] = stack[-8] & (0x01 << 0xa0) - 0x01 // @1449 stack[8] = !address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x1454, if !!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length label_1450: // Incoming jump from 0x144F, if not !!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @1453 memory[0x00:0x00] } 1450 60 PUSH1 0x00 1452 80 DUP1 1453 FD *REVERT // Stack delta = +0 // Outputs[1] { @1453 revert(memory[0x00:0x00]); } // Block terminates label_1454: // Incoming jump from 0x144F, if !!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @1456 msg.gas // @1457 stack[-2] // @1457 stack[-6] // @1457 memory[stack[-3]:stack[-3] + stack[-4]] // @1457 stack[-4] // @1457 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1457 stack[-3] // @1457 stack[-5] // } 1454 5B JUMPDEST 1455 50 POP 1456 5A GAS 1457 FA STATICCALL 1458 15 ISZERO 1459 80 DUP1 145A 15 ISZERO 145B 61 PUSH2 0x1468 145E 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1457 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1458 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1468, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_145F: // Incoming jump from 0x145E, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @145F returndata.length // @1463 returndata[0x00:0x00 + returndata.length] // @1464 returndata.length // @1467 memory[0x00:0x00 + returndata.length] // } 145F 3D RETURNDATASIZE 1460 60 PUSH1 0x00 1462 80 DUP1 1463 3E RETURNDATACOPY 1464 3D RETURNDATASIZE 1465 60 PUSH1 0x00 1467 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1463 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1467 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1468: // Incoming jump from 0x145E, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @146F memory[0x40:0x60] // @1470 returndata.length // } 1468 5B JUMPDEST 1469 50 POP 146A 50 POP 146B 50 POP 146C 50 POP 146D 60 PUSH1 0x40 146F 51 MLOAD 1470 3D RETURNDATASIZE 1471 60 PUSH1 0x20 1473 81 DUP2 1474 10 LT 1475 15 ISZERO 1476 61 PUSH2 0x147e 1479 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @146F stack[-4] = memory[0x40:0x60] // @1470 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x147e, if !(returndata.length < 0x20) label_147A: // Incoming jump from 0x1479, if not !(returndata.length < 0x20) // Inputs[1] { @147D memory[0x00:0x00] } 147A 60 PUSH1 0x00 147C 80 DUP1 147D FD *REVERT // Stack delta = +0 // Outputs[1] { @147D revert(memory[0x00:0x00]); } // Block terminates label_147E: // Incoming jump from 0x1479, if !(returndata.length < 0x20) // Inputs[5] // { // @1480 stack[-2] // @1480 memory[stack[-2]:stack[-2] + 0x20] // @1484 memory[0x40:0x60] // @1490 memory[0x40:0x60] // @14B6 address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // } 147E 5B JUMPDEST 147F 50 POP 1480 51 MLOAD 1481 60 PUSH1 0x40 1483 80 DUP1 1484 51 MLOAD 1485 63 PUSH4 0x0240bc6b 148A 60 PUSH1 0xe2 148C 1B SHL 148D 81 DUP2 148E 52 MSTORE 148F 90 SWAP1 1490 51 MLOAD 1491 60 PUSH1 0x01 1493 60 PUSH1 0x01 1495 60 PUSH1 0xa0 1497 1B SHL 1498 03 SUB 1499 90 SWAP1 149A 92 SWAP3 149B 16 AND 149C 91 SWAP2 149D 63 PUSH4 0x0902f1ac 14A2 91 SWAP2 14A3 60 PUSH1 0x04 14A5 80 DUP1 14A6 82 DUP3 14A7 01 ADD 14A8 92 SWAP3 14A9 60 PUSH1 0x60 14AB 92 SWAP3 14AC 90 SWAP1 14AD 91 SWAP2 14AE 90 SWAP1 14AF 82 DUP3 14B0 90 SWAP1 14B1 03 SUB 14B2 01 ADD 14B3 81 DUP2 14B4 86 DUP7 14B5 80 DUP1 14B6 3B EXTCODESIZE 14B7 15 ISZERO 14B8 80 DUP1 14B9 15 ISZERO 14BA 61 PUSH2 0x14c2 14BD 57 *JUMPI // Stack delta = +7 // Outputs[10] // { // @148E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0240bc6b << 0xe2 // @149C stack[-2] = memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @14A2 stack[-1] = 0x0902f1ac // @14A8 stack[0] = memory[0x40:0x60] + 0x04 // @14AB stack[1] = 0x60 // @14AD stack[2] = memory[0x40:0x60] // @14B2 stack[3] = memory[0x40:0x60] - memory[0x40:0x60] + 0x04 // @14B3 stack[4] = memory[0x40:0x60] // @14B4 stack[5] = memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @14B7 stack[6] = !address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x14c2, if !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length label_14BE: // Incoming jump from 0x14BD, if not !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @14C1 memory[0x00:0x00] } 14BE 60 PUSH1 0x00 14C0 80 DUP1 14C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @14C1 revert(memory[0x00:0x00]); } // Block terminates label_14C2: // Incoming jump from 0x14BD, if !!address(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @14C4 msg.gas // @14C5 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @14C5 stack[-2] // @14C5 stack[-6] // @14C5 stack[-5] // @14C5 stack[-4] // @14C5 memory[stack[-3]:stack[-3] + stack[-4]] // @14C5 stack[-3] // } 14C2 5B JUMPDEST 14C3 50 POP 14C4 5A GAS 14C5 FA STATICCALL 14C6 15 ISZERO 14C7 80 DUP1 14C8 15 ISZERO 14C9 61 PUSH2 0x14d6 14CC 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @14C5 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @14C6 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x14d6, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_14CD: // Incoming jump from 0x14CC, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @14CD returndata.length // @14D1 returndata[0x00:0x00 + returndata.length] // @14D2 returndata.length // @14D5 memory[0x00:0x00 + returndata.length] // } 14CD 3D RETURNDATASIZE 14CE 60 PUSH1 0x00 14D0 80 DUP1 14D1 3E RETURNDATACOPY 14D2 3D RETURNDATASIZE 14D3 60 PUSH1 0x00 14D5 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @14D1 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @14D5 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_14D6: // Incoming jump from 0x14CC, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @14DD memory[0x40:0x60] // @14DE returndata.length // } 14D6 5B JUMPDEST 14D7 50 POP 14D8 50 POP 14D9 50 POP 14DA 50 POP 14DB 60 PUSH1 0x40 14DD 51 MLOAD 14DE 3D RETURNDATASIZE 14DF 60 PUSH1 0x60 14E1 81 DUP2 14E2 10 LT 14E3 15 ISZERO 14E4 61 PUSH2 0x14ec 14E7 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @14DD stack[-4] = memory[0x40:0x60] // @14DE stack[-3] = returndata.length // } // Block ends with conditional jump to 0x14ec, if !(returndata.length < 0x60) label_14E8: // Incoming jump from 0x14E7, if not !(returndata.length < 0x60) // Inputs[1] { @14EB memory[0x00:0x00] } 14E8 60 PUSH1 0x00 14EA 80 DUP1 14EB FD *REVERT // Stack delta = +0 // Outputs[1] { @14EB revert(memory[0x00:0x00]); } // Block terminates label_14EC: // Incoming jump from 0x14E7, if !(returndata.length < 0x60) // Inputs[7] // { // @14EE stack[-2] // @14EF memory[stack[-2]:stack[-2] + 0x20] // @14F5 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @1508 stack[-4] // @150B stack[-3] // @1515 stack[-9] // @1519 stack[-5] // } 14EC 5B JUMPDEST 14ED 50 POP 14EE 80 DUP1 14EF 51 MLOAD 14F0 60 PUSH1 0x20 14F2 90 SWAP1 14F3 91 SWAP2 14F4 01 ADD 14F5 51 MLOAD 14F6 6D PUSH14 0xffffffffffffffffffffffffffff 1505 91 SWAP2 1506 82 DUP3 1507 16 AND 1508 93 SWAP4 1509 50 POP 150A 16 AND 150B 90 SWAP1 150C 50 POP 150D 60 PUSH1 0x01 150F 60 PUSH1 0x01 1511 60 PUSH1 0xa0 1513 1B SHL 1514 03 SUB 1515 87 DUP8 1516 81 DUP2 1517 16 AND 1518 90 SWAP1 1519 84 DUP5 151A 16 AND 151B 14 EQ 151C 61 PUSH2 0x1526 151F 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1508 stack[-4] = 0xffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] // @150B stack[-3] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] & 0xffffffffffffffffffffffffffff // } // Block ends with conditional jump to 0x1526, if stack[-5] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-9] label_1520: // Incoming jump from 0x151F, if not stack[-5] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-9] // Inputs[2] // { // @1520 stack[-1] // @1521 stack[-2] // } 1520 80 DUP1 1521 82 DUP3 1522 61 PUSH2 0x1529 1525 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1520 stack[0] = stack[-1] // @1521 stack[1] = stack[-2] // } // Block ends with unconditional jump to 0x1529 label_1526: // Incoming jump from 0x151F, if stack[-5] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-9] // Inputs[5] // { // @1527 stack[-2] // @1528 stack[-1] // @152B stack[-9] // @152D stack[-8] // @152F stack[-7] // } 1526 5B JUMPDEST 1527 81 DUP2 1528 81 DUP2 1529 5B JUMPDEST 152A 90 SWAP1 152B 99 SWAP10 152C 90 SWAP1 152D 98 SWAP9 152E 50 POP 152F 96 SWAP7 1530 50 POP 1531 50 POP 1532 50 POP 1533 50 POP 1534 50 POP 1535 50 POP 1536 50 POP 1537 56 *JUMP // Stack delta = -7 // Outputs[2] // { // @152B stack[-9] = stack[-2] // @152D stack[-8] = stack[-1] // } // Block ends with unconditional jump to stack[-9] label_1538: // Incoming call from 0x0C66, returns to 0x0C41 // Inputs[2] // { // @1539 stack[-1] // @153A stack[-2] // } 1538 5B JUMPDEST 1539 80 DUP1 153A 82 DUP3 153B 03 SUB 153C 82 DUP3 153D 81 DUP2 153E 11 GT 153F 15 ISZERO 1540 61 PUSH2 0x048b 1543 57 *JUMPI // Stack delta = +1 // Outputs[1] { @153B stack[0] = stack[-2] - stack[-1] } // Block ends with conditional jump to 0x048b, if !(stack[-2] - stack[-1] > stack[-2]) label_1544: // Incoming jump from 0x1543, if not !(stack[-2] - stack[-1] > stack[-2]) // Inputs[3] // { // @1547 memory[0x40:0x60] // @157E memory[0x40:0x60] // @1587 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1544 60 PUSH1 0x40 1546 80 DUP1 1547 51 MLOAD 1548 62 PUSH3 0x461bcd 154C 60 PUSH1 0xe5 154E 1B SHL 154F 81 DUP2 1550 52 MSTORE 1551 60 PUSH1 0x20 1553 60 PUSH1 0x04 1555 82 DUP3 1556 01 ADD 1557 52 MSTORE 1558 60 PUSH1 0x15 155A 60 PUSH1 0x24 155C 82 DUP3 155D 01 ADD 155E 52 MSTORE 155F 74 PUSH21 0x64732d6d6174682d7375622d756e646572666c6f77 1575 60 PUSH1 0x58 1577 1B SHL 1578 60 PUSH1 0x44 157A 82 DUP3 157B 01 ADD 157C 52 MSTORE 157D 90 SWAP1 157E 51 MLOAD 157F 90 SWAP1 1580 81 DUP2 1581 90 SWAP1 1582 03 SUB 1583 60 PUSH1 0x64 1585 01 ADD 1586 90 SWAP1 1587 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1550 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1557 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @155E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x15 // @157C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x64732d6d6174682d7375622d756e646572666c6f77 << 0x58 // @1587 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1588: // Incoming call from 0x13FA, returns to 0x13FB // Inputs[2] // { // @158C stack[-1] // @1596 stack[-2] // } 1588 5B JUMPDEST 1589 60 PUSH1 0x00 158B 80 DUP1 158C 82 DUP3 158D 60 PUSH1 0x01 158F 60 PUSH1 0x01 1591 60 PUSH1 0xa0 1593 1B SHL 1594 03 SUB 1595 16 AND 1596 84 DUP5 1597 60 PUSH1 0x01 1599 60 PUSH1 0x01 159B 60 PUSH1 0xa0 159D 1B SHL 159E 03 SUB 159F 16 AND 15A0 14 EQ 15A1 15 ISZERO 15A2 61 PUSH2 0x15dc 15A5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1589 stack[0] = 0x00 // @158B stack[1] = 0x00 // } // Block ends with conditional jump to 0x15dc, if !((0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_15A6: // Incoming jump from 0x15A5, if not !((0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @15A8 memory[0x40:0x60] // @15D6 memory[0x40:0x60] // @15DB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 15A6 60 PUSH1 0x40 15A8 51 MLOAD 15A9 62 PUSH3 0x461bcd 15AD 60 PUSH1 0xe5 15AF 1B SHL 15B0 81 DUP2 15B1 52 MSTORE 15B2 60 PUSH1 0x04 15B4 01 ADD 15B5 80 DUP1 15B6 80 DUP1 15B7 60 PUSH1 0x20 15B9 01 ADD 15BA 82 DUP3 15BB 81 DUP2 15BC 03 SUB 15BD 82 DUP3 15BE 52 MSTORE 15BF 60 PUSH1 0x25 15C1 81 DUP2 15C2 52 MSTORE 15C3 60 PUSH1 0x20 15C5 01 ADD 15C6 80 DUP1 15C7 61 PUSH2 0x1693 15CA 60 PUSH1 0x25 15CC 91 SWAP2 15CD 39 CODECOPY 15CE 60 PUSH1 0x40 15D0 01 ADD 15D1 91 SWAP2 15D2 50 POP 15D3 50 POP 15D4 60 PUSH1 0x40 15D6 51 MLOAD 15D7 80 DUP1 15D8 91 SWAP2 15D9 03 SUB 15DA 90 SWAP1 15DB FD *REVERT // Stack delta = +0 // Outputs[5] // { // @15B1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @15BE memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @15C2 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x25 // @15CD memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x25] = code[0x1693:0x16b8] // @15DB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_15DC: // Incoming jump from 0x15A5, if !((0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @15DD stack[-3] // @15E7 stack[-4] // } 15DC 5B JUMPDEST 15DD 82 DUP3 15DE 60 PUSH1 0x01 15E0 60 PUSH1 0x01 15E2 60 PUSH1 0xa0 15E4 1B SHL 15E5 03 SUB 15E6 16 AND 15E7 84 DUP5 15E8 60 PUSH1 0x01 15EA 60 PUSH1 0x01 15EC 60 PUSH1 0xa0 15EE 1B SHL 15EF 03 SUB 15F0 16 AND 15F1 10 LT 15F2 61 PUSH2 0x15fc 15F5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x15fc, if (0x01 << 0xa0) - 0x01 & stack[-4] < (0x01 << 0xa0) - 0x01 & stack[-3] label_15F6: // Incoming jump from 0x15F5, if not (0x01 << 0xa0) - 0x01 & stack[-4] < (0x01 << 0xa0) - 0x01 & stack[-3] // Inputs[2] // { // @15F6 stack[-3] // @15F7 stack[-4] // } 15F6 82 DUP3 15F7 84 DUP5 15F8 61 PUSH2 0x15ff 15FB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @15F6 stack[0] = stack[-3] // @15F7 stack[1] = stack[-4] // } // Block ends with unconditional jump to 0x15ff label_15FC: // Incoming jump from 0x15F5, if (0x01 << 0xa0) - 0x01 & stack[-4] < (0x01 << 0xa0) - 0x01 & stack[-3] // Inputs[4] // { // @15FD stack[-4] // @15FE stack[-3] // @1601 stack[-2] // @1603 stack[-1] // } 15FC 5B JUMPDEST 15FD 83 DUP4 15FE 83 DUP4 15FF 5B JUMPDEST 1600 90 SWAP1 1601 92 SWAP3 1602 50 POP 1603 90 SWAP1 1604 50 POP 1605 60 PUSH1 0x01 1607 60 PUSH1 0x01 1609 60 PUSH1 0xa0 160B 1B SHL 160C 03 SUB 160D 82 DUP3 160E 16 AND 160F 61 PUSH2 0x165f 1612 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1601 stack[-2] = stack[-4] // @1603 stack[-1] = stack[-3] // } // Block ends with conditional jump to 0x165f, if stack[-4] & (0x01 << 0xa0) - 0x01 label_1613: // Incoming jump from 0x1612, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x1612, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1616 memory[0x40:0x60] // @1655 memory[0x40:0x60] // @165E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1613 60 PUSH1 0x40 1615 80 DUP1 1616 51 MLOAD 1617 62 PUSH3 0x461bcd 161B 60 PUSH1 0xe5 161D 1B SHL 161E 81 DUP2 161F 52 MSTORE 1620 60 PUSH1 0x20 1622 60 PUSH1 0x04 1624 82 DUP3 1625 01 ADD 1626 52 MSTORE 1627 60 PUSH1 0x1e 1629 60 PUSH1 0x24 162B 82 DUP3 162C 01 ADD 162D 52 MSTORE 162E 7F PUSH32 0x556e697377617056324c6962726172793a205a45524f5f414444524553530000 164F 60 PUSH1 0x44 1651 82 DUP3 1652 01 ADD 1653 52 MSTORE 1654 90 SWAP1 1655 51 MLOAD 1656 90 SWAP1 1657 81 DUP2 1658 90 SWAP1 1659 03 SUB 165A 60 PUSH1 0x64 165C 01 ADD 165D 90 SWAP1 165E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @161F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1626 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @162D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @1653 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x556e697377617056324c6962726172793a205a45524f5f414444524553530000 // @165E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_165F: // Incoming jump from 0x1612, if stack[-2] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x1612, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[5] // { // @1660 stack[-1] // @1660 stack[-4] // @1662 stack[-2] // @1662 stack[-5] // @1663 stack[-3] // } 165F 5B JUMPDEST 1660 92 SWAP3 1661 50 POP 1662 92 SWAP3 1663 90 SWAP1 1664 50 POP 1665 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1660 stack[-4] = stack[-1] // @1662 stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] 1666 FE *ASSERT 1667 55 SSTORE 1668 6E PUSH15 0x697377617056324c6962726172793a 1678 20 SHA3 1679 49 49 167A 4E 4E 167B 53 MSTORE8 167C 55 SSTORE 167D 46 CHAINID 167E 46 CHAINID 167F 49 49 1680 43 NUMBER 1681 49 49 1682 45 GASLIMIT 1683 4E 4E 1684 54 SLOAD 1685 5F PUSH0 1686 4F 4F 1687 55 SSTORE 1688 54 SLOAD 1689 50 POP 168A 55 SSTORE 168B 54 SLOAD 168C 5F PUSH0 168D 41 COINBASE 168E 4D 4D 168F 4F 4F 1690 55 SSTORE 1691 4E 4E 1692 54 SLOAD 1693 55 SSTORE 1694 6E PUSH15 0x697377617056324c6962726172793a 16A4 20 SHA3 16A5 49 49 16A6 44 DIFFICULTY 16A7 45 GASLIMIT 16A8 4E 4E 16A9 54 SLOAD 16AA 49 49 16AB 43 NUMBER 16AC 41 COINBASE 16AD 4C 4C 16AE 5F PUSH0 16AF 41 COINBASE 16B0 44 DIFFICULTY 16B1 44 DIFFICULTY 16B2 52 MSTORE 16B3 45 GASLIMIT 16B4 53 MSTORE8 16B5 53 MSTORE8 16B6 45 GASLIMIT 16B7 53 MSTORE8 16B8 55 SSTORE 16B9 6E PUSH15 0x69737761705632526f757465723a20 16C9 49 49 16CA 4E 4E 16CB 53 MSTORE8 16CC 55 SSTORE 16CD 46 CHAINID 16CE 46 CHAINID 16CF 49 49 16D0 43 NUMBER 16D1 49 49 16D2 45 GASLIMIT 16D3 4E 4E 16D4 54 SLOAD 16D5 5F PUSH0 16D6 42 TIMESTAMP 16D7 5F PUSH0 16D8 41 COINBASE 16D9 4D 4D 16DA 4F 4F 16DB 55 SSTORE 16DC 4E 4E 16DD 54 SLOAD 16DE 55 SSTORE 16DF 6E PUSH15 0x697377617056324c6962726172793a 16EF 20 SHA3 16F0 49 49 16F1 4E 4E 16F2 53 MSTORE8 16F3 55 SSTORE 16F4 46 CHAINID 16F5 46 CHAINID 16F6 49 49 16F7 43 NUMBER 16F8 49 49 16F9 45 GASLIMIT 16FA 4E 4E 16FB 54 SLOAD 16FC 5F PUSH0 16FD 4C 4C 16FE 49 49 16FF 51 MLOAD 1700 55 SSTORE 1701 49 49 1702 44 DIFFICULTY 1703 49 49 1704 54 SLOAD 1705 59 MSIZE 1706 55 SSTORE 1707 6E PUSH15 0x697377617056324c6962726172793a 1717 20 SHA3 1718 49 49 1719 4E 4E 171A 53 MSTORE8 171B 55 SSTORE 171C 46 CHAINID 171D 46 CHAINID 171E 49 49 171F 43 NUMBER 1720 49 49 1721 45 GASLIMIT 1722 4E 4E 1723 54 SLOAD 1724 5F PUSH0 1725 41 COINBASE 1726 4D 4D 1727 4F 4F 1728 55 SSTORE 1729 4E 4E 172A 54 SLOAD 172B 55 SSTORE 172C 6E PUSH15 0x69737761705632526f757465723a20 173C 49 49 173D 4E 4E 173E 53 MSTORE8 173F 55 SSTORE 1740 46 CHAINID 1741 46 CHAINID 1742 49 49 1743 43 NUMBER 1744 49 49 1745 45 GASLIMIT 1746 4E 4E 1747 54 SLOAD 1748 5F PUSH0 1749 41 COINBASE 174A 5F PUSH0 174B 41 COINBASE 174C 4D 4D 174D 4F 4F 174E 55 SSTORE 174F 4E 4E 1750 54 SLOAD 1751 54 SLOAD 1752 72 PUSH19 0x616e7366657248656c7065723a204554485f54 1766 52 MSTORE 1767 41 COINBASE 1768 4E 4E 1769 53 MSTORE8 176A 46 CHAINID 176B 45 GASLIMIT 176C 52 MSTORE 176D 5F PUSH0 176E 46 CHAINID 176F 41 COINBASE 1770 49 49 1771 4C 4C 1772 45 GASLIMIT 1773 44 DIFFICULTY 1774 54 SLOAD 1775 72 PUSH19 0x616e7366657248656c7065723a205452414e53 1789 46 CHAINID 178A 45 GASLIMIT 178B 52 MSTORE 178C 5F PUSH0 178D 46 CHAINID 178E 52 MSTORE 178F 4F 4F 1790 4D 4D 1791 5F PUSH0 1792 46 CHAINID 1793 41 COINBASE 1794 49 49 1795 4C 4C 1796 45 GASLIMIT 1797 44 DIFFICULTY 1798 55 SSTORE 1799 6E PUSH15 0x697377617056324c6962726172793a 17A9 20 SHA3 17AA 49 49 17AB 4E 4E 17AC 53 MSTORE8 17AD 55 SSTORE 17AE 46 CHAINID 17AF 46 CHAINID 17B0 49 49 17B1 43 NUMBER 17B2 49 49 17B3 45 GASLIMIT 17B4 4E 4E 17B5 54 SLOAD 17B6 5F PUSH0 17B7 49 49 17B8 4E 4E 17B9 50 POP 17BA 55 SSTORE 17BB 54 SLOAD 17BC 5F PUSH0 17BD 41 COINBASE 17BE 4D 4D 17BF 4F 4F 17C0 55 SSTORE 17C1 4E 4E 17C2 54 SLOAD 17C3 A2 LOG2 17C4 64 PUSH5 0x6970667358 17CA 22 22 17CB 12 SLT 17CC 20 SHA3 17CD 6C PUSH13 0x9c1b4c58e064aad33cc38ce14a 17DB 69 PUSH10 0x81231adaa73a1c936131 17E6 B0 PUSH 17E7 EC EC 17E8 07 SMOD 17E9 E8 E8 17EA 7F PUSH32 0x6af864736f6c63430006060033
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]