Online Solidity Decompiler

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x0088 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0088, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x8a10f9ce 0026 11 GT 0027 61 PUSH2 0x005b 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x005b, if 0x8a10f9ce > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x8a10f9ce > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0x8a10f9ce 0031 14 EQ 0032 61 PUSH2 0x0101 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0101, if 0x8a10f9ce == stack[-1] label_0036: // Incoming jump from 0x0035, if not 0x8a10f9ce == stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xa1dcd11c 003C 14 EQ 003D 61 PUSH2 0x011d 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x011d, if 0xa1dcd11c == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xa1dcd11c == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xa4a23890 0047 14 EQ 0048 61 PUSH2 0x013b 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x013b, if 0xa4a23890 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xa4a23890 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xfb47ccb2 0052 14 EQ 0053 61 PUSH2 0x0159 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0159, if 0xfb47ccb2 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xfb47ccb2 == stack[-1] 0057 61 PUSH2 0x0088 005A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0088 label_005B: // Incoming jump from 0x002A, if 0x8a10f9ce > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @005C stack[-1] } 005B 5B JUMPDEST 005C 80 DUP1 005D 63 PUSH4 0x4f8a4694 0062 14 EQ 0063 61 PUSH2 0x008d 0066 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x008d, if 0x4f8a4694 == stack[-1] label_0067: // Incoming jump from 0x0066, if not 0x4f8a4694 == stack[-1] // Inputs[1] { @0067 stack[-1] } 0067 80 DUP1 0068 63 PUSH4 0x563277ad 006D 14 EQ 006E 61 PUSH2 0x00ab 0071 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ab, if 0x563277ad == stack[-1] label_0072: // Incoming jump from 0x0071, if not 0x563277ad == stack[-1] // Inputs[1] { @0072 stack[-1] } 0072 80 DUP1 0073 63 PUSH4 0x75238c27 0078 14 EQ 0079 61 PUSH2 0x00c7 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00c7, if 0x75238c27 == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0x75238c27 == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0x7a7b6449 0083 14 EQ 0084 61 PUSH2 0x00e5 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00e5, if 0x7a7b6449 == stack[-1] label_0088: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x005A // Incoming jump from 0x0087, if not 0x7a7b6449 == stack[-1] // Inputs[1] { @008C memory[0x00:0x00] } 0088 5B JUMPDEST 0089 60 PUSH1 0x00 008B 80 DUP1 008C FD *REVERT // Stack delta = +0 // Outputs[1] { @008C revert(memory[0x00:0x00]); } // Block terminates label_008D: // Incoming jump from 0x0066, if 0x4f8a4694 == stack[-1] 008D 5B JUMPDEST 008E 61 PUSH2 0x0095 0091 61 PUSH2 0x0177 0094 56 *JUMP // Stack delta = +1 // Outputs[1] { @008E stack[0] = 0x0095 } // Block ends with call to 0x0177, returns to 0x0095 label_0095: // Incoming return from call to 0x0177 at 0x0094 // Inputs[2] // { // @0098 memory[0x40:0x60] // @009C stack[-1] // } 0095 5B JUMPDEST 0096 60 PUSH1 0x40 0098 51 MLOAD 0099 61 PUSH2 0x00a2 009C 91 SWAP2 009D 90 SWAP1 009E 61 PUSH2 0x11ab 00A1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @009C stack[-1] = 0x00a2 // @009D stack[1] = memory[0x40:0x60] // @009D stack[0] = stack[-1] // } // Block ends with call to 0x11ab, returns to 0x00A2 label_00A2: // Incoming return from call to 0x11AB at 0x00A1 // Inputs[3] // { // @00A5 memory[0x40:0x60] // @00A7 stack[-1] // @00AA memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 00A2 5B JUMPDEST 00A3 60 PUSH1 0x40 00A5 51 MLOAD 00A6 80 DUP1 00A7 91 SWAP2 00A8 03 SUB 00A9 90 SWAP1 00AA F3 *RETURN // Stack delta = -1 // Outputs[1] { @00AA return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_00AB: // Incoming jump from 0x0071, if 0x563277ad == stack[-1] // Inputs[1] { @00B2 msg.data.length } 00AB 5B JUMPDEST 00AC 61 PUSH2 0x00c5 00AF 60 PUSH1 0x04 00B1 80 DUP1 00B2 36 CALLDATASIZE 00B3 03 SUB 00B4 81 DUP2 00B5 01 ADD 00B6 90 SWAP1 00B7 61 PUSH2 0x00c0 00BA 91 SWAP2 00BB 90 SWAP1 00BC 61 PUSH2 0x0ede 00BF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @00AC stack[0] = 0x00c5 // @00BA stack[1] = 0x00c0 // @00BB stack[2] = 0x04 + (msg.data.length - 0x04) // @00BB stack[3] = 0x04 // } // Block ends with call to 0x0ede, returns to 0x00C0 label_00C0: // Incoming return from call to 0x0EDE at 0x00BF 00C0 5B JUMPDEST 00C1 61 PUSH2 0x019d 00C4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x019d label_00C5: // Incoming return from call to 0x00C0 at 0x00BF 00C5 5B JUMPDEST 00C6 00 *STOP // Stack delta = +0 // Outputs[1] { @00C6 stop(); } // Block terminates label_00C7: // Incoming jump from 0x007C, if 0x75238c27 == stack[-1] 00C7 5B JUMPDEST 00C8 61 PUSH2 0x00cf 00CB 61 PUSH2 0x0238 00CE 56 *JUMP // Stack delta = +1 // Outputs[1] { @00C8 stack[0] = 0x00cf } // Block ends with call to 0x0238, returns to 0x00CF label_00CF: // Incoming return from call to 0x0238 at 0x00CE // Inputs[2] // { // @00D2 memory[0x40:0x60] // @00D6 stack[-1] // } 00CF 5B JUMPDEST 00D0 60 PUSH1 0x40 00D2 51 MLOAD 00D3 61 PUSH2 0x00dc 00D6 91 SWAP2 00D7 90 SWAP1 00D8 61 PUSH2 0x11c6 00DB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @00D6 stack[-1] = 0x00dc // @00D7 stack[1] = memory[0x40:0x60] // @00D7 stack[0] = stack[-1] // } // Block ends with call to 0x11c6, returns to 0x00DC label_00DC: // Incoming return from call to 0x11C6 at 0x00DB // Inputs[3] // { // @00DF memory[0x40:0x60] // @00E1 stack[-1] // @00E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 00DC 5B JUMPDEST 00DD 60 PUSH1 0x40 00DF 51 MLOAD 00E0 80 DUP1 00E1 91 SWAP2 00E2 03 SUB 00E3 90 SWAP1 00E4 F3 *RETURN // Stack delta = -1 // Outputs[1] { @00E4 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_00E5: // Incoming jump from 0x0087, if 0x7a7b6449 == stack[-1] // Inputs[1] { @00EC msg.data.length } 00E5 5B JUMPDEST 00E6 61 PUSH2 0x00ff 00E9 60 PUSH1 0x04 00EB 80 DUP1 00EC 36 CALLDATASIZE 00ED 03 SUB 00EE 81 DUP2 00EF 01 ADD 00F0 90 SWAP1 00F1 61 PUSH2 0x00fa 00F4 91 SWAP2 00F5 90 SWAP1 00F6 61 PUSH2 0x0ede 00F9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @00E6 stack[0] = 0x00ff // @00F4 stack[1] = 0x00fa // @00F5 stack[2] = 0x04 + (msg.data.length - 0x04) // @00F5 stack[3] = 0x04 // } // Block ends with call to 0x0ede, returns to 0x00FA label_00FA: // Incoming return from call to 0x0EDE at 0x00F9 00FA 5B JUMPDEST 00FB 61 PUSH2 0x024b 00FE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x024b label_00FF: // Incoming return from call to 0x00FA at 0x00F9 // Incoming return from call to 0x00FA at 0x00F9 00FF 5B JUMPDEST 0100 00 *STOP // Stack delta = +0 // Outputs[1] { @0100 stop(); } // Block terminates label_0101: // Incoming jump from 0x0035, if 0x8a10f9ce == stack[-1] // Inputs[1] { @0108 msg.data.length } 0101 5B JUMPDEST 0102 61 PUSH2 0x011b 0105 60 PUSH1 0x04 0107 80 DUP1 0108 36 CALLDATASIZE 0109 03 SUB 010A 81 DUP2 010B 01 ADD 010C 90 SWAP1 010D 61 PUSH2 0x0116 0110 91 SWAP2 0111 90 SWAP1 0112 61 PUSH2 0x0f30 0115 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0102 stack[0] = 0x011b // @0110 stack[1] = 0x0116 // @0111 stack[2] = 0x04 + (msg.data.length - 0x04) // @0111 stack[3] = 0x04 // } // Block ends with call to 0x0f30, returns to 0x0116 label_0116: // Incoming return from call to 0x0F30 at 0x0115 0116 5B JUMPDEST 0117 61 PUSH2 0x06ed 011A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06ed label_011B: // Incoming return from call to 0x0116 at 0x0115 011B 5B JUMPDEST 011C 00 *STOP // Stack delta = +0 // Outputs[1] { @011C stop(); } // Block terminates label_011D: // Incoming jump from 0x0040, if 0xa1dcd11c == stack[-1] 011D 5B JUMPDEST 011E 61 PUSH2 0x0125 0121 61 PUSH2 0x0b13 0124 56 *JUMP // Stack delta = +1 // Outputs[1] { @011E stack[0] = 0x0125 } // Block ends with call to 0x0b13, returns to 0x0125 label_0125: // Incoming return from call to 0x0B13 at 0x0124 // Inputs[2] // { // @0128 memory[0x40:0x60] // @012C stack[-1] // } 0125 5B JUMPDEST 0126 60 PUSH1 0x40 0128 51 MLOAD 0129 61 PUSH2 0x0132 012C 91 SWAP2 012D 90 SWAP1 012E 61 PUSH2 0x1203 0131 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @012C stack[-1] = 0x0132 // @012D stack[1] = memory[0x40:0x60] // @012D stack[0] = stack[-1] // } // Block ends with call to 0x1203, returns to 0x0132 label_0132: // Incoming return from call to 0x1203 at 0x0131 // Inputs[3] // { // @0135 memory[0x40:0x60] // @0137 stack[-1] // @013A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0132 5B JUMPDEST 0133 60 PUSH1 0x40 0135 51 MLOAD 0136 80 DUP1 0137 91 SWAP2 0138 03 SUB 0139 90 SWAP1 013A F3 *RETURN // Stack delta = -1 // Outputs[1] { @013A return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_013B: // Incoming jump from 0x004B, if 0xa4a23890 == stack[-1] 013B 5B JUMPDEST 013C 61 PUSH2 0x0143 013F 61 PUSH2 0x0b26 0142 56 *JUMP // Stack delta = +1 // Outputs[1] { @013C stack[0] = 0x0143 } // Block ends with call to 0x0b26, returns to 0x0143 label_0143: // Incoming return from call to 0x0B26 at 0x0142 // Inputs[2] // { // @0146 memory[0x40:0x60] // @014A stack[-1] // } 0143 5B JUMPDEST 0144 60 PUSH1 0x40 0146 51 MLOAD 0147 61 PUSH2 0x0150 014A 91 SWAP2 014B 90 SWAP1 014C 61 PUSH2 0x11e1 014F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @014A stack[-1] = 0x0150 // @014B stack[1] = memory[0x40:0x60] // @014B stack[0] = stack[-1] // } // Block ends with call to 0x11e1, returns to 0x0150 label_0150: // Incoming return from call to 0x11E1 at 0x014F // Inputs[3] // { // @0153 memory[0x40:0x60] // @0155 stack[-1] // @0158 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0150 5B JUMPDEST 0151 60 PUSH1 0x40 0153 51 MLOAD 0154 80 DUP1 0155 91 SWAP2 0156 03 SUB 0157 90 SWAP1 0158 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0158 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0159: // Incoming jump from 0x0056, if 0xfb47ccb2 == stack[-1] 0159 5B JUMPDEST 015A 61 PUSH2 0x0161 015D 61 PUSH2 0x0bb4 0160 56 *JUMP // Stack delta = +1 // Outputs[1] { @015A stack[0] = 0x0161 } // Block ends with call to 0x0bb4, returns to 0x0161 label_0161: // Incoming return from call to 0x0BB4 at 0x0160 // Inputs[2] // { // @0164 memory[0x40:0x60] // @0168 stack[-1] // } 0161 5B JUMPDEST 0162 60 PUSH1 0x40 0164 51 MLOAD 0165 61 PUSH2 0x016e 0168 91 SWAP2 0169 90 SWAP1 016A 61 PUSH2 0x11ab 016D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0168 stack[-1] = 0x016e // @0169 stack[1] = memory[0x40:0x60] // @0169 stack[0] = stack[-1] // } // Block ends with call to 0x11ab, returns to 0x016E label_016E: // Incoming return from call to 0x11AB at 0x016D // Inputs[3] // { // @0171 memory[0x40:0x60] // @0173 stack[-1] // @0176 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 016E 5B JUMPDEST 016F 60 PUSH1 0x40 0171 51 MLOAD 0172 80 DUP1 0173 91 SWAP2 0174 03 SUB 0175 90 SWAP1 0176 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0176 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0177: // Incoming call from 0x0094, returns to 0x0095 // Inputs[2] // { // @017D storage[0x01] // @019B stack[-1] // } 0177 5B JUMPDEST 0178 60 PUSH1 0x01 017A 60 PUSH1 0x00 017C 90 SWAP1 017D 54 SLOAD 017E 90 SWAP1 017F 61 PUSH2 0x0100 0182 0A EXP 0183 90 SWAP1 0184 04 DIV 0185 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 019A 16 AND 019B 81 DUP2 019C 56 *JUMP // Stack delta = +1 // Outputs[1] { @019A stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_019D: // Incoming jump from 0x00C4 // Inputs[2] // { // @01A1 storage[0x00] // @01D5 msg.sender // } 019D 5B JUMPDEST 019E 60 PUSH1 0x00 01A0 80 DUP1 01A1 54 SLOAD 01A2 90 SWAP1 01A3 61 PUSH2 0x0100 01A6 0A EXP 01A7 90 SWAP1 01A8 04 DIV 01A9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01BE 16 AND 01BF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01D4 16 AND 01D5 33 CALLER 01D6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01EB 16 AND 01EC 14 EQ 01ED 61 PUSH2 0x01f5 01F0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f5, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 label_01F1: // Incoming jump from 0x01F0, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 // Inputs[1] { @01F4 memory[0x00:0x00] } 01F1 60 PUSH1 0x00 01F3 80 DUP1 01F4 FD *REVERT // Stack delta = +0 // Outputs[1] { @01F4 revert(memory[0x00:0x00]); } // Block terminates label_01F5: // Incoming jump from 0x01F0, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 // Inputs[3] // { // @01F6 stack[-1] // @01FF storage[0x00] // @0237 stack[-2] // } 01F5 5B JUMPDEST 01F6 80 DUP1 01F7 60 PUSH1 0x00 01F9 80 DUP1 01FA 61 PUSH2 0x0100 01FD 0A EXP 01FE 81 DUP2 01FF 54 SLOAD 0200 81 DUP2 0201 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0216 02 MUL 0217 19 NOT 0218 16 AND 0219 90 SWAP1 021A 83 DUP4 021B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0230 16 AND 0231 02 MUL 0232 17 OR 0233 90 SWAP1 0234 55 SSTORE 0235 50 POP 0236 50 POP 0237 56 *JUMP // Stack delta = -2 // Outputs[1] { @0234 storage[0x00] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x00]) } // Block ends with unconditional jump to stack[-2] label_0238: // Incoming call from 0x00CE, returns to 0x00CF // Inputs[2] // { // @023E storage[0x03] // @0249 stack[-1] // } 0238 5B JUMPDEST 0239 60 PUSH1 0x03 023B 60 PUSH1 0x01 023D 90 SWAP1 023E 54 SLOAD 023F 90 SWAP1 0240 61 PUSH2 0x0100 0243 0A EXP 0244 90 SWAP1 0245 04 DIV 0246 60 PUSH1 0xff 0248 16 AND 0249 81 DUP2 024A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0248 stack[0] = 0xff & storage[0x03] / 0x0100 ** 0x01 } // Block ends with unconditional jump to stack[-1] label_024B: // Incoming jump from 0x00FE // Inputs[1] { @0251 memory[0x40:0x60] } 024B 5B JUMPDEST 024C 61 PUSH2 0x0289 024F 60 PUSH1 0x40 0251 51 MLOAD 0252 80 DUP1 0253 60 PUSH1 0x40 0255 01 ADD 0256 60 PUSH1 0x40 0258 52 MSTORE 0259 80 DUP1 025A 60 PUSH1 0x19 025C 81 DUP2 025D 52 MSTORE 025E 60 PUSH1 0x20 0260 01 ADD 0261 7F PUSH32 0x73616c747072656669785f7472616e7366657241737365747300000000000000 0282 81 DUP2 0283 52 MSTORE 0284 50 POP 0285 61 PUSH2 0x0bd8 0288 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @024C stack[0] = 0x0289 // @0251 stack[1] = memory[0x40:0x60] // @0258 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @025D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x19 // @0283 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x73616c747072656669785f7472616e7366657241737365747300000000000000 // } // Block ends with call to 0x0bd8, returns to 0x0289 label_0289: // Incoming return from call to 0x0BD8 at 0x0288 // Inputs[4] // { // @028C stack[-1] // @02AD memory[0x40:0x60] // @02C1 memory[0x40:0x60] // @02C8 address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length // } 0289 5B JUMPDEST 028A 60 PUSH1 0x00 028C 81 DUP2 028D 90 SWAP1 028E 50 POP 028F 80 DUP1 0290 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02A5 16 AND 02A6 63 PUSH4 0x75238c27 02AB 60 PUSH1 0x40 02AD 51 MLOAD 02AE 81 DUP2 02AF 63 PUSH4 0xffffffff 02B4 16 AND 02B5 60 PUSH1 0xe0 02B7 1B SHL 02B8 81 DUP2 02B9 52 MSTORE 02BA 60 PUSH1 0x04 02BC 01 ADD 02BD 60 PUSH1 0x20 02BF 60 PUSH1 0x40 02C1 51 MLOAD 02C2 80 DUP1 02C3 83 DUP4 02C4 03 SUB 02C5 81 DUP2 02C6 86 DUP7 02C7 80 DUP1 02C8 3B EXTCODESIZE 02C9 15 ISZERO 02CA 80 DUP1 02CB 15 ISZERO 02CC 61 PUSH2 0x02d4 02CF 57 *JUMPI // Stack delta = +10 // Outputs[11] // { // @028D stack[0] = stack[-1] // @02A5 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @02A6 stack[2] = 0x75238c27 // @02B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x75238c27) << 0xe0 // @02BC stack[3] = 0x04 + memory[0x40:0x60] // @02BD stack[4] = 0x20 // @02C1 stack[5] = memory[0x40:0x60] // @02C4 stack[6] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @02C5 stack[7] = memory[0x40:0x60] // @02C6 stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @02C9 stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length // } // Block ends with conditional jump to 0x02d4, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length label_02D0: // Incoming jump from 0x02CF, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length // Inputs[1] { @02D3 memory[0x00:0x00] } 02D0 60 PUSH1 0x00 02D2 80 DUP1 02D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D3 revert(memory[0x00:0x00]); } // Block terminates label_02D4: // Incoming jump from 0x02CF, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length // Inputs[8] // { // @02D6 msg.gas // @02D7 stack[-5] // @02D7 stack[-2] // @02D7 stack[-6] // @02D7 memory[stack[-3]:stack[-3] + stack[-4]] // @02D7 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @02D7 stack[-3] // @02D7 stack[-4] // } 02D4 5B JUMPDEST 02D5 50 POP 02D6 5A GAS 02D7 FA STATICCALL 02D8 15 ISZERO 02D9 80 DUP1 02DA 15 ISZERO 02DB 61 PUSH2 0x02e8 02DE 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @02D7 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @02D8 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x02e8, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_02DF: // Incoming jump from 0x02DE, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @02DF returndata.length // @02E3 returndata[0x00:0x00 + returndata.length] // @02E4 returndata.length // @02E7 memory[0x00:0x00 + returndata.length] // } 02DF 3D RETURNDATASIZE 02E0 60 PUSH1 0x00 02E2 80 DUP1 02E3 3E RETURNDATACOPY 02E4 3D RETURNDATASIZE 02E5 60 PUSH1 0x00 02E7 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @02E3 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @02E7 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_02E8: // Incoming jump from 0x02DE, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @02EF memory[0x40:0x60] // @02F0 returndata.length // } 02E8 5B JUMPDEST 02E9 50 POP 02EA 50 POP 02EB 50 POP 02EC 50 POP 02ED 60 PUSH1 0x40 02EF 51 MLOAD 02F0 3D RETURNDATASIZE 02F1 60 PUSH1 0x1f 02F3 19 NOT 02F4 60 PUSH1 0x1f 02F6 82 DUP3 02F7 01 ADD 02F8 16 AND 02F9 82 DUP3 02FA 01 ADD 02FB 80 DUP1 02FC 60 PUSH1 0x40 02FE 52 MSTORE 02FF 50 POP 0300 81 DUP2 0301 01 ADD 0302 90 SWAP1 0303 61 PUSH2 0x030c 0306 91 SWAP2 0307 90 SWAP1 0308 61 PUSH2 0x0ff3 030B 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @02FE memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @0306 stack[-4] = 0x030c // @0307 stack[-2] = memory[0x40:0x60] // @0307 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x0ff3, returns to 0x030C label_030C: // Incoming return from call to 0x0FF3 at 0x030B // Inputs[1] { @0310 stack[-1] } 030C 5B JUMPDEST 030D 61 PUSH2 0x0315 0310 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0315, if stack[-1] label_0311: // Incoming jump from 0x0310, if not stack[-1] // Inputs[1] { @0314 memory[0x00:0x00] } 0311 60 PUSH1 0x00 0313 80 DUP1 0314 FD *REVERT // Stack delta = +0 // Outputs[1] { @0314 revert(memory[0x00:0x00]); } // Block terminates label_0315: // Incoming jump from 0x0310, if stack[-1] // Inputs[4] // { // @0318 stack[-1] // @0336 memory[0x40:0x60] // @034A memory[0x40:0x60] // @0351 address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length // } 0315 5B JUMPDEST 0316 60 PUSH1 0x00 0318 81 DUP2 0319 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 032E 16 AND 032F 63 PUSH4 0x4f8a4694 0334 60 PUSH1 0x40 0336 51 MLOAD 0337 81 DUP2 0338 63 PUSH4 0xffffffff 033D 16 AND 033E 60 PUSH1 0xe0 0340 1B SHL 0341 81 DUP2 0342 52 MSTORE 0343 60 PUSH1 0x04 0345 01 ADD 0346 60 PUSH1 0x20 0348 60 PUSH1 0x40 034A 51 MLOAD 034B 80 DUP1 034C 83 DUP4 034D 03 SUB 034E 81 DUP2 034F 86 DUP7 0350 80 DUP1 0351 3B EXTCODESIZE 0352 15 ISZERO 0353 80 DUP1 0354 15 ISZERO 0355 61 PUSH2 0x035d 0358 57 *JUMPI // Stack delta = +10 // Outputs[11] // { // @0316 stack[0] = 0x00 // @032E stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @032F stack[2] = 0x4f8a4694 // @0342 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x4f8a4694) << 0xe0 // @0345 stack[3] = 0x04 + memory[0x40:0x60] // @0346 stack[4] = 0x20 // @034A stack[5] = memory[0x40:0x60] // @034D stack[6] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @034E stack[7] = memory[0x40:0x60] // @034F stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0352 stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length // } // Block ends with conditional jump to 0x035d, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length label_0359: // Incoming jump from 0x0358, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length // Inputs[1] { @035C memory[0x00:0x00] } 0359 60 PUSH1 0x00 035B 80 DUP1 035C FD *REVERT // Stack delta = +0 // Outputs[1] { @035C revert(memory[0x00:0x00]); } // Block terminates label_035D: // Incoming jump from 0x0358, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-1]).code.length // Inputs[8] // { // @035F msg.gas // @0360 stack[-6] // @0360 stack[-3] // @0360 stack[-4] // @0360 memory[stack[-3]:stack[-3] + stack[-4]] // @0360 stack[-5] // @0360 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0360 stack[-2] // } 035D 5B JUMPDEST 035E 50 POP 035F 5A GAS 0360 FA STATICCALL 0361 15 ISZERO 0362 80 DUP1 0363 15 ISZERO 0364 61 PUSH2 0x0371 0367 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0360 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0361 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0371, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0368: // Incoming jump from 0x0367, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0368 returndata.length // @036C returndata[0x00:0x00 + returndata.length] // @036D returndata.length // @0370 memory[0x00:0x00 + returndata.length] // } 0368 3D RETURNDATASIZE 0369 60 PUSH1 0x00 036B 80 DUP1 036C 3E RETURNDATACOPY 036D 3D RETURNDATASIZE 036E 60 PUSH1 0x00 0370 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @036C memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0370 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0371: // Incoming jump from 0x0367, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0378 memory[0x40:0x60] // @0379 returndata.length // } 0371 5B JUMPDEST 0372 50 POP 0373 50 POP 0374 50 POP 0375 50 POP 0376 60 PUSH1 0x40 0378 51 MLOAD 0379 3D RETURNDATASIZE 037A 60 PUSH1 0x1f 037C 19 NOT 037D 60 PUSH1 0x1f 037F 82 DUP3 0380 01 ADD 0381 16 AND 0382 82 DUP3 0383 01 ADD 0384 80 DUP1 0385 60 PUSH1 0x40 0387 52 MSTORE 0388 50 POP 0389 81 DUP2 038A 01 ADD 038B 90 SWAP1 038C 61 PUSH2 0x0395 038F 91 SWAP2 0390 90 SWAP1 0391 61 PUSH2 0x0f07 0394 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0387 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @038F stack[-4] = 0x0395 // @0390 stack[-2] = memory[0x40:0x60] // @0390 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x0f07, returns to 0x0395 label_0395: // Incoming return from call to 0x0F07 at 0x0394 // Inputs[6] // { // @0396 stack[-2] // @0396 stack[-1] // @039A stack[-3] // @03B8 memory[0x40:0x60] // @03CC memory[0x40:0x60] // @03D3 address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).code.length // } 0395 5B JUMPDEST 0396 90 SWAP1 0397 50 POP 0398 60 PUSH1 0x00 039A 82 DUP3 039B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03B0 16 AND 03B1 63 PUSH4 0xa4a23890 03B6 60 PUSH1 0x40 03B8 51 MLOAD 03B9 81 DUP2 03BA 63 PUSH4 0xffffffff 03BF 16 AND 03C0 60 PUSH1 0xe0 03C2 1B SHL 03C3 81 DUP2 03C4 52 MSTORE 03C5 60 PUSH1 0x04 03C7 01 ADD 03C8 60 PUSH1 0x00 03CA 60 PUSH1 0x40 03CC 51 MLOAD 03CD 80 DUP1 03CE 83 DUP4 03CF 03 SUB 03D0 81 DUP2 03D1 86 DUP7 03D2 80 DUP1 03D3 3B EXTCODESIZE 03D4 15 ISZERO 03D5 80 DUP1 03D6 15 ISZERO 03D7 61 PUSH2 0x03df 03DA 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @0396 stack[-2] = stack[-1] // @0398 stack[-1] = 0x00 // @03B0 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @03B1 stack[1] = 0xa4a23890 // @03C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xa4a23890) << 0xe0 // @03C7 stack[2] = 0x04 + memory[0x40:0x60] // @03C8 stack[3] = 0x00 // @03CC stack[4] = memory[0x40:0x60] // @03CF stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @03D0 stack[6] = memory[0x40:0x60] // @03D1 stack[7] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @03D4 stack[8] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).code.length // } // Block ends with conditional jump to 0x03df, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).code.length label_03DB: // Incoming jump from 0x03DA, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).code.length // Inputs[1] { @03DE memory[0x00:0x00] } 03DB 60 PUSH1 0x00 03DD 80 DUP1 03DE FD *REVERT // Stack delta = +0 // Outputs[1] { @03DE revert(memory[0x00:0x00]); } // Block terminates label_03DF: // Incoming jump from 0x03DA, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).code.length // Inputs[8] // { // @03E1 msg.gas // @03E2 stack[-6] // @03E2 stack[-4] // @03E2 stack[-3] // @03E2 memory[stack[-3]:stack[-3] + stack[-4]] // @03E2 stack[-2] // @03E2 stack[-5] // @03E2 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } 03DF 5B JUMPDEST 03E0 50 POP 03E1 5A GAS 03E2 FA STATICCALL 03E3 15 ISZERO 03E4 80 DUP1 03E5 15 ISZERO 03E6 61 PUSH2 0x03f3 03E9 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @03E2 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @03E3 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x03f3, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_03EA: // Incoming jump from 0x03E9, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @03EA returndata.length // @03EE returndata[0x00:0x00 + returndata.length] // @03EF returndata.length // @03F2 memory[0x00:0x00 + returndata.length] // } 03EA 3D RETURNDATASIZE 03EB 60 PUSH1 0x00 03ED 80 DUP1 03EE 3E RETURNDATACOPY 03EF 3D RETURNDATASIZE 03F0 60 PUSH1 0x00 03F2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @03EE memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @03F2 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_03F3: // Incoming jump from 0x03E9, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @03FA memory[0x40:0x60] // @03FB returndata.length // @03FF returndata[0x00:0x00 + returndata.length] // @0400 returndata.length // } 03F3 5B JUMPDEST 03F4 50 POP 03F5 50 POP 03F6 50 POP 03F7 50 POP 03F8 60 PUSH1 0x40 03FA 51 MLOAD 03FB 3D RETURNDATASIZE 03FC 60 PUSH1 0x00 03FE 82 DUP3 03FF 3E RETURNDATACOPY 0400 3D RETURNDATASIZE 0401 60 PUSH1 0x1f 0403 19 NOT 0404 60 PUSH1 0x1f 0406 82 DUP3 0407 01 ADD 0408 16 AND 0409 82 DUP3 040A 01 ADD 040B 80 DUP1 040C 60 PUSH1 0x40 040E 52 MSTORE 040F 50 POP 0410 81 DUP2 0411 01 ADD 0412 90 SWAP1 0413 61 PUSH2 0x041c 0416 91 SWAP2 0417 90 SWAP1 0418 61 PUSH2 0x101c 041B 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @03FF memory[memory[0x40:0x60]:memory[0x40:0x60] + returndata.length] = returndata[0x00:0x00 + returndata.length] // @040E memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @0416 stack[-4] = 0x041c // @0417 stack[-2] = memory[0x40:0x60] // @0417 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x101c, returns to 0x041C label_041C: // Incoming return from call to 0x101C at 0x041B // Inputs[6] // { // @041D stack[-2] // @041D stack[-1] // @0421 stack[-4] // @043F memory[0x40:0x60] // @0453 memory[0x40:0x60] // @045A address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).code.length // } 041C 5B JUMPDEST 041D 90 SWAP1 041E 50 POP 041F 60 PUSH1 0x00 0421 83 DUP4 0422 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0437 16 AND 0438 63 PUSH4 0xa1dcd11c 043D 60 PUSH1 0x40 043F 51 MLOAD 0440 81 DUP2 0441 63 PUSH4 0xffffffff 0446 16 AND 0447 60 PUSH1 0xe0 0449 1B SHL 044A 81 DUP2 044B 52 MSTORE 044C 60 PUSH1 0x04 044E 01 ADD 044F 60 PUSH1 0x20 0451 60 PUSH1 0x40 0453 51 MLOAD 0454 80 DUP1 0455 83 DUP4 0456 03 SUB 0457 81 DUP2 0458 86 DUP7 0459 80 DUP1 045A 3B EXTCODESIZE 045B 15 ISZERO 045C 80 DUP1 045D 15 ISZERO 045E 61 PUSH2 0x0466 0461 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @041D stack[-2] = stack[-1] // @041F stack[-1] = 0x00 // @0437 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @0438 stack[1] = 0xa1dcd11c // @044B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xa1dcd11c) << 0xe0 // @044E stack[2] = 0x04 + memory[0x40:0x60] // @044F stack[3] = 0x20 // @0453 stack[4] = memory[0x40:0x60] // @0456 stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0457 stack[6] = memory[0x40:0x60] // @0458 stack[7] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @045B stack[8] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).code.length // } // Block ends with conditional jump to 0x0466, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).code.length label_0462: // Incoming jump from 0x0461, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).code.length // Inputs[1] { @0465 memory[0x00:0x00] } 0462 60 PUSH1 0x00 0464 80 DUP1 0465 FD *REVERT // Stack delta = +0 // Outputs[1] { @0465 revert(memory[0x00:0x00]); } // Block terminates label_0466: // Incoming jump from 0x0461, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-4]).code.length // Inputs[8] // { // @0468 msg.gas // @0469 stack[-6] // @0469 stack[-5] // @0469 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0469 stack[-2] // @0469 stack[-3] // @0469 stack[-4] // @0469 memory[stack[-3]:stack[-3] + stack[-4]] // } 0466 5B JUMPDEST 0467 50 POP 0468 5A GAS 0469 FA STATICCALL 046A 15 ISZERO 046B 80 DUP1 046C 15 ISZERO 046D 61 PUSH2 0x047a 0470 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0469 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @046A stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x047a, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0471: // Incoming jump from 0x0470, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0471 returndata.length // @0475 returndata[0x00:0x00 + returndata.length] // @0476 returndata.length // @0479 memory[0x00:0x00 + returndata.length] // } 0471 3D RETURNDATASIZE 0472 60 PUSH1 0x00 0474 80 DUP1 0475 3E RETURNDATACOPY 0476 3D RETURNDATASIZE 0477 60 PUSH1 0x00 0479 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0475 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0479 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_047A: // Incoming jump from 0x0470, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0481 memory[0x40:0x60] // @0482 returndata.length // } 047A 5B JUMPDEST 047B 50 POP 047C 50 POP 047D 50 POP 047E 50 POP 047F 60 PUSH1 0x40 0481 51 MLOAD 0482 3D RETURNDATASIZE 0483 60 PUSH1 0x1f 0485 19 NOT 0486 60 PUSH1 0x1f 0488 82 DUP3 0489 01 ADD 048A 16 AND 048B 82 DUP3 048C 01 ADD 048D 80 DUP1 048E 60 PUSH1 0x40 0490 52 MSTORE 0491 50 POP 0492 81 DUP2 0493 01 ADD 0494 90 SWAP1 0495 61 PUSH2 0x049e 0498 91 SWAP2 0499 90 SWAP1 049A 61 PUSH2 0x105d 049D 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0490 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @0498 stack[-4] = 0x049e // @0499 stack[-2] = memory[0x40:0x60] // @0499 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x105d, returns to 0x049E label_049E: // Incoming return from call to 0x105D at 0x049D // Inputs[2] // { // @049F stack[-2] // @049F stack[-1] // } 049E 5B JUMPDEST 049F 90 SWAP1 04A0 50 POP 04A1 60 PUSH1 0x00 04A3 60 PUSH1 0x01 04A5 81 DUP2 04A6 11 GT 04A7 15 ISZERO 04A8 61 PUSH2 0x04da 04AB 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @049F stack[-2] = stack[-1] // @04A1 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x04da, if !(0x00 > 0x01) label_04AC: // Incoming jump from 0x04AB, if not !(0x00 > 0x01) // Inputs[1] { @04D9 memory[0x00:0x24] } 04AC 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 04CD 60 PUSH1 0x00 04CF 52 MSTORE 04D0 60 PUSH1 0x21 04D2 60 PUSH1 0x04 04D4 52 MSTORE 04D5 60 PUSH1 0x24 04D7 60 PUSH1 0x00 04D9 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @04CF memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @04D4 memory[0x04:0x24] = 0x21 // @04D9 revert(memory[0x00:0x24]); // } // Block terminates label_04DA: // Incoming jump from 0x04AB, if !(0x00 > 0x01) // Inputs[1] { @04DB stack[-2] } 04DA 5B JUMPDEST 04DB 81 DUP2 04DC 60 PUSH1 0x01 04DE 81 DUP2 04DF 11 GT 04E0 15 ISZERO 04E1 61 PUSH2 0x0513 04E4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04DB stack[0] = stack[-2] } // Block ends with conditional jump to 0x0513, if !(stack[-2] > 0x01) label_04E5: // Incoming jump from 0x04E4, if not !(stack[-2] > 0x01) // Inputs[1] { @0512 memory[0x00:0x24] } 04E5 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 0506 60 PUSH1 0x00 0508 52 MSTORE 0509 60 PUSH1 0x21 050B 60 PUSH1 0x04 050D 52 MSTORE 050E 60 PUSH1 0x24 0510 60 PUSH1 0x00 0512 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0508 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @050D memory[0x04:0x24] = 0x21 // @0512 revert(memory[0x00:0x24]); // } // Block terminates label_0513: // Incoming jump from 0x04E4, if !(stack[-2] > 0x01) // Inputs[2] // { // @0514 stack[-1] // @0514 stack[-2] // } 0513 5B JUMPDEST 0514 14 EQ 0515 15 ISZERO 0516 61 PUSH2 0x05c6 0519 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x05c6, if !(stack[-1] == stack[-2]) label_051A: // Incoming jump from 0x0519, if not !(stack[-1] == stack[-2]) // Inputs[1] { @051F memory[0x40:0x60] } 051A 61 PUSH2 0x0557 051D 60 PUSH1 0x40 051F 51 MLOAD 0520 80 DUP1 0521 60 PUSH1 0x40 0523 01 ADD 0524 60 PUSH1 0x40 0526 52 MSTORE 0527 80 DUP1 0528 60 PUSH1 0x0e 052A 81 DUP2 052B 52 MSTORE 052C 60 PUSH1 0x20 052E 01 ADD 052F 7F PUSH32 0x486f77546f43616c6c2e43616c6c000000000000000000000000000000000000 0550 81 DUP2 0551 52 MSTORE 0552 50 POP 0553 61 PUSH2 0x0bd8 0556 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @051A stack[0] = 0x0557 // @051F stack[1] = memory[0x40:0x60] // @0526 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @052B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0e // @0551 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x486f77546f43616c6c2e43616c6c000000000000000000000000000000000000 // } // Block ends with call to 0x0bd8, returns to 0x0557 label_0557: // Incoming return from call to 0x0BD8 at 0x0556 // Inputs[3] // { // @0558 stack[-3] // @056F stack[-2] // @0572 memory[0x40:0x60] // } 0557 5B JUMPDEST 0558 82 DUP3 0559 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 056E 16 AND 056F 82 DUP3 0570 60 PUSH1 0x40 0572 51 MLOAD 0573 61 PUSH2 0x057c 0576 91 SWAP2 0577 90 SWAP1 0578 61 PUSH2 0x1194 057B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @056E stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0576 stack[1] = 0x057c // @0577 stack[2] = stack[-2] // @0577 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x1194, returns to 0x057C label_057C: // Incoming return from call to 0x1194 at 0x057B // Inputs[7] // { // @0581 memory[0x40:0x60] // @0583 stack[-1] // @0588 stack[-2] // @0589 msg.gas // @058A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @058A address(stack[-2]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @058E returndata.length // } 057C 5B JUMPDEST 057D 60 PUSH1 0x00 057F 60 PUSH1 0x40 0581 51 MLOAD 0582 80 DUP1 0583 83 DUP4 0584 03 SUB 0585 81 DUP2 0586 60 PUSH1 0x00 0588 86 DUP7 0589 5A GAS 058A F1 CALL 058B 91 SWAP2 058C 50 POP 058D 50 POP 058E 3D RETURNDATASIZE 058F 80 DUP1 0590 60 PUSH1 0x00 0592 81 DUP2 0593 14 EQ 0594 61 PUSH2 0x05b9 0597 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @058A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-2]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @058B stack[-2] = address(stack[-2]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @058E stack[-1] = returndata.length // @058F stack[0] = returndata.length // } // Block ends with conditional jump to 0x05b9, if returndata.length == 0x00 label_0598: // Incoming jump from 0x0597, if not returndata.length == 0x00 // Inputs[6] // { // @059A memory[0x40:0x60] // @059B stack[-2] // @05A2 returndata.length // @05AA returndata.length // @05AD returndata.length // @05B4 returndata[0x00:0x00 + returndata.length] // } 0598 60 PUSH1 0x40 059A 51 MLOAD 059B 91 SWAP2 059C 50 POP 059D 60 PUSH1 0x1f 059F 19 NOT 05A0 60 PUSH1 0x3f 05A2 3D RETURNDATASIZE 05A3 01 ADD 05A4 16 AND 05A5 82 DUP3 05A6 01 ADD 05A7 60 PUSH1 0x40 05A9 52 MSTORE 05AA 3D RETURNDATASIZE 05AB 82 DUP3 05AC 52 MSTORE 05AD 3D RETURNDATASIZE 05AE 60 PUSH1 0x00 05B0 60 PUSH1 0x20 05B2 84 DUP5 05B3 01 ADD 05B4 3E RETURNDATACOPY 05B5 61 PUSH2 0x05be 05B8 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @059B stack[-2] = memory[0x40:0x60] // @05A9 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @05AC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @05B4 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x05be label_05B9: // Incoming jump from 0x0597, if returndata.length == 0x00 // Inputs[1] { @05BC stack[-2] } 05B9 5B JUMPDEST 05BA 60 PUSH1 0x60 05BC 91 SWAP2 05BD 50 POP 05BE 5B JUMPDEST 05BF 50 POP 05C0 50 POP 05C1 50 POP 05C2 61 PUSH2 0x06e6 05C5 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to 0x06e6 label_05C6: // Incoming jump from 0x0519, if !(stack[-1] == stack[-2]) 05C6 5B JUMPDEST 05C7 60 PUSH1 0x01 05C9 80 DUP1 05CA 81 DUP2 05CB 11 GT 05CC 15 ISZERO 05CD 61 PUSH2 0x05ff 05D0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05C7 stack[0] = 0x01 } // Block ends with conditional jump to 0x05ff, if !(0x01 > 0x01) label_05D1: // Incoming jump from 0x05D0, if not !(0x01 > 0x01) // Inputs[1] { @05FE memory[0x00:0x24] } 05D1 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 05F2 60 PUSH1 0x00 05F4 52 MSTORE 05F5 60 PUSH1 0x21 05F7 60 PUSH1 0x04 05F9 52 MSTORE 05FA 60 PUSH1 0x24 05FC 60 PUSH1 0x00 05FE FD *REVERT // Stack delta = +0 // Outputs[3] // { // @05F4 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @05F9 memory[0x04:0x24] = 0x21 // @05FE revert(memory[0x00:0x24]); // } // Block terminates label_05FF: // Incoming jump from 0x05D0, if !(0x01 > 0x01) // Inputs[1] { @0600 stack[-2] } 05FF 5B JUMPDEST 0600 81 DUP2 0601 60 PUSH1 0x01 0603 81 DUP2 0604 11 GT 0605 15 ISZERO 0606 61 PUSH2 0x0638 0609 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0600 stack[0] = stack[-2] } // Block ends with conditional jump to 0x0638, if !(stack[-2] > 0x01) label_060A: // Incoming jump from 0x0609, if not !(stack[-2] > 0x01) // Inputs[1] { @0637 memory[0x00:0x24] } 060A 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 062B 60 PUSH1 0x00 062D 52 MSTORE 062E 60 PUSH1 0x21 0630 60 PUSH1 0x04 0632 52 MSTORE 0633 60 PUSH1 0x24 0635 60 PUSH1 0x00 0637 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @062D memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @0632 memory[0x04:0x24] = 0x21 // @0637 revert(memory[0x00:0x24]); // } // Block terminates label_0638: // Incoming jump from 0x0609, if !(stack[-2] > 0x01) // Inputs[2] // { // @0639 stack[-1] // @0639 stack[-2] // } 0638 5B JUMPDEST 0639 14 EQ 063A 15 ISZERO 063B 61 PUSH2 0x06e5 063E 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x06e5, if !(stack[-1] == stack[-2]) label_063F: // Incoming jump from 0x063E, if not !(stack[-1] == stack[-2]) // Inputs[1] { @0644 memory[0x40:0x60] } 063F 61 PUSH2 0x067c 0642 60 PUSH1 0x40 0644 51 MLOAD 0645 80 DUP1 0646 60 PUSH1 0x40 0648 01 ADD 0649 60 PUSH1 0x40 064B 52 MSTORE 064C 80 DUP1 064D 60 PUSH1 0x16 064F 81 DUP2 0650 52 MSTORE 0651 60 PUSH1 0x20 0653 01 ADD 0654 7F PUSH32 0x486f77546f43616c6c2e44656c656761746543616c6c00000000000000000000 0675 81 DUP2 0676 52 MSTORE 0677 50 POP 0678 61 PUSH2 0x0bd8 067B 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @063F stack[0] = 0x067c // @0644 stack[1] = memory[0x40:0x60] // @064B memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0650 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x16 // @0676 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x486f77546f43616c6c2e44656c656761746543616c6c00000000000000000000 // } // Block ends with call to 0x0bd8, returns to 0x067C label_067C: // Incoming return from call to 0x0BD8 at 0x067B // Inputs[3] // { // @067D stack[-3] // @0694 stack[-2] // @0697 memory[0x40:0x60] // } 067C 5B JUMPDEST 067D 82 DUP3 067E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0693 16 AND 0694 82 DUP3 0695 60 PUSH1 0x40 0697 51 MLOAD 0698 61 PUSH2 0x06a1 069B 91 SWAP2 069C 90 SWAP1 069D 61 PUSH2 0x1194 06A0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0693 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @069B stack[1] = 0x06a1 // @069C stack[2] = stack[-2] // @069C stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x1194, returns to 0x06A1 label_06A1: // Incoming return from call to 0x1194 at 0x06A0 // Inputs[7] // { // @06A6 memory[0x40:0x60] // @06A8 stack[-1] // @06AB stack[-2] // @06AC msg.gas // @06AD memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @06AD address(stack[-2]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @06B1 returndata.length // } 06A1 5B JUMPDEST 06A2 60 PUSH1 0x00 06A4 60 PUSH1 0x40 06A6 51 MLOAD 06A7 80 DUP1 06A8 83 DUP4 06A9 03 SUB 06AA 81 DUP2 06AB 85 DUP6 06AC 5A GAS 06AD F4 DELEGATECALL 06AE 91 SWAP2 06AF 50 POP 06B0 50 POP 06B1 3D RETURNDATASIZE 06B2 80 DUP1 06B3 60 PUSH1 0x00 06B5 81 DUP2 06B6 14 EQ 06B7 61 PUSH2 0x06dc 06BA 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @06AD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-2]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @06AE stack[-2] = address(stack[-2]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @06B1 stack[-1] = returndata.length // @06B2 stack[0] = returndata.length // } // Block ends with conditional jump to 0x06dc, if returndata.length == 0x00 label_06BB: // Incoming jump from 0x06BA, if not returndata.length == 0x00 // Inputs[6] // { // @06BD memory[0x40:0x60] // @06BE stack[-2] // @06C5 returndata.length // @06CD returndata.length // @06D0 returndata.length // @06D7 returndata[0x00:0x00 + returndata.length] // } 06BB 60 PUSH1 0x40 06BD 51 MLOAD 06BE 91 SWAP2 06BF 50 POP 06C0 60 PUSH1 0x1f 06C2 19 NOT 06C3 60 PUSH1 0x3f 06C5 3D RETURNDATASIZE 06C6 01 ADD 06C7 16 AND 06C8 82 DUP3 06C9 01 ADD 06CA 60 PUSH1 0x40 06CC 52 MSTORE 06CD 3D RETURNDATASIZE 06CE 82 DUP3 06CF 52 MSTORE 06D0 3D RETURNDATASIZE 06D1 60 PUSH1 0x00 06D3 60 PUSH1 0x20 06D5 84 DUP5 06D6 01 ADD 06D7 3E RETURNDATACOPY 06D8 61 PUSH2 0x06e1 06DB 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @06BE stack[-2] = memory[0x40:0x60] // @06CC memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @06CF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @06D7 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x06e1 label_06DC: // Incoming jump from 0x06BA, if returndata.length == 0x00 // Inputs[1] { @06DF stack[-2] } 06DC 5B JUMPDEST 06DD 60 PUSH1 0x60 06DF 91 SWAP2 06E0 50 POP 06E1 5B JUMPDEST 06E2 50 POP 06E3 50 POP 06E4 50 POP // Stack delta = -3 // Block continues label_06E5: // Incoming jump from 0x06E4 // Incoming jump from 0x063E, if !(stack[-1] == stack[-2]) // Incoming jump from 0x06E4 // Inputs[1] { @06EC stack[-6] } 06E5 5B JUMPDEST 06E6 5B JUMPDEST 06E7 50 POP 06E8 50 POP 06E9 50 POP 06EA 50 POP 06EB 50 POP 06EC 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_06ED: // Incoming jump from 0x011A // Inputs[2] // { // @06F1 storage[0x00] // @0725 msg.sender // } 06ED 5B JUMPDEST 06EE 60 PUSH1 0x00 06F0 80 DUP1 06F1 54 SLOAD 06F2 90 SWAP1 06F3 61 PUSH2 0x0100 06F6 0A EXP 06F7 90 SWAP1 06F8 04 DIV 06F9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 070E 16 AND 070F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0724 16 AND 0725 33 CALLER 0726 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 073B 16 AND 073C 14 EQ 073D 61 PUSH2 0x0745 0740 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0745, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 label_0741: // Incoming jump from 0x0740, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 // Inputs[1] { @0744 memory[0x00:0x00] } 0741 60 PUSH1 0x00 0743 80 DUP1 0744 FD *REVERT // Stack delta = +0 // Outputs[1] { @0744 revert(memory[0x00:0x00]); } // Block terminates label_0745: // Incoming jump from 0x0740, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 // Inputs[1] { @074B memory[0x40:0x60] } 0745 5B JUMPDEST 0746 61 PUSH2 0x0783 0749 60 PUSH1 0x40 074B 51 MLOAD 074C 80 DUP1 074D 60 PUSH1 0x40 074F 01 ADD 0750 60 PUSH1 0x40 0752 52 MSTORE 0753 80 DUP1 0754 60 PUSH1 0x1d 0756 81 DUP2 0757 52 MSTORE 0758 60 PUSH1 0x20 075A 01 ADD 075B 7F PUSH32 0x73616c747072656669785f657865637574654f70656e7365614465616c000000 077C 81 DUP2 077D 52 MSTORE 077E 50 POP 077F 61 PUSH2 0x0bd8 0782 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @0746 stack[0] = 0x0783 // @074B stack[1] = memory[0x40:0x60] // @0752 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0757 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1d // @077D memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x73616c747072656669785f657865637574654f70656e7365614465616c000000 // } // Block ends with call to 0x0bd8, returns to 0x0783 label_0783: // Incoming return from call to 0x0BD8 at 0x0782 // Inputs[5] // { // @078F storage[0x03] // @079F stack[-8] // @07A9 storage[0x01] // @07E0 stack[-6] // @07E1 stack[-5] // } 0783 5B JUMPDEST 0784 60 PUSH1 0x01 0786 60 PUSH1 0x03 0788 60 PUSH1 0x01 078A 61 PUSH2 0x0100 078D 0A EXP 078E 81 DUP2 078F 54 SLOAD 0790 81 DUP2 0791 60 PUSH1 0xff 0793 02 MUL 0794 19 NOT 0795 16 AND 0796 90 SWAP1 0797 83 DUP4 0798 15 ISZERO 0799 15 ISZERO 079A 02 MUL 079B 17 OR 079C 90 SWAP1 079D 55 SSTORE 079E 50 POP 079F 87 DUP8 07A0 60 PUSH1 0x01 07A2 60 PUSH1 0x00 07A4 61 PUSH2 0x0100 07A7 0A EXP 07A8 81 DUP2 07A9 54 SLOAD 07AA 81 DUP2 07AB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07C0 02 MUL 07C1 19 NOT 07C2 16 AND 07C3 90 SWAP1 07C4 83 DUP4 07C5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 07DA 16 AND 07DB 02 MUL 07DC 17 OR 07DD 90 SWAP1 07DE 55 SSTORE 07DF 50 POP 07E0 85 DUP6 07E1 85 DUP6 07E2 60 PUSH1 0x02 07E4 91 SWAP2 07E5 90 SWAP1 07E6 61 PUSH2 0x07f0 07E9 92 SWAP3 07EA 91 SWAP2 07EB 90 SWAP1 07EC 61 PUSH2 0x0c9a 07EF 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @079D storage[0x03] = !!0x01 * 0x0100 ** 0x01 | (~(0xff * 0x0100 ** 0x01) & storage[0x03]) // @07DE storage[0x01] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-8]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x01]) // @07E9 stack[0] = 0x07f0 // @07EA stack[1] = 0x02 // @07EB stack[2] = stack[-6] // @07EB stack[3] = stack[-5] // } // Block ends with call to 0x0c9a, returns to 0x07F0 label_07F0: // Incoming return from call to 0x0C9A at 0x07EF // Inputs[2] // { // @07F2 stack[-8] // @07FC storage[0x03] // } 07F0 5B JUMPDEST 07F1 50 POP 07F2 86 DUP7 07F3 60 PUSH1 0x03 07F5 60 PUSH1 0x00 07F7 61 PUSH2 0x0100 07FA 0A EXP 07FB 81 DUP2 07FC 54 SLOAD 07FD 81 DUP2 07FE 60 PUSH1 0xff 0800 02 MUL 0801 19 NOT 0802 16 AND 0803 90 SWAP1 0804 83 DUP4 0805 60 PUSH1 0x01 0807 81 DUP2 0808 11 GT 0809 15 ISZERO 080A 61 PUSH2 0x083c 080D 57 *JUMPI // Stack delta = +4 // Outputs[5] // { // @07F2 stack[-1] = stack[-8] // @07F3 stack[0] = 0x03 // @0803 stack[2] = 0x0100 ** 0x00 // @0803 stack[1] = ~(0xff * 0x0100 ** 0x00) & storage[0x03] // @0804 stack[3] = stack[-8] // } // Block ends with conditional jump to 0x083c, if !(stack[-8] > 0x01) label_080E: // Incoming jump from 0x080D, if not !(stack[-8] > 0x01) // Inputs[1] { @083B memory[0x00:0x24] } 080E 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 082F 60 PUSH1 0x00 0831 52 MSTORE 0832 60 PUSH1 0x21 0834 60 PUSH1 0x04 0836 52 MSTORE 0837 60 PUSH1 0x24 0839 60 PUSH1 0x00 083B FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0831 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @0836 memory[0x04:0x24] = 0x21 // @083B revert(memory[0x00:0x24]); // } // Block terminates label_083C: // Incoming jump from 0x080D, if !(stack[-8] > 0x01) // Inputs[4] // { // @083D stack[-2] // @083D stack[-1] // @083E stack[-3] // @083F stack[-4] // } 083C 5B JUMPDEST 083D 02 MUL 083E 17 OR 083F 90 SWAP1 0840 55 SSTORE 0841 50 POP 0842 60 PUSH1 0x00 0844 60 PUSH1 0x01 0846 81 DUP2 0847 11 GT 0848 15 ISZERO 0849 61 PUSH2 0x087b 084C 57 *JUMPI // Stack delta = -4 // Outputs[2] // { // @0840 storage[stack[-4]] = stack[-1] * stack[-2] | stack[-3] // @0842 stack[-5] = 0x00 // } // Block ends with conditional jump to 0x087b, if !(0x00 > 0x01) label_084D: // Incoming jump from 0x084C, if not !(0x00 > 0x01) // Inputs[1] { @087A memory[0x00:0x24] } 084D 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 086E 60 PUSH1 0x00 0870 52 MSTORE 0871 60 PUSH1 0x21 0873 60 PUSH1 0x04 0875 52 MSTORE 0876 60 PUSH1 0x24 0878 60 PUSH1 0x00 087A FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0870 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @0875 memory[0x04:0x24] = 0x21 // @087A revert(memory[0x00:0x24]); // } // Block terminates label_087B: // Incoming jump from 0x084C, if !(0x00 > 0x01) // Inputs[1] { @087C stack[-4] } 087B 5B JUMPDEST 087C 83 DUP4 087D 60 PUSH1 0x01 087F 81 DUP2 0880 11 GT 0881 15 ISZERO 0882 61 PUSH2 0x08b4 0885 57 *JUMPI // Stack delta = +1 // Outputs[1] { @087C stack[0] = stack[-4] } // Block ends with conditional jump to 0x08b4, if !(stack[-4] > 0x01) label_0886: // Incoming jump from 0x0885, if not !(stack[-4] > 0x01) // Inputs[1] { @08B3 memory[0x00:0x24] } 0886 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 08A7 60 PUSH1 0x00 08A9 52 MSTORE 08AA 60 PUSH1 0x21 08AC 60 PUSH1 0x04 08AE 52 MSTORE 08AF 60 PUSH1 0x24 08B1 60 PUSH1 0x00 08B3 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @08A9 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @08AE memory[0x04:0x24] = 0x21 // @08B3 revert(memory[0x00:0x24]); // } // Block terminates label_08B4: // Incoming jump from 0x0885, if !(stack[-4] > 0x01) // Inputs[2] // { // @08B5 stack[-2] // @08B5 stack[-1] // } 08B4 5B JUMPDEST 08B5 14 EQ 08B6 15 ISZERO 08B7 61 PUSH2 0x092b 08BA 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x092b, if !(stack[-1] == stack[-2]) label_08BB: // Incoming jump from 0x08BA, if not !(stack[-1] == stack[-2]) // Inputs[4] // { // @08BB stack[-4] // @08D2 stack[-2] // @08D3 stack[-1] // @08D6 memory[0x40:0x60] // } 08BB 83 DUP4 08BC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08D1 16 AND 08D2 82 DUP3 08D3 82 DUP3 08D4 60 PUSH1 0x40 08D6 51 MLOAD 08D7 61 PUSH2 0x08e1 08DA 92 SWAP3 08DB 91 SWAP2 08DC 90 SWAP1 08DD 61 PUSH2 0x117b 08E0 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @08D1 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @08DA stack[1] = 0x08e1 // @08DB stack[2] = stack[-2] // @08DC stack[3] = stack[-1] // @08DC stack[4] = memory[0x40:0x60] // } // Block ends with call to 0x117b, returns to 0x08E1 label_08E1: // Incoming return from call to 0x117B at 0x08E0 // Inputs[7] // { // @08E6 memory[0x40:0x60] // @08E8 stack[-1] // @08ED stack[-2] // @08EE msg.gas // @08EF address(stack[-2]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @08EF memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @08F3 returndata.length // } 08E1 5B JUMPDEST 08E2 60 PUSH1 0x00 08E4 60 PUSH1 0x40 08E6 51 MLOAD 08E7 80 DUP1 08E8 83 DUP4 08E9 03 SUB 08EA 81 DUP2 08EB 60 PUSH1 0x00 08ED 86 DUP7 08EE 5A GAS 08EF F1 CALL 08F0 91 SWAP2 08F1 50 POP 08F2 50 POP 08F3 3D RETURNDATASIZE 08F4 80 DUP1 08F5 60 PUSH1 0x00 08F7 81 DUP2 08F8 14 EQ 08F9 61 PUSH2 0x091e 08FC 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @08EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-2]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @08F0 stack[-2] = address(stack[-2]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @08F3 stack[-1] = returndata.length // @08F4 stack[0] = returndata.length // } // Block ends with conditional jump to 0x091e, if returndata.length == 0x00 label_08FD: // Incoming jump from 0x08FC, if not returndata.length == 0x00 // Inputs[6] // { // @08FF memory[0x40:0x60] // @0900 stack[-2] // @0907 returndata.length // @090F returndata.length // @0912 returndata.length // @0919 returndata[0x00:0x00 + returndata.length] // } 08FD 60 PUSH1 0x40 08FF 51 MLOAD 0900 91 SWAP2 0901 50 POP 0902 60 PUSH1 0x1f 0904 19 NOT 0905 60 PUSH1 0x3f 0907 3D RETURNDATASIZE 0908 01 ADD 0909 16 AND 090A 82 DUP3 090B 01 ADD 090C 60 PUSH1 0x40 090E 52 MSTORE 090F 3D RETURNDATASIZE 0910 82 DUP3 0911 52 MSTORE 0912 3D RETURNDATASIZE 0913 60 PUSH1 0x00 0915 60 PUSH1 0x20 0917 84 DUP5 0918 01 ADD 0919 3E RETURNDATACOPY 091A 61 PUSH2 0x0923 091D 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0900 stack[-2] = memory[0x40:0x60] // @090E memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0911 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0919 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0923 label_091E: // Incoming jump from 0x08FC, if returndata.length == 0x00 // Inputs[1] { @0921 stack[-2] } 091E 5B JUMPDEST 091F 60 PUSH1 0x60 0921 91 SWAP2 0922 50 POP 0923 5B JUMPDEST 0924 50 POP 0925 50 POP 0926 50 POP 0927 61 PUSH2 0x0a0f 092A 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to 0x0a0f label_092B: // Incoming jump from 0x08BA, if !(stack[-1] == stack[-2]) 092B 5B JUMPDEST 092C 60 PUSH1 0x01 092E 80 DUP1 092F 81 DUP2 0930 11 GT 0931 15 ISZERO 0932 61 PUSH2 0x0964 0935 57 *JUMPI // Stack delta = +1 // Outputs[1] { @092C stack[0] = 0x01 } // Block ends with conditional jump to 0x0964, if !(0x01 > 0x01) label_0936: // Incoming jump from 0x0935, if not !(0x01 > 0x01) // Inputs[1] { @0963 memory[0x00:0x24] } 0936 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 0957 60 PUSH1 0x00 0959 52 MSTORE 095A 60 PUSH1 0x21 095C 60 PUSH1 0x04 095E 52 MSTORE 095F 60 PUSH1 0x24 0961 60 PUSH1 0x00 0963 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0959 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @095E memory[0x04:0x24] = 0x21 // @0963 revert(memory[0x00:0x24]); // } // Block terminates label_0964: // Incoming jump from 0x0935, if !(0x01 > 0x01) // Inputs[1] { @0965 stack[-4] } 0964 5B JUMPDEST 0965 83 DUP4 0966 60 PUSH1 0x01 0968 81 DUP2 0969 11 GT 096A 15 ISZERO 096B 61 PUSH2 0x099d 096E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0965 stack[0] = stack[-4] } // Block ends with conditional jump to 0x099d, if !(stack[-4] > 0x01) label_096F: // Incoming jump from 0x096E, if not !(stack[-4] > 0x01) // Inputs[1] { @099C memory[0x00:0x24] } 096F 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 0990 60 PUSH1 0x00 0992 52 MSTORE 0993 60 PUSH1 0x21 0995 60 PUSH1 0x04 0997 52 MSTORE 0998 60 PUSH1 0x24 099A 60 PUSH1 0x00 099C FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0992 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @0997 memory[0x04:0x24] = 0x21 // @099C revert(memory[0x00:0x24]); // } // Block terminates label_099D: // Incoming jump from 0x096E, if !(stack[-4] > 0x01) // Inputs[2] // { // @099E stack[-2] // @099E stack[-1] // } 099D 5B JUMPDEST 099E 14 EQ 099F 15 ISZERO 09A0 61 PUSH2 0x0a0e 09A3 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0a0e, if !(stack[-1] == stack[-2]) label_09A4: // Incoming jump from 0x09A3, if not !(stack[-1] == stack[-2]) // Inputs[4] // { // @09A4 stack[-4] // @09BB stack[-2] // @09BC stack[-1] // @09BF memory[0x40:0x60] // } 09A4 83 DUP4 09A5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09BA 16 AND 09BB 82 DUP3 09BC 82 DUP3 09BD 60 PUSH1 0x40 09BF 51 MLOAD 09C0 61 PUSH2 0x09ca 09C3 92 SWAP3 09C4 91 SWAP2 09C5 90 SWAP1 09C6 61 PUSH2 0x117b 09C9 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @09BA stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @09C3 stack[1] = 0x09ca // @09C4 stack[2] = stack[-2] // @09C5 stack[3] = stack[-1] // @09C5 stack[4] = memory[0x40:0x60] // } // Block ends with call to 0x117b, returns to 0x09CA label_09CA: // Incoming return from call to 0x117B at 0x09C9 // Inputs[7] // { // @09CF memory[0x40:0x60] // @09D1 stack[-1] // @09D4 stack[-2] // @09D5 msg.gas // @09D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @09D6 address(stack[-2]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @09DA returndata.length // } 09CA 5B JUMPDEST 09CB 60 PUSH1 0x00 09CD 60 PUSH1 0x40 09CF 51 MLOAD 09D0 80 DUP1 09D1 83 DUP4 09D2 03 SUB 09D3 81 DUP2 09D4 85 DUP6 09D5 5A GAS 09D6 F4 DELEGATECALL 09D7 91 SWAP2 09D8 50 POP 09D9 50 POP 09DA 3D RETURNDATASIZE 09DB 80 DUP1 09DC 60 PUSH1 0x00 09DE 81 DUP2 09DF 14 EQ 09E0 61 PUSH2 0x0a05 09E3 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @09D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-2]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @09D7 stack[-2] = address(stack[-2]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @09DA stack[-1] = returndata.length // @09DB stack[0] = returndata.length // } // Block ends with conditional jump to 0x0a05, if returndata.length == 0x00 label_09E4: // Incoming jump from 0x09E3, if not returndata.length == 0x00 // Inputs[6] // { // @09E6 memory[0x40:0x60] // @09E7 stack[-2] // @09EE returndata.length // @09F6 returndata.length // @09F9 returndata.length // @0A00 returndata[0x00:0x00 + returndata.length] // } 09E4 60 PUSH1 0x40 09E6 51 MLOAD 09E7 91 SWAP2 09E8 50 POP 09E9 60 PUSH1 0x1f 09EB 19 NOT 09EC 60 PUSH1 0x3f 09EE 3D RETURNDATASIZE 09EF 01 ADD 09F0 16 AND 09F1 82 DUP3 09F2 01 ADD 09F3 60 PUSH1 0x40 09F5 52 MSTORE 09F6 3D RETURNDATASIZE 09F7 82 DUP3 09F8 52 MSTORE 09F9 3D RETURNDATASIZE 09FA 60 PUSH1 0x00 09FC 60 PUSH1 0x20 09FE 84 DUP5 09FF 01 ADD 0A00 3E RETURNDATACOPY 0A01 61 PUSH2 0x0a0a 0A04 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @09E7 stack[-2] = memory[0x40:0x60] // @09F5 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @09F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0A00 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0a0a label_0A05: // Incoming jump from 0x09E3, if returndata.length == 0x00 // Inputs[1] { @0A08 stack[-2] } 0A05 5B JUMPDEST 0A06 60 PUSH1 0x60 0A08 91 SWAP2 0A09 50 POP 0A0A 5B JUMPDEST 0A0B 50 POP 0A0C 50 POP 0A0D 50 POP // Stack delta = -3 // Block continues label_0A0E: // Incoming jump from 0x0A0D // Incoming jump from 0x0A0D // Incoming jump from 0x09A3, if !(stack[-1] == stack[-2]) // Inputs[4] // { // @0A1B storage[0x03] // @0A36 storage[0x01] // @0A6F memory[0x40:0x60] // @0AA7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 0A0E 5B JUMPDEST 0A0F 5B JUMPDEST 0A10 60 PUSH1 0x00 0A12 60 PUSH1 0x03 0A14 60 PUSH1 0x01 0A16 61 PUSH2 0x0100 0A19 0A EXP 0A1A 81 DUP2 0A1B 54 SLOAD 0A1C 81 DUP2 0A1D 60 PUSH1 0xff 0A1F 02 MUL 0A20 19 NOT 0A21 16 AND 0A22 90 SWAP1 0A23 83 DUP4 0A24 15 ISZERO 0A25 15 ISZERO 0A26 02 MUL 0A27 17 OR 0A28 90 SWAP1 0A29 55 SSTORE 0A2A 50 POP 0A2B 60 PUSH1 0x00 0A2D 60 PUSH1 0x01 0A2F 60 PUSH1 0x00 0A31 61 PUSH2 0x0100 0A34 0A EXP 0A35 81 DUP2 0A36 54 SLOAD 0A37 81 DUP2 0A38 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A4D 02 MUL 0A4E 19 NOT 0A4F 16 AND 0A50 90 SWAP1 0A51 83 DUP4 0A52 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A67 16 AND 0A68 02 MUL 0A69 17 OR 0A6A 90 SWAP1 0A6B 55 SSTORE 0A6C 50 POP 0A6D 60 PUSH1 0x40 0A6F 51 MLOAD 0A70 80 DUP1 0A71 60 PUSH1 0x40 0A73 01 ADD 0A74 60 PUSH1 0x40 0A76 52 MSTORE 0A77 80 DUP1 0A78 60 PUSH1 0x02 0A7A 81 DUP2 0A7B 52 MSTORE 0A7C 60 PUSH1 0x20 0A7E 01 ADD 0A7F 7F PUSH32 0x3078000000000000000000000000000000000000000000000000000000000000 0AA0 81 DUP2 0AA1 52 MSTORE 0AA2 50 POP 0AA3 60 PUSH1 0x02 0AA5 90 SWAP1 0AA6 80 DUP1 0AA7 51 MLOAD 0AA8 90 SWAP1 0AA9 60 PUSH1 0x20 0AAB 01 ADD 0AAC 90 SWAP1 0AAD 61 PUSH2 0x0ab7 0AB0 92 SWAP3 0AB1 91 SWAP2 0AB2 90 SWAP1 0AB3 61 PUSH2 0x0d20 0AB6 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @0A29 storage[0x03] = !!0x00 * 0x0100 ** 0x01 | (~(0xff * 0x0100 ** 0x01) & storage[0x03]) // @0A6B storage[0x01] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x01]) // @0A76 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0A7B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x02 // @0AA1 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x3078000000000000000000000000000000000000000000000000000000000000 // @0AB0 stack[0] = 0x0ab7 // @0AB1 stack[1] = 0x02 // @0AB2 stack[2] = 0x20 + memory[0x40:0x60] // @0AB2 stack[3] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } // Block ends with call to 0x0d20, returns to 0x0AB7 label_0AB7: // Incoming return from call to 0x0D20 at 0x0AB6 // Incoming return from call to 0x0D20 at 0x0AB6 // Inputs[1] { @0AC4 storage[0x03] } 0AB7 5B JUMPDEST 0AB8 50 POP 0AB9 60 PUSH1 0x00 0ABB 60 PUSH1 0x03 0ABD 60 PUSH1 0x00 0ABF 61 PUSH2 0x0100 0AC2 0A EXP 0AC3 81 DUP2 0AC4 54 SLOAD 0AC5 81 DUP2 0AC6 60 PUSH1 0xff 0AC8 02 MUL 0AC9 19 NOT 0ACA 16 AND 0ACB 90 SWAP1 0ACC 83 DUP4 0ACD 60 PUSH1 0x01 0ACF 81 DUP2 0AD0 11 GT 0AD1 15 ISZERO 0AD2 61 PUSH2 0x0b04 0AD5 57 *JUMPI // Stack delta = +4 // Outputs[5] // { // @0AB9 stack[-1] = 0x00 // @0ABB stack[0] = 0x03 // @0ACB stack[2] = 0x0100 ** 0x00 // @0ACB stack[1] = ~(0xff * 0x0100 ** 0x00) & storage[0x03] // @0ACC stack[3] = 0x00 // } // Block ends with conditional jump to 0x0b04, if !(0x00 > 0x01) label_0AD6: // Incoming jump from 0x0AD5, if not !(0x00 > 0x01) // Inputs[1] { @0B03 memory[0x00:0x24] } 0AD6 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 0AF7 60 PUSH1 0x00 0AF9 52 MSTORE 0AFA 60 PUSH1 0x21 0AFC 60 PUSH1 0x04 0AFE 52 MSTORE 0AFF 60 PUSH1 0x24 0B01 60 PUSH1 0x00 0B03 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0AF9 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @0AFE memory[0x04:0x24] = 0x21 // @0B03 revert(memory[0x00:0x24]); // } // Block terminates label_0B04: // Incoming jump from 0x0AD5, if !(0x00 > 0x01) // Inputs[5] // { // @0B05 stack[-1] // @0B05 stack[-2] // @0B06 stack[-3] // @0B07 stack[-4] // @0B12 stack[-14] // } 0B04 5B JUMPDEST 0B05 02 MUL 0B06 17 OR 0B07 90 SWAP1 0B08 55 SSTORE 0B09 50 POP 0B0A 50 POP 0B0B 50 POP 0B0C 50 POP 0B0D 50 POP 0B0E 50 POP 0B0F 50 POP 0B10 50 POP 0B11 50 POP 0B12 56 *JUMP // Stack delta = -14 // Outputs[1] { @0B08 storage[stack[-4]] = stack[-1] * stack[-2] | stack[-3] } // Block ends with unconditional jump to stack[-14] label_0B13: // Incoming call from 0x0124, returns to 0x0125 // Inputs[2] // { // @0B19 storage[0x03] // @0B24 stack[-1] // } 0B13 5B JUMPDEST 0B14 60 PUSH1 0x03 0B16 60 PUSH1 0x00 0B18 90 SWAP1 0B19 54 SLOAD 0B1A 90 SWAP1 0B1B 61 PUSH2 0x0100 0B1E 0A EXP 0B1F 90 SWAP1 0B20 04 DIV 0B21 60 PUSH1 0xff 0B23 16 AND 0B24 81 DUP2 0B25 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B23 stack[0] = 0xff & storage[0x03] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0B26: // Incoming call from 0x0142, returns to 0x0143 // Inputs[1] { @0B2A storage[0x02] } 0B26 5B JUMPDEST 0B27 60 PUSH1 0x02 0B29 80 DUP1 0B2A 54 SLOAD 0B2B 61 PUSH2 0x0b33 0B2E 90 SWAP1 0B2F 61 PUSH2 0x137e 0B32 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B27 stack[0] = 0x02 // @0B2E stack[1] = 0x0b33 // @0B2E stack[2] = storage[0x02] // } // Block ends with call to 0x137e, returns to 0x0B33 label_0B33: // Incoming return from call to 0x137E at 0x0B32 // Inputs[4] // { // @0B34 stack[-1] // @0B43 memory[0x40:0x60] // @0B4B stack[-2] // @0B56 storage[stack[-2]] // } 0B33 5B JUMPDEST 0B34 80 DUP1 0B35 60 PUSH1 0x1f 0B37 01 ADD 0B38 60 PUSH1 0x20 0B3A 80 DUP1 0B3B 91 SWAP2 0B3C 04 DIV 0B3D 02 MUL 0B3E 60 PUSH1 0x20 0B40 01 ADD 0B41 60 PUSH1 0x40 0B43 51 MLOAD 0B44 90 SWAP1 0B45 81 DUP2 0B46 01 ADD 0B47 60 PUSH1 0x40 0B49 52 MSTORE 0B4A 80 DUP1 0B4B 92 SWAP3 0B4C 91 SWAP2 0B4D 90 SWAP1 0B4E 81 DUP2 0B4F 81 DUP2 0B50 52 MSTORE 0B51 60 PUSH1 0x20 0B53 01 ADD 0B54 82 DUP3 0B55 80 DUP1 0B56 54 SLOAD 0B57 61 PUSH2 0x0b5f 0B5A 90 SWAP1 0B5B 61 PUSH2 0x137e 0B5E 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0B49 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0B4B stack[-2] = memory[0x40:0x60] // @0B4C stack[-1] = stack[-2] // @0B4D stack[0] = stack[-1] // @0B50 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0B53 stack[1] = 0x20 + memory[0x40:0x60] // @0B54 stack[2] = stack[-2] // @0B5A stack[4] = storage[stack[-2]] // @0B5A stack[3] = 0x0b5f // } // Block ends with call to 0x137e, returns to 0x0B5F label_0B5F: // Incoming return from call to 0x137E at 0x0B5E // Inputs[1] { @0B60 stack[-1] } 0B5F 5B JUMPDEST 0B60 80 DUP1 0B61 15 ISZERO 0B62 61 PUSH2 0x0bac 0B65 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bac, if !stack[-1] label_0B66: // Incoming jump from 0x0B65, if not !stack[-1] // Inputs[1] { @0B66 stack[-1] } 0B66 80 DUP1 0B67 60 PUSH1 0x1f 0B69 10 LT 0B6A 61 PUSH2 0x0b81 0B6D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b81, if 0x1f < stack[-1] label_0B6E: // Incoming jump from 0x0B6D, if not 0x1f < stack[-1] // Inputs[4] // { // @0B72 stack[-2] // @0B73 storage[stack[-2]] // @0B76 stack[-3] // @0B78 stack[-1] // } 0B6E 61 PUSH2 0x0100 0B71 80 DUP1 0B72 83 DUP4 0B73 54 SLOAD 0B74 04 DIV 0B75 02 MUL 0B76 83 DUP4 0B77 52 MSTORE 0B78 91 SWAP2 0B79 60 PUSH1 0x20 0B7B 01 ADD 0B7C 91 SWAP2 0B7D 61 PUSH2 0x0bac 0B80 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0B77 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0B7C stack[-1] = stack[-1] // @0B7C stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0bac label_0B81: // Incoming jump from 0x0B6D, if 0x1f < stack[-1] // Inputs[5] // { // @0B82 stack[-3] // @0B83 stack[-1] // @0B85 stack[-2] // @0B8D memory[0x00:0x20] // @0B91 storage[keccak256(memory[0x00:0x20])] // } 0B81 5B JUMPDEST 0B82 82 DUP3 0B83 01 ADD 0B84 91 SWAP2 0B85 90 SWAP1 0B86 60 PUSH1 0x00 0B88 52 MSTORE 0B89 60 PUSH1 0x20 0B8B 60 PUSH1 0x00 0B8D 20 SHA3 0B8E 90 SWAP1 0B8F 5B JUMPDEST 0B90 81 DUP2 0B91 54 SLOAD 0B92 81 DUP2 0B93 52 MSTORE 0B94 90 SWAP1 0B95 60 PUSH1 0x01 0B97 01 ADD 0B98 90 SWAP1 0B99 60 PUSH1 0x20 0B9B 01 ADD 0B9C 80 DUP1 0B9D 83 DUP4 0B9E 11 GT 0B9F 61 PUSH2 0x0b8f 0BA2 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0B84 stack[-3] = stack[-3] + stack[-1] // @0B88 memory[0x00:0x20] = stack[-2] // @0B93 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0B98 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0B9B stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0b8f, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0BA3: // Incoming jump from 0x0BA2, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0BA2, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0BA3 stack[-3] // @0BA4 stack[-1] // } 0BA3 82 DUP3 0BA4 90 SWAP1 0BA5 03 SUB 0BA6 60 PUSH1 0x1f 0BA8 16 AND 0BA9 82 DUP3 0BAA 01 ADD 0BAB 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0BAB stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0BAB stack[-1] = stack[-3] // } // Block continues label_0BAC: // Incoming jump from 0x0BAB // Incoming jump from 0x0B80 // Incoming jump from 0x0B65, if !stack[-1] // Inputs[1] { @0BB2 stack[-7] } 0BAC 5B JUMPDEST 0BAD 50 POP 0BAE 50 POP 0BAF 50 POP 0BB0 50 POP 0BB1 50 POP 0BB2 81 DUP2 0BB3 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0BB4: // Incoming call from 0x0160, returns to 0x0161 // Inputs[2] // { // @0BB8 storage[0x00] // @0BD6 stack[-1] // } 0BB4 5B JUMPDEST 0BB5 60 PUSH1 0x00 0BB7 80 DUP1 0BB8 54 SLOAD 0BB9 90 SWAP1 0BBA 61 PUSH2 0x0100 0BBD 0A EXP 0BBE 90 SWAP1 0BBF 04 DIV 0BC0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BD5 16 AND 0BD6 81 DUP2 0BD7 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BD5 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x00] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0BD8: // Incoming call from 0x0288, returns to 0x0289 // Incoming call from 0x0556, returns to 0x0557 // Incoming call from 0x067B, returns to 0x067C // Incoming call from 0x0782, returns to 0x0783 // Inputs[2] // { // @0BDC stack[-1] // @0BDF memory[0x40:0x60] // } 0BD8 5B JUMPDEST 0BD9 61 PUSH2 0x0c6e 0BDC 81 DUP2 0BDD 60 PUSH1 0x40 0BDF 51 MLOAD 0BE0 60 PUSH1 0x24 0BE2 01 ADD 0BE3 61 PUSH2 0x0bec 0BE6 91 SWAP2 0BE7 90 SWAP1 0BE8 61 PUSH2 0x121e 0BEB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0BD9 stack[0] = 0x0c6e // @0BE6 stack[1] = 0x0bec // @0BE7 stack[2] = stack[-1] // @0BE7 stack[3] = 0x24 + memory[0x40:0x60] // } // Block ends with call to 0x121e, returns to 0x0BEC label_0BEC: // Incoming return from call to 0x121E at 0x0BEB // Inputs[3] // { // @0BEF memory[0x40:0x60] // @0BF3 stack[-1] // @0C41 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // } 0BEC 5B JUMPDEST 0BED 60 PUSH1 0x40 0BEF 51 MLOAD 0BF0 60 PUSH1 0x20 0BF2 81 DUP2 0BF3 83 DUP4 0BF4 03 SUB 0BF5 03 SUB 0BF6 81 DUP2 0BF7 52 MSTORE 0BF8 90 SWAP1 0BF9 60 PUSH1 0x40 0BFB 52 MSTORE 0BFC 7F PUSH32 0x41304fac00000000000000000000000000000000000000000000000000000000 0C1D 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0C3A 19 NOT 0C3B 16 AND 0C3C 60 PUSH1 0x20 0C3E 82 DUP3 0C3F 01 ADD 0C40 80 DUP1 0C41 51 MLOAD 0C42 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0C5F 83 DUP4 0C60 81 DUP2 0C61 83 DUP4 0C62 16 AND 0C63 17 OR 0C64 83 DUP4 0C65 52 MSTORE 0C66 50 POP 0C67 50 POP 0C68 50 POP 0C69 50 POP 0C6A 61 PUSH2 0x0c71 0C6D 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0BF7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @0BF8 stack[-1] = memory[0x40:0x60] // @0BFB memory[0x40:0x60] = stack[-1] // @0C65 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff) | (~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0x41304fac00000000000000000000000000000000000000000000000000000000) // } // Block ends with unconditional jump to 0x0c71 label_0C6E: // Incoming return from call to 0x0BEC at 0x0BEB // Inputs[1] { @0C70 stack[-2] } 0C6E 5B JUMPDEST 0C6F 50 POP 0C70 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0C71: // Incoming jump from 0x0C6D // Inputs[6] // { // @0C74 stack[-1] // @0C75 memory[stack[-1]:stack[-1] + 0x20] // @0C92 msg.gas // @0C93 address(0x636f6e736f6c652e6c6f67).staticcall.gas(msg.gas)(memory[stack[-1] + 0x20:stack[-1] + 0x20 + memory[stack[-1]:stack[-1] + 0x20]]) // @0C93 memory[stack[-1] + 0x20:stack[-1] + 0x20 + memory[stack[-1]:stack[-1] + 0x20]] // @0C99 stack[-2] // } 0C71 5B JUMPDEST 0C72 60 PUSH1 0x00 0C74 81 DUP2 0C75 51 MLOAD 0C76 90 SWAP1 0C77 50 POP 0C78 60 PUSH1 0x00 0C7A 6A PUSH11 0x636f6e736f6c652e6c6f67 0C86 90 SWAP1 0C87 50 POP 0C88 60 PUSH1 0x20 0C8A 83 DUP4 0C8B 01 ADD 0C8C 60 PUSH1 0x00 0C8E 80 DUP1 0C8F 84 DUP5 0C90 83 DUP4 0C91 85 DUP6 0C92 5A GAS 0C93 FA STATICCALL 0C94 50 POP 0C95 50 POP 0C96 50 POP 0C97 50 POP 0C98 50 POP 0C99 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C93 memory[0x00:0x00] = address(0x636f6e736f6c652e6c6f67).staticcall.gas(msg.gas)(memory[stack[-1] + 0x20:stack[-1] + 0x20 + memory[stack[-1]:stack[-1] + 0x20]]) } // Block ends with unconditional jump to stack[-2] label_0C9A: // Incoming call from 0x07EF, returns to 0x07F0 // Inputs[2] // { // @0C9B stack[-3] // @0C9D storage[stack[-3]] // } 0C9A 5B JUMPDEST 0C9B 82 DUP3 0C9C 80 DUP1 0C9D 54 SLOAD 0C9E 61 PUSH2 0x0ca6 0CA1 90 SWAP1 0CA2 61 PUSH2 0x137e 0CA5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C9B stack[0] = stack[-3] // @0CA1 stack[1] = 0x0ca6 // @0CA1 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x137e, returns to 0x0CA6 label_0CA6: // Incoming return from call to 0x137E at 0x0CA5 // Inputs[5] // { // @0CA7 stack[-1] // @0CA7 stack[-2] // @0CAF memory[0x00:0x20] // @0CBA stack[-4] // @0CBB stack[-3] // } 0CA6 5B JUMPDEST 0CA7 90 SWAP1 0CA8 60 PUSH1 0x00 0CAA 52 MSTORE 0CAB 60 PUSH1 0x20 0CAD 60 PUSH1 0x00 0CAF 20 SHA3 0CB0 90 SWAP1 0CB1 60 PUSH1 0x1f 0CB3 01 ADD 0CB4 60 PUSH1 0x20 0CB6 90 SWAP1 0CB7 04 DIV 0CB8 81 DUP2 0CB9 01 ADD 0CBA 92 SWAP3 0CBB 82 DUP3 0CBC 61 PUSH2 0x0cc8 0CBF 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0CAA memory[0x00:0x20] = stack[-2] // @0CB0 stack[-2] = keccak256(memory[0x00:0x20]) // @0CBA stack[-1] = stack[-4] // @0CBA stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x0cc8, if stack[-3] label_0CC0: // Incoming jump from 0x0CBF, if not stack[-3] // Inputs[1] { @0CC2 stack[-5] } 0CC0 60 PUSH1 0x00 0CC2 85 DUP6 0CC3 55 SSTORE 0CC4 61 PUSH2 0x0d0f 0CC7 56 *JUMP // Stack delta = +0 // Outputs[1] { @0CC3 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x0d0f label_0CC8: // Incoming jump from 0x0CBF, if stack[-3] // Inputs[1] { @0CC9 stack[-3] } 0CC8 5B JUMPDEST 0CC9 82 DUP3 0CCA 60 PUSH1 0x1f 0CCC 10 LT 0CCD 61 PUSH2 0x0ce1 0CD0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ce1, if 0x1f < stack[-3] label_0CD1: // Incoming jump from 0x0CD0, if not 0x1f < stack[-3] // Inputs[4] // { // @0CD1 stack[-1] // @0CD2 msg.data[stack[-1]:stack[-1] + 0x20] // @0CD7 stack[-3] // @0CDB stack[-5] // } 0CD1 80 DUP1 0CD2 35 CALLDATALOAD 0CD3 60 PUSH1 0xff 0CD5 19 NOT 0CD6 16 AND 0CD7 83 DUP4 0CD8 80 DUP1 0CD9 01 ADD 0CDA 17 OR 0CDB 85 DUP6 0CDC 55 SSTORE 0CDD 61 PUSH2 0x0d0f 0CE0 56 *JUMP // Stack delta = +0 // Outputs[1] { @0CDC storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & msg.data[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x0d0f label_0CE1: // Incoming jump from 0x0CD0, if 0x1f < stack[-3] // Inputs[2] // { // @0CE2 stack[-3] // @0CE8 stack[-5] // } 0CE1 5B JUMPDEST 0CE2 82 DUP3 0CE3 80 DUP1 0CE4 01 ADD 0CE5 60 PUSH1 0x01 0CE7 01 ADD 0CE8 85 DUP6 0CE9 55 SSTORE 0CEA 82 DUP3 0CEB 15 ISZERO 0CEC 61 PUSH2 0x0d0f 0CEF 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0CE9 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x0d0f, if !stack[-3] label_0CF0: // Incoming jump from 0x0CEF, if not !stack[-3] // Inputs[2] // { // @0CF0 stack[-1] // @0CF0 stack[-3] // } 0CF0 91 SWAP2 0CF1 82 DUP3 0CF2 01 ADD 0CF3 5B JUMPDEST 0CF4 82 DUP3 0CF5 81 DUP2 0CF6 11 GT 0CF7 15 ISZERO 0CF8 61 PUSH2 0x0d0e 0CFB 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0CF0 stack[-3] = stack[-1] // @0CF2 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x0d0e, if !(stack[-1] + stack[-3] > stack[-1]) label_0CFC: // Incoming jump from 0x0CFB, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x0CFB, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @0CFC stack[-3] // @0CFD msg.data[stack[-3]:stack[-3] + 0x20] // @0CFE stack[-2] // @0D00 stack[-1] // } 0CFC 82 DUP3 0CFD 35 CALLDATALOAD 0CFE 82 DUP3 0CFF 55 SSTORE 0D00 91 SWAP2 0D01 60 PUSH1 0x20 0D03 01 ADD 0D04 91 SWAP2 0D05 90 SWAP1 0D06 60 PUSH1 0x01 0D08 01 ADD 0D09 90 SWAP1 0D0A 61 PUSH2 0x0cf3 0D0D 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0CFF storage[stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20] // @0D04 stack[-3] = 0x20 + stack[-3] // @0D09 stack[-2] = 0x01 + stack[-2] // @0D09 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x0cf3 label_0D0E: // Incoming jump from 0x0CFB, if !(stack[-1] > stack[-3]) // Incoming jump from 0x0CFB, if !(stack[-1] + stack[-3] > stack[-1]) 0D0E 5B JUMPDEST // Stack delta = +0 // Block continues label_0D0F: // Incoming jump from 0x0CC7 // Incoming jump from 0x0D0E // Incoming jump from 0x0CEF, if !stack[-3] // Incoming jump from 0x0CE0 // Inputs[3] // { // @0D11 stack[-3] // @0D11 stack[-2] // @0D16 stack[-4] // } 0D0F 5B JUMPDEST 0D10 50 POP 0D11 90 SWAP1 0D12 50 POP 0D13 61 PUSH2 0x0d1c 0D16 91 SWAP2 0D17 90 SWAP1 0D18 61 PUSH2 0x0da6 0D1B 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0D16 stack[-4] = 0x0d1c // @0D17 stack[-2] = stack[-2] // @0D17 stack[-3] = stack[-4] // } // Block ends with call to 0x0da6, returns to 0x0D1C label_0D1C: // Incoming return from call to 0x0DA6 at 0x0D1B // Inputs[2] // { // @0D1E stack[-2] // @0D1E stack[-3] // } 0D1C 5B JUMPDEST 0D1D 50 POP 0D1E 90 SWAP1 0D1F 56 *JUMP // Stack delta = -2 // Outputs[1] { @0D1E stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_0D20: // Incoming call from 0x0AB6, returns to 0x0AB7 // Incoming call from 0x0AB6, returns to 0x0AB7 // Inputs[2] // { // @0D21 stack[-3] // @0D23 storage[stack[-3]] // } 0D20 5B JUMPDEST 0D21 82 DUP3 0D22 80 DUP1 0D23 54 SLOAD 0D24 61 PUSH2 0x0d2c 0D27 90 SWAP1 0D28 61 PUSH2 0x137e 0D2B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D21 stack[0] = stack[-3] // @0D27 stack[1] = 0x0d2c // @0D27 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x137e, returns to 0x0D2C label_0D2C: // Incoming return from call to 0x137E at 0x0D2B // Inputs[5] // { // @0D2D stack[-1] // @0D2D stack[-2] // @0D35 memory[0x00:0x20] // @0D40 stack[-4] // @0D41 stack[-3] // } 0D2C 5B JUMPDEST 0D2D 90 SWAP1 0D2E 60 PUSH1 0x00 0D30 52 MSTORE 0D31 60 PUSH1 0x20 0D33 60 PUSH1 0x00 0D35 20 SHA3 0D36 90 SWAP1 0D37 60 PUSH1 0x1f 0D39 01 ADD 0D3A 60 PUSH1 0x20 0D3C 90 SWAP1 0D3D 04 DIV 0D3E 81 DUP2 0D3F 01 ADD 0D40 92 SWAP3 0D41 82 DUP3 0D42 61 PUSH2 0x0d4e 0D45 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0D30 memory[0x00:0x20] = stack[-2] // @0D36 stack[-2] = keccak256(memory[0x00:0x20]) // @0D40 stack[-1] = stack[-4] // @0D40 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x0d4e, if stack[-3] label_0D46: // Incoming jump from 0x0D45, if not stack[-3] // Inputs[1] { @0D48 stack[-5] } 0D46 60 PUSH1 0x00 0D48 85 DUP6 0D49 55 SSTORE 0D4A 61 PUSH2 0x0d95 0D4D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0D49 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x0d95 label_0D4E: // Incoming jump from 0x0D45, if stack[-3] // Inputs[1] { @0D4F stack[-3] } 0D4E 5B JUMPDEST 0D4F 82 DUP3 0D50 60 PUSH1 0x1f 0D52 10 LT 0D53 61 PUSH2 0x0d67 0D56 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d67, if 0x1f < stack[-3] label_0D57: // Incoming jump from 0x0D56, if not 0x1f < stack[-3] // Inputs[4] // { // @0D57 stack[-1] // @0D58 memory[stack[-1]:stack[-1] + 0x20] // @0D5D stack[-3] // @0D61 stack[-5] // } 0D57 80 DUP1 0D58 51 MLOAD 0D59 60 PUSH1 0xff 0D5B 19 NOT 0D5C 16 AND 0D5D 83 DUP4 0D5E 80 DUP1 0D5F 01 ADD 0D60 17 OR 0D61 85 DUP6 0D62 55 SSTORE 0D63 61 PUSH2 0x0d95 0D66 56 *JUMP // Stack delta = +0 // Outputs[1] { @0D62 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x0d95 label_0D67: // Incoming jump from 0x0D56, if 0x1f < stack[-3] // Inputs[2] // { // @0D68 stack[-3] // @0D6E stack[-5] // } 0D67 5B JUMPDEST 0D68 82 DUP3 0D69 80 DUP1 0D6A 01 ADD 0D6B 60 PUSH1 0x01 0D6D 01 ADD 0D6E 85 DUP6 0D6F 55 SSTORE 0D70 82 DUP3 0D71 15 ISZERO 0D72 61 PUSH2 0x0d95 0D75 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0D6F storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x0d95, if !stack[-3] label_0D76: // Incoming jump from 0x0D75, if not !stack[-3] // Inputs[2] // { // @0D76 stack[-3] // @0D76 stack[-1] // } 0D76 91 SWAP2 0D77 82 DUP3 0D78 01 ADD 0D79 5B JUMPDEST 0D7A 82 DUP3 0D7B 81 DUP2 0D7C 11 GT 0D7D 15 ISZERO 0D7E 61 PUSH2 0x0d94 0D81 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0D76 stack[-3] = stack[-1] // @0D78 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x0d94, if !(stack[-1] + stack[-3] > stack[-1]) label_0D82: // Incoming jump from 0x0D81, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x0D81, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @0D82 stack[-3] // @0D83 memory[stack[-3]:stack[-3] + 0x20] // @0D84 stack[-2] // @0D86 stack[-1] // } 0D82 82 DUP3 0D83 51 MLOAD 0D84 82 DUP3 0D85 55 SSTORE 0D86 91 SWAP2 0D87 60 PUSH1 0x20 0D89 01 ADD 0D8A 91 SWAP2 0D8B 90 SWAP1 0D8C 60 PUSH1 0x01 0D8E 01 ADD 0D8F 90 SWAP1 0D90 61 PUSH2 0x0d79 0D93 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0D85 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @0D8A stack[-3] = 0x20 + stack[-3] // @0D8F stack[-2] = 0x01 + stack[-2] // @0D8F stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x0d79 label_0D94: // Incoming jump from 0x0D81, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x0D81, if !(stack[-1] > stack[-3]) 0D94 5B JUMPDEST // Stack delta = +0 // Block continues label_0D95: // Incoming jump from 0x0D75, if !stack[-3] // Incoming jump from 0x0D66 // Incoming jump from 0x0D94 // Incoming jump from 0x0D4D // Inputs[3] // { // @0D97 stack[-2] // @0D97 stack[-3] // @0D9C stack[-4] // } 0D95 5B JUMPDEST 0D96 50 POP 0D97 90 SWAP1 0D98 50 POP 0D99 61 PUSH2 0x0da2 0D9C 91 SWAP2 0D9D 90 SWAP1 0D9E 61 PUSH2 0x0da6 0DA1 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0D9C stack[-4] = 0x0da2 // @0D9D stack[-2] = stack[-2] // @0D9D stack[-3] = stack[-4] // } // Block ends with call to 0x0da6, returns to 0x0DA2 label_0DA2: // Incoming return from call to 0x0DA6 at 0x0DA1 // Inputs[2] // { // @0DA4 stack[-3] // @0DA4 stack[-2] // } 0DA2 5B JUMPDEST 0DA3 50 POP 0DA4 90 SWAP1 0DA5 56 *JUMP // Stack delta = -2 // Outputs[1] { @0DA4 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_0DA6: // Incoming call from 0x0D1B, returns to 0x0D1C // Incoming call from 0x0DA1, returns to 0x0DA2 // Inputs[2] // { // @0DA8 stack[-1] // @0DA9 stack[-2] // } 0DA6 5B JUMPDEST 0DA7 5B JUMPDEST 0DA8 80 DUP1 0DA9 82 DUP3 0DAA 11 GT 0DAB 15 ISZERO 0DAC 61 PUSH2 0x0dbf 0DAF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dbf, if !(stack[-2] > stack[-1]) label_0DB0: // Incoming jump from 0x0DAF, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x0DAF, if not !(stack[-2] > stack[-1]) // Inputs[1] { @0DB2 stack[-1] } 0DB0 60 PUSH1 0x00 0DB2 81 DUP2 0DB3 60 PUSH1 0x00 0DB5 90 SWAP1 0DB6 55 SSTORE 0DB7 50 POP 0DB8 60 PUSH1 0x01 0DBA 01 ADD 0DBB 61 PUSH2 0x0da7 0DBE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0DB6 storage[stack[-1]] = 0x00 // @0DBA stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x0da7 label_0DBF: // Incoming jump from 0x0DAF, if !(stack[-2] > stack[-1]) // Incoming jump from 0x0DAF, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @0DC1 stack[-2] // @0DC1 stack[-3] // } 0DBF 5B JUMPDEST 0DC0 50 POP 0DC1 90 SWAP1 0DC2 56 *JUMP // Stack delta = -2 // Outputs[1] { @0DC1 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_0DC3: // Incoming call from 0x0EAA, returns to 0x0EAB // Inputs[1] { @0DCC stack[-2] } 0DC3 5B JUMPDEST 0DC4 60 PUSH1 0x00 0DC6 61 PUSH2 0x0dd6 0DC9 61 PUSH2 0x0dd1 0DCC 84 DUP5 0DCD 61 PUSH2 0x1265 0DD0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0DC4 stack[0] = 0x00 // @0DC6 stack[1] = 0x0dd6 // @0DC9 stack[2] = 0x0dd1 // @0DCC stack[3] = stack[-2] // } // Block ends with call to 0x1265, returns to 0x0DD1 label_0DD1: // Incoming return from call to 0x1265 at 0x0DD0 0DD1 5B JUMPDEST 0DD2 61 PUSH2 0x1240 0DD5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1240 label_0DD6: // Incoming return from call to 0x0DD1 at 0x0DD0 // Inputs[5] // { // @0DD7 stack[-1] // @0DD7 stack[-2] // @0DD9 stack[-4] // @0DE0 stack[-5] // @0DE2 stack[-3] // } 0DD6 5B JUMPDEST 0DD7 90 SWAP1 0DD8 50 POP 0DD9 82 DUP3 0DDA 81 DUP2 0DDB 52 MSTORE 0DDC 60 PUSH1 0x20 0DDE 81 DUP2 0DDF 01 ADD 0DE0 84 DUP5 0DE1 84 DUP5 0DE2 84 DUP5 0DE3 01 ADD 0DE4 11 GT 0DE5 15 ISZERO 0DE6 61 PUSH2 0x0dee 0DE9 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @0DD7 stack[-2] = stack[-1] // @0DDB memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @0DDF stack[-1] = stack[-1] + 0x20 // } // Block ends with conditional jump to 0x0dee, if !(stack[-3] + stack[-4] > stack[-5]) label_0DEA: // Incoming jump from 0x0DE9, if not !(stack[-3] + stack[-4] > stack[-5]) // Inputs[1] { @0DED memory[0x00:0x00] } 0DEA 60 PUSH1 0x00 0DEC 80 DUP1 0DED FD *REVERT // Stack delta = +0 // Outputs[1] { @0DED revert(memory[0x00:0x00]); } // Block terminates label_0DEE: // Incoming jump from 0x0DE9, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[3] // { // @0DF2 stack[-4] // @0DF3 stack[-1] // @0DF4 stack[-3] // } 0DEE 5B JUMPDEST 0DEF 61 PUSH2 0x0df9 0DF2 84 DUP5 0DF3 82 DUP3 0DF4 85 DUP6 0DF5 61 PUSH2 0x134b 0DF8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0DEF stack[0] = 0x0df9 // @0DF2 stack[1] = stack[-4] // @0DF3 stack[2] = stack[-1] // @0DF4 stack[3] = stack[-3] // } // Block ends with call to 0x134b, returns to 0x0DF9 label_0DF9: // Incoming return from call to 0x134B at 0x0DF8 // Inputs[3] // { // @0DFB stack[-6] // @0DFB stack[-2] // @0DFC stack[-5] // } 0DF9 5B JUMPDEST 0DFA 50 POP 0DFB 93 SWAP4 0DFC 92 SWAP3 0DFD 50 POP 0DFE 50 POP 0DFF 50 POP 0E00 56 *JUMP // Stack delta = -5 // Outputs[1] { @0DFB stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_0E01: // Incoming call from 0x0EFD, returns to 0x0EFE // Incoming call from 0x0F59, returns to 0x0F5A // Incoming call from 0x0FA6, returns to 0x0FA7 // Inputs[2] // { // @0E04 stack[-1] // @0E05 msg.data[stack[-1]:stack[-1] + 0x20] // } 0E01 5B JUMPDEST 0E02 60 PUSH1 0x00 0E04 81 DUP2 0E05 35 CALLDATALOAD 0E06 90 SWAP1 0E07 50 POP 0E08 61 PUSH2 0x0e10 0E0B 81 DUP2 0E0C 61 PUSH2 0x1493 0E0F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E06 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @0E08 stack[1] = 0x0e10 // @0E0B stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x1493, returns to 0x0E10 label_0E10: // Incoming return from call to 0x1493 at 0x0E0F // Inputs[3] // { // @0E11 stack[-4] // @0E11 stack[-1] // @0E12 stack[-3] // } 0E10 5B JUMPDEST 0E11 92 SWAP3 0E12 91 SWAP2 0E13 50 POP 0E14 50 POP 0E15 56 *JUMP // Stack delta = -3 // Outputs[1] { @0E11 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0E16: // Incoming call from 0x0F26, returns to 0x0F27 // Inputs[2] // { // @0E19 stack[-1] // @0E1A memory[stack[-1]:stack[-1] + 0x20] // } 0E16 5B JUMPDEST 0E17 60 PUSH1 0x00 0E19 81 DUP2 0E1A 51 MLOAD 0E1B 90 SWAP1 0E1C 50 POP 0E1D 61 PUSH2 0x0e25 0E20 81 DUP2 0E21 61 PUSH2 0x1493 0E24 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E1B stack[0] = memory[stack[-1]:stack[-1] + 0x20] // @0E1D stack[1] = 0x0e25 // @0E20 stack[2] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x1493, returns to 0x0E25 label_0E25: // Incoming return from call to 0x1493 at 0x0E24 // Inputs[3] // { // @0E26 stack[-1] // @0E26 stack[-4] // @0E27 stack[-3] // } 0E25 5B JUMPDEST 0E26 92 SWAP3 0E27 91 SWAP2 0E28 50 POP 0E29 50 POP 0E2A 56 *JUMP // Stack delta = -3 // Outputs[1] { @0E26 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0E2B: // Incoming call from 0x1012, returns to 0x1013 // Inputs[2] // { // @0E2E stack[-1] // @0E2F memory[stack[-1]:stack[-1] + 0x20] // } 0E2B 5B JUMPDEST 0E2C 60 PUSH1 0x00 0E2E 81 DUP2 0E2F 51 MLOAD 0E30 90 SWAP1 0E31 50 POP 0E32 61 PUSH2 0x0e3a 0E35 81 DUP2 0E36 61 PUSH2 0x14aa 0E39 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E30 stack[0] = memory[stack[-1]:stack[-1] + 0x20] // @0E32 stack[1] = 0x0e3a // @0E35 stack[2] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x14aa, returns to 0x0E3A label_0E3A: // Incoming return from call to 0x14AA at 0x0E39 // Inputs[3] // { // @0E3B stack[-1] // @0E3B stack[-4] // @0E3C stack[-3] // } 0E3A 5B JUMPDEST 0E3B 92 SWAP3 0E3C 91 SWAP2 0E3D 50 POP 0E3E 50 POP 0E3F 56 *JUMP // Stack delta = -3 // Outputs[1] { @0E3B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0E40: // Incoming call from 0x0FE0, returns to 0x0FE1 // Incoming call from 0x0F93, returns to 0x0F94 // Inputs[2] // { // @0E44 stack[-2] // @0E47 stack[-1] // } 0E40 5B JUMPDEST 0E41 60 PUSH1 0x00 0E43 80 DUP1 0E44 83 DUP4 0E45 60 PUSH1 0x1f 0E47 84 DUP5 0E48 01 ADD 0E49 12 SLT 0E4A 61 PUSH2 0x0e52 0E4D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0E41 stack[0] = 0x00 // @0E43 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0e52, if stack[-1] + 0x1f i< stack[-2] label_0E4E: // Incoming jump from 0x0E4D, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @0E51 memory[0x00:0x00] } 0E4E 60 PUSH1 0x00 0E50 80 DUP1 0E51 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E51 revert(memory[0x00:0x00]); } // Block terminates label_0E52: // Incoming jump from 0x0E4D, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @0E53 stack[-3] // @0E54 msg.data[stack[-3]:stack[-3] + 0x20] // @0E55 stack[-1] // } 0E52 5B JUMPDEST 0E53 82 DUP3 0E54 35 CALLDATALOAD 0E55 90 SWAP1 0E56 50 POP 0E57 67 PUSH8 0xffffffffffffffff 0E60 81 DUP2 0E61 11 GT 0E62 15 ISZERO 0E63 61 PUSH2 0x0e6b 0E66 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0E55 stack[-1] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x0e6b, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_0E67: // Incoming jump from 0x0E66, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @0E6A memory[0x00:0x00] } 0E67 60 PUSH1 0x00 0E69 80 DUP1 0E6A FD *REVERT // Stack delta = +0 // Outputs[1] { @0E6A revert(memory[0x00:0x00]); } // Block terminates label_0E6B: // Incoming jump from 0x0E66, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[4] // { // @0E6E stack[-3] // @0E70 stack[-2] // @0E72 stack[-4] // @0E75 stack[-1] // } 0E6B 5B JUMPDEST 0E6C 60 PUSH1 0x20 0E6E 83 DUP4 0E6F 01 ADD 0E70 91 SWAP2 0E71 50 POP 0E72 83 DUP4 0E73 60 PUSH1 0x01 0E75 82 DUP3 0E76 02 MUL 0E77 83 DUP4 0E78 01 ADD 0E79 11 GT 0E7A 15 ISZERO 0E7B 61 PUSH2 0x0e83 0E7E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0E70 stack[-2] = stack[-3] + 0x20 } // Block ends with conditional jump to 0x0e83, if !(stack[-3] + 0x20 + stack[-1] * 0x01 > stack[-4]) label_0E7F: // Incoming jump from 0x0E7E, if not !(stack[-3] + 0x20 + stack[-1] * 0x01 > stack[-4]) // Inputs[1] { @0E82 memory[0x00:0x00] } 0E7F 60 PUSH1 0x00 0E81 80 DUP1 0E82 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E82 revert(memory[0x00:0x00]); } // Block terminates label_0E83: // Incoming jump from 0x0E7E, if !(stack[-3] + 0x20 + stack[-1] * 0x01 > stack[-4]) // Inputs[5] // { // @0E84 stack[-4] // @0E84 stack[-1] // @0E86 stack[-5] // @0E86 stack[-2] // @0E87 stack[-3] // } 0E83 5B JUMPDEST 0E84 92 SWAP3 0E85 50 POP 0E86 92 SWAP3 0E87 90 SWAP1 0E88 50 POP 0E89 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0E84 stack[-4] = stack[-1] // @0E86 stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_0E8A: // Incoming call from 0x1053, returns to 0x1054 // Inputs[2] // { // @0E8D stack[-2] // @0E90 stack[-1] // } 0E8A 5B JUMPDEST 0E8B 60 PUSH1 0x00 0E8D 82 DUP3 0E8E 60 PUSH1 0x1f 0E90 83 DUP4 0E91 01 ADD 0E92 12 SLT 0E93 61 PUSH2 0x0e9b 0E96 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E8B stack[0] = 0x00 } // Block ends with conditional jump to 0x0e9b, if stack[-1] + 0x1f i< stack[-2] label_0E97: // Incoming jump from 0x0E96, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @0E9A memory[0x00:0x00] } 0E97 60 PUSH1 0x00 0E99 80 DUP1 0E9A FD *REVERT // Stack delta = +0 // Outputs[1] { @0E9A revert(memory[0x00:0x00]); } // Block terminates label_0E9B: // Incoming jump from 0x0E96, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @0E9C stack[-2] // @0E9D memory[stack[-2]:stack[-2] + 0x20] // @0EA1 stack[-3] // } 0E9B 5B JUMPDEST 0E9C 81 DUP2 0E9D 51 MLOAD 0E9E 61 PUSH2 0x0eab 0EA1 84 DUP5 0EA2 82 DUP3 0EA3 60 PUSH1 0x20 0EA5 86 DUP7 0EA6 01 ADD 0EA7 61 PUSH2 0x0dc3 0EAA 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0E9D stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @0E9E stack[1] = 0x0eab // @0EA1 stack[2] = stack[-3] // @0EA2 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @0EA6 stack[4] = stack[-2] + 0x20 // } // Block ends with call to 0x0dc3, returns to 0x0EAB label_0EAB: // Incoming return from call to 0x0DC3 at 0x0EAA // Inputs[4] // { // @0EAC stack[-1] // @0EAC stack[-3] // @0EAF stack[-6] // @0EB0 stack[-5] // } 0EAB 5B JUMPDEST 0EAC 91 SWAP2 0EAD 50 POP 0EAE 50 POP 0EAF 92 SWAP3 0EB0 91 SWAP2 0EB1 50 POP 0EB2 50 POP 0EB3 56 *JUMP // Stack delta = -5 // Outputs[1] { @0EAF stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0EB4: // Incoming call from 0x0FB7, returns to 0x0FB8 // Incoming call from 0x0F6A, returns to 0x0F6B // Inputs[2] // { // @0EB7 stack[-1] // @0EB8 msg.data[stack[-1]:stack[-1] + 0x20] // } 0EB4 5B JUMPDEST 0EB5 60 PUSH1 0x00 0EB7 81 DUP2 0EB8 35 CALLDATALOAD 0EB9 90 SWAP1 0EBA 50 POP 0EBB 61 PUSH2 0x0ec3 0EBE 81 DUP2 0EBF 61 PUSH2 0x14c1 0EC2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0EB9 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @0EBB stack[1] = 0x0ec3 // @0EBE stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x14c1, returns to 0x0EC3 label_0EC3: // Incoming return from call to 0x14C1 at 0x0EC2 // Inputs[3] // { // @0EC4 stack[-1] // @0EC4 stack[-4] // @0EC5 stack[-3] // } 0EC3 5B JUMPDEST 0EC4 92 SWAP3 0EC5 91 SWAP2 0EC6 50 POP 0EC7 50 POP 0EC8 56 *JUMP // Stack delta = -3 // Outputs[1] { @0EC4 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0EC9: // Incoming call from 0x107C, returns to 0x107D // Inputs[2] // { // @0ECC stack[-1] // @0ECD memory[stack[-1]:stack[-1] + 0x20] // } 0EC9 5B JUMPDEST 0ECA 60 PUSH1 0x00 0ECC 81 DUP2 0ECD 51 MLOAD 0ECE 90 SWAP1 0ECF 50 POP 0ED0 61 PUSH2 0x0ed8 0ED3 81 DUP2 0ED4 61 PUSH2 0x14c1 0ED7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0ECE stack[0] = memory[stack[-1]:stack[-1] + 0x20] // @0ED0 stack[1] = 0x0ed8 // @0ED3 stack[2] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x14c1, returns to 0x0ED8 label_0ED8: // Incoming return from call to 0x14C1 at 0x0ED7 // Inputs[3] // { // @0ED9 stack[-4] // @0ED9 stack[-1] // @0EDA stack[-3] // } 0ED8 5B JUMPDEST 0ED9 92 SWAP3 0EDA 91 SWAP2 0EDB 50 POP 0EDC 50 POP 0EDD 56 *JUMP // Stack delta = -3 // Outputs[1] { @0ED9 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0EDE: // Incoming call from 0x00F9, returns to 0x00FA // Incoming call from 0x00BF, returns to 0x00C0 // Inputs[2] // { // @0EE3 stack[-1] // @0EE4 stack[-2] // } 0EDE 5B JUMPDEST 0EDF 60 PUSH1 0x00 0EE1 60 PUSH1 0x20 0EE3 82 DUP3 0EE4 84 DUP5 0EE5 03 SUB 0EE6 12 SLT 0EE7 15 ISZERO 0EE8 61 PUSH2 0x0ef0 0EEB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0EDF stack[0] = 0x00 } // Block ends with conditional jump to 0x0ef0, if !(stack[-2] - stack[-1] i< 0x20) label_0EEC: // Incoming jump from 0x0EEB, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @0EEF memory[0x00:0x00] } 0EEC 60 PUSH1 0x00 0EEE 80 DUP1 0EEF FD *REVERT // Stack delta = +0 // Outputs[1] { @0EEF revert(memory[0x00:0x00]); } // Block terminates label_0EF0: // Incoming jump from 0x0EEB, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @0EF6 stack[-3] // @0EF8 stack[-2] // } 0EF0 5B JUMPDEST 0EF1 60 PUSH1 0x00 0EF3 61 PUSH2 0x0efe 0EF6 84 DUP5 0EF7 82 DUP3 0EF8 85 DUP6 0EF9 01 ADD 0EFA 61 PUSH2 0x0e01 0EFD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EF1 stack[0] = 0x00 // @0EF3 stack[1] = 0x0efe // @0EF6 stack[2] = stack[-3] // @0EF9 stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x0e01, returns to 0x0EFE label_0EFE: // Incoming return from call to 0x0E01 at 0x0EFD // Inputs[4] // { // @0EFF stack[-3] // @0EFF stack[-1] // @0F02 stack[-6] // @0F03 stack[-5] // } 0EFE 5B JUMPDEST 0EFF 91 SWAP2 0F00 50 POP 0F01 50 POP 0F02 92 SWAP3 0F03 91 SWAP2 0F04 50 POP 0F05 50 POP 0F06 56 *JUMP // Stack delta = -5 // Outputs[1] { @0F02 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0F07: // Incoming call from 0x0394, returns to 0x0395 // Inputs[2] // { // @0F0C stack[-1] // @0F0D stack[-2] // } 0F07 5B JUMPDEST 0F08 60 PUSH1 0x00 0F0A 60 PUSH1 0x20 0F0C 82 DUP3 0F0D 84 DUP5 0F0E 03 SUB 0F0F 12 SLT 0F10 15 ISZERO 0F11 61 PUSH2 0x0f19 0F14 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0F08 stack[0] = 0x00 } // Block ends with conditional jump to 0x0f19, if !(stack[-2] - stack[-1] i< 0x20) label_0F15: // Incoming jump from 0x0F14, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @0F18 memory[0x00:0x00] } 0F15 60 PUSH1 0x00 0F17 80 DUP1 0F18 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F18 revert(memory[0x00:0x00]); } // Block terminates label_0F19: // Incoming jump from 0x0F14, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @0F1F stack[-3] // @0F21 stack[-2] // } 0F19 5B JUMPDEST 0F1A 60 PUSH1 0x00 0F1C 61 PUSH2 0x0f27 0F1F 84 DUP5 0F20 82 DUP3 0F21 85 DUP6 0F22 01 ADD 0F23 61 PUSH2 0x0e16 0F26 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F1A stack[0] = 0x00 // @0F1C stack[1] = 0x0f27 // @0F1F stack[2] = stack[-3] // @0F22 stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x0e16, returns to 0x0F27 label_0F27: // Incoming return from call to 0x0E16 at 0x0F26 // Inputs[4] // { // @0F28 stack[-1] // @0F28 stack[-3] // @0F2B stack[-6] // @0F2C stack[-5] // } 0F27 5B JUMPDEST 0F28 91 SWAP2 0F29 50 POP 0F2A 50 POP 0F2B 92 SWAP3 0F2C 91 SWAP2 0F2D 50 POP 0F2E 50 POP 0F2F 56 *JUMP // Stack delta = -5 // Outputs[1] { @0F2B stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0F30: // Incoming call from 0x0115, returns to 0x0116 // Inputs[2] // { // @0F3F stack[-1] // @0F40 stack[-2] // } 0F30 5B JUMPDEST 0F31 60 PUSH1 0x00 0F33 80 DUP1 0F34 60 PUSH1 0x00 0F36 80 DUP1 0F37 60 PUSH1 0x00 0F39 80 DUP1 0F3A 60 PUSH1 0x00 0F3C 80 DUP1 0F3D 60 PUSH1 0xc0 0F3F 89 DUP10 0F40 8B DUP12 0F41 03 SUB 0F42 12 SLT 0F43 15 ISZERO 0F44 61 PUSH2 0x0f4c 0F47 57 *JUMPI // Stack delta = +8 // Outputs[8] // { // @0F31 stack[0] = 0x00 // @0F33 stack[1] = 0x00 // @0F34 stack[2] = 0x00 // @0F36 stack[3] = 0x00 // @0F37 stack[4] = 0x00 // @0F39 stack[5] = 0x00 // @0F3A stack[6] = 0x00 // @0F3C stack[7] = 0x00 // } // Block ends with conditional jump to 0x0f4c, if !(stack[-2] - stack[-1] i< 0xc0) label_0F48: // Incoming jump from 0x0F47, if not !(stack[-2] - stack[-1] i< 0xc0) // Inputs[1] { @0F4B memory[0x00:0x00] } 0F48 60 PUSH1 0x00 0F4A 80 DUP1 0F4B FD *REVERT // Stack delta = +0 // Outputs[1] { @0F4B revert(memory[0x00:0x00]); } // Block terminates label_0F4C: // Incoming jump from 0x0F47, if !(stack[-2] - stack[-1] i< 0xc0) // Inputs[2] // { // @0F52 stack[-10] // @0F54 stack[-9] // } 0F4C 5B JUMPDEST 0F4D 60 PUSH1 0x00 0F4F 61 PUSH2 0x0f5a 0F52 8B DUP12 0F53 82 DUP3 0F54 8C DUP13 0F55 01 ADD 0F56 61 PUSH2 0x0e01 0F59 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F4D stack[0] = 0x00 // @0F4F stack[1] = 0x0f5a // @0F52 stack[2] = stack[-10] // @0F55 stack[3] = stack[-9] + 0x00 // } // Block ends with call to 0x0e01, returns to 0x0F5A label_0F5A: // Incoming return from call to 0x0E01 at 0x0F59 // Inputs[4] // { // @0F5B stack[-1] // @0F5B stack[-10] // @0F63 stack[-12] // @0F65 stack[-11] // } 0F5A 5B JUMPDEST 0F5B 98 SWAP9 0F5C 50 POP 0F5D 50 POP 0F5E 60 PUSH1 0x20 0F60 61 PUSH2 0x0f6b 0F63 8B DUP12 0F64 82 DUP3 0F65 8C DUP13 0F66 01 ADD 0F67 61 PUSH2 0x0eb4 0F6A 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @0F5B stack[-10] = stack[-1] // @0F5E stack[-2] = 0x20 // @0F60 stack[-1] = 0x0f6b // @0F63 stack[0] = stack[-12] // @0F66 stack[1] = stack[-11] + 0x20 // } // Block ends with call to 0x0eb4, returns to 0x0F6B label_0F6B: // Incoming return from call to 0x0EB4 at 0x0F6A // Inputs[4] // { // @0F6C stack[-1] // @0F6C stack[-9] // @0F71 stack[-11] // @0F73 msg.data[stack[-11] + 0x40:stack[-11] + 0x40 + 0x20] // } 0F6B 5B JUMPDEST 0F6C 97 SWAP8 0F6D 50 POP 0F6E 50 POP 0F6F 60 PUSH1 0x40 0F71 89 DUP10 0F72 01 ADD 0F73 35 CALLDATALOAD 0F74 67 PUSH8 0xffffffffffffffff 0F7D 81 DUP2 0F7E 11 GT 0F7F 15 ISZERO 0F80 61 PUSH2 0x0f88 0F83 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0F6C stack[-9] = stack[-1] // @0F73 stack[-2] = msg.data[stack[-11] + 0x40:stack[-11] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x0f88, if !(msg.data[stack[-11] + 0x40:stack[-11] + 0x40 + 0x20] > 0xffffffffffffffff) label_0F84: // Incoming jump from 0x0F83, if not !(msg.data[stack[-11] + 0x40:stack[-11] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @0F87 memory[0x00:0x00] } 0F84 60 PUSH1 0x00 0F86 80 DUP1 0F87 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F87 revert(memory[0x00:0x00]); } // Block terminates label_0F88: // Incoming jump from 0x0F83, if !(msg.data[stack[-11] + 0x40:stack[-11] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @0F8C stack[-11] // @0F8D stack[-1] // @0F8E stack[-10] // } 0F88 5B JUMPDEST 0F89 61 PUSH2 0x0f94 0F8C 8B DUP12 0F8D 82 DUP3 0F8E 8C DUP13 0F8F 01 ADD 0F90 61 PUSH2 0x0e40 0F93 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F89 stack[0] = 0x0f94 // @0F8C stack[1] = stack[-11] // @0F8F stack[2] = stack[-10] + stack[-1] // } // Block ends with call to 0x0e40, returns to 0x0F94 label_0F94: // Incoming return from call to 0x0E40 at 0x0F93 // Inputs[6] // { // @0F95 stack[-1] // @0F95 stack[-8] // @0F97 stack[-2] // @0F97 stack[-9] // @0F9F stack[-13] // @0FA1 stack[-12] // } 0F94 5B JUMPDEST 0F95 96 SWAP7 0F96 50 POP 0F97 96 SWAP7 0F98 50 POP 0F99 50 POP 0F9A 60 PUSH1 0x60 0F9C 61 PUSH2 0x0fa7 0F9F 8B DUP12 0FA0 82 DUP3 0FA1 8C DUP13 0FA2 01 ADD 0FA3 61 PUSH2 0x0e01 0FA6 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0F95 stack[-8] = stack[-1] // @0F97 stack[-9] = stack[-2] // @0F9A stack[-3] = 0x60 // @0F9C stack[-2] = 0x0fa7 // @0F9F stack[-1] = stack[-13] // @0FA2 stack[0] = stack[-12] + 0x60 // } // Block ends with call to 0x0e01, returns to 0x0FA7 label_0FA7: // Incoming return from call to 0x0E01 at 0x0FA6 // Inputs[4] // { // @0FA8 stack[-6] // @0FA8 stack[-1] // @0FB0 stack[-12] // @0FB2 stack[-11] // } 0FA7 5B JUMPDEST 0FA8 94 SWAP5 0FA9 50 POP 0FAA 50 POP 0FAB 60 PUSH1 0x80 0FAD 61 PUSH2 0x0fb8 0FB0 8B DUP12 0FB1 82 DUP3 0FB2 8C DUP13 0FB3 01 ADD 0FB4 61 PUSH2 0x0eb4 0FB7 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @0FA8 stack[-6] = stack[-1] // @0FAB stack[-2] = 0x80 // @0FAD stack[-1] = 0x0fb8 // @0FB0 stack[0] = stack[-12] // @0FB3 stack[1] = stack[-11] + 0x80 // } // Block ends with call to 0x0eb4, returns to 0x0FB8 label_0FB8: // Incoming return from call to 0x0EB4 at 0x0FB7 // Inputs[4] // { // @0FB9 stack[-5] // @0FB9 stack[-1] // @0FBE stack[-11] // @0FC0 msg.data[stack[-11] + 0xa0:stack[-11] + 0xa0 + 0x20] // } 0FB8 5B JUMPDEST 0FB9 93 SWAP4 0FBA 50 POP 0FBB 50 POP 0FBC 60 PUSH1 0xa0 0FBE 89 DUP10 0FBF 01 ADD 0FC0 35 CALLDATALOAD 0FC1 67 PUSH8 0xffffffffffffffff 0FCA 81 DUP2 0FCB 11 GT 0FCC 15 ISZERO 0FCD 61 PUSH2 0x0fd5 0FD0 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0FB9 stack[-5] = stack[-1] // @0FC0 stack[-2] = msg.data[stack[-11] + 0xa0:stack[-11] + 0xa0 + 0x20] // } // Block ends with conditional jump to 0x0fd5, if !(msg.data[stack[-11] + 0xa0:stack[-11] + 0xa0 + 0x20] > 0xffffffffffffffff) label_0FD1: // Incoming jump from 0x0FD0, if not !(msg.data[stack[-11] + 0xa0:stack[-11] + 0xa0 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @0FD4 memory[0x00:0x00] } 0FD1 60 PUSH1 0x00 0FD3 80 DUP1 0FD4 FD *REVERT // Stack delta = +0 // Outputs[1] { @0FD4 revert(memory[0x00:0x00]); } // Block terminates label_0FD5: // Incoming jump from 0x0FD0, if !(msg.data[stack[-11] + 0xa0:stack[-11] + 0xa0 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @0FD9 stack[-11] // @0FDA stack[-1] // @0FDB stack[-10] // } 0FD5 5B JUMPDEST 0FD6 61 PUSH2 0x0fe1 0FD9 8B DUP12 0FDA 82 DUP3 0FDB 8C DUP13 0FDC 01 ADD 0FDD 61 PUSH2 0x0e40 0FE0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FD6 stack[0] = 0x0fe1 // @0FD9 stack[1] = stack[-11] // @0FDC stack[2] = stack[-10] + stack[-1] // } // Block ends with call to 0x0e40, returns to 0x0FE1 label_0FE1: // Incoming return from call to 0x0E40 at 0x0FE0 // Inputs[13] // { // @0FE2 stack[-1] // @0FE2 stack[-4] // @0FE4 stack[-2] // @0FE4 stack[-5] // @0FE7 stack[-7] // @0FE8 stack[-10] // @0FE9 stack[-13] // @0FEB stack[-8] // @0FEC stack[-11] // @0FED stack[-14] // @0FEE stack[-6] // @0FEF stack[-9] // @0FF0 stack[-12] // } 0FE1 5B JUMPDEST 0FE2 92 SWAP3 0FE3 50 POP 0FE4 92 SWAP3 0FE5 50 POP 0FE6 50 POP 0FE7 92 SWAP3 0FE8 95 SWAP6 0FE9 98 SWAP9 0FEA 50 POP 0FEB 92 SWAP3 0FEC 95 SWAP6 0FED 98 SWAP9 0FEE 90 SWAP1 0FEF 93 SWAP4 0FF0 96 SWAP7 0FF1 50 POP 0FF2 56 *JUMP // Stack delta = -6 // Outputs[8] // { // @0FE7 stack[-7] = stack[-1] // @0FE8 stack[-10] = stack[-7] // @0FE9 stack[-13] = stack[-10] // @0FEB stack[-8] = stack[-2] // @0FEC stack[-11] = stack[-8] // @0FED stack[-14] = stack[-11] // @0FEF stack[-9] = stack[-6] // @0FF0 stack[-12] = stack[-9] // } // Block ends with unconditional jump to stack[-14] label_0FF3: // Incoming call from 0x030B, returns to 0x030C // Inputs[2] // { // @0FF8 stack[-1] // @0FF9 stack[-2] // } 0FF3 5B JUMPDEST 0FF4 60 PUSH1 0x00 0FF6 60 PUSH1 0x20 0FF8 82 DUP3 0FF9 84 DUP5 0FFA 03 SUB 0FFB 12 SLT 0FFC 15 ISZERO 0FFD 61 PUSH2 0x1005 1000 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0FF4 stack[0] = 0x00 } // Block ends with conditional jump to 0x1005, if !(stack[-2] - stack[-1] i< 0x20) label_1001: // Incoming jump from 0x1000, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1004 memory[0x00:0x00] } 1001 60 PUSH1 0x00 1003 80 DUP1 1004 FD *REVERT // Stack delta = +0 // Outputs[1] { @1004 revert(memory[0x00:0x00]); } // Block terminates label_1005: // Incoming jump from 0x1000, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @100B stack[-3] // @100D stack[-2] // } 1005 5B JUMPDEST 1006 60 PUSH1 0x00 1008 61 PUSH2 0x1013 100B 84 DUP5 100C 82 DUP3 100D 85 DUP6 100E 01 ADD 100F 61 PUSH2 0x0e2b 1012 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1006 stack[0] = 0x00 // @1008 stack[1] = 0x1013 // @100B stack[2] = stack[-3] // @100E stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x0e2b, returns to 0x1013 label_1013: // Incoming return from call to 0x0E2B at 0x1012 // Inputs[4] // { // @1014 stack[-3] // @1014 stack[-1] // @1017 stack[-6] // @1018 stack[-5] // } 1013 5B JUMPDEST 1014 91 SWAP2 1015 50 POP 1016 50 POP 1017 92 SWAP3 1018 91 SWAP2 1019 50 POP 101A 50 POP 101B 56 *JUMP // Stack delta = -5 // Outputs[1] { @1017 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_101C: // Incoming call from 0x041B, returns to 0x041C // Inputs[2] // { // @1021 stack[-1] // @1022 stack[-2] // } 101C 5B JUMPDEST 101D 60 PUSH1 0x00 101F 60 PUSH1 0x20 1021 82 DUP3 1022 84 DUP5 1023 03 SUB 1024 12 SLT 1025 15 ISZERO 1026 61 PUSH2 0x102e 1029 57 *JUMPI // Stack delta = +1 // Outputs[1] { @101D stack[0] = 0x00 } // Block ends with conditional jump to 0x102e, if !(stack[-2] - stack[-1] i< 0x20) label_102A: // Incoming jump from 0x1029, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @102D memory[0x00:0x00] } 102A 60 PUSH1 0x00 102C 80 DUP1 102D FD *REVERT // Stack delta = +0 // Outputs[1] { @102D revert(memory[0x00:0x00]); } // Block terminates label_102E: // Incoming jump from 0x1029, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1031 stack[-2] // @1033 memory[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] // } 102E 5B JUMPDEST 102F 60 PUSH1 0x00 1031 82 DUP3 1032 01 ADD 1033 51 MLOAD 1034 67 PUSH8 0xffffffffffffffff 103D 81 DUP2 103E 11 GT 103F 15 ISZERO 1040 61 PUSH2 0x1048 1043 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1033 stack[0] = memory[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] } // Block ends with conditional jump to 0x1048, if !(memory[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] > 0xffffffffffffffff) label_1044: // Incoming jump from 0x1043, if not !(memory[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1047 memory[0x00:0x00] } 1044 60 PUSH1 0x00 1046 80 DUP1 1047 FD *REVERT // Stack delta = +0 // Outputs[1] { @1047 revert(memory[0x00:0x00]); } // Block terminates label_1048: // Incoming jump from 0x1043, if !(memory[stack[-2] + 0x00:stack[-2] + 0x00 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @104C stack[-4] // @104D stack[-1] // @104E stack[-3] // } 1048 5B JUMPDEST 1049 61 PUSH2 0x1054 104C 84 DUP5 104D 82 DUP3 104E 85 DUP6 104F 01 ADD 1050 61 PUSH2 0x0e8a 1053 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1049 stack[0] = 0x1054 // @104C stack[1] = stack[-4] // @104F stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x0e8a, returns to 0x1054 label_1054: // Incoming return from call to 0x0E8A at 0x1053 // Inputs[4] // { // @1055 stack[-3] // @1055 stack[-1] // @1058 stack[-6] // @1059 stack[-5] // } 1054 5B JUMPDEST 1055 91 SWAP2 1056 50 POP 1057 50 POP 1058 92 SWAP3 1059 91 SWAP2 105A 50 POP 105B 50 POP 105C 56 *JUMP // Stack delta = -5 // Outputs[1] { @1058 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_105D: // Incoming call from 0x049D, returns to 0x049E // Inputs[2] // { // @1062 stack[-1] // @1063 stack[-2] // } 105D 5B JUMPDEST 105E 60 PUSH1 0x00 1060 60 PUSH1 0x20 1062 82 DUP3 1063 84 DUP5 1064 03 SUB 1065 12 SLT 1066 15 ISZERO 1067 61 PUSH2 0x106f 106A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @105E stack[0] = 0x00 } // Block ends with conditional jump to 0x106f, if !(stack[-2] - stack[-1] i< 0x20) label_106B: // Incoming jump from 0x106A, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @106E memory[0x00:0x00] } 106B 60 PUSH1 0x00 106D 80 DUP1 106E FD *REVERT // Stack delta = +0 // Outputs[1] { @106E revert(memory[0x00:0x00]); } // Block terminates label_106F: // Incoming jump from 0x106A, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1075 stack[-3] // @1077 stack[-2] // } 106F 5B JUMPDEST 1070 60 PUSH1 0x00 1072 61 PUSH2 0x107d 1075 84 DUP5 1076 82 DUP3 1077 85 DUP6 1078 01 ADD 1079 61 PUSH2 0x0ec9 107C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1070 stack[0] = 0x00 // @1072 stack[1] = 0x107d // @1075 stack[2] = stack[-3] // @1078 stack[3] = stack[-2] + 0x00 // } // Block ends with call to 0x0ec9, returns to 0x107D label_107D: // Incoming return from call to 0x0EC9 at 0x107C // Inputs[4] // { // @107E stack[-3] // @107E stack[-1] // @1081 stack[-6] // @1082 stack[-5] // } 107D 5B JUMPDEST 107E 91 SWAP2 107F 50 POP 1080 50 POP 1081 92 SWAP3 1082 91 SWAP2 1083 50 POP 1084 50 POP 1085 56 *JUMP // Stack delta = -5 // Outputs[1] { @1081 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1086: // Incoming call from 0x11BF, returns to 0x11C0 // Inputs[1] { @108A stack[-1] } 1086 5B JUMPDEST 1087 61 PUSH2 0x108f 108A 81 DUP2 108B 61 PUSH2 0x12d9 108E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1087 stack[0] = 0x108f // @108A stack[1] = stack[-1] // } // Block ends with call to 0x12d9, returns to 0x108F label_108F: // Incoming return from call to 0x12D9 at 0x108E // Inputs[3] // { // @1090 stack[-3] // @1091 stack[-1] // @1094 stack[-4] // } 108F 5B JUMPDEST 1090 82 DUP3 1091 52 MSTORE 1092 50 POP 1093 50 POP 1094 56 *JUMP // Stack delta = -4 // Outputs[1] { @1091 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1095: // Incoming call from 0x11DA, returns to 0x11DB // Inputs[1] { @1099 stack[-1] } 1095 5B JUMPDEST 1096 61 PUSH2 0x109e 1099 81 DUP2 109A 61 PUSH2 0x12eb 109D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1096 stack[0] = 0x109e // @1099 stack[1] = stack[-1] // } // Block ends with call to 0x12eb, returns to 0x109E label_109E: // Incoming return from call to 0x12EB at 0x109D // Inputs[3] // { // @109F stack[-3] // @10A0 stack[-1] // @10A3 stack[-4] // } 109E 5B JUMPDEST 109F 82 DUP3 10A0 52 MSTORE 10A1 50 POP 10A2 50 POP 10A3 56 *JUMP // Stack delta = -4 // Outputs[1] { @10A0 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_10A4: // Incoming call from 0x1187, returns to 0x1188 // Inputs[2] // { // @10AA stack[-2] // @10AB stack[-3] // } 10A4 5B JUMPDEST 10A5 60 PUSH1 0x00 10A7 61 PUSH2 0x10b0 10AA 83 DUP4 10AB 85 DUP6 10AC 61 PUSH2 0x12bd 10AF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @10A5 stack[0] = 0x00 // @10A7 stack[1] = 0x10b0 // @10AA stack[2] = stack[-2] // @10AB stack[3] = stack[-3] // } // Block ends with call to 0x12bd, returns to 0x10B0 label_10B0: // Incoming return from call to 0x12BD at 0x10AF // Inputs[4] // { // @10B1 stack[-1] // @10B1 stack[-5] // @10B6 stack[-4] // @10B8 stack[-3] // } 10B0 5B JUMPDEST 10B1 93 SWAP4 10B2 50 POP 10B3 61 PUSH2 0x10bd 10B6 83 DUP4 10B7 85 DUP6 10B8 84 DUP5 10B9 61 PUSH2 0x133c 10BC 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @10B1 stack[-5] = stack[-1] // @10B3 stack[-1] = 0x10bd // @10B6 stack[0] = stack[-4] // @10B7 stack[1] = stack[-1] // @10B8 stack[2] = stack[-3] // } // Block ends with call to 0x133c, returns to 0x10BD label_10BD: // Incoming return from call to 0x133C at 0x10BC // Inputs[4] // { // @10BE stack[-3] // @10BF stack[-4] // @10C1 stack[-1] // @10C3 stack[-5] // } 10BD 5B JUMPDEST 10BE 82 DUP3 10BF 84 DUP5 10C0 01 ADD 10C1 90 SWAP1 10C2 50 POP 10C3 93 SWAP4 10C4 92 SWAP3 10C5 50 POP 10C6 50 POP 10C7 50 POP 10C8 56 *JUMP // Stack delta = -4 // Outputs[1] { @10C3 stack[-5] = stack[-4] + stack[-3] } // Block ends with unconditional jump to stack[-5] label_10C9: // Incoming call from 0x11FA, returns to 0x11FB // Inputs[1] { @10CF stack[-1] } 10C9 5B JUMPDEST 10CA 60 PUSH1 0x00 10CC 61 PUSH2 0x10d4 10CF 82 DUP3 10D0 61 PUSH2 0x1296 10D3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10CA stack[0] = 0x00 // @10CC stack[1] = 0x10d4 // @10CF stack[2] = stack[-1] // } // Block ends with call to 0x1296, returns to 0x10D4 label_10D4: // Incoming return from call to 0x1296 at 0x10D3 // Inputs[2] // { // @10D8 stack[-1] // @10D9 stack[-4] // } 10D4 5B JUMPDEST 10D5 61 PUSH2 0x10de 10D8 81 DUP2 10D9 85 DUP6 10DA 61 PUSH2 0x12ac 10DD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10D5 stack[0] = 0x10de // @10D8 stack[1] = stack[-1] // @10D9 stack[2] = stack[-4] // } // Block ends with call to 0x12ac, returns to 0x10DE label_10DE: // Incoming return from call to 0x12AC at 0x10DD // Inputs[4] // { // @10DF stack[-1] // @10DF stack[-5] // @10E4 stack[-2] // @10E8 stack[-4] // } 10DE 5B JUMPDEST 10DF 93 SWAP4 10E0 50 POP 10E1 61 PUSH2 0x10ee 10E4 81 DUP2 10E5 85 DUP6 10E6 60 PUSH1 0x20 10E8 86 DUP7 10E9 01 ADD 10EA 61 PUSH2 0x134b 10ED 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @10DF stack[-5] = stack[-1] // @10E1 stack[-1] = 0x10ee // @10E4 stack[0] = stack[-2] // @10E5 stack[1] = stack[-1] // @10E9 stack[2] = stack[-4] + 0x20 // } // Block ends with call to 0x134b, returns to 0x10EE label_10EE: // Incoming return from call to 0x134B at 0x10ED // Inputs[1] { @10F2 stack[-1] } 10EE 5B JUMPDEST 10EF 61 PUSH2 0x10f7 10F2 81 DUP2 10F3 61 PUSH2 0x146e 10F6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @10EF stack[0] = 0x10f7 // @10F2 stack[1] = stack[-1] // } // Block ends with call to 0x146e, returns to 0x10F7 label_10F7: // Incoming return from call to 0x146E at 0x10F6 // Inputs[4] // { // @10F8 stack[-5] // @10F9 stack[-1] // @10FA stack[-3] // @10FD stack[-6] // } 10F7 5B JUMPDEST 10F8 84 DUP5 10F9 01 ADD 10FA 91 SWAP2 10FB 50 POP 10FC 50 POP 10FD 92 SWAP3 10FE 91 SWAP2 10FF 50 POP 1100 50 POP 1101 56 *JUMP // Stack delta = -5 // Outputs[1] { @10FD stack[-6] = stack[-5] + stack[-1] } // Block ends with unconditional jump to stack[-6] label_1102: // Incoming call from 0x119F, returns to 0x11A0 // Inputs[1] { @1108 stack[-1] } 1102 5B JUMPDEST 1103 60 PUSH1 0x00 1105 61 PUSH2 0x110d 1108 82 DUP3 1109 61 PUSH2 0x1296 110C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1103 stack[0] = 0x00 // @1105 stack[1] = 0x110d // @1108 stack[2] = stack[-1] // } // Block ends with call to 0x1296, returns to 0x110D label_110D: // Incoming return from call to 0x1296 at 0x110C // Inputs[2] // { // @1111 stack[-1] // @1112 stack[-4] // } 110D 5B JUMPDEST 110E 61 PUSH2 0x1117 1111 81 DUP2 1112 85 DUP6 1113 61 PUSH2 0x12bd 1116 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @110E stack[0] = 0x1117 // @1111 stack[1] = stack[-1] // @1112 stack[2] = stack[-4] // } // Block ends with call to 0x12bd, returns to 0x1117 label_1117: // Incoming return from call to 0x12BD at 0x1116 // Inputs[4] // { // @1118 stack[-5] // @1118 stack[-1] // @111D stack[-2] // @1121 stack[-4] // } 1117 5B JUMPDEST 1118 93 SWAP4 1119 50 POP 111A 61 PUSH2 0x1127 111D 81 DUP2 111E 85 DUP6 111F 60 PUSH1 0x20 1121 86 DUP7 1122 01 ADD 1123 61 PUSH2 0x134b 1126 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1118 stack[-5] = stack[-1] // @111A stack[-1] = 0x1127 // @111D stack[0] = stack[-2] // @111E stack[1] = stack[-1] // @1122 stack[2] = stack[-4] + 0x20 // } // Block ends with call to 0x134b, returns to 0x1127 label_1127: // Incoming return from call to 0x134B at 0x1126 // Inputs[4] // { // @1128 stack[-1] // @1129 stack[-4] // @112B stack[-2] // @112E stack[-5] // } 1127 5B JUMPDEST 1128 80 DUP1 1129 84 DUP5 112A 01 ADD 112B 91 SWAP2 112C 50 POP 112D 50 POP 112E 92 SWAP3 112F 91 SWAP2 1130 50 POP 1131 50 POP 1132 56 *JUMP // Stack delta = -4 // Outputs[1] { @112E stack[-5] = stack[-4] + stack[-1] } // Block ends with unconditional jump to stack[-5] label_1133: // Incoming call from 0x1217, returns to 0x1218 // Inputs[1] { @1137 stack[-1] } 1133 5B JUMPDEST 1134 61 PUSH2 0x113c 1137 81 DUP2 1138 61 PUSH2 0x132a 113B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1134 stack[0] = 0x113c // @1137 stack[1] = stack[-1] // } // Block ends with call to 0x132a, returns to 0x113C label_113C: // Incoming return from call to 0x132A at 0x113B // Inputs[3] // { // @113D stack[-3] // @113E stack[-1] // @1141 stack[-4] // } 113C 5B JUMPDEST 113D 82 DUP3 113E 52 MSTORE 113F 50 POP 1140 50 POP 1141 56 *JUMP // Stack delta = -4 // Outputs[1] { @113E memory[stack[-3]:stack[-3] + 0x20] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1142: // Incoming call from 0x1237, returns to 0x1238 // Inputs[1] { @1148 stack[-1] } 1142 5B JUMPDEST 1143 60 PUSH1 0x00 1145 61 PUSH2 0x114d 1148 82 DUP3 1149 61 PUSH2 0x12a1 114C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1143 stack[0] = 0x00 // @1145 stack[1] = 0x114d // @1148 stack[2] = stack[-1] // } // Block ends with call to 0x12a1, returns to 0x114D label_114D: // Incoming return from call to 0x12A1 at 0x114C // Inputs[2] // { // @1151 stack[-1] // @1152 stack[-4] // } 114D 5B JUMPDEST 114E 61 PUSH2 0x1157 1151 81 DUP2 1152 85 DUP6 1153 61 PUSH2 0x12c8 1156 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @114E stack[0] = 0x1157 // @1151 stack[1] = stack[-1] // @1152 stack[2] = stack[-4] // } // Block ends with call to 0x12c8, returns to 0x1157 label_1157: // Incoming return from call to 0x12C8 at 0x1156 // Inputs[4] // { // @1158 stack[-5] // @1158 stack[-1] // @115D stack[-2] // @1161 stack[-4] // } 1157 5B JUMPDEST 1158 93 SWAP4 1159 50 POP 115A 61 PUSH2 0x1167 115D 81 DUP2 115E 85 DUP6 115F 60 PUSH1 0x20 1161 86 DUP7 1162 01 ADD 1163 61 PUSH2 0x134b 1166 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1158 stack[-5] = stack[-1] // @115A stack[-1] = 0x1167 // @115D stack[0] = stack[-2] // @115E stack[1] = stack[-1] // @1162 stack[2] = stack[-4] + 0x20 // } // Block ends with call to 0x134b, returns to 0x1167 label_1167: // Incoming return from call to 0x134B at 0x1166 // Inputs[1] { @116B stack[-1] } 1167 5B JUMPDEST 1168 61 PUSH2 0x1170 116B 81 DUP2 116C 61 PUSH2 0x146e 116F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1168 stack[0] = 0x1170 // @116B stack[1] = stack[-1] // } // Block ends with call to 0x146e, returns to 0x1170 label_1170: // Incoming return from call to 0x146E at 0x116F // Inputs[4] // { // @1171 stack[-5] // @1172 stack[-1] // @1173 stack[-3] // @1176 stack[-6] // } 1170 5B JUMPDEST 1171 84 DUP5 1172 01 ADD 1173 91 SWAP2 1174 50 POP 1175 50 POP 1176 92 SWAP3 1177 91 SWAP2 1178 50 POP 1179 50 POP 117A 56 *JUMP // Stack delta = -5 // Outputs[1] { @1176 stack[-6] = stack[-5] + stack[-1] } // Block ends with unconditional jump to stack[-6] label_117B: // Incoming call from 0x08E0, returns to 0x08E1 // Incoming call from 0x09C9, returns to 0x09CA // Inputs[3] // { // @1181 stack[-1] // @1182 stack[-2] // @1183 stack[-3] // } 117B 5B JUMPDEST 117C 60 PUSH1 0x00 117E 61 PUSH2 0x1188 1181 82 DUP3 1182 84 DUP5 1183 86 DUP7 1184 61 PUSH2 0x10a4 1187 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @117C stack[0] = 0x00 // @117E stack[1] = 0x1188 // @1181 stack[2] = stack[-1] // @1182 stack[3] = stack[-2] // @1183 stack[4] = stack[-3] // } // Block ends with call to 0x10a4, returns to 0x1188 label_1188: // Incoming return from call to 0x10A4 at 0x1187 // Inputs[5] // { // @1189 stack[-1] // @1189 stack[-3] // @118C stack[-2] // @118E stack[-6] // @118F stack[-5] // } 1188 5B JUMPDEST 1189 91 SWAP2 118A 50 POP 118B 81 DUP2 118C 90 SWAP1 118D 50 POP 118E 93 SWAP4 118F 92 SWAP3 1190 50 POP 1191 50 POP 1192 50 POP 1193 56 *JUMP // Stack delta = -5 // Outputs[1] { @118E stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1194: // Incoming call from 0x06A0, returns to 0x06A1 // Incoming call from 0x057B, returns to 0x057C // Inputs[2] // { // @119A stack[-1] // @119B stack[-2] // } 1194 5B JUMPDEST 1195 60 PUSH1 0x00 1197 61 PUSH2 0x11a0 119A 82 DUP3 119B 84 DUP5 119C 61 PUSH2 0x1102 119F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1195 stack[0] = 0x00 // @1197 stack[1] = 0x11a0 // @119A stack[2] = stack[-1] // @119B stack[3] = stack[-2] // } // Block ends with call to 0x1102, returns to 0x11A0 label_11A0: // Incoming return from call to 0x1102 at 0x119F // Inputs[5] // { // @11A1 stack[-1] // @11A1 stack[-3] // @11A4 stack[-2] // @11A6 stack[-5] // @11A7 stack[-4] // } 11A0 5B JUMPDEST 11A1 91 SWAP2 11A2 50 POP 11A3 81 DUP2 11A4 90 SWAP1 11A5 50 POP 11A6 92 SWAP3 11A7 91 SWAP2 11A8 50 POP 11A9 50 POP 11AA 56 *JUMP // Stack delta = -4 // Outputs[1] { @11A6 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_11AB: // Incoming call from 0x016D, returns to 0x016E // Incoming call from 0x00A1, returns to 0x00A2 // Inputs[2] // { // @11B0 stack[-1] // @11BB stack[-2] // } 11AB 5B JUMPDEST 11AC 60 PUSH1 0x00 11AE 60 PUSH1 0x20 11B0 82 DUP3 11B1 01 ADD 11B2 90 SWAP1 11B3 50 POP 11B4 61 PUSH2 0x11c0 11B7 60 PUSH1 0x00 11B9 83 DUP4 11BA 01 ADD 11BB 84 DUP5 11BC 61 PUSH2 0x1086 11BF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @11B2 stack[0] = stack[-1] + 0x20 // @11B4 stack[1] = 0x11c0 // @11BA stack[2] = stack[-1] + 0x00 // @11BB stack[3] = stack[-2] // } // Block ends with call to 0x1086, returns to 0x11C0 label_11C0: // Incoming return from call to 0x1086 at 0x11BF // Inputs[3] // { // @11C1 stack[-4] // @11C1 stack[-1] // @11C2 stack[-3] // } 11C0 5B JUMPDEST 11C1 92 SWAP3 11C2 91 SWAP2 11C3 50 POP 11C4 50 POP 11C5 56 *JUMP // Stack delta = -3 // Outputs[1] { @11C1 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_11C6: // Incoming call from 0x00DB, returns to 0x00DC // Inputs[2] // { // @11CB stack[-1] // @11D6 stack[-2] // } 11C6 5B JUMPDEST 11C7 60 PUSH1 0x00 11C9 60 PUSH1 0x20 11CB 82 DUP3 11CC 01 ADD 11CD 90 SWAP1 11CE 50 POP 11CF 61 PUSH2 0x11db 11D2 60 PUSH1 0x00 11D4 83 DUP4 11D5 01 ADD 11D6 84 DUP5 11D7 61 PUSH2 0x1095 11DA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @11CD stack[0] = stack[-1] + 0x20 // @11CF stack[1] = 0x11db // @11D5 stack[2] = stack[-1] + 0x00 // @11D6 stack[3] = stack[-2] // } // Block ends with call to 0x1095, returns to 0x11DB label_11DB: // Incoming return from call to 0x1095 at 0x11DA // Inputs[3] // { // @11DC stack[-1] // @11DC stack[-4] // @11DD stack[-3] // } 11DB 5B JUMPDEST 11DC 92 SWAP3 11DD 91 SWAP2 11DE 50 POP 11DF 50 POP 11E0 56 *JUMP // Stack delta = -3 // Outputs[1] { @11DC stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_11E1: // Incoming call from 0x014F, returns to 0x0150 // Inputs[2] // { // @11E6 stack[-1] // @11F6 stack[-2] // } 11E1 5B JUMPDEST 11E2 60 PUSH1 0x00 11E4 60 PUSH1 0x20 11E6 82 DUP3 11E7 01 ADD 11E8 90 SWAP1 11E9 50 POP 11EA 81 DUP2 11EB 81 DUP2 11EC 03 SUB 11ED 60 PUSH1 0x00 11EF 83 DUP4 11F0 01 ADD 11F1 52 MSTORE 11F2 61 PUSH2 0x11fb 11F5 81 DUP2 11F6 84 DUP5 11F7 61 PUSH2 0x10c9 11FA 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @11E8 stack[0] = stack[-1] + 0x20 // @11F1 memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @11F2 stack[1] = 0x11fb // @11F5 stack[2] = stack[-1] + 0x20 // @11F6 stack[3] = stack[-2] // } // Block ends with call to 0x10c9, returns to 0x11FB label_11FB: // Incoming return from call to 0x10C9 at 0x11FA // Inputs[4] // { // @11FC stack[-1] // @11FC stack[-2] // @11FE stack[-5] // @11FF stack[-4] // } 11FB 5B JUMPDEST 11FC 90 SWAP1 11FD 50 POP 11FE 92 SWAP3 11FF 91 SWAP2 1200 50 POP 1201 50 POP 1202 56 *JUMP // Stack delta = -4 // Outputs[1] { @11FE stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1203: // Incoming call from 0x0131, returns to 0x0132 // Inputs[2] // { // @1208 stack[-1] // @1213 stack[-2] // } 1203 5B JUMPDEST 1204 60 PUSH1 0x00 1206 60 PUSH1 0x20 1208 82 DUP3 1209 01 ADD 120A 90 SWAP1 120B 50 POP 120C 61 PUSH2 0x1218 120F 60 PUSH1 0x00 1211 83 DUP4 1212 01 ADD 1213 84 DUP5 1214 61 PUSH2 0x1133 1217 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @120A stack[0] = stack[-1] + 0x20 // @120C stack[1] = 0x1218 // @1212 stack[2] = stack[-1] + 0x00 // @1213 stack[3] = stack[-2] // } // Block ends with call to 0x1133, returns to 0x1218 label_1218: // Incoming return from call to 0x1133 at 0x1217 // Inputs[3] // { // @1219 stack[-1] // @1219 stack[-4] // @121A stack[-3] // } 1218 5B JUMPDEST 1219 92 SWAP3 121A 91 SWAP2 121B 50 POP 121C 50 POP 121D 56 *JUMP // Stack delta = -3 // Outputs[1] { @1219 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_121E: // Incoming call from 0x0BEB, returns to 0x0BEC // Inputs[2] // { // @1223 stack[-1] // @1233 stack[-2] // } 121E 5B JUMPDEST 121F 60 PUSH1 0x00 1221 60 PUSH1 0x20 1223 82 DUP3 1224 01 ADD 1225 90 SWAP1 1226 50 POP 1227 81 DUP2 1228 81 DUP2 1229 03 SUB 122A 60 PUSH1 0x00 122C 83 DUP4 122D 01 ADD 122E 52 MSTORE 122F 61 PUSH2 0x1238 1232 81 DUP2 1233 84 DUP5 1234 61 PUSH2 0x1142 1237 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1225 stack[0] = stack[-1] + 0x20 // @122E memory[stack[-1] + 0x00:stack[-1] + 0x00 + 0x20] = (stack[-1] + 0x20) - stack[-1] // @122F stack[1] = 0x1238 // @1232 stack[2] = stack[-1] + 0x20 // @1233 stack[3] = stack[-2] // } // Block ends with call to 0x1142, returns to 0x1238 label_1238: // Incoming return from call to 0x1142 at 0x1237 // Inputs[4] // { // @1239 stack[-1] // @1239 stack[-2] // @123B stack[-5] // @123C stack[-4] // } 1238 5B JUMPDEST 1239 90 SWAP1 123A 50 POP 123B 92 SWAP3 123C 91 SWAP2 123D 50 POP 123E 50 POP 123F 56 *JUMP // Stack delta = -4 // Outputs[1] { @123B stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1240: // Incoming jump from 0x0DD5 1240 5B JUMPDEST 1241 60 PUSH1 0x00 1243 61 PUSH2 0x124a 1246 61 PUSH2 0x125b 1249 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1241 stack[0] = 0x00 // @1243 stack[1] = 0x124a // } // Block ends with call to 0x125b, returns to 0x124A label_124A: // Incoming return from call to 0x125B at 0x1249 // Inputs[3] // { // @124B stack[-1] // @124B stack[-2] // @1250 stack[-3] // } 124A 5B JUMPDEST 124B 90 SWAP1 124C 50 POP 124D 61 PUSH2 0x1256 1250 82 DUP3 1251 82 DUP3 1252 61 PUSH2 0x13b0 1255 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @124B stack[-2] = stack[-1] // @124D stack[-1] = 0x1256 // @1250 stack[0] = stack[-3] // @1251 stack[1] = stack[-1] // } // Block ends with call to 0x13b0, returns to 0x1256 label_1256: // Incoming return from call to 0x13B0 at 0x1255 // Inputs[3] // { // @1257 stack[-3] // @1257 stack[-1] // @1258 stack[-2] // } 1256 5B JUMPDEST 1257 91 SWAP2 1258 90 SWAP1 1259 50 POP 125A 56 *JUMP // Stack delta = -2 // Outputs[1] { @1257 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_125B: // Incoming call from 0x1249, returns to 0x124A // Inputs[2] // { // @1260 memory[0x40:0x60] // @1263 stack[-1] // } 125B 5B JUMPDEST 125C 60 PUSH1 0x00 125E 60 PUSH1 0x40 1260 51 MLOAD 1261 90 SWAP1 1262 50 POP 1263 90 SWAP1 1264 56 *JUMP // Stack delta = +0 // Outputs[1] { @1263 stack[-1] = memory[0x40:0x60] } // Block ends with unconditional jump to stack[-1] label_1265: // Incoming call from 0x0DD0, returns to 0x0DD1 // Inputs[1] { @1271 stack[-1] } 1265 5B JUMPDEST 1266 60 PUSH1 0x00 1268 67 PUSH8 0xffffffffffffffff 1271 82 DUP3 1272 11 GT 1273 15 ISZERO 1274 61 PUSH2 0x1280 1277 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1266 stack[0] = 0x00 } // Block ends with conditional jump to 0x1280, if !(stack[-1] > 0xffffffffffffffff) label_1278: // Incoming jump from 0x1277, if not !(stack[-1] > 0xffffffffffffffff) 1278 61 PUSH2 0x127f 127B 61 PUSH2 0x143f 127E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1278 stack[0] = 0x127f } // Block ends with unconditional jump to 0x143f 127F 5B JUMPDEST label_1280: // Incoming jump from 0x1277, if !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @1284 stack[-2] } 1280 5B JUMPDEST 1281 61 PUSH2 0x1289 1284 82 DUP3 1285 61 PUSH2 0x146e 1288 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1281 stack[0] = 0x1289 // @1284 stack[1] = stack[-2] // } // Block ends with call to 0x146e, returns to 0x1289 label_1289: // Incoming return from call to 0x146E at 0x1288 // Inputs[4] // { // @128A stack[-2] // @128A stack[-1] // @1292 stack[-4] // @1293 stack[-3] // } 1289 5B JUMPDEST 128A 90 SWAP1 128B 50 POP 128C 60 PUSH1 0x20 128E 81 DUP2 128F 01 ADD 1290 90 SWAP1 1291 50 POP 1292 91 SWAP2 1293 90 SWAP1 1294 50 POP 1295 56 *JUMP // Stack delta = -3 // Outputs[1] { @1292 stack[-4] = stack[-1] + 0x20 } // Block ends with unconditional jump to stack[-4] label_1296: // Incoming call from 0x10D3, returns to 0x10D4 // Incoming call from 0x110C, returns to 0x110D // Inputs[3] // { // @1299 stack[-1] // @129A memory[stack[-1]:stack[-1] + 0x20] // @129D stack[-2] // } 1296 5B JUMPDEST 1297 60 PUSH1 0x00 1299 81 DUP2 129A 51 MLOAD 129B 90 SWAP1 129C 50 POP 129D 91 SWAP2 129E 90 SWAP1 129F 50 POP 12A0 56 *JUMP // Stack delta = -1 // Outputs[1] { @129D stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_12A1: // Incoming call from 0x114C, returns to 0x114D // Inputs[3] // { // @12A4 stack[-1] // @12A5 memory[stack[-1]:stack[-1] + 0x20] // @12A8 stack[-2] // } 12A1 5B JUMPDEST 12A2 60 PUSH1 0x00 12A4 81 DUP2 12A5 51 MLOAD 12A6 90 SWAP1 12A7 50 POP 12A8 91 SWAP2 12A9 90 SWAP1 12AA 50 POP 12AB 56 *JUMP // Stack delta = -1 // Outputs[1] { @12A8 stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-2] label_12AC: // Incoming call from 0x10DD, returns to 0x10DE // Inputs[3] // { // @12AF stack[-2] // @12B0 stack[-1] // @12B8 stack[-3] // } 12AC 5B JUMPDEST 12AD 60 PUSH1 0x00 12AF 82 DUP3 12B0 82 DUP3 12B1 52 MSTORE 12B2 60 PUSH1 0x20 12B4 82 DUP3 12B5 01 ADD 12B6 90 SWAP1 12B7 50 POP 12B8 92 SWAP3 12B9 91 SWAP2 12BA 50 POP 12BB 50 POP 12BC 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @12B1 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @12B8 stack[-3] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-3] label_12BD: // Incoming call from 0x10AF, returns to 0x10B0 // Incoming call from 0x1116, returns to 0x1117 // Inputs[3] // { // @12C0 stack[-1] // @12C3 stack[-3] // @12C4 stack[-2] // } 12BD 5B JUMPDEST 12BE 60 PUSH1 0x00 12C0 81 DUP2 12C1 90 SWAP1 12C2 50 POP 12C3 92 SWAP3 12C4 91 SWAP2 12C5 50 POP 12C6 50 POP 12C7 56 *JUMP // Stack delta = -2 // Outputs[1] { @12C3 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_12C8: // Incoming call from 0x1156, returns to 0x1157 // Inputs[3] // { // @12CB stack[-2] // @12CC stack[-1] // @12D4 stack[-3] // } 12C8 5B JUMPDEST 12C9 60 PUSH1 0x00 12CB 82 DUP3 12CC 82 DUP3 12CD 52 MSTORE 12CE 60 PUSH1 0x20 12D0 82 DUP3 12D1 01 ADD 12D2 90 SWAP1 12D3 50 POP 12D4 92 SWAP3 12D5 91 SWAP2 12D6 50 POP 12D7 50 POP 12D8 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @12CD memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @12D4 stack[-3] = stack[-1] + 0x20 // } // Block ends with unconditional jump to stack[-3] label_12D9: // Incoming call from 0x149B, returns to 0x149C // Incoming call from 0x108E, returns to 0x108F // Inputs[1] { @12DF stack[-1] } 12D9 5B JUMPDEST 12DA 60 PUSH1 0x00 12DC 61 PUSH2 0x12e4 12DF 82 DUP3 12E0 61 PUSH2 0x130a 12E3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @12DA stack[0] = 0x00 // @12DC stack[1] = 0x12e4 // @12DF stack[2] = stack[-1] // } // Block ends with call to 0x130a, returns to 0x12E4 label_12E4: // Incoming return from call to 0x130A at 0x12E3 // Inputs[4] // { // @12E5 stack[-1] // @12E5 stack[-2] // @12E7 stack[-4] // @12E8 stack[-3] // } 12E4 5B JUMPDEST 12E5 90 SWAP1 12E6 50 POP 12E7 91 SWAP2 12E8 90 SWAP1 12E9 50 POP 12EA 56 *JUMP // Stack delta = -3 // Outputs[1] { @12E7 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_12EB: // Incoming call from 0x14B2, returns to 0x14B3 // Incoming call from 0x109D, returns to 0x109E // Inputs[2] // { // @12EE stack[-1] // @12F3 stack[-2] // } 12EB 5B JUMPDEST 12EC 60 PUSH1 0x00 12EE 81 DUP2 12EF 15 ISZERO 12F0 15 ISZERO 12F1 90 SWAP1 12F2 50 POP 12F3 91 SWAP2 12F4 90 SWAP1 12F5 50 POP 12F6 56 *JUMP // Stack delta = -1 // Outputs[1] { @12F3 stack[-2] = !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_12F7: // Incoming call from 0x1334, returns to 0x1335 // Inputs[1] { @12FA stack[-1] } 12F7 5B JUMPDEST 12F8 60 PUSH1 0x00 12FA 81 DUP2 12FB 90 SWAP1 12FC 50 POP 12FD 61 PUSH2 0x1305 1300 82 DUP3 1301 61 PUSH2 0x147f 1304 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @12FB stack[0] = stack[-1] // @12FD stack[1] = 0x1305 // @1300 stack[2] = stack[-1] // } // Block ends with call to 0x147f, returns to 0x1305 label_1305: // Incoming return from call to 0x147F at 0x1304 // Inputs[3] // { // @1306 stack[-1] // @1306 stack[-3] // @1307 stack[-2] // } 1305 5B JUMPDEST 1306 91 SWAP2 1307 90 SWAP1 1308 50 POP 1309 56 *JUMP // Stack delta = -2 // Outputs[1] { @1306 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_130A: // Incoming call from 0x12E3, returns to 0x12E4 // Inputs[2] // { // @1322 stack[-1] // @1326 stack[-2] // } 130A 5B JUMPDEST 130B 60 PUSH1 0x00 130D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1322 82 DUP3 1323 16 AND 1324 90 SWAP1 1325 50 POP 1326 91 SWAP2 1327 90 SWAP1 1328 50 POP 1329 56 *JUMP // Stack delta = -1 // Outputs[1] { @1326 stack[-2] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff } // Block ends with unconditional jump to stack[-2] label_132A: // Incoming call from 0x113B, returns to 0x113C // Inputs[1] { @1330 stack[-1] } 132A 5B JUMPDEST 132B 60 PUSH1 0x00 132D 61 PUSH2 0x1335 1330 82 DUP3 1331 61 PUSH2 0x12f7 1334 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @132B stack[0] = 0x00 // @132D stack[1] = 0x1335 // @1330 stack[2] = stack[-1] // } // Block ends with call to 0x12f7, returns to 0x1335 label_1335: // Incoming return from call to 0x12F7 at 0x1334 // Inputs[4] // { // @1336 stack[-1] // @1336 stack[-2] // @1338 stack[-4] // @1339 stack[-3] // } 1335 5B JUMPDEST 1336 90 SWAP1 1337 50 POP 1338 91 SWAP2 1339 90 SWAP1 133A 50 POP 133B 56 *JUMP // Stack delta = -3 // Outputs[1] { @1338 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_133C: // Incoming call from 0x10BC, returns to 0x10BD // Inputs[5] // { // @133D stack[-3] // @133E stack[-1] // @133F stack[-2] // @1340 msg.data[stack[-1]:stack[-1] + stack[-3]] // @134A stack[-4] // } 133C 5B JUMPDEST 133D 82 DUP3 133E 81 DUP2 133F 83 DUP4 1340 37 CALLDATACOPY 1341 60 PUSH1 0x00 1343 83 DUP4 1344 83 DUP4 1345 01 ADD 1346 52 MSTORE 1347 50 POP 1348 50 POP 1349 50 POP 134A 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1340 memory[stack[-2]:stack[-2] + stack[-3]] = msg.data[stack[-1]:stack[-1] + stack[-3]] // @1346 memory[stack[-2] + stack[-3]:stack[-2] + stack[-3] + 0x20] = 0x00 // } // Block ends with unconditional jump to stack[-4] label_134B: // Incoming call from 0x0DF8, returns to 0x0DF9 // Incoming call from 0x1166, returns to 0x1167 // Incoming call from 0x10ED, returns to 0x10EE // Incoming call from 0x1126, returns to 0x1127 // Inputs[1] { @134F stack[-3] } 134B 5B JUMPDEST 134C 60 PUSH1 0x00 134E 5B JUMPDEST 134F 83 DUP4 1350 81 DUP2 1351 10 LT 1352 15 ISZERO 1353 61 PUSH2 0x1369 1356 57 *JUMPI // Stack delta = +1 // Outputs[1] { @134C stack[0] = 0x00 } // Block ends with conditional jump to 0x1369, if !(0x00 < stack[-3]) label_1357: // Incoming jump from 0x1356, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x1356, if not !(0x00 < stack[-3]) // Inputs[4] // { // @1357 stack[-1] // @1358 stack[-2] // @135A memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @135C stack[-3] // } 1357 80 DUP1 1358 82 DUP3 1359 01 ADD 135A 51 MLOAD 135B 81 DUP2 135C 84 DUP5 135D 01 ADD 135E 52 MSTORE 135F 60 PUSH1 0x20 1361 81 DUP2 1362 01 ADD 1363 90 SWAP1 1364 50 POP 1365 61 PUSH2 0x134e 1368 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @135E memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @1363 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x134e label_1369: // Incoming jump from 0x1356, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1356, if !(0x00 < stack[-3]) // Inputs[2] // { // @136A stack[-4] // @136B stack[-1] // } 1369 5B JUMPDEST 136A 83 DUP4 136B 81 DUP2 136C 11 GT 136D 15 ISZERO 136E 61 PUSH2 0x1378 1371 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1378, if !(stack[-1] > stack[-4]) label_1372: // Incoming jump from 0x1371, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @1374 stack[-4] // @1375 stack[-3] // @137D stack[-5] // } 1372 60 PUSH1 0x00 1374 84 DUP5 1375 84 DUP5 1376 01 ADD 1377 52 MSTORE 1378 5B JUMPDEST 1379 50 POP 137A 50 POP 137B 50 POP 137C 50 POP 137D 56 *JUMP // Stack delta = -5 // Outputs[1] { @1377 memory[stack[-3] + stack[-4]:stack[-3] + stack[-4] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_137E: // Incoming call from 0x0CA5, returns to 0x0CA6 // Incoming call from 0x0D2B, returns to 0x0D2C // Incoming call from 0x0B32, returns to 0x0B33 // Incoming call from 0x0B5E, returns to 0x0B5F // Inputs[1] { @1383 stack[-1] } 137E 5B JUMPDEST 137F 60 PUSH1 0x00 1381 60 PUSH1 0x02 1383 82 DUP3 1384 04 DIV 1385 90 SWAP1 1386 50 POP 1387 60 PUSH1 0x01 1389 82 DUP3 138A 16 AND 138B 80 DUP1 138C 61 PUSH2 0x1396 138F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1385 stack[0] = stack[-1] / 0x02 // @138A stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x1396, if stack[-1] & 0x01 label_1390: // Incoming jump from 0x138F, if not stack[-1] & 0x01 // Inputs[2] // { // @1392 stack[-2] // @139B stack[-1] // } 1390 60 PUSH1 0x7f 1392 82 DUP3 1393 16 AND 1394 91 SWAP2 1395 50 POP 1396 5B JUMPDEST 1397 60 PUSH1 0x20 1399 82 DUP3 139A 10 LT 139B 81 DUP2 139C 14 EQ 139D 15 ISZERO 139E 61 PUSH2 0x13aa 13A1 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1394 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x13aa, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_13A2: // Incoming jump from 0x13A1, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x13A1, if not !(stack[-1] == (stack[-2] < 0x20)) 13A2 61 PUSH2 0x13a9 13A5 61 PUSH2 0x1410 13A8 56 *JUMP // Stack delta = +1 // Outputs[1] { @13A2 stack[0] = 0x13a9 } // Block ends with unconditional jump to 0x1410 13A9 5B JUMPDEST label_13AA: // Incoming jump from 0x13A1, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x13A1, if !(stack[-1] == (stack[-2] < 0x20)) // Inputs[3] // { // @13AC stack[-4] // @13AC stack[-2] // @13AD stack[-3] // } 13AA 5B JUMPDEST 13AB 50 POP 13AC 91 SWAP2 13AD 90 SWAP1 13AE 50 POP 13AF 56 *JUMP // Stack delta = -3 // Outputs[1] { @13AC stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_13B0: // Incoming call from 0x1255, returns to 0x1256 // Inputs[1] { @13B4 stack[-2] } 13B0 5B JUMPDEST 13B1 61 PUSH2 0x13b9 13B4 82 DUP3 13B5 61 PUSH2 0x146e 13B8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @13B1 stack[0] = 0x13b9 // @13B4 stack[1] = stack[-2] // } // Block ends with call to 0x146e, returns to 0x13B9 label_13B9: // Incoming return from call to 0x146E at 0x13B8 // Inputs[2] // { // @13BA stack[-2] // @13BB stack[-1] // } 13B9 5B JUMPDEST 13BA 81 DUP2 13BB 01 ADD 13BC 81 DUP2 13BD 81 DUP2 13BE 10 LT 13BF 67 PUSH8 0xffffffffffffffff 13C8 82 DUP3 13C9 11 GT 13CA 17 OR 13CB 15 ISZERO 13CC 61 PUSH2 0x13d8 13CF 57 *JUMPI // Stack delta = +0 // Outputs[1] { @13BB stack[-1] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x13d8, if !((stack[-2] + stack[-1] > 0xffffffffffffffff) | (stack[-2] + stack[-1] < stack[-2])) label_13D0: // Incoming jump from 0x13CF, if not !((stack[-2] + stack[-1] > 0xffffffffffffffff) | (stack[-2] + stack[-1] < stack[-2])) 13D0 61 PUSH2 0x13d7 13D3 61 PUSH2 0x143f 13D6 56 *JUMP // Stack delta = +1 // Outputs[1] { @13D0 stack[0] = 0x13d7 } // Block ends with unconditional jump to 0x143f 13D7 5B JUMPDEST label_13D8: // Incoming jump from 0x13CF, if !((stack[-2] + stack[-1] > 0xffffffffffffffff) | (stack[-2] + stack[-1] < stack[-2])) // Inputs[2] // { // @13D9 stack[-1] // @13E0 stack[-4] // } 13D8 5B JUMPDEST 13D9 80 DUP1 13DA 60 PUSH1 0x40 13DC 52 MSTORE 13DD 50 POP 13DE 50 POP 13DF 50 POP 13E0 56 *JUMP // Stack delta = -4 // Outputs[1] { @13DC memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_13E1: // Incoming jump from 0x148E // Inputs[1] { @140F memory[0x00:0x24] } 13E1 5B JUMPDEST 13E2 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 1403 60 PUSH1 0x00 1405 52 MSTORE 1406 60 PUSH1 0x21 1408 60 PUSH1 0x04 140A 52 MSTORE 140B 60 PUSH1 0x24 140D 60 PUSH1 0x00 140F FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1405 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @140A memory[0x04:0x24] = 0x21 // @140F revert(memory[0x00:0x24]); // } // Block terminates label_1410: // Incoming jump from 0x13A8 // Inputs[1] { @143E memory[0x00:0x24] } 1410 5B JUMPDEST 1411 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 1432 60 PUSH1 0x00 1434 52 MSTORE 1435 60 PUSH1 0x22 1437 60 PUSH1 0x04 1439 52 MSTORE 143A 60 PUSH1 0x24 143C 60 PUSH1 0x00 143E FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1434 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @1439 memory[0x04:0x24] = 0x22 // @143E revert(memory[0x00:0x24]); // } // Block terminates label_143F: // Incoming jump from 0x127E // Incoming jump from 0x13D6 // Inputs[1] { @146D memory[0x00:0x24] } 143F 5B JUMPDEST 1440 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 1461 60 PUSH1 0x00 1463 52 MSTORE 1464 60 PUSH1 0x41 1466 60 PUSH1 0x04 1468 52 MSTORE 1469 60 PUSH1 0x24 146B 60 PUSH1 0x00 146D FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1463 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @1468 memory[0x04:0x24] = 0x41 // @146D revert(memory[0x00:0x24]); // } // Block terminates label_146E: // Incoming call from 0x10F6, returns to 0x10F7 // Incoming call from 0x13B8, returns to 0x13B9 // Incoming call from 0x116F, returns to 0x1170 // Incoming call from 0x1288, returns to 0x1289 // Inputs[2] // { // @1476 stack[-1] // @147B stack[-2] // } 146E 5B JUMPDEST 146F 60 PUSH1 0x00 1471 60 PUSH1 0x1f 1473 19 NOT 1474 60 PUSH1 0x1f 1476 83 DUP4 1477 01 ADD 1478 16 AND 1479 90 SWAP1 147A 50 POP 147B 91 SWAP2 147C 90 SWAP1 147D 50 POP 147E 56 *JUMP // Stack delta = -1 // Outputs[1] { @147B stack[-2] = stack[-1] + 0x1f & ~0x1f } // Block ends with unconditional jump to stack[-2] label_147F: // Incoming call from 0x1304, returns to 0x1305 // Inputs[1] { @1482 stack[-1] } 147F 5B JUMPDEST 1480 60 PUSH1 0x02 1482 81 DUP2 1483 10 LT 1484 61 PUSH2 0x1490 1487 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1490, if stack[-1] < 0x02 label_1488: // Incoming jump from 0x1487, if not stack[-1] < 0x02 1488 61 PUSH2 0x148f 148B 61 PUSH2 0x13e1 148E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1488 stack[0] = 0x148f } // Block ends with unconditional jump to 0x13e1 148F 5B JUMPDEST label_1490: // Incoming jump from 0x1487, if stack[-1] < 0x02 // Inputs[1] { @1492 stack[-2] } 1490 5B JUMPDEST 1491 50 POP 1492 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1493: // Incoming call from 0x0E0F, returns to 0x0E10 // Incoming call from 0x0E24, returns to 0x0E25 // Inputs[1] { @1497 stack[-1] } 1493 5B JUMPDEST 1494 61 PUSH2 0x149c 1497 81 DUP2 1498 61 PUSH2 0x12d9 149B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1494 stack[0] = 0x149c // @1497 stack[1] = stack[-1] // } // Block ends with call to 0x12d9, returns to 0x149C label_149C: // Incoming return from call to 0x12D9 at 0x149B // Inputs[2] // { // @149D stack[-2] // @149E stack[-1] // } 149C 5B JUMPDEST 149D 81 DUP2 149E 14 EQ 149F 61 PUSH2 0x14a7 14A2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x14a7, if stack[-2] == stack[-1] label_14A3: // Incoming jump from 0x14A2, if not stack[-2] == stack[-1] // Inputs[1] { @14A6 memory[0x00:0x00] } 14A3 60 PUSH1 0x00 14A5 80 DUP1 14A6 FD *REVERT // Stack delta = +0 // Outputs[1] { @14A6 revert(memory[0x00:0x00]); } // Block terminates label_14A7: // Incoming jump from 0x14A2, if stack[-2] == stack[-1] // Inputs[1] { @14A9 stack[-2] } 14A7 5B JUMPDEST 14A8 50 POP 14A9 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_14AA: // Incoming call from 0x0E39, returns to 0x0E3A // Inputs[1] { @14AE stack[-1] } 14AA 5B JUMPDEST 14AB 61 PUSH2 0x14b3 14AE 81 DUP2 14AF 61 PUSH2 0x12eb 14B2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @14AB stack[0] = 0x14b3 // @14AE stack[1] = stack[-1] // } // Block ends with call to 0x12eb, returns to 0x14B3 label_14B3: // Incoming return from call to 0x12EB at 0x14B2 // Inputs[2] // { // @14B4 stack[-2] // @14B5 stack[-1] // } 14B3 5B JUMPDEST 14B4 81 DUP2 14B5 14 EQ 14B6 61 PUSH2 0x14be 14B9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x14be, if stack[-2] == stack[-1] label_14BA: // Incoming jump from 0x14B9, if not stack[-2] == stack[-1] // Inputs[1] { @14BD memory[0x00:0x00] } 14BA 60 PUSH1 0x00 14BC 80 DUP1 14BD FD *REVERT // Stack delta = +0 // Outputs[1] { @14BD revert(memory[0x00:0x00]); } // Block terminates label_14BE: // Incoming jump from 0x14B9, if stack[-2] == stack[-1] // Inputs[1] { @14C0 stack[-2] } 14BE 5B JUMPDEST 14BF 50 POP 14C0 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_14C1: // Incoming call from 0x0EC2, returns to 0x0EC3 // Incoming call from 0x0ED7, returns to 0x0ED8 // Inputs[1] { @14C4 stack[-1] } 14C1 5B JUMPDEST 14C2 60 PUSH1 0x02 14C4 81 DUP2 14C5 10 LT 14C6 61 PUSH2 0x14ce 14C9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14ce, if stack[-1] < 0x02 label_14CA: // Incoming jump from 0x14C9, if not stack[-1] < 0x02 // Inputs[1] { @14CD memory[0x00:0x00] } 14CA 60 PUSH1 0x00 14CC 80 DUP1 14CD FD *REVERT // Stack delta = +0 // Outputs[1] { @14CD revert(memory[0x00:0x00]); } // Block terminates label_14CE: // Incoming jump from 0x14C9, if stack[-1] < 0x02 // Inputs[1] { @14D0 stack[-2] } 14CE 5B JUMPDEST 14CF 50 POP 14D0 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] 14D1 FE *ASSERT 14D2 A2 LOG2 14D3 64 PUSH5 0x6970667358 14D9 22 22 14DA 12 SLT 14DB 20 SHA3 14DC 56 *JUMP 14DD 21 21 14DE 64 PUSH5 0x5ef4f57a47 14E4 BA BA 14E5 A5 A5 14E6 4D 4D 14E7 BE BE 14E8 1F 1F 14E9 93 SWAP4 14EA 4D 4D 14EB E7 E7 14EC 00 *STOP 14ED 97 SWAP8 14EE BB BB 14EF CD CD 14F0 8A DUP11 14F1 D7 D7 14F2 1F 1F 14F3 B1 DUP 14F4 AC AC 14F5 A1 LOG1 14F6 C3 C3 14F7 CC CC 14F8 85 DUP6 14F9 A5 A5 14FA CA CA 14FB A5 A5 14FC 64 PUSH5 0x736f6c6343 1502 00 *STOP 1503 08 ADDMOD 1504 04 DIV 1505 00 *STOP 1506 33 CALLER