Online Solidity Decompiler

« Decompile another contract

Address

0x3895cdeae7cbed053e9669f5f8c7acba10a33ac1 [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.
0x01ffc9a7 supportsInterface(bytes4)
0x06fdde03 name()
0x081812fc getApproved(uint256)
0x095ea7b3 approve(address,uint256)
0x1249c58b mint()
0x23b872dd transferFrom(address,address,uint256)
0x2be09561 startMint()
0x42842e0e safeTransferFrom(address,address,uint256)
0x6352211e ownerOf(uint256)
0x6e762527 Unknown
0x70a08231 balanceOf(address)
0x715018a6 renounceOwnership()
0x8da5cb5b owner()
0x95d89b41 symbol()
0xa22cb465 setApprovalForAll(address,bool)
0xb88d4fde safeTransferFrom(address,address,uint256,bytes)
0xc87b56dd tokenURI(uint256)
0xd5582965 stopMint()
0xe985e9c5 isApprovedForAll(address,address)
0xf2fde38b transferOwnership(address)

Internal Methods

func_0146(arg0) returns (r0)
func_0194(arg0) returns (r0)
func_01C4(arg0, arg1)
func_01EA(arg0, arg1, arg2)
func_0210(arg0, arg1, arg2)
func_022C(arg0) returns (r0)
func_025C(arg0, arg1)
func_0278(arg0) returns (r0)
func_02EE(arg0, arg1)
func_030A(arg0, arg1, arg2, arg3, arg4) returns (r0, r1, r2, r3, r4)
func_0326(arg0) returns (r0)
func_0360(arg0, arg1) returns (r0)
func_0390(arg0)
func_0479() returns (r0)
func_050B(arg0) returns (r0)
func_0614(arg0, arg1) returns (r0)
mint()
func_06EF(arg0, arg2) returns (r0)
startMint()
func_0789(arg0) returns (r0)
renounceOwnership()
func_08F8() returns (r0)
func_0921() returns (r0)
func_09BE(arg0, arg1, arg2)
func_09C9(arg0, arg1, arg2, arg3)
func_09D4(arg0, arg3) returns (r0)
stopMint()
func_0ACF(arg0, arg1) returns (r0)
func_0BE6(arg0) returns (r0)
func_0C50(arg0)
func_0C9B() returns (r0)
func_0CA3(arg0, arg1)
func_0D5C()
func_0DAB(arg0, arg1)
func_0DC9()
func_0E68(arg0, arg1, arg2)
func_1161()
func_11DF(arg0) returns (r0)
func_121C(arg0)
func_144C(arg0, arg1, arg2, arg3)
func_14A8() returns (r0)
func_153A(arg0) returns (r0)
func_157B(arg0, arg1, arg2)
func_15D6(arg0, arg1, arg2, arg3)
func_15DC(arg0, arg1, arg2, arg3)
func_15E2(arg0, arg1, arg2, arg3) returns (r0)
func_1769(arg0, arg1)
func_1986(arg0) returns (r0)
func_19A9() returns (r0)
func_19BD(arg0) returns (r0)
func_19E9(arg0)
func_1A00(arg0, arg1) returns (r0)
func_1A15(arg0, arg1) returns (r0)
func_1A42(arg0) returns (r0)
func_1A4E(arg0, arg1)
func_1A5D(arg0, arg1) returns (r0)
func_1A78(arg0) returns (r0)
func_1A83(arg0, arg1) returns (r0)
func_1A94(arg0, arg1, arg2)
func_1ABE(arg0) returns (r0)
func_1ACF(arg0, arg1) returns (r0)
func_1B08(arg0, arg1) returns (r0)
func_1B2A(arg0) returns (r0)
func_1B34(arg0)
func_1B4B(arg0, arg1) returns (r0)
func_1B60(arg0, arg1) returns (r0)
func_1B8D(arg0) returns (r0)
func_1BAD(arg0) returns (r0)
func_1BBF(arg0, arg1)
func_1BCE(arg0, arg1) returns (r0)
func_1BE9(arg0)
func_1C00(arg0, arg1) returns (r0)
func_1C15(arg0, arg1) returns (r0, r1)
func_1C55(arg0, arg1) returns (r0, r1, r2)
func_1CB7(arg0, arg1) returns (r0, r1)
func_1D0D(arg0, arg1) returns (r0, r1)
func_1D5A(arg0, arg1) returns (r0)
func_1D87(arg0, arg1)
func_1D96(arg0, arg1) returns (r0)
func_1DB1(arg0)
func_1DC8(arg0, arg1) returns (r0)
func_1DDD(arg0, arg1) returns (r0, r1)
func_1E51(arg0, arg1)
func_1E9D(arg0) returns (r0)
func_1ECE(arg0, arg1, arg2)
func_1EDD(arg0, arg1, arg2) returns (r0)
func_1EEB(arg0) returns (r0)
func_1F1F(arg0, arg1) returns (r0)
func_1F4D(arg0, arg1) returns (r0, r1, r2, r3)
func_1FD0(arg0, arg1) returns (r0, r1)
func_203F(arg0) returns (r0)
func_2070(arg0)
func_20BF(arg0) returns (r0)
func_20E2(arg0) returns (r0)
func_2102(arg0)
func_2151(arg0) returns (r0)
func_2174(arg0) returns (r0)
func_21C3(arg0) returns (r0)
func_220B(arg0)
func_225A(arg0) returns (r0)
func_227D(arg0) returns (r0)
func_229D(arg0)
func_22C6(arg0) returns (r0)
func_22E9(arg0) returns (r0)
func_2309(arg0, arg1) returns (r0)
func_2314(arg0) returns (r0)
func_2329(arg0) returns (r0)
func_2339(arg0, arg1) returns (r0)
func_23A2(arg0) returns (r0)
func_23B3(arg0) returns (r0)
func_23B8(arg0) returns (r0)
func_23C4(arg0) returns (r0)
func_23CE(arg0, arg1, arg2)
func_23E3(arg0, arg3, arg4) returns (r0)
func_23F3() returns (r0)
func_23F8(arg0, arg1)
func_2433(arg0, arg1, arg2)
func_2469(arg0, arg1, arg2)
func_2479(arg0, arg1) returns (r0)
func_2486(arg0, arg1) returns (r0)
func_24A4(arg0, arg1) returns (r0)
func_24C0(arg0, arg1, arg2)
func_2590(arg0)
func_25DF(arg0) returns (r0)
func_2602(arg0) returns (r0)
func_2622(arg0)
func_2671(arg0) returns (r0)
func_2694(arg0) returns (r0)
func_26B4(arg0)
func_26DD(arg0) returns (r0)
func_2700(arg0) returns (r0)
func_2720(arg0)
func_276F(arg0) returns (r0)
func_2792(arg0) returns (r0)
func_27B2(arg0)
func_2801(arg0) returns (r0)
func_2824(arg0) returns (r0)
func_2844(arg0)
func_286D(arg0) returns (r0)
func_2890(arg0) returns (r0)
func_28B0(arg0)
func_28D9(arg0) returns (r0)
func_28FC(arg0) returns (r0)
func_291C(arg0)
func_296B(arg0) returns (r0)
func_298E(arg0) returns (r0)
func_29AE(arg0) returns (r0)
func_29B9(arg0, arg1) returns (r0)
func_29CA(arg0, arg1) returns (r0)
func_2A03(arg0, arg1, arg2, arg3, arg4) returns (r0)
func_2A4F(arg0, arg1) returns (r0)
func_2A64(arg0, arg1) returns (r0)
func_2A91(arg0)
func_2ABA(arg0) returns (r0)
func_2ADD(arg0) returns (r0)
func_2AFD(arg0)
func_2B26(arg0) returns (r0)
func_2B49(arg0) returns (r0)

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x80; var var0 = msg.value; if (var0) { revert(memory[0x00:0x00]); } if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); } var0 = msg.data[0x00:0x20] >> 0xe0; if (0x70a08231 > var0) { if (0x23b872dd > var0) { if (var0 == 0x01ffc9a7) { // Dispatch table entry for supportsInterface(bytes4) var var1 = 0x014b; var var2 = 0x0146; var var4 = 0x04; var var3 = var4 + (msg.data.length - var4); var2 = func_1A15(var3, var4); var1 = func_0146(var2); var temp0 = var1; var1 = 0x0158; var2 = temp0; var3 = memory[0x40:0x60]; var1 = func_1A5D(var2, var3); var temp1 = memory[0x40:0x60]; return memory[temp1:temp1 + var1 - temp1]; } else if (var0 == 0x06fdde03) { // Dispatch table entry for name() var1 = 0x0169; var1 = func_0479(); var temp2 = var1; var1 = 0x0176; var2 = temp2; var3 = memory[0x40:0x60]; var1 = func_1B08(var2, var3); var temp3 = memory[0x40:0x60]; return memory[temp3:temp3 + var1 - temp3]; } else if (var0 == 0x081812fc) { // Dispatch table entry for getApproved(uint256) var1 = 0x0199; var2 = 0x0194; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2 = func_1B60(var3, var4); var1 = func_0194(var2); var temp4 = var1; var1 = 0x01a6; var2 = temp4; var3 = memory[0x40:0x60]; var1 = func_1BCE(var2, var3); var temp5 = memory[0x40:0x60]; return memory[temp5:temp5 + var1 - temp5]; } else if (var0 == 0x095ea7b3) { // Dispatch table entry for approve(address,uint256) var1 = 0x01c9; var2 = 0x01c4; var3 = msg.data.length - 0x04 + 0x04; var4 = 0x04; var2, var3 = func_1C15(var3, var4); func_01C4(var2, var3); stop(); } else if (var0 == 0x1249c58b) { // Dispatch table entry for mint() var1 = 0x01d3; mint(); stop(); } else { revert(memory[0x00:0x00]); } } else if (var0 == 0x23b872dd) { // Dispatch table entry for transferFrom(address,address,uint256) var1 = 0x01ef; var2 = 0x01ea; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2, var3, var4 = func_1C55(var3, var4); func_01EA(var2, var3, var4); stop(); } else if (var0 == 0x2be09561) { // Dispatch table entry for startMint() var1 = 0x01f9; startMint(); stop(); } else if (var0 == 0x42842e0e) { // Dispatch table entry for safeTransferFrom(address,address,uint256) var1 = 0x0215; var2 = 0x0210; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2, var3, var4 = func_1C55(var3, var4); func_0210(var2, var3, var4); stop(); } else if (var0 == 0x6352211e) { // Dispatch table entry for ownerOf(uint256) var1 = 0x0231; var2 = 0x022c; var3 = msg.data.length - 0x04 + 0x04; var4 = 0x04; var2 = func_1B60(var3, var4); var1 = func_022C(var2); var temp6 = var1; var1 = 0x023e; var3 = memory[0x40:0x60]; var2 = temp6; var1 = func_1BCE(var2, var3); var temp7 = memory[0x40:0x60]; return memory[temp7:temp7 + var1 - temp7]; } else if (var0 == 0x6e762527) { // Dispatch table entry for 0x6e762527 (unknown) var1 = 0x0261; var2 = 0x025c; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2, var3 = func_1D0D(var3, var4); func_025C(var2, var3); stop(); } else { revert(memory[0x00:0x00]); } } else if (0xb88d4fde > var0) { if (var0 == 0x70a08231) { // Dispatch table entry for balanceOf(address) var1 = 0x027d; var2 = 0x0278; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2 = func_1D5A(var3, var4); var1 = func_0278(var2); var temp8 = var1; var1 = 0x028a; var2 = temp8; var3 = memory[0x40:0x60]; var1 = func_1D96(var2, var3); var temp9 = memory[0x40:0x60]; return memory[temp9:temp9 + var1 - temp9]; } else if (var0 == 0x715018a6) { // Dispatch table entry for renounceOwnership() var1 = 0x029b; renounceOwnership(); stop(); } else if (var0 == 0x8da5cb5b) { // Dispatch table entry for owner() var1 = 0x02a5; var1 = func_08F8(); var temp10 = var1; var1 = 0x02b2; var3 = memory[0x40:0x60]; var2 = temp10; var1 = func_1BCE(var2, var3); var temp11 = memory[0x40:0x60]; return memory[temp11:temp11 + var1 - temp11]; } else if (var0 == 0x95d89b41) { // Dispatch table entry for symbol() var1 = 0x02c3; var1 = func_0921(); var temp12 = var1; var1 = 0x02d0; var3 = memory[0x40:0x60]; var2 = temp12; var1 = func_1B08(var2, var3); var temp13 = memory[0x40:0x60]; return memory[temp13:temp13 + var1 - temp13]; } else if (var0 == 0xa22cb465) { // Dispatch table entry for setApprovalForAll(address,bool) var1 = 0x02f3; var2 = 0x02ee; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2, var3 = func_1DDD(var3, var4); func_02EE(var2, var3); stop(); } else { revert(memory[0x00:0x00]); } } else if (var0 == 0xb88d4fde) { // Dispatch table entry for safeTransferFrom(address,address,uint256,bytes) var1 = 0x030f; var2 = 0x030a; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var var5; var2, var3, var4, var5 = func_1F4D(var3, var4); var var6, var7, var8, var9, var10 = func_030A(var2, var3, var4); stop(); } else if (var0 == 0xc87b56dd) { // Dispatch table entry for tokenURI(uint256) var1 = 0x032b; var2 = 0x0326; var3 = msg.data.length - 0x04 + 0x04; var4 = 0x04; var2 = func_1B60(var3, var4); var1 = func_0326(var2); var temp14 = var1; var1 = 0x0338; var2 = temp14; var3 = memory[0x40:0x60]; var1 = func_1B08(var2, var3); var temp15 = memory[0x40:0x60]; return memory[temp15:temp15 + var1 - temp15]; } else if (var0 == 0xd5582965) { // Dispatch table entry for stopMint() var1 = 0x0349; stopMint(); stop(); } else if (var0 == 0xe985e9c5) { // Dispatch table entry for isApprovedForAll(address,address) var1 = 0x0365; var2 = 0x0360; var3 = msg.data.length - 0x04 + 0x04; var4 = 0x04; var2, var3 = func_1FD0(var3, var4); var1 = func_0360(var2, var3); var temp16 = var1; var1 = 0x0372; var2 = temp16; var3 = memory[0x40:0x60]; var1 = func_1A5D(var2, var3); var temp17 = memory[0x40:0x60]; return memory[temp17:temp17 + var1 - temp17]; } else if (var0 == 0xf2fde38b) { // Dispatch table entry for transferOwnership(address) var1 = 0x0395; var2 = 0x0390; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2 = func_1D5A(var3, var4); func_0390(var2); stop(); } else { revert(memory[0x00:0x00]); } } function func_0146(var arg0) returns (var r0) { var var0 = 0x00; var var1 = arg0 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x80ac58cd00000000000000000000000000000000000000000000000000000000; if (!var1) { var1 = arg0 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x5b5e139f00000000000000000000000000000000000000000000000000000000; if (var1) { goto label_0472; } else { goto label_0468; } } else if (var1) { label_0472: return var1; } else { label_0468: var1 = 0x0471; var var2 = arg0; var1 = func_0BE6(var2); goto label_0472; } } function func_0194(var arg0) returns (var r0) { r0 = func_050B(arg0); // Error: Could not resolve method call return address! } function func_01C4(var arg0, var arg1) { var var0 = 0x00; var var1 = 0x055c; var var2 = arg1; var1 = func_0789(var2); var0 = var1; if ((arg0 & 0xffffffffffffffffffffffffffffffffffffffff) - (var0 & 0xffffffffffffffffffffffffffffffffffffffff)) { var1 = var0 & 0xffffffffffffffffffffffffffffffffffffffff; var2 = 0x05eb; var2 = func_0C9B(); var1 = var2 & 0xffffffffffffffffffffffffffffffffffffffff == var1; if (var1) { label_061A: if (var1) { var1 = 0x0663; var2 = arg0; var var3 = arg1; func_0CA3(var2, var3); return; } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var2 = temp0 + 0x04; var1 = 0x0650; var1 = func_2174(var2); var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + var1 - temp1]); } } else { var1 = 0x0619; var2 = var0; var3 = 0x0614; var3 = func_0C9B(); var1 = func_0614(var2, var3); goto label_061A; } } else { var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var2 = temp2 + 0x04; var1 = 0x05c3; var1 = func_20E2(var2); var temp3 = memory[0x40:0x60]; revert(memory[temp3:temp3 + var1 - temp3]); } } function func_01EA(var arg0, var arg1, var arg2) { var var0 = 0x06f5; var var1 = 0x06ef; var1 = func_0C9B(); var0 = func_06EF(arg2, var1); if (var0) { var0 = 0x073f; var1 = arg0; var var2 = arg1; var var3 = arg2; func_0E68(var1, var2, var3); return; } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var0 = 0x072b; var1 = temp0 + 0x04; var0 = func_227D(var1); var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + var0 - temp1]); } } function func_0210(var arg0, var arg1, var arg2) { var var0 = 0x0784; var var1 = arg0; var var2 = arg1; var var3 = arg2; var temp0 = memory[0x40:0x60]; var var4 = temp0; memory[0x40:0x60] = var4 + 0x20; memory[var4:var4 + 0x20] = 0x00; func_09C9(var1, var2, var3, var4); } function func_022C(var arg0) returns (var r0) { r0 = func_0789(arg0); // Error: Could not resolve method call return address! } function func_025C(var arg0, var arg1) { var var0 = 0x0817; func_1161(); var0 = 0x08; var var1 = 0x0828; var var2 = arg1; var var3 = arg0; var var4 = var0; func_24C0(var2, var3, var4); label_0828: } function func_0278(var arg0) returns (var r0) { var var0 = 0x00; if ((arg0 & 0xffffffffffffffffffffffffffffffffffffffff) - (var0 & 0xffffffffffffffffffffffffffffffffffffffff)) { memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x04; return storage[keccak256(memory[0x00:0x40])]; } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var var2 = temp0 + 0x04; var var1 = 0x0894; var1 = func_2602(var2); var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + var1 - temp1]); } } function func_02EE(var arg0, var arg1) { var var0 = 0x09c5; var var1 = 0x09be; var1 = func_0C9B(); func_09BE(arg0, arg1, var1); } function func_030A(var arg0, var arg1, var arg2) returns (var r0, var r1, var r2, var r3, var r4) { func_09C9(arg0, arg1, arg2, returnAddress1); // Error: Could not resolve method call return address! } function func_0326(var arg0) returns (var r0) { var var0 = 0x60; var var1 = 0xffffffffffffffffffffffffffffffffffffffff & 0x00; var var2 = 0x0a4e; var var3 = arg0; var2 = func_11DF(var3); if ((var2 & 0xffffffffffffffffffffffffffffffffffffffff) - var1) { var1 = 0x0aa3; return func_14A8(); } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x3f6cc76800000000000000000000000000000000000000000000000000000000; var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + (temp0 + 0x04) - temp1]); } } function func_0360(var arg0, var arg1) returns (var r0) { r0 = func_0ACF(arg0, arg1); // Error: Could not resolve method call return address! } function func_0390(var arg0) { var var0 = 0x0b6b; func_1161(); if (arg0 & 0xffffffffffffffffffffffffffffffffffffffff) { var0 = 0x0be3; var var1 = arg0; func_121C(var1); return; } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var0 = 0x0bd1; var1 = temp0 + 0x04; var0 = func_2694(var1); var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + var0 - temp1]); } } function func_0479() returns (var r0) { var var0 = 0x60; var var1 = 0x01; var var2 = 0x0488; var var3 = storage[var1]; var2 = func_203F(var3); var temp0 = var2; var temp1 = memory[0x40:0x60]; memory[0x40:0x60] = temp1 + (temp0 + 0x1f) / 0x20 * 0x20 + 0x20; var temp2 = var1; var1 = temp1; var2 = temp2; var3 = temp0; memory[var1:var1 + 0x20] = var3; var var4 = var1 + 0x20; var var5 = var2; var var7 = storage[var5]; var var6 = 0x04b4; var6 = func_203F(var7); if (!var6) { label_0501: return var1; } else if (0x1f < var6) { var temp3 = var4; var temp4 = temp3 + var6; var4 = temp4; memory[0x00:0x20] = var5; var temp5 = keccak256(memory[0x00:0x20]); memory[temp3:temp3 + 0x20] = storage[temp5]; var5 = temp5 + 0x01; var6 = temp3 + 0x20; if (var4 <= var6) { goto label_04F8; } label_04E4: var temp6 = var5; var temp7 = var6; memory[temp7:temp7 + 0x20] = storage[temp6]; var5 = temp6 + 0x01; var6 = temp7 + 0x20; if (var4 > var6) { goto label_04E4; } label_04F8: var temp8 = var4; var temp9 = temp8 + (var6 - temp8 & 0x1f); var6 = temp8; var4 = temp9; goto label_0501; } else { var temp10 = var4; memory[temp10:temp10 + 0x20] = storage[var5] / 0x0100 * 0x0100; var4 = temp10 + 0x20; var6 = var6; goto label_0501; } } function func_050B(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x0516; var var2 = arg0; func_0C50(var2); memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x05; return storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffffffffffffffffffffffffffff; } function func_0614(var arg0, var arg1) returns (var r0) { r0 = func_0ACF(arg0, arg1); // Error: Could not resolve method call return address! } function mint() { var var0 = 0x0670; func_0D5C(); if (storage[0x09] & 0xff) { var0 = 0x06c2; var var1 = msg.sender; var var2 = storage[0x0a]; func_0DAB(var1, var2); var0 = storage[0x0a]; var1 = 0x0a; var2 = 0x00; var var3 = 0x06d5; var var4 = var0; var3 = func_21C3(var4); storage[var1] = var3; var0 = 0x06e2; func_0DC9(); return; } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0xc6b0e90b00000000000000000000000000000000000000000000000000000000; var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + (temp0 + 0x04) - temp1]); } } function func_06EF(var arg0, var arg1) returns (var r0) { var var0 = arg0; var var1 = 0x00; var var2 = var1; var var3 = 0x0ddf; var var4 = var0; var3 = func_0789(var4); var2 = var3; var3 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff == var2 & 0xffffffffffffffffffffffffffffffffffffffff; if (var3) { label_0E21: if (var3) { label_0E5F: return var3; } else { var3 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; var4 = 0x0e47; var var5 = var0; var4 = func_050B(var5); var3 = var4 & 0xffffffffffffffffffffffffffffffffffffffff == var3; goto label_0E5F; } } else { var3 = 0x0e20; var4 = var2; var5 = arg1; var3 = func_0ACF(var4, var5); goto label_0E21; } } function startMint() { var var0 = 0x074c; func_1161(); storage[0x09] = (storage[0x09] & ~0xff) | 0x01; } function func_0789(var arg0) returns (var r0) { var var0 = 0x00; var var1 = var0; var var2 = 0x0795; var var3 = arg0; var2 = func_11DF(var3); var1 = var2; if (var1 & 0xffffffffffffffffffffffffffffffffffffffff) { return var1; } var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var3 = temp0 + 0x04; var2 = 0x07fd; var2 = func_22E9(var3); var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + var2 - temp1]); } function renounceOwnership() { var var0 = 0x08ec; func_1161(); var0 = 0x08f6; var var1 = 0x00; func_121C(var1); } function func_08F8() returns (var r0) { return storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff; } function func_0921() returns (var r0) { var var0 = 0x60; var var1 = 0x02; var var2 = 0x0930; var var3 = storage[var1]; var2 = func_203F(var3); var temp0 = var2; var temp1 = memory[0x40:0x60]; memory[0x40:0x60] = temp1 + (temp0 + 0x1f) / 0x20 * 0x20 + 0x20; var temp2 = var1; var1 = temp1; var2 = temp2; var3 = temp0; memory[var1:var1 + 0x20] = var3; var var4 = var1 + 0x20; var var5 = var2; var var7 = storage[var5]; var var6 = 0x095c; var6 = func_203F(var7); if (!var6) { label_09A9: return var1; } else if (0x1f < var6) { var temp3 = var4; var temp4 = temp3 + var6; var4 = temp4; memory[0x00:0x20] = var5; var temp5 = keccak256(memory[0x00:0x20]); memory[temp3:temp3 + 0x20] = storage[temp5]; var5 = temp5 + 0x01; var6 = temp3 + 0x20; if (var4 <= var6) { goto label_09A0; } label_098C: var temp6 = var5; var temp7 = var6; memory[temp7:temp7 + 0x20] = storage[temp6]; var5 = temp6 + 0x01; var6 = temp7 + 0x20; if (var4 > var6) { goto label_098C; } label_09A0: var temp8 = var4; var temp9 = temp8 + (var6 - temp8 & 0x1f); var6 = temp8; var4 = temp9; goto label_09A9; } else { var temp10 = var4; memory[temp10:temp10 + 0x20] = storage[var5] / 0x0100 * 0x0100; var4 = temp10 + 0x20; var6 = var6; goto label_09A9; } } function func_09BE(var arg0, var arg1, var arg2) { var var0 = arg0; var var1 = arg1; if ((arg2 & 0xffffffffffffffffffffffffffffffffffffffff) - (var0 & 0xffffffffffffffffffffffffffffffffffffffff)) { var temp0 = arg2; memory[0x00:0x20] = temp0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x06; var temp1 = keccak256(memory[0x00:0x40]); var temp2 = var0; memory[0x00:0x20] = temp2 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp1; var temp3 = keccak256(memory[0x00:0x40]); storage[temp3] = !!var1 | (storage[temp3] & ~0xff); var var2 = temp2 & 0xffffffffffffffffffffffffffffffffffffffff; var var3 = temp0 & 0xffffffffffffffffffffffffffffffffffffffff; var var4 = 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31; var var5 = 0x143f; var var7 = memory[0x40:0x60]; var var6 = var1; var5 = func_1A5D(var6, var7); var temp4 = memory[0x40:0x60]; log(memory[temp4:temp4 + var5 - temp4], [stack[-2], stack[-3], stack[-4]]); return; } else { var temp5 = memory[0x40:0x60]; memory[temp5:temp5 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var3 = temp5 + 0x04; var2 = 0x1345; var2 = func_28FC(var3); var temp6 = memory[0x40:0x60]; revert(memory[temp6:temp6 + var2 - temp6]); } } function func_09C9(var arg0, var arg1, var arg2, var arg3) { var var0 = 0x09da; var var1 = 0x09d4; var1 = func_0C9B(); var0 = func_09D4(arg2, var1); if (var0) { var0 = 0x0a25; var1 = arg0; var var2 = arg1; var var3 = arg2; var var4 = arg3; func_144C(var1, var2, var3, var4); return; } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp0 + 0x04; var0 = 0x0a10; var0 = func_227D(var1); var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + var0 - temp1]); } } function func_09D4(var arg0, var arg1) returns (var r0) { var var0 = arg0; var var1 = 0x00; var var2 = var1; var var3 = 0x0ddf; var var4 = var0; var3 = func_0789(var4); var2 = var3; var3 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff == var2 & 0xffffffffffffffffffffffffffffffffffffffff; if (var3) { label_0E21: if (var3) { label_0E5F: return var3; } else { var3 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; var4 = 0x0e47; var var5 = var0; var4 = func_050B(var5); var3 = var4 & 0xffffffffffffffffffffffffffffffffffffffff == var3; goto label_0E5F; } } else { var3 = 0x0e20; var4 = var2; var5 = arg1; var3 = func_0ACF(var4, var5); goto label_0E21; } } function stopMint() { var var0 = 0x0ab2; func_1161(); storage[0x09] = (storage[0x09] & ~0xff) | 0x00; } function func_0ACF(var arg0, var arg1) returns (var r0) { memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x06; var temp0 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp0; return storage[keccak256(memory[0x00:0x40])] & 0xff; } function func_0BE6(var arg0) returns (var r0) { return arg0 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x01ffc9a700000000000000000000000000000000000000000000000000000000; } function func_0C50(var arg0) { var var0 = 0x0c59; var var1 = arg0; var0 = func_153A(var1); if (var0) { return; } var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var0 = 0x0c8f; var1 = temp0 + 0x04; var0 = func_22E9(var1); var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + var0 - temp1]); } function func_0C9B() returns (var r0) { return msg.sender; } function func_0CA3(var arg0, var arg1) { var temp0 = arg0; memory[0x00:0x20] = arg1; memory[0x20:0x40] = 0x05; var temp1 = keccak256(memory[0x00:0x40]); storage[temp1] = (temp0 & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[temp1] & ~0xffffffffffffffffffffffffffffffffffffffff); var var0 = arg1; var var1 = temp0 & 0xffffffffffffffffffffffffffffffffffffffff; var var2 = 0x0d16; var var3 = var0; var2 = func_0789(var3); var temp2 = memory[0x40:0x60]; log(memory[temp2:temp2 + memory[0x40:0x60] - temp2], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2], stack[-3]]); } function func_0D5C() { if (storage[0x07] - 0x02) { storage[0x07] = 0x02; return; } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var var1 = temp0 + 0x04; var var0 = 0x0d98; var0 = func_2700(var1); var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + var0 - temp1]); } } function func_0DAB(var arg0, var arg1) { var var0 = 0x0dc5; var var1 = arg0; var var2 = arg1; var temp0 = memory[0x40:0x60]; var var3 = temp0; memory[0x40:0x60] = var3 + 0x20; memory[var3:var3 + 0x20] = 0x00; func_157B(var1, var2, var3); } function func_0DC9() { storage[0x07] = 0x01; } function func_0E68(var arg0, var arg1, var arg2) { var var0 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var var1 = 0x0e88; var var2 = arg2; var1 = func_0789(var2); if (var1 & 0xffffffffffffffffffffffffffffffffffffffff != var0) { var temp12 = memory[0x40:0x60]; memory[temp12:temp12 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var0 = 0x0ed5; var1 = temp12 + 0x04; var0 = func_2792(var1); var temp13 = memory[0x40:0x60]; revert(memory[temp13:temp13 + var0 - temp13]); } else if (arg1 & 0xffffffffffffffffffffffffffffffffffffffff) { var0 = 0x0f5a; var1 = arg0; var2 = arg1; var var3 = arg2; var var4 = 0x01; func_15D6(var1, var2, var3, var4); var0 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var1 = 0x0f7a; var2 = arg2; var1 = func_0789(var2); if (var1 & 0xffffffffffffffffffffffffffffffffffffffff == var0) { var temp0 = arg2; memory[0x00:0x20] = temp0; memory[0x20:0x40] = 0x05; var temp1 = keccak256(memory[0x00:0x40]); storage[temp1] = storage[temp1] & ~0xffffffffffffffffffffffffffffffffffffffff; var temp2 = arg0; memory[0x00:0x20] = temp2 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x04; var temp3 = keccak256(memory[0x00:0x40]); storage[temp3] = storage[temp3] - 0x01; var temp4 = arg1; memory[0x00:0x20] = temp4 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x04; var temp5 = keccak256(memory[0x00:0x40]); storage[temp5] = storage[temp5] + 0x01; memory[0x00:0x20] = temp0; memory[0x20:0x40] = 0x03; var temp6 = keccak256(memory[0x00:0x40]); storage[temp6] = (temp4 & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[temp6] & ~0xffffffffffffffffffffffffffffffffffffffff); var temp7 = memory[0x40:0x60]; log(memory[temp7:temp7 + memory[0x40:0x60] - temp7], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1]]); var0 = 0x115c; var1 = temp2; var2 = temp4; var3 = temp0; var4 = 0x01; func_15DC(var1, var2, var3, var4); return; } else { var temp8 = memory[0x40:0x60]; memory[temp8:temp8 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var0 = 0x0fc7; var1 = temp8 + 0x04; var0 = func_2792(var1); var temp9 = memory[0x40:0x60]; revert(memory[temp9:temp9 + var0 - temp9]); } } else { var temp10 = memory[0x40:0x60]; memory[temp10:temp10 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var0 = 0x0f44; var1 = temp10 + 0x04; var0 = func_2824(var1); var temp11 = memory[0x40:0x60]; revert(memory[temp11:temp11 + var0 - temp11]); } } function func_1161() { var var0 = 0x1169; var0 = func_0C9B(); var0 = var0 & 0xffffffffffffffffffffffffffffffffffffffff; var var1 = 0x1187; var1 = func_08F8(); if (var1 & 0xffffffffffffffffffffffffffffffffffffffff == var0) { return; } var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var0 = 0x11d4; var1 = temp0 + 0x04; var0 = func_2890(var1); var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + var0 - temp1]); } function func_11DF(var arg0) returns (var r0) { memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x03; return storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffffffffffffffffffffffffffff; } function func_121C(var arg0) { var temp0 = storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff; var temp1 = arg0; storage[0x00] = (temp1 & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[0x00] & ~0xffffffffffffffffffffffffffffffffffffffff); var temp2 = memory[0x40:0x60]; log(memory[temp2:temp2 + memory[0x40:0x60] - temp2], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); } function func_144C(var arg0, var arg1, var arg2, var arg3) { var var0 = 0x1457; var var1 = arg0; var var2 = arg1; var var3 = arg2; func_0E68(var1, var2, var3); var0 = 0x1463; var1 = arg0; var2 = arg1; var3 = arg2; var var4 = arg3; var0 = func_15E2(var1, var2, var3, var4); if (var0) { return; } var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp0 + 0x04; var0 = 0x1499; var0 = func_298E(var1); var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + var0 - temp1]); } function func_14A8() returns (var r0) { var var0 = 0x60; var var1 = 0x08; var var2 = 0x14b7; var var3 = storage[var1]; var2 = func_203F(var3); var temp0 = var2; var temp1 = memory[0x40:0x60]; memory[0x40:0x60] = temp1 + (temp0 + 0x1f) / 0x20 * 0x20 + 0x20; var temp2 = var1; var1 = temp1; var2 = temp2; var3 = temp0; memory[var1:var1 + 0x20] = var3; var var4 = var1 + 0x20; var var5 = var2; var var7 = storage[var5]; var var6 = 0x14e3; var6 = func_203F(var7); if (!var6) { label_1530: return var1; } else if (0x1f < var6) { var temp3 = var4; var temp4 = temp3 + var6; var4 = temp4; memory[0x00:0x20] = var5; var temp5 = keccak256(memory[0x00:0x20]); memory[temp3:temp3 + 0x20] = storage[temp5]; var5 = temp5 + 0x01; var6 = temp3 + 0x20; if (var4 <= var6) { goto label_1527; } label_1513: var temp6 = var5; var temp7 = var6; memory[temp7:temp7 + 0x20] = storage[temp6]; var5 = temp6 + 0x01; var6 = temp7 + 0x20; if (var4 > var6) { goto label_1513; } label_1527: var temp8 = var4; var temp9 = temp8 + (var6 - temp8 & 0x1f); var6 = temp8; var4 = temp9; goto label_1530; } else { var temp10 = var4; memory[temp10:temp10 + 0x20] = storage[var5] / 0x0100 * 0x0100; var6 = var6; var4 = temp10 + 0x20; goto label_1530; } } function func_153A(var arg0) returns (var r0) { var var0 = 0x00; var var1 = var0 & 0xffffffffffffffffffffffffffffffffffffffff; var var2 = 0x155c; var var3 = arg0; var2 = func_11DF(var3); return var2 & 0xffffffffffffffffffffffffffffffffffffffff != var1; } function func_157B(var arg0, var arg1, var arg2) { var var0 = 0x1585; var var1 = arg0; var var2 = arg1; func_1769(var1, var2); var0 = 0x1592; var1 = 0x00; var2 = arg0; var var3 = arg1; var var4 = arg2; var0 = func_15E2(var1, var2, var3, var4); if (var0) { return; } var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp0 + 0x04; var0 = 0x15c8; var0 = func_298E(var1); var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + var0 - temp1]); } function func_15D6(var arg0, var arg1, var arg2, var arg3) {} function func_15DC(var arg0, var arg1, var arg2, var arg3) {} function func_15E2(var arg0, var arg1, var arg2, var arg3) returns (var r0) { var var0 = 0x00; var var1 = 0x1603; var var2 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; var1 = func_1986(var2); if (!var1) { return 0x01; } var1 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; var2 = 0x150b7a02; var var3 = 0x162c; var3 = func_0C9B(); var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = (var2 & 0xffffffff) << 0xe0; var temp1 = var3; var3 = 0x164e; var var4 = temp1; var var5 = arg0; var var6 = arg2; var var8 = temp0 + 0x04; var var7 = arg3; var3 = func_2A03(var4, var5, var6, var7, var8); var temp2 = memory[0x40:0x60]; var temp3; temp3, memory[temp2:temp2 + 0x20] = address(var1).call.gas(msg.gas)(memory[temp2:temp2 + var3 - temp2]); if (!temp3) { label_168A: if (var1) { arg3 = var0 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0x150b7a02 << 0xe0); // Error: StackRead before write??? var var-6; var-6 = arg3; // Error: Could not resolve jump destination! } else { var1 = returndata.length; var2 = var1; if (var2 == 0x00) { var1 = 0x60; if (memory[var1:var1 + 0x20]) { label_1704: var temp4 = var1; revert(memory[temp4 + 0x20:temp4 + 0x20 + memory[temp4:temp4 + 0x20]]); } else { label_16CA: var temp5 = memory[0x40:0x60]; memory[temp5:temp5 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var2 = 0x16fb; var3 = temp5 + 0x04; var2 = func_298E(var3); var temp6 = memory[0x40:0x60]; revert(memory[temp6:temp6 + var2 - temp6]); } } else { var temp7 = memory[0x40:0x60]; var1 = temp7; memory[0x40:0x60] = var1 + (returndata.length + 0x3f & ~0x1f); memory[var1:var1 + 0x20] = returndata.length; var temp8 = returndata.length; memory[var1 + 0x20:var1 + 0x20 + temp8] = returndata[0x00:0x00 + temp8]; if (memory[var1:var1 + 0x20]) { goto label_1704; } else { goto label_16CA; } } } } else { var temp9 = memory[0x40:0x60]; var temp10 = returndata.length; memory[0x40:0x60] = temp9 + (temp10 + 0x1f & ~0x1f); var1 = 0x1687; var2 = temp9 + temp10; var3 = temp9; var1 = func_2A64(var2, var3); var2 = 0x01; goto label_168A; } } function func_1769(var arg0, var arg1) { if (arg0 & 0xffffffffffffffffffffffffffffffffffffffff) { var var0 = 0x17e1; var var1 = arg1; var0 = func_153A(var1); if (!var0) { var0 = 0x182f; var1 = 0x00; var var2 = arg0; var var3 = arg1; var var4 = 0x01; func_15D6(var1, var2, var3, var4); var0 = 0x1838; var1 = arg1; var0 = func_153A(var1); if (!var0) { var temp0 = arg0; memory[0x00:0x20] = temp0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x04; var temp1 = keccak256(memory[0x00:0x40]); storage[temp1] = storage[temp1] + 0x01; var temp2 = arg1; memory[0x00:0x20] = temp2; memory[0x20:0x40] = 0x03; var temp3 = keccak256(memory[0x00:0x40]); storage[temp3] = (temp0 & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[temp3] & ~0xffffffffffffffffffffffffffffffffffffffff); var temp4 = memory[0x40:0x60]; log(memory[temp4:temp4 + memory[0x40:0x60] - temp4], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0xffffffffffffffffffffffffffffffffffffffff & 0x00, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1]]); var0 = 0x1982; var1 = 0x00; var2 = temp0; var3 = temp2; var4 = 0x01; func_15DC(var1, var2, var3, var4); return; } else { var temp5 = memory[0x40:0x60]; memory[temp5:temp5 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp5 + 0x04; var0 = 0x186f; var0 = func_2B49(var1); var temp6 = memory[0x40:0x60]; revert(memory[temp6:temp6 + var0 - temp6]); } } else { var temp7 = memory[0x40:0x60]; memory[temp7:temp7 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var0 = 0x1818; var1 = temp7 + 0x04; var0 = func_2B49(var1); var temp8 = memory[0x40:0x60]; revert(memory[temp8:temp8 + var0 - temp8]); } } else { var temp9 = memory[0x40:0x60]; memory[temp9:temp9 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var0 = 0x17cf; var1 = temp9 + 0x04; var0 = func_2ADD(var1); var temp10 = memory[0x40:0x60]; revert(memory[temp10:temp10 + var0 - temp10]); } } function func_1986(var arg0) returns (var r0) { return address(arg0 & 0xffffffffffffffffffffffffffffffffffffffff).code.length > 0x00; } function func_19A9() returns (var r0) { return memory[0x40:0x60]; } function func_19BD(var arg0) returns (var r0) { return arg0 & 0xffffffff00000000000000000000000000000000000000000000000000000000; } function func_19E9(var arg0) { var var0 = 0x19f2; var var1 = arg0; var0 = func_19BD(var1); if (arg0 == var0) { return; } else { revert(memory[0x00:0x00]); } } function func_1A00(var arg0, var arg1) returns (var r0) { var var0 = msg.data[arg1:arg1 + 0x20]; var var1 = 0x1a0f; var var2 = var0; func_19E9(var2); return var0; } function func_1A15(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg0 - arg1 i>= 0x20) { var var1 = 0x00; var var2 = 0x1a39; var var3 = arg0; var var4 = arg1 + var1; return func_1A00(var3, var4); } else { var1 = 0x1a2a; revert(memory[0x00:0x00]); } } function func_1A42(var arg0) returns (var r0) { return !!arg0; } function func_1A4E(var arg0, var arg1) { var var0 = 0x1a57; var var1 = arg1; var0 = func_1A42(var1); memory[arg0:arg0 + 0x20] = var0; } function func_1A5D(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; var var1 = 0x1a72; var var2 = temp0; var var3 = arg0; func_1A4E(var2, var3); return var0; } function func_1A78(var arg0) returns (var r0) { return memory[arg0:arg0 + 0x20]; } function func_1A83(var arg0, var arg1) returns (var r0) { var temp0 = arg1; memory[temp0:temp0 + 0x20] = arg0; return temp0 + 0x20; } function func_1A94(var arg0, var arg1, var arg2) { var var0 = 0x00; if (var0 >= arg0) { label_1AB2: memory[arg1 + arg0:arg1 + arg0 + 0x20] = 0x00; return; } else { label_1AA0: var temp0 = var0; memory[arg1 + temp0:arg1 + temp0 + 0x20] = memory[arg2 + temp0:arg2 + temp0 + 0x20]; var0 = temp0 + 0x20; if (var0 >= arg0) { goto label_1AB2; } else { goto label_1AA0; } } } function func_1ABE(var arg0) returns (var r0) { return arg0 + 0x1f & ~0x1f; } function func_1ACF(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x1ada; var var2 = arg1; var1 = func_1A78(var2); var2 = 0x1ae4; var var3 = var1; var var4 = arg0; var2 = func_1A83(var3, var4); var temp0 = var2; arg0 = temp0; var2 = 0x1af4; var3 = var1; var4 = arg0; var var5 = arg1 + 0x20; func_1A94(var3, var4, var5); var2 = 0x1afd; var3 = var1; var2 = func_1ABE(var3); return arg0 + var2; } function func_1B08(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x1b22; var var2 = var0; var var3 = arg0; return func_1ACF(var2, var3); } function func_1B2A(var arg0) returns (var r0) { return arg0; } function func_1B34(var arg0) { var var0 = 0x1b3d; var var1 = arg0; var0 = func_1B2A(var1); if (arg0 == var0) { return; } else { revert(memory[0x00:0x00]); } } function func_1B4B(var arg0, var arg1) returns (var r0) { var var0 = msg.data[arg1:arg1 + 0x20]; var var1 = 0x1b5a; var var2 = var0; func_1B34(var2); return var0; } function func_1B60(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg0 - arg1 i>= 0x20) { var var1 = 0x00; var var2 = 0x1b84; var var3 = arg0; var var4 = arg1 + var1; return func_1B4B(var3, var4); } else { var1 = 0x1b75; revert(memory[0x00:0x00]); } } function func_1B8D(var arg0) returns (var r0) { return arg0 & 0xffffffffffffffffffffffffffffffffffffffff; } function func_1BAD(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x1bb8; var var2 = arg0; return func_1B8D(var2); } function func_1BBF(var arg0, var arg1) { var var0 = 0x1bc8; var var1 = arg1; var0 = func_1BAD(var1); memory[arg0:arg0 + 0x20] = var0; } function func_1BCE(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; var var1 = 0x1be3; var var2 = temp0; var var3 = arg0; func_1BBF(var2, var3); return var0; } function func_1BE9(var arg0) { var var0 = 0x1bf2; var var1 = arg0; var0 = func_1BAD(var1); if (arg0 == var0) { return; } else { revert(memory[0x00:0x00]); } } function func_1C00(var arg0, var arg1) returns (var r0) { var var0 = msg.data[arg1:arg1 + 0x20]; var var1 = 0x1c0f; var var2 = var0; func_1BE9(var2); return var0; } function func_1C15(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; if (arg0 - arg1 i>= 0x40) { var var2 = 0x00; var var3 = 0x1c3a; var var4 = arg0; var var5 = arg1 + var2; var3 = func_1C00(var4, var5); var0 = var3; var2 = 0x20; var3 = 0x1c4b; var4 = arg0; var5 = arg1 + var2; var3 = func_1B4B(var4, var5); arg0 = var3; r0 = var0; return r0, arg0; } else { var2 = 0x1c2b; revert(memory[0x00:0x00]); } } function func_1C55(var arg0, var arg1) returns (var r0, var arg0, var arg1) { var var0 = 0x00; var var1 = var0; var var2 = 0x00; if (arg0 - arg1 i>= 0x60) { var var3 = 0x00; var var4 = 0x1c7c; var var5 = arg0; var var6 = arg1 + var3; var4 = func_1C00(var5, var6); var0 = var4; var3 = 0x20; var4 = 0x1c8d; var5 = arg0; var6 = arg1 + var3; var4 = func_1C00(var5, var6); var1 = var4; var3 = 0x40; var4 = 0x1c9e; var5 = arg0; var6 = arg1 + var3; var4 = func_1B4B(var5, var6); arg1 = var4; arg0 = var1; r0 = var0; return r0, arg0, arg1; } else { var3 = 0x1c6d; revert(memory[0x00:0x00]); } } function func_1CB7(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; if (arg1 + 0x1f i< arg0) { var1 = msg.data[arg1:arg1 + 0x20]; if (var1 <= 0xffffffffffffffff) { var0 = arg1 + 0x20; if (var0 + var1 <= arg0) { arg0 = var1; r0 = var0; return r0, arg0; } else { var var2 = 0x1d05; revert(memory[0x00:0x00]); } } else { var2 = 0x1ce9; revert(memory[0x00:0x00]); } } else { var2 = 0x1ccc; revert(memory[0x00:0x00]); } } function func_1D0D(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; if (arg0 - arg1 i>= 0x20) { var var2 = msg.data[arg1:arg1 + 0x20]; if (var2 <= 0xffffffffffffffff) { var var3 = 0x1d4e; var var4 = arg0; var var5 = arg1 + var2; var3, var4 = func_1CB7(var4, var5); arg0 = var4; r0 = var3; return r0, arg0; } else { var3 = 0x1d41; revert(memory[0x00:0x00]); } } else { var2 = 0x1d23; revert(memory[0x00:0x00]); } } function func_1D5A(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg0 - arg1 i>= 0x20) { var var1 = 0x00; var var2 = 0x1d7e; var var3 = arg0; var var4 = arg1 + var1; return func_1C00(var3, var4); } else { var1 = 0x1d6f; revert(memory[0x00:0x00]); } } function func_1D87(var arg0, var arg1) { var var0 = 0x1d90; var var1 = arg1; var0 = func_1B2A(var1); memory[arg0:arg0 + 0x20] = var0; } function func_1D96(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; var var1 = 0x1dab; var var2 = temp0; var var3 = arg0; func_1D87(var2, var3); return var0; } function func_1DB1(var arg0) { var var0 = 0x1dba; var var1 = arg0; var0 = func_1A42(var1); if (arg0 == var0) { return; } else { revert(memory[0x00:0x00]); } } function func_1DC8(var arg0, var arg1) returns (var r0) { var var0 = msg.data[arg1:arg1 + 0x20]; var var1 = 0x1dd7; var var2 = var0; func_1DB1(var2); return var0; } function func_1DDD(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; if (arg0 - arg1 i>= 0x40) { var var2 = 0x00; var var3 = 0x1e02; var var4 = arg0; var var5 = arg1 + var2; var3 = func_1C00(var4, var5); var0 = var3; var2 = 0x20; var3 = 0x1e13; var4 = arg0; var5 = arg1 + var2; var3 = func_1DC8(var4, var5); arg0 = var3; r0 = var0; return r0, arg0; } else { var2 = 0x1df3; revert(memory[0x00:0x00]); } } function func_1E51(var arg0, var arg1) { var var0 = 0x1e5a; var var1 = arg0; var0 = func_1ABE(var1); var temp0 = arg1; var temp1 = temp0 + var0; var0 = temp1; if (!((var0 > 0xffffffffffffffff) | (var0 < temp0))) { memory[0x40:0x60] = var0; return; } else { var1 = 0x1e78; memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x41; revert(memory[0x00:0x24]); } } function func_1E9D(var arg0) returns (var r0) { var var0 = 0x00; if (arg0 <= 0xffffffffffffffff) { var var1 = 0x1ec1; var var2 = arg0; var1 = func_1ABE(var2); return var1 + 0x20; } else { var1 = 0x1eb7; memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x41; revert(memory[0x00:0x24]); } } function func_1ECE(var arg0, var arg1, var arg2) { var temp0 = arg0; var temp1 = arg1; memory[temp1:temp1 + temp0] = msg.data[arg2:arg2 + temp0]; memory[temp1 + temp0:temp1 + temp0 + 0x20] = 0x00; } function func_1EDD(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x00; var var1 = 0x1ef0; var var2 = 0x1eeb; var var3 = arg1; var2 = func_1E9D(var3); var1 = func_1EEB(var2); var temp0 = var1; var0 = temp0; var temp1 = arg1; memory[var0:var0 + 0x20] = temp1; var1 = var0 + 0x20; if (arg2 + temp1 <= arg0) { var2 = 0x1f17; var3 = arg1; var var4 = var1; var var5 = arg2; func_1ECE(var3, var4, var5); return var0; } else { var2 = 0x1f0b; revert(memory[0x00:0x00]); } } function func_1EEB(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x1e8c; var1 = func_19A9(); var temp0 = var1; var0 = temp0; var1 = 0x1e98; var var2 = arg0; var var3 = var0; func_1E51(var2, var3); return var0; } function func_1F1F(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg1 + 0x1f i< arg0) { var temp0 = arg1; var var1 = msg.data[temp0:temp0 + 0x20]; var var2 = 0x1f44; var var3 = arg0; var var4 = var1; var var5 = temp0 + 0x20; return func_1EDD(var3, var4, var5); } else { var1 = 0x1f33; revert(memory[0x00:0x00]); } } function func_1F4D(var arg0, var arg1) returns (var r0, var arg0, var arg1, var r3) { r3 = 0x00; var var1 = r3; var var2 = 0x00; var var3 = var2; if (arg0 - arg1 i>= 0x80) { var var4 = 0x00; var var5 = 0x1f75; var var6 = arg0; var var7 = arg1 + var4; var5 = func_1C00(var6, var7); r3 = var5; var4 = 0x20; var5 = 0x1f86; var6 = arg0; var7 = arg1 + var4; var5 = func_1C00(var6, var7); var1 = var5; var4 = 0x40; var5 = 0x1f97; var6 = arg0; var7 = arg1 + var4; var5 = func_1B4B(var6, var7); var2 = var5; var4 = msg.data[arg1 + 0x60:arg1 + 0x60 + 0x20]; if (var4 <= 0xffffffffffffffff) { var5 = 0x1fc4; var6 = arg0; var7 = arg1 + var4; var5 = func_1F1F(var6, var7); var temp0 = r3; r3 = var5; r0 = temp0; arg0 = var1; arg1 = var2; return r0, arg0, arg1, r3; } else { var5 = 0x1fb7; revert(memory[0x00:0x00]); } } else { var4 = 0x1f66; revert(memory[0x00:0x00]); } } function func_1FD0(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; if (arg0 - arg1 i>= 0x40) { var var2 = 0x00; var var3 = 0x1ff5; var var4 = arg0; var var5 = arg1 + var2; var3 = func_1C00(var4, var5); var0 = var3; var2 = 0x20; var3 = 0x2006; var4 = arg0; var5 = arg1 + var2; var3 = func_1C00(var4, var5); arg0 = var3; r0 = var0; return r0, arg0; } else { var2 = 0x1fe6; revert(memory[0x00:0x00]); } } function func_203F(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 / 0x02; var var1 = temp0 & 0x01; if (!var1) { var temp1 = var0 & 0x7f; var0 = temp1; if (var1 - (var0 < 0x20)) { goto label_206A; } else { goto label_2062; } } else if (var1 - (var0 < 0x20)) { label_206A: return var0; } else { label_2062: var var2 = 0x2069; memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x22; revert(memory[0x00:0x24]); } } function func_2070(var arg0) { var temp0 = arg0; memory[temp0:temp0 + 0x20] = 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x7200000000000000000000000000000000000000000000000000000000000000; } function func_20BF(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x20cc; var var2 = 0x21; var var3 = arg0; var1 = func_1A83(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x20d7; var2 = arg0; func_2070(var2); return arg0 + 0x40; } function func_20E2(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x20fb; var var2 = var0; return func_20BF(var2); } function func_2102(var arg0) { var temp0 = arg0; memory[temp0:temp0 + 0x20] = 0x4552433732313a20617070726f76652063616c6c6572206973206e6f7420746f; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x6b656e206f776e6572206f7220617070726f76656420666f7220616c6c000000; } function func_2151(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x215e; var var2 = 0x3d; var var3 = arg0; var1 = func_1A83(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x2169; var2 = arg0; func_2102(var2); return arg0 + 0x40; } function func_2174(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x218d; var var2 = var0; return func_2151(var2); } function func_21C3(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x21ce; var var2 = arg0; var1 = func_1B2A(var2); arg0 = var1; if (arg0 - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { return arg0 + 0x01; } var1 = 0x21ff; memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x11; revert(memory[0x00:0x24]); } function func_220B(var arg0) { var temp0 = arg0; memory[temp0:temp0 + 0x20] = 0x4552433732313a2063616c6c6572206973206e6f7420746f6b656e206f776e65; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x72206f7220617070726f76656400000000000000000000000000000000000000; } function func_225A(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x2267; var var2 = 0x2d; var var3 = arg0; var1 = func_1A83(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x2272; var2 = arg0; func_220B(var2); return arg0 + 0x40; } function func_227D(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x2296; var var2 = var0; return func_225A(var2); } function func_229D(var arg0) { memory[arg0:arg0 + 0x20] = 0x4552433732313a20696e76616c696420746f6b656e2049440000000000000000; } function func_22C6(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x22d3; var var2 = 0x18; var var3 = arg0; var1 = func_1A83(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x22de; var2 = arg0; func_229D(var2); return arg0 + 0x20; } function func_22E9(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x2302; var var2 = var0; return func_22C6(var2); } function func_2309(var arg0, var arg1) returns (var r0) { return arg0; } function func_2314(var arg0) returns (var r0) { memory[0x00:0x20] = arg0; return keccak256(memory[0x00:0x20]); } function func_2329(var arg0) returns (var r0) { return (arg0 + 0x1f) / 0x20; } function func_2339(var arg0, var arg1) returns (var r0) { return arg0 << arg1; } function func_23A2(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x23bd; var var2 = 0x23b8; var var3 = 0x23b3; var var4 = arg0; var3 = func_1B2A(var4); var2 = func_23B3(var3); return func_23B8(var2); } function func_23B3(var arg0) returns (var r0) { return arg0; } function func_23B8(var arg0) returns (var r0) { r0 = func_1B2A(arg0); // Error: Could not resolve method call return address! } function func_23C4(var arg0) returns (var r0) { return arg0; } function func_23CE(var arg0, var arg1, var arg2) { var var0 = 0x23d7; var var1 = arg0; var0 = func_23A2(var1); var1 = 0x23eb; var var2 = 0x23e3; var var3 = var0; var2 = func_23C4(var3); var1 = func_23E3(arg1, arg2, var2); storage[arg2] = var1; } function func_23E3(var arg0, var arg1, var arg2) returns (var r0) { var var0 = arg0; var var1 = storage[arg1]; var var2 = 0x00; var var3 = var0 * 0x08; var var4 = 0x2376; var var5 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; var var6 = var3; var4 = func_2339(var5, var6); var5 = 0x2380; var6 = arg2; var var7 = var3; var5 = func_2339(var6, var7); var temp0 = var4; return (var1 & ~temp0) | (var5 & temp0); } function func_23F3() returns (var r0) { return 0x00; } function func_23F8(var arg0, var arg1) { var var0 = 0x2400; var0 = func_23F3(); var var1 = 0x240b; var var2 = var0; var var3 = arg0; var var4 = arg1; func_23CE(var2, var3, var4); } function func_2433(var arg0, var arg1, var arg2) { if (arg1 <= 0x1f) { label_2474: return; } else { var var0 = 0x2445; var var1 = arg2; var0 = func_2314(var1); var1 = 0x244e; var var2 = arg0; var1 = func_2329(var2); var1 = var0 + var1; if (arg0 >= 0x20) { var2 = 0x2471; var var3 = 0x2469; var var4 = arg1; var3 = func_2329(var4); func_2469(var0, var1, var3); label_2471: goto label_2474; } else { var1 = var0; var2 = 0x2471; var3 = 0x2469; var4 = arg1; var3 = func_2329(var4); func_2469(var0, var1, var3); goto label_2471; } } } function func_2469(var arg0, var arg1, var arg2) { arg2 = arg0 + arg2; var var0 = arg1; if (var0 >= arg2) { label_242F: return; } else { label_241A: var var1 = 0x2424; var var2 = 0x00; var var3 = var0; func_23F8(var2, var3); var0 = var0 + 0x01; if (var0 >= arg2) { goto label_242F; } else { goto label_241A; } } } function func_2479(var arg0, var arg1) returns (var r0) { return arg0 >> arg1; } function func_2486(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x2497; var var2 = ~0x00; var var3 = arg0 * 0x08; var1 = func_2479(var2, var3); return arg1 & ~var1; } function func_24A4(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x24b0; var var2 = arg0; var var3 = arg1; var1 = func_2486(var2, var3); return var1 | arg0 * 0x02; } function func_24C0(var arg0, var arg1, var arg2) { var var0 = 0x24ca; var var1 = arg0; var var2 = arg1; var0 = func_2309(var1, var2); if (var0 <= 0xffffffffffffffff) { var1 = 0x24ed; var2 = storage[arg2]; var1 = func_203F(var2); var2 = 0x24f8; var var3 = var0; var var4 = var1; var var5 = arg2; func_2433(var3, var4, var5); var2 = 0x00; var3 = var0 > 0x1f; if (var3 == 0x01) { var4 = var0 & ~0x1f; var5 = 0x2535; var var6 = arg2; var5 = func_2314(var6); var6 = 0x00; if (var6 >= var4) { label_255D: if (var4 >= var0) { label_257A: storage[arg2] = var0 * 0x02 + 0x01; return; } else { var var7 = msg.data[arg1 + var2:arg1 + var2 + 0x20]; var var8 = 0x2576; var var9 = var0 & 0x1f; var var10 = var7; var8 = func_2486(var9, var10); storage[var5] = var8; goto label_257A; } } else { label_2541: var temp0 = var2; var temp1 = var5; storage[temp1] = msg.data[arg1 + temp0:arg1 + temp0 + 0x20]; var5 = temp1 + 0x01; var2 = temp0 + 0x20; var6 = var6 + 0x20; if (var6 >= var4) { goto label_255D; } else { goto label_2541; } } } else { var4 = 0x00; if (!var0) { var5 = 0x251f; var6 = var0; var7 = var4; var5 = func_24A4(var6, var7); label_251F: storage[arg2] = var5; return; } else { var4 = msg.data[arg1 + var2:arg1 + var2 + 0x20]; var5 = 0x251f; var6 = var0; var7 = var4; var5 = func_24A4(var6, var7); goto label_251F; } } } else { var1 = 0x24e2; memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x41; revert(memory[0x00:0x24]); } } function func_2590(var arg0) { var temp0 = arg0; memory[temp0:temp0 + 0x20] = 0x4552433732313a2061646472657373207a65726f206973206e6f742061207661; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x6c6964206f776e65720000000000000000000000000000000000000000000000; } function func_25DF(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x25ec; var var2 = 0x29; var var3 = arg0; var1 = func_1A83(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x25f7; var2 = arg0; func_2590(var2); return arg0 + 0x40; } function func_2602(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x261b; var var2 = var0; return func_25DF(var2); } function func_2622(var arg0) { var temp0 = arg0; memory[temp0:temp0 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000; } function func_2671(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x267e; var var2 = 0x26; var var3 = arg0; var1 = func_1A83(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x2689; var2 = arg0; func_2622(var2); return arg0 + 0x40; } function func_2694(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x26ad; var var2 = var0; return func_2671(var2); } function func_26B4(var arg0) { memory[arg0:arg0 + 0x20] = 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00; } function func_26DD(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x26ea; var var2 = 0x1f; var var3 = arg0; var1 = func_1A83(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x26f5; var2 = arg0; func_26B4(var2); return arg0 + 0x20; } function func_2700(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x2719; var var2 = var0; return func_26DD(var2); } function func_2720(var arg0) { var temp0 = arg0; memory[temp0:temp0 + 0x20] = 0x4552433732313a207472616e736665722066726f6d20696e636f727265637420; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x6f776e6572000000000000000000000000000000000000000000000000000000; } function func_276F(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x277c; var var2 = 0x25; var var3 = arg0; var1 = func_1A83(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x2787; var2 = arg0; func_2720(var2); return arg0 + 0x40; } function func_2792(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x27ab; var var2 = var0; return func_276F(var2); } function func_27B2(var arg0) { var temp0 = arg0; memory[temp0:temp0 + 0x20] = 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x7265737300000000000000000000000000000000000000000000000000000000; } function func_2801(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x280e; var var2 = 0x24; var var3 = arg0; var1 = func_1A83(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x2819; var2 = arg0; func_27B2(var2); return arg0 + 0x40; } function func_2824(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x283d; var var2 = var0; return func_2801(var2); } function func_2844(var arg0) { memory[arg0:arg0 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572; } function func_286D(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x287a; var var2 = 0x20; var var3 = arg0; var1 = func_1A83(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x2885; var2 = arg0; func_2844(var2); return arg0 + 0x20; } function func_2890(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x28a9; var var2 = var0; return func_286D(var2); } function func_28B0(var arg0) { memory[arg0:arg0 + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000; } function func_28D9(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x28e6; var var2 = 0x19; var var3 = arg0; var1 = func_1A83(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x28f1; var2 = arg0; func_28B0(var2); return arg0 + 0x20; } function func_28FC(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x2915; var var2 = var0; return func_28D9(var2); } function func_291C(var arg0) { var temp0 = arg0; memory[temp0:temp0 + 0x20] = 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x63656976657220696d706c656d656e7465720000000000000000000000000000; } function func_296B(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x2978; var var2 = 0x32; var var3 = arg0; var1 = func_1A83(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x2983; var2 = arg0; func_291C(var2); return arg0 + 0x40; } function func_298E(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x29a7; var var2 = var0; return func_296B(var2); } function func_29AE(var arg0) returns (var r0) { return memory[arg0:arg0 + 0x20]; } function func_29B9(var arg0, var arg1) returns (var r0) { var temp0 = arg1; memory[temp0:temp0 + 0x20] = arg0; return temp0 + 0x20; } function func_29CA(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x29d5; var var2 = arg1; var1 = func_29AE(var2); var2 = 0x29df; var var3 = var1; var var4 = arg0; var2 = func_29B9(var3, var4); var temp0 = var2; arg0 = temp0; var2 = 0x29ef; var3 = var1; var4 = arg0; var var5 = arg1 + 0x20; func_1A94(var3, var4, var5); var2 = 0x29f8; var3 = var1; var2 = func_1ABE(var3); return arg0 + var2; } function func_2A03(var arg0, var arg1, var arg2, var arg3, var arg4) returns (var r0) { var temp0 = arg4; var var0 = temp0 + 0x80; var var1 = 0x2a18; var var2 = temp0; var var3 = arg0; func_1BBF(var2, var3); var1 = 0x2a25; var2 = arg4 + 0x20; var3 = arg1; func_1BBF(var2, var3); var1 = 0x2a32; var2 = arg4 + 0x40; var3 = arg2; func_1D87(var2, var3); var temp1 = arg4; memory[temp1 + 0x60:temp1 + 0x60 + 0x20] = var0 - temp1; var1 = 0x2a44; var2 = var0; var3 = arg3; return func_29CA(var2, var3); } function func_2A4F(var arg0, var arg1) returns (var r0) { var var0 = memory[arg1:arg1 + 0x20]; var var1 = 0x2a5e; var var2 = var0; func_19E9(var2); return var0; } function func_2A64(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg0 - arg1 i>= 0x20) { var var1 = 0x00; var var2 = 0x2a88; var var3 = arg0; var var4 = arg1 + var1; return func_2A4F(var3, var4); } else { var1 = 0x2a79; revert(memory[0x00:0x00]); } } function func_2A91(var arg0) { memory[arg0:arg0 + 0x20] = 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373; } function func_2ABA(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x2ac7; var var2 = 0x20; var var3 = arg0; var1 = func_1A83(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x2ad2; var2 = arg0; func_2A91(var2); return arg0 + 0x20; } function func_2ADD(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x2af6; var var2 = var0; return func_2ABA(var2); } function func_2AFD(var arg0) { memory[arg0:arg0 + 0x20] = 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000; } function func_2B26(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x2b33; var var2 = 0x1c; var var3 = arg0; var1 = func_1A83(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x2b3e; var2 = arg0; func_2AFD(var2); return arg0 + 0x20; } function func_2B49(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x2b62; var var2 = var0; return func_2B26(var2); } }

Disassembly

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x012c 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x012c, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x70a08231 0026 11 GT 0027 61 PUSH2 0x00ad 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00ad, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xb88d4fde 0031 11 GT 0032 61 PUSH2 0x0071 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0071, if 0xb88d4fde > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xb88d4fde > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xb88d4fde 003C 14 EQ 003D 61 PUSH2 0x02f5 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f5, if 0xb88d4fde == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xb88d4fde == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xc87b56dd 0047 14 EQ 0048 61 PUSH2 0x0311 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0311, if 0xc87b56dd == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xc87b56dd == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xd5582965 0052 14 EQ 0053 61 PUSH2 0x0341 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0341, if 0xd5582965 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xd5582965 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xe985e9c5 005D 14 EQ 005E 61 PUSH2 0x034b 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x034b, if 0xe985e9c5 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xf2fde38b 0068 14 EQ 0069 61 PUSH2 0x037b 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x037b, if 0xf2fde38b == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xf2fde38b == stack[-1] 006D 61 PUSH2 0x012c 0070 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x012c label_0071: // Incoming jump from 0x0035, if 0xb88d4fde > stack[-1] // Inputs[1] { @0072 stack[-1] } 0071 5B JUMPDEST 0072 80 DUP1 0073 63 PUSH4 0x70a08231 0078 14 EQ 0079 61 PUSH2 0x0263 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0263, if 0x70a08231 == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0x70a08231 == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0x715018a6 0083 14 EQ 0084 61 PUSH2 0x0293 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0293, if 0x715018a6 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0x715018a6 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0x8da5cb5b 008E 14 EQ 008F 61 PUSH2 0x029d 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x029d, if 0x8da5cb5b == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0x95d89b41 0099 14 EQ 009A 61 PUSH2 0x02bb 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02bb, if 0x95d89b41 == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0x95d89b41 == stack[-1] // Inputs[1] { @009E stack[-1] } 009E 80 DUP1 009F 63 PUSH4 0xa22cb465 00A4 14 EQ 00A5 61 PUSH2 0x02d9 00A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d9, if 0xa22cb465 == stack[-1] label_00A9: // Incoming jump from 0x00A8, if not 0xa22cb465 == stack[-1] 00A9 61 PUSH2 0x012c 00AC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x012c label_00AD: // Incoming jump from 0x002A, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00AE stack[-1] } 00AD 5B JUMPDEST 00AE 80 DUP1 00AF 63 PUSH4 0x23b872dd 00B4 11 GT 00B5 61 PUSH2 0x00f4 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00f4, if 0x23b872dd > stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x23b872dd > stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x23b872dd 00BF 14 EQ 00C0 61 PUSH2 0x01d5 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d5, if 0x23b872dd == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x23b872dd == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x2be09561 00CA 14 EQ 00CB 61 PUSH2 0x01f1 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f1, if 0x2be09561 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x2be09561 == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0x42842e0e 00D5 14 EQ 00D6 61 PUSH2 0x01fb 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01fb, if 0x42842e0e == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0x42842e0e == stack[-1] // Inputs[1] { @00DA stack[-1] } 00DA 80 DUP1 00DB 63 PUSH4 0x6352211e 00E0 14 EQ 00E1 61 PUSH2 0x0217 00E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0217, if 0x6352211e == stack[-1] label_00E5: // Incoming jump from 0x00E4, if not 0x6352211e == stack[-1] // Inputs[1] { @00E5 stack[-1] } 00E5 80 DUP1 00E6 63 PUSH4 0x6e762527 00EB 14 EQ 00EC 61 PUSH2 0x0247 00EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0247, if 0x6e762527 == stack[-1] label_00F0: // Incoming jump from 0x00EF, if not 0x6e762527 == stack[-1] 00F0 61 PUSH2 0x012c 00F3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x012c label_00F4: // Incoming jump from 0x00B8, if 0x23b872dd > stack[-1] // Inputs[1] { @00F5 stack[-1] } 00F4 5B JUMPDEST 00F5 80 DUP1 00F6 63 PUSH4 0x01ffc9a7 00FB 14 EQ 00FC 61 PUSH2 0x0131 00FF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0131, if 0x01ffc9a7 == stack[-1] label_0100: // Incoming jump from 0x00FF, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0100 stack[-1] } 0100 80 DUP1 0101 63 PUSH4 0x06fdde03 0106 14 EQ 0107 61 PUSH2 0x0161 010A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0161, if 0x06fdde03 == stack[-1] label_010B: // Incoming jump from 0x010A, if not 0x06fdde03 == stack[-1] // Inputs[1] { @010B stack[-1] } 010B 80 DUP1 010C 63 PUSH4 0x081812fc 0111 14 EQ 0112 61 PUSH2 0x017f 0115 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x017f, if 0x081812fc == stack[-1] label_0116: // Incoming jump from 0x0115, if not 0x081812fc == stack[-1] // Inputs[1] { @0116 stack[-1] } 0116 80 DUP1 0117 63 PUSH4 0x095ea7b3 011C 14 EQ 011D 61 PUSH2 0x01af 0120 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01af, if 0x095ea7b3 == stack[-1] label_0121: // Incoming jump from 0x0120, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0121 stack[-1] } 0121 80 DUP1 0122 63 PUSH4 0x1249c58b 0127 14 EQ 0128 61 PUSH2 0x01cb 012B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cb, if 0x1249c58b == stack[-1] label_012C: // Incoming jump from 0x0070 // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x00F3 // Incoming jump from 0x012B, if not 0x1249c58b == stack[-1] // Incoming jump from 0x00AC // Inputs[1] { @0130 memory[0x00:0x00] } 012C 5B JUMPDEST 012D 60 PUSH1 0x00 012F 80 DUP1 0130 FD *REVERT // Stack delta = +0 // Outputs[1] { @0130 revert(memory[0x00:0x00]); } // Block terminates label_0131: // Incoming jump from 0x00FF, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0138 msg.data.length } 0131 5B JUMPDEST 0132 61 PUSH2 0x014b 0135 60 PUSH1 0x04 0137 80 DUP1 0138 36 CALLDATASIZE 0139 03 SUB 013A 81 DUP2 013B 01 ADD 013C 90 SWAP1 013D 61 PUSH2 0x0146 0140 91 SWAP2 0141 90 SWAP1 0142 61 PUSH2 0x1a15 0145 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0132 stack[0] = 0x014b // @0140 stack[1] = 0x0146 // @0141 stack[2] = 0x04 + (msg.data.length - 0x04) // @0141 stack[3] = 0x04 // } // Block ends with call to 0x1a15, returns to 0x0146 label_0146: // Incoming return from call to 0x1A15 at 0x0145 0146 5B JUMPDEST 0147 61 PUSH2 0x0397 014A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0397 label_014B: // Incoming return from call to 0x0146 at 0x0145 // Inputs[2] // { // @014E memory[0x40:0x60] // @0152 stack[-1] // } 014B 5B JUMPDEST 014C 60 PUSH1 0x40 014E 51 MLOAD 014F 61 PUSH2 0x0158 0152 91 SWAP2 0153 90 SWAP1 0154 61 PUSH2 0x1a5d 0157 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0152 stack[-1] = 0x0158 // @0153 stack[1] = memory[0x40:0x60] // @0153 stack[0] = stack[-1] // } // Block ends with call to 0x1a5d, returns to 0x0158 label_0158: // Incoming return from call to 0x1A5D at 0x0157 // Inputs[3] // { // @015B memory[0x40:0x60] // @015D stack[-1] // @0160 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0158 5B JUMPDEST 0159 60 PUSH1 0x40 015B 51 MLOAD 015C 80 DUP1 015D 91 SWAP2 015E 03 SUB 015F 90 SWAP1 0160 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0160 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0161: // Incoming jump from 0x010A, if 0x06fdde03 == stack[-1] 0161 5B JUMPDEST 0162 61 PUSH2 0x0169 0165 61 PUSH2 0x0479 0168 56 *JUMP // Stack delta = +1 // Outputs[1] { @0162 stack[0] = 0x0169 } // Block ends with call to 0x0479, returns to 0x0169 label_0169: // Incoming return from call to 0x0479 at 0x0168 // Inputs[2] // { // @016C memory[0x40:0x60] // @0170 stack[-1] // } 0169 5B JUMPDEST 016A 60 PUSH1 0x40 016C 51 MLOAD 016D 61 PUSH2 0x0176 0170 91 SWAP2 0171 90 SWAP1 0172 61 PUSH2 0x1b08 0175 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0170 stack[-1] = 0x0176 // @0171 stack[1] = memory[0x40:0x60] // @0171 stack[0] = stack[-1] // } // Block ends with call to 0x1b08, returns to 0x0176 label_0176: // Incoming return from call to 0x1B08 at 0x0175 // Inputs[3] // { // @0179 memory[0x40:0x60] // @017B stack[-1] // @017E memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0176 5B JUMPDEST 0177 60 PUSH1 0x40 0179 51 MLOAD 017A 80 DUP1 017B 91 SWAP2 017C 03 SUB 017D 90 SWAP1 017E F3 *RETURN // Stack delta = -1 // Outputs[1] { @017E return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_017F: // Incoming jump from 0x0115, if 0x081812fc == stack[-1] // Inputs[1] { @0186 msg.data.length } 017F 5B JUMPDEST 0180 61 PUSH2 0x0199 0183 60 PUSH1 0x04 0185 80 DUP1 0186 36 CALLDATASIZE 0187 03 SUB 0188 81 DUP2 0189 01 ADD 018A 90 SWAP1 018B 61 PUSH2 0x0194 018E 91 SWAP2 018F 90 SWAP1 0190 61 PUSH2 0x1b60 0193 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0180 stack[0] = 0x0199 // @018E stack[1] = 0x0194 // @018F stack[2] = 0x04 + (msg.data.length - 0x04) // @018F stack[3] = 0x04 // } // Block ends with call to 0x1b60, returns to 0x0194 label_0194: // Incoming return from call to 0x1B60 at 0x0193 0194 5B JUMPDEST 0195 61 PUSH2 0x050b 0198 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x050b label_0199: // Incoming return from call to 0x0194 at 0x0193 // Inputs[2] // { // @019C memory[0x40:0x60] // @01A0 stack[-1] // } 0199 5B JUMPDEST 019A 60 PUSH1 0x40 019C 51 MLOAD 019D 61 PUSH2 0x01a6 01A0 91 SWAP2 01A1 90 SWAP1 01A2 61 PUSH2 0x1bce 01A5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01A0 stack[-1] = 0x01a6 // @01A1 stack[1] = memory[0x40:0x60] // @01A1 stack[0] = stack[-1] // } // Block ends with call to 0x1bce, returns to 0x01A6 label_01A6: // Incoming return from call to 0x1BCE at 0x01A5 // Inputs[3] // { // @01A9 memory[0x40:0x60] // @01AB stack[-1] // @01AE memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01A6 5B JUMPDEST 01A7 60 PUSH1 0x40 01A9 51 MLOAD 01AA 80 DUP1 01AB 91 SWAP2 01AC 03 SUB 01AD 90 SWAP1 01AE F3 *RETURN // Stack delta = -1 // Outputs[1] { @01AE return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_01AF: // Incoming jump from 0x0120, if 0x095ea7b3 == stack[-1] // Inputs[1] { @01B6 msg.data.length } 01AF 5B JUMPDEST 01B0 61 PUSH2 0x01c9 01B3 60 PUSH1 0x04 01B5 80 DUP1 01B6 36 CALLDATASIZE 01B7 03 SUB 01B8 81 DUP2 01B9 01 ADD 01BA 90 SWAP1 01BB 61 PUSH2 0x01c4 01BE 91 SWAP2 01BF 90 SWAP1 01C0 61 PUSH2 0x1c15 01C3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01B0 stack[0] = 0x01c9 // @01BE stack[1] = 0x01c4 // @01BF stack[2] = 0x04 + (msg.data.length - 0x04) // @01BF stack[3] = 0x04 // } // Block ends with call to 0x1c15, returns to 0x01C4 label_01C4: // Incoming return from call to 0x1C15 at 0x01C3 01C4 5B JUMPDEST 01C5 61 PUSH2 0x0551 01C8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0551 label_01C9: // Incoming return from call to 0x01C4 at 0x01C3 01C9 5B JUMPDEST 01CA 00 *STOP // Stack delta = +0 // Outputs[1] { @01CA stop(); } // Block terminates label_01CB: // Incoming jump from 0x012B, if 0x1249c58b == stack[-1] 01CB 5B JUMPDEST 01CC 61 PUSH2 0x01d3 01CF 61 PUSH2 0x0668 01D2 56 *JUMP // Stack delta = +1 // Outputs[1] { @01CC stack[0] = 0x01d3 } // Block ends with call to 0x0668, returns to 0x01D3 label_01D3: // Incoming return from call to 0x0668 at 0x01D2 01D3 5B JUMPDEST 01D4 00 *STOP // Stack delta = +0 // Outputs[1] { @01D4 stop(); } // Block terminates label_01D5: // Incoming jump from 0x00C3, if 0x23b872dd == stack[-1] // Inputs[1] { @01DC msg.data.length } 01D5 5B JUMPDEST 01D6 61 PUSH2 0x01ef 01D9 60 PUSH1 0x04 01DB 80 DUP1 01DC 36 CALLDATASIZE 01DD 03 SUB 01DE 81 DUP2 01DF 01 ADD 01E0 90 SWAP1 01E1 61 PUSH2 0x01ea 01E4 91 SWAP2 01E5 90 SWAP1 01E6 61 PUSH2 0x1c55 01E9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01D6 stack[0] = 0x01ef // @01E4 stack[1] = 0x01ea // @01E5 stack[2] = 0x04 + (msg.data.length - 0x04) // @01E5 stack[3] = 0x04 // } // Block ends with call to 0x1c55, returns to 0x01EA label_01EA: // Incoming return from call to 0x1C55 at 0x01E9 01EA 5B JUMPDEST 01EB 61 PUSH2 0x06e4 01EE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06e4 label_01EF: // Incoming return from call to 0x01EA at 0x01E9 01EF 5B JUMPDEST 01F0 00 *STOP // Stack delta = +0 // Outputs[1] { @01F0 stop(); } // Block terminates label_01F1: // Incoming jump from 0x00CE, if 0x2be09561 == stack[-1] 01F1 5B JUMPDEST 01F2 61 PUSH2 0x01f9 01F5 61 PUSH2 0x0744 01F8 56 *JUMP // Stack delta = +1 // Outputs[1] { @01F2 stack[0] = 0x01f9 } // Block ends with call to 0x0744, returns to 0x01F9 label_01F9: // Incoming return from call to 0x0744 at 0x01F8 01F9 5B JUMPDEST 01FA 00 *STOP // Stack delta = +0 // Outputs[1] { @01FA stop(); } // Block terminates label_01FB: // Incoming jump from 0x00D9, if 0x42842e0e == stack[-1] // Inputs[1] { @0202 msg.data.length } 01FB 5B JUMPDEST 01FC 61 PUSH2 0x0215 01FF 60 PUSH1 0x04 0201 80 DUP1 0202 36 CALLDATASIZE 0203 03 SUB 0204 81 DUP2 0205 01 ADD 0206 90 SWAP1 0207 61 PUSH2 0x0210 020A 91 SWAP2 020B 90 SWAP1 020C 61 PUSH2 0x1c55 020F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01FC stack[0] = 0x0215 // @020A stack[1] = 0x0210 // @020B stack[2] = 0x04 + (msg.data.length - 0x04) // @020B stack[3] = 0x04 // } // Block ends with call to 0x1c55, returns to 0x0210 label_0210: // Incoming return from call to 0x1C55 at 0x020F 0210 5B JUMPDEST 0211 61 PUSH2 0x0769 0214 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0769 label_0215: // Incoming return from call to 0x0210 at 0x020F 0215 5B JUMPDEST 0216 00 *STOP // Stack delta = +0 // Outputs[1] { @0216 stop(); } // Block terminates label_0217: // Incoming jump from 0x00E4, if 0x6352211e == stack[-1] // Inputs[1] { @021E msg.data.length } 0217 5B JUMPDEST 0218 61 PUSH2 0x0231 021B 60 PUSH1 0x04 021D 80 DUP1 021E 36 CALLDATASIZE 021F 03 SUB 0220 81 DUP2 0221 01 ADD 0222 90 SWAP1 0223 61 PUSH2 0x022c 0226 91 SWAP2 0227 90 SWAP1 0228 61 PUSH2 0x1b60 022B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0218 stack[0] = 0x0231 // @0226 stack[1] = 0x022c // @0227 stack[2] = 0x04 + (msg.data.length - 0x04) // @0227 stack[3] = 0x04 // } // Block ends with call to 0x1b60, returns to 0x022C label_022C: // Incoming return from call to 0x1B60 at 0x022B 022C 5B JUMPDEST 022D 61 PUSH2 0x0789 0230 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0789 label_0231: // Incoming return from call to 0x022C at 0x022B // Inputs[2] // { // @0234 memory[0x40:0x60] // @0238 stack[-1] // } 0231 5B JUMPDEST 0232 60 PUSH1 0x40 0234 51 MLOAD 0235 61 PUSH2 0x023e 0238 91 SWAP2 0239 90 SWAP1 023A 61 PUSH2 0x1bce 023D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0238 stack[-1] = 0x023e // @0239 stack[1] = memory[0x40:0x60] // @0239 stack[0] = stack[-1] // } // Block ends with call to 0x1bce, returns to 0x023E label_023E: // Incoming return from call to 0x1BCE at 0x023D // Inputs[3] // { // @0241 memory[0x40:0x60] // @0243 stack[-1] // @0246 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 023E 5B JUMPDEST 023F 60 PUSH1 0x40 0241 51 MLOAD 0242 80 DUP1 0243 91 SWAP2 0244 03 SUB 0245 90 SWAP1 0246 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0246 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0247: // Incoming jump from 0x00EF, if 0x6e762527 == stack[-1] // Inputs[1] { @024E msg.data.length } 0247 5B JUMPDEST 0248 61 PUSH2 0x0261 024B 60 PUSH1 0x04 024D 80 DUP1 024E 36 CALLDATASIZE 024F 03 SUB 0250 81 DUP2 0251 01 ADD 0252 90 SWAP1 0253 61 PUSH2 0x025c 0256 91 SWAP2 0257 90 SWAP1 0258 61 PUSH2 0x1d0d 025B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0248 stack[0] = 0x0261 // @0256 stack[1] = 0x025c // @0257 stack[2] = 0x04 + (msg.data.length - 0x04) // @0257 stack[3] = 0x04 // } // Block ends with call to 0x1d0d, returns to 0x025C label_025C: // Incoming return from call to 0x1D0D at 0x025B 025C 5B JUMPDEST 025D 61 PUSH2 0x080f 0260 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x080f label_0261: // Incoming return from call to 0x025C at 0x025B 0261 5B JUMPDEST 0262 00 *STOP // Stack delta = +0 // Outputs[1] { @0262 stop(); } // Block terminates label_0263: // Incoming jump from 0x007C, if 0x70a08231 == stack[-1] // Inputs[1] { @026A msg.data.length } 0263 5B JUMPDEST 0264 61 PUSH2 0x027d 0267 60 PUSH1 0x04 0269 80 DUP1 026A 36 CALLDATASIZE 026B 03 SUB 026C 81 DUP2 026D 01 ADD 026E 90 SWAP1 026F 61 PUSH2 0x0278 0272 91 SWAP2 0273 90 SWAP1 0274 61 PUSH2 0x1d5a 0277 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0264 stack[0] = 0x027d // @0272 stack[1] = 0x0278 // @0273 stack[2] = 0x04 + (msg.data.length - 0x04) // @0273 stack[3] = 0x04 // } // Block ends with call to 0x1d5a, returns to 0x0278 label_0278: // Incoming return from call to 0x1D5A at 0x0277 0278 5B JUMPDEST 0279 61 PUSH2 0x082d 027C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x082d label_027D: // Incoming return from call to 0x0278 at 0x0277 // Inputs[2] // { // @0280 memory[0x40:0x60] // @0284 stack[-1] // } 027D 5B JUMPDEST 027E 60 PUSH1 0x40 0280 51 MLOAD 0281 61 PUSH2 0x028a 0284 91 SWAP2 0285 90 SWAP1 0286 61 PUSH2 0x1d96 0289 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0284 stack[-1] = 0x028a // @0285 stack[1] = memory[0x40:0x60] // @0285 stack[0] = stack[-1] // } // Block ends with call to 0x1d96, returns to 0x028A label_028A: // Incoming return from call to 0x1D96 at 0x0289 // Inputs[3] // { // @028D memory[0x40:0x60] // @028F stack[-1] // @0292 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 028A 5B JUMPDEST 028B 60 PUSH1 0x40 028D 51 MLOAD 028E 80 DUP1 028F 91 SWAP2 0290 03 SUB 0291 90 SWAP1 0292 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0292 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0293: // Incoming jump from 0x0087, if 0x715018a6 == stack[-1] 0293 5B JUMPDEST 0294 61 PUSH2 0x029b 0297 61 PUSH2 0x08e4 029A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0294 stack[0] = 0x029b } // Block ends with call to 0x08e4, returns to 0x029B label_029B: // Incoming return from call to 0x08E4 at 0x029A 029B 5B JUMPDEST 029C 00 *STOP // Stack delta = +0 // Outputs[1] { @029C stop(); } // Block terminates label_029D: // Incoming jump from 0x0092, if 0x8da5cb5b == stack[-1] 029D 5B JUMPDEST 029E 61 PUSH2 0x02a5 02A1 61 PUSH2 0x08f8 02A4 56 *JUMP // Stack delta = +1 // Outputs[1] { @029E stack[0] = 0x02a5 } // Block ends with call to 0x08f8, returns to 0x02A5 label_02A5: // Incoming return from call to 0x08F8 at 0x02A4 // Inputs[2] // { // @02A8 memory[0x40:0x60] // @02AC stack[-1] // } 02A5 5B JUMPDEST 02A6 60 PUSH1 0x40 02A8 51 MLOAD 02A9 61 PUSH2 0x02b2 02AC 91 SWAP2 02AD 90 SWAP1 02AE 61 PUSH2 0x1bce 02B1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02AC stack[-1] = 0x02b2 // @02AD stack[1] = memory[0x40:0x60] // @02AD stack[0] = stack[-1] // } // Block ends with call to 0x1bce, returns to 0x02B2 label_02B2: // Incoming return from call to 0x1BCE at 0x02B1 // Inputs[3] // { // @02B5 memory[0x40:0x60] // @02B7 stack[-1] // @02BA memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 02B2 5B JUMPDEST 02B3 60 PUSH1 0x40 02B5 51 MLOAD 02B6 80 DUP1 02B7 91 SWAP2 02B8 03 SUB 02B9 90 SWAP1 02BA F3 *RETURN // Stack delta = -1 // Outputs[1] { @02BA return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_02BB: // Incoming jump from 0x009D, if 0x95d89b41 == stack[-1] 02BB 5B JUMPDEST 02BC 61 PUSH2 0x02c3 02BF 61 PUSH2 0x0921 02C2 56 *JUMP // Stack delta = +1 // Outputs[1] { @02BC stack[0] = 0x02c3 } // Block ends with call to 0x0921, returns to 0x02C3 label_02C3: // Incoming return from call to 0x0921 at 0x02C2 // Inputs[2] // { // @02C6 memory[0x40:0x60] // @02CA stack[-1] // } 02C3 5B JUMPDEST 02C4 60 PUSH1 0x40 02C6 51 MLOAD 02C7 61 PUSH2 0x02d0 02CA 91 SWAP2 02CB 90 SWAP1 02CC 61 PUSH2 0x1b08 02CF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02CA stack[-1] = 0x02d0 // @02CB stack[1] = memory[0x40:0x60] // @02CB stack[0] = stack[-1] // } // Block ends with call to 0x1b08, returns to 0x02D0 label_02D0: // Incoming return from call to 0x1B08 at 0x02CF // Inputs[3] // { // @02D3 memory[0x40:0x60] // @02D5 stack[-1] // @02D8 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 02D0 5B JUMPDEST 02D1 60 PUSH1 0x40 02D3 51 MLOAD 02D4 80 DUP1 02D5 91 SWAP2 02D6 03 SUB 02D7 90 SWAP1 02D8 F3 *RETURN // Stack delta = -1 // Outputs[1] { @02D8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_02D9: // Incoming jump from 0x00A8, if 0xa22cb465 == stack[-1] // Inputs[1] { @02E0 msg.data.length } 02D9 5B JUMPDEST 02DA 61 PUSH2 0x02f3 02DD 60 PUSH1 0x04 02DF 80 DUP1 02E0 36 CALLDATASIZE 02E1 03 SUB 02E2 81 DUP2 02E3 01 ADD 02E4 90 SWAP1 02E5 61 PUSH2 0x02ee 02E8 91 SWAP2 02E9 90 SWAP1 02EA 61 PUSH2 0x1ddd 02ED 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02DA stack[0] = 0x02f3 // @02E8 stack[1] = 0x02ee // @02E9 stack[2] = 0x04 + (msg.data.length - 0x04) // @02E9 stack[3] = 0x04 // } // Block ends with call to 0x1ddd, returns to 0x02EE label_02EE: // Incoming return from call to 0x1DDD at 0x02ED 02EE 5B JUMPDEST 02EF 61 PUSH2 0x09b3 02F2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09b3 label_02F3: // Incoming return from call to 0x02EE at 0x02ED 02F3 5B JUMPDEST 02F4 00 *STOP // Stack delta = +0 // Outputs[1] { @02F4 stop(); } // Block terminates label_02F5: // Incoming jump from 0x0040, if 0xb88d4fde == stack[-1] // Inputs[1] { @02FC msg.data.length } 02F5 5B JUMPDEST 02F6 61 PUSH2 0x030f 02F9 60 PUSH1 0x04 02FB 80 DUP1 02FC 36 CALLDATASIZE 02FD 03 SUB 02FE 81 DUP2 02FF 01 ADD 0300 90 SWAP1 0301 61 PUSH2 0x030a 0304 91 SWAP2 0305 90 SWAP1 0306 61 PUSH2 0x1f4d 0309 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02F6 stack[0] = 0x030f // @0304 stack[1] = 0x030a // @0305 stack[2] = 0x04 + (msg.data.length - 0x04) // @0305 stack[3] = 0x04 // } // Block ends with call to 0x1f4d, returns to 0x030A label_030A: // Incoming return from call to 0x1F4D at 0x0309 030A 5B JUMPDEST 030B 61 PUSH2 0x09c9 030E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09c9 label_030F: // Incoming return from call to 0x030A at 0x0309 // Incoming return from call to 0x030A at 0x0309 030F 5B JUMPDEST 0310 00 *STOP // Stack delta = +0 // Outputs[1] { @0310 stop(); } // Block terminates label_0311: // Incoming jump from 0x004B, if 0xc87b56dd == stack[-1] // Inputs[1] { @0318 msg.data.length } 0311 5B JUMPDEST 0312 61 PUSH2 0x032b 0315 60 PUSH1 0x04 0317 80 DUP1 0318 36 CALLDATASIZE 0319 03 SUB 031A 81 DUP2 031B 01 ADD 031C 90 SWAP1 031D 61 PUSH2 0x0326 0320 91 SWAP2 0321 90 SWAP1 0322 61 PUSH2 0x1b60 0325 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0312 stack[0] = 0x032b // @0320 stack[1] = 0x0326 // @0321 stack[2] = 0x04 + (msg.data.length - 0x04) // @0321 stack[3] = 0x04 // } // Block ends with call to 0x1b60, returns to 0x0326 label_0326: // Incoming return from call to 0x1B60 at 0x0325 0326 5B JUMPDEST 0327 61 PUSH2 0x0a2b 032A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a2b label_032B: // Incoming return from call to 0x0326 at 0x0325 // Inputs[2] // { // @032E memory[0x40:0x60] // @0332 stack[-1] // } 032B 5B JUMPDEST 032C 60 PUSH1 0x40 032E 51 MLOAD 032F 61 PUSH2 0x0338 0332 91 SWAP2 0333 90 SWAP1 0334 61 PUSH2 0x1b08 0337 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0332 stack[-1] = 0x0338 // @0333 stack[1] = memory[0x40:0x60] // @0333 stack[0] = stack[-1] // } // Block ends with call to 0x1b08, returns to 0x0338 label_0338: // Incoming return from call to 0x1B08 at 0x0337 // Inputs[3] // { // @033B memory[0x40:0x60] // @033D stack[-1] // @0340 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0338 5B JUMPDEST 0339 60 PUSH1 0x40 033B 51 MLOAD 033C 80 DUP1 033D 91 SWAP2 033E 03 SUB 033F 90 SWAP1 0340 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0340 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0341: // Incoming jump from 0x0056, if 0xd5582965 == stack[-1] 0341 5B JUMPDEST 0342 61 PUSH2 0x0349 0345 61 PUSH2 0x0aaa 0348 56 *JUMP // Stack delta = +1 // Outputs[1] { @0342 stack[0] = 0x0349 } // Block ends with call to 0x0aaa, returns to 0x0349 label_0349: // Incoming return from call to 0x0AAA at 0x0348 0349 5B JUMPDEST 034A 00 *STOP // Stack delta = +0 // Outputs[1] { @034A stop(); } // Block terminates label_034B: // Incoming jump from 0x0061, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0352 msg.data.length } 034B 5B JUMPDEST 034C 61 PUSH2 0x0365 034F 60 PUSH1 0x04 0351 80 DUP1 0352 36 CALLDATASIZE 0353 03 SUB 0354 81 DUP2 0355 01 ADD 0356 90 SWAP1 0357 61 PUSH2 0x0360 035A 91 SWAP2 035B 90 SWAP1 035C 61 PUSH2 0x1fd0 035F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @034C stack[0] = 0x0365 // @035A stack[1] = 0x0360 // @035B stack[2] = 0x04 + (msg.data.length - 0x04) // @035B stack[3] = 0x04 // } // Block ends with call to 0x1fd0, returns to 0x0360 label_0360: // Incoming return from call to 0x1FD0 at 0x035F 0360 5B JUMPDEST 0361 61 PUSH2 0x0acf 0364 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0acf label_0365: // Incoming return from call to 0x0360 at 0x035F // Inputs[2] // { // @0368 memory[0x40:0x60] // @036C stack[-1] // } 0365 5B JUMPDEST 0366 60 PUSH1 0x40 0368 51 MLOAD 0369 61 PUSH2 0x0372 036C 91 SWAP2 036D 90 SWAP1 036E 61 PUSH2 0x1a5d 0371 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @036C stack[-1] = 0x0372 // @036D stack[1] = memory[0x40:0x60] // @036D stack[0] = stack[-1] // } // Block ends with call to 0x1a5d, returns to 0x0372 label_0372: // Incoming return from call to 0x1A5D at 0x0371 // Inputs[3] // { // @0375 memory[0x40:0x60] // @0377 stack[-1] // @037A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0372 5B JUMPDEST 0373 60 PUSH1 0x40 0375 51 MLOAD 0376 80 DUP1 0377 91 SWAP2 0378 03 SUB 0379 90 SWAP1 037A F3 *RETURN // Stack delta = -1 // Outputs[1] { @037A return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_037B: // Incoming jump from 0x006C, if 0xf2fde38b == stack[-1] // Inputs[1] { @0382 msg.data.length } 037B 5B JUMPDEST 037C 61 PUSH2 0x0395 037F 60 PUSH1 0x04 0381 80 DUP1 0382 36 CALLDATASIZE 0383 03 SUB 0384 81 DUP2 0385 01 ADD 0386 90 SWAP1 0387 61 PUSH2 0x0390 038A 91 SWAP2 038B 90 SWAP1 038C 61 PUSH2 0x1d5a 038F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @037C stack[0] = 0x0395 // @038A stack[1] = 0x0390 // @038B stack[2] = 0x04 + (msg.data.length - 0x04) // @038B stack[3] = 0x04 // } // Block ends with call to 0x1d5a, returns to 0x0390 label_0390: // Incoming return from call to 0x1D5A at 0x038F 0390 5B JUMPDEST 0391 61 PUSH2 0x0b63 0394 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b63 label_0395: // Incoming return from call to 0x0390 at 0x038F 0395 5B JUMPDEST 0396 00 *STOP // Stack delta = +0 // Outputs[1] { @0396 stop(); } // Block terminates label_0397: // Incoming jump from 0x014A // Inputs[1] { @03DA stack[-1] } 0397 5B JUMPDEST 0398 60 PUSH1 0x00 039A 7F PUSH32 0x80ac58cd00000000000000000000000000000000000000000000000000000000 03BB 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 03D8 19 NOT 03D9 16 AND 03DA 82 DUP3 03DB 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 03F8 19 NOT 03F9 16 AND 03FA 14 EQ 03FB 80 DUP1 03FC 61 PUSH2 0x0462 03FF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0398 stack[0] = 0x00 // @03FA stack[1] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x80ac58cd00000000000000000000000000000000000000000000000000000000 // } // Block ends with conditional jump to 0x0462, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x80ac58cd00000000000000000000000000000000000000000000000000000000 label_0400: // Incoming jump from 0x03FF, if not ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x80ac58cd00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0441 stack[-3] } 0400 50 POP 0401 7F PUSH32 0x5b5e139f00000000000000000000000000000000000000000000000000000000 0422 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 043F 19 NOT 0440 16 AND 0441 82 DUP3 0442 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 045F 19 NOT 0460 16 AND 0461 14 EQ 0462 5B JUMPDEST 0463 80 DUP1 0464 61 PUSH2 0x0472 0467 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0461 stack[-1] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x5b5e139f00000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x0472, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x5b5e139f00000000000000000000000000000000000000000000000000000000 label_0468: // Incoming jump from 0x0467, if not stack[-1] // Incoming jump from 0x0467, if not ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x5b5e139f00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @046C stack[-3] } 0468 50 POP 0469 61 PUSH2 0x0471 046C 82 DUP3 046D 61 PUSH2 0x0be6 0470 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0469 stack[-1] = 0x0471 // @046C stack[0] = stack[-3] // } // Block ends with call to 0x0be6, returns to 0x0471 label_0471: // Incoming return from call to 0x0BE6 at 0x0470 0471 5B JUMPDEST // Stack delta = +0 // Block continues label_0472: // Incoming jump from 0x0467, if stack[-1] // Incoming jump from 0x0467, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x5b5e139f00000000000000000000000000000000000000000000000000000000 // Incoming jump from 0x0471 // Inputs[4] // { // @0473 stack[-2] // @0473 stack[-1] // @0475 stack[-4] // @0476 stack[-3] // } 0472 5B JUMPDEST 0473 90 SWAP1 0474 50 POP 0475 91 SWAP2 0476 90 SWAP1 0477 50 POP 0478 56 *JUMP // Stack delta = -3 // Outputs[1] { @0475 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0479: // Incoming call from 0x0168, returns to 0x0169 // Inputs[1] { @047F storage[0x01] } 0479 5B JUMPDEST 047A 60 PUSH1 0x60 047C 60 PUSH1 0x01 047E 80 DUP1 047F 54 SLOAD 0480 61 PUSH2 0x0488 0483 90 SWAP1 0484 61 PUSH2 0x203f 0487 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @047A stack[0] = 0x60 // @047C stack[1] = 0x01 // @0483 stack[2] = 0x0488 // @0483 stack[3] = storage[0x01] // } // Block ends with call to 0x203f, returns to 0x0488 label_0488: // Incoming return from call to 0x203F at 0x0487 // Inputs[4] // { // @0489 stack[-1] // @0498 memory[0x40:0x60] // @04A0 stack[-2] // @04AB storage[stack[-2]] // } 0488 5B JUMPDEST 0489 80 DUP1 048A 60 PUSH1 0x1f 048C 01 ADD 048D 60 PUSH1 0x20 048F 80 DUP1 0490 91 SWAP2 0491 04 DIV 0492 02 MUL 0493 60 PUSH1 0x20 0495 01 ADD 0496 60 PUSH1 0x40 0498 51 MLOAD 0499 90 SWAP1 049A 81 DUP2 049B 01 ADD 049C 60 PUSH1 0x40 049E 52 MSTORE 049F 80 DUP1 04A0 92 SWAP3 04A1 91 SWAP2 04A2 90 SWAP1 04A3 81 DUP2 04A4 81 DUP2 04A5 52 MSTORE 04A6 60 PUSH1 0x20 04A8 01 ADD 04A9 82 DUP3 04AA 80 DUP1 04AB 54 SLOAD 04AC 61 PUSH2 0x04b4 04AF 90 SWAP1 04B0 61 PUSH2 0x203f 04B3 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @049E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @04A0 stack[-2] = memory[0x40:0x60] // @04A1 stack[-1] = stack[-2] // @04A2 stack[0] = stack[-1] // @04A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @04A8 stack[1] = 0x20 + memory[0x40:0x60] // @04A9 stack[2] = stack[-2] // @04AF stack[4] = storage[stack[-2]] // @04AF stack[3] = 0x04b4 // } // Block ends with call to 0x203f, returns to 0x04B4 label_04B4: // Incoming return from call to 0x203F at 0x04B3 // Inputs[1] { @04B5 stack[-1] } 04B4 5B JUMPDEST 04B5 80 DUP1 04B6 15 ISZERO 04B7 61 PUSH2 0x0501 04BA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0501, if !stack[-1] label_04BB: // Incoming jump from 0x04BA, if not !stack[-1] // Inputs[1] { @04BB stack[-1] } 04BB 80 DUP1 04BC 60 PUSH1 0x1f 04BE 10 LT 04BF 61 PUSH2 0x04d6 04C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d6, if 0x1f < stack[-1] label_04C3: // Incoming jump from 0x04C2, if not 0x1f < stack[-1] // Inputs[4] // { // @04C7 stack[-2] // @04C8 storage[stack[-2]] // @04CB stack[-3] // @04CD stack[-1] // } 04C3 61 PUSH2 0x0100 04C6 80 DUP1 04C7 83 DUP4 04C8 54 SLOAD 04C9 04 DIV 04CA 02 MUL 04CB 83 DUP4 04CC 52 MSTORE 04CD 91 SWAP2 04CE 60 PUSH1 0x20 04D0 01 ADD 04D1 91 SWAP2 04D2 61 PUSH2 0x0501 04D5 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @04CC memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @04D1 stack[-1] = stack[-1] // @04D1 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0501 label_04D6: // Incoming jump from 0x04C2, if 0x1f < stack[-1] // Inputs[5] // { // @04D7 stack[-3] // @04D8 stack[-1] // @04DA stack[-2] // @04E2 memory[0x00:0x20] // @04E6 storage[keccak256(memory[0x00:0x20])] // } 04D6 5B JUMPDEST 04D7 82 DUP3 04D8 01 ADD 04D9 91 SWAP2 04DA 90 SWAP1 04DB 60 PUSH1 0x00 04DD 52 MSTORE 04DE 60 PUSH1 0x20 04E0 60 PUSH1 0x00 04E2 20 SHA3 04E3 90 SWAP1 04E4 5B JUMPDEST 04E5 81 DUP2 04E6 54 SLOAD 04E7 81 DUP2 04E8 52 MSTORE 04E9 90 SWAP1 04EA 60 PUSH1 0x01 04EC 01 ADD 04ED 90 SWAP1 04EE 60 PUSH1 0x20 04F0 01 ADD 04F1 80 DUP1 04F2 83 DUP4 04F3 11 GT 04F4 61 PUSH2 0x04e4 04F7 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @04D9 stack[-3] = stack[-3] + stack[-1] // @04DD memory[0x00:0x20] = stack[-2] // @04E8 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @04ED stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @04F0 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x04e4, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_04F8: // Incoming jump from 0x04F7, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x04F7, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @04F8 stack[-3] // @04F9 stack[-1] // } 04F8 82 DUP3 04F9 90 SWAP1 04FA 03 SUB 04FB 60 PUSH1 0x1f 04FD 16 AND 04FE 82 DUP3 04FF 01 ADD 0500 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0500 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0500 stack[-1] = stack[-3] // } // Block continues label_0501: // Incoming jump from 0x04BA, if !stack[-1] // Incoming jump from 0x0500 // Incoming jump from 0x04D5 // Inputs[3] // { // @0507 stack[-7] // @0507 stack[-6] // @0509 stack[-8] // } 0501 5B JUMPDEST 0502 50 POP 0503 50 POP 0504 50 POP 0505 50 POP 0506 50 POP 0507 90 SWAP1 0508 50 POP 0509 90 SWAP1 050A 56 *JUMP // Stack delta = -7 // Outputs[1] { @0509 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_050B: // Incoming call from 0x0E46, returns to 0x0E47 // Incoming jump from 0x0198 // Inputs[1] { @0511 stack[-1] } 050B 5B JUMPDEST 050C 60 PUSH1 0x00 050E 61 PUSH2 0x0516 0511 82 DUP3 0512 61 PUSH2 0x0c50 0515 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @050C stack[0] = 0x00 // @050E stack[1] = 0x0516 // @0511 stack[2] = stack[-1] // } // Block ends with call to 0x0c50, returns to 0x0516 label_0516: // Incoming return from call to 0x0C50 at 0x0515 // Inputs[5] // { // @051B stack[-2] // @0529 memory[0x00:0x40] // @052D storage[keccak256(memory[0x00:0x40])] // @054B stack[-1] // @054D stack[-3] // } 0516 5B JUMPDEST 0517 60 PUSH1 0x05 0519 60 PUSH1 0x00 051B 83 DUP4 051C 81 DUP2 051D 52 MSTORE 051E 60 PUSH1 0x20 0520 01 ADD 0521 90 SWAP1 0522 81 DUP2 0523 52 MSTORE 0524 60 PUSH1 0x20 0526 01 ADD 0527 60 PUSH1 0x00 0529 20 SHA3 052A 60 PUSH1 0x00 052C 90 SWAP1 052D 54 SLOAD 052E 90 SWAP1 052F 61 PUSH2 0x0100 0532 0A EXP 0533 90 SWAP1 0534 04 DIV 0535 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 054A 16 AND 054B 90 SWAP1 054C 50 POP 054D 91 SWAP2 054E 90 SWAP1 054F 50 POP 0550 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @051D memory[0x00:0x20] = stack[-2] // @0523 memory[0x20:0x40] = 0x05 // @054D stack[-3] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-3] label_0551: // Incoming jump from 0x01C8 // Inputs[1] { @0557 stack[-1] } 0551 5B JUMPDEST 0552 60 PUSH1 0x00 0554 61 PUSH2 0x055c 0557 82 DUP3 0558 61 PUSH2 0x0789 055B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0552 stack[0] = 0x00 // @0554 stack[1] = 0x055c // @0557 stack[2] = stack[-1] // } // Block ends with call to 0x0789, returns to 0x055C label_055C: // Incoming return from call to 0x0789 at 0x055B // Inputs[3] // { // @055D stack[-2] // @055D stack[-1] // @0576 stack[-4] // } 055C 5B JUMPDEST 055D 90 SWAP1 055E 50 POP 055F 80 DUP1 0560 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0575 16 AND 0576 83 DUP4 0577 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 058C 16 AND 058D 03 SUB 058E 61 PUSH2 0x05cc 0591 57 *JUMPI // Stack delta = -1 // Outputs[1] { @055D stack[-2] = stack[-1] } // Block ends with conditional jump to 0x05cc, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-4]) - (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_0592: // Incoming jump from 0x0591, if not (0xffffffffffffffffffffffffffffffffffffffff & stack[-4]) - (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @0594 memory[0x40:0x60] } 0592 60 PUSH1 0x40 0594 51 MLOAD 0595 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 05B6 81 DUP2 05B7 52 MSTORE 05B8 60 PUSH1 0x04 05BA 01 ADD 05BB 61 PUSH2 0x05c3 05BE 90 SWAP1 05BF 61 PUSH2 0x20e2 05C2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @05B7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @05BE stack[0] = 0x05c3 // @05BE stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x20e2, returns to 0x05C3 label_05C3: // Incoming return from call to 0x20E2 at 0x05C2 // Inputs[3] // { // @05C6 memory[0x40:0x60] // @05C8 stack[-1] // @05CB memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 05C3 5B JUMPDEST 05C4 60 PUSH1 0x40 05C6 51 MLOAD 05C7 80 DUP1 05C8 91 SWAP2 05C9 03 SUB 05CA 90 SWAP1 05CB FD *REVERT // Stack delta = -1 // Outputs[1] { @05CB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_05CC: // Incoming jump from 0x0591, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-4]) - (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @05CD stack[-1] } 05CC 5B JUMPDEST 05CD 80 DUP1 05CE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05E3 16 AND 05E4 61 PUSH2 0x05eb 05E7 61 PUSH2 0x0c9b 05EA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @05E3 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @05E4 stack[1] = 0x05eb // } // Block ends with call to 0x0c9b, returns to 0x05EB label_05EB: // Incoming return from call to 0x0C9B at 0x05EA // Inputs[2] // { // @0601 stack[-1] // @0602 stack[-2] // } 05EB 5B JUMPDEST 05EC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0601 16 AND 0602 14 EQ 0603 80 DUP1 0604 61 PUSH2 0x061a 0607 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0602 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x061a, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_0608: // Incoming jump from 0x0607, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @060C stack[-2] } 0608 50 POP 0609 61 PUSH2 0x0619 060C 81 DUP2 060D 61 PUSH2 0x0614 0610 61 PUSH2 0x0c9b 0613 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0609 stack[-1] = 0x0619 // @060C stack[0] = stack[-2] // @060D stack[1] = 0x0614 // } // Block ends with call to 0x0c9b, returns to 0x0614 label_0614: // Incoming return from call to 0x0C9B at 0x0613 0614 5B JUMPDEST 0615 61 PUSH2 0x0acf 0618 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0acf label_0619: // Incoming return from call to 0x0614 at 0x0613 0619 5B JUMPDEST // Stack delta = +0 // Block continues label_061A: // Incoming jump from 0x0619 // Incoming jump from 0x0607, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @061E stack[-1] } 061A 5B JUMPDEST 061B 61 PUSH2 0x0659 061E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0659, if stack[-1] label_061F: // Incoming jump from 0x061E, if not stack[-1] // Inputs[1] { @0621 memory[0x40:0x60] } 061F 60 PUSH1 0x40 0621 51 MLOAD 0622 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0643 81 DUP2 0644 52 MSTORE 0645 60 PUSH1 0x04 0647 01 ADD 0648 61 PUSH2 0x0650 064B 90 SWAP1 064C 61 PUSH2 0x2174 064F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0644 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @064B stack[0] = 0x0650 // @064B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2174, returns to 0x0650 label_0650: // Incoming return from call to 0x2174 at 0x064F // Inputs[3] // { // @0653 memory[0x40:0x60] // @0655 stack[-1] // @0658 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0650 5B JUMPDEST 0651 60 PUSH1 0x40 0653 51 MLOAD 0654 80 DUP1 0655 91 SWAP2 0656 03 SUB 0657 90 SWAP1 0658 FD *REVERT // Stack delta = -1 // Outputs[1] { @0658 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0659: // Incoming jump from 0x061E, if stack[-1] // Inputs[2] // { // @065D stack[-3] // @065E stack[-2] // } 0659 5B JUMPDEST 065A 61 PUSH2 0x0663 065D 83 DUP4 065E 83 DUP4 065F 61 PUSH2 0x0ca3 0662 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @065A stack[0] = 0x0663 // @065D stack[1] = stack[-3] // @065E stack[2] = stack[-2] // } // Block ends with call to 0x0ca3, returns to 0x0663 label_0663: // Incoming return from call to 0x0CA3 at 0x0662 // Inputs[1] { @0667 stack[-4] } 0663 5B JUMPDEST 0664 50 POP 0665 50 POP 0666 50 POP 0667 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0668: // Incoming call from 0x01D2, returns to 0x01D3 0668 5B JUMPDEST 0669 61 PUSH2 0x0670 066C 61 PUSH2 0x0d5c 066F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0669 stack[0] = 0x0670 } // Block ends with call to 0x0d5c, returns to 0x0670 label_0670: // Incoming return from call to 0x0D5C at 0x066F // Inputs[1] { @0676 storage[0x09] } 0670 5B JUMPDEST 0671 60 PUSH1 0x09 0673 60 PUSH1 0x00 0675 90 SWAP1 0676 54 SLOAD 0677 90 SWAP1 0678 61 PUSH2 0x0100 067B 0A EXP 067C 90 SWAP1 067D 04 DIV 067E 60 PUSH1 0xff 0680 16 AND 0681 61 PUSH2 0x06b6 0684 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06b6, if 0xff & storage[0x09] / 0x0100 ** 0x00 label_0685: // Incoming jump from 0x0684, if not 0xff & storage[0x09] / 0x0100 ** 0x00 // Inputs[3] // { // @0687 memory[0x40:0x60] // @06B0 memory[0x40:0x60] // @06B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0685 60 PUSH1 0x40 0687 51 MLOAD 0688 7F PUSH32 0xc6b0e90b00000000000000000000000000000000000000000000000000000000 06A9 81 DUP2 06AA 52 MSTORE 06AB 60 PUSH1 0x04 06AD 01 ADD 06AE 60 PUSH1 0x40 06B0 51 MLOAD 06B1 80 DUP1 06B2 91 SWAP2 06B3 03 SUB 06B4 90 SWAP1 06B5 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @06AA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xc6b0e90b00000000000000000000000000000000000000000000000000000000 // @06B5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_06B6: // Incoming jump from 0x0684, if 0xff & storage[0x09] / 0x0100 ** 0x00 // Inputs[2] // { // @06BA msg.sender // @06BD storage[0x0a] // } 06B6 5B JUMPDEST 06B7 61 PUSH2 0x06c2 06BA 33 CALLER 06BB 60 PUSH1 0x0a 06BD 54 SLOAD 06BE 61 PUSH2 0x0dab 06C1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @06B7 stack[0] = 0x06c2 // @06BA stack[1] = msg.sender // @06BD stack[2] = storage[0x0a] // } // Block ends with call to 0x0dab, returns to 0x06C2 label_06C2: // Incoming return from call to 0x0DAB at 0x06C1 // Inputs[1] { @06C8 storage[0x0a] } 06C2 5B JUMPDEST 06C3 60 PUSH1 0x0a 06C5 60 PUSH1 0x00 06C7 81 DUP2 06C8 54 SLOAD 06C9 80 DUP1 06CA 92 SWAP3 06CB 91 SWAP2 06CC 90 SWAP1 06CD 61 PUSH2 0x06d5 06D0 90 SWAP1 06D1 61 PUSH2 0x21c3 06D4 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @06CA stack[0] = storage[0x0a] // @06CB stack[1] = 0x0a // @06CC stack[2] = 0x00 // @06D0 stack[3] = 0x06d5 // @06D0 stack[4] = storage[0x0a] // } // Block ends with call to 0x21c3, returns to 0x06D5 label_06D5: // Incoming return from call to 0x21C3 at 0x06D4 // Inputs[3] // { // @06D6 stack[-1] // @06D6 stack[-3] // @06D7 stack[-2] // } 06D5 5B JUMPDEST 06D6 91 SWAP2 06D7 90 SWAP1 06D8 50 POP 06D9 55 SSTORE 06DA 50 POP 06DB 61 PUSH2 0x06e2 06DE 61 PUSH2 0x0dc9 06E1 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @06D9 storage[stack[-3]] = stack[-1] // @06DB stack[-4] = 0x06e2 // } // Block ends with call to 0x0dc9, returns to 0x06E2 label_06E2: // Incoming return from call to 0x0DC9 at 0x06E1 // Inputs[1] { @06E3 stack[-1] } 06E2 5B JUMPDEST 06E3 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_06E4: // Incoming jump from 0x01EE 06E4 5B JUMPDEST 06E5 61 PUSH2 0x06f5 06E8 61 PUSH2 0x06ef 06EB 61 PUSH2 0x0c9b 06EE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06E5 stack[0] = 0x06f5 // @06E8 stack[1] = 0x06ef // } // Block ends with call to 0x0c9b, returns to 0x06EF label_06EF: // Incoming return from call to 0x0C9B at 0x06EE // Inputs[1] { @06F0 stack[-3] } 06EF 5B JUMPDEST 06F0 82 DUP3 06F1 61 PUSH2 0x0dd3 06F4 56 *JUMP // Stack delta = +1 // Outputs[1] { @06F0 stack[0] = stack[-3] } // Block ends with unconditional jump to 0x0dd3 label_06F5: // Incoming return from call to 0x06EF at 0x06EE // Inputs[1] { @06F9 stack[-1] } 06F5 5B JUMPDEST 06F6 61 PUSH2 0x0734 06F9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0734, if stack[-1] label_06FA: // Incoming jump from 0x06F9, if not stack[-1] // Inputs[1] { @06FC memory[0x40:0x60] } 06FA 60 PUSH1 0x40 06FC 51 MLOAD 06FD 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 071E 81 DUP2 071F 52 MSTORE 0720 60 PUSH1 0x04 0722 01 ADD 0723 61 PUSH2 0x072b 0726 90 SWAP1 0727 61 PUSH2 0x227d 072A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @071F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0726 stack[0] = 0x072b // @0726 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x227d, returns to 0x072B label_072B: // Incoming return from call to 0x227D at 0x072A // Inputs[3] // { // @072E memory[0x40:0x60] // @0730 stack[-1] // @0733 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 072B 5B JUMPDEST 072C 60 PUSH1 0x40 072E 51 MLOAD 072F 80 DUP1 0730 91 SWAP2 0731 03 SUB 0732 90 SWAP1 0733 FD *REVERT // Stack delta = -1 // Outputs[1] { @0733 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0734: // Incoming jump from 0x06F9, if stack[-1] // Inputs[3] // { // @0738 stack[-3] // @0739 stack[-2] // @073A stack[-1] // } 0734 5B JUMPDEST 0735 61 PUSH2 0x073f 0738 83 DUP4 0739 83 DUP4 073A 83 DUP4 073B 61 PUSH2 0x0e68 073E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0735 stack[0] = 0x073f // @0738 stack[1] = stack[-3] // @0739 stack[2] = stack[-2] // @073A stack[3] = stack[-1] // } // Block ends with call to 0x0e68, returns to 0x073F label_073F: // Incoming return from call to 0x0E68 at 0x073E // Inputs[1] { @0743 stack[-4] } 073F 5B JUMPDEST 0740 50 POP 0741 50 POP 0742 50 POP 0743 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0744: // Incoming call from 0x01F8, returns to 0x01F9 0744 5B JUMPDEST 0745 61 PUSH2 0x074c 0748 61 PUSH2 0x1161 074B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0745 stack[0] = 0x074c } // Block ends with call to 0x1161, returns to 0x074C label_074C: // Incoming return from call to 0x1161 at 0x074B // Inputs[2] // { // @0758 storage[0x09] // @0768 stack[-1] // } 074C 5B JUMPDEST 074D 60 PUSH1 0x01 074F 60 PUSH1 0x09 0751 60 PUSH1 0x00 0753 61 PUSH2 0x0100 0756 0A EXP 0757 81 DUP2 0758 54 SLOAD 0759 81 DUP2 075A 60 PUSH1 0xff 075C 02 MUL 075D 19 NOT 075E 16 AND 075F 90 SWAP1 0760 83 DUP4 0761 15 ISZERO 0762 15 ISZERO 0763 02 MUL 0764 17 OR 0765 90 SWAP1 0766 55 SSTORE 0767 50 POP 0768 56 *JUMP // Stack delta = -1 // Outputs[1] { @0766 storage[0x09] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[0x09]) } // Block ends with unconditional jump to stack[-1] label_0769: // Incoming jump from 0x0214 // Inputs[4] // { // @076D stack[-3] // @076E stack[-2] // @076F stack[-1] // @0772 memory[0x40:0x60] // } 0769 5B JUMPDEST 076A 61 PUSH2 0x0784 076D 83 DUP4 076E 83 DUP4 076F 83 DUP4 0770 60 PUSH1 0x40 0772 51 MLOAD 0773 80 DUP1 0774 60 PUSH1 0x20 0776 01 ADD 0777 60 PUSH1 0x40 0779 52 MSTORE 077A 80 DUP1 077B 60 PUSH1 0x00 077D 81 DUP2 077E 52 MSTORE 077F 50 POP 0780 61 PUSH2 0x09c9 0783 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @076A stack[0] = 0x0784 // @076D stack[1] = stack[-3] // @076E stack[2] = stack[-2] // @076F stack[3] = stack[-1] // @0772 stack[4] = memory[0x40:0x60] // @0779 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @077E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x09c9, returns to 0x0784 label_0784: // Incoming return from call to 0x09C9 at 0x0783 // Inputs[1] { @0788 stack[-4] } 0784 5B JUMPDEST 0785 50 POP 0786 50 POP 0787 50 POP 0788 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0789: // Incoming call from 0x0DDE, returns to 0x0DDF // Incoming jump from 0x0230 // Incoming call from 0x0F79, returns to 0x0F7A // Incoming call from 0x0D15, returns to 0x0D16 // Incoming call from 0x055B, returns to 0x055C // Incoming call from 0x0E87, returns to 0x0E88 // Inputs[1] { @0790 stack[-1] } 0789 5B JUMPDEST 078A 60 PUSH1 0x00 078C 80 DUP1 078D 61 PUSH2 0x0795 0790 83 DUP4 0791 61 PUSH2 0x11df 0794 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @078A stack[0] = 0x00 // @078C stack[1] = 0x00 // @078D stack[2] = 0x0795 // @0790 stack[3] = stack[-1] // } // Block ends with call to 0x11df, returns to 0x0795 label_0795: // Incoming return from call to 0x11DF at 0x0794 // Inputs[2] // { // @0796 stack[-2] // @0796 stack[-1] // } 0795 5B JUMPDEST 0796 90 SWAP1 0797 50 POP 0798 60 PUSH1 0x00 079A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07AF 16 AND 07B0 81 DUP2 07B1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07C6 16 AND 07C7 03 SUB 07C8 61 PUSH2 0x0806 07CB 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0796 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0806, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_07CC: // Incoming jump from 0x07CB, if not (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @07CE memory[0x40:0x60] } 07CC 60 PUSH1 0x40 07CE 51 MLOAD 07CF 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 07F0 81 DUP2 07F1 52 MSTORE 07F2 60 PUSH1 0x04 07F4 01 ADD 07F5 61 PUSH2 0x07fd 07F8 90 SWAP1 07F9 61 PUSH2 0x22e9 07FC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @07F1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @07F8 stack[0] = 0x07fd // @07F8 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x22e9, returns to 0x07FD label_07FD: // Incoming return from call to 0x22E9 at 0x07FC // Inputs[3] // { // @0800 memory[0x40:0x60] // @0802 stack[-1] // @0805 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 07FD 5B JUMPDEST 07FE 60 PUSH1 0x40 0800 51 MLOAD 0801 80 DUP1 0802 91 SWAP2 0803 03 SUB 0804 90 SWAP1 0805 FD *REVERT // Stack delta = -1 // Outputs[1] { @0805 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0806: // Incoming jump from 0x07CB, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[4] // { // @0807 stack[-1] // @0808 stack[-2] // @080B stack[-4] // @080C stack[-3] // } 0806 5B JUMPDEST 0807 80 DUP1 0808 91 SWAP2 0809 50 POP 080A 50 POP 080B 91 SWAP2 080C 90 SWAP1 080D 50 POP 080E 56 *JUMP // Stack delta = -3 // Outputs[1] { @080B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_080F: // Incoming jump from 0x0260 080F 5B JUMPDEST 0810 61 PUSH2 0x0817 0813 61 PUSH2 0x1161 0816 56 *JUMP // Stack delta = +1 // Outputs[1] { @0810 stack[0] = 0x0817 } // Block ends with call to 0x1161, returns to 0x0817 label_0817: // Incoming return from call to 0x1161 at 0x0816 // Inputs[2] // { // @0818 stack[-2] // @0819 stack[-1] // } 0817 5B JUMPDEST 0818 81 DUP2 0819 81 DUP2 081A 60 PUSH1 0x08 081C 91 SWAP2 081D 82 DUP3 081E 61 PUSH2 0x0828 0821 92 SWAP3 0822 91 SWAP2 0823 90 SWAP1 0824 61 PUSH2 0x24c0 0827 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @081C stack[0] = 0x08 // @0821 stack[1] = 0x0828 // @0822 stack[2] = stack[-1] // @0823 stack[3] = stack[-2] // @0823 stack[4] = 0x08 // } // Block ends with call to 0x24c0, returns to 0x0828 label_0828: // Incoming return from call to 0x24C0 at 0x0827 // Incoming return from call to 0x24C0 at 0x0827 // Inputs[1] { @082C stack[-4] } 0828 5B JUMPDEST 0829 50 POP 082A 50 POP 082B 50 POP 082C 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_082D: // Incoming jump from 0x027C // Inputs[1] { @0847 stack[-1] } 082D 5B JUMPDEST 082E 60 PUSH1 0x00 0830 80 DUP1 0831 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0846 16 AND 0847 82 DUP3 0848 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 085D 16 AND 085E 03 SUB 085F 61 PUSH2 0x089d 0862 57 *JUMPI // Stack delta = +1 // Outputs[1] { @082E stack[0] = 0x00 } // Block ends with conditional jump to 0x089d, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0863: // Incoming jump from 0x0862, if not (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0865 memory[0x40:0x60] } 0863 60 PUSH1 0x40 0865 51 MLOAD 0866 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0887 81 DUP2 0888 52 MSTORE 0889 60 PUSH1 0x04 088B 01 ADD 088C 61 PUSH2 0x0894 088F 90 SWAP1 0890 61 PUSH2 0x2602 0893 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0888 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @088F stack[0] = 0x0894 // @088F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2602, returns to 0x0894 label_0894: // Incoming return from call to 0x2602 at 0x0893 // Inputs[3] // { // @0897 memory[0x40:0x60] // @0899 stack[-1] // @089C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0894 5B JUMPDEST 0895 60 PUSH1 0x40 0897 51 MLOAD 0898 80 DUP1 0899 91 SWAP2 089A 03 SUB 089B 90 SWAP1 089C FD *REVERT // Stack delta = -1 // Outputs[1] { @089C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_089D: // Incoming jump from 0x0862, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[5] // { // @08A2 stack[-2] // @08DC memory[0x00:0x40] // @08DD storage[keccak256(memory[0x00:0x40])] // @08DE stack[-1] // @08E0 stack[-3] // } 089D 5B JUMPDEST 089E 60 PUSH1 0x04 08A0 60 PUSH1 0x00 08A2 83 DUP4 08A3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08B8 16 AND 08B9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08CE 16 AND 08CF 81 DUP2 08D0 52 MSTORE 08D1 60 PUSH1 0x20 08D3 01 ADD 08D4 90 SWAP1 08D5 81 DUP2 08D6 52 MSTORE 08D7 60 PUSH1 0x20 08D9 01 ADD 08DA 60 PUSH1 0x00 08DC 20 SHA3 08DD 54 SLOAD 08DE 90 SWAP1 08DF 50 POP 08E0 91 SWAP2 08E1 90 SWAP1 08E2 50 POP 08E3 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @08D0 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @08D6 memory[0x20:0x40] = 0x04 // @08E0 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_08E4: // Incoming call from 0x029A, returns to 0x029B 08E4 5B JUMPDEST 08E5 61 PUSH2 0x08ec 08E8 61 PUSH2 0x1161 08EB 56 *JUMP // Stack delta = +1 // Outputs[1] { @08E5 stack[0] = 0x08ec } // Block ends with call to 0x1161, returns to 0x08EC label_08EC: // Incoming return from call to 0x1161 at 0x08EB 08EC 5B JUMPDEST 08ED 61 PUSH2 0x08f6 08F0 60 PUSH1 0x00 08F2 61 PUSH2 0x121c 08F5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @08ED stack[0] = 0x08f6 // @08F0 stack[1] = 0x00 // } // Block ends with call to 0x121c, returns to 0x08F6 label_08F6: // Incoming return from call to 0x121C at 0x08F5 // Inputs[1] { @08F7 stack[-1] } 08F6 5B JUMPDEST 08F7 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_08F8: // Incoming call from 0x1186, returns to 0x1187 // Incoming call from 0x02A4, returns to 0x02A5 // Inputs[2] // { // @08FF storage[0x00] // @091F stack[-1] // } 08F8 5B JUMPDEST 08F9 60 PUSH1 0x00 08FB 80 DUP1 08FC 60 PUSH1 0x00 08FE 90 SWAP1 08FF 54 SLOAD 0900 90 SWAP1 0901 61 PUSH2 0x0100 0904 0A EXP 0905 90 SWAP1 0906 04 DIV 0907 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 091C 16 AND 091D 90 SWAP1 091E 50 POP 091F 90 SWAP1 0920 56 *JUMP // Stack delta = +0 // Outputs[1] { @091F stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0921: // Incoming call from 0x02C2, returns to 0x02C3 // Inputs[1] { @0927 storage[0x02] } 0921 5B JUMPDEST 0922 60 PUSH1 0x60 0924 60 PUSH1 0x02 0926 80 DUP1 0927 54 SLOAD 0928 61 PUSH2 0x0930 092B 90 SWAP1 092C 61 PUSH2 0x203f 092F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0922 stack[0] = 0x60 // @0924 stack[1] = 0x02 // @092B stack[2] = 0x0930 // @092B stack[3] = storage[0x02] // } // Block ends with call to 0x203f, returns to 0x0930 label_0930: // Incoming return from call to 0x203F at 0x092F // Inputs[4] // { // @0931 stack[-1] // @0940 memory[0x40:0x60] // @0948 stack[-2] // @0953 storage[stack[-2]] // } 0930 5B JUMPDEST 0931 80 DUP1 0932 60 PUSH1 0x1f 0934 01 ADD 0935 60 PUSH1 0x20 0937 80 DUP1 0938 91 SWAP2 0939 04 DIV 093A 02 MUL 093B 60 PUSH1 0x20 093D 01 ADD 093E 60 PUSH1 0x40 0940 51 MLOAD 0941 90 SWAP1 0942 81 DUP2 0943 01 ADD 0944 60 PUSH1 0x40 0946 52 MSTORE 0947 80 DUP1 0948 92 SWAP3 0949 91 SWAP2 094A 90 SWAP1 094B 81 DUP2 094C 81 DUP2 094D 52 MSTORE 094E 60 PUSH1 0x20 0950 01 ADD 0951 82 DUP3 0952 80 DUP1 0953 54 SLOAD 0954 61 PUSH2 0x095c 0957 90 SWAP1 0958 61 PUSH2 0x203f 095B 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0946 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0948 stack[-2] = memory[0x40:0x60] // @0949 stack[-1] = stack[-2] // @094A stack[0] = stack[-1] // @094D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0950 stack[1] = 0x20 + memory[0x40:0x60] // @0951 stack[2] = stack[-2] // @0957 stack[4] = storage[stack[-2]] // @0957 stack[3] = 0x095c // } // Block ends with call to 0x203f, returns to 0x095C label_095C: // Incoming return from call to 0x203F at 0x095B // Inputs[1] { @095D stack[-1] } 095C 5B JUMPDEST 095D 80 DUP1 095E 15 ISZERO 095F 61 PUSH2 0x09a9 0962 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09a9, if !stack[-1] label_0963: // Incoming jump from 0x0962, if not !stack[-1] // Inputs[1] { @0963 stack[-1] } 0963 80 DUP1 0964 60 PUSH1 0x1f 0966 10 LT 0967 61 PUSH2 0x097e 096A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x097e, if 0x1f < stack[-1] label_096B: // Incoming jump from 0x096A, if not 0x1f < stack[-1] // Inputs[4] // { // @096F stack[-2] // @0970 storage[stack[-2]] // @0973 stack[-3] // @0975 stack[-1] // } 096B 61 PUSH2 0x0100 096E 80 DUP1 096F 83 DUP4 0970 54 SLOAD 0971 04 DIV 0972 02 MUL 0973 83 DUP4 0974 52 MSTORE 0975 91 SWAP2 0976 60 PUSH1 0x20 0978 01 ADD 0979 91 SWAP2 097A 61 PUSH2 0x09a9 097D 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0974 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0979 stack[-1] = stack[-1] // @0979 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x09a9 label_097E: // Incoming jump from 0x096A, if 0x1f < stack[-1] // Inputs[5] // { // @097F stack[-3] // @0980 stack[-1] // @0982 stack[-2] // @098A memory[0x00:0x20] // @098E storage[keccak256(memory[0x00:0x20])] // } 097E 5B JUMPDEST 097F 82 DUP3 0980 01 ADD 0981 91 SWAP2 0982 90 SWAP1 0983 60 PUSH1 0x00 0985 52 MSTORE 0986 60 PUSH1 0x20 0988 60 PUSH1 0x00 098A 20 SHA3 098B 90 SWAP1 098C 5B JUMPDEST 098D 81 DUP2 098E 54 SLOAD 098F 81 DUP2 0990 52 MSTORE 0991 90 SWAP1 0992 60 PUSH1 0x01 0994 01 ADD 0995 90 SWAP1 0996 60 PUSH1 0x20 0998 01 ADD 0999 80 DUP1 099A 83 DUP4 099B 11 GT 099C 61 PUSH2 0x098c 099F 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0981 stack[-3] = stack[-3] + stack[-1] // @0985 memory[0x00:0x20] = stack[-2] // @0990 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0995 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0998 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x098c, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_09A0: // Incoming jump from 0x099F, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x099F, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @09A0 stack[-3] // @09A1 stack[-1] // } 09A0 82 DUP3 09A1 90 SWAP1 09A2 03 SUB 09A3 60 PUSH1 0x1f 09A5 16 AND 09A6 82 DUP3 09A7 01 ADD 09A8 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @09A8 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @09A8 stack[-1] = stack[-3] // } // Block continues label_09A9: // Incoming jump from 0x09A8 // Incoming jump from 0x0962, if !stack[-1] // Incoming jump from 0x097D // Inputs[3] // { // @09AF stack[-6] // @09AF stack[-7] // @09B1 stack[-8] // } 09A9 5B JUMPDEST 09AA 50 POP 09AB 50 POP 09AC 50 POP 09AD 50 POP 09AE 50 POP 09AF 90 SWAP1 09B0 50 POP 09B1 90 SWAP1 09B2 56 *JUMP // Stack delta = -7 // Outputs[1] { @09B1 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_09B3: // Incoming jump from 0x02F2 09B3 5B JUMPDEST 09B4 61 PUSH2 0x09c5 09B7 61 PUSH2 0x09be 09BA 61 PUSH2 0x0c9b 09BD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @09B4 stack[0] = 0x09c5 // @09B7 stack[1] = 0x09be // } // Block ends with call to 0x0c9b, returns to 0x09BE label_09BE: // Incoming return from call to 0x0C9B at 0x09BD // Inputs[2] // { // @09BF stack[-4] // @09C0 stack[-3] // } 09BE 5B JUMPDEST 09BF 83 DUP4 09C0 83 DUP4 09C1 61 PUSH2 0x12e0 09C4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @09BF stack[0] = stack[-4] // @09C0 stack[1] = stack[-3] // } // Block ends with unconditional jump to 0x12e0 label_09C5: // Incoming return from call to 0x09BE at 0x09BD // Inputs[1] { @09C8 stack[-3] } 09C5 5B JUMPDEST 09C6 50 POP 09C7 50 POP 09C8 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_09C9: // Incoming call from 0x0783, returns to 0x0784 // Incoming jump from 0x030E 09C9 5B JUMPDEST 09CA 61 PUSH2 0x09da 09CD 61 PUSH2 0x09d4 09D0 61 PUSH2 0x0c9b 09D3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @09CA stack[0] = 0x09da // @09CD stack[1] = 0x09d4 // } // Block ends with call to 0x0c9b, returns to 0x09D4 label_09D4: // Incoming return from call to 0x0C9B at 0x09D3 // Inputs[1] { @09D5 stack[-4] } 09D4 5B JUMPDEST 09D5 83 DUP4 09D6 61 PUSH2 0x0dd3 09D9 56 *JUMP // Stack delta = +1 // Outputs[1] { @09D5 stack[0] = stack[-4] } // Block ends with unconditional jump to 0x0dd3 label_09DA: // Incoming return from call to 0x09D4 at 0x09D3 // Inputs[1] { @09DE stack[-1] } 09DA 5B JUMPDEST 09DB 61 PUSH2 0x0a19 09DE 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a19, if stack[-1] label_09DF: // Incoming jump from 0x09DE, if not stack[-1] // Inputs[1] { @09E1 memory[0x40:0x60] } 09DF 60 PUSH1 0x40 09E1 51 MLOAD 09E2 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0A03 81 DUP2 0A04 52 MSTORE 0A05 60 PUSH1 0x04 0A07 01 ADD 0A08 61 PUSH2 0x0a10 0A0B 90 SWAP1 0A0C 61 PUSH2 0x227d 0A0F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A04 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0A0B stack[0] = 0x0a10 // @0A0B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x227d, returns to 0x0A10 label_0A10: // Incoming return from call to 0x227D at 0x0A0F // Inputs[3] // { // @0A13 memory[0x40:0x60] // @0A15 stack[-1] // @0A18 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0A10 5B JUMPDEST 0A11 60 PUSH1 0x40 0A13 51 MLOAD 0A14 80 DUP1 0A15 91 SWAP2 0A16 03 SUB 0A17 90 SWAP1 0A18 FD *REVERT // Stack delta = -1 // Outputs[1] { @0A18 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0A19: // Incoming jump from 0x09DE, if stack[-1] // Inputs[4] // { // @0A1D stack[-4] // @0A1E stack[-3] // @0A1F stack[-2] // @0A20 stack[-1] // } 0A19 5B JUMPDEST 0A1A 61 PUSH2 0x0a25 0A1D 84 DUP5 0A1E 84 DUP5 0A1F 84 DUP5 0A20 84 DUP5 0A21 61 PUSH2 0x144c 0A24 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0A1A stack[0] = 0x0a25 // @0A1D stack[1] = stack[-4] // @0A1E stack[2] = stack[-3] // @0A1F stack[3] = stack[-2] // @0A20 stack[4] = stack[-1] // } // Block ends with call to 0x144c, returns to 0x0A25 label_0A25: // Incoming return from call to 0x144C at 0x0A24 // Inputs[1] { @0A2A stack[-5] } 0A25 5B JUMPDEST 0A26 50 POP 0A27 50 POP 0A28 50 POP 0A29 50 POP 0A2A 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0A2B: // Incoming jump from 0x032A // Inputs[1] { @0A49 stack[-1] } 0A2B 5B JUMPDEST 0A2C 60 PUSH1 0x60 0A2E 60 PUSH1 0x00 0A30 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A45 16 AND 0A46 61 PUSH2 0x0a4e 0A49 83 DUP4 0A4A 61 PUSH2 0x11df 0A4D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A2C stack[0] = 0x60 // @0A45 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & 0x00 // @0A46 stack[2] = 0x0a4e // @0A49 stack[3] = stack[-1] // } // Block ends with call to 0x11df, returns to 0x0A4E label_0A4E: // Incoming return from call to 0x11DF at 0x0A4D // Inputs[2] // { // @0A64 stack[-1] // @0A65 stack[-2] // } 0A4E 5B JUMPDEST 0A4F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A64 16 AND 0A65 03 SUB 0A66 61 PUSH2 0x0a9b 0A69 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0a9b, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) - stack[-2] label_0A6A: // Incoming jump from 0x0A69, if not (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) - stack[-2] // Inputs[3] // { // @0A6C memory[0x40:0x60] // @0A95 memory[0x40:0x60] // @0A9A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A6A 60 PUSH1 0x40 0A6C 51 MLOAD 0A6D 7F PUSH32 0x3f6cc76800000000000000000000000000000000000000000000000000000000 0A8E 81 DUP2 0A8F 52 MSTORE 0A90 60 PUSH1 0x04 0A92 01 ADD 0A93 60 PUSH1 0x40 0A95 51 MLOAD 0A96 80 DUP1 0A97 91 SWAP2 0A98 03 SUB 0A99 90 SWAP1 0A9A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A8F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3f6cc76800000000000000000000000000000000000000000000000000000000 // @0A9A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0A9B: // Incoming jump from 0x0A69, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) - stack[-2] 0A9B 5B JUMPDEST 0A9C 61 PUSH2 0x0aa3 0A9F 61 PUSH2 0x14a8 0AA2 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A9C stack[0] = 0x0aa3 } // Block ends with call to 0x14a8, returns to 0x0AA3 label_0AA3: // Incoming return from call to 0x14A8 at 0x0AA2 // Inputs[4] // { // @0AA4 stack[-2] // @0AA4 stack[-1] // @0AA6 stack[-4] // @0AA7 stack[-3] // } 0AA3 5B JUMPDEST 0AA4 90 SWAP1 0AA5 50 POP 0AA6 91 SWAP2 0AA7 90 SWAP1 0AA8 50 POP 0AA9 56 *JUMP // Stack delta = -3 // Outputs[1] { @0AA6 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0AAA: // Incoming call from 0x0348, returns to 0x0349 0AAA 5B JUMPDEST 0AAB 61 PUSH2 0x0ab2 0AAE 61 PUSH2 0x1161 0AB1 56 *JUMP // Stack delta = +1 // Outputs[1] { @0AAB stack[0] = 0x0ab2 } // Block ends with call to 0x1161, returns to 0x0AB2 label_0AB2: // Incoming return from call to 0x1161 at 0x0AB1 // Inputs[2] // { // @0ABE storage[0x09] // @0ACE stack[-1] // } 0AB2 5B JUMPDEST 0AB3 60 PUSH1 0x00 0AB5 60 PUSH1 0x09 0AB7 60 PUSH1 0x00 0AB9 61 PUSH2 0x0100 0ABC 0A EXP 0ABD 81 DUP2 0ABE 54 SLOAD 0ABF 81 DUP2 0AC0 60 PUSH1 0xff 0AC2 02 MUL 0AC3 19 NOT 0AC4 16 AND 0AC5 90 SWAP1 0AC6 83 DUP4 0AC7 15 ISZERO 0AC8 15 ISZERO 0AC9 02 MUL 0ACA 17 OR 0ACB 90 SWAP1 0ACC 55 SSTORE 0ACD 50 POP 0ACE 56 *JUMP // Stack delta = -1 // Outputs[1] { @0ACC storage[0x09] = !!0x00 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[0x09]) } // Block ends with unconditional jump to stack[-1] label_0ACF: // Incoming jump from 0x0364 // Incoming call from 0x0E1F, returns to 0x0E20 // Incoming jump from 0x0618 // Inputs[6] // { // @0AD6 stack[-2] // @0B10 memory[0x00:0x40] // @0B13 stack[-1] // @0B4D memory[0x00:0x40] // @0B51 storage[keccak256(memory[0x00:0x40])] // @0B5E stack[-3] // } 0ACF 5B JUMPDEST 0AD0 60 PUSH1 0x00 0AD2 60 PUSH1 0x06 0AD4 60 PUSH1 0x00 0AD6 84 DUP5 0AD7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AEC 16 AND 0AED 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B02 16 AND 0B03 81 DUP2 0B04 52 MSTORE 0B05 60 PUSH1 0x20 0B07 01 ADD 0B08 90 SWAP1 0B09 81 DUP2 0B0A 52 MSTORE 0B0B 60 PUSH1 0x20 0B0D 01 ADD 0B0E 60 PUSH1 0x00 0B10 20 SHA3 0B11 60 PUSH1 0x00 0B13 83 DUP4 0B14 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B29 16 AND 0B2A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B3F 16 AND 0B40 81 DUP2 0B41 52 MSTORE 0B42 60 PUSH1 0x20 0B44 01 ADD 0B45 90 SWAP1 0B46 81 DUP2 0B47 52 MSTORE 0B48 60 PUSH1 0x20 0B4A 01 ADD 0B4B 60 PUSH1 0x00 0B4D 20 SHA3 0B4E 60 PUSH1 0x00 0B50 90 SWAP1 0B51 54 SLOAD 0B52 90 SWAP1 0B53 61 PUSH2 0x0100 0B56 0A EXP 0B57 90 SWAP1 0B58 04 DIV 0B59 60 PUSH1 0xff 0B5B 16 AND 0B5C 90 SWAP1 0B5D 50 POP 0B5E 92 SWAP3 0B5F 91 SWAP2 0B60 50 POP 0B61 50 POP 0B62 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0B04 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0B0A memory[0x20:0x40] = 0x06 // @0B41 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0B47 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0B5E stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-3] label_0B63: // Incoming jump from 0x0394 0B63 5B JUMPDEST 0B64 61 PUSH2 0x0b6b 0B67 61 PUSH2 0x1161 0B6A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B64 stack[0] = 0x0b6b } // Block ends with call to 0x1161, returns to 0x0B6B label_0B6B: // Incoming return from call to 0x1161 at 0x0B6A // Inputs[1] { @0B84 stack[-1] } 0B6B 5B JUMPDEST 0B6C 60 PUSH1 0x00 0B6E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B83 16 AND 0B84 81 DUP2 0B85 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B9A 16 AND 0B9B 03 SUB 0B9C 61 PUSH2 0x0bda 0B9F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bda, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0BA0: // Incoming jump from 0x0B9F, if not (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0BA2 memory[0x40:0x60] } 0BA0 60 PUSH1 0x40 0BA2 51 MLOAD 0BA3 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0BC4 81 DUP2 0BC5 52 MSTORE 0BC6 60 PUSH1 0x04 0BC8 01 ADD 0BC9 61 PUSH2 0x0bd1 0BCC 90 SWAP1 0BCD 61 PUSH2 0x2694 0BD0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0BC5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0BCC stack[0] = 0x0bd1 // @0BCC stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2694, returns to 0x0BD1 label_0BD1: // Incoming return from call to 0x2694 at 0x0BD0 // Inputs[3] // { // @0BD4 memory[0x40:0x60] // @0BD6 stack[-1] // @0BD9 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0BD1 5B JUMPDEST 0BD2 60 PUSH1 0x40 0BD4 51 MLOAD 0BD5 80 DUP1 0BD6 91 SWAP2 0BD7 03 SUB 0BD8 90 SWAP1 0BD9 FD *REVERT // Stack delta = -1 // Outputs[1] { @0BD9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0BDA: // Incoming jump from 0x0B9F, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0BDE stack[-1] } 0BDA 5B JUMPDEST 0BDB 61 PUSH2 0x0be3 0BDE 81 DUP2 0BDF 61 PUSH2 0x121c 0BE2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0BDB stack[0] = 0x0be3 // @0BDE stack[1] = stack[-1] // } // Block ends with call to 0x121c, returns to 0x0BE3 label_0BE3: // Incoming return from call to 0x121C at 0x0BE2 // Inputs[1] { @0BE5 stack[-2] } 0BE3 5B JUMPDEST 0BE4 50 POP 0BE5 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0BE6: // Incoming call from 0x0470, returns to 0x0471 // Inputs[2] // { // @0C29 stack[-1] // @0C4C stack[-2] // } 0BE6 5B JUMPDEST 0BE7 60 PUSH1 0x00 0BE9 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 0C0A 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0C27 19 NOT 0C28 16 AND 0C29 82 DUP3 0C2A 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0C47 19 NOT 0C48 16 AND 0C49 14 EQ 0C4A 90 SWAP1 0C4B 50 POP 0C4C 91 SWAP2 0C4D 90 SWAP1 0C4E 50 POP 0C4F 56 *JUMP // Stack delta = -1 // Outputs[1] { @0C4C stack[-2] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x01ffc9a700000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to stack[-2] label_0C50: // Incoming call from 0x0515, returns to 0x0516 // Inputs[1] { @0C54 stack[-1] } 0C50 5B JUMPDEST 0C51 61 PUSH2 0x0c59 0C54 81 DUP2 0C55 61 PUSH2 0x153a 0C58 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C51 stack[0] = 0x0c59 // @0C54 stack[1] = stack[-1] // } // Block ends with call to 0x153a, returns to 0x0C59 label_0C59: // Incoming return from call to 0x153A at 0x0C58 // Inputs[1] { @0C5D stack[-1] } 0C59 5B JUMPDEST 0C5A 61 PUSH2 0x0c98 0C5D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c98, if stack[-1] label_0C5E: // Incoming jump from 0x0C5D, if not stack[-1] // Inputs[1] { @0C60 memory[0x40:0x60] } 0C5E 60 PUSH1 0x40 0C60 51 MLOAD 0C61 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0C82 81 DUP2 0C83 52 MSTORE 0C84 60 PUSH1 0x04 0C86 01 ADD 0C87 61 PUSH2 0x0c8f 0C8A 90 SWAP1 0C8B 61 PUSH2 0x22e9 0C8E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C83 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0C8A stack[0] = 0x0c8f // @0C8A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x22e9, returns to 0x0C8F label_0C8F: // Incoming return from call to 0x22E9 at 0x0C8E // Inputs[3] // { // @0C92 memory[0x40:0x60] // @0C94 stack[-1] // @0C97 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0C8F 5B JUMPDEST 0C90 60 PUSH1 0x40 0C92 51 MLOAD 0C93 80 DUP1 0C94 91 SWAP2 0C95 03 SUB 0C96 90 SWAP1 0C97 FD *REVERT // Stack delta = -1 // Outputs[1] { @0C97 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0C98: // Incoming jump from 0x0C5D, if stack[-1] // Inputs[1] { @0C9A stack[-2] } 0C98 5B JUMPDEST 0C99 50 POP 0C9A 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0C9B: // Incoming call from 0x1168, returns to 0x1169 // Incoming call from 0x162B, returns to 0x162C // Incoming call from 0x09BD, returns to 0x09BE // Incoming call from 0x05EA, returns to 0x05EB // Incoming call from 0x09D3, returns to 0x09D4 // Incoming call from 0x06EE, returns to 0x06EF // Incoming call from 0x0613, returns to 0x0614 // Inputs[2] // { // @0C9E msg.sender // @0CA1 stack[-1] // } 0C9B 5B JUMPDEST 0C9C 60 PUSH1 0x00 0C9E 33 CALLER 0C9F 90 SWAP1 0CA0 50 POP 0CA1 90 SWAP1 0CA2 56 *JUMP // Stack delta = +0 // Outputs[1] { @0CA1 stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_0CA3: // Incoming call from 0x0662, returns to 0x0663 // Inputs[4] // { // @0CA4 stack[-2] // @0CA9 stack[-1] // @0CB7 memory[0x00:0x40] // @0CBF storage[keccak256(memory[0x00:0x40])] // } 0CA3 5B JUMPDEST 0CA4 81 DUP2 0CA5 60 PUSH1 0x05 0CA7 60 PUSH1 0x00 0CA9 83 DUP4 0CAA 81 DUP2 0CAB 52 MSTORE 0CAC 60 PUSH1 0x20 0CAE 01 ADD 0CAF 90 SWAP1 0CB0 81 DUP2 0CB1 52 MSTORE 0CB2 60 PUSH1 0x20 0CB4 01 ADD 0CB5 60 PUSH1 0x00 0CB7 20 SHA3 0CB8 60 PUSH1 0x00 0CBA 61 PUSH2 0x0100 0CBD 0A EXP 0CBE 81 DUP2 0CBF 54 SLOAD 0CC0 81 DUP2 0CC1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CD6 02 MUL 0CD7 19 NOT 0CD8 16 AND 0CD9 90 SWAP1 0CDA 83 DUP4 0CDB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CF0 16 AND 0CF1 02 MUL 0CF2 17 OR 0CF3 90 SWAP1 0CF4 55 SSTORE 0CF5 50 POP 0CF6 80 DUP1 0CF7 82 DUP3 0CF8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D0D 16 AND 0D0E 61 PUSH2 0x0d16 0D11 83 DUP4 0D12 61 PUSH2 0x0789 0D15 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @0CAB memory[0x00:0x20] = stack[-1] // @0CB1 memory[0x20:0x40] = 0x05 // @0CF4 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @0CF6 stack[0] = stack[-1] // @0D0D stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0D0E stack[2] = 0x0d16 // @0D11 stack[3] = stack[-1] // } // Block ends with call to 0x0789, returns to 0x0D16 label_0D16: // Incoming return from call to 0x0789 at 0x0D15 // Inputs[7] // { // @0D2C stack[-1] // @0D50 memory[0x40:0x60] // @0D53 memory[0x40:0x60] // @0D58 stack[-2] // @0D58 stack[-3] // @0D58 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0D5B stack[-6] // } 0D16 5B JUMPDEST 0D17 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D2C 16 AND 0D2D 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0D4E 60 PUSH1 0x40 0D50 51 MLOAD 0D51 60 PUSH1 0x40 0D53 51 MLOAD 0D54 80 DUP1 0D55 91 SWAP2 0D56 03 SUB 0D57 90 SWAP1 0D58 A4 LOG4 0D59 50 POP 0D5A 50 POP 0D5B 56 *JUMP // Stack delta = -6 // Outputs[1] { @0D58 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2], stack[-3]]); } // Block ends with unconditional jump to stack[-6] label_0D5C: // Incoming call from 0x066F, returns to 0x0670 // Inputs[1] { @0D61 storage[0x07] } 0D5C 5B JUMPDEST 0D5D 60 PUSH1 0x02 0D5F 60 PUSH1 0x07 0D61 54 SLOAD 0D62 03 SUB 0D63 61 PUSH2 0x0da1 0D66 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0da1, if storage[0x07] - 0x02 label_0D67: // Incoming jump from 0x0D66, if not storage[0x07] - 0x02 // Inputs[1] { @0D69 memory[0x40:0x60] } 0D67 60 PUSH1 0x40 0D69 51 MLOAD 0D6A 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0D8B 81 DUP2 0D8C 52 MSTORE 0D8D 60 PUSH1 0x04 0D8F 01 ADD 0D90 61 PUSH2 0x0d98 0D93 90 SWAP1 0D94 61 PUSH2 0x2700 0D97 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D8C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0D93 stack[0] = 0x0d98 // @0D93 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2700, returns to 0x0D98 label_0D98: // Incoming return from call to 0x2700 at 0x0D97 // Inputs[3] // { // @0D9B memory[0x40:0x60] // @0D9D stack[-1] // @0DA0 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0D98 5B JUMPDEST 0D99 60 PUSH1 0x40 0D9B 51 MLOAD 0D9C 80 DUP1 0D9D 91 SWAP2 0D9E 03 SUB 0D9F 90 SWAP1 0DA0 FD *REVERT // Stack delta = -1 // Outputs[1] { @0DA0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0DA1: // Incoming jump from 0x0D66, if storage[0x07] - 0x02 // Inputs[1] { @0DAA stack[-1] } 0DA1 5B JUMPDEST 0DA2 60 PUSH1 0x02 0DA4 60 PUSH1 0x07 0DA6 81 DUP2 0DA7 90 SWAP1 0DA8 55 SSTORE 0DA9 50 POP 0DAA 56 *JUMP // Stack delta = -1 // Outputs[1] { @0DA8 storage[0x07] = 0x02 } // Block ends with unconditional jump to stack[-1] label_0DAB: // Incoming call from 0x06C1, returns to 0x06C2 // Inputs[3] // { // @0DAF stack[-2] // @0DB0 stack[-1] // @0DB3 memory[0x40:0x60] // } 0DAB 5B JUMPDEST 0DAC 61 PUSH2 0x0dc5 0DAF 82 DUP3 0DB0 82 DUP3 0DB1 60 PUSH1 0x40 0DB3 51 MLOAD 0DB4 80 DUP1 0DB5 60 PUSH1 0x20 0DB7 01 ADD 0DB8 60 PUSH1 0x40 0DBA 52 MSTORE 0DBB 80 DUP1 0DBC 60 PUSH1 0x00 0DBE 81 DUP2 0DBF 52 MSTORE 0DC0 50 POP 0DC1 61 PUSH2 0x157b 0DC4 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0DAC stack[0] = 0x0dc5 // @0DAF stack[1] = stack[-2] // @0DB0 stack[2] = stack[-1] // @0DB3 stack[3] = memory[0x40:0x60] // @0DBA memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0DBF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x157b, returns to 0x0DC5 label_0DC5: // Incoming return from call to 0x157B at 0x0DC4 // Inputs[1] { @0DC8 stack[-3] } 0DC5 5B JUMPDEST 0DC6 50 POP 0DC7 50 POP 0DC8 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0DC9: // Incoming call from 0x06E1, returns to 0x06E2 // Inputs[1] { @0DD2 stack[-1] } 0DC9 5B JUMPDEST 0DCA 60 PUSH1 0x01 0DCC 60 PUSH1 0x07 0DCE 81 DUP2 0DCF 90 SWAP1 0DD0 55 SSTORE 0DD1 50 POP 0DD2 56 *JUMP // Stack delta = -1 // Outputs[1] { @0DD0 storage[0x07] = 0x01 } // Block ends with unconditional jump to stack[-1] label_0DD3: // Incoming jump from 0x09D9 // Incoming jump from 0x06F4 // Inputs[1] { @0DDA stack[-1] } 0DD3 5B JUMPDEST 0DD4 60 PUSH1 0x00 0DD6 80 DUP1 0DD7 61 PUSH2 0x0ddf 0DDA 83 DUP4 0DDB 61 PUSH2 0x0789 0DDE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0DD4 stack[0] = 0x00 // @0DD6 stack[1] = 0x00 // @0DD7 stack[2] = 0x0ddf // @0DDA stack[3] = stack[-1] // } // Block ends with call to 0x0789, returns to 0x0DDF label_0DDF: // Incoming return from call to 0x0789 at 0x0DDE // Inputs[3] // { // @0DE0 stack[-1] // @0DE0 stack[-2] // @0DF9 stack[-5] // } 0DDF 5B JUMPDEST 0DE0 90 SWAP1 0DE1 50 POP 0DE2 80 DUP1 0DE3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DF8 16 AND 0DF9 84 DUP5 0DFA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E0F 16 AND 0E10 14 EQ 0E11 80 DUP1 0E12 61 PUSH2 0x0e21 0E15 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0DE0 stack[-2] = stack[-1] // @0E10 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // } // Block ends with conditional jump to 0x0e21, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] label_0E16: // Incoming jump from 0x0E15, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[2] // { // @0E1A stack[-2] // @0E1B stack[-5] // } 0E16 50 POP 0E17 61 PUSH2 0x0e20 0E1A 81 DUP2 0E1B 85 DUP6 0E1C 61 PUSH2 0x0acf 0E1F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E17 stack[-1] = 0x0e20 // @0E1A stack[0] = stack[-2] // @0E1B stack[1] = stack[-5] // } // Block ends with call to 0x0acf, returns to 0x0E20 label_0E20: // Incoming return from call to 0x0ACF at 0x0E1F 0E20 5B JUMPDEST // Stack delta = +0 // Block continues label_0E21: // Incoming jump from 0x0E15, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Incoming jump from 0x0E20 // Inputs[1] { @0E22 stack[-1] } 0E21 5B JUMPDEST 0E22 80 DUP1 0E23 61 PUSH2 0x0e5f 0E26 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e5f, if stack[-1] label_0E27: // Incoming jump from 0x0E26, if not stack[-1] // Inputs[2] // { // @0E28 stack[-5] // @0E42 stack[-4] // } 0E27 50 POP 0E28 83 DUP4 0E29 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E3E 16 AND 0E3F 61 PUSH2 0x0e47 0E42 84 DUP5 0E43 61 PUSH2 0x050b 0E46 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E3E stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0E3F stack[0] = 0x0e47 // @0E42 stack[1] = stack[-4] // } // Block ends with call to 0x050b, returns to 0x0E47 label_0E47: // Incoming return from call to 0x050B at 0x0E46 // Inputs[2] // { // @0E5D stack[-1] // @0E5E stack[-2] // } 0E47 5B JUMPDEST 0E48 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E5D 16 AND 0E5E 14 EQ // Stack delta = -1 // Outputs[1] { @0E5E stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] } // Block continues label_0E5F: // Incoming jump from 0x0E5E // Incoming jump from 0x0E26, if stack[-1] // Inputs[4] // { // @0E60 stack[-1] // @0E60 stack[-3] // @0E63 stack[-6] // @0E64 stack[-5] // } 0E5F 5B JUMPDEST 0E60 91 SWAP2 0E61 50 POP 0E62 50 POP 0E63 92 SWAP3 0E64 91 SWAP2 0E65 50 POP 0E66 50 POP 0E67 56 *JUMP // Stack delta = -5 // Outputs[1] { @0E63 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0E68: // Incoming call from 0x073E, returns to 0x073F // Incoming call from 0x1456, returns to 0x1457 // Inputs[2] // { // @0E69 stack[-3] // @0E83 stack[-1] // } 0E68 5B JUMPDEST 0E69 82 DUP3 0E6A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E7F 16 AND 0E80 61 PUSH2 0x0e88 0E83 82 DUP3 0E84 61 PUSH2 0x0789 0E87 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E7F stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0E80 stack[1] = 0x0e88 // @0E83 stack[2] = stack[-1] // } // Block ends with call to 0x0789, returns to 0x0E88 label_0E88: // Incoming return from call to 0x0789 at 0x0E87 // Inputs[2] // { // @0E9E stack[-1] // @0E9F stack[-2] // } 0E88 5B JUMPDEST 0E89 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E9E 16 AND 0E9F 14 EQ 0EA0 61 PUSH2 0x0ede 0EA3 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0ede, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_0EA4: // Incoming jump from 0x0EA3, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @0EA6 memory[0x40:0x60] } 0EA4 60 PUSH1 0x40 0EA6 51 MLOAD 0EA7 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0EC8 81 DUP2 0EC9 52 MSTORE 0ECA 60 PUSH1 0x04 0ECC 01 ADD 0ECD 61 PUSH2 0x0ed5 0ED0 90 SWAP1 0ED1 61 PUSH2 0x2792 0ED4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0EC9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0ED0 stack[0] = 0x0ed5 // @0ED0 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2792, returns to 0x0ED5 label_0ED5: // Incoming return from call to 0x2792 at 0x0ED4 // Inputs[3] // { // @0ED8 memory[0x40:0x60] // @0EDA stack[-1] // @0EDD memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0ED5 5B JUMPDEST 0ED6 60 PUSH1 0x40 0ED8 51 MLOAD 0ED9 80 DUP1 0EDA 91 SWAP2 0EDB 03 SUB 0EDC 90 SWAP1 0EDD FD *REVERT // Stack delta = -1 // Outputs[1] { @0EDD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0EDE: // Incoming jump from 0x0EA3, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @0EF7 stack[-2] } 0EDE 5B JUMPDEST 0EDF 60 PUSH1 0x00 0EE1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EF6 16 AND 0EF7 82 DUP3 0EF8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F0D 16 AND 0F0E 03 SUB 0F0F 61 PUSH2 0x0f4d 0F12 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f4d, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0F13: // Incoming jump from 0x0F12, if not (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0F15 memory[0x40:0x60] } 0F13 60 PUSH1 0x40 0F15 51 MLOAD 0F16 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0F37 81 DUP2 0F38 52 MSTORE 0F39 60 PUSH1 0x04 0F3B 01 ADD 0F3C 61 PUSH2 0x0f44 0F3F 90 SWAP1 0F40 61 PUSH2 0x2824 0F43 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0F38 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0F3F stack[0] = 0x0f44 // @0F3F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2824, returns to 0x0F44 label_0F44: // Incoming return from call to 0x2824 at 0x0F43 // Inputs[3] // { // @0F47 memory[0x40:0x60] // @0F49 stack[-1] // @0F4C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0F44 5B JUMPDEST 0F45 60 PUSH1 0x40 0F47 51 MLOAD 0F48 80 DUP1 0F49 91 SWAP2 0F4A 03 SUB 0F4B 90 SWAP1 0F4C FD *REVERT // Stack delta = -1 // Outputs[1] { @0F4C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0F4D: // Incoming jump from 0x0F12, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @0F51 stack[-3] // @0F52 stack[-2] // @0F53 stack[-1] // } 0F4D 5B JUMPDEST 0F4E 61 PUSH2 0x0f5a 0F51 83 DUP4 0F52 83 DUP4 0F53 83 DUP4 0F54 60 PUSH1 0x01 0F56 61 PUSH2 0x15d6 0F59 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0F4E stack[0] = 0x0f5a // @0F51 stack[1] = stack[-3] // @0F52 stack[2] = stack[-2] // @0F53 stack[3] = stack[-1] // @0F54 stack[4] = 0x01 // } // Block ends with call to 0x15d6, returns to 0x0F5A label_0F5A: // Incoming return from call to 0x15D6 at 0x0F59 // Inputs[2] // { // @0F5B stack[-3] // @0F75 stack[-1] // } 0F5A 5B JUMPDEST 0F5B 82 DUP3 0F5C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F71 16 AND 0F72 61 PUSH2 0x0f7a 0F75 82 DUP3 0F76 61 PUSH2 0x0789 0F79 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F71 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0F72 stack[1] = 0x0f7a // @0F75 stack[2] = stack[-1] // } // Block ends with call to 0x0789, returns to 0x0F7A label_0F7A: // Incoming return from call to 0x0789 at 0x0F79 // Inputs[2] // { // @0F90 stack[-1] // @0F91 stack[-2] // } 0F7A 5B JUMPDEST 0F7B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F90 16 AND 0F91 14 EQ 0F92 61 PUSH2 0x0fd0 0F95 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0fd0, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_0F96: // Incoming jump from 0x0F95, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @0F98 memory[0x40:0x60] } 0F96 60 PUSH1 0x40 0F98 51 MLOAD 0F99 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0FBA 81 DUP2 0FBB 52 MSTORE 0FBC 60 PUSH1 0x04 0FBE 01 ADD 0FBF 61 PUSH2 0x0fc7 0FC2 90 SWAP1 0FC3 61 PUSH2 0x2792 0FC6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0FBB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0FC2 stack[0] = 0x0fc7 // @0FC2 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2792, returns to 0x0FC7 label_0FC7: // Incoming return from call to 0x2792 at 0x0FC6 // Inputs[3] // { // @0FCA memory[0x40:0x60] // @0FCC stack[-1] // @0FCF memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0FC7 5B JUMPDEST 0FC8 60 PUSH1 0x40 0FCA 51 MLOAD 0FCB 80 DUP1 0FCC 91 SWAP2 0FCD 03 SUB 0FCE 90 SWAP1 0FCF FD *REVERT // Stack delta = -1 // Outputs[1] { @0FCF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0FD0: // Incoming jump from 0x0F95, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[14] // { // @0FD5 stack[-1] // @0FE3 memory[0x00:0x40] // @0FEB storage[keccak256(memory[0x00:0x40])] // @100D stack[-3] // @1047 memory[0x00:0x40] // @104C storage[keccak256(memory[0x00:0x40])] // @105B stack[-2] // @1095 memory[0x00:0x40] // @109A storage[keccak256(memory[0x00:0x40])] // @10B6 memory[0x00:0x40] // @10BE storage[keccak256(memory[0x00:0x40])] // @1147 memory[0x40:0x60] // @114A memory[0x40:0x60] // @114F memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // } 0FD0 5B JUMPDEST 0FD1 60 PUSH1 0x05 0FD3 60 PUSH1 0x00 0FD5 82 DUP3 0FD6 81 DUP2 0FD7 52 MSTORE 0FD8 60 PUSH1 0x20 0FDA 01 ADD 0FDB 90 SWAP1 0FDC 81 DUP2 0FDD 52 MSTORE 0FDE 60 PUSH1 0x20 0FE0 01 ADD 0FE1 60 PUSH1 0x00 0FE3 20 SHA3 0FE4 60 PUSH1 0x00 0FE6 61 PUSH2 0x0100 0FE9 0A EXP 0FEA 81 DUP2 0FEB 54 SLOAD 0FEC 90 SWAP1 0FED 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1002 02 MUL 1003 19 NOT 1004 16 AND 1005 90 SWAP1 1006 55 SSTORE 1007 60 PUSH1 0x01 1009 60 PUSH1 0x04 100B 60 PUSH1 0x00 100D 85 DUP6 100E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1023 16 AND 1024 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1039 16 AND 103A 81 DUP2 103B 52 MSTORE 103C 60 PUSH1 0x20 103E 01 ADD 103F 90 SWAP1 1040 81 DUP2 1041 52 MSTORE 1042 60 PUSH1 0x20 1044 01 ADD 1045 60 PUSH1 0x00 1047 20 SHA3 1048 60 PUSH1 0x00 104A 82 DUP3 104B 82 DUP3 104C 54 SLOAD 104D 03 SUB 104E 92 SWAP3 104F 50 POP 1050 50 POP 1051 81 DUP2 1052 90 SWAP1 1053 55 SSTORE 1054 50 POP 1055 60 PUSH1 0x01 1057 60 PUSH1 0x04 1059 60 PUSH1 0x00 105B 84 DUP5 105C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1071 16 AND 1072 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1087 16 AND 1088 81 DUP2 1089 52 MSTORE 108A 60 PUSH1 0x20 108C 01 ADD 108D 90 SWAP1 108E 81 DUP2 108F 52 MSTORE 1090 60 PUSH1 0x20 1092 01 ADD 1093 60 PUSH1 0x00 1095 20 SHA3 1096 60 PUSH1 0x00 1098 82 DUP3 1099 82 DUP3 109A 54 SLOAD 109B 01 ADD 109C 92 SWAP3 109D 50 POP 109E 50 POP 109F 81 DUP2 10A0 90 SWAP1 10A1 55 SSTORE 10A2 50 POP 10A3 81 DUP2 10A4 60 PUSH1 0x03 10A6 60 PUSH1 0x00 10A8 83 DUP4 10A9 81 DUP2 10AA 52 MSTORE 10AB 60 PUSH1 0x20 10AD 01 ADD 10AE 90 SWAP1 10AF 81 DUP2 10B0 52 MSTORE 10B1 60 PUSH1 0x20 10B3 01 ADD 10B4 60 PUSH1 0x00 10B6 20 SHA3 10B7 60 PUSH1 0x00 10B9 61 PUSH2 0x0100 10BC 0A EXP 10BD 81 DUP2 10BE 54 SLOAD 10BF 81 DUP2 10C0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10D5 02 MUL 10D6 19 NOT 10D7 16 AND 10D8 90 SWAP1 10D9 83 DUP4 10DA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10EF 16 AND 10F0 02 MUL 10F1 17 OR 10F2 90 SWAP1 10F3 55 SSTORE 10F4 50 POP 10F5 80 DUP1 10F6 82 DUP3 10F7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 110C 16 AND 110D 84 DUP5 110E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1123 16 AND 1124 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1145 60 PUSH1 0x40 1147 51 MLOAD 1148 60 PUSH1 0x40 114A 51 MLOAD 114B 80 DUP1 114C 91 SWAP2 114D 03 SUB 114E 90 SWAP1 114F A4 LOG4 1150 61 PUSH2 0x115c 1153 83 DUP4 1154 83 DUP4 1155 83 DUP4 1156 60 PUSH1 0x01 1158 61 PUSH2 0x15dc 115B 56 *JUMP // Stack delta = +5 // Outputs[18] // { // @0FD7 memory[0x00:0x20] = stack[-1] // @0FDD memory[0x20:0x40] = 0x05 // @1006 storage[keccak256(memory[0x00:0x40])] = ~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])] // @103B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1041 memory[0x20:0x40] = 0x04 // @1053 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] - 0x01 // @1089 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @108F memory[0x20:0x40] = 0x04 // @10A1 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + 0x01 // @10AA memory[0x00:0x20] = stack[-1] // @10B0 memory[0x20:0x40] = 0x03 // @10F3 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @114F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1]]); // @1150 stack[0] = 0x115c // @1153 stack[1] = stack[-3] // @1154 stack[2] = stack[-2] // @1155 stack[3] = stack[-1] // @1156 stack[4] = 0x01 // } // Block ends with call to 0x15dc, returns to 0x115C label_115C: // Incoming return from call to 0x15DC at 0x115B // Inputs[1] { @1160 stack[-4] } 115C 5B JUMPDEST 115D 50 POP 115E 50 POP 115F 50 POP 1160 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_1161: // Incoming call from 0x0816, returns to 0x0817 // Incoming call from 0x08EB, returns to 0x08EC // Incoming call from 0x0AB1, returns to 0x0AB2 // Incoming call from 0x0B6A, returns to 0x0B6B // Incoming call from 0x074B, returns to 0x074C 1161 5B JUMPDEST 1162 61 PUSH2 0x1169 1165 61 PUSH2 0x0c9b 1168 56 *JUMP // Stack delta = +1 // Outputs[1] { @1162 stack[0] = 0x1169 } // Block ends with call to 0x0c9b, returns to 0x1169 label_1169: // Incoming return from call to 0x0C9B at 0x1168 // Inputs[1] { @117F stack[-1] } 1169 5B JUMPDEST 116A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 117F 16 AND 1180 61 PUSH2 0x1187 1183 61 PUSH2 0x08f8 1186 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @117F stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1180 stack[0] = 0x1187 // } // Block ends with call to 0x08f8, returns to 0x1187 label_1187: // Incoming return from call to 0x08F8 at 0x1186 // Inputs[2] // { // @119D stack[-1] // @119E stack[-2] // } 1187 5B JUMPDEST 1188 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 119D 16 AND 119E 14 EQ 119F 61 PUSH2 0x11dd 11A2 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x11dd, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_11A3: // Incoming jump from 0x11A2, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @11A5 memory[0x40:0x60] } 11A3 60 PUSH1 0x40 11A5 51 MLOAD 11A6 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 11C7 81 DUP2 11C8 52 MSTORE 11C9 60 PUSH1 0x04 11CB 01 ADD 11CC 61 PUSH2 0x11d4 11CF 90 SWAP1 11D0 61 PUSH2 0x2890 11D3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @11C8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @11CF stack[0] = 0x11d4 // @11CF stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2890, returns to 0x11D4 label_11D4: // Incoming return from call to 0x2890 at 0x11D3 // Inputs[3] // { // @11D7 memory[0x40:0x60] // @11D9 stack[-1] // @11DC memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 11D4 5B JUMPDEST 11D5 60 PUSH1 0x40 11D7 51 MLOAD 11D8 80 DUP1 11D9 91 SWAP2 11DA 03 SUB 11DB 90 SWAP1 11DC FD *REVERT // Stack delta = -1 // Outputs[1] { @11DC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_11DD: // Incoming jump from 0x11A2, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @11DE stack[-1] } 11DD 5B JUMPDEST 11DE 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_11DF: // Incoming call from 0x0794, returns to 0x0795 // Incoming call from 0x155B, returns to 0x155C // Incoming call from 0x0A4D, returns to 0x0A4E // Inputs[4] // { // @11E6 stack[-1] // @11F4 memory[0x00:0x40] // @11F8 storage[keccak256(memory[0x00:0x40])] // @1218 stack[-2] // } 11DF 5B JUMPDEST 11E0 60 PUSH1 0x00 11E2 60 PUSH1 0x03 11E4 60 PUSH1 0x00 11E6 83 DUP4 11E7 81 DUP2 11E8 52 MSTORE 11E9 60 PUSH1 0x20 11EB 01 ADD 11EC 90 SWAP1 11ED 81 DUP2 11EE 52 MSTORE 11EF 60 PUSH1 0x20 11F1 01 ADD 11F2 60 PUSH1 0x00 11F4 20 SHA3 11F5 60 PUSH1 0x00 11F7 90 SWAP1 11F8 54 SLOAD 11F9 90 SWAP1 11FA 61 PUSH2 0x0100 11FD 0A EXP 11FE 90 SWAP1 11FF 04 DIV 1200 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1215 16 AND 1216 90 SWAP1 1217 50 POP 1218 91 SWAP2 1219 90 SWAP1 121A 50 POP 121B 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @11E8 memory[0x00:0x20] = stack[-1] // @11EE memory[0x20:0x40] = 0x03 // @1218 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-2] label_121C: // Incoming call from 0x0BE2, returns to 0x0BE3 // Incoming call from 0x08F5, returns to 0x08F6 // Inputs[7] // { // @1223 storage[0x00] // @1243 stack[-1] // @124C storage[0x00] // @12D4 memory[0x40:0x60] // @12D7 memory[0x40:0x60] // @12DC memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @12DF stack[-2] // } 121C 5B JUMPDEST 121D 60 PUSH1 0x00 121F 80 DUP1 1220 60 PUSH1 0x00 1222 90 SWAP1 1223 54 SLOAD 1224 90 SWAP1 1225 61 PUSH2 0x0100 1228 0A EXP 1229 90 SWAP1 122A 04 DIV 122B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1240 16 AND 1241 90 SWAP1 1242 50 POP 1243 81 DUP2 1244 60 PUSH1 0x00 1246 80 DUP1 1247 61 PUSH2 0x0100 124A 0A EXP 124B 81 DUP2 124C 54 SLOAD 124D 81 DUP2 124E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1263 02 MUL 1264 19 NOT 1265 16 AND 1266 90 SWAP1 1267 83 DUP4 1268 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 127D 16 AND 127E 02 MUL 127F 17 OR 1280 90 SWAP1 1281 55 SSTORE 1282 50 POP 1283 81 DUP2 1284 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1299 16 AND 129A 81 DUP2 129B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12B0 16 AND 12B1 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 12D2 60 PUSH1 0x40 12D4 51 MLOAD 12D5 60 PUSH1 0x40 12D7 51 MLOAD 12D8 80 DUP1 12D9 91 SWAP2 12DA 03 SUB 12DB 90 SWAP1 12DC A3 LOG3 12DD 50 POP 12DE 50 POP 12DF 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1281 storage[0x00] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x00]) // @12DC log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-2] label_12E0: // Incoming jump from 0x09C4 // Inputs[2] // { // @12E1 stack[-2] // @12F8 stack[-3] // } 12E0 5B JUMPDEST 12E1 81 DUP2 12E2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12F7 16 AND 12F8 83 DUP4 12F9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 130E 16 AND 130F 03 SUB 1310 61 PUSH2 0x134e 1313 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x134e, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) - (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) label_1314: // Incoming jump from 0x1313, if not (0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) - (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) // Inputs[1] { @1316 memory[0x40:0x60] } 1314 60 PUSH1 0x40 1316 51 MLOAD 1317 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1338 81 DUP2 1339 52 MSTORE 133A 60 PUSH1 0x04 133C 01 ADD 133D 61 PUSH2 0x1345 1340 90 SWAP1 1341 61 PUSH2 0x28fc 1344 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1339 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1340 stack[0] = 0x1345 // @1340 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x28fc, returns to 0x1345 label_1345: // Incoming return from call to 0x28FC at 0x1344 // Inputs[3] // { // @1348 memory[0x40:0x60] // @134A stack[-1] // @134D memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1345 5B JUMPDEST 1346 60 PUSH1 0x40 1348 51 MLOAD 1349 80 DUP1 134A 91 SWAP2 134B 03 SUB 134C 90 SWAP1 134D FD *REVERT // Stack delta = -1 // Outputs[1] { @134D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_134E: // Incoming jump from 0x1313, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) - (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) // Inputs[7] // { // @134F stack[-1] // @1354 stack[-3] // @138E memory[0x00:0x40] // @1391 stack[-2] // @13CB memory[0x00:0x40] // @13D3 storage[keccak256(memory[0x00:0x40])] // @1435 memory[0x40:0x60] // } 134E 5B JUMPDEST 134F 80 DUP1 1350 60 PUSH1 0x06 1352 60 PUSH1 0x00 1354 85 DUP6 1355 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 136A 16 AND 136B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1380 16 AND 1381 81 DUP2 1382 52 MSTORE 1383 60 PUSH1 0x20 1385 01 ADD 1386 90 SWAP1 1387 81 DUP2 1388 52 MSTORE 1389 60 PUSH1 0x20 138B 01 ADD 138C 60 PUSH1 0x00 138E 20 SHA3 138F 60 PUSH1 0x00 1391 84 DUP5 1392 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13A7 16 AND 13A8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13BD 16 AND 13BE 81 DUP2 13BF 52 MSTORE 13C0 60 PUSH1 0x20 13C2 01 ADD 13C3 90 SWAP1 13C4 81 DUP2 13C5 52 MSTORE 13C6 60 PUSH1 0x20 13C8 01 ADD 13C9 60 PUSH1 0x00 13CB 20 SHA3 13CC 60 PUSH1 0x00 13CE 61 PUSH2 0x0100 13D1 0A EXP 13D2 81 DUP2 13D3 54 SLOAD 13D4 81 DUP2 13D5 60 PUSH1 0xff 13D7 02 MUL 13D8 19 NOT 13D9 16 AND 13DA 90 SWAP1 13DB 83 DUP4 13DC 15 ISZERO 13DD 15 ISZERO 13DE 02 MUL 13DF 17 OR 13E0 90 SWAP1 13E1 55 SSTORE 13E2 50 POP 13E3 81 DUP2 13E4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13F9 16 AND 13FA 83 DUP4 13FB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1410 16 AND 1411 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1432 83 DUP4 1433 60 PUSH1 0x40 1435 51 MLOAD 1436 61 PUSH2 0x143f 1439 91 SWAP2 143A 90 SWAP1 143B 61 PUSH2 0x1a5d 143E 56 *JUMP // Stack delta = +6 // Outputs[11] // { // @1382 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1388 memory[0x20:0x40] = 0x06 // @13BF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @13C5 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @13E1 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @13F9 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1410 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1411 stack[2] = 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 // @1439 stack[3] = 0x143f // @143A stack[4] = stack[-1] // @143A stack[5] = memory[0x40:0x60] // } // Block ends with call to 0x1a5d, returns to 0x143F label_143F: // Incoming return from call to 0x1A5D at 0x143E // Inputs[7] // { // @1442 memory[0x40:0x60] // @1444 stack[-1] // @1447 stack[-2] // @1447 stack[-3] // @1447 stack[-4] // @1447 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @144B stack[-8] // } 143F 5B JUMPDEST 1440 60 PUSH1 0x40 1442 51 MLOAD 1443 80 DUP1 1444 91 SWAP2 1445 03 SUB 1446 90 SWAP1 1447 A3 LOG3 1448 50 POP 1449 50 POP 144A 50 POP 144B 56 *JUMP // Stack delta = -8 // Outputs[1] { @1447 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); } // Block ends with unconditional jump to stack[-8] label_144C: // Incoming call from 0x0A24, returns to 0x0A25 // Inputs[3] // { // @1450 stack[-4] // @1451 stack[-3] // @1452 stack[-2] // } 144C 5B JUMPDEST 144D 61 PUSH2 0x1457 1450 84 DUP5 1451 84 DUP5 1452 84 DUP5 1453 61 PUSH2 0x0e68 1456 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @144D stack[0] = 0x1457 // @1450 stack[1] = stack[-4] // @1451 stack[2] = stack[-3] // @1452 stack[3] = stack[-2] // } // Block ends with call to 0x0e68, returns to 0x1457 label_1457: // Incoming return from call to 0x0E68 at 0x1456 // Inputs[4] // { // @145B stack[-4] // @145C stack[-3] // @145D stack[-2] // @145E stack[-1] // } 1457 5B JUMPDEST 1458 61 PUSH2 0x1463 145B 84 DUP5 145C 84 DUP5 145D 84 DUP5 145E 84 DUP5 145F 61 PUSH2 0x15e2 1462 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1458 stack[0] = 0x1463 // @145B stack[1] = stack[-4] // @145C stack[2] = stack[-3] // @145D stack[3] = stack[-2] // @145E stack[4] = stack[-1] // } // Block ends with call to 0x15e2, returns to 0x1463 label_1463: // Incoming return from call to 0x15E2 at 0x1462 // Inputs[1] { @1467 stack[-1] } 1463 5B JUMPDEST 1464 61 PUSH2 0x14a2 1467 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x14a2, if stack[-1] label_1468: // Incoming jump from 0x1467, if not stack[-1] // Inputs[1] { @146A memory[0x40:0x60] } 1468 60 PUSH1 0x40 146A 51 MLOAD 146B 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 148C 81 DUP2 148D 52 MSTORE 148E 60 PUSH1 0x04 1490 01 ADD 1491 61 PUSH2 0x1499 1494 90 SWAP1 1495 61 PUSH2 0x298e 1498 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @148D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1494 stack[0] = 0x1499 // @1494 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x298e, returns to 0x1499 label_1499: // Incoming return from call to 0x298E at 0x1498 // Inputs[3] // { // @149C memory[0x40:0x60] // @149E stack[-1] // @14A1 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1499 5B JUMPDEST 149A 60 PUSH1 0x40 149C 51 MLOAD 149D 80 DUP1 149E 91 SWAP2 149F 03 SUB 14A0 90 SWAP1 14A1 FD *REVERT // Stack delta = -1 // Outputs[1] { @14A1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_14A2: // Incoming jump from 0x1467, if stack[-1] // Inputs[1] { @14A7 stack[-5] } 14A2 5B JUMPDEST 14A3 50 POP 14A4 50 POP 14A5 50 POP 14A6 50 POP 14A7 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_14A8: // Incoming call from 0x0AA2, returns to 0x0AA3 // Inputs[1] { @14AE storage[0x08] } 14A8 5B JUMPDEST 14A9 60 PUSH1 0x60 14AB 60 PUSH1 0x08 14AD 80 DUP1 14AE 54 SLOAD 14AF 61 PUSH2 0x14b7 14B2 90 SWAP1 14B3 61 PUSH2 0x203f 14B6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @14A9 stack[0] = 0x60 // @14AB stack[1] = 0x08 // @14B2 stack[2] = 0x14b7 // @14B2 stack[3] = storage[0x08] // } // Block ends with call to 0x203f, returns to 0x14B7 label_14B7: // Incoming return from call to 0x203F at 0x14B6 // Inputs[4] // { // @14B8 stack[-1] // @14C7 memory[0x40:0x60] // @14CF stack[-2] // @14DA storage[stack[-2]] // } 14B7 5B JUMPDEST 14B8 80 DUP1 14B9 60 PUSH1 0x1f 14BB 01 ADD 14BC 60 PUSH1 0x20 14BE 80 DUP1 14BF 91 SWAP2 14C0 04 DIV 14C1 02 MUL 14C2 60 PUSH1 0x20 14C4 01 ADD 14C5 60 PUSH1 0x40 14C7 51 MLOAD 14C8 90 SWAP1 14C9 81 DUP2 14CA 01 ADD 14CB 60 PUSH1 0x40 14CD 52 MSTORE 14CE 80 DUP1 14CF 92 SWAP3 14D0 91 SWAP2 14D1 90 SWAP1 14D2 81 DUP2 14D3 81 DUP2 14D4 52 MSTORE 14D5 60 PUSH1 0x20 14D7 01 ADD 14D8 82 DUP3 14D9 80 DUP1 14DA 54 SLOAD 14DB 61 PUSH2 0x14e3 14DE 90 SWAP1 14DF 61 PUSH2 0x203f 14E2 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @14CD memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @14CF stack[-2] = memory[0x40:0x60] // @14D0 stack[-1] = stack[-2] // @14D1 stack[0] = stack[-1] // @14D4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @14D7 stack[1] = 0x20 + memory[0x40:0x60] // @14D8 stack[2] = stack[-2] // @14DE stack[4] = storage[stack[-2]] // @14DE stack[3] = 0x14e3 // } // Block ends with call to 0x203f, returns to 0x14E3 label_14E3: // Incoming return from call to 0x203F at 0x14E2 // Inputs[1] { @14E4 stack[-1] } 14E3 5B JUMPDEST 14E4 80 DUP1 14E5 15 ISZERO 14E6 61 PUSH2 0x1530 14E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1530, if !stack[-1] label_14EA: // Incoming jump from 0x14E9, if not !stack[-1] // Inputs[1] { @14EA stack[-1] } 14EA 80 DUP1 14EB 60 PUSH1 0x1f 14ED 10 LT 14EE 61 PUSH2 0x1505 14F1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1505, if 0x1f < stack[-1] label_14F2: // Incoming jump from 0x14F1, if not 0x1f < stack[-1] // Inputs[4] // { // @14F6 stack[-2] // @14F7 storage[stack[-2]] // @14FA stack[-3] // @14FC stack[-1] // } 14F2 61 PUSH2 0x0100 14F5 80 DUP1 14F6 83 DUP4 14F7 54 SLOAD 14F8 04 DIV 14F9 02 MUL 14FA 83 DUP4 14FB 52 MSTORE 14FC 91 SWAP2 14FD 60 PUSH1 0x20 14FF 01 ADD 1500 91 SWAP2 1501 61 PUSH2 0x1530 1504 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @14FB memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1500 stack[-1] = stack[-1] // @1500 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1530 label_1505: // Incoming jump from 0x14F1, if 0x1f < stack[-1] // Inputs[5] // { // @1506 stack[-3] // @1507 stack[-1] // @1509 stack[-2] // @1511 memory[0x00:0x20] // @1515 storage[keccak256(memory[0x00:0x20])] // } 1505 5B JUMPDEST 1506 82 DUP3 1507 01 ADD 1508 91 SWAP2 1509 90 SWAP1 150A 60 PUSH1 0x00 150C 52 MSTORE 150D 60 PUSH1 0x20 150F 60 PUSH1 0x00 1511 20 SHA3 1512 90 SWAP1 1513 5B JUMPDEST 1514 81 DUP2 1515 54 SLOAD 1516 81 DUP2 1517 52 MSTORE 1518 90 SWAP1 1519 60 PUSH1 0x01 151B 01 ADD 151C 90 SWAP1 151D 60 PUSH1 0x20 151F 01 ADD 1520 80 DUP1 1521 83 DUP4 1522 11 GT 1523 61 PUSH2 0x1513 1526 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1508 stack[-3] = stack[-3] + stack[-1] // @150C memory[0x00:0x20] = stack[-2] // @1517 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @151C stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @151F stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1513, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1527: // Incoming jump from 0x1526, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x1526, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @1527 stack[-3] // @1528 stack[-1] // } 1527 82 DUP3 1528 90 SWAP1 1529 03 SUB 152A 60 PUSH1 0x1f 152C 16 AND 152D 82 DUP3 152E 01 ADD 152F 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @152F stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @152F stack[-1] = stack[-3] // } // Block continues label_1530: // Incoming jump from 0x1504 // Incoming jump from 0x152F // Incoming jump from 0x14E9, if !stack[-1] // Inputs[3] // { // @1536 stack[-7] // @1536 stack[-6] // @1538 stack[-8] // } 1530 5B JUMPDEST 1531 50 POP 1532 50 POP 1533 50 POP 1534 50 POP 1535 50 POP 1536 90 SWAP1 1537 50 POP 1538 90 SWAP1 1539 56 *JUMP // Stack delta = -7 // Outputs[1] { @1538 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_153A: // Incoming call from 0x1837, returns to 0x1838 // Incoming call from 0x0C58, returns to 0x0C59 // Incoming call from 0x17E0, returns to 0x17E1 // Inputs[1] { @1557 stack[-1] } 153A 5B JUMPDEST 153B 60 PUSH1 0x00 153D 80 DUP1 153E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1553 16 AND 1554 61 PUSH2 0x155c 1557 83 DUP4 1558 61 PUSH2 0x11df 155B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @153B stack[0] = 0x00 // @1553 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & 0x00 // @1554 stack[2] = 0x155c // @1557 stack[3] = stack[-1] // } // Block ends with call to 0x11df, returns to 0x155C label_155C: // Incoming return from call to 0x11DF at 0x155B // Inputs[5] // { // @1572 stack[-1] // @1573 stack[-2] // @1575 stack[-3] // @1577 stack[-5] // @1578 stack[-4] // } 155C 5B JUMPDEST 155D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1572 16 AND 1573 14 EQ 1574 15 ISZERO 1575 90 SWAP1 1576 50 POP 1577 91 SWAP2 1578 90 SWAP1 1579 50 POP 157A 56 *JUMP // Stack delta = -4 // Outputs[1] { @1577 stack[-5] = !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2]) } // Block ends with unconditional jump to stack[-5] label_157B: // Incoming call from 0x0DC4, returns to 0x0DC5 // Inputs[2] // { // @157F stack[-3] // @1580 stack[-2] // } 157B 5B JUMPDEST 157C 61 PUSH2 0x1585 157F 83 DUP4 1580 83 DUP4 1581 61 PUSH2 0x1769 1584 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @157C stack[0] = 0x1585 // @157F stack[1] = stack[-3] // @1580 stack[2] = stack[-2] // } // Block ends with call to 0x1769, returns to 0x1585 label_1585: // Incoming return from call to 0x1769 at 0x1584 // Inputs[3] // { // @158B stack[-3] // @158C stack[-2] // @158D stack[-1] // } 1585 5B JUMPDEST 1586 61 PUSH2 0x1592 1589 60 PUSH1 0x00 158B 84 DUP5 158C 84 DUP5 158D 84 DUP5 158E 61 PUSH2 0x15e2 1591 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1586 stack[0] = 0x1592 // @1589 stack[1] = 0x00 // @158B stack[2] = stack[-3] // @158C stack[3] = stack[-2] // @158D stack[4] = stack[-1] // } // Block ends with call to 0x15e2, returns to 0x1592 label_1592: // Incoming return from call to 0x15E2 at 0x1591 // Inputs[1] { @1596 stack[-1] } 1592 5B JUMPDEST 1593 61 PUSH2 0x15d1 1596 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x15d1, if stack[-1] label_1597: // Incoming jump from 0x1596, if not stack[-1] // Inputs[1] { @1599 memory[0x40:0x60] } 1597 60 PUSH1 0x40 1599 51 MLOAD 159A 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 15BB 81 DUP2 15BC 52 MSTORE 15BD 60 PUSH1 0x04 15BF 01 ADD 15C0 61 PUSH2 0x15c8 15C3 90 SWAP1 15C4 61 PUSH2 0x298e 15C7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @15BC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @15C3 stack[0] = 0x15c8 // @15C3 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x298e, returns to 0x15C8 label_15C8: // Incoming return from call to 0x298E at 0x15C7 // Inputs[3] // { // @15CB memory[0x40:0x60] // @15CD stack[-1] // @15D0 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 15C8 5B JUMPDEST 15C9 60 PUSH1 0x40 15CB 51 MLOAD 15CC 80 DUP1 15CD 91 SWAP2 15CE 03 SUB 15CF 90 SWAP1 15D0 FD *REVERT // Stack delta = -1 // Outputs[1] { @15D0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_15D1: // Incoming jump from 0x1596, if stack[-1] // Inputs[1] { @15D5 stack[-4] } 15D1 5B JUMPDEST 15D2 50 POP 15D3 50 POP 15D4 50 POP 15D5 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_15D6: // Incoming call from 0x182E, returns to 0x182F // Incoming call from 0x0F59, returns to 0x0F5A // Inputs[1] { @15DB stack[-5] } 15D6 5B JUMPDEST 15D7 50 POP 15D8 50 POP 15D9 50 POP 15DA 50 POP 15DB 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_15DC: // Incoming call from 0x115B, returns to 0x115C // Incoming call from 0x1981, returns to 0x1982 // Inputs[1] { @15E1 stack[-5] } 15DC 5B JUMPDEST 15DD 50 POP 15DE 50 POP 15DF 50 POP 15E0 50 POP 15E1 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_15E2: // Incoming call from 0x1591, returns to 0x1592 // Incoming call from 0x1462, returns to 0x1463 // Inputs[1] { @15E8 stack[-3] } 15E2 5B JUMPDEST 15E3 60 PUSH1 0x00 15E5 61 PUSH2 0x1603 15E8 84 DUP5 15E9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15FE 16 AND 15FF 61 PUSH2 0x1986 1602 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @15E3 stack[0] = 0x00 // @15E5 stack[1] = 0x1603 // @15FE stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // } // Block ends with call to 0x1986, returns to 0x1603 label_1603: // Incoming return from call to 0x1986 at 0x1602 // Inputs[1] { @1604 stack[-1] } 1603 5B JUMPDEST 1604 15 ISZERO 1605 61 PUSH2 0x175c 1608 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x175c, if !stack[-1] label_1609: // Incoming jump from 0x1608, if not !stack[-1] // Inputs[1] { @1609 stack[-4] } 1609 83 DUP4 160A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 161F 16 AND 1620 63 PUSH4 0x150b7a02 1625 61 PUSH2 0x162c 1628 61 PUSH2 0x0c9b 162B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @161F stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @1620 stack[1] = 0x150b7a02 // @1625 stack[2] = 0x162c // } // Block ends with call to 0x0c9b, returns to 0x162C label_162C: // Incoming return from call to 0x0C9B at 0x162B // Inputs[6] // { // @162D stack[-8] // @162E stack[-6] // @162F stack[-5] // @1632 memory[0x40:0x60] // @1633 stack[-2] // @1645 stack[-1] // } 162C 5B JUMPDEST 162D 87 DUP8 162E 86 DUP7 162F 86 DUP7 1630 60 PUSH1 0x40 1632 51 MLOAD 1633 85 DUP6 1634 63 PUSH4 0xffffffff 1639 16 AND 163A 60 PUSH1 0xe0 163C 1B SHL 163D 81 DUP2 163E 52 MSTORE 163F 60 PUSH1 0x04 1641 01 ADD 1642 61 PUSH2 0x164e 1645 94 SWAP5 1646 93 SWAP4 1647 92 SWAP3 1648 91 SWAP2 1649 90 SWAP1 164A 61 PUSH2 0x2a03 164D 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @163E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-2]) << 0xe0 // @1645 stack[-1] = 0x164e // @1646 stack[0] = stack[-1] // @1647 stack[1] = stack[-8] // @1648 stack[2] = stack[-6] // @1649 stack[4] = 0x04 + memory[0x40:0x60] // @1649 stack[3] = stack[-5] // } // Block ends with call to 0x2a03, returns to 0x164E label_164E: // Incoming return from call to 0x2A03 at 0x164D // Inputs[6] // { // @1653 memory[0x40:0x60] // @1655 stack[-1] // @165A stack[-3] // @165B msg.gas // @165C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @165C address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } 164E 5B JUMPDEST 164F 60 PUSH1 0x20 1651 60 PUSH1 0x40 1653 51 MLOAD 1654 80 DUP1 1655 83 DUP4 1656 03 SUB 1657 81 DUP2 1658 60 PUSH1 0x00 165A 87 DUP8 165B 5A GAS 165C F1 CALL 165D 92 SWAP3 165E 50 POP 165F 50 POP 1660 50 POP 1661 80 DUP1 1662 15 ISZERO 1663 61 PUSH2 0x168a 1666 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @165C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @165D stack[-3] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x168a, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) label_1667: // Incoming jump from 0x1666, if not !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[2] // { // @166A memory[0x40:0x60] // @166B returndata.length // } 1667 50 POP 1668 60 PUSH1 0x40 166A 51 MLOAD 166B 3D RETURNDATASIZE 166C 60 PUSH1 0x1f 166E 19 NOT 166F 60 PUSH1 0x1f 1671 82 DUP3 1672 01 ADD 1673 16 AND 1674 82 DUP3 1675 01 ADD 1676 80 DUP1 1677 60 PUSH1 0x40 1679 52 MSTORE 167A 50 POP 167B 81 DUP2 167C 01 ADD 167D 90 SWAP1 167E 61 PUSH2 0x1687 1681 91 SWAP2 1682 90 SWAP1 1683 61 PUSH2 0x2a64 1686 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1679 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @1681 stack[-1] = 0x1687 // @1682 stack[1] = memory[0x40:0x60] // @1682 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x2a64, returns to 0x1687 label_1687: // Incoming return from call to 0x2A64 at 0x1686 1687 5B JUMPDEST 1688 60 PUSH1 0x01 // Stack delta = +1 // Outputs[1] { @1688 stack[0] = 0x01 } // Block continues label_168A: // Incoming jump from 0x1666, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Incoming jump from 0x1688 // Inputs[1] { @168E stack[-1] } 168A 5B JUMPDEST 168B 61 PUSH2 0x170c 168E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x170c, if stack[-1] label_168F: // Incoming jump from 0x168E, if not stack[-1] // Inputs[1] { @168F returndata.length } 168F 3D RETURNDATASIZE 1690 80 DUP1 1691 60 PUSH1 0x00 1693 81 DUP2 1694 14 EQ 1695 61 PUSH2 0x16ba 1698 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @168F stack[0] = returndata.length // @1690 stack[1] = returndata.length // } // Block ends with conditional jump to 0x16ba, if returndata.length == 0x00 label_1699: // Incoming jump from 0x1698, if not returndata.length == 0x00 // Inputs[6] // { // @169B memory[0x40:0x60] // @169C stack[-2] // @16A3 returndata.length // @16AB returndata.length // @16AE returndata.length // @16B5 returndata[0x00:0x00 + returndata.length] // } 1699 60 PUSH1 0x40 169B 51 MLOAD 169C 91 SWAP2 169D 50 POP 169E 60 PUSH1 0x1f 16A0 19 NOT 16A1 60 PUSH1 0x3f 16A3 3D RETURNDATASIZE 16A4 01 ADD 16A5 16 AND 16A6 82 DUP3 16A7 01 ADD 16A8 60 PUSH1 0x40 16AA 52 MSTORE 16AB 3D RETURNDATASIZE 16AC 82 DUP3 16AD 52 MSTORE 16AE 3D RETURNDATASIZE 16AF 60 PUSH1 0x00 16B1 60 PUSH1 0x20 16B3 84 DUP5 16B4 01 ADD 16B5 3E RETURNDATACOPY 16B6 61 PUSH2 0x16bf 16B9 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @169C stack[-2] = memory[0x40:0x60] // @16AA memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @16AD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @16B5 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x16bf label_16BA: // Incoming jump from 0x1698, if returndata.length == 0x00 // Inputs[2] // { // @16BD stack[-2] // @16C4 memory[0x60:0x80] // } 16BA 5B JUMPDEST 16BB 60 PUSH1 0x60 16BD 91 SWAP2 16BE 50 POP 16BF 5B JUMPDEST 16C0 50 POP 16C1 60 PUSH1 0x00 16C3 81 DUP2 16C4 51 MLOAD 16C5 03 SUB 16C6 61 PUSH2 0x1704 16C9 57 *JUMPI // Stack delta = -1 // Outputs[1] { @16BD stack[-2] = 0x60 } // Block ends with conditional jump to 0x1704, if memory[0x60:0x80] - 0x00 label_16CA: // Incoming jump from 0x16C9, if not memory[stack[-2]:stack[-2] + 0x20] - 0x00 // Incoming jump from 0x16C9, if not memory[0x60:0x80] - 0x00 // Inputs[1] { @16CC memory[0x40:0x60] } 16CA 60 PUSH1 0x40 16CC 51 MLOAD 16CD 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 16EE 81 DUP2 16EF 52 MSTORE 16F0 60 PUSH1 0x04 16F2 01 ADD 16F3 61 PUSH2 0x16fb 16F6 90 SWAP1 16F7 61 PUSH2 0x298e 16FA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @16EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @16F6 stack[0] = 0x16fb // @16F6 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x298e, returns to 0x16FB label_16FB: // Incoming return from call to 0x298E at 0x16FA // Inputs[3] // { // @16FE memory[0x40:0x60] // @1700 stack[-1] // @1703 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 16FB 5B JUMPDEST 16FC 60 PUSH1 0x40 16FE 51 MLOAD 16FF 80 DUP1 1700 91 SWAP2 1701 03 SUB 1702 90 SWAP1 1703 FD *REVERT // Stack delta = -1 // Outputs[1] { @1703 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1704: // Incoming jump from 0x16C9, if memory[stack[-2]:stack[-2] + 0x20] - 0x00 // Incoming jump from 0x16C9, if memory[0x60:0x80] - 0x00 // Inputs[3] // { // @1705 stack[-1] // @1706 memory[stack[-1]:stack[-1] + 0x20] // @170B memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 1704 5B JUMPDEST 1705 80 DUP1 1706 51 MLOAD 1707 81 DUP2 1708 60 PUSH1 0x20 170A 01 ADD 170B FD *REVERT // Stack delta = +0 // Outputs[1] { @170B revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_170C: // Incoming jump from 0x168E, if stack[-1] // Inputs[2] // { // @1734 stack[-1] // @1755 stack[-2] // } 170C 5B JUMPDEST 170D 63 PUSH4 0x150b7a02 1712 60 PUSH1 0xe0 1714 1B SHL 1715 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1732 19 NOT 1733 16 AND 1734 81 DUP2 1735 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1752 19 NOT 1753 16 AND 1754 14 EQ 1755 91 SWAP2 1756 50 POP 1757 50 POP 1758 61 PUSH2 0x1761 175B 56 *JUMP // Stack delta = -1 // Outputs[1] { @1755 stack[-2] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0x150b7a02 << 0xe0) } // Block ends with unconditional jump to 0x1761 label_175C: // Incoming jump from 0x1608, if !stack[-1] // Inputs[3] // { // @175F stack[-1] // @1762 stack[-6] // @1763 stack[-5] // } 175C 5B JUMPDEST 175D 60 PUSH1 0x01 175F 90 SWAP1 1760 50 POP 1761 5B JUMPDEST 1762 94 SWAP5 1763 93 SWAP4 1764 50 POP 1765 50 POP 1766 50 POP 1767 50 POP 1768 56 *JUMP // Stack delta = -5 // Outputs[1] { @1762 stack[-6] = 0x01 } // Block ends with unconditional jump to stack[-6] label_1769: // Incoming call from 0x1584, returns to 0x1585 // Inputs[1] { @1782 stack[-2] } 1769 5B JUMPDEST 176A 60 PUSH1 0x00 176C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1781 16 AND 1782 82 DUP3 1783 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1798 16 AND 1799 03 SUB 179A 61 PUSH2 0x17d8 179D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x17d8, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_179E: // Incoming jump from 0x179D, if not (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @17A0 memory[0x40:0x60] } 179E 60 PUSH1 0x40 17A0 51 MLOAD 17A1 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 17C2 81 DUP2 17C3 52 MSTORE 17C4 60 PUSH1 0x04 17C6 01 ADD 17C7 61 PUSH2 0x17cf 17CA 90 SWAP1 17CB 61 PUSH2 0x2add 17CE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @17C3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @17CA stack[0] = 0x17cf // @17CA stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2add, returns to 0x17CF label_17CF: // Incoming return from call to 0x2ADD at 0x17CE // Inputs[3] // { // @17D2 memory[0x40:0x60] // @17D4 stack[-1] // @17D7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 17CF 5B JUMPDEST 17D0 60 PUSH1 0x40 17D2 51 MLOAD 17D3 80 DUP1 17D4 91 SWAP2 17D5 03 SUB 17D6 90 SWAP1 17D7 FD *REVERT // Stack delta = -1 // Outputs[1] { @17D7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_17D8: // Incoming jump from 0x179D, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @17DC stack[-1] } 17D8 5B JUMPDEST 17D9 61 PUSH2 0x17e1 17DC 81 DUP2 17DD 61 PUSH2 0x153a 17E0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @17D9 stack[0] = 0x17e1 // @17DC stack[1] = stack[-1] // } // Block ends with call to 0x153a, returns to 0x17E1 label_17E1: // Incoming return from call to 0x153A at 0x17E0 // Inputs[1] { @17E2 stack[-1] } 17E1 5B JUMPDEST 17E2 15 ISZERO 17E3 61 PUSH2 0x1821 17E6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1821, if !stack[-1] label_17E7: // Incoming jump from 0x17E6, if not !stack[-1] // Inputs[1] { @17E9 memory[0x40:0x60] } 17E7 60 PUSH1 0x40 17E9 51 MLOAD 17EA 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 180B 81 DUP2 180C 52 MSTORE 180D 60 PUSH1 0x04 180F 01 ADD 1810 61 PUSH2 0x1818 1813 90 SWAP1 1814 61 PUSH2 0x2b49 1817 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @180C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1813 stack[0] = 0x1818 // @1813 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2b49, returns to 0x1818 label_1818: // Incoming return from call to 0x2B49 at 0x1817 // Inputs[3] // { // @181B memory[0x40:0x60] // @181D stack[-1] // @1820 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1818 5B JUMPDEST 1819 60 PUSH1 0x40 181B 51 MLOAD 181C 80 DUP1 181D 91 SWAP2 181E 03 SUB 181F 90 SWAP1 1820 FD *REVERT // Stack delta = -1 // Outputs[1] { @1820 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1821: // Incoming jump from 0x17E6, if !stack[-1] // Inputs[2] // { // @1827 stack[-2] // @1828 stack[-1] // } 1821 5B JUMPDEST 1822 61 PUSH2 0x182f 1825 60 PUSH1 0x00 1827 83 DUP4 1828 83 DUP4 1829 60 PUSH1 0x01 182B 61 PUSH2 0x15d6 182E 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1822 stack[0] = 0x182f // @1825 stack[1] = 0x00 // @1827 stack[2] = stack[-2] // @1828 stack[3] = stack[-1] // @1829 stack[4] = 0x01 // } // Block ends with call to 0x15d6, returns to 0x182F label_182F: // Incoming return from call to 0x15D6 at 0x182E // Inputs[1] { @1833 stack[-1] } 182F 5B JUMPDEST 1830 61 PUSH2 0x1838 1833 81 DUP2 1834 61 PUSH2 0x153a 1837 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1830 stack[0] = 0x1838 // @1833 stack[1] = stack[-1] // } // Block ends with call to 0x153a, returns to 0x1838 label_1838: // Incoming return from call to 0x153A at 0x1837 // Inputs[1] { @1839 stack[-1] } 1838 5B JUMPDEST 1839 15 ISZERO 183A 61 PUSH2 0x1878 183D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1878, if !stack[-1] label_183E: // Incoming jump from 0x183D, if not !stack[-1] // Inputs[1] { @1840 memory[0x40:0x60] } 183E 60 PUSH1 0x40 1840 51 MLOAD 1841 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1862 81 DUP2 1863 52 MSTORE 1864 60 PUSH1 0x04 1866 01 ADD 1867 61 PUSH2 0x186f 186A 90 SWAP1 186B 61 PUSH2 0x2b49 186E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1863 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @186A stack[0] = 0x186f // @186A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2b49, returns to 0x186F label_186F: // Incoming return from call to 0x2B49 at 0x186E // Inputs[3] // { // @1872 memory[0x40:0x60] // @1874 stack[-1] // @1877 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 186F 5B JUMPDEST 1870 60 PUSH1 0x40 1872 51 MLOAD 1873 80 DUP1 1874 91 SWAP2 1875 03 SUB 1876 90 SWAP1 1877 FD *REVERT // Stack delta = -1 // Outputs[1] { @1877 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_1878: // Incoming jump from 0x183D, if !stack[-1] // Inputs[9] // { // @187F stack[-2] // @18B9 memory[0x00:0x40] // @18BE storage[keccak256(memory[0x00:0x40])] // @18CC stack[-1] // @18DA memory[0x00:0x40] // @18E2 storage[keccak256(memory[0x00:0x40])] // @196C memory[0x40:0x60] // @196F memory[0x40:0x60] // @1974 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // } 1878 5B JUMPDEST 1879 60 PUSH1 0x01 187B 60 PUSH1 0x04 187D 60 PUSH1 0x00 187F 84 DUP5 1880 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1895 16 AND 1896 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18AB 16 AND 18AC 81 DUP2 18AD 52 MSTORE 18AE 60 PUSH1 0x20 18B0 01 ADD 18B1 90 SWAP1 18B2 81 DUP2 18B3 52 MSTORE 18B4 60 PUSH1 0x20 18B6 01 ADD 18B7 60 PUSH1 0x00 18B9 20 SHA3 18BA 60 PUSH1 0x00 18BC 82 DUP3 18BD 82 DUP3 18BE 54 SLOAD 18BF 01 ADD 18C0 92 SWAP3 18C1 50 POP 18C2 50 POP 18C3 81 DUP2 18C4 90 SWAP1 18C5 55 SSTORE 18C6 50 POP 18C7 81 DUP2 18C8 60 PUSH1 0x03 18CA 60 PUSH1 0x00 18CC 83 DUP4 18CD 81 DUP2 18CE 52 MSTORE 18CF 60 PUSH1 0x20 18D1 01 ADD 18D2 90 SWAP1 18D3 81 DUP2 18D4 52 MSTORE 18D5 60 PUSH1 0x20 18D7 01 ADD 18D8 60 PUSH1 0x00 18DA 20 SHA3 18DB 60 PUSH1 0x00 18DD 61 PUSH2 0x0100 18E0 0A EXP 18E1 81 DUP2 18E2 54 SLOAD 18E3 81 DUP2 18E4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18F9 02 MUL 18FA 19 NOT 18FB 16 AND 18FC 90 SWAP1 18FD 83 DUP4 18FE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1913 16 AND 1914 02 MUL 1915 17 OR 1916 90 SWAP1 1917 55 SSTORE 1918 50 POP 1919 80 DUP1 191A 82 DUP3 191B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1930 16 AND 1931 60 PUSH1 0x00 1933 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1948 16 AND 1949 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 196A 60 PUSH1 0x40 196C 51 MLOAD 196D 60 PUSH1 0x40 196F 51 MLOAD 1970 80 DUP1 1971 91 SWAP2 1972 03 SUB 1973 90 SWAP1 1974 A4 LOG4 1975 61 PUSH2 0x1982 1978 60 PUSH1 0x00 197A 83 DUP4 197B 83 DUP4 197C 60 PUSH1 0x01 197E 61 PUSH2 0x15dc 1981 56 *JUMP // Stack delta = +5 // Outputs[12] // { // @18AD memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @18B3 memory[0x20:0x40] = 0x04 // @18C5 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + 0x01 // @18CE memory[0x00:0x20] = stack[-1] // @18D4 memory[0x20:0x40] = 0x03 // @1917 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @1974 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0xffffffffffffffffffffffffffffffffffffffff & 0x00, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1]]); // @1975 stack[0] = 0x1982 // @1978 stack[1] = 0x00 // @197A stack[2] = stack[-2] // @197B stack[3] = stack[-1] // @197C stack[4] = 0x01 // } // Block ends with call to 0x15dc, returns to 0x1982 label_1982: // Incoming return from call to 0x15DC at 0x1981 // Inputs[1] { @1985 stack[-3] } 1982 5B JUMPDEST 1983 50 POP 1984 50 POP 1985 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_1986: // Incoming call from 0x1602, returns to 0x1603 // Inputs[3] // { // @198A stack[-1] // @19A1 address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length // @19A5 stack[-2] // } 1986 5B JUMPDEST 1987 60 PUSH1 0x00 1989 80 DUP1 198A 82 DUP3 198B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19A0 16 AND 19A1 3B EXTCODESIZE 19A2 11 GT 19A3 90 SWAP1 19A4 50 POP 19A5 91 SWAP2 19A6 90 SWAP1 19A7 50 POP 19A8 56 *JUMP // Stack delta = -1 // Outputs[1] { @19A5 stack[-2] = address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length > 0x00 } // Block ends with unconditional jump to stack[-2] label_19A9: // Incoming call from 0x1E8B, returns to 0x1E8C // Inputs[2] // { // @19AE memory[0x40:0x60] // @19B1 stack[-1] // } 19A9 5B JUMPDEST 19AA 60 PUSH1 0x00 19AC 60 PUSH1 0x40 19AE 51 MLOAD 19AF 90 SWAP1 19B0 50 POP 19B1 90 SWAP1 19B2 56 *JUMP // Stack delta = +0 // Outputs[1] { @19B1 stack[-1] = memory[0x40:0x60] } // Block ends with unconditional jump to stack[-1] label_19B3: // Incoming jump from 0x1F65 // Incoming jump from 0x1DF2 // Incoming jump from 0x2A78 // Incoming jump from 0x1C2A // Incoming jump from 0x1D22 // Incoming jump from 0x1FE5 // Incoming jump from 0x1A29 // Incoming jump from 0x1C6C // Incoming jump from 0x1B74 // Incoming jump from 0x1D6E // Inputs[1] { @19B7 memory[0x00:0x00] } 19B3 5B JUMPDEST 19B4 60 PUSH1 0x00 19B6 80 DUP1 19B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @19B7 revert(memory[0x00:0x00]); } // Block terminates label_19B8: // Incoming jump from 0x1D40 // Incoming jump from 0x1FB6 // Inputs[1] { @19BC memory[0x00:0x00] } 19B8 5B JUMPDEST 19B9 60 PUSH1 0x00 19BB 80 DUP1 19BC FD *REVERT // Stack delta = +0 // Outputs[1] { @19BC revert(memory[0x00:0x00]); } // Block terminates label_19BD: // Incoming call from 0x19F1, returns to 0x19F2 // Inputs[2] // { // @19E1 stack[-1] // @19E5 stack[-2] // } 19BD 5B JUMPDEST 19BE 60 PUSH1 0x00 19C0 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 19E1 82 DUP3 19E2 16 AND 19E3 90 SWAP1 19E4 50 POP 19E5 91 SWAP2 19E6 90 SWAP1 19E7 50 POP 19E8 56 *JUMP // Stack delta = -1 // Outputs[1] { @19E5 stack[-2] = stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to stack[-2] label_19E9: // Incoming call from 0x1A0E, returns to 0x1A0F // Incoming call from 0x2A5D, returns to 0x2A5E // Inputs[1] { @19ED stack[-1] } 19E9 5B JUMPDEST 19EA 61 PUSH2 0x19f2 19ED 81 DUP2 19EE 61 PUSH2 0x19bd 19F1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @19EA stack[0] = 0x19f2 // @19ED stack[1] = stack[-1] // } // Block ends with call to 0x19bd, returns to 0x19F2 label_19F2: // Incoming return from call to 0x19BD at 0x19F1 // Inputs[2] // { // @19F3 stack[-2] // @19F4 stack[-1] // } 19F2 5B JUMPDEST 19F3 81 DUP2 19F4 14 EQ 19F5 61 PUSH2 0x19fd 19F8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x19fd, if stack[-2] == stack[-1] label_19F9: // Incoming jump from 0x19F8, if not stack[-2] == stack[-1] // Inputs[1] { @19FC memory[0x00:0x00] } 19F9 60 PUSH1 0x00 19FB 80 DUP1 19FC FD *REVERT // Stack delta = +0 // Outputs[1] { @19FC revert(memory[0x00:0x00]); } // Block terminates label_19FD: // Incoming jump from 0x19F8, if stack[-2] == stack[-1] // Inputs[1] { @19FF stack[-2] } 19FD 5B JUMPDEST 19FE 50 POP 19FF 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1A00: // Incoming call from 0x1A38, returns to 0x1A39 // Inputs[2] // { // @1A03 stack[-1] // @1A04 msg.data[stack[-1]:stack[-1] + 0x20] // } 1A00 5B JUMPDEST 1A01 60 PUSH1 0x00 1A03 81 DUP2 1A04 35 CALLDATALOAD 1A05 90 SWAP1 1A06 50 POP 1A07 61 PUSH2 0x1a0f 1A0A 81 DUP2 1A0B 61 PUSH2 0x19e9 1A0E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A05 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1A07 stack[1] = 0x1a0f // @1A0A stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x19e9, returns to 0x1A0F label_1A0F: // Incoming return from call to 0x19E9 at 0x1A0E // Inputs[3] // { // @1A10 stack[-4] // @1A10 stack[-1] // @1A11 stack[-3] // } 1A0F 5B JUMPDEST 1A10 92 SWAP3 1A11 91 SWAP2 1A12 50 POP 1A13 50 POP 1A14 56 *JUMP // Stack delta = -3 // Outputs[1] { @1A10 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1A15: // Incoming call from 0x0145, returns to 0x0146 // Inputs[2] // { // @1A1A stack[-1] // @1A1B stack[-2] // } 1A15 5B JUMPDEST 1A16 60 PUSH1 0x00 1A18 60 PUSH1 0x20 1A1A 82 DUP3 1A1B 84 DUP5 1A1C 03 SUB 1A1D 12 SLT 1A1E 15 ISZERO 1A1F 61 PUSH2 0x1a2b 1A22 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A16 stack[0] = 0x00 } // Block ends with conditional jump to 0x1a2b, if !(stack[-2] - stack[-1] i< 0x20) label_1A23: // Incoming jump from 0x1A22, if not !(stack[-2] - stack[-1] i< 0x20) 1A23 61 PUSH2 0x1a2a 1A26 61 PUSH2 0x19b3 1A29 56 *JUMP // Stack delta = +1 // Outputs[1] { @1A23 stack[0] = 0x1a2a } // Block ends with unconditional jump to 0x19b3 1A2A 5B JUMPDEST label_1A2B: // Incoming jump from 0x1A22, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1A31 stack[-3] // @1A33 stack[-2] // } 1A2B 5B JUMPDEST 1A2C 60 PUSH1 0x00 1A2E 61 PUSH2 0x1a39 1A31 84 DUP5 1A32 82 DUP3 1A33 85 DUP6 1A34 01 ADD 1A35 61 PUSH2 0x1a00 1A38 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A2C stack[0] = 0x00 // @1A2E stack[1] = 0x1a39 // @1A31 stack[2] = stack[-3] // @1A34 stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x1a00, returns to 0x1A39 label_1A39: // Incoming return from call to 0x1A00 at 0x1A38 // Inputs[4] // { // @1A3A stack[-1] // @1A3A stack[-3] // @1A3D stack[-6] // @1A3E stack[-5] // } 1A39 5B JUMPDEST 1A3A 91 SWAP2 1A3B 50 POP 1A3C 50 POP 1A3D 92 SWAP3 1A3E 91 SWAP2 1A3F 50 POP 1A40 50 POP 1A41 56 *JUMP // Stack delta = -5 // Outputs[1] { @1A3D stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1A42: // Incoming call from 0x1DB9, returns to 0x1DBA // Incoming call from 0x1A56, returns to 0x1A57 // Inputs[2] // { // @1A45 stack[-1] // @1A4A stack[-2] // } 1A42 5B JUMPDEST 1A43 60 PUSH1 0x00 1A45 81 DUP2 1A46 15 ISZERO 1A47 15 ISZERO 1A48 90 SWAP1 1A49 50 POP 1A4A 91 SWAP2 1A4B 90 SWAP1 1A4C 50 POP 1A4D 56 *JUMP // Stack delta = -1 // Outputs[1] { @1A4A stack[-2] = !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_1A4E: // Incoming call from 0x1A71, returns to 0x1A72 // Inputs[1] { @1A52 stack[-1] } 1A4E 5B JUMPDEST 1A4F 61 PUSH2 0x1a57 1A52 81 DUP2 1A53 61 PUSH2 0x1a42 1A56 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1A4F stack[0] = 0x1a57 // @1A52 stack[1] = stack[-1] // } // Block ends with call to 0x1a42, returns to 0x1A57 label_1A57: // Incoming return from call to 0x1A42 at 0x1A56 // Inputs[3] // { // @1A58 stack[-3] // @1A59 stack[-1] // @1A5C stack[-4] // } 1A57 5B JUMPDEST 1A58 82 DUP3 1A59 52 MSTORE 1A5A 50 POP 1A5B 50 POP 1A5C 56 *JUMP // Stack delta = -4 // Outputs[1] { @1A59 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1A5D: // Incoming call from 0x0371, returns to 0x0372 // Incoming call from 0x143E, returns to 0x143F // Incoming call from 0x0157, returns to 0x0158 // Inputs[2] // { // @1A62 stack[-1] // @1A6D stack[-2] // } 1A5D 5B JUMPDEST 1A5E 60 PUSH1 0x00 1A60 60 PUSH1 0x20 1A62 82 DUP3 1A63 01 ADD 1A64 90 SWAP1 1A65 50 POP 1A66 61 PUSH2 0x1a72 1A69 60 PUSH1 0x00 1A6B 83 DUP4 1A6C 01 ADD 1A6D 84 DUP5 1A6E 61 PUSH2 0x1a4e 1A71 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A64 stack[0] = stack[-1] + 0x20 // @1A66 stack[1] = 0x1a72 // @1A6C stack[2] = stack[-1] + 0x00 // @1A6D stack[3] = stack[-2] // } // Block ends with call to 0x1a4e, returns to 0x1A72 label_1A72: // Incoming return from call to 0x1A4E at 0x1A71 // Inputs[3] // { // @1A73 stack[-4] // @1A73 stack[-1] // @1A74 stack[-3] // } 1A72 5B JUMPDEST 1A73 92 SWAP3 1A74 91 SWAP2 1A75 50 POP 1A76 50 POP 1A77 56 *JUMP // Stack delta = -3 // Outputs[1] { @1A73 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1A78: // Incoming call from 0x1AD9, returns to 0x1ADA // Inputs[3] // { // @1A7B stack[-1] // @1A7C memory[stack[-1]:stack[-1] + 0x20] // @1A7F stack[-2] // } 1A78 5B JUMPDEST 1A79 60 PUSH1 0x00 1A7B 81 DUP2 1A7C 51 MLOAD 1A7D 90 SWAP1 1A7E 50 POP 1A7F 91 SWAP2 1A80 90 SWAP1 1A81 50 POP 1A82 56 *JUMP // Stack delta = -1 // Outputs[1] { @1A7F stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_1A83: // Incoming call from 0x2266, returns to 0x2267 // Incoming call from 0x2879, returns to 0x287A // Incoming call from 0x267D, returns to 0x267E // Incoming call from 0x28E5, returns to 0x28E6 // Incoming call from 0x280D, returns to 0x280E // Incoming call from 0x2AC6, returns to 0x2AC7 // Incoming call from 0x26E9, returns to 0x26EA // Incoming call from 0x277B, returns to 0x277C // Incoming call from 0x2977, returns to 0x2978 // Incoming call from 0x25EB, returns to 0x25EC // Incoming call from 0x22D2, returns to 0x22D3 // Incoming call from 0x2B32, returns to 0x2B33 // Incoming call from 0x20CB, returns to 0x20CC // Incoming call from 0x215D, returns to 0x215E // Incoming call from 0x1AE3, returns to 0x1AE4 // Inputs[3] // { // @1A86 stack[-2] // @1A87 stack[-1] // @1A8F stack[-3] // } 1A83 5B JUMPDEST 1A84 60 PUSH1 0x00 1A86 82 DUP3 1A87 82 DUP3 1A88 52 MSTORE 1A89 60 PUSH1 0x20 1A8B 82 DUP3 1A8C 01 ADD 1A8D 90 SWAP1 1A8E 50 POP 1A8F 92 SWAP3 1A90 91 SWAP2 1A91 50 POP 1A92 50 POP 1A93 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1A88 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @1A8F stack[-3] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-3] label_1A94: // Incoming call from 0x29EE, returns to 0x29EF // Incoming call from 0x1AF3, returns to 0x1AF4 // Inputs[1] { @1A98 stack[-3] } 1A94 5B JUMPDEST 1A95 60 PUSH1 0x00 1A97 5B JUMPDEST 1A98 83 DUP4 1A99 81 DUP2 1A9A 10 LT 1A9B 15 ISZERO 1A9C 61 PUSH2 0x1ab2 1A9F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A95 stack[0] = 0x00 } // Block ends with conditional jump to 0x1ab2, if !(0x00 < stack[-3]) label_1AA0: // Incoming jump from 0x1A9F, if not !(0x00 < stack[-3]) // Incoming jump from 0x1A9F, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @1AA0 stack[-1] // @1AA1 stack[-2] // @1AA3 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @1AA5 stack[-3] // } 1AA0 80 DUP1 1AA1 82 DUP3 1AA2 01 ADD 1AA3 51 MLOAD 1AA4 81 DUP2 1AA5 84 DUP5 1AA6 01 ADD 1AA7 52 MSTORE 1AA8 60 PUSH1 0x20 1AAA 81 DUP2 1AAB 01 ADD 1AAC 90 SWAP1 1AAD 50 POP 1AAE 61 PUSH2 0x1a97 1AB1 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1AA7 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @1AAC stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1a97 label_1AB2: // Incoming jump from 0x1A9F, if !(0x00 < stack[-3]) // Incoming jump from 0x1A9F, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @1AB5 stack[-4] // @1AB6 stack[-3] // @1ABD stack[-5] // } 1AB2 5B JUMPDEST 1AB3 60 PUSH1 0x00 1AB5 84 DUP5 1AB6 84 DUP5 1AB7 01 ADD 1AB8 52 MSTORE 1AB9 50 POP 1ABA 50 POP 1ABB 50 POP 1ABC 50 POP 1ABD 56 *JUMP // Stack delta = -5 // Outputs[1] { @1AB8 memory[stack[-3] + stack[-4]:stack[-3] + stack[-4] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_1ABE: // Incoming call from 0x1AFC, returns to 0x1AFD // Incoming call from 0x1E59, returns to 0x1E5A // Incoming call from 0x29F7, returns to 0x29F8 // Incoming call from 0x1EC0, returns to 0x1EC1 // Inputs[2] // { // @1AC6 stack[-1] // @1ACB stack[-2] // } 1ABE 5B JUMPDEST 1ABF 60 PUSH1 0x00 1AC1 60 PUSH1 0x1f 1AC3 19 NOT 1AC4 60 PUSH1 0x1f 1AC6 83 DUP4 1AC7 01 ADD 1AC8 16 AND 1AC9 90 SWAP1 1ACA 50 POP 1ACB 91 SWAP2 1ACC 90 SWAP1 1ACD 50 POP 1ACE 56 *JUMP // Stack delta = -1 // Outputs[1] { @1ACB stack[-2] = stack[-1] + 0x1f & ~0x1f } // Block ends with unconditional jump to stack[-2] label_1ACF: // Incoming call from 0x1B21, returns to 0x1B22 // Inputs[1] { @1AD5 stack[-1] } 1ACF 5B JUMPDEST 1AD0 60 PUSH1 0x00 1AD2 61 PUSH2 0x1ada 1AD5 82 DUP3 1AD6 61 PUSH2 0x1a78 1AD9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1AD0 stack[0] = 0x00 // @1AD2 stack[1] = 0x1ada // @1AD5 stack[2] = stack[-1] // } // Block ends with call to 0x1a78, returns to 0x1ADA label_1ADA: // Incoming return from call to 0x1A78 at 0x1AD9 // Inputs[2] // { // @1ADE stack[-1] // @1ADF stack[-4] // } 1ADA 5B JUMPDEST 1ADB 61 PUSH2 0x1ae4 1ADE 81 DUP2 1ADF 85 DUP6 1AE0 61 PUSH2 0x1a83 1AE3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1ADB stack[0] = 0x1ae4 // @1ADE stack[1] = stack[-1] // @1ADF stack[2] = stack[-4] // } // Block ends with call to 0x1a83, returns to 0x1AE4 label_1AE4: // Incoming return from call to 0x1A83 at 0x1AE3 // Inputs[4] // { // @1AE5 stack[-1] // @1AE5 stack[-5] // @1AEA stack[-2] // @1AEE stack[-4] // } 1AE4 5B JUMPDEST 1AE5 93 SWAP4 1AE6 50 POP 1AE7 61 PUSH2 0x1af4 1AEA 81 DUP2 1AEB 85 DUP6 1AEC 60 PUSH1 0x20 1AEE 86 DUP7 1AEF 01 ADD 1AF0 61 PUSH2 0x1a94 1AF3 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1AE5 stack[-5] = stack[-1] // @1AE7 stack[-1] = 0x1af4 // @1AEA stack[0] = stack[-2] // @1AEB stack[1] = stack[-1] // @1AEF stack[2] = stack[-4] + 0x20 // } // Block ends with call to 0x1a94, returns to 0x1AF4 label_1AF4: // Incoming return from call to 0x1A94 at 0x1AF3 // Inputs[1] { @1AF8 stack[-1] } 1AF4 5B JUMPDEST 1AF5 61 PUSH2 0x1afd 1AF8 81 DUP2 1AF9 61 PUSH2 0x1abe 1AFC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1AF5 stack[0] = 0x1afd // @1AF8 stack[1] = stack[-1] // } // Block ends with call to 0x1abe, returns to 0x1AFD label_1AFD: // Incoming return from call to 0x1ABE at 0x1AFC // Inputs[4] // { // @1AFE stack[-5] // @1AFF stack[-1] // @1B00 stack[-3] // @1B03 stack[-6] // } 1AFD 5B JUMPDEST 1AFE 84 DUP5 1AFF 01 ADD 1B00 91 SWAP2 1B01 50 POP 1B02 50 POP 1B03 92 SWAP3 1B04 91 SWAP2 1B05 50 POP 1B06 50 POP 1B07 56 *JUMP // Stack delta = -5 // Outputs[1] { @1B03 stack[-6] = stack[-5] + stack[-1] } // Block ends with unconditional jump to stack[-6] label_1B08: // Incoming call from 0x0175, returns to 0x0176 // Incoming call from 0x02CF, returns to 0x02D0 // Incoming call from 0x0337, returns to 0x0338 // Inputs[2] // { // @1B0D stack[-1] // @1B1D stack[-2] // } 1B08 5B JUMPDEST 1B09 60 PUSH1 0x00 1B0B 60 PUSH1 0x20 1B0D 82 DUP3 1B0E 01 ADD 1B0F 90 SWAP1 1B10 50 POP 1B11 81 DUP2 1B12 81 DUP2 1B13 03 SUB 1B14 60 PUSH1 0x00 1B16 83 DUP4 1B17 01 ADD 1B18 52 MSTORE 1B19 61 PUSH2 0x1b22 1B1C 81 DUP2 1B1D 84 DUP5 1B1E 61 PUSH2 0x1acf 1B21 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1B0F stack[0] = stack[-1] + 0x20 // @1B18 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @1B19 stack[1] = 0x1b22 // @1B1C stack[2] = stack[-1] + 0x20 // @1B1D stack[3] = stack[-2] // } // Block ends with call to 0x1acf, returns to 0x1B22 label_1B22: // Incoming return from call to 0x1ACF at 0x1B21 // Inputs[4] // { // @1B23 stack[-2] // @1B23 stack[-1] // @1B25 stack[-5] // @1B26 stack[-4] // } 1B22 5B JUMPDEST 1B23 90 SWAP1 1B24 50 POP 1B25 92 SWAP3 1B26 91 SWAP2 1B27 50 POP 1B28 50 POP 1B29 56 *JUMP // Stack delta = -4 // Outputs[1] { @1B25 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1B2A: // Incoming call from 0x1B3C, returns to 0x1B3D // Incoming call from 0x23B2, returns to 0x23B3 // Incoming call from 0x21CD, returns to 0x21CE // Incoming jump from 0x23BC // Incoming call from 0x1D8F, returns to 0x1D90 // Inputs[2] // { // @1B2D stack[-1] // @1B30 stack[-2] // } 1B2A 5B JUMPDEST 1B2B 60 PUSH1 0x00 1B2D 81 DUP2 1B2E 90 SWAP1 1B2F 50 POP 1B30 91 SWAP2 1B31 90 SWAP1 1B32 50 POP 1B33 56 *JUMP // Stack delta = -1 // Outputs[1] { @1B30 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_1B34: // Incoming call from 0x1B59, returns to 0x1B5A // Inputs[1] { @1B38 stack[-1] } 1B34 5B JUMPDEST 1B35 61 PUSH2 0x1b3d 1B38 81 DUP2 1B39 61 PUSH2 0x1b2a 1B3C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1B35 stack[0] = 0x1b3d // @1B38 stack[1] = stack[-1] // } // Block ends with call to 0x1b2a, returns to 0x1B3D label_1B3D: // Incoming return from call to 0x1B2A at 0x1B3C // Inputs[2] // { // @1B3E stack[-2] // @1B3F stack[-1] // } 1B3D 5B JUMPDEST 1B3E 81 DUP2 1B3F 14 EQ 1B40 61 PUSH2 0x1b48 1B43 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1b48, if stack[-2] == stack[-1] label_1B44: // Incoming jump from 0x1B43, if not stack[-2] == stack[-1] // Inputs[1] { @1B47 memory[0x00:0x00] } 1B44 60 PUSH1 0x00 1B46 80 DUP1 1B47 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B47 revert(memory[0x00:0x00]); } // Block terminates label_1B48: // Incoming jump from 0x1B43, if stack[-2] == stack[-1] // Inputs[1] { @1B4A stack[-2] } 1B48 5B JUMPDEST 1B49 50 POP 1B4A 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1B4B: // Incoming call from 0x1B83, returns to 0x1B84 // Incoming call from 0x1C9D, returns to 0x1C9E // Incoming call from 0x1F96, returns to 0x1F97 // Incoming call from 0x1C4A, returns to 0x1C4B // Inputs[2] // { // @1B4E stack[-1] // @1B4F msg.data[stack[-1]:stack[-1] + 0x20] // } 1B4B 5B JUMPDEST 1B4C 60 PUSH1 0x00 1B4E 81 DUP2 1B4F 35 CALLDATALOAD 1B50 90 SWAP1 1B51 50 POP 1B52 61 PUSH2 0x1b5a 1B55 81 DUP2 1B56 61 PUSH2 0x1b34 1B59 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B50 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1B52 stack[1] = 0x1b5a // @1B55 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x1b34, returns to 0x1B5A label_1B5A: // Incoming return from call to 0x1B34 at 0x1B59 // Inputs[3] // { // @1B5B stack[-4] // @1B5B stack[-1] // @1B5C stack[-3] // } 1B5A 5B JUMPDEST 1B5B 92 SWAP3 1B5C 91 SWAP2 1B5D 50 POP 1B5E 50 POP 1B5F 56 *JUMP // Stack delta = -3 // Outputs[1] { @1B5B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1B60: // Incoming call from 0x0193, returns to 0x0194 // Incoming call from 0x022B, returns to 0x022C // Incoming call from 0x0325, returns to 0x0326 // Inputs[2] // { // @1B65 stack[-1] // @1B66 stack[-2] // } 1B60 5B JUMPDEST 1B61 60 PUSH1 0x00 1B63 60 PUSH1 0x20 1B65 82 DUP3 1B66 84 DUP5 1B67 03 SUB 1B68 12 SLT 1B69 15 ISZERO 1B6A 61 PUSH2 0x1b76 1B6D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B61 stack[0] = 0x00 } // Block ends with conditional jump to 0x1b76, if !(stack[-2] - stack[-1] i< 0x20) label_1B6E: // Incoming jump from 0x1B6D, if not !(stack[-2] - stack[-1] i< 0x20) 1B6E 61 PUSH2 0x1b75 1B71 61 PUSH2 0x19b3 1B74 56 *JUMP // Stack delta = +1 // Outputs[1] { @1B6E stack[0] = 0x1b75 } // Block ends with unconditional jump to 0x19b3 1B75 5B JUMPDEST label_1B76: // Incoming jump from 0x1B6D, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1B7C stack[-3] // @1B7E stack[-2] // } 1B76 5B JUMPDEST 1B77 60 PUSH1 0x00 1B79 61 PUSH2 0x1b84 1B7C 84 DUP5 1B7D 82 DUP3 1B7E 85 DUP6 1B7F 01 ADD 1B80 61 PUSH2 0x1b4b 1B83 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B77 stack[0] = 0x00 // @1B79 stack[1] = 0x1b84 // @1B7C stack[2] = stack[-3] // @1B7F stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x1b4b, returns to 0x1B84 label_1B84: // Incoming return from call to 0x1B4B at 0x1B83 // Inputs[4] // { // @1B85 stack[-3] // @1B85 stack[-1] // @1B88 stack[-6] // @1B89 stack[-5] // } 1B84 5B JUMPDEST 1B85 91 SWAP2 1B86 50 POP 1B87 50 POP 1B88 92 SWAP3 1B89 91 SWAP2 1B8A 50 POP 1B8B 50 POP 1B8C 56 *JUMP // Stack delta = -5 // Outputs[1] { @1B88 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1B8D: // Incoming call from 0x1BB7, returns to 0x1BB8 // Inputs[2] // { // @1BA5 stack[-1] // @1BA9 stack[-2] // } 1B8D 5B JUMPDEST 1B8E 60 PUSH1 0x00 1B90 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1BA5 82 DUP3 1BA6 16 AND 1BA7 90 SWAP1 1BA8 50 POP 1BA9 91 SWAP2 1BAA 90 SWAP1 1BAB 50 POP 1BAC 56 *JUMP // Stack delta = -1 // Outputs[1] { @1BA9 stack[-2] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff } // Block ends with unconditional jump to stack[-2] label_1BAD: // Incoming call from 0x1BC7, returns to 0x1BC8 // Incoming call from 0x1BF1, returns to 0x1BF2 // Inputs[1] { @1BB3 stack[-1] } 1BAD 5B JUMPDEST 1BAE 60 PUSH1 0x00 1BB0 61 PUSH2 0x1bb8 1BB3 82 DUP3 1BB4 61 PUSH2 0x1b8d 1BB7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1BAE stack[0] = 0x00 // @1BB0 stack[1] = 0x1bb8 // @1BB3 stack[2] = stack[-1] // } // Block ends with call to 0x1b8d, returns to 0x1BB8 label_1BB8: // Incoming return from call to 0x1B8D at 0x1BB7 // Inputs[4] // { // @1BB9 stack[-2] // @1BB9 stack[-1] // @1BBB stack[-4] // @1BBC stack[-3] // } 1BB8 5B JUMPDEST 1BB9 90 SWAP1 1BBA 50 POP 1BBB 91 SWAP2 1BBC 90 SWAP1 1BBD 50 POP 1BBE 56 *JUMP // Stack delta = -3 // Outputs[1] { @1BBB stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1BBF: // Incoming call from 0x1BE2, returns to 0x1BE3 // Incoming call from 0x2A24, returns to 0x2A25 // Incoming call from 0x2A17, returns to 0x2A18 // Inputs[1] { @1BC3 stack[-1] } 1BBF 5B JUMPDEST 1BC0 61 PUSH2 0x1bc8 1BC3 81 DUP2 1BC4 61 PUSH2 0x1bad 1BC7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1BC0 stack[0] = 0x1bc8 // @1BC3 stack[1] = stack[-1] // } // Block ends with call to 0x1bad, returns to 0x1BC8 label_1BC8: // Incoming return from call to 0x1BAD at 0x1BC7 // Inputs[3] // { // @1BC9 stack[-3] // @1BCA stack[-1] // @1BCD stack[-4] // } 1BC8 5B JUMPDEST 1BC9 82 DUP3 1BCA 52 MSTORE 1BCB 50 POP 1BCC 50 POP 1BCD 56 *JUMP // Stack delta = -4 // Outputs[1] { @1BCA memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1BCE: // Incoming call from 0x023D, returns to 0x023E // Incoming call from 0x01A5, returns to 0x01A6 // Incoming call from 0x02B1, returns to 0x02B2 // Inputs[2] // { // @1BD3 stack[-1] // @1BDE stack[-2] // } 1BCE 5B JUMPDEST 1BCF 60 PUSH1 0x00 1BD1 60 PUSH1 0x20 1BD3 82 DUP3 1BD4 01 ADD 1BD5 90 SWAP1 1BD6 50 POP 1BD7 61 PUSH2 0x1be3 1BDA 60 PUSH1 0x00 1BDC 83 DUP4 1BDD 01 ADD 1BDE 84 DUP5 1BDF 61 PUSH2 0x1bbf 1BE2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BD5 stack[0] = stack[-1] + 0x20 // @1BD7 stack[1] = 0x1be3 // @1BDD stack[2] = stack[-1] + 0x00 // @1BDE stack[3] = stack[-2] // } // Block ends with call to 0x1bbf, returns to 0x1BE3 label_1BE3: // Incoming return from call to 0x1BBF at 0x1BE2 // Inputs[3] // { // @1BE4 stack[-1] // @1BE4 stack[-4] // @1BE5 stack[-3] // } 1BE3 5B JUMPDEST 1BE4 92 SWAP3 1BE5 91 SWAP2 1BE6 50 POP 1BE7 50 POP 1BE8 56 *JUMP // Stack delta = -3 // Outputs[1] { @1BE4 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1BE9: // Incoming call from 0x1C0E, returns to 0x1C0F // Inputs[1] { @1BED stack[-1] } 1BE9 5B JUMPDEST 1BEA 61 PUSH2 0x1bf2 1BED 81 DUP2 1BEE 61 PUSH2 0x1bad 1BF1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1BEA stack[0] = 0x1bf2 // @1BED stack[1] = stack[-1] // } // Block ends with call to 0x1bad, returns to 0x1BF2 label_1BF2: // Incoming return from call to 0x1BAD at 0x1BF1 // Inputs[2] // { // @1BF3 stack[-2] // @1BF4 stack[-1] // } 1BF2 5B JUMPDEST 1BF3 81 DUP2 1BF4 14 EQ 1BF5 61 PUSH2 0x1bfd 1BF8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1bfd, if stack[-2] == stack[-1] label_1BF9: // Incoming jump from 0x1BF8, if not stack[-2] == stack[-1] // Inputs[1] { @1BFC memory[0x00:0x00] } 1BF9 60 PUSH1 0x00 1BFB 80 DUP1 1BFC FD *REVERT // Stack delta = +0 // Outputs[1] { @1BFC revert(memory[0x00:0x00]); } // Block terminates label_1BFD: // Incoming jump from 0x1BF8, if stack[-2] == stack[-1] // Inputs[1] { @1BFF stack[-2] } 1BFD 5B JUMPDEST 1BFE 50 POP 1BFF 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1C00: // Incoming call from 0x1C7B, returns to 0x1C7C // Incoming call from 0x1D7D, returns to 0x1D7E // Incoming call from 0x1F85, returns to 0x1F86 // Incoming call from 0x1C39, returns to 0x1C3A // Incoming call from 0x1FF4, returns to 0x1FF5 // Incoming call from 0x2005, returns to 0x2006 // Incoming call from 0x1E01, returns to 0x1E02 // Incoming call from 0x1F74, returns to 0x1F75 // Incoming call from 0x1C8C, returns to 0x1C8D // Inputs[2] // { // @1C03 stack[-1] // @1C04 msg.data[stack[-1]:stack[-1] + 0x20] // } 1C00 5B JUMPDEST 1C01 60 PUSH1 0x00 1C03 81 DUP2 1C04 35 CALLDATALOAD 1C05 90 SWAP1 1C06 50 POP 1C07 61 PUSH2 0x1c0f 1C0A 81 DUP2 1C0B 61 PUSH2 0x1be9 1C0E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C05 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1C07 stack[1] = 0x1c0f // @1C0A stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x1be9, returns to 0x1C0F label_1C0F: // Incoming return from call to 0x1BE9 at 0x1C0E // Inputs[3] // { // @1C10 stack[-4] // @1C10 stack[-1] // @1C11 stack[-3] // } 1C0F 5B JUMPDEST 1C10 92 SWAP3 1C11 91 SWAP2 1C12 50 POP 1C13 50 POP 1C14 56 *JUMP // Stack delta = -3 // Outputs[1] { @1C10 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1C15: // Incoming call from 0x01C3, returns to 0x01C4 // Inputs[2] // { // @1C1B stack[-1] // @1C1C stack[-2] // } 1C15 5B JUMPDEST 1C16 60 PUSH1 0x00 1C18 80 DUP1 1C19 60 PUSH1 0x40 1C1B 83 DUP4 1C1C 85 DUP6 1C1D 03 SUB 1C1E 12 SLT 1C1F 15 ISZERO 1C20 61 PUSH2 0x1c2c 1C23 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C16 stack[0] = 0x00 // @1C18 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1c2c, if !(stack[-2] - stack[-1] i< 0x40) label_1C24: // Incoming jump from 0x1C23, if not !(stack[-2] - stack[-1] i< 0x40) 1C24 61 PUSH2 0x1c2b 1C27 61 PUSH2 0x19b3 1C2A 56 *JUMP // Stack delta = +1 // Outputs[1] { @1C24 stack[0] = 0x1c2b } // Block ends with unconditional jump to 0x19b3 1C2B 5B JUMPDEST label_1C2C: // Incoming jump from 0x1C23, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1C32 stack[-4] // @1C34 stack[-3] // } 1C2C 5B JUMPDEST 1C2D 60 PUSH1 0x00 1C2F 61 PUSH2 0x1c3a 1C32 85 DUP6 1C33 82 DUP3 1C34 86 DUP7 1C35 01 ADD 1C36 61 PUSH2 0x1c00 1C39 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C2D stack[0] = 0x00 // @1C2F stack[1] = 0x1c3a // @1C32 stack[2] = stack[-4] // @1C35 stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x1c00, returns to 0x1C3A label_1C3A: // Incoming return from call to 0x1C00 at 0x1C39 // Inputs[4] // { // @1C3B stack[-4] // @1C3B stack[-1] // @1C43 stack[-6] // @1C45 stack[-5] // } 1C3A 5B JUMPDEST 1C3B 92 SWAP3 1C3C 50 POP 1C3D 50 POP 1C3E 60 PUSH1 0x20 1C40 61 PUSH2 0x1c4b 1C43 85 DUP6 1C44 82 DUP3 1C45 86 DUP7 1C46 01 ADD 1C47 61 PUSH2 0x1b4b 1C4A 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1C3B stack[-4] = stack[-1] // @1C3E stack[-2] = 0x20 // @1C40 stack[-1] = 0x1c4b // @1C43 stack[0] = stack[-6] // @1C46 stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x1b4b, returns to 0x1C4B label_1C4B: // Incoming return from call to 0x1B4B at 0x1C4A // Inputs[6] // { // @1C4C stack[-1] // @1C4C stack[-3] // @1C4F stack[-6] // @1C51 stack[-4] // @1C51 stack[-7] // @1C52 stack[-5] // } 1C4B 5B JUMPDEST 1C4C 91 SWAP2 1C4D 50 POP 1C4E 50 POP 1C4F 92 SWAP3 1C50 50 POP 1C51 92 SWAP3 1C52 90 SWAP1 1C53 50 POP 1C54 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1C4F stack[-6] = stack[-1] // @1C51 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1C55: // Incoming call from 0x020F, returns to 0x0210 // Incoming call from 0x01E9, returns to 0x01EA // Inputs[2] // { // @1C5D stack[-1] // @1C5E stack[-2] // } 1C55 5B JUMPDEST 1C56 60 PUSH1 0x00 1C58 80 DUP1 1C59 60 PUSH1 0x00 1C5B 60 PUSH1 0x60 1C5D 84 DUP5 1C5E 86 DUP7 1C5F 03 SUB 1C60 12 SLT 1C61 15 ISZERO 1C62 61 PUSH2 0x1c6e 1C65 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1C56 stack[0] = 0x00 // @1C58 stack[1] = 0x00 // @1C59 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1c6e, if !(stack[-2] - stack[-1] i< 0x60) label_1C66: // Incoming jump from 0x1C65, if not !(stack[-2] - stack[-1] i< 0x60) 1C66 61 PUSH2 0x1c6d 1C69 61 PUSH2 0x19b3 1C6C 56 *JUMP // Stack delta = +1 // Outputs[1] { @1C66 stack[0] = 0x1c6d } // Block ends with unconditional jump to 0x19b3 1C6D 5B JUMPDEST label_1C6E: // Incoming jump from 0x1C65, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @1C74 stack[-5] // @1C76 stack[-4] // } 1C6E 5B JUMPDEST 1C6F 60 PUSH1 0x00 1C71 61 PUSH2 0x1c7c 1C74 86 DUP7 1C75 82 DUP3 1C76 87 DUP8 1C77 01 ADD 1C78 61 PUSH2 0x1c00 1C7B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C6F stack[0] = 0x00 // @1C71 stack[1] = 0x1c7c // @1C74 stack[2] = stack[-5] // @1C77 stack[3] = stack[-4] + 0x00 // } // Block ends with call to 0x1c00, returns to 0x1C7C label_1C7C: // Incoming return from call to 0x1C00 at 0x1C7B // Inputs[4] // { // @1C7D stack[-5] // @1C7D stack[-1] // @1C85 stack[-7] // @1C87 stack[-6] // } 1C7C 5B JUMPDEST 1C7D 93 SWAP4 1C7E 50 POP 1C7F 50 POP 1C80 60 PUSH1 0x20 1C82 61 PUSH2 0x1c8d 1C85 86 DUP7 1C86 82 DUP3 1C87 87 DUP8 1C88 01 ADD 1C89 61 PUSH2 0x1c00 1C8C 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1C7D stack[-5] = stack[-1] // @1C80 stack[-2] = 0x20 // @1C82 stack[-1] = 0x1c8d // @1C85 stack[0] = stack[-7] // @1C88 stack[1] = stack[-6] + 0x20 // } // Block ends with call to 0x1c00, returns to 0x1C8D label_1C8D: // Incoming return from call to 0x1C00 at 0x1C8C // Inputs[4] // { // @1C8E stack[-1] // @1C8E stack[-4] // @1C96 stack[-7] // @1C98 stack[-6] // } 1C8D 5B JUMPDEST 1C8E 92 SWAP3 1C8F 50 POP 1C90 50 POP 1C91 60 PUSH1 0x40 1C93 61 PUSH2 0x1c9e 1C96 86 DUP7 1C97 82 DUP3 1C98 87 DUP8 1C99 01 ADD 1C9A 61 PUSH2 0x1b4b 1C9D 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1C8E stack[-4] = stack[-1] // @1C91 stack[-2] = 0x40 // @1C93 stack[-1] = 0x1c9e // @1C96 stack[0] = stack[-7] // @1C99 stack[1] = stack[-6] + 0x40 // } // Block ends with call to 0x1b4b, returns to 0x1C9E label_1C9E: // Incoming return from call to 0x1B4B at 0x1C9D // Inputs[7] // { // @1C9F stack[-3] // @1C9F stack[-1] // @1CA2 stack[-6] // @1CA4 stack[-7] // @1CA4 stack[-4] // @1CA6 stack[-5] // @1CA6 stack[-8] // } 1C9E 5B JUMPDEST 1C9F 91 SWAP2 1CA0 50 POP 1CA1 50 POP 1CA2 92 SWAP3 1CA3 50 POP 1CA4 92 SWAP3 1CA5 50 POP 1CA6 92 SWAP3 1CA7 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @1CA2 stack[-6] = stack[-1] // @1CA4 stack[-7] = stack[-4] // @1CA6 stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-8] label_1CA8: // Incoming jump from 0x1F32 // Incoming jump from 0x1CCB // Inputs[1] { @1CAC memory[0x00:0x00] } 1CA8 5B JUMPDEST 1CA9 60 PUSH1 0x00 1CAB 80 DUP1 1CAC FD *REVERT // Stack delta = +0 // Outputs[1] { @1CAC revert(memory[0x00:0x00]); } // Block terminates label_1CAD: // Incoming jump from 0x1CE8 // Inputs[1] { @1CB1 memory[0x00:0x00] } 1CAD 5B JUMPDEST 1CAE 60 PUSH1 0x00 1CB0 80 DUP1 1CB1 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CB1 revert(memory[0x00:0x00]); } // Block terminates label_1CB2: // Incoming jump from 0x1D04 // Inputs[1] { @1CB6 memory[0x00:0x00] } 1CB2 5B JUMPDEST 1CB3 60 PUSH1 0x00 1CB5 80 DUP1 1CB6 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CB6 revert(memory[0x00:0x00]); } // Block terminates label_1CB7: // Incoming call from 0x1D4D, returns to 0x1D4E // Inputs[2] // { // @1CBB stack[-2] // @1CBE stack[-1] // } 1CB7 5B JUMPDEST 1CB8 60 PUSH1 0x00 1CBA 80 DUP1 1CBB 83 DUP4 1CBC 60 PUSH1 0x1f 1CBE 84 DUP5 1CBF 01 ADD 1CC0 12 SLT 1CC1 61 PUSH2 0x1ccd 1CC4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1CB8 stack[0] = 0x00 // @1CBA stack[1] = 0x00 // } // Block ends with conditional jump to 0x1ccd, if stack[-1] + 0x1f i< stack[-2] label_1CC5: // Incoming jump from 0x1CC4, if not stack[-1] + 0x1f i< stack[-2] 1CC5 61 PUSH2 0x1ccc 1CC8 61 PUSH2 0x1ca8 1CCB 56 *JUMP // Stack delta = +1 // Outputs[1] { @1CC5 stack[0] = 0x1ccc } // Block ends with unconditional jump to 0x1ca8 1CCC 5B JUMPDEST label_1CCD: // Incoming jump from 0x1CC4, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @1CCE stack[-3] // @1CCF msg.data[stack[-3]:stack[-3] + 0x20] // @1CD0 stack[-1] // } 1CCD 5B JUMPDEST 1CCE 82 DUP3 1CCF 35 CALLDATALOAD 1CD0 90 SWAP1 1CD1 50 POP 1CD2 67 PUSH8 0xffffffffffffffff 1CDB 81 DUP2 1CDC 11 GT 1CDD 15 ISZERO 1CDE 61 PUSH2 0x1cea 1CE1 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1CD0 stack[-1] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x1cea, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_1CE2: // Incoming jump from 0x1CE1, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) 1CE2 61 PUSH2 0x1ce9 1CE5 61 PUSH2 0x1cad 1CE8 56 *JUMP // Stack delta = +1 // Outputs[1] { @1CE2 stack[0] = 0x1ce9 } // Block ends with unconditional jump to 0x1cad 1CE9 5B JUMPDEST label_1CEA: // Incoming jump from 0x1CE1, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[4] // { // @1CED stack[-3] // @1CEF stack[-2] // @1CF1 stack[-4] // @1CF4 stack[-1] // } 1CEA 5B JUMPDEST 1CEB 60 PUSH1 0x20 1CED 83 DUP4 1CEE 01 ADD 1CEF 91 SWAP2 1CF0 50 POP 1CF1 83 DUP4 1CF2 60 PUSH1 0x01 1CF4 82 DUP3 1CF5 02 MUL 1CF6 83 DUP4 1CF7 01 ADD 1CF8 11 GT 1CF9 15 ISZERO 1CFA 61 PUSH2 0x1d06 1CFD 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1CEF stack[-2] = stack[-3] + 0x20 } // Block ends with conditional jump to 0x1d06, if !(stack[-3] + 0x20 + stack[-1] * 0x01 > stack[-4]) label_1CFE: // Incoming jump from 0x1CFD, if not !(stack[-3] + 0x20 + stack[-1] * 0x01 > stack[-4]) 1CFE 61 PUSH2 0x1d05 1D01 61 PUSH2 0x1cb2 1D04 56 *JUMP // Stack delta = +1 // Outputs[1] { @1CFE stack[0] = 0x1d05 } // Block ends with unconditional jump to 0x1cb2 1D05 5B JUMPDEST label_1D06: // Incoming jump from 0x1CFD, if !(stack[-3] + 0x20 + stack[-1] * 0x01 > stack[-4]) // Inputs[5] // { // @1D07 stack[-1] // @1D07 stack[-4] // @1D09 stack[-5] // @1D09 stack[-2] // @1D0A stack[-3] // } 1D06 5B JUMPDEST 1D07 92 SWAP3 1D08 50 POP 1D09 92 SWAP3 1D0A 90 SWAP1 1D0B 50 POP 1D0C 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1D07 stack[-4] = stack[-1] // @1D09 stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_1D0D: // Incoming call from 0x025B, returns to 0x025C // Inputs[2] // { // @1D13 stack[-1] // @1D14 stack[-2] // } 1D0D 5B JUMPDEST 1D0E 60 PUSH1 0x00 1D10 80 DUP1 1D11 60 PUSH1 0x20 1D13 83 DUP4 1D14 85 DUP6 1D15 03 SUB 1D16 12 SLT 1D17 15 ISZERO 1D18 61 PUSH2 0x1d24 1D1B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D0E stack[0] = 0x00 // @1D10 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1d24, if !(stack[-2] - stack[-1] i< 0x20) label_1D1C: // Incoming jump from 0x1D1B, if not !(stack[-2] - stack[-1] i< 0x20) 1D1C 61 PUSH2 0x1d23 1D1F 61 PUSH2 0x19b3 1D22 56 *JUMP // Stack delta = +1 // Outputs[1] { @1D1C stack[0] = 0x1d23 } // Block ends with unconditional jump to 0x19b3 1D23 5B JUMPDEST label_1D24: // Incoming jump from 0x1D1B, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1D27 stack[-3] // @1D29 msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] // } 1D24 5B JUMPDEST 1D25 60 PUSH1 0x00 1D27 83 DUP4 1D28 01 ADD 1D29 35 CALLDATALOAD 1D2A 67 PUSH8 0xffffffffffffffff 1D33 81 DUP2 1D34 11 GT 1D35 15 ISZERO 1D36 61 PUSH2 0x1d42 1D39 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D29 stack[0] = msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] } // Block ends with conditional jump to 0x1d42, if !(msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] > 0xffffffffffffffff) label_1D3A: // Incoming jump from 0x1D39, if not !(msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] > 0xffffffffffffffff) 1D3A 61 PUSH2 0x1d41 1D3D 61 PUSH2 0x19b8 1D40 56 *JUMP // Stack delta = +1 // Outputs[1] { @1D3A stack[0] = 0x1d41 } // Block ends with unconditional jump to 0x19b8 1D41 5B JUMPDEST label_1D42: // Incoming jump from 0x1D39, if !(msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1D46 stack[-5] // @1D47 stack[-1] // @1D48 stack[-4] // } 1D42 5B JUMPDEST 1D43 61 PUSH2 0x1d4e 1D46 85 DUP6 1D47 82 DUP3 1D48 86 DUP7 1D49 01 ADD 1D4A 61 PUSH2 0x1cb7 1D4D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1D43 stack[0] = 0x1d4e // @1D46 stack[1] = stack[-5] // @1D49 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x1cb7, returns to 0x1D4E label_1D4E: // Incoming return from call to 0x1CB7 at 0x1D4D // Inputs[7] // { // @1D4F stack[-4] // @1D4F stack[-1] // @1D51 stack[-5] // @1D51 stack[-2] // @1D54 stack[-7] // @1D56 stack[-8] // @1D57 stack[-6] // } 1D4E 5B JUMPDEST 1D4F 92 SWAP3 1D50 50 POP 1D51 92 SWAP3 1D52 50 POP 1D53 50 POP 1D54 92 SWAP3 1D55 50 POP 1D56 92 SWAP3 1D57 90 SWAP1 1D58 50 POP 1D59 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @1D54 stack[-7] = stack[-1] // @1D56 stack[-8] = stack[-2] // } // Block ends with unconditional jump to stack[-8] label_1D5A: // Incoming call from 0x038F, returns to 0x0390 // Incoming call from 0x0277, returns to 0x0278 // Inputs[2] // { // @1D5F stack[-1] // @1D60 stack[-2] // } 1D5A 5B JUMPDEST 1D5B 60 PUSH1 0x00 1D5D 60 PUSH1 0x20 1D5F 82 DUP3 1D60 84 DUP5 1D61 03 SUB 1D62 12 SLT 1D63 15 ISZERO 1D64 61 PUSH2 0x1d70 1D67 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1D5B stack[0] = 0x00 } // Block ends with conditional jump to 0x1d70, if !(stack[-2] - stack[-1] i< 0x20) label_1D68: // Incoming jump from 0x1D67, if not !(stack[-2] - stack[-1] i< 0x20) 1D68 61 PUSH2 0x1d6f 1D6B 61 PUSH2 0x19b3 1D6E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1D68 stack[0] = 0x1d6f } // Block ends with unconditional jump to 0x19b3 1D6F 5B JUMPDEST label_1D70: // Incoming jump from 0x1D67, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1D76 stack[-3] // @1D78 stack[-2] // } 1D70 5B JUMPDEST 1D71 60 PUSH1 0x00 1D73 61 PUSH2 0x1d7e 1D76 84 DUP5 1D77 82 DUP3 1D78 85 DUP6 1D79 01 ADD 1D7A 61 PUSH2 0x1c00 1D7D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D71 stack[0] = 0x00 // @1D73 stack[1] = 0x1d7e // @1D76 stack[2] = stack[-3] // @1D79 stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x1c00, returns to 0x1D7E label_1D7E: // Incoming return from call to 0x1C00 at 0x1D7D // Inputs[4] // { // @1D7F stack[-1] // @1D7F stack[-3] // @1D82 stack[-6] // @1D83 stack[-5] // } 1D7E 5B JUMPDEST 1D7F 91 SWAP2 1D80 50 POP 1D81 50 POP 1D82 92 SWAP3 1D83 91 SWAP2 1D84 50 POP 1D85 50 POP 1D86 56 *JUMP // Stack delta = -5 // Outputs[1] { @1D82 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1D87: // Incoming call from 0x1DAA, returns to 0x1DAB // Incoming call from 0x2A31, returns to 0x2A32 // Inputs[1] { @1D8B stack[-1] } 1D87 5B JUMPDEST 1D88 61 PUSH2 0x1d90 1D8B 81 DUP2 1D8C 61 PUSH2 0x1b2a 1D8F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D88 stack[0] = 0x1d90 // @1D8B stack[1] = stack[-1] // } // Block ends with call to 0x1b2a, returns to 0x1D90 label_1D90: // Incoming return from call to 0x1B2A at 0x1D8F // Inputs[3] // { // @1D91 stack[-3] // @1D92 stack[-1] // @1D95 stack[-4] // } 1D90 5B JUMPDEST 1D91 82 DUP3 1D92 52 MSTORE 1D93 50 POP 1D94 50 POP 1D95 56 *JUMP // Stack delta = -4 // Outputs[1] { @1D92 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1D96: // Incoming call from 0x0289, returns to 0x028A // Inputs[2] // { // @1D9B stack[-1] // @1DA6 stack[-2] // } 1D96 5B JUMPDEST 1D97 60 PUSH1 0x00 1D99 60 PUSH1 0x20 1D9B 82 DUP3 1D9C 01 ADD 1D9D 90 SWAP1 1D9E 50 POP 1D9F 61 PUSH2 0x1dab 1DA2 60 PUSH1 0x00 1DA4 83 DUP4 1DA5 01 ADD 1DA6 84 DUP5 1DA7 61 PUSH2 0x1d87 1DAA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D9D stack[0] = stack[-1] + 0x20 // @1D9F stack[1] = 0x1dab // @1DA5 stack[2] = stack[-1] + 0x00 // @1DA6 stack[3] = stack[-2] // } // Block ends with call to 0x1d87, returns to 0x1DAB label_1DAB: // Incoming return from call to 0x1D87 at 0x1DAA // Inputs[3] // { // @1DAC stack[-1] // @1DAC stack[-4] // @1DAD stack[-3] // } 1DAB 5B JUMPDEST 1DAC 92 SWAP3 1DAD 91 SWAP2 1DAE 50 POP 1DAF 50 POP 1DB0 56 *JUMP // Stack delta = -3 // Outputs[1] { @1DAC stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1DB1: // Incoming call from 0x1DD6, returns to 0x1DD7 // Inputs[1] { @1DB5 stack[-1] } 1DB1 5B JUMPDEST 1DB2 61 PUSH2 0x1dba 1DB5 81 DUP2 1DB6 61 PUSH2 0x1a42 1DB9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1DB2 stack[0] = 0x1dba // @1DB5 stack[1] = stack[-1] // } // Block ends with call to 0x1a42, returns to 0x1DBA label_1DBA: // Incoming return from call to 0x1A42 at 0x1DB9 // Inputs[2] // { // @1DBB stack[-2] // @1DBC stack[-1] // } 1DBA 5B JUMPDEST 1DBB 81 DUP2 1DBC 14 EQ 1DBD 61 PUSH2 0x1dc5 1DC0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1dc5, if stack[-2] == stack[-1] label_1DC1: // Incoming jump from 0x1DC0, if not stack[-2] == stack[-1] // Inputs[1] { @1DC4 memory[0x00:0x00] } 1DC1 60 PUSH1 0x00 1DC3 80 DUP1 1DC4 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DC4 revert(memory[0x00:0x00]); } // Block terminates label_1DC5: // Incoming jump from 0x1DC0, if stack[-2] == stack[-1] // Inputs[1] { @1DC7 stack[-2] } 1DC5 5B JUMPDEST 1DC6 50 POP 1DC7 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1DC8: // Incoming call from 0x1E12, returns to 0x1E13 // Inputs[2] // { // @1DCB stack[-1] // @1DCC msg.data[stack[-1]:stack[-1] + 0x20] // } 1DC8 5B JUMPDEST 1DC9 60 PUSH1 0x00 1DCB 81 DUP2 1DCC 35 CALLDATALOAD 1DCD 90 SWAP1 1DCE 50 POP 1DCF 61 PUSH2 0x1dd7 1DD2 81 DUP2 1DD3 61 PUSH2 0x1db1 1DD6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1DCD stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1DCF stack[1] = 0x1dd7 // @1DD2 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x1db1, returns to 0x1DD7 label_1DD7: // Incoming return from call to 0x1DB1 at 0x1DD6 // Inputs[3] // { // @1DD8 stack[-4] // @1DD8 stack[-1] // @1DD9 stack[-3] // } 1DD7 5B JUMPDEST 1DD8 92 SWAP3 1DD9 91 SWAP2 1DDA 50 POP 1DDB 50 POP 1DDC 56 *JUMP // Stack delta = -3 // Outputs[1] { @1DD8 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1DDD: // Incoming call from 0x02ED, returns to 0x02EE // Inputs[2] // { // @1DE3 stack[-1] // @1DE4 stack[-2] // } 1DDD 5B JUMPDEST 1DDE 60 PUSH1 0x00 1DE0 80 DUP1 1DE1 60 PUSH1 0x40 1DE3 83 DUP4 1DE4 85 DUP6 1DE5 03 SUB 1DE6 12 SLT 1DE7 15 ISZERO 1DE8 61 PUSH2 0x1df4 1DEB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1DDE stack[0] = 0x00 // @1DE0 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1df4, if !(stack[-2] - stack[-1] i< 0x40) label_1DEC: // Incoming jump from 0x1DEB, if not !(stack[-2] - stack[-1] i< 0x40) 1DEC 61 PUSH2 0x1df3 1DEF 61 PUSH2 0x19b3 1DF2 56 *JUMP // Stack delta = +1 // Outputs[1] { @1DEC stack[0] = 0x1df3 } // Block ends with unconditional jump to 0x19b3 1DF3 5B JUMPDEST label_1DF4: // Incoming jump from 0x1DEB, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1DFA stack[-4] // @1DFC stack[-3] // } 1DF4 5B JUMPDEST 1DF5 60 PUSH1 0x00 1DF7 61 PUSH2 0x1e02 1DFA 85 DUP6 1DFB 82 DUP3 1DFC 86 DUP7 1DFD 01 ADD 1DFE 61 PUSH2 0x1c00 1E01 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DF5 stack[0] = 0x00 // @1DF7 stack[1] = 0x1e02 // @1DFA stack[2] = stack[-4] // @1DFD stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x1c00, returns to 0x1E02 label_1E02: // Incoming return from call to 0x1C00 at 0x1E01 // Inputs[4] // { // @1E03 stack[-4] // @1E03 stack[-1] // @1E0B stack[-6] // @1E0D stack[-5] // } 1E02 5B JUMPDEST 1E03 92 SWAP3 1E04 50 POP 1E05 50 POP 1E06 60 PUSH1 0x20 1E08 61 PUSH2 0x1e13 1E0B 85 DUP6 1E0C 82 DUP3 1E0D 86 DUP7 1E0E 01 ADD 1E0F 61 PUSH2 0x1dc8 1E12 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1E03 stack[-4] = stack[-1] // @1E06 stack[-2] = 0x20 // @1E08 stack[-1] = 0x1e13 // @1E0B stack[0] = stack[-6] // @1E0E stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x1dc8, returns to 0x1E13 label_1E13: // Incoming return from call to 0x1DC8 at 0x1E12 // Inputs[6] // { // @1E14 stack[-1] // @1E14 stack[-3] // @1E17 stack[-6] // @1E19 stack[-4] // @1E19 stack[-7] // @1E1A stack[-5] // } 1E13 5B JUMPDEST 1E14 91 SWAP2 1E15 50 POP 1E16 50 POP 1E17 92 SWAP3 1E18 50 POP 1E19 92 SWAP3 1E1A 90 SWAP1 1E1B 50 POP 1E1C 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1E17 stack[-6] = stack[-1] // @1E19 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1E1D: // Incoming jump from 0x1F0A // Inputs[1] { @1E21 memory[0x00:0x00] } 1E1D 5B JUMPDEST 1E1E 60 PUSH1 0x00 1E20 80 DUP1 1E21 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E21 revert(memory[0x00:0x00]); } // Block terminates label_1E22: // Incoming jump from 0x24E1 // Incoming jump from 0x1EB6 // Incoming jump from 0x1E77 // Inputs[1] { @1E50 memory[0x00:0x24] } 1E22 5B JUMPDEST 1E23 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 1E44 60 PUSH1 0x00 1E46 52 MSTORE 1E47 60 PUSH1 0x41 1E49 60 PUSH1 0x04 1E4B 52 MSTORE 1E4C 60 PUSH1 0x24 1E4E 60 PUSH1 0x00 1E50 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1E46 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @1E4B memory[0x04:0x24] = 0x41 // @1E50 revert(memory[0x00:0x24]); // } // Block terminates label_1E51: // Incoming call from 0x1E97, returns to 0x1E98 // Inputs[1] { @1E55 stack[-2] } 1E51 5B JUMPDEST 1E52 61 PUSH2 0x1e5a 1E55 82 DUP3 1E56 61 PUSH2 0x1abe 1E59 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1E52 stack[0] = 0x1e5a // @1E55 stack[1] = stack[-2] // } // Block ends with call to 0x1abe, returns to 0x1E5A label_1E5A: // Incoming return from call to 0x1ABE at 0x1E59 // Inputs[2] // { // @1E5B stack[-2] // @1E5C stack[-1] // } 1E5A 5B JUMPDEST 1E5B 81 DUP2 1E5C 01 ADD 1E5D 81 DUP2 1E5E 81 DUP2 1E5F 10 LT 1E60 67 PUSH8 0xffffffffffffffff 1E69 82 DUP3 1E6A 11 GT 1E6B 17 OR 1E6C 15 ISZERO 1E6D 61 PUSH2 0x1e79 1E70 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1E5C stack[-1] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x1e79, if !((stack[-2] + stack[-1] > 0xffffffffffffffff) | (stack[-2] + stack[-1] < stack[-2])) label_1E71: // Incoming jump from 0x1E70, if not !((stack[-2] + stack[-1] > 0xffffffffffffffff) | (stack[-2] + stack[-1] < stack[-2])) 1E71 61 PUSH2 0x1e78 1E74 61 PUSH2 0x1e22 1E77 56 *JUMP // Stack delta = +1 // Outputs[1] { @1E71 stack[0] = 0x1e78 } // Block ends with unconditional jump to 0x1e22 1E78 5B JUMPDEST label_1E79: // Incoming jump from 0x1E70, if !((stack[-2] + stack[-1] > 0xffffffffffffffff) | (stack[-2] + stack[-1] < stack[-2])) // Inputs[2] // { // @1E7A stack[-1] // @1E81 stack[-4] // } 1E79 5B JUMPDEST 1E7A 80 DUP1 1E7B 60 PUSH1 0x40 1E7D 52 MSTORE 1E7E 50 POP 1E7F 50 POP 1E80 50 POP 1E81 56 *JUMP // Stack delta = -4 // Outputs[1] { @1E7D memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1E82: // Incoming jump from 0x1EEF 1E82 5B JUMPDEST 1E83 60 PUSH1 0x00 1E85 61 PUSH2 0x1e8c 1E88 61 PUSH2 0x19a9 1E8B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1E83 stack[0] = 0x00 // @1E85 stack[1] = 0x1e8c // } // Block ends with call to 0x19a9, returns to 0x1E8C label_1E8C: // Incoming return from call to 0x19A9 at 0x1E8B // Inputs[3] // { // @1E8D stack[-2] // @1E8D stack[-1] // @1E92 stack[-3] // } 1E8C 5B JUMPDEST 1E8D 90 SWAP1 1E8E 50 POP 1E8F 61 PUSH2 0x1e98 1E92 82 DUP3 1E93 82 DUP3 1E94 61 PUSH2 0x1e51 1E97 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1E8D stack[-2] = stack[-1] // @1E8F stack[-1] = 0x1e98 // @1E92 stack[0] = stack[-3] // @1E93 stack[1] = stack[-1] // } // Block ends with call to 0x1e51, returns to 0x1E98 label_1E98: // Incoming return from call to 0x1E51 at 0x1E97 // Inputs[3] // { // @1E99 stack[-1] // @1E99 stack[-3] // @1E9A stack[-2] // } 1E98 5B JUMPDEST 1E99 91 SWAP2 1E9A 90 SWAP1 1E9B 50 POP 1E9C 56 *JUMP // Stack delta = -2 // Outputs[1] { @1E99 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1E9D: // Incoming call from 0x1EEA, returns to 0x1EEB // Inputs[1] { @1EA9 stack[-1] } 1E9D 5B JUMPDEST 1E9E 60 PUSH1 0x00 1EA0 67 PUSH8 0xffffffffffffffff 1EA9 82 DUP3 1EAA 11 GT 1EAB 15 ISZERO 1EAC 61 PUSH2 0x1eb8 1EAF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E9E stack[0] = 0x00 } // Block ends with conditional jump to 0x1eb8, if !(stack[-1] > 0xffffffffffffffff) label_1EB0: // Incoming jump from 0x1EAF, if not !(stack[-1] > 0xffffffffffffffff) 1EB0 61 PUSH2 0x1eb7 1EB3 61 PUSH2 0x1e22 1EB6 56 *JUMP // Stack delta = +1 // Outputs[1] { @1EB0 stack[0] = 0x1eb7 } // Block ends with unconditional jump to 0x1e22 1EB7 5B JUMPDEST label_1EB8: // Incoming jump from 0x1EAF, if !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @1EBC stack[-2] } 1EB8 5B JUMPDEST 1EB9 61 PUSH2 0x1ec1 1EBC 82 DUP3 1EBD 61 PUSH2 0x1abe 1EC0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1EB9 stack[0] = 0x1ec1 // @1EBC stack[1] = stack[-2] // } // Block ends with call to 0x1abe, returns to 0x1EC1 label_1EC1: // Incoming return from call to 0x1ABE at 0x1EC0 // Inputs[4] // { // @1EC2 stack[-1] // @1EC2 stack[-2] // @1ECA stack[-4] // @1ECB stack[-3] // } 1EC1 5B JUMPDEST 1EC2 90 SWAP1 1EC3 50 POP 1EC4 60 PUSH1 0x20 1EC6 81 DUP2 1EC7 01 ADD 1EC8 90 SWAP1 1EC9 50 POP 1ECA 91 SWAP2 1ECB 90 SWAP1 1ECC 50 POP 1ECD 56 *JUMP // Stack delta = -3 // Outputs[1] { @1ECA stack[-4] = stack[-1] + 0x20 } // Block ends with unconditional jump to stack[-4] label_1ECE: // Incoming call from 0x1F16, returns to 0x1F17 // Inputs[5] // { // @1ECF stack[-3] // @1ED0 stack[-1] // @1ED1 stack[-2] // @1ED2 msg.data[stack[-1]:stack[-1] + stack[-3]] // @1EDC stack[-4] // } 1ECE 5B JUMPDEST 1ECF 82 DUP3 1ED0 81 DUP2 1ED1 83 DUP4 1ED2 37 CALLDATACOPY 1ED3 60 PUSH1 0x00 1ED5 83 DUP4 1ED6 83 DUP4 1ED7 01 ADD 1ED8 52 MSTORE 1ED9 50 POP 1EDA 50 POP 1EDB 50 POP 1EDC 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1ED2 memory[stack[-2]:stack[-2] + stack[-3]] = msg.data[stack[-1]:stack[-1] + stack[-3]] // @1ED8 memory[stack[-2] + stack[-3]:stack[-2] + stack[-3] + 0x20] = 0x00 // } // Block ends with unconditional jump to stack[-4] label_1EDD: // Incoming call from 0x1F43, returns to 0x1F44 // Inputs[1] { @1EE6 stack[-2] } 1EDD 5B JUMPDEST 1EDE 60 PUSH1 0x00 1EE0 61 PUSH2 0x1ef0 1EE3 61 PUSH2 0x1eeb 1EE6 84 DUP5 1EE7 61 PUSH2 0x1e9d 1EEA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1EDE stack[0] = 0x00 // @1EE0 stack[1] = 0x1ef0 // @1EE3 stack[2] = 0x1eeb // @1EE6 stack[3] = stack[-2] // } // Block ends with call to 0x1e9d, returns to 0x1EEB label_1EEB: // Incoming return from call to 0x1E9D at 0x1EEA 1EEB 5B JUMPDEST 1EEC 61 PUSH2 0x1e82 1EEF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1e82 label_1EF0: // Incoming return from call to 0x1EEB at 0x1EEA // Inputs[5] // { // @1EF1 stack[-1] // @1EF1 stack[-2] // @1EF3 stack[-4] // @1EFA stack[-5] // @1EFC stack[-3] // } 1EF0 5B JUMPDEST 1EF1 90 SWAP1 1EF2 50 POP 1EF3 82 DUP3 1EF4 81 DUP2 1EF5 52 MSTORE 1EF6 60 PUSH1 0x20 1EF8 81 DUP2 1EF9 01 ADD 1EFA 84 DUP5 1EFB 84 DUP5 1EFC 84 DUP5 1EFD 01 ADD 1EFE 11 GT 1EFF 15 ISZERO 1F00 61 PUSH2 0x1f0c 1F03 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1EF1 stack[-2] = stack[-1] // @1EF5 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @1EF9 stack[-1] = stack[-1] + 0x20 // } // Block ends with conditional jump to 0x1f0c, if !(stack[-3] + stack[-4] > stack[-5]) label_1F04: // Incoming jump from 0x1F03, if not !(stack[-3] + stack[-4] > stack[-5]) 1F04 61 PUSH2 0x1f0b 1F07 61 PUSH2 0x1e1d 1F0A 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F04 stack[0] = 0x1f0b } // Block ends with unconditional jump to 0x1e1d 1F0B 5B JUMPDEST label_1F0C: // Incoming jump from 0x1F03, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[3] // { // @1F10 stack[-4] // @1F11 stack[-1] // @1F12 stack[-3] // } 1F0C 5B JUMPDEST 1F0D 61 PUSH2 0x1f17 1F10 84 DUP5 1F11 82 DUP3 1F12 85 DUP6 1F13 61 PUSH2 0x1ece 1F16 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F0D stack[0] = 0x1f17 // @1F10 stack[1] = stack[-4] // @1F11 stack[2] = stack[-1] // @1F12 stack[3] = stack[-3] // } // Block ends with call to 0x1ece, returns to 0x1F17 label_1F17: // Incoming return from call to 0x1ECE at 0x1F16 // Inputs[3] // { // @1F19 stack[-2] // @1F19 stack[-6] // @1F1A stack[-5] // } 1F17 5B JUMPDEST 1F18 50 POP 1F19 93 SWAP4 1F1A 92 SWAP3 1F1B 50 POP 1F1C 50 POP 1F1D 50 POP 1F1E 56 *JUMP // Stack delta = -5 // Outputs[1] { @1F19 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_1F1F: // Incoming call from 0x1FC3, returns to 0x1FC4 // Inputs[2] // { // @1F22 stack[-2] // @1F25 stack[-1] // } 1F1F 5B JUMPDEST 1F20 60 PUSH1 0x00 1F22 82 DUP3 1F23 60 PUSH1 0x1f 1F25 83 DUP4 1F26 01 ADD 1F27 12 SLT 1F28 61 PUSH2 0x1f34 1F2B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F20 stack[0] = 0x00 } // Block ends with conditional jump to 0x1f34, if stack[-1] + 0x1f i< stack[-2] label_1F2C: // Incoming jump from 0x1F2B, if not stack[-1] + 0x1f i< stack[-2] 1F2C 61 PUSH2 0x1f33 1F2F 61 PUSH2 0x1ca8 1F32 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F2C stack[0] = 0x1f33 } // Block ends with unconditional jump to 0x1ca8 1F33 5B JUMPDEST label_1F34: // Incoming jump from 0x1F2B, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @1F35 stack[-2] // @1F36 msg.data[stack[-2]:stack[-2] + 0x20] // @1F3A stack[-3] // } 1F34 5B JUMPDEST 1F35 81 DUP2 1F36 35 CALLDATALOAD 1F37 61 PUSH2 0x1f44 1F3A 84 DUP5 1F3B 82 DUP3 1F3C 60 PUSH1 0x20 1F3E 86 DUP7 1F3F 01 ADD 1F40 61 PUSH2 0x1edd 1F43 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1F36 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1F37 stack[1] = 0x1f44 // @1F3A stack[2] = stack[-3] // @1F3B stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // @1F3F stack[4] = stack[-2] + 0x20 // } // Block ends with call to 0x1edd, returns to 0x1F44 label_1F44: // Incoming return from call to 0x1EDD at 0x1F43 // Inputs[4] // { // @1F45 stack[-3] // @1F45 stack[-1] // @1F48 stack[-6] // @1F49 stack[-5] // } 1F44 5B JUMPDEST 1F45 91 SWAP2 1F46 50 POP 1F47 50 POP 1F48 92 SWAP3 1F49 91 SWAP2 1F4A 50 POP 1F4B 50 POP 1F4C 56 *JUMP // Stack delta = -5 // Outputs[1] { @1F48 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1F4D: // Incoming call from 0x0309, returns to 0x030A // Inputs[2] // { // @1F56 stack[-1] // @1F57 stack[-2] // } 1F4D 5B JUMPDEST 1F4E 60 PUSH1 0x00 1F50 80 DUP1 1F51 60 PUSH1 0x00 1F53 80 DUP1 1F54 60 PUSH1 0x80 1F56 85 DUP6 1F57 87 DUP8 1F58 03 SUB 1F59 12 SLT 1F5A 15 ISZERO 1F5B 61 PUSH2 0x1f67 1F5E 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1F4E stack[0] = 0x00 // @1F50 stack[1] = 0x00 // @1F51 stack[2] = 0x00 // @1F53 stack[3] = 0x00 // } // Block ends with conditional jump to 0x1f67, if !(stack[-2] - stack[-1] i< 0x80) label_1F5F: // Incoming jump from 0x1F5E, if not !(stack[-2] - stack[-1] i< 0x80) 1F5F 61 PUSH2 0x1f66 1F62 61 PUSH2 0x19b3 1F65 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F5F stack[0] = 0x1f66 } // Block ends with unconditional jump to 0x19b3 1F66 5B JUMPDEST label_1F67: // Incoming jump from 0x1F5E, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @1F6D stack[-6] // @1F6F stack[-5] // } 1F67 5B JUMPDEST 1F68 60 PUSH1 0x00 1F6A 61 PUSH2 0x1f75 1F6D 87 DUP8 1F6E 82 DUP3 1F6F 88 DUP9 1F70 01 ADD 1F71 61 PUSH2 0x1c00 1F74 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F68 stack[0] = 0x00 // @1F6A stack[1] = 0x1f75 // @1F6D stack[2] = stack[-6] // @1F70 stack[3] = stack[-5] + 0x00 // } // Block ends with call to 0x1c00, returns to 0x1F75 label_1F75: // Incoming return from call to 0x1C00 at 0x1F74 // Inputs[4] // { // @1F76 stack[-6] // @1F76 stack[-1] // @1F7E stack[-8] // @1F80 stack[-7] // } 1F75 5B JUMPDEST 1F76 94 SWAP5 1F77 50 POP 1F78 50 POP 1F79 60 PUSH1 0x20 1F7B 61 PUSH2 0x1f86 1F7E 87 DUP8 1F7F 82 DUP3 1F80 88 DUP9 1F81 01 ADD 1F82 61 PUSH2 0x1c00 1F85 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1F76 stack[-6] = stack[-1] // @1F79 stack[-2] = 0x20 // @1F7B stack[-1] = 0x1f86 // @1F7E stack[0] = stack[-8] // @1F81 stack[1] = stack[-7] + 0x20 // } // Block ends with call to 0x1c00, returns to 0x1F86 label_1F86: // Incoming return from call to 0x1C00 at 0x1F85 // Inputs[4] // { // @1F87 stack[-1] // @1F87 stack[-5] // @1F8F stack[-8] // @1F91 stack[-7] // } 1F86 5B JUMPDEST 1F87 93 SWAP4 1F88 50 POP 1F89 50 POP 1F8A 60 PUSH1 0x40 1F8C 61 PUSH2 0x1f97 1F8F 87 DUP8 1F90 82 DUP3 1F91 88 DUP9 1F92 01 ADD 1F93 61 PUSH2 0x1b4b 1F96 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1F87 stack[-5] = stack[-1] // @1F8A stack[-2] = 0x40 // @1F8C stack[-1] = 0x1f97 // @1F8F stack[0] = stack[-8] // @1F92 stack[1] = stack[-7] + 0x40 // } // Block ends with call to 0x1b4b, returns to 0x1F97 label_1F97: // Incoming return from call to 0x1B4B at 0x1F96 // Inputs[4] // { // @1F98 stack[-1] // @1F98 stack[-4] // @1F9D stack[-7] // @1F9F msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // } 1F97 5B JUMPDEST 1F98 92 SWAP3 1F99 50 POP 1F9A 50 POP 1F9B 60 PUSH1 0x60 1F9D 85 DUP6 1F9E 01 ADD 1F9F 35 CALLDATALOAD 1FA0 67 PUSH8 0xffffffffffffffff 1FA9 81 DUP2 1FAA 11 GT 1FAB 15 ISZERO 1FAC 61 PUSH2 0x1fb8 1FAF 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1F98 stack[-4] = stack[-1] // @1F9F stack[-2] = msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x1fb8, if !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) label_1FB0: // Incoming jump from 0x1FAF, if not !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) 1FB0 61 PUSH2 0x1fb7 1FB3 61 PUSH2 0x19b8 1FB6 56 *JUMP // Stack delta = +1 // Outputs[1] { @1FB0 stack[0] = 0x1fb7 } // Block ends with unconditional jump to 0x19b8 1FB7 5B JUMPDEST label_1FB8: // Incoming jump from 0x1FAF, if !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1FBC stack[-7] // @1FBD stack[-1] // @1FBE stack[-6] // } 1FB8 5B JUMPDEST 1FB9 61 PUSH2 0x1fc4 1FBC 87 DUP8 1FBD 82 DUP3 1FBE 88 DUP9 1FBF 01 ADD 1FC0 61 PUSH2 0x1f1f 1FC3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1FB9 stack[0] = 0x1fc4 // @1FBC stack[1] = stack[-7] // @1FBF stack[2] = stack[-6] + stack[-1] // } // Block ends with call to 0x1f1f, returns to 0x1FC4 label_1FC4: // Incoming return from call to 0x1F1F at 0x1FC3 // Inputs[8] // { // @1FC5 stack[-1] // @1FC5 stack[-3] // @1FC8 stack[-6] // @1FC9 stack[-9] // @1FCA stack[-5] // @1FCB stack[-8] // @1FCD stack[-4] // @1FCD stack[-7] // } 1FC4 5B JUMPDEST 1FC5 91 SWAP2 1FC6 50 POP 1FC7 50 POP 1FC8 92 SWAP3 1FC9 95 SWAP6 1FCA 91 SWAP2 1FCB 94 SWAP5 1FCC 50 POP 1FCD 92 SWAP3 1FCE 50 POP 1FCF 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @1FC8 stack[-6] = stack[-1] // @1FC9 stack[-9] = stack[-6] // @1FCB stack[-8] = stack[-5] // @1FCD stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_1FD0: // Incoming call from 0x035F, returns to 0x0360 // Inputs[2] // { // @1FD6 stack[-1] // @1FD7 stack[-2] // } 1FD0 5B JUMPDEST 1FD1 60 PUSH1 0x00 1FD3 80 DUP1 1FD4 60 PUSH1 0x40 1FD6 83 DUP4 1FD7 85 DUP6 1FD8 03 SUB 1FD9 12 SLT 1FDA 15 ISZERO 1FDB 61 PUSH2 0x1fe7 1FDE 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1FD1 stack[0] = 0x00 // @1FD3 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1fe7, if !(stack[-2] - stack[-1] i< 0x40) label_1FDF: // Incoming jump from 0x1FDE, if not !(stack[-2] - stack[-1] i< 0x40) 1FDF 61 PUSH2 0x1fe6 1FE2 61 PUSH2 0x19b3 1FE5 56 *JUMP // Stack delta = +1 // Outputs[1] { @1FDF stack[0] = 0x1fe6 } // Block ends with unconditional jump to 0x19b3 1FE6 5B JUMPDEST label_1FE7: // Incoming jump from 0x1FDE, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1FED stack[-4] // @1FEF stack[-3] // } 1FE7 5B JUMPDEST 1FE8 60 PUSH1 0x00 1FEA 61 PUSH2 0x1ff5 1FED 85 DUP6 1FEE 82 DUP3 1FEF 86 DUP7 1FF0 01 ADD 1FF1 61 PUSH2 0x1c00 1FF4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1FE8 stack[0] = 0x00 // @1FEA stack[1] = 0x1ff5 // @1FED stack[2] = stack[-4] // @1FF0 stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x1c00, returns to 0x1FF5 label_1FF5: // Incoming return from call to 0x1C00 at 0x1FF4 // Inputs[4] // { // @1FF6 stack[-4] // @1FF6 stack[-1] // @1FFE stack[-6] // @2000 stack[-5] // } 1FF5 5B JUMPDEST 1FF6 92 SWAP3 1FF7 50 POP 1FF8 50 POP 1FF9 60 PUSH1 0x20 1FFB 61 PUSH2 0x2006 1FFE 85 DUP6 1FFF 82 DUP3 2000 86 DUP7 2001 01 ADD 2002 61 PUSH2 0x1c00 2005 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1FF6 stack[-4] = stack[-1] // @1FF9 stack[-2] = 0x20 // @1FFB stack[-1] = 0x2006 // @1FFE stack[0] = stack[-6] // @2001 stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x1c00, returns to 0x2006 label_2006: // Incoming return from call to 0x1C00 at 0x2005 // Inputs[6] // { // @2007 stack[-3] // @2007 stack[-1] // @200A stack[-6] // @200C stack[-4] // @200C stack[-7] // @200D stack[-5] // } 2006 5B JUMPDEST 2007 91 SWAP2 2008 50 POP 2009 50 POP 200A 92 SWAP3 200B 50 POP 200C 92 SWAP3 200D 90 SWAP1 200E 50 POP 200F 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @200A stack[-6] = stack[-1] // @200C stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_2010: // Incoming jump from 0x2068 // Inputs[1] { @203E memory[0x00:0x24] } 2010 5B JUMPDEST 2011 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 2032 60 PUSH1 0x00 2034 52 MSTORE 2035 60 PUSH1 0x22 2037 60 PUSH1 0x04 2039 52 MSTORE 203A 60 PUSH1 0x24 203C 60 PUSH1 0x00 203E FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2034 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @2039 memory[0x04:0x24] = 0x22 // @203E revert(memory[0x00:0x24]); // } // Block terminates label_203F: // Incoming call from 0x095B, returns to 0x095C // Incoming call from 0x24EC, returns to 0x24ED // Incoming call from 0x04B3, returns to 0x04B4 // Incoming call from 0x14B6, returns to 0x14B7 // Incoming call from 0x0487, returns to 0x0488 // Incoming call from 0x092F, returns to 0x0930 // Incoming call from 0x14E2, returns to 0x14E3 // Inputs[1] { @2044 stack[-1] } 203F 5B JUMPDEST 2040 60 PUSH1 0x00 2042 60 PUSH1 0x02 2044 82 DUP3 2045 04 DIV 2046 90 SWAP1 2047 50 POP 2048 60 PUSH1 0x01 204A 82 DUP3 204B 16 AND 204C 80 DUP1 204D 61 PUSH2 0x2057 2050 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2046 stack[0] = stack[-1] / 0x02 // @204B stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x2057, if stack[-1] & 0x01 label_2051: // Incoming jump from 0x2050, if not stack[-1] & 0x01 // Inputs[2] // { // @2053 stack[-2] // @205C stack[-1] // } 2051 60 PUSH1 0x7f 2053 82 DUP3 2054 16 AND 2055 91 SWAP2 2056 50 POP 2057 5B JUMPDEST 2058 60 PUSH1 0x20 205A 82 DUP3 205B 10 LT 205C 81 DUP2 205D 03 SUB 205E 61 PUSH2 0x206a 2061 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2055 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x206a, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_2062: // Incoming jump from 0x2061, if not stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x2061, if not stack[-1] - (stack[-2] & 0x7f < 0x20) 2062 61 PUSH2 0x2069 2065 61 PUSH2 0x2010 2068 56 *JUMP // Stack delta = +1 // Outputs[1] { @2062 stack[0] = 0x2069 } // Block ends with unconditional jump to 0x2010 2069 5B JUMPDEST label_206A: // Incoming jump from 0x2061, if stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x2061, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[3] // { // @206C stack[-2] // @206C stack[-4] // @206D stack[-3] // } 206A 5B JUMPDEST 206B 50 POP 206C 91 SWAP2 206D 90 SWAP1 206E 50 POP 206F 56 *JUMP // Stack delta = -3 // Outputs[1] { @206C stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_2070: // Incoming call from 0x20D6, returns to 0x20D7 // Inputs[2] // { // @2094 stack[-1] // @20BE stack[-2] // } 2070 5B JUMPDEST 2071 7F PUSH32 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 2092 60 PUSH1 0x00 2094 82 DUP3 2095 01 ADD 2096 52 MSTORE 2097 7F PUSH32 0x7200000000000000000000000000000000000000000000000000000000000000 20B8 60 PUSH1 0x20 20BA 82 DUP3 20BB 01 ADD 20BC 52 MSTORE 20BD 50 POP 20BE 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2096 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 // @20BC memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x7200000000000000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_20BF: // Incoming call from 0x20FA, returns to 0x20FB // Inputs[1] { @20C7 stack[-1] } 20BF 5B JUMPDEST 20C0 60 PUSH1 0x00 20C2 61 PUSH2 0x20cc 20C5 60 PUSH1 0x21 20C7 83 DUP4 20C8 61 PUSH2 0x1a83 20CB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @20C0 stack[0] = 0x00 // @20C2 stack[1] = 0x20cc // @20C5 stack[2] = 0x21 // @20C7 stack[3] = stack[-1] // } // Block ends with call to 0x1a83, returns to 0x20CC label_20CC: // Incoming return from call to 0x1A83 at 0x20CB // Inputs[2] // { // @20CD stack[-3] // @20CD stack[-1] // } 20CC 5B JUMPDEST 20CD 91 SWAP2 20CE 50 POP 20CF 61 PUSH2 0x20d7 20D2 82 DUP3 20D3 61 PUSH2 0x2070 20D6 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @20CD stack[-3] = stack[-1] // @20CF stack[-1] = 0x20d7 // @20D2 stack[0] = stack[-1] // } // Block ends with call to 0x2070, returns to 0x20D7 label_20D7: // Incoming return from call to 0x2070 at 0x20D6 // Inputs[3] // { // @20DA stack[-2] // @20DC stack[-1] // @20DE stack[-3] // } 20D7 5B JUMPDEST 20D8 60 PUSH1 0x40 20DA 82 DUP3 20DB 01 ADD 20DC 90 SWAP1 20DD 50 POP 20DE 91 SWAP2 20DF 90 SWAP1 20E0 50 POP 20E1 56 *JUMP // Stack delta = -2 // Outputs[1] { @20DE stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_20E2: // Incoming call from 0x05C2, returns to 0x05C3 // Inputs[1] { @20E7 stack[-1] } 20E2 5B JUMPDEST 20E3 60 PUSH1 0x00 20E5 60 PUSH1 0x20 20E7 82 DUP3 20E8 01 ADD 20E9 90 SWAP1 20EA 50 POP 20EB 81 DUP2 20EC 81 DUP2 20ED 03 SUB 20EE 60 PUSH1 0x00 20F0 83 DUP4 20F1 01 ADD 20F2 52 MSTORE 20F3 61 PUSH2 0x20fb 20F6 81 DUP2 20F7 61 PUSH2 0x20bf 20FA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @20E9 stack[0] = stack[-1] + 0x20 // @20F2 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @20F3 stack[1] = 0x20fb // @20F6 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x20bf, returns to 0x20FB label_20FB: // Incoming return from call to 0x20BF at 0x20FA // Inputs[4] // { // @20FC stack[-1] // @20FC stack[-2] // @20FE stack[-4] // @20FF stack[-3] // } 20FB 5B JUMPDEST 20FC 90 SWAP1 20FD 50 POP 20FE 91 SWAP2 20FF 90 SWAP1 2100 50 POP 2101 56 *JUMP // Stack delta = -3 // Outputs[1] { @20FE stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2102: // Incoming call from 0x2168, returns to 0x2169 // Inputs[2] // { // @2126 stack[-1] // @2150 stack[-2] // } 2102 5B JUMPDEST 2103 7F PUSH32 0x4552433732313a20617070726f76652063616c6c6572206973206e6f7420746f 2124 60 PUSH1 0x00 2126 82 DUP3 2127 01 ADD 2128 52 MSTORE 2129 7F PUSH32 0x6b656e206f776e6572206f7220617070726f76656420666f7220616c6c000000 214A 60 PUSH1 0x20 214C 82 DUP3 214D 01 ADD 214E 52 MSTORE 214F 50 POP 2150 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2128 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a20617070726f76652063616c6c6572206973206e6f7420746f // @214E memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x6b656e206f776e6572206f7220617070726f76656420666f7220616c6c000000 // } // Block ends with unconditional jump to stack[-2] label_2151: // Incoming call from 0x218C, returns to 0x218D // Inputs[1] { @2159 stack[-1] } 2151 5B JUMPDEST 2152 60 PUSH1 0x00 2154 61 PUSH2 0x215e 2157 60 PUSH1 0x3d 2159 83 DUP4 215A 61 PUSH2 0x1a83 215D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2152 stack[0] = 0x00 // @2154 stack[1] = 0x215e // @2157 stack[2] = 0x3d // @2159 stack[3] = stack[-1] // } // Block ends with call to 0x1a83, returns to 0x215E label_215E: // Incoming return from call to 0x1A83 at 0x215D // Inputs[2] // { // @215F stack[-3] // @215F stack[-1] // } 215E 5B JUMPDEST 215F 91 SWAP2 2160 50 POP 2161 61 PUSH2 0x2169 2164 82 DUP3 2165 61 PUSH2 0x2102 2168 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @215F stack[-3] = stack[-1] // @2161 stack[-1] = 0x2169 // @2164 stack[0] = stack[-1] // } // Block ends with call to 0x2102, returns to 0x2169 label_2169: // Incoming return from call to 0x2102 at 0x2168 // Inputs[3] // { // @216C stack[-2] // @216E stack[-1] // @2170 stack[-3] // } 2169 5B JUMPDEST 216A 60 PUSH1 0x40 216C 82 DUP3 216D 01 ADD 216E 90 SWAP1 216F 50 POP 2170 91 SWAP2 2171 90 SWAP1 2172 50 POP 2173 56 *JUMP // Stack delta = -2 // Outputs[1] { @2170 stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_2174: // Incoming call from 0x064F, returns to 0x0650 // Inputs[1] { @2179 stack[-1] } 2174 5B JUMPDEST 2175 60 PUSH1 0x00 2177 60 PUSH1 0x20 2179 82 DUP3 217A 01 ADD 217B 90 SWAP1 217C 50 POP 217D 81 DUP2 217E 81 DUP2 217F 03 SUB 2180 60 PUSH1 0x00 2182 83 DUP4 2183 01 ADD 2184 52 MSTORE 2185 61 PUSH2 0x218d 2188 81 DUP2 2189 61 PUSH2 0x2151 218C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @217B stack[0] = stack[-1] + 0x20 // @2184 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2185 stack[1] = 0x218d // @2188 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2151, returns to 0x218D label_218D: // Incoming return from call to 0x2151 at 0x218C // Inputs[4] // { // @218E stack[-1] // @218E stack[-2] // @2190 stack[-4] // @2191 stack[-3] // } 218D 5B JUMPDEST 218E 90 SWAP1 218F 50 POP 2190 91 SWAP2 2191 90 SWAP1 2192 50 POP 2193 56 *JUMP // Stack delta = -3 // Outputs[1] { @2190 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2194: // Incoming jump from 0x21FE // Inputs[1] { @21C2 memory[0x00:0x24] } 2194 5B JUMPDEST 2195 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 21B6 60 PUSH1 0x00 21B8 52 MSTORE 21B9 60 PUSH1 0x11 21BB 60 PUSH1 0x04 21BD 52 MSTORE 21BE 60 PUSH1 0x24 21C0 60 PUSH1 0x00 21C2 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @21B8 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @21BD memory[0x04:0x24] = 0x11 // @21C2 revert(memory[0x00:0x24]); // } // Block terminates label_21C3: // Incoming call from 0x06D4, returns to 0x06D5 // Inputs[1] { @21C9 stack[-1] } 21C3 5B JUMPDEST 21C4 60 PUSH1 0x00 21C6 61 PUSH2 0x21ce 21C9 82 DUP3 21CA 61 PUSH2 0x1b2a 21CD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @21C4 stack[0] = 0x00 // @21C6 stack[1] = 0x21ce // @21C9 stack[2] = stack[-1] // } // Block ends with call to 0x1b2a, returns to 0x21CE label_21CE: // Incoming return from call to 0x1B2A at 0x21CD // Inputs[2] // { // @21CF stack[-3] // @21CF stack[-1] // } 21CE 5B JUMPDEST 21CF 91 SWAP2 21D0 50 POP 21D1 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 21F2 82 DUP3 21F3 03 SUB 21F4 61 PUSH2 0x2200 21F7 57 *JUMPI // Stack delta = -1 // Outputs[1] { @21CF stack[-3] = stack[-1] } // Block ends with conditional jump to 0x2200, if stack[-1] - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff label_21F8: // Incoming jump from 0x21F7, if not stack[-1] - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 21F8 61 PUSH2 0x21ff 21FB 61 PUSH2 0x2194 21FE 56 *JUMP // Stack delta = +1 // Outputs[1] { @21F8 stack[0] = 0x21ff } // Block ends with unconditional jump to 0x2194 21FF 5B JUMPDEST label_2200: // Incoming jump from 0x21F7, if stack[-1] - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // Inputs[3] // { // @2203 stack[-2] // @2205 stack[-1] // @2207 stack[-3] // } 2200 5B JUMPDEST 2201 60 PUSH1 0x01 2203 82 DUP3 2204 01 ADD 2205 90 SWAP1 2206 50 POP 2207 91 SWAP2 2208 90 SWAP1 2209 50 POP 220A 56 *JUMP // Stack delta = -2 // Outputs[1] { @2207 stack[-3] = stack[-2] + 0x01 } // Block ends with unconditional jump to stack[-3] label_220B: // Incoming call from 0x2271, returns to 0x2272 // Inputs[2] // { // @222F stack[-1] // @2259 stack[-2] // } 220B 5B JUMPDEST 220C 7F PUSH32 0x4552433732313a2063616c6c6572206973206e6f7420746f6b656e206f776e65 222D 60 PUSH1 0x00 222F 82 DUP3 2230 01 ADD 2231 52 MSTORE 2232 7F PUSH32 0x72206f7220617070726f76656400000000000000000000000000000000000000 2253 60 PUSH1 0x20 2255 82 DUP3 2256 01 ADD 2257 52 MSTORE 2258 50 POP 2259 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2231 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a2063616c6c6572206973206e6f7420746f6b656e206f776e65 // @2257 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x72206f7220617070726f76656400000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_225A: // Incoming call from 0x2295, returns to 0x2296 // Inputs[1] { @2262 stack[-1] } 225A 5B JUMPDEST 225B 60 PUSH1 0x00 225D 61 PUSH2 0x2267 2260 60 PUSH1 0x2d 2262 83 DUP4 2263 61 PUSH2 0x1a83 2266 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @225B stack[0] = 0x00 // @225D stack[1] = 0x2267 // @2260 stack[2] = 0x2d // @2262 stack[3] = stack[-1] // } // Block ends with call to 0x1a83, returns to 0x2267 label_2267: // Incoming return from call to 0x1A83 at 0x2266 // Inputs[2] // { // @2268 stack[-3] // @2268 stack[-1] // } 2267 5B JUMPDEST 2268 91 SWAP2 2269 50 POP 226A 61 PUSH2 0x2272 226D 82 DUP3 226E 61 PUSH2 0x220b 2271 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2268 stack[-3] = stack[-1] // @226A stack[-1] = 0x2272 // @226D stack[0] = stack[-1] // } // Block ends with call to 0x220b, returns to 0x2272 label_2272: // Incoming return from call to 0x220B at 0x2271 // Inputs[3] // { // @2275 stack[-2] // @2277 stack[-1] // @2279 stack[-3] // } 2272 5B JUMPDEST 2273 60 PUSH1 0x40 2275 82 DUP3 2276 01 ADD 2277 90 SWAP1 2278 50 POP 2279 91 SWAP2 227A 90 SWAP1 227B 50 POP 227C 56 *JUMP // Stack delta = -2 // Outputs[1] { @2279 stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_227D: // Incoming call from 0x072A, returns to 0x072B // Incoming call from 0x0A0F, returns to 0x0A10 // Inputs[1] { @2282 stack[-1] } 227D 5B JUMPDEST 227E 60 PUSH1 0x00 2280 60 PUSH1 0x20 2282 82 DUP3 2283 01 ADD 2284 90 SWAP1 2285 50 POP 2286 81 DUP2 2287 81 DUP2 2288 03 SUB 2289 60 PUSH1 0x00 228B 83 DUP4 228C 01 ADD 228D 52 MSTORE 228E 61 PUSH2 0x2296 2291 81 DUP2 2292 61 PUSH2 0x225a 2295 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2284 stack[0] = stack[-1] + 0x20 // @228D memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @228E stack[1] = 0x2296 // @2291 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x225a, returns to 0x2296 label_2296: // Incoming return from call to 0x225A at 0x2295 // Inputs[4] // { // @2297 stack[-2] // @2297 stack[-1] // @2299 stack[-4] // @229A stack[-3] // } 2296 5B JUMPDEST 2297 90 SWAP1 2298 50 POP 2299 91 SWAP2 229A 90 SWAP1 229B 50 POP 229C 56 *JUMP // Stack delta = -3 // Outputs[1] { @2299 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_229D: // Incoming call from 0x22DD, returns to 0x22DE // Inputs[2] // { // @22C1 stack[-1] // @22C5 stack[-2] // } 229D 5B JUMPDEST 229E 7F PUSH32 0x4552433732313a20696e76616c696420746f6b656e2049440000000000000000 22BF 60 PUSH1 0x00 22C1 82 DUP3 22C2 01 ADD 22C3 52 MSTORE 22C4 50 POP 22C5 56 *JUMP // Stack delta = -2 // Outputs[1] { @22C3 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a20696e76616c696420746f6b656e2049440000000000000000 } // Block ends with unconditional jump to stack[-2] label_22C6: // Incoming call from 0x2301, returns to 0x2302 // Inputs[1] { @22CE stack[-1] } 22C6 5B JUMPDEST 22C7 60 PUSH1 0x00 22C9 61 PUSH2 0x22d3 22CC 60 PUSH1 0x18 22CE 83 DUP4 22CF 61 PUSH2 0x1a83 22D2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @22C7 stack[0] = 0x00 // @22C9 stack[1] = 0x22d3 // @22CC stack[2] = 0x18 // @22CE stack[3] = stack[-1] // } // Block ends with call to 0x1a83, returns to 0x22D3 label_22D3: // Incoming return from call to 0x1A83 at 0x22D2 // Inputs[2] // { // @22D4 stack[-3] // @22D4 stack[-1] // } 22D3 5B JUMPDEST 22D4 91 SWAP2 22D5 50 POP 22D6 61 PUSH2 0x22de 22D9 82 DUP3 22DA 61 PUSH2 0x229d 22DD 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @22D4 stack[-3] = stack[-1] // @22D6 stack[-1] = 0x22de // @22D9 stack[0] = stack[-1] // } // Block ends with call to 0x229d, returns to 0x22DE label_22DE: // Incoming return from call to 0x229D at 0x22DD // Inputs[3] // { // @22E1 stack[-2] // @22E3 stack[-1] // @22E5 stack[-3] // } 22DE 5B JUMPDEST 22DF 60 PUSH1 0x20 22E1 82 DUP3 22E2 01 ADD 22E3 90 SWAP1 22E4 50 POP 22E5 91 SWAP2 22E6 90 SWAP1 22E7 50 POP 22E8 56 *JUMP // Stack delta = -2 // Outputs[1] { @22E5 stack[-3] = stack[-2] + 0x20 } // Block ends with unconditional jump to stack[-3] label_22E9: // Incoming call from 0x0C8E, returns to 0x0C8F // Incoming call from 0x07FC, returns to 0x07FD // Inputs[1] { @22EE stack[-1] } 22E9 5B JUMPDEST 22EA 60 PUSH1 0x00 22EC 60 PUSH1 0x20 22EE 82 DUP3 22EF 01 ADD 22F0 90 SWAP1 22F1 50 POP 22F2 81 DUP2 22F3 81 DUP2 22F4 03 SUB 22F5 60 PUSH1 0x00 22F7 83 DUP4 22F8 01 ADD 22F9 52 MSTORE 22FA 61 PUSH2 0x2302 22FD 81 DUP2 22FE 61 PUSH2 0x22c6 2301 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @22F0 stack[0] = stack[-1] + 0x20 // @22F9 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @22FA stack[1] = 0x2302 // @22FD stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x22c6, returns to 0x2302 label_2302: // Incoming return from call to 0x22C6 at 0x2301 // Inputs[4] // { // @2303 stack[-2] // @2303 stack[-1] // @2305 stack[-4] // @2306 stack[-3] // } 2302 5B JUMPDEST 2303 90 SWAP1 2304 50 POP 2305 91 SWAP2 2306 90 SWAP1 2307 50 POP 2308 56 *JUMP // Stack delta = -3 // Outputs[1] { @2305 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2309: // Incoming call from 0x24C9, returns to 0x24CA // Inputs[2] // { // @230C stack[-2] // @230F stack[-3] // } 2309 5B JUMPDEST 230A 60 PUSH1 0x00 230C 82 DUP3 230D 90 SWAP1 230E 50 POP 230F 92 SWAP3 2310 91 SWAP2 2311 50 POP 2312 50 POP 2313 56 *JUMP // Stack delta = -2 // Outputs[1] { @230F stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_2314: // Incoming call from 0x2444, returns to 0x2445 // Incoming call from 0x2534, returns to 0x2535 // Inputs[3] // { // @2317 stack[-1] // @2322 memory[0x00:0x20] // @2325 stack[-2] // } 2314 5B JUMPDEST 2315 60 PUSH1 0x00 2317 81 DUP2 2318 90 SWAP1 2319 50 POP 231A 81 DUP2 231B 60 PUSH1 0x00 231D 52 MSTORE 231E 60 PUSH1 0x20 2320 60 PUSH1 0x00 2322 20 SHA3 2323 90 SWAP1 2324 50 POP 2325 91 SWAP2 2326 90 SWAP1 2327 50 POP 2328 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @231D memory[0x00:0x20] = stack[-1] // @2325 stack[-2] = keccak256(memory[0x00:0x20]) // } // Block ends with unconditional jump to stack[-2] label_2329: // Incoming call from 0x2468, returns to 0x2469 // Incoming call from 0x244D, returns to 0x244E // Incoming call from 0x2468, returns to 0x2469 // Inputs[2] // { // @2330 stack[-1] // @2335 stack[-2] // } 2329 5B JUMPDEST 232A 60 PUSH1 0x00 232C 60 PUSH1 0x20 232E 60 PUSH1 0x1f 2330 83 DUP4 2331 01 ADD 2332 04 DIV 2333 90 SWAP1 2334 50 POP 2335 91 SWAP2 2336 90 SWAP1 2337 50 POP 2338 56 *JUMP // Stack delta = -1 // Outputs[1] { @2335 stack[-2] = (stack[-1] + 0x1f) / 0x20 } // Block ends with unconditional jump to stack[-2] label_2339: // Incoming call from 0x2375, returns to 0x2376 // Incoming call from 0x237F, returns to 0x2380 // Inputs[3] // { // @233C stack[-2] // @233D stack[-1] // @2341 stack[-3] // } 2339 5B JUMPDEST 233A 60 PUSH1 0x00 233C 82 DUP3 233D 82 DUP3 233E 1B SHL 233F 90 SWAP1 2340 50 POP 2341 92 SWAP3 2342 91 SWAP2 2343 50 POP 2344 50 POP 2345 56 *JUMP // Stack delta = -2 // Outputs[1] { @2341 stack[-3] = stack[-2] << stack[-1] } // Block ends with unconditional jump to stack[-3] label_2346: // Incoming jump from 0x23EA // Inputs[1] { @234B stack[-2] } 2346 5B JUMPDEST 2347 60 PUSH1 0x00 2349 60 PUSH1 0x08 234B 83 DUP4 234C 02 MUL 234D 61 PUSH2 0x2376 2350 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2371 82 DUP3 2372 61 PUSH2 0x2339 2375 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2347 stack[0] = 0x00 // @234C stack[1] = stack[-2] * 0x08 // @234D stack[2] = 0x2376 // @2350 stack[3] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // @2371 stack[4] = stack[-2] * 0x08 // } // Block ends with call to 0x2339, returns to 0x2376 label_2376: // Incoming return from call to 0x2339 at 0x2375 // Inputs[2] // { // @237A stack[-6] // @237B stack[-2] // } 2376 5B JUMPDEST 2377 61 PUSH2 0x2380 237A 86 DUP7 237B 83 DUP4 237C 61 PUSH2 0x2339 237F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2377 stack[0] = 0x2380 // @237A stack[1] = stack[-6] // @237B stack[2] = stack[-2] // } // Block ends with call to 0x2339, returns to 0x2380 label_2380: // Incoming return from call to 0x2339 at 0x237F // Inputs[6] // { // @2381 stack[-1] // @2381 stack[-7] // @2383 stack[-2] // @2385 stack[-5] // @238E stack[-4] // @2392 stack[-8] // } 2380 5B JUMPDEST 2381 95 SWAP6 2382 50 POP 2383 80 DUP1 2384 19 NOT 2385 84 DUP5 2386 16 AND 2387 93 SWAP4 2388 50 POP 2389 80 DUP1 238A 86 DUP7 238B 16 AND 238C 84 DUP5 238D 17 OR 238E 92 SWAP3 238F 50 POP 2390 50 POP 2391 50 POP 2392 93 SWAP4 2393 92 SWAP3 2394 50 POP 2395 50 POP 2396 50 POP 2397 56 *JUMP // Stack delta = -7 // Outputs[1] { @2392 stack[-8] = (stack[-5] & ~stack[-2]) | (stack[-1] & stack[-2]) } // Block ends with unconditional jump to stack[-8] label_2398: // Incoming jump from 0x23B7 // Inputs[2] // { // @239B stack[-1] // @239E stack[-2] // } 2398 5B JUMPDEST 2399 60 PUSH1 0x00 239B 81 DUP2 239C 90 SWAP1 239D 50 POP 239E 91 SWAP2 239F 90 SWAP1 23A0 50 POP 23A1 56 *JUMP // Stack delta = -1 // Outputs[1] { @239E stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_23A2: // Incoming call from 0x23D6, returns to 0x23D7 // Inputs[1] { @23AE stack[-1] } 23A2 5B JUMPDEST 23A3 60 PUSH1 0x00 23A5 61 PUSH2 0x23bd 23A8 61 PUSH2 0x23b8 23AB 61 PUSH2 0x23b3 23AE 84 DUP5 23AF 61 PUSH2 0x1b2a 23B2 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @23A3 stack[0] = 0x00 // @23A5 stack[1] = 0x23bd // @23A8 stack[2] = 0x23b8 // @23AB stack[3] = 0x23b3 // @23AE stack[4] = stack[-1] // } // Block ends with call to 0x1b2a, returns to 0x23B3 label_23B3: // Incoming return from call to 0x1B2A at 0x23B2 23B3 5B JUMPDEST 23B4 61 PUSH2 0x2398 23B7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2398 label_23B8: // Incoming return from call to 0x23B3 at 0x23B2 23B8 5B JUMPDEST 23B9 61 PUSH2 0x1b2a 23BC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1b2a label_23BD: // Incoming return from call to 0x23B8 at 0x23B2 // Inputs[4] // { // @23BE stack[-2] // @23BE stack[-1] // @23C0 stack[-4] // @23C1 stack[-3] // } 23BD 5B JUMPDEST 23BE 90 SWAP1 23BF 50 POP 23C0 91 SWAP2 23C1 90 SWAP1 23C2 50 POP 23C3 56 *JUMP // Stack delta = -3 // Outputs[1] { @23C0 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_23C4: // Incoming call from 0x23E2, returns to 0x23E3 // Inputs[2] // { // @23C7 stack[-1] // @23CA stack[-2] // } 23C4 5B JUMPDEST 23C5 60 PUSH1 0x00 23C7 81 DUP2 23C8 90 SWAP1 23C9 50 POP 23CA 91 SWAP2 23CB 90 SWAP1 23CC 50 POP 23CD 56 *JUMP // Stack delta = -1 // Outputs[1] { @23CA stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_23CE: // Incoming call from 0x240A, returns to 0x240B // Inputs[1] { @23D2 stack[-3] } 23CE 5B JUMPDEST 23CF 61 PUSH2 0x23d7 23D2 83 DUP4 23D3 61 PUSH2 0x23a2 23D6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @23CF stack[0] = 0x23d7 // @23D2 stack[1] = stack[-3] // } // Block ends with call to 0x23a2, returns to 0x23D7 label_23D7: // Incoming return from call to 0x23A2 at 0x23D6 // Inputs[1] { @23DE stack[-1] } 23D7 5B JUMPDEST 23D8 61 PUSH2 0x23eb 23DB 61 PUSH2 0x23e3 23DE 82 DUP3 23DF 61 PUSH2 0x23c4 23E2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @23D8 stack[0] = 0x23eb // @23DB stack[1] = 0x23e3 // @23DE stack[2] = stack[-1] // } // Block ends with call to 0x23c4, returns to 0x23E3 label_23E3: // Incoming return from call to 0x23C4 at 0x23E2 // Inputs[3] // { // @23E4 stack[-5] // @23E5 stack[-4] // @23E6 storage[stack[-4]] // } 23E3 5B JUMPDEST 23E4 84 DUP5 23E5 84 DUP5 23E6 54 SLOAD 23E7 61 PUSH2 0x2346 23EA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @23E4 stack[0] = stack[-5] // @23E6 stack[1] = storage[stack[-4]] // } // Block ends with unconditional jump to 0x2346 label_23EB: // Incoming return from call to 0x23E3 at 0x23E2 // Inputs[3] // { // @23EC stack[-3] // @23ED stack[-1] // @23F2 stack[-6] // } 23EB 5B JUMPDEST 23EC 82 DUP3 23ED 55 SSTORE 23EE 50 POP 23EF 50 POP 23F0 50 POP 23F1 50 POP 23F2 56 *JUMP // Stack delta = -6 // Outputs[1] { @23ED storage[stack[-3]] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_23F3: // Incoming call from 0x23FF, returns to 0x2400 // Inputs[1] { @23F6 stack[-1] } 23F3 5B JUMPDEST 23F4 60 PUSH1 0x00 23F6 90 SWAP1 23F7 56 *JUMP // Stack delta = +0 // Outputs[1] { @23F6 stack[-1] = 0x00 } // Block ends with unconditional jump to stack[-1] label_23F8: // Incoming call from 0x2423, returns to 0x2424 23F8 5B JUMPDEST 23F9 61 PUSH2 0x2400 23FC 61 PUSH2 0x23f3 23FF 56 *JUMP // Stack delta = +1 // Outputs[1] { @23F9 stack[0] = 0x2400 } // Block ends with call to 0x23f3, returns to 0x2400 label_2400: // Incoming return from call to 0x23F3 at 0x23FF // Inputs[3] // { // @2404 stack[-1] // @2405 stack[-3] // @2406 stack[-2] // } 2400 5B JUMPDEST 2401 61 PUSH2 0x240b 2404 81 DUP2 2405 84 DUP5 2406 84 DUP5 2407 61 PUSH2 0x23ce 240A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2401 stack[0] = 0x240b // @2404 stack[1] = stack[-1] // @2405 stack[2] = stack[-3] // @2406 stack[3] = stack[-2] // } // Block ends with call to 0x23ce, returns to 0x240B label_240B: // Incoming return from call to 0x23CE at 0x240A // Inputs[1] { @240F stack[-4] } 240B 5B JUMPDEST 240C 50 POP 240D 50 POP 240E 50 POP 240F 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_2410: // Incoming jump from 0x2470 // Inputs[2] // { // @2412 stack[-2] // @2413 stack[-1] // } 2410 5B JUMPDEST 2411 5B JUMPDEST 2412 81 DUP2 2413 81 DUP2 2414 10 LT 2415 15 ISZERO 2416 61 PUSH2 0x242f 2419 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x242f, if !(stack[-1] < stack[-2]) label_241A: // Incoming jump from 0x2419, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x2419, if not !(stack[-1] < stack[-2]) // Inputs[1] { @241F stack[-1] } 241A 61 PUSH2 0x2424 241D 60 PUSH1 0x00 241F 82 DUP3 2420 61 PUSH2 0x23f8 2423 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @241A stack[0] = 0x2424 // @241D stack[1] = 0x00 // @241F stack[2] = stack[-1] // } // Block ends with call to 0x23f8, returns to 0x2424 label_2424: // Incoming return from call to 0x23F8 at 0x2423 // Inputs[1] { @2427 stack[-1] } 2424 5B JUMPDEST 2425 60 PUSH1 0x01 2427 81 DUP2 2428 01 ADD 2429 90 SWAP1 242A 50 POP 242B 61 PUSH2 0x2411 242E 56 *JUMP // Stack delta = +0 // Outputs[1] { @2429 stack[-1] = stack[-1] + 0x01 } // Block ends with unconditional jump to 0x2411 label_242F: // Incoming jump from 0x2419, if !(stack[-1] < stack[-2]) // Incoming jump from 0x2419, if !(stack[-1] < stack[-2]) // Inputs[1] { @2432 stack[-3] } 242F 5B JUMPDEST 2430 50 POP 2431 50 POP 2432 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_2433: // Incoming call from 0x24F7, returns to 0x24F8 // Inputs[1] { @2436 stack[-2] } 2433 5B JUMPDEST 2434 60 PUSH1 0x1f 2436 82 DUP3 2437 11 GT 2438 15 ISZERO 2439 61 PUSH2 0x2474 243C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2474, if !(stack[-2] > 0x1f) label_243D: // Incoming jump from 0x243C, if not !(stack[-2] > 0x1f) // Inputs[1] { @2440 stack[-1] } 243D 61 PUSH2 0x2445 2440 81 DUP2 2441 61 PUSH2 0x2314 2444 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @243D stack[0] = 0x2445 // @2440 stack[1] = stack[-1] // } // Block ends with call to 0x2314, returns to 0x2445 label_2445: // Incoming return from call to 0x2314 at 0x2444 // Inputs[1] { @2449 stack[-4] } 2445 5B JUMPDEST 2446 61 PUSH2 0x244e 2449 84 DUP5 244A 61 PUSH2 0x2329 244D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2446 stack[0] = 0x244e // @2449 stack[1] = stack[-4] // } // Block ends with call to 0x2329, returns to 0x244E label_244E: // Incoming return from call to 0x2329 at 0x244D // Inputs[3] // { // @244F stack[-2] // @2450 stack[-1] // @2453 stack[-5] // } 244E 5B JUMPDEST 244F 81 DUP2 2450 01 ADD 2451 60 PUSH1 0x20 2453 85 DUP6 2454 10 LT 2455 15 ISZERO 2456 61 PUSH2 0x245d 2459 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2450 stack[-1] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x245d, if !(stack[-5] < 0x20) label_245A: // Incoming jump from 0x2459, if not !(stack[-5] < 0x20) // Inputs[3] // { // @245A stack[-2] // @245B stack[-1] // @2464 stack[-4] // } 245A 81 DUP2 245B 90 SWAP1 245C 50 POP 245D 5B JUMPDEST 245E 61 PUSH2 0x2471 2461 61 PUSH2 0x2469 2464 85 DUP6 2465 61 PUSH2 0x2329 2468 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @245B stack[-1] = stack[-2] // @245E stack[0] = 0x2471 // @2461 stack[1] = 0x2469 // @2464 stack[2] = stack[-4] // } // Block ends with call to 0x2329, returns to 0x2469 label_2469: // Incoming return from call to 0x2329 at 0x2468 // Incoming return from call to 0x2329 at 0x2468 // Inputs[3] // { // @246A stack[-4] // @246B stack[-1] // @246C stack[-3] // } 2469 5B JUMPDEST 246A 83 DUP4 246B 01 ADD 246C 82 DUP3 246D 61 PUSH2 0x2410 2470 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @246B stack[-1] = stack[-4] + stack[-1] // @246C stack[0] = stack[-3] // } // Block ends with unconditional jump to 0x2410 label_2471: // Incoming return from call to 0x2469 at 0x2468 // Incoming return from call to 0x2469 at 0x2468 2471 5B JUMPDEST 2472 50 POP 2473 50 POP // Stack delta = -2 // Block continues label_2474: // Incoming jump from 0x243C, if !(stack[-2] > 0x1f) // Incoming jump from 0x2473 // Inputs[1] { @2478 stack[-4] } 2474 5B JUMPDEST 2475 50 POP 2476 50 POP 2477 50 POP 2478 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_2479: // Incoming call from 0x2496, returns to 0x2497 // Inputs[3] // { // @247C stack[-2] // @247D stack[-1] // @2481 stack[-3] // } 2479 5B JUMPDEST 247A 60 PUSH1 0x00 247C 82 DUP3 247D 82 DUP3 247E 1C SHR 247F 90 SWAP1 2480 50 POP 2481 92 SWAP3 2482 91 SWAP2 2483 50 POP 2484 50 POP 2485 56 *JUMP // Stack delta = -2 // Outputs[1] { @2481 stack[-3] = stack[-2] >> stack[-1] } // Block ends with unconditional jump to stack[-3] label_2486: // Incoming call from 0x24AF, returns to 0x24B0 // Incoming call from 0x2575, returns to 0x2576 // Inputs[1] { @248F stack[-2] } 2486 5B JUMPDEST 2487 60 PUSH1 0x00 2489 61 PUSH2 0x2497 248C 60 PUSH1 0x00 248E 19 NOT 248F 84 DUP5 2490 60 PUSH1 0x08 2492 02 MUL 2493 61 PUSH2 0x2479 2496 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2487 stack[0] = 0x00 // @2489 stack[1] = 0x2497 // @248E stack[2] = ~0x00 // @2492 stack[3] = 0x08 * stack[-2] // } // Block ends with call to 0x2479, returns to 0x2497 label_2497: // Incoming return from call to 0x2479 at 0x2496 // Inputs[5] // { // @2498 stack[-1] // @249A stack[-3] // @249C stack[-2] // @249F stack[-5] // @24A0 stack[-4] // } 2497 5B JUMPDEST 2498 19 NOT 2499 80 DUP1 249A 83 DUP4 249B 16 AND 249C 91 SWAP2 249D 50 POP 249E 50 POP 249F 92 SWAP3 24A0 91 SWAP2 24A1 50 POP 24A2 50 POP 24A3 56 *JUMP // Stack delta = -4 // Outputs[1] { @249F stack[-5] = stack[-3] & ~stack[-1] } // Block ends with unconditional jump to stack[-5] label_24A4: // Incoming call from 0x251E, returns to 0x251F // Incoming call from 0x251E, returns to 0x251F // Inputs[2] // { // @24AA stack[-2] // @24AB stack[-1] // } 24A4 5B JUMPDEST 24A5 60 PUSH1 0x00 24A7 61 PUSH2 0x24b0 24AA 83 DUP4 24AB 83 DUP4 24AC 61 PUSH2 0x2486 24AF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @24A5 stack[0] = 0x00 // @24A7 stack[1] = 0x24b0 // @24AA stack[2] = stack[-2] // @24AB stack[3] = stack[-1] // } // Block ends with call to 0x2486, returns to 0x24B0 label_24B0: // Incoming return from call to 0x2486 at 0x24AF // Inputs[5] // { // @24B1 stack[-1] // @24B1 stack[-3] // @24B3 stack[-4] // @24B9 stack[-2] // @24BB stack[-5] // } 24B0 5B JUMPDEST 24B1 91 SWAP2 24B2 50 POP 24B3 82 DUP3 24B4 60 PUSH1 0x02 24B6 02 MUL 24B7 82 DUP3 24B8 17 OR 24B9 90 SWAP1 24BA 50 POP 24BB 92 SWAP3 24BC 91 SWAP2 24BD 50 POP 24BE 50 POP 24BF 56 *JUMP // Stack delta = -4 // Outputs[1] { @24BB stack[-5] = stack[-1] | 0x02 * stack[-4] } // Block ends with unconditional jump to stack[-5] label_24C0: // Incoming call from 0x0827, returns to 0x0828 // Inputs[2] // { // @24C4 stack[-3] // @24C5 stack[-2] // } 24C0 5B JUMPDEST 24C1 61 PUSH2 0x24ca 24C4 83 DUP4 24C5 83 DUP4 24C6 61 PUSH2 0x2309 24C9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @24C1 stack[0] = 0x24ca // @24C4 stack[1] = stack[-3] // @24C5 stack[2] = stack[-2] // } // Block ends with call to 0x2309, returns to 0x24CA label_24CA: // Incoming return from call to 0x2309 at 0x24C9 // Inputs[1] { @24D4 stack[-1] } 24CA 5B JUMPDEST 24CB 67 PUSH8 0xffffffffffffffff 24D4 81 DUP2 24D5 11 GT 24D6 15 ISZERO 24D7 61 PUSH2 0x24e3 24DA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x24e3, if !(stack[-1] > 0xffffffffffffffff) label_24DB: // Incoming jump from 0x24DA, if not !(stack[-1] > 0xffffffffffffffff) 24DB 61 PUSH2 0x24e2 24DE 61 PUSH2 0x1e22 24E1 56 *JUMP // Stack delta = +1 // Outputs[1] { @24DB stack[0] = 0x24e2 } // Block ends with unconditional jump to 0x1e22 24E2 5B JUMPDEST label_24E3: // Incoming jump from 0x24DA, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @24E7 stack[-2] // @24E8 storage[stack[-2]] // } 24E3 5B JUMPDEST 24E4 61 PUSH2 0x24ed 24E7 82 DUP3 24E8 54 SLOAD 24E9 61 PUSH2 0x203f 24EC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @24E4 stack[0] = 0x24ed // @24E8 stack[1] = storage[stack[-2]] // } // Block ends with call to 0x203f, returns to 0x24ED label_24ED: // Incoming return from call to 0x203F at 0x24EC // Inputs[3] // { // @24F1 stack[-2] // @24F2 stack[-1] // @24F3 stack[-3] // } 24ED 5B JUMPDEST 24EE 61 PUSH2 0x24f8 24F1 82 DUP3 24F2 82 DUP3 24F3 85 DUP6 24F4 61 PUSH2 0x2433 24F7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @24EE stack[0] = 0x24f8 // @24F1 stack[1] = stack[-2] // @24F2 stack[2] = stack[-1] // @24F3 stack[3] = stack[-3] // } // Block ends with call to 0x2433, returns to 0x24F8 label_24F8: // Incoming return from call to 0x2433 at 0x24F7 // Inputs[1] { @24FD stack[-2] } 24F8 5B JUMPDEST 24F9 60 PUSH1 0x00 24FB 60 PUSH1 0x1f 24FD 83 DUP4 24FE 11 GT 24FF 60 PUSH1 0x01 2501 81 DUP2 2502 14 EQ 2503 61 PUSH2 0x2527 2506 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @24F9 stack[0] = 0x00 // @24FE stack[1] = stack[-2] > 0x1f // } // Block ends with conditional jump to 0x2527, if (stack[-2] > 0x1f) == 0x01 label_2507: // Incoming jump from 0x2506, if not (stack[-2] > 0x1f) == 0x01 // Inputs[1] { @2509 stack[-4] } 2507 60 PUSH1 0x00 2509 84 DUP5 250A 15 ISZERO 250B 61 PUSH2 0x2515 250E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2507 stack[0] = 0x00 } // Block ends with conditional jump to 0x2515, if !stack[-4] label_250F: // Incoming jump from 0x250E, if not !stack[-4] // Inputs[5] // { // @250F stack[-3] // @2510 stack[-7] // @2512 msg.data[stack[-7] + stack[-3]:stack[-7] + stack[-3] + 0x20] // @2513 stack[-1] // @2519 stack[-5] // } 250F 82 DUP3 2510 87 DUP8 2511 01 ADD 2512 35 CALLDATALOAD 2513 90 SWAP1 2514 50 POP 2515 5B JUMPDEST 2516 61 PUSH2 0x251f 2519 85 DUP6 251A 82 DUP3 251B 61 PUSH2 0x24a4 251E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2513 stack[-1] = msg.data[stack[-7] + stack[-3]:stack[-7] + stack[-3] + 0x20] // @2516 stack[0] = 0x251f // @2519 stack[1] = stack[-5] // @251A stack[2] = msg.data[stack[-7] + stack[-3]:stack[-7] + stack[-3] + 0x20] // } // Block ends with call to 0x24a4, returns to 0x251F label_251F: // Incoming return from call to 0x24A4 at 0x251E // Incoming return from call to 0x24A4 at 0x251E // Inputs[2] // { // @2520 stack[-7] // @2521 stack[-1] // } 251F 5B JUMPDEST 2520 86 DUP7 2521 55 SSTORE 2522 50 POP 2523 61 PUSH2 0x2587 2526 56 *JUMP // Stack delta = -2 // Outputs[1] { @2521 storage[stack[-7]] = stack[-1] } // Block ends with unconditional jump to 0x2587 label_2527: // Incoming jump from 0x2506, if (stack[-2] > 0x1f) == 0x01 // Inputs[2] // { // @252B stack[-4] // @2530 stack[-5] // } 2527 5B JUMPDEST 2528 60 PUSH1 0x1f 252A 19 NOT 252B 84 DUP5 252C 16 AND 252D 61 PUSH2 0x2535 2530 86 DUP7 2531 61 PUSH2 0x2314 2534 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @252C stack[0] = stack[-4] & ~0x1f // @252D stack[1] = 0x2535 // @2530 stack[2] = stack[-5] // } // Block ends with call to 0x2314, returns to 0x2535 label_2535: // Incoming return from call to 0x2314 at 0x2534 // Inputs[1] { @2539 stack[-2] } 2535 5B JUMPDEST 2536 60 PUSH1 0x00 2538 5B JUMPDEST 2539 82 DUP3 253A 81 DUP2 253B 10 LT 253C 15 ISZERO 253D 61 PUSH2 0x255d 2540 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2536 stack[0] = 0x00 } // Block ends with conditional jump to 0x255d, if !(0x00 < stack[-2]) label_2541: // Incoming jump from 0x2540, if not !(0x00 < stack[-2]) // Incoming jump from 0x2540, if not !(stack[-1] < stack[-3]) // Inputs[5] // { // @2541 stack[-5] // @2542 stack[-9] // @2544 msg.data[stack[-9] + stack[-5]:stack[-9] + stack[-5] + 0x20] // @2545 stack[-2] // @2555 stack[-1] // } 2541 84 DUP5 2542 89 DUP10 2543 01 ADD 2544 35 CALLDATALOAD 2545 82 DUP3 2546 55 SSTORE 2547 60 PUSH1 0x01 2549 82 DUP3 254A 01 ADD 254B 91 SWAP2 254C 50 POP 254D 60 PUSH1 0x20 254F 85 DUP6 2550 01 ADD 2551 94 SWAP5 2552 50 POP 2553 60 PUSH1 0x20 2555 81 DUP2 2556 01 ADD 2557 90 SWAP1 2558 50 POP 2559 61 PUSH2 0x2538 255C 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2546 storage[stack[-2]] = msg.data[stack[-9] + stack[-5]:stack[-9] + stack[-5] + 0x20] // @254B stack[-2] = stack[-2] + 0x01 // @2551 stack[-5] = stack[-5] + 0x20 // @2557 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x2538 label_255D: // Incoming jump from 0x2540, if !(0x00 < stack[-2]) // Incoming jump from 0x2540, if !(stack[-1] < stack[-3]) // Inputs[2] // { // @255E stack[-7] // @255F stack[-3] // } 255D 5B JUMPDEST 255E 86 DUP7 255F 83 DUP4 2560 10 LT 2561 15 ISZERO 2562 61 PUSH2 0x257a 2565 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x257a, if !(stack[-3] < stack[-7]) label_2566: // Incoming jump from 0x2565, if not !(stack[-3] < stack[-7]) // Inputs[4] // { // @2566 stack[-5] // @2567 stack[-9] // @2569 msg.data[stack[-9] + stack[-5]:stack[-9] + stack[-5] + 0x20] // @256F stack[-7] // } 2566 84 DUP5 2567 89 DUP10 2568 01 ADD 2569 35 CALLDATALOAD 256A 61 PUSH2 0x2576 256D 60 PUSH1 0x1f 256F 89 DUP10 2570 16 AND 2571 82 DUP3 2572 61 PUSH2 0x2486 2575 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2569 stack[0] = msg.data[stack[-9] + stack[-5]:stack[-9] + stack[-5] + 0x20] // @256A stack[1] = 0x2576 // @2570 stack[2] = stack[-7] & 0x1f // @2571 stack[3] = msg.data[stack[-9] + stack[-5]:stack[-9] + stack[-5] + 0x20] // } // Block ends with call to 0x2486, returns to 0x2576 label_2576: // Incoming return from call to 0x2486 at 0x2575 // Inputs[2] // { // @2577 stack[-4] // @2578 stack[-1] // } 2576 5B JUMPDEST 2577 83 DUP4 2578 55 SSTORE 2579 50 POP // Stack delta = -2 // Outputs[1] { @2578 storage[stack[-4]] = stack[-1] } // Block continues label_257A: // Incoming jump from 0x2579 // Incoming jump from 0x2565, if !(stack[-3] < stack[-7]) // Inputs[3] // { // @257F stack[-7] // @2582 stack[-8] // @258F stack[-11] // } 257A 5B JUMPDEST 257B 60 PUSH1 0x01 257D 60 PUSH1 0x02 257F 88 DUP9 2580 02 MUL 2581 01 ADD 2582 88 DUP9 2583 55 SSTORE 2584 50 POP 2585 50 POP 2586 50 POP 2587 5B JUMPDEST 2588 50 POP 2589 50 POP 258A 50 POP 258B 50 POP 258C 50 POP 258D 50 POP 258E 50 POP 258F 56 *JUMP // Stack delta = -11 // Outputs[1] { @2583 storage[stack[-8]] = stack[-7] * 0x02 + 0x01 } // Block ends with unconditional jump to stack[-11] label_2590: // Incoming call from 0x25F6, returns to 0x25F7 // Inputs[2] // { // @25B4 stack[-1] // @25DE stack[-2] // } 2590 5B JUMPDEST 2591 7F PUSH32 0x4552433732313a2061646472657373207a65726f206973206e6f742061207661 25B2 60 PUSH1 0x00 25B4 82 DUP3 25B5 01 ADD 25B6 52 MSTORE 25B7 7F PUSH32 0x6c6964206f776e65720000000000000000000000000000000000000000000000 25D8 60 PUSH1 0x20 25DA 82 DUP3 25DB 01 ADD 25DC 52 MSTORE 25DD 50 POP 25DE 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @25B6 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a2061646472657373207a65726f206973206e6f742061207661 // @25DC memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x6c6964206f776e65720000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_25DF: // Incoming call from 0x261A, returns to 0x261B // Inputs[1] { @25E7 stack[-1] } 25DF 5B JUMPDEST 25E0 60 PUSH1 0x00 25E2 61 PUSH2 0x25ec 25E5 60 PUSH1 0x29 25E7 83 DUP4 25E8 61 PUSH2 0x1a83 25EB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @25E0 stack[0] = 0x00 // @25E2 stack[1] = 0x25ec // @25E5 stack[2] = 0x29 // @25E7 stack[3] = stack[-1] // } // Block ends with call to 0x1a83, returns to 0x25EC label_25EC: // Incoming return from call to 0x1A83 at 0x25EB // Inputs[2] // { // @25ED stack[-1] // @25ED stack[-3] // } 25EC 5B JUMPDEST 25ED 91 SWAP2 25EE 50 POP 25EF 61 PUSH2 0x25f7 25F2 82 DUP3 25F3 61 PUSH2 0x2590 25F6 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @25ED stack[-3] = stack[-1] // @25EF stack[-1] = 0x25f7 // @25F2 stack[0] = stack[-1] // } // Block ends with call to 0x2590, returns to 0x25F7 label_25F7: // Incoming return from call to 0x2590 at 0x25F6 // Inputs[3] // { // @25FA stack[-2] // @25FC stack[-1] // @25FE stack[-3] // } 25F7 5B JUMPDEST 25F8 60 PUSH1 0x40 25FA 82 DUP3 25FB 01 ADD 25FC 90 SWAP1 25FD 50 POP 25FE 91 SWAP2 25FF 90 SWAP1 2600 50 POP 2601 56 *JUMP // Stack delta = -2 // Outputs[1] { @25FE stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_2602: // Incoming call from 0x0893, returns to 0x0894 // Inputs[1] { @2607 stack[-1] } 2602 5B JUMPDEST 2603 60 PUSH1 0x00 2605 60 PUSH1 0x20 2607 82 DUP3 2608 01 ADD 2609 90 SWAP1 260A 50 POP 260B 81 DUP2 260C 81 DUP2 260D 03 SUB 260E 60 PUSH1 0x00 2610 83 DUP4 2611 01 ADD 2612 52 MSTORE 2613 61 PUSH2 0x261b 2616 81 DUP2 2617 61 PUSH2 0x25df 261A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2609 stack[0] = stack[-1] + 0x20 // @2612 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2613 stack[1] = 0x261b // @2616 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x25df, returns to 0x261B label_261B: // Incoming return from call to 0x25DF at 0x261A // Inputs[4] // { // @261C stack[-2] // @261C stack[-1] // @261E stack[-4] // @261F stack[-3] // } 261B 5B JUMPDEST 261C 90 SWAP1 261D 50 POP 261E 91 SWAP2 261F 90 SWAP1 2620 50 POP 2621 56 *JUMP // Stack delta = -3 // Outputs[1] { @261E stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2622: // Incoming call from 0x2688, returns to 0x2689 // Inputs[2] // { // @2646 stack[-1] // @2670 stack[-2] // } 2622 5B JUMPDEST 2623 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 2644 60 PUSH1 0x00 2646 82 DUP3 2647 01 ADD 2648 52 MSTORE 2649 7F PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000 266A 60 PUSH1 0x20 266C 82 DUP3 266D 01 ADD 266E 52 MSTORE 266F 50 POP 2670 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2648 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @266E memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_2671: // Incoming call from 0x26AC, returns to 0x26AD // Inputs[1] { @2679 stack[-1] } 2671 5B JUMPDEST 2672 60 PUSH1 0x00 2674 61 PUSH2 0x267e 2677 60 PUSH1 0x26 2679 83 DUP4 267A 61 PUSH2 0x1a83 267D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2672 stack[0] = 0x00 // @2674 stack[1] = 0x267e // @2677 stack[2] = 0x26 // @2679 stack[3] = stack[-1] // } // Block ends with call to 0x1a83, returns to 0x267E label_267E: // Incoming return from call to 0x1A83 at 0x267D // Inputs[2] // { // @267F stack[-3] // @267F stack[-1] // } 267E 5B JUMPDEST 267F 91 SWAP2 2680 50 POP 2681 61 PUSH2 0x2689 2684 82 DUP3 2685 61 PUSH2 0x2622 2688 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @267F stack[-3] = stack[-1] // @2681 stack[-1] = 0x2689 // @2684 stack[0] = stack[-1] // } // Block ends with call to 0x2622, returns to 0x2689 label_2689: // Incoming return from call to 0x2622 at 0x2688 // Inputs[3] // { // @268C stack[-2] // @268E stack[-1] // @2690 stack[-3] // } 2689 5B JUMPDEST 268A 60 PUSH1 0x40 268C 82 DUP3 268D 01 ADD 268E 90 SWAP1 268F 50 POP 2690 91 SWAP2 2691 90 SWAP1 2692 50 POP 2693 56 *JUMP // Stack delta = -2 // Outputs[1] { @2690 stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_2694: // Incoming call from 0x0BD0, returns to 0x0BD1 // Inputs[1] { @2699 stack[-1] } 2694 5B JUMPDEST 2695 60 PUSH1 0x00 2697 60 PUSH1 0x20 2699 82 DUP3 269A 01 ADD 269B 90 SWAP1 269C 50 POP 269D 81 DUP2 269E 81 DUP2 269F 03 SUB 26A0 60 PUSH1 0x00 26A2 83 DUP4 26A3 01 ADD 26A4 52 MSTORE 26A5 61 PUSH2 0x26ad 26A8 81 DUP2 26A9 61 PUSH2 0x2671 26AC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @269B stack[0] = stack[-1] + 0x20 // @26A4 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @26A5 stack[1] = 0x26ad // @26A8 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2671, returns to 0x26AD label_26AD: // Incoming return from call to 0x2671 at 0x26AC // Inputs[4] // { // @26AE stack[-2] // @26AE stack[-1] // @26B0 stack[-4] // @26B1 stack[-3] // } 26AD 5B JUMPDEST 26AE 90 SWAP1 26AF 50 POP 26B0 91 SWAP2 26B1 90 SWAP1 26B2 50 POP 26B3 56 *JUMP // Stack delta = -3 // Outputs[1] { @26B0 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_26B4: // Incoming call from 0x26F4, returns to 0x26F5 // Inputs[2] // { // @26D8 stack[-1] // @26DC stack[-2] // } 26B4 5B JUMPDEST 26B5 7F PUSH32 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 26D6 60 PUSH1 0x00 26D8 82 DUP3 26D9 01 ADD 26DA 52 MSTORE 26DB 50 POP 26DC 56 *JUMP // Stack delta = -2 // Outputs[1] { @26DA memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 } // Block ends with unconditional jump to stack[-2] label_26DD: // Incoming call from 0x2718, returns to 0x2719 // Inputs[1] { @26E5 stack[-1] } 26DD 5B JUMPDEST 26DE 60 PUSH1 0x00 26E0 61 PUSH2 0x26ea 26E3 60 PUSH1 0x1f 26E5 83 DUP4 26E6 61 PUSH2 0x1a83 26E9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @26DE stack[0] = 0x00 // @26E0 stack[1] = 0x26ea // @26E3 stack[2] = 0x1f // @26E5 stack[3] = stack[-1] // } // Block ends with call to 0x1a83, returns to 0x26EA label_26EA: // Incoming return from call to 0x1A83 at 0x26E9 // Inputs[2] // { // @26EB stack[-1] // @26EB stack[-3] // } 26EA 5B JUMPDEST 26EB 91 SWAP2 26EC 50 POP 26ED 61 PUSH2 0x26f5 26F0 82 DUP3 26F1 61 PUSH2 0x26b4 26F4 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @26EB stack[-3] = stack[-1] // @26ED stack[-1] = 0x26f5 // @26F0 stack[0] = stack[-1] // } // Block ends with call to 0x26b4, returns to 0x26F5 label_26F5: // Incoming return from call to 0x26B4 at 0x26F4 // Inputs[3] // { // @26F8 stack[-2] // @26FA stack[-1] // @26FC stack[-3] // } 26F5 5B JUMPDEST 26F6 60 PUSH1 0x20 26F8 82 DUP3 26F9 01 ADD 26FA 90 SWAP1 26FB 50 POP 26FC 91 SWAP2 26FD 90 SWAP1 26FE 50 POP 26FF 56 *JUMP // Stack delta = -2 // Outputs[1] { @26FC stack[-3] = stack[-2] + 0x20 } // Block ends with unconditional jump to stack[-3] label_2700: // Incoming call from 0x0D97, returns to 0x0D98 // Inputs[1] { @2705 stack[-1] } 2700 5B JUMPDEST 2701 60 PUSH1 0x00 2703 60 PUSH1 0x20 2705 82 DUP3 2706 01 ADD 2707 90 SWAP1 2708 50 POP 2709 81 DUP2 270A 81 DUP2 270B 03 SUB 270C 60 PUSH1 0x00 270E 83 DUP4 270F 01 ADD 2710 52 MSTORE 2711 61 PUSH2 0x2719 2714 81 DUP2 2715 61 PUSH2 0x26dd 2718 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2707 stack[0] = stack[-1] + 0x20 // @2710 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2711 stack[1] = 0x2719 // @2714 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x26dd, returns to 0x2719 label_2719: // Incoming return from call to 0x26DD at 0x2718 // Inputs[4] // { // @271A stack[-1] // @271A stack[-2] // @271C stack[-4] // @271D stack[-3] // } 2719 5B JUMPDEST 271A 90 SWAP1 271B 50 POP 271C 91 SWAP2 271D 90 SWAP1 271E 50 POP 271F 56 *JUMP // Stack delta = -3 // Outputs[1] { @271C stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2720: // Incoming call from 0x2786, returns to 0x2787 // Inputs[2] // { // @2744 stack[-1] // @276E stack[-2] // } 2720 5B JUMPDEST 2721 7F PUSH32 0x4552433732313a207472616e736665722066726f6d20696e636f727265637420 2742 60 PUSH1 0x00 2744 82 DUP3 2745 01 ADD 2746 52 MSTORE 2747 7F PUSH32 0x6f776e6572000000000000000000000000000000000000000000000000000000 2768 60 PUSH1 0x20 276A 82 DUP3 276B 01 ADD 276C 52 MSTORE 276D 50 POP 276E 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2746 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a207472616e736665722066726f6d20696e636f727265637420 // @276C memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x6f776e6572000000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_276F: // Incoming call from 0x27AA, returns to 0x27AB // Inputs[1] { @2777 stack[-1] } 276F 5B JUMPDEST 2770 60 PUSH1 0x00 2772 61 PUSH2 0x277c 2775 60 PUSH1 0x25 2777 83 DUP4 2778 61 PUSH2 0x1a83 277B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2770 stack[0] = 0x00 // @2772 stack[1] = 0x277c // @2775 stack[2] = 0x25 // @2777 stack[3] = stack[-1] // } // Block ends with call to 0x1a83, returns to 0x277C label_277C: // Incoming return from call to 0x1A83 at 0x277B // Inputs[2] // { // @277D stack[-3] // @277D stack[-1] // } 277C 5B JUMPDEST 277D 91 SWAP2 277E 50 POP 277F 61 PUSH2 0x2787 2782 82 DUP3 2783 61 PUSH2 0x2720 2786 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @277D stack[-3] = stack[-1] // @277F stack[-1] = 0x2787 // @2782 stack[0] = stack[-1] // } // Block ends with call to 0x2720, returns to 0x2787 label_2787: // Incoming return from call to 0x2720 at 0x2786 // Inputs[3] // { // @278A stack[-2] // @278C stack[-1] // @278E stack[-3] // } 2787 5B JUMPDEST 2788 60 PUSH1 0x40 278A 82 DUP3 278B 01 ADD 278C 90 SWAP1 278D 50 POP 278E 91 SWAP2 278F 90 SWAP1 2790 50 POP 2791 56 *JUMP // Stack delta = -2 // Outputs[1] { @278E stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_2792: // Incoming call from 0x0FC6, returns to 0x0FC7 // Incoming call from 0x0ED4, returns to 0x0ED5 // Inputs[1] { @2797 stack[-1] } 2792 5B JUMPDEST 2793 60 PUSH1 0x00 2795 60 PUSH1 0x20 2797 82 DUP3 2798 01 ADD 2799 90 SWAP1 279A 50 POP 279B 81 DUP2 279C 81 DUP2 279D 03 SUB 279E 60 PUSH1 0x00 27A0 83 DUP4 27A1 01 ADD 27A2 52 MSTORE 27A3 61 PUSH2 0x27ab 27A6 81 DUP2 27A7 61 PUSH2 0x276f 27AA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2799 stack[0] = stack[-1] + 0x20 // @27A2 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @27A3 stack[1] = 0x27ab // @27A6 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x276f, returns to 0x27AB label_27AB: // Incoming return from call to 0x276F at 0x27AA // Inputs[4] // { // @27AC stack[-1] // @27AC stack[-2] // @27AE stack[-4] // @27AF stack[-3] // } 27AB 5B JUMPDEST 27AC 90 SWAP1 27AD 50 POP 27AE 91 SWAP2 27AF 90 SWAP1 27B0 50 POP 27B1 56 *JUMP // Stack delta = -3 // Outputs[1] { @27AE stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_27B2: // Incoming call from 0x2818, returns to 0x2819 // Inputs[2] // { // @27D6 stack[-1] // @2800 stack[-2] // } 27B2 5B JUMPDEST 27B3 7F PUSH32 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 27D4 60 PUSH1 0x00 27D6 82 DUP3 27D7 01 ADD 27D8 52 MSTORE 27D9 7F PUSH32 0x7265737300000000000000000000000000000000000000000000000000000000 27FA 60 PUSH1 0x20 27FC 82 DUP3 27FD 01 ADD 27FE 52 MSTORE 27FF 50 POP 2800 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @27D8 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 // @27FE memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x7265737300000000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_2801: // Incoming call from 0x283C, returns to 0x283D // Inputs[1] { @2809 stack[-1] } 2801 5B JUMPDEST 2802 60 PUSH1 0x00 2804 61 PUSH2 0x280e 2807 60 PUSH1 0x24 2809 83 DUP4 280A 61 PUSH2 0x1a83 280D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2802 stack[0] = 0x00 // @2804 stack[1] = 0x280e // @2807 stack[2] = 0x24 // @2809 stack[3] = stack[-1] // } // Block ends with call to 0x1a83, returns to 0x280E label_280E: // Incoming return from call to 0x1A83 at 0x280D // Inputs[2] // { // @280F stack[-1] // @280F stack[-3] // } 280E 5B JUMPDEST 280F 91 SWAP2 2810 50 POP 2811 61 PUSH2 0x2819 2814 82 DUP3 2815 61 PUSH2 0x27b2 2818 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @280F stack[-3] = stack[-1] // @2811 stack[-1] = 0x2819 // @2814 stack[0] = stack[-1] // } // Block ends with call to 0x27b2, returns to 0x2819 label_2819: // Incoming return from call to 0x27B2 at 0x2818 // Inputs[3] // { // @281C stack[-2] // @281E stack[-1] // @2820 stack[-3] // } 2819 5B JUMPDEST 281A 60 PUSH1 0x40 281C 82 DUP3 281D 01 ADD 281E 90 SWAP1 281F 50 POP 2820 91 SWAP2 2821 90 SWAP1 2822 50 POP 2823 56 *JUMP // Stack delta = -2 // Outputs[1] { @2820 stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_2824: // Incoming call from 0x0F43, returns to 0x0F44 // Inputs[1] { @2829 stack[-1] } 2824 5B JUMPDEST 2825 60 PUSH1 0x00 2827 60 PUSH1 0x20 2829 82 DUP3 282A 01 ADD 282B 90 SWAP1 282C 50 POP 282D 81 DUP2 282E 81 DUP2 282F 03 SUB 2830 60 PUSH1 0x00 2832 83 DUP4 2833 01 ADD 2834 52 MSTORE 2835 61 PUSH2 0x283d 2838 81 DUP2 2839 61 PUSH2 0x2801 283C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @282B stack[0] = stack[-1] + 0x20 // @2834 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2835 stack[1] = 0x283d // @2838 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2801, returns to 0x283D label_283D: // Incoming return from call to 0x2801 at 0x283C // Inputs[4] // { // @283E stack[-2] // @283E stack[-1] // @2840 stack[-4] // @2841 stack[-3] // } 283D 5B JUMPDEST 283E 90 SWAP1 283F 50 POP 2840 91 SWAP2 2841 90 SWAP1 2842 50 POP 2843 56 *JUMP // Stack delta = -3 // Outputs[1] { @2840 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2844: // Incoming call from 0x2884, returns to 0x2885 // Inputs[2] // { // @2868 stack[-1] // @286C stack[-2] // } 2844 5B JUMPDEST 2845 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 2866 60 PUSH1 0x00 2868 82 DUP3 2869 01 ADD 286A 52 MSTORE 286B 50 POP 286C 56 *JUMP // Stack delta = -2 // Outputs[1] { @286A memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 } // Block ends with unconditional jump to stack[-2] label_286D: // Incoming call from 0x28A8, returns to 0x28A9 // Inputs[1] { @2875 stack[-1] } 286D 5B JUMPDEST 286E 60 PUSH1 0x00 2870 61 PUSH2 0x287a 2873 60 PUSH1 0x20 2875 83 DUP4 2876 61 PUSH2 0x1a83 2879 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @286E stack[0] = 0x00 // @2870 stack[1] = 0x287a // @2873 stack[2] = 0x20 // @2875 stack[3] = stack[-1] // } // Block ends with call to 0x1a83, returns to 0x287A label_287A: // Incoming return from call to 0x1A83 at 0x2879 // Inputs[2] // { // @287B stack[-3] // @287B stack[-1] // } 287A 5B JUMPDEST 287B 91 SWAP2 287C 50 POP 287D 61 PUSH2 0x2885 2880 82 DUP3 2881 61 PUSH2 0x2844 2884 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @287B stack[-3] = stack[-1] // @287D stack[-1] = 0x2885 // @2880 stack[0] = stack[-1] // } // Block ends with call to 0x2844, returns to 0x2885 label_2885: // Incoming return from call to 0x2844 at 0x2884 // Inputs[3] // { // @2888 stack[-2] // @288A stack[-1] // @288C stack[-3] // } 2885 5B JUMPDEST 2886 60 PUSH1 0x20 2888 82 DUP3 2889 01 ADD 288A 90 SWAP1 288B 50 POP 288C 91 SWAP2 288D 90 SWAP1 288E 50 POP 288F 56 *JUMP // Stack delta = -2 // Outputs[1] { @288C stack[-3] = stack[-2] + 0x20 } // Block ends with unconditional jump to stack[-3] label_2890: // Incoming call from 0x11D3, returns to 0x11D4 // Inputs[1] { @2895 stack[-1] } 2890 5B JUMPDEST 2891 60 PUSH1 0x00 2893 60 PUSH1 0x20 2895 82 DUP3 2896 01 ADD 2897 90 SWAP1 2898 50 POP 2899 81 DUP2 289A 81 DUP2 289B 03 SUB 289C 60 PUSH1 0x00 289E 83 DUP4 289F 01 ADD 28A0 52 MSTORE 28A1 61 PUSH2 0x28a9 28A4 81 DUP2 28A5 61 PUSH2 0x286d 28A8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2897 stack[0] = stack[-1] + 0x20 // @28A0 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @28A1 stack[1] = 0x28a9 // @28A4 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x286d, returns to 0x28A9 label_28A9: // Incoming return from call to 0x286D at 0x28A8 // Inputs[4] // { // @28AA stack[-1] // @28AA stack[-2] // @28AC stack[-4] // @28AD stack[-3] // } 28A9 5B JUMPDEST 28AA 90 SWAP1 28AB 50 POP 28AC 91 SWAP2 28AD 90 SWAP1 28AE 50 POP 28AF 56 *JUMP // Stack delta = -3 // Outputs[1] { @28AC stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_28B0: // Incoming call from 0x28F0, returns to 0x28F1 // Inputs[2] // { // @28D4 stack[-1] // @28D8 stack[-2] // } 28B0 5B JUMPDEST 28B1 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 28D2 60 PUSH1 0x00 28D4 82 DUP3 28D5 01 ADD 28D6 52 MSTORE 28D7 50 POP 28D8 56 *JUMP // Stack delta = -2 // Outputs[1] { @28D6 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 } // Block ends with unconditional jump to stack[-2] label_28D9: // Incoming call from 0x2914, returns to 0x2915 // Inputs[1] { @28E1 stack[-1] } 28D9 5B JUMPDEST 28DA 60 PUSH1 0x00 28DC 61 PUSH2 0x28e6 28DF 60 PUSH1 0x19 28E1 83 DUP4 28E2 61 PUSH2 0x1a83 28E5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @28DA stack[0] = 0x00 // @28DC stack[1] = 0x28e6 // @28DF stack[2] = 0x19 // @28E1 stack[3] = stack[-1] // } // Block ends with call to 0x1a83, returns to 0x28E6 label_28E6: // Incoming return from call to 0x1A83 at 0x28E5 // Inputs[2] // { // @28E7 stack[-1] // @28E7 stack[-3] // } 28E6 5B JUMPDEST 28E7 91 SWAP2 28E8 50 POP 28E9 61 PUSH2 0x28f1 28EC 82 DUP3 28ED 61 PUSH2 0x28b0 28F0 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @28E7 stack[-3] = stack[-1] // @28E9 stack[-1] = 0x28f1 // @28EC stack[0] = stack[-1] // } // Block ends with call to 0x28b0, returns to 0x28F1 label_28F1: // Incoming return from call to 0x28B0 at 0x28F0 // Inputs[3] // { // @28F4 stack[-2] // @28F6 stack[-1] // @28F8 stack[-3] // } 28F1 5B JUMPDEST 28F2 60 PUSH1 0x20 28F4 82 DUP3 28F5 01 ADD 28F6 90 SWAP1 28F7 50 POP 28F8 91 SWAP2 28F9 90 SWAP1 28FA 50 POP 28FB 56 *JUMP // Stack delta = -2 // Outputs[1] { @28F8 stack[-3] = stack[-2] + 0x20 } // Block ends with unconditional jump to stack[-3] label_28FC: // Incoming call from 0x1344, returns to 0x1345 // Inputs[1] { @2901 stack[-1] } 28FC 5B JUMPDEST 28FD 60 PUSH1 0x00 28FF 60 PUSH1 0x20 2901 82 DUP3 2902 01 ADD 2903 90 SWAP1 2904 50 POP 2905 81 DUP2 2906 81 DUP2 2907 03 SUB 2908 60 PUSH1 0x00 290A 83 DUP4 290B 01 ADD 290C 52 MSTORE 290D 61 PUSH2 0x2915 2910 81 DUP2 2911 61 PUSH2 0x28d9 2914 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2903 stack[0] = stack[-1] + 0x20 // @290C memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @290D stack[1] = 0x2915 // @2910 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x28d9, returns to 0x2915 label_2915: // Incoming return from call to 0x28D9 at 0x2914 // Inputs[4] // { // @2916 stack[-2] // @2916 stack[-1] // @2918 stack[-4] // @2919 stack[-3] // } 2915 5B JUMPDEST 2916 90 SWAP1 2917 50 POP 2918 91 SWAP2 2919 90 SWAP1 291A 50 POP 291B 56 *JUMP // Stack delta = -3 // Outputs[1] { @2918 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_291C: // Incoming call from 0x2982, returns to 0x2983 // Inputs[2] // { // @2940 stack[-1] // @296A stack[-2] // } 291C 5B JUMPDEST 291D 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 293E 60 PUSH1 0x00 2940 82 DUP3 2941 01 ADD 2942 52 MSTORE 2943 7F PUSH32 0x63656976657220696d706c656d656e7465720000000000000000000000000000 2964 60 PUSH1 0x20 2966 82 DUP3 2967 01 ADD 2968 52 MSTORE 2969 50 POP 296A 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2942 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 // @2968 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x63656976657220696d706c656d656e7465720000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_296B: // Incoming call from 0x29A6, returns to 0x29A7 // Inputs[1] { @2973 stack[-1] } 296B 5B JUMPDEST 296C 60 PUSH1 0x00 296E 61 PUSH2 0x2978 2971 60 PUSH1 0x32 2973 83 DUP4 2974 61 PUSH2 0x1a83 2977 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @296C stack[0] = 0x00 // @296E stack[1] = 0x2978 // @2971 stack[2] = 0x32 // @2973 stack[3] = stack[-1] // } // Block ends with call to 0x1a83, returns to 0x2978 label_2978: // Incoming return from call to 0x1A83 at 0x2977 // Inputs[2] // { // @2979 stack[-1] // @2979 stack[-3] // } 2978 5B JUMPDEST 2979 91 SWAP2 297A 50 POP 297B 61 PUSH2 0x2983 297E 82 DUP3 297F 61 PUSH2 0x291c 2982 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2979 stack[-3] = stack[-1] // @297B stack[-1] = 0x2983 // @297E stack[0] = stack[-1] // } // Block ends with call to 0x291c, returns to 0x2983 label_2983: // Incoming return from call to 0x291C at 0x2982 // Inputs[3] // { // @2986 stack[-2] // @2988 stack[-1] // @298A stack[-3] // } 2983 5B JUMPDEST 2984 60 PUSH1 0x40 2986 82 DUP3 2987 01 ADD 2988 90 SWAP1 2989 50 POP 298A 91 SWAP2 298B 90 SWAP1 298C 50 POP 298D 56 *JUMP // Stack delta = -2 // Outputs[1] { @298A stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_298E: // Incoming call from 0x15C7, returns to 0x15C8 // Incoming call from 0x16FA, returns to 0x16FB // Incoming call from 0x1498, returns to 0x1499 // Inputs[1] { @2993 stack[-1] } 298E 5B JUMPDEST 298F 60 PUSH1 0x00 2991 60 PUSH1 0x20 2993 82 DUP3 2994 01 ADD 2995 90 SWAP1 2996 50 POP 2997 81 DUP2 2998 81 DUP2 2999 03 SUB 299A 60 PUSH1 0x00 299C 83 DUP4 299D 01 ADD 299E 52 MSTORE 299F 61 PUSH2 0x29a7 29A2 81 DUP2 29A3 61 PUSH2 0x296b 29A6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2995 stack[0] = stack[-1] + 0x20 // @299E memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @299F stack[1] = 0x29a7 // @29A2 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x296b, returns to 0x29A7 label_29A7: // Incoming return from call to 0x296B at 0x29A6 // Inputs[4] // { // @29A8 stack[-2] // @29A8 stack[-1] // @29AA stack[-4] // @29AB stack[-3] // } 29A7 5B JUMPDEST 29A8 90 SWAP1 29A9 50 POP 29AA 91 SWAP2 29AB 90 SWAP1 29AC 50 POP 29AD 56 *JUMP // Stack delta = -3 // Outputs[1] { @29AA stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_29AE: // Incoming call from 0x29D4, returns to 0x29D5 // Inputs[3] // { // @29B1 stack[-1] // @29B2 memory[stack[-1]:stack[-1] + 0x20] // @29B5 stack[-2] // } 29AE 5B JUMPDEST 29AF 60 PUSH1 0x00 29B1 81 DUP2 29B2 51 MLOAD 29B3 90 SWAP1 29B4 50 POP 29B5 91 SWAP2 29B6 90 SWAP1 29B7 50 POP 29B8 56 *JUMP // Stack delta = -1 // Outputs[1] { @29B5 stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_29B9: // Incoming call from 0x29DE, returns to 0x29DF // Inputs[3] // { // @29BC stack[-2] // @29BD stack[-1] // @29C5 stack[-3] // } 29B9 5B JUMPDEST 29BA 60 PUSH1 0x00 29BC 82 DUP3 29BD 82 DUP3 29BE 52 MSTORE 29BF 60 PUSH1 0x20 29C1 82 DUP3 29C2 01 ADD 29C3 90 SWAP1 29C4 50 POP 29C5 92 SWAP3 29C6 91 SWAP2 29C7 50 POP 29C8 50 POP 29C9 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @29BE memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @29C5 stack[-3] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-3] label_29CA: // Incoming call from 0x2A43, returns to 0x2A44 // Inputs[1] { @29D0 stack[-1] } 29CA 5B JUMPDEST 29CB 60 PUSH1 0x00 29CD 61 PUSH2 0x29d5 29D0 82 DUP3 29D1 61 PUSH2 0x29ae 29D4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @29CB stack[0] = 0x00 // @29CD stack[1] = 0x29d5 // @29D0 stack[2] = stack[-1] // } // Block ends with call to 0x29ae, returns to 0x29D5 label_29D5: // Incoming return from call to 0x29AE at 0x29D4 // Inputs[2] // { // @29D9 stack[-1] // @29DA stack[-4] // } 29D5 5B JUMPDEST 29D6 61 PUSH2 0x29df 29D9 81 DUP2 29DA 85 DUP6 29DB 61 PUSH2 0x29b9 29DE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @29D6 stack[0] = 0x29df // @29D9 stack[1] = stack[-1] // @29DA stack[2] = stack[-4] // } // Block ends with call to 0x29b9, returns to 0x29DF label_29DF: // Incoming return from call to 0x29B9 at 0x29DE // Inputs[4] // { // @29E0 stack[-1] // @29E0 stack[-5] // @29E5 stack[-2] // @29E9 stack[-4] // } 29DF 5B JUMPDEST 29E0 93 SWAP4 29E1 50 POP 29E2 61 PUSH2 0x29ef 29E5 81 DUP2 29E6 85 DUP6 29E7 60 PUSH1 0x20 29E9 86 DUP7 29EA 01 ADD 29EB 61 PUSH2 0x1a94 29EE 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @29E0 stack[-5] = stack[-1] // @29E2 stack[-1] = 0x29ef // @29E5 stack[0] = stack[-2] // @29E6 stack[1] = stack[-1] // @29EA stack[2] = stack[-4] + 0x20 // } // Block ends with call to 0x1a94, returns to 0x29EF label_29EF: // Incoming return from call to 0x1A94 at 0x29EE // Inputs[1] { @29F3 stack[-1] } 29EF 5B JUMPDEST 29F0 61 PUSH2 0x29f8 29F3 81 DUP2 29F4 61 PUSH2 0x1abe 29F7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @29F0 stack[0] = 0x29f8 // @29F3 stack[1] = stack[-1] // } // Block ends with call to 0x1abe, returns to 0x29F8 label_29F8: // Incoming return from call to 0x1ABE at 0x29F7 // Inputs[4] // { // @29F9 stack[-5] // @29FA stack[-1] // @29FB stack[-3] // @29FE stack[-6] // } 29F8 5B JUMPDEST 29F9 84 DUP5 29FA 01 ADD 29FB 91 SWAP2 29FC 50 POP 29FD 50 POP 29FE 92 SWAP3 29FF 91 SWAP2 2A00 50 POP 2A01 50 POP 2A02 56 *JUMP // Stack delta = -5 // Outputs[1] { @29FE stack[-6] = stack[-5] + stack[-1] } // Block ends with unconditional jump to stack[-6] label_2A03: // Incoming call from 0x164D, returns to 0x164E // Inputs[2] // { // @2A08 stack[-1] // @2A13 stack[-5] // } 2A03 5B JUMPDEST 2A04 60 PUSH1 0x00 2A06 60 PUSH1 0x80 2A08 82 DUP3 2A09 01 ADD 2A0A 90 SWAP1 2A0B 50 POP 2A0C 61 PUSH2 0x2a18 2A0F 60 PUSH1 0x00 2A11 83 DUP4 2A12 01 ADD 2A13 87 DUP8 2A14 61 PUSH2 0x1bbf 2A17 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2A0A stack[0] = stack[-1] + 0x80 // @2A0C stack[1] = 0x2a18 // @2A12 stack[2] = stack[-1] + 0x00 // @2A13 stack[3] = stack[-5] // } // Block ends with call to 0x1bbf, returns to 0x2A18 label_2A18: // Incoming return from call to 0x1BBF at 0x2A17 // Inputs[2] // { // @2A1E stack[-2] // @2A20 stack[-5] // } 2A18 5B JUMPDEST 2A19 61 PUSH2 0x2a25 2A1C 60 PUSH1 0x20 2A1E 83 DUP4 2A1F 01 ADD 2A20 86 DUP7 2A21 61 PUSH2 0x1bbf 2A24 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2A19 stack[0] = 0x2a25 // @2A1F stack[1] = stack[-2] + 0x20 // @2A20 stack[2] = stack[-5] // } // Block ends with call to 0x1bbf, returns to 0x2A25 label_2A25: // Incoming return from call to 0x1BBF at 0x2A24 // Inputs[2] // { // @2A2B stack[-2] // @2A2D stack[-4] // } 2A25 5B JUMPDEST 2A26 61 PUSH2 0x2a32 2A29 60 PUSH1 0x40 2A2B 83 DUP4 2A2C 01 ADD 2A2D 85 DUP6 2A2E 61 PUSH2 0x1d87 2A31 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2A26 stack[0] = 0x2a32 // @2A2C stack[1] = stack[-2] + 0x40 // @2A2D stack[2] = stack[-4] // } // Block ends with call to 0x1d87, returns to 0x2A32 label_2A32: // Incoming return from call to 0x1D87 at 0x2A31 // Inputs[3] // { // @2A33 stack[-2] // @2A34 stack[-1] // @2A3F stack[-3] // } 2A32 5B JUMPDEST 2A33 81 DUP2 2A34 81 DUP2 2A35 03 SUB 2A36 60 PUSH1 0x60 2A38 83 DUP4 2A39 01 ADD 2A3A 52 MSTORE 2A3B 61 PUSH2 0x2a44 2A3E 81 DUP2 2A3F 84 DUP5 2A40 61 PUSH2 0x29ca 2A43 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2A3A memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] = stack[-1] - stack[-2] // @2A3B stack[0] = 0x2a44 // @2A3E stack[1] = stack[-1] // @2A3F stack[2] = stack[-3] // } // Block ends with call to 0x29ca, returns to 0x2A44 label_2A44: // Incoming return from call to 0x29CA at 0x2A43 // Inputs[4] // { // @2A45 stack[-1] // @2A45 stack[-2] // @2A47 stack[-8] // @2A48 stack[-7] // } 2A44 5B JUMPDEST 2A45 90 SWAP1 2A46 50 POP 2A47 95 SWAP6 2A48 94 SWAP5 2A49 50 POP 2A4A 50 POP 2A4B 50 POP 2A4C 50 POP 2A4D 50 POP 2A4E 56 *JUMP // Stack delta = -7 // Outputs[1] { @2A47 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_2A4F: // Incoming call from 0x2A87, returns to 0x2A88 // Inputs[2] // { // @2A52 stack[-1] // @2A53 memory[stack[-1]:stack[-1] + 0x20] // } 2A4F 5B JUMPDEST 2A50 60 PUSH1 0x00 2A52 81 DUP2 2A53 51 MLOAD 2A54 90 SWAP1 2A55 50 POP 2A56 61 PUSH2 0x2a5e 2A59 81 DUP2 2A5A 61 PUSH2 0x19e9 2A5D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2A54 stack[0] = memory[stack[-1]:stack[-1] + 0x20] // @2A56 stack[1] = 0x2a5e // @2A59 stack[2] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x19e9, returns to 0x2A5E label_2A5E: // Incoming return from call to 0x19E9 at 0x2A5D // Inputs[3] // { // @2A5F stack[-1] // @2A5F stack[-4] // @2A60 stack[-3] // } 2A5E 5B JUMPDEST 2A5F 92 SWAP3 2A60 91 SWAP2 2A61 50 POP 2A62 50 POP 2A63 56 *JUMP // Stack delta = -3 // Outputs[1] { @2A5F stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2A64: // Incoming call from 0x1686, returns to 0x1687 // Inputs[2] // { // @2A69 stack[-1] // @2A6A stack[-2] // } 2A64 5B JUMPDEST 2A65 60 PUSH1 0x00 2A67 60 PUSH1 0x20 2A69 82 DUP3 2A6A 84 DUP5 2A6B 03 SUB 2A6C 12 SLT 2A6D 15 ISZERO 2A6E 61 PUSH2 0x2a7a 2A71 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A65 stack[0] = 0x00 } // Block ends with conditional jump to 0x2a7a, if !(stack[-2] - stack[-1] i< 0x20) label_2A72: // Incoming jump from 0x2A71, if not !(stack[-2] - stack[-1] i< 0x20) 2A72 61 PUSH2 0x2a79 2A75 61 PUSH2 0x19b3 2A78 56 *JUMP // Stack delta = +1 // Outputs[1] { @2A72 stack[0] = 0x2a79 } // Block ends with unconditional jump to 0x19b3 2A79 5B JUMPDEST label_2A7A: // Incoming jump from 0x2A71, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2A80 stack[-3] // @2A82 stack[-2] // } 2A7A 5B JUMPDEST 2A7B 60 PUSH1 0x00 2A7D 61 PUSH2 0x2a88 2A80 84 DUP5 2A81 82 DUP3 2A82 85 DUP6 2A83 01 ADD 2A84 61 PUSH2 0x2a4f 2A87 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2A7B stack[0] = 0x00 // @2A7D stack[1] = 0x2a88 // @2A80 stack[2] = stack[-3] // @2A83 stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x2a4f, returns to 0x2A88 label_2A88: // Incoming return from call to 0x2A4F at 0x2A87 // Inputs[4] // { // @2A89 stack[-1] // @2A89 stack[-3] // @2A8C stack[-6] // @2A8D stack[-5] // } 2A88 5B JUMPDEST 2A89 91 SWAP2 2A8A 50 POP 2A8B 50 POP 2A8C 92 SWAP3 2A8D 91 SWAP2 2A8E 50 POP 2A8F 50 POP 2A90 56 *JUMP // Stack delta = -5 // Outputs[1] { @2A8C stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_2A91: // Incoming call from 0x2AD1, returns to 0x2AD2 // Inputs[2] // { // @2AB5 stack[-1] // @2AB9 stack[-2] // } 2A91 5B JUMPDEST 2A92 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 2AB3 60 PUSH1 0x00 2AB5 82 DUP3 2AB6 01 ADD 2AB7 52 MSTORE 2AB8 50 POP 2AB9 56 *JUMP // Stack delta = -2 // Outputs[1] { @2AB7 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 } // Block ends with unconditional jump to stack[-2] label_2ABA: // Incoming call from 0x2AF5, returns to 0x2AF6 // Inputs[1] { @2AC2 stack[-1] } 2ABA 5B JUMPDEST 2ABB 60 PUSH1 0x00 2ABD 61 PUSH2 0x2ac7 2AC0 60 PUSH1 0x20 2AC2 83 DUP4 2AC3 61 PUSH2 0x1a83 2AC6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2ABB stack[0] = 0x00 // @2ABD stack[1] = 0x2ac7 // @2AC0 stack[2] = 0x20 // @2AC2 stack[3] = stack[-1] // } // Block ends with call to 0x1a83, returns to 0x2AC7 label_2AC7: // Incoming return from call to 0x1A83 at 0x2AC6 // Inputs[2] // { // @2AC8 stack[-1] // @2AC8 stack[-3] // } 2AC7 5B JUMPDEST 2AC8 91 SWAP2 2AC9 50 POP 2ACA 61 PUSH2 0x2ad2 2ACD 82 DUP3 2ACE 61 PUSH2 0x2a91 2AD1 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2AC8 stack[-3] = stack[-1] // @2ACA stack[-1] = 0x2ad2 // @2ACD stack[0] = stack[-1] // } // Block ends with call to 0x2a91, returns to 0x2AD2 label_2AD2: // Incoming return from call to 0x2A91 at 0x2AD1 // Inputs[3] // { // @2AD5 stack[-2] // @2AD7 stack[-1] // @2AD9 stack[-3] // } 2AD2 5B JUMPDEST 2AD3 60 PUSH1 0x20 2AD5 82 DUP3 2AD6 01 ADD 2AD7 90 SWAP1 2AD8 50 POP 2AD9 91 SWAP2 2ADA 90 SWAP1 2ADB 50 POP 2ADC 56 *JUMP // Stack delta = -2 // Outputs[1] { @2AD9 stack[-3] = stack[-2] + 0x20 } // Block ends with unconditional jump to stack[-3] label_2ADD: // Incoming call from 0x17CE, returns to 0x17CF // Inputs[1] { @2AE2 stack[-1] } 2ADD 5B JUMPDEST 2ADE 60 PUSH1 0x00 2AE0 60 PUSH1 0x20 2AE2 82 DUP3 2AE3 01 ADD 2AE4 90 SWAP1 2AE5 50 POP 2AE6 81 DUP2 2AE7 81 DUP2 2AE8 03 SUB 2AE9 60 PUSH1 0x00 2AEB 83 DUP4 2AEC 01 ADD 2AED 52 MSTORE 2AEE 61 PUSH2 0x2af6 2AF1 81 DUP2 2AF2 61 PUSH2 0x2aba 2AF5 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2AE4 stack[0] = stack[-1] + 0x20 // @2AED memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2AEE stack[1] = 0x2af6 // @2AF1 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2aba, returns to 0x2AF6 label_2AF6: // Incoming return from call to 0x2ABA at 0x2AF5 // Inputs[4] // { // @2AF7 stack[-1] // @2AF7 stack[-2] // @2AF9 stack[-4] // @2AFA stack[-3] // } 2AF6 5B JUMPDEST 2AF7 90 SWAP1 2AF8 50 POP 2AF9 91 SWAP2 2AFA 90 SWAP1 2AFB 50 POP 2AFC 56 *JUMP // Stack delta = -3 // Outputs[1] { @2AF9 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2AFD: // Incoming call from 0x2B3D, returns to 0x2B3E // Inputs[2] // { // @2B21 stack[-1] // @2B25 stack[-2] // } 2AFD 5B JUMPDEST 2AFE 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 2B1F 60 PUSH1 0x00 2B21 82 DUP3 2B22 01 ADD 2B23 52 MSTORE 2B24 50 POP 2B25 56 *JUMP // Stack delta = -2 // Outputs[1] { @2B23 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 } // Block ends with unconditional jump to stack[-2] label_2B26: // Incoming call from 0x2B61, returns to 0x2B62 // Inputs[1] { @2B2E stack[-1] } 2B26 5B JUMPDEST 2B27 60 PUSH1 0x00 2B29 61 PUSH2 0x2b33 2B2C 60 PUSH1 0x1c 2B2E 83 DUP4 2B2F 61 PUSH2 0x1a83 2B32 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2B27 stack[0] = 0x00 // @2B29 stack[1] = 0x2b33 // @2B2C stack[2] = 0x1c // @2B2E stack[3] = stack[-1] // } // Block ends with call to 0x1a83, returns to 0x2B33 label_2B33: // Incoming return from call to 0x1A83 at 0x2B32 // Inputs[2] // { // @2B34 stack[-1] // @2B34 stack[-3] // } 2B33 5B JUMPDEST 2B34 91 SWAP2 2B35 50 POP 2B36 61 PUSH2 0x2b3e 2B39 82 DUP3 2B3A 61 PUSH2 0x2afd 2B3D 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2B34 stack[-3] = stack[-1] // @2B36 stack[-1] = 0x2b3e // @2B39 stack[0] = stack[-1] // } // Block ends with call to 0x2afd, returns to 0x2B3E label_2B3E: // Incoming return from call to 0x2AFD at 0x2B3D // Inputs[3] // { // @2B41 stack[-2] // @2B43 stack[-1] // @2B45 stack[-3] // } 2B3E 5B JUMPDEST 2B3F 60 PUSH1 0x20 2B41 82 DUP3 2B42 01 ADD 2B43 90 SWAP1 2B44 50 POP 2B45 91 SWAP2 2B46 90 SWAP1 2B47 50 POP 2B48 56 *JUMP // Stack delta = -2 // Outputs[1] { @2B45 stack[-3] = stack[-2] + 0x20 } // Block ends with unconditional jump to stack[-3] label_2B49: // Incoming call from 0x186E, returns to 0x186F // Incoming call from 0x1817, returns to 0x1818 // Inputs[1] { @2B4E stack[-1] } 2B49 5B JUMPDEST 2B4A 60 PUSH1 0x00 2B4C 60 PUSH1 0x20 2B4E 82 DUP3 2B4F 01 ADD 2B50 90 SWAP1 2B51 50 POP 2B52 81 DUP2 2B53 81 DUP2 2B54 03 SUB 2B55 60 PUSH1 0x00 2B57 83 DUP4 2B58 01 ADD 2B59 52 MSTORE 2B5A 61 PUSH2 0x2b62 2B5D 81 DUP2 2B5E 61 PUSH2 0x2b26 2B61 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2B50 stack[0] = stack[-1] + 0x20 // @2B59 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @2B5A stack[1] = 0x2b62 // @2B5D stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x2b26, returns to 0x2B62 label_2B62: // Incoming return from call to 0x2B26 at 0x2B61 // Inputs[4] // { // @2B63 stack[-2] // @2B63 stack[-1] // @2B65 stack[-4] // @2B66 stack[-3] // } 2B62 5B JUMPDEST 2B63 90 SWAP1 2B64 50 POP 2B65 91 SWAP2 2B66 90 SWAP1 2B67 50 POP 2B68 56 *JUMP // Stack delta = -3 // Outputs[1] { @2B65 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] 2B69 FE *ASSERT 2B6A A2 LOG2 2B6B 64 PUSH5 0x6970667358 2B71 22 22 2B72 12 SLT 2B73 20 SHA3 2B74 F2 CALLCODE 2B75 EF EF 2B76 F8 F8 2B77 C6 C6 2B78 32 ORIGIN 2B79 2F 2F 2B7A C3 C3 2B7B 03 SUB 2B7C 4F 4F 2B7D 51 MLOAD 2B7E EE EE 2B7F 44 DIFFICULTY 2B80 2C 2C 2B81 60 PUSH1 0x36 2B83 00 *STOP 2B84 67 PUSH8 0x2ae2f8fd531e2b8e 2B8D CE CE 2B8E 41 COINBASE 2B8F 3F EXTCODEHASH 2B90 29 29 2B91 8D DUP14 2B92 05 SDIV 2B93 2B 2B 2B94 64 PUSH5 0x736f6c6343 2B9A 00 *STOP 2B9B 08 ADDMOD 2B9C 13 SGT 2B9D 00 *STOP 2B9E 33 CALLER
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]