Online Solidity Decompiler

« Decompile another contract

Address

0x4fa3d04bb16ad580aa2c0f9423a452cb842cabf3 [etherscan.io | etherchain.org]

Public Methods

Method names cached from 4byte.directory.
0x00fdd58e balanceOf(address,uint256)
0x01ffc9a7 supportsInterface(bytes4)
0x02fe5305 setURI(string)
0x06fdde03 name()
0x0e89341c uri(uint256)
0x26987b60 currentIndex()
0x2eb2c2d6 safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)
0x4cd88b76 initialize(string,string)
0x4e1273f4 balanceOfBatch(address[],uint256[])
0x729ad39e airdrop(address[])
0x8da5cb5b owner()
0x95d89b41 symbol()
0xa22cb465 setApprovalForAll(address,bool)
0xe985e9c5 isApprovedForAll(address,address)
0xf242432a safeTransferFrom(address,address,uint256,uint256,bytes)

Internal Methods

func_010E(arg0, arg1) returns (r0)
func_013E(arg0) returns (r0)
func_016E(arg0)
func_01A8(arg0) returns (r0)
func_01F6(arg0, arg1, arg2, arg3, arg4)
func_0212(arg0, arg1)
func_022E(arg0, arg1) returns (r0)
func_025E(arg0)
func_02B6(arg0, arg1)
func_02D2(arg0, arg1) returns (r0)
func_0302(arg0, arg1, arg2, arg3, arg4)
func_04EF(arg0) returns (r0)
func_0611(arg0) returns (r0)
func_0812(arg0, arg1, arg3, arg6) returns (r0)
func_095B(arg0) returns (r0)
func_097F(arg0) returns (r0)
func_0A69(arg0) returns (r0)
func_0AD3(arg0)
func_0AED()
func_0BB7(arg0)
func_0CC0(arg0, arg1, arg2, arg3, arg4)
func_0D45(arg0, arg1, arg2) returns (r0)
func_0DCB(arg0, arg1) returns (r0)
func_0DE8(arg0, arg1, arg2) returns (r0)
func_0DF6(arg0) returns (r0)
func_0E54(arg0, arg1, arg2) returns (r0)
func_0E62(arg0) returns (r0)
func_0EC0(arg0, arg1, arg2) returns (r0)
func_0ECE(arg0) returns (r0)
func_0EFE(arg0, arg1, arg2) returns (r0)
func_0F0C(arg0) returns (r0)
func_0F3C(arg0, arg1) returns (r0)
func_0F51(arg0, arg1) returns (r0)
func_0F7B(arg0, arg1) returns (r0)
func_0FA5(arg0, arg1) returns (r0)
func_0FBA(arg0, arg1) returns (r0)
func_0FCF(arg0, arg1) returns (r0)
func_0FF9(arg0, arg1) returns (r0)
func_1023(arg0, arg1) returns (r0)
func_1038(arg0, arg1) returns (r0, r1)
func_1074(arg0, arg1) returns (r0, r1, r2, r3, r4)
func_1133(arg0, arg1) returns (r0, r1, r2, r3, r4)
func_11C2(arg0, arg1) returns (r0, r1)
func_11FE(arg0, arg1) returns (r0, r1)
func_123A(arg0, arg1) returns (r0)
func_127B(arg0, arg1) returns (r0, r1)
func_12E7(arg0, arg1) returns (r0)
func_1310(arg0, arg1) returns (r0)
func_1351(arg0, arg1) returns (r0, r1)
func_13BD(arg0, arg1) returns (r0)
func_13E6(arg0, arg1) returns (r0)
func_13FE(arg0, arg1)
func_140D(arg0, arg1) returns (r0)
func_146B(arg0, arg1)
func_147A(arg0, arg1)
func_1489(arg0, arg1)
func_1498(arg0, arg1) returns (r0)
func_14D1(arg0) returns (r0)
func_14F4(arg0) returns (r0)
func_1517(arg0, arg1)
func_1526(arg0, arg1)
func_1535(arg0, arg1) returns (r0)
func_1550(arg0, arg1) returns (r0)
func_1572(arg0, arg1) returns (r0)
func_158D(arg0, arg1, arg2) returns (r0)
func_15B6(arg0, arg1) returns (r0)
func_15D8(arg0) returns (r0)
func_15F8(arg0) returns (r0)
func_1618(arg0, arg1) returns (r0)
func_1633(arg0, arg1, arg2) returns (r0)
func_165C(arg0, arg1, arg2) returns (r0)
func_16A0() returns (r0)
func_16AA(arg0) returns (r0)
func_16D6(arg0) returns (r0)
func_1702(arg0) returns (r0)
func_1733(arg0) returns (r0)
func_1764(arg0) returns (r0)
func_1774(arg0) returns (r0)
func_177F(arg0) returns (r0)
func_178A(arg0) returns (r0)
func_1797(arg0, arg1) returns (r0)
func_17A8(arg0, arg1) returns (r0)
func_17B9(arg0, arg1) returns (r0)
func_180F(arg0) returns (r0)
func_1821(arg0) returns (r0)
func_182D(arg0) returns (r0)
func_1859(arg0) returns (r0)
func_1879(arg0) returns (r0)
func_1883(arg0) returns (r0)
func_1895(arg0) returns (r0)
func_18A7(arg0, arg1, arg2)
func_18B6(arg0, arg1, arg2)
func_18E9(arg0) returns (r0)
func_191B(arg0, arg1)
func_194C(arg0) returns (r0)
func_1A22(arg0) returns (r0)
func_1A33(arg0)
func_1A5C(arg0)
func_1AAB(arg0)
func_1AC2(arg0)
func_1AD9(arg0)
func_1AF0(arg0)

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x80; var var0 = msg.value; if (var0) { revert(memory[0x00:0x00]); } if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); } var0 = msg.data[0x00:0x20] >> 0xe0; if (0x4cd88b76 > var0) { if (0x06fdde03 > var0) { if (var0 == 0xfdd58e) { // Dispatch table entry for balanceOf(address,uint256) var var1 = 0x0113; var var2 = 0x010e; var var4 = 0x04; var var3 = var4 + (msg.data.length - var4); var2, var3 = func_11FE(var3, var4); var1 = func_010E(var2, var3); var temp0 = var1; var1 = 0x0120; var3 = memory[0x40:0x60]; var2 = temp0; var1 = func_1618(var2, var3); var temp1 = memory[0x40:0x60]; return memory[temp1:temp1 + var1 - temp1]; } else if (var0 == 0x01ffc9a7) { // Dispatch table entry for supportsInterface(bytes4) var1 = 0x0143; var2 = 0x013e; var3 = msg.data.length - 0x04 + 0x04; var4 = 0x04; var2 = func_12E7(var3, var4); var1 = func_013E(var2); var temp2 = var1; var1 = 0x0150; var2 = temp2; var3 = memory[0x40:0x60]; var1 = func_1572(var2, var3); var temp3 = memory[0x40:0x60]; return memory[temp3:temp3 + var1 - temp3]; } else if (var0 == 0x02fe5305) { // Dispatch table entry for setURI(string) var1 = 0x0173; var2 = 0x016e; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2 = func_1310(var3, var4); func_016E(var2); stop(); } else { revert(memory[0x00:0x00]); } } else if (var0 == 0x06fdde03) { // Dispatch table entry for name() var1 = 0x017d; var2 = func_04EF(); var temp4 = var2; var2 = 0x018a; var3 = temp4; var4 = memory[0x40:0x60]; var2 = func_15B6(var3, var4); var temp5 = memory[0x40:0x60]; return memory[temp5:temp5 + var2 - temp5]; } else if (var0 == 0x0e89341c) { // Dispatch table entry for uri(uint256) var1 = 0x01ad; var2 = 0x01a8; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2 = func_13BD(var3, var4); var1 = func_01A8(var2); var temp6 = var1; var1 = 0x01ba; var3 = memory[0x40:0x60]; var2 = temp6; var1 = func_15B6(var2, var3); var temp7 = memory[0x40:0x60]; return memory[temp7:temp7 + var1 - temp7]; } else if (var0 == 0x26987b60) { // Dispatch table entry for currentIndex() var1 = 0x01cb; var2 = func_0611(); var temp8 = var2; var2 = 0x01d8; var3 = temp8; var4 = memory[0x40:0x60]; var2 = func_1618(var3, var4); var temp9 = memory[0x40:0x60]; return memory[temp9:temp9 + var2 - temp9]; } else if (var0 == 0x2eb2c2d6) { // Dispatch table entry for safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) var1 = 0x01fb; var2 = 0x01f6; var3 = msg.data.length - 0x04 + 0x04; var4 = 0x04; var var5; var var6; var2, var3, var4, var5, var6 = func_1074(var3, var4); func_01F6(var2, var3, var4, var5, var6); stop(); } else { revert(memory[0x00:0x00]); } } else if (0x95d89b41 > var0) { if (var0 == 0x4cd88b76) { // Dispatch table entry for initialize(string,string) var1 = 0x0217; var2 = 0x0212; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2, var3 = func_1351(var3, var4); func_0212(var2, var3); stop(); } else if (var0 == 0x4e1273f4) { // Dispatch table entry for balanceOfBatch(address[],uint256[]) var1 = 0x0233; var2 = 0x022e; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2, var3 = func_127B(var3, var4); var1 = func_022E(var2, var3); var temp10 = var1; var1 = 0x0240; var2 = temp10; var3 = memory[0x40:0x60]; var1 = func_1550(var2, var3); var temp11 = memory[0x40:0x60]; return memory[temp11:temp11 + var1 - temp11]; } else if (var0 == 0x729ad39e) { // Dispatch table entry for airdrop(address[]) var1 = 0x0263; var2 = 0x025e; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2 = func_123A(var3, var4); func_025E(var2); stop(); } else if (var0 == 0x8da5cb5b) { // Dispatch table entry for owner() var1 = 0x026d; var2 = func_095B(); var temp12 = var2; var2 = 0x027a; var3 = temp12; var4 = memory[0x40:0x60]; var2 = func_1535(var3, var4); var temp13 = memory[0x40:0x60]; return memory[temp13:temp13 + var2 - temp13]; } else { revert(memory[0x00:0x00]); } } else if (var0 == 0x95d89b41) { // Dispatch table entry for symbol() var1 = 0x028b; var2 = func_097F(); var temp14 = var2; var2 = 0x0298; var4 = memory[0x40:0x60]; var3 = temp14; var2 = func_15B6(var3, var4); var temp15 = memory[0x40:0x60]; return memory[temp15:temp15 + var2 - temp15]; } else if (var0 == 0xa22cb465) { // Dispatch table entry for setApprovalForAll(address,bool) var1 = 0x02bb; var2 = 0x02b6; var3 = msg.data.length - 0x04 + 0x04; var4 = 0x04; var2, var3 = func_11C2(var3, var4); func_02B6(var2, var3); stop(); } else if (var0 == 0xe985e9c5) { // Dispatch table entry for isApprovedForAll(address,address) var1 = 0x02d7; var2 = 0x02d2; var3 = msg.data.length - 0x04 + 0x04; var4 = 0x04; var2, var3 = func_1038(var3, var4); var1 = func_02D2(var2, var3); var temp16 = var1; var1 = 0x02e4; var2 = temp16; var3 = memory[0x40:0x60]; var1 = func_1572(var2, var3); var temp17 = memory[0x40:0x60]; return memory[temp17:temp17 + var1 - temp17]; } else if (var0 == 0xf242432a) { // Dispatch table entry for safeTransferFrom(address,address,uint256,uint256,bytes) var1 = 0x0307; var2 = 0x0302; var4 = 0x04; var3 = var4 + (msg.data.length - var4); var2, var3, var4, var5, var6 = func_1133(var3, var4); func_0302(var2, var3, var4, var5, var6); stop(); } else { revert(memory[0x00:0x00]); } } function func_010E(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff == arg0 & 0xffffffffffffffffffffffffffffffffffffffff) { return 0xff & 0x01; } var var1 = 0x00; return var1 & 0xff; } function func_013E(var arg0) returns (var r0) { var var0 = 0x00; var var1 = arg0 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0xd9b67a2600000000000000000000000000000000000000000000000000000000; if (!var1) { var1 = arg0 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0e89341c00000000000000000000000000000000000000000000000000000000; if (var1) { goto label_044E; } else { goto label_0444; } } else if (var1) { label_044E: return var1; } else { label_0444: var1 = 0x044d; var var2 = arg0; var1 = func_0A69(var2); goto label_044E; } } function func_016E(var arg0) { if (storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender) { var var0 = 0x04ec; var var1 = arg0; func_0AD3(var1); return; } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp0 + 0x04; var0 = 0x04da; var0 = func_15D8(var1); var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + var0 - temp1]); } } function func_01A8(var arg0) returns (var r0) { var var0 = 0x60; var var1 = 0x02; var var2 = 0x058c; var var3 = storage[var1]; var2 = func_18E9(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 var6 = 0x05b8; var var7 = storage[var5]; var6 = func_18E9(var7); if (!var6) { label_0605: 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_05FC; } label_05E8: var temp6 = var5; var temp7 = var6; memory[temp7:temp7 + 0x20] = storage[temp6]; var5 = temp6 + 0x01; var6 = temp7 + 0x20; if (var4 > var6) { goto label_05E8; } label_05FC: var temp8 = var4; var temp9 = temp8 + (var6 - temp8 & 0x1f); var6 = temp8; var4 = temp9; goto label_0605; } else { var temp10 = var4; memory[temp10:temp10 + 0x20] = storage[var5] / 0x0100 * 0x0100; var6 = var6; var4 = temp10 + 0x20; goto label_0605; } } function func_01F6(var arg0, var arg1, var arg2, var arg3, var arg4) {} function func_0212(var arg0, var arg1) { var var0 = storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff == 0xffffffffffffffffffffffffffffffffffffffff & 0x00; if (var0) { if (!var0) { revert(memory[0x00:0x00]); } label_06CD: var0 = 0x06d5; func_0AED(); var0 = 0x06de; var var1 = arg1; func_0AD3(var1); var temp0 = arg0; var0 = 0x06f4; var1 = 0x03; var var3 = memory[temp0:temp0 + 0x20]; var var2 = temp0 + 0x20; var0 = func_0D45(var1, var2, var3); var temp1 = arg0; var0 = 0x070b; var1 = 0x04; var2 = temp1 + 0x20; var3 = memory[temp1:temp1 + 0x20]; var0 = func_0D45(var1, var2, var3); return; } else if (storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender) { goto label_06CD; } else { revert(memory[0x00:0x00]); } } function func_022E(var arg0, var arg1) returns (var r0) { var var0 = 0x60; if (memory[arg0:arg0 + 0x20] == memory[arg1:arg1 + 0x20]) { var var1 = 0x00; var var2 = memory[arg0:arg0 + 0x20]; if (var2 <= 0xffffffffffffffff) { var temp0 = memory[0x40:0x60]; var temp1 = var2; var2 = temp0; var var3 = temp1; memory[var2:var2 + 0x20] = var3; memory[0x40:0x60] = var2 + var3 * 0x20 + 0x20; if (!var3) { var1 = var2; var2 = 0x00; if (var2 >= memory[arg0:arg0 + 0x20]) { label_08B6: return var1; } else { label_07D7: var3 = 0x0860; var var4 = arg0; var var5 = var2; if (var5 < memory[var4:var4 + 0x20]) { var3 = func_0812(arg1, var2, var4, var5); var4 = var1; var5 = var2; if (var5 < memory[var4:var4 + 0x20]) { memory[var5 * 0x20 + 0x20 + var4:var5 * 0x20 + 0x20 + var4 + 0x20] = var3; var4 = var2; var3 = 0x08af; var3 = func_194C(var4); var2 = var3; if (var2 >= memory[arg0:arg0 + 0x20]) { goto label_08B6; } else { goto label_07D7; } } else { memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x32; revert(memory[0x00:0x24]); } } else { memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x32; revert(memory[0x00:0x24]); } } } else { var temp2 = var3 * 0x20; memory[var2 + 0x20:var2 + 0x20 + temp2] = msg.data[msg.data.length:msg.data.length + temp2]; var1 = var2; var2 = 0x00; if (var2 >= memory[arg0:arg0 + 0x20]) { goto label_08B6; } else { goto label_07D7; } } } else { memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x41; revert(memory[0x00:0x24]); } } else { var temp3 = memory[0x40:0x60]; memory[temp3:temp3 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = 0x074d; var2 = temp3 + 0x04; var1 = func_15F8(var2); var temp4 = memory[0x40:0x60]; revert(memory[temp4:temp4 + var1 - temp4]); } } function func_025E(var arg0) { if (storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender) { var var0 = 0x0958; var var1 = arg0; func_0BB7(var1); return; } else { var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000; var1 = temp0 + 0x04; var0 = 0x0946; var0 = func_15D8(var1); var temp1 = memory[0x40:0x60]; revert(memory[temp1:temp1 + var0 - temp1]); } } function func_02B6(var arg0, var arg1) {} function func_02D2(var arg0, var arg1) returns (var r0) { return 0x01; } function func_0302(var arg0, var arg1, var arg2, var arg3, var arg4) { if (arg0 & 0xffffffffffffffffffffffffffffffffffffffff != msg.sender) { revert(memory[0x00:0x00]); } var var0 = 0x0a62; var var1 = arg0; var var2 = arg1; var var3 = arg2; var var4 = arg3; var var5 = arg4; func_0CC0(var1, var2, var3, var4, var5); } function func_04EF() returns (var r0) { r0 = 0x03; var var1 = 0x04fc; var var2 = storage[r0]; var1 = func_18E9(var2); var temp0 = var1; var temp1 = memory[0x40:0x60]; memory[0x40:0x60] = temp1 + (temp0 + 0x1f) / 0x20 * 0x20 + 0x20; var temp2 = r0; r0 = temp1; var1 = temp2; var2 = temp0; memory[r0:r0 + 0x20] = var2; var var3 = r0 + 0x20; var var4 = var1; var var6 = storage[var4]; var var5 = 0x0528; var5 = func_18E9(var6); if (!var5) { label_0575: return r0; } else if (0x1f < var5) { var temp3 = var3; var temp4 = temp3 + var5; var3 = temp4; memory[0x00:0x20] = var4; var temp5 = keccak256(memory[0x00:0x20]); memory[temp3:temp3 + 0x20] = storage[temp5]; var4 = temp5 + 0x01; var5 = temp3 + 0x20; if (var3 <= var5) { goto label_056C; } label_0558: var temp6 = var4; var temp7 = var5; memory[temp7:temp7 + 0x20] = storage[temp6]; var4 = temp6 + 0x01; var5 = temp7 + 0x20; if (var3 > var5) { goto label_0558; } label_056C: var temp8 = var3; var temp9 = temp8 + (var5 - temp8 & 0x1f); var5 = temp8; var3 = temp9; goto label_0575; } else { var temp10 = var3; memory[temp10:temp10 + 0x20] = storage[var4] / 0x0100 * 0x0100; var3 = temp10 + 0x20; var5 = var5; goto label_0575; } } function func_0611() returns (var r0) { return storage[0x01]; } function func_0812(var arg0, var arg1, var arg2, var arg3) returns (var r0) { arg2 = memory[arg3 * 0x20 + 0x20 + arg2:arg3 * 0x20 + 0x20 + arg2 + 0x20]; arg3 = arg0; var var0 = arg1; if (var0 < memory[arg3:arg3 + 0x20]) { arg3 = memory[var0 * 0x20 + 0x20 + arg3:var0 * 0x20 + 0x20 + arg3 + 0x20]; var0 = 0x00; if (storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff == arg2 & 0xffffffffffffffffffffffffffffffffffffffff) { return 0xff & 0x01; } var var1 = 0x00; return var1 & 0xff; } else { memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x32; revert(memory[0x00:0x24]); } } function func_095B() returns (var r0) { return storage[0x00] & 0xffffffffffffffffffffffffffffffffffffffff; } function func_097F() returns (var r0) { r0 = 0x04; var var1 = 0x098c; var var2 = storage[r0]; var1 = func_18E9(var2); var temp0 = var1; var temp1 = memory[0x40:0x60]; memory[0x40:0x60] = temp1 + (temp0 + 0x1f) / 0x20 * 0x20 + 0x20; var temp2 = r0; r0 = temp1; var1 = temp2; var2 = temp0; memory[r0:r0 + 0x20] = var2; var var3 = r0 + 0x20; var var4 = var1; var var6 = storage[var4]; var var5 = 0x09b8; var5 = func_18E9(var6); if (!var5) { label_0A05: return r0; } else if (0x1f < var5) { var temp3 = var3; var temp4 = temp3 + var5; var3 = temp4; memory[0x00:0x20] = var4; var temp5 = keccak256(memory[0x00:0x20]); memory[temp3:temp3 + 0x20] = storage[temp5]; var4 = temp5 + 0x01; var5 = temp3 + 0x20; if (var3 <= var5) { goto label_09FC; } label_09E8: var temp6 = var4; var temp7 = var5; memory[temp7:temp7 + 0x20] = storage[temp6]; var4 = temp6 + 0x01; var5 = temp7 + 0x20; if (var3 > var5) { goto label_09E8; } label_09FC: var temp8 = var3; var temp9 = temp8 + (var5 - temp8 & 0x1f); var5 = temp8; var3 = temp9; goto label_0A05; } else { var temp10 = var3; memory[temp10:temp10 + 0x20] = storage[var4] / 0x0100 * 0x0100; var3 = temp10 + 0x20; var5 = var5; goto label_0A05; } } function func_0A69(var arg0) returns (var r0) { return arg0 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x01ffc9a700000000000000000000000000000000000000000000000000000000; } function func_0AD3(var arg0) { var temp0 = arg0; var var0 = 0x0ae9; var var1 = 0x02; var var3 = memory[temp0:temp0 + 0x20]; var var2 = temp0 + 0x20; var0 = func_0D45(var1, var2, var3); } function func_0AED() { storage[0x00] = msg.sender | (storage[0x00] & ~0xffffffffffffffffffffffffffffffffffffffff); storage[0x01] = 0x01; var var0 = msg.sender; var var1 = 0xffffffffffffffffffffffffffffffffffffffff & 0x00; var var2 = msg.sender; var var3 = 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62; var var4 = 0x0bad; var var5 = 0x00; var var7 = memory[0x40:0x60]; var var6 = 0x01; var4 = func_158D(var5, var6, var7); var temp0 = memory[0x40:0x60]; log(memory[temp0:temp0 + var4 - temp0], [stack[-2], stack[-3], stack[-4], stack[-5]]); } function func_0BB7(var arg0) { var var0 = 0x00; if (var0 >= memory[arg0:arg0 + 0x20]) { label_0CA2: var0 = memory[arg0:arg0 + 0x20]; var var1 = 0x01; var var2 = 0x00; var var3 = 0x0cb6; var var5 = storage[var1]; var var4 = var0; var3 = func_17B9(var4, var5); storage[var1] = var3; return; } else { label_0BC4: var1 = arg0; var2 = var0; if (var2 < memory[var1:var1 + 0x20]) { var1 = memory[var2 * 0x20 + 0x20 + var1:var2 * 0x20 + 0x20 + var1 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff; var2 = msg.sender; var3 = msg.sender; var4 = 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62; var5 = 0x0c77; var var6 = var0; var var7 = storage[0x01]; var5 = func_17B9(var6, var7); var temp0 = var5; var5 = 0x0c87; var6 = temp0; var7 = 0x01; var var8 = memory[0x40:0x60]; var5 = func_1633(var6, var7, var8); var temp1 = memory[0x40:0x60]; log(memory[temp1:temp1 + var5 - temp1], [stack[-2], stack[-3], stack[-4], stack[-5]]); var1 = var0; var2 = 0x0c9a; var3 = var1; var2 = func_194C(var3); var0 = var2; if (var0 >= memory[arg0:arg0 + 0x20]) { goto label_0CA2; } else { goto label_0BC4; } } else { memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x32; revert(memory[0x00:0x24]); } } } function func_0CC0(var arg0, var arg1, var arg2, var arg3, var arg4) { var var0 = arg1 & 0xffffffffffffffffffffffffffffffffffffffff; var var1 = arg0 & 0xffffffffffffffffffffffffffffffffffffffff; var var2 = msg.sender; var var3 = 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62; var var4 = 0x0d36; var var5 = arg2; var var6 = arg3; var var7 = memory[0x40:0x60]; var4 = func_165C(var5, var6, var7); var temp0 = memory[0x40:0x60]; log(memory[temp0:temp0 + var4 - temp0], [stack[-2], stack[-3], stack[-4], stack[-5]]); } function func_0D45(var arg0, var arg1, var arg2) returns (var r0) { var var0 = arg0; var var1 = 0x0d51; var var2 = storage[var0]; var1 = func_18E9(var2); memory[0x00:0x20] = var0; var0 = keccak256(memory[0x00:0x20]); var temp0 = var0 + (var1 + 0x1f) / 0x20; var1 = arg1; arg1 = temp0; if (!arg2) { storage[arg0] = 0x00; goto label_0DBA; } else if (0x1f < arg2) { var temp1 = arg2; storage[arg0] = temp1 + temp1 + 0x01; if (!temp1) { label_0DBA: var temp2 = arg1; arg1 = 0x0dc7; var0 = var0; arg2 = temp2; arg1 = func_0DCB(arg2, var0); return arg0; } else { var temp3 = arg2; var temp4 = var1; arg2 = temp4; var1 = arg2 + temp3; if (var1 <= arg2) { label_0DB9: goto label_0DBA; } else { label_0DA7: var temp5 = arg2; var temp6 = var0; storage[temp6] = memory[temp5:temp5 + 0x20]; arg2 = temp5 + 0x20; var0 = temp6 + 0x01; var1 = var1; if (var1 <= arg2) { goto label_0DB9; } else { goto label_0DA7; } } } } else { var temp7 = arg2; storage[arg0] = temp7 + temp7 | (memory[var1:var1 + 0x20] & ~0xff); goto label_0DBA; } } function func_0DCB(var arg0, var arg1) returns (var r0) { if (arg0 <= arg1) { label_0DE4: return arg0; } else { label_0DD5: var temp0 = arg1; storage[temp0] = 0x00; arg1 = temp0 + 0x01; if (arg0 <= arg1) { goto label_0DE4; } else { goto label_0DD5; } } } function func_0DE8(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x00; var var1 = 0x0dfb; var var2 = 0x0df6; var var3 = arg1; var2 = func_16AA(var3); var1 = func_0DF6(var2); var temp0 = var1; var0 = temp0; var temp1 = arg1; memory[var0:var0 + 0x20] = temp1; var1 = var0 + 0x20; var2 = arg2; if (var2 + temp1 * 0x20 > arg0) { revert(memory[0x00:0x00]); } var3 = 0x00; if (var3 >= arg1) { label_0E4A: return var0; } else { label_0E26: var var4 = var2; var var5 = 0x0e30; var var6 = arg0; var var7 = var4; var5 = func_0F3C(var6, var7); var temp2 = var1; memory[temp2:temp2 + 0x20] = var5; var1 = temp2 + 0x20; var2 = var2 + 0x20; var3 = var3 + 0x01; if (var3 >= arg1) { goto label_0E4A; } else { goto label_0E26; } } } function func_0DF6(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x168f; var1 = func_16A0(); var temp0 = var1; var0 = temp0; var1 = 0x169b; var var2 = arg0; var var3 = var0; func_191B(var2, var3); return var0; } function func_0E54(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x00; var var1 = 0x0e67; var var2 = 0x0e62; var var3 = arg1; var2 = func_16D6(var3); var1 = func_0E62(var2); var temp0 = var1; var0 = temp0; var temp1 = arg1; memory[var0:var0 + 0x20] = temp1; var1 = var0 + 0x20; var2 = arg2; if (var2 + temp1 * 0x20 > arg0) { revert(memory[0x00:0x00]); } var3 = 0x00; if (var3 >= arg1) { label_0EB6: return var0; } else { label_0E92: var var4 = var2; var var5 = 0x0e9c; var var6 = arg0; var var7 = var4; var5 = func_1023(var6, var7); var temp2 = var1; memory[temp2:temp2 + 0x20] = var5; var1 = temp2 + 0x20; var2 = var2 + 0x20; var3 = var3 + 0x01; if (var3 >= arg1) { goto label_0EB6; } else { goto label_0E92; } } } function func_0E62(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x168f; var1 = func_16A0(); var temp0 = var1; var0 = temp0; var1 = 0x169b; var var2 = arg0; var var3 = var0; func_191B(var2, var3); return var0; } function func_0EC0(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x00; var var1 = 0x0ed3; var var2 = 0x0ece; var var3 = arg1; var2 = func_1702(var3); var1 = func_0ECE(var2); var temp0 = var1; var0 = temp0; var temp1 = arg1; memory[var0:var0 + 0x20] = temp1; var1 = var0 + 0x20; if (arg2 + temp1 > arg0) { revert(memory[0x00:0x00]); } var2 = 0x0ef6; var3 = arg1; var var4 = var1; var var5 = arg2; func_18A7(var3, var4, var5); return var0; } function func_0ECE(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x168f; var1 = func_16A0(); var temp0 = var1; var0 = temp0; var1 = 0x169b; var var2 = arg0; var var3 = var0; func_191B(var2, var3); return var0; } function func_0EFE(var arg0, var arg1, var arg2) returns (var r0) { var var0 = 0x00; var var1 = 0x0f11; var var2 = 0x0f0c; var var3 = arg1; var2 = func_1733(var3); var1 = func_0F0C(var2); var temp0 = var1; var0 = temp0; var temp1 = arg1; memory[var0:var0 + 0x20] = temp1; var1 = var0 + 0x20; if (arg2 + temp1 > arg0) { revert(memory[0x00:0x00]); } var2 = 0x0f34; var3 = arg1; var var4 = var1; var var5 = arg2; func_18A7(var3, var4, var5); return var0; } function func_0F0C(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x168f; var1 = func_16A0(); var temp0 = var1; var0 = temp0; var1 = 0x169b; var var2 = arg0; var var3 = var0; func_191B(var2, var3); return var0; } function func_0F3C(var arg0, var arg1) returns (var r0) { var var0 = msg.data[arg1:arg1 + 0x20]; var var1 = 0x0f4b; var var2 = var0; func_1AAB(var2); return var0; } function func_0F51(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg1 + 0x1f i>= arg0) { revert(memory[0x00:0x00]); } var temp0 = arg1; var var1 = msg.data[temp0:temp0 + 0x20]; var var2 = 0x0f72; var var3 = arg0; var var4 = var1; var var5 = temp0 + 0x20; return func_0DE8(var3, var4, var5); } function func_0F7B(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg1 + 0x1f i>= arg0) { revert(memory[0x00:0x00]); } var temp0 = arg1; var var1 = msg.data[temp0:temp0 + 0x20]; var var2 = 0x0f9c; var var3 = arg0; var var4 = var1; var var5 = temp0 + 0x20; return func_0E54(var3, var4, var5); } function func_0FA5(var arg0, var arg1) returns (var r0) { var var0 = msg.data[arg1:arg1 + 0x20]; var var1 = 0x0fb4; var var2 = var0; func_1AC2(var2); return var0; } function func_0FBA(var arg0, var arg1) returns (var r0) { var var0 = msg.data[arg1:arg1 + 0x20]; var var1 = 0x0fc9; var var2 = var0; func_1AD9(var2); return var0; } function func_0FCF(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg1 + 0x1f i>= arg0) { revert(memory[0x00:0x00]); } var temp0 = arg1; var var1 = msg.data[temp0:temp0 + 0x20]; var var2 = 0x0ff0; var var3 = arg0; var var4 = var1; var var5 = temp0 + 0x20; return func_0EC0(var3, var4, var5); } function func_0FF9(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg1 + 0x1f i>= arg0) { revert(memory[0x00:0x00]); } var temp0 = arg1; var var1 = msg.data[temp0:temp0 + 0x20]; var var2 = 0x101a; var var3 = arg0; var var4 = var1; var var5 = temp0 + 0x20; return func_0EFE(var3, var4, var5); } function func_1023(var arg0, var arg1) returns (var r0) { var var0 = msg.data[arg1:arg1 + 0x20]; var var1 = 0x1032; var var2 = var0; func_1AF0(var2); return var0; } function func_1038(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; if (arg0 - arg1 i< 0x40) { revert(memory[0x00:0x00]); } var var2 = 0x00; var var3 = 0x1059; var var4 = arg0; var var5 = arg1 + var2; var3 = func_0F3C(var4, var5); var0 = var3; var2 = 0x20; var3 = 0x106a; var4 = arg0; var5 = arg1 + var2; var3 = func_0F3C(var4, var5); arg0 = var3; r0 = var0; return r0, arg0; } function func_1074(var arg0, var arg1) returns (var r0, var arg0, var arg1, var r3, var r4) { r3 = 0x00; r4 = r3; var var2 = 0x00; var var3 = var2; var var4 = 0x00; if (arg0 - arg1 i< 0xa0) { revert(memory[0x00:0x00]); } var var5 = 0x00; var var6 = 0x109a; var var7 = arg0; var var8 = arg1 + var5; var6 = func_0F3C(var7, var8); r3 = var6; var5 = 0x20; var6 = 0x10ab; var7 = arg0; var8 = arg1 + var5; var6 = func_0F3C(var7, var8); r4 = var6; var5 = msg.data[arg1 + 0x40:arg1 + 0x40 + 0x20]; if (var5 > 0xffffffffffffffff) { revert(memory[0x00:0x00]); } var6 = 0x10d4; var7 = arg0; var8 = arg1 + var5; var6 = func_0F7B(var7, var8); var2 = var6; var5 = msg.data[arg1 + 0x60:arg1 + 0x60 + 0x20]; if (var5 > 0xffffffffffffffff) { revert(memory[0x00:0x00]); } var6 = 0x10fd; var7 = arg0; var8 = arg1 + var5; var6 = func_0F7B(var7, var8); var3 = var6; var5 = msg.data[arg1 + 0x80:arg1 + 0x80 + 0x20]; if (var5 > 0xffffffffffffffff) { revert(memory[0x00:0x00]); } var6 = 0x1126; var7 = arg0; var8 = arg1 + var5; var6 = func_0FCF(var7, var8); var temp0 = r4; r4 = var6; arg0 = temp0; var temp1 = r3; r3 = var3; r0 = temp1; arg1 = var2; return r0, arg0, arg1, r3, r4; } function func_1133(var arg0, var arg1) returns (var r0, var arg0, var arg1, var r3, var r4) { r3 = 0x00; r4 = r3; var var2 = 0x00; var var3 = var2; var var4 = 0x00; if (arg0 - arg1 i< 0xa0) { revert(memory[0x00:0x00]); } var var5 = 0x00; var var6 = 0x1159; var var7 = arg0; var var8 = arg1 + var5; var6 = func_0F3C(var7, var8); r3 = var6; var5 = 0x20; var6 = 0x116a; var7 = arg0; var8 = arg1 + var5; var6 = func_0F3C(var7, var8); r4 = var6; var5 = 0x40; var6 = 0x117b; var7 = arg0; var8 = arg1 + var5; var6 = func_1023(var7, var8); var2 = var6; var5 = 0x60; var6 = 0x118c; var7 = arg0; var8 = arg1 + var5; var6 = func_1023(var7, var8); var3 = var6; var5 = msg.data[arg1 + 0x80:arg1 + 0x80 + 0x20]; if (var5 > 0xffffffffffffffff) { revert(memory[0x00:0x00]); } var6 = 0x11b5; var7 = arg0; var8 = arg1 + var5; var6 = func_0FCF(var7, var8); var temp0 = r4; r4 = var6; arg0 = temp0; var temp1 = r3; r3 = var3; r0 = temp1; arg1 = var2; return r0, arg0, arg1, r3, r4; } function func_11C2(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; if (arg0 - arg1 i< 0x40) { revert(memory[0x00:0x00]); } var var2 = 0x00; var var3 = 0x11e3; var var4 = arg0; var var5 = arg1 + var2; var3 = func_0F3C(var4, var5); var0 = var3; var2 = 0x20; var3 = 0x11f4; var4 = arg0; var5 = arg1 + var2; var3 = func_0FA5(var4, var5); arg0 = var3; r0 = var0; return r0, arg0; } function func_11FE(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; if (arg0 - arg1 i< 0x40) { revert(memory[0x00:0x00]); } var var2 = 0x00; var var3 = 0x121f; var var4 = arg0; var var5 = arg1 + var2; var3 = func_0F3C(var4, var5); var0 = var3; var2 = 0x20; var3 = 0x1230; var4 = arg0; var5 = arg1 + var2; var3 = func_1023(var4, var5); arg0 = var3; r0 = var0; return r0, arg0; } function func_123A(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg0 - arg1 i< 0x20) { revert(memory[0x00:0x00]); } var var1 = msg.data[arg1:arg1 + 0x20]; if (var1 > 0xffffffffffffffff) { revert(memory[0x00:0x00]); } var var2 = 0x1272; var var3 = arg0; var var4 = arg1 + var1; return func_0F51(var3, var4); } function func_127B(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; if (arg0 - arg1 i< 0x40) { revert(memory[0x00:0x00]); } var var2 = msg.data[arg1:arg1 + 0x20]; if (var2 > 0xffffffffffffffff) { revert(memory[0x00:0x00]); } var var3 = 0x12b4; var var4 = arg0; var var5 = arg1 + var2; var3 = func_0F51(var4, var5); var0 = var3; var2 = msg.data[arg1 + 0x20:arg1 + 0x20 + 0x20]; if (var2 > 0xffffffffffffffff) { revert(memory[0x00:0x00]); } var3 = 0x12dd; var4 = arg0; var5 = arg1 + var2; var3 = func_0F7B(var4, var5); arg0 = var3; r0 = var0; return r0, arg0; } function func_12E7(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg0 - arg1 i< 0x20) { revert(memory[0x00:0x00]); } var var1 = 0x00; var var2 = 0x1307; var var3 = arg0; var var4 = arg1 + var1; return func_0FBA(var3, var4); } function func_1310(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg0 - arg1 i< 0x20) { revert(memory[0x00:0x00]); } var var1 = msg.data[arg1:arg1 + 0x20]; if (var1 > 0xffffffffffffffff) { revert(memory[0x00:0x00]); } var var2 = 0x1348; var var3 = arg0; var var4 = arg1 + var1; return func_0FF9(var3, var4); } function func_1351(var arg0, var arg1) returns (var r0, var arg0) { var var0 = 0x00; var var1 = var0; if (arg0 - arg1 i< 0x40) { revert(memory[0x00:0x00]); } var var2 = msg.data[arg1:arg1 + 0x20]; if (var2 > 0xffffffffffffffff) { revert(memory[0x00:0x00]); } var var3 = 0x138a; var var4 = arg0; var var5 = arg1 + var2; var3 = func_0FF9(var4, var5); var0 = var3; var2 = msg.data[arg1 + 0x20:arg1 + 0x20 + 0x20]; if (var2 > 0xffffffffffffffff) { revert(memory[0x00:0x00]); } var3 = 0x13b3; var4 = arg0; var5 = arg1 + var2; var3 = func_0FF9(var4, var5); arg0 = var3; r0 = var0; return r0, arg0; } function func_13BD(var arg0, var arg1) returns (var r0) { var var0 = 0x00; if (arg0 - arg1 i< 0x20) { revert(memory[0x00:0x00]); } var var1 = 0x00; var var2 = 0x13dd; var var3 = arg0; var var4 = arg1 + var1; return func_1023(var3, var4); } function func_13E6(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x13f2; var var2 = arg0; var var3 = arg1; func_1517(var2, var3); return arg0 + 0x20; } function func_13FE(var arg0, var arg1) { var var0 = 0x1407; var var1 = arg1; var0 = func_180F(var1); memory[arg0:arg0 + 0x20] = var0; } function func_140D(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x1418; var var2 = arg1; var1 = func_1774(var2); var2 = 0x1422; var var3 = var1; var var4 = arg0; var2 = func_1797(var3, var4); arg0 = var2; var2 = 0x142d; var3 = arg1; var2 = func_1764(var3); var3 = var2; var4 = 0x00; if (var4 >= var1) { label_145E: return arg0; } else { label_143A: var var5 = memory[var3:var3 + 0x20]; var var6 = 0x1445; var var7 = arg0; var var8 = var5; var6 = func_13E6(var7, var8); arg0 = var6; var6 = 0x1450; var7 = var3; var6 = func_178A(var7); var3 = var6; var4 = var4 + 0x01; if (var4 >= var1) { goto label_145E; } else { goto label_143A; } } } function func_146B(var arg0, var arg1) { var var0 = 0x1474; var var1 = arg1; var0 = func_1821(var1); memory[arg0:arg0 + 0x20] = var0; } function func_147A(var arg0, var arg1) { var var0 = 0x1483; var var1 = arg1; var0 = func_1883(var1); memory[arg0:arg0 + 0x20] = var0; } function func_1489(var arg0, var arg1) { var var0 = 0x1492; var var1 = arg1; var0 = func_1895(var1); memory[arg0:arg0 + 0x20] = var0; } function func_1498(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x14a3; var var2 = arg1; var1 = func_177F(var2); var2 = 0x14ad; var var3 = var1; var var4 = arg0; var2 = func_17A8(var3, var4); var temp0 = var2; arg0 = temp0; var2 = 0x14bd; var3 = var1; var4 = arg0; var var5 = arg1 + 0x20; func_18B6(var3, var4, var5); var2 = 0x14c6; var3 = var1; var2 = func_1A22(var3); return arg0 + var2; } function func_14D1(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x14de; var var2 = 0x1a; var var3 = arg0; var1 = func_17A8(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x14e9; var2 = arg0; func_1A33(var2); return arg0 + 0x20; } function func_14F4(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x1501; var var2 = 0x29; var var3 = arg0; var1 = func_17A8(var2, var3); var temp0 = var1; arg0 = temp0; var1 = 0x150c; var2 = arg0; func_1A5C(var2); return arg0 + 0x40; } function func_1517(var arg0, var arg1) { var var0 = 0x1520; var var1 = arg1; var0 = func_1879(var1); memory[arg0:arg0 + 0x20] = var0; } function func_1526(var arg0, var arg1) { var var0 = 0x152f; var var1 = arg1; var0 = func_1879(var1); memory[arg0:arg0 + 0x20] = var0; } function func_1535(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; var var1 = 0x154a; var var2 = temp0; var var3 = arg0; func_13FE(var2, var3); return var0; } function func_1550(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x156a; var var2 = var0; var var3 = arg0; return func_140D(var2, var3); } function func_1572(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; var var1 = 0x1587; var var2 = temp0; var var3 = arg0; func_146B(var2, var3); return var0; } function func_158D(var arg0, var arg1, var arg2) returns (var r0) { var temp0 = arg2; var var0 = temp0 + 0x40; var var1 = 0x15a2; var var2 = temp0; var var3 = arg0; func_147A(var2, var3); var1 = 0x15af; var2 = arg2 + 0x20; var3 = arg1; func_1489(var2, var3); return var0; } function func_15B6(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x15d0; var var2 = var0; var var3 = arg0; return func_1498(var2, var3); } function func_15D8(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x15f1; var var2 = var0; return func_14D1(var2); } function func_15F8(var arg0) returns (var r0) { var temp0 = arg0; var var0 = temp0 + 0x20; memory[temp0:temp0 + 0x20] = var0 - temp0; var var1 = 0x1611; var var2 = var0; return func_14F4(var2); } function func_1618(var arg0, var arg1) returns (var r0) { var temp0 = arg1; var var0 = temp0 + 0x20; var var1 = 0x162d; var var2 = temp0; var var3 = arg0; func_1526(var2, var3); return var0; } function func_1633(var arg0, var arg1, var arg2) returns (var r0) { var temp0 = arg2; var var0 = temp0 + 0x40; var var1 = 0x1648; var var2 = temp0; var var3 = arg0; func_1526(var2, var3); var1 = 0x1655; var2 = arg2 + 0x20; var3 = arg1; func_1489(var2, var3); return var0; } function func_165C(var arg0, var arg1, var arg2) returns (var r0) { var temp0 = arg2; var var0 = temp0 + 0x40; var var1 = 0x1671; var var2 = temp0; var var3 = arg0; func_1526(var2, var3); var1 = 0x167e; var2 = arg2 + 0x20; var3 = arg1; func_1526(var2, var3); return var0; } function func_16A0() returns (var r0) { return memory[0x40:0x60]; } function func_16AA(var arg0) returns (var r0) { var var0 = 0x00; if (arg0 <= 0xffffffffffffffff) { return arg0 * 0x20 + 0x20; } var var1 = 0x16c4; memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x41; revert(memory[0x00:0x24]); } function func_16D6(var arg0) returns (var r0) { var var0 = 0x00; if (arg0 <= 0xffffffffffffffff) { return arg0 * 0x20 + 0x20; } var var1 = 0x16f0; memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x41; revert(memory[0x00:0x24]); } function func_1702(var arg0) returns (var r0) { var var0 = 0x00; if (arg0 <= 0xffffffffffffffff) { var var1 = 0x1726; var var2 = arg0; var1 = func_1A22(var2); return var1 + 0x20; } else { var1 = 0x171c; memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x41; revert(memory[0x00:0x24]); } } function func_1733(var arg0) returns (var r0) { var var0 = 0x00; if (arg0 <= 0xffffffffffffffff) { var var1 = 0x1757; var var2 = arg0; var1 = func_1A22(var2); return var1 + 0x20; } else { var1 = 0x174d; memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x41; revert(memory[0x00:0x24]); } } function func_1764(var arg0) returns (var r0) { return arg0 + 0x20; } function func_1774(var arg0) returns (var r0) { return memory[arg0:arg0 + 0x20]; } function func_177F(var arg0) returns (var r0) { return memory[arg0:arg0 + 0x20]; } function func_178A(var arg0) returns (var r0) { return arg0 + 0x20; } function func_1797(var arg0, var arg1) returns (var r0) { var temp0 = arg1; memory[temp0:temp0 + 0x20] = arg0; return temp0 + 0x20; } function func_17A8(var arg0, var arg1) returns (var r0) { var temp0 = arg1; memory[temp0:temp0 + 0x20] = arg0; return temp0 + 0x20; } function func_17B9(var arg0, var arg1) returns (var r0) { var var0 = 0x00; var var1 = 0x17c4; var var2 = arg1; var1 = func_1879(var2); arg1 = var1; var1 = 0x17cf; var2 = arg0; var1 = func_1879(var2); arg0 = var1; if (arg1 <= 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - arg0) { return arg1 + arg0; } var1 = 0x1803; memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x11; revert(memory[0x00:0x24]); } function func_180F(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x181a; var var2 = arg0; return func_1859(var2); } function func_1821(var arg0) returns (var r0) { return !!arg0; } function func_182D(var arg0) returns (var r0) { return arg0 & 0xffffffff00000000000000000000000000000000000000000000000000000000; } function func_1859(var arg0) returns (var r0) { return arg0 & 0xffffffffffffffffffffffffffffffffffffffff; } function func_1879(var arg0) returns (var r0) { return arg0; } function func_1883(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x188e; var var2 = arg0; return func_1879(var2); } function func_1895(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x18a0; var var2 = arg0; return func_1879(var2); } function func_18A7(var arg0, var arg1, var arg2) { var temp0 = arg0; var temp1 = arg1; memory[temp1:temp1 + temp0] = msg.data[arg2:arg2 + temp0]; memory[temp1 + temp0:temp1 + temp0 + 0x20] = 0x00; } function func_18B6(var arg0, var arg1, var arg2) { var var0 = 0x00; if (var0 >= arg0) { label_18D4: if (var0 <= arg0) { return; } memory[arg1 + arg0:arg1 + arg0 + 0x20] = 0x00; return; } else { label_18C2: var temp0 = var0; memory[arg1 + temp0:arg1 + temp0 + 0x20] = memory[arg2 + temp0:arg2 + temp0 + 0x20]; var0 = temp0 + 0x20; if (var0 >= arg0) { goto label_18D4; } else { goto label_18C2; } } } function func_18E9(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_1915; } else { goto label_190D; } } else if (var1 != (var0 < 0x20)) { label_1915: return var0; } else { label_190D: var var2 = 0x1914; memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x22; revert(memory[0x00:0x24]); } } function func_191B(var arg0, var arg1) { var var0 = 0x1924; var var1 = arg0; var0 = func_1A22(var1); var temp0 = arg1; var temp1 = temp0 + var0; var0 = temp1; if (!((var0 > 0xffffffffffffffff) | (var0 < temp0))) { memory[0x40:0x60] = var0; return; } else { var1 = 0x1942; memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x41; revert(memory[0x00:0x24]); } } function func_194C(var arg0) returns (var r0) { var var0 = 0x00; var var1 = 0x1957; var var2 = arg0; var1 = func_1879(var2); arg0 = var1; if (arg0 != 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { return arg0 + 0x01; } var1 = 0x1989; memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000; memory[0x04:0x24] = 0x11; revert(memory[0x00:0x24]); } function func_1A22(var arg0) returns (var r0) { return arg0 + 0x1f & ~0x1f; } function func_1A33(var arg0) { memory[arg0:arg0 + 0x20] = 0x6163636573732064656e6965642e206f776e6572204f4e4c592e000000000000; } function func_1A5C(var arg0) { var temp0 = arg0; memory[temp0:temp0 + 0x20] = 0x455243313135353a206163636f756e747320616e6420696473206c656e677468; memory[temp0 + 0x20:temp0 + 0x20 + 0x20] = 0x206d69736d617463680000000000000000000000000000000000000000000000; } function func_1AAB(var arg0) { var var0 = 0x1ab4; var var1 = arg0; var0 = func_180F(var1); if (arg0 == var0) { return; } else { revert(memory[0x00:0x00]); } } function func_1AC2(var arg0) { var var0 = 0x1acb; var var1 = arg0; var0 = func_1821(var1); if (arg0 == var0) { return; } else { revert(memory[0x00:0x00]); } } function func_1AD9(var arg0) { var var0 = 0x1ae2; var var1 = arg0; var0 = func_182D(var1); if (arg0 == var0) { return; } else { revert(memory[0x00:0x00]); } } function func_1AF0(var arg0) { var var0 = 0x1af9; var var1 = arg0; var0 = func_1879(var1); if (arg0 == var0) { return; } else { revert(memory[0x00:0x00]); } } }

Disassembly

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x00f4 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x00f4, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x4cd88b76 0026 11 GT 0027 61 PUSH2 0x0097 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0097, if 0x4cd88b76 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x4cd88b76 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0x95d89b41 0031 11 GT 0032 61 PUSH2 0x0066 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0066, if 0x95d89b41 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0x95d89b41 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0x95d89b41 003C 14 EQ 003D 61 PUSH2 0x0283 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0283, if 0x95d89b41 == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0x95d89b41 == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xa22cb465 0047 14 EQ 0048 61 PUSH2 0x02a1 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a1, if 0xa22cb465 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xa22cb465 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xe985e9c5 0052 14 EQ 0053 61 PUSH2 0x02bd 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02bd, if 0xe985e9c5 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xf242432a 005D 14 EQ 005E 61 PUSH2 0x02ed 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ed, if 0xf242432a == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xf242432a == stack[-1] 0062 61 PUSH2 0x00f4 0065 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00f4 label_0066: // Incoming jump from 0x0035, if 0x95d89b41 > stack[-1] // Inputs[1] { @0067 stack[-1] } 0066 5B JUMPDEST 0067 80 DUP1 0068 63 PUSH4 0x4cd88b76 006D 14 EQ 006E 61 PUSH2 0x01fd 0071 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01fd, if 0x4cd88b76 == stack[-1] label_0072: // Incoming jump from 0x0071, if not 0x4cd88b76 == stack[-1] // Inputs[1] { @0072 stack[-1] } 0072 80 DUP1 0073 63 PUSH4 0x4e1273f4 0078 14 EQ 0079 61 PUSH2 0x0219 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0219, if 0x4e1273f4 == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0x4e1273f4 == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0x729ad39e 0083 14 EQ 0084 61 PUSH2 0x0249 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0249, if 0x729ad39e == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0x729ad39e == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0x8da5cb5b 008E 14 EQ 008F 61 PUSH2 0x0265 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0265, if 0x8da5cb5b == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0x8da5cb5b == stack[-1] 0093 61 PUSH2 0x00f4 0096 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00f4 label_0097: // Incoming jump from 0x002A, if 0x4cd88b76 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0098 stack[-1] } 0097 5B JUMPDEST 0098 80 DUP1 0099 63 PUSH4 0x06fdde03 009E 11 GT 009F 61 PUSH2 0x00d3 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d3, if 0x06fdde03 > stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0x06fdde03 > stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0x06fdde03 00A9 14 EQ 00AA 61 PUSH2 0x0175 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0175, if 0x06fdde03 == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x06fdde03 == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x0e89341c 00B4 14 EQ 00B5 61 PUSH2 0x0193 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0193, if 0x0e89341c == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x0e89341c == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x26987b60 00BF 14 EQ 00C0 61 PUSH2 0x01c3 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c3, if 0x26987b60 == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x26987b60 == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x2eb2c2d6 00CA 14 EQ 00CB 61 PUSH2 0x01e1 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e1, if 0x2eb2c2d6 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x2eb2c2d6 == stack[-1] 00CF 61 PUSH2 0x00f4 00D2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00f4 label_00D3: // Incoming jump from 0x00A2, if 0x06fdde03 > stack[-1] // Inputs[1] { @00D4 stack[-1] } 00D3 5B JUMPDEST 00D4 80 DUP1 00D5 62 PUSH3 0xfdd58e 00D9 14 EQ 00DA 61 PUSH2 0x00f9 00DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00f9, if 0xfdd58e == stack[-1] label_00DE: // Incoming jump from 0x00DD, if not 0xfdd58e == stack[-1] // Inputs[1] { @00DE stack[-1] } 00DE 80 DUP1 00DF 63 PUSH4 0x01ffc9a7 00E4 14 EQ 00E5 61 PUSH2 0x0129 00E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0129, if 0x01ffc9a7 == stack[-1] label_00E9: // Incoming jump from 0x00E8, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @00E9 stack[-1] } 00E9 80 DUP1 00EA 63 PUSH4 0x02fe5305 00EF 14 EQ 00F0 61 PUSH2 0x0159 00F3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0159, if 0x02fe5305 == stack[-1] label_00F4: // Incoming jump from 0x0065 // Incoming jump from 0x00F3, if not 0x02fe5305 == stack[-1] // Incoming jump from 0x00D2 // Incoming jump from 0x0096 // Incoming jump from 0x0019, if msg.data.length < 0x04 // Inputs[1] { @00F8 memory[0x00:0x00] } 00F4 5B JUMPDEST 00F5 60 PUSH1 0x00 00F7 80 DUP1 00F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F8 revert(memory[0x00:0x00]); } // Block terminates label_00F9: // Incoming jump from 0x00DD, if 0xfdd58e == stack[-1] // Inputs[1] { @0100 msg.data.length } 00F9 5B JUMPDEST 00FA 61 PUSH2 0x0113 00FD 60 PUSH1 0x04 00FF 80 DUP1 0100 36 CALLDATASIZE 0101 03 SUB 0102 81 DUP2 0103 01 ADD 0104 90 SWAP1 0105 61 PUSH2 0x010e 0108 91 SWAP2 0109 90 SWAP1 010A 61 PUSH2 0x11fe 010D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @00FA stack[0] = 0x0113 // @0108 stack[1] = 0x010e // @0109 stack[2] = 0x04 + (msg.data.length - 0x04) // @0109 stack[3] = 0x04 // } // Block ends with call to 0x11fe, returns to 0x010E label_010E: // Incoming return from call to 0x11FE at 0x010D 010E 5B JUMPDEST 010F 61 PUSH2 0x0309 0112 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0309 label_0113: // Incoming return from call to 0x010E at 0x010D // Inputs[2] // { // @0116 memory[0x40:0x60] // @011A stack[-1] // } 0113 5B JUMPDEST 0114 60 PUSH1 0x40 0116 51 MLOAD 0117 61 PUSH2 0x0120 011A 91 SWAP2 011B 90 SWAP1 011C 61 PUSH2 0x1618 011F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @011A stack[-1] = 0x0120 // @011B stack[1] = memory[0x40:0x60] // @011B stack[0] = stack[-1] // } // Block ends with call to 0x1618, returns to 0x0120 label_0120: // Incoming return from call to 0x1618 at 0x011F // Inputs[3] // { // @0123 memory[0x40:0x60] // @0125 stack[-1] // @0128 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0120 5B JUMPDEST 0121 60 PUSH1 0x40 0123 51 MLOAD 0124 80 DUP1 0125 91 SWAP2 0126 03 SUB 0127 90 SWAP1 0128 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0128 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0129: // Incoming jump from 0x00E8, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0130 msg.data.length } 0129 5B JUMPDEST 012A 61 PUSH2 0x0143 012D 60 PUSH1 0x04 012F 80 DUP1 0130 36 CALLDATASIZE 0131 03 SUB 0132 81 DUP2 0133 01 ADD 0134 90 SWAP1 0135 61 PUSH2 0x013e 0138 91 SWAP2 0139 90 SWAP1 013A 61 PUSH2 0x12e7 013D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @012A stack[0] = 0x0143 // @0138 stack[1] = 0x013e // @0139 stack[2] = 0x04 + (msg.data.length - 0x04) // @0139 stack[3] = 0x04 // } // Block ends with call to 0x12e7, returns to 0x013E label_013E: // Incoming return from call to 0x12E7 at 0x013D 013E 5B JUMPDEST 013F 61 PUSH2 0x0373 0142 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0373 label_0143: // Incoming return from call to 0x013E at 0x013D // Inputs[2] // { // @0146 memory[0x40:0x60] // @014A stack[-1] // } 0143 5B JUMPDEST 0144 60 PUSH1 0x40 0146 51 MLOAD 0147 61 PUSH2 0x0150 014A 91 SWAP2 014B 90 SWAP1 014C 61 PUSH2 0x1572 014F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @014A stack[-1] = 0x0150 // @014B stack[1] = memory[0x40:0x60] // @014B stack[0] = stack[-1] // } // Block ends with call to 0x1572, returns to 0x0150 label_0150: // Incoming return from call to 0x1572 at 0x014F // Inputs[3] // { // @0153 memory[0x40:0x60] // @0155 stack[-1] // @0158 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0150 5B JUMPDEST 0151 60 PUSH1 0x40 0153 51 MLOAD 0154 80 DUP1 0155 91 SWAP2 0156 03 SUB 0157 90 SWAP1 0158 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0158 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0159: // Incoming jump from 0x00F3, if 0x02fe5305 == stack[-1] // Inputs[1] { @0160 msg.data.length } 0159 5B JUMPDEST 015A 61 PUSH2 0x0173 015D 60 PUSH1 0x04 015F 80 DUP1 0160 36 CALLDATASIZE 0161 03 SUB 0162 81 DUP2 0163 01 ADD 0164 90 SWAP1 0165 61 PUSH2 0x016e 0168 91 SWAP2 0169 90 SWAP1 016A 61 PUSH2 0x1310 016D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @015A stack[0] = 0x0173 // @0168 stack[1] = 0x016e // @0169 stack[2] = 0x04 + (msg.data.length - 0x04) // @0169 stack[3] = 0x04 // } // Block ends with call to 0x1310, returns to 0x016E label_016E: // Incoming return from call to 0x1310 at 0x016D 016E 5B JUMPDEST 016F 61 PUSH2 0x0455 0172 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0455 label_0173: // Incoming return from call to 0x016E at 0x016D 0173 5B JUMPDEST 0174 00 *STOP // Stack delta = +0 // Outputs[1] { @0174 stop(); } // Block terminates label_0175: // Incoming jump from 0x00AD, if 0x06fdde03 == stack[-1] 0175 5B JUMPDEST 0176 61 PUSH2 0x017d 0179 61 PUSH2 0x04ef 017C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0176 stack[0] = 0x017d } // Block ends with call to 0x04ef, returns to 0x017D label_017D: // Incoming return from call to 0x04EF at 0x017C // Inputs[2] // { // @0180 memory[0x40:0x60] // @0184 stack[-1] // } 017D 5B JUMPDEST 017E 60 PUSH1 0x40 0180 51 MLOAD 0181 61 PUSH2 0x018a 0184 91 SWAP2 0185 90 SWAP1 0186 61 PUSH2 0x15b6 0189 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0184 stack[-1] = 0x018a // @0185 stack[1] = memory[0x40:0x60] // @0185 stack[0] = stack[-1] // } // Block ends with call to 0x15b6, returns to 0x018A label_018A: // Incoming return from call to 0x15B6 at 0x0189 // Inputs[3] // { // @018D memory[0x40:0x60] // @018F stack[-1] // @0192 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 018A 5B JUMPDEST 018B 60 PUSH1 0x40 018D 51 MLOAD 018E 80 DUP1 018F 91 SWAP2 0190 03 SUB 0191 90 SWAP1 0192 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0192 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0193: // Incoming jump from 0x00B8, if 0x0e89341c == stack[-1] // Inputs[1] { @019A msg.data.length } 0193 5B JUMPDEST 0194 61 PUSH2 0x01ad 0197 60 PUSH1 0x04 0199 80 DUP1 019A 36 CALLDATASIZE 019B 03 SUB 019C 81 DUP2 019D 01 ADD 019E 90 SWAP1 019F 61 PUSH2 0x01a8 01A2 91 SWAP2 01A3 90 SWAP1 01A4 61 PUSH2 0x13bd 01A7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0194 stack[0] = 0x01ad // @01A2 stack[1] = 0x01a8 // @01A3 stack[2] = 0x04 + (msg.data.length - 0x04) // @01A3 stack[3] = 0x04 // } // Block ends with call to 0x13bd, returns to 0x01A8 label_01A8: // Incoming return from call to 0x13BD at 0x01A7 01A8 5B JUMPDEST 01A9 61 PUSH2 0x057d 01AC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x057d label_01AD: // Incoming return from call to 0x01A8 at 0x01A7 // Inputs[2] // { // @01B0 memory[0x40:0x60] // @01B4 stack[-1] // } 01AD 5B JUMPDEST 01AE 60 PUSH1 0x40 01B0 51 MLOAD 01B1 61 PUSH2 0x01ba 01B4 91 SWAP2 01B5 90 SWAP1 01B6 61 PUSH2 0x15b6 01B9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01B4 stack[-1] = 0x01ba // @01B5 stack[1] = memory[0x40:0x60] // @01B5 stack[0] = stack[-1] // } // Block ends with call to 0x15b6, returns to 0x01BA label_01BA: // Incoming return from call to 0x15B6 at 0x01B9 // Inputs[3] // { // @01BD memory[0x40:0x60] // @01BF stack[-1] // @01C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01BA 5B JUMPDEST 01BB 60 PUSH1 0x40 01BD 51 MLOAD 01BE 80 DUP1 01BF 91 SWAP2 01C0 03 SUB 01C1 90 SWAP1 01C2 F3 *RETURN // Stack delta = -1 // Outputs[1] { @01C2 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_01C3: // Incoming jump from 0x00C3, if 0x26987b60 == stack[-1] 01C3 5B JUMPDEST 01C4 61 PUSH2 0x01cb 01C7 61 PUSH2 0x0611 01CA 56 *JUMP // Stack delta = +1 // Outputs[1] { @01C4 stack[0] = 0x01cb } // Block ends with call to 0x0611, returns to 0x01CB label_01CB: // Incoming return from call to 0x0611 at 0x01CA // Inputs[2] // { // @01CE memory[0x40:0x60] // @01D2 stack[-1] // } 01CB 5B JUMPDEST 01CC 60 PUSH1 0x40 01CE 51 MLOAD 01CF 61 PUSH2 0x01d8 01D2 91 SWAP2 01D3 90 SWAP1 01D4 61 PUSH2 0x1618 01D7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01D2 stack[-1] = 0x01d8 // @01D3 stack[1] = memory[0x40:0x60] // @01D3 stack[0] = stack[-1] // } // Block ends with call to 0x1618, returns to 0x01D8 label_01D8: // Incoming return from call to 0x1618 at 0x01D7 // Inputs[3] // { // @01DB memory[0x40:0x60] // @01DD stack[-1] // @01E0 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01D8 5B JUMPDEST 01D9 60 PUSH1 0x40 01DB 51 MLOAD 01DC 80 DUP1 01DD 91 SWAP2 01DE 03 SUB 01DF 90 SWAP1 01E0 F3 *RETURN // Stack delta = -1 // Outputs[1] { @01E0 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_01E1: // Incoming jump from 0x00CE, if 0x2eb2c2d6 == stack[-1] // Inputs[1] { @01E8 msg.data.length } 01E1 5B JUMPDEST 01E2 61 PUSH2 0x01fb 01E5 60 PUSH1 0x04 01E7 80 DUP1 01E8 36 CALLDATASIZE 01E9 03 SUB 01EA 81 DUP2 01EB 01 ADD 01EC 90 SWAP1 01ED 61 PUSH2 0x01f6 01F0 91 SWAP2 01F1 90 SWAP1 01F2 61 PUSH2 0x1074 01F5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01E2 stack[0] = 0x01fb // @01F0 stack[1] = 0x01f6 // @01F1 stack[2] = 0x04 + (msg.data.length - 0x04) // @01F1 stack[3] = 0x04 // } // Block ends with call to 0x1074, returns to 0x01F6 label_01F6: // Incoming return from call to 0x1074 at 0x01F5 01F6 5B JUMPDEST 01F7 61 PUSH2 0x0617 01FA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0617 label_01FB: // Incoming return from call to 0x01F6 at 0x01F5 01FB 5B JUMPDEST 01FC 00 *STOP // Stack delta = +0 // Outputs[1] { @01FC stop(); } // Block terminates label_01FD: // Incoming jump from 0x0071, if 0x4cd88b76 == stack[-1] // Inputs[1] { @0204 msg.data.length } 01FD 5B JUMPDEST 01FE 61 PUSH2 0x0217 0201 60 PUSH1 0x04 0203 80 DUP1 0204 36 CALLDATASIZE 0205 03 SUB 0206 81 DUP2 0207 01 ADD 0208 90 SWAP1 0209 61 PUSH2 0x0212 020C 91 SWAP2 020D 90 SWAP1 020E 61 PUSH2 0x1351 0211 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01FE stack[0] = 0x0217 // @020C stack[1] = 0x0212 // @020D stack[2] = 0x04 + (msg.data.length - 0x04) // @020D stack[3] = 0x04 // } // Block ends with call to 0x1351, returns to 0x0212 label_0212: // Incoming return from call to 0x1351 at 0x0211 0212 5B JUMPDEST 0213 61 PUSH2 0x061e 0216 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x061e label_0217: // Incoming return from call to 0x0212 at 0x0211 0217 5B JUMPDEST 0218 00 *STOP // Stack delta = +0 // Outputs[1] { @0218 stop(); } // Block terminates label_0219: // Incoming jump from 0x007C, if 0x4e1273f4 == stack[-1] // Inputs[1] { @0220 msg.data.length } 0219 5B JUMPDEST 021A 61 PUSH2 0x0233 021D 60 PUSH1 0x04 021F 80 DUP1 0220 36 CALLDATASIZE 0221 03 SUB 0222 81 DUP2 0223 01 ADD 0224 90 SWAP1 0225 61 PUSH2 0x022e 0228 91 SWAP2 0229 90 SWAP1 022A 61 PUSH2 0x127b 022D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @021A stack[0] = 0x0233 // @0228 stack[1] = 0x022e // @0229 stack[2] = 0x04 + (msg.data.length - 0x04) // @0229 stack[3] = 0x04 // } // Block ends with call to 0x127b, returns to 0x022E label_022E: // Incoming return from call to 0x127B at 0x022D 022E 5B JUMPDEST 022F 61 PUSH2 0x0710 0232 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0710 label_0233: // Incoming return from call to 0x022E at 0x022D // Inputs[2] // { // @0236 memory[0x40:0x60] // @023A stack[-1] // } 0233 5B JUMPDEST 0234 60 PUSH1 0x40 0236 51 MLOAD 0237 61 PUSH2 0x0240 023A 91 SWAP2 023B 90 SWAP1 023C 61 PUSH2 0x1550 023F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @023A stack[-1] = 0x0240 // @023B stack[1] = memory[0x40:0x60] // @023B stack[0] = stack[-1] // } // Block ends with call to 0x1550, returns to 0x0240 label_0240: // Incoming return from call to 0x1550 at 0x023F // Inputs[3] // { // @0243 memory[0x40:0x60] // @0245 stack[-1] // @0248 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0240 5B JUMPDEST 0241 60 PUSH1 0x40 0243 51 MLOAD 0244 80 DUP1 0245 91 SWAP2 0246 03 SUB 0247 90 SWAP1 0248 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0248 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0249: // Incoming jump from 0x0087, if 0x729ad39e == stack[-1] // Inputs[1] { @0250 msg.data.length } 0249 5B JUMPDEST 024A 61 PUSH2 0x0263 024D 60 PUSH1 0x04 024F 80 DUP1 0250 36 CALLDATASIZE 0251 03 SUB 0252 81 DUP2 0253 01 ADD 0254 90 SWAP1 0255 61 PUSH2 0x025e 0258 91 SWAP2 0259 90 SWAP1 025A 61 PUSH2 0x123a 025D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @024A stack[0] = 0x0263 // @0258 stack[1] = 0x025e // @0259 stack[2] = 0x04 + (msg.data.length - 0x04) // @0259 stack[3] = 0x04 // } // Block ends with call to 0x123a, returns to 0x025E label_025E: // Incoming return from call to 0x123A at 0x025D 025E 5B JUMPDEST 025F 61 PUSH2 0x08c1 0262 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08c1 label_0263: // Incoming return from call to 0x025E at 0x025D 0263 5B JUMPDEST 0264 00 *STOP // Stack delta = +0 // Outputs[1] { @0264 stop(); } // Block terminates label_0265: // Incoming jump from 0x0092, if 0x8da5cb5b == stack[-1] 0265 5B JUMPDEST 0266 61 PUSH2 0x026d 0269 61 PUSH2 0x095b 026C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0266 stack[0] = 0x026d } // Block ends with call to 0x095b, returns to 0x026D label_026D: // Incoming return from call to 0x095B at 0x026C // Inputs[2] // { // @0270 memory[0x40:0x60] // @0274 stack[-1] // } 026D 5B JUMPDEST 026E 60 PUSH1 0x40 0270 51 MLOAD 0271 61 PUSH2 0x027a 0274 91 SWAP2 0275 90 SWAP1 0276 61 PUSH2 0x1535 0279 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0274 stack[-1] = 0x027a // @0275 stack[1] = memory[0x40:0x60] // @0275 stack[0] = stack[-1] // } // Block ends with call to 0x1535, returns to 0x027A label_027A: // Incoming return from call to 0x1535 at 0x0279 // Inputs[3] // { // @027D memory[0x40:0x60] // @027F stack[-1] // @0282 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 027A 5B JUMPDEST 027B 60 PUSH1 0x40 027D 51 MLOAD 027E 80 DUP1 027F 91 SWAP2 0280 03 SUB 0281 90 SWAP1 0282 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0282 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0283: // Incoming jump from 0x0040, if 0x95d89b41 == stack[-1] 0283 5B JUMPDEST 0284 61 PUSH2 0x028b 0287 61 PUSH2 0x097f 028A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0284 stack[0] = 0x028b } // Block ends with call to 0x097f, returns to 0x028B label_028B: // Incoming return from call to 0x097F at 0x028A // Inputs[2] // { // @028E memory[0x40:0x60] // @0292 stack[-1] // } 028B 5B JUMPDEST 028C 60 PUSH1 0x40 028E 51 MLOAD 028F 61 PUSH2 0x0298 0292 91 SWAP2 0293 90 SWAP1 0294 61 PUSH2 0x15b6 0297 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0292 stack[-1] = 0x0298 // @0293 stack[1] = memory[0x40:0x60] // @0293 stack[0] = stack[-1] // } // Block ends with call to 0x15b6, returns to 0x0298 label_0298: // Incoming return from call to 0x15B6 at 0x0297 // Inputs[3] // { // @029B memory[0x40:0x60] // @029D stack[-1] // @02A0 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0298 5B JUMPDEST 0299 60 PUSH1 0x40 029B 51 MLOAD 029C 80 DUP1 029D 91 SWAP2 029E 03 SUB 029F 90 SWAP1 02A0 F3 *RETURN // Stack delta = -1 // Outputs[1] { @02A0 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_02A1: // Incoming jump from 0x004B, if 0xa22cb465 == stack[-1] // Inputs[1] { @02A8 msg.data.length } 02A1 5B JUMPDEST 02A2 61 PUSH2 0x02bb 02A5 60 PUSH1 0x04 02A7 80 DUP1 02A8 36 CALLDATASIZE 02A9 03 SUB 02AA 81 DUP2 02AB 01 ADD 02AC 90 SWAP1 02AD 61 PUSH2 0x02b6 02B0 91 SWAP2 02B1 90 SWAP1 02B2 61 PUSH2 0x11c2 02B5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02A2 stack[0] = 0x02bb // @02B0 stack[1] = 0x02b6 // @02B1 stack[2] = 0x04 + (msg.data.length - 0x04) // @02B1 stack[3] = 0x04 // } // Block ends with call to 0x11c2, returns to 0x02B6 label_02B6: // Incoming return from call to 0x11C2 at 0x02B5 02B6 5B JUMPDEST 02B7 61 PUSH2 0x0a0d 02BA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a0d label_02BB: // Incoming return from call to 0x02B6 at 0x02B5 02BB 5B JUMPDEST 02BC 00 *STOP // Stack delta = +0 // Outputs[1] { @02BC stop(); } // Block terminates label_02BD: // Incoming jump from 0x0056, if 0xe985e9c5 == stack[-1] // Inputs[1] { @02C4 msg.data.length } 02BD 5B JUMPDEST 02BE 61 PUSH2 0x02d7 02C1 60 PUSH1 0x04 02C3 80 DUP1 02C4 36 CALLDATASIZE 02C5 03 SUB 02C6 81 DUP2 02C7 01 ADD 02C8 90 SWAP1 02C9 61 PUSH2 0x02d2 02CC 91 SWAP2 02CD 90 SWAP1 02CE 61 PUSH2 0x1038 02D1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02BE stack[0] = 0x02d7 // @02CC stack[1] = 0x02d2 // @02CD stack[2] = 0x04 + (msg.data.length - 0x04) // @02CD stack[3] = 0x04 // } // Block ends with call to 0x1038, returns to 0x02D2 label_02D2: // Incoming return from call to 0x1038 at 0x02D1 02D2 5B JUMPDEST 02D3 61 PUSH2 0x0a11 02D6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a11 label_02D7: // Incoming return from call to 0x02D2 at 0x02D1 // Inputs[2] // { // @02DA memory[0x40:0x60] // @02DE stack[-1] // } 02D7 5B JUMPDEST 02D8 60 PUSH1 0x40 02DA 51 MLOAD 02DB 61 PUSH2 0x02e4 02DE 91 SWAP2 02DF 90 SWAP1 02E0 61 PUSH2 0x1572 02E3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02DE stack[-1] = 0x02e4 // @02DF stack[1] = memory[0x40:0x60] // @02DF stack[0] = stack[-1] // } // Block ends with call to 0x1572, returns to 0x02E4 label_02E4: // Incoming return from call to 0x1572 at 0x02E3 // Inputs[3] // { // @02E7 memory[0x40:0x60] // @02E9 stack[-1] // @02EC memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 02E4 5B JUMPDEST 02E5 60 PUSH1 0x40 02E7 51 MLOAD 02E8 80 DUP1 02E9 91 SWAP2 02EA 03 SUB 02EB 90 SWAP1 02EC F3 *RETURN // Stack delta = -1 // Outputs[1] { @02EC return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_02ED: // Incoming jump from 0x0061, if 0xf242432a == stack[-1] // Inputs[1] { @02F4 msg.data.length } 02ED 5B JUMPDEST 02EE 61 PUSH2 0x0307 02F1 60 PUSH1 0x04 02F3 80 DUP1 02F4 36 CALLDATASIZE 02F5 03 SUB 02F6 81 DUP2 02F7 01 ADD 02F8 90 SWAP1 02F9 61 PUSH2 0x0302 02FC 91 SWAP2 02FD 90 SWAP1 02FE 61 PUSH2 0x1133 0301 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02EE stack[0] = 0x0307 // @02FC stack[1] = 0x0302 // @02FD stack[2] = 0x04 + (msg.data.length - 0x04) // @02FD stack[3] = 0x04 // } // Block ends with call to 0x1133, returns to 0x0302 label_0302: // Incoming return from call to 0x1133 at 0x0301 0302 5B JUMPDEST 0303 61 PUSH2 0x0a1d 0306 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a1d label_0307: // Incoming return from call to 0x0302 at 0x0301 0307 5B JUMPDEST 0308 00 *STOP // Stack delta = +0 // Outputs[1] { @0308 stop(); } // Block terminates label_0309: // Incoming jump from 0x0112 // Incoming jump from 0x085F // Inputs[2] // { // @030C stack[-2] // @0326 storage[0x00] // } 0309 5B JUMPDEST 030A 60 PUSH1 0x00 030C 82 DUP3 030D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0322 16 AND 0323 60 PUSH1 0x00 0325 80 DUP1 0326 54 SLOAD 0327 90 SWAP1 0328 61 PUSH2 0x0100 032B 0A EXP 032C 90 SWAP1 032D 04 DIV 032E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0343 16 AND 0344 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0359 16 AND 035A 14 EQ 035B 61 PUSH2 0x0365 035E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @030A stack[0] = 0x00 } // Block ends with conditional jump to 0x0365, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] label_035F: // Incoming jump from 0x035E, if not 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] 035F 60 PUSH1 0x00 0361 61 PUSH2 0x0368 0364 56 *JUMP // Stack delta = +1 // Outputs[1] { @035F stack[0] = 0x00 } // Block ends with unconditional jump to 0x0368 label_0365: // Incoming jump from 0x035E, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // Inputs[3] // { // @036C stack[-1] // @036E stack[-4] // @036F stack[-3] // } 0365 5B JUMPDEST 0366 60 PUSH1 0x01 0368 5B JUMPDEST 0369 60 PUSH1 0xff 036B 16 AND 036C 90 SWAP1 036D 50 POP 036E 92 SWAP3 036F 91 SWAP2 0370 50 POP 0371 50 POP 0372 56 *JUMP // Stack delta = -3 // Outputs[1] { @036E stack[-4] = 0xff & 0x01 } // Block ends with unconditional jump to stack[-4] label_0373: // Incoming jump from 0x0142 // Inputs[1] { @03B6 stack[-1] } 0373 5B JUMPDEST 0374 60 PUSH1 0x00 0376 7F PUSH32 0xd9b67a2600000000000000000000000000000000000000000000000000000000 0397 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 03B4 19 NOT 03B5 16 AND 03B6 82 DUP3 03B7 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 03D4 19 NOT 03D5 16 AND 03D6 14 EQ 03D7 80 DUP1 03D8 61 PUSH2 0x043e 03DB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0374 stack[0] = 0x00 // @03D6 stack[1] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0xd9b67a2600000000000000000000000000000000000000000000000000000000 // } // Block ends with conditional jump to 0x043e, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0xd9b67a2600000000000000000000000000000000000000000000000000000000 label_03DC: // Incoming jump from 0x03DB, if not ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0xd9b67a2600000000000000000000000000000000000000000000000000000000 // Inputs[1] { @041D stack[-3] } 03DC 50 POP 03DD 7F PUSH32 0x0e89341c00000000000000000000000000000000000000000000000000000000 03FE 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 041B 19 NOT 041C 16 AND 041D 82 DUP3 041E 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 043B 19 NOT 043C 16 AND 043D 14 EQ 043E 5B JUMPDEST 043F 80 DUP1 0440 61 PUSH2 0x044e 0443 57 *JUMPI // Stack delta = +0 // Outputs[1] { @043D stack[-1] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0e89341c00000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x044e, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0e89341c00000000000000000000000000000000000000000000000000000000 label_0444: // Incoming jump from 0x0443, if not ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0e89341c00000000000000000000000000000000000000000000000000000000 // Incoming jump from 0x0443, if not stack[-1] // Inputs[1] { @0448 stack[-3] } 0444 50 POP 0445 61 PUSH2 0x044d 0448 82 DUP3 0449 61 PUSH2 0x0a69 044C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0445 stack[-1] = 0x044d // @0448 stack[0] = stack[-3] // } // Block ends with call to 0x0a69, returns to 0x044D label_044D: // Incoming return from call to 0x0A69 at 0x044C 044D 5B JUMPDEST // Stack delta = +0 // Block continues label_044E: // Incoming jump from 0x0443, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0e89341c00000000000000000000000000000000000000000000000000000000 // Incoming jump from 0x044D // Incoming jump from 0x0443, if stack[-1] // Inputs[4] // { // @044F stack[-1] // @044F stack[-2] // @0451 stack[-4] // @0452 stack[-3] // } 044E 5B JUMPDEST 044F 90 SWAP1 0450 50 POP 0451 91 SWAP2 0452 90 SWAP1 0453 50 POP 0454 56 *JUMP // Stack delta = -3 // Outputs[1] { @0451 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0455: // Incoming jump from 0x0172 // Inputs[2] // { // @0456 msg.sender // @0470 storage[0x00] // } 0455 5B JUMPDEST 0456 33 CALLER 0457 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 046C 16 AND 046D 60 PUSH1 0x00 046F 80 DUP1 0470 54 SLOAD 0471 90 SWAP1 0472 61 PUSH2 0x0100 0475 0A EXP 0476 90 SWAP1 0477 04 DIV 0478 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 048D 16 AND 048E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04A3 16 AND 04A4 14 EQ 04A5 61 PUSH2 0x04e3 04A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e3, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender label_04A9: // Incoming jump from 0x04A8, if not 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // Inputs[1] { @04AB memory[0x40:0x60] } 04A9 60 PUSH1 0x40 04AB 51 MLOAD 04AC 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 04CD 81 DUP2 04CE 52 MSTORE 04CF 60 PUSH1 0x04 04D1 01 ADD 04D2 61 PUSH2 0x04da 04D5 90 SWAP1 04D6 61 PUSH2 0x15d8 04D9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @04CE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @04D5 stack[0] = 0x04da // @04D5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x15d8, returns to 0x04DA label_04DA: // Incoming return from call to 0x15D8 at 0x04D9 // Inputs[3] // { // @04DD memory[0x40:0x60] // @04DF stack[-1] // @04E2 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 04DA 5B JUMPDEST 04DB 60 PUSH1 0x40 04DD 51 MLOAD 04DE 80 DUP1 04DF 91 SWAP2 04E0 03 SUB 04E1 90 SWAP1 04E2 FD *REVERT // Stack delta = -1 // Outputs[1] { @04E2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_04E3: // Incoming jump from 0x04A8, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // Inputs[1] { @04E7 stack[-1] } 04E3 5B JUMPDEST 04E4 61 PUSH2 0x04ec 04E7 81 DUP2 04E8 61 PUSH2 0x0ad3 04EB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @04E4 stack[0] = 0x04ec // @04E7 stack[1] = stack[-1] // } // Block ends with call to 0x0ad3, returns to 0x04EC label_04EC: // Incoming return from call to 0x0AD3 at 0x04EB // Inputs[1] { @04EE stack[-2] } 04EC 5B JUMPDEST 04ED 50 POP 04EE 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_04EF: // Incoming call from 0x017C, returns to 0x017D // Inputs[1] { @04F3 storage[0x03] } 04EF 5B JUMPDEST 04F0 60 PUSH1 0x03 04F2 80 DUP1 04F3 54 SLOAD 04F4 61 PUSH2 0x04fc 04F7 90 SWAP1 04F8 61 PUSH2 0x18e9 04FB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @04F0 stack[0] = 0x03 // @04F7 stack[1] = 0x04fc // @04F7 stack[2] = storage[0x03] // } // Block ends with call to 0x18e9, returns to 0x04FC label_04FC: // Incoming return from call to 0x18E9 at 0x04FB // Inputs[4] // { // @04FD stack[-1] // @050C memory[0x40:0x60] // @0514 stack[-2] // @051F storage[stack[-2]] // } 04FC 5B JUMPDEST 04FD 80 DUP1 04FE 60 PUSH1 0x1f 0500 01 ADD 0501 60 PUSH1 0x20 0503 80 DUP1 0504 91 SWAP2 0505 04 DIV 0506 02 MUL 0507 60 PUSH1 0x20 0509 01 ADD 050A 60 PUSH1 0x40 050C 51 MLOAD 050D 90 SWAP1 050E 81 DUP2 050F 01 ADD 0510 60 PUSH1 0x40 0512 52 MSTORE 0513 80 DUP1 0514 92 SWAP3 0515 91 SWAP2 0516 90 SWAP1 0517 81 DUP2 0518 81 DUP2 0519 52 MSTORE 051A 60 PUSH1 0x20 051C 01 ADD 051D 82 DUP3 051E 80 DUP1 051F 54 SLOAD 0520 61 PUSH2 0x0528 0523 90 SWAP1 0524 61 PUSH2 0x18e9 0527 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0512 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0514 stack[-2] = memory[0x40:0x60] // @0515 stack[-1] = stack[-2] // @0516 stack[0] = stack[-1] // @0519 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @051C stack[1] = 0x20 + memory[0x40:0x60] // @051D stack[2] = stack[-2] // @0523 stack[4] = storage[stack[-2]] // @0523 stack[3] = 0x0528 // } // Block ends with call to 0x18e9, returns to 0x0528 label_0528: // Incoming return from call to 0x18E9 at 0x0527 // Inputs[1] { @0529 stack[-1] } 0528 5B JUMPDEST 0529 80 DUP1 052A 15 ISZERO 052B 61 PUSH2 0x0575 052E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0575, if !stack[-1] label_052F: // Incoming jump from 0x052E, if not !stack[-1] // Inputs[1] { @052F stack[-1] } 052F 80 DUP1 0530 60 PUSH1 0x1f 0532 10 LT 0533 61 PUSH2 0x054a 0536 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x054a, if 0x1f < stack[-1] label_0537: // Incoming jump from 0x0536, if not 0x1f < stack[-1] // Inputs[4] // { // @053B stack[-2] // @053C storage[stack[-2]] // @053F stack[-3] // @0541 stack[-1] // } 0537 61 PUSH2 0x0100 053A 80 DUP1 053B 83 DUP4 053C 54 SLOAD 053D 04 DIV 053E 02 MUL 053F 83 DUP4 0540 52 MSTORE 0541 91 SWAP2 0542 60 PUSH1 0x20 0544 01 ADD 0545 91 SWAP2 0546 61 PUSH2 0x0575 0549 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0540 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0545 stack[-1] = stack[-1] // @0545 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0575 label_054A: // Incoming jump from 0x0536, if 0x1f < stack[-1] // Inputs[5] // { // @054B stack[-3] // @054C stack[-1] // @054E stack[-2] // @0556 memory[0x00:0x20] // @055A storage[keccak256(memory[0x00:0x20])] // } 054A 5B JUMPDEST 054B 82 DUP3 054C 01 ADD 054D 91 SWAP2 054E 90 SWAP1 054F 60 PUSH1 0x00 0551 52 MSTORE 0552 60 PUSH1 0x20 0554 60 PUSH1 0x00 0556 20 SHA3 0557 90 SWAP1 0558 5B JUMPDEST 0559 81 DUP2 055A 54 SLOAD 055B 81 DUP2 055C 52 MSTORE 055D 90 SWAP1 055E 60 PUSH1 0x01 0560 01 ADD 0561 90 SWAP1 0562 60 PUSH1 0x20 0564 01 ADD 0565 80 DUP1 0566 83 DUP4 0567 11 GT 0568 61 PUSH2 0x0558 056B 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @054D stack[-3] = stack[-3] + stack[-1] // @0551 memory[0x00:0x20] = stack[-2] // @055C memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0561 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0564 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0558, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_056C: // Incoming jump from 0x056B, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x056B, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @056C stack[-3] // @056D stack[-1] // } 056C 82 DUP3 056D 90 SWAP1 056E 03 SUB 056F 60 PUSH1 0x1f 0571 16 AND 0572 82 DUP3 0573 01 ADD 0574 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0574 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0574 stack[-1] = stack[-3] // } // Block continues label_0575: // Incoming jump from 0x0574 // Incoming jump from 0x052E, if !stack[-1] // Incoming jump from 0x0549 // Inputs[1] { @057B stack[-7] } 0575 5B JUMPDEST 0576 50 POP 0577 50 POP 0578 50 POP 0579 50 POP 057A 50 POP 057B 81 DUP2 057C 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_057D: // Incoming jump from 0x01AC // Inputs[1] { @0583 storage[0x02] } 057D 5B JUMPDEST 057E 60 PUSH1 0x60 0580 60 PUSH1 0x02 0582 80 DUP1 0583 54 SLOAD 0584 61 PUSH2 0x058c 0587 90 SWAP1 0588 61 PUSH2 0x18e9 058B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @057E stack[0] = 0x60 // @0580 stack[1] = 0x02 // @0587 stack[2] = 0x058c // @0587 stack[3] = storage[0x02] // } // Block ends with call to 0x18e9, returns to 0x058C label_058C: // Incoming return from call to 0x18E9 at 0x058B // Inputs[4] // { // @058D stack[-1] // @059C memory[0x40:0x60] // @05A4 stack[-2] // @05AF storage[stack[-2]] // } 058C 5B JUMPDEST 058D 80 DUP1 058E 60 PUSH1 0x1f 0590 01 ADD 0591 60 PUSH1 0x20 0593 80 DUP1 0594 91 SWAP2 0595 04 DIV 0596 02 MUL 0597 60 PUSH1 0x20 0599 01 ADD 059A 60 PUSH1 0x40 059C 51 MLOAD 059D 90 SWAP1 059E 81 DUP2 059F 01 ADD 05A0 60 PUSH1 0x40 05A2 52 MSTORE 05A3 80 DUP1 05A4 92 SWAP3 05A5 91 SWAP2 05A6 90 SWAP1 05A7 81 DUP2 05A8 81 DUP2 05A9 52 MSTORE 05AA 60 PUSH1 0x20 05AC 01 ADD 05AD 82 DUP3 05AE 80 DUP1 05AF 54 SLOAD 05B0 61 PUSH2 0x05b8 05B3 90 SWAP1 05B4 61 PUSH2 0x18e9 05B7 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @05A2 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @05A4 stack[-2] = memory[0x40:0x60] // @05A5 stack[-1] = stack[-2] // @05A6 stack[0] = stack[-1] // @05A9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @05AC stack[1] = 0x20 + memory[0x40:0x60] // @05AD stack[2] = stack[-2] // @05B3 stack[4] = storage[stack[-2]] // @05B3 stack[3] = 0x05b8 // } // Block ends with call to 0x18e9, returns to 0x05B8 label_05B8: // Incoming return from call to 0x18E9 at 0x05B7 // Inputs[1] { @05B9 stack[-1] } 05B8 5B JUMPDEST 05B9 80 DUP1 05BA 15 ISZERO 05BB 61 PUSH2 0x0605 05BE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0605, if !stack[-1] label_05BF: // Incoming jump from 0x05BE, if not !stack[-1] // Inputs[1] { @05BF stack[-1] } 05BF 80 DUP1 05C0 60 PUSH1 0x1f 05C2 10 LT 05C3 61 PUSH2 0x05da 05C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05da, if 0x1f < stack[-1] label_05C7: // Incoming jump from 0x05C6, if not 0x1f < stack[-1] // Inputs[4] // { // @05CB stack[-2] // @05CC storage[stack[-2]] // @05CF stack[-3] // @05D1 stack[-1] // } 05C7 61 PUSH2 0x0100 05CA 80 DUP1 05CB 83 DUP4 05CC 54 SLOAD 05CD 04 DIV 05CE 02 MUL 05CF 83 DUP4 05D0 52 MSTORE 05D1 91 SWAP2 05D2 60 PUSH1 0x20 05D4 01 ADD 05D5 91 SWAP2 05D6 61 PUSH2 0x0605 05D9 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @05D0 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @05D5 stack[-1] = stack[-1] // @05D5 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0605 label_05DA: // Incoming jump from 0x05C6, if 0x1f < stack[-1] // Inputs[5] // { // @05DB stack[-3] // @05DC stack[-1] // @05DE stack[-2] // @05E6 memory[0x00:0x20] // @05EA storage[keccak256(memory[0x00:0x20])] // } 05DA 5B JUMPDEST 05DB 82 DUP3 05DC 01 ADD 05DD 91 SWAP2 05DE 90 SWAP1 05DF 60 PUSH1 0x00 05E1 52 MSTORE 05E2 60 PUSH1 0x20 05E4 60 PUSH1 0x00 05E6 20 SHA3 05E7 90 SWAP1 05E8 5B JUMPDEST 05E9 81 DUP2 05EA 54 SLOAD 05EB 81 DUP2 05EC 52 MSTORE 05ED 90 SWAP1 05EE 60 PUSH1 0x01 05F0 01 ADD 05F1 90 SWAP1 05F2 60 PUSH1 0x20 05F4 01 ADD 05F5 80 DUP1 05F6 83 DUP4 05F7 11 GT 05F8 61 PUSH2 0x05e8 05FB 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @05DD stack[-3] = stack[-3] + stack[-1] // @05E1 memory[0x00:0x20] = stack[-2] // @05EC memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @05F1 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @05F4 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x05e8, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_05FC: // Incoming jump from 0x05FB, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x05FB, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @05FC stack[-3] // @05FD stack[-1] // } 05FC 82 DUP3 05FD 90 SWAP1 05FE 03 SUB 05FF 60 PUSH1 0x1f 0601 16 AND 0602 82 DUP3 0603 01 ADD 0604 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0604 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0604 stack[-1] = stack[-3] // } // Block continues label_0605: // Incoming jump from 0x05D9 // Incoming jump from 0x05BE, if !stack[-1] // Incoming jump from 0x0604 // Inputs[4] // { // @060B stack[-7] // @060B stack[-6] // @060D stack[-9] // @060E stack[-8] // } 0605 5B JUMPDEST 0606 50 POP 0607 50 POP 0608 50 POP 0609 50 POP 060A 50 POP 060B 90 SWAP1 060C 50 POP 060D 91 SWAP2 060E 90 SWAP1 060F 50 POP 0610 56 *JUMP // Stack delta = -8 // Outputs[1] { @060D stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_0611: // Incoming call from 0x01CA, returns to 0x01CB // Inputs[2] // { // @0614 storage[0x01] // @0615 stack[-1] // } 0611 5B JUMPDEST 0612 60 PUSH1 0x01 0614 54 SLOAD 0615 81 DUP2 0616 56 *JUMP // Stack delta = +1 // Outputs[1] { @0614 stack[0] = storage[0x01] } // Block ends with unconditional jump to stack[-1] label_0617: // Incoming jump from 0x01FA // Inputs[1] { @061D stack[-6] } 0617 5B JUMPDEST 0618 50 POP 0619 50 POP 061A 50 POP 061B 50 POP 061C 50 POP 061D 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_061E: // Incoming jump from 0x0216 // Inputs[1] { @063A storage[0x00] } 061E 5B JUMPDEST 061F 60 PUSH1 0x00 0621 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0636 16 AND 0637 60 PUSH1 0x00 0639 80 DUP1 063A 54 SLOAD 063B 90 SWAP1 063C 61 PUSH2 0x0100 063F 0A EXP 0640 90 SWAP1 0641 04 DIV 0642 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0657 16 AND 0658 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 066D 16 AND 066E 14 EQ 066F 80 DUP1 0670 61 PUSH2 0x06c4 0673 57 *JUMPI // Stack delta = +1 // Outputs[1] { @066E stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00 } // Block ends with conditional jump to 0x06c4, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00 label_0674: // Incoming jump from 0x0673, if not 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00 // Inputs[2] // { // @0675 msg.sender // @068F storage[0x00] // } 0674 50 POP 0675 33 CALLER 0676 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 068B 16 AND 068C 60 PUSH1 0x00 068E 80 DUP1 068F 54 SLOAD 0690 90 SWAP1 0691 61 PUSH2 0x0100 0694 0A EXP 0695 90 SWAP1 0696 04 DIV 0697 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06AC 16 AND 06AD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06C2 16 AND 06C3 14 EQ 06C4 5B JUMPDEST 06C5 61 PUSH2 0x06cd 06C8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x06cd, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender label_06C9: // Incoming jump from 0x06C8, if not 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // Incoming jump from 0x06C8, if not stack[-1] // Inputs[1] { @06CC memory[0x00:0x00] } 06C9 60 PUSH1 0x00 06CB 80 DUP1 06CC FD *REVERT // Stack delta = +0 // Outputs[1] { @06CC revert(memory[0x00:0x00]); } // Block terminates label_06CD: // Incoming jump from 0x06C8, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // Incoming jump from 0x06C8, if stack[-1] 06CD 5B JUMPDEST 06CE 61 PUSH2 0x06d5 06D1 61 PUSH2 0x0aed 06D4 56 *JUMP // Stack delta = +1 // Outputs[1] { @06CE stack[0] = 0x06d5 } // Block ends with call to 0x0aed, returns to 0x06D5 label_06D5: // Incoming return from call to 0x0AED at 0x06D4 // Inputs[1] { @06D9 stack[-1] } 06D5 5B JUMPDEST 06D6 61 PUSH2 0x06de 06D9 81 DUP2 06DA 61 PUSH2 0x0ad3 06DD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06D6 stack[0] = 0x06de // @06D9 stack[1] = stack[-1] // } // Block ends with call to 0x0ad3, returns to 0x06DE label_06DE: // Incoming return from call to 0x0AD3 at 0x06DD // Inputs[2] // { // @06DF stack[-2] // @06E4 memory[stack[-2]:stack[-2] + 0x20] // } 06DE 5B JUMPDEST 06DF 81 DUP2 06E0 60 PUSH1 0x03 06E2 90 SWAP1 06E3 80 DUP1 06E4 51 MLOAD 06E5 90 SWAP1 06E6 60 PUSH1 0x20 06E8 01 ADD 06E9 90 SWAP1 06EA 61 PUSH2 0x06f4 06ED 92 SWAP3 06EE 91 SWAP2 06EF 90 SWAP1 06F0 61 PUSH2 0x0d45 06F3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06ED stack[0] = 0x06f4 // @06EE stack[1] = 0x03 // @06EF stack[2] = 0x20 + stack[-2] // @06EF stack[3] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x0d45, returns to 0x06F4 label_06F4: // Incoming return from call to 0x0D45 at 0x06F3 // Inputs[2] // { // @06F6 stack[-3] // @06FB memory[stack[-3]:stack[-3] + 0x20] // } 06F4 5B JUMPDEST 06F5 50 POP 06F6 81 DUP2 06F7 60 PUSH1 0x04 06F9 90 SWAP1 06FA 80 DUP1 06FB 51 MLOAD 06FC 90 SWAP1 06FD 60 PUSH1 0x20 06FF 01 ADD 0700 90 SWAP1 0701 61 PUSH2 0x070b 0704 92 SWAP3 0705 91 SWAP2 0706 90 SWAP1 0707 61 PUSH2 0x0d45 070A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0704 stack[-1] = 0x070b // @0705 stack[0] = 0x04 // @0706 stack[2] = memory[stack[-3]:stack[-3] + 0x20] // @0706 stack[1] = 0x20 + stack[-3] // } // Block ends with call to 0x0d45, returns to 0x070B label_070B: // Incoming return from call to 0x0D45 at 0x070A // Inputs[1] { @070F stack[-4] } 070B 5B JUMPDEST 070C 50 POP 070D 50 POP 070E 50 POP 070F 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0710: // Incoming jump from 0x0232 // Inputs[4] // { // @0713 stack[-1] // @0714 memory[stack[-1]:stack[-1] + 0x20] // @0715 stack[-2] // @0716 memory[stack[-2]:stack[-2] + 0x20] // } 0710 5B JUMPDEST 0711 60 PUSH1 0x60 0713 81 DUP2 0714 51 MLOAD 0715 83 DUP4 0716 51 MLOAD 0717 14 EQ 0718 61 PUSH2 0x0756 071B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0711 stack[0] = 0x60 } // Block ends with conditional jump to 0x0756, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] label_071C: // Incoming jump from 0x071B, if not memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @071E memory[0x40:0x60] } 071C 60 PUSH1 0x40 071E 51 MLOAD 071F 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0740 81 DUP2 0741 52 MSTORE 0742 60 PUSH1 0x04 0744 01 ADD 0745 61 PUSH2 0x074d 0748 90 SWAP1 0749 61 PUSH2 0x15f8 074C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0741 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0748 stack[0] = 0x074d // @0748 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x15f8, returns to 0x074D label_074D: // Incoming return from call to 0x15F8 at 0x074C // Inputs[3] // { // @0750 memory[0x40:0x60] // @0752 stack[-1] // @0755 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 074D 5B JUMPDEST 074E 60 PUSH1 0x40 0750 51 MLOAD 0751 80 DUP1 0752 91 SWAP2 0753 03 SUB 0754 90 SWAP1 0755 FD *REVERT // Stack delta = -1 // Outputs[1] { @0755 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0756: // Incoming jump from 0x071B, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[2] // { // @0759 stack[-3] // @075A memory[stack[-3]:stack[-3] + 0x20] // } 0756 5B JUMPDEST 0757 60 PUSH1 0x00 0759 83 DUP4 075A 51 MLOAD 075B 67 PUSH8 0xffffffffffffffff 0764 81 DUP2 0765 11 GT 0766 15 ISZERO 0767 61 PUSH2 0x0799 076A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0757 stack[0] = 0x00 // @075A stack[1] = memory[stack[-3]:stack[-3] + 0x20] // } // Block ends with conditional jump to 0x0799, if !(memory[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_076B: // Incoming jump from 0x076A, if not !(memory[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @0798 memory[0x00:0x24] } 076B 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 078C 60 PUSH1 0x00 078E 52 MSTORE 078F 60 PUSH1 0x41 0791 60 PUSH1 0x04 0793 52 MSTORE 0794 60 PUSH1 0x24 0796 60 PUSH1 0x00 0798 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @078E memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @0793 memory[0x04:0x24] = 0x41 // @0798 revert(memory[0x00:0x24]); // } // Block terminates label_0799: // Incoming jump from 0x076A, if !(memory[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @079C memory[0x40:0x60] // @079D stack[-1] // } 0799 5B JUMPDEST 079A 60 PUSH1 0x40 079C 51 MLOAD 079D 90 SWAP1 079E 80 DUP1 079F 82 DUP3 07A0 52 MSTORE 07A1 80 DUP1 07A2 60 PUSH1 0x20 07A4 02 MUL 07A5 60 PUSH1 0x20 07A7 01 ADD 07A8 82 DUP3 07A9 01 ADD 07AA 60 PUSH1 0x40 07AC 52 MSTORE 07AD 80 DUP1 07AE 15 ISZERO 07AF 61 PUSH2 0x07c7 07B2 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @079D stack[-1] = memory[0x40:0x60] // @079D stack[0] = stack[-1] // @07A0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @07AC memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x07c7, if !stack[-1] label_07B3: // Incoming jump from 0x07B2, if not !stack[-1] // Inputs[7] // { // @07B3 stack[-2] // @07B9 stack[-1] // @07BC msg.data.length // @07BE msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @07C9 stack[-3] // @07CE stack[-6] // @07CF memory[stack[-6]:stack[-6] + 0x20] // } 07B3 81 DUP2 07B4 60 PUSH1 0x20 07B6 01 ADD 07B7 60 PUSH1 0x20 07B9 82 DUP3 07BA 02 MUL 07BB 80 DUP1 07BC 36 CALLDATASIZE 07BD 83 DUP4 07BE 37 CALLDATACOPY 07BF 80 DUP1 07C0 82 DUP3 07C1 01 ADD 07C2 91 SWAP2 07C3 50 POP 07C4 50 POP 07C5 90 SWAP1 07C6 50 POP 07C7 5B JUMPDEST 07C8 50 POP 07C9 90 SWAP1 07CA 50 POP 07CB 60 PUSH1 0x00 07CD 5B JUMPDEST 07CE 84 DUP5 07CF 51 MLOAD 07D0 81 DUP2 07D1 10 LT 07D2 15 ISZERO 07D3 61 PUSH2 0x08b6 07D6 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @07BE memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @07C9 stack[-3] = stack[-2] // @07CB stack[-2] = 0x00 // } // Block ends with conditional jump to 0x08b6, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_07D7: // Incoming jump from 0x07D6, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x07D6, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x07D6, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[3] // { // @07DA stack[-5] // @07DB stack[-1] // @07DD memory[stack[-5]:stack[-5] + 0x20] // } 07D7 61 PUSH2 0x0860 07DA 85 DUP6 07DB 82 DUP3 07DC 81 DUP2 07DD 51 MLOAD 07DE 81 DUP2 07DF 10 LT 07E0 61 PUSH2 0x0812 07E3 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @07D7 stack[0] = 0x0860 // @07DA stack[1] = stack[-5] // @07DB stack[2] = stack[-1] // } // Block ends with conditional call to 0x0812, returns to 0x0860, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_07E4: // Incoming jump from 0x07E3, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[1] { @0811 memory[0x00:0x24] } 07E4 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 0805 60 PUSH1 0x00 0807 52 MSTORE 0808 60 PUSH1 0x32 080A 60 PUSH1 0x04 080C 52 MSTORE 080D 60 PUSH1 0x24 080F 60 PUSH1 0x00 0811 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0807 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @080C memory[0x04:0x24] = 0x32 // @0811 revert(memory[0x00:0x24]); // } // Block terminates label_0812: // Incoming call from 0x07E3, returns to 0x0860, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[6] // { // @0815 stack[-1] // @0819 stack[-2] // @081A memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @081B stack[-7] // @081C stack[-4] // @081E memory[stack[-7]:stack[-7] + 0x20] // } 0812 5B JUMPDEST 0813 60 PUSH1 0x20 0815 02 MUL 0816 60 PUSH1 0x20 0818 01 ADD 0819 01 ADD 081A 51 MLOAD 081B 85 DUP6 081C 83 DUP4 081D 81 DUP2 081E 51 MLOAD 081F 81 DUP2 0820 10 LT 0821 61 PUSH2 0x0853 0824 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @081A stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @081B stack[-1] = stack[-7] // @081C stack[0] = stack[-4] // } // Block ends with conditional jump to 0x0853, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] label_0825: // Incoming jump from 0x0824, if not stack[-4] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[1] { @0852 memory[0x00:0x24] } 0825 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 0846 60 PUSH1 0x00 0848 52 MSTORE 0849 60 PUSH1 0x32 084B 60 PUSH1 0x04 084D 52 MSTORE 084E 60 PUSH1 0x24 0850 60 PUSH1 0x00 0852 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0848 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @084D memory[0x04:0x24] = 0x32 // @0852 revert(memory[0x00:0x24]); // } // Block terminates label_0853: // Incoming jump from 0x0824, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[3] // { // @0856 stack[-1] // @085A stack[-2] // @085B memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 0853 5B JUMPDEST 0854 60 PUSH1 0x20 0856 02 MUL 0857 60 PUSH1 0x20 0859 01 ADD 085A 01 ADD 085B 51 MLOAD 085C 61 PUSH2 0x0309 085F 56 *JUMP // Stack delta = -1 // Outputs[1] { @085B stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0309 label_0860: // Incoming return from call to 0x0812 at 0x07E3 // Inputs[3] // { // @0861 stack[-3] // @0862 stack[-2] // @0864 memory[stack[-3]:stack[-3] + 0x20] // } 0860 5B JUMPDEST 0861 82 DUP3 0862 82 DUP3 0863 81 DUP2 0864 51 MLOAD 0865 81 DUP2 0866 10 LT 0867 61 PUSH2 0x0899 086A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0861 stack[0] = stack[-3] // @0862 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0899, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] label_086B: // Incoming jump from 0x086A, if not stack[-2] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[1] { @0898 memory[0x00:0x24] } 086B 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 088C 60 PUSH1 0x00 088E 52 MSTORE 088F 60 PUSH1 0x32 0891 60 PUSH1 0x04 0893 52 MSTORE 0894 60 PUSH1 0x24 0896 60 PUSH1 0x00 0898 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @088E memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @0893 memory[0x04:0x24] = 0x32 // @0898 revert(memory[0x00:0x24]); // } // Block terminates label_0899: // Incoming jump from 0x086A, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @089C stack[-1] // @08A0 stack[-2] // @08A1 stack[-3] // @08A6 stack[-4] // } 0899 5B JUMPDEST 089A 60 PUSH1 0x20 089C 02 MUL 089D 60 PUSH1 0x20 089F 01 ADD 08A0 01 ADD 08A1 81 DUP2 08A2 81 DUP2 08A3 52 MSTORE 08A4 50 POP 08A5 50 POP 08A6 80 DUP1 08A7 61 PUSH2 0x08af 08AA 90 SWAP1 08AB 61 PUSH2 0x194c 08AE 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @08A3 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] // @08AA stack[-2] = stack[-4] // @08AA stack[-3] = 0x08af // } // Block ends with call to 0x194c, returns to 0x08AF label_08AF: // Incoming return from call to 0x194C at 0x08AE // Inputs[2] // { // @08B0 stack[-2] // @08B0 stack[-1] // } 08AF 5B JUMPDEST 08B0 90 SWAP1 08B1 50 POP 08B2 61 PUSH2 0x07cd 08B5 56 *JUMP // Stack delta = -1 // Outputs[1] { @08B0 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x07cd label_08B6: // Incoming jump from 0x07D6, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x07D6, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x07D6, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[4] // { // @08B8 stack[-2] // @08B9 stack[-3] // @08BC stack[-6] // @08BD stack[-5] // } 08B6 5B JUMPDEST 08B7 50 POP 08B8 80 DUP1 08B9 91 SWAP2 08BA 50 POP 08BB 50 POP 08BC 92 SWAP3 08BD 91 SWAP2 08BE 50 POP 08BF 50 POP 08C0 56 *JUMP // Stack delta = -5 // Outputs[1] { @08BC stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_08C1: // Incoming jump from 0x0262 // Inputs[2] // { // @08C2 msg.sender // @08DC storage[0x00] // } 08C1 5B JUMPDEST 08C2 33 CALLER 08C3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08D8 16 AND 08D9 60 PUSH1 0x00 08DB 80 DUP1 08DC 54 SLOAD 08DD 90 SWAP1 08DE 61 PUSH2 0x0100 08E1 0A EXP 08E2 90 SWAP1 08E3 04 DIV 08E4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08F9 16 AND 08FA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 090F 16 AND 0910 14 EQ 0911 61 PUSH2 0x094f 0914 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x094f, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender label_0915: // Incoming jump from 0x0914, if not 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // Inputs[1] { @0917 memory[0x40:0x60] } 0915 60 PUSH1 0x40 0917 51 MLOAD 0918 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0939 81 DUP2 093A 52 MSTORE 093B 60 PUSH1 0x04 093D 01 ADD 093E 61 PUSH2 0x0946 0941 90 SWAP1 0942 61 PUSH2 0x15d8 0945 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @093A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0941 stack[0] = 0x0946 // @0941 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x15d8, returns to 0x0946 label_0946: // Incoming return from call to 0x15D8 at 0x0945 // Inputs[3] // { // @0949 memory[0x40:0x60] // @094B stack[-1] // @094E memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0946 5B JUMPDEST 0947 60 PUSH1 0x40 0949 51 MLOAD 094A 80 DUP1 094B 91 SWAP2 094C 03 SUB 094D 90 SWAP1 094E FD *REVERT // Stack delta = -1 // Outputs[1] { @094E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_094F: // Incoming jump from 0x0914, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // Inputs[1] { @0953 stack[-1] } 094F 5B JUMPDEST 0950 61 PUSH2 0x0958 0953 81 DUP2 0954 61 PUSH2 0x0bb7 0957 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0950 stack[0] = 0x0958 // @0953 stack[1] = stack[-1] // } // Block ends with call to 0x0bb7, returns to 0x0958 label_0958: // Incoming return from call to 0x0BB7 at 0x0957 // Inputs[1] { @095A stack[-2] } 0958 5B JUMPDEST 0959 50 POP 095A 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_095B: // Incoming call from 0x026C, returns to 0x026D // Inputs[2] // { // @095F storage[0x00] // @097D stack[-1] // } 095B 5B JUMPDEST 095C 60 PUSH1 0x00 095E 80 DUP1 095F 54 SLOAD 0960 90 SWAP1 0961 61 PUSH2 0x0100 0964 0A EXP 0965 90 SWAP1 0966 04 DIV 0967 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 097C 16 AND 097D 81 DUP2 097E 56 *JUMP // Stack delta = +1 // Outputs[1] { @097C stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_097F: // Incoming call from 0x028A, returns to 0x028B // Inputs[1] { @0983 storage[0x04] } 097F 5B JUMPDEST 0980 60 PUSH1 0x04 0982 80 DUP1 0983 54 SLOAD 0984 61 PUSH2 0x098c 0987 90 SWAP1 0988 61 PUSH2 0x18e9 098B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0980 stack[0] = 0x04 // @0987 stack[1] = 0x098c // @0987 stack[2] = storage[0x04] // } // Block ends with call to 0x18e9, returns to 0x098C label_098C: // Incoming return from call to 0x18E9 at 0x098B // Inputs[4] // { // @098D stack[-1] // @099C memory[0x40:0x60] // @09A4 stack[-2] // @09AF storage[stack[-2]] // } 098C 5B JUMPDEST 098D 80 DUP1 098E 60 PUSH1 0x1f 0990 01 ADD 0991 60 PUSH1 0x20 0993 80 DUP1 0994 91 SWAP2 0995 04 DIV 0996 02 MUL 0997 60 PUSH1 0x20 0999 01 ADD 099A 60 PUSH1 0x40 099C 51 MLOAD 099D 90 SWAP1 099E 81 DUP2 099F 01 ADD 09A0 60 PUSH1 0x40 09A2 52 MSTORE 09A3 80 DUP1 09A4 92 SWAP3 09A5 91 SWAP2 09A6 90 SWAP1 09A7 81 DUP2 09A8 81 DUP2 09A9 52 MSTORE 09AA 60 PUSH1 0x20 09AC 01 ADD 09AD 82 DUP3 09AE 80 DUP1 09AF 54 SLOAD 09B0 61 PUSH2 0x09b8 09B3 90 SWAP1 09B4 61 PUSH2 0x18e9 09B7 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @09A2 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @09A4 stack[-2] = memory[0x40:0x60] // @09A5 stack[-1] = stack[-2] // @09A6 stack[0] = stack[-1] // @09A9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @09AC stack[1] = 0x20 + memory[0x40:0x60] // @09AD stack[2] = stack[-2] // @09B3 stack[4] = storage[stack[-2]] // @09B3 stack[3] = 0x09b8 // } // Block ends with call to 0x18e9, returns to 0x09B8 label_09B8: // Incoming return from call to 0x18E9 at 0x09B7 // Inputs[1] { @09B9 stack[-1] } 09B8 5B JUMPDEST 09B9 80 DUP1 09BA 15 ISZERO 09BB 61 PUSH2 0x0a05 09BE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a05, if !stack[-1] label_09BF: // Incoming jump from 0x09BE, if not !stack[-1] // Inputs[1] { @09BF stack[-1] } 09BF 80 DUP1 09C0 60 PUSH1 0x1f 09C2 10 LT 09C3 61 PUSH2 0x09da 09C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09da, if 0x1f < stack[-1] label_09C7: // Incoming jump from 0x09C6, if not 0x1f < stack[-1] // Inputs[4] // { // @09CB stack[-2] // @09CC storage[stack[-2]] // @09CF stack[-3] // @09D1 stack[-1] // } 09C7 61 PUSH2 0x0100 09CA 80 DUP1 09CB 83 DUP4 09CC 54 SLOAD 09CD 04 DIV 09CE 02 MUL 09CF 83 DUP4 09D0 52 MSTORE 09D1 91 SWAP2 09D2 60 PUSH1 0x20 09D4 01 ADD 09D5 91 SWAP2 09D6 61 PUSH2 0x0a05 09D9 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @09D0 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @09D5 stack[-1] = stack[-1] // @09D5 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0a05 label_09DA: // Incoming jump from 0x09C6, if 0x1f < stack[-1] // Inputs[5] // { // @09DB stack[-3] // @09DC stack[-1] // @09DE stack[-2] // @09E6 memory[0x00:0x20] // @09EA storage[keccak256(memory[0x00:0x20])] // } 09DA 5B JUMPDEST 09DB 82 DUP3 09DC 01 ADD 09DD 91 SWAP2 09DE 90 SWAP1 09DF 60 PUSH1 0x00 09E1 52 MSTORE 09E2 60 PUSH1 0x20 09E4 60 PUSH1 0x00 09E6 20 SHA3 09E7 90 SWAP1 09E8 5B JUMPDEST 09E9 81 DUP2 09EA 54 SLOAD 09EB 81 DUP2 09EC 52 MSTORE 09ED 90 SWAP1 09EE 60 PUSH1 0x01 09F0 01 ADD 09F1 90 SWAP1 09F2 60 PUSH1 0x20 09F4 01 ADD 09F5 80 DUP1 09F6 83 DUP4 09F7 11 GT 09F8 61 PUSH2 0x09e8 09FB 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @09DD stack[-3] = stack[-3] + stack[-1] // @09E1 memory[0x00:0x20] = stack[-2] // @09EC memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @09F1 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @09F4 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x09e8, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_09FC: // Incoming jump from 0x09FB, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x09FB, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @09FC stack[-3] // @09FD stack[-1] // } 09FC 82 DUP3 09FD 90 SWAP1 09FE 03 SUB 09FF 60 PUSH1 0x1f 0A01 16 AND 0A02 82 DUP3 0A03 01 ADD 0A04 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0A04 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0A04 stack[-1] = stack[-3] // } // Block continues label_0A05: // Incoming jump from 0x09BE, if !stack[-1] // Incoming jump from 0x09D9 // Incoming jump from 0x0A04 // Inputs[1] { @0A0B stack[-7] } 0A05 5B JUMPDEST 0A06 50 POP 0A07 50 POP 0A08 50 POP 0A09 50 POP 0A0A 50 POP 0A0B 81 DUP2 0A0C 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0A0D: // Incoming jump from 0x02BA // Inputs[1] { @0A10 stack[-3] } 0A0D 5B JUMPDEST 0A0E 50 POP 0A0F 50 POP 0A10 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0A11: // Incoming jump from 0x02D6 // Inputs[2] // { // @0A18 stack[-3] // @0A19 stack[-2] // } 0A11 5B JUMPDEST 0A12 60 PUSH1 0x00 0A14 60 PUSH1 0x01 0A16 90 SWAP1 0A17 50 POP 0A18 92 SWAP3 0A19 91 SWAP2 0A1A 50 POP 0A1B 50 POP 0A1C 56 *JUMP // Stack delta = -2 // Outputs[1] { @0A18 stack[-3] = 0x01 } // Block ends with unconditional jump to stack[-3] label_0A1D: // Incoming jump from 0x0306 // Inputs[2] // { // @0A1E msg.sender // @0A35 stack[-5] // } 0A1D 5B JUMPDEST 0A1E 33 CALLER 0A1F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A34 16 AND 0A35 85 DUP6 0A36 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A4B 16 AND 0A4C 14 EQ 0A4D 61 PUSH2 0x0a55 0A50 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a55, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender label_0A51: // Incoming jump from 0x0A50, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // Inputs[1] { @0A54 memory[0x00:0x00] } 0A51 60 PUSH1 0x00 0A53 80 DUP1 0A54 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A54 revert(memory[0x00:0x00]); } // Block terminates label_0A55: // Incoming jump from 0x0A50, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // Inputs[5] // { // @0A59 stack[-5] // @0A5A stack[-4] // @0A5B stack[-3] // @0A5C stack[-2] // @0A5D stack[-1] // } 0A55 5B JUMPDEST 0A56 61 PUSH2 0x0a62 0A59 85 DUP6 0A5A 85 DUP6 0A5B 85 DUP6 0A5C 85 DUP6 0A5D 85 DUP6 0A5E 61 PUSH2 0x0cc0 0A61 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0A56 stack[0] = 0x0a62 // @0A59 stack[1] = stack[-5] // @0A5A stack[2] = stack[-4] // @0A5B stack[3] = stack[-3] // @0A5C stack[4] = stack[-2] // @0A5D stack[5] = stack[-1] // } // Block ends with call to 0x0cc0, returns to 0x0A62 label_0A62: // Incoming return from call to 0x0CC0 at 0x0A61 // Inputs[1] { @0A68 stack[-6] } 0A62 5B JUMPDEST 0A63 50 POP 0A64 50 POP 0A65 50 POP 0A66 50 POP 0A67 50 POP 0A68 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_0A69: // Incoming call from 0x044C, returns to 0x044D // Inputs[2] // { // @0AAC stack[-1] // @0ACF stack[-2] // } 0A69 5B JUMPDEST 0A6A 60 PUSH1 0x00 0A6C 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 0A8D 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0AAA 19 NOT 0AAB 16 AND 0AAC 82 DUP3 0AAD 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0ACA 19 NOT 0ACB 16 AND 0ACC 14 EQ 0ACD 90 SWAP1 0ACE 50 POP 0ACF 91 SWAP2 0AD0 90 SWAP1 0AD1 50 POP 0AD2 56 *JUMP // Stack delta = -1 // Outputs[1] { @0ACF stack[-2] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x01ffc9a700000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to stack[-2] label_0AD3: // Incoming call from 0x06DD, returns to 0x06DE // Incoming call from 0x04EB, returns to 0x04EC // Inputs[2] // { // @0AD4 stack[-1] // @0AD9 memory[stack[-1]:stack[-1] + 0x20] // } 0AD3 5B JUMPDEST 0AD4 80 DUP1 0AD5 60 PUSH1 0x02 0AD7 90 SWAP1 0AD8 80 DUP1 0AD9 51 MLOAD 0ADA 90 SWAP1 0ADB 60 PUSH1 0x20 0ADD 01 ADD 0ADE 90 SWAP1 0ADF 61 PUSH2 0x0ae9 0AE2 92 SWAP3 0AE3 91 SWAP2 0AE4 90 SWAP1 0AE5 61 PUSH2 0x0d45 0AE8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0AE2 stack[0] = 0x0ae9 // @0AE3 stack[1] = 0x02 // @0AE4 stack[2] = 0x20 + stack[-1] // @0AE4 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x0d45, returns to 0x0AE9 label_0AE9: // Incoming return from call to 0x0D45 at 0x0AE8 // Inputs[1] { @0AEC stack[-3] } 0AE9 5B JUMPDEST 0AEA 50 POP 0AEB 50 POP 0AEC 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0AED: // Incoming call from 0x06D4, returns to 0x06D5 // Inputs[5] // { // @0AEE msg.sender // @0AF7 storage[0x00] // @0B35 msg.sender // @0B64 msg.sender // @0BA2 memory[0x40:0x60] // } 0AED 5B JUMPDEST 0AEE 33 CALLER 0AEF 60 PUSH1 0x00 0AF1 80 DUP1 0AF2 61 PUSH2 0x0100 0AF5 0A EXP 0AF6 81 DUP2 0AF7 54 SLOAD 0AF8 81 DUP2 0AF9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B0E 02 MUL 0B0F 19 NOT 0B10 16 AND 0B11 90 SWAP1 0B12 83 DUP4 0B13 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B28 16 AND 0B29 02 MUL 0B2A 17 OR 0B2B 90 SWAP1 0B2C 55 SSTORE 0B2D 50 POP 0B2E 60 PUSH1 0x01 0B30 80 DUP1 0B31 81 DUP2 0B32 90 SWAP1 0B33 55 SSTORE 0B34 50 POP 0B35 33 CALLER 0B36 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B4B 16 AND 0B4C 60 PUSH1 0x00 0B4E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B63 16 AND 0B64 33 CALLER 0B65 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B7A 16 AND 0B7B 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 0B9C 60 PUSH1 0x00 0B9E 60 PUSH1 0x01 0BA0 60 PUSH1 0x40 0BA2 51 MLOAD 0BA3 61 PUSH2 0x0bad 0BA6 92 SWAP3 0BA7 91 SWAP2 0BA8 90 SWAP1 0BA9 61 PUSH2 0x158d 0BAC 56 *JUMP // Stack delta = +8 // Outputs[10] // { // @0B2C storage[0x00] = (0xffffffffffffffffffffffffffffffffffffffff & msg.sender) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x00]) // @0B33 storage[0x01] = 0x01 // @0B4B stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0B63 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & 0x00 // @0B7A stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0B7B stack[3] = 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 // @0BA6 stack[4] = 0x0bad // @0BA7 stack[5] = 0x00 // @0BA8 stack[6] = 0x01 // @0BA8 stack[7] = memory[0x40:0x60] // } // Block ends with call to 0x158d, returns to 0x0BAD label_0BAD: // Incoming return from call to 0x158D at 0x0BAC // Inputs[8] // { // @0BB0 memory[0x40:0x60] // @0BB2 stack[-1] // @0BB5 stack[-2] // @0BB5 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0BB5 stack[-3] // @0BB5 stack[-5] // @0BB5 stack[-4] // @0BB6 stack[-6] // } 0BAD 5B JUMPDEST 0BAE 60 PUSH1 0x40 0BB0 51 MLOAD 0BB1 80 DUP1 0BB2 91 SWAP2 0BB3 03 SUB 0BB4 90 SWAP1 0BB5 A4 LOG4 0BB6 56 *JUMP // Stack delta = -6 // Outputs[1] { @0BB5 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4], stack[-5]]); } // Block ends with unconditional jump to stack[-6] label_0BB7: // Incoming call from 0x0957, returns to 0x0958 // Inputs[2] // { // @0BBB stack[-1] // @0BBC memory[stack[-1]:stack[-1] + 0x20] // } 0BB7 5B JUMPDEST 0BB8 60 PUSH1 0x00 0BBA 5B JUMPDEST 0BBB 81 DUP2 0BBC 51 MLOAD 0BBD 81 DUP2 0BBE 10 LT 0BBF 15 ISZERO 0BC0 61 PUSH2 0x0ca2 0BC3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BB8 stack[0] = 0x00 } // Block ends with conditional jump to 0x0ca2, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0BC4: // Incoming jump from 0x0BC3, if not !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x0BC3, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0BC4 stack[-2] // @0BC5 stack[-1] // @0BC7 memory[stack[-2]:stack[-2] + 0x20] // } 0BC4 81 DUP2 0BC5 81 DUP2 0BC6 81 DUP2 0BC7 51 MLOAD 0BC8 81 DUP2 0BC9 10 LT 0BCA 61 PUSH2 0x0bfc 0BCD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0BC4 stack[0] = stack[-2] // @0BC5 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x0bfc, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_0BCE: // Incoming jump from 0x0BCD, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @0BFB memory[0x00:0x24] } 0BCE 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 0BEF 60 PUSH1 0x00 0BF1 52 MSTORE 0BF2 60 PUSH1 0x32 0BF4 60 PUSH1 0x04 0BF6 52 MSTORE 0BF7 60 PUSH1 0x24 0BF9 60 PUSH1 0x00 0BFB FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0BF1 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @0BF6 memory[0x04:0x24] = 0x32 // @0BFB revert(memory[0x00:0x24]); // } // Block terminates label_0BFC: // Incoming jump from 0x0BCD, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[7] // { // @0BFF stack[-1] // @0C03 stack[-2] // @0C04 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0C1B msg.sender // @0C32 msg.sender // @0C6A stack[-3] // @0C6D storage[0x01] // } 0BFC 5B JUMPDEST 0BFD 60 PUSH1 0x20 0BFF 02 MUL 0C00 60 PUSH1 0x20 0C02 01 ADD 0C03 01 ADD 0C04 51 MLOAD 0C05 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C1A 16 AND 0C1B 33 CALLER 0C1C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C31 16 AND 0C32 33 CALLER 0C33 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C48 16 AND 0C49 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 0C6A 84 DUP5 0C6B 60 PUSH1 0x01 0C6D 54 SLOAD 0C6E 61 PUSH2 0x0c77 0C71 91 SWAP2 0C72 90 SWAP1 0C73 61 PUSH2 0x17b9 0C76 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0C1A stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0C31 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0C48 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0C49 stack[1] = 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 // @0C71 stack[2] = 0x0c77 // @0C72 stack[4] = storage[0x01] // @0C72 stack[3] = stack[-3] // } // Block ends with call to 0x17b9, returns to 0x0C77 label_0C77: // Incoming return from call to 0x17B9 at 0x0C76 // Inputs[2] // { // @0C7C memory[0x40:0x60] // @0C80 stack[-1] // } 0C77 5B JUMPDEST 0C78 60 PUSH1 0x01 0C7A 60 PUSH1 0x40 0C7C 51 MLOAD 0C7D 61 PUSH2 0x0c87 0C80 92 SWAP3 0C81 91 SWAP2 0C82 90 SWAP1 0C83 61 PUSH2 0x1633 0C86 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0C80 stack[-1] = 0x0c87 // @0C81 stack[0] = stack[-1] // @0C82 stack[2] = memory[0x40:0x60] // @0C82 stack[1] = 0x01 // } // Block ends with call to 0x1633, returns to 0x0C87 label_0C87: // Incoming return from call to 0x1633 at 0x0C86 // Inputs[8] // { // @0C8A memory[0x40:0x60] // @0C8C stack[-1] // @0C8F stack[-3] // @0C8F stack[-4] // @0C8F stack[-5] // @0C8F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0C8F stack[-2] // @0C90 stack[-6] // } 0C87 5B JUMPDEST 0C88 60 PUSH1 0x40 0C8A 51 MLOAD 0C8B 80 DUP1 0C8C 91 SWAP2 0C8D 03 SUB 0C8E 90 SWAP1 0C8F A4 LOG4 0C90 80 DUP1 0C91 80 DUP1 0C92 61 PUSH2 0x0c9a 0C95 90 SWAP1 0C96 61 PUSH2 0x194c 0C99 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @0C8F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4], stack[-5]]); // @0C90 stack[-5] = stack[-6] // @0C95 stack[-4] = 0x0c9a // @0C95 stack[-3] = stack[-6] // } // Block ends with call to 0x194c, returns to 0x0C9A label_0C9A: // Incoming return from call to 0x194C at 0x0C99 // Inputs[2] // { // @0C9B stack[-1] // @0C9B stack[-3] // } 0C9A 5B JUMPDEST 0C9B 91 SWAP2 0C9C 50 POP 0C9D 50 POP 0C9E 61 PUSH2 0x0bba 0CA1 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C9B stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0bba label_0CA2: // Incoming jump from 0x0BC3, if !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x0BC3, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0CA4 stack[-2] // @0CA5 memory[stack[-2]:stack[-2] + 0x20] // @0CAC storage[0x01] // } 0CA2 5B JUMPDEST 0CA3 50 POP 0CA4 80 DUP1 0CA5 51 MLOAD 0CA6 60 PUSH1 0x01 0CA8 60 PUSH1 0x00 0CAA 82 DUP3 0CAB 82 DUP3 0CAC 54 SLOAD 0CAD 61 PUSH2 0x0cb6 0CB0 91 SWAP2 0CB1 90 SWAP1 0CB2 61 PUSH2 0x17b9 0CB5 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @0CA5 stack[-1] = memory[stack[-2]:stack[-2] + 0x20] // @0CA6 stack[0] = 0x01 // @0CA8 stack[1] = 0x00 // @0CB0 stack[2] = 0x0cb6 // @0CB1 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @0CB1 stack[4] = storage[0x01] // } // Block ends with call to 0x17b9, returns to 0x0CB6 label_0CB6: // Incoming return from call to 0x17B9 at 0x0CB5 // Inputs[4] // { // @0CB7 stack[-1] // @0CB7 stack[-4] // @0CBB stack[-3] // @0CBF stack[-6] // } 0CB6 5B JUMPDEST 0CB7 92 SWAP3 0CB8 50 POP 0CB9 50 POP 0CBA 81 DUP2 0CBB 90 SWAP1 0CBC 55 SSTORE 0CBD 50 POP 0CBE 50 POP 0CBF 56 *JUMP // Stack delta = -6 // Outputs[1] { @0CBC storage[stack[-3]] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0CC0: // Incoming call from 0x0A61, returns to 0x0A62 // Inputs[6] // { // @0CC1 stack[-4] // @0CD8 stack[-5] // @0CEF msg.sender // @0D27 stack[-3] // @0D28 stack[-2] // @0D2B memory[0x40:0x60] // } 0CC0 5B JUMPDEST 0CC1 83 DUP4 0CC2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CD7 16 AND 0CD8 85 DUP6 0CD9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CEE 16 AND 0CEF 33 CALLER 0CF0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D05 16 AND 0D06 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 0D27 86 DUP7 0D28 86 DUP7 0D29 60 PUSH1 0x40 0D2B 51 MLOAD 0D2C 61 PUSH2 0x0d36 0D2F 92 SWAP3 0D30 91 SWAP2 0D31 90 SWAP1 0D32 61 PUSH2 0x165c 0D35 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @0CD7 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0CEE stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0D05 stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0D06 stack[3] = 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 // @0D2F stack[4] = 0x0d36 // @0D30 stack[5] = stack[-3] // @0D31 stack[6] = stack[-2] // @0D31 stack[7] = memory[0x40:0x60] // } // Block ends with call to 0x165c, returns to 0x0D36 label_0D36: // Incoming return from call to 0x165C at 0x0D35 // Inputs[8] // { // @0D39 memory[0x40:0x60] // @0D3B stack[-1] // @0D3E stack[-4] // @0D3E stack[-3] // @0D3E memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0D3E stack[-2] // @0D3E stack[-5] // @0D44 stack[-11] // } 0D36 5B JUMPDEST 0D37 60 PUSH1 0x40 0D39 51 MLOAD 0D3A 80 DUP1 0D3B 91 SWAP2 0D3C 03 SUB 0D3D 90 SWAP1 0D3E A4 LOG4 0D3F 50 POP 0D40 50 POP 0D41 50 POP 0D42 50 POP 0D43 50 POP 0D44 56 *JUMP // Stack delta = -11 // Outputs[1] { @0D3E log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4], stack[-5]]); } // Block ends with unconditional jump to stack[-11] label_0D45: // Incoming call from 0x06F3, returns to 0x06F4 // Incoming call from 0x0AE8, returns to 0x0AE9 // Incoming call from 0x070A, returns to 0x070B // Inputs[2] // { // @0D46 stack[-3] // @0D48 storage[stack[-3]] // } 0D45 5B JUMPDEST 0D46 82 DUP3 0D47 80 DUP1 0D48 54 SLOAD 0D49 61 PUSH2 0x0d51 0D4C 90 SWAP1 0D4D 61 PUSH2 0x18e9 0D50 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D46 stack[0] = stack[-3] // @0D4C stack[1] = 0x0d51 // @0D4C stack[2] = storage[stack[-3]] // } // Block ends with call to 0x18e9, returns to 0x0D51 label_0D51: // Incoming return from call to 0x18E9 at 0x0D50 // Inputs[5] // { // @0D52 stack[-2] // @0D52 stack[-1] // @0D5A memory[0x00:0x20] // @0D65 stack[-4] // @0D66 stack[-3] // } 0D51 5B JUMPDEST 0D52 90 SWAP1 0D53 60 PUSH1 0x00 0D55 52 MSTORE 0D56 60 PUSH1 0x20 0D58 60 PUSH1 0x00 0D5A 20 SHA3 0D5B 90 SWAP1 0D5C 60 PUSH1 0x1f 0D5E 01 ADD 0D5F 60 PUSH1 0x20 0D61 90 SWAP1 0D62 04 DIV 0D63 81 DUP2 0D64 01 ADD 0D65 92 SWAP3 0D66 82 DUP3 0D67 61 PUSH2 0x0d73 0D6A 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0D55 memory[0x00:0x20] = stack[-2] // @0D5B stack[-2] = keccak256(memory[0x00:0x20]) // @0D65 stack[-1] = stack[-4] // @0D65 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x0d73, if stack[-3] label_0D6B: // Incoming jump from 0x0D6A, if not stack[-3] // Inputs[1] { @0D6D stack[-5] } 0D6B 60 PUSH1 0x00 0D6D 85 DUP6 0D6E 55 SSTORE 0D6F 61 PUSH2 0x0dba 0D72 56 *JUMP // Stack delta = +0 // Outputs[1] { @0D6E storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x0dba label_0D73: // Incoming jump from 0x0D6A, if stack[-3] // Inputs[1] { @0D74 stack[-3] } 0D73 5B JUMPDEST 0D74 82 DUP3 0D75 60 PUSH1 0x1f 0D77 10 LT 0D78 61 PUSH2 0x0d8c 0D7B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d8c, if 0x1f < stack[-3] label_0D7C: // Incoming jump from 0x0D7B, if not 0x1f < stack[-3] // Inputs[4] // { // @0D7C stack[-1] // @0D7D memory[stack[-1]:stack[-1] + 0x20] // @0D82 stack[-3] // @0D86 stack[-5] // } 0D7C 80 DUP1 0D7D 51 MLOAD 0D7E 60 PUSH1 0xff 0D80 19 NOT 0D81 16 AND 0D82 83 DUP4 0D83 80 DUP1 0D84 01 ADD 0D85 17 OR 0D86 85 DUP6 0D87 55 SSTORE 0D88 61 PUSH2 0x0dba 0D8B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0D87 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x0dba label_0D8C: // Incoming jump from 0x0D7B, if 0x1f < stack[-3] // Inputs[2] // { // @0D8D stack[-3] // @0D93 stack[-5] // } 0D8C 5B JUMPDEST 0D8D 82 DUP3 0D8E 80 DUP1 0D8F 01 ADD 0D90 60 PUSH1 0x01 0D92 01 ADD 0D93 85 DUP6 0D94 55 SSTORE 0D95 82 DUP3 0D96 15 ISZERO 0D97 61 PUSH2 0x0dba 0D9A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0D94 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x0dba, if !stack[-3] label_0D9B: // Incoming jump from 0x0D9A, if not !stack[-3] // Inputs[2] // { // @0D9B stack[-3] // @0D9B stack[-1] // } 0D9B 91 SWAP2 0D9C 82 DUP3 0D9D 01 ADD 0D9E 5B JUMPDEST 0D9F 82 DUP3 0DA0 81 DUP2 0DA1 11 GT 0DA2 15 ISZERO 0DA3 61 PUSH2 0x0db9 0DA6 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0D9B stack[-3] = stack[-1] // @0D9D stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x0db9, if !(stack[-1] + stack[-3] > stack[-1]) label_0DA7: // Incoming jump from 0x0DA6, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x0DA6, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @0DA7 stack[-3] // @0DA8 memory[stack[-3]:stack[-3] + 0x20] // @0DA9 stack[-2] // @0DAB stack[-1] // } 0DA7 82 DUP3 0DA8 51 MLOAD 0DA9 82 DUP3 0DAA 55 SSTORE 0DAB 91 SWAP2 0DAC 60 PUSH1 0x20 0DAE 01 ADD 0DAF 91 SWAP2 0DB0 90 SWAP1 0DB1 60 PUSH1 0x01 0DB3 01 ADD 0DB4 90 SWAP1 0DB5 61 PUSH2 0x0d9e 0DB8 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0DAA storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @0DAF stack[-3] = 0x20 + stack[-3] // @0DB4 stack[-2] = 0x01 + stack[-2] // @0DB4 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x0d9e label_0DB9: // Incoming jump from 0x0DA6, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x0DA6, if !(stack[-1] > stack[-3]) 0DB9 5B JUMPDEST // Stack delta = +0 // Block continues label_0DBA: // Incoming jump from 0x0DB9 // Incoming jump from 0x0D9A, if !stack[-3] // Incoming jump from 0x0D72 // Incoming jump from 0x0D8B // Inputs[3] // { // @0DBC stack[-3] // @0DBC stack[-2] // @0DC1 stack[-4] // } 0DBA 5B JUMPDEST 0DBB 50 POP 0DBC 90 SWAP1 0DBD 50 POP 0DBE 61 PUSH2 0x0dc7 0DC1 91 SWAP2 0DC2 90 SWAP1 0DC3 61 PUSH2 0x0dcb 0DC6 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0DC1 stack[-4] = 0x0dc7 // @0DC2 stack[-2] = stack[-2] // @0DC2 stack[-3] = stack[-4] // } // Block ends with call to 0x0dcb, returns to 0x0DC7 label_0DC7: // Incoming return from call to 0x0DCB at 0x0DC6 // Inputs[2] // { // @0DC9 stack[-2] // @0DC9 stack[-3] // } 0DC7 5B JUMPDEST 0DC8 50 POP 0DC9 90 SWAP1 0DCA 56 *JUMP // Stack delta = -2 // Outputs[1] { @0DC9 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_0DCB: // Incoming call from 0x0DC6, returns to 0x0DC7 // Inputs[2] // { // @0DCD stack[-1] // @0DCE stack[-2] // } 0DCB 5B JUMPDEST 0DCC 5B JUMPDEST 0DCD 80 DUP1 0DCE 82 DUP3 0DCF 11 GT 0DD0 15 ISZERO 0DD1 61 PUSH2 0x0de4 0DD4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0de4, if !(stack[-2] > stack[-1]) label_0DD5: // Incoming jump from 0x0DD4, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x0DD4, if not !(stack[-2] > stack[-1]) // Inputs[1] { @0DD7 stack[-1] } 0DD5 60 PUSH1 0x00 0DD7 81 DUP2 0DD8 60 PUSH1 0x00 0DDA 90 SWAP1 0DDB 55 SSTORE 0DDC 50 POP 0DDD 60 PUSH1 0x01 0DDF 01 ADD 0DE0 61 PUSH2 0x0dcc 0DE3 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0DDB storage[stack[-1]] = 0x00 // @0DDF stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x0dcc label_0DE4: // Incoming jump from 0x0DD4, if !(stack[-2] > stack[-1]) // Incoming jump from 0x0DD4, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @0DE6 stack[-2] // @0DE6 stack[-3] // } 0DE4 5B JUMPDEST 0DE5 50 POP 0DE6 90 SWAP1 0DE7 56 *JUMP // Stack delta = -2 // Outputs[1] { @0DE6 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_0DE8: // Incoming call from 0x0F71, returns to 0x0F72 // Inputs[1] { @0DF1 stack[-2] } 0DE8 5B JUMPDEST 0DE9 60 PUSH1 0x00 0DEB 61 PUSH2 0x0dfb 0DEE 61 PUSH2 0x0df6 0DF1 84 DUP5 0DF2 61 PUSH2 0x16aa 0DF5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0DE9 stack[0] = 0x00 // @0DEB stack[1] = 0x0dfb // @0DEE stack[2] = 0x0df6 // @0DF1 stack[3] = stack[-2] // } // Block ends with call to 0x16aa, returns to 0x0DF6 label_0DF6: // Incoming return from call to 0x16AA at 0x0DF5 0DF6 5B JUMPDEST 0DF7 61 PUSH2 0x1685 0DFA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1685 label_0DFB: // Incoming return from call to 0x0DF6 at 0x0DF5 // Inputs[5] // { // @0DFC stack[-2] // @0DFC stack[-1] // @0DFF stack[-4] // @0E08 stack[-3] // @0E09 stack[-5] // } 0DFB 5B JUMPDEST 0DFC 90 SWAP1 0DFD 50 POP 0DFE 80 DUP1 0DFF 83 DUP4 0E00 82 DUP3 0E01 52 MSTORE 0E02 60 PUSH1 0x20 0E04 82 DUP3 0E05 01 ADD 0E06 90 SWAP1 0E07 50 POP 0E08 82 DUP3 0E09 85 DUP6 0E0A 60 PUSH1 0x20 0E0C 86 DUP7 0E0D 02 MUL 0E0E 82 DUP3 0E0F 01 ADD 0E10 11 GT 0E11 15 ISZERO 0E12 61 PUSH2 0x0e1a 0E15 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0DFC stack[-2] = stack[-1] // @0E01 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @0E06 stack[-1] = stack[-1] + 0x20 // @0E08 stack[0] = stack[-3] // } // Block ends with conditional jump to 0x0e1a, if !(stack[-3] + stack[-4] * 0x20 > stack[-5]) label_0E16: // Incoming jump from 0x0E15, if not !(stack[-3] + stack[-4] * 0x20 > stack[-5]) // Inputs[1] { @0E19 memory[0x00:0x00] } 0E16 60 PUSH1 0x00 0E18 80 DUP1 0E19 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E19 revert(memory[0x00:0x00]); } // Block terminates label_0E1A: // Incoming jump from 0x0E15, if !(stack[-3] + stack[-4] * 0x20 > stack[-5]) // Inputs[1] { @0E1E stack[-5] } 0E1A 5B JUMPDEST 0E1B 60 PUSH1 0x00 0E1D 5B JUMPDEST 0E1E 85 DUP6 0E1F 81 DUP2 0E20 10 LT 0E21 15 ISZERO 0E22 61 PUSH2 0x0e4a 0E25 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E1B stack[0] = 0x00 } // Block ends with conditional jump to 0x0e4a, if !(0x00 < stack[-5]) label_0E26: // Incoming jump from 0x0E25, if not !(0x00 < stack[-5]) // Incoming jump from 0x0E25, if not !(stack[-1] < stack[-6]) // Inputs[2] // { // @0E26 stack[-2] // @0E2A stack[-7] // } 0E26 81 DUP2 0E27 61 PUSH2 0x0e30 0E2A 88 DUP9 0E2B 82 DUP3 0E2C 61 PUSH2 0x0f3c 0E2F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E26 stack[0] = stack[-2] // @0E27 stack[1] = 0x0e30 // @0E2A stack[2] = stack[-7] // @0E2B stack[3] = stack[-2] // } // Block ends with call to 0x0f3c, returns to 0x0E30 label_0E30: // Incoming return from call to 0x0F3C at 0x0E2F // Inputs[4] // { // @0E31 stack[-5] // @0E32 stack[-1] // @0E3B stack[-4] // @0E42 stack[-3] // } 0E30 5B JUMPDEST 0E31 84 DUP5 0E32 52 MSTORE 0E33 60 PUSH1 0x20 0E35 84 DUP5 0E36 01 ADD 0E37 93 SWAP4 0E38 50 POP 0E39 60 PUSH1 0x20 0E3B 83 DUP4 0E3C 01 ADD 0E3D 92 SWAP3 0E3E 50 POP 0E3F 50 POP 0E40 60 PUSH1 0x01 0E42 81 DUP2 0E43 01 ADD 0E44 90 SWAP1 0E45 50 POP 0E46 61 PUSH2 0x0e1d 0E49 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @0E32 memory[stack[-5]:stack[-5] + 0x20] = stack[-1] // @0E37 stack[-5] = stack[-5] + 0x20 // @0E3D stack[-4] = stack[-4] + 0x20 // @0E44 stack[-3] = stack[-3] + 0x01 // } // Block ends with unconditional jump to 0x0e1d label_0E4A: // Incoming jump from 0x0E25, if !(0x00 < stack[-5]) // Incoming jump from 0x0E25, if !(stack[-1] < stack[-6]) // Inputs[3] // { // @0E4E stack[-4] // @0E4E stack[-8] // @0E4F stack[-7] // } 0E4A 5B JUMPDEST 0E4B 50 POP 0E4C 50 POP 0E4D 50 POP 0E4E 93 SWAP4 0E4F 92 SWAP3 0E50 50 POP 0E51 50 POP 0E52 50 POP 0E53 56 *JUMP // Stack delta = -7 // Outputs[1] { @0E4E stack[-8] = stack[-4] } // Block ends with unconditional jump to stack[-8] label_0E54: // Incoming call from 0x0F9B, returns to 0x0F9C // Inputs[1] { @0E5D stack[-2] } 0E54 5B JUMPDEST 0E55 60 PUSH1 0x00 0E57 61 PUSH2 0x0e67 0E5A 61 PUSH2 0x0e62 0E5D 84 DUP5 0E5E 61 PUSH2 0x16d6 0E61 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E55 stack[0] = 0x00 // @0E57 stack[1] = 0x0e67 // @0E5A stack[2] = 0x0e62 // @0E5D stack[3] = stack[-2] // } // Block ends with call to 0x16d6, returns to 0x0E62 label_0E62: // Incoming return from call to 0x16D6 at 0x0E61 0E62 5B JUMPDEST 0E63 61 PUSH2 0x1685 0E66 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1685 label_0E67: // Incoming return from call to 0x0E62 at 0x0E61 // Inputs[5] // { // @0E68 stack[-2] // @0E68 stack[-1] // @0E6B stack[-4] // @0E74 stack[-3] // @0E75 stack[-5] // } 0E67 5B JUMPDEST 0E68 90 SWAP1 0E69 50 POP 0E6A 80 DUP1 0E6B 83 DUP4 0E6C 82 DUP3 0E6D 52 MSTORE 0E6E 60 PUSH1 0x20 0E70 82 DUP3 0E71 01 ADD 0E72 90 SWAP1 0E73 50 POP 0E74 82 DUP3 0E75 85 DUP6 0E76 60 PUSH1 0x20 0E78 86 DUP7 0E79 02 MUL 0E7A 82 DUP3 0E7B 01 ADD 0E7C 11 GT 0E7D 15 ISZERO 0E7E 61 PUSH2 0x0e86 0E81 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0E68 stack[-2] = stack[-1] // @0E6D memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @0E72 stack[-1] = stack[-1] + 0x20 // @0E74 stack[0] = stack[-3] // } // Block ends with conditional jump to 0x0e86, if !(stack[-3] + stack[-4] * 0x20 > stack[-5]) label_0E82: // Incoming jump from 0x0E81, if not !(stack[-3] + stack[-4] * 0x20 > stack[-5]) // Inputs[1] { @0E85 memory[0x00:0x00] } 0E82 60 PUSH1 0x00 0E84 80 DUP1 0E85 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E85 revert(memory[0x00:0x00]); } // Block terminates label_0E86: // Incoming jump from 0x0E81, if !(stack[-3] + stack[-4] * 0x20 > stack[-5]) // Inputs[1] { @0E8A stack[-5] } 0E86 5B JUMPDEST 0E87 60 PUSH1 0x00 0E89 5B JUMPDEST 0E8A 85 DUP6 0E8B 81 DUP2 0E8C 10 LT 0E8D 15 ISZERO 0E8E 61 PUSH2 0x0eb6 0E91 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E87 stack[0] = 0x00 } // Block ends with conditional jump to 0x0eb6, if !(0x00 < stack[-5]) label_0E92: // Incoming jump from 0x0E91, if not !(stack[-1] < stack[-6]) // Incoming jump from 0x0E91, if not !(0x00 < stack[-5]) // Inputs[2] // { // @0E92 stack[-2] // @0E96 stack[-7] // } 0E92 81 DUP2 0E93 61 PUSH2 0x0e9c 0E96 88 DUP9 0E97 82 DUP3 0E98 61 PUSH2 0x1023 0E9B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E92 stack[0] = stack[-2] // @0E93 stack[1] = 0x0e9c // @0E96 stack[2] = stack[-7] // @0E97 stack[3] = stack[-2] // } // Block ends with call to 0x1023, returns to 0x0E9C label_0E9C: // Incoming return from call to 0x1023 at 0x0E9B // Inputs[4] // { // @0E9D stack[-5] // @0E9E stack[-1] // @0EA7 stack[-4] // @0EAE stack[-3] // } 0E9C 5B JUMPDEST 0E9D 84 DUP5 0E9E 52 MSTORE 0E9F 60 PUSH1 0x20 0EA1 84 DUP5 0EA2 01 ADD 0EA3 93 SWAP4 0EA4 50 POP 0EA5 60 PUSH1 0x20 0EA7 83 DUP4 0EA8 01 ADD 0EA9 92 SWAP3 0EAA 50 POP 0EAB 50 POP 0EAC 60 PUSH1 0x01 0EAE 81 DUP2 0EAF 01 ADD 0EB0 90 SWAP1 0EB1 50 POP 0EB2 61 PUSH2 0x0e89 0EB5 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @0E9E memory[stack[-5]:stack[-5] + 0x20] = stack[-1] // @0EA3 stack[-5] = stack[-5] + 0x20 // @0EA9 stack[-4] = stack[-4] + 0x20 // @0EB0 stack[-3] = stack[-3] + 0x01 // } // Block ends with unconditional jump to 0x0e89 label_0EB6: // Incoming jump from 0x0E91, if !(stack[-1] < stack[-6]) // Incoming jump from 0x0E91, if !(0x00 < stack[-5]) // Inputs[3] // { // @0EBA stack[-8] // @0EBA stack[-4] // @0EBB stack[-7] // } 0EB6 5B JUMPDEST 0EB7 50 POP 0EB8 50 POP 0EB9 50 POP 0EBA 93 SWAP4 0EBB 92 SWAP3 0EBC 50 POP 0EBD 50 POP 0EBE 50 POP 0EBF 56 *JUMP // Stack delta = -7 // Outputs[1] { @0EBA stack[-8] = stack[-4] } // Block ends with unconditional jump to stack[-8] label_0EC0: // Incoming call from 0x0FEF, returns to 0x0FF0 // Inputs[1] { @0EC9 stack[-2] } 0EC0 5B JUMPDEST 0EC1 60 PUSH1 0x00 0EC3 61 PUSH2 0x0ed3 0EC6 61 PUSH2 0x0ece 0EC9 84 DUP5 0ECA 61 PUSH2 0x1702 0ECD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EC1 stack[0] = 0x00 // @0EC3 stack[1] = 0x0ed3 // @0EC6 stack[2] = 0x0ece // @0EC9 stack[3] = stack[-2] // } // Block ends with call to 0x1702, returns to 0x0ECE label_0ECE: // Incoming return from call to 0x1702 at 0x0ECD 0ECE 5B JUMPDEST 0ECF 61 PUSH2 0x1685 0ED2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1685 label_0ED3: // Incoming return from call to 0x0ECE at 0x0ECD // Inputs[5] // { // @0ED4 stack[-1] // @0ED4 stack[-2] // @0ED6 stack[-4] // @0EDD stack[-5] // @0EDF stack[-3] // } 0ED3 5B JUMPDEST 0ED4 90 SWAP1 0ED5 50 POP 0ED6 82 DUP3 0ED7 81 DUP2 0ED8 52 MSTORE 0ED9 60 PUSH1 0x20 0EDB 81 DUP2 0EDC 01 ADD 0EDD 84 DUP5 0EDE 84 DUP5 0EDF 84 DUP5 0EE0 01 ADD 0EE1 11 GT 0EE2 15 ISZERO 0EE3 61 PUSH2 0x0eeb 0EE6 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @0ED4 stack[-2] = stack[-1] // @0ED8 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @0EDC stack[-1] = stack[-1] + 0x20 // } // Block ends with conditional jump to 0x0eeb, if !(stack[-3] + stack[-4] > stack[-5]) label_0EE7: // Incoming jump from 0x0EE6, if not !(stack[-3] + stack[-4] > stack[-5]) // Inputs[1] { @0EEA memory[0x00:0x00] } 0EE7 60 PUSH1 0x00 0EE9 80 DUP1 0EEA FD *REVERT // Stack delta = +0 // Outputs[1] { @0EEA revert(memory[0x00:0x00]); } // Block terminates label_0EEB: // Incoming jump from 0x0EE6, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[3] // { // @0EEF stack[-4] // @0EF0 stack[-1] // @0EF1 stack[-3] // } 0EEB 5B JUMPDEST 0EEC 61 PUSH2 0x0ef6 0EEF 84 DUP5 0EF0 82 DUP3 0EF1 85 DUP6 0EF2 61 PUSH2 0x18a7 0EF5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EEC stack[0] = 0x0ef6 // @0EEF stack[1] = stack[-4] // @0EF0 stack[2] = stack[-1] // @0EF1 stack[3] = stack[-3] // } // Block ends with call to 0x18a7, returns to 0x0EF6 label_0EF6: // Incoming return from call to 0x18A7 at 0x0EF5 // Inputs[3] // { // @0EF8 stack[-6] // @0EF8 stack[-2] // @0EF9 stack[-5] // } 0EF6 5B JUMPDEST 0EF7 50 POP 0EF8 93 SWAP4 0EF9 92 SWAP3 0EFA 50 POP 0EFB 50 POP 0EFC 50 POP 0EFD 56 *JUMP // Stack delta = -5 // Outputs[1] { @0EF8 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_0EFE: // Incoming call from 0x1019, returns to 0x101A // Inputs[1] { @0F07 stack[-2] } 0EFE 5B JUMPDEST 0EFF 60 PUSH1 0x00 0F01 61 PUSH2 0x0f11 0F04 61 PUSH2 0x0f0c 0F07 84 DUP5 0F08 61 PUSH2 0x1733 0F0B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EFF stack[0] = 0x00 // @0F01 stack[1] = 0x0f11 // @0F04 stack[2] = 0x0f0c // @0F07 stack[3] = stack[-2] // } // Block ends with call to 0x1733, returns to 0x0F0C label_0F0C: // Incoming return from call to 0x1733 at 0x0F0B 0F0C 5B JUMPDEST 0F0D 61 PUSH2 0x1685 0F10 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1685 label_0F11: // Incoming return from call to 0x0F0C at 0x0F0B // Inputs[5] // { // @0F12 stack[-1] // @0F12 stack[-2] // @0F14 stack[-4] // @0F1B stack[-5] // @0F1D stack[-3] // } 0F11 5B JUMPDEST 0F12 90 SWAP1 0F13 50 POP 0F14 82 DUP3 0F15 81 DUP2 0F16 52 MSTORE 0F17 60 PUSH1 0x20 0F19 81 DUP2 0F1A 01 ADD 0F1B 84 DUP5 0F1C 84 DUP5 0F1D 84 DUP5 0F1E 01 ADD 0F1F 11 GT 0F20 15 ISZERO 0F21 61 PUSH2 0x0f29 0F24 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @0F12 stack[-2] = stack[-1] // @0F16 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @0F1A stack[-1] = stack[-1] + 0x20 // } // Block ends with conditional jump to 0x0f29, if !(stack[-3] + stack[-4] > stack[-5]) label_0F25: // Incoming jump from 0x0F24, if not !(stack[-3] + stack[-4] > stack[-5]) // Inputs[1] { @0F28 memory[0x00:0x00] } 0F25 60 PUSH1 0x00 0F27 80 DUP1 0F28 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F28 revert(memory[0x00:0x00]); } // Block terminates label_0F29: // Incoming jump from 0x0F24, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[3] // { // @0F2D stack[-4] // @0F2E stack[-1] // @0F2F stack[-3] // } 0F29 5B JUMPDEST 0F2A 61 PUSH2 0x0f34 0F2D 84 DUP5 0F2E 82 DUP3 0F2F 85 DUP6 0F30 61 PUSH2 0x18a7 0F33 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F2A stack[0] = 0x0f34 // @0F2D stack[1] = stack[-4] // @0F2E stack[2] = stack[-1] // @0F2F stack[3] = stack[-3] // } // Block ends with call to 0x18a7, returns to 0x0F34 label_0F34: // Incoming return from call to 0x18A7 at 0x0F33 // Inputs[3] // { // @0F36 stack[-6] // @0F36 stack[-2] // @0F37 stack[-5] // } 0F34 5B JUMPDEST 0F35 50 POP 0F36 93 SWAP4 0F37 92 SWAP3 0F38 50 POP 0F39 50 POP 0F3A 50 POP 0F3B 56 *JUMP // Stack delta = -5 // Outputs[1] { @0F36 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_0F3C: // Incoming call from 0x11E2, returns to 0x11E3 // Incoming call from 0x1058, returns to 0x1059 // Incoming call from 0x1099, returns to 0x109A // Incoming call from 0x0E2F, returns to 0x0E30 // Incoming call from 0x1169, returns to 0x116A // Incoming call from 0x1069, returns to 0x106A // Incoming call from 0x1158, returns to 0x1159 // Incoming call from 0x10AA, returns to 0x10AB // Incoming call from 0x121E, returns to 0x121F // Inputs[2] // { // @0F3F stack[-1] // @0F40 msg.data[stack[-1]:stack[-1] + 0x20] // } 0F3C 5B JUMPDEST 0F3D 60 PUSH1 0x00 0F3F 81 DUP2 0F40 35 CALLDATALOAD 0F41 90 SWAP1 0F42 50 POP 0F43 61 PUSH2 0x0f4b 0F46 81 DUP2 0F47 61 PUSH2 0x1aab 0F4A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F41 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @0F43 stack[1] = 0x0f4b // @0F46 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x1aab, returns to 0x0F4B label_0F4B: // Incoming return from call to 0x1AAB at 0x0F4A // Inputs[3] // { // @0F4C stack[-4] // @0F4C stack[-1] // @0F4D stack[-3] // } 0F4B 5B JUMPDEST 0F4C 92 SWAP3 0F4D 91 SWAP2 0F4E 50 POP 0F4F 50 POP 0F50 56 *JUMP // Stack delta = -3 // Outputs[1] { @0F4C stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0F51: // Incoming call from 0x1271, returns to 0x1272 // Incoming call from 0x12B3, returns to 0x12B4 // Inputs[2] // { // @0F54 stack[-2] // @0F57 stack[-1] // } 0F51 5B JUMPDEST 0F52 60 PUSH1 0x00 0F54 82 DUP3 0F55 60 PUSH1 0x1f 0F57 83 DUP4 0F58 01 ADD 0F59 12 SLT 0F5A 61 PUSH2 0x0f62 0F5D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0F52 stack[0] = 0x00 } // Block ends with conditional jump to 0x0f62, if stack[-1] + 0x1f i< stack[-2] label_0F5E: // Incoming jump from 0x0F5D, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @0F61 memory[0x00:0x00] } 0F5E 60 PUSH1 0x00 0F60 80 DUP1 0F61 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F61 revert(memory[0x00:0x00]); } // Block terminates label_0F62: // Incoming jump from 0x0F5D, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @0F63 stack[-2] // @0F64 msg.data[stack[-2]:stack[-2] + 0x20] // @0F68 stack[-3] // } 0F62 5B JUMPDEST 0F63 81 DUP2 0F64 35 CALLDATALOAD 0F65 61 PUSH2 0x0f72 0F68 84 DUP5 0F69 82 DUP3 0F6A 60 PUSH1 0x20 0F6C 86 DUP7 0F6D 01 ADD 0F6E 61 PUSH2 0x0de8 0F71 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0F64 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @0F65 stack[1] = 0x0f72 // @0F68 stack[2] = stack[-3] // @0F69 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // @0F6D stack[4] = stack[-2] + 0x20 // } // Block ends with call to 0x0de8, returns to 0x0F72 label_0F72: // Incoming return from call to 0x0DE8 at 0x0F71 // Inputs[4] // { // @0F73 stack[-3] // @0F73 stack[-1] // @0F76 stack[-6] // @0F77 stack[-5] // } 0F72 5B JUMPDEST 0F73 91 SWAP2 0F74 50 POP 0F75 50 POP 0F76 92 SWAP3 0F77 91 SWAP2 0F78 50 POP 0F79 50 POP 0F7A 56 *JUMP // Stack delta = -5 // Outputs[1] { @0F76 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0F7B: // Incoming call from 0x12DC, returns to 0x12DD // Incoming call from 0x10D3, returns to 0x10D4 // Incoming call from 0x10FC, returns to 0x10FD // Inputs[2] // { // @0F7E stack[-2] // @0F81 stack[-1] // } 0F7B 5B JUMPDEST 0F7C 60 PUSH1 0x00 0F7E 82 DUP3 0F7F 60 PUSH1 0x1f 0F81 83 DUP4 0F82 01 ADD 0F83 12 SLT 0F84 61 PUSH2 0x0f8c 0F87 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0F7C stack[0] = 0x00 } // Block ends with conditional jump to 0x0f8c, if stack[-1] + 0x1f i< stack[-2] label_0F88: // Incoming jump from 0x0F87, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @0F8B memory[0x00:0x00] } 0F88 60 PUSH1 0x00 0F8A 80 DUP1 0F8B FD *REVERT // Stack delta = +0 // Outputs[1] { @0F8B revert(memory[0x00:0x00]); } // Block terminates label_0F8C: // Incoming jump from 0x0F87, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @0F8D stack[-2] // @0F8E msg.data[stack[-2]:stack[-2] + 0x20] // @0F92 stack[-3] // } 0F8C 5B JUMPDEST 0F8D 81 DUP2 0F8E 35 CALLDATALOAD 0F8F 61 PUSH2 0x0f9c 0F92 84 DUP5 0F93 82 DUP3 0F94 60 PUSH1 0x20 0F96 86 DUP7 0F97 01 ADD 0F98 61 PUSH2 0x0e54 0F9B 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0F8E stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @0F8F stack[1] = 0x0f9c // @0F92 stack[2] = stack[-3] // @0F93 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // @0F97 stack[4] = stack[-2] + 0x20 // } // Block ends with call to 0x0e54, returns to 0x0F9C label_0F9C: // Incoming return from call to 0x0E54 at 0x0F9B // Inputs[4] // { // @0F9D stack[-1] // @0F9D stack[-3] // @0FA0 stack[-6] // @0FA1 stack[-5] // } 0F9C 5B JUMPDEST 0F9D 91 SWAP2 0F9E 50 POP 0F9F 50 POP 0FA0 92 SWAP3 0FA1 91 SWAP2 0FA2 50 POP 0FA3 50 POP 0FA4 56 *JUMP // Stack delta = -5 // Outputs[1] { @0FA0 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0FA5: // Incoming call from 0x11F3, returns to 0x11F4 // Inputs[2] // { // @0FA8 stack[-1] // @0FA9 msg.data[stack[-1]:stack[-1] + 0x20] // } 0FA5 5B JUMPDEST 0FA6 60 PUSH1 0x00 0FA8 81 DUP2 0FA9 35 CALLDATALOAD 0FAA 90 SWAP1 0FAB 50 POP 0FAC 61 PUSH2 0x0fb4 0FAF 81 DUP2 0FB0 61 PUSH2 0x1ac2 0FB3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FAA stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @0FAC stack[1] = 0x0fb4 // @0FAF stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x1ac2, returns to 0x0FB4 label_0FB4: // Incoming return from call to 0x1AC2 at 0x0FB3 // Inputs[3] // { // @0FB5 stack[-1] // @0FB5 stack[-4] // @0FB6 stack[-3] // } 0FB4 5B JUMPDEST 0FB5 92 SWAP3 0FB6 91 SWAP2 0FB7 50 POP 0FB8 50 POP 0FB9 56 *JUMP // Stack delta = -3 // Outputs[1] { @0FB5 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0FBA: // Incoming call from 0x1306, returns to 0x1307 // Inputs[2] // { // @0FBD stack[-1] // @0FBE msg.data[stack[-1]:stack[-1] + 0x20] // } 0FBA 5B JUMPDEST 0FBB 60 PUSH1 0x00 0FBD 81 DUP2 0FBE 35 CALLDATALOAD 0FBF 90 SWAP1 0FC0 50 POP 0FC1 61 PUSH2 0x0fc9 0FC4 81 DUP2 0FC5 61 PUSH2 0x1ad9 0FC8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FBF stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @0FC1 stack[1] = 0x0fc9 // @0FC4 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x1ad9, returns to 0x0FC9 label_0FC9: // Incoming return from call to 0x1AD9 at 0x0FC8 // Inputs[3] // { // @0FCA stack[-4] // @0FCA stack[-1] // @0FCB stack[-3] // } 0FC9 5B JUMPDEST 0FCA 92 SWAP3 0FCB 91 SWAP2 0FCC 50 POP 0FCD 50 POP 0FCE 56 *JUMP // Stack delta = -3 // Outputs[1] { @0FCA stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0FCF: // Incoming call from 0x1125, returns to 0x1126 // Incoming call from 0x11B4, returns to 0x11B5 // Inputs[2] // { // @0FD2 stack[-2] // @0FD5 stack[-1] // } 0FCF 5B JUMPDEST 0FD0 60 PUSH1 0x00 0FD2 82 DUP3 0FD3 60 PUSH1 0x1f 0FD5 83 DUP4 0FD6 01 ADD 0FD7 12 SLT 0FD8 61 PUSH2 0x0fe0 0FDB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0FD0 stack[0] = 0x00 } // Block ends with conditional jump to 0x0fe0, if stack[-1] + 0x1f i< stack[-2] label_0FDC: // Incoming jump from 0x0FDB, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @0FDF memory[0x00:0x00] } 0FDC 60 PUSH1 0x00 0FDE 80 DUP1 0FDF FD *REVERT // Stack delta = +0 // Outputs[1] { @0FDF revert(memory[0x00:0x00]); } // Block terminates label_0FE0: // Incoming jump from 0x0FDB, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @0FE1 stack[-2] // @0FE2 msg.data[stack[-2]:stack[-2] + 0x20] // @0FE6 stack[-3] // } 0FE0 5B JUMPDEST 0FE1 81 DUP2 0FE2 35 CALLDATALOAD 0FE3 61 PUSH2 0x0ff0 0FE6 84 DUP5 0FE7 82 DUP3 0FE8 60 PUSH1 0x20 0FEA 86 DUP7 0FEB 01 ADD 0FEC 61 PUSH2 0x0ec0 0FEF 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0FE2 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @0FE3 stack[1] = 0x0ff0 // @0FE6 stack[2] = stack[-3] // @0FE7 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // @0FEB stack[4] = stack[-2] + 0x20 // } // Block ends with call to 0x0ec0, returns to 0x0FF0 label_0FF0: // Incoming return from call to 0x0EC0 at 0x0FEF // Inputs[4] // { // @0FF1 stack[-3] // @0FF1 stack[-1] // @0FF4 stack[-6] // @0FF5 stack[-5] // } 0FF0 5B JUMPDEST 0FF1 91 SWAP2 0FF2 50 POP 0FF3 50 POP 0FF4 92 SWAP3 0FF5 91 SWAP2 0FF6 50 POP 0FF7 50 POP 0FF8 56 *JUMP // Stack delta = -5 // Outputs[1] { @0FF4 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0FF9: // Incoming call from 0x13B2, returns to 0x13B3 // Incoming call from 0x1389, returns to 0x138A // Incoming call from 0x1347, returns to 0x1348 // Inputs[2] // { // @0FFC stack[-2] // @0FFF stack[-1] // } 0FF9 5B JUMPDEST 0FFA 60 PUSH1 0x00 0FFC 82 DUP3 0FFD 60 PUSH1 0x1f 0FFF 83 DUP4 1000 01 ADD 1001 12 SLT 1002 61 PUSH2 0x100a 1005 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0FFA stack[0] = 0x00 } // Block ends with conditional jump to 0x100a, if stack[-1] + 0x1f i< stack[-2] label_1006: // Incoming jump from 0x1005, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @1009 memory[0x00:0x00] } 1006 60 PUSH1 0x00 1008 80 DUP1 1009 FD *REVERT // Stack delta = +0 // Outputs[1] { @1009 revert(memory[0x00:0x00]); } // Block terminates label_100A: // Incoming jump from 0x1005, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @100B stack[-2] // @100C msg.data[stack[-2]:stack[-2] + 0x20] // @1010 stack[-3] // } 100A 5B JUMPDEST 100B 81 DUP2 100C 35 CALLDATALOAD 100D 61 PUSH2 0x101a 1010 84 DUP5 1011 82 DUP3 1012 60 PUSH1 0x20 1014 86 DUP7 1015 01 ADD 1016 61 PUSH2 0x0efe 1019 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @100C stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @100D stack[1] = 0x101a // @1010 stack[2] = stack[-3] // @1011 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // @1015 stack[4] = stack[-2] + 0x20 // } // Block ends with call to 0x0efe, returns to 0x101A label_101A: // Incoming return from call to 0x0EFE at 0x1019 // Inputs[4] // { // @101B stack[-1] // @101B stack[-3] // @101E stack[-6] // @101F stack[-5] // } 101A 5B JUMPDEST 101B 91 SWAP2 101C 50 POP 101D 50 POP 101E 92 SWAP3 101F 91 SWAP2 1020 50 POP 1021 50 POP 1022 56 *JUMP // Stack delta = -5 // Outputs[1] { @101E stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1023: // Incoming call from 0x13DC, returns to 0x13DD // Incoming call from 0x118B, returns to 0x118C // Incoming call from 0x0E9B, returns to 0x0E9C // Incoming call from 0x122F, returns to 0x1230 // Incoming call from 0x117A, returns to 0x117B // Inputs[2] // { // @1026 stack[-1] // @1027 msg.data[stack[-1]:stack[-1] + 0x20] // } 1023 5B JUMPDEST 1024 60 PUSH1 0x00 1026 81 DUP2 1027 35 CALLDATALOAD 1028 90 SWAP1 1029 50 POP 102A 61 PUSH2 0x1032 102D 81 DUP2 102E 61 PUSH2 0x1af0 1031 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1028 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @102A stack[1] = 0x1032 // @102D stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x1af0, returns to 0x1032 label_1032: // Incoming return from call to 0x1AF0 at 0x1031 // Inputs[3] // { // @1033 stack[-1] // @1033 stack[-4] // @1034 stack[-3] // } 1032 5B JUMPDEST 1033 92 SWAP3 1034 91 SWAP2 1035 50 POP 1036 50 POP 1037 56 *JUMP // Stack delta = -3 // Outputs[1] { @1033 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1038: // Incoming call from 0x02D1, returns to 0x02D2 // Inputs[2] // { // @103E stack[-1] // @103F stack[-2] // } 1038 5B JUMPDEST 1039 60 PUSH1 0x00 103B 80 DUP1 103C 60 PUSH1 0x40 103E 83 DUP4 103F 85 DUP6 1040 03 SUB 1041 12 SLT 1042 15 ISZERO 1043 61 PUSH2 0x104b 1046 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1039 stack[0] = 0x00 // @103B stack[1] = 0x00 // } // Block ends with conditional jump to 0x104b, if !(stack[-2] - stack[-1] i< 0x40) label_1047: // Incoming jump from 0x1046, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @104A memory[0x00:0x00] } 1047 60 PUSH1 0x00 1049 80 DUP1 104A FD *REVERT // Stack delta = +0 // Outputs[1] { @104A revert(memory[0x00:0x00]); } // Block terminates label_104B: // Incoming jump from 0x1046, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1051 stack[-4] // @1053 stack[-3] // } 104B 5B JUMPDEST 104C 60 PUSH1 0x00 104E 61 PUSH2 0x1059 1051 85 DUP6 1052 82 DUP3 1053 86 DUP7 1054 01 ADD 1055 61 PUSH2 0x0f3c 1058 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @104C stack[0] = 0x00 // @104E stack[1] = 0x1059 // @1051 stack[2] = stack[-4] // @1054 stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x0f3c, returns to 0x1059 label_1059: // Incoming return from call to 0x0F3C at 0x1058 // Inputs[4] // { // @105A stack[-1] // @105A stack[-4] // @1062 stack[-6] // @1064 stack[-5] // } 1059 5B JUMPDEST 105A 92 SWAP3 105B 50 POP 105C 50 POP 105D 60 PUSH1 0x20 105F 61 PUSH2 0x106a 1062 85 DUP6 1063 82 DUP3 1064 86 DUP7 1065 01 ADD 1066 61 PUSH2 0x0f3c 1069 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @105A stack[-4] = stack[-1] // @105D stack[-2] = 0x20 // @105F stack[-1] = 0x106a // @1062 stack[0] = stack[-6] // @1065 stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x0f3c, returns to 0x106A label_106A: // Incoming return from call to 0x0F3C at 0x1069 // Inputs[6] // { // @106B stack[-1] // @106B stack[-3] // @106E stack[-6] // @1070 stack[-7] // @1070 stack[-4] // @1071 stack[-5] // } 106A 5B JUMPDEST 106B 91 SWAP2 106C 50 POP 106D 50 POP 106E 92 SWAP3 106F 50 POP 1070 92 SWAP3 1071 90 SWAP1 1072 50 POP 1073 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @106E stack[-6] = stack[-1] // @1070 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1074: // Incoming call from 0x01F5, returns to 0x01F6 // Inputs[2] // { // @107F stack[-1] // @1080 stack[-2] // } 1074 5B JUMPDEST 1075 60 PUSH1 0x00 1077 80 DUP1 1078 60 PUSH1 0x00 107A 80 DUP1 107B 60 PUSH1 0x00 107D 60 PUSH1 0xa0 107F 86 DUP7 1080 88 DUP9 1081 03 SUB 1082 12 SLT 1083 15 ISZERO 1084 61 PUSH2 0x108c 1087 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1075 stack[0] = 0x00 // @1077 stack[1] = 0x00 // @1078 stack[2] = 0x00 // @107A stack[3] = 0x00 // @107B stack[4] = 0x00 // } // Block ends with conditional jump to 0x108c, if !(stack[-2] - stack[-1] i< 0xa0) label_1088: // Incoming jump from 0x1087, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @108B memory[0x00:0x00] } 1088 60 PUSH1 0x00 108A 80 DUP1 108B FD *REVERT // Stack delta = +0 // Outputs[1] { @108B revert(memory[0x00:0x00]); } // Block terminates label_108C: // Incoming jump from 0x1087, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @1092 stack[-7] // @1094 stack[-6] // } 108C 5B JUMPDEST 108D 60 PUSH1 0x00 108F 61 PUSH2 0x109a 1092 88 DUP9 1093 82 DUP3 1094 89 DUP10 1095 01 ADD 1096 61 PUSH2 0x0f3c 1099 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @108D stack[0] = 0x00 // @108F stack[1] = 0x109a // @1092 stack[2] = stack[-7] // @1095 stack[3] = stack[-6] + 0x00 // } // Block ends with call to 0x0f3c, returns to 0x109A label_109A: // Incoming return from call to 0x0F3C at 0x1099 // Inputs[4] // { // @109B stack[-1] // @109B stack[-7] // @10A3 stack[-9] // @10A5 stack[-8] // } 109A 5B JUMPDEST 109B 95 SWAP6 109C 50 POP 109D 50 POP 109E 60 PUSH1 0x20 10A0 61 PUSH2 0x10ab 10A3 88 DUP9 10A4 82 DUP3 10A5 89 DUP10 10A6 01 ADD 10A7 61 PUSH2 0x0f3c 10AA 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @109B stack[-7] = stack[-1] // @109E stack[-2] = 0x20 // @10A0 stack[-1] = 0x10ab // @10A3 stack[0] = stack[-9] // @10A6 stack[1] = stack[-8] + 0x20 // } // Block ends with call to 0x0f3c, returns to 0x10AB label_10AB: // Incoming return from call to 0x0F3C at 0x10AA // Inputs[4] // { // @10AC stack[-1] // @10AC stack[-6] // @10B1 stack[-8] // @10B3 msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] // } 10AB 5B JUMPDEST 10AC 94 SWAP5 10AD 50 POP 10AE 50 POP 10AF 60 PUSH1 0x40 10B1 86 DUP7 10B2 01 ADD 10B3 35 CALLDATALOAD 10B4 67 PUSH8 0xffffffffffffffff 10BD 81 DUP2 10BE 11 GT 10BF 15 ISZERO 10C0 61 PUSH2 0x10c8 10C3 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @10AC stack[-6] = stack[-1] // @10B3 stack[-2] = msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x10c8, if !(msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] > 0xffffffffffffffff) label_10C4: // Incoming jump from 0x10C3, if not !(msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @10C7 memory[0x00:0x00] } 10C4 60 PUSH1 0x00 10C6 80 DUP1 10C7 FD *REVERT // Stack delta = +0 // Outputs[1] { @10C7 revert(memory[0x00:0x00]); } // Block terminates label_10C8: // Incoming jump from 0x10C3, if !(msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @10CC stack[-8] // @10CD stack[-1] // @10CE stack[-7] // } 10C8 5B JUMPDEST 10C9 61 PUSH2 0x10d4 10CC 88 DUP9 10CD 82 DUP3 10CE 89 DUP10 10CF 01 ADD 10D0 61 PUSH2 0x0f7b 10D3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10C9 stack[0] = 0x10d4 // @10CC stack[1] = stack[-8] // @10CF stack[2] = stack[-7] + stack[-1] // } // Block ends with call to 0x0f7b, returns to 0x10D4 label_10D4: // Incoming return from call to 0x0F7B at 0x10D3 // Inputs[4] // { // @10D5 stack[-1] // @10D5 stack[-5] // @10DA stack[-8] // @10DC msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] // } 10D4 5B JUMPDEST 10D5 93 SWAP4 10D6 50 POP 10D7 50 POP 10D8 60 PUSH1 0x60 10DA 86 DUP7 10DB 01 ADD 10DC 35 CALLDATALOAD 10DD 67 PUSH8 0xffffffffffffffff 10E6 81 DUP2 10E7 11 GT 10E8 15 ISZERO 10E9 61 PUSH2 0x10f1 10EC 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @10D5 stack[-5] = stack[-1] // @10DC stack[-2] = msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x10f1, if !(msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] > 0xffffffffffffffff) label_10ED: // Incoming jump from 0x10EC, if not !(msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @10F0 memory[0x00:0x00] } 10ED 60 PUSH1 0x00 10EF 80 DUP1 10F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @10F0 revert(memory[0x00:0x00]); } // Block terminates label_10F1: // Incoming jump from 0x10EC, if !(msg.data[stack[-8] + 0x60:stack[-8] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @10F5 stack[-8] // @10F6 stack[-1] // @10F7 stack[-7] // } 10F1 5B JUMPDEST 10F2 61 PUSH2 0x10fd 10F5 88 DUP9 10F6 82 DUP3 10F7 89 DUP10 10F8 01 ADD 10F9 61 PUSH2 0x0f7b 10FC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10F2 stack[0] = 0x10fd // @10F5 stack[1] = stack[-8] // @10F8 stack[2] = stack[-7] + stack[-1] // } // Block ends with call to 0x0f7b, returns to 0x10FD label_10FD: // Incoming return from call to 0x0F7B at 0x10FC // Inputs[4] // { // @10FE stack[-4] // @10FE stack[-1] // @1103 stack[-8] // @1105 msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] // } 10FD 5B JUMPDEST 10FE 92 SWAP3 10FF 50 POP 1100 50 POP 1101 60 PUSH1 0x80 1103 86 DUP7 1104 01 ADD 1105 35 CALLDATALOAD 1106 67 PUSH8 0xffffffffffffffff 110F 81 DUP2 1110 11 GT 1111 15 ISZERO 1112 61 PUSH2 0x111a 1115 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @10FE stack[-4] = stack[-1] // @1105 stack[-2] = msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x111a, if !(msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] > 0xffffffffffffffff) label_1116: // Incoming jump from 0x1115, if not !(msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1119 memory[0x00:0x00] } 1116 60 PUSH1 0x00 1118 80 DUP1 1119 FD *REVERT // Stack delta = +0 // Outputs[1] { @1119 revert(memory[0x00:0x00]); } // Block terminates label_111A: // Incoming jump from 0x1115, if !(msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @111E stack[-8] // @111F stack[-1] // @1120 stack[-7] // } 111A 5B JUMPDEST 111B 61 PUSH2 0x1126 111E 88 DUP9 111F 82 DUP3 1120 89 DUP10 1121 01 ADD 1122 61 PUSH2 0x0fcf 1125 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @111B stack[0] = 0x1126 // @111E stack[1] = stack[-8] // @1121 stack[2] = stack[-7] + stack[-1] // } // Block ends with call to 0x0fcf, returns to 0x1126 label_1126: // Incoming return from call to 0x0FCF at 0x1125 // Inputs[9] // { // @1127 stack[-1] // @1127 stack[-3] // @112A stack[-6] // @112B stack[-9] // @112D stack[-7] // @112D stack[-4] // @112E stack[-10] // @112F stack[-5] // @1130 stack[-8] // } 1126 5B JUMPDEST 1127 91 SWAP2 1128 50 POP 1129 50 POP 112A 92 SWAP3 112B 95 SWAP6 112C 50 POP 112D 92 SWAP3 112E 95 SWAP6 112F 90 SWAP1 1130 93 SWAP4 1131 50 POP 1132 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @112A stack[-6] = stack[-1] // @112B stack[-9] = stack[-6] // @112D stack[-7] = stack[-4] // @112E stack[-10] = stack[-7] // @1130 stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-10] label_1133: // Incoming call from 0x0301, returns to 0x0302 // Inputs[2] // { // @113E stack[-1] // @113F stack[-2] // } 1133 5B JUMPDEST 1134 60 PUSH1 0x00 1136 80 DUP1 1137 60 PUSH1 0x00 1139 80 DUP1 113A 60 PUSH1 0x00 113C 60 PUSH1 0xa0 113E 86 DUP7 113F 88 DUP9 1140 03 SUB 1141 12 SLT 1142 15 ISZERO 1143 61 PUSH2 0x114b 1146 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1134 stack[0] = 0x00 // @1136 stack[1] = 0x00 // @1137 stack[2] = 0x00 // @1139 stack[3] = 0x00 // @113A stack[4] = 0x00 // } // Block ends with conditional jump to 0x114b, if !(stack[-2] - stack[-1] i< 0xa0) label_1147: // Incoming jump from 0x1146, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @114A memory[0x00:0x00] } 1147 60 PUSH1 0x00 1149 80 DUP1 114A FD *REVERT // Stack delta = +0 // Outputs[1] { @114A revert(memory[0x00:0x00]); } // Block terminates label_114B: // Incoming jump from 0x1146, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @1151 stack[-7] // @1153 stack[-6] // } 114B 5B JUMPDEST 114C 60 PUSH1 0x00 114E 61 PUSH2 0x1159 1151 88 DUP9 1152 82 DUP3 1153 89 DUP10 1154 01 ADD 1155 61 PUSH2 0x0f3c 1158 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @114C stack[0] = 0x00 // @114E stack[1] = 0x1159 // @1151 stack[2] = stack[-7] // @1154 stack[3] = stack[-6] + 0x00 // } // Block ends with call to 0x0f3c, returns to 0x1159 label_1159: // Incoming return from call to 0x0F3C at 0x1158 // Inputs[4] // { // @115A stack[-1] // @115A stack[-7] // @1162 stack[-9] // @1164 stack[-8] // } 1159 5B JUMPDEST 115A 95 SWAP6 115B 50 POP 115C 50 POP 115D 60 PUSH1 0x20 115F 61 PUSH2 0x116a 1162 88 DUP9 1163 82 DUP3 1164 89 DUP10 1165 01 ADD 1166 61 PUSH2 0x0f3c 1169 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @115A stack[-7] = stack[-1] // @115D stack[-2] = 0x20 // @115F stack[-1] = 0x116a // @1162 stack[0] = stack[-9] // @1165 stack[1] = stack[-8] + 0x20 // } // Block ends with call to 0x0f3c, returns to 0x116A label_116A: // Incoming return from call to 0x0F3C at 0x1169 // Inputs[4] // { // @116B stack[-1] // @116B stack[-6] // @1173 stack[-9] // @1175 stack[-8] // } 116A 5B JUMPDEST 116B 94 SWAP5 116C 50 POP 116D 50 POP 116E 60 PUSH1 0x40 1170 61 PUSH2 0x117b 1173 88 DUP9 1174 82 DUP3 1175 89 DUP10 1176 01 ADD 1177 61 PUSH2 0x1023 117A 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @116B stack[-6] = stack[-1] // @116E stack[-2] = 0x40 // @1170 stack[-1] = 0x117b // @1173 stack[0] = stack[-9] // @1176 stack[1] = stack[-8] + 0x40 // } // Block ends with call to 0x1023, returns to 0x117B label_117B: // Incoming return from call to 0x1023 at 0x117A // Inputs[4] // { // @117C stack[-5] // @117C stack[-1] // @1184 stack[-9] // @1186 stack[-8] // } 117B 5B JUMPDEST 117C 93 SWAP4 117D 50 POP 117E 50 POP 117F 60 PUSH1 0x60 1181 61 PUSH2 0x118c 1184 88 DUP9 1185 82 DUP3 1186 89 DUP10 1187 01 ADD 1188 61 PUSH2 0x1023 118B 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @117C stack[-5] = stack[-1] // @117F stack[-2] = 0x60 // @1181 stack[-1] = 0x118c // @1184 stack[0] = stack[-9] // @1187 stack[1] = stack[-8] + 0x60 // } // Block ends with call to 0x1023, returns to 0x118C label_118C: // Incoming return from call to 0x1023 at 0x118B // Inputs[4] // { // @118D stack[-4] // @118D stack[-1] // @1192 stack[-8] // @1194 msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] // } 118C 5B JUMPDEST 118D 92 SWAP3 118E 50 POP 118F 50 POP 1190 60 PUSH1 0x80 1192 86 DUP7 1193 01 ADD 1194 35 CALLDATALOAD 1195 67 PUSH8 0xffffffffffffffff 119E 81 DUP2 119F 11 GT 11A0 15 ISZERO 11A1 61 PUSH2 0x11a9 11A4 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @118D stack[-4] = stack[-1] // @1194 stack[-2] = msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x11a9, if !(msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] > 0xffffffffffffffff) label_11A5: // Incoming jump from 0x11A4, if not !(msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @11A8 memory[0x00:0x00] } 11A5 60 PUSH1 0x00 11A7 80 DUP1 11A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @11A8 revert(memory[0x00:0x00]); } // Block terminates label_11A9: // Incoming jump from 0x11A4, if !(msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @11AD stack[-8] // @11AE stack[-1] // @11AF stack[-7] // } 11A9 5B JUMPDEST 11AA 61 PUSH2 0x11b5 11AD 88 DUP9 11AE 82 DUP3 11AF 89 DUP10 11B0 01 ADD 11B1 61 PUSH2 0x0fcf 11B4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @11AA stack[0] = 0x11b5 // @11AD stack[1] = stack[-8] // @11B0 stack[2] = stack[-7] + stack[-1] // } // Block ends with call to 0x0fcf, returns to 0x11B5 label_11B5: // Incoming return from call to 0x0FCF at 0x11B4 // Inputs[9] // { // @11B6 stack[-3] // @11B6 stack[-1] // @11B9 stack[-6] // @11BA stack[-9] // @11BC stack[-4] // @11BC stack[-7] // @11BD stack[-10] // @11BE stack[-5] // @11BF stack[-8] // } 11B5 5B JUMPDEST 11B6 91 SWAP2 11B7 50 POP 11B8 50 POP 11B9 92 SWAP3 11BA 95 SWAP6 11BB 50 POP 11BC 92 SWAP3 11BD 95 SWAP6 11BE 90 SWAP1 11BF 93 SWAP4 11C0 50 POP 11C1 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @11B9 stack[-6] = stack[-1] // @11BA stack[-9] = stack[-6] // @11BC stack[-7] = stack[-4] // @11BD stack[-10] = stack[-7] // @11BF stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-10] label_11C2: // Incoming call from 0x02B5, returns to 0x02B6 // Inputs[2] // { // @11C8 stack[-1] // @11C9 stack[-2] // } 11C2 5B JUMPDEST 11C3 60 PUSH1 0x00 11C5 80 DUP1 11C6 60 PUSH1 0x40 11C8 83 DUP4 11C9 85 DUP6 11CA 03 SUB 11CB 12 SLT 11CC 15 ISZERO 11CD 61 PUSH2 0x11d5 11D0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @11C3 stack[0] = 0x00 // @11C5 stack[1] = 0x00 // } // Block ends with conditional jump to 0x11d5, if !(stack[-2] - stack[-1] i< 0x40) label_11D1: // Incoming jump from 0x11D0, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @11D4 memory[0x00:0x00] } 11D1 60 PUSH1 0x00 11D3 80 DUP1 11D4 FD *REVERT // Stack delta = +0 // Outputs[1] { @11D4 revert(memory[0x00:0x00]); } // Block terminates label_11D5: // Incoming jump from 0x11D0, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @11DB stack[-4] // @11DD stack[-3] // } 11D5 5B JUMPDEST 11D6 60 PUSH1 0x00 11D8 61 PUSH2 0x11e3 11DB 85 DUP6 11DC 82 DUP3 11DD 86 DUP7 11DE 01 ADD 11DF 61 PUSH2 0x0f3c 11E2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @11D6 stack[0] = 0x00 // @11D8 stack[1] = 0x11e3 // @11DB stack[2] = stack[-4] // @11DE stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x0f3c, returns to 0x11E3 label_11E3: // Incoming return from call to 0x0F3C at 0x11E2 // Inputs[4] // { // @11E4 stack[-4] // @11E4 stack[-1] // @11EC stack[-6] // @11EE stack[-5] // } 11E3 5B JUMPDEST 11E4 92 SWAP3 11E5 50 POP 11E6 50 POP 11E7 60 PUSH1 0x20 11E9 61 PUSH2 0x11f4 11EC 85 DUP6 11ED 82 DUP3 11EE 86 DUP7 11EF 01 ADD 11F0 61 PUSH2 0x0fa5 11F3 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @11E4 stack[-4] = stack[-1] // @11E7 stack[-2] = 0x20 // @11E9 stack[-1] = 0x11f4 // @11EC stack[0] = stack[-6] // @11EF stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x0fa5, returns to 0x11F4 label_11F4: // Incoming return from call to 0x0FA5 at 0x11F3 // Inputs[6] // { // @11F5 stack[-1] // @11F5 stack[-3] // @11F8 stack[-6] // @11FA stack[-4] // @11FA stack[-7] // @11FB stack[-5] // } 11F4 5B JUMPDEST 11F5 91 SWAP2 11F6 50 POP 11F7 50 POP 11F8 92 SWAP3 11F9 50 POP 11FA 92 SWAP3 11FB 90 SWAP1 11FC 50 POP 11FD 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @11F8 stack[-6] = stack[-1] // @11FA stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_11FE: // Incoming call from 0x010D, returns to 0x010E // Inputs[2] // { // @1204 stack[-1] // @1205 stack[-2] // } 11FE 5B JUMPDEST 11FF 60 PUSH1 0x00 1201 80 DUP1 1202 60 PUSH1 0x40 1204 83 DUP4 1205 85 DUP6 1206 03 SUB 1207 12 SLT 1208 15 ISZERO 1209 61 PUSH2 0x1211 120C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @11FF stack[0] = 0x00 // @1201 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1211, if !(stack[-2] - stack[-1] i< 0x40) label_120D: // Incoming jump from 0x120C, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1210 memory[0x00:0x00] } 120D 60 PUSH1 0x00 120F 80 DUP1 1210 FD *REVERT // Stack delta = +0 // Outputs[1] { @1210 revert(memory[0x00:0x00]); } // Block terminates label_1211: // Incoming jump from 0x120C, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1217 stack[-4] // @1219 stack[-3] // } 1211 5B JUMPDEST 1212 60 PUSH1 0x00 1214 61 PUSH2 0x121f 1217 85 DUP6 1218 82 DUP3 1219 86 DUP7 121A 01 ADD 121B 61 PUSH2 0x0f3c 121E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1212 stack[0] = 0x00 // @1214 stack[1] = 0x121f // @1217 stack[2] = stack[-4] // @121A stack[3] = stack[-3] + 0x00 // } // Block ends with call to 0x0f3c, returns to 0x121F label_121F: // Incoming return from call to 0x0F3C at 0x121E // Inputs[4] // { // @1220 stack[-4] // @1220 stack[-1] // @1228 stack[-6] // @122A stack[-5] // } 121F 5B JUMPDEST 1220 92 SWAP3 1221 50 POP 1222 50 POP 1223 60 PUSH1 0x20 1225 61 PUSH2 0x1230 1228 85 DUP6 1229 82 DUP3 122A 86 DUP7 122B 01 ADD 122C 61 PUSH2 0x1023 122F 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1220 stack[-4] = stack[-1] // @1223 stack[-2] = 0x20 // @1225 stack[-1] = 0x1230 // @1228 stack[0] = stack[-6] // @122B stack[1] = stack[-5] + 0x20 // } // Block ends with call to 0x1023, returns to 0x1230 label_1230: // Incoming return from call to 0x1023 at 0x122F // Inputs[6] // { // @1231 stack[-1] // @1231 stack[-3] // @1234 stack[-6] // @1236 stack[-7] // @1236 stack[-4] // @1237 stack[-5] // } 1230 5B JUMPDEST 1231 91 SWAP2 1232 50 POP 1233 50 POP 1234 92 SWAP3 1235 50 POP 1236 92 SWAP3 1237 90 SWAP1 1238 50 POP 1239 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1234 stack[-6] = stack[-1] // @1236 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_123A: // Incoming call from 0x025D, returns to 0x025E // Inputs[2] // { // @123F stack[-1] // @1240 stack[-2] // } 123A 5B JUMPDEST 123B 60 PUSH1 0x00 123D 60 PUSH1 0x20 123F 82 DUP3 1240 84 DUP5 1241 03 SUB 1242 12 SLT 1243 15 ISZERO 1244 61 PUSH2 0x124c 1247 57 *JUMPI // Stack delta = +1 // Outputs[1] { @123B stack[0] = 0x00 } // Block ends with conditional jump to 0x124c, if !(stack[-2] - stack[-1] i< 0x20) label_1248: // Incoming jump from 0x1247, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @124B memory[0x00:0x00] } 1248 60 PUSH1 0x00 124A 80 DUP1 124B FD *REVERT // Stack delta = +0 // Outputs[1] { @124B revert(memory[0x00:0x00]); } // Block terminates label_124C: // Incoming jump from 0x1247, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @124F stack[-2] // @1251 msg.data[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] // } 124C 5B JUMPDEST 124D 60 PUSH1 0x00 124F 82 DUP3 1250 01 ADD 1251 35 CALLDATALOAD 1252 67 PUSH8 0xffffffffffffffff 125B 81 DUP2 125C 11 GT 125D 15 ISZERO 125E 61 PUSH2 0x1266 1261 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1251 stack[0] = msg.data[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] } // Block ends with conditional jump to 0x1266, if !(msg.data[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] > 0xffffffffffffffff) label_1262: // Incoming jump from 0x1261, if not !(msg.data[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1265 memory[0x00:0x00] } 1262 60 PUSH1 0x00 1264 80 DUP1 1265 FD *REVERT // Stack delta = +0 // Outputs[1] { @1265 revert(memory[0x00:0x00]); } // Block terminates label_1266: // Incoming jump from 0x1261, if !(msg.data[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @126A stack[-4] // @126B stack[-1] // @126C stack[-3] // } 1266 5B JUMPDEST 1267 61 PUSH2 0x1272 126A 84 DUP5 126B 82 DUP3 126C 85 DUP6 126D 01 ADD 126E 61 PUSH2 0x0f51 1271 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1267 stack[0] = 0x1272 // @126A stack[1] = stack[-4] // @126D stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x0f51, returns to 0x1272 label_1272: // Incoming return from call to 0x0F51 at 0x1271 // Inputs[4] // { // @1273 stack[-1] // @1273 stack[-3] // @1276 stack[-6] // @1277 stack[-5] // } 1272 5B JUMPDEST 1273 91 SWAP2 1274 50 POP 1275 50 POP 1276 92 SWAP3 1277 91 SWAP2 1278 50 POP 1279 50 POP 127A 56 *JUMP // Stack delta = -5 // Outputs[1] { @1276 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_127B: // Incoming call from 0x022D, returns to 0x022E // Inputs[2] // { // @1281 stack[-1] // @1282 stack[-2] // } 127B 5B JUMPDEST 127C 60 PUSH1 0x00 127E 80 DUP1 127F 60 PUSH1 0x40 1281 83 DUP4 1282 85 DUP6 1283 03 SUB 1284 12 SLT 1285 15 ISZERO 1286 61 PUSH2 0x128e 1289 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @127C stack[0] = 0x00 // @127E stack[1] = 0x00 // } // Block ends with conditional jump to 0x128e, if !(stack[-2] - stack[-1] i< 0x40) label_128A: // Incoming jump from 0x1289, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @128D memory[0x00:0x00] } 128A 60 PUSH1 0x00 128C 80 DUP1 128D FD *REVERT // Stack delta = +0 // Outputs[1] { @128D revert(memory[0x00:0x00]); } // Block terminates label_128E: // Incoming jump from 0x1289, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1291 stack[-3] // @1293 msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] // } 128E 5B JUMPDEST 128F 60 PUSH1 0x00 1291 83 DUP4 1292 01 ADD 1293 35 CALLDATALOAD 1294 67 PUSH8 0xffffffffffffffff 129D 81 DUP2 129E 11 GT 129F 15 ISZERO 12A0 61 PUSH2 0x12a8 12A3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1293 stack[0] = msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] } // Block ends with conditional jump to 0x12a8, if !(msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] > 0xffffffffffffffff) label_12A4: // Incoming jump from 0x12A3, if not !(msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @12A7 memory[0x00:0x00] } 12A4 60 PUSH1 0x00 12A6 80 DUP1 12A7 FD *REVERT // Stack delta = +0 // Outputs[1] { @12A7 revert(memory[0x00:0x00]); } // Block terminates label_12A8: // Incoming jump from 0x12A3, if !(msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @12AC stack[-5] // @12AD stack[-1] // @12AE stack[-4] // } 12A8 5B JUMPDEST 12A9 61 PUSH2 0x12b4 12AC 85 DUP6 12AD 82 DUP3 12AE 86 DUP7 12AF 01 ADD 12B0 61 PUSH2 0x0f51 12B3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @12A9 stack[0] = 0x12b4 // @12AC stack[1] = stack[-5] // @12AF stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x0f51, returns to 0x12B4 label_12B4: // Incoming return from call to 0x0F51 at 0x12B3 // Inputs[4] // { // @12B5 stack[-4] // @12B5 stack[-1] // @12BA stack[-5] // @12BC msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 12B4 5B JUMPDEST 12B5 92 SWAP3 12B6 50 POP 12B7 50 POP 12B8 60 PUSH1 0x20 12BA 83 DUP4 12BB 01 ADD 12BC 35 CALLDATALOAD 12BD 67 PUSH8 0xffffffffffffffff 12C6 81 DUP2 12C7 11 GT 12C8 15 ISZERO 12C9 61 PUSH2 0x12d1 12CC 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @12B5 stack[-4] = stack[-1] // @12BC stack[-2] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x12d1, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) label_12CD: // Incoming jump from 0x12CC, if not !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @12D0 memory[0x00:0x00] } 12CD 60 PUSH1 0x00 12CF 80 DUP1 12D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @12D0 revert(memory[0x00:0x00]); } // Block terminates label_12D1: // Incoming jump from 0x12CC, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @12D5 stack[-5] // @12D6 stack[-1] // @12D7 stack[-4] // } 12D1 5B JUMPDEST 12D2 61 PUSH2 0x12dd 12D5 85 DUP6 12D6 82 DUP3 12D7 86 DUP7 12D8 01 ADD 12D9 61 PUSH2 0x0f7b 12DC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @12D2 stack[0] = 0x12dd // @12D5 stack[1] = stack[-5] // @12D8 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x0f7b, returns to 0x12DD label_12DD: // Incoming return from call to 0x0F7B at 0x12DC // Inputs[6] // { // @12DE stack[-3] // @12DE stack[-1] // @12E1 stack[-6] // @12E3 stack[-4] // @12E3 stack[-7] // @12E4 stack[-5] // } 12DD 5B JUMPDEST 12DE 91 SWAP2 12DF 50 POP 12E0 50 POP 12E1 92 SWAP3 12E2 50 POP 12E3 92 SWAP3 12E4 90 SWAP1 12E5 50 POP 12E6 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @12E1 stack[-6] = stack[-1] // @12E3 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_12E7: // Incoming call from 0x013D, returns to 0x013E // Inputs[2] // { // @12EC stack[-1] // @12ED stack[-2] // } 12E7 5B JUMPDEST 12E8 60 PUSH1 0x00 12EA 60 PUSH1 0x20 12EC 82 DUP3 12ED 84 DUP5 12EE 03 SUB 12EF 12 SLT 12F0 15 ISZERO 12F1 61 PUSH2 0x12f9 12F4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @12E8 stack[0] = 0x00 } // Block ends with conditional jump to 0x12f9, if !(stack[-2] - stack[-1] i< 0x20) label_12F5: // Incoming jump from 0x12F4, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @12F8 memory[0x00:0x00] } 12F5 60 PUSH1 0x00 12F7 80 DUP1 12F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @12F8 revert(memory[0x00:0x00]); } // Block terminates label_12F9: // Incoming jump from 0x12F4, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @12FF stack[-3] // @1301 stack[-2] // } 12F9 5B JUMPDEST 12FA 60 PUSH1 0x00 12FC 61 PUSH2 0x1307 12FF 84 DUP5 1300 82 DUP3 1301 85 DUP6 1302 01 ADD 1303 61 PUSH2 0x0fba 1306 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @12FA stack[0] = 0x00 // @12FC stack[1] = 0x1307 // @12FF stack[2] = stack[-3] // @1302 stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x0fba, returns to 0x1307 label_1307: // Incoming return from call to 0x0FBA at 0x1306 // Inputs[4] // { // @1308 stack[-3] // @1308 stack[-1] // @130B stack[-6] // @130C stack[-5] // } 1307 5B JUMPDEST 1308 91 SWAP2 1309 50 POP 130A 50 POP 130B 92 SWAP3 130C 91 SWAP2 130D 50 POP 130E 50 POP 130F 56 *JUMP // Stack delta = -5 // Outputs[1] { @130B stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1310: // Incoming call from 0x016D, returns to 0x016E // Inputs[2] // { // @1315 stack[-1] // @1316 stack[-2] // } 1310 5B JUMPDEST 1311 60 PUSH1 0x00 1313 60 PUSH1 0x20 1315 82 DUP3 1316 84 DUP5 1317 03 SUB 1318 12 SLT 1319 15 ISZERO 131A 61 PUSH2 0x1322 131D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1311 stack[0] = 0x00 } // Block ends with conditional jump to 0x1322, if !(stack[-2] - stack[-1] i< 0x20) label_131E: // Incoming jump from 0x131D, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1321 memory[0x00:0x00] } 131E 60 PUSH1 0x00 1320 80 DUP1 1321 FD *REVERT // Stack delta = +0 // Outputs[1] { @1321 revert(memory[0x00:0x00]); } // Block terminates label_1322: // Incoming jump from 0x131D, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1325 stack[-2] // @1327 msg.data[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] // } 1322 5B JUMPDEST 1323 60 PUSH1 0x00 1325 82 DUP3 1326 01 ADD 1327 35 CALLDATALOAD 1328 67 PUSH8 0xffffffffffffffff 1331 81 DUP2 1332 11 GT 1333 15 ISZERO 1334 61 PUSH2 0x133c 1337 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1327 stack[0] = msg.data[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] } // Block ends with conditional jump to 0x133c, if !(msg.data[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] > 0xffffffffffffffff) label_1338: // Incoming jump from 0x1337, if not !(msg.data[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @133B memory[0x00:0x00] } 1338 60 PUSH1 0x00 133A 80 DUP1 133B FD *REVERT // Stack delta = +0 // Outputs[1] { @133B revert(memory[0x00:0x00]); } // Block terminates label_133C: // Incoming jump from 0x1337, if !(msg.data[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1340 stack[-4] // @1341 stack[-1] // @1342 stack[-3] // } 133C 5B JUMPDEST 133D 61 PUSH2 0x1348 1340 84 DUP5 1341 82 DUP3 1342 85 DUP6 1343 01 ADD 1344 61 PUSH2 0x0ff9 1347 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @133D stack[0] = 0x1348 // @1340 stack[1] = stack[-4] // @1343 stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x0ff9, returns to 0x1348 label_1348: // Incoming return from call to 0x0FF9 at 0x1347 // Inputs[4] // { // @1349 stack[-3] // @1349 stack[-1] // @134C stack[-6] // @134D stack[-5] // } 1348 5B JUMPDEST 1349 91 SWAP2 134A 50 POP 134B 50 POP 134C 92 SWAP3 134D 91 SWAP2 134E 50 POP 134F 50 POP 1350 56 *JUMP // Stack delta = -5 // Outputs[1] { @134C stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1351: // Incoming call from 0x0211, returns to 0x0212 // Inputs[2] // { // @1357 stack[-1] // @1358 stack[-2] // } 1351 5B JUMPDEST 1352 60 PUSH1 0x00 1354 80 DUP1 1355 60 PUSH1 0x40 1357 83 DUP4 1358 85 DUP6 1359 03 SUB 135A 12 SLT 135B 15 ISZERO 135C 61 PUSH2 0x1364 135F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1352 stack[0] = 0x00 // @1354 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1364, if !(stack[-2] - stack[-1] i< 0x40) label_1360: // Incoming jump from 0x135F, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1363 memory[0x00:0x00] } 1360 60 PUSH1 0x00 1362 80 DUP1 1363 FD *REVERT // Stack delta = +0 // Outputs[1] { @1363 revert(memory[0x00:0x00]); } // Block terminates label_1364: // Incoming jump from 0x135F, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1367 stack[-3] // @1369 msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] // } 1364 5B JUMPDEST 1365 60 PUSH1 0x00 1367 83 DUP4 1368 01 ADD 1369 35 CALLDATALOAD 136A 67 PUSH8 0xffffffffffffffff 1373 81 DUP2 1374 11 GT 1375 15 ISZERO 1376 61 PUSH2 0x137e 1379 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1369 stack[0] = msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] } // Block ends with conditional jump to 0x137e, if !(msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] > 0xffffffffffffffff) label_137A: // Incoming jump from 0x1379, if not !(msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @137D memory[0x00:0x00] } 137A 60 PUSH1 0x00 137C 80 DUP1 137D FD *REVERT // Stack delta = +0 // Outputs[1] { @137D revert(memory[0x00:0x00]); } // Block terminates label_137E: // Incoming jump from 0x1379, if !(msg.data[stack[-3] + 0x00:stack[-3] + 0x00 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1382 stack[-5] // @1383 stack[-1] // @1384 stack[-4] // } 137E 5B JUMPDEST 137F 61 PUSH2 0x138a 1382 85 DUP6 1383 82 DUP3 1384 86 DUP7 1385 01 ADD 1386 61 PUSH2 0x0ff9 1389 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @137F stack[0] = 0x138a // @1382 stack[1] = stack[-5] // @1385 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x0ff9, returns to 0x138A label_138A: // Incoming return from call to 0x0FF9 at 0x1389 // Inputs[4] // { // @138B stack[-4] // @138B stack[-1] // @1390 stack[-5] // @1392 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 138A 5B JUMPDEST 138B 92 SWAP3 138C 50 POP 138D 50 POP 138E 60 PUSH1 0x20 1390 83 DUP4 1391 01 ADD 1392 35 CALLDATALOAD 1393 67 PUSH8 0xffffffffffffffff 139C 81 DUP2 139D 11 GT 139E 15 ISZERO 139F 61 PUSH2 0x13a7 13A2 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @138B stack[-4] = stack[-1] // @1392 stack[-2] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x13a7, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) label_13A3: // Incoming jump from 0x13A2, if not !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @13A6 memory[0x00:0x00] } 13A3 60 PUSH1 0x00 13A5 80 DUP1 13A6 FD *REVERT // Stack delta = +0 // Outputs[1] { @13A6 revert(memory[0x00:0x00]); } // Block terminates label_13A7: // Incoming jump from 0x13A2, if !(msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @13AB stack[-5] // @13AC stack[-1] // @13AD stack[-4] // } 13A7 5B JUMPDEST 13A8 61 PUSH2 0x13b3 13AB 85 DUP6 13AC 82 DUP3 13AD 86 DUP7 13AE 01 ADD 13AF 61 PUSH2 0x0ff9 13B2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @13A8 stack[0] = 0x13b3 // @13AB stack[1] = stack[-5] // @13AE stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x0ff9, returns to 0x13B3 label_13B3: // Incoming return from call to 0x0FF9 at 0x13B2 // Inputs[6] // { // @13B4 stack[-1] // @13B4 stack[-3] // @13B7 stack[-6] // @13B9 stack[-7] // @13B9 stack[-4] // @13BA stack[-5] // } 13B3 5B JUMPDEST 13B4 91 SWAP2 13B5 50 POP 13B6 50 POP 13B7 92 SWAP3 13B8 50 POP 13B9 92 SWAP3 13BA 90 SWAP1 13BB 50 POP 13BC 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @13B7 stack[-6] = stack[-1] // @13B9 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_13BD: // Incoming call from 0x01A7, returns to 0x01A8 // Inputs[2] // { // @13C2 stack[-1] // @13C3 stack[-2] // } 13BD 5B JUMPDEST 13BE 60 PUSH1 0x00 13C0 60 PUSH1 0x20 13C2 82 DUP3 13C3 84 DUP5 13C4 03 SUB 13C5 12 SLT 13C6 15 ISZERO 13C7 61 PUSH2 0x13cf 13CA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @13BE stack[0] = 0x00 } // Block ends with conditional jump to 0x13cf, if !(stack[-2] - stack[-1] i< 0x20) label_13CB: // Incoming jump from 0x13CA, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @13CE memory[0x00:0x00] } 13CB 60 PUSH1 0x00 13CD 80 DUP1 13CE FD *REVERT // Stack delta = +0 // Outputs[1] { @13CE revert(memory[0x00:0x00]); } // Block terminates label_13CF: // Incoming jump from 0x13CA, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @13D5 stack[-3] // @13D7 stack[-2] // } 13CF 5B JUMPDEST 13D0 60 PUSH1 0x00 13D2 61 PUSH2 0x13dd 13D5 84 DUP5 13D6 82 DUP3 13D7 85 DUP6 13D8 01 ADD 13D9 61 PUSH2 0x1023 13DC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @13D0 stack[0] = 0x00 // @13D2 stack[1] = 0x13dd // @13D5 stack[2] = stack[-3] // @13D8 stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x1023, returns to 0x13DD label_13DD: // Incoming return from call to 0x1023 at 0x13DC // Inputs[4] // { // @13DE stack[-3] // @13DE stack[-1] // @13E1 stack[-6] // @13E2 stack[-5] // } 13DD 5B JUMPDEST 13DE 91 SWAP2 13DF 50 POP 13E0 50 POP 13E1 92 SWAP3 13E2 91 SWAP2 13E3 50 POP 13E4 50 POP 13E5 56 *JUMP // Stack delta = -5 // Outputs[1] { @13E1 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_13E6: // Incoming call from 0x1444, returns to 0x1445 // Inputs[2] // { // @13EC stack[-2] // @13ED stack[-1] // } 13E6 5B JUMPDEST 13E7 60 PUSH1 0x00 13E9 61 PUSH2 0x13f2 13EC 83 DUP4 13ED 83 DUP4 13EE 61 PUSH2 0x1517 13F1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @13E7 stack[0] = 0x00 // @13E9 stack[1] = 0x13f2 // @13EC stack[2] = stack[-2] // @13ED stack[3] = stack[-1] // } // Block ends with call to 0x1517, returns to 0x13F2 label_13F2: // Incoming return from call to 0x1517 at 0x13F1 // Inputs[3] // { // @13F5 stack[-3] // @13F7 stack[-1] // @13F9 stack[-4] // } 13F2 5B JUMPDEST 13F3 60 PUSH1 0x20 13F5 83 DUP4 13F6 01 ADD 13F7 90 SWAP1 13F8 50 POP 13F9 92 SWAP3 13FA 91 SWAP2 13FB 50 POP 13FC 50 POP 13FD 56 *JUMP // Stack delta = -3 // Outputs[1] { @13F9 stack[-4] = stack[-3] + 0x20 } // Block ends with unconditional jump to stack[-4] label_13FE: // Incoming call from 0x1549, returns to 0x154A // Inputs[1] { @1402 stack[-1] } 13FE 5B JUMPDEST 13FF 61 PUSH2 0x1407 1402 81 DUP2 1403 61 PUSH2 0x180f 1406 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @13FF stack[0] = 0x1407 // @1402 stack[1] = stack[-1] // } // Block ends with call to 0x180f, returns to 0x1407 label_1407: // Incoming return from call to 0x180F at 0x1406 // Inputs[3] // { // @1408 stack[-3] // @1409 stack[-1] // @140C stack[-4] // } 1407 5B JUMPDEST 1408 82 DUP3 1409 52 MSTORE 140A 50 POP 140B 50 POP 140C 56 *JUMP // Stack delta = -4 // Outputs[1] { @1409 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_140D: // Incoming call from 0x1569, returns to 0x156A // Inputs[1] { @1413 stack[-1] } 140D 5B JUMPDEST 140E 60 PUSH1 0x00 1410 61 PUSH2 0x1418 1413 82 DUP3 1414 61 PUSH2 0x1774 1417 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @140E stack[0] = 0x00 // @1410 stack[1] = 0x1418 // @1413 stack[2] = stack[-1] // } // Block ends with call to 0x1774, returns to 0x1418 label_1418: // Incoming return from call to 0x1774 at 0x1417 // Inputs[2] // { // @141C stack[-1] // @141D stack[-4] // } 1418 5B JUMPDEST 1419 61 PUSH2 0x1422 141C 81 DUP2 141D 85 DUP6 141E 61 PUSH2 0x1797 1421 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1419 stack[0] = 0x1422 // @141C stack[1] = stack[-1] // @141D stack[2] = stack[-4] // } // Block ends with call to 0x1797, returns to 0x1422 label_1422: // Incoming return from call to 0x1797 at 0x1421 // Inputs[3] // { // @1423 stack[-1] // @1423 stack[-5] // @1428 stack[-4] // } 1422 5B JUMPDEST 1423 93 SWAP4 1424 50 POP 1425 61 PUSH2 0x142d 1428 83 DUP4 1429 61 PUSH2 0x1764 142C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1423 stack[-5] = stack[-1] // @1425 stack[-1] = 0x142d // @1428 stack[0] = stack[-4] // } // Block ends with call to 0x1764, returns to 0x142D label_142D: // Incoming return from call to 0x1764 at 0x142C // Inputs[2] // { // @142E stack[-1] // @1432 stack[-2] // } 142D 5B JUMPDEST 142E 80 DUP1 142F 60 PUSH1 0x00 1431 5B JUMPDEST 1432 83 DUP4 1433 81 DUP2 1434 10 LT 1435 15 ISZERO 1436 61 PUSH2 0x145e 1439 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @142E stack[0] = stack[-1] // @142F stack[1] = 0x00 // } // Block ends with conditional jump to 0x145e, if !(0x00 < stack[-2]) label_143A: // Incoming jump from 0x1439, if not !(0x00 < stack[-2]) // Incoming jump from 0x1439, if not !(stack[-1] < stack[-4]) // Inputs[3] // { // @143A stack[-2] // @143B memory[stack[-2]:stack[-2] + 0x20] // @143F stack[-7] // } 143A 81 DUP2 143B 51 MLOAD 143C 61 PUSH2 0x1445 143F 88 DUP9 1440 82 DUP3 1441 61 PUSH2 0x13e6 1444 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @143B stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @143C stack[1] = 0x1445 // @143F stack[2] = stack[-7] // @1440 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x13e6, returns to 0x1445 label_1445: // Incoming return from call to 0x13E6 at 0x1444 // Inputs[3] // { // @1446 stack[-9] // @1446 stack[-1] // @144B stack[-4] // } 1445 5B JUMPDEST 1446 97 SWAP8 1447 50 POP 1448 61 PUSH2 0x1450 144B 83 DUP4 144C 61 PUSH2 0x178a 144F 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1446 stack[-9] = stack[-1] // @1448 stack[-1] = 0x1450 // @144B stack[0] = stack[-4] // } // Block ends with call to 0x178a, returns to 0x1450 label_1450: // Incoming return from call to 0x178A at 0x144F // Inputs[3] // { // @1451 stack[-4] // @1451 stack[-1] // @1456 stack[-3] // } 1450 5B JUMPDEST 1451 92 SWAP3 1452 50 POP 1453 50 POP 1454 60 PUSH1 0x01 1456 81 DUP2 1457 01 ADD 1458 90 SWAP1 1459 50 POP 145A 61 PUSH2 0x1431 145D 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1451 stack[-4] = stack[-1] // @1458 stack[-3] = stack[-3] + 0x01 // } // Block ends with unconditional jump to 0x1431 label_145E: // Incoming jump from 0x1439, if !(0x00 < stack[-2]) // Incoming jump from 0x1439, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @1460 stack[-7] // @1461 stack[-5] // @1466 stack[-8] // } 145E 5B JUMPDEST 145F 50 POP 1460 85 DUP6 1461 93 SWAP4 1462 50 POP 1463 50 POP 1464 50 POP 1465 50 POP 1466 92 SWAP3 1467 91 SWAP2 1468 50 POP 1469 50 POP 146A 56 *JUMP // Stack delta = -7 // Outputs[1] { @1466 stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_146B: // Incoming call from 0x1586, returns to 0x1587 // Inputs[1] { @146F stack[-1] } 146B 5B JUMPDEST 146C 61 PUSH2 0x1474 146F 81 DUP2 1470 61 PUSH2 0x1821 1473 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @146C stack[0] = 0x1474 // @146F stack[1] = stack[-1] // } // Block ends with call to 0x1821, returns to 0x1474 label_1474: // Incoming return from call to 0x1821 at 0x1473 // Inputs[3] // { // @1475 stack[-3] // @1476 stack[-1] // @1479 stack[-4] // } 1474 5B JUMPDEST 1475 82 DUP3 1476 52 MSTORE 1477 50 POP 1478 50 POP 1479 56 *JUMP // Stack delta = -4 // Outputs[1] { @1476 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_147A: // Incoming call from 0x15A1, returns to 0x15A2 // Inputs[1] { @147E stack[-1] } 147A 5B JUMPDEST 147B 61 PUSH2 0x1483 147E 81 DUP2 147F 61 PUSH2 0x1883 1482 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @147B stack[0] = 0x1483 // @147E stack[1] = stack[-1] // } // Block ends with call to 0x1883, returns to 0x1483 label_1483: // Incoming return from call to 0x1883 at 0x1482 // Inputs[3] // { // @1484 stack[-3] // @1485 stack[-1] // @1488 stack[-4] // } 1483 5B JUMPDEST 1484 82 DUP3 1485 52 MSTORE 1486 50 POP 1487 50 POP 1488 56 *JUMP // Stack delta = -4 // Outputs[1] { @1485 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1489: // Incoming call from 0x1654, returns to 0x1655 // Incoming call from 0x15AE, returns to 0x15AF // Inputs[1] { @148D stack[-1] } 1489 5B JUMPDEST 148A 61 PUSH2 0x1492 148D 81 DUP2 148E 61 PUSH2 0x1895 1491 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @148A stack[0] = 0x1492 // @148D stack[1] = stack[-1] // } // Block ends with call to 0x1895, returns to 0x1492 label_1492: // Incoming return from call to 0x1895 at 0x1491 // Inputs[3] // { // @1493 stack[-3] // @1494 stack[-1] // @1497 stack[-4] // } 1492 5B JUMPDEST 1493 82 DUP3 1494 52 MSTORE 1495 50 POP 1496 50 POP 1497 56 *JUMP // Stack delta = -4 // Outputs[1] { @1494 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1498: // Incoming call from 0x15CF, returns to 0x15D0 // Inputs[1] { @149E stack[-1] } 1498 5B JUMPDEST 1499 60 PUSH1 0x00 149B 61 PUSH2 0x14a3 149E 82 DUP3 149F 61 PUSH2 0x177f 14A2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1499 stack[0] = 0x00 // @149B stack[1] = 0x14a3 // @149E stack[2] = stack[-1] // } // Block ends with call to 0x177f, returns to 0x14A3 label_14A3: // Incoming return from call to 0x177F at 0x14A2 // Inputs[2] // { // @14A7 stack[-1] // @14A8 stack[-4] // } 14A3 5B JUMPDEST 14A4 61 PUSH2 0x14ad 14A7 81 DUP2 14A8 85 DUP6 14A9 61 PUSH2 0x17a8 14AC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @14A4 stack[0] = 0x14ad // @14A7 stack[1] = stack[-1] // @14A8 stack[2] = stack[-4] // } // Block ends with call to 0x17a8, returns to 0x14AD label_14AD: // Incoming return from call to 0x17A8 at 0x14AC // Inputs[4] // { // @14AE stack[-5] // @14AE stack[-1] // @14B3 stack[-2] // @14B7 stack[-4] // } 14AD 5B JUMPDEST 14AE 93 SWAP4 14AF 50 POP 14B0 61 PUSH2 0x14bd 14B3 81 DUP2 14B4 85 DUP6 14B5 60 PUSH1 0x20 14B7 86 DUP7 14B8 01 ADD 14B9 61 PUSH2 0x18b6 14BC 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @14AE stack[-5] = stack[-1] // @14B0 stack[-1] = 0x14bd // @14B3 stack[0] = stack[-2] // @14B4 stack[1] = stack[-1] // @14B8 stack[2] = stack[-4] + 0x20 // } // Block ends with call to 0x18b6, returns to 0x14BD label_14BD: // Incoming return from call to 0x18B6 at 0x14BC // Inputs[1] { @14C1 stack[-1] } 14BD 5B JUMPDEST 14BE 61 PUSH2 0x14c6 14C1 81 DUP2 14C2 61 PUSH2 0x1a22 14C5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @14BE stack[0] = 0x14c6 // @14C1 stack[1] = stack[-1] // } // Block ends with call to 0x1a22, returns to 0x14C6 label_14C6: // Incoming return from call to 0x1A22 at 0x14C5 // Inputs[4] // { // @14C7 stack[-5] // @14C8 stack[-1] // @14C9 stack[-3] // @14CC stack[-6] // } 14C6 5B JUMPDEST 14C7 84 DUP5 14C8 01 ADD 14C9 91 SWAP2 14CA 50 POP 14CB 50 POP 14CC 92 SWAP3 14CD 91 SWAP2 14CE 50 POP 14CF 50 POP 14D0 56 *JUMP // Stack delta = -5 // Outputs[1] { @14CC stack[-6] = stack[-5] + stack[-1] } // Block ends with unconditional jump to stack[-6] label_14D1: // Incoming call from 0x15F0, returns to 0x15F1 // Inputs[1] { @14D9 stack[-1] } 14D1 5B JUMPDEST 14D2 60 PUSH1 0x00 14D4 61 PUSH2 0x14de 14D7 60 PUSH1 0x1a 14D9 83 DUP4 14DA 61 PUSH2 0x17a8 14DD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @14D2 stack[0] = 0x00 // @14D4 stack[1] = 0x14de // @14D7 stack[2] = 0x1a // @14D9 stack[3] = stack[-1] // } // Block ends with call to 0x17a8, returns to 0x14DE label_14DE: // Incoming return from call to 0x17A8 at 0x14DD // Inputs[2] // { // @14DF stack[-1] // @14DF stack[-3] // } 14DE 5B JUMPDEST 14DF 91 SWAP2 14E0 50 POP 14E1 61 PUSH2 0x14e9 14E4 82 DUP3 14E5 61 PUSH2 0x1a33 14E8 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @14DF stack[-3] = stack[-1] // @14E1 stack[-1] = 0x14e9 // @14E4 stack[0] = stack[-1] // } // Block ends with call to 0x1a33, returns to 0x14E9 label_14E9: // Incoming return from call to 0x1A33 at 0x14E8 // Inputs[3] // { // @14EC stack[-2] // @14EE stack[-1] // @14F0 stack[-3] // } 14E9 5B JUMPDEST 14EA 60 PUSH1 0x20 14EC 82 DUP3 14ED 01 ADD 14EE 90 SWAP1 14EF 50 POP 14F0 91 SWAP2 14F1 90 SWAP1 14F2 50 POP 14F3 56 *JUMP // Stack delta = -2 // Outputs[1] { @14F0 stack[-3] = stack[-2] + 0x20 } // Block ends with unconditional jump to stack[-3] label_14F4: // Incoming call from 0x1610, returns to 0x1611 // Inputs[1] { @14FC stack[-1] } 14F4 5B JUMPDEST 14F5 60 PUSH1 0x00 14F7 61 PUSH2 0x1501 14FA 60 PUSH1 0x29 14FC 83 DUP4 14FD 61 PUSH2 0x17a8 1500 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @14F5 stack[0] = 0x00 // @14F7 stack[1] = 0x1501 // @14FA stack[2] = 0x29 // @14FC stack[3] = stack[-1] // } // Block ends with call to 0x17a8, returns to 0x1501 label_1501: // Incoming return from call to 0x17A8 at 0x1500 // Inputs[2] // { // @1502 stack[-1] // @1502 stack[-3] // } 1501 5B JUMPDEST 1502 91 SWAP2 1503 50 POP 1504 61 PUSH2 0x150c 1507 82 DUP3 1508 61 PUSH2 0x1a5c 150B 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1502 stack[-3] = stack[-1] // @1504 stack[-1] = 0x150c // @1507 stack[0] = stack[-1] // } // Block ends with call to 0x1a5c, returns to 0x150C label_150C: // Incoming return from call to 0x1A5C at 0x150B // Inputs[3] // { // @150F stack[-2] // @1511 stack[-1] // @1513 stack[-3] // } 150C 5B JUMPDEST 150D 60 PUSH1 0x40 150F 82 DUP3 1510 01 ADD 1511 90 SWAP1 1512 50 POP 1513 91 SWAP2 1514 90 SWAP1 1515 50 POP 1516 56 *JUMP // Stack delta = -2 // Outputs[1] { @1513 stack[-3] = stack[-2] + 0x40 } // Block ends with unconditional jump to stack[-3] label_1517: // Incoming call from 0x13F1, returns to 0x13F2 // Inputs[1] { @151B stack[-1] } 1517 5B JUMPDEST 1518 61 PUSH2 0x1520 151B 81 DUP2 151C 61 PUSH2 0x1879 151F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1518 stack[0] = 0x1520 // @151B stack[1] = stack[-1] // } // Block ends with call to 0x1879, returns to 0x1520 label_1520: // Incoming return from call to 0x1879 at 0x151F // Inputs[3] // { // @1521 stack[-3] // @1522 stack[-1] // @1525 stack[-4] // } 1520 5B JUMPDEST 1521 82 DUP3 1522 52 MSTORE 1523 50 POP 1524 50 POP 1525 56 *JUMP // Stack delta = -4 // Outputs[1] { @1522 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1526: // Incoming call from 0x167D, returns to 0x167E // Incoming call from 0x162C, returns to 0x162D // Incoming call from 0x1670, returns to 0x1671 // Incoming call from 0x1647, returns to 0x1648 // Inputs[1] { @152A stack[-1] } 1526 5B JUMPDEST 1527 61 PUSH2 0x152f 152A 81 DUP2 152B 61 PUSH2 0x1879 152E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1527 stack[0] = 0x152f // @152A stack[1] = stack[-1] // } // Block ends with call to 0x1879, returns to 0x152F label_152F: // Incoming return from call to 0x1879 at 0x152E // Inputs[3] // { // @1530 stack[-3] // @1531 stack[-1] // @1534 stack[-4] // } 152F 5B JUMPDEST 1530 82 DUP3 1531 52 MSTORE 1532 50 POP 1533 50 POP 1534 56 *JUMP // Stack delta = -4 // Outputs[1] { @1531 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1535: // Incoming call from 0x0279, returns to 0x027A // Inputs[2] // { // @153A stack[-1] // @1545 stack[-2] // } 1535 5B JUMPDEST 1536 60 PUSH1 0x00 1538 60 PUSH1 0x20 153A 82 DUP3 153B 01 ADD 153C 90 SWAP1 153D 50 POP 153E 61 PUSH2 0x154a 1541 60 PUSH1 0x00 1543 83 DUP4 1544 01 ADD 1545 84 DUP5 1546 61 PUSH2 0x13fe 1549 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @153C stack[0] = stack[-1] + 0x20 // @153E stack[1] = 0x154a // @1544 stack[2] = stack[-1] + 0x00 // @1545 stack[3] = stack[-2] // } // Block ends with call to 0x13fe, returns to 0x154A label_154A: // Incoming return from call to 0x13FE at 0x1549 // Inputs[3] // { // @154B stack[-1] // @154B stack[-4] // @154C stack[-3] // } 154A 5B JUMPDEST 154B 92 SWAP3 154C 91 SWAP2 154D 50 POP 154E 50 POP 154F 56 *JUMP // Stack delta = -3 // Outputs[1] { @154B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1550: // Incoming call from 0x023F, returns to 0x0240 // Inputs[2] // { // @1555 stack[-1] // @1565 stack[-2] // } 1550 5B JUMPDEST 1551 60 PUSH1 0x00 1553 60 PUSH1 0x20 1555 82 DUP3 1556 01 ADD 1557 90 SWAP1 1558 50 POP 1559 81 DUP2 155A 81 DUP2 155B 03 SUB 155C 60 PUSH1 0x00 155E 83 DUP4 155F 01 ADD 1560 52 MSTORE 1561 61 PUSH2 0x156a 1564 81 DUP2 1565 84 DUP5 1566 61 PUSH2 0x140d 1569 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1557 stack[0] = stack[-1] + 0x20 // @1560 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @1561 stack[1] = 0x156a // @1564 stack[2] = stack[-1] + 0x20 // @1565 stack[3] = stack[-2] // } // Block ends with call to 0x140d, returns to 0x156A label_156A: // Incoming return from call to 0x140D at 0x1569 // Inputs[4] // { // @156B stack[-1] // @156B stack[-2] // @156D stack[-5] // @156E stack[-4] // } 156A 5B JUMPDEST 156B 90 SWAP1 156C 50 POP 156D 92 SWAP3 156E 91 SWAP2 156F 50 POP 1570 50 POP 1571 56 *JUMP // Stack delta = -4 // Outputs[1] { @156D stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1572: // Incoming call from 0x02E3, returns to 0x02E4 // Incoming call from 0x014F, returns to 0x0150 // Inputs[2] // { // @1577 stack[-1] // @1582 stack[-2] // } 1572 5B JUMPDEST 1573 60 PUSH1 0x00 1575 60 PUSH1 0x20 1577 82 DUP3 1578 01 ADD 1579 90 SWAP1 157A 50 POP 157B 61 PUSH2 0x1587 157E 60 PUSH1 0x00 1580 83 DUP4 1581 01 ADD 1582 84 DUP5 1583 61 PUSH2 0x146b 1586 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1579 stack[0] = stack[-1] + 0x20 // @157B stack[1] = 0x1587 // @1581 stack[2] = stack[-1] + 0x00 // @1582 stack[3] = stack[-2] // } // Block ends with call to 0x146b, returns to 0x1587 label_1587: // Incoming return from call to 0x146B at 0x1586 // Inputs[3] // { // @1588 stack[-1] // @1588 stack[-4] // @1589 stack[-3] // } 1587 5B JUMPDEST 1588 92 SWAP3 1589 91 SWAP2 158A 50 POP 158B 50 POP 158C 56 *JUMP // Stack delta = -3 // Outputs[1] { @1588 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_158D: // Incoming call from 0x0BAC, returns to 0x0BAD // Inputs[2] // { // @1592 stack[-1] // @159D stack[-3] // } 158D 5B JUMPDEST 158E 60 PUSH1 0x00 1590 60 PUSH1 0x40 1592 82 DUP3 1593 01 ADD 1594 90 SWAP1 1595 50 POP 1596 61 PUSH2 0x15a2 1599 60 PUSH1 0x00 159B 83 DUP4 159C 01 ADD 159D 85 DUP6 159E 61 PUSH2 0x147a 15A1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1594 stack[0] = stack[-1] + 0x40 // @1596 stack[1] = 0x15a2 // @159C stack[2] = stack[-1] + 0x00 // @159D stack[3] = stack[-3] // } // Block ends with call to 0x147a, returns to 0x15A2 label_15A2: // Incoming return from call to 0x147A at 0x15A1 // Inputs[2] // { // @15A8 stack[-2] // @15AA stack[-3] // } 15A2 5B JUMPDEST 15A3 61 PUSH2 0x15af 15A6 60 PUSH1 0x20 15A8 83 DUP4 15A9 01 ADD 15AA 84 DUP5 15AB 61 PUSH2 0x1489 15AE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @15A3 stack[0] = 0x15af // @15A9 stack[1] = stack[-2] + 0x20 // @15AA stack[2] = stack[-3] // } // Block ends with call to 0x1489, returns to 0x15AF label_15AF: // Incoming return from call to 0x1489 at 0x15AE // Inputs[3] // { // @15B0 stack[-1] // @15B0 stack[-5] // @15B1 stack[-4] // } 15AF 5B JUMPDEST 15B0 93 SWAP4 15B1 92 SWAP3 15B2 50 POP 15B3 50 POP 15B4 50 POP 15B5 56 *JUMP // Stack delta = -4 // Outputs[1] { @15B0 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_15B6: // Incoming call from 0x01B9, returns to 0x01BA // Incoming call from 0x0189, returns to 0x018A // Incoming call from 0x0297, returns to 0x0298 // Inputs[2] // { // @15BB stack[-1] // @15CB stack[-2] // } 15B6 5B JUMPDEST 15B7 60 PUSH1 0x00 15B9 60 PUSH1 0x20 15BB 82 DUP3 15BC 01 ADD 15BD 90 SWAP1 15BE 50 POP 15BF 81 DUP2 15C0 81 DUP2 15C1 03 SUB 15C2 60 PUSH1 0x00 15C4 83 DUP4 15C5 01 ADD 15C6 52 MSTORE 15C7 61 PUSH2 0x15d0 15CA 81 DUP2 15CB 84 DUP5 15CC 61 PUSH2 0x1498 15CF 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @15BD stack[0] = stack[-1] + 0x20 // @15C6 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @15C7 stack[1] = 0x15d0 // @15CA stack[2] = stack[-1] + 0x20 // @15CB stack[3] = stack[-2] // } // Block ends with call to 0x1498, returns to 0x15D0 label_15D0: // Incoming return from call to 0x1498 at 0x15CF // Inputs[4] // { // @15D1 stack[-2] // @15D1 stack[-1] // @15D3 stack[-5] // @15D4 stack[-4] // } 15D0 5B JUMPDEST 15D1 90 SWAP1 15D2 50 POP 15D3 92 SWAP3 15D4 91 SWAP2 15D5 50 POP 15D6 50 POP 15D7 56 *JUMP // Stack delta = -4 // Outputs[1] { @15D3 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_15D8: // Incoming call from 0x0945, returns to 0x0946 // Incoming call from 0x04D9, returns to 0x04DA // Inputs[1] { @15DD stack[-1] } 15D8 5B JUMPDEST 15D9 60 PUSH1 0x00 15DB 60 PUSH1 0x20 15DD 82 DUP3 15DE 01 ADD 15DF 90 SWAP1 15E0 50 POP 15E1 81 DUP2 15E2 81 DUP2 15E3 03 SUB 15E4 60 PUSH1 0x00 15E6 83 DUP4 15E7 01 ADD 15E8 52 MSTORE 15E9 61 PUSH2 0x15f1 15EC 81 DUP2 15ED 61 PUSH2 0x14d1 15F0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @15DF stack[0] = stack[-1] + 0x20 // @15E8 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @15E9 stack[1] = 0x15f1 // @15EC stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x14d1, returns to 0x15F1 label_15F1: // Incoming return from call to 0x14D1 at 0x15F0 // Inputs[4] // { // @15F2 stack[-2] // @15F2 stack[-1] // @15F4 stack[-4] // @15F5 stack[-3] // } 15F1 5B JUMPDEST 15F2 90 SWAP1 15F3 50 POP 15F4 91 SWAP2 15F5 90 SWAP1 15F6 50 POP 15F7 56 *JUMP // Stack delta = -3 // Outputs[1] { @15F4 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_15F8: // Incoming call from 0x074C, returns to 0x074D // Inputs[1] { @15FD stack[-1] } 15F8 5B JUMPDEST 15F9 60 PUSH1 0x00 15FB 60 PUSH1 0x20 15FD 82 DUP3 15FE 01 ADD 15FF 90 SWAP1 1600 50 POP 1601 81 DUP2 1602 81 DUP2 1603 03 SUB 1604 60 PUSH1 0x00 1606 83 DUP4 1607 01 ADD 1608 52 MSTORE 1609 61 PUSH2 0x1611 160C 81 DUP2 160D 61 PUSH2 0x14f4 1610 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @15FF stack[0] = stack[-1] + 0x20 // @1608 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @1609 stack[1] = 0x1611 // @160C stack[2] = stack[-1] + 0x20 // } // Block ends with call to 0x14f4, returns to 0x1611 label_1611: // Incoming return from call to 0x14F4 at 0x1610 // Inputs[4] // { // @1612 stack[-2] // @1612 stack[-1] // @1614 stack[-4] // @1615 stack[-3] // } 1611 5B JUMPDEST 1612 90 SWAP1 1613 50 POP 1614 91 SWAP2 1615 90 SWAP1 1616 50 POP 1617 56 *JUMP // Stack delta = -3 // Outputs[1] { @1614 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1618: // Incoming call from 0x01D7, returns to 0x01D8 // Incoming call from 0x011F, returns to 0x0120 // Inputs[2] // { // @161D stack[-1] // @1628 stack[-2] // } 1618 5B JUMPDEST 1619 60 PUSH1 0x00 161B 60 PUSH1 0x20 161D 82 DUP3 161E 01 ADD 161F 90 SWAP1 1620 50 POP 1621 61 PUSH2 0x162d 1624 60 PUSH1 0x00 1626 83 DUP4 1627 01 ADD 1628 84 DUP5 1629 61 PUSH2 0x1526 162C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @161F stack[0] = stack[-1] + 0x20 // @1621 stack[1] = 0x162d // @1627 stack[2] = stack[-1] + 0x00 // @1628 stack[3] = stack[-2] // } // Block ends with call to 0x1526, returns to 0x162D label_162D: // Incoming return from call to 0x1526 at 0x162C // Inputs[3] // { // @162E stack[-1] // @162E stack[-4] // @162F stack[-3] // } 162D 5B JUMPDEST 162E 92 SWAP3 162F 91 SWAP2 1630 50 POP 1631 50 POP 1632 56 *JUMP // Stack delta = -3 // Outputs[1] { @162E stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1633: // Incoming call from 0x0C86, returns to 0x0C87 // Inputs[2] // { // @1638 stack[-1] // @1643 stack[-3] // } 1633 5B JUMPDEST 1634 60 PUSH1 0x00 1636 60 PUSH1 0x40 1638 82 DUP3 1639 01 ADD 163A 90 SWAP1 163B 50 POP 163C 61 PUSH2 0x1648 163F 60 PUSH1 0x00 1641 83 DUP4 1642 01 ADD 1643 85 DUP6 1644 61 PUSH2 0x1526 1647 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @163A stack[0] = stack[-1] + 0x40 // @163C stack[1] = 0x1648 // @1642 stack[2] = stack[-1] + 0x00 // @1643 stack[3] = stack[-3] // } // Block ends with call to 0x1526, returns to 0x1648 label_1648: // Incoming return from call to 0x1526 at 0x1647 // Inputs[2] // { // @164E stack[-2] // @1650 stack[-3] // } 1648 5B JUMPDEST 1649 61 PUSH2 0x1655 164C 60 PUSH1 0x20 164E 83 DUP4 164F 01 ADD 1650 84 DUP5 1651 61 PUSH2 0x1489 1654 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1649 stack[0] = 0x1655 // @164F stack[1] = stack[-2] + 0x20 // @1650 stack[2] = stack[-3] // } // Block ends with call to 0x1489, returns to 0x1655 label_1655: // Incoming return from call to 0x1489 at 0x1654 // Inputs[3] // { // @1656 stack[-1] // @1656 stack[-5] // @1657 stack[-4] // } 1655 5B JUMPDEST 1656 93 SWAP4 1657 92 SWAP3 1658 50 POP 1659 50 POP 165A 50 POP 165B 56 *JUMP // Stack delta = -4 // Outputs[1] { @1656 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_165C: // Incoming call from 0x0D35, returns to 0x0D36 // Inputs[2] // { // @1661 stack[-1] // @166C stack[-3] // } 165C 5B JUMPDEST 165D 60 PUSH1 0x00 165F 60 PUSH1 0x40 1661 82 DUP3 1662 01 ADD 1663 90 SWAP1 1664 50 POP 1665 61 PUSH2 0x1671 1668 60 PUSH1 0x00 166A 83 DUP4 166B 01 ADD 166C 85 DUP6 166D 61 PUSH2 0x1526 1670 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1663 stack[0] = stack[-1] + 0x40 // @1665 stack[1] = 0x1671 // @166B stack[2] = stack[-1] + 0x00 // @166C stack[3] = stack[-3] // } // Block ends with call to 0x1526, returns to 0x1671 label_1671: // Incoming return from call to 0x1526 at 0x1670 // Inputs[2] // { // @1677 stack[-2] // @1679 stack[-3] // } 1671 5B JUMPDEST 1672 61 PUSH2 0x167e 1675 60 PUSH1 0x20 1677 83 DUP4 1678 01 ADD 1679 84 DUP5 167A 61 PUSH2 0x1526 167D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1672 stack[0] = 0x167e // @1678 stack[1] = stack[-2] + 0x20 // @1679 stack[2] = stack[-3] // } // Block ends with call to 0x1526, returns to 0x167E label_167E: // Incoming return from call to 0x1526 at 0x167D // Inputs[3] // { // @167F stack[-5] // @167F stack[-1] // @1680 stack[-4] // } 167E 5B JUMPDEST 167F 93 SWAP4 1680 92 SWAP3 1681 50 POP 1682 50 POP 1683 50 POP 1684 56 *JUMP // Stack delta = -4 // Outputs[1] { @167F stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1685: // Incoming jump from 0x0E66 // Incoming jump from 0x0F10 // Incoming jump from 0x0DFA // Incoming jump from 0x0ED2 1685 5B JUMPDEST 1686 60 PUSH1 0x00 1688 61 PUSH2 0x168f 168B 61 PUSH2 0x16a0 168E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1686 stack[0] = 0x00 // @1688 stack[1] = 0x168f // } // Block ends with call to 0x16a0, returns to 0x168F label_168F: // Incoming return from call to 0x16A0 at 0x168E // Inputs[3] // { // @1690 stack[-2] // @1690 stack[-1] // @1695 stack[-3] // } 168F 5B JUMPDEST 1690 90 SWAP1 1691 50 POP 1692 61 PUSH2 0x169b 1695 82 DUP3 1696 82 DUP3 1697 61 PUSH2 0x191b 169A 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1690 stack[-2] = stack[-1] // @1692 stack[-1] = 0x169b // @1695 stack[0] = stack[-3] // @1696 stack[1] = stack[-1] // } // Block ends with call to 0x191b, returns to 0x169B label_169B: // Incoming return from call to 0x191B at 0x169A // Inputs[3] // { // @169C stack[-1] // @169C stack[-3] // @169D stack[-2] // } 169B 5B JUMPDEST 169C 91 SWAP2 169D 90 SWAP1 169E 50 POP 169F 56 *JUMP // Stack delta = -2 // Outputs[1] { @169C stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_16A0: // Incoming call from 0x168E, returns to 0x168F // Inputs[2] // { // @16A5 memory[0x40:0x60] // @16A8 stack[-1] // } 16A0 5B JUMPDEST 16A1 60 PUSH1 0x00 16A3 60 PUSH1 0x40 16A5 51 MLOAD 16A6 90 SWAP1 16A7 50 POP 16A8 90 SWAP1 16A9 56 *JUMP // Stack delta = +0 // Outputs[1] { @16A8 stack[-1] = memory[0x40:0x60] } // Block ends with unconditional jump to stack[-1] label_16AA: // Incoming call from 0x0DF5, returns to 0x0DF6 // Inputs[1] { @16B6 stack[-1] } 16AA 5B JUMPDEST 16AB 60 PUSH1 0x00 16AD 67 PUSH8 0xffffffffffffffff 16B6 82 DUP3 16B7 11 GT 16B8 15 ISZERO 16B9 61 PUSH2 0x16c5 16BC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @16AB stack[0] = 0x00 } // Block ends with conditional jump to 0x16c5, if !(stack[-1] > 0xffffffffffffffff) label_16BD: // Incoming jump from 0x16BC, if not !(stack[-1] > 0xffffffffffffffff) 16BD 61 PUSH2 0x16c4 16C0 61 PUSH2 0x19f3 16C3 56 *JUMP // Stack delta = +1 // Outputs[1] { @16BD stack[0] = 0x16c4 } // Block ends with unconditional jump to 0x19f3 16C4 5B JUMPDEST label_16C5: // Incoming jump from 0x16BC, if !(stack[-1] > 0xffffffffffffffff) // Inputs[3] // { // @16C8 stack[-2] // @16CA stack[-1] // @16D2 stack[-3] // } 16C5 5B JUMPDEST 16C6 60 PUSH1 0x20 16C8 82 DUP3 16C9 02 MUL 16CA 90 SWAP1 16CB 50 POP 16CC 60 PUSH1 0x20 16CE 81 DUP2 16CF 01 ADD 16D0 90 SWAP1 16D1 50 POP 16D2 91 SWAP2 16D3 90 SWAP1 16D4 50 POP 16D5 56 *JUMP // Stack delta = -2 // Outputs[1] { @16D2 stack[-3] = stack[-2] * 0x20 + 0x20 } // Block ends with unconditional jump to stack[-3] label_16D6: // Incoming call from 0x0E61, returns to 0x0E62 // Inputs[1] { @16E2 stack[-1] } 16D6 5B JUMPDEST 16D7 60 PUSH1 0x00 16D9 67 PUSH8 0xffffffffffffffff 16E2 82 DUP3 16E3 11 GT 16E4 15 ISZERO 16E5 61 PUSH2 0x16f1 16E8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @16D7 stack[0] = 0x00 } // Block ends with conditional jump to 0x16f1, if !(stack[-1] > 0xffffffffffffffff) label_16E9: // Incoming jump from 0x16E8, if not !(stack[-1] > 0xffffffffffffffff) 16E9 61 PUSH2 0x16f0 16EC 61 PUSH2 0x19f3 16EF 56 *JUMP // Stack delta = +1 // Outputs[1] { @16E9 stack[0] = 0x16f0 } // Block ends with unconditional jump to 0x19f3 16F0 5B JUMPDEST label_16F1: // Incoming jump from 0x16E8, if !(stack[-1] > 0xffffffffffffffff) // Inputs[3] // { // @16F4 stack[-2] // @16F6 stack[-1] // @16FE stack[-3] // } 16F1 5B JUMPDEST 16F2 60 PUSH1 0x20 16F4 82 DUP3 16F5 02 MUL 16F6 90 SWAP1 16F7 50 POP 16F8 60 PUSH1 0x20 16FA 81 DUP2 16FB 01 ADD 16FC 90 SWAP1 16FD 50 POP 16FE 91 SWAP2 16FF 90 SWAP1 1700 50 POP 1701 56 *JUMP // Stack delta = -2 // Outputs[1] { @16FE stack[-3] = stack[-2] * 0x20 + 0x20 } // Block ends with unconditional jump to stack[-3] label_1702: // Incoming call from 0x0ECD, returns to 0x0ECE // Inputs[1] { @170E stack[-1] } 1702 5B JUMPDEST 1703 60 PUSH1 0x00 1705 67 PUSH8 0xffffffffffffffff 170E 82 DUP3 170F 11 GT 1710 15 ISZERO 1711 61 PUSH2 0x171d 1714 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1703 stack[0] = 0x00 } // Block ends with conditional jump to 0x171d, if !(stack[-1] > 0xffffffffffffffff) label_1715: // Incoming jump from 0x1714, if not !(stack[-1] > 0xffffffffffffffff) 1715 61 PUSH2 0x171c 1718 61 PUSH2 0x19f3 171B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1715 stack[0] = 0x171c } // Block ends with unconditional jump to 0x19f3 171C 5B JUMPDEST label_171D: // Incoming jump from 0x1714, if !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @1721 stack[-2] } 171D 5B JUMPDEST 171E 61 PUSH2 0x1726 1721 82 DUP3 1722 61 PUSH2 0x1a22 1725 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @171E stack[0] = 0x1726 // @1721 stack[1] = stack[-2] // } // Block ends with call to 0x1a22, returns to 0x1726 label_1726: // Incoming return from call to 0x1A22 at 0x1725 // Inputs[4] // { // @1727 stack[-2] // @1727 stack[-1] // @172F stack[-4] // @1730 stack[-3] // } 1726 5B JUMPDEST 1727 90 SWAP1 1728 50 POP 1729 60 PUSH1 0x20 172B 81 DUP2 172C 01 ADD 172D 90 SWAP1 172E 50 POP 172F 91 SWAP2 1730 90 SWAP1 1731 50 POP 1732 56 *JUMP // Stack delta = -3 // Outputs[1] { @172F stack[-4] = stack[-1] + 0x20 } // Block ends with unconditional jump to stack[-4] label_1733: // Incoming call from 0x0F0B, returns to 0x0F0C // Inputs[1] { @173F stack[-1] } 1733 5B JUMPDEST 1734 60 PUSH1 0x00 1736 67 PUSH8 0xffffffffffffffff 173F 82 DUP3 1740 11 GT 1741 15 ISZERO 1742 61 PUSH2 0x174e 1745 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1734 stack[0] = 0x00 } // Block ends with conditional jump to 0x174e, if !(stack[-1] > 0xffffffffffffffff) label_1746: // Incoming jump from 0x1745, if not !(stack[-1] > 0xffffffffffffffff) 1746 61 PUSH2 0x174d 1749 61 PUSH2 0x19f3 174C 56 *JUMP // Stack delta = +1 // Outputs[1] { @1746 stack[0] = 0x174d } // Block ends with unconditional jump to 0x19f3 174D 5B JUMPDEST label_174E: // Incoming jump from 0x1745, if !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @1752 stack[-2] } 174E 5B JUMPDEST 174F 61 PUSH2 0x1757 1752 82 DUP3 1753 61 PUSH2 0x1a22 1756 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @174F stack[0] = 0x1757 // @1752 stack[1] = stack[-2] // } // Block ends with call to 0x1a22, returns to 0x1757 label_1757: // Incoming return from call to 0x1A22 at 0x1756 // Inputs[4] // { // @1758 stack[-1] // @1758 stack[-2] // @1760 stack[-4] // @1761 stack[-3] // } 1757 5B JUMPDEST 1758 90 SWAP1 1759 50 POP 175A 60 PUSH1 0x20 175C 81 DUP2 175D 01 ADD 175E 90 SWAP1 175F 50 POP 1760 91 SWAP2 1761 90 SWAP1 1762 50 POP 1763 56 *JUMP // Stack delta = -3 // Outputs[1] { @1760 stack[-4] = stack[-1] + 0x20 } // Block ends with unconditional jump to stack[-4] label_1764: // Incoming call from 0x142C, returns to 0x142D // Inputs[2] // { // @1767 stack[-1] // @1770 stack[-2] // } 1764 5B JUMPDEST 1765 60 PUSH1 0x00 1767 81 DUP2 1768 90 SWAP1 1769 50 POP 176A 60 PUSH1 0x20 176C 82 DUP3 176D 01 ADD 176E 90 SWAP1 176F 50 POP 1770 91 SWAP2 1771 90 SWAP1 1772 50 POP 1773 56 *JUMP // Stack delta = -1 // Outputs[1] { @1770 stack[-2] = stack[-1] + 0x20 } // Block ends with unconditional jump to stack[-2] label_1774: // Incoming call from 0x1417, returns to 0x1418 // Inputs[3] // { // @1777 stack[-1] // @1778 memory[stack[-1]:stack[-1] + 0x20] // @177B stack[-2] // } 1774 5B JUMPDEST 1775 60 PUSH1 0x00 1777 81 DUP2 1778 51 MLOAD 1779 90 SWAP1 177A 50 POP 177B 91 SWAP2 177C 90 SWAP1 177D 50 POP 177E 56 *JUMP // Stack delta = -1 // Outputs[1] { @177B stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_177F: // Incoming call from 0x14A2, returns to 0x14A3 // Inputs[3] // { // @1782 stack[-1] // @1783 memory[stack[-1]:stack[-1] + 0x20] // @1786 stack[-2] // } 177F 5B JUMPDEST 1780 60 PUSH1 0x00 1782 81 DUP2 1783 51 MLOAD 1784 90 SWAP1 1785 50 POP 1786 91 SWAP2 1787 90 SWAP1 1788 50 POP 1789 56 *JUMP // Stack delta = -1 // Outputs[1] { @1786 stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_178A: // Incoming call from 0x144F, returns to 0x1450 // Inputs[2] // { // @178F stack[-1] // @1793 stack[-2] // } 178A 5B JUMPDEST 178B 60 PUSH1 0x00 178D 60 PUSH1 0x20 178F 82 DUP3 1790 01 ADD 1791 90 SWAP1 1792 50 POP 1793 91 SWAP2 1794 90 SWAP1 1795 50 POP 1796 56 *JUMP // Stack delta = -1 // Outputs[1] { @1793 stack[-2] = stack[-1] + 0x20 } // Block ends with unconditional jump to stack[-2] label_1797: // Incoming call from 0x1421, returns to 0x1422 // Inputs[3] // { // @179A stack[-2] // @179B stack[-1] // @17A3 stack[-3] // } 1797 5B JUMPDEST 1798 60 PUSH1 0x00 179A 82 DUP3 179B 82 DUP3 179C 52 MSTORE 179D 60 PUSH1 0x20 179F 82 DUP3 17A0 01 ADD 17A1 90 SWAP1 17A2 50 POP 17A3 92 SWAP3 17A4 91 SWAP2 17A5 50 POP 17A6 50 POP 17A7 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @179C memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @17A3 stack[-3] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-3] label_17A8: // Incoming call from 0x1500, returns to 0x1501 // Incoming call from 0x14DD, returns to 0x14DE // Incoming call from 0x14AC, returns to 0x14AD // Inputs[3] // { // @17AB stack[-2] // @17AC stack[-1] // @17B4 stack[-3] // } 17A8 5B JUMPDEST 17A9 60 PUSH1 0x00 17AB 82 DUP3 17AC 82 DUP3 17AD 52 MSTORE 17AE 60 PUSH1 0x20 17B0 82 DUP3 17B1 01 ADD 17B2 90 SWAP1 17B3 50 POP 17B4 92 SWAP3 17B5 91 SWAP2 17B6 50 POP 17B7 50 POP 17B8 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @17AD memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @17B4 stack[-3] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-3] label_17B9: // Incoming call from 0x0C76, returns to 0x0C77 // Incoming call from 0x0CB5, returns to 0x0CB6 // Inputs[1] { @17BF stack[-1] } 17B9 5B JUMPDEST 17BA 60 PUSH1 0x00 17BC 61 PUSH2 0x17c4 17BF 82 DUP3 17C0 61 PUSH2 0x1879 17C3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @17BA stack[0] = 0x00 // @17BC stack[1] = 0x17c4 // @17BF stack[2] = stack[-1] // } // Block ends with call to 0x1879, returns to 0x17C4 label_17C4: // Incoming return from call to 0x1879 at 0x17C3 // Inputs[3] // { // @17C5 stack[-3] // @17C5 stack[-1] // @17CA stack[-4] // } 17C4 5B JUMPDEST 17C5 91 SWAP2 17C6 50 POP 17C7 61 PUSH2 0x17cf 17CA 83 DUP4 17CB 61 PUSH2 0x1879 17CE 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @17C5 stack[-3] = stack[-1] // @17C7 stack[-1] = 0x17cf // @17CA stack[0] = stack[-4] // } // Block ends with call to 0x1879, returns to 0x17CF label_17CF: // Incoming return from call to 0x1879 at 0x17CE // Inputs[3] // { // @17D0 stack[-1] // @17D0 stack[-4] // @17F5 stack[-3] // } 17CF 5B JUMPDEST 17D0 92 SWAP3 17D1 50 POP 17D2 82 DUP3 17D3 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 17F4 03 SUB 17F5 82 DUP3 17F6 11 GT 17F7 15 ISZERO 17F8 61 PUSH2 0x1804 17FB 57 *JUMPI // Stack delta = -1 // Outputs[1] { @17D0 stack[-4] = stack[-1] } // Block ends with conditional jump to 0x1804, if !(stack[-3] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - stack[-1]) label_17FC: // Incoming jump from 0x17FB, if not !(stack[-3] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - stack[-1]) 17FC 61 PUSH2 0x1803 17FF 61 PUSH2 0x1995 1802 56 *JUMP // Stack delta = +1 // Outputs[1] { @17FC stack[0] = 0x1803 } // Block ends with unconditional jump to 0x1995 1803 5B JUMPDEST label_1804: // Incoming jump from 0x17FB, if !(stack[-3] > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - stack[-1]) // Inputs[4] // { // @1805 stack[-3] // @1806 stack[-2] // @1808 stack[-1] // @180A stack[-4] // } 1804 5B JUMPDEST 1805 82 DUP3 1806 82 DUP3 1807 01 ADD 1808 90 SWAP1 1809 50 POP 180A 92 SWAP3 180B 91 SWAP2 180C 50 POP 180D 50 POP 180E 56 *JUMP // Stack delta = -3 // Outputs[1] { @180A stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_180F: // Incoming call from 0x1406, returns to 0x1407 // Incoming call from 0x1AB3, returns to 0x1AB4 // Inputs[1] { @1815 stack[-1] } 180F 5B JUMPDEST 1810 60 PUSH1 0x00 1812 61 PUSH2 0x181a 1815 82 DUP3 1816 61 PUSH2 0x1859 1819 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1810 stack[0] = 0x00 // @1812 stack[1] = 0x181a // @1815 stack[2] = stack[-1] // } // Block ends with call to 0x1859, returns to 0x181A label_181A: // Incoming return from call to 0x1859 at 0x1819 // Inputs[4] // { // @181B stack[-2] // @181B stack[-1] // @181D stack[-4] // @181E stack[-3] // } 181A 5B JUMPDEST 181B 90 SWAP1 181C 50 POP 181D 91 SWAP2 181E 90 SWAP1 181F 50 POP 1820 56 *JUMP // Stack delta = -3 // Outputs[1] { @181D stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1821: // Incoming call from 0x1473, returns to 0x1474 // Incoming call from 0x1ACA, returns to 0x1ACB // Inputs[2] // { // @1824 stack[-1] // @1829 stack[-2] // } 1821 5B JUMPDEST 1822 60 PUSH1 0x00 1824 81 DUP2 1825 15 ISZERO 1826 15 ISZERO 1827 90 SWAP1 1828 50 POP 1829 91 SWAP2 182A 90 SWAP1 182B 50 POP 182C 56 *JUMP // Stack delta = -1 // Outputs[1] { @1829 stack[-2] = !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_182D: // Incoming call from 0x1AE1, returns to 0x1AE2 // Inputs[2] // { // @1851 stack[-1] // @1855 stack[-2] // } 182D 5B JUMPDEST 182E 60 PUSH1 0x00 1830 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 1851 82 DUP3 1852 16 AND 1853 90 SWAP1 1854 50 POP 1855 91 SWAP2 1856 90 SWAP1 1857 50 POP 1858 56 *JUMP // Stack delta = -1 // Outputs[1] { @1855 stack[-2] = stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to stack[-2] label_1859: // Incoming call from 0x1819, returns to 0x181A // Inputs[2] // { // @1871 stack[-1] // @1875 stack[-2] // } 1859 5B JUMPDEST 185A 60 PUSH1 0x00 185C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1871 82 DUP3 1872 16 AND 1873 90 SWAP1 1874 50 POP 1875 91 SWAP2 1876 90 SWAP1 1877 50 POP 1878 56 *JUMP // Stack delta = -1 // Outputs[1] { @1875 stack[-2] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff } // Block ends with unconditional jump to stack[-2] label_1879: // Incoming call from 0x17CE, returns to 0x17CF // Incoming call from 0x189F, returns to 0x18A0 // Incoming call from 0x152E, returns to 0x152F // Incoming call from 0x1956, returns to 0x1957 // Incoming call from 0x17C3, returns to 0x17C4 // Incoming call from 0x151F, returns to 0x1520 // Incoming call from 0x1AF8, returns to 0x1AF9 // Incoming call from 0x188D, returns to 0x188E // Inputs[2] // { // @187C stack[-1] // @187F stack[-2] // } 1879 5B JUMPDEST 187A 60 PUSH1 0x00 187C 81 DUP2 187D 90 SWAP1 187E 50 POP 187F 91 SWAP2 1880 90 SWAP1 1881 50 POP 1882 56 *JUMP // Stack delta = -1 // Outputs[1] { @187F stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_1883: // Incoming call from 0x1482, returns to 0x1483 // Inputs[1] { @1889 stack[-1] } 1883 5B JUMPDEST 1884 60 PUSH1 0x00 1886 61 PUSH2 0x188e 1889 82 DUP3 188A 61 PUSH2 0x1879 188D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1884 stack[0] = 0x00 // @1886 stack[1] = 0x188e // @1889 stack[2] = stack[-1] // } // Block ends with call to 0x1879, returns to 0x188E label_188E: // Incoming return from call to 0x1879 at 0x188D // Inputs[4] // { // @188F stack[-1] // @188F stack[-2] // @1891 stack[-4] // @1892 stack[-3] // } 188E 5B JUMPDEST 188F 90 SWAP1 1890 50 POP 1891 91 SWAP2 1892 90 SWAP1 1893 50 POP 1894 56 *JUMP // Stack delta = -3 // Outputs[1] { @1891 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1895: // Incoming call from 0x1491, returns to 0x1492 // Inputs[1] { @189B stack[-1] } 1895 5B JUMPDEST 1896 60 PUSH1 0x00 1898 61 PUSH2 0x18a0 189B 82 DUP3 189C 61 PUSH2 0x1879 189F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1896 stack[0] = 0x00 // @1898 stack[1] = 0x18a0 // @189B stack[2] = stack[-1] // } // Block ends with call to 0x1879, returns to 0x18A0 label_18A0: // Incoming return from call to 0x1879 at 0x189F // Inputs[4] // { // @18A1 stack[-1] // @18A1 stack[-2] // @18A3 stack[-4] // @18A4 stack[-3] // } 18A0 5B JUMPDEST 18A1 90 SWAP1 18A2 50 POP 18A3 91 SWAP2 18A4 90 SWAP1 18A5 50 POP 18A6 56 *JUMP // Stack delta = -3 // Outputs[1] { @18A3 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_18A7: // Incoming call from 0x0F33, returns to 0x0F34 // Incoming call from 0x0EF5, returns to 0x0EF6 // Inputs[5] // { // @18A8 stack[-3] // @18A9 stack[-1] // @18AA stack[-2] // @18AB msg.data[stack[-1]:stack[-1] + stack[-3]] // @18B5 stack[-4] // } 18A7 5B JUMPDEST 18A8 82 DUP3 18A9 81 DUP2 18AA 83 DUP4 18AB 37 CALLDATACOPY 18AC 60 PUSH1 0x00 18AE 83 DUP4 18AF 83 DUP4 18B0 01 ADD 18B1 52 MSTORE 18B2 50 POP 18B3 50 POP 18B4 50 POP 18B5 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @18AB memory[stack[-2]:stack[-2] + stack[-3]] = msg.data[stack[-1]:stack[-1] + stack[-3]] // @18B1 memory[stack[-2] + stack[-3]:stack[-2] + stack[-3] + 0x20] = 0x00 // } // Block ends with unconditional jump to stack[-4] label_18B6: // Incoming call from 0x14BC, returns to 0x14BD // Inputs[1] { @18BA stack[-3] } 18B6 5B JUMPDEST 18B7 60 PUSH1 0x00 18B9 5B JUMPDEST 18BA 83 DUP4 18BB 81 DUP2 18BC 10 LT 18BD 15 ISZERO 18BE 61 PUSH2 0x18d4 18C1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @18B7 stack[0] = 0x00 } // Block ends with conditional jump to 0x18d4, if !(0x00 < stack[-3]) label_18C2: // Incoming jump from 0x18C1, if not !(0x00 < stack[-3]) // Incoming jump from 0x18C1, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @18C2 stack[-1] // @18C3 stack[-2] // @18C5 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @18C7 stack[-3] // } 18C2 80 DUP1 18C3 82 DUP3 18C4 01 ADD 18C5 51 MLOAD 18C6 81 DUP2 18C7 84 DUP5 18C8 01 ADD 18C9 52 MSTORE 18CA 60 PUSH1 0x20 18CC 81 DUP2 18CD 01 ADD 18CE 90 SWAP1 18CF 50 POP 18D0 61 PUSH2 0x18b9 18D3 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @18C9 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @18CE stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x18b9 label_18D4: // Incoming jump from 0x18C1, if !(0x00 < stack[-3]) // Incoming jump from 0x18C1, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @18D5 stack[-4] // @18D6 stack[-1] // } 18D4 5B JUMPDEST 18D5 83 DUP4 18D6 81 DUP2 18D7 11 GT 18D8 15 ISZERO 18D9 61 PUSH2 0x18e3 18DC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x18e3, if !(stack[-1] > stack[-4]) label_18DD: // Incoming jump from 0x18DC, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @18DF stack[-4] // @18E0 stack[-3] // @18E8 stack[-5] // } 18DD 60 PUSH1 0x00 18DF 84 DUP5 18E0 84 DUP5 18E1 01 ADD 18E2 52 MSTORE 18E3 5B JUMPDEST 18E4 50 POP 18E5 50 POP 18E6 50 POP 18E7 50 POP 18E8 56 *JUMP // Stack delta = -5 // Outputs[1] { @18E2 memory[stack[-3] + stack[-4]:stack[-3] + stack[-4] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_18E9: // Incoming call from 0x04FB, returns to 0x04FC // Incoming call from 0x09B7, returns to 0x09B8 // Incoming call from 0x0D50, returns to 0x0D51 // Incoming call from 0x05B7, returns to 0x05B8 // Incoming call from 0x0527, returns to 0x0528 // Incoming call from 0x058B, returns to 0x058C // Incoming call from 0x098B, returns to 0x098C // Inputs[1] { @18EE stack[-1] } 18E9 5B JUMPDEST 18EA 60 PUSH1 0x00 18EC 60 PUSH1 0x02 18EE 82 DUP3 18EF 04 DIV 18F0 90 SWAP1 18F1 50 POP 18F2 60 PUSH1 0x01 18F4 82 DUP3 18F5 16 AND 18F6 80 DUP1 18F7 61 PUSH2 0x1901 18FA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @18F0 stack[0] = stack[-1] / 0x02 // @18F5 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x1901, if stack[-1] & 0x01 label_18FB: // Incoming jump from 0x18FA, if not stack[-1] & 0x01 // Inputs[2] // { // @18FD stack[-2] // @1906 stack[-1] // } 18FB 60 PUSH1 0x7f 18FD 82 DUP3 18FE 16 AND 18FF 91 SWAP2 1900 50 POP 1901 5B JUMPDEST 1902 60 PUSH1 0x20 1904 82 DUP3 1905 10 LT 1906 81 DUP2 1907 14 EQ 1908 15 ISZERO 1909 61 PUSH2 0x1915 190C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @18FF stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x1915, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_190D: // Incoming jump from 0x190C, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x190C, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) 190D 61 PUSH2 0x1914 1910 61 PUSH2 0x19c4 1913 56 *JUMP // Stack delta = +1 // Outputs[1] { @190D stack[0] = 0x1914 } // Block ends with unconditional jump to 0x19c4 1914 5B JUMPDEST label_1915: // Incoming jump from 0x190C, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x190C, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @1917 stack[-4] // @1917 stack[-2] // @1918 stack[-3] // } 1915 5B JUMPDEST 1916 50 POP 1917 91 SWAP2 1918 90 SWAP1 1919 50 POP 191A 56 *JUMP // Stack delta = -3 // Outputs[1] { @1917 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_191B: // Incoming call from 0x169A, returns to 0x169B // Inputs[1] { @191F stack[-2] } 191B 5B JUMPDEST 191C 61 PUSH2 0x1924 191F 82 DUP3 1920 61 PUSH2 0x1a22 1923 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @191C stack[0] = 0x1924 // @191F stack[1] = stack[-2] // } // Block ends with call to 0x1a22, returns to 0x1924 label_1924: // Incoming return from call to 0x1A22 at 0x1923 // Inputs[2] // { // @1925 stack[-2] // @1926 stack[-1] // } 1924 5B JUMPDEST 1925 81 DUP2 1926 01 ADD 1927 81 DUP2 1928 81 DUP2 1929 10 LT 192A 67 PUSH8 0xffffffffffffffff 1933 82 DUP3 1934 11 GT 1935 17 OR 1936 15 ISZERO 1937 61 PUSH2 0x1943 193A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1926 stack[-1] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x1943, if !((stack[-2] + stack[-1] > 0xffffffffffffffff) | (stack[-2] + stack[-1] < stack[-2])) label_193B: // Incoming jump from 0x193A, if not !((stack[-2] + stack[-1] > 0xffffffffffffffff) | (stack[-2] + stack[-1] < stack[-2])) 193B 61 PUSH2 0x1942 193E 61 PUSH2 0x19f3 1941 56 *JUMP // Stack delta = +1 // Outputs[1] { @193B stack[0] = 0x1942 } // Block ends with unconditional jump to 0x19f3 1942 5B JUMPDEST label_1943: // Incoming jump from 0x193A, if !((stack[-2] + stack[-1] > 0xffffffffffffffff) | (stack[-2] + stack[-1] < stack[-2])) // Inputs[2] // { // @1944 stack[-1] // @194B stack[-4] // } 1943 5B JUMPDEST 1944 80 DUP1 1945 60 PUSH1 0x40 1947 52 MSTORE 1948 50 POP 1949 50 POP 194A 50 POP 194B 56 *JUMP // Stack delta = -4 // Outputs[1] { @1947 memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_194C: // Incoming call from 0x0C99, returns to 0x0C9A // Incoming call from 0x08AE, returns to 0x08AF // Inputs[1] { @1952 stack[-1] } 194C 5B JUMPDEST 194D 60 PUSH1 0x00 194F 61 PUSH2 0x1957 1952 82 DUP3 1953 61 PUSH2 0x1879 1956 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @194D stack[0] = 0x00 // @194F stack[1] = 0x1957 // @1952 stack[2] = stack[-1] // } // Block ends with call to 0x1879, returns to 0x1957 label_1957: // Incoming return from call to 0x1879 at 0x1956 // Inputs[2] // { // @1958 stack[-3] // @1958 stack[-1] // } 1957 5B JUMPDEST 1958 91 SWAP2 1959 50 POP 195A 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 197B 82 DUP3 197C 14 EQ 197D 15 ISZERO 197E 61 PUSH2 0x198a 1981 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1958 stack[-3] = stack[-1] } // Block ends with conditional jump to 0x198a, if !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) label_1982: // Incoming jump from 0x1981, if not !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) 1982 61 PUSH2 0x1989 1985 61 PUSH2 0x1995 1988 56 *JUMP // Stack delta = +1 // Outputs[1] { @1982 stack[0] = 0x1989 } // Block ends with unconditional jump to 0x1995 1989 5B JUMPDEST label_198A: // Incoming jump from 0x1981, if !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) // Inputs[3] // { // @198D stack[-2] // @198F stack[-1] // @1991 stack[-3] // } 198A 5B JUMPDEST 198B 60 PUSH1 0x01 198D 82 DUP3 198E 01 ADD 198F 90 SWAP1 1990 50 POP 1991 91 SWAP2 1992 90 SWAP1 1993 50 POP 1994 56 *JUMP // Stack delta = -2 // Outputs[1] { @1991 stack[-3] = stack[-2] + 0x01 } // Block ends with unconditional jump to stack[-3] label_1995: // Incoming jump from 0x1988 // Incoming jump from 0x1802 // Inputs[1] { @19C3 memory[0x00:0x24] } 1995 5B JUMPDEST 1996 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 19B7 60 PUSH1 0x00 19B9 52 MSTORE 19BA 60 PUSH1 0x11 19BC 60 PUSH1 0x04 19BE 52 MSTORE 19BF 60 PUSH1 0x24 19C1 60 PUSH1 0x00 19C3 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @19B9 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @19BE memory[0x04:0x24] = 0x11 // @19C3 revert(memory[0x00:0x24]); // } // Block terminates label_19C4: // Incoming jump from 0x1913 // Inputs[1] { @19F2 memory[0x00:0x24] } 19C4 5B JUMPDEST 19C5 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 19E6 60 PUSH1 0x00 19E8 52 MSTORE 19E9 60 PUSH1 0x22 19EB 60 PUSH1 0x04 19ED 52 MSTORE 19EE 60 PUSH1 0x24 19F0 60 PUSH1 0x00 19F2 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @19E8 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @19ED memory[0x04:0x24] = 0x22 // @19F2 revert(memory[0x00:0x24]); // } // Block terminates label_19F3: // Incoming jump from 0x16EF // Incoming jump from 0x16C3 // Incoming jump from 0x174C // Incoming jump from 0x1941 // Incoming jump from 0x171B // Inputs[1] { @1A21 memory[0x00:0x24] } 19F3 5B JUMPDEST 19F4 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 1A15 60 PUSH1 0x00 1A17 52 MSTORE 1A18 60 PUSH1 0x41 1A1A 60 PUSH1 0x04 1A1C 52 MSTORE 1A1D 60 PUSH1 0x24 1A1F 60 PUSH1 0x00 1A21 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1A17 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @1A1C memory[0x04:0x24] = 0x41 // @1A21 revert(memory[0x00:0x24]); // } // Block terminates label_1A22: // Incoming call from 0x1756, returns to 0x1757 // Incoming call from 0x1725, returns to 0x1726 // Incoming call from 0x14C5, returns to 0x14C6 // Incoming call from 0x1923, returns to 0x1924 // Inputs[2] // { // @1A2A stack[-1] // @1A2F stack[-2] // } 1A22 5B JUMPDEST 1A23 60 PUSH1 0x00 1A25 60 PUSH1 0x1f 1A27 19 NOT 1A28 60 PUSH1 0x1f 1A2A 83 DUP4 1A2B 01 ADD 1A2C 16 AND 1A2D 90 SWAP1 1A2E 50 POP 1A2F 91 SWAP2 1A30 90 SWAP1 1A31 50 POP 1A32 56 *JUMP // Stack delta = -1 // Outputs[1] { @1A2F stack[-2] = stack[-1] + 0x1f & ~0x1f } // Block ends with unconditional jump to stack[-2] label_1A33: // Incoming call from 0x14E8, returns to 0x14E9 // Inputs[2] // { // @1A57 stack[-1] // @1A5B stack[-2] // } 1A33 5B JUMPDEST 1A34 7F PUSH32 0x6163636573732064656e6965642e206f776e6572204f4e4c592e000000000000 1A55 60 PUSH1 0x00 1A57 82 DUP3 1A58 01 ADD 1A59 52 MSTORE 1A5A 50 POP 1A5B 56 *JUMP // Stack delta = -2 // Outputs[1] { @1A59 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x6163636573732064656e6965642e206f776e6572204f4e4c592e000000000000 } // Block ends with unconditional jump to stack[-2] label_1A5C: // Incoming call from 0x150B, returns to 0x150C // Inputs[2] // { // @1A80 stack[-1] // @1AAA stack[-2] // } 1A5C 5B JUMPDEST 1A5D 7F PUSH32 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 1A7E 60 PUSH1 0x00 1A80 82 DUP3 1A81 01 ADD 1A82 52 MSTORE 1A83 7F PUSH32 0x206d69736d617463680000000000000000000000000000000000000000000000 1AA4 60 PUSH1 0x20 1AA6 82 DUP3 1AA7 01 ADD 1AA8 52 MSTORE 1AA9 50 POP 1AAA 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1A82 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 // @1AA8 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x206d69736d617463680000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-2] label_1AAB: // Incoming call from 0x0F4A, returns to 0x0F4B // Inputs[1] { @1AAF stack[-1] } 1AAB 5B JUMPDEST 1AAC 61 PUSH2 0x1ab4 1AAF 81 DUP2 1AB0 61 PUSH2 0x180f 1AB3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1AAC stack[0] = 0x1ab4 // @1AAF stack[1] = stack[-1] // } // Block ends with call to 0x180f, returns to 0x1AB4 label_1AB4: // Incoming return from call to 0x180F at 0x1AB3 // Inputs[2] // { // @1AB5 stack[-2] // @1AB6 stack[-1] // } 1AB4 5B JUMPDEST 1AB5 81 DUP2 1AB6 14 EQ 1AB7 61 PUSH2 0x1abf 1ABA 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1abf, if stack[-2] == stack[-1] label_1ABB: // Incoming jump from 0x1ABA, if not stack[-2] == stack[-1] // Inputs[1] { @1ABE memory[0x00:0x00] } 1ABB 60 PUSH1 0x00 1ABD 80 DUP1 1ABE FD *REVERT // Stack delta = +0 // Outputs[1] { @1ABE revert(memory[0x00:0x00]); } // Block terminates label_1ABF: // Incoming jump from 0x1ABA, if stack[-2] == stack[-1] // Inputs[1] { @1AC1 stack[-2] } 1ABF 5B JUMPDEST 1AC0 50 POP 1AC1 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1AC2: // Incoming call from 0x0FB3, returns to 0x0FB4 // Inputs[1] { @1AC6 stack[-1] } 1AC2 5B JUMPDEST 1AC3 61 PUSH2 0x1acb 1AC6 81 DUP2 1AC7 61 PUSH2 0x1821 1ACA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1AC3 stack[0] = 0x1acb // @1AC6 stack[1] = stack[-1] // } // Block ends with call to 0x1821, returns to 0x1ACB label_1ACB: // Incoming return from call to 0x1821 at 0x1ACA // Inputs[2] // { // @1ACC stack[-2] // @1ACD stack[-1] // } 1ACB 5B JUMPDEST 1ACC 81 DUP2 1ACD 14 EQ 1ACE 61 PUSH2 0x1ad6 1AD1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1ad6, if stack[-2] == stack[-1] label_1AD2: // Incoming jump from 0x1AD1, if not stack[-2] == stack[-1] // Inputs[1] { @1AD5 memory[0x00:0x00] } 1AD2 60 PUSH1 0x00 1AD4 80 DUP1 1AD5 FD *REVERT // Stack delta = +0 // Outputs[1] { @1AD5 revert(memory[0x00:0x00]); } // Block terminates label_1AD6: // Incoming jump from 0x1AD1, if stack[-2] == stack[-1] // Inputs[1] { @1AD8 stack[-2] } 1AD6 5B JUMPDEST 1AD7 50 POP 1AD8 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1AD9: // Incoming call from 0x0FC8, returns to 0x0FC9 // Inputs[1] { @1ADD stack[-1] } 1AD9 5B JUMPDEST 1ADA 61 PUSH2 0x1ae2 1ADD 81 DUP2 1ADE 61 PUSH2 0x182d 1AE1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1ADA stack[0] = 0x1ae2 // @1ADD stack[1] = stack[-1] // } // Block ends with call to 0x182d, returns to 0x1AE2 label_1AE2: // Incoming return from call to 0x182D at 0x1AE1 // Inputs[2] // { // @1AE3 stack[-2] // @1AE4 stack[-1] // } 1AE2 5B JUMPDEST 1AE3 81 DUP2 1AE4 14 EQ 1AE5 61 PUSH2 0x1aed 1AE8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1aed, if stack[-2] == stack[-1] label_1AE9: // Incoming jump from 0x1AE8, if not stack[-2] == stack[-1] // Inputs[1] { @1AEC memory[0x00:0x00] } 1AE9 60 PUSH1 0x00 1AEB 80 DUP1 1AEC FD *REVERT // Stack delta = +0 // Outputs[1] { @1AEC revert(memory[0x00:0x00]); } // Block terminates label_1AED: // Incoming jump from 0x1AE8, if stack[-2] == stack[-1] // Inputs[1] { @1AEF stack[-2] } 1AED 5B JUMPDEST 1AEE 50 POP 1AEF 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1AF0: // Incoming call from 0x1031, returns to 0x1032 // Inputs[1] { @1AF4 stack[-1] } 1AF0 5B JUMPDEST 1AF1 61 PUSH2 0x1af9 1AF4 81 DUP2 1AF5 61 PUSH2 0x1879 1AF8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1AF1 stack[0] = 0x1af9 // @1AF4 stack[1] = stack[-1] // } // Block ends with call to 0x1879, returns to 0x1AF9 label_1AF9: // Incoming return from call to 0x1879 at 0x1AF8 // Inputs[2] // { // @1AFA stack[-2] // @1AFB stack[-1] // } 1AF9 5B JUMPDEST 1AFA 81 DUP2 1AFB 14 EQ 1AFC 61 PUSH2 0x1b04 1AFF 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1b04, if stack[-2] == stack[-1] label_1B00: // Incoming jump from 0x1AFF, if not stack[-2] == stack[-1] // Inputs[1] { @1B03 memory[0x00:0x00] } 1B00 60 PUSH1 0x00 1B02 80 DUP1 1B03 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B03 revert(memory[0x00:0x00]); } // Block terminates label_1B04: // Incoming jump from 0x1AFF, if stack[-2] == stack[-1] // Inputs[1] { @1B06 stack[-2] } 1B04 5B JUMPDEST 1B05 50 POP 1B06 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] 1B07 FE *ASSERT 1B08 A2 LOG2 1B09 64 PUSH5 0x6970667358 1B0F 22 22 1B10 12 SLT 1B11 20 SHA3 1B12 C3 C3 1B13 7D PUSH30 0xb2f55a548e9eb80b001e50c589d5932e436fb7eed75e3c5a2f1efb78461c 1B32 64 PUSH5 0x736f6c6343 1B38 00 *STOP 1B39 08 ADDMOD 1B3A 04 DIV 1B3B 00 *STOP 1B3C 33 CALLER
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]