Online Solidity Decompiler

« Decompile another contract

Address

0x8baae1b64dccfee7b88244b41b9c0c4f587e7345 [etherscan.io]

Public Methods

Method names cached from 4byte.directory.
0x5b61291c aekS()
0x64d98f6e isSolved()
0x6c54fcef Unknown
0x7430306c Unknown
0xb220f73c Unknown
0xb4eff690 checkFlag(bytes)
0xd6385778 Unknown
0xf605fa57 Unknown

Internal Methods

isSolved() returns (r0)
func_02B5(arg0)
func_073D(arg0)
checkFlag(arg0)
func_1195(arg0)
func_1869(arg0)
func_1DBD()

Decompilation

contract Contract { function main() { memory[0x40:0x60] = 0x60; if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); } var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff; if (var0 == 0x5b61291c) { // Dispatch table entry for aekS() var var1 = 0x009b; revert(memory[0x00:0x00]); } else if (var0 == 0x64d98f6e) { // Dispatch table entry for isSolved() if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x00b0; var1 = isSolved(); var temp0 = memory[0x40:0x60]; memory[temp0:temp0 + 0x20] = !!var1; var temp1 = memory[0x40:0x60]; return memory[temp1:temp1 + (temp0 + 0x20) - temp1]; } else if (var0 == 0x6c54fcef) { // Dispatch table entry for 0x6c54fcef (unknown) if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x0125; var temp2 = msg.data[0x04:0x24] + 0x04; var temp3 = msg.data[temp2:temp2 + 0x20]; var temp4 = memory[0x40:0x60]; memory[0x40:0x60] = temp4 + (temp3 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp4:temp4 + 0x20] = temp3; memory[temp4 + 0x20:temp4 + 0x20 + temp3] = msg.data[temp2 + 0x20:temp2 + 0x20 + temp3]; var var2 = temp4; func_02B5(var2); stop(); } else if (var0 == 0x7430306c) { // Dispatch table entry for 0x7430306c (unknown) if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x013a; selfdestruct(0x00); } else if (var0 == 0xb220f73c) { // Dispatch table entry for 0xb220f73c (unknown) if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x0197; var temp5 = msg.data[0x04:0x24] + 0x04; var temp6 = msg.data[temp5:temp5 + 0x20]; var temp7 = memory[0x40:0x60]; memory[0x40:0x60] = temp7 + (temp6 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp7:temp7 + 0x20] = temp6; memory[temp7 + 0x20:temp7 + 0x20 + temp6] = msg.data[temp5 + 0x20:temp5 + 0x20 + temp6]; var2 = temp7; func_073D(var2); stop(); } else if (var0 == 0xb4eff690) { // Dispatch table entry for checkFlag(bytes) var1 = 0x01e9; var temp8 = msg.data[0x04:0x24] + 0x04; var temp9 = msg.data[temp8:temp8 + 0x20]; var temp10 = memory[0x40:0x60]; memory[0x40:0x60] = temp10 + (temp9 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp10:temp10 + 0x20] = temp9; memory[temp10 + 0x20:temp10 + 0x20 + temp9] = msg.data[temp8 + 0x20:temp8 + 0x20 + temp9]; var2 = temp10; checkFlag(var2); stop(); } else if (var0 == 0xd6385778) { // Dispatch table entry for 0xd6385778 (unknown) if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x0246; var temp11 = msg.data[0x04:0x24] + 0x04; var temp12 = msg.data[temp11:temp11 + 0x20]; var temp13 = memory[0x40:0x60]; memory[0x40:0x60] = temp13 + (temp12 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp13:temp13 + 0x20] = temp12; memory[temp13 + 0x20:temp13 + 0x20 + temp12] = msg.data[temp11 + 0x20:temp11 + 0x20 + temp12]; var2 = temp13; func_1195(var2); stop(); } else if (var0 == 0xf605fa57) { // Dispatch table entry for 0xf605fa57 (unknown) var1 = 0x0298; var temp14 = msg.data[0x04:0x24] + 0x04; var temp15 = msg.data[temp14:temp14 + 0x20]; var temp16 = memory[0x40:0x60]; memory[0x40:0x60] = temp16 + (temp15 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp16:temp16 + 0x20] = temp15; memory[temp16 + 0x20:temp16 + 0x20 + temp15] = msg.data[temp14 + 0x20:temp14 + 0x20 + temp15]; var2 = temp16; func_1869(var2); stop(); } else { revert(memory[0x00:0x00]); } } function isSolved() returns (var r0) { return storage[0x00] & 0xff; } function func_02B5(var arg0) { var var0 = 0x00; if (block.timestamp != 0x5ad92d80) { goto label_0038; } var var1 = 0x02d0; func_1DBD(); var1 = arg0; var var2 = 0x12; if (var2 >= memory[var1:var1 + 0x20]) { assert(); } var0 = (memory[var1 + 0x20 + var2:var1 + 0x20 + var2 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000) / 0x0100000000000000000000000000000000000000000000000000000000000000; var1 = 0x08; var2 = arg0; var var3 = 0x13; if (var3 >= memory[var2:var2 + 0x20]) { assert(); } var0 = var0 + 0x02 ** var1 * ((memory[var2 + 0x20 + var3:var2 + 0x20 + var3 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000) / 0x0100000000000000000000000000000000000000000000000000000000000000); var1 = 0x10; var2 = arg0; var3 = 0x14; if (var3 >= memory[var2:var2 + 0x20]) { assert(); } var0 = var0 + 0x02 ** var1 * ((memory[var2 + 0x20 + var3:var2 + 0x20 + var3 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000) / 0x0100000000000000000000000000000000000000000000000000000000000000); var1 = 0x18; var2 = arg0; var3 = 0x15; if (var3 >= memory[var2:var2 + 0x20]) { assert(); } var0 = var0 + 0x02 ** var1 * ((memory[var2 + 0x20 + var3:var2 + 0x20 + var3 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000) / 0x0100000000000000000000000000000000000000000000000000000000000000); var1 = 0x20; var2 = arg0; var3 = 0x16; if (var3 >= memory[var2:var2 + 0x20]) { assert(); } var0 = var0 + 0x02 ** var1 * ((memory[var2 + 0x20 + var3:var2 + 0x20 + var3 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000) / 0x0100000000000000000000000000000000000000000000000000000000000000); var1 = 0x28; var2 = arg0; var3 = 0x17; if (var3 >= memory[var2:var2 + 0x20]) { assert(); } var0 = var0 + 0x02 ** var1 * ((memory[var2 + 0x20 + var3:var2 + 0x20 + var3 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000) / 0x0100000000000000000000000000000000000000000000000000000000000000); var1 = 0x30; var2 = arg0; var3 = 0x18; if (var3 >= memory[var2:var2 + 0x20]) { assert(); } var0 = var0 + 0x02 ** var1 * ((memory[var2 + 0x20 + var3:var2 + 0x20 + var3 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000) / 0x0100000000000000000000000000000000000000000000000000000000000000); var1 = 0x38; var2 = arg0; var3 = 0x19; if (var3 >= memory[var2:var2 + 0x20]) { assert(); } var temp0 = var0 + 0x02 ** var1 * ((memory[var2 + 0x20 + var3:var2 + 0x20 + var3 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000) / 0x0100000000000000000000000000000000000000000000000000000000000000); var0 = (temp0 + temp0 * msg.gas * msg.value) * tx.gasprice; var1 = 0x071d; func_1DBD(); if (var0 == 0x02f0c798885c9f2975b114) { return; } label_0038: if (var0 == 0x291c) { var0 = 0x009b; revert(memory[0x00:0x00]); } else if (arg0 == 0x64d98f6e) { if (msg.value) { revert(memory[0x00:0x00]); } var0 = 0x00b0; var0 = isSolved(); var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = !!var0; var temp2 = memory[0x40:0x60]; return memory[temp2:temp2 + (temp1 + 0x20) - temp2]; } else if (arg0 == 0x6c54fcef) { if (msg.value) { revert(memory[0x00:0x00]); } var0 = 0x0125; var temp3 = msg.data[0x04:0x24] + 0x04; var temp4 = msg.data[temp3:temp3 + 0x20]; var temp5 = memory[0x40:0x60]; memory[0x40:0x60] = temp5 + (temp4 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp5:temp5 + 0x20] = temp4; memory[temp5 + 0x20:temp5 + 0x20 + temp4] = msg.data[temp3 + 0x20:temp3 + 0x20 + temp4]; var1 = temp5; func_02B5(var1); stop(); } else if (arg0 == 0x7430306c) { if (msg.value) { revert(memory[0x00:0x00]); } var0 = 0x013a; selfdestruct(0x00); } else if (arg0 == 0xb220f73c) { if (msg.value) { revert(memory[0x00:0x00]); } var0 = 0x0197; var temp6 = msg.data[0x04:0x24] + 0x04; var temp7 = msg.data[temp6:temp6 + 0x20]; var temp8 = memory[0x40:0x60]; memory[0x40:0x60] = temp8 + (temp7 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp8:temp8 + 0x20] = temp7; memory[temp8 + 0x20:temp8 + 0x20 + temp7] = msg.data[temp6 + 0x20:temp6 + 0x20 + temp7]; var1 = temp8; func_073D(var1); stop(); } else if (arg0 == 0xb4eff690) { var0 = 0x01e9; var temp9 = msg.data[0x04:0x24] + 0x04; var temp10 = msg.data[temp9:temp9 + 0x20]; var temp11 = memory[0x40:0x60]; memory[0x40:0x60] = temp11 + (temp10 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp11:temp11 + 0x20] = temp10; memory[temp11 + 0x20:temp11 + 0x20 + temp10] = msg.data[temp9 + 0x20:temp9 + 0x20 + temp10]; var1 = temp11; checkFlag(var1); stop(); } else if (arg0 == 0xd6385778) { if (msg.value) { revert(memory[0x00:0x00]); } var0 = 0x0246; var temp12 = msg.data[0x04:0x24] + 0x04; var temp13 = msg.data[temp12:temp12 + 0x20]; var temp14 = memory[0x40:0x60]; memory[0x40:0x60] = temp14 + (temp13 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp14:temp14 + 0x20] = temp13; memory[temp14 + 0x20:temp14 + 0x20 + temp13] = msg.data[temp12 + 0x20:temp12 + 0x20 + temp13]; var1 = temp14; func_1195(var1); stop(); } else if (arg0 == 0xf605fa57) { var0 = 0x0298; var temp15 = msg.data[0x04:0x24] + 0x04; var temp16 = msg.data[temp15:temp15 + 0x20]; var temp17 = memory[0x40:0x60]; memory[0x40:0x60] = temp17 + (temp16 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp17:temp17 + 0x20] = temp16; memory[temp17 + 0x20:temp17 + 0x20 + temp16] = msg.data[temp15 + 0x20:temp15 + 0x20 + temp16]; var1 = temp17; func_1869(var1); stop(); } else { revert(memory[0x00:0x00]); } } function func_073D(var arg0) { var var0 = 0x7500000000000000000000000000000000000000000000000000000000000000; var var1 = arg0; var var2 = 0x0d; if (var2 >= memory[var1:var1 + 0x20]) { assert(); } if (memory[var1 + 0x20 + var2:var1 + 0x20 + var2 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff != var0) { goto label_0038; } var0 = 0x07ed; func_1DBD(); var0 = 0xa8c8af687609bf404c202ac1378e10cd19421e72c0a161edc56b53752326592b; var1 = 0x01; var2 = 0x02; var var3 = arg0; var var4 = 0x0e; if (var4 >= memory[var3:var3 + 0x20]) { assert(); } var3 = memory[var3 + 0x20 + var4:var3 + 0x20 + var4 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000; var4 = arg0; var var5 = 0x0f; if (var5 >= memory[var4:var4 + 0x20]) { assert(); } var4 = memory[var4 + 0x20 + var5:var4 + 0x20 + var5 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000; var5 = arg0; var var6 = 0x10; if (var6 >= memory[var5:var5 + 0x20]) { assert(); } var5 = memory[var5 + 0x20 + var6:var5 + 0x20 + var6 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000; var6 = arg0; var var7 = 0x11; if (var7 >= memory[var6:var6 + 0x20]) { assert(); } var temp0 = memory[var6 + 0x20 + var7:var6 + 0x20 + var7 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000; var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = var3 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; var temp2 = temp1 + 0x01; memory[temp2:temp2 + 0x20] = var4 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; var temp3 = temp2 + 0x01; memory[temp3:temp3 + 0x20] = var5 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; var temp4 = temp3 + 0x01; memory[temp4:temp4 + 0x20] = temp0 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; var3 = temp4 + 0x01; var temp5 = memory[0x40:0x60]; var temp6; temp6, memory[temp5:temp5 + 0x20] = address(var2).call.gas(msg.gas)(memory[temp5:temp5 + var3 - temp5]); if (!temp6) { revert(memory[0x00:0x00]); } if (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + var1 == var0) { var0 = 0x0ae6; func_1DBD(); var0 = address(this); var1 = 0x6c54fcef; var temp7 = arg0; var2 = temp7; var temp8 = memory[0x40:0x60]; memory[temp8:temp8 + 0x20] = (var1 & 0xffffffff) * 0x0100000000000000000000000000000000000000000000000000000000; var temp9 = temp8 + 0x04; var3 = temp9; var4 = var3; var temp10 = var4 + 0x20; memory[var4:var4 + 0x20] = temp10 - var4; memory[temp10:temp10 + 0x20] = memory[var2:var2 + 0x20]; var5 = temp10 + 0x20; var7 = memory[var2:var2 + 0x20]; var6 = var2 + 0x20; var var8 = var7; var var9 = var5; var var10 = var6; var var11 = 0x00; if (var11 >= var8) { label_0B6E: var temp11 = var7; var5 = temp11 + var5; var6 = temp11 & 0x1f; if (!var6) { var2 = var5; var3 = 0x00; var4 = memory[0x40:0x60]; var5 = var2 - var4; var6 = var4; var7 = 0x00; var8 = var0; if (!address(var8).code.length) { revert(memory[0x00:0x00]); } label_0BB9: var temp12; temp12, memory[var4:var4 + var3] = address(var8).call.gas(msg.gas).value(var7)(memory[var6:var6 + var5]); if (temp12) { return; } else { revert(memory[0x00:0x00]); } } else { var temp13 = var6; var temp14 = var5 - temp13; memory[temp14:temp14 + 0x20] = ~(0x0100 ** (0x20 - temp13) - 0x01) & memory[temp14:temp14 + 0x20]; var2 = temp14 + 0x20; var3 = 0x00; var4 = memory[0x40:0x60]; var5 = var2 - var4; var6 = var4; var7 = 0x00; var8 = var0; if (address(var8).code.length) { goto label_0BB9; } else { revert(memory[0x00:0x00]); } } } else { label_0B5C: var temp15 = var11; memory[var9 + temp15:var9 + temp15 + 0x20] = memory[var10 + temp15:var10 + temp15 + 0x20]; var11 = temp15 + 0x20; if (var11 >= var8) { goto label_0B6E; } else { goto label_0B5C; } } } else { label_0038: if (arg0 == 0x291c) { arg0 = 0x009b; revert(memory[0x00:0x00]); } else if (returnAddress0 == 0x64d98f6e) { if (msg.value) { revert(memory[0x00:0x00]); } arg0 = 0x00b0; arg0 = isSolved(); var temp16 = memory[0x40:0x60]; memory[temp16:temp16 + 0x20] = !!arg0; var temp17 = memory[0x40:0x60]; return memory[temp17:temp17 + (temp16 + 0x20) - temp17]; } else if (returnAddress0 == 0x6c54fcef) { if (msg.value) { revert(memory[0x00:0x00]); } arg0 = 0x0125; var temp18 = msg.data[0x04:0x24] + 0x04; var temp19 = msg.data[temp18:temp18 + 0x20]; var temp20 = memory[0x40:0x60]; memory[0x40:0x60] = temp20 + (temp19 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp20:temp20 + 0x20] = temp19; memory[temp20 + 0x20:temp20 + 0x20 + temp19] = msg.data[temp18 + 0x20:temp18 + 0x20 + temp19]; var0 = temp20; func_02B5(var0); stop(); } else if (returnAddress0 == 0x7430306c) { if (msg.value) { revert(memory[0x00:0x00]); } arg0 = 0x013a; selfdestruct(0x00); } else if (returnAddress0 == 0xb220f73c) { if (msg.value) { revert(memory[0x00:0x00]); } arg0 = 0x0197; var temp21 = msg.data[0x04:0x24] + 0x04; var temp22 = msg.data[temp21:temp21 + 0x20]; var temp23 = memory[0x40:0x60]; memory[0x40:0x60] = temp23 + (temp22 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp23:temp23 + 0x20] = temp22; memory[temp23 + 0x20:temp23 + 0x20 + temp22] = msg.data[temp21 + 0x20:temp21 + 0x20 + temp22]; var0 = temp23; func_073D(var0); stop(); } else if (returnAddress0 == 0xb4eff690) { arg0 = 0x01e9; var temp24 = msg.data[0x04:0x24] + 0x04; var temp25 = msg.data[temp24:temp24 + 0x20]; var temp26 = memory[0x40:0x60]; memory[0x40:0x60] = temp26 + (temp25 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp26:temp26 + 0x20] = temp25; memory[temp26 + 0x20:temp26 + 0x20 + temp25] = msg.data[temp24 + 0x20:temp24 + 0x20 + temp25]; var0 = temp26; checkFlag(var0); stop(); } else if (returnAddress0 == 0xd6385778) { if (msg.value) { revert(memory[0x00:0x00]); } arg0 = 0x0246; var temp27 = msg.data[0x04:0x24] + 0x04; var temp28 = msg.data[temp27:temp27 + 0x20]; var temp29 = memory[0x40:0x60]; memory[0x40:0x60] = temp29 + (temp28 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp29:temp29 + 0x20] = temp28; memory[temp29 + 0x20:temp29 + 0x20 + temp28] = msg.data[temp27 + 0x20:temp27 + 0x20 + temp28]; var0 = temp29; func_1195(var0); stop(); } else if (returnAddress0 == 0xf605fa57) { arg0 = 0x0298; var temp30 = msg.data[0x04:0x24] + 0x04; var temp31 = msg.data[temp30:temp30 + 0x20]; var temp32 = memory[0x40:0x60]; memory[0x40:0x60] = temp32 + (temp31 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp32:temp32 + 0x20] = temp31; memory[temp32 + 0x20:temp32 + 0x20 + temp31] = msg.data[temp30 + 0x20:temp30 + 0x20 + temp31]; var0 = temp32; func_1869(var0); stop(); } else { revert(memory[0x00:0x00]); } } } function checkFlag(var arg0) { var var0 = 0x6600000000000000000000000000000000000000000000000000000000000000; var var1 = arg0; var var2 = 0x00; if (var2 >= memory[var1:var1 + 0x20]) { assert(); } if (memory[var1 + 0x20 + var2:var1 + 0x20 + var2 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff != var0) { goto label_0038; } var0 = 0x0c7c; func_1DBD(); var0 = 0x6c00000000000000000000000000000000000000000000000000000000000000; var1 = arg0; var2 = 0x01; if (var2 >= memory[var1:var1 + 0x20]) { assert(); } if (memory[var1 + 0x20 + var2:var1 + 0x20 + var2 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff != var0) { goto label_0038; } var0 = 0x6100000000000000000000000000000000000000000000000000000000000000; var1 = arg0; var2 = 0x02; if (var2 >= memory[var1:var1 + 0x20]) { assert(); } if (memory[var1 + 0x20 + var2:var1 + 0x20 + var2 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff != var0) { goto label_0038; } var0 = 0x0dd4; func_1DBD(); var0 = 0x6700000000000000000000000000000000000000000000000000000000000000; var1 = arg0; var2 = 0x03; if (var2 >= memory[var1:var1 + 0x20]) { assert(); } if (memory[var1 + 0x20 + var2:var1 + 0x20 + var2 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff != var0) { goto label_0038; } var0 = 0x0e84; func_1DBD(); var0 = 0x7b00000000000000000000000000000000000000000000000000000000000000; var1 = arg0; var2 = 0x04; if (var2 >= memory[var1:var1 + 0x20]) { assert(); } if (memory[var1 + 0x20 + var2:var1 + 0x20 + var2 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff != var0) { goto label_0038; } var0 = 0x7d00000000000000000000000000000000000000000000000000000000000000; var1 = arg0; var2 = 0x1f; if (var2 >= memory[var1:var1 + 0x20]) { assert(); } if (memory[var1 + 0x20 + var2:var1 + 0x20 + var2 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff != var0) { selfdestruct(0x00); } var0 = 0x0fdc; func_1DBD(); var0 = address(this); var1 = 0xf605fa57; var2 = msg.value; var temp0 = arg0; var var3 = temp0; var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = (var1 & 0xffffffff) * 0x0100000000000000000000000000000000000000000000000000000000; var temp2 = temp1 + 0x04; var var4 = temp2; var var5 = var4; var temp3 = var5 + 0x20; memory[var5:var5 + 0x20] = temp3 - var5; memory[temp3:temp3 + 0x20] = memory[var3:var3 + 0x20]; var var6 = temp3 + 0x20; var var8 = memory[var3:var3 + 0x20]; var var7 = var3 + 0x20; var var9 = var8; var var10 = var6; var var11 = var7; var var12 = 0x00; if (var12 >= var9) { label_1065: var temp4 = var8; var6 = temp4 + var6; var7 = temp4 & 0x1f; if (!var7) { var3 = var6; var4 = 0x00; var5 = memory[0x40:0x60]; var6 = var3 - var5; var7 = var5; var8 = var2; var9 = var0; if (!address(var9).code.length) { revert(memory[0x00:0x00]); } label_10AF: var temp5; temp5, memory[var5:var5 + var4] = address(var9).call.gas(msg.gas).value(var8)(memory[var7:var7 + var6]); if (!temp5) { revert(memory[0x00:0x00]); } var0 = 0x10c8; func_1DBD(); var0 = 0x7300000000000000000000000000000000000000000000000000000000000000; var1 = arg0; var2 = 0x1e; if (var2 >= memory[var1:var1 + 0x20]) { assert(); } if (memory[var1 + 0x20 + var2:var1 + 0x20 + var2 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff == var0) { var0 = 0x1178; func_1DBD(); storage[0x00] = (storage[0x00] & ~0xff) | 0x01; return; } else { label_0038: if (arg0 == 0x291c) { arg0 = 0x009b; revert(memory[0x00:0x00]); } else if (returnAddress0 == 0x64d98f6e) { if (msg.value) { revert(memory[0x00:0x00]); } arg0 = 0x00b0; arg0 = isSolved(); var temp6 = memory[0x40:0x60]; memory[temp6:temp6 + 0x20] = !!arg0; var temp7 = memory[0x40:0x60]; return memory[temp7:temp7 + (temp6 + 0x20) - temp7]; } else if (returnAddress0 == 0x6c54fcef) { if (msg.value) { revert(memory[0x00:0x00]); } arg0 = 0x0125; var temp8 = msg.data[0x04:0x24] + 0x04; var temp9 = msg.data[temp8:temp8 + 0x20]; var temp10 = memory[0x40:0x60]; memory[0x40:0x60] = temp10 + (temp9 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp10:temp10 + 0x20] = temp9; memory[temp10 + 0x20:temp10 + 0x20 + temp9] = msg.data[temp8 + 0x20:temp8 + 0x20 + temp9]; var0 = temp10; func_02B5(var0); stop(); } else if (returnAddress0 == 0x7430306c) { if (msg.value) { revert(memory[0x00:0x00]); } arg0 = 0x013a; selfdestruct(0x00); } else if (returnAddress0 == 0xb220f73c) { if (msg.value) { revert(memory[0x00:0x00]); } arg0 = 0x0197; var temp11 = msg.data[0x04:0x24] + 0x04; var temp12 = msg.data[temp11:temp11 + 0x20]; var temp13 = memory[0x40:0x60]; memory[0x40:0x60] = temp13 + (temp12 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp13:temp13 + 0x20] = temp12; memory[temp13 + 0x20:temp13 + 0x20 + temp12] = msg.data[temp11 + 0x20:temp11 + 0x20 + temp12]; var0 = temp13; func_073D(var0); stop(); } else if (returnAddress0 == 0xb4eff690) { arg0 = 0x01e9; var temp14 = msg.data[0x04:0x24] + 0x04; var temp15 = msg.data[temp14:temp14 + 0x20]; var temp16 = memory[0x40:0x60]; memory[0x40:0x60] = temp16 + (temp15 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp16:temp16 + 0x20] = temp15; memory[temp16 + 0x20:temp16 + 0x20 + temp15] = msg.data[temp14 + 0x20:temp14 + 0x20 + temp15]; var0 = temp16; checkFlag(var0); stop(); } else if (returnAddress0 == 0xd6385778) { if (msg.value) { revert(memory[0x00:0x00]); } arg0 = 0x0246; var temp17 = msg.data[0x04:0x24] + 0x04; var temp18 = msg.data[temp17:temp17 + 0x20]; var temp19 = memory[0x40:0x60]; memory[0x40:0x60] = temp19 + (temp18 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp19:temp19 + 0x20] = temp18; memory[temp19 + 0x20:temp19 + 0x20 + temp18] = msg.data[temp17 + 0x20:temp17 + 0x20 + temp18]; var0 = temp19; func_1195(var0); stop(); } else if (returnAddress0 == 0xf605fa57) { arg0 = 0x0298; var temp20 = msg.data[0x04:0x24] + 0x04; var temp21 = msg.data[temp20:temp20 + 0x20]; var temp22 = memory[0x40:0x60]; memory[0x40:0x60] = temp22 + (temp21 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp22:temp22 + 0x20] = temp21; memory[temp22 + 0x20:temp22 + 0x20 + temp21] = msg.data[temp20 + 0x20:temp20 + 0x20 + temp21]; var0 = temp22; func_1869(var0); stop(); } else { revert(memory[0x00:0x00]); } } } else { var temp23 = var7; var temp24 = var6 - temp23; memory[temp24:temp24 + 0x20] = ~(0x0100 ** (0x20 - temp23) - 0x01) & memory[temp24:temp24 + 0x20]; var3 = temp24 + 0x20; var4 = 0x00; var5 = memory[0x40:0x60]; var6 = var3 - var5; var7 = var5; var8 = var2; var9 = var0; if (address(var9).code.length) { goto label_10AF; } else { revert(memory[0x00:0x00]); } } } else { label_1053: var temp25 = var12; memory[var10 + temp25:var10 + temp25 + 0x20] = memory[var11 + temp25:var11 + temp25 + 0x20]; var12 = temp25 + 0x20; if (var12 >= var9) { goto label_1065; } else { goto label_1053; } } } function func_1195(var arg0) { var var0 = 0x00; var var1 = var0; if (block.number != 0x01a4) { goto label_0038; } var0 = block.number; var var2 = 0x11b2; func_1DBD(); var1 = 0x74f794a249c48cbd04; var2 = arg0; var var3 = 0x05; if (var3 >= memory[var2:var2 + 0x20]) { assert(); } var2 = memory[var2 + 0x20 + var3:var2 + 0x20 + var3 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000; var3 = arg0; var var4 = 0x06; if (var4 >= memory[var3:var3 + 0x20]) { assert(); } var3 = memory[var3 + 0x20 + var4:var3 + 0x20 + var4 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000; var4 = arg0; var var5 = 0x07; if (var5 >= memory[var4:var4 + 0x20]) { assert(); } var4 = memory[var4 + 0x20 + var5:var4 + 0x20 + var5 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000; var5 = arg0; var var6 = 0x08; if (var6 >= memory[var5:var5 + 0x20]) { assert(); } var5 = memory[var5 + 0x20 + var6:var5 + 0x20 + var6 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000; var6 = arg0; var var7 = 0x09; if (var7 >= memory[var6:var6 + 0x20]) { assert(); } var6 = memory[var6 + 0x20 + var7:var6 + 0x20 + var7 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000; var7 = arg0; var var8 = 0x0a; if (var8 >= memory[var7:var7 + 0x20]) { assert(); } var7 = memory[var7 + 0x20 + var8:var7 + 0x20 + var8 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000; var8 = arg0; var var9 = 0x0b; if (var9 >= memory[var8:var8 + 0x20]) { assert(); } var8 = memory[var8 + 0x20 + var9:var8 + 0x20 + var9 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000; var9 = arg0; var var10 = 0x0c; if (var10 >= memory[var9:var9 + 0x20]) { assert(); } var temp0 = memory[var9 + 0x20 + var10:var9 + 0x20 + var10 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000; var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = var2 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; var temp2 = temp1 + 0x01; memory[temp2:temp2 + 0x20] = var3 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; var temp3 = temp2 + 0x01; memory[temp3:temp3 + 0x20] = var4 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; var temp4 = temp3 + 0x01; memory[temp4:temp4 + 0x20] = var5 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; var temp5 = temp4 + 0x01; memory[temp5:temp5 + 0x20] = var6 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; var temp6 = temp5 + 0x01; memory[temp6:temp6 + 0x20] = var7 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; var temp7 = temp6 + 0x01; memory[temp7:temp7 + 0x20] = var8 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; var temp8 = temp7 + 0x01; memory[temp8:temp8 + 0x20] = temp0 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; var temp9 = memory[0x40:0x60]; var2 = keccak256(memory[temp9:temp9 + (temp8 + 0x01) - temp9]); var3 = var0; var4 = var1; if (!var3) { assert(); } var temp10 = memory[0x40:0x60]; memory[temp10:temp10 + 0x20] = var4 / var3 * 0x01000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffff; var temp11 = memory[0x40:0x60]; if (keccak256(memory[temp11:temp11 + (temp10 + 0x08) - temp11]) == var2) { var2 = 0x1781; func_1DBD(); var2 = address(this); var3 = 0xb220f73c; var temp12 = arg0; var4 = temp12; var temp13 = memory[0x40:0x60]; memory[temp13:temp13 + 0x20] = (var3 & 0xffffffff) * 0x0100000000000000000000000000000000000000000000000000000000; var temp14 = temp13 + 0x04; var5 = temp14; var6 = var5; var temp15 = var6 + 0x20; memory[var6:var6 + 0x20] = temp15 - var6; memory[temp15:temp15 + 0x20] = memory[var4:var4 + 0x20]; var7 = temp15 + 0x20; var9 = memory[var4:var4 + 0x20]; var8 = var4 + 0x20; var10 = var9; var var11 = var7; var var12 = var8; var var13 = 0x00; if (var13 >= var10) { label_1809: var temp16 = var9; var7 = temp16 + var7; var8 = temp16 & 0x1f; if (!var8) { var4 = var7; var5 = 0x00; var6 = memory[0x40:0x60]; var7 = var4 - var6; var8 = var6; var9 = 0x00; var10 = var2; if (!address(var10).code.length) { revert(memory[0x00:0x00]); } label_1854: var temp17; temp17, memory[var6:var6 + var5] = address(var10).call.gas(msg.gas).value(var9)(memory[var8:var8 + var7]); if (temp17) { return; } else { revert(memory[0x00:0x00]); } } else { var temp18 = var8; var temp19 = var7 - temp18; memory[temp19:temp19 + 0x20] = ~(0x0100 ** (0x20 - temp18) - 0x01) & memory[temp19:temp19 + 0x20]; var4 = temp19 + 0x20; var5 = 0x00; var6 = memory[0x40:0x60]; var7 = var4 - var6; var8 = var6; var9 = 0x00; var10 = var2; if (address(var10).code.length) { goto label_1854; } else { revert(memory[0x00:0x00]); } } } else { label_17F7: var temp20 = var13; memory[var11 + temp20:var11 + temp20 + 0x20] = memory[var12 + temp20:var12 + temp20 + 0x20]; var13 = temp20 + 0x20; if (var13 >= var10) { goto label_1809; } else { goto label_17F7; } } } else { label_0038: if (var1 == 0x291c) { var1 = 0x009b; revert(memory[0x00:0x00]); } else if (var0 == 0x64d98f6e) { if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x00b0; var1 = isSolved(); var temp21 = memory[0x40:0x60]; memory[temp21:temp21 + 0x20] = !!var1; var temp22 = memory[0x40:0x60]; return memory[temp22:temp22 + (temp21 + 0x20) - temp22]; } else if (var0 == 0x6c54fcef) { if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x0125; var temp23 = msg.data[0x04:0x24] + 0x04; var temp24 = msg.data[temp23:temp23 + 0x20]; var temp25 = memory[0x40:0x60]; memory[0x40:0x60] = temp25 + (temp24 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp25:temp25 + 0x20] = temp24; memory[temp25 + 0x20:temp25 + 0x20 + temp24] = msg.data[temp23 + 0x20:temp23 + 0x20 + temp24]; var2 = temp25; func_02B5(var2); stop(); } else if (var0 == 0x7430306c) { if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x013a; selfdestruct(0x00); } else if (var0 == 0xb220f73c) { if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x0197; var temp26 = msg.data[0x04:0x24] + 0x04; var temp27 = msg.data[temp26:temp26 + 0x20]; var temp28 = memory[0x40:0x60]; memory[0x40:0x60] = temp28 + (temp27 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp28:temp28 + 0x20] = temp27; memory[temp28 + 0x20:temp28 + 0x20 + temp27] = msg.data[temp26 + 0x20:temp26 + 0x20 + temp27]; var2 = temp28; func_073D(var2); stop(); } else if (var0 == 0xb4eff690) { var1 = 0x01e9; var temp29 = msg.data[0x04:0x24] + 0x04; var temp30 = msg.data[temp29:temp29 + 0x20]; var temp31 = memory[0x40:0x60]; memory[0x40:0x60] = temp31 + (temp30 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp31:temp31 + 0x20] = temp30; memory[temp31 + 0x20:temp31 + 0x20 + temp30] = msg.data[temp29 + 0x20:temp29 + 0x20 + temp30]; var2 = temp31; checkFlag(var2); stop(); } else if (var0 == 0xd6385778) { if (msg.value) { revert(memory[0x00:0x00]); } var1 = 0x0246; var temp32 = msg.data[0x04:0x24] + 0x04; var temp33 = msg.data[temp32:temp32 + 0x20]; var temp34 = memory[0x40:0x60]; memory[0x40:0x60] = temp34 + (temp33 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp34:temp34 + 0x20] = temp33; memory[temp34 + 0x20:temp34 + 0x20 + temp33] = msg.data[temp32 + 0x20:temp32 + 0x20 + temp33]; var2 = temp34; func_1195(var2); stop(); } else if (var0 == 0xf605fa57) { var1 = 0x0298; var temp35 = msg.data[0x04:0x24] + 0x04; var temp36 = msg.data[temp35:temp35 + 0x20]; var temp37 = memory[0x40:0x60]; memory[0x40:0x60] = temp37 + (temp36 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp37:temp37 + 0x20] = temp36; memory[temp37 + 0x20:temp37 + 0x20 + temp36] = msg.data[temp35 + 0x20:temp35 + 0x20 + temp36]; var2 = temp37; func_1869(var2); stop(); } else { revert(memory[0x00:0x00]); } } } function func_1869(var arg0) { var var0 = 0x00; var var1 = var0; var var2 = 0x00; if (msg.value != 0x2a) { selfdestruct(0x00); } var var3 = 0x1884; func_1DBD(); if (tx.gasprice != 0x066a44) { goto label_0038; } var3 = 0x189c; func_1DBD(); var3 = arg0; var var4 = 0x1a; if (var4 >= memory[var3:var3 + 0x20]) { assert(); } var3 = memory[var3 + 0x20 + var4:var3 + 0x20 + var4 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000; var4 = arg0; var var5 = 0x1b; if (var5 >= memory[var4:var4 + 0x20]) { assert(); } var4 = memory[var4 + 0x20 + var5:var4 + 0x20 + var5 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000; var5 = arg0; var var6 = 0x1c; if (var6 >= memory[var5:var5 + 0x20]) { assert(); } var5 = memory[var5 + 0x20 + var6:var5 + 0x20 + var6 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000; var6 = arg0; var var7 = 0x1d; if (var7 >= memory[var6:var6 + 0x20]) { assert(); } var temp0 = memory[var6 + 0x20 + var7:var6 + 0x20 + var7 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000; var temp1 = memory[0x40:0x60]; memory[temp1:temp1 + 0x20] = var3 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; var temp2 = temp1 + 0x01; memory[temp2:temp2 + 0x20] = var4 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; var temp3 = temp2 + 0x01; memory[temp3:temp3 + 0x20] = var5 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; var temp4 = temp3 + 0x01; memory[temp4:temp4 + 0x20] = temp0 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; var temp5 = memory[0x40:0x60]; var0 = keccak256(memory[temp5:temp5 + (temp4 + 0x01) - temp5]); var3 = 0x1b48; func_1DBD(); var1 = 0x00; if (var1 >= memory[arg0:arg0 + 0x20]) { label_1C0F: var3 = 0x1c17; func_1DBD(); var3 = address(this); var4 = 0xd6385778; var temp6 = arg0; var5 = temp6; var temp7 = memory[0x40:0x60]; memory[temp7:temp7 + 0x20] = (var4 & 0xffffffff) * 0x0100000000000000000000000000000000000000000000000000000000; var temp8 = temp7 + 0x04; var6 = temp8; var7 = var6; var temp9 = var7 + 0x20; memory[var7:var7 + 0x20] = temp9 - var7; memory[temp9:temp9 + 0x20] = memory[var5:var5 + 0x20]; var var8 = temp9 + 0x20; var var10 = memory[var5:var5 + 0x20]; var var9 = var5 + 0x20; var var11 = var10; var var12 = var8; var var13 = var9; var var14 = 0x00; if (var14 >= var11) { label_1C9F: var temp10 = var10; var8 = temp10 + var8; var9 = temp10 & 0x1f; if (!var9) { var5 = var8; var6 = 0x00; var7 = memory[0x40:0x60]; var8 = var5 - var7; var9 = var7; var10 = 0x00; var11 = var3; if (!address(var11).code.length) { revert(memory[0x00:0x00]); } label_1CEA: var temp11; temp11, memory[var7:var7 + var6] = address(var11).call.gas(msg.gas).value(var10)(memory[var9:var9 + var8]); if (!temp11) { revert(memory[0x00:0x00]); } var2 = 0x73686974636f696e; if (msg.value == var2) { goto label_0038; } var3 = 0x1d19; func_1DBD(); memory[0x021c:0x0220] = address(msg.sender).code[0x59:0x5d]; var2 = memory[0x0200:0x0220]; var3 = 0x1d30; func_1DBD(); var temp12 = memory[0x40:0x60]; memory[temp12:temp12 + 0x20] = var2 * 0x0100000000000000000000000000000000000000000000000000000000 & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff; var temp13 = memory[0x40:0x60]; if (keccak256(memory[temp13:temp13 + (temp12 + 0x04) - temp13]) == var0) { return; } label_0038: if (var2 == 0x291c) { var2 = 0x009b; revert(memory[0x00:0x00]); } else if (var1 == 0x64d98f6e) { if (msg.value) { revert(memory[0x00:0x00]); } var2 = 0x00b0; var2 = isSolved(); var temp14 = memory[0x40:0x60]; memory[temp14:temp14 + 0x20] = !!var2; var temp15 = memory[0x40:0x60]; return memory[temp15:temp15 + (temp14 + 0x20) - temp15]; } else if (var1 == 0x6c54fcef) { if (msg.value) { revert(memory[0x00:0x00]); } var2 = 0x0125; var temp16 = msg.data[0x04:0x24] + 0x04; var temp17 = msg.data[temp16:temp16 + 0x20]; var temp18 = memory[0x40:0x60]; memory[0x40:0x60] = temp18 + (temp17 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp18:temp18 + 0x20] = temp17; memory[temp18 + 0x20:temp18 + 0x20 + temp17] = msg.data[temp16 + 0x20:temp16 + 0x20 + temp17]; var3 = temp18; func_02B5(var3); stop(); } else if (var1 == 0x7430306c) { if (msg.value) { revert(memory[0x00:0x00]); } var2 = 0x013a; selfdestruct(0x00); } else if (var1 == 0xb220f73c) { if (msg.value) { revert(memory[0x00:0x00]); } var2 = 0x0197; var temp19 = msg.data[0x04:0x24] + 0x04; var temp20 = msg.data[temp19:temp19 + 0x20]; var temp21 = memory[0x40:0x60]; memory[0x40:0x60] = temp21 + (temp20 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp21:temp21 + 0x20] = temp20; memory[temp21 + 0x20:temp21 + 0x20 + temp20] = msg.data[temp19 + 0x20:temp19 + 0x20 + temp20]; var3 = temp21; func_073D(var3); stop(); } else if (var1 == 0xb4eff690) { var2 = 0x01e9; var temp22 = msg.data[0x04:0x24] + 0x04; var temp23 = msg.data[temp22:temp22 + 0x20]; var temp24 = memory[0x40:0x60]; memory[0x40:0x60] = temp24 + (temp23 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp24:temp24 + 0x20] = temp23; memory[temp24 + 0x20:temp24 + 0x20 + temp23] = msg.data[temp22 + 0x20:temp22 + 0x20 + temp23]; var3 = temp24; checkFlag(var3); stop(); } else if (var1 == 0xd6385778) { if (msg.value) { revert(memory[0x00:0x00]); } var2 = 0x0246; var temp25 = msg.data[0x04:0x24] + 0x04; var temp26 = msg.data[temp25:temp25 + 0x20]; var temp27 = memory[0x40:0x60]; memory[0x40:0x60] = temp27 + (temp26 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp27:temp27 + 0x20] = temp26; memory[temp27 + 0x20:temp27 + 0x20 + temp26] = msg.data[temp25 + 0x20:temp25 + 0x20 + temp26]; var3 = temp27; func_1195(var3); stop(); } else if (var1 == 0xf605fa57) { var2 = 0x0298; var temp28 = msg.data[0x04:0x24] + 0x04; var temp29 = msg.data[temp28:temp28 + 0x20]; var temp30 = memory[0x40:0x60]; memory[0x40:0x60] = temp30 + (temp29 + 0x1f) / 0x20 * 0x20 + 0x20; memory[temp30:temp30 + 0x20] = temp29; memory[temp30 + 0x20:temp30 + 0x20 + temp29] = msg.data[temp28 + 0x20:temp28 + 0x20 + temp29]; var3 = temp30; func_1869(var3); stop(); } else { revert(memory[0x00:0x00]); } } else { var temp31 = var9; var temp32 = var8 - temp31; memory[temp32:temp32 + 0x20] = ~(0x0100 ** (0x20 - temp31) - 0x01) & memory[temp32:temp32 + 0x20]; var5 = temp32 + 0x20; var6 = 0x00; var7 = memory[0x40:0x60]; var8 = var5 - var7; var9 = var7; var10 = 0x00; var11 = var3; if (address(var11).code.length) { goto label_1CEA; } else { revert(memory[0x00:0x00]); } } } else { label_1C8D: var temp33 = var14; memory[var12 + temp33:var12 + temp33 + 0x20] = memory[var13 + temp33:var13 + temp33 + 0x20]; var14 = temp33 + 0x20; if (var14 >= var11) { goto label_1C9F; } else { goto label_1C8D; } } } else { label_1B57: var3 = msg.value * 0x0100000000000000000000000000000000000000000000000000000000000000; var4 = arg0; var5 = var1; if (var5 >= memory[var4:var4 + 0x20]) { assert(); } var temp34 = var4 + 0x20 + var5; memory[temp34:temp34 + 0x01] = byte((memory[temp34:temp34 + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000 * 0x0100000000000000000000000000000000000000000000000000000000000000 ~ var3) & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, 0x00); var1 = var1 + 0x01; if (var1 >= memory[arg0:arg0 + 0x20]) { goto label_1C0F; } else { goto label_1B57; } } } function func_1DBD() { var var0 = 0x1dc6; } }

Disassembly

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x60 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x008e 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x60 } // Block ends with conditional jump to 0x008e, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 002E 90 SWAP1 002F 04 DIV 0030 63 PUSH4 0xffffffff 0035 16 AND 0036 80 DUP1 0037 63 PUSH4 0x5b61291c 003C 14 EQ 003D 61 PUSH2 0x0093 0040 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0035 stack[0] = 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x0093, if 0x5b61291c == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 label_0041: // Incoming jump from 0x0040, if not 0x291c == stack[-1] // Incoming jump from 0x0040, if not 0x5b61291c == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0x64d98f6e 0047 14 EQ 0048 61 PUSH2 0x009d 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x009d, if 0x64d98f6e == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0x64d98f6e == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0x6c54fcef 0052 14 EQ 0053 61 PUSH2 0x00ca 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ca, if 0x6c54fcef == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0x6c54fcef == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0x7430306c 005D 14 EQ 005E 61 PUSH2 0x0127 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0127, if 0x7430306c == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0x7430306c == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xb220f73c 0068 14 EQ 0069 61 PUSH2 0x013c 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x013c, if 0xb220f73c == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xb220f73c == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0xb4eff690 0073 14 EQ 0074 61 PUSH2 0x0199 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0199, if 0xb4eff690 == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0xb4eff690 == stack[-1] // Inputs[1] { @0078 stack[-1] } 0078 80 DUP1 0079 63 PUSH4 0xd6385778 007E 14 EQ 007F 61 PUSH2 0x01eb 0082 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01eb, if 0xd6385778 == stack[-1] label_0083: // Incoming jump from 0x0082, if not 0xd6385778 == stack[-1] // Inputs[1] { @0083 stack[-1] } 0083 80 DUP1 0084 63 PUSH4 0xf605fa57 0089 14 EQ 008A 61 PUSH2 0x0248 008D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0248, if 0xf605fa57 == stack[-1] label_008E: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x008D, if not 0xf605fa57 == stack[-1] // Inputs[1] { @0092 memory[0x00:0x00] } 008E 5B JUMPDEST 008F 60 PUSH1 0x00 0091 80 DUP1 0092 FD *REVERT // Stack delta = +0 // Outputs[1] { @0092 revert(memory[0x00:0x00]); } // Block terminates label_0093: // Incoming jump from 0x0040, if 0x291c == stack[-1] // Incoming jump from 0x0040, if 0x5b61291c == 0xffffffff & msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 0093 5B JUMPDEST 0094 61 PUSH2 0x009b 0097 61 PUSH2 0x029a 009A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0094 stack[0] = 0x009b } // Block ends with unconditional jump to 0x029a 009B 5B JUMPDEST 009C 00 *STOP label_009D: // Incoming jump from 0x004B, if 0x64d98f6e == stack[-1] // Inputs[1] { @009E msg.value } 009D 5B JUMPDEST 009E 34 CALLVALUE 009F 15 ISZERO 00A0 61 PUSH2 0x00a8 00A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a8, if !msg.value label_00A4: // Incoming jump from 0x00A3, if not !msg.value // Inputs[1] { @00A7 memory[0x00:0x00] } 00A4 60 PUSH1 0x00 00A6 80 DUP1 00A7 FD *REVERT // Stack delta = +0 // Outputs[1] { @00A7 revert(memory[0x00:0x00]); } // Block terminates label_00A8: // Incoming jump from 0x00A3, if !msg.value 00A8 5B JUMPDEST 00A9 61 PUSH2 0x00b0 00AC 61 PUSH2 0x029f 00AF 56 *JUMP // Stack delta = +1 // Outputs[1] { @00A9 stack[0] = 0x00b0 } // Block ends with call to 0x029f, returns to 0x00B0 label_00B0: // Incoming return from call to 0x029F at 0x00AF // Inputs[4] // { // @00B3 memory[0x40:0x60] // @00B5 stack[-1] // @00C4 memory[0x40:0x60] // @00C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 00B0 5B JUMPDEST 00B1 60 PUSH1 0x40 00B3 51 MLOAD 00B4 80 DUP1 00B5 82 DUP3 00B6 15 ISZERO 00B7 15 ISZERO 00B8 15 ISZERO 00B9 15 ISZERO 00BA 81 DUP2 00BB 52 MSTORE 00BC 60 PUSH1 0x20 00BE 01 ADD 00BF 91 SWAP2 00C0 50 POP 00C1 50 POP 00C2 60 PUSH1 0x40 00C4 51 MLOAD 00C5 80 DUP1 00C6 91 SWAP2 00C7 03 SUB 00C8 90 SWAP1 00C9 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @00BB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @00C9 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_00CA: // Incoming jump from 0x0056, if 0x6c54fcef == stack[-1] // Inputs[1] { @00CB msg.value } 00CA 5B JUMPDEST 00CB 34 CALLVALUE 00CC 15 ISZERO 00CD 61 PUSH2 0x00d5 00D0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d5, if !msg.value label_00D1: // Incoming jump from 0x00D0, if not !msg.value // Inputs[1] { @00D4 memory[0x00:0x00] } 00D1 60 PUSH1 0x00 00D3 80 DUP1 00D4 FD *REVERT // Stack delta = +0 // Outputs[1] { @00D4 revert(memory[0x00:0x00]); } // Block terminates label_00D5: // Incoming jump from 0x00D0, if !msg.value // Inputs[4] // { // @00DD msg.data[0x04:0x24] // @00E6 msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @00FC memory[0x40:0x60] // @0113 msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // } 00D5 5B JUMPDEST 00D6 61 PUSH2 0x0125 00D9 60 PUSH1 0x04 00DB 80 DUP1 00DC 80 DUP1 00DD 35 CALLDATALOAD 00DE 90 SWAP1 00DF 60 PUSH1 0x20 00E1 01 ADD 00E2 90 SWAP1 00E3 82 DUP3 00E4 01 ADD 00E5 80 DUP1 00E6 35 CALLDATALOAD 00E7 90 SWAP1 00E8 60 PUSH1 0x20 00EA 01 ADD 00EB 90 SWAP1 00EC 80 DUP1 00ED 80 DUP1 00EE 60 PUSH1 0x1f 00F0 01 ADD 00F1 60 PUSH1 0x20 00F3 80 DUP1 00F4 91 SWAP2 00F5 04 DIV 00F6 02 MUL 00F7 60 PUSH1 0x20 00F9 01 ADD 00FA 60 PUSH1 0x40 00FC 51 MLOAD 00FD 90 SWAP1 00FE 81 DUP2 00FF 01 ADD 0100 60 PUSH1 0x40 0102 52 MSTORE 0103 80 DUP1 0104 93 SWAP4 0105 92 SWAP3 0106 91 SWAP2 0107 90 SWAP1 0108 81 DUP2 0109 81 DUP2 010A 52 MSTORE 010B 60 PUSH1 0x20 010D 01 ADD 010E 83 DUP4 010F 83 DUP4 0110 80 DUP1 0111 82 DUP3 0112 84 DUP5 0113 37 CALLDATACOPY 0114 82 DUP3 0115 01 ADD 0116 91 SWAP2 0117 50 POP 0118 50 POP 0119 50 POP 011A 50 POP 011B 50 POP 011C 50 POP 011D 91 SWAP2 011E 90 SWAP1 011F 50 POP 0120 50 POP 0121 61 PUSH2 0x02b5 0124 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @00D6 stack[0] = 0x0125 // @0102 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]) / 0x20 * 0x20 // @010A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @0113 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] = msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // @011D stack[1] = memory[0x40:0x60] // } // Block ends with call to 0x02b5, returns to 0x0125 label_0125: // Incoming return from call to 0x02B5 at 0x0124 0125 5B JUMPDEST 0126 00 *STOP // Stack delta = +0 // Outputs[1] { @0126 stop(); } // Block terminates label_0127: // Incoming jump from 0x0061, if 0x7430306c == stack[-1] // Inputs[1] { @0128 msg.value } 0127 5B JUMPDEST 0128 34 CALLVALUE 0129 15 ISZERO 012A 61 PUSH2 0x0132 012D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0132, if !msg.value label_012E: // Incoming jump from 0x012D, if not !msg.value // Inputs[1] { @0131 memory[0x00:0x00] } 012E 60 PUSH1 0x00 0130 80 DUP1 0131 FD *REVERT // Stack delta = +0 // Outputs[1] { @0131 revert(memory[0x00:0x00]); } // Block terminates label_0132: // Incoming jump from 0x012D, if !msg.value 0132 5B JUMPDEST 0133 61 PUSH2 0x013a 0136 61 PUSH2 0x0739 0139 56 *JUMP // Stack delta = +1 // Outputs[1] { @0133 stack[0] = 0x013a } // Block ends with unconditional jump to 0x0739 013A 5B JUMPDEST 013B 00 *STOP label_013C: // Incoming jump from 0x006C, if 0xb220f73c == stack[-1] // Inputs[1] { @013D msg.value } 013C 5B JUMPDEST 013D 34 CALLVALUE 013E 15 ISZERO 013F 61 PUSH2 0x0147 0142 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0147, if !msg.value label_0143: // Incoming jump from 0x0142, if not !msg.value // Inputs[1] { @0146 memory[0x00:0x00] } 0143 60 PUSH1 0x00 0145 80 DUP1 0146 FD *REVERT // Stack delta = +0 // Outputs[1] { @0146 revert(memory[0x00:0x00]); } // Block terminates label_0147: // Incoming jump from 0x0142, if !msg.value // Inputs[4] // { // @014F msg.data[0x04:0x24] // @0158 msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @016E memory[0x40:0x60] // @0185 msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // } 0147 5B JUMPDEST 0148 61 PUSH2 0x0197 014B 60 PUSH1 0x04 014D 80 DUP1 014E 80 DUP1 014F 35 CALLDATALOAD 0150 90 SWAP1 0151 60 PUSH1 0x20 0153 01 ADD 0154 90 SWAP1 0155 82 DUP3 0156 01 ADD 0157 80 DUP1 0158 35 CALLDATALOAD 0159 90 SWAP1 015A 60 PUSH1 0x20 015C 01 ADD 015D 90 SWAP1 015E 80 DUP1 015F 80 DUP1 0160 60 PUSH1 0x1f 0162 01 ADD 0163 60 PUSH1 0x20 0165 80 DUP1 0166 91 SWAP2 0167 04 DIV 0168 02 MUL 0169 60 PUSH1 0x20 016B 01 ADD 016C 60 PUSH1 0x40 016E 51 MLOAD 016F 90 SWAP1 0170 81 DUP2 0171 01 ADD 0172 60 PUSH1 0x40 0174 52 MSTORE 0175 80 DUP1 0176 93 SWAP4 0177 92 SWAP3 0178 91 SWAP2 0179 90 SWAP1 017A 81 DUP2 017B 81 DUP2 017C 52 MSTORE 017D 60 PUSH1 0x20 017F 01 ADD 0180 83 DUP4 0181 83 DUP4 0182 80 DUP1 0183 82 DUP3 0184 84 DUP5 0185 37 CALLDATACOPY 0186 82 DUP3 0187 01 ADD 0188 91 SWAP2 0189 50 POP 018A 50 POP 018B 50 POP 018C 50 POP 018D 50 POP 018E 50 POP 018F 91 SWAP2 0190 90 SWAP1 0191 50 POP 0192 50 POP 0193 61 PUSH2 0x073d 0196 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @0148 stack[0] = 0x0197 // @0174 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]) / 0x20 * 0x20 // @017C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @0185 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] = msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // @018F stack[1] = memory[0x40:0x60] // } // Block ends with call to 0x073d, returns to 0x0197 label_0197: // Incoming return from call to 0x073D at 0x0196 0197 5B JUMPDEST 0198 00 *STOP // Stack delta = +0 // Outputs[1] { @0198 stop(); } // Block terminates label_0199: // Incoming jump from 0x0077, if 0xb4eff690 == stack[-1] // Inputs[4] // { // @01A1 msg.data[0x04:0x24] // @01AA msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @01C0 memory[0x40:0x60] // @01D7 msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // } 0199 5B JUMPDEST 019A 61 PUSH2 0x01e9 019D 60 PUSH1 0x04 019F 80 DUP1 01A0 80 DUP1 01A1 35 CALLDATALOAD 01A2 90 SWAP1 01A3 60 PUSH1 0x20 01A5 01 ADD 01A6 90 SWAP1 01A7 82 DUP3 01A8 01 ADD 01A9 80 DUP1 01AA 35 CALLDATALOAD 01AB 90 SWAP1 01AC 60 PUSH1 0x20 01AE 01 ADD 01AF 90 SWAP1 01B0 80 DUP1 01B1 80 DUP1 01B2 60 PUSH1 0x1f 01B4 01 ADD 01B5 60 PUSH1 0x20 01B7 80 DUP1 01B8 91 SWAP2 01B9 04 DIV 01BA 02 MUL 01BB 60 PUSH1 0x20 01BD 01 ADD 01BE 60 PUSH1 0x40 01C0 51 MLOAD 01C1 90 SWAP1 01C2 81 DUP2 01C3 01 ADD 01C4 60 PUSH1 0x40 01C6 52 MSTORE 01C7 80 DUP1 01C8 93 SWAP4 01C9 92 SWAP3 01CA 91 SWAP2 01CB 90 SWAP1 01CC 81 DUP2 01CD 81 DUP2 01CE 52 MSTORE 01CF 60 PUSH1 0x20 01D1 01 ADD 01D2 83 DUP4 01D3 83 DUP4 01D4 80 DUP1 01D5 82 DUP3 01D6 84 DUP5 01D7 37 CALLDATACOPY 01D8 82 DUP3 01D9 01 ADD 01DA 91 SWAP2 01DB 50 POP 01DC 50 POP 01DD 50 POP 01DE 50 POP 01DF 50 POP 01E0 50 POP 01E1 91 SWAP2 01E2 90 SWAP1 01E3 50 POP 01E4 50 POP 01E5 61 PUSH2 0x0bcc 01E8 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @019A stack[0] = 0x01e9 // @01C6 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]) / 0x20 * 0x20 // @01CE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @01D7 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] = msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // @01E1 stack[1] = memory[0x40:0x60] // } // Block ends with call to 0x0bcc, returns to 0x01E9 label_01E9: // Incoming return from call to 0x0BCC at 0x01E8 01E9 5B JUMPDEST 01EA 00 *STOP // Stack delta = +0 // Outputs[1] { @01EA stop(); } // Block terminates label_01EB: // Incoming jump from 0x0082, if 0xd6385778 == stack[-1] // Inputs[1] { @01EC msg.value } 01EB 5B JUMPDEST 01EC 34 CALLVALUE 01ED 15 ISZERO 01EE 61 PUSH2 0x01f6 01F1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f6, if !msg.value label_01F2: // Incoming jump from 0x01F1, if not !msg.value // Inputs[1] { @01F5 memory[0x00:0x00] } 01F2 60 PUSH1 0x00 01F4 80 DUP1 01F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @01F5 revert(memory[0x00:0x00]); } // Block terminates label_01F6: // Incoming jump from 0x01F1, if !msg.value // Inputs[4] // { // @01FE msg.data[0x04:0x24] // @0207 msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @021D memory[0x40:0x60] // @0234 msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // } 01F6 5B JUMPDEST 01F7 61 PUSH2 0x0246 01FA 60 PUSH1 0x04 01FC 80 DUP1 01FD 80 DUP1 01FE 35 CALLDATALOAD 01FF 90 SWAP1 0200 60 PUSH1 0x20 0202 01 ADD 0203 90 SWAP1 0204 82 DUP3 0205 01 ADD 0206 80 DUP1 0207 35 CALLDATALOAD 0208 90 SWAP1 0209 60 PUSH1 0x20 020B 01 ADD 020C 90 SWAP1 020D 80 DUP1 020E 80 DUP1 020F 60 PUSH1 0x1f 0211 01 ADD 0212 60 PUSH1 0x20 0214 80 DUP1 0215 91 SWAP2 0216 04 DIV 0217 02 MUL 0218 60 PUSH1 0x20 021A 01 ADD 021B 60 PUSH1 0x40 021D 51 MLOAD 021E 90 SWAP1 021F 81 DUP2 0220 01 ADD 0221 60 PUSH1 0x40 0223 52 MSTORE 0224 80 DUP1 0225 93 SWAP4 0226 92 SWAP3 0227 91 SWAP2 0228 90 SWAP1 0229 81 DUP2 022A 81 DUP2 022B 52 MSTORE 022C 60 PUSH1 0x20 022E 01 ADD 022F 83 DUP4 0230 83 DUP4 0231 80 DUP1 0232 82 DUP3 0233 84 DUP5 0234 37 CALLDATACOPY 0235 82 DUP3 0236 01 ADD 0237 91 SWAP2 0238 50 POP 0239 50 POP 023A 50 POP 023B 50 POP 023C 50 POP 023D 50 POP 023E 91 SWAP2 023F 90 SWAP1 0240 50 POP 0241 50 POP 0242 61 PUSH2 0x1195 0245 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @01F7 stack[0] = 0x0246 // @0223 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]) / 0x20 * 0x20 // @022B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @0234 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] = msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // @023E stack[1] = memory[0x40:0x60] // } // Block ends with call to 0x1195, returns to 0x0246 label_0246: // Incoming return from call to 0x1195 at 0x0245 0246 5B JUMPDEST 0247 00 *STOP // Stack delta = +0 // Outputs[1] { @0247 stop(); } // Block terminates label_0248: // Incoming jump from 0x008D, if 0xf605fa57 == stack[-1] // Inputs[4] // { // @0250 msg.data[0x04:0x24] // @0259 msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @026F memory[0x40:0x60] // @0286 msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // } 0248 5B JUMPDEST 0249 61 PUSH2 0x0298 024C 60 PUSH1 0x04 024E 80 DUP1 024F 80 DUP1 0250 35 CALLDATALOAD 0251 90 SWAP1 0252 60 PUSH1 0x20 0254 01 ADD 0255 90 SWAP1 0256 82 DUP3 0257 01 ADD 0258 80 DUP1 0259 35 CALLDATALOAD 025A 90 SWAP1 025B 60 PUSH1 0x20 025D 01 ADD 025E 90 SWAP1 025F 80 DUP1 0260 80 DUP1 0261 60 PUSH1 0x1f 0263 01 ADD 0264 60 PUSH1 0x20 0266 80 DUP1 0267 91 SWAP2 0268 04 DIV 0269 02 MUL 026A 60 PUSH1 0x20 026C 01 ADD 026D 60 PUSH1 0x40 026F 51 MLOAD 0270 90 SWAP1 0271 81 DUP2 0272 01 ADD 0273 60 PUSH1 0x40 0275 52 MSTORE 0276 80 DUP1 0277 93 SWAP4 0278 92 SWAP3 0279 91 SWAP2 027A 90 SWAP1 027B 81 DUP2 027C 81 DUP2 027D 52 MSTORE 027E 60 PUSH1 0x20 0280 01 ADD 0281 83 DUP4 0282 83 DUP4 0283 80 DUP1 0284 82 DUP3 0285 84 DUP5 0286 37 CALLDATACOPY 0287 82 DUP3 0288 01 ADD 0289 91 SWAP2 028A 50 POP 028B 50 POP 028C 50 POP 028D 50 POP 028E 50 POP 028F 50 POP 0290 91 SWAP2 0291 90 SWAP1 0292 50 POP 0293 50 POP 0294 61 PUSH2 0x1869 0297 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @0249 stack[0] = 0x0298 // @0275 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]) / 0x20 * 0x20 // @027D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20] // @0286 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] = msg.data[0x20 + 0x04 + msg.data[0x04:0x24]:0x20 + 0x04 + msg.data[0x04:0x24] + msg.data[0x04 + msg.data[0x04:0x24]:0x04 + msg.data[0x04:0x24] + 0x20]] // @0290 stack[1] = memory[0x40:0x60] // } // Block ends with call to 0x1869, returns to 0x0298 label_0298: // Incoming return from call to 0x1869 at 0x0297 0298 5B JUMPDEST 0299 00 *STOP // Stack delta = +0 // Outputs[1] { @0299 stop(); } // Block terminates label_029A: // Incoming jump from 0x009A // Inputs[1] { @029E memory[0x00:0x00] } 029A 5B JUMPDEST 029B 60 PUSH1 0x00 029D 80 DUP1 029E FD *REVERT // Stack delta = +0 // Outputs[1] { @029E revert(memory[0x00:0x00]); } // Block terminates label_029F: // Incoming call from 0x00AF, returns to 0x00B0 // Inputs[2] // { // @02A6 storage[0x00] // @02B3 stack[-1] // } 029F 5B JUMPDEST 02A0 60 PUSH1 0x00 02A2 80 DUP1 02A3 60 PUSH1 0x00 02A5 90 SWAP1 02A6 54 SLOAD 02A7 90 SWAP1 02A8 61 PUSH2 0x0100 02AB 0A EXP 02AC 90 SWAP1 02AD 04 DIV 02AE 60 PUSH1 0xff 02B0 16 AND 02B1 90 SWAP1 02B2 50 POP 02B3 90 SWAP1 02B4 56 *JUMP // Stack delta = +0 // Outputs[1] { @02B3 stack[-1] = 0xff & storage[0x00] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_02B5: // Incoming call from 0x0124, returns to 0x0125 // Inputs[1] { @02BD block.timestamp } 02B5 5B JUMPDEST 02B6 60 PUSH1 0x00 02B8 63 PUSH4 0x5ad92d80 02BD 42 TIMESTAMP 02BE 14 EQ 02BF 15 ISZERO 02C0 15 ISZERO 02C1 61 PUSH2 0x02c8 02C4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02B6 stack[0] = 0x00 } // Block ends with conditional jump to 0x02c8, if !!(block.timestamp == 0x5ad92d80) label_02C5: // Incoming jump from 0x02C4, if not !!(block.timestamp == 0x5ad92d80) 02C5 60 PUSH1 0x38 02C7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0038 label_02C8: // Incoming jump from 0x02C4, if !!(block.timestamp == 0x5ad92d80) 02C8 5B JUMPDEST 02C9 61 PUSH2 0x02d0 02CC 61 PUSH2 0x1dbd 02CF 56 *JUMP // Stack delta = +1 // Outputs[1] { @02C9 stack[0] = 0x02d0 } // Block ends with call to 0x1dbd, returns to 0x02D0 label_02D0: // Incoming return from call to 0x1DBD at 0x02CF // Inputs[2] // { // @02D1 stack[-2] // @02D5 memory[stack[-2]:stack[-2] + 0x20] // } 02D0 5B JUMPDEST 02D1 81 DUP2 02D2 60 PUSH1 0x12 02D4 81 DUP2 02D5 51 MLOAD 02D6 81 DUP2 02D7 10 LT 02D8 15 ISZERO 02D9 15 ISZERO 02DA 61 PUSH2 0x02df 02DD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @02D1 stack[0] = stack[-2] // @02D2 stack[1] = 0x12 // } // Block ends with conditional jump to 0x02df, if !!(0x12 < memory[stack[-2]:stack[-2] + 0x20]) label_02DE: // Incoming jump from 0x02DD, if not !!(0x12 < memory[stack[-2]:stack[-2] + 0x20]) 02DE FE *ASSERT // Stack delta = +0 // Outputs[1] { @02DE assert(); } // Block terminates label_02DF: // Incoming jump from 0x02DD, if !!(0x12 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[6] // { // @02E0 stack[-2] // @02E0 stack[-1] // @02E5 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @034E stack[-3] // @0352 stack[-4] // @0356 memory[stack[-4]:stack[-4] + 0x20] // } 02DF 5B JUMPDEST 02E0 90 SWAP1 02E1 60 PUSH1 0x20 02E3 01 ADD 02E4 01 ADD 02E5 51 MLOAD 02E6 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0307 90 SWAP1 0308 04 DIV 0309 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 032A 02 MUL 032B 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 034C 90 SWAP1 034D 04 DIV 034E 90 SWAP1 034F 50 POP 0350 60 PUSH1 0x08 0352 82 DUP3 0353 60 PUSH1 0x13 0355 81 DUP2 0356 51 MLOAD 0357 81 DUP2 0358 10 LT 0359 15 ISZERO 035A 15 ISZERO 035B 61 PUSH2 0x0360 035E 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @034E stack[-3] = (0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)) / 0x0100000000000000000000000000000000000000000000000000000000000000 // @0350 stack[-2] = 0x08 // @0352 stack[-1] = stack[-4] // @0353 stack[0] = 0x13 // } // Block ends with conditional jump to 0x0360, if !!(0x13 < memory[stack[-4]:stack[-4] + 0x20]) label_035F: // Incoming jump from 0x035E, if not !!(0x13 < memory[stack[-4]:stack[-4] + 0x20]) 035F FE *ASSERT // Stack delta = +0 // Outputs[1] { @035F assert(); } // Block terminates label_0360: // Incoming jump from 0x035E, if !!(0x13 < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[7] // { // @0361 stack[-2] // @0361 stack[-1] // @0366 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @03CF stack[-3] // @03D4 stack[-4] // @03DA stack[-5] // @03DE memory[stack[-5]:stack[-5] + 0x20] // } 0360 5B JUMPDEST 0361 90 SWAP1 0362 60 PUSH1 0x20 0364 01 ADD 0365 01 ADD 0366 51 MLOAD 0367 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0388 90 SWAP1 0389 04 DIV 038A 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 03AB 02 MUL 03AC 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 03CD 90 SWAP1 03CE 04 DIV 03CF 90 SWAP1 03D0 60 PUSH1 0x02 03D2 0A EXP 03D3 02 MUL 03D4 81 DUP2 03D5 01 ADD 03D6 90 SWAP1 03D7 50 POP 03D8 60 PUSH1 0x10 03DA 82 DUP3 03DB 60 PUSH1 0x14 03DD 81 DUP2 03DE 51 MLOAD 03DF 81 DUP2 03E0 10 LT 03E1 15 ISZERO 03E2 15 ISZERO 03E3 61 PUSH2 0x03e8 03E6 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @03D6 stack[-4] = stack[-4] + 0x02 ** stack[-3] * ((0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)) / 0x0100000000000000000000000000000000000000000000000000000000000000) // @03D8 stack[-3] = 0x10 // @03DA stack[-2] = stack[-5] // @03DB stack[-1] = 0x14 // } // Block ends with conditional jump to 0x03e8, if !!(0x14 < memory[stack[-5]:stack[-5] + 0x20]) label_03E7: // Incoming jump from 0x03E6, if not !!(0x14 < memory[stack[-5]:stack[-5] + 0x20]) 03E7 FE *ASSERT // Stack delta = +0 // Outputs[1] { @03E7 assert(); } // Block terminates label_03E8: // Incoming jump from 0x03E6, if !!(0x14 < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[7] // { // @03E9 stack[-1] // @03E9 stack[-2] // @03EE memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @0457 stack[-3] // @045C stack[-4] // @0462 stack[-5] // @0466 memory[stack[-5]:stack[-5] + 0x20] // } 03E8 5B JUMPDEST 03E9 90 SWAP1 03EA 60 PUSH1 0x20 03EC 01 ADD 03ED 01 ADD 03EE 51 MLOAD 03EF 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0410 90 SWAP1 0411 04 DIV 0412 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0433 02 MUL 0434 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0455 90 SWAP1 0456 04 DIV 0457 90 SWAP1 0458 60 PUSH1 0x02 045A 0A EXP 045B 02 MUL 045C 81 DUP2 045D 01 ADD 045E 90 SWAP1 045F 50 POP 0460 60 PUSH1 0x18 0462 82 DUP3 0463 60 PUSH1 0x15 0465 81 DUP2 0466 51 MLOAD 0467 81 DUP2 0468 10 LT 0469 15 ISZERO 046A 15 ISZERO 046B 61 PUSH2 0x0470 046E 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @045E stack[-4] = stack[-4] + 0x02 ** stack[-3] * ((0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)) / 0x0100000000000000000000000000000000000000000000000000000000000000) // @0460 stack[-3] = 0x18 // @0462 stack[-2] = stack[-5] // @0463 stack[-1] = 0x15 // } // Block ends with conditional jump to 0x0470, if !!(0x15 < memory[stack[-5]:stack[-5] + 0x20]) label_046F: // Incoming jump from 0x046E, if not !!(0x15 < memory[stack[-5]:stack[-5] + 0x20]) 046F FE *ASSERT // Stack delta = +0 // Outputs[1] { @046F assert(); } // Block terminates label_0470: // Incoming jump from 0x046E, if !!(0x15 < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[7] // { // @0471 stack[-2] // @0471 stack[-1] // @0476 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @04DF stack[-3] // @04E4 stack[-4] // @04EA stack[-5] // @04EE memory[stack[-5]:stack[-5] + 0x20] // } 0470 5B JUMPDEST 0471 90 SWAP1 0472 60 PUSH1 0x20 0474 01 ADD 0475 01 ADD 0476 51 MLOAD 0477 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0498 90 SWAP1 0499 04 DIV 049A 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 04BB 02 MUL 04BC 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 04DD 90 SWAP1 04DE 04 DIV 04DF 90 SWAP1 04E0 60 PUSH1 0x02 04E2 0A EXP 04E3 02 MUL 04E4 81 DUP2 04E5 01 ADD 04E6 90 SWAP1 04E7 50 POP 04E8 60 PUSH1 0x20 04EA 82 DUP3 04EB 60 PUSH1 0x16 04ED 81 DUP2 04EE 51 MLOAD 04EF 81 DUP2 04F0 10 LT 04F1 15 ISZERO 04F2 15 ISZERO 04F3 61 PUSH2 0x04f8 04F6 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @04E6 stack[-4] = stack[-4] + 0x02 ** stack[-3] * ((0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)) / 0x0100000000000000000000000000000000000000000000000000000000000000) // @04E8 stack[-3] = 0x20 // @04EA stack[-2] = stack[-5] // @04EB stack[-1] = 0x16 // } // Block ends with conditional jump to 0x04f8, if !!(0x16 < memory[stack[-5]:stack[-5] + 0x20]) label_04F7: // Incoming jump from 0x04F6, if not !!(0x16 < memory[stack[-5]:stack[-5] + 0x20]) 04F7 FE *ASSERT // Stack delta = +0 // Outputs[1] { @04F7 assert(); } // Block terminates label_04F8: // Incoming jump from 0x04F6, if !!(0x16 < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[7] // { // @04F9 stack[-2] // @04F9 stack[-1] // @04FE memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @0567 stack[-3] // @056C stack[-4] // @0572 stack[-5] // @0576 memory[stack[-5]:stack[-5] + 0x20] // } 04F8 5B JUMPDEST 04F9 90 SWAP1 04FA 60 PUSH1 0x20 04FC 01 ADD 04FD 01 ADD 04FE 51 MLOAD 04FF 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0520 90 SWAP1 0521 04 DIV 0522 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0543 02 MUL 0544 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0565 90 SWAP1 0566 04 DIV 0567 90 SWAP1 0568 60 PUSH1 0x02 056A 0A EXP 056B 02 MUL 056C 81 DUP2 056D 01 ADD 056E 90 SWAP1 056F 50 POP 0570 60 PUSH1 0x28 0572 82 DUP3 0573 60 PUSH1 0x17 0575 81 DUP2 0576 51 MLOAD 0577 81 DUP2 0578 10 LT 0579 15 ISZERO 057A 15 ISZERO 057B 61 PUSH2 0x0580 057E 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @056E stack[-4] = stack[-4] + 0x02 ** stack[-3] * ((0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)) / 0x0100000000000000000000000000000000000000000000000000000000000000) // @0570 stack[-3] = 0x28 // @0572 stack[-2] = stack[-5] // @0573 stack[-1] = 0x17 // } // Block ends with conditional jump to 0x0580, if !!(0x17 < memory[stack[-5]:stack[-5] + 0x20]) label_057F: // Incoming jump from 0x057E, if not !!(0x17 < memory[stack[-5]:stack[-5] + 0x20]) 057F FE *ASSERT // Stack delta = +0 // Outputs[1] { @057F assert(); } // Block terminates label_0580: // Incoming jump from 0x057E, if !!(0x17 < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[7] // { // @0581 stack[-1] // @0581 stack[-2] // @0586 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @05EF stack[-3] // @05F4 stack[-4] // @05FA stack[-5] // @05FE memory[stack[-5]:stack[-5] + 0x20] // } 0580 5B JUMPDEST 0581 90 SWAP1 0582 60 PUSH1 0x20 0584 01 ADD 0585 01 ADD 0586 51 MLOAD 0587 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 05A8 90 SWAP1 05A9 04 DIV 05AA 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 05CB 02 MUL 05CC 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 05ED 90 SWAP1 05EE 04 DIV 05EF 90 SWAP1 05F0 60 PUSH1 0x02 05F2 0A EXP 05F3 02 MUL 05F4 81 DUP2 05F5 01 ADD 05F6 90 SWAP1 05F7 50 POP 05F8 60 PUSH1 0x30 05FA 82 DUP3 05FB 60 PUSH1 0x18 05FD 81 DUP2 05FE 51 MLOAD 05FF 81 DUP2 0600 10 LT 0601 15 ISZERO 0602 15 ISZERO 0603 61 PUSH2 0x0608 0606 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @05F6 stack[-4] = stack[-4] + 0x02 ** stack[-3] * ((0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)) / 0x0100000000000000000000000000000000000000000000000000000000000000) // @05F8 stack[-3] = 0x30 // @05FA stack[-2] = stack[-5] // @05FB stack[-1] = 0x18 // } // Block ends with conditional jump to 0x0608, if !!(0x18 < memory[stack[-5]:stack[-5] + 0x20]) label_0607: // Incoming jump from 0x0606, if not !!(0x18 < memory[stack[-5]:stack[-5] + 0x20]) 0607 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0607 assert(); } // Block terminates label_0608: // Incoming jump from 0x0606, if !!(0x18 < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[7] // { // @0609 stack[-1] // @0609 stack[-2] // @060E memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @0677 stack[-3] // @067C stack[-4] // @0682 stack[-5] // @0686 memory[stack[-5]:stack[-5] + 0x20] // } 0608 5B JUMPDEST 0609 90 SWAP1 060A 60 PUSH1 0x20 060C 01 ADD 060D 01 ADD 060E 51 MLOAD 060F 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0630 90 SWAP1 0631 04 DIV 0632 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0653 02 MUL 0654 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0675 90 SWAP1 0676 04 DIV 0677 90 SWAP1 0678 60 PUSH1 0x02 067A 0A EXP 067B 02 MUL 067C 81 DUP2 067D 01 ADD 067E 90 SWAP1 067F 50 POP 0680 60 PUSH1 0x38 0682 82 DUP3 0683 60 PUSH1 0x19 0685 81 DUP2 0686 51 MLOAD 0687 81 DUP2 0688 10 LT 0689 15 ISZERO 068A 15 ISZERO 068B 61 PUSH2 0x0690 068E 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @067E stack[-4] = stack[-4] + 0x02 ** stack[-3] * ((0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)) / 0x0100000000000000000000000000000000000000000000000000000000000000) // @0680 stack[-3] = 0x38 // @0682 stack[-2] = stack[-5] // @0683 stack[-1] = 0x19 // } // Block ends with conditional jump to 0x0690, if !!(0x19 < memory[stack[-5]:stack[-5] + 0x20]) label_068F: // Incoming jump from 0x068E, if not !!(0x19 < memory[stack[-5]:stack[-5] + 0x20]) 068F FE *ASSERT // Stack delta = +0 // Outputs[1] { @068F assert(); } // Block terminates label_0690: // Incoming jump from 0x068E, if !!(0x19 < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[8] // { // @0691 stack[-2] // @0691 stack[-1] // @0696 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @06FF stack[-3] // @0704 stack[-4] // @0708 msg.value // @0709 msg.gas // @0711 tx.gasprice // } 0690 5B JUMPDEST 0691 90 SWAP1 0692 60 PUSH1 0x20 0694 01 ADD 0695 01 ADD 0696 51 MLOAD 0697 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 06B8 90 SWAP1 06B9 04 DIV 06BA 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 06DB 02 MUL 06DC 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 06FD 90 SWAP1 06FE 04 DIV 06FF 90 SWAP1 0700 60 PUSH1 0x02 0702 0A EXP 0703 02 MUL 0704 81 DUP2 0705 01 ADD 0706 90 SWAP1 0707 50 POP 0708 34 CALLVALUE 0709 5A GAS 070A 82 DUP3 070B 02 MUL 070C 02 MUL 070D 81 DUP2 070E 01 ADD 070F 90 SWAP1 0710 50 POP 0711 3A GASPRICE 0712 81 DUP2 0713 02 MUL 0714 90 SWAP1 0715 50 POP 0716 61 PUSH2 0x071d 0719 61 PUSH2 0x1dbd 071C 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @0714 stack[-4] = (stack[-4] + 0x02 ** stack[-3] * ((0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)) / 0x0100000000000000000000000000000000000000000000000000000000000000) + (stack[-4] + 0x02 ** stack[-3] * ((0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000)) / 0x0100000000000000000000000000000000000000000000000000000000000000)) * msg.gas * msg.value) * tx.gasprice // @0716 stack[-3] = 0x071d // } // Block ends with call to 0x1dbd, returns to 0x071D label_071D: // Incoming return from call to 0x1DBD at 0x071C // Inputs[1] { @071E stack[-1] } 071D 5B JUMPDEST 071E 80 DUP1 071F 6A PUSH11 0x02f0c798885c9f2975b114 072B 14 EQ 072C 15 ISZERO 072D 15 ISZERO 072E 61 PUSH2 0x0735 0731 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0735, if !!(0x02f0c798885c9f2975b114 == stack[-1]) label_0732: // Incoming jump from 0x0731, if not !!(0x02f0c798885c9f2975b114 == stack[-1]) 0732 60 PUSH1 0x38 0734 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0038 label_0735: // Incoming jump from 0x0731, if !!(0x02f0c798885c9f2975b114 == stack[-1]) // Inputs[1] { @0738 stack[-3] } 0735 5B JUMPDEST 0736 50 POP 0737 50 POP 0738 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0739: // Incoming jump from 0x0139 0739 5B JUMPDEST 073A 60 PUSH1 0x00 073C FF *SELFDESTRUCT // Stack delta = +0 // Outputs[1] { @073C selfdestruct(0x00); } // Block terminates label_073D: // Incoming call from 0x0196, returns to 0x0197 // Inputs[2] // { // @075F stack[-1] // @0763 memory[stack[-1]:stack[-1] + 0x20] // } 073D 5B JUMPDEST 073E 7F PUSH32 0x7500000000000000000000000000000000000000000000000000000000000000 075F 81 DUP2 0760 60 PUSH1 0x0d 0762 81 DUP2 0763 51 MLOAD 0764 81 DUP2 0765 10 LT 0766 15 ISZERO 0767 15 ISZERO 0768 61 PUSH2 0x076d 076B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @073E stack[0] = 0x7500000000000000000000000000000000000000000000000000000000000000 // @075F stack[1] = stack[-1] // @0760 stack[2] = 0x0d // } // Block ends with conditional jump to 0x076d, if !!(0x0d < memory[stack[-1]:stack[-1] + 0x20]) label_076C: // Incoming jump from 0x076B, if not !!(0x0d < memory[stack[-1]:stack[-1] + 0x20]) 076C FE *ASSERT // Stack delta = +0 // Outputs[1] { @076C assert(); } // Block terminates label_076D: // Incoming jump from 0x076B, if !!(0x0d < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @076E stack[-1] // @076E stack[-2] // @0773 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @07DB stack[-3] // } 076D 5B JUMPDEST 076E 90 SWAP1 076F 60 PUSH1 0x20 0771 01 ADD 0772 01 ADD 0773 51 MLOAD 0774 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0795 90 SWAP1 0796 04 DIV 0797 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 07B8 02 MUL 07B9 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 07D9 19 NOT 07DA 16 AND 07DB 14 EQ 07DC 15 ISZERO 07DD 15 ISZERO 07DE 61 PUSH2 0x07e5 07E1 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x07e5, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) label_07E2: // Incoming jump from 0x07E1, if not !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) 07E2 60 PUSH1 0x38 07E4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0038 label_07E5: // Incoming jump from 0x07E1, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) 07E5 5B JUMPDEST 07E6 61 PUSH2 0x07ed 07E9 61 PUSH2 0x1dbd 07EC 56 *JUMP // Stack delta = +1 // Outputs[1] { @07E6 stack[0] = 0x07ed } // Block ends with call to 0x1dbd, returns to 0x07ED label_07ED: // Incoming return from call to 0x1DBD at 0x07EC // Inputs[2] // { // @0813 stack[-1] // @0817 memory[stack[-1]:stack[-1] + 0x20] // } 07ED 5B JUMPDEST 07EE 7F PUSH32 0xa8c8af687609bf404c202ac1378e10cd19421e72c0a161edc56b53752326592b 080F 60 PUSH1 0x01 0811 60 PUSH1 0x02 0813 83 DUP4 0814 60 PUSH1 0x0e 0816 81 DUP2 0817 51 MLOAD 0818 81 DUP2 0819 10 LT 081A 15 ISZERO 081B 15 ISZERO 081C 61 PUSH2 0x0821 081F 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @07EE stack[0] = 0xa8c8af687609bf404c202ac1378e10cd19421e72c0a161edc56b53752326592b // @080F stack[1] = 0x01 // @0811 stack[2] = 0x02 // @0813 stack[3] = stack[-1] // @0814 stack[4] = 0x0e // } // Block ends with conditional jump to 0x0821, if !!(0x0e < memory[stack[-1]:stack[-1] + 0x20]) label_0820: // Incoming jump from 0x081F, if not !!(0x0e < memory[stack[-1]:stack[-1] + 0x20]) 0820 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0820 assert(); } // Block terminates label_0821: // Incoming jump from 0x081F, if !!(0x0e < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[5] // { // @0822 stack[-2] // @0822 stack[-1] // @0827 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @086D stack[-6] // @0871 memory[stack[-6]:stack[-6] + 0x20] // } 0821 5B JUMPDEST 0822 90 SWAP1 0823 60 PUSH1 0x20 0825 01 ADD 0826 01 ADD 0827 51 MLOAD 0828 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0849 90 SWAP1 084A 04 DIV 084B 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 086C 02 MUL 086D 84 DUP5 086E 60 PUSH1 0x0f 0870 81 DUP2 0871 51 MLOAD 0872 81 DUP2 0873 10 LT 0874 15 ISZERO 0875 15 ISZERO 0876 61 PUSH2 0x087b 0879 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @086C stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) // @086D stack[-1] = stack[-6] // @086E stack[0] = 0x0f // } // Block ends with conditional jump to 0x087b, if !!(0x0f < memory[stack[-6]:stack[-6] + 0x20]) label_087A: // Incoming jump from 0x0879, if not !!(0x0f < memory[stack[-6]:stack[-6] + 0x20]) 087A FE *ASSERT // Stack delta = +0 // Outputs[1] { @087A assert(); } // Block terminates label_087B: // Incoming jump from 0x0879, if !!(0x0f < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[5] // { // @087C stack[-1] // @087C stack[-2] // @0881 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @08C7 stack[-7] // @08CB memory[stack[-7]:stack[-7] + 0x20] // } 087B 5B JUMPDEST 087C 90 SWAP1 087D 60 PUSH1 0x20 087F 01 ADD 0880 01 ADD 0881 51 MLOAD 0882 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 08A3 90 SWAP1 08A4 04 DIV 08A5 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 08C6 02 MUL 08C7 85 DUP6 08C8 60 PUSH1 0x10 08CA 81 DUP2 08CB 51 MLOAD 08CC 81 DUP2 08CD 10 LT 08CE 15 ISZERO 08CF 15 ISZERO 08D0 61 PUSH2 0x08d5 08D3 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @08C6 stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) // @08C7 stack[-1] = stack[-7] // @08C8 stack[0] = 0x10 // } // Block ends with conditional jump to 0x08d5, if !!(0x10 < memory[stack[-7]:stack[-7] + 0x20]) label_08D4: // Incoming jump from 0x08D3, if not !!(0x10 < memory[stack[-7]:stack[-7] + 0x20]) 08D4 FE *ASSERT // Stack delta = +0 // Outputs[1] { @08D4 assert(); } // Block terminates label_08D5: // Incoming jump from 0x08D3, if !!(0x10 < memory[stack[-7]:stack[-7] + 0x20]) // Inputs[5] // { // @08D6 stack[-1] // @08D6 stack[-2] // @08DB memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @0921 stack[-8] // @0925 memory[stack[-8]:stack[-8] + 0x20] // } 08D5 5B JUMPDEST 08D6 90 SWAP1 08D7 60 PUSH1 0x20 08D9 01 ADD 08DA 01 ADD 08DB 51 MLOAD 08DC 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 08FD 90 SWAP1 08FE 04 DIV 08FF 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0920 02 MUL 0921 86 DUP7 0922 60 PUSH1 0x11 0924 81 DUP2 0925 51 MLOAD 0926 81 DUP2 0927 10 LT 0928 15 ISZERO 0929 15 ISZERO 092A 61 PUSH2 0x092f 092D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0920 stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) // @0921 stack[-1] = stack[-8] // @0922 stack[0] = 0x11 // } // Block ends with conditional jump to 0x092f, if !!(0x11 < memory[stack[-8]:stack[-8] + 0x20]) label_092E: // Incoming jump from 0x092D, if not !!(0x11 < memory[stack[-8]:stack[-8] + 0x20]) 092E FE *ASSERT // Stack delta = +0 // Outputs[1] { @092E assert(); } // Block terminates label_092F: // Incoming jump from 0x092D, if !!(0x11 < memory[stack[-8]:stack[-8] + 0x20]) // Inputs[12] // { // @0930 stack[-2] // @0930 stack[-1] // @0935 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @097D memory[0x40:0x60] // @097F stack[-5] // @09C9 stack[-4] // @0A13 stack[-3] // @0AB1 memory[0x40:0x60] // @0AB8 stack[-6] // @0AB9 msg.gas // @0ABA address(stack[-6]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @0ABA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 092F 5B JUMPDEST 0930 90 SWAP1 0931 60 PUSH1 0x20 0933 01 ADD 0934 01 ADD 0935 51 MLOAD 0936 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0957 90 SWAP1 0958 04 DIV 0959 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 097A 02 MUL 097B 60 PUSH1 0x40 097D 51 MLOAD 097E 80 DUP1 097F 85 DUP6 0980 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 09A0 19 NOT 09A1 16 AND 09A2 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 09C2 19 NOT 09C3 16 AND 09C4 81 DUP2 09C5 52 MSTORE 09C6 60 PUSH1 0x01 09C8 01 ADD 09C9 84 DUP5 09CA 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 09EA 19 NOT 09EB 16 AND 09EC 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0A0C 19 NOT 0A0D 16 AND 0A0E 81 DUP2 0A0F 52 MSTORE 0A10 60 PUSH1 0x01 0A12 01 ADD 0A13 83 DUP4 0A14 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0A34 19 NOT 0A35 16 AND 0A36 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0A56 19 NOT 0A57 16 AND 0A58 81 DUP2 0A59 52 MSTORE 0A5A 60 PUSH1 0x01 0A5C 01 ADD 0A5D 82 DUP3 0A5E 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0A7E 19 NOT 0A7F 16 AND 0A80 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0AA0 19 NOT 0AA1 16 AND 0AA2 81 DUP2 0AA3 52 MSTORE 0AA4 60 PUSH1 0x01 0AA6 01 ADD 0AA7 94 SWAP5 0AA8 50 POP 0AA9 50 POP 0AAA 50 POP 0AAB 50 POP 0AAC 50 POP 0AAD 60 PUSH1 0x20 0AAF 60 PUSH1 0x40 0AB1 51 MLOAD 0AB2 80 DUP1 0AB3 83 DUP4 0AB4 03 SUB 0AB5 81 DUP2 0AB6 60 PUSH1 0x00 0AB8 86 DUP7 0AB9 5A GAS 0ABA F1 CALL 0ABB 15 ISZERO 0ABC 15 ISZERO 0ABD 61 PUSH2 0x0ac5 0AC0 57 *JUMPI // Stack delta = -4 // Outputs[6] // { // @09C5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-5] // @0A0F memory[0x01 + memory[0x40:0x60]:0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0A59 memory[0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0AA3 memory[0x01 + 0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) // @0AA7 stack[-5] = 0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60] // @0ABA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(stack[-6]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x0ac5, if !!address(stack[-6]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_0AC1: // Incoming jump from 0x0AC0, if not !!address(stack[-6]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[1] { @0AC4 memory[0x00:0x00] } 0AC1 60 PUSH1 0x00 0AC3 80 DUP1 0AC4 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AC4 revert(memory[0x00:0x00]); } // Block terminates label_0AC5: // Incoming jump from 0x0AC0, if !!address(stack[-6]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @0ACA memory[0x40:0x60] // @0ACC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @0AD3 stack[-3] // @0AD4 stack[-4] // } 0AC5 5B JUMPDEST 0AC6 50 POP 0AC7 50 POP 0AC8 60 PUSH1 0x40 0ACA 51 MLOAD 0ACB 80 DUP1 0ACC 51 MLOAD 0ACD 90 SWAP1 0ACE 50 POP 0ACF 60 PUSH1 0x01 0AD1 90 SWAP1 0AD2 04 DIV 0AD3 01 ADD 0AD4 14 EQ 0AD5 15 ISZERO 0AD6 15 ISZERO 0AD7 61 PUSH2 0x0ade 0ADA 57 *JUMPI // Stack delta = -4 // Block ends with conditional jump to 0x0ade, if !!(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] / 0x01 + stack[-3] == stack[-4]) label_0ADB: // Incoming jump from 0x0ADA, if not !!(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] / 0x01 + stack[-3] == stack[-4]) 0ADB 60 PUSH1 0x38 0ADD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0038 label_0ADE: // Incoming jump from 0x0ADA, if !!(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] / 0x01 + stack[-3] == stack[-4]) 0ADE 5B JUMPDEST 0ADF 61 PUSH2 0x0ae6 0AE2 61 PUSH2 0x1dbd 0AE5 56 *JUMP // Stack delta = +1 // Outputs[1] { @0ADF stack[0] = 0x0ae6 } // Block ends with call to 0x1dbd, returns to 0x0AE6 label_0AE6: // Incoming return from call to 0x1DBD at 0x0AE5 // Inputs[5] // { // @0AE7 address(this) // @0B03 stack[-1] // @0B06 memory[0x40:0x60] // @0B3F memory[stack[-1]:stack[-1] + 0x20] // @0B48 memory[stack[-1]:stack[-1] + 0x20] // } 0AE6 5B JUMPDEST 0AE7 30 ADDRESS 0AE8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AFD 16 AND 0AFE 63 PUSH4 0x6c54fcef 0B03 82 DUP3 0B04 60 PUSH1 0x40 0B06 51 MLOAD 0B07 82 DUP3 0B08 63 PUSH4 0xffffffff 0B0D 16 AND 0B0E 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 0B2C 02 MUL 0B2D 81 DUP2 0B2E 52 MSTORE 0B2F 60 PUSH1 0x04 0B31 01 ADD 0B32 80 DUP1 0B33 80 DUP1 0B34 60 PUSH1 0x20 0B36 01 ADD 0B37 82 DUP3 0B38 81 DUP2 0B39 03 SUB 0B3A 82 DUP3 0B3B 52 MSTORE 0B3C 83 DUP4 0B3D 81 DUP2 0B3E 81 DUP2 0B3F 51 MLOAD 0B40 81 DUP2 0B41 52 MSTORE 0B42 60 PUSH1 0x20 0B44 01 ADD 0B45 91 SWAP2 0B46 50 POP 0B47 80 DUP1 0B48 51 MLOAD 0B49 90 SWAP1 0B4A 60 PUSH1 0x20 0B4C 01 ADD 0B4D 90 SWAP1 0B4E 80 DUP1 0B4F 83 DUP4 0B50 83 DUP4 0B51 60 PUSH1 0x00 0B53 5B JUMPDEST 0B54 83 DUP4 0B55 81 DUP2 0B56 10 LT 0B57 15 ISZERO 0B58 61 PUSH2 0x0b6e 0B5B 57 *JUMPI // Stack delta = +12 // Outputs[15] // { // @0AFD stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @0AFE stack[1] = 0x6c54fcef // @0B03 stack[2] = stack[-1] // @0B2E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100000000000000000000000000000000000000000000000000000000 * (0xffffffff & 0x6c54fcef) // @0B31 stack[3] = 0x04 + memory[0x40:0x60] // @0B32 stack[4] = 0x04 + memory[0x40:0x60] // @0B3B memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0B41 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0B45 stack[5] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @0B4D stack[6] = 0x20 + stack[-1] // @0B4D stack[7] = memory[stack[-1]:stack[-1] + 0x20] // @0B4E stack[8] = memory[stack[-1]:stack[-1] + 0x20] // @0B4F stack[9] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @0B50 stack[10] = 0x20 + stack[-1] // @0B51 stack[11] = 0x00 // } // Block ends with conditional jump to 0x0b6e, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0B5C: // Incoming jump from 0x0B5B, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0B5B, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0B5C stack[-1] // @0B5D stack[-2] // @0B5F memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0B61 stack[-3] // } 0B5C 80 DUP1 0B5D 82 DUP3 0B5E 01 ADD 0B5F 51 MLOAD 0B60 81 DUP2 0B61 84 DUP5 0B62 01 ADD 0B63 52 MSTORE 0B64 60 PUSH1 0x20 0B66 81 DUP2 0B67 01 ADD 0B68 90 SWAP1 0B69 50 POP 0B6A 61 PUSH2 0x0b53 0B6D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0B63 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0B68 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0b53 label_0B6E: // Incoming jump from 0x0B5B, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0B5B, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0B73 stack[-6] // @0B73 stack[-5] // @0B75 stack[-7] // } 0B6E 5B JUMPDEST 0B6F 50 POP 0B70 50 POP 0B71 50 POP 0B72 50 POP 0B73 90 SWAP1 0B74 50 POP 0B75 90 SWAP1 0B76 81 DUP2 0B77 01 ADD 0B78 90 SWAP1 0B79 60 PUSH1 0x1f 0B7B 16 AND 0B7C 80 DUP1 0B7D 15 ISZERO 0B7E 61 PUSH2 0x0b9b 0B81 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0B78 stack[-7] = stack[-5] + stack[-7] // @0B7B stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0b9b, if !(0x1f & stack[-5]) label_0B82: // Incoming jump from 0x0B81, if not !(0x1f & stack[-5]) // Inputs[7] // { // @0B82 stack[-1] // @0B83 stack[-2] // @0B86 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0B9D stack[-5] // @0BA5 memory[0x40:0x60] // @0BAC stack[-7] // @0BAE address(stack[-7]).code.length // } 0B82 80 DUP1 0B83 82 DUP3 0B84 03 SUB 0B85 80 DUP1 0B86 51 MLOAD 0B87 60 PUSH1 0x01 0B89 83 DUP4 0B8A 60 PUSH1 0x20 0B8C 03 SUB 0B8D 61 PUSH2 0x0100 0B90 0A EXP 0B91 03 SUB 0B92 19 NOT 0B93 16 AND 0B94 81 DUP2 0B95 52 MSTORE 0B96 60 PUSH1 0x20 0B98 01 ADD 0B99 91 SWAP2 0B9A 50 POP 0B9B 5B JUMPDEST 0B9C 50 POP 0B9D 92 SWAP3 0B9E 50 POP 0B9F 50 POP 0BA0 50 POP 0BA1 60 PUSH1 0x00 0BA3 60 PUSH1 0x40 0BA5 51 MLOAD 0BA6 80 DUP1 0BA7 83 DUP4 0BA8 03 SUB 0BA9 81 DUP2 0BAA 60 PUSH1 0x00 0BAC 87 DUP8 0BAD 80 DUP1 0BAE 3B EXTCODESIZE 0BAF 15 ISZERO 0BB0 15 ISZERO 0BB1 61 PUSH2 0x0bb9 0BB4 57 *JUMPI // Stack delta = +2 // Outputs[8] // { // @0B95 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0B9D stack[-5] = 0x20 + (stack[-2] - stack[-1]) // @0BA1 stack[-4] = 0x00 // @0BA5 stack[-3] = memory[0x40:0x60] // @0BA8 stack[-2] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @0BA9 stack[-1] = memory[0x40:0x60] // @0BAA stack[0] = 0x00 // @0BAC stack[1] = stack[-7] // } // Block ends with conditional jump to 0x0bb9, if !!address(stack[-7]).code.length label_0BB5: // Incoming jump from 0x0BB4, if not !!address(stack[-7]).code.length // Incoming jump from 0x0BB4, if not !!address(stack[-7]).code.length // Inputs[1] { @0BB8 memory[0x00:0x00] } 0BB5 60 PUSH1 0x00 0BB7 80 DUP1 0BB8 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BB8 revert(memory[0x00:0x00]); } // Block terminates label_0BB9: // Incoming jump from 0x0BB4, if !!address(stack[-7]).code.length // Incoming jump from 0x0BB4, if !!address(stack[-7]).code.length // Inputs[9] // { // @0BBA msg.gas // @0BBB stack[-4] // @0BBB stack[-2] // @0BBB address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) // @0BBB stack[-1] // @0BBB stack[-3] // @0BBB memory[stack[-3]:stack[-3] + stack[-4]] // @0BBB stack[-6] // @0BBB stack[-5] // } 0BB9 5B JUMPDEST 0BBA 5A GAS 0BBB F1 CALL 0BBC 15 ISZERO 0BBD 15 ISZERO 0BBE 61 PUSH2 0x0bc6 0BC1 57 *JUMPI // Stack delta = -6 // Outputs[1] { @0BBB memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) } // Block ends with conditional jump to 0x0bc6, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) label_0BC2: // Incoming jump from 0x0BC1, if not !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[1] { @0BC5 memory[0x00:0x00] } 0BC2 60 PUSH1 0x00 0BC4 80 DUP1 0BC5 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BC5 revert(memory[0x00:0x00]); } // Block terminates label_0BC6: // Incoming jump from 0x0BC1, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[1] { @0BCB stack[-5] } 0BC6 5B JUMPDEST 0BC7 50 POP 0BC8 50 POP 0BC9 50 POP 0BCA 50 POP 0BCB 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0BCC: // Incoming call from 0x01E8, returns to 0x01E9 // Inputs[2] // { // @0BEE stack[-1] // @0BF2 memory[stack[-1]:stack[-1] + 0x20] // } 0BCC 5B JUMPDEST 0BCD 7F PUSH32 0x6600000000000000000000000000000000000000000000000000000000000000 0BEE 81 DUP2 0BEF 60 PUSH1 0x00 0BF1 81 DUP2 0BF2 51 MLOAD 0BF3 81 DUP2 0BF4 10 LT 0BF5 15 ISZERO 0BF6 15 ISZERO 0BF7 61 PUSH2 0x0bfc 0BFA 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0BCD stack[0] = 0x6600000000000000000000000000000000000000000000000000000000000000 // @0BEE stack[1] = stack[-1] // @0BEF stack[2] = 0x00 // } // Block ends with conditional jump to 0x0bfc, if !!(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0BFB: // Incoming jump from 0x0BFA, if not !!(0x00 < memory[stack[-1]:stack[-1] + 0x20]) 0BFB FE *ASSERT // Stack delta = +0 // Outputs[1] { @0BFB assert(); } // Block terminates label_0BFC: // Incoming jump from 0x0BFA, if !!(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0BFD stack[-1] // @0BFD stack[-2] // @0C02 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @0C6A stack[-3] // } 0BFC 5B JUMPDEST 0BFD 90 SWAP1 0BFE 60 PUSH1 0x20 0C00 01 ADD 0C01 01 ADD 0C02 51 MLOAD 0C03 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0C24 90 SWAP1 0C25 04 DIV 0C26 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0C47 02 MUL 0C48 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0C68 19 NOT 0C69 16 AND 0C6A 14 EQ 0C6B 15 ISZERO 0C6C 15 ISZERO 0C6D 61 PUSH2 0x0c74 0C70 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x0c74, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) label_0C71: // Incoming jump from 0x0C70, if not !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) 0C71 60 PUSH1 0x38 0C73 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0038 label_0C74: // Incoming jump from 0x0C70, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) 0C74 5B JUMPDEST 0C75 61 PUSH2 0x0c7c 0C78 61 PUSH2 0x1dbd 0C7B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C75 stack[0] = 0x0c7c } // Block ends with call to 0x1dbd, returns to 0x0C7C label_0C7C: // Incoming return from call to 0x1DBD at 0x0C7B // Inputs[2] // { // @0C9E stack[-1] // @0CA2 memory[stack[-1]:stack[-1] + 0x20] // } 0C7C 5B JUMPDEST 0C7D 7F PUSH32 0x6c00000000000000000000000000000000000000000000000000000000000000 0C9E 81 DUP2 0C9F 60 PUSH1 0x01 0CA1 81 DUP2 0CA2 51 MLOAD 0CA3 81 DUP2 0CA4 10 LT 0CA5 15 ISZERO 0CA6 15 ISZERO 0CA7 61 PUSH2 0x0cac 0CAA 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0C7D stack[0] = 0x6c00000000000000000000000000000000000000000000000000000000000000 // @0C9E stack[1] = stack[-1] // @0C9F stack[2] = 0x01 // } // Block ends with conditional jump to 0x0cac, if !!(0x01 < memory[stack[-1]:stack[-1] + 0x20]) label_0CAB: // Incoming jump from 0x0CAA, if not !!(0x01 < memory[stack[-1]:stack[-1] + 0x20]) 0CAB FE *ASSERT // Stack delta = +0 // Outputs[1] { @0CAB assert(); } // Block terminates label_0CAC: // Incoming jump from 0x0CAA, if !!(0x01 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0CAD stack[-1] // @0CAD stack[-2] // @0CB2 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @0D1A stack[-3] // } 0CAC 5B JUMPDEST 0CAD 90 SWAP1 0CAE 60 PUSH1 0x20 0CB0 01 ADD 0CB1 01 ADD 0CB2 51 MLOAD 0CB3 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0CD4 90 SWAP1 0CD5 04 DIV 0CD6 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0CF7 02 MUL 0CF8 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0D18 19 NOT 0D19 16 AND 0D1A 14 EQ 0D1B 15 ISZERO 0D1C 15 ISZERO 0D1D 61 PUSH2 0x0d24 0D20 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x0d24, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) label_0D21: // Incoming jump from 0x0D20, if not !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) 0D21 60 PUSH1 0x38 0D23 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0038 label_0D24: // Incoming jump from 0x0D20, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) // Inputs[2] // { // @0D46 stack[-1] // @0D4A memory[stack[-1]:stack[-1] + 0x20] // } 0D24 5B JUMPDEST 0D25 7F PUSH32 0x6100000000000000000000000000000000000000000000000000000000000000 0D46 81 DUP2 0D47 60 PUSH1 0x02 0D49 81 DUP2 0D4A 51 MLOAD 0D4B 81 DUP2 0D4C 10 LT 0D4D 15 ISZERO 0D4E 15 ISZERO 0D4F 61 PUSH2 0x0d54 0D52 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0D25 stack[0] = 0x6100000000000000000000000000000000000000000000000000000000000000 // @0D46 stack[1] = stack[-1] // @0D47 stack[2] = 0x02 // } // Block ends with conditional jump to 0x0d54, if !!(0x02 < memory[stack[-1]:stack[-1] + 0x20]) label_0D53: // Incoming jump from 0x0D52, if not !!(0x02 < memory[stack[-1]:stack[-1] + 0x20]) 0D53 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0D53 assert(); } // Block terminates label_0D54: // Incoming jump from 0x0D52, if !!(0x02 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0D55 stack[-1] // @0D55 stack[-2] // @0D5A memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @0DC2 stack[-3] // } 0D54 5B JUMPDEST 0D55 90 SWAP1 0D56 60 PUSH1 0x20 0D58 01 ADD 0D59 01 ADD 0D5A 51 MLOAD 0D5B 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0D7C 90 SWAP1 0D7D 04 DIV 0D7E 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0D9F 02 MUL 0DA0 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0DC0 19 NOT 0DC1 16 AND 0DC2 14 EQ 0DC3 15 ISZERO 0DC4 15 ISZERO 0DC5 61 PUSH2 0x0dcc 0DC8 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x0dcc, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) label_0DC9: // Incoming jump from 0x0DC8, if not !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) 0DC9 60 PUSH1 0x38 0DCB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0038 label_0DCC: // Incoming jump from 0x0DC8, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) 0DCC 5B JUMPDEST 0DCD 61 PUSH2 0x0dd4 0DD0 61 PUSH2 0x1dbd 0DD3 56 *JUMP // Stack delta = +1 // Outputs[1] { @0DCD stack[0] = 0x0dd4 } // Block ends with call to 0x1dbd, returns to 0x0DD4 label_0DD4: // Incoming return from call to 0x1DBD at 0x0DD3 // Inputs[2] // { // @0DF6 stack[-1] // @0DFA memory[stack[-1]:stack[-1] + 0x20] // } 0DD4 5B JUMPDEST 0DD5 7F PUSH32 0x6700000000000000000000000000000000000000000000000000000000000000 0DF6 81 DUP2 0DF7 60 PUSH1 0x03 0DF9 81 DUP2 0DFA 51 MLOAD 0DFB 81 DUP2 0DFC 10 LT 0DFD 15 ISZERO 0DFE 15 ISZERO 0DFF 61 PUSH2 0x0e04 0E02 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0DD5 stack[0] = 0x6700000000000000000000000000000000000000000000000000000000000000 // @0DF6 stack[1] = stack[-1] // @0DF7 stack[2] = 0x03 // } // Block ends with conditional jump to 0x0e04, if !!(0x03 < memory[stack[-1]:stack[-1] + 0x20]) label_0E03: // Incoming jump from 0x0E02, if not !!(0x03 < memory[stack[-1]:stack[-1] + 0x20]) 0E03 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0E03 assert(); } // Block terminates label_0E04: // Incoming jump from 0x0E02, if !!(0x03 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0E05 stack[-2] // @0E05 stack[-1] // @0E0A memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @0E72 stack[-3] // } 0E04 5B JUMPDEST 0E05 90 SWAP1 0E06 60 PUSH1 0x20 0E08 01 ADD 0E09 01 ADD 0E0A 51 MLOAD 0E0B 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0E2C 90 SWAP1 0E2D 04 DIV 0E2E 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0E4F 02 MUL 0E50 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0E70 19 NOT 0E71 16 AND 0E72 14 EQ 0E73 15 ISZERO 0E74 15 ISZERO 0E75 61 PUSH2 0x0e7c 0E78 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x0e7c, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) label_0E79: // Incoming jump from 0x0E78, if not !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) 0E79 60 PUSH1 0x38 0E7B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0038 label_0E7C: // Incoming jump from 0x0E78, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) 0E7C 5B JUMPDEST 0E7D 61 PUSH2 0x0e84 0E80 61 PUSH2 0x1dbd 0E83 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E7D stack[0] = 0x0e84 } // Block ends with call to 0x1dbd, returns to 0x0E84 label_0E84: // Incoming return from call to 0x1DBD at 0x0E83 // Inputs[2] // { // @0EA6 stack[-1] // @0EAA memory[stack[-1]:stack[-1] + 0x20] // } 0E84 5B JUMPDEST 0E85 7F PUSH32 0x7b00000000000000000000000000000000000000000000000000000000000000 0EA6 81 DUP2 0EA7 60 PUSH1 0x04 0EA9 81 DUP2 0EAA 51 MLOAD 0EAB 81 DUP2 0EAC 10 LT 0EAD 15 ISZERO 0EAE 15 ISZERO 0EAF 61 PUSH2 0x0eb4 0EB2 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0E85 stack[0] = 0x7b00000000000000000000000000000000000000000000000000000000000000 // @0EA6 stack[1] = stack[-1] // @0EA7 stack[2] = 0x04 // } // Block ends with conditional jump to 0x0eb4, if !!(0x04 < memory[stack[-1]:stack[-1] + 0x20]) label_0EB3: // Incoming jump from 0x0EB2, if not !!(0x04 < memory[stack[-1]:stack[-1] + 0x20]) 0EB3 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0EB3 assert(); } // Block terminates label_0EB4: // Incoming jump from 0x0EB2, if !!(0x04 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0EB5 stack[-1] // @0EB5 stack[-2] // @0EBA memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @0F22 stack[-3] // } 0EB4 5B JUMPDEST 0EB5 90 SWAP1 0EB6 60 PUSH1 0x20 0EB8 01 ADD 0EB9 01 ADD 0EBA 51 MLOAD 0EBB 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0EDC 90 SWAP1 0EDD 04 DIV 0EDE 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0EFF 02 MUL 0F00 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0F20 19 NOT 0F21 16 AND 0F22 14 EQ 0F23 15 ISZERO 0F24 15 ISZERO 0F25 61 PUSH2 0x0f2c 0F28 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x0f2c, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) label_0F29: // Incoming jump from 0x0F28, if not !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) 0F29 60 PUSH1 0x38 0F2B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0038 label_0F2C: // Incoming jump from 0x0F28, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) // Inputs[2] // { // @0F4E stack[-1] // @0F52 memory[stack[-1]:stack[-1] + 0x20] // } 0F2C 5B JUMPDEST 0F2D 7F PUSH32 0x7d00000000000000000000000000000000000000000000000000000000000000 0F4E 81 DUP2 0F4F 60 PUSH1 0x1f 0F51 81 DUP2 0F52 51 MLOAD 0F53 81 DUP2 0F54 10 LT 0F55 15 ISZERO 0F56 15 ISZERO 0F57 61 PUSH2 0x0f5c 0F5A 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0F2D stack[0] = 0x7d00000000000000000000000000000000000000000000000000000000000000 // @0F4E stack[1] = stack[-1] // @0F4F stack[2] = 0x1f // } // Block ends with conditional jump to 0x0f5c, if !!(0x1f < memory[stack[-1]:stack[-1] + 0x20]) label_0F5B: // Incoming jump from 0x0F5A, if not !!(0x1f < memory[stack[-1]:stack[-1] + 0x20]) 0F5B FE *ASSERT // Stack delta = +0 // Outputs[1] { @0F5B assert(); } // Block terminates label_0F5C: // Incoming jump from 0x0F5A, if !!(0x1f < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0F5D stack[-1] // @0F5D stack[-2] // @0F62 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @0FCA stack[-3] // } 0F5C 5B JUMPDEST 0F5D 90 SWAP1 0F5E 60 PUSH1 0x20 0F60 01 ADD 0F61 01 ADD 0F62 51 MLOAD 0F63 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0F84 90 SWAP1 0F85 04 DIV 0F86 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 0FA7 02 MUL 0FA8 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0FC8 19 NOT 0FC9 16 AND 0FCA 14 EQ 0FCB 15 ISZERO 0FCC 15 ISZERO 0FCD 61 PUSH2 0x0fd4 0FD0 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x0fd4, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) label_0FD1: // Incoming jump from 0x0FD0, if not !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) 0FD1 60 PUSH1 0x00 0FD3 FF *SELFDESTRUCT // Stack delta = +0 // Outputs[1] { @0FD3 selfdestruct(0x00); } // Block terminates label_0FD4: // Incoming jump from 0x0FD0, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) 0FD4 5B JUMPDEST 0FD5 61 PUSH2 0x0fdc 0FD8 61 PUSH2 0x1dbd 0FDB 56 *JUMP // Stack delta = +1 // Outputs[1] { @0FD5 stack[0] = 0x0fdc } // Block ends with call to 0x1dbd, returns to 0x0FDC label_0FDC: // Incoming return from call to 0x1DBD at 0x0FDB // Inputs[6] // { // @0FDD address(this) // @0FF9 msg.value // @0FFA stack[-1] // @0FFD memory[0x40:0x60] // @1036 memory[stack[-1]:stack[-1] + 0x20] // @103F memory[stack[-1]:stack[-1] + 0x20] // } 0FDC 5B JUMPDEST 0FDD 30 ADDRESS 0FDE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FF3 16 AND 0FF4 63 PUSH4 0xf605fa57 0FF9 34 CALLVALUE 0FFA 83 DUP4 0FFB 60 PUSH1 0x40 0FFD 51 MLOAD 0FFE 83 DUP4 0FFF 63 PUSH4 0xffffffff 1004 16 AND 1005 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 1023 02 MUL 1024 81 DUP2 1025 52 MSTORE 1026 60 PUSH1 0x04 1028 01 ADD 1029 80 DUP1 102A 80 DUP1 102B 60 PUSH1 0x20 102D 01 ADD 102E 82 DUP3 102F 81 DUP2 1030 03 SUB 1031 82 DUP3 1032 52 MSTORE 1033 83 DUP4 1034 81 DUP2 1035 81 DUP2 1036 51 MLOAD 1037 81 DUP2 1038 52 MSTORE 1039 60 PUSH1 0x20 103B 01 ADD 103C 91 SWAP2 103D 50 POP 103E 80 DUP1 103F 51 MLOAD 1040 90 SWAP1 1041 60 PUSH1 0x20 1043 01 ADD 1044 90 SWAP1 1045 80 DUP1 1046 83 DUP4 1047 83 DUP4 1048 60 PUSH1 0x00 104A 5B JUMPDEST 104B 83 DUP4 104C 81 DUP2 104D 10 LT 104E 15 ISZERO 104F 61 PUSH2 0x1065 1052 57 *JUMPI // Stack delta = +13 // Outputs[16] // { // @0FF3 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @0FF4 stack[1] = 0xf605fa57 // @0FF9 stack[2] = msg.value // @0FFA stack[3] = stack[-1] // @1025 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100000000000000000000000000000000000000000000000000000000 * (0xffffffff & 0xf605fa57) // @1028 stack[4] = 0x04 + memory[0x40:0x60] // @1029 stack[5] = 0x04 + memory[0x40:0x60] // @1032 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1038 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @103C stack[6] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1044 stack[8] = memory[stack[-1]:stack[-1] + 0x20] // @1044 stack[7] = 0x20 + stack[-1] // @1045 stack[9] = memory[stack[-1]:stack[-1] + 0x20] // @1046 stack[10] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1047 stack[11] = 0x20 + stack[-1] // @1048 stack[12] = 0x00 // } // Block ends with conditional jump to 0x1065, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_1053: // Incoming jump from 0x1052, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1052, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @1053 stack[-1] // @1054 stack[-2] // @1056 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @1058 stack[-3] // } 1053 80 DUP1 1054 82 DUP3 1055 01 ADD 1056 51 MLOAD 1057 81 DUP2 1058 84 DUP5 1059 01 ADD 105A 52 MSTORE 105B 60 PUSH1 0x20 105D 81 DUP2 105E 01 ADD 105F 90 SWAP1 1060 50 POP 1061 61 PUSH2 0x104a 1064 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @105A memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @105F stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x104a label_1065: // Incoming jump from 0x1052, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1052, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @106A stack[-5] // @106A stack[-6] // @106C stack[-7] // } 1065 5B JUMPDEST 1066 50 POP 1067 50 POP 1068 50 POP 1069 50 POP 106A 90 SWAP1 106B 50 POP 106C 90 SWAP1 106D 81 DUP2 106E 01 ADD 106F 90 SWAP1 1070 60 PUSH1 0x1f 1072 16 AND 1073 80 DUP1 1074 15 ISZERO 1075 61 PUSH2 0x1092 1078 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @106F stack[-7] = stack[-5] + stack[-7] // @1072 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x1092, if !(0x1f & stack[-5]) label_1079: // Incoming jump from 0x1078, if not !(0x1f & stack[-5]) // Inputs[8] // { // @1079 stack[-1] // @107A stack[-2] // @107D memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @1094 stack[-5] // @109C memory[0x40:0x60] // @10A1 stack[-6] // @10A2 stack[-8] // @10A4 address(stack[-8]).code.length // } 1079 80 DUP1 107A 82 DUP3 107B 03 SUB 107C 80 DUP1 107D 51 MLOAD 107E 60 PUSH1 0x01 1080 83 DUP4 1081 60 PUSH1 0x20 1083 03 SUB 1084 61 PUSH2 0x0100 1087 0A EXP 1088 03 SUB 1089 19 NOT 108A 16 AND 108B 81 DUP2 108C 52 MSTORE 108D 60 PUSH1 0x20 108F 01 ADD 1090 91 SWAP2 1091 50 POP 1092 5B JUMPDEST 1093 50 POP 1094 92 SWAP3 1095 50 POP 1096 50 POP 1097 50 POP 1098 60 PUSH1 0x00 109A 60 PUSH1 0x40 109C 51 MLOAD 109D 80 DUP1 109E 83 DUP4 109F 03 SUB 10A0 81 DUP2 10A1 85 DUP6 10A2 88 DUP9 10A3 80 DUP1 10A4 3B EXTCODESIZE 10A5 15 ISZERO 10A6 15 ISZERO 10A7 61 PUSH2 0x10af 10AA 57 *JUMPI // Stack delta = +2 // Outputs[8] // { // @108C memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @1094 stack[-5] = 0x20 + (stack[-2] - stack[-1]) // @1098 stack[-4] = 0x00 // @109C stack[-3] = memory[0x40:0x60] // @109F stack[-2] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @10A0 stack[-1] = memory[0x40:0x60] // @10A1 stack[0] = stack[-6] // @10A2 stack[1] = stack[-8] // } // Block ends with conditional jump to 0x10af, if !!address(stack[-8]).code.length label_10AB: // Incoming jump from 0x10AA, if not !!address(stack[-8]).code.length // Incoming jump from 0x10AA, if not !!address(stack[-8]).code.length // Inputs[1] { @10AE memory[0x00:0x00] } 10AB 60 PUSH1 0x00 10AD 80 DUP1 10AE FD *REVERT // Stack delta = +0 // Outputs[1] { @10AE revert(memory[0x00:0x00]); } // Block terminates label_10AF: // Incoming jump from 0x10AA, if !!address(stack[-8]).code.length // Incoming jump from 0x10AA, if !!address(stack[-8]).code.length // Inputs[9] // { // @10B0 msg.gas // @10B1 stack[-3] // @10B1 stack[-6] // @10B1 stack[-4] // @10B1 stack[-5] // @10B1 address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) // @10B1 stack[-2] // @10B1 stack[-1] // @10B1 memory[stack[-3]:stack[-3] + stack[-4]] // } 10AF 5B JUMPDEST 10B0 5A GAS 10B1 F1 CALL 10B2 15 ISZERO 10B3 15 ISZERO 10B4 61 PUSH2 0x10bc 10B7 57 *JUMPI // Stack delta = -6 // Outputs[1] { @10B1 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) } // Block ends with conditional jump to 0x10bc, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) label_10B8: // Incoming jump from 0x10B7, if not !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[1] { @10BB memory[0x00:0x00] } 10B8 60 PUSH1 0x00 10BA 80 DUP1 10BB FD *REVERT // Stack delta = +0 // Outputs[1] { @10BB revert(memory[0x00:0x00]); } // Block terminates label_10BC: // Incoming jump from 0x10B7, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) 10BC 5B JUMPDEST 10BD 50 POP 10BE 50 POP 10BF 50 POP 10C0 50 POP 10C1 61 PUSH2 0x10c8 10C4 61 PUSH2 0x1dbd 10C7 56 *JUMP // Stack delta = -3 // Outputs[1] { @10C1 stack[-4] = 0x10c8 } // Block ends with call to 0x1dbd, returns to 0x10C8 label_10C8: // Incoming return from call to 0x1DBD at 0x10C7 // Inputs[2] // { // @10EA stack[-1] // @10EE memory[stack[-1]:stack[-1] + 0x20] // } 10C8 5B JUMPDEST 10C9 7F PUSH32 0x7300000000000000000000000000000000000000000000000000000000000000 10EA 81 DUP2 10EB 60 PUSH1 0x1e 10ED 81 DUP2 10EE 51 MLOAD 10EF 81 DUP2 10F0 10 LT 10F1 15 ISZERO 10F2 15 ISZERO 10F3 61 PUSH2 0x10f8 10F6 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @10C9 stack[0] = 0x7300000000000000000000000000000000000000000000000000000000000000 // @10EA stack[1] = stack[-1] // @10EB stack[2] = 0x1e // } // Block ends with conditional jump to 0x10f8, if !!(0x1e < memory[stack[-1]:stack[-1] + 0x20]) label_10F7: // Incoming jump from 0x10F6, if not !!(0x1e < memory[stack[-1]:stack[-1] + 0x20]) 10F7 FE *ASSERT // Stack delta = +0 // Outputs[1] { @10F7 assert(); } // Block terminates label_10F8: // Incoming jump from 0x10F6, if !!(0x1e < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @10F9 stack[-1] // @10F9 stack[-2] // @10FE memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @1166 stack[-3] // } 10F8 5B JUMPDEST 10F9 90 SWAP1 10FA 60 PUSH1 0x20 10FC 01 ADD 10FD 01 ADD 10FE 51 MLOAD 10FF 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 1120 90 SWAP1 1121 04 DIV 1122 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 1143 02 MUL 1144 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1164 19 NOT 1165 16 AND 1166 14 EQ 1167 15 ISZERO 1168 15 ISZERO 1169 61 PUSH2 0x1170 116C 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x1170, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) label_116D: // Incoming jump from 0x116C, if not !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) 116D 60 PUSH1 0x38 116F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0038 label_1170: // Incoming jump from 0x116C, if !!(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) == stack[-3]) 1170 5B JUMPDEST 1171 61 PUSH2 0x1178 1174 61 PUSH2 0x1dbd 1177 56 *JUMP // Stack delta = +1 // Outputs[1] { @1171 stack[0] = 0x1178 } // Block ends with call to 0x1dbd, returns to 0x1178 label_1178: // Incoming return from call to 0x1DBD at 0x1177 // Inputs[2] // { // @1183 storage[0x00] // @1194 stack[-2] // } 1178 5B JUMPDEST 1179 60 PUSH1 0x01 117B 60 PUSH1 0x00 117D 80 DUP1 117E 61 PUSH2 0x0100 1181 0A EXP 1182 81 DUP2 1183 54 SLOAD 1184 81 DUP2 1185 60 PUSH1 0xff 1187 02 MUL 1188 19 NOT 1189 16 AND 118A 90 SWAP1 118B 83 DUP4 118C 15 ISZERO 118D 15 ISZERO 118E 02 MUL 118F 17 OR 1190 90 SWAP1 1191 55 SSTORE 1192 50 POP 1193 50 POP 1194 56 *JUMP // Stack delta = -2 // Outputs[1] { @1191 storage[0x00] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[0x00]) } // Block ends with unconditional jump to stack[-2] label_1195: // Incoming call from 0x0245, returns to 0x0246 // Inputs[1] { @119C block.number } 1195 5B JUMPDEST 1196 60 PUSH1 0x00 1198 80 DUP1 1199 61 PUSH2 0x01a4 119C 43 NUMBER 119D 14 EQ 119E 15 ISZERO 119F 15 ISZERO 11A0 61 PUSH2 0x11a7 11A3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1196 stack[0] = 0x00 // @1198 stack[1] = 0x00 // } // Block ends with conditional jump to 0x11a7, if !!(block.number == 0x01a4) label_11A4: // Incoming jump from 0x11A3, if not !!(block.number == 0x01a4) 11A4 60 PUSH1 0x38 11A6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0038 label_11A7: // Incoming jump from 0x11A3, if !!(block.number == 0x01a4) // Inputs[2] // { // @11A8 block.number // @11A9 stack[-2] // } 11A7 5B JUMPDEST 11A8 43 NUMBER 11A9 91 SWAP2 11AA 50 POP 11AB 61 PUSH2 0x11b2 11AE 61 PUSH2 0x1dbd 11B1 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @11A9 stack[-2] = block.number // @11AB stack[0] = 0x11b2 // } // Block ends with call to 0x1dbd, returns to 0x11B2 label_11B2: // Incoming return from call to 0x1DBD at 0x11B1 // Inputs[3] // { // @11BD stack[-1] // @11BF stack[-3] // @11C3 memory[stack[-3]:stack[-3] + 0x20] // } 11B2 5B JUMPDEST 11B3 68 PUSH9 0x74f794a249c48cbd04 11BD 90 SWAP1 11BE 50 POP 11BF 82 DUP3 11C0 60 PUSH1 0x05 11C2 81 DUP2 11C3 51 MLOAD 11C4 81 DUP2 11C5 10 LT 11C6 15 ISZERO 11C7 15 ISZERO 11C8 61 PUSH2 0x11cd 11CB 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @11BD stack[-1] = 0x74f794a249c48cbd04 // @11BF stack[0] = stack[-3] // @11C0 stack[1] = 0x05 // } // Block ends with conditional jump to 0x11cd, if !!(0x05 < memory[stack[-3]:stack[-3] + 0x20]) label_11CC: // Incoming jump from 0x11CB, if not !!(0x05 < memory[stack[-3]:stack[-3] + 0x20]) 11CC FE *ASSERT // Stack delta = +0 // Outputs[1] { @11CC assert(); } // Block terminates label_11CD: // Incoming jump from 0x11CB, if !!(0x05 < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[5] // { // @11CE stack[-2] // @11CE stack[-1] // @11D3 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @1219 stack[-5] // @121D memory[stack[-5]:stack[-5] + 0x20] // } 11CD 5B JUMPDEST 11CE 90 SWAP1 11CF 60 PUSH1 0x20 11D1 01 ADD 11D2 01 ADD 11D3 51 MLOAD 11D4 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 11F5 90 SWAP1 11F6 04 DIV 11F7 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 1218 02 MUL 1219 83 DUP4 121A 60 PUSH1 0x06 121C 81 DUP2 121D 51 MLOAD 121E 81 DUP2 121F 10 LT 1220 15 ISZERO 1221 15 ISZERO 1222 61 PUSH2 0x1227 1225 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1218 stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) // @1219 stack[-1] = stack[-5] // @121A stack[0] = 0x06 // } // Block ends with conditional jump to 0x1227, if !!(0x06 < memory[stack[-5]:stack[-5] + 0x20]) label_1226: // Incoming jump from 0x1225, if not !!(0x06 < memory[stack[-5]:stack[-5] + 0x20]) 1226 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1226 assert(); } // Block terminates label_1227: // Incoming jump from 0x1225, if !!(0x06 < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[5] // { // @1228 stack[-1] // @1228 stack[-2] // @122D memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @1273 stack[-6] // @1277 memory[stack[-6]:stack[-6] + 0x20] // } 1227 5B JUMPDEST 1228 90 SWAP1 1229 60 PUSH1 0x20 122B 01 ADD 122C 01 ADD 122D 51 MLOAD 122E 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 124F 90 SWAP1 1250 04 DIV 1251 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 1272 02 MUL 1273 84 DUP5 1274 60 PUSH1 0x07 1276 81 DUP2 1277 51 MLOAD 1278 81 DUP2 1279 10 LT 127A 15 ISZERO 127B 15 ISZERO 127C 61 PUSH2 0x1281 127F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1272 stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) // @1273 stack[-1] = stack[-6] // @1274 stack[0] = 0x07 // } // Block ends with conditional jump to 0x1281, if !!(0x07 < memory[stack[-6]:stack[-6] + 0x20]) label_1280: // Incoming jump from 0x127F, if not !!(0x07 < memory[stack[-6]:stack[-6] + 0x20]) 1280 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1280 assert(); } // Block terminates label_1281: // Incoming jump from 0x127F, if !!(0x07 < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[5] // { // @1282 stack[-2] // @1282 stack[-1] // @1287 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @12CD stack[-7] // @12D1 memory[stack[-7]:stack[-7] + 0x20] // } 1281 5B JUMPDEST 1282 90 SWAP1 1283 60 PUSH1 0x20 1285 01 ADD 1286 01 ADD 1287 51 MLOAD 1288 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 12A9 90 SWAP1 12AA 04 DIV 12AB 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 12CC 02 MUL 12CD 85 DUP6 12CE 60 PUSH1 0x08 12D0 81 DUP2 12D1 51 MLOAD 12D2 81 DUP2 12D3 10 LT 12D4 15 ISZERO 12D5 15 ISZERO 12D6 61 PUSH2 0x12db 12D9 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @12CC stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) // @12CD stack[-1] = stack[-7] // @12CE stack[0] = 0x08 // } // Block ends with conditional jump to 0x12db, if !!(0x08 < memory[stack[-7]:stack[-7] + 0x20]) label_12DA: // Incoming jump from 0x12D9, if not !!(0x08 < memory[stack[-7]:stack[-7] + 0x20]) 12DA FE *ASSERT // Stack delta = +0 // Outputs[1] { @12DA assert(); } // Block terminates label_12DB: // Incoming jump from 0x12D9, if !!(0x08 < memory[stack[-7]:stack[-7] + 0x20]) // Inputs[5] // { // @12DC stack[-1] // @12DC stack[-2] // @12E1 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @1327 stack[-8] // @132B memory[stack[-8]:stack[-8] + 0x20] // } 12DB 5B JUMPDEST 12DC 90 SWAP1 12DD 60 PUSH1 0x20 12DF 01 ADD 12E0 01 ADD 12E1 51 MLOAD 12E2 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 1303 90 SWAP1 1304 04 DIV 1305 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 1326 02 MUL 1327 86 DUP7 1328 60 PUSH1 0x09 132A 81 DUP2 132B 51 MLOAD 132C 81 DUP2 132D 10 LT 132E 15 ISZERO 132F 15 ISZERO 1330 61 PUSH2 0x1335 1333 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1326 stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) // @1327 stack[-1] = stack[-8] // @1328 stack[0] = 0x09 // } // Block ends with conditional jump to 0x1335, if !!(0x09 < memory[stack[-8]:stack[-8] + 0x20]) label_1334: // Incoming jump from 0x1333, if not !!(0x09 < memory[stack[-8]:stack[-8] + 0x20]) 1334 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1334 assert(); } // Block terminates label_1335: // Incoming jump from 0x1333, if !!(0x09 < memory[stack[-8]:stack[-8] + 0x20]) // Inputs[5] // { // @1336 stack[-2] // @1336 stack[-1] // @133B memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @1381 stack[-9] // @1385 memory[stack[-9]:stack[-9] + 0x20] // } 1335 5B JUMPDEST 1336 90 SWAP1 1337 60 PUSH1 0x20 1339 01 ADD 133A 01 ADD 133B 51 MLOAD 133C 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 135D 90 SWAP1 135E 04 DIV 135F 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 1380 02 MUL 1381 87 DUP8 1382 60 PUSH1 0x0a 1384 81 DUP2 1385 51 MLOAD 1386 81 DUP2 1387 10 LT 1388 15 ISZERO 1389 15 ISZERO 138A 61 PUSH2 0x138f 138D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1380 stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) // @1381 stack[-1] = stack[-9] // @1382 stack[0] = 0x0a // } // Block ends with conditional jump to 0x138f, if !!(0x0a < memory[stack[-9]:stack[-9] + 0x20]) label_138E: // Incoming jump from 0x138D, if not !!(0x0a < memory[stack[-9]:stack[-9] + 0x20]) 138E FE *ASSERT // Stack delta = +0 // Outputs[1] { @138E assert(); } // Block terminates label_138F: // Incoming jump from 0x138D, if !!(0x0a < memory[stack[-9]:stack[-9] + 0x20]) // Inputs[5] // { // @1390 stack[-2] // @1390 stack[-1] // @1395 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @13DB stack[-10] // @13DF memory[stack[-10]:stack[-10] + 0x20] // } 138F 5B JUMPDEST 1390 90 SWAP1 1391 60 PUSH1 0x20 1393 01 ADD 1394 01 ADD 1395 51 MLOAD 1396 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 13B7 90 SWAP1 13B8 04 DIV 13B9 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 13DA 02 MUL 13DB 88 DUP9 13DC 60 PUSH1 0x0b 13DE 81 DUP2 13DF 51 MLOAD 13E0 81 DUP2 13E1 10 LT 13E2 15 ISZERO 13E3 15 ISZERO 13E4 61 PUSH2 0x13e9 13E7 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @13DA stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) // @13DB stack[-1] = stack[-10] // @13DC stack[0] = 0x0b // } // Block ends with conditional jump to 0x13e9, if !!(0x0b < memory[stack[-10]:stack[-10] + 0x20]) label_13E8: // Incoming jump from 0x13E7, if not !!(0x0b < memory[stack[-10]:stack[-10] + 0x20]) 13E8 FE *ASSERT // Stack delta = +0 // Outputs[1] { @13E8 assert(); } // Block terminates label_13E9: // Incoming jump from 0x13E7, if !!(0x0b < memory[stack[-10]:stack[-10] + 0x20]) // Inputs[5] // { // @13EA stack[-2] // @13EA stack[-1] // @13EF memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @1435 stack[-11] // @1439 memory[stack[-11]:stack[-11] + 0x20] // } 13E9 5B JUMPDEST 13EA 90 SWAP1 13EB 60 PUSH1 0x20 13ED 01 ADD 13EE 01 ADD 13EF 51 MLOAD 13F0 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 1411 90 SWAP1 1412 04 DIV 1413 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 1434 02 MUL 1435 89 DUP10 1436 60 PUSH1 0x0c 1438 81 DUP2 1439 51 MLOAD 143A 81 DUP2 143B 10 LT 143C 15 ISZERO 143D 15 ISZERO 143E 61 PUSH2 0x1443 1441 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1434 stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) // @1435 stack[-1] = stack[-11] // @1436 stack[0] = 0x0c // } // Block ends with conditional jump to 0x1443, if !!(0x0c < memory[stack[-11]:stack[-11] + 0x20]) label_1442: // Incoming jump from 0x1441, if not !!(0x0c < memory[stack[-11]:stack[-11] + 0x20]) 1442 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1442 assert(); } // Block terminates label_1443: // Incoming jump from 0x1441, if !!(0x0c < memory[stack[-11]:stack[-11] + 0x20]) // Inputs[15] // { // @1444 stack[-1] // @1444 stack[-2] // @1449 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @1491 memory[0x40:0x60] // @1493 stack[-9] // @14DD stack[-8] // @1527 stack[-7] // @1571 stack[-6] // @15BB stack[-5] // @1605 stack[-4] // @164F stack[-3] // @16EF memory[0x40:0x60] // @16F4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]] // @16F9 stack[-11] // @16FA stack[-10] // } 1443 5B JUMPDEST 1444 90 SWAP1 1445 60 PUSH1 0x20 1447 01 ADD 1448 01 ADD 1449 51 MLOAD 144A 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 146B 90 SWAP1 146C 04 DIV 146D 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 148E 02 MUL 148F 60 PUSH1 0x40 1491 51 MLOAD 1492 80 DUP1 1493 89 DUP10 1494 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 14B4 19 NOT 14B5 16 AND 14B6 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 14D6 19 NOT 14D7 16 AND 14D8 81 DUP2 14D9 52 MSTORE 14DA 60 PUSH1 0x01 14DC 01 ADD 14DD 88 DUP9 14DE 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 14FE 19 NOT 14FF 16 AND 1500 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1520 19 NOT 1521 16 AND 1522 81 DUP2 1523 52 MSTORE 1524 60 PUSH1 0x01 1526 01 ADD 1527 87 DUP8 1528 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1548 19 NOT 1549 16 AND 154A 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 156A 19 NOT 156B 16 AND 156C 81 DUP2 156D 52 MSTORE 156E 60 PUSH1 0x01 1570 01 ADD 1571 86 DUP7 1572 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1592 19 NOT 1593 16 AND 1594 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 15B4 19 NOT 15B5 16 AND 15B6 81 DUP2 15B7 52 MSTORE 15B8 60 PUSH1 0x01 15BA 01 ADD 15BB 85 DUP6 15BC 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 15DC 19 NOT 15DD 16 AND 15DE 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 15FE 19 NOT 15FF 16 AND 1600 81 DUP2 1601 52 MSTORE 1602 60 PUSH1 0x01 1604 01 ADD 1605 84 DUP5 1606 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1626 19 NOT 1627 16 AND 1628 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1648 19 NOT 1649 16 AND 164A 81 DUP2 164B 52 MSTORE 164C 60 PUSH1 0x01 164E 01 ADD 164F 83 DUP4 1650 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1670 19 NOT 1671 16 AND 1672 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1692 19 NOT 1693 16 AND 1694 81 DUP2 1695 52 MSTORE 1696 60 PUSH1 0x01 1698 01 ADD 1699 82 DUP3 169A 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 16BA 19 NOT 16BB 16 AND 16BC 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 16DC 19 NOT 16DD 16 AND 16DE 81 DUP2 16DF 52 MSTORE 16E0 60 PUSH1 0x01 16E2 01 ADD 16E3 98 SWAP9 16E4 50 POP 16E5 50 POP 16E6 50 POP 16E7 50 POP 16E8 50 POP 16E9 50 POP 16EA 50 POP 16EB 50 POP 16EC 50 POP 16ED 60 PUSH1 0x40 16EF 51 MLOAD 16F0 80 DUP1 16F1 91 SWAP2 16F2 03 SUB 16F3 90 SWAP1 16F4 20 SHA3 16F5 60 PUSH1 0x00 16F7 19 NOT 16F8 16 AND 16F9 82 DUP3 16FA 82 DUP3 16FB 81 DUP2 16FC 15 ISZERO 16FD 15 ISZERO 16FE 61 PUSH2 0x1703 1701 57 *JUMPI // Stack delta = -6 // Outputs[11] // { // @14D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-9] // @1523 memory[0x01 + memory[0x40:0x60]:0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-8] // @156D memory[0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-7] // @15B7 memory[0x01 + 0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-6] // @1601 memory[0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-5] // @164B memory[0x01 + 0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-4] // @1695 memory[0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] // @16DF memory[0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) // @16F8 stack[-9] = ~0x00 & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @16F9 stack[-8] = stack[-11] // @16FA stack[-7] = stack[-10] // } // Block ends with conditional jump to 0x1703, if !!stack[-11] label_1702: // Incoming jump from 0x1701, if not !!stack[-11] 1702 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1702 assert(); } // Block terminates label_1703: // Incoming jump from 0x1701, if !!stack[-11] // Inputs[6] // { // @1704 stack[-1] // @1704 stack[-2] // @1722 memory[0x40:0x60] // @1765 memory[0x40:0x60] // @176A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x08 + memory[0x40:0x60]) - memory[0x40:0x60]] // @176F stack[-3] // } 1703 5B JUMPDEST 1704 04 DIV 1705 78 PUSH25 0x01000000000000000000000000000000000000000000000000 171F 02 MUL 1720 60 PUSH1 0x40 1722 51 MLOAD 1723 80 DUP1 1724 82 DUP3 1725 77 PUSH24 0xffffffffffffffffffffffffffffffffffffffffffffffff 173E 19 NOT 173F 16 AND 1740 77 PUSH24 0xffffffffffffffffffffffffffffffffffffffffffffffff 1759 19 NOT 175A 16 AND 175B 81 DUP2 175C 52 MSTORE 175D 60 PUSH1 0x08 175F 01 ADD 1760 91 SWAP2 1761 50 POP 1762 50 POP 1763 60 PUSH1 0x40 1765 51 MLOAD 1766 80 DUP1 1767 91 SWAP2 1768 03 SUB 1769 90 SWAP1 176A 20 SHA3 176B 60 PUSH1 0x00 176D 19 NOT 176E 16 AND 176F 14 EQ 1770 15 ISZERO 1771 15 ISZERO 1772 61 PUSH2 0x1779 1775 57 *JUMPI // Stack delta = -3 // Outputs[1] { @175C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffff & 0x01000000000000000000000000000000000000000000000000 * (stack[-1] / stack[-2]) } // Block ends with conditional jump to 0x1779, if !!(~0x00 & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x08 + memory[0x40:0x60]) - memory[0x40:0x60]]) == stack[-3]) label_1776: // Incoming jump from 0x1775, if not !!(~0x00 & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x08 + memory[0x40:0x60]) - memory[0x40:0x60]]) == stack[-3]) 1776 60 PUSH1 0x38 1778 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0038 label_1779: // Incoming jump from 0x1775, if !!(~0x00 & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x08 + memory[0x40:0x60]) - memory[0x40:0x60]]) == stack[-3]) 1779 5B JUMPDEST 177A 61 PUSH2 0x1781 177D 61 PUSH2 0x1dbd 1780 56 *JUMP // Stack delta = +1 // Outputs[1] { @177A stack[0] = 0x1781 } // Block ends with call to 0x1dbd, returns to 0x1781 label_1781: // Incoming return from call to 0x1DBD at 0x1780 // Inputs[5] // { // @1782 address(this) // @179E stack[-3] // @17A1 memory[0x40:0x60] // @17DA memory[stack[-3]:stack[-3] + 0x20] // @17E3 memory[stack[-3]:stack[-3] + 0x20] // } 1781 5B JUMPDEST 1782 30 ADDRESS 1783 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1798 16 AND 1799 63 PUSH4 0xb220f73c 179E 84 DUP5 179F 60 PUSH1 0x40 17A1 51 MLOAD 17A2 82 DUP3 17A3 63 PUSH4 0xffffffff 17A8 16 AND 17A9 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 17C7 02 MUL 17C8 81 DUP2 17C9 52 MSTORE 17CA 60 PUSH1 0x04 17CC 01 ADD 17CD 80 DUP1 17CE 80 DUP1 17CF 60 PUSH1 0x20 17D1 01 ADD 17D2 82 DUP3 17D3 81 DUP2 17D4 03 SUB 17D5 82 DUP3 17D6 52 MSTORE 17D7 83 DUP4 17D8 81 DUP2 17D9 81 DUP2 17DA 51 MLOAD 17DB 81 DUP2 17DC 52 MSTORE 17DD 60 PUSH1 0x20 17DF 01 ADD 17E0 91 SWAP2 17E1 50 POP 17E2 80 DUP1 17E3 51 MLOAD 17E4 90 SWAP1 17E5 60 PUSH1 0x20 17E7 01 ADD 17E8 90 SWAP1 17E9 80 DUP1 17EA 83 DUP4 17EB 83 DUP4 17EC 60 PUSH1 0x00 17EE 5B JUMPDEST 17EF 83 DUP4 17F0 81 DUP2 17F1 10 LT 17F2 15 ISZERO 17F3 61 PUSH2 0x1809 17F6 57 *JUMPI // Stack delta = +12 // Outputs[15] // { // @1798 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @1799 stack[1] = 0xb220f73c // @179E stack[2] = stack[-3] // @17C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100000000000000000000000000000000000000000000000000000000 * (0xffffffff & 0xb220f73c) // @17CC stack[3] = 0x04 + memory[0x40:0x60] // @17CD stack[4] = 0x04 + memory[0x40:0x60] // @17D6 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @17DC memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-3]:stack[-3] + 0x20] // @17E0 stack[5] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @17E8 stack[6] = 0x20 + stack[-3] // @17E8 stack[7] = memory[stack[-3]:stack[-3] + 0x20] // @17E9 stack[8] = memory[stack[-3]:stack[-3] + 0x20] // @17EA stack[9] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @17EB stack[10] = 0x20 + stack[-3] // @17EC stack[11] = 0x00 // } // Block ends with conditional jump to 0x1809, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) label_17F7: // Incoming jump from 0x17F6, if not !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x17F6, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @17F7 stack[-1] // @17F8 stack[-2] // @17FA memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @17FC stack[-3] // } 17F7 80 DUP1 17F8 82 DUP3 17F9 01 ADD 17FA 51 MLOAD 17FB 81 DUP2 17FC 84 DUP5 17FD 01 ADD 17FE 52 MSTORE 17FF 60 PUSH1 0x20 1801 81 DUP2 1802 01 ADD 1803 90 SWAP1 1804 50 POP 1805 61 PUSH2 0x17ee 1808 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @17FE memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @1803 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x17ee label_1809: // Incoming jump from 0x17F6, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x17F6, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @180E stack[-6] // @180E stack[-5] // @1810 stack[-7] // } 1809 5B JUMPDEST 180A 50 POP 180B 50 POP 180C 50 POP 180D 50 POP 180E 90 SWAP1 180F 50 POP 1810 90 SWAP1 1811 81 DUP2 1812 01 ADD 1813 90 SWAP1 1814 60 PUSH1 0x1f 1816 16 AND 1817 80 DUP1 1818 15 ISZERO 1819 61 PUSH2 0x1836 181C 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1813 stack[-7] = stack[-5] + stack[-7] // @1816 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x1836, if !(0x1f & stack[-5]) label_181D: // Incoming jump from 0x181C, if not !(0x1f & stack[-5]) // Inputs[7] // { // @181D stack[-1] // @181E stack[-2] // @1821 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @1838 stack[-5] // @1840 memory[0x40:0x60] // @1847 stack[-7] // @1849 address(stack[-7]).code.length // } 181D 80 DUP1 181E 82 DUP3 181F 03 SUB 1820 80 DUP1 1821 51 MLOAD 1822 60 PUSH1 0x01 1824 83 DUP4 1825 60 PUSH1 0x20 1827 03 SUB 1828 61 PUSH2 0x0100 182B 0A EXP 182C 03 SUB 182D 19 NOT 182E 16 AND 182F 81 DUP2 1830 52 MSTORE 1831 60 PUSH1 0x20 1833 01 ADD 1834 91 SWAP2 1835 50 POP 1836 5B JUMPDEST 1837 50 POP 1838 92 SWAP3 1839 50 POP 183A 50 POP 183B 50 POP 183C 60 PUSH1 0x00 183E 60 PUSH1 0x40 1840 51 MLOAD 1841 80 DUP1 1842 83 DUP4 1843 03 SUB 1844 81 DUP2 1845 60 PUSH1 0x00 1847 87 DUP8 1848 80 DUP1 1849 3B EXTCODESIZE 184A 15 ISZERO 184B 15 ISZERO 184C 61 PUSH2 0x1854 184F 57 *JUMPI // Stack delta = +2 // Outputs[8] // { // @1830 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @1838 stack[-5] = 0x20 + (stack[-2] - stack[-1]) // @183C stack[-4] = 0x00 // @1840 stack[-3] = memory[0x40:0x60] // @1843 stack[-2] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @1844 stack[-1] = memory[0x40:0x60] // @1845 stack[0] = 0x00 // @1847 stack[1] = stack[-7] // } // Block ends with conditional jump to 0x1854, if !!address(stack[-7]).code.length label_1850: // Incoming jump from 0x184F, if not !!address(stack[-7]).code.length // Incoming jump from 0x184F, if not !!address(stack[-7]).code.length // Inputs[1] { @1853 memory[0x00:0x00] } 1850 60 PUSH1 0x00 1852 80 DUP1 1853 FD *REVERT // Stack delta = +0 // Outputs[1] { @1853 revert(memory[0x00:0x00]); } // Block terminates label_1854: // Incoming jump from 0x184F, if !!address(stack[-7]).code.length // Incoming jump from 0x184F, if !!address(stack[-7]).code.length // Inputs[9] // { // @1855 msg.gas // @1856 stack[-2] // @1856 stack[-1] // @1856 stack[-4] // @1856 address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) // @1856 stack[-6] // @1856 stack[-3] // @1856 stack[-5] // @1856 memory[stack[-3]:stack[-3] + stack[-4]] // } 1854 5B JUMPDEST 1855 5A GAS 1856 F1 CALL 1857 15 ISZERO 1858 15 ISZERO 1859 61 PUSH2 0x1861 185C 57 *JUMPI // Stack delta = -6 // Outputs[1] { @1856 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) } // Block ends with conditional jump to 0x1861, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) label_185D: // Incoming jump from 0x185C, if not !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[1] { @1860 memory[0x00:0x00] } 185D 60 PUSH1 0x00 185F 80 DUP1 1860 FD *REVERT // Stack delta = +0 // Outputs[1] { @1860 revert(memory[0x00:0x00]); } // Block terminates label_1861: // Incoming jump from 0x185C, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[1] { @1868 stack[-7] } 1861 5B JUMPDEST 1862 50 POP 1863 50 POP 1864 50 POP 1865 50 POP 1866 50 POP 1867 50 POP 1868 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_1869: // Incoming call from 0x0297, returns to 0x0298 // Inputs[1] { @1871 msg.value } 1869 5B JUMPDEST 186A 60 PUSH1 0x00 186C 80 DUP1 186D 60 PUSH1 0x00 186F 60 PUSH1 0x2a 1871 34 CALLVALUE 1872 14 EQ 1873 15 ISZERO 1874 15 ISZERO 1875 61 PUSH2 0x187c 1878 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @186A stack[0] = 0x00 // @186C stack[1] = 0x00 // @186D stack[2] = 0x00 // } // Block ends with conditional jump to 0x187c, if !!(msg.value == 0x2a) label_1879: // Incoming jump from 0x1878, if not !!(msg.value == 0x2a) 1879 60 PUSH1 0x00 187B FF *SELFDESTRUCT // Stack delta = +0 // Outputs[1] { @187B selfdestruct(0x00); } // Block terminates label_187C: // Incoming jump from 0x1878, if !!(msg.value == 0x2a) 187C 5B JUMPDEST 187D 61 PUSH2 0x1884 1880 61 PUSH2 0x1dbd 1883 56 *JUMP // Stack delta = +1 // Outputs[1] { @187D stack[0] = 0x1884 } // Block ends with call to 0x1dbd, returns to 0x1884 label_1884: // Incoming return from call to 0x1DBD at 0x1883 // Inputs[1] { @1889 tx.gasprice } 1884 5B JUMPDEST 1885 62 PUSH3 0x066a44 1889 3A GASPRICE 188A 14 EQ 188B 15 ISZERO 188C 15 ISZERO 188D 61 PUSH2 0x1894 1890 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1894, if !!(tx.gasprice == 0x066a44) label_1891: // Incoming jump from 0x1890, if not !!(tx.gasprice == 0x066a44) 1891 60 PUSH1 0x38 1893 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0038 label_1894: // Incoming jump from 0x1890, if !!(tx.gasprice == 0x066a44) 1894 5B JUMPDEST 1895 61 PUSH2 0x189c 1898 61 PUSH2 0x1dbd 189B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1895 stack[0] = 0x189c } // Block ends with call to 0x1dbd, returns to 0x189C label_189C: // Incoming return from call to 0x1DBD at 0x189B // Inputs[2] // { // @189D stack[-4] // @18A1 memory[stack[-4]:stack[-4] + 0x20] // } 189C 5B JUMPDEST 189D 83 DUP4 189E 60 PUSH1 0x1a 18A0 81 DUP2 18A1 51 MLOAD 18A2 81 DUP2 18A3 10 LT 18A4 15 ISZERO 18A5 15 ISZERO 18A6 61 PUSH2 0x18ab 18A9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @189D stack[0] = stack[-4] // @189E stack[1] = 0x1a // } // Block ends with conditional jump to 0x18ab, if !!(0x1a < memory[stack[-4]:stack[-4] + 0x20]) label_18AA: // Incoming jump from 0x18A9, if not !!(0x1a < memory[stack[-4]:stack[-4] + 0x20]) 18AA FE *ASSERT // Stack delta = +0 // Outputs[1] { @18AA assert(); } // Block terminates label_18AB: // Incoming jump from 0x18A9, if !!(0x1a < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[5] // { // @18AC stack[-1] // @18AC stack[-2] // @18B1 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @18F7 stack[-6] // @18FB memory[stack[-6]:stack[-6] + 0x20] // } 18AB 5B JUMPDEST 18AC 90 SWAP1 18AD 60 PUSH1 0x20 18AF 01 ADD 18B0 01 ADD 18B1 51 MLOAD 18B2 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 18D3 90 SWAP1 18D4 04 DIV 18D5 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 18F6 02 MUL 18F7 84 DUP5 18F8 60 PUSH1 0x1b 18FA 81 DUP2 18FB 51 MLOAD 18FC 81 DUP2 18FD 10 LT 18FE 15 ISZERO 18FF 15 ISZERO 1900 61 PUSH2 0x1905 1903 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @18F6 stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) // @18F7 stack[-1] = stack[-6] // @18F8 stack[0] = 0x1b // } // Block ends with conditional jump to 0x1905, if !!(0x1b < memory[stack[-6]:stack[-6] + 0x20]) label_1904: // Incoming jump from 0x1903, if not !!(0x1b < memory[stack[-6]:stack[-6] + 0x20]) 1904 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1904 assert(); } // Block terminates label_1905: // Incoming jump from 0x1903, if !!(0x1b < memory[stack[-6]:stack[-6] + 0x20]) // Inputs[5] // { // @1906 stack[-2] // @1906 stack[-1] // @190B memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @1951 stack[-7] // @1955 memory[stack[-7]:stack[-7] + 0x20] // } 1905 5B JUMPDEST 1906 90 SWAP1 1907 60 PUSH1 0x20 1909 01 ADD 190A 01 ADD 190B 51 MLOAD 190C 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 192D 90 SWAP1 192E 04 DIV 192F 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 1950 02 MUL 1951 85 DUP6 1952 60 PUSH1 0x1c 1954 81 DUP2 1955 51 MLOAD 1956 81 DUP2 1957 10 LT 1958 15 ISZERO 1959 15 ISZERO 195A 61 PUSH2 0x195f 195D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1950 stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) // @1951 stack[-1] = stack[-7] // @1952 stack[0] = 0x1c // } // Block ends with conditional jump to 0x195f, if !!(0x1c < memory[stack[-7]:stack[-7] + 0x20]) label_195E: // Incoming jump from 0x195D, if not !!(0x1c < memory[stack[-7]:stack[-7] + 0x20]) 195E FE *ASSERT // Stack delta = +0 // Outputs[1] { @195E assert(); } // Block terminates label_195F: // Incoming jump from 0x195D, if !!(0x1c < memory[stack[-7]:stack[-7] + 0x20]) // Inputs[5] // { // @1960 stack[-2] // @1960 stack[-1] // @1965 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @19AB stack[-8] // @19AF memory[stack[-8]:stack[-8] + 0x20] // } 195F 5B JUMPDEST 1960 90 SWAP1 1961 60 PUSH1 0x20 1963 01 ADD 1964 01 ADD 1965 51 MLOAD 1966 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 1987 90 SWAP1 1988 04 DIV 1989 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 19AA 02 MUL 19AB 86 DUP7 19AC 60 PUSH1 0x1d 19AE 81 DUP2 19AF 51 MLOAD 19B0 81 DUP2 19B1 10 LT 19B2 15 ISZERO 19B3 15 ISZERO 19B4 61 PUSH2 0x19b9 19B7 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @19AA stack[-2] = 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) // @19AB stack[-1] = stack[-8] // @19AC stack[0] = 0x1d // } // Block ends with conditional jump to 0x19b9, if !!(0x1d < memory[stack[-8]:stack[-8] + 0x20]) label_19B8: // Incoming jump from 0x19B7, if not !!(0x1d < memory[stack[-8]:stack[-8] + 0x20]) 19B8 FE *ASSERT // Stack delta = +0 // Outputs[1] { @19B8 assert(); } // Block terminates label_19B9: // Incoming jump from 0x19B7, if !!(0x1d < memory[stack[-8]:stack[-8] + 0x20]) // Inputs[10] // { // @19BA stack[-1] // @19BA stack[-2] // @19BF memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @1A07 memory[0x40:0x60] // @1A09 stack[-5] // @1A53 stack[-4] // @1A9D stack[-3] // @1B39 memory[0x40:0x60] // @1B3E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1B3F stack[-8] // } 19B9 5B JUMPDEST 19BA 90 SWAP1 19BB 60 PUSH1 0x20 19BD 01 ADD 19BE 01 ADD 19BF 51 MLOAD 19C0 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 19E1 90 SWAP1 19E2 04 DIV 19E3 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 1A04 02 MUL 1A05 60 PUSH1 0x40 1A07 51 MLOAD 1A08 80 DUP1 1A09 85 DUP6 1A0A 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1A2A 19 NOT 1A2B 16 AND 1A2C 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1A4C 19 NOT 1A4D 16 AND 1A4E 81 DUP2 1A4F 52 MSTORE 1A50 60 PUSH1 0x01 1A52 01 ADD 1A53 84 DUP5 1A54 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1A74 19 NOT 1A75 16 AND 1A76 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1A96 19 NOT 1A97 16 AND 1A98 81 DUP2 1A99 52 MSTORE 1A9A 60 PUSH1 0x01 1A9C 01 ADD 1A9D 83 DUP4 1A9E 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1ABE 19 NOT 1ABF 16 AND 1AC0 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1AE0 19 NOT 1AE1 16 AND 1AE2 81 DUP2 1AE3 52 MSTORE 1AE4 60 PUSH1 0x01 1AE6 01 ADD 1AE7 82 DUP3 1AE8 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1B08 19 NOT 1B09 16 AND 1B0A 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1B2A 19 NOT 1B2B 16 AND 1B2C 81 DUP2 1B2D 52 MSTORE 1B2E 60 PUSH1 0x01 1B30 01 ADD 1B31 94 SWAP5 1B32 50 POP 1B33 50 POP 1B34 50 POP 1B35 50 POP 1B36 50 POP 1B37 60 PUSH1 0x40 1B39 51 MLOAD 1B3A 80 DUP1 1B3B 91 SWAP2 1B3C 03 SUB 1B3D 90 SWAP1 1B3E 20 SHA3 1B3F 92 SWAP3 1B40 50 POP 1B41 61 PUSH2 0x1b48 1B44 61 PUSH2 0x1dbd 1B47 56 *JUMP // Stack delta = -4 // Outputs[6] // { // @1A4F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-5] // @1A99 memory[0x01 + memory[0x40:0x60]:0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-4] // @1AE3 memory[0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1B2D memory[0x01 + 0x01 + 0x01 + memory[0x40:0x60]:0x01 + 0x01 + 0x01 + memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) // @1B3F stack[-8] = keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x01 + 0x01 + 0x01 + 0x01 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @1B41 stack[-5] = 0x1b48 // } // Block ends with call to 0x1dbd, returns to 0x1B48 label_1B48: // Incoming return from call to 0x1DBD at 0x1B47 // Inputs[3] // { // @1B4B stack[-2] // @1B4E stack[-4] // @1B4F memory[stack[-4]:stack[-4] + 0x20] // } 1B48 5B JUMPDEST 1B49 60 PUSH1 0x00 1B4B 91 SWAP2 1B4C 50 POP 1B4D 5B JUMPDEST 1B4E 83 DUP4 1B4F 51 MLOAD 1B50 82 DUP3 1B51 10 LT 1B52 15 ISZERO 1B53 61 PUSH2 0x1c0f 1B56 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1B4B stack[-2] = 0x00 } // Block ends with conditional jump to 0x1c0f, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) label_1B57: // Incoming jump from 0x1B56, if not !(stack[-2] < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x1B56, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[4] // { // @1B57 msg.value // @1B7A stack[-4] // @1B7B stack[-2] // @1B7D memory[stack[-4]:stack[-4] + 0x20] // } 1B57 34 CALLVALUE 1B58 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 1B79 02 MUL 1B7A 84 DUP5 1B7B 83 DUP4 1B7C 81 DUP2 1B7D 51 MLOAD 1B7E 81 DUP2 1B7F 10 LT 1B80 15 ISZERO 1B81 15 ISZERO 1B82 61 PUSH2 0x1b87 1B85 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1B79 stack[0] = 0x0100000000000000000000000000000000000000000000000000000000000000 * msg.value // @1B7A stack[1] = stack[-4] // @1B7B stack[2] = stack[-2] // } // Block ends with conditional jump to 0x1b87, if !!(stack[-2] < memory[stack[-4]:stack[-4] + 0x20]) label_1B86: // Incoming jump from 0x1B85, if not !!(stack[-2] < memory[stack[-4]:stack[-4] + 0x20]) 1B86 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1B86 assert(); } // Block terminates label_1B87: // Incoming jump from 0x1B85, if !!(stack[-2] < memory[stack[-4]:stack[-4] + 0x20]) // Inputs[5] // { // @1B88 stack[-2] // @1B88 stack[-1] // @1B8D stack[-3] // @1B8F memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] // @1C03 stack[-5] // } 1B87 5B JUMPDEST 1B88 90 SWAP1 1B89 60 PUSH1 0x20 1B8B 01 ADD 1B8C 01 ADD 1B8D 81 DUP2 1B8E 81 DUP2 1B8F 51 MLOAD 1B90 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 1BB1 90 SWAP1 1BB2 04 DIV 1BB3 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 1BD4 02 MUL 1BD5 18 XOR 1BD6 91 SWAP2 1BD7 50 POP 1BD8 90 SWAP1 1BD9 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1BF9 19 NOT 1BFA 16 AND 1BFB 90 SWAP1 1BFC 81 DUP2 1BFD 60 PUSH1 0x00 1BFF 1A BYTE 1C00 90 SWAP1 1C01 53 MSTORE8 1C02 50 POP 1C03 81 DUP2 1C04 80 DUP1 1C05 60 PUSH1 0x01 1C07 01 ADD 1C08 92 SWAP3 1C09 50 POP 1C0A 50 POP 1C0B 61 PUSH2 0x1b4d 1C0E 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1C01 memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0x0100000000000000000000000000000000000000000000000000000000000000 * (memory[0x20 + stack[-2] + stack[-1]:0x20 + stack[-2] + stack[-1] + 0x20] / 0x0100000000000000000000000000000000000000000000000000000000000000) ~ stack[-3]), 0x00) // @1C08 stack[-5] = 0x01 + stack[-5] // } // Block ends with unconditional jump to 0x1b4d label_1C0F: // Incoming jump from 0x1B56, if !(stack[-2] < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x1B56, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) 1C0F 5B JUMPDEST 1C10 61 PUSH2 0x1c17 1C13 61 PUSH2 0x1dbd 1C16 56 *JUMP // Stack delta = +1 // Outputs[1] { @1C10 stack[0] = 0x1c17 } // Block ends with call to 0x1dbd, returns to 0x1C17 label_1C17: // Incoming return from call to 0x1DBD at 0x1C16 // Inputs[5] // { // @1C18 address(this) // @1C34 stack[-4] // @1C37 memory[0x40:0x60] // @1C70 memory[stack[-4]:stack[-4] + 0x20] // @1C79 memory[stack[-4]:stack[-4] + 0x20] // } 1C17 5B JUMPDEST 1C18 30 ADDRESS 1C19 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C2E 16 AND 1C2F 63 PUSH4 0xd6385778 1C34 85 DUP6 1C35 60 PUSH1 0x40 1C37 51 MLOAD 1C38 82 DUP3 1C39 63 PUSH4 0xffffffff 1C3E 16 AND 1C3F 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 1C5D 02 MUL 1C5E 81 DUP2 1C5F 52 MSTORE 1C60 60 PUSH1 0x04 1C62 01 ADD 1C63 80 DUP1 1C64 80 DUP1 1C65 60 PUSH1 0x20 1C67 01 ADD 1C68 82 DUP3 1C69 81 DUP2 1C6A 03 SUB 1C6B 82 DUP3 1C6C 52 MSTORE 1C6D 83 DUP4 1C6E 81 DUP2 1C6F 81 DUP2 1C70 51 MLOAD 1C71 81 DUP2 1C72 52 MSTORE 1C73 60 PUSH1 0x20 1C75 01 ADD 1C76 91 SWAP2 1C77 50 POP 1C78 80 DUP1 1C79 51 MLOAD 1C7A 90 SWAP1 1C7B 60 PUSH1 0x20 1C7D 01 ADD 1C7E 90 SWAP1 1C7F 80 DUP1 1C80 83 DUP4 1C81 83 DUP4 1C82 60 PUSH1 0x00 1C84 5B JUMPDEST 1C85 83 DUP4 1C86 81 DUP2 1C87 10 LT 1C88 15 ISZERO 1C89 61 PUSH2 0x1c9f 1C8C 57 *JUMPI // Stack delta = +12 // Outputs[15] // { // @1C2E stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @1C2F stack[1] = 0xd6385778 // @1C34 stack[2] = stack[-4] // @1C5F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100000000000000000000000000000000000000000000000000000000 * (0xffffffff & 0xd6385778) // @1C62 stack[3] = 0x04 + memory[0x40:0x60] // @1C63 stack[4] = 0x04 + memory[0x40:0x60] // @1C6C memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1C72 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-4]:stack[-4] + 0x20] // @1C76 stack[5] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1C7E stack[6] = 0x20 + stack[-4] // @1C7E stack[7] = memory[stack[-4]:stack[-4] + 0x20] // @1C7F stack[8] = memory[stack[-4]:stack[-4] + 0x20] // @1C80 stack[9] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1C81 stack[10] = 0x20 + stack[-4] // @1C82 stack[11] = 0x00 // } // Block ends with conditional jump to 0x1c9f, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) label_1C8D: // Incoming jump from 0x1C8C, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x1C8C, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @1C8D stack[-1] // @1C8E stack[-2] // @1C90 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @1C92 stack[-3] // } 1C8D 80 DUP1 1C8E 82 DUP3 1C8F 01 ADD 1C90 51 MLOAD 1C91 81 DUP2 1C92 84 DUP5 1C93 01 ADD 1C94 52 MSTORE 1C95 60 PUSH1 0x20 1C97 81 DUP2 1C98 01 ADD 1C99 90 SWAP1 1C9A 50 POP 1C9B 61 PUSH2 0x1c84 1C9E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1C94 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @1C99 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1c84 label_1C9F: // Incoming jump from 0x1C8C, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x1C8C, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @1CA4 stack[-6] // @1CA4 stack[-5] // @1CA6 stack[-7] // } 1C9F 5B JUMPDEST 1CA0 50 POP 1CA1 50 POP 1CA2 50 POP 1CA3 50 POP 1CA4 90 SWAP1 1CA5 50 POP 1CA6 90 SWAP1 1CA7 81 DUP2 1CA8 01 ADD 1CA9 90 SWAP1 1CAA 60 PUSH1 0x1f 1CAC 16 AND 1CAD 80 DUP1 1CAE 15 ISZERO 1CAF 61 PUSH2 0x1ccc 1CB2 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1CA9 stack[-7] = stack[-5] + stack[-7] // @1CAC stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x1ccc, if !(0x1f & stack[-5]) label_1CB3: // Incoming jump from 0x1CB2, if not !(0x1f & stack[-5]) // Inputs[7] // { // @1CB3 stack[-1] // @1CB4 stack[-2] // @1CB7 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @1CCE stack[-5] // @1CD6 memory[0x40:0x60] // @1CDD stack[-7] // @1CDF address(stack[-7]).code.length // } 1CB3 80 DUP1 1CB4 82 DUP3 1CB5 03 SUB 1CB6 80 DUP1 1CB7 51 MLOAD 1CB8 60 PUSH1 0x01 1CBA 83 DUP4 1CBB 60 PUSH1 0x20 1CBD 03 SUB 1CBE 61 PUSH2 0x0100 1CC1 0A EXP 1CC2 03 SUB 1CC3 19 NOT 1CC4 16 AND 1CC5 81 DUP2 1CC6 52 MSTORE 1CC7 60 PUSH1 0x20 1CC9 01 ADD 1CCA 91 SWAP2 1CCB 50 POP 1CCC 5B JUMPDEST 1CCD 50 POP 1CCE 92 SWAP3 1CCF 50 POP 1CD0 50 POP 1CD1 50 POP 1CD2 60 PUSH1 0x00 1CD4 60 PUSH1 0x40 1CD6 51 MLOAD 1CD7 80 DUP1 1CD8 83 DUP4 1CD9 03 SUB 1CDA 81 DUP2 1CDB 60 PUSH1 0x00 1CDD 87 DUP8 1CDE 80 DUP1 1CDF 3B EXTCODESIZE 1CE0 15 ISZERO 1CE1 15 ISZERO 1CE2 61 PUSH2 0x1cea 1CE5 57 *JUMPI // Stack delta = +2 // Outputs[8] // { // @1CC6 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @1CCE stack[-5] = 0x20 + (stack[-2] - stack[-1]) // @1CD2 stack[-4] = 0x00 // @1CD6 stack[-3] = memory[0x40:0x60] // @1CD9 stack[-2] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @1CDA stack[-1] = memory[0x40:0x60] // @1CDB stack[0] = 0x00 // @1CDD stack[1] = stack[-7] // } // Block ends with conditional jump to 0x1cea, if !!address(stack[-7]).code.length label_1CE6: // Incoming jump from 0x1CE5, if not !!address(stack[-7]).code.length // Incoming jump from 0x1CE5, if not !!address(stack[-7]).code.length // Inputs[1] { @1CE9 memory[0x00:0x00] } 1CE6 60 PUSH1 0x00 1CE8 80 DUP1 1CE9 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CE9 revert(memory[0x00:0x00]); } // Block terminates label_1CEA: // Incoming jump from 0x1CE5, if !!address(stack[-7]).code.length // Incoming jump from 0x1CE5, if !!address(stack[-7]).code.length // Inputs[9] // { // @1CEB msg.gas // @1CEC stack[-6] // @1CEC stack[-4] // @1CEC address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) // @1CEC memory[stack[-3]:stack[-3] + stack[-4]] // @1CEC stack[-1] // @1CEC stack[-3] // @1CEC stack[-2] // @1CEC stack[-5] // } 1CEA 5B JUMPDEST 1CEB 5A GAS 1CEC F1 CALL 1CED 15 ISZERO 1CEE 15 ISZERO 1CEF 61 PUSH2 0x1cf7 1CF2 57 *JUMPI // Stack delta = -6 // Outputs[1] { @1CEC memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) } // Block ends with conditional jump to 0x1cf7, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) label_1CF3: // Incoming jump from 0x1CF2, if not !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[1] { @1CF6 memory[0x00:0x00] } 1CF3 60 PUSH1 0x00 1CF5 80 DUP1 1CF6 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CF6 revert(memory[0x00:0x00]); } // Block terminates label_1CF7: // Incoming jump from 0x1CF2, if !!address(stack[-1]).call.gas(msg.gas).value(stack[-2])(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1D04 stack[-4] // @1D07 msg.value // } 1CF7 5B JUMPDEST 1CF8 50 POP 1CF9 50 POP 1CFA 50 POP 1CFB 67 PUSH8 0x73686974636f696e 1D04 90 SWAP1 1D05 50 POP 1D06 80 DUP1 1D07 34 CALLVALUE 1D08 14 EQ 1D09 15 ISZERO 1D0A 61 PUSH2 0x1d11 1D0D 57 *JUMPI // Stack delta = -3 // Outputs[1] { @1D04 stack[-4] = 0x73686974636f696e } // Block ends with conditional jump to 0x1d11, if !(msg.value == 0x73686974636f696e) label_1D0E: // Incoming jump from 0x1D0D, if not !(msg.value == 0x73686974636f696e) 1D0E 60 PUSH1 0x38 1D10 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0038 label_1D11: // Incoming jump from 0x1D0D, if !(msg.value == 0x73686974636f696e) 1D11 5B JUMPDEST 1D12 61 PUSH2 0x1d19 1D15 61 PUSH2 0x1dbd 1D18 56 *JUMP // Stack delta = +1 // Outputs[1] { @1D12 stack[0] = 0x1d19 } // Block ends with call to 0x1dbd, returns to 0x1D19 label_1D19: // Incoming return from call to 0x1DBD at 0x1D18 // Inputs[4] // { // @1D21 msg.sender // @1D22 address(msg.sender).code[0x59:0x5d] // @1D26 memory[0x0200:0x0220] // @1D27 stack[-1] // } 1D19 5B JUMPDEST 1D1A 60 PUSH1 0x04 1D1C 60 PUSH1 0x59 1D1E 61 PUSH2 0x021c 1D21 33 CALLER 1D22 3C EXTCODECOPY 1D23 61 PUSH2 0x0200 1D26 51 MLOAD 1D27 90 SWAP1 1D28 50 POP 1D29 61 PUSH2 0x1d30 1D2C 61 PUSH2 0x1dbd 1D2F 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1D22 memory[0x021c:0x0220] = address(msg.sender).code[0x59:0x5d] // @1D27 stack[-1] = memory[0x0200:0x0220] // @1D29 stack[0] = 0x1d30 // } // Block ends with call to 0x1dbd, returns to 0x1D30 label_1D30: // Incoming return from call to 0x1DBD at 0x1D2F // Inputs[5] // { // @1D31 stack[-3] // @1D36 stack[-1] // @1D58 memory[0x40:0x60] // @1DA3 memory[0x40:0x60] // @1DA8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1D30 5B JUMPDEST 1D31 82 DUP3 1D32 60 PUSH1 0x00 1D34 19 NOT 1D35 16 AND 1D36 81 DUP2 1D37 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 1D55 02 MUL 1D56 60 PUSH1 0x40 1D58 51 MLOAD 1D59 80 DUP1 1D5A 82 DUP3 1D5B 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1D78 19 NOT 1D79 16 AND 1D7A 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1D97 19 NOT 1D98 16 AND 1D99 81 DUP2 1D9A 52 MSTORE 1D9B 60 PUSH1 0x04 1D9D 01 ADD 1D9E 91 SWAP2 1D9F 50 POP 1DA0 50 POP 1DA1 60 PUSH1 0x40 1DA3 51 MLOAD 1DA4 80 DUP1 1DA5 91 SWAP2 1DA6 03 SUB 1DA7 90 SWAP1 1DA8 20 SHA3 1DA9 60 PUSH1 0x00 1DAB 19 NOT 1DAC 16 AND 1DAD 14 EQ 1DAE 15 ISZERO 1DAF 15 ISZERO 1DB0 61 PUSH2 0x1db7 1DB3 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1D9A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x0100000000000000000000000000000000000000000000000000000000 * stack[-1] } // Block ends with conditional jump to 0x1db7, if !!(~0x00 & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]) == ~0x00 & stack[-3]) label_1DB4: // Incoming jump from 0x1DB3, if not !!(~0x00 & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]) == ~0x00 & stack[-3]) 1DB4 60 PUSH1 0x38 1DB6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0038 label_1DB7: // Incoming jump from 0x1DB3, if !!(~0x00 & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]) == ~0x00 & stack[-3]) // Inputs[1] { @1DBC stack[-5] } 1DB7 5B JUMPDEST 1DB8 50 POP 1DB9 50 POP 1DBA 50 POP 1DBB 50 POP 1DBC 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_1DBD: // Incoming call from 0x07EC, returns to 0x07ED // Incoming call from 0x11B1, returns to 0x11B2 // Incoming call from 0x0E83, returns to 0x0E84 // Incoming call from 0x1B47, returns to 0x1B48 // Incoming call from 0x0C7B, returns to 0x0C7C // Incoming call from 0x1D18, returns to 0x1D19 // Incoming call from 0x1883, returns to 0x1884 // Incoming call from 0x1D2F, returns to 0x1D30 // Incoming call from 0x0DD3, returns to 0x0DD4 // Incoming call from 0x0FDB, returns to 0x0FDC // Incoming call from 0x02CF, returns to 0x02D0 // Incoming call from 0x189B, returns to 0x189C // Incoming call from 0x10C7, returns to 0x10C8 // Incoming call from 0x0AE5, returns to 0x0AE6 // Incoming call from 0x1780, returns to 0x1781 // Incoming call from 0x1C16, returns to 0x1C17 // Incoming call from 0x071C, returns to 0x071D // Incoming call from 0x1177, returns to 0x1178 1DBD 5B JUMPDEST 1DBE 60 PUSH1 0x00 1DC0 61 PUSH2 0x1dc6 1DC3 01 ADD 1DC4 80 DUP1 1DC5 56 *JUMP // Stack delta = +1 // Outputs[1] { @1DC3 stack[0] = 0x1dc6 + 0x00 } // Block ends with unconditional jump to 0x1dc6 + 0x00 label_1DC6: // Incoming jump from 0x1DC5 // Inputs[1] { @1DC8 stack[-2] } 1DC6 5B JUMPDEST 1DC7 50 POP 1DC8 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] 1DC9 00 *STOP 1DCA A1 LOG1 1DCB 65 PUSH6 0x627a7a723058 1DD2 20 SHA3 1DD3 EA EA 1DD4 82 DUP3 1DD5 3A GASPRICE 1DD6 E6 E6 1DD7 4C 4C 1DD8 4D 4D 1DD9 0A EXP 1DDA 53 MSTORE8 1DDB 8A DUP11 1DDC 62 PUSH3 0x5ed214 1DE0 5F 5F 1DE1 63 PUSH4 0x8d8dfa4a 1DE6 01 ADD 1DE7 54 SLOAD 1DE8 A7 A7 1DE9 DC DC 1DEA 19 NOT 1DEB EF EF 1DEC EC EC 1DED D1 D1 1DEE 22 22 1DEF AE AE 1DF0 10 LT 1DF1 12 SLT 1DF2 C3 C3 1DF3 00 *STOP 1DF4 29 29
Found this site useful?
Donations are greatly appreciated!
ETH: 0xB3F04f0c276fa1177c1779f6E1E156B2738ea392
Contact/hire: [email protected]