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 0x021a 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x021a, 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 0x70a08231 0019 11 GT 001A 61 PUSH2 0x0123 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0123, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xb88d4fde 0024 11 GT 0025 61 PUSH2 0x00ab 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ab, if 0xb88d4fde > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xb88d4fde > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xe30c3978 002F 11 GT 0030 61 PUSH2 0x006f 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x006f, if 0xe30c3978 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xe30c3978 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xe30c3978 003A 14 EQ 003B 61 PUSH2 0x05a9 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a9, if 0xe30c3978 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xe30c3978 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe985e9c5 0045 14 EQ 0046 61 PUSH2 0x05c7 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c7, if 0xe985e9c5 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xed9ec888 0050 14 EQ 0051 61 PUSH2 0x0610 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0610, if 0xed9ec888 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xed9ec888 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf2fde38b 005B 14 EQ 005C 61 PUSH2 0x063d 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x063d, if 0xf2fde38b == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xf4a0a528 0066 14 EQ 0067 61 PUSH2 0x065d 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x065d, if 0xf4a0a528 == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xf4a0a528 == stack[-1] // Inputs[1] { @006E memory[0x00:0x00] } 006B 60 PUSH1 0x00 006D 80 DUP1 006E FD *REVERT // Stack delta = +0 // Outputs[1] { @006E revert(memory[0x00:0x00]); } // Block terminates label_006F: // Incoming jump from 0x0033, if 0xe30c3978 > stack[-1] // Inputs[1] { @0070 stack[-1] } 006F 5B JUMPDEST 0070 80 DUP1 0071 63 PUSH4 0xb88d4fde 0076 14 EQ 0077 61 PUSH2 0x052a 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x052a, if 0xb88d4fde == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xb88d4fde == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xc002d23d 0081 14 EQ 0082 61 PUSH2 0x053d 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x053d, if 0xc002d23d == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xc002d23d == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xc204642c 008C 14 EQ 008D 61 PUSH2 0x0553 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0553, if 0xc204642c == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xc204642c == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xc87b56dd 0097 14 EQ 0098 61 PUSH2 0x0573 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0573, 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 0xde7fcb1d 00A2 14 EQ 00A3 61 PUSH2 0x0593 00A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0593, if 0xde7fcb1d == stack[-1] label_00A7: // Incoming jump from 0x00A6, if not 0xde7fcb1d == stack[-1] // Inputs[1] { @00AA memory[0x00:0x00] } 00A7 60 PUSH1 0x00 00A9 80 DUP1 00AA FD *REVERT // Stack delta = +0 // Outputs[1] { @00AA revert(memory[0x00:0x00]); } // Block terminates label_00AB: // Incoming jump from 0x0028, if 0xb88d4fde > stack[-1] // Inputs[1] { @00AC stack[-1] } 00AB 5B JUMPDEST 00AC 80 DUP1 00AD 63 PUSH4 0x8da5cb5b 00B2 11 GT 00B3 61 PUSH2 0x00f2 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00f2, if 0x8da5cb5b > stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x8da5cb5b > stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x8da5cb5b 00BD 14 EQ 00BE 61 PUSH2 0x049c 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x049c, if 0x8da5cb5b == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0x95d89b41 00C8 14 EQ 00C9 61 PUSH2 0x04bf 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04bf, if 0x95d89b41 == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0xa22cb465 00D3 14 EQ 00D4 61 PUSH2 0x04d4 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d4, 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 0xafdf6134 00DE 14 EQ 00DF 61 PUSH2 0x04f4 00E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f4, if 0xafdf6134 == stack[-1] label_00E3: // Incoming jump from 0x00E2, if not 0xafdf6134 == stack[-1] // Inputs[1] { @00E3 stack[-1] } 00E3 80 DUP1 00E4 63 PUSH4 0xb19960e6 00E9 14 EQ 00EA 61 PUSH2 0x0514 00ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0514, if 0xb19960e6 == stack[-1] label_00EE: // Incoming jump from 0x00ED, if not 0xb19960e6 == stack[-1] // Inputs[1] { @00F1 memory[0x00:0x00] } 00EE 60 PUSH1 0x00 00F0 80 DUP1 00F1 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F1 revert(memory[0x00:0x00]); } // Block terminates label_00F2: // Incoming jump from 0x00B6, if 0x8da5cb5b > stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F2 5B JUMPDEST 00F3 80 DUP1 00F4 63 PUSH4 0x70a08231 00F9 14 EQ 00FA 61 PUSH2 0x043d 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x043d, if 0x70a08231 == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x70a08231 == stack[-1] // Inputs[1] { @00FE stack[-1] } 00FE 80 DUP1 00FF 63 PUSH4 0x715018a6 0104 14 EQ 0105 61 PUSH2 0x045d 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x045d, if 0x715018a6 == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x715018a6 == stack[-1] // Inputs[1] { @0109 stack[-1] } 0109 80 DUP1 010A 63 PUSH4 0x79ba5097 010F 14 EQ 0110 61 PUSH2 0x0472 0113 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0472, if 0x79ba5097 == stack[-1] label_0114: // Incoming jump from 0x0113, if not 0x79ba5097 == stack[-1] // Inputs[1] { @0114 stack[-1] } 0114 80 DUP1 0115 63 PUSH4 0x8456cb59 011A 14 EQ 011B 61 PUSH2 0x0487 011E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0487, if 0x8456cb59 == stack[-1] label_011F: // Incoming jump from 0x011E, if not 0x8456cb59 == stack[-1] // Inputs[1] { @0122 memory[0x00:0x00] } 011F 60 PUSH1 0x00 0121 80 DUP1 0122 FD *REVERT // Stack delta = +0 // Outputs[1] { @0122 revert(memory[0x00:0x00]); } // Block terminates label_0123: // Incoming jump from 0x001D, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0124 stack[-1] } 0123 5B JUMPDEST 0124 80 DUP1 0125 63 PUSH4 0x41f43434 012A 11 GT 012B 61 PUSH2 0x01a6 012E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a6, if 0x41f43434 > stack[-1] label_012F: // Incoming jump from 0x012E, if not 0x41f43434 > stack[-1] // Inputs[1] { @012F stack[-1] } 012F 80 DUP1 0130 63 PUSH4 0x5c975abb 0135 11 GT 0136 61 PUSH2 0x0175 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0175, if 0x5c975abb > stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x5c975abb > stack[-1] // Inputs[1] { @013A stack[-1] } 013A 80 DUP1 013B 63 PUSH4 0x5c975abb 0140 14 EQ 0141 61 PUSH2 0x03b0 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b0, if 0x5c975abb == stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x5c975abb == stack[-1] // Inputs[1] { @0145 stack[-1] } 0145 80 DUP1 0146 63 PUSH4 0x616cdb1e 014B 14 EQ 014C 61 PUSH2 0x03c8 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c8, if 0x616cdb1e == stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x616cdb1e == stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x6352211e 0156 14 EQ 0157 61 PUSH2 0x03e8 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e8, if 0x6352211e == stack[-1] label_015B: // Incoming jump from 0x015A, if not 0x6352211e == stack[-1] // Inputs[1] { @015B stack[-1] } 015B 80 DUP1 015C 63 PUSH4 0x6c0360eb 0161 14 EQ 0162 61 PUSH2 0x0408 0165 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0408, if 0x6c0360eb == stack[-1] label_0166: // Incoming jump from 0x0165, if not 0x6c0360eb == stack[-1] // Inputs[1] { @0166 stack[-1] } 0166 80 DUP1 0167 63 PUSH4 0x6f8b44b0 016C 14 EQ 016D 61 PUSH2 0x041d 0170 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x041d, if 0x6f8b44b0 == stack[-1] label_0171: // Incoming jump from 0x0170, if not 0x6f8b44b0 == stack[-1] // Inputs[1] { @0174 memory[0x00:0x00] } 0171 60 PUSH1 0x00 0173 80 DUP1 0174 FD *REVERT // Stack delta = +0 // Outputs[1] { @0174 revert(memory[0x00:0x00]); } // Block terminates label_0175: // Incoming jump from 0x0139, if 0x5c975abb > stack[-1] // Inputs[1] { @0176 stack[-1] } 0175 5B JUMPDEST 0176 80 DUP1 0177 63 PUSH4 0x41f43434 017C 14 EQ 017D 61 PUSH2 0x033b 0180 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033b, if 0x41f43434 == stack[-1] label_0181: // Incoming jump from 0x0180, if not 0x41f43434 == stack[-1] // Inputs[1] { @0181 stack[-1] } 0181 80 DUP1 0182 63 PUSH4 0x42842e0e 0187 14 EQ 0188 61 PUSH2 0x035d 018B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x035d, if 0x42842e0e == stack[-1] label_018C: // Incoming jump from 0x018B, if not 0x42842e0e == stack[-1] // Inputs[1] { @018C stack[-1] } 018C 80 DUP1 018D 63 PUSH4 0x51cff8d9 0192 14 EQ 0193 61 PUSH2 0x0370 0196 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0370, if 0x51cff8d9 == stack[-1] label_0197: // Incoming jump from 0x0196, if not 0x51cff8d9 == stack[-1] // Inputs[1] { @0197 stack[-1] } 0197 80 DUP1 0198 63 PUSH4 0x55f804b3 019D 14 EQ 019E 61 PUSH2 0x0390 01A1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0390, if 0x55f804b3 == stack[-1] label_01A2: // Incoming jump from 0x01A1, if not 0x55f804b3 == stack[-1] // Inputs[1] { @01A5 memory[0x00:0x00] } 01A2 60 PUSH1 0x00 01A4 80 DUP1 01A5 FD *REVERT // Stack delta = +0 // Outputs[1] { @01A5 revert(memory[0x00:0x00]); } // Block terminates label_01A6: // Incoming jump from 0x012E, if 0x41f43434 > stack[-1] // Inputs[1] { @01A7 stack[-1] } 01A6 5B JUMPDEST 01A7 80 DUP1 01A8 63 PUSH4 0x18160ddd 01AD 11 GT 01AE 61 PUSH2 0x01ed 01B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ed, if 0x18160ddd > stack[-1] label_01B2: // Incoming jump from 0x01B1, if not 0x18160ddd > stack[-1] // Inputs[1] { @01B2 stack[-1] } 01B2 80 DUP1 01B3 63 PUSH4 0x18160ddd 01B8 14 EQ 01B9 61 PUSH2 0x02c3 01BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c3, if 0x18160ddd == stack[-1] label_01BD: // Incoming jump from 0x01BC, if not 0x18160ddd == stack[-1] // Inputs[1] { @01BD stack[-1] } 01BD 80 DUP1 01BE 63 PUSH4 0x23b872dd 01C3 14 EQ 01C4 61 PUSH2 0x02ea 01C7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ea, if 0x23b872dd == stack[-1] label_01C8: // Incoming jump from 0x01C7, if not 0x23b872dd == stack[-1] // Inputs[1] { @01C8 stack[-1] } 01C8 80 DUP1 01C9 63 PUSH4 0x32cb6b0c 01CE 14 EQ 01CF 61 PUSH2 0x02fd 01D2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02fd, if 0x32cb6b0c == stack[-1] label_01D3: // Incoming jump from 0x01D2, if not 0x32cb6b0c == stack[-1] // Inputs[1] { @01D3 stack[-1] } 01D3 80 DUP1 01D4 63 PUSH4 0x3f4ba83a 01D9 14 EQ 01DA 61 PUSH2 0x0313 01DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0313, if 0x3f4ba83a == stack[-1] label_01DE: // Incoming jump from 0x01DD, if not 0x3f4ba83a == stack[-1] // Inputs[1] { @01DE stack[-1] } 01DE 80 DUP1 01DF 63 PUSH4 0x40c10f19 01E4 14 EQ 01E5 61 PUSH2 0x0328 01E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0328, if 0x40c10f19 == stack[-1] label_01E9: // Incoming jump from 0x01E8, if not 0x40c10f19 == stack[-1] // Inputs[1] { @01EC memory[0x00:0x00] } 01E9 60 PUSH1 0x00 01EB 80 DUP1 01EC FD *REVERT // Stack delta = +0 // Outputs[1] { @01EC revert(memory[0x00:0x00]); } // Block terminates label_01ED: // Incoming jump from 0x01B1, if 0x18160ddd > stack[-1] // Inputs[1] { @01EE stack[-1] } 01ED 5B JUMPDEST 01EE 80 DUP1 01EF 63 PUSH4 0x01ffc9a7 01F4 14 EQ 01F5 61 PUSH2 0x021f 01F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x021f, if 0x01ffc9a7 == stack[-1] label_01F9: // Incoming jump from 0x01F8, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01F9 stack[-1] } 01F9 80 DUP1 01FA 63 PUSH4 0x06fdde03 01FF 14 EQ 0200 61 PUSH2 0x0254 0203 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0254, if 0x06fdde03 == stack[-1] label_0204: // Incoming jump from 0x0203, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0204 stack[-1] } 0204 80 DUP1 0205 63 PUSH4 0x081812fc 020A 14 EQ 020B 61 PUSH2 0x0276 020E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0276, if 0x081812fc == stack[-1] label_020F: // Incoming jump from 0x020E, if not 0x081812fc == stack[-1] // Inputs[1] { @020F stack[-1] } 020F 80 DUP1 0210 63 PUSH4 0x095ea7b3 0215 14 EQ 0216 61 PUSH2 0x02ae 0219 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ae, if 0x095ea7b3 == stack[-1] label_021A: // Incoming jump from 0x0219, if not 0x095ea7b3 == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @021E memory[0x00:0x00] } 021A 5B JUMPDEST 021B 60 PUSH1 0x00 021D 80 DUP1 021E FD *REVERT // Stack delta = +0 // Outputs[1] { @021E revert(memory[0x00:0x00]); } // Block terminates label_021F: // Incoming jump from 0x01F8, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0220 msg.value } 021F 5B JUMPDEST 0220 34 CALLVALUE 0221 80 DUP1 0222 15 ISZERO 0223 61 PUSH2 0x022b 0226 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0220 stack[0] = msg.value } // Block ends with conditional jump to 0x022b, if !msg.value label_0227: // Incoming jump from 0x0226, if not !msg.value // Inputs[1] { @022A memory[0x00:0x00] } 0227 60 PUSH1 0x00 0229 80 DUP1 022A FD *REVERT // Stack delta = +0 // Outputs[1] { @022A revert(memory[0x00:0x00]); } // Block terminates label_022B: // Incoming jump from 0x0226, if !msg.value // Inputs[1] { @0233 msg.data.length } 022B 5B JUMPDEST 022C 50 POP 022D 61 PUSH2 0x023f 0230 61 PUSH2 0x023a 0233 36 CALLDATASIZE 0234 60 PUSH1 0x04 0236 61 PUSH2 0x1607 0239 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @022D stack[-1] = 0x023f // @0230 stack[0] = 0x023a // @0233 stack[1] = msg.data.length // @0234 stack[2] = 0x04 // } // Block ends with call to 0x1607, returns to 0x023A label_023A: // Incoming return from call to 0x1607 at 0x0239 023A 5B JUMPDEST 023B 61 PUSH2 0x067d 023E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x067d label_023F: // Incoming return from call to 0x023A at 0x0239 // Incoming return from call to 0x05E2 at 0x05E1 // Incoming jump from 0x03C7 // Inputs[4] // { // @0242 memory[0x40:0x60] // @0243 stack[-1] // @024E memory[0x40:0x60] // @0253 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 023F 5B JUMPDEST 0240 60 PUSH1 0x40 0242 51 MLOAD 0243 90 SWAP1 0244 15 ISZERO 0245 15 ISZERO 0246 81 DUP2 0247 52 MSTORE 0248 60 PUSH1 0x20 024A 01 ADD 024B 5B JUMPDEST 024C 60 PUSH1 0x40 024E 51 MLOAD 024F 80 DUP1 0250 91 SWAP2 0251 03 SUB 0252 90 SWAP1 0253 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0247 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0253 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0254: // Incoming jump from 0x0203, if 0x06fdde03 == stack[-1] // Inputs[1] { @0255 msg.value } 0254 5B JUMPDEST 0255 34 CALLVALUE 0256 80 DUP1 0257 15 ISZERO 0258 61 PUSH2 0x0260 025B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0255 stack[0] = msg.value } // Block ends with conditional jump to 0x0260, if !msg.value label_025C: // Incoming jump from 0x025B, if not !msg.value // Inputs[1] { @025F memory[0x00:0x00] } 025C 60 PUSH1 0x00 025E 80 DUP1 025F FD *REVERT // Stack delta = +0 // Outputs[1] { @025F revert(memory[0x00:0x00]); } // Block terminates label_0260: // Incoming jump from 0x025B, if !msg.value 0260 5B JUMPDEST 0261 50 POP 0262 61 PUSH2 0x0269 0265 61 PUSH2 0x06cf 0268 56 *JUMP // Stack delta = +0 // Outputs[1] { @0262 stack[-1] = 0x0269 } // Block ends with call to 0x06cf, returns to 0x0269 label_0269: // Incoming return from call to 0x0A76 at 0x041C // Incoming return from call to 0x06CF at 0x0268 // Incoming return from call to 0x0BFC at 0x04D3 // Inputs[2] // { // @026C memory[0x40:0x60] // @0270 stack[-1] // } 0269 5B JUMPDEST 026A 60 PUSH1 0x40 026C 51 MLOAD 026D 61 PUSH2 0x024b 0270 91 SWAP2 0271 90 SWAP1 0272 61 PUSH2 0x1674 0275 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0270 stack[-1] = 0x024b // @0271 stack[1] = memory[0x40:0x60] // @0271 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1674 label_0276: // Incoming jump from 0x020E, if 0x081812fc == stack[-1] // Inputs[1] { @0277 msg.value } 0276 5B JUMPDEST 0277 34 CALLVALUE 0278 80 DUP1 0279 15 ISZERO 027A 61 PUSH2 0x0282 027D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0277 stack[0] = msg.value } // Block ends with conditional jump to 0x0282, if !msg.value label_027E: // Incoming jump from 0x027D, if not !msg.value // Inputs[1] { @0281 memory[0x00:0x00] } 027E 60 PUSH1 0x00 0280 80 DUP1 0281 FD *REVERT // Stack delta = +0 // Outputs[1] { @0281 revert(memory[0x00:0x00]); } // Block terminates label_0282: // Incoming jump from 0x027D, if !msg.value // Inputs[1] { @028A msg.data.length } 0282 5B JUMPDEST 0283 50 POP 0284 61 PUSH2 0x0296 0287 61 PUSH2 0x0291 028A 36 CALLDATASIZE 028B 60 PUSH1 0x04 028D 61 PUSH2 0x1687 0290 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0284 stack[-1] = 0x0296 // @0287 stack[0] = 0x0291 // @028A stack[1] = msg.data.length // @028B stack[2] = 0x04 // } // Block ends with call to 0x1687, returns to 0x0291 label_0291: // Incoming return from call to 0x1687 at 0x0290 0291 5B JUMPDEST 0292 61 PUSH2 0x0761 0295 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0761 label_0296: // Incoming jump from 0x04BE // Incoming jump from 0x05C6 // Incoming return from call to 0x0403 at 0x0402 // Incoming return from call to 0x0291 at 0x0290 // Incoming jump from 0x035C // Inputs[2] // { // @0299 memory[0x40:0x60] // @02A3 stack[-1] // } 0296 5B JUMPDEST 0297 60 PUSH1 0x40 0299 51 MLOAD 029A 60 PUSH1 0x01 029C 60 PUSH1 0x01 029E 60 PUSH1 0xa0 02A0 1B SHL 02A1 03 SUB 02A2 90 SWAP1 02A3 91 SWAP2 02A4 16 AND 02A5 81 DUP2 02A6 52 MSTORE 02A7 60 PUSH1 0x20 02A9 01 ADD 02AA 61 PUSH2 0x024b 02AD 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02A6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @02A9 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x024b label_02AE: // Incoming jump from 0x0219, if 0x095ea7b3 == stack[-1] // Inputs[1] { @02B5 msg.data.length } 02AE 5B JUMPDEST 02AF 61 PUSH2 0x02c1 02B2 61 PUSH2 0x02bc 02B5 36 CALLDATASIZE 02B6 60 PUSH1 0x04 02B8 61 PUSH2 0x16b5 02BB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02AF stack[0] = 0x02c1 // @02B2 stack[1] = 0x02bc // @02B5 stack[2] = msg.data.length // @02B6 stack[3] = 0x04 // } // Block ends with call to 0x16b5, returns to 0x02BC label_02BC: // Incoming return from call to 0x16B5 at 0x02BB 02BC 5B JUMPDEST 02BD 61 PUSH2 0x07a5 02C0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07a5 label_02C1: // Incoming return from call to 0x0438 at 0x0437 // Incoming return from call to 0x04EF at 0x04EE // Incoming return from call to 0x050F at 0x050E // Incoming return from call to 0x056E at 0x056D // Incoming return from call to 0x038B at 0x038A // Incoming return from call to 0x03E3 at 0x03E2 // Incoming return from call to 0x0336 at 0x0335 // Incoming return from call to 0x0538 at 0x0537 // Incoming return from call to 0x02BC at 0x02BB // Incoming return from call to 0x02F8 at 0x02F7 // Incoming return from call to 0x0B72 at 0x0486 // Incoming return from call to 0x0678 at 0x0677 // Incoming return from call to 0x0658 at 0x0657 02C1 5B JUMPDEST 02C2 00 *STOP // Stack delta = +0 // Outputs[1] { @02C2 stop(); } // Block terminates label_02C3: // Incoming jump from 0x01BC, if 0x18160ddd == stack[-1] // Inputs[1] { @02C4 msg.value } 02C3 5B JUMPDEST 02C4 34 CALLVALUE 02C5 80 DUP1 02C6 15 ISZERO 02C7 61 PUSH2 0x02cf 02CA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02C4 stack[0] = msg.value } // Block ends with conditional jump to 0x02cf, if !msg.value label_02CB: // Incoming jump from 0x02CA, if not !msg.value // Inputs[1] { @02CE memory[0x00:0x00] } 02CB 60 PUSH1 0x00 02CD 80 DUP1 02CE FD *REVERT // Stack delta = +0 // Outputs[1] { @02CE revert(memory[0x00:0x00]); } // Block terminates label_02CF: // Incoming jump from 0x02CA, if !msg.value // Inputs[3] // { // @02D3 storage[0x01] // @02D6 storage[0x00] // @02DF memory[0x40:0x60] // } 02CF 5B JUMPDEST 02D0 50 POP 02D1 60 PUSH1 0x01 02D3 54 SLOAD 02D4 60 PUSH1 0x00 02D6 54 SLOAD 02D7 03 SUB 02D8 60 PUSH1 0x00 02DA 19 NOT 02DB 01 ADD 02DC 5B JUMPDEST 02DD 60 PUSH1 0x40 02DF 51 MLOAD 02E0 90 SWAP1 02E1 81 DUP2 02E2 52 MSTORE 02E3 60 PUSH1 0x20 02E5 01 ADD 02E6 61 PUSH2 0x024b 02E9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02E2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0x00 + (storage[0x00] - storage[0x01]) // @02E5 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x024b label_02EA: // Incoming jump from 0x01C7, if 0x23b872dd == stack[-1] // Inputs[1] { @02F1 msg.data.length } 02EA 5B JUMPDEST 02EB 61 PUSH2 0x02c1 02EE 61 PUSH2 0x02f8 02F1 36 CALLDATASIZE 02F2 60 PUSH1 0x04 02F4 61 PUSH2 0x16e1 02F7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02EB stack[0] = 0x02c1 // @02EE stack[1] = 0x02f8 // @02F1 stack[2] = msg.data.length // @02F2 stack[3] = 0x04 // } // Block ends with call to 0x16e1, returns to 0x02F8 label_02F8: // Incoming return from call to 0x16E1 at 0x02F7 02F8 5B JUMPDEST 02F9 61 PUSH2 0x07be 02FC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07be label_02FD: // Incoming jump from 0x01D2, if 0x32cb6b0c == stack[-1] // Inputs[1] { @02FE msg.value } 02FD 5B JUMPDEST 02FE 34 CALLVALUE 02FF 80 DUP1 0300 15 ISZERO 0301 61 PUSH2 0x0309 0304 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02FE stack[0] = msg.value } // Block ends with conditional jump to 0x0309, if !msg.value label_0305: // Incoming jump from 0x0304, if not !msg.value // Inputs[1] { @0308 memory[0x00:0x00] } 0305 60 PUSH1 0x00 0307 80 DUP1 0308 FD *REVERT // Stack delta = +0 // Outputs[1] { @0308 revert(memory[0x00:0x00]); } // Block terminates label_0309: // Incoming jump from 0x0304, if !msg.value // Inputs[1] { @0310 storage[0x0b] } 0309 5B JUMPDEST 030A 50 POP 030B 61 PUSH2 0x02dc 030E 60 PUSH1 0x0b 0310 54 SLOAD 0311 81 DUP2 0312 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @030B stack[-1] = 0x02dc // @0310 stack[0] = storage[0x0b] // } // Block ends with unconditional jump to 0x02dc label_0313: // Incoming jump from 0x01DD, if 0x3f4ba83a == stack[-1] // Inputs[1] { @0314 msg.value } 0313 5B JUMPDEST 0314 34 CALLVALUE 0315 80 DUP1 0316 15 ISZERO 0317 61 PUSH2 0x031f 031A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0314 stack[0] = msg.value } // Block ends with conditional jump to 0x031f, if !msg.value label_031B: // Incoming jump from 0x031A, if not !msg.value // Inputs[1] { @031E memory[0x00:0x00] } 031B 60 PUSH1 0x00 031D 80 DUP1 031E FD *REVERT // Stack delta = +0 // Outputs[1] { @031E revert(memory[0x00:0x00]); } // Block terminates label_031F: // Incoming jump from 0x031A, if !msg.value 031F 5B JUMPDEST 0320 50 POP 0321 61 PUSH2 0x02c1 0324 61 PUSH2 0x07e9 0327 56 *JUMP // Stack delta = +0 // Outputs[1] { @0321 stack[-1] = 0x02c1 } // Block ends with unconditional jump to 0x07e9 label_0328: // Incoming jump from 0x01E8, if 0x40c10f19 == stack[-1] // Inputs[1] { @032F msg.data.length } 0328 5B JUMPDEST 0329 61 PUSH2 0x02c1 032C 61 PUSH2 0x0336 032F 36 CALLDATASIZE 0330 60 PUSH1 0x04 0332 61 PUSH2 0x16b5 0335 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0329 stack[0] = 0x02c1 // @032C stack[1] = 0x0336 // @032F stack[2] = msg.data.length // @0330 stack[3] = 0x04 // } // Block ends with call to 0x16b5, returns to 0x0336 label_0336: // Incoming return from call to 0x16B5 at 0x0335 0336 5B JUMPDEST 0337 61 PUSH2 0x07fb 033A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07fb label_033B: // Incoming jump from 0x0180, if 0x41f43434 == stack[-1] // Inputs[1] { @033C msg.value } 033B 5B JUMPDEST 033C 34 CALLVALUE 033D 80 DUP1 033E 15 ISZERO 033F 61 PUSH2 0x0347 0342 57 *JUMPI // Stack delta = +1 // Outputs[1] { @033C stack[0] = msg.value } // Block ends with conditional jump to 0x0347, if !msg.value label_0343: // Incoming jump from 0x0342, if not !msg.value // Inputs[1] { @0346 memory[0x00:0x00] } 0343 60 PUSH1 0x00 0345 80 DUP1 0346 FD *REVERT // Stack delta = +0 // Outputs[1] { @0346 revert(memory[0x00:0x00]); } // Block terminates label_0347: // Incoming jump from 0x0342, if !msg.value 0347 5B JUMPDEST 0348 50 POP 0349 61 PUSH2 0x0296 034C 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 035B 81 DUP2 035C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0349 stack[-1] = 0x0296 // @034C stack[0] = 0xaaeb6d7670e522a718067333cd4e // } // Block ends with unconditional jump to 0x0296 label_035D: // Incoming jump from 0x018B, if 0x42842e0e == stack[-1] // Inputs[1] { @0364 msg.data.length } 035D 5B JUMPDEST 035E 61 PUSH2 0x02c1 0361 61 PUSH2 0x036b 0364 36 CALLDATASIZE 0365 60 PUSH1 0x04 0367 61 PUSH2 0x16e1 036A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @035E stack[0] = 0x02c1 // @0361 stack[1] = 0x036b // @0364 stack[2] = msg.data.length // @0365 stack[3] = 0x04 // } // Block ends with call to 0x16e1, returns to 0x036B label_036B: // Incoming return from call to 0x16E1 at 0x036A 036B 5B JUMPDEST 036C 61 PUSH2 0x098d 036F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x098d label_0370: // Incoming jump from 0x0196, if 0x51cff8d9 == stack[-1] // Inputs[1] { @0371 msg.value } 0370 5B JUMPDEST 0371 34 CALLVALUE 0372 80 DUP1 0373 15 ISZERO 0374 61 PUSH2 0x037c 0377 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0371 stack[0] = msg.value } // Block ends with conditional jump to 0x037c, if !msg.value label_0378: // Incoming jump from 0x0377, if not !msg.value // Inputs[1] { @037B memory[0x00:0x00] } 0378 60 PUSH1 0x00 037A 80 DUP1 037B FD *REVERT // Stack delta = +0 // Outputs[1] { @037B revert(memory[0x00:0x00]); } // Block terminates label_037C: // Incoming jump from 0x0377, if !msg.value // Inputs[1] { @0384 msg.data.length } 037C 5B JUMPDEST 037D 50 POP 037E 61 PUSH2 0x02c1 0381 61 PUSH2 0x038b 0384 36 CALLDATASIZE 0385 60 PUSH1 0x04 0387 61 PUSH2 0x1722 038A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @037E stack[-1] = 0x02c1 // @0381 stack[0] = 0x038b // @0384 stack[1] = msg.data.length // @0385 stack[2] = 0x04 // } // Block ends with call to 0x1722, returns to 0x038B label_038B: // Incoming return from call to 0x1722 at 0x038A 038B 5B JUMPDEST 038C 61 PUSH2 0x09a8 038F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09a8 label_0390: // Incoming jump from 0x01A1, if 0x55f804b3 == stack[-1] // Inputs[1] { @0391 msg.value } 0390 5B JUMPDEST 0391 34 CALLVALUE 0392 80 DUP1 0393 15 ISZERO 0394 61 PUSH2 0x039c 0397 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0391 stack[0] = msg.value } // Block ends with conditional jump to 0x039c, if !msg.value label_0398: // Incoming jump from 0x0397, if not !msg.value // Inputs[1] { @039B memory[0x00:0x00] } 0398 60 PUSH1 0x00 039A 80 DUP1 039B FD *REVERT // Stack delta = +0 // Outputs[1] { @039B revert(memory[0x00:0x00]); } // Block terminates label_039C: // Incoming jump from 0x0397, if !msg.value // Inputs[1] { @03A4 msg.data.length } 039C 5B JUMPDEST 039D 50 POP 039E 61 PUSH2 0x02c1 03A1 61 PUSH2 0x03ab 03A4 36 CALLDATASIZE 03A5 60 PUSH1 0x04 03A7 61 PUSH2 0x17de 03AA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @039E stack[-1] = 0x02c1 // @03A1 stack[0] = 0x03ab // @03A4 stack[1] = msg.data.length // @03A5 stack[2] = 0x04 // } // Block ends with call to 0x17de, returns to 0x03AB label_03AB: // Incoming return from call to 0x17DE at 0x03AA 03AB 5B JUMPDEST 03AC 61 PUSH2 0x0a4a 03AF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a4a label_03B0: // Incoming jump from 0x0144, if 0x5c975abb == stack[-1] // Inputs[1] { @03B1 msg.value } 03B0 5B JUMPDEST 03B1 34 CALLVALUE 03B2 80 DUP1 03B3 15 ISZERO 03B4 61 PUSH2 0x03bc 03B7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03B1 stack[0] = msg.value } // Block ends with conditional jump to 0x03bc, if !msg.value label_03B8: // Incoming jump from 0x03B7, if not !msg.value // Inputs[1] { @03BB memory[0x00:0x00] } 03B8 60 PUSH1 0x00 03BA 80 DUP1 03BB FD *REVERT // Stack delta = +0 // Outputs[1] { @03BB revert(memory[0x00:0x00]); } // Block terminates label_03BC: // Incoming jump from 0x03B7, if !msg.value // Inputs[1] { @03C0 storage[0x08] } 03BC 5B JUMPDEST 03BD 50 POP 03BE 60 PUSH1 0x08 03C0 54 SLOAD 03C1 60 PUSH1 0xff 03C3 16 AND 03C4 61 PUSH2 0x023f 03C7 56 *JUMP // Stack delta = +0 // Outputs[1] { @03C3 stack[-1] = 0xff & storage[0x08] } // Block ends with unconditional jump to 0x023f label_03C8: // Incoming jump from 0x014F, if 0x616cdb1e == stack[-1] // Inputs[1] { @03C9 msg.value } 03C8 5B JUMPDEST 03C9 34 CALLVALUE 03CA 80 DUP1 03CB 15 ISZERO 03CC 61 PUSH2 0x03d4 03CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03C9 stack[0] = msg.value } // Block ends with conditional jump to 0x03d4, if !msg.value label_03D0: // Incoming jump from 0x03CF, if not !msg.value // Inputs[1] { @03D3 memory[0x00:0x00] } 03D0 60 PUSH1 0x00 03D2 80 DUP1 03D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D3 revert(memory[0x00:0x00]); } // Block terminates label_03D4: // Incoming jump from 0x03CF, if !msg.value // Inputs[1] { @03DC msg.data.length } 03D4 5B JUMPDEST 03D5 50 POP 03D6 61 PUSH2 0x02c1 03D9 61 PUSH2 0x03e3 03DC 36 CALLDATASIZE 03DD 60 PUSH1 0x04 03DF 61 PUSH2 0x1687 03E2 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03D6 stack[-1] = 0x02c1 // @03D9 stack[0] = 0x03e3 // @03DC stack[1] = msg.data.length // @03DD stack[2] = 0x04 // } // Block ends with call to 0x1687, returns to 0x03E3 label_03E3: // Incoming return from call to 0x1687 at 0x03E2 03E3 5B JUMPDEST 03E4 61 PUSH2 0x0a5e 03E7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a5e label_03E8: // Incoming jump from 0x015A, if 0x6352211e == stack[-1] // Inputs[1] { @03E9 msg.value } 03E8 5B JUMPDEST 03E9 34 CALLVALUE 03EA 80 DUP1 03EB 15 ISZERO 03EC 61 PUSH2 0x03f4 03EF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03E9 stack[0] = msg.value } // Block ends with conditional jump to 0x03f4, if !msg.value label_03F0: // Incoming jump from 0x03EF, if not !msg.value // Inputs[1] { @03F3 memory[0x00:0x00] } 03F0 60 PUSH1 0x00 03F2 80 DUP1 03F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @03F3 revert(memory[0x00:0x00]); } // Block terminates label_03F4: // Incoming jump from 0x03EF, if !msg.value // Inputs[1] { @03FC msg.data.length } 03F4 5B JUMPDEST 03F5 50 POP 03F6 61 PUSH2 0x0296 03F9 61 PUSH2 0x0403 03FC 36 CALLDATASIZE 03FD 60 PUSH1 0x04 03FF 61 PUSH2 0x1687 0402 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03F6 stack[-1] = 0x0296 // @03F9 stack[0] = 0x0403 // @03FC stack[1] = msg.data.length // @03FD stack[2] = 0x04 // } // Block ends with call to 0x1687, returns to 0x0403 label_0403: // Incoming return from call to 0x1687 at 0x0402 0403 5B JUMPDEST 0404 61 PUSH2 0x0a6b 0407 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a6b label_0408: // Incoming jump from 0x0165, if 0x6c0360eb == stack[-1] // Inputs[1] { @0409 msg.value } 0408 5B JUMPDEST 0409 34 CALLVALUE 040A 80 DUP1 040B 15 ISZERO 040C 61 PUSH2 0x0414 040F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0409 stack[0] = msg.value } // Block ends with conditional jump to 0x0414, if !msg.value label_0410: // Incoming jump from 0x040F, if not !msg.value // Inputs[1] { @0413 memory[0x00:0x00] } 0410 60 PUSH1 0x00 0412 80 DUP1 0413 FD *REVERT // Stack delta = +0 // Outputs[1] { @0413 revert(memory[0x00:0x00]); } // Block terminates label_0414: // Incoming jump from 0x040F, if !msg.value 0414 5B JUMPDEST 0415 50 POP 0416 61 PUSH2 0x0269 0419 61 PUSH2 0x0a76 041C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0416 stack[-1] = 0x0269 } // Block ends with call to 0x0a76, returns to 0x0269 label_041D: // Incoming jump from 0x0170, if 0x6f8b44b0 == stack[-1] // Inputs[1] { @041E msg.value } 041D 5B JUMPDEST 041E 34 CALLVALUE 041F 80 DUP1 0420 15 ISZERO 0421 61 PUSH2 0x0429 0424 57 *JUMPI // Stack delta = +1 // Outputs[1] { @041E stack[0] = msg.value } // Block ends with conditional jump to 0x0429, if !msg.value label_0425: // Incoming jump from 0x0424, if not !msg.value // Inputs[1] { @0428 memory[0x00:0x00] } 0425 60 PUSH1 0x00 0427 80 DUP1 0428 FD *REVERT // Stack delta = +0 // Outputs[1] { @0428 revert(memory[0x00:0x00]); } // Block terminates label_0429: // Incoming jump from 0x0424, if !msg.value // Inputs[1] { @0431 msg.data.length } 0429 5B JUMPDEST 042A 50 POP 042B 61 PUSH2 0x02c1 042E 61 PUSH2 0x0438 0431 36 CALLDATASIZE 0432 60 PUSH1 0x04 0434 61 PUSH2 0x1687 0437 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @042B stack[-1] = 0x02c1 // @042E stack[0] = 0x0438 // @0431 stack[1] = msg.data.length // @0432 stack[2] = 0x04 // } // Block ends with call to 0x1687, returns to 0x0438 label_0438: // Incoming return from call to 0x1687 at 0x0437 0438 5B JUMPDEST 0439 61 PUSH2 0x0b04 043C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b04 label_043D: // Incoming jump from 0x00FD, if 0x70a08231 == stack[-1] // Inputs[1] { @043E msg.value } 043D 5B JUMPDEST 043E 34 CALLVALUE 043F 80 DUP1 0440 15 ISZERO 0441 61 PUSH2 0x0449 0444 57 *JUMPI // Stack delta = +1 // Outputs[1] { @043E stack[0] = msg.value } // Block ends with conditional jump to 0x0449, if !msg.value label_0445: // Incoming jump from 0x0444, if not !msg.value // Inputs[1] { @0448 memory[0x00:0x00] } 0445 60 PUSH1 0x00 0447 80 DUP1 0448 FD *REVERT // Stack delta = +0 // Outputs[1] { @0448 revert(memory[0x00:0x00]); } // Block terminates label_0449: // Incoming jump from 0x0444, if !msg.value // Inputs[1] { @0451 msg.data.length } 0449 5B JUMPDEST 044A 50 POP 044B 61 PUSH2 0x02dc 044E 61 PUSH2 0x0458 0451 36 CALLDATASIZE 0452 60 PUSH1 0x04 0454 61 PUSH2 0x1722 0457 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @044B stack[-1] = 0x02dc // @044E stack[0] = 0x0458 // @0451 stack[1] = msg.data.length // @0452 stack[2] = 0x04 // } // Block ends with call to 0x1722, returns to 0x0458 label_0458: // Incoming return from call to 0x1722 at 0x0457 0458 5B JUMPDEST 0459 61 PUSH2 0x0b11 045C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b11 label_045D: // Incoming jump from 0x0108, if 0x715018a6 == stack[-1] // Inputs[1] { @045E msg.value } 045D 5B JUMPDEST 045E 34 CALLVALUE 045F 80 DUP1 0460 15 ISZERO 0461 61 PUSH2 0x0469 0464 57 *JUMPI // Stack delta = +1 // Outputs[1] { @045E stack[0] = msg.value } // Block ends with conditional jump to 0x0469, if !msg.value label_0465: // Incoming jump from 0x0464, if not !msg.value // Inputs[1] { @0468 memory[0x00:0x00] } 0465 60 PUSH1 0x00 0467 80 DUP1 0468 FD *REVERT // Stack delta = +0 // Outputs[1] { @0468 revert(memory[0x00:0x00]); } // Block terminates label_0469: // Incoming jump from 0x0464, if !msg.value 0469 5B JUMPDEST 046A 50 POP 046B 61 PUSH2 0x02c1 046E 61 PUSH2 0x0b60 0471 56 *JUMP // Stack delta = +0 // Outputs[1] { @046B stack[-1] = 0x02c1 } // Block ends with unconditional jump to 0x0b60 label_0472: // Incoming jump from 0x0113, if 0x79ba5097 == stack[-1] // Inputs[1] { @0473 msg.value } 0472 5B JUMPDEST 0473 34 CALLVALUE 0474 80 DUP1 0475 15 ISZERO 0476 61 PUSH2 0x047e 0479 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0473 stack[0] = msg.value } // Block ends with conditional jump to 0x047e, if !msg.value label_047A: // Incoming jump from 0x0479, if not !msg.value // Inputs[1] { @047D memory[0x00:0x00] } 047A 60 PUSH1 0x00 047C 80 DUP1 047D FD *REVERT // Stack delta = +0 // Outputs[1] { @047D revert(memory[0x00:0x00]); } // Block terminates label_047E: // Incoming jump from 0x0479, if !msg.value 047E 5B JUMPDEST 047F 50 POP 0480 61 PUSH2 0x02c1 0483 61 PUSH2 0x0b72 0486 56 *JUMP // Stack delta = +0 // Outputs[1] { @0480 stack[-1] = 0x02c1 } // Block ends with call to 0x0b72, returns to 0x02C1 label_0487: // Incoming jump from 0x011E, if 0x8456cb59 == stack[-1] // Inputs[1] { @0488 msg.value } 0487 5B JUMPDEST 0488 34 CALLVALUE 0489 80 DUP1 048A 15 ISZERO 048B 61 PUSH2 0x0493 048E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0488 stack[0] = msg.value } // Block ends with conditional jump to 0x0493, if !msg.value label_048F: // Incoming jump from 0x048E, if not !msg.value // Inputs[1] { @0492 memory[0x00:0x00] } 048F 60 PUSH1 0x00 0491 80 DUP1 0492 FD *REVERT // Stack delta = +0 // Outputs[1] { @0492 revert(memory[0x00:0x00]); } // Block terminates label_0493: // Incoming jump from 0x048E, if !msg.value 0493 5B JUMPDEST 0494 50 POP 0495 61 PUSH2 0x02c1 0498 61 PUSH2 0x0bec 049B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0495 stack[-1] = 0x02c1 } // Block ends with unconditional jump to 0x0bec label_049C: // Incoming jump from 0x00C1, if 0x8da5cb5b == stack[-1] // Inputs[1] { @049D msg.value } 049C 5B JUMPDEST 049D 34 CALLVALUE 049E 80 DUP1 049F 15 ISZERO 04A0 61 PUSH2 0x04a8 04A3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @049D stack[0] = msg.value } // Block ends with conditional jump to 0x04a8, if !msg.value label_04A4: // Incoming jump from 0x04A3, if not !msg.value // Inputs[1] { @04A7 memory[0x00:0x00] } 04A4 60 PUSH1 0x00 04A6 80 DUP1 04A7 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A7 revert(memory[0x00:0x00]); } // Block terminates label_04A8: // Incoming jump from 0x04A3, if !msg.value // Inputs[1] { @04AC storage[0x08] } 04A8 5B JUMPDEST 04A9 50 POP 04AA 60 PUSH1 0x08 04AC 54 SLOAD 04AD 61 PUSH2 0x0100 04B0 90 SWAP1 04B1 04 DIV 04B2 60 PUSH1 0x01 04B4 60 PUSH1 0x01 04B6 60 PUSH1 0xa0 04B8 1B SHL 04B9 03 SUB 04BA 16 AND 04BB 61 PUSH2 0x0296 04BE 56 *JUMP // Stack delta = +0 // Outputs[1] { @04BA stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x08] / 0x0100 } // Block ends with unconditional jump to 0x0296 label_04BF: // Incoming jump from 0x00CC, if 0x95d89b41 == stack[-1] // Inputs[1] { @04C0 msg.value } 04BF 5B JUMPDEST 04C0 34 CALLVALUE 04C1 80 DUP1 04C2 15 ISZERO 04C3 61 PUSH2 0x04cb 04C6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04C0 stack[0] = msg.value } // Block ends with conditional jump to 0x04cb, if !msg.value label_04C7: // Incoming jump from 0x04C6, if not !msg.value // Inputs[1] { @04CA memory[0x00:0x00] } 04C7 60 PUSH1 0x00 04C9 80 DUP1 04CA FD *REVERT // Stack delta = +0 // Outputs[1] { @04CA revert(memory[0x00:0x00]); } // Block terminates label_04CB: // Incoming jump from 0x04C6, if !msg.value 04CB 5B JUMPDEST 04CC 50 POP 04CD 61 PUSH2 0x0269 04D0 61 PUSH2 0x0bfc 04D3 56 *JUMP // Stack delta = +0 // Outputs[1] { @04CD stack[-1] = 0x0269 } // Block ends with call to 0x0bfc, returns to 0x0269 label_04D4: // Incoming jump from 0x00D7, if 0xa22cb465 == stack[-1] // Inputs[1] { @04D5 msg.value } 04D4 5B JUMPDEST 04D5 34 CALLVALUE 04D6 80 DUP1 04D7 15 ISZERO 04D8 61 PUSH2 0x04e0 04DB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04D5 stack[0] = msg.value } // Block ends with conditional jump to 0x04e0, if !msg.value label_04DC: // Incoming jump from 0x04DB, if not !msg.value // Inputs[1] { @04DF memory[0x00:0x00] } 04DC 60 PUSH1 0x00 04DE 80 DUP1 04DF FD *REVERT // Stack delta = +0 // Outputs[1] { @04DF revert(memory[0x00:0x00]); } // Block terminates label_04E0: // Incoming jump from 0x04DB, if !msg.value // Inputs[1] { @04E8 msg.data.length } 04E0 5B JUMPDEST 04E1 50 POP 04E2 61 PUSH2 0x02c1 04E5 61 PUSH2 0x04ef 04E8 36 CALLDATASIZE 04E9 60 PUSH1 0x04 04EB 61 PUSH2 0x1835 04EE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04E2 stack[-1] = 0x02c1 // @04E5 stack[0] = 0x04ef // @04E8 stack[1] = msg.data.length // @04E9 stack[2] = 0x04 // } // Block ends with call to 0x1835, returns to 0x04EF label_04EF: // Incoming return from call to 0x1835 at 0x04EE 04EF 5B JUMPDEST 04F0 61 PUSH2 0x0c0b 04F3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c0b label_04F4: // Incoming jump from 0x00E2, if 0xafdf6134 == stack[-1] // Inputs[1] { @04F5 msg.value } 04F4 5B JUMPDEST 04F5 34 CALLVALUE 04F6 80 DUP1 04F7 15 ISZERO 04F8 61 PUSH2 0x0500 04FB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04F5 stack[0] = msg.value } // Block ends with conditional jump to 0x0500, if !msg.value label_04FC: // Incoming jump from 0x04FB, if not !msg.value // Inputs[1] { @04FF memory[0x00:0x00] } 04FC 60 PUSH1 0x00 04FE 80 DUP1 04FF FD *REVERT // Stack delta = +0 // Outputs[1] { @04FF revert(memory[0x00:0x00]); } // Block terminates label_0500: // Incoming jump from 0x04FB, if !msg.value // Inputs[1] { @0508 msg.data.length } 0500 5B JUMPDEST 0501 50 POP 0502 61 PUSH2 0x02c1 0505 61 PUSH2 0x050f 0508 36 CALLDATASIZE 0509 60 PUSH1 0x04 050B 61 PUSH2 0x1687 050E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0502 stack[-1] = 0x02c1 // @0505 stack[0] = 0x050f // @0508 stack[1] = msg.data.length // @0509 stack[2] = 0x04 // } // Block ends with call to 0x1687, returns to 0x050F label_050F: // Incoming return from call to 0x1687 at 0x050E 050F 5B JUMPDEST 0510 61 PUSH2 0x0c1f 0513 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c1f label_0514: // Incoming jump from 0x00ED, if 0xb19960e6 == stack[-1] // Inputs[1] { @0515 msg.value } 0514 5B JUMPDEST 0515 34 CALLVALUE 0516 80 DUP1 0517 15 ISZERO 0518 61 PUSH2 0x0520 051B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0515 stack[0] = msg.value } // Block ends with conditional jump to 0x0520, if !msg.value label_051C: // Incoming jump from 0x051B, if not !msg.value // Inputs[1] { @051F memory[0x00:0x00] } 051C 60 PUSH1 0x00 051E 80 DUP1 051F FD *REVERT // Stack delta = +0 // Outputs[1] { @051F revert(memory[0x00:0x00]); } // Block terminates label_0520: // Incoming jump from 0x051B, if !msg.value // Inputs[1] { @0527 storage[0x0c] } 0520 5B JUMPDEST 0521 50 POP 0522 61 PUSH2 0x02dc 0525 60 PUSH1 0x0c 0527 54 SLOAD 0528 81 DUP2 0529 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0522 stack[-1] = 0x02dc // @0527 stack[0] = storage[0x0c] // } // Block ends with unconditional jump to 0x02dc label_052A: // Incoming jump from 0x007A, if 0xb88d4fde == stack[-1] // Inputs[1] { @0531 msg.data.length } 052A 5B JUMPDEST 052B 61 PUSH2 0x02c1 052E 61 PUSH2 0x0538 0531 36 CALLDATASIZE 0532 60 PUSH1 0x04 0534 61 PUSH2 0x186e 0537 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @052B stack[0] = 0x02c1 // @052E stack[1] = 0x0538 // @0531 stack[2] = msg.data.length // @0532 stack[3] = 0x04 // } // Block ends with call to 0x186e, returns to 0x0538 label_0538: // Incoming return from call to 0x186E at 0x0537 0538 5B JUMPDEST 0539 61 PUSH2 0x0c2c 053C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c2c label_053D: // Incoming jump from 0x0085, if 0xc002d23d == stack[-1] // Inputs[1] { @053E msg.value } 053D 5B JUMPDEST 053E 34 CALLVALUE 053F 80 DUP1 0540 15 ISZERO 0541 61 PUSH2 0x0549 0544 57 *JUMPI // Stack delta = +1 // Outputs[1] { @053E stack[0] = msg.value } // Block ends with conditional jump to 0x0549, if !msg.value label_0545: // Incoming jump from 0x0544, if not !msg.value // Inputs[1] { @0548 memory[0x00:0x00] } 0545 60 PUSH1 0x00 0547 80 DUP1 0548 FD *REVERT // Stack delta = +0 // Outputs[1] { @0548 revert(memory[0x00:0x00]); } // Block terminates label_0549: // Incoming jump from 0x0544, if !msg.value // Inputs[1] { @0550 storage[0x0e] } 0549 5B JUMPDEST 054A 50 POP 054B 61 PUSH2 0x02dc 054E 60 PUSH1 0x0e 0550 54 SLOAD 0551 81 DUP2 0552 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @054B stack[-1] = 0x02dc // @0550 stack[0] = storage[0x0e] // } // Block ends with unconditional jump to 0x02dc label_0553: // Incoming jump from 0x0090, if 0xc204642c == stack[-1] // Inputs[1] { @0554 msg.value } 0553 5B JUMPDEST 0554 34 CALLVALUE 0555 80 DUP1 0556 15 ISZERO 0557 61 PUSH2 0x055f 055A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0554 stack[0] = msg.value } // Block ends with conditional jump to 0x055f, if !msg.value label_055B: // Incoming jump from 0x055A, if not !msg.value // Inputs[1] { @055E memory[0x00:0x00] } 055B 60 PUSH1 0x00 055D 80 DUP1 055E FD *REVERT // Stack delta = +0 // Outputs[1] { @055E revert(memory[0x00:0x00]); } // Block terminates label_055F: // Incoming jump from 0x055A, if !msg.value // Inputs[1] { @0567 msg.data.length } 055F 5B JUMPDEST 0560 50 POP 0561 61 PUSH2 0x02c1 0564 61 PUSH2 0x056e 0567 36 CALLDATASIZE 0568 60 PUSH1 0x04 056A 61 PUSH2 0x18ee 056D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0561 stack[-1] = 0x02c1 // @0564 stack[0] = 0x056e // @0567 stack[1] = msg.data.length // @0568 stack[2] = 0x04 // } // Block ends with call to 0x18ee, returns to 0x056E label_056E: // Incoming return from call to 0x18EE at 0x056D 056E 5B JUMPDEST 056F 61 PUSH2 0x0c70 0572 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c70 label_0573: // Incoming jump from 0x009B, if 0xc87b56dd == stack[-1] // Inputs[1] { @0574 msg.value } 0573 5B JUMPDEST 0574 34 CALLVALUE 0575 80 DUP1 0576 15 ISZERO 0577 61 PUSH2 0x057f 057A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0574 stack[0] = msg.value } // Block ends with conditional jump to 0x057f, if !msg.value label_057B: // Incoming jump from 0x057A, if not !msg.value // Inputs[1] { @057E memory[0x00:0x00] } 057B 60 PUSH1 0x00 057D 80 DUP1 057E FD *REVERT // Stack delta = +0 // Outputs[1] { @057E revert(memory[0x00:0x00]); } // Block terminates label_057F: // Incoming jump from 0x057A, if !msg.value // Inputs[1] { @0587 msg.data.length } 057F 5B JUMPDEST 0580 50 POP 0581 61 PUSH2 0x0269 0584 61 PUSH2 0x058e 0587 36 CALLDATASIZE 0588 60 PUSH1 0x04 058A 61 PUSH2 0x1687 058D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0581 stack[-1] = 0x0269 // @0584 stack[0] = 0x058e // @0587 stack[1] = msg.data.length // @0588 stack[2] = 0x04 // } // Block ends with call to 0x1687, returns to 0x058E label_058E: // Incoming return from call to 0x1687 at 0x058D 058E 5B JUMPDEST 058F 61 PUSH2 0x0cb9 0592 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cb9 label_0593: // Incoming jump from 0x00A6, if 0xde7fcb1d == stack[-1] // Inputs[1] { @0594 msg.value } 0593 5B JUMPDEST 0594 34 CALLVALUE 0595 80 DUP1 0596 15 ISZERO 0597 61 PUSH2 0x059f 059A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0594 stack[0] = msg.value } // Block ends with conditional jump to 0x059f, if !msg.value label_059B: // Incoming jump from 0x059A, if not !msg.value // Inputs[1] { @059E memory[0x00:0x00] } 059B 60 PUSH1 0x00 059D 80 DUP1 059E FD *REVERT // Stack delta = +0 // Outputs[1] { @059E revert(memory[0x00:0x00]); } // Block terminates label_059F: // Incoming jump from 0x059A, if !msg.value // Inputs[1] { @05A6 storage[0x0d] } 059F 5B JUMPDEST 05A0 50 POP 05A1 61 PUSH2 0x02dc 05A4 60 PUSH1 0x0d 05A6 54 SLOAD 05A7 81 DUP2 05A8 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @05A1 stack[-1] = 0x02dc // @05A6 stack[0] = storage[0x0d] // } // Block ends with unconditional jump to 0x02dc label_05A9: // Incoming jump from 0x003E, if 0xe30c3978 == stack[-1] // Inputs[1] { @05AA msg.value } 05A9 5B JUMPDEST 05AA 34 CALLVALUE 05AB 80 DUP1 05AC 15 ISZERO 05AD 61 PUSH2 0x05b5 05B0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05AA stack[0] = msg.value } // Block ends with conditional jump to 0x05b5, if !msg.value label_05B1: // Incoming jump from 0x05B0, if not !msg.value // Inputs[1] { @05B4 memory[0x00:0x00] } 05B1 60 PUSH1 0x00 05B3 80 DUP1 05B4 FD *REVERT // Stack delta = +0 // Outputs[1] { @05B4 revert(memory[0x00:0x00]); } // Block terminates label_05B5: // Incoming jump from 0x05B0, if !msg.value // Inputs[1] { @05B9 storage[0x09] } 05B5 5B JUMPDEST 05B6 50 POP 05B7 60 PUSH1 0x09 05B9 54 SLOAD 05BA 60 PUSH1 0x01 05BC 60 PUSH1 0x01 05BE 60 PUSH1 0xa0 05C0 1B SHL 05C1 03 SUB 05C2 16 AND 05C3 61 PUSH2 0x0296 05C6 56 *JUMP // Stack delta = +0 // Outputs[1] { @05C2 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x09] } // Block ends with unconditional jump to 0x0296 label_05C7: // Incoming jump from 0x0049, if 0xe985e9c5 == stack[-1] // Inputs[1] { @05C8 msg.value } 05C7 5B JUMPDEST 05C8 34 CALLVALUE 05C9 80 DUP1 05CA 15 ISZERO 05CB 61 PUSH2 0x05d3 05CE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05C8 stack[0] = msg.value } // Block ends with conditional jump to 0x05d3, if !msg.value label_05CF: // Incoming jump from 0x05CE, if not !msg.value // Inputs[1] { @05D2 memory[0x00:0x00] } 05CF 60 PUSH1 0x00 05D1 80 DUP1 05D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @05D2 revert(memory[0x00:0x00]); } // Block terminates label_05D3: // Incoming jump from 0x05CE, if !msg.value // Inputs[1] { @05DB msg.data.length } 05D3 5B JUMPDEST 05D4 50 POP 05D5 61 PUSH2 0x023f 05D8 61 PUSH2 0x05e2 05DB 36 CALLDATASIZE 05DC 60 PUSH1 0x04 05DE 61 PUSH2 0x19a6 05E1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05D5 stack[-1] = 0x023f // @05D8 stack[0] = 0x05e2 // @05DB stack[1] = msg.data.length // @05DC stack[2] = 0x04 // } // Block ends with call to 0x19a6, returns to 0x05E2 label_05E2: // Incoming return from call to 0x19A6 at 0x05E1 // Incoming call from 0x1016, returns to 0x1017 // Incoming call from 0x0F2F, returns to 0x0F30 // Inputs[6] // { // @05EB stack[-2] // @05FE memory[0x00:0x40] // @05FF stack[-1] // @0609 memory[0x00:0x40] // @060A storage[keccak256(memory[0x00:0x40])] // @060E stack[-3] // } 05E2 5B JUMPDEST 05E3 60 PUSH1 0x01 05E5 60 PUSH1 0x01 05E7 60 PUSH1 0xa0 05E9 1B SHL 05EA 03 SUB 05EB 91 SWAP2 05EC 82 DUP3 05ED 16 AND 05EE 60 PUSH1 0x00 05F0 90 SWAP1 05F1 81 DUP2 05F2 52 MSTORE 05F3 60 PUSH1 0x07 05F5 60 PUSH1 0x20 05F7 90 SWAP1 05F8 81 DUP2 05F9 52 MSTORE 05FA 60 PUSH1 0x40 05FC 80 DUP1 05FD 83 DUP4 05FE 20 SHA3 05FF 93 SWAP4 0600 90 SWAP1 0601 94 SWAP5 0602 16 AND 0603 82 DUP3 0604 52 MSTORE 0605 91 SWAP2 0606 90 SWAP1 0607 91 SWAP2 0608 52 MSTORE 0609 20 SHA3 060A 54 SLOAD 060B 60 PUSH1 0xff 060D 16 AND 060E 90 SWAP1 060F 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @05F2 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @05F9 memory[0x20:0x40] = 0x07 // @0604 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0608 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @060E stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0610: // Incoming jump from 0x0054, if 0xed9ec888 == stack[-1] // Inputs[1] { @0611 msg.value } 0610 5B JUMPDEST 0611 34 CALLVALUE 0612 80 DUP1 0613 15 ISZERO 0614 61 PUSH2 0x061c 0617 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0611 stack[0] = msg.value } // Block ends with conditional jump to 0x061c, if !msg.value label_0618: // Incoming jump from 0x0617, if not !msg.value // Inputs[1] { @061B memory[0x00:0x00] } 0618 60 PUSH1 0x00 061A 80 DUP1 061B FD *REVERT // Stack delta = +0 // Outputs[1] { @061B revert(memory[0x00:0x00]); } // Block terminates label_061C: // Incoming jump from 0x0617, if !msg.value // Inputs[1] { @0624 msg.data.length } 061C 5B JUMPDEST 061D 50 POP 061E 61 PUSH2 0x02dc 0621 61 PUSH2 0x062b 0624 36 CALLDATASIZE 0625 60 PUSH1 0x04 0627 61 PUSH2 0x1722 062A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @061E stack[-1] = 0x02dc // @0621 stack[0] = 0x062b // @0624 stack[1] = msg.data.length // @0625 stack[2] = 0x04 // } // Block ends with call to 0x1722, returns to 0x062B label_062B: // Incoming return from call to 0x1722 at 0x062A // Inputs[4] // { // @0633 stack[-1] // @0639 memory[0x00:0x40] // @063A storage[keccak256(memory[0x00:0x40])] // @063B stack[-2] // } 062B 5B JUMPDEST 062C 60 PUSH1 0x0f 062E 60 PUSH1 0x20 0630 52 MSTORE 0631 60 PUSH1 0x00 0633 90 SWAP1 0634 81 DUP2 0635 52 MSTORE 0636 60 PUSH1 0x40 0638 90 SWAP1 0639 20 SHA3 063A 54 SLOAD 063B 81 DUP2 063C 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0630 memory[0x20:0x40] = 0x0f // @0635 memory[0x00:0x20] = stack[-1] // @063A stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_063D: // Incoming jump from 0x005F, if 0xf2fde38b == stack[-1] // Inputs[1] { @063E msg.value } 063D 5B JUMPDEST 063E 34 CALLVALUE 063F 80 DUP1 0640 15 ISZERO 0641 61 PUSH2 0x0649 0644 57 *JUMPI // Stack delta = +1 // Outputs[1] { @063E stack[0] = msg.value } // Block ends with conditional jump to 0x0649, if !msg.value label_0645: // Incoming jump from 0x0644, if not !msg.value // Inputs[1] { @0648 memory[0x00:0x00] } 0645 60 PUSH1 0x00 0647 80 DUP1 0648 FD *REVERT // Stack delta = +0 // Outputs[1] { @0648 revert(memory[0x00:0x00]); } // Block terminates label_0649: // Incoming jump from 0x0644, if !msg.value // Inputs[1] { @0651 msg.data.length } 0649 5B JUMPDEST 064A 50 POP 064B 61 PUSH2 0x02c1 064E 61 PUSH2 0x0658 0651 36 CALLDATASIZE 0652 60 PUSH1 0x04 0654 61 PUSH2 0x1722 0657 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @064B stack[-1] = 0x02c1 // @064E stack[0] = 0x0658 // @0651 stack[1] = msg.data.length // @0652 stack[2] = 0x04 // } // Block ends with call to 0x1722, returns to 0x0658 label_0658: // Incoming return from call to 0x1722 at 0x0657 0658 5B JUMPDEST 0659 61 PUSH2 0x0d3d 065C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d3d label_065D: // Incoming jump from 0x006A, if 0xf4a0a528 == stack[-1] // Inputs[1] { @065E msg.value } 065D 5B JUMPDEST 065E 34 CALLVALUE 065F 80 DUP1 0660 15 ISZERO 0661 61 PUSH2 0x0669 0664 57 *JUMPI // Stack delta = +1 // Outputs[1] { @065E stack[0] = msg.value } // Block ends with conditional jump to 0x0669, if !msg.value label_0665: // Incoming jump from 0x0664, if not !msg.value // Inputs[1] { @0668 memory[0x00:0x00] } 0665 60 PUSH1 0x00 0667 80 DUP1 0668 FD *REVERT // Stack delta = +0 // Outputs[1] { @0668 revert(memory[0x00:0x00]); } // Block terminates label_0669: // Incoming jump from 0x0664, if !msg.value // Inputs[1] { @0671 msg.data.length } 0669 5B JUMPDEST 066A 50 POP 066B 61 PUSH2 0x02c1 066E 61 PUSH2 0x0678 0671 36 CALLDATASIZE 0672 60 PUSH1 0x04 0674 61 PUSH2 0x1687 0677 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @066B stack[-1] = 0x02c1 // @066E stack[0] = 0x0678 // @0671 stack[1] = msg.data.length // @0672 stack[2] = 0x04 // } // Block ends with call to 0x1687, returns to 0x0678 label_0678: // Incoming return from call to 0x1687 at 0x0677 0678 5B JUMPDEST 0679 61 PUSH2 0x0db4 067C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0db4 label_067D: // Incoming jump from 0x023E // Inputs[1] { @0691 stack[-1] } 067D 5B JUMPDEST 067E 60 PUSH1 0x00 0680 63 PUSH4 0x01ffc9a7 0685 60 PUSH1 0xe0 0687 1B SHL 0688 60 PUSH1 0x01 068A 60 PUSH1 0x01 068C 60 PUSH1 0xe0 068E 1B SHL 068F 03 SUB 0690 19 NOT 0691 83 DUP4 0692 16 AND 0693 14 EQ 0694 80 DUP1 0695 61 PUSH2 0x06ae 0698 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @067E stack[0] = 0x00 // @0693 stack[1] = stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // } // Block ends with conditional jump to 0x06ae, if stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 label_0699: // Incoming jump from 0x0698, if not stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // Inputs[1] { @06AB stack[-3] } 0699 50 POP 069A 63 PUSH4 0x80ac58cd 069F 60 PUSH1 0xe0 06A1 1B SHL 06A2 60 PUSH1 0x01 06A4 60 PUSH1 0x01 06A6 60 PUSH1 0xe0 06A8 1B SHL 06A9 03 SUB 06AA 19 NOT 06AB 83 DUP4 06AC 16 AND 06AD 14 EQ 06AE 5B JUMPDEST 06AF 80 DUP1 06B0 61 PUSH2 0x06c9 06B3 57 *JUMPI // Stack delta = +0 // Outputs[1] { @06AD stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 } // Block ends with conditional jump to 0x06c9, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 label_06B4: // Incoming jump from 0x06B3, if not stack[-1] // Incoming jump from 0x06B3, if not stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 // Inputs[1] { @06C6 stack[-3] } 06B4 50 POP 06B5 63 PUSH4 0x5b5e139f 06BA 60 PUSH1 0xe0 06BC 1B SHL 06BD 60 PUSH1 0x01 06BF 60 PUSH1 0x01 06C1 60 PUSH1 0xe0 06C3 1B SHL 06C4 03 SUB 06C5 19 NOT 06C6 83 DUP4 06C7 16 AND 06C8 14 EQ // Stack delta = +0 // Outputs[1] { @06C8 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x5b5e139f << 0xe0 } // Block continues label_06C9: // Incoming jump from 0x0E35, if !stack[-1] // Incoming jump from 0x06C8 // Incoming jump from 0x06B3, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 // Incoming return from call to 0x1338 at 0x0A75 // Incoming jump from 0x0E35, if !(stack[-3] < storage[0x00]) // Incoming jump from 0x06B3, if stack[-1] // Inputs[3] // { // @06CA stack[-1] // @06CA stack[-4] // @06CB stack[-3] // } 06C9 5B JUMPDEST 06CA 92 SWAP3 06CB 91 SWAP2 06CC 50 POP 06CD 50 POP 06CE 56 *JUMP // Stack delta = -3 // Outputs[1] { @06CA stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_06CF: // Incoming call from 0x0268, returns to 0x0269 // Inputs[1] { @06D5 storage[0x02] } 06CF 5B JUMPDEST 06D0 60 PUSH1 0x60 06D2 60 PUSH1 0x02 06D4 80 DUP1 06D5 54 SLOAD 06D6 61 PUSH2 0x06de 06D9 90 SWAP1 06DA 61 PUSH2 0x19d4 06DD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06D0 stack[0] = 0x60 // @06D2 stack[1] = 0x02 // @06D9 stack[2] = 0x06de // @06D9 stack[3] = storage[0x02] // } // Block ends with call to 0x19d4, returns to 0x06DE label_06DE: // Incoming return from call to 0x19D4 at 0x1563 // Incoming return from call to 0x19D4 at 0x06DD // Incoming return from call to 0x19D4 at 0x0C0A // Inputs[4] // { // @06DF stack[-1] // @06EE memory[0x40:0x60] // @06F6 stack[-2] // @0701 storage[stack[-2]] // } 06DE 5B JUMPDEST 06DF 80 DUP1 06E0 60 PUSH1 0x1f 06E2 01 ADD 06E3 60 PUSH1 0x20 06E5 80 DUP1 06E6 91 SWAP2 06E7 04 DIV 06E8 02 MUL 06E9 60 PUSH1 0x20 06EB 01 ADD 06EC 60 PUSH1 0x40 06EE 51 MLOAD 06EF 90 SWAP1 06F0 81 DUP2 06F1 01 ADD 06F2 60 PUSH1 0x40 06F4 52 MSTORE 06F5 80 DUP1 06F6 92 SWAP3 06F7 91 SWAP2 06F8 90 SWAP1 06F9 81 DUP2 06FA 81 DUP2 06FB 52 MSTORE 06FC 60 PUSH1 0x20 06FE 01 ADD 06FF 82 DUP3 0700 80 DUP1 0701 54 SLOAD 0702 61 PUSH2 0x070a 0705 90 SWAP1 0706 61 PUSH2 0x19d4 0709 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @06F4 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @06F6 stack[-2] = memory[0x40:0x60] // @06F7 stack[-1] = stack[-2] // @06F8 stack[0] = stack[-1] // @06FB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @06FE stack[1] = 0x20 + memory[0x40:0x60] // @06FF stack[2] = stack[-2] // @0705 stack[4] = storage[stack[-2]] // @0705 stack[3] = 0x070a // } // Block ends with call to 0x19d4, returns to 0x070A label_070A: // Incoming return from call to 0x19D4 at 0x0709 // Inputs[1] { @070B stack[-1] } 070A 5B JUMPDEST 070B 80 DUP1 070C 15 ISZERO 070D 61 PUSH2 0x0757 0710 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0757, if !stack[-1] label_0711: // Incoming jump from 0x0710, if not !stack[-1] // Inputs[1] { @0711 stack[-1] } 0711 80 DUP1 0712 60 PUSH1 0x1f 0714 10 LT 0715 61 PUSH2 0x072c 0718 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x072c, if 0x1f < stack[-1] label_0719: // Incoming jump from 0x0718, if not 0x1f < stack[-1] // Inputs[4] // { // @071D stack[-2] // @071E storage[stack[-2]] // @0721 stack[-3] // @0723 stack[-1] // } 0719 61 PUSH2 0x0100 071C 80 DUP1 071D 83 DUP4 071E 54 SLOAD 071F 04 DIV 0720 02 MUL 0721 83 DUP4 0722 52 MSTORE 0723 91 SWAP2 0724 60 PUSH1 0x20 0726 01 ADD 0727 91 SWAP2 0728 61 PUSH2 0x0757 072B 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0722 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0727 stack[-1] = stack[-1] // @0727 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0757 label_072C: // Incoming jump from 0x0718, if 0x1f < stack[-1] // Inputs[5] // { // @072D stack[-3] // @072E stack[-1] // @0730 stack[-2] // @0738 memory[0x00:0x20] // @073C storage[keccak256(memory[0x00:0x20])] // } 072C 5B JUMPDEST 072D 82 DUP3 072E 01 ADD 072F 91 SWAP2 0730 90 SWAP1 0731 60 PUSH1 0x00 0733 52 MSTORE 0734 60 PUSH1 0x20 0736 60 PUSH1 0x00 0738 20 SHA3 0739 90 SWAP1 073A 5B JUMPDEST 073B 81 DUP2 073C 54 SLOAD 073D 81 DUP2 073E 52 MSTORE 073F 90 SWAP1 0740 60 PUSH1 0x01 0742 01 ADD 0743 90 SWAP1 0744 60 PUSH1 0x20 0746 01 ADD 0747 80 DUP1 0748 83 DUP4 0749 11 GT 074A 61 PUSH2 0x073a 074D 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @072F stack[-3] = stack[-3] + stack[-1] // @0733 memory[0x00:0x20] = stack[-2] // @073E memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0743 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0746 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x073a, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_074E: // Incoming jump from 0x074D, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x074D, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @074E stack[-3] // @074F stack[-1] // } 074E 82 DUP3 074F 90 SWAP1 0750 03 SUB 0751 60 PUSH1 0x1f 0753 16 AND 0754 82 DUP3 0755 01 ADD 0756 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0756 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0756 stack[-1] = stack[-3] // } // Block continues label_0757: // Incoming jump from 0x0710, if !stack[-1] // Incoming jump from 0x0756 // Incoming jump from 0x072B // Inputs[3] // { // @075D stack[-6] // @075D stack[-7] // @075F stack[-8] // } 0757 5B JUMPDEST 0758 50 POP 0759 50 POP 075A 50 POP 075B 50 POP 075C 50 POP 075D 90 SWAP1 075E 50 POP 075F 90 SWAP1 0760 56 *JUMP // Stack delta = -7 // Outputs[1] { @075F stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0761: // Incoming jump from 0x0295 // Inputs[1] { @0767 stack[-1] } 0761 5B JUMPDEST 0762 60 PUSH1 0x00 0764 61 PUSH2 0x076c 0767 82 DUP3 0768 61 PUSH2 0x0e1b 076B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0762 stack[0] = 0x00 // @0764 stack[1] = 0x076c // @0767 stack[2] = stack[-1] // } // Block ends with call to 0x0e1b, returns to 0x076C label_076C: // Incoming return from call to 0x0E1B at 0x076B // Inputs[1] { @0770 stack[-1] } 076C 5B JUMPDEST 076D 61 PUSH2 0x0789 0770 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0789, if stack[-1] label_0771: // Incoming jump from 0x0770, if not stack[-1] // Inputs[3] // { // @0773 memory[0x40:0x60] // @0783 memory[0x40:0x60] // @0788 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0771 60 PUSH1 0x40 0773 51 MLOAD 0774 63 PUSH4 0x33d1c039 0779 60 PUSH1 0xe2 077B 1B SHL 077C 81 DUP2 077D 52 MSTORE 077E 60 PUSH1 0x04 0780 01 ADD 0781 60 PUSH1 0x40 0783 51 MLOAD 0784 80 DUP1 0785 91 SWAP2 0786 03 SUB 0787 90 SWAP1 0788 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @077D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x33d1c039 << 0xe2 // @0788 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0789: // Incoming jump from 0x0770, if stack[-1] // Inputs[4] // { // @078D stack[-2] // @0798 memory[0x00:0x40] // @0799 storage[keccak256(memory[0x00:0x40])] // @07A3 stack[-3] // } 0789 5B JUMPDEST 078A 50 POP 078B 60 PUSH1 0x00 078D 90 SWAP1 078E 81 DUP2 078F 52 MSTORE 0790 60 PUSH1 0x06 0792 60 PUSH1 0x20 0794 52 MSTORE 0795 60 PUSH1 0x40 0797 90 SWAP1 0798 20 SHA3 0799 54 SLOAD 079A 60 PUSH1 0x01 079C 60 PUSH1 0x01 079E 60 PUSH1 0xa0 07A0 1B SHL 07A1 03 SUB 07A2 16 AND 07A3 90 SWAP1 07A4 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @078F memory[0x00:0x20] = stack[-2] // @0794 memory[0x20:0x40] = 0x06 // @07A3 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_07A5: // Incoming jump from 0x02C0 // Inputs[1] { @07A6 stack[-2] } 07A5 5B JUMPDEST 07A6 81 DUP2 07A7 61 PUSH2 0x07af 07AA 81 DUP2 07AB 61 PUSH2 0x0e50 07AE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07A6 stack[0] = stack[-2] // @07A7 stack[1] = 0x07af // @07AA stack[2] = stack[-2] // } // Block ends with call to 0x0e50, returns to 0x07AF label_07AF: // Incoming return from call to 0x0E50 at 0x07AE // Inputs[2] // { // @07B3 stack[-3] // @07B4 stack[-2] // } 07AF 5B JUMPDEST 07B0 61 PUSH2 0x07b9 07B3 83 DUP4 07B4 83 DUP4 07B5 61 PUSH2 0x0f09 07B8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07B0 stack[0] = 0x07b9 // @07B3 stack[1] = stack[-3] // @07B4 stack[2] = stack[-2] // } // Block ends with call to 0x0f09, returns to 0x07B9 label_07B9: // Incoming return from call to 0x0C2C at 0x09A7 // Incoming return from call to 0x0F09 at 0x07B8 // Incoming jump from 0x0A0B, if stack[-3] // Incoming jump from 0x0C84, if !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x0A0B, if stack[-3] // Incoming return from call to 0x13FD at 0x0C1E // Incoming jump from 0x1A17, if !(stack[-2] > 0x1f) // Incoming jump from 0x0C84, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[1] { @07BD stack[-4] } 07B9 5B JUMPDEST 07BA 50 POP 07BB 50 POP 07BC 50 POP 07BD 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_07BE: // Incoming jump from 0x02FC // Incoming call from 0x0C36, returns to 0x0C37 // Inputs[2] // { // @07BF stack[-3] // @07CA msg.sender // } 07BE 5B JUMPDEST 07BF 82 DUP3 07C0 60 PUSH1 0x01 07C2 60 PUSH1 0x01 07C4 60 PUSH1 0xa0 07C6 1B SHL 07C7 03 SUB 07C8 81 DUP2 07C9 16 AND 07CA 33 CALLER 07CB 14 EQ 07CC 61 PUSH2 0x07d8 07CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07BF stack[0] = stack[-3] } // Block ends with conditional jump to 0x07d8, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 label_07D0: // Incoming jump from 0x07CF, if not msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @07D3 msg.sender } 07D0 61 PUSH2 0x07d8 07D3 33 CALLER 07D4 61 PUSH2 0x0e50 07D7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @07D0 stack[0] = 0x07d8 // @07D3 stack[1] = msg.sender // } // Block ends with call to 0x0e50, returns to 0x07D8 label_07D8: // Incoming jump from 0x07CF, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Incoming return from call to 0x0E50 at 0x07D7 // Inputs[3] // { // @07DC stack[-4] // @07DD stack[-3] // @07DE stack[-2] // } 07D8 5B JUMPDEST 07D9 61 PUSH2 0x07e3 07DC 84 DUP5 07DD 84 DUP5 07DE 84 DUP5 07DF 61 PUSH2 0x0fa9 07E2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @07D9 stack[0] = 0x07e3 // @07DC stack[1] = stack[-4] // @07DD stack[2] = stack[-3] // @07DE stack[3] = stack[-2] // } // Block ends with call to 0x0fa9, returns to 0x07E3 label_07E3: // Incoming jump from 0x0C47, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Incoming return from call to 0x0FA9 at 0x07E2 // Inputs[1] { @07E8 stack[-5] } 07E3 5B JUMPDEST 07E4 50 POP 07E5 50 POP 07E6 50 POP 07E7 50 POP 07E8 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_07E9: // Incoming jump from 0x0327 07E9 5B JUMPDEST 07EA 61 PUSH2 0x07f1 07ED 61 PUSH2 0x1142 07F0 56 *JUMP // Stack delta = +1 // Outputs[1] { @07EA stack[0] = 0x07f1 } // Block ends with call to 0x1142, returns to 0x07F1 label_07F1: // Incoming return from call to 0x1142 at 0x07F0 07F1 5B JUMPDEST 07F2 61 PUSH2 0x07f9 07F5 61 PUSH2 0x11a2 07F8 56 *JUMP // Stack delta = +1 // Outputs[1] { @07F2 stack[0] = 0x07f9 } // Block ends with call to 0x11a2, returns to 0x07F9 label_07F9: // Incoming jump from 0x15B2, if 0xff & storage[0x08] // Incoming return from call to 0x11A2 at 0x07F8 // Incoming return from call to 0x13A7 at 0x0B71 // Incoming jump from 0x11FF, if !(0xff & storage[0x08]) // Incoming return from call to 0x13C0 at 0x0BFB // Incoming jump from 0x115A, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @07FA stack[-1] } 07F9 5B JUMPDEST 07FA 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_07FB: // Incoming jump from 0x033A 07FB 5B JUMPDEST 07FC 61 PUSH2 0x0803 07FF 61 PUSH2 0x11f4 0802 56 *JUMP // Stack delta = +1 // Outputs[1] { @07FC stack[0] = 0x0803 } // Block ends with call to 0x11f4, returns to 0x0803 label_0803: // Incoming return from call to 0x11F4 at 0x0802 // Inputs[4] // { // @0806 storage[0x0b] // @0809 storage[0x01] // @080C storage[0x00] // @080E stack[-1] // } 0803 5B JUMPDEST 0804 60 PUSH1 0x0b 0806 54 SLOAD 0807 60 PUSH1 0x01 0809 54 SLOAD 080A 60 PUSH1 0x00 080C 54 SLOAD 080D 03 SUB 080E 82 DUP3 080F 01 ADD 0810 60 PUSH1 0x00 0812 19 NOT 0813 01 ADD 0814 11 GT 0815 15 ISZERO 0816 61 PUSH2 0x085b 0819 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x085b, if !(~0x00 + stack[-1] + (storage[0x00] - storage[0x01]) > storage[0x0b]) label_081A: // Incoming jump from 0x0819, if not !(~0x00 + stack[-1] + (storage[0x00] - storage[0x01]) > storage[0x0b]) // Inputs[1] { @081C memory[0x40:0x60] } 081A 60 PUSH1 0x40 081C 51 MLOAD 081D 62 PUSH3 0x461bcd 0821 60 PUSH1 0xe5 0823 1B SHL 0824 81 DUP2 0825 52 MSTORE 0826 60 PUSH1 0x20 0828 60 PUSH1 0x04 082A 82 DUP3 082B 01 ADD 082C 52 MSTORE 082D 60 PUSH1 0x12 082F 60 PUSH1 0x24 0831 82 DUP3 0832 01 ADD 0833 52 MSTORE 0834 71 PUSH18 0x13585e081cdd5c1c1b1e481c995858da1959 0847 60 PUSH1 0x72 0849 1B SHL 084A 60 PUSH1 0x44 084C 82 DUP3 084D 01 ADD 084E 52 MSTORE 084F 60 PUSH1 0x64 0851 01 ADD // Stack delta = +1 // Outputs[5] // { // @0825 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @082C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0833 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x12 // @084E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x13585e081cdd5c1c1b1e481c995858da1959 << 0x72 // @0851 stack[0] = 0x64 + memory[0x40:0x60] // } // Block continues label_0852: // Incoming jump from 0x0960 // Incoming jump from 0x0918 // Incoming jump from 0x1239 // Incoming jump from 0x11A1 // Incoming jump from 0x15F0 // Incoming jump from 0x0851 // Incoming jump from 0x0A49 // Incoming jump from 0x0BDF // Incoming jump from 0x08C6 // Inputs[3] // { // @0855 memory[0x40:0x60] // @0857 stack[-1] // @085A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0852 5B JUMPDEST 0853 60 PUSH1 0x40 0855 51 MLOAD 0856 80 DUP1 0857 91 SWAP2 0858 03 SUB 0859 90 SWAP1 085A FD *REVERT // Stack delta = -1 // Outputs[1] { @085A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_085B: // Incoming jump from 0x0819, if !(~0x00 + stack[-1] + (storage[0x00] - storage[0x01]) > storage[0x0b]) // Inputs[5] // { // @085E storage[0x0c] // @0867 stack[-2] // @0876 memory[0x00:0x40] // @0877 storage[keccak256(memory[0x00:0x40])] // @0878 stack[-1] // } 085B 5B JUMPDEST 085C 60 PUSH1 0x0c 085E 54 SLOAD 085F 60 PUSH1 0x01 0861 60 PUSH1 0x01 0863 60 PUSH1 0xa0 0865 1B SHL 0866 03 SUB 0867 83 DUP4 0868 16 AND 0869 60 PUSH1 0x00 086B 90 SWAP1 086C 81 DUP2 086D 52 MSTORE 086E 60 PUSH1 0x0f 0870 60 PUSH1 0x20 0872 52 MSTORE 0873 60 PUSH1 0x40 0875 90 SWAP1 0876 20 SHA3 0877 54 SLOAD 0878 82 DUP3 0879 01 ADD 087A 11 GT 087B 15 ISZERO 087C 61 PUSH2 0x08c7 087F 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @086D memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0872 memory[0x20:0x40] = 0x0f // } // Block ends with conditional jump to 0x08c7, if !(stack[-1] + storage[keccak256(memory[0x00:0x40])] > storage[0x0c]) label_0880: // Incoming jump from 0x087F, if not !(stack[-1] + storage[keccak256(memory[0x00:0x40])] > storage[0x0c]) // Inputs[1] { @0882 memory[0x40:0x60] } 0880 60 PUSH1 0x40 0882 51 MLOAD 0883 62 PUSH3 0x461bcd 0887 60 PUSH1 0xe5 0889 1B SHL 088A 81 DUP2 088B 52 MSTORE 088C 60 PUSH1 0x20 088E 60 PUSH1 0x04 0890 82 DUP3 0891 01 ADD 0892 52 MSTORE 0893 60 PUSH1 0x1b 0895 60 PUSH1 0x24 0897 82 DUP3 0898 01 ADD 0899 52 MSTORE 089A 7F PUSH32 0x4d6178206d696e74207065722077616c6c657420726561636865640000000000 08BB 60 PUSH1 0x44 08BD 82 DUP3 08BE 01 ADD 08BF 52 MSTORE 08C0 60 PUSH1 0x64 08C2 01 ADD 08C3 61 PUSH2 0x0852 08C6 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @088B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0892 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0899 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1b // @08BF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4d6178206d696e74207065722077616c6c657420726561636865640000000000 // @08C2 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0852 label_08C7: // Incoming jump from 0x087F, if !(stack[-1] + storage[keccak256(memory[0x00:0x40])] > storage[0x0c]) // Inputs[2] // { // @08CA storage[0x0d] // @08CB stack[-1] // } 08C7 5B JUMPDEST 08C8 60 PUSH1 0x0d 08CA 54 SLOAD 08CB 81 DUP2 08CC 11 GT 08CD 15 ISZERO 08CE 61 PUSH2 0x0919 08D1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0919, if !(stack[-1] > storage[0x0d]) label_08D2: // Incoming jump from 0x08D1, if not !(stack[-1] > storage[0x0d]) // Inputs[1] { @08D4 memory[0x40:0x60] } 08D2 60 PUSH1 0x40 08D4 51 MLOAD 08D5 62 PUSH3 0x461bcd 08D9 60 PUSH1 0xe5 08DB 1B SHL 08DC 81 DUP2 08DD 52 MSTORE 08DE 60 PUSH1 0x20 08E0 60 PUSH1 0x04 08E2 82 DUP3 08E3 01 ADD 08E4 52 MSTORE 08E5 60 PUSH1 0x17 08E7 60 PUSH1 0x24 08E9 82 DUP3 08EA 01 ADD 08EB 52 MSTORE 08EC 7F PUSH32 0x4d6178206d696e74207065722074782072656163686564000000000000000000 090D 60 PUSH1 0x44 090F 82 DUP3 0910 01 ADD 0911 52 MSTORE 0912 60 PUSH1 0x64 0914 01 ADD 0915 61 PUSH2 0x0852 0918 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @08DD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08E4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @08EB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x17 // @0911 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4d6178206d696e74207065722074782072656163686564000000000000000000 // @0914 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0852 label_0919: // Incoming jump from 0x08D1, if !(stack[-1] > storage[0x0d]) // Inputs[3] // { // @091A stack[-1] // @091D storage[0x0e] // @091F msg.value // } 0919 5B JUMPDEST 091A 80 DUP1 091B 60 PUSH1 0x0e 091D 54 SLOAD 091E 02 MUL 091F 34 CALLVALUE 0920 14 EQ 0921 61 PUSH2 0x0961 0924 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0961, if msg.value == storage[0x0e] * stack[-1] label_0925: // Incoming jump from 0x0924, if not msg.value == storage[0x0e] * stack[-1] // Inputs[1] { @0927 memory[0x40:0x60] } 0925 60 PUSH1 0x40 0927 51 MLOAD 0928 62 PUSH3 0x461bcd 092C 60 PUSH1 0xe5 092E 1B SHL 092F 81 DUP2 0930 52 MSTORE 0931 60 PUSH1 0x20 0933 60 PUSH1 0x04 0935 82 DUP3 0936 01 ADD 0937 52 MSTORE 0938 60 PUSH1 0x12 093A 60 PUSH1 0x24 093C 82 DUP3 093D 01 ADD 093E 52 MSTORE 093F 71 PUSH18 0x496e73756666696369656e742066756e6473 0952 60 PUSH1 0x70 0954 1B SHL 0955 60 PUSH1 0x44 0957 82 DUP3 0958 01 ADD 0959 52 MSTORE 095A 60 PUSH1 0x64 095C 01 ADD 095D 61 PUSH2 0x0852 0960 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0930 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0937 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @093E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x12 // @0959 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x496e73756666696369656e742066756e6473 << 0x70 // @095C stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0852 label_0961: // Incoming jump from 0x0924, if msg.value == storage[0x0e] * stack[-1] // Inputs[4] // { // @096A stack[-2] // @0979 memory[0x00:0x40] // @097B storage[keccak256(memory[0x00:0x40])] // @097C stack[-1] // } 0961 5B JUMPDEST 0962 60 PUSH1 0x01 0964 60 PUSH1 0x01 0966 60 PUSH1 0xa0 0968 1B SHL 0969 03 SUB 096A 82 DUP3 096B 16 AND 096C 60 PUSH1 0x00 096E 90 SWAP1 096F 81 DUP2 0970 52 MSTORE 0971 60 PUSH1 0x0f 0973 60 PUSH1 0x20 0975 52 MSTORE 0976 60 PUSH1 0x40 0978 90 SWAP1 0979 20 SHA3 097A 80 DUP1 097B 54 SLOAD 097C 82 DUP3 097D 01 ADD 097E 90 SWAP1 097F 55 SSTORE 0980 61 PUSH2 0x0989 0983 82 DUP3 0984 82 DUP3 0985 61 PUSH2 0x123a 0988 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @0970 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0975 memory[0x20:0x40] = 0x0f // @097F storage[keccak256(memory[0x00:0x40])] = stack[-1] + storage[keccak256(memory[0x00:0x40])] // @0980 stack[0] = 0x0989 // @0983 stack[1] = stack[-2] // @0984 stack[2] = stack[-1] // } // Block ends with call to 0x123a, returns to 0x0989 label_0989: // Incoming return from call to 0x1A54 at 0x0A5D // Incoming return from call to 0x123A at 0x0988 // Inputs[1] { @098C stack[-3] } 0989 5B JUMPDEST 098A 50 POP 098B 50 POP 098C 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_098D: // Incoming jump from 0x036F // Inputs[4] // { // @0991 stack[-3] // @0992 stack[-2] // @0993 stack[-1] // @0996 memory[0x40:0x60] // } 098D 5B JUMPDEST 098E 61 PUSH2 0x07b9 0991 83 DUP4 0992 83 DUP4 0993 83 DUP4 0994 60 PUSH1 0x40 0996 51 MLOAD 0997 80 DUP1 0998 60 PUSH1 0x20 099A 01 ADD 099B 60 PUSH1 0x40 099D 52 MSTORE 099E 80 DUP1 099F 60 PUSH1 0x00 09A1 81 DUP2 09A2 52 MSTORE 09A3 50 POP 09A4 61 PUSH2 0x0c2c 09A7 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @098E stack[0] = 0x07b9 // @0991 stack[1] = stack[-3] // @0992 stack[2] = stack[-2] // @0993 stack[3] = stack[-1] // @0996 stack[4] = memory[0x40:0x60] // @099D memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @09A2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x0c2c, returns to 0x07B9 label_09A8: // Incoming jump from 0x038F 09A8 5B JUMPDEST 09A9 61 PUSH2 0x09b0 09AC 61 PUSH2 0x1142 09AF 56 *JUMP // Stack delta = +1 // Outputs[1] { @09A9 stack[0] = 0x09b0 } // Block ends with call to 0x1142, returns to 0x09B0 label_09B0: // Incoming return from call to 0x1142 at 0x09AF // Inputs[8] // { // @09B3 memory[0x40:0x60] // @09B4 address(this).balance // @09B4 address(this) // @09C1 stack[-1] // @09CC msg.gas // @09CD address(stack[-1] & (0x01 << 0xa0) - 0x01).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @09CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @09D2 returndata.length // } 09B0 5B JUMPDEST 09B1 60 PUSH1 0x40 09B3 51 MLOAD 09B4 47 SELFBALANCE 09B5 90 SWAP1 09B6 60 PUSH1 0x00 09B8 90 SWAP1 09B9 60 PUSH1 0x01 09BB 60 PUSH1 0x01 09BD 60 PUSH1 0xa0 09BF 1B SHL 09C0 03 SUB 09C1 84 DUP5 09C2 16 AND 09C3 90 SWAP1 09C4 83 DUP4 09C5 90 SWAP1 09C6 83 DUP4 09C7 81 DUP2 09C8 81 DUP2 09C9 81 DUP2 09CA 85 DUP6 09CB 87 DUP8 09CC 5A GAS 09CD F1 CALL 09CE 92 SWAP3 09CF 50 POP 09D0 50 POP 09D1 50 POP 09D2 3D RETURNDATASIZE 09D3 80 DUP1 09D4 60 PUSH1 0x00 09D6 81 DUP2 09D7 14 EQ 09D8 61 PUSH2 0x09fd 09DB 57 *JUMPI // Stack delta = +5 // Outputs[6] // { // @09B5 stack[0] = address(this).balance // @09B8 stack[1] = 0x00 // @09CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-1] & (0x01 << 0xa0) - 0x01).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @09CE stack[2] = address(stack[-1] & (0x01 << 0xa0) - 0x01).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @09D2 stack[3] = returndata.length // @09D3 stack[4] = returndata.length // } // Block ends with conditional jump to 0x09fd, if returndata.length == 0x00 label_09DC: // Incoming jump from 0x09DB, if not returndata.length == 0x00 // Inputs[6] // { // @09DE memory[0x40:0x60] // @09DF stack[-2] // @09E6 returndata.length // @09EE returndata.length // @09F1 returndata.length // @09F8 returndata[0x00:0x00 + returndata.length] // } 09DC 60 PUSH1 0x40 09DE 51 MLOAD 09DF 91 SWAP2 09E0 50 POP 09E1 60 PUSH1 0x1f 09E3 19 NOT 09E4 60 PUSH1 0x3f 09E6 3D RETURNDATASIZE 09E7 01 ADD 09E8 16 AND 09E9 82 DUP3 09EA 01 ADD 09EB 60 PUSH1 0x40 09ED 52 MSTORE 09EE 3D RETURNDATASIZE 09EF 82 DUP3 09F0 52 MSTORE 09F1 3D RETURNDATASIZE 09F2 60 PUSH1 0x00 09F4 60 PUSH1 0x20 09F6 84 DUP5 09F7 01 ADD 09F8 3E RETURNDATACOPY 09F9 61 PUSH2 0x0a02 09FC 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @09DF stack[-2] = memory[0x40:0x60] // @09ED memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @09F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @09F8 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0a02 label_09FD: // Incoming jump from 0x09DB, if returndata.length == 0x00 // Inputs[3] // { // @0A00 stack[-2] // @0A05 stack[-3] // @0A05 stack[-4] // } 09FD 5B JUMPDEST 09FE 60 PUSH1 0x60 0A00 91 SWAP2 0A01 50 POP 0A02 5B JUMPDEST 0A03 50 POP 0A04 50 POP 0A05 90 SWAP1 0A06 50 POP 0A07 80 DUP1 0A08 61 PUSH2 0x07b9 0A0B 57 *JUMPI // Stack delta = -3 // Outputs[1] { @0A05 stack[-4] = stack[-3] } // Block ends with conditional jump to 0x07b9, if stack[-3] label_0A0C: // Incoming jump from 0x0A0B, if not stack[-3] // Incoming jump from 0x0A0B, if not stack[-3] // Inputs[1] { @0A0E memory[0x40:0x60] } 0A0C 60 PUSH1 0x40 0A0E 51 MLOAD 0A0F 62 PUSH3 0x461bcd 0A13 60 PUSH1 0xe5 0A15 1B SHL 0A16 81 DUP2 0A17 52 MSTORE 0A18 60 PUSH1 0x20 0A1A 60 PUSH1 0x04 0A1C 82 DUP3 0A1D 01 ADD 0A1E 52 MSTORE 0A1F 60 PUSH1 0x14 0A21 60 PUSH1 0x24 0A23 82 DUP3 0A24 01 ADD 0A25 52 MSTORE 0A26 73 PUSH20 0x2330b4b632b2103a379039b2b7321022ba3432b9 0A3B 60 PUSH1 0x61 0A3D 1B SHL 0A3E 60 PUSH1 0x44 0A40 82 DUP3 0A41 01 ADD 0A42 52 MSTORE 0A43 60 PUSH1 0x64 0A45 01 ADD 0A46 61 PUSH2 0x0852 0A49 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A17 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A1E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A25 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @0A42 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x2330b4b632b2103a379039b2b7321022ba3432b9 << 0x61 // @0A45 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0852 label_0A4A: // Incoming jump from 0x03AF 0A4A 5B JUMPDEST 0A4B 61 PUSH2 0x0a52 0A4E 61 PUSH2 0x1142 0A51 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A4B stack[0] = 0x0a52 } // Block ends with call to 0x1142, returns to 0x0A52 label_0A52: // Incoming return from call to 0x1142 at 0x0A51 // Inputs[1] { @0A58 stack[-1] } 0A52 5B JUMPDEST 0A53 60 PUSH1 0x0a 0A55 61 PUSH2 0x0989 0A58 82 DUP3 0A59 82 DUP3 0A5A 61 PUSH2 0x1a54 0A5D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A53 stack[0] = 0x0a // @0A55 stack[1] = 0x0989 // @0A58 stack[2] = stack[-1] // @0A59 stack[3] = 0x0a // } // Block ends with call to 0x1a54, returns to 0x0989 label_0A5E: // Incoming jump from 0x03E7 0A5E 5B JUMPDEST 0A5F 61 PUSH2 0x0a66 0A62 61 PUSH2 0x1142 0A65 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A5F stack[0] = 0x0a66 } // Block ends with call to 0x1142, returns to 0x0A66 label_0A66: // Incoming return from call to 0x1142 at 0x0A65 // Inputs[2] // { // @0A69 stack[-1] // @0A6A stack[-2] // } 0A66 5B JUMPDEST 0A67 60 PUSH1 0x0d 0A69 55 SSTORE 0A6A 56 *JUMP // Stack delta = -2 // Outputs[1] { @0A69 storage[0x0d] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0A6B: // Incoming call from 0x0F13, returns to 0x0F14 // Incoming jump from 0x0407 // Inputs[1] { @0A71 stack[-1] } 0A6B 5B JUMPDEST 0A6C 60 PUSH1 0x00 0A6E 61 PUSH2 0x06c9 0A71 82 DUP3 0A72 61 PUSH2 0x1338 0A75 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A6C stack[0] = 0x00 // @0A6E stack[1] = 0x06c9 // @0A71 stack[2] = stack[-1] // } // Block ends with call to 0x1338, returns to 0x06C9 label_0A76: // Incoming call from 0x041C, returns to 0x0269 // Inputs[1] { @0A7A storage[0x0a] } 0A76 5B JUMPDEST 0A77 60 PUSH1 0x0a 0A79 80 DUP1 0A7A 54 SLOAD 0A7B 61 PUSH2 0x0a83 0A7E 90 SWAP1 0A7F 61 PUSH2 0x19d4 0A82 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A77 stack[0] = 0x0a // @0A7E stack[1] = 0x0a83 // @0A7E stack[2] = storage[0x0a] // } // Block ends with call to 0x19d4, returns to 0x0A83 label_0A83: // Incoming return from call to 0x19D4 at 0x0A82 // Inputs[4] // { // @0A84 stack[-1] // @0A93 memory[0x40:0x60] // @0A9B stack[-2] // @0AA6 storage[stack[-2]] // } 0A83 5B JUMPDEST 0A84 80 DUP1 0A85 60 PUSH1 0x1f 0A87 01 ADD 0A88 60 PUSH1 0x20 0A8A 80 DUP1 0A8B 91 SWAP2 0A8C 04 DIV 0A8D 02 MUL 0A8E 60 PUSH1 0x20 0A90 01 ADD 0A91 60 PUSH1 0x40 0A93 51 MLOAD 0A94 90 SWAP1 0A95 81 DUP2 0A96 01 ADD 0A97 60 PUSH1 0x40 0A99 52 MSTORE 0A9A 80 DUP1 0A9B 92 SWAP3 0A9C 91 SWAP2 0A9D 90 SWAP1 0A9E 81 DUP2 0A9F 81 DUP2 0AA0 52 MSTORE 0AA1 60 PUSH1 0x20 0AA3 01 ADD 0AA4 82 DUP3 0AA5 80 DUP1 0AA6 54 SLOAD 0AA7 61 PUSH2 0x0aaf 0AAA 90 SWAP1 0AAB 61 PUSH2 0x19d4 0AAE 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0A99 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0A9B stack[-2] = memory[0x40:0x60] // @0A9C stack[-1] = stack[-2] // @0A9D stack[0] = stack[-1] // @0AA0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0AA3 stack[1] = 0x20 + memory[0x40:0x60] // @0AA4 stack[2] = stack[-2] // @0AAA stack[4] = storage[stack[-2]] // @0AAA stack[3] = 0x0aaf // } // Block ends with call to 0x19d4, returns to 0x0AAF label_0AAF: // Incoming return from call to 0x19D4 at 0x0AAE // Inputs[1] { @0AB0 stack[-1] } 0AAF 5B JUMPDEST 0AB0 80 DUP1 0AB1 15 ISZERO 0AB2 61 PUSH2 0x0afc 0AB5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0afc, if !stack[-1] label_0AB6: // Incoming jump from 0x0AB5, if not !stack[-1] // Inputs[1] { @0AB6 stack[-1] } 0AB6 80 DUP1 0AB7 60 PUSH1 0x1f 0AB9 10 LT 0ABA 61 PUSH2 0x0ad1 0ABD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ad1, if 0x1f < stack[-1] label_0ABE: // Incoming jump from 0x0ABD, if not 0x1f < stack[-1] // Inputs[4] // { // @0AC2 stack[-2] // @0AC3 storage[stack[-2]] // @0AC6 stack[-3] // @0AC8 stack[-1] // } 0ABE 61 PUSH2 0x0100 0AC1 80 DUP1 0AC2 83 DUP4 0AC3 54 SLOAD 0AC4 04 DIV 0AC5 02 MUL 0AC6 83 DUP4 0AC7 52 MSTORE 0AC8 91 SWAP2 0AC9 60 PUSH1 0x20 0ACB 01 ADD 0ACC 91 SWAP2 0ACD 61 PUSH2 0x0afc 0AD0 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0AC7 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0ACC stack[-1] = stack[-1] // @0ACC stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0afc label_0AD1: // Incoming jump from 0x0ABD, if 0x1f < stack[-1] // Inputs[5] // { // @0AD2 stack[-3] // @0AD3 stack[-1] // @0AD5 stack[-2] // @0ADD memory[0x00:0x20] // @0AE1 storage[keccak256(memory[0x00:0x20])] // } 0AD1 5B JUMPDEST 0AD2 82 DUP3 0AD3 01 ADD 0AD4 91 SWAP2 0AD5 90 SWAP1 0AD6 60 PUSH1 0x00 0AD8 52 MSTORE 0AD9 60 PUSH1 0x20 0ADB 60 PUSH1 0x00 0ADD 20 SHA3 0ADE 90 SWAP1 0ADF 5B JUMPDEST 0AE0 81 DUP2 0AE1 54 SLOAD 0AE2 81 DUP2 0AE3 52 MSTORE 0AE4 90 SWAP1 0AE5 60 PUSH1 0x01 0AE7 01 ADD 0AE8 90 SWAP1 0AE9 60 PUSH1 0x20 0AEB 01 ADD 0AEC 80 DUP1 0AED 83 DUP4 0AEE 11 GT 0AEF 61 PUSH2 0x0adf 0AF2 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0AD4 stack[-3] = stack[-3] + stack[-1] // @0AD8 memory[0x00:0x20] = stack[-2] // @0AE3 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0AE8 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0AEB stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0adf, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0AF3: // Incoming jump from 0x0AF2, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0AF2, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0AF3 stack[-3] // @0AF4 stack[-1] // } 0AF3 82 DUP3 0AF4 90 SWAP1 0AF5 03 SUB 0AF6 60 PUSH1 0x1f 0AF8 16 AND 0AF9 82 DUP3 0AFA 01 ADD 0AFB 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0AFB stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0AFB stack[-1] = stack[-3] // } // Block continues label_0AFC: // Incoming jump from 0x0AFB // Incoming jump from 0x0AB5, if !stack[-1] // Incoming jump from 0x0AD0 // Inputs[1] { @0B02 stack[-7] } 0AFC 5B JUMPDEST 0AFD 50 POP 0AFE 50 POP 0AFF 50 POP 0B00 50 POP 0B01 50 POP 0B02 81 DUP2 0B03 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0B04: // Incoming jump from 0x043C 0B04 5B JUMPDEST 0B05 61 PUSH2 0x0b0c 0B08 61 PUSH2 0x1142 0B0B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B05 stack[0] = 0x0b0c } // Block ends with call to 0x1142, returns to 0x0B0C label_0B0C: // Incoming return from call to 0x1142 at 0x0B0B // Inputs[2] // { // @0B0F stack[-1] // @0B10 stack[-2] // } 0B0C 5B JUMPDEST 0B0D 60 PUSH1 0x0b 0B0F 55 SSTORE 0B10 56 *JUMP // Stack delta = -2 // Outputs[1] { @0B0F storage[0x0b] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0B11: // Incoming jump from 0x045C // Inputs[1] { @0B1C stack[-1] } 0B11 5B JUMPDEST 0B12 60 PUSH1 0x00 0B14 60 PUSH1 0x01 0B16 60 PUSH1 0x01 0B18 60 PUSH1 0xa0 0B1A 1B SHL 0B1B 03 SUB 0B1C 82 DUP3 0B1D 16 AND 0B1E 61 PUSH2 0x0b3a 0B21 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B12 stack[0] = 0x00 } // Block ends with conditional jump to 0x0b3a, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0B22: // Incoming jump from 0x0B21, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0B24 memory[0x40:0x60] // @0B34 memory[0x40:0x60] // @0B39 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B22 60 PUSH1 0x40 0B24 51 MLOAD 0B25 63 PUSH4 0x23d3ad81 0B2A 60 PUSH1 0xe2 0B2C 1B SHL 0B2D 81 DUP2 0B2E 52 MSTORE 0B2F 60 PUSH1 0x04 0B31 01 ADD 0B32 60 PUSH1 0x40 0B34 51 MLOAD 0B35 80 DUP1 0B36 91 SWAP2 0B37 03 SUB 0B38 90 SWAP1 0B39 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0B2E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x23d3ad81 << 0xe2 // @0B39 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0B3A: // Incoming jump from 0x0B21, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0B44 stack[-2] // @0B52 memory[0x00:0x40] // @0B53 storage[keccak256(memory[0x00:0x40])] // @0B5E stack[-3] // } 0B3A 5B JUMPDEST 0B3B 50 POP 0B3C 60 PUSH1 0x01 0B3E 60 PUSH1 0x01 0B40 60 PUSH1 0xa0 0B42 1B SHL 0B43 03 SUB 0B44 16 AND 0B45 60 PUSH1 0x00 0B47 90 SWAP1 0B48 81 DUP2 0B49 52 MSTORE 0B4A 60 PUSH1 0x05 0B4C 60 PUSH1 0x20 0B4E 52 MSTORE 0B4F 60 PUSH1 0x40 0B51 90 SWAP1 0B52 20 SHA3 0B53 54 SLOAD 0B54 67 PUSH8 0xffffffffffffffff 0B5D 16 AND 0B5E 90 SWAP1 0B5F 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0B49 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0B4E memory[0x20:0x40] = 0x05 // @0B5E stack[-3] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0B60: // Incoming jump from 0x0471 0B60 5B JUMPDEST 0B61 61 PUSH2 0x0b68 0B64 61 PUSH2 0x1142 0B67 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B61 stack[0] = 0x0b68 } // Block ends with call to 0x1142, returns to 0x0B68 label_0B68: // Incoming return from call to 0x1142 at 0x0B67 0B68 5B JUMPDEST 0B69 61 PUSH2 0x07f9 0B6C 60 PUSH1 0x00 0B6E 61 PUSH2 0x13a7 0B71 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B69 stack[0] = 0x07f9 // @0B6C stack[1] = 0x00 // } // Block ends with call to 0x13a7, returns to 0x07F9 label_0B72: // Incoming call from 0x0486, returns to 0x02C1 // Inputs[2] // { // @0B75 storage[0x09] // @0B76 msg.sender // } 0B72 5B JUMPDEST 0B73 60 PUSH1 0x09 0B75 54 SLOAD 0B76 33 CALLER 0B77 90 SWAP1 0B78 60 PUSH1 0x01 0B7A 60 PUSH1 0x01 0B7C 60 PUSH1 0xa0 0B7E 1B SHL 0B7F 03 SUB 0B80 16 AND 0B81 81 DUP2 0B82 14 EQ 0B83 61 PUSH2 0x0be0 0B86 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B77 stack[0] = msg.sender } // Block ends with conditional jump to 0x0be0, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] label_0B87: // Incoming jump from 0x0B86, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] // 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 0x20 0B95 60 PUSH1 0x04 0B97 82 DUP3 0B98 01 ADD 0B99 52 MSTORE 0B9A 60 PUSH1 0x29 0B9C 60 PUSH1 0x24 0B9E 82 DUP3 0B9F 01 ADD 0BA0 52 MSTORE 0BA1 7F PUSH32 0x4f776e61626c6532537465703a2063616c6c6572206973206e6f742074686520 0BC2 60 PUSH1 0x44 0BC4 82 DUP3 0BC5 01 ADD 0BC6 52 MSTORE 0BC7 68 PUSH9 0x3732bb9037bbb732b9 0BD1 60 PUSH1 0xb9 0BD3 1B SHL 0BD4 60 PUSH1 0x64 0BD6 82 DUP3 0BD7 01 ADD 0BD8 52 MSTORE 0BD9 60 PUSH1 0x84 0BDB 01 ADD 0BDC 61 PUSH2 0x0852 0BDF 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0B92 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B99 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0BA0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @0BC6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c6532537465703a2063616c6c6572206973206e6f742074686520 // @0BD8 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x3732bb9037bbb732b9 << 0xb9 // @0BDB stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0852 label_0BE0: // Incoming jump from 0x0B86, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x09] // Inputs[1] { @0BE4 stack[-1] } 0BE0 5B JUMPDEST 0BE1 61 PUSH2 0x0be9 0BE4 81 DUP2 0BE5 61 PUSH2 0x13a7 0BE8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0BE1 stack[0] = 0x0be9 // @0BE4 stack[1] = stack[-1] // } // Block ends with call to 0x13a7, returns to 0x0BE9 label_0BE9: // Incoming jump from 0x1830, if stack[-1] == !!stack[-1] // Incoming return from call to 0x0DC1 at 0x13BF // Incoming jump from 0x16B0, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Incoming return from call to 0x13A7 at 0x0BE8 // Incoming jump from 0x1602, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x0E65, if !address(0xaaeb6d7670e522a718067333cd4e).code.length // Inputs[1] { @0BEB stack[-2] } 0BE9 5B JUMPDEST 0BEA 50 POP 0BEB 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0BEC: // Incoming jump from 0x049B 0BEC 5B JUMPDEST 0BED 61 PUSH2 0x0bf4 0BF0 61 PUSH2 0x1142 0BF3 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BED stack[0] = 0x0bf4 } // Block ends with call to 0x1142, returns to 0x0BF4 label_0BF4: // Incoming return from call to 0x1142 at 0x0BF3 0BF4 5B JUMPDEST 0BF5 61 PUSH2 0x07f9 0BF8 61 PUSH2 0x13c0 0BFB 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BF5 stack[0] = 0x07f9 } // Block ends with call to 0x13c0, returns to 0x07F9 label_0BFC: // Incoming call from 0x04D3, returns to 0x0269 // Inputs[1] { @0C02 storage[0x03] } 0BFC 5B JUMPDEST 0BFD 60 PUSH1 0x60 0BFF 60 PUSH1 0x03 0C01 80 DUP1 0C02 54 SLOAD 0C03 61 PUSH2 0x06de 0C06 90 SWAP1 0C07 61 PUSH2 0x19d4 0C0A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0BFD stack[0] = 0x60 // @0BFF stack[1] = 0x03 // @0C06 stack[2] = 0x06de // @0C06 stack[3] = storage[0x03] // } // Block ends with call to 0x19d4, returns to 0x06DE label_0C0B: // Incoming jump from 0x04F3 // Inputs[1] { @0C0C stack[-2] } 0C0B 5B JUMPDEST 0C0C 81 DUP2 0C0D 61 PUSH2 0x0c15 0C10 81 DUP2 0C11 61 PUSH2 0x0e50 0C14 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C0C stack[0] = stack[-2] // @0C0D stack[1] = 0x0c15 // @0C10 stack[2] = stack[-2] // } // Block ends with call to 0x0e50, returns to 0x0C15 label_0C15: // Incoming return from call to 0x0E50 at 0x0C14 // Inputs[2] // { // @0C19 stack[-3] // @0C1A stack[-2] // } 0C15 5B JUMPDEST 0C16 61 PUSH2 0x07b9 0C19 83 DUP4 0C1A 83 DUP4 0C1B 61 PUSH2 0x13fd 0C1E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C16 stack[0] = 0x07b9 // @0C19 stack[1] = stack[-3] // @0C1A stack[2] = stack[-2] // } // Block ends with call to 0x13fd, returns to 0x07B9 label_0C1F: // Incoming jump from 0x0513 0C1F 5B JUMPDEST 0C20 61 PUSH2 0x0c27 0C23 61 PUSH2 0x1142 0C26 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C20 stack[0] = 0x0c27 } // Block ends with call to 0x1142, returns to 0x0C27 label_0C27: // Incoming return from call to 0x1142 at 0x0C26 // Inputs[2] // { // @0C2A stack[-1] // @0C2B stack[-2] // } 0C27 5B JUMPDEST 0C28 60 PUSH1 0x0c 0C2A 55 SSTORE 0C2B 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C2A storage[0x0c] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0C2C: // Incoming jump from 0x053C // Incoming call from 0x09A7, returns to 0x07B9 // Inputs[3] // { // @0C30 stack[-4] // @0C31 stack[-3] // @0C32 stack[-2] // } 0C2C 5B JUMPDEST 0C2D 61 PUSH2 0x0c37 0C30 84 DUP5 0C31 84 DUP5 0C32 84 DUP5 0C33 61 PUSH2 0x07be 0C36 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0C2D stack[0] = 0x0c37 // @0C30 stack[1] = stack[-4] // @0C31 stack[2] = stack[-3] // @0C32 stack[3] = stack[-2] // } // Block ends with call to 0x07be, returns to 0x0C37 label_0C37: // Incoming return from call to 0x07BE at 0x0C36 // Inputs[2] // { // @0C40 stack[-3] // @0C42 address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 0C37 5B JUMPDEST 0C38 60 PUSH1 0x01 0C3A 60 PUSH1 0x01 0C3C 60 PUSH1 0xa0 0C3E 1B SHL 0C3F 03 SUB 0C40 83 DUP4 0C41 16 AND 0C42 3B EXTCODESIZE 0C43 15 ISZERO 0C44 61 PUSH2 0x07e3 0C47 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07e3, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_0C48: // Incoming jump from 0x0C47, if not !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[4] // { // @0C4B stack[-4] // @0C4C stack[-3] // @0C4D stack[-2] // @0C4E stack[-1] // } 0C48 61 PUSH2 0x0c53 0C4B 84 DUP5 0C4C 84 DUP5 0C4D 84 DUP5 0C4E 84 DUP5 0C4F 61 PUSH2 0x1469 0C52 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0C48 stack[0] = 0x0c53 // @0C4B stack[1] = stack[-4] // @0C4C stack[2] = stack[-3] // @0C4D stack[3] = stack[-2] // @0C4E stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x1469 0C53 5B JUMPDEST 0C54 61 PUSH2 0x07e3 0C57 57 *JUMPI 0C58 60 PUSH1 0x40 0C5A 51 MLOAD 0C5B 63 PUSH4 0x68d2bf6b 0C60 60 PUSH1 0xe1 0C62 1B SHL 0C63 81 DUP2 0C64 52 MSTORE 0C65 60 PUSH1 0x04 0C67 01 ADD 0C68 60 PUSH1 0x40 0C6A 51 MLOAD 0C6B 80 DUP1 0C6C 91 SWAP2 0C6D 03 SUB 0C6E 90 SWAP1 0C6F FD *REVERT label_0C70: // Incoming jump from 0x0572 0C70 5B JUMPDEST 0C71 61 PUSH2 0x0c78 0C74 61 PUSH2 0x1142 0C77 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C71 stack[0] = 0x0c78 } // Block ends with call to 0x1142, returns to 0x0C78 label_0C78: // Incoming return from call to 0x1142 at 0x0C77 // Inputs[2] // { // @0C7C stack[-2] // @0C7D memory[stack[-2]:stack[-2] + 0x20] // } 0C78 5B JUMPDEST 0C79 60 PUSH1 0x00 0C7B 5B JUMPDEST 0C7C 82 DUP3 0C7D 51 MLOAD 0C7E 81 DUP2 0C7F 10 LT 0C80 15 ISZERO 0C81 61 PUSH2 0x07b9 0C84 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C79 stack[0] = 0x00 } // Block ends with conditional jump to 0x07b9, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_0C85: // Incoming jump from 0x0C84, if not !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x0C84, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @0C88 stack[-3] // @0C89 stack[-1] // @0C8B memory[stack[-3]:stack[-3] + 0x20] // } 0C85 61 PUSH2 0x0ca7 0C88 83 DUP4 0C89 82 DUP3 0C8A 81 DUP2 0C8B 51 MLOAD 0C8C 81 DUP2 0C8D 10 LT 0C8E 61 PUSH2 0x0c99 0C91 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0C85 stack[0] = 0x0ca7 // @0C88 stack[1] = stack[-3] // @0C89 stack[2] = stack[-1] // } // Block ends with conditional call to 0x0c99, returns to 0x0CA7, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_0C92: // Incoming jump from 0x0C91, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] 0C92 61 PUSH2 0x0c99 0C95 61 PUSH2 0x1b14 0C98 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C92 stack[0] = 0x0c99 } // Block ends with unconditional jump to 0x1b14 label_0C99: // Incoming call from 0x0C91, returns to 0x0CA7, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @0C9C stack[-1] // @0CA0 stack[-2] // @0CA1 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0CA2 stack[-5] // } 0C99 5B JUMPDEST 0C9A 60 PUSH1 0x20 0C9C 02 MUL 0C9D 60 PUSH1 0x20 0C9F 01 ADD 0CA0 01 ADD 0CA1 51 MLOAD 0CA2 83 DUP4 0CA3 61 PUSH2 0x123a 0CA6 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0CA1 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0CA2 stack[-1] = stack[-5] // } // Block ends with unconditional jump to 0x123a label_0CA7: // Incoming return from call to 0x0C99 at 0x0C91 // Inputs[1] { @0CA8 stack[-1] } 0CA7 5B JUMPDEST 0CA8 80 DUP1 0CA9 61 PUSH2 0x0cb1 0CAC 81 DUP2 0CAD 61 PUSH2 0x1b2a 0CB0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CA8 stack[0] = stack[-1] // @0CA9 stack[1] = 0x0cb1 // @0CAC stack[2] = stack[-1] // } // Block ends with call to 0x1b2a, returns to 0x0CB1 label_0CB1: // Incoming return from call to 0x1B2A at 0x0CB0 // Inputs[2] // { // @0CB2 stack[-1] // @0CB2 stack[-3] // } 0CB1 5B JUMPDEST 0CB2 91 SWAP2 0CB3 50 POP 0CB4 50 POP 0CB5 61 PUSH2 0x0c7b 0CB8 56 *JUMP // Stack delta = -2 // Outputs[1] { @0CB2 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0c7b label_0CB9: // Incoming jump from 0x0592 // Inputs[1] { @0CBF stack[-1] } 0CB9 5B JUMPDEST 0CBA 60 PUSH1 0x60 0CBC 61 PUSH2 0x0cc4 0CBF 82 DUP3 0CC0 61 PUSH2 0x0e1b 0CC3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CBA stack[0] = 0x60 // @0CBC stack[1] = 0x0cc4 // @0CBF stack[2] = stack[-1] // } // Block ends with call to 0x0e1b, returns to 0x0CC4 label_0CC4: // Incoming return from call to 0x0E1B at 0x0CC3 // Inputs[1] { @0CC8 stack[-1] } 0CC4 5B JUMPDEST 0CC5 61 PUSH2 0x0ce1 0CC8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0ce1, if stack[-1] label_0CC9: // Incoming jump from 0x0CC8, if not stack[-1] // Inputs[3] // { // @0CCB memory[0x40:0x60] // @0CDB memory[0x40:0x60] // @0CE0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0CC9 60 PUSH1 0x40 0CCB 51 MLOAD 0CCC 63 PUSH4 0x0a14c4b5 0CD1 60 PUSH1 0xe4 0CD3 1B SHL 0CD4 81 DUP2 0CD5 52 MSTORE 0CD6 60 PUSH1 0x04 0CD8 01 ADD 0CD9 60 PUSH1 0x40 0CDB 51 MLOAD 0CDC 80 DUP1 0CDD 91 SWAP2 0CDE 03 SUB 0CDF 90 SWAP1 0CE0 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0CD5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a14c4b5 << 0xe4 // @0CE0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0CE1: // Incoming jump from 0x0CC8, if stack[-1] 0CE1 5B JUMPDEST 0CE2 60 PUSH1 0x00 0CE4 61 PUSH2 0x0ceb 0CE7 61 PUSH2 0x1555 0CEA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0CE2 stack[0] = 0x00 // @0CE4 stack[1] = 0x0ceb // } // Block ends with unconditional jump to 0x1555 0CEB 5B JUMPDEST 0CEC 90 SWAP1 0CED 50 POP 0CEE 80 DUP1 0CEF 51 MLOAD 0CF0 60 PUSH1 0x00 0CF2 03 SUB 0CF3 61 PUSH2 0x0d0b 0CF6 57 *JUMPI 0CF7 60 PUSH1 0x40 0CF9 51 MLOAD 0CFA 80 DUP1 0CFB 60 PUSH1 0x20 0CFD 01 ADD 0CFE 60 PUSH1 0x40 0D00 52 MSTORE 0D01 80 DUP1 0D02 60 PUSH1 0x00 0D04 81 DUP2 0D05 52 MSTORE 0D06 50 POP 0D07 61 PUSH2 0x0d36 0D0A 56 *JUMP 0D0B 5B JUMPDEST 0D0C 80 DUP1 0D0D 61 PUSH2 0x0d15 0D10 84 DUP5 0D11 61 PUSH2 0x1564 0D14 56 *JUMP 0D15 5B JUMPDEST 0D16 60 PUSH1 0x40 0D18 51 MLOAD 0D19 60 PUSH1 0x20 0D1B 01 ADD 0D1C 61 PUSH2 0x0d26 0D1F 92 SWAP3 0D20 91 SWAP2 0D21 90 SWAP1 0D22 61 PUSH2 0x1b51 0D25 56 *JUMP 0D26 5B JUMPDEST 0D27 60 PUSH1 0x40 0D29 51 MLOAD 0D2A 60 PUSH1 0x20 0D2C 81 DUP2 0D2D 83 DUP4 0D2E 03 SUB 0D2F 03 SUB 0D30 81 DUP2 0D31 52 MSTORE 0D32 90 SWAP1 0D33 60 PUSH1 0x40 0D35 52 MSTORE label_0D36: // Incoming return from call to 0x1827 at 0x1B9C // Incoming return from call to 0x16A0 at 0x173E // Incoming return from call to 0x15F1 at 0x1623 // Incoming return from call to 0x15F1 at 0x1BF6 // Incoming jump from 0x1373, if 0x00 - stack[-1] // Incoming return from call to 0x1648 at 0x1686 // Inputs[3] // { // @0D37 stack[-5] // @0D37 stack[-1] // @0D38 stack[-4] // } 0D36 5B JUMPDEST 0D37 93 SWAP4 0D38 92 SWAP3 0D39 50 POP 0D3A 50 POP 0D3B 50 POP 0D3C 56 *JUMP // Stack delta = -4 // Outputs[1] { @0D37 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0D3D: // Incoming jump from 0x065C 0D3D 5B JUMPDEST 0D3E 61 PUSH2 0x0d45 0D41 61 PUSH2 0x1142 0D44 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D3E stack[0] = 0x0d45 } // Block ends with call to 0x1142, returns to 0x0D45 label_0D45: // Incoming return from call to 0x1142 at 0x0D44 // Inputs[3] // { // @0D49 storage[0x09] // @0D52 stack[-1] // @0D6A storage[0x08] // } 0D45 5B JUMPDEST 0D46 60 PUSH1 0x09 0D48 80 DUP1 0D49 54 SLOAD 0D4A 60 PUSH1 0x01 0D4C 60 PUSH1 0x01 0D4E 60 PUSH1 0xa0 0D50 1B SHL 0D51 03 SUB 0D52 83 DUP4 0D53 16 AND 0D54 60 PUSH1 0x01 0D56 60 PUSH1 0x01 0D58 60 PUSH1 0xa0 0D5A 1B SHL 0D5B 03 SUB 0D5C 19 NOT 0D5D 90 SWAP1 0D5E 91 SWAP2 0D5F 16 AND 0D60 81 DUP2 0D61 17 OR 0D62 90 SWAP1 0D63 91 SWAP2 0D64 55 SSTORE 0D65 61 PUSH2 0x0d7c 0D68 60 PUSH1 0x08 0D6A 54 SLOAD 0D6B 60 PUSH1 0x01 0D6D 60 PUSH1 0x01 0D6F 60 PUSH1 0xa0 0D71 1B SHL 0D72 03 SUB 0D73 61 PUSH2 0x0100 0D76 90 SWAP1 0D77 91 SWAP2 0D78 04 DIV 0D79 16 AND 0D7A 90 SWAP1 0D7B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D63 stack[0] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0D64 storage[0x09] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x09] & ~((0x01 << 0xa0) - 0x01)) // @0D7A stack[1] = storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // } // Block ends with unconditional jump to 0x0d7c label_0D7C: // Incoming jump from 0x0D7B // Inputs[6] // { // @0D85 stack[-1] // @0DA9 memory[0x40:0x60] // @0DAC memory[0x40:0x60] // @0DB1 stack[-2] // @0DB1 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0DB3 stack[-4] // } 0D7C 5B JUMPDEST 0D7D 60 PUSH1 0x01 0D7F 60 PUSH1 0x01 0D81 60 PUSH1 0xa0 0D83 1B SHL 0D84 03 SUB 0D85 16 AND 0D86 7F PUSH32 0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700 0DA7 60 PUSH1 0x40 0DA9 51 MLOAD 0DAA 60 PUSH1 0x40 0DAC 51 MLOAD 0DAD 80 DUP1 0DAE 91 SWAP2 0DAF 03 SUB 0DB0 90 SWAP1 0DB1 A3 LOG3 0DB2 50 POP 0DB3 56 *JUMP // Stack delta = -4 // Outputs[1] { @0DB1 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-2]]); } // Block ends with unconditional jump to stack[-4] label_0DB4: // Incoming jump from 0x067C 0DB4 5B JUMPDEST 0DB5 61 PUSH2 0x0dbc 0DB8 61 PUSH2 0x1142 0DBB 56 *JUMP // Stack delta = +1 // Outputs[1] { @0DB5 stack[0] = 0x0dbc } // Block ends with call to 0x1142, returns to 0x0DBC label_0DBC: // Incoming return from call to 0x1142 at 0x0DBB // Inputs[2] // { // @0DBF stack[-1] // @0DC0 stack[-2] // } 0DBC 5B JUMPDEST 0DBD 60 PUSH1 0x0e 0DBF 55 SSTORE 0DC0 56 *JUMP // Stack delta = -2 // Outputs[1] { @0DBF storage[0x0e] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0DC1: // Incoming call from 0x13BF, returns to 0x0BE9 // Inputs[5] // { // @0DC5 storage[0x08] // @0DCE stack[-1] // @0DE9 memory[0x40:0x60] // @0E17 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0E1A stack[-2] // } 0DC1 5B JUMPDEST 0DC2 60 PUSH1 0x08 0DC4 80 DUP1 0DC5 54 SLOAD 0DC6 60 PUSH1 0x01 0DC8 60 PUSH1 0x01 0DCA 60 PUSH1 0xa0 0DCC 1B SHL 0DCD 03 SUB 0DCE 83 DUP4 0DCF 81 DUP2 0DD0 16 AND 0DD1 61 PUSH2 0x0100 0DD4 81 DUP2 0DD5 81 DUP2 0DD6 02 MUL 0DD7 61 PUSH2 0x0100 0DDA 60 PUSH1 0x01 0DDC 60 PUSH1 0xa8 0DDE 1B SHL 0DDF 03 SUB 0DE0 19 NOT 0DE1 85 DUP6 0DE2 16 AND 0DE3 17 OR 0DE4 90 SWAP1 0DE5 94 SWAP5 0DE6 55 SSTORE 0DE7 60 PUSH1 0x40 0DE9 51 MLOAD 0DEA 93 SWAP4 0DEB 90 SWAP1 0DEC 92 SWAP3 0DED 04 DIV 0DEE 16 AND 0DEF 91 SWAP2 0DF0 82 DUP3 0DF1 90 SWAP1 0DF2 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 0E13 90 SWAP1 0E14 60 PUSH1 0x00 0E16 90 SWAP1 0E17 A3 LOG3 0E18 50 POP 0E19 50 POP 0E1A 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @0DE6 storage[0x08] = (storage[0x08] & ~((0x01 << 0xa8) - 0x0100)) | 0x0100 * (stack[-1] & (0x01 << 0xa0) - 0x01) // @0E17 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_0E1B: // Incoming call from 0x076B, returns to 0x076C // Incoming call from 0x0CC3, returns to 0x0CC4 // Inputs[1] { @0E1E stack[-1] } 0E1B 5B JUMPDEST 0E1C 60 PUSH1 0x00 0E1E 81 DUP2 0E1F 60 PUSH1 0x01 0E21 11 GT 0E22 15 ISZERO 0E23 80 DUP1 0E24 15 ISZERO 0E25 61 PUSH2 0x0e2f 0E28 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0E1C stack[0] = 0x00 // @0E22 stack[1] = !(0x01 > stack[-1]) // } // Block ends with conditional jump to 0x0e2f, if !!(0x01 > stack[-1]) label_0E29: // Incoming jump from 0x0E28, if not !!(0x01 > stack[-1]) // Inputs[2] // { // @0E2C storage[0x00] // @0E2D stack[-3] // } 0E29 50 POP 0E2A 60 PUSH1 0x00 0E2C 54 SLOAD 0E2D 82 DUP3 0E2E 10 LT 0E2F 5B JUMPDEST 0E30 80 DUP1 0E31 15 ISZERO 0E32 61 PUSH2 0x06c9 0E35 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0E2E stack[-1] = stack[-3] < storage[0x00] } // Block ends with conditional jump to 0x06c9, if !(stack[-3] < storage[0x00]) label_0E36: // Incoming jump from 0x0E35, if not !stack[-1] // Incoming jump from 0x0E35, if not !(stack[-3] < storage[0x00]) // Inputs[4] // { // @0E3A stack[-3] // @0E45 memory[0x00:0x40] // @0E46 storage[keccak256(memory[0x00:0x40])] // @0E4E stack[-4] // } 0E36 50 POP 0E37 50 POP 0E38 60 PUSH1 0x00 0E3A 90 SWAP1 0E3B 81 DUP2 0E3C 52 MSTORE 0E3D 60 PUSH1 0x04 0E3F 60 PUSH1 0x20 0E41 52 MSTORE 0E42 60 PUSH1 0x40 0E44 90 SWAP1 0E45 20 SHA3 0E46 54 SLOAD 0E47 60 PUSH1 0x01 0E49 60 PUSH1 0xe0 0E4B 1B SHL 0E4C 16 AND 0E4D 15 ISZERO 0E4E 90 SWAP1 0E4F 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0E3C memory[0x00:0x20] = stack[-3] // @0E41 memory[0x20:0x40] = 0x04 // @0E4E stack[-4] = !((0x01 << 0xe0) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-4] label_0E50: // Incoming call from 0x07AE, returns to 0x07AF // Incoming call from 0x0C14, returns to 0x0C15 // Incoming call from 0x07D7, returns to 0x07D8 // Inputs[1] { @0E60 address(0xaaeb6d7670e522a718067333cd4e).code.length } 0E50 5B JUMPDEST 0E51 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 0E60 3B EXTCODESIZE 0E61 15 ISZERO 0E62 61 PUSH2 0x0be9 0E65 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0be9, if !address(0xaaeb6d7670e522a718067333cd4e).code.length label_0E66: // Incoming jump from 0x0E65, if not !address(0xaaeb6d7670e522a718067333cd4e).code.length // Inputs[7] // { // @0E68 memory[0x40:0x60] // @0E73 address(this) // @0E81 stack[-1] // @0EA5 memory[0x40:0x60] // @0EAB msg.gas // @0EAC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0EAC address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } 0E66 60 PUSH1 0x40 0E68 51 MLOAD 0E69 63 PUSH4 0x3185c44d 0E6E 60 PUSH1 0xe2 0E70 1B SHL 0E71 81 DUP2 0E72 52 MSTORE 0E73 30 ADDRESS 0E74 60 PUSH1 0x04 0E76 82 DUP3 0E77 01 ADD 0E78 52 MSTORE 0E79 60 PUSH1 0x01 0E7B 60 PUSH1 0x01 0E7D 60 PUSH1 0xa0 0E7F 1B SHL 0E80 03 SUB 0E81 82 DUP3 0E82 16 AND 0E83 60 PUSH1 0x24 0E85 82 DUP3 0E86 01 ADD 0E87 52 MSTORE 0E88 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 0E97 90 SWAP1 0E98 63 PUSH4 0xc6171134 0E9D 90 SWAP1 0E9E 60 PUSH1 0x44 0EA0 01 ADD 0EA1 60 PUSH1 0x20 0EA3 60 PUSH1 0x40 0EA5 51 MLOAD 0EA6 80 DUP1 0EA7 83 DUP4 0EA8 03 SUB 0EA9 81 DUP2 0EAA 86 DUP7 0EAB 5A GAS 0EAC FA STATICCALL 0EAD 15 ISZERO 0EAE 80 DUP1 0EAF 15 ISZERO 0EB0 61 PUSH2 0x0ebd 0EB3 57 *JUMPI // Stack delta = +4 // Outputs[8] // { // @0E72 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3185c44d << 0xe2 // @0E78 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @0E87 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0E97 stack[0] = 0xaaeb6d7670e522a718067333cd4e // @0E9D stack[1] = 0xc6171134 // @0EA0 stack[2] = 0x44 + memory[0x40:0x60] // @0EAC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @0EAD stack[3] = !address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x0ebd, if !!address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_0EB4: // Incoming jump from 0x0EB3, if not !!address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @0EB4 returndata.length // @0EB8 returndata[0x00:0x00 + returndata.length] // @0EB9 returndata.length // @0EBC memory[0x00:0x00 + returndata.length] // } 0EB4 3D RETURNDATASIZE 0EB5 60 PUSH1 0x00 0EB7 80 DUP1 0EB8 3E RETURNDATACOPY 0EB9 3D RETURNDATASIZE 0EBA 60 PUSH1 0x00 0EBC FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0EB8 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0EBC revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0EBD: // Incoming jump from 0x0EB3, if !!address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[2] // { // @0EC4 memory[0x40:0x60] // @0EC5 returndata.length // } 0EBD 5B JUMPDEST 0EBE 50 POP 0EBF 50 POP 0EC0 50 POP 0EC1 50 POP 0EC2 60 PUSH1 0x40 0EC4 51 MLOAD 0EC5 3D RETURNDATASIZE 0EC6 60 PUSH1 0x1f 0EC8 19 NOT 0EC9 60 PUSH1 0x1f 0ECB 82 DUP3 0ECC 01 ADD 0ECD 16 AND 0ECE 82 DUP3 0ECF 01 ADD 0ED0 80 DUP1 0ED1 60 PUSH1 0x40 0ED3 52 MSTORE 0ED4 50 POP 0ED5 81 DUP2 0ED6 01 ADD 0ED7 90 SWAP1 0ED8 61 PUSH2 0x0ee1 0EDB 91 SWAP2 0EDC 90 SWAP1 0EDD 61 PUSH2 0x1b80 0EE0 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0ED3 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @0EDB stack[-4] = 0x0ee1 // @0EDC stack[-2] = memory[0x40:0x60] // @0EDC stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x1b80 0EE1 5B JUMPDEST 0EE2 61 PUSH2 0x0be9 0EE5 57 *JUMPI 0EE6 60 PUSH1 0x40 0EE8 51 MLOAD 0EE9 63 PUSH4 0x3b79c773 0EEE 60 PUSH1 0xe2 0EF0 1B SHL 0EF1 81 DUP2 0EF2 52 MSTORE 0EF3 60 PUSH1 0x01 0EF5 60 PUSH1 0x01 0EF7 60 PUSH1 0xa0 0EF9 1B SHL 0EFA 03 SUB 0EFB 82 DUP3 0EFC 16 AND 0EFD 60 PUSH1 0x04 0EFF 82 DUP3 0F00 01 ADD 0F01 52 MSTORE 0F02 60 PUSH1 0x24 0F04 01 ADD 0F05 61 PUSH2 0x0852 0F08 56 *JUMP label_0F09: // Incoming call from 0x07B8, returns to 0x07B9 // Inputs[1] { @0F0F stack[-1] } 0F09 5B JUMPDEST 0F0A 60 PUSH1 0x00 0F0C 61 PUSH2 0x0f14 0F0F 82 DUP3 0F10 61 PUSH2 0x0a6b 0F13 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F0A stack[0] = 0x00 // @0F0C stack[1] = 0x0f14 // @0F0F stack[2] = stack[-1] // } // Block ends with call to 0x0a6b, returns to 0x0F14 label_0F14: // Incoming return from call to 0x0A6B at 0x0F13 // Inputs[3] // { // @0F15 stack[-2] // @0F15 stack[-1] // @0F17 msg.sender // } 0F14 5B JUMPDEST 0F15 90 SWAP1 0F16 50 POP 0F17 33 CALLER 0F18 60 PUSH1 0x01 0F1A 60 PUSH1 0x01 0F1C 60 PUSH1 0xa0 0F1E 1B SHL 0F1F 03 SUB 0F20 82 DUP3 0F21 16 AND 0F22 14 EQ 0F23 61 PUSH2 0x0f4d 0F26 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0F15 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0f4d, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_0F27: // Incoming jump from 0x0F26, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @0F2A stack[-1] // @0F2B msg.sender // } 0F27 61 PUSH2 0x0f30 0F2A 81 DUP2 0F2B 33 CALLER 0F2C 61 PUSH2 0x05e2 0F2F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F27 stack[0] = 0x0f30 // @0F2A stack[1] = stack[-1] // @0F2B stack[2] = msg.sender // } // Block ends with call to 0x05e2, returns to 0x0F30 label_0F30: // Incoming return from call to 0x05E2 at 0x0F2F // Inputs[1] { @0F34 stack[-1] } 0F30 5B JUMPDEST 0F31 61 PUSH2 0x0f4d 0F34 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f4d, if stack[-1] label_0F35: // Incoming jump from 0x0F34, if not stack[-1] // Inputs[3] // { // @0F37 memory[0x40:0x60] // @0F47 memory[0x40:0x60] // @0F4C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0F35 60 PUSH1 0x40 0F37 51 MLOAD 0F38 63 PUSH4 0x67d9dca1 0F3D 60 PUSH1 0xe1 0F3F 1B SHL 0F40 81 DUP2 0F41 52 MSTORE 0F42 60 PUSH1 0x04 0F44 01 ADD 0F45 60 PUSH1 0x40 0F47 51 MLOAD 0F48 80 DUP1 0F49 91 SWAP2 0F4A 03 SUB 0F4B 90 SWAP1 0F4C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0F41 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x67d9dca1 << 0xe1 // @0F4C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0F4D: // Incoming jump from 0x0F34, if stack[-1] // Incoming jump from 0x0F26, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[8] // { // @0F50 stack[-2] // @0F5C memory[0x00:0x40] // @0F5E storage[keccak256(memory[0x00:0x40])] // @0F71 stack[-3] // @0F7B memory[0x40:0x60] // @0F7F stack[-1] // @0FA4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0FA8 stack[-4] // } 0F4D 5B JUMPDEST 0F4E 60 PUSH1 0x00 0F50 82 DUP3 0F51 81 DUP2 0F52 52 MSTORE 0F53 60 PUSH1 0x06 0F55 60 PUSH1 0x20 0F57 52 MSTORE 0F58 60 PUSH1 0x40 0F5A 80 DUP1 0F5B 82 DUP3 0F5C 20 SHA3 0F5D 80 DUP1 0F5E 54 SLOAD 0F5F 60 PUSH1 0x01 0F61 60 PUSH1 0x01 0F63 60 PUSH1 0xa0 0F65 1B SHL 0F66 03 SUB 0F67 19 NOT 0F68 16 AND 0F69 60 PUSH1 0x01 0F6B 60 PUSH1 0x01 0F6D 60 PUSH1 0xa0 0F6F 1B SHL 0F70 03 SUB 0F71 87 DUP8 0F72 81 DUP2 0F73 16 AND 0F74 91 SWAP2 0F75 82 DUP3 0F76 17 OR 0F77 90 SWAP1 0F78 92 SWAP3 0F79 55 SSTORE 0F7A 91 SWAP2 0F7B 51 MLOAD 0F7C 85 DUP6 0F7D 93 SWAP4 0F7E 91 SWAP2 0F7F 85 DUP6 0F80 16 AND 0F81 91 SWAP2 0F82 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0FA3 91 SWAP2 0FA4 A4 LOG4 0FA5 50 POP 0FA6 50 POP 0FA7 50 POP 0FA8 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @0F52 memory[0x00:0x20] = stack[-2] // @0F57 memory[0x20:0x40] = 0x06 // @0F79 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @0FA4 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_0FA9: // Incoming call from 0x07E2, returns to 0x07E3 // Inputs[1] { @0FAF stack[-1] } 0FA9 5B JUMPDEST 0FAA 60 PUSH1 0x00 0FAC 61 PUSH2 0x0fb4 0FAF 82 DUP3 0FB0 61 PUSH2 0x1338 0FB3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FAA stack[0] = 0x00 // @0FAC stack[1] = 0x0fb4 // @0FAF stack[2] = stack[-1] // } // Block ends with call to 0x1338, returns to 0x0FB4 label_0FB4: // Incoming return from call to 0x1338 at 0x0FB3 // Inputs[3] // { // @0FB5 stack[-1] // @0FB5 stack[-2] // @0FB7 stack[-5] // } 0FB4 5B JUMPDEST 0FB5 90 SWAP1 0FB6 50 POP 0FB7 83 DUP4 0FB8 60 PUSH1 0x01 0FBA 60 PUSH1 0x01 0FBC 60 PUSH1 0xa0 0FBE 1B SHL 0FBF 03 SUB 0FC0 16 AND 0FC1 81 DUP2 0FC2 60 PUSH1 0x01 0FC4 60 PUSH1 0x01 0FC6 60 PUSH1 0xa0 0FC8 1B SHL 0FC9 03 SUB 0FCA 16 AND 0FCB 14 EQ 0FCC 61 PUSH2 0x0fe7 0FCF 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0FB5 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0fe7, if (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] label_0FD0: // Incoming jump from 0x0FCF, if not (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @0FD2 memory[0x40:0x60] // @0FE1 memory[0x40:0x60] // @0FE6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0FD0 60 PUSH1 0x40 0FD2 51 MLOAD 0FD3 62 PUSH3 0xa11481 0FD7 60 PUSH1 0xe8 0FD9 1B SHL 0FDA 81 DUP2 0FDB 52 MSTORE 0FDC 60 PUSH1 0x04 0FDE 01 ADD 0FDF 60 PUSH1 0x40 0FE1 51 MLOAD 0FE2 80 DUP1 0FE3 91 SWAP2 0FE4 03 SUB 0FE5 90 SWAP1 0FE6 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0FDB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa11481 << 0xe8 // @0FE6 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0FE7: // Incoming jump from 0x0FCF, if (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[5] // { // @0FEA stack[-2] // @0FF5 memory[0x00:0x40] // @0FF7 storage[keccak256(memory[0x00:0x40])] // @0FF8 msg.sender // @1004 stack[-4] // } 0FE7 5B JUMPDEST 0FE8 60 PUSH1 0x00 0FEA 82 DUP3 0FEB 81 DUP2 0FEC 52 MSTORE 0FED 60 PUSH1 0x06 0FEF 60 PUSH1 0x20 0FF1 52 MSTORE 0FF2 60 PUSH1 0x40 0FF4 90 SWAP1 0FF5 20 SHA3 0FF6 80 DUP1 0FF7 54 SLOAD 0FF8 33 CALLER 0FF9 80 DUP1 0FFA 82 DUP3 0FFB 14 EQ 0FFC 60 PUSH1 0x01 0FFE 60 PUSH1 0x01 1000 60 PUSH1 0xa0 1002 1B SHL 1003 03 SUB 1004 88 DUP9 1005 16 AND 1006 90 SWAP1 1007 91 SWAP2 1008 14 EQ 1009 17 OR 100A 61 PUSH2 0x1034 100D 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0FEC memory[0x00:0x20] = stack[-2] // @0FF1 memory[0x20:0x40] = 0x06 // @0FF5 stack[0] = keccak256(memory[0x00:0x40]) // @0FF7 stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1034, if (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) label_100E: // Incoming jump from 0x100D, if not (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) // Inputs[2] // { // @1011 stack[-6] // @1012 msg.sender // } 100E 61 PUSH2 0x1017 1011 86 DUP7 1012 33 CALLER 1013 61 PUSH2 0x05e2 1016 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @100E stack[0] = 0x1017 // @1011 stack[1] = stack[-6] // @1012 stack[2] = msg.sender // } // Block ends with call to 0x05e2, returns to 0x1017 label_1017: // Incoming return from call to 0x05E2 at 0x1016 // Inputs[1] { @101B stack[-1] } 1017 5B JUMPDEST 1018 61 PUSH2 0x1034 101B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1034, if stack[-1] label_101C: // Incoming jump from 0x101B, if not stack[-1] // Inputs[3] // { // @101E memory[0x40:0x60] // @102E memory[0x40:0x60] // @1033 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 101C 60 PUSH1 0x40 101E 51 MLOAD 101F 63 PUSH4 0x2ce44b5f 1024 60 PUSH1 0xe1 1026 1B SHL 1027 81 DUP2 1028 52 MSTORE 1029 60 PUSH1 0x04 102B 01 ADD 102C 60 PUSH1 0x40 102E 51 MLOAD 102F 80 DUP1 1030 91 SWAP2 1031 03 SUB 1032 90 SWAP1 1033 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1028 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2ce44b5f << 0xe1 // @1033 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1034: // Incoming jump from 0x101B, if stack[-1] // Incoming jump from 0x100D, if (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) // Inputs[1] { @103D stack[-5] } 1034 5B JUMPDEST 1035 60 PUSH1 0x01 1037 60 PUSH1 0x01 1039 60 PUSH1 0xa0 103B 1B SHL 103C 03 SUB 103D 85 DUP6 103E 16 AND 103F 61 PUSH2 0x105b 1042 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x105b, if stack[-5] & (0x01 << 0xa0) - 0x01 label_1043: // Incoming jump from 0x1042, if not stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1045 memory[0x40:0x60] // @1055 memory[0x40:0x60] // @105A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1043 60 PUSH1 0x40 1045 51 MLOAD 1046 63 PUSH4 0x3a954ecd 104B 60 PUSH1 0xe2 104D 1B SHL 104E 81 DUP2 104F 52 MSTORE 1050 60 PUSH1 0x04 1052 01 ADD 1053 60 PUSH1 0x40 1055 51 MLOAD 1056 80 DUP1 1057 91 SWAP2 1058 03 SUB 1059 90 SWAP1 105A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @104F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3a954ecd << 0xe2 // @105A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_105B: // Incoming jump from 0x1042, if stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @105C stack[-1] } 105B 5B JUMPDEST 105C 80 DUP1 105D 15 ISZERO 105E 61 PUSH2 0x1066 1061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1066, if !stack[-1] label_1062: // Incoming jump from 0x1061, if not !stack[-1] // Inputs[11] // { // @1064 stack[-2] // @106F stack[-6] // @1080 memory[0x00:0x40] // @1082 storage[keccak256(memory[0x00:0x40])] // @108A stack[-5] // @1091 memory[0x00:0x40] // @1093 storage[keccak256(memory[0x00:0x40])] // @1099 block.timestamp // @10A6 stack[-4] // @10B1 memory[0x00:0x40] // @10BB stack[-3] // } 1062 60 PUSH1 0x00 1064 82 DUP3 1065 55 SSTORE 1066 5B JUMPDEST 1067 60 PUSH1 0x01 1069 60 PUSH1 0x01 106B 60 PUSH1 0xa0 106D 1B SHL 106E 03 SUB 106F 86 DUP7 1070 81 DUP2 1071 16 AND 1072 60 PUSH1 0x00 1074 90 SWAP1 1075 81 DUP2 1076 52 MSTORE 1077 60 PUSH1 0x05 1079 60 PUSH1 0x20 107B 52 MSTORE 107C 60 PUSH1 0x40 107E 80 DUP1 107F 82 DUP3 1080 20 SHA3 1081 80 DUP1 1082 54 SLOAD 1083 60 PUSH1 0x00 1085 19 NOT 1086 01 ADD 1087 90 SWAP1 1088 55 SSTORE 1089 91 SWAP2 108A 87 DUP8 108B 16 AND 108C 80 DUP1 108D 82 DUP3 108E 52 MSTORE 108F 91 SWAP2 1090 90 SWAP1 1091 20 SHA3 1092 80 DUP1 1093 54 SLOAD 1094 60 PUSH1 0x01 1096 01 ADD 1097 90 SWAP1 1098 55 SSTORE 1099 42 TIMESTAMP 109A 60 PUSH1 0xa0 109C 1B SHL 109D 17 OR 109E 60 PUSH1 0x01 10A0 60 PUSH1 0xe1 10A2 1B SHL 10A3 17 OR 10A4 60 PUSH1 0x00 10A6 85 DUP6 10A7 81 DUP2 10A8 52 MSTORE 10A9 60 PUSH1 0x04 10AB 60 PUSH1 0x20 10AD 52 MSTORE 10AE 60 PUSH1 0x40 10B0 81 DUP2 10B1 20 SHA3 10B2 91 SWAP2 10B3 90 SWAP1 10B4 91 SWAP2 10B5 55 SSTORE 10B6 60 PUSH1 0x01 10B8 60 PUSH1 0xe1 10BA 1B SHL 10BB 84 DUP5 10BC 16 AND 10BD 90 SWAP1 10BE 03 SUB 10BF 61 PUSH2 0x10f8 10C2 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @1065 storage[stack[-2]] = 0x00 // @1076 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @107B memory[0x20:0x40] = 0x05 // @1088 storage[keccak256(memory[0x00:0x40])] = ~0x00 + storage[keccak256(memory[0x00:0x40])] // @108E memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @1098 storage[keccak256(memory[0x00:0x40])] = 0x01 + storage[keccak256(memory[0x00:0x40])] // @10A8 memory[0x00:0x20] = stack[-4] // @10AD memory[0x20:0x40] = 0x04 // @10B5 storage[keccak256(memory[0x00:0x40])] = (0x01 << 0xe1) | (block.timestamp << 0xa0) | (stack[-5] & (0x01 << 0xa0) - 0x01) // } // Block ends with conditional jump to 0x10f8, if 0x00 - (stack[-3] & (0x01 << 0xe1)) label_10C3: // Incoming jump from 0x10C2, if not 0x00 - (stack[-3] & (0x01 << 0xe1)) // Incoming jump from 0x10C2, if not 0x00 - (stack[-3] & (0x01 << 0xe1)) // Inputs[3] // { // @10C5 stack[-4] // @10D4 memory[0x00:0x40] // @10D5 storage[keccak256(memory[0x00:0x40])] // } 10C3 60 PUSH1 0x01 10C5 84 DUP5 10C6 01 ADD 10C7 60 PUSH1 0x00 10C9 81 DUP2 10CA 81 DUP2 10CB 52 MSTORE 10CC 60 PUSH1 0x04 10CE 60 PUSH1 0x20 10D0 52 MSTORE 10D1 60 PUSH1 0x40 10D3 81 DUP2 10D4 20 SHA3 10D5 54 SLOAD 10D6 90 SWAP1 10D7 03 SUB 10D8 61 PUSH2 0x10f6 10DB 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @10C6 stack[0] = stack[-4] + 0x01 // @10CB memory[0x00:0x20] = stack[-4] + 0x01 // @10D0 memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x10f6, if 0x00 - storage[keccak256(memory[0x00:0x40])] label_10DC: // Incoming jump from 0x10DB, if not 0x00 - storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @10DE storage[0x00] // @10DF stack[-1] // } 10DC 60 PUSH1 0x00 10DE 54 SLOAD 10DF 81 DUP2 10E0 14 EQ 10E1 61 PUSH2 0x10f6 10E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10f6, if stack[-1] == storage[0x00] label_10E5: // Incoming jump from 0x10E4, if not stack[-1] == storage[0x00] // Inputs[3] // { // @10E7 stack[-1] // @10F2 memory[0x00:0x40] // @10F3 stack[-4] // } 10E5 60 PUSH1 0x00 10E7 81 DUP2 10E8 81 DUP2 10E9 52 MSTORE 10EA 60 PUSH1 0x04 10EC 60 PUSH1 0x20 10EE 52 MSTORE 10EF 60 PUSH1 0x40 10F1 90 SWAP1 10F2 20 SHA3 10F3 84 DUP5 10F4 90 SWAP1 10F5 55 SSTORE // Stack delta = +0 // Outputs[3] // { // @10E9 memory[0x00:0x20] = stack[-1] // @10EE memory[0x20:0x40] = 0x04 // @10F5 storage[keccak256(memory[0x00:0x40])] = stack[-4] // } // Block continues label_10F6: // Incoming jump from 0x10F5 // Incoming jump from 0x10E4, if stack[-1] == storage[0x00] // Incoming jump from 0x10DB, if 0x00 - storage[keccak256(memory[0x00:0x40])] 10F6 5B JUMPDEST 10F7 50 POP // Stack delta = -1 // Block continues label_10F8: // Incoming jump from 0x10C2, if 0x00 - (stack[-3] & (0x01 << 0xe1)) // Incoming jump from 0x10F7 // Incoming jump from 0x10C2, if 0x00 - (stack[-3] & (0x01 << 0xe1)) // Inputs[7] // { // @10F9 stack[-4] // @10FA stack[-5] // @1104 stack[-6] // @1131 memory[0x40:0x60] // @1134 memory[0x40:0x60] // @1139 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1141 stack[-7] // } 10F8 5B JUMPDEST 10F9 83 DUP4 10FA 85 DUP6 10FB 60 PUSH1 0x01 10FD 60 PUSH1 0x01 10FF 60 PUSH1 0xa0 1101 1B SHL 1102 03 SUB 1103 16 AND 1104 87 DUP8 1105 60 PUSH1 0x01 1107 60 PUSH1 0x01 1109 60 PUSH1 0xa0 110B 1B SHL 110C 03 SUB 110D 16 AND 110E 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 112F 60 PUSH1 0x40 1131 51 MLOAD 1132 60 PUSH1 0x40 1134 51 MLOAD 1135 80 DUP1 1136 91 SWAP2 1137 03 SUB 1138 90 SWAP1 1139 A4 LOG4 113A 5B JUMPDEST 113B 50 POP 113C 50 POP 113D 50 POP 113E 50 POP 113F 50 POP 1140 50 POP 1141 56 *JUMP // Stack delta = -7 // Outputs[1] { @1139 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5] & (0x01 << 0xa0) - 0x01, stack[-4]]); } // Block ends with unconditional jump to stack[-7] label_1142: // Incoming call from 0x0BF3, returns to 0x0BF4 // Incoming call from 0x0A51, returns to 0x0A52 // Incoming call from 0x0B0B, returns to 0x0B0C // Incoming call from 0x0B67, returns to 0x0B68 // Incoming call from 0x0C77, returns to 0x0C78 // Incoming call from 0x07F0, returns to 0x07F1 // Incoming call from 0x0C26, returns to 0x0C27 // Incoming call from 0x0D44, returns to 0x0D45 // Incoming call from 0x0DBB, returns to 0x0DBC // Incoming call from 0x09AF, returns to 0x09B0 // Incoming call from 0x0A65, returns to 0x0A66 // Inputs[2] // { // @1145 storage[0x08] // @1155 msg.sender // } 1142 5B JUMPDEST 1143 60 PUSH1 0x08 1145 54 SLOAD 1146 60 PUSH1 0x01 1148 60 PUSH1 0x01 114A 60 PUSH1 0xa0 114C 1B SHL 114D 03 SUB 114E 61 PUSH2 0x0100 1151 90 SWAP1 1152 91 SWAP2 1153 04 DIV 1154 16 AND 1155 33 CALLER 1156 14 EQ 1157 61 PUSH2 0x07f9 115A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07f9, if msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 label_115B: // Incoming jump from 0x115A, if not msg.sender == storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 // Inputs[1] { @115D memory[0x40:0x60] } 115B 60 PUSH1 0x40 115D 51 MLOAD 115E 62 PUSH3 0x461bcd 1162 60 PUSH1 0xe5 1164 1B SHL 1165 81 DUP2 1166 52 MSTORE 1167 60 PUSH1 0x20 1169 60 PUSH1 0x04 116B 82 DUP3 116C 01 ADD 116D 81 DUP2 116E 90 SWAP1 116F 52 MSTORE 1170 60 PUSH1 0x24 1172 82 DUP3 1173 01 ADD 1174 52 MSTORE 1175 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1196 60 PUSH1 0x44 1198 82 DUP3 1199 01 ADD 119A 52 MSTORE 119B 60 PUSH1 0x64 119D 01 ADD 119E 61 PUSH2 0x0852 11A1 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1166 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @116F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1174 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @119A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @119D stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0852 label_11A2: // Incoming call from 0x07F8, returns to 0x07F9 11A2 5B JUMPDEST 11A3 61 PUSH2 0x11aa 11A6 61 PUSH2 0x15a8 11A9 56 *JUMP // Stack delta = +1 // Outputs[1] { @11A3 stack[0] = 0x11aa } // Block ends with call to 0x15a8, returns to 0x11AA label_11AA: // Incoming return from call to 0x15A8 at 0x11A9 // Inputs[6] // { // @11AE storage[0x08] // @11D6 msg.sender // @11DA memory[0x40:0x60] // @11ED memory[0x40:0x60] // @11F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @11F3 stack[-1] // } 11AA 5B JUMPDEST 11AB 60 PUSH1 0x08 11AD 80 DUP1 11AE 54 SLOAD 11AF 60 PUSH1 0xff 11B1 19 NOT 11B2 16 AND 11B3 90 SWAP1 11B4 55 SSTORE 11B5 7F PUSH32 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa 11D6 33 CALLER 11D7 5B JUMPDEST 11D8 60 PUSH1 0x40 11DA 51 MLOAD 11DB 60 PUSH1 0x01 11DD 60 PUSH1 0x01 11DF 60 PUSH1 0xa0 11E1 1B SHL 11E2 03 SUB 11E3 90 SWAP1 11E4 91 SWAP2 11E5 16 AND 11E6 81 DUP2 11E7 52 MSTORE 11E8 60 PUSH1 0x20 11EA 01 ADD 11EB 60 PUSH1 0x40 11ED 51 MLOAD 11EE 80 DUP1 11EF 91 SWAP2 11F0 03 SUB 11F1 90 SWAP1 11F2 A1 LOG1 11F3 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @11B4 storage[0x08] = ~0xff & storage[0x08] // @11E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.sender & (0x01 << 0xa0) - 0x01 // @11F2 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_11F4: // Incoming call from 0x13C7, returns to 0x13C8 // Incoming call from 0x0802, returns to 0x0803 // Inputs[1] { @11F7 storage[0x08] } 11F4 5B JUMPDEST 11F5 60 PUSH1 0x08 11F7 54 SLOAD 11F8 60 PUSH1 0xff 11FA 16 AND 11FB 15 ISZERO 11FC 61 PUSH2 0x07f9 11FF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07f9, if !(0xff & storage[0x08]) label_1200: // Incoming jump from 0x11FF, if not !(0xff & storage[0x08]) // Inputs[1] { @1202 memory[0x40:0x60] } 1200 60 PUSH1 0x40 1202 51 MLOAD 1203 62 PUSH3 0x461bcd 1207 60 PUSH1 0xe5 1209 1B SHL 120A 81 DUP2 120B 52 MSTORE 120C 60 PUSH1 0x20 120E 60 PUSH1 0x04 1210 82 DUP3 1211 01 ADD 1212 52 MSTORE 1213 60 PUSH1 0x10 1215 60 PUSH1 0x24 1217 82 DUP3 1218 01 ADD 1219 52 MSTORE 121A 6F PUSH16 0x14185d5cd8589b194e881c185d5cd959 122B 60 PUSH1 0x82 122D 1B SHL 122E 60 PUSH1 0x44 1230 82 DUP3 1231 01 ADD 1232 52 MSTORE 1233 60 PUSH1 0x64 1235 01 ADD 1236 61 PUSH2 0x0852 1239 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @120B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1212 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1219 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @1232 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x14185d5cd8589b194e881c185d5cd959 << 0x82 // @1235 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0852 label_123A: // Incoming jump from 0x0CA6 // Incoming call from 0x0988, returns to 0x0989 // Inputs[2] // { // @123E storage[0x00] // @1240 stack[-1] // } 123A 5B JUMPDEST 123B 60 PUSH1 0x00 123D 80 DUP1 123E 54 SLOAD 123F 90 SWAP1 1240 82 DUP3 1241 90 SWAP1 1242 03 SUB 1243 61 PUSH2 0x125f 1246 57 *JUMPI // Stack delta = +1 // Outputs[1] { @123F stack[0] = storage[0x00] } // Block ends with conditional jump to 0x125f, if 0x00 - stack[-1] label_1247: // Incoming jump from 0x1246, if not 0x00 - stack[-1] // Inputs[3] // { // @1249 memory[0x40:0x60] // @1259 memory[0x40:0x60] // @125E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1247 60 PUSH1 0x40 1249 51 MLOAD 124A 63 PUSH4 0xb562e8dd 124F 60 PUSH1 0xe0 1251 1B SHL 1252 81 DUP2 1253 52 MSTORE 1254 60 PUSH1 0x04 1256 01 ADD 1257 60 PUSH1 0x40 1259 51 MLOAD 125A 80 DUP1 125B 91 SWAP2 125C 03 SUB 125D 90 SWAP1 125E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1253 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd << 0xe0 // @125E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_125F: // Incoming jump from 0x1246, if 0x00 - stack[-1] // Inputs[8] // { // @1268 stack[-3] // @127A memory[0x00:0x40] // @127C storage[keccak256(memory[0x00:0x40])] // @1287 stack[-2] // @128C stack[-1] // @1295 memory[0x00:0x40] // @129D block.timestamp // @12D1 memory[0x00:0x00] // } 125F 5B JUMPDEST 1260 60 PUSH1 0x01 1262 60 PUSH1 0x01 1264 60 PUSH1 0xa0 1266 1B SHL 1267 03 SUB 1268 83 DUP4 1269 16 AND 126A 60 PUSH1 0x00 126C 81 DUP2 126D 81 DUP2 126E 52 MSTORE 126F 60 PUSH1 0x05 1271 60 PUSH1 0x20 1273 90 SWAP1 1274 81 DUP2 1275 52 MSTORE 1276 60 PUSH1 0x40 1278 80 DUP1 1279 83 DUP4 127A 20 SHA3 127B 80 DUP1 127C 54 SLOAD 127D 68 PUSH9 0x010000000000000001 1287 88 DUP9 1288 02 MUL 1289 01 ADD 128A 90 SWAP1 128B 55 SSTORE 128C 84 DUP5 128D 83 DUP4 128E 52 MSTORE 128F 60 PUSH1 0x04 1291 90 SWAP1 1292 91 SWAP2 1293 52 MSTORE 1294 81 DUP2 1295 20 SHA3 1296 60 PUSH1 0x01 1298 85 DUP6 1299 14 EQ 129A 60 PUSH1 0xe1 129C 1B SHL 129D 42 TIMESTAMP 129E 60 PUSH1 0xa0 12A0 1B SHL 12A1 17 OR 12A2 83 DUP4 12A3 17 OR 12A4 90 SWAP1 12A5 55 SSTORE 12A6 82 DUP3 12A7 84 DUP5 12A8 01 ADD 12A9 90 SWAP1 12AA 83 DUP4 12AB 90 SWAP1 12AC 83 DUP4 12AD 90 SWAP1 12AE 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 12CF 81 DUP2 12D0 80 DUP1 12D1 A4 LOG4 12D2 60 PUSH1 0x01 12D4 83 DUP4 12D5 01 ADD 12D6 5B JUMPDEST 12D7 81 DUP2 12D8 81 DUP2 12D9 14 EQ 12DA 61 PUSH2 0x130e 12DD 57 *JUMPI // Stack delta = +3 // Outputs[10] // { // @1269 stack[0] = stack[-3] & (0x01 << 0xa0) - 0x01 // @126E memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1275 memory[0x20:0x40] = 0x05 // @128B storage[keccak256(memory[0x00:0x40])] = stack[-2] * 0x010000000000000001 + storage[keccak256(memory[0x00:0x40])] // @128E memory[0x00:0x20] = stack[-1] // @1293 memory[0x20:0x40] = 0x04 // @12A5 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (block.timestamp << 0xa0) | ((stack[-2] == 0x01) << 0xe1) // @12A9 stack[1] = stack[-2] + stack[-1] // @12D1 log(memory[0x00:0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-1]]); // @12D5 stack[2] = stack[-1] + 0x01 // } // Block ends with conditional jump to 0x130e, if stack[-1] + 0x01 == stack[-2] + stack[-1] label_12DE: // Incoming jump from 0x12DD, if not stack[-1] == stack[-2] // Incoming jump from 0x12DD, if not stack[-1] + 0x01 == stack[-2] + stack[-1] // Inputs[3] // { // @12DE stack[-1] // @12DF stack[-3] // @1306 memory[0x00:0x00] // } 12DE 80 DUP1 12DF 83 DUP4 12E0 60 PUSH1 0x00 12E2 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1303 60 PUSH1 0x00 1305 80 DUP1 1306 A4 LOG4 1307 60 PUSH1 0x01 1309 01 ADD 130A 61 PUSH2 0x12d6 130D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1306 log(memory[0x00:0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-3], stack[-1]]); // @1309 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x12d6 label_130E: // Incoming jump from 0x12DD, if stack[-1] == stack[-2] // Incoming jump from 0x12DD, if stack[-1] + 0x01 == stack[-2] + stack[-1] // Inputs[1] { @1310 stack[-3] } 130E 5B JUMPDEST 130F 50 POP 1310 81 DUP2 1311 60 PUSH1 0x00 1313 03 SUB 1314 61 PUSH2 0x132f 1317 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x132f, if 0x00 - stack[-3] label_1318: // Incoming jump from 0x1317, if not 0x00 - stack[-3] // Inputs[3] // { // @131A memory[0x40:0x60] // @1329 memory[0x40:0x60] // @132E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1318 60 PUSH1 0x40 131A 51 MLOAD 131B 62 PUSH3 0x2e0763 131F 60 PUSH1 0xe8 1321 1B SHL 1322 81 DUP2 1323 52 MSTORE 1324 60 PUSH1 0x04 1326 01 ADD 1327 60 PUSH1 0x40 1329 51 MLOAD 132A 80 DUP1 132B 91 SWAP2 132C 03 SUB 132D 90 SWAP1 132E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1323 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e0763 << 0xe8 // @132E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_132F: // Incoming jump from 0x1317, if 0x00 - stack[-3] // Inputs[2] // { // @1332 stack[-1] // @1337 stack[-6] // } 132F 5B JUMPDEST 1330 60 PUSH1 0x00 1332 55 SSTORE 1333 50 POP 1334 50 POP 1335 50 POP 1336 50 POP 1337 56 *JUMP // Stack delta = -6 // Outputs[1] { @1332 storage[0x00] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1338: // Incoming call from 0x0A75, returns to 0x06C9 // Incoming call from 0x0FB3, returns to 0x0FB4 // Inputs[1] { @133B stack[-1] } 1338 5B JUMPDEST 1339 60 PUSH1 0x00 133B 81 DUP2 133C 80 DUP1 133D 60 PUSH1 0x01 133F 11 GT 1340 61 PUSH2 0x138e 1343 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1339 stack[0] = 0x00 // @133B stack[1] = stack[-1] // } // Block ends with conditional jump to 0x138e, if 0x01 > stack[-1] label_1344: // Incoming jump from 0x1343, if not 0x01 > stack[-1] // Inputs[2] // { // @1346 storage[0x00] // @1347 stack[-1] // } 1344 60 PUSH1 0x00 1346 54 SLOAD 1347 81 DUP2 1348 10 LT 1349 15 ISZERO 134A 61 PUSH2 0x138e 134D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x138e, if !(stack[-1] < storage[0x00]) label_134E: // Incoming jump from 0x134D, if not !(stack[-1] < storage[0x00]) // Inputs[3] // { // @1350 stack[-1] // @135B memory[0x00:0x40] // @135C storage[keccak256(memory[0x00:0x40])] // } 134E 60 PUSH1 0x00 1350 81 DUP2 1351 81 DUP2 1352 52 MSTORE 1353 60 PUSH1 0x04 1355 60 PUSH1 0x20 1357 52 MSTORE 1358 60 PUSH1 0x40 135A 81 DUP2 135B 20 SHA3 135C 54 SLOAD 135D 90 SWAP1 135E 60 PUSH1 0x01 1360 60 PUSH1 0xe0 1362 1B SHL 1363 82 DUP3 1364 16 AND 1365 90 SWAP1 1366 03 SUB 1367 61 PUSH2 0x138c 136A 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1352 memory[0x00:0x20] = stack[-1] // @1357 memory[0x20:0x40] = 0x04 // @135D stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x138c, if 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) label_136B: // Incoming jump from 0x136A, if not 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) // Incoming jump from 0x138B // Inputs[1] { @136C stack[-1] } 136B 5B JUMPDEST 136C 80 DUP1 136D 60 PUSH1 0x00 136F 03 SUB 1370 61 PUSH2 0x0d36 1373 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d36, if 0x00 - stack[-1] label_1374: // Incoming jump from 0x1373, if not 0x00 - stack[-1] // Inputs[3] // { // @1378 stack[-2] // @1386 memory[0x00:0x40] // @1387 storage[keccak256(memory[0x00:0x40])] // } 1374 50 POP 1375 60 PUSH1 0x00 1377 19 NOT 1378 01 ADD 1379 60 PUSH1 0x00 137B 81 DUP2 137C 81 DUP2 137D 52 MSTORE 137E 60 PUSH1 0x04 1380 60 PUSH1 0x20 1382 52 MSTORE 1383 60 PUSH1 0x40 1385 90 SWAP1 1386 20 SHA3 1387 54 SLOAD 1388 61 PUSH2 0x136b 138B 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1378 stack[-2] = ~0x00 + stack[-2] // @137D memory[0x00:0x20] = ~0x00 + stack[-2] // @1382 memory[0x20:0x40] = 0x04 // @1387 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x136b label_138C: // Incoming jump from 0x136A, if 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) 138C 5B JUMPDEST 138D 50 POP // Stack delta = -1 // Block continues label_138E: // Incoming jump from 0x138D // Incoming jump from 0x134D, if !(stack[-1] < storage[0x00]) // Incoming jump from 0x1343, if 0x01 > stack[-1] // Inputs[3] // { // @1391 memory[0x40:0x60] // @13A1 memory[0x40:0x60] // @13A6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 138E 5B JUMPDEST 138F 60 PUSH1 0x40 1391 51 MLOAD 1392 63 PUSH4 0x6f96cda1 1397 60 PUSH1 0xe1 1399 1B SHL 139A 81 DUP2 139B 52 MSTORE 139C 60 PUSH1 0x04 139E 01 ADD 139F 60 PUSH1 0x40 13A1 51 MLOAD 13A2 80 DUP1 13A3 91 SWAP2 13A4 03 SUB 13A5 90 SWAP1 13A6 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @139B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f96cda1 << 0xe1 // @13A6 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_13A7: // Incoming call from 0x0BE8, returns to 0x0BE9 // Incoming call from 0x0B71, returns to 0x07F9 // Inputs[2] // { // @13AB storage[0x09] // @13BB stack[-1] // } 13A7 5B JUMPDEST 13A8 60 PUSH1 0x09 13AA 80 DUP1 13AB 54 SLOAD 13AC 60 PUSH1 0x01 13AE 60 PUSH1 0x01 13B0 60 PUSH1 0xa0 13B2 1B SHL 13B3 03 SUB 13B4 19 NOT 13B5 16 AND 13B6 90 SWAP1 13B7 55 SSTORE 13B8 61 PUSH2 0x0be9 13BB 81 DUP2 13BC 61 PUSH2 0x0dc1 13BF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @13B7 storage[0x09] = ~((0x01 << 0xa0) - 0x01) & storage[0x09] // @13B8 stack[0] = 0x0be9 // @13BB stack[1] = stack[-1] // } // Block ends with call to 0x0dc1, returns to 0x0BE9 label_13C0: // Incoming call from 0x0BFB, returns to 0x07F9 13C0 5B JUMPDEST 13C1 61 PUSH2 0x13c8 13C4 61 PUSH2 0x11f4 13C7 56 *JUMP // Stack delta = +1 // Outputs[1] { @13C1 stack[0] = 0x13c8 } // Block ends with call to 0x11f4, returns to 0x13C8 label_13C8: // Incoming return from call to 0x11F4 at 0x13C7 // Inputs[2] // { // @13CC storage[0x08] // @13FA msg.sender // } 13C8 5B JUMPDEST 13C9 60 PUSH1 0x08 13CB 80 DUP1 13CC 54 SLOAD 13CD 60 PUSH1 0xff 13CF 19 NOT 13D0 16 AND 13D1 60 PUSH1 0x01 13D3 17 OR 13D4 90 SWAP1 13D5 55 SSTORE 13D6 7F PUSH32 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 13F7 61 PUSH2 0x11d7 13FA 33 CALLER 13FB 90 SWAP1 13FC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @13D5 storage[0x08] = 0x01 | (~0xff & storage[0x08]) // @13D6 stack[0] = 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 // @13FB stack[1] = msg.sender // } // Block ends with unconditional jump to 0x11d7 label_13FD: // Incoming call from 0x0C1E, returns to 0x07B9 // Inputs[10] // { // @13FE msg.sender // @140F memory[0x00:0x40] // @1418 stack[-2] // @1423 memory[0x00:0x40] // @1425 storage[keccak256(memory[0x00:0x40])] // @142A stack[-1] // @1434 memory[0x40:0x60] // @1460 memory[0x40:0x60] // @1465 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1468 stack[-3] // } 13FD 5B JUMPDEST 13FE 33 CALLER 13FF 60 PUSH1 0x00 1401 81 DUP2 1402 81 DUP2 1403 52 MSTORE 1404 60 PUSH1 0x07 1406 60 PUSH1 0x20 1408 90 SWAP1 1409 81 DUP2 140A 52 MSTORE 140B 60 PUSH1 0x40 140D 80 DUP1 140E 83 DUP4 140F 20 SHA3 1410 60 PUSH1 0x01 1412 60 PUSH1 0x01 1414 60 PUSH1 0xa0 1416 1B SHL 1417 03 SUB 1418 87 DUP8 1419 16 AND 141A 80 DUP1 141B 85 DUP6 141C 52 MSTORE 141D 90 SWAP1 141E 83 DUP4 141F 52 MSTORE 1420 92 SWAP3 1421 81 DUP2 1422 90 SWAP1 1423 20 SHA3 1424 80 DUP1 1425 54 SLOAD 1426 60 PUSH1 0xff 1428 19 NOT 1429 16 AND 142A 86 DUP7 142B 15 ISZERO 142C 15 ISZERO 142D 90 SWAP1 142E 81 DUP2 142F 17 OR 1430 90 SWAP1 1431 91 SWAP2 1432 55 SSTORE 1433 90 SWAP1 1434 51 MLOAD 1435 90 SWAP1 1436 81 DUP2 1437 52 MSTORE 1438 91 SWAP2 1439 92 SWAP3 143A 91 SWAP2 143B 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 145C 91 SWAP2 145D 01 ADD 145E 60 PUSH1 0x40 1460 51 MLOAD 1461 80 DUP1 1462 91 SWAP2 1463 03 SUB 1464 90 SWAP1 1465 A3 LOG3 1466 50 POP 1467 50 POP 1468 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @1403 memory[0x00:0x20] = msg.sender // @140A memory[0x20:0x40] = 0x07 // @141C memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @141F memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1432 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @1437 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @1465 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_1469: // Incoming jump from 0x0C52 // Inputs[6] // { // @146C memory[0x40:0x60] // @1482 stack[-3] // @148F msg.sender // @1491 stack[-4] // @1493 stack[-2] // @1495 stack[-1] // } 1469 5B JUMPDEST 146A 60 PUSH1 0x40 146C 51 MLOAD 146D 63 PUSH4 0x0a85bd01 1472 60 PUSH1 0xe1 1474 1B SHL 1475 81 DUP2 1476 52 MSTORE 1477 60 PUSH1 0x00 1479 90 SWAP1 147A 60 PUSH1 0x01 147C 60 PUSH1 0x01 147E 60 PUSH1 0xa0 1480 1B SHL 1481 03 SUB 1482 85 DUP6 1483 16 AND 1484 90 SWAP1 1485 63 PUSH4 0x150b7a02 148A 90 SWAP1 148B 61 PUSH2 0x149e 148E 90 SWAP1 148F 33 CALLER 1490 90 SWAP1 1491 89 DUP10 1492 90 SWAP1 1493 88 DUP9 1494 90 SWAP1 1495 88 DUP9 1496 90 SWAP1 1497 60 PUSH1 0x04 1499 01 ADD 149A 61 PUSH2 0x1b9d 149D 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @1476 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @1479 stack[0] = 0x00 // @1484 stack[1] = stack[-3] & (0x01 << 0xa0) - 0x01 // @148A stack[2] = 0x150b7a02 // @148E stack[3] = 0x149e // @1490 stack[4] = msg.sender // @1492 stack[5] = stack[-4] // @1494 stack[6] = stack[-2] // @1496 stack[7] = stack[-1] // @1499 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1b9d, returns to 0x149E label_149E: // Incoming return from call to 0x1B9D at 0x149D // Inputs[6] // { // @14A3 memory[0x40:0x60] // @14A5 stack[-1] // @14AA stack[-3] // @14AB msg.gas // @14AC address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @14AC memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 149E 5B JUMPDEST 149F 60 PUSH1 0x20 14A1 60 PUSH1 0x40 14A3 51 MLOAD 14A4 80 DUP1 14A5 83 DUP4 14A6 03 SUB 14A7 81 DUP2 14A8 60 PUSH1 0x00 14AA 87 DUP8 14AB 5A GAS 14AC F1 CALL 14AD 92 SWAP3 14AE 50 POP 14AF 50 POP 14B0 50 POP 14B1 80 DUP1 14B2 15 ISZERO 14B3 61 PUSH2 0x14d9 14B6 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @14AC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @14AD stack[-3] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x14d9, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) label_14B7: // Incoming jump from 0x14B6, if not !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[2] // { // @14BB memory[0x40:0x60] // @14BE returndata.length // } 14B7 50 POP 14B8 60 PUSH1 0x40 14BA 80 DUP1 14BB 51 MLOAD 14BC 60 PUSH1 0x1f 14BE 3D RETURNDATASIZE 14BF 90 SWAP1 14C0 81 DUP2 14C1 01 ADD 14C2 60 PUSH1 0x1f 14C4 19 NOT 14C5 16 AND 14C6 82 DUP3 14C7 01 ADD 14C8 90 SWAP1 14C9 92 SWAP3 14CA 52 MSTORE 14CB 61 PUSH2 0x14d6 14CE 91 SWAP2 14CF 81 DUP2 14D0 01 ADD 14D1 90 SWAP1 14D2 61 PUSH2 0x1bda 14D5 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @14CA memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @14CE stack[-1] = 0x14d6 // @14D1 stack[1] = memory[0x40:0x60] // @14D1 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x1bda 14D6 5B JUMPDEST 14D7 60 PUSH1 0x01 label_14D9: // Incoming jump from 0x14B6, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[1] { @14DD stack[-1] } 14D9 5B JUMPDEST 14DA 61 PUSH2 0x1537 14DD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1537, if stack[-1] label_14DE: // Incoming jump from 0x14DD, if not stack[-1] // Inputs[1] { @14DE returndata.length } 14DE 3D RETURNDATASIZE 14DF 80 DUP1 14E0 80 DUP1 14E1 15 ISZERO 14E2 61 PUSH2 0x1507 14E5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @14DE stack[0] = returndata.length // @14DF stack[1] = returndata.length // } // Block ends with conditional jump to 0x1507, if !returndata.length label_14E6: // Incoming jump from 0x14E5, if not !returndata.length // Inputs[6] // { // @14E8 memory[0x40:0x60] // @14E9 stack[-2] // @14F0 returndata.length // @14F8 returndata.length // @14FB returndata.length // @1502 returndata[0x00:0x00 + returndata.length] // } 14E6 60 PUSH1 0x40 14E8 51 MLOAD 14E9 91 SWAP2 14EA 50 POP 14EB 60 PUSH1 0x1f 14ED 19 NOT 14EE 60 PUSH1 0x3f 14F0 3D RETURNDATASIZE 14F1 01 ADD 14F2 16 AND 14F3 82 DUP3 14F4 01 ADD 14F5 60 PUSH1 0x40 14F7 52 MSTORE 14F8 3D RETURNDATASIZE 14F9 82 DUP3 14FA 52 MSTORE 14FB 3D RETURNDATASIZE 14FC 60 PUSH1 0x00 14FE 60 PUSH1 0x20 1500 84 DUP5 1501 01 ADD 1502 3E RETURNDATACOPY 1503 61 PUSH2 0x150c 1506 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @14E9 stack[-2] = memory[0x40:0x60] // @14F7 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @14FA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1502 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x150c label_1507: // Incoming jump from 0x14E5, if !returndata.length // Inputs[2] // { // @150A stack[-2] // @150F memory[0x60:0x80] // } 1507 5B JUMPDEST 1508 60 PUSH1 0x60 150A 91 SWAP2 150B 50 POP 150C 5B JUMPDEST 150D 50 POP 150E 80 DUP1 150F 51 MLOAD 1510 60 PUSH1 0x00 1512 03 SUB 1513 61 PUSH2 0x152f 1516 57 *JUMPI // Stack delta = -1 // Outputs[1] { @150A stack[-2] = 0x60 } // Block ends with conditional jump to 0x152f, if 0x00 - memory[0x60:0x80] label_1517: // Incoming jump from 0x1516, if not 0x00 - memory[0x60:0x80] // Incoming jump from 0x1516, if not 0x00 - memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @1519 memory[0x40:0x60] // @1529 memory[0x40:0x60] // @152E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1517 60 PUSH1 0x40 1519 51 MLOAD 151A 63 PUSH4 0x68d2bf6b 151F 60 PUSH1 0xe1 1521 1B SHL 1522 81 DUP2 1523 52 MSTORE 1524 60 PUSH1 0x04 1526 01 ADD 1527 60 PUSH1 0x40 1529 51 MLOAD 152A 80 DUP1 152B 91 SWAP2 152C 03 SUB 152D 90 SWAP1 152E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1523 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x68d2bf6b << 0xe1 // @152E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_152F: // Incoming jump from 0x1516, if 0x00 - memory[0x60:0x80] // Incoming jump from 0x1516, if 0x00 - memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @1530 stack[-1] // @1531 memory[stack[-1]:stack[-1] + 0x20] // @1536 memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 152F 5B JUMPDEST 1530 80 DUP1 1531 51 MLOAD 1532 81 DUP2 1533 60 PUSH1 0x20 1535 01 ADD 1536 FD *REVERT // Stack delta = +0 // Outputs[1] { @1536 revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_1537: // Incoming jump from 0x14DD, if stack[-1] // Inputs[2] // { // @1541 stack[-1] // @154B stack[-2] // } 1537 5B JUMPDEST 1538 60 PUSH1 0x01 153A 60 PUSH1 0x01 153C 60 PUSH1 0xe0 153E 1B SHL 153F 03 SUB 1540 19 NOT 1541 16 AND 1542 63 PUSH4 0x0a85bd01 1547 60 PUSH1 0xe1 1549 1B SHL 154A 14 EQ 154B 90 SWAP1 154C 50 POP // Stack delta = -1 // Outputs[1] { @154B stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block continues label_154D: // Incoming return from call to 0x1786 at 0x1826 // Incoming jump from 0x154C // Inputs[3] // { // @154E stack[-6] // @154E stack[-1] // @154F stack[-5] // } 154D 5B JUMPDEST 154E 94 SWAP5 154F 93 SWAP4 1550 50 POP 1551 50 POP 1552 50 POP 1553 50 POP 1554 56 *JUMP // Stack delta = -5 // Outputs[1] { @154E stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1555: // Incoming jump from 0x0CEA // Inputs[1] { @155B storage[0x0a] } 1555 5B JUMPDEST 1556 60 PUSH1 0x60 1558 60 PUSH1 0x0a 155A 80 DUP1 155B 54 SLOAD 155C 61 PUSH2 0x06de 155F 90 SWAP1 1560 61 PUSH2 0x19d4 1563 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1556 stack[0] = 0x60 // @1558 stack[1] = 0x0a // @155F stack[2] = 0x06de // @155F stack[3] = storage[0x0a] // } // Block ends with call to 0x19d4, returns to 0x06DE 1564 5B JUMPDEST 1565 60 PUSH1 0x60 1567 60 PUSH1 0xa0 1569 60 PUSH1 0x40 156B 51 MLOAD 156C 01 ADD 156D 80 DUP1 156E 60 PUSH1 0x40 1570 52 MSTORE 1571 60 PUSH1 0x20 1573 81 DUP2 1574 03 SUB 1575 91 SWAP2 1576 50 POP 1577 50 POP 1578 60 PUSH1 0x00 157A 81 DUP2 157B 52 MSTORE 157C 80 DUP1 157D 82 DUP3 157E 5B JUMPDEST 157F 60 PUSH1 0x01 1581 83 DUP4 1582 03 SUB 1583 92 SWAP3 1584 50 POP 1585 60 PUSH1 0x0a 1587 81 DUP2 1588 06 MOD 1589 60 PUSH1 0x30 158B 01 ADD 158C 83 DUP4 158D 53 MSTORE8 158E 60 PUSH1 0x0a 1590 90 SWAP1 1591 04 DIV 1592 80 DUP1 1593 61 PUSH2 0x157e 1596 57 *JUMPI 1597 50 POP 1598 81 DUP2 1599 90 SWAP1 159A 03 SUB 159B 60 PUSH1 0x1f 159D 19 NOT 159E 90 SWAP1 159F 91 SWAP2 15A0 01 ADD 15A1 90 SWAP1 15A2 81 DUP2 15A3 52 MSTORE 15A4 91 SWAP2 15A5 90 SWAP1 15A6 50 POP 15A7 56 *JUMP label_15A8: // Incoming call from 0x11A9, returns to 0x11AA // Inputs[1] { @15AB storage[0x08] } 15A8 5B JUMPDEST 15A9 60 PUSH1 0x08 15AB 54 SLOAD 15AC 60 PUSH1 0xff 15AE 16 AND 15AF 61 PUSH2 0x07f9 15B2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07f9, if 0xff & storage[0x08] label_15B3: // Incoming jump from 0x15B2, if not 0xff & storage[0x08] // Inputs[1] { @15B5 memory[0x40:0x60] } 15B3 60 PUSH1 0x40 15B5 51 MLOAD 15B6 62 PUSH3 0x461bcd 15BA 60 PUSH1 0xe5 15BC 1B SHL 15BD 81 DUP2 15BE 52 MSTORE 15BF 60 PUSH1 0x20 15C1 60 PUSH1 0x04 15C3 82 DUP3 15C4 01 ADD 15C5 52 MSTORE 15C6 60 PUSH1 0x14 15C8 60 PUSH1 0x24 15CA 82 DUP3 15CB 01 ADD 15CC 52 MSTORE 15CD 73 PUSH20 0x14185d5cd8589b194e881b9bdd081c185d5cd959 15E2 60 PUSH1 0x62 15E4 1B SHL 15E5 60 PUSH1 0x44 15E7 82 DUP3 15E8 01 ADD 15E9 52 MSTORE 15EA 60 PUSH1 0x64 15EC 01 ADD 15ED 61 PUSH2 0x0852 15F0 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @15BE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @15C5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @15CC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @15E9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x14185d5cd8589b194e881b9bdd081c185d5cd959 << 0x62 // @15EC stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0852 label_15F1: // Incoming call from 0x1623, returns to 0x0D36 // Incoming call from 0x1BF6, returns to 0x0D36 // Inputs[1] { @15FB stack[-1] } 15F1 5B JUMPDEST 15F2 60 PUSH1 0x01 15F4 60 PUSH1 0x01 15F6 60 PUSH1 0xe0 15F8 1B SHL 15F9 03 SUB 15FA 19 NOT 15FB 81 DUP2 15FC 16 AND 15FD 81 DUP2 15FE 14 EQ 15FF 61 PUSH2 0x0be9 1602 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0be9, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1603: // Incoming jump from 0x1602, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1606 memory[0x00:0x00] } 1603 60 PUSH1 0x00 1605 80 DUP1 1606 FD *REVERT // Stack delta = +0 // Outputs[1] { @1606 revert(memory[0x00:0x00]); } // Block terminates label_1607: // Incoming call from 0x0239, returns to 0x023A // Inputs[2] // { // @160C stack[-1] // @160D stack[-2] // } 1607 5B JUMPDEST 1608 60 PUSH1 0x00 160A 60 PUSH1 0x20 160C 82 DUP3 160D 84 DUP5 160E 03 SUB 160F 12 SLT 1610 15 ISZERO 1611 61 PUSH2 0x1619 1614 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1608 stack[0] = 0x00 } // Block ends with conditional jump to 0x1619, if !(stack[-2] - stack[-1] i< 0x20) label_1615: // Incoming jump from 0x1614, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1618 memory[0x00:0x00] } 1615 60 PUSH1 0x00 1617 80 DUP1 1618 FD *REVERT // Stack delta = +0 // Outputs[1] { @1618 revert(memory[0x00:0x00]); } // Block terminates label_1619: // Incoming jump from 0x1614, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @161A stack[-2] // @161B msg.data[stack[-2]:stack[-2] + 0x20] // } 1619 5B JUMPDEST 161A 81 DUP2 161B 35 CALLDATALOAD 161C 61 PUSH2 0x0d36 161F 81 DUP2 1620 61 PUSH2 0x15f1 1623 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @161B stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @161C stack[1] = 0x0d36 // @161F stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x15f1, returns to 0x0D36 label_1624: // Incoming call from 0x165F, returns to 0x1660 // Inputs[1] { @1628 stack[-3] } 1624 5B JUMPDEST 1625 60 PUSH1 0x00 1627 5B JUMPDEST 1628 83 DUP4 1629 81 DUP2 162A 10 LT 162B 15 ISZERO 162C 61 PUSH2 0x163f 162F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1625 stack[0] = 0x00 } // Block ends with conditional jump to 0x163f, if !(0x00 < stack[-3]) label_1630: // Incoming jump from 0x162F, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x162F, if not !(0x00 < stack[-3]) // Inputs[4] // { // @1630 stack[-2] // @1631 stack[-1] // @1633 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1634 stack[-3] // } 1630 81 DUP2 1631 81 DUP2 1632 01 ADD 1633 51 MLOAD 1634 83 DUP4 1635 82 DUP3 1636 01 ADD 1637 52 MSTORE 1638 60 PUSH1 0x20 163A 01 ADD 163B 61 PUSH2 0x1627 163E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1637 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @163A stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1627 label_163F: // Incoming jump from 0x162F, if !(stack[-1] < stack[-4]) // Incoming jump from 0x162F, if !(0x00 < stack[-3]) // Inputs[3] // { // @1644 stack[-4] // @1645 stack[-3] // @1647 stack[-5] // } 163F 5B JUMPDEST 1640 50 POP 1641 50 POP 1642 60 PUSH1 0x00 1644 91 SWAP2 1645 01 ADD 1646 52 MSTORE 1647 56 *JUMP // Stack delta = -5 // Outputs[1] { @1646 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_1648: // Incoming call from 0x1686, returns to 0x0D36 // Incoming call from 0x1BCF, returns to 0x1BD0 // Inputs[3] // { // @164B stack[-1] // @164C memory[stack[-1]:stack[-1] + 0x20] // @164E stack[-2] // } 1648 5B JUMPDEST 1649 60 PUSH1 0x00 164B 81 DUP2 164C 51 MLOAD 164D 80 DUP1 164E 84 DUP5 164F 52 MSTORE 1650 61 PUSH2 0x1660 1653 81 DUP2 1654 60 PUSH1 0x20 1656 86 DUP7 1657 01 ADD 1658 60 PUSH1 0x20 165A 86 DUP7 165B 01 ADD 165C 61 PUSH2 0x1624 165F 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1649 stack[0] = 0x00 // @164C stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @164F memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1650 stack[2] = 0x1660 // @1653 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @1657 stack[4] = stack[-2] + 0x20 // @165B stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x1624, returns to 0x1660 label_1660: // Incoming return from call to 0x1624 at 0x165F // Inputs[4] // { // @1663 stack[-1] // @1668 stack[-4] // @1669 stack[-2] // @166F stack[-5] // } 1660 5B JUMPDEST 1661 60 PUSH1 0x1f 1663 01 ADD 1664 60 PUSH1 0x1f 1666 19 NOT 1667 16 AND 1668 92 SWAP3 1669 90 SWAP1 166A 92 SWAP3 166B 01 ADD 166C 60 PUSH1 0x20 166E 01 ADD 166F 92 SWAP3 1670 91 SWAP2 1671 50 POP 1672 50 POP 1673 56 *JUMP // Stack delta = -4 // Outputs[1] { @166F stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_1674: // Incoming jump from 0x0275 // Inputs[2] // { // @1677 stack[-1] // @1682 stack[-2] // } 1674 5B JUMPDEST 1675 60 PUSH1 0x20 1677 81 DUP2 1678 52 MSTORE 1679 60 PUSH1 0x00 167B 61 PUSH2 0x0d36 167E 60 PUSH1 0x20 1680 83 DUP4 1681 01 ADD 1682 84 DUP5 1683 61 PUSH2 0x1648 1686 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1678 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1679 stack[0] = 0x00 // @167B stack[1] = 0x0d36 // @1681 stack[2] = stack[-1] + 0x20 // @1682 stack[3] = stack[-2] // } // Block ends with call to 0x1648, returns to 0x0D36 label_1687: // Incoming call from 0x0437, returns to 0x0438 // Incoming call from 0x0290, returns to 0x0291 // Incoming call from 0x050E, returns to 0x050F // Incoming call from 0x058D, returns to 0x058E // Incoming call from 0x03E2, returns to 0x03E3 // Incoming call from 0x0402, returns to 0x0403 // Incoming call from 0x0677, returns to 0x0678 // Inputs[2] // { // @168C stack[-1] // @168D stack[-2] // } 1687 5B JUMPDEST 1688 60 PUSH1 0x00 168A 60 PUSH1 0x20 168C 82 DUP3 168D 84 DUP5 168E 03 SUB 168F 12 SLT 1690 15 ISZERO 1691 61 PUSH2 0x1699 1694 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1688 stack[0] = 0x00 } // Block ends with conditional jump to 0x1699, if !(stack[-2] - stack[-1] i< 0x20) label_1695: // Incoming jump from 0x1694, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1698 memory[0x00:0x00] } 1695 60 PUSH1 0x00 1697 80 DUP1 1698 FD *REVERT // Stack delta = +0 // Outputs[1] { @1698 revert(memory[0x00:0x00]); } // Block terminates label_1699: // Incoming jump from 0x1694, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @169B msg.data[stack[-2]:stack[-2] + 0x20] // @169B stack[-2] // @169C stack[-4] // @169D stack[-3] // } 1699 5B JUMPDEST 169A 50 POP 169B 35 CALLDATALOAD 169C 91 SWAP2 169D 90 SWAP1 169E 50 POP 169F 56 *JUMP // Stack delta = -3 // Outputs[1] { @169C stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_16A0: // Incoming call from 0x188E, returns to 0x188F // Incoming call from 0x1700, returns to 0x1701 // Incoming call from 0x1985, returns to 0x1986 // Incoming call from 0x1710, returns to 0x1711 // Incoming call from 0x19D3, returns to 0x1863 // Incoming call from 0x173E, returns to 0x0D36 // Incoming call from 0x19C3, returns to 0x19C4 // Incoming call from 0x1852, returns to 0x1853 // Incoming call from 0x189E, returns to 0x189F // Incoming call from 0x16D2, returns to 0x16D3 // Inputs[1] { @16A9 stack[-1] } 16A0 5B JUMPDEST 16A1 60 PUSH1 0x01 16A3 60 PUSH1 0x01 16A5 60 PUSH1 0xa0 16A7 1B SHL 16A8 03 SUB 16A9 81 DUP2 16AA 16 AND 16AB 81 DUP2 16AC 14 EQ 16AD 61 PUSH2 0x0be9 16B0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0be9, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 label_16B1: // Incoming jump from 0x16B0, if not stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @16B4 memory[0x00:0x00] } 16B1 60 PUSH1 0x00 16B3 80 DUP1 16B4 FD *REVERT // Stack delta = +0 // Outputs[1] { @16B4 revert(memory[0x00:0x00]); } // Block terminates label_16B5: // Incoming call from 0x02BB, returns to 0x02BC // Incoming call from 0x0335, returns to 0x0336 // Inputs[2] // { // @16BB stack[-1] // @16BC stack[-2] // } 16B5 5B JUMPDEST 16B6 60 PUSH1 0x00 16B8 80 DUP1 16B9 60 PUSH1 0x40 16BB 83 DUP4 16BC 85 DUP6 16BD 03 SUB 16BE 12 SLT 16BF 15 ISZERO 16C0 61 PUSH2 0x16c8 16C3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @16B6 stack[0] = 0x00 // @16B8 stack[1] = 0x00 // } // Block ends with conditional jump to 0x16c8, if !(stack[-2] - stack[-1] i< 0x40) label_16C4: // Incoming jump from 0x16C3, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @16C7 memory[0x00:0x00] } 16C4 60 PUSH1 0x00 16C6 80 DUP1 16C7 FD *REVERT // Stack delta = +0 // Outputs[1] { @16C7 revert(memory[0x00:0x00]); } // Block terminates label_16C8: // Incoming jump from 0x16C3, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @16C9 stack[-3] // @16CA msg.data[stack[-3]:stack[-3] + 0x20] // } 16C8 5B JUMPDEST 16C9 82 DUP3 16CA 35 CALLDATALOAD 16CB 61 PUSH2 0x16d3 16CE 81 DUP2 16CF 61 PUSH2 0x16a0 16D2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @16CA stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @16CB stack[1] = 0x16d3 // @16CE stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x16a0, returns to 0x16D3 label_16D3: // Incoming return from call to 0x16A0 at 0x16D2 // Inputs[5] // { // @16D4 stack[-1] // @16D4 stack[-6] // @16D7 stack[-4] // @16DB msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @16DC stack[-5] // } 16D3 5B JUMPDEST 16D4 94 SWAP5 16D5 60 PUSH1 0x20 16D7 93 SWAP4 16D8 90 SWAP1 16D9 93 SWAP4 16DA 01 ADD 16DB 35 CALLDATALOAD 16DC 93 SWAP4 16DD 50 POP 16DE 50 POP 16DF 50 POP 16E0 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @16D4 stack[-6] = stack[-1] // @16DC stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_16E1: // Incoming call from 0x036A, returns to 0x036B // Incoming call from 0x02F7, returns to 0x02F8 // Inputs[2] // { // @16E9 stack[-1] // @16EA stack[-2] // } 16E1 5B JUMPDEST 16E2 60 PUSH1 0x00 16E4 80 DUP1 16E5 60 PUSH1 0x00 16E7 60 PUSH1 0x60 16E9 84 DUP5 16EA 86 DUP7 16EB 03 SUB 16EC 12 SLT 16ED 15 ISZERO 16EE 61 PUSH2 0x16f6 16F1 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @16E2 stack[0] = 0x00 // @16E4 stack[1] = 0x00 // @16E5 stack[2] = 0x00 // } // Block ends with conditional jump to 0x16f6, if !(stack[-2] - stack[-1] i< 0x60) label_16F2: // Incoming jump from 0x16F1, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @16F5 memory[0x00:0x00] } 16F2 60 PUSH1 0x00 16F4 80 DUP1 16F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @16F5 revert(memory[0x00:0x00]); } // Block terminates label_16F6: // Incoming jump from 0x16F1, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @16F7 stack[-4] // @16F8 msg.data[stack[-4]:stack[-4] + 0x20] // } 16F6 5B JUMPDEST 16F7 83 DUP4 16F8 35 CALLDATALOAD 16F9 61 PUSH2 0x1701 16FC 81 DUP2 16FD 61 PUSH2 0x16a0 1700 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @16F8 stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @16F9 stack[1] = 0x1701 // @16FC stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x16a0, returns to 0x1701 label_1701: // Incoming return from call to 0x16A0 at 0x1700 // Inputs[4] // { // @1702 stack[-1] // @1702 stack[-4] // @1706 stack[-5] // @1708 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 1701 5B JUMPDEST 1702 92 SWAP3 1703 50 POP 1704 60 PUSH1 0x20 1706 84 DUP5 1707 01 ADD 1708 35 CALLDATALOAD 1709 61 PUSH2 0x1711 170C 81 DUP2 170D 61 PUSH2 0x16a0 1710 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1702 stack[-4] = stack[-1] // @1708 stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @1709 stack[0] = 0x1711 // @170C stack[1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with call to 0x16a0, returns to 0x1711 label_1711: // Incoming return from call to 0x16A0 at 0x1710 // Inputs[6] // { // @1712 stack[-4] // @1712 stack[-1] // @1713 stack[-7] // @1715 stack[-6] // @171B stack[-5] // @171F msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } 1711 5B JUMPDEST 1712 92 SWAP3 1713 95 SWAP6 1714 92 SWAP3 1715 94 SWAP5 1716 50 POP 1717 50 POP 1718 50 POP 1719 60 PUSH1 0x40 171B 91 SWAP2 171C 90 SWAP1 171D 91 SWAP2 171E 01 ADD 171F 35 CALLDATALOAD 1720 90 SWAP1 1721 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1713 stack[-7] = stack[-4] // @1715 stack[-6] = stack[-1] // @1720 stack[-5] = msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } // Block ends with unconditional jump to stack[-7] label_1722: // Incoming call from 0x0457, returns to 0x0458 // Incoming call from 0x038A, returns to 0x038B // Incoming call from 0x062A, returns to 0x062B // Incoming call from 0x0657, returns to 0x0658 // Inputs[2] // { // @1727 stack[-1] // @1728 stack[-2] // } 1722 5B JUMPDEST 1723 60 PUSH1 0x00 1725 60 PUSH1 0x20 1727 82 DUP3 1728 84 DUP5 1729 03 SUB 172A 12 SLT 172B 15 ISZERO 172C 61 PUSH2 0x1734 172F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1723 stack[0] = 0x00 } // Block ends with conditional jump to 0x1734, if !(stack[-2] - stack[-1] i< 0x20) label_1730: // Incoming jump from 0x172F, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1733 memory[0x00:0x00] } 1730 60 PUSH1 0x00 1732 80 DUP1 1733 FD *REVERT // Stack delta = +0 // Outputs[1] { @1733 revert(memory[0x00:0x00]); } // Block terminates label_1734: // Incoming jump from 0x172F, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1735 stack[-2] // @1736 msg.data[stack[-2]:stack[-2] + 0x20] // } 1734 5B JUMPDEST 1735 81 DUP2 1736 35 CALLDATALOAD 1737 61 PUSH2 0x0d36 173A 81 DUP2 173B 61 PUSH2 0x16a0 173E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1736 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1737 stack[1] = 0x0d36 // @173A stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x16a0, returns to 0x0D36 label_173F: // Incoming jump from 0x177D // Incoming jump from 0x1A6D // Incoming jump from 0x1940 // Incoming jump from 0x179F // Inputs[1] { @1754 memory[0x00:0x24] } 173F 5B JUMPDEST 1740 63 PUSH4 0x4e487b71 1745 60 PUSH1 0xe0 1747 1B SHL 1748 60 PUSH1 0x00 174A 52 MSTORE 174B 60 PUSH1 0x41 174D 60 PUSH1 0x04 174F 52 MSTORE 1750 60 PUSH1 0x24 1752 60 PUSH1 0x00 1754 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @174A memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @174F memory[0x04:0x24] = 0x41 // @1754 revert(memory[0x00:0x24]); // } // Block terminates label_1755: // Incoming call from 0x1951, returns to 0x1952 // Incoming call from 0x17B2, returns to 0x17B3 // Inputs[2] // { // @1758 memory[0x40:0x60] // @175B stack[-1] // } 1755 5B JUMPDEST 1756 60 PUSH1 0x40 1758 51 MLOAD 1759 60 PUSH1 0x1f 175B 82 DUP3 175C 01 ADD 175D 60 PUSH1 0x1f 175F 19 NOT 1760 16 AND 1761 81 DUP2 1762 01 ADD 1763 67 PUSH8 0xffffffffffffffff 176C 81 DUP2 176D 11 GT 176E 82 DUP3 176F 82 DUP3 1770 10 LT 1771 17 OR 1772 15 ISZERO 1773 61 PUSH2 0x177e 1776 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1758 stack[0] = memory[0x40:0x60] // @1762 stack[1] = memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) // } // Block ends with conditional jump to 0x177e, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) label_1777: // Incoming jump from 0x1776, if not !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) 1777 61 PUSH2 0x177e 177A 61 PUSH2 0x173f 177D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1777 stack[0] = 0x177e } // Block ends with unconditional jump to 0x173f label_177E: // Incoming jump from 0x1776, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) // Inputs[4] // { // @1781 stack[-1] // @1782 stack[-2] // @1782 stack[-4] // @1783 stack[-3] // } 177E 5B JUMPDEST 177F 60 PUSH1 0x40 1781 52 MSTORE 1782 91 SWAP2 1783 90 SWAP1 1784 50 POP 1785 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1781 memory[0x40:0x60] = stack[-1] // @1782 stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_1786: // Incoming call from 0x1826, returns to 0x154D // Incoming call from 0x18E1, returns to 0x18E2 // Inputs[1] { @1792 stack[-2] } 1786 5B JUMPDEST 1787 60 PUSH1 0x00 1789 67 PUSH8 0xffffffffffffffff 1792 83 DUP4 1793 11 GT 1794 15 ISZERO 1795 61 PUSH2 0x17a0 1798 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1787 stack[0] = 0x00 } // Block ends with conditional jump to 0x17a0, if !(stack[-2] > 0xffffffffffffffff) label_1799: // Incoming jump from 0x1798, if not !(stack[-2] > 0xffffffffffffffff) 1799 61 PUSH2 0x17a0 179C 61 PUSH2 0x173f 179F 56 *JUMP // Stack delta = +1 // Outputs[1] { @1799 stack[0] = 0x17a0 } // Block ends with unconditional jump to 0x173f label_17A0: // Incoming jump from 0x1798, if !(stack[-2] > 0xffffffffffffffff) // Inputs[1] { @17A6 stack[-3] } 17A0 5B JUMPDEST 17A1 61 PUSH2 0x17b3 17A4 60 PUSH1 0x1f 17A6 84 DUP5 17A7 01 ADD 17A8 60 PUSH1 0x1f 17AA 19 NOT 17AB 16 AND 17AC 60 PUSH1 0x20 17AE 01 ADD 17AF 61 PUSH2 0x1755 17B2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @17A1 stack[0] = 0x17b3 // @17AE stack[1] = 0x20 + (~0x1f & stack[-3] + 0x1f) // } // Block ends with call to 0x1755, returns to 0x17B3 label_17B3: // Incoming return from call to 0x1755 at 0x17B2 // Inputs[5] // { // @17B4 stack[-1] // @17B4 stack[-2] // @17B6 stack[-4] // @17B9 stack[-5] // @17BB stack[-3] // } 17B3 5B JUMPDEST 17B4 90 SWAP1 17B5 50 POP 17B6 82 DUP3 17B7 81 DUP2 17B8 52 MSTORE 17B9 83 DUP4 17BA 83 DUP4 17BB 83 DUP4 17BC 01 ADD 17BD 11 GT 17BE 15 ISZERO 17BF 61 PUSH2 0x17c7 17C2 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @17B4 stack[-2] = stack[-1] // @17B8 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // } // Block ends with conditional jump to 0x17c7, if !(stack[-3] + stack[-4] > stack[-5]) label_17C3: // Incoming jump from 0x17C2, if not !(stack[-3] + stack[-4] > stack[-5]) // Inputs[1] { @17C6 memory[0x00:0x00] } 17C3 60 PUSH1 0x00 17C5 80 DUP1 17C6 FD *REVERT // Stack delta = +0 // Outputs[1] { @17C6 revert(memory[0x00:0x00]); } // Block terminates label_17C7: // Incoming jump from 0x17C2, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[6] // { // @17C8 stack[-3] // @17C9 stack[-2] // @17CC stack[-1] // @17CE msg.data[stack[-2]:stack[-2] + stack[-3]] // @17D8 stack[-5] // @17D9 stack[-4] // } 17C7 5B JUMPDEST 17C8 82 DUP3 17C9 82 DUP3 17CA 60 PUSH1 0x20 17CC 83 DUP4 17CD 01 ADD 17CE 37 CALLDATACOPY 17CF 60 PUSH1 0x00 17D1 60 PUSH1 0x20 17D3 84 DUP5 17D4 83 DUP4 17D5 01 ADD 17D6 01 ADD 17D7 52 MSTORE 17D8 93 SWAP4 17D9 92 SWAP3 17DA 50 POP 17DB 50 POP 17DC 50 POP 17DD 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @17CE memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-3]] = msg.data[stack[-2]:stack[-2] + stack[-3]] // @17D7 memory[stack[-1] + stack[-3] + 0x20:stack[-1] + stack[-3] + 0x20 + 0x20] = 0x00 // @17D8 stack[-5] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_17DE: // Incoming call from 0x03AA, returns to 0x03AB // Inputs[2] // { // @17E3 stack[-1] // @17E4 stack[-2] // } 17DE 5B JUMPDEST 17DF 60 PUSH1 0x00 17E1 60 PUSH1 0x20 17E3 82 DUP3 17E4 84 DUP5 17E5 03 SUB 17E6 12 SLT 17E7 15 ISZERO 17E8 61 PUSH2 0x17f0 17EB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @17DF stack[0] = 0x00 } // Block ends with conditional jump to 0x17f0, if !(stack[-2] - stack[-1] i< 0x20) label_17EC: // Incoming jump from 0x17EB, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @17EF memory[0x00:0x00] } 17EC 60 PUSH1 0x00 17EE 80 DUP1 17EF FD *REVERT // Stack delta = +0 // Outputs[1] { @17EF revert(memory[0x00:0x00]); } // Block terminates label_17F0: // Incoming jump from 0x17EB, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @17F1 stack[-2] // @17F2 msg.data[stack[-2]:stack[-2] + 0x20] // } 17F0 5B JUMPDEST 17F1 81 DUP2 17F2 35 CALLDATALOAD 17F3 67 PUSH8 0xffffffffffffffff 17FC 81 DUP2 17FD 11 GT 17FE 15 ISZERO 17FF 61 PUSH2 0x1807 1802 57 *JUMPI // Stack delta = +1 // Outputs[1] { @17F2 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1807, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1803: // Incoming jump from 0x1802, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1806 memory[0x00:0x00] } 1803 60 PUSH1 0x00 1805 80 DUP1 1806 FD *REVERT // Stack delta = +0 // Outputs[1] { @1806 revert(memory[0x00:0x00]); } // Block terminates label_1807: // Incoming jump from 0x1802, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1808 stack[-3] // @1809 stack[-1] // @180E stack[-4] // } 1807 5B JUMPDEST 1808 82 DUP3 1809 01 ADD 180A 60 PUSH1 0x1f 180C 81 DUP2 180D 01 ADD 180E 84 DUP5 180F 13 SGT 1810 61 PUSH2 0x1818 1813 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1809 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x1818, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_1814: // Incoming jump from 0x1813, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @1817 memory[0x00:0x00] } 1814 60 PUSH1 0x00 1816 80 DUP1 1817 FD *REVERT // Stack delta = +0 // Outputs[1] { @1817 revert(memory[0x00:0x00]); } // Block terminates label_1818: // Incoming jump from 0x1813, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @181C stack[-4] // @181D stack[-1] // @181E msg.data[stack[-1]:stack[-1] + 0x20] // } 1818 5B JUMPDEST 1819 61 PUSH2 0x154d 181C 84 DUP5 181D 82 DUP3 181E 35 CALLDATALOAD 181F 60 PUSH1 0x20 1821 84 DUP5 1822 01 ADD 1823 61 PUSH2 0x1786 1826 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1819 stack[0] = 0x154d // @181C stack[1] = stack[-4] // @181E stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1822 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1786, returns to 0x154D label_1827: // Incoming call from 0x1B9C, returns to 0x0D36 // Incoming call from 0x1862, returns to 0x1863 // Inputs[1] { @1828 stack[-1] } 1827 5B JUMPDEST 1828 80 DUP1 1829 15 ISZERO 182A 15 ISZERO 182B 81 DUP2 182C 14 EQ 182D 61 PUSH2 0x0be9 1830 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0be9, if stack[-1] == !!stack[-1] label_1831: // Incoming jump from 0x1830, if not stack[-1] == !!stack[-1] // Inputs[1] { @1834 memory[0x00:0x00] } 1831 60 PUSH1 0x00 1833 80 DUP1 1834 FD *REVERT // Stack delta = +0 // Outputs[1] { @1834 revert(memory[0x00:0x00]); } // Block terminates label_1835: // Incoming call from 0x04EE, returns to 0x04EF // Inputs[2] // { // @183B stack[-1] // @183C stack[-2] // } 1835 5B JUMPDEST 1836 60 PUSH1 0x00 1838 80 DUP1 1839 60 PUSH1 0x40 183B 83 DUP4 183C 85 DUP6 183D 03 SUB 183E 12 SLT 183F 15 ISZERO 1840 61 PUSH2 0x1848 1843 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1836 stack[0] = 0x00 // @1838 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1848, if !(stack[-2] - stack[-1] i< 0x40) label_1844: // Incoming jump from 0x1843, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1847 memory[0x00:0x00] } 1844 60 PUSH1 0x00 1846 80 DUP1 1847 FD *REVERT // Stack delta = +0 // Outputs[1] { @1847 revert(memory[0x00:0x00]); } // Block terminates label_1848: // Incoming jump from 0x1843, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1849 stack[-3] // @184A msg.data[stack[-3]:stack[-3] + 0x20] // } 1848 5B JUMPDEST 1849 82 DUP3 184A 35 CALLDATALOAD 184B 61 PUSH2 0x1853 184E 81 DUP2 184F 61 PUSH2 0x16a0 1852 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @184A stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @184B stack[1] = 0x1853 // @184E stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x16a0, returns to 0x1853 label_1853: // Incoming return from call to 0x16A0 at 0x1852 // Inputs[4] // { // @1854 stack[-3] // @1854 stack[-1] // @1858 stack[-4] // @185A msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 1853 5B JUMPDEST 1854 91 SWAP2 1855 50 POP 1856 60 PUSH1 0x20 1858 83 DUP4 1859 01 ADD 185A 35 CALLDATALOAD 185B 61 PUSH2 0x1863 185E 81 DUP2 185F 61 PUSH2 0x1827 1862 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1854 stack[-3] = stack[-1] // @185A stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @185B stack[0] = 0x1863 // @185E stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x1827, returns to 0x1863 label_1863: // Incoming return from call to 0x16A0 at 0x19D3 // Incoming return from call to 0x1827 at 0x1862 // Inputs[6] // { // @1864 stack[-1] // @1865 stack[-2] // @1868 stack[-5] // @186A stack[-6] // @186A stack[-3] // @186B stack[-4] // } 1863 5B JUMPDEST 1864 80 DUP1 1865 91 SWAP2 1866 50 POP 1867 50 POP 1868 92 SWAP3 1869 50 POP 186A 92 SWAP3 186B 90 SWAP1 186C 50 POP 186D 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1868 stack[-5] = stack[-1] // @186A stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_186E: // Incoming call from 0x0537, returns to 0x0538 // Inputs[2] // { // @1877 stack[-1] // @1878 stack[-2] // } 186E 5B JUMPDEST 186F 60 PUSH1 0x00 1871 80 DUP1 1872 60 PUSH1 0x00 1874 80 DUP1 1875 60 PUSH1 0x80 1877 85 DUP6 1878 87 DUP8 1879 03 SUB 187A 12 SLT 187B 15 ISZERO 187C 61 PUSH2 0x1884 187F 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @186F stack[0] = 0x00 // @1871 stack[1] = 0x00 // @1872 stack[2] = 0x00 // @1874 stack[3] = 0x00 // } // Block ends with conditional jump to 0x1884, if !(stack[-2] - stack[-1] i< 0x80) label_1880: // Incoming jump from 0x187F, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1883 memory[0x00:0x00] } 1880 60 PUSH1 0x00 1882 80 DUP1 1883 FD *REVERT // Stack delta = +0 // Outputs[1] { @1883 revert(memory[0x00:0x00]); } // Block terminates label_1884: // Incoming jump from 0x187F, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @1885 stack[-5] // @1886 msg.data[stack[-5]:stack[-5] + 0x20] // } 1884 5B JUMPDEST 1885 84 DUP5 1886 35 CALLDATALOAD 1887 61 PUSH2 0x188f 188A 81 DUP2 188B 61 PUSH2 0x16a0 188E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1886 stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] // @1887 stack[1] = 0x188f // @188A stack[2] = msg.data[stack[-5]:stack[-5] + 0x20] // } // Block ends with call to 0x16a0, returns to 0x188F label_188F: // Incoming return from call to 0x16A0 at 0x188E // Inputs[4] // { // @1890 stack[-1] // @1890 stack[-5] // @1894 stack[-6] // @1896 msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } 188F 5B JUMPDEST 1890 93 SWAP4 1891 50 POP 1892 60 PUSH1 0x20 1894 85 DUP6 1895 01 ADD 1896 35 CALLDATALOAD 1897 61 PUSH2 0x189f 189A 81 DUP2 189B 61 PUSH2 0x16a0 189E 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1890 stack[-5] = stack[-1] // @1896 stack[-1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @1897 stack[0] = 0x189f // @189A stack[1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } // Block ends with call to 0x16a0, returns to 0x189F label_189F: // Incoming return from call to 0x16A0 at 0x189E // Inputs[6] // { // @18A0 stack[-1] // @18A0 stack[-4] // @18A4 stack[-6] // @18A6 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @18A7 stack[-3] // @18AD msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 189F 5B JUMPDEST 18A0 92 SWAP3 18A1 50 POP 18A2 60 PUSH1 0x40 18A4 85 DUP6 18A5 01 ADD 18A6 35 CALLDATALOAD 18A7 91 SWAP2 18A8 50 POP 18A9 60 PUSH1 0x60 18AB 85 DUP6 18AC 01 ADD 18AD 35 CALLDATALOAD 18AE 67 PUSH8 0xffffffffffffffff 18B7 81 DUP2 18B8 11 GT 18B9 15 ISZERO 18BA 61 PUSH2 0x18c2 18BD 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @18A0 stack[-4] = stack[-1] // @18A7 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @18AD stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x18c2, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_18BE: // Incoming jump from 0x18BD, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @18C1 memory[0x00:0x00] } 18BE 60 PUSH1 0x00 18C0 80 DUP1 18C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @18C1 revert(memory[0x00:0x00]); } // Block terminates label_18C2: // Incoming jump from 0x18BD, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @18C3 stack[-6] // @18C4 stack[-1] // @18C9 stack[-7] // } 18C2 5B JUMPDEST 18C3 85 DUP6 18C4 01 ADD 18C5 60 PUSH1 0x1f 18C7 81 DUP2 18C8 01 ADD 18C9 87 DUP8 18CA 13 SGT 18CB 61 PUSH2 0x18d3 18CE 57 *JUMPI // Stack delta = +0 // Outputs[1] { @18C4 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x18d3, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_18CF: // Incoming jump from 0x18CE, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @18D2 memory[0x00:0x00] } 18CF 60 PUSH1 0x00 18D1 80 DUP1 18D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @18D2 revert(memory[0x00:0x00]); } // Block terminates label_18D3: // Incoming jump from 0x18CE, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @18D7 stack[-7] // @18D8 stack[-1] // @18D9 msg.data[stack[-1]:stack[-1] + 0x20] // } 18D3 5B JUMPDEST 18D4 61 PUSH2 0x18e2 18D7 87 DUP8 18D8 82 DUP3 18D9 35 CALLDATALOAD 18DA 60 PUSH1 0x20 18DC 84 DUP5 18DD 01 ADD 18DE 61 PUSH2 0x1786 18E1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @18D4 stack[0] = 0x18e2 // @18D7 stack[1] = stack[-7] // @18D9 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @18DD stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1786, returns to 0x18E2 label_18E2: // Incoming return from call to 0x1786 at 0x18E1 // Inputs[8] // { // @18E3 stack[-1] // @18E3 stack[-3] // @18E6 stack[-6] // @18E7 stack[-9] // @18E8 stack[-5] // @18E9 stack[-8] // @18EB stack[-4] // @18EB stack[-7] // } 18E2 5B JUMPDEST 18E3 91 SWAP2 18E4 50 POP 18E5 50 POP 18E6 92 SWAP3 18E7 95 SWAP6 18E8 91 SWAP2 18E9 94 SWAP5 18EA 50 POP 18EB 92 SWAP3 18EC 50 POP 18ED 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @18E6 stack[-6] = stack[-1] // @18E7 stack[-9] = stack[-6] // @18E9 stack[-8] = stack[-5] // @18EB stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_18EE: // Incoming call from 0x056D, returns to 0x056E // Inputs[2] // { // @18F4 stack[-1] // @18F5 stack[-2] // } 18EE 5B JUMPDEST 18EF 60 PUSH1 0x00 18F1 80 DUP1 18F2 60 PUSH1 0x40 18F4 83 DUP4 18F5 85 DUP6 18F6 03 SUB 18F7 12 SLT 18F8 15 ISZERO 18F9 61 PUSH2 0x1901 18FC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @18EF stack[0] = 0x00 // @18F1 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1901, if !(stack[-2] - stack[-1] i< 0x40) label_18FD: // Incoming jump from 0x18FC, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1900 memory[0x00:0x00] } 18FD 60 PUSH1 0x00 18FF 80 DUP1 1900 FD *REVERT // Stack delta = +0 // Outputs[1] { @1900 revert(memory[0x00:0x00]); } // Block terminates label_1901: // Incoming jump from 0x18FC, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1902 stack[-3] // @1903 msg.data[stack[-3]:stack[-3] + 0x20] // } 1901 5B JUMPDEST 1902 82 DUP3 1903 35 CALLDATALOAD 1904 67 PUSH8 0xffffffffffffffff 190D 80 DUP1 190E 82 DUP3 190F 11 GT 1910 15 ISZERO 1911 61 PUSH2 0x1919 1914 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1903 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1904 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1919, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_1915: // Incoming jump from 0x1914, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1918 memory[0x00:0x00] } 1915 60 PUSH1 0x00 1917 80 DUP1 1918 FD *REVERT // Stack delta = +0 // Outputs[1] { @1918 revert(memory[0x00:0x00]); } // Block terminates label_1919: // Incoming jump from 0x1914, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @191A stack[-2] // @191B stack[-5] // @191F stack[-6] // } 1919 5B JUMPDEST 191A 81 DUP2 191B 85 DUP6 191C 01 ADD 191D 91 SWAP2 191E 50 POP 191F 85 DUP6 1920 60 PUSH1 0x1f 1922 83 DUP4 1923 01 ADD 1924 12 SLT 1925 61 PUSH2 0x192d 1928 57 *JUMPI // Stack delta = +0 // Outputs[1] { @191D stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x192d, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_1929: // Incoming jump from 0x1928, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[1] { @192C memory[0x00:0x00] } 1929 60 PUSH1 0x00 192B 80 DUP1 192C FD *REVERT // Stack delta = +0 // Outputs[1] { @192C revert(memory[0x00:0x00]); } // Block terminates label_192D: // Incoming jump from 0x1928, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[3] // { // @192E stack[-2] // @192F msg.data[stack[-2]:stack[-2] + 0x20] // @1932 stack[-1] // } 192D 5B JUMPDEST 192E 81 DUP2 192F 35 CALLDATALOAD 1930 60 PUSH1 0x20 1932 82 DUP3 1933 82 DUP3 1934 11 GT 1935 15 ISZERO 1936 61 PUSH2 0x1941 1939 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @192F stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1930 stack[1] = 0x20 // } // Block ends with conditional jump to 0x1941, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_193A: // Incoming jump from 0x1939, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) 193A 61 PUSH2 0x1941 193D 61 PUSH2 0x173f 1940 56 *JUMP // Stack delta = +1 // Outputs[1] { @193A stack[0] = 0x1941 } // Block ends with unconditional jump to 0x173f label_1941: // Incoming jump from 0x1939, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @1942 stack[-2] // @1946 stack[-3] // @194B stack[-1] // } 1941 5B JUMPDEST 1942 81 DUP2 1943 60 PUSH1 0x05 1945 1B SHL 1946 92 SWAP3 1947 50 POP 1948 61 PUSH2 0x1952 194B 81 DUP2 194C 84 DUP5 194D 01 ADD 194E 61 PUSH2 0x1755 1951 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1946 stack[-3] = stack[-2] << 0x05 // @1948 stack[0] = 0x1952 // @194D stack[1] = (stack[-2] << 0x05) + stack[-1] // } // Block ends with call to 0x1755, returns to 0x1952 label_1952: // Incoming return from call to 0x1755 at 0x1951 // Inputs[6] // { // @1953 stack[-3] // @1954 stack[-1] // @1956 stack[-4] // @1957 stack[-5] // @1959 stack[-2] // @1960 stack[-9] // } 1952 5B JUMPDEST 1953 82 DUP3 1954 81 DUP2 1955 52 MSTORE 1956 92 SWAP3 1957 84 DUP5 1958 01 ADD 1959 81 DUP2 195A 01 ADD 195B 92 SWAP3 195C 81 DUP2 195D 81 DUP2 195E 01 ADD 195F 90 SWAP1 1960 89 DUP10 1961 85 DUP6 1962 11 GT 1963 15 ISZERO 1964 61 PUSH2 0x196c 1967 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1955 memory[stack[-1]:stack[-1] + 0x20] = stack[-3] // @195B stack[-4] = stack[-2] + stack[-5] + stack[-4] // @195F stack[-1] = stack[-1] + stack[-2] // @195F stack[0] = stack[-1] // } // Block ends with conditional jump to 0x196c, if !(stack[-2] + stack[-5] + stack[-4] > stack[-9]) label_1968: // Incoming jump from 0x1967, if not !(stack[-2] + stack[-5] + stack[-4] > stack[-9]) // Inputs[1] { @196B memory[0x00:0x00] } 1968 60 PUSH1 0x00 196A 80 DUP1 196B FD *REVERT // Stack delta = +0 // Outputs[1] { @196B revert(memory[0x00:0x00]); } // Block terminates label_196C: // Incoming jump from 0x1967, if !(stack[-2] + stack[-5] + stack[-4] > stack[-9]) // Inputs[4] // { // @196D stack[-1] // @196D stack[-6] // @196E stack[-3] // @1972 stack[-5] // } 196C 5B JUMPDEST 196D 94 SWAP5 196E 82 DUP3 196F 01 ADD 1970 94 SWAP5 1971 5B JUMPDEST 1972 84 DUP5 1973 86 DUP7 1974 10 LT 1975 15 ISZERO 1976 61 PUSH2 0x1996 1979 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1970 stack[-1] = stack[-1] // @1970 stack[-6] = stack[-3] + stack[-6] // } // Block ends with conditional jump to 0x1996, if !(stack[-3] + stack[-6] < stack[-5]) label_197A: // Incoming jump from 0x1979, if not !(stack[-6] < stack[-5]) // Incoming jump from 0x1979, if not !(stack[-3] + stack[-6] < stack[-5]) // Inputs[3] // { // @197A stack[-6] // @197B msg.data[stack[-6]:stack[-6] + 0x20] // @197C stack[-4] // } 197A 85 DUP6 197B 35 CALLDATALOAD 197C 93 SWAP4 197D 50 POP 197E 61 PUSH2 0x1986 1981 84 DUP5 1982 61 PUSH2 0x16a0 1985 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @197C stack[-4] = msg.data[stack[-6]:stack[-6] + 0x20] // @197E stack[0] = 0x1986 // @1981 stack[1] = msg.data[stack[-6]:stack[-6] + 0x20] // } // Block ends with call to 0x16a0, returns to 0x1986 label_1986: // Incoming return from call to 0x16A0 at 0x1985 // Inputs[5] // { // @1987 stack[-4] // @1988 stack[-2] // @198A stack[-1] // @198A stack[-6] // @198B stack[-3] // } 1986 5B JUMPDEST 1987 83 DUP4 1988 82 DUP3 1989 52 MSTORE 198A 94 SWAP5 198B 82 DUP3 198C 01 ADD 198D 94 SWAP5 198E 90 SWAP1 198F 82 DUP3 1990 01 ADD 1991 90 SWAP1 1992 61 PUSH2 0x1971 1995 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1989 memory[stack[-2]:stack[-2] + 0x20] = stack[-4] // @198D stack[-6] = stack[-3] + stack[-6] // @1991 stack[-2] = stack[-3] + stack[-2] // @1991 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1971 label_1996: // Incoming jump from 0x1979, if !(stack[-6] < stack[-5]) // Incoming jump from 0x1979, if !(stack[-3] + stack[-6] < stack[-5]) // Inputs[7] // { // @1997 stack[-1] // @1997 stack[-11] // @1998 stack[-9] // @1999 stack[-2] // @199A stack[-3] // @199C msg.data[stack[-3] + stack[-9]:stack[-3] + stack[-9] + 0x20] // @199D stack[-10] // } 1996 5B JUMPDEST 1997 99 SWAP10 1998 97 SWAP8 1999 90 SWAP1 199A 91 SWAP2 199B 01 ADD 199C 35 CALLDATALOAD 199D 97 SWAP8 199E 50 POP 199F 50 POP 19A0 50 POP 19A1 50 POP 19A2 50 POP 19A3 50 POP 19A4 50 POP 19A5 56 *JUMP // Stack delta = -9 // Outputs[2] // { // @1997 stack[-11] = stack[-1] // @199D stack[-10] = msg.data[stack[-3] + stack[-9]:stack[-3] + stack[-9] + 0x20] // } // Block ends with unconditional jump to stack[-11] label_19A6: // Incoming call from 0x05E1, returns to 0x05E2 // Inputs[2] // { // @19AC stack[-1] // @19AD stack[-2] // } 19A6 5B JUMPDEST 19A7 60 PUSH1 0x00 19A9 80 DUP1 19AA 60 PUSH1 0x40 19AC 83 DUP4 19AD 85 DUP6 19AE 03 SUB 19AF 12 SLT 19B0 15 ISZERO 19B1 61 PUSH2 0x19b9 19B4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @19A7 stack[0] = 0x00 // @19A9 stack[1] = 0x00 // } // Block ends with conditional jump to 0x19b9, if !(stack[-2] - stack[-1] i< 0x40) label_19B5: // Incoming jump from 0x19B4, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @19B8 memory[0x00:0x00] } 19B5 60 PUSH1 0x00 19B7 80 DUP1 19B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @19B8 revert(memory[0x00:0x00]); } // Block terminates label_19B9: // Incoming jump from 0x19B4, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @19BA stack[-3] // @19BB msg.data[stack[-3]:stack[-3] + 0x20] // } 19B9 5B JUMPDEST 19BA 82 DUP3 19BB 35 CALLDATALOAD 19BC 61 PUSH2 0x19c4 19BF 81 DUP2 19C0 61 PUSH2 0x16a0 19C3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @19BB stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @19BC stack[1] = 0x19c4 // @19BF stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x16a0, returns to 0x19C4 label_19C4: // Incoming return from call to 0x16A0 at 0x19C3 // Inputs[4] // { // @19C5 stack[-1] // @19C5 stack[-3] // @19C9 stack[-4] // @19CB msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 19C4 5B JUMPDEST 19C5 91 SWAP2 19C6 50 POP 19C7 60 PUSH1 0x20 19C9 83 DUP4 19CA 01 ADD 19CB 35 CALLDATALOAD 19CC 61 PUSH2 0x1863 19CF 81 DUP2 19D0 61 PUSH2 0x16a0 19D3 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @19C5 stack[-3] = stack[-1] // @19CB stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @19CC stack[0] = 0x1863 // @19CF stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x16a0, returns to 0x1863 label_19D4: // Incoming call from 0x1563, returns to 0x06DE // Incoming call from 0x0AAE, returns to 0x0AAF // Incoming call from 0x0709, returns to 0x070A // Incoming call from 0x06DD, returns to 0x06DE // Incoming call from 0x1A7B, returns to 0x1A7C // Incoming call from 0x0A82, returns to 0x0A83 // Incoming call from 0x0C0A, returns to 0x06DE // Inputs[1] { @19D7 stack[-1] } 19D4 5B JUMPDEST 19D5 60 PUSH1 0x01 19D7 81 DUP2 19D8 81 DUP2 19D9 1C SHR 19DA 90 SWAP1 19DB 82 DUP3 19DC 16 AND 19DD 80 DUP1 19DE 61 PUSH2 0x19e8 19E1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @19DA stack[0] = stack[-1] >> 0x01 // @19DC stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x19e8, if stack[-1] & 0x01 label_19E2: // Incoming jump from 0x19E1, if not stack[-1] & 0x01 // Inputs[2] // { // @19E4 stack[-2] // @19ED stack[-1] // } 19E2 60 PUSH1 0x7f 19E4 82 DUP3 19E5 16 AND 19E6 91 SWAP2 19E7 50 POP 19E8 5B JUMPDEST 19E9 60 PUSH1 0x20 19EB 82 DUP3 19EC 10 LT 19ED 81 DUP2 19EE 03 SUB 19EF 61 PUSH2 0x1a08 19F2 57 *JUMPI // Stack delta = +0 // Outputs[1] { @19E6 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x1a08, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_19F3: // Incoming jump from 0x19F2, if not stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x19F2, if not stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[1] { @1A07 memory[0x00:0x24] } 19F3 63 PUSH4 0x4e487b71 19F8 60 PUSH1 0xe0 19FA 1B SHL 19FB 60 PUSH1 0x00 19FD 52 MSTORE 19FE 60 PUSH1 0x22 1A00 60 PUSH1 0x04 1A02 52 MSTORE 1A03 60 PUSH1 0x24 1A05 60 PUSH1 0x00 1A07 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @19FD memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1A02 memory[0x04:0x24] = 0x22 // @1A07 revert(memory[0x00:0x24]); // } // Block terminates label_1A08: // Incoming jump from 0x19F2, if stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x19F2, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[3] // { // @1A0A stack[-2] // @1A0A stack[-4] // @1A0B stack[-3] // } 1A08 5B JUMPDEST 1A09 50 POP 1A0A 91 SWAP2 1A0B 90 SWAP1 1A0C 50 POP 1A0D 56 *JUMP // Stack delta = -3 // Outputs[1] { @1A0A stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_1A0E: // Incoming jump from 0x1A81 // Inputs[1] { @1A11 stack[-2] } 1A0E 5B JUMPDEST 1A0F 60 PUSH1 0x1f 1A11 82 DUP3 1A12 11 GT 1A13 15 ISZERO 1A14 61 PUSH2 0x07b9 1A17 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07b9, if !(stack[-2] > 0x1f) label_1A18: // Incoming jump from 0x1A17, if not !(stack[-2] > 0x1f) // Inputs[3] // { // @1A1A stack[-1] // @1A20 memory[0x00:0x20] // @1A23 stack[-3] // } 1A18 60 PUSH1 0x00 1A1A 81 DUP2 1A1B 81 DUP2 1A1C 52 MSTORE 1A1D 60 PUSH1 0x20 1A1F 81 DUP2 1A20 20 SHA3 1A21 60 PUSH1 0x1f 1A23 85 DUP6 1A24 01 ADD 1A25 60 PUSH1 0x05 1A27 1C SHR 1A28 81 DUP2 1A29 01 ADD 1A2A 60 PUSH1 0x20 1A2C 86 DUP7 1A2D 10 LT 1A2E 15 ISZERO 1A2F 61 PUSH2 0x1a35 1A32 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @1A18 stack[0] = 0x00 // @1A1C memory[0x00:0x20] = stack[-1] // @1A20 stack[1] = keccak256(memory[0x00:0x20]) // @1A29 stack[2] = keccak256(memory[0x00:0x20]) + (stack[-3] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x1a35, if !(stack[-3] < 0x20) label_1A33: // Incoming jump from 0x1A32, if not !(stack[-3] < 0x20) // Inputs[2] // { // @1A34 stack[-2] // @1A38 stack[-5] // } 1A33 50 POP 1A34 80 DUP1 1A35 5B JUMPDEST 1A36 60 PUSH1 0x1f 1A38 85 DUP6 1A39 01 ADD 1A3A 60 PUSH1 0x05 1A3C 1C SHR 1A3D 82 DUP3 1A3E 01 ADD 1A3F 91 SWAP2 1A40 50 POP 1A41 5B JUMPDEST 1A42 81 DUP2 1A43 81 DUP2 1A44 10 LT 1A45 15 ISZERO 1A46 61 PUSH2 0x113a 1A49 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1A34 stack[-1] = stack[-2] // @1A3F stack[-2] = stack[-2] + (stack[-5] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x113a, if !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) label_1A4A: // Incoming jump from 0x1A49, if not !(stack[-1] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x1A49, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x1A49, if not !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Inputs[2] // { // @1A4A stack[-3] // @1A4B stack[-1] // } 1A4A 82 DUP3 1A4B 81 DUP2 1A4C 55 SSTORE 1A4D 60 PUSH1 0x01 1A4F 01 ADD 1A50 61 PUSH2 0x1a41 1A53 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1A4C storage[stack[-1]] = stack[-3] // @1A4F stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1a41 label_1A54: // Incoming call from 0x0A5D, returns to 0x0989 // Inputs[2] // { // @1A55 stack[-2] // @1A56 memory[stack[-2]:stack[-2] + 0x20] // } 1A54 5B JUMPDEST 1A55 81 DUP2 1A56 51 MLOAD 1A57 67 PUSH8 0xffffffffffffffff 1A60 81 DUP2 1A61 11 GT 1A62 15 ISZERO 1A63 61 PUSH2 0x1a6e 1A66 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A56 stack[0] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1a6e, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1A67: // Incoming jump from 0x1A66, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) 1A67 61 PUSH2 0x1a6e 1A6A 61 PUSH2 0x173f 1A6D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1A67 stack[0] = 0x1a6e } // Block ends with unconditional jump to 0x173f label_1A6E: // Incoming jump from 0x1A66, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1A72 stack[-1] // @1A76 stack[-2] // @1A77 storage[stack[-2]] // } 1A6E 5B JUMPDEST 1A6F 61 PUSH2 0x1a82 1A72 81 DUP2 1A73 61 PUSH2 0x1a7c 1A76 84 DUP5 1A77 54 SLOAD 1A78 61 PUSH2 0x19d4 1A7B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A6F stack[0] = 0x1a82 // @1A72 stack[1] = stack[-1] // @1A73 stack[2] = 0x1a7c // @1A77 stack[3] = storage[stack[-2]] // } // Block ends with call to 0x19d4, returns to 0x1A7C label_1A7C: // Incoming return from call to 0x19D4 at 0x1A7B // Inputs[1] { @1A7D stack[-5] } 1A7C 5B JUMPDEST 1A7D 84 DUP5 1A7E 61 PUSH2 0x1a0e 1A81 56 *JUMP // Stack delta = +1 // Outputs[1] { @1A7D stack[0] = stack[-5] } // Block ends with unconditional jump to 0x1a0e label_1A82: // Incoming return from call to 0x1A7C at 0x1A7B // Inputs[1] { @1A88 stack[-1] } 1A82 5B JUMPDEST 1A83 60 PUSH1 0x20 1A85 80 DUP1 1A86 60 PUSH1 0x1f 1A88 83 DUP4 1A89 11 GT 1A8A 60 PUSH1 0x01 1A8C 81 DUP2 1A8D 14 EQ 1A8E 61 PUSH2 0x1ab7 1A91 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1A83 stack[0] = 0x20 // @1A85 stack[1] = 0x20 // @1A89 stack[2] = stack[-1] > 0x1f // } // Block ends with conditional jump to 0x1ab7, if (stack[-1] > 0x1f) == 0x01 label_1A92: // Incoming jump from 0x1A91, if not (stack[-1] > 0x1f) == 0x01 // Inputs[1] { @1A94 stack[-4] } 1A92 60 PUSH1 0x00 1A94 84 DUP5 1A95 15 ISZERO 1A96 61 PUSH2 0x1a9f 1A99 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A92 stack[0] = 0x00 } // Block ends with conditional jump to 0x1a9f, if !stack[-4] label_1A9A: // Incoming jump from 0x1A99, if not !stack[-4] // Inputs[5] // { // @1A9B stack[-7] // @1A9C stack[-4] // @1A9E memory[stack[-4] + stack[-7]:stack[-4] + stack[-7] + 0x20] // @1AA5 stack[-5] // @1AB1 stack[-6] // } 1A9A 50 POP 1A9B 85 DUP6 1A9C 83 DUP4 1A9D 01 ADD 1A9E 51 MLOAD 1A9F 5B JUMPDEST 1AA0 60 PUSH1 0x00 1AA2 19 NOT 1AA3 60 PUSH1 0x03 1AA5 86 DUP7 1AA6 90 SWAP1 1AA7 1B SHL 1AA8 1C SHR 1AA9 19 NOT 1AAA 16 AND 1AAB 60 PUSH1 0x01 1AAD 85 DUP6 1AAE 90 SWAP1 1AAF 1B SHL 1AB0 17 OR 1AB1 85 DUP6 1AB2 55 SSTORE 1AB3 61 PUSH2 0x113a 1AB6 56 *JUMP // Stack delta = -1 // Outputs[1] { @1AB2 storage[stack[-6]] = (stack[-5] << 0x01) | (~(~0x00 >> (stack[-5] << 0x03)) & memory[stack[-4] + stack[-7]:stack[-4] + stack[-7] + 0x20]) } // Block ends with unconditional jump to 0x113a label_1AB7: // Incoming jump from 0x1A91, if (stack[-1] > 0x1f) == 0x01 // Inputs[3] // { // @1ABA stack[-5] // @1AC0 memory[0x00:0x20] // @1AC4 stack[-4] // } 1AB7 5B JUMPDEST 1AB8 60 PUSH1 0x00 1ABA 85 DUP6 1ABB 81 DUP2 1ABC 52 MSTORE 1ABD 60 PUSH1 0x20 1ABF 81 DUP2 1AC0 20 SHA3 1AC1 60 PUSH1 0x1f 1AC3 19 NOT 1AC4 86 DUP7 1AC5 16 AND 1AC6 91 SWAP2 1AC7 5B JUMPDEST 1AC8 82 DUP3 1AC9 81 DUP2 1ACA 10 LT 1ACB 15 ISZERO 1ACC 61 PUSH2 0x1ae6 1ACF 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @1ABC memory[0x00:0x20] = stack[-5] // @1AC0 stack[1] = keccak256(memory[0x00:0x20]) // @1AC6 stack[0] = stack[-4] & ~0x1f // @1AC6 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1ae6, if !(0x00 < stack[-4] & ~0x1f) label_1AD0: // Incoming jump from 0x1ACF, if not !(stack[-1] < stack[-3]) // Incoming jump from 0x1ACF, if not !(0x00 < stack[-4] & ~0x1f) // Inputs[6] // { // @1AD0 stack[-9] // @1AD1 stack[-6] // @1AD3 memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @1AD4 stack[-2] // @1AD6 stack[-1] // @1AD7 stack[-5] // } 1AD0 88 DUP9 1AD1 86 DUP7 1AD2 01 ADD 1AD3 51 MLOAD 1AD4 82 DUP3 1AD5 55 SSTORE 1AD6 94 SWAP5 1AD7 84 DUP5 1AD8 01 ADD 1AD9 94 SWAP5 1ADA 60 PUSH1 0x01 1ADC 90 SWAP1 1ADD 91 SWAP2 1ADE 01 ADD 1ADF 90 SWAP1 1AE0 84 DUP5 1AE1 01 ADD 1AE2 61 PUSH2 0x1ac7 1AE5 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1AD5 storage[stack[-2]] = memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @1AD9 stack[-6] = stack[-5] + stack[-6] // @1ADF stack[-2] = stack[-2] + 0x01 // @1AE1 stack[-1] = stack[-5] + stack[-1] // } // Block ends with unconditional jump to 0x1ac7 label_1AE6: // Incoming jump from 0x1ACF, if !(stack[-1] < stack[-3]) // Incoming jump from 0x1ACF, if !(0x00 < stack[-4] & ~0x1f) // Inputs[2] // { // @1AE8 stack[-7] // @1AE9 stack[-3] // } 1AE6 5B JUMPDEST 1AE7 50 POP 1AE8 85 DUP6 1AE9 82 DUP3 1AEA 10 LT 1AEB 15 ISZERO 1AEC 61 PUSH2 0x1b04 1AEF 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1b04, if !(stack[-3] < stack[-7]) label_1AF0: // Incoming jump from 0x1AEF, if not !(stack[-3] < stack[-7]) // Inputs[7] // { // @1AF0 stack[-8] // @1AF1 stack[-5] // @1AF3 memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @1AF9 stack[-6] // @1B02 stack[-1] // @1B10 stack[-7] // @1B13 stack[-9] // } 1AF0 87 DUP8 1AF1 85 DUP6 1AF2 01 ADD 1AF3 51 MLOAD 1AF4 60 PUSH1 0x00 1AF6 19 NOT 1AF7 60 PUSH1 0x03 1AF9 88 DUP9 1AFA 90 SWAP1 1AFB 1B SHL 1AFC 60 PUSH1 0xf8 1AFE 16 AND 1AFF 1C SHR 1B00 19 NOT 1B01 16 AND 1B02 81 DUP2 1B03 55 SSTORE 1B04 5B JUMPDEST 1B05 50 POP 1B06 50 POP 1B07 50 POP 1B08 50 POP 1B09 50 POP 1B0A 60 PUSH1 0x01 1B0C 90 SWAP1 1B0D 81 DUP2 1B0E 1B SHL 1B0F 01 ADD 1B10 90 SWAP1 1B11 55 SSTORE 1B12 50 POP 1B13 56 *JUMP // Stack delta = -9 // Outputs[2] // { // @1B03 storage[stack[-1]] = ~(~0x00 >> (0xf8 & (stack[-6] << 0x03))) & memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @1B11 storage[stack[-7]] = (stack[-6] << 0x01) + 0x01 // } // Block ends with unconditional jump to stack[-9] label_1B14: // Incoming jump from 0x0C98 // Inputs[1] { @1B29 memory[0x00:0x24] } 1B14 5B JUMPDEST 1B15 63 PUSH4 0x4e487b71 1B1A 60 PUSH1 0xe0 1B1C 1B SHL 1B1D 60 PUSH1 0x00 1B1F 52 MSTORE 1B20 60 PUSH1 0x32 1B22 60 PUSH1 0x04 1B24 52 MSTORE 1B25 60 PUSH1 0x24 1B27 60 PUSH1 0x00 1B29 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1B1F memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1B24 memory[0x04:0x24] = 0x32 // @1B29 revert(memory[0x00:0x24]); // } // Block terminates label_1B2A: // Incoming call from 0x0CB0, returns to 0x0CB1 // Inputs[1] { @1B2F stack[-1] } 1B2A 5B JUMPDEST 1B2B 60 PUSH1 0x00 1B2D 60 PUSH1 0x01 1B2F 82 DUP3 1B30 01 ADD 1B31 61 PUSH2 0x1b4a 1B34 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B2B stack[0] = 0x00 } // Block ends with conditional jump to 0x1b4a, if stack[-1] + 0x01 label_1B35: // Incoming jump from 0x1B34, if not stack[-1] + 0x01 // Inputs[1] { @1B49 memory[0x00:0x24] } 1B35 63 PUSH4 0x4e487b71 1B3A 60 PUSH1 0xe0 1B3C 1B SHL 1B3D 60 PUSH1 0x00 1B3F 52 MSTORE 1B40 60 PUSH1 0x11 1B42 60 PUSH1 0x04 1B44 52 MSTORE 1B45 60 PUSH1 0x24 1B47 60 PUSH1 0x00 1B49 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1B3F memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1B44 memory[0x04:0x24] = 0x11 // @1B49 revert(memory[0x00:0x24]); // } // Block terminates label_1B4A: // Incoming jump from 0x1B34, if stack[-1] + 0x01 // Inputs[2] // { // @1B4E stack[-2] // @1B4F stack[-3] // } 1B4A 5B JUMPDEST 1B4B 50 POP 1B4C 60 PUSH1 0x01 1B4E 01 ADD 1B4F 90 SWAP1 1B50 56 *JUMP // Stack delta = -2 // Outputs[1] { @1B4F stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] 1B51 5B JUMPDEST 1B52 60 PUSH1 0x00 1B54 83 DUP4 1B55 51 MLOAD 1B56 61 PUSH2 0x1b63 1B59 81 DUP2 1B5A 84 DUP5 1B5B 60 PUSH1 0x20 1B5D 88 DUP9 1B5E 01 ADD 1B5F 61 PUSH2 0x1624 1B62 56 *JUMP 1B63 5B JUMPDEST 1B64 83 DUP4 1B65 51 MLOAD 1B66 90 SWAP1 1B67 83 DUP4 1B68 01 ADD 1B69 90 SWAP1 1B6A 61 PUSH2 0x1b77 1B6D 81 DUP2 1B6E 83 DUP4 1B6F 60 PUSH1 0x20 1B71 88 DUP9 1B72 01 ADD 1B73 61 PUSH2 0x1624 1B76 56 *JUMP 1B77 5B JUMPDEST 1B78 01 ADD 1B79 94 SWAP5 1B7A 93 SWAP4 1B7B 50 POP 1B7C 50 POP 1B7D 50 POP 1B7E 50 POP 1B7F 56 *JUMP label_1B80: // Incoming jump from 0x0EE0 // Inputs[2] // { // @1B85 stack[-1] // @1B86 stack[-2] // } 1B80 5B JUMPDEST 1B81 60 PUSH1 0x00 1B83 60 PUSH1 0x20 1B85 82 DUP3 1B86 84 DUP5 1B87 03 SUB 1B88 12 SLT 1B89 15 ISZERO 1B8A 61 PUSH2 0x1b92 1B8D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B81 stack[0] = 0x00 } // Block ends with conditional jump to 0x1b92, if !(stack[-2] - stack[-1] i< 0x20) label_1B8E: // Incoming jump from 0x1B8D, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1B91 memory[0x00:0x00] } 1B8E 60 PUSH1 0x00 1B90 80 DUP1 1B91 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B91 revert(memory[0x00:0x00]); } // Block terminates label_1B92: // Incoming jump from 0x1B8D, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1B93 stack[-2] // @1B94 memory[stack[-2]:stack[-2] + 0x20] // } 1B92 5B JUMPDEST 1B93 81 DUP2 1B94 51 MLOAD 1B95 61 PUSH2 0x0d36 1B98 81 DUP2 1B99 61 PUSH2 0x1827 1B9C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B94 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @1B95 stack[1] = 0x0d36 // @1B98 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1827, returns to 0x0D36 label_1B9D: // Incoming call from 0x149D, returns to 0x149E // Inputs[5] // { // @1BA6 stack[-5] // @1BA9 stack[-1] // @1BAB stack[-4] // @1BB6 stack[-3] // @1BCB stack[-2] // } 1B9D 5B JUMPDEST 1B9E 60 PUSH1 0x01 1BA0 60 PUSH1 0x01 1BA2 60 PUSH1 0xa0 1BA4 1B SHL 1BA5 03 SUB 1BA6 85 DUP6 1BA7 81 DUP2 1BA8 16 AND 1BA9 82 DUP3 1BAA 52 MSTORE 1BAB 84 DUP5 1BAC 16 AND 1BAD 60 PUSH1 0x20 1BAF 82 DUP3 1BB0 01 ADD 1BB1 52 MSTORE 1BB2 60 PUSH1 0x40 1BB4 81 DUP2 1BB5 01 ADD 1BB6 83 DUP4 1BB7 90 SWAP1 1BB8 52 MSTORE 1BB9 60 PUSH1 0x80 1BBB 60 PUSH1 0x60 1BBD 82 DUP3 1BBE 01 ADD 1BBF 81 DUP2 1BC0 90 SWAP1 1BC1 52 MSTORE 1BC2 60 PUSH1 0x00 1BC4 90 SWAP1 1BC5 61 PUSH2 0x1bd0 1BC8 90 SWAP1 1BC9 83 DUP4 1BCA 01 ADD 1BCB 84 DUP5 1BCC 61 PUSH2 0x1648 1BCF 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @1BAA memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1BB1 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1BB8 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @1BC1 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @1BC4 stack[0] = 0x00 // @1BC8 stack[1] = 0x1bd0 // @1BCA stack[2] = stack[-1] + 0x80 // @1BCB stack[3] = stack[-2] // } // Block ends with call to 0x1648, returns to 0x1BD0 label_1BD0: // Incoming return from call to 0x1648 at 0x1BCF // Inputs[3] // { // @1BD1 stack[-8] // @1BD1 stack[-1] // @1BD2 stack[-7] // } 1BD0 5B JUMPDEST 1BD1 96 SWAP7 1BD2 95 SWAP6 1BD3 50 POP 1BD4 50 POP 1BD5 50 POP 1BD6 50 POP 1BD7 50 POP 1BD8 50 POP 1BD9 56 *JUMP // Stack delta = -7 // Outputs[1] { @1BD1 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_1BDA: // Incoming jump from 0x14D5 // Inputs[2] // { // @1BDF stack[-1] // @1BE0 stack[-2] // } 1BDA 5B JUMPDEST 1BDB 60 PUSH1 0x00 1BDD 60 PUSH1 0x20 1BDF 82 DUP3 1BE0 84 DUP5 1BE1 03 SUB 1BE2 12 SLT 1BE3 15 ISZERO 1BE4 61 PUSH2 0x1bec 1BE7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1BDB stack[0] = 0x00 } // Block ends with conditional jump to 0x1bec, if !(stack[-2] - stack[-1] i< 0x20) label_1BE8: // Incoming jump from 0x1BE7, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1BEB memory[0x00:0x00] } 1BE8 60 PUSH1 0x00 1BEA 80 DUP1 1BEB FD *REVERT // Stack delta = +0 // Outputs[1] { @1BEB revert(memory[0x00:0x00]); } // Block terminates label_1BEC: // Incoming jump from 0x1BE7, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1BED stack[-2] // @1BEE memory[stack[-2]:stack[-2] + 0x20] // } 1BEC 5B JUMPDEST 1BED 81 DUP2 1BEE 51 MLOAD 1BEF 61 PUSH2 0x0d36 1BF2 81 DUP2 1BF3 61 PUSH2 0x15f1 1BF6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1BEE stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @1BEF stack[1] = 0x0d36 // @1BF2 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x15f1, returns to 0x0D36 1BF7 FE *ASSERT 1BF8 A2 LOG2 1BF9 64 PUSH5 0x6970667358 1BFF 22 22 1C00 12 SLT 1C01 20 SHA3 1C02 7E PUSH31 0x1bd2761d021a16f8c2730e00750931db04536c90f8f7d24e38297848d32d20 1C22 64 PUSH5 0x736f6c6343 1C28 00 *STOP 1C29 08 ADDMOD 1C2A 11 GT 1C2B 00 *STOP 1C2C 33 CALLER