Online Solidity Decompiler

« Decompile another contract

Address

0x8d73365bb00a9a1a06100fdfdc22fd8a61cfff93 [etherscan.io]

Public Methods

Method names cached from 4byte.directory.
0x061778b6 Unknown
0x06fdde03 name()
0x095ea7b3 approve(address,uint256)
0x16ada547 time()
0x18160ddd totalSupply()
0x313ce567 decimals()
0x3a0f6e04 Unknown
0x3ccfd60b withdraw()
0x5ad0ae39 Unknown
0x70a08231 balanceOf(address)
0x8da5cb5b owner()
0x95907291 CaptureTheFlag(string)
0x95d89b41 symbol()
0xa9059cbb transfer(address,uint256)
0xca5d0880 airDrop()
0xdd62ed3e allowance(address,address)
0xe86383b3 Unknown
0xf664de00 Unknown
0xfcae8c06 takeMoney()

Internal Methods

func_0706(arg1) returns (r0)
name(arg0) returns (r0)
approve(arg0, arg1) returns (r0)
time(arg0) returns (r0)
totalSupply() returns (r0)
decimals(arg0) returns (r0)
func_085E()
withdraw()
func_09D7(arg0, arg1, arg2, arg3) returns (r0)
balanceOf(arg0) returns (r0)
owner(arg0) returns (r0)
CaptureTheFlag(arg0) returns (r0)
symbol(arg0) returns (r0)
transfer(arg0, arg1) returns (r0)
airDrop(arg0) returns (r0)
allowance(arg0, arg1) returns (r0)
func_1044(arg0)
func_1109(arg1) returns (r0)
takeMoney() returns (r0)
func_12C5(arg0, arg1) returns (r0)

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x80; if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); } var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff; if (var0 == 0x061778b6) { // Dispatch table entry for 0x061778b6 (unknown) var var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x014d; var var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; var2 = func_0706(var2); var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = var2; var temp1 = memory[0x40:0x60]; return memory[temp1:temp1 + (temp0 + 0x20) - temp1]; } else if (var0 == 0x06fdde03) { // Dispatch table entry for name() var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0178; var2 = name(); var temp2 = memory[0x40:0x60]; var var3 = temp2; var var4 = var3; var temp3 = var4 + 0x20; memory[var4:var4 + 0x20] = temp3 - var4; var temp4 = var2; memory[temp3:temp3 + 0x20] = memory[temp4:temp4 + 0x20]; var var5 = temp3 + 0x20; var var7 = memory[temp4:temp4 + 0x20]; var var6 = temp4 + 0x20; var var8 = var7; var var9 = var5; var var10 = var6; var var11 = 0x00; if (var11 >= var8) { label_01B8: var temp5 = var7; var5 = temp5 + var5; var6 = temp5 & 0x1f; if (!var6) { var temp6 = memory[0x40:0x60]; return memory[temp6:temp6 + var5 - temp6]; } else { var temp7 = var6; var temp8 = var5 - temp7; memory[temp8:temp8 + 0x20] = ~(0x0100 ** (0x20 - temp7) - 0x01) & memory[temp8:temp8 + 0x20]; var temp9 = memory[0x40:0x60]; return memory[temp9:temp9 + (temp8 + 0x20) - temp9]; } } else { label_01A6: var temp10 = var11; memory[var9 + temp10:var9 + temp10 + 0x20] = memory[var10 + temp10:var10 + temp10 + 0x20]; var11 = temp10 + 0x20; if (var11 >= var8) { goto label_01B8; } else { goto label_01A6; } } } else if (var0 == 0x095ea7b3) { // Dispatch table entry for approve(address,uint256) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x023e; var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; var3 = msg.data[0x24:0x44]; var1 = approve(var2, var3); var temp11 = memory[0x40:0x60]; memory[temp11:temp11 + 0x20] = !!var1; var temp12 = memory[0x40:0x60]; return memory[temp12:temp12 + (temp11 + 0x20) - temp12]; } else if (var0 == 0x16ada547) { // Dispatch table entry for time() var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x026d; var2 = time(); var temp13 = memory[0x40:0x60]; memory[temp13:temp13 + 0x20] = var2; var temp14 = memory[0x40:0x60]; return memory[temp14:temp14 + (temp13 + 0x20) - temp14]; } else if (var0 == 0x18160ddd) { // Dispatch table entry for totalSupply() var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0298; var1 = totalSupply(); var temp15 = memory[0x40:0x60]; memory[temp15:temp15 + 0x20] = var1; var temp16 = memory[0x40:0x60]; return memory[temp16:temp16 + (temp15 + 0x20) - temp16]; } else if (var0 == 0x313ce567) { // Dispatch table entry for decimals() var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x02c3; var2 = decimals(); var temp17 = memory[0x40:0x60]; memory[temp17:temp17 + 0x20] = var2; var temp18 = memory[0x40:0x60]; return memory[temp18:temp18 + (temp17 + 0x20) - temp18]; } else if (var0 == 0x3a0f6e04) { // Dispatch table entry for 0x3a0f6e04 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x02ee; func_085E(); stop(); } else if (var0 == 0x3ccfd60b) { // Dispatch table entry for withdraw() var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0305; withdraw(); stop(); } else if (var0 == 0x5ad0ae39) { // Dispatch table entry for 0x5ad0ae39 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x037c; var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; var3 = msg.data[0x24:0x44] & 0xffffffffffffffffffffffffffffffffffffffff; var4 = msg.data[0x44:0x64]; var5 = msg.data[0x64:0x84]; var1 = func_09D7(var2, var3, var4, var5); var temp19 = memory[0x40:0x60]; memory[temp19:temp19 + 0x20] = !!var1; var temp20 = memory[0x40:0x60]; return memory[temp20:temp20 + (temp19 + 0x20) - temp20]; } else if (var0 == 0x70a08231) { // Dispatch table entry for balanceOf(address) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x03d7; var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; var1 = balanceOf(var2); var temp21 = memory[0x40:0x60]; memory[temp21:temp21 + 0x20] = var1; var temp22 = memory[0x40:0x60]; return memory[temp22:temp22 + (temp21 + 0x20) - temp22]; } else if (var0 == 0x8da5cb5b) { // Dispatch table entry for owner() var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0402; var2 = owner(); var temp23 = memory[0x40:0x60]; memory[temp23:temp23 + 0x20] = var2 & 0xffffffffffffffffffffffffffffffffffffffff; var temp24 = memory[0x40:0x60]; return memory[temp24:temp24 + (temp23 + 0x20) - temp24]; } else if (var0 == 0x95907291) { // Dispatch table entry for CaptureTheFlag(string) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x04ab; var temp25 = msg.data[0x04:0x24] + 0x04; var temp26 = msg.data[temp25:temp25 + 0x20]; var temp27 = memory[0x40:0x60]; memory[0x40:0x60] = temp27 + (temp26 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp27:temp27 + 0x20] = temp26; memory[temp27 + 0x20:temp27 + 0x20 + temp26] = msg.data[temp25 + 0x20:temp25 + 0x20 + temp26]; var2 = temp27; var1 = CaptureTheFlag(var2); var temp28 = memory[0x40:0x60]; memory[temp28:temp28 + 0x20] = !!var1; var temp29 = memory[0x40:0x60]; return memory[temp29:temp29 + (temp28 + 0x20) - temp29]; } else if (var0 == 0x95d89b41) { // Dispatch table entry for symbol() var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x04da; var2 = symbol(); var temp30 = memory[0x40:0x60]; var3 = temp30; var4 = var3; var temp31 = var4 + 0x20; memory[var4:var4 + 0x20] = temp31 - var4; var temp32 = var2; memory[temp31:temp31 + 0x20] = memory[temp32:temp32 + 0x20]; var5 = temp31 + 0x20; var6 = temp32 + 0x20; var7 = memory[temp32:temp32 + 0x20]; var8 = var7; var9 = var5; var10 = var6; var11 = 0x00; if (var11 >= var8) { label_051A: var temp33 = var7; var5 = temp33 + var5; var6 = temp33 & 0x1f; if (!var6) { var temp34 = memory[0x40:0x60]; return memory[temp34:temp34 + var5 - temp34]; } else { var temp35 = var6; var temp36 = var5 - temp35; memory[temp36:temp36 + 0x20] = ~(0x0100 ** (0x20 - temp35) - 0x01) & memory[temp36:temp36 + 0x20]; var temp37 = memory[0x40:0x60]; return memory[temp37:temp37 + (temp36 + 0x20) - temp37]; } } else { label_0508: var temp38 = var11; memory[var9 + temp38:var9 + temp38 + 0x20] = memory[var10 + temp38:var10 + temp38 + 0x20]; var11 = temp38 + 0x20; if (var11 >= var8) { goto label_051A; } else { goto label_0508; } } } else if (var0 == 0xa9059cbb) { // Dispatch table entry for transfer(address,uint256) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x05a0; var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; var3 = msg.data[0x24:0x44]; var1 = transfer(var2, var3); var temp39 = memory[0x40:0x60]; memory[temp39:temp39 + 0x20] = !!var1; var temp40 = memory[0x40:0x60]; return memory[temp40:temp40 + (temp39 + 0x20) - temp40]; } else if (var0 == 0xca5d0880) { // Dispatch table entry for airDrop() var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x05cf; var2 = airDrop(); var temp41 = memory[0x40:0x60]; memory[temp41:temp41 + 0x20] = var2; var temp42 = memory[0x40:0x60]; return memory[temp42:temp42 + (temp41 + 0x20) - temp42]; } else if (var0 == 0xdd62ed3e) { // Dispatch table entry for allowance(address,address) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x0646; var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; var3 = msg.data[0x24:0x44] & 0xffffffffffffffffffffffffffffffffffffffff; var1 = allowance(var2, var3); var temp43 = memory[0x40:0x60]; memory[temp43:temp43 + 0x20] = var1; var temp44 = memory[0x40:0x60]; return memory[temp44:temp44 + (temp43 + 0x20) - temp44]; } else if (var0 == 0xe86383b3) { // Dispatch table entry for 0xe86383b3 (unknown) var1 = 0x067a; var2 = msg.data[0x04:0x24]; func_1044(var2); stop(); } else if (var0 == 0xf664de00) { // Dispatch table entry for 0xf664de00 (unknown) var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x06bd; var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff; var2 = func_1109(var2); var temp45 = memory[0x40:0x60]; memory[temp45:temp45 + 0x20] = !!var2; var temp46 = memory[0x40:0x60]; return memory[temp46:temp46 + (temp45 + 0x20) - temp46]; } else if (var0 == 0xfcae8c06) { // Dispatch table entry for takeMoney() var1 = msg.value; if (var1) { revert(memory[0x00:0x00]); } var1 = 0x06ec; var1 = takeMoney(); var temp47 = memory[0x40:0x60]; memory[temp47:temp47 + 0x20] = !!var1; var temp48 = memory[0x40:0x60]; return memory[temp48:temp48 + (temp47 + 0x20) - temp48]; } else { revert(memory[0x00:0x00]); } } function func_0706(var arg0) returns (var arg0) { memory[0x20:0x40] = 0x09; memory[0x00:0x20] = arg0; return storage[keccak256(memory[0x00:0x40])]; } function name() returns (var r0) { var temp0 = memory[0x40:0x60]; r0 = temp0; memory[0x40:0x60] = r0 + 0x40; memory[r0:r0 + 0x20] = 0x04; memory[r0 + 0x20:r0 + 0x20 + 0x20] = 0x436f696e00000000000000000000000000000000000000000000000000000000; return r0; } function approve(var arg0, var arg1) returns (var r0) { var temp0 = arg1; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x03; var temp1 = keccak256(memory[0x00:0x40]); var temp2 = arg0; memory[0x00:0x20] = temp2 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp1; storage[keccak256(memory[0x00:0x40])] = temp0; var temp3 = memory[0x40:0x60]; memory[temp3:temp3 + 0x20] = temp0; var temp4 = memory[0x40:0x60]; log(memory[temp4:temp4 + (temp3 + 0x20) - temp4], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); return 0x01; } function time() returns (var r0) { return storage[0x07]; } function totalSupply() returns (var r0) { return storage[0x01]; } function decimals() returns (var r0) { return 0x03; } function func_085E() { var var0 = 0x257d8e293df14da274f6f2cd4dc2aef0c5d96c00; var temp0 = address(address(this)).balance; var temp1 = memory[0x40:0x60]; var temp2; temp2, memory[temp1:temp1 + 0x00] = address(var0 & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(!temp0 * 0x08fc).value(temp0)(memory[temp1:temp1 + memory[0x40:0x60] - temp1]); var var1 = !temp2; if (!var1) { return; } var temp3 = returndata.length; memory[0x00:0x00 + temp3] = returndata[0x00:0x00 + temp3]; revert(memory[0x00:0x00 + returndata.length]); } function withdraw() { if (msg.sender != storage[0x04] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); } memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x0a; if (!!(storage[keccak256(memory[0x00:0x40])] & 0xff) != !!0x01) { revert(memory[0x00:0x00]); } memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; } function func_09D7(var arg0, var arg1, var arg2, var arg3) returns (var r0) { var var0 = 0x00; memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x03; var temp0 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = temp0; if (arg2 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); } if (storage[0x02] + msg.sender != arg3) { revert(memory[0x00:0x00]); } var temp1 = arg2; var temp2 = arg0; memory[0x00:0x20] = temp2 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x00; var temp3 = storage[keccak256(memory[0x00:0x40])] - temp1; memory[0x00:0x20] = temp2 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x00; storage[keccak256(memory[0x00:0x40])] = temp3; var temp4 = arg1; memory[0x00:0x20] = temp4 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x00; var temp5 = storage[keccak256(memory[0x00:0x40])] + temp1; memory[0x00:0x20] = temp4 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x00; storage[keccak256(memory[0x00:0x40])] = temp5; memory[0x00:0x20] = temp2 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x03; var temp6 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = temp6; var temp7 = storage[keccak256(memory[0x00:0x40])] - temp1; memory[0x00:0x20] = temp2 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x03; var temp8 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = temp8; storage[keccak256(memory[0x00:0x40])] = temp7; return 0x01; } function balanceOf(var arg0) returns (var r0) { memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x00; return storage[keccak256(memory[0x00:0x40])]; } function owner() returns (var r0) { return storage[0x0b] & 0xffffffffffffffffffffffffffffffffffffffff; } function CaptureTheFlag(var arg0) returns (var r0) { var var0 = 0x00; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x0a; if (!!(storage[keccak256(memory[0x00:0x40])] & 0xff) != !!0x01) { revert(memory[0x00:0x00]); } memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; if (storage[keccak256(memory[0x00:0x40])] != 0x00) { revert(memory[0x00:0x00]); } var var1 = 0x97803934afce44f37ca48365ffc7eb16fa035591056c7715c6747b0158d89f00; var temp0 = arg0; var var2 = temp0; var temp1 = memory[0x40:0x60]; var var3 = temp1; var var4 = var3; var var5 = var4 + 0x20; var temp2 = var5 + 0x20; memory[var4:var4 + 0x20] = temp2 - var4; memory[temp2:temp2 + 0x20] = memory[var2:var2 + 0x20]; var var6 = temp2 + 0x20; var var8 = memory[var2:var2 + 0x20]; var var7 = var2 + 0x20; var var9 = var8; var var10 = var6; var var11 = var7; var var12 = 0x00; if (var12 >= var9) { label_0E1F: var temp3 = var8; var6 = temp3 + var6; var7 = temp3 & 0x1f; if (!var7) { var temp4 = var6; memory[var5:var5 + 0x20] = temp4 - var3; memory[temp4:temp4 + 0x20] = 0x24; var temp5 = temp4 + 0x20; memory[temp5:temp5 + 0x20] = 0x436f6e67726174756c6174696f6e7320746f2063617074757265207468652066; memory[temp5 + 0x20:temp5 + 0x20 + 0x20] = 0x6c61672100000000000000000000000000000000000000000000000000000000; var temp6 = memory[0x40:0x60]; log(memory[temp6:temp6 + (temp5 + 0x40) - temp6], [stack[-7]]); return var0; } else { var temp7 = var7; var temp8 = var6 - temp7; memory[temp8:temp8 + 0x20] = ~(0x0100 ** (0x20 - temp7) - 0x01) & memory[temp8:temp8 + 0x20]; var temp9 = temp8 + 0x20; memory[var5:var5 + 0x20] = temp9 - var3; memory[temp9:temp9 + 0x20] = 0x24; var temp10 = temp9 + 0x20; memory[temp10:temp10 + 0x20] = 0x436f6e67726174756c6174696f6e7320746f2063617074757265207468652066; memory[temp10 + 0x20:temp10 + 0x20 + 0x20] = 0x6c61672100000000000000000000000000000000000000000000000000000000; var temp11 = memory[0x40:0x60]; log(memory[temp11:temp11 + (temp10 + 0x40) - temp11], [stack[-7]]); return var0; } } else { label_0E0D: var temp12 = var12; memory[var10 + temp12:var10 + temp12 + 0x20] = memory[var11 + temp12:var11 + temp12 + 0x20]; var12 = temp12 + 0x20; if (var12 >= var9) { goto label_0E1F; } else { goto label_0E0D; } } } function symbol() returns (var r0) { var temp0 = memory[0x40:0x60]; r0 = temp0; memory[0x40:0x60] = r0 + 0x40; memory[r0:r0 + 0x20] = 0x03; memory[r0 + 0x20:r0 + 0x20 + 0x20] = 0x3078300000000000000000000000000000000000000000000000000000000000; return r0; } function transfer(var arg0, var arg1) returns (var r0) { var var0 = 0x00; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x09; if (block.timestamp <= storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); } var var1 = 0x0f4b; var var2 = arg0; var var3 = arg1; var1 = func_12C5(var2, var3); var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = arg1; var temp1 = memory[0x40:0x60]; log(memory[temp1:temp1 + (temp0 + 0x20) - temp1], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, msg.sender, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff]); return var0; } function airDrop() returns (var r0) { return storage[0x08]; } function allowance(var arg0, var arg1) returns (var r0) { memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x03; var temp0 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp0; return storage[keccak256(memory[0x00:0x40])]; } function func_1044(var arg0) { var var0 = arg0 == storage[0x05]; if (!var0) { if (!var0) { revert(memory[0x00:0x00]); } label_1062: storage[0x0b] = msg.sender | (storage[0x0b] & ~0xffffffffffffffffffffffffffffffffffffffff); var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = msg.sender; var temp1 = memory[0x40:0x60]; log(memory[temp1:temp1 + (temp0 + 0x20) - temp1], [0xb55d30896f7b0c71b13dfc5d76977122428a5d16e59082dd105c040cdcb5b94f]); return; } else if (msg.value >= storage[0x06]) { goto label_1062; } else { revert(memory[0x00:0x00]); } } function func_1109(var arg0) returns (var arg0) { memory[0x20:0x40] = 0x0a; memory[0x00:0x20] = arg0; return storage[keccak256(memory[0x00:0x40])] & 0xff; } function takeMoney() returns (var r0) { var var0 = 0x00; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x0a; if (!!(storage[keccak256(memory[0x00:0x40])] & 0xff) != !!var0) { revert(memory[0x00:0x00]); } memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; storage[keccak256(memory[0x00:0x40])] = storage[0x08]; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x0a; var temp0 = keccak256(memory[0x00:0x40]); storage[temp0] = (storage[temp0] & ~0xff) | 0x01; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x09; storage[keccak256(memory[0x00:0x40])] = storage[0x07]; var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = storage[0x08]; var temp2 = memory[0x40:0x60]; log(memory[temp2:temp2 + (temp1 + 0x20) - temp2], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, msg.sender]); return 0x01; } function func_12C5(var arg0, var arg1) returns (var r0) { var var0 = 0x00; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = var0; if (arg1 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); } if (arg0 & 0xffffffffffffffffffffffffffffffffffffffff == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) { revert(memory[0x00:0x00]); } var temp0 = arg1; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; var temp1 = storage[keccak256(memory[0x00:0x40])] - temp0; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x00; storage[keccak256(memory[0x00:0x40])] = temp1; var temp2 = arg0; memory[0x00:0x20] = temp2 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x00; var temp3 = storage[keccak256(memory[0x00:0x40])] + temp0; memory[0x00:0x20] = temp2 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x00; storage[keccak256(memory[0x00:0x40])] = temp3; var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = temp0; var temp5 = memory[0x40:0x60]; log(memory[temp5:temp5 + (temp4 + 0x20) - temp5], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, msg.sender, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff]); return 0x01; } }

Disassembly

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x0107 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0107, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 002E 90 SWAP1 002F 04 DIV 0030 63 PUSH4 0xffffffff 0035 16 AND 0036 80 DUP1 0037 63 PUSH4 0x061778b6 003C 14 EQ 003D 61 PUSH2 0x010c 0040 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0035 stack[0] = 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x010c, if 0x061778b6 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 label_0041: // Incoming jump from 0x0040, if not 0x061778b6 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0x06fdde03 0047 14 EQ 0048 61 PUSH2 0x0163 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0163, if 0x06fdde03 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0x06fdde03 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0x095ea7b3 0052 14 EQ 0053 61 PUSH2 0x01f3 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f3, if 0x095ea7b3 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0x16ada547 005D 14 EQ 005E 61 PUSH2 0x0258 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0258, if 0x16ada547 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0x16ada547 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0x18160ddd 0068 14 EQ 0069 61 PUSH2 0x0283 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0283, if 0x18160ddd == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0x18160ddd == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0x313ce567 0073 14 EQ 0074 61 PUSH2 0x02ae 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ae, if 0x313ce567 == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0x313ce567 == stack[-1] // Inputs[1] { @0078 stack[-1] } 0078 80 DUP1 0079 63 PUSH4 0x3a0f6e04 007E 14 EQ 007F 61 PUSH2 0x02d9 0082 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d9, if 0x3a0f6e04 == stack[-1] label_0083: // Incoming jump from 0x0082, if not 0x3a0f6e04 == stack[-1] // Inputs[1] { @0083 stack[-1] } 0083 80 DUP1 0084 63 PUSH4 0x3ccfd60b 0089 14 EQ 008A 61 PUSH2 0x02f0 008D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f0, if 0x3ccfd60b == stack[-1] label_008E: // Incoming jump from 0x008D, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @008E stack[-1] } 008E 80 DUP1 008F 63 PUSH4 0x5ad0ae39 0094 14 EQ 0095 61 PUSH2 0x0307 0098 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0307, if 0x5ad0ae39 == stack[-1] label_0099: // Incoming jump from 0x0098, if not 0x5ad0ae39 == stack[-1] // Inputs[1] { @0099 stack[-1] } 0099 80 DUP1 009A 63 PUSH4 0x70a08231 009F 14 EQ 00A0 61 PUSH2 0x0396 00A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0396, if 0x70a08231 == stack[-1] label_00A4: // Incoming jump from 0x00A3, if not 0x70a08231 == stack[-1] // Inputs[1] { @00A4 stack[-1] } 00A4 80 DUP1 00A5 63 PUSH4 0x8da5cb5b 00AA 14 EQ 00AB 61 PUSH2 0x03ed 00AE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ed, if 0x8da5cb5b == stack[-1] label_00AF: // Incoming jump from 0x00AE, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00AF stack[-1] } 00AF 80 DUP1 00B0 63 PUSH4 0x95907291 00B5 14 EQ 00B6 61 PUSH2 0x0444 00B9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0444, if 0x95907291 == stack[-1] label_00BA: // Incoming jump from 0x00B9, if not 0x95907291 == stack[-1] // Inputs[1] { @00BA stack[-1] } 00BA 80 DUP1 00BB 63 PUSH4 0x95d89b41 00C0 14 EQ 00C1 61 PUSH2 0x04c5 00C4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c5, if 0x95d89b41 == stack[-1] label_00C5: // Incoming jump from 0x00C4, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00C5 stack[-1] } 00C5 80 DUP1 00C6 63 PUSH4 0xa9059cbb 00CB 14 EQ 00CC 61 PUSH2 0x0555 00CF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0555, if 0xa9059cbb == stack[-1] label_00D0: // Incoming jump from 0x00CF, if not 0xa9059cbb == stack[-1] // Inputs[1] { @00D0 stack[-1] } 00D0 80 DUP1 00D1 63 PUSH4 0xca5d0880 00D6 14 EQ 00D7 61 PUSH2 0x05ba 00DA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05ba, if 0xca5d0880 == stack[-1] label_00DB: // Incoming jump from 0x00DA, if not 0xca5d0880 == stack[-1] // Inputs[1] { @00DB stack[-1] } 00DB 80 DUP1 00DC 63 PUSH4 0xdd62ed3e 00E1 14 EQ 00E2 61 PUSH2 0x05e5 00E5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05e5, if 0xdd62ed3e == stack[-1] label_00E6: // Incoming jump from 0x00E5, if not 0xdd62ed3e == stack[-1] // Inputs[1] { @00E6 stack[-1] } 00E6 80 DUP1 00E7 63 PUSH4 0xe86383b3 00EC 14 EQ 00ED 61 PUSH2 0x065c 00F0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x065c, if 0xe86383b3 == stack[-1] label_00F1: // Incoming jump from 0x00F0, if not 0xe86383b3 == stack[-1] // Inputs[1] { @00F1 stack[-1] } 00F1 80 DUP1 00F2 63 PUSH4 0xf664de00 00F7 14 EQ 00F8 61 PUSH2 0x067c 00FB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x067c, if 0xf664de00 == stack[-1] label_00FC: // Incoming jump from 0x00FB, if not 0xf664de00 == stack[-1] // Inputs[1] { @00FC stack[-1] } 00FC 80 DUP1 00FD 63 PUSH4 0xfcae8c06 0102 14 EQ 0103 61 PUSH2 0x06d7 0106 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06d7, if 0xfcae8c06 == stack[-1] label_0107: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x0106, if not 0xfcae8c06 == stack[-1] // Inputs[1] { @010B memory[0x00:0x00] } 0107 5B JUMPDEST 0108 60 PUSH1 0x00 010A 80 DUP1 010B FD *REVERT // Stack delta = +0 // Outputs[1] { @010B revert(memory[0x00:0x00]); } // Block terminates label_010C: // Incoming jump from 0x0040, if 0x061778b6 == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @010D msg.value } 010C 5B JUMPDEST 010D 34 CALLVALUE 010E 80 DUP1 010F 15 ISZERO 0110 61 PUSH2 0x0118 0113 57 *JUMPI // Stack delta = +1 // Outputs[1] { @010D stack[0] = msg.value } // Block ends with conditional jump to 0x0118, if !msg.value label_0114: // Incoming jump from 0x0113, if not !msg.value // Inputs[1] { @0117 memory[0x00:0x00] } 0114 60 PUSH1 0x00 0116 80 DUP1 0117 FD *REVERT // Stack delta = +0 // Outputs[1] { @0117 revert(memory[0x00:0x00]); } // Block terminates label_0118: // Incoming jump from 0x0113, if !msg.value // Inputs[2] // { // @0120 msg.data.length // @0127 msg.data[0x04:0x24] // } 0118 5B JUMPDEST 0119 50 POP 011A 61 PUSH2 0x014d 011D 60 PUSH1 0x04 011F 80 DUP1 0120 36 CALLDATASIZE 0121 03 SUB 0122 81 DUP2 0123 01 ADD 0124 90 SWAP1 0125 80 DUP1 0126 80 DUP1 0127 35 CALLDATALOAD 0128 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 013D 16 AND 013E 90 SWAP1 013F 60 PUSH1 0x20 0141 01 ADD 0142 90 SWAP1 0143 92 SWAP3 0144 91 SWAP2 0145 90 SWAP1 0146 50 POP 0147 50 POP 0148 50 POP 0149 61 PUSH2 0x0706 014C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @011A stack[-1] = 0x014d // @0143 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x0706, returns to 0x014D label_014D: // Incoming return from call to 0x0706 at 0x014C // Inputs[4] // { // @0150 memory[0x40:0x60] // @0152 stack[-1] // @015D memory[0x40:0x60] // @0162 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 014D 5B JUMPDEST 014E 60 PUSH1 0x40 0150 51 MLOAD 0151 80 DUP1 0152 82 DUP3 0153 81 DUP2 0154 52 MSTORE 0155 60 PUSH1 0x20 0157 01 ADD 0158 91 SWAP2 0159 50 POP 015A 50 POP 015B 60 PUSH1 0x40 015D 51 MLOAD 015E 80 DUP1 015F 91 SWAP2 0160 03 SUB 0161 90 SWAP1 0162 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0154 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0162 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0163: // Incoming jump from 0x004B, if 0x06fdde03 == stack[-1] // Inputs[1] { @0164 msg.value } 0163 5B JUMPDEST 0164 34 CALLVALUE 0165 80 DUP1 0166 15 ISZERO 0167 61 PUSH2 0x016f 016A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0164 stack[0] = msg.value } // Block ends with conditional jump to 0x016f, if !msg.value label_016B: // Incoming jump from 0x016A, if not !msg.value // Inputs[1] { @016E memory[0x00:0x00] } 016B 60 PUSH1 0x00 016D 80 DUP1 016E FD *REVERT // Stack delta = +0 // Outputs[1] { @016E revert(memory[0x00:0x00]); } // Block terminates label_016F: // Incoming jump from 0x016A, if !msg.value 016F 5B JUMPDEST 0170 50 POP 0171 61 PUSH2 0x0178 0174 61 PUSH2 0x071e 0177 56 *JUMP // Stack delta = +0 // Outputs[1] { @0171 stack[-1] = 0x0178 } // Block ends with call to 0x071e, returns to 0x0178 label_0178: // Incoming return from call to 0x071E at 0x0177 // Inputs[4] // { // @017B memory[0x40:0x60] // @0186 stack[-1] // @0189 memory[stack[-1]:stack[-1] + 0x20] // @0192 memory[stack[-1]:stack[-1] + 0x20] // } 0178 5B JUMPDEST 0179 60 PUSH1 0x40 017B 51 MLOAD 017C 80 DUP1 017D 80 DUP1 017E 60 PUSH1 0x20 0180 01 ADD 0181 82 DUP3 0182 81 DUP2 0183 03 SUB 0184 82 DUP3 0185 52 MSTORE 0186 83 DUP4 0187 81 DUP2 0188 81 DUP2 0189 51 MLOAD 018A 81 DUP2 018B 52 MSTORE 018C 60 PUSH1 0x20 018E 01 ADD 018F 91 SWAP2 0190 50 POP 0191 80 DUP1 0192 51 MLOAD 0193 90 SWAP1 0194 60 PUSH1 0x20 0196 01 ADD 0197 90 SWAP1 0198 80 DUP1 0199 83 DUP4 019A 83 DUP4 019B 60 PUSH1 0x00 019D 5B JUMPDEST 019E 83 DUP4 019F 81 DUP2 01A0 10 LT 01A1 15 ISZERO 01A2 61 PUSH2 0x01b8 01A5 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @017B stack[0] = memory[0x40:0x60] // @017C stack[1] = memory[0x40:0x60] // @0185 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @018B memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @018F stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0197 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0197 stack[3] = 0x20 + stack[-1] // @0198 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0199 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @019A stack[7] = 0x20 + stack[-1] // @019B stack[8] = 0x00 // } // Block ends with conditional jump to 0x01b8, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_01A6: // Incoming jump from 0x01A5, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x01A5, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @01A6 stack[-1] // @01A7 stack[-2] // @01A9 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @01AB stack[-3] // } 01A6 80 DUP1 01A7 82 DUP3 01A8 01 ADD 01A9 51 MLOAD 01AA 81 DUP2 01AB 84 DUP5 01AC 01 ADD 01AD 52 MSTORE 01AE 60 PUSH1 0x20 01B0 81 DUP2 01B1 01 ADD 01B2 90 SWAP1 01B3 50 POP 01B4 61 PUSH2 0x019d 01B7 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01AD memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @01B2 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x019d label_01B8: // Incoming jump from 0x01A5, if !(stack[-1] < stack[-4]) // Incoming jump from 0x01A5, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @01BD stack[-6] // @01BD stack[-5] // @01BF stack[-7] // } 01B8 5B JUMPDEST 01B9 50 POP 01BA 50 POP 01BB 50 POP 01BC 50 POP 01BD 90 SWAP1 01BE 50 POP 01BF 90 SWAP1 01C0 81 DUP2 01C1 01 ADD 01C2 90 SWAP1 01C3 60 PUSH1 0x1f 01C5 16 AND 01C6 80 DUP1 01C7 15 ISZERO 01C8 61 PUSH2 0x01e5 01CB 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @01C2 stack[-7] = stack[-5] + stack[-7] // @01C5 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x01e5, if !(0x1f & stack[-5]) label_01CC: // Incoming jump from 0x01CB, if not !(0x1f & stack[-5]) // Inputs[6] // { // @01CC stack[-1] // @01CD stack[-2] // @01D0 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @01E7 stack[-5] // @01ED memory[0x40:0x60] // @01F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 01CC 80 DUP1 01CD 82 DUP3 01CE 03 SUB 01CF 80 DUP1 01D0 51 MLOAD 01D1 60 PUSH1 0x01 01D3 83 DUP4 01D4 60 PUSH1 0x20 01D6 03 SUB 01D7 61 PUSH2 0x0100 01DA 0A EXP 01DB 03 SUB 01DC 19 NOT 01DD 16 AND 01DE 81 DUP2 01DF 52 MSTORE 01E0 60 PUSH1 0x20 01E2 01 ADD 01E3 91 SWAP2 01E4 50 POP 01E5 5B JUMPDEST 01E6 50 POP 01E7 92 SWAP3 01E8 50 POP 01E9 50 POP 01EA 50 POP 01EB 60 PUSH1 0x40 01ED 51 MLOAD 01EE 80 DUP1 01EF 91 SWAP2 01F0 03 SUB 01F1 90 SWAP1 01F2 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @01DF memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @01F2 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_01F3: // Incoming jump from 0x0056, if 0x095ea7b3 == stack[-1] // Inputs[1] { @01F4 msg.value } 01F3 5B JUMPDEST 01F4 34 CALLVALUE 01F5 80 DUP1 01F6 15 ISZERO 01F7 61 PUSH2 0x01ff 01FA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01F4 stack[0] = msg.value } // Block ends with conditional jump to 0x01ff, if !msg.value label_01FB: // Incoming jump from 0x01FA, if not !msg.value // Inputs[1] { @01FE memory[0x00:0x00] } 01FB 60 PUSH1 0x00 01FD 80 DUP1 01FE FD *REVERT // Stack delta = +0 // Outputs[1] { @01FE revert(memory[0x00:0x00]); } // Block terminates label_01FF: // Incoming jump from 0x01FA, if !msg.value // Inputs[3] // { // @0207 msg.data.length // @020E msg.data[0x04:0x24] // @022E msg.data[0x24:0x44] // } 01FF 5B JUMPDEST 0200 50 POP 0201 61 PUSH2 0x023e 0204 60 PUSH1 0x04 0206 80 DUP1 0207 36 CALLDATASIZE 0208 03 SUB 0209 81 DUP2 020A 01 ADD 020B 90 SWAP1 020C 80 DUP1 020D 80 DUP1 020E 35 CALLDATALOAD 020F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0224 16 AND 0225 90 SWAP1 0226 60 PUSH1 0x20 0228 01 ADD 0229 90 SWAP1 022A 92 SWAP3 022B 91 SWAP2 022C 90 SWAP1 022D 80 DUP1 022E 35 CALLDATALOAD 022F 90 SWAP1 0230 60 PUSH1 0x20 0232 01 ADD 0233 90 SWAP1 0234 92 SWAP3 0235 91 SWAP2 0236 90 SWAP1 0237 50 POP 0238 50 POP 0239 50 POP 023A 61 PUSH2 0x0757 023D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0201 stack[-1] = 0x023e // @022A stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @0234 stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x0757, returns to 0x023E label_023E: // Incoming return from call to 0x0757 at 0x023D // Inputs[4] // { // @0241 memory[0x40:0x60] // @0243 stack[-1] // @0252 memory[0x40:0x60] // @0257 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 023E 5B JUMPDEST 023F 60 PUSH1 0x40 0241 51 MLOAD 0242 80 DUP1 0243 82 DUP3 0244 15 ISZERO 0245 15 ISZERO 0246 15 ISZERO 0247 15 ISZERO 0248 81 DUP2 0249 52 MSTORE 024A 60 PUSH1 0x20 024C 01 ADD 024D 91 SWAP2 024E 50 POP 024F 50 POP 0250 60 PUSH1 0x40 0252 51 MLOAD 0253 80 DUP1 0254 91 SWAP2 0255 03 SUB 0256 90 SWAP1 0257 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0249 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0257 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0258: // Incoming jump from 0x0061, if 0x16ada547 == stack[-1] // Inputs[1] { @0259 msg.value } 0258 5B JUMPDEST 0259 34 CALLVALUE 025A 80 DUP1 025B 15 ISZERO 025C 61 PUSH2 0x0264 025F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0259 stack[0] = msg.value } // Block ends with conditional jump to 0x0264, if !msg.value label_0260: // Incoming jump from 0x025F, if not !msg.value // Inputs[1] { @0263 memory[0x00:0x00] } 0260 60 PUSH1 0x00 0262 80 DUP1 0263 FD *REVERT // Stack delta = +0 // Outputs[1] { @0263 revert(memory[0x00:0x00]); } // Block terminates label_0264: // Incoming jump from 0x025F, if !msg.value 0264 5B JUMPDEST 0265 50 POP 0266 61 PUSH2 0x026d 0269 61 PUSH2 0x0849 026C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0266 stack[-1] = 0x026d } // Block ends with call to 0x0849, returns to 0x026D label_026D: // Incoming return from call to 0x0849 at 0x026C // Inputs[4] // { // @0270 memory[0x40:0x60] // @0272 stack[-1] // @027D memory[0x40:0x60] // @0282 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 026D 5B JUMPDEST 026E 60 PUSH1 0x40 0270 51 MLOAD 0271 80 DUP1 0272 82 DUP3 0273 81 DUP2 0274 52 MSTORE 0275 60 PUSH1 0x20 0277 01 ADD 0278 91 SWAP2 0279 50 POP 027A 50 POP 027B 60 PUSH1 0x40 027D 51 MLOAD 027E 80 DUP1 027F 91 SWAP2 0280 03 SUB 0281 90 SWAP1 0282 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0274 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0282 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0283: // Incoming jump from 0x006C, if 0x18160ddd == stack[-1] // Inputs[1] { @0284 msg.value } 0283 5B JUMPDEST 0284 34 CALLVALUE 0285 80 DUP1 0286 15 ISZERO 0287 61 PUSH2 0x028f 028A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0284 stack[0] = msg.value } // Block ends with conditional jump to 0x028f, if !msg.value label_028B: // Incoming jump from 0x028A, if not !msg.value // Inputs[1] { @028E memory[0x00:0x00] } 028B 60 PUSH1 0x00 028D 80 DUP1 028E FD *REVERT // Stack delta = +0 // Outputs[1] { @028E revert(memory[0x00:0x00]); } // Block terminates label_028F: // Incoming jump from 0x028A, if !msg.value 028F 5B JUMPDEST 0290 50 POP 0291 61 PUSH2 0x0298 0294 61 PUSH2 0x084f 0297 56 *JUMP // Stack delta = +0 // Outputs[1] { @0291 stack[-1] = 0x0298 } // Block ends with call to 0x084f, returns to 0x0298 label_0298: // Incoming return from call to 0x084F at 0x0297 // Inputs[4] // { // @029B memory[0x40:0x60] // @029D stack[-1] // @02A8 memory[0x40:0x60] // @02AD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0298 5B JUMPDEST 0299 60 PUSH1 0x40 029B 51 MLOAD 029C 80 DUP1 029D 82 DUP3 029E 81 DUP2 029F 52 MSTORE 02A0 60 PUSH1 0x20 02A2 01 ADD 02A3 91 SWAP2 02A4 50 POP 02A5 50 POP 02A6 60 PUSH1 0x40 02A8 51 MLOAD 02A9 80 DUP1 02AA 91 SWAP2 02AB 03 SUB 02AC 90 SWAP1 02AD F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @029F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02AD return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02AE: // Incoming jump from 0x0077, if 0x313ce567 == stack[-1] // Inputs[1] { @02AF msg.value } 02AE 5B JUMPDEST 02AF 34 CALLVALUE 02B0 80 DUP1 02B1 15 ISZERO 02B2 61 PUSH2 0x02ba 02B5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02AF stack[0] = msg.value } // Block ends with conditional jump to 0x02ba, if !msg.value label_02B6: // Incoming jump from 0x02B5, if not !msg.value // Inputs[1] { @02B9 memory[0x00:0x00] } 02B6 60 PUSH1 0x00 02B8 80 DUP1 02B9 FD *REVERT // Stack delta = +0 // Outputs[1] { @02B9 revert(memory[0x00:0x00]); } // Block terminates label_02BA: // Incoming jump from 0x02B5, if !msg.value 02BA 5B JUMPDEST 02BB 50 POP 02BC 61 PUSH2 0x02c3 02BF 61 PUSH2 0x0859 02C2 56 *JUMP // Stack delta = +0 // Outputs[1] { @02BC stack[-1] = 0x02c3 } // Block ends with call to 0x0859, returns to 0x02C3 label_02C3: // Incoming return from call to 0x0859 at 0x02C2 // Inputs[4] // { // @02C6 memory[0x40:0x60] // @02C8 stack[-1] // @02D3 memory[0x40:0x60] // @02D8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02C3 5B JUMPDEST 02C4 60 PUSH1 0x40 02C6 51 MLOAD 02C7 80 DUP1 02C8 82 DUP3 02C9 81 DUP2 02CA 52 MSTORE 02CB 60 PUSH1 0x20 02CD 01 ADD 02CE 91 SWAP2 02CF 50 POP 02D0 50 POP 02D1 60 PUSH1 0x40 02D3 51 MLOAD 02D4 80 DUP1 02D5 91 SWAP2 02D6 03 SUB 02D7 90 SWAP1 02D8 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02CA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02D8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02D9: // Incoming jump from 0x0082, if 0x3a0f6e04 == stack[-1] // Inputs[1] { @02DA msg.value } 02D9 5B JUMPDEST 02DA 34 CALLVALUE 02DB 80 DUP1 02DC 15 ISZERO 02DD 61 PUSH2 0x02e5 02E0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02DA stack[0] = msg.value } // Block ends with conditional jump to 0x02e5, if !msg.value label_02E1: // Incoming jump from 0x02E0, if not !msg.value // Inputs[1] { @02E4 memory[0x00:0x00] } 02E1 60 PUSH1 0x00 02E3 80 DUP1 02E4 FD *REVERT // Stack delta = +0 // Outputs[1] { @02E4 revert(memory[0x00:0x00]); } // Block terminates label_02E5: // Incoming jump from 0x02E0, if !msg.value 02E5 5B JUMPDEST 02E6 50 POP 02E7 61 PUSH2 0x02ee 02EA 61 PUSH2 0x085e 02ED 56 *JUMP // Stack delta = +0 // Outputs[1] { @02E7 stack[-1] = 0x02ee } // Block ends with call to 0x085e, returns to 0x02EE label_02EE: // Incoming return from call to 0x085E at 0x02ED 02EE 5B JUMPDEST 02EF 00 *STOP // Stack delta = +0 // Outputs[1] { @02EF stop(); } // Block terminates label_02F0: // Incoming jump from 0x008D, if 0x3ccfd60b == stack[-1] // Inputs[1] { @02F1 msg.value } 02F0 5B JUMPDEST 02F1 34 CALLVALUE 02F2 80 DUP1 02F3 15 ISZERO 02F4 61 PUSH2 0x02fc 02F7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02F1 stack[0] = msg.value } // Block ends with conditional jump to 0x02fc, if !msg.value label_02F8: // Incoming jump from 0x02F7, if not !msg.value // Inputs[1] { @02FB memory[0x00:0x00] } 02F8 60 PUSH1 0x00 02FA 80 DUP1 02FB FD *REVERT // Stack delta = +0 // Outputs[1] { @02FB revert(memory[0x00:0x00]); } // Block terminates label_02FC: // Incoming jump from 0x02F7, if !msg.value 02FC 5B JUMPDEST 02FD 50 POP 02FE 61 PUSH2 0x0305 0301 61 PUSH2 0x08d8 0304 56 *JUMP // Stack delta = +0 // Outputs[1] { @02FE stack[-1] = 0x0305 } // Block ends with call to 0x08d8, returns to 0x0305 label_0305: // Incoming return from call to 0x08D8 at 0x0304 0305 5B JUMPDEST 0306 00 *STOP // Stack delta = +0 // Outputs[1] { @0306 stop(); } // Block terminates label_0307: // Incoming jump from 0x0098, if 0x5ad0ae39 == stack[-1] // Inputs[1] { @0308 msg.value } 0307 5B JUMPDEST 0308 34 CALLVALUE 0309 80 DUP1 030A 15 ISZERO 030B 61 PUSH2 0x0313 030E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0308 stack[0] = msg.value } // Block ends with conditional jump to 0x0313, if !msg.value label_030F: // Incoming jump from 0x030E, if not !msg.value // Inputs[1] { @0312 memory[0x00:0x00] } 030F 60 PUSH1 0x00 0311 80 DUP1 0312 FD *REVERT // Stack delta = +0 // Outputs[1] { @0312 revert(memory[0x00:0x00]); } // Block terminates label_0313: // Incoming jump from 0x030E, if !msg.value // Inputs[5] // { // @031B msg.data.length // @0322 msg.data[0x04:0x24] // @0342 msg.data[0x24:0x44] // @0362 msg.data[0x44:0x64] // @036C msg.data[0x64:0x84] // } 0313 5B JUMPDEST 0314 50 POP 0315 61 PUSH2 0x037c 0318 60 PUSH1 0x04 031A 80 DUP1 031B 36 CALLDATASIZE 031C 03 SUB 031D 81 DUP2 031E 01 ADD 031F 90 SWAP1 0320 80 DUP1 0321 80 DUP1 0322 35 CALLDATALOAD 0323 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0338 16 AND 0339 90 SWAP1 033A 60 PUSH1 0x20 033C 01 ADD 033D 90 SWAP1 033E 92 SWAP3 033F 91 SWAP2 0340 90 SWAP1 0341 80 DUP1 0342 35 CALLDATALOAD 0343 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0358 16 AND 0359 90 SWAP1 035A 60 PUSH1 0x20 035C 01 ADD 035D 90 SWAP1 035E 92 SWAP3 035F 91 SWAP2 0360 90 SWAP1 0361 80 DUP1 0362 35 CALLDATALOAD 0363 90 SWAP1 0364 60 PUSH1 0x20 0366 01 ADD 0367 90 SWAP1 0368 92 SWAP3 0369 91 SWAP2 036A 90 SWAP1 036B 80 DUP1 036C 35 CALLDATALOAD 036D 90 SWAP1 036E 60 PUSH1 0x20 0370 01 ADD 0371 90 SWAP1 0372 92 SWAP3 0373 91 SWAP2 0374 90 SWAP1 0375 50 POP 0376 50 POP 0377 50 POP 0378 61 PUSH2 0x09d7 037B 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0315 stack[-1] = 0x037c // @033E stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @035E stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x24:0x44] // @0368 stack[2] = msg.data[0x44:0x64] // @0372 stack[3] = msg.data[0x64:0x84] // } // Block ends with call to 0x09d7, returns to 0x037C label_037C: // Incoming return from call to 0x09D7 at 0x037B // Inputs[4] // { // @037F memory[0x40:0x60] // @0381 stack[-1] // @0390 memory[0x40:0x60] // @0395 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 037C 5B JUMPDEST 037D 60 PUSH1 0x40 037F 51 MLOAD 0380 80 DUP1 0381 82 DUP3 0382 15 ISZERO 0383 15 ISZERO 0384 15 ISZERO 0385 15 ISZERO 0386 81 DUP2 0387 52 MSTORE 0388 60 PUSH1 0x20 038A 01 ADD 038B 91 SWAP2 038C 50 POP 038D 50 POP 038E 60 PUSH1 0x40 0390 51 MLOAD 0391 80 DUP1 0392 91 SWAP2 0393 03 SUB 0394 90 SWAP1 0395 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0387 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0395 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0396: // Incoming jump from 0x00A3, if 0x70a08231 == stack[-1] // Inputs[1] { @0397 msg.value } 0396 5B JUMPDEST 0397 34 CALLVALUE 0398 80 DUP1 0399 15 ISZERO 039A 61 PUSH2 0x03a2 039D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0397 stack[0] = msg.value } // Block ends with conditional jump to 0x03a2, if !msg.value label_039E: // Incoming jump from 0x039D, if not !msg.value // Inputs[1] { @03A1 memory[0x00:0x00] } 039E 60 PUSH1 0x00 03A0 80 DUP1 03A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @03A1 revert(memory[0x00:0x00]); } // Block terminates label_03A2: // Incoming jump from 0x039D, if !msg.value // Inputs[2] // { // @03AA msg.data.length // @03B1 msg.data[0x04:0x24] // } 03A2 5B JUMPDEST 03A3 50 POP 03A4 61 PUSH2 0x03d7 03A7 60 PUSH1 0x04 03A9 80 DUP1 03AA 36 CALLDATASIZE 03AB 03 SUB 03AC 81 DUP2 03AD 01 ADD 03AE 90 SWAP1 03AF 80 DUP1 03B0 80 DUP1 03B1 35 CALLDATALOAD 03B2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03C7 16 AND 03C8 90 SWAP1 03C9 60 PUSH1 0x20 03CB 01 ADD 03CC 90 SWAP1 03CD 92 SWAP3 03CE 91 SWAP2 03CF 90 SWAP1 03D0 50 POP 03D1 50 POP 03D2 50 POP 03D3 61 PUSH2 0x0c9d 03D6 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03A4 stack[-1] = 0x03d7 // @03CD stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x0c9d, returns to 0x03D7 label_03D7: // Incoming return from call to 0x0C9D at 0x03D6 // Inputs[4] // { // @03DA memory[0x40:0x60] // @03DC stack[-1] // @03E7 memory[0x40:0x60] // @03EC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 03D7 5B JUMPDEST 03D8 60 PUSH1 0x40 03DA 51 MLOAD 03DB 80 DUP1 03DC 82 DUP3 03DD 81 DUP2 03DE 52 MSTORE 03DF 60 PUSH1 0x20 03E1 01 ADD 03E2 91 SWAP2 03E3 50 POP 03E4 50 POP 03E5 60 PUSH1 0x40 03E7 51 MLOAD 03E8 80 DUP1 03E9 91 SWAP2 03EA 03 SUB 03EB 90 SWAP1 03EC F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @03DE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @03EC return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_03ED: // Incoming jump from 0x00AE, if 0x8da5cb5b == stack[-1] // Inputs[1] { @03EE msg.value } 03ED 5B JUMPDEST 03EE 34 CALLVALUE 03EF 80 DUP1 03F0 15 ISZERO 03F1 61 PUSH2 0x03f9 03F4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03EE stack[0] = msg.value } // Block ends with conditional jump to 0x03f9, if !msg.value label_03F5: // Incoming jump from 0x03F4, if not !msg.value // Inputs[1] { @03F8 memory[0x00:0x00] } 03F5 60 PUSH1 0x00 03F7 80 DUP1 03F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @03F8 revert(memory[0x00:0x00]); } // Block terminates label_03F9: // Incoming jump from 0x03F4, if !msg.value 03F9 5B JUMPDEST 03FA 50 POP 03FB 61 PUSH2 0x0402 03FE 61 PUSH2 0x0ce5 0401 56 *JUMP // Stack delta = +0 // Outputs[1] { @03FB stack[-1] = 0x0402 } // Block ends with call to 0x0ce5, returns to 0x0402 label_0402: // Incoming return from call to 0x0CE5 at 0x0401 // Inputs[4] // { // @0405 memory[0x40:0x60] // @0407 stack[-1] // @043E memory[0x40:0x60] // @0443 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0402 5B JUMPDEST 0403 60 PUSH1 0x40 0405 51 MLOAD 0406 80 DUP1 0407 82 DUP3 0408 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 041D 16 AND 041E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0433 16 AND 0434 81 DUP2 0435 52 MSTORE 0436 60 PUSH1 0x20 0438 01 ADD 0439 91 SWAP2 043A 50 POP 043B 50 POP 043C 60 PUSH1 0x40 043E 51 MLOAD 043F 80 DUP1 0440 91 SWAP2 0441 03 SUB 0442 90 SWAP1 0443 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0435 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0443 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0444: // Incoming jump from 0x00B9, if 0x95907291 == stack[-1] // Inputs[1] { @0445 msg.value } 0444 5B JUMPDEST 0445 34 CALLVALUE 0446 80 DUP1 0447 15 ISZERO 0448 61 PUSH2 0x0450 044B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0445 stack[0] = msg.value } // Block ends with conditional jump to 0x0450, if !msg.value label_044C: // Incoming jump from 0x044B, if not !msg.value // Inputs[1] { @044F memory[0x00:0x00] } 044C 60 PUSH1 0x00 044E 80 DUP1 044F FD *REVERT // Stack delta = +0 // Outputs[1] { @044F revert(memory[0x00:0x00]); } // Block terminates label_0450: // Incoming jump from 0x044B, if !msg.value // Inputs[5] // { // @0458 msg.data.length // @045F msg.data[0x04:0x24] // @0468 msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @047E memory[0x40:0x60] // @0495 msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // } 0450 5B JUMPDEST 0451 50 POP 0452 61 PUSH2 0x04ab 0455 60 PUSH1 0x04 0457 80 DUP1 0458 36 CALLDATASIZE 0459 03 SUB 045A 81 DUP2 045B 01 ADD 045C 90 SWAP1 045D 80 DUP1 045E 80 DUP1 045F 35 CALLDATALOAD 0460 90 SWAP1 0461 60 PUSH1 0x20 0463 01 ADD 0464 90 SWAP1 0465 82 DUP3 0466 01 ADD 0467 80 DUP1 0468 35 CALLDATALOAD 0469 90 SWAP1 046A 60 PUSH1 0x20 046C 01 ADD 046D 90 SWAP1 046E 80 DUP1 046F 80 DUP1 0470 60 PUSH1 0x1f 0472 01 ADD 0473 60 PUSH1 0x20 0475 80 DUP1 0476 91 SWAP2 0477 04 DIV 0478 02 MUL 0479 60 PUSH1 0x20 047B 01 ADD 047C 60 PUSH1 0x40 047E 51 MLOAD 047F 90 SWAP1 0480 81 DUP2 0481 01 ADD 0482 60 PUSH1 0x40 0484 52 MSTORE 0485 80 DUP1 0486 93 SWAP4 0487 92 SWAP3 0488 91 SWAP2 0489 90 SWAP1 048A 81 DUP2 048B 81 DUP2 048C 52 MSTORE 048D 60 PUSH1 0x20 048F 01 ADD 0490 83 DUP4 0491 83 DUP4 0492 80 DUP1 0493 82 DUP3 0494 84 DUP5 0495 37 CALLDATACOPY 0496 82 DUP3 0497 01 ADD 0498 91 SWAP2 0499 50 POP 049A 50 POP 049B 50 POP 049C 50 POP 049D 50 POP 049E 50 POP 049F 91 SWAP2 04A0 92 SWAP3 04A1 91 SWAP2 04A2 92 SWAP3 04A3 90 SWAP1 04A4 50 POP 04A5 50 POP 04A6 50 POP 04A7 61 PUSH2 0x0d0b 04AA 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0452 stack[-1] = 0x04ab // @0484 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]) / 0x20 * 0x20 // @048C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @0495 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] = msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // @04A2 stack[0] = memory[0x40:0x60] // } // Block ends with call to 0x0d0b, returns to 0x04AB label_04AB: // Incoming return from call to 0x0D0B at 0x04AA // Inputs[4] // { // @04AE memory[0x40:0x60] // @04B0 stack[-1] // @04BF memory[0x40:0x60] // @04C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 04AB 5B JUMPDEST 04AC 60 PUSH1 0x40 04AE 51 MLOAD 04AF 80 DUP1 04B0 82 DUP3 04B1 15 ISZERO 04B2 15 ISZERO 04B3 15 ISZERO 04B4 15 ISZERO 04B5 81 DUP2 04B6 52 MSTORE 04B7 60 PUSH1 0x20 04B9 01 ADD 04BA 91 SWAP2 04BB 50 POP 04BC 50 POP 04BD 60 PUSH1 0x40 04BF 51 MLOAD 04C0 80 DUP1 04C1 91 SWAP2 04C2 03 SUB 04C3 90 SWAP1 04C4 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @04B6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @04C4 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_04C5: // Incoming jump from 0x00C4, if 0x95d89b41 == stack[-1] // Inputs[1] { @04C6 msg.value } 04C5 5B JUMPDEST 04C6 34 CALLVALUE 04C7 80 DUP1 04C8 15 ISZERO 04C9 61 PUSH2 0x04d1 04CC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04C6 stack[0] = msg.value } // Block ends with conditional jump to 0x04d1, if !msg.value label_04CD: // Incoming jump from 0x04CC, if not !msg.value // Inputs[1] { @04D0 memory[0x00:0x00] } 04CD 60 PUSH1 0x00 04CF 80 DUP1 04D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D0 revert(memory[0x00:0x00]); } // Block terminates label_04D1: // Incoming jump from 0x04CC, if !msg.value 04D1 5B JUMPDEST 04D2 50 POP 04D3 61 PUSH2 0x04da 04D6 61 PUSH2 0x0eb9 04D9 56 *JUMP // Stack delta = +0 // Outputs[1] { @04D3 stack[-1] = 0x04da } // Block ends with call to 0x0eb9, returns to 0x04DA label_04DA: // Incoming return from call to 0x0EB9 at 0x04D9 // Inputs[4] // { // @04DD memory[0x40:0x60] // @04E8 stack[-1] // @04EB memory[stack[-1]:stack[-1] + 0x20] // @04F4 memory[stack[-1]:stack[-1] + 0x20] // } 04DA 5B JUMPDEST 04DB 60 PUSH1 0x40 04DD 51 MLOAD 04DE 80 DUP1 04DF 80 DUP1 04E0 60 PUSH1 0x20 04E2 01 ADD 04E3 82 DUP3 04E4 81 DUP2 04E5 03 SUB 04E6 82 DUP3 04E7 52 MSTORE 04E8 83 DUP4 04E9 81 DUP2 04EA 81 DUP2 04EB 51 MLOAD 04EC 81 DUP2 04ED 52 MSTORE 04EE 60 PUSH1 0x20 04F0 01 ADD 04F1 91 SWAP2 04F2 50 POP 04F3 80 DUP1 04F4 51 MLOAD 04F5 90 SWAP1 04F6 60 PUSH1 0x20 04F8 01 ADD 04F9 90 SWAP1 04FA 80 DUP1 04FB 83 DUP4 04FC 83 DUP4 04FD 60 PUSH1 0x00 04FF 5B JUMPDEST 0500 83 DUP4 0501 81 DUP2 0502 10 LT 0503 15 ISZERO 0504 61 PUSH2 0x051a 0507 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @04DD stack[0] = memory[0x40:0x60] // @04DE stack[1] = memory[0x40:0x60] // @04E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @04ED memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @04F1 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @04F9 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @04F9 stack[3] = 0x20 + stack[-1] // @04FA stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @04FB stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @04FC stack[7] = 0x20 + stack[-1] // @04FD stack[8] = 0x00 // } // Block ends with conditional jump to 0x051a, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0508: // Incoming jump from 0x0507, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0507, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0508 stack[-1] // @0509 stack[-2] // @050B memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @050D stack[-3] // } 0508 80 DUP1 0509 82 DUP3 050A 01 ADD 050B 51 MLOAD 050C 81 DUP2 050D 84 DUP5 050E 01 ADD 050F 52 MSTORE 0510 60 PUSH1 0x20 0512 81 DUP2 0513 01 ADD 0514 90 SWAP1 0515 50 POP 0516 61 PUSH2 0x04ff 0519 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @050F memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0514 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x04ff label_051A: // Incoming jump from 0x0507, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0507, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @051F stack[-6] // @051F stack[-5] // @0521 stack[-7] // } 051A 5B JUMPDEST 051B 50 POP 051C 50 POP 051D 50 POP 051E 50 POP 051F 90 SWAP1 0520 50 POP 0521 90 SWAP1 0522 81 DUP2 0523 01 ADD 0524 90 SWAP1 0525 60 PUSH1 0x1f 0527 16 AND 0528 80 DUP1 0529 15 ISZERO 052A 61 PUSH2 0x0547 052D 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0524 stack[-7] = stack[-5] + stack[-7] // @0527 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0547, if !(0x1f & stack[-5]) label_052E: // Incoming jump from 0x052D, if not !(0x1f & stack[-5]) // Inputs[6] // { // @052E stack[-1] // @052F stack[-2] // @0532 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0549 stack[-5] // @054F memory[0x40:0x60] // @0554 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 052E 80 DUP1 052F 82 DUP3 0530 03 SUB 0531 80 DUP1 0532 51 MLOAD 0533 60 PUSH1 0x01 0535 83 DUP4 0536 60 PUSH1 0x20 0538 03 SUB 0539 61 PUSH2 0x0100 053C 0A EXP 053D 03 SUB 053E 19 NOT 053F 16 AND 0540 81 DUP2 0541 52 MSTORE 0542 60 PUSH1 0x20 0544 01 ADD 0545 91 SWAP2 0546 50 POP 0547 5B JUMPDEST 0548 50 POP 0549 92 SWAP3 054A 50 POP 054B 50 POP 054C 50 POP 054D 60 PUSH1 0x40 054F 51 MLOAD 0550 80 DUP1 0551 91 SWAP2 0552 03 SUB 0553 90 SWAP1 0554 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0541 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0554 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0555: // Incoming jump from 0x00CF, if 0xa9059cbb == stack[-1] // Inputs[1] { @0556 msg.value } 0555 5B JUMPDEST 0556 34 CALLVALUE 0557 80 DUP1 0558 15 ISZERO 0559 61 PUSH2 0x0561 055C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0556 stack[0] = msg.value } // Block ends with conditional jump to 0x0561, if !msg.value label_055D: // Incoming jump from 0x055C, if not !msg.value // Inputs[1] { @0560 memory[0x00:0x00] } 055D 60 PUSH1 0x00 055F 80 DUP1 0560 FD *REVERT // Stack delta = +0 // Outputs[1] { @0560 revert(memory[0x00:0x00]); } // Block terminates label_0561: // Incoming jump from 0x055C, if !msg.value // Inputs[3] // { // @0569 msg.data.length // @0570 msg.data[0x04:0x24] // @0590 msg.data[0x24:0x44] // } 0561 5B JUMPDEST 0562 50 POP 0563 61 PUSH2 0x05a0 0566 60 PUSH1 0x04 0568 80 DUP1 0569 36 CALLDATASIZE 056A 03 SUB 056B 81 DUP2 056C 01 ADD 056D 90 SWAP1 056E 80 DUP1 056F 80 DUP1 0570 35 CALLDATALOAD 0571 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0586 16 AND 0587 90 SWAP1 0588 60 PUSH1 0x20 058A 01 ADD 058B 90 SWAP1 058C 92 SWAP3 058D 91 SWAP2 058E 90 SWAP1 058F 80 DUP1 0590 35 CALLDATALOAD 0591 90 SWAP1 0592 60 PUSH1 0x20 0594 01 ADD 0595 90 SWAP1 0596 92 SWAP3 0597 91 SWAP2 0598 90 SWAP1 0599 50 POP 059A 50 POP 059B 50 POP 059C 61 PUSH2 0x0ef2 059F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0563 stack[-1] = 0x05a0 // @058C stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @0596 stack[1] = msg.data[0x24:0x44] // } // Block ends with call to 0x0ef2, returns to 0x05A0 label_05A0: // Incoming return from call to 0x0EF2 at 0x059F // Inputs[4] // { // @05A3 memory[0x40:0x60] // @05A5 stack[-1] // @05B4 memory[0x40:0x60] // @05B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 05A0 5B JUMPDEST 05A1 60 PUSH1 0x40 05A3 51 MLOAD 05A4 80 DUP1 05A5 82 DUP3 05A6 15 ISZERO 05A7 15 ISZERO 05A8 15 ISZERO 05A9 15 ISZERO 05AA 81 DUP2 05AB 52 MSTORE 05AC 60 PUSH1 0x20 05AE 01 ADD 05AF 91 SWAP2 05B0 50 POP 05B1 50 POP 05B2 60 PUSH1 0x40 05B4 51 MLOAD 05B5 80 DUP1 05B6 91 SWAP2 05B7 03 SUB 05B8 90 SWAP1 05B9 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @05AB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @05B9 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_05BA: // Incoming jump from 0x00DA, if 0xca5d0880 == stack[-1] // Inputs[1] { @05BB msg.value } 05BA 5B JUMPDEST 05BB 34 CALLVALUE 05BC 80 DUP1 05BD 15 ISZERO 05BE 61 PUSH2 0x05c6 05C1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05BB stack[0] = msg.value } // Block ends with conditional jump to 0x05c6, if !msg.value label_05C2: // Incoming jump from 0x05C1, if not !msg.value // Inputs[1] { @05C5 memory[0x00:0x00] } 05C2 60 PUSH1 0x00 05C4 80 DUP1 05C5 FD *REVERT // Stack delta = +0 // Outputs[1] { @05C5 revert(memory[0x00:0x00]); } // Block terminates label_05C6: // Incoming jump from 0x05C1, if !msg.value 05C6 5B JUMPDEST 05C7 50 POP 05C8 61 PUSH2 0x05cf 05CB 61 PUSH2 0x0fb7 05CE 56 *JUMP // Stack delta = +0 // Outputs[1] { @05C8 stack[-1] = 0x05cf } // Block ends with call to 0x0fb7, returns to 0x05CF label_05CF: // Incoming return from call to 0x0FB7 at 0x05CE // Inputs[4] // { // @05D2 memory[0x40:0x60] // @05D4 stack[-1] // @05DF memory[0x40:0x60] // @05E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 05CF 5B JUMPDEST 05D0 60 PUSH1 0x40 05D2 51 MLOAD 05D3 80 DUP1 05D4 82 DUP3 05D5 81 DUP2 05D6 52 MSTORE 05D7 60 PUSH1 0x20 05D9 01 ADD 05DA 91 SWAP2 05DB 50 POP 05DC 50 POP 05DD 60 PUSH1 0x40 05DF 51 MLOAD 05E0 80 DUP1 05E1 91 SWAP2 05E2 03 SUB 05E3 90 SWAP1 05E4 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @05D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @05E4 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_05E5: // Incoming jump from 0x00E5, if 0xdd62ed3e == stack[-1] // Inputs[1] { @05E6 msg.value } 05E5 5B JUMPDEST 05E6 34 CALLVALUE 05E7 80 DUP1 05E8 15 ISZERO 05E9 61 PUSH2 0x05f1 05EC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05E6 stack[0] = msg.value } // Block ends with conditional jump to 0x05f1, if !msg.value label_05ED: // Incoming jump from 0x05EC, if not !msg.value // Inputs[1] { @05F0 memory[0x00:0x00] } 05ED 60 PUSH1 0x00 05EF 80 DUP1 05F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @05F0 revert(memory[0x00:0x00]); } // Block terminates label_05F1: // Incoming jump from 0x05EC, if !msg.value // Inputs[3] // { // @05F9 msg.data.length // @0600 msg.data[0x04:0x24] // @0620 msg.data[0x24:0x44] // } 05F1 5B JUMPDEST 05F2 50 POP 05F3 61 PUSH2 0x0646 05F6 60 PUSH1 0x04 05F8 80 DUP1 05F9 36 CALLDATASIZE 05FA 03 SUB 05FB 81 DUP2 05FC 01 ADD 05FD 90 SWAP1 05FE 80 DUP1 05FF 80 DUP1 0600 35 CALLDATALOAD 0601 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0616 16 AND 0617 90 SWAP1 0618 60 PUSH1 0x20 061A 01 ADD 061B 90 SWAP1 061C 92 SWAP3 061D 91 SWAP2 061E 90 SWAP1 061F 80 DUP1 0620 35 CALLDATALOAD 0621 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0636 16 AND 0637 90 SWAP1 0638 60 PUSH1 0x20 063A 01 ADD 063B 90 SWAP1 063C 92 SWAP3 063D 91 SWAP2 063E 90 SWAP1 063F 50 POP 0640 50 POP 0641 50 POP 0642 61 PUSH2 0x0fbd 0645 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @05F3 stack[-1] = 0x0646 // @061C stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // @063C stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x24:0x44] // } // Block ends with call to 0x0fbd, returns to 0x0646 label_0646: // Incoming return from call to 0x0FBD at 0x0645 // Inputs[4] // { // @0649 memory[0x40:0x60] // @064B stack[-1] // @0656 memory[0x40:0x60] // @065B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0646 5B JUMPDEST 0647 60 PUSH1 0x40 0649 51 MLOAD 064A 80 DUP1 064B 82 DUP3 064C 81 DUP2 064D 52 MSTORE 064E 60 PUSH1 0x20 0650 01 ADD 0651 91 SWAP2 0652 50 POP 0653 50 POP 0654 60 PUSH1 0x40 0656 51 MLOAD 0657 80 DUP1 0658 91 SWAP2 0659 03 SUB 065A 90 SWAP1 065B F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @064D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @065B return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_065C: // Incoming jump from 0x00F0, if 0xe86383b3 == stack[-1] // Inputs[2] // { // @0663 msg.data.length // @066A msg.data[0x04:0x24] // } 065C 5B JUMPDEST 065D 61 PUSH2 0x067a 0660 60 PUSH1 0x04 0662 80 DUP1 0663 36 CALLDATASIZE 0664 03 SUB 0665 81 DUP2 0666 01 ADD 0667 90 SWAP1 0668 80 DUP1 0669 80 DUP1 066A 35 CALLDATALOAD 066B 90 SWAP1 066C 60 PUSH1 0x20 066E 01 ADD 066F 90 SWAP1 0670 92 SWAP3 0671 91 SWAP2 0672 90 SWAP1 0673 50 POP 0674 50 POP 0675 50 POP 0676 61 PUSH2 0x1044 0679 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @065D stack[0] = 0x067a // @0670 stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x1044, returns to 0x067A label_067A: // Incoming return from call to 0x1044 at 0x0679 067A 5B JUMPDEST 067B 00 *STOP // Stack delta = +0 // Outputs[1] { @067B stop(); } // Block terminates label_067C: // Incoming jump from 0x00FB, if 0xf664de00 == stack[-1] // Inputs[1] { @067D msg.value } 067C 5B JUMPDEST 067D 34 CALLVALUE 067E 80 DUP1 067F 15 ISZERO 0680 61 PUSH2 0x0688 0683 57 *JUMPI // Stack delta = +1 // Outputs[1] { @067D stack[0] = msg.value } // Block ends with conditional jump to 0x0688, if !msg.value label_0684: // Incoming jump from 0x0683, if not !msg.value // Inputs[1] { @0687 memory[0x00:0x00] } 0684 60 PUSH1 0x00 0686 80 DUP1 0687 FD *REVERT // Stack delta = +0 // Outputs[1] { @0687 revert(memory[0x00:0x00]); } // Block terminates label_0688: // Incoming jump from 0x0683, if !msg.value // Inputs[2] // { // @0690 msg.data.length // @0697 msg.data[0x04:0x24] // } 0688 5B JUMPDEST 0689 50 POP 068A 61 PUSH2 0x06bd 068D 60 PUSH1 0x04 068F 80 DUP1 0690 36 CALLDATASIZE 0691 03 SUB 0692 81 DUP2 0693 01 ADD 0694 90 SWAP1 0695 80 DUP1 0696 80 DUP1 0697 35 CALLDATALOAD 0698 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06AD 16 AND 06AE 90 SWAP1 06AF 60 PUSH1 0x20 06B1 01 ADD 06B2 90 SWAP1 06B3 92 SWAP3 06B4 91 SWAP2 06B5 90 SWAP1 06B6 50 POP 06B7 50 POP 06B8 50 POP 06B9 61 PUSH2 0x1109 06BC 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @068A stack[-1] = 0x06bd // @06B3 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x04:0x24] // } // Block ends with call to 0x1109, returns to 0x06BD label_06BD: // Incoming return from call to 0x1109 at 0x06BC // Inputs[4] // { // @06C0 memory[0x40:0x60] // @06C2 stack[-1] // @06D1 memory[0x40:0x60] // @06D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 06BD 5B JUMPDEST 06BE 60 PUSH1 0x40 06C0 51 MLOAD 06C1 80 DUP1 06C2 82 DUP3 06C3 15 ISZERO 06C4 15 ISZERO 06C5 15 ISZERO 06C6 15 ISZERO 06C7 81 DUP2 06C8 52 MSTORE 06C9 60 PUSH1 0x20 06CB 01 ADD 06CC 91 SWAP2 06CD 50 POP 06CE 50 POP 06CF 60 PUSH1 0x40 06D1 51 MLOAD 06D2 80 DUP1 06D3 91 SWAP2 06D4 03 SUB 06D5 90 SWAP1 06D6 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @06C8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @06D6 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_06D7: // Incoming jump from 0x0106, if 0xfcae8c06 == stack[-1] // Inputs[1] { @06D8 msg.value } 06D7 5B JUMPDEST 06D8 34 CALLVALUE 06D9 80 DUP1 06DA 15 ISZERO 06DB 61 PUSH2 0x06e3 06DE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06D8 stack[0] = msg.value } // Block ends with conditional jump to 0x06e3, if !msg.value label_06DF: // Incoming jump from 0x06DE, if not !msg.value // Inputs[1] { @06E2 memory[0x00:0x00] } 06DF 60 PUSH1 0x00 06E1 80 DUP1 06E2 FD *REVERT // Stack delta = +0 // Outputs[1] { @06E2 revert(memory[0x00:0x00]); } // Block terminates label_06E3: // Incoming jump from 0x06DE, if !msg.value 06E3 5B JUMPDEST 06E4 50 POP 06E5 61 PUSH2 0x06ec 06E8 61 PUSH2 0x1129 06EB 56 *JUMP // Stack delta = +0 // Outputs[1] { @06E5 stack[-1] = 0x06ec } // Block ends with call to 0x1129, returns to 0x06EC label_06EC: // Incoming return from call to 0x1129 at 0x06EB // Inputs[4] // { // @06EF memory[0x40:0x60] // @06F1 stack[-1] // @0700 memory[0x40:0x60] // @0705 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 06EC 5B JUMPDEST 06ED 60 PUSH1 0x40 06EF 51 MLOAD 06F0 80 DUP1 06F1 82 DUP3 06F2 15 ISZERO 06F3 15 ISZERO 06F4 15 ISZERO 06F5 15 ISZERO 06F6 81 DUP2 06F7 52 MSTORE 06F8 60 PUSH1 0x20 06FA 01 ADD 06FB 91 SWAP2 06FC 50 POP 06FD 50 POP 06FE 60 PUSH1 0x40 0700 51 MLOAD 0701 80 DUP1 0702 91 SWAP2 0703 03 SUB 0704 90 SWAP1 0705 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @06F7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0705 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0706: // Incoming call from 0x014C, returns to 0x014D // Inputs[4] // { // @070C stack[-1] // @0714 memory[0x00:0x40] // @071B storage[keccak256(memory[0x00:0x40])] // @071C stack[-2] // } 0706 5B JUMPDEST 0707 60 PUSH1 0x09 0709 60 PUSH1 0x20 070B 52 MSTORE 070C 80 DUP1 070D 60 PUSH1 0x00 070F 52 MSTORE 0710 60 PUSH1 0x40 0712 60 PUSH1 0x00 0714 20 SHA3 0715 60 PUSH1 0x00 0717 91 SWAP2 0718 50 POP 0719 90 SWAP1 071A 50 POP 071B 54 SLOAD 071C 81 DUP2 071D 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @070B memory[0x20:0x40] = 0x09 // @070F memory[0x00:0x20] = stack[-1] // @071B stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_071E: // Incoming call from 0x0177, returns to 0x0178 // Inputs[2] // { // @0722 memory[0x40:0x60] // @0755 stack[-1] // } 071E 5B JUMPDEST 071F 60 PUSH1 0x40 0721 80 DUP1 0722 51 MLOAD 0723 90 SWAP1 0724 81 DUP2 0725 01 ADD 0726 60 PUSH1 0x40 0728 52 MSTORE 0729 80 DUP1 072A 60 PUSH1 0x04 072C 81 DUP2 072D 52 MSTORE 072E 60 PUSH1 0x20 0730 01 ADD 0731 7F PUSH32 0x436f696e00000000000000000000000000000000000000000000000000000000 0752 81 DUP2 0753 52 MSTORE 0754 50 POP 0755 81 DUP2 0756 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @0723 stack[0] = memory[0x40:0x60] // @0728 memory[0x40:0x60] = memory[0x40:0x60] + 0x40 // @072D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x04 // @0753 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x436f696e00000000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-1] label_0757: // Incoming call from 0x023D, returns to 0x023E // Inputs[10] // { // @075A stack[-1] // @075F msg.sender // @0799 memory[0x00:0x40] // @079C stack[-2] // @07D6 memory[0x00:0x40] // @07F2 msg.sender // @082D memory[0x40:0x60] // @083A memory[0x40:0x60] // @083F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0844 stack[-3] // } 0757 5B JUMPDEST 0758 60 PUSH1 0x00 075A 81 DUP2 075B 60 PUSH1 0x03 075D 60 PUSH1 0x00 075F 33 CALLER 0760 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0775 16 AND 0776 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 078B 16 AND 078C 81 DUP2 078D 52 MSTORE 078E 60 PUSH1 0x20 0790 01 ADD 0791 90 SWAP1 0792 81 DUP2 0793 52 MSTORE 0794 60 PUSH1 0x20 0796 01 ADD 0797 60 PUSH1 0x00 0799 20 SHA3 079A 60 PUSH1 0x00 079C 85 DUP6 079D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07B2 16 AND 07B3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07C8 16 AND 07C9 81 DUP2 07CA 52 MSTORE 07CB 60 PUSH1 0x20 07CD 01 ADD 07CE 90 SWAP1 07CF 81 DUP2 07D0 52 MSTORE 07D1 60 PUSH1 0x20 07D3 01 ADD 07D4 60 PUSH1 0x00 07D6 20 SHA3 07D7 81 DUP2 07D8 90 SWAP1 07D9 55 SSTORE 07DA 50 POP 07DB 82 DUP3 07DC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07F1 16 AND 07F2 33 CALLER 07F3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0808 16 AND 0809 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 082A 84 DUP5 082B 60 PUSH1 0x40 082D 51 MLOAD 082E 80 DUP1 082F 82 DUP3 0830 81 DUP2 0831 52 MSTORE 0832 60 PUSH1 0x20 0834 01 ADD 0835 91 SWAP2 0836 50 POP 0837 50 POP 0838 60 PUSH1 0x40 083A 51 MLOAD 083B 80 DUP1 083C 91 SWAP2 083D 03 SUB 083E 90 SWAP1 083F A3 LOG3 0840 60 PUSH1 0x01 0842 90 SWAP1 0843 50 POP 0844 92 SWAP3 0845 91 SWAP2 0846 50 POP 0847 50 POP 0848 56 *JUMP // Stack delta = -2 // Outputs[8] // { // @078D memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0793 memory[0x20:0x40] = 0x03 // @07CA memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @07D0 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @07D9 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0831 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @083F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // @0844 stack[-3] = 0x01 // } // Block ends with unconditional jump to stack[-3] label_0849: // Incoming call from 0x026C, returns to 0x026D // Inputs[2] // { // @084C storage[0x07] // @084D stack[-1] // } 0849 5B JUMPDEST 084A 60 PUSH1 0x07 084C 54 SLOAD 084D 81 DUP2 084E 56 *JUMP // Stack delta = +1 // Outputs[1] { @084C stack[0] = storage[0x07] } // Block ends with unconditional jump to stack[-1] label_084F: // Incoming call from 0x0297, returns to 0x0298 // Inputs[2] // { // @0854 storage[0x01] // @0857 stack[-1] // } 084F 5B JUMPDEST 0850 60 PUSH1 0x00 0852 60 PUSH1 0x01 0854 54 SLOAD 0855 90 SWAP1 0856 50 POP 0857 90 SWAP1 0858 56 *JUMP // Stack delta = +0 // Outputs[1] { @0857 stack[-1] = storage[0x01] } // Block ends with unconditional jump to stack[-1] label_0859: // Incoming call from 0x02C2, returns to 0x02C3 // Inputs[1] { @085C stack[-1] } 0859 5B JUMPDEST 085A 60 PUSH1 0x03 085C 81 DUP2 085D 56 *JUMP // Stack delta = +1 // Outputs[1] { @085A stack[0] = 0x03 } // Block ends with unconditional jump to stack[-1] label_085E: // Incoming call from 0x02ED, returns to 0x02EE // Inputs[6] // { // @0892 address(this) // @08A9 address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance // @08B1 memory[0x40:0x60] // @08B6 memory[0x40:0x60] // @08BE memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @08BE address(0xffffffffffffffffffffffffffffffffffffffff & 0x257d8e293df14da274f6f2cd4dc2aef0c5d96c00).call.gas(!address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance * 0x08fc).value(address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // } 085E 5B JUMPDEST 085F 60 PUSH1 0x00 0861 73 PUSH20 0x257d8e293df14da274f6f2cd4dc2aef0c5d96c00 0876 90 SWAP1 0877 50 POP 0878 80 DUP1 0879 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 088E 16 AND 088F 61 PUSH2 0x08fc 0892 30 ADDRESS 0893 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08A8 16 AND 08A9 31 BALANCE 08AA 90 SWAP1 08AB 81 DUP2 08AC 15 ISZERO 08AD 02 MUL 08AE 90 SWAP1 08AF 60 PUSH1 0x40 08B1 51 MLOAD 08B2 60 PUSH1 0x00 08B4 60 PUSH1 0x40 08B6 51 MLOAD 08B7 80 DUP1 08B8 83 DUP4 08B9 03 SUB 08BA 81 DUP2 08BB 85 DUP6 08BC 88 DUP9 08BD 88 DUP9 08BE F1 CALL 08BF 93 SWAP4 08C0 50 POP 08C1 50 POP 08C2 50 POP 08C3 50 POP 08C4 15 ISZERO 08C5 80 DUP1 08C6 15 ISZERO 08C7 61 PUSH2 0x08d4 08CA 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0876 stack[0] = 0x257d8e293df14da274f6f2cd4dc2aef0c5d96c00 // @08BE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0xffffffffffffffffffffffffffffffffffffffff & 0x257d8e293df14da274f6f2cd4dc2aef0c5d96c00).call.gas(!address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance * 0x08fc).value(address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @08C4 stack[1] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0x257d8e293df14da274f6f2cd4dc2aef0c5d96c00).call.gas(!address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance * 0x08fc).value(address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x08d4, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0x257d8e293df14da274f6f2cd4dc2aef0c5d96c00).call.gas(!address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance * 0x08fc).value(address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) label_08CB: // Incoming jump from 0x08CA, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0x257d8e293df14da274f6f2cd4dc2aef0c5d96c00).call.gas(!address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance * 0x08fc).value(address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[4] // { // @08CB returndata.length // @08CF returndata[0x00:0x00 + returndata.length] // @08D0 returndata.length // @08D3 memory[0x00:0x00 + returndata.length] // } 08CB 3D RETURNDATASIZE 08CC 60 PUSH1 0x00 08CE 80 DUP1 08CF 3E RETURNDATACOPY 08D0 3D RETURNDATASIZE 08D1 60 PUSH1 0x00 08D3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @08CF memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @08D3 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_08D4: // Incoming jump from 0x08CA, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0x257d8e293df14da274f6f2cd4dc2aef0c5d96c00).call.gas(!address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance * 0x08fc).value(address(0xffffffffffffffffffffffffffffffffffffffff & address(this)).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[1] { @08D7 stack[-3] } 08D4 5B JUMPDEST 08D5 50 POP 08D6 50 POP 08D7 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_08D8: // Incoming call from 0x0304, returns to 0x0305 // Inputs[2] // { // @08DE storage[0x04] // @0912 msg.sender // } 08D8 5B JUMPDEST 08D9 60 PUSH1 0x04 08DB 60 PUSH1 0x00 08DD 90 SWAP1 08DE 54 SLOAD 08DF 90 SWAP1 08E0 61 PUSH2 0x0100 08E3 0A EXP 08E4 90 SWAP1 08E5 04 DIV 08E6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08FB 16 AND 08FC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0911 16 AND 0912 33 CALLER 0913 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0928 16 AND 0929 14 EQ 092A 15 ISZERO 092B 15 ISZERO 092C 61 PUSH2 0x0934 092F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0934, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x04] / 0x0100 ** 0x00) label_0930: // Incoming jump from 0x092F, if not !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x04] / 0x0100 ** 0x00) // Inputs[1] { @0933 memory[0x00:0x00] } 0930 60 PUSH1 0x00 0932 80 DUP1 0933 FD *REVERT // Stack delta = +0 // Outputs[1] { @0933 revert(memory[0x00:0x00]); } // Block terminates label_0934: // Incoming jump from 0x092F, if !!(0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x04] / 0x0100 ** 0x00) // Inputs[3] // { // @093D msg.sender // @0977 memory[0x00:0x40] // @097B storage[keccak256(memory[0x00:0x40])] // } 0934 5B JUMPDEST 0935 60 PUSH1 0x01 0937 15 ISZERO 0938 15 ISZERO 0939 60 PUSH1 0x0a 093B 60 PUSH1 0x00 093D 33 CALLER 093E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0953 16 AND 0954 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0969 16 AND 096A 81 DUP2 096B 52 MSTORE 096C 60 PUSH1 0x20 096E 01 ADD 096F 90 SWAP1 0970 81 DUP2 0971 52 MSTORE 0972 60 PUSH1 0x20 0974 01 ADD 0975 60 PUSH1 0x00 0977 20 SHA3 0978 60 PUSH1 0x00 097A 90 SWAP1 097B 54 SLOAD 097C 90 SWAP1 097D 61 PUSH2 0x0100 0980 0A EXP 0981 90 SWAP1 0982 04 DIV 0983 60 PUSH1 0xff 0985 16 AND 0986 15 ISZERO 0987 15 ISZERO 0988 14 EQ 0989 15 ISZERO 098A 15 ISZERO 098B 61 PUSH2 0x0993 098E 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @096B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0971 memory[0x20:0x40] = 0x0a // } // Block ends with conditional jump to 0x0993, if !!(!!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) == !!0x01) label_098F: // Incoming jump from 0x098E, if not !!(!!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) == !!0x01) // Inputs[1] { @0992 memory[0x00:0x00] } 098F 60 PUSH1 0x00 0991 80 DUP1 0992 FD *REVERT // Stack delta = +0 // Outputs[1] { @0992 revert(memory[0x00:0x00]); } // Block terminates label_0993: // Incoming jump from 0x098E, if !!(!!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) == !!0x01) // Inputs[3] // { // @0999 msg.sender // @09D3 memory[0x00:0x40] // @09D6 stack[-1] // } 0993 5B JUMPDEST 0994 60 PUSH1 0x00 0996 80 DUP1 0997 60 PUSH1 0x00 0999 33 CALLER 099A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09AF 16 AND 09B0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09C5 16 AND 09C6 81 DUP2 09C7 52 MSTORE 09C8 60 PUSH1 0x20 09CA 01 ADD 09CB 90 SWAP1 09CC 81 DUP2 09CD 52 MSTORE 09CE 60 PUSH1 0x20 09D0 01 ADD 09D1 60 PUSH1 0x00 09D3 20 SHA3 09D4 50 POP 09D5 50 POP 09D6 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @09C7 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @09CD memory[0x20:0x40] = 0x00 // } // Block ends with unconditional jump to stack[-1] label_09D7: // Incoming call from 0x037B, returns to 0x037C // Inputs[6] // { // @09DE stack[-4] // @0A18 memory[0x00:0x40] // @0A1B msg.sender // @0A55 memory[0x00:0x40] // @0A56 storage[keccak256(memory[0x00:0x40])] // @0A57 stack[-2] // } 09D7 5B JUMPDEST 09D8 60 PUSH1 0x00 09DA 60 PUSH1 0x03 09DC 60 PUSH1 0x00 09DE 86 DUP7 09DF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09F4 16 AND 09F5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A0A 16 AND 0A0B 81 DUP2 0A0C 52 MSTORE 0A0D 60 PUSH1 0x20 0A0F 01 ADD 0A10 90 SWAP1 0A11 81 DUP2 0A12 52 MSTORE 0A13 60 PUSH1 0x20 0A15 01 ADD 0A16 60 PUSH1 0x00 0A18 20 SHA3 0A19 60 PUSH1 0x00 0A1B 33 CALLER 0A1C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A31 16 AND 0A32 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A47 16 AND 0A48 81 DUP2 0A49 52 MSTORE 0A4A 60 PUSH1 0x20 0A4C 01 ADD 0A4D 90 SWAP1 0A4E 81 DUP2 0A4F 52 MSTORE 0A50 60 PUSH1 0x20 0A52 01 ADD 0A53 60 PUSH1 0x00 0A55 20 SHA3 0A56 54 SLOAD 0A57 83 DUP4 0A58 11 GT 0A59 15 ISZERO 0A5A 15 ISZERO 0A5B 15 ISZERO 0A5C 61 PUSH2 0x0a64 0A5F 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @09D8 stack[0] = 0x00 // @0A0C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0A12 memory[0x20:0x40] = 0x03 // @0A49 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0A4F memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x0a64, if !!!(stack[-2] > storage[keccak256(memory[0x00:0x40])]) label_0A60: // Incoming jump from 0x0A5F, if not !!!(stack[-2] > storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @0A63 memory[0x00:0x00] } 0A60 60 PUSH1 0x00 0A62 80 DUP1 0A63 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A63 revert(memory[0x00:0x00]); } // Block terminates label_0A64: // Incoming jump from 0x0A5F, if !!!(stack[-2] > storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @0A65 stack[-2] // @0A66 msg.sender // @0A7F storage[0x02] // } 0A64 5B JUMPDEST 0A65 81 DUP2 0A66 33 CALLER 0A67 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A7C 16 AND 0A7D 60 PUSH1 0x02 0A7F 54 SLOAD 0A80 01 ADD 0A81 14 EQ 0A82 15 ISZERO 0A83 15 ISZERO 0A84 61 PUSH2 0x0a8c 0A87 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a8c, if !!(storage[0x02] + (0xffffffffffffffffffffffffffffffffffffffff & msg.sender) == stack[-2]) label_0A88: // Incoming jump from 0x0A87, if not !!(storage[0x02] + (0xffffffffffffffffffffffffffffffffffffffff & msg.sender) == stack[-2]) // Inputs[1] { @0A8B memory[0x00:0x00] } 0A88 60 PUSH1 0x00 0A8A 80 DUP1 0A8B FD *REVERT // Stack delta = +0 // Outputs[1] { @0A8B revert(memory[0x00:0x00]); } // Block terminates label_0A8C: // Incoming jump from 0x0A87, if !!(storage[0x02] + (0xffffffffffffffffffffffffffffffffffffffff & msg.sender) == stack[-2]) // Inputs[18] // { // @0A8D stack[-3] // @0A91 stack[-5] // @0ACB memory[0x00:0x40] // @0ACC storage[keccak256(memory[0x00:0x40])] // @0B0B memory[0x00:0x40] // @0B14 stack[-4] // @0B4E memory[0x00:0x40] // @0B4F storage[keccak256(memory[0x00:0x40])] // @0B8E memory[0x00:0x40] // @0BD2 memory[0x00:0x40] // @0BD5 msg.sender // @0C0F memory[0x00:0x40] // @0C10 storage[keccak256(memory[0x00:0x40])] // @0C50 memory[0x00:0x40] // @0C53 msg.sender // @0C8D memory[0x00:0x40] // @0C94 stack[-1] // @0C96 stack[-6] // } 0A8C 5B JUMPDEST 0A8D 82 DUP3 0A8E 60 PUSH1 0x00 0A90 80 DUP1 0A91 87 DUP8 0A92 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AA7 16 AND 0AA8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0ABD 16 AND 0ABE 81 DUP2 0ABF 52 MSTORE 0AC0 60 PUSH1 0x20 0AC2 01 ADD 0AC3 90 SWAP1 0AC4 81 DUP2 0AC5 52 MSTORE 0AC6 60 PUSH1 0x20 0AC8 01 ADD 0AC9 60 PUSH1 0x00 0ACB 20 SHA3 0ACC 54 SLOAD 0ACD 03 SUB 0ACE 60 PUSH1 0x00 0AD0 80 DUP1 0AD1 87 DUP8 0AD2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AE7 16 AND 0AE8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AFD 16 AND 0AFE 81 DUP2 0AFF 52 MSTORE 0B00 60 PUSH1 0x20 0B02 01 ADD 0B03 90 SWAP1 0B04 81 DUP2 0B05 52 MSTORE 0B06 60 PUSH1 0x20 0B08 01 ADD 0B09 60 PUSH1 0x00 0B0B 20 SHA3 0B0C 81 DUP2 0B0D 90 SWAP1 0B0E 55 SSTORE 0B0F 50 POP 0B10 82 DUP3 0B11 60 PUSH1 0x00 0B13 80 DUP1 0B14 86 DUP7 0B15 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B2A 16 AND 0B2B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B40 16 AND 0B41 81 DUP2 0B42 52 MSTORE 0B43 60 PUSH1 0x20 0B45 01 ADD 0B46 90 SWAP1 0B47 81 DUP2 0B48 52 MSTORE 0B49 60 PUSH1 0x20 0B4B 01 ADD 0B4C 60 PUSH1 0x00 0B4E 20 SHA3 0B4F 54 SLOAD 0B50 01 ADD 0B51 60 PUSH1 0x00 0B53 80 DUP1 0B54 86 DUP7 0B55 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B6A 16 AND 0B6B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B80 16 AND 0B81 81 DUP2 0B82 52 MSTORE 0B83 60 PUSH1 0x20 0B85 01 ADD 0B86 90 SWAP1 0B87 81 DUP2 0B88 52 MSTORE 0B89 60 PUSH1 0x20 0B8B 01 ADD 0B8C 60 PUSH1 0x00 0B8E 20 SHA3 0B8F 81 DUP2 0B90 90 SWAP1 0B91 55 SSTORE 0B92 50 POP 0B93 82 DUP3 0B94 60 PUSH1 0x03 0B96 60 PUSH1 0x00 0B98 87 DUP8 0B99 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BAE 16 AND 0BAF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BC4 16 AND 0BC5 81 DUP2 0BC6 52 MSTORE 0BC7 60 PUSH1 0x20 0BC9 01 ADD 0BCA 90 SWAP1 0BCB 81 DUP2 0BCC 52 MSTORE 0BCD 60 PUSH1 0x20 0BCF 01 ADD 0BD0 60 PUSH1 0x00 0BD2 20 SHA3 0BD3 60 PUSH1 0x00 0BD5 33 CALLER 0BD6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BEB 16 AND 0BEC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C01 16 AND 0C02 81 DUP2 0C03 52 MSTORE 0C04 60 PUSH1 0x20 0C06 01 ADD 0C07 90 SWAP1 0C08 81 DUP2 0C09 52 MSTORE 0C0A 60 PUSH1 0x20 0C0C 01 ADD 0C0D 60 PUSH1 0x00 0C0F 20 SHA3 0C10 54 SLOAD 0C11 03 SUB 0C12 60 PUSH1 0x03 0C14 60 PUSH1 0x00 0C16 87 DUP8 0C17 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C2C 16 AND 0C2D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C42 16 AND 0C43 81 DUP2 0C44 52 MSTORE 0C45 60 PUSH1 0x20 0C47 01 ADD 0C48 90 SWAP1 0C49 81 DUP2 0C4A 52 MSTORE 0C4B 60 PUSH1 0x20 0C4D 01 ADD 0C4E 60 PUSH1 0x00 0C50 20 SHA3 0C51 60 PUSH1 0x00 0C53 33 CALLER 0C54 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C69 16 AND 0C6A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C7F 16 AND 0C80 81 DUP2 0C81 52 MSTORE 0C82 60 PUSH1 0x20 0C84 01 ADD 0C85 90 SWAP1 0C86 81 DUP2 0C87 52 MSTORE 0C88 60 PUSH1 0x20 0C8A 01 ADD 0C8B 60 PUSH1 0x00 0C8D 20 SHA3 0C8E 81 DUP2 0C8F 90 SWAP1 0C90 55 SSTORE 0C91 50 POP 0C92 60 PUSH1 0x01 0C94 90 SWAP1 0C95 50 POP 0C96 94 SWAP5 0C97 93 SWAP4 0C98 50 POP 0C99 50 POP 0C9A 50 POP 0C9B 50 POP 0C9C 56 *JUMP // Stack delta = -5 // Outputs[20] // { // @0ABF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0AC5 memory[0x20:0x40] = 0x00 // @0AFF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0B05 memory[0x20:0x40] = 0x00 // @0B0E storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] - stack[-3] // @0B42 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0B48 memory[0x20:0x40] = 0x00 // @0B82 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0B88 memory[0x20:0x40] = 0x00 // @0B91 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + stack[-3] // @0BC6 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0BCC memory[0x20:0x40] = 0x03 // @0C03 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0C09 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0C44 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0C4A memory[0x20:0x40] = 0x03 // @0C81 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0C87 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0C90 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] - stack[-3] // @0C96 stack[-6] = 0x01 // } // Block ends with unconditional jump to stack[-6] label_0C9D: // Incoming call from 0x03D6, returns to 0x03D7 // Inputs[4] // { // @0CA3 stack[-1] // @0CDD memory[0x00:0x40] // @0CDE storage[keccak256(memory[0x00:0x40])] // @0CE1 stack[-2] // } 0C9D 5B JUMPDEST 0C9E 60 PUSH1 0x00 0CA0 80 DUP1 0CA1 60 PUSH1 0x00 0CA3 83 DUP4 0CA4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CB9 16 AND 0CBA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CCF 16 AND 0CD0 81 DUP2 0CD1 52 MSTORE 0CD2 60 PUSH1 0x20 0CD4 01 ADD 0CD5 90 SWAP1 0CD6 81 DUP2 0CD7 52 MSTORE 0CD8 60 PUSH1 0x20 0CDA 01 ADD 0CDB 60 PUSH1 0x00 0CDD 20 SHA3 0CDE 54 SLOAD 0CDF 90 SWAP1 0CE0 50 POP 0CE1 91 SWAP2 0CE2 90 SWAP1 0CE3 50 POP 0CE4 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0CD1 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0CD7 memory[0x20:0x40] = 0x00 // @0CE1 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0CE5: // Incoming call from 0x0401, returns to 0x0402 // Inputs[2] // { // @0CEB storage[0x0b] // @0D09 stack[-1] // } 0CE5 5B JUMPDEST 0CE6 60 PUSH1 0x0b 0CE8 60 PUSH1 0x00 0CEA 90 SWAP1 0CEB 54 SLOAD 0CEC 90 SWAP1 0CED 61 PUSH2 0x0100 0CF0 0A EXP 0CF1 90 SWAP1 0CF2 04 DIV 0CF3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D08 16 AND 0D09 81 DUP2 0D0A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D08 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0D0B: // Incoming call from 0x04AA, returns to 0x04AB // Inputs[3] // { // @0D16 msg.sender // @0D50 memory[0x00:0x40] // @0D54 storage[keccak256(memory[0x00:0x40])] // } 0D0B 5B JUMPDEST 0D0C 60 PUSH1 0x00 0D0E 60 PUSH1 0x01 0D10 15 ISZERO 0D11 15 ISZERO 0D12 60 PUSH1 0x0a 0D14 60 PUSH1 0x00 0D16 33 CALLER 0D17 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D2C 16 AND 0D2D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D42 16 AND 0D43 81 DUP2 0D44 52 MSTORE 0D45 60 PUSH1 0x20 0D47 01 ADD 0D48 90 SWAP1 0D49 81 DUP2 0D4A 52 MSTORE 0D4B 60 PUSH1 0x20 0D4D 01 ADD 0D4E 60 PUSH1 0x00 0D50 20 SHA3 0D51 60 PUSH1 0x00 0D53 90 SWAP1 0D54 54 SLOAD 0D55 90 SWAP1 0D56 61 PUSH2 0x0100 0D59 0A EXP 0D5A 90 SWAP1 0D5B 04 DIV 0D5C 60 PUSH1 0xff 0D5E 16 AND 0D5F 15 ISZERO 0D60 15 ISZERO 0D61 14 EQ 0D62 15 ISZERO 0D63 15 ISZERO 0D64 61 PUSH2 0x0d6c 0D67 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0D0C stack[0] = 0x00 // @0D44 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0D4A memory[0x20:0x40] = 0x0a // } // Block ends with conditional jump to 0x0d6c, if !!(!!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) == !!0x01) label_0D68: // Incoming jump from 0x0D67, if not !!(!!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) == !!0x01) // Inputs[1] { @0D6B memory[0x00:0x00] } 0D68 60 PUSH1 0x00 0D6A 80 DUP1 0D6B FD *REVERT // Stack delta = +0 // Outputs[1] { @0D6B revert(memory[0x00:0x00]); } // Block terminates label_0D6C: // Incoming jump from 0x0D67, if !!(!!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) == !!0x01) // Inputs[3] // { // @0D72 msg.sender // @0DAC memory[0x00:0x40] // @0DAD storage[keccak256(memory[0x00:0x40])] // } 0D6C 5B JUMPDEST 0D6D 60 PUSH1 0x00 0D6F 80 DUP1 0D70 60 PUSH1 0x00 0D72 33 CALLER 0D73 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D88 16 AND 0D89 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D9E 16 AND 0D9F 81 DUP2 0DA0 52 MSTORE 0DA1 60 PUSH1 0x20 0DA3 01 ADD 0DA4 90 SWAP1 0DA5 81 DUP2 0DA6 52 MSTORE 0DA7 60 PUSH1 0x20 0DA9 01 ADD 0DAA 60 PUSH1 0x00 0DAC 20 SHA3 0DAD 54 SLOAD 0DAE 14 EQ 0DAF 15 ISZERO 0DB0 15 ISZERO 0DB1 61 PUSH2 0x0db9 0DB4 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0DA0 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0DA6 memory[0x20:0x40] = 0x00 // } // Block ends with conditional jump to 0x0db9, if !!(storage[keccak256(memory[0x00:0x40])] == 0x00) label_0DB5: // Incoming jump from 0x0DB4, if not !!(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[1] { @0DB8 memory[0x00:0x00] } 0DB5 60 PUSH1 0x00 0DB7 80 DUP1 0DB8 FD *REVERT // Stack delta = +0 // Outputs[1] { @0DB8 revert(memory[0x00:0x00]); } // Block terminates label_0DB9: // Incoming jump from 0x0DB4, if !!(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[4] // { // @0DDB stack[-2] // @0DDE memory[0x40:0x60] // @0DF0 memory[stack[-2]:stack[-2] + 0x20] // @0DF9 memory[stack[-2]:stack[-2] + 0x20] // } 0DB9 5B JUMPDEST 0DBA 7F PUSH32 0x97803934afce44f37ca48365ffc7eb16fa035591056c7715c6747b0158d89f00 0DDB 82 DUP3 0DDC 60 PUSH1 0x40 0DDE 51 MLOAD 0DDF 80 DUP1 0DE0 80 DUP1 0DE1 60 PUSH1 0x20 0DE3 01 ADD 0DE4 80 DUP1 0DE5 60 PUSH1 0x20 0DE7 01 ADD 0DE8 83 DUP4 0DE9 81 DUP2 0DEA 03 SUB 0DEB 83 DUP4 0DEC 52 MSTORE 0DED 84 DUP5 0DEE 81 DUP2 0DEF 81 DUP2 0DF0 51 MLOAD 0DF1 81 DUP2 0DF2 52 MSTORE 0DF3 60 PUSH1 0x20 0DF5 01 ADD 0DF6 91 SWAP2 0DF7 50 POP 0DF8 80 DUP1 0DF9 51 MLOAD 0DFA 90 SWAP1 0DFB 60 PUSH1 0x20 0DFD 01 ADD 0DFE 90 SWAP1 0DFF 80 DUP1 0E00 83 DUP4 0E01 83 DUP4 0E02 60 PUSH1 0x00 0E04 5B JUMPDEST 0E05 83 DUP4 0E06 81 DUP2 0E07 10 LT 0E08 15 ISZERO 0E09 61 PUSH2 0x0e1f 0E0C 57 *JUMPI // Stack delta = +12 // Outputs[14] // { // @0DBA stack[0] = 0x97803934afce44f37ca48365ffc7eb16fa035591056c7715c6747b0158d89f00 // @0DDB stack[1] = stack[-2] // @0DDE stack[2] = memory[0x40:0x60] // @0DDF stack[3] = memory[0x40:0x60] // @0DE3 stack[4] = 0x20 + memory[0x40:0x60] // @0DEC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0DF2 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @0DF6 stack[5] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @0DFE stack[7] = memory[stack[-2]:stack[-2] + 0x20] // @0DFE stack[6] = 0x20 + stack[-2] // @0DFF stack[8] = memory[stack[-2]:stack[-2] + 0x20] // @0E00 stack[9] = 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @0E01 stack[10] = 0x20 + stack[-2] // @0E02 stack[11] = 0x00 // } // Block ends with conditional jump to 0x0e1f, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_0E0D: // Incoming jump from 0x0E0C, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x0E0C, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0E0D stack[-1] // @0E0E stack[-2] // @0E10 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0E12 stack[-3] // } 0E0D 80 DUP1 0E0E 82 DUP3 0E0F 01 ADD 0E10 51 MLOAD 0E11 81 DUP2 0E12 84 DUP5 0E13 01 ADD 0E14 52 MSTORE 0E15 60 PUSH1 0x20 0E17 81 DUP2 0E18 01 ADD 0E19 90 SWAP1 0E1A 50 POP 0E1B 61 PUSH2 0x0e04 0E1E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0E14 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0E19 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0e04 label_0E1F: // Incoming jump from 0x0E0C, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x0E0C, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0E24 stack[-5] // @0E24 stack[-6] // @0E26 stack[-7] // } 0E1F 5B JUMPDEST 0E20 50 POP 0E21 50 POP 0E22 50 POP 0E23 50 POP 0E24 90 SWAP1 0E25 50 POP 0E26 90 SWAP1 0E27 81 DUP2 0E28 01 ADD 0E29 90 SWAP1 0E2A 60 PUSH1 0x1f 0E2C 16 AND 0E2D 80 DUP1 0E2E 15 ISZERO 0E2F 61 PUSH2 0x0e4c 0E32 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0E29 stack[-7] = stack[-5] + stack[-7] // @0E2C stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0e4c, if !(0x1f & stack[-5]) label_0E33: // Incoming jump from 0x0E32, if not !(0x1f & stack[-5]) // Inputs[12] // { // @0E33 stack[-1] // @0E34 stack[-2] // @0E37 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0E4E stack[-5] // @0E51 stack[-3] // @0EA8 stack[-6] // @0EAF memory[0x40:0x60] // @0EB4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // @0EB4 stack[-7] // @0EB5 stack[-10] // @0EB5 stack[-8] // @0EB6 stack[-9] // } 0E33 80 DUP1 0E34 82 DUP3 0E35 03 SUB 0E36 80 DUP1 0E37 51 MLOAD 0E38 60 PUSH1 0x01 0E3A 83 DUP4 0E3B 60 PUSH1 0x20 0E3D 03 SUB 0E3E 61 PUSH2 0x0100 0E41 0A EXP 0E42 03 SUB 0E43 19 NOT 0E44 16 AND 0E45 81 DUP2 0E46 52 MSTORE 0E47 60 PUSH1 0x20 0E49 01 ADD 0E4A 91 SWAP2 0E4B 50 POP 0E4C 5B JUMPDEST 0E4D 50 POP 0E4E 83 DUP4 0E4F 81 DUP2 0E50 03 SUB 0E51 82 DUP3 0E52 52 MSTORE 0E53 60 PUSH1 0x24 0E55 81 DUP2 0E56 52 MSTORE 0E57 60 PUSH1 0x20 0E59 01 ADD 0E5A 80 DUP1 0E5B 7F PUSH32 0x436f6e67726174756c6174696f6e7320746f2063617074757265207468652066 0E7C 81 DUP2 0E7D 52 MSTORE 0E7E 60 PUSH1 0x20 0E80 01 ADD 0E81 7F PUSH32 0x6c61672100000000000000000000000000000000000000000000000000000000 0EA2 81 DUP2 0EA3 52 MSTORE 0EA4 50 POP 0EA5 60 PUSH1 0x40 0EA7 01 ADD 0EA8 93 SWAP4 0EA9 50 POP 0EAA 50 POP 0EAB 50 POP 0EAC 50 POP 0EAD 60 PUSH1 0x40 0EAF 51 MLOAD 0EB0 80 DUP1 0EB1 91 SWAP2 0EB2 03 SUB 0EB3 90 SWAP1 0EB4 A1 LOG1 0EB5 91 SWAP2 0EB6 90 SWAP1 0EB7 50 POP 0EB8 56 *JUMP // Stack delta = -9 // Outputs[7] // { // @0E46 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0E52 memory[stack[-3]:stack[-3] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - stack[-5] // @0E56 memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = 0x24 // @0E7D memory[0x20 + 0x20 + (stack[-2] - stack[-1]):0x20 + 0x20 + (stack[-2] - stack[-1]) + 0x20] = 0x436f6e67726174756c6174696f6e7320746f2063617074757265207468652066 // @0EA3 memory[0x20 + 0x20 + 0x20 + (stack[-2] - stack[-1]):0x20 + 0x20 + 0x20 + (stack[-2] - stack[-1]) + 0x20] = 0x6c61672100000000000000000000000000000000000000000000000000000000 // @0EB4 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]], [stack[-7]]); // @0EB5 stack[-10] = stack[-8] // } // Block ends with unconditional jump to stack[-10] label_0EB9: // Incoming call from 0x04D9, returns to 0x04DA // Inputs[2] // { // @0EBD memory[0x40:0x60] // @0EF0 stack[-1] // } 0EB9 5B JUMPDEST 0EBA 60 PUSH1 0x40 0EBC 80 DUP1 0EBD 51 MLOAD 0EBE 90 SWAP1 0EBF 81 DUP2 0EC0 01 ADD 0EC1 60 PUSH1 0x40 0EC3 52 MSTORE 0EC4 80 DUP1 0EC5 60 PUSH1 0x03 0EC7 81 DUP2 0EC8 52 MSTORE 0EC9 60 PUSH1 0x20 0ECB 01 ADD 0ECC 7F PUSH32 0x3078300000000000000000000000000000000000000000000000000000000000 0EED 81 DUP2 0EEE 52 MSTORE 0EEF 50 POP 0EF0 81 DUP2 0EF1 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @0EBE stack[0] = memory[0x40:0x60] // @0EC3 memory[0x40:0x60] = memory[0x40:0x60] + 0x40 // @0EC8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x03 // @0EEE memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x3078300000000000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-1] label_0EF2: // Incoming call from 0x059F, returns to 0x05A0 // Inputs[4] // { // @0EF9 msg.sender // @0F33 memory[0x00:0x40] // @0F34 storage[keccak256(memory[0x00:0x40])] // @0F35 block.timestamp // } 0EF2 5B JUMPDEST 0EF3 60 PUSH1 0x00 0EF5 60 PUSH1 0x09 0EF7 60 PUSH1 0x00 0EF9 33 CALLER 0EFA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F0F 16 AND 0F10 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F25 16 AND 0F26 81 DUP2 0F27 52 MSTORE 0F28 60 PUSH1 0x20 0F2A 01 ADD 0F2B 90 SWAP1 0F2C 81 DUP2 0F2D 52 MSTORE 0F2E 60 PUSH1 0x20 0F30 01 ADD 0F31 60 PUSH1 0x00 0F33 20 SHA3 0F34 54 SLOAD 0F35 42 TIMESTAMP 0F36 11 GT 0F37 15 ISZERO 0F38 15 ISZERO 0F39 61 PUSH2 0x0f41 0F3C 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0EF3 stack[0] = 0x00 // @0F27 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0F2D memory[0x20:0x40] = 0x09 // } // Block ends with conditional jump to 0x0f41, if !!(block.timestamp > storage[keccak256(memory[0x00:0x40])]) label_0F3D: // Incoming jump from 0x0F3C, if not !!(block.timestamp > storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @0F40 memory[0x00:0x00] } 0F3D 60 PUSH1 0x00 0F3F 80 DUP1 0F40 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F40 revert(memory[0x00:0x00]); } // Block terminates label_0F41: // Incoming jump from 0x0F3C, if !!(block.timestamp > storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @0F45 stack[-3] // @0F46 stack[-2] // } 0F41 5B JUMPDEST 0F42 61 PUSH2 0x0f4b 0F45 83 DUP4 0F46 83 DUP4 0F47 61 PUSH2 0x12c5 0F4A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F42 stack[0] = 0x0f4b // @0F45 stack[1] = stack[-3] // @0F46 stack[2] = stack[-2] // } // Block ends with call to 0x12c5, returns to 0x0F4B label_0F4B: // Incoming return from call to 0x12C5 at 0x0F4A // Inputs[8] // { // @0F4D stack[-4] // @0F64 msg.sender // @0F9C stack[-3] // @0F9F memory[0x40:0x60] // @0FAC memory[0x40:0x60] // @0FB1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0FB2 stack[-2] // @0FB2 stack[-5] // } 0F4B 5B JUMPDEST 0F4C 50 POP 0F4D 82 DUP3 0F4E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F63 16 AND 0F64 33 CALLER 0F65 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F7A 16 AND 0F7B 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0F9C 84 DUP5 0F9D 60 PUSH1 0x40 0F9F 51 MLOAD 0FA0 80 DUP1 0FA1 82 DUP3 0FA2 81 DUP2 0FA3 52 MSTORE 0FA4 60 PUSH1 0x20 0FA6 01 ADD 0FA7 91 SWAP2 0FA8 50 POP 0FA9 50 POP 0FAA 60 PUSH1 0x40 0FAC 51 MLOAD 0FAD 80 DUP1 0FAE 91 SWAP2 0FAF 03 SUB 0FB0 90 SWAP1 0FB1 A3 LOG3 0FB2 92 SWAP3 0FB3 91 SWAP2 0FB4 50 POP 0FB5 50 POP 0FB6 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @0FA3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @0FB1 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, msg.sender, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff]); // @0FB2 stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_0FB7: // Incoming call from 0x05CE, returns to 0x05CF // Inputs[2] // { // @0FBA storage[0x08] // @0FBB stack[-1] // } 0FB7 5B JUMPDEST 0FB8 60 PUSH1 0x08 0FBA 54 SLOAD 0FBB 81 DUP2 0FBC 56 *JUMP // Stack delta = +1 // Outputs[1] { @0FBA stack[0] = storage[0x08] } // Block ends with unconditional jump to stack[-1] label_0FBD: // Incoming call from 0x0645, returns to 0x0646 // Inputs[6] // { // @0FC4 stack[-2] // @0FFE memory[0x00:0x40] // @1001 stack[-1] // @103B memory[0x00:0x40] // @103C storage[keccak256(memory[0x00:0x40])] // @103F stack[-3] // } 0FBD 5B JUMPDEST 0FBE 60 PUSH1 0x00 0FC0 60 PUSH1 0x03 0FC2 60 PUSH1 0x00 0FC4 84 DUP5 0FC5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FDA 16 AND 0FDB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FF0 16 AND 0FF1 81 DUP2 0FF2 52 MSTORE 0FF3 60 PUSH1 0x20 0FF5 01 ADD 0FF6 90 SWAP1 0FF7 81 DUP2 0FF8 52 MSTORE 0FF9 60 PUSH1 0x20 0FFB 01 ADD 0FFC 60 PUSH1 0x00 0FFE 20 SHA3 0FFF 60 PUSH1 0x00 1001 83 DUP4 1002 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1017 16 AND 1018 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 102D 16 AND 102E 81 DUP2 102F 52 MSTORE 1030 60 PUSH1 0x20 1032 01 ADD 1033 90 SWAP1 1034 81 DUP2 1035 52 MSTORE 1036 60 PUSH1 0x20 1038 01 ADD 1039 60 PUSH1 0x00 103B 20 SHA3 103C 54 SLOAD 103D 90 SWAP1 103E 50 POP 103F 92 SWAP3 1040 91 SWAP2 1041 50 POP 1042 50 POP 1043 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0FF2 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0FF8 memory[0x20:0x40] = 0x03 // @102F memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1035 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @103F stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_1044: // Incoming call from 0x0679, returns to 0x067A // Inputs[2] // { // @1047 storage[0x05] // @1048 stack[-1] // } 1044 5B JUMPDEST 1045 60 PUSH1 0x05 1047 54 SLOAD 1048 81 DUP2 1049 14 EQ 104A 80 DUP1 104B 15 ISZERO 104C 61 PUSH2 0x1057 104F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1049 stack[0] = stack[-1] == storage[0x05] } // Block ends with conditional jump to 0x1057, if !(stack[-1] == storage[0x05]) label_1050: // Incoming jump from 0x104F, if not !(stack[-1] == storage[0x05]) // Inputs[2] // { // @1053 storage[0x06] // @1054 msg.value // } 1050 50 POP 1051 60 PUSH1 0x06 1053 54 SLOAD 1054 34 CALLVALUE 1055 10 LT 1056 15 ISZERO 1057 5B JUMPDEST 1058 15 ISZERO 1059 15 ISZERO 105A 61 PUSH2 0x1062 105D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1062, if !!!(msg.value < storage[0x06]) label_105E: // Incoming jump from 0x105D, if not !!stack[-1] // Incoming jump from 0x105D, if not !!!(msg.value < storage[0x06]) // Inputs[1] { @1061 memory[0x00:0x00] } 105E 60 PUSH1 0x00 1060 80 DUP1 1061 FD *REVERT // Stack delta = +0 // Outputs[1] { @1061 revert(memory[0x00:0x00]); } // Block terminates label_1062: // Incoming jump from 0x105D, if !!stack[-1] // Incoming jump from 0x105D, if !!!(msg.value < storage[0x06]) // Inputs[7] // { // @1063 msg.sender // @106D storage[0x0b] // @10C5 msg.sender // @10C8 memory[0x40:0x60] // @1101 memory[0x40:0x60] // @1106 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1108 stack[-2] // } 1062 5B JUMPDEST 1063 33 CALLER 1064 60 PUSH1 0x0b 1066 60 PUSH1 0x00 1068 61 PUSH2 0x0100 106B 0A EXP 106C 81 DUP2 106D 54 SLOAD 106E 81 DUP2 106F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1084 02 MUL 1085 19 NOT 1086 16 AND 1087 90 SWAP1 1088 83 DUP4 1089 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 109E 16 AND 109F 02 MUL 10A0 17 OR 10A1 90 SWAP1 10A2 55 SSTORE 10A3 50 POP 10A4 7F PUSH32 0xb55d30896f7b0c71b13dfc5d76977122428a5d16e59082dd105c040cdcb5b94f 10C5 33 CALLER 10C6 60 PUSH1 0x40 10C8 51 MLOAD 10C9 80 DUP1 10CA 82 DUP3 10CB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10E0 16 AND 10E1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10F6 16 AND 10F7 81 DUP2 10F8 52 MSTORE 10F9 60 PUSH1 0x20 10FB 01 ADD 10FC 91 SWAP2 10FD 50 POP 10FE 50 POP 10FF 60 PUSH1 0x40 1101 51 MLOAD 1102 80 DUP1 1103 91 SWAP2 1104 03 SUB 1105 90 SWAP1 1106 A1 LOG1 1107 50 POP 1108 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @10A2 storage[0x0b] = (0xffffffffffffffffffffffffffffffffffffffff & msg.sender) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x0b]) // @10F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1106 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xb55d30896f7b0c71b13dfc5d76977122428a5d16e59082dd105c040cdcb5b94f]); // } // Block ends with unconditional jump to stack[-2] label_1109: // Incoming call from 0x06BC, returns to 0x06BD // Inputs[4] // { // @110F stack[-1] // @1117 memory[0x00:0x40] // @111C storage[keccak256(memory[0x00:0x40])] // @1127 stack[-2] // } 1109 5B JUMPDEST 110A 60 PUSH1 0x0a 110C 60 PUSH1 0x20 110E 52 MSTORE 110F 80 DUP1 1110 60 PUSH1 0x00 1112 52 MSTORE 1113 60 PUSH1 0x40 1115 60 PUSH1 0x00 1117 20 SHA3 1118 60 PUSH1 0x00 111A 91 SWAP2 111B 50 POP 111C 54 SLOAD 111D 90 SWAP1 111E 61 PUSH2 0x0100 1121 0A EXP 1122 90 SWAP1 1123 04 DIV 1124 60 PUSH1 0xff 1126 16 AND 1127 81 DUP2 1128 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @110E memory[0x20:0x40] = 0x0a // @1112 memory[0x00:0x20] = stack[-1] // @1126 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-2] label_1129: // Incoming call from 0x06EB, returns to 0x06EC // Inputs[3] // { // @1133 msg.sender // @116D memory[0x00:0x40] // @1171 storage[keccak256(memory[0x00:0x40])] // } 1129 5B JUMPDEST 112A 60 PUSH1 0x00 112C 80 DUP1 112D 15 ISZERO 112E 15 ISZERO 112F 60 PUSH1 0x0a 1131 60 PUSH1 0x00 1133 33 CALLER 1134 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1149 16 AND 114A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 115F 16 AND 1160 81 DUP2 1161 52 MSTORE 1162 60 PUSH1 0x20 1164 01 ADD 1165 90 SWAP1 1166 81 DUP2 1167 52 MSTORE 1168 60 PUSH1 0x20 116A 01 ADD 116B 60 PUSH1 0x00 116D 20 SHA3 116E 60 PUSH1 0x00 1170 90 SWAP1 1171 54 SLOAD 1172 90 SWAP1 1173 61 PUSH2 0x0100 1176 0A EXP 1177 90 SWAP1 1178 04 DIV 1179 60 PUSH1 0xff 117B 16 AND 117C 15 ISZERO 117D 15 ISZERO 117E 14 EQ 117F 15 ISZERO 1180 15 ISZERO 1181 61 PUSH2 0x1189 1184 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @112A stack[0] = 0x00 // @1161 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1167 memory[0x20:0x40] = 0x0a // } // Block ends with conditional jump to 0x1189, if !!(!!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) == !!0x00) label_1185: // Incoming jump from 0x1184, if not !!(!!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) == !!0x00) // Inputs[1] { @1188 memory[0x00:0x00] } 1185 60 PUSH1 0x00 1187 80 DUP1 1188 FD *REVERT // Stack delta = +0 // Outputs[1] { @1188 revert(memory[0x00:0x00]); } // Block terminates label_1189: // Incoming jump from 0x1184, if !!(!!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) == !!0x00) // Inputs[16] // { // @118C storage[0x08] // @1190 msg.sender // @11CA memory[0x00:0x40] // @11D5 msg.sender // @120F memory[0x00:0x40] // @1217 storage[keccak256(memory[0x00:0x40])] // @1229 storage[0x07] // @122E msg.sender // @1268 memory[0x00:0x40] // @126D msg.sender // @12A9 storage[0x08] // @12AC memory[0x40:0x60] // @12B9 memory[0x40:0x60] // @12BE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @12C1 stack[-1] // @12C3 stack[-2] // } 1189 5B JUMPDEST 118A 60 PUSH1 0x08 118C 54 SLOAD 118D 60 PUSH1 0x00 118F 80 DUP1 1190 33 CALLER 1191 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11A6 16 AND 11A7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11BC 16 AND 11BD 81 DUP2 11BE 52 MSTORE 11BF 60 PUSH1 0x20 11C1 01 ADD 11C2 90 SWAP1 11C3 81 DUP2 11C4 52 MSTORE 11C5 60 PUSH1 0x20 11C7 01 ADD 11C8 60 PUSH1 0x00 11CA 20 SHA3 11CB 81 DUP2 11CC 90 SWAP1 11CD 55 SSTORE 11CE 50 POP 11CF 60 PUSH1 0x01 11D1 60 PUSH1 0x0a 11D3 60 PUSH1 0x00 11D5 33 CALLER 11D6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11EB 16 AND 11EC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1201 16 AND 1202 81 DUP2 1203 52 MSTORE 1204 60 PUSH1 0x20 1206 01 ADD 1207 90 SWAP1 1208 81 DUP2 1209 52 MSTORE 120A 60 PUSH1 0x20 120C 01 ADD 120D 60 PUSH1 0x00 120F 20 SHA3 1210 60 PUSH1 0x00 1212 61 PUSH2 0x0100 1215 0A EXP 1216 81 DUP2 1217 54 SLOAD 1218 81 DUP2 1219 60 PUSH1 0xff 121B 02 MUL 121C 19 NOT 121D 16 AND 121E 90 SWAP1 121F 83 DUP4 1220 15 ISZERO 1221 15 ISZERO 1222 02 MUL 1223 17 OR 1224 90 SWAP1 1225 55 SSTORE 1226 50 POP 1227 60 PUSH1 0x07 1229 54 SLOAD 122A 60 PUSH1 0x09 122C 60 PUSH1 0x00 122E 33 CALLER 122F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1244 16 AND 1245 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 125A 16 AND 125B 81 DUP2 125C 52 MSTORE 125D 60 PUSH1 0x20 125F 01 ADD 1260 90 SWAP1 1261 81 DUP2 1262 52 MSTORE 1263 60 PUSH1 0x20 1265 01 ADD 1266 60 PUSH1 0x00 1268 20 SHA3 1269 81 DUP2 126A 90 SWAP1 126B 55 SSTORE 126C 50 POP 126D 33 CALLER 126E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1283 16 AND 1284 60 PUSH1 0x00 1286 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 12A7 60 PUSH1 0x08 12A9 54 SLOAD 12AA 60 PUSH1 0x40 12AC 51 MLOAD 12AD 80 DUP1 12AE 82 DUP3 12AF 81 DUP2 12B0 52 MSTORE 12B1 60 PUSH1 0x20 12B3 01 ADD 12B4 91 SWAP2 12B5 50 POP 12B6 50 POP 12B7 60 PUSH1 0x40 12B9 51 MLOAD 12BA 80 DUP1 12BB 91 SWAP2 12BC 03 SUB 12BD 90 SWAP1 12BE A3 LOG3 12BF 60 PUSH1 0x01 12C1 90 SWAP1 12C2 50 POP 12C3 90 SWAP1 12C4 56 *JUMP // Stack delta = -1 // Outputs[12] // { // @11BE memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @11C4 memory[0x20:0x40] = 0x00 // @11CD storage[keccak256(memory[0x00:0x40])] = storage[0x08] // @1203 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1209 memory[0x20:0x40] = 0x0a // @1225 storage[keccak256(memory[0x00:0x40])] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @125C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1262 memory[0x20:0x40] = 0x09 // @126B storage[keccak256(memory[0x00:0x40])] = storage[0x07] // @12B0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x08] // @12BE log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, msg.sender]); // @12C3 stack[-2] = 0x01 // } // Block ends with unconditional jump to stack[-2] label_12C5: // Incoming call from 0x0F4A, returns to 0x0F4B // Inputs[4] // { // @12CB msg.sender // @1305 memory[0x00:0x40] // @1306 storage[keccak256(memory[0x00:0x40])] // @1307 stack[-1] // } 12C5 5B JUMPDEST 12C6 60 PUSH1 0x00 12C8 80 DUP1 12C9 60 PUSH1 0x00 12CB 33 CALLER 12CC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12E1 16 AND 12E2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12F7 16 AND 12F8 81 DUP2 12F9 52 MSTORE 12FA 60 PUSH1 0x20 12FC 01 ADD 12FD 90 SWAP1 12FE 81 DUP2 12FF 52 MSTORE 1300 60 PUSH1 0x20 1302 01 ADD 1303 60 PUSH1 0x00 1305 20 SHA3 1306 54 SLOAD 1307 82 DUP3 1308 11 GT 1309 15 ISZERO 130A 15 ISZERO 130B 15 ISZERO 130C 61 PUSH2 0x1314 130F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @12C6 stack[0] = 0x00 // @12F9 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @12FF memory[0x20:0x40] = 0x00 // } // Block ends with conditional jump to 0x1314, if !!!(stack[-1] > storage[keccak256(memory[0x00:0x40])]) label_1310: // Incoming jump from 0x130F, if not !!!(stack[-1] > storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @1313 memory[0x00:0x00] } 1310 60 PUSH1 0x00 1312 80 DUP1 1313 FD *REVERT // Stack delta = +0 // Outputs[1] { @1313 revert(memory[0x00:0x00]); } // Block terminates label_1314: // Incoming jump from 0x130F, if !!!(stack[-1] > storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @132D stack[-3] } 1314 5B JUMPDEST 1315 60 PUSH1 0x00 1317 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 132C 16 AND 132D 83 DUP4 132E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1343 16 AND 1344 14 EQ 1345 15 ISZERO 1346 15 ISZERO 1347 15 ISZERO 1348 61 PUSH2 0x1350 134B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1350, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_134C: // Incoming jump from 0x134B, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @134F memory[0x00:0x00] } 134C 60 PUSH1 0x00 134E 80 DUP1 134F FD *REVERT // Stack delta = +0 // Outputs[1] { @134F revert(memory[0x00:0x00]); } // Block terminates label_1350: // Incoming jump from 0x134B, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[16] // { // @1351 stack[-2] // @1355 msg.sender // @138F memory[0x00:0x40] // @1390 storage[keccak256(memory[0x00:0x40])] // @1395 msg.sender // @13CF memory[0x00:0x40] // @13D8 stack[-3] // @1412 memory[0x00:0x40] // @1413 storage[keccak256(memory[0x00:0x40])] // @1452 memory[0x00:0x40] // @146E msg.sender // @14A9 memory[0x40:0x60] // @14B6 memory[0x40:0x60] // @14BB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @14BE stack[-1] // @14C0 stack[-4] // } 1350 5B JUMPDEST 1351 81 DUP2 1352 60 PUSH1 0x00 1354 80 DUP1 1355 33 CALLER 1356 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 136B 16 AND 136C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1381 16 AND 1382 81 DUP2 1383 52 MSTORE 1384 60 PUSH1 0x20 1386 01 ADD 1387 90 SWAP1 1388 81 DUP2 1389 52 MSTORE 138A 60 PUSH1 0x20 138C 01 ADD 138D 60 PUSH1 0x00 138F 20 SHA3 1390 54 SLOAD 1391 03 SUB 1392 60 PUSH1 0x00 1394 80 DUP1 1395 33 CALLER 1396 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13AB 16 AND 13AC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13C1 16 AND 13C2 81 DUP2 13C3 52 MSTORE 13C4 60 PUSH1 0x20 13C6 01 ADD 13C7 90 SWAP1 13C8 81 DUP2 13C9 52 MSTORE 13CA 60 PUSH1 0x20 13CC 01 ADD 13CD 60 PUSH1 0x00 13CF 20 SHA3 13D0 81 DUP2 13D1 90 SWAP1 13D2 55 SSTORE 13D3 50 POP 13D4 81 DUP2 13D5 60 PUSH1 0x00 13D7 80 DUP1 13D8 85 DUP6 13D9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13EE 16 AND 13EF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1404 16 AND 1405 81 DUP2 1406 52 MSTORE 1407 60 PUSH1 0x20 1409 01 ADD 140A 90 SWAP1 140B 81 DUP2 140C 52 MSTORE 140D 60 PUSH1 0x20 140F 01 ADD 1410 60 PUSH1 0x00 1412 20 SHA3 1413 54 SLOAD 1414 01 ADD 1415 60 PUSH1 0x00 1417 80 DUP1 1418 85 DUP6 1419 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 142E 16 AND 142F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1444 16 AND 1445 81 DUP2 1446 52 MSTORE 1447 60 PUSH1 0x20 1449 01 ADD 144A 90 SWAP1 144B 81 DUP2 144C 52 MSTORE 144D 60 PUSH1 0x20 144F 01 ADD 1450 60 PUSH1 0x00 1452 20 SHA3 1453 81 DUP2 1454 90 SWAP1 1455 55 SSTORE 1456 50 POP 1457 82 DUP3 1458 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 146D 16 AND 146E 33 CALLER 146F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1484 16 AND 1485 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 14A6 84 DUP5 14A7 60 PUSH1 0x40 14A9 51 MLOAD 14AA 80 DUP1 14AB 82 DUP3 14AC 81 DUP2 14AD 52 MSTORE 14AE 60 PUSH1 0x20 14B0 01 ADD 14B1 91 SWAP2 14B2 50 POP 14B3 50 POP 14B4 60 PUSH1 0x40 14B6 51 MLOAD 14B7 80 DUP1 14B8 91 SWAP2 14B9 03 SUB 14BA 90 SWAP1 14BB A3 LOG3 14BC 60 PUSH1 0x01 14BE 90 SWAP1 14BF 50 POP 14C0 92 SWAP3 14C1 91 SWAP2 14C2 50 POP 14C3 50 POP 14C4 56 *JUMP // Stack delta = -3 // Outputs[13] // { // @1383 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1389 memory[0x20:0x40] = 0x00 // @13C3 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @13C9 memory[0x20:0x40] = 0x00 // @13D2 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] - stack[-2] // @1406 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @140C memory[0x20:0x40] = 0x00 // @1446 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @144C memory[0x20:0x40] = 0x00 // @1455 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + stack[-2] // @14AD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @14BB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, msg.sender, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff]); // @14C0 stack[-4] = 0x01 // } // Block ends with unconditional jump to stack[-4] 14C5 00 *STOP 14C6 A1 LOG1 14C7 65 PUSH6 0x627a7a723058 14CE 20 SHA3 14CF C2 C2 14D0 23 23 14D1 1F 1F 14D2 2D 2D 14D3 DB DB 14D4 23 23 14D5 F0 CREATE 14D6 19 NOT 14D7 B1 DUP 14D8 3F EXTCODEHASH 14D9 B3 B3 14DA FE *ASSERT 14DB E2 E2 14DC D8 D8 14DD 5C 5C 14DE FE *ASSERT 14DF 2A 2A 14E0 AC AC 14E1 6C PUSH13 0xdf1535283e98df769e4f50a44a 14EF 00 *STOP 14F0 29 29
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]