Online Solidity Decompiler

« Decompile another contract

Address

0xecb4380189e22ed2abccff53a6ac1d1e02bd6981 [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.
0x173825d9 removeOwner(address)
0x2f54bf6e isOwner(address)
0x4123cb6b m_numOwners()
0x52375093 m_lastDay()
0x54fd4d50 version()
0x5c52c2f5 resetSpentToday()
0x659010e7 m_spentToday()
0x7065cb48 addOwner(address)
0x746c9171 m_required()
0x797af627 confirm(bytes32)
0xb20d30a9 setDailyLimit(uint256)
0xb61d27f6 execute(address,uint256,bytes)
0xb75c7dc6 revoke(bytes32)
0xba51a6df changeRequirement(uint256)
0xc2cf7326 hasConfirmed(bytes32,address)
0xcbf0b0c0 kill(address)
0xf00d4b5d changeOwner(address,address)
0xf1736d86 m_dailyLimit()

Internal Methods

func_0106()
func_015B()
revoke(arg0)
changeOwner(arg0, arg1)
addOwner(arg0)
removeOwner(arg0)
changeRequirement(arg0)
isOwner(arg0) returns (r0)
hasConfirmed(arg0, arg1) returns (r0)
m_required(arg0) returns (r0)
m_numOwners(arg0) returns (r0)
setDailyLimit(arg0)
resetSpentToday()
m_dailyLimit(arg0) returns (r0)
m_spentToday(arg0) returns (r0)
m_lastDay(arg0) returns (r0)
version(arg0) returns (r0)
kill(arg0)
execute(arg0, arg1, arg2, arg3) returns (r0)
func_0E46(arg0, arg1) returns (r0)
confirm(arg0) returns (r0)
func_12A7(arg0, arg1) returns (r0)
func_12DB(arg0) returns (r0)
func_13A4(arg0, arg1) returns (r0)
func_153D() returns (r0)
func_16D7(arg0) returns (r0)
func_1777()
func_1848(arg0, arg1) returns (r0)
func_1885()
func_195B(arg0, arg1) returns (r0)
func_1980() returns (r0)

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x60; if (!msg.data.length) { label_00F8: var var0 = 0x015e; if (msg.value <= 0x00) { func_015B(); stop(); } else { func_0106(); stop(); } } else { var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000; if (var0 == 0x173825d9) { // Dispatch table entry for removeOwner(address) var var1 = 0x0176; var var2 = msg.data[0x04:0x24]; removeOwner(var2); stop(); } else if (var0 == 0x2f54bf6e) { // Dispatch table entry for isOwner(address) var1 = 0x018e; var2 = msg.data[0x04:0x24]; var1 = isOwner(var2); var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = var1; var temp1 = memory[0x40:0x60]; return memory[temp1:temp1 + (temp0 + 0x20) - temp1]; } else if (var0 == 0x4123cb6b) { // Dispatch table entry for m_numOwners() var1 = 0x01b1; var2 = m_numOwners(); var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = var2; var temp3 = memory[0x40:0x60]; return memory[temp3:temp3 + (temp2 + 0x20) - temp3]; } else if (var0 == 0x52375093) { // Dispatch table entry for m_lastDay() var1 = 0x01d4; var2 = m_lastDay(); var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = var2; var temp5 = memory[0x40:0x60]; return memory[temp5:temp5 + (temp4 + 0x20) - temp5]; } else if (var0 == 0x54fd4d50) { // Dispatch table entry for version() var1 = 0x01f7; var2 = version(); var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = var2; var temp7 = memory[0x40:0x60]; return memory[temp7:temp7 + (temp6 + 0x20) - temp7]; } else if (var0 == 0x5c52c2f5) { // Dispatch table entry for resetSpentToday() var1 = 0x021a; resetSpentToday(); stop(); } else if (var0 == 0x659010e7) { // Dispatch table entry for m_spentToday() var1 = 0x0229; var2 = m_spentToday(); var temp8 = memory[0x40:0x60]; memory[temp8:temp8 + 0x20] = var2; var temp9 = memory[0x40:0x60]; return memory[temp9:temp9 + (temp8 + 0x20) - temp9]; } else if (var0 == 0x7065cb48) { // Dispatch table entry for addOwner(address) var1 = 0x0255; var2 = msg.data[0x04:0x24]; addOwner(var2); stop(); } else if (var0 == 0x746c9171) { // Dispatch table entry for m_required() var1 = 0x0264; var2 = m_required(); var temp10 = memory[0x40:0x60]; memory[temp10:temp10 + 0x20] = var2; var temp11 = memory[0x40:0x60]; return memory[temp11:temp11 + (temp10 + 0x20) - temp11]; } else if (var0 == 0x797af627) { // Dispatch table entry for confirm(bytes32) var1 = 0x0290; var2 = msg.data[0x04:0x24]; var1 = confirm(var2); var temp12 = memory[0x40:0x60]; memory[temp12:temp12 + 0x20] = var1; var temp13 = memory[0x40:0x60]; return memory[temp13:temp13 + (temp12 + 0x20) - temp13]; } else if (var0 == 0xb20d30a9) { // Dispatch table entry for setDailyLimit(uint256) var1 = 0x02bc; var2 = msg.data[0x04:0x24]; setDailyLimit(var2); stop(); } else if (var0 == 0xb61d27f6) { // Dispatch table entry for execute(address,uint256,bytes) var1 = 0x02f1; var2 = msg.data[0x04:0x24]; var var3 = msg.data[0x24:0x44]; var temp14 = msg.data[0x44:0x64] + 0x04; var var5 = msg.data[temp14:temp14 + 0x20]; var var4 = temp14 + 0x20; var1 = execute(var2, var3, var4, var5); label_02F1: 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 == 0xb75c7dc6) { // Dispatch table entry for revoke(bytes32) var1 = 0x031d; var2 = msg.data[0x04:0x24]; revoke(var2); stop(); } else if (var0 == 0xba51a6df) { // Dispatch table entry for changeRequirement(uint256) var1 = 0x0335; var2 = msg.data[0x04:0x24]; changeRequirement(var2); stop(); } else if (var0 == 0xc2cf7326) { // Dispatch table entry for hasConfirmed(bytes32,address) var1 = 0x0356; var2 = msg.data[0x04:0x24]; var3 = msg.data[0x24:0x44]; var1 = hasConfirmed(var2, var3); var temp17 = memory[0x40:0x60]; memory[temp17:temp17 + 0x20] = var1; var temp18 = memory[0x40:0x60]; return memory[temp18:temp18 + (temp17 + 0x20) - temp18]; } else if (var0 == 0xcbf0b0c0) { // Dispatch table entry for kill(address) var1 = 0x0382; var2 = msg.data[0x04:0x24]; kill(var2); stop(); } else if (var0 == 0xf00d4b5d) { // Dispatch table entry for changeOwner(address,address) var1 = 0x03a3; var2 = msg.data[0x04:0x24]; var3 = msg.data[0x24:0x44]; changeOwner(var2, var3); stop(); } else if (var0 == 0xf1736d86) { // Dispatch table entry for m_dailyLimit() var1 = 0x03b2; var2 = m_dailyLimit(); var temp19 = memory[0x40:0x60]; memory[temp19:temp19 + 0x20] = var2; var temp20 = memory[0x40:0x60]; return memory[temp20:temp20 + (temp19 + 0x20) - temp20]; } else { goto label_00F8; } } } function func_0106() { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = msg.sender; var temp1 = temp0 + 0x20; memory[temp1:temp1 + 0x20] = msg.value; var temp2 = memory[0x40:0x60]; log(memory[temp2:temp2 + (temp1 + 0x20) - temp2], [0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c]); } function func_015B() {} function revoke(var arg0) { var var1 = 0x00; var var2 = 0x00; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x0102; var var0 = storage[keccak256(memory[0x00:0x40])]; if (var0 == 0x00) { goto label_04C4; } var1 = 0x02 ** var0; memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x0103; var2 = keccak256(memory[0x00:0x40]); if (storage[var2 + 0x01] & var1 <= 0x00) { label_04C4: return; } else { var temp0 = var2; var temp1 = temp0; storage[temp1] = storage[temp1] + 0x01; var temp2 = temp0 + 0x01; storage[temp2] = storage[temp2] - var1; var temp3 = memory[0x40:0x60]; memory[temp3:temp3 + 0x20] = msg.sender; var temp4 = temp3 + 0x20; memory[temp4:temp4 + 0x20] = arg0; var temp5 = memory[0x40:0x60]; log(memory[temp5:temp5 + (temp4 + 0x20) - temp5], [0xc7fb647e59b18047309aa15aad418e5d7ca96d173ad704f1031a2c3d7591734b]); goto label_04C4; } } function changeOwner(var arg0, var arg1) { var var0 = 0x00; var temp0 = msg.data.length; var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + temp0] = msg.data[0x00:0x00 + temp0]; var temp2 = temp1 + temp0; memory[temp2:temp2 + 0x20] = block.number; var temp3 = memory[0x40:0x60]; var var1 = keccak256(memory[temp3:temp3 + (temp2 + 0x20) - temp3]); var var2 = 0x04fb; var var3 = var1; var2 = func_12DB(var3); if (!var2) { label_0667: return; } else { var2 = 0x0509; var3 = arg1; var2 = isOwner(var3); if (var2) { goto label_0669; } memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x0102; var0 = storage[keccak256(memory[0x00:0x40])]; if (var0 != 0x00) { var2 = 0x055e; func_1777(); var2 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; var3 = 0x02; var var4 = var0; if (var4 >= 0x0100) { memory[0x40:0x60] = var4; if (!msg.data.length) { label_00F8: var4 = 0x015e; if (msg.value <= 0x00) { func_015B(); stop(); } else { func_0106(); stop(); } } else { var4 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000; if (var4 == 0x173825d9) { var var5 = 0x0176; var var6 = msg.data[0x04:0x24]; removeOwner(var6); stop(); } else if (var4 == 0x2f54bf6e) { var5 = 0x018e; var6 = msg.data[0x04:0x24]; var5 = isOwner(var6); var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = var5; var temp5 = memory[0x40:0x60]; return memory[temp5:temp5 + (temp4 + 0x20) - temp5]; } else if (var4 == 0x4123cb6b) { var5 = 0x01b1; var6 = m_numOwners(); var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = var6; var temp7 = memory[0x40:0x60]; return memory[temp7:temp7 + (temp6 + 0x20) - temp7]; } else if (var4 == 0x52375093) { var5 = 0x01d4; var6 = m_lastDay(); var temp8 = memory[0x40:0x60]; memory[temp8:temp8 + 0x20] = var6; var temp9 = memory[0x40:0x60]; return memory[temp9:temp9 + (temp8 + 0x20) - temp9]; } else if (var4 == 0x54fd4d50) { var5 = 0x01f7; var6 = version(); var temp10 = memory[0x40:0x60]; memory[temp10:temp10 + 0x20] = var6; var temp11 = memory[0x40:0x60]; return memory[temp11:temp11 + (temp10 + 0x20) - temp11]; } else if (var4 == 0x5c52c2f5) { var5 = 0x021a; resetSpentToday(); stop(); } else if (var4 == 0x659010e7) { var5 = 0x0229; var6 = m_spentToday(); var temp12 = memory[0x40:0x60]; memory[temp12:temp12 + 0x20] = var6; var temp13 = memory[0x40:0x60]; return memory[temp13:temp13 + (temp12 + 0x20) - temp13]; } else if (var4 == 0x7065cb48) { var5 = 0x0255; var6 = msg.data[0x04:0x24]; addOwner(var6); stop(); } else if (var4 == 0x746c9171) { var5 = 0x0264; var6 = m_required(); var temp14 = memory[0x40:0x60]; memory[temp14:temp14 + 0x20] = var6; var temp15 = memory[0x40:0x60]; return memory[temp15:temp15 + (temp14 + 0x20) - temp15]; } else if (var4 == 0x797af627) { var5 = 0x0290; var6 = msg.data[0x04:0x24]; var5 = confirm(var6); var temp16 = memory[0x40:0x60]; memory[temp16:temp16 + 0x20] = var5; var temp17 = memory[0x40:0x60]; return memory[temp17:temp17 + (temp16 + 0x20) - temp17]; } else if (var4 == 0xb20d30a9) { var5 = 0x02bc; var6 = msg.data[0x04:0x24]; setDailyLimit(var6); stop(); } else if (var4 == 0xb61d27f6) { var5 = 0x02f1; var6 = msg.data[0x04:0x24]; var var7 = msg.data[0x24:0x44]; var temp18 = msg.data[0x44:0x64] + 0x04; var var9 = msg.data[temp18:temp18 + 0x20]; var var8 = temp18 + 0x20; var5 = execute(var6, var7, var8, var9); label_02F1: var temp19 = memory[0x40:0x60]; memory[temp19:temp19 + 0x20] = var5; var temp20 = memory[0x40:0x60]; return memory[temp20:temp20 + (temp19 + 0x20) - temp20]; } else if (var4 == 0xb75c7dc6) { var5 = 0x031d; var6 = msg.data[0x04:0x24]; revoke(var6); stop(); } else if (var4 == 0xba51a6df) { var5 = 0x0335; var6 = msg.data[0x04:0x24]; changeRequirement(var6); stop(); } else if (var4 == 0xc2cf7326) { var5 = 0x0356; var6 = msg.data[0x04:0x24]; var7 = msg.data[0x24:0x44]; var5 = hasConfirmed(var6, var7); var temp21 = memory[0x40:0x60]; memory[temp21:temp21 + 0x20] = var5; var temp22 = memory[0x40:0x60]; return memory[temp22:temp22 + (temp21 + 0x20) - temp22]; } else if (var4 == 0xcbf0b0c0) { var5 = 0x0382; var6 = msg.data[0x04:0x24]; kill(var6); stop(); } else if (var4 == 0xf00d4b5d) { var5 = 0x03a3; var6 = msg.data[0x04:0x24]; var7 = msg.data[0x24:0x44]; changeOwner(var6, var7); stop(); } else if (var4 == 0xf1736d86) { var5 = 0x03b2; var6 = m_dailyLimit(); var temp23 = memory[0x40:0x60]; memory[temp23:temp23 + 0x20] = var6; var temp24 = memory[0x40:0x60]; return memory[temp24:temp24 + (temp23 + 0x20) - temp24]; } else { goto label_00F8; } } } else { storage[var4 + var3] = var2; var temp25 = arg0; memory[0x00:0x20] = temp25 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x0102; storage[keccak256(memory[0x00:0x40])] = 0x00; var temp26 = arg1; memory[0x00:0x20] = temp26 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x0102; storage[keccak256(memory[0x00:0x40])] = var0; var temp27 = memory[0x40:0x60]; memory[temp27:temp27 + 0x20] = temp25 & 0xffffffffffffffffffffffffffffffffffffffff; var temp28 = temp27 + 0x20; memory[temp28:temp28 + 0x20] = temp26 & 0xffffffffffffffffffffffffffffffffffffffff; var temp29 = memory[0x40:0x60]; log(memory[temp29:temp29 + (temp28 + 0x20) - temp29], [0xb532073b38c83145e3e5135377a08bf9aab55bc0fd7c1179cd4fb995d2a5159c]); goto label_0667; } } else { label_0669: return; } } } function addOwner(var arg0) { var temp0 = msg.data.length; var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + temp0] = msg.data[0x00:0x00 + temp0]; var temp2 = temp1 + temp0; memory[temp2:temp2 + 0x20] = block.number; var temp3 = memory[0x40:0x60]; var var0 = keccak256(memory[temp3:temp3 + (temp2 + 0x20) - temp3]); var var1 = 0x069d; var var2 = var0; var1 = func_12DB(var2); if (!var1) { label_07BF: return; } else { var1 = 0x06ab; var2 = arg0; var1 = isOwner(var2); if (var1) { goto label_07C1; } var1 = 0x06be; func_1777(); if (storage[0x01] < 0xfa) { label_06D7: if (storage[0x01] < 0xfa) { storage[0x01] = storage[0x01] + 0x01; var1 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var2 = 0x02; var var3 = storage[0x01]; if (var3 >= 0x0100) { memory[0x40:0x60] = var3; if (!msg.data.length) { label_00F8: var3 = 0x015e; if (msg.value <= 0x00) { func_015B(); stop(); } else { func_0106(); stop(); } } else { var3 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000; if (var3 == 0x173825d9) { var var4 = 0x0176; var var5 = msg.data[0x04:0x24]; removeOwner(var5); stop(); } else if (var3 == 0x2f54bf6e) { var4 = 0x018e; var5 = msg.data[0x04:0x24]; var4 = isOwner(var5); var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = var4; var temp5 = memory[0x40:0x60]; return memory[temp5:temp5 + (temp4 + 0x20) - temp5]; } else if (var3 == 0x4123cb6b) { var4 = 0x01b1; var5 = m_numOwners(); var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = var5; var temp7 = memory[0x40:0x60]; return memory[temp7:temp7 + (temp6 + 0x20) - temp7]; } else if (var3 == 0x52375093) { var4 = 0x01d4; var5 = m_lastDay(); var temp8 = memory[0x40:0x60]; memory[temp8:temp8 + 0x20] = var5; var temp9 = memory[0x40:0x60]; return memory[temp9:temp9 + (temp8 + 0x20) - temp9]; } else if (var3 == 0x54fd4d50) { var4 = 0x01f7; var5 = version(); var temp10 = memory[0x40:0x60]; memory[temp10:temp10 + 0x20] = var5; var temp11 = memory[0x40:0x60]; return memory[temp11:temp11 + (temp10 + 0x20) - temp11]; } else if (var3 == 0x5c52c2f5) { var4 = 0x021a; resetSpentToday(); stop(); } else if (var3 == 0x659010e7) { var4 = 0x0229; var5 = m_spentToday(); var temp12 = memory[0x40:0x60]; memory[temp12:temp12 + 0x20] = var5; var temp13 = memory[0x40:0x60]; return memory[temp13:temp13 + (temp12 + 0x20) - temp13]; } else if (var3 == 0x7065cb48) { var4 = 0x0255; var5 = msg.data[0x04:0x24]; addOwner(var5); stop(); } else if (var3 == 0x746c9171) { var4 = 0x0264; var5 = m_required(); var temp14 = memory[0x40:0x60]; memory[temp14:temp14 + 0x20] = var5; var temp15 = memory[0x40:0x60]; return memory[temp15:temp15 + (temp14 + 0x20) - temp15]; } else if (var3 == 0x797af627) { var4 = 0x0290; var5 = msg.data[0x04:0x24]; var4 = confirm(var5); var temp16 = memory[0x40:0x60]; memory[temp16:temp16 + 0x20] = var4; var temp17 = memory[0x40:0x60]; return memory[temp17:temp17 + (temp16 + 0x20) - temp17]; } else if (var3 == 0xb20d30a9) { var4 = 0x02bc; var5 = msg.data[0x04:0x24]; setDailyLimit(var5); stop(); } else if (var3 == 0xb61d27f6) { var4 = 0x02f1; var5 = msg.data[0x04:0x24]; var var6 = msg.data[0x24:0x44]; var temp18 = msg.data[0x44:0x64] + 0x04; var var8 = msg.data[temp18:temp18 + 0x20]; var var7 = temp18 + 0x20; var4 = execute(var5, var6, var7, var8); label_02F1: var temp19 = memory[0x40:0x60]; memory[temp19:temp19 + 0x20] = var4; var temp20 = memory[0x40:0x60]; return memory[temp20:temp20 + (temp19 + 0x20) - temp20]; } else if (var3 == 0xb75c7dc6) { var4 = 0x031d; var5 = msg.data[0x04:0x24]; revoke(var5); stop(); } else if (var3 == 0xba51a6df) { var4 = 0x0335; var5 = msg.data[0x04:0x24]; changeRequirement(var5); stop(); } else if (var3 == 0xc2cf7326) { var4 = 0x0356; var5 = msg.data[0x04:0x24]; var6 = msg.data[0x24:0x44]; var4 = hasConfirmed(var5, var6); var temp21 = memory[0x40:0x60]; memory[temp21:temp21 + 0x20] = var4; var temp22 = memory[0x40:0x60]; return memory[temp22:temp22 + (temp21 + 0x20) - temp22]; } else if (var3 == 0xcbf0b0c0) { var4 = 0x0382; var5 = msg.data[0x04:0x24]; kill(var5); stop(); } else if (var3 == 0xf00d4b5d) { var4 = 0x03a3; var5 = msg.data[0x04:0x24]; var6 = msg.data[0x24:0x44]; changeOwner(var5, var6); stop(); } else if (var3 == 0xf1736d86) { var4 = 0x03b2; var5 = m_dailyLimit(); var temp23 = memory[0x40:0x60]; memory[temp23:temp23 + 0x20] = var5; var temp24 = memory[0x40:0x60]; return memory[temp24:temp24 + (temp23 + 0x20) - temp24]; } else { goto label_00F8; } } } else { storage[var3 + var2] = var1; var temp25 = arg0; memory[0x00:0x20] = temp25 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x0102; storage[keccak256(memory[0x00:0x40])] = storage[0x01]; var temp26 = memory[0x40:0x60]; memory[temp26:temp26 + 0x20] = temp25 & 0xffffffffffffffffffffffffffffffffffffffff; var temp27 = memory[0x40:0x60]; log(memory[temp27:temp27 + (temp26 + 0x20) - temp27], [0x994a936646fe87ffe4f1e469d3d6aa417d6b855598397f323de5b449f765f0c3]); goto label_07BF; } } else { label_07C1: return; } } else { var1 = 0x06d5; var1 = func_153D(); goto label_06D7; } } } function removeOwner(var arg0) { var var0 = 0x00; var temp0 = msg.data.length; var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + temp0] = msg.data[0x00:0x00 + temp0]; var temp2 = temp1 + temp0; memory[temp2:temp2 + 0x20] = block.number; var temp3 = memory[0x40:0x60]; var var1 = keccak256(memory[temp3:temp3 + (temp2 + 0x20) - temp3]); var var2 = 0x07f5; var var3 = var1; var2 = func_12DB(var3); if (!var2) { label_0909: return; } else { memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x0102; var0 = storage[keccak256(memory[0x00:0x40])]; if (var0 == 0x00) { goto label_090B; } if (storage[0x00] <= storage[0x01] - 0x01) { var2 = 0x00; var3 = 0x02; var var4 = var0; if (var4 >= 0x0100) { memory[0x40:0x60] = var4; if (!msg.data.length) { label_00F8: var4 = 0x015e; if (msg.value <= 0x00) { func_015B(); stop(); } else { func_0106(); stop(); } } else { var4 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000; if (var4 == 0x173825d9) { var var5 = 0x0176; var var6 = msg.data[0x04:0x24]; removeOwner(var6); stop(); } else if (var4 == 0x2f54bf6e) { var5 = 0x018e; var6 = msg.data[0x04:0x24]; var5 = isOwner(var6); var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = var5; var temp5 = memory[0x40:0x60]; return memory[temp5:temp5 + (temp4 + 0x20) - temp5]; } else if (var4 == 0x4123cb6b) { var5 = 0x01b1; var6 = m_numOwners(); var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = var6; var temp7 = memory[0x40:0x60]; return memory[temp7:temp7 + (temp6 + 0x20) - temp7]; } else if (var4 == 0x52375093) { var5 = 0x01d4; var6 = m_lastDay(); var temp8 = memory[0x40:0x60]; memory[temp8:temp8 + 0x20] = var6; var temp9 = memory[0x40:0x60]; return memory[temp9:temp9 + (temp8 + 0x20) - temp9]; } else if (var4 == 0x54fd4d50) { var5 = 0x01f7; var6 = version(); var temp10 = memory[0x40:0x60]; memory[temp10:temp10 + 0x20] = var6; var temp11 = memory[0x40:0x60]; return memory[temp11:temp11 + (temp10 + 0x20) - temp11]; } else if (var4 == 0x5c52c2f5) { var5 = 0x021a; resetSpentToday(); stop(); } else if (var4 == 0x659010e7) { var5 = 0x0229; var6 = m_spentToday(); var temp12 = memory[0x40:0x60]; memory[temp12:temp12 + 0x20] = var6; var temp13 = memory[0x40:0x60]; return memory[temp13:temp13 + (temp12 + 0x20) - temp13]; } else if (var4 == 0x7065cb48) { var5 = 0x0255; var6 = msg.data[0x04:0x24]; addOwner(var6); stop(); } else if (var4 == 0x746c9171) { var5 = 0x0264; var6 = m_required(); var temp14 = memory[0x40:0x60]; memory[temp14:temp14 + 0x20] = var6; var temp15 = memory[0x40:0x60]; return memory[temp15:temp15 + (temp14 + 0x20) - temp15]; } else if (var4 == 0x797af627) { var5 = 0x0290; var6 = msg.data[0x04:0x24]; var5 = confirm(var6); var temp16 = memory[0x40:0x60]; memory[temp16:temp16 + 0x20] = var5; var temp17 = memory[0x40:0x60]; return memory[temp17:temp17 + (temp16 + 0x20) - temp17]; } else if (var4 == 0xb20d30a9) { var5 = 0x02bc; var6 = msg.data[0x04:0x24]; setDailyLimit(var6); stop(); } else if (var4 == 0xb61d27f6) { var5 = 0x02f1; var6 = msg.data[0x04:0x24]; var var7 = msg.data[0x24:0x44]; var temp18 = msg.data[0x44:0x64] + 0x04; var var9 = msg.data[temp18:temp18 + 0x20]; var var8 = temp18 + 0x20; var5 = execute(var6, var7, var8, var9); label_02F1: var temp19 = memory[0x40:0x60]; memory[temp19:temp19 + 0x20] = var5; var temp20 = memory[0x40:0x60]; return memory[temp20:temp20 + (temp19 + 0x20) - temp20]; } else if (var4 == 0xb75c7dc6) { var5 = 0x031d; var6 = msg.data[0x04:0x24]; revoke(var6); stop(); } else if (var4 == 0xba51a6df) { var5 = 0x0335; var6 = msg.data[0x04:0x24]; changeRequirement(var6); stop(); } else if (var4 == 0xc2cf7326) { var5 = 0x0356; var6 = msg.data[0x04:0x24]; var7 = msg.data[0x24:0x44]; var5 = hasConfirmed(var6, var7); var temp21 = memory[0x40:0x60]; memory[temp21:temp21 + 0x20] = var5; var temp22 = memory[0x40:0x60]; return memory[temp22:temp22 + (temp21 + 0x20) - temp22]; } else if (var4 == 0xcbf0b0c0) { var5 = 0x0382; var6 = msg.data[0x04:0x24]; kill(var6); stop(); } else if (var4 == 0xf00d4b5d) { var5 = 0x03a3; var6 = msg.data[0x04:0x24]; var7 = msg.data[0x24:0x44]; changeOwner(var6, var7); stop(); } else if (var4 == 0xf1736d86) { var5 = 0x03b2; var6 = m_dailyLimit(); var temp23 = memory[0x40:0x60]; memory[temp23:temp23 + 0x20] = var6; var temp24 = memory[0x40:0x60]; return memory[temp24:temp24 + (temp23 + 0x20) - temp24]; } else { goto label_00F8; } } } else { storage[var4 + var3] = var2; memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x0102; storage[keccak256(memory[0x00:0x40])] = 0x00; var2 = 0x08b2; func_1777(); var2 = 0x08ba; var2 = func_153D(); var temp25 = memory[0x40:0x60]; memory[temp25:temp25 + 0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var temp26 = memory[0x40:0x60]; log(memory[temp26:temp26 + (temp25 + 0x20) - temp26], [0x58619076adf5bb0943d100ef88d52d7c3fd691b19d3a9071b555b651fbf418da]); goto label_0909; } } else { label_090B: return; } } } function changeRequirement(var arg0) { var temp0 = msg.data.length; var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + temp0] = msg.data[0x00:0x00 + temp0]; var temp2 = temp1 + temp0; memory[temp2:temp2 + 0x20] = block.number; var temp3 = memory[0x40:0x60]; var var0 = keccak256(memory[temp3:temp3 + (temp2 + 0x20) - temp3]); var var1 = 0x093e; var var2 = var0; var1 = func_12DB(var2); if (!var1) { label_09A0: return; } else if (arg0 <= storage[0x01]) { storage[0x00] = arg0; var1 = 0x0968; func_1777(); var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = arg0; var temp5 = memory[0x40:0x60]; log(memory[temp5:temp5 + (temp4 + 0x20) - temp5], [0xacbdb084c721332ac59f9b8e392196c9eb0e4932862da8eb9beaf0dad4f550da]); goto label_09A0; } else { return; } } function isOwner(var arg0) returns (var r0) { memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x0102; var var0 = storage[keccak256(memory[0x00:0x40])] > 0x00; return var0; } function hasConfirmed(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var3 = 0x00; memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x0103; var var1 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x0102; var var2 = storage[keccak256(memory[0x00:0x40])]; if (var2 != 0x00) { var3 = 0x02 ** var2; if (storage[var1 + 0x01] & var3 != 0x00) { var0 = 0x01; label_0A7F: return var0; } else { var0 = 0x00; goto label_0A7F; } } else { var0 = 0x00; goto label_0A7F; } } function m_required() returns (var r0) { return storage[0x00]; } function m_numOwners() returns (var r0) { return storage[0x01]; } function setDailyLimit(var arg0) { var temp0 = msg.data.length; var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + temp0] = msg.data[0x00:0x00 + temp0]; var temp2 = temp1 + temp0; memory[temp2:temp2 + 0x20] = block.number; var temp3 = memory[0x40:0x60]; var var0 = keccak256(memory[temp3:temp3 + (temp2 + 0x20) - temp3]); var var1 = 0x0ac9; var var2 = var0; var1 = func_12DB(var2); if (!var1) { return; } storage[0x0105] = arg0; } function resetSpentToday() { var temp0 = msg.data.length; var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + temp0] = msg.data[0x00:0x00 + temp0]; var temp2 = temp1 + temp0; memory[temp2:temp2 + 0x20] = block.number; var temp3 = memory[0x40:0x60]; var var0 = keccak256(memory[temp3:temp3 + (temp2 + 0x20) - temp3]); var var1 = 0x0b0e; var var2 = var0; var1 = func_12DB(var2); if (!var1) { return; } storage[0x0106] = 0x00; } function m_dailyLimit() returns (var r0) { return storage[0x0105]; } function m_spentToday() returns (var r0) { return storage[0x0106]; } function m_lastDay() returns (var r0) { return storage[0x0107]; } function version() returns (var r0) { return storage[0x0108]; } function kill(var arg0) { var temp0 = msg.data.length; var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + temp0] = msg.data[0x00:0x00 + temp0]; var temp2 = temp1 + temp0; memory[temp2:temp2 + 0x20] = block.number; var temp3 = memory[0x40:0x60]; var var0 = keccak256(memory[temp3:temp3 + (temp2 + 0x20) - temp3]); var var1 = 0x0b7b; var var2 = var0; var1 = func_12DB(var2); if (!var1) { return; } else { selfdestruct(arg0 & 0xffffffffffffffffffffffffffffffffffffffff); } } function execute(var arg0, var arg1, var arg2, var arg3) returns (var r0) { var var0 = 0x00; var var1 = 0x0ba9; var var2 = msg.sender; var1 = isOwner(var2); if (!var1) { label_0F05: return var0; } else { var1 = 0x0bb7; var2 = arg1; var1 = func_16D7(var2); label_0BB7: if (!var1) { var temp0 = msg.data.length; var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + temp0] = msg.data[0x00:0x00 + temp0]; var temp2 = temp1 + temp0; memory[temp2:temp2 + 0x20] = block.number; var temp3 = memory[0x40:0x60]; var0 = keccak256(memory[temp3:temp3 + (temp2 + 0x20) - temp3]); var1 = 0x0cd3; var2 = var0; var1 = confirm(var2); var temp4 = !var1; var1 = temp4; if (var1) { memory[0x00:0x20] = var0; memory[0x20:0x40] = 0x0109; if (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffffffffffffffffffffffffffff != 0x00) { goto label_0F04; } else { goto label_0D39; } } else if (!var1) { label_0F04: goto label_0F05; } else { label_0D39: var temp5 = var0; memory[0x00:0x20] = temp5; memory[0x20:0x40] = 0x0109; var temp6 = keccak256(memory[0x00:0x40]); storage[temp6] = arg0 | (storage[temp6] & ~0xffffffffffffffffffffffffffffffffffffffff); memory[0x00:0x20] = temp5; memory[0x20:0x40] = 0x0109; storage[keccak256(memory[0x00:0x40]) + 0x01] = arg1; memory[0x00:0x20] = temp5; memory[0x20:0x40] = 0x0109; var temp7 = keccak256(memory[0x00:0x40]) + 0x02; var1 = temp7; var var3 = arg3; var temp8 = storage[var1]; memory[0x00:0x20] = var1; var var4 = keccak256(memory[0x00:0x20]); var2 = var4 + ((!(temp8 & 0x01) * 0x0100 - 0x01 & temp8) / 0x02 + 0x1f) / 0x20; var var5 = arg2; if (0x1f < var3) { var temp9 = var3; storage[var1] = temp9 + temp9 + 0x01; if (!temp9) { label_0E39: var temp10 = var2; var2 = 0x0e64; var4 = var4; var3 = temp10; var2 = func_0E46(var3, var4); var temp11 = arg3; var temp12 = memory[0x40:0x60]; memory[temp12:temp12 + 0x20] = var0; var temp13 = temp12 + 0x20; memory[temp13:temp13 + 0x20] = msg.sender; var temp14 = temp13 + 0x20; memory[temp14:temp14 + 0x20] = arg1; var temp15 = temp14 + 0x20; memory[temp15:temp15 + 0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var temp16 = temp15 + 0x20; var temp17 = temp16 + 0x20; memory[temp16:temp16 + 0x20] = temp17 - temp12; memory[temp17:temp17 + 0x20] = temp11; var temp18 = temp17 + 0x20; memory[temp18:temp18 + temp11] = msg.data[arg2:arg2 + temp11]; var temp19 = memory[0x40:0x60]; log(memory[temp19:temp19 + (temp18 + temp11) - temp19], [0x1733cbb53659d713b79580f79f3f9ff215f78a7c7aa45890f3b89fc5cddfbf32]); goto label_0F04; } else { var temp20 = var3; var temp21 = var5; var3 = temp21; var5 = var3 + temp20; if (var5 <= var3) { label_0E38: goto label_0E39; } else { label_0E23: var temp22 = var3; var temp23 = var4; storage[temp23] = msg.data[temp22:temp22 + 0x20]; var3 = temp22 + 0x20; var4 = temp23 + 0x01; var5 = var5; if (var5 <= var3) { goto label_0E38; } else { goto label_0E23; } } } } else { var temp24 = var3; storage[var1] = temp24 + temp24 | (msg.data[var5:var5 + 0x20] & ~0xff); goto label_0E39; } } } else { var temp25 = arg1; var temp26 = arg0; var temp27 = arg2; var temp28 = arg3; var temp29 = memory[0x40:0x60]; memory[temp29:temp29 + 0x20] = msg.sender; var temp30 = temp29 + 0x20; memory[temp30:temp30 + 0x20] = temp25; var temp31 = temp30 + 0x20; memory[temp31:temp31 + 0x20] = temp26 & 0xffffffffffffffffffffffffffffffffffffffff; var temp32 = temp31 + 0x20; var temp33 = temp32 + 0x20; memory[temp32:temp32 + 0x20] = temp33 - temp29; memory[temp33:temp33 + 0x20] = temp28; var temp34 = temp33 + 0x20; memory[temp34:temp34 + temp28] = msg.data[temp27:temp27 + temp28]; var temp35 = memory[0x40:0x60]; log(memory[temp35:temp35 + (temp34 + temp28) - temp35], [0x92ca3a80853e6663fa31fa10b99225f18d4902939b4c53a9caae9043f6efd004]); var temp36 = memory[0x40:0x60]; memory[temp36:temp36 + temp28] = msg.data[temp27:temp27 + temp28]; var temp37 = memory[0x40:0x60]; memory[temp37:temp37 + 0x00] = address(temp26 & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(msg.gas - 0x8502).value(temp25)(memory[temp37:temp37 + (temp36 + temp28) - temp37]); return 0x00; } } } function func_0E46(var arg0, var arg1) returns (var r0) { if (arg0 <= arg1) { return arg0; } var temp0 = arg1; storage[temp0] = 0x00; arg1 = temp0 + 0x01; r0 = func_0E46(arg0, arg1); // Error: Could not resolve method call return address! } function confirm(var arg0) returns (var r0) { var var0 = 0x00; var var1 = arg0; var var2 = 0x0f1a; var var3 = var1; var2 = func_12DB(var3); if (!var2) { label_12D4: return var0; } else { memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x0109; if (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffffffffffffffffffffffffffff == 0x00) { goto label_12D4; } var temp0 = arg0; memory[0x00:0x20] = temp0; memory[0x20:0x40] = 0x0109; var2 = storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x00:0x20] = temp0; memory[0x20:0x40] = 0x0109; var3 = storage[keccak256(memory[0x00:0x40]) + 0x01]; memory[0x00:0x20] = temp0; memory[0x20:0x40] = 0x0109; var var4 = keccak256(memory[0x00:0x40]) + 0x02; var var5 = memory[0x40:0x60]; var var6 = var5; var var7 = var4; var temp1 = storage[var7]; var var8 = (!(temp1 & 0x01) * 0x0100 - 0x01 & temp1) / 0x02; if (!var8) { label_1076: var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x00] = address(var2).call.gas(msg.gas - 0x8502).value(var3)(memory[temp2:temp2 + var6 - temp2]); var2 = 0xe7c957c06e9a662c1a6c77366179f5b702b97651dc28eee7d5bf1dff6e40bb4a; var3 = msg.sender; var temp3 = arg0; var4 = temp3; memory[0x00:0x20] = var4; memory[0x20:0x40] = 0x0109; var temp4 = storage[keccak256(memory[0x00:0x40]) + 0x01]; var5 = temp4; memory[0x00:0x20] = var4; memory[0x20:0x40] = 0x0109; var temp5 = storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffffffffffffffffffffffffffff; var6 = temp5; memory[0x00:0x20] = var4; memory[0x20:0x40] = 0x0109; var temp6 = keccak256(memory[0x00:0x40]) + 0x02; var7 = temp6; var temp7 = memory[0x40:0x60]; var8 = temp7; memory[var8:var8 + 0x20] = var3 & 0xffffffffffffffffffffffffffffffffffffffff; var temp8 = var8 + 0x20; memory[temp8:temp8 + 0x20] = var4; var temp9 = temp8 + 0x20; memory[temp9:temp9 + 0x20] = var5; var temp10 = temp9 + 0x20; memory[temp10:temp10 + 0x20] = var6 & 0xffffffffffffffffffffffffffffffffffffffff; var temp11 = temp10 + 0x20; var var9 = temp11; var temp12 = var9 + 0x20; memory[var9:var9 + 0x20] = temp12 - var8; var var11 = var7; var temp13 = storage[var11]; memory[temp12:temp12 + 0x20] = (!(temp13 & 0x01) * 0x0100 - 0x01 & temp13) / 0x02; var var10 = temp12 + 0x20; var temp14 = storage[var11]; var var12 = (!(temp14 & 0x01) * 0x0100 - 0x01 & temp14) / 0x02; if (!var12) { label_1200: var temp15 = memory[0x40:0x60]; log(memory[temp15:temp15 + var10 - temp15], [stack[-11]]); memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x0109; var temp16 = keccak256(memory[0x00:0x40]); var2 = temp16; var3 = 0x00; var temp17 = var2; storage[temp17] = storage[temp17] & ~0xffffffffffffffffffffffffffffffffffffffff; storage[var2 + 0x01] = 0x00; var temp18 = var2 + 0x02; var4 = temp18; var temp19 = storage[var4]; var5 = (!(temp19 & 0x01) * 0x0100 - 0x01 & temp19) / 0x02; storage[var4] = 0x00; if (0x1f >= var5) { goto label_12C6; } memory[0x00:0x20] = var4; var4 = 0x12c5; var5 = keccak256(memory[0x00:0x20]) + (var5 + 0x1f) / 0x20; var6 = keccak256(memory[0x00:0x20]); var4 = func_12A7(var5, var6); label_12C6: return 0x01; } else if (0x1f < var12) { var temp20 = var10; var temp21 = temp20 + var12; var10 = temp21; memory[0x00:0x20] = var11; var temp22 = keccak256(memory[0x00:0x20]); memory[temp20:temp20 + 0x20] = storage[temp22]; var11 = temp22 + 0x01; var12 = temp20 + 0x20; if (var10 <= var12) { goto label_11F7; } label_11E3: var temp23 = var11; var temp24 = var12; memory[temp24:temp24 + 0x20] = storage[temp23]; var11 = temp23 + 0x01; var12 = temp24 + 0x20; if (var10 > var12) { goto label_11E3; } label_11F7: var temp25 = var10; var temp26 = temp25 + (var12 - temp25 & 0x1f); var12 = temp25; var10 = temp26; goto label_1200; } else { var temp27 = var10; memory[temp27:temp27 + 0x20] = storage[var11] / 0x0100 * 0x0100; var12 = var12; var10 = temp27 + 0x20; goto label_1200; } } else if (0x1f < var8) { var temp28 = var6; var temp29 = temp28 + var8; var6 = temp29; memory[0x00:0x20] = var7; var temp30 = keccak256(memory[0x00:0x20]); memory[temp28:temp28 + 0x20] = storage[temp30]; var7 = temp30 + 0x01; var8 = temp28 + 0x20; if (var6 <= var8) { goto label_106D; } label_1059: var temp31 = var7; var temp32 = var8; memory[temp32:temp32 + 0x20] = storage[temp31]; var7 = temp31 + 0x01; var8 = temp32 + 0x20; if (var6 > var8) { goto label_1059; } label_106D: var temp33 = var6; var temp34 = temp33 + (var8 - temp33 & 0x1f); var8 = temp33; var6 = temp34; goto label_1076; } else { var temp35 = var6; memory[temp35:temp35 + 0x20] = storage[var7] / 0x0100 * 0x0100; var8 = var8; var6 = temp35 + 0x20; goto label_1076; } } } function func_12A7(var arg0, var arg1) returns (var r0) { if (arg0 <= arg1) { return arg0; } var temp0 = arg1; storage[temp0] = 0x00; arg1 = temp0 + 0x01; r0 = func_12A7(arg0, arg1); // Error: Could not resolve method call return address! } function func_12DB(var arg0) returns (var r0) { var var0 = 0x00; var var2 = 0x00; var var3 = 0x00; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x0102; var var1 = storage[keccak256(memory[0x00:0x40])]; if (var1 == 0x00) { goto label_1535; } memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x0103; var2 = keccak256(memory[0x00:0x40]); if (storage[var2] != 0x00) { label_13FD: var3 = 0x02 ** var1; if (storage[var2 + 0x01] & var3 != 0x00) { label_1534: label_1535: return var0; } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = msg.sender; var temp1 = temp0 + 0x20; memory[temp1:temp1 + 0x20] = arg0; var temp2 = memory[0x40:0x60]; log(memory[temp2:temp2 + (temp1 + 0x20) - temp2], [0xe1c52dc63b719ade82e8bea94cc41a0d5d28e4aaf536adb5e9cccc9ff8c1aeda]); if (storage[var2] > 0x01) { var temp3 = var2; var temp4 = temp3; storage[temp4] = storage[temp4] - 0x01; var temp5 = temp3 + 0x01; storage[temp5] = storage[temp5] | var3; goto label_1534; } else { var var4 = 0x0104; memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x0103; var var5 = storage[keccak256(memory[0x00:0x40]) + 0x02]; if (var5 >= storage[var4]) { label_0002: memory[0x40:0x60] = var5; if (!msg.data.length) { label_00F8: var5 = 0x015e; if (msg.value <= 0x00) { func_015B(); stop(); } else { func_0106(); stop(); } } else { var5 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000; if (var5 == 0x173825d9) { var var6 = 0x0176; var var7 = msg.data[0x04:0x24]; removeOwner(var7); stop(); } else if (var5 == 0x2f54bf6e) { var6 = 0x018e; var7 = msg.data[0x04:0x24]; var6 = isOwner(var7); var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = var6; var temp7 = memory[0x40:0x60]; return memory[temp7:temp7 + (temp6 + 0x20) - temp7]; } else if (var5 == 0x4123cb6b) { var6 = 0x01b1; var7 = m_numOwners(); var temp8 = memory[0x40:0x60]; memory[temp8:temp8 + 0x20] = var7; var temp9 = memory[0x40:0x60]; return memory[temp9:temp9 + (temp8 + 0x20) - temp9]; } else if (var5 == 0x52375093) { var6 = 0x01d4; var7 = m_lastDay(); var temp10 = memory[0x40:0x60]; memory[temp10:temp10 + 0x20] = var7; var temp11 = memory[0x40:0x60]; return memory[temp11:temp11 + (temp10 + 0x20) - temp11]; } else if (var5 == 0x54fd4d50) { var6 = 0x01f7; var7 = version(); var temp12 = memory[0x40:0x60]; memory[temp12:temp12 + 0x20] = var7; var temp13 = memory[0x40:0x60]; return memory[temp13:temp13 + (temp12 + 0x20) - temp13]; } else if (var5 == 0x5c52c2f5) { var6 = 0x021a; resetSpentToday(); stop(); } else if (var5 == 0x659010e7) { var6 = 0x0229; var7 = m_spentToday(); var temp14 = memory[0x40:0x60]; memory[temp14:temp14 + 0x20] = var7; var temp15 = memory[0x40:0x60]; return memory[temp15:temp15 + (temp14 + 0x20) - temp15]; } else if (var5 == 0x7065cb48) { var6 = 0x0255; var7 = msg.data[0x04:0x24]; addOwner(var7); stop(); } else if (var5 == 0x746c9171) { var6 = 0x0264; var7 = m_required(); var temp16 = memory[0x40:0x60]; memory[temp16:temp16 + 0x20] = var7; var temp17 = memory[0x40:0x60]; return memory[temp17:temp17 + (temp16 + 0x20) - temp17]; } else if (var5 == 0x797af627) { var6 = 0x0290; var7 = msg.data[0x04:0x24]; var6 = confirm(var7); var temp18 = memory[0x40:0x60]; memory[temp18:temp18 + 0x20] = var6; var temp19 = memory[0x40:0x60]; return memory[temp19:temp19 + (temp18 + 0x20) - temp19]; } else if (var5 == 0xb20d30a9) { var6 = 0x02bc; var7 = msg.data[0x04:0x24]; setDailyLimit(var7); stop(); } else if (var5 == 0xb61d27f6) { var6 = 0x02f1; var7 = msg.data[0x04:0x24]; var var8 = msg.data[0x24:0x44]; var temp20 = msg.data[0x44:0x64] + 0x04; var var10 = msg.data[temp20:temp20 + 0x20]; var var9 = temp20 + 0x20; var6 = execute(var7, var8, var9, var10); label_02F1: var temp21 = memory[0x40:0x60]; memory[temp21:temp21 + 0x20] = var6; var temp22 = memory[0x40:0x60]; return memory[temp22:temp22 + (temp21 + 0x20) - temp22]; } else if (var5 == 0xb75c7dc6) { var6 = 0x031d; var7 = msg.data[0x04:0x24]; revoke(var7); stop(); } else if (var5 == 0xba51a6df) { var6 = 0x0335; var7 = msg.data[0x04:0x24]; changeRequirement(var7); stop(); } else if (var5 == 0xc2cf7326) { var6 = 0x0356; var7 = msg.data[0x04:0x24]; var8 = msg.data[0x24:0x44]; var6 = hasConfirmed(var7, var8); var temp23 = memory[0x40:0x60]; memory[temp23:temp23 + 0x20] = var6; var temp24 = memory[0x40:0x60]; return memory[temp24:temp24 + (temp23 + 0x20) - temp24]; } else if (var5 == 0xcbf0b0c0) { var6 = 0x0382; var7 = msg.data[0x04:0x24]; kill(var7); stop(); } else if (var5 == 0xf00d4b5d) { var6 = 0x03a3; var7 = msg.data[0x04:0x24]; var8 = msg.data[0x24:0x44]; changeOwner(var7, var8); stop(); } else if (var5 == 0xf1736d86) { var6 = 0x03b2; var7 = m_dailyLimit(); var temp25 = memory[0x40:0x60]; memory[temp25:temp25 + 0x20] = var7; var temp26 = memory[0x40:0x60]; return memory[temp26:temp26 + (temp25 + 0x20) - temp26]; } else { goto label_00F8; } } } else { memory[0x00:0x20] = var4; storage[var5 + keccak256(memory[0x00:0x20])] = 0x00; memory[0x00:0x20] = arg0; memory[0x20:0x40] = 0x0103; var temp27 = keccak256(memory[0x00:0x40]); storage[temp27] = 0x00; storage[temp27 + 0x01] = 0x00; storage[temp27 + 0x02] = 0x00; var0 = 0x01; goto label_1535; } } } } else { var temp28 = var2; storage[temp28] = storage[0x00]; storage[temp28 + 0x01] = 0x00; var4 = storage[0x0104]; var temp29 = var4 + 0x01; var6 = temp29; var5 = 0x0104; var temp30 = storage[var5]; var7 = temp30; storage[var5] = var6; if (!var7 > var6) { label_13C3: var temp31 = var2; storage[temp31 + 0x02] = var4; var4 = arg0; var5 = 0x0104; var6 = storage[temp31 + 0x02]; if (var6 >= storage[var5]) { goto label_0002; } memory[0x00:0x20] = var5; storage[var6 + keccak256(memory[0x00:0x20])] = var4; goto label_13FD; } else { memory[0x00:0x20] = var5; var temp32 = keccak256(memory[0x00:0x20]); var temp33 = temp32 + var7; var7 = 0x13c2; var8 = temp33; var9 = temp32 + var6; var7 = func_13A4(var8, var9); goto label_13C3; } } } function func_13A4(var arg0, var arg1) returns (var r0) { if (arg0 <= arg1) { return arg0; } var temp0 = arg1; storage[temp0] = 0x00; arg1 = temp0 + 0x01; r0 = func_13A4(arg0, arg1); // Error: Could not resolve method call return address! } function func_153D() returns (var r0) { var var0 = 0x00; var var1 = 0x01; if (var1 >= storage[0x01]) { label_16D2: return var0; } else { label_1554: var var2 = var1 < storage[0x01]; if (!var2) { label_1580: if (!var2) { var2 = storage[0x01] > 0x01; if (var2) { goto label_15A3; } label_15C4: if (!var2) { var2 = var1 < storage[0x01]; if (!var2) { label_1614: if (!var2) { label_1637: if (!var2) { label_16CD: if (var1 >= storage[0x01]) { goto label_16D2; } else { goto label_1554; } } else { var2 = 0x02; var var3 = storage[0x01]; if (var3 >= 0x0100) { label_0002: memory[0x40:0x60] = var3; if (!msg.data.length) { label_00F8: var3 = 0x015e; if (msg.value <= 0x00) { func_015B(); stop(); } else { func_0106(); stop(); } } else { var3 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000; if (var3 == 0x173825d9) { var var4 = 0x0176; var var5 = msg.data[0x04:0x24]; removeOwner(var5); stop(); } else if (var3 == 0x2f54bf6e) { var4 = 0x018e; var5 = msg.data[0x04:0x24]; var4 = isOwner(var5); var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = var4; var temp1 = memory[0x40:0x60]; return memory[temp1:temp1 + (temp0 + 0x20) - temp1]; } else if (var3 == 0x4123cb6b) { var4 = 0x01b1; var5 = m_numOwners(); var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = var5; var temp3 = memory[0x40:0x60]; return memory[temp3:temp3 + (temp2 + 0x20) - temp3]; } else if (var3 == 0x52375093) { var4 = 0x01d4; var5 = m_lastDay(); var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = var5; var temp5 = memory[0x40:0x60]; return memory[temp5:temp5 + (temp4 + 0x20) - temp5]; } else if (var3 == 0x54fd4d50) { var4 = 0x01f7; var5 = version(); var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = var5; var temp7 = memory[0x40:0x60]; return memory[temp7:temp7 + (temp6 + 0x20) - temp7]; } else if (var3 == 0x5c52c2f5) { var4 = 0x021a; resetSpentToday(); stop(); } else if (var3 == 0x659010e7) { var4 = 0x0229; var5 = m_spentToday(); var temp8 = memory[0x40:0x60]; memory[temp8:temp8 + 0x20] = var5; var temp9 = memory[0x40:0x60]; return memory[temp9:temp9 + (temp8 + 0x20) - temp9]; } else if (var3 == 0x7065cb48) { var4 = 0x0255; var5 = msg.data[0x04:0x24]; addOwner(var5); stop(); } else if (var3 == 0x746c9171) { var4 = 0x0264; var5 = m_required(); var temp10 = memory[0x40:0x60]; memory[temp10:temp10 + 0x20] = var5; var temp11 = memory[0x40:0x60]; return memory[temp11:temp11 + (temp10 + 0x20) - temp11]; } else if (var3 == 0x797af627) { var4 = 0x0290; var5 = msg.data[0x04:0x24]; var4 = confirm(var5); var temp12 = memory[0x40:0x60]; memory[temp12:temp12 + 0x20] = var4; var temp13 = memory[0x40:0x60]; return memory[temp13:temp13 + (temp12 + 0x20) - temp13]; } else if (var3 == 0xb20d30a9) { var4 = 0x02bc; var5 = msg.data[0x04:0x24]; setDailyLimit(var5); stop(); } else if (var3 == 0xb61d27f6) { var4 = 0x02f1; var5 = msg.data[0x04:0x24]; var var6 = msg.data[0x24:0x44]; var temp14 = msg.data[0x44:0x64] + 0x04; var var8 = msg.data[temp14:temp14 + 0x20]; var var7 = temp14 + 0x20; var4 = execute(var5, var6, var7, var8); label_02F1: var temp15 = memory[0x40:0x60]; memory[temp15:temp15 + 0x20] = var4; var temp16 = memory[0x40:0x60]; return memory[temp16:temp16 + (temp15 + 0x20) - temp16]; } else if (var3 == 0xb75c7dc6) { var4 = 0x031d; var5 = msg.data[0x04:0x24]; revoke(var5); stop(); } else if (var3 == 0xba51a6df) { var4 = 0x0335; var5 = msg.data[0x04:0x24]; changeRequirement(var5); stop(); } else if (var3 == 0xc2cf7326) { var4 = 0x0356; var5 = msg.data[0x04:0x24]; var6 = msg.data[0x24:0x44]; var4 = hasConfirmed(var5, var6); var temp17 = memory[0x40:0x60]; memory[temp17:temp17 + 0x20] = var4; var temp18 = memory[0x40:0x60]; return memory[temp18:temp18 + (temp17 + 0x20) - temp18]; } else if (var3 == 0xcbf0b0c0) { var4 = 0x0382; var5 = msg.data[0x04:0x24]; kill(var5); stop(); } else if (var3 == 0xf00d4b5d) { var4 = 0x03a3; var5 = msg.data[0x04:0x24]; var6 = msg.data[0x24:0x44]; changeOwner(var5, var6); stop(); } else if (var3 == 0xf1736d86) { var4 = 0x03b2; var5 = m_dailyLimit(); var temp19 = memory[0x40:0x60]; memory[temp19:temp19 + 0x20] = var5; var temp20 = memory[0x40:0x60]; return memory[temp20:temp20 + (temp19 + 0x20) - temp20]; } else { goto label_00F8; } } } else { var2 = storage[var3 + var2]; var3 = 0x02; var4 = var1; if (var4 >= 0x0100) { goto label_0002; } storage[var4 + var3] = var2; var2 = var1; var3 = 0x0102; var4 = 0x00; var5 = 0x02; var6 = var2; if (var6 >= 0x0100) { goto label_0002; } var temp21 = var4; memory[temp21:temp21 + 0x20] = storage[var6 + var5]; var temp22 = temp21 + 0x20; memory[temp22:temp22 + 0x20] = var3; storage[keccak256(memory[0x00:0x00 + temp22 + 0x20])] = var2; var2 = 0x00; var3 = 0x02; var4 = storage[0x01]; if (var4 >= 0x0100) { goto label_0002; } storage[var4 + var3] = var2; goto label_16CD; } } } else { var2 = 0x00; var3 = 0x02; var4 = var1; if (var4 >= 0x0100) { goto label_0002; } var2 = storage[var4 + var3] == var2; goto label_1637; } } else { var2 = 0x00; var3 = 0x02; var4 = storage[0x01]; if (var4 >= 0x0100) { goto label_0002; } var2 = storage[var4 + var3] != var2; goto label_1614; } } else { storage[0x01] = storage[0x01] - 0x01; var2 = storage[0x01] > 0x01; if (!var2) { goto label_15C4; } label_15A3: var2 = 0x00; var3 = 0x02; var4 = storage[0x01]; if (var4 >= 0x0100) { goto label_0002; } var2 = storage[var4 + var3] == var2; goto label_15C4; } } else { var1 = var1 + 0x01; goto label_1554; } } else { var2 = 0x00; var3 = 0x02; var4 = var1; if (var4 >= 0x0100) { goto label_0002; } var2 = storage[var4 + var3] != var2; goto label_1580; } } } function func_16D7(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x16e2; var var2 = msg.sender; var1 = isOwner(var2); if (!var1) { return var0; } var1 = storage[0x0107]; var2 = 0x16f6; var2 = func_1980(); if (var2 <= var1) { label_171B: var1 = storage[0x0106] + arg0 >= storage[0x0106]; if (!var1) { if (!var1) { label_1768: var0 = 0x00; label_1772: return var0; } else { label_174D: storage[0x0106] = storage[0x0106] + arg0; var0 = 0x01; goto label_1772; } } else if (storage[0x0106] + arg0 > storage[0x0105]) { goto label_1768; } else { goto label_174D; } } else { storage[0x0106] = 0x00; var1 = 0x1710; var1 = func_1980(); storage[0x0107] = var1; goto label_171B; } } function func_1777() { var var0 = storage[0x0104]; var var1 = 0x00; if (var1 >= var0) { label_1878: var var2 = 0x1880; func_1885(); return; } else { label_1795: var2 = 0x0109; var var3 = 0x00; var var4 = 0x0104; var var5 = var1; if (var5 >= storage[var4]) { memory[0x40:0x60] = var5; if (!msg.data.length) { label_00F8: var5 = 0x015e; if (msg.value <= 0x00) { func_015B(); stop(); } else { func_0106(); stop(); } } else { var5 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000; if (var5 == 0x173825d9) { var var6 = 0x0176; var var7 = msg.data[0x04:0x24]; removeOwner(var7); stop(); } else if (var5 == 0x2f54bf6e) { var6 = 0x018e; var7 = msg.data[0x04:0x24]; var6 = isOwner(var7); var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = var6; var temp1 = memory[0x40:0x60]; return memory[temp1:temp1 + (temp0 + 0x20) - temp1]; } else if (var5 == 0x4123cb6b) { var6 = 0x01b1; var7 = m_numOwners(); var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = var7; var temp3 = memory[0x40:0x60]; return memory[temp3:temp3 + (temp2 + 0x20) - temp3]; } else if (var5 == 0x52375093) { var6 = 0x01d4; var7 = m_lastDay(); var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = var7; var temp5 = memory[0x40:0x60]; return memory[temp5:temp5 + (temp4 + 0x20) - temp5]; } else if (var5 == 0x54fd4d50) { var6 = 0x01f7; var7 = version(); var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = var7; var temp7 = memory[0x40:0x60]; return memory[temp7:temp7 + (temp6 + 0x20) - temp7]; } else if (var5 == 0x5c52c2f5) { var6 = 0x021a; resetSpentToday(); stop(); } else if (var5 == 0x659010e7) { var6 = 0x0229; var7 = m_spentToday(); var temp8 = memory[0x40:0x60]; memory[temp8:temp8 + 0x20] = var7; var temp9 = memory[0x40:0x60]; return memory[temp9:temp9 + (temp8 + 0x20) - temp9]; } else if (var5 == 0x7065cb48) { var6 = 0x0255; var7 = msg.data[0x04:0x24]; addOwner(var7); stop(); } else if (var5 == 0x746c9171) { var6 = 0x0264; var7 = m_required(); var temp10 = memory[0x40:0x60]; memory[temp10:temp10 + 0x20] = var7; var temp11 = memory[0x40:0x60]; return memory[temp11:temp11 + (temp10 + 0x20) - temp11]; } else if (var5 == 0x797af627) { var6 = 0x0290; var7 = msg.data[0x04:0x24]; var6 = confirm(var7); var temp12 = memory[0x40:0x60]; memory[temp12:temp12 + 0x20] = var6; var temp13 = memory[0x40:0x60]; return memory[temp13:temp13 + (temp12 + 0x20) - temp13]; } else if (var5 == 0xb20d30a9) { var6 = 0x02bc; var7 = msg.data[0x04:0x24]; setDailyLimit(var7); stop(); } else if (var5 == 0xb61d27f6) { var6 = 0x02f1; var7 = msg.data[0x04:0x24]; var var8 = msg.data[0x24:0x44]; var temp14 = msg.data[0x44:0x64] + 0x04; var var10 = msg.data[temp14:temp14 + 0x20]; var var9 = temp14 + 0x20; var6 = execute(var7, var8, var9, var10); label_02F1: var temp15 = memory[0x40:0x60]; memory[temp15:temp15 + 0x20] = var6; var temp16 = memory[0x40:0x60]; return memory[temp16:temp16 + (temp15 + 0x20) - temp16]; } else if (var5 == 0xb75c7dc6) { var6 = 0x031d; var7 = msg.data[0x04:0x24]; revoke(var7); stop(); } else if (var5 == 0xba51a6df) { var6 = 0x0335; var7 = msg.data[0x04:0x24]; changeRequirement(var7); stop(); } else if (var5 == 0xc2cf7326) { var6 = 0x0356; var7 = msg.data[0x04:0x24]; var8 = msg.data[0x24:0x44]; var6 = hasConfirmed(var7, var8); var temp17 = memory[0x40:0x60]; memory[temp17:temp17 + 0x20] = var6; var temp18 = memory[0x40:0x60]; return memory[temp18:temp18 + (temp17 + 0x20) - temp18]; } else if (var5 == 0xcbf0b0c0) { var6 = 0x0382; var7 = msg.data[0x04:0x24]; kill(var7); stop(); } else if (var5 == 0xf00d4b5d) { var6 = 0x03a3; var7 = msg.data[0x04:0x24]; var8 = msg.data[0x24:0x44]; changeOwner(var7, var8); stop(); } else if (var5 == 0xf1736d86) { var6 = 0x03b2; var7 = m_dailyLimit(); var temp19 = memory[0x40:0x60]; memory[temp19:temp19 + 0x20] = var7; var temp20 = memory[0x40:0x60]; return memory[temp20:temp20 + (temp19 + 0x20) - temp20]; } else { goto label_00F8; } } } else { memory[0x00:0x20] = var4; var temp21 = var3; memory[temp21:temp21 + 0x20] = storage[var5 + keccak256(memory[0x00:0x20])]; var temp22 = temp21 + 0x20; memory[temp22:temp22 + 0x20] = var2; var temp23 = keccak256(memory[0x00:0x00 + temp22 + 0x20]); var2 = temp23; var3 = 0x00; var temp24 = var2; storage[temp24] = storage[temp24] & ~0xffffffffffffffffffffffffffffffffffffffff; storage[var2 + 0x01] = 0x00; var temp25 = var2 + 0x02; var4 = temp25; var temp26 = storage[var4]; var5 = (!(temp26 & 0x01) * 0x0100 - 0x01 & temp26) / 0x02; storage[var4] = 0x00; if (0x1f >= var5) { goto label_1867; } memory[0x00:0x20] = var4; var4 = 0x1866; var5 = keccak256(memory[0x00:0x20]) + (var5 + 0x1f) / 0x20; var6 = keccak256(memory[0x00:0x20]); var4 = func_1848(var5, var6); label_1867: var1 = var1 + 0x01; if (var1 >= var0) { goto label_1878; } else { goto label_1795; } } } } function func_1848(var arg0, var arg1) returns (var r0) { if (arg0 <= arg1) { return arg0; } var temp0 = arg1; storage[temp0] = 0x00; arg1 = temp0 + 0x01; r0 = func_1848(arg0, arg1); // Error: Could not resolve method call return address! } function func_1885() { var var0 = storage[0x0104]; var var1 = 0x00; if (var1 >= var0) { label_1938: var temp0 = storage[0x0104]; storage[0x0104] = 0x00; memory[0x00:0x20] = 0x0104; var var2 = 0x1979; var var3 = keccak256(memory[0x00:0x20]) + temp0; var var4 = keccak256(memory[0x00:0x20]); var2 = func_195B(var3, var4); return; } else { label_18A3: var2 = 0x00; var3 = 0x0104; var4 = var1; if (var4 >= storage[var3]) { label_0002: memory[0x40:0x60] = var4; if (!msg.data.length) { label_00F8: var4 = 0x015e; if (msg.value <= 0x00) { func_015B(); stop(); } else { func_0106(); stop(); } } else { var4 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000; if (var4 == 0x173825d9) { var var5 = 0x0176; var var6 = msg.data[0x04:0x24]; removeOwner(var6); stop(); } else if (var4 == 0x2f54bf6e) { var5 = 0x018e; var6 = msg.data[0x04:0x24]; var5 = isOwner(var6); var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = var5; var temp2 = memory[0x40:0x60]; return memory[temp2:temp2 + (temp1 + 0x20) - temp2]; } else if (var4 == 0x4123cb6b) { var5 = 0x01b1; var6 = m_numOwners(); var temp3 = memory[0x40:0x60]; memory[temp3:temp3 + 0x20] = var6; var temp4 = memory[0x40:0x60]; return memory[temp4:temp4 + (temp3 + 0x20) - temp4]; } else if (var4 == 0x52375093) { var5 = 0x01d4; var6 = m_lastDay(); var temp5 = memory[0x40:0x60]; memory[temp5:temp5 + 0x20] = var6; var temp6 = memory[0x40:0x60]; return memory[temp6:temp6 + (temp5 + 0x20) - temp6]; } else if (var4 == 0x54fd4d50) { var5 = 0x01f7; var6 = version(); var temp7 = memory[0x40:0x60]; memory[temp7:temp7 + 0x20] = var6; var temp8 = memory[0x40:0x60]; return memory[temp8:temp8 + (temp7 + 0x20) - temp8]; } else if (var4 == 0x5c52c2f5) { var5 = 0x021a; resetSpentToday(); stop(); } else if (var4 == 0x659010e7) { var5 = 0x0229; var6 = m_spentToday(); var temp9 = memory[0x40:0x60]; memory[temp9:temp9 + 0x20] = var6; var temp10 = memory[0x40:0x60]; return memory[temp10:temp10 + (temp9 + 0x20) - temp10]; } else if (var4 == 0x7065cb48) { var5 = 0x0255; var6 = msg.data[0x04:0x24]; addOwner(var6); stop(); } else if (var4 == 0x746c9171) { var5 = 0x0264; var6 = m_required(); var temp11 = memory[0x40:0x60]; memory[temp11:temp11 + 0x20] = var6; var temp12 = memory[0x40:0x60]; return memory[temp12:temp12 + (temp11 + 0x20) - temp12]; } else if (var4 == 0x797af627) { var5 = 0x0290; var6 = msg.data[0x04:0x24]; var5 = confirm(var6); var temp13 = memory[0x40:0x60]; memory[temp13:temp13 + 0x20] = var5; var temp14 = memory[0x40:0x60]; return memory[temp14:temp14 + (temp13 + 0x20) - temp14]; } else if (var4 == 0xb20d30a9) { var5 = 0x02bc; var6 = msg.data[0x04:0x24]; setDailyLimit(var6); stop(); } else if (var4 == 0xb61d27f6) { var5 = 0x02f1; var6 = msg.data[0x04:0x24]; var var7 = msg.data[0x24:0x44]; var temp15 = msg.data[0x44:0x64] + 0x04; var var9 = msg.data[temp15:temp15 + 0x20]; var var8 = temp15 + 0x20; var5 = execute(var6, var7, var8, var9); label_02F1: var temp16 = memory[0x40:0x60]; memory[temp16:temp16 + 0x20] = var5; var temp17 = memory[0x40:0x60]; return memory[temp17:temp17 + (temp16 + 0x20) - temp17]; } else if (var4 == 0xb75c7dc6) { var5 = 0x031d; var6 = msg.data[0x04:0x24]; revoke(var6); stop(); } else if (var4 == 0xba51a6df) { var5 = 0x0335; var6 = msg.data[0x04:0x24]; changeRequirement(var6); stop(); } else if (var4 == 0xc2cf7326) { var5 = 0x0356; var6 = msg.data[0x04:0x24]; var7 = msg.data[0x24:0x44]; var5 = hasConfirmed(var6, var7); var temp18 = memory[0x40:0x60]; memory[temp18:temp18 + 0x20] = var5; var temp19 = memory[0x40:0x60]; return memory[temp19:temp19 + (temp18 + 0x20) - temp19]; } else if (var4 == 0xcbf0b0c0) { var5 = 0x0382; var6 = msg.data[0x04:0x24]; kill(var6); stop(); } else if (var4 == 0xf00d4b5d) { var5 = 0x03a3; var6 = msg.data[0x04:0x24]; var7 = msg.data[0x24:0x44]; changeOwner(var6, var7); stop(); } else if (var4 == 0xf1736d86) { var5 = 0x03b2; var6 = m_dailyLimit(); var temp20 = memory[0x40:0x60]; memory[temp20:temp20 + 0x20] = var6; var temp21 = memory[0x40:0x60]; return memory[temp21:temp21 + (temp20 + 0x20) - temp21]; } else { goto label_00F8; } } } else { memory[0x00:0x20] = var3; if (storage[var4 + keccak256(memory[0x00:0x20])] == var2) { label_192A: var1 = var1 + 0x01; if (var1 >= var0) { goto label_1938; } else { goto label_18A3; } } else { var2 = 0x0103; var3 = 0x00; var4 = 0x0104; var5 = var1; if (var5 >= storage[var4]) { goto label_0002; } memory[0x00:0x20] = var4; var temp22 = var3; memory[temp22:temp22 + 0x20] = storage[var5 + keccak256(memory[0x00:0x20])]; var temp23 = temp22 + 0x20; memory[temp23:temp23 + 0x20] = var2; var temp24 = keccak256(memory[0x00:0x00 + temp23 + 0x20]); storage[temp24] = 0x00; storage[temp24 + 0x01] = 0x00; storage[temp24 + 0x02] = 0x00; goto label_192A; } } } } function func_195B(var arg0, var arg1) returns (var r0) { if (arg0 <= arg1) { return arg0; } var temp0 = arg1; storage[temp0] = 0x00; arg1 = temp0 + 0x01; r0 = func_195B(arg0, arg1); // Error: Could not resolve method call return address! } function func_1980() returns (var r0) { var var0 = block.timestamp / 0x015180; return var0; } }

Disassembly

label_0000: // Inputs[1] { @0005 msg.data.length } 0000 60 PUSH1 0x60 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 36 CALLDATASIZE 0006 15 ISZERO 0007 61 PUSH2 0x00f8 000A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x60 } // Block ends with conditional jump to 0x00f8, if !msg.data.length label_000B: // Incoming jump from 0x000A, if not !msg.data.length // Incoming jump from 0x000A, if not !msg.data.length // Inputs[1] { @000D msg.data[0x00:0x20] } 000B 60 PUSH1 0x00 000D 35 CALLDATALOAD 000E 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 002C 90 SWAP1 002D 04 DIV 002E 80 DUP1 002F 63 PUSH4 0x173825d9 0034 14 EQ 0035 61 PUSH2 0x0160 0038 57 *JUMPI // Stack delta = +1 // Outputs[1] { @002D stack[0] = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x0160, if 0x173825d9 == msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 label_0039: // Incoming jump from 0x0038, if not 0x173825d9 == msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0039 stack[-1] } 0039 80 DUP1 003A 63 PUSH4 0x2f54bf6e 003F 14 EQ 0040 61 PUSH2 0x0178 0043 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0178, if 0x2f54bf6e == stack[-1] label_0044: // Incoming jump from 0x0043, if not 0x2f54bf6e == stack[-1] // Inputs[1] { @0044 stack[-1] } 0044 80 DUP1 0045 63 PUSH4 0x4123cb6b 004A 14 EQ 004B 61 PUSH2 0x01a4 004E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a4, if 0x4123cb6b == stack[-1] label_004F: // Incoming jump from 0x004E, if not 0x4123cb6b == stack[-1] // Inputs[1] { @004F stack[-1] } 004F 80 DUP1 0050 63 PUSH4 0x52375093 0055 14 EQ 0056 61 PUSH2 0x01c7 0059 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c7, if 0x52375093 == stack[-1] label_005A: // Incoming jump from 0x0059, if not 0x52375093 == stack[-1] // Inputs[1] { @005A stack[-1] } 005A 80 DUP1 005B 63 PUSH4 0x54fd4d50 0060 14 EQ 0061 61 PUSH2 0x01ea 0064 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ea, if 0x54fd4d50 == stack[-1] label_0065: // Incoming jump from 0x0064, if not 0x54fd4d50 == stack[-1] // Inputs[1] { @0065 stack[-1] } 0065 80 DUP1 0066 63 PUSH4 0x5c52c2f5 006B 14 EQ 006C 61 PUSH2 0x020d 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x020d, if 0x5c52c2f5 == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0x5c52c2f5 == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0x659010e7 0076 14 EQ 0077 61 PUSH2 0x021c 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x021c, if 0x659010e7 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0x659010e7 == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0x7065cb48 0081 14 EQ 0082 61 PUSH2 0x023f 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023f, if 0x7065cb48 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0x7065cb48 == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0x746c9171 008C 14 EQ 008D 61 PUSH2 0x0257 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0257, if 0x746c9171 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0x746c9171 == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0x797af627 0097 14 EQ 0098 61 PUSH2 0x027a 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x027a, if 0x797af627 == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0x797af627 == stack[-1] // Inputs[1] { @009C stack[-1] } 009C 80 DUP1 009D 63 PUSH4 0xb20d30a9 00A2 14 EQ 00A3 61 PUSH2 0x02a6 00A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a6, if 0xb20d30a9 == stack[-1] label_00A7: // Incoming jump from 0x00A6, if not 0xb20d30a9 == stack[-1] // Inputs[1] { @00A7 stack[-1] } 00A7 80 DUP1 00A8 63 PUSH4 0xb61d27f6 00AD 14 EQ 00AE 61 PUSH2 0x02be 00B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02be, if 0xb61d27f6 == stack[-1] label_00B2: // Incoming jump from 0x00B1, if not 0xb61d27f6 == stack[-1] // Inputs[1] { @00B2 stack[-1] } 00B2 80 DUP1 00B3 63 PUSH4 0xb75c7dc6 00B8 14 EQ 00B9 61 PUSH2 0x0307 00BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0307, if 0xb75c7dc6 == stack[-1] label_00BD: // Incoming jump from 0x00BC, if not 0xb75c7dc6 == stack[-1] // Inputs[1] { @00BD stack[-1] } 00BD 80 DUP1 00BE 63 PUSH4 0xba51a6df 00C3 14 EQ 00C4 61 PUSH2 0x031f 00C7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x031f, if 0xba51a6df == stack[-1] label_00C8: // Incoming jump from 0x00C7, if not 0xba51a6df == stack[-1] // Inputs[1] { @00C8 stack[-1] } 00C8 80 DUP1 00C9 63 PUSH4 0xc2cf7326 00CE 14 EQ 00CF 61 PUSH2 0x0337 00D2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0337, if 0xc2cf7326 == stack[-1] label_00D3: // Incoming jump from 0x00D2, if not 0xc2cf7326 == stack[-1] // Inputs[1] { @00D3 stack[-1] } 00D3 80 DUP1 00D4 63 PUSH4 0xcbf0b0c0 00D9 14 EQ 00DA 61 PUSH2 0x036c 00DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036c, if 0xcbf0b0c0 == stack[-1] label_00DE: // Incoming jump from 0x00DD, if not 0xcbf0b0c0 == stack[-1] // Inputs[1] { @00DE stack[-1] } 00DE 80 DUP1 00DF 63 PUSH4 0xf00d4b5d 00E4 14 EQ 00E5 61 PUSH2 0x0384 00E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0384, if 0xf00d4b5d == stack[-1] label_00E9: // Incoming jump from 0x00E8, if not 0xf00d4b5d == stack[-1] // Inputs[1] { @00E9 stack[-1] } 00E9 80 DUP1 00EA 63 PUSH4 0xf1736d86 00EF 14 EQ 00F0 61 PUSH2 0x03a5 00F3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a5, if 0xf1736d86 == stack[-1] label_00F4: // Incoming jump from 0x00F3, if not 0xf1736d86 == stack[-1] 00F4 61 PUSH2 0x00f8 00F7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00f8 label_00F8: // Incoming jump from 0x000A, if !msg.data.length // Incoming jump from 0x000A, if !msg.data.length // Incoming jump from 0x00F7 // Inputs[1] { @00FF msg.value } 00F8 5B JUMPDEST 00F9 61 PUSH2 0x015e 00FC 5B JUMPDEST 00FD 60 PUSH1 0x00 00FF 34 CALLVALUE 0100 11 GT 0101 15 ISZERO 0102 61 PUSH2 0x015b 0105 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00F9 stack[0] = 0x015e } // Block ends with conditional call to 0x015b, returns to 0x015E, if !(msg.value > 0x00) label_0106: // Incoming call from 0x0105, returns to 0x015E, if not !(msg.value > 0x00) // Inputs[6] // { // @0127 msg.sender // @0128 msg.value // @012B memory[0x40:0x60] // @0155 memory[0x40:0x60] // @015A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @015D stack[-1] // } 0106 7F PUSH32 0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c 0127 33 CALLER 0128 34 CALLVALUE 0129 60 PUSH1 0x40 012B 51 MLOAD 012C 80 DUP1 012D 83 DUP4 012E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0143 16 AND 0144 81 DUP2 0145 52 MSTORE 0146 60 PUSH1 0x20 0148 01 ADD 0149 82 DUP3 014A 81 DUP2 014B 52 MSTORE 014C 60 PUSH1 0x20 014E 01 ADD 014F 92 SWAP3 0150 50 POP 0151 50 POP 0152 50 POP 0153 60 PUSH1 0x40 0155 51 MLOAD 0156 80 DUP1 0157 91 SWAP2 0158 03 SUB 0159 90 SWAP1 015A A1 LOG1 015B 5B JUMPDEST 015C 5B JUMPDEST 015D 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0145 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @014B memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = msg.value // @015A log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c]); // } // Block ends with unconditional jump to stack[-1] label_015E: // Incoming return from call to 0x015B at 0x0105 // Incoming return from call to 0x0106 at 0x0105 015E 5B JUMPDEST 015F 00 *STOP // Stack delta = +0 // Outputs[1] { @015F stop(); } // Block terminates label_0160: // Incoming jump from 0x0038, if 0x173825d9 == msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0168 msg.data[0x04:0x24] } 0160 5B JUMPDEST 0161 61 PUSH2 0x0176 0164 60 PUSH1 0x04 0166 80 DUP1 0167 80 DUP1 0168 35 CALLDATALOAD 0169 90 SWAP1 016A 60 PUSH1 0x20 016C 01 ADD 016D 90 SWAP1 016E 91 SWAP2 016F 90 SWAP1 0170 50 POP 0171 50 POP 0172 61 PUSH2 0x07c4 0175 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0161 stack[0] = 0x0176 // @016E stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x07c4, returns to 0x0176 label_0176: // Incoming return from call to 0x07C4 at 0x0175 0176 5B JUMPDEST 0177 00 *STOP // Stack delta = +0 // Outputs[1] { @0177 stop(); } // Block terminates label_0178: // Incoming jump from 0x0043, if 0x2f54bf6e == stack[-1] // Inputs[1] { @0180 msg.data[0x04:0x24] } 0178 5B JUMPDEST 0179 61 PUSH2 0x018e 017C 60 PUSH1 0x04 017E 80 DUP1 017F 80 DUP1 0180 35 CALLDATALOAD 0181 90 SWAP1 0182 60 PUSH1 0x20 0184 01 ADD 0185 90 SWAP1 0186 91 SWAP2 0187 90 SWAP1 0188 50 POP 0189 50 POP 018A 61 PUSH2 0x09a5 018D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0179 stack[0] = 0x018e // @0186 stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x09a5, returns to 0x018E label_018E: // Incoming return from call to 0x09A5 at 0x018D // Inputs[4] // { // @0191 memory[0x40:0x60] // @0193 stack[-1] // @019E memory[0x40:0x60] // @01A3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 018E 5B JUMPDEST 018F 60 PUSH1 0x40 0191 51 MLOAD 0192 80 DUP1 0193 82 DUP3 0194 81 DUP2 0195 52 MSTORE 0196 60 PUSH1 0x20 0198 01 ADD 0199 91 SWAP2 019A 50 POP 019B 50 POP 019C 60 PUSH1 0x40 019E 51 MLOAD 019F 80 DUP1 01A0 91 SWAP2 01A1 03 SUB 01A2 90 SWAP1 01A3 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0195 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @01A3 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_01A4: // Incoming jump from 0x004E, if 0x4123cb6b == stack[-1] 01A4 5B JUMPDEST 01A5 61 PUSH2 0x01b1 01A8 60 PUSH1 0x04 01AA 80 DUP1 01AB 50 POP 01AC 50 POP 01AD 61 PUSH2 0x0a91 01B0 56 *JUMP // Stack delta = +1 // Outputs[1] { @01A5 stack[0] = 0x01b1 } // Block ends with call to 0x0a91, returns to 0x01B1 label_01B1: // Incoming return from call to 0x0A91 at 0x01B0 // Inputs[4] // { // @01B4 memory[0x40:0x60] // @01B6 stack[-1] // @01C1 memory[0x40:0x60] // @01C6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01B1 5B JUMPDEST 01B2 60 PUSH1 0x40 01B4 51 MLOAD 01B5 80 DUP1 01B6 82 DUP3 01B7 81 DUP2 01B8 52 MSTORE 01B9 60 PUSH1 0x20 01BB 01 ADD 01BC 91 SWAP2 01BD 50 POP 01BE 50 POP 01BF 60 PUSH1 0x40 01C1 51 MLOAD 01C2 80 DUP1 01C3 91 SWAP2 01C4 03 SUB 01C5 90 SWAP1 01C6 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @01C6 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_01C7: // Incoming jump from 0x0059, if 0x52375093 == stack[-1] 01C7 5B JUMPDEST 01C8 61 PUSH2 0x01d4 01CB 60 PUSH1 0x04 01CD 80 DUP1 01CE 50 POP 01CF 50 POP 01D0 61 PUSH2 0x0b38 01D3 56 *JUMP // Stack delta = +1 // Outputs[1] { @01C8 stack[0] = 0x01d4 } // Block ends with call to 0x0b38, returns to 0x01D4 label_01D4: // Incoming return from call to 0x0B38 at 0x01D3 // Inputs[4] // { // @01D7 memory[0x40:0x60] // @01D9 stack[-1] // @01E4 memory[0x40:0x60] // @01E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01D4 5B JUMPDEST 01D5 60 PUSH1 0x40 01D7 51 MLOAD 01D8 80 DUP1 01D9 82 DUP3 01DA 81 DUP2 01DB 52 MSTORE 01DC 60 PUSH1 0x20 01DE 01 ADD 01DF 91 SWAP2 01E0 50 POP 01E1 50 POP 01E2 60 PUSH1 0x40 01E4 51 MLOAD 01E5 80 DUP1 01E6 91 SWAP2 01E7 03 SUB 01E8 90 SWAP1 01E9 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01DB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @01E9 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_01EA: // Incoming jump from 0x0064, if 0x54fd4d50 == stack[-1] 01EA 5B JUMPDEST 01EB 61 PUSH2 0x01f7 01EE 60 PUSH1 0x04 01F0 80 DUP1 01F1 50 POP 01F2 50 POP 01F3 61 PUSH2 0x0b42 01F6 56 *JUMP // Stack delta = +1 // Outputs[1] { @01EB stack[0] = 0x01f7 } // Block ends with call to 0x0b42, returns to 0x01F7 label_01F7: // Incoming return from call to 0x0B42 at 0x01F6 // Inputs[4] // { // @01FA memory[0x40:0x60] // @01FC stack[-1] // @0207 memory[0x40:0x60] // @020C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01F7 5B JUMPDEST 01F8 60 PUSH1 0x40 01FA 51 MLOAD 01FB 80 DUP1 01FC 82 DUP3 01FD 81 DUP2 01FE 52 MSTORE 01FF 60 PUSH1 0x20 0201 01 ADD 0202 91 SWAP2 0203 50 POP 0204 50 POP 0205 60 PUSH1 0x40 0207 51 MLOAD 0208 80 DUP1 0209 91 SWAP2 020A 03 SUB 020B 90 SWAP1 020C F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01FE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @020C return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_020D: // Incoming jump from 0x006F, if 0x5c52c2f5 == stack[-1] 020D 5B JUMPDEST 020E 61 PUSH2 0x021a 0211 60 PUSH1 0x04 0213 80 DUP1 0214 50 POP 0215 50 POP 0216 61 PUSH2 0x0adf 0219 56 *JUMP // Stack delta = +1 // Outputs[1] { @020E stack[0] = 0x021a } // Block ends with call to 0x0adf, returns to 0x021A label_021A: // Incoming return from call to 0x0ADF at 0x0219 021A 5B JUMPDEST 021B 00 *STOP // Stack delta = +0 // Outputs[1] { @021B stop(); } // Block terminates label_021C: // Incoming jump from 0x007A, if 0x659010e7 == stack[-1] 021C 5B JUMPDEST 021D 61 PUSH2 0x0229 0220 60 PUSH1 0x04 0222 80 DUP1 0223 50 POP 0224 50 POP 0225 61 PUSH2 0x0b2e 0228 56 *JUMP // Stack delta = +1 // Outputs[1] { @021D stack[0] = 0x0229 } // Block ends with call to 0x0b2e, returns to 0x0229 label_0229: // Incoming return from call to 0x0B2E at 0x0228 // Inputs[4] // { // @022C memory[0x40:0x60] // @022E stack[-1] // @0239 memory[0x40:0x60] // @023E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0229 5B JUMPDEST 022A 60 PUSH1 0x40 022C 51 MLOAD 022D 80 DUP1 022E 82 DUP3 022F 81 DUP2 0230 52 MSTORE 0231 60 PUSH1 0x20 0233 01 ADD 0234 91 SWAP2 0235 50 POP 0236 50 POP 0237 60 PUSH1 0x40 0239 51 MLOAD 023A 80 DUP1 023B 91 SWAP2 023C 03 SUB 023D 90 SWAP1 023E F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0230 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @023E return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_023F: // Incoming jump from 0x0085, if 0x7065cb48 == stack[-1] // Inputs[1] { @0247 msg.data[0x04:0x24] } 023F 5B JUMPDEST 0240 61 PUSH2 0x0255 0243 60 PUSH1 0x04 0245 80 DUP1 0246 80 DUP1 0247 35 CALLDATALOAD 0248 90 SWAP1 0249 60 PUSH1 0x20 024B 01 ADD 024C 90 SWAP1 024D 91 SWAP2 024E 90 SWAP1 024F 50 POP 0250 50 POP 0251 61 PUSH2 0x066e 0254 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0240 stack[0] = 0x0255 // @024D stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x066e, returns to 0x0255 label_0255: // Incoming return from call to 0x066E at 0x0254 // Incoming return from call to 0x066E at 0x0254 0255 5B JUMPDEST 0256 00 *STOP // Stack delta = +0 // Outputs[1] { @0256 stop(); } // Block terminates label_0257: // Incoming jump from 0x0090, if 0x746c9171 == stack[-1] 0257 5B JUMPDEST 0258 61 PUSH2 0x0264 025B 60 PUSH1 0x04 025D 80 DUP1 025E 50 POP 025F 50 POP 0260 61 PUSH2 0x0a88 0263 56 *JUMP // Stack delta = +1 // Outputs[1] { @0258 stack[0] = 0x0264 } // Block ends with call to 0x0a88, returns to 0x0264 label_0264: // Incoming return from call to 0x0A88 at 0x0263 // Inputs[4] // { // @0267 memory[0x40:0x60] // @0269 stack[-1] // @0274 memory[0x40:0x60] // @0279 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0264 5B JUMPDEST 0265 60 PUSH1 0x40 0267 51 MLOAD 0268 80 DUP1 0269 82 DUP3 026A 81 DUP2 026B 52 MSTORE 026C 60 PUSH1 0x20 026E 01 ADD 026F 91 SWAP2 0270 50 POP 0271 50 POP 0272 60 PUSH1 0x40 0274 51 MLOAD 0275 80 DUP1 0276 91 SWAP2 0277 03 SUB 0278 90 SWAP1 0279 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @026B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0279 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_027A: // Incoming jump from 0x009B, if 0x797af627 == stack[-1] // Inputs[1] { @0282 msg.data[0x04:0x24] } 027A 5B JUMPDEST 027B 61 PUSH2 0x0290 027E 60 PUSH1 0x04 0280 80 DUP1 0281 80 DUP1 0282 35 CALLDATALOAD 0283 90 SWAP1 0284 60 PUSH1 0x20 0286 01 ADD 0287 90 SWAP1 0288 91 SWAP2 0289 90 SWAP1 028A 50 POP 028B 50 POP 028C 61 PUSH2 0x0f0e 028F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @027B stack[0] = 0x0290 // @0288 stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x0f0e, returns to 0x0290 label_0290: // Incoming return from call to 0x0F0E at 0x028F // Inputs[4] // { // @0293 memory[0x40:0x60] // @0295 stack[-1] // @02A0 memory[0x40:0x60] // @02A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0290 5B JUMPDEST 0291 60 PUSH1 0x40 0293 51 MLOAD 0294 80 DUP1 0295 82 DUP3 0296 81 DUP2 0297 52 MSTORE 0298 60 PUSH1 0x20 029A 01 ADD 029B 91 SWAP2 029C 50 POP 029D 50 POP 029E 60 PUSH1 0x40 02A0 51 MLOAD 02A1 80 DUP1 02A2 91 SWAP2 02A3 03 SUB 02A4 90 SWAP1 02A5 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0297 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02A5 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02A6: // Incoming jump from 0x00A6, if 0xb20d30a9 == stack[-1] // Inputs[1] { @02AE msg.data[0x04:0x24] } 02A6 5B JUMPDEST 02A7 61 PUSH2 0x02bc 02AA 60 PUSH1 0x04 02AC 80 DUP1 02AD 80 DUP1 02AE 35 CALLDATALOAD 02AF 90 SWAP1 02B0 60 PUSH1 0x20 02B2 01 ADD 02B3 90 SWAP1 02B4 91 SWAP2 02B5 90 SWAP1 02B6 50 POP 02B7 50 POP 02B8 61 PUSH2 0x0a9a 02BB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @02A7 stack[0] = 0x02bc // @02B4 stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x0a9a, returns to 0x02BC label_02BC: // Incoming return from call to 0x0A9A at 0x02BB 02BC 5B JUMPDEST 02BD 00 *STOP // Stack delta = +0 // Outputs[1] { @02BD stop(); } // Block terminates label_02BE: // Incoming jump from 0x00B1, if 0xb61d27f6 == stack[-1] // Inputs[4] // { // @02C6 msg.data[0x04:0x24] // @02CF msg.data[0x24:0x44] // @02D8 msg.data[0x44:0x64] // @02E1 msg.data[0x04 + msg.data[0x44:0x64]:0x04 + msg.data[0x44:0x64] + 0x20] // } 02BE 5B JUMPDEST 02BF 61 PUSH2 0x02f1 02C2 60 PUSH1 0x04 02C4 80 DUP1 02C5 80 DUP1 02C6 35 CALLDATALOAD 02C7 90 SWAP1 02C8 60 PUSH1 0x20 02CA 01 ADD 02CB 90 SWAP1 02CC 91 SWAP2 02CD 90 SWAP1 02CE 80 DUP1 02CF 35 CALLDATALOAD 02D0 90 SWAP1 02D1 60 PUSH1 0x20 02D3 01 ADD 02D4 90 SWAP1 02D5 91 SWAP2 02D6 90 SWAP1 02D7 80 DUP1 02D8 35 CALLDATALOAD 02D9 90 SWAP1 02DA 60 PUSH1 0x20 02DC 01 ADD 02DD 90 SWAP1 02DE 82 DUP3 02DF 01 ADD 02E0 80 DUP1 02E1 35 CALLDATALOAD 02E2 90 SWAP1 02E3 60 PUSH1 0x20 02E5 01 ADD 02E6 91 SWAP2 02E7 90 SWAP1 02E8 91 SWAP2 02E9 92 SWAP3 02EA 90 SWAP1 02EB 50 POP 02EC 50 POP 02ED 61 PUSH2 0x0b9e 02F0 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @02BF stack[0] = 0x02f1 // @02CC stack[1] = msg.data[0x04:0x24] // @02D5 stack[2] = msg.data[0x24:0x44] // @02E8 stack[4] = msg.data[0x04 + msg.data[0x44:0x64]:0x04 + msg.data[0x44:0x64] + 0x20] // @02E9 stack[3] = 0x20 + 0x04 + msg.data[0x44:0x64] // } // Block ends with call to 0x0b9e, returns to 0x02F1 label_02F1: // Incoming return from call to 0x0B9E at 0x02F0 // Incoming return from call to 0x0B9E at 0x02F0 // Inputs[4] // { // @02F4 memory[0x40:0x60] // @02F6 stack[-1] // @0301 memory[0x40:0x60] // @0306 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02F1 5B JUMPDEST 02F2 60 PUSH1 0x40 02F4 51 MLOAD 02F5 80 DUP1 02F6 82 DUP3 02F7 81 DUP2 02F8 52 MSTORE 02F9 60 PUSH1 0x20 02FB 01 ADD 02FC 91 SWAP2 02FD 50 POP 02FE 50 POP 02FF 60 PUSH1 0x40 0301 51 MLOAD 0302 80 DUP1 0303 91 SWAP2 0304 03 SUB 0305 90 SWAP1 0306 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0306 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0307: // Incoming jump from 0x00BC, if 0xb75c7dc6 == stack[-1] // Inputs[1] { @030F msg.data[0x04:0x24] } 0307 5B JUMPDEST 0308 61 PUSH2 0x031d 030B 60 PUSH1 0x04 030D 80 DUP1 030E 80 DUP1 030F 35 CALLDATALOAD 0310 90 SWAP1 0311 60 PUSH1 0x20 0313 01 ADD 0314 90 SWAP1 0315 91 SWAP2 0316 90 SWAP1 0317 50 POP 0318 50 POP 0319 61 PUSH2 0x03c8 031C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0308 stack[0] = 0x031d // @0315 stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x03c8, returns to 0x031D label_031D: // Incoming return from call to 0x03C8 at 0x031C 031D 5B JUMPDEST 031E 00 *STOP // Stack delta = +0 // Outputs[1] { @031E stop(); } // Block terminates label_031F: // Incoming jump from 0x00C7, if 0xba51a6df == stack[-1] // Inputs[1] { @0327 msg.data[0x04:0x24] } 031F 5B JUMPDEST 0320 61 PUSH2 0x0335 0323 60 PUSH1 0x04 0325 80 DUP1 0326 80 DUP1 0327 35 CALLDATALOAD 0328 90 SWAP1 0329 60 PUSH1 0x20 032B 01 ADD 032C 90 SWAP1 032D 91 SWAP2 032E 90 SWAP1 032F 50 POP 0330 50 POP 0331 61 PUSH2 0x090f 0334 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0320 stack[0] = 0x0335 // @032D stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x090f, returns to 0x0335 label_0335: // Incoming return from call to 0x090F at 0x0334 0335 5B JUMPDEST 0336 00 *STOP // Stack delta = +0 // Outputs[1] { @0336 stop(); } // Block terminates label_0337: // Incoming jump from 0x00D2, if 0xc2cf7326 == stack[-1] // Inputs[2] // { // @033F msg.data[0x04:0x24] // @0348 msg.data[0x24:0x44] // } 0337 5B JUMPDEST 0338 61 PUSH2 0x0356 033B 60 PUSH1 0x04 033D 80 DUP1 033E 80 DUP1 033F 35 CALLDATALOAD 0340 90 SWAP1 0341 60 PUSH1 0x20 0343 01 ADD 0344 90 SWAP1 0345 91 SWAP2 0346 90 SWAP1 0347 80 DUP1 0348 35 CALLDATALOAD 0349 90 SWAP1 034A 60 PUSH1 0x20 034C 01 ADD 034D 90 SWAP1 034E 91 SWAP2 034F 90 SWAP1 0350 50 POP 0351 50 POP 0352 61 PUSH2 0x09e7 0355 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0338 stack[0] = 0x0356 // @0345 stack[1] = msg.data[0x04:0x24] // @034E stack[2] = msg.data[0x24:0x44] // } // Block ends with call to 0x09e7, returns to 0x0356 label_0356: // Incoming return from call to 0x09E7 at 0x0355 // Inputs[4] // { // @0359 memory[0x40:0x60] // @035B stack[-1] // @0366 memory[0x40:0x60] // @036B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0356 5B JUMPDEST 0357 60 PUSH1 0x40 0359 51 MLOAD 035A 80 DUP1 035B 82 DUP3 035C 81 DUP2 035D 52 MSTORE 035E 60 PUSH1 0x20 0360 01 ADD 0361 91 SWAP2 0362 50 POP 0363 50 POP 0364 60 PUSH1 0x40 0366 51 MLOAD 0367 80 DUP1 0368 91 SWAP2 0369 03 SUB 036A 90 SWAP1 036B F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @035D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @036B return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_036C: // Incoming jump from 0x00DD, if 0xcbf0b0c0 == stack[-1] // Inputs[1] { @0374 msg.data[0x04:0x24] } 036C 5B JUMPDEST 036D 61 PUSH2 0x0382 0370 60 PUSH1 0x04 0372 80 DUP1 0373 80 DUP1 0374 35 CALLDATALOAD 0375 90 SWAP1 0376 60 PUSH1 0x20 0378 01 ADD 0379 90 SWAP1 037A 91 SWAP2 037B 90 SWAP1 037C 50 POP 037D 50 POP 037E 61 PUSH2 0x0b4c 0381 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @036D stack[0] = 0x0382 // @037A stack[1] = msg.data[0x04:0x24] // } // Block ends with call to 0x0b4c, returns to 0x0382 label_0382: // Incoming return from call to 0x0B4C at 0x0381 0382 5B JUMPDEST 0383 00 *STOP // Stack delta = +0 // Outputs[1] { @0383 stop(); } // Block terminates label_0384: // Incoming jump from 0x00E8, if 0xf00d4b5d == stack[-1] // Inputs[2] // { // @038C msg.data[0x04:0x24] // @0395 msg.data[0x24:0x44] // } 0384 5B JUMPDEST 0385 61 PUSH2 0x03a3 0388 60 PUSH1 0x04 038A 80 DUP1 038B 80 DUP1 038C 35 CALLDATALOAD 038D 90 SWAP1 038E 60 PUSH1 0x20 0390 01 ADD 0391 90 SWAP1 0392 91 SWAP2 0393 90 SWAP1 0394 80 DUP1 0395 35 CALLDATALOAD 0396 90 SWAP1 0397 60 PUSH1 0x20 0399 01 ADD 039A 90 SWAP1 039B 91 SWAP2 039C 90 SWAP1 039D 50 POP 039E 50 POP 039F 61 PUSH2 0x04ca 03A2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0385 stack[0] = 0x03a3 // @0392 stack[1] = msg.data[0x04:0x24] // @039B stack[2] = msg.data[0x24:0x44] // } // Block ends with call to 0x04ca, returns to 0x03A3 label_03A3: // Incoming return from call to 0x04CA at 0x03A2 // Incoming return from call to 0x04CA at 0x03A2 03A3 5B JUMPDEST 03A4 00 *STOP // Stack delta = +0 // Outputs[1] { @03A4 stop(); } // Block terminates label_03A5: // Incoming jump from 0x00F3, if 0xf1736d86 == stack[-1] 03A5 5B JUMPDEST 03A6 61 PUSH2 0x03b2 03A9 60 PUSH1 0x04 03AB 80 DUP1 03AC 50 POP 03AD 50 POP 03AE 61 PUSH2 0x0b24 03B1 56 *JUMP // Stack delta = +1 // Outputs[1] { @03A6 stack[0] = 0x03b2 } // Block ends with call to 0x0b24, returns to 0x03B2 label_03B2: // Incoming return from call to 0x0B24 at 0x03B1 // Inputs[4] // { // @03B5 memory[0x40:0x60] // @03B7 stack[-1] // @03C2 memory[0x40:0x60] // @03C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 03B2 5B JUMPDEST 03B3 60 PUSH1 0x40 03B5 51 MLOAD 03B6 80 DUP1 03B7 82 DUP3 03B8 81 DUP2 03B9 52 MSTORE 03BA 60 PUSH1 0x20 03BC 01 ADD 03BD 91 SWAP2 03BE 50 POP 03BF 50 POP 03C0 60 PUSH1 0x40 03C2 51 MLOAD 03C3 80 DUP1 03C4 91 SWAP2 03C5 03 SUB 03C6 90 SWAP1 03C7 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @03B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @03C7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_03C8: // Incoming call from 0x031C, returns to 0x031D // Inputs[3] // { // @03D7 msg.sender // @03FB memory[0x00:0x40] // @03FF storage[keccak256(memory[0x00:0x40])] // } 03C8 5B JUMPDEST 03C9 60 PUSH1 0x00 03CB 60 PUSH1 0x00 03CD 60 PUSH1 0x00 03CF 61 PUSH2 0x0102 03D2 60 PUSH1 0x00 03D4 50 POP 03D5 60 PUSH1 0x00 03D7 33 CALLER 03D8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03ED 16 AND 03EE 81 DUP2 03EF 52 MSTORE 03F0 60 PUSH1 0x20 03F2 01 ADD 03F3 90 SWAP1 03F4 81 DUP2 03F5 52 MSTORE 03F6 60 PUSH1 0x20 03F8 01 ADD 03F9 60 PUSH1 0x00 03FB 20 SHA3 03FC 60 PUSH1 0x00 03FE 50 POP 03FF 54 SLOAD 0400 92 SWAP3 0401 50 POP 0402 60 PUSH1 0x00 0404 83 DUP4 0405 14 EQ 0406 15 ISZERO 0407 61 PUSH2 0x040f 040A 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @03CB stack[1] = 0x00 // @03CD stack[2] = 0x00 // @03EF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @03F5 memory[0x20:0x40] = 0x0102 // @0400 stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x040f, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) label_040B: // Incoming jump from 0x040A, if not !(storage[keccak256(memory[0x00:0x40])] == 0x00) 040B 61 PUSH2 0x04c4 040E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04c4 label_040F: // Incoming jump from 0x040A, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[6] // { // @0410 stack[-3] // @0414 stack[-2] // @041E stack[-4] // @042C memory[0x00:0x40] // @0430 stack[-1] // @043C storage[0x01 + keccak256(memory[0x00:0x40])] // } 040F 5B JUMPDEST 0410 82 DUP3 0411 60 PUSH1 0x02 0413 0A EXP 0414 91 SWAP2 0415 50 POP 0416 61 PUSH2 0x0103 0419 60 PUSH1 0x00 041B 50 POP 041C 60 PUSH1 0x00 041E 85 DUP6 041F 81 DUP2 0420 52 MSTORE 0421 60 PUSH1 0x20 0423 01 ADD 0424 90 SWAP1 0425 81 DUP2 0426 52 MSTORE 0427 60 PUSH1 0x20 0429 01 ADD 042A 60 PUSH1 0x00 042C 20 SHA3 042D 60 PUSH1 0x00 042F 50 POP 0430 90 SWAP1 0431 50 POP 0432 60 PUSH1 0x00 0434 82 DUP3 0435 82 DUP3 0436 60 PUSH1 0x01 0438 01 ADD 0439 60 PUSH1 0x00 043B 50 POP 043C 54 SLOAD 043D 16 AND 043E 11 GT 043F 15 ISZERO 0440 61 PUSH2 0x04c3 0443 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0414 stack[-2] = 0x02 ** stack[-3] // @0420 memory[0x00:0x20] = stack[-4] // @0426 memory[0x20:0x40] = 0x0103 // @0430 stack[-1] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x04c3, if !(storage[0x01 + keccak256(memory[0x00:0x40])] & 0x02 ** stack[-3] > 0x00) label_0444: // Incoming jump from 0x0443, if not !(storage[0x01 + keccak256(memory[0x00:0x40])] & 0x02 ** stack[-3] > 0x00) // Inputs[9] // { // @0444 stack[-1] // @044D storage[0x00 + stack[-1]] // @045A stack[-2] // @0465 storage[0x01 + stack[-1]] // @048F msg.sender // @0490 stack[-4] // @0493 memory[0x40:0x60] // @04BD memory[0x40:0x60] // @04C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0444 80 DUP1 0445 60 PUSH1 0x00 0447 01 ADD 0448 60 PUSH1 0x00 044A 81 DUP2 044B 81 DUP2 044C 50 POP 044D 54 SLOAD 044E 80 DUP1 044F 92 SWAP3 0450 91 SWAP2 0451 90 SWAP1 0452 60 PUSH1 0x01 0454 01 ADD 0455 91 SWAP2 0456 90 SWAP1 0457 50 POP 0458 55 SSTORE 0459 50 POP 045A 81 DUP2 045B 81 DUP2 045C 60 PUSH1 0x01 045E 01 ADD 045F 60 PUSH1 0x00 0461 82 DUP3 0462 82 DUP3 0463 82 DUP3 0464 50 POP 0465 54 SLOAD 0466 03 SUB 0467 92 SWAP3 0468 50 POP 0469 50 POP 046A 81 DUP2 046B 90 SWAP1 046C 55 SSTORE 046D 50 POP 046E 7F PUSH32 0xc7fb647e59b18047309aa15aad418e5d7ca96d173ad704f1031a2c3d7591734b 048F 33 CALLER 0490 85 DUP6 0491 60 PUSH1 0x40 0493 51 MLOAD 0494 80 DUP1 0495 83 DUP4 0496 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04AB 16 AND 04AC 81 DUP2 04AD 52 MSTORE 04AE 60 PUSH1 0x20 04B0 01 ADD 04B1 82 DUP3 04B2 81 DUP2 04B3 52 MSTORE 04B4 60 PUSH1 0x20 04B6 01 ADD 04B7 92 SWAP3 04B8 50 POP 04B9 50 POP 04BA 50 POP 04BB 60 PUSH1 0x40 04BD 51 MLOAD 04BE 80 DUP1 04BF 91 SWAP2 04C0 03 SUB 04C1 90 SWAP1 04C2 A1 LOG1 04C3 5B JUMPDEST // Stack delta = +0 // Outputs[5] // { // @0458 storage[0x00 + stack[-1]] = 0x01 + storage[0x00 + stack[-1]] // @046C storage[0x01 + stack[-1]] = storage[0x01 + stack[-1]] - stack[-2] // @04AD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @04B3 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-4] // @04C2 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xc7fb647e59b18047309aa15aad418e5d7ca96d173ad704f1031a2c3d7591734b]); // } // Block continues label_04C4: // Incoming jump from 0x040E // Incoming jump from 0x04C3 // Incoming jump from 0x04C3 // Inputs[1] { @04C9 stack[-5] } 04C4 5B JUMPDEST 04C5 50 POP 04C6 50 POP 04C7 50 POP 04C8 50 POP 04C9 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_04CA: // Incoming call from 0x03A2, returns to 0x03A3 // Inputs[6] // { // @04CF msg.data.length // @04D0 block.number // @04D3 memory[0x40:0x60] // @04DA msg.data[0x00:0x00 + msg.data.length] // @04ED memory[0x40:0x60] // @04F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]] // } 04CA 5B JUMPDEST 04CB 60 PUSH1 0x00 04CD 60 PUSH1 0x00 04CF 36 CALLDATASIZE 04D0 43 NUMBER 04D1 60 PUSH1 0x40 04D3 51 MLOAD 04D4 80 DUP1 04D5 84 DUP5 04D6 84 DUP5 04D7 80 DUP1 04D8 82 DUP3 04D9 84 DUP5 04DA 37 CALLDATACOPY 04DB 82 DUP3 04DC 01 ADD 04DD 91 SWAP2 04DE 50 POP 04DF 50 POP 04E0 82 DUP3 04E1 81 DUP2 04E2 52 MSTORE 04E3 60 PUSH1 0x20 04E5 01 ADD 04E6 93 SWAP4 04E7 50 POP 04E8 50 POP 04E9 50 POP 04EA 50 POP 04EB 60 PUSH1 0x40 04ED 51 MLOAD 04EE 80 DUP1 04EF 91 SWAP2 04F0 03 SUB 04F1 90 SWAP1 04F2 20 SHA3 04F3 61 PUSH2 0x04fb 04F6 81 DUP2 04F7 61 PUSH2 0x12db 04FA 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @04CB stack[0] = 0x00 // @04DA memory[memory[0x40:0x60]:memory[0x40:0x60] + msg.data.length] = msg.data[0x00:0x00 + msg.data.length] // @04E2 memory[memory[0x40:0x60] + msg.data.length:memory[0x40:0x60] + msg.data.length + 0x20] = block.number // @04F2 stack[1] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]]) // @04F3 stack[2] = 0x04fb // @04F6 stack[3] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]]) // } // Block ends with call to 0x12db, returns to 0x04FB label_04FB: // Incoming return from call to 0x12DB at 0x04FA // Inputs[1] { @04FC stack[-1] } 04FB 5B JUMPDEST 04FC 15 ISZERO 04FD 61 PUSH2 0x0667 0500 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0667, if !stack[-1] label_0501: // Incoming jump from 0x0500, if not !stack[-1] // Inputs[1] { @0504 stack[-3] } 0501 61 PUSH2 0x0509 0504 83 DUP4 0505 61 PUSH2 0x09a5 0508 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0501 stack[0] = 0x0509 // @0504 stack[1] = stack[-3] // } // Block ends with call to 0x09a5, returns to 0x0509 label_0509: // Incoming return from call to 0x09A5 at 0x0508 // Inputs[1] { @050A stack[-1] } 0509 5B JUMPDEST 050A 15 ISZERO 050B 61 PUSH2 0x0514 050E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0514, if !stack[-1] label_050F: // Incoming jump from 0x050E, if not !stack[-1] 050F 50 POP 0510 61 PUSH2 0x0669 0513 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x0669 label_0514: // Incoming jump from 0x050E, if !stack[-1] // Inputs[4] // { // @051D stack[-4] // @0541 memory[0x00:0x40] // @0545 storage[keccak256(memory[0x00:0x40])] // @0546 stack[-2] // } 0514 5B JUMPDEST 0515 61 PUSH2 0x0102 0518 60 PUSH1 0x00 051A 50 POP 051B 60 PUSH1 0x00 051D 85 DUP6 051E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0533 16 AND 0534 81 DUP2 0535 52 MSTORE 0536 60 PUSH1 0x20 0538 01 ADD 0539 90 SWAP1 053A 81 DUP2 053B 52 MSTORE 053C 60 PUSH1 0x20 053E 01 ADD 053F 60 PUSH1 0x00 0541 20 SHA3 0542 60 PUSH1 0x00 0544 50 POP 0545 54 SLOAD 0546 91 SWAP2 0547 50 POP 0548 60 PUSH1 0x00 054A 82 DUP3 054B 14 EQ 054C 15 ISZERO 054D 61 PUSH2 0x0556 0550 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @0535 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @053B memory[0x20:0x40] = 0x0102 // @0546 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0556, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) label_0551: // Incoming jump from 0x0550, if not !(storage[keccak256(memory[0x00:0x40])] == 0x00) 0551 50 POP 0552 61 PUSH2 0x0669 0555 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x0669 label_0556: // Incoming jump from 0x0550, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) 0556 5B JUMPDEST 0557 61 PUSH2 0x055e 055A 61 PUSH2 0x1777 055D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0557 stack[0] = 0x055e } // Block ends with call to 0x1777, returns to 0x055E label_055E: // Incoming return from call to 0x1777 at 0x055D // Inputs[2] // { // @055F stack[-3] // @057B stack[-2] // } 055E 5B JUMPDEST 055F 82 DUP3 0560 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0575 16 AND 0576 60 PUSH1 0x02 0578 60 PUSH1 0x00 057A 50 POP 057B 83 DUP4 057C 61 PUSH2 0x0100 057F 81 DUP2 0580 10 LT 0581 15 ISZERO 0582 61 PUSH2 0x0002 0585 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0575 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0576 stack[1] = 0x02 // @057B stack[2] = stack[-2] // } // Block ends with conditional jump to 0x0002, if !(stack[-2] < 0x0100) label_0586: // Incoming jump from 0x0585, if not !(stack[-2] < 0x0100) // Inputs[11] // { // @0586 stack[-2] // @0586 stack[-1] // @058D stack[-3] // @059B stack[-7] // @05BF memory[0x00:0x40] // @05C7 stack[-5] // @05D0 stack[-6] // @05F4 memory[0x00:0x40] // @0621 memory[0x40:0x60] // @0661 memory[0x40:0x60] // @0666 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0586 90 SWAP1 0587 90 SWAP1 0588 01 ADD 0589 60 PUSH1 0x00 058B 5B JUMPDEST 058C 50 POP 058D 81 DUP2 058E 90 SWAP1 058F 55 SSTORE 0590 50 POP 0591 60 PUSH1 0x00 0593 61 PUSH2 0x0102 0596 60 PUSH1 0x00 0598 50 POP 0599 60 PUSH1 0x00 059B 86 DUP7 059C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05B1 16 AND 05B2 81 DUP2 05B3 52 MSTORE 05B4 60 PUSH1 0x20 05B6 01 ADD 05B7 90 SWAP1 05B8 81 DUP2 05B9 52 MSTORE 05BA 60 PUSH1 0x20 05BC 01 ADD 05BD 60 PUSH1 0x00 05BF 20 SHA3 05C0 60 PUSH1 0x00 05C2 50 POP 05C3 81 DUP2 05C4 90 SWAP1 05C5 55 SSTORE 05C6 50 POP 05C7 81 DUP2 05C8 61 PUSH2 0x0102 05CB 60 PUSH1 0x00 05CD 50 POP 05CE 60 PUSH1 0x00 05D0 85 DUP6 05D1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05E6 16 AND 05E7 81 DUP2 05E8 52 MSTORE 05E9 60 PUSH1 0x20 05EB 01 ADD 05EC 90 SWAP1 05ED 81 DUP2 05EE 52 MSTORE 05EF 60 PUSH1 0x20 05F1 01 ADD 05F2 60 PUSH1 0x00 05F4 20 SHA3 05F5 60 PUSH1 0x00 05F7 50 POP 05F8 81 DUP2 05F9 90 SWAP1 05FA 55 SSTORE 05FB 50 POP 05FC 7F PUSH32 0xb532073b38c83145e3e5135377a08bf9aab55bc0fd7c1179cd4fb995d2a5159c 061D 84 DUP5 061E 84 DUP5 061F 60 PUSH1 0x40 0621 51 MLOAD 0622 80 DUP1 0623 83 DUP4 0624 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0639 16 AND 063A 81 DUP2 063B 52 MSTORE 063C 60 PUSH1 0x20 063E 01 ADD 063F 82 DUP3 0640 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0655 16 AND 0656 81 DUP2 0657 52 MSTORE 0658 60 PUSH1 0x20 065A 01 ADD 065B 92 SWAP3 065C 50 POP 065D 50 POP 065E 50 POP 065F 60 PUSH1 0x40 0661 51 MLOAD 0662 80 DUP1 0663 91 SWAP2 0664 03 SUB 0665 90 SWAP1 0666 A1 LOG1 // Stack delta = -3 // Outputs[10] // { // @058F storage[stack[-1] + stack[-2]] = stack[-3] // @05B3 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @05B9 memory[0x20:0x40] = 0x0102 // @05C5 storage[keccak256(memory[0x00:0x40])] = 0x00 // @05E8 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @05EE memory[0x20:0x40] = 0x0102 // @05FA storage[keccak256(memory[0x00:0x40])] = stack[-5] // @063B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @0657 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @0666 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xb532073b38c83145e3e5135377a08bf9aab55bc0fd7c1179cd4fb995d2a5159c]); // } // Block continues label_0667: // Incoming jump from 0x0666 // Incoming jump from 0x0500, if !stack[-1] // Inputs[1] { @066D stack[-5] } 0667 5B JUMPDEST 0668 50 POP 0669 5B JUMPDEST 066A 50 POP 066B 50 POP 066C 50 POP 066D 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_066E: // Incoming call from 0x0254, returns to 0x0255 // Inputs[6] // { // @0671 msg.data.length // @0672 block.number // @0675 memory[0x40:0x60] // @067C msg.data[0x00:0x00 + msg.data.length] // @068F memory[0x40:0x60] // @0694 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]] // } 066E 5B JUMPDEST 066F 60 PUSH1 0x00 0671 36 CALLDATASIZE 0672 43 NUMBER 0673 60 PUSH1 0x40 0675 51 MLOAD 0676 80 DUP1 0677 84 DUP5 0678 84 DUP5 0679 80 DUP1 067A 82 DUP3 067B 84 DUP5 067C 37 CALLDATACOPY 067D 82 DUP3 067E 01 ADD 067F 91 SWAP2 0680 50 POP 0681 50 POP 0682 82 DUP3 0683 81 DUP2 0684 52 MSTORE 0685 60 PUSH1 0x20 0687 01 ADD 0688 93 SWAP4 0689 50 POP 068A 50 POP 068B 50 POP 068C 50 POP 068D 60 PUSH1 0x40 068F 51 MLOAD 0690 80 DUP1 0691 91 SWAP2 0692 03 SUB 0693 90 SWAP1 0694 20 SHA3 0695 61 PUSH2 0x069d 0698 81 DUP2 0699 61 PUSH2 0x12db 069C 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @067C memory[memory[0x40:0x60]:memory[0x40:0x60] + msg.data.length] = msg.data[0x00:0x00 + msg.data.length] // @0684 memory[memory[0x40:0x60] + msg.data.length:memory[0x40:0x60] + msg.data.length + 0x20] = block.number // @0694 stack[0] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]]) // @0695 stack[1] = 0x069d // @0698 stack[2] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]]) // } // Block ends with call to 0x12db, returns to 0x069D label_069D: // Incoming return from call to 0x12DB at 0x069C // Inputs[1] { @069E stack[-1] } 069D 5B JUMPDEST 069E 15 ISZERO 069F 61 PUSH2 0x07bf 06A2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x07bf, if !stack[-1] label_06A3: // Incoming jump from 0x06A2, if not !stack[-1] // Inputs[1] { @06A6 stack[-2] } 06A3 61 PUSH2 0x06ab 06A6 82 DUP3 06A7 61 PUSH2 0x09a5 06AA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06A3 stack[0] = 0x06ab // @06A6 stack[1] = stack[-2] // } // Block ends with call to 0x09a5, returns to 0x06AB label_06AB: // Incoming return from call to 0x09A5 at 0x06AA // Inputs[1] { @06AC stack[-1] } 06AB 5B JUMPDEST 06AC 15 ISZERO 06AD 61 PUSH2 0x06b6 06B0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x06b6, if !stack[-1] label_06B1: // Incoming jump from 0x06B0, if not !stack[-1] 06B1 50 POP 06B2 61 PUSH2 0x07c1 06B5 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x07c1 label_06B6: // Incoming jump from 0x06B0, if !stack[-1] 06B6 5B JUMPDEST 06B7 61 PUSH2 0x06be 06BA 61 PUSH2 0x1777 06BD 56 *JUMP // Stack delta = +1 // Outputs[1] { @06B7 stack[0] = 0x06be } // Block ends with call to 0x1777, returns to 0x06BE label_06BE: // Incoming return from call to 0x1777 at 0x06BD // Inputs[1] { @06C6 storage[0x01] } 06BE 5B JUMPDEST 06BF 60 PUSH1 0xfa 06C1 60 PUSH1 0x01 06C3 60 PUSH1 0x00 06C5 50 POP 06C6 54 SLOAD 06C7 10 LT 06C8 15 ISZERO 06C9 15 ISZERO 06CA 61 PUSH2 0x06d7 06CD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06d7, if !!(storage[0x01] < 0xfa) label_06CE: // Incoming jump from 0x06CD, if not !!(storage[0x01] < 0xfa) 06CE 61 PUSH2 0x06d5 06D1 61 PUSH2 0x153d 06D4 56 *JUMP // Stack delta = +1 // Outputs[1] { @06CE stack[0] = 0x06d5 } // Block ends with call to 0x153d, returns to 0x06D5 label_06D5: // Incoming return from call to 0x153D at 0x06D4 06D5 5B JUMPDEST 06D6 50 POP // Stack delta = -1 // Block continues label_06D7: // Incoming jump from 0x06D6 // Incoming jump from 0x06CD, if !!(storage[0x01] < 0xfa) // Inputs[1] { @06DF storage[0x01] } 06D7 5B JUMPDEST 06D8 60 PUSH1 0xfa 06DA 60 PUSH1 0x01 06DC 60 PUSH1 0x00 06DE 50 POP 06DF 54 SLOAD 06E0 10 LT 06E1 15 ISZERO 06E2 15 ISZERO 06E3 61 PUSH2 0x06ec 06E6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06ec, if !!(storage[0x01] < 0xfa) label_06E7: // Incoming jump from 0x06E6, if not !!(storage[0x01] < 0xfa) 06E7 50 POP 06E8 61 PUSH2 0x07c1 06EB 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x07c1 label_06EC: // Incoming jump from 0x06E6, if !!(storage[0x01] < 0xfa) // Inputs[3] // { // @06F4 storage[0x01] // @0701 stack[-2] // @0722 storage[0x01] // } 06EC 5B JUMPDEST 06ED 60 PUSH1 0x01 06EF 60 PUSH1 0x00 06F1 81 DUP2 06F2 81 DUP2 06F3 50 POP 06F4 54 SLOAD 06F5 80 DUP1 06F6 92 SWAP3 06F7 91 SWAP2 06F8 90 SWAP1 06F9 60 PUSH1 0x01 06FB 01 ADD 06FC 91 SWAP2 06FD 90 SWAP1 06FE 50 POP 06FF 55 SSTORE 0700 50 POP 0701 81 DUP2 0702 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0717 16 AND 0718 60 PUSH1 0x02 071A 60 PUSH1 0x00 071C 50 POP 071D 60 PUSH1 0x01 071F 60 PUSH1 0x00 0721 50 POP 0722 54 SLOAD 0723 61 PUSH2 0x0100 0726 81 DUP2 0727 10 LT 0728 15 ISZERO 0729 61 PUSH2 0x0002 072C 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @06FF storage[0x01] = 0x01 + storage[0x01] // @0717 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0718 stack[1] = 0x02 // @0722 stack[2] = storage[0x01] // } // Block ends with conditional jump to 0x0002, if !(storage[0x01] < 0x0100) label_072D: // Incoming jump from 0x072C, if not !(storage[0x01] < 0x0100) // Inputs[9] // { // @072D stack[-1] // @072D stack[-2] // @0734 stack[-3] // @073D storage[0x01] // @0746 stack[-5] // @076A memory[0x00:0x40] // @0796 memory[0x40:0x60] // @07B9 memory[0x40:0x60] // @07BE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 072D 90 SWAP1 072E 90 SWAP1 072F 01 ADD 0730 60 PUSH1 0x00 0732 5B JUMPDEST 0733 50 POP 0734 81 DUP2 0735 90 SWAP1 0736 55 SSTORE 0737 50 POP 0738 60 PUSH1 0x01 073A 60 PUSH1 0x00 073C 50 POP 073D 54 SLOAD 073E 61 PUSH2 0x0102 0741 60 PUSH1 0x00 0743 50 POP 0744 60 PUSH1 0x00 0746 84 DUP5 0747 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 075C 16 AND 075D 81 DUP2 075E 52 MSTORE 075F 60 PUSH1 0x20 0761 01 ADD 0762 90 SWAP1 0763 81 DUP2 0764 52 MSTORE 0765 60 PUSH1 0x20 0767 01 ADD 0768 60 PUSH1 0x00 076A 20 SHA3 076B 60 PUSH1 0x00 076D 50 POP 076E 81 DUP2 076F 90 SWAP1 0770 55 SSTORE 0771 50 POP 0772 7F PUSH32 0x994a936646fe87ffe4f1e469d3d6aa417d6b855598397f323de5b449f765f0c3 0793 82 DUP3 0794 60 PUSH1 0x40 0796 51 MLOAD 0797 80 DUP1 0798 82 DUP3 0799 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07AE 16 AND 07AF 81 DUP2 07B0 52 MSTORE 07B1 60 PUSH1 0x20 07B3 01 ADD 07B4 91 SWAP2 07B5 50 POP 07B6 50 POP 07B7 60 PUSH1 0x40 07B9 51 MLOAD 07BA 80 DUP1 07BB 91 SWAP2 07BC 03 SUB 07BD 90 SWAP1 07BE A1 LOG1 // Stack delta = -3 // Outputs[6] // { // @0736 storage[stack[-1] + stack[-2]] = stack[-3] // @075E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0764 memory[0x20:0x40] = 0x0102 // @0770 storage[keccak256(memory[0x00:0x40])] = storage[0x01] // @07B0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @07BE log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x994a936646fe87ffe4f1e469d3d6aa417d6b855598397f323de5b449f765f0c3]); // } // Block continues label_07BF: // Incoming jump from 0x06A2, if !stack[-1] // Incoming jump from 0x07BE // Inputs[1] { @07C3 stack[-3] } 07BF 5B JUMPDEST 07C0 50 POP 07C1 5B JUMPDEST 07C2 50 POP 07C3 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_07C4: // Incoming call from 0x0175, returns to 0x0176 // Inputs[6] // { // @07C9 msg.data.length // @07CA block.number // @07CD memory[0x40:0x60] // @07D4 msg.data[0x00:0x00 + msg.data.length] // @07E7 memory[0x40:0x60] // @07EC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]] // } 07C4 5B JUMPDEST 07C5 60 PUSH1 0x00 07C7 60 PUSH1 0x00 07C9 36 CALLDATASIZE 07CA 43 NUMBER 07CB 60 PUSH1 0x40 07CD 51 MLOAD 07CE 80 DUP1 07CF 84 DUP5 07D0 84 DUP5 07D1 80 DUP1 07D2 82 DUP3 07D3 84 DUP5 07D4 37 CALLDATACOPY 07D5 82 DUP3 07D6 01 ADD 07D7 91 SWAP2 07D8 50 POP 07D9 50 POP 07DA 82 DUP3 07DB 81 DUP2 07DC 52 MSTORE 07DD 60 PUSH1 0x20 07DF 01 ADD 07E0 93 SWAP4 07E1 50 POP 07E2 50 POP 07E3 50 POP 07E4 50 POP 07E5 60 PUSH1 0x40 07E7 51 MLOAD 07E8 80 DUP1 07E9 91 SWAP2 07EA 03 SUB 07EB 90 SWAP1 07EC 20 SHA3 07ED 61 PUSH2 0x07f5 07F0 81 DUP2 07F1 61 PUSH2 0x12db 07F4 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @07C5 stack[0] = 0x00 // @07D4 memory[memory[0x40:0x60]:memory[0x40:0x60] + msg.data.length] = msg.data[0x00:0x00 + msg.data.length] // @07DC memory[memory[0x40:0x60] + msg.data.length:memory[0x40:0x60] + msg.data.length + 0x20] = block.number // @07EC stack[1] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]]) // @07ED stack[2] = 0x07f5 // @07F0 stack[3] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]]) // } // Block ends with call to 0x12db, returns to 0x07F5 label_07F5: // Incoming return from call to 0x12DB at 0x07F4 // Inputs[1] { @07F6 stack[-1] } 07F5 5B JUMPDEST 07F6 15 ISZERO 07F7 61 PUSH2 0x0909 07FA 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0909, if !stack[-1] label_07FB: // Incoming jump from 0x07FA, if not !stack[-1] // Inputs[4] // { // @0803 stack[-3] // @0827 memory[0x00:0x40] // @082B storage[keccak256(memory[0x00:0x40])] // @082C stack[-2] // } 07FB 61 PUSH2 0x0102 07FE 60 PUSH1 0x00 0800 50 POP 0801 60 PUSH1 0x00 0803 84 DUP5 0804 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0819 16 AND 081A 81 DUP2 081B 52 MSTORE 081C 60 PUSH1 0x20 081E 01 ADD 081F 90 SWAP1 0820 81 DUP2 0821 52 MSTORE 0822 60 PUSH1 0x20 0824 01 ADD 0825 60 PUSH1 0x00 0827 20 SHA3 0828 60 PUSH1 0x00 082A 50 POP 082B 54 SLOAD 082C 91 SWAP2 082D 50 POP 082E 60 PUSH1 0x00 0830 82 DUP3 0831 14 EQ 0832 15 ISZERO 0833 61 PUSH2 0x083c 0836 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @081B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0821 memory[0x20:0x40] = 0x0102 // @082C stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x083c, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) label_0837: // Incoming jump from 0x0836, if not !(storage[keccak256(memory[0x00:0x40])] == 0x00) 0837 50 POP 0838 61 PUSH2 0x090b 083B 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x090b label_083C: // Incoming jump from 0x0836, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[2] // { // @0844 storage[0x01] // @084B storage[0x00] // } 083C 5B JUMPDEST 083D 60 PUSH1 0x01 083F 60 PUSH1 0x01 0841 60 PUSH1 0x00 0843 50 POP 0844 54 SLOAD 0845 03 SUB 0846 60 PUSH1 0x00 0848 60 PUSH1 0x00 084A 50 POP 084B 54 SLOAD 084C 11 GT 084D 15 ISZERO 084E 61 PUSH2 0x0857 0851 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0857, if !(storage[0x00] > storage[0x01] - 0x01) label_0852: // Incoming jump from 0x0851, if not !(storage[0x00] > storage[0x01] - 0x01) 0852 50 POP 0853 61 PUSH2 0x090b 0856 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x090b label_0857: // Incoming jump from 0x0851, if !(storage[0x00] > storage[0x01] - 0x01) // Inputs[1] { @085F stack[-2] } 0857 5B JUMPDEST 0858 60 PUSH1 0x00 085A 60 PUSH1 0x02 085C 60 PUSH1 0x00 085E 50 POP 085F 83 DUP4 0860 61 PUSH2 0x0100 0863 81 DUP2 0864 10 LT 0865 15 ISZERO 0866 61 PUSH2 0x0002 0869 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0858 stack[0] = 0x00 // @085A stack[1] = 0x02 // @085F stack[2] = stack[-2] // } // Block ends with conditional jump to 0x0002, if !(stack[-2] < 0x0100) label_086A: // Incoming jump from 0x0869, if not !(stack[-2] < 0x0100) // Inputs[5] // { // @086A stack[-1] // @086A stack[-2] // @0871 stack[-3] // @087F stack[-6] // @08A3 memory[0x00:0x40] // } 086A 90 SWAP1 086B 90 SWAP1 086C 01 ADD 086D 60 PUSH1 0x00 086F 5B JUMPDEST 0870 50 POP 0871 81 DUP2 0872 90 SWAP1 0873 55 SSTORE 0874 50 POP 0875 60 PUSH1 0x00 0877 61 PUSH2 0x0102 087A 60 PUSH1 0x00 087C 50 POP 087D 60 PUSH1 0x00 087F 85 DUP6 0880 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0895 16 AND 0896 81 DUP2 0897 52 MSTORE 0898 60 PUSH1 0x20 089A 01 ADD 089B 90 SWAP1 089C 81 DUP2 089D 52 MSTORE 089E 60 PUSH1 0x20 08A0 01 ADD 08A1 60 PUSH1 0x00 08A3 20 SHA3 08A4 60 PUSH1 0x00 08A6 50 POP 08A7 81 DUP2 08A8 90 SWAP1 08A9 55 SSTORE 08AA 50 POP 08AB 61 PUSH2 0x08b2 08AE 61 PUSH2 0x1777 08B1 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0873 storage[stack[-1] + stack[-2]] = stack[-3] // @0897 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @089D memory[0x20:0x40] = 0x0102 // @08A9 storage[keccak256(memory[0x00:0x40])] = 0x00 // @08AB stack[-3] = 0x08b2 // } // Block ends with call to 0x1777, returns to 0x08B2 label_08B2: // Incoming return from call to 0x1777 at 0x08B1 08B2 5B JUMPDEST 08B3 61 PUSH2 0x08ba 08B6 61 PUSH2 0x153d 08B9 56 *JUMP // Stack delta = +1 // Outputs[1] { @08B3 stack[0] = 0x08ba } // Block ends with call to 0x153d, returns to 0x08BA label_08BA: // Incoming return from call to 0x153D at 0x08B9 // Inputs[4] // { // @08DD stack[-4] // @08E0 memory[0x40:0x60] // @0903 memory[0x40:0x60] // @0908 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 08BA 5B JUMPDEST 08BB 50 POP 08BC 7F PUSH32 0x58619076adf5bb0943d100ef88d52d7c3fd691b19d3a9071b555b651fbf418da 08DD 83 DUP4 08DE 60 PUSH1 0x40 08E0 51 MLOAD 08E1 80 DUP1 08E2 82 DUP3 08E3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08F8 16 AND 08F9 81 DUP2 08FA 52 MSTORE 08FB 60 PUSH1 0x20 08FD 01 ADD 08FE 91 SWAP2 08FF 50 POP 0900 50 POP 0901 60 PUSH1 0x40 0903 51 MLOAD 0904 80 DUP1 0905 91 SWAP2 0906 03 SUB 0907 90 SWAP1 0908 A1 LOG1 // Stack delta = -1 // Outputs[2] // { // @08FA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0908 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x58619076adf5bb0943d100ef88d52d7c3fd691b19d3a9071b555b651fbf418da]); // } // Block continues label_0909: // Incoming jump from 0x0908 // Incoming jump from 0x07FA, if !stack[-1] // Inputs[1] { @090E stack[-4] } 0909 5B JUMPDEST 090A 50 POP 090B 5B JUMPDEST 090C 50 POP 090D 50 POP 090E 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_090F: // Incoming call from 0x0334, returns to 0x0335 // Inputs[6] // { // @0912 msg.data.length // @0913 block.number // @0916 memory[0x40:0x60] // @091D msg.data[0x00:0x00 + msg.data.length] // @0930 memory[0x40:0x60] // @0935 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]] // } 090F 5B JUMPDEST 0910 60 PUSH1 0x00 0912 36 CALLDATASIZE 0913 43 NUMBER 0914 60 PUSH1 0x40 0916 51 MLOAD 0917 80 DUP1 0918 84 DUP5 0919 84 DUP5 091A 80 DUP1 091B 82 DUP3 091C 84 DUP5 091D 37 CALLDATACOPY 091E 82 DUP3 091F 01 ADD 0920 91 SWAP2 0921 50 POP 0922 50 POP 0923 82 DUP3 0924 81 DUP2 0925 52 MSTORE 0926 60 PUSH1 0x20 0928 01 ADD 0929 93 SWAP4 092A 50 POP 092B 50 POP 092C 50 POP 092D 50 POP 092E 60 PUSH1 0x40 0930 51 MLOAD 0931 80 DUP1 0932 91 SWAP2 0933 03 SUB 0934 90 SWAP1 0935 20 SHA3 0936 61 PUSH2 0x093e 0939 81 DUP2 093A 61 PUSH2 0x12db 093D 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @091D memory[memory[0x40:0x60]:memory[0x40:0x60] + msg.data.length] = msg.data[0x00:0x00 + msg.data.length] // @0925 memory[memory[0x40:0x60] + msg.data.length:memory[0x40:0x60] + msg.data.length + 0x20] = block.number // @0935 stack[0] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]]) // @0936 stack[1] = 0x093e // @0939 stack[2] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]]) // } // Block ends with call to 0x12db, returns to 0x093E label_093E: // Incoming return from call to 0x12DB at 0x093D // Inputs[1] { @093F stack[-1] } 093E 5B JUMPDEST 093F 15 ISZERO 0940 61 PUSH2 0x09a0 0943 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x09a0, if !stack[-1] label_0944: // Incoming jump from 0x0943, if not !stack[-1] // Inputs[2] // { // @0949 storage[0x01] // @094A stack[-2] // } 0944 60 PUSH1 0x01 0946 60 PUSH1 0x00 0948 50 POP 0949 54 SLOAD 094A 82 DUP3 094B 11 GT 094C 15 ISZERO 094D 61 PUSH2 0x0956 0950 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0956, if !(stack[-2] > storage[0x01]) label_0951: // Incoming jump from 0x0950, if not !(stack[-2] > storage[0x01]) 0951 50 POP 0952 61 PUSH2 0x09a2 0955 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x09a2 label_0956: // Incoming jump from 0x0950, if !(stack[-2] > storage[0x01]) // Inputs[1] { @0957 stack[-2] } 0956 5B JUMPDEST 0957 81 DUP2 0958 60 PUSH1 0x00 095A 60 PUSH1 0x00 095C 50 POP 095D 81 DUP2 095E 90 SWAP1 095F 55 SSTORE 0960 50 POP 0961 61 PUSH2 0x0968 0964 61 PUSH2 0x1777 0967 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @095F storage[0x00] = stack[-2] // @0961 stack[0] = 0x0968 // } // Block ends with call to 0x1777, returns to 0x0968 label_0968: // Incoming return from call to 0x1777 at 0x0967 // Inputs[4] // { // @098A stack[-2] // @098D memory[0x40:0x60] // @099A memory[0x40:0x60] // @099F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0968 5B JUMPDEST 0969 7F PUSH32 0xacbdb084c721332ac59f9b8e392196c9eb0e4932862da8eb9beaf0dad4f550da 098A 82 DUP3 098B 60 PUSH1 0x40 098D 51 MLOAD 098E 80 DUP1 098F 82 DUP3 0990 81 DUP2 0991 52 MSTORE 0992 60 PUSH1 0x20 0994 01 ADD 0995 91 SWAP2 0996 50 POP 0997 50 POP 0998 60 PUSH1 0x40 099A 51 MLOAD 099B 80 DUP1 099C 91 SWAP2 099D 03 SUB 099E 90 SWAP1 099F A1 LOG1 // Stack delta = +0 // Outputs[2] // { // @0991 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @099F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xacbdb084c721332ac59f9b8e392196c9eb0e4932862da8eb9beaf0dad4f550da]); // } // Block continues label_09A0: // Incoming jump from 0x099F // Incoming jump from 0x0943, if !stack[-1] // Inputs[1] { @09A4 stack[-3] } 09A0 5B JUMPDEST 09A1 50 POP 09A2 5B JUMPDEST 09A3 50 POP 09A4 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_09A5: // Incoming call from 0x0BA8, returns to 0x0BA9 // Incoming call from 0x16E1, returns to 0x16E2 // Incoming call from 0x018D, returns to 0x018E // Incoming call from 0x06AA, returns to 0x06AB // Incoming call from 0x0508, returns to 0x0509 // Inputs[3] // { // @09B2 stack[-1] // @09D6 memory[0x00:0x40] // @09DA storage[keccak256(memory[0x00:0x40])] // } 09A5 5B JUMPDEST 09A6 60 PUSH1 0x00 09A8 60 PUSH1 0x00 09AA 61 PUSH2 0x0102 09AD 60 PUSH1 0x00 09AF 50 POP 09B0 60 PUSH1 0x00 09B2 84 DUP5 09B3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09C8 16 AND 09C9 81 DUP2 09CA 52 MSTORE 09CB 60 PUSH1 0x20 09CD 01 ADD 09CE 90 SWAP1 09CF 81 DUP2 09D0 52 MSTORE 09D1 60 PUSH1 0x20 09D3 01 ADD 09D4 60 PUSH1 0x00 09D6 20 SHA3 09D7 60 PUSH1 0x00 09D9 50 POP 09DA 54 SLOAD 09DB 11 GT 09DC 90 SWAP1 09DD 50 POP 09DE 61 PUSH2 0x09e2 09E1 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @09CA memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @09D0 memory[0x20:0x40] = 0x0102 // @09DC stack[0] = storage[keccak256(memory[0x00:0x40])] > 0x00 // } // Block ends with unconditional jump to 0x09e2 label_09E2: // Incoming jump from 0x09E1 // Inputs[3] // { // @09E3 stack[-3] // @09E3 stack[-1] // @09E4 stack[-2] // } 09E2 5B JUMPDEST 09E3 91 SWAP2 09E4 90 SWAP1 09E5 50 POP 09E6 56 *JUMP // Stack delta = -2 // Outputs[1] { @09E3 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_09E7: // Incoming call from 0x0355, returns to 0x0356 // Inputs[5] // { // @09F8 stack[-2] // @0A06 memory[0x00:0x40] // @0A14 stack[-1] // @0A38 memory[0x00:0x40] // @0A3C storage[keccak256(memory[0x00:0x40])] // } 09E7 5B JUMPDEST 09E8 60 PUSH1 0x00 09EA 60 PUSH1 0x00 09EC 60 PUSH1 0x00 09EE 60 PUSH1 0x00 09F0 61 PUSH2 0x0103 09F3 60 PUSH1 0x00 09F5 50 POP 09F6 60 PUSH1 0x00 09F8 87 DUP8 09F9 81 DUP2 09FA 52 MSTORE 09FB 60 PUSH1 0x20 09FD 01 ADD 09FE 90 SWAP1 09FF 81 DUP2 0A00 52 MSTORE 0A01 60 PUSH1 0x20 0A03 01 ADD 0A04 60 PUSH1 0x00 0A06 20 SHA3 0A07 60 PUSH1 0x00 0A09 50 POP 0A0A 92 SWAP3 0A0B 50 POP 0A0C 61 PUSH2 0x0102 0A0F 60 PUSH1 0x00 0A11 50 POP 0A12 60 PUSH1 0x00 0A14 86 DUP7 0A15 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A2A 16 AND 0A2B 81 DUP2 0A2C 52 MSTORE 0A2D 60 PUSH1 0x20 0A2F 01 ADD 0A30 90 SWAP1 0A31 81 DUP2 0A32 52 MSTORE 0A33 60 PUSH1 0x20 0A35 01 ADD 0A36 60 PUSH1 0x00 0A38 20 SHA3 0A39 60 PUSH1 0x00 0A3B 50 POP 0A3C 54 SLOAD 0A3D 91 SWAP2 0A3E 50 POP 0A3F 60 PUSH1 0x00 0A41 82 DUP3 0A42 14 EQ 0A43 15 ISZERO 0A44 61 PUSH2 0x0a50 0A47 57 *JUMPI // Stack delta = +4 // Outputs[8] // { // @09E8 stack[0] = 0x00 // @09EE stack[3] = 0x00 // @09FA memory[0x00:0x20] = stack[-2] // @0A00 memory[0x20:0x40] = 0x0103 // @0A0A stack[1] = keccak256(memory[0x00:0x40]) // @0A2C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0A32 memory[0x20:0x40] = 0x0102 // @0A3D stack[2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0a50, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) label_0A48: // Incoming jump from 0x0A47, if not !(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[1] { @0A4A stack[-4] } 0A48 60 PUSH1 0x00 0A4A 93 SWAP4 0A4B 50 POP 0A4C 61 PUSH2 0x0a7f 0A4F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0A4A stack[-4] = 0x00 } // Block ends with unconditional jump to 0x0a7f label_0A50: // Incoming jump from 0x0A47, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[4] // { // @0A51 stack[-2] // @0A55 stack[-1] // @0A5A stack[-3] // @0A61 storage[0x01 + stack[-3]] // } 0A50 5B JUMPDEST 0A51 81 DUP2 0A52 60 PUSH1 0x02 0A54 0A EXP 0A55 90 SWAP1 0A56 50 POP 0A57 60 PUSH1 0x00 0A59 81 DUP2 0A5A 84 DUP5 0A5B 60 PUSH1 0x01 0A5D 01 ADD 0A5E 60 PUSH1 0x00 0A60 50 POP 0A61 54 SLOAD 0A62 16 AND 0A63 14 EQ 0A64 15 ISZERO 0A65 61 PUSH2 0x0a75 0A68 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0A55 stack[-1] = 0x02 ** stack[-2] } // Block ends with conditional jump to 0x0a75, if !(storage[0x01 + stack[-3]] & 0x02 ** stack[-2] == 0x00) label_0A69: // Incoming jump from 0x0A68, if not !(storage[0x01 + stack[-3]] & 0x02 ** stack[-2] == 0x00) // Inputs[1] { @0A6B stack[-4] } 0A69 60 PUSH1 0x00 0A6B 93 SWAP4 0A6C 50 POP 0A6D 61 PUSH2 0x0a7f 0A70 56 *JUMP // Stack delta = +0 // Outputs[1] { @0A6B stack[-4] = 0x00 } // Block ends with unconditional jump to 0x0a7f 0A71 61 PUSH2 0x0a7e 0A74 56 *JUMP label_0A75: // Incoming jump from 0x0A68, if !(storage[0x01 + stack[-3]] & 0x02 ** stack[-2] == 0x00) // Inputs[1] { @0A78 stack[-4] } 0A75 5B JUMPDEST 0A76 60 PUSH1 0x01 0A78 93 SWAP4 0A79 50 POP 0A7A 61 PUSH2 0x0a7f 0A7D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0A78 stack[-4] = 0x01 } // Block ends with unconditional jump to 0x0a7f 0A7E 5B JUMPDEST label_0A7F: // Incoming jump from 0x0A4F // Incoming jump from 0x0A70 // Incoming jump from 0x0A7D // Inputs[3] // { // @0A83 stack[-7] // @0A83 stack[-4] // @0A84 stack[-6] // } 0A7F 5B JUMPDEST 0A80 50 POP 0A81 50 POP 0A82 50 POP 0A83 92 SWAP3 0A84 91 SWAP2 0A85 50 POP 0A86 50 POP 0A87 56 *JUMP // Stack delta = -6 // Outputs[1] { @0A83 stack[-7] = stack[-4] } // Block ends with unconditional jump to stack[-7] label_0A88: // Incoming call from 0x0263, returns to 0x0264 // Inputs[2] // { // @0A8E storage[0x00] // @0A8F stack[-1] // } 0A88 5B JUMPDEST 0A89 60 PUSH1 0x00 0A8B 60 PUSH1 0x00 0A8D 50 POP 0A8E 54 SLOAD 0A8F 81 DUP2 0A90 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A8E stack[0] = storage[0x00] } // Block ends with unconditional jump to stack[-1] label_0A91: // Incoming call from 0x01B0, returns to 0x01B1 // Inputs[2] // { // @0A97 storage[0x01] // @0A98 stack[-1] // } 0A91 5B JUMPDEST 0A92 60 PUSH1 0x01 0A94 60 PUSH1 0x00 0A96 50 POP 0A97 54 SLOAD 0A98 81 DUP2 0A99 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A97 stack[0] = storage[0x01] } // Block ends with unconditional jump to stack[-1] label_0A9A: // Incoming call from 0x02BB, returns to 0x02BC // Inputs[6] // { // @0A9D msg.data.length // @0A9E block.number // @0AA1 memory[0x40:0x60] // @0AA8 msg.data[0x00:0x00 + msg.data.length] // @0ABB memory[0x40:0x60] // @0AC0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]] // } 0A9A 5B JUMPDEST 0A9B 60 PUSH1 0x00 0A9D 36 CALLDATASIZE 0A9E 43 NUMBER 0A9F 60 PUSH1 0x40 0AA1 51 MLOAD 0AA2 80 DUP1 0AA3 84 DUP5 0AA4 84 DUP5 0AA5 80 DUP1 0AA6 82 DUP3 0AA7 84 DUP5 0AA8 37 CALLDATACOPY 0AA9 82 DUP3 0AAA 01 ADD 0AAB 91 SWAP2 0AAC 50 POP 0AAD 50 POP 0AAE 82 DUP3 0AAF 81 DUP2 0AB0 52 MSTORE 0AB1 60 PUSH1 0x20 0AB3 01 ADD 0AB4 93 SWAP4 0AB5 50 POP 0AB6 50 POP 0AB7 50 POP 0AB8 50 POP 0AB9 60 PUSH1 0x40 0ABB 51 MLOAD 0ABC 80 DUP1 0ABD 91 SWAP2 0ABE 03 SUB 0ABF 90 SWAP1 0AC0 20 SHA3 0AC1 61 PUSH2 0x0ac9 0AC4 81 DUP2 0AC5 61 PUSH2 0x12db 0AC8 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0AA8 memory[memory[0x40:0x60]:memory[0x40:0x60] + msg.data.length] = msg.data[0x00:0x00 + msg.data.length] // @0AB0 memory[memory[0x40:0x60] + msg.data.length:memory[0x40:0x60] + msg.data.length + 0x20] = block.number // @0AC0 stack[0] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]]) // @0AC1 stack[1] = 0x0ac9 // @0AC4 stack[2] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]]) // } // Block ends with call to 0x12db, returns to 0x0AC9 label_0AC9: // Incoming return from call to 0x12DB at 0x0AC8 // Inputs[1] { @0ACA stack[-1] } 0AC9 5B JUMPDEST 0ACA 15 ISZERO 0ACB 61 PUSH2 0x0ada 0ACE 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0ada, if !stack[-1] label_0ACF: // Incoming jump from 0x0ACE, if not !stack[-1] // Inputs[2] // { // @0ACF stack[-2] // @0ADE stack[-3] // } 0ACF 81 DUP2 0AD0 61 PUSH2 0x0105 0AD3 60 PUSH1 0x00 0AD5 50 POP 0AD6 81 DUP2 0AD7 90 SWAP1 0AD8 55 SSTORE 0AD9 50 POP 0ADA 5B JUMPDEST 0ADB 50 POP 0ADC 5B JUMPDEST 0ADD 50 POP 0ADE 56 *JUMP // Stack delta = -3 // Outputs[1] { @0AD8 storage[0x0105] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_0ADF: // Incoming call from 0x0219, returns to 0x021A // Inputs[6] // { // @0AE2 msg.data.length // @0AE3 block.number // @0AE6 memory[0x40:0x60] // @0AED msg.data[0x00:0x00 + msg.data.length] // @0B00 memory[0x40:0x60] // @0B05 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]] // } 0ADF 5B JUMPDEST 0AE0 60 PUSH1 0x00 0AE2 36 CALLDATASIZE 0AE3 43 NUMBER 0AE4 60 PUSH1 0x40 0AE6 51 MLOAD 0AE7 80 DUP1 0AE8 84 DUP5 0AE9 84 DUP5 0AEA 80 DUP1 0AEB 82 DUP3 0AEC 84 DUP5 0AED 37 CALLDATACOPY 0AEE 82 DUP3 0AEF 01 ADD 0AF0 91 SWAP2 0AF1 50 POP 0AF2 50 POP 0AF3 82 DUP3 0AF4 81 DUP2 0AF5 52 MSTORE 0AF6 60 PUSH1 0x20 0AF8 01 ADD 0AF9 93 SWAP4 0AFA 50 POP 0AFB 50 POP 0AFC 50 POP 0AFD 50 POP 0AFE 60 PUSH1 0x40 0B00 51 MLOAD 0B01 80 DUP1 0B02 91 SWAP2 0B03 03 SUB 0B04 90 SWAP1 0B05 20 SHA3 0B06 61 PUSH2 0x0b0e 0B09 81 DUP2 0B0A 61 PUSH2 0x12db 0B0D 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0AED memory[memory[0x40:0x60]:memory[0x40:0x60] + msg.data.length] = msg.data[0x00:0x00 + msg.data.length] // @0AF5 memory[memory[0x40:0x60] + msg.data.length:memory[0x40:0x60] + msg.data.length + 0x20] = block.number // @0B05 stack[0] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]]) // @0B06 stack[1] = 0x0b0e // @0B09 stack[2] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]]) // } // Block ends with call to 0x12db, returns to 0x0B0E label_0B0E: // Incoming return from call to 0x12DB at 0x0B0D // Inputs[1] { @0B0F stack[-1] } 0B0E 5B JUMPDEST 0B0F 15 ISZERO 0B10 61 PUSH2 0x0b20 0B13 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b20, if !stack[-1] label_0B14: // Incoming jump from 0x0B13, if not !stack[-1] // Inputs[1] { @0B23 stack[-2] } 0B14 60 PUSH1 0x00 0B16 61 PUSH2 0x0106 0B19 60 PUSH1 0x00 0B1B 50 POP 0B1C 81 DUP2 0B1D 90 SWAP1 0B1E 55 SSTORE 0B1F 50 POP 0B20 5B JUMPDEST 0B21 50 POP 0B22 5B JUMPDEST 0B23 56 *JUMP // Stack delta = -2 // Outputs[1] { @0B1E storage[0x0106] = 0x00 } // Block ends with unconditional jump to stack[-2] label_0B24: // Incoming call from 0x03B1, returns to 0x03B2 // Inputs[2] // { // @0B2B storage[0x0105] // @0B2C stack[-1] // } 0B24 5B JUMPDEST 0B25 61 PUSH2 0x0105 0B28 60 PUSH1 0x00 0B2A 50 POP 0B2B 54 SLOAD 0B2C 81 DUP2 0B2D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B2B stack[0] = storage[0x0105] } // Block ends with unconditional jump to stack[-1] label_0B2E: // Incoming call from 0x0228, returns to 0x0229 // Inputs[2] // { // @0B35 storage[0x0106] // @0B36 stack[-1] // } 0B2E 5B JUMPDEST 0B2F 61 PUSH2 0x0106 0B32 60 PUSH1 0x00 0B34 50 POP 0B35 54 SLOAD 0B36 81 DUP2 0B37 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B35 stack[0] = storage[0x0106] } // Block ends with unconditional jump to stack[-1] label_0B38: // Incoming call from 0x01D3, returns to 0x01D4 // Inputs[2] // { // @0B3F storage[0x0107] // @0B40 stack[-1] // } 0B38 5B JUMPDEST 0B39 61 PUSH2 0x0107 0B3C 60 PUSH1 0x00 0B3E 50 POP 0B3F 54 SLOAD 0B40 81 DUP2 0B41 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B3F stack[0] = storage[0x0107] } // Block ends with unconditional jump to stack[-1] label_0B42: // Incoming call from 0x01F6, returns to 0x01F7 // Inputs[2] // { // @0B49 storage[0x0108] // @0B4A stack[-1] // } 0B42 5B JUMPDEST 0B43 61 PUSH2 0x0108 0B46 60 PUSH1 0x00 0B48 50 POP 0B49 54 SLOAD 0B4A 81 DUP2 0B4B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B49 stack[0] = storage[0x0108] } // Block ends with unconditional jump to stack[-1] label_0B4C: // Incoming call from 0x0381, returns to 0x0382 // Inputs[6] // { // @0B4F msg.data.length // @0B50 block.number // @0B53 memory[0x40:0x60] // @0B5A msg.data[0x00:0x00 + msg.data.length] // @0B6D memory[0x40:0x60] // @0B72 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]] // } 0B4C 5B JUMPDEST 0B4D 60 PUSH1 0x00 0B4F 36 CALLDATASIZE 0B50 43 NUMBER 0B51 60 PUSH1 0x40 0B53 51 MLOAD 0B54 80 DUP1 0B55 84 DUP5 0B56 84 DUP5 0B57 80 DUP1 0B58 82 DUP3 0B59 84 DUP5 0B5A 37 CALLDATACOPY 0B5B 82 DUP3 0B5C 01 ADD 0B5D 91 SWAP2 0B5E 50 POP 0B5F 50 POP 0B60 82 DUP3 0B61 81 DUP2 0B62 52 MSTORE 0B63 60 PUSH1 0x20 0B65 01 ADD 0B66 93 SWAP4 0B67 50 POP 0B68 50 POP 0B69 50 POP 0B6A 50 POP 0B6B 60 PUSH1 0x40 0B6D 51 MLOAD 0B6E 80 DUP1 0B6F 91 SWAP2 0B70 03 SUB 0B71 90 SWAP1 0B72 20 SHA3 0B73 61 PUSH2 0x0b7b 0B76 81 DUP2 0B77 61 PUSH2 0x12db 0B7A 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0B5A memory[memory[0x40:0x60]:memory[0x40:0x60] + msg.data.length] = msg.data[0x00:0x00 + msg.data.length] // @0B62 memory[memory[0x40:0x60] + msg.data.length:memory[0x40:0x60] + msg.data.length + 0x20] = block.number // @0B72 stack[0] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]]) // @0B73 stack[1] = 0x0b7b // @0B76 stack[2] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]]) // } // Block ends with call to 0x12db, returns to 0x0B7B label_0B7B: // Incoming return from call to 0x12DB at 0x0B7A // Inputs[1] { @0B7C stack[-1] } 0B7B 5B JUMPDEST 0B7C 15 ISZERO 0B7D 61 PUSH2 0x0b99 0B80 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b99, if !stack[-1] label_0B81: // Incoming jump from 0x0B80, if not !stack[-1] // Inputs[1] { @0B81 stack[-2] } 0B81 81 DUP2 0B82 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B97 16 AND 0B98 FF *SELFDESTRUCT // Stack delta = +0 // Outputs[1] { @0B98 selfdestruct(0xffffffffffffffffffffffffffffffffffffffff & stack[-2]); } // Block terminates label_0B99: // Incoming jump from 0x0B80, if !stack[-1] // Inputs[1] { @0B9D stack[-3] } 0B99 5B JUMPDEST 0B9A 50 POP 0B9B 5B JUMPDEST 0B9C 50 POP 0B9D 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0B9E: // Incoming call from 0x02F0, returns to 0x02F1 // Inputs[1] { @0BA4 msg.sender } 0B9E 5B JUMPDEST 0B9F 60 PUSH1 0x00 0BA1 61 PUSH2 0x0ba9 0BA4 33 CALLER 0BA5 61 PUSH2 0x09a5 0BA8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B9F stack[0] = 0x00 // @0BA1 stack[1] = 0x0ba9 // @0BA4 stack[2] = msg.sender // } // Block ends with call to 0x09a5, returns to 0x0BA9 label_0BA9: // Incoming return from call to 0x09A5 at 0x0BA8 // Inputs[1] { @0BAA stack[-1] } 0BA9 5B JUMPDEST 0BAA 15 ISZERO 0BAB 61 PUSH2 0x0f05 0BAE 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f05, if !stack[-1] label_0BAF: // Incoming jump from 0x0BAE, if not !stack[-1] // Inputs[1] { @0BB2 stack[-4] } 0BAF 61 PUSH2 0x0bb7 0BB2 84 DUP5 0BB3 61 PUSH2 0x16d7 0BB6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0BAF stack[0] = 0x0bb7 // @0BB2 stack[1] = stack[-4] // } // Block ends with call to 0x16d7, returns to 0x0BB7 label_0BB7: // Incoming return from call to 0x16D7 at 0x0BB6 // Incoming return from call to 0x16D7 at 0x0BB6 // Inputs[1] { @0BB8 stack[-1] } 0BB7 5B JUMPDEST 0BB8 15 ISZERO 0BB9 61 PUSH2 0x0ca0 0BBC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0ca0, if !stack[-1] label_0BBD: // Incoming jump from 0x0BBC, if not !stack[-1] // Inputs[16] // { // @0BDE msg.sender // @0BDF stack[-4] // @0BE0 stack[-5] // @0BE1 stack[-3] // @0BE2 stack[-2] // @0BE5 memory[0x40:0x60] // @0C3C msg.data[stack[-3]:stack[-3] + stack[-2]] // @0C4C memory[0x40:0x60] // @0C51 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + stack[-2]) - memory[0x40:0x60]] // @0C6E memory[0x40:0x60] // @0C75 msg.data[stack[-3]:stack[-3] + stack[-2]] // @0C83 memory[0x40:0x60] // @0C8D msg.gas // @0C8F address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).call.gas(msg.gas - 0x8502).value(stack[-4])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-2]) - memory[0x40:0x60]]) // @0C8F memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-2]) - memory[0x40:0x60]] // @0C9A stack[-1] // } 0BBD 7F PUSH32 0x92ca3a80853e6663fa31fa10b99225f18d4902939b4c53a9caae9043f6efd004 0BDE 33 CALLER 0BDF 85 DUP6 0BE0 87 DUP8 0BE1 86 DUP7 0BE2 86 DUP7 0BE3 60 PUSH1 0x40 0BE5 51 MLOAD 0BE6 80 DUP1 0BE7 86 DUP7 0BE8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BFD 16 AND 0BFE 81 DUP2 0BFF 52 MSTORE 0C00 60 PUSH1 0x20 0C02 01 ADD 0C03 85 DUP6 0C04 81 DUP2 0C05 52 MSTORE 0C06 60 PUSH1 0x20 0C08 01 ADD 0C09 84 DUP5 0C0A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C1F 16 AND 0C20 81 DUP2 0C21 52 MSTORE 0C22 60 PUSH1 0x20 0C24 01 ADD 0C25 80 DUP1 0C26 60 PUSH1 0x20 0C28 01 ADD 0C29 82 DUP3 0C2A 81 DUP2 0C2B 03 SUB 0C2C 82 DUP3 0C2D 52 MSTORE 0C2E 84 DUP5 0C2F 84 DUP5 0C30 82 DUP3 0C31 81 DUP2 0C32 81 DUP2 0C33 52 MSTORE 0C34 60 PUSH1 0x20 0C36 01 ADD 0C37 92 SWAP3 0C38 50 POP 0C39 80 DUP1 0C3A 82 DUP3 0C3B 84 DUP5 0C3C 37 CALLDATACOPY 0C3D 82 DUP3 0C3E 01 ADD 0C3F 91 SWAP2 0C40 50 POP 0C41 50 POP 0C42 96 SWAP7 0C43 50 POP 0C44 50 POP 0C45 50 POP 0C46 50 POP 0C47 50 POP 0C48 50 POP 0C49 50 POP 0C4A 60 PUSH1 0x40 0C4C 51 MLOAD 0C4D 80 DUP1 0C4E 91 SWAP2 0C4F 03 SUB 0C50 90 SWAP1 0C51 A1 LOG1 0C52 84 DUP5 0C53 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C68 16 AND 0C69 84 DUP5 0C6A 84 DUP5 0C6B 84 DUP5 0C6C 60 PUSH1 0x40 0C6E 51 MLOAD 0C6F 80 DUP1 0C70 83 DUP4 0C71 83 DUP4 0C72 80 DUP1 0C73 82 DUP3 0C74 84 DUP5 0C75 37 CALLDATACOPY 0C76 82 DUP3 0C77 01 ADD 0C78 91 SWAP2 0C79 50 POP 0C7A 50 POP 0C7B 92 SWAP3 0C7C 50 POP 0C7D 50 POP 0C7E 50 POP 0C7F 60 PUSH1 0x00 0C81 60 PUSH1 0x40 0C83 51 MLOAD 0C84 80 DUP1 0C85 83 DUP4 0C86 03 SUB 0C87 81 DUP2 0C88 85 DUP6 0C89 87 DUP8 0C8A 61 PUSH2 0x8502 0C8D 5A GAS 0C8E 03 SUB 0C8F F1 CALL 0C90 92 SWAP3 0C91 50 POP 0C92 50 POP 0C93 50 POP 0C94 50 POP 0C95 60 PUSH1 0x00 0C97 60 PUSH1 0x01 0C99 02 MUL 0C9A 90 SWAP1 0C9B 50 POP 0C9C 61 PUSH2 0x0f06 0C9F 56 *JUMP // Stack delta = +0 // Outputs[10] // { // @0BFF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0C05 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-4] // @0C21 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0C2D memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0C33 memory[0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = stack[-2] // @0C3C memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0C51 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + stack[-2]) - memory[0x40:0x60]], [0x92ca3a80853e6663fa31fa10b99225f18d4902939b4c53a9caae9043f6efd004]); // @0C75 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0C8F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).call.gas(msg.gas - 0x8502).value(stack[-4])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + stack[-2]) - memory[0x40:0x60]]) // @0C9A stack[-1] = 0x01 * 0x00 // } // Block ends with unconditional jump to 0x0f06 label_0CA0: // Incoming jump from 0x0BBC, if !stack[-1] // Inputs[7] // { // @0CA3 msg.data.length // @0CA4 block.number // @0CA7 memory[0x40:0x60] // @0CAE msg.data[0x00:0x00 + msg.data.length] // @0CC1 memory[0x40:0x60] // @0CC6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]] // @0CC7 stack[-1] // } 0CA0 5B JUMPDEST 0CA1 60 PUSH1 0x00 0CA3 36 CALLDATASIZE 0CA4 43 NUMBER 0CA5 60 PUSH1 0x40 0CA7 51 MLOAD 0CA8 80 DUP1 0CA9 84 DUP5 0CAA 84 DUP5 0CAB 80 DUP1 0CAC 82 DUP3 0CAD 84 DUP5 0CAE 37 CALLDATACOPY 0CAF 82 DUP3 0CB0 01 ADD 0CB1 91 SWAP2 0CB2 50 POP 0CB3 50 POP 0CB4 82 DUP3 0CB5 81 DUP2 0CB6 52 MSTORE 0CB7 60 PUSH1 0x20 0CB9 01 ADD 0CBA 93 SWAP4 0CBB 50 POP 0CBC 50 POP 0CBD 50 POP 0CBE 50 POP 0CBF 60 PUSH1 0x40 0CC1 51 MLOAD 0CC2 80 DUP1 0CC3 91 SWAP2 0CC4 03 SUB 0CC5 90 SWAP1 0CC6 20 SHA3 0CC7 90 SWAP1 0CC8 50 POP 0CC9 80 DUP1 0CCA 50 POP 0CCB 61 PUSH2 0x0cd3 0CCE 81 DUP2 0CCF 61 PUSH2 0x0f0e 0CD2 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @0CAE memory[memory[0x40:0x60]:memory[0x40:0x60] + msg.data.length] = msg.data[0x00:0x00 + msg.data.length] // @0CB6 memory[memory[0x40:0x60] + msg.data.length:memory[0x40:0x60] + msg.data.length + 0x20] = block.number // @0CC7 stack[-1] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]]) // @0CCB stack[0] = 0x0cd3 // @0CCE stack[1] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60] + msg.data.length) - memory[0x40:0x60]]) // } // Block ends with call to 0x0f0e, returns to 0x0CD3 label_0CD3: // Incoming return from call to 0x0F0E at 0x0CD2 // Inputs[1] { @0CD4 stack[-1] } 0CD3 5B JUMPDEST 0CD4 15 ISZERO 0CD5 80 DUP1 0CD6 15 ISZERO 0CD7 61 PUSH2 0x0d33 0CDA 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0CD4 stack[-1] = !stack[-1] } // Block ends with conditional jump to 0x0d33, if !!stack[-1] label_0CDB: // Incoming jump from 0x0CDA, if not !!stack[-1] // Inputs[3] // { // @0CE6 stack[-2] // @0CF4 memory[0x00:0x40] // @0CFE storage[0x00 + keccak256(memory[0x00:0x40])] // } 0CDB 50 POP 0CDC 60 PUSH1 0x00 0CDE 61 PUSH2 0x0109 0CE1 60 PUSH1 0x00 0CE3 50 POP 0CE4 60 PUSH1 0x00 0CE6 83 DUP4 0CE7 81 DUP2 0CE8 52 MSTORE 0CE9 60 PUSH1 0x20 0CEB 01 ADD 0CEC 90 SWAP1 0CED 81 DUP2 0CEE 52 MSTORE 0CEF 60 PUSH1 0x20 0CF1 01 ADD 0CF2 60 PUSH1 0x00 0CF4 20 SHA3 0CF5 60 PUSH1 0x00 0CF7 50 POP 0CF8 60 PUSH1 0x00 0CFA 01 ADD 0CFB 60 PUSH1 0x00 0CFD 90 SWAP1 0CFE 54 SLOAD 0CFF 90 SWAP1 0D00 61 PUSH2 0x0100 0D03 0A EXP 0D04 90 SWAP1 0D05 04 DIV 0D06 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D1B 16 AND 0D1C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D31 16 AND 0D32 14 EQ 0D33 5B JUMPDEST 0D34 15 ISZERO 0D35 61 PUSH2 0x0f04 0D38 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0CE8 memory[0x00:0x20] = stack[-2] // @0CEE memory[0x20:0x40] = 0x0109 // } // Block ends with conditional jump to 0x0f04, if !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00 + keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0x00) label_0D39: // Incoming jump from 0x0D38, if not !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00 + keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0x00) // Incoming jump from 0x0D38, if not !stack[-1] // Inputs[11] // { // @0D39 stack[-5] // @0D42 stack[-1] // @0D50 memory[0x00:0x40] // @0D5E storage[0x00 + keccak256(memory[0x00:0x40])] // @0D7F stack[-4] // @0D96 memory[0x00:0x40] // @0DA4 stack[-3] // @0DA5 stack[-2] // @0DBC memory[0x00:0x40] // @0DCA storage[0x02 + keccak256(memory[0x00:0x40])] // @0DE4 memory[0x00:0x20] // } 0D39 84 DUP5 0D3A 61 PUSH2 0x0109 0D3D 60 PUSH1 0x00 0D3F 50 POP 0D40 60 PUSH1 0x00 0D42 83 DUP4 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 50 POP 0D54 60 PUSH1 0x00 0D56 01 ADD 0D57 60 PUSH1 0x00 0D59 61 PUSH2 0x0100 0D5C 0A EXP 0D5D 81 DUP2 0D5E 54 SLOAD 0D5F 81 DUP2 0D60 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D75 02 MUL 0D76 19 NOT 0D77 16 AND 0D78 90 SWAP1 0D79 83 DUP4 0D7A 02 MUL 0D7B 17 OR 0D7C 90 SWAP1 0D7D 55 SSTORE 0D7E 50 POP 0D7F 83 DUP4 0D80 61 PUSH2 0x0109 0D83 60 PUSH1 0x00 0D85 50 POP 0D86 60 PUSH1 0x00 0D88 83 DUP4 0D89 81 DUP2 0D8A 52 MSTORE 0D8B 60 PUSH1 0x20 0D8D 01 ADD 0D8E 90 SWAP1 0D8F 81 DUP2 0D90 52 MSTORE 0D91 60 PUSH1 0x20 0D93 01 ADD 0D94 60 PUSH1 0x00 0D96 20 SHA3 0D97 60 PUSH1 0x00 0D99 50 POP 0D9A 60 PUSH1 0x01 0D9C 01 ADD 0D9D 60 PUSH1 0x00 0D9F 50 POP 0DA0 81 DUP2 0DA1 90 SWAP1 0DA2 55 SSTORE 0DA3 50 POP 0DA4 82 DUP3 0DA5 82 DUP3 0DA6 61 PUSH2 0x0109 0DA9 60 PUSH1 0x00 0DAB 50 POP 0DAC 60 PUSH1 0x00 0DAE 84 DUP5 0DAF 81 DUP2 0DB0 52 MSTORE 0DB1 60 PUSH1 0x20 0DB3 01 ADD 0DB4 90 SWAP1 0DB5 81 DUP2 0DB6 52 MSTORE 0DB7 60 PUSH1 0x20 0DB9 01 ADD 0DBA 60 PUSH1 0x00 0DBC 20 SHA3 0DBD 60 PUSH1 0x00 0DBF 50 POP 0DC0 60 PUSH1 0x02 0DC2 01 ADD 0DC3 60 PUSH1 0x00 0DC5 50 POP 0DC6 91 SWAP2 0DC7 90 SWAP1 0DC8 82 DUP3 0DC9 80 DUP1 0DCA 54 SLOAD 0DCB 60 PUSH1 0x01 0DCD 81 DUP2 0DCE 60 PUSH1 0x01 0DD0 16 AND 0DD1 15 ISZERO 0DD2 61 PUSH2 0x0100 0DD5 02 MUL 0DD6 03 SUB 0DD7 16 AND 0DD8 60 PUSH1 0x02 0DDA 90 SWAP1 0DDB 04 DIV 0DDC 90 SWAP1 0DDD 60 PUSH1 0x00 0DDF 52 MSTORE 0DE0 60 PUSH1 0x20 0DE2 60 PUSH1 0x00 0DE4 20 SHA3 0DE5 90 SWAP1 0DE6 60 PUSH1 0x1f 0DE8 01 ADD 0DE9 60 PUSH1 0x20 0DEB 90 SWAP1 0DEC 04 DIV 0DED 81 DUP2 0DEE 01 ADD 0DEF 92 SWAP3 0DF0 82 DUP3 0DF1 60 PUSH1 0x1f 0DF3 10 LT 0DF4 61 PUSH2 0x0e08 0DF7 57 *JUMPI // Stack delta = +5 // Outputs[14] // { // @0D44 memory[0x00:0x20] = stack[-1] // @0D4A memory[0x20:0x40] = 0x0109 // @0D7D storage[0x00 + keccak256(memory[0x00:0x40])] = stack[-5] * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x00 + keccak256(memory[0x00:0x40])]) // @0D8A memory[0x00:0x20] = stack[-1] // @0D90 memory[0x20:0x40] = 0x0109 // @0DA2 storage[0x01 + keccak256(memory[0x00:0x40])] = stack[-4] // @0DB0 memory[0x00:0x20] = stack[-1] // @0DB6 memory[0x20:0x40] = 0x0109 // @0DC6 stack[0] = 0x02 + keccak256(memory[0x00:0x40]) // @0DC7 stack[2] = stack[-2] // @0DDF memory[0x00:0x20] = 0x02 + keccak256(memory[0x00:0x40]) // @0DE5 stack[3] = keccak256(memory[0x00:0x20]) // @0DEF stack[1] = keccak256(memory[0x00:0x20]) + (0x1f + (0x0100 * !(0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) - 0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) / 0x02) / 0x20 // @0DEF stack[4] = stack[-3] // } // Block ends with conditional jump to 0x0e08, if 0x1f < stack[-2] label_0DF8: // Incoming jump from 0x0DF7, if not 0x1f < stack[-2] // Inputs[4] // { // @0DF8 stack[-1] // @0DF9 msg.data[stack[-1]:stack[-1] + 0x20] // @0DFE stack[-3] // @0E02 stack[-5] // } 0DF8 80 DUP1 0DF9 35 CALLDATALOAD 0DFA 60 PUSH1 0xff 0DFC 19 NOT 0DFD 16 AND 0DFE 83 DUP4 0DFF 80 DUP1 0E00 01 ADD 0E01 17 OR 0E02 85 DUP6 0E03 55 SSTORE 0E04 61 PUSH2 0x0e39 0E07 56 *JUMP // Stack delta = +0 // Outputs[1] { @0E03 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & msg.data[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x0e39 label_0E08: // Incoming jump from 0x0DF7, if 0x1f < stack[-2] // Inputs[2] // { // @0E09 stack[-3] // @0E0F stack[-5] // } 0E08 5B JUMPDEST 0E09 82 DUP3 0E0A 80 DUP1 0E0B 01 ADD 0E0C 60 PUSH1 0x01 0E0E 01 ADD 0E0F 85 DUP6 0E10 55 SSTORE 0E11 82 DUP3 0E12 15 ISZERO 0E13 61 PUSH2 0x0e39 0E16 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0E10 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x0e39, if !stack[-3] label_0E17: // Incoming jump from 0x0E16, if not !stack[-3] // Inputs[2] // { // @0E17 stack[-1] // @0E17 stack[-3] // } 0E17 91 SWAP2 0E18 82 DUP3 0E19 01 ADD 0E1A 5B JUMPDEST 0E1B 82 DUP3 0E1C 81 DUP2 0E1D 11 GT 0E1E 15 ISZERO 0E1F 61 PUSH2 0x0e38 0E22 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0E17 stack[-3] = stack[-1] // @0E19 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x0e38, if !(stack[-1] + stack[-3] > stack[-1]) label_0E23: // Incoming jump from 0x0E22, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x0E22, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @0E23 stack[-3] // @0E24 msg.data[stack[-3]:stack[-3] + 0x20] // @0E25 stack[-2] // @0E2A stack[-1] // } 0E23 82 DUP3 0E24 35 CALLDATALOAD 0E25 82 DUP3 0E26 60 PUSH1 0x00 0E28 50 POP 0E29 55 SSTORE 0E2A 91 SWAP2 0E2B 60 PUSH1 0x20 0E2D 01 ADD 0E2E 91 SWAP2 0E2F 90 SWAP1 0E30 60 PUSH1 0x01 0E32 01 ADD 0E33 90 SWAP1 0E34 61 PUSH2 0x0e1a 0E37 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0E29 storage[stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20] // @0E2E stack[-3] = 0x20 + stack[-3] // @0E33 stack[-2] = 0x01 + stack[-2] // @0E33 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x0e1a label_0E38: // Incoming jump from 0x0E22, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x0E22, if !(stack[-1] > stack[-3]) 0E38 5B JUMPDEST // Stack delta = +0 // Block continues label_0E39: // Incoming jump from 0x0E16, if !stack[-3] // Incoming jump from 0x0E38 // Incoming jump from 0x0E07 // Inputs[3] // { // @0E3B stack[-3] // @0E3B stack[-2] // @0E40 stack[-4] // } 0E39 5B JUMPDEST 0E3A 50 POP 0E3B 90 SWAP1 0E3C 50 POP 0E3D 61 PUSH2 0x0e64 0E40 91 SWAP2 0E41 90 SWAP1 0E42 61 PUSH2 0x0e46 0E45 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0E40 stack[-4] = 0x0e64 // @0E41 stack[-2] = stack[-2] // @0E41 stack[-3] = stack[-4] // } // Block ends with call to 0x0e46, returns to 0x0E64 label_0E46: // Incoming call from 0x0E45, returns to 0x0E64 // Incoming jump from 0x0E5F // Inputs[2] // { // @0E47 stack[-1] // @0E48 stack[-2] // } 0E46 5B JUMPDEST 0E47 80 DUP1 0E48 82 DUP3 0E49 11 GT 0E4A 15 ISZERO 0E4B 61 PUSH2 0x0e60 0E4E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e60, if !(stack[-2] > stack[-1]) label_0E4F: // Incoming jump from 0x0E4E, if not !(stack[-2] > stack[-1]) // Inputs[1] { @0E51 stack[-1] } 0E4F 60 PUSH1 0x00 0E51 81 DUP2 0E52 81 DUP2 0E53 50 POP 0E54 60 PUSH1 0x00 0E56 90 SWAP1 0E57 55 SSTORE 0E58 50 POP 0E59 60 PUSH1 0x01 0E5B 01 ADD 0E5C 61 PUSH2 0x0e46 0E5F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0E57 storage[stack[-1]] = 0x00 // @0E5B stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x0e46 label_0E60: // Incoming jump from 0x0E4E, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @0E62 stack[-3] // @0E62 stack[-2] // } 0E60 5B JUMPDEST 0E61 50 POP 0E62 90 SWAP1 0E63 56 *JUMP // Stack delta = -2 // Outputs[1] { @0E62 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_0E64: // Incoming return from call to 0x0E46 at 0x0E45 // Inputs[10] // { // @0E88 stack[-3] // @0E89 msg.sender // @0E8A stack[-6] // @0E8B stack[-7] // @0E8C stack[-5] // @0E8D stack[-4] // @0E90 memory[0x40:0x60] // @0EED msg.data[stack[-5]:stack[-5] + stack[-4]] // @0EFE memory[0x40:0x60] // @0F03 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + stack[-4]) - memory[0x40:0x60]] // } 0E64 5B JUMPDEST 0E65 50 POP 0E66 50 POP 0E67 7F PUSH32 0x1733cbb53659d713b79580f79f3f9ff215f78a7c7aa45890f3b89fc5cddfbf32 0E88 81 DUP2 0E89 33 CALLER 0E8A 86 DUP7 0E8B 88 DUP9 0E8C 87 DUP8 0E8D 87 DUP8 0E8E 60 PUSH1 0x40 0E90 51 MLOAD 0E91 80 DUP1 0E92 87 DUP8 0E93 81 DUP2 0E94 52 MSTORE 0E95 60 PUSH1 0x20 0E97 01 ADD 0E98 86 DUP7 0E99 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EAE 16 AND 0EAF 81 DUP2 0EB0 52 MSTORE 0EB1 60 PUSH1 0x20 0EB3 01 ADD 0EB4 85 DUP6 0EB5 81 DUP2 0EB6 52 MSTORE 0EB7 60 PUSH1 0x20 0EB9 01 ADD 0EBA 84 DUP5 0EBB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0ED0 16 AND 0ED1 81 DUP2 0ED2 52 MSTORE 0ED3 60 PUSH1 0x20 0ED5 01 ADD 0ED6 80 DUP1 0ED7 60 PUSH1 0x20 0ED9 01 ADD 0EDA 82 DUP3 0EDB 81 DUP2 0EDC 03 SUB 0EDD 82 DUP3 0EDE 52 MSTORE 0EDF 84 DUP5 0EE0 84 DUP5 0EE1 82 DUP3 0EE2 81 DUP2 0EE3 81 DUP2 0EE4 52 MSTORE 0EE5 60 PUSH1 0x20 0EE7 01 ADD 0EE8 92 SWAP3 0EE9 50 POP 0EEA 80 DUP1 0EEB 82 DUP3 0EEC 84 DUP5 0EED 37 CALLDATACOPY 0EEE 82 DUP3 0EEF 01 ADD 0EF0 91 SWAP2 0EF1 50 POP 0EF2 50 POP 0EF3 97 SWAP8 0EF4 50 POP 0EF5 50 POP 0EF6 50 POP 0EF7 50 POP 0EF8 50 POP 0EF9 50 POP 0EFA 50 POP 0EFB 50 POP 0EFC 60 PUSH1 0x40 0EFE 51 MLOAD 0EFF 80 DUP1 0F00 91 SWAP2 0F01 03 SUB 0F02 90 SWAP1 0F03 A1 LOG1 // Stack delta = -2 // Outputs[8] // { // @0E94 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @0EB0 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0EB6 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = stack[-6] // @0ED2 memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @0EDE memory[0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0EE4 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = stack[-4] // @0EED memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + stack[-4]] = msg.data[stack[-5]:stack[-5] + stack[-4]] // @0F03 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + stack[-4]) - memory[0x40:0x60]], [0x1733cbb53659d713b79580f79f3f9ff215f78a7c7aa45890f3b89fc5cddfbf32]); // } // Block continues label_0F04: // Incoming jump from 0x0D38, if !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00 + keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0x00) // Incoming jump from 0x0F03 // Incoming jump from 0x0D38, if !stack[-1] 0F04 5B JUMPDEST // Stack delta = +0 // Block continues label_0F05: // Incoming jump from 0x0F04 // Incoming jump from 0x0BAE, if !stack[-1] // Inputs[3] // { // @0F07 stack[-6] // @0F07 stack[-1] // @0F08 stack[-5] // } 0F05 5B JUMPDEST 0F06 5B JUMPDEST 0F07 94 SWAP5 0F08 93 SWAP4 0F09 50 POP 0F0A 50 POP 0F0B 50 POP 0F0C 50 POP 0F0D 56 *JUMP // Stack delta = -5 // Outputs[1] { @0F07 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0F0E: // Incoming call from 0x0CD2, returns to 0x0CD3 // Incoming call from 0x028F, returns to 0x0290 // Inputs[1] { @0F11 stack[-1] } 0F0E 5B JUMPDEST 0F0F 60 PUSH1 0x00 0F11 81 DUP2 0F12 61 PUSH2 0x0f1a 0F15 81 DUP2 0F16 61 PUSH2 0x12db 0F19 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F0F stack[0] = 0x00 // @0F11 stack[1] = stack[-1] // @0F12 stack[2] = 0x0f1a // @0F15 stack[3] = stack[-1] // } // Block ends with call to 0x12db, returns to 0x0F1A label_0F1A: // Incoming return from call to 0x12DB at 0x0F19 // Inputs[1] { @0F1B stack[-1] } 0F1A 5B JUMPDEST 0F1B 15 ISZERO 0F1C 61 PUSH2 0x12d4 0F1F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x12d4, if !stack[-1] label_0F20: // Incoming jump from 0x0F1F, if not !stack[-1] // Inputs[3] // { // @0F2A stack[-3] // @0F38 memory[0x00:0x40] // @0F42 storage[0x00 + keccak256(memory[0x00:0x40])] // } 0F20 60 PUSH1 0x00 0F22 61 PUSH2 0x0109 0F25 60 PUSH1 0x00 0F27 50 POP 0F28 60 PUSH1 0x00 0F2A 85 DUP6 0F2B 81 DUP2 0F2C 52 MSTORE 0F2D 60 PUSH1 0x20 0F2F 01 ADD 0F30 90 SWAP1 0F31 81 DUP2 0F32 52 MSTORE 0F33 60 PUSH1 0x20 0F35 01 ADD 0F36 60 PUSH1 0x00 0F38 20 SHA3 0F39 60 PUSH1 0x00 0F3B 50 POP 0F3C 60 PUSH1 0x00 0F3E 01 ADD 0F3F 60 PUSH1 0x00 0F41 90 SWAP1 0F42 54 SLOAD 0F43 90 SWAP1 0F44 61 PUSH2 0x0100 0F47 0A EXP 0F48 90 SWAP1 0F49 04 DIV 0F4A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F5F 16 AND 0F60 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F75 16 AND 0F76 14 EQ 0F77 15 ISZERO 0F78 15 ISZERO 0F79 61 PUSH2 0x12d3 0F7C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0F2C memory[0x00:0x20] = stack[-3] // @0F32 memory[0x20:0x40] = 0x0109 // } // Block ends with conditional jump to 0x12d3, if !!(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00 + keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0x00) label_0F7D: // Incoming jump from 0x0F7C, if not !!(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00 + keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0x00) // Inputs[8] // { // @0F85 stack[-3] // @0F93 memory[0x00:0x40] // @0F9D storage[0x00 + keccak256(memory[0x00:0x40])] // @0FE7 memory[0x00:0x40] // @0FF1 storage[0x01 + keccak256(memory[0x00:0x40])] // @1008 memory[0x00:0x40] // @1014 memory[0x40:0x60] // @1018 storage[0x02 + keccak256(memory[0x00:0x40])] // } 0F7D 61 PUSH2 0x0109 0F80 60 PUSH1 0x00 0F82 50 POP 0F83 60 PUSH1 0x00 0F85 84 DUP5 0F86 81 DUP2 0F87 52 MSTORE 0F88 60 PUSH1 0x20 0F8A 01 ADD 0F8B 90 SWAP1 0F8C 81 DUP2 0F8D 52 MSTORE 0F8E 60 PUSH1 0x20 0F90 01 ADD 0F91 60 PUSH1 0x00 0F93 20 SHA3 0F94 60 PUSH1 0x00 0F96 50 POP 0F97 60 PUSH1 0x00 0F99 01 ADD 0F9A 60 PUSH1 0x00 0F9C 90 SWAP1 0F9D 54 SLOAD 0F9E 90 SWAP1 0F9F 61 PUSH2 0x0100 0FA2 0A EXP 0FA3 90 SWAP1 0FA4 04 DIV 0FA5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FBA 16 AND 0FBB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FD0 16 AND 0FD1 61 PUSH2 0x0109 0FD4 60 PUSH1 0x00 0FD6 50 POP 0FD7 60 PUSH1 0x00 0FD9 85 DUP6 0FDA 81 DUP2 0FDB 52 MSTORE 0FDC 60 PUSH1 0x20 0FDE 01 ADD 0FDF 90 SWAP1 0FE0 81 DUP2 0FE1 52 MSTORE 0FE2 60 PUSH1 0x20 0FE4 01 ADD 0FE5 60 PUSH1 0x00 0FE7 20 SHA3 0FE8 60 PUSH1 0x00 0FEA 50 POP 0FEB 60 PUSH1 0x01 0FED 01 ADD 0FEE 60 PUSH1 0x00 0FF0 50 POP 0FF1 54 SLOAD 0FF2 61 PUSH2 0x0109 0FF5 60 PUSH1 0x00 0FF7 50 POP 0FF8 60 PUSH1 0x00 0FFA 86 DUP7 0FFB 81 DUP2 0FFC 52 MSTORE 0FFD 60 PUSH1 0x20 0FFF 01 ADD 1000 90 SWAP1 1001 81 DUP2 1002 52 MSTORE 1003 60 PUSH1 0x20 1005 01 ADD 1006 60 PUSH1 0x00 1008 20 SHA3 1009 60 PUSH1 0x00 100B 50 POP 100C 60 PUSH1 0x02 100E 01 ADD 100F 60 PUSH1 0x00 1011 50 POP 1012 60 PUSH1 0x40 1014 51 MLOAD 1015 80 DUP1 1016 82 DUP3 1017 80 DUP1 1018 54 SLOAD 1019 60 PUSH1 0x01 101B 81 DUP2 101C 60 PUSH1 0x01 101E 16 AND 101F 15 ISZERO 1020 61 PUSH2 0x0100 1023 02 MUL 1024 03 SUB 1025 16 AND 1026 60 PUSH1 0x02 1028 90 SWAP1 1029 04 DIV 102A 80 DUP1 102B 15 ISZERO 102C 61 PUSH2 0x1076 102F 57 *JUMPI // Stack delta = +7 // Outputs[13] // { // @0F87 memory[0x00:0x20] = stack[-3] // @0F8D memory[0x20:0x40] = 0x0109 // @0FD0 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00 + keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // @0FDB memory[0x00:0x20] = stack[-3] // @0FE1 memory[0x20:0x40] = 0x0109 // @0FF1 stack[1] = storage[0x01 + keccak256(memory[0x00:0x40])] // @0FFC memory[0x00:0x20] = stack[-3] // @1002 memory[0x20:0x40] = 0x0109 // @100E stack[2] = 0x02 + keccak256(memory[0x00:0x40]) // @1014 stack[3] = memory[0x40:0x60] // @1015 stack[4] = memory[0x40:0x60] // @1016 stack[5] = 0x02 + keccak256(memory[0x00:0x40]) // @1029 stack[6] = (0x0100 * !(0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) - 0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) / 0x02 // } // Block ends with conditional jump to 0x1076, if !((0x0100 * !(0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) - 0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) / 0x02) label_1030: // Incoming jump from 0x102F, if not !((0x0100 * !(0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) - 0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[1] { @1030 stack[-1] } 1030 80 DUP1 1031 60 PUSH1 0x1f 1033 10 LT 1034 61 PUSH2 0x104b 1037 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x104b, if 0x1f < stack[-1] label_1038: // Incoming jump from 0x1037, if not 0x1f < stack[-1] // Inputs[4] // { // @103C stack[-2] // @103D storage[stack[-2]] // @1040 stack[-3] // @1042 stack[-1] // } 1038 61 PUSH2 0x0100 103B 80 DUP1 103C 83 DUP4 103D 54 SLOAD 103E 04 DIV 103F 02 MUL 1040 83 DUP4 1041 52 MSTORE 1042 91 SWAP2 1043 60 PUSH1 0x20 1045 01 ADD 1046 91 SWAP2 1047 61 PUSH2 0x1076 104A 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1041 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1046 stack[-1] = stack[-1] // @1046 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1076 label_104B: // Incoming jump from 0x1037, if 0x1f < stack[-1] // Inputs[5] // { // @104C stack[-3] // @104D stack[-1] // @104F stack[-2] // @1057 memory[0x00:0x20] // @105B storage[keccak256(memory[0x00:0x20])] // } 104B 5B JUMPDEST 104C 82 DUP3 104D 01 ADD 104E 91 SWAP2 104F 90 SWAP1 1050 60 PUSH1 0x00 1052 52 MSTORE 1053 60 PUSH1 0x20 1055 60 PUSH1 0x00 1057 20 SHA3 1058 90 SWAP1 1059 5B JUMPDEST 105A 81 DUP2 105B 54 SLOAD 105C 81 DUP2 105D 52 MSTORE 105E 90 SWAP1 105F 60 PUSH1 0x01 1061 01 ADD 1062 90 SWAP1 1063 60 PUSH1 0x20 1065 01 ADD 1066 80 DUP1 1067 83 DUP4 1068 11 GT 1069 61 PUSH2 0x1059 106C 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @104E stack[-3] = stack[-3] + stack[-1] // @1052 memory[0x00:0x20] = stack[-2] // @105D memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1062 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1065 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1059, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_106D: // Incoming jump from 0x106C, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x106C, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @106D stack[-3] // @106E stack[-1] // } 106D 82 DUP3 106E 90 SWAP1 106F 03 SUB 1070 60 PUSH1 0x1f 1072 16 AND 1073 82 DUP3 1074 01 ADD 1075 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1075 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1075 stack[-1] = stack[-3] // } // Block continues label_1076: // Incoming jump from 0x1075 // Incoming jump from 0x102F, if !((0x0100 * !(0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) - 0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) / 0x02) // Incoming jump from 0x104A // Inputs[18] // { // @1079 stack[-5] // @1079 stack[-3] // @1080 memory[0x40:0x60] // @1085 stack[-6] // @1086 stack[-7] // @108A msg.gas // @108C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-3] - memory[0x40:0x60]] // @108C address(stack[-7]).call.gas(msg.gas - 0x8502).value(stack[-6])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-3] - memory[0x40:0x60]]) // @10B3 msg.sender // @10B4 stack[-10] // @10CB memory[0x00:0x40] // @10D5 storage[0x01 + keccak256(memory[0x00:0x40])] // @10EC memory[0x00:0x40] // @10F6 storage[0x00 + keccak256(memory[0x00:0x40])] // @112A memory[0x00:0x40] // @1136 memory[0x40:0x60] // @1188 storage[0x02 + keccak256(memory[0x00:0x40])] // @11A2 storage[0x02 + keccak256(memory[0x00:0x40])] // } 1076 5B JUMPDEST 1077 50 POP 1078 50 POP 1079 91 SWAP2 107A 50 POP 107B 50 POP 107C 60 PUSH1 0x00 107E 60 PUSH1 0x40 1080 51 MLOAD 1081 80 DUP1 1082 83 DUP4 1083 03 SUB 1084 81 DUP2 1085 85 DUP6 1086 87 DUP8 1087 61 PUSH2 0x8502 108A 5A GAS 108B 03 SUB 108C F1 CALL 108D 92 SWAP3 108E 50 POP 108F 50 POP 1090 50 POP 1091 50 POP 1092 7F PUSH32 0xe7c957c06e9a662c1a6c77366179f5b702b97651dc28eee7d5bf1dff6e40bb4a 10B3 33 CALLER 10B4 84 DUP5 10B5 61 PUSH2 0x0109 10B8 60 PUSH1 0x00 10BA 50 POP 10BB 60 PUSH1 0x00 10BD 87 DUP8 10BE 81 DUP2 10BF 52 MSTORE 10C0 60 PUSH1 0x20 10C2 01 ADD 10C3 90 SWAP1 10C4 81 DUP2 10C5 52 MSTORE 10C6 60 PUSH1 0x20 10C8 01 ADD 10C9 60 PUSH1 0x00 10CB 20 SHA3 10CC 60 PUSH1 0x00 10CE 50 POP 10CF 60 PUSH1 0x01 10D1 01 ADD 10D2 60 PUSH1 0x00 10D4 50 POP 10D5 54 SLOAD 10D6 61 PUSH2 0x0109 10D9 60 PUSH1 0x00 10DB 50 POP 10DC 60 PUSH1 0x00 10DE 88 DUP9 10DF 81 DUP2 10E0 52 MSTORE 10E1 60 PUSH1 0x20 10E3 01 ADD 10E4 90 SWAP1 10E5 81 DUP2 10E6 52 MSTORE 10E7 60 PUSH1 0x20 10E9 01 ADD 10EA 60 PUSH1 0x00 10EC 20 SHA3 10ED 60 PUSH1 0x00 10EF 50 POP 10F0 60 PUSH1 0x00 10F2 01 ADD 10F3 60 PUSH1 0x00 10F5 90 SWAP1 10F6 54 SLOAD 10F7 90 SWAP1 10F8 61 PUSH2 0x0100 10FB 0A EXP 10FC 90 SWAP1 10FD 04 DIV 10FE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1113 16 AND 1114 61 PUSH2 0x0109 1117 60 PUSH1 0x00 1119 50 POP 111A 60 PUSH1 0x00 111C 89 DUP10 111D 81 DUP2 111E 52 MSTORE 111F 60 PUSH1 0x20 1121 01 ADD 1122 90 SWAP1 1123 81 DUP2 1124 52 MSTORE 1125 60 PUSH1 0x20 1127 01 ADD 1128 60 PUSH1 0x00 112A 20 SHA3 112B 60 PUSH1 0x00 112D 50 POP 112E 60 PUSH1 0x02 1130 01 ADD 1131 60 PUSH1 0x00 1133 50 POP 1134 60 PUSH1 0x40 1136 51 MLOAD 1137 80 DUP1 1138 86 DUP7 1139 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 114E 16 AND 114F 81 DUP2 1150 52 MSTORE 1151 60 PUSH1 0x20 1153 01 ADD 1154 85 DUP6 1155 81 DUP2 1156 52 MSTORE 1157 60 PUSH1 0x20 1159 01 ADD 115A 84 DUP5 115B 81 DUP2 115C 52 MSTORE 115D 60 PUSH1 0x20 115F 01 ADD 1160 83 DUP4 1161 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1176 16 AND 1177 81 DUP2 1178 52 MSTORE 1179 60 PUSH1 0x20 117B 01 ADD 117C 80 DUP1 117D 60 PUSH1 0x20 117F 01 ADD 1180 82 DUP3 1181 81 DUP2 1182 03 SUB 1183 82 DUP3 1184 52 MSTORE 1185 83 DUP4 1186 81 DUP2 1187 81 DUP2 1188 54 SLOAD 1189 60 PUSH1 0x01 118B 81 DUP2 118C 60 PUSH1 0x01 118E 16 AND 118F 15 ISZERO 1190 61 PUSH2 0x0100 1193 02 MUL 1194 03 SUB 1195 16 AND 1196 60 PUSH1 0x02 1198 90 SWAP1 1199 04 DIV 119A 81 DUP2 119B 52 MSTORE 119C 60 PUSH1 0x20 119E 01 ADD 119F 91 SWAP2 11A0 50 POP 11A1 80 DUP1 11A2 54 SLOAD 11A3 60 PUSH1 0x01 11A5 81 DUP2 11A6 60 PUSH1 0x01 11A8 16 AND 11A9 15 ISZERO 11AA 61 PUSH2 0x0100 11AD 02 MUL 11AE 03 SUB 11AF 16 AND 11B0 60 PUSH1 0x02 11B2 90 SWAP1 11B3 04 DIV 11B4 80 DUP1 11B5 15 ISZERO 11B6 61 PUSH2 0x1200 11B9 57 *JUMPI // Stack delta = +4 // Outputs[24] // { // @108C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-7]).call.gas(msg.gas - 0x8502).value(stack[-6])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-3] - memory[0x40:0x60]]) // @1092 stack[-7] = 0xe7c957c06e9a662c1a6c77366179f5b702b97651dc28eee7d5bf1dff6e40bb4a // @10B3 stack[-6] = msg.sender // @10B4 stack[-5] = stack[-10] // @10BF memory[0x00:0x20] = stack[-10] // @10C5 memory[0x20:0x40] = 0x0109 // @10D5 stack[-4] = storage[0x01 + keccak256(memory[0x00:0x40])] // @10E0 memory[0x00:0x20] = stack[-10] // @10E6 memory[0x20:0x40] = 0x0109 // @1113 stack[-3] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00 + keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // @111E memory[0x00:0x20] = stack[-10] // @1124 memory[0x20:0x40] = 0x0109 // @1130 stack[-2] = 0x02 + keccak256(memory[0x00:0x40]) // @1136 stack[-1] = memory[0x40:0x60] // @1150 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1156 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-10] // @115C memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = storage[0x01 + keccak256(memory[0x00:0x40])] // @1178 memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00 + keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // @117B stack[0] = 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @1184 memory[0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @1185 stack[2] = 0x02 + keccak256(memory[0x00:0x40]) // @119B memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) - 0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) / 0x02 // @119F stack[1] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] // @11B3 stack[3] = (0x0100 * !(0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) - 0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) / 0x02 // } // Block ends with conditional jump to 0x1200, if !((0x0100 * !(0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) - 0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) / 0x02) label_11BA: // Incoming jump from 0x11B9, if not !((0x0100 * !(0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) - 0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[1] { @11BA stack[-1] } 11BA 80 DUP1 11BB 60 PUSH1 0x1f 11BD 10 LT 11BE 61 PUSH2 0x11d5 11C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11d5, if 0x1f < stack[-1] label_11C2: // Incoming jump from 0x11C1, if not 0x1f < stack[-1] // Inputs[4] // { // @11C6 stack[-2] // @11C7 storage[stack[-2]] // @11CA stack[-3] // @11CC stack[-1] // } 11C2 61 PUSH2 0x0100 11C5 80 DUP1 11C6 83 DUP4 11C7 54 SLOAD 11C8 04 DIV 11C9 02 MUL 11CA 83 DUP4 11CB 52 MSTORE 11CC 91 SWAP2 11CD 60 PUSH1 0x20 11CF 01 ADD 11D0 91 SWAP2 11D1 61 PUSH2 0x1200 11D4 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @11CB memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @11D0 stack[-1] = stack[-1] // @11D0 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1200 label_11D5: // Incoming jump from 0x11C1, if 0x1f < stack[-1] // Inputs[5] // { // @11D6 stack[-3] // @11D7 stack[-1] // @11D9 stack[-2] // @11E1 memory[0x00:0x20] // @11E5 storage[keccak256(memory[0x00:0x20])] // } 11D5 5B JUMPDEST 11D6 82 DUP3 11D7 01 ADD 11D8 91 SWAP2 11D9 90 SWAP1 11DA 60 PUSH1 0x00 11DC 52 MSTORE 11DD 60 PUSH1 0x20 11DF 60 PUSH1 0x00 11E1 20 SHA3 11E2 90 SWAP1 11E3 5B JUMPDEST 11E4 81 DUP2 11E5 54 SLOAD 11E6 81 DUP2 11E7 52 MSTORE 11E8 90 SWAP1 11E9 60 PUSH1 0x01 11EB 01 ADD 11EC 90 SWAP1 11ED 60 PUSH1 0x20 11EF 01 ADD 11F0 80 DUP1 11F1 83 DUP4 11F2 11 GT 11F3 61 PUSH2 0x11e3 11F6 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @11D8 stack[-3] = stack[-3] + stack[-1] // @11DC memory[0x00:0x20] = stack[-2] // @11E7 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @11EC stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @11EF stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x11e3, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_11F7: // Incoming jump from 0x11F6, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x11F6, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @11F7 stack[-3] // @11F8 stack[-1] // } 11F7 82 DUP3 11F8 90 SWAP1 11F9 03 SUB 11FA 60 PUSH1 0x1f 11FC 16 AND 11FD 82 DUP3 11FE 01 ADD 11FF 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @11FF stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @11FF stack[-1] = stack[-3] // } // Block continues label_1200: // Incoming jump from 0x11B9, if !((0x0100 * !(0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) - 0x01 & storage[0x02 + keccak256(memory[0x00:0x40])]) / 0x02) // Incoming jump from 0x11FF // Incoming jump from 0x11D4 // Inputs[9] // { // @1203 stack[-3] // @1203 stack[-10] // @120D memory[0x40:0x60] // @1212 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-3] - memory[0x40:0x60]] // @1212 stack[-11] // @121B stack[-14] // @1229 memory[0x00:0x40] // @1237 storage[keccak256(memory[0x00:0x40]) + 0x00] // @1266 storage[keccak256(memory[0x00:0x40]) + 0x02] // } 1200 5B JUMPDEST 1201 50 POP 1202 50 POP 1203 96 SWAP7 1204 50 POP 1205 50 POP 1206 50 POP 1207 50 POP 1208 50 POP 1209 50 POP 120A 50 POP 120B 60 PUSH1 0x40 120D 51 MLOAD 120E 80 DUP1 120F 91 SWAP2 1210 03 SUB 1211 90 SWAP1 1212 A1 LOG1 1213 61 PUSH2 0x0109 1216 60 PUSH1 0x00 1218 50 POP 1219 60 PUSH1 0x00 121B 84 DUP5 121C 81 DUP2 121D 52 MSTORE 121E 60 PUSH1 0x20 1220 01 ADD 1221 90 SWAP1 1222 81 DUP2 1223 52 MSTORE 1224 60 PUSH1 0x20 1226 01 ADD 1227 60 PUSH1 0x00 1229 20 SHA3 122A 60 PUSH1 0x00 122C 60 PUSH1 0x00 122E 82 DUP3 122F 01 ADD 1230 60 PUSH1 0x00 1232 61 PUSH2 0x0100 1235 0A EXP 1236 81 DUP2 1237 54 SLOAD 1238 90 SWAP1 1239 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 124E 02 MUL 124F 19 NOT 1250 16 AND 1251 90 SWAP1 1252 55 SSTORE 1253 60 PUSH1 0x01 1255 82 DUP3 1256 01 ADD 1257 60 PUSH1 0x00 1259 50 POP 125A 60 PUSH1 0x00 125C 90 SWAP1 125D 55 SSTORE 125E 60 PUSH1 0x02 1260 82 DUP3 1261 01 ADD 1262 60 PUSH1 0x00 1264 50 POP 1265 80 DUP1 1266 54 SLOAD 1267 60 PUSH1 0x01 1269 81 DUP2 126A 60 PUSH1 0x01 126C 16 AND 126D 15 ISZERO 126E 61 PUSH2 0x0100 1271 02 MUL 1272 03 SUB 1273 16 AND 1274 60 PUSH1 0x02 1276 90 SWAP1 1277 04 DIV 1278 60 PUSH1 0x00 127A 82 DUP3 127B 55 SSTORE 127C 80 DUP1 127D 60 PUSH1 0x1f 127F 10 LT 1280 61 PUSH2 0x1289 1283 57 *JUMPI // Stack delta = -7 // Outputs[10] // { // @1212 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-3] - memory[0x40:0x60]], [stack[-11]]); // @121D memory[0x00:0x20] = stack[-14] // @1223 memory[0x20:0x40] = 0x0109 // @1229 stack[-11] = keccak256(memory[0x00:0x40]) // @122A stack[-10] = 0x00 // @1252 storage[keccak256(memory[0x00:0x40]) + 0x00] = ~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40]) + 0x00] // @125D storage[keccak256(memory[0x00:0x40]) + 0x01] = 0x00 // @1261 stack[-9] = keccak256(memory[0x00:0x40]) + 0x02 // @1277 stack[-8] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40]) + 0x02]) - 0x01 & storage[keccak256(memory[0x00:0x40]) + 0x02]) / 0x02 // @127B storage[keccak256(memory[0x00:0x40]) + 0x02] = 0x00 // } // Block ends with conditional jump to 0x1289, if 0x1f < (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40]) + 0x02]) - 0x01 & storage[keccak256(memory[0x00:0x40]) + 0x02]) / 0x02 label_1284: // Incoming jump from 0x1283, if not 0x1f < (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40]) + 0x02]) - 0x01 & storage[keccak256(memory[0x00:0x40]) + 0x02]) / 0x02 1284 50 POP 1285 61 PUSH2 0x12c6 1288 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x12c6 label_1289: // Incoming jump from 0x1283, if 0x1f < (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40]) + 0x02]) - 0x01 & storage[keccak256(memory[0x00:0x40]) + 0x02]) / 0x02 // Inputs[3] // { // @128C stack[-1] // @1291 stack[-2] // @1299 memory[0x00:0x20] // } 1289 5B JUMPDEST 128A 60 PUSH1 0x1f 128C 01 ADD 128D 60 PUSH1 0x20 128F 90 SWAP1 1290 04 DIV 1291 90 SWAP1 1292 60 PUSH1 0x00 1294 52 MSTORE 1295 60 PUSH1 0x20 1297 60 PUSH1 0x00 1299 20 SHA3 129A 90 SWAP1 129B 81 DUP2 129C 01 ADD 129D 90 SWAP1 129E 61 PUSH2 0x12c5 12A1 91 SWAP2 12A2 90 SWAP1 12A3 61 PUSH2 0x12a7 12A6 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1294 memory[0x00:0x20] = stack[-2] // @12A1 stack[-2] = 0x12c5 // @12A2 stack[-1] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // @12A2 stack[0] = keccak256(memory[0x00:0x20]) // } // Block ends with call to 0x12a7, returns to 0x12C5 label_12A7: // Incoming jump from 0x12C0 // Incoming call from 0x12A6, returns to 0x12C5 // Inputs[2] // { // @12A8 stack[-1] // @12A9 stack[-2] // } 12A7 5B JUMPDEST 12A8 80 DUP1 12A9 82 DUP3 12AA 11 GT 12AB 15 ISZERO 12AC 61 PUSH2 0x12c1 12AF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12c1, if !(stack[-2] > stack[-1]) label_12B0: // Incoming jump from 0x12AF, if not !(stack[-2] > stack[-1]) // Inputs[1] { @12B2 stack[-1] } 12B0 60 PUSH1 0x00 12B2 81 DUP2 12B3 81 DUP2 12B4 50 POP 12B5 60 PUSH1 0x00 12B7 90 SWAP1 12B8 55 SSTORE 12B9 50 POP 12BA 60 PUSH1 0x01 12BC 01 ADD 12BD 61 PUSH2 0x12a7 12C0 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @12B8 storage[stack[-1]] = 0x00 // @12BC stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x12a7 label_12C1: // Incoming jump from 0x12AF, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @12C3 stack[-2] // @12C3 stack[-3] // } 12C1 5B JUMPDEST 12C2 50 POP 12C3 90 SWAP1 12C4 56 *JUMP // Stack delta = -2 // Outputs[1] { @12C3 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_12C5: // Incoming return from call to 0x12A7 at 0x12A6 12C5 5B JUMPDEST // Stack delta = +0 // Block continues label_12C6: // Incoming jump from 0x1288 // Incoming jump from 0x12C5 // Inputs[1] { @12CC stack[-5] } 12C6 5B JUMPDEST 12C7 50 POP 12C8 50 POP 12C9 50 POP 12CA 60 PUSH1 0x01 12CC 91 SWAP2 12CD 50 POP 12CE 50 POP 12CF 61 PUSH2 0x12d6 12D2 56 *JUMP // Stack delta = -4 // Outputs[1] { @12CC stack[-5] = 0x01 } // Block ends with unconditional jump to 0x12d6 label_12D3: // Incoming jump from 0x0F7C, if !!(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00 + keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0x00) 12D3 5B JUMPDEST // Stack delta = +0 // Block continues label_12D4: // Incoming jump from 0x12D3 // Incoming jump from 0x0F1F, if !stack[-1] // Inputs[3] // { // @12D7 stack[-2] // @12D7 stack[-4] // @12D8 stack[-3] // } 12D4 5B JUMPDEST 12D5 50 POP 12D6 5B JUMPDEST 12D7 91 SWAP2 12D8 90 SWAP1 12D9 50 POP 12DA 56 *JUMP // Stack delta = -3 // Outputs[1] { @12D7 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_12DB: // Incoming call from 0x04FA, returns to 0x04FB // Incoming call from 0x0B0D, returns to 0x0B0E // Incoming call from 0x0B7A, returns to 0x0B7B // Incoming call from 0x0AC8, returns to 0x0AC9 // Incoming call from 0x069C, returns to 0x069D // Incoming call from 0x07F4, returns to 0x07F5 // Incoming call from 0x0F19, returns to 0x0F1A // Incoming call from 0x093D, returns to 0x093E // Inputs[3] // { // @12EC msg.sender // @1310 memory[0x00:0x40] // @1314 storage[keccak256(memory[0x00:0x40])] // } 12DB 5B JUMPDEST 12DC 60 PUSH1 0x00 12DE 60 PUSH1 0x00 12E0 60 PUSH1 0x00 12E2 60 PUSH1 0x00 12E4 61 PUSH2 0x0102 12E7 60 PUSH1 0x00 12E9 50 POP 12EA 60 PUSH1 0x00 12EC 33 CALLER 12ED 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1302 16 AND 1303 81 DUP2 1304 52 MSTORE 1305 60 PUSH1 0x20 1307 01 ADD 1308 90 SWAP1 1309 81 DUP2 130A 52 MSTORE 130B 60 PUSH1 0x20 130D 01 ADD 130E 60 PUSH1 0x00 1310 20 SHA3 1311 60 PUSH1 0x00 1313 50 POP 1314 54 SLOAD 1315 92 SWAP3 1316 50 POP 1317 60 PUSH1 0x00 1319 83 DUP4 131A 14 EQ 131B 15 ISZERO 131C 61 PUSH2 0x1324 131F 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @12DC stack[0] = 0x00 // @12E0 stack[2] = 0x00 // @12E2 stack[3] = 0x00 // @1304 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @130A memory[0x20:0x40] = 0x0102 // @1315 stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1324, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) label_1320: // Incoming jump from 0x131F, if not !(storage[keccak256(memory[0x00:0x40])] == 0x00) 1320 61 PUSH2 0x1535 1323 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1535 label_1324: // Incoming jump from 0x131F, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[4] // { // @132D stack[-5] // @133B memory[0x00:0x40] // @133F stack[-2] // @134A storage[0x00 + keccak256(memory[0x00:0x40])] // } 1324 5B JUMPDEST 1325 61 PUSH2 0x0103 1328 60 PUSH1 0x00 132A 50 POP 132B 60 PUSH1 0x00 132D 86 DUP7 132E 81 DUP2 132F 52 MSTORE 1330 60 PUSH1 0x20 1332 01 ADD 1333 90 SWAP1 1334 81 DUP2 1335 52 MSTORE 1336 60 PUSH1 0x20 1338 01 ADD 1339 60 PUSH1 0x00 133B 20 SHA3 133C 60 PUSH1 0x00 133E 50 POP 133F 91 SWAP2 1340 50 POP 1341 60 PUSH1 0x00 1343 82 DUP3 1344 60 PUSH1 0x00 1346 01 ADD 1347 60 PUSH1 0x00 1349 50 POP 134A 54 SLOAD 134B 14 EQ 134C 15 ISZERO 134D 61 PUSH2 0x13fd 1350 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @132F memory[0x00:0x20] = stack[-5] // @1335 memory[0x20:0x40] = 0x0103 // @133F stack[-2] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x13fd, if !(storage[0x00 + keccak256(memory[0x00:0x40])] == 0x00) label_1351: // Incoming jump from 0x1350, if not !(storage[0x00 + keccak256(memory[0x00:0x40])] == 0x00) // Inputs[4] // { // @1356 storage[0x00] // @1357 stack[-2] // @1376 storage[0x0104] // @1380 storage[0x0104] // } 1351 60 PUSH1 0x00 1353 60 PUSH1 0x00 1355 50 POP 1356 54 SLOAD 1357 82 DUP3 1358 60 PUSH1 0x00 135A 01 ADD 135B 60 PUSH1 0x00 135D 50 POP 135E 81 DUP2 135F 90 SWAP1 1360 55 SSTORE 1361 50 POP 1362 60 PUSH1 0x00 1364 82 DUP3 1365 60 PUSH1 0x01 1367 01 ADD 1368 60 PUSH1 0x00 136A 50 POP 136B 81 DUP2 136C 90 SWAP1 136D 55 SSTORE 136E 50 POP 136F 61 PUSH2 0x0104 1372 60 PUSH1 0x00 1374 50 POP 1375 80 DUP1 1376 54 SLOAD 1377 80 DUP1 1378 91 SWAP2 1379 90 SWAP1 137A 60 PUSH1 0x01 137C 01 ADD 137D 90 SWAP1 137E 90 SWAP1 137F 81 DUP2 1380 54 SLOAD 1381 81 DUP2 1382 83 DUP4 1383 55 SSTORE 1384 81 DUP2 1385 81 DUP2 1386 15 ISZERO 1387 11 GT 1388 61 PUSH2 0x13c3 138B 57 *JUMPI // Stack delta = +4 // Outputs[7] // { // @1360 storage[0x00 + stack[-2]] = storage[0x00] // @136D storage[0x01 + stack[-2]] = 0x00 // @1378 stack[0] = storage[0x0104] // @137E stack[2] = 0x01 + storage[0x0104] // @137E stack[1] = 0x0104 // @1380 stack[3] = storage[0x0104] // @1383 storage[0x0104] = 0x01 + storage[0x0104] // } // Block ends with conditional jump to 0x13c3, if !storage[0x0104] > 0x01 + storage[0x0104] label_138C: // Incoming jump from 0x138B, if not !storage[0x0104] > 0x01 + storage[0x0104] // Inputs[4] // { // @138C stack[-2] // @138D stack[-3] // @1395 memory[0x00:0x20] // @1396 stack[-1] // } 138C 81 DUP2 138D 83 DUP4 138E 60 PUSH1 0x00 1390 52 MSTORE 1391 60 PUSH1 0x20 1393 60 PUSH1 0x00 1395 20 SHA3 1396 91 SWAP2 1397 82 DUP3 1398 01 ADD 1399 91 SWAP2 139A 01 ADD 139B 61 PUSH2 0x13c2 139E 91 SWAP2 139F 90 SWAP1 13A0 61 PUSH2 0x13a4 13A3 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1390 memory[0x00:0x20] = stack[-3] // @139E stack[-1] = 0x13c2 // @139F stack[1] = keccak256(memory[0x00:0x20]) + stack[-2] // @139F stack[0] = keccak256(memory[0x00:0x20]) + stack[-1] // } // Block ends with call to 0x13a4, returns to 0x13C2 label_13A4: // Incoming call from 0x13A3, returns to 0x13C2 // Incoming jump from 0x13BD // Inputs[2] // { // @13A5 stack[-1] // @13A6 stack[-2] // } 13A4 5B JUMPDEST 13A5 80 DUP1 13A6 82 DUP3 13A7 11 GT 13A8 15 ISZERO 13A9 61 PUSH2 0x13be 13AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13be, if !(stack[-2] > stack[-1]) label_13AD: // Incoming jump from 0x13AC, if not !(stack[-2] > stack[-1]) // Inputs[1] { @13AF stack[-1] } 13AD 60 PUSH1 0x00 13AF 81 DUP2 13B0 81 DUP2 13B1 50 POP 13B2 60 PUSH1 0x00 13B4 90 SWAP1 13B5 55 SSTORE 13B6 50 POP 13B7 60 PUSH1 0x01 13B9 01 ADD 13BA 61 PUSH2 0x13a4 13BD 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @13B5 storage[stack[-1]] = 0x00 // @13B9 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x13a4 label_13BE: // Incoming jump from 0x13AC, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @13C0 stack[-3] // @13C0 stack[-2] // } 13BE 5B JUMPDEST 13BF 50 POP 13C0 90 SWAP1 13C1 56 *JUMP // Stack delta = -2 // Outputs[1] { @13C0 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_13C2: // Incoming return from call to 0x13A4 at 0x13A3 13C2 5B JUMPDEST // Stack delta = +0 // Block continues label_13C3: // Incoming jump from 0x13C2 // Incoming jump from 0x138B, if !storage[0x0104] > 0x01 + storage[0x0104] // Inputs[5] // { // @13C7 stack[-6] // @13CE stack[-4] // @13D2 stack[-9] // @13E0 storage[0x02 + stack[-6]] // @13E2 storage[0x0104] // } 13C3 5B JUMPDEST 13C4 50 POP 13C5 50 POP 13C6 50 POP 13C7 82 DUP3 13C8 60 PUSH1 0x02 13CA 01 ADD 13CB 60 PUSH1 0x00 13CD 50 POP 13CE 81 DUP2 13CF 90 SWAP1 13D0 55 SSTORE 13D1 50 POP 13D2 84 DUP5 13D3 61 PUSH2 0x0104 13D6 60 PUSH1 0x00 13D8 50 POP 13D9 83 DUP4 13DA 60 PUSH1 0x02 13DC 01 ADD 13DD 60 PUSH1 0x00 13DF 50 POP 13E0 54 SLOAD 13E1 81 DUP2 13E2 54 SLOAD 13E3 81 DUP2 13E4 10 LT 13E5 15 ISZERO 13E6 61 PUSH2 0x0002 13E9 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @13D0 storage[0x02 + stack[-6]] = stack[-4] // @13D2 stack[-4] = stack[-9] // @13D3 stack[-3] = 0x0104 // @13E0 stack[-2] = storage[0x02 + stack[-6]] // } // Block ends with conditional jump to 0x0002, if !(storage[0x02 + stack[-6]] < storage[0x0104]) label_13EA: // Incoming jump from 0x13E9, if not !(storage[0x02 + stack[-6]] < storage[0x0104]) // Inputs[4] // { // @13EA stack[-1] // @13EA stack[-2] // @13F2 memory[0x00:0x20] // @13F9 stack[-3] // } 13EA 90 SWAP1 13EB 60 PUSH1 0x00 13ED 52 MSTORE 13EE 60 PUSH1 0x20 13F0 60 PUSH1 0x00 13F2 20 SHA3 13F3 90 SWAP1 13F4 01 ADD 13F5 60 PUSH1 0x00 13F7 5B JUMPDEST 13F8 50 POP 13F9 81 DUP2 13FA 90 SWAP1 13FB 55 SSTORE 13FC 50 POP // Stack delta = -3 // Outputs[2] // { // @13ED memory[0x00:0x20] = stack[-2] // @13FB storage[stack[-1] + keccak256(memory[0x00:0x20])] = stack[-3] // } // Block continues label_13FD: // Incoming jump from 0x13FC // Incoming jump from 0x1350, if !(storage[0x00 + keccak256(memory[0x00:0x40])] == 0x00) // Inputs[4] // { // @13FE stack[-3] // @1402 stack[-1] // @1407 stack[-2] // @140E storage[0x01 + stack[-2]] // } 13FD 5B JUMPDEST 13FE 82 DUP3 13FF 60 PUSH1 0x02 1401 0A EXP 1402 90 SWAP1 1403 50 POP 1404 60 PUSH1 0x00 1406 81 DUP2 1407 83 DUP4 1408 60 PUSH1 0x01 140A 01 ADD 140B 60 PUSH1 0x00 140D 50 POP 140E 54 SLOAD 140F 16 AND 1410 14 EQ 1411 15 ISZERO 1412 61 PUSH2 0x1534 1415 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1402 stack[-1] = 0x02 ** stack[-3] } // Block ends with conditional jump to 0x1534, if !(storage[0x01 + stack[-2]] & 0x02 ** stack[-3] == 0x00) label_1416: // Incoming jump from 0x1415, if not !(storage[0x01 + stack[-2]] & 0x02 ** stack[-3] == 0x00) // Inputs[7] // { // @1437 msg.sender // @1438 stack[-5] // @143B memory[0x40:0x60] // @1465 memory[0x40:0x60] // @146A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @146D stack[-2] // @1474 storage[0x00 + stack[-2]] // } 1416 7F PUSH32 0xe1c52dc63b719ade82e8bea94cc41a0d5d28e4aaf536adb5e9cccc9ff8c1aeda 1437 33 CALLER 1438 86 DUP7 1439 60 PUSH1 0x40 143B 51 MLOAD 143C 80 DUP1 143D 83 DUP4 143E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1453 16 AND 1454 81 DUP2 1455 52 MSTORE 1456 60 PUSH1 0x20 1458 01 ADD 1459 82 DUP3 145A 81 DUP2 145B 52 MSTORE 145C 60 PUSH1 0x20 145E 01 ADD 145F 92 SWAP3 1460 50 POP 1461 50 POP 1462 50 POP 1463 60 PUSH1 0x40 1465 51 MLOAD 1466 80 DUP1 1467 91 SWAP2 1468 03 SUB 1469 90 SWAP1 146A A1 LOG1 146B 60 PUSH1 0x01 146D 82 DUP3 146E 60 PUSH1 0x00 1470 01 ADD 1471 60 PUSH1 0x00 1473 50 POP 1474 54 SLOAD 1475 11 GT 1476 15 ISZERO 1477 15 ISZERO 1478 61 PUSH2 0x1507 147B 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1455 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @145B memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-5] // @146A log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xe1c52dc63b719ade82e8bea94cc41a0d5d28e4aaf536adb5e9cccc9ff8c1aeda]); // } // Block ends with conditional jump to 0x1507, if !!(storage[0x00 + stack[-2]] > 0x01) label_147C: // Incoming jump from 0x147B, if not !!(storage[0x00 + stack[-2]] > 0x01) // Inputs[4] // { // @148A stack[-5] // @1498 memory[0x00:0x40] // @14A2 storage[0x02 + keccak256(memory[0x00:0x40])] // @14A4 storage[0x0104] // } 147C 61 PUSH2 0x0104 147F 60 PUSH1 0x00 1481 50 POP 1482 61 PUSH2 0x0103 1485 60 PUSH1 0x00 1487 50 POP 1488 60 PUSH1 0x00 148A 87 DUP8 148B 81 DUP2 148C 52 MSTORE 148D 60 PUSH1 0x20 148F 01 ADD 1490 90 SWAP1 1491 81 DUP2 1492 52 MSTORE 1493 60 PUSH1 0x20 1495 01 ADD 1496 60 PUSH1 0x00 1498 20 SHA3 1499 60 PUSH1 0x00 149B 50 POP 149C 60 PUSH1 0x02 149E 01 ADD 149F 60 PUSH1 0x00 14A1 50 POP 14A2 54 SLOAD 14A3 81 DUP2 14A4 54 SLOAD 14A5 81 DUP2 14A6 10 LT 14A7 15 ISZERO 14A8 61 PUSH2 0x0002 14AB 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @147C stack[0] = 0x0104 // @148C memory[0x00:0x20] = stack[-5] // @1492 memory[0x20:0x40] = 0x0103 // @14A2 stack[1] = storage[0x02 + keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0002, if !(storage[0x02 + keccak256(memory[0x00:0x40])] < storage[0x0104]) label_14AC: // Incoming jump from 0x14AB, if not !(storage[0x02 + keccak256(memory[0x00:0x40])] < storage[0x0104]) // Inputs[6] // { // @14AC stack[-2] // @14AC stack[-1] // @14B4 memory[0x00:0x20] // @14C7 stack[-7] // @14D5 memory[0x00:0x40] // @14FD stack[-6] // } 14AC 90 SWAP1 14AD 60 PUSH1 0x00 14AF 52 MSTORE 14B0 60 PUSH1 0x20 14B2 60 PUSH1 0x00 14B4 20 SHA3 14B5 90 SWAP1 14B6 01 ADD 14B7 60 PUSH1 0x00 14B9 5B JUMPDEST 14BA 50 POP 14BB 60 PUSH1 0x00 14BD 90 SWAP1 14BE 55 SSTORE 14BF 61 PUSH2 0x0103 14C2 60 PUSH1 0x00 14C4 50 POP 14C5 60 PUSH1 0x00 14C7 86 DUP7 14C8 81 DUP2 14C9 52 MSTORE 14CA 60 PUSH1 0x20 14CC 01 ADD 14CD 90 SWAP1 14CE 81 DUP2 14CF 52 MSTORE 14D0 60 PUSH1 0x20 14D2 01 ADD 14D3 60 PUSH1 0x00 14D5 20 SHA3 14D6 60 PUSH1 0x00 14D8 60 PUSH1 0x00 14DA 82 DUP3 14DB 01 ADD 14DC 60 PUSH1 0x00 14DE 50 POP 14DF 60 PUSH1 0x00 14E1 90 SWAP1 14E2 55 SSTORE 14E3 60 PUSH1 0x01 14E5 82 DUP3 14E6 01 ADD 14E7 60 PUSH1 0x00 14E9 50 POP 14EA 60 PUSH1 0x00 14EC 90 SWAP1 14ED 55 SSTORE 14EE 60 PUSH1 0x02 14F0 82 DUP3 14F1 01 ADD 14F2 60 PUSH1 0x00 14F4 50 POP 14F5 60 PUSH1 0x00 14F7 90 SWAP1 14F8 55 SSTORE 14F9 50 POP 14FA 50 POP 14FB 60 PUSH1 0x01 14FD 93 SWAP4 14FE 50 POP 14FF 61 PUSH2 0x1535 1502 56 *JUMP // Stack delta = -2 // Outputs[8] // { // @14AF memory[0x00:0x20] = stack[-2] // @14BE storage[stack[-1] + keccak256(memory[0x00:0x20])] = 0x00 // @14C9 memory[0x00:0x20] = stack[-7] // @14CF memory[0x20:0x40] = 0x0103 // @14E2 storage[keccak256(memory[0x00:0x40]) + 0x00] = 0x00 // @14ED storage[keccak256(memory[0x00:0x40]) + 0x01] = 0x00 // @14F8 storage[keccak256(memory[0x00:0x40]) + 0x02] = 0x00 // @14FD stack[-6] = 0x01 // } // Block ends with unconditional jump to 0x1535 1503 61 PUSH2 0x1533 1506 56 *JUMP label_1507: // Incoming jump from 0x147B, if !!(storage[0x00 + stack[-2]] > 0x01) // Inputs[4] // { // @1508 stack[-2] // @1511 storage[0x00 + stack[-2]] // @151F stack[-1] // @152A storage[0x01 + stack[-2]] // } 1507 5B JUMPDEST 1508 81 DUP2 1509 60 PUSH1 0x00 150B 01 ADD 150C 60 PUSH1 0x00 150E 81 DUP2 150F 81 DUP2 1510 50 POP 1511 54 SLOAD 1512 80 DUP1 1513 92 SWAP3 1514 91 SWAP2 1515 90 SWAP1 1516 60 PUSH1 0x01 1518 90 SWAP1 1519 03 SUB 151A 91 SWAP2 151B 90 SWAP1 151C 50 POP 151D 55 SSTORE 151E 50 POP 151F 80 DUP1 1520 82 DUP3 1521 60 PUSH1 0x01 1523 01 ADD 1524 60 PUSH1 0x00 1526 82 DUP3 1527 82 DUP3 1528 82 DUP3 1529 50 POP 152A 54 SLOAD 152B 17 OR 152C 92 SWAP3 152D 50 POP 152E 50 POP 152F 81 DUP2 1530 90 SWAP1 1531 55 SSTORE 1532 50 POP 1533 5B JUMPDEST // Stack delta = +0 // Outputs[2] // { // @151D storage[0x00 + stack[-2]] = storage[0x00 + stack[-2]] - 0x01 // @1531 storage[0x01 + stack[-2]] = storage[0x01 + stack[-2]] | stack[-1] // } // Block continues label_1534: // Incoming jump from 0x1415, if !(storage[0x01 + stack[-2]] & 0x02 ** stack[-3] == 0x00) // Incoming jump from 0x1533 1534 5B JUMPDEST // Stack delta = +0 // Block continues label_1535: // Incoming jump from 0x1323 // Incoming jump from 0x1502 // Incoming jump from 0x1534 // Inputs[3] // { // @1539 stack[-4] // @1539 stack[-6] // @153A stack[-5] // } 1535 5B JUMPDEST 1536 50 POP 1537 50 POP 1538 50 POP 1539 91 SWAP2 153A 90 SWAP1 153B 50 POP 153C 56 *JUMP // Stack delta = -5 // Outputs[1] { @1539 stack[-6] = stack[-4] } // Block ends with unconditional jump to stack[-6] label_153D: // Incoming call from 0x08B9, returns to 0x08BA // Incoming call from 0x06D4, returns to 0x06D5 // Inputs[1] { @154C storage[0x01] } 153D 5B JUMPDEST 153E 60 PUSH1 0x00 1540 60 PUSH1 0x00 1542 60 PUSH1 0x01 1544 90 SWAP1 1545 50 POP 1546 5B JUMPDEST 1547 60 PUSH1 0x01 1549 60 PUSH1 0x00 154B 50 POP 154C 54 SLOAD 154D 81 DUP2 154E 10 LT 154F 15 ISZERO 1550 61 PUSH2 0x16d2 1553 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @153E stack[0] = 0x00 // @1544 stack[1] = 0x01 // } // Block ends with conditional jump to 0x16d2, if !(0x01 < storage[0x01]) label_1554: // Incoming jump from 0x1591 // Incoming jump from 0x1553, if not !(0x01 < storage[0x01]) // Incoming jump from 0x1553, if not !(stack[-1] < storage[0x01]) // Inputs[2] // { // @155A storage[0x01] // @155B stack[-1] // } 1554 5B JUMPDEST 1555 60 PUSH1 0x01 1557 60 PUSH1 0x00 1559 50 POP 155A 54 SLOAD 155B 81 DUP2 155C 10 LT 155D 80 DUP1 155E 15 ISZERO 155F 61 PUSH2 0x1580 1562 57 *JUMPI // Stack delta = +1 // Outputs[1] { @155C stack[0] = stack[-1] < storage[0x01] } // Block ends with conditional jump to 0x1580, if !(stack[-1] < storage[0x01]) label_1563: // Incoming jump from 0x1562, if not !(stack[-1] < storage[0x01]) // Inputs[1] { @156B stack[-2] } 1563 50 POP 1564 60 PUSH1 0x00 1566 60 PUSH1 0x02 1568 60 PUSH1 0x00 156A 50 POP 156B 82 DUP3 156C 61 PUSH2 0x0100 156F 81 DUP2 1570 10 LT 1571 15 ISZERO 1572 61 PUSH2 0x0002 1575 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @1564 stack[-1] = 0x00 // @1566 stack[0] = 0x02 // @156B stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0002, if !(stack[-2] < 0x0100) label_1576: // Incoming jump from 0x1575, if not !(stack[-2] < 0x0100) // Inputs[4] // { // @1576 stack[-1] // @1576 stack[-2] // @157D storage[stack[-1] + stack[-2]] // @157E stack[-3] // } 1576 90 SWAP1 1577 90 SWAP1 1578 01 ADD 1579 60 PUSH1 0x00 157B 5B JUMPDEST 157C 50 POP 157D 54 SLOAD 157E 14 EQ 157F 15 ISZERO // Stack delta = -2 // Outputs[1] { @157F stack[-3] = !(storage[stack[-1] + stack[-2]] == stack[-3]) } // Block continues label_1580: // Incoming jump from 0x1562, if !(stack[-1] < storage[0x01]) // Incoming jump from 0x157F // Inputs[1] { @1581 stack[-1] } 1580 5B JUMPDEST 1581 15 ISZERO 1582 61 PUSH2 0x1592 1585 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1592, if !stack[-1] label_1586: // Incoming jump from 0x1585, if not !stack[-1] // Inputs[1] { @1586 stack[-1] } 1586 80 DUP1 1587 80 DUP1 1588 60 PUSH1 0x01 158A 01 ADD 158B 91 SWAP2 158C 50 POP 158D 50 POP 158E 61 PUSH2 0x1554 1591 56 *JUMP // Stack delta = +0 // Outputs[1] { @158B stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x1554 label_1592: // Incoming jump from 0x1585, if !stack[-1] // Inputs[1] { @159B storage[0x01] } 1592 5B JUMPDEST 1593 5B JUMPDEST 1594 60 PUSH1 0x01 1596 60 PUSH1 0x01 1598 60 PUSH1 0x00 159A 50 POP 159B 54 SLOAD 159C 11 GT 159D 80 DUP1 159E 15 ISZERO 159F 61 PUSH2 0x15c4 15A2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @159C stack[0] = storage[0x01] > 0x01 } // Block ends with conditional jump to 0x15c4, if !(storage[0x01] > 0x01) label_15A3: // Incoming jump from 0x15A2, if not !(storage[0x01] > 0x01) // Incoming jump from 0x15A2, if not !(storage[0x01] > 0x01) // Inputs[1] { @15B0 storage[0x01] } 15A3 50 POP 15A4 60 PUSH1 0x00 15A6 60 PUSH1 0x02 15A8 60 PUSH1 0x00 15AA 50 POP 15AB 60 PUSH1 0x01 15AD 60 PUSH1 0x00 15AF 50 POP 15B0 54 SLOAD 15B1 61 PUSH2 0x0100 15B4 81 DUP2 15B5 10 LT 15B6 15 ISZERO 15B7 61 PUSH2 0x0002 15BA 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @15A4 stack[-1] = 0x00 // @15A6 stack[0] = 0x02 // @15B0 stack[1] = storage[0x01] // } // Block ends with conditional jump to 0x0002, if !(storage[0x01] < 0x0100) label_15BB: // Incoming jump from 0x15BA, if not !(storage[0x01] < 0x0100) // Inputs[4] // { // @15BB stack[-1] // @15BB stack[-2] // @15C2 storage[stack[-1] + stack[-2]] // @15C3 stack[-3] // } 15BB 90 SWAP1 15BC 90 SWAP1 15BD 01 ADD 15BE 60 PUSH1 0x00 15C0 5B JUMPDEST 15C1 50 POP 15C2 54 SLOAD 15C3 14 EQ // Stack delta = -2 // Outputs[1] { @15C3 stack[-3] = storage[stack[-1] + stack[-2]] == stack[-3] } // Block continues label_15C4: // Incoming jump from 0x15C3 // Incoming jump from 0x15A2, if !(storage[0x01] > 0x01) // Incoming jump from 0x15A2, if !(storage[0x01] > 0x01) // Inputs[1] { @15C5 stack[-1] } 15C4 5B JUMPDEST 15C5 15 ISZERO 15C6 61 PUSH2 0x15e3 15C9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x15e3, if !stack[-1] label_15CA: // Incoming jump from 0x15C9, if not !stack[-1] // Inputs[1] { @15D1 storage[0x01] } 15CA 60 PUSH1 0x01 15CC 60 PUSH1 0x00 15CE 81 DUP2 15CF 81 DUP2 15D0 50 POP 15D1 54 SLOAD 15D2 80 DUP1 15D3 92 SWAP3 15D4 91 SWAP2 15D5 90 SWAP1 15D6 60 PUSH1 0x01 15D8 90 SWAP1 15D9 03 SUB 15DA 91 SWAP2 15DB 90 SWAP1 15DC 50 POP 15DD 55 SSTORE 15DE 50 POP 15DF 61 PUSH2 0x1593 15E2 56 *JUMP // Stack delta = +0 // Outputs[1] { @15DD storage[0x01] = storage[0x01] - 0x01 } // Block ends with unconditional jump to 0x1593 label_15E3: // Incoming jump from 0x15C9, if !stack[-1] // Inputs[2] // { // @15E9 storage[0x01] // @15EA stack[-1] // } 15E3 5B JUMPDEST 15E4 60 PUSH1 0x01 15E6 60 PUSH1 0x00 15E8 50 POP 15E9 54 SLOAD 15EA 81 DUP2 15EB 10 LT 15EC 80 DUP1 15ED 15 ISZERO 15EE 61 PUSH2 0x1614 15F1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @15EB stack[0] = stack[-1] < storage[0x01] } // Block ends with conditional jump to 0x1614, if !(stack[-1] < storage[0x01]) label_15F2: // Incoming jump from 0x15F1, if not !(stack[-1] < storage[0x01]) // Inputs[1] { @15FF storage[0x01] } 15F2 50 POP 15F3 60 PUSH1 0x00 15F5 60 PUSH1 0x02 15F7 60 PUSH1 0x00 15F9 50 POP 15FA 60 PUSH1 0x01 15FC 60 PUSH1 0x00 15FE 50 POP 15FF 54 SLOAD 1600 61 PUSH2 0x0100 1603 81 DUP2 1604 10 LT 1605 15 ISZERO 1606 61 PUSH2 0x0002 1609 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @15F3 stack[-1] = 0x00 // @15F5 stack[0] = 0x02 // @15FF stack[1] = storage[0x01] // } // Block ends with conditional jump to 0x0002, if !(storage[0x01] < 0x0100) label_160A: // Incoming jump from 0x1609, if not !(storage[0x01] < 0x0100) // Inputs[4] // { // @160A stack[-2] // @160A stack[-1] // @1611 storage[stack[-1] + stack[-2]] // @1612 stack[-3] // } 160A 90 SWAP1 160B 90 SWAP1 160C 01 ADD 160D 60 PUSH1 0x00 160F 5B JUMPDEST 1610 50 POP 1611 54 SLOAD 1612 14 EQ 1613 15 ISZERO // Stack delta = -2 // Outputs[1] { @1613 stack[-3] = !(storage[stack[-1] + stack[-2]] == stack[-3]) } // Block continues label_1614: // Incoming jump from 0x15F1, if !(stack[-1] < storage[0x01]) // Incoming jump from 0x1613 // Inputs[1] { @1615 stack[-1] } 1614 5B JUMPDEST 1615 80 DUP1 1616 15 ISZERO 1617 61 PUSH2 0x1637 161A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1637, if !stack[-1] label_161B: // Incoming jump from 0x161A, if not !stack[-1] // Inputs[1] { @1623 stack[-2] } 161B 50 POP 161C 60 PUSH1 0x00 161E 60 PUSH1 0x02 1620 60 PUSH1 0x00 1622 50 POP 1623 82 DUP3 1624 61 PUSH2 0x0100 1627 81 DUP2 1628 10 LT 1629 15 ISZERO 162A 61 PUSH2 0x0002 162D 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @161C stack[-1] = 0x00 // @161E stack[0] = 0x02 // @1623 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0002, if !(stack[-2] < 0x0100) label_162E: // Incoming jump from 0x162D, if not !(stack[-2] < 0x0100) // Inputs[4] // { // @162E stack[-1] // @162E stack[-2] // @1635 storage[stack[-1] + stack[-2]] // @1636 stack[-3] // } 162E 90 SWAP1 162F 90 SWAP1 1630 01 ADD 1631 60 PUSH1 0x00 1633 5B JUMPDEST 1634 50 POP 1635 54 SLOAD 1636 14 EQ // Stack delta = -2 // Outputs[1] { @1636 stack[-3] = storage[stack[-1] + stack[-2]] == stack[-3] } // Block continues label_1637: // Incoming jump from 0x161A, if !stack[-1] // Incoming jump from 0x1636 // Inputs[1] { @1638 stack[-1] } 1637 5B JUMPDEST 1638 15 ISZERO 1639 61 PUSH2 0x16cd 163C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x16cd, if !stack[-1] label_163D: // Incoming jump from 0x163C, if not !stack[-1] // Inputs[1] { @1647 storage[0x01] } 163D 60 PUSH1 0x02 163F 60 PUSH1 0x00 1641 50 POP 1642 60 PUSH1 0x01 1644 60 PUSH1 0x00 1646 50 POP 1647 54 SLOAD 1648 61 PUSH2 0x0100 164B 81 DUP2 164C 10 LT 164D 15 ISZERO 164E 61 PUSH2 0x0002 1651 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @163D stack[0] = 0x02 // @1647 stack[1] = storage[0x01] // } // Block ends with conditional jump to 0x0002, if !(storage[0x01] < 0x0100) label_1652: // Incoming jump from 0x1651, if not !(storage[0x01] < 0x0100) // Inputs[4] // { // @1652 stack[-1] // @1652 stack[-2] // @1659 storage[stack[-1] + stack[-2]] // @165F stack[-3] // } 1652 90 SWAP1 1653 90 SWAP1 1654 01 ADD 1655 60 PUSH1 0x00 1657 5B JUMPDEST 1658 50 POP 1659 54 SLOAD 165A 60 PUSH1 0x02 165C 60 PUSH1 0x00 165E 50 POP 165F 82 DUP3 1660 61 PUSH2 0x0100 1663 81 DUP2 1664 10 LT 1665 15 ISZERO 1666 61 PUSH2 0x0002 1669 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1659 stack[-2] = storage[stack[-1] + stack[-2]] // @165A stack[-1] = 0x02 // @165F stack[0] = stack[-3] // } // Block ends with conditional jump to 0x0002, if !(stack[-3] < 0x0100) label_166A: // Incoming jump from 0x1669, if not !(stack[-3] < 0x0100) // Inputs[4] // { // @166A stack[-1] // @166A stack[-2] // @1671 stack[-3] // @1675 stack[-4] // } 166A 90 SWAP1 166B 90 SWAP1 166C 01 ADD 166D 60 PUSH1 0x00 166F 5B JUMPDEST 1670 50 POP 1671 81 DUP2 1672 90 SWAP1 1673 55 SSTORE 1674 50 POP 1675 80 DUP1 1676 61 PUSH2 0x0102 1679 60 PUSH1 0x00 167B 50 POP 167C 60 PUSH1 0x00 167E 60 PUSH1 0x02 1680 60 PUSH1 0x00 1682 50 POP 1683 84 DUP5 1684 61 PUSH2 0x0100 1687 81 DUP2 1688 10 LT 1689 15 ISZERO 168A 61 PUSH2 0x0002 168D 57 *JUMPI // Stack delta = +2 // Outputs[6] // { // @1673 storage[stack[-1] + stack[-2]] = stack[-3] // @1675 stack[-3] = stack[-4] // @1676 stack[-2] = 0x0102 // @167C stack[-1] = 0x00 // @167E stack[0] = 0x02 // @1683 stack[1] = stack[-4] // } // Block ends with conditional jump to 0x0002, if !(stack[-4] < 0x0100) label_168E: // Incoming jump from 0x168D, if not !(stack[-4] < 0x0100) // Inputs[8] // { // @168E stack[-2] // @168E stack[-1] // @1695 storage[stack[-1] + stack[-2]] // @1696 stack[-3] // @169B stack[-4] // @16A3 memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @16A7 stack[-5] // @16B7 storage[0x01] // } 168E 90 SWAP1 168F 90 SWAP1 1690 01 ADD 1691 60 PUSH1 0x00 1693 5B JUMPDEST 1694 50 POP 1695 54 SLOAD 1696 81 DUP2 1697 52 MSTORE 1698 60 PUSH1 0x20 169A 01 ADD 169B 90 SWAP1 169C 81 DUP2 169D 52 MSTORE 169E 60 PUSH1 0x20 16A0 01 ADD 16A1 60 PUSH1 0x00 16A3 20 SHA3 16A4 60 PUSH1 0x00 16A6 50 POP 16A7 81 DUP2 16A8 90 SWAP1 16A9 55 SSTORE 16AA 50 POP 16AB 60 PUSH1 0x00 16AD 60 PUSH1 0x02 16AF 60 PUSH1 0x00 16B1 50 POP 16B2 60 PUSH1 0x01 16B4 60 PUSH1 0x00 16B6 50 POP 16B7 54 SLOAD 16B8 61 PUSH2 0x0100 16BB 81 DUP2 16BC 10 LT 16BD 15 ISZERO 16BE 61 PUSH2 0x0002 16C1 57 *JUMPI // Stack delta = -2 // Outputs[6] // { // @1697 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-1] + stack[-2]] // @169D memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @16A9 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] = stack[-5] // @16AB stack[-5] = 0x00 // @16AD stack[-4] = 0x02 // @16B7 stack[-3] = storage[0x01] // } // Block ends with conditional jump to 0x0002, if !(storage[0x01] < 0x0100) label_16C2: // Incoming jump from 0x16C1, if not !(storage[0x01] < 0x0100) // Inputs[3] // { // @16C2 stack[-1] // @16C2 stack[-2] // @16C9 stack[-3] // } 16C2 90 SWAP1 16C3 90 SWAP1 16C4 01 ADD 16C5 60 PUSH1 0x00 16C7 5B JUMPDEST 16C8 50 POP 16C9 81 DUP2 16CA 90 SWAP1 16CB 55 SSTORE 16CC 50 POP // Stack delta = -3 // Outputs[1] { @16CB storage[stack[-1] + stack[-2]] = stack[-3] } // Block continues label_16CD: // Incoming jump from 0x16CC // Incoming jump from 0x163C, if !stack[-1] 16CD 5B JUMPDEST 16CE 61 PUSH2 0x1546 16D1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1546 label_16D2: // Incoming jump from 0x1553, if !(0x01 < storage[0x01]) // Incoming jump from 0x1553, if !(stack[-1] < storage[0x01]) // Inputs[2] // { // @16D5 stack[-2] // @16D5 stack[-3] // } 16D2 5B JUMPDEST 16D3 5B JUMPDEST 16D4 50 POP 16D5 90 SWAP1 16D6 56 *JUMP // Stack delta = -2 // Outputs[1] { @16D5 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_16D7: // Incoming call from 0x0BB6, returns to 0x0BB7 // Inputs[1] { @16DD msg.sender } 16D7 5B JUMPDEST 16D8 60 PUSH1 0x00 16DA 61 PUSH2 0x16e2 16DD 33 CALLER 16DE 61 PUSH2 0x09a5 16E1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @16D8 stack[0] = 0x00 // @16DA stack[1] = 0x16e2 // @16DD stack[2] = msg.sender // } // Block ends with call to 0x09a5, returns to 0x16E2 label_16E2: // Incoming return from call to 0x09A5 at 0x16E1 // Inputs[1] { @16E3 stack[-1] } 16E2 5B JUMPDEST 16E3 15 ISZERO 16E4 61 PUSH2 0x1771 16E7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1771, if !stack[-1] label_16E8: // Incoming jump from 0x16E7, if not !stack[-1] // Inputs[1] { @16EE storage[0x0107] } 16E8 61 PUSH2 0x0107 16EB 60 PUSH1 0x00 16ED 50 POP 16EE 54 SLOAD 16EF 61 PUSH2 0x16f6 16F2 61 PUSH2 0x1980 16F5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @16EE stack[0] = storage[0x0107] // @16EF stack[1] = 0x16f6 // } // Block ends with call to 0x1980, returns to 0x16F6 label_16F6: // Incoming return from call to 0x1980 at 0x16F5 // Inputs[2] // { // @16F7 stack[-2] // @16F7 stack[-1] // } 16F6 5B JUMPDEST 16F7 11 GT 16F8 15 ISZERO 16F9 61 PUSH2 0x171b 16FC 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x171b, if !(stack[-1] > stack[-2]) label_16FD: // Incoming jump from 0x16FC, if not !(stack[-1] > stack[-2]) 16FD 60 PUSH1 0x00 16FF 61 PUSH2 0x0106 1702 60 PUSH1 0x00 1704 50 POP 1705 81 DUP2 1706 90 SWAP1 1707 55 SSTORE 1708 50 POP 1709 61 PUSH2 0x1710 170C 61 PUSH2 0x1980 170F 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1707 storage[0x0106] = 0x00 // @1709 stack[0] = 0x1710 // } // Block ends with call to 0x1980, returns to 0x1710 label_1710: // Incoming return from call to 0x1980 at 0x170F // Inputs[1] { @1717 stack[-1] } 1710 5B JUMPDEST 1711 61 PUSH2 0x0107 1714 60 PUSH1 0x00 1716 50 POP 1717 81 DUP2 1718 90 SWAP1 1719 55 SSTORE 171A 50 POP // Stack delta = -1 // Outputs[1] { @1719 storage[0x0107] = stack[-1] } // Block continues label_171B: // Incoming jump from 0x171A // Incoming jump from 0x16FC, if !(stack[-1] > stack[-2]) // Inputs[3] // { // @1722 storage[0x0106] // @1723 stack[-2] // @172A storage[0x0106] // } 171B 5B JUMPDEST 171C 61 PUSH2 0x0106 171F 60 PUSH1 0x00 1721 50 POP 1722 54 SLOAD 1723 82 DUP3 1724 61 PUSH2 0x0106 1727 60 PUSH1 0x00 1729 50 POP 172A 54 SLOAD 172B 01 ADD 172C 10 LT 172D 15 ISZERO 172E 80 DUP1 172F 15 ISZERO 1730 61 PUSH2 0x1747 1733 57 *JUMPI // Stack delta = +1 // Outputs[1] { @172D stack[0] = !(storage[0x0106] + stack[-2] < storage[0x0106]) } // Block ends with conditional jump to 0x1747, if !!(storage[0x0106] + stack[-2] < storage[0x0106]) label_1734: // Incoming jump from 0x1733, if not !!(storage[0x0106] + stack[-2] < storage[0x0106]) // Inputs[3] // { // @173B storage[0x0105] // @173C stack[-3] // @1743 storage[0x0106] // } 1734 50 POP 1735 61 PUSH2 0x0105 1738 60 PUSH1 0x00 173A 50 POP 173B 54 SLOAD 173C 82 DUP3 173D 61 PUSH2 0x0106 1740 60 PUSH1 0x00 1742 50 POP 1743 54 SLOAD 1744 01 ADD 1745 11 GT 1746 15 ISZERO 1747 5B JUMPDEST 1748 15 ISZERO 1749 61 PUSH2 0x1768 174C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1768, if !!(storage[0x0106] + stack[-3] > storage[0x0105]) label_174D: // Incoming jump from 0x174C, if not !!(storage[0x0106] + stack[-3] > storage[0x0105]) // Incoming jump from 0x174C, if not !stack[-1] // Inputs[3] // { // @174D stack[-2] // @1757 storage[0x0106] // @1762 stack[-1] // } 174D 81 DUP2 174E 61 PUSH2 0x0106 1751 60 PUSH1 0x00 1753 82 DUP3 1754 82 DUP3 1755 82 DUP3 1756 50 POP 1757 54 SLOAD 1758 01 ADD 1759 92 SWAP3 175A 50 POP 175B 50 POP 175C 81 DUP2 175D 90 SWAP1 175E 55 SSTORE 175F 50 POP 1760 60 PUSH1 0x01 1762 90 SWAP1 1763 50 POP 1764 61 PUSH2 0x1772 1767 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @175E storage[0x0106] = storage[0x0106] + stack[-2] // @1762 stack[-1] = 0x01 // } // Block ends with unconditional jump to 0x1772 label_1768: // Incoming jump from 0x174C, if !!(storage[0x0106] + stack[-3] > storage[0x0105]) // Incoming jump from 0x174C, if !stack[-1] // Inputs[1] { @176B stack[-1] } 1768 5B JUMPDEST 1769 60 PUSH1 0x00 176B 90 SWAP1 176C 50 POP 176D 61 PUSH2 0x1772 1770 56 *JUMP // Stack delta = +0 // Outputs[1] { @176B stack[-1] = 0x00 } // Block ends with unconditional jump to 0x1772 label_1771: // Incoming jump from 0x16E7, if !stack[-1] // Inputs[3] // { // @1773 stack[-1] // @1773 stack[-3] // @1774 stack[-2] // } 1771 5B JUMPDEST 1772 5B JUMPDEST 1773 91 SWAP2 1774 90 SWAP1 1775 50 POP 1776 56 *JUMP // Stack delta = -2 // Outputs[1] { @1773 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1777: // Incoming call from 0x06BD, returns to 0x06BE // Incoming call from 0x0967, returns to 0x0968 // Incoming call from 0x08B1, returns to 0x08B2 // Incoming call from 0x055D, returns to 0x055E // Inputs[1] { @1783 storage[0x0104] } 1777 5B JUMPDEST 1778 60 PUSH1 0x00 177A 60 PUSH1 0x00 177C 61 PUSH2 0x0104 177F 60 PUSH1 0x00 1781 50 POP 1782 80 DUP1 1783 54 SLOAD 1784 90 SWAP1 1785 50 POP 1786 91 SWAP2 1787 50 POP 1788 60 PUSH1 0x00 178A 90 SWAP1 178B 50 POP 178C 5B JUMPDEST 178D 81 DUP2 178E 81 DUP2 178F 10 LT 1790 15 ISZERO 1791 61 PUSH2 0x1878 1794 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1786 stack[0] = storage[0x0104] // @178A stack[1] = 0x00 // } // Block ends with conditional jump to 0x1878, if !(0x00 < storage[0x0104]) label_1795: // Incoming jump from 0x1794, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x1794, if not !(0x00 < storage[0x0104]) // Inputs[2] // { // @17A3 stack[-1] // @17A5 storage[0x0104] // } 1795 61 PUSH2 0x0109 1798 60 PUSH1 0x00 179A 50 POP 179B 60 PUSH1 0x00 179D 61 PUSH2 0x0104 17A0 60 PUSH1 0x00 17A2 50 POP 17A3 83 DUP4 17A4 81 DUP2 17A5 54 SLOAD 17A6 81 DUP2 17A7 10 LT 17A8 15 ISZERO 17A9 61 PUSH2 0x0002 17AC 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1795 stack[0] = 0x0109 // @179B stack[1] = 0x00 // @179D stack[2] = 0x0104 // @17A3 stack[3] = stack[-1] // } // Block ends with conditional jump to 0x0002, if !(stack[-1] < storage[0x0104]) label_17AD: // Incoming jump from 0x17AC, if not !(stack[-1] < storage[0x0104]) // Inputs[9] // { // @17AD stack[-1] // @17AD stack[-2] // @17B5 memory[0x00:0x20] // @17BC storage[stack[-1] + keccak256(memory[0x00:0x20])] // @17BD stack[-3] // @17C2 stack[-4] // @17CA memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @17D8 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) + 0x00] // @1807 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) + 0x02] // } 17AD 90 SWAP1 17AE 60 PUSH1 0x00 17B0 52 MSTORE 17B1 60 PUSH1 0x20 17B3 60 PUSH1 0x00 17B5 20 SHA3 17B6 90 SWAP1 17B7 01 ADD 17B8 60 PUSH1 0x00 17BA 5B JUMPDEST 17BB 50 POP 17BC 54 SLOAD 17BD 81 DUP2 17BE 52 MSTORE 17BF 60 PUSH1 0x20 17C1 01 ADD 17C2 90 SWAP1 17C3 81 DUP2 17C4 52 MSTORE 17C5 60 PUSH1 0x20 17C7 01 ADD 17C8 60 PUSH1 0x00 17CA 20 SHA3 17CB 60 PUSH1 0x00 17CD 60 PUSH1 0x00 17CF 82 DUP3 17D0 01 ADD 17D1 60 PUSH1 0x00 17D3 61 PUSH2 0x0100 17D6 0A EXP 17D7 81 DUP2 17D8 54 SLOAD 17D9 90 SWAP1 17DA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17EF 02 MUL 17F0 19 NOT 17F1 16 AND 17F2 90 SWAP1 17F3 55 SSTORE 17F4 60 PUSH1 0x01 17F6 82 DUP3 17F7 01 ADD 17F8 60 PUSH1 0x00 17FA 50 POP 17FB 60 PUSH1 0x00 17FD 90 SWAP1 17FE 55 SSTORE 17FF 60 PUSH1 0x02 1801 82 DUP3 1802 01 ADD 1803 60 PUSH1 0x00 1805 50 POP 1806 80 DUP1 1807 54 SLOAD 1808 60 PUSH1 0x01 180A 81 DUP2 180B 60 PUSH1 0x01 180D 16 AND 180E 15 ISZERO 180F 61 PUSH2 0x0100 1812 02 MUL 1813 03 SUB 1814 16 AND 1815 60 PUSH1 0x02 1817 90 SWAP1 1818 04 DIV 1819 60 PUSH1 0x00 181B 82 DUP3 181C 55 SSTORE 181D 80 DUP1 181E 60 PUSH1 0x1f 1820 10 LT 1821 61 PUSH2 0x182a 1824 57 *JUMPI // Stack delta = +0 // Outputs[10] // { // @17B0 memory[0x00:0x20] = stack[-2] // @17BE memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-1] + keccak256(memory[0x00:0x20])] // @17C4 memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @17CA stack[-4] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) // @17CB stack[-3] = 0x00 // @17F3 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) + 0x00] = ~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) + 0x00] // @17FE storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) + 0x01] = 0x00 // @1802 stack[-2] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) + 0x02 // @1818 stack[-1] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) + 0x02]) - 0x01 & storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) + 0x02]) / 0x02 // @181C storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) + 0x02] = 0x00 // } // Block ends with conditional jump to 0x182a, if 0x1f < (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) + 0x02]) - 0x01 & storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) + 0x02]) / 0x02 label_1825: // Incoming jump from 0x1824, if not 0x1f < (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) + 0x02]) - 0x01 & storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) + 0x02]) / 0x02 1825 50 POP 1826 61 PUSH2 0x1867 1829 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x1867 label_182A: // Incoming jump from 0x1824, if 0x1f < (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) + 0x02]) - 0x01 & storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) + 0x02]) / 0x02 // Inputs[3] // { // @182D stack[-1] // @1832 stack[-2] // @183A memory[0x00:0x20] // } 182A 5B JUMPDEST 182B 60 PUSH1 0x1f 182D 01 ADD 182E 60 PUSH1 0x20 1830 90 SWAP1 1831 04 DIV 1832 90 SWAP1 1833 60 PUSH1 0x00 1835 52 MSTORE 1836 60 PUSH1 0x20 1838 60 PUSH1 0x00 183A 20 SHA3 183B 90 SWAP1 183C 81 DUP2 183D 01 ADD 183E 90 SWAP1 183F 61 PUSH2 0x1866 1842 91 SWAP2 1843 90 SWAP1 1844 61 PUSH2 0x1848 1847 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1835 memory[0x00:0x20] = stack[-2] // @1842 stack[-2] = 0x1866 // @1843 stack[-1] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // @1843 stack[0] = keccak256(memory[0x00:0x20]) // } // Block ends with call to 0x1848, returns to 0x1866 label_1848: // Incoming call from 0x1847, returns to 0x1866 // Incoming jump from 0x1861 // Inputs[2] // { // @1849 stack[-1] // @184A stack[-2] // } 1848 5B JUMPDEST 1849 80 DUP1 184A 82 DUP3 184B 11 GT 184C 15 ISZERO 184D 61 PUSH2 0x1862 1850 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1862, if !(stack[-2] > stack[-1]) label_1851: // Incoming jump from 0x1850, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1853 stack[-1] } 1851 60 PUSH1 0x00 1853 81 DUP2 1854 81 DUP2 1855 50 POP 1856 60 PUSH1 0x00 1858 90 SWAP1 1859 55 SSTORE 185A 50 POP 185B 60 PUSH1 0x01 185D 01 ADD 185E 61 PUSH2 0x1848 1861 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1859 storage[stack[-1]] = 0x00 // @185D stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1848 label_1862: // Incoming jump from 0x1850, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @1864 stack[-3] // @1864 stack[-2] // } 1862 5B JUMPDEST 1863 50 POP 1864 90 SWAP1 1865 56 *JUMP // Stack delta = -2 // Outputs[1] { @1864 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_1866: // Incoming return from call to 0x1848 at 0x1847 1866 5B JUMPDEST // Stack delta = +0 // Block continues label_1867: // Incoming jump from 0x1829 // Incoming jump from 0x1866 // Inputs[1] { @186C stack[-4] } 1867 5B JUMPDEST 1868 50 POP 1869 50 POP 186A 50 POP 186B 5B JUMPDEST 186C 80 DUP1 186D 60 PUSH1 0x01 186F 01 ADD 1870 90 SWAP1 1871 50 POP 1872 80 DUP1 1873 50 POP 1874 61 PUSH2 0x178c 1877 56 *JUMP // Stack delta = -3 // Outputs[1] { @1870 stack[-4] = 0x01 + stack[-4] } // Block ends with unconditional jump to 0x178c label_1878: // Incoming jump from 0x1794, if !(stack[-1] < stack[-2]) // Incoming jump from 0x1794, if !(0x00 < storage[0x0104]) 1878 5B JUMPDEST 1879 61 PUSH2 0x1880 187C 61 PUSH2 0x1885 187F 56 *JUMP // Stack delta = +1 // Outputs[1] { @1879 stack[0] = 0x1880 } // Block ends with call to 0x1885, returns to 0x1880 label_1880: // Incoming return from call to 0x1885 at 0x187F // Inputs[1] { @1884 stack[-3] } 1880 5B JUMPDEST 1881 5B JUMPDEST 1882 50 POP 1883 50 POP 1884 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_1885: // Incoming call from 0x187F, returns to 0x1880 // Inputs[1] { @1891 storage[0x0104] } 1885 5B JUMPDEST 1886 60 PUSH1 0x00 1888 60 PUSH1 0x00 188A 61 PUSH2 0x0104 188D 60 PUSH1 0x00 188F 50 POP 1890 80 DUP1 1891 54 SLOAD 1892 90 SWAP1 1893 50 POP 1894 91 SWAP2 1895 50 POP 1896 60 PUSH1 0x00 1898 90 SWAP1 1899 50 POP 189A 5B JUMPDEST 189B 81 DUP2 189C 81 DUP2 189D 10 LT 189E 15 ISZERO 189F 61 PUSH2 0x1938 18A2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1894 stack[0] = storage[0x0104] // @1898 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1938, if !(0x00 < storage[0x0104]) label_18A3: // Incoming jump from 0x18A2, if not !(0x00 < storage[0x0104]) // Incoming jump from 0x18A2, if not !(stack[-1] < stack[-2]) // Inputs[2] // { // @18AE stack[-1] // @18B0 storage[0x0104] // } 18A3 60 PUSH1 0x00 18A5 60 PUSH1 0x01 18A7 02 MUL 18A8 61 PUSH2 0x0104 18AB 60 PUSH1 0x00 18AD 50 POP 18AE 82 DUP3 18AF 81 DUP2 18B0 54 SLOAD 18B1 81 DUP2 18B2 10 LT 18B3 15 ISZERO 18B4 61 PUSH2 0x0002 18B7 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @18A7 stack[0] = 0x01 * 0x00 // @18A8 stack[1] = 0x0104 // @18AE stack[2] = stack[-1] // } // Block ends with conditional jump to 0x0002, if !(stack[-1] < storage[0x0104]) label_18B8: // Incoming jump from 0x18B7, if not !(stack[-1] < storage[0x0104]) // Inputs[5] // { // @18B8 stack[-2] // @18B8 stack[-1] // @18C0 memory[0x00:0x20] // @18C7 storage[stack[-1] + keccak256(memory[0x00:0x20])] // @18C8 stack[-3] // } 18B8 90 SWAP1 18B9 60 PUSH1 0x00 18BB 52 MSTORE 18BC 60 PUSH1 0x20 18BE 60 PUSH1 0x00 18C0 20 SHA3 18C1 90 SWAP1 18C2 01 ADD 18C3 60 PUSH1 0x00 18C5 5B JUMPDEST 18C6 50 POP 18C7 54 SLOAD 18C8 14 EQ 18C9 15 ISZERO 18CA 15 ISZERO 18CB 61 PUSH2 0x192a 18CE 57 *JUMPI // Stack delta = -3 // Outputs[1] { @18BB memory[0x00:0x20] = stack[-2] } // Block ends with conditional jump to 0x192a, if !!(storage[stack[-1] + keccak256(memory[0x00:0x20])] == stack[-3]) label_18CF: // Incoming jump from 0x18CE, if not !!(storage[stack[-1] + keccak256(memory[0x00:0x20])] == stack[-3]) // Inputs[2] // { // @18DD stack[-1] // @18DF storage[0x0104] // } 18CF 61 PUSH2 0x0103 18D2 60 PUSH1 0x00 18D4 50 POP 18D5 60 PUSH1 0x00 18D7 61 PUSH2 0x0104 18DA 60 PUSH1 0x00 18DC 50 POP 18DD 83 DUP4 18DE 81 DUP2 18DF 54 SLOAD 18E0 81 DUP2 18E1 10 LT 18E2 15 ISZERO 18E3 61 PUSH2 0x0002 18E6 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @18CF stack[0] = 0x0103 // @18D5 stack[1] = 0x00 // @18D7 stack[2] = 0x0104 // @18DD stack[3] = stack[-1] // } // Block ends with conditional jump to 0x0002, if !(stack[-1] < storage[0x0104]) label_18E7: // Incoming jump from 0x18E6, if not !(stack[-1] < storage[0x0104]) // Inputs[7] // { // @18E7 stack[-2] // @18E7 stack[-1] // @18EF memory[0x00:0x20] // @18F6 storage[stack[-1] + keccak256(memory[0x00:0x20])] // @18F7 stack[-3] // @18FC stack[-4] // @1904 memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // } 18E7 90 SWAP1 18E8 60 PUSH1 0x00 18EA 52 MSTORE 18EB 60 PUSH1 0x20 18ED 60 PUSH1 0x00 18EF 20 SHA3 18F0 90 SWAP1 18F1 01 ADD 18F2 60 PUSH1 0x00 18F4 5B JUMPDEST 18F5 50 POP 18F6 54 SLOAD 18F7 81 DUP2 18F8 52 MSTORE 18F9 60 PUSH1 0x20 18FB 01 ADD 18FC 90 SWAP1 18FD 81 DUP2 18FE 52 MSTORE 18FF 60 PUSH1 0x20 1901 01 ADD 1902 60 PUSH1 0x00 1904 20 SHA3 1905 60 PUSH1 0x00 1907 60 PUSH1 0x00 1909 82 DUP3 190A 01 ADD 190B 60 PUSH1 0x00 190D 50 POP 190E 60 PUSH1 0x00 1910 90 SWAP1 1911 55 SSTORE 1912 60 PUSH1 0x01 1914 82 DUP3 1915 01 ADD 1916 60 PUSH1 0x00 1918 50 POP 1919 60 PUSH1 0x00 191B 90 SWAP1 191C 55 SSTORE 191D 60 PUSH1 0x02 191F 82 DUP3 1920 01 ADD 1921 60 PUSH1 0x00 1923 50 POP 1924 60 PUSH1 0x00 1926 90 SWAP1 1927 55 SSTORE 1928 50 POP 1929 50 POP // Stack delta = -4 // Outputs[6] // { // @18EA memory[0x00:0x20] = stack[-2] // @18F8 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-1] + keccak256(memory[0x00:0x20])] // @18FE memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @1911 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) + 0x00] = 0x00 // @191C storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) + 0x01] = 0x00 // @1927 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]]) + 0x02] = 0x00 // } // Block continues label_192A: // Incoming jump from 0x18CE, if !!(storage[stack[-1] + keccak256(memory[0x00:0x20])] == stack[-3]) // Incoming jump from 0x1929 // Inputs[1] { @192C stack[-1] } 192A 5B JUMPDEST 192B 5B JUMPDEST 192C 80 DUP1 192D 60 PUSH1 0x01 192F 01 ADD 1930 90 SWAP1 1931 50 POP 1932 80 DUP1 1933 50 POP 1934 61 PUSH2 0x189a 1937 56 *JUMP // Stack delta = +0 // Outputs[1] { @1930 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x189a label_1938: // Incoming jump from 0x18A2, if !(0x00 < storage[0x0104]) // Incoming jump from 0x18A2, if !(stack[-1] < stack[-2]) // Inputs[2] // { // @1940 storage[0x0104] // @194D memory[0x00:0x20] // } 1938 5B JUMPDEST 1939 61 PUSH2 0x0104 193C 60 PUSH1 0x00 193E 50 POP 193F 80 DUP1 1940 54 SLOAD 1941 60 PUSH1 0x00 1943 82 DUP3 1944 55 SSTORE 1945 90 SWAP1 1946 60 PUSH1 0x00 1948 52 MSTORE 1949 60 PUSH1 0x20 194B 60 PUSH1 0x00 194D 20 SHA3 194E 90 SWAP1 194F 81 DUP2 1950 01 ADD 1951 90 SWAP1 1952 61 PUSH2 0x1979 1955 91 SWAP2 1956 90 SWAP1 1957 61 PUSH2 0x195b 195A 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1944 storage[0x0104] = 0x00 // @1948 memory[0x00:0x20] = 0x0104 // @1955 stack[0] = 0x1979 // @1956 stack[1] = keccak256(memory[0x00:0x20]) + storage[0x0104] // @1956 stack[2] = keccak256(memory[0x00:0x20]) // } // Block ends with call to 0x195b, returns to 0x1979 label_195B: // Incoming call from 0x195A, returns to 0x1979 // Incoming jump from 0x1974 // Inputs[2] // { // @195C stack[-1] // @195D stack[-2] // } 195B 5B JUMPDEST 195C 80 DUP1 195D 82 DUP3 195E 11 GT 195F 15 ISZERO 1960 61 PUSH2 0x1975 1963 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1975, if !(stack[-2] > stack[-1]) label_1964: // Incoming jump from 0x1963, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1966 stack[-1] } 1964 60 PUSH1 0x00 1966 81 DUP2 1967 81 DUP2 1968 50 POP 1969 60 PUSH1 0x00 196B 90 SWAP1 196C 55 SSTORE 196D 50 POP 196E 60 PUSH1 0x01 1970 01 ADD 1971 61 PUSH2 0x195b 1974 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @196C storage[stack[-1]] = 0x00 // @1970 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x195b label_1975: // Incoming jump from 0x1963, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @1977 stack[-3] // @1977 stack[-2] // } 1975 5B JUMPDEST 1976 50 POP 1977 90 SWAP1 1978 56 *JUMP // Stack delta = -2 // Outputs[1] { @1977 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_1979: // Incoming return from call to 0x195B at 0x195A // Inputs[1] { @197F stack[-4] } 1979 5B JUMPDEST 197A 5B JUMPDEST 197B 50 POP 197C 5B JUMPDEST 197D 50 POP 197E 50 POP 197F 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_1980: // Incoming call from 0x16F5, returns to 0x16F6 // Incoming call from 0x170F, returns to 0x1710 // Inputs[1] { @1987 block.timestamp } 1980 5B JUMPDEST 1981 60 PUSH1 0x00 1983 62 PUSH3 0x015180 1987 42 TIMESTAMP 1988 04 DIV 1989 90 SWAP1 198A 50 POP 198B 61 PUSH2 0x198f 198E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1989 stack[0] = block.timestamp / 0x015180 } // Block ends with unconditional jump to 0x198f label_198F: // Incoming jump from 0x198E // Inputs[2] // { // @1990 stack[-1] // @1990 stack[-2] // } 198F 5B JUMPDEST 1990 90 SWAP1 1991 56 *JUMP // Stack delta = -1 // Outputs[1] { @1990 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2]
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]