Online Solidity Decompiler

« Decompile another contract

Address

0xb570cf8cb430ef6855f8effbd009e55cb8109b4b [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.
0x06fdde03 name()
0x095ea7b3 approve(address,uint256)
0x18160ddd totalSupply()
0x23b872dd transferFrom(address,address,uint256)
0x313ce567 decimals()
0x39509351 increaseAllowance(address,uint256)
0x70a08231 balanceOf(address)
0x715018a6 renounceOwnership()
0x8da5cb5b owner()
0x95d89b41 symbol()
0xa457c2d7 decreaseAllowance(address,uint256)
0xa9059cbb transfer(address,uint256)
0xdd62ed3e allowance(address,address)
0xf2fde38b transferOwnership(address)

Internal Methods

func_011F(arg0, arg1) returns (r0)
func_016D(arg0, arg1, arg2) returns (r0)
func_01BB(arg0, arg1) returns (r0)
func_01EB(arg0) returns (r0)
func_0261(arg0, arg1) returns (r0)
func_0291(arg0, arg1) returns (r0)
func_02C1(arg0, arg1) returns (r0)
func_02F1(arg0)
func_02F8() returns (r0)
func_039E() returns (r0)
func_0443(arg0, arg1, arg2)
func_0453() returns (r0)
func_04F9(arg0, arg1, arg2)
renounceOwnership()
func_0695() returns (r0)
func_06BC() returns (r0)
func_07DD(arg0, arg1, arg2)
func_0A3A(arg0, arg1, arg2)
func_0BFD(arg0, arg1, arg2)
func_0E65(arg0, arg1) returns (r0)
func_0EC2(arg0, arg1) returns (r0)
func_0F1F(arg0) returns (r0)
func_0F29(arg0, arg1) returns (r0)
func_0F39(arg0, arg1, arg2)
func_0F61(arg0) returns (r0)
func_0F71(arg0, arg1) returns (r0)
func_0FA9(arg0, arg1) returns (r0)
func_0FCD(arg0) returns (r0)
func_0FEC(arg0) returns (r0)
func_0FFD(arg0)
func_1013(arg0, arg1) returns (r0)
func_1027(arg0) returns (r0)
func_1030(arg0)
func_1046(arg0, arg1) returns (r0)
func_105A(arg0, arg1) returns (r0, r1)
func_1098(arg0) returns (r0)
func_10A3(arg0, arg1)
func_10B2(arg0, arg1) returns (r0)
func_10CB(arg0, arg1)
func_10DA(arg0, arg1) returns (r0)
func_10F3(arg0, arg1) returns (r0, r1, r2)
func_1143(arg0) returns (r0)
func_114F(arg0, arg1)
func_115E(arg0, arg1) returns (r0)
func_1177(arg0, arg1) returns (r0)
func_11A2(arg0, arg1)
func_11B1(arg0, arg1) returns (r0)
func_11CA(arg0, arg1) returns (r0, r1)
func_1235(arg0) returns (r0)
func_1265(arg0)
func_128D(arg0) returns (r0)
func_12AF(arg0) returns (r0)
func_12CD(arg0)
func_131B(arg0) returns (r0)
func_133D(arg0) returns (r0)
func_135B(arg0)
func_13A9(arg0) returns (r0)
func_13CB(arg0) returns (r0)
func_13E9(arg0)
func_1437(arg0) returns (r0)
func_1459(arg0) returns (r0)
func_1477(arg0)
func_14C5(arg0) returns (r0)
func_14E7(arg0) returns (r0)
func_1505(arg0)
func_1553(arg0) returns (r0)
func_1575(arg0) returns (r0)
func_1593(arg0)
func_15BB(arg0) returns (r0)
func_15DD(arg0) returns (r0)
func_1628(arg0, arg1) returns (r0)
func_165B(arg0, arg1) returns (r0)
func_168E(arg0)
func_16B6(arg0) returns (r0)
func_16D8(arg0) returns (r0)

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x80; var var0 = msg.value; if (var0) { revert(memory[0x00:0x00]); } if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); } var0 = msg.data[0x00:0x20] >> 0xe0; if (0x715018a6 > var0) { if (0x23b872dd > var0) { if (var0 == 0x06fdde03) { // Dispatch table entry for name() var var1 = 0x00f4; var1 = func_02F8(); var temp0 = var1; var1 = 0x0101; var var2 = temp0; var var3 = memory[0x40:0x60]; var1 = func_0FA9(var2, var3); var temp1 = memory[0x40:0x60]; return memory[temp1:temp1 + var1 - temp1]; } else if (var0 == 0x095ea7b3) { // Dispatch table entry for approve(address,uint256) var1 = 0x0124; var2 = 0x011f; var var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2, var3 = func_105A(var3, var4); var1 = func_011F(var2, var3); var temp2 = var1; var1 = 0x0131; var2 = temp2; var3 = memory[0x40:0x60]; var1 = func_10B2(var2, var3); var temp3 = memory[0x40:0x60]; return memory[temp3:temp3 + var1 - temp3]; } else if (var0 == 0x18160ddd) { // Dispatch table entry for totalSupply() var1 = 0x0142; var1 = func_039E(); var temp4 = var1; var1 = 0x014f; var2 = temp4; var3 = memory[0x40:0x60]; var1 = func_10DA(var2, var3); var temp5 = memory[0x40:0x60]; return memory[temp5:temp5 + var1 - temp5]; } else { revert(memory[0x00:0x00]); } } else if (var0 == 0x23b872dd) { // Dispatch table entry for transferFrom(address,address,uint256) var1 = 0x0172; var2 = 0x016d; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2, var3, var4 = func_10F3(var3, var4); var1 = func_016D(var2, var3, var4); var temp6 = var1; var1 = 0x017f; var2 = temp6; var3 = memory[0x40:0x60]; var1 = func_10B2(var2, var3); var temp7 = memory[0x40:0x60]; return memory[temp7:temp7 + var1 - temp7]; } else if (var0 == 0x313ce567) { // Dispatch table entry for decimals() var1 = 0x0190; var1 = func_0453(); var temp8 = var1; var1 = 0x019d; var2 = temp8; var3 = memory[0x40:0x60]; var1 = func_115E(var2, var3); var temp9 = memory[0x40:0x60]; return memory[temp9:temp9 + var1 - temp9]; } else if (var0 == 0x39509351) { // Dispatch table entry for increaseAllowance(address,uint256) var1 = 0x01c0; var2 = 0x01bb; var3 = msg.data.length - 0x04 + 0x04; var4 = 0x04; var2, var3 = func_105A(var3, var4); var1 = func_01BB(var2, var3); var temp10 = var1; var1 = 0x01cd; var2 = temp10; var3 = memory[0x40:0x60]; var1 = func_10B2(var2, var3); var temp11 = memory[0x40:0x60]; return memory[temp11:temp11 + var1 - temp11]; } else if (var0 == 0x70a08231) { // Dispatch table entry for balanceOf(address) var1 = 0x01f0; var2 = 0x01eb; var3 = msg.data.length - 0x04 + 0x04; var4 = 0x04; var2 = func_1177(var3, var4); var1 = func_01EB(var2); var temp12 = var1; var1 = 0x01fd; var2 = temp12; var3 = memory[0x40:0x60]; var1 = func_10DA(var2, var3); var temp13 = memory[0x40:0x60]; return memory[temp13:temp13 + var1 - temp13]; } else { revert(memory[0x00:0x00]); } } else if (0xa457c2d7 > var0) { if (var0 == 0x715018a6) { // Dispatch table entry for renounceOwnership() var1 = 0x020e; renounceOwnership(); stop(); } else if (var0 == 0x8da5cb5b) { // Dispatch table entry for owner() var1 = 0x0218; var1 = func_0695(); var temp14 = var1; var1 = 0x0225; var2 = temp14; var3 = memory[0x40:0x60]; var1 = func_11B1(var2, var3); var temp15 = memory[0x40:0x60]; return memory[temp15:temp15 + var1 - temp15]; } else if (var0 == 0x95d89b41) { // Dispatch table entry for symbol() var1 = 0x0236; var1 = func_06BC(); var temp16 = var1; var1 = 0x0243; var2 = temp16; var3 = memory[0x40:0x60]; var1 = func_0FA9(var2, var3); var temp17 = memory[0x40:0x60]; return memory[temp17:temp17 + var1 - temp17]; } else { revert(memory[0x00:0x00]); } } else if (var0 == 0xa457c2d7) { // Dispatch table entry for decreaseAllowance(address,uint256) var1 = 0x0266; var2 = 0x0261; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2, var3 = func_105A(var3, var4); var1 = func_0261(var2, var3); var temp18 = var1; var1 = 0x0273; var2 = temp18; var3 = memory[0x40:0x60]; var1 = func_10B2(var2, var3); var temp19 = memory[0x40:0x60]; return memory[temp19:temp19 + var1 - temp19]; } else if (var0 == 0xa9059cbb) { // Dispatch table entry for transfer(address,uint256) var1 = 0x0296; var2 = 0x0291; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2, var3 = func_105A(var3, var4); var1 = func_0291(var2, var3); var temp20 = var1; var1 = 0x02a3; var2 = temp20; var3 = memory[0x40:0x60]; var1 = func_10B2(var2, var3); var temp21 = memory[0x40:0x60]; return memory[temp21:temp21 + var1 - temp21]; } else if (var0 == 0xdd62ed3e) { // Dispatch table entry for allowance(address,address) var1 = 0x02c6; var2 = 0x02c1; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2, var3 = func_11CA(var3, var4); var1 = func_02C1(var2, var3); var temp22 = var1; var1 = 0x02d3; var3 = memory[0x40:0x60]; var2 = temp22; var1 = func_10DA(var2, var3); var temp23 = memory[0x40:0x60]; return memory[temp23:temp23 + var1 - temp23]; } else if (var0 == 0xf2fde38b) { // Dispatch table entry for transferOwnership(address) var1 = 0x02f6; var2 = 0x02f1; var3 = msg.data.length - 0x04 + 0x04; var4 = 0x04; var2 = func_1177(var3, var4); func_02F1(var2); stop(); } else { revert(memory[0x00:0x00]); } } function func_011F(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x0394; var var2 = msg.sender; var var3 = arg0; var var4 = arg1; func_0A3A(var2, var3, var4); return 0x01; } function func_016D(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x00; var var1 = 0x03b3; var var2 = arg0; var var3 = arg1; var var4 = arg2; func_0BFD(var2, var3, var4); var1 = 0x0448; var2 = arg0; var3 = msg.sender; var4 = 0x0443; memory[0x00:0x20] = var2 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x06; var temp0 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = temp0; var var5 = storage[keccak256(memory[0x00:0x40])]; var var6 = arg2; var4 = func_0E65(var5, var6); func_0443(var2, var3, var4); return 0x01; } function func_01BB(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x04fe; var var2 = msg.sender; var var3 = arg0; var var4 = 0x04f9; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x06; var temp0 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = var3 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp0; var var5 = storage[keccak256(memory[0x00:0x40])]; var var6 = arg1; var4 = func_0EC2(var5, var6); func_04F9(var2, var3, var4); return 0x01; } function func_01EB(var arg0) returns (var r0) { memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x05; return storage[keccak256(memory[0x00:0x40])]; } function func_0261(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x07e2; var var2 = msg.sender; var var3 = arg0; var var4 = 0x07dd; memory[0x00:0x20] = msg.sender; memory[0x20:0x40] = 0x06; var temp0 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = var3 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp0; var var5 = storage[keccak256(memory[0x00:0x40])]; var var6 = arg1; var4 = func_0E65(var5, var6); func_07DD(var2, var3, var4); return 0x01; } function func_0291(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x07f8; var var2 = msg.sender; var var3 = arg0; var var4 = arg1; func_0BFD(var2, var3, var4); return 0x01; } function func_02C1(var arg0, var arg1) returns (var r0) { memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x06; var temp0 = keccak256(memory[0x00:0x40]); memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp0; return storage[keccak256(memory[0x00:0x40])]; } function func_02F1(var arg0) { if (storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff != msg.sender) { var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp4 + 0x04; var0 = 0x0908; var0 = func_12AF(var1); var temp5 = memory[0x40:0x60]; revert(memory[temp5:temp5 + var0 - temp5]); } else if (arg0 & 0xffffffffffffffffffffffffffffffffffffffff) { var temp0 = arg0; var temp1 = memory[0x40:0x60]; log(memory[temp1:temp1 + memory[0x40:0x60] - temp1], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); storage[0x00] = (temp0 & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[0x00] & ~0xffffffffffffffffffffffffffffffffffffffff); return; } else { var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var var1 = temp2 + 0x04; var var0 = 0x0976; var0 = func_133D(var1); var temp3 = memory[0x40:0x60]; revert(memory[temp3:temp3 + var0 - temp3]); } } function func_02F8() returns (var r0) { var var0 = 0x60; var var1 = 0x01; var var2 = 0x0307; var var3 = storage[var1]; var2 = func_1235(var3); var temp0 = var2; var temp1 = memory[0x40:0x60]; memory[0x40:0x60] = temp1 + (temp0 + 0x1f) / 0x20 * 0x20 + 0x20; var temp2 = var1; var1 = temp1; var2 = temp2; var3 = temp0; memory[var1:var1 + 0x20] = var3; var var4 = var1 + 0x20; var var5 = var2; var var7 = storage[var5]; var var6 = 0x0333; var6 = func_1235(var7); if (!var6) { label_037E: return var1; } else if (0x1f < var6) { var temp3 = var4; var temp4 = temp3 + var6; var4 = temp4; memory[0x00:0x20] = var5; var temp5 = keccak256(memory[0x00:0x20]); memory[temp3:temp3 + 0x20] = storage[temp5]; var5 = temp5 + 0x01; var6 = temp3 + 0x20; if (var4 <= var6) { goto label_0375; } label_0361: var temp6 = var5; var temp7 = var6; memory[temp7:temp7 + 0x20] = storage[temp6]; var5 = temp6 + 0x01; var6 = temp7 + 0x20; if (var4 > var6) { goto label_0361; } label_0375: var temp8 = var4; var temp9 = temp8 + (var6 - temp8 & 0x1f); var6 = temp8; var4 = temp9; goto label_037E; } else { var temp10 = var4; memory[temp10:temp10 + 0x20] = storage[var5] / 0x0100 * 0x0100; var4 = temp10 + 0x20; var6 = var6; goto label_037E; } } function func_039E() returns (var r0) { return storage[0x04]; } function func_0443(var arg0, var arg1, var arg2) { func_0A3A(arg0, arg1, arg2); // Error: Could not resolve method call return address! } function func_0453() returns (var r0) { return storage[0x03] & 0xff; } function func_04F9(var arg0, var arg1, var arg2) { func_0A3A(arg0, arg1, arg2); // Error: Could not resolve method call return address! } function renounceOwnership() { if (storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender) { var temp0 = memory[0x40:0x60]; log(memory[temp0:temp0 + memory[0x40:0x60] - temp0], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffffffffffff & 0x00]); storage[0x00] = (storage[0x00] & ~0xffffffffffffffffffffffffffffffffffffffff) | 0x00; return; } else { var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var var1 = temp1 + 0x04; var var0 = 0x05d2; var0 = func_12AF(var1); var temp2 = memory[0x40:0x60]; revert(memory[temp2:temp2 + var0 - temp2]); } } function func_0695() returns (var r0) { return storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff; } function func_06BC() returns (var r0) { var var0 = 0x60; var var1 = 0x02; var var2 = 0x06cb; var var3 = storage[var1]; var2 = func_1235(var3); var temp0 = var2; var temp1 = memory[0x40:0x60]; memory[0x40:0x60] = temp1 + (temp0 + 0x1f) / 0x20 * 0x20 + 0x20; var temp2 = var1; var1 = temp1; var2 = temp2; var3 = temp0; memory[var1:var1 + 0x20] = var3; var var4 = var1 + 0x20; var var5 = var2; var var7 = storage[var5]; var var6 = 0x06f7; var6 = func_1235(var7); if (!var6) { label_0742: return var1; } else if (0x1f < var6) { var temp3 = var4; var temp4 = temp3 + var6; var4 = temp4; memory[0x00:0x20] = var5; var temp5 = keccak256(memory[0x00:0x20]); memory[temp3:temp3 + 0x20] = storage[temp5]; var5 = temp5 + 0x01; var6 = temp3 + 0x20; if (var4 <= var6) { goto label_0739; } label_0725: var temp6 = var5; var temp7 = var6; memory[temp7:temp7 + 0x20] = storage[temp6]; var5 = temp6 + 0x01; var6 = temp7 + 0x20; if (var4 > var6) { goto label_0725; } label_0739: var temp8 = var4; var temp9 = temp8 + (var6 - temp8 & 0x1f); var6 = temp8; var4 = temp9; goto label_0742; } else { var temp10 = var4; memory[temp10:temp10 + 0x20] = storage[var5] / 0x0100 * 0x0100; var4 = temp10 + 0x20; var6 = var6; goto label_0742; } } function func_07DD(var arg0, var arg1, var arg2) { func_0A3A(arg0, arg1, arg2); // Error: Could not resolve method call return address! } function func_0A3A(var arg0, var arg1, var arg2) { if (!(arg0 & 0xffffffffffffffffffffffffffffffffffffffff)) { var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp6 + 0x04; var0 = 0x0a9f; var0 = func_13CB(var1); var temp7 = memory[0x40:0x60]; revert(memory[temp7:temp7 + var0 - temp7]); } else if (arg1 & 0xffffffffffffffffffffffffffffffffffffffff) { var temp0 = arg0; memory[0x00:0x20] = temp0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x06; var temp1 = keccak256(memory[0x00:0x40]); var temp2 = arg1; memory[0x00:0x20] = temp2 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = temp1; storage[keccak256(memory[0x00:0x40])] = arg2; var var0 = temp2 & 0xffffffffffffffffffffffffffffffffffffffff; var var1 = temp0 & 0xffffffffffffffffffffffffffffffffffffffff; var var2 = 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925; var var3 = 0x0bf0; var var4 = arg2; var var5 = memory[0x40:0x60]; var3 = func_10DA(var4, var5); var temp3 = memory[0x40:0x60]; log(memory[temp3:temp3 + var3 - temp3], [stack[-2], stack[-3], stack[-4]]); return; } else { var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp4 + 0x04; var0 = 0x0b0d; var0 = func_1459(var1); var temp5 = memory[0x40:0x60]; revert(memory[temp5:temp5 + var0 - temp5]); } } function func_0BFD(var arg0, var arg1, var arg2) { if (!(arg0 & 0xffffffffffffffffffffffffffffffffffffffff)) { var temp4 = memory[0x40:0x60]; memory[temp4:temp4 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp4 + 0x04; var0 = 0x0c62; var0 = func_14E7(var1); var temp5 = memory[0x40:0x60]; revert(memory[temp5:temp5 + var0 - temp5]); } else if (arg1 & 0xffffffffffffffffffffffffffffffffffffffff) { var var0 = 0x0d29; memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x05; var var1 = storage[keccak256(memory[0x00:0x40])]; var var2 = arg2; var0 = func_0E65(var1, var2); memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x05; storage[keccak256(memory[0x00:0x40])] = var0; var0 = 0x0dba; memory[0x00:0x20] = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x05; var1 = storage[keccak256(memory[0x00:0x40])]; var2 = arg2; var0 = func_0EC2(var1, var2); var temp0 = arg1; memory[0x00:0x20] = temp0 & 0xffffffffffffffffffffffffffffffffffffffff; memory[0x20:0x40] = 0x05; storage[keccak256(memory[0x00:0x40])] = var0; var0 = temp0 & 0xffffffffffffffffffffffffffffffffffffffff; var1 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var2 = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef; var var3 = 0x0e58; var var5 = memory[0x40:0x60]; var var4 = arg2; var3 = func_10DA(var4, var5); var temp1 = memory[0x40:0x60]; log(memory[temp1:temp1 + var3 - temp1], [stack[-2], stack[-3], stack[-4]]); return; } else { var temp2 = memory[0x40:0x60]; memory[temp2:temp2 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp2 + 0x04; var0 = 0x0cd0; var0 = func_1575(var1); var temp3 = memory[0x40:0x60]; revert(memory[temp3:temp3 + var0 - temp3]); } } function func_0E65(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg1 <= arg0) { var var1 = 0x00; var var2 = 0x0eb6; var var3 = arg1; var var4 = arg0; return func_1628(var3, var4); } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = 0x0ea0; var2 = temp0 + 0x04; var1 = func_15DD(var2); var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + var1 - temp1]); } } function func_0EC2(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = var0; var var2 = 0x0ed0; var var3 = arg1; var var4 = arg0; var2 = func_165B(var3, var4); var1 = var2; if (var1 >= arg0) { return var1; } var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var3 = temp0 + 0x04; var2 = 0x0f0c; var2 = func_16D8(var3); var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + var2 - temp1]); } function func_0F1F(var arg0) returns (var r0) { return memory[arg0:arg0 + 0x20]; } function func_0F29(var arg0, var arg1) returns (var r0) { var temp0 = arg1; memory[temp0:temp0 + 0x20] = arg0; return temp0 + 0x20; } function func_0F39(var arg0, var arg1, var arg2) { var var0 = 0x00; if (var0 >= arg0) { label_0F56: memory[arg1 + arg0:arg1 + arg0 + 0x20] = 0x00; return; } else { label_0F44: var temp0 = var0; memory[arg1 + temp0:arg1 + temp0 + 0x20] = memory[arg2 + temp0:arg2 + temp0 + 0x20]; var0 = temp0 + 0x20; if (var0 >= arg0) { goto label_0F56; } else { goto label_0F44; } } } function func_0F61(var arg0) returns (var r0) { return arg0 + 0x1f & ~0x1f; } function func_0F71(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x0f7b; var var2 = arg1; var1 = func_0F1F(var2); var2 = 0x0f85; var var3 = var1; var var4 = arg0; var2 = func_0F29(var3, var4); var temp0 = var2; arg0 = temp0; var2 = 0x0f95; var3 = var1; var4 = arg0; var var5 = arg1 + 0x20; func_0F39(var3, var4, var5); var2 = 0x0f9e; var3 = var1; var2 = func_0F61(var3); return arg0 + var2; } function func_0FA9(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x0fc1; var var2 = var0; var var3 = arg0; return func_0F71(var2, var3); } function func_0FCD(var arg0) returns (var r0) { return arg0 & 0xffffffffffffffffffffffffffffffffffffffff; } function func_0FEC(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x0ff6; var var2 = arg0; return func_0FCD(var2); } function func_0FFD(var arg0) { var var0 = 0x1006; var var1 = arg0; var0 = func_0FEC(var1); if (arg0 == var0) { return; } else { revert(memory[0x00:0x00]); } } function func_1013(var arg0, var arg1) returns (var r0) { var var0 = msg.data[arg1:arg1 + 0x20]; var var1 = 0x1021; var var2 = var0; func_0FFD(var2); return var0; } function func_1027(var arg0) returns (var r0) { return arg0; } function func_1030(var arg0) { var var0 = 0x1039; var var1 = arg0; var0 = func_1027(var1); if (arg0 == var0) { return; } else { revert(memory[0x00:0x00]); } } function func_1046(var arg0, var arg1) returns (var r0) { var var0 = msg.data[arg1:arg1 + 0x20]; var var1 = 0x1054; var var2 = var0; func_1030(var2); return var0; } function func_105A(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; if (arg0 - arg1 i>= 0x40) { var var2 = 0x00; var var3 = 0x107d; var var4 = arg0; var var5 = arg1 + var2; var3 = func_1013(var4, var5); var0 = var3; var2 = 0x20; var3 = 0x108e; var4 = arg0; var5 = arg1 + var2; var3 = func_1046(var4, var5); arg0 = var3; r0 = var0; return r0, arg0; } else { var2 = 0x106f; revert(memory[0x00:0x00]); } } function func_1098(var arg0) returns (var r0) { return !!arg0; } function func_10A3(var arg0, var arg1) { var var0 = 0x10ac; var var1 = arg1; var0 = func_1098(var1); memory[arg0:arg0 + 0x20] = var0; } function func_10B2(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; var var1 = 0x10c5; var var2 = temp0; var var3 = arg0; func_10A3(var2, var3); return var0; } function func_10CB(var arg0, var arg1) { var var0 = 0x10d4; var var1 = arg1; var0 = func_1027(var1); memory[arg0:arg0 + 0x20] = var0; } function func_10DA(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; var var1 = 0x10ed; var var2 = temp0; var var3 = arg0; func_10CB(var2, var3); return var0; } function func_10F3(var arg0, var arg1) returns (var r0, var arg0, var arg1) { var var0 = 0x00; var var1 = var0; var var2 = 0x00; if (arg0 - arg1 i>= 0x60) { var var3 = 0x00; var var4 = 0x1117; var var5 = arg0; var var6 = arg1 + var3; var4 = func_1013(var5, var6); var0 = var4; var3 = 0x20; var4 = 0x1128; var5 = arg0; var6 = arg1 + var3; var4 = func_1013(var5, var6); var1 = var4; var3 = 0x40; var4 = 0x1139; var5 = arg0; var6 = arg1 + var3; var4 = func_1046(var5, var6); arg1 = var4; arg0 = var1; r0 = var0; return r0, arg0, arg1; } else { var3 = 0x1109; revert(memory[0x00:0x00]); } } function func_1143(var arg0) returns (var r0) { return arg0 & 0xff; } function func_114F(var arg0, var arg1) { var var0 = 0x1158; var var1 = arg1; var0 = func_1143(var1); memory[arg0:arg0 + 0x20] = var0; } function func_115E(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; var var1 = 0x1171; var var2 = temp0; var var3 = arg0; func_114F(var2, var3); return var0; } function func_1177(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg0 - arg1 i>= 0x20) { var var1 = 0x00; var var2 = 0x1199; var var3 = arg0; var var4 = arg1 + var1; return func_1013(var3, var4); } else { var1 = 0x118b; revert(memory[0x00:0x00]); } } function func_11A2(var arg0, var arg1) { var var0 = 0x11ab; var var1 = arg1; var0 = func_0FEC(var1); memory[arg0:arg0 + 0x20] = var0; } function func_11B1(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; var var1 = 0x11c4; var var2 = temp0; var var3 = arg0; func_11A2(var2, var3); return var0; } function func_11CA(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; if (arg0 - arg1 i>= 0x40) { var var2 = 0x00; var var3 = 0x11ed; var var4 = arg0; var var5 = arg1 + var2; var3 = func_1013(var4, var5); var0 = var3; var2 = 0x20; var3 = 0x11fe; var4 = arg0; var5 = arg1 + var2; var3 = func_1013(var4, var5); arg0 = var3; r0 = var0; return r0, arg0; } else { var2 = 0x11df; revert(memory[0x00:0x00]); } } function func_1235(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 / 0x02; var var1 = temp0 & 0x01; if (!var1) { var temp1 = var0 & 0x7f; var0 = temp1; if (var1 - (var0 < 0x20)) { goto label_125F; } else { goto label_1257; } } else if (var1 - (var0 < 0x20)) { label_125F: return var0; } else { label_1257: var var2 = 0x125e; memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x22; revert(memory[0x00:0x24]); } } function func_1265(var arg0) { memory[arg0:arg0 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572; } function func_128D(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x1299; var var2 = 0x20; var var3 = arg0; var1 = func_0F29(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x12a4; var2 = arg0; func_1265(var2); return arg0 + 0x20; } function func_12AF(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x12c6; var var2 = var0; return func_128D(var2); } function func_12CD(var arg0) { var temp0 = arg0; memory[temp0:temp0 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000; } function func_131B(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x1327; var var2 = 0x26; var var3 = arg0; var1 = func_0F29(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x1332; var2 = arg0; func_12CD(var2); return arg0 + 0x40; } function func_133D(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x1354; var var2 = var0; return func_131B(var2); } function func_135B(var arg0) { var temp0 = arg0; memory[temp0:temp0 + 0x20] = 0x45524332303a20617070726f76652066726f6d20746865207a65726f20616464; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x7265737300000000000000000000000000000000000000000000000000000000; } function func_13A9(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x13b5; var var2 = 0x24; var var3 = arg0; var1 = func_0F29(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x13c0; var2 = arg0; func_135B(var2); return arg0 + 0x40; } function func_13CB(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x13e2; var var2 = var0; return func_13A9(var2); } function func_13E9(var arg0) { var temp0 = arg0; memory[temp0:temp0 + 0x20] = 0x45524332303a20617070726f766520746f20746865207a65726f206164647265; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x7373000000000000000000000000000000000000000000000000000000000000; } function func_1437(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x1443; var var2 = 0x22; var var3 = arg0; var1 = func_0F29(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x144e; var2 = arg0; func_13E9(var2); return arg0 + 0x40; } function func_1459(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x1470; var var2 = var0; return func_1437(var2); } function func_1477(var arg0) { var temp0 = arg0; memory[temp0:temp0 + 0x20] = 0x45524332303a207472616e736665722066726f6d20746865207a65726f206164; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x6472657373000000000000000000000000000000000000000000000000000000; } function func_14C5(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x14d1; var var2 = 0x25; var var3 = arg0; var1 = func_0F29(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x14dc; var2 = arg0; func_1477(var2); return arg0 + 0x40; } function func_14E7(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x14fe; var var2 = var0; return func_14C5(var2); } function func_1505(var arg0) { var temp0 = arg0; memory[temp0:temp0 + 0x20] = 0x45524332303a207472616e7366657220746f20746865207a65726f2061646472; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x6573730000000000000000000000000000000000000000000000000000000000; } function func_1553(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x155f; var var2 = 0x23; var var3 = arg0; var1 = func_0F29(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x156a; var2 = arg0; func_1505(var2); return arg0 + 0x40; } function func_1575(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x158c; var var2 = var0; return func_1553(var2); } function func_1593(var arg0) { memory[arg0:arg0 + 0x20] = 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000; } function func_15BB(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x15c7; var var2 = 0x1e; var var3 = arg0; var1 = func_0F29(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x15d2; var2 = arg0; func_1593(var2); return arg0 + 0x20; } function func_15DD(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x15f4; var var2 = var0; return func_15BB(var2); } function func_1628(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x1632; var var2 = arg1; var1 = func_1027(var2); arg1 = var1; var1 = 0x163d; var2 = arg0; var1 = func_1027(var2); arg0 = var1; var temp0 = arg1; var0 = temp0 - arg0; if (var0 <= temp0) { return var0; } var1 = 0x1654; memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x11; revert(memory[0x00:0x24]); } function func_165B(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x1665; var var2 = arg1; var1 = func_1027(var2); arg1 = var1; var1 = 0x1670; var2 = arg0; var1 = func_1027(var2); arg0 = var1; var temp0 = arg1; var0 = temp0 + arg0; if (temp0 <= var0) { return var0; } var1 = 0x1687; memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x11; revert(memory[0x00:0x24]); } function func_168E(var arg0) { memory[arg0:arg0 + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000; } function func_16B6(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x16c2; var var2 = 0x1b; var var3 = arg0; var1 = func_0F29(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x16cd; var2 = arg0; func_168E(var2); return arg0 + 0x20; } function func_16D8(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x16ef; var var2 = var0; return func_16B6(var2); } }

Disassembly

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x000f 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x000f, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000E memory[0x00:0x00] } 000C 5F PUSH0 000D 80 DUP1 000E FD *REVERT // Stack delta = +0 // Outputs[1] { @000E revert(memory[0x00:0x00]); } // Block terminates label_000F: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0013 msg.data.length } 000F 5B JUMPDEST 0010 50 POP 0011 60 PUSH1 0x04 0013 36 CALLDATASIZE 0014 10 LT 0015 61 PUSH2 0x00e8 0018 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x00e8, if msg.data.length < 0x04 label_0019: // Incoming jump from 0x0018, if not msg.data.length < 0x04 // Inputs[1] { @001A msg.data[0x00:0x20] } 0019 5F PUSH0 001A 35 CALLDATALOAD 001B 60 PUSH1 0xe0 001D 1C SHR 001E 80 DUP1 001F 63 PUSH4 0x715018a6 0024 11 GT 0025 61 PUSH2 0x008a 0028 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001D stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x008a, if 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 label_0029: // Incoming jump from 0x0028, if not 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xa457c2d7 002F 11 GT 0030 61 PUSH2 0x0064 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0064, if 0xa457c2d7 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xa457c2d7 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xa457c2d7 003A 14 EQ 003B 61 PUSH2 0x024c 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024c, if 0xa457c2d7 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xa457c2d7 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xa9059cbb 0045 14 EQ 0046 61 PUSH2 0x027c 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x027c, if 0xa9059cbb == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xa9059cbb == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xdd62ed3e 0050 14 EQ 0051 61 PUSH2 0x02ac 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ac, if 0xdd62ed3e == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xdd62ed3e == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf2fde38b 005B 14 EQ 005C 61 PUSH2 0x02dc 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02dc, if 0xf2fde38b == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf2fde38b == stack[-1] 0060 61 PUSH2 0x00e8 0063 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00e8 label_0064: // Incoming jump from 0x0033, if 0xa457c2d7 > stack[-1] // Inputs[1] { @0065 stack[-1] } 0064 5B JUMPDEST 0065 80 DUP1 0066 63 PUSH4 0x715018a6 006B 14 EQ 006C 61 PUSH2 0x0206 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0206, if 0x715018a6 == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0x715018a6 == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0x8da5cb5b 0076 14 EQ 0077 61 PUSH2 0x0210 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0210, if 0x8da5cb5b == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0x95d89b41 0081 14 EQ 0082 61 PUSH2 0x022e 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x022e, if 0x95d89b41 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0x95d89b41 == stack[-1] 0086 61 PUSH2 0x00e8 0089 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00e8 label_008A: // Incoming jump from 0x0028, if 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @008B stack[-1] } 008A 5B JUMPDEST 008B 80 DUP1 008C 63 PUSH4 0x23b872dd 0091 11 GT 0092 61 PUSH2 0x00c6 0095 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00c6, if 0x23b872dd > stack[-1] label_0096: // Incoming jump from 0x0095, if not 0x23b872dd > stack[-1] // Inputs[1] { @0096 stack[-1] } 0096 80 DUP1 0097 63 PUSH4 0x23b872dd 009C 14 EQ 009D 61 PUSH2 0x0158 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0158, if 0x23b872dd == stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0x23b872dd == stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0x313ce567 00A7 14 EQ 00A8 61 PUSH2 0x0188 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0188, if 0x313ce567 == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x313ce567 == stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0x39509351 00B2 14 EQ 00B3 61 PUSH2 0x01a6 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a6, if 0x39509351 == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x39509351 == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x70a08231 00BD 14 EQ 00BE 61 PUSH2 0x01d6 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d6, if 0x70a08231 == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x70a08231 == stack[-1] 00C2 61 PUSH2 0x00e8 00C5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00e8 label_00C6: // Incoming jump from 0x0095, if 0x23b872dd > stack[-1] // Inputs[1] { @00C7 stack[-1] } 00C6 5B JUMPDEST 00C7 80 DUP1 00C8 63 PUSH4 0x06fdde03 00CD 14 EQ 00CE 61 PUSH2 0x00ec 00D1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ec, if 0x06fdde03 == stack[-1] label_00D2: // Incoming jump from 0x00D1, if not 0x06fdde03 == stack[-1] // Inputs[1] { @00D2 stack[-1] } 00D2 80 DUP1 00D3 63 PUSH4 0x095ea7b3 00D8 14 EQ 00D9 61 PUSH2 0x010a 00DC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x010a, if 0x095ea7b3 == stack[-1] label_00DD: // Incoming jump from 0x00DC, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @00DD stack[-1] } 00DD 80 DUP1 00DE 63 PUSH4 0x18160ddd 00E3 14 EQ 00E4 61 PUSH2 0x013a 00E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x013a, if 0x18160ddd == stack[-1] label_00E8: // Incoming jump from 0x0063 // Incoming jump from 0x00C5 // Incoming jump from 0x0089 // Incoming jump from 0x00E7, if not 0x18160ddd == stack[-1] // Incoming jump from 0x0018, if msg.data.length < 0x04 // Inputs[1] { @00EB memory[0x00:0x00] } 00E8 5B JUMPDEST 00E9 5F PUSH0 00EA 80 DUP1 00EB FD *REVERT // Stack delta = +0 // Outputs[1] { @00EB revert(memory[0x00:0x00]); } // Block terminates label_00EC: // Incoming jump from 0x00D1, if 0x06fdde03 == stack[-1] 00EC 5B JUMPDEST 00ED 61 PUSH2 0x00f4 00F0 61 PUSH2 0x02f8 00F3 56 *JUMP // Stack delta = +1 // Outputs[1] { @00ED stack[0] = 0x00f4 } // Block ends with call to 0x02f8, returns to 0x00F4 label_00F4: // Incoming return from call to 0x02F8 at 0x00F3 // Inputs[2] // { // @00F7 memory[0x40:0x60] // @00FB stack[-1] // } 00F4 5B JUMPDEST 00F5 60 PUSH1 0x40 00F7 51 MLOAD 00F8 61 PUSH2 0x0101 00FB 91 SWAP2 00FC 90 SWAP1 00FD 61 PUSH2 0x0fa9 0100 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @00FB stack[-1] = 0x0101 // @00FC stack[1] = memory[0x40:0x60] // @00FC stack[0] = stack[-1] // } // Block ends with call to 0x0fa9, returns to 0x0101 label_0101: // Incoming return from call to 0x0FA9 at 0x0100 // Inputs[3] // { // @0104 memory[0x40:0x60] // @0106 stack[-1] // @0109 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0101 5B JUMPDEST 0102 60 PUSH1 0x40 0104 51 MLOAD 0105 80 DUP1 0106 91 SWAP2 0107 03 SUB 0108 90 SWAP1 0109 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0109 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_010A: // Incoming jump from 0x00DC, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0111 msg.data.length } 010A 5B JUMPDEST 010B 61 PUSH2 0x0124 010E 60 PUSH1 0x04 0110 80 DUP1 0111 36 CALLDATASIZE 0112 03 SUB 0113 81 DUP2 0114 01 ADD 0115 90 SWAP1 0116 61 PUSH2 0x011f 0119 91 SWAP2 011A 90 SWAP1 011B 61 PUSH2 0x105a 011E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @010B stack[0] = 0x0124 // @0119 stack[1] = 0x011f // @011A stack[2] = 0x04 + (msg.data.length - 0x04) // @011A stack[3] = 0x04 // } // Block ends with call to 0x105a, returns to 0x011F label_011F: // Incoming return from call to 0x105A at 0x011E 011F 5B JUMPDEST 0120 61 PUSH2 0x0388 0123 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0388 label_0124: // Incoming return from call to 0x011F at 0x011E // Inputs[2] // { // @0127 memory[0x40:0x60] // @012B stack[-1] // } 0124 5B JUMPDEST 0125 60 PUSH1 0x40 0127 51 MLOAD 0128 61 PUSH2 0x0131 012B 91 SWAP2 012C 90 SWAP1 012D 61 PUSH2 0x10b2 0130 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @012B stack[-1] = 0x0131 // @012C stack[1] = memory[0x40:0x60] // @012C stack[0] = stack[-1] // } // Block ends with call to 0x10b2, returns to 0x0131 label_0131: // Incoming return from call to 0x10B2 at 0x0130 // Inputs[3] // { // @0134 memory[0x40:0x60] // @0136 stack[-1] // @0139 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0131 5B JUMPDEST 0132 60 PUSH1 0x40 0134 51 MLOAD 0135 80 DUP1 0136 91 SWAP2 0137 03 SUB 0138 90 SWAP1 0139 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0139 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_013A: // Incoming jump from 0x00E7, if 0x18160ddd == stack[-1] 013A 5B JUMPDEST 013B 61 PUSH2 0x0142 013E 61 PUSH2 0x039e 0141 56 *JUMP // Stack delta = +1 // Outputs[1] { @013B stack[0] = 0x0142 } // Block ends with call to 0x039e, returns to 0x0142 label_0142: // Incoming return from call to 0x039E at 0x0141 // Inputs[2] // { // @0145 memory[0x40:0x60] // @0149 stack[-1] // } 0142 5B JUMPDEST 0143 60 PUSH1 0x40 0145 51 MLOAD 0146 61 PUSH2 0x014f 0149 91 SWAP2 014A 90 SWAP1 014B 61 PUSH2 0x10da 014E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0149 stack[-1] = 0x014f // @014A stack[1] = memory[0x40:0x60] // @014A stack[0] = stack[-1] // } // Block ends with call to 0x10da, returns to 0x014F label_014F: // Incoming return from call to 0x10DA at 0x014E // Inputs[3] // { // @0152 memory[0x40:0x60] // @0154 stack[-1] // @0157 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 014F 5B JUMPDEST 0150 60 PUSH1 0x40 0152 51 MLOAD 0153 80 DUP1 0154 91 SWAP2 0155 03 SUB 0156 90 SWAP1 0157 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0157 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0158: // Incoming jump from 0x00A0, if 0x23b872dd == stack[-1] // Inputs[1] { @015F msg.data.length } 0158 5B JUMPDEST 0159 61 PUSH2 0x0172 015C 60 PUSH1 0x04 015E 80 DUP1 015F 36 CALLDATASIZE 0160 03 SUB 0161 81 DUP2 0162 01 ADD 0163 90 SWAP1 0164 61 PUSH2 0x016d 0167 91 SWAP2 0168 90 SWAP1 0169 61 PUSH2 0x10f3 016C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0159 stack[0] = 0x0172 // @0167 stack[1] = 0x016d // @0168 stack[2] = 0x04 + (msg.data.length - 0x04) // @0168 stack[3] = 0x04 // } // Block ends with call to 0x10f3, returns to 0x016D label_016D: // Incoming return from call to 0x10F3 at 0x016C 016D 5B JUMPDEST 016E 61 PUSH2 0x03a7 0171 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03a7 label_0172: // Incoming return from call to 0x016D at 0x016C // Inputs[2] // { // @0175 memory[0x40:0x60] // @0179 stack[-1] // } 0172 5B JUMPDEST 0173 60 PUSH1 0x40 0175 51 MLOAD 0176 61 PUSH2 0x017f 0179 91 SWAP2 017A 90 SWAP1 017B 61 PUSH2 0x10b2 017E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0179 stack[-1] = 0x017f // @017A stack[1] = memory[0x40:0x60] // @017A stack[0] = stack[-1] // } // Block ends with call to 0x10b2, returns to 0x017F label_017F: // Incoming return from call to 0x10B2 at 0x017E // Inputs[3] // { // @0182 memory[0x40:0x60] // @0184 stack[-1] // @0187 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 017F 5B JUMPDEST 0180 60 PUSH1 0x40 0182 51 MLOAD 0183 80 DUP1 0184 91 SWAP2 0185 03 SUB 0186 90 SWAP1 0187 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0187 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0188: // Incoming jump from 0x00AB, if 0x313ce567 == stack[-1] 0188 5B JUMPDEST 0189 61 PUSH2 0x0190 018C 61 PUSH2 0x0453 018F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0189 stack[0] = 0x0190 } // Block ends with call to 0x0453, returns to 0x0190 label_0190: // Incoming return from call to 0x0453 at 0x018F // Inputs[2] // { // @0193 memory[0x40:0x60] // @0197 stack[-1] // } 0190 5B JUMPDEST 0191 60 PUSH1 0x40 0193 51 MLOAD 0194 61 PUSH2 0x019d 0197 91 SWAP2 0198 90 SWAP1 0199 61 PUSH2 0x115e 019C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0197 stack[-1] = 0x019d // @0198 stack[1] = memory[0x40:0x60] // @0198 stack[0] = stack[-1] // } // Block ends with call to 0x115e, returns to 0x019D label_019D: // Incoming return from call to 0x115E at 0x019C // Inputs[3] // { // @01A0 memory[0x40:0x60] // @01A2 stack[-1] // @01A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 019D 5B JUMPDEST 019E 60 PUSH1 0x40 01A0 51 MLOAD 01A1 80 DUP1 01A2 91 SWAP2 01A3 03 SUB 01A4 90 SWAP1 01A5 F3 *RETURN // Stack delta = -1 // Outputs[1] { @01A5 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_01A6: // Incoming jump from 0x00B6, if 0x39509351 == stack[-1] // Inputs[1] { @01AD msg.data.length } 01A6 5B JUMPDEST 01A7 61 PUSH2 0x01c0 01AA 60 PUSH1 0x04 01AC 80 DUP1 01AD 36 CALLDATASIZE 01AE 03 SUB 01AF 81 DUP2 01B0 01 ADD 01B1 90 SWAP1 01B2 61 PUSH2 0x01bb 01B5 91 SWAP2 01B6 90 SWAP1 01B7 61 PUSH2 0x105a 01BA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01A7 stack[0] = 0x01c0 // @01B5 stack[1] = 0x01bb // @01B6 stack[2] = 0x04 + (msg.data.length - 0x04) // @01B6 stack[3] = 0x04 // } // Block ends with call to 0x105a, returns to 0x01BB label_01BB: // Incoming return from call to 0x105A at 0x01BA 01BB 5B JUMPDEST 01BC 61 PUSH2 0x0468 01BF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0468 label_01C0: // Incoming return from call to 0x01BB at 0x01BA // Inputs[2] // { // @01C3 memory[0x40:0x60] // @01C7 stack[-1] // } 01C0 5B JUMPDEST 01C1 60 PUSH1 0x40 01C3 51 MLOAD 01C4 61 PUSH2 0x01cd 01C7 91 SWAP2 01C8 90 SWAP1 01C9 61 PUSH2 0x10b2 01CC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01C7 stack[-1] = 0x01cd // @01C8 stack[1] = memory[0x40:0x60] // @01C8 stack[0] = stack[-1] // } // Block ends with call to 0x10b2, returns to 0x01CD label_01CD: // Incoming return from call to 0x10B2 at 0x01CC // Inputs[3] // { // @01D0 memory[0x40:0x60] // @01D2 stack[-1] // @01D5 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01CD 5B JUMPDEST 01CE 60 PUSH1 0x40 01D0 51 MLOAD 01D1 80 DUP1 01D2 91 SWAP2 01D3 03 SUB 01D4 90 SWAP1 01D5 F3 *RETURN // Stack delta = -1 // Outputs[1] { @01D5 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_01D6: // Incoming jump from 0x00C1, if 0x70a08231 == stack[-1] // Inputs[1] { @01DD msg.data.length } 01D6 5B JUMPDEST 01D7 61 PUSH2 0x01f0 01DA 60 PUSH1 0x04 01DC 80 DUP1 01DD 36 CALLDATASIZE 01DE 03 SUB 01DF 81 DUP2 01E0 01 ADD 01E1 90 SWAP1 01E2 61 PUSH2 0x01eb 01E5 91 SWAP2 01E6 90 SWAP1 01E7 61 PUSH2 0x1177 01EA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01D7 stack[0] = 0x01f0 // @01E5 stack[1] = 0x01eb // @01E6 stack[2] = 0x04 + (msg.data.length - 0x04) // @01E6 stack[3] = 0x04 // } // Block ends with call to 0x1177, returns to 0x01EB label_01EB: // Incoming return from call to 0x1177 at 0x01EA 01EB 5B JUMPDEST 01EC 61 PUSH2 0x0508 01EF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0508 label_01F0: // Incoming return from call to 0x01EB at 0x01EA // Inputs[2] // { // @01F3 memory[0x40:0x60] // @01F7 stack[-1] // } 01F0 5B JUMPDEST 01F1 60 PUSH1 0x40 01F3 51 MLOAD 01F4 61 PUSH2 0x01fd 01F7 91 SWAP2 01F8 90 SWAP1 01F9 61 PUSH2 0x10da 01FC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01F7 stack[-1] = 0x01fd // @01F8 stack[1] = memory[0x40:0x60] // @01F8 stack[0] = stack[-1] // } // Block ends with call to 0x10da, returns to 0x01FD label_01FD: // Incoming return from call to 0x10DA at 0x01FC // Inputs[3] // { // @0200 memory[0x40:0x60] // @0202 stack[-1] // @0205 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01FD 5B JUMPDEST 01FE 60 PUSH1 0x40 0200 51 MLOAD 0201 80 DUP1 0202 91 SWAP2 0203 03 SUB 0204 90 SWAP1 0205 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0205 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0206: // Incoming jump from 0x006F, if 0x715018a6 == stack[-1] 0206 5B JUMPDEST 0207 61 PUSH2 0x020e 020A 61 PUSH2 0x054e 020D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0207 stack[0] = 0x020e } // Block ends with call to 0x054e, returns to 0x020E label_020E: // Incoming return from call to 0x054E at 0x020D 020E 5B JUMPDEST 020F 00 *STOP // Stack delta = +0 // Outputs[1] { @020F stop(); } // Block terminates label_0210: // Incoming jump from 0x007A, if 0x8da5cb5b == stack[-1] 0210 5B JUMPDEST 0211 61 PUSH2 0x0218 0214 61 PUSH2 0x0695 0217 56 *JUMP // Stack delta = +1 // Outputs[1] { @0211 stack[0] = 0x0218 } // Block ends with call to 0x0695, returns to 0x0218 label_0218: // Incoming return from call to 0x0695 at 0x0217 // Inputs[2] // { // @021B memory[0x40:0x60] // @021F stack[-1] // } 0218 5B JUMPDEST 0219 60 PUSH1 0x40 021B 51 MLOAD 021C 61 PUSH2 0x0225 021F 91 SWAP2 0220 90 SWAP1 0221 61 PUSH2 0x11b1 0224 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @021F stack[-1] = 0x0225 // @0220 stack[1] = memory[0x40:0x60] // @0220 stack[0] = stack[-1] // } // Block ends with call to 0x11b1, returns to 0x0225 label_0225: // Incoming return from call to 0x11B1 at 0x0224 // Inputs[3] // { // @0228 memory[0x40:0x60] // @022A stack[-1] // @022D memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0225 5B JUMPDEST 0226 60 PUSH1 0x40 0228 51 MLOAD 0229 80 DUP1 022A 91 SWAP2 022B 03 SUB 022C 90 SWAP1 022D F3 *RETURN // Stack delta = -1 // Outputs[1] { @022D return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_022E: // Incoming jump from 0x0085, if 0x95d89b41 == stack[-1] 022E 5B JUMPDEST 022F 61 PUSH2 0x0236 0232 61 PUSH2 0x06bc 0235 56 *JUMP // Stack delta = +1 // Outputs[1] { @022F stack[0] = 0x0236 } // Block ends with call to 0x06bc, returns to 0x0236 label_0236: // Incoming return from call to 0x06BC at 0x0235 // Inputs[2] // { // @0239 memory[0x40:0x60] // @023D stack[-1] // } 0236 5B JUMPDEST 0237 60 PUSH1 0x40 0239 51 MLOAD 023A 61 PUSH2 0x0243 023D 91 SWAP2 023E 90 SWAP1 023F 61 PUSH2 0x0fa9 0242 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @023D stack[-1] = 0x0243 // @023E stack[1] = memory[0x40:0x60] // @023E stack[0] = stack[-1] // } // Block ends with call to 0x0fa9, returns to 0x0243 label_0243: // Incoming return from call to 0x0FA9 at 0x0242 // Inputs[3] // { // @0246 memory[0x40:0x60] // @0248 stack[-1] // @024B memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0243 5B JUMPDEST 0244 60 PUSH1 0x40 0246 51 MLOAD 0247 80 DUP1 0248 91 SWAP2 0249 03 SUB 024A 90 SWAP1 024B F3 *RETURN // Stack delta = -1 // Outputs[1] { @024B return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_024C: // Incoming jump from 0x003E, if 0xa457c2d7 == stack[-1] // Inputs[1] { @0253 msg.data.length } 024C 5B JUMPDEST 024D 61 PUSH2 0x0266 0250 60 PUSH1 0x04 0252 80 DUP1 0253 36 CALLDATASIZE 0254 03 SUB 0255 81 DUP2 0256 01 ADD 0257 90 SWAP1 0258 61 PUSH2 0x0261 025B 91 SWAP2 025C 90 SWAP1 025D 61 PUSH2 0x105a 0260 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @024D stack[0] = 0x0266 // @025B stack[1] = 0x0261 // @025C stack[2] = 0x04 + (msg.data.length - 0x04) // @025C stack[3] = 0x04 // } // Block ends with call to 0x105a, returns to 0x0261 label_0261: // Incoming return from call to 0x105A at 0x0260 0261 5B JUMPDEST 0262 61 PUSH2 0x074c 0265 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x074c label_0266: // Incoming return from call to 0x0261 at 0x0260 // Inputs[2] // { // @0269 memory[0x40:0x60] // @026D stack[-1] // } 0266 5B JUMPDEST 0267 60 PUSH1 0x40 0269 51 MLOAD 026A 61 PUSH2 0x0273 026D 91 SWAP2 026E 90 SWAP1 026F 61 PUSH2 0x10b2 0272 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @026D stack[-1] = 0x0273 // @026E stack[1] = memory[0x40:0x60] // @026E stack[0] = stack[-1] // } // Block ends with call to 0x10b2, returns to 0x0273 label_0273: // Incoming return from call to 0x10B2 at 0x0272 // Inputs[3] // { // @0276 memory[0x40:0x60] // @0278 stack[-1] // @027B memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0273 5B JUMPDEST 0274 60 PUSH1 0x40 0276 51 MLOAD 0277 80 DUP1 0278 91 SWAP2 0279 03 SUB 027A 90 SWAP1 027B F3 *RETURN // Stack delta = -1 // Outputs[1] { @027B return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_027C: // Incoming jump from 0x0049, if 0xa9059cbb == stack[-1] // Inputs[1] { @0283 msg.data.length } 027C 5B JUMPDEST 027D 61 PUSH2 0x0296 0280 60 PUSH1 0x04 0282 80 DUP1 0283 36 CALLDATASIZE 0284 03 SUB 0285 81 DUP2 0286 01 ADD 0287 90 SWAP1 0288 61 PUSH2 0x0291 028B 91 SWAP2 028C 90 SWAP1 028D 61 PUSH2 0x105a 0290 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @027D stack[0] = 0x0296 // @028B stack[1] = 0x0291 // @028C stack[2] = 0x04 + (msg.data.length - 0x04) // @028C stack[3] = 0x04 // } // Block ends with call to 0x105a, returns to 0x0291 label_0291: // Incoming return from call to 0x105A at 0x0290 0291 5B JUMPDEST 0292 61 PUSH2 0x07ec 0295 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07ec label_0296: // Incoming return from call to 0x0291 at 0x0290 // Inputs[2] // { // @0299 memory[0x40:0x60] // @029D stack[-1] // } 0296 5B JUMPDEST 0297 60 PUSH1 0x40 0299 51 MLOAD 029A 61 PUSH2 0x02a3 029D 91 SWAP2 029E 90 SWAP1 029F 61 PUSH2 0x10b2 02A2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @029D stack[-1] = 0x02a3 // @029E stack[1] = memory[0x40:0x60] // @029E stack[0] = stack[-1] // } // Block ends with call to 0x10b2, returns to 0x02A3 label_02A3: // Incoming return from call to 0x10B2 at 0x02A2 // Inputs[3] // { // @02A6 memory[0x40:0x60] // @02A8 stack[-1] // @02AB memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 02A3 5B JUMPDEST 02A4 60 PUSH1 0x40 02A6 51 MLOAD 02A7 80 DUP1 02A8 91 SWAP2 02A9 03 SUB 02AA 90 SWAP1 02AB F3 *RETURN // Stack delta = -1 // Outputs[1] { @02AB return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_02AC: // Incoming jump from 0x0054, if 0xdd62ed3e == stack[-1] // Inputs[1] { @02B3 msg.data.length } 02AC 5B JUMPDEST 02AD 61 PUSH2 0x02c6 02B0 60 PUSH1 0x04 02B2 80 DUP1 02B3 36 CALLDATASIZE 02B4 03 SUB 02B5 81 DUP2 02B6 01 ADD 02B7 90 SWAP1 02B8 61 PUSH2 0x02c1 02BB 91 SWAP2 02BC 90 SWAP1 02BD 61 PUSH2 0x11ca 02C0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02AD stack[0] = 0x02c6 // @02BB stack[1] = 0x02c1 // @02BC stack[2] = 0x04 + (msg.data.length - 0x04) // @02BC stack[3] = 0x04 // } // Block ends with call to 0x11ca, returns to 0x02C1 label_02C1: // Incoming return from call to 0x11CA at 0x02C0 02C1 5B JUMPDEST 02C2 61 PUSH2 0x0802 02C5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0802 label_02C6: // Incoming return from call to 0x02C1 at 0x02C0 // Inputs[2] // { // @02C9 memory[0x40:0x60] // @02CD stack[-1] // } 02C6 5B JUMPDEST 02C7 60 PUSH1 0x40 02C9 51 MLOAD 02CA 61 PUSH2 0x02d3 02CD 91 SWAP2 02CE 90 SWAP1 02CF 61 PUSH2 0x10da 02D2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02CD stack[-1] = 0x02d3 // @02CE stack[1] = memory[0x40:0x60] // @02CE stack[0] = stack[-1] // } // Block ends with call to 0x10da, returns to 0x02D3 label_02D3: // Incoming return from call to 0x10DA at 0x02D2 // Inputs[3] // { // @02D6 memory[0x40:0x60] // @02D8 stack[-1] // @02DB memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 02D3 5B JUMPDEST 02D4 60 PUSH1 0x40 02D6 51 MLOAD 02D7 80 DUP1 02D8 91 SWAP2 02D9 03 SUB 02DA 90 SWAP1 02DB F3 *RETURN // Stack delta = -1 // Outputs[1] { @02DB return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_02DC: // Incoming jump from 0x005F, if 0xf2fde38b == stack[-1] // Inputs[1] { @02E3 msg.data.length } 02DC 5B JUMPDEST 02DD 61 PUSH2 0x02f6 02E0 60 PUSH1 0x04 02E2 80 DUP1 02E3 36 CALLDATASIZE 02E4 03 SUB 02E5 81 DUP2 02E6 01 ADD 02E7 90 SWAP1 02E8 61 PUSH2 0x02f1 02EB 91 SWAP2 02EC 90 SWAP1 02ED 61 PUSH2 0x1177 02F0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02DD stack[0] = 0x02f6 // @02EB stack[1] = 0x02f1 // @02EC stack[2] = 0x04 + (msg.data.length - 0x04) // @02EC stack[3] = 0x04 // } // Block ends with call to 0x1177, returns to 0x02F1 label_02F1: // Incoming return from call to 0x1177 at 0x02F0 02F1 5B JUMPDEST 02F2 61 PUSH2 0x0884 02F5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0884 label_02F6: // Incoming return from call to 0x02F1 at 0x02F0 02F6 5B JUMPDEST 02F7 00 *STOP // Stack delta = +0 // Outputs[1] { @02F7 stop(); } // Block terminates label_02F8: // Incoming call from 0x00F3, returns to 0x00F4 // Inputs[1] { @02FE storage[0x01] } 02F8 5B JUMPDEST 02F9 60 PUSH1 0x60 02FB 60 PUSH1 0x01 02FD 80 DUP1 02FE 54 SLOAD 02FF 61 PUSH2 0x0307 0302 90 SWAP1 0303 61 PUSH2 0x1235 0306 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02F9 stack[0] = 0x60 // @02FB stack[1] = 0x01 // @0302 stack[2] = 0x0307 // @0302 stack[3] = storage[0x01] // } // Block ends with call to 0x1235, returns to 0x0307 label_0307: // Incoming return from call to 0x1235 at 0x0306 // Inputs[4] // { // @0308 stack[-1] // @0317 memory[0x40:0x60] // @031F stack[-2] // @032A storage[stack[-2]] // } 0307 5B JUMPDEST 0308 80 DUP1 0309 60 PUSH1 0x1f 030B 01 ADD 030C 60 PUSH1 0x20 030E 80 DUP1 030F 91 SWAP2 0310 04 DIV 0311 02 MUL 0312 60 PUSH1 0x20 0314 01 ADD 0315 60 PUSH1 0x40 0317 51 MLOAD 0318 90 SWAP1 0319 81 DUP2 031A 01 ADD 031B 60 PUSH1 0x40 031D 52 MSTORE 031E 80 DUP1 031F 92 SWAP3 0320 91 SWAP2 0321 90 SWAP1 0322 81 DUP2 0323 81 DUP2 0324 52 MSTORE 0325 60 PUSH1 0x20 0327 01 ADD 0328 82 DUP3 0329 80 DUP1 032A 54 SLOAD 032B 61 PUSH2 0x0333 032E 90 SWAP1 032F 61 PUSH2 0x1235 0332 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @031D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @031F stack[-2] = memory[0x40:0x60] // @0320 stack[-1] = stack[-2] // @0321 stack[0] = stack[-1] // @0324 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0327 stack[1] = 0x20 + memory[0x40:0x60] // @0328 stack[2] = stack[-2] // @032E stack[4] = storage[stack[-2]] // @032E stack[3] = 0x0333 // } // Block ends with call to 0x1235, returns to 0x0333 label_0333: // Incoming return from call to 0x1235 at 0x0332 // Inputs[1] { @0334 stack[-1] } 0333 5B JUMPDEST 0334 80 DUP1 0335 15 ISZERO 0336 61 PUSH2 0x037e 0339 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x037e, if !stack[-1] label_033A: // Incoming jump from 0x0339, if not !stack[-1] // Inputs[1] { @033A stack[-1] } 033A 80 DUP1 033B 60 PUSH1 0x1f 033D 10 LT 033E 61 PUSH2 0x0355 0341 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0355, if 0x1f < stack[-1] label_0342: // Incoming jump from 0x0341, if not 0x1f < stack[-1] // Inputs[4] // { // @0346 stack[-2] // @0347 storage[stack[-2]] // @034A stack[-3] // @034C stack[-1] // } 0342 61 PUSH2 0x0100 0345 80 DUP1 0346 83 DUP4 0347 54 SLOAD 0348 04 DIV 0349 02 MUL 034A 83 DUP4 034B 52 MSTORE 034C 91 SWAP2 034D 60 PUSH1 0x20 034F 01 ADD 0350 91 SWAP2 0351 61 PUSH2 0x037e 0354 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @034B memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0350 stack[-1] = stack[-1] // @0350 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x037e label_0355: // Incoming jump from 0x0341, if 0x1f < stack[-1] // Inputs[5] // { // @0356 stack[-3] // @0357 stack[-1] // @0359 stack[-2] // @035F memory[0x00:0x20] // @0363 storage[keccak256(memory[0x00:0x20])] // } 0355 5B JUMPDEST 0356 82 DUP3 0357 01 ADD 0358 91 SWAP2 0359 90 SWAP1 035A 5F PUSH0 035B 52 MSTORE 035C 60 PUSH1 0x20 035E 5F PUSH0 035F 20 SHA3 0360 90 SWAP1 0361 5B JUMPDEST 0362 81 DUP2 0363 54 SLOAD 0364 81 DUP2 0365 52 MSTORE 0366 90 SWAP1 0367 60 PUSH1 0x01 0369 01 ADD 036A 90 SWAP1 036B 60 PUSH1 0x20 036D 01 ADD 036E 80 DUP1 036F 83 DUP4 0370 11 GT 0371 61 PUSH2 0x0361 0374 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0358 stack[-3] = stack[-3] + stack[-1] // @035B memory[0x00:0x20] = stack[-2] // @0365 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @036A stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @036D stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0361, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0375: // Incoming jump from 0x0374, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0374, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0375 stack[-3] // @0376 stack[-1] // } 0375 82 DUP3 0376 90 SWAP1 0377 03 SUB 0378 60 PUSH1 0x1f 037A 16 AND 037B 82 DUP3 037C 01 ADD 037D 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @037D stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @037D stack[-1] = stack[-3] // } // Block continues label_037E: // Incoming jump from 0x0354 // Incoming jump from 0x037D // Incoming jump from 0x0339, if !stack[-1] // Inputs[3] // { // @0384 stack[-7] // @0384 stack[-6] // @0386 stack[-8] // } 037E 5B JUMPDEST 037F 50 POP 0380 50 POP 0381 50 POP 0382 50 POP 0383 50 POP 0384 90 SWAP1 0385 50 POP 0386 90 SWAP1 0387 56 *JUMP // Stack delta = -7 // Outputs[1] { @0386 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0388: // Incoming jump from 0x0123 // Inputs[3] // { // @038D msg.sender // @038E stack[-2] // @038F stack[-1] // } 0388 5B JUMPDEST 0389 5F PUSH0 038A 61 PUSH2 0x0394 038D 33 CALLER 038E 84 DUP5 038F 84 DUP5 0390 61 PUSH2 0x0a3a 0393 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0389 stack[0] = 0x00 // @038A stack[1] = 0x0394 // @038D stack[2] = msg.sender // @038E stack[3] = stack[-2] // @038F stack[4] = stack[-1] // } // Block ends with call to 0x0a3a, returns to 0x0394 label_0394: // Incoming return from call to 0x0A3A at 0x0393 // Inputs[3] // { // @0397 stack[-1] // @0399 stack[-4] // @039A stack[-3] // } 0394 5B JUMPDEST 0395 60 PUSH1 0x01 0397 90 SWAP1 0398 50 POP 0399 92 SWAP3 039A 91 SWAP2 039B 50 POP 039C 50 POP 039D 56 *JUMP // Stack delta = -3 // Outputs[1] { @0399 stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_039E: // Incoming call from 0x0141, returns to 0x0142 // Inputs[2] // { // @03A2 storage[0x04] // @03A5 stack[-1] // } 039E 5B JUMPDEST 039F 5F PUSH0 03A0 60 PUSH1 0x04 03A2 54 SLOAD 03A3 90 SWAP1 03A4 50 POP 03A5 90 SWAP1 03A6 56 *JUMP // Stack delta = +0 // Outputs[1] { @03A5 stack[-1] = storage[0x04] } // Block ends with unconditional jump to stack[-1] label_03A7: // Incoming jump from 0x0171 // Inputs[3] // { // @03AC stack[-3] // @03AD stack[-2] // @03AE stack[-1] // } 03A7 5B JUMPDEST 03A8 5F PUSH0 03A9 61 PUSH2 0x03b3 03AC 84 DUP5 03AD 84 DUP5 03AE 84 DUP5 03AF 61 PUSH2 0x0bfd 03B2 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @03A8 stack[0] = 0x00 // @03A9 stack[1] = 0x03b3 // @03AC stack[2] = stack[-3] // @03AD stack[3] = stack[-2] // @03AE stack[4] = stack[-1] // } // Block ends with call to 0x0bfd, returns to 0x03B3 label_03B3: // Incoming return from call to 0x0BFD at 0x03B2 // Inputs[7] // { // @03B7 stack[-4] // @03B8 msg.sender // @03BC stack[-2] // @03F9 memory[0x00:0x40] // @03FB msg.sender // @0434 memory[0x00:0x40] // @0435 storage[keccak256(memory[0x00:0x40])] // } 03B3 5B JUMPDEST 03B4 61 PUSH2 0x0448 03B7 84 DUP5 03B8 33 CALLER 03B9 61 PUSH2 0x0443 03BC 85 DUP6 03BD 60 PUSH1 0x06 03BF 5F PUSH0 03C0 8A DUP11 03C1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03D6 16 AND 03D7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03EC 16 AND 03ED 81 DUP2 03EE 52 MSTORE 03EF 60 PUSH1 0x20 03F1 01 ADD 03F2 90 SWAP1 03F3 81 DUP2 03F4 52 MSTORE 03F5 60 PUSH1 0x20 03F7 01 ADD 03F8 5F PUSH0 03F9 20 SHA3 03FA 5F PUSH0 03FB 33 CALLER 03FC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0411 16 AND 0412 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0427 16 AND 0428 81 DUP2 0429 52 MSTORE 042A 60 PUSH1 0x20 042C 01 ADD 042D 90 SWAP1 042E 81 DUP2 042F 52 MSTORE 0430 60 PUSH1 0x20 0432 01 ADD 0433 5F PUSH0 0434 20 SHA3 0435 54 SLOAD 0436 61 PUSH2 0x0e65 0439 90 SWAP1 043A 91 SWAP2 043B 90 SWAP1 043C 63 PUSH4 0xffffffff 0441 16 AND 0442 56 *JUMP // Stack delta = +6 // Outputs[10] // { // @03B4 stack[0] = 0x0448 // @03B7 stack[1] = stack[-4] // @03B8 stack[2] = msg.sender // @03B9 stack[3] = 0x0443 // @03EE memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @03F4 memory[0x20:0x40] = 0x06 // @0429 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @042F memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @043A stack[4] = storage[keccak256(memory[0x00:0x40])] // @043B stack[5] = stack[-2] // } // Block ends with call to 0xffffffff & 0x0e65, returns to 0x0443 label_0443: // Incoming return from call to 0x0E65 at 0x0442 0443 5B JUMPDEST 0444 61 PUSH2 0x0a3a 0447 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a3a label_0448: // Incoming return from call to 0x0443 at 0x0442 // Inputs[3] // { // @044B stack[-1] // @044D stack[-5] // @044E stack[-4] // } 0448 5B JUMPDEST 0449 60 PUSH1 0x01 044B 90 SWAP1 044C 50 POP 044D 93 SWAP4 044E 92 SWAP3 044F 50 POP 0450 50 POP 0451 50 POP 0452 56 *JUMP // Stack delta = -4 // Outputs[1] { @044D stack[-5] = 0x01 } // Block ends with unconditional jump to stack[-5] label_0453: // Incoming call from 0x018F, returns to 0x0190 // Inputs[2] // { // @0459 storage[0x03] // @0466 stack[-1] // } 0453 5B JUMPDEST 0454 5F PUSH0 0455 60 PUSH1 0x03 0457 5F PUSH0 0458 90 SWAP1 0459 54 SLOAD 045A 90 SWAP1 045B 61 PUSH2 0x0100 045E 0A EXP 045F 90 SWAP1 0460 04 DIV 0461 60 PUSH1 0xff 0463 16 AND 0464 90 SWAP1 0465 50 POP 0466 90 SWAP1 0467 56 *JUMP // Stack delta = +0 // Outputs[1] { @0466 stack[-1] = 0xff & storage[0x03] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0468: // Incoming jump from 0x01BF // Inputs[7] // { // @046D msg.sender // @046E stack[-2] // @0472 stack[-1] // @0476 msg.sender // @04AF memory[0x00:0x40] // @04EA memory[0x00:0x40] // @04EB storage[keccak256(memory[0x00:0x40])] // } 0468 5B JUMPDEST 0469 5F PUSH0 046A 61 PUSH2 0x04fe 046D 33 CALLER 046E 84 DUP5 046F 61 PUSH2 0x04f9 0472 85 DUP6 0473 60 PUSH1 0x06 0475 5F PUSH0 0476 33 CALLER 0477 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 048C 16 AND 048D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04A2 16 AND 04A3 81 DUP2 04A4 52 MSTORE 04A5 60 PUSH1 0x20 04A7 01 ADD 04A8 90 SWAP1 04A9 81 DUP2 04AA 52 MSTORE 04AB 60 PUSH1 0x20 04AD 01 ADD 04AE 5F PUSH0 04AF 20 SHA3 04B0 5F PUSH0 04B1 89 DUP10 04B2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04C7 16 AND 04C8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04DD 16 AND 04DE 81 DUP2 04DF 52 MSTORE 04E0 60 PUSH1 0x20 04E2 01 ADD 04E3 90 SWAP1 04E4 81 DUP2 04E5 52 MSTORE 04E6 60 PUSH1 0x20 04E8 01 ADD 04E9 5F PUSH0 04EA 20 SHA3 04EB 54 SLOAD 04EC 61 PUSH2 0x0ec2 04EF 90 SWAP1 04F0 91 SWAP2 04F1 90 SWAP1 04F2 63 PUSH4 0xffffffff 04F7 16 AND 04F8 56 *JUMP // Stack delta = +7 // Outputs[11] // { // @0469 stack[0] = 0x00 // @046A stack[1] = 0x04fe // @046D stack[2] = msg.sender // @046E stack[3] = stack[-2] // @046F stack[4] = 0x04f9 // @04A4 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @04AA memory[0x20:0x40] = 0x06 // @04DF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @04E5 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @04F0 stack[5] = storage[keccak256(memory[0x00:0x40])] // @04F1 stack[6] = stack[-1] // } // Block ends with call to 0xffffffff & 0x0ec2, returns to 0x04F9 label_04F9: // Incoming return from call to 0x0EC2 at 0x04F8 04F9 5B JUMPDEST 04FA 61 PUSH2 0x0a3a 04FD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a3a label_04FE: // Incoming return from call to 0x04F9 at 0x04F8 // Inputs[3] // { // @0501 stack[-1] // @0503 stack[-4] // @0504 stack[-3] // } 04FE 5B JUMPDEST 04FF 60 PUSH1 0x01 0501 90 SWAP1 0502 50 POP 0503 92 SWAP3 0504 91 SWAP2 0505 50 POP 0506 50 POP 0507 56 *JUMP // Stack delta = -3 // Outputs[1] { @0503 stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_0508: // Incoming jump from 0x01EF // Inputs[4] // { // @050D stack[-1] // @0546 memory[0x00:0x40] // @0547 storage[keccak256(memory[0x00:0x40])] // @054A stack[-2] // } 0508 5B JUMPDEST 0509 5F PUSH0 050A 60 PUSH1 0x05 050C 5F PUSH0 050D 83 DUP4 050E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0523 16 AND 0524 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0539 16 AND 053A 81 DUP2 053B 52 MSTORE 053C 60 PUSH1 0x20 053E 01 ADD 053F 90 SWAP1 0540 81 DUP2 0541 52 MSTORE 0542 60 PUSH1 0x20 0544 01 ADD 0545 5F PUSH0 0546 20 SHA3 0547 54 SLOAD 0548 90 SWAP1 0549 50 POP 054A 91 SWAP2 054B 90 SWAP1 054C 50 POP 054D 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @053B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0541 memory[0x20:0x40] = 0x05 // @054A stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_054E: // Incoming call from 0x020D, returns to 0x020E // Inputs[2] // { // @054F msg.sender // @0568 storage[0x00] // } 054E 5B JUMPDEST 054F 33 CALLER 0550 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0565 16 AND 0566 5F PUSH0 0567 80 DUP1 0568 54 SLOAD 0569 90 SWAP1 056A 61 PUSH2 0x0100 056D 0A EXP 056E 90 SWAP1 056F 04 DIV 0570 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0585 16 AND 0586 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 059B 16 AND 059C 14 EQ 059D 61 PUSH2 0x05db 05A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05db, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender label_05A1: // Incoming jump from 0x05A0, if not 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // Inputs[1] { @05A3 memory[0x40:0x60] } 05A1 60 PUSH1 0x40 05A3 51 MLOAD 05A4 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 05C5 81 DUP2 05C6 52 MSTORE 05C7 60 PUSH1 0x04 05C9 01 ADD 05CA 61 PUSH2 0x05d2 05CD 90 SWAP1 05CE 61 PUSH2 0x12af 05D1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @05C6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @05CD stack[0] = 0x05d2 // @05CD stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x12af, returns to 0x05D2 label_05D2: // Incoming return from call to 0x12AF at 0x05D1 // Inputs[3] // { // @05D5 memory[0x40:0x60] // @05D7 stack[-1] // @05DA memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 05D2 5B JUMPDEST 05D3 60 PUSH1 0x40 05D5 51 MLOAD 05D6 80 DUP1 05D7 91 SWAP2 05D8 03 SUB 05D9 90 SWAP1 05DA FD *REVERT // Stack delta = -1 // Outputs[1] { @05DA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_05DB: // Incoming jump from 0x05A0, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // Inputs[6] // { // @05F5 storage[0x00] // @064C memory[0x40:0x60] // @064F memory[0x40:0x60] // @0654 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @065D storage[0x00] // @0694 stack[-1] // } 05DB 5B JUMPDEST 05DC 5F PUSH0 05DD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05F2 16 AND 05F3 5F PUSH0 05F4 80 DUP1 05F5 54 SLOAD 05F6 90 SWAP1 05F7 61 PUSH2 0x0100 05FA 0A EXP 05FB 90 SWAP1 05FC 04 DIV 05FD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0612 16 AND 0613 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0628 16 AND 0629 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 064A 60 PUSH1 0x40 064C 51 MLOAD 064D 60 PUSH1 0x40 064F 51 MLOAD 0650 80 DUP1 0651 91 SWAP2 0652 03 SUB 0653 90 SWAP1 0654 A3 LOG3 0655 5F PUSH0 0656 80 DUP1 0657 5F PUSH0 0658 61 PUSH2 0x0100 065B 0A EXP 065C 81 DUP2 065D 54 SLOAD 065E 81 DUP2 065F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0674 02 MUL 0675 19 NOT 0676 16 AND 0677 90 SWAP1 0678 83 DUP4 0679 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 068E 16 AND 068F 02 MUL 0690 17 OR 0691 90 SWAP1 0692 55 SSTORE 0693 50 POP 0694 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @0654 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffffffffffff & 0x00]); // @0692 storage[0x00] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x00]) // } // Block ends with unconditional jump to stack[-1] label_0695: // Incoming call from 0x0217, returns to 0x0218 // Inputs[2] // { // @069A storage[0x00] // @06BA stack[-1] // } 0695 5B JUMPDEST 0696 5F PUSH0 0697 80 DUP1 0698 5F PUSH0 0699 90 SWAP1 069A 54 SLOAD 069B 90 SWAP1 069C 61 PUSH2 0x0100 069F 0A EXP 06A0 90 SWAP1 06A1 04 DIV 06A2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06B7 16 AND 06B8 90 SWAP1 06B9 50 POP 06BA 90 SWAP1 06BB 56 *JUMP // Stack delta = +0 // Outputs[1] { @06BA stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_06BC: // Incoming call from 0x0235, returns to 0x0236 // Inputs[1] { @06C2 storage[0x02] } 06BC 5B JUMPDEST 06BD 60 PUSH1 0x60 06BF 60 PUSH1 0x02 06C1 80 DUP1 06C2 54 SLOAD 06C3 61 PUSH2 0x06cb 06C6 90 SWAP1 06C7 61 PUSH2 0x1235 06CA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06BD stack[0] = 0x60 // @06BF stack[1] = 0x02 // @06C6 stack[2] = 0x06cb // @06C6 stack[3] = storage[0x02] // } // Block ends with call to 0x1235, returns to 0x06CB label_06CB: // Incoming return from call to 0x1235 at 0x06CA // Inputs[4] // { // @06CC stack[-1] // @06DB memory[0x40:0x60] // @06E3 stack[-2] // @06EE storage[stack[-2]] // } 06CB 5B JUMPDEST 06CC 80 DUP1 06CD 60 PUSH1 0x1f 06CF 01 ADD 06D0 60 PUSH1 0x20 06D2 80 DUP1 06D3 91 SWAP2 06D4 04 DIV 06D5 02 MUL 06D6 60 PUSH1 0x20 06D8 01 ADD 06D9 60 PUSH1 0x40 06DB 51 MLOAD 06DC 90 SWAP1 06DD 81 DUP2 06DE 01 ADD 06DF 60 PUSH1 0x40 06E1 52 MSTORE 06E2 80 DUP1 06E3 92 SWAP3 06E4 91 SWAP2 06E5 90 SWAP1 06E6 81 DUP2 06E7 81 DUP2 06E8 52 MSTORE 06E9 60 PUSH1 0x20 06EB 01 ADD 06EC 82 DUP3 06ED 80 DUP1 06EE 54 SLOAD 06EF 61 PUSH2 0x06f7 06F2 90 SWAP1 06F3 61 PUSH2 0x1235 06F6 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @06E1 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @06E3 stack[-2] = memory[0x40:0x60] // @06E4 stack[-1] = stack[-2] // @06E5 stack[0] = stack[-1] // @06E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @06EB stack[1] = 0x20 + memory[0x40:0x60] // @06EC stack[2] = stack[-2] // @06F2 stack[4] = storage[stack[-2]] // @06F2 stack[3] = 0x06f7 // } // Block ends with call to 0x1235, returns to 0x06F7 label_06F7: // Incoming return from call to 0x1235 at 0x06F6 // Inputs[1] { @06F8 stack[-1] } 06F7 5B JUMPDEST 06F8 80 DUP1 06F9 15 ISZERO 06FA 61 PUSH2 0x0742 06FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0742, if !stack[-1] label_06FE: // Incoming jump from 0x06FD, if not !stack[-1] // Inputs[1] { @06FE stack[-1] } 06FE 80 DUP1 06FF 60 PUSH1 0x1f 0701 10 LT 0702 61 PUSH2 0x0719 0705 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0719, if 0x1f < stack[-1] label_0706: // Incoming jump from 0x0705, if not 0x1f < stack[-1] // Inputs[4] // { // @070A stack[-2] // @070B storage[stack[-2]] // @070E stack[-3] // @0710 stack[-1] // } 0706 61 PUSH2 0x0100 0709 80 DUP1 070A 83 DUP4 070B 54 SLOAD 070C 04 DIV 070D 02 MUL 070E 83 DUP4 070F 52 MSTORE 0710 91 SWAP2 0711 60 PUSH1 0x20 0713 01 ADD 0714 91 SWAP2 0715 61 PUSH2 0x0742 0718 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @070F memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0714 stack[-1] = stack[-1] // @0714 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0742 label_0719: // Incoming jump from 0x0705, if 0x1f < stack[-1] // Inputs[5] // { // @071A stack[-3] // @071B stack[-1] // @071D stack[-2] // @0723 memory[0x00:0x20] // @0727 storage[keccak256(memory[0x00:0x20])] // } 0719 5B JUMPDEST 071A 82 DUP3 071B 01 ADD 071C 91 SWAP2 071D 90 SWAP1 071E 5F PUSH0 071F 52 MSTORE 0720 60 PUSH1 0x20 0722 5F PUSH0 0723 20 SHA3 0724 90 SWAP1 0725 5B JUMPDEST 0726 81 DUP2 0727 54 SLOAD 0728 81 DUP2 0729 52 MSTORE 072A 90 SWAP1 072B 60 PUSH1 0x01 072D 01 ADD 072E 90 SWAP1 072F 60 PUSH1 0x20 0731 01 ADD 0732 80 DUP1 0733 83 DUP4 0734 11 GT 0735 61 PUSH2 0x0725 0738 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @071C stack[-3] = stack[-3] + stack[-1] // @071F memory[0x00:0x20] = stack[-2] // @0729 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @072E stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0731 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0725, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0739: // Incoming jump from 0x0738, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0738, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0739 stack[-3] // @073A stack[-1] // } 0739 82 DUP3 073A 90 SWAP1 073B 03 SUB 073C 60 PUSH1 0x1f 073E 16 AND 073F 82 DUP3 0740 01 ADD 0741 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0741 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0741 stack[-1] = stack[-3] // } // Block continues label_0742: // Incoming jump from 0x06FD, if !stack[-1] // Incoming jump from 0x0741 // Incoming jump from 0x0718 // Inputs[3] // { // @0748 stack[-7] // @0748 stack[-6] // @074A stack[-8] // } 0742 5B JUMPDEST 0743 50 POP 0744 50 POP 0745 50 POP 0746 50 POP 0747 50 POP 0748 90 SWAP1 0749 50 POP 074A 90 SWAP1 074B 56 *JUMP // Stack delta = -7 // Outputs[1] { @074A stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_074C: // Incoming jump from 0x0265 // Inputs[7] // { // @0751 msg.sender // @0752 stack[-2] // @0756 stack[-1] // @075A msg.sender // @0793 memory[0x00:0x40] // @07CE memory[0x00:0x40] // @07CF storage[keccak256(memory[0x00:0x40])] // } 074C 5B JUMPDEST 074D 5F PUSH0 074E 61 PUSH2 0x07e2 0751 33 CALLER 0752 84 DUP5 0753 61 PUSH2 0x07dd 0756 85 DUP6 0757 60 PUSH1 0x06 0759 5F PUSH0 075A 33 CALLER 075B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0770 16 AND 0771 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0786 16 AND 0787 81 DUP2 0788 52 MSTORE 0789 60 PUSH1 0x20 078B 01 ADD 078C 90 SWAP1 078D 81 DUP2 078E 52 MSTORE 078F 60 PUSH1 0x20 0791 01 ADD 0792 5F PUSH0 0793 20 SHA3 0794 5F PUSH0 0795 89 DUP10 0796 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07AB 16 AND 07AC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07C1 16 AND 07C2 81 DUP2 07C3 52 MSTORE 07C4 60 PUSH1 0x20 07C6 01 ADD 07C7 90 SWAP1 07C8 81 DUP2 07C9 52 MSTORE 07CA 60 PUSH1 0x20 07CC 01 ADD 07CD 5F PUSH0 07CE 20 SHA3 07CF 54 SLOAD 07D0 61 PUSH2 0x0e65 07D3 90 SWAP1 07D4 91 SWAP2 07D5 90 SWAP1 07D6 63 PUSH4 0xffffffff 07DB 16 AND 07DC 56 *JUMP // Stack delta = +7 // Outputs[11] // { // @074D stack[0] = 0x00 // @074E stack[1] = 0x07e2 // @0751 stack[2] = msg.sender // @0752 stack[3] = stack[-2] // @0753 stack[4] = 0x07dd // @0788 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @078E memory[0x20:0x40] = 0x06 // @07C3 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @07C9 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @07D4 stack[5] = storage[keccak256(memory[0x00:0x40])] // @07D5 stack[6] = stack[-1] // } // Block ends with call to 0xffffffff & 0x0e65, returns to 0x07DD label_07DD: // Incoming return from call to 0x0E65 at 0x07DC 07DD 5B JUMPDEST 07DE 61 PUSH2 0x0a3a 07E1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a3a label_07E2: // Incoming return from call to 0x07DD at 0x07DC // Inputs[3] // { // @07E5 stack[-1] // @07E7 stack[-4] // @07E8 stack[-3] // } 07E2 5B JUMPDEST 07E3 60 PUSH1 0x01 07E5 90 SWAP1 07E6 50 POP 07E7 92 SWAP3 07E8 91 SWAP2 07E9 50 POP 07EA 50 POP 07EB 56 *JUMP // Stack delta = -3 // Outputs[1] { @07E7 stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_07EC: // Incoming jump from 0x0295 // Inputs[3] // { // @07F1 msg.sender // @07F2 stack[-2] // @07F3 stack[-1] // } 07EC 5B JUMPDEST 07ED 5F PUSH0 07EE 61 PUSH2 0x07f8 07F1 33 CALLER 07F2 84 DUP5 07F3 84 DUP5 07F4 61 PUSH2 0x0bfd 07F7 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @07ED stack[0] = 0x00 // @07EE stack[1] = 0x07f8 // @07F1 stack[2] = msg.sender // @07F2 stack[3] = stack[-2] // @07F3 stack[4] = stack[-1] // } // Block ends with call to 0x0bfd, returns to 0x07F8 label_07F8: // Incoming return from call to 0x0BFD at 0x07F7 // Inputs[3] // { // @07FB stack[-1] // @07FD stack[-4] // @07FE stack[-3] // } 07F8 5B JUMPDEST 07F9 60 PUSH1 0x01 07FB 90 SWAP1 07FC 50 POP 07FD 92 SWAP3 07FE 91 SWAP2 07FF 50 POP 0800 50 POP 0801 56 *JUMP // Stack delta = -3 // Outputs[1] { @07FD stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_0802: // Incoming jump from 0x02C5 // Inputs[6] // { // @0807 stack[-2] // @0840 memory[0x00:0x40] // @0842 stack[-1] // @087B memory[0x00:0x40] // @087C storage[keccak256(memory[0x00:0x40])] // @087F stack[-3] // } 0802 5B JUMPDEST 0803 5F PUSH0 0804 60 PUSH1 0x06 0806 5F PUSH0 0807 84 DUP5 0808 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 081D 16 AND 081E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0833 16 AND 0834 81 DUP2 0835 52 MSTORE 0836 60 PUSH1 0x20 0838 01 ADD 0839 90 SWAP1 083A 81 DUP2 083B 52 MSTORE 083C 60 PUSH1 0x20 083E 01 ADD 083F 5F PUSH0 0840 20 SHA3 0841 5F PUSH0 0842 83 DUP4 0843 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0858 16 AND 0859 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 086E 16 AND 086F 81 DUP2 0870 52 MSTORE 0871 60 PUSH1 0x20 0873 01 ADD 0874 90 SWAP1 0875 81 DUP2 0876 52 MSTORE 0877 60 PUSH1 0x20 0879 01 ADD 087A 5F PUSH0 087B 20 SHA3 087C 54 SLOAD 087D 90 SWAP1 087E 50 POP 087F 92 SWAP3 0880 91 SWAP2 0881 50 POP 0882 50 POP 0883 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0835 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @083B memory[0x20:0x40] = 0x06 // @0870 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0876 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @087F stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0884: // Incoming jump from 0x02F5 // Inputs[2] // { // @0885 msg.sender // @089E storage[0x00] // } 0884 5B JUMPDEST 0885 33 CALLER 0886 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 089B 16 AND 089C 5F PUSH0 089D 80 DUP1 089E 54 SLOAD 089F 90 SWAP1 08A0 61 PUSH2 0x0100 08A3 0A EXP 08A4 90 SWAP1 08A5 04 DIV 08A6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08BB 16 AND 08BC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08D1 16 AND 08D2 14 EQ 08D3 61 PUSH2 0x0911 08D6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0911, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender label_08D7: // Incoming jump from 0x08D6, if not 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // Inputs[1] { @08D9 memory[0x40:0x60] } 08D7 60 PUSH1 0x40 08D9 51 MLOAD 08DA 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 08FB 81 DUP2 08FC 52 MSTORE 08FD 60 PUSH1 0x04 08FF 01 ADD 0900 61 PUSH2 0x0908 0903 90 SWAP1 0904 61 PUSH2 0x12af 0907 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @08FC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0903 stack[0] = 0x0908 // @0903 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x12af, returns to 0x0908 label_0908: // Incoming return from call to 0x12AF at 0x0907 // Inputs[3] // { // @090B memory[0x40:0x60] // @090D stack[-1] // @0910 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0908 5B JUMPDEST 0909 60 PUSH1 0x40 090B 51 MLOAD 090C 80 DUP1 090D 91 SWAP2 090E 03 SUB 090F 90 SWAP1 0910 FD *REVERT // Stack delta = -1 // Outputs[1] { @0910 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0911: // Incoming jump from 0x08D6, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // Inputs[1] { @0929 stack[-1] } 0911 5B JUMPDEST 0912 5F PUSH0 0913 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0928 16 AND 0929 81 DUP2 092A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 093F 16 AND 0940 03 SUB 0941 61 PUSH2 0x097f 0944 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x097f, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0945: // Incoming jump from 0x0944, if not (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0947 memory[0x40:0x60] } 0945 60 PUSH1 0x40 0947 51 MLOAD 0948 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0969 81 DUP2 096A 52 MSTORE 096B 60 PUSH1 0x04 096D 01 ADD 096E 61 PUSH2 0x0976 0971 90 SWAP1 0972 61 PUSH2 0x133d 0975 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @096A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0971 stack[0] = 0x0976 // @0971 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x133d, returns to 0x0976 label_0976: // Incoming return from call to 0x133D at 0x0975 // Inputs[3] // { // @0979 memory[0x40:0x60] // @097B stack[-1] // @097E memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0976 5B JUMPDEST 0977 60 PUSH1 0x40 0979 51 MLOAD 097A 80 DUP1 097B 91 SWAP2 097C 03 SUB 097D 90 SWAP1 097E FD *REVERT // Stack delta = -1 // Outputs[1] { @097E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_097F: // Incoming jump from 0x0944, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[7] // { // @0980 stack[-1] // @0999 storage[0x00] // @09F0 memory[0x40:0x60] // @09F3 memory[0x40:0x60] // @09F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0A01 storage[0x00] // @0A39 stack[-2] // } 097F 5B JUMPDEST 0980 80 DUP1 0981 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0996 16 AND 0997 5F PUSH0 0998 80 DUP1 0999 54 SLOAD 099A 90 SWAP1 099B 61 PUSH2 0x0100 099E 0A EXP 099F 90 SWAP1 09A0 04 DIV 09A1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09B6 16 AND 09B7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09CC 16 AND 09CD 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 09EE 60 PUSH1 0x40 09F0 51 MLOAD 09F1 60 PUSH1 0x40 09F3 51 MLOAD 09F4 80 DUP1 09F5 91 SWAP2 09F6 03 SUB 09F7 90 SWAP1 09F8 A3 LOG3 09F9 80 DUP1 09FA 5F PUSH0 09FB 80 DUP1 09FC 61 PUSH2 0x0100 09FF 0A EXP 0A00 81 DUP2 0A01 54 SLOAD 0A02 81 DUP2 0A03 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A18 02 MUL 0A19 19 NOT 0A1A 16 AND 0A1B 90 SWAP1 0A1C 83 DUP4 0A1D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A32 16 AND 0A33 02 MUL 0A34 17 OR 0A35 90 SWAP1 0A36 55 SSTORE 0A37 50 POP 0A38 50 POP 0A39 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @09F8 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); // @0A36 storage[0x00] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x00]) // } // Block ends with unconditional jump to stack[-2] label_0A3A: // Incoming jump from 0x07E1 // Incoming jump from 0x0447 // Incoming jump from 0x04FD // Incoming call from 0x0393, returns to 0x0394 // Inputs[1] { @0A52 stack[-3] } 0A3A 5B JUMPDEST 0A3B 5F PUSH0 0A3C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A51 16 AND 0A52 83 DUP4 0A53 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A68 16 AND 0A69 03 SUB 0A6A 61 PUSH2 0x0aa8 0A6D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0aa8, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0A6E: // Incoming jump from 0x0A6D, if not (0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0A70 memory[0x40:0x60] } 0A6E 60 PUSH1 0x40 0A70 51 MLOAD 0A71 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0A92 81 DUP2 0A93 52 MSTORE 0A94 60 PUSH1 0x04 0A96 01 ADD 0A97 61 PUSH2 0x0a9f 0A9A 90 SWAP1 0A9B 61 PUSH2 0x13cb 0A9E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A93 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0A9A stack[0] = 0x0a9f // @0A9A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x13cb, returns to 0x0A9F label_0A9F: // Incoming return from call to 0x13CB at 0x0A9E // Inputs[3] // { // @0AA2 memory[0x40:0x60] // @0AA4 stack[-1] // @0AA7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0A9F 5B JUMPDEST 0AA0 60 PUSH1 0x40 0AA2 51 MLOAD 0AA3 80 DUP1 0AA4 91 SWAP2 0AA5 03 SUB 0AA6 90 SWAP1 0AA7 FD *REVERT // Stack delta = -1 // Outputs[1] { @0AA7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0AA8: // Incoming jump from 0x0A6D, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0AC0 stack[-2] } 0AA8 5B JUMPDEST 0AA9 5F PUSH0 0AAA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0ABF 16 AND 0AC0 82 DUP3 0AC1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AD6 16 AND 0AD7 03 SUB 0AD8 61 PUSH2 0x0b16 0ADB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b16, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0ADC: // Incoming jump from 0x0ADB, if not (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0ADE memory[0x40:0x60] } 0ADC 60 PUSH1 0x40 0ADE 51 MLOAD 0ADF 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0B00 81 DUP2 0B01 52 MSTORE 0B02 60 PUSH1 0x04 0B04 01 ADD 0B05 61 PUSH2 0x0b0d 0B08 90 SWAP1 0B09 61 PUSH2 0x1459 0B0C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B01 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0B08 stack[0] = 0x0b0d // @0B08 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1459, returns to 0x0B0D label_0B0D: // Incoming return from call to 0x1459 at 0x0B0C // Inputs[3] // { // @0B10 memory[0x40:0x60] // @0B12 stack[-1] // @0B15 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0B0D 5B JUMPDEST 0B0E 60 PUSH1 0x40 0B10 51 MLOAD 0B11 80 DUP1 0B12 91 SWAP2 0B13 03 SUB 0B14 90 SWAP1 0B15 FD *REVERT // Stack delta = -1 // Outputs[1] { @0B15 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0B16: // Incoming jump from 0x0ADB, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[6] // { // @0B17 stack[-1] // @0B1B stack[-3] // @0B54 memory[0x00:0x40] // @0B56 stack[-2] // @0B8F memory[0x00:0x40] // @0BE6 memory[0x40:0x60] // } 0B16 5B JUMPDEST 0B17 80 DUP1 0B18 60 PUSH1 0x06 0B1A 5F PUSH0 0B1B 85 DUP6 0B1C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B31 16 AND 0B32 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B47 16 AND 0B48 81 DUP2 0B49 52 MSTORE 0B4A 60 PUSH1 0x20 0B4C 01 ADD 0B4D 90 SWAP1 0B4E 81 DUP2 0B4F 52 MSTORE 0B50 60 PUSH1 0x20 0B52 01 ADD 0B53 5F PUSH0 0B54 20 SHA3 0B55 5F PUSH0 0B56 84 DUP5 0B57 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B6C 16 AND 0B6D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B82 16 AND 0B83 81 DUP2 0B84 52 MSTORE 0B85 60 PUSH1 0x20 0B87 01 ADD 0B88 90 SWAP1 0B89 81 DUP2 0B8A 52 MSTORE 0B8B 60 PUSH1 0x20 0B8D 01 ADD 0B8E 5F PUSH0 0B8F 20 SHA3 0B90 81 DUP2 0B91 90 SWAP1 0B92 55 SSTORE 0B93 50 POP 0B94 81 DUP2 0B95 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BAA 16 AND 0BAB 83 DUP4 0BAC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BC1 16 AND 0BC2 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0BE3 83 DUP4 0BE4 60 PUSH1 0x40 0BE6 51 MLOAD 0BE7 61 PUSH2 0x0bf0 0BEA 91 SWAP2 0BEB 90 SWAP1 0BEC 61 PUSH2 0x10da 0BEF 56 *JUMP // Stack delta = +6 // Outputs[11] // { // @0B49 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0B4F memory[0x20:0x40] = 0x06 // @0B84 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0B8A memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0B92 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0BAA stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0BC1 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0BC2 stack[2] = 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 // @0BEA stack[3] = 0x0bf0 // @0BEB stack[4] = stack[-1] // @0BEB stack[5] = memory[0x40:0x60] // } // Block ends with call to 0x10da, returns to 0x0BF0 label_0BF0: // Incoming return from call to 0x10DA at 0x0BEF // Inputs[7] // { // @0BF3 memory[0x40:0x60] // @0BF5 stack[-1] // @0BF8 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0BF8 stack[-3] // @0BF8 stack[-4] // @0BF8 stack[-2] // @0BFC stack[-8] // } 0BF0 5B JUMPDEST 0BF1 60 PUSH1 0x40 0BF3 51 MLOAD 0BF4 80 DUP1 0BF5 91 SWAP2 0BF6 03 SUB 0BF7 90 SWAP1 0BF8 A3 LOG3 0BF9 50 POP 0BFA 50 POP 0BFB 50 POP 0BFC 56 *JUMP // Stack delta = -8 // Outputs[1] { @0BF8 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); } // Block ends with unconditional jump to stack[-8] label_0BFD: // Incoming call from 0x07F7, returns to 0x07F8 // Incoming call from 0x03B2, returns to 0x03B3 // Inputs[1] { @0C15 stack[-3] } 0BFD 5B JUMPDEST 0BFE 5F PUSH0 0BFF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C14 16 AND 0C15 83 DUP4 0C16 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C2B 16 AND 0C2C 03 SUB 0C2D 61 PUSH2 0x0c6b 0C30 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c6b, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0C31: // Incoming jump from 0x0C30, if not (0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0C33 memory[0x40:0x60] } 0C31 60 PUSH1 0x40 0C33 51 MLOAD 0C34 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0C55 81 DUP2 0C56 52 MSTORE 0C57 60 PUSH1 0x04 0C59 01 ADD 0C5A 61 PUSH2 0x0c62 0C5D 90 SWAP1 0C5E 61 PUSH2 0x14e7 0C61 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C56 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0C5D stack[0] = 0x0c62 // @0C5D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x14e7, returns to 0x0C62 label_0C62: // Incoming return from call to 0x14E7 at 0x0C61 // Inputs[3] // { // @0C65 memory[0x40:0x60] // @0C67 stack[-1] // @0C6A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0C62 5B JUMPDEST 0C63 60 PUSH1 0x40 0C65 51 MLOAD 0C66 80 DUP1 0C67 91 SWAP2 0C68 03 SUB 0C69 90 SWAP1 0C6A FD *REVERT // Stack delta = -1 // Outputs[1] { @0C6A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0C6B: // Incoming jump from 0x0C30, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0C83 stack[-2] } 0C6B 5B JUMPDEST 0C6C 5F PUSH0 0C6D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C82 16 AND 0C83 82 DUP3 0C84 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C99 16 AND 0C9A 03 SUB 0C9B 61 PUSH2 0x0cd9 0C9E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cd9, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0C9F: // Incoming jump from 0x0C9E, if not (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0CA1 memory[0x40:0x60] } 0C9F 60 PUSH1 0x40 0CA1 51 MLOAD 0CA2 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0CC3 81 DUP2 0CC4 52 MSTORE 0CC5 60 PUSH1 0x04 0CC7 01 ADD 0CC8 61 PUSH2 0x0cd0 0CCB 90 SWAP1 0CCC 61 PUSH2 0x1575 0CCF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0CC4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0CCB stack[0] = 0x0cd0 // @0CCB stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1575, returns to 0x0CD0 label_0CD0: // Incoming return from call to 0x1575 at 0x0CCF // Inputs[3] // { // @0CD3 memory[0x40:0x60] // @0CD5 stack[-1] // @0CD8 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0CD0 5B JUMPDEST 0CD1 60 PUSH1 0x40 0CD3 51 MLOAD 0CD4 80 DUP1 0CD5 91 SWAP2 0CD6 03 SUB 0CD7 90 SWAP1 0CD8 FD *REVERT // Stack delta = -1 // Outputs[1] { @0CD8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0CD9: // Incoming jump from 0x0C9E, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) - (0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[4] // { // @0CDD stack[-1] // @0CE1 stack[-3] // @0D1A memory[0x00:0x40] // @0D1B storage[keccak256(memory[0x00:0x40])] // } 0CD9 5B JUMPDEST 0CDA 61 PUSH2 0x0d29 0CDD 81 DUP2 0CDE 60 PUSH1 0x05 0CE0 5F PUSH0 0CE1 86 DUP7 0CE2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CF7 16 AND 0CF8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D0D 16 AND 0D0E 81 DUP2 0D0F 52 MSTORE 0D10 60 PUSH1 0x20 0D12 01 ADD 0D13 90 SWAP1 0D14 81 DUP2 0D15 52 MSTORE 0D16 60 PUSH1 0x20 0D18 01 ADD 0D19 5F PUSH0 0D1A 20 SHA3 0D1B 54 SLOAD 0D1C 61 PUSH2 0x0e65 0D1F 90 SWAP1 0D20 91 SWAP2 0D21 90 SWAP1 0D22 63 PUSH4 0xffffffff 0D27 16 AND 0D28 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0CDA stack[0] = 0x0d29 // @0D0F memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0D15 memory[0x20:0x40] = 0x05 // @0D20 stack[1] = storage[keccak256(memory[0x00:0x40])] // @0D21 stack[2] = stack[-1] // } // Block ends with call to 0xffffffff & 0x0e65, returns to 0x0D29 label_0D29: // Incoming return from call to 0x0E65 at 0x0D28 // Inputs[7] // { // @0D2D stack[-4] // @0D66 memory[0x00:0x40] // @0D67 stack[-1] // @0D6E stack[-2] // @0D72 stack[-3] // @0DAB memory[0x00:0x40] // @0DAC storage[keccak256(memory[0x00:0x40])] // } 0D29 5B JUMPDEST 0D2A 60 PUSH1 0x05 0D2C 5F PUSH0 0D2D 85 DUP6 0D2E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D43 16 AND 0D44 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D59 16 AND 0D5A 81 DUP2 0D5B 52 MSTORE 0D5C 60 PUSH1 0x20 0D5E 01 ADD 0D5F 90 SWAP1 0D60 81 DUP2 0D61 52 MSTORE 0D62 60 PUSH1 0x20 0D64 01 ADD 0D65 5F PUSH0 0D66 20 SHA3 0D67 81 DUP2 0D68 90 SWAP1 0D69 55 SSTORE 0D6A 50 POP 0D6B 61 PUSH2 0x0dba 0D6E 81 DUP2 0D6F 60 PUSH1 0x05 0D71 5F PUSH0 0D72 85 DUP6 0D73 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D88 16 AND 0D89 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D9E 16 AND 0D9F 81 DUP2 0DA0 52 MSTORE 0DA1 60 PUSH1 0x20 0DA3 01 ADD 0DA4 90 SWAP1 0DA5 81 DUP2 0DA6 52 MSTORE 0DA7 60 PUSH1 0x20 0DA9 01 ADD 0DAA 5F PUSH0 0DAB 20 SHA3 0DAC 54 SLOAD 0DAD 61 PUSH2 0x0ec2 0DB0 90 SWAP1 0DB1 91 SWAP2 0DB2 90 SWAP1 0DB3 63 PUSH4 0xffffffff 0DB8 16 AND 0DB9 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @0D5B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0D61 memory[0x20:0x40] = 0x05 // @0D69 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0D6B stack[-1] = 0x0dba // @0DA0 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0DA6 memory[0x20:0x40] = 0x05 // @0DB1 stack[0] = storage[keccak256(memory[0x00:0x40])] // @0DB2 stack[1] = stack[-2] // } // Block ends with call to 0xffffffff & 0x0ec2, returns to 0x0DBA label_0DBA: // Incoming return from call to 0x0EC2 at 0x0DB9 // Inputs[6] // { // @0DBE stack[-3] // @0DF7 memory[0x00:0x40] // @0DF8 stack[-1] // @0E13 stack[-4] // @0E4B stack[-2] // @0E4E memory[0x40:0x60] // } 0DBA 5B JUMPDEST 0DBB 60 PUSH1 0x05 0DBD 5F PUSH0 0DBE 84 DUP5 0DBF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DD4 16 AND 0DD5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DEA 16 AND 0DEB 81 DUP2 0DEC 52 MSTORE 0DED 60 PUSH1 0x20 0DEF 01 ADD 0DF0 90 SWAP1 0DF1 81 DUP2 0DF2 52 MSTORE 0DF3 60 PUSH1 0x20 0DF5 01 ADD 0DF6 5F PUSH0 0DF7 20 SHA3 0DF8 81 DUP2 0DF9 90 SWAP1 0DFA 55 SSTORE 0DFB 50 POP 0DFC 81 DUP2 0DFD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E12 16 AND 0E13 83 DUP4 0E14 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E29 16 AND 0E2A 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0E4B 83 DUP4 0E4C 60 PUSH1 0x40 0E4E 51 MLOAD 0E4F 61 PUSH2 0x0e58 0E52 91 SWAP2 0E53 90 SWAP1 0E54 61 PUSH2 0x10da 0E57 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0DEC memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0DF2 memory[0x20:0x40] = 0x05 // @0DFA storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0E12 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0E29 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0E2A stack[1] = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef // @0E52 stack[2] = 0x0e58 // @0E53 stack[3] = stack[-2] // @0E53 stack[4] = memory[0x40:0x60] // } // Block ends with call to 0x10da, returns to 0x0E58 label_0E58: // Incoming return from call to 0x10DA at 0x0E57 // Inputs[7] // { // @0E5B memory[0x40:0x60] // @0E5D stack[-1] // @0E60 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0E60 stack[-4] // @0E60 stack[-3] // @0E60 stack[-2] // @0E64 stack[-8] // } 0E58 5B JUMPDEST 0E59 60 PUSH1 0x40 0E5B 51 MLOAD 0E5C 80 DUP1 0E5D 91 SWAP2 0E5E 03 SUB 0E5F 90 SWAP1 0E60 A3 LOG3 0E61 50 POP 0E62 50 POP 0E63 50 POP 0E64 56 *JUMP // Stack delta = -8 // Outputs[1] { @0E60 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); } // Block ends with unconditional jump to stack[-8] label_0E65: // Incoming call from 0x0442, returns to 0x0443 // Incoming call from 0x0D28, returns to 0x0D29 // Incoming call from 0x07DC, returns to 0x07DD // Inputs[2] // { // @0E67 stack[-2] // @0E68 stack[-1] // } 0E65 5B JUMPDEST 0E66 5F PUSH0 0E67 82 DUP3 0E68 82 DUP3 0E69 11 GT 0E6A 15 ISZERO 0E6B 61 PUSH2 0x0ea9 0E6E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E66 stack[0] = 0x00 } // Block ends with conditional jump to 0x0ea9, if !(stack[-1] > stack[-2]) label_0E6F: // Incoming jump from 0x0E6E, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0E71 memory[0x40:0x60] } 0E6F 60 PUSH1 0x40 0E71 51 MLOAD 0E72 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0E93 81 DUP2 0E94 52 MSTORE 0E95 60 PUSH1 0x04 0E97 01 ADD 0E98 61 PUSH2 0x0ea0 0E9B 90 SWAP1 0E9C 61 PUSH2 0x15dd 0E9F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E94 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0E9B stack[0] = 0x0ea0 // @0E9B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x15dd, returns to 0x0EA0 label_0EA0: // Incoming return from call to 0x15DD at 0x0E9F // Inputs[3] // { // @0EA3 memory[0x40:0x60] // @0EA5 stack[-1] // @0EA8 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0EA0 5B JUMPDEST 0EA1 60 PUSH1 0x40 0EA3 51 MLOAD 0EA4 80 DUP1 0EA5 91 SWAP2 0EA6 03 SUB 0EA7 90 SWAP1 0EA8 FD *REVERT // Stack delta = -1 // Outputs[1] { @0EA8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0EA9: // Incoming jump from 0x0E6E, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @0EAB stack[-2] // @0EAC stack[-3] // } 0EA9 5B JUMPDEST 0EAA 5F PUSH0 0EAB 82 DUP3 0EAC 84 DUP5 0EAD 61 PUSH2 0x0eb6 0EB0 91 SWAP2 0EB1 90 SWAP1 0EB2 61 PUSH2 0x1628 0EB5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EAA stack[0] = 0x00 // @0EB0 stack[1] = 0x0eb6 // @0EB1 stack[2] = stack[-2] // @0EB1 stack[3] = stack[-3] // } // Block ends with call to 0x1628, returns to 0x0EB6 label_0EB6: // Incoming return from call to 0x1628 at 0x0EB5 // Inputs[5] // { // @0EB7 stack[-1] // @0EB7 stack[-2] // @0EBA stack[-3] // @0EBD stack[-6] // @0EBE stack[-5] // } 0EB6 5B JUMPDEST 0EB7 90 SWAP1 0EB8 50 POP 0EB9 80 DUP1 0EBA 91 SWAP2 0EBB 50 POP 0EBC 50 POP 0EBD 92 SWAP3 0EBE 91 SWAP2 0EBF 50 POP 0EC0 50 POP 0EC1 56 *JUMP // Stack delta = -5 // Outputs[1] { @0EBD stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0EC2: // Incoming call from 0x0DB9, returns to 0x0DBA // Incoming call from 0x04F8, returns to 0x04F9 // Inputs[2] // { // @0EC5 stack[-1] // @0EC6 stack[-2] // } 0EC2 5B JUMPDEST 0EC3 5F PUSH0 0EC4 80 DUP1 0EC5 82 DUP3 0EC6 84 DUP5 0EC7 61 PUSH2 0x0ed0 0ECA 91 SWAP2 0ECB 90 SWAP1 0ECC 61 PUSH2 0x165b 0ECF 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0EC3 stack[0] = 0x00 // @0EC4 stack[1] = 0x00 // @0ECA stack[2] = 0x0ed0 // @0ECB stack[3] = stack[-1] // @0ECB stack[4] = stack[-2] // } // Block ends with call to 0x165b, returns to 0x0ED0 label_0ED0: // Incoming return from call to 0x165B at 0x0ECF // Inputs[3] // { // @0ED1 stack[-2] // @0ED1 stack[-1] // @0ED3 stack[-5] // } 0ED0 5B JUMPDEST 0ED1 90 SWAP1 0ED2 50 POP 0ED3 83 DUP4 0ED4 81 DUP2 0ED5 10 LT 0ED6 15 ISZERO 0ED7 61 PUSH2 0x0f15 0EDA 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0ED1 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0f15, if !(stack[-1] < stack[-5]) label_0EDB: // Incoming jump from 0x0EDA, if not !(stack[-1] < stack[-5]) // Inputs[1] { @0EDD memory[0x40:0x60] } 0EDB 60 PUSH1 0x40 0EDD 51 MLOAD 0EDE 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0EFF 81 DUP2 0F00 52 MSTORE 0F01 60 PUSH1 0x04 0F03 01 ADD 0F04 61 PUSH2 0x0f0c 0F07 90 SWAP1 0F08 61 PUSH2 0x16d8 0F0B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0F00 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0F07 stack[0] = 0x0f0c // @0F07 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x16d8, returns to 0x0F0C label_0F0C: // Incoming return from call to 0x16D8 at 0x0F0B // Inputs[3] // { // @0F0F memory[0x40:0x60] // @0F11 stack[-1] // @0F14 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0F0C 5B JUMPDEST 0F0D 60 PUSH1 0x40 0F0F 51 MLOAD 0F10 80 DUP1 0F11 91 SWAP2 0F12 03 SUB 0F13 90 SWAP1 0F14 FD *REVERT // Stack delta = -1 // Outputs[1] { @0F14 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0F15: // Incoming jump from 0x0EDA, if !(stack[-1] < stack[-5]) // Inputs[4] // { // @0F16 stack[-1] // @0F17 stack[-2] // @0F1A stack[-5] // @0F1B stack[-4] // } 0F15 5B JUMPDEST 0F16 80 DUP1 0F17 91 SWAP2 0F18 50 POP 0F19 50 POP 0F1A 92 SWAP3 0F1B 91 SWAP2 0F1C 50 POP 0F1D 50 POP 0F1E 56 *JUMP // Stack delta = -4 // Outputs[1] { @0F1A stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0F1F: // Incoming call from 0x0F7A, returns to 0x0F7B // Inputs[3] // { // @0F21 stack[-1] // @0F22 memory[stack[-1]:stack[-1] + 0x20] // @0F25 stack[-2] // } 0F1F 5B JUMPDEST 0F20 5F PUSH0 0F21 81 DUP2 0F22 51 MLOAD 0F23 90 SWAP1 0F24 50 POP 0F25 91 SWAP2 0F26 90 SWAP1 0F27 50 POP 0F28 56 *JUMP // Stack delta = -1 // Outputs[1] { @0F25 stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_0F29: // Incoming call from 0x1442, returns to 0x1443 // Incoming call from 0x15C6, returns to 0x15C7 // Incoming call from 0x155E, returns to 0x155F // Incoming call from 0x14D0, returns to 0x14D1 // Incoming call from 0x1326, returns to 0x1327 // Incoming call from 0x0F84, returns to 0x0F85 // Incoming call from 0x16C1, returns to 0x16C2 // Incoming call from 0x13B4, returns to 0x13B5 // Incoming call from 0x1298, returns to 0x1299 // Inputs[3] // { // @0F2B stack[-2] // @0F2C stack[-1] // @0F34 stack[-3] // } 0F29 5B JUMPDEST 0F2A 5F PUSH0 0F2B 82 DUP3 0F2C 82 DUP3 0F2D 52 MSTORE 0F2E 60 PUSH1 0x20 0F30 82 DUP3 0F31 01 ADD 0F32 90 SWAP1 0F33 50 POP 0F34 92 SWAP3 0F35 91 SWAP2 0F36 50 POP 0F37 50 POP 0F38 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @0F2D memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @0F34 stack[-3] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-3] label_0F39: // Incoming call from 0x0F94, returns to 0x0F95 // Inputs[1] { @0F3C stack[-3] } 0F39 5B JUMPDEST 0F3A 5F PUSH0 0F3B 5B JUMPDEST 0F3C 83 DUP4 0F3D 81 DUP2 0F3E 10 LT 0F3F 15 ISZERO 0F40 61 PUSH2 0x0f56 0F43 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0F3A stack[0] = 0x00 } // Block ends with conditional jump to 0x0f56, if !(0x00 < stack[-3]) label_0F44: // Incoming jump from 0x0F43, if not !(0x00 < stack[-3]) // Incoming jump from 0x0F43, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0F44 stack[-1] // @0F45 stack[-2] // @0F47 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0F49 stack[-3] // } 0F44 80 DUP1 0F45 82 DUP3 0F46 01 ADD 0F47 51 MLOAD 0F48 81 DUP2 0F49 84 DUP5 0F4A 01 ADD 0F4B 52 MSTORE 0F4C 60 PUSH1 0x20 0F4E 81 DUP2 0F4F 01 ADD 0F50 90 SWAP1 0F51 50 POP 0F52 61 PUSH2 0x0f3b 0F55 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0F4B memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0F50 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0f3b label_0F56: // Incoming jump from 0x0F43, if !(0x00 < stack[-3]) // Incoming jump from 0x0F43, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0F58 stack[-4] // @0F59 stack[-3] // @0F60 stack[-5] // } 0F56 5B JUMPDEST 0F57 5F PUSH0 0F58 84 DUP5 0F59 84 DUP5 0F5A 01 ADD 0F5B 52 MSTORE 0F5C 50 POP 0F5D 50 POP 0F5E 50 POP 0F5F 50 POP 0F60 56 *JUMP // Stack delta = -5 // Outputs[1] { @0F5B memory[stack[-3] + stack[-4]:stack[-3] + stack[-4] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_0F61: // Incoming call from 0x0F9D, returns to 0x0F9E // Inputs[2] // { // @0F68 stack[-1] // @0F6D stack[-2] // } 0F61 5B JUMPDEST 0F62 5F PUSH0 0F63 60 PUSH1 0x1f 0F65 19 NOT 0F66 60 PUSH1 0x1f 0F68 83 DUP4 0F69 01 ADD 0F6A 16 AND 0F6B 90 SWAP1 0F6C 50 POP 0F6D 91 SWAP2 0F6E 90 SWAP1 0F6F 50 POP 0F70 56 *JUMP // Stack delta = -1 // Outputs[1] { @0F6D stack[-2] = stack[-1] + 0x1f & ~0x1f } // Block ends with unconditional jump to stack[-2] label_0F71: // Incoming call from 0x0FC0, returns to 0x0FC1 // Inputs[1] { @0F76 stack[-1] } 0F71 5B JUMPDEST 0F72 5F PUSH0 0F73 61 PUSH2 0x0f7b 0F76 82 DUP3 0F77 61 PUSH2 0x0f1f 0F7A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F72 stack[0] = 0x00 // @0F73 stack[1] = 0x0f7b // @0F76 stack[2] = stack[-1] // } // Block ends with call to 0x0f1f, returns to 0x0F7B label_0F7B: // Incoming return from call to 0x0F1F at 0x0F7A // Inputs[2] // { // @0F7F stack[-1] // @0F80 stack[-4] // } 0F7B 5B JUMPDEST 0F7C 61 PUSH2 0x0f85 0F7F 81 DUP2 0F80 85 DUP6 0F81 61 PUSH2 0x0f29 0F84 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F7C stack[0] = 0x0f85 // @0F7F stack[1] = stack[-1] // @0F80 stack[2] = stack[-4] // } // Block ends with call to 0x0f29, returns to 0x0F85 label_0F85: // Incoming return from call to 0x0F29 at 0x0F84 // Inputs[4] // { // @0F86 stack[-5] // @0F86 stack[-1] // @0F8B stack[-2] // @0F8F stack[-4] // } 0F85 5B JUMPDEST 0F86 93 SWAP4 0F87 50 POP 0F88 61 PUSH2 0x0f95 0F8B 81 DUP2 0F8C 85 DUP6 0F8D 60 PUSH1 0x20 0F8F 86 DUP7 0F90 01 ADD 0F91 61 PUSH2 0x0f39 0F94 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0F86 stack[-5] = stack[-1] // @0F88 stack[-1] = 0x0f95 // @0F8B stack[0] = stack[-2] // @0F8C stack[1] = stack[-1] // @0F90 stack[2] = stack[-4] + 0x20 // } // Block ends with call to 0x0f39, returns to 0x0F95 label_0F95: // Incoming return from call to 0x0F39 at 0x0F94 // Inputs[1] { @0F99 stack[-1] } 0F95 5B JUMPDEST 0F96 61 PUSH2 0x0f9e 0F99 81 DUP2 0F9A 61 PUSH2 0x0f61 0F9D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0F96 stack[0] = 0x0f9e // @0F99 stack[1] = stack[-1] // } // Block ends with call to 0x0f61, returns to 0x0F9E label_0F9E: // Incoming return from call to 0x0F61 at 0x0F9D // Inputs[4] // { // @0F9F stack[-5] // @0FA0 stack[-1] // @0FA1 stack[-3] // @0FA4 stack[-6] // } 0F9E 5B JUMPDEST 0F9F 84 DUP5 0FA0 01 ADD 0FA1 91 SWAP2 0FA2 50 POP 0FA3 50 POP 0FA4 92 SWAP3 0FA5 91 SWAP2 0FA6 50 POP 0FA7 50 POP 0FA8 56 *JUMP // Stack delta = -5 // Outputs[1] { @0FA4 stack[-6] = stack[-5] + stack[-1] } // Block ends with unconditional jump to stack[-6] label_0FA9: // Incoming call from 0x0242, returns to 0x0243 // Incoming call from 0x0100, returns to 0x0101 // Inputs[2] // { // @0FAD stack[-1] // @0FBC stack[-2] // } 0FA9 5B JUMPDEST 0FAA 5F PUSH0 0FAB 60 PUSH1 0x20 0FAD 82 DUP3 0FAE 01 ADD 0FAF 90 SWAP1 0FB0 50 POP 0FB1 81 DUP2 0FB2 81 DUP2 0FB3 03 SUB 0FB4 5F PUSH0 0FB5 83 DUP4 0FB6 01 ADD 0FB7 52 MSTORE 0FB8 61 PUSH2 0x0fc1 0FBB 81 DUP2 0FBC 84 DUP5 0FBD 61 PUSH2 0x0f71 0FC0 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0FAF stack[0] = stack[-1] + 0x20 // @0FB7 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @0FB8 stack[1] = 0x0fc1 // @0FBB stack[2] = stack[-1] + 0x20 // @0FBC stack[3] = stack[-2] // } // Block ends with call to 0x0f71, returns to 0x0FC1 label_0FC1: // Incoming return from call to 0x0F71 at 0x0FC0 // Inputs[4] // { // @0FC2 stack[-2] // @0FC2 stack[-1] // @0FC4 stack[-5] // @0FC5 stack[-4] // } 0FC1 5B JUMPDEST 0FC2 90 SWAP1 0FC3 50 POP 0FC4 92 SWAP3 0FC5 91 SWAP2 0FC6 50 POP 0FC7 50 POP 0FC8 56 *JUMP // Stack delta = -4 // Outputs[1] { @0FC4 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0FC9: // Incoming jump from 0x1108 // Incoming jump from 0x118A // Incoming jump from 0x106E // Incoming jump from 0x11DE // Inputs[1] { @0FCC memory[0x00:0x00] } 0FC9 5B JUMPDEST 0FCA 5F PUSH0 0FCB 80 DUP1 0FCC FD *REVERT // Stack delta = +0 // Outputs[1] { @0FCC revert(memory[0x00:0x00]); } // Block terminates label_0FCD: // Incoming call from 0x0FF5, returns to 0x0FF6 // Inputs[2] // { // @0FE4 stack[-1] // @0FE8 stack[-2] // } 0FCD 5B JUMPDEST 0FCE 5F PUSH0 0FCF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FE4 82 DUP3 0FE5 16 AND 0FE6 90 SWAP1 0FE7 50 POP 0FE8 91 SWAP2 0FE9 90 SWAP1 0FEA 50 POP 0FEB 56 *JUMP // Stack delta = -1 // Outputs[1] { @0FE8 stack[-2] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff } // Block ends with unconditional jump to stack[-2] label_0FEC: // Incoming call from 0x1005, returns to 0x1006 // Incoming call from 0x11AA, returns to 0x11AB // Inputs[1] { @0FF1 stack[-1] } 0FEC 5B JUMPDEST 0FED 5F PUSH0 0FEE 61 PUSH2 0x0ff6 0FF1 82 DUP3 0FF2 61 PUSH2 0x0fcd 0FF5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FED stack[0] = 0x00 // @0FEE stack[1] = 0x0ff6 // @0FF1 stack[2] = stack[-1] // } // Block ends with call to 0x0fcd, returns to 0x0FF6 label_0FF6: // Incoming return from call to 0x0FCD at 0x0FF5 // Inputs[4] // { // @0FF7 stack[-1] // @0FF7 stack[-2] // @0FF9 stack[-4] // @0FFA stack[-3] // } 0FF6 5B JUMPDEST 0FF7 90 SWAP1 0FF8 50 POP 0FF9 91 SWAP2 0FFA 90 SWAP1 0FFB 50 POP 0FFC 56 *JUMP // Stack delta = -3 // Outputs[1] { @0FF9 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0FFD: // Incoming call from 0x1020, returns to 0x1021 // Inputs[1] { @1001 stack[-1] } 0FFD 5B JUMPDEST 0FFE 61 PUSH2 0x1006 1001 81 DUP2 1002 61 PUSH2 0x0fec 1005 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0FFE stack[0] = 0x1006 // @1001 stack[1] = stack[-1] // } // Block ends with call to 0x0fec, returns to 0x1006 label_1006: // Incoming return from call to 0x0FEC at 0x1005 // Inputs[2] // { // @1007 stack[-2] // @1008 stack[-1] // } 1006 5B JUMPDEST 1007 81 DUP2 1008 14 EQ 1009 61 PUSH2 0x1010 100C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1010, if stack[-2] == stack[-1] label_100D: // Incoming jump from 0x100C, if not stack[-2] == stack[-1] // Inputs[1] { @100F memory[0x00:0x00] } 100D 5F PUSH0 100E 80 DUP1 100F FD *REVERT // Stack delta = +0 // Outputs[1] { @100F revert(memory[0x00:0x00]); } // Block terminates label_1010: // Incoming jump from 0x100C, if stack[-2] == stack[-1] // Inputs[1] { @1012 stack[-2] } 1010 5B JUMPDEST 1011 50 POP 1012 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1013: // Incoming call from 0x11FD, returns to 0x11FE // Incoming call from 0x1198, returns to 0x1199 // Incoming call from 0x1127, returns to 0x1128 // Incoming call from 0x1116, returns to 0x1117 // Incoming call from 0x107C, returns to 0x107D // Incoming call from 0x11EC, returns to 0x11ED // Inputs[2] // { // @1015 stack[-1] // @1016 msg.data[stack[-1]:stack[-1] + 0x20] // } 1013 5B JUMPDEST 1014 5F PUSH0 1015 81 DUP2 1016 35 CALLDATALOAD 1017 90 SWAP1 1018 50 POP 1019 61 PUSH2 0x1021 101C 81 DUP2 101D 61 PUSH2 0x0ffd 1020 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1017 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @1019 stack[1] = 0x1021 // @101C stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x0ffd, returns to 0x1021 label_1021: // Incoming return from call to 0x0FFD at 0x1020 // Inputs[3] // { // @1022 stack[-4] // @1022 stack[-1] // @1023 stack[-3] // } 1021 5B JUMPDEST 1022 92 SWAP3 1023 91 SWAP2 1024 50 POP 1025 50 POP 1026 56 *JUMP // Stack delta = -3 // Outputs[1] { @1022 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1027: // Incoming call from 0x1664, returns to 0x1665 // Incoming call from 0x166F, returns to 0x1670 // Incoming call from 0x1038, returns to 0x1039 // Incoming call from 0x1631, returns to 0x1632 // Incoming call from 0x10D3, returns to 0x10D4 // Incoming call from 0x163C, returns to 0x163D // Inputs[2] // { // @1029 stack[-1] // @102C stack[-2] // } 1027 5B JUMPDEST 1028 5F PUSH0 1029 81 DUP2 102A 90 SWAP1 102B 50 POP 102C 91 SWAP2 102D 90 SWAP1 102E 50 POP 102F 56 *JUMP // Stack delta = -1 // Outputs[1] { @102C stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_1030: // Incoming call from 0x1053, returns to 0x1054 // Inputs[1] { @1034 stack[-1] } 1030 5B JUMPDEST 1031 61 PUSH2 0x1039 1034 81 DUP2 1035 61 PUSH2 0x1027 1038 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1031 stack[0] = 0x1039 // @1034 stack[1] = stack[-1] // } // Block ends with call to 0x1027, returns to 0x1039 label_1039: // Incoming return from call to 0x1027 at 0x1038 // Inputs[2] // { // @103A stack[-2] // @103B stack[-1] // } 1039 5B JUMPDEST 103A 81 DUP2 103B 14 EQ 103C 61 PUSH2 0x1043 103F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1043, if stack[-2] == stack[-1] label_1040: // Incoming jump from 0x103F, if not stack[-2] == stack[-1] // Inputs[1] { @1042 memory[0x00:0x00] } 1040 5F PUSH0 1041 80 DUP1 1042 FD *REVERT // Stack delta = +0 // Outputs[1] { @1042 revert(memory[0x00:0x00]); } // Block terminates label_1043: // Incoming jump from 0x103F, if stack[-2] == stack[-1] // Inputs[1] { @1045 stack[-2] } 1043 5B JUMPDEST 1044 50 POP 1045 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1046: // Incoming call from 0x108D, returns to 0x108E // Incoming call from 0x1138, returns to 0x1139 // Inputs[2] // { // @1048 stack[-1] // @1049 msg.data[stack[-1]:stack[-1] + 0x20] // } 1046 5B JUMPDEST 1047 5F PUSH0 1048 81 DUP2 1049 35 CALLDATALOAD 104A 90 SWAP1 104B 50 POP 104C 61 PUSH2 0x1054 104F 81 DUP2 1050 61 PUSH2 0x1030 1053 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @104A stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @104C stack[1] = 0x1054 // @104F stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x1030, returns to 0x1054 label_1054: // Incoming return from call to 0x1030 at 0x1053 // Inputs[3] // { // @1055 stack[-4] // @1055 stack[-1] // @1056 stack[-3] // } 1054 5B JUMPDEST 1055 92 SWAP3 1056 91 SWAP2 1057 50 POP 1058 50 POP 1059 56 *JUMP // Stack delta = -3 // Outputs[1] { @1055 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_105A: // Incoming call from 0x011E, returns to 0x011F // Incoming call from 0x0260, returns to 0x0261 // Incoming call from 0x01BA, returns to 0x01BB // Incoming call from 0x0290, returns to 0x0291 // Inputs[2] // { // @105F stack[-1] // @1060 stack[-2] // } 105A 5B JUMPDEST 105B 5F PUSH0 105C 80 DUP1 105D 60 PUSH1 0x40 105F 83 DUP4 1060 85 DUP6 1061 03 SUB 1062 12 SLT 1063 15 ISZERO 1064 61 PUSH2 0x1070 1067 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @105B stack[0] = 0x00 // @105C stack[1] = 0x00 // } // Block ends with conditional jump to 0x1070, if !(stack[-2] - stack[-1] i< 0x40) label_1068: // Incoming jump from 0x1067, if not !(stack[-2] - stack[-1] i< 0x40) 1068 61 PUSH2 0x106f 106B 61 PUSH2 0x0fc9 106E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1068 stack[0] = 0x106f } // Block ends with unconditional jump to 0x0fc9 106F 5B JUMPDEST label_1070: // Incoming jump from 0x1067, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1075 stack[-4] // @1077 stack[-3] // } 1070 5B JUMPDEST 1071 5F PUSH0 1072 61 PUSH2 0x107d 1075 85 DUP6 1076 82 DUP3 1077 86 DUP7 1078 01 ADD 1079 61 PUSH2 0x1013 107C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1071 stack[0] = 0x00 // @1072 stack[1] = 0x107d // @1075 stack[2] = stack[-4] // @1078 stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x1013, returns to 0x107D label_107D: // Incoming return from call to 0x1013 at 0x107C // Inputs[4] // { // @107E stack[-1] // @107E stack[-4] // @1086 stack[-6] // @1088 stack[-5] // } 107D 5B JUMPDEST 107E 92 SWAP3 107F 50 POP 1080 50 POP 1081 60 PUSH1 0x20 1083 61 PUSH2 0x108e 1086 85 DUP6 1087 82 DUP3 1088 86 DUP7 1089 01 ADD 108A 61 PUSH2 0x1046 108D 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @107E stack[-4] = stack[-1] // @1081 stack[-2] = 0x20 // @1083 stack[-1] = 0x108e // @1086 stack[0] = stack[-6] // @1089 stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x1046, returns to 0x108E label_108E: // Incoming return from call to 0x1046 at 0x108D // Inputs[6] // { // @108F stack[-3] // @108F stack[-1] // @1092 stack[-6] // @1094 stack[-4] // @1094 stack[-7] // @1095 stack[-5] // } 108E 5B JUMPDEST 108F 91 SWAP2 1090 50 POP 1091 50 POP 1092 92 SWAP3 1093 50 POP 1094 92 SWAP3 1095 90 SWAP1 1096 50 POP 1097 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1092 stack[-6] = stack[-1] // @1094 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1098: // Incoming call from 0x10AB, returns to 0x10AC // Inputs[2] // { // @109A stack[-1] // @109F stack[-2] // } 1098 5B JUMPDEST 1099 5F PUSH0 109A 81 DUP2 109B 15 ISZERO 109C 15 ISZERO 109D 90 SWAP1 109E 50 POP 109F 91 SWAP2 10A0 90 SWAP1 10A1 50 POP 10A2 56 *JUMP // Stack delta = -1 // Outputs[1] { @109F stack[-2] = !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_10A3: // Incoming call from 0x10C4, returns to 0x10C5 // Inputs[1] { @10A7 stack[-1] } 10A3 5B JUMPDEST 10A4 61 PUSH2 0x10ac 10A7 81 DUP2 10A8 61 PUSH2 0x1098 10AB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @10A4 stack[0] = 0x10ac // @10A7 stack[1] = stack[-1] // } // Block ends with call to 0x1098, returns to 0x10AC label_10AC: // Incoming return from call to 0x1098 at 0x10AB // Inputs[3] // { // @10AD stack[-3] // @10AE stack[-1] // @10B1 stack[-4] // } 10AC 5B JUMPDEST 10AD 82 DUP3 10AE 52 MSTORE 10AF 50 POP 10B0 50 POP 10B1 56 *JUMP // Stack delta = -4 // Outputs[1] { @10AE memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_10B2: // Incoming call from 0x01CC, returns to 0x01CD // Incoming call from 0x0130, returns to 0x0131 // Incoming call from 0x02A2, returns to 0x02A3 // Incoming call from 0x017E, returns to 0x017F // Incoming call from 0x0272, returns to 0x0273 // Inputs[2] // { // @10B6 stack[-1] // @10C0 stack[-2] // } 10B2 5B JUMPDEST 10B3 5F PUSH0 10B4 60 PUSH1 0x20 10B6 82 DUP3 10B7 01 ADD 10B8 90 SWAP1 10B9 50 POP 10BA 61 PUSH2 0x10c5 10BD 5F PUSH0 10BE 83 DUP4 10BF 01 ADD 10C0 84 DUP5 10C1 61 PUSH2 0x10a3 10C4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @10B8 stack[0] = stack[-1] + 0x20 // @10BA stack[1] = 0x10c5 // @10BF stack[2] = stack[-1] + 0x00 // @10C0 stack[3] = stack[-2] // } // Block ends with call to 0x10a3, returns to 0x10C5 label_10C5: // Incoming return from call to 0x10A3 at 0x10C4 // Inputs[3] // { // @10C6 stack[-1] // @10C6 stack[-4] // @10C7 stack[-3] // } 10C5 5B JUMPDEST 10C6 92 SWAP3 10C7 91 SWAP2 10C8 50 POP 10C9 50 POP 10CA 56 *JUMP // Stack delta = -3 // Outputs[1] { @10C6 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_10CB: // Incoming call from 0x10EC, returns to 0x10ED // Inputs[1] { @10CF stack[-1] } 10CB 5B JUMPDEST 10CC 61 PUSH2 0x10d4 10CF 81 DUP2 10D0 61 PUSH2 0x1027 10D3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @10CC stack[0] = 0x10d4 // @10CF stack[1] = stack[-1] // } // Block ends with call to 0x1027, returns to 0x10D4 label_10D4: // Incoming return from call to 0x1027 at 0x10D3 // Inputs[3] // { // @10D5 stack[-3] // @10D6 stack[-1] // @10D9 stack[-4] // } 10D4 5B JUMPDEST 10D5 82 DUP3 10D6 52 MSTORE 10D7 50 POP 10D8 50 POP 10D9 56 *JUMP // Stack delta = -4 // Outputs[1] { @10D6 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_10DA: // Incoming call from 0x014E, returns to 0x014F // Incoming call from 0x0E57, returns to 0x0E58 // Incoming call from 0x01FC, returns to 0x01FD // Incoming call from 0x02D2, returns to 0x02D3 // Incoming call from 0x0BEF, returns to 0x0BF0 // Inputs[2] // { // @10DE stack[-1] // @10E8 stack[-2] // } 10DA 5B JUMPDEST 10DB 5F PUSH0 10DC 60 PUSH1 0x20 10DE 82 DUP3 10DF 01 ADD 10E0 90 SWAP1 10E1 50 POP 10E2 61 PUSH2 0x10ed 10E5 5F PUSH0 10E6 83 DUP4 10E7 01 ADD 10E8 84 DUP5 10E9 61 PUSH2 0x10cb 10EC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @10E0 stack[0] = stack[-1] + 0x20 // @10E2 stack[1] = 0x10ed // @10E7 stack[2] = stack[-1] + 0x00 // @10E8 stack[3] = stack[-2] // } // Block ends with call to 0x10cb, returns to 0x10ED label_10ED: // Incoming return from call to 0x10CB at 0x10EC // Inputs[3] // { // @10EE stack[-4] // @10EE stack[-1] // @10EF stack[-3] // } 10ED 5B JUMPDEST 10EE 92 SWAP3 10EF 91 SWAP2 10F0 50 POP 10F1 50 POP 10F2 56 *JUMP // Stack delta = -3 // Outputs[1] { @10EE stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_10F3: // Incoming call from 0x016C, returns to 0x016D // Inputs[2] // { // @10F9 stack[-1] // @10FA stack[-2] // } 10F3 5B JUMPDEST 10F4 5F PUSH0 10F5 80 DUP1 10F6 5F PUSH0 10F7 60 PUSH1 0x60 10F9 84 DUP5 10FA 86 DUP7 10FB 03 SUB 10FC 12 SLT 10FD 15 ISZERO 10FE 61 PUSH2 0x110a 1101 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @10F4 stack[0] = 0x00 // @10F5 stack[1] = 0x00 // @10F6 stack[2] = 0x00 // } // Block ends with conditional jump to 0x110a, if !(stack[-2] - stack[-1] i< 0x60) label_1102: // Incoming jump from 0x1101, if not !(stack[-2] - stack[-1] i< 0x60) 1102 61 PUSH2 0x1109 1105 61 PUSH2 0x0fc9 1108 56 *JUMP // Stack delta = +1 // Outputs[1] { @1102 stack[0] = 0x1109 } // Block ends with unconditional jump to 0x0fc9 1109 5B JUMPDEST label_110A: // Incoming jump from 0x1101, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @110F stack[-5] // @1111 stack[-4] // } 110A 5B JUMPDEST 110B 5F PUSH0 110C 61 PUSH2 0x1117 110F 86 DUP7 1110 82 DUP3 1111 87 DUP8 1112 01 ADD 1113 61 PUSH2 0x1013 1116 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @110B stack[0] = 0x00 // @110C stack[1] = 0x1117 // @110F stack[2] = stack[-5] // @1112 stack[3] = stack[-4] + 0x00 // } // Block ends with call to 0x1013, returns to 0x1117 label_1117: // Incoming return from call to 0x1013 at 0x1116 // Inputs[4] // { // @1118 stack[-5] // @1118 stack[-1] // @1120 stack[-7] // @1122 stack[-6] // } 1117 5B JUMPDEST 1118 93 SWAP4 1119 50 POP 111A 50 POP 111B 60 PUSH1 0x20 111D 61 PUSH2 0x1128 1120 86 DUP7 1121 82 DUP3 1122 87 DUP8 1123 01 ADD 1124 61 PUSH2 0x1013 1127 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1118 stack[-5] = stack[-1] // @111B stack[-2] = 0x20 // @111D stack[-1] = 0x1128 // @1120 stack[0] = stack[-7] // @1123 stack[1] = stack[-6] + 0x20 // } // Block ends with call to 0x1013, returns to 0x1128 label_1128: // Incoming return from call to 0x1013 at 0x1127 // Inputs[4] // { // @1129 stack[-1] // @1129 stack[-4] // @1131 stack[-7] // @1133 stack[-6] // } 1128 5B JUMPDEST 1129 92 SWAP3 112A 50 POP 112B 50 POP 112C 60 PUSH1 0x40 112E 61 PUSH2 0x1139 1131 86 DUP7 1132 82 DUP3 1133 87 DUP8 1134 01 ADD 1135 61 PUSH2 0x1046 1138 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1129 stack[-4] = stack[-1] // @112C stack[-2] = 0x40 // @112E stack[-1] = 0x1139 // @1131 stack[0] = stack[-7] // @1134 stack[1] = stack[-6] + 0x40 // } // Block ends with call to 0x1046, returns to 0x1139 label_1139: // Incoming return from call to 0x1046 at 0x1138 // Inputs[7] // { // @113A stack[-3] // @113A stack[-1] // @113D stack[-6] // @113F stack[-4] // @113F stack[-7] // @1141 stack[-5] // @1141 stack[-8] // } 1139 5B JUMPDEST 113A 91 SWAP2 113B 50 POP 113C 50 POP 113D 92 SWAP3 113E 50 POP 113F 92 SWAP3 1140 50 POP 1141 92 SWAP3 1142 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @113D stack[-6] = stack[-1] // @113F stack[-7] = stack[-4] // @1141 stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-8] label_1143: // Incoming call from 0x1157, returns to 0x1158 // Inputs[2] // { // @1147 stack[-1] // @114B stack[-2] // } 1143 5B JUMPDEST 1144 5F PUSH0 1145 60 PUSH1 0xff 1147 82 DUP3 1148 16 AND 1149 90 SWAP1 114A 50 POP 114B 91 SWAP2 114C 90 SWAP1 114D 50 POP 114E 56 *JUMP // Stack delta = -1 // Outputs[1] { @114B stack[-2] = stack[-1] & 0xff } // Block ends with unconditional jump to stack[-2] label_114F: // Incoming call from 0x1170, returns to 0x1171 // Inputs[1] { @1153 stack[-1] } 114F 5B JUMPDEST 1150 61 PUSH2 0x1158 1153 81 DUP2 1154 61 PUSH2 0x1143 1157 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1150 stack[0] = 0x1158 // @1153 stack[1] = stack[-1] // } // Block ends with call to 0x1143, returns to 0x1158 label_1158: // Incoming return from call to 0x1143 at 0x1157 // Inputs[3] // { // @1159 stack[-3] // @115A stack[-1] // @115D stack[-4] // } 1158 5B JUMPDEST 1159 82 DUP3 115A 52 MSTORE 115B 50 POP 115C 50 POP 115D 56 *JUMP // Stack delta = -4 // Outputs[1] { @115A memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_115E: // Incoming call from 0x019C, returns to 0x019D // Inputs[2] // { // @1162 stack[-1] // @116C stack[-2] // } 115E 5B JUMPDEST 115F 5F PUSH0 1160 60 PUSH1 0x20 1162 82 DUP3 1163 01 ADD 1164 90 SWAP1 1165 50 POP 1166 61 PUSH2 0x1171 1169 5F PUSH0 116A 83 DUP4 116B 01 ADD 116C 84 DUP5 116D 61 PUSH2 0x114f 1170 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1164 stack[0] = stack[-1] + 0x20 // @1166 stack[1] = 0x1171 // @116B stack[2] = stack[-1] + 0x00 // @116C stack[3] = stack[-2] // } // Block ends with call to 0x114f, returns to 0x1171 label_1171: // Incoming return from call to 0x114F at 0x1170 // Inputs[3] // { // @1172 stack[-1] // @1172 stack[-4] // @1173 stack[-3] // } 1171 5B JUMPDEST 1172 92 SWAP3 1173 91 SWAP2 1174 50 POP 1175 50 POP 1176 56 *JUMP // Stack delta = -3 // Outputs[1] { @1172 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1177: // Incoming call from 0x02F0, returns to 0x02F1 // Incoming call from 0x01EA, returns to 0x01EB // Inputs[2] // { // @117B stack[-1] // @117C stack[-2] // } 1177 5B JUMPDEST 1178 5F PUSH0 1179 60 PUSH1 0x20 117B 82 DUP3 117C 84 DUP5 117D 03 SUB 117E 12 SLT 117F 15 ISZERO 1180 61 PUSH2 0x118c 1183 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1178 stack[0] = 0x00 } // Block ends with conditional jump to 0x118c, if !(stack[-2] - stack[-1] i< 0x20) label_1184: // Incoming jump from 0x1183, if not !(stack[-2] - stack[-1] i< 0x20) 1184 61 PUSH2 0x118b 1187 61 PUSH2 0x0fc9 118A 56 *JUMP // Stack delta = +1 // Outputs[1] { @1184 stack[0] = 0x118b } // Block ends with unconditional jump to 0x0fc9 118B 5B JUMPDEST label_118C: // Incoming jump from 0x1183, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1191 stack[-3] // @1193 stack[-2] // } 118C 5B JUMPDEST 118D 5F PUSH0 118E 61 PUSH2 0x1199 1191 84 DUP5 1192 82 DUP3 1193 85 DUP6 1194 01 ADD 1195 61 PUSH2 0x1013 1198 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @118D stack[0] = 0x00 // @118E stack[1] = 0x1199 // @1191 stack[2] = stack[-3] // @1194 stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x1013, returns to 0x1199 label_1199: // Incoming return from call to 0x1013 at 0x1198 // Inputs[4] // { // @119A stack[-1] // @119A stack[-3] // @119D stack[-6] // @119E stack[-5] // } 1199 5B JUMPDEST 119A 91 SWAP2 119B 50 POP 119C 50 POP 119D 92 SWAP3 119E 91 SWAP2 119F 50 POP 11A0 50 POP 11A1 56 *JUMP // Stack delta = -5 // Outputs[1] { @119D stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_11A2: // Incoming call from 0x11C3, returns to 0x11C4 // Inputs[1] { @11A6 stack[-1] } 11A2 5B JUMPDEST 11A3 61 PUSH2 0x11ab 11A6 81 DUP2 11A7 61 PUSH2 0x0fec 11AA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @11A3 stack[0] = 0x11ab // @11A6 stack[1] = stack[-1] // } // Block ends with call to 0x0fec, returns to 0x11AB label_11AB: // Incoming return from call to 0x0FEC at 0x11AA // Inputs[3] // { // @11AC stack[-3] // @11AD stack[-1] // @11B0 stack[-4] // } 11AB 5B JUMPDEST 11AC 82 DUP3 11AD 52 MSTORE 11AE 50 POP 11AF 50 POP 11B0 56 *JUMP // Stack delta = -4 // Outputs[1] { @11AD memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_11B1: // Incoming call from 0x0224, returns to 0x0225 // Inputs[2] // { // @11B5 stack[-1] // @11BF stack[-2] // } 11B1 5B JUMPDEST 11B2 5F PUSH0 11B3 60 PUSH1 0x20 11B5 82 DUP3 11B6 01 ADD 11B7 90 SWAP1 11B8 50 POP 11B9 61 PUSH2 0x11c4 11BC 5F PUSH0 11BD 83 DUP4 11BE 01 ADD 11BF 84 DUP5 11C0 61 PUSH2 0x11a2 11C3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @11B7 stack[0] = stack[-1] + 0x20 // @11B9 stack[1] = 0x11c4 // @11BE stack[2] = stack[-1] + 0x00 // @11BF stack[3] = stack[-2] // } // Block ends with call to 0x11a2, returns to 0x11C4 label_11C4: // Incoming return from call to 0x11A2 at 0x11C3 // Inputs[3] // { // @11C5 stack[-1] // @11C5 stack[-4] // @11C6 stack[-3] // } 11C4 5B JUMPDEST 11C5 92 SWAP3 11C6 91 SWAP2 11C7 50 POP 11C8 50 POP 11C9 56 *JUMP // Stack delta = -3 // Outputs[1] { @11C5 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_11CA: // Incoming call from 0x02C0, returns to 0x02C1 // Inputs[2] // { // @11CF stack[-1] // @11D0 stack[-2] // } 11CA 5B JUMPDEST 11CB 5F PUSH0 11CC 80 DUP1 11CD 60 PUSH1 0x40 11CF 83 DUP4 11D0 85 DUP6 11D1 03 SUB 11D2 12 SLT 11D3 15 ISZERO 11D4 61 PUSH2 0x11e0 11D7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @11CB stack[0] = 0x00 // @11CC stack[1] = 0x00 // } // Block ends with conditional jump to 0x11e0, if !(stack[-2] - stack[-1] i< 0x40) label_11D8: // Incoming jump from 0x11D7, if not !(stack[-2] - stack[-1] i< 0x40) 11D8 61 PUSH2 0x11df 11DB 61 PUSH2 0x0fc9 11DE 56 *JUMP // Stack delta = +1 // Outputs[1] { @11D8 stack[0] = 0x11df } // Block ends with unconditional jump to 0x0fc9 11DF 5B JUMPDEST label_11E0: // Incoming jump from 0x11D7, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @11E5 stack[-4] // @11E7 stack[-3] // } 11E0 5B JUMPDEST 11E1 5F PUSH0 11E2 61 PUSH2 0x11ed 11E5 85 DUP6 11E6 82 DUP3 11E7 86 DUP7 11E8 01 ADD 11E9 61 PUSH2 0x1013 11EC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @11E1 stack[0] = 0x00 // @11E2 stack[1] = 0x11ed // @11E5 stack[2] = stack[-4] // @11E8 stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x1013, returns to 0x11ED label_11ED: // Incoming return from call to 0x1013 at 0x11EC // Inputs[4] // { // @11EE stack[-4] // @11EE stack[-1] // @11F6 stack[-6] // @11F8 stack[-5] // } 11ED 5B JUMPDEST 11EE 92 SWAP3 11EF 50 POP 11F0 50 POP 11F1 60 PUSH1 0x20 11F3 61 PUSH2 0x11fe 11F6 85 DUP6 11F7 82 DUP3 11F8 86 DUP7 11F9 01 ADD 11FA 61 PUSH2 0x1013 11FD 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @11EE stack[-4] = stack[-1] // @11F1 stack[-2] = 0x20 // @11F3 stack[-1] = 0x11fe // @11F6 stack[0] = stack[-6] // @11F9 stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x1013, returns to 0x11FE label_11FE: // Incoming return from call to 0x1013 at 0x11FD // Inputs[6] // { // @11FF stack[-1] // @11FF stack[-3] // @1202 stack[-6] // @1204 stack[-7] // @1204 stack[-4] // @1205 stack[-5] // } 11FE 5B JUMPDEST 11FF 91 SWAP2 1200 50 POP 1201 50 POP 1202 92 SWAP3 1203 50 POP 1204 92 SWAP3 1205 90 SWAP1 1206 50 POP 1207 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1202 stack[-6] = stack[-1] // @1204 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1208: // Incoming jump from 0x125D // Inputs[1] { @1234 memory[0x00:0x24] } 1208 5B JUMPDEST 1209 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 122A 5F PUSH0 122B 52 MSTORE 122C 60 PUSH1 0x22 122E 60 PUSH1 0x04 1230 52 MSTORE 1231 60 PUSH1 0x24 1233 5F PUSH0 1234 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @122B memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @1230 memory[0x04:0x24] = 0x22 // @1234 revert(memory[0x00:0x24]); // } // Block terminates label_1235: // Incoming call from 0x06F6, returns to 0x06F7 // Incoming call from 0x06CA, returns to 0x06CB // Incoming call from 0x0332, returns to 0x0333 // Incoming call from 0x0306, returns to 0x0307 // Inputs[1] { @1239 stack[-1] } 1235 5B JUMPDEST 1236 5F PUSH0 1237 60 PUSH1 0x02 1239 82 DUP3 123A 04 DIV 123B 90 SWAP1 123C 50 POP 123D 60 PUSH1 0x01 123F 82 DUP3 1240 16 AND 1241 80 DUP1 1242 61 PUSH2 0x124c 1245 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @123B stack[0] = stack[-1] / 0x02 // @1240 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x124c, if stack[-1] & 0x01 label_1246: // Incoming jump from 0x1245, if not stack[-1] & 0x01 // Inputs[2] // { // @1248 stack[-2] // @1251 stack[-1] // } 1246 60 PUSH1 0x7f 1248 82 DUP3 1249 16 AND 124A 91 SWAP2 124B 50 POP 124C 5B JUMPDEST 124D 60 PUSH1 0x20 124F 82 DUP3 1250 10 LT 1251 81 DUP2 1252 03 SUB 1253 61 PUSH2 0x125f 1256 57 *JUMPI // Stack delta = +0 // Outputs[1] { @124A stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x125f, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_1257: // Incoming jump from 0x1256, if not stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x1256, if not stack[-1] - (stack[-2] & 0x7f < 0x20) 1257 61 PUSH2 0x125e 125A 61 PUSH2 0x1208 125D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1257 stack[0] = 0x125e } // Block ends with unconditional jump to 0x1208 125E 5B JUMPDEST label_125F: // Incoming jump from 0x1256, if stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x1256, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[3] // { // @1261 stack[-4] // @1261 stack[-2] // @1262 stack[-3] // } 125F 5B JUMPDEST 1260 50 POP 1261 91 SWAP2 1262 90 SWAP1 1263 50 POP 1264 56 *JUMP // Stack delta = -3 // Outputs[1] { @1261 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_1265: // Incoming call from 0x12A3, returns to 0x12A4 // Inputs[2] // { // @1288 stack[-1] // @128C stack[-2] // } 1265 5B JUMPDEST 1266 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1287 5F PUSH0 1288 82 DUP3 1289 01 ADD 128A 52 MSTORE 128B 50 POP 128C 56 *JUMP // Stack delta = -2 // Outputs[1] { @128A memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 } // Block ends with unconditional jump to stack[-2] label_128D: // Incoming call from 0x12C5, returns to 0x12C6 // Inputs[1] { @1294 stack[-1] } 128D 5B JUMPDEST 128E 5F PUSH0 128F 61 PUSH2 0x1299 1292 60 PUSH1 0x20 1294 83 DUP4 1295 61 PUSH2 0x0f29 1298 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @128E stack[0] = 0x00 // @128F stack[1] = 0x1299 // @1292 stack[2] = 0x20 // @1294 stack[3] = stack[-1] // } // Block ends with call to 0x0f29, returns to 0x1299 label_1299: // Incoming return from call to 0x0F29 at 0x1298 // Inputs[2] // { // @129A stack[-3] // @129A stack[-1] // } 1299 5B JUMPDEST 129A 91 SWAP2 129B 50 POP 129C 61 PUSH2 0x12a4 129F 82 DUP3 12A0 61 PUSH2 0x1265 12A3 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @129A stack[-3] = stack[-1] // @129C stack[-1] = 0x12a4 // @129F stack[0] = stack[-1] // } // Block ends with call to 0x1265, returns to 0x12A4 label_12A4: // Incoming return from call to 0x1265 at 0x12A3 // Inputs[3] // { // @12A7 stack[-2] // @12A9 stack[-1] // @12AB stack[-3] // } 12A4 5B JUMPDEST 12A5 60 PUSH1 0x20 12A7 82 DUP3 12A8 01 ADD 12A9 90 SWAP1 12AA 50 POP 12AB 91 SWAP2 12AC 90 SWAP1 12AD 50 POP 12AE 56 *JUMP // Stack delta = -2 // Outputs[1] { @12AB stack[-3] = stack[-2] + 0x20 } // Block ends with unconditional jump to stack[-3] label_12AF: // Incoming call from 0x0907, returns to 0x0908 // Incoming call from 0x05D1, returns to 0x05D2 // Inputs[1] { @12B3 stack[-1] } 12AF 5B JUMPDEST 12B0 5F PUSH0 12B1 60 PUSH1 0x20 12B3 82 DUP3 12B4 01 ADD 12B5 90 SWAP1 12B6 50 POP 12B7 81 DUP2 12B8 81 DUP2 12B9 03 SUB 12BA 5F PUSH0 12BB 83 DUP4 12BC 01 ADD 12BD 52 MSTORE 12BE 61 PUSH2 0x12c6 12C1 81 DUP2 12C2 61 PUSH2 0x128d 12C5 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @12B5 stack[0] = stack[-1] + 0x20 // @12BD memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @12BE stack[1] = 0x12c6 // @12C1 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x128d, returns to 0x12C6 label_12C6: // Incoming return from call to 0x128D at 0x12C5 // Inputs[4] // { // @12C7 stack[-2] // @12C7 stack[-1] // @12C9 stack[-4] // @12CA stack[-3] // } 12C6 5B JUMPDEST 12C7 90 SWAP1 12C8 50 POP 12C9 91 SWAP2 12CA 90 SWAP1 12CB 50 POP 12CC 56 *JUMP // Stack delta = -3 // Outputs[1] { @12C9 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_12CD: // Incoming call from 0x1331, returns to 0x1332 // Inputs[2] // { // @12F0 stack[-1] // @131A stack[-2] // } 12CD 5B JUMPDEST 12CE 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 12EF 5F PUSH0 12F0 82 DUP3 12F1 01 ADD 12F2 52 MSTORE 12F3 7F PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000 1314 60 PUSH1 0x20 1316 82 DUP3 1317 01 ADD 1318 52 MSTORE 1319 50 POP 131A 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @12F2 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @1318 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_131B: // Incoming call from 0x1353, returns to 0x1354 // Inputs[1] { @1322 stack[-1] } 131B 5B JUMPDEST 131C 5F PUSH0 131D 61 PUSH2 0x1327 1320 60 PUSH1 0x26 1322 83 DUP4 1323 61 PUSH2 0x0f29 1326 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @131C stack[0] = 0x00 // @131D stack[1] = 0x1327 // @1320 stack[2] = 0x26 // @1322 stack[3] = stack[-1] // } // Block ends with call to 0x0f29, returns to 0x1327 label_1327: // Incoming return from call to 0x0F29 at 0x1326 // Inputs[2] // { // @1328 stack[-3] // @1328 stack[-1] // } 1327 5B JUMPDEST 1328 91 SWAP2 1329 50 POP 132A 61 PUSH2 0x1332 132D 82 DUP3 132E 61 PUSH2 0x12cd 1331 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1328 stack[-3] = stack[-1] // @132A stack[-1] = 0x1332 // @132D stack[0] = stack[-1] // } // Block ends with call to 0x12cd, returns to 0x1332 label_1332: // Incoming return from call to 0x12CD at 0x1331 // Inputs[3] // { // @1335 stack[-2] // @1337 stack[-1] // @1339 stack[-3] // } 1332 5B JUMPDEST 1333 60 PUSH1 0x40 1335 82 DUP3 1336 01 ADD 1337 90 SWAP1 1338 50 POP 1339 91 SWAP2 133A 90 SWAP1 133B 50 POP 133C 56 *JUMP // Stack delta = -2 // Outputs[1] { @1339 stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_133D: // Incoming call from 0x0975, returns to 0x0976 // Inputs[1] { @1341 stack[-1] } 133D 5B JUMPDEST 133E 5F PUSH0 133F 60 PUSH1 0x20 1341 82 DUP3 1342 01 ADD 1343 90 SWAP1 1344 50 POP 1345 81 DUP2 1346 81 DUP2 1347 03 SUB 1348 5F PUSH0 1349 83 DUP4 134A 01 ADD 134B 52 MSTORE 134C 61 PUSH2 0x1354 134F 81 DUP2 1350 61 PUSH2 0x131b 1353 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1343 stack[0] = stack[-1] + 0x20 // @134B memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @134C stack[1] = 0x1354 // @134F stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x131b, returns to 0x1354 label_1354: // Incoming return from call to 0x131B at 0x1353 // Inputs[4] // { // @1355 stack[-1] // @1355 stack[-2] // @1357 stack[-4] // @1358 stack[-3] // } 1354 5B JUMPDEST 1355 90 SWAP1 1356 50 POP 1357 91 SWAP2 1358 90 SWAP1 1359 50 POP 135A 56 *JUMP // Stack delta = -3 // Outputs[1] { @1357 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_135B: // Incoming call from 0x13BF, returns to 0x13C0 // Inputs[2] // { // @137E stack[-1] // @13A8 stack[-2] // } 135B 5B JUMPDEST 135C 7F PUSH32 0x45524332303a20617070726f76652066726f6d20746865207a65726f20616464 137D 5F PUSH0 137E 82 DUP3 137F 01 ADD 1380 52 MSTORE 1381 7F PUSH32 0x7265737300000000000000000000000000000000000000000000000000000000 13A2 60 PUSH1 0x20 13A4 82 DUP3 13A5 01 ADD 13A6 52 MSTORE 13A7 50 POP 13A8 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1380 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x45524332303a20617070726f76652066726f6d20746865207a65726f20616464 // @13A6 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x7265737300000000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_13A9: // Incoming call from 0x13E1, returns to 0x13E2 // Inputs[1] { @13B0 stack[-1] } 13A9 5B JUMPDEST 13AA 5F PUSH0 13AB 61 PUSH2 0x13b5 13AE 60 PUSH1 0x24 13B0 83 DUP4 13B1 61 PUSH2 0x0f29 13B4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @13AA stack[0] = 0x00 // @13AB stack[1] = 0x13b5 // @13AE stack[2] = 0x24 // @13B0 stack[3] = stack[-1] // } // Block ends with call to 0x0f29, returns to 0x13B5 label_13B5: // Incoming return from call to 0x0F29 at 0x13B4 // Inputs[2] // { // @13B6 stack[-3] // @13B6 stack[-1] // } 13B5 5B JUMPDEST 13B6 91 SWAP2 13B7 50 POP 13B8 61 PUSH2 0x13c0 13BB 82 DUP3 13BC 61 PUSH2 0x135b 13BF 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @13B6 stack[-3] = stack[-1] // @13B8 stack[-1] = 0x13c0 // @13BB stack[0] = stack[-1] // } // Block ends with call to 0x135b, returns to 0x13C0 label_13C0: // Incoming return from call to 0x135B at 0x13BF // Inputs[3] // { // @13C3 stack[-2] // @13C5 stack[-1] // @13C7 stack[-3] // } 13C0 5B JUMPDEST 13C1 60 PUSH1 0x40 13C3 82 DUP3 13C4 01 ADD 13C5 90 SWAP1 13C6 50 POP 13C7 91 SWAP2 13C8 90 SWAP1 13C9 50 POP 13CA 56 *JUMP // Stack delta = -2 // Outputs[1] { @13C7 stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_13CB: // Incoming call from 0x0A9E, returns to 0x0A9F // Inputs[1] { @13CF stack[-1] } 13CB 5B JUMPDEST 13CC 5F PUSH0 13CD 60 PUSH1 0x20 13CF 82 DUP3 13D0 01 ADD 13D1 90 SWAP1 13D2 50 POP 13D3 81 DUP2 13D4 81 DUP2 13D5 03 SUB 13D6 5F PUSH0 13D7 83 DUP4 13D8 01 ADD 13D9 52 MSTORE 13DA 61 PUSH2 0x13e2 13DD 81 DUP2 13DE 61 PUSH2 0x13a9 13E1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @13D1 stack[0] = stack[-1] + 0x20 // @13D9 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @13DA stack[1] = 0x13e2 // @13DD stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x13a9, returns to 0x13E2 label_13E2: // Incoming return from call to 0x13A9 at 0x13E1 // Inputs[4] // { // @13E3 stack[-2] // @13E3 stack[-1] // @13E5 stack[-4] // @13E6 stack[-3] // } 13E2 5B JUMPDEST 13E3 90 SWAP1 13E4 50 POP 13E5 91 SWAP2 13E6 90 SWAP1 13E7 50 POP 13E8 56 *JUMP // Stack delta = -3 // Outputs[1] { @13E5 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_13E9: // Incoming call from 0x144D, returns to 0x144E // Inputs[2] // { // @140C stack[-1] // @1436 stack[-2] // } 13E9 5B JUMPDEST 13EA 7F PUSH32 0x45524332303a20617070726f766520746f20746865207a65726f206164647265 140B 5F PUSH0 140C 82 DUP3 140D 01 ADD 140E 52 MSTORE 140F 7F PUSH32 0x7373000000000000000000000000000000000000000000000000000000000000 1430 60 PUSH1 0x20 1432 82 DUP3 1433 01 ADD 1434 52 MSTORE 1435 50 POP 1436 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @140E memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x45524332303a20617070726f766520746f20746865207a65726f206164647265 // @1434 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x7373000000000000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_1437: // Incoming call from 0x146F, returns to 0x1470 // Inputs[1] { @143E stack[-1] } 1437 5B JUMPDEST 1438 5F PUSH0 1439 61 PUSH2 0x1443 143C 60 PUSH1 0x22 143E 83 DUP4 143F 61 PUSH2 0x0f29 1442 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1438 stack[0] = 0x00 // @1439 stack[1] = 0x1443 // @143C stack[2] = 0x22 // @143E stack[3] = stack[-1] // } // Block ends with call to 0x0f29, returns to 0x1443 label_1443: // Incoming return from call to 0x0F29 at 0x1442 // Inputs[2] // { // @1444 stack[-1] // @1444 stack[-3] // } 1443 5B JUMPDEST 1444 91 SWAP2 1445 50 POP 1446 61 PUSH2 0x144e 1449 82 DUP3 144A 61 PUSH2 0x13e9 144D 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1444 stack[-3] = stack[-1] // @1446 stack[-1] = 0x144e // @1449 stack[0] = stack[-1] // } // Block ends with call to 0x13e9, returns to 0x144E label_144E: // Incoming return from call to 0x13E9 at 0x144D // Inputs[3] // { // @1451 stack[-2] // @1453 stack[-1] // @1455 stack[-3] // } 144E 5B JUMPDEST 144F 60 PUSH1 0x40 1451 82 DUP3 1452 01 ADD 1453 90 SWAP1 1454 50 POP 1455 91 SWAP2 1456 90 SWAP1 1457 50 POP 1458 56 *JUMP // Stack delta = -2 // Outputs[1] { @1455 stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_1459: // Incoming call from 0x0B0C, returns to 0x0B0D // Inputs[1] { @145D stack[-1] } 1459 5B JUMPDEST 145A 5F PUSH0 145B 60 PUSH1 0x20 145D 82 DUP3 145E 01 ADD 145F 90 SWAP1 1460 50 POP 1461 81 DUP2 1462 81 DUP2 1463 03 SUB 1464 5F PUSH0 1465 83 DUP4 1466 01 ADD 1467 52 MSTORE 1468 61 PUSH2 0x1470 146B 81 DUP2 146C 61 PUSH2 0x1437 146F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @145F stack[0] = stack[-1] + 0x20 // @1467 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @1468 stack[1] = 0x1470 // @146B stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1437, returns to 0x1470 label_1470: // Incoming return from call to 0x1437 at 0x146F // Inputs[4] // { // @1471 stack[-1] // @1471 stack[-2] // @1473 stack[-4] // @1474 stack[-3] // } 1470 5B JUMPDEST 1471 90 SWAP1 1472 50 POP 1473 91 SWAP2 1474 90 SWAP1 1475 50 POP 1476 56 *JUMP // Stack delta = -3 // Outputs[1] { @1473 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1477: // Incoming call from 0x14DB, returns to 0x14DC // Inputs[2] // { // @149A stack[-1] // @14C4 stack[-2] // } 1477 5B JUMPDEST 1478 7F PUSH32 0x45524332303a207472616e736665722066726f6d20746865207a65726f206164 1499 5F PUSH0 149A 82 DUP3 149B 01 ADD 149C 52 MSTORE 149D 7F PUSH32 0x6472657373000000000000000000000000000000000000000000000000000000 14BE 60 PUSH1 0x20 14C0 82 DUP3 14C1 01 ADD 14C2 52 MSTORE 14C3 50 POP 14C4 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @149C memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x45524332303a207472616e736665722066726f6d20746865207a65726f206164 // @14C2 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x6472657373000000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_14C5: // Incoming call from 0x14FD, returns to 0x14FE // Inputs[1] { @14CC stack[-1] } 14C5 5B JUMPDEST 14C6 5F PUSH0 14C7 61 PUSH2 0x14d1 14CA 60 PUSH1 0x25 14CC 83 DUP4 14CD 61 PUSH2 0x0f29 14D0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @14C6 stack[0] = 0x00 // @14C7 stack[1] = 0x14d1 // @14CA stack[2] = 0x25 // @14CC stack[3] = stack[-1] // } // Block ends with call to 0x0f29, returns to 0x14D1 label_14D1: // Incoming return from call to 0x0F29 at 0x14D0 // Inputs[2] // { // @14D2 stack[-3] // @14D2 stack[-1] // } 14D1 5B JUMPDEST 14D2 91 SWAP2 14D3 50 POP 14D4 61 PUSH2 0x14dc 14D7 82 DUP3 14D8 61 PUSH2 0x1477 14DB 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @14D2 stack[-3] = stack[-1] // @14D4 stack[-1] = 0x14dc // @14D7 stack[0] = stack[-1] // } // Block ends with call to 0x1477, returns to 0x14DC label_14DC: // Incoming return from call to 0x1477 at 0x14DB // Inputs[3] // { // @14DF stack[-2] // @14E1 stack[-1] // @14E3 stack[-3] // } 14DC 5B JUMPDEST 14DD 60 PUSH1 0x40 14DF 82 DUP3 14E0 01 ADD 14E1 90 SWAP1 14E2 50 POP 14E3 91 SWAP2 14E4 90 SWAP1 14E5 50 POP 14E6 56 *JUMP // Stack delta = -2 // Outputs[1] { @14E3 stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_14E7: // Incoming call from 0x0C61, returns to 0x0C62 // Inputs[1] { @14EB stack[-1] } 14E7 5B JUMPDEST 14E8 5F PUSH0 14E9 60 PUSH1 0x20 14EB 82 DUP3 14EC 01 ADD 14ED 90 SWAP1 14EE 50 POP 14EF 81 DUP2 14F0 81 DUP2 14F1 03 SUB 14F2 5F PUSH0 14F3 83 DUP4 14F4 01 ADD 14F5 52 MSTORE 14F6 61 PUSH2 0x14fe 14F9 81 DUP2 14FA 61 PUSH2 0x14c5 14FD 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @14ED stack[0] = stack[-1] + 0x20 // @14F5 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @14F6 stack[1] = 0x14fe // @14F9 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x14c5, returns to 0x14FE label_14FE: // Incoming return from call to 0x14C5 at 0x14FD // Inputs[4] // { // @14FF stack[-1] // @14FF stack[-2] // @1501 stack[-4] // @1502 stack[-3] // } 14FE 5B JUMPDEST 14FF 90 SWAP1 1500 50 POP 1501 91 SWAP2 1502 90 SWAP1 1503 50 POP 1504 56 *JUMP // Stack delta = -3 // Outputs[1] { @1501 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1505: // Incoming call from 0x1569, returns to 0x156A // Inputs[2] // { // @1528 stack[-1] // @1552 stack[-2] // } 1505 5B JUMPDEST 1506 7F PUSH32 0x45524332303a207472616e7366657220746f20746865207a65726f2061646472 1527 5F PUSH0 1528 82 DUP3 1529 01 ADD 152A 52 MSTORE 152B 7F PUSH32 0x6573730000000000000000000000000000000000000000000000000000000000 154C 60 PUSH1 0x20 154E 82 DUP3 154F 01 ADD 1550 52 MSTORE 1551 50 POP 1552 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @152A memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x45524332303a207472616e7366657220746f20746865207a65726f2061646472 // @1550 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x6573730000000000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_1553: // Incoming call from 0x158B, returns to 0x158C // Inputs[1] { @155A stack[-1] } 1553 5B JUMPDEST 1554 5F PUSH0 1555 61 PUSH2 0x155f 1558 60 PUSH1 0x23 155A 83 DUP4 155B 61 PUSH2 0x0f29 155E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1554 stack[0] = 0x00 // @1555 stack[1] = 0x155f // @1558 stack[2] = 0x23 // @155A stack[3] = stack[-1] // } // Block ends with call to 0x0f29, returns to 0x155F label_155F: // Incoming return from call to 0x0F29 at 0x155E // Inputs[2] // { // @1560 stack[-3] // @1560 stack[-1] // } 155F 5B JUMPDEST 1560 91 SWAP2 1561 50 POP 1562 61 PUSH2 0x156a 1565 82 DUP3 1566 61 PUSH2 0x1505 1569 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1560 stack[-3] = stack[-1] // @1562 stack[-1] = 0x156a // @1565 stack[0] = stack[-1] // } // Block ends with call to 0x1505, returns to 0x156A label_156A: // Incoming return from call to 0x1505 at 0x1569 // Inputs[3] // { // @156D stack[-2] // @156F stack[-1] // @1571 stack[-3] // } 156A 5B JUMPDEST 156B 60 PUSH1 0x40 156D 82 DUP3 156E 01 ADD 156F 90 SWAP1 1570 50 POP 1571 91 SWAP2 1572 90 SWAP1 1573 50 POP 1574 56 *JUMP // Stack delta = -2 // Outputs[1] { @1571 stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_1575: // Incoming call from 0x0CCF, returns to 0x0CD0 // Inputs[1] { @1579 stack[-1] } 1575 5B JUMPDEST 1576 5F PUSH0 1577 60 PUSH1 0x20 1579 82 DUP3 157A 01 ADD 157B 90 SWAP1 157C 50 POP 157D 81 DUP2 157E 81 DUP2 157F 03 SUB 1580 5F PUSH0 1581 83 DUP4 1582 01 ADD 1583 52 MSTORE 1584 61 PUSH2 0x158c 1587 81 DUP2 1588 61 PUSH2 0x1553 158B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @157B stack[0] = stack[-1] + 0x20 // @1583 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @1584 stack[1] = 0x158c // @1587 stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x1553, returns to 0x158C label_158C: // Incoming return from call to 0x1553 at 0x158B // Inputs[4] // { // @158D stack[-1] // @158D stack[-2] // @158F stack[-4] // @1590 stack[-3] // } 158C 5B JUMPDEST 158D 90 SWAP1 158E 50 POP 158F 91 SWAP2 1590 90 SWAP1 1591 50 POP 1592 56 *JUMP // Stack delta = -3 // Outputs[1] { @158F stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1593: // Incoming call from 0x15D1, returns to 0x15D2 // Inputs[2] // { // @15B6 stack[-1] // @15BA stack[-2] // } 1593 5B JUMPDEST 1594 7F PUSH32 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 15B5 5F PUSH0 15B6 82 DUP3 15B7 01 ADD 15B8 52 MSTORE 15B9 50 POP 15BA 56 *JUMP // Stack delta = -2 // Outputs[1] { @15B8 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 } // Block ends with unconditional jump to stack[-2] label_15BB: // Incoming call from 0x15F3, returns to 0x15F4 // Inputs[1] { @15C2 stack[-1] } 15BB 5B JUMPDEST 15BC 5F PUSH0 15BD 61 PUSH2 0x15c7 15C0 60 PUSH1 0x1e 15C2 83 DUP4 15C3 61 PUSH2 0x0f29 15C6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @15BC stack[0] = 0x00 // @15BD stack[1] = 0x15c7 // @15C0 stack[2] = 0x1e // @15C2 stack[3] = stack[-1] // } // Block ends with call to 0x0f29, returns to 0x15C7 label_15C7: // Incoming return from call to 0x0F29 at 0x15C6 // Inputs[2] // { // @15C8 stack[-3] // @15C8 stack[-1] // } 15C7 5B JUMPDEST 15C8 91 SWAP2 15C9 50 POP 15CA 61 PUSH2 0x15d2 15CD 82 DUP3 15CE 61 PUSH2 0x1593 15D1 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @15C8 stack[-3] = stack[-1] // @15CA stack[-1] = 0x15d2 // @15CD stack[0] = stack[-1] // } // Block ends with call to 0x1593, returns to 0x15D2 label_15D2: // Incoming return from call to 0x1593 at 0x15D1 // Inputs[3] // { // @15D5 stack[-2] // @15D7 stack[-1] // @15D9 stack[-3] // } 15D2 5B JUMPDEST 15D3 60 PUSH1 0x20 15D5 82 DUP3 15D6 01 ADD 15D7 90 SWAP1 15D8 50 POP 15D9 91 SWAP2 15DA 90 SWAP1 15DB 50 POP 15DC 56 *JUMP // Stack delta = -2 // Outputs[1] { @15D9 stack[-3] = stack[-2] + 0x20 } // Block ends with unconditional jump to stack[-3] label_15DD: // Incoming call from 0x0E9F, returns to 0x0EA0 // Inputs[1] { @15E1 stack[-1] } 15DD 5B JUMPDEST 15DE 5F PUSH0 15DF 60 PUSH1 0x20 15E1 82 DUP3 15E2 01 ADD 15E3 90 SWAP1 15E4 50 POP 15E5 81 DUP2 15E6 81 DUP2 15E7 03 SUB 15E8 5F PUSH0 15E9 83 DUP4 15EA 01 ADD 15EB 52 MSTORE 15EC 61 PUSH2 0x15f4 15EF 81 DUP2 15F0 61 PUSH2 0x15bb 15F3 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @15E3 stack[0] = stack[-1] + 0x20 // @15EB memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @15EC stack[1] = 0x15f4 // @15EF stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x15bb, returns to 0x15F4 label_15F4: // Incoming return from call to 0x15BB at 0x15F3 // Inputs[4] // { // @15F5 stack[-2] // @15F5 stack[-1] // @15F7 stack[-4] // @15F8 stack[-3] // } 15F4 5B JUMPDEST 15F5 90 SWAP1 15F6 50 POP 15F7 91 SWAP2 15F8 90 SWAP1 15F9 50 POP 15FA 56 *JUMP // Stack delta = -3 // Outputs[1] { @15F7 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_15FB: // Incoming jump from 0x1653 // Incoming jump from 0x1686 // Inputs[1] { @1627 memory[0x00:0x24] } 15FB 5B JUMPDEST 15FC 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 161D 5F PUSH0 161E 52 MSTORE 161F 60 PUSH1 0x11 1621 60 PUSH1 0x04 1623 52 MSTORE 1624 60 PUSH1 0x24 1626 5F PUSH0 1627 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @161E memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @1623 memory[0x04:0x24] = 0x11 // @1627 revert(memory[0x00:0x24]); // } // Block terminates label_1628: // Incoming call from 0x0EB5, returns to 0x0EB6 // Inputs[1] { @162D stack[-1] } 1628 5B JUMPDEST 1629 5F PUSH0 162A 61 PUSH2 0x1632 162D 82 DUP3 162E 61 PUSH2 0x1027 1631 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1629 stack[0] = 0x00 // @162A stack[1] = 0x1632 // @162D stack[2] = stack[-1] // } // Block ends with call to 0x1027, returns to 0x1632 label_1632: // Incoming return from call to 0x1027 at 0x1631 // Inputs[3] // { // @1633 stack[-3] // @1633 stack[-1] // @1638 stack[-4] // } 1632 5B JUMPDEST 1633 91 SWAP2 1634 50 POP 1635 61 PUSH2 0x163d 1638 83 DUP4 1639 61 PUSH2 0x1027 163C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1633 stack[-3] = stack[-1] // @1635 stack[-1] = 0x163d // @1638 stack[0] = stack[-4] // } // Block ends with call to 0x1027, returns to 0x163D label_163D: // Incoming return from call to 0x1027 at 0x163C // Inputs[4] // { // @163E stack[-4] // @163E stack[-1] // @1641 stack[-3] // @1643 stack[-2] // } 163D 5B JUMPDEST 163E 92 SWAP3 163F 50 POP 1640 82 DUP3 1641 82 DUP3 1642 03 SUB 1643 90 SWAP1 1644 50 POP 1645 81 DUP2 1646 81 DUP2 1647 11 GT 1648 15 ISZERO 1649 61 PUSH2 0x1655 164C 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @163E stack[-4] = stack[-1] // @1643 stack[-2] = stack[-3] - stack[-1] // } // Block ends with conditional jump to 0x1655, if !(stack[-3] - stack[-1] > stack[-3]) label_164D: // Incoming jump from 0x164C, if not !(stack[-3] - stack[-1] > stack[-3]) 164D 61 PUSH2 0x1654 1650 61 PUSH2 0x15fb 1653 56 *JUMP // Stack delta = +1 // Outputs[1] { @164D stack[0] = 0x1654 } // Block ends with unconditional jump to 0x15fb 1654 5B JUMPDEST label_1655: // Incoming jump from 0x164C, if !(stack[-3] - stack[-1] > stack[-3]) // Inputs[3] // { // @1656 stack[-1] // @1656 stack[-4] // @1657 stack[-3] // } 1655 5B JUMPDEST 1656 92 SWAP3 1657 91 SWAP2 1658 50 POP 1659 50 POP 165A 56 *JUMP // Stack delta = -3 // Outputs[1] { @1656 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_165B: // Incoming call from 0x0ECF, returns to 0x0ED0 // Inputs[1] { @1660 stack[-1] } 165B 5B JUMPDEST 165C 5F PUSH0 165D 61 PUSH2 0x1665 1660 82 DUP3 1661 61 PUSH2 0x1027 1664 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @165C stack[0] = 0x00 // @165D stack[1] = 0x1665 // @1660 stack[2] = stack[-1] // } // Block ends with call to 0x1027, returns to 0x1665 label_1665: // Incoming return from call to 0x1027 at 0x1664 // Inputs[3] // { // @1666 stack[-1] // @1666 stack[-3] // @166B stack[-4] // } 1665 5B JUMPDEST 1666 91 SWAP2 1667 50 POP 1668 61 PUSH2 0x1670 166B 83 DUP4 166C 61 PUSH2 0x1027 166F 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1666 stack[-3] = stack[-1] // @1668 stack[-1] = 0x1670 // @166B stack[0] = stack[-4] // } // Block ends with call to 0x1027, returns to 0x1670 label_1670: // Incoming return from call to 0x1027 at 0x166F // Inputs[4] // { // @1671 stack[-4] // @1671 stack[-1] // @1674 stack[-3] // @1676 stack[-2] // } 1670 5B JUMPDEST 1671 92 SWAP3 1672 50 POP 1673 82 DUP3 1674 82 DUP3 1675 01 ADD 1676 90 SWAP1 1677 50 POP 1678 80 DUP1 1679 82 DUP3 167A 11 GT 167B 15 ISZERO 167C 61 PUSH2 0x1688 167F 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1671 stack[-4] = stack[-1] // @1676 stack[-2] = stack[-3] + stack[-1] // } // Block ends with conditional jump to 0x1688, if !(stack[-3] > stack[-3] + stack[-1]) label_1680: // Incoming jump from 0x167F, if not !(stack[-3] > stack[-3] + stack[-1]) 1680 61 PUSH2 0x1687 1683 61 PUSH2 0x15fb 1686 56 *JUMP // Stack delta = +1 // Outputs[1] { @1680 stack[0] = 0x1687 } // Block ends with unconditional jump to 0x15fb 1687 5B JUMPDEST label_1688: // Incoming jump from 0x167F, if !(stack[-3] > stack[-3] + stack[-1]) // Inputs[3] // { // @1689 stack[-1] // @1689 stack[-4] // @168A stack[-3] // } 1688 5B JUMPDEST 1689 92 SWAP3 168A 91 SWAP2 168B 50 POP 168C 50 POP 168D 56 *JUMP // Stack delta = -3 // Outputs[1] { @1689 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_168E: // Incoming call from 0x16CC, returns to 0x16CD // Inputs[2] // { // @16B1 stack[-1] // @16B5 stack[-2] // } 168E 5B JUMPDEST 168F 7F PUSH32 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 16B0 5F PUSH0 16B1 82 DUP3 16B2 01 ADD 16B3 52 MSTORE 16B4 50 POP 16B5 56 *JUMP // Stack delta = -2 // Outputs[1] { @16B3 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 } // Block ends with unconditional jump to stack[-2] label_16B6: // Incoming call from 0x16EE, returns to 0x16EF // Inputs[1] { @16BD stack[-1] } 16B6 5B JUMPDEST 16B7 5F PUSH0 16B8 61 PUSH2 0x16c2 16BB 60 PUSH1 0x1b 16BD 83 DUP4 16BE 61 PUSH2 0x0f29 16C1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @16B7 stack[0] = 0x00 // @16B8 stack[1] = 0x16c2 // @16BB stack[2] = 0x1b // @16BD stack[3] = stack[-1] // } // Block ends with call to 0x0f29, returns to 0x16C2 label_16C2: // Incoming return from call to 0x0F29 at 0x16C1 // Inputs[2] // { // @16C3 stack[-3] // @16C3 stack[-1] // } 16C2 5B JUMPDEST 16C3 91 SWAP2 16C4 50 POP 16C5 61 PUSH2 0x16cd 16C8 82 DUP3 16C9 61 PUSH2 0x168e 16CC 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @16C3 stack[-3] = stack[-1] // @16C5 stack[-1] = 0x16cd // @16C8 stack[0] = stack[-1] // } // Block ends with call to 0x168e, returns to 0x16CD label_16CD: // Incoming return from call to 0x168E at 0x16CC // Inputs[3] // { // @16D0 stack[-2] // @16D2 stack[-1] // @16D4 stack[-3] // } 16CD 5B JUMPDEST 16CE 60 PUSH1 0x20 16D0 82 DUP3 16D1 01 ADD 16D2 90 SWAP1 16D3 50 POP 16D4 91 SWAP2 16D5 90 SWAP1 16D6 50 POP 16D7 56 *JUMP // Stack delta = -2 // Outputs[1] { @16D4 stack[-3] = stack[-2] + 0x20 } // Block ends with unconditional jump to stack[-3] label_16D8: // Incoming call from 0x0F0B, returns to 0x0F0C // Inputs[1] { @16DC stack[-1] } 16D8 5B JUMPDEST 16D9 5F PUSH0 16DA 60 PUSH1 0x20 16DC 82 DUP3 16DD 01 ADD 16DE 90 SWAP1 16DF 50 POP 16E0 81 DUP2 16E1 81 DUP2 16E2 03 SUB 16E3 5F PUSH0 16E4 83 DUP4 16E5 01 ADD 16E6 52 MSTORE 16E7 61 PUSH2 0x16ef 16EA 81 DUP2 16EB 61 PUSH2 0x16b6 16EE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @16DE stack[0] = stack[-1] + 0x20 // @16E6 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @16E7 stack[1] = 0x16ef // @16EA stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x16b6, returns to 0x16EF label_16EF: // Incoming return from call to 0x16B6 at 0x16EE // Inputs[4] // { // @16F0 stack[-2] // @16F0 stack[-1] // @16F2 stack[-4] // @16F3 stack[-3] // } 16EF 5B JUMPDEST 16F0 90 SWAP1 16F1 50 POP 16F2 91 SWAP2 16F3 90 SWAP1 16F4 50 POP 16F5 56 *JUMP // Stack delta = -3 // Outputs[1] { @16F2 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] 16F6 FE *ASSERT 16F7 A2 LOG2 16F8 64 PUSH5 0x6970667358 16FE 22 22 16FF 12 SLT 1700 20 SHA3 1701 75 PUSH22 0x5dae02b3947df5be94f8cc81b223024e3ccaab76d611 1718 42 TIMESTAMP 1719 A0 LOG0 171A 61 PUSH2 0x4bec 171D 8E DUP15 171E D4 D4 171F 19 NOT 1720 8F DUP16 1721 64 PUSH5 0x736f6c6343 1727 00 *STOP 1728 08 ADDMOD 1729 15 ISZERO 172A 00 *STOP 172B 33 CALLER
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]