Online Solidity Decompiler

« Decompile another contract

Address

0xaad462c3aa6ca38ba26278cdbe4f8856c5e53586 [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.
0x0121b93f vote(uint256)
0x11ac9a92 Unknown
0x13af4035 setOwner(address)
0x1ac84690 powerOf(address)
0x20c5429b revoke(uint256)
0x2f54bf6e isOwner(address)
0x6530735e Unknown
0x7a41984b Unknown
0x86c1ff68 Unknown
0x8da5cb5b owner()
0xb9f05f2f Unknown
0xd6740cdb Unknown
0xdb3ad22c Unknown
0xf4ab9adf addVoter(address)
0xfc0c546a token()

Internal Methods

vote(arg0, arg1)
setOwner(arg0, arg1)
powerOf(arg0, arg1) returns (r0)
revoke(arg0, arg1)
isOwner(arg0, arg1) returns (r0)
func_0210(arg0, arg1) returns (r0)
func_022D(arg0, arg1) returns (r0)
func_024A(arg0, arg1)
func_0294(arg0, arg1)
addVoter(arg0, arg1)
owner(arg0) returns (r0)
func_0B1A(arg0, arg1)
func_0C94(arg0) returns (r0)
func_0C9A(arg0) returns (r0)
token(arg0) returns (r0)
func_0D11(arg0) returns (r0)
func_0D17(arg0)
func_0ED8(arg0, arg1) returns (r0)
func_0EED(arg0) returns (r0)
func_0F01(arg0, arg1) returns (r0)
func_0F1A(arg0, arg1, arg2) returns (r0)
func_0F28(arg0)

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 (0x7a41984b > var0) { if (0x1ac84690 > var0) { if (var0 == 0x0121b93f) { // Dispatch table entry for vote(uint256) var var1 = 0x0117; var var2 = 0x04; var var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } vote(var2, var3); stop(); } else if (var0 == 0x11ac9a92) { // Dispatch table entry for 0x11ac9a92 (unknown) var1 = 0x0145; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } var temp0 = var2; var2 = msg.data[temp0:temp0 + 0x20] & (0x01 << 0xa0) - 0x01; var3 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20]; var var4 = 0x00; memory[var4:var4 + 0x20] = msg.sender; memory[0x20:0x40] = 0x03; if (storage[keccak256(memory[var4:var4 + 0x40])]) { var temp1 = storage[0x00] + 0x01; storage[0x00] = temp1; var temp2 = memory[0x40:0x60]; memory[0x40:0x60] = temp2 + 0x40; var temp3 = (0x01 << 0xa0) - 0x01; memory[temp2:temp2 + 0x20] = temp3 & var2; var temp4 = temp2 + 0x20; memory[temp4:temp4 + 0x20] = var3; var temp5 = storage[0x09]; storage[0x09] = temp5 + 0x01; memory[0x00:0x20] = 0x09; var temp6 = temp5 * 0x02; var temp7 = temp6 + 0x6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7af; storage[temp7] = (temp3 & memory[temp2:temp2 + 0x20]) | (storage[temp7] & ~((0x01 << 0xa0) - 0x01)); storage[temp6 + 0x6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7b0] = memory[temp4:temp4 + 0x20]; var var5 = temp1; var var6 = storage[0x09]; var var7 = 0x061d; var var8 = var6; if (var8 > storage[0x02]) { memory[0x00:0x20] = var8; memory[0x20:0x40] = 0x04; if (!storage[keccak256(memory[0x00:0x40])]) { var temp8 = var8; storage[0x02] = temp8; var temp9 = memory[0x40:0x60]; memory[temp9:temp9 + 0x20] = msg.sender; memory[temp9 + 0x20:temp9 + 0x20 + 0x20] = temp8; var temp10 = memory[0x40:0x60]; log(memory[temp10:temp10 + temp9 - temp10 + 0x40], [0x294a8b64183582a911805b3a31b11b3c4d20c7431578897c6abcc35aae886d5e]); var var9 = 0x0cff; var var10 = temp8; func_0D17(var10); // Error: Could not resolve jump destination! } else { var temp11 = memory[0x40:0x60]; memory[temp11:temp11 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp11 + 0x04:temp11 + 0x04 + 0x20] = 0x20; memory[temp11 + 0x24:temp11 + 0x24 + 0x20] = 0x08; memory[temp11 + 0x44:temp11 + 0x44 + 0x20] = 0x766f7465735f6571 * (0x01 << 0xc0); var temp12 = memory[0x40:0x60]; revert(memory[temp12:temp12 + temp11 - temp12 + 0x64]); } } else { var temp13 = memory[0x40:0x60]; memory[temp13:temp13 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp13 + 0x04:temp13 + 0x04 + 0x20] = 0x20; memory[temp13 + 0x24:temp13 + 0x24 + 0x20] = 0x04; memory[temp13 + 0x44:temp13 + 0x44 + 0x20] = 0x1b97d9dd * (0x01 << 0xe2); var temp14 = memory[0x40:0x60]; revert(memory[temp14:temp14 + temp13 - temp14 + 0x64]); } } else { var temp15 = memory[0x40:0x60]; memory[temp15:temp15 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp15 + 0x04:temp15 + 0x04 + 0x20] = 0x20; memory[temp15 + 0x24:temp15 + 0x24 + 0x20] = 0x0c; memory[temp15 + 0x44:temp15 + 0x44 + 0x20] = 0x766f7465725f616363657373 * (0x01 << 0xa0); var temp16 = memory[0x40:0x60]; revert(memory[temp16:temp16 + temp15 - temp16 + 0x64]); } } else if (var0 == 0x13af4035) { // Dispatch table entry for setOwner(address) var1 = 0x0117; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } setOwner(var2, var3); stop(); } else { revert(memory[0x00:0x00]); } } else if (var0 == 0x1ac84690) { // Dispatch table entry for powerOf(address) var1 = 0x0145; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var1 = powerOf(var2, var3); label_0145: var temp17 = memory[0x40:0x60]; memory[temp17:temp17 + 0x20] = var1; var temp18 = memory[0x40:0x60]; return memory[temp18:temp18 + temp17 - temp18 + 0x20]; } else if (var0 == 0x20c5429b) { // Dispatch table entry for revoke(uint256) var1 = 0x0117; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } revoke(var2, var3); stop(); } else if (var0 == 0x2f54bf6e) { // Dispatch table entry for isOwner(address) var1 = 0x01e6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var1 = isOwner(var2, var3); label_01E6: var temp19 = memory[0x40:0x60]; memory[temp19:temp19 + 0x20] = !!var1; var temp20 = memory[0x40:0x60]; return memory[temp20:temp20 + temp19 - temp20 + 0x20]; } else if (var0 == 0x6530735e) { // Dispatch table entry for 0x6530735e (unknown) var1 = 0x0145; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var1 = func_0210(var2, var3); goto label_0145; } else { revert(memory[0x00:0x00]); } } else if (0xd6740cdb > var0) { if (var0 == 0x7a41984b) { // Dispatch table entry for 0x7a41984b (unknown) var1 = 0x01e6; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } var1 = func_022D(var2, var3); goto label_01E6; } else if (var0 == 0x86c1ff68) { // Dispatch table entry for 0x86c1ff68 (unknown) var1 = 0x0117; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } func_024A(var2, var3); stop(); } else if (var0 == 0x8da5cb5b) { // Dispatch table entry for owner() var1 = 0x0262; var2 = owner(); label_0262: var temp21 = memory[0x40:0x60]; memory[temp21:temp21 + 0x20] = var2 & (0x01 << 0xa0) - 0x01; var temp22 = memory[0x40:0x60]; return memory[temp22:temp22 + temp21 - temp22 + 0x20]; } else if (var0 == 0xb9f05f2f) { // Dispatch table entry for 0xb9f05f2f (unknown) var1 = 0x0117; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x40) { revert(memory[0x00:0x00]); } func_0294(var2, var3); stop(); } else { revert(memory[0x00:0x00]); } } else if (var0 == 0xd6740cdb) { // Dispatch table entry for 0xd6740cdb (unknown) var1 = 0x0145; var2 = func_0C94(); goto label_0145; } else if (var0 == 0xdb3ad22c) { // Dispatch table entry for 0xdb3ad22c (unknown) var1 = 0x0145; var2 = func_0C9A(); goto label_0145; } else if (var0 == 0xf4ab9adf) { // Dispatch table entry for addVoter(address) var1 = 0x0117; var2 = 0x04; var3 = msg.data.length - var2; if (var3 < 0x20) { revert(memory[0x00:0x00]); } addVoter(var2, var3); stop(); } else if (var0 == 0xfc0c546a) { // Dispatch table entry for token() var1 = 0x0262; var2 = token(); goto label_0262; } else { revert(memory[0x00:0x00]); } } function vote(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20]; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x03; if (storage[keccak256(memory[0x00:0x40])]) { memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x05; arg1 = arg0; if (storage[keccak256(memory[0x00:0x40])] & 0xff) { var temp10 = memory[0x40:0x60]; memory[temp10:temp10 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp10 + 0x04:temp10 + 0x04 + 0x20] = 0x20; memory[temp10 + 0x24:temp10 + 0x24 + 0x20] = 0x0c; memory[temp10 + 0x44:temp10 + 0x44 + 0x20] = 0x636f6d706c657465645f6571 * (0x01 << 0xa0); var temp11 = memory[0x40:0x60]; revert(memory[temp11:temp11 + temp10 - temp11 + 0x64]); } else if (arg1 <= 0x00) { var temp8 = memory[0x40:0x60]; memory[temp8:temp8 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp8 + 0x04:temp8 + 0x04 + 0x20] = 0x20; memory[temp8 + 0x24:temp8 + 0x24 + 0x20] = 0x04; memory[temp8 + 0x44:temp8 + 0x44 + 0x20] = 0x1b97d9dd * (0x01 << 0xe2); var temp9 = memory[0x40:0x60]; revert(memory[temp9:temp9 + temp8 - temp9 + 0x64]); } else if (arg1 <= storage[0x02]) { var var0 = 0x042b; var var1 = arg1; var0 = func_0D11(var1); if (var0) { var temp0 = storage[0x00] + 0x01; storage[0x00] = temp0; memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x06; var temp1 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = temp1; var0 = temp0; if (!storage[keccak256(memory[0x00:0x40])]) { memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x05; if (storage[keccak256(memory[0x00:0x40])] & 0xff) { revert(memory[0x00:0x00]); } var1 = 0x050b; var var2 = arg0; func_0D17(var2); if (var0 == storage[0x00]) { return; } else { revert(memory[0x00:0x00]); } } else { var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp2 + 0x04:temp2 + 0x04 + 0x20] = 0x20; memory[temp2 + 0x24:temp2 + 0x24 + 0x20] = 0x0d; memory[temp2 + 0x44:temp2 + 0x44 + 0x20] = 0x676976656e566f7465735f657100000000000000000000000000000000000000; var temp3 = memory[0x40:0x60]; revert(memory[temp3:temp3 + temp2 - temp3 + 0x64]); } } else { var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp4 + 0x04:temp4 + 0x04 + 0x20] = 0x20; memory[temp4 + 0x24:temp4 + 0x24 + 0x20] = 0x09; memory[temp4 + 0x44:temp4 + 0x44 + 0x20] = 0x6973566f7461626c65 * (0x01 << 0xb8); var temp5 = memory[0x40:0x60]; revert(memory[temp5:temp5 + temp4 - temp5 + 0x64]); } } else { var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp6 + 0x04:temp6 + 0x04 + 0x20] = 0x20; memory[temp6 + 0x24:temp6 + 0x24 + 0x20] = 0x05; memory[temp6 + 0x44:temp6 + 0x44 + 0x20] = 0x6e5f6c7465 * (0x01 << 0xd8); var temp7 = memory[0x40:0x60]; revert(memory[temp7:temp7 + temp6 - temp7 + 0x64]); } } else { var temp12 = memory[0x40:0x60]; memory[temp12:temp12 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp12 + 0x04:temp12 + 0x04 + 0x20] = 0x20; memory[temp12 + 0x24:temp12 + 0x24 + 0x20] = 0x0c; memory[temp12 + 0x44:temp12 + 0x44 + 0x20] = 0x766f7465725f616363657373 * (0x01 << 0xa0); var temp13 = memory[0x40:0x60]; revert(memory[temp13:temp13 + temp12 - temp13 + 0x64]); } } function setOwner(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20] & (0x01 << 0xa0) - 0x01; if (msg.sender == storage[0x07] & (0x01 << 0xa0) - 0x01) { var temp0 = storage[0x07]; var temp1 = (0x01 << 0xa0) - 0x01; var temp2 = (temp0 & ~((0x01 << 0xa0) - 0x01)) | (temp1 & arg0); storage[0x07] = temp2; log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, ((storage[0x07] & ~((0x01 << 0xa0) - 0x01)) | (stack[-1] & (0x01 << 0xa0) - 0x01)) & (0x01 << 0xa0) - 0x01, storage[0x07] & (0x01 << 0xa0) - 0x01]); return; } else { var temp3 = memory[0x40:0x60]; memory[temp3:temp3 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp3 + 0x04:temp3 + 0x04 + 0x20] = 0x20; memory[temp3 + 0x24:temp3 + 0x24 + 0x20] = 0x0c; memory[temp3 + 0x44:temp3 + 0x44 + 0x20] = 0x6f776e65725f616363657373 * (0x01 << 0xa0); var temp4 = memory[0x40:0x60]; revert(memory[temp4:temp4 + temp3 - temp4 + 0x64]); } } function powerOf(var arg0, var arg1) returns (var r0) { arg0 = msg.data[arg0:arg0 + 0x20] & (0x01 << 0xa0) - 0x01; memory[0x00:0x20] = arg0 & (0x01 << 0xa0) - 0x01; memory[0x20:0x40] = 0x03; return storage[keccak256(memory[0x00:0x40])]; } function revoke(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20]; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x03; if (storage[keccak256(memory[0x00:0x40])]) { memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x05; arg1 = arg0; if (storage[keccak256(memory[0x00:0x40])] & 0xff) { var temp17 = memory[0x40:0x60]; memory[temp17:temp17 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp17 + 0x04:temp17 + 0x04 + 0x20] = 0x20; memory[temp17 + 0x24:temp17 + 0x24 + 0x20] = 0x0c; memory[temp17 + 0x44:temp17 + 0x44 + 0x20] = 0x636f6d706c657465645f6571 * (0x01 << 0xa0); var temp18 = memory[0x40:0x60]; revert(memory[temp18:temp18 + temp17 - temp18 + 0x64]); } else if (arg1 <= 0x00) { var temp15 = memory[0x40:0x60]; memory[temp15:temp15 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp15 + 0x04:temp15 + 0x04 + 0x20] = 0x20; memory[temp15 + 0x24:temp15 + 0x24 + 0x20] = 0x04; memory[temp15 + 0x44:temp15 + 0x44 + 0x20] = 0x1b97d9dd * (0x01 << 0xe2); var temp16 = memory[0x40:0x60]; revert(memory[temp16:temp16 + temp15 - temp16 + 0x64]); } else if (arg1 <= storage[0x02]) { var var0 = 0x083b; var var1 = arg1; var0 = func_0D11(var1); if (var0) { memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x06; var temp0 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = temp0; if (storage[keccak256(memory[0x00:0x40])]) { var temp1 = arg0; memory[0x00:0x20] = temp1; memory[0x20:0x40] = 0x06; var temp2 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = temp2; var temp3 = storage[keccak256(memory[0x00:0x40])]; memory[0x00:0x20] = temp1; memory[0x20:0x40] = 0x04; var0 = temp3; var var2 = storage[keccak256(memory[0x00:0x40])]; var1 = 0x0922; var var3 = var0; var1 = func_0ED8(var2, var3); var temp4 = arg0; memory[0x00:0x20] = temp4; memory[0x20:0x40] = 0x04; storage[keccak256(memory[0x00:0x40])] = var1; memory[0x20:0x40] = 0x06; var temp5 = keccak256(memory[0x00:0x40]); var temp6 = msg.sender; memory[0x00:0x20] = temp6; memory[0x20:0x40] = temp5; storage[keccak256(memory[0x00:0x40])] = 0x00; var temp7 = memory[0x40:0x60]; memory[temp7:temp7 + 0x20] = temp6; memory[temp7 + 0x20:temp7 + 0x20 + 0x20] = temp4; memory[temp7 + 0x40:temp7 + 0x40 + 0x20] = var0; var temp8 = memory[0x40:0x60]; log(memory[temp8:temp8 + temp7 - temp8 + 0x60], [0x64fe3672cff9c67b9d4f039224c41fb445c7c4bc4a6c92453598ec54b3edeaca]); return; } else { var temp9 = memory[0x40:0x60]; memory[temp9:temp9 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp9 + 0x04:temp9 + 0x04 + 0x20] = 0x20; memory[temp9 + 0x24:temp9 + 0x24 + 0x20] = 0x0d; memory[temp9 + 0x44:temp9 + 0x44 + 0x20] = 0x676976656e566f7465735f6f6b00000000000000000000000000000000000000; var temp10 = memory[0x40:0x60]; revert(memory[temp10:temp10 + temp9 - temp10 + 0x64]); } } else { var temp11 = memory[0x40:0x60]; memory[temp11:temp11 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp11 + 0x04:temp11 + 0x04 + 0x20] = 0x20; memory[temp11 + 0x24:temp11 + 0x24 + 0x20] = 0x09; memory[temp11 + 0x44:temp11 + 0x44 + 0x20] = 0x6973566f7461626c65 * (0x01 << 0xb8); var temp12 = memory[0x40:0x60]; revert(memory[temp12:temp12 + temp11 - temp12 + 0x64]); } } else { var temp13 = memory[0x40:0x60]; memory[temp13:temp13 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp13 + 0x04:temp13 + 0x04 + 0x20] = 0x20; memory[temp13 + 0x24:temp13 + 0x24 + 0x20] = 0x05; memory[temp13 + 0x44:temp13 + 0x44 + 0x20] = 0x6e5f6c7465 * (0x01 << 0xd8); var temp14 = memory[0x40:0x60]; revert(memory[temp14:temp14 + temp13 - temp14 + 0x64]); } } else { var temp19 = memory[0x40:0x60]; memory[temp19:temp19 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp19 + 0x04:temp19 + 0x04 + 0x20] = 0x20; memory[temp19 + 0x24:temp19 + 0x24 + 0x20] = 0x0c; memory[temp19 + 0x44:temp19 + 0x44 + 0x20] = 0x766f7465725f616363657373 * (0x01 << 0xa0); var temp20 = memory[0x40:0x60]; revert(memory[temp20:temp20 + temp19 - temp20 + 0x64]); } } function isOwner(var arg0, var arg1) returns (var r0) { arg0 = msg.data[arg0:arg0 + 0x20] & (0x01 << 0xa0) - 0x01; arg1 = 0x00; var var0 = 0x0998; var var1 = arg0; return func_0EED(var1); } function func_0210(var arg0, var arg1) returns (var r0) { arg0 = msg.data[arg0:arg0 + 0x20]; memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x04; return storage[keccak256(memory[0x00:0x40])]; } function func_022D(var arg0, var arg1) returns (var r0) { arg0 = msg.data[arg0:arg0 + 0x20]; memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x05; return storage[keccak256(memory[0x00:0x40])] & 0xff; } function func_024A(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20] & (0x01 << 0xa0) - 0x01; if (msg.sender != storage[0x07] & (0x01 << 0xa0) - 0x01) { var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp4 + 0x04:temp4 + 0x04 + 0x20] = 0x20; memory[temp4 + 0x24:temp4 + 0x24 + 0x20] = 0x0c; memory[temp4 + 0x44:temp4 + 0x44 + 0x20] = 0x6f776e65725f616363657373 * (0x01 << 0xa0); var temp5 = memory[0x40:0x60]; revert(memory[temp5:temp5 + temp4 - temp5 + 0x64]); } else if (arg0 & (0x01 << 0xa0) - 0x01) { memory[0x00:0x20] = arg0 & (0x01 << 0xa0) - 0x01; memory[0x20:0x40] = 0x03; if (storage[keccak256(memory[0x00:0x40])]) { memory[0x00:0x20] = arg0 & (0x01 << 0xa0) - 0x01; memory[0x20:0x40] = 0x03; var var0 = storage[0x01]; arg1 = 0x0aee; var var1 = storage[keccak256(memory[0x00:0x40])]; arg1 = func_0ED8(var0, var1); storage[0x01] = arg1; memory[0x00:0x20] = arg0 & (0x01 << 0xa0) - 0x01; memory[0x20:0x40] = 0x03; storage[keccak256(memory[0x00:0x40])] = 0x00; return; } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp0 + 0x04:temp0 + 0x04 + 0x20] = 0x20; memory[temp0 + 0x24:temp0 + 0x24 + 0x20] = 0x0a; memory[temp0 + 0x44:temp0 + 0x44 + 0x20] = 0x195e1a5cdd1cd7db9bdd * (0x01 << 0xb2); var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + temp0 - temp1 + 0x64]); } } else { var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp2 + 0x04:temp2 + 0x04 + 0x20] = 0x20; memory[temp2 + 0x24:temp2 + 0x24 + 0x20] = 0x09; memory[temp2 + 0x44:temp2 + 0x44 + 0x20] = 0x766f7465725f726571 * (0x01 << 0xb8); var temp3 = memory[0x40:0x60]; revert(memory[temp3:temp3 + temp2 - temp3 + 0x64]); } } function func_0294(var arg0, var arg1) { var temp0 = arg0; arg0 = msg.data[temp0:temp0 + 0x20] & (0x01 << 0xa0) - 0x01; arg1 = msg.data[temp0 + 0x20:temp0 + 0x20 + 0x20]; func_0B1A(arg0, arg1); // Error: Could not resolve method call return address! } function addVoter(var arg0, var arg1) { arg0 = msg.data[arg0:arg0 + 0x20] & (0x01 << 0xa0) - 0x01; if (msg.sender == storage[0x07] & (0x01 << 0xa0) - 0x01) { arg1 = 0x0cff; var var0 = arg0; var var1 = 0x01; func_0B1A(var0, var1); return; } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp0 + 0x04:temp0 + 0x04 + 0x20] = 0x20; memory[temp0 + 0x24:temp0 + 0x24 + 0x20] = 0x0c; memory[temp0 + 0x44:temp0 + 0x44 + 0x20] = 0x6f776e65725f616363657373 * (0x01 << 0xa0); var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + temp0 - temp1 + 0x64]); } } function owner() returns (var r0) { return storage[0x07] & (0x01 << 0xa0) - 0x01; } function func_0B1A(var arg0, var arg1) { if (msg.sender != storage[0x07] & (0x01 << 0xa0) - 0x01) { var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp6 + 0x04:temp6 + 0x04 + 0x20] = 0x20; memory[temp6 + 0x24:temp6 + 0x24 + 0x20] = 0x0c; memory[temp6 + 0x44:temp6 + 0x44 + 0x20] = 0x6f776e65725f616363657373 * (0x01 << 0xa0); var temp7 = memory[0x40:0x60]; revert(memory[temp7:temp7 + temp6 - temp7 + 0x64]); } else if (arg0 & (0x01 << 0xa0) - 0x01) { memory[0x00:0x20] = arg0 & (0x01 << 0xa0) - 0x01; memory[0x20:0x40] = 0x03; if (storage[keccak256(memory[0x00:0x40])]) { var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp2 + 0x04:temp2 + 0x04 + 0x20] = 0x20; memory[temp2 + 0x24:temp2 + 0x24 + 0x20] = 0x0a; memory[temp2 + 0x44:temp2 + 0x44 + 0x20] = 0x195e1a5cdd1cd7db9bdd * (0x01 << 0xb2); var temp3 = memory[0x40:0x60]; revert(memory[temp3:temp3 + temp2 - temp3 + 0x64]); } else if (arg1 > 0x00) { memory[0x00:0x20] = arg0 & (0x01 << 0xa0) - 0x01; memory[0x20:0x40] = 0x03; storage[keccak256(memory[0x00:0x40])] = arg1; var var0 = 0x0c8d; var var1 = storage[0x01]; var var2 = arg1; var0 = func_0F01(var1, var2); storage[0x01] = var0; return; } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp0 + 0x04:temp0 + 0x04 + 0x20] = 0x20; memory[temp0 + 0x24:temp0 + 0x24 + 0x20] = 0x08; memory[temp0 + 0x44:temp0 + 0x44 + 0x20] = 0x1d9bdd195cd7d9dd * (0x01 << 0xc2); var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + temp0 - temp1 + 0x64]); } } else { var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp4 + 0x04:temp4 + 0x04 + 0x20] = 0x20; memory[temp4 + 0x24:temp4 + 0x24 + 0x20] = 0x09; memory[temp4 + 0x44:temp4 + 0x44 + 0x20] = 0x766f7465725f726571 * (0x01 << 0xb8); var temp5 = memory[0x40:0x60]; revert(memory[temp5:temp5 + temp4 - temp5 + 0x64]); } } function func_0C94() returns (var r0) { return storage[0x02]; } function func_0C9A() returns (var r0) { return storage[0x01]; } function token() returns (var r0) { return storage[0x08] & (0x01 << 0xa0) - 0x01; } function func_0D11(var arg0) returns (var r0) { return 0x01; } function func_0D17(var arg0) { memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x03; var temp0 = storage[keccak256(memory[0x00:0x40])]; memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x04; var var0 = temp0; var var1 = 0x0d46; var var2 = storage[keccak256(memory[0x00:0x40])]; var var3 = var0; var1 = func_0F01(var2, var3); var temp1 = arg0; memory[0x00:0x20] = temp1; memory[0x20:0x40] = 0x04; storage[keccak256(memory[0x00:0x40])] = var1; var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = msg.sender; memory[temp2 + 0x20:temp2 + 0x20 + 0x20] = temp1; var temp3 = var0; memory[temp2 + 0x40:temp2 + 0x40 + 0x20] = temp3; var temp4 = memory[0x40:0x60]; log(memory[temp4:temp4 + temp2 - temp4 + 0x60], [0x7fceb43eed04ef82929f3934ad976c493fa8028f5b17a07f0d41bfea4b2e83ed]); memory[0x00:0x20] = temp1; memory[0x20:0x40] = 0x06; var temp5 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = temp5; storage[keccak256(memory[0x00:0x40])] = temp3; memory[0x00:0x20] = temp1; memory[0x20:0x40] = 0x04; var1 = 0x0dcd; var3 = storage[keccak256(memory[0x00:0x40])]; var var4 = storage[0x01]; var2 = temp1; var1 = func_0F1A(var2, var3, var4); if (!var1) { label_0DF4: return; } else { memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x05; var temp6 = keccak256(memory[0x00:0x40]); storage[temp6] = (storage[temp6] & ~0xff) | 0x01; var1 = 0x0df4; var2 = arg0; func_0F28(var2); goto label_0DF4; } } function func_0ED8(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg1 <= arg0) { return arg0 - arg1; } else { revert(memory[0x00:0x00]); } } function func_0EED(var arg0) returns (var r0) { var temp0 = (0x01 << 0xa0) - 0x01; return temp0 & storage[0x07] == temp0 & arg0; } function func_0F01(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var temp0 = arg0; var var1 = arg1 + temp0; if (var1 >= temp0) { return var1; } else { revert(memory[0x00:0x00]); } } function func_0F1A(var arg0, var arg1, var arg2) returns (var r0) { return arg2 / 0x02 + 0x01 <= arg1; } function func_0F28(var arg0) { var var0 = 0x00; var var1 = 0x09; var var2 = arg0 - 0x01; if (var2 >= storage[var1]) { assert(); } memory[0x00:0x20] = var1; var temp0 = keccak256(memory[0x00:0x20]); var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x70a08231 * (0x01 << 0xe0); memory[temp1 + 0x04:temp1 + 0x04 + 0x20] = address(this); var0 = temp0 + var2 * 0x02; var var4 = 0x20; var1 = storage[0x08] & (0x01 << 0xa0) - 0x01; var var5 = memory[0x40:0x60]; var2 = 0x70a08231; var var3 = temp1 + 0x24; var var6 = temp1 - var5 + 0x24; var var7 = var5; var var8 = var1; var var9 = !address(var8).code.length; if (var9) { revert(memory[0x00:0x00]); } var temp2; temp2, memory[var5:var5 + var4] = address(var8).staticcall.gas(msg.gas)(memory[var7:var7 + var6]); var4 = !temp2; if (!var4) { var1 = memory[0x40:0x60]; var2 = returndata.length; if (var2 < 0x20) { revert(memory[0x00:0x00]); } if (storage[var0 + 0x01] <= memory[var1:var1 + 0x20]) { var temp3 = var0; var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = 0xa9059cbb * (0x01 << 0xe0); var temp5 = (0x01 << 0xa0) - 0x01; memory[temp4 + 0x04:temp4 + 0x04 + 0x20] = temp5 & storage[temp3]; memory[temp4 + 0x24:temp4 + 0x24 + 0x20] = storage[temp3 + 0x01]; var1 = storage[0x08] & temp5; var2 = 0xa9059cbb; var3 = temp4 + 0x44; var4 = 0x20; var5 = memory[0x40:0x60]; var6 = temp4 - var5 + 0x44; var7 = var5; var8 = 0x00; var9 = var1; var var10 = !address(var9).code.length; if (var10) { revert(memory[0x00:0x00]); } var temp6; temp6, memory[var5:var5 + var4] = address(var9).call.gas(msg.gas).value(var8)(memory[var7:var7 + var6]); var4 = !temp6; if (!var4) { var1 = memory[0x40:0x60]; var2 = returndata.length; if (var2 < 0x20) { revert(memory[0x00:0x00]); } if (memory[var1:var1 + 0x20]) { var temp7 = var0; var temp8 = memory[0x40:0x60]; memory[temp8:temp8 + 0x20] = storage[temp7] & (0x01 << 0xa0) - 0x01; memory[temp8 + 0x20:temp8 + 0x20 + 0x20] = storage[temp7 + 0x01]; var temp9 = memory[0x40:0x60]; log(memory[temp9:temp9 + temp8 - temp9 + 0x40], [0xe6d858f14d755446648a6e0c8ab8b5a0f58ccc7920d4c910b0454e4dcd869af0]); return; } else { var temp10 = memory[0x40:0x60]; memory[temp10:temp10 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp10 + 0x04:temp10 + 0x04 + 0x20] = 0x20; memory[temp10 + 0x24:temp10 + 0x24 + 0x20] = 0x0b; memory[temp10 + 0x44:temp10 + 0x44 + 0x20] = 0x1d1c985b9cd9995c9c9959 * (0x01 << 0xaa); var temp11 = memory[0x40:0x60]; revert(memory[temp11:temp11 + temp10 - temp11 + 0x64]); } } else { var temp12 = returndata.length; memory[0x00:0x00 + temp12] = returndata[0x00:0x00 + temp12]; revert(memory[0x00:0x00 + returndata.length]); } } else { var temp13 = memory[0x40:0x60]; memory[temp13:temp13 + 0x20] = 0x461bcd * (0x01 << 0xe5); memory[temp13 + 0x04:temp13 + 0x04 + 0x20] = 0x20; memory[temp13 + 0x24:temp13 + 0x24 + 0x20] = 0x0d; memory[temp13 + 0x44:temp13 + 0x44 + 0x20] = 0x616d6f756e745f656e6f75676800000000000000000000000000000000000000; var temp14 = memory[0x40:0x60]; revert(memory[temp14:temp14 + temp13 - temp14 + 0x64]); } } else { var temp15 = returndata.length; memory[0x00:0x00 + temp15] = returndata[0x00:0x00 + temp15]; revert(memory[0x00:0x00 + returndata.length]); } } }

Disassembly

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x00f5 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x00f5, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x7a41984b 0026 11 GT 0027 61 PUSH2 0x0097 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0097, if 0x7a41984b > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x7a41984b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xd6740cdb 0031 11 GT 0032 61 PUSH2 0x0066 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0066, if 0xd6740cdb > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xd6740cdb > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xd6740cdb 003C 14 EQ 003D 61 PUSH2 0x02aa 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02aa, if 0xd6740cdb == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xd6740cdb == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xdb3ad22c 0047 14 EQ 0048 61 PUSH2 0x02b2 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b2, if 0xdb3ad22c == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xdb3ad22c == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xf4ab9adf 0052 14 EQ 0053 61 PUSH2 0x02ba 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ba, if 0xf4ab9adf == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xf4ab9adf == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xfc0c546a 005D 14 EQ 005E 61 PUSH2 0x02e0 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e0, if 0xfc0c546a == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xfc0c546a == stack[-1] 0062 61 PUSH2 0x00f5 0065 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00f5 label_0066: // Incoming jump from 0x0035, if 0xd6740cdb > stack[-1] // Inputs[1] { @0067 stack[-1] } 0066 5B JUMPDEST 0067 80 DUP1 0068 63 PUSH4 0x7a41984b 006D 14 EQ 006E 61 PUSH2 0x0217 0071 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0217, if 0x7a41984b == stack[-1] label_0072: // Incoming jump from 0x0071, if not 0x7a41984b == stack[-1] // Inputs[1] { @0072 stack[-1] } 0072 80 DUP1 0073 63 PUSH4 0x86c1ff68 0078 14 EQ 0079 61 PUSH2 0x0234 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0234, if 0x86c1ff68 == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0x86c1ff68 == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0x8da5cb5b 0083 14 EQ 0084 61 PUSH2 0x025a 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x025a, if 0x8da5cb5b == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xb9f05f2f 008E 14 EQ 008F 61 PUSH2 0x027e 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x027e, if 0xb9f05f2f == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xb9f05f2f == stack[-1] 0093 61 PUSH2 0x00f5 0096 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00f5 label_0097: // Incoming jump from 0x002A, if 0x7a41984b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0098 stack[-1] } 0097 5B JUMPDEST 0098 80 DUP1 0099 63 PUSH4 0x1ac84690 009E 11 GT 009F 61 PUSH2 0x00d3 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d3, if 0x1ac84690 > stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0x1ac84690 > stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0x1ac84690 00A9 14 EQ 00AA 61 PUSH2 0x017d 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x017d, if 0x1ac84690 == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x1ac84690 == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x20c5429b 00B4 14 EQ 00B5 61 PUSH2 0x01a3 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a3, if 0x20c5429b == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x20c5429b == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x2f54bf6e 00BF 14 EQ 00C0 61 PUSH2 0x01c0 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c0, if 0x2f54bf6e == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x2f54bf6e == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x6530735e 00CA 14 EQ 00CB 61 PUSH2 0x01fa 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01fa, if 0x6530735e == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x6530735e == stack[-1] 00CF 61 PUSH2 0x00f5 00D2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00f5 label_00D3: // Incoming jump from 0x00A2, if 0x1ac84690 > stack[-1] // Inputs[1] { @00D4 stack[-1] } 00D3 5B JUMPDEST 00D4 80 DUP1 00D5 63 PUSH4 0x0121b93f 00DA 14 EQ 00DB 61 PUSH2 0x00fa 00DE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00fa, if 0x0121b93f == stack[-1] label_00DF: // Incoming jump from 0x00DE, if not 0x0121b93f == stack[-1] // Inputs[1] { @00DF stack[-1] } 00DF 80 DUP1 00E0 63 PUSH4 0x11ac9a92 00E5 14 EQ 00E6 61 PUSH2 0x0119 00E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0119, if 0x11ac9a92 == stack[-1] label_00EA: // Incoming jump from 0x00E9, if not 0x11ac9a92 == stack[-1] // Inputs[1] { @00EA stack[-1] } 00EA 80 DUP1 00EB 63 PUSH4 0x13af4035 00F0 14 EQ 00F1 61 PUSH2 0x0157 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0157, if 0x13af4035 == stack[-1] label_00F5: // Incoming jump from 0x0065 // Incoming jump from 0x0096 // Incoming jump from 0x00D2 // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x00F4, if not 0x13af4035 == stack[-1] // Inputs[1] { @00F9 memory[0x00:0x00] } 00F5 5B JUMPDEST 00F6 60 PUSH1 0x00 00F8 80 DUP1 00F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F9 revert(memory[0x00:0x00]); } // Block terminates label_00FA: // Incoming jump from 0x00DE, if 0x0121b93f == stack[-1] // Inputs[1] { @0101 msg.data.length } 00FA 5B JUMPDEST 00FB 61 PUSH2 0x0117 00FE 60 PUSH1 0x04 0100 80 DUP1 0101 36 CALLDATASIZE 0102 03 SUB 0103 60 PUSH1 0x20 0105 81 DUP2 0106 10 LT 0107 15 ISZERO 0108 61 PUSH2 0x0110 010B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @00FB stack[0] = 0x0117 // @00FE stack[1] = 0x04 // @0102 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0110, returns to 0x0117, if !(msg.data.length - 0x04 < 0x20) label_010C: // Incoming jump from 0x010B, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @010F memory[0x00:0x00] } 010C 60 PUSH1 0x00 010E 80 DUP1 010F FD *REVERT // Stack delta = +0 // Outputs[1] { @010F revert(memory[0x00:0x00]); } // Block terminates label_0110: // Incoming call from 0x010B, returns to 0x0117, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0112 msg.data[stack[-2]:stack[-2] + 0x20] // @0112 stack[-2] // } 0110 5B JUMPDEST 0111 50 POP 0112 35 CALLDATALOAD 0113 61 PUSH2 0x02e8 0116 56 *JUMP // Stack delta = -1 // Outputs[1] { @0112 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x02e8 label_0117: // Incoming return from call to 0x0110 at 0x010B // Incoming return from call to 0x01B9 at 0x01B4 // Incoming return from call to 0x024A at 0x0245 // Incoming return from call to 0x0294 at 0x028F // Incoming return from call to 0x02D0 at 0x02CB // Incoming return from call to 0x016D at 0x0168 0117 5B JUMPDEST 0118 00 *STOP // Stack delta = +0 // Outputs[1] { @0118 stop(); } // Block terminates label_0119: // Incoming jump from 0x00E9, if 0x11ac9a92 == stack[-1] // Inputs[1] { @0120 msg.data.length } 0119 5B JUMPDEST 011A 61 PUSH2 0x0145 011D 60 PUSH1 0x04 011F 80 DUP1 0120 36 CALLDATASIZE 0121 03 SUB 0122 60 PUSH1 0x40 0124 81 DUP2 0125 10 LT 0126 15 ISZERO 0127 61 PUSH2 0x012f 012A 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @011A stack[0] = 0x0145 // @011D stack[1] = 0x04 // @0121 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x012f, if !(msg.data.length - 0x04 < 0x40) label_012B: // Incoming jump from 0x012A, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @012E memory[0x00:0x00] } 012B 60 PUSH1 0x00 012D 80 DUP1 012E FD *REVERT // Stack delta = +0 // Outputs[1] { @012E revert(memory[0x00:0x00]); } // Block terminates label_012F: // Incoming jump from 0x012A, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0139 stack[-2] // @013A msg.data[stack[-2]:stack[-2] + 0x20] // @0140 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 012F 5B JUMPDEST 0130 50 POP 0131 60 PUSH1 0x01 0133 60 PUSH1 0x01 0135 60 PUSH1 0xa0 0137 1B SHL 0138 03 SUB 0139 81 DUP2 013A 35 CALLDATALOAD 013B 16 AND 013C 90 SWAP1 013D 60 PUSH1 0x20 013F 01 ADD 0140 35 CALLDATALOAD 0141 61 PUSH2 0x051e 0144 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @013C stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0140 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x051e label_0145: // Incoming return from call to 0x0210 at 0x020B // Incoming return from call to 0x0193 at 0x018E // Incoming return from call to 0x0C9A at 0x02B9 // Incoming return from call to 0x0C94 at 0x02B1 // Inputs[4] // { // @0149 memory[0x40:0x60] // @014A stack[-1] // @014D memory[0x40:0x60] // @0156 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0145 5B JUMPDEST 0146 60 PUSH1 0x40 0148 80 DUP1 0149 51 MLOAD 014A 91 SWAP2 014B 82 DUP3 014C 52 MSTORE 014D 51 MLOAD 014E 90 SWAP1 014F 81 DUP2 0150 90 SWAP1 0151 03 SUB 0152 60 PUSH1 0x20 0154 01 ADD 0155 90 SWAP1 0156 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @014C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0156 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0157: // Incoming jump from 0x00F4, if 0x13af4035 == stack[-1] // Inputs[1] { @015E msg.data.length } 0157 5B JUMPDEST 0158 61 PUSH2 0x0117 015B 60 PUSH1 0x04 015D 80 DUP1 015E 36 CALLDATASIZE 015F 03 SUB 0160 60 PUSH1 0x20 0162 81 DUP2 0163 10 LT 0164 15 ISZERO 0165 61 PUSH2 0x016d 0168 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0158 stack[0] = 0x0117 // @015B stack[1] = 0x04 // @015F stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x016d, returns to 0x0117, if !(msg.data.length - 0x04 < 0x20) label_0169: // Incoming jump from 0x0168, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @016C memory[0x00:0x00] } 0169 60 PUSH1 0x00 016B 80 DUP1 016C FD *REVERT // Stack delta = +0 // Outputs[1] { @016C revert(memory[0x00:0x00]); } // Block terminates label_016D: // Incoming call from 0x0168, returns to 0x0117, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @016F msg.data[stack[-2]:stack[-2] + 0x20] // @016F stack[-2] // } 016D 5B JUMPDEST 016E 50 POP 016F 35 CALLDATALOAD 0170 60 PUSH1 0x01 0172 60 PUSH1 0x01 0174 60 PUSH1 0xa0 0176 1B SHL 0177 03 SUB 0178 16 AND 0179 61 PUSH2 0x0634 017C 56 *JUMP // Stack delta = -1 // Outputs[1] { @0178 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0634 label_017D: // Incoming jump from 0x00AD, if 0x1ac84690 == stack[-1] // Inputs[1] { @0184 msg.data.length } 017D 5B JUMPDEST 017E 61 PUSH2 0x0145 0181 60 PUSH1 0x04 0183 80 DUP1 0184 36 CALLDATASIZE 0185 03 SUB 0186 60 PUSH1 0x20 0188 81 DUP2 0189 10 LT 018A 15 ISZERO 018B 61 PUSH2 0x0193 018E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @017E stack[0] = 0x0145 // @0181 stack[1] = 0x04 // @0185 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0193, returns to 0x0145, if !(msg.data.length - 0x04 < 0x20) label_018F: // Incoming jump from 0x018E, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0192 memory[0x00:0x00] } 018F 60 PUSH1 0x00 0191 80 DUP1 0192 FD *REVERT // Stack delta = +0 // Outputs[1] { @0192 revert(memory[0x00:0x00]); } // Block terminates label_0193: // Incoming call from 0x018E, returns to 0x0145, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0195 msg.data[stack[-2]:stack[-2] + 0x20] // @0195 stack[-2] // } 0193 5B JUMPDEST 0194 50 POP 0195 35 CALLDATALOAD 0196 60 PUSH1 0x01 0198 60 PUSH1 0x01 019A 60 PUSH1 0xa0 019C 1B SHL 019D 03 SUB 019E 16 AND 019F 61 PUSH2 0x06dd 01A2 56 *JUMP // Stack delta = -1 // Outputs[1] { @019E stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x06dd label_01A3: // Incoming jump from 0x00B8, if 0x20c5429b == stack[-1] // Inputs[1] { @01AA msg.data.length } 01A3 5B JUMPDEST 01A4 61 PUSH2 0x0117 01A7 60 PUSH1 0x04 01A9 80 DUP1 01AA 36 CALLDATASIZE 01AB 03 SUB 01AC 60 PUSH1 0x20 01AE 81 DUP2 01AF 10 LT 01B0 15 ISZERO 01B1 61 PUSH2 0x01b9 01B4 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @01A4 stack[0] = 0x0117 // @01A7 stack[1] = 0x04 // @01AB stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x01b9, returns to 0x0117, if !(msg.data.length - 0x04 < 0x20) label_01B5: // Incoming jump from 0x01B4, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @01B8 memory[0x00:0x00] } 01B5 60 PUSH1 0x00 01B7 80 DUP1 01B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @01B8 revert(memory[0x00:0x00]); } // Block terminates label_01B9: // Incoming call from 0x01B4, returns to 0x0117, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @01BB stack[-2] // @01BB msg.data[stack[-2]:stack[-2] + 0x20] // } 01B9 5B JUMPDEST 01BA 50 POP 01BB 35 CALLDATALOAD 01BC 61 PUSH2 0x06f8 01BF 56 *JUMP // Stack delta = -1 // Outputs[1] { @01BB stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x06f8 label_01C0: // Incoming jump from 0x00C3, if 0x2f54bf6e == stack[-1] // Inputs[1] { @01C7 msg.data.length } 01C0 5B JUMPDEST 01C1 61 PUSH2 0x01e6 01C4 60 PUSH1 0x04 01C6 80 DUP1 01C7 36 CALLDATASIZE 01C8 03 SUB 01C9 60 PUSH1 0x20 01CB 81 DUP2 01CC 10 LT 01CD 15 ISZERO 01CE 61 PUSH2 0x01d6 01D1 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @01C1 stack[0] = 0x01e6 // @01C4 stack[1] = 0x04 // @01C8 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x01d6, returns to 0x01E6, if !(msg.data.length - 0x04 < 0x20) label_01D2: // Incoming jump from 0x01D1, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @01D5 memory[0x00:0x00] } 01D2 60 PUSH1 0x00 01D4 80 DUP1 01D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D5 revert(memory[0x00:0x00]); } // Block terminates label_01D6: // Incoming call from 0x01D1, returns to 0x01E6, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @01D8 stack[-2] // @01D8 msg.data[stack[-2]:stack[-2] + 0x20] // } 01D6 5B JUMPDEST 01D7 50 POP 01D8 35 CALLDATALOAD 01D9 60 PUSH1 0x01 01DB 60 PUSH1 0x01 01DD 60 PUSH1 0xa0 01DF 1B SHL 01E0 03 SUB 01E1 16 AND 01E2 61 PUSH2 0x098d 01E5 56 *JUMP // Stack delta = -1 // Outputs[1] { @01E1 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x098d label_01E6: // Incoming return from call to 0x022D at 0x0228 // Incoming return from call to 0x01D6 at 0x01D1 // Inputs[4] // { // @01EA memory[0x40:0x60] // @01EB stack[-1] // @01F0 memory[0x40:0x60] // @01F9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 01E6 5B JUMPDEST 01E7 60 PUSH1 0x40 01E9 80 DUP1 01EA 51 MLOAD 01EB 91 SWAP2 01EC 15 ISZERO 01ED 15 ISZERO 01EE 82 DUP3 01EF 52 MSTORE 01F0 51 MLOAD 01F1 90 SWAP1 01F2 81 DUP2 01F3 90 SWAP1 01F4 03 SUB 01F5 60 PUSH1 0x20 01F7 01 ADD 01F8 90 SWAP1 01F9 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @01F9 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_01FA: // Incoming jump from 0x00CE, if 0x6530735e == stack[-1] // Inputs[1] { @0201 msg.data.length } 01FA 5B JUMPDEST 01FB 61 PUSH2 0x0145 01FE 60 PUSH1 0x04 0200 80 DUP1 0201 36 CALLDATASIZE 0202 03 SUB 0203 60 PUSH1 0x20 0205 81 DUP2 0206 10 LT 0207 15 ISZERO 0208 61 PUSH2 0x0210 020B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @01FB stack[0] = 0x0145 // @01FE stack[1] = 0x04 // @0202 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0210, returns to 0x0145, if !(msg.data.length - 0x04 < 0x20) label_020C: // Incoming jump from 0x020B, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @020F memory[0x00:0x00] } 020C 60 PUSH1 0x00 020E 80 DUP1 020F FD *REVERT // Stack delta = +0 // Outputs[1] { @020F revert(memory[0x00:0x00]); } // Block terminates label_0210: // Incoming call from 0x020B, returns to 0x0145, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0212 msg.data[stack[-2]:stack[-2] + 0x20] // @0212 stack[-2] // } 0210 5B JUMPDEST 0211 50 POP 0212 35 CALLDATALOAD 0213 61 PUSH2 0x099e 0216 56 *JUMP // Stack delta = -1 // Outputs[1] { @0212 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x099e label_0217: // Incoming jump from 0x0071, if 0x7a41984b == stack[-1] // Inputs[1] { @021E msg.data.length } 0217 5B JUMPDEST 0218 61 PUSH2 0x01e6 021B 60 PUSH1 0x04 021D 80 DUP1 021E 36 CALLDATASIZE 021F 03 SUB 0220 60 PUSH1 0x20 0222 81 DUP2 0223 10 LT 0224 15 ISZERO 0225 61 PUSH2 0x022d 0228 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0218 stack[0] = 0x01e6 // @021B stack[1] = 0x04 // @021F stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x022d, returns to 0x01E6, if !(msg.data.length - 0x04 < 0x20) label_0229: // Incoming jump from 0x0228, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @022C memory[0x00:0x00] } 0229 60 PUSH1 0x00 022B 80 DUP1 022C FD *REVERT // Stack delta = +0 // Outputs[1] { @022C revert(memory[0x00:0x00]); } // Block terminates label_022D: // Incoming call from 0x0228, returns to 0x01E6, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @022F msg.data[stack[-2]:stack[-2] + 0x20] // @022F stack[-2] // } 022D 5B JUMPDEST 022E 50 POP 022F 35 CALLDATALOAD 0230 61 PUSH2 0x09b0 0233 56 *JUMP // Stack delta = -1 // Outputs[1] { @022F stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x09b0 label_0234: // Incoming jump from 0x007C, if 0x86c1ff68 == stack[-1] // Inputs[1] { @023B msg.data.length } 0234 5B JUMPDEST 0235 61 PUSH2 0x0117 0238 60 PUSH1 0x04 023A 80 DUP1 023B 36 CALLDATASIZE 023C 03 SUB 023D 60 PUSH1 0x20 023F 81 DUP2 0240 10 LT 0241 15 ISZERO 0242 61 PUSH2 0x024a 0245 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0235 stack[0] = 0x0117 // @0238 stack[1] = 0x04 // @023C stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x024a, returns to 0x0117, if !(msg.data.length - 0x04 < 0x20) label_0246: // Incoming jump from 0x0245, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0249 memory[0x00:0x00] } 0246 60 PUSH1 0x00 0248 80 DUP1 0249 FD *REVERT // Stack delta = +0 // Outputs[1] { @0249 revert(memory[0x00:0x00]); } // Block terminates label_024A: // Incoming call from 0x0245, returns to 0x0117, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @024C msg.data[stack[-2]:stack[-2] + 0x20] // @024C stack[-2] // } 024A 5B JUMPDEST 024B 50 POP 024C 35 CALLDATALOAD 024D 60 PUSH1 0x01 024F 60 PUSH1 0x01 0251 60 PUSH1 0xa0 0253 1B SHL 0254 03 SUB 0255 16 AND 0256 61 PUSH2 0x09c5 0259 56 *JUMP // Stack delta = -1 // Outputs[1] { @0255 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x09c5 label_025A: // Incoming jump from 0x0087, if 0x8da5cb5b == stack[-1] 025A 5B JUMPDEST 025B 61 PUSH2 0x0262 025E 61 PUSH2 0x0b0b 0261 56 *JUMP // Stack delta = +1 // Outputs[1] { @025B stack[0] = 0x0262 } // Block ends with call to 0x0b0b, returns to 0x0262 label_0262: // Incoming return from call to 0x0D02 at 0x02E7 // Incoming return from call to 0x0B0B at 0x0261 // Inputs[4] // { // @0266 memory[0x40:0x60] // @0270 stack[-1] // @0274 memory[0x40:0x60] // @027D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0262 5B JUMPDEST 0263 60 PUSH1 0x40 0265 80 DUP1 0266 51 MLOAD 0267 60 PUSH1 0x01 0269 60 PUSH1 0x01 026B 60 PUSH1 0xa0 026D 1B SHL 026E 03 SUB 026F 90 SWAP1 0270 92 SWAP3 0271 16 AND 0272 82 DUP3 0273 52 MSTORE 0274 51 MLOAD 0275 90 SWAP1 0276 81 DUP2 0277 90 SWAP1 0278 03 SUB 0279 60 PUSH1 0x20 027B 01 ADD 027C 90 SWAP1 027D F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0273 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @027D return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_027E: // Incoming jump from 0x0092, if 0xb9f05f2f == stack[-1] // Inputs[1] { @0285 msg.data.length } 027E 5B JUMPDEST 027F 61 PUSH2 0x0117 0282 60 PUSH1 0x04 0284 80 DUP1 0285 36 CALLDATASIZE 0286 03 SUB 0287 60 PUSH1 0x40 0289 81 DUP2 028A 10 LT 028B 15 ISZERO 028C 61 PUSH2 0x0294 028F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @027F stack[0] = 0x0117 // @0282 stack[1] = 0x04 // @0286 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0294, returns to 0x0117, if !(msg.data.length - 0x04 < 0x40) label_0290: // Incoming jump from 0x028F, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0293 memory[0x00:0x00] } 0290 60 PUSH1 0x00 0292 80 DUP1 0293 FD *REVERT // Stack delta = +0 // Outputs[1] { @0293 revert(memory[0x00:0x00]); } // Block terminates label_0294: // Incoming call from 0x028F, returns to 0x0117, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @029E stack[-2] // @029F msg.data[stack[-2]:stack[-2] + 0x20] // @02A5 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0294 5B JUMPDEST 0295 50 POP 0296 60 PUSH1 0x01 0298 60 PUSH1 0x01 029A 60 PUSH1 0xa0 029C 1B SHL 029D 03 SUB 029E 81 DUP2 029F 35 CALLDATALOAD 02A0 16 AND 02A1 90 SWAP1 02A2 60 PUSH1 0x20 02A4 01 ADD 02A5 35 CALLDATALOAD 02A6 61 PUSH2 0x0b1a 02A9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02A1 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @02A5 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0b1a label_02AA: // Incoming jump from 0x0040, if 0xd6740cdb == stack[-1] 02AA 5B JUMPDEST 02AB 61 PUSH2 0x0145 02AE 61 PUSH2 0x0c94 02B1 56 *JUMP // Stack delta = +1 // Outputs[1] { @02AB stack[0] = 0x0145 } // Block ends with call to 0x0c94, returns to 0x0145 label_02B2: // Incoming jump from 0x004B, if 0xdb3ad22c == stack[-1] 02B2 5B JUMPDEST 02B3 61 PUSH2 0x0145 02B6 61 PUSH2 0x0c9a 02B9 56 *JUMP // Stack delta = +1 // Outputs[1] { @02B3 stack[0] = 0x0145 } // Block ends with call to 0x0c9a, returns to 0x0145 label_02BA: // Incoming jump from 0x0056, if 0xf4ab9adf == stack[-1] // Inputs[1] { @02C1 msg.data.length } 02BA 5B JUMPDEST 02BB 61 PUSH2 0x0117 02BE 60 PUSH1 0x04 02C0 80 DUP1 02C1 36 CALLDATASIZE 02C2 03 SUB 02C3 60 PUSH1 0x20 02C5 81 DUP2 02C6 10 LT 02C7 15 ISZERO 02C8 61 PUSH2 0x02d0 02CB 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @02BB stack[0] = 0x0117 // @02BE stack[1] = 0x04 // @02C2 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x02d0, returns to 0x0117, if !(msg.data.length - 0x04 < 0x20) label_02CC: // Incoming jump from 0x02CB, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @02CF memory[0x00:0x00] } 02CC 60 PUSH1 0x00 02CE 80 DUP1 02CF FD *REVERT // Stack delta = +0 // Outputs[1] { @02CF revert(memory[0x00:0x00]); } // Block terminates label_02D0: // Incoming call from 0x02CB, returns to 0x0117, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @02D2 stack[-2] // @02D2 msg.data[stack[-2]:stack[-2] + 0x20] // } 02D0 5B JUMPDEST 02D1 50 POP 02D2 35 CALLDATALOAD 02D3 60 PUSH1 0x01 02D5 60 PUSH1 0x01 02D7 60 PUSH1 0xa0 02D9 1B SHL 02DA 03 SUB 02DB 16 AND 02DC 61 PUSH2 0x0ca0 02DF 56 *JUMP // Stack delta = -1 // Outputs[1] { @02DB stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0ca0 label_02E0: // Incoming jump from 0x0061, if 0xfc0c546a == stack[-1] 02E0 5B JUMPDEST 02E1 61 PUSH2 0x0262 02E4 61 PUSH2 0x0d02 02E7 56 *JUMP // Stack delta = +1 // Outputs[1] { @02E1 stack[0] = 0x0262 } // Block ends with call to 0x0d02, returns to 0x0262 label_02E8: // Incoming jump from 0x0116 // Inputs[3] // { // @02E9 msg.sender // @02F7 memory[0x00:0x40] // @02F8 storage[keccak256(memory[0x00:0x40])] // } 02E8 5B JUMPDEST 02E9 33 CALLER 02EA 60 PUSH1 0x00 02EC 90 SWAP1 02ED 81 DUP2 02EE 52 MSTORE 02EF 60 PUSH1 0x03 02F1 60 PUSH1 0x20 02F3 52 MSTORE 02F4 60 PUSH1 0x40 02F6 90 SWAP1 02F7 20 SHA3 02F8 54 SLOAD 02F9 61 PUSH2 0x033e 02FC 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @02EE memory[0x00:0x20] = msg.sender // @02F3 memory[0x20:0x40] = 0x03 // } // Block ends with conditional jump to 0x033e, if storage[keccak256(memory[0x00:0x40])] label_02FD: // Incoming jump from 0x02FC, if not storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @0300 memory[0x40:0x60] // @0334 memory[0x40:0x60] // @033D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 02FD 60 PUSH1 0x40 02FF 80 DUP1 0300 51 MLOAD 0301 60 PUSH1 0x01 0303 60 PUSH1 0xe5 0305 1B SHL 0306 62 PUSH3 0x461bcd 030A 02 MUL 030B 81 DUP2 030C 52 MSTORE 030D 60 PUSH1 0x20 030F 60 PUSH1 0x04 0311 82 DUP3 0312 01 ADD 0313 52 MSTORE 0314 60 PUSH1 0x0c 0316 60 PUSH1 0x24 0318 82 DUP3 0319 01 ADD 031A 52 MSTORE 031B 60 PUSH1 0x01 031D 60 PUSH1 0xa0 031F 1B SHL 0320 6B PUSH12 0x766f7465725f616363657373 032D 02 MUL 032E 60 PUSH1 0x44 0330 82 DUP3 0331 01 ADD 0332 52 MSTORE 0333 90 SWAP1 0334 51 MLOAD 0335 90 SWAP1 0336 81 DUP2 0337 90 SWAP1 0338 03 SUB 0339 60 PUSH1 0x64 033B 01 ADD 033C 90 SWAP1 033D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @030C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0313 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @031A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0c // @0332 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x766f7465725f616363657373 * (0x01 << 0xa0) // @033D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_033E: // Incoming jump from 0x02FC, if storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @0341 stack[-1] // @034C memory[0x00:0x40] // @034D storage[keccak256(memory[0x00:0x40])] // } 033E 5B JUMPDEST 033F 60 PUSH1 0x00 0341 81 DUP2 0342 81 DUP2 0343 52 MSTORE 0344 60 PUSH1 0x05 0346 60 PUSH1 0x20 0348 52 MSTORE 0349 60 PUSH1 0x40 034B 90 SWAP1 034C 20 SHA3 034D 54 SLOAD 034E 81 DUP2 034F 90 SWAP1 0350 60 PUSH1 0xff 0352 16 AND 0353 15 ISZERO 0354 61 PUSH2 0x0399 0357 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0343 memory[0x00:0x20] = stack[-1] // @0348 memory[0x20:0x40] = 0x05 // @034F stack[0] = stack[-1] // } // Block ends with conditional jump to 0x0399, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_0358: // Incoming jump from 0x0357, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @035B memory[0x40:0x60] // @038F memory[0x40:0x60] // @0398 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0358 60 PUSH1 0x40 035A 80 DUP1 035B 51 MLOAD 035C 60 PUSH1 0x01 035E 60 PUSH1 0xe5 0360 1B SHL 0361 62 PUSH3 0x461bcd 0365 02 MUL 0366 81 DUP2 0367 52 MSTORE 0368 60 PUSH1 0x20 036A 60 PUSH1 0x04 036C 82 DUP3 036D 01 ADD 036E 52 MSTORE 036F 60 PUSH1 0x0c 0371 60 PUSH1 0x24 0373 82 DUP3 0374 01 ADD 0375 52 MSTORE 0376 60 PUSH1 0x01 0378 60 PUSH1 0xa0 037A 1B SHL 037B 6B PUSH12 0x636f6d706c657465645f6571 0388 02 MUL 0389 60 PUSH1 0x44 038B 82 DUP3 038C 01 ADD 038D 52 MSTORE 038E 90 SWAP1 038F 51 MLOAD 0390 90 SWAP1 0391 81 DUP2 0392 90 SWAP1 0393 03 SUB 0394 60 PUSH1 0x64 0396 01 ADD 0397 90 SWAP1 0398 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0367 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @036E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0375 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0c // @038D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x636f6d706c657465645f6571 * (0x01 << 0xa0) // @0398 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0399: // Incoming jump from 0x0357, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @039C stack[-1] } 0399 5B JUMPDEST 039A 60 PUSH1 0x00 039C 81 DUP2 039D 11 GT 039E 61 PUSH2 0x03dd 03A1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03dd, if stack[-1] > 0x00 label_03A2: // Incoming jump from 0x03A1, if not stack[-1] > 0x00 // Inputs[3] // { // @03A5 memory[0x40:0x60] // @03D3 memory[0x40:0x60] // @03DC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 03A2 60 PUSH1 0x40 03A4 80 DUP1 03A5 51 MLOAD 03A6 60 PUSH1 0x01 03A8 60 PUSH1 0xe5 03AA 1B SHL 03AB 62 PUSH3 0x461bcd 03AF 02 MUL 03B0 81 DUP2 03B1 52 MSTORE 03B2 60 PUSH1 0x20 03B4 60 PUSH1 0x04 03B6 80 DUP1 03B7 83 DUP4 03B8 01 ADD 03B9 91 SWAP2 03BA 90 SWAP1 03BB 91 SWAP2 03BC 52 MSTORE 03BD 60 PUSH1 0x24 03BF 82 DUP3 03C0 01 ADD 03C1 52 MSTORE 03C2 60 PUSH1 0x01 03C4 60 PUSH1 0xe2 03C6 1B SHL 03C7 63 PUSH4 0x1b97d9dd 03CC 02 MUL 03CD 60 PUSH1 0x44 03CF 82 DUP3 03D0 01 ADD 03D1 52 MSTORE 03D2 90 SWAP1 03D3 51 MLOAD 03D4 90 SWAP1 03D5 81 DUP2 03D6 90 SWAP1 03D7 03 SUB 03D8 60 PUSH1 0x64 03DA 01 ADD 03DB 90 SWAP1 03DC FD *REVERT // Stack delta = +0 // Outputs[5] // { // @03B1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @03BC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @03C1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @03D1 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1b97d9dd * (0x01 << 0xe2) // @03DC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_03DD: // Incoming jump from 0x03A1, if stack[-1] > 0x00 // Inputs[2] // { // @03E0 storage[0x02] // @03E1 stack[-1] // } 03DD 5B JUMPDEST 03DE 60 PUSH1 0x02 03E0 54 SLOAD 03E1 81 DUP2 03E2 11 GT 03E3 15 ISZERO 03E4 61 PUSH2 0x0422 03E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0422, if !(stack[-1] > storage[0x02]) label_03E8: // Incoming jump from 0x03E7, if not !(stack[-1] > storage[0x02]) // Inputs[3] // { // @03EB memory[0x40:0x60] // @0418 memory[0x40:0x60] // @0421 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 03E8 60 PUSH1 0x40 03EA 80 DUP1 03EB 51 MLOAD 03EC 60 PUSH1 0x01 03EE 60 PUSH1 0xe5 03F0 1B SHL 03F1 62 PUSH3 0x461bcd 03F5 02 MUL 03F6 81 DUP2 03F7 52 MSTORE 03F8 60 PUSH1 0x20 03FA 60 PUSH1 0x04 03FC 82 DUP3 03FD 01 ADD 03FE 52 MSTORE 03FF 60 PUSH1 0x05 0401 60 PUSH1 0x24 0403 82 DUP3 0404 01 ADD 0405 52 MSTORE 0406 60 PUSH1 0x01 0408 60 PUSH1 0xd8 040A 1B SHL 040B 64 PUSH5 0x6e5f6c7465 0411 02 MUL 0412 60 PUSH1 0x44 0414 82 DUP3 0415 01 ADD 0416 52 MSTORE 0417 90 SWAP1 0418 51 MLOAD 0419 90 SWAP1 041A 81 DUP2 041B 90 SWAP1 041C 03 SUB 041D 60 PUSH1 0x64 041F 01 ADD 0420 90 SWAP1 0421 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @03F7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @03FE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0405 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x05 // @0416 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x6e5f6c7465 * (0x01 << 0xd8) // @0421 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0422: // Incoming jump from 0x03E7, if !(stack[-1] > storage[0x02]) // Inputs[1] { @0426 stack[-1] } 0422 5B JUMPDEST 0423 61 PUSH2 0x042b 0426 81 DUP2 0427 61 PUSH2 0x0d11 042A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0423 stack[0] = 0x042b // @0426 stack[1] = stack[-1] // } // Block ends with call to 0x0d11, returns to 0x042B label_042B: // Incoming return from call to 0x0D11 at 0x042A // Inputs[1] { @042F stack[-1] } 042B 5B JUMPDEST 042C 61 PUSH2 0x046e 042F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x046e, if stack[-1] label_0430: // Incoming jump from 0x042F, if not stack[-1] // Inputs[3] // { // @0433 memory[0x40:0x60] // @0464 memory[0x40:0x60] // @046D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0430 60 PUSH1 0x40 0432 80 DUP1 0433 51 MLOAD 0434 60 PUSH1 0x01 0436 60 PUSH1 0xe5 0438 1B SHL 0439 62 PUSH3 0x461bcd 043D 02 MUL 043E 81 DUP2 043F 52 MSTORE 0440 60 PUSH1 0x20 0442 60 PUSH1 0x04 0444 82 DUP3 0445 01 ADD 0446 52 MSTORE 0447 60 PUSH1 0x09 0449 60 PUSH1 0x24 044B 82 DUP3 044C 01 ADD 044D 52 MSTORE 044E 60 PUSH1 0x01 0450 60 PUSH1 0xb8 0452 1B SHL 0453 68 PUSH9 0x6973566f7461626c65 045D 02 MUL 045E 60 PUSH1 0x44 0460 82 DUP3 0461 01 ADD 0462 52 MSTORE 0463 90 SWAP1 0464 51 MLOAD 0465 90 SWAP1 0466 81 DUP2 0467 90 SWAP1 0468 03 SUB 0469 60 PUSH1 0x64 046B 01 ADD 046C 90 SWAP1 046D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @043F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0446 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @044D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x09 // @0462 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x6973566f7461626c65 * (0x01 << 0xb8) // @046D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_046E: // Incoming jump from 0x042F, if stack[-1] // Inputs[6] // { // @0472 storage[0x00] // @0479 stack[-2] // @0487 memory[0x00:0x40] // @0488 msg.sender // @0490 memory[0x00:0x40] // @0491 storage[keccak256(memory[0x00:0x40])] // } 046E 5B JUMPDEST 046F 60 PUSH1 0x00 0471 80 DUP1 0472 54 SLOAD 0473 60 PUSH1 0x01 0475 01 ADD 0476 80 DUP1 0477 82 DUP3 0478 55 SSTORE 0479 83 DUP4 047A 82 DUP3 047B 52 MSTORE 047C 60 PUSH1 0x06 047E 60 PUSH1 0x20 0480 90 SWAP1 0481 81 DUP2 0482 52 MSTORE 0483 60 PUSH1 0x40 0485 80 DUP1 0486 84 DUP5 0487 20 SHA3 0488 33 CALLER 0489 85 DUP6 048A 52 MSTORE 048B 90 SWAP1 048C 91 SWAP2 048D 52 MSTORE 048E 90 SWAP1 048F 91 SWAP2 0490 20 SHA3 0491 54 SLOAD 0492 15 ISZERO 0493 61 PUSH2 0x04e6 0496 57 *JUMPI // Stack delta = +1 // Outputs[6] // { // @0478 storage[0x00] = 0x01 + storage[0x00] // @047B memory[0x00:0x20] = stack[-2] // @0482 memory[0x20:0x40] = 0x06 // @048A memory[0x00:0x20] = msg.sender // @048D memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @048F stack[0] = 0x01 + storage[0x00] // } // Block ends with conditional jump to 0x04e6, if !storage[keccak256(memory[0x00:0x40])] label_0497: // Incoming jump from 0x0496, if not !storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @049A memory[0x40:0x60] // @04DC memory[0x40:0x60] // @04E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0497 60 PUSH1 0x40 0499 80 DUP1 049A 51 MLOAD 049B 60 PUSH1 0x01 049D 60 PUSH1 0xe5 049F 1B SHL 04A0 62 PUSH3 0x461bcd 04A4 02 MUL 04A5 81 DUP2 04A6 52 MSTORE 04A7 60 PUSH1 0x20 04A9 60 PUSH1 0x04 04AB 82 DUP3 04AC 01 ADD 04AD 52 MSTORE 04AE 60 PUSH1 0x0d 04B0 60 PUSH1 0x24 04B2 82 DUP3 04B3 01 ADD 04B4 52 MSTORE 04B5 7F PUSH32 0x676976656e566f7465735f657100000000000000000000000000000000000000 04D6 60 PUSH1 0x44 04D8 82 DUP3 04D9 01 ADD 04DA 52 MSTORE 04DB 90 SWAP1 04DC 51 MLOAD 04DD 90 SWAP1 04DE 81 DUP2 04DF 90 SWAP1 04E0 03 SUB 04E1 60 PUSH1 0x64 04E3 01 ADD 04E4 90 SWAP1 04E5 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @04A6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @04AD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @04B4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0d // @04DA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x676976656e566f7465735f657100000000000000000000000000000000000000 // @04E5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_04E6: // Incoming jump from 0x0496, if !storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @04E9 stack[-3] // @04F4 memory[0x00:0x40] // @04F5 storage[keccak256(memory[0x00:0x40])] // } 04E6 5B JUMPDEST 04E7 60 PUSH1 0x00 04E9 83 DUP4 04EA 81 DUP2 04EB 52 MSTORE 04EC 60 PUSH1 0x05 04EE 60 PUSH1 0x20 04F0 52 MSTORE 04F1 60 PUSH1 0x40 04F3 90 SWAP1 04F4 20 SHA3 04F5 54 SLOAD 04F6 60 PUSH1 0xff 04F8 16 AND 04F9 15 ISZERO 04FA 61 PUSH2 0x0502 04FD 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @04EB memory[0x00:0x20] = stack[-3] // @04F0 memory[0x20:0x40] = 0x05 // } // Block ends with conditional jump to 0x0502, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_04FE: // Incoming jump from 0x04FD, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @0501 memory[0x00:0x00] } 04FE 60 PUSH1 0x00 0500 80 DUP1 0501 FD *REVERT // Stack delta = +0 // Outputs[1] { @0501 revert(memory[0x00:0x00]); } // Block terminates label_0502: // Incoming jump from 0x04FD, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @0506 stack[-3] } 0502 5B JUMPDEST 0503 61 PUSH2 0x050b 0506 83 DUP4 0507 61 PUSH2 0x0d17 050A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0503 stack[0] = 0x050b // @0506 stack[1] = stack[-3] // } // Block ends with call to 0x0d17, returns to 0x050B label_050B: // Incoming return from call to 0x0D17 at 0x050A // Inputs[2] // { // @050E storage[0x00] // @050F stack[-1] // } 050B 5B JUMPDEST 050C 60 PUSH1 0x00 050E 54 SLOAD 050F 81 DUP2 0510 14 EQ 0511 61 PUSH2 0x0519 0514 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0519, if stack[-1] == storage[0x00] label_0515: // Incoming jump from 0x0514, if not stack[-1] == storage[0x00] // Inputs[1] { @0518 memory[0x00:0x00] } 0515 60 PUSH1 0x00 0517 80 DUP1 0518 FD *REVERT // Stack delta = +0 // Outputs[1] { @0518 revert(memory[0x00:0x00]); } // Block terminates label_0519: // Incoming jump from 0x0514, if stack[-1] == storage[0x00] // Inputs[1] { @051D stack[-4] } 0519 5B JUMPDEST 051A 50 POP 051B 50 POP 051C 50 POP 051D 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_051E: // Incoming jump from 0x0144 // Inputs[3] // { // @051F msg.sender // @052D memory[0x00:0x40] // @052E storage[keccak256(memory[0x00:0x40])] // } 051E 5B JUMPDEST 051F 33 CALLER 0520 60 PUSH1 0x00 0522 90 SWAP1 0523 81 DUP2 0524 52 MSTORE 0525 60 PUSH1 0x03 0527 60 PUSH1 0x20 0529 52 MSTORE 052A 60 PUSH1 0x40 052C 81 DUP2 052D 20 SHA3 052E 54 SLOAD 052F 61 PUSH2 0x0574 0532 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0522 stack[0] = 0x00 // @0524 memory[0x00:0x20] = msg.sender // @0529 memory[0x20:0x40] = 0x03 // } // Block ends with conditional jump to 0x0574, if storage[keccak256(memory[0x00:0x40])] label_0533: // Incoming jump from 0x0532, if not storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @0536 memory[0x40:0x60] // @056A memory[0x40:0x60] // @0573 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0533 60 PUSH1 0x40 0535 80 DUP1 0536 51 MLOAD 0537 60 PUSH1 0x01 0539 60 PUSH1 0xe5 053B 1B SHL 053C 62 PUSH3 0x461bcd 0540 02 MUL 0541 81 DUP2 0542 52 MSTORE 0543 60 PUSH1 0x20 0545 60 PUSH1 0x04 0547 82 DUP3 0548 01 ADD 0549 52 MSTORE 054A 60 PUSH1 0x0c 054C 60 PUSH1 0x24 054E 82 DUP3 054F 01 ADD 0550 52 MSTORE 0551 60 PUSH1 0x01 0553 60 PUSH1 0xa0 0555 1B SHL 0556 6B PUSH12 0x766f7465725f616363657373 0563 02 MUL 0564 60 PUSH1 0x44 0566 82 DUP3 0567 01 ADD 0568 52 MSTORE 0569 90 SWAP1 056A 51 MLOAD 056B 90 SWAP1 056C 81 DUP2 056D 90 SWAP1 056E 03 SUB 056F 60 PUSH1 0x64 0571 01 ADD 0572 90 SWAP1 0573 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0542 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0549 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0550 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0c // @0568 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x766f7465725f616363657373 * (0x01 << 0xa0) // @0573 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0574: // Incoming jump from 0x0532, if storage[keccak256(memory[0x00:0x40])] // Inputs[9] // { // @0578 storage[0x00] // @0584 memory[0x40:0x60] // @0593 stack[-3] // @059C stack[-2] // @05A2 storage[0x09] // @05AD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @05D8 storage[storage[0x09] * 0x02 + 0x6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7af] // @05EA memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @0614 storage[0x09] // } 0574 5B JUMPDEST 0575 60 PUSH1 0x00 0577 80 DUP1 0578 54 SLOAD 0579 60 PUSH1 0x01 057B 90 SWAP1 057C 81 DUP2 057D 01 ADD 057E 80 DUP1 057F 83 DUP4 0580 55 SSTORE 0581 60 PUSH1 0x40 0583 80 DUP1 0584 51 MLOAD 0585 80 DUP1 0586 82 DUP3 0587 01 ADD 0588 90 SWAP1 0589 91 SWAP2 058A 52 MSTORE 058B 60 PUSH1 0x01 058D 60 PUSH1 0x01 058F 60 PUSH1 0xa0 0591 1B SHL 0592 03 SUB 0593 87 DUP8 0594 81 DUP2 0595 16 AND 0596 82 DUP3 0597 52 MSTORE 0598 60 PUSH1 0x20 059A 82 DUP3 059B 01 ADD 059C 87 DUP8 059D 81 DUP2 059E 52 MSTORE 059F 60 PUSH1 0x09 05A1 80 DUP1 05A2 54 SLOAD 05A3 95 SWAP6 05A4 86 DUP7 05A5 01 ADD 05A6 81 DUP2 05A7 55 SSTORE 05A8 95 SWAP6 05A9 86 DUP7 05AA 90 SWAP1 05AB 52 MSTORE 05AC 91 SWAP2 05AD 51 MLOAD 05AE 7F PUSH32 0x6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7af 05CF 60 PUSH1 0x02 05D1 90 SWAP1 05D2 95 SWAP6 05D3 02 MUL 05D4 94 SWAP5 05D5 85 DUP6 05D6 01 ADD 05D7 80 DUP1 05D8 54 SLOAD 05D9 60 PUSH1 0x01 05DB 60 PUSH1 0x01 05DD 60 PUSH1 0xa0 05DF 1B SHL 05E0 03 SUB 05E1 19 NOT 05E2 16 AND 05E3 91 SWAP2 05E4 90 SWAP1 05E5 92 SWAP3 05E6 16 AND 05E7 17 OR 05E8 90 SWAP1 05E9 55 SSTORE 05EA 51 MLOAD 05EB 7F PUSH32 0x6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7b0 060C 90 SWAP1 060D 92 SWAP3 060E 01 ADD 060F 91 SWAP2 0610 90 SWAP1 0611 91 SWAP2 0612 55 SSTORE 0613 90 SWAP1 0614 54 SLOAD 0615 61 PUSH2 0x061d 0618 81 DUP2 0619 61 PUSH2 0x0df8 061C 56 *JUMP // Stack delta = +4 // Outputs[12] // { // @0580 storage[0x00] = 0x01 + storage[0x00] // @058A memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0597 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @059E memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-2] // @05A7 storage[0x09] = storage[0x09] + 0x01 // @05AB memory[0x00:0x20] = 0x09 // @05E9 storage[storage[0x09] * 0x02 + 0x6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7af] = ((0x01 << 0xa0) - 0x01 & memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) | (~((0x01 << 0xa0) - 0x01) & storage[storage[0x09] * 0x02 + 0x6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7af]) // @0612 storage[storage[0x09] * 0x02 + 0x6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7b0] = memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @0613 stack[0] = 0x01 + storage[0x00] // @0614 stack[1] = storage[0x09] // @0615 stack[2] = 0x061d // @0618 stack[3] = storage[0x09] // } // Block ends with unconditional jump to 0x0df8 061D 5B JUMPDEST 061E 91 SWAP2 061F 50 POP 0620 60 PUSH1 0x00 0622 54 SLOAD 0623 81 DUP2 0624 14 EQ 0625 61 PUSH2 0x062d 0628 57 *JUMPI 0629 60 PUSH1 0x00 062B 80 DUP1 062C FD *REVERT 062D 5B JUMPDEST 062E 50 POP 062F 92 SWAP3 0630 91 SWAP2 0631 50 POP 0632 50 POP 0633 56 *JUMP label_0634: // Incoming jump from 0x017C // Inputs[2] // { // @0637 storage[0x07] // @0641 msg.sender // } 0634 5B JUMPDEST 0635 60 PUSH1 0x07 0637 54 SLOAD 0638 60 PUSH1 0x01 063A 60 PUSH1 0x01 063C 60 PUSH1 0xa0 063E 1B SHL 063F 03 SUB 0640 16 AND 0641 33 CALLER 0642 14 EQ 0643 61 PUSH2 0x0688 0646 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0688, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_0647: // Incoming jump from 0x0646, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[3] // { // @064A memory[0x40:0x60] // @067E memory[0x40:0x60] // @0687 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0647 60 PUSH1 0x40 0649 80 DUP1 064A 51 MLOAD 064B 60 PUSH1 0x01 064D 60 PUSH1 0xe5 064F 1B SHL 0650 62 PUSH3 0x461bcd 0654 02 MUL 0655 81 DUP2 0656 52 MSTORE 0657 60 PUSH1 0x20 0659 60 PUSH1 0x04 065B 82 DUP3 065C 01 ADD 065D 52 MSTORE 065E 60 PUSH1 0x0c 0660 60 PUSH1 0x24 0662 82 DUP3 0663 01 ADD 0664 52 MSTORE 0665 60 PUSH1 0x01 0667 60 PUSH1 0xa0 0669 1B SHL 066A 6B PUSH12 0x6f776e65725f616363657373 0677 02 MUL 0678 60 PUSH1 0x44 067A 82 DUP3 067B 01 ADD 067C 52 MSTORE 067D 90 SWAP1 067E 51 MLOAD 067F 90 SWAP1 0680 81 DUP2 0681 90 SWAP1 0682 03 SUB 0683 60 PUSH1 0x64 0685 01 ADD 0686 90 SWAP1 0687 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0656 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @065D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0664 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0c // @067C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x6f776e65725f616363657373 * (0x01 << 0xa0) // @0687 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0688: // Incoming jump from 0x0646, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[5] // { // @068C storage[0x07] // @0695 stack[-1] // @06AA memory[0x40:0x60] // @06D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @06DC stack[-2] // } 0688 5B JUMPDEST 0689 60 PUSH1 0x07 068B 80 DUP1 068C 54 SLOAD 068D 60 PUSH1 0x01 068F 60 PUSH1 0x01 0691 60 PUSH1 0xa0 0693 1B SHL 0694 03 SUB 0695 83 DUP4 0696 81 DUP2 0697 16 AND 0698 60 PUSH1 0x01 069A 60 PUSH1 0x01 069C 60 PUSH1 0xa0 069E 1B SHL 069F 03 SUB 06A0 19 NOT 06A1 83 DUP4 06A2 16 AND 06A3 17 OR 06A4 92 SWAP3 06A5 83 DUP4 06A6 90 SWAP1 06A7 55 SSTORE 06A8 60 PUSH1 0x40 06AA 51 MLOAD 06AB 91 SWAP2 06AC 81 DUP2 06AD 16 AND 06AE 92 SWAP3 06AF 83 DUP4 06B0 92 SWAP3 06B1 91 SWAP2 06B2 16 AND 06B3 90 SWAP1 06B4 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 06D5 90 SWAP1 06D6 60 PUSH1 0x00 06D8 90 SWAP1 06D9 A3 LOG3 06DA 50 POP 06DB 50 POP 06DC 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @06A7 storage[0x07] = (storage[0x07] & ~((0x01 << 0xa0) - 0x01)) | (stack[-1] & (0x01 << 0xa0) - 0x01) // @06D9 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, ((storage[0x07] & ~((0x01 << 0xa0) - 0x01)) | (stack[-1] & (0x01 << 0xa0) - 0x01)) & (0x01 << 0xa0) - 0x01, storage[0x07] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_06DD: // Incoming jump from 0x01A2 // Inputs[4] // { // @06E6 stack[-1] // @06F4 memory[0x00:0x40] // @06F5 storage[keccak256(memory[0x00:0x40])] // @06F6 stack[-2] // } 06DD 5B JUMPDEST 06DE 60 PUSH1 0x01 06E0 60 PUSH1 0x01 06E2 60 PUSH1 0xa0 06E4 1B SHL 06E5 03 SUB 06E6 16 AND 06E7 60 PUSH1 0x00 06E9 90 SWAP1 06EA 81 DUP2 06EB 52 MSTORE 06EC 60 PUSH1 0x03 06EE 60 PUSH1 0x20 06F0 52 MSTORE 06F1 60 PUSH1 0x40 06F3 90 SWAP1 06F4 20 SHA3 06F5 54 SLOAD 06F6 90 SWAP1 06F7 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @06EB memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @06F0 memory[0x20:0x40] = 0x03 // @06F6 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_06F8: // Incoming jump from 0x01BF // Inputs[3] // { // @06F9 msg.sender // @0707 memory[0x00:0x40] // @0708 storage[keccak256(memory[0x00:0x40])] // } 06F8 5B JUMPDEST 06F9 33 CALLER 06FA 60 PUSH1 0x00 06FC 90 SWAP1 06FD 81 DUP2 06FE 52 MSTORE 06FF 60 PUSH1 0x03 0701 60 PUSH1 0x20 0703 52 MSTORE 0704 60 PUSH1 0x40 0706 90 SWAP1 0707 20 SHA3 0708 54 SLOAD 0709 61 PUSH2 0x074e 070C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @06FE memory[0x00:0x20] = msg.sender // @0703 memory[0x20:0x40] = 0x03 // } // Block ends with conditional jump to 0x074e, if storage[keccak256(memory[0x00:0x40])] label_070D: // Incoming jump from 0x070C, if not storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @0710 memory[0x40:0x60] // @0744 memory[0x40:0x60] // @074D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 070D 60 PUSH1 0x40 070F 80 DUP1 0710 51 MLOAD 0711 60 PUSH1 0x01 0713 60 PUSH1 0xe5 0715 1B SHL 0716 62 PUSH3 0x461bcd 071A 02 MUL 071B 81 DUP2 071C 52 MSTORE 071D 60 PUSH1 0x20 071F 60 PUSH1 0x04 0721 82 DUP3 0722 01 ADD 0723 52 MSTORE 0724 60 PUSH1 0x0c 0726 60 PUSH1 0x24 0728 82 DUP3 0729 01 ADD 072A 52 MSTORE 072B 60 PUSH1 0x01 072D 60 PUSH1 0xa0 072F 1B SHL 0730 6B PUSH12 0x766f7465725f616363657373 073D 02 MUL 073E 60 PUSH1 0x44 0740 82 DUP3 0741 01 ADD 0742 52 MSTORE 0743 90 SWAP1 0744 51 MLOAD 0745 90 SWAP1 0746 81 DUP2 0747 90 SWAP1 0748 03 SUB 0749 60 PUSH1 0x64 074B 01 ADD 074C 90 SWAP1 074D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @071C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0723 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @072A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0c // @0742 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x766f7465725f616363657373 * (0x01 << 0xa0) // @074D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_074E: // Incoming jump from 0x070C, if storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @0751 stack[-1] // @075C memory[0x00:0x40] // @075D storage[keccak256(memory[0x00:0x40])] // } 074E 5B JUMPDEST 074F 60 PUSH1 0x00 0751 81 DUP2 0752 81 DUP2 0753 52 MSTORE 0754 60 PUSH1 0x05 0756 60 PUSH1 0x20 0758 52 MSTORE 0759 60 PUSH1 0x40 075B 90 SWAP1 075C 20 SHA3 075D 54 SLOAD 075E 81 DUP2 075F 90 SWAP1 0760 60 PUSH1 0xff 0762 16 AND 0763 15 ISZERO 0764 61 PUSH2 0x07a9 0767 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0753 memory[0x00:0x20] = stack[-1] // @0758 memory[0x20:0x40] = 0x05 // @075F stack[0] = stack[-1] // } // Block ends with conditional jump to 0x07a9, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_0768: // Incoming jump from 0x0767, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @076B memory[0x40:0x60] // @079F memory[0x40:0x60] // @07A8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0768 60 PUSH1 0x40 076A 80 DUP1 076B 51 MLOAD 076C 60 PUSH1 0x01 076E 60 PUSH1 0xe5 0770 1B SHL 0771 62 PUSH3 0x461bcd 0775 02 MUL 0776 81 DUP2 0777 52 MSTORE 0778 60 PUSH1 0x20 077A 60 PUSH1 0x04 077C 82 DUP3 077D 01 ADD 077E 52 MSTORE 077F 60 PUSH1 0x0c 0781 60 PUSH1 0x24 0783 82 DUP3 0784 01 ADD 0785 52 MSTORE 0786 60 PUSH1 0x01 0788 60 PUSH1 0xa0 078A 1B SHL 078B 6B PUSH12 0x636f6d706c657465645f6571 0798 02 MUL 0799 60 PUSH1 0x44 079B 82 DUP3 079C 01 ADD 079D 52 MSTORE 079E 90 SWAP1 079F 51 MLOAD 07A0 90 SWAP1 07A1 81 DUP2 07A2 90 SWAP1 07A3 03 SUB 07A4 60 PUSH1 0x64 07A6 01 ADD 07A7 90 SWAP1 07A8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0777 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @077E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0785 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0c // @079D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x636f6d706c657465645f6571 * (0x01 << 0xa0) // @07A8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_07A9: // Incoming jump from 0x0767, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @07AC stack[-1] } 07A9 5B JUMPDEST 07AA 60 PUSH1 0x00 07AC 81 DUP2 07AD 11 GT 07AE 61 PUSH2 0x07ed 07B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07ed, if stack[-1] > 0x00 label_07B2: // Incoming jump from 0x07B1, if not stack[-1] > 0x00 // Inputs[3] // { // @07B5 memory[0x40:0x60] // @07E3 memory[0x40:0x60] // @07EC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 07B2 60 PUSH1 0x40 07B4 80 DUP1 07B5 51 MLOAD 07B6 60 PUSH1 0x01 07B8 60 PUSH1 0xe5 07BA 1B SHL 07BB 62 PUSH3 0x461bcd 07BF 02 MUL 07C0 81 DUP2 07C1 52 MSTORE 07C2 60 PUSH1 0x20 07C4 60 PUSH1 0x04 07C6 80 DUP1 07C7 83 DUP4 07C8 01 ADD 07C9 91 SWAP2 07CA 90 SWAP1 07CB 91 SWAP2 07CC 52 MSTORE 07CD 60 PUSH1 0x24 07CF 82 DUP3 07D0 01 ADD 07D1 52 MSTORE 07D2 60 PUSH1 0x01 07D4 60 PUSH1 0xe2 07D6 1B SHL 07D7 63 PUSH4 0x1b97d9dd 07DC 02 MUL 07DD 60 PUSH1 0x44 07DF 82 DUP3 07E0 01 ADD 07E1 52 MSTORE 07E2 90 SWAP1 07E3 51 MLOAD 07E4 90 SWAP1 07E5 81 DUP2 07E6 90 SWAP1 07E7 03 SUB 07E8 60 PUSH1 0x64 07EA 01 ADD 07EB 90 SWAP1 07EC FD *REVERT // Stack delta = +0 // Outputs[5] // { // @07C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @07CC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @07D1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @07E1 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1b97d9dd * (0x01 << 0xe2) // @07EC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_07ED: // Incoming jump from 0x07B1, if stack[-1] > 0x00 // Inputs[2] // { // @07F0 storage[0x02] // @07F1 stack[-1] // } 07ED 5B JUMPDEST 07EE 60 PUSH1 0x02 07F0 54 SLOAD 07F1 81 DUP2 07F2 11 GT 07F3 15 ISZERO 07F4 61 PUSH2 0x0832 07F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0832, if !(stack[-1] > storage[0x02]) label_07F8: // Incoming jump from 0x07F7, if not !(stack[-1] > storage[0x02]) // Inputs[3] // { // @07FB memory[0x40:0x60] // @0828 memory[0x40:0x60] // @0831 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 07F8 60 PUSH1 0x40 07FA 80 DUP1 07FB 51 MLOAD 07FC 60 PUSH1 0x01 07FE 60 PUSH1 0xe5 0800 1B SHL 0801 62 PUSH3 0x461bcd 0805 02 MUL 0806 81 DUP2 0807 52 MSTORE 0808 60 PUSH1 0x20 080A 60 PUSH1 0x04 080C 82 DUP3 080D 01 ADD 080E 52 MSTORE 080F 60 PUSH1 0x05 0811 60 PUSH1 0x24 0813 82 DUP3 0814 01 ADD 0815 52 MSTORE 0816 60 PUSH1 0x01 0818 60 PUSH1 0xd8 081A 1B SHL 081B 64 PUSH5 0x6e5f6c7465 0821 02 MUL 0822 60 PUSH1 0x44 0824 82 DUP3 0825 01 ADD 0826 52 MSTORE 0827 90 SWAP1 0828 51 MLOAD 0829 90 SWAP1 082A 81 DUP2 082B 90 SWAP1 082C 03 SUB 082D 60 PUSH1 0x64 082F 01 ADD 0830 90 SWAP1 0831 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0807 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @080E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0815 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x05 // @0826 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x6e5f6c7465 * (0x01 << 0xd8) // @0831 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0832: // Incoming jump from 0x07F7, if !(stack[-1] > storage[0x02]) // Inputs[1] { @0836 stack[-1] } 0832 5B JUMPDEST 0833 61 PUSH2 0x083b 0836 81 DUP2 0837 61 PUSH2 0x0d11 083A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0833 stack[0] = 0x083b // @0836 stack[1] = stack[-1] // } // Block ends with call to 0x0d11, returns to 0x083B label_083B: // Incoming return from call to 0x0D11 at 0x083A // Inputs[1] { @083F stack[-1] } 083B 5B JUMPDEST 083C 61 PUSH2 0x087e 083F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x087e, if stack[-1] label_0840: // Incoming jump from 0x083F, if not stack[-1] // Inputs[3] // { // @0843 memory[0x40:0x60] // @0874 memory[0x40:0x60] // @087D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0840 60 PUSH1 0x40 0842 80 DUP1 0843 51 MLOAD 0844 60 PUSH1 0x01 0846 60 PUSH1 0xe5 0848 1B SHL 0849 62 PUSH3 0x461bcd 084D 02 MUL 084E 81 DUP2 084F 52 MSTORE 0850 60 PUSH1 0x20 0852 60 PUSH1 0x04 0854 82 DUP3 0855 01 ADD 0856 52 MSTORE 0857 60 PUSH1 0x09 0859 60 PUSH1 0x24 085B 82 DUP3 085C 01 ADD 085D 52 MSTORE 085E 60 PUSH1 0x01 0860 60 PUSH1 0xb8 0862 1B SHL 0863 68 PUSH9 0x6973566f7461626c65 086D 02 MUL 086E 60 PUSH1 0x44 0870 82 DUP3 0871 01 ADD 0872 52 MSTORE 0873 90 SWAP1 0874 51 MLOAD 0875 90 SWAP1 0876 81 DUP2 0877 90 SWAP1 0878 03 SUB 0879 60 PUSH1 0x64 087B 01 ADD 087C 90 SWAP1 087D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @084F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0856 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @085D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x09 // @0872 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x6973566f7461626c65 * (0x01 << 0xb8) // @087D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_087E: // Incoming jump from 0x083F, if stack[-1] // Inputs[5] // { // @0881 stack[-2] // @088F memory[0x00:0x40] // @0890 msg.sender // @0897 memory[0x00:0x40] // @0898 storage[keccak256(memory[0x00:0x40])] // } 087E 5B JUMPDEST 087F 60 PUSH1 0x00 0881 82 DUP3 0882 81 DUP2 0883 52 MSTORE 0884 60 PUSH1 0x06 0886 60 PUSH1 0x20 0888 90 SWAP1 0889 81 DUP2 088A 52 MSTORE 088B 60 PUSH1 0x40 088D 80 DUP1 088E 83 DUP4 088F 20 SHA3 0890 33 CALLER 0891 84 DUP5 0892 52 MSTORE 0893 90 SWAP1 0894 91 SWAP2 0895 52 MSTORE 0896 90 SWAP1 0897 20 SHA3 0898 54 SLOAD 0899 61 PUSH2 0x08ec 089C 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0883 memory[0x00:0x20] = stack[-2] // @088A memory[0x20:0x40] = 0x06 // @0892 memory[0x00:0x20] = msg.sender // @0895 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x08ec, if storage[keccak256(memory[0x00:0x40])] label_089D: // Incoming jump from 0x089C, if not storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @08A0 memory[0x40:0x60] // @08E2 memory[0x40:0x60] // @08EB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 089D 60 PUSH1 0x40 089F 80 DUP1 08A0 51 MLOAD 08A1 60 PUSH1 0x01 08A3 60 PUSH1 0xe5 08A5 1B SHL 08A6 62 PUSH3 0x461bcd 08AA 02 MUL 08AB 81 DUP2 08AC 52 MSTORE 08AD 60 PUSH1 0x20 08AF 60 PUSH1 0x04 08B1 82 DUP3 08B2 01 ADD 08B3 52 MSTORE 08B4 60 PUSH1 0x0d 08B6 60 PUSH1 0x24 08B8 82 DUP3 08B9 01 ADD 08BA 52 MSTORE 08BB 7F PUSH32 0x676976656e566f7465735f6f6b00000000000000000000000000000000000000 08DC 60 PUSH1 0x44 08DE 82 DUP3 08DF 01 ADD 08E0 52 MSTORE 08E1 90 SWAP1 08E2 51 MLOAD 08E3 90 SWAP1 08E4 81 DUP2 08E5 90 SWAP1 08E6 03 SUB 08E7 60 PUSH1 0x64 08E9 01 ADD 08EA 90 SWAP1 08EB FD *REVERT // Stack delta = +0 // Outputs[5] // { // @08AC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @08B3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @08BA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0d // @08E0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x676976656e566f7465735f6f6b00000000000000000000000000000000000000 // @08EB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_08EC: // Incoming jump from 0x089C, if storage[keccak256(memory[0x00:0x40])] // Inputs[7] // { // @08EF stack[-2] // @08FD memory[0x00:0x40] // @08FE msg.sender // @0905 memory[0x00:0x40] // @0906 storage[keccak256(memory[0x00:0x40])] // @0911 memory[0x00:0x40] // @0912 storage[keccak256(memory[0x00:0x40])] // } 08EC 5B JUMPDEST 08ED 60 PUSH1 0x00 08EF 82 DUP3 08F0 81 DUP2 08F1 52 MSTORE 08F2 60 PUSH1 0x06 08F4 60 PUSH1 0x20 08F6 90 SWAP1 08F7 81 DUP2 08F8 52 MSTORE 08F9 60 PUSH1 0x40 08FB 80 DUP1 08FC 83 DUP4 08FD 20 SHA3 08FE 33 CALLER 08FF 84 DUP5 0900 52 MSTORE 0901 82 DUP3 0902 52 MSTORE 0903 80 DUP1 0904 83 DUP4 0905 20 SHA3 0906 54 SLOAD 0907 85 DUP6 0908 84 DUP5 0909 52 MSTORE 090A 60 PUSH1 0x04 090C 90 SWAP1 090D 92 SWAP3 090E 52 MSTORE 090F 90 SWAP1 0910 91 SWAP2 0911 20 SHA3 0912 54 SLOAD 0913 61 PUSH2 0x0922 0916 90 SWAP1 0917 82 DUP3 0918 63 PUSH4 0xffffffff 091D 61 PUSH2 0x0ed8 0920 16 AND 0921 56 *JUMP // Stack delta = +4 // Outputs[10] // { // @08F1 memory[0x00:0x20] = stack[-2] // @08F8 memory[0x20:0x40] = 0x06 // @0900 memory[0x00:0x20] = msg.sender // @0902 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0909 memory[0x00:0x20] = stack[-2] // @090E memory[0x20:0x40] = 0x04 // @0910 stack[0] = storage[keccak256(memory[0x00:0x40])] // @0916 stack[1] = 0x0922 // @0916 stack[2] = storage[keccak256(memory[0x00:0x40])] // @0917 stack[3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x0ed8 & 0xffffffff, returns to 0x0922 label_0922: // Incoming return from call to 0x0ED8 at 0x0921 // Inputs[11] // { // @0925 stack[-4] // @0933 memory[0x00:0x40] // @0934 stack[-1] // @093E memory[0x00:0x40] // @093F msg.sender // @0948 memory[0x00:0x40] // @094E memory[0x40:0x60] // @095A stack[-2] // @095E memory[0x40:0x60] // @0988 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x60 + (memory[0x40:0x60] - memory[0x40:0x60])] // @098C stack[-5] // } 0922 5B JUMPDEST 0923 60 PUSH1 0x00 0925 84 DUP5 0926 81 DUP2 0927 52 MSTORE 0928 60 PUSH1 0x04 092A 60 PUSH1 0x20 092C 90 SWAP1 092D 81 DUP2 092E 52 MSTORE 092F 60 PUSH1 0x40 0931 80 DUP1 0932 83 DUP4 0933 20 SHA3 0934 93 SWAP4 0935 90 SWAP1 0936 93 SWAP4 0937 55 SSTORE 0938 60 PUSH1 0x06 093A 81 DUP2 093B 52 MSTORE 093C 82 DUP3 093D 82 DUP3 093E 20 SHA3 093F 33 CALLER 0940 80 DUP1 0941 84 DUP5 0942 52 MSTORE 0943 90 SWAP1 0944 82 DUP3 0945 52 MSTORE 0946 83 DUP4 0947 83 DUP4 0948 20 SHA3 0949 92 SWAP3 094A 90 SWAP1 094B 92 SWAP3 094C 55 SSTORE 094D 82 DUP3 094E 51 MLOAD 094F 91 SWAP2 0950 82 DUP3 0951 52 MSTORE 0952 81 DUP2 0953 01 ADD 0954 85 DUP6 0955 90 SWAP1 0956 52 MSTORE 0957 80 DUP1 0958 82 DUP3 0959 01 ADD 095A 83 DUP4 095B 90 SWAP1 095C 52 MSTORE 095D 90 SWAP1 095E 51 MLOAD 095F 7F PUSH32 0x64fe3672cff9c67b9d4f039224c41fb445c7c4bc4a6c92453598ec54b3edeaca 0980 91 SWAP2 0981 81 DUP2 0982 90 SWAP1 0983 03 SUB 0984 60 PUSH1 0x60 0986 01 ADD 0987 90 SWAP1 0988 A1 LOG1 0989 50 POP 098A 50 POP 098B 50 POP 098C 56 *JUMP // Stack delta = -5 // Outputs[11] // { // @0927 memory[0x00:0x20] = stack[-4] // @092E memory[0x20:0x40] = 0x04 // @0937 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @093B memory[0x20:0x40] = 0x06 // @0942 memory[0x00:0x20] = msg.sender // @0945 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @094C storage[keccak256(memory[0x00:0x40])] = 0x00 // @0951 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.sender // @0956 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-4] // @095C memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-2] // @0988 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x60 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x64fe3672cff9c67b9d4f039224c41fb445c7c4bc4a6c92453598ec54b3edeaca]); // } // Block ends with unconditional jump to stack[-5] label_098D: // Incoming jump from 0x01E5 // Inputs[1] { @0993 stack[-1] } 098D 5B JUMPDEST 098E 60 PUSH1 0x00 0990 61 PUSH2 0x0998 0993 82 DUP3 0994 61 PUSH2 0x0eed 0997 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @098E stack[0] = 0x00 // @0990 stack[1] = 0x0998 // @0993 stack[2] = stack[-1] // } // Block ends with call to 0x0eed, returns to 0x0998 label_0998: // Incoming return from call to 0x0EED at 0x0997 // Inputs[3] // { // @0999 stack[-4] // @0999 stack[-1] // @099A stack[-3] // } 0998 5B JUMPDEST 0999 92 SWAP3 099A 91 SWAP2 099B 50 POP 099C 50 POP 099D 56 *JUMP // Stack delta = -3 // Outputs[1] { @0999 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_099E: // Incoming jump from 0x0216 // Inputs[4] // { // @09A1 stack[-1] // @09AC memory[0x00:0x40] // @09AD storage[keccak256(memory[0x00:0x40])] // @09AE stack[-2] // } 099E 5B JUMPDEST 099F 60 PUSH1 0x00 09A1 90 SWAP1 09A2 81 DUP2 09A3 52 MSTORE 09A4 60 PUSH1 0x04 09A6 60 PUSH1 0x20 09A8 52 MSTORE 09A9 60 PUSH1 0x40 09AB 90 SWAP1 09AC 20 SHA3 09AD 54 SLOAD 09AE 90 SWAP1 09AF 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @09A3 memory[0x00:0x20] = stack[-1] // @09A8 memory[0x20:0x40] = 0x04 // @09AE stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_09B0: // Incoming jump from 0x0233 // Inputs[4] // { // @09B3 stack[-1] // @09BE memory[0x00:0x40] // @09BF storage[keccak256(memory[0x00:0x40])] // @09C3 stack[-2] // } 09B0 5B JUMPDEST 09B1 60 PUSH1 0x00 09B3 90 SWAP1 09B4 81 DUP2 09B5 52 MSTORE 09B6 60 PUSH1 0x05 09B8 60 PUSH1 0x20 09BA 52 MSTORE 09BB 60 PUSH1 0x40 09BD 90 SWAP1 09BE 20 SHA3 09BF 54 SLOAD 09C0 60 PUSH1 0xff 09C2 16 AND 09C3 90 SWAP1 09C4 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @09B5 memory[0x00:0x20] = stack[-1] // @09BA memory[0x20:0x40] = 0x05 // @09C3 stack[-2] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_09C5: // Incoming jump from 0x0259 // Inputs[2] // { // @09C8 storage[0x07] // @09D2 msg.sender // } 09C5 5B JUMPDEST 09C6 60 PUSH1 0x07 09C8 54 SLOAD 09C9 60 PUSH1 0x01 09CB 60 PUSH1 0x01 09CD 60 PUSH1 0xa0 09CF 1B SHL 09D0 03 SUB 09D1 16 AND 09D2 33 CALLER 09D3 14 EQ 09D4 61 PUSH2 0x0a19 09D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a19, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_09D8: // Incoming jump from 0x09D7, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[3] // { // @09DB memory[0x40:0x60] // @0A0F memory[0x40:0x60] // @0A18 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 09D8 60 PUSH1 0x40 09DA 80 DUP1 09DB 51 MLOAD 09DC 60 PUSH1 0x01 09DE 60 PUSH1 0xe5 09E0 1B SHL 09E1 62 PUSH3 0x461bcd 09E5 02 MUL 09E6 81 DUP2 09E7 52 MSTORE 09E8 60 PUSH1 0x20 09EA 60 PUSH1 0x04 09EC 82 DUP3 09ED 01 ADD 09EE 52 MSTORE 09EF 60 PUSH1 0x0c 09F1 60 PUSH1 0x24 09F3 82 DUP3 09F4 01 ADD 09F5 52 MSTORE 09F6 60 PUSH1 0x01 09F8 60 PUSH1 0xa0 09FA 1B SHL 09FB 6B PUSH12 0x6f776e65725f616363657373 0A08 02 MUL 0A09 60 PUSH1 0x44 0A0B 82 DUP3 0A0C 01 ADD 0A0D 52 MSTORE 0A0E 90 SWAP1 0A0F 51 MLOAD 0A10 90 SWAP1 0A11 81 DUP2 0A12 90 SWAP1 0A13 03 SUB 0A14 60 PUSH1 0x64 0A16 01 ADD 0A17 90 SWAP1 0A18 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @09E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @09EE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @09F5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0c // @0A0D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x6f776e65725f616363657373 * (0x01 << 0xa0) // @0A18 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0A19: // Incoming jump from 0x09D7, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[1] { @0A22 stack[-1] } 0A19 5B JUMPDEST 0A1A 60 PUSH1 0x01 0A1C 60 PUSH1 0x01 0A1E 60 PUSH1 0xa0 0A20 1B SHL 0A21 03 SUB 0A22 81 DUP2 0A23 16 AND 0A24 61 PUSH2 0x0a66 0A27 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a66, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0A28: // Incoming jump from 0x0A27, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0A2B memory[0x40:0x60] // @0A5C memory[0x40:0x60] // @0A65 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0A28 60 PUSH1 0x40 0A2A 80 DUP1 0A2B 51 MLOAD 0A2C 60 PUSH1 0x01 0A2E 60 PUSH1 0xe5 0A30 1B SHL 0A31 62 PUSH3 0x461bcd 0A35 02 MUL 0A36 81 DUP2 0A37 52 MSTORE 0A38 60 PUSH1 0x20 0A3A 60 PUSH1 0x04 0A3C 82 DUP3 0A3D 01 ADD 0A3E 52 MSTORE 0A3F 60 PUSH1 0x09 0A41 60 PUSH1 0x24 0A43 82 DUP3 0A44 01 ADD 0A45 52 MSTORE 0A46 60 PUSH1 0x01 0A48 60 PUSH1 0xb8 0A4A 1B SHL 0A4B 68 PUSH9 0x766f7465725f726571 0A55 02 MUL 0A56 60 PUSH1 0x44 0A58 82 DUP3 0A59 01 ADD 0A5A 52 MSTORE 0A5B 90 SWAP1 0A5C 51 MLOAD 0A5D 90 SWAP1 0A5E 81 DUP2 0A5F 90 SWAP1 0A60 03 SUB 0A61 60 PUSH1 0x64 0A63 01 ADD 0A64 90 SWAP1 0A65 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0A37 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0A3E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A45 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x09 // @0A5A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x766f7465725f726571 * (0x01 << 0xb8) // @0A65 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0A66: // Incoming jump from 0x0A27, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0A6F stack[-1] // @0A7E memory[0x00:0x40] // @0A7F storage[keccak256(memory[0x00:0x40])] // } 0A66 5B JUMPDEST 0A67 60 PUSH1 0x01 0A69 60 PUSH1 0x01 0A6B 60 PUSH1 0xa0 0A6D 1B SHL 0A6E 03 SUB 0A6F 81 DUP2 0A70 16 AND 0A71 60 PUSH1 0x00 0A73 90 SWAP1 0A74 81 DUP2 0A75 52 MSTORE 0A76 60 PUSH1 0x03 0A78 60 PUSH1 0x20 0A7A 52 MSTORE 0A7B 60 PUSH1 0x40 0A7D 90 SWAP1 0A7E 20 SHA3 0A7F 54 SLOAD 0A80 61 PUSH2 0x0ac3 0A83 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0A75 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0A7A memory[0x20:0x40] = 0x03 // } // Block ends with conditional jump to 0x0ac3, if storage[keccak256(memory[0x00:0x40])] label_0A84: // Incoming jump from 0x0A83, if not storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @0A87 memory[0x40:0x60] // @0AB9 memory[0x40:0x60] // @0AC2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0A84 60 PUSH1 0x40 0A86 80 DUP1 0A87 51 MLOAD 0A88 60 PUSH1 0x01 0A8A 60 PUSH1 0xe5 0A8C 1B SHL 0A8D 62 PUSH3 0x461bcd 0A91 02 MUL 0A92 81 DUP2 0A93 52 MSTORE 0A94 60 PUSH1 0x20 0A96 60 PUSH1 0x04 0A98 82 DUP3 0A99 01 ADD 0A9A 52 MSTORE 0A9B 60 PUSH1 0x0a 0A9D 60 PUSH1 0x24 0A9F 82 DUP3 0AA0 01 ADD 0AA1 52 MSTORE 0AA2 60 PUSH1 0x01 0AA4 60 PUSH1 0xb2 0AA6 1B SHL 0AA7 69 PUSH10 0x195e1a5cdd1cd7db9bdd 0AB2 02 MUL 0AB3 60 PUSH1 0x44 0AB5 82 DUP3 0AB6 01 ADD 0AB7 52 MSTORE 0AB8 90 SWAP1 0AB9 51 MLOAD 0ABA 90 SWAP1 0ABB 81 DUP2 0ABC 90 SWAP1 0ABD 03 SUB 0ABE 60 PUSH1 0x64 0AC0 01 ADD 0AC1 90 SWAP1 0AC2 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0A93 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0A9A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0AA1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0a // @0AB7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x195e1a5cdd1cd7db9bdd * (0x01 << 0xb2) // @0AC2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0AC3: // Incoming jump from 0x0A83, if storage[keccak256(memory[0x00:0x40])] // Inputs[4] // { // @0ACC stack[-1] // @0ADB memory[0x00:0x40] // @0ADC storage[keccak256(memory[0x00:0x40])] // @0ADF storage[0x01] // } 0AC3 5B JUMPDEST 0AC4 60 PUSH1 0x01 0AC6 60 PUSH1 0x01 0AC8 60 PUSH1 0xa0 0ACA 1B SHL 0ACB 03 SUB 0ACC 81 DUP2 0ACD 16 AND 0ACE 60 PUSH1 0x00 0AD0 90 SWAP1 0AD1 81 DUP2 0AD2 52 MSTORE 0AD3 60 PUSH1 0x03 0AD5 60 PUSH1 0x20 0AD7 52 MSTORE 0AD8 60 PUSH1 0x40 0ADA 90 SWAP1 0ADB 20 SHA3 0ADC 54 SLOAD 0ADD 60 PUSH1 0x01 0ADF 54 SLOAD 0AE0 61 PUSH2 0x0aee 0AE3 91 SWAP2 0AE4 63 PUSH4 0xffffffff 0AE9 61 PUSH2 0x0ed8 0AEC 16 AND 0AED 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0AD2 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0AD7 memory[0x20:0x40] = 0x03 // @0ADF stack[1] = storage[0x01] // @0AE3 stack[0] = 0x0aee // @0AE3 stack[2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x0ed8 & 0xffffffff, returns to 0x0AEE label_0AEE: // Incoming return from call to 0x0ED8 at 0x0AED // Inputs[4] // { // @0AF1 stack[-1] // @0AFA stack[-2] // @0B08 memory[0x00:0x40] // @0B0A stack[-3] // } 0AEE 5B JUMPDEST 0AEF 60 PUSH1 0x01 0AF1 55 SSTORE 0AF2 60 PUSH1 0x01 0AF4 60 PUSH1 0x01 0AF6 60 PUSH1 0xa0 0AF8 1B SHL 0AF9 03 SUB 0AFA 16 AND 0AFB 60 PUSH1 0x00 0AFD 90 SWAP1 0AFE 81 DUP2 0AFF 52 MSTORE 0B00 60 PUSH1 0x03 0B02 60 PUSH1 0x20 0B04 52 MSTORE 0B05 60 PUSH1 0x40 0B07 81 DUP2 0B08 20 SHA3 0B09 55 SSTORE 0B0A 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @0AF1 storage[0x01] = stack[-1] // @0AFF memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0B04 memory[0x20:0x40] = 0x03 // @0B09 storage[keccak256(memory[0x00:0x40])] = 0x00 // } // Block ends with unconditional jump to stack[-3] label_0B0B: // Incoming call from 0x0261, returns to 0x0262 // Inputs[2] // { // @0B0E storage[0x07] // @0B18 stack[-1] // } 0B0B 5B JUMPDEST 0B0C 60 PUSH1 0x07 0B0E 54 SLOAD 0B0F 60 PUSH1 0x01 0B11 60 PUSH1 0x01 0B13 60 PUSH1 0xa0 0B15 1B SHL 0B16 03 SUB 0B17 16 AND 0B18 81 DUP2 0B19 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B17 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x07] } // Block ends with unconditional jump to stack[-1] label_0B1A: // Incoming call from 0x0CFE, returns to 0x0CFF // Incoming jump from 0x02A9 // Inputs[2] // { // @0B1D storage[0x07] // @0B27 msg.sender // } 0B1A 5B JUMPDEST 0B1B 60 PUSH1 0x07 0B1D 54 SLOAD 0B1E 60 PUSH1 0x01 0B20 60 PUSH1 0x01 0B22 60 PUSH1 0xa0 0B24 1B SHL 0B25 03 SUB 0B26 16 AND 0B27 33 CALLER 0B28 14 EQ 0B29 61 PUSH2 0x0b6e 0B2C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b6e, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_0B2D: // Incoming jump from 0x0B2C, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[3] // { // @0B30 memory[0x40:0x60] // @0B64 memory[0x40:0x60] // @0B6D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0B2D 60 PUSH1 0x40 0B2F 80 DUP1 0B30 51 MLOAD 0B31 60 PUSH1 0x01 0B33 60 PUSH1 0xe5 0B35 1B SHL 0B36 62 PUSH3 0x461bcd 0B3A 02 MUL 0B3B 81 DUP2 0B3C 52 MSTORE 0B3D 60 PUSH1 0x20 0B3F 60 PUSH1 0x04 0B41 82 DUP3 0B42 01 ADD 0B43 52 MSTORE 0B44 60 PUSH1 0x0c 0B46 60 PUSH1 0x24 0B48 82 DUP3 0B49 01 ADD 0B4A 52 MSTORE 0B4B 60 PUSH1 0x01 0B4D 60 PUSH1 0xa0 0B4F 1B SHL 0B50 6B PUSH12 0x6f776e65725f616363657373 0B5D 02 MUL 0B5E 60 PUSH1 0x44 0B60 82 DUP3 0B61 01 ADD 0B62 52 MSTORE 0B63 90 SWAP1 0B64 51 MLOAD 0B65 90 SWAP1 0B66 81 DUP2 0B67 90 SWAP1 0B68 03 SUB 0B69 60 PUSH1 0x64 0B6B 01 ADD 0B6C 90 SWAP1 0B6D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0B3C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0B43 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B4A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0c // @0B62 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x6f776e65725f616363657373 * (0x01 << 0xa0) // @0B6D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0B6E: // Incoming jump from 0x0B2C, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[1] { @0B77 stack[-2] } 0B6E 5B JUMPDEST 0B6F 60 PUSH1 0x01 0B71 60 PUSH1 0x01 0B73 60 PUSH1 0xa0 0B75 1B SHL 0B76 03 SUB 0B77 82 DUP3 0B78 16 AND 0B79 61 PUSH2 0x0bbb 0B7C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bbb, if stack[-2] & (0x01 << 0xa0) - 0x01 label_0B7D: // Incoming jump from 0x0B7C, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0B80 memory[0x40:0x60] // @0BB1 memory[0x40:0x60] // @0BBA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0B7D 60 PUSH1 0x40 0B7F 80 DUP1 0B80 51 MLOAD 0B81 60 PUSH1 0x01 0B83 60 PUSH1 0xe5 0B85 1B SHL 0B86 62 PUSH3 0x461bcd 0B8A 02 MUL 0B8B 81 DUP2 0B8C 52 MSTORE 0B8D 60 PUSH1 0x20 0B8F 60 PUSH1 0x04 0B91 82 DUP3 0B92 01 ADD 0B93 52 MSTORE 0B94 60 PUSH1 0x09 0B96 60 PUSH1 0x24 0B98 82 DUP3 0B99 01 ADD 0B9A 52 MSTORE 0B9B 60 PUSH1 0x01 0B9D 60 PUSH1 0xb8 0B9F 1B SHL 0BA0 68 PUSH9 0x766f7465725f726571 0BAA 02 MUL 0BAB 60 PUSH1 0x44 0BAD 82 DUP3 0BAE 01 ADD 0BAF 52 MSTORE 0BB0 90 SWAP1 0BB1 51 MLOAD 0BB2 90 SWAP1 0BB3 81 DUP2 0BB4 90 SWAP1 0BB5 03 SUB 0BB6 60 PUSH1 0x64 0BB8 01 ADD 0BB9 90 SWAP1 0BBA FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0B8C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0B93 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B9A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x09 // @0BAF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x766f7465725f726571 * (0x01 << 0xb8) // @0BBA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0BBB: // Incoming jump from 0x0B7C, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0BC4 stack[-2] // @0BD3 memory[0x00:0x40] // @0BD4 storage[keccak256(memory[0x00:0x40])] // } 0BBB 5B JUMPDEST 0BBC 60 PUSH1 0x01 0BBE 60 PUSH1 0x01 0BC0 60 PUSH1 0xa0 0BC2 1B SHL 0BC3 03 SUB 0BC4 82 DUP3 0BC5 16 AND 0BC6 60 PUSH1 0x00 0BC8 90 SWAP1 0BC9 81 DUP2 0BCA 52 MSTORE 0BCB 60 PUSH1 0x03 0BCD 60 PUSH1 0x20 0BCF 52 MSTORE 0BD0 60 PUSH1 0x40 0BD2 90 SWAP1 0BD3 20 SHA3 0BD4 54 SLOAD 0BD5 15 ISZERO 0BD6 61 PUSH2 0x0c19 0BD9 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0BCA memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0BCF memory[0x20:0x40] = 0x03 // } // Block ends with conditional jump to 0x0c19, if !storage[keccak256(memory[0x00:0x40])] label_0BDA: // Incoming jump from 0x0BD9, if not !storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @0BDD memory[0x40:0x60] // @0C0F memory[0x40:0x60] // @0C18 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0BDA 60 PUSH1 0x40 0BDC 80 DUP1 0BDD 51 MLOAD 0BDE 60 PUSH1 0x01 0BE0 60 PUSH1 0xe5 0BE2 1B SHL 0BE3 62 PUSH3 0x461bcd 0BE7 02 MUL 0BE8 81 DUP2 0BE9 52 MSTORE 0BEA 60 PUSH1 0x20 0BEC 60 PUSH1 0x04 0BEE 82 DUP3 0BEF 01 ADD 0BF0 52 MSTORE 0BF1 60 PUSH1 0x0a 0BF3 60 PUSH1 0x24 0BF5 82 DUP3 0BF6 01 ADD 0BF7 52 MSTORE 0BF8 60 PUSH1 0x01 0BFA 60 PUSH1 0xb2 0BFC 1B SHL 0BFD 69 PUSH10 0x195e1a5cdd1cd7db9bdd 0C08 02 MUL 0C09 60 PUSH1 0x44 0C0B 82 DUP3 0C0C 01 ADD 0C0D 52 MSTORE 0C0E 90 SWAP1 0C0F 51 MLOAD 0C10 90 SWAP1 0C11 81 DUP2 0C12 90 SWAP1 0C13 03 SUB 0C14 60 PUSH1 0x64 0C16 01 ADD 0C17 90 SWAP1 0C18 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0BE9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0BF0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0BF7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0a // @0C0D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x195e1a5cdd1cd7db9bdd * (0x01 << 0xb2) // @0C18 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0C19: // Incoming jump from 0x0BD9, if !storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0C1C stack[-1] } 0C19 5B JUMPDEST 0C1A 60 PUSH1 0x00 0C1C 81 DUP2 0C1D 11 GT 0C1E 61 PUSH2 0x0c5f 0C21 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c5f, if stack[-1] > 0x00 label_0C22: // Incoming jump from 0x0C21, if not stack[-1] > 0x00 // Inputs[3] // { // @0C25 memory[0x40:0x60] // @0C55 memory[0x40:0x60] // @0C5E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0C22 60 PUSH1 0x40 0C24 80 DUP1 0C25 51 MLOAD 0C26 60 PUSH1 0x01 0C28 60 PUSH1 0xe5 0C2A 1B SHL 0C2B 62 PUSH3 0x461bcd 0C2F 02 MUL 0C30 81 DUP2 0C31 52 MSTORE 0C32 60 PUSH1 0x20 0C34 60 PUSH1 0x04 0C36 82 DUP3 0C37 01 ADD 0C38 52 MSTORE 0C39 60 PUSH1 0x08 0C3B 60 PUSH1 0x24 0C3D 82 DUP3 0C3E 01 ADD 0C3F 52 MSTORE 0C40 60 PUSH1 0x01 0C42 60 PUSH1 0xc2 0C44 1B SHL 0C45 67 PUSH8 0x1d9bdd195cd7d9dd 0C4E 02 MUL 0C4F 60 PUSH1 0x44 0C51 82 DUP3 0C52 01 ADD 0C53 52 MSTORE 0C54 90 SWAP1 0C55 51 MLOAD 0C56 90 SWAP1 0C57 81 DUP2 0C58 90 SWAP1 0C59 03 SUB 0C5A 60 PUSH1 0x64 0C5C 01 ADD 0C5D 90 SWAP1 0C5E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0C31 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0C38 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C3F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x08 // @0C53 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1d9bdd195cd7d9dd * (0x01 << 0xc2) // @0C5E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0C5F: // Incoming jump from 0x0C21, if stack[-1] > 0x00 // Inputs[4] // { // @0C68 stack[-2] // @0C77 memory[0x00:0x40] // @0C78 stack[-1] // @0C7D storage[0x01] // } 0C5F 5B JUMPDEST 0C60 60 PUSH1 0x01 0C62 60 PUSH1 0x01 0C64 60 PUSH1 0xa0 0C66 1B SHL 0C67 03 SUB 0C68 82 DUP3 0C69 16 AND 0C6A 60 PUSH1 0x00 0C6C 90 SWAP1 0C6D 81 DUP2 0C6E 52 MSTORE 0C6F 60 PUSH1 0x03 0C71 60 PUSH1 0x20 0C73 52 MSTORE 0C74 60 PUSH1 0x40 0C76 90 SWAP1 0C77 20 SHA3 0C78 81 DUP2 0C79 90 SWAP1 0C7A 55 SSTORE 0C7B 60 PUSH1 0x01 0C7D 54 SLOAD 0C7E 61 PUSH2 0x0c8d 0C81 90 SWAP1 0C82 82 DUP3 0C83 63 PUSH4 0xffffffff 0C88 61 PUSH2 0x0f01 0C8B 16 AND 0C8C 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @0C6E memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0C73 memory[0x20:0x40] = 0x03 // @0C7A storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0C81 stack[0] = 0x0c8d // @0C81 stack[1] = storage[0x01] // @0C82 stack[2] = stack[-1] // } // Block ends with call to 0x0f01 & 0xffffffff, returns to 0x0C8D label_0C8D: // Incoming return from call to 0x0F01 at 0x0C8C // Inputs[2] // { // @0C90 stack[-1] // @0C93 stack[-4] // } 0C8D 5B JUMPDEST 0C8E 60 PUSH1 0x01 0C90 55 SSTORE 0C91 50 POP 0C92 50 POP 0C93 56 *JUMP // Stack delta = -4 // Outputs[1] { @0C90 storage[0x01] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0C94: // Incoming call from 0x02B1, returns to 0x0145 // Inputs[2] // { // @0C97 storage[0x02] // @0C98 stack[-1] // } 0C94 5B JUMPDEST 0C95 60 PUSH1 0x02 0C97 54 SLOAD 0C98 81 DUP2 0C99 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C97 stack[0] = storage[0x02] } // Block ends with unconditional jump to stack[-1] label_0C9A: // Incoming call from 0x02B9, returns to 0x0145 // Inputs[2] // { // @0C9D storage[0x01] // @0C9E stack[-1] // } 0C9A 5B JUMPDEST 0C9B 60 PUSH1 0x01 0C9D 54 SLOAD 0C9E 81 DUP2 0C9F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C9D stack[0] = storage[0x01] } // Block ends with unconditional jump to stack[-1] label_0CA0: // Incoming jump from 0x02DF // Inputs[2] // { // @0CA3 storage[0x07] // @0CAD msg.sender // } 0CA0 5B JUMPDEST 0CA1 60 PUSH1 0x07 0CA3 54 SLOAD 0CA4 60 PUSH1 0x01 0CA6 60 PUSH1 0x01 0CA8 60 PUSH1 0xa0 0CAA 1B SHL 0CAB 03 SUB 0CAC 16 AND 0CAD 33 CALLER 0CAE 14 EQ 0CAF 61 PUSH2 0x0cf4 0CB2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cf4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_0CB3: // Incoming jump from 0x0CB2, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[3] // { // @0CB6 memory[0x40:0x60] // @0CEA memory[0x40:0x60] // @0CF3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0CB3 60 PUSH1 0x40 0CB5 80 DUP1 0CB6 51 MLOAD 0CB7 60 PUSH1 0x01 0CB9 60 PUSH1 0xe5 0CBB 1B SHL 0CBC 62 PUSH3 0x461bcd 0CC0 02 MUL 0CC1 81 DUP2 0CC2 52 MSTORE 0CC3 60 PUSH1 0x20 0CC5 60 PUSH1 0x04 0CC7 82 DUP3 0CC8 01 ADD 0CC9 52 MSTORE 0CCA 60 PUSH1 0x0c 0CCC 60 PUSH1 0x24 0CCE 82 DUP3 0CCF 01 ADD 0CD0 52 MSTORE 0CD1 60 PUSH1 0x01 0CD3 60 PUSH1 0xa0 0CD5 1B SHL 0CD6 6B PUSH12 0x6f776e65725f616363657373 0CE3 02 MUL 0CE4 60 PUSH1 0x44 0CE6 82 DUP3 0CE7 01 ADD 0CE8 52 MSTORE 0CE9 90 SWAP1 0CEA 51 MLOAD 0CEB 90 SWAP1 0CEC 81 DUP2 0CED 90 SWAP1 0CEE 03 SUB 0CEF 60 PUSH1 0x64 0CF1 01 ADD 0CF2 90 SWAP1 0CF3 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0CC2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0CC9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0CD0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0c // @0CE8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x6f776e65725f616363657373 * (0x01 << 0xa0) // @0CF3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0CF4: // Incoming jump from 0x0CB2, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[1] { @0CF8 stack[-1] } 0CF4 5B JUMPDEST 0CF5 61 PUSH2 0x0cff 0CF8 81 DUP2 0CF9 60 PUSH1 0x01 0CFB 61 PUSH2 0x0b1a 0CFE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CF5 stack[0] = 0x0cff // @0CF8 stack[1] = stack[-1] // @0CF9 stack[2] = 0x01 // } // Block ends with call to 0x0b1a, returns to 0x0CFF label_0CFF: // Incoming return from call to 0x0B1A at 0x0CFE // Incoming return from call to 0x0D17 at 0x0ED7 // Inputs[1] { @0D01 stack[-2] } 0CFF 5B JUMPDEST 0D00 50 POP 0D01 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0D02: // Incoming call from 0x02E7, returns to 0x0262 // Inputs[2] // { // @0D05 storage[0x08] // @0D0F stack[-1] // } 0D02 5B JUMPDEST 0D03 60 PUSH1 0x08 0D05 54 SLOAD 0D06 60 PUSH1 0x01 0D08 60 PUSH1 0x01 0D0A 60 PUSH1 0xa0 0D0C 1B SHL 0D0D 03 SUB 0D0E 16 AND 0D0F 81 DUP2 0D10 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D0E stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x08] } // Block ends with unconditional jump to stack[-1] label_0D11: // Incoming call from 0x083A, returns to 0x083B // Incoming call from 0x042A, returns to 0x042B // Inputs[1] { @0D15 stack[-2] } 0D11 5B JUMPDEST 0D12 50 POP 0D13 60 PUSH1 0x01 0D15 90 SWAP1 0D16 56 *JUMP // Stack delta = -1 // Outputs[1] { @0D15 stack[-2] = 0x01 } // Block ends with unconditional jump to stack[-2] label_0D17: // Incoming call from 0x050A, returns to 0x050B // Incoming call from 0x0ED7, returns to 0x0CFF // Inputs[6] // { // @0D18 msg.sender // @0D29 memory[0x00:0x40] // @0D2A storage[keccak256(memory[0x00:0x40])] // @0D2B stack[-1] // @0D35 memory[0x00:0x40] // @0D36 storage[keccak256(memory[0x00:0x40])] // } 0D17 5B JUMPDEST 0D18 33 CALLER 0D19 60 PUSH1 0x00 0D1B 90 SWAP1 0D1C 81 DUP2 0D1D 52 MSTORE 0D1E 60 PUSH1 0x03 0D20 60 PUSH1 0x20 0D22 90 SWAP1 0D23 81 DUP2 0D24 52 MSTORE 0D25 60 PUSH1 0x40 0D27 80 DUP1 0D28 83 DUP4 0D29 20 SHA3 0D2A 54 SLOAD 0D2B 84 DUP5 0D2C 84 DUP5 0D2D 52 MSTORE 0D2E 60 PUSH1 0x04 0D30 90 SWAP1 0D31 92 SWAP3 0D32 52 MSTORE 0D33 90 SWAP1 0D34 91 SWAP2 0D35 20 SHA3 0D36 54 SLOAD 0D37 61 PUSH2 0x0d46 0D3A 90 SWAP1 0D3B 82 DUP3 0D3C 63 PUSH4 0xffffffff 0D41 61 PUSH2 0x0f01 0D44 16 AND 0D45 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @0D1D memory[0x00:0x20] = msg.sender // @0D24 memory[0x20:0x40] = 0x03 // @0D2D memory[0x00:0x20] = stack[-1] // @0D32 memory[0x20:0x40] = 0x04 // @0D34 stack[0] = storage[keccak256(memory[0x00:0x40])] // @0D3A stack[1] = 0x0d46 // @0D3A stack[2] = storage[keccak256(memory[0x00:0x40])] // @0D3B stack[3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x0f01 & 0xffffffff, returns to 0x0D46 label_0D46: // Incoming return from call to 0x0F01 at 0x0D45 // Inputs[14] // { // @0D49 stack[-3] // @0D58 memory[0x00:0x40] // @0D59 stack[-1] // @0D5E memory[0x40:0x60] // @0D5F msg.sender // @0D6B stack[-2] // @0D6E memory[0x40:0x60] // @0D98 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x60 + (memory[0x40:0x60] - memory[0x40:0x60])] // @0DA9 memory[0x00:0x40] // @0DAA msg.sender // @0DB1 memory[0x00:0x40] // @0DBE memory[0x00:0x40] // @0DBF storage[keccak256(memory[0x00:0x40])] // @0DC2 storage[0x01] // } 0D46 5B JUMPDEST 0D47 60 PUSH1 0x00 0D49 83 DUP4 0D4A 81 DUP2 0D4B 52 MSTORE 0D4C 60 PUSH1 0x04 0D4E 60 PUSH1 0x20 0D50 90 SWAP1 0D51 81 DUP2 0D52 52 MSTORE 0D53 60 PUSH1 0x40 0D55 91 SWAP2 0D56 82 DUP3 0D57 90 SWAP1 0D58 20 SHA3 0D59 92 SWAP3 0D5A 90 SWAP1 0D5B 92 SWAP3 0D5C 55 SSTORE 0D5D 80 DUP1 0D5E 51 MLOAD 0D5F 33 CALLER 0D60 81 DUP2 0D61 52 MSTORE 0D62 91 SWAP2 0D63 82 DUP3 0D64 01 ADD 0D65 84 DUP5 0D66 90 SWAP1 0D67 52 MSTORE 0D68 81 DUP2 0D69 81 DUP2 0D6A 01 ADD 0D6B 83 DUP4 0D6C 90 SWAP1 0D6D 52 MSTORE 0D6E 51 MLOAD 0D6F 7F PUSH32 0x7fceb43eed04ef82929f3934ad976c493fa8028f5b17a07f0d41bfea4b2e83ed 0D90 91 SWAP2 0D91 81 DUP2 0D92 90 SWAP1 0D93 03 SUB 0D94 60 PUSH1 0x60 0D96 01 ADD 0D97 90 SWAP1 0D98 A1 LOG1 0D99 60 PUSH1 0x00 0D9B 82 DUP3 0D9C 81 DUP2 0D9D 52 MSTORE 0D9E 60 PUSH1 0x06 0DA0 60 PUSH1 0x20 0DA2 90 SWAP1 0DA3 81 DUP2 0DA4 52 MSTORE 0DA5 60 PUSH1 0x40 0DA7 80 DUP1 0DA8 83 DUP4 0DA9 20 SHA3 0DAA 33 CALLER 0DAB 84 DUP5 0DAC 52 MSTORE 0DAD 82 DUP3 0DAE 52 MSTORE 0DAF 80 DUP1 0DB0 83 DUP4 0DB1 20 SHA3 0DB2 84 DUP5 0DB3 90 SWAP1 0DB4 55 SSTORE 0DB5 84 DUP5 0DB6 83 DUP4 0DB7 52 MSTORE 0DB8 60 PUSH1 0x04 0DBA 90 SWAP1 0DBB 91 SWAP2 0DBC 52 MSTORE 0DBD 90 SWAP1 0DBE 20 SHA3 0DBF 54 SLOAD 0DC0 60 PUSH1 0x01 0DC2 54 SLOAD 0DC3 61 PUSH2 0x0dcd 0DC6 91 SWAP2 0DC7 84 DUP5 0DC8 91 SWAP2 0DC9 61 PUSH2 0x0f1a 0DCC 56 *JUMP // Stack delta = +3 // Outputs[18] // { // @0D4B memory[0x00:0x20] = stack[-3] // @0D52 memory[0x20:0x40] = 0x04 // @0D5C storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0D61 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.sender // @0D67 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-3] // @0D6D memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-2] // @0D98 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x60 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x7fceb43eed04ef82929f3934ad976c493fa8028f5b17a07f0d41bfea4b2e83ed]); // @0D9D memory[0x00:0x20] = stack[-3] // @0DA4 memory[0x20:0x40] = 0x06 // @0DAC memory[0x00:0x20] = msg.sender // @0DAE memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0DB4 storage[keccak256(memory[0x00:0x40])] = stack[-2] // @0DB7 memory[0x00:0x20] = stack[-3] // @0DBC memory[0x20:0x40] = 0x04 // @0DC6 stack[-1] = 0x0dcd // @0DC6 stack[1] = storage[keccak256(memory[0x00:0x40])] // @0DC8 stack[2] = storage[0x01] // @0DC8 stack[0] = stack[-3] // } // Block ends with call to 0x0f1a, returns to 0x0DCD label_0DCD: // Incoming return from call to 0x0F1A at 0x0DCC // Inputs[1] { @0DCE stack[-1] } 0DCD 5B JUMPDEST 0DCE 15 ISZERO 0DCF 61 PUSH2 0x0df4 0DD2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0df4, if !stack[-1] label_0DD3: // Incoming jump from 0x0DD2, if not !stack[-1] // Inputs[3] // { // @0DD5 stack[-2] // @0DE0 memory[0x00:0x40] // @0DE2 storage[keccak256(memory[0x00:0x40])] // } 0DD3 60 PUSH1 0x00 0DD5 82 DUP3 0DD6 81 DUP2 0DD7 52 MSTORE 0DD8 60 PUSH1 0x05 0DDA 60 PUSH1 0x20 0DDC 52 MSTORE 0DDD 60 PUSH1 0x40 0DDF 90 SWAP1 0DE0 20 SHA3 0DE1 80 DUP1 0DE2 54 SLOAD 0DE3 60 PUSH1 0xff 0DE5 19 NOT 0DE6 16 AND 0DE7 60 PUSH1 0x01 0DE9 17 OR 0DEA 90 SWAP1 0DEB 55 SSTORE 0DEC 61 PUSH2 0x0df4 0DEF 82 DUP3 0DF0 61 PUSH2 0x0f28 0DF3 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @0DD7 memory[0x00:0x20] = stack[-2] // @0DDC memory[0x20:0x40] = 0x05 // @0DEB storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0DEC stack[0] = 0x0df4 // @0DEF stack[1] = stack[-2] // } // Block ends with call to 0x0f28, returns to 0x0DF4 label_0DF4: // Incoming jump from 0x0DD2, if !stack[-1] // Incoming return from call to 0x0F28 at 0x0DF3 // Inputs[1] { @0DF7 stack[-3] } 0DF4 5B JUMPDEST 0DF5 50 POP 0DF6 50 POP 0DF7 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0DF8: // Incoming jump from 0x061C // Inputs[2] // { // @0DFB storage[0x02] // @0DFC stack[-1] // } 0DF8 5B JUMPDEST 0DF9 60 PUSH1 0x02 0DFB 54 SLOAD 0DFC 81 DUP2 0DFD 11 GT 0DFE 61 PUSH2 0x0e3d 0E01 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e3d, if stack[-1] > storage[0x02] label_0E02: // Incoming jump from 0x0E01, if not stack[-1] > storage[0x02] // Inputs[3] // { // @0E05 memory[0x40:0x60] // @0E33 memory[0x40:0x60] // @0E3C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0E02 60 PUSH1 0x40 0E04 80 DUP1 0E05 51 MLOAD 0E06 60 PUSH1 0x01 0E08 60 PUSH1 0xe5 0E0A 1B SHL 0E0B 62 PUSH3 0x461bcd 0E0F 02 MUL 0E10 81 DUP2 0E11 52 MSTORE 0E12 60 PUSH1 0x20 0E14 60 PUSH1 0x04 0E16 80 DUP1 0E17 83 DUP4 0E18 01 ADD 0E19 91 SWAP2 0E1A 90 SWAP1 0E1B 91 SWAP2 0E1C 52 MSTORE 0E1D 60 PUSH1 0x24 0E1F 82 DUP3 0E20 01 ADD 0E21 52 MSTORE 0E22 60 PUSH1 0x01 0E24 60 PUSH1 0xe2 0E26 1B SHL 0E27 63 PUSH4 0x1b97d9dd 0E2C 02 MUL 0E2D 60 PUSH1 0x44 0E2F 82 DUP3 0E30 01 ADD 0E31 52 MSTORE 0E32 90 SWAP1 0E33 51 MLOAD 0E34 90 SWAP1 0E35 81 DUP2 0E36 90 SWAP1 0E37 03 SUB 0E38 60 PUSH1 0x64 0E3A 01 ADD 0E3B 90 SWAP1 0E3C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0E11 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0E1C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E21 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x04 // @0E31 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1b97d9dd * (0x01 << 0xe2) // @0E3C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0E3D: // Incoming jump from 0x0E01, if stack[-1] > storage[0x02] // Inputs[3] // { // @0E40 stack[-1] // @0E4B memory[0x00:0x40] // @0E4C storage[keccak256(memory[0x00:0x40])] // } 0E3D 5B JUMPDEST 0E3E 60 PUSH1 0x00 0E40 81 DUP2 0E41 81 DUP2 0E42 52 MSTORE 0E43 60 PUSH1 0x04 0E45 60 PUSH1 0x20 0E47 52 MSTORE 0E48 60 PUSH1 0x40 0E4A 90 SWAP1 0E4B 20 SHA3 0E4C 54 SLOAD 0E4D 15 ISZERO 0E4E 61 PUSH2 0x0e8f 0E51 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0E42 memory[0x00:0x20] = stack[-1] // @0E47 memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x0e8f, if !storage[keccak256(memory[0x00:0x40])] label_0E52: // Incoming jump from 0x0E51, if not !storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @0E55 memory[0x40:0x60] // @0E85 memory[0x40:0x60] // @0E8E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0E52 60 PUSH1 0x40 0E54 80 DUP1 0E55 51 MLOAD 0E56 60 PUSH1 0x01 0E58 60 PUSH1 0xe5 0E5A 1B SHL 0E5B 62 PUSH3 0x461bcd 0E5F 02 MUL 0E60 81 DUP2 0E61 52 MSTORE 0E62 60 PUSH1 0x20 0E64 60 PUSH1 0x04 0E66 82 DUP3 0E67 01 ADD 0E68 52 MSTORE 0E69 60 PUSH1 0x08 0E6B 60 PUSH1 0x24 0E6D 82 DUP3 0E6E 01 ADD 0E6F 52 MSTORE 0E70 60 PUSH1 0x01 0E72 60 PUSH1 0xc0 0E74 1B SHL 0E75 67 PUSH8 0x766f7465735f6571 0E7E 02 MUL 0E7F 60 PUSH1 0x44 0E81 82 DUP3 0E82 01 ADD 0E83 52 MSTORE 0E84 90 SWAP1 0E85 51 MLOAD 0E86 90 SWAP1 0E87 81 DUP2 0E88 90 SWAP1 0E89 03 SUB 0E8A 60 PUSH1 0x64 0E8C 01 ADD 0E8D 90 SWAP1 0E8E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0E61 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0E68 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E6F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x08 // @0E83 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x766f7465735f6571 * (0x01 << 0xc0) // @0E8E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0E8F: // Incoming jump from 0x0E51, if !storage[keccak256(memory[0x00:0x40])] // Inputs[5] // { // @0E92 stack[-1] // @0E98 memory[0x40:0x60] // @0E99 msg.sender // @0EA4 memory[0x40:0x60] // @0ECF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x40 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0E8F 5B JUMPDEST 0E90 60 PUSH1 0x02 0E92 81 DUP2 0E93 90 SWAP1 0E94 55 SSTORE 0E95 60 PUSH1 0x40 0E97 80 DUP1 0E98 51 MLOAD 0E99 33 CALLER 0E9A 81 DUP2 0E9B 52 MSTORE 0E9C 60 PUSH1 0x20 0E9E 81 DUP2 0E9F 01 ADD 0EA0 83 DUP4 0EA1 90 SWAP1 0EA2 52 MSTORE 0EA3 81 DUP2 0EA4 51 MLOAD 0EA5 7F PUSH32 0x294a8b64183582a911805b3a31b11b3c4d20c7431578897c6abcc35aae886d5e 0EC6 92 SWAP3 0EC7 91 SWAP2 0EC8 81 DUP2 0EC9 90 SWAP1 0ECA 03 SUB 0ECB 90 SWAP1 0ECC 91 SWAP2 0ECD 01 ADD 0ECE 90 SWAP1 0ECF A1 LOG1 0ED0 61 PUSH2 0x0cff 0ED3 81 DUP2 0ED4 61 PUSH2 0x0d17 0ED7 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @0E94 storage[0x02] = stack[-1] // @0E9B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.sender // @0EA2 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @0ECF log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x40 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x294a8b64183582a911805b3a31b11b3c4d20c7431578897c6abcc35aae886d5e]); // @0ED0 stack[0] = 0x0cff // @0ED3 stack[1] = stack[-1] // } // Block ends with call to 0x0d17, returns to 0x0CFF label_0ED8: // Incoming call from 0x0AED, returns to 0x0AEE // Incoming call from 0x0921, returns to 0x0922 // Inputs[2] // { // @0EDB stack[-2] // @0EDC stack[-1] // } 0ED8 5B JUMPDEST 0ED9 60 PUSH1 0x00 0EDB 82 DUP3 0EDC 82 DUP3 0EDD 11 GT 0EDE 15 ISZERO 0EDF 61 PUSH2 0x0ee7 0EE2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0ED9 stack[0] = 0x00 } // Block ends with conditional jump to 0x0ee7, if !(stack[-1] > stack[-2]) label_0EE3: // Incoming jump from 0x0EE2, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0EE6 memory[0x00:0x00] } 0EE3 60 PUSH1 0x00 0EE5 80 DUP1 0EE6 FD *REVERT // Stack delta = +0 // Outputs[1] { @0EE6 revert(memory[0x00:0x00]); } // Block terminates label_0EE7: // Incoming jump from 0x0EE2, if !(stack[-1] > stack[-2]) // Inputs[3] // { // @0EE9 stack[-3] // @0EE9 stack[-2] // @0EEB stack[-4] // } 0EE7 5B JUMPDEST 0EE8 50 POP 0EE9 90 SWAP1 0EEA 03 SUB 0EEB 90 SWAP1 0EEC 56 *JUMP // Stack delta = -3 // Outputs[1] { @0EEB stack[-4] = stack[-3] - stack[-2] } // Block ends with unconditional jump to stack[-4] label_0EED: // Incoming call from 0x0997, returns to 0x0998 // Inputs[3] // { // @0EF0 storage[0x07] // @0EF9 stack[-1] // @0EFF stack[-2] // } 0EED 5B JUMPDEST 0EEE 60 PUSH1 0x07 0EF0 54 SLOAD 0EF1 60 PUSH1 0x01 0EF3 60 PUSH1 0x01 0EF5 60 PUSH1 0xa0 0EF7 1B SHL 0EF8 03 SUB 0EF9 91 SWAP2 0EFA 82 DUP3 0EFB 16 AND 0EFC 91 SWAP2 0EFD 16 AND 0EFE 14 EQ 0EFF 90 SWAP1 0F00 56 *JUMP // Stack delta = -1 // Outputs[1] { @0EFF stack[-2] = (0x01 << 0xa0) - 0x01 & storage[0x07] == (0x01 << 0xa0) - 0x01 & stack[-1] } // Block ends with unconditional jump to stack[-2] label_0F01: // Incoming call from 0x0D45, returns to 0x0D46 // Incoming call from 0x0C8C, returns to 0x0C8D // Inputs[2] // { // @0F04 stack[-2] // @0F05 stack[-1] // } 0F01 5B JUMPDEST 0F02 60 PUSH1 0x00 0F04 82 DUP3 0F05 82 DUP3 0F06 01 ADD 0F07 83 DUP4 0F08 81 DUP2 0F09 10 LT 0F0A 15 ISZERO 0F0B 61 PUSH2 0x0f13 0F0E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0F02 stack[0] = 0x00 // @0F06 stack[1] = stack[-1] + stack[-2] // } // Block ends with conditional jump to 0x0f13, if !(stack[-1] + stack[-2] < stack[-2]) label_0F0F: // Incoming jump from 0x0F0E, if not !(stack[-1] + stack[-2] < stack[-2]) // Inputs[1] { @0F12 memory[0x00:0x00] } 0F0F 60 PUSH1 0x00 0F11 80 DUP1 0F12 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F12 revert(memory[0x00:0x00]); } // Block terminates label_0F13: // Incoming jump from 0x0F0E, if !(stack[-1] + stack[-2] < stack[-2]) // Inputs[3] // { // @0F14 stack[-5] // @0F14 stack[-1] // @0F15 stack[-4] // } 0F13 5B JUMPDEST 0F14 93 SWAP4 0F15 92 SWAP3 0F16 50 POP 0F17 50 POP 0F18 50 POP 0F19 56 *JUMP // Stack delta = -4 // Outputs[1] { @0F14 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0F1A: // Incoming call from 0x0DCC, returns to 0x0DCD // Inputs[4] // { // @0F1D stack[-1] // @0F22 stack[-2] // @0F24 stack[-4] // @0F25 stack[-3] // } 0F1A 5B JUMPDEST 0F1B 60 PUSH1 0x02 0F1D 90 SWAP1 0F1E 04 DIV 0F1F 60 PUSH1 0x01 0F21 01 ADD 0F22 11 GT 0F23 15 ISZERO 0F24 91 SWAP2 0F25 90 SWAP1 0F26 50 POP 0F27 56 *JUMP // Stack delta = -3 // Outputs[1] { @0F24 stack[-4] = !(0x01 + stack[-1] / 0x02 > stack[-2]) } // Block ends with unconditional jump to stack[-4] label_0F28: // Incoming call from 0x0DF3, returns to 0x0DF4 // Inputs[2] // { // @0F2F stack[-1] // @0F32 storage[0x09] // } 0F28 5B JUMPDEST 0F29 60 PUSH1 0x00 0F2B 60 PUSH1 0x09 0F2D 60 PUSH1 0x01 0F2F 83 DUP4 0F30 03 SUB 0F31 81 DUP2 0F32 54 SLOAD 0F33 81 DUP2 0F34 10 LT 0F35 61 PUSH2 0x0f3a 0F38 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0F29 stack[0] = 0x00 // @0F2B stack[1] = 0x09 // @0F30 stack[2] = stack[-1] - 0x01 // } // Block ends with conditional jump to 0x0f3a, if stack[-1] - 0x01 < storage[0x09] label_0F39: // Incoming jump from 0x0F38, if not stack[-1] - 0x01 < storage[0x09] 0F39 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0F39 assert(); } // Block terminates label_0F3A: // Incoming jump from 0x0F38, if stack[-1] - 0x01 < storage[0x09] // Inputs[9] // { // @0F3D stack[-2] // @0F45 memory[0x00:0x20] // @0F48 storage[0x08] // @0F4C memory[0x40:0x60] // @0F5A address(this) // @0F61 memory[0x40:0x60] // @0F65 stack[-1] // @0F6A stack[-3] // @0F89 address((0x01 << 0xa0) - 0x01 & storage[0x08]).code.length // } 0F3A 5B JUMPDEST 0F3B 60 PUSH1 0x00 0F3D 91 SWAP2 0F3E 82 DUP3 0F3F 52 MSTORE 0F40 60 PUSH1 0x20 0F42 91 SWAP2 0F43 82 DUP3 0F44 90 SWAP1 0F45 20 SHA3 0F46 60 PUSH1 0x08 0F48 54 SLOAD 0F49 60 PUSH1 0x40 0F4B 80 DUP1 0F4C 51 MLOAD 0F4D 60 PUSH1 0x01 0F4F 60 PUSH1 0xe0 0F51 1B SHL 0F52 63 PUSH4 0x70a08231 0F57 02 MUL 0F58 81 DUP2 0F59 52 MSTORE 0F5A 30 ADDRESS 0F5B 60 PUSH1 0x04 0F5D 82 DUP3 0F5E 01 ADD 0F5F 52 MSTORE 0F60 90 SWAP1 0F61 51 MLOAD 0F62 60 PUSH1 0x02 0F64 90 SWAP1 0F65 94 SWAP5 0F66 02 MUL 0F67 90 SWAP1 0F68 92 SWAP3 0F69 01 ADD 0F6A 94 SWAP5 0F6B 50 POP 0F6C 60 PUSH1 0x01 0F6E 60 PUSH1 0x01 0F70 60 PUSH1 0xa0 0F72 1B SHL 0F73 03 SUB 0F74 16 AND 0F75 92 SWAP3 0F76 63 PUSH4 0x70a08231 0F7B 92 SWAP3 0F7C 60 PUSH1 0x24 0F7E 80 DUP1 0F7F 84 DUP5 0F80 01 ADD 0F81 93 SWAP4 0F82 82 DUP3 0F83 90 SWAP1 0F84 03 SUB 0F85 01 ADD 0F86 81 DUP2 0F87 86 DUP7 0F88 80 DUP1 0F89 3B EXTCODESIZE 0F8A 15 ISZERO 0F8B 80 DUP1 0F8C 15 ISZERO 0F8D 61 PUSH2 0x0f95 0F90 57 *JUMPI // Stack delta = +7 // Outputs[13] // { // @0F3F memory[0x00:0x20] = stack[-2] // @0F59 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 * (0x01 << 0xe0) // @0F5F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @0F6A stack[-3] = keccak256(memory[0x00:0x20]) + stack[-1] * 0x02 // @0F75 stack[1] = 0x20 // @0F75 stack[-2] = (0x01 << 0xa0) - 0x01 & storage[0x08] // @0F7B stack[-1] = 0x70a08231 // @0F7B stack[2] = memory[0x40:0x60] // @0F81 stack[0] = memory[0x40:0x60] + 0x24 // @0F85 stack[3] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @0F86 stack[4] = memory[0x40:0x60] // @0F87 stack[5] = (0x01 << 0xa0) - 0x01 & storage[0x08] // @0F8A stack[6] = !address((0x01 << 0xa0) - 0x01 & storage[0x08]).code.length // } // Block ends with conditional jump to 0x0f95, if !!address((0x01 << 0xa0) - 0x01 & storage[0x08]).code.length label_0F91: // Incoming jump from 0x0F90, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x08]).code.length // Inputs[1] { @0F94 memory[0x00:0x00] } 0F91 60 PUSH1 0x00 0F93 80 DUP1 0F94 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F94 revert(memory[0x00:0x00]); } // Block terminates label_0F95: // Incoming jump from 0x0F90, if !!address((0x01 << 0xa0) - 0x01 & storage[0x08]).code.length // Inputs[8] // { // @0F97 msg.gas // @0F98 stack[-4] // @0F98 stack[-2] // @0F98 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0F98 memory[stack[-3]:stack[-3] + stack[-4]] // @0F98 stack[-6] // @0F98 stack[-3] // @0F98 stack[-5] // } 0F95 5B JUMPDEST 0F96 50 POP 0F97 5A GAS 0F98 FA STATICCALL 0F99 15 ISZERO 0F9A 80 DUP1 0F9B 15 ISZERO 0F9C 61 PUSH2 0x0fa9 0F9F 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0F98 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0F99 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0fa9, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0FA0: // Incoming jump from 0x0F9F, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0FA0 returndata.length // @0FA4 returndata[0x00:0x00 + returndata.length] // @0FA5 returndata.length // @0FA8 memory[0x00:0x00 + returndata.length] // } 0FA0 3D RETURNDATASIZE 0FA1 60 PUSH1 0x00 0FA3 80 DUP1 0FA4 3E RETURNDATACOPY 0FA5 3D RETURNDATASIZE 0FA6 60 PUSH1 0x00 0FA8 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0FA4 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0FA8 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0FA9: // Incoming jump from 0x0F9F, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0FB0 memory[0x40:0x60] // @0FB1 returndata.length // } 0FA9 5B JUMPDEST 0FAA 50 POP 0FAB 50 POP 0FAC 50 POP 0FAD 50 POP 0FAE 60 PUSH1 0x40 0FB0 51 MLOAD 0FB1 3D RETURNDATASIZE 0FB2 60 PUSH1 0x20 0FB4 81 DUP2 0FB5 10 LT 0FB6 15 ISZERO 0FB7 61 PUSH2 0x0fbf 0FBA 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0FB0 stack[-4] = memory[0x40:0x60] // @0FB1 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0fbf, if !(returndata.length < 0x20) label_0FBB: // Incoming jump from 0x0FBA, if not !(returndata.length < 0x20) // Inputs[1] { @0FBE memory[0x00:0x00] } 0FBB 60 PUSH1 0x00 0FBD 80 DUP1 0FBE FD *REVERT // Stack delta = +0 // Outputs[1] { @0FBE revert(memory[0x00:0x00]); } // Block terminates label_0FBF: // Incoming jump from 0x0FBA, if !(returndata.length < 0x20) // Inputs[4] // { // @0FC1 stack[-2] // @0FC1 memory[stack[-2]:stack[-2] + 0x20] // @0FC4 stack[-3] // @0FC6 storage[stack[-3] + 0x01] // } 0FBF 5B JUMPDEST 0FC0 50 POP 0FC1 51 MLOAD 0FC2 60 PUSH1 0x01 0FC4 82 DUP3 0FC5 01 ADD 0FC6 54 SLOAD 0FC7 11 GT 0FC8 15 ISZERO 0FC9 61 PUSH2 0x101c 0FCC 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x101c, if !(storage[stack[-3] + 0x01] > memory[stack[-2]:stack[-2] + 0x20]) label_0FCD: // Incoming jump from 0x0FCC, if not !(storage[stack[-3] + 0x01] > memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @0FD0 memory[0x40:0x60] // @1012 memory[0x40:0x60] // @101B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0FCD 60 PUSH1 0x40 0FCF 80 DUP1 0FD0 51 MLOAD 0FD1 60 PUSH1 0x01 0FD3 60 PUSH1 0xe5 0FD5 1B SHL 0FD6 62 PUSH3 0x461bcd 0FDA 02 MUL 0FDB 81 DUP2 0FDC 52 MSTORE 0FDD 60 PUSH1 0x20 0FDF 60 PUSH1 0x04 0FE1 82 DUP3 0FE2 01 ADD 0FE3 52 MSTORE 0FE4 60 PUSH1 0x0d 0FE6 60 PUSH1 0x24 0FE8 82 DUP3 0FE9 01 ADD 0FEA 52 MSTORE 0FEB 7F PUSH32 0x616d6f756e745f656e6f75676800000000000000000000000000000000000000 100C 60 PUSH1 0x44 100E 82 DUP3 100F 01 ADD 1010 52 MSTORE 1011 90 SWAP1 1012 51 MLOAD 1013 90 SWAP1 1014 81 DUP2 1015 90 SWAP1 1016 03 SUB 1017 60 PUSH1 0x64 1019 01 ADD 101A 90 SWAP1 101B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0FDC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0FE3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0FEA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0d // @1010 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x616d6f756e745f656e6f75676800000000000000000000000000000000000000 // @101B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_101C: // Incoming jump from 0x0FCC, if !(storage[stack[-3] + 0x01] > memory[stack[-2]:stack[-2] + 0x20]) // Inputs[7] // { // @101F storage[0x08] // @1020 stack[-1] // @1021 storage[stack[-1]] // @1026 storage[stack[-1] + 0x01] // @102A memory[0x40:0x60] // @1050 memory[0x40:0x60] // @1070 address(storage[0x08] & (0x01 << 0xa0) - 0x01).code.length // } 101C 5B JUMPDEST 101D 60 PUSH1 0x08 101F 54 SLOAD 1020 81 DUP2 1021 54 SLOAD 1022 60 PUSH1 0x01 1024 83 DUP4 1025 01 ADD 1026 54 SLOAD 1027 60 PUSH1 0x40 1029 80 DUP1 102A 51 MLOAD 102B 60 PUSH1 0x01 102D 60 PUSH1 0xe0 102F 1B SHL 1030 63 PUSH4 0xa9059cbb 1035 02 MUL 1036 81 DUP2 1037 52 MSTORE 1038 60 PUSH1 0x01 103A 60 PUSH1 0x01 103C 60 PUSH1 0xa0 103E 1B SHL 103F 03 SUB 1040 93 SWAP4 1041 84 DUP5 1042 16 AND 1043 60 PUSH1 0x04 1045 82 DUP3 1046 01 ADD 1047 52 MSTORE 1048 60 PUSH1 0x24 104A 81 DUP2 104B 01 ADD 104C 92 SWAP3 104D 90 SWAP1 104E 92 SWAP3 104F 52 MSTORE 1050 51 MLOAD 1051 91 SWAP2 1052 90 SWAP1 1053 92 SWAP3 1054 16 AND 1055 91 SWAP2 1056 63 PUSH4 0xa9059cbb 105B 91 SWAP2 105C 60 PUSH1 0x44 105E 80 DUP1 105F 83 DUP4 1060 01 ADD 1061 92 SWAP3 1062 60 PUSH1 0x20 1064 92 SWAP3 1065 91 SWAP2 1066 90 SWAP1 1067 82 DUP3 1068 90 SWAP1 1069 03 SUB 106A 01 ADD 106B 81 DUP2 106C 60 PUSH1 0x00 106E 87 DUP8 106F 80 DUP1 1070 3B EXTCODESIZE 1071 15 ISZERO 1072 80 DUP1 1073 15 ISZERO 1074 61 PUSH2 0x107c 1077 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @1037 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa9059cbb * (0x01 << 0xe0) // @1047 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & storage[stack[-1]] // @104F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = storage[stack[-1] + 0x01] // @1055 stack[0] = storage[0x08] & (0x01 << 0xa0) - 0x01 // @105B stack[1] = 0xa9059cbb // @1061 stack[2] = memory[0x40:0x60] + 0x44 // @1064 stack[3] = 0x20 // @1065 stack[4] = memory[0x40:0x60] // @106A stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @106B stack[6] = memory[0x40:0x60] // @106C stack[7] = 0x00 // @106E stack[8] = storage[0x08] & (0x01 << 0xa0) - 0x01 // @1071 stack[9] = !address(storage[0x08] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x107c, if !!address(storage[0x08] & (0x01 << 0xa0) - 0x01).code.length label_1078: // Incoming jump from 0x1077, if not !!address(storage[0x08] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @107B memory[0x00:0x00] } 1078 60 PUSH1 0x00 107A 80 DUP1 107B FD *REVERT // Stack delta = +0 // Outputs[1] { @107B revert(memory[0x00:0x00]); } // Block terminates label_107C: // Incoming jump from 0x1077, if !!address(storage[0x08] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @107E msg.gas // @107F address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @107F stack[-5] // @107F stack[-6] // @107F stack[-3] // @107F stack[-4] // @107F stack[-2] // @107F stack[-7] // @107F memory[stack[-4]:stack[-4] + stack[-5]] // } 107C 5B JUMPDEST 107D 50 POP 107E 5A GAS 107F F1 CALL 1080 15 ISZERO 1081 80 DUP1 1082 15 ISZERO 1083 61 PUSH2 0x1090 1086 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @107F memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1080 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1090, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1087: // Incoming jump from 0x1086, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1087 returndata.length // @108B returndata[0x00:0x00 + returndata.length] // @108C returndata.length // @108F memory[0x00:0x00 + returndata.length] // } 1087 3D RETURNDATASIZE 1088 60 PUSH1 0x00 108A 80 DUP1 108B 3E RETURNDATACOPY 108C 3D RETURNDATASIZE 108D 60 PUSH1 0x00 108F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @108B memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @108F revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1090: // Incoming jump from 0x1086, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1097 memory[0x40:0x60] // @1098 returndata.length // } 1090 5B JUMPDEST 1091 50 POP 1092 50 POP 1093 50 POP 1094 50 POP 1095 60 PUSH1 0x40 1097 51 MLOAD 1098 3D RETURNDATASIZE 1099 60 PUSH1 0x20 109B 81 DUP2 109C 10 LT 109D 15 ISZERO 109E 61 PUSH2 0x10a6 10A1 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1097 stack[-4] = memory[0x40:0x60] // @1098 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x10a6, if !(returndata.length < 0x20) label_10A2: // Incoming jump from 0x10A1, if not !(returndata.length < 0x20) // Inputs[1] { @10A5 memory[0x00:0x00] } 10A2 60 PUSH1 0x00 10A4 80 DUP1 10A5 FD *REVERT // Stack delta = +0 // Outputs[1] { @10A5 revert(memory[0x00:0x00]); } // Block terminates label_10A6: // Incoming jump from 0x10A1, if !(returndata.length < 0x20) // Inputs[2] // { // @10A8 stack[-2] // @10A8 memory[stack[-2]:stack[-2] + 0x20] // } 10A6 5B JUMPDEST 10A7 50 POP 10A8 51 MLOAD 10A9 61 PUSH2 0x10ed 10AC 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x10ed, if memory[stack[-2]:stack[-2] + 0x20] label_10AD: // Incoming jump from 0x10AC, if not memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @10B0 memory[0x40:0x60] // @10E3 memory[0x40:0x60] // @10EC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 10AD 60 PUSH1 0x40 10AF 80 DUP1 10B0 51 MLOAD 10B1 60 PUSH1 0x01 10B3 60 PUSH1 0xe5 10B5 1B SHL 10B6 62 PUSH3 0x461bcd 10BA 02 MUL 10BB 81 DUP2 10BC 52 MSTORE 10BD 60 PUSH1 0x20 10BF 60 PUSH1 0x04 10C1 82 DUP3 10C2 01 ADD 10C3 52 MSTORE 10C4 60 PUSH1 0x0b 10C6 60 PUSH1 0x24 10C8 82 DUP3 10C9 01 ADD 10CA 52 MSTORE 10CB 60 PUSH1 0x01 10CD 60 PUSH1 0xaa 10CF 1B SHL 10D0 6A PUSH11 0x1d1c985b9cd9995c9c9959 10DC 02 MUL 10DD 60 PUSH1 0x44 10DF 82 DUP3 10E0 01 ADD 10E1 52 MSTORE 10E2 90 SWAP1 10E3 51 MLOAD 10E4 90 SWAP1 10E5 81 DUP2 10E6 90 SWAP1 10E7 03 SUB 10E8 60 PUSH1 0x64 10EA 01 ADD 10EB 90 SWAP1 10EC FD *REVERT // Stack delta = +0 // Outputs[5] // { // @10BC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @10C3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @10CA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0b // @10E1 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1d1c985b9cd9995c9c9959 * (0x01 << 0xaa) // @10EC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_10ED: // Incoming jump from 0x10AC, if memory[stack[-2]:stack[-2] + 0x20] // Inputs[7] // { // @10EE stack[-1] // @10EF storage[stack[-1]] // @10F4 storage[stack[-1] + 0x01] // @10F8 memory[0x40:0x60] // @110F memory[0x40:0x60] // @1139 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x40 + (memory[0x40:0x60] - memory[0x40:0x60])] // @113C stack[-3] // } 10ED 5B JUMPDEST 10EE 80 DUP1 10EF 54 SLOAD 10F0 60 PUSH1 0x01 10F2 82 DUP3 10F3 01 ADD 10F4 54 SLOAD 10F5 60 PUSH1 0x40 10F7 80 DUP1 10F8 51 MLOAD 10F9 60 PUSH1 0x01 10FB 60 PUSH1 0x01 10FD 60 PUSH1 0xa0 10FF 1B SHL 1100 03 SUB 1101 90 SWAP1 1102 93 SWAP4 1103 16 AND 1104 83 DUP4 1105 52 MSTORE 1106 60 PUSH1 0x20 1108 83 DUP4 1109 01 ADD 110A 91 SWAP2 110B 90 SWAP1 110C 91 SWAP2 110D 52 MSTORE 110E 80 DUP1 110F 51 MLOAD 1110 7F PUSH32 0xe6d858f14d755446648a6e0c8ab8b5a0f58ccc7920d4c910b0454e4dcd869af0 1131 92 SWAP3 1132 81 DUP2 1133 90 SWAP1 1134 03 SUB 1135 90 SWAP1 1136 91 SWAP2 1137 01 ADD 1138 90 SWAP1 1139 A1 LOG1 113A 50 POP 113B 50 POP 113C 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1105 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[stack[-1]] & (0x01 << 0xa0) - 0x01 // @110D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = storage[stack[-1] + 0x01] // @1139 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x40 + (memory[0x40:0x60] - memory[0x40:0x60])], [0xe6d858f14d755446648a6e0c8ab8b5a0f58ccc7920d4c910b0454e4dcd869af0]); // } // Block ends with unconditional jump to stack[-3] 113D FE *ASSERT 113E A1 LOG1 113F 65 PUSH6 0x627a7a723058 1146 20 SHA3 1147 C4 C4 1148 1E 1E 1149 86 DUP7 114A 17 OR 114B CA CA 114C 30 ADDRESS 114D 17 OR 114E E0 E0 114F F3 *RETURN 1150 35 CALLDATALOAD 1151 DB DB 1152 BD BD 1153 0E 0E 1154 CB CB 1155 C9 C9 1156 B2 SWAP 1157 0C 0C 1158 1E 1E 1159 22 22 115A 8B DUP12 115B 33 CALLER 115C 4B 4B 115D 9D SWAP14 115E BD BD 115F FF *SELFDESTRUCT 1160 22 22 1161 5E 5E 1162 05 SDIV 1163 58 PC 1164 7B PUSH28 0xf5df0029
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]