Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x0246 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0246, 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 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x8da5cb5b 0019 11 GT 001A 61 PUSH2 0x0139 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0139, if 0x8da5cb5b > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x8da5cb5b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xc47f0027 0024 11 GT 0025 61 PUSH2 0x00b6 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b6, if 0xc47f0027 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xc47f0027 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xdecd6e5b 002F 11 GT 0030 61 PUSH2 0x007a 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007a, if 0xdecd6e5b > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xdecd6e5b > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xdecd6e5b 003A 14 EQ 003B 61 PUSH2 0x0655 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0655, if 0xdecd6e5b == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xdecd6e5b == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xdff13081 0045 14 EQ 0046 61 PUSH2 0x066a 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x066a, if 0xdff13081 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xdff13081 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xe985e9c5 0050 14 EQ 0051 61 PUSH2 0x067f 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x067f, if 0xe985e9c5 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xedc1fe41 005B 14 EQ 005C 61 PUSH2 0x06c8 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06c8, if 0xedc1fe41 == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xedc1fe41 == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xf2fde38b 0066 14 EQ 0067 61 PUSH2 0x06dd 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06dd, if 0xf2fde38b == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xf2fde38b == stack[-1] // Inputs[1] { @006B stack[-1] } 006B 80 DUP1 006C 63 PUSH4 0xf47d224b 0071 14 EQ 0072 61 PUSH2 0x06fd 0075 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06fd, if 0xf47d224b == stack[-1] label_0076: // Incoming jump from 0x0075, if not 0xf47d224b == stack[-1] // Inputs[1] { @0079 memory[0x00:0x00] } 0076 60 PUSH1 0x00 0078 80 DUP1 0079 FD *REVERT // Stack delta = +0 // Outputs[1] { @0079 revert(memory[0x00:0x00]); } // Block terminates label_007A: // Incoming jump from 0x0033, if 0xdecd6e5b > stack[-1] // Inputs[1] { @007B stack[-1] } 007A 5B JUMPDEST 007B 80 DUP1 007C 63 PUSH4 0xc47f0027 0081 14 EQ 0082 61 PUSH2 0x05cc 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05cc, if 0xc47f0027 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xc47f0027 == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xc4be5b59 008C 14 EQ 008D 61 PUSH2 0x05ec 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05ec, if 0xc4be5b59 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xc4be5b59 == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xc87b56dd 0097 14 EQ 0098 61 PUSH2 0x05ff 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05ff, if 0xc87b56dd == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xc87b56dd == stack[-1] // Inputs[1] { @009C stack[-1] } 009C 80 DUP1 009D 63 PUSH4 0xcc46f31e 00A2 14 EQ 00A3 61 PUSH2 0x061f 00A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x061f, if 0xcc46f31e == stack[-1] label_00A7: // Incoming jump from 0x00A6, if not 0xcc46f31e == stack[-1] // Inputs[1] { @00A7 stack[-1] } 00A7 80 DUP1 00A8 63 PUSH4 0xd60abf78 00AD 14 EQ 00AE 61 PUSH2 0x063f 00B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x063f, if 0xd60abf78 == stack[-1] label_00B2: // Incoming jump from 0x00B1, if not 0xd60abf78 == stack[-1] // Inputs[1] { @00B5 memory[0x00:0x00] } 00B2 60 PUSH1 0x00 00B4 80 DUP1 00B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @00B5 revert(memory[0x00:0x00]); } // Block terminates label_00B6: // Incoming jump from 0x0028, if 0xc47f0027 > stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B6 5B JUMPDEST 00B7 80 DUP1 00B8 63 PUSH4 0xa035b1fe 00BD 11 GT 00BE 61 PUSH2 0x00fd 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00fd, if 0xa035b1fe > stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0xa035b1fe > stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0xa035b1fe 00C8 14 EQ 00C9 61 PUSH2 0x0541 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0541, if 0xa035b1fe == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0xa035b1fe == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0xa22cb465 00D3 14 EQ 00D4 61 PUSH2 0x0557 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0557, if 0xa22cb465 == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00D8 stack[-1] } 00D8 80 DUP1 00D9 63 PUSH4 0xa62771d6 00DE 14 EQ 00DF 61 PUSH2 0x0577 00E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0577, if 0xa62771d6 == stack[-1] label_00E3: // Incoming jump from 0x00E2, if not 0xa62771d6 == stack[-1] // Inputs[1] { @00E3 stack[-1] } 00E3 80 DUP1 00E4 63 PUSH4 0xb84c8246 00E9 14 EQ 00EA 61 PUSH2 0x058c 00ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x058c, if 0xb84c8246 == stack[-1] label_00EE: // Incoming jump from 0x00ED, if not 0xb84c8246 == stack[-1] // Inputs[1] { @00EE stack[-1] } 00EE 80 DUP1 00EF 63 PUSH4 0xb88d4fde 00F4 14 EQ 00F5 61 PUSH2 0x05ac 00F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05ac, if 0xb88d4fde == stack[-1] label_00F9: // Incoming jump from 0x00F8, if not 0xb88d4fde == stack[-1] // Inputs[1] { @00FC memory[0x00:0x00] } 00F9 60 PUSH1 0x00 00FB 80 DUP1 00FC FD *REVERT // Stack delta = +0 // Outputs[1] { @00FC revert(memory[0x00:0x00]); } // Block terminates label_00FD: // Incoming jump from 0x00C1, if 0xa035b1fe > stack[-1] // Inputs[1] { @00FE stack[-1] } 00FD 5B JUMPDEST 00FE 80 DUP1 00FF 63 PUSH4 0x8da5cb5b 0104 14 EQ 0105 61 PUSH2 0x04a9 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04a9, if 0x8da5cb5b == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0109 stack[-1] } 0109 80 DUP1 010A 63 PUSH4 0x91b7f5ed 010F 14 EQ 0110 61 PUSH2 0x04cc 0113 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04cc, if 0x91b7f5ed == stack[-1] label_0114: // Incoming jump from 0x0113, if not 0x91b7f5ed == stack[-1] // Inputs[1] { @0114 stack[-1] } 0114 80 DUP1 0115 63 PUSH4 0x95d89b41 011A 14 EQ 011B 61 PUSH2 0x04ec 011E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ec, if 0x95d89b41 == stack[-1] label_011F: // Incoming jump from 0x011E, if not 0x95d89b41 == stack[-1] // Inputs[1] { @011F stack[-1] } 011F 80 DUP1 0120 63 PUSH4 0x9851b815 0125 14 EQ 0126 61 PUSH2 0x0501 0129 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0501, if 0x9851b815 == stack[-1] label_012A: // Incoming jump from 0x0129, if not 0x9851b815 == stack[-1] // Inputs[1] { @012A stack[-1] } 012A 80 DUP1 012B 63 PUSH4 0x9afd313f 0130 14 EQ 0131 61 PUSH2 0x0521 0134 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0521, if 0x9afd313f == stack[-1] label_0135: // Incoming jump from 0x0134, if not 0x9afd313f == stack[-1] // Inputs[1] { @0138 memory[0x00:0x00] } 0135 60 PUSH1 0x00 0137 80 DUP1 0138 FD *REVERT // Stack delta = +0 // Outputs[1] { @0138 revert(memory[0x00:0x00]); } // Block terminates label_0139: // Incoming jump from 0x001D, if 0x8da5cb5b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @013A stack[-1] } 0139 5B JUMPDEST 013A 80 DUP1 013B 63 PUSH4 0x3f4ba83a 0140 11 GT 0141 61 PUSH2 0x01c7 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c7, if 0x3f4ba83a > stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x3f4ba83a > stack[-1] // Inputs[1] { @0145 stack[-1] } 0145 80 DUP1 0146 63 PUSH4 0x70a08231 014B 11 GT 014C 61 PUSH2 0x018b 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x018b, if 0x70a08231 > stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x70a08231 > stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x70a08231 0156 14 EQ 0157 61 PUSH2 0x042a 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x042a, if 0x70a08231 == stack[-1] label_015B: // Incoming jump from 0x015A, if not 0x70a08231 == stack[-1] // Inputs[1] { @015B stack[-1] } 015B 80 DUP1 015C 63 PUSH4 0x715018a6 0161 14 EQ 0162 61 PUSH2 0x044a 0165 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x044a, if 0x715018a6 == stack[-1] label_0166: // Incoming jump from 0x0165, if not 0x715018a6 == stack[-1] // Inputs[1] { @0166 stack[-1] } 0166 80 DUP1 0167 63 PUSH4 0x76c64c62 016C 14 EQ 016D 61 PUSH2 0x045f 0170 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x045f, if 0x76c64c62 == stack[-1] label_0171: // Incoming jump from 0x0170, if not 0x76c64c62 == stack[-1] // Inputs[1] { @0171 stack[-1] } 0171 80 DUP1 0172 63 PUSH4 0x7cb64759 0177 14 EQ 0178 61 PUSH2 0x0474 017B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0474, if 0x7cb64759 == stack[-1] label_017C: // Incoming jump from 0x017B, if not 0x7cb64759 == stack[-1] // Inputs[1] { @017C stack[-1] } 017C 80 DUP1 017D 63 PUSH4 0x8456cb59 0182 14 EQ 0183 61 PUSH2 0x0494 0186 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0494, if 0x8456cb59 == stack[-1] label_0187: // Incoming jump from 0x0186, if not 0x8456cb59 == stack[-1] // Inputs[1] { @018A memory[0x00:0x00] } 0187 60 PUSH1 0x00 0189 80 DUP1 018A FD *REVERT // Stack delta = +0 // Outputs[1] { @018A revert(memory[0x00:0x00]); } // Block terminates label_018B: // Incoming jump from 0x014F, if 0x70a08231 > stack[-1] // Inputs[1] { @018C stack[-1] } 018B 5B JUMPDEST 018C 80 DUP1 018D 63 PUSH4 0x3f4ba83a 0192 14 EQ 0193 61 PUSH2 0x039d 0196 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x039d, if 0x3f4ba83a == stack[-1] label_0197: // Incoming jump from 0x0196, if not 0x3f4ba83a == stack[-1] // Inputs[1] { @0197 stack[-1] } 0197 80 DUP1 0198 63 PUSH4 0x42842e0e 019D 14 EQ 019E 61 PUSH2 0x03b2 01A1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b2, if 0x42842e0e == stack[-1] label_01A2: // Incoming jump from 0x01A1, if not 0x42842e0e == stack[-1] // Inputs[1] { @01A2 stack[-1] } 01A2 80 DUP1 01A3 63 PUSH4 0x55f804b3 01A8 14 EQ 01A9 61 PUSH2 0x03d2 01AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d2, if 0x55f804b3 == stack[-1] label_01AD: // Incoming jump from 0x01AC, if not 0x55f804b3 == stack[-1] // Inputs[1] { @01AD stack[-1] } 01AD 80 DUP1 01AE 63 PUSH4 0x5c975abb 01B3 14 EQ 01B4 61 PUSH2 0x03f2 01B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f2, if 0x5c975abb == stack[-1] label_01B8: // Incoming jump from 0x01B7, if not 0x5c975abb == stack[-1] // Inputs[1] { @01B8 stack[-1] } 01B8 80 DUP1 01B9 63 PUSH4 0x6352211e 01BE 14 EQ 01BF 61 PUSH2 0x040a 01C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x040a, if 0x6352211e == stack[-1] label_01C3: // Incoming jump from 0x01C2, if not 0x6352211e == stack[-1] // Inputs[1] { @01C6 memory[0x00:0x00] } 01C3 60 PUSH1 0x00 01C5 80 DUP1 01C6 FD *REVERT // Stack delta = +0 // Outputs[1] { @01C6 revert(memory[0x00:0x00]); } // Block terminates label_01C7: // Incoming jump from 0x0144, if 0x3f4ba83a > stack[-1] // Inputs[1] { @01C8 stack[-1] } 01C7 5B JUMPDEST 01C8 80 DUP1 01C9 63 PUSH4 0x18160ddd 01CE 11 GT 01CF 61 PUSH2 0x020e 01D2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x020e, if 0x18160ddd > stack[-1] label_01D3: // Incoming jump from 0x01D2, if not 0x18160ddd > stack[-1] // Inputs[1] { @01D3 stack[-1] } 01D3 80 DUP1 01D4 63 PUSH4 0x18160ddd 01D9 14 EQ 01DA 61 PUSH2 0x031c 01DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x031c, if 0x18160ddd == stack[-1] label_01DE: // Incoming jump from 0x01DD, if not 0x18160ddd == stack[-1] // Inputs[1] { @01DE stack[-1] } 01DE 80 DUP1 01DF 63 PUSH4 0x23b872dd 01E4 14 EQ 01E5 61 PUSH2 0x033f 01E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033f, if 0x23b872dd == stack[-1] label_01E9: // Incoming jump from 0x01E8, if not 0x23b872dd == stack[-1] // Inputs[1] { @01E9 stack[-1] } 01E9 80 DUP1 01EA 63 PUSH4 0x2402ca23 01EF 14 EQ 01F0 61 PUSH2 0x035f 01F3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x035f, if 0x2402ca23 == stack[-1] label_01F4: // Incoming jump from 0x01F3, if not 0x2402ca23 == stack[-1] // Inputs[1] { @01F4 stack[-1] } 01F4 80 DUP1 01F5 63 PUSH4 0x2db11544 01FA 14 EQ 01FB 61 PUSH2 0x0375 01FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0375, if 0x2db11544 == stack[-1] label_01FF: // Incoming jump from 0x01FE, if not 0x2db11544 == stack[-1] // Inputs[1] { @01FF stack[-1] } 01FF 80 DUP1 0200 63 PUSH4 0x3ccfd60b 0205 14 EQ 0206 61 PUSH2 0x0388 0209 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0388, if 0x3ccfd60b == stack[-1] label_020A: // Incoming jump from 0x0209, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @020D memory[0x00:0x00] } 020A 60 PUSH1 0x00 020C 80 DUP1 020D FD *REVERT // Stack delta = +0 // Outputs[1] { @020D revert(memory[0x00:0x00]); } // Block terminates label_020E: // Incoming jump from 0x01D2, if 0x18160ddd > stack[-1] // Inputs[1] { @020F stack[-1] } 020E 5B JUMPDEST 020F 80 DUP1 0210 63 PUSH4 0x01ffc9a7 0215 14 EQ 0216 61 PUSH2 0x024b 0219 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024b, if 0x01ffc9a7 == stack[-1] label_021A: // Incoming jump from 0x0219, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @021A stack[-1] } 021A 80 DUP1 021B 63 PUSH4 0x06fdde03 0220 14 EQ 0221 61 PUSH2 0x0280 0224 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0280, if 0x06fdde03 == stack[-1] label_0225: // Incoming jump from 0x0224, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0225 stack[-1] } 0225 80 DUP1 0226 63 PUSH4 0x081812fc 022B 14 EQ 022C 61 PUSH2 0x02a2 022F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a2, if 0x081812fc == stack[-1] label_0230: // Incoming jump from 0x022F, if not 0x081812fc == stack[-1] // Inputs[1] { @0230 stack[-1] } 0230 80 DUP1 0231 63 PUSH4 0x095ea7b3 0236 14 EQ 0237 61 PUSH2 0x02da 023A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02da, if 0x095ea7b3 == stack[-1] label_023B: // Incoming jump from 0x023A, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @023B stack[-1] } 023B 80 DUP1 023C 63 PUSH4 0x0ff8e323 0241 14 EQ 0242 61 PUSH2 0x02fc 0245 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02fc, if 0x0ff8e323 == stack[-1] label_0246: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x0245, if not 0x0ff8e323 == stack[-1] // Inputs[1] { @024A memory[0x00:0x00] } 0246 5B JUMPDEST 0247 60 PUSH1 0x00 0249 80 DUP1 024A FD *REVERT // Stack delta = +0 // Outputs[1] { @024A revert(memory[0x00:0x00]); } // Block terminates label_024B: // Incoming jump from 0x0219, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @024C msg.value } 024B 5B JUMPDEST 024C 34 CALLVALUE 024D 80 DUP1 024E 15 ISZERO 024F 61 PUSH2 0x0257 0252 57 *JUMPI // Stack delta = +1 // Outputs[1] { @024C stack[0] = msg.value } // Block ends with conditional jump to 0x0257, if !msg.value label_0253: // Incoming jump from 0x0252, if not !msg.value // Inputs[1] { @0256 memory[0x00:0x00] } 0253 60 PUSH1 0x00 0255 80 DUP1 0256 FD *REVERT // Stack delta = +0 // Outputs[1] { @0256 revert(memory[0x00:0x00]); } // Block terminates label_0257: // Incoming jump from 0x0252, if !msg.value // Inputs[1] { @025F msg.data.length } 0257 5B JUMPDEST 0258 50 POP 0259 61 PUSH2 0x026b 025C 61 PUSH2 0x0266 025F 36 CALLDATASIZE 0260 60 PUSH1 0x04 0262 61 PUSH2 0x2313 0265 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0259 stack[-1] = 0x026b // @025C stack[0] = 0x0266 // @025F stack[1] = msg.data.length // @0260 stack[2] = 0x04 // } // Block ends with call to 0x2313, returns to 0x0266 label_0266: // Incoming return from call to 0x2313 at 0x0265 0266 5B JUMPDEST 0267 61 PUSH2 0x0712 026A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0712 label_026B: // Incoming jump from 0x0409 // Incoming return from call to 0x0266 at 0x0265 // Incoming return from call to 0x069A at 0x0699 // Inputs[2] // { // @026E memory[0x40:0x60] // @026F stack[-1] // } 026B 5B JUMPDEST 026C 60 PUSH1 0x40 026E 51 MLOAD 026F 90 SWAP1 0270 15 ISZERO 0271 15 ISZERO 0272 81 DUP2 0273 52 MSTORE 0274 60 PUSH1 0x20 0276 01 ADD // Stack delta = +0 // Outputs[2] // { // @0273 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0276 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_0277: // Incoming jump from 0x02D9 // Incoming jump from 0x0276 // Incoming jump from 0x033E // Inputs[3] // { // @027A memory[0x40:0x60] // @027C stack[-1] // @027F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0277 5B JUMPDEST 0278 60 PUSH1 0x40 027A 51 MLOAD 027B 80 DUP1 027C 91 SWAP2 027D 03 SUB 027E 90 SWAP1 027F F3 *RETURN // Stack delta = -1 // Outputs[1] { @027F return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0280: // Incoming jump from 0x0224, if 0x06fdde03 == stack[-1] // Inputs[1] { @0281 msg.value } 0280 5B JUMPDEST 0281 34 CALLVALUE 0282 80 DUP1 0283 15 ISZERO 0284 61 PUSH2 0x028c 0287 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0281 stack[0] = msg.value } // Block ends with conditional jump to 0x028c, if !msg.value label_0288: // Incoming jump from 0x0287, if not !msg.value // Inputs[1] { @028B memory[0x00:0x00] } 0288 60 PUSH1 0x00 028A 80 DUP1 028B FD *REVERT // Stack delta = +0 // Outputs[1] { @028B revert(memory[0x00:0x00]); } // Block terminates label_028C: // Incoming jump from 0x0287, if !msg.value 028C 5B JUMPDEST 028D 50 POP 028E 61 PUSH2 0x0295 0291 61 PUSH2 0x0764 0294 56 *JUMP // Stack delta = +0 // Outputs[1] { @028E stack[-1] = 0x0295 } // Block ends with call to 0x0764, returns to 0x0295 label_0295: // Incoming return from call to 0x0C89 at 0x0500 // Incoming return from call to 0x0DE7 at 0x058B // Incoming return from call to 0x0764 at 0x0294 // Inputs[2] // { // @0298 memory[0x40:0x60] // @029C stack[-1] // } 0295 5B JUMPDEST 0296 60 PUSH1 0x40 0298 51 MLOAD 0299 61 PUSH2 0x0277 029C 91 SWAP2 029D 90 SWAP1 029E 61 PUSH2 0x24bf 02A1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @029C stack[-1] = 0x0277 // @029D stack[1] = memory[0x40:0x60] // @029D stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x24bf label_02A2: // Incoming jump from 0x022F, if 0x081812fc == stack[-1] // Inputs[1] { @02A3 msg.value } 02A2 5B JUMPDEST 02A3 34 CALLVALUE 02A4 80 DUP1 02A5 15 ISZERO 02A6 61 PUSH2 0x02ae 02A9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02A3 stack[0] = msg.value } // Block ends with conditional jump to 0x02ae, if !msg.value label_02AA: // Incoming jump from 0x02A9, if not !msg.value // Inputs[1] { @02AD memory[0x00:0x00] } 02AA 60 PUSH1 0x00 02AC 80 DUP1 02AD FD *REVERT // Stack delta = +0 // Outputs[1] { @02AD revert(memory[0x00:0x00]); } // Block terminates label_02AE: // Incoming jump from 0x02A9, if !msg.value // Inputs[1] { @02B6 msg.data.length } 02AE 5B JUMPDEST 02AF 50 POP 02B0 61 PUSH2 0x02c2 02B3 61 PUSH2 0x02bd 02B6 36 CALLDATASIZE 02B7 60 PUSH1 0x04 02B9 61 PUSH2 0x22fb 02BC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02B0 stack[-1] = 0x02c2 // @02B3 stack[0] = 0x02bd // @02B6 stack[1] = msg.data.length // @02B7 stack[2] = 0x04 // } // Block ends with call to 0x22fb, returns to 0x02BD label_02BD: // Incoming return from call to 0x22FB at 0x02BC 02BD 5B JUMPDEST 02BE 61 PUSH2 0x07f6 02C1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07f6 label_02C2: // Incoming return from call to 0x02BD at 0x02BC // Incoming jump from 0x04CB // Incoming return from call to 0x0425 at 0x0424 // Inputs[2] // { // @02C5 memory[0x40:0x60] // @02CF stack[-1] // } 02C2 5B JUMPDEST 02C3 60 PUSH1 0x40 02C5 51 MLOAD 02C6 60 PUSH1 0x01 02C8 60 PUSH1 0x01 02CA 60 PUSH1 0xa0 02CC 1B SHL 02CD 03 SUB 02CE 90 SWAP1 02CF 91 SWAP2 02D0 16 AND 02D1 81 DUP2 02D2 52 MSTORE 02D3 60 PUSH1 0x20 02D5 01 ADD 02D6 61 PUSH2 0x0277 02D9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02D2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @02D5 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0277 label_02DA: // Incoming jump from 0x023A, if 0x095ea7b3 == stack[-1] // Inputs[1] { @02DB msg.value } 02DA 5B JUMPDEST 02DB 34 CALLVALUE 02DC 80 DUP1 02DD 15 ISZERO 02DE 61 PUSH2 0x02e6 02E1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02DB stack[0] = msg.value } // Block ends with conditional jump to 0x02e6, if !msg.value label_02E2: // Incoming jump from 0x02E1, if not !msg.value // Inputs[1] { @02E5 memory[0x00:0x00] } 02E2 60 PUSH1 0x00 02E4 80 DUP1 02E5 FD *REVERT // Stack delta = +0 // Outputs[1] { @02E5 revert(memory[0x00:0x00]); } // Block terminates label_02E6: // Incoming jump from 0x02E1, if !msg.value // Inputs[1] { @02EE msg.data.length } 02E6 5B JUMPDEST 02E7 50 POP 02E8 61 PUSH2 0x02fa 02EB 61 PUSH2 0x02f5 02EE 36 CALLDATASIZE 02EF 60 PUSH1 0x04 02F1 61 PUSH2 0x22d2 02F4 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02E8 stack[-1] = 0x02fa // @02EB stack[0] = 0x02f5 // @02EE stack[1] = msg.data.length // @02EF stack[2] = 0x04 // } // Block ends with call to 0x22d2, returns to 0x02F5 label_02F5: // Incoming return from call to 0x22D2 at 0x02F4 02F5 5B JUMPDEST 02F6 61 PUSH2 0x083a 02F9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x083a label_02FA: // Incoming return from call to 0x0BA8 at 0x0473 // Incoming return from call to 0x048F at 0x048E // Incoming return from call to 0x116E at 0x0669 // Incoming return from call to 0x05C7 at 0x05C6 // Incoming return from call to 0x02F5 at 0x02F4 // Incoming return from call to 0x0A16 at 0x039C // Incoming return from call to 0x063A at 0x0639 // Incoming return from call to 0x051C at 0x051B // Incoming return from call to 0x0572 at 0x0571 // Incoming return from call to 0x0A75 at 0x03B1 // Incoming return from call to 0x0C1C at 0x04A8 // Incoming return from call to 0x1205 at 0x06DC // Incoming return from call to 0x0B6E at 0x045E // Incoming return from call to 0x04E7 at 0x04E6 // Incoming return from call to 0x12DF at 0x0711 02FA 5B JUMPDEST 02FB 00 *STOP // Stack delta = +0 // Outputs[1] { @02FB stop(); } // Block terminates label_02FC: // Incoming jump from 0x0245, if 0x0ff8e323 == stack[-1] // Inputs[1] { @02FD msg.value } 02FC 5B JUMPDEST 02FD 34 CALLVALUE 02FE 80 DUP1 02FF 15 ISZERO 0300 61 PUSH2 0x0308 0303 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02FD stack[0] = msg.value } // Block ends with conditional jump to 0x0308, if !msg.value label_0304: // Incoming jump from 0x0303, if not !msg.value // Inputs[1] { @0307 memory[0x00:0x00] } 0304 60 PUSH1 0x00 0306 80 DUP1 0307 FD *REVERT // Stack delta = +0 // Outputs[1] { @0307 revert(memory[0x00:0x00]); } // Block terminates label_0308: // Incoming jump from 0x0303, if !msg.value // Inputs[1] { @0310 msg.data.length } 0308 5B JUMPDEST 0309 50 POP 030A 61 PUSH2 0x02fa 030D 61 PUSH2 0x0317 0310 36 CALLDATASIZE 0311 60 PUSH1 0x04 0313 61 PUSH2 0x22d2 0316 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @030A stack[-1] = 0x02fa // @030D stack[0] = 0x0317 // @0310 stack[1] = msg.data.length // @0311 stack[2] = 0x04 // } // Block ends with call to 0x22d2, returns to 0x0317 label_0317: // Incoming return from call to 0x22D2 at 0x0316 0317 5B JUMPDEST 0318 61 PUSH2 0x08c8 031B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08c8 label_031C: // Incoming jump from 0x01DD, if 0x18160ddd == stack[-1] // Inputs[1] { @031D msg.value } 031C 5B JUMPDEST 031D 34 CALLVALUE 031E 80 DUP1 031F 15 ISZERO 0320 61 PUSH2 0x0328 0323 57 *JUMPI // Stack delta = +1 // Outputs[1] { @031D stack[0] = msg.value } // Block ends with conditional jump to 0x0328, if !msg.value label_0324: // Incoming jump from 0x0323, if not !msg.value // Inputs[1] { @0327 memory[0x00:0x00] } 0324 60 PUSH1 0x00 0326 80 DUP1 0327 FD *REVERT // Stack delta = +0 // Outputs[1] { @0327 revert(memory[0x00:0x00]); } // Block terminates label_0328: // Incoming jump from 0x0323, if !msg.value // Inputs[2] // { // @032C storage[0x01] // @032F storage[0x00] // } 0328 5B JUMPDEST 0329 50 POP 032A 60 PUSH1 0x01 032C 54 SLOAD 032D 60 PUSH1 0x00 032F 54 SLOAD 0330 03 SUB // Stack delta = +0 // Outputs[1] { @0330 stack[-1] = storage[0x00] - storage[0x01] } // Block continues label_0331: // Incoming jump from 0x0654 // Incoming jump from 0x0330 // Incoming jump from 0x0556 // Incoming jump from 0x0374 // Incoming return from call to 0x0445 at 0x0444 // Inputs[2] // { // @0334 memory[0x40:0x60] // @0335 stack[-1] // } 0331 5B JUMPDEST 0332 60 PUSH1 0x40 0334 51 MLOAD 0335 90 SWAP1 0336 81 DUP2 0337 52 MSTORE 0338 60 PUSH1 0x20 033A 01 ADD 033B 61 PUSH2 0x0277 033E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0337 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @033A stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0277 label_033F: // Incoming jump from 0x01E8, if 0x23b872dd == stack[-1] // Inputs[1] { @0340 msg.value } 033F 5B JUMPDEST 0340 34 CALLVALUE 0341 80 DUP1 0342 15 ISZERO 0343 61 PUSH2 0x034b 0346 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0340 stack[0] = msg.value } // Block ends with conditional jump to 0x034b, if !msg.value label_0347: // Incoming jump from 0x0346, if not !msg.value // Inputs[1] { @034A memory[0x00:0x00] } 0347 60 PUSH1 0x00 0349 80 DUP1 034A FD *REVERT // Stack delta = +0 // Outputs[1] { @034A revert(memory[0x00:0x00]); } // Block terminates label_034B: // Incoming jump from 0x0346, if !msg.value // Inputs[1] { @0353 msg.data.length } 034B 5B JUMPDEST 034C 50 POP 034D 61 PUSH2 0x02fa 0350 61 PUSH2 0x035a 0353 36 CALLDATASIZE 0354 60 PUSH1 0x04 0356 61 PUSH2 0x21e4 0359 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @034D stack[-1] = 0x02fa // @0350 stack[0] = 0x035a // @0353 stack[1] = msg.data.length // @0354 stack[2] = 0x04 // } // Block ends with call to 0x21e4, returns to 0x035A label_035A: // Incoming return from call to 0x21E4 at 0x0359 035A 5B JUMPDEST 035B 61 PUSH2 0x090f 035E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x090f label_035F: // Incoming jump from 0x01F3, if 0x2402ca23 == stack[-1] // Inputs[1] { @0360 msg.value } 035F 5B JUMPDEST 0360 34 CALLVALUE 0361 80 DUP1 0362 15 ISZERO 0363 61 PUSH2 0x036b 0366 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0360 stack[0] = msg.value } // Block ends with conditional jump to 0x036b, if !msg.value label_0367: // Incoming jump from 0x0366, if not !msg.value // Inputs[1] { @036A memory[0x00:0x00] } 0367 60 PUSH1 0x00 0369 80 DUP1 036A FD *REVERT // Stack delta = +0 // Outputs[1] { @036A revert(memory[0x00:0x00]); } // Block terminates label_036B: // Incoming jump from 0x0366, if !msg.value // Inputs[1] { @0372 storage[0x0f] } 036B 5B JUMPDEST 036C 50 POP 036D 61 PUSH2 0x0331 0370 60 PUSH1 0x0f 0372 54 SLOAD 0373 81 DUP2 0374 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @036D stack[-1] = 0x0331 // @0372 stack[0] = storage[0x0f] // } // Block ends with unconditional jump to 0x0331 label_0375: // Incoming jump from 0x01FE, if 0x2db11544 == stack[-1] // Inputs[1] { @037C msg.data.length } 0375 5B JUMPDEST 0376 61 PUSH2 0x02fa 0379 61 PUSH2 0x0383 037C 36 CALLDATASIZE 037D 60 PUSH1 0x04 037F 61 PUSH2 0x22fb 0382 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0376 stack[0] = 0x02fa // @0379 stack[1] = 0x0383 // @037C stack[2] = msg.data.length // @037D stack[3] = 0x04 // } // Block ends with call to 0x22fb, returns to 0x0383 label_0383: // Incoming return from call to 0x22FB at 0x0382 0383 5B JUMPDEST 0384 61 PUSH2 0x091a 0387 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x091a label_0388: // Incoming jump from 0x0209, if 0x3ccfd60b == stack[-1] // Inputs[1] { @0389 msg.value } 0388 5B JUMPDEST 0389 34 CALLVALUE 038A 80 DUP1 038B 15 ISZERO 038C 61 PUSH2 0x0394 038F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0389 stack[0] = msg.value } // Block ends with conditional jump to 0x0394, if !msg.value label_0390: // Incoming jump from 0x038F, if not !msg.value // Inputs[1] { @0393 memory[0x00:0x00] } 0390 60 PUSH1 0x00 0392 80 DUP1 0393 FD *REVERT // Stack delta = +0 // Outputs[1] { @0393 revert(memory[0x00:0x00]); } // Block terminates label_0394: // Incoming jump from 0x038F, if !msg.value 0394 5B JUMPDEST 0395 50 POP 0396 61 PUSH2 0x02fa 0399 61 PUSH2 0x0a16 039C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0396 stack[-1] = 0x02fa } // Block ends with call to 0x0a16, returns to 0x02FA label_039D: // Incoming jump from 0x0196, if 0x3f4ba83a == stack[-1] // Inputs[1] { @039E msg.value } 039D 5B JUMPDEST 039E 34 CALLVALUE 039F 80 DUP1 03A0 15 ISZERO 03A1 61 PUSH2 0x03a9 03A4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @039E stack[0] = msg.value } // Block ends with conditional jump to 0x03a9, if !msg.value label_03A5: // Incoming jump from 0x03A4, if not !msg.value // Inputs[1] { @03A8 memory[0x00:0x00] } 03A5 60 PUSH1 0x00 03A7 80 DUP1 03A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @03A8 revert(memory[0x00:0x00]); } // Block terminates label_03A9: // Incoming jump from 0x03A4, if !msg.value 03A9 5B JUMPDEST 03AA 50 POP 03AB 61 PUSH2 0x02fa 03AE 61 PUSH2 0x0a75 03B1 56 *JUMP // Stack delta = +0 // Outputs[1] { @03AB stack[-1] = 0x02fa } // Block ends with call to 0x0a75, returns to 0x02FA label_03B2: // Incoming jump from 0x01A1, if 0x42842e0e == stack[-1] // Inputs[1] { @03B3 msg.value } 03B2 5B JUMPDEST 03B3 34 CALLVALUE 03B4 80 DUP1 03B5 15 ISZERO 03B6 61 PUSH2 0x03be 03B9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03B3 stack[0] = msg.value } // Block ends with conditional jump to 0x03be, if !msg.value label_03BA: // Incoming jump from 0x03B9, if not !msg.value // Inputs[1] { @03BD memory[0x00:0x00] } 03BA 60 PUSH1 0x00 03BC 80 DUP1 03BD FD *REVERT // Stack delta = +0 // Outputs[1] { @03BD revert(memory[0x00:0x00]); } // Block terminates label_03BE: // Incoming jump from 0x03B9, if !msg.value // Inputs[1] { @03C6 msg.data.length } 03BE 5B JUMPDEST 03BF 50 POP 03C0 61 PUSH2 0x02fa 03C3 61 PUSH2 0x03cd 03C6 36 CALLDATASIZE 03C7 60 PUSH1 0x04 03C9 61 PUSH2 0x21e4 03CC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03C0 stack[-1] = 0x02fa // @03C3 stack[0] = 0x03cd // @03C6 stack[1] = msg.data.length // @03C7 stack[2] = 0x04 // } // Block ends with call to 0x21e4, returns to 0x03CD label_03CD: // Incoming return from call to 0x21E4 at 0x03CC 03CD 5B JUMPDEST 03CE 61 PUSH2 0x0aaf 03D1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0aaf label_03D2: // Incoming jump from 0x01AC, if 0x55f804b3 == stack[-1] // Inputs[1] { @03D3 msg.value } 03D2 5B JUMPDEST 03D3 34 CALLVALUE 03D4 80 DUP1 03D5 15 ISZERO 03D6 61 PUSH2 0x03de 03D9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03D3 stack[0] = msg.value } // Block ends with conditional jump to 0x03de, if !msg.value label_03DA: // Incoming jump from 0x03D9, if not !msg.value // Inputs[1] { @03DD memory[0x00:0x00] } 03DA 60 PUSH1 0x00 03DC 80 DUP1 03DD FD *REVERT // Stack delta = +0 // Outputs[1] { @03DD revert(memory[0x00:0x00]); } // Block terminates label_03DE: // Incoming jump from 0x03D9, if !msg.value // Inputs[1] { @03E6 msg.data.length } 03DE 5B JUMPDEST 03DF 50 POP 03E0 61 PUSH2 0x02fa 03E3 61 PUSH2 0x03ed 03E6 36 CALLDATASIZE 03E7 60 PUSH1 0x04 03E9 61 PUSH2 0x234b 03EC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03E0 stack[-1] = 0x02fa // @03E3 stack[0] = 0x03ed // @03E6 stack[1] = msg.data.length // @03E7 stack[2] = 0x04 // } // Block ends with call to 0x234b, returns to 0x03ED label_03ED: // Incoming return from call to 0x234B at 0x03EC 03ED 5B JUMPDEST 03EE 61 PUSH2 0x0aca 03F1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0aca label_03F2: // Incoming jump from 0x01B7, if 0x5c975abb == stack[-1] // Inputs[1] { @03F3 msg.value } 03F2 5B JUMPDEST 03F3 34 CALLVALUE 03F4 80 DUP1 03F5 15 ISZERO 03F6 61 PUSH2 0x03fe 03F9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03F3 stack[0] = msg.value } // Block ends with conditional jump to 0x03fe, if !msg.value label_03FA: // Incoming jump from 0x03F9, if not !msg.value // Inputs[1] { @03FD memory[0x00:0x00] } 03FA 60 PUSH1 0x00 03FC 80 DUP1 03FD FD *REVERT // Stack delta = +0 // Outputs[1] { @03FD revert(memory[0x00:0x00]); } // Block terminates label_03FE: // Incoming jump from 0x03F9, if !msg.value // Inputs[1] { @0402 storage[0x08] } 03FE 5B JUMPDEST 03FF 50 POP 0400 60 PUSH1 0x08 0402 54 SLOAD 0403 60 PUSH1 0xff 0405 16 AND 0406 61 PUSH2 0x026b 0409 56 *JUMP // Stack delta = +0 // Outputs[1] { @0405 stack[-1] = 0xff & storage[0x08] } // Block ends with unconditional jump to 0x026b label_040A: // Incoming jump from 0x01C2, if 0x6352211e == stack[-1] // Inputs[1] { @040B msg.value } 040A 5B JUMPDEST 040B 34 CALLVALUE 040C 80 DUP1 040D 15 ISZERO 040E 61 PUSH2 0x0416 0411 57 *JUMPI // Stack delta = +1 // Outputs[1] { @040B stack[0] = msg.value } // Block ends with conditional jump to 0x0416, if !msg.value label_0412: // Incoming jump from 0x0411, if not !msg.value // Inputs[1] { @0415 memory[0x00:0x00] } 0412 60 PUSH1 0x00 0414 80 DUP1 0415 FD *REVERT // Stack delta = +0 // Outputs[1] { @0415 revert(memory[0x00:0x00]); } // Block terminates label_0416: // Incoming jump from 0x0411, if !msg.value // Inputs[1] { @041E msg.data.length } 0416 5B JUMPDEST 0417 50 POP 0418 61 PUSH2 0x02c2 041B 61 PUSH2 0x0425 041E 36 CALLDATASIZE 041F 60 PUSH1 0x04 0421 61 PUSH2 0x22fb 0424 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0418 stack[-1] = 0x02c2 // @041B stack[0] = 0x0425 // @041E stack[1] = msg.data.length // @041F stack[2] = 0x04 // } // Block ends with call to 0x22fb, returns to 0x0425 label_0425: // Incoming return from call to 0x22FB at 0x0424 0425 5B JUMPDEST 0426 61 PUSH2 0x0b0d 0429 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b0d label_042A: // Incoming jump from 0x015A, if 0x70a08231 == stack[-1] // Inputs[1] { @042B msg.value } 042A 5B JUMPDEST 042B 34 CALLVALUE 042C 80 DUP1 042D 15 ISZERO 042E 61 PUSH2 0x0436 0431 57 *JUMPI // Stack delta = +1 // Outputs[1] { @042B stack[0] = msg.value } // Block ends with conditional jump to 0x0436, if !msg.value label_0432: // Incoming jump from 0x0431, if not !msg.value // Inputs[1] { @0435 memory[0x00:0x00] } 0432 60 PUSH1 0x00 0434 80 DUP1 0435 FD *REVERT // Stack delta = +0 // Outputs[1] { @0435 revert(memory[0x00:0x00]); } // Block terminates label_0436: // Incoming jump from 0x0431, if !msg.value // Inputs[1] { @043E msg.data.length } 0436 5B JUMPDEST 0437 50 POP 0438 61 PUSH2 0x0331 043B 61 PUSH2 0x0445 043E 36 CALLDATASIZE 043F 60 PUSH1 0x04 0441 61 PUSH2 0x2198 0444 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0438 stack[-1] = 0x0331 // @043B stack[0] = 0x0445 // @043E stack[1] = msg.data.length // @043F stack[2] = 0x04 // } // Block ends with call to 0x2198, returns to 0x0445 label_0445: // Incoming return from call to 0x2198 at 0x0444 0445 5B JUMPDEST 0446 61 PUSH2 0x0b1f 0449 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b1f label_044A: // Incoming jump from 0x0165, if 0x715018a6 == stack[-1] // Inputs[1] { @044B msg.value } 044A 5B JUMPDEST 044B 34 CALLVALUE 044C 80 DUP1 044D 15 ISZERO 044E 61 PUSH2 0x0456 0451 57 *JUMPI // Stack delta = +1 // Outputs[1] { @044B stack[0] = msg.value } // Block ends with conditional jump to 0x0456, if !msg.value label_0452: // Incoming jump from 0x0451, if not !msg.value // Inputs[1] { @0455 memory[0x00:0x00] } 0452 60 PUSH1 0x00 0454 80 DUP1 0455 FD *REVERT // Stack delta = +0 // Outputs[1] { @0455 revert(memory[0x00:0x00]); } // Block terminates label_0456: // Incoming jump from 0x0451, if !msg.value 0456 5B JUMPDEST 0457 50 POP 0458 61 PUSH2 0x02fa 045B 61 PUSH2 0x0b6e 045E 56 *JUMP // Stack delta = +0 // Outputs[1] { @0458 stack[-1] = 0x02fa } // Block ends with call to 0x0b6e, returns to 0x02FA label_045F: // Incoming jump from 0x0170, if 0x76c64c62 == stack[-1] // Inputs[1] { @0460 msg.value } 045F 5B JUMPDEST 0460 34 CALLVALUE 0461 80 DUP1 0462 15 ISZERO 0463 61 PUSH2 0x046b 0466 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0460 stack[0] = msg.value } // Block ends with conditional jump to 0x046b, if !msg.value label_0467: // Incoming jump from 0x0466, if not !msg.value // Inputs[1] { @046A memory[0x00:0x00] } 0467 60 PUSH1 0x00 0469 80 DUP1 046A FD *REVERT // Stack delta = +0 // Outputs[1] { @046A revert(memory[0x00:0x00]); } // Block terminates label_046B: // Incoming jump from 0x0466, if !msg.value 046B 5B JUMPDEST 046C 50 POP 046D 61 PUSH2 0x02fa 0470 61 PUSH2 0x0ba8 0473 56 *JUMP // Stack delta = +0 // Outputs[1] { @046D stack[-1] = 0x02fa } // Block ends with call to 0x0ba8, returns to 0x02FA label_0474: // Incoming jump from 0x017B, if 0x7cb64759 == stack[-1] // Inputs[1] { @0475 msg.value } 0474 5B JUMPDEST 0475 34 CALLVALUE 0476 80 DUP1 0477 15 ISZERO 0478 61 PUSH2 0x0480 047B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0475 stack[0] = msg.value } // Block ends with conditional jump to 0x0480, if !msg.value label_047C: // Incoming jump from 0x047B, if not !msg.value // Inputs[1] { @047F memory[0x00:0x00] } 047C 60 PUSH1 0x00 047E 80 DUP1 047F FD *REVERT // Stack delta = +0 // Outputs[1] { @047F revert(memory[0x00:0x00]); } // Block terminates label_0480: // Incoming jump from 0x047B, if !msg.value // Inputs[1] { @0488 msg.data.length } 0480 5B JUMPDEST 0481 50 POP 0482 61 PUSH2 0x02fa 0485 61 PUSH2 0x048f 0488 36 CALLDATASIZE 0489 60 PUSH1 0x04 048B 61 PUSH2 0x22fb 048E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0482 stack[-1] = 0x02fa // @0485 stack[0] = 0x048f // @0488 stack[1] = msg.data.length // @0489 stack[2] = 0x04 // } // Block ends with call to 0x22fb, returns to 0x048F label_048F: // Incoming return from call to 0x22FB at 0x048E 048F 5B JUMPDEST 0490 61 PUSH2 0x0be7 0493 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0be7 label_0494: // Incoming jump from 0x0186, if 0x8456cb59 == stack[-1] // Inputs[1] { @0495 msg.value } 0494 5B JUMPDEST 0495 34 CALLVALUE 0496 80 DUP1 0497 15 ISZERO 0498 61 PUSH2 0x04a0 049B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0495 stack[0] = msg.value } // Block ends with conditional jump to 0x04a0, if !msg.value label_049C: // Incoming jump from 0x049B, if not !msg.value // Inputs[1] { @049F memory[0x00:0x00] } 049C 60 PUSH1 0x00 049E 80 DUP1 049F FD *REVERT // Stack delta = +0 // Outputs[1] { @049F revert(memory[0x00:0x00]); } // Block terminates label_04A0: // Incoming jump from 0x049B, if !msg.value 04A0 5B JUMPDEST 04A1 50 POP 04A2 61 PUSH2 0x02fa 04A5 61 PUSH2 0x0c1c 04A8 56 *JUMP // Stack delta = +0 // Outputs[1] { @04A2 stack[-1] = 0x02fa } // Block ends with call to 0x0c1c, returns to 0x02FA label_04A9: // Incoming jump from 0x0108, if 0x8da5cb5b == stack[-1] // Inputs[1] { @04AA msg.value } 04A9 5B JUMPDEST 04AA 34 CALLVALUE 04AB 80 DUP1 04AC 15 ISZERO 04AD 61 PUSH2 0x04b5 04B0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04AA stack[0] = msg.value } // Block ends with conditional jump to 0x04b5, if !msg.value label_04B1: // Incoming jump from 0x04B0, if not !msg.value // Inputs[1] { @04B4 memory[0x00:0x00] } 04B1 60 PUSH1 0x00 04B3 80 DUP1 04B4 FD *REVERT // Stack delta = +0 // Outputs[1] { @04B4 revert(memory[0x00:0x00]); } // Block terminates label_04B5: // Incoming jump from 0x04B0, if !msg.value // Inputs[1] { @04B9 storage[0x08] } 04B5 5B JUMPDEST 04B6 50 POP 04B7 60 PUSH1 0x08 04B9 54 SLOAD 04BA 61 PUSH2 0x0100 04BD 90 SWAP1 04BE 04 DIV 04BF 60 PUSH1 0x01 04C1 60 PUSH1 0x01 04C3 60 PUSH1 0xa0 04C5 1B SHL 04C6 03 SUB 04C7 16 AND 04C8 61 PUSH2 0x02c2 04CB 56 *JUMP // Stack delta = +0 // Outputs[1] { @04C7 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x08] / 0x0100 } // Block ends with unconditional jump to 0x02c2 label_04CC: // Incoming jump from 0x0113, if 0x91b7f5ed == stack[-1] // Inputs[1] { @04CD msg.value } 04CC 5B JUMPDEST 04CD 34 CALLVALUE 04CE 80 DUP1 04CF 15 ISZERO 04D0 61 PUSH2 0x04d8 04D3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04CD stack[0] = msg.value } // Block ends with conditional jump to 0x04d8, if !msg.value label_04D4: // Incoming jump from 0x04D3, if not !msg.value // Inputs[1] { @04D7 memory[0x00:0x00] } 04D4 60 PUSH1 0x00 04D6 80 DUP1 04D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D7 revert(memory[0x00:0x00]); } // Block terminates label_04D8: // Incoming jump from 0x04D3, if !msg.value // Inputs[1] { @04E0 msg.data.length } 04D8 5B JUMPDEST 04D9 50 POP 04DA 61 PUSH2 0x02fa 04DD 61 PUSH2 0x04e7 04E0 36 CALLDATASIZE 04E1 60 PUSH1 0x04 04E3 61 PUSH2 0x22fb 04E6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04DA stack[-1] = 0x02fa // @04DD stack[0] = 0x04e7 // @04E0 stack[1] = msg.data.length // @04E1 stack[2] = 0x04 // } // Block ends with call to 0x22fb, returns to 0x04E7 label_04E7: // Incoming return from call to 0x22FB at 0x04E6 04E7 5B JUMPDEST 04E8 61 PUSH2 0x0c54 04EB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c54 label_04EC: // Incoming jump from 0x011E, if 0x95d89b41 == stack[-1] // Inputs[1] { @04ED msg.value } 04EC 5B JUMPDEST 04ED 34 CALLVALUE 04EE 80 DUP1 04EF 15 ISZERO 04F0 61 PUSH2 0x04f8 04F3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04ED stack[0] = msg.value } // Block ends with conditional jump to 0x04f8, if !msg.value label_04F4: // Incoming jump from 0x04F3, if not !msg.value // Inputs[1] { @04F7 memory[0x00:0x00] } 04F4 60 PUSH1 0x00 04F6 80 DUP1 04F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F7 revert(memory[0x00:0x00]); } // Block terminates label_04F8: // Incoming jump from 0x04F3, if !msg.value 04F8 5B JUMPDEST 04F9 50 POP 04FA 61 PUSH2 0x0295 04FD 61 PUSH2 0x0c89 0500 56 *JUMP // Stack delta = +0 // Outputs[1] { @04FA stack[-1] = 0x0295 } // Block ends with call to 0x0c89, returns to 0x0295 label_0501: // Incoming jump from 0x0129, if 0x9851b815 == stack[-1] // Inputs[1] { @0502 msg.value } 0501 5B JUMPDEST 0502 34 CALLVALUE 0503 80 DUP1 0504 15 ISZERO 0505 61 PUSH2 0x050d 0508 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0502 stack[0] = msg.value } // Block ends with conditional jump to 0x050d, if !msg.value label_0509: // Incoming jump from 0x0508, if not !msg.value // Inputs[1] { @050C memory[0x00:0x00] } 0509 60 PUSH1 0x00 050B 80 DUP1 050C FD *REVERT // Stack delta = +0 // Outputs[1] { @050C revert(memory[0x00:0x00]); } // Block terminates label_050D: // Incoming jump from 0x0508, if !msg.value // Inputs[1] { @0515 msg.data.length } 050D 5B JUMPDEST 050E 50 POP 050F 61 PUSH2 0x02fa 0512 61 PUSH2 0x051c 0515 36 CALLDATASIZE 0516 60 PUSH1 0x04 0518 61 PUSH2 0x22fb 051B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @050F stack[-1] = 0x02fa // @0512 stack[0] = 0x051c // @0515 stack[1] = msg.data.length // @0516 stack[2] = 0x04 // } // Block ends with call to 0x22fb, returns to 0x051C label_051C: // Incoming return from call to 0x22FB at 0x051B 051C 5B JUMPDEST 051D 61 PUSH2 0x0c98 0520 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c98 label_0521: // Incoming jump from 0x0134, if 0x9afd313f == stack[-1] // Inputs[1] { @0522 msg.value } 0521 5B JUMPDEST 0522 34 CALLVALUE 0523 80 DUP1 0524 15 ISZERO 0525 61 PUSH2 0x052d 0528 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0522 stack[0] = msg.value } // Block ends with conditional jump to 0x052d, if !msg.value label_0529: // Incoming jump from 0x0528, if not !msg.value // Inputs[1] { @052C memory[0x00:0x00] } 0529 60 PUSH1 0x00 052B 80 DUP1 052C FD *REVERT // Stack delta = +0 // Outputs[1] { @052C revert(memory[0x00:0x00]); } // Block terminates label_052D: // Incoming jump from 0x0528, if !msg.value // Inputs[1] { @0535 msg.data.length } 052D 5B JUMPDEST 052E 50 POP 052F 61 PUSH2 0x02fa 0532 61 PUSH2 0x053c 0535 36 CALLDATASIZE 0536 60 PUSH1 0x04 0538 61 PUSH2 0x2198 053B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @052F stack[-1] = 0x02fa // @0532 stack[0] = 0x053c // @0535 stack[1] = msg.data.length // @0536 stack[2] = 0x04 // } // Block ends with call to 0x2198, returns to 0x053C label_053C: // Incoming return from call to 0x2198 at 0x053B 053C 5B JUMPDEST 053D 61 PUSH2 0x0d18 0540 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d18 label_0541: // Incoming jump from 0x00CC, if 0xa035b1fe == stack[-1] // Inputs[1] { @0542 msg.value } 0541 5B JUMPDEST 0542 34 CALLVALUE 0543 80 DUP1 0544 15 ISZERO 0545 61 PUSH2 0x054d 0548 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0542 stack[0] = msg.value } // Block ends with conditional jump to 0x054d, if !msg.value label_0549: // Incoming jump from 0x0548, if not !msg.value // Inputs[1] { @054C memory[0x00:0x00] } 0549 60 PUSH1 0x00 054B 80 DUP1 054C FD *REVERT // Stack delta = +0 // Outputs[1] { @054C revert(memory[0x00:0x00]); } // Block terminates label_054D: // Incoming jump from 0x0548, if !msg.value // Inputs[1] { @0554 storage[0x0c] } 054D 5B JUMPDEST 054E 50 POP 054F 61 PUSH2 0x0331 0552 60 PUSH1 0x0c 0554 54 SLOAD 0555 81 DUP2 0556 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @054F stack[-1] = 0x0331 // @0554 stack[0] = storage[0x0c] // } // Block ends with unconditional jump to 0x0331 label_0557: // Incoming jump from 0x00D7, if 0xa22cb465 == stack[-1] // Inputs[1] { @0558 msg.value } 0557 5B JUMPDEST 0558 34 CALLVALUE 0559 80 DUP1 055A 15 ISZERO 055B 61 PUSH2 0x0563 055E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0558 stack[0] = msg.value } // Block ends with conditional jump to 0x0563, if !msg.value label_055F: // Incoming jump from 0x055E, if not !msg.value // Inputs[1] { @0562 memory[0x00:0x00] } 055F 60 PUSH1 0x00 0561 80 DUP1 0562 FD *REVERT // Stack delta = +0 // Outputs[1] { @0562 revert(memory[0x00:0x00]); } // Block terminates label_0563: // Incoming jump from 0x055E, if !msg.value // Inputs[1] { @056B msg.data.length } 0563 5B JUMPDEST 0564 50 POP 0565 61 PUSH2 0x02fa 0568 61 PUSH2 0x0572 056B 36 CALLDATASIZE 056C 60 PUSH1 0x04 056E 61 PUSH2 0x2298 0571 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0565 stack[-1] = 0x02fa // @0568 stack[0] = 0x0572 // @056B stack[1] = msg.data.length // @056C stack[2] = 0x04 // } // Block ends with call to 0x2298, returns to 0x0572 label_0572: // Incoming return from call to 0x2298 at 0x0571 0572 5B JUMPDEST 0573 61 PUSH2 0x0d51 0576 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d51 label_0577: // Incoming jump from 0x00E2, if 0xa62771d6 == stack[-1] // Inputs[1] { @0578 msg.value } 0577 5B JUMPDEST 0578 34 CALLVALUE 0579 80 DUP1 057A 15 ISZERO 057B 61 PUSH2 0x0583 057E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0578 stack[0] = msg.value } // Block ends with conditional jump to 0x0583, if !msg.value label_057F: // Incoming jump from 0x057E, if not !msg.value // Inputs[1] { @0582 memory[0x00:0x00] } 057F 60 PUSH1 0x00 0581 80 DUP1 0582 FD *REVERT // Stack delta = +0 // Outputs[1] { @0582 revert(memory[0x00:0x00]); } // Block terminates label_0583: // Incoming jump from 0x057E, if !msg.value 0583 5B JUMPDEST 0584 50 POP 0585 61 PUSH2 0x0295 0588 61 PUSH2 0x0de7 058B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0585 stack[-1] = 0x0295 } // Block ends with call to 0x0de7, returns to 0x0295 label_058C: // Incoming jump from 0x00ED, if 0xb84c8246 == stack[-1] // Inputs[1] { @058D msg.value } 058C 5B JUMPDEST 058D 34 CALLVALUE 058E 80 DUP1 058F 15 ISZERO 0590 61 PUSH2 0x0598 0593 57 *JUMPI // Stack delta = +1 // Outputs[1] { @058D stack[0] = msg.value } // Block ends with conditional jump to 0x0598, if !msg.value label_0594: // Incoming jump from 0x0593, if not !msg.value // Inputs[1] { @0597 memory[0x00:0x00] } 0594 60 PUSH1 0x00 0596 80 DUP1 0597 FD *REVERT // Stack delta = +0 // Outputs[1] { @0597 revert(memory[0x00:0x00]); } // Block terminates label_0598: // Incoming jump from 0x0593, if !msg.value // Inputs[1] { @05A0 msg.data.length } 0598 5B JUMPDEST 0599 50 POP 059A 61 PUSH2 0x02fa 059D 61 PUSH2 0x05a7 05A0 36 CALLDATASIZE 05A1 60 PUSH1 0x04 05A3 61 PUSH2 0x234b 05A6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @059A stack[-1] = 0x02fa // @059D stack[0] = 0x05a7 // @05A0 stack[1] = msg.data.length // @05A1 stack[2] = 0x04 // } // Block ends with call to 0x234b, returns to 0x05A7 label_05A7: // Incoming return from call to 0x234B at 0x05A6 05A7 5B JUMPDEST 05A8 61 PUSH2 0x0e03 05AB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e03 label_05AC: // Incoming jump from 0x00F8, if 0xb88d4fde == stack[-1] // Inputs[1] { @05AD msg.value } 05AC 5B JUMPDEST 05AD 34 CALLVALUE 05AE 80 DUP1 05AF 15 ISZERO 05B0 61 PUSH2 0x05b8 05B3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05AD stack[0] = msg.value } // Block ends with conditional jump to 0x05b8, if !msg.value label_05B4: // Incoming jump from 0x05B3, if not !msg.value // Inputs[1] { @05B7 memory[0x00:0x00] } 05B4 60 PUSH1 0x00 05B6 80 DUP1 05B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @05B7 revert(memory[0x00:0x00]); } // Block terminates label_05B8: // Incoming jump from 0x05B3, if !msg.value // Inputs[1] { @05C0 msg.data.length } 05B8 5B JUMPDEST 05B9 50 POP 05BA 61 PUSH2 0x02fa 05BD 61 PUSH2 0x05c7 05C0 36 CALLDATASIZE 05C1 60 PUSH1 0x04 05C3 61 PUSH2 0x221f 05C6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05BA stack[-1] = 0x02fa // @05BD stack[0] = 0x05c7 // @05C0 stack[1] = msg.data.length // @05C1 stack[2] = 0x04 // } // Block ends with call to 0x221f, returns to 0x05C7 label_05C7: // Incoming return from call to 0x221F at 0x05C6 05C7 5B JUMPDEST 05C8 61 PUSH2 0x0e46 05CB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e46 label_05CC: // Incoming jump from 0x0085, if 0xc47f0027 == stack[-1] // Inputs[1] { @05CD msg.value } 05CC 5B JUMPDEST 05CD 34 CALLVALUE 05CE 80 DUP1 05CF 15 ISZERO 05D0 61 PUSH2 0x05d8 05D3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05CD stack[0] = msg.value } // Block ends with conditional jump to 0x05d8, if !msg.value label_05D4: // Incoming jump from 0x05D3, if not !msg.value // Inputs[1] { @05D7 memory[0x00:0x00] } 05D4 60 PUSH1 0x00 05D6 80 DUP1 05D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @05D7 revert(memory[0x00:0x00]); } // Block terminates label_05D8: // Incoming jump from 0x05D3, if !msg.value // Inputs[1] { @05E0 msg.data.length } 05D8 5B JUMPDEST 05D9 50 POP 05DA 61 PUSH2 0x02fa 05DD 61 PUSH2 0x05e7 05E0 36 CALLDATASIZE 05E1 60 PUSH1 0x04 05E3 61 PUSH2 0x234b 05E6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05DA stack[-1] = 0x02fa // @05DD stack[0] = 0x05e7 // @05E0 stack[1] = msg.data.length // @05E1 stack[2] = 0x04 // } // Block ends with call to 0x234b, returns to 0x05E7 label_05E7: // Incoming return from call to 0x234B at 0x05E6 05E7 5B JUMPDEST 05E8 61 PUSH2 0x0e97 05EB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e97 label_05EC: // Incoming jump from 0x0090, if 0xc4be5b59 == stack[-1] // Inputs[1] { @05F3 msg.data.length } 05EC 5B JUMPDEST 05ED 61 PUSH2 0x02fa 05F0 61 PUSH2 0x05fa 05F3 36 CALLDATASIZE 05F4 60 PUSH1 0x04 05F6 61 PUSH2 0x23a9 05F9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05ED stack[0] = 0x02fa // @05F0 stack[1] = 0x05fa // @05F3 stack[2] = msg.data.length // @05F4 stack[3] = 0x04 // } // Block ends with call to 0x23a9, returns to 0x05FA label_05FA: // Incoming return from call to 0x23A9 at 0x05F9 05FA 5B JUMPDEST 05FB 61 PUSH2 0x0eda 05FE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0eda label_05FF: // Incoming jump from 0x009B, if 0xc87b56dd == stack[-1] // Inputs[1] { @0600 msg.value } 05FF 5B JUMPDEST 0600 34 CALLVALUE 0601 80 DUP1 0602 15 ISZERO 0603 61 PUSH2 0x060b 0606 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0600 stack[0] = msg.value } // Block ends with conditional jump to 0x060b, if !msg.value label_0607: // Incoming jump from 0x0606, if not !msg.value // Inputs[1] { @060A memory[0x00:0x00] } 0607 60 PUSH1 0x00 0609 80 DUP1 060A FD *REVERT // Stack delta = +0 // Outputs[1] { @060A revert(memory[0x00:0x00]); } // Block terminates label_060B: // Incoming jump from 0x0606, if !msg.value // Inputs[1] { @0613 msg.data.length } 060B 5B JUMPDEST 060C 50 POP 060D 61 PUSH2 0x0295 0610 61 PUSH2 0x061a 0613 36 CALLDATASIZE 0614 60 PUSH1 0x04 0616 61 PUSH2 0x22fb 0619 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @060D stack[-1] = 0x0295 // @0610 stack[0] = 0x061a // @0613 stack[1] = msg.data.length // @0614 stack[2] = 0x04 // } // Block ends with call to 0x22fb, returns to 0x061A label_061A: // Incoming return from call to 0x22FB at 0x0619 061A 5B JUMPDEST 061B 61 PUSH2 0x1069 061E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1069 label_061F: // Incoming jump from 0x00A6, if 0xcc46f31e == stack[-1] // Inputs[1] { @0620 msg.value } 061F 5B JUMPDEST 0620 34 CALLVALUE 0621 80 DUP1 0622 15 ISZERO 0623 61 PUSH2 0x062b 0626 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0620 stack[0] = msg.value } // Block ends with conditional jump to 0x062b, if !msg.value label_0627: // Incoming jump from 0x0626, if not !msg.value // Inputs[1] { @062A memory[0x00:0x00] } 0627 60 PUSH1 0x00 0629 80 DUP1 062A FD *REVERT // Stack delta = +0 // Outputs[1] { @062A revert(memory[0x00:0x00]); } // Block terminates label_062B: // Incoming jump from 0x0626, if !msg.value // Inputs[1] { @0633 msg.data.length } 062B 5B JUMPDEST 062C 50 POP 062D 61 PUSH2 0x02fa 0630 61 PUSH2 0x063a 0633 36 CALLDATASIZE 0634 60 PUSH1 0x04 0636 61 PUSH2 0x22fb 0639 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @062D stack[-1] = 0x02fa // @0630 stack[0] = 0x063a // @0633 stack[1] = msg.data.length // @0634 stack[2] = 0x04 // } // Block ends with call to 0x22fb, returns to 0x063A label_063A: // Incoming return from call to 0x22FB at 0x0639 063A 5B JUMPDEST 063B 61 PUSH2 0x10ee 063E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10ee label_063F: // Incoming jump from 0x00B1, if 0xd60abf78 == stack[-1] // Inputs[1] { @0640 msg.value } 063F 5B JUMPDEST 0640 34 CALLVALUE 0641 80 DUP1 0642 15 ISZERO 0643 61 PUSH2 0x064b 0646 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0640 stack[0] = msg.value } // Block ends with conditional jump to 0x064b, if !msg.value label_0647: // Incoming jump from 0x0646, if not !msg.value // Inputs[1] { @064A memory[0x00:0x00] } 0647 60 PUSH1 0x00 0649 80 DUP1 064A FD *REVERT // Stack delta = +0 // Outputs[1] { @064A revert(memory[0x00:0x00]); } // Block terminates label_064B: // Incoming jump from 0x0646, if !msg.value // Inputs[1] { @0652 storage[0x13] } 064B 5B JUMPDEST 064C 50 POP 064D 61 PUSH2 0x0331 0650 60 PUSH1 0x13 0652 54 SLOAD 0653 81 DUP2 0654 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @064D stack[-1] = 0x0331 // @0652 stack[0] = storage[0x13] // } // Block ends with unconditional jump to 0x0331 label_0655: // Incoming jump from 0x003E, if 0xdecd6e5b == stack[-1] // Inputs[1] { @0656 msg.value } 0655 5B JUMPDEST 0656 34 CALLVALUE 0657 80 DUP1 0658 15 ISZERO 0659 61 PUSH2 0x0661 065C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0656 stack[0] = msg.value } // Block ends with conditional jump to 0x0661, if !msg.value label_065D: // Incoming jump from 0x065C, if not !msg.value // Inputs[1] { @0660 memory[0x00:0x00] } 065D 60 PUSH1 0x00 065F 80 DUP1 0660 FD *REVERT // Stack delta = +0 // Outputs[1] { @0660 revert(memory[0x00:0x00]); } // Block terminates label_0661: // Incoming jump from 0x065C, if !msg.value 0661 5B JUMPDEST 0662 50 POP 0663 61 PUSH2 0x02fa 0666 61 PUSH2 0x116e 0669 56 *JUMP // Stack delta = +0 // Outputs[1] { @0663 stack[-1] = 0x02fa } // Block ends with call to 0x116e, returns to 0x02FA label_066A: // Incoming jump from 0x0049, if 0xdff13081 == stack[-1] // Inputs[1] { @066B msg.value } 066A 5B JUMPDEST 066B 34 CALLVALUE 066C 80 DUP1 066D 15 ISZERO 066E 61 PUSH2 0x0676 0671 57 *JUMPI // Stack delta = +1 // Outputs[1] { @066B stack[0] = msg.value } // Block ends with conditional jump to 0x0676, if !msg.value label_0672: // Incoming jump from 0x0671, if not !msg.value // Inputs[1] { @0675 memory[0x00:0x00] } 0672 60 PUSH1 0x00 0674 80 DUP1 0675 FD *REVERT // Stack delta = +0 // Outputs[1] { @0675 revert(memory[0x00:0x00]); } // Block terminates label_0676: // Incoming jump from 0x0671, if !msg.value 0676 5B JUMPDEST 0677 50 POP 0678 61 PUSH2 0x02fa 067B 61 PUSH2 0x11aa 067E 56 *JUMP // Stack delta = +0 // Outputs[1] { @0678 stack[-1] = 0x02fa } // Block ends with unconditional jump to 0x11aa label_067F: // Incoming jump from 0x0054, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0680 msg.value } 067F 5B JUMPDEST 0680 34 CALLVALUE 0681 80 DUP1 0682 15 ISZERO 0683 61 PUSH2 0x068b 0686 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0680 stack[0] = msg.value } // Block ends with conditional jump to 0x068b, if !msg.value label_0687: // Incoming jump from 0x0686, if not !msg.value // Inputs[1] { @068A memory[0x00:0x00] } 0687 60 PUSH1 0x00 0689 80 DUP1 068A FD *REVERT // Stack delta = +0 // Outputs[1] { @068A revert(memory[0x00:0x00]); } // Block terminates label_068B: // Incoming jump from 0x0686, if !msg.value // Inputs[1] { @0693 msg.data.length } 068B 5B JUMPDEST 068C 50 POP 068D 61 PUSH2 0x026b 0690 61 PUSH2 0x069a 0693 36 CALLDATASIZE 0694 60 PUSH1 0x04 0696 61 PUSH2 0x21b2 0699 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @068D stack[-1] = 0x026b // @0690 stack[0] = 0x069a // @0693 stack[1] = msg.data.length // @0694 stack[2] = 0x04 // } // Block ends with call to 0x21b2, returns to 0x069A label_069A: // Incoming call from 0x0897, returns to 0x0898 // Incoming call from 0x1549, returns to 0x154A // Incoming return from call to 0x21B2 at 0x0699 // Inputs[6] // { // @06A3 stack[-2] // @06B6 memory[0x00:0x40] // @06B7 stack[-1] // @06C1 memory[0x00:0x40] // @06C2 storage[keccak256(memory[0x00:0x40])] // @06C6 stack[-3] // } 069A 5B JUMPDEST 069B 60 PUSH1 0x01 069D 60 PUSH1 0x01 069F 60 PUSH1 0xa0 06A1 1B SHL 06A2 03 SUB 06A3 91 SWAP2 06A4 82 DUP3 06A5 16 AND 06A6 60 PUSH1 0x00 06A8 90 SWAP1 06A9 81 DUP2 06AA 52 MSTORE 06AB 60 PUSH1 0x07 06AD 60 PUSH1 0x20 06AF 90 SWAP1 06B0 81 DUP2 06B1 52 MSTORE 06B2 60 PUSH1 0x40 06B4 80 DUP1 06B5 83 DUP4 06B6 20 SHA3 06B7 93 SWAP4 06B8 90 SWAP1 06B9 94 SWAP5 06BA 16 AND 06BB 82 DUP3 06BC 52 MSTORE 06BD 91 SWAP2 06BE 90 SWAP1 06BF 91 SWAP2 06C0 52 MSTORE 06C1 20 SHA3 06C2 54 SLOAD 06C3 60 PUSH1 0xff 06C5 16 AND 06C6 90 SWAP1 06C7 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @06AA memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @06B1 memory[0x20:0x40] = 0x07 // @06BC memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @06C0 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @06C6 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_06C8: // Incoming jump from 0x005F, if 0xedc1fe41 == stack[-1] // Inputs[1] { @06C9 msg.value } 06C8 5B JUMPDEST 06C9 34 CALLVALUE 06CA 80 DUP1 06CB 15 ISZERO 06CC 61 PUSH2 0x06d4 06CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06C9 stack[0] = msg.value } // Block ends with conditional jump to 0x06d4, if !msg.value label_06D0: // Incoming jump from 0x06CF, if not !msg.value // Inputs[1] { @06D3 memory[0x00:0x00] } 06D0 60 PUSH1 0x00 06D2 80 DUP1 06D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @06D3 revert(memory[0x00:0x00]); } // Block terminates label_06D4: // Incoming jump from 0x06CF, if !msg.value 06D4 5B JUMPDEST 06D5 50 POP 06D6 61 PUSH2 0x02fa 06D9 61 PUSH2 0x1205 06DC 56 *JUMP // Stack delta = +0 // Outputs[1] { @06D6 stack[-1] = 0x02fa } // Block ends with call to 0x1205, returns to 0x02FA label_06DD: // Incoming jump from 0x006A, if 0xf2fde38b == stack[-1] // Inputs[1] { @06DE msg.value } 06DD 5B JUMPDEST 06DE 34 CALLVALUE 06DF 80 DUP1 06E0 15 ISZERO 06E1 61 PUSH2 0x06e9 06E4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06DE stack[0] = msg.value } // Block ends with conditional jump to 0x06e9, if !msg.value label_06E5: // Incoming jump from 0x06E4, if not !msg.value // Inputs[1] { @06E8 memory[0x00:0x00] } 06E5 60 PUSH1 0x00 06E7 80 DUP1 06E8 FD *REVERT // Stack delta = +0 // Outputs[1] { @06E8 revert(memory[0x00:0x00]); } // Block terminates label_06E9: // Incoming jump from 0x06E4, if !msg.value // Inputs[1] { @06F1 msg.data.length } 06E9 5B JUMPDEST 06EA 50 POP 06EB 61 PUSH2 0x02fa 06EE 61 PUSH2 0x06f8 06F1 36 CALLDATASIZE 06F2 60 PUSH1 0x04 06F4 61 PUSH2 0x2198 06F7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06EB stack[-1] = 0x02fa // @06EE stack[0] = 0x06f8 // @06F1 stack[1] = msg.data.length // @06F2 stack[2] = 0x04 // } // Block ends with call to 0x2198, returns to 0x06F8 label_06F8: // Incoming return from call to 0x2198 at 0x06F7 06F8 5B JUMPDEST 06F9 61 PUSH2 0x1241 06FC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1241 label_06FD: // Incoming jump from 0x0075, if 0xf47d224b == stack[-1] // Inputs[1] { @06FE msg.value } 06FD 5B JUMPDEST 06FE 34 CALLVALUE 06FF 80 DUP1 0700 15 ISZERO 0701 61 PUSH2 0x0709 0704 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06FE stack[0] = msg.value } // Block ends with conditional jump to 0x0709, if !msg.value label_0705: // Incoming jump from 0x0704, if not !msg.value // Inputs[1] { @0708 memory[0x00:0x00] } 0705 60 PUSH1 0x00 0707 80 DUP1 0708 FD *REVERT // Stack delta = +0 // Outputs[1] { @0708 revert(memory[0x00:0x00]); } // Block terminates label_0709: // Incoming jump from 0x0704, if !msg.value 0709 5B JUMPDEST 070A 50 POP 070B 61 PUSH2 0x02fa 070E 61 PUSH2 0x12df 0711 56 *JUMP // Stack delta = +0 // Outputs[1] { @070B stack[-1] = 0x02fa } // Block ends with call to 0x12df, returns to 0x02FA label_0712: // Incoming jump from 0x026A // Inputs[1] { @071E stack[-1] } 0712 5B JUMPDEST 0713 60 PUSH1 0x00 0715 60 PUSH1 0x01 0717 60 PUSH1 0x01 0719 60 PUSH1 0xe0 071B 1B SHL 071C 03 SUB 071D 19 NOT 071E 82 DUP3 071F 16 AND 0720 63 PUSH4 0x80ac58cd 0725 60 PUSH1 0xe0 0727 1B SHL 0728 14 EQ 0729 80 DUP1 072A 61 PUSH2 0x0743 072D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0713 stack[0] = 0x00 // @0728 stack[1] = 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0743, if 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_072E: // Incoming jump from 0x072D, if not 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0738 stack[-3] } 072E 50 POP 072F 60 PUSH1 0x01 0731 60 PUSH1 0x01 0733 60 PUSH1 0xe0 0735 1B SHL 0736 03 SUB 0737 19 NOT 0738 82 DUP3 0739 16 AND 073A 63 PUSH4 0x5b5e139f 073F 60 PUSH1 0xe0 0741 1B SHL 0742 14 EQ 0743 5B JUMPDEST 0744 80 DUP1 0745 61 PUSH2 0x075e 0748 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0742 stack[-1] = 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x075e, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_0749: // Incoming jump from 0x0748, if not 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x0748, if not stack[-1] // Inputs[1] { @075B stack[-3] } 0749 50 POP 074A 63 PUSH4 0x01ffc9a7 074F 60 PUSH1 0xe0 0751 1B SHL 0752 60 PUSH1 0x01 0754 60 PUSH1 0x01 0756 60 PUSH1 0xe0 0758 1B SHL 0759 03 SUB 075A 19 NOT 075B 83 DUP4 075C 16 AND 075D 14 EQ // Stack delta = +0 // Outputs[1] { @075D stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block continues label_075E: // Incoming jump from 0x1339, if !(stack[-1] < storage[0x00]) // Incoming jump from 0x0748, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x075D // Incoming jump from 0x0748, if stack[-1] // Inputs[3] // { // @075F stack[-1] // @075F stack[-4] // @0760 stack[-3] // } 075E 5B JUMPDEST 075F 92 SWAP3 0760 91 SWAP2 0761 50 POP 0762 50 POP 0763 56 *JUMP // Stack delta = -3 // Outputs[1] { @075F stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0764: // Incoming call from 0x0294, returns to 0x0295 // Inputs[1] { @076A storage[0x0a] } 0764 5B JUMPDEST 0765 60 PUSH1 0x60 0767 60 PUSH1 0x0a 0769 80 DUP1 076A 54 SLOAD 076B 61 PUSH2 0x0773 076E 90 SWAP1 076F 61 PUSH2 0x2595 0772 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0765 stack[0] = 0x60 // @0767 stack[1] = 0x0a // @076E stack[2] = 0x0773 // @076E stack[3] = storage[0x0a] // } // Block ends with call to 0x2595, returns to 0x0773 label_0773: // Incoming return from call to 0x2595 at 0x0772 // Incoming return from call to 0x2595 at 0x0C97 // Incoming return from call to 0x2595 at 0x1CCE // Inputs[4] // { // @0774 stack[-1] // @0783 memory[0x40:0x60] // @078B stack[-2] // @0796 storage[stack[-2]] // } 0773 5B JUMPDEST 0774 80 DUP1 0775 60 PUSH1 0x1f 0777 01 ADD 0778 60 PUSH1 0x20 077A 80 DUP1 077B 91 SWAP2 077C 04 DIV 077D 02 MUL 077E 60 PUSH1 0x20 0780 01 ADD 0781 60 PUSH1 0x40 0783 51 MLOAD 0784 90 SWAP1 0785 81 DUP2 0786 01 ADD 0787 60 PUSH1 0x40 0789 52 MSTORE 078A 80 DUP1 078B 92 SWAP3 078C 91 SWAP2 078D 90 SWAP1 078E 81 DUP2 078F 81 DUP2 0790 52 MSTORE 0791 60 PUSH1 0x20 0793 01 ADD 0794 82 DUP3 0795 80 DUP1 0796 54 SLOAD 0797 61 PUSH2 0x079f 079A 90 SWAP1 079B 61 PUSH2 0x2595 079E 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0789 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @078B stack[-2] = memory[0x40:0x60] // @078C stack[-1] = stack[-2] // @078D stack[0] = stack[-1] // @0790 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0793 stack[1] = 0x20 + memory[0x40:0x60] // @0794 stack[2] = stack[-2] // @079A stack[4] = storage[stack[-2]] // @079A stack[3] = 0x079f // } // Block ends with call to 0x2595, returns to 0x079F label_079F: // Incoming return from call to 0x2595 at 0x079E // Inputs[1] { @07A0 stack[-1] } 079F 5B JUMPDEST 07A0 80 DUP1 07A1 15 ISZERO 07A2 61 PUSH2 0x07ec 07A5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07ec, if !stack[-1] label_07A6: // Incoming jump from 0x07A5, if not !stack[-1] // Inputs[1] { @07A6 stack[-1] } 07A6 80 DUP1 07A7 60 PUSH1 0x1f 07A9 10 LT 07AA 61 PUSH2 0x07c1 07AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07c1, if 0x1f < stack[-1] label_07AE: // Incoming jump from 0x07AD, if not 0x1f < stack[-1] // Inputs[4] // { // @07B2 stack[-2] // @07B3 storage[stack[-2]] // @07B6 stack[-3] // @07B8 stack[-1] // } 07AE 61 PUSH2 0x0100 07B1 80 DUP1 07B2 83 DUP4 07B3 54 SLOAD 07B4 04 DIV 07B5 02 MUL 07B6 83 DUP4 07B7 52 MSTORE 07B8 91 SWAP2 07B9 60 PUSH1 0x20 07BB 01 ADD 07BC 91 SWAP2 07BD 61 PUSH2 0x07ec 07C0 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @07B7 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @07BC stack[-1] = stack[-1] // @07BC stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x07ec label_07C1: // Incoming jump from 0x07AD, if 0x1f < stack[-1] // Inputs[5] // { // @07C2 stack[-3] // @07C3 stack[-1] // @07C5 stack[-2] // @07CD memory[0x00:0x20] // @07D1 storage[keccak256(memory[0x00:0x20])] // } 07C1 5B JUMPDEST 07C2 82 DUP3 07C3 01 ADD 07C4 91 SWAP2 07C5 90 SWAP1 07C6 60 PUSH1 0x00 07C8 52 MSTORE 07C9 60 PUSH1 0x20 07CB 60 PUSH1 0x00 07CD 20 SHA3 07CE 90 SWAP1 07CF 5B JUMPDEST 07D0 81 DUP2 07D1 54 SLOAD 07D2 81 DUP2 07D3 52 MSTORE 07D4 90 SWAP1 07D5 60 PUSH1 0x01 07D7 01 ADD 07D8 90 SWAP1 07D9 60 PUSH1 0x20 07DB 01 ADD 07DC 80 DUP1 07DD 83 DUP4 07DE 11 GT 07DF 61 PUSH2 0x07cf 07E2 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @07C4 stack[-3] = stack[-3] + stack[-1] // @07C8 memory[0x00:0x20] = stack[-2] // @07D3 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @07D8 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @07DB stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x07cf, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_07E3: // Incoming jump from 0x07E2, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x07E2, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @07E3 stack[-3] // @07E4 stack[-1] // } 07E3 82 DUP3 07E4 90 SWAP1 07E5 03 SUB 07E6 60 PUSH1 0x1f 07E8 16 AND 07E9 82 DUP3 07EA 01 ADD 07EB 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @07EB stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @07EB stack[-1] = stack[-3] // } // Block continues label_07EC: // Incoming jump from 0x07C0 // Incoming jump from 0x07A5, if !stack[-1] // Incoming jump from 0x07EB // Inputs[3] // { // @07F2 stack[-6] // @07F2 stack[-7] // @07F4 stack[-8] // } 07EC 5B JUMPDEST 07ED 50 POP 07EE 50 POP 07EF 50 POP 07F0 50 POP 07F1 50 POP 07F2 90 SWAP1 07F3 50 POP 07F4 90 SWAP1 07F5 56 *JUMP // Stack delta = -7 // Outputs[1] { @07F4 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_07F6: // Incoming jump from 0x02C1 // Incoming call from 0x1559, returns to 0x155A // Inputs[1] { @07FC stack[-1] } 07F6 5B JUMPDEST 07F7 60 PUSH1 0x00 07F9 61 PUSH2 0x0801 07FC 82 DUP3 07FD 61 PUSH2 0x132d 0800 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07F7 stack[0] = 0x00 // @07F9 stack[1] = 0x0801 // @07FC stack[2] = stack[-1] // } // Block ends with call to 0x132d, returns to 0x0801 label_0801: // Incoming return from call to 0x132D at 0x0800 // Inputs[1] { @0805 stack[-1] } 0801 5B JUMPDEST 0802 61 PUSH2 0x081e 0805 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x081e, if stack[-1] label_0806: // Incoming jump from 0x0805, if not stack[-1] // Inputs[3] // { // @0808 memory[0x40:0x60] // @0818 memory[0x40:0x60] // @081D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0806 60 PUSH1 0x40 0808 51 MLOAD 0809 63 PUSH4 0x33d1c039 080E 60 PUSH1 0xe2 0810 1B SHL 0811 81 DUP2 0812 52 MSTORE 0813 60 PUSH1 0x04 0815 01 ADD 0816 60 PUSH1 0x40 0818 51 MLOAD 0819 80 DUP1 081A 91 SWAP2 081B 03 SUB 081C 90 SWAP1 081D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0812 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x33d1c039 << 0xe2 // @081D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_081E: // Incoming jump from 0x0805, if stack[-1] // Inputs[4] // { // @0822 stack[-2] // @082D memory[0x00:0x40] // @082E storage[keccak256(memory[0x00:0x40])] // @0838 stack[-3] // } 081E 5B JUMPDEST 081F 50 POP 0820 60 PUSH1 0x00 0822 90 SWAP1 0823 81 DUP2 0824 52 MSTORE 0825 60 PUSH1 0x06 0827 60 PUSH1 0x20 0829 52 MSTORE 082A 60 PUSH1 0x40 082C 90 SWAP1 082D 20 SHA3 082E 54 SLOAD 082F 60 PUSH1 0x01 0831 60 PUSH1 0x01 0833 60 PUSH1 0xa0 0835 1B SHL 0836 03 SUB 0837 16 AND 0838 90 SWAP1 0839 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0824 memory[0x00:0x20] = stack[-2] // @0829 memory[0x20:0x40] = 0x06 // @0838 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_083A: // Incoming jump from 0x02F9 // Inputs[1] { @0840 stack[-1] } 083A 5B JUMPDEST 083B 60 PUSH1 0x00 083D 61 PUSH2 0x0845 0840 82 DUP3 0841 61 PUSH2 0x0b0d 0844 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @083B stack[0] = 0x00 // @083D stack[1] = 0x0845 // @0840 stack[2] = stack[-1] // } // Block ends with call to 0x0b0d, returns to 0x0845 label_0845: // Incoming return from call to 0x0B0D at 0x0844 // Inputs[3] // { // @0846 stack[-1] // @0846 stack[-2] // @0852 stack[-4] // } 0845 5B JUMPDEST 0846 90 SWAP1 0847 50 POP 0848 80 DUP1 0849 60 PUSH1 0x01 084B 60 PUSH1 0x01 084D 60 PUSH1 0xa0 084F 1B SHL 0850 03 SUB 0851 16 AND 0852 83 DUP4 0853 60 PUSH1 0x01 0855 60 PUSH1 0x01 0857 60 PUSH1 0xa0 0859 1B SHL 085A 03 SUB 085B 16 AND 085C 14 EQ 085D 15 ISZERO 085E 61 PUSH2 0x087a 0861 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0846 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x087a, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0862: // Incoming jump from 0x0861, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @0864 memory[0x40:0x60] // @0874 memory[0x40:0x60] // @0879 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0862 60 PUSH1 0x40 0864 51 MLOAD 0865 63 PUSH4 0x250fdee3 086A 60 PUSH1 0xe2 086C 1B SHL 086D 81 DUP2 086E 52 MSTORE 086F 60 PUSH1 0x04 0871 01 ADD 0872 60 PUSH1 0x40 0874 51 MLOAD 0875 80 DUP1 0876 91 SWAP2 0877 03 SUB 0878 90 SWAP1 0879 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @086E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x250fdee3 << 0xe2 // @0879 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_087A: // Incoming jump from 0x0861, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @087B msg.sender // @0884 stack[-1] // } 087A 5B JUMPDEST 087B 33 CALLER 087C 60 PUSH1 0x01 087E 60 PUSH1 0x01 0880 60 PUSH1 0xa0 0882 1B SHL 0883 03 SUB 0884 82 DUP3 0885 16 AND 0886 14 EQ 0887 80 DUP1 0888 15 ISZERO 0889 90 SWAP1 088A 61 PUSH2 0x089a 088D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0889 stack[0] = !(stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender) } // Block ends with conditional jump to 0x089a, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_088E: // Incoming jump from 0x088D, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @0892 stack[-2] // @0893 msg.sender // } 088E 50 POP 088F 61 PUSH2 0x0898 0892 81 DUP2 0893 33 CALLER 0894 61 PUSH2 0x069a 0897 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @088F stack[-1] = 0x0898 // @0892 stack[0] = stack[-2] // @0893 stack[1] = msg.sender // } // Block ends with call to 0x069a, returns to 0x0898 label_0898: // Incoming return from call to 0x069A at 0x0897 // Inputs[1] { @0899 stack[-1] } 0898 5B JUMPDEST 0899 15 ISZERO // Stack delta = +0 // Outputs[1] { @0899 stack[-1] = !stack[-1] } // Block continues label_089A: // Incoming jump from 0x0899 // Incoming jump from 0x088D, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @089B stack[-1] } 089A 5B JUMPDEST 089B 15 ISZERO 089C 61 PUSH2 0x08b8 089F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x08b8, if !stack[-1] label_08A0: // Incoming jump from 0x089F, if not !stack[-1] // Inputs[3] // { // @08A2 memory[0x40:0x60] // @08B2 memory[0x40:0x60] // @08B7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 08A0 60 PUSH1 0x40 08A2 51 MLOAD 08A3 63 PUSH4 0x67d9dca1 08A8 60 PUSH1 0xe1 08AA 1B SHL 08AB 81 DUP2 08AC 52 MSTORE 08AD 60 PUSH1 0x04 08AF 01 ADD 08B0 60 PUSH1 0x40 08B2 51 MLOAD 08B3 80 DUP1 08B4 91 SWAP2 08B5 03 SUB 08B6 90 SWAP1 08B7 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @08AC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x67d9dca1 << 0xe1 // @08B7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_08B8: // Incoming jump from 0x089F, if !stack[-1] // Inputs[3] // { // @08BC stack[-3] // @08BD stack[-2] // @08BE stack[-1] // } 08B8 5B JUMPDEST 08B9 61 PUSH2 0x08c3 08BC 83 DUP4 08BD 83 DUP4 08BE 83 DUP4 08BF 61 PUSH2 0x1358 08C2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @08B9 stack[0] = 0x08c3 // @08BC stack[1] = stack[-3] // @08BD stack[2] = stack[-2] // @08BE stack[3] = stack[-1] // } // Block ends with call to 0x1358, returns to 0x08C3 label_08C3: // Incoming return from call to 0x0E46 at 0x0AC9 // Incoming return from call to 0x1358 at 0x08C2 // Incoming return from call to 0x14EA at 0x0919 // Inputs[1] { @08C7 stack[-4] } 08C3 5B JUMPDEST 08C4 50 POP 08C5 50 POP 08C6 50 POP 08C7 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_08C8: // Incoming jump from 0x031B // Inputs[2] // { // @08CB storage[0x08] // @08DB msg.sender // } 08C8 5B JUMPDEST 08C9 60 PUSH1 0x08 08CB 54 SLOAD 08CC 60 PUSH1 0x01 08CE 60 PUSH1 0x01 08D0 60 PUSH1 0xa0 08D2 1B SHL 08D3 03 SUB 08D4 61 PUSH2 0x0100 08D7 90 SWAP1 08D8 91 SWAP2 08D9 04 DIV 08DA 16 AND 08DB 33 CALLER 08DC 14 EQ 08DD 61 PUSH2 0x0901 08E0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0901, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 label_08E1: // Incoming jump from 0x08E0, if not msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @08E3 memory[0x40:0x60] } 08E1 60 PUSH1 0x40 08E3 51 MLOAD 08E4 62 PUSH3 0x461bcd 08E8 60 PUSH1 0xe5 08EA 1B SHL 08EB 81 DUP2 08EC 52 MSTORE 08ED 60 PUSH1 0x04 08EF 01 ADD 08F0 61 PUSH2 0x08f8 08F3 90 SWAP1 08F4 61 PUSH2 0x24d2 08F7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @08EC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08F3 stack[0] = 0x08f8 // @08F3 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24d2, returns to 0x08F8 label_08F8: // Incoming jump from 0x1403 // Incoming return from call to 0x24D2 at 0x1234 // Incoming return from call to 0x24D2 at 0x0AF9 // Incoming return from call to 0x24D2 at 0x119D // Incoming jump from 0x1932 // Incoming jump from 0x0D12 // Incoming return from call to 0x24D2 at 0x0AA4 // Incoming return from call to 0x24D2 at 0x0D47 // Incoming return from call to 0x24D2 at 0x08F7 // Incoming jump from 0x09B0 // Incoming return from call to 0x24D2 at 0x0C83 // Incoming return from call to 0x24D2 at 0x0C4B // Incoming return from call to 0x24D2 at 0x0CC7 // Incoming return from call to 0x24D2 at 0x0C16 // Incoming jump from 0x14B4 // Incoming jump from 0x19D0 // Incoming jump from 0x1168 // Incoming return from call to 0x24D2 at 0x0B9D // Incoming jump from 0x095E // Incoming return from call to 0x24D2 at 0x1270 // Incoming jump from 0x12D5 // Incoming jump from 0x1B20 // Incoming jump from 0x1AC1 // Incoming jump from 0x0A08 // Incoming jump from 0x0F87 // Incoming return from call to 0x24D2 at 0x0E32 // Incoming jump from 0x0F2F // Incoming jump from 0x11FB // Incoming return from call to 0x24D2 at 0x0A45 // Incoming jump from 0x172C // Incoming return from call to 0x24D2 at 0x0EC6 // Incoming return from call to 0x24D2 at 0x111D // Incoming jump from 0x1455 // Incoming jump from 0x104E // Incoming return from call to 0x24D2 at 0x130E // Incoming return from call to 0x24D2 at 0x0BD7 // Inputs[3] // { // @08FB memory[0x40:0x60] // @08FD stack[-1] // @0900 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 08F8 5B JUMPDEST 08F9 60 PUSH1 0x40 08FB 51 MLOAD 08FC 80 DUP1 08FD 91 SWAP2 08FE 03 SUB 08FF 90 SWAP1 0900 FD *REVERT // Stack delta = -1 // Outputs[1] { @0900 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0901: // Incoming jump from 0x08E0, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0905 stack[-2] // @0906 stack[-1] // } 0901 5B JUMPDEST 0902 61 PUSH2 0x090b 0905 82 DUP3 0906 82 DUP3 0907 61 PUSH2 0x13b4 090A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0902 stack[0] = 0x090b // @0905 stack[1] = stack[-2] // @0906 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x13b4 label_090B: // Incoming return from call to 0x1DE9 at 0x14E9 // Incoming jump from 0x0A6B, if !!address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[1] { @090E stack[-3] } 090B 5B JUMPDEST 090C 50 POP 090D 50 POP 090E 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_090F: // Incoming jump from 0x035E // Inputs[3] // { // @0913 stack[-3] // @0914 stack[-2] // @0915 stack[-1] // } 090F 5B JUMPDEST 0910 61 PUSH2 0x08c3 0913 83 DUP4 0914 83 DUP4 0915 83 DUP4 0916 61 PUSH2 0x14ea 0919 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0910 stack[0] = 0x08c3 // @0913 stack[1] = stack[-3] // @0914 stack[2] = stack[-2] // @0915 stack[3] = stack[-1] // } // Block ends with call to 0x14ea, returns to 0x08C3 label_091A: // Incoming jump from 0x0387 // Inputs[2] // { // @091B tx.origin // @091C msg.sender // } 091A 5B JUMPDEST 091B 32 ORIGIN 091C 33 CALLER 091D 14 EQ 091E 61 PUSH2 0x095f 0921 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x095f, if msg.sender == tx.origin label_0922: // Incoming jump from 0x0921, if not msg.sender == tx.origin // Inputs[1] { @0924 memory[0x40:0x60] } 0922 60 PUSH1 0x40 0924 51 MLOAD 0925 62 PUSH3 0x461bcd 0929 60 PUSH1 0xe5 092B 1B SHL 092C 81 DUP2 092D 52 MSTORE 092E 60 PUSH1 0x20 0930 60 PUSH1 0x04 0932 82 DUP3 0933 01 ADD 0934 52 MSTORE 0935 60 PUSH1 0x13 0937 60 PUSH1 0x24 0939 82 DUP3 093A 01 ADD 093B 52 MSTORE 093C 72 PUSH19 0x21b0b63632b91036bab9ba103132903ab9b2b9 0950 60 PUSH1 0x69 0952 1B SHL 0953 60 PUSH1 0x44 0955 82 DUP3 0956 01 ADD 0957 52 MSTORE 0958 60 PUSH1 0x64 095A 01 ADD 095B 61 PUSH2 0x08f8 095E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @092D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0934 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @093B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x13 // @0957 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x21b0b63632b91036bab9ba103132903ab9b2b9 << 0x69 // @095A stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f8 label_095F: // Incoming jump from 0x0921, if msg.sender == tx.origin // Inputs[1] { @0962 storage[0x11] } 095F 5B JUMPDEST 0960 60 PUSH1 0x11 0962 54 SLOAD 0963 60 PUSH1 0xff 0965 16 AND 0966 61 PUSH2 0x09b1 0969 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09b1, if 0xff & storage[0x11] label_096A: // Incoming jump from 0x0969, if not 0xff & storage[0x11] // Inputs[1] { @096C memory[0x40:0x60] } 096A 60 PUSH1 0x40 096C 51 MLOAD 096D 62 PUSH3 0x461bcd 0971 60 PUSH1 0xe5 0973 1B SHL 0974 81 DUP2 0975 52 MSTORE 0976 60 PUSH1 0x20 0978 60 PUSH1 0x04 097A 82 DUP3 097B 01 ADD 097C 52 MSTORE 097D 60 PUSH1 0x1a 097F 60 PUSH1 0x24 0981 82 DUP3 0982 01 ADD 0983 52 MSTORE 0984 7F PUSH32 0x5075626c6963206d696e74696e67206469646e74207374617274000000000000 09A5 60 PUSH1 0x44 09A7 82 DUP3 09A8 01 ADD 09A9 52 MSTORE 09AA 60 PUSH1 0x64 09AC 01 ADD 09AD 61 PUSH2 0x08f8 09B0 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0975 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @097C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0983 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1a // @09A9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5075626c6963206d696e74696e67206469646e74207374617274000000000000 // @09AC stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f8 label_09B1: // Incoming jump from 0x0969, if 0xff & storage[0x11] // Inputs[2] // { // @09B2 stack[-1] // @09B5 storage[0x0c] // } 09B1 5B JUMPDEST 09B2 80 DUP1 09B3 60 PUSH1 0x0c 09B5 54 SLOAD 09B6 61 PUSH2 0x09bf 09B9 91 SWAP2 09BA 90 SWAP1 09BB 61 PUSH2 0x2533 09BE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09B9 stack[0] = 0x09bf // @09BA stack[1] = stack[-1] // @09BA stack[2] = storage[0x0c] // } // Block ends with call to 0x2533, returns to 0x09BF label_09BF: // Incoming return from call to 0x2533 at 0x09BE // Inputs[2] // { // @09C0 msg.value // @09C1 stack[-1] // } 09BF 5B JUMPDEST 09C0 34 CALLVALUE 09C1 14 EQ 09C2 61 PUSH2 0x0a09 09C5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a09, if msg.value == stack[-1] label_09C6: // Incoming jump from 0x09C5, if not msg.value == stack[-1] // Inputs[1] { @09C8 memory[0x40:0x60] } 09C6 60 PUSH1 0x40 09C8 51 MLOAD 09C9 62 PUSH3 0x461bcd 09CD 60 PUSH1 0xe5 09CF 1B SHL 09D0 81 DUP2 09D1 52 MSTORE 09D2 60 PUSH1 0x20 09D4 60 PUSH1 0x04 09D6 82 DUP3 09D7 01 ADD 09D8 52 MSTORE 09D9 60 PUSH1 0x19 09DB 60 PUSH1 0x24 09DD 82 DUP3 09DE 01 ADD 09DF 52 MSTORE 09E0 78 PUSH25 0x115d1a195c881cd95b9d081a5cc81b9bdd0818dbdc9c9958dd 09FA 60 PUSH1 0x3a 09FC 1B SHL 09FD 60 PUSH1 0x44 09FF 82 DUP3 0A00 01 ADD 0A01 52 MSTORE 0A02 60 PUSH1 0x64 0A04 01 ADD 0A05 61 PUSH2 0x08f8 0A08 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @09D1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09D8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @09DF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @0A01 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x115d1a195c881cd95b9d081a5cc81b9bdd0818dbdc9c9958dd << 0x3a // @0A04 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f8 label_0A09: // Incoming jump from 0x09C5, if msg.value == stack[-1] // Inputs[2] // { // @0A0D msg.sender // @0A0E stack[-1] // } 0A09 5B JUMPDEST 0A0A 61 PUSH2 0x0a13 0A0D 33 CALLER 0A0E 82 DUP3 0A0F 61 PUSH2 0x13b4 0A12 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A0A stack[0] = 0x0a13 // @0A0D stack[1] = msg.sender // @0A0E stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x13b4 label_0A13: // Incoming return from call to 0x1893 at 0x12DE // Incoming jump from 0x2652, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0A15 stack[-2] } 0A13 5B JUMPDEST 0A14 50 POP 0A15 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0A16: // Incoming call from 0x039C, returns to 0x02FA // Inputs[2] // { // @0A19 storage[0x08] // @0A29 msg.sender // } 0A16 5B JUMPDEST 0A17 60 PUSH1 0x08 0A19 54 SLOAD 0A1A 60 PUSH1 0x01 0A1C 60 PUSH1 0x01 0A1E 60 PUSH1 0xa0 0A20 1B SHL 0A21 03 SUB 0A22 61 PUSH2 0x0100 0A25 90 SWAP1 0A26 91 SWAP2 0A27 04 DIV 0A28 16 AND 0A29 33 CALLER 0A2A 14 EQ 0A2B 61 PUSH2 0x0a46 0A2E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a46, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 label_0A2F: // Incoming jump from 0x0A2E, if not msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0A31 memory[0x40:0x60] } 0A2F 60 PUSH1 0x40 0A31 51 MLOAD 0A32 62 PUSH3 0x461bcd 0A36 60 PUSH1 0xe5 0A38 1B SHL 0A39 81 DUP2 0A3A 52 MSTORE 0A3B 60 PUSH1 0x04 0A3D 01 ADD 0A3E 61 PUSH2 0x08f8 0A41 90 SWAP1 0A42 61 PUSH2 0x24d2 0A45 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A3A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A41 stack[0] = 0x08f8 // @0A41 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24d2, returns to 0x08F8 label_0A46: // Incoming jump from 0x0A2E, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @0A49 memory[0x40:0x60] // @0A4A address(this).balance // @0A4A address(this) // @0A4C msg.sender // @0A5F address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0A5F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // } 0A46 5B JUMPDEST 0A47 60 PUSH1 0x40 0A49 51 MLOAD 0A4A 47 SELFBALANCE 0A4B 90 SWAP1 0A4C 33 CALLER 0A4D 90 SWAP1 0A4E 82 DUP3 0A4F 15 ISZERO 0A50 61 PUSH2 0x08fc 0A53 02 MUL 0A54 90 SWAP1 0A55 83 DUP4 0A56 90 SWAP1 0A57 60 PUSH1 0x00 0A59 81 DUP2 0A5A 81 DUP2 0A5B 81 DUP2 0A5C 85 DUP6 0A5D 88 DUP9 0A5E 88 DUP9 0A5F F1 CALL 0A60 93 SWAP4 0A61 50 POP 0A62 50 POP 0A63 50 POP 0A64 50 POP 0A65 15 ISZERO 0A66 80 DUP1 0A67 15 ISZERO 0A68 61 PUSH2 0x090b 0A6B 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0A4B stack[0] = address(this).balance // @0A5F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0A65 stack[1] = !address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } // Block ends with conditional jump to 0x090b, if !!address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_0A6C: // Incoming jump from 0x0A6B, if not !!address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[4] // { // @0A6C returndata.length // @0A70 returndata[0x00:0x00 + returndata.length] // @0A71 returndata.length // @0A74 memory[0x00:0x00 + returndata.length] // } 0A6C 3D RETURNDATASIZE 0A6D 60 PUSH1 0x00 0A6F 80 DUP1 0A70 3E RETURNDATACOPY 0A71 3D RETURNDATASIZE 0A72 60 PUSH1 0x00 0A74 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A70 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0A74 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0A75: // Incoming call from 0x03B1, returns to 0x02FA // Inputs[2] // { // @0A78 storage[0x08] // @0A88 msg.sender // } 0A75 5B JUMPDEST 0A76 60 PUSH1 0x08 0A78 54 SLOAD 0A79 60 PUSH1 0x01 0A7B 60 PUSH1 0x01 0A7D 60 PUSH1 0xa0 0A7F 1B SHL 0A80 03 SUB 0A81 61 PUSH2 0x0100 0A84 90 SWAP1 0A85 91 SWAP2 0A86 04 DIV 0A87 16 AND 0A88 33 CALLER 0A89 14 EQ 0A8A 61 PUSH2 0x0aa5 0A8D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0aa5, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 label_0A8E: // Incoming jump from 0x0A8D, if not msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0A90 memory[0x40:0x60] } 0A8E 60 PUSH1 0x40 0A90 51 MLOAD 0A91 62 PUSH3 0x461bcd 0A95 60 PUSH1 0xe5 0A97 1B SHL 0A98 81 DUP2 0A99 52 MSTORE 0A9A 60 PUSH1 0x04 0A9C 01 ADD 0A9D 61 PUSH2 0x08f8 0AA0 90 SWAP1 0AA1 61 PUSH2 0x24d2 0AA4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A99 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AA0 stack[0] = 0x08f8 // @0AA0 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24d2, returns to 0x08F8 label_0AA5: // Incoming jump from 0x0A8D, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 0AA5 5B JUMPDEST 0AA6 61 PUSH2 0x0aad 0AA9 61 PUSH2 0x16e4 0AAC 56 *JUMP // Stack delta = +1 // Outputs[1] { @0AA6 stack[0] = 0x0aad } // Block ends with call to 0x16e4, returns to 0x0AAD label_0AAD: // Incoming return from call to 0x1893 at 0x0BA7 // Incoming return from call to 0x18ED at 0x0C53 // Incoming return from call to 0x16E4 at 0x0AAC // Inputs[1] { @0AAE stack[-1] } 0AAD 5B JUMPDEST 0AAE 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0AAF: // Incoming jump from 0x03D1 // Inputs[4] // { // @0AB3 stack[-3] // @0AB4 stack[-2] // @0AB5 stack[-1] // @0AB8 memory[0x40:0x60] // } 0AAF 5B JUMPDEST 0AB0 61 PUSH2 0x08c3 0AB3 83 DUP4 0AB4 83 DUP4 0AB5 83 DUP4 0AB6 60 PUSH1 0x40 0AB8 51 MLOAD 0AB9 80 DUP1 0ABA 60 PUSH1 0x20 0ABC 01 ADD 0ABD 60 PUSH1 0x40 0ABF 52 MSTORE 0AC0 80 DUP1 0AC1 60 PUSH1 0x00 0AC3 81 DUP2 0AC4 52 MSTORE 0AC5 50 POP 0AC6 61 PUSH2 0x0e46 0AC9 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0AB0 stack[0] = 0x08c3 // @0AB3 stack[1] = stack[-3] // @0AB4 stack[2] = stack[-2] // @0AB5 stack[3] = stack[-1] // @0AB8 stack[4] = memory[0x40:0x60] // @0ABF memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0AC4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x0e46, returns to 0x08C3 label_0ACA: // Incoming jump from 0x03F1 // Inputs[2] // { // @0ACD storage[0x08] // @0ADD msg.sender // } 0ACA 5B JUMPDEST 0ACB 60 PUSH1 0x08 0ACD 54 SLOAD 0ACE 60 PUSH1 0x01 0AD0 60 PUSH1 0x01 0AD2 60 PUSH1 0xa0 0AD4 1B SHL 0AD5 03 SUB 0AD6 61 PUSH2 0x0100 0AD9 90 SWAP1 0ADA 91 SWAP2 0ADB 04 DIV 0ADC 16 AND 0ADD 33 CALLER 0ADE 14 EQ 0ADF 61 PUSH2 0x0afa 0AE2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0afa, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 label_0AE3: // Incoming jump from 0x0AE2, if not msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0AE5 memory[0x40:0x60] } 0AE3 60 PUSH1 0x40 0AE5 51 MLOAD 0AE6 62 PUSH3 0x461bcd 0AEA 60 PUSH1 0xe5 0AEC 1B SHL 0AED 81 DUP2 0AEE 52 MSTORE 0AEF 60 PUSH1 0x04 0AF1 01 ADD 0AF2 61 PUSH2 0x08f8 0AF5 90 SWAP1 0AF6 61 PUSH2 0x24d2 0AF9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0AEE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AF5 stack[0] = 0x08f8 // @0AF5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24d2, returns to 0x08F8 label_0AFA: // Incoming jump from 0x0AE2, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0AFB stack[-1] // @0AFC memory[stack[-1]:stack[-1] + 0x20] // } 0AFA 5B JUMPDEST 0AFB 80 DUP1 0AFC 51 MLOAD 0AFD 61 PUSH2 0x090b 0B00 90 SWAP1 0B01 60 PUSH1 0x09 0B03 90 SWAP1 0B04 60 PUSH1 0x20 0B06 84 DUP5 0B07 01 ADD 0B08 90 SWAP1 0B09 61 PUSH2 0x206d 0B0C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B00 stack[0] = 0x090b // @0B03 stack[1] = 0x09 // @0B08 stack[2] = stack[-1] + 0x20 // @0B08 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x206d label_0B0D: // Incoming call from 0x0844, returns to 0x0845 // Incoming jump from 0x0429 // Inputs[1] { @0B13 stack[-1] } 0B0D 5B JUMPDEST 0B0E 60 PUSH1 0x00 0B10 61 PUSH2 0x0b18 0B13 82 DUP3 0B14 61 PUSH2 0x1777 0B17 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B0E stack[0] = 0x00 // @0B10 stack[1] = 0x0b18 // @0B13 stack[2] = stack[-1] // } // Block ends with call to 0x1777, returns to 0x0B18 label_0B18: // Incoming return from call to 0x1777 at 0x0B17 // Inputs[4] // { // @0B19 memory[stack[-1]:stack[-1] + 0x20] // @0B19 stack[-1] // @0B1A stack[-4] // @0B1B stack[-3] // } 0B18 5B JUMPDEST 0B19 51 MLOAD 0B1A 92 SWAP3 0B1B 91 SWAP2 0B1C 50 POP 0B1D 50 POP 0B1E 56 *JUMP // Stack delta = -3 // Outputs[1] { @0B1A stack[-4] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-4] label_0B1F: // Incoming jump from 0x0449 // Inputs[1] { @0B2A stack[-1] } 0B1F 5B JUMPDEST 0B20 60 PUSH1 0x00 0B22 60 PUSH1 0x01 0B24 60 PUSH1 0x01 0B26 60 PUSH1 0xa0 0B28 1B SHL 0B29 03 SUB 0B2A 82 DUP3 0B2B 16 AND 0B2C 61 PUSH2 0x0b48 0B2F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B20 stack[0] = 0x00 } // Block ends with conditional jump to 0x0b48, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0B30: // Incoming jump from 0x0B2F, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0B32 memory[0x40:0x60] // @0B42 memory[0x40:0x60] // @0B47 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B30 60 PUSH1 0x40 0B32 51 MLOAD 0B33 63 PUSH4 0x23d3ad81 0B38 60 PUSH1 0xe2 0B3A 1B SHL 0B3B 81 DUP2 0B3C 52 MSTORE 0B3D 60 PUSH1 0x04 0B3F 01 ADD 0B40 60 PUSH1 0x40 0B42 51 MLOAD 0B43 80 DUP1 0B44 91 SWAP2 0B45 03 SUB 0B46 90 SWAP1 0B47 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0B3C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x23d3ad81 << 0xe2 // @0B47 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0B48: // Incoming jump from 0x0B2F, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0B52 stack[-2] // @0B60 memory[0x00:0x40] // @0B61 storage[keccak256(memory[0x00:0x40])] // @0B6C stack[-3] // } 0B48 5B JUMPDEST 0B49 50 POP 0B4A 60 PUSH1 0x01 0B4C 60 PUSH1 0x01 0B4E 60 PUSH1 0xa0 0B50 1B SHL 0B51 03 SUB 0B52 16 AND 0B53 60 PUSH1 0x00 0B55 90 SWAP1 0B56 81 DUP2 0B57 52 MSTORE 0B58 60 PUSH1 0x05 0B5A 60 PUSH1 0x20 0B5C 52 MSTORE 0B5D 60 PUSH1 0x40 0B5F 90 SWAP1 0B60 20 SHA3 0B61 54 SLOAD 0B62 67 PUSH8 0xffffffffffffffff 0B6B 16 AND 0B6C 90 SWAP1 0B6D 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0B57 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0B5C memory[0x20:0x40] = 0x05 // @0B6C stack[-3] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0B6E: // Incoming call from 0x045E, returns to 0x02FA // Inputs[2] // { // @0B71 storage[0x08] // @0B81 msg.sender // } 0B6E 5B JUMPDEST 0B6F 60 PUSH1 0x08 0B71 54 SLOAD 0B72 60 PUSH1 0x01 0B74 60 PUSH1 0x01 0B76 60 PUSH1 0xa0 0B78 1B SHL 0B79 03 SUB 0B7A 61 PUSH2 0x0100 0B7D 90 SWAP1 0B7E 91 SWAP2 0B7F 04 DIV 0B80 16 AND 0B81 33 CALLER 0B82 14 EQ 0B83 61 PUSH2 0x0b9e 0B86 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b9e, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 label_0B87: // Incoming jump from 0x0B86, if not msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0B89 memory[0x40:0x60] } 0B87 60 PUSH1 0x40 0B89 51 MLOAD 0B8A 62 PUSH3 0x461bcd 0B8E 60 PUSH1 0xe5 0B90 1B SHL 0B91 81 DUP2 0B92 52 MSTORE 0B93 60 PUSH1 0x04 0B95 01 ADD 0B96 61 PUSH2 0x08f8 0B99 90 SWAP1 0B9A 61 PUSH2 0x24d2 0B9D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B92 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B99 stack[0] = 0x08f8 // @0B99 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24d2, returns to 0x08F8 label_0B9E: // Incoming jump from 0x0B86, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 0B9E 5B JUMPDEST 0B9F 61 PUSH2 0x0aad 0BA2 60 PUSH1 0x00 0BA4 61 PUSH2 0x1893 0BA7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B9F stack[0] = 0x0aad // @0BA2 stack[1] = 0x00 // } // Block ends with call to 0x1893, returns to 0x0AAD label_0BA8: // Incoming call from 0x0473, returns to 0x02FA // Inputs[2] // { // @0BAB storage[0x08] // @0BBB msg.sender // } 0BA8 5B JUMPDEST 0BA9 60 PUSH1 0x08 0BAB 54 SLOAD 0BAC 60 PUSH1 0x01 0BAE 60 PUSH1 0x01 0BB0 60 PUSH1 0xa0 0BB2 1B SHL 0BB3 03 SUB 0BB4 61 PUSH2 0x0100 0BB7 90 SWAP1 0BB8 91 SWAP2 0BB9 04 DIV 0BBA 16 AND 0BBB 33 CALLER 0BBC 14 EQ 0BBD 61 PUSH2 0x0bd8 0BC0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bd8, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 label_0BC1: // Incoming jump from 0x0BC0, if not msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0BC3 memory[0x40:0x60] } 0BC1 60 PUSH1 0x40 0BC3 51 MLOAD 0BC4 62 PUSH3 0x461bcd 0BC8 60 PUSH1 0xe5 0BCA 1B SHL 0BCB 81 DUP2 0BCC 52 MSTORE 0BCD 60 PUSH1 0x04 0BCF 01 ADD 0BD0 61 PUSH2 0x08f8 0BD3 90 SWAP1 0BD4 61 PUSH2 0x24d2 0BD7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0BCC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BD3 stack[0] = 0x08f8 // @0BD3 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24d2, returns to 0x08F8 label_0BD8: // Incoming jump from 0x0BC0, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0BDC storage[0x11] // @0BE6 stack[-1] // } 0BD8 5B JUMPDEST 0BD9 60 PUSH1 0x11 0BDB 80 DUP1 0BDC 54 SLOAD 0BDD 60 PUSH1 0xff 0BDF 19 NOT 0BE0 16 AND 0BE1 60 PUSH1 0x01 0BE3 17 OR 0BE4 90 SWAP1 0BE5 55 SSTORE 0BE6 56 *JUMP // Stack delta = -1 // Outputs[1] { @0BE5 storage[0x11] = 0x01 | (~0xff & storage[0x11]) } // Block ends with unconditional jump to stack[-1] label_0BE7: // Incoming jump from 0x0493 // Inputs[2] // { // @0BEA storage[0x08] // @0BFA msg.sender // } 0BE7 5B JUMPDEST 0BE8 60 PUSH1 0x08 0BEA 54 SLOAD 0BEB 60 PUSH1 0x01 0BED 60 PUSH1 0x01 0BEF 60 PUSH1 0xa0 0BF1 1B SHL 0BF2 03 SUB 0BF3 61 PUSH2 0x0100 0BF6 90 SWAP1 0BF7 91 SWAP2 0BF8 04 DIV 0BF9 16 AND 0BFA 33 CALLER 0BFB 14 EQ 0BFC 61 PUSH2 0x0c17 0BFF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c17, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 label_0C00: // Incoming jump from 0x0BFF, if not msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0C02 memory[0x40:0x60] } 0C00 60 PUSH1 0x40 0C02 51 MLOAD 0C03 62 PUSH3 0x461bcd 0C07 60 PUSH1 0xe5 0C09 1B SHL 0C0A 81 DUP2 0C0B 52 MSTORE 0C0C 60 PUSH1 0x04 0C0E 01 ADD 0C0F 61 PUSH2 0x08f8 0C12 90 SWAP1 0C13 61 PUSH2 0x24d2 0C16 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C0B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C12 stack[0] = 0x08f8 // @0C12 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24d2, returns to 0x08F8 label_0C17: // Incoming jump from 0x0BFF, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0C1A stack[-1] // @0C1B stack[-2] // } 0C17 5B JUMPDEST 0C18 60 PUSH1 0x0d 0C1A 55 SSTORE 0C1B 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C1A storage[0x0d] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0C1C: // Incoming call from 0x04A8, returns to 0x02FA // Inputs[2] // { // @0C1F storage[0x08] // @0C2F msg.sender // } 0C1C 5B JUMPDEST 0C1D 60 PUSH1 0x08 0C1F 54 SLOAD 0C20 60 PUSH1 0x01 0C22 60 PUSH1 0x01 0C24 60 PUSH1 0xa0 0C26 1B SHL 0C27 03 SUB 0C28 61 PUSH2 0x0100 0C2B 90 SWAP1 0C2C 91 SWAP2 0C2D 04 DIV 0C2E 16 AND 0C2F 33 CALLER 0C30 14 EQ 0C31 61 PUSH2 0x0c4c 0C34 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c4c, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 label_0C35: // Incoming jump from 0x0C34, if not msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0C37 memory[0x40:0x60] } 0C35 60 PUSH1 0x40 0C37 51 MLOAD 0C38 62 PUSH3 0x461bcd 0C3C 60 PUSH1 0xe5 0C3E 1B SHL 0C3F 81 DUP2 0C40 52 MSTORE 0C41 60 PUSH1 0x04 0C43 01 ADD 0C44 61 PUSH2 0x08f8 0C47 90 SWAP1 0C48 61 PUSH2 0x24d2 0C4B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C40 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C47 stack[0] = 0x08f8 // @0C47 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24d2, returns to 0x08F8 label_0C4C: // Incoming jump from 0x0C34, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 0C4C 5B JUMPDEST 0C4D 61 PUSH2 0x0aad 0C50 61 PUSH2 0x18ed 0C53 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C4D stack[0] = 0x0aad } // Block ends with call to 0x18ed, returns to 0x0AAD label_0C54: // Incoming jump from 0x04EB // Inputs[2] // { // @0C57 storage[0x08] // @0C67 msg.sender // } 0C54 5B JUMPDEST 0C55 60 PUSH1 0x08 0C57 54 SLOAD 0C58 60 PUSH1 0x01 0C5A 60 PUSH1 0x01 0C5C 60 PUSH1 0xa0 0C5E 1B SHL 0C5F 03 SUB 0C60 61 PUSH2 0x0100 0C63 90 SWAP1 0C64 91 SWAP2 0C65 04 DIV 0C66 16 AND 0C67 33 CALLER 0C68 14 EQ 0C69 61 PUSH2 0x0c84 0C6C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c84, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 label_0C6D: // Incoming jump from 0x0C6C, if not msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0C6F memory[0x40:0x60] } 0C6D 60 PUSH1 0x40 0C6F 51 MLOAD 0C70 62 PUSH3 0x461bcd 0C74 60 PUSH1 0xe5 0C76 1B SHL 0C77 81 DUP2 0C78 52 MSTORE 0C79 60 PUSH1 0x04 0C7B 01 ADD 0C7C 61 PUSH2 0x08f8 0C7F 90 SWAP1 0C80 61 PUSH2 0x24d2 0C83 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C78 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C7F stack[0] = 0x08f8 // @0C7F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24d2, returns to 0x08F8 label_0C84: // Incoming jump from 0x0C6C, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0C87 stack[-1] // @0C88 stack[-2] // } 0C84 5B JUMPDEST 0C85 60 PUSH1 0x0c 0C87 55 SSTORE 0C88 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C87 storage[0x0c] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0C89: // Incoming call from 0x0500, returns to 0x0295 // Inputs[1] { @0C8F storage[0x0b] } 0C89 5B JUMPDEST 0C8A 60 PUSH1 0x60 0C8C 60 PUSH1 0x0b 0C8E 80 DUP1 0C8F 54 SLOAD 0C90 61 PUSH2 0x0773 0C93 90 SWAP1 0C94 61 PUSH2 0x2595 0C97 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0C8A stack[0] = 0x60 // @0C8C stack[1] = 0x0b // @0C93 stack[2] = 0x0773 // @0C93 stack[3] = storage[0x0b] // } // Block ends with call to 0x2595, returns to 0x0773 label_0C98: // Incoming jump from 0x0520 // Inputs[2] // { // @0C9B storage[0x08] // @0CAB msg.sender // } 0C98 5B JUMPDEST 0C99 60 PUSH1 0x08 0C9B 54 SLOAD 0C9C 60 PUSH1 0x01 0C9E 60 PUSH1 0x01 0CA0 60 PUSH1 0xa0 0CA2 1B SHL 0CA3 03 SUB 0CA4 61 PUSH2 0x0100 0CA7 90 SWAP1 0CA8 91 SWAP2 0CA9 04 DIV 0CAA 16 AND 0CAB 33 CALLER 0CAC 14 EQ 0CAD 61 PUSH2 0x0cc8 0CB0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cc8, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 label_0CB1: // Incoming jump from 0x0CB0, if not msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0CB3 memory[0x40:0x60] } 0CB1 60 PUSH1 0x40 0CB3 51 MLOAD 0CB4 62 PUSH3 0x461bcd 0CB8 60 PUSH1 0xe5 0CBA 1B SHL 0CBB 81 DUP2 0CBC 52 MSTORE 0CBD 60 PUSH1 0x04 0CBF 01 ADD 0CC0 61 PUSH2 0x08f8 0CC3 90 SWAP1 0CC4 61 PUSH2 0x24d2 0CC7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0CBC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CC3 stack[0] = 0x08f8 // @0CC3 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24d2, returns to 0x08F8 label_0CC8: // Incoming jump from 0x0CB0, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0CCB storage[0x14] // @0CCC stack[-1] // } 0CC8 5B JUMPDEST 0CC9 60 PUSH1 0x14 0CCB 54 SLOAD 0CCC 81 DUP2 0CCD 10 LT 0CCE 61 PUSH2 0x0d13 0CD1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d13, if stack[-1] < storage[0x14] label_0CD2: // Incoming jump from 0x0CD1, if not stack[-1] < storage[0x14] // Inputs[1] { @0CD4 memory[0x40:0x60] } 0CD2 60 PUSH1 0x40 0CD4 51 MLOAD 0CD5 62 PUSH3 0x461bcd 0CD9 60 PUSH1 0xe5 0CDB 1B SHL 0CDC 81 DUP2 0CDD 52 MSTORE 0CDE 60 PUSH1 0x20 0CE0 60 PUSH1 0x04 0CE2 82 DUP3 0CE3 01 ADD 0CE4 52 MSTORE 0CE5 60 PUSH1 0x17 0CE7 60 PUSH1 0x24 0CE9 82 DUP3 0CEA 01 ADD 0CEB 52 MSTORE 0CEC 76 PUSH23 0x43616e206e6f7420696e63726561736520737570706c79 0D04 60 PUSH1 0x48 0D06 1B SHL 0D07 60 PUSH1 0x44 0D09 82 DUP3 0D0A 01 ADD 0D0B 52 MSTORE 0D0C 60 PUSH1 0x64 0D0E 01 ADD 0D0F 61 PUSH2 0x08f8 0D12 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0CDD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CE4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0CEB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x17 // @0D0B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43616e206e6f7420696e63726561736520737570706c79 << 0x48 // @0D0E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f8 label_0D13: // Incoming jump from 0x0CD1, if stack[-1] < storage[0x14] // Inputs[2] // { // @0D16 stack[-1] // @0D17 stack[-2] // } 0D13 5B JUMPDEST 0D14 60 PUSH1 0x14 0D16 55 SSTORE 0D17 56 *JUMP // Stack delta = -2 // Outputs[1] { @0D16 storage[0x14] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0D18: // Incoming jump from 0x0540 // Inputs[2] // { // @0D1B storage[0x08] // @0D2B msg.sender // } 0D18 5B JUMPDEST 0D19 60 PUSH1 0x08 0D1B 54 SLOAD 0D1C 60 PUSH1 0x01 0D1E 60 PUSH1 0x01 0D20 60 PUSH1 0xa0 0D22 1B SHL 0D23 03 SUB 0D24 61 PUSH2 0x0100 0D27 90 SWAP1 0D28 91 SWAP2 0D29 04 DIV 0D2A 16 AND 0D2B 33 CALLER 0D2C 14 EQ 0D2D 61 PUSH2 0x0d48 0D30 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d48, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 label_0D31: // Incoming jump from 0x0D30, if not msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0D33 memory[0x40:0x60] } 0D31 60 PUSH1 0x40 0D33 51 MLOAD 0D34 62 PUSH3 0x461bcd 0D38 60 PUSH1 0xe5 0D3A 1B SHL 0D3B 81 DUP2 0D3C 52 MSTORE 0D3D 60 PUSH1 0x04 0D3F 01 ADD 0D40 61 PUSH2 0x08f8 0D43 90 SWAP1 0D44 61 PUSH2 0x24d2 0D47 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D3C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D43 stack[0] = 0x08f8 // @0D43 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24d2, returns to 0x08F8 label_0D48: // Incoming jump from 0x0D30, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0D4C stack[-1] } 0D48 5B JUMPDEST 0D49 61 PUSH2 0x0a13 0D4C 81 DUP2 0D4D 61 PUSH2 0x1968 0D50 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D49 stack[0] = 0x0a13 // @0D4C stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x1968 label_0D51: // Incoming jump from 0x0576 // Inputs[2] // { // @0D5A stack[-2] // @0D5C msg.sender // } 0D51 5B JUMPDEST 0D52 60 PUSH1 0x01 0D54 60 PUSH1 0x01 0D56 60 PUSH1 0xa0 0D58 1B SHL 0D59 03 SUB 0D5A 82 DUP3 0D5B 16 AND 0D5C 33 CALLER 0D5D 14 EQ 0D5E 15 ISZERO 0D5F 61 PUSH2 0x0d7b 0D62 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d7b, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) label_0D63: // Incoming jump from 0x0D62, if not !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @0D65 memory[0x40:0x60] // @0D75 memory[0x40:0x60] // @0D7A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0D63 60 PUSH1 0x40 0D65 51 MLOAD 0D66 63 PUSH4 0xb06307db 0D6B 60 PUSH1 0xe0 0D6D 1B SHL 0D6E 81 DUP2 0D6F 52 MSTORE 0D70 60 PUSH1 0x04 0D72 01 ADD 0D73 60 PUSH1 0x40 0D75 51 MLOAD 0D76 80 DUP1 0D77 91 SWAP2 0D78 03 SUB 0D79 90 SWAP1 0D7A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0D6F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb06307db << 0xe0 // @0D7A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0D7B: // Incoming jump from 0x0D62, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[10] // { // @0D7C msg.sender // @0D8D memory[0x00:0x40] // @0D96 stack[-2] // @0DA1 memory[0x00:0x40] // @0DA3 storage[keccak256(memory[0x00:0x40])] // @0DA8 stack[-1] // @0DB2 memory[0x40:0x60] // @0DDE memory[0x40:0x60] // @0DE3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0DE6 stack[-3] // } 0D7B 5B JUMPDEST 0D7C 33 CALLER 0D7D 60 PUSH1 0x00 0D7F 81 DUP2 0D80 81 DUP2 0D81 52 MSTORE 0D82 60 PUSH1 0x07 0D84 60 PUSH1 0x20 0D86 90 SWAP1 0D87 81 DUP2 0D88 52 MSTORE 0D89 60 PUSH1 0x40 0D8B 80 DUP1 0D8C 83 DUP4 0D8D 20 SHA3 0D8E 60 PUSH1 0x01 0D90 60 PUSH1 0x01 0D92 60 PUSH1 0xa0 0D94 1B SHL 0D95 03 SUB 0D96 87 DUP8 0D97 16 AND 0D98 80 DUP1 0D99 85 DUP6 0D9A 52 MSTORE 0D9B 90 SWAP1 0D9C 83 DUP4 0D9D 52 MSTORE 0D9E 92 SWAP3 0D9F 81 DUP2 0DA0 90 SWAP1 0DA1 20 SHA3 0DA2 80 DUP1 0DA3 54 SLOAD 0DA4 60 PUSH1 0xff 0DA6 19 NOT 0DA7 16 AND 0DA8 86 DUP7 0DA9 15 ISZERO 0DAA 15 ISZERO 0DAB 90 SWAP1 0DAC 81 DUP2 0DAD 17 OR 0DAE 90 SWAP1 0DAF 91 SWAP2 0DB0 55 SSTORE 0DB1 90 SWAP1 0DB2 51 MLOAD 0DB3 90 SWAP1 0DB4 81 DUP2 0DB5 52 MSTORE 0DB6 91 SWAP2 0DB7 92 SWAP3 0DB8 91 SWAP2 0DB9 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0DDA 91 SWAP2 0DDB 01 ADD 0DDC 60 PUSH1 0x40 0DDE 51 MLOAD 0DDF 80 DUP1 0DE0 91 SWAP2 0DE1 03 SUB 0DE2 90 SWAP1 0DE3 A3 LOG3 0DE4 50 POP 0DE5 50 POP 0DE6 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @0D81 memory[0x00:0x20] = msg.sender // @0D88 memory[0x20:0x40] = 0x07 // @0D9A memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0D9D memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0DB0 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0DB5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0DE3 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-3] label_0DE7: // Incoming call from 0x058B, returns to 0x0295 // Inputs[2] // { // @0DEA memory[0x40:0x60] // @0E01 stack[-1] // } 0DE7 5B JUMPDEST 0DE8 60 PUSH1 0x40 0DEA 51 MLOAD 0DEB 80 DUP1 0DEC 60 PUSH1 0x60 0DEE 01 ADD 0DEF 60 PUSH1 0x40 0DF1 52 MSTORE 0DF2 80 DUP1 0DF3 60 PUSH1 0x28 0DF5 81 DUP2 0DF6 52 MSTORE 0DF7 60 PUSH1 0x20 0DF9 01 ADD 0DFA 61 PUSH2 0x2658 0DFD 60 PUSH1 0x28 0DFF 91 SWAP2 0E00 39 CODECOPY 0E01 81 DUP2 0E02 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @0DEA stack[0] = memory[0x40:0x60] // @0DF1 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @0DF6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x28 // @0E00 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x28] = code[0x2658:0x2680] // } // Block ends with unconditional jump to stack[-1] label_0E03: // Incoming jump from 0x05AB // Inputs[2] // { // @0E06 storage[0x08] // @0E16 msg.sender // } 0E03 5B JUMPDEST 0E04 60 PUSH1 0x08 0E06 54 SLOAD 0E07 60 PUSH1 0x01 0E09 60 PUSH1 0x01 0E0B 60 PUSH1 0xa0 0E0D 1B SHL 0E0E 03 SUB 0E0F 61 PUSH2 0x0100 0E12 90 SWAP1 0E13 91 SWAP2 0E14 04 DIV 0E15 16 AND 0E16 33 CALLER 0E17 14 EQ 0E18 61 PUSH2 0x0e33 0E1B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e33, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 label_0E1C: // Incoming jump from 0x0E1B, if not msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0E1E memory[0x40:0x60] } 0E1C 60 PUSH1 0x40 0E1E 51 MLOAD 0E1F 62 PUSH3 0x461bcd 0E23 60 PUSH1 0xe5 0E25 1B SHL 0E26 81 DUP2 0E27 52 MSTORE 0E28 60 PUSH1 0x04 0E2A 01 ADD 0E2B 61 PUSH2 0x08f8 0E2E 90 SWAP1 0E2F 61 PUSH2 0x24d2 0E32 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E27 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E2E stack[0] = 0x08f8 // @0E2E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24d2, returns to 0x08F8 label_0E33: // Incoming jump from 0x0E1B, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0E34 stack[-1] // @0E35 memory[stack[-1]:stack[-1] + 0x20] // } 0E33 5B JUMPDEST 0E34 80 DUP1 0E35 51 MLOAD 0E36 61 PUSH2 0x090b 0E39 90 SWAP1 0E3A 60 PUSH1 0x0b 0E3C 90 SWAP1 0E3D 60 PUSH1 0x20 0E3F 84 DUP5 0E40 01 ADD 0E41 90 SWAP1 0E42 61 PUSH2 0x206d 0E45 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E39 stack[0] = 0x090b // @0E3C stack[1] = 0x0b // @0E41 stack[2] = stack[-1] + 0x20 // @0E41 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x206d label_0E46: // Incoming call from 0x0AC9, returns to 0x08C3 // Incoming jump from 0x05CB // Inputs[3] // { // @0E4A stack[-4] // @0E4B stack[-3] // @0E4C stack[-2] // } 0E46 5B JUMPDEST 0E47 61 PUSH2 0x0e51 0E4A 84 DUP5 0E4B 84 DUP5 0E4C 84 DUP5 0E4D 61 PUSH2 0x14ea 0E50 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E47 stack[0] = 0x0e51 // @0E4A stack[1] = stack[-4] // @0E4B stack[2] = stack[-3] // @0E4C stack[3] = stack[-2] // } // Block ends with call to 0x14ea, returns to 0x0E51 label_0E51: // Incoming return from call to 0x14EA at 0x0E50 // Inputs[2] // { // @0E5A stack[-3] // @0E5C address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 0E51 5B JUMPDEST 0E52 60 PUSH1 0x01 0E54 60 PUSH1 0x01 0E56 60 PUSH1 0xa0 0E58 1B SHL 0E59 03 SUB 0E5A 83 DUP4 0E5B 16 AND 0E5C 3B EXTCODESIZE 0E5D 15 ISZERO 0E5E 15 ISZERO 0E5F 80 DUP1 0E60 15 ISZERO 0E61 61 PUSH2 0x0e73 0E64 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E5E stack[0] = !!address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length } // Block ends with conditional jump to 0x0e73, if !!!address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_0E65: // Incoming jump from 0x0E64, if not !!!address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[4] // { // @0E69 stack[-5] // @0E6A stack[-4] // @0E6B stack[-3] // @0E6C stack[-2] // } 0E65 50 POP 0E66 61 PUSH2 0x0e71 0E69 84 DUP5 0E6A 84 DUP5 0E6B 84 DUP5 0E6C 84 DUP5 0E6D 61 PUSH2 0x1b33 0E70 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0E66 stack[-1] = 0x0e71 // @0E69 stack[0] = stack[-5] // @0E6A stack[1] = stack[-4] // @0E6B stack[2] = stack[-3] // @0E6C stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1b33 0E71 5B JUMPDEST 0E72 15 ISZERO label_0E73: // Incoming jump from 0x0E64, if !!!address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0E74 stack[-1] } 0E73 5B JUMPDEST 0E74 15 ISZERO 0E75 61 PUSH2 0x0e91 0E78 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e91, if !stack[-1] label_0E79: // Incoming jump from 0x0E78, if not !stack[-1] // Inputs[3] // { // @0E7B memory[0x40:0x60] // @0E8B memory[0x40:0x60] // @0E90 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0E79 60 PUSH1 0x40 0E7B 51 MLOAD 0E7C 63 PUSH4 0x68d2bf6b 0E81 60 PUSH1 0xe1 0E83 1B SHL 0E84 81 DUP2 0E85 52 MSTORE 0E86 60 PUSH1 0x04 0E88 01 ADD 0E89 60 PUSH1 0x40 0E8B 51 MLOAD 0E8C 80 DUP1 0E8D 91 SWAP2 0E8E 03 SUB 0E8F 90 SWAP1 0E90 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0E85 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x68d2bf6b << 0xe1 // @0E90 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0E91: // Incoming jump from 0x0E78, if !stack[-1] // Incoming jump from 0x1FD2, if !(0xff & storage[0x08]) // Incoming jump from 0x258C, if !(stack[-1] > stack[-4]) // Inputs[1] { @0E96 stack[-5] } 0E91 5B JUMPDEST 0E92 50 POP 0E93 50 POP 0E94 50 POP 0E95 50 POP 0E96 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0E97: // Incoming jump from 0x05EB // Inputs[2] // { // @0E9A storage[0x08] // @0EAA msg.sender // } 0E97 5B JUMPDEST 0E98 60 PUSH1 0x08 0E9A 54 SLOAD 0E9B 60 PUSH1 0x01 0E9D 60 PUSH1 0x01 0E9F 60 PUSH1 0xa0 0EA1 1B SHL 0EA2 03 SUB 0EA3 61 PUSH2 0x0100 0EA6 90 SWAP1 0EA7 91 SWAP2 0EA8 04 DIV 0EA9 16 AND 0EAA 33 CALLER 0EAB 14 EQ 0EAC 61 PUSH2 0x0ec7 0EAF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ec7, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 label_0EB0: // Incoming jump from 0x0EAF, if not msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0EB2 memory[0x40:0x60] } 0EB0 60 PUSH1 0x40 0EB2 51 MLOAD 0EB3 62 PUSH3 0x461bcd 0EB7 60 PUSH1 0xe5 0EB9 1B SHL 0EBA 81 DUP2 0EBB 52 MSTORE 0EBC 60 PUSH1 0x04 0EBE 01 ADD 0EBF 61 PUSH2 0x08f8 0EC2 90 SWAP1 0EC3 61 PUSH2 0x24d2 0EC6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0EBB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EC2 stack[0] = 0x08f8 // @0EC2 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24d2, returns to 0x08F8 label_0EC7: // Incoming jump from 0x0EAF, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0EC8 stack[-1] // @0EC9 memory[stack[-1]:stack[-1] + 0x20] // } 0EC7 5B JUMPDEST 0EC8 80 DUP1 0EC9 51 MLOAD 0ECA 61 PUSH2 0x090b 0ECD 90 SWAP1 0ECE 60 PUSH1 0x0a 0ED0 90 SWAP1 0ED1 60 PUSH1 0x20 0ED3 84 DUP5 0ED4 01 ADD 0ED5 90 SWAP1 0ED6 61 PUSH2 0x206d 0ED9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0ECD stack[0] = 0x090b // @0ED0 stack[1] = 0x0a // @0ED5 stack[2] = stack[-1] + 0x20 // @0ED5 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x206d label_0EDA: // Incoming jump from 0x05FE // Inputs[1] { @0EDE stack[-4] } 0EDA 5B JUMPDEST 0EDB 61 PUSH2 0x0ee3 0EDE 84 DUP5 0EDF 61 PUSH2 0x1c2b 0EE2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0EDB stack[0] = 0x0ee3 // @0EDE stack[1] = stack[-4] // } // Block ends with call to 0x1c2b, returns to 0x0EE3 label_0EE3: // Incoming return from call to 0x1C2B at 0x0EE2 // Inputs[1] { @0EE4 stack[-1] } 0EE3 5B JUMPDEST 0EE4 15 ISZERO 0EE5 61 PUSH2 0x0f30 0EE8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f30, if !stack[-1] label_0EE9: // Incoming jump from 0x0EE8, if not !stack[-1] // Inputs[1] { @0EEB memory[0x40:0x60] } 0EE9 60 PUSH1 0x40 0EEB 51 MLOAD 0EEC 62 PUSH3 0x461bcd 0EF0 60 PUSH1 0xe5 0EF2 1B SHL 0EF3 81 DUP2 0EF4 52 MSTORE 0EF5 60 PUSH1 0x20 0EF7 60 PUSH1 0x04 0EF9 82 DUP3 0EFA 01 ADD 0EFB 52 MSTORE 0EFC 60 PUSH1 0x19 0EFE 60 PUSH1 0x24 0F00 82 DUP3 0F01 01 ADD 0F02 52 MSTORE 0F03 7F PUSH32 0x57686974656c69737420616c726561647920636c61696d656400000000000000 0F24 60 PUSH1 0x44 0F26 82 DUP3 0F27 01 ADD 0F28 52 MSTORE 0F29 60 PUSH1 0x64 0F2B 01 ADD 0F2C 61 PUSH2 0x08f8 0F2F 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0EF4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EFB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F02 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @0F28 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x57686974656c69737420616c726561647920636c61696d656400000000000000 // @0F2B stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f8 label_0F30: // Incoming jump from 0x0EE8, if !stack[-1] // Inputs[2] // { // @0F31 stack[-3] // @0F34 storage[0x0c] // } 0F30 5B JUMPDEST 0F31 82 DUP3 0F32 60 PUSH1 0x0c 0F34 54 SLOAD 0F35 61 PUSH2 0x0f3e 0F38 91 SWAP2 0F39 90 SWAP1 0F3A 61 PUSH2 0x2533 0F3D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F38 stack[0] = 0x0f3e // @0F39 stack[1] = stack[-3] // @0F39 stack[2] = storage[0x0c] // } // Block ends with call to 0x2533, returns to 0x0F3E label_0F3E: // Incoming return from call to 0x2533 at 0x0F3D // Inputs[2] // { // @0F3F msg.value // @0F40 stack[-1] // } 0F3E 5B JUMPDEST 0F3F 34 CALLVALUE 0F40 14 EQ 0F41 61 PUSH2 0x0f88 0F44 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f88, if msg.value == stack[-1] label_0F45: // Incoming jump from 0x0F44, if not msg.value == stack[-1] // Inputs[1] { @0F47 memory[0x40:0x60] } 0F45 60 PUSH1 0x40 0F47 51 MLOAD 0F48 62 PUSH3 0x461bcd 0F4C 60 PUSH1 0xe5 0F4E 1B SHL 0F4F 81 DUP2 0F50 52 MSTORE 0F51 60 PUSH1 0x20 0F53 60 PUSH1 0x04 0F55 82 DUP3 0F56 01 ADD 0F57 52 MSTORE 0F58 60 PUSH1 0x19 0F5A 60 PUSH1 0x24 0F5C 82 DUP3 0F5D 01 ADD 0F5E 52 MSTORE 0F5F 78 PUSH25 0x115d1a195c881cd95b9d081a5cc81b9bdd0818dbdc9c9958dd 0F79 60 PUSH1 0x3a 0F7B 1B SHL 0F7C 60 PUSH1 0x44 0F7E 82 DUP3 0F7F 01 ADD 0F80 52 MSTORE 0F81 60 PUSH1 0x64 0F83 01 ADD 0F84 61 PUSH2 0x08f8 0F87 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0F50 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F57 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F5E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @0F80 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x115d1a195c881cd95b9d081a5cc81b9bdd0818dbdc9c9958dd << 0x3a // @0F83 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f8 label_0F88: // Incoming jump from 0x0F44, if msg.value == stack[-1] // Inputs[12] // { // @0F8C memory[0x40:0x60] // @0F91 stack[-4] // @0FA2 msg.sender // @0FB2 stack[-3] // @0FBD memory[0x40:0x60] // @0FCB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @0FD0 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @0FD6 stack[-2] // @0FD7 stack[-1] // @0FE2 memory[0x40:0x60] // @0FFC msg.data[stack[-2]:stack[-2] + 0x20 * stack[-1]] // @1009 storage[0x0d] // } 0F88 5B JUMPDEST 0F89 60 PUSH1 0x40 0F8B 80 DUP1 0F8C 51 MLOAD 0F8D 60 PUSH1 0x20 0F8F 81 DUP2 0F90 01 ADD 0F91 86 DUP7 0F92 90 SWAP1 0F93 52 MSTORE 0F94 6B PUSH12 0xffffffffffffffffffffffff 0FA1 19 NOT 0FA2 33 CALLER 0FA3 60 PUSH1 0x60 0FA5 1B SHL 0FA6 16 AND 0FA7 91 SWAP2 0FA8 81 DUP2 0FA9 01 ADD 0FAA 91 SWAP2 0FAB 90 SWAP1 0FAC 91 SWAP2 0FAD 52 MSTORE 0FAE 60 PUSH1 0x54 0FB0 81 DUP2 0FB1 01 ADD 0FB2 84 DUP5 0FB3 90 SWAP1 0FB4 52 MSTORE 0FB5 60 PUSH1 0x00 0FB7 90 SWAP1 0FB8 60 PUSH1 0x74 0FBA 01 ADD 0FBB 60 PUSH1 0x40 0FBD 51 MLOAD 0FBE 60 PUSH1 0x20 0FC0 81 DUP2 0FC1 83 DUP4 0FC2 03 SUB 0FC3 03 SUB 0FC4 81 DUP2 0FC5 52 MSTORE 0FC6 90 SWAP1 0FC7 60 PUSH1 0x40 0FC9 52 MSTORE 0FCA 80 DUP1 0FCB 51 MLOAD 0FCC 90 SWAP1 0FCD 60 PUSH1 0x20 0FCF 01 ADD 0FD0 20 SHA3 0FD1 90 SWAP1 0FD2 50 POP 0FD3 61 PUSH2 0x1013 0FD6 83 DUP4 0FD7 83 DUP4 0FD8 80 DUP1 0FD9 80 DUP1 0FDA 60 PUSH1 0x20 0FDC 02 MUL 0FDD 60 PUSH1 0x20 0FDF 01 ADD 0FE0 60 PUSH1 0x40 0FE2 51 MLOAD 0FE3 90 SWAP1 0FE4 81 DUP2 0FE5 01 ADD 0FE6 60 PUSH1 0x40 0FE8 52 MSTORE 0FE9 80 DUP1 0FEA 93 SWAP4 0FEB 92 SWAP3 0FEC 91 SWAP2 0FED 90 SWAP1 0FEE 81 DUP2 0FEF 81 DUP2 0FF0 52 MSTORE 0FF1 60 PUSH1 0x20 0FF3 01 ADD 0FF4 83 DUP4 0FF5 83 DUP4 0FF6 60 PUSH1 0x20 0FF8 02 MUL 0FF9 80 DUP1 0FFA 82 DUP3 0FFB 84 DUP5 0FFC 37 CALLDATACOPY 0FFD 60 PUSH1 0x00 0FFF 92 SWAP3 1000 01 ADD 1001 91 SWAP2 1002 90 SWAP1 1003 91 SWAP2 1004 52 MSTORE 1005 50 POP 1006 50 POP 1007 60 PUSH1 0x0d 1009 54 SLOAD 100A 91 SWAP2 100B 50 POP 100C 84 DUP5 100D 90 SWAP1 100E 50 POP 100F 61 PUSH2 0x1c6c 1012 56 *JUMP // Stack delta = +5 // Outputs[14] // { // @0F93 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-4] // @0FAD memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = (msg.sender << 0x60) & ~0xffffffffffffffffffffffff // @0FB4 memory[memory[0x40:0x60] + 0x54:memory[0x40:0x60] + 0x54 + 0x20] = stack[-3] // @0FC5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x74 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @0FC9 memory[0x40:0x60] = 0x74 + memory[0x40:0x60] // @0FD1 stack[0] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @0FD3 stack[1] = 0x1013 // @0FE8 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // @0FEA stack[2] = memory[0x40:0x60] // @0FF0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0FFC memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-1]] = msg.data[stack[-2]:stack[-2] + 0x20 * stack[-1]] // @1004 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-1]:0x20 + memory[0x40:0x60] + 0x20 * stack[-1] + 0x20] = 0x00 // @100A stack[3] = storage[0x0d] // @100D stack[4] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with call to 0x1c6c, returns to 0x1013 label_1013: // Incoming return from call to 0x1C6C at 0x1012 // Inputs[1] { @1017 stack[-1] } 1013 5B JUMPDEST 1014 61 PUSH2 0x104f 1017 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x104f, if stack[-1] label_1018: // Incoming jump from 0x1017, if not stack[-1] // Inputs[1] { @101A memory[0x40:0x60] } 1018 60 PUSH1 0x40 101A 51 MLOAD 101B 62 PUSH3 0x461bcd 101F 60 PUSH1 0xe5 1021 1B SHL 1022 81 DUP2 1023 52 MSTORE 1024 60 PUSH1 0x20 1026 60 PUSH1 0x04 1028 82 DUP3 1029 01 ADD 102A 52 MSTORE 102B 60 PUSH1 0x0d 102D 60 PUSH1 0x24 102F 82 DUP3 1030 01 ADD 1031 52 MSTORE 1032 6C PUSH13 0x24b73b30b634b210383937b7b3 1040 60 PUSH1 0x99 1042 1B SHL 1043 60 PUSH1 0x44 1045 82 DUP3 1046 01 ADD 1047 52 MSTORE 1048 60 PUSH1 0x64 104A 01 ADD 104B 61 PUSH2 0x08f8 104E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1023 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @102A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1031 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0d // @1047 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x24b73b30b634b210383937b7b3 << 0x99 // @104A stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f8 label_104F: // Incoming jump from 0x1017, if stack[-1] // Inputs[1] { @1053 stack[-5] } 104F 5B JUMPDEST 1050 61 PUSH2 0x1058 1053 85 DUP6 1054 61 PUSH2 0x1c82 1057 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1050 stack[0] = 0x1058 // @1053 stack[1] = stack[-5] // } // Block ends with call to 0x1c82, returns to 0x1058 label_1058: // Incoming return from call to 0x1C82 at 0x1057 // Inputs[2] // { // @105C msg.sender // @105D stack[-4] // } 1058 5B JUMPDEST 1059 61 PUSH2 0x1062 105C 33 CALLER 105D 85 DUP6 105E 61 PUSH2 0x13b4 1061 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1059 stack[0] = 0x1062 // @105C stack[1] = msg.sender // @105D stack[2] = stack[-4] // } // Block ends with unconditional jump to 0x13b4 label_1062: // Incoming jump from 0x16E3 // Incoming jump from 0x1FC6 // Inputs[1] { @1068 stack[-6] } 1062 5B JUMPDEST 1063 50 POP 1064 50 POP 1065 50 POP 1066 50 POP 1067 50 POP 1068 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_1069: // Incoming jump from 0x061E // Inputs[1] { @106F stack[-1] } 1069 5B JUMPDEST 106A 60 PUSH1 0x60 106C 61 PUSH2 0x1074 106F 82 DUP3 1070 61 PUSH2 0x132d 1073 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @106A stack[0] = 0x60 // @106C stack[1] = 0x1074 // @106F stack[2] = stack[-1] // } // Block ends with call to 0x132d, returns to 0x1074 label_1074: // Incoming return from call to 0x132D at 0x1073 // Inputs[1] { @1078 stack[-1] } 1074 5B JUMPDEST 1075 61 PUSH2 0x1091 1078 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1091, if stack[-1] label_1079: // Incoming jump from 0x1078, if not stack[-1] // Inputs[3] // { // @107B memory[0x40:0x60] // @108B memory[0x40:0x60] // @1090 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1079 60 PUSH1 0x40 107B 51 MLOAD 107C 63 PUSH4 0x0a14c4b5 1081 60 PUSH1 0xe4 1083 1B SHL 1084 81 DUP2 1085 52 MSTORE 1086 60 PUSH1 0x04 1088 01 ADD 1089 60 PUSH1 0x40 108B 51 MLOAD 108C 80 DUP1 108D 91 SWAP2 108E 03 SUB 108F 90 SWAP1 1090 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1085 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a14c4b5 << 0xe4 // @1090 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1091: // Incoming jump from 0x1078, if stack[-1] 1091 5B JUMPDEST 1092 60 PUSH1 0x00 1094 61 PUSH2 0x109b 1097 61 PUSH2 0x1cc0 109A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1092 stack[0] = 0x00 // @1094 stack[1] = 0x109b // } // Block ends with unconditional jump to 0x1cc0 109B 5B JUMPDEST 109C 90 SWAP1 109D 50 POP 109E 80 DUP1 109F 51 MLOAD 10A0 60 PUSH1 0x00 10A2 14 EQ 10A3 15 ISZERO 10A4 61 PUSH2 0x10bc 10A7 57 *JUMPI 10A8 60 PUSH1 0x40 10AA 51 MLOAD 10AB 80 DUP1 10AC 60 PUSH1 0x20 10AE 01 ADD 10AF 60 PUSH1 0x40 10B1 52 MSTORE 10B2 80 DUP1 10B3 60 PUSH1 0x00 10B5 81 DUP2 10B6 52 MSTORE 10B7 50 POP 10B8 61 PUSH2 0x10e7 10BB 56 *JUMP 10BC 5B JUMPDEST 10BD 80 DUP1 10BE 61 PUSH2 0x10c6 10C1 84 DUP5 10C2 61 PUSH2 0x1ccf 10C5 56 *JUMP 10C6 5B JUMPDEST 10C7 60 PUSH1 0x40 10C9 51 MLOAD 10CA 60 PUSH1 0x20 10CC 01 ADD 10CD 61 PUSH2 0x10d7 10D0 92 SWAP3 10D1 91 SWAP2 10D2 90 SWAP1 10D3 61 PUSH2 0x2453 10D6 56 *JUMP 10D7 5B JUMPDEST 10D8 60 PUSH1 0x40 10DA 51 MLOAD 10DB 60 PUSH1 0x20 10DD 81 DUP2 10DE 83 DUP4 10DF 03 SUB 10E0 03 SUB 10E1 81 DUP2 10E2 52 MSTORE 10E3 90 SWAP1 10E4 60 PUSH1 0x40 10E6 52 MSTORE label_10E7: // Incoming return from call to 0x217C at 0x21B1 // Incoming return from call to 0x2427 at 0x24D1 // Incoming return from call to 0x2641 at 0x234A // Incoming return from call to 0x2641 at 0x232E // Inputs[3] // { // @10E8 stack[-1] // @10E8 stack[-5] // @10E9 stack[-4] // } 10E7 5B JUMPDEST 10E8 93 SWAP4 10E9 92 SWAP3 10EA 50 POP 10EB 50 POP 10EC 50 POP 10ED 56 *JUMP // Stack delta = -4 // Outputs[1] { @10E8 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_10EE: // Incoming jump from 0x063E // Inputs[2] // { // @10F1 storage[0x08] // @1101 msg.sender // } 10EE 5B JUMPDEST 10EF 60 PUSH1 0x08 10F1 54 SLOAD 10F2 60 PUSH1 0x01 10F4 60 PUSH1 0x01 10F6 60 PUSH1 0xa0 10F8 1B SHL 10F9 03 SUB 10FA 61 PUSH2 0x0100 10FD 90 SWAP1 10FE 91 SWAP2 10FF 04 DIV 1100 16 AND 1101 33 CALLER 1102 14 EQ 1103 61 PUSH2 0x111e 1106 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x111e, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 label_1107: // Incoming jump from 0x1106, if not msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1109 memory[0x40:0x60] } 1107 60 PUSH1 0x40 1109 51 MLOAD 110A 62 PUSH3 0x461bcd 110E 60 PUSH1 0xe5 1110 1B SHL 1111 81 DUP2 1112 52 MSTORE 1113 60 PUSH1 0x04 1115 01 ADD 1116 61 PUSH2 0x08f8 1119 90 SWAP1 111A 61 PUSH2 0x24d2 111D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1112 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1119 stack[0] = 0x08f8 // @1119 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24d2, returns to 0x08F8 label_111E: // Incoming jump from 0x1106, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1121 storage[0x10] // @1122 stack[-1] // } 111E 5B JUMPDEST 111F 60 PUSH1 0x10 1121 54 SLOAD 1122 81 DUP2 1123 10 LT 1124 61 PUSH2 0x1169 1127 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1169, if stack[-1] < storage[0x10] label_1128: // Incoming jump from 0x1127, if not stack[-1] < storage[0x10] // Inputs[1] { @112A memory[0x40:0x60] } 1128 60 PUSH1 0x40 112A 51 MLOAD 112B 62 PUSH3 0x461bcd 112F 60 PUSH1 0xe5 1131 1B SHL 1132 81 DUP2 1133 52 MSTORE 1134 60 PUSH1 0x20 1136 60 PUSH1 0x04 1138 82 DUP3 1139 01 ADD 113A 52 MSTORE 113B 60 PUSH1 0x17 113D 60 PUSH1 0x24 113F 82 DUP3 1140 01 ADD 1141 52 MSTORE 1142 76 PUSH23 0x43616e206e6f7420696e63726561736520737570706c79 115A 60 PUSH1 0x48 115C 1B SHL 115D 60 PUSH1 0x44 115F 82 DUP3 1160 01 ADD 1161 52 MSTORE 1162 60 PUSH1 0x64 1164 01 ADD 1165 61 PUSH2 0x08f8 1168 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1133 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @113A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1141 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x17 // @1161 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x43616e206e6f7420696e63726561736520737570706c79 << 0x48 // @1164 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f8 label_1169: // Incoming jump from 0x1127, if stack[-1] < storage[0x10] // Inputs[2] // { // @116C stack[-1] // @116D stack[-2] // } 1169 5B JUMPDEST 116A 60 PUSH1 0x10 116C 55 SSTORE 116D 56 *JUMP // Stack delta = -2 // Outputs[1] { @116C storage[0x10] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_116E: // Incoming call from 0x0669, returns to 0x02FA // Inputs[2] // { // @1171 storage[0x08] // @1181 msg.sender // } 116E 5B JUMPDEST 116F 60 PUSH1 0x08 1171 54 SLOAD 1172 60 PUSH1 0x01 1174 60 PUSH1 0x01 1176 60 PUSH1 0xa0 1178 1B SHL 1179 03 SUB 117A 61 PUSH2 0x0100 117D 90 SWAP1 117E 91 SWAP2 117F 04 DIV 1180 16 AND 1181 33 CALLER 1182 14 EQ 1183 61 PUSH2 0x119e 1186 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x119e, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 label_1187: // Incoming jump from 0x1186, if not msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1189 memory[0x40:0x60] } 1187 60 PUSH1 0x40 1189 51 MLOAD 118A 62 PUSH3 0x461bcd 118E 60 PUSH1 0xe5 1190 1B SHL 1191 81 DUP2 1192 52 MSTORE 1193 60 PUSH1 0x04 1195 01 ADD 1196 61 PUSH2 0x08f8 1199 90 SWAP1 119A 61 PUSH2 0x24d2 119D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1192 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1199 stack[0] = 0x08f8 // @1199 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24d2, returns to 0x08F8 label_119E: // Incoming jump from 0x1186, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @11A2 storage[0x15] // @11A9 stack[-1] // } 119E 5B JUMPDEST 119F 60 PUSH1 0x15 11A1 80 DUP1 11A2 54 SLOAD 11A3 60 PUSH1 0xff 11A5 19 NOT 11A6 16 AND 11A7 90 SWAP1 11A8 55 SSTORE 11A9 56 *JUMP // Stack delta = -1 // Outputs[1] { @11A8 storage[0x15] = ~0xff & storage[0x15] } // Block ends with unconditional jump to stack[-1] label_11AA: // Incoming jump from 0x067E // Inputs[1] { @11AD storage[0x15] } 11AA 5B JUMPDEST 11AB 60 PUSH1 0x15 11AD 54 SLOAD 11AE 60 PUSH1 0xff 11B0 16 AND 11B1 61 PUSH2 0x11fc 11B4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11fc, if 0xff & storage[0x15] label_11B5: // Incoming jump from 0x11B4, if not 0xff & storage[0x15] // Inputs[1] { @11B7 memory[0x40:0x60] } 11B5 60 PUSH1 0x40 11B7 51 MLOAD 11B8 62 PUSH3 0x461bcd 11BC 60 PUSH1 0xe5 11BE 1B SHL 11BF 81 DUP2 11C0 52 MSTORE 11C1 60 PUSH1 0x20 11C3 60 PUSH1 0x04 11C5 82 DUP3 11C6 01 ADD 11C7 52 MSTORE 11C8 60 PUSH1 0x1b 11CA 60 PUSH1 0x24 11CC 82 DUP3 11CD 01 ADD 11CE 52 MSTORE 11CF 7F PUSH32 0x5374616b696e67206d696e74696e67206469646e742073746172740000000000 11F0 60 PUSH1 0x44 11F2 82 DUP3 11F3 01 ADD 11F4 52 MSTORE 11F5 60 PUSH1 0x64 11F7 01 ADD 11F8 61 PUSH2 0x08f8 11FB 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @11C0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11C7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @11CE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1b // @11F4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5374616b696e67206d696e74696e67206469646e742073746172740000000000 // @11F7 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f8 label_11FC: // Incoming jump from 0x11B4, if 0xff & storage[0x15] // Inputs[1] { @1200 msg.sender } 11FC 5B JUMPDEST 11FD 61 PUSH2 0x0aad 1200 33 CALLER 1201 61 PUSH2 0x1968 1204 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @11FD stack[0] = 0x0aad // @1200 stack[1] = msg.sender // } // Block ends with unconditional jump to 0x1968 label_1205: // Incoming call from 0x06DC, returns to 0x02FA // Inputs[2] // { // @1208 storage[0x08] // @1218 msg.sender // } 1205 5B JUMPDEST 1206 60 PUSH1 0x08 1208 54 SLOAD 1209 60 PUSH1 0x01 120B 60 PUSH1 0x01 120D 60 PUSH1 0xa0 120F 1B SHL 1210 03 SUB 1211 61 PUSH2 0x0100 1214 90 SWAP1 1215 91 SWAP2 1216 04 DIV 1217 16 AND 1218 33 CALLER 1219 14 EQ 121A 61 PUSH2 0x1235 121D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1235, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 label_121E: // Incoming jump from 0x121D, if not msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1220 memory[0x40:0x60] } 121E 60 PUSH1 0x40 1220 51 MLOAD 1221 62 PUSH3 0x461bcd 1225 60 PUSH1 0xe5 1227 1B SHL 1228 81 DUP2 1229 52 MSTORE 122A 60 PUSH1 0x04 122C 01 ADD 122D 61 PUSH2 0x08f8 1230 90 SWAP1 1231 61 PUSH2 0x24d2 1234 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1229 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1230 stack[0] = 0x08f8 // @1230 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24d2, returns to 0x08F8 label_1235: // Incoming jump from 0x121D, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1239 storage[0x11] // @1240 stack[-1] // } 1235 5B JUMPDEST 1236 60 PUSH1 0x11 1238 80 DUP1 1239 54 SLOAD 123A 60 PUSH1 0xff 123C 19 NOT 123D 16 AND 123E 90 SWAP1 123F 55 SSTORE 1240 56 *JUMP // Stack delta = -1 // Outputs[1] { @123F storage[0x11] = ~0xff & storage[0x11] } // Block ends with unconditional jump to stack[-1] label_1241: // Incoming jump from 0x06FC // Inputs[2] // { // @1244 storage[0x08] // @1254 msg.sender // } 1241 5B JUMPDEST 1242 60 PUSH1 0x08 1244 54 SLOAD 1245 60 PUSH1 0x01 1247 60 PUSH1 0x01 1249 60 PUSH1 0xa0 124B 1B SHL 124C 03 SUB 124D 61 PUSH2 0x0100 1250 90 SWAP1 1251 91 SWAP2 1252 04 DIV 1253 16 AND 1254 33 CALLER 1255 14 EQ 1256 61 PUSH2 0x1271 1259 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1271, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 label_125A: // Incoming jump from 0x1259, if not msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @125C memory[0x40:0x60] } 125A 60 PUSH1 0x40 125C 51 MLOAD 125D 62 PUSH3 0x461bcd 1261 60 PUSH1 0xe5 1263 1B SHL 1264 81 DUP2 1265 52 MSTORE 1266 60 PUSH1 0x04 1268 01 ADD 1269 61 PUSH2 0x08f8 126C 90 SWAP1 126D 61 PUSH2 0x24d2 1270 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1265 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @126C stack[0] = 0x08f8 // @126C stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24d2, returns to 0x08F8 label_1271: // Incoming jump from 0x1259, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @127A stack[-1] } 1271 5B JUMPDEST 1272 60 PUSH1 0x01 1274 60 PUSH1 0x01 1276 60 PUSH1 0xa0 1278 1B SHL 1279 03 SUB 127A 81 DUP2 127B 16 AND 127C 61 PUSH2 0x12d6 127F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12d6, if stack[-1] & (0x01 << 0xa0) - 0x01 label_1280: // Incoming jump from 0x127F, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1282 memory[0x40:0x60] } 1280 60 PUSH1 0x40 1282 51 MLOAD 1283 62 PUSH3 0x461bcd 1287 60 PUSH1 0xe5 1289 1B SHL 128A 81 DUP2 128B 52 MSTORE 128C 60 PUSH1 0x20 128E 60 PUSH1 0x04 1290 82 DUP3 1291 01 ADD 1292 52 MSTORE 1293 60 PUSH1 0x26 1295 60 PUSH1 0x24 1297 82 DUP3 1298 01 ADD 1299 52 MSTORE 129A 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 12BB 60 PUSH1 0x44 12BD 82 DUP3 12BE 01 ADD 12BF 52 MSTORE 12C0 65 PUSH6 0x646472657373 12C7 60 PUSH1 0xd0 12C9 1B SHL 12CA 60 PUSH1 0x64 12CC 82 DUP3 12CD 01 ADD 12CE 52 MSTORE 12CF 60 PUSH1 0x84 12D1 01 ADD 12D2 61 PUSH2 0x08f8 12D5 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @128B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1292 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1299 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @12BF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @12CE memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @12D1 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f8 label_12D6: // Incoming jump from 0x127F, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @12DA stack[-1] } 12D6 5B JUMPDEST 12D7 61 PUSH2 0x0a13 12DA 81 DUP2 12DB 61 PUSH2 0x1893 12DE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @12D7 stack[0] = 0x0a13 // @12DA stack[1] = stack[-1] // } // Block ends with call to 0x1893, returns to 0x0A13 label_12DF: // Incoming call from 0x0711, returns to 0x02FA // Inputs[2] // { // @12E2 storage[0x08] // @12F2 msg.sender // } 12DF 5B JUMPDEST 12E0 60 PUSH1 0x08 12E2 54 SLOAD 12E3 60 PUSH1 0x01 12E5 60 PUSH1 0x01 12E7 60 PUSH1 0xa0 12E9 1B SHL 12EA 03 SUB 12EB 61 PUSH2 0x0100 12EE 90 SWAP1 12EF 91 SWAP2 12F0 04 DIV 12F1 16 AND 12F2 33 CALLER 12F3 14 EQ 12F4 61 PUSH2 0x130f 12F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x130f, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 label_12F8: // Incoming jump from 0x12F7, if not msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @12FA memory[0x40:0x60] } 12F8 60 PUSH1 0x40 12FA 51 MLOAD 12FB 62 PUSH3 0x461bcd 12FF 60 PUSH1 0xe5 1301 1B SHL 1302 81 DUP2 1303 52 MSTORE 1304 60 PUSH1 0x04 1306 01 ADD 1307 61 PUSH2 0x08f8 130A 90 SWAP1 130B 61 PUSH2 0x24d2 130E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1303 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @130A stack[0] = 0x08f8 // @130A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x24d2, returns to 0x08F8 label_130F: // Incoming jump from 0x12F7, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1313 storage[0x15] // @131D stack[-1] // } 130F 5B JUMPDEST 1310 60 PUSH1 0x15 1312 80 DUP1 1313 54 SLOAD 1314 60 PUSH1 0xff 1316 19 NOT 1317 16 AND 1318 60 PUSH1 0x01 131A 17 OR 131B 90 SWAP1 131C 55 SSTORE 131D 56 *JUMP // Stack delta = -1 // Outputs[1] { @131C storage[0x15] = 0x01 | (~0xff & storage[0x15]) } // Block ends with unconditional jump to stack[-1] 131E 5B JUMPDEST 131F 60 PUSH1 0x01 1321 60 PUSH1 0x01 1323 60 PUSH1 0xa0 1325 1B SHL 1326 03 SUB 1327 16 AND 1328 3B EXTCODESIZE 1329 15 ISZERO 132A 15 ISZERO 132B 90 SWAP1 132C 56 *JUMP label_132D: // Incoming call from 0x1073, returns to 0x1074 // Incoming call from 0x0800, returns to 0x0801 // Inputs[2] // { // @1331 storage[0x00] // @1332 stack[-1] // } 132D 5B JUMPDEST 132E 60 PUSH1 0x00 1330 80 DUP1 1331 54 SLOAD 1332 82 DUP3 1333 10 LT 1334 80 DUP1 1335 15 ISZERO 1336 61 PUSH2 0x075e 1339 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @132E stack[0] = 0x00 // @1333 stack[1] = stack[-1] < storage[0x00] // } // Block ends with conditional jump to 0x075e, if !(stack[-1] < storage[0x00]) label_133A: // Incoming jump from 0x1339, if not !(stack[-1] < storage[0x00]) // Inputs[4] // { // @133E stack[-3] // @1349 memory[0x00:0x40] // @134A storage[keccak256(memory[0x00:0x40])] // @1356 stack[-4] // } 133A 50 POP 133B 50 POP 133C 60 PUSH1 0x00 133E 90 SWAP1 133F 81 DUP2 1340 52 MSTORE 1341 60 PUSH1 0x04 1343 60 PUSH1 0x20 1345 52 MSTORE 1346 60 PUSH1 0x40 1348 90 SWAP1 1349 20 SHA3 134A 54 SLOAD 134B 60 PUSH1 0x01 134D 60 PUSH1 0xe0 134F 1B SHL 1350 90 SWAP1 1351 04 DIV 1352 60 PUSH1 0xff 1354 16 AND 1355 15 ISZERO 1356 90 SWAP1 1357 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1340 memory[0x00:0x20] = stack[-3] // @1345 memory[0x20:0x40] = 0x04 // @1356 stack[-4] = !(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with unconditional jump to stack[-4] label_1358: // Incoming call from 0x15C4, returns to 0x15C5 // Incoming call from 0x08C2, returns to 0x08C3 // Inputs[8] // { // @135B stack[-2] // @1367 memory[0x00:0x40] // @1369 storage[keccak256(memory[0x00:0x40])] // @137C stack[-3] // @1386 memory[0x40:0x60] // @138A stack[-1] // @13AF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @13B3 stack[-4] // } 1358 5B JUMPDEST 1359 60 PUSH1 0x00 135B 82 DUP3 135C 81 DUP2 135D 52 MSTORE 135E 60 PUSH1 0x06 1360 60 PUSH1 0x20 1362 52 MSTORE 1363 60 PUSH1 0x40 1365 80 DUP1 1366 82 DUP3 1367 20 SHA3 1368 80 DUP1 1369 54 SLOAD 136A 60 PUSH1 0x01 136C 60 PUSH1 0x01 136E 60 PUSH1 0xa0 1370 1B SHL 1371 03 SUB 1372 19 NOT 1373 16 AND 1374 60 PUSH1 0x01 1376 60 PUSH1 0x01 1378 60 PUSH1 0xa0 137A 1B SHL 137B 03 SUB 137C 87 DUP8 137D 81 DUP2 137E 16 AND 137F 91 SWAP2 1380 82 DUP3 1381 17 OR 1382 90 SWAP1 1383 92 SWAP3 1384 55 SSTORE 1385 91 SWAP2 1386 51 MLOAD 1387 85 DUP6 1388 93 SWAP4 1389 91 SWAP2 138A 85 DUP6 138B 16 AND 138C 91 SWAP2 138D 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 13AE 91 SWAP2 13AF A4 LOG4 13B0 50 POP 13B1 50 POP 13B2 50 POP 13B3 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @135D memory[0x00:0x20] = stack[-2] // @1362 memory[0x20:0x40] = 0x06 // @1384 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @13AF log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_13B4: // Incoming jump from 0x0A12 // Incoming jump from 0x1061 // Incoming jump from 0x090A // Inputs[1] { @13B7 stack[-1] } 13B4 5B JUMPDEST 13B5 60 PUSH1 0x00 13B7 81 DUP2 13B8 11 GT 13B9 61 PUSH2 0x1404 13BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1404, if stack[-1] > 0x00 label_13BD: // Incoming jump from 0x13BC, if not stack[-1] > 0x00 // Inputs[1] { @13BF memory[0x40:0x60] } 13BD 60 PUSH1 0x40 13BF 51 MLOAD 13C0 62 PUSH3 0x461bcd 13C4 60 PUSH1 0xe5 13C6 1B SHL 13C7 81 DUP2 13C8 52 MSTORE 13C9 60 PUSH1 0x20 13CB 60 PUSH1 0x04 13CD 82 DUP3 13CE 01 ADD 13CF 52 MSTORE 13D0 60 PUSH1 0x1b 13D2 60 PUSH1 0x24 13D4 82 DUP3 13D5 01 ADD 13D6 52 MSTORE 13D7 7F PUSH32 0x596f752063616e74206d696e74206e65676174697665204c414e440000000000 13F8 60 PUSH1 0x44 13FA 82 DUP3 13FB 01 ADD 13FC 52 MSTORE 13FD 60 PUSH1 0x64 13FF 01 ADD 1400 61 PUSH2 0x08f8 1403 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @13C8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13CF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @13D6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1b // @13FC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x596f752063616e74206d696e74206e65676174697665204c414e440000000000 // @13FF stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f8 label_1404: // Incoming jump from 0x13BC, if stack[-1] > 0x00 // Inputs[2] // { // @1407 storage[0x12] // @1408 stack[-1] // } 1404 5B JUMPDEST 1405 60 PUSH1 0x12 1407 54 SLOAD 1408 81 DUP2 1409 11 GT 140A 15 ISZERO 140B 61 PUSH2 0x1456 140E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1456, if !(stack[-1] > storage[0x12]) label_140F: // Incoming jump from 0x140E, if not !(stack[-1] > storage[0x12]) // Inputs[1] { @1411 memory[0x40:0x60] } 140F 60 PUSH1 0x40 1411 51 MLOAD 1412 62 PUSH3 0x461bcd 1416 60 PUSH1 0xe5 1418 1B SHL 1419 81 DUP2 141A 52 MSTORE 141B 60 PUSH1 0x20 141D 60 PUSH1 0x04 141F 82 DUP3 1420 01 ADD 1421 52 MSTORE 1422 60 PUSH1 0x1e 1424 60 PUSH1 0x24 1426 82 DUP3 1427 01 ADD 1428 52 MSTORE 1429 7F PUSH32 0x596f752063616e206d696e74206d61782035204c414e44207065722074780000 144A 60 PUSH1 0x44 144C 82 DUP3 144D 01 ADD 144E 52 MSTORE 144F 60 PUSH1 0x64 1451 01 ADD 1452 61 PUSH2 0x08f8 1455 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @141A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1421 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1428 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @144E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x596f752063616e206d696e74206d61782035204c414e44207065722074780000 // @1451 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f8 label_1456: // Incoming jump from 0x140E, if !(stack[-1] > storage[0x12]) // Inputs[3] // { // @1459 storage[0x10] // @145A stack[-1] // @145D storage[0x0f] // } 1456 5B JUMPDEST 1457 60 PUSH1 0x10 1459 54 SLOAD 145A 81 DUP2 145B 60 PUSH1 0x0f 145D 54 SLOAD 145E 61 PUSH2 0x1467 1461 91 SWAP2 1462 90 SWAP1 1463 61 PUSH2 0x2507 1466 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1459 stack[0] = storage[0x10] // @1461 stack[1] = 0x1467 // @1462 stack[2] = stack[-1] // @1462 stack[3] = storage[0x0f] // } // Block ends with call to 0x2507, returns to 0x1467 label_1467: // Incoming return from call to 0x2507 at 0x1466 // Inputs[2] // { // @1468 stack[-2] // @1468 stack[-1] // } 1467 5B JUMPDEST 1468 11 GT 1469 15 ISZERO 146A 61 PUSH2 0x14b5 146D 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x14b5, if !(stack[-1] > stack[-2]) label_146E: // Incoming jump from 0x146D, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1470 memory[0x40:0x60] } 146E 60 PUSH1 0x40 1470 51 MLOAD 1471 62 PUSH3 0x461bcd 1475 60 PUSH1 0xe5 1477 1B SHL 1478 81 DUP2 1479 52 MSTORE 147A 60 PUSH1 0x20 147C 60 PUSH1 0x04 147E 82 DUP3 147F 01 ADD 1480 52 MSTORE 1481 60 PUSH1 0x1b 1483 60 PUSH1 0x24 1485 82 DUP3 1486 01 ADD 1487 52 MSTORE 1488 7F PUSH32 0x45786365656473206d6178696d756d204c414e4420737570706c790000000000 14A9 60 PUSH1 0x44 14AB 82 DUP3 14AC 01 ADD 14AD 52 MSTORE 14AE 60 PUSH1 0x64 14B0 01 ADD 14B1 61 PUSH2 0x08f8 14B4 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1479 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1480 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1487 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1b // @14AD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45786365656473206d6178696d756d204c414e4420737570706c790000000000 // @14B0 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f8 label_14B5: // Incoming jump from 0x146D, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @14B6 stack[-1] // @14BD storage[0x0f] // } 14B5 5B JUMPDEST 14B6 80 DUP1 14B7 60 PUSH1 0x0f 14B9 60 PUSH1 0x00 14BB 82 DUP3 14BC 82 DUP3 14BD 54 SLOAD 14BE 61 PUSH2 0x14c7 14C1 91 SWAP2 14C2 90 SWAP1 14C3 61 PUSH2 0x2507 14C6 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @14B6 stack[0] = stack[-1] // @14B7 stack[1] = 0x0f // @14B9 stack[2] = 0x00 // @14C1 stack[3] = 0x14c7 // @14C2 stack[4] = stack[-1] // @14C2 stack[5] = storage[0x0f] // } // Block ends with call to 0x2507, returns to 0x14C7 label_14C7: // Incoming return from call to 0x2507 at 0x14C6 // Incoming return from call to 0x2507 at 0x1B32 // Inputs[6] // { // @14C8 stack[-1] // @14C8 stack[-4] // @14CC stack[-3] // @14D2 stack[-6] // @14D3 stack[-5] // @14D6 memory[0x40:0x60] // } 14C7 5B JUMPDEST 14C8 92 SWAP3 14C9 50 POP 14CA 50 POP 14CB 81 DUP2 14CC 90 SWAP1 14CD 55 SSTORE 14CE 50 POP 14CF 61 PUSH2 0x090b 14D2 82 DUP3 14D3 82 DUP3 14D4 60 PUSH1 0x40 14D6 51 MLOAD 14D7 80 DUP1 14D8 60 PUSH1 0x20 14DA 01 ADD 14DB 60 PUSH1 0x40 14DD 52 MSTORE 14DE 80 DUP1 14DF 60 PUSH1 0x00 14E1 81 DUP2 14E2 52 MSTORE 14E3 50 POP 14E4 60 PUSH1 0x00 14E6 61 PUSH2 0x1de9 14E9 56 *JUMP // Stack delta = +1 // Outputs[8] // { // @14CD storage[stack[-3]] = stack[-1] // @14CF stack[-4] = 0x090b // @14D2 stack[-3] = stack[-6] // @14D3 stack[-2] = stack[-5] // @14D6 stack[-1] = memory[0x40:0x60] // @14DD memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @14E2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @14E4 stack[0] = 0x00 // } // Block ends with call to 0x1de9, returns to 0x090B label_14EA: // Incoming call from 0x0919, returns to 0x08C3 // Incoming call from 0x0E50, returns to 0x0E51 // Inputs[1] { @14F0 stack[-1] } 14EA 5B JUMPDEST 14EB 60 PUSH1 0x00 14ED 61 PUSH2 0x14f5 14F0 82 DUP3 14F1 61 PUSH2 0x1777 14F4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @14EB stack[0] = 0x00 // @14ED stack[1] = 0x14f5 // @14F0 stack[2] = stack[-1] // } // Block ends with call to 0x1777, returns to 0x14F5 label_14F5: // Incoming return from call to 0x1777 at 0x14F4 // Inputs[4] // { // @14F6 stack[-2] // @14F6 stack[-1] // @14F8 stack[-5] // @1506 memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // } 14F5 5B JUMPDEST 14F6 90 SWAP1 14F7 50 POP 14F8 83 DUP4 14F9 60 PUSH1 0x01 14FB 60 PUSH1 0x01 14FD 60 PUSH1 0xa0 14FF 1B SHL 1500 03 SUB 1501 16 AND 1502 81 DUP2 1503 60 PUSH1 0x00 1505 01 ADD 1506 51 MLOAD 1507 60 PUSH1 0x01 1509 60 PUSH1 0x01 150B 60 PUSH1 0xa0 150D 1B SHL 150E 03 SUB 150F 16 AND 1510 14 EQ 1511 61 PUSH2 0x152c 1514 57 *JUMPI // Stack delta = -1 // Outputs[1] { @14F6 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x152c, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] label_1515: // Incoming jump from 0x1514, if not (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @1517 memory[0x40:0x60] // @1526 memory[0x40:0x60] // @152B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1515 60 PUSH1 0x40 1517 51 MLOAD 1518 62 PUSH3 0xa11481 151C 60 PUSH1 0xe8 151E 1B SHL 151F 81 DUP2 1520 52 MSTORE 1521 60 PUSH1 0x04 1523 01 ADD 1524 60 PUSH1 0x40 1526 51 MLOAD 1527 80 DUP1 1528 91 SWAP2 1529 03 SUB 152A 90 SWAP1 152B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1520 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa11481 << 0xe8 // @152B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_152C: // Incoming jump from 0x1514, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[2] // { // @152F msg.sender // @1538 stack[-4] // } 152C 5B JUMPDEST 152D 60 PUSH1 0x00 152F 33 CALLER 1530 60 PUSH1 0x01 1532 60 PUSH1 0x01 1534 60 PUSH1 0xa0 1536 1B SHL 1537 03 SUB 1538 86 DUP7 1539 16 AND 153A 14 EQ 153B 80 DUP1 153C 61 PUSH2 0x154a 153F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @152D stack[0] = 0x00 // @153A stack[1] = stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // } // Block ends with conditional jump to 0x154a, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender label_1540: // Incoming jump from 0x153F, if not stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @1544 stack[-6] // @1545 msg.sender // } 1540 50 POP 1541 61 PUSH2 0x154a 1544 85 DUP6 1545 33 CALLER 1546 61 PUSH2 0x069a 1549 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1541 stack[-1] = 0x154a // @1544 stack[0] = stack[-6] // @1545 stack[1] = msg.sender // } // Block ends with call to 0x069a, returns to 0x154A label_154A: // Incoming jump from 0x153F, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Incoming return from call to 0x069A at 0x1549 // Inputs[1] { @154B stack[-1] } 154A 5B JUMPDEST 154B 80 DUP1 154C 61 PUSH2 0x1565 154F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1565, if stack[-1] label_1550: // Incoming jump from 0x154F, if not stack[-1] // Inputs[2] // { // @1551 msg.sender // @1555 stack[-4] // } 1550 50 POP 1551 33 CALLER 1552 61 PUSH2 0x155a 1555 84 DUP5 1556 61 PUSH2 0x07f6 1559 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1551 stack[-1] = msg.sender // @1552 stack[0] = 0x155a // @1555 stack[1] = stack[-4] // } // Block ends with call to 0x07f6, returns to 0x155A label_155A: // Incoming return from call to 0x07F6 at 0x1559 // Inputs[2] // { // @1563 stack[-1] // @1564 stack[-2] // } 155A 5B JUMPDEST 155B 60 PUSH1 0x01 155D 60 PUSH1 0x01 155F 60 PUSH1 0xa0 1561 1B SHL 1562 03 SUB 1563 16 AND 1564 14 EQ // Stack delta = -1 // Outputs[1] { @1564 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_1565: // Incoming jump from 0x1564 // Incoming jump from 0x154F, if stack[-1] // Inputs[2] // { // @1566 stack[-1] // @1566 stack[-2] // } 1565 5B JUMPDEST 1566 90 SWAP1 1567 50 POP 1568 80 DUP1 1569 61 PUSH2 0x1585 156C 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1566 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1585, if stack[-1] label_156D: // Incoming jump from 0x156C, if not stack[-1] // Inputs[3] // { // @156F memory[0x40:0x60] // @157F memory[0x40:0x60] // @1584 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 156D 60 PUSH1 0x40 156F 51 MLOAD 1570 63 PUSH4 0x2ce44b5f 1575 60 PUSH1 0xe1 1577 1B SHL 1578 81 DUP2 1579 52 MSTORE 157A 60 PUSH1 0x04 157C 01 ADD 157D 60 PUSH1 0x40 157F 51 MLOAD 1580 80 DUP1 1581 91 SWAP2 1582 03 SUB 1583 90 SWAP1 1584 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1579 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2ce44b5f << 0xe1 // @1584 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1585: // Incoming jump from 0x156C, if stack[-1] // Inputs[1] { @158E stack[-4] } 1585 5B JUMPDEST 1586 60 PUSH1 0x01 1588 60 PUSH1 0x01 158A 60 PUSH1 0xa0 158C 1B SHL 158D 03 SUB 158E 84 DUP5 158F 16 AND 1590 61 PUSH2 0x15ac 1593 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x15ac, if stack[-4] & (0x01 << 0xa0) - 0x01 label_1594: // Incoming jump from 0x1593, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1596 memory[0x40:0x60] // @15A6 memory[0x40:0x60] // @15AB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1594 60 PUSH1 0x40 1596 51 MLOAD 1597 63 PUSH4 0x3a954ecd 159C 60 PUSH1 0xe2 159E 1B SHL 159F 81 DUP2 15A0 52 MSTORE 15A1 60 PUSH1 0x04 15A3 01 ADD 15A4 60 PUSH1 0x40 15A6 51 MLOAD 15A7 80 DUP1 15A8 91 SWAP2 15A9 03 SUB 15AA 90 SWAP1 15AB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @15A0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3a954ecd << 0xe2 // @15AB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_15AC: // Incoming jump from 0x1593, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @15B0 stack[-5] // @15B1 stack[-4] // @15B2 stack[-3] // } 15AC 5B JUMPDEST 15AD 61 PUSH2 0x15b9 15B0 85 DUP6 15B1 85 DUP6 15B2 85 DUP6 15B3 60 PUSH1 0x01 15B5 61 PUSH2 0x1fc7 15B8 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @15AD stack[0] = 0x15b9 // @15B0 stack[1] = stack[-5] // @15B1 stack[2] = stack[-4] // @15B2 stack[3] = stack[-3] // @15B3 stack[4] = 0x01 // } // Block ends with call to 0x1fc7, returns to 0x15B9 label_15B9: // Incoming return from call to 0x1FC7 at 0x15B8 // Inputs[2] // { // @15BF stack[-3] // @15C0 stack[-5] // } 15B9 5B JUMPDEST 15BA 61 PUSH2 0x15c5 15BD 60 PUSH1 0x00 15BF 84 DUP5 15C0 87 DUP8 15C1 61 PUSH2 0x1358 15C4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @15BA stack[0] = 0x15c5 // @15BD stack[1] = 0x00 // @15BF stack[2] = stack[-3] // @15C0 stack[3] = stack[-5] // } // Block ends with call to 0x1358, returns to 0x15C5 label_15C5: // Incoming return from call to 0x1358 at 0x15C4 // Inputs[12] // { // @15CE stack[-5] // @15E1 memory[0x00:0x40] // @15E3 storage[keccak256(memory[0x00:0x40])] // @1607 stack[-4] // @160F memory[0x00:0x40] // @1611 storage[keccak256(memory[0x00:0x40])] // @1625 stack[-3] // @162F memory[0x00:0x40] // @1631 storage[keccak256(memory[0x00:0x40])] // @1644 block.timestamp // @1655 memory[0x00:0x40] // @1657 storage[keccak256(memory[0x00:0x40])] // } 15C5 5B JUMPDEST 15C6 60 PUSH1 0x01 15C8 60 PUSH1 0x01 15CA 60 PUSH1 0xa0 15CC 1B SHL 15CD 03 SUB 15CE 85 DUP6 15CF 81 DUP2 15D0 16 AND 15D1 60 PUSH1 0x00 15D3 90 SWAP1 15D4 81 DUP2 15D5 52 MSTORE 15D6 60 PUSH1 0x05 15D8 60 PUSH1 0x20 15DA 90 SWAP1 15DB 81 DUP2 15DC 52 MSTORE 15DD 60 PUSH1 0x40 15DF 80 DUP1 15E0 83 DUP4 15E1 20 SHA3 15E2 80 DUP1 15E3 54 SLOAD 15E4 67 PUSH8 0xffffffffffffffff 15ED 19 NOT 15EE 80 DUP1 15EF 82 DUP3 15F0 16 AND 15F1 67 PUSH8 0xffffffffffffffff 15FA 92 SWAP3 15FB 83 DUP4 15FC 16 AND 15FD 60 PUSH1 0x00 15FF 19 NOT 1600 01 ADD 1601 83 DUP4 1602 16 AND 1603 17 OR 1604 90 SWAP1 1605 92 SWAP3 1606 55 SSTORE 1607 89 DUP10 1608 86 DUP7 1609 16 AND 160A 80 DUP1 160B 86 DUP7 160C 52 MSTORE 160D 83 DUP4 160E 86 DUP7 160F 20 SHA3 1610 80 DUP1 1611 54 SLOAD 1612 93 SWAP4 1613 84 DUP5 1614 16 AND 1615 93 SWAP4 1616 83 DUP4 1617 16 AND 1618 60 PUSH1 0x01 161A 90 SWAP1 161B 81 DUP2 161C 01 ADD 161D 84 DUP5 161E 16 AND 161F 94 SWAP5 1620 90 SWAP1 1621 94 SWAP5 1622 17 OR 1623 90 SWAP1 1624 55 SSTORE 1625 89 DUP10 1626 86 DUP7 1627 52 MSTORE 1628 60 PUSH1 0x04 162A 90 SWAP1 162B 94 SWAP5 162C 52 MSTORE 162D 82 DUP3 162E 85 DUP6 162F 20 SHA3 1630 80 DUP1 1631 54 SLOAD 1632 60 PUSH1 0x01 1634 60 PUSH1 0x01 1636 60 PUSH1 0xe0 1638 1B SHL 1639 03 SUB 163A 19 NOT 163B 16 AND 163C 90 SWAP1 163D 94 SWAP5 163E 17 OR 163F 60 PUSH1 0x01 1641 60 PUSH1 0xa0 1643 1B SHL 1644 42 TIMESTAMP 1645 90 SWAP1 1646 92 SWAP3 1647 16 AND 1648 91 SWAP2 1649 90 SWAP1 164A 91 SWAP2 164B 02 MUL 164C 17 OR 164D 83 DUP4 164E 55 SSTORE 164F 87 DUP8 1650 01 ADD 1651 80 DUP1 1652 84 DUP5 1653 52 MSTORE 1654 92 SWAP3 1655 20 SHA3 1656 80 DUP1 1657 54 SLOAD 1658 91 SWAP2 1659 93 SWAP4 165A 90 SWAP1 165B 91 SWAP2 165C 16 AND 165D 61 PUSH2 0x169b 1660 57 *JUMPI // Stack delta = +3 // Outputs[12] // { // @15D5 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @15DC memory[0x20:0x40] = 0x05 // @1606 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & ~0x00 + (0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @160C memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @1624 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & 0x01 + (0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @1627 memory[0x00:0x20] = stack[-3] // @162C memory[0x20:0x40] = 0x04 // @164E storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & block.timestamp) * (0x01 << 0xa0) | ((0x01 << 0xa0) - 0x01 & stack[-4]) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1653 memory[0x00:0x20] = stack[-3] + 0x01 // @1654 stack[1] = stack[-3] + 0x01 // @1659 stack[0] = keccak256(memory[0x00:0x40]) // @165B stack[2] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x169b, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 label_1661: // Incoming jump from 0x1660, if not storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1663 storage[0x00] // @1664 stack[-2] // } 1661 60 PUSH1 0x00 1663 54 SLOAD 1664 82 DUP3 1665 14 EQ 1666 61 PUSH2 0x169b 1669 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x169b, if stack[-2] == storage[0x00] label_166A: // Incoming jump from 0x1669, if not stack[-2] == storage[0x00] // Inputs[5] // { // @166A stack[-1] // @166B storage[stack[-1]] // @166E stack[-5] // @1670 memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @1695 stack[-8] // } 166A 80 DUP1 166B 54 SLOAD 166C 60 PUSH1 0x20 166E 86 DUP7 166F 01 ADD 1670 51 MLOAD 1671 67 PUSH8 0xffffffffffffffff 167A 16 AND 167B 60 PUSH1 0x01 167D 60 PUSH1 0xa0 167F 1B SHL 1680 02 MUL 1681 60 PUSH1 0x01 1683 60 PUSH1 0x01 1685 60 PUSH1 0xe0 1687 1B SHL 1688 03 SUB 1689 19 NOT 168A 90 SWAP1 168B 91 SWAP2 168C 16 AND 168D 60 PUSH1 0x01 168F 60 PUSH1 0x01 1691 60 PUSH1 0xa0 1693 1B SHL 1694 03 SUB 1695 8A DUP11 1696 16 AND 1697 17 OR 1698 17 OR 1699 81 DUP2 169A 55 SSTORE // Stack delta = +0 // Outputs[1] { @169A storage[stack[-1]] = (stack[-8] & (0x01 << 0xa0) - 0x01) | (storage[stack[-1]] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * (0xffffffffffffffff & memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20]) } // Block continues label_169B: // Incoming jump from 0x1669, if stack[-2] == storage[0x00] // Incoming jump from 0x1660, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x169A // Inputs[6] // { // @169F stack[-6] // @16A0 stack[-7] // @16AA stack[-8] // @16D7 memory[0x40:0x60] // @16DA memory[0x40:0x60] // @16DF memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // } 169B 5B JUMPDEST 169C 50 POP 169D 50 POP 169E 50 POP 169F 82 DUP3 16A0 84 DUP5 16A1 60 PUSH1 0x01 16A3 60 PUSH1 0x01 16A5 60 PUSH1 0xa0 16A7 1B SHL 16A8 03 SUB 16A9 16 AND 16AA 86 DUP7 16AB 60 PUSH1 0x01 16AD 60 PUSH1 0x01 16AF 60 PUSH1 0xa0 16B1 1B SHL 16B2 03 SUB 16B3 16 AND 16B4 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 16D5 60 PUSH1 0x40 16D7 51 MLOAD 16D8 60 PUSH1 0x40 16DA 51 MLOAD 16DB 80 DUP1 16DC 91 SWAP2 16DD 03 SUB 16DE 90 SWAP1 16DF A4 LOG4 16E0 61 PUSH2 0x1062 16E3 56 *JUMP // Stack delta = -3 // Outputs[1] { @16DF log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-8] & (0x01 << 0xa0) - 0x01, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-6]]); } // Block ends with unconditional jump to 0x1062 label_16E4: // Incoming call from 0x0AAC, returns to 0x0AAD // Inputs[1] { @16E7 storage[0x08] } 16E4 5B JUMPDEST 16E5 60 PUSH1 0x08 16E7 54 SLOAD 16E8 60 PUSH1 0xff 16EA 16 AND 16EB 61 PUSH2 0x172d 16EE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x172d, if 0xff & storage[0x08] label_16EF: // Incoming jump from 0x16EE, if not 0xff & storage[0x08] // Inputs[1] { @16F1 memory[0x40:0x60] } 16EF 60 PUSH1 0x40 16F1 51 MLOAD 16F2 62 PUSH3 0x461bcd 16F6 60 PUSH1 0xe5 16F8 1B SHL 16F9 81 DUP2 16FA 52 MSTORE 16FB 60 PUSH1 0x20 16FD 60 PUSH1 0x04 16FF 82 DUP3 1700 01 ADD 1701 52 MSTORE 1702 60 PUSH1 0x14 1704 60 PUSH1 0x24 1706 82 DUP3 1707 01 ADD 1708 52 MSTORE 1709 73 PUSH20 0x14185d5cd8589b194e881b9bdd081c185d5cd959 171E 60 PUSH1 0x62 1720 1B SHL 1721 60 PUSH1 0x44 1723 82 DUP3 1724 01 ADD 1725 52 MSTORE 1726 60 PUSH1 0x64 1728 01 ADD 1729 61 PUSH2 0x08f8 172C 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @16FA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1701 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1708 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @1725 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x14185d5cd8589b194e881b9bdd081c185d5cd959 << 0x62 // @1728 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f8 label_172D: // Incoming jump from 0x16EE, if 0xff & storage[0x08] // Inputs[6] // { // @1731 storage[0x08] // @1759 msg.sender // @175D memory[0x40:0x60] // @1770 memory[0x40:0x60] // @1775 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1776 stack[-1] // } 172D 5B JUMPDEST 172E 60 PUSH1 0x08 1730 80 DUP1 1731 54 SLOAD 1732 60 PUSH1 0xff 1734 19 NOT 1735 16 AND 1736 90 SWAP1 1737 55 SSTORE 1738 7F PUSH32 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa 1759 33 CALLER 175A 5B JUMPDEST 175B 60 PUSH1 0x40 175D 51 MLOAD 175E 60 PUSH1 0x01 1760 60 PUSH1 0x01 1762 60 PUSH1 0xa0 1764 1B SHL 1765 03 SUB 1766 90 SWAP1 1767 91 SWAP2 1768 16 AND 1769 81 DUP2 176A 52 MSTORE 176B 60 PUSH1 0x20 176D 01 ADD 176E 60 PUSH1 0x40 1770 51 MLOAD 1771 80 DUP1 1772 91 SWAP2 1773 03 SUB 1774 90 SWAP1 1775 A1 LOG1 1776 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1737 storage[0x08] = ~0xff & storage[0x08] // @176A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.sender & (0x01 << 0xa0) - 0x01 // @1775 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa]); // } // Block ends with unconditional jump to stack[-1] label_1777: // Incoming call from 0x0B17, returns to 0x0B18 // Incoming call from 0x14F4, returns to 0x14F5 // Inputs[3] // { // @177B memory[0x40:0x60] // @1795 stack[-1] // @1798 storage[0x00] // } 1777 5B JUMPDEST 1778 60 PUSH1 0x40 177A 80 DUP1 177B 51 MLOAD 177C 60 PUSH1 0x60 177E 81 DUP2 177F 01 ADD 1780 82 DUP3 1781 52 MSTORE 1782 60 PUSH1 0x00 1784 80 DUP1 1785 82 DUP3 1786 52 MSTORE 1787 60 PUSH1 0x20 1789 82 DUP3 178A 01 ADD 178B 81 DUP2 178C 90 SWAP1 178D 52 MSTORE 178E 91 SWAP2 178F 81 DUP2 1790 01 ADD 1791 91 SWAP2 1792 90 SWAP1 1793 91 SWAP2 1794 52 MSTORE 1795 81 DUP2 1796 60 PUSH1 0x00 1798 54 SLOAD 1799 81 DUP2 179A 10 LT 179B 15 ISZERO 179C 61 PUSH2 0x187a 179F 57 *JUMPI // Stack delta = +2 // Outputs[6] // { // @1781 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1786 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @178D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @1793 stack[0] = memory[0x40:0x60] // @1794 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @1795 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x187a, if !(stack[-1] < storage[0x00]) label_17A0: // Incoming jump from 0x179F, if not !(stack[-1] < storage[0x00]) // Inputs[4] // { // @17A2 stack[-1] // @17B1 memory[0x00:0x40] // @17B3 memory[0x40:0x60] // @17BB storage[keccak256(memory[0x00:0x40])] // } 17A0 60 PUSH1 0x00 17A2 81 DUP2 17A3 81 DUP2 17A4 52 MSTORE 17A5 60 PUSH1 0x04 17A7 60 PUSH1 0x20 17A9 90 SWAP1 17AA 81 DUP2 17AB 52 MSTORE 17AC 60 PUSH1 0x40 17AE 91 SWAP2 17AF 82 DUP3 17B0 90 SWAP1 17B1 20 SHA3 17B2 82 DUP3 17B3 51 MLOAD 17B4 60 PUSH1 0x60 17B6 81 DUP2 17B7 01 ADD 17B8 84 DUP5 17B9 52 MSTORE 17BA 90 SWAP1 17BB 54 SLOAD 17BC 60 PUSH1 0x01 17BE 60 PUSH1 0x01 17C0 60 PUSH1 0xa0 17C2 1B SHL 17C3 03 SUB 17C4 81 DUP2 17C5 16 AND 17C6 82 DUP3 17C7 52 MSTORE 17C8 60 PUSH1 0x01 17CA 60 PUSH1 0xa0 17CC 1B SHL 17CD 81 DUP2 17CE 04 DIV 17CF 67 PUSH8 0xffffffffffffffff 17D8 16 AND 17D9 92 SWAP3 17DA 82 DUP3 17DB 01 ADD 17DC 92 SWAP3 17DD 90 SWAP1 17DE 92 SWAP3 17DF 52 MSTORE 17E0 60 PUSH1 0x01 17E2 60 PUSH1 0xe0 17E4 1B SHL 17E5 90 SWAP1 17E6 91 SWAP2 17E7 04 DIV 17E8 60 PUSH1 0xff 17EA 16 AND 17EB 15 ISZERO 17EC 15 ISZERO 17ED 91 SWAP2 17EE 81 DUP2 17EF 01 ADD 17F0 82 DUP3 17F1 90 SWAP1 17F2 52 MSTORE 17F3 90 SWAP1 17F4 61 PUSH2 0x1878 17F7 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @17A4 memory[0x00:0x20] = stack[-1] // @17AB memory[0x20:0x40] = 0x04 // @17B9 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @17C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @17DF memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @17F2 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // @17F3 stack[0] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x1878, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) label_17F8: // Incoming jump from 0x17F7, if not !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // Inputs[2] // { // @17F8 stack[-1] // @17F9 memory[stack[-1]:stack[-1] + 0x20] // } 17F8 80 DUP1 17F9 51 MLOAD 17FA 60 PUSH1 0x01 17FC 60 PUSH1 0x01 17FE 60 PUSH1 0xa0 1800 1B SHL 1801 03 SUB 1802 16 AND 1803 15 ISZERO 1804 61 PUSH2 0x180e 1807 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x180e, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) label_1808: // Incoming jump from 0x1807, if not !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @1808 stack[-5] // @1808 stack[-1] // @1809 stack[-4] // } 1808 93 SWAP4 1809 92 SWAP3 180A 50 POP 180B 50 POP 180C 50 POP 180D 56 *JUMP // Stack delta = -4 // Outputs[1] { @1808 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_180E: // Incoming jump from 0x1877 // Incoming jump from 0x1807, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @1813 stack[-2] // @1825 memory[0x00:0x40] // @1827 memory[0x40:0x60] // @182F storage[keccak256(memory[0x00:0x40])] // } 180E 5B JUMPDEST 180F 50 POP 1810 60 PUSH1 0x00 1812 19 NOT 1813 01 ADD 1814 60 PUSH1 0x00 1816 81 DUP2 1817 81 DUP2 1818 52 MSTORE 1819 60 PUSH1 0x04 181B 60 PUSH1 0x20 181D 90 SWAP1 181E 81 DUP2 181F 52 MSTORE 1820 60 PUSH1 0x40 1822 91 SWAP2 1823 82 DUP3 1824 90 SWAP1 1825 20 SHA3 1826 82 DUP3 1827 51 MLOAD 1828 60 PUSH1 0x60 182A 81 DUP2 182B 01 ADD 182C 84 DUP5 182D 52 MSTORE 182E 90 SWAP1 182F 54 SLOAD 1830 60 PUSH1 0x01 1832 60 PUSH1 0x01 1834 60 PUSH1 0xa0 1836 1B SHL 1837 03 SUB 1838 81 DUP2 1839 16 AND 183A 80 DUP1 183B 83 DUP4 183C 52 MSTORE 183D 60 PUSH1 0x01 183F 60 PUSH1 0xa0 1841 1B SHL 1842 82 DUP3 1843 04 DIV 1844 67 PUSH8 0xffffffffffffffff 184D 16 AND 184E 93 SWAP4 184F 83 DUP4 1850 01 ADD 1851 93 SWAP4 1852 90 SWAP1 1853 93 SWAP4 1854 52 MSTORE 1855 60 PUSH1 0x01 1857 60 PUSH1 0xe0 1859 1B SHL 185A 90 SWAP1 185B 04 DIV 185C 60 PUSH1 0xff 185E 16 AND 185F 15 ISZERO 1860 15 ISZERO 1861 92 SWAP3 1862 81 DUP2 1863 01 ADD 1864 92 SWAP3 1865 90 SWAP1 1866 92 SWAP3 1867 52 MSTORE 1868 15 ISZERO 1869 61 PUSH2 0x1873 186C 57 *JUMPI // Stack delta = +0 // Outputs[8] // { // @1813 stack[-2] = ~0x00 + stack[-2] // @1818 memory[0x00:0x20] = ~0x00 + stack[-2] // @181F memory[0x20:0x40] = 0x04 // @182D memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @183C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @1854 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @1866 stack[-1] = memory[0x40:0x60] // @1867 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with conditional jump to 0x1873, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) label_186D: // Incoming jump from 0x186C, if not !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @186D stack[-5] // @186D stack[-1] // @186E stack[-4] // } 186D 93 SWAP4 186E 92 SWAP3 186F 50 POP 1870 50 POP 1871 50 POP 1872 56 *JUMP // Stack delta = -4 // Outputs[1] { @186D stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1873: // Incoming jump from 0x186C, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) 1873 5B JUMPDEST 1874 61 PUSH2 0x180e 1877 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x180e label_1878: // Incoming jump from 0x17F7, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) 1878 5B JUMPDEST 1879 50 POP // Stack delta = -1 // Block continues label_187A: // Incoming jump from 0x1879 // Incoming jump from 0x179F, if !(stack[-1] < storage[0x00]) // Inputs[3] // { // @187D memory[0x40:0x60] // @188D memory[0x40:0x60] // @1892 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 187A 5B JUMPDEST 187B 60 PUSH1 0x40 187D 51 MLOAD 187E 63 PUSH4 0x6f96cda1 1883 60 PUSH1 0xe1 1885 1B SHL 1886 81 DUP2 1887 52 MSTORE 1888 60 PUSH1 0x04 188A 01 ADD 188B 60 PUSH1 0x40 188D 51 MLOAD 188E 80 DUP1 188F 91 SWAP2 1890 03 SUB 1891 90 SWAP1 1892 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1887 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f96cda1 << 0xe1 // @1892 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1893: // Incoming call from 0x12DE, returns to 0x0A13 // Incoming call from 0x0BA7, returns to 0x0AAD // Inputs[5] // { // @1897 storage[0x08] // @18A0 stack[-1] // @18BB memory[0x40:0x60] // @18E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @18EC stack[-2] // } 1893 5B JUMPDEST 1894 60 PUSH1 0x08 1896 80 DUP1 1897 54 SLOAD 1898 60 PUSH1 0x01 189A 60 PUSH1 0x01 189C 60 PUSH1 0xa0 189E 1B SHL 189F 03 SUB 18A0 83 DUP4 18A1 81 DUP2 18A2 16 AND 18A3 61 PUSH2 0x0100 18A6 81 DUP2 18A7 81 DUP2 18A8 02 MUL 18A9 61 PUSH2 0x0100 18AC 60 PUSH1 0x01 18AE 60 PUSH1 0xa8 18B0 1B SHL 18B1 03 SUB 18B2 19 NOT 18B3 85 DUP6 18B4 16 AND 18B5 17 OR 18B6 90 SWAP1 18B7 94 SWAP5 18B8 55 SSTORE 18B9 60 PUSH1 0x40 18BB 51 MLOAD 18BC 93 SWAP4 18BD 90 SWAP1 18BE 92 SWAP3 18BF 04 DIV 18C0 16 AND 18C1 91 SWAP2 18C2 82 DUP3 18C3 90 SWAP1 18C4 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 18E5 90 SWAP1 18E6 60 PUSH1 0x00 18E8 90 SWAP1 18E9 A3 LOG3 18EA 50 POP 18EB 50 POP 18EC 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @18B8 storage[0x08] = (storage[0x08] & ~((0x01 << 0xa8) - 0x0100)) | 0x0100 * (stack[-1] & (0x01 << 0xa0) - 0x01) // @18E9 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_18ED: // Incoming call from 0x0C53, returns to 0x0AAD // Inputs[1] { @18F0 storage[0x08] } 18ED 5B JUMPDEST 18EE 60 PUSH1 0x08 18F0 54 SLOAD 18F1 60 PUSH1 0xff 18F3 16 AND 18F4 15 ISZERO 18F5 61 PUSH2 0x1933 18F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1933, if !(0xff & storage[0x08]) label_18F9: // Incoming jump from 0x18F8, if not !(0xff & storage[0x08]) // Inputs[1] { @18FB memory[0x40:0x60] } 18F9 60 PUSH1 0x40 18FB 51 MLOAD 18FC 62 PUSH3 0x461bcd 1900 60 PUSH1 0xe5 1902 1B SHL 1903 81 DUP2 1904 52 MSTORE 1905 60 PUSH1 0x20 1907 60 PUSH1 0x04 1909 82 DUP3 190A 01 ADD 190B 52 MSTORE 190C 60 PUSH1 0x10 190E 60 PUSH1 0x24 1910 82 DUP3 1911 01 ADD 1912 52 MSTORE 1913 6F PUSH16 0x14185d5cd8589b194e881c185d5cd959 1924 60 PUSH1 0x82 1926 1B SHL 1927 60 PUSH1 0x44 1929 82 DUP3 192A 01 ADD 192B 52 MSTORE 192C 60 PUSH1 0x64 192E 01 ADD 192F 61 PUSH2 0x08f8 1932 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1904 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @190B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1912 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @192B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x14185d5cd8589b194e881c185d5cd959 << 0x82 // @192E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f8 label_1933: // Incoming jump from 0x18F8, if !(0xff & storage[0x08]) // Inputs[2] // { // @1937 storage[0x08] // @1965 msg.sender // } 1933 5B JUMPDEST 1934 60 PUSH1 0x08 1936 80 DUP1 1937 54 SLOAD 1938 60 PUSH1 0xff 193A 19 NOT 193B 16 AND 193C 60 PUSH1 0x01 193E 17 OR 193F 90 SWAP1 1940 55 SSTORE 1941 7F PUSH32 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 1962 61 PUSH2 0x175a 1965 33 CALLER 1966 90 SWAP1 1967 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1940 storage[0x08] = 0x01 | (~0xff & storage[0x08]) // @1941 stack[0] = 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 // @1966 stack[1] = msg.sender // } // Block ends with unconditional jump to 0x175a label_1968: // Incoming jump from 0x0D50 // Incoming jump from 0x1204 // Inputs[3] // { // @1971 stack[-1] // @1980 memory[0x00:0x40] // @1981 storage[keccak256(memory[0x00:0x40])] // } 1968 5B JUMPDEST 1969 60 PUSH1 0x01 196B 60 PUSH1 0x01 196D 60 PUSH1 0xa0 196F 1B SHL 1970 03 SUB 1971 81 DUP2 1972 16 AND 1973 60 PUSH1 0x00 1975 90 SWAP1 1976 81 DUP2 1977 52 MSTORE 1978 60 PUSH1 0x16 197A 60 PUSH1 0x20 197C 52 MSTORE 197D 60 PUSH1 0x40 197F 90 SWAP1 1980 20 SHA3 1981 54 SLOAD 1982 60 PUSH1 0xff 1984 16 AND 1985 15 ISZERO 1986 61 PUSH2 0x19d1 1989 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1977 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @197C memory[0x20:0x40] = 0x16 // } // Block ends with conditional jump to 0x19d1, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_198A: // Incoming jump from 0x1989, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @198C memory[0x40:0x60] } 198A 60 PUSH1 0x40 198C 51 MLOAD 198D 62 PUSH3 0x461bcd 1991 60 PUSH1 0xe5 1993 1B SHL 1994 81 DUP2 1995 52 MSTORE 1996 60 PUSH1 0x20 1998 60 PUSH1 0x04 199A 82 DUP3 199B 01 ADD 199C 52 MSTORE 199D 60 PUSH1 0x1d 199F 60 PUSH1 0x24 19A1 82 DUP3 19A2 01 ADD 19A3 52 MSTORE 19A4 7F PUSH32 0x596f7520616c7265616479206d696e746564206279207374616b696e67000000 19C5 60 PUSH1 0x44 19C7 82 DUP3 19C8 01 ADD 19C9 52 MSTORE 19CA 60 PUSH1 0x64 19CC 01 ADD 19CD 61 PUSH2 0x08f8 19D0 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1995 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @199C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @19A3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1d // @19C9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x596f7520616c7265616479206d696e746564206279207374616b696e67000000 // @19CC stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f8 label_19D1: // Incoming jump from 0x1989, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[7] // { // @19DA stack[-1] // @19EB memory[0x00:0x40] // @19ED storage[keccak256(memory[0x00:0x40])] // @19F9 storage[0x15] // @19FB memory[0x40:0x60] // @1A25 memory[0x40:0x60] // @1A2C address(storage[0x15] / 0x0100 & (0x01 << 0xa0) - 0x01).code.length // } 19D1 5B JUMPDEST 19D2 60 PUSH1 0x01 19D4 60 PUSH1 0x01 19D6 60 PUSH1 0xa0 19D8 1B SHL 19D9 03 SUB 19DA 81 DUP2 19DB 81 DUP2 19DC 16 AND 19DD 60 PUSH1 0x00 19DF 81 DUP2 19E0 81 DUP2 19E1 52 MSTORE 19E2 60 PUSH1 0x16 19E4 60 PUSH1 0x20 19E6 52 MSTORE 19E7 60 PUSH1 0x40 19E9 80 DUP1 19EA 82 DUP3 19EB 20 SHA3 19EC 80 DUP1 19ED 54 SLOAD 19EE 60 PUSH1 0xff 19F0 19 NOT 19F1 16 AND 19F2 60 PUSH1 0x01 19F4 17 OR 19F5 90 SWAP1 19F6 55 SSTORE 19F7 60 PUSH1 0x15 19F9 54 SLOAD 19FA 90 SWAP1 19FB 51 MLOAD 19FC 63 PUSH4 0x6dcbf2a3 1A01 60 PUSH1 0xe0 1A03 1B SHL 1A04 81 DUP2 1A05 52 MSTORE 1A06 60 PUSH1 0x04 1A08 81 DUP2 1A09 01 ADD 1A0A 93 SWAP4 1A0B 90 SWAP1 1A0C 93 SWAP4 1A0D 52 MSTORE 1A0E 90 SWAP1 1A0F 92 SWAP3 1A10 61 PUSH2 0x0100 1A13 90 SWAP1 1A14 91 SWAP2 1A15 04 DIV 1A16 16 AND 1A17 90 SWAP1 1A18 63 PUSH4 0x6dcbf2a3 1A1D 90 SWAP1 1A1E 60 PUSH1 0x24 1A20 01 ADD 1A21 60 PUSH1 0x20 1A23 60 PUSH1 0x40 1A25 51 MLOAD 1A26 80 DUP1 1A27 83 DUP4 1A28 03 SUB 1A29 81 DUP2 1A2A 86 DUP7 1A2B 80 DUP1 1A2C 3B EXTCODESIZE 1A2D 15 ISZERO 1A2E 80 DUP1 1A2F 15 ISZERO 1A30 61 PUSH2 0x1a38 1A33 57 *JUMPI // Stack delta = +10 // Outputs[15] // { // @19E1 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @19E6 memory[0x20:0x40] = 0x16 // @19F6 storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @1A05 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6dcbf2a3 << 0xe0 // @1A0D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1A0F stack[0] = 0x00 // @1A17 stack[1] = storage[0x15] / 0x0100 & (0x01 << 0xa0) - 0x01 // @1A1D stack[2] = 0x6dcbf2a3 // @1A20 stack[3] = 0x24 + memory[0x40:0x60] // @1A21 stack[4] = 0x20 // @1A25 stack[5] = memory[0x40:0x60] // @1A28 stack[6] = (0x24 + memory[0x40:0x60]) - memory[0x40:0x60] // @1A29 stack[7] = memory[0x40:0x60] // @1A2A stack[8] = storage[0x15] / 0x0100 & (0x01 << 0xa0) - 0x01 // @1A2D stack[9] = !address(storage[0x15] / 0x0100 & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x1a38, if !!address(storage[0x15] / 0x0100 & (0x01 << 0xa0) - 0x01).code.length label_1A34: // Incoming jump from 0x1A33, if not !!address(storage[0x15] / 0x0100 & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @1A37 memory[0x00:0x00] } 1A34 60 PUSH1 0x00 1A36 80 DUP1 1A37 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A37 revert(memory[0x00:0x00]); } // Block terminates label_1A38: // Incoming jump from 0x1A33, if !!address(storage[0x15] / 0x0100 & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @1A3A msg.gas // @1A3B memory[stack[-3]:stack[-3] + stack[-4]] // @1A3B stack[-4] // @1A3B stack[-2] // @1A3B stack[-6] // @1A3B address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1A3B stack[-3] // @1A3B stack[-5] // } 1A38 5B JUMPDEST 1A39 50 POP 1A3A 5A GAS 1A3B FA STATICCALL 1A3C 15 ISZERO 1A3D 80 DUP1 1A3E 15 ISZERO 1A3F 61 PUSH2 0x1a4c 1A42 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1A3B memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1A3C stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1a4c, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1A43: // Incoming jump from 0x1A42, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1A43 returndata.length // @1A47 returndata[0x00:0x00 + returndata.length] // @1A48 returndata.length // @1A4B memory[0x00:0x00 + returndata.length] // } 1A43 3D RETURNDATASIZE 1A44 60 PUSH1 0x00 1A46 80 DUP1 1A47 3E RETURNDATACOPY 1A48 3D RETURNDATASIZE 1A49 60 PUSH1 0x00 1A4B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1A47 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1A4B revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1A4C: // Incoming jump from 0x1A42, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1A53 memory[0x40:0x60] // @1A54 returndata.length // } 1A4C 5B JUMPDEST 1A4D 50 POP 1A4E 50 POP 1A4F 50 POP 1A50 50 POP 1A51 60 PUSH1 0x40 1A53 51 MLOAD 1A54 3D RETURNDATASIZE 1A55 60 PUSH1 0x1f 1A57 19 NOT 1A58 60 PUSH1 0x1f 1A5A 82 DUP3 1A5B 01 ADD 1A5C 16 AND 1A5D 82 DUP3 1A5E 01 ADD 1A5F 80 DUP1 1A60 60 PUSH1 0x40 1A62 52 MSTORE 1A63 50 POP 1A64 81 DUP2 1A65 01 ADD 1A66 90 SWAP1 1A67 61 PUSH2 0x1a70 1A6A 91 SWAP2 1A6B 90 SWAP1 1A6C 61 PUSH2 0x2391 1A6F 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1A62 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @1A6A stack[-4] = 0x1a70 // @1A6B stack[-2] = memory[0x40:0x60] // @1A6B stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x2391, returns to 0x1A70 label_1A70: // Incoming return from call to 0x2391 at 0x1A6F // Inputs[2] // { // @1A71 stack[-1] // @1A71 stack[-2] // } 1A70 5B JUMPDEST 1A71 90 SWAP1 1A72 50 POP 1A73 60 PUSH1 0x00 1A75 81 DUP2 1A76 11 GT 1A77 61 PUSH2 0x1ac2 1A7A 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1A71 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1ac2, if stack[-1] > 0x00 label_1A7B: // Incoming jump from 0x1A7A, if not stack[-1] > 0x00 // Inputs[1] { @1A7D memory[0x40:0x60] } 1A7B 60 PUSH1 0x40 1A7D 51 MLOAD 1A7E 62 PUSH3 0x461bcd 1A82 60 PUSH1 0xe5 1A84 1B SHL 1A85 81 DUP2 1A86 52 MSTORE 1A87 60 PUSH1 0x20 1A89 60 PUSH1 0x04 1A8B 82 DUP3 1A8C 01 ADD 1A8D 52 MSTORE 1A8E 60 PUSH1 0x1b 1A90 60 PUSH1 0x24 1A92 82 DUP3 1A93 01 ADD 1A94 52 MSTORE 1A95 7F PUSH32 0x596f752068617665206e6f207374616b696e67207469636b6574730000000000 1AB6 60 PUSH1 0x44 1AB8 82 DUP3 1AB9 01 ADD 1ABA 52 MSTORE 1ABB 60 PUSH1 0x64 1ABD 01 ADD 1ABE 61 PUSH2 0x08f8 1AC1 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1A86 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1A8D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1A94 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1b // @1ABA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x596f752068617665206e6f207374616b696e67207469636b6574730000000000 // @1ABD stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f8 label_1AC2: // Incoming jump from 0x1A7A, if stack[-1] > 0x00 // Inputs[3] // { // @1AC5 storage[0x14] // @1AC6 stack[-1] // @1AC9 storage[0x13] // } 1AC2 5B JUMPDEST 1AC3 60 PUSH1 0x14 1AC5 54 SLOAD 1AC6 81 DUP2 1AC7 60 PUSH1 0x13 1AC9 54 SLOAD 1ACA 61 PUSH2 0x1ad3 1ACD 91 SWAP2 1ACE 90 SWAP1 1ACF 61 PUSH2 0x2507 1AD2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1AC5 stack[0] = storage[0x14] // @1ACD stack[1] = 0x1ad3 // @1ACE stack[2] = stack[-1] // @1ACE stack[3] = storage[0x13] // } // Block ends with call to 0x2507, returns to 0x1AD3 label_1AD3: // Incoming return from call to 0x2507 at 0x1AD2 // Inputs[2] // { // @1AD4 stack[-2] // @1AD4 stack[-1] // } 1AD3 5B JUMPDEST 1AD4 11 GT 1AD5 15 ISZERO 1AD6 61 PUSH2 0x1b21 1AD9 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1b21, if !(stack[-1] > stack[-2]) label_1ADA: // Incoming jump from 0x1AD9, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1ADC memory[0x40:0x60] } 1ADA 60 PUSH1 0x40 1ADC 51 MLOAD 1ADD 62 PUSH3 0x461bcd 1AE1 60 PUSH1 0xe5 1AE3 1B SHL 1AE4 81 DUP2 1AE5 52 MSTORE 1AE6 60 PUSH1 0x20 1AE8 60 PUSH1 0x04 1AEA 82 DUP3 1AEB 01 ADD 1AEC 52 MSTORE 1AED 60 PUSH1 0x1b 1AEF 60 PUSH1 0x24 1AF1 82 DUP3 1AF2 01 ADD 1AF3 52 MSTORE 1AF4 7F PUSH32 0x45786365656473206d6178696d756d204c414e4420737570706c790000000000 1B15 60 PUSH1 0x44 1B17 82 DUP3 1B18 01 ADD 1B19 52 MSTORE 1B1A 60 PUSH1 0x64 1B1C 01 ADD 1B1D 61 PUSH2 0x08f8 1B20 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1AE5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1AEC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1AF3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1b // @1B19 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45786365656473206d6178696d756d204c414e4420737570706c790000000000 // @1B1C stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08f8 label_1B21: // Incoming jump from 0x1AD9, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @1B22 stack[-1] // @1B29 storage[0x13] // } 1B21 5B JUMPDEST 1B22 80 DUP1 1B23 60 PUSH1 0x13 1B25 60 PUSH1 0x00 1B27 82 DUP3 1B28 82 DUP3 1B29 54 SLOAD 1B2A 61 PUSH2 0x14c7 1B2D 91 SWAP2 1B2E 90 SWAP1 1B2F 61 PUSH2 0x2507 1B32 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1B22 stack[0] = stack[-1] // @1B23 stack[1] = 0x13 // @1B25 stack[2] = 0x00 // @1B2D stack[3] = 0x14c7 // @1B2E stack[4] = stack[-1] // @1B2E stack[5] = storage[0x13] // } // Block ends with call to 0x2507, returns to 0x14C7 label_1B33: // Incoming jump from 0x0E70 // Incoming jump from 0x1F3F // Inputs[6] // { // @1B36 memory[0x40:0x60] // @1B4C stack[-3] // @1B59 msg.sender // @1B5B stack[-4] // @1B5D stack[-2] // @1B5F stack[-1] // } 1B33 5B JUMPDEST 1B34 60 PUSH1 0x40 1B36 51 MLOAD 1B37 63 PUSH4 0x0a85bd01 1B3C 60 PUSH1 0xe1 1B3E 1B SHL 1B3F 81 DUP2 1B40 52 MSTORE 1B41 60 PUSH1 0x00 1B43 90 SWAP1 1B44 60 PUSH1 0x01 1B46 60 PUSH1 0x01 1B48 60 PUSH1 0xa0 1B4A 1B SHL 1B4B 03 SUB 1B4C 85 DUP6 1B4D 16 AND 1B4E 90 SWAP1 1B4F 63 PUSH4 0x150b7a02 1B54 90 SWAP1 1B55 61 PUSH2 0x1b68 1B58 90 SWAP1 1B59 33 CALLER 1B5A 90 SWAP1 1B5B 89 DUP10 1B5C 90 SWAP1 1B5D 88 DUP9 1B5E 90 SWAP1 1B5F 88 DUP9 1B60 90 SWAP1 1B61 60 PUSH1 0x04 1B63 01 ADD 1B64 61 PUSH2 0x2482 1B67 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @1B40 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @1B43 stack[0] = 0x00 // @1B4E stack[1] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1B54 stack[2] = 0x150b7a02 // @1B58 stack[3] = 0x1b68 // @1B5A stack[4] = msg.sender // @1B5C stack[5] = stack[-4] // @1B5E stack[6] = stack[-2] // @1B60 stack[7] = stack[-1] // @1B63 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2482, returns to 0x1B68 label_1B68: // Incoming return from call to 0x2482 at 0x1B67 // Inputs[4] // { // @1B6D memory[0x40:0x60] // @1B6F stack[-1] // @1B74 stack[-3] // @1B76 address(stack[-3]).code.length // } 1B68 5B JUMPDEST 1B69 60 PUSH1 0x20 1B6B 60 PUSH1 0x40 1B6D 51 MLOAD 1B6E 80 DUP1 1B6F 83 DUP4 1B70 03 SUB 1B71 81 DUP2 1B72 60 PUSH1 0x00 1B74 87 DUP8 1B75 80 DUP1 1B76 3B EXTCODESIZE 1B77 15 ISZERO 1B78 80 DUP1 1B79 15 ISZERO 1B7A 61 PUSH2 0x1b82 1B7D 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @1B69 stack[0] = 0x20 // @1B6D stack[1] = memory[0x40:0x60] // @1B70 stack[2] = stack[-1] - memory[0x40:0x60] // @1B71 stack[3] = memory[0x40:0x60] // @1B72 stack[4] = 0x00 // @1B74 stack[5] = stack[-3] // @1B77 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x1b82, if !!address(stack[-3]).code.length label_1B7E: // Incoming jump from 0x1B7D, if not !!address(stack[-3]).code.length // Inputs[1] { @1B81 memory[0x00:0x00] } 1B7E 60 PUSH1 0x00 1B80 80 DUP1 1B81 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B81 revert(memory[0x00:0x00]); } // Block terminates label_1B82: // Incoming jump from 0x1B7D, if !!address(stack[-3]).code.length // Inputs[10] // { // @1B84 msg.gas // @1B85 stack[-4] // @1B85 stack[-7] // @1B85 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1B85 stack[-6] // @1B85 memory[stack[-4]:stack[-4] + stack[-5]] // @1B85 stack[-3] // @1B85 stack[-2] // @1B85 stack[-5] // @1B86 stack[-10] // } 1B82 5B JUMPDEST 1B83 50 POP 1B84 5A GAS 1B85 F1 CALL 1B86 92 SWAP3 1B87 50 POP 1B88 50 POP 1B89 50 POP 1B8A 80 DUP1 1B8B 15 ISZERO 1B8C 61 PUSH2 0x1bb2 1B8F 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @1B85 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1B86 stack[-10] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1bb2, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1B90: // Incoming jump from 0x1B8F, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1B94 memory[0x40:0x60] // @1B97 returndata.length // } 1B90 50 POP 1B91 60 PUSH1 0x40 1B93 80 DUP1 1B94 51 MLOAD 1B95 60 PUSH1 0x1f 1B97 3D RETURNDATASIZE 1B98 90 SWAP1 1B99 81 DUP2 1B9A 01 ADD 1B9B 60 PUSH1 0x1f 1B9D 19 NOT 1B9E 16 AND 1B9F 82 DUP3 1BA0 01 ADD 1BA1 90 SWAP1 1BA2 92 SWAP3 1BA3 52 MSTORE 1BA4 61 PUSH2 0x1baf 1BA7 91 SWAP2 1BA8 81 DUP2 1BA9 01 ADD 1BAA 90 SWAP1 1BAB 61 PUSH2 0x232f 1BAE 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1BA3 memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @1BA7 stack[-1] = 0x1baf // @1BAA stack[1] = memory[0x40:0x60] // @1BAA stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x232f 1BAF 5B JUMPDEST 1BB0 60 PUSH1 0x01 label_1BB2: // Incoming jump from 0x1B8F, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @1BB6 stack[-1] } 1BB2 5B JUMPDEST 1BB3 61 PUSH2 0x1c0d 1BB6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1c0d, if stack[-1] label_1BB7: // Incoming jump from 0x1BB6, if not stack[-1] // Inputs[1] { @1BB7 returndata.length } 1BB7 3D RETURNDATASIZE 1BB8 80 DUP1 1BB9 80 DUP1 1BBA 15 ISZERO 1BBB 61 PUSH2 0x1be0 1BBE 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1BB7 stack[0] = returndata.length // @1BB8 stack[1] = returndata.length // } // Block ends with conditional jump to 0x1be0, if !returndata.length label_1BBF: // Incoming jump from 0x1BBE, if not !returndata.length // Inputs[6] // { // @1BC1 memory[0x40:0x60] // @1BC2 stack[-2] // @1BC9 returndata.length // @1BD1 returndata.length // @1BD4 returndata.length // @1BDB returndata[0x00:0x00 + returndata.length] // } 1BBF 60 PUSH1 0x40 1BC1 51 MLOAD 1BC2 91 SWAP2 1BC3 50 POP 1BC4 60 PUSH1 0x1f 1BC6 19 NOT 1BC7 60 PUSH1 0x3f 1BC9 3D RETURNDATASIZE 1BCA 01 ADD 1BCB 16 AND 1BCC 82 DUP3 1BCD 01 ADD 1BCE 60 PUSH1 0x40 1BD0 52 MSTORE 1BD1 3D RETURNDATASIZE 1BD2 82 DUP3 1BD3 52 MSTORE 1BD4 3D RETURNDATASIZE 1BD5 60 PUSH1 0x00 1BD7 60 PUSH1 0x20 1BD9 84 DUP5 1BDA 01 ADD 1BDB 3E RETURNDATACOPY 1BDC 61 PUSH2 0x1be5 1BDF 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1BC2 stack[-2] = memory[0x40:0x60] // @1BD0 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1BD3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1BDB memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1be5 label_1BE0: // Incoming jump from 0x1BBE, if !returndata.length // Inputs[2] // { // @1BE3 stack[-2] // @1BE8 memory[0x60:0x80] // } 1BE0 5B JUMPDEST 1BE1 60 PUSH1 0x60 1BE3 91 SWAP2 1BE4 50 POP 1BE5 5B JUMPDEST 1BE6 50 POP 1BE7 80 DUP1 1BE8 51 MLOAD 1BE9 61 PUSH2 0x1c05 1BEC 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1BE3 stack[-2] = 0x60 } // Block ends with conditional jump to 0x1c05, if memory[0x60:0x80] label_1BED: // Incoming jump from 0x1BEC, if not memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1BEC, if not memory[0x60:0x80] // Inputs[3] // { // @1BEF memory[0x40:0x60] // @1BFF memory[0x40:0x60] // @1C04 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1BED 60 PUSH1 0x40 1BEF 51 MLOAD 1BF0 63 PUSH4 0x68d2bf6b 1BF5 60 PUSH1 0xe1 1BF7 1B SHL 1BF8 81 DUP2 1BF9 52 MSTORE 1BFA 60 PUSH1 0x04 1BFC 01 ADD 1BFD 60 PUSH1 0x40 1BFF 51 MLOAD 1C00 80 DUP1 1C01 91 SWAP2 1C02 03 SUB 1C03 90 SWAP1 1C04 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1BF9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x68d2bf6b << 0xe1 // @1C04 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1C05: // Incoming jump from 0x1BEC, if memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1BEC, if memory[0x60:0x80] // Inputs[3] // { // @1C06 stack[-1] // @1C07 memory[stack[-1]:stack[-1] + 0x20] // @1C0C memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 1C05 5B JUMPDEST 1C06 80 DUP1 1C07 51 MLOAD 1C08 81 DUP2 1C09 60 PUSH1 0x20 1C0B 01 ADD 1C0C FD *REVERT // Stack delta = +0 // Outputs[1] { @1C0C revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_1C0D: // Incoming jump from 0x1BB6, if stack[-1] // Inputs[2] // { // @1C17 stack[-1] // @1C21 stack[-2] // } 1C0D 5B JUMPDEST 1C0E 60 PUSH1 0x01 1C10 60 PUSH1 0x01 1C12 60 PUSH1 0xe0 1C14 1B SHL 1C15 03 SUB 1C16 19 NOT 1C17 16 AND 1C18 63 PUSH4 0x0a85bd01 1C1D 60 PUSH1 0xe1 1C1F 1B SHL 1C20 14 EQ 1C21 90 SWAP1 1C22 50 POP // Stack delta = -1 // Outputs[1] { @1C21 stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block continues label_1C23: // Incoming return from call to 0x2106 at 0x2390 // Incoming jump from 0x1C22 // Inputs[3] // { // @1C24 stack[-1] // @1C24 stack[-6] // @1C25 stack[-5] // } 1C23 5B JUMPDEST 1C24 94 SWAP5 1C25 93 SWAP4 1C26 50 POP 1C27 50 POP 1C28 50 POP 1C29 50 POP 1C2A 56 *JUMP // Stack delta = -5 // Outputs[1] { @1C24 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1C2B: // Incoming call from 0x0EE2, returns to 0x0EE3 // Inputs[1] { @1C35 stack[-1] } 1C2B 5B JUMPDEST 1C2C 60 PUSH1 0x00 1C2E 80 DUP1 1C2F 61 PUSH2 0x1c3a 1C32 61 PUSH2 0x0100 1C35 84 DUP5 1C36 61 PUSH2 0x251f 1C39 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1C2C stack[0] = 0x00 // @1C2E stack[1] = 0x00 // @1C2F stack[2] = 0x1c3a // @1C32 stack[3] = 0x0100 // @1C35 stack[4] = stack[-1] // } // Block ends with call to 0x251f, returns to 0x1C3A label_1C3A: // Incoming return from call to 0x251F at 0x1C39 // Inputs[3] // { // @1C3B stack[-2] // @1C3B stack[-1] // @1C45 stack[-4] // } 1C3A 5B JUMPDEST 1C3B 90 SWAP1 1C3C 50 POP 1C3D 60 PUSH1 0x00 1C3F 61 PUSH2 0x1c4a 1C42 61 PUSH2 0x0100 1C45 85 DUP6 1C46 61 PUSH2 0x25eb 1C49 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1C3B stack[-2] = stack[-1] // @1C3D stack[-1] = 0x00 // @1C3F stack[0] = 0x1c4a // @1C42 stack[1] = 0x0100 // @1C45 stack[2] = stack[-4] // } // Block ends with call to 0x25eb, returns to 0x1C4A label_1C4A: // Incoming return from call to 0x25EB at 0x1C49 // Inputs[7] // { // @1C4D stack[-3] // @1C57 stack[-1] // @1C59 memory[0x00:0x40] // @1C5A storage[keccak256(memory[0x00:0x40])] // @1C63 stack[-2] // @1C66 stack[-6] // @1C67 stack[-5] // } 1C4A 5B JUMPDEST 1C4B 60 PUSH1 0x00 1C4D 92 SWAP3 1C4E 83 DUP4 1C4F 52 MSTORE 1C50 60 PUSH1 0x0e 1C52 60 PUSH1 0x20 1C54 52 MSTORE 1C55 60 PUSH1 0x40 1C57 90 SWAP1 1C58 92 SWAP3 1C59 20 SHA3 1C5A 54 SLOAD 1C5B 60 PUSH1 0x01 1C5D 90 SWAP1 1C5E 92 SWAP3 1C5F 1B SHL 1C60 91 SWAP2 1C61 82 DUP3 1C62 16 AND 1C63 90 SWAP1 1C64 91 SWAP2 1C65 14 EQ 1C66 93 SWAP4 1C67 92 SWAP3 1C68 50 POP 1C69 50 POP 1C6A 50 POP 1C6B 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @1C4F memory[0x00:0x20] = stack[-3] // @1C54 memory[0x20:0x40] = 0x0e // @1C66 stack[-6] = 0x01 << stack[-1] == (0x01 << stack[-1]) & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-6] label_1C6C: // Incoming call from 0x1012, returns to 0x1013 // Inputs[3] // { // @1C6F stack[-2] // @1C73 stack[-3] // @1C74 stack[-1] // } 1C6C 5B JUMPDEST 1C6D 60 PUSH1 0x00 1C6F 82 DUP3 1C70 61 PUSH2 0x1c79 1C73 85 DUP6 1C74 84 DUP5 1C75 61 PUSH2 0x1feb 1C78 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1C6D stack[0] = 0x00 // @1C6F stack[1] = stack[-2] // @1C70 stack[2] = 0x1c79 // @1C73 stack[3] = stack[-3] // @1C74 stack[4] = stack[-1] // } // Block ends with call to 0x1feb, returns to 0x1C79 label_1C79: // Incoming return from call to 0x1FEB at 0x1C78 // Inputs[4] // { // @1C7A stack[-2] // @1C7A stack[-1] // @1C7B stack[-7] // @1C7C stack[-6] // } 1C79 5B JUMPDEST 1C7A 14 EQ 1C7B 94 SWAP5 1C7C 93 SWAP4 1C7D 50 POP 1C7E 50 POP 1C7F 50 POP 1C80 50 POP 1C81 56 *JUMP // Stack delta = -6 // Outputs[1] { @1C7B stack[-7] = stack[-1] == stack[-2] } // Block ends with unconditional jump to stack[-7] label_1C82: // Incoming call from 0x1057, returns to 0x1058 // Inputs[1] { @1C8B stack[-1] } 1C82 5B JUMPDEST 1C83 60 PUSH1 0x00 1C85 61 PUSH2 0x1c90 1C88 61 PUSH2 0x0100 1C8B 83 DUP4 1C8C 61 PUSH2 0x251f 1C8F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C83 stack[0] = 0x00 // @1C85 stack[1] = 0x1c90 // @1C88 stack[2] = 0x0100 // @1C8B stack[3] = stack[-1] // } // Block ends with call to 0x251f, returns to 0x1C90 label_1C90: // Incoming return from call to 0x251F at 0x1C8F // Inputs[3] // { // @1C91 stack[-1] // @1C91 stack[-2] // @1C9B stack[-3] // } 1C90 5B JUMPDEST 1C91 90 SWAP1 1C92 50 POP 1C93 60 PUSH1 0x00 1C95 61 PUSH2 0x1ca0 1C98 61 PUSH2 0x0100 1C9B 84 DUP5 1C9C 61 PUSH2 0x25eb 1C9F 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1C91 stack[-2] = stack[-1] // @1C93 stack[-1] = 0x00 // @1C95 stack[0] = 0x1ca0 // @1C98 stack[1] = 0x0100 // @1C9B stack[2] = stack[-3] // } // Block ends with call to 0x25eb, returns to 0x1CA0 label_1CA0: // Incoming return from call to 0x25EB at 0x1C9F // Inputs[6] // { // @1CA3 stack[-3] // @1CAD stack[-1] // @1CAF memory[0x00:0x40] // @1CB1 storage[keccak256(memory[0x00:0x40])] // @1CBA stack[-2] // @1CBF stack[-5] // } 1CA0 5B JUMPDEST 1CA1 60 PUSH1 0x00 1CA3 92 SWAP3 1CA4 83 DUP4 1CA5 52 MSTORE 1CA6 60 PUSH1 0x0e 1CA8 60 PUSH1 0x20 1CAA 52 MSTORE 1CAB 60 PUSH1 0x40 1CAD 90 SWAP1 1CAE 92 SWAP3 1CAF 20 SHA3 1CB0 80 DUP1 1CB1 54 SLOAD 1CB2 60 PUSH1 0x01 1CB4 90 SWAP1 1CB5 93 SWAP4 1CB6 1B SHL 1CB7 90 SWAP1 1CB8 92 SWAP3 1CB9 17 OR 1CBA 90 SWAP1 1CBB 91 SWAP2 1CBC 55 SSTORE 1CBD 50 POP 1CBE 50 POP 1CBF 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @1CA5 memory[0x00:0x20] = stack[-3] // @1CAA memory[0x20:0x40] = 0x0e // @1CBC storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] | (0x01 << stack[-1]) // } // Block ends with unconditional jump to stack[-5] label_1CC0: // Incoming jump from 0x109A // Inputs[1] { @1CC6 storage[0x09] } 1CC0 5B JUMPDEST 1CC1 60 PUSH1 0x60 1CC3 60 PUSH1 0x09 1CC5 80 DUP1 1CC6 54 SLOAD 1CC7 61 PUSH2 0x0773 1CCA 90 SWAP1 1CCB 61 PUSH2 0x2595 1CCE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1CC1 stack[0] = 0x60 // @1CC3 stack[1] = 0x09 // @1CCA stack[2] = 0x0773 // @1CCA stack[3] = storage[0x09] // } // Block ends with call to 0x2595, returns to 0x0773 1CCF 5B JUMPDEST 1CD0 60 PUSH1 0x60 1CD2 81 DUP2 1CD3 61 PUSH2 0x1cf3 1CD6 57 *JUMPI 1CD7 50 POP 1CD8 50 POP 1CD9 60 PUSH1 0x40 1CDB 80 DUP1 1CDC 51 MLOAD 1CDD 80 DUP1 1CDE 82 DUP3 1CDF 01 ADD 1CE0 90 SWAP1 1CE1 91 SWAP2 1CE2 52 MSTORE 1CE3 60 PUSH1 0x01 1CE5 81 DUP2 1CE6 52 MSTORE 1CE7 60 PUSH1 0x03 1CE9 60 PUSH1 0xfc 1CEB 1B SHL 1CEC 60 PUSH1 0x20 1CEE 82 DUP3 1CEF 01 ADD 1CF0 52 MSTORE 1CF1 90 SWAP1 1CF2 56 *JUMP 1CF3 5B JUMPDEST 1CF4 81 DUP2 1CF5 60 PUSH1 0x00 1CF7 5B JUMPDEST 1CF8 81 DUP2 1CF9 15 ISZERO 1CFA 61 PUSH2 0x1d1d 1CFD 57 *JUMPI 1CFE 80 DUP1 1CFF 61 PUSH2 0x1d07 1D02 81 DUP2 1D03 61 PUSH2 0x25d0 1D06 56 *JUMP 1D07 5B JUMPDEST 1D08 91 SWAP2 1D09 50 POP 1D0A 61 PUSH2 0x1d16 1D0D 90 SWAP1 1D0E 50 POP 1D0F 60 PUSH1 0x0a 1D11 83 DUP4 1D12 61 PUSH2 0x251f 1D15 56 *JUMP 1D16 5B JUMPDEST 1D17 91 SWAP2 1D18 50 POP 1D19 61 PUSH2 0x1cf7 1D1C 56 *JUMP 1D1D 5B JUMPDEST 1D1E 60 PUSH1 0x00 1D20 81 DUP2 1D21 67 PUSH8 0xffffffffffffffff 1D2A 81 DUP2 1D2B 11 GT 1D2C 15 ISZERO 1D2D 61 PUSH2 0x1d46 1D30 57 *JUMPI 1D31 63 PUSH4 0x4e487b71 1D36 60 PUSH1 0xe0 1D38 1B SHL 1D39 60 PUSH1 0x00 1D3B 52 MSTORE 1D3C 60 PUSH1 0x41 1D3E 60 PUSH1 0x04 1D40 52 MSTORE 1D41 60 PUSH1 0x24 1D43 60 PUSH1 0x00 1D45 FD *REVERT 1D46 5B JUMPDEST 1D47 60 PUSH1 0x40 1D49 51 MLOAD 1D4A 90 SWAP1 1D4B 80 DUP1 1D4C 82 DUP3 1D4D 52 MSTORE 1D4E 80 DUP1 1D4F 60 PUSH1 0x1f 1D51 01 ADD 1D52 60 PUSH1 0x1f 1D54 19 NOT 1D55 16 AND 1D56 60 PUSH1 0x20 1D58 01 ADD 1D59 82 DUP3 1D5A 01 ADD 1D5B 60 PUSH1 0x40 1D5D 52 MSTORE 1D5E 80 DUP1 1D5F 15 ISZERO 1D60 61 PUSH2 0x1d70 1D63 57 *JUMPI 1D64 60 PUSH1 0x20 1D66 82 DUP3 1D67 01 ADD 1D68 81 DUP2 1D69 80 DUP1 1D6A 36 CALLDATASIZE 1D6B 83 DUP4 1D6C 37 CALLDATACOPY 1D6D 01 ADD 1D6E 90 SWAP1 1D6F 50 POP 1D70 5B JUMPDEST 1D71 50 POP 1D72 90 SWAP1 1D73 50 POP 1D74 5B JUMPDEST 1D75 84 DUP5 1D76 15 ISZERO 1D77 61 PUSH2 0x1c23 1D7A 57 *JUMPI 1D7B 61 PUSH2 0x1d85 1D7E 60 PUSH1 0x01 1D80 83 DUP4 1D81 61 PUSH2 0x2552 1D84 56 *JUMP 1D85 5B JUMPDEST 1D86 91 SWAP2 1D87 50 POP 1D88 61 PUSH2 0x1d92 1D8B 60 PUSH1 0x0a 1D8D 86 DUP7 1D8E 61 PUSH2 0x25eb 1D91 56 *JUMP 1D92 5B JUMPDEST 1D93 61 PUSH2 0x1d9d 1D96 90 SWAP1 1D97 60 PUSH1 0x30 1D99 61 PUSH2 0x2507 1D9C 56 *JUMP 1D9D 5B JUMPDEST 1D9E 60 PUSH1 0xf8 1DA0 1B SHL 1DA1 81 DUP2 1DA2 83 DUP4 1DA3 81 DUP2 1DA4 51 MLOAD 1DA5 81 DUP2 1DA6 10 LT 1DA7 61 PUSH2 0x1dc0 1DAA 57 *JUMPI 1DAB 63 PUSH4 0x4e487b71 1DB0 60 PUSH1 0xe0 1DB2 1B SHL 1DB3 60 PUSH1 0x00 1DB5 52 MSTORE 1DB6 60 PUSH1 0x32 1DB8 60 PUSH1 0x04 1DBA 52 MSTORE 1DBB 60 PUSH1 0x24 1DBD 60 PUSH1 0x00 1DBF FD *REVERT 1DC0 5B JUMPDEST 1DC1 60 PUSH1 0x20 1DC3 01 ADD 1DC4 01 ADD 1DC5 90 SWAP1 1DC6 60 PUSH1 0x01 1DC8 60 PUSH1 0x01 1DCA 60 PUSH1 0xf8 1DCC 1B SHL 1DCD 03 SUB 1DCE 19 NOT 1DCF 16 AND 1DD0 90 SWAP1 1DD1 81 DUP2 1DD2 60 PUSH1 0x00 1DD4 1A BYTE 1DD5 90 SWAP1 1DD6 53 MSTORE8 1DD7 50 POP 1DD8 61 PUSH2 0x1de2 1DDB 60 PUSH1 0x0a 1DDD 86 DUP7 1DDE 61 PUSH2 0x251f 1DE1 56 *JUMP 1DE2 5B JUMPDEST 1DE3 94 SWAP5 1DE4 50 POP 1DE5 61 PUSH2 0x1d74 1DE8 56 *JUMP label_1DE9: // Incoming call from 0x14E9, returns to 0x090B // Inputs[2] // { // @1DEC storage[0x00] // @1DF5 stack[-4] // } 1DE9 5B JUMPDEST 1DEA 60 PUSH1 0x00 1DEC 54 SLOAD 1DED 60 PUSH1 0x01 1DEF 60 PUSH1 0x01 1DF1 60 PUSH1 0xa0 1DF3 1B SHL 1DF4 03 SUB 1DF5 85 DUP6 1DF6 16 AND 1DF7 61 PUSH2 0x1e12 1DFA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1DEC stack[0] = storage[0x00] } // Block ends with conditional jump to 0x1e12, if stack[-4] & (0x01 << 0xa0) - 0x01 label_1DFB: // Incoming jump from 0x1DFA, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1DFD memory[0x40:0x60] // @1E0C memory[0x40:0x60] // @1E11 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1DFB 60 PUSH1 0x40 1DFD 51 MLOAD 1DFE 62 PUSH3 0x2e0763 1E02 60 PUSH1 0xe8 1E04 1B SHL 1E05 81 DUP2 1E06 52 MSTORE 1E07 60 PUSH1 0x04 1E09 01 ADD 1E0A 60 PUSH1 0x40 1E0C 51 MLOAD 1E0D 80 DUP1 1E0E 91 SWAP2 1E0F 03 SUB 1E10 90 SWAP1 1E11 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1E06 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e0763 << 0xe8 // @1E11 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1E12: // Incoming jump from 0x1DFA, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1E13 stack[-4] } 1E12 5B JUMPDEST 1E13 83 DUP4 1E14 61 PUSH2 0x1e30 1E17 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e30, if stack[-4] label_1E18: // Incoming jump from 0x1E17, if not stack[-4] // Inputs[3] // { // @1E1A memory[0x40:0x60] // @1E2A memory[0x40:0x60] // @1E2F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1E18 60 PUSH1 0x40 1E1A 51 MLOAD 1E1B 63 PUSH4 0xb562e8dd 1E20 60 PUSH1 0xe0 1E22 1B SHL 1E23 81 DUP2 1E24 52 MSTORE 1E25 60 PUSH1 0x04 1E27 01 ADD 1E28 60 PUSH1 0x40 1E2A 51 MLOAD 1E2B 80 DUP1 1E2C 91 SWAP2 1E2D 03 SUB 1E2E 90 SWAP1 1E2F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1E24 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd << 0xe0 // @1E2F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1E30: // Incoming jump from 0x1E17, if stack[-4] // Inputs[3] // { // @1E36 stack[-5] // @1E37 stack[-1] // @1E38 stack[-4] // } 1E30 5B JUMPDEST 1E31 61 PUSH2 0x1e3d 1E34 60 PUSH1 0x00 1E36 86 DUP7 1E37 83 DUP4 1E38 87 DUP8 1E39 61 PUSH2 0x1fc7 1E3C 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1E31 stack[0] = 0x1e3d // @1E34 stack[1] = 0x00 // @1E36 stack[2] = stack[-5] // @1E37 stack[3] = stack[-1] // @1E38 stack[4] = stack[-4] // } // Block ends with call to 0x1fc7, returns to 0x1E3D label_1E3D: // Incoming return from call to 0x1FC7 at 0x1E3C // Inputs[9] // { // @1E46 stack[-5] // @1E58 memory[0x00:0x40] // @1E5A storage[keccak256(memory[0x00:0x40])] // @1E7B stack[-4] // @1EAC stack[-1] // @1EB6 memory[0x00:0x40] // @1EB8 storage[keccak256(memory[0x00:0x40])] // @1ECB block.timestamp // @1EDA stack[-2] // } 1E3D 5B JUMPDEST 1E3E 60 PUSH1 0x01 1E40 60 PUSH1 0x01 1E42 60 PUSH1 0xa0 1E44 1B SHL 1E45 03 SUB 1E46 85 DUP6 1E47 16 AND 1E48 60 PUSH1 0x00 1E4A 81 DUP2 1E4B 81 DUP2 1E4C 52 MSTORE 1E4D 60 PUSH1 0x05 1E4F 60 PUSH1 0x20 1E51 90 SWAP1 1E52 81 DUP2 1E53 52 MSTORE 1E54 60 PUSH1 0x40 1E56 80 DUP1 1E57 83 DUP4 1E58 20 SHA3 1E59 80 DUP1 1E5A 54 SLOAD 1E5B 6F PUSH16 0xffffffffffffffffffffffffffffffff 1E6C 19 NOT 1E6D 81 DUP2 1E6E 16 AND 1E6F 67 PUSH8 0xffffffffffffffff 1E78 80 DUP1 1E79 83 DUP4 1E7A 16 AND 1E7B 8C DUP13 1E7C 01 ADD 1E7D 81 DUP2 1E7E 16 AND 1E7F 91 SWAP2 1E80 82 DUP3 1E81 17 OR 1E82 68 PUSH9 0x010000000000000000 1E8C 67 PUSH8 0xffffffffffffffff 1E95 19 NOT 1E96 90 SWAP1 1E97 94 SWAP5 1E98 16 AND 1E99 90 SWAP1 1E9A 92 SWAP3 1E9B 17 OR 1E9C 83 DUP4 1E9D 90 SWAP1 1E9E 04 DIV 1E9F 81 DUP2 1EA0 16 AND 1EA1 8C DUP13 1EA2 01 ADD 1EA3 81 DUP2 1EA4 16 AND 1EA5 90 SWAP1 1EA6 92 SWAP3 1EA7 02 MUL 1EA8 17 OR 1EA9 90 SWAP1 1EAA 91 SWAP2 1EAB 55 SSTORE 1EAC 85 DUP6 1EAD 84 DUP5 1EAE 52 MSTORE 1EAF 60 PUSH1 0x04 1EB1 90 SWAP1 1EB2 92 SWAP3 1EB3 52 MSTORE 1EB4 90 SWAP1 1EB5 91 SWAP2 1EB6 20 SHA3 1EB7 80 DUP1 1EB8 54 SLOAD 1EB9 60 PUSH1 0x01 1EBB 60 PUSH1 0x01 1EBD 60 PUSH1 0xe0 1EBF 1B SHL 1EC0 03 SUB 1EC1 19 NOT 1EC2 16 AND 1EC3 90 SWAP1 1EC4 92 SWAP3 1EC5 17 OR 1EC6 60 PUSH1 0x01 1EC8 60 PUSH1 0xa0 1ECA 1B SHL 1ECB 42 TIMESTAMP 1ECC 90 SWAP1 1ECD 92 SWAP3 1ECE 16 AND 1ECF 91 SWAP2 1ED0 90 SWAP1 1ED1 91 SWAP2 1ED2 02 MUL 1ED3 17 OR 1ED4 90 SWAP1 1ED5 55 SSTORE 1ED6 80 DUP1 1ED7 80 DUP1 1ED8 85 DUP6 1ED9 01 ADD 1EDA 83 DUP4 1EDB 80 DUP1 1EDC 15 ISZERO 1EDD 61 PUSH2 0x1eef 1EE0 57 *JUMPI // Stack delta = +3 // Outputs[9] // { // @1E4C memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @1E53 memory[0x20:0x40] = 0x05 // @1EAB storage[keccak256(memory[0x00:0x40])] = 0x010000000000000000 * (0xffffffffffffffff & stack[-4] + (0xffffffffffffffff & ((0xffffffffffffffff & stack[-4] + (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff)) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff)) / 0x010000000000000000)) | (0xffffffffffffffff & stack[-4] + (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff)) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffffffffffffffffffff) // @1EAE memory[0x00:0x20] = stack[-1] // @1EB3 memory[0x20:0x40] = 0x04 // @1ED5 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & block.timestamp) * (0x01 << 0xa0) | (stack[-5] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1ED6 stack[0] = stack[-1] // @1ED9 stack[1] = stack[-4] + stack[-1] // @1EDA stack[2] = stack[-2] // } // Block ends with conditional jump to 0x1eef, if !stack[-2] label_1EE1: // Incoming jump from 0x1EE0, if not !stack[-2] // Inputs[2] // { // @1EEA stack[-8] // @1EEC address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // } 1EE1 50 POP 1EE2 60 PUSH1 0x01 1EE4 60 PUSH1 0x01 1EE6 60 PUSH1 0xa0 1EE8 1B SHL 1EE9 03 SUB 1EEA 87 DUP8 1EEB 16 AND 1EEC 3B EXTCODESIZE 1EED 15 ISZERO 1EEE 15 ISZERO 1EEF 5B JUMPDEST 1EF0 15 ISZERO 1EF1 61 PUSH2 0x1f78 1EF4 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1f78, if !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length label_1EF5: // Incoming jump from 0x1EF4, if not !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Incoming jump from 0x1EF4, if not !stack[-1] // Inputs[5] // { // @1EF8 memory[0x40:0x60] // @1EF9 stack[-2] // @1F03 stack[-7] // @1F2D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1F3B stack[-5] // } 1EF5 5B JUMPDEST 1EF6 60 PUSH1 0x40 1EF8 51 MLOAD 1EF9 82 DUP3 1EFA 90 SWAP1 1EFB 60 PUSH1 0x01 1EFD 60 PUSH1 0x01 1EFF 60 PUSH1 0xa0 1F01 1B SHL 1F02 03 SUB 1F03 89 DUP10 1F04 16 AND 1F05 90 SWAP1 1F06 60 PUSH1 0x00 1F08 90 SWAP1 1F09 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1F2A 90 SWAP1 1F2B 82 DUP3 1F2C 90 SWAP1 1F2D A4 LOG4 1F2E 61 PUSH2 0x1f40 1F31 60 PUSH1 0x00 1F33 88 DUP9 1F34 84 DUP5 1F35 80 DUP1 1F36 60 PUSH1 0x01 1F38 01 ADD 1F39 95 SWAP6 1F3A 50 POP 1F3B 88 DUP9 1F3C 61 PUSH2 0x1b33 1F3F 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1F2D log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-2]]); // @1F2E stack[0] = 0x1f40 // @1F31 stack[1] = 0x00 // @1F33 stack[2] = stack[-7] // @1F34 stack[3] = stack[-2] // @1F39 stack[-2] = 0x01 + stack[-2] // @1F3B stack[4] = stack[-5] // } // Block ends with unconditional jump to 0x1b33 1F40 5B JUMPDEST 1F41 61 PUSH2 0x1f5d 1F44 57 *JUMPI 1F45 60 PUSH1 0x40 1F47 51 MLOAD 1F48 63 PUSH4 0x68d2bf6b 1F4D 60 PUSH1 0xe1 1F4F 1B SHL 1F50 81 DUP2 1F51 52 MSTORE 1F52 60 PUSH1 0x04 1F54 01 ADD 1F55 60 PUSH1 0x40 1F57 51 MLOAD 1F58 80 DUP1 1F59 91 SWAP2 1F5A 03 SUB 1F5B 90 SWAP1 1F5C FD *REVERT 1F5D 5B JUMPDEST 1F5E 80 DUP1 1F5F 82 DUP3 1F60 14 EQ 1F61 15 ISZERO 1F62 61 PUSH2 0x1ef5 1F65 57 *JUMPI 1F66 82 DUP3 1F67 60 PUSH1 0x00 1F69 54 SLOAD 1F6A 14 EQ 1F6B 61 PUSH2 0x1f73 1F6E 57 *JUMPI 1F6F 60 PUSH1 0x00 1F71 80 DUP1 1F72 FD *REVERT 1F73 5B JUMPDEST 1F74 61 PUSH2 0x1fbe 1F77 56 *JUMP label_1F78: // Incoming jump from 0x1EF4, if !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Incoming jump from 0x1EF4, if !stack[-1] // Inputs[5] // { // @1F7C memory[0x40:0x60] // @1F7F stack[-2] // @1F8B stack[-7] // @1FB5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1FB6 stack[-1] // } 1F78 5B JUMPDEST 1F79 5B JUMPDEST 1F7A 60 PUSH1 0x40 1F7C 51 MLOAD 1F7D 60 PUSH1 0x01 1F7F 83 DUP4 1F80 01 ADD 1F81 92 SWAP3 1F82 90 SWAP1 1F83 60 PUSH1 0x01 1F85 60 PUSH1 0x01 1F87 60 PUSH1 0xa0 1F89 1B SHL 1F8A 03 SUB 1F8B 89 DUP10 1F8C 16 AND 1F8D 90 SWAP1 1F8E 60 PUSH1 0x00 1F90 90 SWAP1 1F91 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1FB2 90 SWAP1 1FB3 82 DUP3 1FB4 90 SWAP1 1FB5 A4 LOG4 1FB6 80 DUP1 1FB7 82 DUP3 1FB8 14 EQ 1FB9 15 ISZERO 1FBA 61 PUSH2 0x1f79 1FBD 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1F81 stack[-2] = stack[-2] + 0x01 // @1FB5 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with conditional jump to 0x1f79, if !(stack[-2] + 0x01 == stack[-1]) label_1FBE: // Incoming jump from 0x1FBD, if not !(stack[-2] + 0x01 == stack[-1]) // Incoming jump from 0x1FBD, if not !(stack[-2] + 0x01 == stack[-1]) // Inputs[1] { @1FC2 stack[-2] } 1FBE 5B JUMPDEST 1FBF 50 POP 1FC0 60 PUSH1 0x00 1FC2 55 SSTORE 1FC3 61 PUSH2 0x1062 1FC6 56 *JUMP // Stack delta = -2 // Outputs[1] { @1FC2 storage[0x00] = stack[-2] } // Block ends with unconditional jump to 0x1062 label_1FC7: // Incoming call from 0x1E3C, returns to 0x1E3D // Incoming call from 0x15B8, returns to 0x15B9 // Inputs[1] { @1FCA storage[0x08] } 1FC7 5B JUMPDEST 1FC8 60 PUSH1 0x08 1FCA 54 SLOAD 1FCB 60 PUSH1 0xff 1FCD 16 AND 1FCE 15 ISZERO 1FCF 61 PUSH2 0x0e91 1FD2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e91, if !(0xff & storage[0x08]) label_1FD3: // Incoming jump from 0x1FD2, if not !(0xff & storage[0x08]) // Inputs[3] // { // @1FD5 memory[0x40:0x60] // @1FE5 memory[0x40:0x60] // @1FEA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1FD3 60 PUSH1 0x40 1FD5 51 MLOAD 1FD6 63 PUSH4 0xab35696f 1FDB 60 PUSH1 0xe0 1FDD 1B SHL 1FDE 81 DUP2 1FDF 52 MSTORE 1FE0 60 PUSH1 0x04 1FE2 01 ADD 1FE3 60 PUSH1 0x40 1FE5 51 MLOAD 1FE6 80 DUP1 1FE7 91 SWAP2 1FE8 03 SUB 1FE9 90 SWAP1 1FEA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1FDF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xab35696f << 0xe0 // @1FEA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1FEB: // Incoming call from 0x1C78, returns to 0x1C79 // Inputs[3] // { // @1FEE stack[-1] // @1FF1 stack[-2] // @1FF2 memory[stack[-2]:stack[-2] + 0x20] // } 1FEB 5B JUMPDEST 1FEC 60 PUSH1 0x00 1FEE 81 DUP2 1FEF 81 DUP2 1FF0 5B JUMPDEST 1FF1 84 DUP5 1FF2 51 MLOAD 1FF3 81 DUP2 1FF4 10 LT 1FF5 15 ISZERO 1FF6 61 PUSH2 0x2065 1FF9 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1FEC stack[0] = 0x00 // @1FEE stack[1] = stack[-1] // @1FEF stack[2] = 0x00 // } // Block ends with conditional jump to 0x2065, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_1FFA: // Incoming jump from 0x1FF9, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1FF9, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @1FFC stack[-5] // @1FFD stack[-1] // @1FFF memory[stack[-5]:stack[-5] + 0x20] // } 1FFA 60 PUSH1 0x00 1FFC 85 DUP6 1FFD 82 DUP3 1FFE 81 DUP2 1FFF 51 MLOAD 2000 81 DUP2 2001 10 LT 2002 61 PUSH2 0x201b 2005 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1FFA stack[0] = 0x00 // @1FFC stack[1] = stack[-5] // @1FFD stack[2] = stack[-1] // } // Block ends with conditional jump to 0x201b, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_2006: // Incoming jump from 0x2005, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[1] { @201A memory[0x00:0x24] } 2006 63 PUSH4 0x4e487b71 200B 60 PUSH1 0xe0 200D 1B SHL 200E 60 PUSH1 0x00 2010 52 MSTORE 2011 60 PUSH1 0x32 2013 60 PUSH1 0x04 2015 52 MSTORE 2016 60 PUSH1 0x24 2018 60 PUSH1 0x00 201A FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2010 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2015 memory[0x04:0x24] = 0x32 // @201A revert(memory[0x00:0x24]); // } // Block terminates label_201B: // Incoming jump from 0x2005, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[5] // { // @201E stack[-1] // @2022 stack[-2] // @2023 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2024 stack[-3] // @2027 stack[-5] // } 201B 5B JUMPDEST 201C 60 PUSH1 0x20 201E 02 MUL 201F 60 PUSH1 0x20 2021 01 ADD 2022 01 ADD 2023 51 MLOAD 2024 90 SWAP1 2025 50 POP 2026 80 DUP1 2027 83 DUP4 2028 11 GT 2029 61 PUSH2 0x2041 202C 57 *JUMPI // Stack delta = -2 // Outputs[1] { @2024 stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with conditional jump to 0x2041, if stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_202D: // Incoming jump from 0x202C, if not stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[3] // { // @202F stack[-3] // @2034 stack[-1] // @203A memory[0x00:0x40] // } 202D 60 PUSH1 0x00 202F 83 DUP4 2030 81 DUP2 2031 52 MSTORE 2032 60 PUSH1 0x20 2034 82 DUP3 2035 90 SWAP1 2036 52 MSTORE 2037 60 PUSH1 0x40 2039 90 SWAP1 203A 20 SHA3 203B 92 SWAP3 203C 50 POP 203D 61 PUSH2 0x2052 2040 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2031 memory[0x00:0x20] = stack[-3] // @2036 memory[0x20:0x40] = stack[-1] // @203B stack[-3] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to 0x2052 label_2041: // Incoming jump from 0x202C, if stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[4] // { // @2044 stack[-1] // @2049 stack[-3] // @204F memory[0x00:0x40] // @2054 stack[-2] // } 2041 5B JUMPDEST 2042 60 PUSH1 0x00 2044 81 DUP2 2045 81 DUP2 2046 52 MSTORE 2047 60 PUSH1 0x20 2049 84 DUP5 204A 90 SWAP1 204B 52 MSTORE 204C 60 PUSH1 0x40 204E 90 SWAP1 204F 20 SHA3 2050 92 SWAP3 2051 50 POP 2052 5B JUMPDEST 2053 50 POP 2054 80 DUP1 2055 61 PUSH2 0x205d 2058 81 DUP2 2059 61 PUSH2 0x25d0 205C 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @2046 memory[0x00:0x20] = stack[-1] // @204B memory[0x20:0x40] = stack[-3] // @2050 stack[-3] = keccak256(memory[0x00:0x40]) // @2054 stack[-1] = stack[-2] // @2055 stack[0] = 0x205d // @2058 stack[1] = stack[-2] // } // Block ends with call to 0x25d0, returns to 0x205D label_205D: // Incoming return from call to 0x25D0 at 0x205C // Incoming return from call to 0x25D0 at 0x205C // Inputs[2] // { // @205E stack[-1] // @205E stack[-3] // } 205D 5B JUMPDEST 205E 91 SWAP2 205F 50 POP 2060 50 POP 2061 61 PUSH2 0x1ff0 2064 56 *JUMP // Stack delta = -2 // Outputs[1] { @205E stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1ff0 label_2065: // Incoming jump from 0x1FF9, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1FF9, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @2067 stack[-6] // @2067 stack[-2] // @2068 stack[-5] // } 2065 5B JUMPDEST 2066 50 POP 2067 93 SWAP4 2068 92 SWAP3 2069 50 POP 206A 50 POP 206B 50 POP 206C 56 *JUMP // Stack delta = -5 // Outputs[1] { @2067 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_206D: // Incoming jump from 0x0B0C // Incoming jump from 0x0E45 // Incoming jump from 0x0ED9 // Inputs[2] // { // @206E stack[-3] // @2070 storage[stack[-3]] // } 206D 5B JUMPDEST 206E 82 DUP3 206F 80 DUP1 2070 54 SLOAD 2071 61 PUSH2 0x2079 2074 90 SWAP1 2075 61 PUSH2 0x2595 2078 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @206E stack[0] = stack[-3] // @2074 stack[1] = 0x2079 // @2074 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x2595, returns to 0x2079 label_2079: // Incoming return from call to 0x2595 at 0x2078 // Inputs[5] // { // @207A stack[-1] // @207A stack[-2] // @2082 memory[0x00:0x20] // @208D stack[-4] // @208E stack[-3] // } 2079 5B JUMPDEST 207A 90 SWAP1 207B 60 PUSH1 0x00 207D 52 MSTORE 207E 60 PUSH1 0x20 2080 60 PUSH1 0x00 2082 20 SHA3 2083 90 SWAP1 2084 60 PUSH1 0x1f 2086 01 ADD 2087 60 PUSH1 0x20 2089 90 SWAP1 208A 04 DIV 208B 81 DUP2 208C 01 ADD 208D 92 SWAP3 208E 82 DUP3 208F 61 PUSH2 0x209b 2092 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @207D memory[0x00:0x20] = stack[-2] // @2083 stack[-2] = keccak256(memory[0x00:0x20]) // @208D stack[-1] = stack[-4] // @208D stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x209b, if stack[-3] label_2093: // Incoming jump from 0x2092, if not stack[-3] // Inputs[1] { @2095 stack[-5] } 2093 60 PUSH1 0x00 2095 85 DUP6 2096 55 SSTORE 2097 61 PUSH2 0x20e1 209A 56 *JUMP // Stack delta = +0 // Outputs[1] { @2096 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x20e1 label_209B: // Incoming jump from 0x2092, if stack[-3] // Inputs[1] { @209C stack[-3] } 209B 5B JUMPDEST 209C 82 DUP3 209D 60 PUSH1 0x1f 209F 10 LT 20A0 61 PUSH2 0x20b4 20A3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x20b4, if 0x1f < stack[-3] label_20A4: // Incoming jump from 0x20A3, if not 0x1f < stack[-3] // Inputs[4] // { // @20A4 stack[-1] // @20A5 memory[stack[-1]:stack[-1] + 0x20] // @20AA stack[-3] // @20AE stack[-5] // } 20A4 80 DUP1 20A5 51 MLOAD 20A6 60 PUSH1 0xff 20A8 19 NOT 20A9 16 AND 20AA 83 DUP4 20AB 80 DUP1 20AC 01 ADD 20AD 17 OR 20AE 85 DUP6 20AF 55 SSTORE 20B0 61 PUSH2 0x20e1 20B3 56 *JUMP // Stack delta = +0 // Outputs[1] { @20AF storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x20e1 label_20B4: // Incoming jump from 0x20A3, if 0x1f < stack[-3] // Inputs[2] // { // @20B5 stack[-3] // @20BB stack[-5] // } 20B4 5B JUMPDEST 20B5 82 DUP3 20B6 80 DUP1 20B7 01 ADD 20B8 60 PUSH1 0x01 20BA 01 ADD 20BB 85 DUP6 20BC 55 SSTORE 20BD 82 DUP3 20BE 15 ISZERO 20BF 61 PUSH2 0x20e1 20C2 57 *JUMPI // Stack delta = +0 // Outputs[1] { @20BC storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x20e1, if !stack[-3] label_20C3: // Incoming jump from 0x20C2, if not !stack[-3] // Inputs[2] // { // @20C3 stack[-3] // @20C3 stack[-1] // } 20C3 91 SWAP2 20C4 82 DUP3 20C5 01 ADD 20C6 5B JUMPDEST 20C7 82 DUP3 20C8 81 DUP2 20C9 11 GT 20CA 15 ISZERO 20CB 61 PUSH2 0x20e1 20CE 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @20C3 stack[-3] = stack[-1] // @20C5 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x20e1, if !(stack[-1] + stack[-3] > stack[-1]) label_20CF: // Incoming jump from 0x20CE, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x20CE, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @20CF stack[-3] // @20D0 memory[stack[-3]:stack[-3] + 0x20] // @20D1 stack[-2] // @20D3 stack[-1] // } 20CF 82 DUP3 20D0 51 MLOAD 20D1 82 DUP3 20D2 55 SSTORE 20D3 91 SWAP2 20D4 60 PUSH1 0x20 20D6 01 ADD 20D7 91 SWAP2 20D8 90 SWAP1 20D9 60 PUSH1 0x01 20DB 01 ADD 20DC 90 SWAP1 20DD 61 PUSH2 0x20c6 20E0 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @20D2 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @20D7 stack[-3] = 0x20 + stack[-3] // @20DC stack[-2] = 0x01 + stack[-2] // @20DC stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x20c6 label_20E1: // Incoming jump from 0x209A // Incoming jump from 0x20CE, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x20C2, if !stack[-3] // Incoming jump from 0x20CE, if !(stack[-1] > stack[-3]) // Incoming jump from 0x20B3 // Inputs[2] // { // @20E6 stack[-4] // @20E7 stack[-3] // } 20E1 5B JUMPDEST 20E2 50 POP 20E3 61 PUSH2 0x20ed 20E6 92 SWAP3 20E7 91 SWAP2 20E8 50 POP 20E9 61 PUSH2 0x20f1 20EC 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @20E6 stack[-4] = 0x20ed // @20E7 stack[-3] = stack[-4] // } // Block ends with call to 0x20f1, returns to 0x20ED label_20ED: // Incoming jump from 0x20FA, if !(stack[-2] > stack[-1]) // Incoming jump from 0x20FA, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x20F1 at 0x20EC // Inputs[2] // { // @20EF stack[-2] // @20EF stack[-3] // } 20ED 5B JUMPDEST 20EE 50 POP 20EF 90 SWAP1 20F0 56 *JUMP // Stack delta = -2 // Outputs[1] { @20EF stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_20F1: // Incoming call from 0x20EC, returns to 0x20ED // Inputs[2] // { // @20F3 stack[-1] // @20F4 stack[-2] // } 20F1 5B JUMPDEST 20F2 5B JUMPDEST 20F3 80 DUP1 20F4 82 DUP3 20F5 11 GT 20F6 15 ISZERO 20F7 61 PUSH2 0x20ed 20FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x20ed, if !(stack[-2] > stack[-1]) label_20FB: // Incoming jump from 0x20FA, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x20FA, if not !(stack[-2] > stack[-1]) // Inputs[1] { @20FD stack[-1] } 20FB 60 PUSH1 0x00 20FD 81 DUP2 20FE 55 SSTORE 20FF 60 PUSH1 0x01 2101 01 ADD 2102 61 PUSH2 0x20f2 2105 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @20FE storage[stack[-1]] = 0x00 // @2101 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x20f2 label_2106: // Incoming call from 0x2390, returns to 0x1C23 // Incoming call from 0x228B, returns to 0x228C // Inputs[1] { @2113 stack[-2] } 2106 5B JUMPDEST 2107 60 PUSH1 0x00 2109 67 PUSH8 0xffffffffffffffff 2112 80 DUP1 2113 84 DUP5 2114 11 GT 2115 15 ISZERO 2116 61 PUSH2 0x2121 2119 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2107 stack[0] = 0x00 // @2109 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x2121, if !(stack[-2] > 0xffffffffffffffff) label_211A: // Incoming jump from 0x2119, if not !(stack[-2] > 0xffffffffffffffff) 211A 61 PUSH2 0x2121 211D 61 PUSH2 0x262b 2120 56 *JUMP // Stack delta = +1 // Outputs[1] { @211A stack[0] = 0x2121 } // Block ends with unconditional jump to 0x262b label_2121: // Incoming jump from 0x2119, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @2124 memory[0x40:0x60] // @2127 stack[-4] // @2136 stack[-1] // } 2121 5B JUMPDEST 2122 60 PUSH1 0x40 2124 51 MLOAD 2125 60 PUSH1 0x1f 2127 85 DUP6 2128 01 ADD 2129 60 PUSH1 0x1f 212B 19 NOT 212C 90 SWAP1 212D 81 DUP2 212E 16 AND 212F 60 PUSH1 0x3f 2131 01 ADD 2132 16 AND 2133 81 DUP2 2134 01 ADD 2135 90 SWAP1 2136 82 DUP3 2137 82 DUP3 2138 11 GT 2139 81 DUP2 213A 83 DUP4 213B 10 LT 213C 17 OR 213D 15 ISZERO 213E 61 PUSH2 0x2149 2141 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2135 stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @2135 stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x2149, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) label_2142: // Incoming jump from 0x2141, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) 2142 61 PUSH2 0x2149 2145 61 PUSH2 0x262b 2148 56 *JUMP // Stack delta = +1 // Outputs[1] { @2142 stack[0] = 0x2149 } // Block ends with unconditional jump to 0x262b label_2149: // Incoming jump from 0x2141, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) // Inputs[6] // { // @214A stack[-2] // @214E stack[-1] // @214F stack[-4] // @2151 stack[-6] // @2154 stack[-7] // @2156 stack[-5] // } 2149 5B JUMPDEST 214A 81 DUP2 214B 60 PUSH1 0x40 214D 52 MSTORE 214E 80 DUP1 214F 93 SWAP4 2150 50 POP 2151 85 DUP6 2152 81 DUP2 2153 52 MSTORE 2154 86 DUP7 2155 86 DUP7 2156 86 DUP7 2157 01 ADD 2158 11 GT 2159 15 ISZERO 215A 61 PUSH2 0x2162 215D 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @214D memory[0x40:0x60] = stack[-2] // @214F stack[-4] = stack[-1] // @2153 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x2162, if !(stack[-5] + stack[-6] > stack[-7]) label_215E: // Incoming jump from 0x215D, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @2161 memory[0x00:0x00] } 215E 60 PUSH1 0x00 2160 80 DUP1 2161 FD *REVERT // Stack delta = +0 // Outputs[1] { @2161 revert(memory[0x00:0x00]); } // Block terminates label_2162: // Incoming jump from 0x215D, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @2163 stack[-6] // @2164 stack[-5] // @2167 stack[-1] // @2169 msg.data[stack[-5]:stack[-5] + stack[-6]] // @2176 stack[-8] // @2176 stack[-4] // @2177 stack[-7] // } 2162 5B JUMPDEST 2163 85 DUP6 2164 85 DUP6 2165 60 PUSH1 0x20 2167 83 DUP4 2168 01 ADD 2169 37 CALLDATACOPY 216A 60 PUSH1 0x00 216C 60 PUSH1 0x20 216E 87 DUP8 216F 83 DUP4 2170 01 ADD 2171 01 ADD 2172 52 MSTORE 2173 50 POP 2174 50 POP 2175 50 POP 2176 93 SWAP4 2177 92 SWAP3 2178 50 POP 2179 50 POP 217A 50 POP 217B 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @2169 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @2172 memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @2176 stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_217C: // Incoming call from 0x21B1, returns to 0x10E7 // Incoming call from 0x22B2, returns to 0x22B3 // Incoming call from 0x22EC, returns to 0x22ED // Incoming call from 0x2200, returns to 0x2201 // Incoming call from 0x21CC, returns to 0x21CD // Incoming call from 0x220E, returns to 0x220F // Incoming call from 0x224A, returns to 0x224B // Incoming call from 0x223C, returns to 0x223D // Incoming call from 0x21DA, returns to 0x21DB // Inputs[2] // { // @217D stack[-1] // @217E msg.data[stack[-1]:stack[-1] + 0x20] // } 217C 5B JUMPDEST 217D 80 DUP1 217E 35 CALLDATALOAD 217F 60 PUSH1 0x01 2181 60 PUSH1 0x01 2183 60 PUSH1 0xa0 2185 1B SHL 2186 03 SUB 2187 81 DUP2 2188 16 AND 2189 81 DUP2 218A 14 EQ 218B 61 PUSH2 0x2193 218E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @217E stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x2193, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_218F: // Incoming jump from 0x218E, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2192 memory[0x00:0x00] } 218F 60 PUSH1 0x00 2191 80 DUP1 2192 FD *REVERT // Stack delta = +0 // Outputs[1] { @2192 revert(memory[0x00:0x00]); } // Block terminates label_2193: // Incoming jump from 0x218E, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @2194 stack[-3] // @2194 stack[-1] // @2195 stack[-2] // } 2193 5B JUMPDEST 2194 91 SWAP2 2195 90 SWAP1 2196 50 POP 2197 56 *JUMP // Stack delta = -2 // Outputs[1] { @2194 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_2198: // Incoming call from 0x0444, returns to 0x0445 // Incoming call from 0x053B, returns to 0x053C // Incoming call from 0x06F7, returns to 0x06F8 // Inputs[2] // { // @219D stack[-1] // @219E stack[-2] // } 2198 5B JUMPDEST 2199 60 PUSH1 0x00 219B 60 PUSH1 0x20 219D 82 DUP3 219E 84 DUP5 219F 03 SUB 21A0 12 SLT 21A1 15 ISZERO 21A2 61 PUSH2 0x21a9 21A5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2199 stack[0] = 0x00 } // Block ends with conditional jump to 0x21a9, if !(stack[-2] - stack[-1] i< 0x20) label_21A6: // Incoming jump from 0x21A5, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @21A6 stack[-1] // @21A8 memory[stack[-1]:stack[-1] + stack[-1]] // } 21A6 80 DUP1 21A7 81 DUP2 21A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @21A8 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_21A9: // Incoming jump from 0x21A5, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @21AD stack[-2] } 21A9 5B JUMPDEST 21AA 61 PUSH2 0x10e7 21AD 82 DUP3 21AE 61 PUSH2 0x217c 21B1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @21AA stack[0] = 0x10e7 // @21AD stack[1] = stack[-2] // } // Block ends with call to 0x217c, returns to 0x10E7 label_21B2: // Incoming call from 0x0699, returns to 0x069A // Inputs[2] // { // @21B8 stack[-1] // @21B9 stack[-2] // } 21B2 5B JUMPDEST 21B3 60 PUSH1 0x00 21B5 80 DUP1 21B6 60 PUSH1 0x40 21B8 83 DUP4 21B9 85 DUP6 21BA 03 SUB 21BB 12 SLT 21BC 15 ISZERO 21BD 61 PUSH2 0x21c4 21C0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @21B3 stack[0] = 0x00 // @21B5 stack[1] = 0x00 // } // Block ends with conditional jump to 0x21c4, if !(stack[-2] - stack[-1] i< 0x40) label_21C1: // Incoming jump from 0x21C0, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @21C1 stack[-1] // @21C3 memory[stack[-1]:stack[-1] + stack[-1]] // } 21C1 80 DUP1 21C2 81 DUP2 21C3 FD *REVERT // Stack delta = +0 // Outputs[1] { @21C3 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_21C4: // Incoming jump from 0x21C0, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @21C8 stack[-3] } 21C4 5B JUMPDEST 21C5 61 PUSH2 0x21cd 21C8 83 DUP4 21C9 61 PUSH2 0x217c 21CC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @21C5 stack[0] = 0x21cd // @21C8 stack[1] = stack[-3] // } // Block ends with call to 0x217c, returns to 0x21CD label_21CD: // Incoming return from call to 0x217C at 0x21CC // Inputs[3] // { // @21CE stack[-3] // @21CE stack[-1] // @21D5 stack[-4] // } 21CD 5B JUMPDEST 21CE 91 SWAP2 21CF 50 POP 21D0 61 PUSH2 0x21db 21D3 60 PUSH1 0x20 21D5 84 DUP5 21D6 01 ADD 21D7 61 PUSH2 0x217c 21DA 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @21CE stack[-3] = stack[-1] // @21D0 stack[-1] = 0x21db // @21D6 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x217c, returns to 0x21DB label_21DB: // Incoming return from call to 0x217C at 0x21DA // Inputs[6] // { // @21DC stack[-2] // @21DC stack[-1] // @21DE stack[-5] // @21E0 stack[-6] // @21E0 stack[-3] // @21E1 stack[-4] // } 21DB 5B JUMPDEST 21DC 90 SWAP1 21DD 50 POP 21DE 92 SWAP3 21DF 50 POP 21E0 92 SWAP3 21E1 90 SWAP1 21E2 50 POP 21E3 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @21DE stack[-5] = stack[-1] // @21E0 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_21E4: // Incoming call from 0x03CC, returns to 0x03CD // Incoming call from 0x0359, returns to 0x035A // Inputs[2] // { // @21EC stack[-1] // @21ED stack[-2] // } 21E4 5B JUMPDEST 21E5 60 PUSH1 0x00 21E7 80 DUP1 21E8 60 PUSH1 0x00 21EA 60 PUSH1 0x60 21EC 84 DUP5 21ED 86 DUP7 21EE 03 SUB 21EF 12 SLT 21F0 15 ISZERO 21F1 61 PUSH2 0x21f8 21F4 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @21E5 stack[0] = 0x00 // @21E7 stack[1] = 0x00 // @21E8 stack[2] = 0x00 // } // Block ends with conditional jump to 0x21f8, if !(stack[-2] - stack[-1] i< 0x60) label_21F5: // Incoming jump from 0x21F4, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @21F5 stack[-1] // @21F7 memory[stack[-1]:stack[-1] + stack[-1]] // } 21F5 80 DUP1 21F6 81 DUP2 21F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @21F7 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_21F8: // Incoming jump from 0x21F4, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @21FC stack[-4] } 21F8 5B JUMPDEST 21F9 61 PUSH2 0x2201 21FC 84 DUP5 21FD 61 PUSH2 0x217c 2200 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @21F9 stack[0] = 0x2201 // @21FC stack[1] = stack[-4] // } // Block ends with call to 0x217c, returns to 0x2201 label_2201: // Incoming return from call to 0x217C at 0x2200 // Inputs[3] // { // @2202 stack[-4] // @2202 stack[-1] // @2209 stack[-5] // } 2201 5B JUMPDEST 2202 92 SWAP3 2203 50 POP 2204 61 PUSH2 0x220f 2207 60 PUSH1 0x20 2209 85 DUP6 220A 01 ADD 220B 61 PUSH2 0x217c 220E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2202 stack[-4] = stack[-1] // @2204 stack[-1] = 0x220f // @220A stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x217c, returns to 0x220F label_220F: // Incoming return from call to 0x217C at 0x220E // Inputs[8] // { // @2210 stack[-1] // @2210 stack[-3] // @2214 stack[-5] // @2216 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @2217 stack[-2] // @221B stack[-6] // @221D stack[-7] // @221D stack[-4] // } 220F 5B JUMPDEST 2210 91 SWAP2 2211 50 POP 2212 60 PUSH1 0x40 2214 84 DUP5 2215 01 ADD 2216 35 CALLDATALOAD 2217 90 SWAP1 2218 50 POP 2219 92 SWAP3 221A 50 POP 221B 92 SWAP3 221C 50 POP 221D 92 SWAP3 221E 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2219 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @221B stack[-6] = stack[-1] // @221D stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_221F: // Incoming call from 0x05C6, returns to 0x05C7 // Inputs[2] // { // @2228 stack[-1] // @2229 stack[-2] // } 221F 5B JUMPDEST 2220 60 PUSH1 0x00 2222 80 DUP1 2223 60 PUSH1 0x00 2225 80 DUP1 2226 60 PUSH1 0x80 2228 85 DUP6 2229 87 DUP8 222A 03 SUB 222B 12 SLT 222C 15 ISZERO 222D 61 PUSH2 0x2234 2230 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2220 stack[0] = 0x00 // @2222 stack[1] = 0x00 // @2223 stack[2] = 0x00 // @2225 stack[3] = 0x00 // } // Block ends with conditional jump to 0x2234, if !(stack[-2] - stack[-1] i< 0x80) label_2231: // Incoming jump from 0x2230, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @2231 stack[-1] // @2233 memory[stack[-1]:stack[-1] + stack[-1]] // } 2231 80 DUP1 2232 81 DUP2 2233 FD *REVERT // Stack delta = +0 // Outputs[1] { @2233 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2234: // Incoming jump from 0x2230, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @2238 stack[-5] } 2234 5B JUMPDEST 2235 61 PUSH2 0x223d 2238 85 DUP6 2239 61 PUSH2 0x217c 223C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2235 stack[0] = 0x223d // @2238 stack[1] = stack[-5] // } // Block ends with call to 0x217c, returns to 0x223D label_223D: // Incoming return from call to 0x217C at 0x223C // Inputs[3] // { // @223E stack[-5] // @223E stack[-1] // @2245 stack[-6] // } 223D 5B JUMPDEST 223E 93 SWAP4 223F 50 POP 2240 61 PUSH2 0x224b 2243 60 PUSH1 0x20 2245 86 DUP7 2246 01 ADD 2247 61 PUSH2 0x217c 224A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @223E stack[-5] = stack[-1] // @2240 stack[-1] = 0x224b // @2246 stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x217c, returns to 0x224B label_224B: // Incoming return from call to 0x217C at 0x224A // Inputs[6] // { // @224C stack[-4] // @224C stack[-1] // @2250 stack[-6] // @2252 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2253 stack[-3] // @2259 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 224B 5B JUMPDEST 224C 92 SWAP3 224D 50 POP 224E 60 PUSH1 0x40 2250 85 DUP6 2251 01 ADD 2252 35 CALLDATALOAD 2253 91 SWAP2 2254 50 POP 2255 60 PUSH1 0x60 2257 85 DUP6 2258 01 ADD 2259 35 CALLDATALOAD 225A 67 PUSH8 0xffffffffffffffff 2263 81 DUP2 2264 11 GT 2265 15 ISZERO 2266 61 PUSH2 0x226d 2269 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @224C stack[-4] = stack[-1] // @2253 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2259 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x226d, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_226A: // Incoming jump from 0x2269, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @226A stack[-2] // @226C memory[stack[-2]:stack[-2] + stack[-2]] // } 226A 81 DUP2 226B 82 DUP3 226C FD *REVERT // Stack delta = +0 // Outputs[1] { @226C revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_226D: // Incoming jump from 0x2269, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @226E stack[-6] // @226F stack[-1] // @2274 stack[-7] // } 226D 5B JUMPDEST 226E 85 DUP6 226F 01 ADD 2270 60 PUSH1 0x1f 2272 81 DUP2 2273 01 ADD 2274 87 DUP8 2275 13 SGT 2276 61 PUSH2 0x227d 2279 57 *JUMPI // Stack delta = +0 // Outputs[1] { @226F stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x227d, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_227A: // Incoming jump from 0x2279, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[2] // { // @227A stack[-2] // @227C memory[stack[-2]:stack[-2] + stack[-2]] // } 227A 81 DUP2 227B 82 DUP3 227C FD *REVERT // Stack delta = +0 // Outputs[1] { @227C revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_227D: // Incoming jump from 0x2279, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @2281 stack[-7] // @2282 stack[-1] // @2283 msg.data[stack[-1]:stack[-1] + 0x20] // } 227D 5B JUMPDEST 227E 61 PUSH2 0x228c 2281 87 DUP8 2282 82 DUP3 2283 35 CALLDATALOAD 2284 60 PUSH1 0x20 2286 84 DUP5 2287 01 ADD 2288 61 PUSH2 0x2106 228B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @227E stack[0] = 0x228c // @2281 stack[1] = stack[-7] // @2283 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @2287 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x2106, returns to 0x228C label_228C: // Incoming return from call to 0x2106 at 0x228B // Inputs[8] // { // @228D stack[-3] // @228D stack[-1] // @2290 stack[-6] // @2291 stack[-9] // @2292 stack[-5] // @2293 stack[-8] // @2295 stack[-4] // @2295 stack[-7] // } 228C 5B JUMPDEST 228D 91 SWAP2 228E 50 POP 228F 50 POP 2290 92 SWAP3 2291 95 SWAP6 2292 91 SWAP2 2293 94 SWAP5 2294 50 POP 2295 92 SWAP3 2296 50 POP 2297 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @2290 stack[-6] = stack[-1] // @2291 stack[-9] = stack[-6] // @2293 stack[-8] = stack[-5] // @2295 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_2298: // Incoming call from 0x0571, returns to 0x0572 // Inputs[2] // { // @229E stack[-1] // @229F stack[-2] // } 2298 5B JUMPDEST 2299 60 PUSH1 0x00 229B 80 DUP1 229C 60 PUSH1 0x40 229E 83 DUP4 229F 85 DUP6 22A0 03 SUB 22A1 12 SLT 22A2 15 ISZERO 22A3 61 PUSH2 0x22aa 22A6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2299 stack[0] = 0x00 // @229B stack[1] = 0x00 // } // Block ends with conditional jump to 0x22aa, if !(stack[-2] - stack[-1] i< 0x40) label_22A7: // Incoming jump from 0x22A6, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @22A7 stack[-2] // @22A9 memory[stack[-2]:stack[-2] + stack[-2]] // } 22A7 81 DUP2 22A8 82 DUP3 22A9 FD *REVERT // Stack delta = +0 // Outputs[1] { @22A9 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_22AA: // Incoming jump from 0x22A6, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @22AE stack[-3] } 22AA 5B JUMPDEST 22AB 61 PUSH2 0x22b3 22AE 83 DUP4 22AF 61 PUSH2 0x217c 22B2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @22AB stack[0] = 0x22b3 // @22AE stack[1] = stack[-3] // } // Block ends with call to 0x217c, returns to 0x22B3 label_22B3: // Incoming return from call to 0x217C at 0x22B2 // Inputs[4] // { // @22B4 stack[-3] // @22B4 stack[-1] // @22B8 stack[-4] // @22BA msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 22B3 5B JUMPDEST 22B4 91 SWAP2 22B5 50 POP 22B6 60 PUSH1 0x20 22B8 83 DUP4 22B9 01 ADD 22BA 35 CALLDATALOAD 22BB 80 DUP1 22BC 15 ISZERO 22BD 15 ISZERO 22BE 81 DUP2 22BF 14 EQ 22C0 61 PUSH2 0x22c7 22C3 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @22B4 stack[-3] = stack[-1] // @22BA stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x22c7, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_22C4: // Incoming jump from 0x22C3, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[2] // { // @22C4 stack[-2] // @22C6 memory[stack[-2]:stack[-2] + stack[-2]] // } 22C4 81 DUP2 22C5 82 DUP3 22C6 FD *REVERT // Stack delta = +0 // Outputs[1] { @22C6 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_22C7: // Incoming jump from 0x22C3, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @22C8 stack[-1] // @22C9 stack[-2] // @22CC stack[-5] // @22CE stack[-6] // @22CE stack[-3] // @22CF stack[-4] // } 22C7 5B JUMPDEST 22C8 80 DUP1 22C9 91 SWAP2 22CA 50 POP 22CB 50 POP 22CC 92 SWAP3 22CD 50 POP 22CE 92 SWAP3 22CF 90 SWAP1 22D0 50 POP 22D1 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @22CC stack[-5] = stack[-1] // @22CE stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_22D2: // Incoming call from 0x0316, returns to 0x0317 // Incoming call from 0x02F4, returns to 0x02F5 // Inputs[2] // { // @22D8 stack[-1] // @22D9 stack[-2] // } 22D2 5B JUMPDEST 22D3 60 PUSH1 0x00 22D5 80 DUP1 22D6 60 PUSH1 0x40 22D8 83 DUP4 22D9 85 DUP6 22DA 03 SUB 22DB 12 SLT 22DC 15 ISZERO 22DD 61 PUSH2 0x22e4 22E0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @22D3 stack[0] = 0x00 // @22D5 stack[1] = 0x00 // } // Block ends with conditional jump to 0x22e4, if !(stack[-2] - stack[-1] i< 0x40) label_22E1: // Incoming jump from 0x22E0, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @22E1 stack[-2] // @22E3 memory[stack[-2]:stack[-2] + stack[-2]] // } 22E1 81 DUP2 22E2 82 DUP3 22E3 FD *REVERT // Stack delta = +0 // Outputs[1] { @22E3 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_22E4: // Incoming jump from 0x22E0, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @22E8 stack[-3] } 22E4 5B JUMPDEST 22E5 61 PUSH2 0x22ed 22E8 83 DUP4 22E9 61 PUSH2 0x217c 22EC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @22E5 stack[0] = 0x22ed // @22E8 stack[1] = stack[-3] // } // Block ends with call to 0x217c, returns to 0x22ED label_22ED: // Incoming return from call to 0x217C at 0x22EC // Inputs[5] // { // @22EE stack[-6] // @22EE stack[-1] // @22F1 stack[-4] // @22F5 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @22F6 stack[-5] // } 22ED 5B JUMPDEST 22EE 94 SWAP5 22EF 60 PUSH1 0x20 22F1 93 SWAP4 22F2 90 SWAP1 22F3 93 SWAP4 22F4 01 ADD 22F5 35 CALLDATALOAD 22F6 93 SWAP4 22F7 50 POP 22F8 50 POP 22F9 50 POP 22FA 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @22EE stack[-6] = stack[-1] // @22F6 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_22FB: // Incoming call from 0x051B, returns to 0x051C // Incoming call from 0x02BC, returns to 0x02BD // Incoming call from 0x048E, returns to 0x048F // Incoming call from 0x0424, returns to 0x0425 // Incoming call from 0x0619, returns to 0x061A // Incoming call from 0x0382, returns to 0x0383 // Incoming call from 0x04E6, returns to 0x04E7 // Incoming call from 0x0639, returns to 0x063A // Inputs[2] // { // @2300 stack[-1] // @2301 stack[-2] // } 22FB 5B JUMPDEST 22FC 60 PUSH1 0x00 22FE 60 PUSH1 0x20 2300 82 DUP3 2301 84 DUP5 2302 03 SUB 2303 12 SLT 2304 15 ISZERO 2305 61 PUSH2 0x230c 2308 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22FC stack[0] = 0x00 } // Block ends with conditional jump to 0x230c, if !(stack[-2] - stack[-1] i< 0x20) label_2309: // Incoming jump from 0x2308, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2309 stack[-1] // @230B memory[stack[-1]:stack[-1] + stack[-1]] // } 2309 80 DUP1 230A 81 DUP2 230B FD *REVERT // Stack delta = +0 // Outputs[1] { @230B revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_230C: // Incoming jump from 0x2308, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @230E msg.data[stack[-2]:stack[-2] + 0x20] // @230E stack[-2] // @230F stack[-4] // @2310 stack[-3] // } 230C 5B JUMPDEST 230D 50 POP 230E 35 CALLDATALOAD 230F 91 SWAP2 2310 90 SWAP1 2311 50 POP 2312 56 *JUMP // Stack delta = -3 // Outputs[1] { @230F stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_2313: // Incoming call from 0x0265, returns to 0x0266 // Inputs[2] // { // @2318 stack[-1] // @2319 stack[-2] // } 2313 5B JUMPDEST 2314 60 PUSH1 0x00 2316 60 PUSH1 0x20 2318 82 DUP3 2319 84 DUP5 231A 03 SUB 231B 12 SLT 231C 15 ISZERO 231D 61 PUSH2 0x2324 2320 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2314 stack[0] = 0x00 } // Block ends with conditional jump to 0x2324, if !(stack[-2] - stack[-1] i< 0x20) label_2321: // Incoming jump from 0x2320, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2321 stack[-1] // @2323 memory[stack[-1]:stack[-1] + stack[-1]] // } 2321 80 DUP1 2322 81 DUP2 2323 FD *REVERT // Stack delta = +0 // Outputs[1] { @2323 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2324: // Incoming jump from 0x2320, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2325 stack[-2] // @2326 msg.data[stack[-2]:stack[-2] + 0x20] // } 2324 5B JUMPDEST 2325 81 DUP2 2326 35 CALLDATALOAD 2327 61 PUSH2 0x10e7 232A 81 DUP2 232B 61 PUSH2 0x2641 232E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2326 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2327 stack[1] = 0x10e7 // @232A stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2641, returns to 0x10E7 label_232F: // Incoming jump from 0x1BAE // Inputs[2] // { // @2334 stack[-1] // @2335 stack[-2] // } 232F 5B JUMPDEST 2330 60 PUSH1 0x00 2332 60 PUSH1 0x20 2334 82 DUP3 2335 84 DUP5 2336 03 SUB 2337 12 SLT 2338 15 ISZERO 2339 61 PUSH2 0x2340 233C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2330 stack[0] = 0x00 } // Block ends with conditional jump to 0x2340, if !(stack[-2] - stack[-1] i< 0x20) label_233D: // Incoming jump from 0x233C, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @233D stack[-1] // @233F memory[stack[-1]:stack[-1] + stack[-1]] // } 233D 80 DUP1 233E 81 DUP2 233F FD *REVERT // Stack delta = +0 // Outputs[1] { @233F revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2340: // Incoming jump from 0x233C, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2341 stack[-2] // @2342 memory[stack[-2]:stack[-2] + 0x20] // } 2340 5B JUMPDEST 2341 81 DUP2 2342 51 MLOAD 2343 61 PUSH2 0x10e7 2346 81 DUP2 2347 61 PUSH2 0x2641 234A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2342 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @2343 stack[1] = 0x10e7 // @2346 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2641, returns to 0x10E7 label_234B: // Incoming call from 0x03EC, returns to 0x03ED // Incoming call from 0x05A6, returns to 0x05A7 // Incoming call from 0x05E6, returns to 0x05E7 // Inputs[2] // { // @2350 stack[-1] // @2351 stack[-2] // } 234B 5B JUMPDEST 234C 60 PUSH1 0x00 234E 60 PUSH1 0x20 2350 82 DUP3 2351 84 DUP5 2352 03 SUB 2353 12 SLT 2354 15 ISZERO 2355 61 PUSH2 0x235c 2358 57 *JUMPI // Stack delta = +1 // Outputs[1] { @234C stack[0] = 0x00 } // Block ends with conditional jump to 0x235c, if !(stack[-2] - stack[-1] i< 0x20) label_2359: // Incoming jump from 0x2358, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2359 stack[-1] // @235B memory[stack[-1]:stack[-1] + stack[-1]] // } 2359 80 DUP1 235A 81 DUP2 235B FD *REVERT // Stack delta = +0 // Outputs[1] { @235B revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_235C: // Incoming jump from 0x2358, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @235D stack[-2] // @235E msg.data[stack[-2]:stack[-2] + 0x20] // } 235C 5B JUMPDEST 235D 81 DUP2 235E 35 CALLDATALOAD 235F 67 PUSH8 0xffffffffffffffff 2368 81 DUP2 2369 11 GT 236A 15 ISZERO 236B 61 PUSH2 0x2372 236E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @235E stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2372, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_236F: // Incoming jump from 0x236E, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @236F stack[-2] // @2371 memory[stack[-2]:stack[-2] + stack[-2]] // } 236F 81 DUP2 2370 82 DUP3 2371 FD *REVERT // Stack delta = +0 // Outputs[1] { @2371 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2372: // Incoming jump from 0x236E, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2373 stack[-3] // @2374 stack[-1] // @2379 stack[-4] // } 2372 5B JUMPDEST 2373 82 DUP3 2374 01 ADD 2375 60 PUSH1 0x1f 2377 81 DUP2 2378 01 ADD 2379 84 DUP5 237A 13 SGT 237B 61 PUSH2 0x2382 237E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2374 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x2382, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_237F: // Incoming jump from 0x237E, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[2] // { // @237F stack[-2] // @2381 memory[stack[-2]:stack[-2] + stack[-2]] // } 237F 81 DUP2 2380 82 DUP3 2381 FD *REVERT // Stack delta = +0 // Outputs[1] { @2381 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2382: // Incoming jump from 0x237E, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @2386 stack[-4] // @2387 stack[-1] // @2388 msg.data[stack[-1]:stack[-1] + 0x20] // } 2382 5B JUMPDEST 2383 61 PUSH2 0x1c23 2386 84 DUP5 2387 82 DUP3 2388 35 CALLDATALOAD 2389 60 PUSH1 0x20 238B 84 DUP5 238C 01 ADD 238D 61 PUSH2 0x2106 2390 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2383 stack[0] = 0x1c23 // @2386 stack[1] = stack[-4] // @2388 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @238C stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x2106, returns to 0x1C23 label_2391: // Incoming call from 0x1A6F, returns to 0x1A70 // Inputs[2] // { // @2396 stack[-1] // @2397 stack[-2] // } 2391 5B JUMPDEST 2392 60 PUSH1 0x00 2394 60 PUSH1 0x20 2396 82 DUP3 2397 84 DUP5 2398 03 SUB 2399 12 SLT 239A 15 ISZERO 239B 61 PUSH2 0x23a2 239E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2392 stack[0] = 0x00 } // Block ends with conditional jump to 0x23a2, if !(stack[-2] - stack[-1] i< 0x20) label_239F: // Incoming jump from 0x239E, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @239F stack[-1] // @23A1 memory[stack[-1]:stack[-1] + stack[-1]] // } 239F 80 DUP1 23A0 81 DUP2 23A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @23A1 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_23A2: // Incoming jump from 0x239E, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @23A4 stack[-2] // @23A4 memory[stack[-2]:stack[-2] + 0x20] // @23A5 stack[-4] // @23A6 stack[-3] // } 23A2 5B JUMPDEST 23A3 50 POP 23A4 51 MLOAD 23A5 91 SWAP2 23A6 90 SWAP1 23A7 50 POP 23A8 56 *JUMP // Stack delta = -3 // Outputs[1] { @23A5 stack[-4] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_23A9: // Incoming call from 0x05F9, returns to 0x05FA // Inputs[2] // { // @23B2 stack[-1] // @23B3 stack[-2] // } 23A9 5B JUMPDEST 23AA 60 PUSH1 0x00 23AC 80 DUP1 23AD 60 PUSH1 0x00 23AF 80 DUP1 23B0 60 PUSH1 0x60 23B2 85 DUP6 23B3 87 DUP8 23B4 03 SUB 23B5 12 SLT 23B6 15 ISZERO 23B7 61 PUSH2 0x23be 23BA 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @23AA stack[0] = 0x00 // @23AC stack[1] = 0x00 // @23AD stack[2] = 0x00 // @23AF stack[3] = 0x00 // } // Block ends with conditional jump to 0x23be, if !(stack[-2] - stack[-1] i< 0x60) label_23BB: // Incoming jump from 0x23BA, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @23BB stack[-4] // @23BD memory[stack[-4]:stack[-4] + stack[-4]] // } 23BB 83 DUP4 23BC 84 DUP5 23BD FD *REVERT // Stack delta = +0 // Outputs[1] { @23BD revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_23BE: // Incoming jump from 0x23BA, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[6] // { // @23BF stack[-5] // @23C0 msg.data[stack[-5]:stack[-5] + 0x20] // @23C1 stack[-4] // @23C7 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @23C8 stack[-3] // @23CE msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } 23BE 5B JUMPDEST 23BF 84 DUP5 23C0 35 CALLDATALOAD 23C1 93 SWAP4 23C2 50 POP 23C3 60 PUSH1 0x20 23C5 85 DUP6 23C6 01 ADD 23C7 35 CALLDATALOAD 23C8 92 SWAP3 23C9 50 POP 23CA 60 PUSH1 0x40 23CC 85 DUP6 23CD 01 ADD 23CE 35 CALLDATALOAD 23CF 67 PUSH8 0xffffffffffffffff 23D8 80 DUP1 23D9 82 DUP3 23DA 11 GT 23DB 15 ISZERO 23DC 61 PUSH2 0x23e3 23DF 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @23C1 stack[-4] = msg.data[stack[-5]:stack[-5] + 0x20] // @23C8 stack[-3] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @23CE stack[0] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @23CF stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x23e3, if !(msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] > 0xffffffffffffffff) label_23E0: // Incoming jump from 0x23DF, if not !(msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @23E0 stack[-4] // @23E2 memory[stack[-4]:stack[-4] + stack[-4]] // } 23E0 83 DUP4 23E1 84 DUP5 23E2 FD *REVERT // Stack delta = +0 // Outputs[1] { @23E2 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_23E3: // Incoming jump from 0x23DF, if !(msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @23E4 stack[-2] // @23E5 stack[-7] // @23E9 stack[-8] // } 23E3 5B JUMPDEST 23E4 81 DUP2 23E5 87 DUP8 23E6 01 ADD 23E7 91 SWAP2 23E8 50 POP 23E9 87 DUP8 23EA 60 PUSH1 0x1f 23EC 83 DUP4 23ED 01 ADD 23EE 12 SLT 23EF 61 PUSH2 0x23f6 23F2 57 *JUMPI // Stack delta = +0 // Outputs[1] { @23E7 stack[-2] = stack[-7] + stack[-2] } // Block ends with conditional jump to 0x23f6, if stack[-7] + stack[-2] + 0x1f i< stack[-8] label_23F3: // Incoming jump from 0x23F2, if not stack[-7] + stack[-2] + 0x1f i< stack[-8] // Inputs[2] // { // @23F3 stack[-4] // @23F5 memory[stack[-4]:stack[-4] + stack[-4]] // } 23F3 83 DUP4 23F4 84 DUP5 23F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @23F5 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_23F6: // Incoming jump from 0x23F2, if stack[-7] + stack[-2] + 0x1f i< stack[-8] // Inputs[3] // { // @23F7 stack[-2] // @23F8 msg.data[stack[-2]:stack[-2] + 0x20] // @23F9 stack[-1] // } 23F6 5B JUMPDEST 23F7 81 DUP2 23F8 35 CALLDATALOAD 23F9 81 DUP2 23FA 81 DUP2 23FB 11 GT 23FC 15 ISZERO 23FD 61 PUSH2 0x2404 2400 57 *JUMPI // Stack delta = +1 // Outputs[1] { @23F8 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2404, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_2401: // Incoming jump from 0x2400, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[2] // { // @2401 stack[-5] // @2403 memory[stack[-5]:stack[-5] + stack[-5]] // } 2401 84 DUP5 2402 85 DUP6 2403 FD *REVERT // Stack delta = +0 // Outputs[1] { @2403 revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_2404: // Incoming jump from 0x2400, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @2405 stack[-9] // @2408 stack[-1] // @240C stack[-3] // } 2404 5B JUMPDEST 2405 88 DUP9 2406 60 PUSH1 0x20 2408 82 DUP3 2409 60 PUSH1 0x05 240B 1B SHL 240C 85 DUP6 240D 01 ADD 240E 01 ADD 240F 11 GT 2410 15 ISZERO 2411 61 PUSH2 0x2418 2414 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2418, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-9]) label_2415: // Incoming jump from 0x2414, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-9]) // Inputs[2] // { // @2415 stack[-5] // @2417 memory[stack[-5]:stack[-5] + stack[-5]] // } 2415 84 DUP5 2416 85 DUP6 2417 FD *REVERT // Stack delta = +0 // Outputs[1] { @2417 revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_2418: // Incoming jump from 0x2414, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-9]) // Inputs[7] // { // @2419 stack[-7] // @2419 stack[-1] // @241A stack[-10] // @241B stack[-6] // @241C stack[-9] // @2421 stack[-3] // @2422 stack[-8] // } 2418 5B JUMPDEST 2419 95 SWAP6 241A 98 SWAP9 241B 94 SWAP5 241C 97 SWAP8 241D 50 POP 241E 50 POP 241F 60 PUSH1 0x20 2421 01 ADD 2422 94 SWAP5 2423 50 POP 2424 50 POP 2425 50 POP 2426 56 *JUMP // Stack delta = -6 // Outputs[4] // { // @2419 stack[-7] = stack[-1] // @241A stack[-10] = stack[-7] // @241C stack[-9] = stack[-6] // @2422 stack[-8] = 0x20 + stack[-3] // } // Block ends with unconditional jump to stack[-10] label_2427: // Incoming call from 0x24D1, returns to 0x10E7 // Incoming call from 0x24B4, returns to 0x24B5 // Inputs[3] // { // @242A stack[-1] // @242B memory[stack[-1]:stack[-1] + 0x20] // @242D stack[-2] // } 2427 5B JUMPDEST 2428 60 PUSH1 0x00 242A 81 DUP2 242B 51 MLOAD 242C 80 DUP1 242D 84 DUP5 242E 52 MSTORE 242F 61 PUSH2 0x243f 2432 81 DUP2 2433 60 PUSH1 0x20 2435 86 DUP7 2436 01 ADD 2437 60 PUSH1 0x20 2439 86 DUP7 243A 01 ADD 243B 61 PUSH2 0x2569 243E 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @2428 stack[0] = 0x00 // @242B stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @242E memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @242F stack[2] = 0x243f // @2432 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @2436 stack[4] = stack[-2] + 0x20 // @243A stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x2569, returns to 0x243F label_243F: // Incoming return from call to 0x2569 at 0x243E // Inputs[4] // { // @2442 stack[-1] // @2447 stack[-4] // @2448 stack[-2] // @244E stack[-5] // } 243F 5B JUMPDEST 2440 60 PUSH1 0x1f 2442 01 ADD 2443 60 PUSH1 0x1f 2445 19 NOT 2446 16 AND 2447 92 SWAP3 2448 90 SWAP1 2449 92 SWAP3 244A 01 ADD 244B 60 PUSH1 0x20 244D 01 ADD 244E 92 SWAP3 244F 91 SWAP2 2450 50 POP 2451 50 POP 2452 56 *JUMP // Stack delta = -4 // Outputs[1] { @244E stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] 2453 5B JUMPDEST 2454 60 PUSH1 0x00 2456 83 DUP4 2457 51 MLOAD 2458 61 PUSH2 0x2465 245B 81 DUP2 245C 84 DUP5 245D 60 PUSH1 0x20 245F 88 DUP9 2460 01 ADD 2461 61 PUSH2 0x2569 2464 56 *JUMP 2465 5B JUMPDEST 2466 83 DUP4 2467 51 MLOAD 2468 90 SWAP1 2469 83 DUP4 246A 01 ADD 246B 90 SWAP1 246C 61 PUSH2 0x2479 246F 81 DUP2 2470 83 DUP4 2471 60 PUSH1 0x20 2473 88 DUP9 2474 01 ADD 2475 61 PUSH2 0x2569 2478 56 *JUMP 2479 5B JUMPDEST 247A 01 ADD 247B 94 SWAP5 247C 93 SWAP4 247D 50 POP 247E 50 POP 247F 50 POP 2480 50 POP 2481 56 *JUMP label_2482: // Incoming call from 0x1B67, returns to 0x1B68 // Inputs[5] // { // @248B stack[-5] // @248E stack[-1] // @2490 stack[-4] // @249B stack[-3] // @24B0 stack[-2] // } 2482 5B JUMPDEST 2483 60 PUSH1 0x01 2485 60 PUSH1 0x01 2487 60 PUSH1 0xa0 2489 1B SHL 248A 03 SUB 248B 85 DUP6 248C 81 DUP2 248D 16 AND 248E 82 DUP3 248F 52 MSTORE 2490 84 DUP5 2491 16 AND 2492 60 PUSH1 0x20 2494 82 DUP3 2495 01 ADD 2496 52 MSTORE 2497 60 PUSH1 0x40 2499 81 DUP2 249A 01 ADD 249B 83 DUP4 249C 90 SWAP1 249D 52 MSTORE 249E 60 PUSH1 0x80 24A0 60 PUSH1 0x60 24A2 82 DUP3 24A3 01 ADD 24A4 81 DUP2 24A5 90 SWAP1 24A6 52 MSTORE 24A7 60 PUSH1 0x00 24A9 90 SWAP1 24AA 61 PUSH2 0x24b5 24AD 90 SWAP1 24AE 83 DUP4 24AF 01 ADD 24B0 84 DUP5 24B1 61 PUSH2 0x2427 24B4 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @248F memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @2496 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @249D memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @24A6 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @24A9 stack[0] = 0x00 // @24AD stack[1] = 0x24b5 // @24AF stack[2] = stack[-1] + 0x80 // @24B0 stack[3] = stack[-2] // } // Block ends with call to 0x2427, returns to 0x24B5 label_24B5: // Incoming return from call to 0x2427 at 0x24B4 // Inputs[3] // { // @24B6 stack[-1] // @24B6 stack[-8] // @24B7 stack[-7] // } 24B5 5B JUMPDEST 24B6 96 SWAP7 24B7 95 SWAP6 24B8 50 POP 24B9 50 POP 24BA 50 POP 24BB 50 POP 24BC 50 POP 24BD 50 POP 24BE 56 *JUMP // Stack delta = -7 // Outputs[1] { @24B6 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_24BF: // Incoming jump from 0x02A1 // Inputs[2] // { // @24C2 stack[-1] // @24CD stack[-2] // } 24BF 5B JUMPDEST 24C0 60 PUSH1 0x20 24C2 81 DUP2 24C3 52 MSTORE 24C4 60 PUSH1 0x00 24C6 61 PUSH2 0x10e7 24C9 60 PUSH1 0x20 24CB 83 DUP4 24CC 01 ADD 24CD 84 DUP5 24CE 61 PUSH2 0x2427 24D1 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @24C3 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @24C4 stack[0] = 0x00 // @24C6 stack[1] = 0x10e7 // @24CC stack[2] = stack[-1] + 0x20 // @24CD stack[3] = stack[-2] // } // Block ends with call to 0x2427, returns to 0x10E7 label_24D2: // Incoming call from 0x0C16, returns to 0x08F8 // Incoming call from 0x1234, returns to 0x08F8 // Incoming call from 0x0AF9, returns to 0x08F8 // Incoming call from 0x0B9D, returns to 0x08F8 // Incoming call from 0x111D, returns to 0x08F8 // Incoming call from 0x0A45, returns to 0x08F8 // Incoming call from 0x0AA4, returns to 0x08F8 // Incoming call from 0x130E, returns to 0x08F8 // Incoming call from 0x0D47, returns to 0x08F8 // Incoming call from 0x0E32, returns to 0x08F8 // Incoming call from 0x08F7, returns to 0x08F8 // Incoming call from 0x0C83, returns to 0x08F8 // Incoming call from 0x0EC6, returns to 0x08F8 // Incoming call from 0x119D, returns to 0x08F8 // Incoming call from 0x1270, returns to 0x08F8 // Incoming call from 0x0C4B, returns to 0x08F8 // Incoming call from 0x0BD7, returns to 0x08F8 // Incoming call from 0x0CC7, returns to 0x08F8 // Inputs[2] // { // @24D6 stack[-1] // @2505 stack[-2] // } 24D2 5B JUMPDEST 24D3 60 PUSH1 0x20 24D5 80 DUP1 24D6 82 DUP3 24D7 52 MSTORE 24D8 81 DUP2 24D9 81 DUP2 24DA 01 ADD 24DB 52 MSTORE 24DC 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 24FD 60 PUSH1 0x40 24FF 82 DUP3 2500 01 ADD 2501 52 MSTORE 2502 60 PUSH1 0x60 2504 01 ADD 2505 90 SWAP1 2506 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @24D7 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @24DB memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @2501 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @2505 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2507: // Incoming call from 0x1466, returns to 0x1467 // Incoming call from 0x1AD2, returns to 0x1AD3 // Incoming call from 0x14C6, returns to 0x14C7 // Incoming call from 0x1B32, returns to 0x14C7 // Inputs[2] // { // @250A stack[-2] // @250C stack[-1] // } 2507 5B JUMPDEST 2508 60 PUSH1 0x00 250A 82 DUP3 250B 19 NOT 250C 82 DUP3 250D 11 GT 250E 15 ISZERO 250F 61 PUSH2 0x251a 2512 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2508 stack[0] = 0x00 } // Block ends with conditional jump to 0x251a, if !(stack[-1] > ~stack[-2]) label_2513: // Incoming jump from 0x2512, if not !(stack[-1] > ~stack[-2]) 2513 61 PUSH2 0x251a 2516 61 PUSH2 0x25ff 2519 56 *JUMP // Stack delta = +1 // Outputs[1] { @2513 stack[0] = 0x251a } // Block ends with unconditional jump to 0x25ff label_251A: // Incoming jump from 0x2512, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @251C stack[-3] // @251C stack[-2] // @251D stack[-4] // } 251A 5B JUMPDEST 251B 50 POP 251C 01 ADD 251D 90 SWAP1 251E 56 *JUMP // Stack delta = -3 // Outputs[1] { @251D stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_251F: // Incoming call from 0x1C39, returns to 0x1C3A // Incoming call from 0x1C8F, returns to 0x1C90 // Inputs[1] { @2522 stack[-2] } 251F 5B JUMPDEST 2520 60 PUSH1 0x00 2522 82 DUP3 2523 61 PUSH2 0x252e 2526 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2520 stack[0] = 0x00 } // Block ends with conditional jump to 0x252e, if stack[-2] label_2527: // Incoming jump from 0x2526, if not stack[-2] 2527 61 PUSH2 0x252e 252A 61 PUSH2 0x2615 252D 56 *JUMP // Stack delta = +1 // Outputs[1] { @2527 stack[0] = 0x252e } // Block ends with unconditional jump to 0x2615 label_252E: // Incoming jump from 0x2526, if stack[-2] // Inputs[3] // { // @2530 stack[-2] // @2530 stack[-3] // @2531 stack[-4] // } 252E 5B JUMPDEST 252F 50 POP 2530 04 DIV 2531 90 SWAP1 2532 56 *JUMP // Stack delta = -3 // Outputs[1] { @2531 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_2533: // Incoming call from 0x09BE, returns to 0x09BF // Incoming call from 0x0F3D, returns to 0x0F3E // Inputs[2] // { // @2536 stack[-1] // @253B stack[-2] // } 2533 5B JUMPDEST 2534 60 PUSH1 0x00 2536 81 DUP2 2537 60 PUSH1 0x00 2539 19 NOT 253A 04 DIV 253B 83 DUP4 253C 11 GT 253D 82 DUP3 253E 15 ISZERO 253F 15 ISZERO 2540 16 AND 2541 15 ISZERO 2542 61 PUSH2 0x254d 2545 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2534 stack[0] = 0x00 } // Block ends with conditional jump to 0x254d, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_2546: // Incoming jump from 0x2545, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 2546 61 PUSH2 0x254d 2549 61 PUSH2 0x25ff 254C 56 *JUMP // Stack delta = +1 // Outputs[1] { @2546 stack[0] = 0x254d } // Block ends with unconditional jump to 0x25ff label_254D: // Incoming jump from 0x2545, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @254F stack[-3] // @254F stack[-2] // @2550 stack[-4] // } 254D 5B JUMPDEST 254E 50 POP 254F 02 MUL 2550 90 SWAP1 2551 56 *JUMP // Stack delta = -3 // Outputs[1] { @2550 stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] 2552 5B JUMPDEST 2553 60 PUSH1 0x00 2555 82 DUP3 2556 82 DUP3 2557 10 LT 2558 15 ISZERO 2559 61 PUSH2 0x2564 255C 57 *JUMPI 255D 61 PUSH2 0x2564 2560 61 PUSH2 0x25ff 2563 56 *JUMP 2564 5B JUMPDEST 2565 50 POP 2566 03 SUB 2567 90 SWAP1 2568 56 *JUMP label_2569: // Incoming call from 0x243E, returns to 0x243F // Inputs[1] { @256D stack[-3] } 2569 5B JUMPDEST 256A 60 PUSH1 0x00 256C 5B JUMPDEST 256D 83 DUP4 256E 81 DUP2 256F 10 LT 2570 15 ISZERO 2571 61 PUSH2 0x2584 2574 57 *JUMPI // Stack delta = +1 // Outputs[1] { @256A stack[0] = 0x00 } // Block ends with conditional jump to 0x2584, if !(0x00 < stack[-3]) label_2575: // Incoming jump from 0x2574, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x2574, if not !(0x00 < stack[-3]) // Inputs[4] // { // @2575 stack[-2] // @2576 stack[-1] // @2578 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2579 stack[-3] // } 2575 81 DUP2 2576 81 DUP2 2577 01 ADD 2578 51 MLOAD 2579 83 DUP4 257A 82 DUP3 257B 01 ADD 257C 52 MSTORE 257D 60 PUSH1 0x20 257F 01 ADD 2580 61 PUSH2 0x256c 2583 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @257C memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @257F stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x256c label_2584: // Incoming jump from 0x2574, if !(stack[-1] < stack[-4]) // Incoming jump from 0x2574, if !(0x00 < stack[-3]) // Inputs[2] // { // @2585 stack[-4] // @2586 stack[-1] // } 2584 5B JUMPDEST 2585 83 DUP4 2586 81 DUP2 2587 11 GT 2588 15 ISZERO 2589 61 PUSH2 0x0e91 258C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e91, if !(stack[-1] > stack[-4]) label_258D: // Incoming jump from 0x258C, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @2591 stack[-4] // @2592 stack[-3] // @2594 stack[-5] // } 258D 50 POP 258E 50 POP 258F 60 PUSH1 0x00 2591 91 SWAP2 2592 01 ADD 2593 52 MSTORE 2594 56 *JUMP // Stack delta = -5 // Outputs[1] { @2593 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_2595: // Incoming call from 0x079E, returns to 0x079F // Incoming call from 0x0772, returns to 0x0773 // Incoming call from 0x1CCE, returns to 0x0773 // Incoming call from 0x0C97, returns to 0x0773 // Incoming call from 0x2078, returns to 0x2079 // Inputs[1] { @2598 stack[-1] } 2595 5B JUMPDEST 2596 60 PUSH1 0x01 2598 81 DUP2 2599 81 DUP2 259A 1C SHR 259B 90 SWAP1 259C 82 DUP3 259D 16 AND 259E 80 DUP1 259F 61 PUSH2 0x25a9 25A2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @259B stack[0] = stack[-1] >> 0x01 // @259D stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x25a9, if stack[-1] & 0x01 label_25A3: // Incoming jump from 0x25A2, if not stack[-1] & 0x01 // Inputs[2] // { // @25A5 stack[-2] // @25AE stack[-1] // } 25A3 60 PUSH1 0x7f 25A5 82 DUP3 25A6 16 AND 25A7 91 SWAP2 25A8 50 POP 25A9 5B JUMPDEST 25AA 60 PUSH1 0x20 25AC 82 DUP3 25AD 10 LT 25AE 81 DUP2 25AF 14 EQ 25B0 15 ISZERO 25B1 61 PUSH2 0x25ca 25B4 57 *JUMPI // Stack delta = +0 // Outputs[1] { @25A7 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x25ca, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_25B5: // Incoming jump from 0x25B4, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x25B4, if not !(stack[-1] == (stack[-2] < 0x20)) // Inputs[1] { @25C9 memory[0x00:0x24] } 25B5 63 PUSH4 0x4e487b71 25BA 60 PUSH1 0xe0 25BC 1B SHL 25BD 60 PUSH1 0x00 25BF 52 MSTORE 25C0 60 PUSH1 0x22 25C2 60 PUSH1 0x04 25C4 52 MSTORE 25C5 60 PUSH1 0x24 25C7 60 PUSH1 0x00 25C9 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @25BF memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @25C4 memory[0x04:0x24] = 0x22 // @25C9 revert(memory[0x00:0x24]); // } // Block terminates label_25CA: // Incoming jump from 0x25B4, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x25B4, if !(stack[-1] == (stack[-2] < 0x20)) // Inputs[3] // { // @25CC stack[-2] // @25CC stack[-4] // @25CD stack[-3] // } 25CA 5B JUMPDEST 25CB 50 POP 25CC 91 SWAP2 25CD 90 SWAP1 25CE 50 POP 25CF 56 *JUMP // Stack delta = -3 // Outputs[1] { @25CC stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_25D0: // Incoming call from 0x205C, returns to 0x205D // Incoming call from 0x205C, returns to 0x205D // Inputs[1] { @25D6 stack[-1] } 25D0 5B JUMPDEST 25D1 60 PUSH1 0x00 25D3 60 PUSH1 0x00 25D5 19 NOT 25D6 82 DUP3 25D7 14 EQ 25D8 15 ISZERO 25D9 61 PUSH2 0x25e4 25DC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25D1 stack[0] = 0x00 } // Block ends with conditional jump to 0x25e4, if !(stack[-1] == ~0x00) label_25DD: // Incoming jump from 0x25DC, if not !(stack[-1] == ~0x00) 25DD 61 PUSH2 0x25e4 25E0 61 PUSH2 0x25ff 25E3 56 *JUMP // Stack delta = +1 // Outputs[1] { @25DD stack[0] = 0x25e4 } // Block ends with unconditional jump to 0x25ff label_25E4: // Incoming jump from 0x25DC, if !(stack[-1] == ~0x00) // Inputs[2] // { // @25E8 stack[-2] // @25E9 stack[-3] // } 25E4 5B JUMPDEST 25E5 50 POP 25E6 60 PUSH1 0x01 25E8 01 ADD 25E9 90 SWAP1 25EA 56 *JUMP // Stack delta = -2 // Outputs[1] { @25E9 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_25EB: // Incoming call from 0x1C49, returns to 0x1C4A // Incoming call from 0x1C9F, returns to 0x1CA0 // Inputs[1] { @25EE stack[-2] } 25EB 5B JUMPDEST 25EC 60 PUSH1 0x00 25EE 82 DUP3 25EF 61 PUSH2 0x25fa 25F2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25EC stack[0] = 0x00 } // Block ends with conditional jump to 0x25fa, if stack[-2] label_25F3: // Incoming jump from 0x25F2, if not stack[-2] 25F3 61 PUSH2 0x25fa 25F6 61 PUSH2 0x2615 25F9 56 *JUMP // Stack delta = +1 // Outputs[1] { @25F3 stack[0] = 0x25fa } // Block ends with unconditional jump to 0x2615 label_25FA: // Incoming jump from 0x25F2, if stack[-2] // Inputs[3] // { // @25FC stack[-3] // @25FC stack[-2] // @25FD stack[-4] // } 25FA 5B JUMPDEST 25FB 50 POP 25FC 06 MOD 25FD 90 SWAP1 25FE 56 *JUMP // Stack delta = -3 // Outputs[1] { @25FD stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_25FF: // Incoming jump from 0x2519 // Incoming jump from 0x254C // Incoming jump from 0x25E3 // Inputs[1] { @2614 memory[0x00:0x24] } 25FF 5B JUMPDEST 2600 63 PUSH4 0x4e487b71 2605 60 PUSH1 0xe0 2607 1B SHL 2608 60 PUSH1 0x00 260A 52 MSTORE 260B 60 PUSH1 0x11 260D 60 PUSH1 0x04 260F 52 MSTORE 2610 60 PUSH1 0x24 2612 60 PUSH1 0x00 2614 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @260A memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @260F memory[0x04:0x24] = 0x11 // @2614 revert(memory[0x00:0x24]); // } // Block terminates label_2615: // Incoming jump from 0x25F9 // Incoming jump from 0x252D // Inputs[1] { @262A memory[0x00:0x24] } 2615 5B JUMPDEST 2616 63 PUSH4 0x4e487b71 261B 60 PUSH1 0xe0 261D 1B SHL 261E 60 PUSH1 0x00 2620 52 MSTORE 2621 60 PUSH1 0x12 2623 60 PUSH1 0x04 2625 52 MSTORE 2626 60 PUSH1 0x24 2628 60 PUSH1 0x00 262A FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2620 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2625 memory[0x04:0x24] = 0x12 // @262A revert(memory[0x00:0x24]); // } // Block terminates label_262B: // Incoming jump from 0x2148 // Incoming jump from 0x2120 // Inputs[1] { @2640 memory[0x00:0x24] } 262B 5B JUMPDEST 262C 63 PUSH4 0x4e487b71 2631 60 PUSH1 0xe0 2633 1B SHL 2634 60 PUSH1 0x00 2636 52 MSTORE 2637 60 PUSH1 0x41 2639 60 PUSH1 0x04 263B 52 MSTORE 263C 60 PUSH1 0x24 263E 60 PUSH1 0x00 2640 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2636 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @263B memory[0x04:0x24] = 0x41 // @2640 revert(memory[0x00:0x24]); // } // Block terminates label_2641: // Incoming call from 0x234A, returns to 0x10E7 // Incoming call from 0x232E, returns to 0x10E7 // Inputs[1] { @264B stack[-1] } 2641 5B JUMPDEST 2642 60 PUSH1 0x01 2644 60 PUSH1 0x01 2646 60 PUSH1 0xe0 2648 1B SHL 2649 03 SUB 264A 19 NOT 264B 81 DUP2 264C 16 AND 264D 81 DUP2 264E 14 EQ 264F 61 PUSH2 0x0a13 2652 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a13, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_2653: // Incoming jump from 0x2652, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @2656 memory[0x00:0x00] } 2653 60 PUSH1 0x00 2655 80 DUP1 2656 FD *REVERT // Stack delta = +0 // Outputs[1] { @2656 revert(memory[0x00:0x00]); } // Block terminates 2657 FE *ASSERT 2658 62 PUSH3 0x613361 265C 36 CALLDATASIZE 265D 65 PUSH6 0x623839376662 2664 62 PUSH3 0x313436 2668 62 PUSH3 0x373765 266C 63 PUSH4 0x33326337 2671 33 CALLER 2672 61 PUSH2 0x3731 2675 32 ORIGIN 2676 61 PUSH2 0x3430 2679 36 CALLDATASIZE 267A 36 CALLDATASIZE 267B 64 PUSH5 0x34613530a2 2681 64 PUSH5 0x6970667358 2687 22 22 2688 12 SLT 2689 20 SHA3 268A 44 DIFFICULTY 268B 70 PUSH17 0xca1c2cb961d37947ef9354299682320e62 269D 11 GT 269E 27 27 269F BA BA 26A0 DE DE 26A1 4F 4F 26A2 65 PUSH6 0xc8d7d4d1d811 26A9 2E 2E 26AA 64 PUSH5 0x736f6c6343 26B0 00 *STOP 26B1 08 ADDMOD 26B2 04 DIV 26B3 00 *STOP 26B4 33 CALLER