Online Solidity Decompiler

« Decompile another contract

Address

0xb0c345743f0bcb6ce22f3bdf74748af179eb632b [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.
0x01ffc9a7 supportsInterface(bytes4)
0x06fdde03 name()
0x081812fc getApproved(uint256)
0x095ea7b3 approve(address,uint256)
0x18160ddd totalSupply()
0x23b872dd transferFrom(address,address,uint256)
0x2f745c59 tokenOfOwnerByIndex(address,uint256)
0x42842e0e safeTransferFrom(address,address,uint256)
0x4f6ccce7 tokenByIndex(uint256)
0x6352211e ownerOf(uint256)
0x6c0360eb baseURI()
0x70a08231 balanceOf(address)
0x715018a6 renounceOwnership()
0x8da5cb5b owner()
0x95d89b41 symbol()
0xa22cb465 setApprovalForAll(address,bool)
0xb88d4fde safeTransferFrom(address,address,uint256,bytes)
0xc87b56dd tokenURI(uint256)
0xe985e9c5 isApprovedForAll(address,address)
0xf2fde38b transferOwnership(address)

Internal Methods

supportsInterface(arg0, arg1) returns (r0)
getApproved(arg0, arg1) returns (r0)
approve(arg0, arg1)
transferFrom(arg0, arg1)
tokenOfOwnerByIndex(arg0, arg1) returns (r0)
tokenByIndex(arg0, arg1) returns (r0)
ownerOf(arg0, arg1) returns (r0)
balanceOf(arg0, arg1) returns (r0)
setApprovalForAll(arg0, arg1)
safeTransferFrom(arg0, arg1)
tokenURI(arg0, arg1) returns (r0)
isApprovedForAll(arg0, arg1) returns (r0)
transferOwnership(arg0, arg1)
name() returns (r0)
func_0A58(arg0) returns (r0)
func_0BCD(arg0, arg1) returns (r0)
totalSupply() returns (r0)
func_0C53(arg0, arg2) returns (r0)
func_0D08(arg0) returns (r0)
baseURI() returns (r0)
renounceOwnership()
owner() returns (r0)
symbol() returns (r0)
func_125D(arg0, arg1, arg2, arg3)
func_1268(arg0, arg3) returns (r0)
func_15A6(arg0, arg1) returns (r0)
func_182F(arg0) returns (r0)
func_1844() returns (r0)
func_184C(arg0, arg1)
func_1905(arg0) returns (r0)
func_1A07(arg0, arg1, arg2)
func_1BA6(arg0, arg1, arg2) returns (r0)
func_1D69(arg0, arg1) returns (r0)
func_1E6C(arg0, arg1) returns (r0)
func_1F5B(arg0, arg1, arg2, arg3)
func_1FCD(arg0) returns (r0)
func_20FD(arg0, arg1, arg2)
func_2102(arg0, arg1, arg2) returns (r0)
func_2221(arg0, arg1, arg2, arg3, arg4, arg12) returns (r0)
func_2251(arg0, arg1) returns (r0)
func_226B(arg0) returns (r0)
func_2280(arg0) returns (r0)
func_2295(arg0, arg1) returns (r0, r1)
func_22C4(arg0, arg1) returns (r0)
func_22E1(arg0, arg1, arg2, arg3) returns (r0)
func_2324(arg0, arg1, arg5, arg6, arg7, arg8) returns (r0)
func_2526(arg0, arg1, arg2, arg3, arg4, arg5) returns (r0)
func_273A(arg0, arg1) returns (r0)
func_27BD(arg0) returns (r0)
func_27CE(arg0) returns (r0)
func_27DF(arg0, arg1) returns (r0, r1)
func_284B(arg0, arg1) returns (r0)
func_290A(arg0) returns (r0)
func_2935(arg0, arg1) returns (r0)
func_294F(arg0, arg1) returns (r0)
func_2969(arg0, arg1, arg2) returns (r0)
func_299E(arg0, arg1, arg2, arg3) returns (r0)
func_2B47(arg0, arg1) returns (r0)
func_2C2F(arg0, arg1) returns (r0)
func_2C9F(arg0, arg1, arg2) returns (r0)
func_2D7B(arg0, arg1, arg2) returns (r0)
func_2E47(arg0, arg1) 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 (0x6c0360eb > var0) { if (0x23b872dd > var0) { if (var0 == 0x01ffc9a7) { // Dispatch table entry for supportsInterface(bytes4) var var1 = 0x017c; var var2 = 0x04; var var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var1 = supportsInterface(var2, var3); var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = !!var1; var temp1 = memory[0x40:0x60]; return memory[temp1:temp1 + (temp0 + 0x20) - temp1]; } else if (var0 == 0x06fdde03) { // Dispatch table entry for name() var1 = 0x019e; var1 = name(); var temp2 = memory[0x40:0x60]; var2 = temp2; var3 = var2; var temp3 = var3 + 0x20; memory[var3:var3 + 0x20] = temp3 - var3; var temp4 = var1; memory[temp3:temp3 + 0x20] = memory[temp4:temp4 + 0x20]; var var4 = temp3 + 0x20; var var5 = temp4 + 0x20; var var6 = memory[temp4:temp4 + 0x20]; var var7 = var6; var var8 = var4; var var9 = var5; var var10 = 0x00; if (var10 >= var7) { label_01DE: var temp5 = var6; var4 = temp5 + var4; var5 = temp5 & 0x1f; if (!var5) { var temp6 = memory[0x40:0x60]; return memory[temp6:temp6 + var4 - temp6]; } else { var temp7 = var5; var temp8 = var4 - temp7; memory[temp8:temp8 + 0x20] = ~(0x0100 ** (0x20 - temp7) - 0x01) & memory[temp8:temp8 + 0x20]; var temp9 = memory[0x40:0x60]; return memory[temp9:temp9 + (temp8 + 0x20) - temp9]; } } else { label_01CC: var temp10 = var10; memory[var8 + temp10:var8 + temp10 + 0x20] = memory[var9 + temp10:var9 + temp10 + 0x20]; var10 = temp10 + 0x20; if (var10 >= var7) { goto label_01DE; } else { goto label_01CC; } } } else if (var0 == 0x081812fc) { // Dispatch table entry for getApproved(uint256) var1 = 0x0245; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var1 = getApproved(var2, var3); var temp11 = memory[0x40:0x60]; memory[temp11:temp11 + 0x20] = var1 & 0xffffffffffffffffffffffffffffffffffffffff; var temp12 = memory[0x40:0x60]; return memory[temp12:temp12 + (temp11 + 0x20) - temp12]; } else if (var0 == 0x095ea7b3) { // Dispatch table entry for approve(address,uint256) var1 = 0x02d3; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } approve(var2, var3); stop(); } else if (var0 == 0x18160ddd) { // Dispatch table entry for totalSupply() var1 = 0x02dd; var1 = totalSupply(); var temp13 = memory[0x40:0x60]; memory[temp13:temp13 + 0x20] = var1; var temp14 = memory[0x40:0x60]; return memory[temp14:temp14 + (temp13 + 0x20) - temp14]; } else { revert(memory[0x00:0x00]); } } else if (var0 == 0x23b872dd) { // Dispatch table entry for transferFrom(address,address,uint256) var1 = 0x035f; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x60) { revert(memory[0x00:0x00]); } transferFrom(var2, var3); stop(); } else if (var0 == 0x2f745c59) { // Dispatch table entry for tokenOfOwnerByIndex(address,uint256) var1 = 0x03ad; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } var1 = tokenOfOwnerByIndex(var2, var3); var temp15 = memory[0x40:0x60]; memory[temp15:temp15 + 0x20] = var1; var temp16 = memory[0x40:0x60]; return memory[temp16:temp16 + (temp15 + 0x20) - temp16]; } else if (var0 == 0x42842e0e) { // Dispatch table entry for safeTransferFrom(address,address,uint256) var1 = 0x042f; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x60) { revert(memory[0x00:0x00]); } safeTransferFrom(var2, var3); stop(); } else if (var0 == 0x4f6ccce7) { // Dispatch table entry for tokenByIndex(uint256) var1 = 0x045d; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var1 = tokenByIndex(var2, var3); var temp17 = memory[0x40:0x60]; memory[temp17:temp17 + 0x20] = var1; var temp18 = memory[0x40:0x60]; return memory[temp18:temp18 + (temp17 + 0x20) - temp18]; } else if (var0 == 0x6352211e) { // Dispatch table entry for ownerOf(uint256) var1 = 0x049f; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var1 = ownerOf(var2, var3); var temp19 = memory[0x40:0x60]; memory[temp19:temp19 + 0x20] = var1 & 0xffffffffffffffffffffffffffffffffffffffff; var temp20 = memory[0x40:0x60]; return memory[temp20:temp20 + (temp19 + 0x20) - temp20]; } else { revert(memory[0x00:0x00]); } } else if (0xa22cb465 > var0) { if (var0 == 0x6c0360eb) { // Dispatch table entry for baseURI() var1 = 0x04e9; var1 = baseURI(); var temp21 = memory[0x40:0x60]; var2 = temp21; var3 = var2; var temp22 = var3 + 0x20; memory[var3:var3 + 0x20] = temp22 - var3; var temp23 = var1; memory[temp22:temp22 + 0x20] = memory[temp23:temp23 + 0x20]; var4 = temp22 + 0x20; var6 = memory[temp23:temp23 + 0x20]; var5 = temp23 + 0x20; var7 = var6; var8 = var4; var9 = var5; var10 = 0x00; if (var10 >= var7) { label_0529: var temp24 = var6; var4 = temp24 + var4; var5 = temp24 & 0x1f; if (!var5) { var temp25 = memory[0x40:0x60]; return memory[temp25:temp25 + var4 - temp25]; } else { var temp26 = var5; var temp27 = var4 - temp26; memory[temp27:temp27 + 0x20] = ~(0x0100 ** (0x20 - temp26) - 0x01) & memory[temp27:temp27 + 0x20]; var temp28 = memory[0x40:0x60]; return memory[temp28:temp28 + (temp27 + 0x20) - temp28]; } } else { label_0517: var temp29 = var10; memory[var8 + temp29:var8 + temp29 + 0x20] = memory[var9 + temp29:var9 + temp29 + 0x20]; var10 = temp29 + 0x20; if (var10 >= var7) { goto label_0529; } else { goto label_0517; } } } else if (var0 == 0x70a08231) { // Dispatch table entry for balanceOf(address) var1 = 0x05a6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var1 = balanceOf(var2, var3); var temp30 = memory[0x40:0x60]; memory[temp30:temp30 + 0x20] = var1; var temp31 = memory[0x40:0x60]; return memory[temp31:temp31 + (temp30 + 0x20) - temp31]; } else if (var0 == 0x715018a6) { // Dispatch table entry for renounceOwnership() var1 = 0x05c4; renounceOwnership(); stop(); } else if (var0 == 0x8da5cb5b) { // Dispatch table entry for owner() var1 = 0x05ce; var1 = owner(); var temp32 = memory[0x40:0x60]; memory[temp32:temp32 + 0x20] = var1 & 0xffffffffffffffffffffffffffffffffffffffff; var temp33 = memory[0x40:0x60]; return memory[temp33:temp33 + (temp32 + 0x20) - temp33]; } else if (var0 == 0x95d89b41) { // Dispatch table entry for symbol() var1 = 0x0618; var1 = symbol(); var temp34 = memory[0x40:0x60]; var2 = temp34; var3 = var2; var temp35 = var3 + 0x20; memory[var3:var3 + 0x20] = temp35 - var3; var temp36 = var1; memory[temp35:temp35 + 0x20] = memory[temp36:temp36 + 0x20]; var4 = temp35 + 0x20; var6 = memory[temp36:temp36 + 0x20]; var5 = temp36 + 0x20; var7 = var6; var8 = var4; var9 = var5; var10 = 0x00; if (var10 >= var7) { label_0658: var temp37 = var6; var4 = temp37 + var4; var5 = temp37 & 0x1f; if (!var5) { var temp38 = memory[0x40:0x60]; return memory[temp38:temp38 + var4 - temp38]; } else { var temp39 = var5; var temp40 = var4 - temp39; memory[temp40:temp40 + 0x20] = ~(0x0100 ** (0x20 - temp39) - 0x01) & memory[temp40:temp40 + 0x20]; var temp41 = memory[0x40:0x60]; return memory[temp41:temp41 + (temp40 + 0x20) - temp41]; } } else { label_0646: var temp42 = var10; memory[var8 + temp42:var8 + temp42 + 0x20] = memory[var9 + temp42:var9 + temp42 + 0x20]; var10 = temp42 + 0x20; if (var10 >= var7) { goto label_0658; } else { goto label_0646; } } } else { revert(memory[0x00:0x00]); } } else if (var0 == 0xa22cb465) { // Dispatch table entry for setApprovalForAll(address,bool) var1 = 0x06e1; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } setApprovalForAll(var2, var3); stop(); } else if (var0 == 0xb88d4fde) { // Dispatch table entry for safeTransferFrom(address,address,uint256,bytes) var1 = 0x07e6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x80) { revert(memory[0x00:0x00]); } safeTransferFrom(var2, var3); stop(); } else if (var0 == 0xc87b56dd) { // Dispatch table entry for tokenURI(uint256) var1 = 0x0814; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var1 = tokenURI(var2, var3); var temp43 = memory[0x40:0x60]; var2 = temp43; var3 = var2; var temp44 = var3 + 0x20; memory[var3:var3 + 0x20] = temp44 - var3; var temp45 = var1; memory[temp44:temp44 + 0x20] = memory[temp45:temp45 + 0x20]; var4 = temp44 + 0x20; var6 = memory[temp45:temp45 + 0x20]; var5 = temp45 + 0x20; var7 = var6; var8 = var4; var9 = var5; var10 = 0x00; if (var10 >= var7) { label_0854: var temp46 = var6; var4 = temp46 + var4; var5 = temp46 & 0x1f; if (!var5) { var temp47 = memory[0x40:0x60]; return memory[temp47:temp47 + var4 - temp47]; } else { var temp48 = var5; var temp49 = var4 - temp48; memory[temp49:temp49 + 0x20] = ~(0x0100 ** (0x20 - temp48) - 0x01) & memory[temp49:temp49 + 0x20]; var temp50 = memory[0x40:0x60]; return memory[temp50:temp50 + (temp49 + 0x20) - temp50]; } } else { label_0842: var temp51 = var10; memory[var8 + temp51:var8 + temp51 + 0x20] = memory[var9 + temp51:var9 + temp51 + 0x20]; var10 = temp51 + 0x20; if (var10 >= var7) { goto label_0854; } else { goto label_0842; } } } else if (var0 == 0xe985e9c5) { // Dispatch table entry for isApprovedForAll(address,address) var1 = 0x08f1; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } var1 = isApprovedForAll(var2, var3); var temp52 = memory[0x40:0x60]; memory[temp52:temp52 + 0x20] = !!var1; var temp53 = memory[0x40:0x60]; return memory[temp53:temp53 + (temp52 + 0x20) - temp53]; } else if (var0 == 0xf2fde38b) { // Dispatch table entry for transferOwnership(address) var1 = 0x094d; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } transferOwnership(var2, var3); stop(); } else { revert(memory[0x00:0x00]); } } function supportsInterface(var arg0, var arg1) returns (var r0) { arg0 = msg.data[arg0:arg0 + 0x20] & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff; memory[0x00:0x20] = arg0 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x00; return storage[keccak256(memory[0x00:0x40])] & 0xff; } function getApproved(var arg0, var arg1) returns (var r0) { arg0 = msg.data[arg0:arg0 + 0x20]; r0 = func_0A58(arg0); // Error: Could not resolve method call return address! } function approve(var arg0, var arg1) { var temp0 = arg0; arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20]; var var0 = 0x00; var var1 = 0x0afe; var var2 = arg1; var1 = func_0D08(var2); var0 = var1; if (arg0 & 0xffffffffffffffffffffffffffffffffffffffff != var0 & 0xffffffffffffffffffffffffffffffffffffffff) { var1 = var0 & 0xffffffffffffffffffffffffffffffffffffffff; var2 = 0x0ba4; var2 = func_1844(); var1 = var2 & 0xffffffffffffffffffffffffffffffffffffffff == var1; if (var1) { label_0BD3: if (var1) { var1 = 0x0c32; var2 = arg0; var var3 = arg1; func_184C(var2, var3); return; } else { var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp2 = temp1 + 0x04; var temp3 = temp2 + 0x20; memory[temp2:temp2 + 0x20] = temp3 - temp2; memory[temp3:temp3 + 0x20] = 0x38; var temp4 = temp3 + 0x20; memory[temp4:temp4 + 0x38] = code[0x303d:0x3075]; var temp5 = memory[0x40:0x60]; revert(memory[temp5:temp5 + (temp4 + 0x40) - temp5]); } } else { var1 = 0x0bd2; var2 = var0; var3 = 0x0bcd; var3 = func_1844(); var1 = func_0BCD(var2, var3); goto label_0BD3; } } else { var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp7 = temp6 + 0x04; var temp8 = temp7 + 0x20; memory[temp7:temp7 + 0x20] = temp8 - temp7; memory[temp8:temp8 + 0x20] = 0x21; var temp9 = temp8 + 0x20; memory[temp9:temp9 + 0x21] = code[0x3123:0x3144]; var temp10 = memory[0x40:0x60]; revert(memory[temp10:temp10 + (temp9 + 0x40) - temp10]); } } function transferFrom(var arg0, var arg1) { var temp0 = arg0; var temp1 = temp0 + 0x20; arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; arg1 = msg.data[temp1:temp1 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; var var0 = msg.data[temp1 + 0x20:temp1 + 0x20 + 0x20]; var var1 = 0x0c59; var var2 = 0x0c53; var2 = func_1844(); var1 = func_0C53(var0, var2); if (var1) { var1 = 0x0cb9; var2 = arg0; var var3 = arg1; var var4 = var0; func_1A07(var2, var3, var4); return; } else { var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp3 = temp2 + 0x04; var temp4 = temp3 + 0x20; memory[temp3:temp3 + 0x20] = temp4 - temp3; memory[temp4:temp4 + 0x20] = 0x31; var temp5 = temp4 + 0x20; memory[temp5:temp5 + 0x31] = code[0x3144:0x3175]; var temp6 = memory[0x40:0x60]; revert(memory[temp6:temp6 + (temp5 + 0x40) - temp6]); } } function tokenOfOwnerByIndex(var arg0, var arg1) returns (var r0) { var temp0 = arg0; arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20]; var var0 = 0x00; var var1 = 0x0cd6; var var2 = 0x01; var var3 = arg0; var var4 = arg1; return func_1BA6(var2, var3, var4); } function safeTransferFrom(var arg0, var arg1) { var temp0 = arg0; var temp1 = temp0 + 0x20; arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; arg1 = msg.data[temp1:temp1 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; var var0 = msg.data[temp1 + 0x20:temp1 + 0x20 + 0x20]; var var1 = 0x0cf9; var var2 = arg0; var var3 = arg1; var var4 = var0; var temp2 = memory[0x40:0x60]; var var5 = temp2; memory[0x40:0x60] = var5 + 0x20; memory[var5:var5 + 0x20] = 0x00; func_125D(var2, var3, var4, var5); } function tokenByIndex(var arg0, var arg1) returns (var r0) { return msg.data[arg0:arg0 + 0x20]; } function ownerOf(var arg0, var arg1) returns (var r0) { arg0 = msg.data[arg0:arg0 + 0x20]; r0 = func_0D08(arg0); // Error: Could not resolve method call return address! } function balanceOf(var arg0, var arg1) returns (var r0) { arg0 = msg.data[arg0:arg0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; arg1 = 0x00; if (arg0 & 0xffffffffffffffffffffffffffffffffffffffff != arg1 & 0xffffffffffffffffffffffffffffffffffffffff) { var var0 = 0x0e62; var var1 = 0x01; var var2 = arg0; return func_1E6C(var1, var2); } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp1 = temp0 + 0x04; var temp2 = temp1 + 0x20; memory[temp1:temp1 + 0x20] = temp2 - temp1; memory[temp2:temp2 + 0x20] = 0x2a; var temp3 = temp2 + 0x20; memory[temp3:temp3 + 0x2a] = code[0x3075:0x309f]; var temp4 = memory[0x40:0x60]; revert(memory[temp4:temp4 + (temp3 + 0x40) - temp4]); } } function setApprovalForAll(var arg0, var arg1) { var temp0 = arg0; arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; arg1 = !!msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20]; var var0 = 0x10ad; var0 = func_1844(); if (arg0 & 0xffffffffffffffffffffffffffffffffffffffff != var0 & 0xffffffffffffffffffffffffffffffffffffffff) { var0 = arg1; var var1 = 0x09; var var2 = 0x00; var var3 = 0x115b; var3 = func_1844(); var temp1 = var2; memory[temp1:temp1 + 0x20] = var3 & 0xffffffffffffffffffffffffffffffffffffffff; var temp2 = temp1 + 0x20; memory[temp2:temp2 + 0x20] = var1; var temp3 = keccak256(memory[0x00:0x00 + temp2 + 0x20]); var temp4 = arg0; memory[0x00:0x20] = temp4 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp3; var temp5 = keccak256(memory[0x00:0x40]); storage[temp5] = !!var0 | (storage[temp5] & ~0xff); var0 = temp4 & 0xffffffffffffffffffffffffffffffffffffffff; var1 = 0x1208; var1 = func_1844(); var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = !!arg1; var temp7 = memory[0x40:0x60]; log(memory[temp7:temp7 + (temp6 + 0x20) - temp7], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2]]); return; } else { var temp8 = memory[0x40:0x60]; memory[temp8:temp8 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp9 = temp8 + 0x04; var temp10 = temp9 + 0x20; memory[temp9:temp9 + 0x20] = temp10 - temp9; memory[temp10:temp10 + 0x20] = 0x19; var temp11 = temp10 + 0x20; memory[temp11:temp11 + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000; var temp12 = memory[0x40:0x60]; revert(memory[temp12:temp12 + (temp11 + 0x20) - temp12]); } } function safeTransferFrom(var arg0, var arg1) { var temp0 = arg0; var temp1 = temp0 + arg1; var temp2 = temp0 + 0x20; arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; var temp3 = temp2 + 0x20; arg1 = msg.data[temp2:temp2 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; var temp4 = temp3 + 0x20; var var0 = msg.data[temp3:temp3 + 0x20]; var var1 = temp1; var var2 = temp0; var var3 = temp4 + 0x20; var var4 = msg.data[temp4:temp4 + 0x20]; if (var4 > 0x0100000000) { revert(memory[0x00:0x00]); } var temp5 = var2 + var4; var4 = temp5; if (var4 + 0x20 > var1) { revert(memory[0x00:0x00]); } var temp6 = var4; var temp7 = msg.data[temp6:temp6 + 0x20]; var4 = temp7; var temp8 = var3; var3 = temp6 + 0x20; var var5 = temp8; if ((var4 > 0x0100000000) | (var3 + var4 > var1)) { revert(memory[0x00:0x00]); } var temp9 = var4; var temp10 = memory[0x40:0x60]; memory[0x40:0x60] = temp10 + (temp9 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp10:temp10 + 0x20] = temp9; var temp11 = temp10 + 0x20; memory[temp11:temp11 + temp9] = msg.data[var3:var3 + temp9]; memory[temp11 + temp9:temp11 + temp9 + 0x20] = 0x00; var1 = temp10; func_125D(arg0, arg1, var0, var1); // Error: Could not resolve method call return address! } function tokenURI(var arg0, var arg1) returns (var r0) { arg0 = msg.data[arg0:arg0 + 0x20]; arg1 = 0x60; var var0 = 0x12e0; var var1 = arg0; var0 = func_182F(var1); if (var0) { var0 = 0x60; memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x0c; var temp0 = keccak256(memory[0x00:0x40]); var temp1 = storage[temp0]; var temp2 = (!(temp1 & 0x01) * 0x0100 - 0x01 & temp1) / 0x02; var temp3 = memory[0x40:0x60]; memory[0x40:0x60] = temp3 + (temp2 + 0x1f) / 0x20 * 0x20 + 0x20; var1 = temp3; var var2 = temp0; var var3 = temp2; memory[var1:var1 + 0x20] = var3; var var4 = var1 + 0x20; var var5 = var2; var temp4 = storage[var5]; var var6 = (!(temp4 & 0x01) * 0x0100 - 0x01 & temp4) / 0x02; if (!var6) { label_13DE: var0 = var1; var1 = 0x60; var2 = 0x13ef; var2 = baseURI(); var1 = var2; if (memory[var1:var1 + 0x20] == 0x00) { arg1 = var0; goto label_15A1; } else if (memory[var0:var0 + 0x20] <= 0x00) { var2 = var1; var3 = 0x14e0; var4 = arg0; var3 = func_1FCD(var4); var4 = memory[0x40:0x60] + 0x20; var5 = var4; var temp5 = var2; var6 = temp5 + 0x20; var var7 = memory[temp5:temp5 + 0x20]; var var8 = var7; var var9 = var5; var var10 = var6; if (var8 < 0x20) { label_1516: var temp6 = 0x0100 ** (0x20 - var8) - 0x01; var temp7 = var9; memory[temp7:temp7 + 0x20] = (memory[var10:var10 + 0x20] & ~temp6) | (memory[temp7:temp7 + 0x20] & temp6); var temp8 = var7 + var5; var5 = temp8; var temp9 = var3; var7 = memory[temp9:temp9 + 0x20]; var6 = temp9 + 0x20; var8 = var7; var9 = var5; var10 = var6; if (var8 < 0x20) { label_1567: var temp10 = 0x0100 ** (0x20 - var8) - 0x01; var temp11 = var9; memory[temp11:temp11 + 0x20] = (memory[var10:var10 + 0x20] & ~temp10) | (memory[temp11:temp11 + 0x20] & temp10); var temp12 = var7 + var5; var temp13 = memory[0x40:0x60]; memory[temp13:temp13 + 0x20] = temp12 - temp13 - 0x20; memory[0x40:0x60] = temp12; arg1 = temp13; label_15A1: return arg1; } else { label_154D: var temp14 = var10; var temp15 = var9; memory[temp15:temp15 + 0x20] = memory[temp14:temp14 + 0x20]; var9 = temp15 + 0x20; var10 = temp14 + 0x20; var8 = var8 - 0x20; if (var8 < 0x20) { goto label_1567; } else { goto label_154D; } } } else { label_14FC: var temp16 = var10; var temp17 = var9; memory[temp17:temp17 + 0x20] = memory[temp16:temp16 + 0x20]; var9 = temp17 + 0x20; var10 = temp16 + 0x20; var8 = var8 - 0x20; if (var8 < 0x20) { goto label_1516; } else { goto label_14FC; } } } else { var temp18 = var1; var2 = temp18; var3 = var0; var4 = memory[0x40:0x60] + 0x20; var5 = var4; var7 = memory[var2:var2 + 0x20]; var6 = var2 + 0x20; var8 = var7; var9 = var5; var10 = var6; if (var8 < 0x20) { label_1447: var temp19 = 0x0100 ** (0x20 - var8) - 0x01; var temp20 = var9; memory[temp20:temp20 + 0x20] = (memory[var10:var10 + 0x20] & ~temp19) | (memory[temp20:temp20 + 0x20] & temp19); var temp21 = var7 + var5; var5 = temp21; var temp22 = var3; var6 = temp22 + 0x20; var7 = memory[temp22:temp22 + 0x20]; var8 = var7; var9 = var5; var10 = var6; if (var8 < 0x20) { label_1498: var temp23 = 0x0100 ** (0x20 - var8) - 0x01; var temp24 = var9; memory[temp24:temp24 + 0x20] = (memory[var10:var10 + 0x20] & ~temp23) | (memory[temp24:temp24 + 0x20] & temp23); var temp25 = var7 + var5; var temp26 = memory[0x40:0x60]; memory[temp26:temp26 + 0x20] = temp25 - temp26 - 0x20; memory[0x40:0x60] = temp25; arg1 = temp26; goto label_15A1; } else { label_147E: var temp27 = var10; var temp28 = var9; memory[temp28:temp28 + 0x20] = memory[temp27:temp27 + 0x20]; var9 = temp28 + 0x20; var10 = temp27 + 0x20; var8 = var8 - 0x20; if (var8 < 0x20) { goto label_1498; } else { goto label_147E; } } } else { label_142D: var temp29 = var10; var temp30 = var9; memory[temp30:temp30 + 0x20] = memory[temp29:temp29 + 0x20]; var9 = temp30 + 0x20; var10 = temp29 + 0x20; var8 = var8 - 0x20; if (var8 < 0x20) { goto label_1447; } else { goto label_142D; } } } } else if (0x1f < var6) { var temp31 = var4; var temp32 = temp31 + var6; var4 = temp32; memory[0x00:0x20] = var5; var temp33 = keccak256(memory[0x00:0x20]); memory[temp31:temp31 + 0x20] = storage[temp33]; var5 = temp33 + 0x01; var6 = temp31 + 0x20; if (var4 <= var6) { goto label_13D5; } label_13C1: var temp34 = var5; var temp35 = var6; memory[temp35:temp35 + 0x20] = storage[temp34]; var5 = temp34 + 0x01; var6 = temp35 + 0x20; if (var4 > var6) { goto label_13C1; } label_13D5: var temp36 = var4; var temp37 = temp36 + (var6 - temp36 & 0x1f); var6 = temp36; var4 = temp37; goto label_13DE; } else { var temp38 = var4; memory[temp38:temp38 + 0x20] = storage[var5] / 0x0100 * 0x0100; var4 = temp38 + 0x20; var6 = var6; goto label_13DE; } } else { var temp39 = memory[0x40:0x60]; memory[temp39:temp39 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp40 = temp39 + 0x04; var temp41 = temp40 + 0x20; memory[temp40:temp40 + 0x20] = temp41 - temp40; memory[temp41:temp41 + 0x20] = 0x2f; var temp42 = temp41 + 0x20; memory[temp42:temp42 + 0x2f] = code[0x30f4:0x3123]; var temp43 = memory[0x40:0x60]; revert(memory[temp43:temp43 + (temp42 + 0x40) - temp43]); } } function isApprovedForAll(var arg0, var arg1) returns (var r0) { var temp0 = arg0; arg0 = msg.data[temp0:temp0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; r0 = func_15A6(arg0, arg1); // Error: Could not resolve method call return address! } function transferOwnership(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; arg1 = 0x1642; arg1 = func_1844(); arg1 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; var var0 = 0x1660; var0 = owner(); if (var0 & 0xffffffffffffffffffffffffffffffffffffffff != arg1) { var temp7 = memory[0x40:0x60]; memory[temp7:temp7 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp8 = temp7 + 0x04; var temp9 = temp8 + 0x20; memory[temp8:temp8 + 0x20] = temp9 - temp8; memory[temp9:temp9 + 0x20] = 0x20; var temp10 = temp9 + 0x20; memory[temp10:temp10 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572; var temp11 = memory[0x40:0x60]; revert(memory[temp11:temp11 + (temp10 + 0x20) - temp11]); } else if (arg0 & 0xffffffffffffffffffffffffffffffffffffffff != 0xffffffffffffffffffffffffffffffffffffffff & 0x00) { var temp0 = arg0; var temp1 = memory[0x40:0x60]; log(memory[temp1:temp1 + memory[0x40:0x60] - temp1], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0e] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); storage[0x0e] = (temp0 & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[0x0e] & ~0xffffffffffffffffffffffffffffffffffffffff); return; } else { var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp3 = temp2 + 0x04; var temp4 = temp3 + 0x20; memory[temp3:temp3 + 0x20] = temp4 - temp3; memory[temp4:temp4 + 0x20] = 0x26; var temp5 = temp4 + 0x20; memory[temp5:temp5 + 0x26] = code[0x2fa1:0x2fc7]; var temp6 = memory[0x40:0x60]; revert(memory[temp6:temp6 + (temp5 + 0x40) - temp6]); } } function name() returns (var r0) { var var0 = 0x60; var temp0 = storage[0x0a]; var temp1 = (!(temp0 & 0x01) * 0x0100 - 0x01 & temp0) / 0x02; var temp2 = memory[0x40:0x60]; memory[0x40:0x60] = temp2 + (temp1 + 0x1f) / 0x20 * 0x20 + 0x20; var var1 = temp2; var var2 = 0x0a; var var3 = temp1; memory[var1:var1 + 0x20] = var3; var var4 = var1 + 0x20; var var5 = var2; var temp3 = storage[var5]; var var6 = (!(temp3 & 0x01) * 0x0100 - 0x01 & temp3) / 0x02; if (!var6) { label_0A4E: return var1; } else if (0x1f < var6) { var temp4 = var4; var temp5 = temp4 + var6; var4 = temp5; memory[0x00:0x20] = var5; var temp6 = keccak256(memory[0x00:0x20]); memory[temp4:temp4 + 0x20] = storage[temp6]; var5 = temp6 + 0x01; var6 = temp4 + 0x20; if (var4 <= var6) { goto label_0A45; } label_0A31: var temp7 = var5; var temp8 = var6; memory[temp8:temp8 + 0x20] = storage[temp7]; var5 = temp7 + 0x01; var6 = temp8 + 0x20; if (var4 > var6) { goto label_0A31; } label_0A45: var temp9 = var4; var temp10 = temp9 + (var6 - temp9 & 0x1f); var6 = temp9; var4 = temp10; goto label_0A4E; } else { var temp11 = var4; memory[temp11:temp11 + 0x20] = storage[var5] / 0x0100 * 0x0100; var4 = temp11 + 0x20; var6 = var6; goto label_0A4E; } } function func_0A58(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x0a63; var var2 = arg0; var1 = func_182F(var2); if (var1) { memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x08; return storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffffffffffffffffffffffffffff; } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp1 = temp0 + 0x04; var temp2 = temp1 + 0x20; memory[temp1:temp1 + 0x20] = temp2 - temp1; memory[temp2:temp2 + 0x20] = 0x2c; var temp3 = temp2 + 0x20; memory[temp3:temp3 + 0x2c] = code[0x309f:0x30cb]; var temp4 = memory[0x40:0x60]; revert(memory[temp4:temp4 + (temp3 + 0x40) - temp4]); } } function func_0BCD(var arg0, var arg1) returns (var r0) { r0 = func_15A6(arg0, arg1); // Error: Could not resolve method call return address! } function totalSupply() returns (var r0) { var var0 = 0x00; var var1 = 0x0c43; var var2 = 0x01; return func_1905(var2); } function func_0C53(var arg0, var arg1) returns (var r0) { var var0 = arg0; var var1 = 0x00; var var2 = 0x191e; var var3 = var0; var2 = func_182F(var3); if (var2) { var2 = 0x00; var3 = 0x197e; var var4 = var0; var3 = func_0D08(var4); var2 = var3; var3 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff == var2 & 0xffffffffffffffffffffffffffffffffffffffff; if (var3) { label_19ED: if (var3) { label_19FE: return var3; } else { var3 = 0x19fd; var4 = var2; var var5 = arg1; var3 = func_15A6(var4, var5); goto label_19FE; } } else { var3 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; var4 = 0x19d5; var5 = var0; var4 = func_0A58(var5); var3 = var4 & 0xffffffffffffffffffffffffffffffffffffffff == var3; goto label_19ED; } } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp1 = temp0 + 0x04; var temp2 = temp1 + 0x20; memory[temp1:temp1 + 0x20] = temp2 - temp1; memory[temp2:temp2 + 0x20] = 0x2c; var temp3 = temp2 + 0x20; memory[temp3:temp3 + 0x2c] = code[0x3011:0x303d]; var temp4 = memory[0x40:0x60]; revert(memory[temp4:temp4 + (temp3 + 0x40) - temp4]); } } function func_0D08(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x0d1e; var var2 = 0x01; var var3 = arg0; var1 = func_1D69(var2, var3); label_0D1E: return var1; } function baseURI() returns (var r0) { var var0 = 0x60; var temp0 = storage[0x0d]; var temp1 = (!(temp0 & 0x01) * 0x0100 - 0x01 & temp0) / 0x02; var temp2 = memory[0x40:0x60]; memory[0x40:0x60] = temp2 + (temp1 + 0x1f) / 0x20 * 0x20 + 0x20; var var1 = temp2; var var2 = 0x0d; var var3 = temp1; memory[var1:var1 + 0x20] = var3; var var4 = var1 + 0x20; var var5 = var2; var temp3 = storage[var5]; var var6 = (!(temp3 & 0x01) * 0x0100 - 0x01 & temp3) / 0x02; if (!var6) { label_0DBD: return var1; } else if (0x1f < var6) { var temp4 = var4; var temp5 = temp4 + var6; var4 = temp5; memory[0x00:0x20] = var5; var temp6 = keccak256(memory[0x00:0x20]); memory[temp4:temp4 + 0x20] = storage[temp6]; var5 = temp6 + 0x01; var6 = temp4 + 0x20; if (var4 <= var6) { goto label_0DB4; } label_0DA0: var temp7 = var5; var temp8 = var6; memory[temp8:temp8 + 0x20] = storage[temp7]; var5 = temp7 + 0x01; var6 = temp8 + 0x20; if (var4 > var6) { goto label_0DA0; } label_0DB4: var temp9 = var4; var temp10 = temp9 + (var6 - temp9 & 0x1f); var6 = temp9; var4 = temp10; goto label_0DBD; } else { var temp11 = var4; memory[temp11:temp11 + 0x20] = storage[var5] / 0x0100 * 0x0100; var4 = temp11 + 0x20; var6 = var6; goto label_0DBD; } } function renounceOwnership() { var var0 = 0x0e71; var0 = func_1844(); var0 = var0 & 0xffffffffffffffffffffffffffffffffffffffff; var var1 = 0x0e8f; var1 = owner(); if (var1 & 0xffffffffffffffffffffffffffffffffffffffff == var0) { var temp0 = memory[0x40:0x60]; log(memory[temp0:temp0 + memory[0x40:0x60] - temp0], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0e] & 0xffffffffffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffffffffffff & 0x00]); storage[0x0e] = (storage[0x0e] & ~0xffffffffffffffffffffffffffffffffffffffff) | 0x00; return; } else { var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp2 = temp1 + 0x04; var temp3 = temp2 + 0x20; memory[temp2:temp2 + 0x20] = temp3 - temp2; memory[temp3:temp3 + 0x20] = 0x20; var temp4 = temp3 + 0x20; memory[temp4:temp4 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572; var temp5 = memory[0x40:0x60]; revert(memory[temp5:temp5 + (temp4 + 0x20) - temp5]); } } function owner() returns (var r0) { return storage[0x0e] & 0xffffffffffffffffffffffffffffffffffffffff; } function symbol() returns (var r0) { var var0 = 0x60; var temp0 = storage[0x0b]; var temp1 = (!(temp0 & 0x01) * 0x0100 - 0x01 & temp0) / 0x02; var temp2 = memory[0x40:0x60]; memory[0x40:0x60] = temp2 + (temp1 + 0x1f) / 0x20 * 0x20 + 0x20; var var1 = temp2; var var2 = 0x0b; var var3 = temp1; memory[var1:var1 + 0x20] = var3; var var4 = var1 + 0x20; var var5 = var2; var temp3 = storage[var5]; var var6 = (!(temp3 & 0x01) * 0x0100 - 0x01 & temp3) / 0x02; if (!var6) { label_109B: return var1; } else if (0x1f < var6) { var temp4 = var4; var temp5 = temp4 + var6; var4 = temp5; memory[0x00:0x20] = var5; var temp6 = keccak256(memory[0x00:0x20]); memory[temp4:temp4 + 0x20] = storage[temp6]; var5 = temp6 + 0x01; var6 = temp4 + 0x20; if (var4 <= var6) { goto label_1092; } label_107E: var temp7 = var5; var temp8 = var6; memory[temp8:temp8 + 0x20] = storage[temp7]; var5 = temp7 + 0x01; var6 = temp8 + 0x20; if (var4 > var6) { goto label_107E; } label_1092: var temp9 = var4; var temp10 = temp9 + (var6 - temp9 & 0x1f); var6 = temp9; var4 = temp10; goto label_109B; } else { var temp11 = var4; memory[temp11:temp11 + 0x20] = storage[var5] / 0x0100 * 0x0100; var6 = var6; var4 = temp11 + 0x20; goto label_109B; } } function func_125D(var arg0, var arg1, var arg2, var arg3) { var var0 = 0x126e; var var1 = 0x1268; var1 = func_1844(); var0 = func_1268(arg2, var1); if (var0) { var0 = 0x12cf; var1 = arg0; var var2 = arg1; var var3 = arg2; var var4 = arg3; func_1F5B(var1, var2, var3, var4); return; } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp1 = temp0 + 0x04; var temp2 = temp1 + 0x20; memory[temp1:temp1 + 0x20] = temp2 - temp1; memory[temp2:temp2 + 0x20] = 0x31; var temp3 = temp2 + 0x20; memory[temp3:temp3 + 0x31] = code[0x3144:0x3175]; var temp4 = memory[0x40:0x60]; revert(memory[temp4:temp4 + (temp3 + 0x40) - temp4]); } } function func_1268(var arg0, var arg1) returns (var r0) { var var0 = arg0; var var1 = 0x00; var var2 = 0x191e; var var3 = var0; var2 = func_182F(var3); if (var2) { var2 = 0x00; var3 = 0x197e; var var4 = var0; var3 = func_0D08(var4); var2 = var3; var3 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff == var2 & 0xffffffffffffffffffffffffffffffffffffffff; if (var3) { label_19ED: if (var3) { label_19FE: return var3; } else { var3 = 0x19fd; var4 = var2; var var5 = arg1; var3 = func_15A6(var4, var5); goto label_19FE; } } else { var3 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; var4 = 0x19d5; var5 = var0; var4 = func_0A58(var5); var3 = var4 & 0xffffffffffffffffffffffffffffffffffffffff == var3; goto label_19ED; } } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp1 = temp0 + 0x04; var temp2 = temp1 + 0x20; memory[temp1:temp1 + 0x20] = temp2 - temp1; memory[temp2:temp2 + 0x20] = 0x2c; var temp3 = temp2 + 0x20; memory[temp3:temp3 + 0x2c] = code[0x3011:0x303d]; var temp4 = memory[0x40:0x60]; revert(memory[temp4:temp4 + (temp3 + 0x40) - temp4]); } } function func_15A6(var arg0, var arg1) returns (var r0) { memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x09; var temp0 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp0; return storage[keccak256(memory[0x00:0x40])] & 0xff; } function func_182F(var arg0) returns (var r0) { var var0 = 0x00; var var1 = arg0; var var2 = 0x183c; var var3 = 0x01; var2 = func_1905(var3); return var2 > var1; } function func_1844() returns (var r0) { return msg.sender; } function func_184C(var arg0, var arg1) { var temp0 = arg0; memory[0x00:0x20] = arg1; memory[0x20:0x40] = 0x08; var temp1 = keccak256(memory[0x00:0x40]); storage[temp1] = (temp0 & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[temp1] & ~0xffffffffffffffffffffffffffffffffffffffff); var var0 = arg1; var var1 = temp0 & 0xffffffffffffffffffffffffffffffffffffffff; var var2 = 0x18bf; var var3 = var0; var2 = func_0D08(var3); var temp2 = memory[0x40:0x60]; log(memory[temp2:temp2 + memory[0x40:0x60] - temp2], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2], stack[-3]]); } function func_1905(var arg0) returns (var r0) { return storage[arg0 + 0x04]; } function func_1A07(var arg0, var arg1, var arg2) { var var0 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var var1 = 0x1a27; var var2 = arg2; var1 = func_0D08(var2); if (var1 & 0xffffffffffffffffffffffffffffffffffffffff != var0) { var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp7 = temp6 + 0x04; var temp8 = temp7 + 0x20; memory[temp7:temp7 + 0x20] = temp8 - temp7; memory[temp8:temp8 + 0x20] = 0x29; var temp9 = temp8 + 0x20; memory[temp9:temp9 + 0x29] = code[0x30cb:0x30f4]; var temp10 = memory[0x40:0x60]; revert(memory[temp10:temp10 + (temp9 + 0x40) - temp10]); } else if (arg1 & 0xffffffffffffffffffffffffffffffffffffffff != 0xffffffffffffffffffffffffffffffffffffffff & 0x00) { var0 = 0x1b24; var1 = arg0; var2 = arg1; var var3 = arg2; func_20FD(var1, var2, var3); var0 = 0x1b2f; var1 = 0x00; var2 = arg2; func_184C(var1, var2); var0 = 0x1b45; var1 = 0x01; var2 = arg2; var3 = arg1; var0 = func_2102(var1, var2, var3); label_1B45: var temp0 = memory[0x40:0x60]; log(memory[temp0:temp0 + memory[0x40:0x60] - temp0], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2]]); return; } else { var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp2 = temp1 + 0x04; var temp3 = temp2 + 0x20; memory[temp2:temp2 + 0x20] = temp3 - temp2; memory[temp3:temp3 + 0x20] = 0x24; var temp4 = temp3 + 0x20; memory[temp4:temp4 + 0x24] = code[0x2fc7:0x2feb]; var temp5 = memory[0x40:0x60]; revert(memory[temp5:temp5 + (temp4 + 0x40) - temp5]); } } function func_1BA6(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x00; var var1 = var0; var var2 = 0x1bfd; memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = arg0; var var3 = keccak256(memory[0x00:0x40]); var var4 = 0x00; var2 = func_2251(var3, var4); var temp0 = var2; var1 = temp0; memory[0x00:0x20] = var1; memory[0x20:0x40] = arg0 + 0x01; var2 = storage[keccak256(memory[0x00:0x40])]; if (arg2 >= var2 - var1) { var temp1 = arg2 - (var2 - var1); arg2 = temp1; if (arg2 >= 0x01) { label_1C4B: var3 = 0x01; var4 = 0x1c9b; memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = arg0; var var5 = keccak256(memory[0x00:0x40]); var4 = func_226B(var5); label_1C9B: if (var3 < var4) { var4 = 0x1cf5; memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = arg0; var5 = keccak256(memory[0x00:0x40]); var var6 = var3; var4 = func_2251(var5, var6); var temp2 = var4; var1 = temp2; memory[0x00:0x20] = var1; memory[0x20:0x40] = arg0 + 0x01; var2 = storage[keccak256(memory[0x00:0x40])]; if (arg2 >= var2 - var1) { var temp3 = arg2 - (var2 - var1); arg2 = temp3; if (arg2 >= 0x01) { label_1D42: var3 = var3 + 0x01; var4 = 0x1c9b; memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = arg0; var5 = keccak256(memory[0x00:0x40]); var4 = func_226B(var5); goto label_1C9B; } else if (0x00) { goto label_1D42; } else { revert(memory[0x00:0x00]); } } else { var0 = var1 + arg2; goto label_1D62; } } else if (0x00) { var0 = 0x00; label_1D62: return var0; } else { revert(memory[0x00:0x00]); } } else if (0x00) { goto label_1C4B; } else { revert(memory[0x00:0x00]); } } else { var0 = var1 + arg2; goto label_1D62; } } function func_1D69(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = var0; var var2 = 0x1d78; var var3 = arg0 + 0x02; var2 = func_2280(var3); var1 = var2; if (var1 <= storage[arg0 + 0x06]) { label_1DB7: memory[0x00:0x20] = 0x00; memory[0x20:0x40] = arg0 + 0x01; var2 = storage[keccak256(memory[0x00:0x40])]; if (arg1 >= var2) { var3 = 0x00; if (var3 >= var1 - 0x01) { label_1E5E: return 0x00; } else { label_1E0B: var var4 = var2; memory[0x00:0x20] = var4; memory[0x20:0x40] = arg0 + 0x01; var2 = storage[keccak256(memory[0x00:0x40])]; if (arg1 >= var2) { var3 = var3 + 0x01; if (var3 >= var1 - 0x01) { goto label_1E5E; } else { goto label_1E0B; } } else { var var5 = 0x1e45; var var6 = arg0 + 0x02; var var7 = var4; var5 = func_22C4(var6, var7); var0 = var5; label_1E66: return var0; } } } else { var3 = 0x1df0; var4 = arg0 + 0x02; var5 = 0x00; var3 = func_22C4(var4, var5); var0 = var3; goto label_1E66; } } else { var2 = 0x00; var3 = var2; var4 = 0x1d9f; var5 = arg0 + 0x02; var6 = arg1; var4, var5 = func_2295(var5, var6); var3 = var5; var2 = var4; if (!var2) { goto label_1DB7; } var0 = var3; goto label_1E66; } } function func_1E6C(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x00; var var2 = 0x00; var var3 = 0x1ec2; memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = arg0; var var4 = keccak256(memory[0x00:0x40]); var3 = func_226B(var4); label_1EC2: if (var2 >= var3) { return var1; } var3 = 0x00; var4 = 0x1f1e; memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = arg0; var var5 = keccak256(memory[0x00:0x40]); var var6 = var2; var4 = func_2251(var5, var6); var temp0 = var4; memory[0x00:0x20] = temp0; memory[0x20:0x40] = arg0 + 0x01; var1 = var1 + (storage[keccak256(memory[0x00:0x40])] - temp0); var2 = var2 + 0x01; var3 = 0x1ec2; memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = arg0; var4 = keccak256(memory[0x00:0x40]); var3 = func_226B(var4); goto label_1EC2; } function func_1F5B(var arg0, var arg1, var arg2, var arg3) { var var0 = 0x1f66; var var1 = arg0; var var2 = arg1; var var3 = arg2; func_1A07(var1, var2, var3); var0 = 0x1f72; var1 = arg0; var2 = arg1; var3 = arg2; var var4 = arg3; var0 = func_22E1(var1, var2, var3, var4); if (var0) { return; } var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp1 = temp0 + 0x04; var temp2 = temp1 + 0x20; memory[temp1:temp1 + 0x20] = temp2 - temp1; memory[temp2:temp2 + 0x20] = 0x32; var temp3 = temp2 + 0x20; memory[temp3:temp3 + 0x32] = code[0x2f6f:0x2fa1]; var temp4 = memory[0x40:0x60]; revert(memory[temp4:temp4 + (temp3 + 0x40) - temp4]); } function func_1FCD(var arg0) returns (var r0) { var var0 = 0x60; if (arg0 != 0x00) { var var1 = arg0; var var2 = 0x00; if (var1 == 0x00) { label_203F: var var3 = 0x60; var temp0 = var2; var temp1 = memory[0x40:0x60]; var var4 = temp1; var var5 = temp0; memory[var4:var4 + 0x20] = var5; memory[0x40:0x60] = var4 + (var5 + 0x1f & ~0x1f) + 0x20; if (!var5) { var3 = var4; var4 = var2 - 0x01; var1 = arg0; if (var1 == 0x00) { label_20F0: var0 = var3; label_20F8: return var0; } else { label_208C: var5 = 0x0a; var var6 = var1; if (!var5) { assert(); } var5 = var6 % var5 + 0x30 << 0xf8; var6 = var3; var temp2 = var4; var var7 = temp2; var4 = var7 - 0x01; if (var7 >= memory[var6:var6 + 0x20]) { assert(); } memory[var7 + 0x20 + var6:var7 + 0x20 + var6 + 0x01] = byte(var5 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, 0x00); var5 = 0x0a; var6 = var1; if (!var5) { assert(); } var1 = var6 / var5; if (var1 == 0x00) { goto label_20F0; } else { goto label_208C; } } } else { var temp3 = var5; memory[var4 + 0x20:var4 + 0x20 + temp3] = code[code.length:code.length + temp3]; var3 = var4; var4 = var2 - 0x01; var1 = arg0; if (var1 == 0x00) { goto label_20F0; } else { goto label_208C; } } } else { label_2026: var2 = var2 + 0x01; var3 = 0x0a; var4 = var1; if (!var3) { assert(); } var1 = var4 / var3; if (var1 == 0x00) { goto label_203F; } else { goto label_2026; } } } else { var temp4 = memory[0x40:0x60]; memory[0x40:0x60] = temp4 + 0x40; memory[temp4:temp4 + 0x20] = 0x01; memory[temp4 + 0x20:temp4 + 0x20 + 0x20] = 0x3000000000000000000000000000000000000000000000000000000000000000; var0 = temp4; goto label_20F8; } } function func_20FD(var arg0, var arg1, var arg2) {} function func_2102(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x00; var var1 = var0; var var2 = 0x2111; var var3 = arg0 + 0x02; var2 = func_2280(var3); var1 = var2; if (var1 <= storage[arg0 + 0x06]) { label_2178: var2 = 0x00; var3 = 0x2191; var var4 = arg0 + 0x02; var var5 = 0x00; var3 = func_22C4(var4, var5); var2 = var3; memory[0x00:0x20] = 0x00; memory[0x20:0x40] = arg0 + 0x01; var3 = storage[keccak256(memory[0x00:0x40])]; if (arg1 >= var3) { var4 = 0x00; if (var4 >= var1 - 0x01) { label_2241: return 0x00; } else { label_21E0: var5 = var3; memory[0x00:0x20] = var5; memory[0x20:0x40] = arg0 + 0x01; var3 = storage[keccak256(memory[0x00:0x40])]; if (arg1 >= var3) { var4 = var4 + 0x01; if (var4 >= var1 - 0x01) { goto label_2241; } else { goto label_21E0; } } else { var var6 = 0x2227; var var7 = arg0; var var8 = arg1; var var9 = var5; var var10 = var3; var var11 = 0x2221; var var12 = var7 + 0x02; var var13 = var9; var11 = func_22C4(var12, var13); var6 = func_2221(arg2, var7, var8, var9, var10, var11); var0 = var6; label_224A: return var0; } } } else { var4 = 0x21c4; var5 = arg0; var6 = arg1; var7 = 0x00; var8 = var3; var9 = var2; var10 = arg2; var4 = func_2526(var5, var6, var7, var8, var9, var10); var0 = var4; goto label_224A; } } else { var2 = 0x00; var3 = var2; var4 = 0x2138; var5 = arg0 + 0x02; var6 = arg1; var4, var5 = func_2295(var5, var6); var3 = var5; var2 = var4; if (!var2) { goto label_2178; } memory[0x00:0x20] = arg1; memory[0x20:0x40] = arg0 + 0x01; var4 = storage[keccak256(memory[0x00:0x40])]; var5 = 0x216a; var6 = arg0; var7 = arg1; var8 = var7; var9 = var4; var10 = var3; var11 = arg2; var5 = func_2526(var6, var7, var8, var9, var10, var11); var0 = var5; goto label_224A; } } function func_2221(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5) returns (var r0) { var var0 = arg0; r0 = func_2526(arg1, arg2, arg3, arg4, arg5, var0); // Error: Could not resolve method call return address! } function func_2251(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x2260; var var2 = arg0; var var3 = arg1; var1 = func_273A(var2, var3); return var1 >> 0x00; } function func_226B(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x2279; var var2 = arg0; return func_27BD(var2); } function func_2280(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x228e; var var2 = arg0; return func_27CE(var2); } function func_2295(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; var var2 = 0x00; var var3 = var2; var var4 = 0x22ab; var var5 = arg0; var var6 = arg1 << 0x00; var4, var5 = func_27DF(var5, var6); arg0 = var5 >> 0x00; r0 = var4; return r0, arg0; } function func_22C4(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x22d6; var var2 = arg0; var var3 = arg1 << 0x00; var1 = func_284B(var2, var3); return var1 >> 0x00; } function func_22E1(var arg0, var arg1, var arg2, var arg3) returns (var r0) { var var0 = 0x00; var var1 = 0x2302; var var2 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; var1 = func_290A(var2); if (var1) { var1 = 0x60; var2 = 0x24a5; var var3 = 0x150b7a02 << 0xe0; var var4 = 0x2324; var4 = func_1844(); var2 = func_2324(arg0, arg1, arg2, arg3, var3, var4); var temp0 = var2; var1 = temp0; var2 = 0x00; var3 = var1 + 0x20; var4 = memory[var1:var1 + 0x20]; if (var4 < 0x20) { revert(memory[0x00:0x00]); } var0 = memory[var3:var3 + 0x20] & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0x150b7a02 << 0xe0); label_251E: return var0; } else { var0 = 0x01; goto label_251E; } } function func_2324(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5) returns (var r0) { var var0 = arg0; var var1 = arg2; var temp0 = arg3; var var2 = temp0; var temp1 = memory[0x40:0x60] + 0x24; var var3 = temp1; memory[var3:var3 + 0x20] = arg5 & 0xffffffffffffffffffffffffffffffffffffffff; var temp2 = var3 + 0x20; memory[temp2:temp2 + 0x20] = var0 & 0xffffffffffffffffffffffffffffffffffffffff; var temp3 = temp2 + 0x20; memory[temp3:temp3 + 0x20] = var1; var temp4 = temp3 + 0x20; var var4 = temp4; var temp5 = var4 + 0x20; memory[var4:var4 + 0x20] = temp5 - var3; memory[temp5:temp5 + 0x20] = memory[var2:var2 + 0x20]; var var5 = temp5 + 0x20; var var7 = memory[var2:var2 + 0x20]; var var6 = var2 + 0x20; var var8 = var7; var var9 = var5; var var10 = var6; var var11 = 0x00; if (var11 >= var8) { label_23D4: var temp6 = var7; var5 = temp6 + var5; var6 = temp6 & 0x1f; if (!var6) { var temp7 = var5; var temp8 = memory[0x40:0x60]; memory[temp8:temp8 + 0x20] = temp7 - temp8 - 0x20; memory[0x40:0x60] = temp7; var temp9 = temp8 + 0x20; memory[temp9:temp9 + 0x20] = (memory[temp9:temp9 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff) | (arg4 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); var temp10 = memory[0x40:0x60]; memory[0x40:0x60] = temp10 + 0x60; memory[temp10:temp10 + 0x20] = 0x32; memory[temp10 + 0x20:temp10 + 0x20 + 0x32] = code[0x2f6f:0x2fa1]; arg4 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; arg5 = temp8; var0 = temp10; label_291D: var1 = 0x60; var2 = 0x292c; var3 = arg4; var4 = arg5; var5 = 0x00; var6 = var0; return func_299E(var3, var4, var5, var6); } else { var temp11 = var6; var temp12 = var5 - temp11; memory[temp12:temp12 + 0x20] = ~(0x0100 ** (0x20 - temp11) - 0x01) & memory[temp12:temp12 + 0x20]; var temp13 = temp12 + 0x20; var temp14 = memory[0x40:0x60]; memory[temp14:temp14 + 0x20] = temp13 - temp14 - 0x20; memory[0x40:0x60] = temp13; var temp15 = temp14 + 0x20; memory[temp15:temp15 + 0x20] = (memory[temp15:temp15 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff) | (arg4 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff); var temp16 = memory[0x40:0x60]; memory[0x40:0x60] = temp16 + 0x60; memory[temp16:temp16 + 0x20] = 0x32; memory[temp16 + 0x20:temp16 + 0x20 + 0x32] = code[0x2f6f:0x2fa1]; arg4 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; arg5 = temp14; var0 = temp16; goto label_291D; } } else { label_23C2: var temp17 = var11; memory[var9 + temp17:var9 + temp17 + 0x20] = memory[var10 + temp17:var10 + temp17 + 0x20]; var11 = temp17 + 0x20; if (var11 >= var8) { goto label_23D4; } else { goto label_23C2; } } } function func_2526(var arg0, var arg1, var arg2, var arg3, var arg4, var arg5) returns (var r0) { var var0 = 0x00; var var1 = arg1 + 0x01; if (var1 != arg3) { var temp0 = arg1; var temp1 = arg0; memory[0x00:0x20] = arg2; memory[0x20:0x40] = temp1 + 0x01; storage[keccak256(memory[0x00:0x40])] = temp0; var temp2 = var1; memory[0x00:0x20] = temp0; memory[0x20:0x40] = temp1 + 0x01; storage[keccak256(memory[0x00:0x40])] = temp2; memory[0x00:0x20] = temp2; memory[0x20:0x40] = temp1 + 0x01; storage[keccak256(memory[0x00:0x40])] = arg3; var var2 = 0x2668; var var3 = temp1 + 0x02; var var4 = temp0; var var5 = arg5; var2 = func_2969(var3, var4, var5); var2 = 0x2681; var3 = arg0 + 0x02; var4 = var1; var5 = arg4; var2 = func_2969(var3, var4, var5); var2 = 0x26d5; memory[0x00:0x20] = arg4 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = arg0; var3 = keccak256(memory[0x00:0x40]); var4 = var1; var2 = func_294F(var3, var4); var2 = 0x2729; memory[0x00:0x20] = arg5 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = arg0; var3 = keccak256(memory[0x00:0x40]); var4 = arg1; var2 = func_294F(var3, var4); return 0x01; } else { var2 = 0x258a; memory[0x00:0x20] = arg4 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = arg0; var3 = keccak256(memory[0x00:0x40]); var4 = arg1; var2 = func_2935(var3, var4); var2 = 0x25de; memory[0x00:0x20] = arg5 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = arg0; var3 = keccak256(memory[0x00:0x40]); var4 = arg1; var2 = func_294F(var3, var4); var2 = 0x25f7; var3 = arg0 + 0x02; var4 = arg1; var5 = arg5; var2 = func_2969(var3, var4, var5); return 0x01; } } function func_273A(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (storage[arg0] > arg1) { var var1 = arg0; var var2 = arg1; if (var2 >= storage[var1]) { assert(); } memory[0x00:0x20] = var1; return storage[keccak256(memory[0x00:0x20]) + var2]; } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp1 = temp0 + 0x04; var temp2 = temp1 + 0x20; memory[temp1:temp1 + 0x20] = temp2 - temp1; memory[temp2:temp2 + 0x20] = 0x22; var temp3 = temp2 + 0x20; memory[temp3:temp3 + 0x22] = code[0x2f4d:0x2f6f]; var temp4 = memory[0x40:0x60]; revert(memory[temp4:temp4 + (temp3 + 0x40) - temp4]); } } function func_27BD(var arg0) returns (var r0) { return storage[arg0]; } function func_27CE(var arg0) returns (var r0) { return storage[arg0]; } function func_27DF(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; memory[0x00:0x20] = arg1; memory[0x20:0x40] = arg0 + 0x01; var var2 = storage[keccak256(memory[0x00:0x40])]; if (var2 != 0x00) { var var3 = 0x01; var var4 = arg0; var var5 = var2 - 0x01; if (var5 >= storage[var4]) { assert(); } memory[0x00:0x20] = var4; var1 = storage[var5 * 0x02 + keccak256(memory[0x00:0x20]) + 0x01]; var0 = var3; label_2844: arg0 = var1; r0 = var0; return r0, arg0; } else { var1 = 0x00 << 0x00; var0 = 0x00; goto label_2844; } } function func_284B(var arg0, var arg1) returns (var r0) { var var0 = 0x00; memory[0x00:0x20] = arg1; memory[0x20:0x40] = arg0 + 0x01; var var1 = storage[keccak256(memory[0x00:0x40])]; if (var1 != 0x00) { var var2 = arg0; var var3 = var1 - 0x01; if (var3 >= storage[var2]) { assert(); } memory[0x00:0x20] = var2; return storage[var3 * 0x02 + keccak256(memory[0x00:0x20]) + 0x01]; } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp1 = temp0 + 0x04; var temp2 = temp1 + 0x20; memory[temp1:temp1 + 0x20] = temp2 - temp1; memory[temp2:temp2 + 0x20] = 0x1e; var temp3 = temp2 + 0x20; memory[temp3:temp3 + 0x20] = 0x456e756d657261626c654d61703a206e6f6e6578697374656e74206b65790000; var temp4 = memory[0x40:0x60]; revert(memory[temp4:temp4 + (temp3 + 0x20) - temp4]); } } function func_290A(var arg0) returns (var r0) { return address(arg0).code.length > 0x00; } function func_2935(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x2947; var var2 = arg0; var var3 = arg1 << 0x00; return func_2B47(var2, var3); } function func_294F(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x2961; var var2 = arg0; var var3 = arg1 << 0x00; return func_2C2F(var2, var3); } function func_2969(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x00; var var1 = 0x2995; var var2 = arg0; var var3 = arg1 << 0x00; var var4 = (arg2 & 0xffffffffffffffffffffffffffffffffffffffff) << 0x00; return func_2C9F(var2, var3, var4); } function func_299E(var arg0, var arg1, var arg2, var arg3) returns (var r0) { var var0 = 0x60; if (address(this).balance >= arg2) { var var1 = 0x2a02; var var2 = arg0; var1 = func_290A(var2); if (var1) { var1 = 0x00; var2 = 0x60; var var3 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var var4 = arg2; var temp0 = arg1; var var5 = temp0; var var6 = memory[0x40:0x60]; var var7 = var6; var var8 = var5 + 0x20; var var9 = memory[var5:var5 + 0x20]; var var10 = var9; var var11 = var7; var var12 = var8; if (var10 < 0x20) { label_2AC4: var temp1 = 0x0100 ** (0x20 - var10) - 0x01; var temp2 = var11; memory[temp2:temp2 + 0x20] = (memory[var12:var12 + 0x20] & ~temp1) | (memory[temp2:temp2 + 0x20] & temp1); var temp3 = memory[0x40:0x60]; var temp4; temp4, memory[temp3:temp3 + 0x00] = address(var3).call.gas(msg.gas).value(var4)(memory[temp3:temp3 + (var9 + var7) - temp3]); var4 = returndata.length; var5 = var4; if (var5 == 0x00) { var2 = 0x60; var temp5 = var3; var1 = temp5; var3 = 0x2b3b; var4 = var1; var5 = var2; var6 = arg3; var3 = func_2D7B(var4, var5, var6); label_2B3B: return var3; } else { var temp6 = memory[0x40:0x60]; var4 = temp6; memory[0x40:0x60] = var4 + (returndata.length + 0x3f & ~0x1f); memory[var4:var4 + 0x20] = returndata.length; var temp7 = returndata.length; memory[var4 + 0x20:var4 + 0x20 + temp7] = returndata[0x00:0x00 + temp7]; var temp8 = var4; var2 = temp8; var temp9 = var3; var1 = temp9; var3 = 0x2b3b; var4 = var1; var5 = var2; var6 = arg3; var3 = func_2D7B(var4, var5, var6); goto label_2B3B; } } else { label_2AAA: var temp10 = var12; var temp11 = var11; memory[temp11:temp11 + 0x20] = memory[temp10:temp10 + 0x20]; var11 = temp11 + 0x20; var12 = temp10 + 0x20; var10 = var10 - 0x20; if (var10 < 0x20) { goto label_2AC4; } else { goto label_2AAA; } } } else { var temp12 = memory[0x40:0x60]; memory[temp12:temp12 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp13 = temp12 + 0x04; var temp14 = temp13 + 0x20; memory[temp13:temp13 + 0x20] = temp14 - temp13; memory[temp14:temp14 + 0x20] = 0x1d; var temp15 = temp14 + 0x20; memory[temp15:temp15 + 0x20] = 0x416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000; var temp16 = memory[0x40:0x60]; revert(memory[temp16:temp16 + (temp15 + 0x20) - temp16]); } } else { var temp17 = memory[0x40:0x60]; memory[temp17:temp17 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp18 = temp17 + 0x04; var temp19 = temp18 + 0x20; memory[temp18:temp18 + 0x20] = temp19 - temp18; memory[temp19:temp19 + 0x20] = 0x26; var temp20 = temp19 + 0x20; memory[temp20:temp20 + 0x26] = code[0x2feb:0x3011]; var temp21 = memory[0x40:0x60]; revert(memory[temp21:temp21 + (temp20 + 0x40) - temp21]); } } function func_2B47(var arg0, var arg1) returns (var r0) { var var0 = 0x00; memory[0x00:0x20] = arg1; memory[0x20:0x40] = arg0 + 0x01; var var1 = storage[keccak256(memory[0x00:0x40])]; if (var1 == 0x00) { return 0x00; } var var2 = var1 - 0x01; var temp0 = arg0; var var3 = storage[temp0] - 0x01; var var4 = 0x00; var var5 = temp0; var var6 = var3; if (var6 >= storage[var5]) { assert(); } memory[0x00:0x20] = var5; var4 = storage[keccak256(memory[0x00:0x20]) + var6]; var5 = var4; var6 = arg0; var var7 = var2; if (var7 >= storage[var6]) { assert(); } memory[0x00:0x20] = var6; storage[keccak256(memory[0x00:0x20]) + var7] = var5; var temp1 = arg0; memory[0x00:0x20] = var4; memory[0x20:0x40] = temp1 + 0x01; storage[keccak256(memory[0x00:0x40])] = var2 + 0x01; var5 = temp1; var6 = storage[var5]; if (!var6) { assert(); } var temp2 = var6 - 0x01; var temp3 = var5; memory[0x00:0x20] = temp3; storage[keccak256(memory[0x00:0x20]) + temp2] = 0x00; storage[temp3] = temp2; memory[0x00:0x20] = arg1; memory[0x20:0x40] = arg0 + 0x01; storage[keccak256(memory[0x00:0x40])] = 0x00; return 0x01; } function func_2C2F(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x2c3b; var var2 = arg0; var var3 = arg1; var1 = func_2E47(var2, var3); if (var1) { return 0x00; } var temp0 = arg0; var temp1 = temp0; var temp2 = arg1; var temp3 = storage[temp1] + 0x01; storage[temp1] = temp3; memory[0x00:0x20] = temp1; storage[keccak256(memory[0x00:0x20]) + (temp3 - 0x01)] = temp2; memory[0x00:0x20] = temp2; memory[0x20:0x40] = temp0 + 0x01; storage[keccak256(memory[0x00:0x40])] = storage[temp0]; return 0x01; } function func_2C9F(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x00; memory[0x00:0x20] = arg1; memory[0x20:0x40] = arg0 + 0x01; var var1 = storage[keccak256(memory[0x00:0x40])]; if (var1 != 0x00) { var var2 = arg2; var var3 = arg0; var var4 = var1 - 0x01; if (var4 >= storage[var3]) { assert(); } memory[0x00:0x20] = var3; storage[var4 * 0x02 + keccak256(memory[0x00:0x20]) + 0x01] = var2; return 0x00; } else { var temp0 = arg0; var temp1 = temp0; var temp2 = memory[0x40:0x60]; memory[0x40:0x60] = temp2 + 0x40; var temp3 = arg1; memory[temp2:temp2 + 0x20] = temp3; memory[temp2 + 0x20:temp2 + 0x20 + 0x20] = arg2; var temp4 = storage[temp1] + 0x01; storage[temp1] = temp4; memory[0x00:0x20] = temp1; var temp5 = temp4 - 0x01 * 0x02 + keccak256(memory[0x00:0x20]); storage[temp5] = memory[temp2:temp2 + 0x20]; storage[temp5 + 0x01] = memory[temp2 + 0x20:temp2 + 0x20 + 0x20]; memory[0x00:0x20] = temp3; memory[0x20:0x40] = temp0 + 0x01; storage[keccak256(memory[0x00:0x40])] = storage[temp0]; return 0x01; } } function func_2D7B(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x60; if (arg0) { return arg1; } if (memory[arg1:arg1 + 0x20] <= 0x00) { var temp0 = arg2; var var1 = temp0; var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var temp2 = temp1 + 0x04; var var2 = temp2; var var3 = var2; var temp3 = var3 + 0x20; memory[var3:var3 + 0x20] = temp3 - var3; memory[temp3:temp3 + 0x20] = memory[var1:var1 + 0x20]; var var4 = temp3 + 0x20; var var6 = memory[var1:var1 + 0x20]; var var5 = var1 + 0x20; var var7 = var6; var var8 = var4; var var9 = var5; var var10 = 0x00; if (var10 >= var7) { label_2E05: var temp4 = var6; var4 = temp4 + var4; var5 = temp4 & 0x1f; if (!var5) { var temp5 = memory[0x40:0x60]; revert(memory[temp5:temp5 + var4 - temp5]); } else { var temp6 = var5; var temp7 = var4 - temp6; memory[temp7:temp7 + 0x20] = ~(0x0100 ** (0x20 - temp6) - 0x01) & memory[temp7:temp7 + 0x20]; var temp8 = memory[0x40:0x60]; revert(memory[temp8:temp8 + (temp7 + 0x20) - temp8]); } } else { label_2DF3: var temp9 = var10; memory[var8 + temp9:var8 + temp9 + 0x20] = memory[var9 + temp9:var9 + temp9 + 0x20]; var10 = temp9 + 0x20; if (var10 >= var7) { goto label_2E05; } else { goto label_2DF3; } } } else { var temp10 = arg1; var1 = memory[temp10:temp10 + 0x20]; revert(memory[temp10 + 0x20:temp10 + 0x20 + var1]); } } function func_2E47(var arg0, var arg1) returns (var r0) { memory[0x00:0x20] = arg1; memory[0x20:0x40] = arg0 + 0x01; return storage[keccak256(memory[0x00:0x40])] != 0x00; } }

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 0x6c0360eb 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 0x6c0360eb > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x6c0360eb > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xa22cb465 0031 11 GT 0032 61 PUSH2 0x0071 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0071, if 0xa22cb465 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xa22cb465 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xa22cb465 003C 14 EQ 003D 61 PUSH2 0x0693 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0693, if 0xa22cb465 == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xb88d4fde 0047 14 EQ 0048 61 PUSH2 0x06e3 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06e3, if 0xb88d4fde == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xb88d4fde == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xc87b56dd 0052 14 EQ 0053 61 PUSH2 0x07e8 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07e8, if 0xc87b56dd == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xc87b56dd == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xe985e9c5 005D 14 EQ 005E 61 PUSH2 0x088f 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x088f, 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 0x090b 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x090b, 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 0xa22cb465 > stack[-1] // Inputs[1] { @0072 stack[-1] } 0071 5B JUMPDEST 0072 80 DUP1 0073 63 PUSH4 0x6c0360eb 0078 14 EQ 0079 61 PUSH2 0x04e1 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e1, if 0x6c0360eb == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0x6c0360eb == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0x70a08231 0083 14 EQ 0084 61 PUSH2 0x0564 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0564, if 0x70a08231 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0x70a08231 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0x715018a6 008E 14 EQ 008F 61 PUSH2 0x05bc 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05bc, if 0x715018a6 == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0x715018a6 == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0x8da5cb5b 0099 14 EQ 009A 61 PUSH2 0x05c6 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c6, if 0x8da5cb5b == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @009E stack[-1] } 009E 80 DUP1 009F 63 PUSH4 0x95d89b41 00A4 14 EQ 00A5 61 PUSH2 0x0610 00A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0610, if 0x95d89b41 == stack[-1] label_00A9: // Incoming jump from 0x00A8, if not 0x95d89b41 == 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 0x6c0360eb > 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 0x02f3 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f3, 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 0x2f745c59 00CA 14 EQ 00CB 61 PUSH2 0x0361 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0361, if 0x2f745c59 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x2f745c59 == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0x42842e0e 00D5 14 EQ 00D6 61 PUSH2 0x03c3 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c3, 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 0x4f6ccce7 00E0 14 EQ 00E1 61 PUSH2 0x0431 00E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0431, if 0x4f6ccce7 == stack[-1] label_00E5: // Incoming jump from 0x00E4, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @00E5 stack[-1] } 00E5 80 DUP1 00E6 63 PUSH4 0x6352211e 00EB 14 EQ 00EC 61 PUSH2 0x0473 00EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0473, if 0x6352211e == stack[-1] label_00F0: // Incoming jump from 0x00EF, if not 0x6352211e == 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 0x0196 010A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0196, 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 0x0219 0115 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0219, 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 0x0287 0120 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0287, 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 0x18160ddd 0127 14 EQ 0128 61 PUSH2 0x02d5 012B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d5, if 0x18160ddd == stack[-1] label_012C: // Incoming jump from 0x00AC // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x012B, if not 0x18160ddd == stack[-1] // Incoming jump from 0x00F3 // Incoming jump from 0x0070 // 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 0x017c 0135 60 PUSH1 0x04 0137 80 DUP1 0138 36 CALLDATASIZE 0139 03 SUB 013A 60 PUSH1 0x20 013C 81 DUP2 013D 10 LT 013E 15 ISZERO 013F 61 PUSH2 0x0147 0142 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0132 stack[0] = 0x017c // @0135 stack[1] = 0x04 // @0139 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0147, returns to 0x017C, if !(msg.data.length - 0x04 < 0x20) label_0143: // Incoming jump from 0x0142, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0146 memory[0x00:0x00] } 0143 60 PUSH1 0x00 0145 80 DUP1 0146 FD *REVERT // Stack delta = +0 // Outputs[1] { @0146 revert(memory[0x00:0x00]); } // Block terminates label_0147: // Incoming call from 0x0142, returns to 0x017C, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0148 stack[-2] // @0149 stack[-1] // @014D msg.data[stack[-2]:stack[-2] + 0x20] // } 0147 5B JUMPDEST 0148 81 DUP2 0149 01 ADD 014A 90 SWAP1 014B 80 DUP1 014C 80 DUP1 014D 35 CALLDATALOAD 014E 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 016B 19 NOT 016C 16 AND 016D 90 SWAP1 016E 60 PUSH1 0x20 0170 01 ADD 0171 90 SWAP1 0172 92 SWAP3 0173 91 SWAP2 0174 90 SWAP1 0175 50 POP 0176 50 POP 0177 50 POP 0178 61 PUSH2 0x094f 017B 56 *JUMP // Stack delta = -1 // Outputs[1] { @0172 stack[-2] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x094f label_017C: // Incoming return from call to 0x0147 at 0x0142 // Inputs[4] // { // @017F memory[0x40:0x60] // @0181 stack[-1] // @0190 memory[0x40:0x60] // @0195 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 017C 5B JUMPDEST 017D 60 PUSH1 0x40 017F 51 MLOAD 0180 80 DUP1 0181 82 DUP3 0182 15 ISZERO 0183 15 ISZERO 0184 15 ISZERO 0185 15 ISZERO 0186 81 DUP2 0187 52 MSTORE 0188 60 PUSH1 0x20 018A 01 ADD 018B 91 SWAP2 018C 50 POP 018D 50 POP 018E 60 PUSH1 0x40 0190 51 MLOAD 0191 80 DUP1 0192 91 SWAP2 0193 03 SUB 0194 90 SWAP1 0195 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0187 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0195 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0196: // Incoming jump from 0x010A, if 0x06fdde03 == stack[-1] 0196 5B JUMPDEST 0197 61 PUSH2 0x019e 019A 61 PUSH2 0x09b6 019D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0197 stack[0] = 0x019e } // Block ends with call to 0x09b6, returns to 0x019E label_019E: // Incoming return from call to 0x09B6 at 0x019D // Inputs[4] // { // @01A1 memory[0x40:0x60] // @01AC stack[-1] // @01AF memory[stack[-1]:stack[-1] + 0x20] // @01B8 memory[stack[-1]:stack[-1] + 0x20] // } 019E 5B JUMPDEST 019F 60 PUSH1 0x40 01A1 51 MLOAD 01A2 80 DUP1 01A3 80 DUP1 01A4 60 PUSH1 0x20 01A6 01 ADD 01A7 82 DUP3 01A8 81 DUP2 01A9 03 SUB 01AA 82 DUP3 01AB 52 MSTORE 01AC 83 DUP4 01AD 81 DUP2 01AE 81 DUP2 01AF 51 MLOAD 01B0 81 DUP2 01B1 52 MSTORE 01B2 60 PUSH1 0x20 01B4 01 ADD 01B5 91 SWAP2 01B6 50 POP 01B7 80 DUP1 01B8 51 MLOAD 01B9 90 SWAP1 01BA 60 PUSH1 0x20 01BC 01 ADD 01BD 90 SWAP1 01BE 80 DUP1 01BF 83 DUP4 01C0 83 DUP4 01C1 60 PUSH1 0x00 01C3 5B JUMPDEST 01C4 83 DUP4 01C5 81 DUP2 01C6 10 LT 01C7 15 ISZERO 01C8 61 PUSH2 0x01de 01CB 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @01A1 stack[0] = memory[0x40:0x60] // @01A2 stack[1] = memory[0x40:0x60] // @01AB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @01B1 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @01B5 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @01BD stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @01BD stack[3] = 0x20 + stack[-1] // @01BE stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @01BF stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @01C0 stack[7] = 0x20 + stack[-1] // @01C1 stack[8] = 0x00 // } // Block ends with conditional jump to 0x01de, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_01CC: // Incoming jump from 0x01CB, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x01CB, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @01CC stack[-1] // @01CD stack[-2] // @01CF memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @01D1 stack[-3] // } 01CC 80 DUP1 01CD 82 DUP3 01CE 01 ADD 01CF 51 MLOAD 01D0 81 DUP2 01D1 84 DUP5 01D2 01 ADD 01D3 52 MSTORE 01D4 60 PUSH1 0x20 01D6 81 DUP2 01D7 01 ADD 01D8 90 SWAP1 01D9 50 POP 01DA 61 PUSH2 0x01c3 01DD 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01D3 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @01D8 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x01c3 label_01DE: // Incoming jump from 0x01CB, if !(stack[-1] < stack[-4]) // Incoming jump from 0x01CB, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @01E3 stack[-6] // @01E3 stack[-5] // @01E5 stack[-7] // } 01DE 5B JUMPDEST 01DF 50 POP 01E0 50 POP 01E1 50 POP 01E2 50 POP 01E3 90 SWAP1 01E4 50 POP 01E5 90 SWAP1 01E6 81 DUP2 01E7 01 ADD 01E8 90 SWAP1 01E9 60 PUSH1 0x1f 01EB 16 AND 01EC 80 DUP1 01ED 15 ISZERO 01EE 61 PUSH2 0x020b 01F1 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @01E8 stack[-7] = stack[-5] + stack[-7] // @01EB stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x020b, if !(0x1f & stack[-5]) label_01F2: // Incoming jump from 0x01F1, if not !(0x1f & stack[-5]) // Inputs[6] // { // @01F2 stack[-1] // @01F3 stack[-2] // @01F6 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @020D stack[-5] // @0213 memory[0x40:0x60] // @0218 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 01F2 80 DUP1 01F3 82 DUP3 01F4 03 SUB 01F5 80 DUP1 01F6 51 MLOAD 01F7 60 PUSH1 0x01 01F9 83 DUP4 01FA 60 PUSH1 0x20 01FC 03 SUB 01FD 61 PUSH2 0x0100 0200 0A EXP 0201 03 SUB 0202 19 NOT 0203 16 AND 0204 81 DUP2 0205 52 MSTORE 0206 60 PUSH1 0x20 0208 01 ADD 0209 91 SWAP2 020A 50 POP 020B 5B JUMPDEST 020C 50 POP 020D 92 SWAP3 020E 50 POP 020F 50 POP 0210 50 POP 0211 60 PUSH1 0x40 0213 51 MLOAD 0214 80 DUP1 0215 91 SWAP2 0216 03 SUB 0217 90 SWAP1 0218 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0205 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0218 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0219: // Incoming jump from 0x0115, if 0x081812fc == stack[-1] // Inputs[1] { @0220 msg.data.length } 0219 5B JUMPDEST 021A 61 PUSH2 0x0245 021D 60 PUSH1 0x04 021F 80 DUP1 0220 36 CALLDATASIZE 0221 03 SUB 0222 60 PUSH1 0x20 0224 81 DUP2 0225 10 LT 0226 15 ISZERO 0227 61 PUSH2 0x022f 022A 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @021A stack[0] = 0x0245 // @021D stack[1] = 0x04 // @0221 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x022f, returns to 0x0245, if !(msg.data.length - 0x04 < 0x20) label_022B: // Incoming jump from 0x022A, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @022E memory[0x00:0x00] } 022B 60 PUSH1 0x00 022D 80 DUP1 022E FD *REVERT // Stack delta = +0 // Outputs[1] { @022E revert(memory[0x00:0x00]); } // Block terminates label_022F: // Incoming call from 0x022A, returns to 0x0245, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0230 stack[-2] // @0231 stack[-1] // @0235 msg.data[stack[-2]:stack[-2] + 0x20] // } 022F 5B JUMPDEST 0230 81 DUP2 0231 01 ADD 0232 90 SWAP1 0233 80 DUP1 0234 80 DUP1 0235 35 CALLDATALOAD 0236 90 SWAP1 0237 60 PUSH1 0x20 0239 01 ADD 023A 90 SWAP1 023B 92 SWAP3 023C 91 SWAP2 023D 90 SWAP1 023E 50 POP 023F 50 POP 0240 50 POP 0241 61 PUSH2 0x0a58 0244 56 *JUMP // Stack delta = -1 // Outputs[1] { @023B stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0a58 label_0245: // Incoming return from call to 0x022F at 0x022A // Inputs[4] // { // @0248 memory[0x40:0x60] // @024A stack[-1] // @0281 memory[0x40:0x60] // @0286 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0245 5B JUMPDEST 0246 60 PUSH1 0x40 0248 51 MLOAD 0249 80 DUP1 024A 82 DUP3 024B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0260 16 AND 0261 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0276 16 AND 0277 81 DUP2 0278 52 MSTORE 0279 60 PUSH1 0x20 027B 01 ADD 027C 91 SWAP2 027D 50 POP 027E 50 POP 027F 60 PUSH1 0x40 0281 51 MLOAD 0282 80 DUP1 0283 91 SWAP2 0284 03 SUB 0285 90 SWAP1 0286 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0278 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0286 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0287: // Incoming jump from 0x0120, if 0x095ea7b3 == stack[-1] // Inputs[1] { @028E msg.data.length } 0287 5B JUMPDEST 0288 61 PUSH2 0x02d3 028B 60 PUSH1 0x04 028D 80 DUP1 028E 36 CALLDATASIZE 028F 03 SUB 0290 60 PUSH1 0x40 0292 81 DUP2 0293 10 LT 0294 15 ISZERO 0295 61 PUSH2 0x029d 0298 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0288 stack[0] = 0x02d3 // @028B stack[1] = 0x04 // @028F stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x029d, returns to 0x02D3, if !(msg.data.length - 0x04 < 0x40) label_0299: // Incoming jump from 0x0298, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @029C memory[0x00:0x00] } 0299 60 PUSH1 0x00 029B 80 DUP1 029C FD *REVERT // Stack delta = +0 // Outputs[1] { @029C revert(memory[0x00:0x00]); } // Block terminates label_029D: // Incoming call from 0x0298, returns to 0x02D3, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @029E stack[-2] // @029F stack[-1] // @02A3 msg.data[stack[-2]:stack[-2] + 0x20] // @02C3 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 029D 5B JUMPDEST 029E 81 DUP2 029F 01 ADD 02A0 90 SWAP1 02A1 80 DUP1 02A2 80 DUP1 02A3 35 CALLDATALOAD 02A4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02B9 16 AND 02BA 90 SWAP1 02BB 60 PUSH1 0x20 02BD 01 ADD 02BE 90 SWAP1 02BF 92 SWAP3 02C0 91 SWAP2 02C1 90 SWAP1 02C2 80 DUP1 02C3 35 CALLDATALOAD 02C4 90 SWAP1 02C5 60 PUSH1 0x20 02C7 01 ADD 02C8 90 SWAP1 02C9 92 SWAP3 02CA 91 SWAP2 02CB 90 SWAP1 02CC 50 POP 02CD 50 POP 02CE 50 POP 02CF 61 PUSH2 0x0af3 02D2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02BF stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @02C9 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0af3 label_02D3: // Incoming return from call to 0x029D at 0x0298 02D3 5B JUMPDEST 02D4 00 *STOP // Stack delta = +0 // Outputs[1] { @02D4 stop(); } // Block terminates label_02D5: // Incoming jump from 0x012B, if 0x18160ddd == stack[-1] 02D5 5B JUMPDEST 02D6 61 PUSH2 0x02dd 02D9 61 PUSH2 0x0c37 02DC 56 *JUMP // Stack delta = +1 // Outputs[1] { @02D6 stack[0] = 0x02dd } // Block ends with call to 0x0c37, returns to 0x02DD label_02DD: // Incoming return from call to 0x0C37 at 0x02DC // Inputs[4] // { // @02E0 memory[0x40:0x60] // @02E2 stack[-1] // @02ED memory[0x40:0x60] // @02F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02DD 5B JUMPDEST 02DE 60 PUSH1 0x40 02E0 51 MLOAD 02E1 80 DUP1 02E2 82 DUP3 02E3 81 DUP2 02E4 52 MSTORE 02E5 60 PUSH1 0x20 02E7 01 ADD 02E8 91 SWAP2 02E9 50 POP 02EA 50 POP 02EB 60 PUSH1 0x40 02ED 51 MLOAD 02EE 80 DUP1 02EF 91 SWAP2 02F0 03 SUB 02F1 90 SWAP1 02F2 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02F2 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02F3: // Incoming jump from 0x00C3, if 0x23b872dd == stack[-1] // Inputs[1] { @02FA msg.data.length } 02F3 5B JUMPDEST 02F4 61 PUSH2 0x035f 02F7 60 PUSH1 0x04 02F9 80 DUP1 02FA 36 CALLDATASIZE 02FB 03 SUB 02FC 60 PUSH1 0x60 02FE 81 DUP2 02FF 10 LT 0300 15 ISZERO 0301 61 PUSH2 0x0309 0304 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @02F4 stack[0] = 0x035f // @02F7 stack[1] = 0x04 // @02FB stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0309, returns to 0x035F, if !(msg.data.length - 0x04 < 0x60) label_0305: // Incoming jump from 0x0304, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0308 memory[0x00:0x00] } 0305 60 PUSH1 0x00 0307 80 DUP1 0308 FD *REVERT // Stack delta = +0 // Outputs[1] { @0308 revert(memory[0x00:0x00]); } // Block terminates label_0309: // Incoming call from 0x0304, returns to 0x035F, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @030A stack[-2] // @030B stack[-1] // @030F msg.data[stack[-2]:stack[-2] + 0x20] // @032F msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @034F msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 0309 5B JUMPDEST 030A 81 DUP2 030B 01 ADD 030C 90 SWAP1 030D 80 DUP1 030E 80 DUP1 030F 35 CALLDATALOAD 0310 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0325 16 AND 0326 90 SWAP1 0327 60 PUSH1 0x20 0329 01 ADD 032A 90 SWAP1 032B 92 SWAP3 032C 91 SWAP2 032D 90 SWAP1 032E 80 DUP1 032F 35 CALLDATALOAD 0330 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0345 16 AND 0346 90 SWAP1 0347 60 PUSH1 0x20 0349 01 ADD 034A 90 SWAP1 034B 92 SWAP3 034C 91 SWAP2 034D 90 SWAP1 034E 80 DUP1 034F 35 CALLDATALOAD 0350 90 SWAP1 0351 60 PUSH1 0x20 0353 01 ADD 0354 90 SWAP1 0355 92 SWAP3 0356 91 SWAP2 0357 90 SWAP1 0358 50 POP 0359 50 POP 035A 50 POP 035B 61 PUSH2 0x0c48 035E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @032B stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @034B stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0355 stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0c48 label_035F: // Incoming return from call to 0x0309 at 0x0304 035F 5B JUMPDEST 0360 00 *STOP // Stack delta = +0 // Outputs[1] { @0360 stop(); } // Block terminates label_0361: // Incoming jump from 0x00CE, if 0x2f745c59 == stack[-1] // Inputs[1] { @0368 msg.data.length } 0361 5B JUMPDEST 0362 61 PUSH2 0x03ad 0365 60 PUSH1 0x04 0367 80 DUP1 0368 36 CALLDATASIZE 0369 03 SUB 036A 60 PUSH1 0x40 036C 81 DUP2 036D 10 LT 036E 15 ISZERO 036F 61 PUSH2 0x0377 0372 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0362 stack[0] = 0x03ad // @0365 stack[1] = 0x04 // @0369 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0377, returns to 0x03AD, if !(msg.data.length - 0x04 < 0x40) label_0373: // Incoming jump from 0x0372, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0376 memory[0x00:0x00] } 0373 60 PUSH1 0x00 0375 80 DUP1 0376 FD *REVERT // Stack delta = +0 // Outputs[1] { @0376 revert(memory[0x00:0x00]); } // Block terminates label_0377: // Incoming call from 0x0372, returns to 0x03AD, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0378 stack[-2] // @0379 stack[-1] // @037D msg.data[stack[-2]:stack[-2] + 0x20] // @039D msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0377 5B JUMPDEST 0378 81 DUP2 0379 01 ADD 037A 90 SWAP1 037B 80 DUP1 037C 80 DUP1 037D 35 CALLDATALOAD 037E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0393 16 AND 0394 90 SWAP1 0395 60 PUSH1 0x20 0397 01 ADD 0398 90 SWAP1 0399 92 SWAP3 039A 91 SWAP2 039B 90 SWAP1 039C 80 DUP1 039D 35 CALLDATALOAD 039E 90 SWAP1 039F 60 PUSH1 0x20 03A1 01 ADD 03A2 90 SWAP1 03A3 92 SWAP3 03A4 91 SWAP2 03A5 90 SWAP1 03A6 50 POP 03A7 50 POP 03A8 50 POP 03A9 61 PUSH2 0x0cbe 03AC 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0399 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @03A3 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0cbe label_03AD: // Incoming return from call to 0x0377 at 0x0372 // Inputs[4] // { // @03B0 memory[0x40:0x60] // @03B2 stack[-1] // @03BD memory[0x40:0x60] // @03C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 03AD 5B JUMPDEST 03AE 60 PUSH1 0x40 03B0 51 MLOAD 03B1 80 DUP1 03B2 82 DUP3 03B3 81 DUP2 03B4 52 MSTORE 03B5 60 PUSH1 0x20 03B7 01 ADD 03B8 91 SWAP2 03B9 50 POP 03BA 50 POP 03BB 60 PUSH1 0x40 03BD 51 MLOAD 03BE 80 DUP1 03BF 91 SWAP2 03C0 03 SUB 03C1 90 SWAP1 03C2 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @03B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @03C2 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_03C3: // Incoming jump from 0x00D9, if 0x42842e0e == stack[-1] // Inputs[1] { @03CA msg.data.length } 03C3 5B JUMPDEST 03C4 61 PUSH2 0x042f 03C7 60 PUSH1 0x04 03C9 80 DUP1 03CA 36 CALLDATASIZE 03CB 03 SUB 03CC 60 PUSH1 0x60 03CE 81 DUP2 03CF 10 LT 03D0 15 ISZERO 03D1 61 PUSH2 0x03d9 03D4 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @03C4 stack[0] = 0x042f // @03C7 stack[1] = 0x04 // @03CB stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03d9, returns to 0x042F, if !(msg.data.length - 0x04 < 0x60) label_03D5: // Incoming jump from 0x03D4, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @03D8 memory[0x00:0x00] } 03D5 60 PUSH1 0x00 03D7 80 DUP1 03D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D8 revert(memory[0x00:0x00]); } // Block terminates label_03D9: // Incoming call from 0x03D4, returns to 0x042F, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @03DA stack[-2] // @03DB stack[-1] // @03DF msg.data[stack[-2]:stack[-2] + 0x20] // @03FF msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @041F msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 03D9 5B JUMPDEST 03DA 81 DUP2 03DB 01 ADD 03DC 90 SWAP1 03DD 80 DUP1 03DE 80 DUP1 03DF 35 CALLDATALOAD 03E0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03F5 16 AND 03F6 90 SWAP1 03F7 60 PUSH1 0x20 03F9 01 ADD 03FA 90 SWAP1 03FB 92 SWAP3 03FC 91 SWAP2 03FD 90 SWAP1 03FE 80 DUP1 03FF 35 CALLDATALOAD 0400 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0415 16 AND 0416 90 SWAP1 0417 60 PUSH1 0x20 0419 01 ADD 041A 90 SWAP1 041B 92 SWAP3 041C 91 SWAP2 041D 90 SWAP1 041E 80 DUP1 041F 35 CALLDATALOAD 0420 90 SWAP1 0421 60 PUSH1 0x20 0423 01 ADD 0424 90 SWAP1 0425 92 SWAP3 0426 91 SWAP2 0427 90 SWAP1 0428 50 POP 0429 50 POP 042A 50 POP 042B 61 PUSH2 0x0cde 042E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @03FB stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @041B stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0425 stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0cde label_042F: // Incoming return from call to 0x03D9 at 0x03D4 042F 5B JUMPDEST 0430 00 *STOP // Stack delta = +0 // Outputs[1] { @0430 stop(); } // Block terminates label_0431: // Incoming jump from 0x00E4, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @0438 msg.data.length } 0431 5B JUMPDEST 0432 61 PUSH2 0x045d 0435 60 PUSH1 0x04 0437 80 DUP1 0438 36 CALLDATASIZE 0439 03 SUB 043A 60 PUSH1 0x20 043C 81 DUP2 043D 10 LT 043E 15 ISZERO 043F 61 PUSH2 0x0447 0442 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0432 stack[0] = 0x045d // @0435 stack[1] = 0x04 // @0439 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0447, returns to 0x045D, if !(msg.data.length - 0x04 < 0x20) label_0443: // Incoming jump from 0x0442, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0446 memory[0x00:0x00] } 0443 60 PUSH1 0x00 0445 80 DUP1 0446 FD *REVERT // Stack delta = +0 // Outputs[1] { @0446 revert(memory[0x00:0x00]); } // Block terminates label_0447: // Incoming call from 0x0442, returns to 0x045D, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0448 stack[-2] // @0449 stack[-1] // @044D msg.data[stack[-2]:stack[-2] + 0x20] // } 0447 5B JUMPDEST 0448 81 DUP2 0449 01 ADD 044A 90 SWAP1 044B 80 DUP1 044C 80 DUP1 044D 35 CALLDATALOAD 044E 90 SWAP1 044F 60 PUSH1 0x20 0451 01 ADD 0452 90 SWAP1 0453 92 SWAP3 0454 91 SWAP2 0455 90 SWAP1 0456 50 POP 0457 50 POP 0458 50 POP 0459 61 PUSH2 0x0cfe 045C 56 *JUMP // Stack delta = -1 // Outputs[1] { @0453 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0cfe label_045D: // Incoming return from call to 0x0447 at 0x0442 // Inputs[4] // { // @0460 memory[0x40:0x60] // @0462 stack[-1] // @046D memory[0x40:0x60] // @0472 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 045D 5B JUMPDEST 045E 60 PUSH1 0x40 0460 51 MLOAD 0461 80 DUP1 0462 82 DUP3 0463 81 DUP2 0464 52 MSTORE 0465 60 PUSH1 0x20 0467 01 ADD 0468 91 SWAP2 0469 50 POP 046A 50 POP 046B 60 PUSH1 0x40 046D 51 MLOAD 046E 80 DUP1 046F 91 SWAP2 0470 03 SUB 0471 90 SWAP1 0472 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0464 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0472 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0473: // Incoming jump from 0x00EF, if 0x6352211e == stack[-1] // Inputs[1] { @047A msg.data.length } 0473 5B JUMPDEST 0474 61 PUSH2 0x049f 0477 60 PUSH1 0x04 0479 80 DUP1 047A 36 CALLDATASIZE 047B 03 SUB 047C 60 PUSH1 0x20 047E 81 DUP2 047F 10 LT 0480 15 ISZERO 0481 61 PUSH2 0x0489 0484 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0474 stack[0] = 0x049f // @0477 stack[1] = 0x04 // @047B stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0489, returns to 0x049F, if !(msg.data.length - 0x04 < 0x20) label_0485: // Incoming jump from 0x0484, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0488 memory[0x00:0x00] } 0485 60 PUSH1 0x00 0487 80 DUP1 0488 FD *REVERT // Stack delta = +0 // Outputs[1] { @0488 revert(memory[0x00:0x00]); } // Block terminates label_0489: // Incoming call from 0x0484, returns to 0x049F, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @048A stack[-2] // @048B stack[-1] // @048F msg.data[stack[-2]:stack[-2] + 0x20] // } 0489 5B JUMPDEST 048A 81 DUP2 048B 01 ADD 048C 90 SWAP1 048D 80 DUP1 048E 80 DUP1 048F 35 CALLDATALOAD 0490 90 SWAP1 0491 60 PUSH1 0x20 0493 01 ADD 0494 90 SWAP1 0495 92 SWAP3 0496 91 SWAP2 0497 90 SWAP1 0498 50 POP 0499 50 POP 049A 50 POP 049B 61 PUSH2 0x0d08 049E 56 *JUMP // Stack delta = -1 // Outputs[1] { @0495 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0d08 label_049F: // Incoming return from call to 0x0489 at 0x0484 // Inputs[4] // { // @04A2 memory[0x40:0x60] // @04A4 stack[-1] // @04DB memory[0x40:0x60] // @04E0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 049F 5B JUMPDEST 04A0 60 PUSH1 0x40 04A2 51 MLOAD 04A3 80 DUP1 04A4 82 DUP3 04A5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04BA 16 AND 04BB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04D0 16 AND 04D1 81 DUP2 04D2 52 MSTORE 04D3 60 PUSH1 0x20 04D5 01 ADD 04D6 91 SWAP2 04D7 50 POP 04D8 50 POP 04D9 60 PUSH1 0x40 04DB 51 MLOAD 04DC 80 DUP1 04DD 91 SWAP2 04DE 03 SUB 04DF 90 SWAP1 04E0 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @04D2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @04E0 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_04E1: // Incoming jump from 0x007C, if 0x6c0360eb == stack[-1] 04E1 5B JUMPDEST 04E2 61 PUSH2 0x04e9 04E5 61 PUSH2 0x0d25 04E8 56 *JUMP // Stack delta = +1 // Outputs[1] { @04E2 stack[0] = 0x04e9 } // Block ends with call to 0x0d25, returns to 0x04E9 label_04E9: // Incoming return from call to 0x0D25 at 0x04E8 // Inputs[4] // { // @04EC memory[0x40:0x60] // @04F7 stack[-1] // @04FA memory[stack[-1]:stack[-1] + 0x20] // @0503 memory[stack[-1]:stack[-1] + 0x20] // } 04E9 5B JUMPDEST 04EA 60 PUSH1 0x40 04EC 51 MLOAD 04ED 80 DUP1 04EE 80 DUP1 04EF 60 PUSH1 0x20 04F1 01 ADD 04F2 82 DUP3 04F3 81 DUP2 04F4 03 SUB 04F5 82 DUP3 04F6 52 MSTORE 04F7 83 DUP4 04F8 81 DUP2 04F9 81 DUP2 04FA 51 MLOAD 04FB 81 DUP2 04FC 52 MSTORE 04FD 60 PUSH1 0x20 04FF 01 ADD 0500 91 SWAP2 0501 50 POP 0502 80 DUP1 0503 51 MLOAD 0504 90 SWAP1 0505 60 PUSH1 0x20 0507 01 ADD 0508 90 SWAP1 0509 80 DUP1 050A 83 DUP4 050B 83 DUP4 050C 60 PUSH1 0x00 050E 5B JUMPDEST 050F 83 DUP4 0510 81 DUP2 0511 10 LT 0512 15 ISZERO 0513 61 PUSH2 0x0529 0516 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @04EC stack[0] = memory[0x40:0x60] // @04ED stack[1] = memory[0x40:0x60] // @04F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @04FC memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0500 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0508 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0508 stack[3] = 0x20 + stack[-1] // @0509 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @050A stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @050B stack[7] = 0x20 + stack[-1] // @050C stack[8] = 0x00 // } // Block ends with conditional jump to 0x0529, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0517: // Incoming jump from 0x0516, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0516, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0517 stack[-1] // @0518 stack[-2] // @051A memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @051C stack[-3] // } 0517 80 DUP1 0518 82 DUP3 0519 01 ADD 051A 51 MLOAD 051B 81 DUP2 051C 84 DUP5 051D 01 ADD 051E 52 MSTORE 051F 60 PUSH1 0x20 0521 81 DUP2 0522 01 ADD 0523 90 SWAP1 0524 50 POP 0525 61 PUSH2 0x050e 0528 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @051E memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0523 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x050e label_0529: // Incoming jump from 0x0516, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0516, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @052E stack[-6] // @052E stack[-5] // @0530 stack[-7] // } 0529 5B JUMPDEST 052A 50 POP 052B 50 POP 052C 50 POP 052D 50 POP 052E 90 SWAP1 052F 50 POP 0530 90 SWAP1 0531 81 DUP2 0532 01 ADD 0533 90 SWAP1 0534 60 PUSH1 0x1f 0536 16 AND 0537 80 DUP1 0538 15 ISZERO 0539 61 PUSH2 0x0556 053C 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0533 stack[-7] = stack[-5] + stack[-7] // @0536 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0556, if !(0x1f & stack[-5]) label_053D: // Incoming jump from 0x053C, if not !(0x1f & stack[-5]) // Inputs[6] // { // @053D stack[-1] // @053E stack[-2] // @0541 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0558 stack[-5] // @055E memory[0x40:0x60] // @0563 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 053D 80 DUP1 053E 82 DUP3 053F 03 SUB 0540 80 DUP1 0541 51 MLOAD 0542 60 PUSH1 0x01 0544 83 DUP4 0545 60 PUSH1 0x20 0547 03 SUB 0548 61 PUSH2 0x0100 054B 0A EXP 054C 03 SUB 054D 19 NOT 054E 16 AND 054F 81 DUP2 0550 52 MSTORE 0551 60 PUSH1 0x20 0553 01 ADD 0554 91 SWAP2 0555 50 POP 0556 5B JUMPDEST 0557 50 POP 0558 92 SWAP3 0559 50 POP 055A 50 POP 055B 50 POP 055C 60 PUSH1 0x40 055E 51 MLOAD 055F 80 DUP1 0560 91 SWAP2 0561 03 SUB 0562 90 SWAP1 0563 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0550 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0563 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0564: // Incoming jump from 0x0087, if 0x70a08231 == stack[-1] // Inputs[1] { @056B msg.data.length } 0564 5B JUMPDEST 0565 61 PUSH2 0x05a6 0568 60 PUSH1 0x04 056A 80 DUP1 056B 36 CALLDATASIZE 056C 03 SUB 056D 60 PUSH1 0x20 056F 81 DUP2 0570 10 LT 0571 15 ISZERO 0572 61 PUSH2 0x057a 0575 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0565 stack[0] = 0x05a6 // @0568 stack[1] = 0x04 // @056C stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x057a, returns to 0x05A6, if !(msg.data.length - 0x04 < 0x20) label_0576: // Incoming jump from 0x0575, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0579 memory[0x00:0x00] } 0576 60 PUSH1 0x00 0578 80 DUP1 0579 FD *REVERT // Stack delta = +0 // Outputs[1] { @0579 revert(memory[0x00:0x00]); } // Block terminates label_057A: // Incoming call from 0x0575, returns to 0x05A6, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @057B stack[-2] // @057C stack[-1] // @0580 msg.data[stack[-2]:stack[-2] + 0x20] // } 057A 5B JUMPDEST 057B 81 DUP2 057C 01 ADD 057D 90 SWAP1 057E 80 DUP1 057F 80 DUP1 0580 35 CALLDATALOAD 0581 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0596 16 AND 0597 90 SWAP1 0598 60 PUSH1 0x20 059A 01 ADD 059B 90 SWAP1 059C 92 SWAP3 059D 91 SWAP2 059E 90 SWAP1 059F 50 POP 05A0 50 POP 05A1 50 POP 05A2 61 PUSH2 0x0dc7 05A5 56 *JUMP // Stack delta = -1 // Outputs[1] { @059C stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0dc7 label_05A6: // Incoming return from call to 0x057A at 0x0575 // Inputs[4] // { // @05A9 memory[0x40:0x60] // @05AB stack[-1] // @05B6 memory[0x40:0x60] // @05BB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 05A6 5B JUMPDEST 05A7 60 PUSH1 0x40 05A9 51 MLOAD 05AA 80 DUP1 05AB 82 DUP3 05AC 81 DUP2 05AD 52 MSTORE 05AE 60 PUSH1 0x20 05B0 01 ADD 05B1 91 SWAP2 05B2 50 POP 05B3 50 POP 05B4 60 PUSH1 0x40 05B6 51 MLOAD 05B7 80 DUP1 05B8 91 SWAP2 05B9 03 SUB 05BA 90 SWAP1 05BB F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @05AD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @05BB return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_05BC: // Incoming jump from 0x0092, if 0x715018a6 == stack[-1] 05BC 5B JUMPDEST 05BD 61 PUSH2 0x05c4 05C0 61 PUSH2 0x0e69 05C3 56 *JUMP // Stack delta = +1 // Outputs[1] { @05BD stack[0] = 0x05c4 } // Block ends with call to 0x0e69, returns to 0x05C4 label_05C4: // Incoming return from call to 0x0E69 at 0x05C3 05C4 5B JUMPDEST 05C5 00 *STOP // Stack delta = +0 // Outputs[1] { @05C5 stop(); } // Block terminates label_05C6: // Incoming jump from 0x009D, if 0x8da5cb5b == stack[-1] 05C6 5B JUMPDEST 05C7 61 PUSH2 0x05ce 05CA 61 PUSH2 0x0fd9 05CD 56 *JUMP // Stack delta = +1 // Outputs[1] { @05C7 stack[0] = 0x05ce } // Block ends with call to 0x0fd9, returns to 0x05CE label_05CE: // Incoming return from call to 0x0FD9 at 0x05CD // Inputs[4] // { // @05D1 memory[0x40:0x60] // @05D3 stack[-1] // @060A memory[0x40:0x60] // @060F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 05CE 5B JUMPDEST 05CF 60 PUSH1 0x40 05D1 51 MLOAD 05D2 80 DUP1 05D3 82 DUP3 05D4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05E9 16 AND 05EA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05FF 16 AND 0600 81 DUP2 0601 52 MSTORE 0602 60 PUSH1 0x20 0604 01 ADD 0605 91 SWAP2 0606 50 POP 0607 50 POP 0608 60 PUSH1 0x40 060A 51 MLOAD 060B 80 DUP1 060C 91 SWAP2 060D 03 SUB 060E 90 SWAP1 060F F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0601 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @060F return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0610: // Incoming jump from 0x00A8, if 0x95d89b41 == stack[-1] 0610 5B JUMPDEST 0611 61 PUSH2 0x0618 0614 61 PUSH2 0x1003 0617 56 *JUMP // Stack delta = +1 // Outputs[1] { @0611 stack[0] = 0x0618 } // Block ends with call to 0x1003, returns to 0x0618 label_0618: // Incoming return from call to 0x1003 at 0x0617 // Inputs[4] // { // @061B memory[0x40:0x60] // @0626 stack[-1] // @0629 memory[stack[-1]:stack[-1] + 0x20] // @0632 memory[stack[-1]:stack[-1] + 0x20] // } 0618 5B JUMPDEST 0619 60 PUSH1 0x40 061B 51 MLOAD 061C 80 DUP1 061D 80 DUP1 061E 60 PUSH1 0x20 0620 01 ADD 0621 82 DUP3 0622 81 DUP2 0623 03 SUB 0624 82 DUP3 0625 52 MSTORE 0626 83 DUP4 0627 81 DUP2 0628 81 DUP2 0629 51 MLOAD 062A 81 DUP2 062B 52 MSTORE 062C 60 PUSH1 0x20 062E 01 ADD 062F 91 SWAP2 0630 50 POP 0631 80 DUP1 0632 51 MLOAD 0633 90 SWAP1 0634 60 PUSH1 0x20 0636 01 ADD 0637 90 SWAP1 0638 80 DUP1 0639 83 DUP4 063A 83 DUP4 063B 60 PUSH1 0x00 063D 5B JUMPDEST 063E 83 DUP4 063F 81 DUP2 0640 10 LT 0641 15 ISZERO 0642 61 PUSH2 0x0658 0645 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @061B stack[0] = memory[0x40:0x60] // @061C stack[1] = memory[0x40:0x60] // @0625 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @062B memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @062F stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0637 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0637 stack[3] = 0x20 + stack[-1] // @0638 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0639 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @063A stack[7] = 0x20 + stack[-1] // @063B stack[8] = 0x00 // } // Block ends with conditional jump to 0x0658, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0646: // Incoming jump from 0x0645, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0645, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0646 stack[-1] // @0647 stack[-2] // @0649 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @064B stack[-3] // } 0646 80 DUP1 0647 82 DUP3 0648 01 ADD 0649 51 MLOAD 064A 81 DUP2 064B 84 DUP5 064C 01 ADD 064D 52 MSTORE 064E 60 PUSH1 0x20 0650 81 DUP2 0651 01 ADD 0652 90 SWAP1 0653 50 POP 0654 61 PUSH2 0x063d 0657 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @064D memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0652 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x063d label_0658: // Incoming jump from 0x0645, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0645, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @065D stack[-6] // @065D stack[-5] // @065F stack[-7] // } 0658 5B JUMPDEST 0659 50 POP 065A 50 POP 065B 50 POP 065C 50 POP 065D 90 SWAP1 065E 50 POP 065F 90 SWAP1 0660 81 DUP2 0661 01 ADD 0662 90 SWAP1 0663 60 PUSH1 0x1f 0665 16 AND 0666 80 DUP1 0667 15 ISZERO 0668 61 PUSH2 0x0685 066B 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0662 stack[-7] = stack[-5] + stack[-7] // @0665 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0685, if !(0x1f & stack[-5]) label_066C: // Incoming jump from 0x066B, if not !(0x1f & stack[-5]) // Inputs[6] // { // @066C stack[-1] // @066D stack[-2] // @0670 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0687 stack[-5] // @068D memory[0x40:0x60] // @0692 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 066C 80 DUP1 066D 82 DUP3 066E 03 SUB 066F 80 DUP1 0670 51 MLOAD 0671 60 PUSH1 0x01 0673 83 DUP4 0674 60 PUSH1 0x20 0676 03 SUB 0677 61 PUSH2 0x0100 067A 0A EXP 067B 03 SUB 067C 19 NOT 067D 16 AND 067E 81 DUP2 067F 52 MSTORE 0680 60 PUSH1 0x20 0682 01 ADD 0683 91 SWAP2 0684 50 POP 0685 5B JUMPDEST 0686 50 POP 0687 92 SWAP3 0688 50 POP 0689 50 POP 068A 50 POP 068B 60 PUSH1 0x40 068D 51 MLOAD 068E 80 DUP1 068F 91 SWAP2 0690 03 SUB 0691 90 SWAP1 0692 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @067F memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0692 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0693: // Incoming jump from 0x0040, if 0xa22cb465 == stack[-1] // Inputs[1] { @069A msg.data.length } 0693 5B JUMPDEST 0694 61 PUSH2 0x06e1 0697 60 PUSH1 0x04 0699 80 DUP1 069A 36 CALLDATASIZE 069B 03 SUB 069C 60 PUSH1 0x40 069E 81 DUP2 069F 10 LT 06A0 15 ISZERO 06A1 61 PUSH2 0x06a9 06A4 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0694 stack[0] = 0x06e1 // @0697 stack[1] = 0x04 // @069B stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x06a9, returns to 0x06E1, if !(msg.data.length - 0x04 < 0x40) label_06A5: // Incoming jump from 0x06A4, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @06A8 memory[0x00:0x00] } 06A5 60 PUSH1 0x00 06A7 80 DUP1 06A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @06A8 revert(memory[0x00:0x00]); } // Block terminates label_06A9: // Incoming call from 0x06A4, returns to 0x06E1, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @06AA stack[-2] // @06AB stack[-1] // @06AF msg.data[stack[-2]:stack[-2] + 0x20] // @06CF msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 06A9 5B JUMPDEST 06AA 81 DUP2 06AB 01 ADD 06AC 90 SWAP1 06AD 80 DUP1 06AE 80 DUP1 06AF 35 CALLDATALOAD 06B0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06C5 16 AND 06C6 90 SWAP1 06C7 60 PUSH1 0x20 06C9 01 ADD 06CA 90 SWAP1 06CB 92 SWAP3 06CC 91 SWAP2 06CD 90 SWAP1 06CE 80 DUP1 06CF 35 CALLDATALOAD 06D0 15 ISZERO 06D1 15 ISZERO 06D2 90 SWAP1 06D3 60 PUSH1 0x20 06D5 01 ADD 06D6 90 SWAP1 06D7 92 SWAP3 06D8 91 SWAP2 06D9 90 SWAP1 06DA 50 POP 06DB 50 POP 06DC 50 POP 06DD 61 PUSH2 0x10a5 06E0 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @06CB stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @06D7 stack[-1] = !!msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x10a5 label_06E1: // Incoming return from call to 0x06A9 at 0x06A4 06E1 5B JUMPDEST 06E2 00 *STOP // Stack delta = +0 // Outputs[1] { @06E2 stop(); } // Block terminates label_06E3: // Incoming jump from 0x004B, if 0xb88d4fde == stack[-1] // Inputs[1] { @06EA msg.data.length } 06E3 5B JUMPDEST 06E4 61 PUSH2 0x07e6 06E7 60 PUSH1 0x04 06E9 80 DUP1 06EA 36 CALLDATASIZE 06EB 03 SUB 06EC 60 PUSH1 0x80 06EE 81 DUP2 06EF 10 LT 06F0 15 ISZERO 06F1 61 PUSH2 0x06f9 06F4 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @06E4 stack[0] = 0x07e6 // @06E7 stack[1] = 0x04 // @06EB stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x06f9, returns to 0x07E6, if !(msg.data.length - 0x04 < 0x80) label_06F5: // Incoming jump from 0x06F4, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @06F8 memory[0x00:0x00] } 06F5 60 PUSH1 0x00 06F7 80 DUP1 06F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @06F8 revert(memory[0x00:0x00]); } // Block terminates label_06F9: // Incoming call from 0x06F4, returns to 0x07E6, if !(msg.data.length - 0x04 < 0x80) // Inputs[6] // { // @06FA stack[-2] // @06FB stack[-1] // @06FF msg.data[stack[-2]:stack[-2] + 0x20] // @071F msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @073F msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // @0749 msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] // } 06F9 5B JUMPDEST 06FA 81 DUP2 06FB 01 ADD 06FC 90 SWAP1 06FD 80 DUP1 06FE 80 DUP1 06FF 35 CALLDATALOAD 0700 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0715 16 AND 0716 90 SWAP1 0717 60 PUSH1 0x20 0719 01 ADD 071A 90 SWAP1 071B 92 SWAP3 071C 91 SWAP2 071D 90 SWAP1 071E 80 DUP1 071F 35 CALLDATALOAD 0720 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0735 16 AND 0736 90 SWAP1 0737 60 PUSH1 0x20 0739 01 ADD 073A 90 SWAP1 073B 92 SWAP3 073C 91 SWAP2 073D 90 SWAP1 073E 80 DUP1 073F 35 CALLDATALOAD 0740 90 SWAP1 0741 60 PUSH1 0x20 0743 01 ADD 0744 90 SWAP1 0745 92 SWAP3 0746 91 SWAP2 0747 90 SWAP1 0748 80 DUP1 0749 35 CALLDATALOAD 074A 90 SWAP1 074B 60 PUSH1 0x20 074D 01 ADD 074E 90 SWAP1 074F 64 PUSH5 0x0100000000 0755 81 DUP2 0756 11 GT 0757 15 ISZERO 0758 61 PUSH2 0x0760 075B 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @071B stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @073B stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0745 stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // @0746 stack[1] = stack[-2] + stack[-1] // @0747 stack[2] = stack[-2] // @074E stack[4] = msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] // @074E stack[3] = 0x20 + 0x20 + 0x20 + 0x20 + stack[-2] // } // Block ends with conditional jump to 0x0760, if !(msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) label_075C: // Incoming jump from 0x075B, if not !(msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @075F memory[0x00:0x00] } 075C 60 PUSH1 0x00 075E 80 DUP1 075F FD *REVERT // Stack delta = +0 // Outputs[1] { @075F revert(memory[0x00:0x00]); } // Block terminates label_0760: // Incoming jump from 0x075B, if !(msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @0761 stack[-3] // @0762 stack[-1] // @0763 stack[-4] // } 0760 5B JUMPDEST 0761 82 DUP3 0762 01 ADD 0763 83 DUP4 0764 60 PUSH1 0x20 0766 82 DUP3 0767 01 ADD 0768 11 GT 0769 15 ISZERO 076A 61 PUSH2 0x0772 076D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0762 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0772, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_076E: // Incoming jump from 0x076D, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0771 memory[0x00:0x00] } 076E 60 PUSH1 0x00 0770 80 DUP1 0771 FD *REVERT // Stack delta = +0 // Outputs[1] { @0771 revert(memory[0x00:0x00]); } // Block terminates label_0772: // Incoming jump from 0x076D, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0773 stack[-1] // @0774 msg.data[stack[-1]:stack[-1] + 0x20] // @0779 stack[-2] // @077A stack[-4] // } 0772 5B JUMPDEST 0773 80 DUP1 0774 35 CALLDATALOAD 0775 90 SWAP1 0776 60 PUSH1 0x20 0778 01 ADD 0779 91 SWAP2 077A 84 DUP5 077B 60 PUSH1 0x01 077D 83 DUP4 077E 02 MUL 077F 84 DUP5 0780 01 ADD 0781 11 GT 0782 64 PUSH5 0x0100000000 0788 83 DUP4 0789 11 GT 078A 17 OR 078B 15 ISZERO 078C 61 PUSH2 0x0794 078F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0775 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0779 stack[0] = stack[-2] // @0779 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0794, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0790: // Incoming jump from 0x078F, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0793 memory[0x00:0x00] } 0790 60 PUSH1 0x00 0792 80 DUP1 0793 FD *REVERT // Stack delta = +0 // Outputs[1] { @0793 revert(memory[0x00:0x00]); } // Block terminates label_0794: // Incoming jump from 0x078F, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @0795 stack[-3] // @0795 stack[-1] // @0796 stack[-2] // @07A7 memory[0x40:0x60] // @07BE msg.data[stack[-3]:stack[-3] + stack[-2]] // @07DA stack[-4] // @07DB stack[-5] // } 0794 5B JUMPDEST 0795 91 SWAP2 0796 90 SWAP1 0797 80 DUP1 0798 80 DUP1 0799 60 PUSH1 0x1f 079B 01 ADD 079C 60 PUSH1 0x20 079E 80 DUP1 079F 91 SWAP2 07A0 04 DIV 07A1 02 MUL 07A2 60 PUSH1 0x20 07A4 01 ADD 07A5 60 PUSH1 0x40 07A7 51 MLOAD 07A8 90 SWAP1 07A9 81 DUP2 07AA 01 ADD 07AB 60 PUSH1 0x40 07AD 52 MSTORE 07AE 80 DUP1 07AF 93 SWAP4 07B0 92 SWAP3 07B1 91 SWAP2 07B2 90 SWAP1 07B3 81 DUP2 07B4 81 DUP2 07B5 52 MSTORE 07B6 60 PUSH1 0x20 07B8 01 ADD 07B9 83 DUP4 07BA 83 DUP4 07BB 80 DUP1 07BC 82 DUP3 07BD 84 DUP5 07BE 37 CALLDATACOPY 07BF 60 PUSH1 0x00 07C1 81 DUP2 07C2 84 DUP5 07C3 01 ADD 07C4 52 MSTORE 07C5 60 PUSH1 0x1f 07C7 19 NOT 07C8 60 PUSH1 0x1f 07CA 82 DUP3 07CB 01 ADD 07CC 16 AND 07CD 90 SWAP1 07CE 50 POP 07CF 80 DUP1 07D0 83 DUP4 07D1 01 ADD 07D2 92 SWAP3 07D3 50 POP 07D4 50 POP 07D5 50 POP 07D6 50 POP 07D7 50 POP 07D8 50 POP 07D9 50 POP 07DA 91 SWAP2 07DB 92 SWAP3 07DC 91 SWAP2 07DD 92 SWAP3 07DE 90 SWAP1 07DF 50 POP 07E0 50 POP 07E1 50 POP 07E2 61 PUSH2 0x125d 07E5 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @07AD memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @07B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @07BE memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @07C4 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @07DD stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x125d label_07E6: // Incoming return from call to 0x06F9 at 0x06F4 07E6 5B JUMPDEST 07E7 00 *STOP // Stack delta = +0 // Outputs[1] { @07E7 stop(); } // Block terminates label_07E8: // Incoming jump from 0x0056, if 0xc87b56dd == stack[-1] // Inputs[1] { @07EF msg.data.length } 07E8 5B JUMPDEST 07E9 61 PUSH2 0x0814 07EC 60 PUSH1 0x04 07EE 80 DUP1 07EF 36 CALLDATASIZE 07F0 03 SUB 07F1 60 PUSH1 0x20 07F3 81 DUP2 07F4 10 LT 07F5 15 ISZERO 07F6 61 PUSH2 0x07fe 07F9 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @07E9 stack[0] = 0x0814 // @07EC stack[1] = 0x04 // @07F0 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x07fe, returns to 0x0814, if !(msg.data.length - 0x04 < 0x20) label_07FA: // Incoming jump from 0x07F9, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @07FD memory[0x00:0x00] } 07FA 60 PUSH1 0x00 07FC 80 DUP1 07FD FD *REVERT // Stack delta = +0 // Outputs[1] { @07FD revert(memory[0x00:0x00]); } // Block terminates label_07FE: // Incoming call from 0x07F9, returns to 0x0814, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @07FF stack[-2] // @0800 stack[-1] // @0804 msg.data[stack[-2]:stack[-2] + 0x20] // } 07FE 5B JUMPDEST 07FF 81 DUP2 0800 01 ADD 0801 90 SWAP1 0802 80 DUP1 0803 80 DUP1 0804 35 CALLDATALOAD 0805 90 SWAP1 0806 60 PUSH1 0x20 0808 01 ADD 0809 90 SWAP1 080A 92 SWAP3 080B 91 SWAP2 080C 90 SWAP1 080D 50 POP 080E 50 POP 080F 50 POP 0810 61 PUSH2 0x12d5 0813 56 *JUMP // Stack delta = -1 // Outputs[1] { @080A stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x12d5 label_0814: // Incoming return from call to 0x07FE at 0x07F9 // Inputs[4] // { // @0817 memory[0x40:0x60] // @0822 stack[-1] // @0825 memory[stack[-1]:stack[-1] + 0x20] // @082E memory[stack[-1]:stack[-1] + 0x20] // } 0814 5B JUMPDEST 0815 60 PUSH1 0x40 0817 51 MLOAD 0818 80 DUP1 0819 80 DUP1 081A 60 PUSH1 0x20 081C 01 ADD 081D 82 DUP3 081E 81 DUP2 081F 03 SUB 0820 82 DUP3 0821 52 MSTORE 0822 83 DUP4 0823 81 DUP2 0824 81 DUP2 0825 51 MLOAD 0826 81 DUP2 0827 52 MSTORE 0828 60 PUSH1 0x20 082A 01 ADD 082B 91 SWAP2 082C 50 POP 082D 80 DUP1 082E 51 MLOAD 082F 90 SWAP1 0830 60 PUSH1 0x20 0832 01 ADD 0833 90 SWAP1 0834 80 DUP1 0835 83 DUP4 0836 83 DUP4 0837 60 PUSH1 0x00 0839 5B JUMPDEST 083A 83 DUP4 083B 81 DUP2 083C 10 LT 083D 15 ISZERO 083E 61 PUSH2 0x0854 0841 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @0817 stack[0] = memory[0x40:0x60] // @0818 stack[1] = memory[0x40:0x60] // @0821 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0827 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @082B stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0833 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0833 stack[3] = 0x20 + stack[-1] // @0834 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0835 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0836 stack[7] = 0x20 + stack[-1] // @0837 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0854, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0842: // Incoming jump from 0x0841, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0841, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0842 stack[-1] // @0843 stack[-2] // @0845 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0847 stack[-3] // } 0842 80 DUP1 0843 82 DUP3 0844 01 ADD 0845 51 MLOAD 0846 81 DUP2 0847 84 DUP5 0848 01 ADD 0849 52 MSTORE 084A 60 PUSH1 0x20 084C 81 DUP2 084D 01 ADD 084E 90 SWAP1 084F 50 POP 0850 61 PUSH2 0x0839 0853 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0849 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @084E stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0839 label_0854: // Incoming jump from 0x0841, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0841, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0859 stack[-6] // @0859 stack[-5] // @085B stack[-7] // } 0854 5B JUMPDEST 0855 50 POP 0856 50 POP 0857 50 POP 0858 50 POP 0859 90 SWAP1 085A 50 POP 085B 90 SWAP1 085C 81 DUP2 085D 01 ADD 085E 90 SWAP1 085F 60 PUSH1 0x1f 0861 16 AND 0862 80 DUP1 0863 15 ISZERO 0864 61 PUSH2 0x0881 0867 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @085E stack[-7] = stack[-5] + stack[-7] // @0861 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0881, if !(0x1f & stack[-5]) label_0868: // Incoming jump from 0x0867, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0868 stack[-1] // @0869 stack[-2] // @086C memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0883 stack[-5] // @0889 memory[0x40:0x60] // @088E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0868 80 DUP1 0869 82 DUP3 086A 03 SUB 086B 80 DUP1 086C 51 MLOAD 086D 60 PUSH1 0x01 086F 83 DUP4 0870 60 PUSH1 0x20 0872 03 SUB 0873 61 PUSH2 0x0100 0876 0A EXP 0877 03 SUB 0878 19 NOT 0879 16 AND 087A 81 DUP2 087B 52 MSTORE 087C 60 PUSH1 0x20 087E 01 ADD 087F 91 SWAP2 0880 50 POP 0881 5B JUMPDEST 0882 50 POP 0883 92 SWAP3 0884 50 POP 0885 50 POP 0886 50 POP 0887 60 PUSH1 0x40 0889 51 MLOAD 088A 80 DUP1 088B 91 SWAP2 088C 03 SUB 088D 90 SWAP1 088E F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @087B memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @088E return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_088F: // Incoming jump from 0x0061, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0896 msg.data.length } 088F 5B JUMPDEST 0890 61 PUSH2 0x08f1 0893 60 PUSH1 0x04 0895 80 DUP1 0896 36 CALLDATASIZE 0897 03 SUB 0898 60 PUSH1 0x40 089A 81 DUP2 089B 10 LT 089C 15 ISZERO 089D 61 PUSH2 0x08a5 08A0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0890 stack[0] = 0x08f1 // @0893 stack[1] = 0x04 // @0897 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x08a5, returns to 0x08F1, if !(msg.data.length - 0x04 < 0x40) label_08A1: // Incoming jump from 0x08A0, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @08A4 memory[0x00:0x00] } 08A1 60 PUSH1 0x00 08A3 80 DUP1 08A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @08A4 revert(memory[0x00:0x00]); } // Block terminates label_08A5: // Incoming call from 0x08A0, returns to 0x08F1, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @08A6 stack[-2] // @08A7 stack[-1] // @08AB msg.data[stack[-2]:stack[-2] + 0x20] // @08CB msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 08A5 5B JUMPDEST 08A6 81 DUP2 08A7 01 ADD 08A8 90 SWAP1 08A9 80 DUP1 08AA 80 DUP1 08AB 35 CALLDATALOAD 08AC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08C1 16 AND 08C2 90 SWAP1 08C3 60 PUSH1 0x20 08C5 01 ADD 08C6 90 SWAP1 08C7 92 SWAP3 08C8 91 SWAP2 08C9 90 SWAP1 08CA 80 DUP1 08CB 35 CALLDATALOAD 08CC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08E1 16 AND 08E2 90 SWAP1 08E3 60 PUSH1 0x20 08E5 01 ADD 08E6 90 SWAP1 08E7 92 SWAP3 08E8 91 SWAP2 08E9 90 SWAP1 08EA 50 POP 08EB 50 POP 08EC 50 POP 08ED 61 PUSH2 0x15a6 08F0 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @08C7 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @08E7 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x15a6 label_08F1: // Incoming return from call to 0x08A5 at 0x08A0 // Inputs[4] // { // @08F4 memory[0x40:0x60] // @08F6 stack[-1] // @0905 memory[0x40:0x60] // @090A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 08F1 5B JUMPDEST 08F2 60 PUSH1 0x40 08F4 51 MLOAD 08F5 80 DUP1 08F6 82 DUP3 08F7 15 ISZERO 08F8 15 ISZERO 08F9 15 ISZERO 08FA 15 ISZERO 08FB 81 DUP2 08FC 52 MSTORE 08FD 60 PUSH1 0x20 08FF 01 ADD 0900 91 SWAP2 0901 50 POP 0902 50 POP 0903 60 PUSH1 0x40 0905 51 MLOAD 0906 80 DUP1 0907 91 SWAP2 0908 03 SUB 0909 90 SWAP1 090A F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @08FC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @090A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_090B: // Incoming jump from 0x006C, if 0xf2fde38b == stack[-1] // Inputs[1] { @0912 msg.data.length } 090B 5B JUMPDEST 090C 61 PUSH2 0x094d 090F 60 PUSH1 0x04 0911 80 DUP1 0912 36 CALLDATASIZE 0913 03 SUB 0914 60 PUSH1 0x20 0916 81 DUP2 0917 10 LT 0918 15 ISZERO 0919 61 PUSH2 0x0921 091C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @090C stack[0] = 0x094d // @090F stack[1] = 0x04 // @0913 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0921, returns to 0x094D, if !(msg.data.length - 0x04 < 0x20) label_091D: // Incoming jump from 0x091C, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0920 memory[0x00:0x00] } 091D 60 PUSH1 0x00 091F 80 DUP1 0920 FD *REVERT // Stack delta = +0 // Outputs[1] { @0920 revert(memory[0x00:0x00]); } // Block terminates label_0921: // Incoming call from 0x091C, returns to 0x094D, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0922 stack[-2] // @0923 stack[-1] // @0927 msg.data[stack[-2]:stack[-2] + 0x20] // } 0921 5B JUMPDEST 0922 81 DUP2 0923 01 ADD 0924 90 SWAP1 0925 80 DUP1 0926 80 DUP1 0927 35 CALLDATALOAD 0928 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 093D 16 AND 093E 90 SWAP1 093F 60 PUSH1 0x20 0941 01 ADD 0942 90 SWAP1 0943 92 SWAP3 0944 91 SWAP2 0945 90 SWAP1 0946 50 POP 0947 50 POP 0948 50 POP 0949 61 PUSH2 0x163a 094C 56 *JUMP // Stack delta = -1 // Outputs[1] { @0943 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x163a label_094D: // Incoming return from call to 0x0921 at 0x091C 094D 5B JUMPDEST 094E 00 *STOP // Stack delta = +0 // Outputs[1] { @094E stop(); } // Block terminates label_094F: // Incoming jump from 0x017B // Inputs[4] // { // @0955 stack[-1] // @09A1 memory[0x00:0x40] // @09A5 storage[keccak256(memory[0x00:0x40])] // @09B2 stack[-2] // } 094F 5B JUMPDEST 0950 60 PUSH1 0x00 0952 80 DUP1 0953 60 PUSH1 0x00 0955 83 DUP4 0956 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0973 19 NOT 0974 16 AND 0975 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0992 19 NOT 0993 16 AND 0994 81 DUP2 0995 52 MSTORE 0996 60 PUSH1 0x20 0998 01 ADD 0999 90 SWAP1 099A 81 DUP2 099B 52 MSTORE 099C 60 PUSH1 0x20 099E 01 ADD 099F 60 PUSH1 0x00 09A1 20 SHA3 09A2 60 PUSH1 0x00 09A4 90 SWAP1 09A5 54 SLOAD 09A6 90 SWAP1 09A7 61 PUSH2 0x0100 09AA 0A EXP 09AB 90 SWAP1 09AC 04 DIV 09AD 60 PUSH1 0xff 09AF 16 AND 09B0 90 SWAP1 09B1 50 POP 09B2 91 SWAP2 09B3 90 SWAP1 09B4 50 POP 09B5 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0995 memory[0x00:0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] // @099B memory[0x20:0x40] = 0x00 // @09B2 stack[-2] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-2] label_09B6: // Incoming call from 0x019D, returns to 0x019E // Inputs[3] // { // @09BC storage[0x0a] // @09DD memory[0x40:0x60] // @09F0 storage[0x0a] // } 09B6 5B JUMPDEST 09B7 60 PUSH1 0x60 09B9 60 PUSH1 0x0a 09BB 80 DUP1 09BC 54 SLOAD 09BD 60 PUSH1 0x01 09BF 81 DUP2 09C0 60 PUSH1 0x01 09C2 16 AND 09C3 15 ISZERO 09C4 61 PUSH2 0x0100 09C7 02 MUL 09C8 03 SUB 09C9 16 AND 09CA 60 PUSH1 0x02 09CC 90 SWAP1 09CD 04 DIV 09CE 80 DUP1 09CF 60 PUSH1 0x1f 09D1 01 ADD 09D2 60 PUSH1 0x20 09D4 80 DUP1 09D5 91 SWAP2 09D6 04 DIV 09D7 02 MUL 09D8 60 PUSH1 0x20 09DA 01 ADD 09DB 60 PUSH1 0x40 09DD 51 MLOAD 09DE 90 SWAP1 09DF 81 DUP2 09E0 01 ADD 09E1 60 PUSH1 0x40 09E3 52 MSTORE 09E4 80 DUP1 09E5 92 SWAP3 09E6 91 SWAP2 09E7 90 SWAP1 09E8 81 DUP2 09E9 81 DUP2 09EA 52 MSTORE 09EB 60 PUSH1 0x20 09ED 01 ADD 09EE 82 DUP3 09EF 80 DUP1 09F0 54 SLOAD 09F1 60 PUSH1 0x01 09F3 81 DUP2 09F4 60 PUSH1 0x01 09F6 16 AND 09F7 15 ISZERO 09F8 61 PUSH2 0x0100 09FB 02 MUL 09FC 03 SUB 09FD 16 AND 09FE 60 PUSH1 0x02 0A00 90 SWAP1 0A01 04 DIV 0A02 80 DUP1 0A03 15 ISZERO 0A04 61 PUSH2 0x0a4e 0A07 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @09B7 stack[0] = 0x60 // @09E3 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02) / 0x20 * 0x20 // @09E5 stack[1] = memory[0x40:0x60] // @09E6 stack[2] = 0x0a // @09E7 stack[3] = (0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02 // @09EA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02 // @09ED stack[4] = 0x20 + memory[0x40:0x60] // @09EE stack[5] = 0x0a // @0A01 stack[6] = (0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02 // } // Block ends with conditional jump to 0x0a4e, if !((0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02) label_0A08: // Incoming jump from 0x0A07, if not !((0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02) // Inputs[1] { @0A08 stack[-1] } 0A08 80 DUP1 0A09 60 PUSH1 0x1f 0A0B 10 LT 0A0C 61 PUSH2 0x0a23 0A0F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a23, if 0x1f < stack[-1] label_0A10: // Incoming jump from 0x0A0F, if not 0x1f < stack[-1] // Inputs[4] // { // @0A14 stack[-2] // @0A15 storage[stack[-2]] // @0A18 stack[-3] // @0A1A stack[-1] // } 0A10 61 PUSH2 0x0100 0A13 80 DUP1 0A14 83 DUP4 0A15 54 SLOAD 0A16 04 DIV 0A17 02 MUL 0A18 83 DUP4 0A19 52 MSTORE 0A1A 91 SWAP2 0A1B 60 PUSH1 0x20 0A1D 01 ADD 0A1E 91 SWAP2 0A1F 61 PUSH2 0x0a4e 0A22 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0A19 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0A1E stack[-1] = stack[-1] // @0A1E stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0a4e label_0A23: // Incoming jump from 0x0A0F, if 0x1f < stack[-1] // Inputs[5] // { // @0A24 stack[-3] // @0A25 stack[-1] // @0A27 stack[-2] // @0A2F memory[0x00:0x20] // @0A33 storage[keccak256(memory[0x00:0x20])] // } 0A23 5B JUMPDEST 0A24 82 DUP3 0A25 01 ADD 0A26 91 SWAP2 0A27 90 SWAP1 0A28 60 PUSH1 0x00 0A2A 52 MSTORE 0A2B 60 PUSH1 0x20 0A2D 60 PUSH1 0x00 0A2F 20 SHA3 0A30 90 SWAP1 0A31 5B JUMPDEST 0A32 81 DUP2 0A33 54 SLOAD 0A34 81 DUP2 0A35 52 MSTORE 0A36 90 SWAP1 0A37 60 PUSH1 0x01 0A39 01 ADD 0A3A 90 SWAP1 0A3B 60 PUSH1 0x20 0A3D 01 ADD 0A3E 80 DUP1 0A3F 83 DUP4 0A40 11 GT 0A41 61 PUSH2 0x0a31 0A44 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0A26 stack[-3] = stack[-3] + stack[-1] // @0A2A memory[0x00:0x20] = stack[-2] // @0A35 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0A3A stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0A3D stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0a31, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0A45: // Incoming jump from 0x0A44, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0A44, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0A45 stack[-3] // @0A46 stack[-1] // } 0A45 82 DUP3 0A46 90 SWAP1 0A47 03 SUB 0A48 60 PUSH1 0x1f 0A4A 16 AND 0A4B 82 DUP3 0A4C 01 ADD 0A4D 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0A4D stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0A4D stack[-1] = stack[-3] // } // Block continues label_0A4E: // Incoming jump from 0x0A07, if !((0x0100 * !(0x01 & storage[0x0a]) - 0x01 & storage[0x0a]) / 0x02) // Incoming jump from 0x0A22 // Incoming jump from 0x0A4D // Inputs[3] // { // @0A54 stack[-6] // @0A54 stack[-7] // @0A56 stack[-8] // } 0A4E 5B JUMPDEST 0A4F 50 POP 0A50 50 POP 0A51 50 POP 0A52 50 POP 0A53 50 POP 0A54 90 SWAP1 0A55 50 POP 0A56 90 SWAP1 0A57 56 *JUMP // Stack delta = -7 // Outputs[1] { @0A56 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0A58: // Incoming call from 0x19D4, returns to 0x19D5 // Incoming jump from 0x0244 // Inputs[1] { @0A5E stack[-1] } 0A58 5B JUMPDEST 0A59 60 PUSH1 0x00 0A5B 61 PUSH2 0x0a63 0A5E 82 DUP3 0A5F 61 PUSH2 0x182f 0A62 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A59 stack[0] = 0x00 // @0A5B stack[1] = 0x0a63 // @0A5E stack[2] = stack[-1] // } // Block ends with call to 0x182f, returns to 0x0A63 label_0A63: // Incoming return from call to 0x182F at 0x0A62 // Inputs[1] { @0A67 stack[-1] } 0A63 5B JUMPDEST 0A64 61 PUSH2 0x0ab8 0A67 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0ab8, if stack[-1] label_0A68: // Incoming jump from 0x0A67, if not stack[-1] // Inputs[3] // { // @0A6A memory[0x40:0x60] // @0AB2 memory[0x40:0x60] // @0AB7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A68 60 PUSH1 0x40 0A6A 51 MLOAD 0A6B 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0A8C 81 DUP2 0A8D 52 MSTORE 0A8E 60 PUSH1 0x04 0A90 01 ADD 0A91 80 DUP1 0A92 80 DUP1 0A93 60 PUSH1 0x20 0A95 01 ADD 0A96 82 DUP3 0A97 81 DUP2 0A98 03 SUB 0A99 82 DUP3 0A9A 52 MSTORE 0A9B 60 PUSH1 0x2c 0A9D 81 DUP2 0A9E 52 MSTORE 0A9F 60 PUSH1 0x20 0AA1 01 ADD 0AA2 80 DUP1 0AA3 61 PUSH2 0x309f 0AA6 60 PUSH1 0x2c 0AA8 91 SWAP2 0AA9 39 CODECOPY 0AAA 60 PUSH1 0x40 0AAC 01 ADD 0AAD 91 SWAP2 0AAE 50 POP 0AAF 50 POP 0AB0 60 PUSH1 0x40 0AB2 51 MLOAD 0AB3 80 DUP1 0AB4 91 SWAP2 0AB5 03 SUB 0AB6 90 SWAP1 0AB7 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0A8D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0A9A memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0A9E memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @0AA9 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x309f:0x30cb] // @0AB7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0AB8: // Incoming jump from 0x0A67, if stack[-1] // Inputs[5] // { // @0ABD stack[-2] // @0ACB memory[0x00:0x40] // @0ACF storage[keccak256(memory[0x00:0x40])] // @0AED stack[-1] // @0AEF stack[-3] // } 0AB8 5B JUMPDEST 0AB9 60 PUSH1 0x08 0ABB 60 PUSH1 0x00 0ABD 83 DUP4 0ABE 81 DUP2 0ABF 52 MSTORE 0AC0 60 PUSH1 0x20 0AC2 01 ADD 0AC3 90 SWAP1 0AC4 81 DUP2 0AC5 52 MSTORE 0AC6 60 PUSH1 0x20 0AC8 01 ADD 0AC9 60 PUSH1 0x00 0ACB 20 SHA3 0ACC 60 PUSH1 0x00 0ACE 90 SWAP1 0ACF 54 SLOAD 0AD0 90 SWAP1 0AD1 61 PUSH2 0x0100 0AD4 0A EXP 0AD5 90 SWAP1 0AD6 04 DIV 0AD7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AEC 16 AND 0AED 90 SWAP1 0AEE 50 POP 0AEF 91 SWAP2 0AF0 90 SWAP1 0AF1 50 POP 0AF2 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0ABF memory[0x00:0x20] = stack[-2] // @0AC5 memory[0x20:0x40] = 0x08 // @0AEF stack[-3] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-3] label_0AF3: // Incoming jump from 0x02D2 // Inputs[1] { @0AF9 stack[-1] } 0AF3 5B JUMPDEST 0AF4 60 PUSH1 0x00 0AF6 61 PUSH2 0x0afe 0AF9 82 DUP3 0AFA 61 PUSH2 0x0d08 0AFD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0AF4 stack[0] = 0x00 // @0AF6 stack[1] = 0x0afe // @0AF9 stack[2] = stack[-1] // } // Block ends with call to 0x0d08, returns to 0x0AFE label_0AFE: // Incoming return from call to 0x0D08 at 0x0AFD // Inputs[3] // { // @0AFF stack[-2] // @0AFF stack[-1] // @0B18 stack[-4] // } 0AFE 5B JUMPDEST 0AFF 90 SWAP1 0B00 50 POP 0B01 80 DUP1 0B02 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B17 16 AND 0B18 83 DUP4 0B19 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B2E 16 AND 0B2F 14 EQ 0B30 15 ISZERO 0B31 61 PUSH2 0x0b85 0B34 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0AFF stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0b85, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_0B35: // Incoming jump from 0x0B34, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[3] // { // @0B37 memory[0x40:0x60] // @0B7F memory[0x40:0x60] // @0B84 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B35 60 PUSH1 0x40 0B37 51 MLOAD 0B38 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0B59 81 DUP2 0B5A 52 MSTORE 0B5B 60 PUSH1 0x04 0B5D 01 ADD 0B5E 80 DUP1 0B5F 80 DUP1 0B60 60 PUSH1 0x20 0B62 01 ADD 0B63 82 DUP3 0B64 81 DUP2 0B65 03 SUB 0B66 82 DUP3 0B67 52 MSTORE 0B68 60 PUSH1 0x21 0B6A 81 DUP2 0B6B 52 MSTORE 0B6C 60 PUSH1 0x20 0B6E 01 ADD 0B6F 80 DUP1 0B70 61 PUSH2 0x3123 0B73 60 PUSH1 0x21 0B75 91 SWAP2 0B76 39 CODECOPY 0B77 60 PUSH1 0x40 0B79 01 ADD 0B7A 91 SWAP2 0B7B 50 POP 0B7C 50 POP 0B7D 60 PUSH1 0x40 0B7F 51 MLOAD 0B80 80 DUP1 0B81 91 SWAP2 0B82 03 SUB 0B83 90 SWAP1 0B84 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0B5A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0B67 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0B6B memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x21 // @0B76 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x21] = code[0x3123:0x3144] // @0B84 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0B85: // Incoming jump from 0x0B34, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @0B86 stack[-1] } 0B85 5B JUMPDEST 0B86 80 DUP1 0B87 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B9C 16 AND 0B9D 61 PUSH2 0x0ba4 0BA0 61 PUSH2 0x1844 0BA3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B9C stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0B9D stack[1] = 0x0ba4 // } // Block ends with call to 0x1844, returns to 0x0BA4 label_0BA4: // Incoming return from call to 0x1844 at 0x0BA3 // Inputs[2] // { // @0BBA stack[-1] // @0BBB stack[-2] // } 0BA4 5B JUMPDEST 0BA5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BBA 16 AND 0BBB 14 EQ 0BBC 80 DUP1 0BBD 61 PUSH2 0x0bd3 0BC0 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0BBB stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x0bd3, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_0BC1: // Incoming jump from 0x0BC0, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @0BC5 stack[-2] } 0BC1 50 POP 0BC2 61 PUSH2 0x0bd2 0BC5 81 DUP2 0BC6 61 PUSH2 0x0bcd 0BC9 61 PUSH2 0x1844 0BCC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0BC2 stack[-1] = 0x0bd2 // @0BC5 stack[0] = stack[-2] // @0BC6 stack[1] = 0x0bcd // } // Block ends with call to 0x1844, returns to 0x0BCD label_0BCD: // Incoming return from call to 0x1844 at 0x0BCC 0BCD 5B JUMPDEST 0BCE 61 PUSH2 0x15a6 0BD1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x15a6 label_0BD2: // Incoming return from call to 0x0BCD at 0x0BCC 0BD2 5B JUMPDEST // Stack delta = +0 // Block continues label_0BD3: // Incoming jump from 0x0BD2 // Incoming jump from 0x0BC0, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @0BD7 stack[-1] } 0BD3 5B JUMPDEST 0BD4 61 PUSH2 0x0c28 0BD7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c28, if stack[-1] label_0BD8: // Incoming jump from 0x0BD7, if not stack[-1] // Inputs[3] // { // @0BDA memory[0x40:0x60] // @0C22 memory[0x40:0x60] // @0C27 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0BD8 60 PUSH1 0x40 0BDA 51 MLOAD 0BDB 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0BFC 81 DUP2 0BFD 52 MSTORE 0BFE 60 PUSH1 0x04 0C00 01 ADD 0C01 80 DUP1 0C02 80 DUP1 0C03 60 PUSH1 0x20 0C05 01 ADD 0C06 82 DUP3 0C07 81 DUP2 0C08 03 SUB 0C09 82 DUP3 0C0A 52 MSTORE 0C0B 60 PUSH1 0x38 0C0D 81 DUP2 0C0E 52 MSTORE 0C0F 60 PUSH1 0x20 0C11 01 ADD 0C12 80 DUP1 0C13 61 PUSH2 0x303d 0C16 60 PUSH1 0x38 0C18 91 SWAP2 0C19 39 CODECOPY 0C1A 60 PUSH1 0x40 0C1C 01 ADD 0C1D 91 SWAP2 0C1E 50 POP 0C1F 50 POP 0C20 60 PUSH1 0x40 0C22 51 MLOAD 0C23 80 DUP1 0C24 91 SWAP2 0C25 03 SUB 0C26 90 SWAP1 0C27 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0BFD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0C0A memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0C0E memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x38 // @0C19 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x38] = code[0x303d:0x3075] // @0C27 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0C28: // Incoming jump from 0x0BD7, if stack[-1] // Inputs[2] // { // @0C2C stack[-3] // @0C2D stack[-2] // } 0C28 5B JUMPDEST 0C29 61 PUSH2 0x0c32 0C2C 83 DUP4 0C2D 83 DUP4 0C2E 61 PUSH2 0x184c 0C31 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C29 stack[0] = 0x0c32 // @0C2C stack[1] = stack[-3] // @0C2D stack[2] = stack[-2] // } // Block ends with call to 0x184c, returns to 0x0C32 label_0C32: // Incoming return from call to 0x184C at 0x0C31 // Inputs[1] { @0C36 stack[-4] } 0C32 5B JUMPDEST 0C33 50 POP 0C34 50 POP 0C35 50 POP 0C36 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0C37: // Incoming call from 0x02DC, returns to 0x02DD 0C37 5B JUMPDEST 0C38 60 PUSH1 0x00 0C3A 61 PUSH2 0x0c43 0C3D 60 PUSH1 0x01 0C3F 61 PUSH2 0x1905 0C42 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C38 stack[0] = 0x00 // @0C3A stack[1] = 0x0c43 // @0C3D stack[2] = 0x01 // } // Block ends with call to 0x1905, returns to 0x0C43 label_0C43: // Incoming return from call to 0x1905 at 0x0C42 // Inputs[3] // { // @0C44 stack[-2] // @0C44 stack[-1] // @0C46 stack[-3] // } 0C43 5B JUMPDEST 0C44 90 SWAP1 0C45 50 POP 0C46 90 SWAP1 0C47 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C46 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_0C48: // Incoming jump from 0x035E 0C48 5B JUMPDEST 0C49 61 PUSH2 0x0c59 0C4C 61 PUSH2 0x0c53 0C4F 61 PUSH2 0x1844 0C52 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C49 stack[0] = 0x0c59 // @0C4C stack[1] = 0x0c53 // } // Block ends with call to 0x1844, returns to 0x0C53 label_0C53: // Incoming return from call to 0x1844 at 0x0C52 // Inputs[1] { @0C54 stack[-3] } 0C53 5B JUMPDEST 0C54 82 DUP3 0C55 61 PUSH2 0x1913 0C58 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C54 stack[0] = stack[-3] } // Block ends with unconditional jump to 0x1913 label_0C59: // Incoming return from call to 0x0C53 at 0x0C52 // Inputs[1] { @0C5D stack[-1] } 0C59 5B JUMPDEST 0C5A 61 PUSH2 0x0cae 0C5D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0cae, if stack[-1] label_0C5E: // Incoming jump from 0x0C5D, if not stack[-1] // Inputs[3] // { // @0C60 memory[0x40:0x60] // @0CA8 memory[0x40:0x60] // @0CAD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - 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 80 DUP1 0C88 80 DUP1 0C89 60 PUSH1 0x20 0C8B 01 ADD 0C8C 82 DUP3 0C8D 81 DUP2 0C8E 03 SUB 0C8F 82 DUP3 0C90 52 MSTORE 0C91 60 PUSH1 0x31 0C93 81 DUP2 0C94 52 MSTORE 0C95 60 PUSH1 0x20 0C97 01 ADD 0C98 80 DUP1 0C99 61 PUSH2 0x3144 0C9C 60 PUSH1 0x31 0C9E 91 SWAP2 0C9F 39 CODECOPY 0CA0 60 PUSH1 0x40 0CA2 01 ADD 0CA3 91 SWAP2 0CA4 50 POP 0CA5 50 POP 0CA6 60 PUSH1 0x40 0CA8 51 MLOAD 0CA9 80 DUP1 0CAA 91 SWAP2 0CAB 03 SUB 0CAC 90 SWAP1 0CAD FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0C83 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0C90 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0C94 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x31 // @0C9F memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x31] = code[0x3144:0x3175] // @0CAD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0CAE: // Incoming jump from 0x0C5D, if stack[-1] // Inputs[3] // { // @0CB2 stack[-3] // @0CB3 stack[-2] // @0CB4 stack[-1] // } 0CAE 5B JUMPDEST 0CAF 61 PUSH2 0x0cb9 0CB2 83 DUP4 0CB3 83 DUP4 0CB4 83 DUP4 0CB5 61 PUSH2 0x1a07 0CB8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0CAF stack[0] = 0x0cb9 // @0CB2 stack[1] = stack[-3] // @0CB3 stack[2] = stack[-2] // @0CB4 stack[3] = stack[-1] // } // Block ends with call to 0x1a07, returns to 0x0CB9 label_0CB9: // Incoming return from call to 0x1A07 at 0x0CB8 // Inputs[1] { @0CBD stack[-4] } 0CB9 5B JUMPDEST 0CBA 50 POP 0CBB 50 POP 0CBC 50 POP 0CBD 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0CBE: // Incoming jump from 0x03AC // Inputs[2] // { // @0CC4 stack[-2] // @0CC5 stack[-1] // } 0CBE 5B JUMPDEST 0CBF 60 PUSH1 0x00 0CC1 61 PUSH2 0x0cd6 0CC4 83 DUP4 0CC5 83 DUP4 0CC6 60 PUSH1 0x01 0CC8 61 PUSH2 0x1ba6 0CCB 90 SWAP1 0CCC 92 SWAP3 0CCD 91 SWAP2 0CCE 90 SWAP1 0CCF 63 PUSH4 0xffffffff 0CD4 16 AND 0CD5 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0CBF stack[0] = 0x00 // @0CC1 stack[1] = 0x0cd6 // @0CCC stack[2] = 0x01 // @0CCD stack[3] = stack[-2] // @0CCE stack[4] = stack[-1] // } // Block ends with call to 0xffffffff & 0x1ba6, returns to 0x0CD6 label_0CD6: // Incoming return from call to 0x1BA6 at 0x0CD5 // Inputs[4] // { // @0CD7 stack[-2] // @0CD7 stack[-1] // @0CD9 stack[-5] // @0CDA stack[-4] // } 0CD6 5B JUMPDEST 0CD7 90 SWAP1 0CD8 50 POP 0CD9 92 SWAP3 0CDA 91 SWAP2 0CDB 50 POP 0CDC 50 POP 0CDD 56 *JUMP // Stack delta = -4 // Outputs[1] { @0CD9 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0CDE: // Incoming jump from 0x042E // Inputs[4] // { // @0CE2 stack[-3] // @0CE3 stack[-2] // @0CE4 stack[-1] // @0CE7 memory[0x40:0x60] // } 0CDE 5B JUMPDEST 0CDF 61 PUSH2 0x0cf9 0CE2 83 DUP4 0CE3 83 DUP4 0CE4 83 DUP4 0CE5 60 PUSH1 0x40 0CE7 51 MLOAD 0CE8 80 DUP1 0CE9 60 PUSH1 0x20 0CEB 01 ADD 0CEC 60 PUSH1 0x40 0CEE 52 MSTORE 0CEF 80 DUP1 0CF0 60 PUSH1 0x00 0CF2 81 DUP2 0CF3 52 MSTORE 0CF4 50 POP 0CF5 61 PUSH2 0x125d 0CF8 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0CDF stack[0] = 0x0cf9 // @0CE2 stack[1] = stack[-3] // @0CE3 stack[2] = stack[-2] // @0CE4 stack[3] = stack[-1] // @0CE7 stack[4] = memory[0x40:0x60] // @0CEE memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0CF3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x125d, returns to 0x0CF9 label_0CF9: // Incoming return from call to 0x125D at 0x0CF8 // Inputs[1] { @0CFD stack[-4] } 0CF9 5B JUMPDEST 0CFA 50 POP 0CFB 50 POP 0CFC 50 POP 0CFD 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0CFE: // Incoming jump from 0x045C // Inputs[2] // { // @0D01 stack[-1] // @0D04 stack[-2] // } 0CFE 5B JUMPDEST 0CFF 60 PUSH1 0x00 0D01 81 DUP2 0D02 90 SWAP1 0D03 50 POP 0D04 91 SWAP2 0D05 90 SWAP1 0D06 50 POP 0D07 56 *JUMP // Stack delta = -1 // Outputs[1] { @0D04 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0D08: // Incoming call from 0x197D, returns to 0x197E // Incoming jump from 0x049E // Incoming call from 0x1A26, returns to 0x1A27 // Incoming call from 0x0AFD, returns to 0x0AFE // Incoming call from 0x18BE, returns to 0x18BF // Inputs[1] { @0D0E stack[-1] } 0D08 5B JUMPDEST 0D09 60 PUSH1 0x00 0D0B 61 PUSH2 0x0d1e 0D0E 82 DUP3 0D0F 60 PUSH1 0x01 0D11 61 PUSH2 0x1d69 0D14 90 SWAP1 0D15 91 SWAP2 0D16 90 SWAP1 0D17 63 PUSH4 0xffffffff 0D1C 16 AND 0D1D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D09 stack[0] = 0x00 // @0D0B stack[1] = 0x0d1e // @0D15 stack[2] = 0x01 // @0D16 stack[3] = stack[-1] // } // Block ends with call to 0xffffffff & 0x1d69, returns to 0x0D1E label_0D1E: // Incoming return from call to 0x1D69 at 0x0D1D // Incoming return from call to 0x1D69 at 0x0D1D // Inputs[4] // { // @0D1F stack[-2] // @0D1F stack[-1] // @0D21 stack[-4] // @0D22 stack[-3] // } 0D1E 5B JUMPDEST 0D1F 90 SWAP1 0D20 50 POP 0D21 91 SWAP2 0D22 90 SWAP1 0D23 50 POP 0D24 56 *JUMP // Stack delta = -3 // Outputs[1] { @0D21 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0D25: // Incoming call from 0x04E8, returns to 0x04E9 // Incoming call from 0x13EE, returns to 0x13EF // Inputs[3] // { // @0D2B storage[0x0d] // @0D4C memory[0x40:0x60] // @0D5F storage[0x0d] // } 0D25 5B JUMPDEST 0D26 60 PUSH1 0x60 0D28 60 PUSH1 0x0d 0D2A 80 DUP1 0D2B 54 SLOAD 0D2C 60 PUSH1 0x01 0D2E 81 DUP2 0D2F 60 PUSH1 0x01 0D31 16 AND 0D32 15 ISZERO 0D33 61 PUSH2 0x0100 0D36 02 MUL 0D37 03 SUB 0D38 16 AND 0D39 60 PUSH1 0x02 0D3B 90 SWAP1 0D3C 04 DIV 0D3D 80 DUP1 0D3E 60 PUSH1 0x1f 0D40 01 ADD 0D41 60 PUSH1 0x20 0D43 80 DUP1 0D44 91 SWAP2 0D45 04 DIV 0D46 02 MUL 0D47 60 PUSH1 0x20 0D49 01 ADD 0D4A 60 PUSH1 0x40 0D4C 51 MLOAD 0D4D 90 SWAP1 0D4E 81 DUP2 0D4F 01 ADD 0D50 60 PUSH1 0x40 0D52 52 MSTORE 0D53 80 DUP1 0D54 92 SWAP3 0D55 91 SWAP2 0D56 90 SWAP1 0D57 81 DUP2 0D58 81 DUP2 0D59 52 MSTORE 0D5A 60 PUSH1 0x20 0D5C 01 ADD 0D5D 82 DUP3 0D5E 80 DUP1 0D5F 54 SLOAD 0D60 60 PUSH1 0x01 0D62 81 DUP2 0D63 60 PUSH1 0x01 0D65 16 AND 0D66 15 ISZERO 0D67 61 PUSH2 0x0100 0D6A 02 MUL 0D6B 03 SUB 0D6C 16 AND 0D6D 60 PUSH1 0x02 0D6F 90 SWAP1 0D70 04 DIV 0D71 80 DUP1 0D72 15 ISZERO 0D73 61 PUSH2 0x0dbd 0D76 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @0D26 stack[0] = 0x60 // @0D52 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x0d]) - 0x01 & storage[0x0d]) / 0x02) / 0x20 * 0x20 // @0D54 stack[1] = memory[0x40:0x60] // @0D55 stack[2] = 0x0d // @0D56 stack[3] = (0x0100 * !(0x01 & storage[0x0d]) - 0x01 & storage[0x0d]) / 0x02 // @0D59 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x0d]) - 0x01 & storage[0x0d]) / 0x02 // @0D5C stack[4] = 0x20 + memory[0x40:0x60] // @0D5D stack[5] = 0x0d // @0D70 stack[6] = (0x0100 * !(0x01 & storage[0x0d]) - 0x01 & storage[0x0d]) / 0x02 // } // Block ends with conditional jump to 0x0dbd, if !((0x0100 * !(0x01 & storage[0x0d]) - 0x01 & storage[0x0d]) / 0x02) label_0D77: // Incoming jump from 0x0D76, if not !((0x0100 * !(0x01 & storage[0x0d]) - 0x01 & storage[0x0d]) / 0x02) // Inputs[1] { @0D77 stack[-1] } 0D77 80 DUP1 0D78 60 PUSH1 0x1f 0D7A 10 LT 0D7B 61 PUSH2 0x0d92 0D7E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d92, if 0x1f < stack[-1] label_0D7F: // Incoming jump from 0x0D7E, if not 0x1f < stack[-1] // Inputs[4] // { // @0D83 stack[-2] // @0D84 storage[stack[-2]] // @0D87 stack[-3] // @0D89 stack[-1] // } 0D7F 61 PUSH2 0x0100 0D82 80 DUP1 0D83 83 DUP4 0D84 54 SLOAD 0D85 04 DIV 0D86 02 MUL 0D87 83 DUP4 0D88 52 MSTORE 0D89 91 SWAP2 0D8A 60 PUSH1 0x20 0D8C 01 ADD 0D8D 91 SWAP2 0D8E 61 PUSH2 0x0dbd 0D91 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0D88 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0D8D stack[-1] = stack[-1] // @0D8D stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0dbd label_0D92: // Incoming jump from 0x0D7E, if 0x1f < stack[-1] // Inputs[5] // { // @0D93 stack[-3] // @0D94 stack[-1] // @0D96 stack[-2] // @0D9E memory[0x00:0x20] // @0DA2 storage[keccak256(memory[0x00:0x20])] // } 0D92 5B JUMPDEST 0D93 82 DUP3 0D94 01 ADD 0D95 91 SWAP2 0D96 90 SWAP1 0D97 60 PUSH1 0x00 0D99 52 MSTORE 0D9A 60 PUSH1 0x20 0D9C 60 PUSH1 0x00 0D9E 20 SHA3 0D9F 90 SWAP1 0DA0 5B JUMPDEST 0DA1 81 DUP2 0DA2 54 SLOAD 0DA3 81 DUP2 0DA4 52 MSTORE 0DA5 90 SWAP1 0DA6 60 PUSH1 0x01 0DA8 01 ADD 0DA9 90 SWAP1 0DAA 60 PUSH1 0x20 0DAC 01 ADD 0DAD 80 DUP1 0DAE 83 DUP4 0DAF 11 GT 0DB0 61 PUSH2 0x0da0 0DB3 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0D95 stack[-3] = stack[-3] + stack[-1] // @0D99 memory[0x00:0x20] = stack[-2] // @0DA4 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0DA9 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0DAC stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0da0, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0DB4: // Incoming jump from 0x0DB3, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0DB3, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0DB4 stack[-3] // @0DB5 stack[-1] // } 0DB4 82 DUP3 0DB5 90 SWAP1 0DB6 03 SUB 0DB7 60 PUSH1 0x1f 0DB9 16 AND 0DBA 82 DUP3 0DBB 01 ADD 0DBC 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0DBC stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0DBC stack[-1] = stack[-3] // } // Block continues label_0DBD: // Incoming jump from 0x0D76, if !((0x0100 * !(0x01 & storage[0x0d]) - 0x01 & storage[0x0d]) / 0x02) // Incoming jump from 0x0DBC // Incoming jump from 0x0D91 // Inputs[3] // { // @0DC3 stack[-6] // @0DC3 stack[-7] // @0DC5 stack[-8] // } 0DBD 5B JUMPDEST 0DBE 50 POP 0DBF 50 POP 0DC0 50 POP 0DC1 50 POP 0DC2 50 POP 0DC3 90 SWAP1 0DC4 50 POP 0DC5 90 SWAP1 0DC6 56 *JUMP // Stack delta = -7 // Outputs[1] { @0DC5 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0DC7: // Incoming jump from 0x05A5 // Inputs[1] { @0DE1 stack[-1] } 0DC7 5B JUMPDEST 0DC8 60 PUSH1 0x00 0DCA 80 DUP1 0DCB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DE0 16 AND 0DE1 82 DUP3 0DE2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DF7 16 AND 0DF8 14 EQ 0DF9 15 ISZERO 0DFA 61 PUSH2 0x0e4e 0DFD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0DC8 stack[0] = 0x00 } // Block ends with conditional jump to 0x0e4e, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0DFE: // Incoming jump from 0x0DFD, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @0E00 memory[0x40:0x60] // @0E48 memory[0x40:0x60] // @0E4D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0DFE 60 PUSH1 0x40 0E00 51 MLOAD 0E01 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0E22 81 DUP2 0E23 52 MSTORE 0E24 60 PUSH1 0x04 0E26 01 ADD 0E27 80 DUP1 0E28 80 DUP1 0E29 60 PUSH1 0x20 0E2B 01 ADD 0E2C 82 DUP3 0E2D 81 DUP2 0E2E 03 SUB 0E2F 82 DUP3 0E30 52 MSTORE 0E31 60 PUSH1 0x2a 0E33 81 DUP2 0E34 52 MSTORE 0E35 60 PUSH1 0x20 0E37 01 ADD 0E38 80 DUP1 0E39 61 PUSH2 0x3075 0E3C 60 PUSH1 0x2a 0E3E 91 SWAP2 0E3F 39 CODECOPY 0E40 60 PUSH1 0x40 0E42 01 ADD 0E43 91 SWAP2 0E44 50 POP 0E45 50 POP 0E46 60 PUSH1 0x40 0E48 51 MLOAD 0E49 80 DUP1 0E4A 91 SWAP2 0E4B 03 SUB 0E4C 90 SWAP1 0E4D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0E23 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0E30 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0E34 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2a // @0E3F memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2a] = code[0x3075:0x309f] // @0E4D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0E4E: // Incoming jump from 0x0DFD, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0E52 stack[-2] } 0E4E 5B JUMPDEST 0E4F 61 PUSH2 0x0e62 0E52 82 DUP3 0E53 60 PUSH1 0x01 0E55 61 PUSH2 0x1e6c 0E58 90 SWAP1 0E59 91 SWAP2 0E5A 90 SWAP1 0E5B 63 PUSH4 0xffffffff 0E60 16 AND 0E61 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E4F stack[0] = 0x0e62 // @0E59 stack[1] = 0x01 // @0E5A stack[2] = stack[-2] // } // Block ends with call to 0xffffffff & 0x1e6c, returns to 0x0E62 label_0E62: // Incoming return from call to 0x1E6C at 0x0E61 // Inputs[4] // { // @0E63 stack[-2] // @0E63 stack[-1] // @0E65 stack[-4] // @0E66 stack[-3] // } 0E62 5B JUMPDEST 0E63 90 SWAP1 0E64 50 POP 0E65 91 SWAP2 0E66 90 SWAP1 0E67 50 POP 0E68 56 *JUMP // Stack delta = -3 // Outputs[1] { @0E65 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0E69: // Incoming call from 0x05C3, returns to 0x05C4 0E69 5B JUMPDEST 0E6A 61 PUSH2 0x0e71 0E6D 61 PUSH2 0x1844 0E70 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E6A stack[0] = 0x0e71 } // Block ends with call to 0x1844, returns to 0x0E71 label_0E71: // Incoming return from call to 0x1844 at 0x0E70 // Inputs[1] { @0E87 stack[-1] } 0E71 5B JUMPDEST 0E72 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E87 16 AND 0E88 61 PUSH2 0x0e8f 0E8B 61 PUSH2 0x0fd9 0E8E 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0E87 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0E88 stack[0] = 0x0e8f // } // Block ends with call to 0x0fd9, returns to 0x0E8F label_0E8F: // Incoming return from call to 0x0FD9 at 0x0E8E // Inputs[2] // { // @0EA5 stack[-1] // @0EA6 stack[-2] // } 0E8F 5B JUMPDEST 0E90 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EA5 16 AND 0EA6 14 EQ 0EA7 61 PUSH2 0x0f18 0EAA 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0f18, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_0EAB: // Incoming jump from 0x0EAA, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[3] // { // @0EAD memory[0x40:0x60] // @0F12 memory[0x40:0x60] // @0F17 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0EAB 60 PUSH1 0x40 0EAD 51 MLOAD 0EAE 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0ECF 81 DUP2 0ED0 52 MSTORE 0ED1 60 PUSH1 0x04 0ED3 01 ADD 0ED4 80 DUP1 0ED5 80 DUP1 0ED6 60 PUSH1 0x20 0ED8 01 ADD 0ED9 82 DUP3 0EDA 81 DUP2 0EDB 03 SUB 0EDC 82 DUP3 0EDD 52 MSTORE 0EDE 60 PUSH1 0x20 0EE0 81 DUP2 0EE1 52 MSTORE 0EE2 60 PUSH1 0x20 0EE4 01 ADD 0EE5 80 DUP1 0EE6 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0F07 81 DUP2 0F08 52 MSTORE 0F09 50 POP 0F0A 60 PUSH1 0x20 0F0C 01 ADD 0F0D 91 SWAP2 0F0E 50 POP 0F0F 50 POP 0F10 60 PUSH1 0x40 0F12 51 MLOAD 0F13 80 DUP1 0F14 91 SWAP2 0F15 03 SUB 0F16 90 SWAP1 0F17 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0ED0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0EDD memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0EE1 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @0F08 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0F17 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0F18: // Incoming jump from 0x0EAA, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[6] // { // @0F36 storage[0x0e] // @0F8D memory[0x40:0x60] // @0F90 memory[0x40:0x60] // @0F95 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0FA1 storage[0x0e] // @0FD8 stack[-1] // } 0F18 5B JUMPDEST 0F19 60 PUSH1 0x00 0F1B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F30 16 AND 0F31 60 PUSH1 0x0e 0F33 60 PUSH1 0x00 0F35 90 SWAP1 0F36 54 SLOAD 0F37 90 SWAP1 0F38 61 PUSH2 0x0100 0F3B 0A EXP 0F3C 90 SWAP1 0F3D 04 DIV 0F3E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F53 16 AND 0F54 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F69 16 AND 0F6A 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 0F8B 60 PUSH1 0x40 0F8D 51 MLOAD 0F8E 60 PUSH1 0x40 0F90 51 MLOAD 0F91 80 DUP1 0F92 91 SWAP2 0F93 03 SUB 0F94 90 SWAP1 0F95 A3 LOG3 0F96 60 PUSH1 0x00 0F98 60 PUSH1 0x0e 0F9A 60 PUSH1 0x00 0F9C 61 PUSH2 0x0100 0F9F 0A EXP 0FA0 81 DUP2 0FA1 54 SLOAD 0FA2 81 DUP2 0FA3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FB8 02 MUL 0FB9 19 NOT 0FBA 16 AND 0FBB 90 SWAP1 0FBC 83 DUP4 0FBD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FD2 16 AND 0FD3 02 MUL 0FD4 17 OR 0FD5 90 SWAP1 0FD6 55 SSTORE 0FD7 50 POP 0FD8 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @0F95 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0e] & 0xffffffffffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffffffffffff & 0x00]); // @0FD6 storage[0x0e] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x0e]) // } // Block ends with unconditional jump to stack[-1] label_0FD9: // Incoming call from 0x165F, returns to 0x1660 // Incoming call from 0x0E8E, returns to 0x0E8F // Incoming call from 0x05CD, returns to 0x05CE // Inputs[2] // { // @0FE1 storage[0x0e] // @1001 stack[-1] // } 0FD9 5B JUMPDEST 0FDA 60 PUSH1 0x00 0FDC 60 PUSH1 0x0e 0FDE 60 PUSH1 0x00 0FE0 90 SWAP1 0FE1 54 SLOAD 0FE2 90 SWAP1 0FE3 61 PUSH2 0x0100 0FE6 0A EXP 0FE7 90 SWAP1 0FE8 04 DIV 0FE9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FFE 16 AND 0FFF 90 SWAP1 1000 50 POP 1001 90 SWAP1 1002 56 *JUMP // Stack delta = +0 // Outputs[1] { @1001 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0e] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_1003: // Incoming call from 0x0617, returns to 0x0618 // Inputs[3] // { // @1009 storage[0x0b] // @102A memory[0x40:0x60] // @103D storage[0x0b] // } 1003 5B JUMPDEST 1004 60 PUSH1 0x60 1006 60 PUSH1 0x0b 1008 80 DUP1 1009 54 SLOAD 100A 60 PUSH1 0x01 100C 81 DUP2 100D 60 PUSH1 0x01 100F 16 AND 1010 15 ISZERO 1011 61 PUSH2 0x0100 1014 02 MUL 1015 03 SUB 1016 16 AND 1017 60 PUSH1 0x02 1019 90 SWAP1 101A 04 DIV 101B 80 DUP1 101C 60 PUSH1 0x1f 101E 01 ADD 101F 60 PUSH1 0x20 1021 80 DUP1 1022 91 SWAP2 1023 04 DIV 1024 02 MUL 1025 60 PUSH1 0x20 1027 01 ADD 1028 60 PUSH1 0x40 102A 51 MLOAD 102B 90 SWAP1 102C 81 DUP2 102D 01 ADD 102E 60 PUSH1 0x40 1030 52 MSTORE 1031 80 DUP1 1032 92 SWAP3 1033 91 SWAP2 1034 90 SWAP1 1035 81 DUP2 1036 81 DUP2 1037 52 MSTORE 1038 60 PUSH1 0x20 103A 01 ADD 103B 82 DUP3 103C 80 DUP1 103D 54 SLOAD 103E 60 PUSH1 0x01 1040 81 DUP2 1041 60 PUSH1 0x01 1043 16 AND 1044 15 ISZERO 1045 61 PUSH2 0x0100 1048 02 MUL 1049 03 SUB 104A 16 AND 104B 60 PUSH1 0x02 104D 90 SWAP1 104E 04 DIV 104F 80 DUP1 1050 15 ISZERO 1051 61 PUSH2 0x109b 1054 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @1004 stack[0] = 0x60 // @1030 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02) / 0x20 * 0x20 // @1032 stack[1] = memory[0x40:0x60] // @1033 stack[2] = 0x0b // @1034 stack[3] = (0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02 // @1037 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02 // @103A stack[4] = 0x20 + memory[0x40:0x60] // @103B stack[5] = 0x0b // @104E stack[6] = (0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02 // } // Block ends with conditional jump to 0x109b, if !((0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02) label_1055: // Incoming jump from 0x1054, if not !((0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02) // Inputs[1] { @1055 stack[-1] } 1055 80 DUP1 1056 60 PUSH1 0x1f 1058 10 LT 1059 61 PUSH2 0x1070 105C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1070, if 0x1f < stack[-1] label_105D: // Incoming jump from 0x105C, if not 0x1f < stack[-1] // Inputs[4] // { // @1061 stack[-2] // @1062 storage[stack[-2]] // @1065 stack[-3] // @1067 stack[-1] // } 105D 61 PUSH2 0x0100 1060 80 DUP1 1061 83 DUP4 1062 54 SLOAD 1063 04 DIV 1064 02 MUL 1065 83 DUP4 1066 52 MSTORE 1067 91 SWAP2 1068 60 PUSH1 0x20 106A 01 ADD 106B 91 SWAP2 106C 61 PUSH2 0x109b 106F 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1066 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @106B stack[-1] = stack[-1] // @106B stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x109b label_1070: // Incoming jump from 0x105C, if 0x1f < stack[-1] // Inputs[5] // { // @1071 stack[-3] // @1072 stack[-1] // @1074 stack[-2] // @107C memory[0x00:0x20] // @1080 storage[keccak256(memory[0x00:0x20])] // } 1070 5B JUMPDEST 1071 82 DUP3 1072 01 ADD 1073 91 SWAP2 1074 90 SWAP1 1075 60 PUSH1 0x00 1077 52 MSTORE 1078 60 PUSH1 0x20 107A 60 PUSH1 0x00 107C 20 SHA3 107D 90 SWAP1 107E 5B JUMPDEST 107F 81 DUP2 1080 54 SLOAD 1081 81 DUP2 1082 52 MSTORE 1083 90 SWAP1 1084 60 PUSH1 0x01 1086 01 ADD 1087 90 SWAP1 1088 60 PUSH1 0x20 108A 01 ADD 108B 80 DUP1 108C 83 DUP4 108D 11 GT 108E 61 PUSH2 0x107e 1091 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1073 stack[-3] = stack[-3] + stack[-1] // @1077 memory[0x00:0x20] = stack[-2] // @1082 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1087 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @108A stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x107e, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1092: // Incoming jump from 0x1091, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x1091, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @1092 stack[-3] // @1093 stack[-1] // } 1092 82 DUP3 1093 90 SWAP1 1094 03 SUB 1095 60 PUSH1 0x1f 1097 16 AND 1098 82 DUP3 1099 01 ADD 109A 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @109A stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @109A stack[-1] = stack[-3] // } // Block continues label_109B: // Incoming jump from 0x1054, if !((0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02) // Incoming jump from 0x106F // Incoming jump from 0x109A // Inputs[3] // { // @10A1 stack[-7] // @10A1 stack[-6] // @10A3 stack[-8] // } 109B 5B JUMPDEST 109C 50 POP 109D 50 POP 109E 50 POP 109F 50 POP 10A0 50 POP 10A1 90 SWAP1 10A2 50 POP 10A3 90 SWAP1 10A4 56 *JUMP // Stack delta = -7 // Outputs[1] { @10A3 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_10A5: // Incoming jump from 0x06E0 10A5 5B JUMPDEST 10A6 61 PUSH2 0x10ad 10A9 61 PUSH2 0x1844 10AC 56 *JUMP // Stack delta = +1 // Outputs[1] { @10A6 stack[0] = 0x10ad } // Block ends with call to 0x1844, returns to 0x10AD label_10AD: // Incoming return from call to 0x1844 at 0x10AC // Inputs[2] // { // @10C3 stack[-1] // @10C4 stack[-3] // } 10AD 5B JUMPDEST 10AE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10C3 16 AND 10C4 82 DUP3 10C5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10DA 16 AND 10DB 14 EQ 10DC 15 ISZERO 10DD 61 PUSH2 0x114e 10E0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x114e, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_10E1: // Incoming jump from 0x10E0, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[3] // { // @10E3 memory[0x40:0x60] // @1148 memory[0x40:0x60] // @114D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 10E1 60 PUSH1 0x40 10E3 51 MLOAD 10E4 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1105 81 DUP2 1106 52 MSTORE 1107 60 PUSH1 0x04 1109 01 ADD 110A 80 DUP1 110B 80 DUP1 110C 60 PUSH1 0x20 110E 01 ADD 110F 82 DUP3 1110 81 DUP2 1111 03 SUB 1112 82 DUP3 1113 52 MSTORE 1114 60 PUSH1 0x19 1116 81 DUP2 1117 52 MSTORE 1118 60 PUSH1 0x20 111A 01 ADD 111B 80 DUP1 111C 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 113D 81 DUP2 113E 52 MSTORE 113F 50 POP 1140 60 PUSH1 0x20 1142 01 ADD 1143 91 SWAP2 1144 50 POP 1145 50 POP 1146 60 PUSH1 0x40 1148 51 MLOAD 1149 80 DUP1 114A 91 SWAP2 114B 03 SUB 114C 90 SWAP1 114D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1106 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1113 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1117 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x19 // @113E memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 // @114D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_114E: // Incoming jump from 0x10E0, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @114F stack[-1] } 114E 5B JUMPDEST 114F 80 DUP1 1150 60 PUSH1 0x09 1152 60 PUSH1 0x00 1154 61 PUSH2 0x115b 1157 61 PUSH2 0x1844 115A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @114F stack[0] = stack[-1] // @1150 stack[1] = 0x09 // @1152 stack[2] = 0x00 // @1154 stack[3] = 0x115b // } // Block ends with call to 0x1844, returns to 0x115B label_115B: // Incoming return from call to 0x1844 at 0x115A // Inputs[8] // { // @1171 stack[-1] // @1188 stack[-2] // @118D stack[-3] // @1195 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @1198 stack[-6] // @11D2 memory[0x00:0x40] // @11DA storage[keccak256(memory[0x00:0x40])] // @11E2 stack[-4] // } 115B 5B JUMPDEST 115C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1171 16 AND 1172 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1187 16 AND 1188 81 DUP2 1189 52 MSTORE 118A 60 PUSH1 0x20 118C 01 ADD 118D 90 SWAP1 118E 81 DUP2 118F 52 MSTORE 1190 60 PUSH1 0x20 1192 01 ADD 1193 60 PUSH1 0x00 1195 20 SHA3 1196 60 PUSH1 0x00 1198 84 DUP5 1199 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11AE 16 AND 11AF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11C4 16 AND 11C5 81 DUP2 11C6 52 MSTORE 11C7 60 PUSH1 0x20 11C9 01 ADD 11CA 90 SWAP1 11CB 81 DUP2 11CC 52 MSTORE 11CD 60 PUSH1 0x20 11CF 01 ADD 11D0 60 PUSH1 0x00 11D2 20 SHA3 11D3 60 PUSH1 0x00 11D5 61 PUSH2 0x0100 11D8 0A EXP 11D9 81 DUP2 11DA 54 SLOAD 11DB 81 DUP2 11DC 60 PUSH1 0xff 11DE 02 MUL 11DF 19 NOT 11E0 16 AND 11E1 90 SWAP1 11E2 83 DUP4 11E3 15 ISZERO 11E4 15 ISZERO 11E5 02 MUL 11E6 17 OR 11E7 90 SWAP1 11E8 55 SSTORE 11E9 50 POP 11EA 81 DUP2 11EB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1200 16 AND 1201 61 PUSH2 0x1208 1204 61 PUSH2 0x1844 1207 56 *JUMP // Stack delta = -2 // Outputs[7] // { // @1189 memory[stack[-2]:stack[-2] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @118F memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @11C6 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @11CC memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]]) // @11E8 storage[keccak256(memory[0x00:0x40])] = !!stack[-4] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @1200 stack[-4] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @1201 stack[-3] = 0x1208 // } // Block ends with call to 0x1844, returns to 0x1208 label_1208: // Incoming return from call to 0x1844 at 0x1207 // Inputs[7] // { // @121E stack[-1] // @1240 stack[-3] // @1243 memory[0x40:0x60] // @1254 memory[0x40:0x60] // @1259 stack[-2] // @1259 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @125C stack[-5] // } 1208 5B JUMPDEST 1209 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 121E 16 AND 121F 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1240 83 DUP4 1241 60 PUSH1 0x40 1243 51 MLOAD 1244 80 DUP1 1245 82 DUP3 1246 15 ISZERO 1247 15 ISZERO 1248 15 ISZERO 1249 15 ISZERO 124A 81 DUP2 124B 52 MSTORE 124C 60 PUSH1 0x20 124E 01 ADD 124F 91 SWAP2 1250 50 POP 1251 50 POP 1252 60 PUSH1 0x40 1254 51 MLOAD 1255 80 DUP1 1256 91 SWAP2 1257 03 SUB 1258 90 SWAP1 1259 A3 LOG3 125A 50 POP 125B 50 POP 125C 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @124B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-3] // @1259 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2]]); // } // Block ends with unconditional jump to stack[-5] label_125D: // Incoming jump from 0x07E5 // Incoming call from 0x0CF8, returns to 0x0CF9 125D 5B JUMPDEST 125E 61 PUSH2 0x126e 1261 61 PUSH2 0x1268 1264 61 PUSH2 0x1844 1267 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @125E stack[0] = 0x126e // @1261 stack[1] = 0x1268 // } // Block ends with call to 0x1844, returns to 0x1268 label_1268: // Incoming return from call to 0x1844 at 0x1267 // Inputs[1] { @1269 stack[-4] } 1268 5B JUMPDEST 1269 83 DUP4 126A 61 PUSH2 0x1913 126D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1269 stack[0] = stack[-4] } // Block ends with unconditional jump to 0x1913 label_126E: // Incoming return from call to 0x1268 at 0x1267 // Inputs[1] { @1272 stack[-1] } 126E 5B JUMPDEST 126F 61 PUSH2 0x12c3 1272 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x12c3, if stack[-1] label_1273: // Incoming jump from 0x1272, if not stack[-1] // Inputs[3] // { // @1275 memory[0x40:0x60] // @12BD memory[0x40:0x60] // @12C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1273 60 PUSH1 0x40 1275 51 MLOAD 1276 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1297 81 DUP2 1298 52 MSTORE 1299 60 PUSH1 0x04 129B 01 ADD 129C 80 DUP1 129D 80 DUP1 129E 60 PUSH1 0x20 12A0 01 ADD 12A1 82 DUP3 12A2 81 DUP2 12A3 03 SUB 12A4 82 DUP3 12A5 52 MSTORE 12A6 60 PUSH1 0x31 12A8 81 DUP2 12A9 52 MSTORE 12AA 60 PUSH1 0x20 12AC 01 ADD 12AD 80 DUP1 12AE 61 PUSH2 0x3144 12B1 60 PUSH1 0x31 12B3 91 SWAP2 12B4 39 CODECOPY 12B5 60 PUSH1 0x40 12B7 01 ADD 12B8 91 SWAP2 12B9 50 POP 12BA 50 POP 12BB 60 PUSH1 0x40 12BD 51 MLOAD 12BE 80 DUP1 12BF 91 SWAP2 12C0 03 SUB 12C1 90 SWAP1 12C2 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1298 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @12A5 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @12A9 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x31 // @12B4 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x31] = code[0x3144:0x3175] // @12C2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_12C3: // Incoming jump from 0x1272, if stack[-1] // Inputs[4] // { // @12C7 stack[-4] // @12C8 stack[-3] // @12C9 stack[-2] // @12CA stack[-1] // } 12C3 5B JUMPDEST 12C4 61 PUSH2 0x12cf 12C7 84 DUP5 12C8 84 DUP5 12C9 84 DUP5 12CA 84 DUP5 12CB 61 PUSH2 0x1f5b 12CE 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @12C4 stack[0] = 0x12cf // @12C7 stack[1] = stack[-4] // @12C8 stack[2] = stack[-3] // @12C9 stack[3] = stack[-2] // @12CA stack[4] = stack[-1] // } // Block ends with call to 0x1f5b, returns to 0x12CF label_12CF: // Incoming return from call to 0x1F5B at 0x12CE // Inputs[1] { @12D4 stack[-5] } 12CF 5B JUMPDEST 12D0 50 POP 12D1 50 POP 12D2 50 POP 12D3 50 POP 12D4 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_12D5: // Incoming jump from 0x0813 // Inputs[1] { @12DB stack[-1] } 12D5 5B JUMPDEST 12D6 60 PUSH1 0x60 12D8 61 PUSH2 0x12e0 12DB 82 DUP3 12DC 61 PUSH2 0x182f 12DF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @12D6 stack[0] = 0x60 // @12D8 stack[1] = 0x12e0 // @12DB stack[2] = stack[-1] // } // Block ends with call to 0x182f, returns to 0x12E0 label_12E0: // Incoming return from call to 0x182F at 0x12DF // Inputs[1] { @12E4 stack[-1] } 12E0 5B JUMPDEST 12E1 61 PUSH2 0x1335 12E4 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1335, if stack[-1] label_12E5: // Incoming jump from 0x12E4, if not stack[-1] // Inputs[3] // { // @12E7 memory[0x40:0x60] // @132F memory[0x40:0x60] // @1334 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 12E5 60 PUSH1 0x40 12E7 51 MLOAD 12E8 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1309 81 DUP2 130A 52 MSTORE 130B 60 PUSH1 0x04 130D 01 ADD 130E 80 DUP1 130F 80 DUP1 1310 60 PUSH1 0x20 1312 01 ADD 1313 82 DUP3 1314 81 DUP2 1315 03 SUB 1316 82 DUP3 1317 52 MSTORE 1318 60 PUSH1 0x2f 131A 81 DUP2 131B 52 MSTORE 131C 60 PUSH1 0x20 131E 01 ADD 131F 80 DUP1 1320 61 PUSH2 0x30f4 1323 60 PUSH1 0x2f 1325 91 SWAP2 1326 39 CODECOPY 1327 60 PUSH1 0x40 1329 01 ADD 132A 91 SWAP2 132B 50 POP 132C 50 POP 132D 60 PUSH1 0x40 132F 51 MLOAD 1330 80 DUP1 1331 91 SWAP2 1332 03 SUB 1333 90 SWAP1 1334 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @130A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1317 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @131B memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2f // @1326 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2f] = code[0x30f4:0x3123] // @1334 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1335: // Incoming jump from 0x12E4, if stack[-1] // Inputs[5] // { // @133C stack[-2] // @134A memory[0x00:0x40] // @134C storage[keccak256(memory[0x00:0x40])] // @136D memory[0x40:0x60] // @1380 storage[keccak256(memory[0x00:0x40])] // } 1335 5B JUMPDEST 1336 60 PUSH1 0x60 1338 60 PUSH1 0x0c 133A 60 PUSH1 0x00 133C 84 DUP5 133D 81 DUP2 133E 52 MSTORE 133F 60 PUSH1 0x20 1341 01 ADD 1342 90 SWAP1 1343 81 DUP2 1344 52 MSTORE 1345 60 PUSH1 0x20 1347 01 ADD 1348 60 PUSH1 0x00 134A 20 SHA3 134B 80 DUP1 134C 54 SLOAD 134D 60 PUSH1 0x01 134F 81 DUP2 1350 60 PUSH1 0x01 1352 16 AND 1353 15 ISZERO 1354 61 PUSH2 0x0100 1357 02 MUL 1358 03 SUB 1359 16 AND 135A 60 PUSH1 0x02 135C 90 SWAP1 135D 04 DIV 135E 80 DUP1 135F 60 PUSH1 0x1f 1361 01 ADD 1362 60 PUSH1 0x20 1364 80 DUP1 1365 91 SWAP2 1366 04 DIV 1367 02 MUL 1368 60 PUSH1 0x20 136A 01 ADD 136B 60 PUSH1 0x40 136D 51 MLOAD 136E 90 SWAP1 136F 81 DUP2 1370 01 ADD 1371 60 PUSH1 0x40 1373 52 MSTORE 1374 80 DUP1 1375 92 SWAP3 1376 91 SWAP2 1377 90 SWAP1 1378 81 DUP2 1379 81 DUP2 137A 52 MSTORE 137B 60 PUSH1 0x20 137D 01 ADD 137E 82 DUP3 137F 80 DUP1 1380 54 SLOAD 1381 60 PUSH1 0x01 1383 81 DUP2 1384 60 PUSH1 0x01 1386 16 AND 1387 15 ISZERO 1388 61 PUSH2 0x0100 138B 02 MUL 138C 03 SUB 138D 16 AND 138E 60 PUSH1 0x02 1390 90 SWAP1 1391 04 DIV 1392 80 DUP1 1393 15 ISZERO 1394 61 PUSH2 0x13de 1397 57 *JUMPI // Stack delta = +7 // Outputs[11] // { // @1336 stack[0] = 0x60 // @133E memory[0x00:0x20] = stack[-2] // @1344 memory[0x20:0x40] = 0x0c // @1373 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) / 0x20 * 0x20 // @1375 stack[1] = memory[0x40:0x60] // @1376 stack[2] = keccak256(memory[0x00:0x40]) // @1377 stack[3] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @137A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @137D stack[4] = 0x20 + memory[0x40:0x60] // @137E stack[5] = keccak256(memory[0x00:0x40]) // @1391 stack[6] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // } // Block ends with conditional jump to 0x13de, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) label_1398: // Incoming jump from 0x1397, if not !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[1] { @1398 stack[-1] } 1398 80 DUP1 1399 60 PUSH1 0x1f 139B 10 LT 139C 61 PUSH2 0x13b3 139F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13b3, if 0x1f < stack[-1] label_13A0: // Incoming jump from 0x139F, if not 0x1f < stack[-1] // Inputs[4] // { // @13A4 stack[-2] // @13A5 storage[stack[-2]] // @13A8 stack[-3] // @13AA stack[-1] // } 13A0 61 PUSH2 0x0100 13A3 80 DUP1 13A4 83 DUP4 13A5 54 SLOAD 13A6 04 DIV 13A7 02 MUL 13A8 83 DUP4 13A9 52 MSTORE 13AA 91 SWAP2 13AB 60 PUSH1 0x20 13AD 01 ADD 13AE 91 SWAP2 13AF 61 PUSH2 0x13de 13B2 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @13A9 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @13AE stack[-1] = stack[-1] // @13AE stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x13de label_13B3: // Incoming jump from 0x139F, if 0x1f < stack[-1] // Inputs[5] // { // @13B4 stack[-3] // @13B5 stack[-1] // @13B7 stack[-2] // @13BF memory[0x00:0x20] // @13C3 storage[keccak256(memory[0x00:0x20])] // } 13B3 5B JUMPDEST 13B4 82 DUP3 13B5 01 ADD 13B6 91 SWAP2 13B7 90 SWAP1 13B8 60 PUSH1 0x00 13BA 52 MSTORE 13BB 60 PUSH1 0x20 13BD 60 PUSH1 0x00 13BF 20 SHA3 13C0 90 SWAP1 13C1 5B JUMPDEST 13C2 81 DUP2 13C3 54 SLOAD 13C4 81 DUP2 13C5 52 MSTORE 13C6 90 SWAP1 13C7 60 PUSH1 0x01 13C9 01 ADD 13CA 90 SWAP1 13CB 60 PUSH1 0x20 13CD 01 ADD 13CE 80 DUP1 13CF 83 DUP4 13D0 11 GT 13D1 61 PUSH2 0x13c1 13D4 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @13B6 stack[-3] = stack[-3] + stack[-1] // @13BA memory[0x00:0x20] = stack[-2] // @13C5 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @13CA stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @13CD stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x13c1, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_13D5: // Incoming jump from 0x13D4, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x13D4, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @13D5 stack[-3] // @13D6 stack[-1] // } 13D5 82 DUP3 13D6 90 SWAP1 13D7 03 SUB 13D8 60 PUSH1 0x1f 13DA 16 AND 13DB 82 DUP3 13DC 01 ADD 13DD 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @13DD stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @13DD stack[-1] = stack[-3] // } // Block continues label_13DE: // Incoming jump from 0x13DD // Incoming jump from 0x1397, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Incoming jump from 0x13B2 // Inputs[2] // { // @13E4 stack[-6] // @13E4 stack[-7] // } 13DE 5B JUMPDEST 13DF 50 POP 13E0 50 POP 13E1 50 POP 13E2 50 POP 13E3 50 POP 13E4 90 SWAP1 13E5 50 POP 13E6 60 PUSH1 0x60 13E8 61 PUSH2 0x13ef 13EB 61 PUSH2 0x0d25 13EE 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @13E4 stack[-7] = stack[-6] // @13E6 stack[-6] = 0x60 // @13E8 stack[-5] = 0x13ef // } // Block ends with call to 0x0d25, returns to 0x13EF label_13EF: // Incoming return from call to 0x0D25 at 0x13EE // Inputs[3] // { // @13F0 stack[-2] // @13F0 stack[-1] // @13F5 memory[stack[-1]:stack[-1] + 0x20] // } 13EF 5B JUMPDEST 13F0 90 SWAP1 13F1 50 POP 13F2 60 PUSH1 0x00 13F4 81 DUP2 13F5 51 MLOAD 13F6 14 EQ 13F7 15 ISZERO 13F8 61 PUSH2 0x1405 13FB 57 *JUMPI // Stack delta = -1 // Outputs[1] { @13F0 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1405, if !(memory[stack[-1]:stack[-1] + 0x20] == 0x00) label_13FC: // Incoming jump from 0x13FB, if not !(memory[stack[-1]:stack[-1] + 0x20] == 0x00) // Inputs[2] // { // @13FC stack[-2] // @13FD stack[-3] // } 13FC 81 DUP2 13FD 92 SWAP3 13FE 50 POP 13FF 50 POP 1400 50 POP 1401 61 PUSH2 0x15a1 1404 56 *JUMP // Stack delta = -2 // Outputs[1] { @13FD stack[-3] = stack[-2] } // Block ends with unconditional jump to 0x15a1 label_1405: // Incoming jump from 0x13FB, if !(memory[stack[-1]:stack[-1] + 0x20] == 0x00) // Inputs[2] // { // @1408 stack[-2] // @1409 memory[stack[-2]:stack[-2] + 0x20] // } 1405 5B JUMPDEST 1406 60 PUSH1 0x00 1408 82 DUP3 1409 51 MLOAD 140A 11 GT 140B 15 ISZERO 140C 61 PUSH2 0x14d6 140F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14d6, if !(memory[stack[-2]:stack[-2] + 0x20] > 0x00) label_1410: // Incoming jump from 0x140F, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0x00) // Inputs[4] // { // @1410 stack[-1] // @1411 stack[-2] // @1414 memory[0x40:0x60] // @141B memory[stack[-1]:stack[-1] + 0x20] // } 1410 80 DUP1 1411 82 DUP3 1412 60 PUSH1 0x40 1414 51 MLOAD 1415 60 PUSH1 0x20 1417 01 ADD 1418 80 DUP1 1419 83 DUP4 141A 80 DUP1 141B 51 MLOAD 141C 90 SWAP1 141D 60 PUSH1 0x20 141F 01 ADD 1420 90 SWAP1 1421 80 DUP1 1422 83 DUP4 1423 83 DUP4 1424 5B JUMPDEST 1425 60 PUSH1 0x20 1427 83 DUP4 1428 10 LT 1429 61 PUSH2 0x1447 142C 57 *JUMPI // Stack delta = +9 // Outputs[9] // { // @1410 stack[0] = stack[-1] // @1411 stack[1] = stack[-2] // @1417 stack[2] = 0x20 + memory[0x40:0x60] // @1418 stack[3] = 0x20 + memory[0x40:0x60] // @1420 stack[4] = 0x20 + stack[-1] // @1420 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @1421 stack[6] = memory[stack[-1]:stack[-1] + 0x20] // @1422 stack[7] = 0x20 + memory[0x40:0x60] // @1423 stack[8] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x1447, if memory[stack[-1]:stack[-1] + 0x20] < 0x20 label_142D: // Incoming jump from 0x142C, if not stack[-3] < 0x20 // Incoming jump from 0x142C, if not memory[stack[-1]:stack[-1] + 0x20] < 0x20 // Inputs[4] // { // @142D stack[-1] // @142E memory[stack[-1]:stack[-1] + 0x20] // @142F stack[-2] // @143F stack[-3] // } 142D 80 DUP1 142E 51 MLOAD 142F 82 DUP3 1430 52 MSTORE 1431 60 PUSH1 0x20 1433 82 DUP3 1434 01 ADD 1435 91 SWAP2 1436 50 POP 1437 60 PUSH1 0x20 1439 81 DUP2 143A 01 ADD 143B 90 SWAP1 143C 50 POP 143D 60 PUSH1 0x20 143F 83 DUP4 1440 03 SUB 1441 92 SWAP3 1442 50 POP 1443 61 PUSH2 0x1424 1446 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1430 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1435 stack[-2] = stack[-2] + 0x20 // @143B stack[-1] = stack[-1] + 0x20 // @1441 stack[-3] = stack[-3] - 0x20 // } // Block ends with unconditional jump to 0x1424 label_1447: // Incoming jump from 0x142C, if stack[-3] < 0x20 // Incoming jump from 0x142C, if memory[stack[-1]:stack[-1] + 0x20] < 0x20 // Inputs[10] // { // @144A stack[-3] // @1455 stack[-1] // @1456 memory[stack[-1]:stack[-1] + 0x20] // @1459 stack[-2] // @145A memory[stack[-2]:stack[-2] + 0x20] // @1467 stack[-5] // @1467 stack[-4] // @1469 stack[-6] // @146A stack[-8] // @146C memory[stack[-8]:stack[-8] + 0x20] // } 1447 5B JUMPDEST 1448 60 PUSH1 0x01 144A 83 DUP4 144B 60 PUSH1 0x20 144D 03 SUB 144E 61 PUSH2 0x0100 1451 0A EXP 1452 03 SUB 1453 80 DUP1 1454 19 NOT 1455 82 DUP3 1456 51 MLOAD 1457 16 AND 1458 81 DUP2 1459 84 DUP5 145A 51 MLOAD 145B 16 AND 145C 80 DUP1 145D 82 DUP3 145E 17 OR 145F 85 DUP6 1460 52 MSTORE 1461 50 POP 1462 50 POP 1463 50 POP 1464 50 POP 1465 50 POP 1466 50 POP 1467 90 SWAP1 1468 50 POP 1469 01 ADD 146A 82 DUP3 146B 80 DUP1 146C 51 MLOAD 146D 90 SWAP1 146E 60 PUSH1 0x20 1470 01 ADD 1471 90 SWAP1 1472 80 DUP1 1473 83 DUP4 1474 83 DUP4 1475 5B JUMPDEST 1476 60 PUSH1 0x20 1478 83 DUP4 1479 10 LT 147A 61 PUSH2 0x1498 147D 57 *JUMPI // Stack delta = +0 // Outputs[7] // { // @1460 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @1469 stack[-6] = stack[-4] + stack[-6] // @1471 stack[-5] = 0x20 + stack[-8] // @1471 stack[-4] = memory[stack[-8]:stack[-8] + 0x20] // @1472 stack[-3] = memory[stack[-8]:stack[-8] + 0x20] // @1473 stack[-2] = stack[-4] + stack[-6] // @1474 stack[-1] = 0x20 + stack[-8] // } // Block ends with conditional jump to 0x1498, if memory[stack[-8]:stack[-8] + 0x20] < 0x20 label_147E: // Incoming jump from 0x147D, if not stack[-3] < 0x20 // Incoming jump from 0x147D, if not memory[stack[-8]:stack[-8] + 0x20] < 0x20 // Inputs[4] // { // @147E stack[-1] // @147F memory[stack[-1]:stack[-1] + 0x20] // @1480 stack[-2] // @1490 stack[-3] // } 147E 80 DUP1 147F 51 MLOAD 1480 82 DUP3 1481 52 MSTORE 1482 60 PUSH1 0x20 1484 82 DUP3 1485 01 ADD 1486 91 SWAP2 1487 50 POP 1488 60 PUSH1 0x20 148A 81 DUP2 148B 01 ADD 148C 90 SWAP1 148D 50 POP 148E 60 PUSH1 0x20 1490 83 DUP4 1491 03 SUB 1492 92 SWAP3 1493 50 POP 1494 61 PUSH2 0x1475 1497 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1481 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1486 stack[-2] = stack[-2] + 0x20 // @148C stack[-1] = stack[-1] + 0x20 // @1492 stack[-3] = stack[-3] - 0x20 // } // Block ends with unconditional jump to 0x1475 label_1498: // Incoming jump from 0x147D, if stack[-3] < 0x20 // Incoming jump from 0x147D, if memory[stack[-8]:stack[-8] + 0x20] < 0x20 // Inputs[11] // { // @149B stack[-3] // @14A6 stack[-1] // @14A7 memory[stack[-1]:stack[-1] + 0x20] // @14AA stack[-2] // @14AB memory[stack[-2]:stack[-2] + 0x20] // @14B8 stack[-5] // @14B8 stack[-4] // @14BA stack[-6] // @14BB stack[-9] // @14C1 memory[0x40:0x60] // @14CE stack[-12] // } 1498 5B JUMPDEST 1499 60 PUSH1 0x01 149B 83 DUP4 149C 60 PUSH1 0x20 149E 03 SUB 149F 61 PUSH2 0x0100 14A2 0A EXP 14A3 03 SUB 14A4 80 DUP1 14A5 19 NOT 14A6 82 DUP3 14A7 51 MLOAD 14A8 16 AND 14A9 81 DUP2 14AA 84 DUP5 14AB 51 MLOAD 14AC 16 AND 14AD 80 DUP1 14AE 82 DUP3 14AF 17 OR 14B0 85 DUP6 14B1 52 MSTORE 14B2 50 POP 14B3 50 POP 14B4 50 POP 14B5 50 POP 14B6 50 POP 14B7 50 POP 14B8 90 SWAP1 14B9 50 POP 14BA 01 ADD 14BB 92 SWAP3 14BC 50 POP 14BD 50 POP 14BE 50 POP 14BF 60 PUSH1 0x40 14C1 51 MLOAD 14C2 60 PUSH1 0x20 14C4 81 DUP2 14C5 83 DUP4 14C6 03 SUB 14C7 03 SUB 14C8 81 DUP2 14C9 52 MSTORE 14CA 90 SWAP1 14CB 60 PUSH1 0x40 14CD 52 MSTORE 14CE 92 SWAP3 14CF 50 POP 14D0 50 POP 14D1 50 POP 14D2 61 PUSH2 0x15a1 14D5 56 *JUMP // Stack delta = -11 // Outputs[4] // { // @14B1 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @14C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (stack[-4] + stack[-6]) - memory[0x40:0x60] - 0x20 // @14CD memory[0x40:0x60] = stack[-4] + stack[-6] // @14CE stack[-12] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x15a1 label_14D6: // Incoming jump from 0x140F, if !(memory[stack[-2]:stack[-2] + 0x20] > 0x00) // Inputs[2] // { // @14D7 stack[-1] // @14DB stack[-4] // } 14D6 5B JUMPDEST 14D7 80 DUP1 14D8 61 PUSH2 0x14e0 14DB 85 DUP6 14DC 61 PUSH2 0x1fcd 14DF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @14D7 stack[0] = stack[-1] // @14D8 stack[1] = 0x14e0 // @14DB stack[2] = stack[-4] // } // Block ends with call to 0x1fcd, returns to 0x14E0 label_14E0: // Incoming return from call to 0x1FCD at 0x14DF // Inputs[3] // { // @14E3 memory[0x40:0x60] // @14E8 stack[-2] // @14EA memory[stack[-2]:stack[-2] + 0x20] // } 14E0 5B JUMPDEST 14E1 60 PUSH1 0x40 14E3 51 MLOAD 14E4 60 PUSH1 0x20 14E6 01 ADD 14E7 80 DUP1 14E8 83 DUP4 14E9 80 DUP1 14EA 51 MLOAD 14EB 90 SWAP1 14EC 60 PUSH1 0x20 14EE 01 ADD 14EF 90 SWAP1 14F0 80 DUP1 14F1 83 DUP4 14F2 83 DUP4 14F3 5B JUMPDEST 14F4 60 PUSH1 0x20 14F6 83 DUP4 14F7 10 LT 14F8 61 PUSH2 0x1516 14FB 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @14E6 stack[0] = 0x20 + memory[0x40:0x60] // @14E7 stack[1] = 0x20 + memory[0x40:0x60] // @14EF stack[2] = 0x20 + stack[-2] // @14EF stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @14F0 stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @14F1 stack[5] = 0x20 + memory[0x40:0x60] // @14F2 stack[6] = 0x20 + stack[-2] // } // Block ends with conditional jump to 0x1516, if memory[stack[-2]:stack[-2] + 0x20] < 0x20 label_14FC: // Incoming jump from 0x14FB, if not stack[-3] < 0x20 // Incoming jump from 0x14FB, if not memory[stack[-2]:stack[-2] + 0x20] < 0x20 // Inputs[4] // { // @14FC stack[-1] // @14FD memory[stack[-1]:stack[-1] + 0x20] // @14FE stack[-2] // @150E stack[-3] // } 14FC 80 DUP1 14FD 51 MLOAD 14FE 82 DUP3 14FF 52 MSTORE 1500 60 PUSH1 0x20 1502 82 DUP3 1503 01 ADD 1504 91 SWAP2 1505 50 POP 1506 60 PUSH1 0x20 1508 81 DUP2 1509 01 ADD 150A 90 SWAP1 150B 50 POP 150C 60 PUSH1 0x20 150E 83 DUP4 150F 03 SUB 1510 92 SWAP3 1511 50 POP 1512 61 PUSH2 0x14f3 1515 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @14FF memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1504 stack[-2] = stack[-2] + 0x20 // @150A stack[-1] = stack[-1] + 0x20 // @1510 stack[-3] = stack[-3] - 0x20 // } // Block ends with unconditional jump to 0x14f3 label_1516: // Incoming jump from 0x14FB, if stack[-3] < 0x20 // Incoming jump from 0x14FB, if memory[stack[-2]:stack[-2] + 0x20] < 0x20 // Inputs[10] // { // @1519 stack[-3] // @1524 stack[-1] // @1525 memory[stack[-1]:stack[-1] + 0x20] // @1528 stack[-2] // @1529 memory[stack[-2]:stack[-2] + 0x20] // @1536 stack[-4] // @1536 stack[-5] // @1538 stack[-6] // @1539 stack[-8] // @153B memory[stack[-8]:stack[-8] + 0x20] // } 1516 5B JUMPDEST 1517 60 PUSH1 0x01 1519 83 DUP4 151A 60 PUSH1 0x20 151C 03 SUB 151D 61 PUSH2 0x0100 1520 0A EXP 1521 03 SUB 1522 80 DUP1 1523 19 NOT 1524 82 DUP3 1525 51 MLOAD 1526 16 AND 1527 81 DUP2 1528 84 DUP5 1529 51 MLOAD 152A 16 AND 152B 80 DUP1 152C 82 DUP3 152D 17 OR 152E 85 DUP6 152F 52 MSTORE 1530 50 POP 1531 50 POP 1532 50 POP 1533 50 POP 1534 50 POP 1535 50 POP 1536 90 SWAP1 1537 50 POP 1538 01 ADD 1539 82 DUP3 153A 80 DUP1 153B 51 MLOAD 153C 90 SWAP1 153D 60 PUSH1 0x20 153F 01 ADD 1540 90 SWAP1 1541 80 DUP1 1542 83 DUP4 1543 83 DUP4 1544 5B JUMPDEST 1545 60 PUSH1 0x20 1547 83 DUP4 1548 10 LT 1549 61 PUSH2 0x1567 154C 57 *JUMPI // Stack delta = +0 // Outputs[7] // { // @152F memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @1538 stack[-6] = stack[-4] + stack[-6] // @1540 stack[-5] = 0x20 + stack[-8] // @1540 stack[-4] = memory[stack[-8]:stack[-8] + 0x20] // @1541 stack[-3] = memory[stack[-8]:stack[-8] + 0x20] // @1542 stack[-2] = stack[-4] + stack[-6] // @1543 stack[-1] = 0x20 + stack[-8] // } // Block ends with conditional jump to 0x1567, if memory[stack[-8]:stack[-8] + 0x20] < 0x20 label_154D: // Incoming jump from 0x154C, if not stack[-3] < 0x20 // Incoming jump from 0x154C, if not memory[stack[-8]:stack[-8] + 0x20] < 0x20 // Inputs[4] // { // @154D stack[-1] // @154E memory[stack[-1]:stack[-1] + 0x20] // @154F stack[-2] // @155F stack[-3] // } 154D 80 DUP1 154E 51 MLOAD 154F 82 DUP3 1550 52 MSTORE 1551 60 PUSH1 0x20 1553 82 DUP3 1554 01 ADD 1555 91 SWAP2 1556 50 POP 1557 60 PUSH1 0x20 1559 81 DUP2 155A 01 ADD 155B 90 SWAP1 155C 50 POP 155D 60 PUSH1 0x20 155F 83 DUP4 1560 03 SUB 1561 92 SWAP3 1562 50 POP 1563 61 PUSH2 0x1544 1566 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1550 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1555 stack[-2] = stack[-2] + 0x20 // @155B stack[-1] = stack[-1] + 0x20 // @1561 stack[-3] = stack[-3] - 0x20 // } // Block ends with unconditional jump to 0x1544 label_1567: // Incoming jump from 0x154C, if stack[-3] < 0x20 // Incoming jump from 0x154C, if memory[stack[-8]:stack[-8] + 0x20] < 0x20 // Inputs[11] // { // @156A stack[-3] // @1575 stack[-1] // @1576 memory[stack[-1]:stack[-1] + 0x20] // @1579 stack[-2] // @157A memory[stack[-2]:stack[-2] + 0x20] // @1587 stack[-5] // @1587 stack[-4] // @1589 stack[-6] // @158A stack[-9] // @1590 memory[0x40:0x60] // @159D stack[-12] // } 1567 5B JUMPDEST 1568 60 PUSH1 0x01 156A 83 DUP4 156B 60 PUSH1 0x20 156D 03 SUB 156E 61 PUSH2 0x0100 1571 0A EXP 1572 03 SUB 1573 80 DUP1 1574 19 NOT 1575 82 DUP3 1576 51 MLOAD 1577 16 AND 1578 81 DUP2 1579 84 DUP5 157A 51 MLOAD 157B 16 AND 157C 80 DUP1 157D 82 DUP3 157E 17 OR 157F 85 DUP6 1580 52 MSTORE 1581 50 POP 1582 50 POP 1583 50 POP 1584 50 POP 1585 50 POP 1586 50 POP 1587 90 SWAP1 1588 50 POP 1589 01 ADD 158A 92 SWAP3 158B 50 POP 158C 50 POP 158D 50 POP 158E 60 PUSH1 0x40 1590 51 MLOAD 1591 60 PUSH1 0x20 1593 81 DUP2 1594 83 DUP4 1595 03 SUB 1596 03 SUB 1597 81 DUP2 1598 52 MSTORE 1599 90 SWAP1 159A 60 PUSH1 0x40 159C 52 MSTORE 159D 92 SWAP3 159E 50 POP 159F 50 POP 15A0 50 POP // Stack delta = -11 // Outputs[4] // { // @1580 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @1598 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (stack[-4] + stack[-6]) - memory[0x40:0x60] - 0x20 // @159C memory[0x40:0x60] = stack[-4] + stack[-6] // @159D stack[-12] = memory[0x40:0x60] // } // Block continues label_15A1: // Incoming jump from 0x14D5 // Incoming jump from 0x1404 // Incoming jump from 0x15A0 // Inputs[3] // { // @15A2 stack[-1] // @15A2 stack[-3] // @15A3 stack[-2] // } 15A1 5B JUMPDEST 15A2 91 SWAP2 15A3 90 SWAP1 15A4 50 POP 15A5 56 *JUMP // Stack delta = -2 // Outputs[1] { @15A2 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_15A6: // Incoming call from 0x19FC, returns to 0x19FD // Incoming jump from 0x08F0 // Incoming jump from 0x0BD1 // Inputs[6] // { // @15AD stack[-2] // @15E7 memory[0x00:0x40] // @15EA stack[-1] // @1624 memory[0x00:0x40] // @1628 storage[keccak256(memory[0x00:0x40])] // @1635 stack[-3] // } 15A6 5B JUMPDEST 15A7 60 PUSH1 0x00 15A9 60 PUSH1 0x09 15AB 60 PUSH1 0x00 15AD 84 DUP5 15AE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15C3 16 AND 15C4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15D9 16 AND 15DA 81 DUP2 15DB 52 MSTORE 15DC 60 PUSH1 0x20 15DE 01 ADD 15DF 90 SWAP1 15E0 81 DUP2 15E1 52 MSTORE 15E2 60 PUSH1 0x20 15E4 01 ADD 15E5 60 PUSH1 0x00 15E7 20 SHA3 15E8 60 PUSH1 0x00 15EA 83 DUP4 15EB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1600 16 AND 1601 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1616 16 AND 1617 81 DUP2 1618 52 MSTORE 1619 60 PUSH1 0x20 161B 01 ADD 161C 90 SWAP1 161D 81 DUP2 161E 52 MSTORE 161F 60 PUSH1 0x20 1621 01 ADD 1622 60 PUSH1 0x00 1624 20 SHA3 1625 60 PUSH1 0x00 1627 90 SWAP1 1628 54 SLOAD 1629 90 SWAP1 162A 61 PUSH2 0x0100 162D 0A EXP 162E 90 SWAP1 162F 04 DIV 1630 60 PUSH1 0xff 1632 16 AND 1633 90 SWAP1 1634 50 POP 1635 92 SWAP3 1636 91 SWAP2 1637 50 POP 1638 50 POP 1639 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @15DB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @15E1 memory[0x20:0x40] = 0x09 // @1618 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @161E memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1635 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-3] label_163A: // Incoming jump from 0x094C 163A 5B JUMPDEST 163B 61 PUSH2 0x1642 163E 61 PUSH2 0x1844 1641 56 *JUMP // Stack delta = +1 // Outputs[1] { @163B stack[0] = 0x1642 } // Block ends with call to 0x1844, returns to 0x1642 label_1642: // Incoming return from call to 0x1844 at 0x1641 // Inputs[1] { @1658 stack[-1] } 1642 5B JUMPDEST 1643 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1658 16 AND 1659 61 PUSH2 0x1660 165C 61 PUSH2 0x0fd9 165F 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1658 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1659 stack[0] = 0x1660 // } // Block ends with call to 0x0fd9, returns to 0x1660 label_1660: // Incoming return from call to 0x0FD9 at 0x165F // Inputs[2] // { // @1676 stack[-1] // @1677 stack[-2] // } 1660 5B JUMPDEST 1661 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1676 16 AND 1677 14 EQ 1678 61 PUSH2 0x16e9 167B 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x16e9, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_167C: // Incoming jump from 0x167B, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[3] // { // @167E memory[0x40:0x60] // @16E3 memory[0x40:0x60] // @16E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 167C 60 PUSH1 0x40 167E 51 MLOAD 167F 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 16A0 81 DUP2 16A1 52 MSTORE 16A2 60 PUSH1 0x04 16A4 01 ADD 16A5 80 DUP1 16A6 80 DUP1 16A7 60 PUSH1 0x20 16A9 01 ADD 16AA 82 DUP3 16AB 81 DUP2 16AC 03 SUB 16AD 82 DUP3 16AE 52 MSTORE 16AF 60 PUSH1 0x20 16B1 81 DUP2 16B2 52 MSTORE 16B3 60 PUSH1 0x20 16B5 01 ADD 16B6 80 DUP1 16B7 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 16D8 81 DUP2 16D9 52 MSTORE 16DA 50 POP 16DB 60 PUSH1 0x20 16DD 01 ADD 16DE 91 SWAP2 16DF 50 POP 16E0 50 POP 16E1 60 PUSH1 0x40 16E3 51 MLOAD 16E4 80 DUP1 16E5 91 SWAP2 16E6 03 SUB 16E7 90 SWAP1 16E8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @16A1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @16AE memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @16B2 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @16D9 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @16E8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_16E9: // Incoming jump from 0x167B, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @1702 stack[-1] } 16E9 5B JUMPDEST 16EA 60 PUSH1 0x00 16EC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1701 16 AND 1702 81 DUP2 1703 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1718 16 AND 1719 14 EQ 171A 15 ISZERO 171B 61 PUSH2 0x176f 171E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x176f, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_171F: // Incoming jump from 0x171E, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @1721 memory[0x40:0x60] // @1769 memory[0x40:0x60] // @176E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 171F 60 PUSH1 0x40 1721 51 MLOAD 1722 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1743 81 DUP2 1744 52 MSTORE 1745 60 PUSH1 0x04 1747 01 ADD 1748 80 DUP1 1749 80 DUP1 174A 60 PUSH1 0x20 174C 01 ADD 174D 82 DUP3 174E 81 DUP2 174F 03 SUB 1750 82 DUP3 1751 52 MSTORE 1752 60 PUSH1 0x26 1754 81 DUP2 1755 52 MSTORE 1756 60 PUSH1 0x20 1758 01 ADD 1759 80 DUP1 175A 61 PUSH2 0x2fa1 175D 60 PUSH1 0x26 175F 91 SWAP2 1760 39 CODECOPY 1761 60 PUSH1 0x40 1763 01 ADD 1764 91 SWAP2 1765 50 POP 1766 50 POP 1767 60 PUSH1 0x40 1769 51 MLOAD 176A 80 DUP1 176B 91 SWAP2 176C 03 SUB 176D 90 SWAP1 176E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1744 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1751 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1755 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x26 // @1760 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x26] = code[0x2fa1:0x2fc7] // @176E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_176F: // Incoming jump from 0x171E, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[7] // { // @1770 stack[-1] // @178C storage[0x0e] // @17E3 memory[0x40:0x60] // @17E6 memory[0x40:0x60] // @17EB memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @17F6 storage[0x0e] // @182E stack[-2] // } 176F 5B JUMPDEST 1770 80 DUP1 1771 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1786 16 AND 1787 60 PUSH1 0x0e 1789 60 PUSH1 0x00 178B 90 SWAP1 178C 54 SLOAD 178D 90 SWAP1 178E 61 PUSH2 0x0100 1791 0A EXP 1792 90 SWAP1 1793 04 DIV 1794 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17A9 16 AND 17AA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17BF 16 AND 17C0 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 17E1 60 PUSH1 0x40 17E3 51 MLOAD 17E4 60 PUSH1 0x40 17E6 51 MLOAD 17E7 80 DUP1 17E8 91 SWAP2 17E9 03 SUB 17EA 90 SWAP1 17EB A3 LOG3 17EC 80 DUP1 17ED 60 PUSH1 0x0e 17EF 60 PUSH1 0x00 17F1 61 PUSH2 0x0100 17F4 0A EXP 17F5 81 DUP2 17F6 54 SLOAD 17F7 81 DUP2 17F8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 180D 02 MUL 180E 19 NOT 180F 16 AND 1810 90 SWAP1 1811 83 DUP4 1812 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1827 16 AND 1828 02 MUL 1829 17 OR 182A 90 SWAP1 182B 55 SSTORE 182C 50 POP 182D 50 POP 182E 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @17EB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0e] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); // @182B storage[0x0e] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x0e]) // } // Block ends with unconditional jump to stack[-2] label_182F: // Incoming call from 0x0A62, returns to 0x0A63 // Incoming call from 0x12DF, returns to 0x12E0 // Incoming call from 0x191D, returns to 0x191E // Inputs[1] { @1832 stack[-1] } 182F 5B JUMPDEST 1830 60 PUSH1 0x00 1832 81 DUP2 1833 61 PUSH2 0x183c 1836 60 PUSH1 0x01 1838 61 PUSH2 0x1905 183B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1830 stack[0] = 0x00 // @1832 stack[1] = stack[-1] // @1833 stack[2] = 0x183c // @1836 stack[3] = 0x01 // } // Block ends with call to 0x1905, returns to 0x183C label_183C: // Incoming return from call to 0x1905 at 0x183B // Inputs[5] // { // @183D stack[-2] // @183D stack[-1] // @183E stack[-3] // @1840 stack[-5] // @1841 stack[-4] // } 183C 5B JUMPDEST 183D 11 GT 183E 90 SWAP1 183F 50 POP 1840 91 SWAP2 1841 90 SWAP1 1842 50 POP 1843 56 *JUMP // Stack delta = -4 // Outputs[1] { @1840 stack[-5] = stack[-1] > stack[-2] } // Block ends with unconditional jump to stack[-5] label_1844: // Incoming call from 0x115A, returns to 0x115B // Incoming call from 0x1207, returns to 0x1208 // Incoming call from 0x0BCC, returns to 0x0BCD // Incoming call from 0x1267, returns to 0x1268 // Incoming call from 0x10AC, returns to 0x10AD // Incoming call from 0x0C52, returns to 0x0C53 // Incoming call from 0x2323, returns to 0x2324 // Incoming call from 0x1641, returns to 0x1642 // Incoming call from 0x0BA3, returns to 0x0BA4 // Incoming call from 0x0E70, returns to 0x0E71 // Inputs[2] // { // @1847 msg.sender // @184A stack[-1] // } 1844 5B JUMPDEST 1845 60 PUSH1 0x00 1847 33 CALLER 1848 90 SWAP1 1849 50 POP 184A 90 SWAP1 184B 56 *JUMP // Stack delta = +0 // Outputs[1] { @184A stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_184C: // Incoming call from 0x1B2E, returns to 0x1B2F // Incoming call from 0x0C31, returns to 0x0C32 // Inputs[4] // { // @184D stack[-2] // @1852 stack[-1] // @1860 memory[0x00:0x40] // @1868 storage[keccak256(memory[0x00:0x40])] // } 184C 5B JUMPDEST 184D 81 DUP2 184E 60 PUSH1 0x08 1850 60 PUSH1 0x00 1852 83 DUP4 1853 81 DUP2 1854 52 MSTORE 1855 60 PUSH1 0x20 1857 01 ADD 1858 90 SWAP1 1859 81 DUP2 185A 52 MSTORE 185B 60 PUSH1 0x20 185D 01 ADD 185E 60 PUSH1 0x00 1860 20 SHA3 1861 60 PUSH1 0x00 1863 61 PUSH2 0x0100 1866 0A EXP 1867 81 DUP2 1868 54 SLOAD 1869 81 DUP2 186A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 187F 02 MUL 1880 19 NOT 1881 16 AND 1882 90 SWAP1 1883 83 DUP4 1884 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1899 16 AND 189A 02 MUL 189B 17 OR 189C 90 SWAP1 189D 55 SSTORE 189E 50 POP 189F 80 DUP1 18A0 82 DUP3 18A1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18B6 16 AND 18B7 61 PUSH2 0x18bf 18BA 83 DUP4 18BB 61 PUSH2 0x0d08 18BE 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @1854 memory[0x00:0x20] = stack[-1] // @185A memory[0x20:0x40] = 0x08 // @189D storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @189F stack[0] = stack[-1] // @18B6 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @18B7 stack[2] = 0x18bf // @18BA stack[3] = stack[-1] // } // Block ends with call to 0x0d08, returns to 0x18BF label_18BF: // Incoming return from call to 0x0D08 at 0x18BE // Inputs[7] // { // @18D5 stack[-1] // @18F9 memory[0x40:0x60] // @18FC memory[0x40:0x60] // @1901 stack[-3] // @1901 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1901 stack[-2] // @1904 stack[-6] // } 18BF 5B JUMPDEST 18C0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18D5 16 AND 18D6 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 18F7 60 PUSH1 0x40 18F9 51 MLOAD 18FA 60 PUSH1 0x40 18FC 51 MLOAD 18FD 80 DUP1 18FE 91 SWAP2 18FF 03 SUB 1900 90 SWAP1 1901 A4 LOG4 1902 50 POP 1903 50 POP 1904 56 *JUMP // Stack delta = -6 // Outputs[1] { @1901 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_1905: // Incoming call from 0x0C42, returns to 0x0C43 // Incoming call from 0x183B, returns to 0x183C // Inputs[3] // { // @1908 stack[-1] // @190C storage[0x04 + stack[-1]] // @190F stack[-2] // } 1905 5B JUMPDEST 1906 60 PUSH1 0x00 1908 81 DUP2 1909 60 PUSH1 0x04 190B 01 ADD 190C 54 SLOAD 190D 90 SWAP1 190E 50 POP 190F 91 SWAP2 1910 90 SWAP1 1911 50 POP 1912 56 *JUMP // Stack delta = -1 // Outputs[1] { @190F stack[-2] = storage[0x04 + stack[-1]] } // Block ends with unconditional jump to stack[-2] label_1913: // Incoming jump from 0x0C58 // Incoming jump from 0x126D // Inputs[1] { @1919 stack[-1] } 1913 5B JUMPDEST 1914 60 PUSH1 0x00 1916 61 PUSH2 0x191e 1919 82 DUP3 191A 61 PUSH2 0x182f 191D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1914 stack[0] = 0x00 // @1916 stack[1] = 0x191e // @1919 stack[2] = stack[-1] // } // Block ends with call to 0x182f, returns to 0x191E label_191E: // Incoming return from call to 0x182F at 0x191D // Inputs[1] { @1922 stack[-1] } 191E 5B JUMPDEST 191F 61 PUSH2 0x1973 1922 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1973, if stack[-1] label_1923: // Incoming jump from 0x1922, if not stack[-1] // Inputs[3] // { // @1925 memory[0x40:0x60] // @196D memory[0x40:0x60] // @1972 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1923 60 PUSH1 0x40 1925 51 MLOAD 1926 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1947 81 DUP2 1948 52 MSTORE 1949 60 PUSH1 0x04 194B 01 ADD 194C 80 DUP1 194D 80 DUP1 194E 60 PUSH1 0x20 1950 01 ADD 1951 82 DUP3 1952 81 DUP2 1953 03 SUB 1954 82 DUP3 1955 52 MSTORE 1956 60 PUSH1 0x2c 1958 81 DUP2 1959 52 MSTORE 195A 60 PUSH1 0x20 195C 01 ADD 195D 80 DUP1 195E 61 PUSH2 0x3011 1961 60 PUSH1 0x2c 1963 91 SWAP2 1964 39 CODECOPY 1965 60 PUSH1 0x40 1967 01 ADD 1968 91 SWAP2 1969 50 POP 196A 50 POP 196B 60 PUSH1 0x40 196D 51 MLOAD 196E 80 DUP1 196F 91 SWAP2 1970 03 SUB 1971 90 SWAP1 1972 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1948 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1955 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1959 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @1964 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x3011:0x303d] // @1972 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1973: // Incoming jump from 0x1922, if stack[-1] // Inputs[1] { @1979 stack[-2] } 1973 5B JUMPDEST 1974 60 PUSH1 0x00 1976 61 PUSH2 0x197e 1979 83 DUP4 197A 61 PUSH2 0x0d08 197D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1974 stack[0] = 0x00 // @1976 stack[1] = 0x197e // @1979 stack[2] = stack[-2] // } // Block ends with call to 0x0d08, returns to 0x197E label_197E: // Incoming return from call to 0x0D08 at 0x197D // Inputs[3] // { // @197F stack[-2] // @197F stack[-1] // @1998 stack[-5] // } 197E 5B JUMPDEST 197F 90 SWAP1 1980 50 POP 1981 80 DUP1 1982 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1997 16 AND 1998 84 DUP5 1999 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19AE 16 AND 19AF 14 EQ 19B0 80 DUP1 19B1 61 PUSH2 0x19ed 19B4 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @197F stack[-2] = stack[-1] // @19AF stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // } // Block ends with conditional jump to 0x19ed, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] label_19B5: // Incoming jump from 0x19B4, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[2] // { // @19B6 stack[-5] // @19D0 stack[-4] // } 19B5 50 POP 19B6 83 DUP4 19B7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19CC 16 AND 19CD 61 PUSH2 0x19d5 19D0 84 DUP5 19D1 61 PUSH2 0x0a58 19D4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @19CC stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @19CD stack[0] = 0x19d5 // @19D0 stack[1] = stack[-4] // } // Block ends with call to 0x0a58, returns to 0x19D5 label_19D5: // Incoming return from call to 0x0A58 at 0x19D4 // Inputs[2] // { // @19EB stack[-1] // @19EC stack[-2] // } 19D5 5B JUMPDEST 19D6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19EB 16 AND 19EC 14 EQ // Stack delta = -1 // Outputs[1] { @19EC stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] } // Block continues label_19ED: // Incoming jump from 0x19B4, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Incoming jump from 0x19EC // Inputs[1] { @19EE stack[-1] } 19ED 5B JUMPDEST 19EE 80 DUP1 19EF 61 PUSH2 0x19fe 19F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x19fe, if stack[-1] label_19F3: // Incoming jump from 0x19F2, if not stack[-1] // Inputs[2] // { // @19F7 stack[-2] // @19F8 stack[-5] // } 19F3 50 POP 19F4 61 PUSH2 0x19fd 19F7 81 DUP2 19F8 85 DUP6 19F9 61 PUSH2 0x15a6 19FC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @19F4 stack[-1] = 0x19fd // @19F7 stack[0] = stack[-2] // @19F8 stack[1] = stack[-5] // } // Block ends with call to 0x15a6, returns to 0x19FD label_19FD: // Incoming return from call to 0x15A6 at 0x19FC 19FD 5B JUMPDEST // Stack delta = +0 // Block continues label_19FE: // Incoming jump from 0x19FD // Incoming jump from 0x19F2, if stack[-1] // Inputs[4] // { // @19FF stack[-3] // @19FF stack[-1] // @1A02 stack[-6] // @1A03 stack[-5] // } 19FE 5B JUMPDEST 19FF 91 SWAP2 1A00 50 POP 1A01 50 POP 1A02 92 SWAP3 1A03 91 SWAP2 1A04 50 POP 1A05 50 POP 1A06 56 *JUMP // Stack delta = -5 // Outputs[1] { @1A02 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1A07: // Incoming call from 0x1F65, returns to 0x1F66 // Incoming call from 0x0CB8, returns to 0x0CB9 // Inputs[2] // { // @1A08 stack[-3] // @1A22 stack[-1] // } 1A07 5B JUMPDEST 1A08 82 DUP3 1A09 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A1E 16 AND 1A1F 61 PUSH2 0x1a27 1A22 82 DUP3 1A23 61 PUSH2 0x0d08 1A26 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A1E stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1A1F stack[1] = 0x1a27 // @1A22 stack[2] = stack[-1] // } // Block ends with call to 0x0d08, returns to 0x1A27 label_1A27: // Incoming return from call to 0x0D08 at 0x1A26 // Inputs[2] // { // @1A3D stack[-1] // @1A3E stack[-2] // } 1A27 5B JUMPDEST 1A28 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A3D 16 AND 1A3E 14 EQ 1A3F 61 PUSH2 0x1a93 1A42 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1a93, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_1A43: // Incoming jump from 0x1A42, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[3] // { // @1A45 memory[0x40:0x60] // @1A8D memory[0x40:0x60] // @1A92 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1A43 60 PUSH1 0x40 1A45 51 MLOAD 1A46 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1A67 81 DUP2 1A68 52 MSTORE 1A69 60 PUSH1 0x04 1A6B 01 ADD 1A6C 80 DUP1 1A6D 80 DUP1 1A6E 60 PUSH1 0x20 1A70 01 ADD 1A71 82 DUP3 1A72 81 DUP2 1A73 03 SUB 1A74 82 DUP3 1A75 52 MSTORE 1A76 60 PUSH1 0x29 1A78 81 DUP2 1A79 52 MSTORE 1A7A 60 PUSH1 0x20 1A7C 01 ADD 1A7D 80 DUP1 1A7E 61 PUSH2 0x30cb 1A81 60 PUSH1 0x29 1A83 91 SWAP2 1A84 39 CODECOPY 1A85 60 PUSH1 0x40 1A87 01 ADD 1A88 91 SWAP2 1A89 50 POP 1A8A 50 POP 1A8B 60 PUSH1 0x40 1A8D 51 MLOAD 1A8E 80 DUP1 1A8F 91 SWAP2 1A90 03 SUB 1A91 90 SWAP1 1A92 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1A68 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1A75 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1A79 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x29 // @1A84 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x29] = code[0x30cb:0x30f4] // @1A92 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1A93: // Incoming jump from 0x1A42, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @1AAC stack[-2] } 1A93 5B JUMPDEST 1A94 60 PUSH1 0x00 1A96 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AAB 16 AND 1AAC 82 DUP3 1AAD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AC2 16 AND 1AC3 14 EQ 1AC4 15 ISZERO 1AC5 61 PUSH2 0x1b19 1AC8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b19, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1AC9: // Incoming jump from 0x1AC8, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @1ACB memory[0x40:0x60] // @1B13 memory[0x40:0x60] // @1B18 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1AC9 60 PUSH1 0x40 1ACB 51 MLOAD 1ACC 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1AED 81 DUP2 1AEE 52 MSTORE 1AEF 60 PUSH1 0x04 1AF1 01 ADD 1AF2 80 DUP1 1AF3 80 DUP1 1AF4 60 PUSH1 0x20 1AF6 01 ADD 1AF7 82 DUP3 1AF8 81 DUP2 1AF9 03 SUB 1AFA 82 DUP3 1AFB 52 MSTORE 1AFC 60 PUSH1 0x24 1AFE 81 DUP2 1AFF 52 MSTORE 1B00 60 PUSH1 0x20 1B02 01 ADD 1B03 80 DUP1 1B04 61 PUSH2 0x2fc7 1B07 60 PUSH1 0x24 1B09 91 SWAP2 1B0A 39 CODECOPY 1B0B 60 PUSH1 0x40 1B0D 01 ADD 1B0E 91 SWAP2 1B0F 50 POP 1B10 50 POP 1B11 60 PUSH1 0x40 1B13 51 MLOAD 1B14 80 DUP1 1B15 91 SWAP2 1B16 03 SUB 1B17 90 SWAP1 1B18 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1AEE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1AFB memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1AFF memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x24 // @1B0A memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x24] = code[0x2fc7:0x2feb] // @1B18 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1B19: // Incoming jump from 0x1AC8, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @1B1D stack[-3] // @1B1E stack[-2] // @1B1F stack[-1] // } 1B19 5B JUMPDEST 1B1A 61 PUSH2 0x1b24 1B1D 83 DUP4 1B1E 83 DUP4 1B1F 83 DUP4 1B20 61 PUSH2 0x20fd 1B23 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B1A stack[0] = 0x1b24 // @1B1D stack[1] = stack[-3] // @1B1E stack[2] = stack[-2] // @1B1F stack[3] = stack[-1] // } // Block ends with call to 0x20fd, returns to 0x1B24 label_1B24: // Incoming return from call to 0x20FD at 0x1B23 // Inputs[1] { @1B2A stack[-1] } 1B24 5B JUMPDEST 1B25 61 PUSH2 0x1b2f 1B28 60 PUSH1 0x00 1B2A 82 DUP3 1B2B 61 PUSH2 0x184c 1B2E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B25 stack[0] = 0x1b2f // @1B28 stack[1] = 0x00 // @1B2A stack[2] = stack[-1] // } // Block ends with call to 0x184c, returns to 0x1B2F label_1B2F: // Incoming return from call to 0x184C at 0x1B2E // Inputs[2] // { // @1B33 stack[-1] // @1B34 stack[-2] // } 1B2F 5B JUMPDEST 1B30 61 PUSH2 0x1b45 1B33 81 DUP2 1B34 83 DUP4 1B35 60 PUSH1 0x01 1B37 61 PUSH2 0x2102 1B3A 90 SWAP1 1B3B 92 SWAP3 1B3C 91 SWAP2 1B3D 90 SWAP1 1B3E 63 PUSH4 0xffffffff 1B43 16 AND 1B44 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B30 stack[0] = 0x1b45 // @1B3B stack[1] = 0x01 // @1B3C stack[2] = stack[-1] // @1B3D stack[3] = stack[-2] // } // Block ends with call to 0xffffffff & 0x2102, returns to 0x1B45 label_1B45: // Incoming return from call to 0x2102 at 0x1B44 // Incoming return from call to 0x2102 at 0x1B44 // Inputs[7] // { // @1B47 stack[-2] // @1B48 stack[-3] // @1B5F stack[-4] // @1B99 memory[0x40:0x60] // @1B9C memory[0x40:0x60] // @1BA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1BA5 stack[-5] // } 1B45 5B JUMPDEST 1B46 50 POP 1B47 80 DUP1 1B48 82 DUP3 1B49 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B5E 16 AND 1B5F 84 DUP5 1B60 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B75 16 AND 1B76 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1B97 60 PUSH1 0x40 1B99 51 MLOAD 1B9A 60 PUSH1 0x40 1B9C 51 MLOAD 1B9D 80 DUP1 1B9E 91 SWAP2 1B9F 03 SUB 1BA0 90 SWAP1 1BA1 A4 LOG4 1BA2 50 POP 1BA3 50 POP 1BA4 50 POP 1BA5 56 *JUMP // Stack delta = -5 // Outputs[1] { @1BA1 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2]]); } // Block ends with unconditional jump to stack[-5] label_1BA6: // Incoming call from 0x0CD5, returns to 0x0CD6 // Inputs[3] // { // @1BAF stack[-3] // @1BB5 stack[-2] // @1BEF memory[0x00:0x40] // } 1BA6 5B JUMPDEST 1BA7 60 PUSH1 0x00 1BA9 80 DUP1 1BAA 61 PUSH2 0x1bfd 1BAD 60 PUSH1 0x00 1BAF 86 DUP7 1BB0 60 PUSH1 0x00 1BB2 01 ADD 1BB3 60 PUSH1 0x00 1BB5 87 DUP8 1BB6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1BCB 16 AND 1BCC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1BE1 16 AND 1BE2 81 DUP2 1BE3 52 MSTORE 1BE4 60 PUSH1 0x20 1BE6 01 ADD 1BE7 90 SWAP1 1BE8 81 DUP2 1BE9 52 MSTORE 1BEA 60 PUSH1 0x20 1BEC 01 ADD 1BED 60 PUSH1 0x00 1BEF 20 SHA3 1BF0 61 PUSH2 0x2251 1BF3 90 SWAP1 1BF4 91 SWAP2 1BF5 90 SWAP1 1BF6 63 PUSH4 0xffffffff 1BFB 16 AND 1BFC 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1BA7 stack[0] = 0x00 // @1BA9 stack[1] = 0x00 // @1BAA stack[2] = 0x1bfd // @1BE3 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1BE9 memory[0x20:0x40] = 0x00 + stack[-3] // @1BF4 stack[3] = keccak256(memory[0x00:0x40]) // @1BF5 stack[4] = 0x00 // } // Block ends with call to 0xffffffff & 0x2251, returns to 0x1BFD label_1BFD: // Incoming return from call to 0x2251 at 0x1BFC // Inputs[6] // { // @1BFE stack[-2] // @1BFE stack[-1] // @1C02 stack[-6] // @1C16 memory[0x00:0x40] // @1C17 storage[keccak256(memory[0x00:0x40])] // @1C1D stack[-4] // } 1BFD 5B JUMPDEST 1BFE 90 SWAP1 1BFF 50 POP 1C00 60 PUSH1 0x00 1C02 85 DUP6 1C03 60 PUSH1 0x01 1C05 01 ADD 1C06 60 PUSH1 0x00 1C08 83 DUP4 1C09 81 DUP2 1C0A 52 MSTORE 1C0B 60 PUSH1 0x20 1C0D 01 ADD 1C0E 90 SWAP1 1C0F 81 DUP2 1C10 52 MSTORE 1C11 60 PUSH1 0x20 1C13 01 ADD 1C14 60 PUSH1 0x00 1C16 20 SHA3 1C17 54 SLOAD 1C18 90 SWAP1 1C19 50 POP 1C1A 81 DUP2 1C1B 81 DUP2 1C1C 03 SUB 1C1D 84 DUP5 1C1E 10 LT 1C1F 15 ISZERO 1C20 61 PUSH2 0x1c2f 1C23 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1BFE stack[-2] = stack[-1] // @1C0A memory[0x00:0x20] = stack[-1] // @1C10 memory[0x20:0x40] = 0x01 + stack[-6] // @1C18 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1c2f, if !(stack[-4] < storage[keccak256(memory[0x00:0x40])] - stack[-1]) label_1C24: // Incoming jump from 0x1C23, if not !(stack[-4] < storage[keccak256(memory[0x00:0x40])] - stack[-1]) // Inputs[3] // { // @1C24 stack[-4] // @1C25 stack[-2] // @1C27 stack[-3] // } 1C24 83 DUP4 1C25 82 DUP3 1C26 01 ADD 1C27 92 SWAP3 1C28 50 POP 1C29 50 POP 1C2A 50 POP 1C2B 61 PUSH2 0x1d62 1C2E 56 *JUMP // Stack delta = -2 // Outputs[1] { @1C27 stack[-3] = stack[-2] + stack[-4] } // Block ends with unconditional jump to 0x1d62 label_1C2F: // Incoming jump from 0x1C23, if !(stack[-4] < storage[keccak256(memory[0x00:0x40])] - stack[-1]) // Inputs[3] // { // @1C30 stack[-2] // @1C31 stack[-1] // @1C33 stack[-4] // } 1C2F 5B JUMPDEST 1C30 81 DUP2 1C31 81 DUP2 1C32 03 SUB 1C33 84 DUP5 1C34 03 SUB 1C35 93 SWAP4 1C36 50 POP 1C37 60 PUSH1 0x01 1C39 84 DUP5 1C3A 10 LT 1C3B 15 ISZERO 1C3C 61 PUSH2 0x1c4b 1C3F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1C35 stack[-4] = stack[-4] - (stack[-1] - stack[-2]) } // Block ends with conditional jump to 0x1c4b, if !(stack[-4] - (stack[-1] - stack[-2]) < 0x01) label_1C40: // Incoming jump from 0x1C3F, if not !(stack[-4] - (stack[-1] - stack[-2]) < 0x01) 1C40 60 PUSH1 0x00 1C42 61 PUSH2 0x1c4a 1C45 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c4a, if 0x00 label_1C46: // Incoming jump from 0x1C45, if not 0x00 // Inputs[1] { @1C49 memory[0x00:0x00] } 1C46 60 PUSH1 0x00 1C48 80 DUP1 1C49 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C49 revert(memory[0x00:0x00]); } // Block terminates label_1C4A: // Incoming jump from 0x1C45, if 0x00 1C4A 5B JUMPDEST // Stack delta = +0 // Block continues label_1C4B: // Incoming jump from 0x1C3F, if !(stack[-4] - (stack[-1] - stack[-2]) < 0x01) // Incoming jump from 0x1C4A // Inputs[3] // { // @1C56 stack[-6] // @1C5C stack[-5] // @1C96 memory[0x00:0x40] // } 1C4B 5B JUMPDEST 1C4C 60 PUSH1 0x00 1C4E 60 PUSH1 0x01 1C50 90 SWAP1 1C51 50 POP 1C52 5B JUMPDEST 1C53 61 PUSH2 0x1c9b 1C56 87 DUP8 1C57 60 PUSH1 0x00 1C59 01 ADD 1C5A 60 PUSH1 0x00 1C5C 88 DUP9 1C5D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C72 16 AND 1C73 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C88 16 AND 1C89 81 DUP2 1C8A 52 MSTORE 1C8B 60 PUSH1 0x20 1C8D 01 ADD 1C8E 90 SWAP1 1C8F 81 DUP2 1C90 52 MSTORE 1C91 60 PUSH1 0x20 1C93 01 ADD 1C94 60 PUSH1 0x00 1C96 20 SHA3 1C97 61 PUSH2 0x226b 1C9A 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1C50 stack[0] = 0x01 // @1C53 stack[1] = 0x1c9b // @1C8A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @1C90 memory[0x20:0x40] = 0x00 + stack[-6] // @1C96 stack[2] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x226b, returns to 0x1C9B label_1C9B: // Incoming return from call to 0x226B at 0x1C9A // Incoming return from call to 0x226B at 0x1C9A // Inputs[2] // { // @1C9C stack[-2] // @1C9D stack[-1] // } 1C9B 5B JUMPDEST 1C9C 81 DUP2 1C9D 10 LT 1C9E 15 ISZERO 1C9F 61 PUSH2 0x1d4f 1CA2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1d4f, if !(stack[-2] < stack[-1]) label_1CA3: // Incoming jump from 0x1CA2, if not !(stack[-2] < stack[-1]) // Inputs[4] // { // @1CA6 stack[-1] // @1CA7 stack[-7] // @1CAD stack[-6] // @1CE7 memory[0x00:0x40] // } 1CA3 61 PUSH2 0x1cf5 1CA6 81 DUP2 1CA7 88 DUP9 1CA8 60 PUSH1 0x00 1CAA 01 ADD 1CAB 60 PUSH1 0x00 1CAD 89 DUP10 1CAE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CC3 16 AND 1CC4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CD9 16 AND 1CDA 81 DUP2 1CDB 52 MSTORE 1CDC 60 PUSH1 0x20 1CDE 01 ADD 1CDF 90 SWAP1 1CE0 81 DUP2 1CE1 52 MSTORE 1CE2 60 PUSH1 0x20 1CE4 01 ADD 1CE5 60 PUSH1 0x00 1CE7 20 SHA3 1CE8 61 PUSH2 0x2251 1CEB 90 SWAP1 1CEC 91 SWAP2 1CED 90 SWAP1 1CEE 63 PUSH4 0xffffffff 1CF3 16 AND 1CF4 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1CA3 stack[0] = 0x1cf5 // @1CDB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @1CE1 memory[0x20:0x40] = 0x00 + stack[-7] // @1CEC stack[1] = keccak256(memory[0x00:0x40]) // @1CED stack[2] = stack[-1] // } // Block ends with call to 0xffffffff & 0x2251, returns to 0x1CF5 label_1CF5: // Incoming return from call to 0x2251 at 0x1CF4 // Inputs[7] // { // @1CF6 stack[-4] // @1CF6 stack[-1] // @1CF8 stack[-8] // @1D0C memory[0x00:0x40] // @1D0D storage[keccak256(memory[0x00:0x40])] // @1D0E stack[-3] // @1D13 stack[-6] // } 1CF5 5B JUMPDEST 1CF6 92 SWAP3 1CF7 50 POP 1CF8 86 DUP7 1CF9 60 PUSH1 0x01 1CFB 01 ADD 1CFC 60 PUSH1 0x00 1CFE 84 DUP5 1CFF 81 DUP2 1D00 52 MSTORE 1D01 60 PUSH1 0x20 1D03 01 ADD 1D04 90 SWAP1 1D05 81 DUP2 1D06 52 MSTORE 1D07 60 PUSH1 0x20 1D09 01 ADD 1D0A 60 PUSH1 0x00 1D0C 20 SHA3 1D0D 54 SLOAD 1D0E 91 SWAP2 1D0F 50 POP 1D10 82 DUP3 1D11 82 DUP3 1D12 03 SUB 1D13 85 DUP6 1D14 10 LT 1D15 15 ISZERO 1D16 61 PUSH2 0x1d26 1D19 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @1CF6 stack[-4] = stack[-1] // @1D00 memory[0x00:0x20] = stack[-1] // @1D06 memory[0x20:0x40] = 0x01 + stack[-8] // @1D0E stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1d26, if !(stack[-6] < storage[keccak256(memory[0x00:0x40])] - stack[-1]) label_1D1A: // Incoming jump from 0x1D19, if not !(stack[-6] < storage[keccak256(memory[0x00:0x40])] - stack[-1]) // Inputs[3] // { // @1D1A stack[-5] // @1D1B stack[-3] // @1D1D stack[-4] // } 1D1A 84 DUP5 1D1B 83 DUP4 1D1C 01 ADD 1D1D 93 SWAP4 1D1E 50 POP 1D1F 50 POP 1D20 50 POP 1D21 50 POP 1D22 61 PUSH2 0x1d62 1D25 56 *JUMP // Stack delta = -3 // Outputs[1] { @1D1D stack[-4] = stack[-3] + stack[-5] } // Block ends with unconditional jump to 0x1d62 label_1D26: // Incoming jump from 0x1D19, if !(stack[-6] < storage[keccak256(memory[0x00:0x40])] - stack[-1]) // Inputs[3] // { // @1D27 stack[-3] // @1D28 stack[-2] // @1D2A stack[-5] // } 1D26 5B JUMPDEST 1D27 82 DUP3 1D28 82 DUP3 1D29 03 SUB 1D2A 85 DUP6 1D2B 03 SUB 1D2C 94 SWAP5 1D2D 50 POP 1D2E 60 PUSH1 0x01 1D30 85 DUP6 1D31 10 LT 1D32 15 ISZERO 1D33 61 PUSH2 0x1d42 1D36 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1D2C stack[-5] = stack[-5] - (stack[-2] - stack[-3]) } // Block ends with conditional jump to 0x1d42, if !(stack[-5] - (stack[-2] - stack[-3]) < 0x01) label_1D37: // Incoming jump from 0x1D36, if not !(stack[-5] - (stack[-2] - stack[-3]) < 0x01) 1D37 60 PUSH1 0x00 1D39 61 PUSH2 0x1d41 1D3C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1d41, if 0x00 label_1D3D: // Incoming jump from 0x1D3C, if not 0x00 // Inputs[1] { @1D40 memory[0x00:0x00] } 1D3D 60 PUSH1 0x00 1D3F 80 DUP1 1D40 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D40 revert(memory[0x00:0x00]); } // Block terminates label_1D41: // Incoming jump from 0x1D3C, if 0x00 1D41 5B JUMPDEST // Stack delta = +0 // Block continues label_1D42: // Incoming jump from 0x1D36, if !(stack[-5] - (stack[-2] - stack[-3]) < 0x01) // Incoming jump from 0x1D41 // Inputs[1] { @1D43 stack[-1] } 1D42 5B JUMPDEST 1D43 80 DUP1 1D44 80 DUP1 1D45 60 PUSH1 0x01 1D47 01 ADD 1D48 91 SWAP2 1D49 50 POP 1D4A 50 POP 1D4B 61 PUSH2 0x1c52 1D4E 56 *JUMP // Stack delta = +0 // Outputs[1] { @1D48 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x1c52 label_1D4F: // Incoming jump from 0x1CA2, if !(stack[-2] < stack[-1]) 1D4F 5B JUMPDEST 1D50 50 POP 1D51 60 PUSH1 0x00 1D53 61 PUSH2 0x1d5b 1D56 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1d5b, if 0x00 label_1D57: // Incoming jump from 0x1D56, if not 0x00 // Inputs[1] { @1D5A memory[0x00:0x00] } 1D57 60 PUSH1 0x00 1D59 80 DUP1 1D5A FD *REVERT // Stack delta = +0 // Outputs[1] { @1D5A revert(memory[0x00:0x00]); } // Block terminates label_1D5B: // Incoming jump from 0x1D56, if 0x00 // Inputs[1] { @1D5E stack[-3] } 1D5B 5B JUMPDEST 1D5C 60 PUSH1 0x00 1D5E 92 SWAP3 1D5F 50 POP 1D60 50 POP 1D61 50 POP // Stack delta = -2 // Outputs[1] { @1D5E stack[-3] = 0x00 } // Block continues label_1D62: // Incoming jump from 0x1C2E // Incoming jump from 0x1D25 // Incoming jump from 0x1D61 // Inputs[3] // { // @1D63 stack[-5] // @1D63 stack[-1] // @1D64 stack[-4] // } 1D62 5B JUMPDEST 1D63 93 SWAP4 1D64 92 SWAP3 1D65 50 POP 1D66 50 POP 1D67 50 POP 1D68 56 *JUMP // Stack delta = -4 // Outputs[1] { @1D63 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1D69: // Incoming call from 0x0D1D, returns to 0x0D1E // Inputs[1] { @1D70 stack[-2] } 1D69 5B JUMPDEST 1D6A 60 PUSH1 0x00 1D6C 80 DUP1 1D6D 61 PUSH2 0x1d78 1D70 84 DUP5 1D71 60 PUSH1 0x02 1D73 01 ADD 1D74 61 PUSH2 0x2280 1D77 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D6A stack[0] = 0x00 // @1D6C stack[1] = 0x00 // @1D6D stack[2] = 0x1d78 // @1D73 stack[3] = 0x02 + stack[-2] // } // Block ends with call to 0x2280, returns to 0x1D78 label_1D78: // Incoming return from call to 0x2280 at 0x1D77 // Inputs[4] // { // @1D79 stack[-2] // @1D79 stack[-1] // @1D7B stack[-5] // @1D7F storage[0x06 + stack[-5]] // } 1D78 5B JUMPDEST 1D79 90 SWAP1 1D7A 50 POP 1D7B 83 DUP4 1D7C 60 PUSH1 0x06 1D7E 01 ADD 1D7F 54 SLOAD 1D80 81 DUP2 1D81 11 GT 1D82 15 ISZERO 1D83 61 PUSH2 0x1db7 1D86 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1D79 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1db7, if !(stack[-1] > storage[0x06 + stack[-5]]) label_1D87: // Incoming jump from 0x1D86, if not !(stack[-1] > storage[0x06 + stack[-5]]) // Inputs[2] // { // @1D8D stack[-3] // @1D8E stack[-4] // } 1D87 60 PUSH1 0x00 1D89 80 DUP1 1D8A 61 PUSH2 0x1d9f 1D8D 85 DUP6 1D8E 87 DUP8 1D8F 60 PUSH1 0x02 1D91 01 ADD 1D92 61 PUSH2 0x2295 1D95 90 SWAP1 1D96 91 SWAP2 1D97 90 SWAP1 1D98 63 PUSH4 0xffffffff 1D9D 16 AND 1D9E 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1D87 stack[0] = 0x00 // @1D89 stack[1] = 0x00 // @1D8A stack[2] = 0x1d9f // @1D96 stack[3] = 0x02 + stack[-4] // @1D97 stack[4] = stack[-3] // } // Block ends with call to 0xffffffff & 0x2295, returns to 0x1D9F label_1D9F: // Incoming return from call to 0x2295 at 0x1D9E // Inputs[4] // { // @1DA0 stack[-1] // @1DA0 stack[-3] // @1DA2 stack[-4] // @1DA2 stack[-2] // } 1D9F 5B JUMPDEST 1DA0 91 SWAP2 1DA1 50 POP 1DA2 91 SWAP2 1DA3 50 POP 1DA4 81 DUP2 1DA5 15 ISZERO 1DA6 61 PUSH2 0x1db4 1DA9 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1DA0 stack[-3] = stack[-1] // @1DA2 stack[-4] = stack[-2] // } // Block ends with conditional jump to 0x1db4, if !stack[-2] label_1DAA: // Incoming jump from 0x1DA9, if not !stack[-2] // Inputs[2] // { // @1DAA stack[-1] // @1DAB stack[-4] // } 1DAA 80 DUP1 1DAB 93 SWAP4 1DAC 50 POP 1DAD 50 POP 1DAE 50 POP 1DAF 50 POP 1DB0 61 PUSH2 0x1e66 1DB3 56 *JUMP // Stack delta = -3 // Outputs[1] { @1DAB stack[-4] = stack[-1] } // Block ends with unconditional jump to 0x1e66 label_1DB4: // Incoming jump from 0x1DA9, if !stack[-2] 1DB4 5B JUMPDEST 1DB5 50 POP 1DB6 50 POP // Stack delta = -2 // Block continues label_1DB7: // Incoming jump from 0x1D86, if !(stack[-1] > storage[0x06 + stack[-5]]) // Incoming jump from 0x1DB6 // Inputs[4] // { // @1DBA stack[-4] // @1DCE memory[0x00:0x40] // @1DCF storage[keccak256(memory[0x00:0x40])] // @1DD3 stack[-3] // } 1DB7 5B JUMPDEST 1DB8 60 PUSH1 0x00 1DBA 84 DUP5 1DBB 60 PUSH1 0x01 1DBD 01 ADD 1DBE 60 PUSH1 0x00 1DC0 80 DUP1 1DC1 81 DUP2 1DC2 52 MSTORE 1DC3 60 PUSH1 0x20 1DC5 01 ADD 1DC6 90 SWAP1 1DC7 81 DUP2 1DC8 52 MSTORE 1DC9 60 PUSH1 0x20 1DCB 01 ADD 1DCC 60 PUSH1 0x00 1DCE 20 SHA3 1DCF 54 SLOAD 1DD0 90 SWAP1 1DD1 50 POP 1DD2 80 DUP1 1DD3 84 DUP5 1DD4 10 LT 1DD5 15 ISZERO 1DD6 61 PUSH2 0x1df9 1DD9 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1DC2 memory[0x00:0x20] = 0x00 // @1DC8 memory[0x20:0x40] = 0x01 + stack[-4] // @1DD0 stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1df9, if !(stack[-3] < storage[keccak256(memory[0x00:0x40])]) label_1DDA: // Incoming jump from 0x1DD9, if not !(stack[-3] < storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @1DDF stack[-5] } 1DDA 61 PUSH2 0x1df0 1DDD 60 PUSH1 0x00 1DDF 86 DUP7 1DE0 60 PUSH1 0x02 1DE2 01 ADD 1DE3 61 PUSH2 0x22c4 1DE6 90 SWAP1 1DE7 91 SWAP2 1DE8 90 SWAP1 1DE9 63 PUSH4 0xffffffff 1DEE 16 AND 1DEF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1DDA stack[0] = 0x1df0 // @1DE7 stack[1] = 0x02 + stack[-5] // @1DE8 stack[2] = 0x00 // } // Block ends with call to 0xffffffff & 0x22c4, returns to 0x1DF0 label_1DF0: // Incoming return from call to 0x22C4 at 0x1DEF // Inputs[2] // { // @1DF1 stack[-1] // @1DF1 stack[-4] // } 1DF0 5B JUMPDEST 1DF1 92 SWAP3 1DF2 50 POP 1DF3 50 POP 1DF4 50 POP 1DF5 61 PUSH2 0x1e66 1DF8 56 *JUMP // Stack delta = -3 // Outputs[1] { @1DF1 stack[-4] = stack[-1] } // Block ends with unconditional jump to 0x1e66 label_1DF9: // Incoming jump from 0x1DD9, if !(stack[-3] < storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @1E02 stack[-2] } 1DF9 5B JUMPDEST 1DFA 60 PUSH1 0x00 1DFC 80 DUP1 1DFD 90 SWAP1 1DFE 50 POP 1DFF 5B JUMPDEST 1E00 60 PUSH1 0x01 1E02 83 DUP4 1E03 03 SUB 1E04 81 DUP2 1E05 10 LT 1E06 15 ISZERO 1E07 61 PUSH2 0x1e5e 1E0A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1DFD stack[0] = 0x00 } // Block ends with conditional jump to 0x1e5e, if !(0x00 < stack[-2] - 0x01) label_1E0B: // Incoming jump from 0x1E0A, if not !(stack[-1] < stack[-3] - 0x01) // Incoming jump from 0x1E0A, if not !(0x00 < stack[-2] - 0x01) // Inputs[5] // { // @1E0D stack[-2] // @1E10 stack[-6] // @1E24 memory[0x00:0x40] // @1E25 storage[keccak256(memory[0x00:0x40])] // @1E29 stack[-5] // } 1E0B 60 PUSH1 0x00 1E0D 82 DUP3 1E0E 90 SWAP1 1E0F 50 POP 1E10 86 DUP7 1E11 60 PUSH1 0x01 1E13 01 ADD 1E14 60 PUSH1 0x00 1E16 82 DUP3 1E17 81 DUP2 1E18 52 MSTORE 1E19 60 PUSH1 0x20 1E1B 01 ADD 1E1C 90 SWAP1 1E1D 81 DUP2 1E1E 52 MSTORE 1E1F 60 PUSH1 0x20 1E21 01 ADD 1E22 60 PUSH1 0x00 1E24 20 SHA3 1E25 54 SLOAD 1E26 92 SWAP3 1E27 50 POP 1E28 82 DUP3 1E29 86 DUP7 1E2A 10 LT 1E2B 15 ISZERO 1E2C 61 PUSH2 0x1e50 1E2F 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1E0E stack[0] = stack[-2] // @1E18 memory[0x00:0x20] = stack[-2] // @1E1E memory[0x20:0x40] = 0x01 + stack[-6] // @1E26 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1e50, if !(stack[-5] < storage[keccak256(memory[0x00:0x40])]) label_1E30: // Incoming jump from 0x1E2F, if not !(stack[-5] < storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @1E33 stack[-1] // @1E34 stack[-7] // } 1E30 61 PUSH2 0x1e45 1E33 81 DUP2 1E34 88 DUP9 1E35 60 PUSH1 0x02 1E37 01 ADD 1E38 61 PUSH2 0x22c4 1E3B 90 SWAP1 1E3C 91 SWAP2 1E3D 90 SWAP1 1E3E 63 PUSH4 0xffffffff 1E43 16 AND 1E44 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E30 stack[0] = 0x1e45 // @1E3C stack[1] = 0x02 + stack[-7] // @1E3D stack[2] = stack[-1] // } // Block ends with call to 0xffffffff & 0x22c4, returns to 0x1E45 label_1E45: // Incoming return from call to 0x22C4 at 0x1E44 // Inputs[2] // { // @1E46 stack[-1] // @1E46 stack[-6] // } 1E45 5B JUMPDEST 1E46 94 SWAP5 1E47 50 POP 1E48 50 POP 1E49 50 POP 1E4A 50 POP 1E4B 50 POP 1E4C 61 PUSH2 0x1e66 1E4F 56 *JUMP // Stack delta = -5 // Outputs[1] { @1E46 stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x1e66 label_1E50: // Incoming jump from 0x1E2F, if !(stack[-5] < storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @1E52 stack[-2] } 1E50 5B JUMPDEST 1E51 50 POP 1E52 80 DUP1 1E53 80 DUP1 1E54 60 PUSH1 0x01 1E56 01 ADD 1E57 91 SWAP2 1E58 50 POP 1E59 50 POP 1E5A 61 PUSH2 0x1dff 1E5D 56 *JUMP // Stack delta = -1 // Outputs[1] { @1E57 stack[-2] = 0x01 + stack[-2] } // Block ends with unconditional jump to 0x1dff label_1E5E: // Incoming jump from 0x1E0A, if !(stack[-1] < stack[-3] - 0x01) // Incoming jump from 0x1E0A, if !(0x00 < stack[-2] - 0x01) // Inputs[3] // { // @1E62 stack[-4] // @1E67 stack[-7] // @1E68 stack[-6] // } 1E5E 5B JUMPDEST 1E5F 50 POP 1E60 60 PUSH1 0x00 1E62 92 SWAP3 1E63 50 POP 1E64 50 POP 1E65 50 POP 1E66 5B JUMPDEST 1E67 92 SWAP3 1E68 91 SWAP2 1E69 50 POP 1E6A 50 POP 1E6B 56 *JUMP // Stack delta = -6 // Outputs[1] { @1E67 stack[-7] = 0x00 } // Block ends with unconditional jump to stack[-7] label_1E6C: // Incoming call from 0x0E61, returns to 0x0E62 // Inputs[3] // { // @1E7D stack[-2] // @1E83 stack[-1] // @1EBD memory[0x00:0x40] // } 1E6C 5B JUMPDEST 1E6D 60 PUSH1 0x00 1E6F 80 DUP1 1E70 60 PUSH1 0x00 1E72 90 SWAP1 1E73 50 POP 1E74 60 PUSH1 0x00 1E76 80 DUP1 1E77 90 SWAP1 1E78 50 POP 1E79 5B JUMPDEST 1E7A 61 PUSH2 0x1ec2 1E7D 85 DUP6 1E7E 60 PUSH1 0x00 1E80 01 ADD 1E81 60 PUSH1 0x00 1E83 86 DUP7 1E84 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E99 16 AND 1E9A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EAF 16 AND 1EB0 81 DUP2 1EB1 52 MSTORE 1EB2 60 PUSH1 0x20 1EB4 01 ADD 1EB5 90 SWAP1 1EB6 81 DUP2 1EB7 52 MSTORE 1EB8 60 PUSH1 0x20 1EBA 01 ADD 1EBB 60 PUSH1 0x00 1EBD 20 SHA3 1EBE 61 PUSH2 0x226b 1EC1 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1E6D stack[0] = 0x00 // @1E72 stack[1] = 0x00 // @1E77 stack[2] = 0x00 // @1E7A stack[3] = 0x1ec2 // @1EB1 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1EB7 memory[0x20:0x40] = 0x00 + stack[-2] // @1EBD stack[4] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x226b, returns to 0x1EC2 label_1EC2: // Incoming return from call to 0x226B at 0x1EC1 // Incoming return from call to 0x226B at 0x1EC1 // Inputs[2] // { // @1EC3 stack[-2] // @1EC4 stack[-1] // } 1EC2 5B JUMPDEST 1EC3 81 DUP2 1EC4 10 LT 1EC5 15 ISZERO 1EC6 61 PUSH2 0x1f50 1EC9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1f50, if !(stack[-2] < stack[-1]) label_1ECA: // Incoming jump from 0x1EC9, if not !(stack[-2] < stack[-1]) // Inputs[4] // { // @1ECF stack[-1] // @1ED0 stack[-5] // @1ED6 stack[-4] // @1F10 memory[0x00:0x40] // } 1ECA 60 PUSH1 0x00 1ECC 61 PUSH2 0x1f1e 1ECF 82 DUP3 1ED0 87 DUP8 1ED1 60 PUSH1 0x00 1ED3 01 ADD 1ED4 60 PUSH1 0x00 1ED6 88 DUP9 1ED7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EEC 16 AND 1EED 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F02 16 AND 1F03 81 DUP2 1F04 52 MSTORE 1F05 60 PUSH1 0x20 1F07 01 ADD 1F08 90 SWAP1 1F09 81 DUP2 1F0A 52 MSTORE 1F0B 60 PUSH1 0x20 1F0D 01 ADD 1F0E 60 PUSH1 0x00 1F10 20 SHA3 1F11 61 PUSH2 0x2251 1F14 90 SWAP1 1F15 91 SWAP2 1F16 90 SWAP1 1F17 63 PUSH4 0xffffffff 1F1C 16 AND 1F1D 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1ECA stack[0] = 0x00 // @1ECC stack[1] = 0x1f1e // @1F04 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @1F0A memory[0x20:0x40] = 0x00 + stack[-5] // @1F15 stack[2] = keccak256(memory[0x00:0x40]) // @1F16 stack[3] = stack[-1] // } // Block ends with call to 0xffffffff & 0x2251, returns to 0x1F1E label_1F1E: // Incoming return from call to 0x2251 at 0x1F1D // Inputs[7] // { // @1F1F stack[-1] // @1F1F stack[-2] // @1F23 stack[-7] // @1F37 memory[0x00:0x40] // @1F38 storage[keccak256(memory[0x00:0x40])] // @1F3E stack[-4] // @1F44 stack[-3] // } 1F1E 5B JUMPDEST 1F1F 90 SWAP1 1F20 50 POP 1F21 60 PUSH1 0x00 1F23 86 DUP7 1F24 60 PUSH1 0x01 1F26 01 ADD 1F27 60 PUSH1 0x00 1F29 83 DUP4 1F2A 81 DUP2 1F2B 52 MSTORE 1F2C 60 PUSH1 0x20 1F2E 01 ADD 1F2F 90 SWAP1 1F30 81 DUP2 1F31 52 MSTORE 1F32 60 PUSH1 0x20 1F34 01 ADD 1F35 60 PUSH1 0x00 1F37 20 SHA3 1F38 54 SLOAD 1F39 90 SWAP1 1F3A 50 POP 1F3B 81 DUP2 1F3C 81 DUP2 1F3D 03 SUB 1F3E 84 DUP5 1F3F 01 ADD 1F40 93 SWAP4 1F41 50 POP 1F42 50 POP 1F43 50 POP 1F44 80 DUP1 1F45 80 DUP1 1F46 60 PUSH1 0x01 1F48 01 ADD 1F49 91 SWAP2 1F4A 50 POP 1F4B 50 POP 1F4C 61 PUSH2 0x1e79 1F4F 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @1F2B memory[0x00:0x20] = stack[-1] // @1F31 memory[0x20:0x40] = 0x01 + stack[-7] // @1F40 stack[-4] = stack[-4] + (storage[keccak256(memory[0x00:0x40])] - stack[-1]) // @1F49 stack[-3] = 0x01 + stack[-3] // } // Block ends with unconditional jump to 0x1e79 label_1F50: // Incoming jump from 0x1EC9, if !(stack[-2] < stack[-1]) // Inputs[4] // { // @1F52 stack[-2] // @1F53 stack[-3] // @1F56 stack[-6] // @1F57 stack[-5] // } 1F50 5B JUMPDEST 1F51 50 POP 1F52 80 DUP1 1F53 91 SWAP2 1F54 50 POP 1F55 50 POP 1F56 92 SWAP3 1F57 91 SWAP2 1F58 50 POP 1F59 50 POP 1F5A 56 *JUMP // Stack delta = -5 // Outputs[1] { @1F56 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_1F5B: // Incoming call from 0x12CE, returns to 0x12CF // Inputs[3] // { // @1F5F stack[-4] // @1F60 stack[-3] // @1F61 stack[-2] // } 1F5B 5B JUMPDEST 1F5C 61 PUSH2 0x1f66 1F5F 84 DUP5 1F60 84 DUP5 1F61 84 DUP5 1F62 61 PUSH2 0x1a07 1F65 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F5C stack[0] = 0x1f66 // @1F5F stack[1] = stack[-4] // @1F60 stack[2] = stack[-3] // @1F61 stack[3] = stack[-2] // } // Block ends with call to 0x1a07, returns to 0x1F66 label_1F66: // Incoming return from call to 0x1A07 at 0x1F65 // Inputs[4] // { // @1F6A stack[-4] // @1F6B stack[-3] // @1F6C stack[-2] // @1F6D stack[-1] // } 1F66 5B JUMPDEST 1F67 61 PUSH2 0x1f72 1F6A 84 DUP5 1F6B 84 DUP5 1F6C 84 DUP5 1F6D 84 DUP5 1F6E 61 PUSH2 0x22e1 1F71 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1F67 stack[0] = 0x1f72 // @1F6A stack[1] = stack[-4] // @1F6B stack[2] = stack[-3] // @1F6C stack[3] = stack[-2] // @1F6D stack[4] = stack[-1] // } // Block ends with call to 0x22e1, returns to 0x1F72 label_1F72: // Incoming return from call to 0x22E1 at 0x1F71 // Inputs[1] { @1F76 stack[-1] } 1F72 5B JUMPDEST 1F73 61 PUSH2 0x1fc7 1F76 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1fc7, if stack[-1] label_1F77: // Incoming jump from 0x1F76, if not stack[-1] // Inputs[3] // { // @1F79 memory[0x40:0x60] // @1FC1 memory[0x40:0x60] // @1FC6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1F77 60 PUSH1 0x40 1F79 51 MLOAD 1F7A 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1F9B 81 DUP2 1F9C 52 MSTORE 1F9D 60 PUSH1 0x04 1F9F 01 ADD 1FA0 80 DUP1 1FA1 80 DUP1 1FA2 60 PUSH1 0x20 1FA4 01 ADD 1FA5 82 DUP3 1FA6 81 DUP2 1FA7 03 SUB 1FA8 82 DUP3 1FA9 52 MSTORE 1FAA 60 PUSH1 0x32 1FAC 81 DUP2 1FAD 52 MSTORE 1FAE 60 PUSH1 0x20 1FB0 01 ADD 1FB1 80 DUP1 1FB2 61 PUSH2 0x2f6f 1FB5 60 PUSH1 0x32 1FB7 91 SWAP2 1FB8 39 CODECOPY 1FB9 60 PUSH1 0x40 1FBB 01 ADD 1FBC 91 SWAP2 1FBD 50 POP 1FBE 50 POP 1FBF 60 PUSH1 0x40 1FC1 51 MLOAD 1FC2 80 DUP1 1FC3 91 SWAP2 1FC4 03 SUB 1FC5 90 SWAP1 1FC6 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1F9C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1FA9 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1FAD memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x32 // @1FB8 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x32] = code[0x2f6f:0x2fa1] // @1FC6 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1FC7: // Incoming jump from 0x1F76, if stack[-1] // Inputs[1] { @1FCC stack[-5] } 1FC7 5B JUMPDEST 1FC8 50 POP 1FC9 50 POP 1FCA 50 POP 1FCB 50 POP 1FCC 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_1FCD: // Incoming call from 0x14DF, returns to 0x14E0 // Inputs[1] { @1FD2 stack[-1] } 1FCD 5B JUMPDEST 1FCE 60 PUSH1 0x60 1FD0 60 PUSH1 0x00 1FD2 82 DUP3 1FD3 14 EQ 1FD4 15 ISZERO 1FD5 61 PUSH2 0x2015 1FD8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1FCE stack[0] = 0x60 } // Block ends with conditional jump to 0x2015, if !(stack[-1] == 0x00) label_1FD9: // Incoming jump from 0x1FD8, if not !(stack[-1] == 0x00) // Inputs[2] // { // @1FDB memory[0x40:0x60] // @200F stack[-1] // } 1FD9 60 PUSH1 0x40 1FDB 51 MLOAD 1FDC 80 DUP1 1FDD 60 PUSH1 0x40 1FDF 01 ADD 1FE0 60 PUSH1 0x40 1FE2 52 MSTORE 1FE3 80 DUP1 1FE4 60 PUSH1 0x01 1FE6 81 DUP2 1FE7 52 MSTORE 1FE8 60 PUSH1 0x20 1FEA 01 ADD 1FEB 7F PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 200C 81 DUP2 200D 52 MSTORE 200E 50 POP 200F 90 SWAP1 2010 50 POP 2011 61 PUSH2 0x20f8 2014 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1FE2 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1FE7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @200D memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x3000000000000000000000000000000000000000000000000000000000000000 // @200F stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x20f8 label_2015: // Incoming jump from 0x1FD8, if !(stack[-1] == 0x00) // Inputs[1] { @2018 stack[-2] } 2015 5B JUMPDEST 2016 60 PUSH1 0x00 2018 82 DUP3 2019 90 SWAP1 201A 50 POP 201B 60 PUSH1 0x00 201D 5B JUMPDEST 201E 60 PUSH1 0x00 2020 82 DUP3 2021 14 EQ 2022 61 PUSH2 0x203f 2025 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2019 stack[0] = stack[-2] // @201B stack[1] = 0x00 // } // Block ends with conditional jump to 0x203f, if stack[-2] == 0x00 label_2026: // Incoming jump from 0x2025, if not stack[-2] == 0x00 // Incoming jump from 0x2025, if not stack[-2] == 0x00 // Inputs[2] // { // @2026 stack[-1] // @2030 stack[-2] // } 2026 80 DUP1 2027 80 DUP1 2028 60 PUSH1 0x01 202A 01 ADD 202B 91 SWAP2 202C 50 POP 202D 50 POP 202E 60 PUSH1 0x0a 2030 82 DUP3 2031 81 DUP2 2032 61 PUSH2 0x2037 2035 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @202B stack[-1] = 0x01 + stack[-1] // @202E stack[0] = 0x0a // @2030 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x2037, if 0x0a label_2036: // Incoming jump from 0x2035, if not 0x0a 2036 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2036 assert(); } // Block terminates label_2037: // Incoming jump from 0x2035, if 0x0a // Inputs[3] // { // @2038 stack[-1] // @2038 stack[-2] // @2039 stack[-4] // } 2037 5B JUMPDEST 2038 04 DIV 2039 91 SWAP2 203A 50 POP 203B 61 PUSH2 0x201d 203E 56 *JUMP // Stack delta = -2 // Outputs[1] { @2039 stack[-4] = stack[-1] / stack[-2] } // Block ends with unconditional jump to 0x201d label_203F: // Incoming jump from 0x2025, if stack[-2] == 0x00 // Incoming jump from 0x2025, if stack[-2] == 0x00 // Inputs[2] // { // @2042 stack[-1] // @2045 memory[0x40:0x60] // } 203F 5B JUMPDEST 2040 60 PUSH1 0x60 2042 81 DUP2 2043 60 PUSH1 0x40 2045 51 MLOAD 2046 90 SWAP1 2047 80 DUP1 2048 82 DUP3 2049 52 MSTORE 204A 80 DUP1 204B 60 PUSH1 0x1f 204D 01 ADD 204E 60 PUSH1 0x1f 2050 19 NOT 2051 16 AND 2052 60 PUSH1 0x20 2054 01 ADD 2055 82 DUP3 2056 01 ADD 2057 60 PUSH1 0x40 2059 52 MSTORE 205A 80 DUP1 205B 15 ISZERO 205C 61 PUSH2 0x2074 205F 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @2040 stack[0] = 0x60 // @2046 stack[1] = memory[0x40:0x60] // @2046 stack[2] = stack[-1] // @2049 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @2059 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x2074, if !stack[-1] label_2060: // Incoming jump from 0x205F, if not !stack[-1] // Inputs[7] // { // @2060 stack[-2] // @2066 stack[-1] // @2069 code.length // @2076 stack[-3] // @207C stack[-4] // @2080 stack[-7] // @2081 stack[-5] // } 2060 81 DUP2 2061 60 PUSH1 0x20 2063 01 ADD 2064 60 PUSH1 0x01 2066 82 DUP3 2067 02 MUL 2068 80 DUP1 2069 38 CODESIZE 206A 83 DUP4 206B 39 CODECOPY 206C 80 DUP1 206D 82 DUP3 206E 01 ADD 206F 91 SWAP2 2070 50 POP 2071 50 POP 2072 90 SWAP1 2073 50 POP 2074 5B JUMPDEST 2075 50 POP 2076 90 SWAP1 2077 50 POP 2078 60 PUSH1 0x00 207A 60 PUSH1 0x01 207C 83 DUP4 207D 03 SUB 207E 90 SWAP1 207F 50 POP 2080 85 DUP6 2081 93 SWAP4 2082 50 POP 2083 5B JUMPDEST 2084 60 PUSH1 0x00 2086 84 DUP5 2087 14 EQ 2088 61 PUSH2 0x20f0 208B 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @206B memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x01] = code[code.length:code.length + stack[-1] * 0x01] // @2076 stack[-3] = stack[-2] // @207E stack[-2] = stack[-4] - 0x01 // @2081 stack[-5] = stack[-7] // } // Block ends with conditional jump to 0x20f0, if stack[-7] == 0x00 label_208C: // Incoming jump from 0x208B, if not stack[-4] == 0x00 // Incoming jump from 0x208B, if not stack[-7] == 0x00 // Incoming jump from 0x208B, if not stack[-7] == 0x00 // Inputs[1] { @208E stack[-4] } 208C 60 PUSH1 0x0a 208E 84 DUP5 208F 81 DUP2 2090 61 PUSH2 0x2095 2093 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @208C stack[0] = 0x0a // @208E stack[1] = stack[-4] // } // Block ends with conditional jump to 0x2095, if 0x0a label_2094: // Incoming jump from 0x2093, if not 0x0a 2094 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2094 assert(); } // Block terminates label_2095: // Incoming jump from 0x2093, if 0x0a // Inputs[5] // { // @2096 stack[-2] // @2096 stack[-1] // @209D stack[-4] // @209E stack[-3] // @20A7 memory[stack[-4]:stack[-4] + 0x20] // } 2095 5B JUMPDEST 2096 06 MOD 2097 60 PUSH1 0x30 2099 01 ADD 209A 60 PUSH1 0xf8 209C 1B SHL 209D 82 DUP3 209E 82 DUP3 209F 80 DUP1 20A0 60 PUSH1 0x01 20A2 90 SWAP1 20A3 03 SUB 20A4 93 SWAP4 20A5 50 POP 20A6 81 DUP2 20A7 51 MLOAD 20A8 81 DUP2 20A9 10 LT 20AA 61 PUSH2 0x20af 20AD 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @209C stack[-2] = 0x30 + stack[-1] % stack[-2] << 0xf8 // @209D stack[-1] = stack[-4] // @209E stack[0] = stack[-3] // @20A4 stack[-3] = stack[-3] - 0x01 // } // Block ends with conditional jump to 0x20af, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_20AE: // Incoming jump from 0x20AD, if not stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 20AE FE *ASSERT // Stack delta = +0 // Outputs[1] { @20AE assert(); } // Block terminates label_20AF: // Incoming jump from 0x20AD, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @20B2 stack[-1] // @20B3 stack[-2] // @20B4 stack[-3] // @20E1 stack[-7] // } 20AF 5B JUMPDEST 20B0 60 PUSH1 0x20 20B2 01 ADD 20B3 01 ADD 20B4 90 SWAP1 20B5 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 20D5 19 NOT 20D6 16 AND 20D7 90 SWAP1 20D8 81 DUP2 20D9 60 PUSH1 0x00 20DB 1A BYTE 20DC 90 SWAP1 20DD 53 MSTORE8 20DE 50 POP 20DF 60 PUSH1 0x0a 20E1 84 DUP5 20E2 81 DUP2 20E3 61 PUSH2 0x20e8 20E6 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @20DD memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @20DF stack[-3] = 0x0a // @20E1 stack[-2] = stack[-7] // } // Block ends with conditional jump to 0x20e8, if 0x0a label_20E7: // Incoming jump from 0x20E6, if not 0x0a 20E7 FE *ASSERT // Stack delta = +0 // Outputs[1] { @20E7 assert(); } // Block terminates label_20E8: // Incoming jump from 0x20E6, if 0x0a // Inputs[3] // { // @20E9 stack[-2] // @20E9 stack[-1] // @20EA stack[-6] // } 20E8 5B JUMPDEST 20E9 04 DIV 20EA 93 SWAP4 20EB 50 POP 20EC 61 PUSH2 0x2083 20EF 56 *JUMP // Stack delta = -2 // Outputs[1] { @20EA stack[-6] = stack[-1] / stack[-2] } // Block ends with unconditional jump to 0x2083 label_20F0: // Incoming jump from 0x208B, if stack[-4] == 0x00 // Incoming jump from 0x208B, if stack[-7] == 0x00 // Incoming jump from 0x208B, if stack[-7] == 0x00 // Inputs[2] // { // @20F1 stack[-2] // @20F2 stack[-5] // } 20F0 5B JUMPDEST 20F1 81 DUP2 20F2 94 SWAP5 20F3 50 POP 20F4 50 POP 20F5 50 POP 20F6 50 POP 20F7 50 POP // Stack delta = -4 // Outputs[1] { @20F2 stack[-5] = stack[-2] } // Block continues label_20F8: // Incoming jump from 0x2014 // Incoming jump from 0x20F7 // Inputs[3] // { // @20F9 stack[-1] // @20F9 stack[-3] // @20FA stack[-2] // } 20F8 5B JUMPDEST 20F9 91 SWAP2 20FA 90 SWAP1 20FB 50 POP 20FC 56 *JUMP // Stack delta = -2 // Outputs[1] { @20F9 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_20FD: // Incoming call from 0x1B23, returns to 0x1B24 // Inputs[1] { @2101 stack[-4] } 20FD 5B JUMPDEST 20FE 50 POP 20FF 50 POP 2100 50 POP 2101 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_2102: // Incoming call from 0x1B44, returns to 0x1B45 // Inputs[1] { @2109 stack[-3] } 2102 5B JUMPDEST 2103 60 PUSH1 0x00 2105 80 DUP1 2106 61 PUSH2 0x2111 2109 85 DUP6 210A 60 PUSH1 0x02 210C 01 ADD 210D 61 PUSH2 0x2280 2110 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2103 stack[0] = 0x00 // @2105 stack[1] = 0x00 // @2106 stack[2] = 0x2111 // @210C stack[3] = 0x02 + stack[-3] // } // Block ends with call to 0x2280, returns to 0x2111 label_2111: // Incoming return from call to 0x2280 at 0x2110 // Inputs[4] // { // @2112 stack[-2] // @2112 stack[-1] // @2114 stack[-6] // @2118 storage[0x06 + stack[-6]] // } 2111 5B JUMPDEST 2112 90 SWAP1 2113 50 POP 2114 84 DUP5 2115 60 PUSH1 0x06 2117 01 ADD 2118 54 SLOAD 2119 81 DUP2 211A 11 GT 211B 15 ISZERO 211C 61 PUSH2 0x2178 211F 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2112 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x2178, if !(stack[-1] > storage[0x06 + stack[-6]]) label_2120: // Incoming jump from 0x211F, if not !(stack[-1] > storage[0x06 + stack[-6]]) // Inputs[2] // { // @2126 stack[-4] // @2127 stack[-5] // } 2120 60 PUSH1 0x00 2122 80 DUP1 2123 61 PUSH2 0x2138 2126 86 DUP7 2127 88 DUP9 2128 60 PUSH1 0x02 212A 01 ADD 212B 61 PUSH2 0x2295 212E 90 SWAP1 212F 91 SWAP2 2130 90 SWAP1 2131 63 PUSH4 0xffffffff 2136 16 AND 2137 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2120 stack[0] = 0x00 // @2122 stack[1] = 0x00 // @2123 stack[2] = 0x2138 // @212F stack[3] = 0x02 + stack[-5] // @2130 stack[4] = stack[-4] // } // Block ends with call to 0xffffffff & 0x2295, returns to 0x2138 label_2138: // Incoming return from call to 0x2295 at 0x2137 // Inputs[4] // { // @2139 stack[-3] // @2139 stack[-1] // @213B stack[-4] // @213B stack[-2] // } 2138 5B JUMPDEST 2139 91 SWAP2 213A 50 POP 213B 91 SWAP2 213C 50 POP 213D 81 DUP2 213E 15 ISZERO 213F 61 PUSH2 0x2175 2142 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2139 stack[-3] = stack[-1] // @213B stack[-4] = stack[-2] // } // Block ends with conditional jump to 0x2175, if !stack[-2] label_2143: // Incoming jump from 0x2142, if not !stack[-2] // Inputs[6] // { // @2145 stack[-7] // @214B stack[-6] // @2159 memory[0x00:0x40] // @215A storage[keccak256(memory[0x00:0x40])] // @2164 stack[-1] // @2165 stack[-5] // } 2143 60 PUSH1 0x00 2145 87 DUP8 2146 60 PUSH1 0x01 2148 01 ADD 2149 60 PUSH1 0x00 214B 88 DUP9 214C 81 DUP2 214D 52 MSTORE 214E 60 PUSH1 0x20 2150 01 ADD 2151 90 SWAP1 2152 81 DUP2 2153 52 MSTORE 2154 60 PUSH1 0x20 2156 01 ADD 2157 60 PUSH1 0x00 2159 20 SHA3 215A 54 SLOAD 215B 90 SWAP1 215C 50 POP 215D 61 PUSH2 0x216a 2160 88 DUP9 2161 88 DUP9 2162 89 DUP10 2163 84 DUP5 2164 86 DUP7 2165 8B DUP12 2166 61 PUSH2 0x2526 2169 56 *JUMP // Stack delta = +8 // Outputs[10] // { // @214D memory[0x00:0x20] = stack[-6] // @2153 memory[0x20:0x40] = 0x01 + stack[-7] // @215B stack[0] = storage[keccak256(memory[0x00:0x40])] // @215D stack[1] = 0x216a // @2160 stack[2] = stack[-7] // @2161 stack[3] = stack[-6] // @2162 stack[4] = stack[-6] // @2163 stack[5] = storage[keccak256(memory[0x00:0x40])] // @2164 stack[6] = stack[-1] // @2165 stack[7] = stack[-5] // } // Block ends with call to 0x2526, returns to 0x216A label_216A: // Incoming return from call to 0x2526 at 0x2169 // Inputs[2] // { // @216B stack[-6] // @216B stack[-1] // } 216A 5B JUMPDEST 216B 94 SWAP5 216C 50 POP 216D 50 POP 216E 50 POP 216F 50 POP 2170 50 POP 2171 61 PUSH2 0x224a 2174 56 *JUMP // Stack delta = -5 // Outputs[1] { @216B stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x224a label_2175: // Incoming jump from 0x2142, if !stack[-2] 2175 5B JUMPDEST 2176 50 POP 2177 50 POP // Stack delta = -2 // Block continues label_2178: // Incoming jump from 0x211F, if !(stack[-1] > storage[0x06 + stack[-6]]) // Incoming jump from 0x2177 // Inputs[1] { @2180 stack[-5] } 2178 5B JUMPDEST 2179 60 PUSH1 0x00 217B 61 PUSH2 0x2191 217E 60 PUSH1 0x00 2180 87 DUP8 2181 60 PUSH1 0x02 2183 01 ADD 2184 61 PUSH2 0x22c4 2187 90 SWAP1 2188 91 SWAP2 2189 90 SWAP1 218A 63 PUSH4 0xffffffff 218F 16 AND 2190 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2179 stack[0] = 0x00 // @217B stack[1] = 0x2191 // @2188 stack[2] = 0x02 + stack[-5] // @2189 stack[3] = 0x00 // } // Block ends with call to 0xffffffff & 0x22c4, returns to 0x2191 label_2191: // Incoming return from call to 0x22C4 at 0x2190 // Inputs[6] // { // @2192 stack[-2] // @2192 stack[-1] // @2196 stack[-7] // @21AA memory[0x00:0x40] // @21AB storage[keccak256(memory[0x00:0x40])] // @21AF stack[-6] // } 2191 5B JUMPDEST 2192 90 SWAP1 2193 50 POP 2194 60 PUSH1 0x00 2196 86 DUP7 2197 60 PUSH1 0x01 2199 01 ADD 219A 60 PUSH1 0x00 219C 80 DUP1 219D 81 DUP2 219E 52 MSTORE 219F 60 PUSH1 0x20 21A1 01 ADD 21A2 90 SWAP1 21A3 81 DUP2 21A4 52 MSTORE 21A5 60 PUSH1 0x20 21A7 01 ADD 21A8 60 PUSH1 0x00 21AA 20 SHA3 21AB 54 SLOAD 21AC 90 SWAP1 21AD 50 POP 21AE 80 DUP1 21AF 86 DUP7 21B0 10 LT 21B1 15 ISZERO 21B2 61 PUSH2 0x21ce 21B5 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2192 stack[-2] = stack[-1] // @219E memory[0x00:0x20] = 0x00 // @21A4 memory[0x20:0x40] = 0x01 + stack[-7] // @21AC stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x21ce, if !(stack[-6] < storage[keccak256(memory[0x00:0x40])]) label_21B6: // Incoming jump from 0x21B5, if not !(stack[-6] < storage[keccak256(memory[0x00:0x40])]) // Inputs[5] // { // @21B9 stack[-7] // @21BA stack[-6] // @21BD stack[-1] // @21BE stack[-2] // @21BF stack[-5] // } 21B6 61 PUSH2 0x21c4 21B9 87 DUP8 21BA 87 DUP8 21BB 60 PUSH1 0x00 21BD 84 DUP5 21BE 86 DUP7 21BF 8A DUP11 21C0 61 PUSH2 0x2526 21C3 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @21B6 stack[0] = 0x21c4 // @21B9 stack[1] = stack[-7] // @21BA stack[2] = stack[-6] // @21BB stack[3] = 0x00 // @21BD stack[4] = stack[-1] // @21BE stack[5] = stack[-2] // @21BF stack[6] = stack[-5] // } // Block ends with call to 0x2526, returns to 0x21C4 label_21C4: // Incoming return from call to 0x2526 at 0x21C3 // Inputs[2] // { // @21C5 stack[-1] // @21C5 stack[-5] // } 21C4 5B JUMPDEST 21C5 93 SWAP4 21C6 50 POP 21C7 50 POP 21C8 50 POP 21C9 50 POP 21CA 61 PUSH2 0x224a 21CD 56 *JUMP // Stack delta = -4 // Outputs[1] { @21C5 stack[-5] = stack[-1] } // Block ends with unconditional jump to 0x224a label_21CE: // Incoming jump from 0x21B5, if !(stack[-6] < storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @21D7 stack[-3] } 21CE 5B JUMPDEST 21CF 60 PUSH1 0x00 21D1 80 DUP1 21D2 90 SWAP1 21D3 50 POP 21D4 5B JUMPDEST 21D5 60 PUSH1 0x01 21D7 84 DUP5 21D8 03 SUB 21D9 81 DUP2 21DA 10 LT 21DB 15 ISZERO 21DC 61 PUSH2 0x2241 21DF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @21D2 stack[0] = 0x00 } // Block ends with conditional jump to 0x2241, if !(0x00 < stack[-3] - 0x01) label_21E0: // Incoming jump from 0x21DF, if not !(stack[-1] < stack[-4] - 0x01) // Incoming jump from 0x21DF, if not !(0x00 < stack[-3] - 0x01) // Inputs[5] // { // @21E2 stack[-2] // @21E5 stack[-8] // @21F9 memory[0x00:0x40] // @21FA storage[keccak256(memory[0x00:0x40])] // @21FE stack[-7] // } 21E0 60 PUSH1 0x00 21E2 82 DUP3 21E3 90 SWAP1 21E4 50 POP 21E5 88 DUP9 21E6 60 PUSH1 0x01 21E8 01 ADD 21E9 60 PUSH1 0x00 21EB 82 DUP3 21EC 81 DUP2 21ED 52 MSTORE 21EE 60 PUSH1 0x20 21F0 01 ADD 21F1 90 SWAP1 21F2 81 DUP2 21F3 52 MSTORE 21F4 60 PUSH1 0x20 21F6 01 ADD 21F7 60 PUSH1 0x00 21F9 20 SHA3 21FA 54 SLOAD 21FB 92 SWAP3 21FC 50 POP 21FD 82 DUP3 21FE 88 DUP9 21FF 10 LT 2200 15 ISZERO 2201 61 PUSH2 0x2233 2204 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @21E3 stack[0] = stack[-2] // @21ED memory[0x00:0x20] = stack[-2] // @21F3 memory[0x20:0x40] = 0x01 + stack[-8] // @21FB stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x2233, if !(stack[-7] < storage[keccak256(memory[0x00:0x40])]) label_2205: // Incoming jump from 0x2204, if not !(stack[-7] < storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @2208 stack[-9] // @2209 stack[-8] // @220A stack[-1] // @220B stack[-3] // } 2205 61 PUSH2 0x2227 2208 89 DUP10 2209 89 DUP10 220A 83 DUP4 220B 86 DUP7 220C 61 PUSH2 0x2221 220F 86 DUP7 2210 8F DUP16 2211 60 PUSH1 0x02 2213 01 ADD 2214 61 PUSH2 0x22c4 2217 90 SWAP1 2218 91 SWAP2 2219 90 SWAP1 221A 63 PUSH4 0xffffffff 221F 16 AND 2220 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @2205 stack[0] = 0x2227 // @2208 stack[1] = stack[-9] // @2209 stack[2] = stack[-8] // @220A stack[3] = stack[-1] // @220B stack[4] = stack[-3] // @220C stack[5] = 0x2221 // @2218 stack[6] = 0x02 + stack[-9] // @2219 stack[7] = stack[-1] // } // Block ends with call to 0xffffffff & 0x22c4, returns to 0x2221 label_2221: // Incoming return from call to 0x22C4 at 0x2220 // Inputs[1] { @2222 stack[-13] } 2221 5B JUMPDEST 2222 8C DUP13 2223 61 PUSH2 0x2526 2226 56 *JUMP // Stack delta = +1 // Outputs[1] { @2222 stack[0] = stack[-13] } // Block ends with unconditional jump to 0x2526 label_2227: // Incoming return from call to 0x2221 at 0x2220 // Inputs[2] // { // @2228 stack[-7] // @2228 stack[-1] // } 2227 5B JUMPDEST 2228 95 SWAP6 2229 50 POP 222A 50 POP 222B 50 POP 222C 50 POP 222D 50 POP 222E 50 POP 222F 61 PUSH2 0x224a 2232 56 *JUMP // Stack delta = -6 // Outputs[1] { @2228 stack[-7] = stack[-1] } // Block ends with unconditional jump to 0x224a label_2233: // Incoming jump from 0x2204, if !(stack[-7] < storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @2235 stack[-2] } 2233 5B JUMPDEST 2234 50 POP 2235 80 DUP1 2236 80 DUP1 2237 60 PUSH1 0x01 2239 01 ADD 223A 91 SWAP2 223B 50 POP 223C 50 POP 223D 61 PUSH2 0x21d4 2240 56 *JUMP // Stack delta = -1 // Outputs[1] { @223A stack[-2] = 0x01 + stack[-2] } // Block ends with unconditional jump to 0x21d4 label_2241: // Incoming jump from 0x21DF, if !(stack[-1] < stack[-4] - 0x01) // Incoming jump from 0x21DF, if !(0x00 < stack[-3] - 0x01) // Inputs[3] // { // @2245 stack[-5] // @224B stack[-9] // @224C stack[-8] // } 2241 5B JUMPDEST 2242 50 POP 2243 60 PUSH1 0x00 2245 93 SWAP4 2246 50 POP 2247 50 POP 2248 50 POP 2249 50 POP 224A 5B JUMPDEST 224B 93 SWAP4 224C 92 SWAP3 224D 50 POP 224E 50 POP 224F 50 POP 2250 56 *JUMP // Stack delta = -8 // Outputs[1] { @224B stack[-9] = 0x00 } // Block ends with unconditional jump to stack[-9] label_2251: // Incoming call from 0x1CF4, returns to 0x1CF5 // Incoming call from 0x1BFC, returns to 0x1BFD // Incoming call from 0x1F1D, returns to 0x1F1E // Inputs[2] // { // @2257 stack[-2] // @225B stack[-1] // } 2251 5B JUMPDEST 2252 60 PUSH1 0x00 2254 61 PUSH2 0x2260 2257 83 DUP4 2258 60 PUSH1 0x00 225A 01 ADD 225B 83 DUP4 225C 61 PUSH2 0x273a 225F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2252 stack[0] = 0x00 // @2254 stack[1] = 0x2260 // @225A stack[2] = 0x00 + stack[-2] // @225B stack[3] = stack[-1] // } // Block ends with call to 0x273a, returns to 0x2260 label_2260: // Incoming return from call to 0x273A at 0x225F // Inputs[4] // { // @2263 stack[-1] // @2264 stack[-2] // @2266 stack[-5] // @2267 stack[-4] // } 2260 5B JUMPDEST 2261 60 PUSH1 0x00 2263 1C SHR 2264 90 SWAP1 2265 50 POP 2266 92 SWAP3 2267 91 SWAP2 2268 50 POP 2269 50 POP 226A 56 *JUMP // Stack delta = -4 // Outputs[1] { @2266 stack[-5] = stack[-1] >> 0x00 } // Block ends with unconditional jump to stack[-5] label_226B: // Incoming call from 0x1C9A, returns to 0x1C9B // Incoming call from 0x1C9A, returns to 0x1C9B // Incoming call from 0x1EC1, returns to 0x1EC2 // Incoming call from 0x1EC1, returns to 0x1EC2 // Inputs[1] { @2271 stack[-1] } 226B 5B JUMPDEST 226C 60 PUSH1 0x00 226E 61 PUSH2 0x2279 2271 82 DUP3 2272 60 PUSH1 0x00 2274 01 ADD 2275 61 PUSH2 0x27bd 2278 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @226C stack[0] = 0x00 // @226E stack[1] = 0x2279 // @2274 stack[2] = 0x00 + stack[-1] // } // Block ends with call to 0x27bd, returns to 0x2279 label_2279: // Incoming return from call to 0x27BD at 0x2278 // Inputs[4] // { // @227A stack[-2] // @227A stack[-1] // @227C stack[-4] // @227D stack[-3] // } 2279 5B JUMPDEST 227A 90 SWAP1 227B 50 POP 227C 91 SWAP2 227D 90 SWAP1 227E 50 POP 227F 56 *JUMP // Stack delta = -3 // Outputs[1] { @227C stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2280: // Incoming call from 0x1D77, returns to 0x1D78 // Incoming call from 0x2110, returns to 0x2111 // Inputs[1] { @2286 stack[-1] } 2280 5B JUMPDEST 2281 60 PUSH1 0x00 2283 61 PUSH2 0x228e 2286 82 DUP3 2287 60 PUSH1 0x00 2289 01 ADD 228A 61 PUSH2 0x27ce 228D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2281 stack[0] = 0x00 // @2283 stack[1] = 0x228e // @2289 stack[2] = 0x00 + stack[-1] // } // Block ends with call to 0x27ce, returns to 0x228E label_228E: // Incoming return from call to 0x27CE at 0x228D // Inputs[4] // { // @228F stack[-2] // @228F stack[-1] // @2291 stack[-4] // @2292 stack[-3] // } 228E 5B JUMPDEST 228F 90 SWAP1 2290 50 POP 2291 91 SWAP2 2292 90 SWAP1 2293 50 POP 2294 56 *JUMP // Stack delta = -3 // Outputs[1] { @2291 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2295: // Incoming call from 0x1D9E, returns to 0x1D9F // Incoming call from 0x2137, returns to 0x2138 // Inputs[2] // { // @229F stack[-2] // @22A3 stack[-1] // } 2295 5B JUMPDEST 2296 60 PUSH1 0x00 2298 80 DUP1 2299 60 PUSH1 0x00 229B 80 DUP1 229C 61 PUSH2 0x22ab 229F 86 DUP7 22A0 60 PUSH1 0x00 22A2 01 ADD 22A3 86 DUP7 22A4 60 PUSH1 0x00 22A6 1B SHL 22A7 61 PUSH2 0x27df 22AA 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @2296 stack[0] = 0x00 // @2298 stack[1] = 0x00 // @2299 stack[2] = 0x00 // @229B stack[3] = 0x00 // @229C stack[4] = 0x22ab // @22A2 stack[5] = 0x00 + stack[-2] // @22A6 stack[6] = stack[-1] << 0x00 // } // Block ends with call to 0x27df, returns to 0x22AB label_22AB: // Incoming return from call to 0x27DF at 0x22AA // Inputs[9] // { // @22AC stack[-3] // @22AC stack[-1] // @22AE stack[-2] // @22AE stack[-4] // @22B8 stack[-5] // @22BA stack[-6] // @22BE stack[-8] // @22C0 stack[-9] // @22C1 stack[-7] // } 22AB 5B JUMPDEST 22AC 91 SWAP2 22AD 50 POP 22AE 91 SWAP2 22AF 50 POP 22B0 81 DUP2 22B1 81 DUP2 22B2 60 PUSH1 0x00 22B4 1C SHR 22B5 80 DUP1 22B6 90 SWAP1 22B7 50 POP 22B8 93 SWAP4 22B9 50 POP 22BA 93 SWAP4 22BB 50 POP 22BC 50 POP 22BD 50 POP 22BE 92 SWAP3 22BF 50 POP 22C0 92 SWAP3 22C1 90 SWAP1 22C2 50 POP 22C3 56 *JUMP // Stack delta = -7 // Outputs[2] // { // @22BE stack[-8] = stack[-1] >> 0x00 // @22C0 stack[-9] = stack[-2] // } // Block ends with unconditional jump to stack[-9] label_22C4: // Incoming call from 0x1E44, returns to 0x1E45 // Incoming call from 0x2220, returns to 0x2221 // Incoming call from 0x1DEF, returns to 0x1DF0 // Incoming call from 0x2190, returns to 0x2191 // Inputs[2] // { // @22CA stack[-2] // @22CE stack[-1] // } 22C4 5B JUMPDEST 22C5 60 PUSH1 0x00 22C7 61 PUSH2 0x22d6 22CA 83 DUP4 22CB 60 PUSH1 0x00 22CD 01 ADD 22CE 83 DUP4 22CF 60 PUSH1 0x00 22D1 1B SHL 22D2 61 PUSH2 0x284b 22D5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @22C5 stack[0] = 0x00 // @22C7 stack[1] = 0x22d6 // @22CD stack[2] = 0x00 + stack[-2] // @22D1 stack[3] = stack[-1] << 0x00 // } // Block ends with call to 0x284b, returns to 0x22D6 label_22D6: // Incoming return from call to 0x284B at 0x22D5 // Inputs[4] // { // @22D9 stack[-1] // @22DA stack[-2] // @22DC stack[-5] // @22DD stack[-4] // } 22D6 5B JUMPDEST 22D7 60 PUSH1 0x00 22D9 1C SHR 22DA 90 SWAP1 22DB 50 POP 22DC 92 SWAP3 22DD 91 SWAP2 22DE 50 POP 22DF 50 POP 22E0 56 *JUMP // Stack delta = -4 // Outputs[1] { @22DC stack[-5] = stack[-1] >> 0x00 } // Block ends with unconditional jump to stack[-5] label_22E1: // Incoming call from 0x1F71, returns to 0x1F72 // Inputs[1] { @22E7 stack[-3] } 22E1 5B JUMPDEST 22E2 60 PUSH1 0x00 22E4 61 PUSH2 0x2302 22E7 84 DUP5 22E8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 22FD 16 AND 22FE 61 PUSH2 0x290a 2301 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @22E2 stack[0] = 0x00 // @22E4 stack[1] = 0x2302 // @22FD stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // } // Block ends with call to 0x290a, returns to 0x2302 label_2302: // Incoming return from call to 0x290A at 0x2301 // Inputs[1] { @2306 stack[-1] } 2302 5B JUMPDEST 2303 61 PUSH2 0x230f 2306 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x230f, if stack[-1] label_2307: // Incoming jump from 0x2306, if not stack[-1] // Inputs[1] { @2309 stack[-1] } 2307 60 PUSH1 0x01 2309 90 SWAP1 230A 50 POP 230B 61 PUSH2 0x251e 230E 56 *JUMP // Stack delta = +0 // Outputs[1] { @2309 stack[-1] = 0x01 } // Block ends with unconditional jump to 0x251e label_230F: // Incoming jump from 0x2306, if stack[-1] 230F 5B JUMPDEST 2310 60 PUSH1 0x60 2312 61 PUSH2 0x24a5 2315 63 PUSH4 0x150b7a02 231A 60 PUSH1 0xe0 231C 1B SHL 231D 61 PUSH2 0x2324 2320 61 PUSH2 0x1844 2323 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2310 stack[0] = 0x60 // @2312 stack[1] = 0x24a5 // @231C stack[2] = 0x150b7a02 << 0xe0 // @231D stack[3] = 0x2324 // } // Block ends with call to 0x1844, returns to 0x2324 label_2324: // Incoming return from call to 0x1844 at 0x2323 // Inputs[7] // { // @2325 stack[-9] // @2326 stack[-7] // @2327 stack[-6] // @232A memory[0x40:0x60] // @232F stack[-1] // @23A5 memory[stack[-6]:stack[-6] + 0x20] // @23AE memory[stack[-6]:stack[-6] + 0x20] // } 2324 5B JUMPDEST 2325 88 DUP9 2326 87 DUP8 2327 87 DUP8 2328 60 PUSH1 0x40 232A 51 MLOAD 232B 60 PUSH1 0x24 232D 01 ADD 232E 80 DUP1 232F 85 DUP6 2330 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2345 16 AND 2346 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 235B 16 AND 235C 81 DUP2 235D 52 MSTORE 235E 60 PUSH1 0x20 2360 01 ADD 2361 84 DUP5 2362 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2377 16 AND 2378 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 238D 16 AND 238E 81 DUP2 238F 52 MSTORE 2390 60 PUSH1 0x20 2392 01 ADD 2393 83 DUP4 2394 81 DUP2 2395 52 MSTORE 2396 60 PUSH1 0x20 2398 01 ADD 2399 80 DUP1 239A 60 PUSH1 0x20 239C 01 ADD 239D 82 DUP3 239E 81 DUP2 239F 03 SUB 23A0 82 DUP3 23A1 52 MSTORE 23A2 83 DUP4 23A3 81 DUP2 23A4 81 DUP2 23A5 51 MLOAD 23A6 81 DUP2 23A7 52 MSTORE 23A8 60 PUSH1 0x20 23AA 01 ADD 23AB 91 SWAP2 23AC 50 POP 23AD 80 DUP1 23AE 51 MLOAD 23AF 90 SWAP1 23B0 60 PUSH1 0x20 23B2 01 ADD 23B3 90 SWAP1 23B4 80 DUP1 23B5 83 DUP4 23B6 83 DUP4 23B7 60 PUSH1 0x00 23B9 5B JUMPDEST 23BA 83 DUP4 23BB 81 DUP2 23BC 10 LT 23BD 15 ISZERO 23BE 61 PUSH2 0x23d4 23C1 57 *JUMPI // Stack delta = +12 // Outputs[17] // { // @2325 stack[0] = stack[-9] // @2326 stack[1] = stack[-7] // @2327 stack[2] = stack[-6] // @232D stack[3] = 0x24 + memory[0x40:0x60] // @235D memory[0x24 + memory[0x40:0x60]:0x24 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @238F memory[0x20 + 0x24 + memory[0x40:0x60]:0x20 + 0x24 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-9] // @2395 memory[0x20 + 0x20 + 0x24 + memory[0x40:0x60]:0x20 + 0x20 + 0x24 + memory[0x40:0x60] + 0x20] = stack[-7] // @2398 stack[4] = 0x20 + 0x20 + 0x20 + 0x24 + memory[0x40:0x60] // @23A1 memory[0x20 + 0x20 + 0x20 + 0x24 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x24 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x24 + memory[0x40:0x60]) - (0x24 + memory[0x40:0x60]) // @23A7 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x24 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x24 + memory[0x40:0x60] + 0x20] = memory[stack[-6]:stack[-6] + 0x20] // @23AB stack[5] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x24 + memory[0x40:0x60] // @23B3 stack[6] = 0x20 + stack[-6] // @23B3 stack[7] = memory[stack[-6]:stack[-6] + 0x20] // @23B4 stack[8] = memory[stack[-6]:stack[-6] + 0x20] // @23B5 stack[9] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x24 + memory[0x40:0x60] // @23B6 stack[10] = 0x20 + stack[-6] // @23B7 stack[11] = 0x00 // } // Block ends with conditional jump to 0x23d4, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_23C2: // Incoming jump from 0x23C1, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x23C1, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[4] // { // @23C2 stack[-1] // @23C3 stack[-2] // @23C5 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @23C7 stack[-3] // } 23C2 80 DUP1 23C3 82 DUP3 23C4 01 ADD 23C5 51 MLOAD 23C6 81 DUP2 23C7 84 DUP5 23C8 01 ADD 23C9 52 MSTORE 23CA 60 PUSH1 0x20 23CC 81 DUP2 23CD 01 ADD 23CE 90 SWAP1 23CF 50 POP 23D0 61 PUSH2 0x23b9 23D3 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @23C9 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @23CE stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x23b9 label_23D4: // Incoming jump from 0x23C1, if !(stack[-1] < stack[-4]) // Incoming jump from 0x23C1, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[3] // { // @23D9 stack[-5] // @23D9 stack[-6] // @23DB stack[-7] // } 23D4 5B JUMPDEST 23D5 50 POP 23D6 50 POP 23D7 50 POP 23D8 50 POP 23D9 90 SWAP1 23DA 50 POP 23DB 90 SWAP1 23DC 81 DUP2 23DD 01 ADD 23DE 90 SWAP1 23DF 60 PUSH1 0x1f 23E1 16 AND 23E2 80 DUP1 23E3 15 ISZERO 23E4 61 PUSH2 0x2401 23E7 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @23DE stack[-7] = stack[-5] + stack[-7] // @23E1 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x2401, if !(0x1f & stack[-5]) label_23E8: // Incoming jump from 0x23E7, if not !(0x1f & stack[-5]) // Inputs[9] // { // @23E8 stack[-1] // @23E9 stack[-2] // @23EC memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @2403 stack[-8] // @240C memory[0x40:0x60] // @2419 stack[-9] // @243E memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @2469 memory[0x40:0x60] // @2480 stack[-15] // } 23E8 80 DUP1 23E9 82 DUP3 23EA 03 SUB 23EB 80 DUP1 23EC 51 MLOAD 23ED 60 PUSH1 0x01 23EF 83 DUP4 23F0 60 PUSH1 0x20 23F2 03 SUB 23F3 61 PUSH2 0x0100 23F6 0A EXP 23F7 03 SUB 23F8 19 NOT 23F9 16 AND 23FA 81 DUP2 23FB 52 MSTORE 23FC 60 PUSH1 0x20 23FE 01 ADD 23FF 91 SWAP2 2400 50 POP 2401 5B JUMPDEST 2402 50 POP 2403 95 SWAP6 2404 50 POP 2405 50 POP 2406 50 POP 2407 50 POP 2408 50 POP 2409 50 POP 240A 60 PUSH1 0x40 240C 51 MLOAD 240D 60 PUSH1 0x20 240F 81 DUP2 2410 83 DUP4 2411 03 SUB 2412 03 SUB 2413 81 DUP2 2414 52 MSTORE 2415 90 SWAP1 2416 60 PUSH1 0x40 2418 52 MSTORE 2419 90 SWAP1 241A 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2437 19 NOT 2438 16 AND 2439 60 PUSH1 0x20 243B 82 DUP3 243C 01 ADD 243D 80 DUP1 243E 51 MLOAD 243F 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 245C 83 DUP4 245D 81 DUP2 245E 83 DUP4 245F 16 AND 2460 17 OR 2461 83 DUP4 2462 52 MSTORE 2463 50 POP 2464 50 POP 2465 50 POP 2466 50 POP 2467 60 PUSH1 0x40 2469 51 MLOAD 246A 80 DUP1 246B 60 PUSH1 0x60 246D 01 ADD 246E 60 PUSH1 0x40 2470 52 MSTORE 2471 80 DUP1 2472 60 PUSH1 0x32 2474 81 DUP2 2475 52 MSTORE 2476 60 PUSH1 0x20 2478 01 ADD 2479 61 PUSH2 0x2f6f 247C 60 PUSH1 0x32 247E 91 SWAP2 247F 39 CODECOPY 2480 87 DUP8 2481 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2496 16 AND 2497 61 PUSH2 0x291d 249A 90 SWAP1 249B 92 SWAP3 249C 91 SWAP2 249D 90 SWAP1 249E 63 PUSH4 0xffffffff 24A3 16 AND 24A4 56 *JUMP // Stack delta = -6 // Outputs[10] // { // @23FB memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @2414 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] - 0x20 // @2418 memory[0x40:0x60] = 0x20 + (stack[-2] - stack[-1]) // @2462 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff) | (~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-9]) // @2470 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @2475 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x32 // @247F memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x32] = code[0x2f6f:0x2fa1] // @249B stack[-9] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-15] // @249C stack[-8] = memory[0x40:0x60] // @249D stack[-7] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0xffffffff & 0x291d label_24A5: // Incoming return from call to 0x2324 at 0x2323 // Inputs[3] // { // @24A6 stack[-1] // @24A6 stack[-2] // @24B0 memory[stack[-1]:stack[-1] + 0x20] // } 24A5 5B JUMPDEST 24A6 90 SWAP1 24A7 50 POP 24A8 60 PUSH1 0x00 24AA 81 DUP2 24AB 80 DUP1 24AC 60 PUSH1 0x20 24AE 01 ADD 24AF 90 SWAP1 24B0 51 MLOAD 24B1 60 PUSH1 0x20 24B3 81 DUP2 24B4 10 LT 24B5 15 ISZERO 24B6 61 PUSH2 0x24be 24B9 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @24A6 stack[-2] = stack[-1] // @24A8 stack[-1] = 0x00 // @24AF stack[0] = 0x20 + stack[-1] // @24B0 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x24be, if !(memory[stack[-1]:stack[-1] + 0x20] < 0x20) label_24BA: // Incoming jump from 0x24B9, if not !(memory[stack[-1]:stack[-1] + 0x20] < 0x20) // Inputs[1] { @24BD memory[0x00:0x00] } 24BA 60 PUSH1 0x00 24BC 80 DUP1 24BD FD *REVERT // Stack delta = +0 // Outputs[1] { @24BD revert(memory[0x00:0x00]); } // Block terminates label_24BE: // Incoming jump from 0x24B9, if !(memory[stack[-1]:stack[-1] + 0x20] < 0x20) // Inputs[5] // { // @24BF stack[-2] // @24C0 stack[-1] // @24C4 memory[stack[-2]:stack[-2] + 0x20] // @24D0 stack[-3] // @251A stack[-5] // } 24BE 5B JUMPDEST 24BF 81 DUP2 24C0 01 ADD 24C1 90 SWAP1 24C2 80 DUP1 24C3 80 DUP1 24C4 51 MLOAD 24C5 90 SWAP1 24C6 60 PUSH1 0x20 24C8 01 ADD 24C9 90 SWAP1 24CA 92 SWAP3 24CB 91 SWAP2 24CC 90 SWAP1 24CD 50 POP 24CE 50 POP 24CF 50 POP 24D0 90 SWAP1 24D1 50 POP 24D2 63 PUSH4 0x150b7a02 24D7 60 PUSH1 0xe0 24D9 1B SHL 24DA 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 24F7 19 NOT 24F8 16 AND 24F9 81 DUP2 24FA 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2517 19 NOT 2518 16 AND 2519 14 EQ 251A 92 SWAP3 251B 50 POP 251C 50 POP 251D 50 POP // Stack delta = -4 // Outputs[1] { @251A stack[-5] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0x150b7a02 << 0xe0) } // Block continues label_251E: // Incoming jump from 0x251D // Incoming jump from 0x230E // Inputs[3] // { // @251F stack[-1] // @251F stack[-6] // @2520 stack[-5] // } 251E 5B JUMPDEST 251F 94 SWAP5 2520 93 SWAP4 2521 50 POP 2522 50 POP 2523 50 POP 2524 50 POP 2525 56 *JUMP // Stack delta = -5 // Outputs[1] { @251F stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_2526: // Incoming call from 0x2169, returns to 0x216A // Incoming call from 0x21C3, returns to 0x21C4 // Incoming jump from 0x2226 // Inputs[2] // { // @252C stack[-5] // @2530 stack[-3] // } 2526 5B JUMPDEST 2527 60 PUSH1 0x00 2529 80 DUP1 252A 60 PUSH1 0x01 252C 87 DUP8 252D 01 ADD 252E 90 SWAP1 252F 50 POP 2530 84 DUP5 2531 81 DUP2 2532 14 EQ 2533 15 ISZERO 2534 61 PUSH2 0x2602 2537 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2527 stack[0] = 0x00 // @252E stack[1] = stack[-5] + 0x01 // } // Block ends with conditional jump to 0x2602, if !(stack[-5] + 0x01 == stack[-3]) label_2538: // Incoming jump from 0x2537, if not !(stack[-5] + 0x01 == stack[-3]) // Inputs[4] // { // @253B stack[-7] // @253C stack[-8] // @2542 stack[-4] // @257C memory[0x00:0x40] // } 2538 61 PUSH2 0x258a 253B 87 DUP8 253C 89 DUP10 253D 60 PUSH1 0x00 253F 01 ADD 2540 60 PUSH1 0x00 2542 87 DUP8 2543 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2558 16 AND 2559 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 256E 16 AND 256F 81 DUP2 2570 52 MSTORE 2571 60 PUSH1 0x20 2573 01 ADD 2574 90 SWAP1 2575 81 DUP2 2576 52 MSTORE 2577 60 PUSH1 0x20 2579 01 ADD 257A 60 PUSH1 0x00 257C 20 SHA3 257D 61 PUSH2 0x2935 2580 90 SWAP1 2581 91 SWAP2 2582 90 SWAP1 2583 63 PUSH4 0xffffffff 2588 16 AND 2589 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @2538 stack[0] = 0x258a // @2570 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @2576 memory[0x20:0x40] = 0x00 + stack[-8] // @2581 stack[1] = keccak256(memory[0x00:0x40]) // @2582 stack[2] = stack[-7] // } // Block ends with call to 0xffffffff & 0x2935, returns to 0x258A label_258A: // Incoming return from call to 0x2935 at 0x2589 // Inputs[4] // { // @258F stack[-8] // @2590 stack[-9] // @2596 stack[-4] // @25D0 memory[0x00:0x40] // } 258A 5B JUMPDEST 258B 50 POP 258C 61 PUSH2 0x25de 258F 87 DUP8 2590 89 DUP10 2591 60 PUSH1 0x00 2593 01 ADD 2594 60 PUSH1 0x00 2596 86 DUP7 2597 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25AC 16 AND 25AD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25C2 16 AND 25C3 81 DUP2 25C4 52 MSTORE 25C5 60 PUSH1 0x20 25C7 01 ADD 25C8 90 SWAP1 25C9 81 DUP2 25CA 52 MSTORE 25CB 60 PUSH1 0x20 25CD 01 ADD 25CE 60 PUSH1 0x00 25D0 20 SHA3 25D1 61 PUSH2 0x294f 25D4 90 SWAP1 25D5 91 SWAP2 25D6 90 SWAP1 25D7 63 PUSH4 0xffffffff 25DC 16 AND 25DD 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @258C stack[-1] = 0x25de // @25C4 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @25CA memory[0x20:0x40] = 0x00 + stack[-9] // @25D5 stack[0] = keccak256(memory[0x00:0x40]) // @25D6 stack[1] = stack[-8] // } // Block ends with call to 0xffffffff & 0x294f, returns to 0x25DE label_25DE: // Incoming return from call to 0x294F at 0x25DD // Inputs[3] // { // @25E3 stack[-8] // @25E4 stack[-4] // @25E5 stack[-9] // } 25DE 5B JUMPDEST 25DF 50 POP 25E0 61 PUSH2 0x25f7 25E3 87 DUP8 25E4 84 DUP5 25E5 8A DUP11 25E6 60 PUSH1 0x02 25E8 01 ADD 25E9 61 PUSH2 0x2969 25EC 90 SWAP1 25ED 92 SWAP3 25EE 91 SWAP2 25EF 90 SWAP1 25F0 63 PUSH4 0xffffffff 25F5 16 AND 25F6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @25E0 stack[-1] = 0x25f7 // @25ED stack[0] = 0x02 + stack[-9] // @25EE stack[1] = stack[-8] // @25EF stack[2] = stack[-4] // } // Block ends with call to 0xffffffff & 0x2969, returns to 0x25F7 label_25F7: // Incoming return from call to 0x2969 at 0x25F6 // Inputs[1] { @25FB stack[-3] } 25F7 5B JUMPDEST 25F8 50 POP 25F9 60 PUSH1 0x01 25FB 91 SWAP2 25FC 50 POP 25FD 50 POP 25FE 61 PUSH2 0x2730 2601 56 *JUMP // Stack delta = -2 // Outputs[1] { @25FB stack[-3] = 0x01 } // Block ends with unconditional jump to 0x2730 label_2602: // Incoming jump from 0x2537, if !(stack[-5] + 0x01 == stack[-3]) // Inputs[9] // { // @2603 stack[-7] // @2604 stack[-8] // @260A stack[-6] // @2618 memory[0x00:0x40] // @261D stack[-1] // @2632 memory[0x00:0x40] // @2637 stack[-5] // @264C memory[0x00:0x40] // @2655 stack[-3] // } 2602 5B JUMPDEST 2603 86 DUP7 2604 88 DUP9 2605 60 PUSH1 0x01 2607 01 ADD 2608 60 PUSH1 0x00 260A 88 DUP9 260B 81 DUP2 260C 52 MSTORE 260D 60 PUSH1 0x20 260F 01 ADD 2610 90 SWAP1 2611 81 DUP2 2612 52 MSTORE 2613 60 PUSH1 0x20 2615 01 ADD 2616 60 PUSH1 0x00 2618 20 SHA3 2619 81 DUP2 261A 90 SWAP1 261B 55 SSTORE 261C 50 POP 261D 80 DUP1 261E 88 DUP9 261F 60 PUSH1 0x01 2621 01 ADD 2622 60 PUSH1 0x00 2624 89 DUP10 2625 81 DUP2 2626 52 MSTORE 2627 60 PUSH1 0x20 2629 01 ADD 262A 90 SWAP1 262B 81 DUP2 262C 52 MSTORE 262D 60 PUSH1 0x20 262F 01 ADD 2630 60 PUSH1 0x00 2632 20 SHA3 2633 81 DUP2 2634 90 SWAP1 2635 55 SSTORE 2636 50 POP 2637 84 DUP5 2638 88 DUP9 2639 60 PUSH1 0x01 263B 01 ADD 263C 60 PUSH1 0x00 263E 83 DUP4 263F 81 DUP2 2640 52 MSTORE 2641 60 PUSH1 0x20 2643 01 ADD 2644 90 SWAP1 2645 81 DUP2 2646 52 MSTORE 2647 60 PUSH1 0x20 2649 01 ADD 264A 60 PUSH1 0x00 264C 20 SHA3 264D 81 DUP2 264E 90 SWAP1 264F 55 SSTORE 2650 50 POP 2651 61 PUSH2 0x2668 2654 87 DUP8 2655 84 DUP5 2656 8A DUP11 2657 60 PUSH1 0x02 2659 01 ADD 265A 61 PUSH2 0x2969 265D 90 SWAP1 265E 92 SWAP3 265F 91 SWAP2 2660 90 SWAP1 2661 63 PUSH4 0xffffffff 2666 16 AND 2667 56 *JUMP // Stack delta = +4 // Outputs[13] // { // @260C memory[0x00:0x20] = stack[-6] // @2612 memory[0x20:0x40] = 0x01 + stack[-8] // @261B storage[keccak256(memory[0x00:0x40])] = stack[-7] // @2626 memory[0x00:0x20] = stack[-7] // @262C memory[0x20:0x40] = 0x01 + stack[-8] // @2635 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2640 memory[0x00:0x20] = stack[-1] // @2646 memory[0x20:0x40] = 0x01 + stack[-8] // @264F storage[keccak256(memory[0x00:0x40])] = stack[-5] // @2651 stack[0] = 0x2668 // @265E stack[1] = 0x02 + stack[-8] // @265F stack[2] = stack[-7] // @2660 stack[3] = stack[-3] // } // Block ends with call to 0xffffffff & 0x2969, returns to 0x2668 label_2668: // Incoming return from call to 0x2969 at 0x2667 // Inputs[3] // { // @266D stack[-2] // @266E stack[-5] // @266F stack[-9] // } 2668 5B JUMPDEST 2669 50 POP 266A 61 PUSH2 0x2681 266D 81 DUP2 266E 85 DUP6 266F 8A DUP11 2670 60 PUSH1 0x02 2672 01 ADD 2673 61 PUSH2 0x2969 2676 90 SWAP1 2677 92 SWAP3 2678 91 SWAP2 2679 90 SWAP1 267A 63 PUSH4 0xffffffff 267F 16 AND 2680 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @266A stack[-1] = 0x2681 // @2677 stack[0] = 0x02 + stack[-9] // @2678 stack[1] = stack[-2] // @2679 stack[2] = stack[-5] // } // Block ends with call to 0xffffffff & 0x2969, returns to 0x2681 label_2681: // Incoming return from call to 0x2969 at 0x2680 // Inputs[4] // { // @2686 stack[-2] // @2687 stack[-9] // @268D stack[-5] // @26C7 memory[0x00:0x40] // } 2681 5B JUMPDEST 2682 50 POP 2683 61 PUSH2 0x26d5 2686 81 DUP2 2687 89 DUP10 2688 60 PUSH1 0x00 268A 01 ADD 268B 60 PUSH1 0x00 268D 87 DUP8 268E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26A3 16 AND 26A4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26B9 16 AND 26BA 81 DUP2 26BB 52 MSTORE 26BC 60 PUSH1 0x20 26BE 01 ADD 26BF 90 SWAP1 26C0 81 DUP2 26C1 52 MSTORE 26C2 60 PUSH1 0x20 26C4 01 ADD 26C5 60 PUSH1 0x00 26C7 20 SHA3 26C8 61 PUSH2 0x294f 26CB 90 SWAP1 26CC 91 SWAP2 26CD 90 SWAP1 26CE 63 PUSH4 0xffffffff 26D3 16 AND 26D4 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @2683 stack[-1] = 0x26d5 // @26BB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @26C1 memory[0x20:0x40] = 0x00 + stack[-9] // @26CC stack[0] = keccak256(memory[0x00:0x40]) // @26CD stack[1] = stack[-2] // } // Block ends with call to 0xffffffff & 0x294f, returns to 0x26D5 label_26D5: // Incoming return from call to 0x294F at 0x26D4 // Inputs[4] // { // @26DA stack[-8] // @26DB stack[-9] // @26E1 stack[-4] // @271B memory[0x00:0x40] // } 26D5 5B JUMPDEST 26D6 50 POP 26D7 61 PUSH2 0x2729 26DA 87 DUP8 26DB 89 DUP10 26DC 60 PUSH1 0x00 26DE 01 ADD 26DF 60 PUSH1 0x00 26E1 86 DUP7 26E2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26F7 16 AND 26F8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 270D 16 AND 270E 81 DUP2 270F 52 MSTORE 2710 60 PUSH1 0x20 2712 01 ADD 2713 90 SWAP1 2714 81 DUP2 2715 52 MSTORE 2716 60 PUSH1 0x20 2718 01 ADD 2719 60 PUSH1 0x00 271B 20 SHA3 271C 61 PUSH2 0x294f 271F 90 SWAP1 2720 91 SWAP2 2721 90 SWAP1 2722 63 PUSH4 0xffffffff 2727 16 AND 2728 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @26D7 stack[-1] = 0x2729 // @270F memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @2715 memory[0x20:0x40] = 0x00 + stack[-9] // @2720 stack[0] = keccak256(memory[0x00:0x40]) // @2721 stack[1] = stack[-8] // } // Block ends with call to 0xffffffff & 0x294f, returns to 0x2729 label_2729: // Incoming return from call to 0x294F at 0x2728 // Inputs[3] // { // @272D stack[-3] // @2731 stack[-10] // @2732 stack[-9] // } 2729 5B JUMPDEST 272A 50 POP 272B 60 PUSH1 0x01 272D 91 SWAP2 272E 50 POP 272F 50 POP 2730 5B JUMPDEST 2731 96 SWAP7 2732 95 SWAP6 2733 50 POP 2734 50 POP 2735 50 POP 2736 50 POP 2737 50 POP 2738 50 POP 2739 56 *JUMP // Stack delta = -9 // Outputs[1] { @2731 stack[-10] = 0x01 } // Block ends with unconditional jump to stack[-10] label_273A: // Incoming call from 0x225F, returns to 0x2260 // Inputs[3] // { // @273D stack[-1] // @273E stack[-2] // @2743 storage[0x00 + stack[-2]] // } 273A 5B JUMPDEST 273B 60 PUSH1 0x00 273D 81 DUP2 273E 83 DUP4 273F 60 PUSH1 0x00 2741 01 ADD 2742 80 DUP1 2743 54 SLOAD 2744 90 SWAP1 2745 50 POP 2746 11 GT 2747 61 PUSH2 0x279b 274A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @273B stack[0] = 0x00 } // Block ends with conditional jump to 0x279b, if storage[0x00 + stack[-2]] > stack[-1] label_274B: // Incoming jump from 0x274A, if not storage[0x00 + stack[-2]] > stack[-1] // Inputs[3] // { // @274D memory[0x40:0x60] // @2795 memory[0x40:0x60] // @279A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 274B 60 PUSH1 0x40 274D 51 MLOAD 274E 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 276F 81 DUP2 2770 52 MSTORE 2771 60 PUSH1 0x04 2773 01 ADD 2774 80 DUP1 2775 80 DUP1 2776 60 PUSH1 0x20 2778 01 ADD 2779 82 DUP3 277A 81 DUP2 277B 03 SUB 277C 82 DUP3 277D 52 MSTORE 277E 60 PUSH1 0x22 2780 81 DUP2 2781 52 MSTORE 2782 60 PUSH1 0x20 2784 01 ADD 2785 80 DUP1 2786 61 PUSH2 0x2f4d 2789 60 PUSH1 0x22 278B 91 SWAP2 278C 39 CODECOPY 278D 60 PUSH1 0x40 278F 01 ADD 2790 91 SWAP2 2791 50 POP 2792 50 POP 2793 60 PUSH1 0x40 2795 51 MLOAD 2796 80 DUP1 2797 91 SWAP2 2798 03 SUB 2799 90 SWAP1 279A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2770 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @277D memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2781 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x22 // @278C memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x22] = code[0x2f4d:0x2f6f] // @279A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_279B: // Incoming jump from 0x274A, if storage[0x00 + stack[-2]] > stack[-1] // Inputs[3] // { // @279C stack[-3] // @27A0 stack[-2] // @27A2 storage[0x00 + stack[-3]] // } 279B 5B JUMPDEST 279C 82 DUP3 279D 60 PUSH1 0x00 279F 01 ADD 27A0 82 DUP3 27A1 81 DUP2 27A2 54 SLOAD 27A3 81 DUP2 27A4 10 LT 27A5 61 PUSH2 0x27aa 27A8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @279F stack[0] = 0x00 + stack[-3] // @27A0 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x27aa, if stack[-2] < storage[0x00 + stack[-3]] label_27A9: // Incoming jump from 0x27A8, if not stack[-2] < storage[0x00 + stack[-3]] 27A9 FE *ASSERT // Stack delta = +0 // Outputs[1] { @27A9 assert(); } // Block terminates label_27AA: // Incoming jump from 0x27A8, if stack[-2] < storage[0x00 + stack[-3]] // Inputs[7] // { // @27AB stack[-1] // @27AB stack[-2] // @27B3 memory[0x00:0x20] // @27B5 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @27B6 stack[-3] // @27B8 stack[-6] // @27B9 stack[-5] // } 27AA 5B JUMPDEST 27AB 90 SWAP1 27AC 60 PUSH1 0x00 27AE 52 MSTORE 27AF 60 PUSH1 0x20 27B1 60 PUSH1 0x00 27B3 20 SHA3 27B4 01 ADD 27B5 54 SLOAD 27B6 90 SWAP1 27B7 50 POP 27B8 92 SWAP3 27B9 91 SWAP2 27BA 50 POP 27BB 50 POP 27BC 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @27AE memory[0x00:0x20] = stack[-2] // @27B8 stack[-6] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-6] label_27BD: // Incoming call from 0x2278, returns to 0x2279 // Inputs[3] // { // @27C0 stack[-1] // @27C5 storage[0x00 + stack[-1]] // @27CA stack[-2] // } 27BD 5B JUMPDEST 27BE 60 PUSH1 0x00 27C0 81 DUP2 27C1 60 PUSH1 0x00 27C3 01 ADD 27C4 80 DUP1 27C5 54 SLOAD 27C6 90 SWAP1 27C7 50 POP 27C8 90 SWAP1 27C9 50 POP 27CA 91 SWAP2 27CB 90 SWAP1 27CC 50 POP 27CD 56 *JUMP // Stack delta = -1 // Outputs[1] { @27CA stack[-2] = storage[0x00 + stack[-1]] } // Block ends with unconditional jump to stack[-2] label_27CE: // Incoming call from 0x228D, returns to 0x228E // Inputs[3] // { // @27D1 stack[-1] // @27D6 storage[0x00 + stack[-1]] // @27DB stack[-2] // } 27CE 5B JUMPDEST 27CF 60 PUSH1 0x00 27D1 81 DUP2 27D2 60 PUSH1 0x00 27D4 01 ADD 27D5 80 DUP1 27D6 54 SLOAD 27D7 90 SWAP1 27D8 50 POP 27D9 90 SWAP1 27DA 50 POP 27DB 91 SWAP2 27DC 90 SWAP1 27DD 50 POP 27DE 56 *JUMP // Stack delta = -1 // Outputs[1] { @27DB stack[-2] = storage[0x00 + stack[-1]] } // Block ends with unconditional jump to stack[-2] label_27DF: // Incoming call from 0x22AA, returns to 0x22AB // Inputs[4] // { // @27E5 stack[-2] // @27EB stack[-1] // @27F9 memory[0x00:0x40] // @27FA storage[keccak256(memory[0x00:0x40])] // } 27DF 5B JUMPDEST 27E0 60 PUSH1 0x00 27E2 80 DUP1 27E3 60 PUSH1 0x00 27E5 84 DUP5 27E6 60 PUSH1 0x01 27E8 01 ADD 27E9 60 PUSH1 0x00 27EB 85 DUP6 27EC 81 DUP2 27ED 52 MSTORE 27EE 60 PUSH1 0x20 27F0 01 ADD 27F1 90 SWAP1 27F2 81 DUP2 27F3 52 MSTORE 27F4 60 PUSH1 0x20 27F6 01 ADD 27F7 60 PUSH1 0x00 27F9 20 SHA3 27FA 54 SLOAD 27FB 90 SWAP1 27FC 50 POP 27FD 60 PUSH1 0x00 27FF 81 DUP2 2800 14 EQ 2801 15 ISZERO 2802 61 PUSH2 0x2818 2805 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @27E0 stack[0] = 0x00 // @27E2 stack[1] = 0x00 // @27ED memory[0x00:0x20] = stack[-1] // @27F3 memory[0x20:0x40] = 0x01 + stack[-2] // @27FB stack[2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x2818, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) label_2806: // Incoming jump from 0x2805, if not !(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[2] // { // @280F stack[-2] // @2811 stack[-3] // } 2806 60 PUSH1 0x00 2808 80 DUP1 2809 80 DUP1 280A 60 PUSH1 0x00 280C 1B SHL 280D 90 SWAP1 280E 50 POP 280F 92 SWAP3 2810 50 POP 2811 92 SWAP3 2812 50 POP 2813 50 POP 2814 61 PUSH2 0x2844 2817 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @280F stack[-2] = 0x00 << 0x00 // @2811 stack[-3] = 0x00 // } // Block ends with unconditional jump to 0x2844 label_2818: // Incoming jump from 0x2805, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[3] // { // @281B stack[-5] // @2821 stack[-1] // @2824 storage[0x00 + stack[-5]] // } 2818 5B JUMPDEST 2819 60 PUSH1 0x01 281B 85 DUP6 281C 60 PUSH1 0x00 281E 01 ADD 281F 60 PUSH1 0x01 2821 83 DUP4 2822 03 SUB 2823 81 DUP2 2824 54 SLOAD 2825 81 DUP2 2826 10 LT 2827 61 PUSH2 0x282c 282A 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2819 stack[0] = 0x01 // @281E stack[1] = 0x00 + stack[-5] // @2822 stack[2] = stack[-1] - 0x01 // } // Block ends with conditional jump to 0x282c, if stack[-1] - 0x01 < storage[0x00 + stack[-5]] label_282B: // Incoming jump from 0x282A, if not stack[-1] - 0x01 < storage[0x00 + stack[-5]] 282B FE *ASSERT // Stack delta = +0 // Outputs[1] { @282B assert(); } // Block terminates label_282C: // Incoming jump from 0x282A, if stack[-1] - 0x01 < storage[0x00 + stack[-5]] // Inputs[7] // { // @282D stack[-1] // @282D stack[-2] // @2835 memory[0x00:0x20] // @283E storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @283F stack[-5] // @2841 stack[-6] // @2841 stack[-3] // } 282C 5B JUMPDEST 282D 90 SWAP1 282E 60 PUSH1 0x00 2830 52 MSTORE 2831 60 PUSH1 0x20 2833 60 PUSH1 0x00 2835 20 SHA3 2836 90 SWAP1 2837 60 PUSH1 0x02 2839 02 MUL 283A 01 ADD 283B 60 PUSH1 0x01 283D 01 ADD 283E 54 SLOAD 283F 92 SWAP3 2840 50 POP 2841 92 SWAP3 2842 50 POP 2843 50 POP // Stack delta = -4 // Outputs[3] // { // @2830 memory[0x00:0x20] = stack[-2] // @283F stack[-5] = storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @2841 stack[-6] = stack[-3] // } // Block continues label_2844: // Incoming jump from 0x2817 // Incoming jump from 0x2843 // Inputs[5] // { // @2845 stack[-4] // @2845 stack[-1] // @2847 stack[-2] // @2847 stack[-5] // @2848 stack[-3] // } 2844 5B JUMPDEST 2845 92 SWAP3 2846 50 POP 2847 92 SWAP3 2848 90 SWAP1 2849 50 POP 284A 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @2845 stack[-4] = stack[-1] // @2847 stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_284B: // Incoming call from 0x22D5, returns to 0x22D6 // Inputs[4] // { // @284F stack[-2] // @2855 stack[-1] // @2863 memory[0x00:0x40] // @2864 storage[keccak256(memory[0x00:0x40])] // } 284B 5B JUMPDEST 284C 60 PUSH1 0x00 284E 80 DUP1 284F 83 DUP4 2850 60 PUSH1 0x01 2852 01 ADD 2853 60 PUSH1 0x00 2855 84 DUP5 2856 81 DUP2 2857 52 MSTORE 2858 60 PUSH1 0x20 285A 01 ADD 285B 90 SWAP1 285C 81 DUP2 285D 52 MSTORE 285E 60 PUSH1 0x20 2860 01 ADD 2861 60 PUSH1 0x00 2863 20 SHA3 2864 54 SLOAD 2865 90 SWAP1 2866 50 POP 2867 60 PUSH1 0x00 2869 81 DUP2 286A 14 EQ 286B 15 ISZERO 286C 61 PUSH2 0x28dd 286F 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @284C stack[0] = 0x00 // @2857 memory[0x00:0x20] = stack[-1] // @285D memory[0x20:0x40] = 0x01 + stack[-2] // @2865 stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x28dd, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) label_2870: // Incoming jump from 0x286F, if not !(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[3] // { // @2872 memory[0x40:0x60] // @28D7 memory[0x40:0x60] // @28DC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2870 60 PUSH1 0x40 2872 51 MLOAD 2873 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2894 81 DUP2 2895 52 MSTORE 2896 60 PUSH1 0x04 2898 01 ADD 2899 80 DUP1 289A 80 DUP1 289B 60 PUSH1 0x20 289D 01 ADD 289E 82 DUP3 289F 81 DUP2 28A0 03 SUB 28A1 82 DUP3 28A2 52 MSTORE 28A3 60 PUSH1 0x1e 28A5 81 DUP2 28A6 52 MSTORE 28A7 60 PUSH1 0x20 28A9 01 ADD 28AA 80 DUP1 28AB 7F PUSH32 0x456e756d657261626c654d61703a206e6f6e6578697374656e74206b65790000 28CC 81 DUP2 28CD 52 MSTORE 28CE 50 POP 28CF 60 PUSH1 0x20 28D1 01 ADD 28D2 91 SWAP2 28D3 50 POP 28D4 50 POP 28D5 60 PUSH1 0x40 28D7 51 MLOAD 28D8 80 DUP1 28D9 91 SWAP2 28DA 03 SUB 28DB 90 SWAP1 28DC FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2895 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @28A2 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @28A6 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1e // @28CD memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x456e756d657261626c654d61703a206e6f6e6578697374656e74206b65790000 // @28DC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_28DD: // Incoming jump from 0x286F, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[3] // { // @28DE stack[-4] // @28E4 stack[-1] // @28E7 storage[0x00 + stack[-4]] // } 28DD 5B JUMPDEST 28DE 83 DUP4 28DF 60 PUSH1 0x00 28E1 01 ADD 28E2 60 PUSH1 0x01 28E4 82 DUP3 28E5 03 SUB 28E6 81 DUP2 28E7 54 SLOAD 28E8 81 DUP2 28E9 10 LT 28EA 61 PUSH2 0x28ef 28ED 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @28E1 stack[0] = 0x00 + stack[-4] // @28E5 stack[1] = stack[-1] - 0x01 // } // Block ends with conditional jump to 0x28ef, if stack[-1] - 0x01 < storage[0x00 + stack[-4]] label_28EE: // Incoming jump from 0x28ED, if not stack[-1] - 0x01 < storage[0x00 + stack[-4]] 28EE FE *ASSERT // Stack delta = +0 // Outputs[1] { @28EE assert(); } // Block terminates label_28EF: // Incoming jump from 0x28ED, if stack[-1] - 0x01 < storage[0x00 + stack[-4]] // Inputs[7] // { // @28F0 stack[-2] // @28F0 stack[-1] // @28F8 memory[0x00:0x20] // @2901 storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @2902 stack[-4] // @2905 stack[-7] // @2906 stack[-6] // } 28EF 5B JUMPDEST 28F0 90 SWAP1 28F1 60 PUSH1 0x00 28F3 52 MSTORE 28F4 60 PUSH1 0x20 28F6 60 PUSH1 0x00 28F8 20 SHA3 28F9 90 SWAP1 28FA 60 PUSH1 0x02 28FC 02 MUL 28FD 01 ADD 28FE 60 PUSH1 0x01 2900 01 ADD 2901 54 SLOAD 2902 91 SWAP2 2903 50 POP 2904 50 POP 2905 92 SWAP3 2906 91 SWAP2 2907 50 POP 2908 50 POP 2909 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @28F3 memory[0x00:0x20] = stack[-2] // @2905 stack[-7] = storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // } // Block ends with unconditional jump to stack[-7] label_290A: // Incoming call from 0x2A01, returns to 0x2A02 // Incoming call from 0x2301, returns to 0x2302 // Inputs[3] // { // @290E stack[-1] // @290F address(stack[-1]).code.length // @2919 stack[-2] // } 290A 5B JUMPDEST 290B 60 PUSH1 0x00 290D 80 DUP1 290E 82 DUP3 290F 3B EXTCODESIZE 2910 90 SWAP1 2911 50 POP 2912 60 PUSH1 0x00 2914 81 DUP2 2915 11 GT 2916 91 SWAP2 2917 50 POP 2918 50 POP 2919 91 SWAP2 291A 90 SWAP1 291B 50 POP 291C 56 *JUMP // Stack delta = -1 // Outputs[1] { @2919 stack[-2] = address(stack[-1]).code.length > 0x00 } // Block ends with unconditional jump to stack[-2] label_291D: // Incoming jump from 0x24A4 // Incoming jump from 0x24A4 // Inputs[3] // { // @2923 stack[-3] // @2924 stack[-2] // @2927 stack[-1] // } 291D 5B JUMPDEST 291E 60 PUSH1 0x60 2920 61 PUSH2 0x292c 2923 84 DUP5 2924 84 DUP5 2925 60 PUSH1 0x00 2927 85 DUP6 2928 61 PUSH2 0x299e 292B 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @291E stack[0] = 0x60 // @2920 stack[1] = 0x292c // @2923 stack[2] = stack[-3] // @2924 stack[3] = stack[-2] // @2925 stack[4] = 0x00 // @2927 stack[5] = stack[-1] // } // Block ends with call to 0x299e, returns to 0x292C label_292C: // Incoming return from call to 0x299E at 0x292B // Inputs[4] // { // @292D stack[-2] // @292D stack[-1] // @292F stack[-6] // @2930 stack[-5] // } 292C 5B JUMPDEST 292D 90 SWAP1 292E 50 POP 292F 93 SWAP4 2930 92 SWAP3 2931 50 POP 2932 50 POP 2933 50 POP 2934 56 *JUMP // Stack delta = -5 // Outputs[1] { @292F stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_2935: // Incoming call from 0x2589, returns to 0x258A // Inputs[2] // { // @293B stack[-2] // @293F stack[-1] // } 2935 5B JUMPDEST 2936 60 PUSH1 0x00 2938 61 PUSH2 0x2947 293B 83 DUP4 293C 60 PUSH1 0x00 293E 01 ADD 293F 83 DUP4 2940 60 PUSH1 0x00 2942 1B SHL 2943 61 PUSH2 0x2b47 2946 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2936 stack[0] = 0x00 // @2938 stack[1] = 0x2947 // @293E stack[2] = 0x00 + stack[-2] // @2942 stack[3] = stack[-1] << 0x00 // } // Block ends with call to 0x2b47, returns to 0x2947 label_2947: // Incoming return from call to 0x2B47 at 0x2946 // Inputs[4] // { // @2948 stack[-1] // @2948 stack[-2] // @294A stack[-5] // @294B stack[-4] // } 2947 5B JUMPDEST 2948 90 SWAP1 2949 50 POP 294A 92 SWAP3 294B 91 SWAP2 294C 50 POP 294D 50 POP 294E 56 *JUMP // Stack delta = -4 // Outputs[1] { @294A stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_294F: // Incoming call from 0x25DD, returns to 0x25DE // Incoming call from 0x2728, returns to 0x2729 // Incoming call from 0x26D4, returns to 0x26D5 // Inputs[2] // { // @2955 stack[-2] // @2959 stack[-1] // } 294F 5B JUMPDEST 2950 60 PUSH1 0x00 2952 61 PUSH2 0x2961 2955 83 DUP4 2956 60 PUSH1 0x00 2958 01 ADD 2959 83 DUP4 295A 60 PUSH1 0x00 295C 1B SHL 295D 61 PUSH2 0x2c2f 2960 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2950 stack[0] = 0x00 // @2952 stack[1] = 0x2961 // @2958 stack[2] = 0x00 + stack[-2] // @295C stack[3] = stack[-1] << 0x00 // } // Block ends with call to 0x2c2f, returns to 0x2961 label_2961: // Incoming return from call to 0x2C2F at 0x2960 // Inputs[4] // { // @2962 stack[-2] // @2962 stack[-1] // @2964 stack[-5] // @2965 stack[-4] // } 2961 5B JUMPDEST 2962 90 SWAP1 2963 50 POP 2964 92 SWAP3 2965 91 SWAP2 2966 50 POP 2967 50 POP 2968 56 *JUMP // Stack delta = -4 // Outputs[1] { @2964 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_2969: // Incoming call from 0x25F6, returns to 0x25F7 // Incoming call from 0x2680, returns to 0x2681 // Incoming call from 0x2667, returns to 0x2668 // Inputs[3] // { // @296F stack[-3] // @2973 stack[-2] // @2977 stack[-1] // } 2969 5B JUMPDEST 296A 60 PUSH1 0x00 296C 61 PUSH2 0x2995 296F 84 DUP5 2970 60 PUSH1 0x00 2972 01 ADD 2973 84 DUP5 2974 60 PUSH1 0x00 2976 1B SHL 2977 84 DUP5 2978 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 298D 16 AND 298E 60 PUSH1 0x00 2990 1B SHL 2991 61 PUSH2 0x2c9f 2994 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @296A stack[0] = 0x00 // @296C stack[1] = 0x2995 // @2972 stack[2] = 0x00 + stack[-3] // @2976 stack[3] = stack[-2] << 0x00 // @2990 stack[4] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) << 0x00 // } // Block ends with call to 0x2c9f, returns to 0x2995 label_2995: // Incoming return from call to 0x2C9F at 0x2994 // Inputs[4] // { // @2996 stack[-2] // @2996 stack[-1] // @2998 stack[-6] // @2999 stack[-5] // } 2995 5B JUMPDEST 2996 90 SWAP1 2997 50 POP 2998 93 SWAP4 2999 92 SWAP3 299A 50 POP 299B 50 POP 299C 50 POP 299D 56 *JUMP // Stack delta = -5 // Outputs[1] { @2998 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_299E: // Incoming call from 0x292B, returns to 0x292C // Inputs[3] // { // @29A1 stack[-2] // @29A2 address(this) // @29A2 address(this).balance // } 299E 5B JUMPDEST 299F 60 PUSH1 0x60 29A1 82 DUP3 29A2 47 SELFBALANCE 29A3 10 LT 29A4 15 ISZERO 29A5 61 PUSH2 0x29f9 29A8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @299F stack[0] = 0x60 } // Block ends with conditional jump to 0x29f9, if !(address(this).balance < stack[-2]) label_29A9: // Incoming jump from 0x29A8, if not !(address(this).balance < stack[-2]) // Inputs[3] // { // @29AB memory[0x40:0x60] // @29F3 memory[0x40:0x60] // @29F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 29A9 60 PUSH1 0x40 29AB 51 MLOAD 29AC 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 29CD 81 DUP2 29CE 52 MSTORE 29CF 60 PUSH1 0x04 29D1 01 ADD 29D2 80 DUP1 29D3 80 DUP1 29D4 60 PUSH1 0x20 29D6 01 ADD 29D7 82 DUP3 29D8 81 DUP2 29D9 03 SUB 29DA 82 DUP3 29DB 52 MSTORE 29DC 60 PUSH1 0x26 29DE 81 DUP2 29DF 52 MSTORE 29E0 60 PUSH1 0x20 29E2 01 ADD 29E3 80 DUP1 29E4 61 PUSH2 0x2feb 29E7 60 PUSH1 0x26 29E9 91 SWAP2 29EA 39 CODECOPY 29EB 60 PUSH1 0x40 29ED 01 ADD 29EE 91 SWAP2 29EF 50 POP 29F0 50 POP 29F1 60 PUSH1 0x40 29F3 51 MLOAD 29F4 80 DUP1 29F5 91 SWAP2 29F6 03 SUB 29F7 90 SWAP1 29F8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @29CE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @29DB memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @29DF memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x26 // @29EA memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x26] = code[0x2feb:0x3011] // @29F8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_29F9: // Incoming jump from 0x29A8, if !(address(this).balance < stack[-2]) // Inputs[1] { @29FD stack[-5] } 29F9 5B JUMPDEST 29FA 61 PUSH2 0x2a02 29FD 85 DUP6 29FE 61 PUSH2 0x290a 2A01 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @29FA stack[0] = 0x2a02 // @29FD stack[1] = stack[-5] // } // Block ends with call to 0x290a, returns to 0x2A02 label_2A02: // Incoming return from call to 0x290A at 0x2A01 // Inputs[1] { @2A06 stack[-1] } 2A02 5B JUMPDEST 2A03 61 PUSH2 0x2a74 2A06 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2a74, if stack[-1] label_2A07: // Incoming jump from 0x2A06, if not stack[-1] // Inputs[3] // { // @2A09 memory[0x40:0x60] // @2A6E memory[0x40:0x60] // @2A73 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2A07 60 PUSH1 0x40 2A09 51 MLOAD 2A0A 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2A2B 81 DUP2 2A2C 52 MSTORE 2A2D 60 PUSH1 0x04 2A2F 01 ADD 2A30 80 DUP1 2A31 80 DUP1 2A32 60 PUSH1 0x20 2A34 01 ADD 2A35 82 DUP3 2A36 81 DUP2 2A37 03 SUB 2A38 82 DUP3 2A39 52 MSTORE 2A3A 60 PUSH1 0x1d 2A3C 81 DUP2 2A3D 52 MSTORE 2A3E 60 PUSH1 0x20 2A40 01 ADD 2A41 80 DUP1 2A42 7F PUSH32 0x416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000 2A63 81 DUP2 2A64 52 MSTORE 2A65 50 POP 2A66 60 PUSH1 0x20 2A68 01 ADD 2A69 91 SWAP2 2A6A 50 POP 2A6B 50 POP 2A6C 60 PUSH1 0x40 2A6E 51 MLOAD 2A6F 80 DUP1 2A70 91 SWAP2 2A71 03 SUB 2A72 90 SWAP1 2A73 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2A2C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2A39 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2A3D memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1d // @2A64 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000 // @2A73 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2A74: // Incoming jump from 0x2A06, if stack[-1] // Inputs[5] // { // @2A79 stack[-5] // @2A90 stack[-3] // @2A91 stack[-4] // @2A94 memory[0x40:0x60] // @2A98 memory[stack[-4]:stack[-4] + 0x20] // } 2A74 5B JUMPDEST 2A75 60 PUSH1 0x00 2A77 60 PUSH1 0x60 2A79 86 DUP7 2A7A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2A8F 16 AND 2A90 85 DUP6 2A91 87 DUP8 2A92 60 PUSH1 0x40 2A94 51 MLOAD 2A95 80 DUP1 2A96 82 DUP3 2A97 80 DUP1 2A98 51 MLOAD 2A99 90 SWAP1 2A9A 60 PUSH1 0x20 2A9C 01 ADD 2A9D 90 SWAP1 2A9E 80 DUP1 2A9F 83 DUP4 2AA0 83 DUP4 2AA1 5B JUMPDEST 2AA2 60 PUSH1 0x20 2AA4 83 DUP4 2AA5 10 LT 2AA6 61 PUSH2 0x2ac4 2AA9 57 *JUMPI // Stack delta = +12 // Outputs[12] // { // @2A75 stack[0] = 0x00 // @2A77 stack[1] = 0x60 // @2A8F stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @2A90 stack[3] = stack[-3] // @2A91 stack[4] = stack[-4] // @2A94 stack[5] = memory[0x40:0x60] // @2A95 stack[6] = memory[0x40:0x60] // @2A9D stack[7] = 0x20 + stack[-4] // @2A9D stack[8] = memory[stack[-4]:stack[-4] + 0x20] // @2A9E stack[9] = memory[stack[-4]:stack[-4] + 0x20] // @2A9F stack[10] = memory[0x40:0x60] // @2AA0 stack[11] = 0x20 + stack[-4] // } // Block ends with conditional jump to 0x2ac4, if memory[stack[-4]:stack[-4] + 0x20] < 0x20 label_2AAA: // Incoming jump from 0x2AA9, if not memory[stack[-4]:stack[-4] + 0x20] < 0x20 // Incoming jump from 0x2AA9, if not stack[-3] < 0x20 // Inputs[4] // { // @2AAA stack[-1] // @2AAB memory[stack[-1]:stack[-1] + 0x20] // @2AAC stack[-2] // @2ABC stack[-3] // } 2AAA 80 DUP1 2AAB 51 MLOAD 2AAC 82 DUP3 2AAD 52 MSTORE 2AAE 60 PUSH1 0x20 2AB0 82 DUP3 2AB1 01 ADD 2AB2 91 SWAP2 2AB3 50 POP 2AB4 60 PUSH1 0x20 2AB6 81 DUP2 2AB7 01 ADD 2AB8 90 SWAP1 2AB9 50 POP 2ABA 60 PUSH1 0x20 2ABC 83 DUP4 2ABD 03 SUB 2ABE 92 SWAP3 2ABF 50 POP 2AC0 61 PUSH2 0x2aa1 2AC3 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2AAD memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @2AB2 stack[-2] = stack[-2] + 0x20 // @2AB8 stack[-1] = stack[-1] + 0x20 // @2ABE stack[-3] = stack[-3] - 0x20 // } // Block ends with unconditional jump to 0x2aa1 label_2AC4: // Incoming jump from 0x2AA9, if memory[stack[-4]:stack[-4] + 0x20] < 0x20 // Incoming jump from 0x2AA9, if stack[-3] < 0x20 // Inputs[16] // { // @2AC7 stack[-3] // @2AD2 stack[-1] // @2AD3 memory[stack[-1]:stack[-1] + 0x20] // @2AD6 stack[-2] // @2AD7 memory[stack[-2]:stack[-2] + 0x20] // @2AE4 stack[-5] // @2AE4 stack[-4] // @2AE6 stack[-6] // @2AE7 stack[-8] // @2AEE memory[0x40:0x60] // @2AF3 stack[-9] // @2AF4 stack[-10] // @2AF5 msg.gas // @2AF6 address(stack[-10]).call.gas(msg.gas).value(stack[-9])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @2AF6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]] // @2AFB returndata.length // } 2AC4 5B JUMPDEST 2AC5 60 PUSH1 0x01 2AC7 83 DUP4 2AC8 60 PUSH1 0x20 2ACA 03 SUB 2ACB 61 PUSH2 0x0100 2ACE 0A EXP 2ACF 03 SUB 2AD0 80 DUP1 2AD1 19 NOT 2AD2 82 DUP3 2AD3 51 MLOAD 2AD4 16 AND 2AD5 81 DUP2 2AD6 84 DUP5 2AD7 51 MLOAD 2AD8 16 AND 2AD9 80 DUP1 2ADA 82 DUP3 2ADB 17 OR 2ADC 85 DUP6 2ADD 52 MSTORE 2ADE 50 POP 2ADF 50 POP 2AE0 50 POP 2AE1 50 POP 2AE2 50 POP 2AE3 50 POP 2AE4 90 SWAP1 2AE5 50 POP 2AE6 01 ADD 2AE7 91 SWAP2 2AE8 50 POP 2AE9 50 POP 2AEA 60 PUSH1 0x00 2AEC 60 PUSH1 0x40 2AEE 51 MLOAD 2AEF 80 DUP1 2AF0 83 DUP4 2AF1 03 SUB 2AF2 81 DUP2 2AF3 85 DUP6 2AF4 87 DUP8 2AF5 5A GAS 2AF6 F1 CALL 2AF7 92 SWAP3 2AF8 50 POP 2AF9 50 POP 2AFA 50 POP 2AFB 3D RETURNDATASIZE 2AFC 80 DUP1 2AFD 60 PUSH1 0x00 2AFF 81 DUP2 2B00 14 EQ 2B01 61 PUSH2 0x2b26 2B04 57 *JUMPI // Stack delta = -7 // Outputs[5] // { // @2ADD memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @2AF6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-10]).call.gas(msg.gas).value(stack[-9])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @2AF7 stack[-10] = address(stack[-10]).call.gas(msg.gas).value(stack[-9])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @2AFB stack[-9] = returndata.length // @2AFC stack[-8] = returndata.length // } // Block ends with conditional jump to 0x2b26, if returndata.length == 0x00 label_2B05: // Incoming jump from 0x2B04, if not returndata.length == 0x00 // Inputs[6] // { // @2B07 memory[0x40:0x60] // @2B08 stack[-2] // @2B0F returndata.length // @2B17 returndata.length // @2B1A returndata.length // @2B21 returndata[0x00:0x00 + returndata.length] // } 2B05 60 PUSH1 0x40 2B07 51 MLOAD 2B08 91 SWAP2 2B09 50 POP 2B0A 60 PUSH1 0x1f 2B0C 19 NOT 2B0D 60 PUSH1 0x3f 2B0F 3D RETURNDATASIZE 2B10 01 ADD 2B11 16 AND 2B12 82 DUP3 2B13 01 ADD 2B14 60 PUSH1 0x40 2B16 52 MSTORE 2B17 3D RETURNDATASIZE 2B18 82 DUP3 2B19 52 MSTORE 2B1A 3D RETURNDATASIZE 2B1B 60 PUSH1 0x00 2B1D 60 PUSH1 0x20 2B1F 84 DUP5 2B20 01 ADD 2B21 3E RETURNDATACOPY 2B22 61 PUSH2 0x2b2b 2B25 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2B08 stack[-2] = memory[0x40:0x60] // @2B16 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @2B19 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @2B21 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x2b2b label_2B26: // Incoming jump from 0x2B04, if returndata.length == 0x00 // Inputs[5] // { // @2B29 stack[-2] // @2B2D stack[-4] // @2B2F stack[-5] // @2B2F stack[-3] // @2B36 stack[-7] // } 2B26 5B JUMPDEST 2B27 60 PUSH1 0x60 2B29 91 SWAP2 2B2A 50 POP 2B2B 5B JUMPDEST 2B2C 50 POP 2B2D 91 SWAP2 2B2E 50 POP 2B2F 91 SWAP2 2B30 50 POP 2B31 61 PUSH2 0x2b3b 2B34 82 DUP3 2B35 82 DUP3 2B36 86 DUP7 2B37 61 PUSH2 0x2d7b 2B3A 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @2B2D stack[-4] = 0x60 // @2B2F stack[-5] = stack[-3] // @2B31 stack[-3] = 0x2b3b // @2B34 stack[-2] = stack[-3] // @2B35 stack[-1] = 0x60 // @2B36 stack[0] = stack[-7] // } // Block ends with call to 0x2d7b, returns to 0x2B3B label_2B3B: // Incoming return from call to 0x2D7B at 0x2B3A // Incoming return from call to 0x2D7B at 0x2B3A // Inputs[4] // { // @2B3C stack[-4] // @2B3C stack[-1] // @2B40 stack[-9] // @2B41 stack[-8] // } 2B3B 5B JUMPDEST 2B3C 92 SWAP3 2B3D 50 POP 2B3E 50 POP 2B3F 50 POP 2B40 94 SWAP5 2B41 93 SWAP4 2B42 50 POP 2B43 50 POP 2B44 50 POP 2B45 50 POP 2B46 56 *JUMP // Stack delta = -8 // Outputs[1] { @2B40 stack[-9] = stack[-1] } // Block ends with unconditional jump to stack[-9] label_2B47: // Incoming call from 0x2946, returns to 0x2947 // Inputs[4] // { // @2B4B stack[-2] // @2B51 stack[-1] // @2B5F memory[0x00:0x40] // @2B60 storage[keccak256(memory[0x00:0x40])] // } 2B47 5B JUMPDEST 2B48 60 PUSH1 0x00 2B4A 80 DUP1 2B4B 83 DUP4 2B4C 60 PUSH1 0x01 2B4E 01 ADD 2B4F 60 PUSH1 0x00 2B51 84 DUP5 2B52 81 DUP2 2B53 52 MSTORE 2B54 60 PUSH1 0x20 2B56 01 ADD 2B57 90 SWAP1 2B58 81 DUP2 2B59 52 MSTORE 2B5A 60 PUSH1 0x20 2B5C 01 ADD 2B5D 60 PUSH1 0x00 2B5F 20 SHA3 2B60 54 SLOAD 2B61 90 SWAP1 2B62 50 POP 2B63 60 PUSH1 0x00 2B65 81 DUP2 2B66 14 EQ 2B67 61 PUSH2 0x2c23 2B6A 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @2B48 stack[0] = 0x00 // @2B53 memory[0x00:0x20] = stack[-1] // @2B59 memory[0x20:0x40] = 0x01 + stack[-2] // @2B61 stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x2c23, if storage[keccak256(memory[0x00:0x40])] == 0x00 label_2B6B: // Incoming jump from 0x2B6A, if not storage[keccak256(memory[0x00:0x40])] == 0x00 // Inputs[4] // { // @2B6F stack[-1] // @2B77 stack[-4] // @2B7C storage[0x00 + stack[-4]] // @2B8A storage[0x00 + stack[-4]] // } 2B6B 60 PUSH1 0x00 2B6D 60 PUSH1 0x01 2B6F 82 DUP3 2B70 03 SUB 2B71 90 SWAP1 2B72 50 POP 2B73 60 PUSH1 0x00 2B75 60 PUSH1 0x01 2B77 86 DUP7 2B78 60 PUSH1 0x00 2B7A 01 ADD 2B7B 80 DUP1 2B7C 54 SLOAD 2B7D 90 SWAP1 2B7E 50 POP 2B7F 03 SUB 2B80 90 SWAP1 2B81 50 POP 2B82 60 PUSH1 0x00 2B84 86 DUP7 2B85 60 PUSH1 0x00 2B87 01 ADD 2B88 82 DUP3 2B89 81 DUP2 2B8A 54 SLOAD 2B8B 81 DUP2 2B8C 10 LT 2B8D 61 PUSH2 0x2b92 2B90 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @2B71 stack[0] = stack[-1] - 0x01 // @2B80 stack[1] = storage[0x00 + stack[-4]] - 0x01 // @2B82 stack[2] = 0x00 // @2B87 stack[3] = 0x00 + stack[-4] // @2B88 stack[4] = storage[0x00 + stack[-4]] - 0x01 // } // Block ends with conditional jump to 0x2b92, if storage[0x00 + stack[-4]] - 0x01 < storage[0x00 + stack[-4]] label_2B91: // Incoming jump from 0x2B90, if not storage[0x00 + stack[-4]] - 0x01 < storage[0x00 + stack[-4]] 2B91 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2B91 assert(); } // Block terminates label_2B92: // Incoming jump from 0x2B90, if storage[0x00 + stack[-4]] - 0x01 < storage[0x00 + stack[-4]] // Inputs[8] // { // @2B93 stack[-1] // @2B93 stack[-2] // @2B9B memory[0x00:0x20] // @2B9D storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @2B9E stack[-3] // @2BA1 stack[-9] // @2BA5 stack[-5] // @2BA7 storage[0x00 + stack[-9]] // } 2B92 5B JUMPDEST 2B93 90 SWAP1 2B94 60 PUSH1 0x00 2B96 52 MSTORE 2B97 60 PUSH1 0x20 2B99 60 PUSH1 0x00 2B9B 20 SHA3 2B9C 01 ADD 2B9D 54 SLOAD 2B9E 90 SWAP1 2B9F 50 POP 2BA0 80 DUP1 2BA1 87 DUP8 2BA2 60 PUSH1 0x00 2BA4 01 ADD 2BA5 84 DUP5 2BA6 81 DUP2 2BA7 54 SLOAD 2BA8 81 DUP2 2BA9 10 LT 2BAA 61 PUSH2 0x2baf 2BAD 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @2B96 memory[0x00:0x20] = stack[-2] // @2B9E stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @2BA0 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @2BA4 stack[-1] = 0x00 + stack[-9] // @2BA5 stack[0] = stack[-5] // } // Block ends with conditional jump to 0x2baf, if stack[-5] < storage[0x00 + stack[-9]] label_2BAE: // Incoming jump from 0x2BAD, if not stack[-5] < storage[0x00 + stack[-9]] 2BAE FE *ASSERT // Stack delta = +0 // Outputs[1] { @2BAE assert(); } // Block terminates label_2BAF: // Incoming jump from 0x2BAD, if stack[-5] < storage[0x00 + stack[-9]] // Inputs[9] // { // @2BB0 stack[-2] // @2BB0 stack[-1] // @2BB8 memory[0x00:0x20] // @2BBA stack[-3] // @2BC0 stack[-6] // @2BC2 stack[-10] // @2BC8 stack[-4] // @2BD6 memory[0x00:0x40] // @2BE0 storage[0x00 + stack[-10]] // } 2BAF 5B JUMPDEST 2BB0 90 SWAP1 2BB1 60 PUSH1 0x00 2BB3 52 MSTORE 2BB4 60 PUSH1 0x20 2BB6 60 PUSH1 0x00 2BB8 20 SHA3 2BB9 01 ADD 2BBA 81 DUP2 2BBB 90 SWAP1 2BBC 55 SSTORE 2BBD 50 POP 2BBE 60 PUSH1 0x01 2BC0 83 DUP4 2BC1 01 ADD 2BC2 87 DUP8 2BC3 60 PUSH1 0x01 2BC5 01 ADD 2BC6 60 PUSH1 0x00 2BC8 83 DUP4 2BC9 81 DUP2 2BCA 52 MSTORE 2BCB 60 PUSH1 0x20 2BCD 01 ADD 2BCE 90 SWAP1 2BCF 81 DUP2 2BD0 52 MSTORE 2BD1 60 PUSH1 0x20 2BD3 01 ADD 2BD4 60 PUSH1 0x00 2BD6 20 SHA3 2BD7 81 DUP2 2BD8 90 SWAP1 2BD9 55 SSTORE 2BDA 50 POP 2BDB 86 DUP7 2BDC 60 PUSH1 0x00 2BDE 01 ADD 2BDF 80 DUP1 2BE0 54 SLOAD 2BE1 80 DUP1 2BE2 61 PUSH2 0x2be7 2BE5 57 *JUMPI // Stack delta = -1 // Outputs[7] // { // @2BB3 memory[0x00:0x20] = stack[-2] // @2BBC storage[keccak256(memory[0x00:0x20]) + stack[-1]] = stack[-3] // @2BCA memory[0x00:0x20] = stack[-4] // @2BD0 memory[0x20:0x40] = 0x01 + stack[-10] // @2BD9 storage[keccak256(memory[0x00:0x40])] = stack[-6] + 0x01 // @2BDE stack[-3] = 0x00 + stack[-10] // @2BE0 stack[-2] = storage[0x00 + stack[-10]] // } // Block ends with conditional jump to 0x2be7, if storage[0x00 + stack[-10]] label_2BE6: // Incoming jump from 0x2BE5, if not storage[0x00 + stack[-10]] 2BE6 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2BE6 assert(); } // Block terminates label_2BE7: // Incoming jump from 0x2BE5, if storage[0x00 + stack[-10]] // Inputs[7] // { // @2BEA stack[-1] // @2BEC stack[-2] // @2BF6 memory[0x00:0x20] // @2BFE stack[-9] // @2C04 stack[-8] // @2C12 memory[0x00:0x40] // @2C19 stack[-7] // } 2BE7 5B JUMPDEST 2BE8 60 PUSH1 0x01 2BEA 90 SWAP1 2BEB 03 SUB 2BEC 81 DUP2 2BED 81 DUP2 2BEE 90 SWAP1 2BEF 60 PUSH1 0x00 2BF1 52 MSTORE 2BF2 60 PUSH1 0x20 2BF4 60 PUSH1 0x00 2BF6 20 SHA3 2BF7 01 ADD 2BF8 60 PUSH1 0x00 2BFA 90 SWAP1 2BFB 55 SSTORE 2BFC 90 SWAP1 2BFD 55 SSTORE 2BFE 86 DUP7 2BFF 60 PUSH1 0x01 2C01 01 ADD 2C02 60 PUSH1 0x00 2C04 87 DUP8 2C05 81 DUP2 2C06 52 MSTORE 2C07 60 PUSH1 0x20 2C09 01 ADD 2C0A 90 SWAP1 2C0B 81 DUP2 2C0C 52 MSTORE 2C0D 60 PUSH1 0x20 2C0F 01 ADD 2C10 60 PUSH1 0x00 2C12 20 SHA3 2C13 60 PUSH1 0x00 2C15 90 SWAP1 2C16 55 SSTORE 2C17 60 PUSH1 0x01 2C19 94 SWAP5 2C1A 50 POP 2C1B 50 POP 2C1C 50 POP 2C1D 50 POP 2C1E 50 POP 2C1F 61 PUSH2 0x2c29 2C22 56 *JUMP // Stack delta = -6 // Outputs[7] // { // @2BF1 memory[0x00:0x20] = stack[-2] // @2BFB storage[keccak256(memory[0x00:0x20]) + (stack[-1] - 0x01)] = 0x00 // @2BFD storage[stack[-2]] = stack[-1] - 0x01 // @2C06 memory[0x00:0x20] = stack[-8] // @2C0C memory[0x20:0x40] = 0x01 + stack[-9] // @2C16 storage[keccak256(memory[0x00:0x40])] = 0x00 // @2C19 stack[-7] = 0x01 // } // Block ends with unconditional jump to 0x2c29 label_2C23: // Incoming jump from 0x2B6A, if storage[keccak256(memory[0x00:0x40])] == 0x00 // Inputs[3] // { // @2C26 stack[-2] // @2C2A stack[-5] // @2C2B stack[-4] // } 2C23 5B JUMPDEST 2C24 60 PUSH1 0x00 2C26 91 SWAP2 2C27 50 POP 2C28 50 POP 2C29 5B JUMPDEST 2C2A 92 SWAP3 2C2B 91 SWAP2 2C2C 50 POP 2C2D 50 POP 2C2E 56 *JUMP // Stack delta = -4 // Outputs[1] { @2C2A stack[-5] = 0x00 } // Block ends with unconditional jump to stack[-5] label_2C2F: // Incoming call from 0x2960, returns to 0x2961 // Inputs[2] // { // @2C35 stack[-2] // @2C36 stack[-1] // } 2C2F 5B JUMPDEST 2C30 60 PUSH1 0x00 2C32 61 PUSH2 0x2c3b 2C35 83 DUP4 2C36 83 DUP4 2C37 61 PUSH2 0x2e47 2C3A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2C30 stack[0] = 0x00 // @2C32 stack[1] = 0x2c3b // @2C35 stack[2] = stack[-2] // @2C36 stack[3] = stack[-1] // } // Block ends with call to 0x2e47, returns to 0x2C3B label_2C3B: // Incoming return from call to 0x2E47 at 0x2C3A // Inputs[1] { @2C3F stack[-1] } 2C3B 5B JUMPDEST 2C3C 61 PUSH2 0x2c94 2C3F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2c94, if stack[-1] label_2C40: // Incoming jump from 0x2C3F, if not stack[-1] // Inputs[7] // { // @2C40 stack[-3] // @2C44 stack[-2] // @2C4A storage[0x00 + stack[-3]] // @2C5F memory[0x00:0x20] // @2C70 storage[0x00 + stack[-3]] // @2C87 memory[0x00:0x40] // @2C8E stack[-1] // } 2C40 82 DUP3 2C41 60 PUSH1 0x00 2C43 01 ADD 2C44 82 DUP3 2C45 90 SWAP1 2C46 80 DUP1 2C47 60 PUSH1 0x01 2C49 81 DUP2 2C4A 54 SLOAD 2C4B 01 ADD 2C4C 80 DUP1 2C4D 82 DUP3 2C4E 55 SSTORE 2C4F 80 DUP1 2C50 91 SWAP2 2C51 50 POP 2C52 50 POP 2C53 60 PUSH1 0x01 2C55 90 SWAP1 2C56 03 SUB 2C57 90 SWAP1 2C58 60 PUSH1 0x00 2C5A 52 MSTORE 2C5B 60 PUSH1 0x20 2C5D 60 PUSH1 0x00 2C5F 20 SHA3 2C60 01 ADD 2C61 60 PUSH1 0x00 2C63 90 SWAP1 2C64 91 SWAP2 2C65 90 SWAP1 2C66 91 SWAP2 2C67 90 SWAP1 2C68 91 SWAP2 2C69 50 POP 2C6A 55 SSTORE 2C6B 82 DUP3 2C6C 60 PUSH1 0x00 2C6E 01 ADD 2C6F 80 DUP1 2C70 54 SLOAD 2C71 90 SWAP1 2C72 50 POP 2C73 83 DUP4 2C74 60 PUSH1 0x01 2C76 01 ADD 2C77 60 PUSH1 0x00 2C79 84 DUP5 2C7A 81 DUP2 2C7B 52 MSTORE 2C7C 60 PUSH1 0x20 2C7E 01 ADD 2C7F 90 SWAP1 2C80 81 DUP2 2C81 52 MSTORE 2C82 60 PUSH1 0x20 2C84 01 ADD 2C85 60 PUSH1 0x00 2C87 20 SHA3 2C88 81 DUP2 2C89 90 SWAP1 2C8A 55 SSTORE 2C8B 50 POP 2C8C 60 PUSH1 0x01 2C8E 90 SWAP1 2C8F 50 POP 2C90 61 PUSH2 0x2c99 2C93 56 *JUMP // Stack delta = +0 // Outputs[7] // { // @2C4E storage[0x00 + stack[-3]] = storage[0x00 + stack[-3]] + 0x01 // @2C5A memory[0x00:0x20] = 0x00 + stack[-3] // @2C6A storage[keccak256(memory[0x00:0x20]) + ((storage[0x00 + stack[-3]] + 0x01) - 0x01)] = stack[-2] // @2C7B memory[0x00:0x20] = stack[-2] // @2C81 memory[0x20:0x40] = 0x01 + stack[-3] // @2C8A storage[keccak256(memory[0x00:0x40])] = storage[0x00 + stack[-3]] // @2C8E stack[-1] = 0x01 // } // Block ends with unconditional jump to 0x2c99 label_2C94: // Incoming jump from 0x2C3F, if stack[-1] // Inputs[3] // { // @2C97 stack[-1] // @2C9A stack[-4] // @2C9B stack[-3] // } 2C94 5B JUMPDEST 2C95 60 PUSH1 0x00 2C97 90 SWAP1 2C98 50 POP 2C99 5B JUMPDEST 2C9A 92 SWAP3 2C9B 91 SWAP2 2C9C 50 POP 2C9D 50 POP 2C9E 56 *JUMP // Stack delta = -3 // Outputs[1] { @2C9A stack[-4] = 0x00 } // Block ends with unconditional jump to stack[-4] label_2C9F: // Incoming call from 0x2994, returns to 0x2995 // Inputs[4] // { // @2CA3 stack[-3] // @2CA9 stack[-2] // @2CB7 memory[0x00:0x40] // @2CB8 storage[keccak256(memory[0x00:0x40])] // } 2C9F 5B JUMPDEST 2CA0 60 PUSH1 0x00 2CA2 80 DUP1 2CA3 84 DUP5 2CA4 60 PUSH1 0x01 2CA6 01 ADD 2CA7 60 PUSH1 0x00 2CA9 85 DUP6 2CAA 81 DUP2 2CAB 52 MSTORE 2CAC 60 PUSH1 0x20 2CAE 01 ADD 2CAF 90 SWAP1 2CB0 81 DUP2 2CB1 52 MSTORE 2CB2 60 PUSH1 0x20 2CB4 01 ADD 2CB5 60 PUSH1 0x00 2CB7 20 SHA3 2CB8 54 SLOAD 2CB9 90 SWAP1 2CBA 50 POP 2CBB 60 PUSH1 0x00 2CBD 81 DUP2 2CBE 14 EQ 2CBF 15 ISZERO 2CC0 61 PUSH2 0x2d46 2CC3 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @2CA0 stack[0] = 0x00 // @2CAB memory[0x00:0x20] = stack[-2] // @2CB1 memory[0x20:0x40] = 0x01 + stack[-3] // @2CB9 stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x2d46, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) label_2CC4: // Incoming jump from 0x2CC3, if not !(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[11] // { // @2CC4 stack[-5] // @2CCA memory[0x40:0x60] // @2CD3 stack[-4] // @2CD9 stack[-3] // @2CE2 storage[0x00 + stack[-5]] // @2CF7 memory[0x00:0x20] // @2D0A memory[memory[0x40:0x60] + 0x00:memory[0x40:0x60] + 0x00 + 0x20] // @2D14 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @2D21 storage[0x00 + stack[-5]] // @2D38 memory[0x00:0x40] // @2D3F stack[-2] // } 2CC4 84 DUP5 2CC5 60 PUSH1 0x00 2CC7 01 ADD 2CC8 60 PUSH1 0x40 2CCA 51 MLOAD 2CCB 80 DUP1 2CCC 60 PUSH1 0x40 2CCE 01 ADD 2CCF 60 PUSH1 0x40 2CD1 52 MSTORE 2CD2 80 DUP1 2CD3 86 DUP7 2CD4 81 DUP2 2CD5 52 MSTORE 2CD6 60 PUSH1 0x20 2CD8 01 ADD 2CD9 85 DUP6 2CDA 81 DUP2 2CDB 52 MSTORE 2CDC 50 POP 2CDD 90 SWAP1 2CDE 80 DUP1 2CDF 60 PUSH1 0x01 2CE1 81 DUP2 2CE2 54 SLOAD 2CE3 01 ADD 2CE4 80 DUP1 2CE5 82 DUP3 2CE6 55 SSTORE 2CE7 80 DUP1 2CE8 91 SWAP2 2CE9 50 POP 2CEA 50 POP 2CEB 60 PUSH1 0x01 2CED 90 SWAP1 2CEE 03 SUB 2CEF 90 SWAP1 2CF0 60 PUSH1 0x00 2CF2 52 MSTORE 2CF3 60 PUSH1 0x20 2CF5 60 PUSH1 0x00 2CF7 20 SHA3 2CF8 90 SWAP1 2CF9 60 PUSH1 0x02 2CFB 02 MUL 2CFC 01 ADD 2CFD 60 PUSH1 0x00 2CFF 90 SWAP1 2D00 91 SWAP2 2D01 90 SWAP1 2D02 91 SWAP2 2D03 90 SWAP1 2D04 91 SWAP2 2D05 50 POP 2D06 60 PUSH1 0x00 2D08 82 DUP3 2D09 01 ADD 2D0A 51 MLOAD 2D0B 81 DUP2 2D0C 60 PUSH1 0x00 2D0E 01 ADD 2D0F 55 SSTORE 2D10 60 PUSH1 0x20 2D12 82 DUP3 2D13 01 ADD 2D14 51 MLOAD 2D15 81 DUP2 2D16 60 PUSH1 0x01 2D18 01 ADD 2D19 55 SSTORE 2D1A 50 POP 2D1B 50 POP 2D1C 84 DUP5 2D1D 60 PUSH1 0x00 2D1F 01 ADD 2D20 80 DUP1 2D21 54 SLOAD 2D22 90 SWAP1 2D23 50 POP 2D24 85 DUP6 2D25 60 PUSH1 0x01 2D27 01 ADD 2D28 60 PUSH1 0x00 2D2A 86 DUP7 2D2B 81 DUP2 2D2C 52 MSTORE 2D2D 60 PUSH1 0x20 2D2F 01 ADD 2D30 90 SWAP1 2D31 81 DUP2 2D32 52 MSTORE 2D33 60 PUSH1 0x20 2D35 01 ADD 2D36 60 PUSH1 0x00 2D38 20 SHA3 2D39 81 DUP2 2D3A 90 SWAP1 2D3B 55 SSTORE 2D3C 50 POP 2D3D 60 PUSH1 0x01 2D3F 91 SWAP2 2D40 50 POP 2D41 50 POP 2D42 61 PUSH2 0x2d74 2D45 56 *JUMP // Stack delta = -1 // Outputs[11] // { // @2CD1 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @2CD5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-4] // @2CDB memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-3] // @2CE6 storage[0x00 + stack[-5]] = storage[0x00 + stack[-5]] + 0x01 // @2CF2 memory[0x00:0x20] = 0x00 + stack[-5] // @2D0F storage[0x00 + 0x02 * ((storage[0x00 + stack[-5]] + 0x01) - 0x01) + keccak256(memory[0x00:0x20])] = memory[memory[0x40:0x60] + 0x00:memory[0x40:0x60] + 0x00 + 0x20] // @2D19 storage[0x01 + 0x02 * ((storage[0x00 + stack[-5]] + 0x01) - 0x01) + keccak256(memory[0x00:0x20])] = memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @2D2C memory[0x00:0x20] = stack[-4] // @2D32 memory[0x20:0x40] = 0x01 + stack[-5] // @2D3B storage[keccak256(memory[0x00:0x40])] = storage[0x00 + stack[-5]] // @2D3F stack[-2] = 0x01 // } // Block ends with unconditional jump to 0x2d74 label_2D46: // Incoming jump from 0x2CC3, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[4] // { // @2D47 stack[-3] // @2D48 stack[-5] // @2D4E stack[-1] // @2D51 storage[0x00 + stack[-5]] // } 2D46 5B JUMPDEST 2D47 82 DUP3 2D48 85 DUP6 2D49 60 PUSH1 0x00 2D4B 01 ADD 2D4C 60 PUSH1 0x01 2D4E 83 DUP4 2D4F 03 SUB 2D50 81 DUP2 2D51 54 SLOAD 2D52 81 DUP2 2D53 10 LT 2D54 61 PUSH2 0x2d59 2D57 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2D47 stack[0] = stack[-3] // @2D4B stack[1] = 0x00 + stack[-5] // @2D4F stack[2] = stack[-1] - 0x01 // } // Block ends with conditional jump to 0x2d59, if stack[-1] - 0x01 < storage[0x00 + stack[-5]] label_2D58: // Incoming jump from 0x2D57, if not stack[-1] - 0x01 < storage[0x00 + stack[-5]] 2D58 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2D58 assert(); } // Block terminates label_2D59: // Incoming jump from 0x2D57, if stack[-1] - 0x01 < storage[0x00 + stack[-5]] // Inputs[7] // { // @2D5A stack[-1] // @2D5A stack[-2] // @2D62 memory[0x00:0x20] // @2D6B stack[-3] // @2D71 stack[-5] // @2D75 stack[-9] // @2D76 stack[-8] // } 2D59 5B JUMPDEST 2D5A 90 SWAP1 2D5B 60 PUSH1 0x00 2D5D 52 MSTORE 2D5E 60 PUSH1 0x20 2D60 60 PUSH1 0x00 2D62 20 SHA3 2D63 90 SWAP1 2D64 60 PUSH1 0x02 2D66 02 MUL 2D67 01 ADD 2D68 60 PUSH1 0x01 2D6A 01 ADD 2D6B 81 DUP2 2D6C 90 SWAP1 2D6D 55 SSTORE 2D6E 50 POP 2D6F 60 PUSH1 0x00 2D71 91 SWAP2 2D72 50 POP 2D73 50 POP 2D74 5B JUMPDEST 2D75 93 SWAP4 2D76 92 SWAP3 2D77 50 POP 2D78 50 POP 2D79 50 POP 2D7A 56 *JUMP // Stack delta = -8 // Outputs[3] // { // @2D5D memory[0x00:0x20] = stack[-2] // @2D6D storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] = stack[-3] // @2D75 stack[-9] = 0x00 // } // Block ends with unconditional jump to stack[-9] label_2D7B: // Incoming call from 0x2B3A, returns to 0x2B3B // Incoming call from 0x2B3A, returns to 0x2B3B // Inputs[1] { @2D7E stack[-3] } 2D7B 5B JUMPDEST 2D7C 60 PUSH1 0x60 2D7E 83 DUP4 2D7F 15 ISZERO 2D80 61 PUSH2 0x2d8b 2D83 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2D7C stack[0] = 0x60 } // Block ends with conditional jump to 0x2d8b, if !stack[-3] label_2D84: // Incoming jump from 0x2D83, if not !stack[-3] // Inputs[2] // { // @2D84 stack[-3] // @2D85 stack[-1] // } 2D84 82 DUP3 2D85 90 SWAP1 2D86 50 POP 2D87 61 PUSH2 0x2e40 2D8A 56 *JUMP // Stack delta = +0 // Outputs[1] { @2D85 stack[-1] = stack[-3] } // Block ends with unconditional jump to 0x2e40 label_2D8B: // Incoming jump from 0x2D83, if !stack[-3] // Inputs[2] // { // @2D8E stack[-3] // @2D8F memory[stack[-3]:stack[-3] + 0x20] // } 2D8B 5B JUMPDEST 2D8C 60 PUSH1 0x00 2D8E 83 DUP4 2D8F 51 MLOAD 2D90 11 GT 2D91 15 ISZERO 2D92 61 PUSH2 0x2d9e 2D95 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2d9e, if !(memory[stack[-3]:stack[-3] + 0x20] > 0x00) label_2D96: // Incoming jump from 0x2D95, if not !(memory[stack[-3]:stack[-3] + 0x20] > 0x00) // Inputs[3] // { // @2D96 stack[-3] // @2D97 memory[stack[-3]:stack[-3] + 0x20] // @2D9D memory[0x20 + stack[-3]:0x20 + stack[-3] + memory[stack[-3]:stack[-3] + 0x20]] // } 2D96 82 DUP3 2D97 51 MLOAD 2D98 80 DUP1 2D99 84 DUP5 2D9A 60 PUSH1 0x20 2D9C 01 ADD 2D9D FD *REVERT // Stack delta = +1 // Outputs[2] // { // @2D97 stack[0] = memory[stack[-3]:stack[-3] + 0x20] // @2D9D revert(memory[0x20 + stack[-3]:0x20 + stack[-3] + memory[stack[-3]:stack[-3] + 0x20]]); // } // Block terminates label_2D9E: // Incoming jump from 0x2D95, if !(memory[stack[-3]:stack[-3] + 0x20] > 0x00) // Inputs[4] // { // @2D9F stack[-2] // @2DA2 memory[0x40:0x60] // @2DD6 memory[stack[-2]:stack[-2] + 0x20] // @2DDF memory[stack[-2]:stack[-2] + 0x20] // } 2D9E 5B JUMPDEST 2D9F 81 DUP2 2DA0 60 PUSH1 0x40 2DA2 51 MLOAD 2DA3 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2DC4 81 DUP2 2DC5 52 MSTORE 2DC6 60 PUSH1 0x04 2DC8 01 ADD 2DC9 80 DUP1 2DCA 80 DUP1 2DCB 60 PUSH1 0x20 2DCD 01 ADD 2DCE 82 DUP3 2DCF 81 DUP2 2DD0 03 SUB 2DD1 82 DUP3 2DD2 52 MSTORE 2DD3 83 DUP4 2DD4 81 DUP2 2DD5 81 DUP2 2DD6 51 MLOAD 2DD7 81 DUP2 2DD8 52 MSTORE 2DD9 60 PUSH1 0x20 2DDB 01 ADD 2DDC 91 SWAP2 2DDD 50 POP 2DDE 80 DUP1 2DDF 51 MLOAD 2DE0 90 SWAP1 2DE1 60 PUSH1 0x20 2DE3 01 ADD 2DE4 90 SWAP1 2DE5 80 DUP1 2DE6 83 DUP4 2DE7 83 DUP4 2DE8 60 PUSH1 0x00 2DEA 5B JUMPDEST 2DEB 83 DUP4 2DEC 81 DUP2 2DED 10 LT 2DEE 15 ISZERO 2DEF 61 PUSH2 0x2e05 2DF2 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @2D9F stack[0] = stack[-2] // @2DC5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2DC8 stack[1] = 0x04 + memory[0x40:0x60] // @2DC9 stack[2] = 0x04 + memory[0x40:0x60] // @2DD2 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2DD8 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @2DDC stack[3] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2DE4 stack[4] = 0x20 + stack[-2] // @2DE4 stack[5] = memory[stack[-2]:stack[-2] + 0x20] // @2DE5 stack[6] = memory[stack[-2]:stack[-2] + 0x20] // @2DE6 stack[7] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2DE7 stack[8] = 0x20 + stack[-2] // @2DE8 stack[9] = 0x00 // } // Block ends with conditional jump to 0x2e05, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_2DF3: // Incoming jump from 0x2DF2, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x2DF2, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @2DF3 stack[-1] // @2DF4 stack[-2] // @2DF6 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2DF8 stack[-3] // } 2DF3 80 DUP1 2DF4 82 DUP3 2DF5 01 ADD 2DF6 51 MLOAD 2DF7 81 DUP2 2DF8 84 DUP5 2DF9 01 ADD 2DFA 52 MSTORE 2DFB 60 PUSH1 0x20 2DFD 81 DUP2 2DFE 01 ADD 2DFF 90 SWAP1 2E00 50 POP 2E01 61 PUSH2 0x2dea 2E04 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2DFA memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2DFF stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x2dea label_2E05: // Incoming jump from 0x2DF2, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x2DF2, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @2E0A stack[-5] // @2E0A stack[-6] // @2E0C stack[-7] // } 2E05 5B JUMPDEST 2E06 50 POP 2E07 50 POP 2E08 50 POP 2E09 50 POP 2E0A 90 SWAP1 2E0B 50 POP 2E0C 90 SWAP1 2E0D 81 DUP2 2E0E 01 ADD 2E0F 90 SWAP1 2E10 60 PUSH1 0x1f 2E12 16 AND 2E13 80 DUP1 2E14 15 ISZERO 2E15 61 PUSH2 0x2e32 2E18 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @2E0F stack[-7] = stack[-5] + stack[-7] // @2E12 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x2e32, if !(0x1f & stack[-5]) label_2E19: // Incoming jump from 0x2E18, if not !(0x1f & stack[-5]) // Inputs[6] // { // @2E19 stack[-1] // @2E1A stack[-2] // @2E1D memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @2E34 stack[-5] // @2E3A memory[0x40:0x60] // @2E3F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 2E19 80 DUP1 2E1A 82 DUP3 2E1B 03 SUB 2E1C 80 DUP1 2E1D 51 MLOAD 2E1E 60 PUSH1 0x01 2E20 83 DUP4 2E21 60 PUSH1 0x20 2E23 03 SUB 2E24 61 PUSH2 0x0100 2E27 0A EXP 2E28 03 SUB 2E29 19 NOT 2E2A 16 AND 2E2B 81 DUP2 2E2C 52 MSTORE 2E2D 60 PUSH1 0x20 2E2F 01 ADD 2E30 91 SWAP2 2E31 50 POP 2E32 5B JUMPDEST 2E33 50 POP 2E34 92 SWAP3 2E35 50 POP 2E36 50 POP 2E37 50 POP 2E38 60 PUSH1 0x40 2E3A 51 MLOAD 2E3B 80 DUP1 2E3C 91 SWAP2 2E3D 03 SUB 2E3E 90 SWAP1 2E3F FD *REVERT // Stack delta = -5 // Outputs[2] // { // @2E2C memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @2E3F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]); // } // Block terminates label_2E40: // Incoming jump from 0x2D8A // Inputs[3] // { // @2E41 stack[-5] // @2E41 stack[-1] // @2E42 stack[-4] // } 2E40 5B JUMPDEST 2E41 93 SWAP4 2E42 92 SWAP3 2E43 50 POP 2E44 50 POP 2E45 50 POP 2E46 56 *JUMP // Stack delta = -4 // Outputs[1] { @2E41 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_2E47: // Incoming call from 0x2C3A, returns to 0x2C3B // Inputs[5] // { // @2E4B stack[-2] // @2E51 stack[-1] // @2E5F memory[0x00:0x40] // @2E60 storage[keccak256(memory[0x00:0x40])] // @2E65 stack[-3] // } 2E47 5B JUMPDEST 2E48 60 PUSH1 0x00 2E4A 80 DUP1 2E4B 83 DUP4 2E4C 60 PUSH1 0x01 2E4E 01 ADD 2E4F 60 PUSH1 0x00 2E51 84 DUP5 2E52 81 DUP2 2E53 52 MSTORE 2E54 60 PUSH1 0x20 2E56 01 ADD 2E57 90 SWAP1 2E58 81 DUP2 2E59 52 MSTORE 2E5A 60 PUSH1 0x20 2E5C 01 ADD 2E5D 60 PUSH1 0x00 2E5F 20 SHA3 2E60 54 SLOAD 2E61 14 EQ 2E62 15 ISZERO 2E63 90 SWAP1 2E64 50 POP 2E65 92 SWAP3 2E66 91 SWAP2 2E67 50 POP 2E68 50 POP 2E69 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @2E53 memory[0x00:0x20] = stack[-1] // @2E59 memory[0x20:0x40] = 0x01 + stack[-2] // @2E65 stack[-3] = !(storage[keccak256(memory[0x00:0x40])] == 0x00) // } // Block ends with unconditional jump to stack[-3] 2E6A 5B JUMPDEST 2E6B 60 PUSH1 0x00 2E6D 84 DUP5 2E6E 60 PUSH1 0x05 2E70 01 ADD 2E71 60 PUSH1 0x00 2E73 90 SWAP1 2E74 54 SLOAD 2E75 90 SWAP1 2E76 61 PUSH2 0x0100 2E79 0A EXP 2E7A 90 SWAP1 2E7B 04 DIV 2E7C 60 PUSH1 0xff 2E7E 16 AND 2E7F 15 ISZERO 2E80 61 PUSH2 0x2e88 2E83 57 *JUMPI 2E84 60 PUSH1 0x00 2E86 80 DUP1 2E87 FD *REVERT 2E88 5B JUMPDEST 2E89 61 PUSH2 0x2edc 2E8C 60 PUSH1 0x00 2E8E 86 DUP7 2E8F 60 PUSH1 0x00 2E91 01 ADD 2E92 60 PUSH1 0x00 2E94 87 DUP8 2E95 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2EAA 16 AND 2EAB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2EC0 16 AND 2EC1 81 DUP2 2EC2 52 MSTORE 2EC3 60 PUSH1 0x20 2EC5 01 ADD 2EC6 90 SWAP1 2EC7 81 DUP2 2EC8 52 MSTORE 2EC9 60 PUSH1 0x20 2ECB 01 ADD 2ECC 60 PUSH1 0x00 2ECE 20 SHA3 2ECF 61 PUSH2 0x294f 2ED2 90 SWAP1 2ED3 91 SWAP2 2ED4 90 SWAP1 2ED5 63 PUSH4 0xffffffff 2EDA 16 AND 2EDB 56 *JUMP 2EDC 5B JUMPDEST 2EDD 50 POP 2EDE 82 DUP3 2EDF 85 DUP6 2EE0 60 PUSH1 0x01 2EE2 01 ADD 2EE3 60 PUSH1 0x00 2EE5 80 DUP1 2EE6 81 DUP2 2EE7 52 MSTORE 2EE8 60 PUSH1 0x20 2EEA 01 ADD 2EEB 90 SWAP1 2EEC 81 DUP2 2EED 52 MSTORE 2EEE 60 PUSH1 0x20 2EF0 01 ADD 2EF1 60 PUSH1 0x00 2EF3 20 SHA3 2EF4 81 DUP2 2EF5 90 SWAP1 2EF6 55 SSTORE 2EF7 50 POP 2EF8 61 PUSH2 0x2f10 2EFB 60 PUSH1 0x00 2EFD 85 DUP6 2EFE 87 DUP8 2EFF 60 PUSH1 0x02 2F01 01 ADD 2F02 61 PUSH2 0x2969 2F05 90 SWAP1 2F06 92 SWAP3 2F07 91 SWAP2 2F08 90 SWAP1 2F09 63 PUSH4 0xffffffff 2F0E 16 AND 2F0F 56 *JUMP 2F10 5B JUMPDEST 2F11 50 POP 2F12 82 DUP3 2F13 85 DUP6 2F14 60 PUSH1 0x04 2F16 01 ADD 2F17 81 DUP2 2F18 90 SWAP1 2F19 55 SSTORE 2F1A 50 POP 2F1B 60 PUSH1 0x01 2F1D 85 DUP6 2F1E 60 PUSH1 0x05 2F20 01 ADD 2F21 60 PUSH1 0x00 2F23 61 PUSH2 0x0100 2F26 0A EXP 2F27 81 DUP2 2F28 54 SLOAD 2F29 81 DUP2 2F2A 60 PUSH1 0xff 2F2C 02 MUL 2F2D 19 NOT 2F2E 16 AND 2F2F 90 SWAP1 2F30 83 DUP4 2F31 15 ISZERO 2F32 15 ISZERO 2F33 02 MUL 2F34 17 OR 2F35 90 SWAP1 2F36 55 SSTORE 2F37 50 POP 2F38 81 DUP2 2F39 85 DUP6 2F3A 60 PUSH1 0x06 2F3C 01 ADD 2F3D 81 DUP2 2F3E 90 SWAP1 2F3F 55 SSTORE 2F40 50 POP 2F41 60 PUSH1 0x01 2F43 90 SWAP1 2F44 50 POP 2F45 94 SWAP5 2F46 93 SWAP4 2F47 50 POP 2F48 50 POP 2F49 50 POP 2F4A 50 POP 2F4B 56 *JUMP 2F4C FE *ASSERT 2F4D 45 GASLIMIT 2F4E 6E PUSH15 0x756d657261626c655365743a20696e 2F5E 64 PUSH5 0x6578206f75 2F64 74 PUSH21 0x206f6620626f756e64734552433732313a20747261 2F7A 6E PUSH15 0x7366657220746f206e6f6e20455243 2F8A 37 CALLDATACOPY 2F8B 32 ORIGIN 2F8C 31 BALANCE 2F8D 52 MSTORE 2F8E 65 PUSH6 0x636569766572 2F95 20 SHA3 2F96 69 PUSH10 0x6d706c656d656e746572 2FA1 4F 4F 2FA2 77 PUSH24 0x6e61626c653a206e6577206f776e65722069732074686520 2FBB 7A PUSH27 0x65726f20616464726573734552433732313a207472616e73666572 2FD7 20 SHA3 2FD8 74 PUSH21 0x6f20746865207a65726f2061646472657373416464 2FEE 72 PUSH19 0x6573733a20696e73756666696369656e742062 3002 61 PUSH2 0x6c61 3005 6E PUSH15 0x636520666f722063616c6c45524337 3015 32 ORIGIN 3016 31 BALANCE 3017 3A GASPRICE 3018 20 SHA3 3019 6F PUSH16 0x70657261746f7220717565727920666f 302A 72 PUSH19 0x206e6f6e6578697374656e7420746f6b656e45 303E 52 MSTORE 303F 43 NUMBER 3040 37 CALLDATACOPY 3041 32 ORIGIN 3042 31 BALANCE 3043 3A GASPRICE 3044 20 SHA3 3045 61 PUSH2 0x7070 3048 72 PUSH19 0x6f76652063616c6c6572206973206e6f74206f 305C 77 PUSH24 0x6e6572206e6f7220617070726f76656420666f7220616c6c 3075 45 GASLIMIT 3076 52 MSTORE 3077 43 NUMBER 3078 37 CALLDATACOPY 3079 32 ORIGIN 307A 31 BALANCE 307B 3A GASPRICE 307C 20 SHA3 307D 62 PUSH3 0x616c61 3081 6E PUSH15 0x636520717565727920666f72207468 3091 65 PUSH6 0x207a65726f20 3098 61 PUSH2 0x6464 309B 72 PUSH19 0x6573734552433732313a20617070726f766564 30AF 20 SHA3 30B0 71 PUSH18 0x7565727920666f72206e6f6e657869737465 30C3 6E PUSH15 0x7420746f6b656e4552433732313a20 30D3 74 PUSH21 0x72616e73666572206f6620746f6b656e2074686174 30E9 20 SHA3 30EA 69 PUSH10 0x73206e6f74206f776e45 30F5 52 MSTORE 30F6 43 NUMBER 30F7 37 CALLDATACOPY 30F8 32 ORIGIN 30F9 31 BALANCE 30FA 4D 4D 30FB 65 PUSH6 0x746164617461 3102 3A GASPRICE 3103 20 SHA3 3104 55 SSTORE 3105 52 MSTORE 3106 49 49 3107 20 SHA3 3108 71 PUSH18 0x7565727920666f72206e6f6e657869737465 311B 6E PUSH15 0x7420746f6b656e4552433732313a20 312B 61 PUSH2 0x7070 312E 72 PUSH19 0x6f76616c20746f2063757272656e74206f776e 3142 65 PUSH6 0x724552433732 3149 31 BALANCE 314A 3A GASPRICE 314B 20 SHA3 314C 74 PUSH21 0x72616e736665722063616c6c6572206973206e6f74 3162 20 SHA3 3163 6F PUSH16 0x776e6572206e6f7220617070726f7665 3174 64 PUSH5 0xa264697066 317A 73 PUSH20 0x58221220ff65e3d4b137417353935f1fa8326a9f 318F 4D 4D 3190 B1 DUP 3191 35 CALLDATALOAD 3192 19 NOT 3193 37 CALLDATACOPY 3194 78 PUSH25 0xce2444963c6c8ff9252d64736f6c63430006020033
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]