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 0x01b9 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01b9, 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 0x6a627842 0026 11 GT 0027 61 PUSH2 0x00f9 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00f9, if 0x6a627842 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x6a627842 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xba9a7a56 0031 11 GT 0032 61 PUSH2 0x0097 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0097, if 0xba9a7a56 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xba9a7a56 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xd21220a7 003C 11 GT 003D 61 PUSH2 0x0071 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0071, if 0xd21220a7 > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xd21220a7 > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xd21220a7 0047 14 EQ 0048 61 PUSH2 0x05da 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05da, if 0xd21220a7 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xd21220a7 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xd505accf 0052 14 EQ 0053 61 PUSH2 0x05e2 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05e2, if 0xd505accf == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xd505accf == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xdd62ed3e 005D 14 EQ 005E 61 PUSH2 0x0640 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0640, if 0xdd62ed3e == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xdd62ed3e == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xfff6cae9 0068 14 EQ 0069 61 PUSH2 0x067b 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x067b, if 0xfff6cae9 == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xfff6cae9 == stack[-1] 006D 61 PUSH2 0x01b9 0070 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01b9 label_0071: // Incoming jump from 0x0040, if 0xd21220a7 > stack[-1] // Inputs[1] { @0072 stack[-1] } 0071 5B JUMPDEST 0072 80 DUP1 0073 63 PUSH4 0xba9a7a56 0078 14 EQ 0079 61 PUSH2 0x0597 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0597, if 0xba9a7a56 == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0xba9a7a56 == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0xbc25cf77 0083 14 EQ 0084 61 PUSH2 0x059f 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x059f, if 0xbc25cf77 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xbc25cf77 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xc45a0155 008E 14 EQ 008F 61 PUSH2 0x05d2 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d2, if 0xc45a0155 == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xc45a0155 == stack[-1] 0093 61 PUSH2 0x01b9 0096 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01b9 label_0097: // Incoming jump from 0x0035, if 0xba9a7a56 > stack[-1] // Inputs[1] { @0098 stack[-1] } 0097 5B JUMPDEST 0098 80 DUP1 0099 63 PUSH4 0x7ecebe00 009E 11 GT 009F 61 PUSH2 0x00d3 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d3, if 0x7ecebe00 > stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0x7ecebe00 > stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0x7ecebe00 00A9 14 EQ 00AA 61 PUSH2 0x04d7 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d7, if 0x7ecebe00 == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x7ecebe00 == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x89afcb44 00B4 14 EQ 00B5 61 PUSH2 0x050a 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x050a, if 0x89afcb44 == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x89afcb44 == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x95d89b41 00BF 14 EQ 00C0 61 PUSH2 0x0556 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0556, if 0x95d89b41 == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0xa9059cbb 00CA 14 EQ 00CB 61 PUSH2 0x055e 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x055e, if 0xa9059cbb == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0xa9059cbb == stack[-1] 00CF 61 PUSH2 0x01b9 00D2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01b9 label_00D3: // Incoming jump from 0x00A2, if 0x7ecebe00 > stack[-1] // Inputs[1] { @00D4 stack[-1] } 00D3 5B JUMPDEST 00D4 80 DUP1 00D5 63 PUSH4 0x6a627842 00DA 14 EQ 00DB 61 PUSH2 0x0469 00DE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0469, if 0x6a627842 == stack[-1] label_00DF: // Incoming jump from 0x00DE, if not 0x6a627842 == stack[-1] // Inputs[1] { @00DF stack[-1] } 00DF 80 DUP1 00E0 63 PUSH4 0x70a08231 00E5 14 EQ 00E6 61 PUSH2 0x049c 00E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x049c, if 0x70a08231 == stack[-1] label_00EA: // Incoming jump from 0x00E9, if not 0x70a08231 == stack[-1] // Inputs[1] { @00EA stack[-1] } 00EA 80 DUP1 00EB 63 PUSH4 0x7464fc3d 00F0 14 EQ 00F1 61 PUSH2 0x04cf 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04cf, if 0x7464fc3d == stack[-1] label_00F5: // Incoming jump from 0x00F4, if not 0x7464fc3d == stack[-1] 00F5 61 PUSH2 0x01b9 00F8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01b9 label_00F9: // Incoming jump from 0x002A, if 0x6a627842 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00FA stack[-1] } 00F9 5B JUMPDEST 00FA 80 DUP1 00FB 63 PUSH4 0x23b872dd 0100 11 GT 0101 61 PUSH2 0x0166 0104 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0166, if 0x23b872dd > stack[-1] label_0105: // Incoming jump from 0x0104, if not 0x23b872dd > stack[-1] // Inputs[1] { @0105 stack[-1] } 0105 80 DUP1 0106 63 PUSH4 0x3644e515 010B 11 GT 010C 61 PUSH2 0x0140 010F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0140, if 0x3644e515 > stack[-1] label_0110: // Incoming jump from 0x010F, if not 0x3644e515 > stack[-1] // Inputs[1] { @0110 stack[-1] } 0110 80 DUP1 0111 63 PUSH4 0x3644e515 0116 14 EQ 0117 61 PUSH2 0x0416 011A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0416, if 0x3644e515 == stack[-1] label_011B: // Incoming jump from 0x011A, if not 0x3644e515 == stack[-1] // Inputs[1] { @011B stack[-1] } 011B 80 DUP1 011C 63 PUSH4 0x485cc955 0121 14 EQ 0122 61 PUSH2 0x041e 0125 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x041e, if 0x485cc955 == stack[-1] label_0126: // Incoming jump from 0x0125, if not 0x485cc955 == stack[-1] // Inputs[1] { @0126 stack[-1] } 0126 80 DUP1 0127 63 PUSH4 0x5909c0d5 012C 14 EQ 012D 61 PUSH2 0x0459 0130 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0459, if 0x5909c0d5 == stack[-1] label_0131: // Incoming jump from 0x0130, if not 0x5909c0d5 == stack[-1] // Inputs[1] { @0131 stack[-1] } 0131 80 DUP1 0132 63 PUSH4 0x5a3d5493 0137 14 EQ 0138 61 PUSH2 0x0461 013B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0461, if 0x5a3d5493 == stack[-1] label_013C: // Incoming jump from 0x013B, if not 0x5a3d5493 == stack[-1] 013C 61 PUSH2 0x01b9 013F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01b9 label_0140: // Incoming jump from 0x010F, if 0x3644e515 > stack[-1] // Inputs[1] { @0141 stack[-1] } 0140 5B JUMPDEST 0141 80 DUP1 0142 63 PUSH4 0x23b872dd 0147 14 EQ 0148 61 PUSH2 0x03ad 014B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ad, if 0x23b872dd == stack[-1] label_014C: // Incoming jump from 0x014B, if not 0x23b872dd == stack[-1] // Inputs[1] { @014C stack[-1] } 014C 80 DUP1 014D 63 PUSH4 0x30adf81f 0152 14 EQ 0153 61 PUSH2 0x03f0 0156 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f0, if 0x30adf81f == stack[-1] label_0157: // Incoming jump from 0x0156, if not 0x30adf81f == stack[-1] // Inputs[1] { @0157 stack[-1] } 0157 80 DUP1 0158 63 PUSH4 0x313ce567 015D 14 EQ 015E 61 PUSH2 0x03f8 0161 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f8, if 0x313ce567 == stack[-1] label_0162: // Incoming jump from 0x0161, if not 0x313ce567 == stack[-1] 0162 61 PUSH2 0x01b9 0165 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01b9 label_0166: // Incoming jump from 0x0104, if 0x23b872dd > stack[-1] // Inputs[1] { @0167 stack[-1] } 0166 5B JUMPDEST 0167 80 DUP1 0168 63 PUSH4 0x095ea7b3 016D 11 GT 016E 61 PUSH2 0x0197 0171 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0197, if 0x095ea7b3 > stack[-1] label_0172: // Incoming jump from 0x0171, if not 0x095ea7b3 > stack[-1] // Inputs[1] { @0172 stack[-1] } 0172 80 DUP1 0173 63 PUSH4 0x095ea7b3 0178 14 EQ 0179 61 PUSH2 0x0315 017C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0315, if 0x095ea7b3 == stack[-1] label_017D: // Incoming jump from 0x017C, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @017D stack[-1] } 017D 80 DUP1 017E 63 PUSH4 0x0dfe1681 0183 14 EQ 0184 61 PUSH2 0x0362 0187 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0362, if 0x0dfe1681 == stack[-1] label_0188: // Incoming jump from 0x0187, if not 0x0dfe1681 == stack[-1] // Inputs[1] { @0188 stack[-1] } 0188 80 DUP1 0189 63 PUSH4 0x18160ddd 018E 14 EQ 018F 61 PUSH2 0x0393 0192 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0393, if 0x18160ddd == stack[-1] label_0193: // Incoming jump from 0x0192, if not 0x18160ddd == stack[-1] 0193 61 PUSH2 0x01b9 0196 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01b9 label_0197: // Incoming jump from 0x0171, if 0x095ea7b3 > stack[-1] // Inputs[1] { @0198 stack[-1] } 0197 5B JUMPDEST 0198 80 DUP1 0199 63 PUSH4 0x022c0d9f 019E 14 EQ 019F 61 PUSH2 0x01be 01A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01be, if 0x022c0d9f == stack[-1] label_01A3: // Incoming jump from 0x01A2, if not 0x022c0d9f == stack[-1] // Inputs[1] { @01A3 stack[-1] } 01A3 80 DUP1 01A4 63 PUSH4 0x06fdde03 01A9 14 EQ 01AA 61 PUSH2 0x0259 01AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0259, if 0x06fdde03 == stack[-1] label_01AE: // Incoming jump from 0x01AD, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01AE stack[-1] } 01AE 80 DUP1 01AF 63 PUSH4 0x0902f1ac 01B4 14 EQ 01B5 61 PUSH2 0x02d6 01B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d6, if 0x0902f1ac == stack[-1] label_01B9: // Incoming jump from 0x00F8 // Incoming jump from 0x0070 // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x00D2 // Incoming jump from 0x0165 // Incoming jump from 0x01B8, if not 0x0902f1ac == stack[-1] // Incoming jump from 0x013F // Incoming jump from 0x0096 // Incoming jump from 0x0196 // Inputs[1] { @01BD memory[0x00:0x00] } 01B9 5B JUMPDEST 01BA 60 PUSH1 0x00 01BC 80 DUP1 01BD FD *REVERT // Stack delta = +0 // Outputs[1] { @01BD revert(memory[0x00:0x00]); } // Block terminates label_01BE: // Incoming jump from 0x01A2, if 0x022c0d9f == stack[-1] // Inputs[1] { @01C5 msg.data.length } 01BE 5B JUMPDEST 01BF 61 PUSH2 0x0257 01C2 60 PUSH1 0x04 01C4 80 DUP1 01C5 36 CALLDATASIZE 01C6 03 SUB 01C7 60 PUSH1 0x80 01C9 81 DUP2 01CA 10 LT 01CB 15 ISZERO 01CC 61 PUSH2 0x01d4 01CF 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @01BF stack[0] = 0x0257 // @01C2 stack[1] = 0x04 // @01C6 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x01d4, returns to 0x0257, if !(msg.data.length - 0x04 < 0x80) label_01D0: // Incoming jump from 0x01CF, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @01D3 memory[0x00:0x00] } 01D0 60 PUSH1 0x00 01D2 80 DUP1 01D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D3 revert(memory[0x00:0x00]); } // Block terminates label_01D4: // Incoming call from 0x01CF, returns to 0x0257, if !(msg.data.length - 0x04 < 0x80) // Inputs[6] // { // @01D5 stack[-2] // @01D6 msg.data[stack[-2]:stack[-2] + 0x20] // @01DC msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @01DD stack[-1] // @01F7 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0206 msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } 01D4 5B JUMPDEST 01D5 81 DUP2 01D6 35 CALLDATALOAD 01D7 91 SWAP2 01D8 60 PUSH1 0x20 01DA 81 DUP2 01DB 01 ADD 01DC 35 CALLDATALOAD 01DD 91 SWAP2 01DE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01F3 60 PUSH1 0x40 01F5 83 DUP4 01F6 01 ADD 01F7 35 CALLDATALOAD 01F8 16 AND 01F9 91 SWAP2 01FA 90 SWAP1 01FB 81 DUP2 01FC 01 ADD 01FD 90 SWAP1 01FE 60 PUSH1 0x80 0200 81 DUP2 0201 01 ADD 0202 60 PUSH1 0x60 0204 82 DUP3 0205 01 ADD 0206 35 CALLDATALOAD 0207 64 PUSH5 0x0100000000 020D 81 DUP2 020E 11 GT 020F 15 ISZERO 0210 61 PUSH2 0x0218 0213 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @01D7 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @01DD stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @01F9 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff // @01FD stack[1] = stack[-2] + stack[-1] // @01FD stack[2] = stack[-2] // @0201 stack[3] = stack[-2] + 0x80 // @0206 stack[4] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x0218, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x0100000000) label_0214: // Incoming jump from 0x0213, if not !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x0100000000) // Inputs[1] { @0217 memory[0x00:0x00] } 0214 60 PUSH1 0x00 0216 80 DUP1 0217 FD *REVERT // Stack delta = +0 // Outputs[1] { @0217 revert(memory[0x00:0x00]); } // Block terminates label_0218: // Incoming jump from 0x0213, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x0100000000) // Inputs[3] // { // @0219 stack[-3] // @021A stack[-1] // @021B stack[-4] // } 0218 5B JUMPDEST 0219 82 DUP3 021A 01 ADD 021B 83 DUP4 021C 60 PUSH1 0x20 021E 82 DUP3 021F 01 ADD 0220 11 GT 0221 15 ISZERO 0222 61 PUSH2 0x022a 0225 57 *JUMPI // Stack delta = +0 // Outputs[1] { @021A stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x022a, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0226: // Incoming jump from 0x0225, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0229 memory[0x00:0x00] } 0226 60 PUSH1 0x00 0228 80 DUP1 0229 FD *REVERT // Stack delta = +0 // Outputs[1] { @0229 revert(memory[0x00:0x00]); } // Block terminates label_022A: // Incoming jump from 0x0225, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @022B stack[-1] // @022C msg.data[stack[-1]:stack[-1] + 0x20] // @0231 stack[-2] // @0232 stack[-4] // } 022A 5B JUMPDEST 022B 80 DUP1 022C 35 CALLDATALOAD 022D 90 SWAP1 022E 60 PUSH1 0x20 0230 01 ADD 0231 91 SWAP2 0232 84 DUP5 0233 60 PUSH1 0x01 0235 83 DUP4 0236 02 MUL 0237 84 DUP5 0238 01 ADD 0239 11 GT 023A 64 PUSH5 0x0100000000 0240 83 DUP4 0241 11 GT 0242 17 OR 0243 15 ISZERO 0244 61 PUSH2 0x024c 0247 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @022D stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0231 stack[0] = stack[-2] // @0231 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x024c, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0248: // Incoming jump from 0x0247, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @024B memory[0x00:0x00] } 0248 60 PUSH1 0x00 024A 80 DUP1 024B FD *REVERT // Stack delta = +0 // Outputs[1] { @024B revert(memory[0x00:0x00]); } // Block terminates label_024C: // Incoming jump from 0x0247, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[4] // { // @024E stack[-3] // @024E stack[-2] // @024F stack[-5] // @0251 stack[-4] // } 024C 5B JUMPDEST 024D 50 POP 024E 90 SWAP1 024F 92 SWAP3 0250 50 POP 0251 90 SWAP1 0252 50 POP 0253 61 PUSH2 0x0683 0256 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @024F stack[-5] = stack[-3] // @0251 stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x0683 label_0257: // Incoming return from call to 0x0434 at 0x042F // Incoming return from call to 0x1DF5 at 0x0682 // Incoming return from call to 0x05F8 at 0x05F3 // Incoming return from call to 0x05B5 at 0x05B0 // Incoming return from call to 0x01D4 at 0x01CF 0257 5B JUMPDEST 0258 00 *STOP // Stack delta = +0 // Outputs[1] { @0258 stop(); } // Block terminates label_0259: // Incoming jump from 0x01AD, if 0x06fdde03 == stack[-1] 0259 5B JUMPDEST 025A 61 PUSH2 0x0261 025D 61 PUSH2 0x0d57 0260 56 *JUMP // Stack delta = +1 // Outputs[1] { @025A stack[0] = 0x0261 } // Block ends with call to 0x0d57, returns to 0x0261 label_0261: // Incoming return from call to 0x1892 at 0x055D // Incoming return from call to 0x0D57 at 0x0260 // Inputs[4] // { // @0265 memory[0x40:0x60] // @026B stack[-1] // @026C memory[stack[-1]:stack[-1] + 0x20] // @0272 memory[stack[-1]:stack[-1] + 0x20] // } 0261 5B JUMPDEST 0262 60 PUSH1 0x40 0264 80 DUP1 0265 51 MLOAD 0266 60 PUSH1 0x20 0268 80 DUP1 0269 82 DUP3 026A 52 MSTORE 026B 83 DUP4 026C 51 MLOAD 026D 81 DUP2 026E 83 DUP4 026F 01 ADD 0270 52 MSTORE 0271 83 DUP4 0272 51 MLOAD 0273 91 SWAP2 0274 92 SWAP3 0275 83 DUP4 0276 92 SWAP3 0277 90 SWAP1 0278 83 DUP4 0279 01 ADD 027A 91 SWAP2 027B 85 DUP6 027C 01 ADD 027D 90 SWAP1 027E 80 DUP1 027F 83 DUP4 0280 83 DUP4 0281 60 PUSH1 0x00 0283 5B JUMPDEST 0284 83 DUP4 0285 81 DUP2 0286 10 LT 0287 15 ISZERO 0288 61 PUSH2 0x029b 028B 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @026A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @0270 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0274 stack[0] = memory[0x40:0x60] // @0276 stack[1] = memory[0x40:0x60] // @027A stack[2] = memory[0x40:0x60] + 0x40 // @027D stack[3] = stack[-1] + 0x20 // @027D stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @027E stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @027F stack[6] = memory[0x40:0x60] + 0x40 // @0280 stack[7] = stack[-1] + 0x20 // @0281 stack[8] = 0x00 // } // Block ends with conditional jump to 0x029b, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_028C: // Incoming jump from 0x028B, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x028B, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @028C stack[-2] // @028D stack[-1] // @028F memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0290 stack[-3] // } 028C 81 DUP2 028D 81 DUP2 028E 01 ADD 028F 51 MLOAD 0290 83 DUP4 0291 82 DUP3 0292 01 ADD 0293 52 MSTORE 0294 60 PUSH1 0x20 0296 01 ADD 0297 61 PUSH2 0x0283 029A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0293 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0296 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x0283 label_029B: // Incoming jump from 0x028B, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x028B, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @02A0 stack[-5] // @02A0 stack[-6] // @02A2 stack[-7] // } 029B 5B JUMPDEST 029C 50 POP 029D 50 POP 029E 50 POP 029F 50 POP 02A0 90 SWAP1 02A1 50 POP 02A2 90 SWAP1 02A3 81 DUP2 02A4 01 ADD 02A5 90 SWAP1 02A6 60 PUSH1 0x1f 02A8 16 AND 02A9 80 DUP1 02AA 15 ISZERO 02AB 61 PUSH2 0x02c8 02AE 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @02A5 stack[-7] = stack[-5] + stack[-7] // @02A8 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x02c8, if !(0x1f & stack[-5]) label_02AF: // Incoming jump from 0x02AE, if not !(0x1f & stack[-5]) // Inputs[6] // { // @02AF stack[-1] // @02B0 stack[-2] // @02B3 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @02CA stack[-5] // @02D0 memory[0x40:0x60] // @02D5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 02AF 80 DUP1 02B0 82 DUP3 02B1 03 SUB 02B2 80 DUP1 02B3 51 MLOAD 02B4 60 PUSH1 0x01 02B6 83 DUP4 02B7 60 PUSH1 0x20 02B9 03 SUB 02BA 61 PUSH2 0x0100 02BD 0A EXP 02BE 03 SUB 02BF 19 NOT 02C0 16 AND 02C1 81 DUP2 02C2 52 MSTORE 02C3 60 PUSH1 0x20 02C5 01 ADD 02C6 91 SWAP2 02C7 50 POP 02C8 5B JUMPDEST 02C9 50 POP 02CA 92 SWAP3 02CB 50 POP 02CC 50 POP 02CD 50 POP 02CE 60 PUSH1 0x40 02D0 51 MLOAD 02D1 80 DUP1 02D2 91 SWAP2 02D3 03 SUB 02D4 90 SWAP1 02D5 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @02C2 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @02D5 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_02D6: // Incoming jump from 0x01B8, if 0x0902f1ac == stack[-1] 02D6 5B JUMPDEST 02D7 61 PUSH2 0x02de 02DA 61 PUSH2 0x0d90 02DD 56 *JUMP // Stack delta = +1 // Outputs[1] { @02D7 stack[0] = 0x02de } // Block ends with call to 0x0d90, returns to 0x02DE label_02DE: // Incoming return from call to 0x0D90 at 0x02DD // Inputs[6] // { // @02E2 memory[0x40:0x60] // @02F2 stack[-3] // @02F7 stack[-2] // @0305 stack[-1] // @030B memory[0x40:0x60] // @0314 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x60 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 02DE 5B JUMPDEST 02DF 60 PUSH1 0x40 02E1 80 DUP1 02E2 51 MLOAD 02E3 6D PUSH14 0xffffffffffffffffffffffffffff 02F2 94 SWAP5 02F3 85 DUP6 02F4 16 AND 02F5 81 DUP2 02F6 52 MSTORE 02F7 92 SWAP3 02F8 90 SWAP1 02F9 93 SWAP4 02FA 16 AND 02FB 60 PUSH1 0x20 02FD 83 DUP4 02FE 01 ADD 02FF 52 MSTORE 0300 63 PUSH4 0xffffffff 0305 16 AND 0306 81 DUP2 0307 83 DUP4 0308 01 ADD 0309 52 MSTORE 030A 90 SWAP1 030B 51 MLOAD 030C 90 SWAP1 030D 81 DUP2 030E 90 SWAP1 030F 03 SUB 0310 60 PUSH1 0x60 0312 01 ADD 0313 90 SWAP1 0314 F3 *RETURN // Stack delta = -3 // Outputs[4] // { // @02F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffff & stack[-3] // @02FF memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffffffffffffffff & stack[-2] // @0309 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = 0xffffffff & stack[-1] // @0314 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x60 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0315: // Incoming jump from 0x017C, if 0x095ea7b3 == stack[-1] // Inputs[1] { @031C msg.data.length } 0315 5B JUMPDEST 0316 61 PUSH2 0x034e 0319 60 PUSH1 0x04 031B 80 DUP1 031C 36 CALLDATASIZE 031D 03 SUB 031E 60 PUSH1 0x40 0320 81 DUP2 0321 10 LT 0322 15 ISZERO 0323 61 PUSH2 0x032b 0326 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0316 stack[0] = 0x034e // @0319 stack[1] = 0x04 // @031D stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x032b, returns to 0x034E, if !(msg.data.length - 0x04 < 0x40) label_0327: // Incoming jump from 0x0326, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @032A memory[0x00:0x00] } 0327 60 PUSH1 0x00 0329 80 DUP1 032A FD *REVERT // Stack delta = +0 // Outputs[1] { @032A revert(memory[0x00:0x00]); } // Block terminates label_032B: // Incoming call from 0x0326, returns to 0x034E, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0342 stack[-2] // @0343 msg.data[stack[-2]:stack[-2] + 0x20] // @0349 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 032B 5B JUMPDEST 032C 50 POP 032D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0342 81 DUP2 0343 35 CALLDATALOAD 0344 16 AND 0345 90 SWAP1 0346 60 PUSH1 0x20 0348 01 ADD 0349 35 CALLDATALOAD 034A 61 PUSH2 0x0de5 034D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0345 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff // @0349 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0de5 label_034E: // Incoming return from call to 0x03C3 at 0x03BE // Incoming return from call to 0x032B at 0x0326 // Inputs[4] // { // @0352 memory[0x40:0x60] // @0353 stack[-1] // @0358 memory[0x40:0x60] // @0361 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 034E 5B JUMPDEST 034F 60 PUSH1 0x40 0351 80 DUP1 0352 51 MLOAD 0353 91 SWAP2 0354 15 ISZERO 0355 15 ISZERO 0356 82 DUP3 0357 52 MSTORE 0358 51 MLOAD 0359 90 SWAP1 035A 81 DUP2 035B 90 SWAP1 035C 03 SUB 035D 60 PUSH1 0x20 035F 01 ADD 0360 90 SWAP1 0361 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0357 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0361 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0362: // Incoming jump from 0x0187, if 0x0dfe1681 == stack[-1] 0362 5B JUMPDEST 0363 61 PUSH2 0x036a 0366 61 PUSH2 0x0dfc 0369 56 *JUMP // Stack delta = +1 // Outputs[1] { @0363 stack[0] = 0x036a } // Block ends with call to 0x0dfc, returns to 0x036A label_036A: // Incoming return from call to 0x1AD4 at 0x05D9 // Incoming return from call to 0x0DFC at 0x0369 // Incoming return from call to 0x1AF0 at 0x05E1 // Inputs[4] // { // @036E memory[0x40:0x60] // @0385 stack[-1] // @0389 memory[0x40:0x60] // @0392 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 036A 5B JUMPDEST 036B 60 PUSH1 0x40 036D 80 DUP1 036E 51 MLOAD 036F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0384 90 SWAP1 0385 92 SWAP3 0386 16 AND 0387 82 DUP3 0388 52 MSTORE 0389 51 MLOAD 038A 90 SWAP1 038B 81 DUP2 038C 90 SWAP1 038D 03 SUB 038E 60 PUSH1 0x20 0390 01 ADD 0391 90 SWAP1 0392 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0388 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // @0392 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0393: // Incoming jump from 0x0192, if 0x18160ddd == stack[-1] 0393 5B JUMPDEST 0394 61 PUSH2 0x039b 0397 61 PUSH2 0x0e18 039A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0394 stack[0] = 0x039b } // Block ends with call to 0x0e18, returns to 0x039B label_039B: // Incoming return from call to 0x0656 at 0x0651 // Incoming return from call to 0x0F26 at 0x041D // Incoming return from call to 0x18D8 at 0x059E // Incoming return from call to 0x0EFD at 0x03F7 // Incoming return from call to 0x04B2 at 0x04AD // Incoming return from call to 0x100B at 0x0468 // Incoming return from call to 0x1005 at 0x0460 // Incoming return from call to 0x047F at 0x047A // Incoming return from call to 0x0E18 at 0x039A // Incoming return from call to 0x04ED at 0x04E8 // Incoming return from call to 0x13DD at 0x04D6 // Inputs[4] // { // @039F memory[0x40:0x60] // @03A0 stack[-1] // @03A3 memory[0x40:0x60] // @03AC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 039B 5B JUMPDEST 039C 60 PUSH1 0x40 039E 80 DUP1 039F 51 MLOAD 03A0 91 SWAP2 03A1 82 DUP3 03A2 52 MSTORE 03A3 51 MLOAD 03A4 90 SWAP1 03A5 81 DUP2 03A6 90 SWAP1 03A7 03 SUB 03A8 60 PUSH1 0x20 03AA 01 ADD 03AB 90 SWAP1 03AC F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @03A2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @03AC return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_03AD: // Incoming jump from 0x014B, if 0x23b872dd == stack[-1] // Inputs[1] { @03B4 msg.data.length } 03AD 5B JUMPDEST 03AE 61 PUSH2 0x034e 03B1 60 PUSH1 0x04 03B3 80 DUP1 03B4 36 CALLDATASIZE 03B5 03 SUB 03B6 60 PUSH1 0x60 03B8 81 DUP2 03B9 10 LT 03BA 15 ISZERO 03BB 61 PUSH2 0x03c3 03BE 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @03AE stack[0] = 0x034e // @03B1 stack[1] = 0x04 // @03B5 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03c3, returns to 0x034E, if !(msg.data.length - 0x04 < 0x60) label_03BF: // Incoming jump from 0x03BE, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @03C2 memory[0x00:0x00] } 03BF 60 PUSH1 0x00 03C1 80 DUP1 03C2 FD *REVERT // Stack delta = +0 // Outputs[1] { @03C2 revert(memory[0x00:0x00]); } // Block terminates label_03C3: // Incoming call from 0x03BE, returns to 0x034E, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @03DA stack[-2] // @03DB msg.data[stack[-2]:stack[-2] + 0x20] // @03E3 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @03EB msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 03C3 5B JUMPDEST 03C4 50 POP 03C5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03DA 81 DUP2 03DB 35 CALLDATALOAD 03DC 81 DUP2 03DD 16 AND 03DE 91 SWAP2 03DF 60 PUSH1 0x20 03E1 81 DUP2 03E2 01 ADD 03E3 35 CALLDATALOAD 03E4 90 SWAP1 03E5 91 SWAP2 03E6 16 AND 03E7 90 SWAP1 03E8 60 PUSH1 0x40 03EA 01 ADD 03EB 35 CALLDATALOAD 03EC 61 PUSH2 0x0e1e 03EF 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @03DE stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @03E7 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @03EB stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0e1e label_03F0: // Incoming jump from 0x0156, if 0x30adf81f == stack[-1] 03F0 5B JUMPDEST 03F1 61 PUSH2 0x039b 03F4 61 PUSH2 0x0efd 03F7 56 *JUMP // Stack delta = +1 // Outputs[1] { @03F1 stack[0] = 0x039b } // Block ends with call to 0x0efd, returns to 0x039B label_03F8: // Incoming jump from 0x0161, if 0x313ce567 == stack[-1] 03F8 5B JUMPDEST 03F9 61 PUSH2 0x0400 03FC 61 PUSH2 0x0f21 03FF 56 *JUMP // Stack delta = +1 // Outputs[1] { @03F9 stack[0] = 0x0400 } // Block ends with call to 0x0f21, returns to 0x0400 label_0400: // Incoming return from call to 0x0F21 at 0x03FF // Inputs[4] // { // @0404 memory[0x40:0x60] // @0408 stack[-1] // @040C memory[0x40:0x60] // @0415 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0400 5B JUMPDEST 0401 60 PUSH1 0x40 0403 80 DUP1 0404 51 MLOAD 0405 60 PUSH1 0xff 0407 90 SWAP1 0408 92 SWAP3 0409 16 AND 040A 82 DUP3 040B 52 MSTORE 040C 51 MLOAD 040D 90 SWAP1 040E 81 DUP2 040F 90 SWAP1 0410 03 SUB 0411 60 PUSH1 0x20 0413 01 ADD 0414 90 SWAP1 0415 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @040B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xff // @0415 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0416: // Incoming jump from 0x011A, if 0x3644e515 == stack[-1] 0416 5B JUMPDEST 0417 61 PUSH2 0x039b 041A 61 PUSH2 0x0f26 041D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0417 stack[0] = 0x039b } // Block ends with call to 0x0f26, returns to 0x039B label_041E: // Incoming jump from 0x0125, if 0x485cc955 == stack[-1] // Inputs[1] { @0425 msg.data.length } 041E 5B JUMPDEST 041F 61 PUSH2 0x0257 0422 60 PUSH1 0x04 0424 80 DUP1 0425 36 CALLDATASIZE 0426 03 SUB 0427 60 PUSH1 0x40 0429 81 DUP2 042A 10 LT 042B 15 ISZERO 042C 61 PUSH2 0x0434 042F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @041F stack[0] = 0x0257 // @0422 stack[1] = 0x04 // @0426 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0434, returns to 0x0257, if !(msg.data.length - 0x04 < 0x40) label_0430: // Incoming jump from 0x042F, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0433 memory[0x00:0x00] } 0430 60 PUSH1 0x00 0432 80 DUP1 0433 FD *REVERT // Stack delta = +0 // Outputs[1] { @0433 revert(memory[0x00:0x00]); } // Block terminates label_0434: // Incoming call from 0x042F, returns to 0x0257, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @044B stack[-2] // @044C msg.data[stack[-2]:stack[-2] + 0x20] // @0453 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0434 5B JUMPDEST 0435 50 POP 0436 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 044B 81 DUP2 044C 35 CALLDATALOAD 044D 81 DUP2 044E 16 AND 044F 91 SWAP2 0450 60 PUSH1 0x20 0452 01 ADD 0453 35 CALLDATALOAD 0454 16 AND 0455 61 PUSH2 0x0f2c 0458 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @044F stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0454 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff // } // Block ends with unconditional jump to 0x0f2c label_0459: // Incoming jump from 0x0130, if 0x5909c0d5 == stack[-1] 0459 5B JUMPDEST 045A 61 PUSH2 0x039b 045D 61 PUSH2 0x1005 0460 56 *JUMP // Stack delta = +1 // Outputs[1] { @045A stack[0] = 0x039b } // Block ends with call to 0x1005, returns to 0x039B label_0461: // Incoming jump from 0x013B, if 0x5a3d5493 == stack[-1] 0461 5B JUMPDEST 0462 61 PUSH2 0x039b 0465 61 PUSH2 0x100b 0468 56 *JUMP // Stack delta = +1 // Outputs[1] { @0462 stack[0] = 0x039b } // Block ends with call to 0x100b, returns to 0x039B label_0469: // Incoming jump from 0x00DE, if 0x6a627842 == stack[-1] // Inputs[1] { @0470 msg.data.length } 0469 5B JUMPDEST 046A 61 PUSH2 0x039b 046D 60 PUSH1 0x04 046F 80 DUP1 0470 36 CALLDATASIZE 0471 03 SUB 0472 60 PUSH1 0x20 0474 81 DUP2 0475 10 LT 0476 15 ISZERO 0477 61 PUSH2 0x047f 047A 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @046A stack[0] = 0x039b // @046D stack[1] = 0x04 // @0471 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x047f, returns to 0x039B, if !(msg.data.length - 0x04 < 0x20) label_047B: // Incoming jump from 0x047A, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @047E memory[0x00:0x00] } 047B 60 PUSH1 0x00 047D 80 DUP1 047E FD *REVERT // Stack delta = +0 // Outputs[1] { @047E revert(memory[0x00:0x00]); } // Block terminates label_047F: // Incoming call from 0x047A, returns to 0x039B, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0481 stack[-2] // @0481 msg.data[stack[-2]:stack[-2] + 0x20] // } 047F 5B JUMPDEST 0480 50 POP 0481 35 CALLDATALOAD 0482 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0497 16 AND 0498 61 PUSH2 0x1011 049B 56 *JUMP // Stack delta = -1 // Outputs[1] { @0497 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1011 label_049C: // Incoming jump from 0x00E9, if 0x70a08231 == stack[-1] // Inputs[1] { @04A3 msg.data.length } 049C 5B JUMPDEST 049D 61 PUSH2 0x039b 04A0 60 PUSH1 0x04 04A2 80 DUP1 04A3 36 CALLDATASIZE 04A4 03 SUB 04A5 60 PUSH1 0x20 04A7 81 DUP2 04A8 10 LT 04A9 15 ISZERO 04AA 61 PUSH2 0x04b2 04AD 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @049D stack[0] = 0x039b // @04A0 stack[1] = 0x04 // @04A4 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04b2, returns to 0x039B, if !(msg.data.length - 0x04 < 0x20) label_04AE: // Incoming jump from 0x04AD, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @04B1 memory[0x00:0x00] } 04AE 60 PUSH1 0x00 04B0 80 DUP1 04B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @04B1 revert(memory[0x00:0x00]); } // Block terminates label_04B2: // Incoming call from 0x04AD, returns to 0x039B, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @04B4 msg.data[stack[-2]:stack[-2] + 0x20] // @04B4 stack[-2] // } 04B2 5B JUMPDEST 04B3 50 POP 04B4 35 CALLDATALOAD 04B5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04CA 16 AND 04CB 61 PUSH2 0x13cb 04CE 56 *JUMP // Stack delta = -1 // Outputs[1] { @04CA stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x13cb label_04CF: // Incoming jump from 0x00F4, if 0x7464fc3d == stack[-1] 04CF 5B JUMPDEST 04D0 61 PUSH2 0x039b 04D3 61 PUSH2 0x13dd 04D6 56 *JUMP // Stack delta = +1 // Outputs[1] { @04D0 stack[0] = 0x039b } // Block ends with call to 0x13dd, returns to 0x039B label_04D7: // Incoming jump from 0x00AD, if 0x7ecebe00 == stack[-1] // Inputs[1] { @04DE msg.data.length } 04D7 5B JUMPDEST 04D8 61 PUSH2 0x039b 04DB 60 PUSH1 0x04 04DD 80 DUP1 04DE 36 CALLDATASIZE 04DF 03 SUB 04E0 60 PUSH1 0x20 04E2 81 DUP2 04E3 10 LT 04E4 15 ISZERO 04E5 61 PUSH2 0x04ed 04E8 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @04D8 stack[0] = 0x039b // @04DB stack[1] = 0x04 // @04DF stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04ed, returns to 0x039B, if !(msg.data.length - 0x04 < 0x20) label_04E9: // Incoming jump from 0x04E8, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @04EC memory[0x00:0x00] } 04E9 60 PUSH1 0x00 04EB 80 DUP1 04EC FD *REVERT // Stack delta = +0 // Outputs[1] { @04EC revert(memory[0x00:0x00]); } // Block terminates label_04ED: // Incoming call from 0x04E8, returns to 0x039B, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @04EF msg.data[stack[-2]:stack[-2] + 0x20] // @04EF stack[-2] // } 04ED 5B JUMPDEST 04EE 50 POP 04EF 35 CALLDATALOAD 04F0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0505 16 AND 0506 61 PUSH2 0x13e3 0509 56 *JUMP // Stack delta = -1 // Outputs[1] { @0505 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x13e3 label_050A: // Incoming jump from 0x00B8, if 0x89afcb44 == stack[-1] // Inputs[1] { @0511 msg.data.length } 050A 5B JUMPDEST 050B 61 PUSH2 0x053d 050E 60 PUSH1 0x04 0510 80 DUP1 0511 36 CALLDATASIZE 0512 03 SUB 0513 60 PUSH1 0x20 0515 81 DUP2 0516 10 LT 0517 15 ISZERO 0518 61 PUSH2 0x0520 051B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @050B stack[0] = 0x053d // @050E stack[1] = 0x04 // @0512 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0520, returns to 0x053D, if !(msg.data.length - 0x04 < 0x20) label_051C: // Incoming jump from 0x051B, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @051F memory[0x00:0x00] } 051C 60 PUSH1 0x00 051E 80 DUP1 051F FD *REVERT // Stack delta = +0 // Outputs[1] { @051F revert(memory[0x00:0x00]); } // Block terminates label_0520: // Incoming call from 0x051B, returns to 0x053D, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0522 stack[-2] // @0522 msg.data[stack[-2]:stack[-2] + 0x20] // } 0520 5B JUMPDEST 0521 50 POP 0522 35 CALLDATALOAD 0523 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0538 16 AND 0539 61 PUSH2 0x13f5 053C 56 *JUMP // Stack delta = -1 // Outputs[1] { @0538 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x13f5 label_053D: // Incoming return from call to 0x0520 at 0x051B // Inputs[5] // { // @0541 memory[0x40:0x60] // @0542 stack[-2] // @0549 stack[-1] // @054E memory[0x40:0x60] // @0555 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x40] // } 053D 5B JUMPDEST 053E 60 PUSH1 0x40 0540 80 DUP1 0541 51 MLOAD 0542 92 SWAP3 0543 83 DUP4 0544 52 MSTORE 0545 60 PUSH1 0x20 0547 83 DUP4 0548 01 ADD 0549 91 SWAP2 054A 90 SWAP1 054B 91 SWAP2 054C 52 MSTORE 054D 80 DUP1 054E 51 MLOAD 054F 91 SWAP2 0550 82 DUP3 0551 90 SWAP1 0552 03 SUB 0553 01 ADD 0554 90 SWAP1 0555 F3 *RETURN // Stack delta = -2 // Outputs[3] // { // @0544 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @054C memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @0555 return memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x40]; // } // Block terminates label_0556: // Incoming jump from 0x00C3, if 0x95d89b41 == stack[-1] 0556 5B JUMPDEST 0557 61 PUSH2 0x0261 055A 61 PUSH2 0x1892 055D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0557 stack[0] = 0x0261 } // Block ends with call to 0x1892, returns to 0x0261 label_055E: // Incoming jump from 0x00CE, if 0xa9059cbb == stack[-1] // Inputs[1] { @0565 msg.data.length } 055E 5B JUMPDEST 055F 61 PUSH2 0x034e 0562 60 PUSH1 0x04 0564 80 DUP1 0565 36 CALLDATASIZE 0566 03 SUB 0567 60 PUSH1 0x40 0569 81 DUP2 056A 10 LT 056B 15 ISZERO 056C 61 PUSH2 0x0574 056F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @055F stack[0] = 0x034e // @0562 stack[1] = 0x04 // @0566 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0574, if !(msg.data.length - 0x04 < 0x40) label_0570: // Incoming jump from 0x056F, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0573 memory[0x00:0x00] } 0570 60 PUSH1 0x00 0572 80 DUP1 0573 FD *REVERT // Stack delta = +0 // Outputs[1] { @0573 revert(memory[0x00:0x00]); } // Block terminates label_0574: // Incoming jump from 0x056F, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @058B stack[-2] // @058C msg.data[stack[-2]:stack[-2] + 0x20] // @0592 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0574 5B JUMPDEST 0575 50 POP 0576 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 058B 81 DUP2 058C 35 CALLDATALOAD 058D 16 AND 058E 90 SWAP1 058F 60 PUSH1 0x20 0591 01 ADD 0592 35 CALLDATALOAD 0593 61 PUSH2 0x18cb 0596 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @058E stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff // @0592 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x18cb label_0597: // Incoming jump from 0x007C, if 0xba9a7a56 == stack[-1] 0597 5B JUMPDEST 0598 61 PUSH2 0x039b 059B 61 PUSH2 0x18d8 059E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0598 stack[0] = 0x039b } // Block ends with call to 0x18d8, returns to 0x039B label_059F: // Incoming jump from 0x0087, if 0xbc25cf77 == stack[-1] // Inputs[1] { @05A6 msg.data.length } 059F 5B JUMPDEST 05A0 61 PUSH2 0x0257 05A3 60 PUSH1 0x04 05A5 80 DUP1 05A6 36 CALLDATASIZE 05A7 03 SUB 05A8 60 PUSH1 0x20 05AA 81 DUP2 05AB 10 LT 05AC 15 ISZERO 05AD 61 PUSH2 0x05b5 05B0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @05A0 stack[0] = 0x0257 // @05A3 stack[1] = 0x04 // @05A7 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x05b5, returns to 0x0257, if !(msg.data.length - 0x04 < 0x20) label_05B1: // Incoming jump from 0x05B0, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @05B4 memory[0x00:0x00] } 05B1 60 PUSH1 0x00 05B3 80 DUP1 05B4 FD *REVERT // Stack delta = +0 // Outputs[1] { @05B4 revert(memory[0x00:0x00]); } // Block terminates label_05B5: // Incoming call from 0x05B0, returns to 0x0257, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @05B7 msg.data[stack[-2]:stack[-2] + 0x20] // @05B7 stack[-2] // } 05B5 5B JUMPDEST 05B6 50 POP 05B7 35 CALLDATALOAD 05B8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05CD 16 AND 05CE 61 PUSH2 0x18de 05D1 56 *JUMP // Stack delta = -1 // Outputs[1] { @05CD stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x18de label_05D2: // Incoming jump from 0x0092, if 0xc45a0155 == stack[-1] 05D2 5B JUMPDEST 05D3 61 PUSH2 0x036a 05D6 61 PUSH2 0x1ad4 05D9 56 *JUMP // Stack delta = +1 // Outputs[1] { @05D3 stack[0] = 0x036a } // Block ends with call to 0x1ad4, returns to 0x036A label_05DA: // Incoming jump from 0x004B, if 0xd21220a7 == stack[-1] 05DA 5B JUMPDEST 05DB 61 PUSH2 0x036a 05DE 61 PUSH2 0x1af0 05E1 56 *JUMP // Stack delta = +1 // Outputs[1] { @05DB stack[0] = 0x036a } // Block ends with call to 0x1af0, returns to 0x036A label_05E2: // Incoming jump from 0x0056, if 0xd505accf == stack[-1] // Inputs[1] { @05E9 msg.data.length } 05E2 5B JUMPDEST 05E3 61 PUSH2 0x0257 05E6 60 PUSH1 0x04 05E8 80 DUP1 05E9 36 CALLDATASIZE 05EA 03 SUB 05EB 60 PUSH1 0xe0 05ED 81 DUP2 05EE 10 LT 05EF 15 ISZERO 05F0 61 PUSH2 0x05f8 05F3 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @05E3 stack[0] = 0x0257 // @05E6 stack[1] = 0x04 // @05EA stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x05f8, returns to 0x0257, if !(msg.data.length - 0x04 < 0xe0) label_05F4: // Incoming jump from 0x05F3, if not !(msg.data.length - 0x04 < 0xe0) // Inputs[1] { @05F7 memory[0x00:0x00] } 05F4 60 PUSH1 0x00 05F6 80 DUP1 05F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @05F7 revert(memory[0x00:0x00]); } // Block terminates label_05F8: // Incoming call from 0x05F3, returns to 0x0257, if !(msg.data.length - 0x04 < 0xe0) // Inputs[8] // { // @060F stack[-2] // @0610 msg.data[stack[-2]:stack[-2] + 0x20] // @0618 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0621 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0627 msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @062F msg.data[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] // @0636 msg.data[stack[-2] + 0xa0:stack[-2] + 0xa0 + 0x20] // @063B msg.data[0xc0 + stack[-2]:0xc0 + stack[-2] + 0x20] // } 05F8 5B JUMPDEST 05F9 50 POP 05FA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 060F 81 DUP2 0610 35 CALLDATALOAD 0611 81 DUP2 0612 16 AND 0613 91 SWAP2 0614 60 PUSH1 0x20 0616 81 DUP2 0617 01 ADD 0618 35 CALLDATALOAD 0619 90 SWAP1 061A 91 SWAP2 061B 16 AND 061C 90 SWAP1 061D 60 PUSH1 0x40 061F 81 DUP2 0620 01 ADD 0621 35 CALLDATALOAD 0622 90 SWAP1 0623 60 PUSH1 0x60 0625 81 DUP2 0626 01 ADD 0627 35 CALLDATALOAD 0628 90 SWAP1 0629 60 PUSH1 0xff 062B 60 PUSH1 0x80 062D 82 DUP3 062E 01 ADD 062F 35 CALLDATALOAD 0630 16 AND 0631 90 SWAP1 0632 60 PUSH1 0xa0 0634 81 DUP2 0635 01 ADD 0636 35 CALLDATALOAD 0637 90 SWAP1 0638 60 PUSH1 0xc0 063A 01 ADD 063B 35 CALLDATALOAD 063C 61 PUSH2 0x1b0c 063F 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0613 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @061C stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0622 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0628 stack[1] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @0631 stack[2] = msg.data[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] & 0xff // @0637 stack[3] = msg.data[stack[-2] + 0xa0:stack[-2] + 0xa0 + 0x20] // @063B stack[4] = msg.data[0xc0 + stack[-2]:0xc0 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1b0c label_0640: // Incoming jump from 0x0061, if 0xdd62ed3e == stack[-1] // Inputs[1] { @0647 msg.data.length } 0640 5B JUMPDEST 0641 61 PUSH2 0x039b 0644 60 PUSH1 0x04 0646 80 DUP1 0647 36 CALLDATASIZE 0648 03 SUB 0649 60 PUSH1 0x40 064B 81 DUP2 064C 10 LT 064D 15 ISZERO 064E 61 PUSH2 0x0656 0651 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0641 stack[0] = 0x039b // @0644 stack[1] = 0x04 // @0648 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0656, returns to 0x039B, if !(msg.data.length - 0x04 < 0x40) label_0652: // Incoming jump from 0x0651, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0655 memory[0x00:0x00] } 0652 60 PUSH1 0x00 0654 80 DUP1 0655 FD *REVERT // Stack delta = +0 // Outputs[1] { @0655 revert(memory[0x00:0x00]); } // Block terminates label_0656: // Incoming call from 0x0651, returns to 0x039B, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @066D stack[-2] // @066E msg.data[stack[-2]:stack[-2] + 0x20] // @0675 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0656 5B JUMPDEST 0657 50 POP 0658 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 066D 81 DUP2 066E 35 CALLDATALOAD 066F 81 DUP2 0670 16 AND 0671 91 SWAP2 0672 60 PUSH1 0x20 0674 01 ADD 0675 35 CALLDATALOAD 0676 16 AND 0677 61 PUSH2 0x1dd8 067A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0671 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0676 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff // } // Block ends with unconditional jump to 0x1dd8 label_067B: // Incoming jump from 0x006C, if 0xfff6cae9 == stack[-1] 067B 5B JUMPDEST 067C 61 PUSH2 0x0257 067F 61 PUSH2 0x1df5 0682 56 *JUMP // Stack delta = +1 // Outputs[1] { @067C stack[0] = 0x0257 } // Block ends with call to 0x1df5, returns to 0x0257 label_0683: // Incoming jump from 0x0256 // Inputs[1] { @0686 storage[0x0c] } 0683 5B JUMPDEST 0684 60 PUSH1 0x0c 0686 54 SLOAD 0687 60 PUSH1 0x01 0689 14 EQ 068A 61 PUSH2 0x06f4 068D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06f4, if 0x01 == storage[0x0c] label_068E: // Incoming jump from 0x068D, if not 0x01 == storage[0x0c] // Inputs[3] // { // @0691 memory[0x40:0x60] // @06EA memory[0x40:0x60] // @06F3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 068E 60 PUSH1 0x40 0690 80 DUP1 0691 51 MLOAD 0692 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 06B3 81 DUP2 06B4 52 MSTORE 06B5 60 PUSH1 0x20 06B7 60 PUSH1 0x04 06B9 82 DUP3 06BA 01 ADD 06BB 52 MSTORE 06BC 60 PUSH1 0x11 06BE 60 PUSH1 0x24 06C0 82 DUP3 06C1 01 ADD 06C2 52 MSTORE 06C3 7F PUSH32 0x556e697377617056323a204c4f434b4544000000000000000000000000000000 06E4 60 PUSH1 0x44 06E6 82 DUP3 06E7 01 ADD 06E8 52 MSTORE 06E9 90 SWAP1 06EA 51 MLOAD 06EB 90 SWAP1 06EC 81 DUP2 06ED 90 SWAP1 06EE 03 SUB 06EF 60 PUSH1 0x64 06F1 01 ADD 06F2 90 SWAP1 06F3 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @06B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @06BB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @06C2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x11 // @06E8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x556e697377617056323a204c4f434b4544000000000000000000000000000000 // @06F3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_06F4: // Incoming jump from 0x068D, if 0x01 == storage[0x0c] // Inputs[1] { @06FA stack[-5] } 06F4 5B JUMPDEST 06F5 60 PUSH1 0x00 06F7 60 PUSH1 0x0c 06F9 55 SSTORE 06FA 84 DUP5 06FB 15 ISZERO 06FC 15 ISZERO 06FD 80 DUP1 06FE 61 PUSH2 0x0707 0701 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @06F9 storage[0x0c] = 0x00 // @06FC stack[0] = !!stack[-5] // } // Block ends with conditional jump to 0x0707, if !!stack[-5] label_0702: // Incoming jump from 0x0701, if not !!stack[-5] // Inputs[1] { @0705 stack[-5] } 0702 50 POP 0703 60 PUSH1 0x00 0705 84 DUP5 0706 11 GT 0707 5B JUMPDEST 0708 61 PUSH2 0x075c 070B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x075c, if stack[-5] > 0x00 label_070C: // Incoming jump from 0x070B, if not stack[-1] // Incoming jump from 0x070B, if not stack[-5] > 0x00 // Inputs[3] // { // @070E memory[0x40:0x60] // @0756 memory[0x40:0x60] // @075B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 070C 60 PUSH1 0x40 070E 51 MLOAD 070F 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0730 81 DUP2 0731 52 MSTORE 0732 60 PUSH1 0x04 0734 01 ADD 0735 80 DUP1 0736 80 DUP1 0737 60 PUSH1 0x20 0739 01 ADD 073A 82 DUP3 073B 81 DUP2 073C 03 SUB 073D 82 DUP3 073E 52 MSTORE 073F 60 PUSH1 0x25 0741 81 DUP2 0742 52 MSTORE 0743 60 PUSH1 0x20 0745 01 ADD 0746 80 DUP1 0747 61 PUSH2 0x2b2f 074A 60 PUSH1 0x25 074C 91 SWAP2 074D 39 CODECOPY 074E 60 PUSH1 0x40 0750 01 ADD 0751 91 SWAP2 0752 50 POP 0753 50 POP 0754 60 PUSH1 0x40 0756 51 MLOAD 0757 80 DUP1 0758 91 SWAP2 0759 03 SUB 075A 90 SWAP1 075B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0731 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @073E memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0742 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x25 // @074D memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x25] = code[0x2b2f:0x2b54] // @075B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_075C: // Incoming jump from 0x070B, if stack[-1] // Incoming jump from 0x070B, if stack[-5] > 0x00 075C 5B JUMPDEST 075D 60 PUSH1 0x00 075F 80 DUP1 0760 61 PUSH2 0x0767 0763 61 PUSH2 0x0d90 0766 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @075D stack[0] = 0x00 // @075F stack[1] = 0x00 // @0760 stack[2] = 0x0767 // } // Block ends with call to 0x0d90, returns to 0x0767 label_0767: // Incoming return from call to 0x0D90 at 0x0766 // Inputs[5] // { // @0769 stack[-4] // @0769 stack[-2] // @076B stack[-5] // @076B stack[-3] // @077E stack[-10] // } 0767 5B JUMPDEST 0768 50 POP 0769 91 SWAP2 076A 50 POP 076B 91 SWAP2 076C 50 POP 076D 81 DUP2 076E 6D PUSH14 0xffffffffffffffffffffffffffff 077D 16 AND 077E 87 DUP8 077F 10 LT 0780 80 DUP1 0781 15 ISZERO 0782 61 PUSH2 0x079a 0785 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @0769 stack[-4] = stack[-2] // @076B stack[-5] = stack[-3] // @077F stack[-3] = stack[-10] < 0xffffffffffffffffffffffffffff & stack[-3] // } // Block ends with conditional jump to 0x079a, if !(stack[-10] < 0xffffffffffffffffffffffffffff & stack[-3]) label_0786: // Incoming jump from 0x0785, if not !(stack[-10] < 0xffffffffffffffffffffffffffff & stack[-3]) // Inputs[2] // { // @0787 stack[-2] // @0798 stack[-7] // } 0786 50 POP 0787 80 DUP1 0788 6D PUSH14 0xffffffffffffffffffffffffffff 0797 16 AND 0798 86 DUP7 0799 10 LT 079A 5B JUMPDEST 079B 61 PUSH2 0x07ef 079E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x07ef, if stack[-7] < 0xffffffffffffffffffffffffffff & stack[-2] label_079F: // Incoming jump from 0x079E, if not stack[-1] // Incoming jump from 0x079E, if not stack[-7] < 0xffffffffffffffffffffffffffff & stack[-2] // Inputs[3] // { // @07A1 memory[0x40:0x60] // @07E9 memory[0x40:0x60] // @07EE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 079F 60 PUSH1 0x40 07A1 51 MLOAD 07A2 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 07C3 81 DUP2 07C4 52 MSTORE 07C5 60 PUSH1 0x04 07C7 01 ADD 07C8 80 DUP1 07C9 80 DUP1 07CA 60 PUSH1 0x20 07CC 01 ADD 07CD 82 DUP3 07CE 81 DUP2 07CF 03 SUB 07D0 82 DUP3 07D1 52 MSTORE 07D2 60 PUSH1 0x21 07D4 81 DUP2 07D5 52 MSTORE 07D6 60 PUSH1 0x20 07D8 01 ADD 07D9 80 DUP1 07DA 61 PUSH2 0x2b78 07DD 60 PUSH1 0x21 07DF 91 SWAP2 07E0 39 CODECOPY 07E1 60 PUSH1 0x40 07E3 01 ADD 07E4 91 SWAP2 07E5 50 POP 07E6 50 POP 07E7 60 PUSH1 0x40 07E9 51 MLOAD 07EA 80 DUP1 07EB 91 SWAP2 07EC 03 SUB 07ED 90 SWAP1 07EE FD *REVERT // Stack delta = +0 // Outputs[5] // { // @07C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @07D1 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @07D5 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x21 // @07E0 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x21] = code[0x2b78:0x2b99] // @07EE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_07EF: // Incoming jump from 0x079E, if stack[-1] // Incoming jump from 0x079E, if stack[-7] < 0xffffffffffffffffffffffffffff & stack[-2] // Inputs[3] // { // @07F2 storage[0x06] // @07F5 storage[0x07] // @0818 stack[-5] // } 07EF 5B JUMPDEST 07F0 60 PUSH1 0x06 07F2 54 SLOAD 07F3 60 PUSH1 0x07 07F5 54 SLOAD 07F6 60 PUSH1 0x00 07F8 91 SWAP2 07F9 82 DUP3 07FA 91 SWAP2 07FB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0810 91 SWAP2 0811 82 DUP3 0812 16 AND 0813 91 SWAP2 0814 90 SWAP1 0815 81 DUP2 0816 16 AND 0817 90 SWAP1 0818 89 DUP10 0819 16 AND 081A 82 DUP3 081B 14 EQ 081C 80 DUP1 081D 15 ISZERO 081E 90 SWAP1 081F 61 PUSH2 0x0854 0822 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @07F8 stack[0] = 0x00 // @07FA stack[1] = 0x00 // @0813 stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] // @0817 stack[3] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x07] // @081E stack[4] = !(0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] == stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff) // } // Block ends with conditional jump to 0x0854, if 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] == stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff label_0823: // Incoming jump from 0x0822, if not 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] == stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[2] // { // @0824 stack[-2] // @083B stack[-10] // } 0823 50 POP 0824 80 DUP1 0825 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 083A 16 AND 083B 89 DUP10 083C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0851 16 AND 0852 14 EQ 0853 15 ISZERO 0854 5B JUMPDEST 0855 61 PUSH2 0x08bf 0858 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x08bf, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-10] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) label_0859: // Incoming jump from 0x0858, if not stack[-1] // Incoming jump from 0x0858, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-10] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) // Inputs[3] // { // @085C memory[0x40:0x60] // @08B5 memory[0x40:0x60] // @08BE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0859 60 PUSH1 0x40 085B 80 DUP1 085C 51 MLOAD 085D 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 087E 81 DUP2 087F 52 MSTORE 0880 60 PUSH1 0x20 0882 60 PUSH1 0x04 0884 82 DUP3 0885 01 ADD 0886 52 MSTORE 0887 60 PUSH1 0x15 0889 60 PUSH1 0x24 088B 82 DUP3 088C 01 ADD 088D 52 MSTORE 088E 7F PUSH32 0x556e697377617056323a20494e56414c49445f544f0000000000000000000000 08AF 60 PUSH1 0x44 08B1 82 DUP3 08B2 01 ADD 08B3 52 MSTORE 08B4 90 SWAP1 08B5 51 MLOAD 08B6 90 SWAP1 08B7 81 DUP2 08B8 90 SWAP1 08B9 03 SUB 08BA 60 PUSH1 0x64 08BC 01 ADD 08BD 90 SWAP1 08BE FD *REVERT // Stack delta = +0 // Outputs[5] // { // @087F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0886 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @088D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x15 // @08B3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x556e697377617056323a20494e56414c49445f544f0000000000000000000000 // @08BE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_08BF: // Incoming jump from 0x0858, if stack[-1] // Incoming jump from 0x0858, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-10] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) // Inputs[1] { @08C0 stack[-11] } 08BF 5B JUMPDEST 08C0 8A DUP11 08C1 15 ISZERO 08C2 61 PUSH2 0x08d0 08C5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08d0, if !stack[-11] label_08C6: // Incoming jump from 0x08C5, if not !stack[-11] // Inputs[3] // { // @08C9 stack[-2] // @08CA stack[-9] // @08CB stack[-11] // } 08C6 61 PUSH2 0x08d0 08C9 82 DUP3 08CA 8A DUP11 08CB 8D DUP14 08CC 61 PUSH2 0x1fdb 08CF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @08C6 stack[0] = 0x08d0 // @08C9 stack[1] = stack[-2] // @08CA stack[2] = stack[-9] // @08CB stack[3] = stack[-11] // } // Block ends with call to 0x1fdb, returns to 0x08D0 label_08D0: // Incoming jump from 0x08C5, if !stack[-11] // Incoming return from call to 0x1FDB at 0x08CF // Inputs[1] { @08D1 stack[-10] } 08D0 5B JUMPDEST 08D1 89 DUP10 08D2 15 ISZERO 08D3 61 PUSH2 0x08e1 08D6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08e1, if !stack[-10] label_08D7: // Incoming jump from 0x08D6, if not !stack[-10] // Inputs[3] // { // @08DA stack[-1] // @08DB stack[-9] // @08DC stack[-10] // } 08D7 61 PUSH2 0x08e1 08DA 81 DUP2 08DB 8A DUP11 08DC 8C DUP13 08DD 61 PUSH2 0x1fdb 08E0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @08D7 stack[0] = 0x08e1 // @08DA stack[1] = stack[-1] // @08DB stack[2] = stack[-9] // @08DC stack[3] = stack[-10] // } // Block ends with call to 0x1fdb, returns to 0x08E1 label_08E1: // Incoming jump from 0x08D6, if !stack[-10] // Incoming return from call to 0x1FDB at 0x08E0 // Inputs[1] { @08E2 stack[-7] } 08E1 5B JUMPDEST 08E2 86 DUP7 08E3 15 ISZERO 08E4 61 PUSH2 0x09c3 08E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09c3, if !stack[-7] label_08E8: // Incoming jump from 0x08E7, if not !stack[-7] // Inputs[10] // { // @08E8 stack[-9] // @0904 msg.sender // @0905 stack[-11] // @0906 stack[-10] // @0907 stack[-8] // @0908 stack[-7] // @090B memory[0x40:0x60] // @0971 msg.data[stack[-8]:stack[-8] + stack[-7]] // @0995 memory[0x40:0x60] // @099E address(0xffffffffffffffffffffffffffffffffffffffff & stack[-9]).code.length // } 08E8 88 DUP9 08E9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08FE 16 AND 08FF 63 PUSH4 0x10d1e85c 0904 33 CALLER 0905 8D DUP14 0906 8D DUP14 0907 8C DUP13 0908 8C DUP13 0909 60 PUSH1 0x40 090B 51 MLOAD 090C 86 DUP7 090D 63 PUSH4 0xffffffff 0912 16 AND 0913 60 PUSH1 0xe0 0915 1B SHL 0916 81 DUP2 0917 52 MSTORE 0918 60 PUSH1 0x04 091A 01 ADD 091B 80 DUP1 091C 86 DUP7 091D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0932 16 AND 0933 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0948 16 AND 0949 81 DUP2 094A 52 MSTORE 094B 60 PUSH1 0x20 094D 01 ADD 094E 85 DUP6 094F 81 DUP2 0950 52 MSTORE 0951 60 PUSH1 0x20 0953 01 ADD 0954 84 DUP5 0955 81 DUP2 0956 52 MSTORE 0957 60 PUSH1 0x20 0959 01 ADD 095A 80 DUP1 095B 60 PUSH1 0x20 095D 01 ADD 095E 82 DUP3 095F 81 DUP2 0960 03 SUB 0961 82 DUP3 0962 52 MSTORE 0963 84 DUP5 0964 84 DUP5 0965 82 DUP3 0966 81 DUP2 0967 81 DUP2 0968 52 MSTORE 0969 60 PUSH1 0x20 096B 01 ADD 096C 92 SWAP3 096D 50 POP 096E 80 DUP1 096F 82 DUP3 0970 84 DUP5 0971 37 CALLDATACOPY 0972 60 PUSH1 0x00 0974 81 DUP2 0975 84 DUP5 0976 01 ADD 0977 52 MSTORE 0978 60 PUSH1 0x1f 097A 19 NOT 097B 60 PUSH1 0x1f 097D 82 DUP3 097E 01 ADD 097F 16 AND 0980 90 SWAP1 0981 50 POP 0982 80 DUP1 0983 83 DUP4 0984 01 ADD 0985 92 SWAP3 0986 50 POP 0987 50 POP 0988 50 POP 0989 96 SWAP7 098A 50 POP 098B 50 POP 098C 50 POP 098D 50 POP 098E 50 POP 098F 50 POP 0990 50 POP 0991 60 PUSH1 0x00 0993 60 PUSH1 0x40 0995 51 MLOAD 0996 80 DUP1 0997 83 DUP4 0998 03 SUB 0999 81 DUP2 099A 60 PUSH1 0x00 099C 87 DUP8 099D 80 DUP1 099E 3B EXTCODESIZE 099F 15 ISZERO 09A0 80 DUP1 09A1 15 ISZERO 09A2 61 PUSH2 0x09aa 09A5 57 *JUMPI // Stack delta = +10 // Outputs[18] // { // @08FE stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-9] // @08FF stack[1] = 0x10d1e85c // @0917 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x10d1e85c) << 0xe0 // @094A memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @0950 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-11] // @0956 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-10] // @0962 memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0968 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-7] // @0971 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + stack[-7]] = msg.data[stack[-8]:stack[-8] + stack[-7]] // @0977 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + stack[-7]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + stack[-7] + 0x20] = 0x00 // @0989 stack[2] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + (stack[-7] + 0x1f & ~0x1f) // @0991 stack[3] = 0x00 // @0995 stack[4] = memory[0x40:0x60] // @0998 stack[5] = (0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + (stack[-7] + 0x1f & ~0x1f)) - memory[0x40:0x60] // @0999 stack[6] = memory[0x40:0x60] // @099A stack[7] = 0x00 // @099C stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-9] // @099F stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-9]).code.length // } // Block ends with conditional jump to 0x09aa, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-9]).code.length label_09A6: // Incoming jump from 0x09A5, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-9]).code.length // Inputs[1] { @09A9 memory[0x00:0x00] } 09A6 60 PUSH1 0x00 09A8 80 DUP1 09A9 FD *REVERT // Stack delta = +0 // Outputs[1] { @09A9 revert(memory[0x00:0x00]); } // Block terminates label_09AA: // Incoming jump from 0x09A5, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-9]).code.length // Inputs[9] // { // @09AC msg.gas // @09AD stack[-2] // @09AD stack[-3] // @09AD memory[stack[-4]:stack[-4] + stack[-5]] // @09AD stack[-5] // @09AD stack[-4] // @09AD stack[-6] // @09AD stack[-7] // @09AD address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 09AA 5B JUMPDEST 09AB 50 POP 09AC 5A GAS 09AD F1 CALL 09AE 15 ISZERO 09AF 80 DUP1 09B0 15 ISZERO 09B1 61 PUSH2 0x09be 09B4 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @09AD memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @09AE stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x09be, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_09B5: // Incoming jump from 0x09B4, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @09B5 returndata.length // @09B9 returndata[0x00:0x00 + returndata.length] // @09BA returndata.length // @09BD memory[0x00:0x00 + returndata.length] // } 09B5 3D RETURNDATASIZE 09B6 60 PUSH1 0x00 09B8 80 DUP1 09B9 3E RETURNDATACOPY 09BA 3D RETURNDATASIZE 09BB 60 PUSH1 0x00 09BD FD *REVERT // Stack delta = +0 // Outputs[2] // { // @09B9 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @09BD revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_09BE: // Incoming jump from 0x09B4, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) 09BE 5B JUMPDEST 09BF 50 POP 09C0 50 POP 09C1 50 POP 09C2 50 POP // Stack delta = -4 // Block continues label_09C3: // Incoming jump from 0x08E7, if !stack[-7] // Incoming jump from 0x09C2 // Inputs[5] // { // @09C7 memory[0x40:0x60] // @09EB address(this) // @09F2 memory[0x40:0x60] // @0A08 stack[-2] // @0A23 address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 09C3 5B JUMPDEST 09C4 60 PUSH1 0x40 09C6 80 DUP1 09C7 51 MLOAD 09C8 7F PUSH32 0x70a0823100000000000000000000000000000000000000000000000000000000 09E9 81 DUP2 09EA 52 MSTORE 09EB 30 ADDRESS 09EC 60 PUSH1 0x04 09EE 82 DUP3 09EF 01 ADD 09F0 52 MSTORE 09F1 90 SWAP1 09F2 51 MLOAD 09F3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A08 84 DUP5 0A09 16 AND 0A0A 91 SWAP2 0A0B 63 PUSH4 0x70a08231 0A10 91 SWAP2 0A11 60 PUSH1 0x24 0A13 80 DUP1 0A14 83 DUP4 0A15 01 ADD 0A16 92 SWAP3 0A17 60 PUSH1 0x20 0A19 92 SWAP3 0A1A 91 SWAP2 0A1B 90 SWAP1 0A1C 82 DUP3 0A1D 90 SWAP1 0A1E 03 SUB 0A1F 01 ADD 0A20 81 DUP2 0A21 86 DUP7 0A22 80 DUP1 0A23 3B EXTCODESIZE 0A24 15 ISZERO 0A25 80 DUP1 0A26 15 ISZERO 0A27 61 PUSH2 0x0a2f 0A2A 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @09EA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000 // @09F0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @0A0A stack[0] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @0A10 stack[1] = 0x70a08231 // @0A16 stack[2] = memory[0x40:0x60] + 0x24 // @0A19 stack[3] = 0x20 // @0A1A stack[4] = memory[0x40:0x60] // @0A1F stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @0A20 stack[6] = memory[0x40:0x60] // @0A21 stack[7] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @0A24 stack[8] = !address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x0a2f, if !!address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_0A2B: // Incoming jump from 0x0A2A, if not !!address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @0A2E memory[0x00:0x00] } 0A2B 60 PUSH1 0x00 0A2D 80 DUP1 0A2E FD *REVERT // Stack delta = +0 // Outputs[1] { @0A2E revert(memory[0x00:0x00]); } // Block terminates label_0A2F: // Incoming jump from 0x0A2A, if !!address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[8] // { // @0A31 msg.gas // @0A32 stack[-2] // @0A32 stack[-5] // @0A32 memory[stack[-3]:stack[-3] + stack[-4]] // @0A32 stack[-3] // @0A32 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0A32 stack[-4] // @0A32 stack[-6] // } 0A2F 5B JUMPDEST 0A30 50 POP 0A31 5A GAS 0A32 FA STATICCALL 0A33 15 ISZERO 0A34 80 DUP1 0A35 15 ISZERO 0A36 61 PUSH2 0x0a43 0A39 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0A32 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0A33 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0a43, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0A3A: // Incoming jump from 0x0A39, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0A3A returndata.length // @0A3E returndata[0x00:0x00 + returndata.length] // @0A3F returndata.length // @0A42 memory[0x00:0x00 + returndata.length] // } 0A3A 3D RETURNDATASIZE 0A3B 60 PUSH1 0x00 0A3D 80 DUP1 0A3E 3E RETURNDATACOPY 0A3F 3D RETURNDATASIZE 0A40 60 PUSH1 0x00 0A42 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A3E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0A42 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0A43: // Incoming jump from 0x0A39, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0A4A memory[0x40:0x60] // @0A4B returndata.length // } 0A43 5B JUMPDEST 0A44 50 POP 0A45 50 POP 0A46 50 POP 0A47 50 POP 0A48 60 PUSH1 0x40 0A4A 51 MLOAD 0A4B 3D RETURNDATASIZE 0A4C 60 PUSH1 0x20 0A4E 81 DUP2 0A4F 10 LT 0A50 15 ISZERO 0A51 61 PUSH2 0x0a59 0A54 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0A4A stack[-4] = memory[0x40:0x60] // @0A4B stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0a59, if !(returndata.length < 0x20) label_0A55: // Incoming jump from 0x0A54, if not !(returndata.length < 0x20) // Inputs[1] { @0A58 memory[0x00:0x00] } 0A55 60 PUSH1 0x00 0A57 80 DUP1 0A58 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A58 revert(memory[0x00:0x00]); } // Block terminates label_0A59: // Incoming jump from 0x0A54, if !(returndata.length < 0x20) // Inputs[8] // { // @0A5B stack[-2] // @0A5B memory[stack[-2]:stack[-2] + 0x20] // @0A5F memory[0x40:0x60] // @0A83 address(this) // @0A8A memory[0x40:0x60] // @0A8C stack[-6] // @0AA3 stack[-3] // @0ABF address(stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 0A59 5B JUMPDEST 0A5A 50 POP 0A5B 51 MLOAD 0A5C 60 PUSH1 0x40 0A5E 80 DUP1 0A5F 51 MLOAD 0A60 7F PUSH32 0x70a0823100000000000000000000000000000000000000000000000000000000 0A81 81 DUP2 0A82 52 MSTORE 0A83 30 ADDRESS 0A84 60 PUSH1 0x04 0A86 82 DUP3 0A87 01 ADD 0A88 52 MSTORE 0A89 90 SWAP1 0A8A 51 MLOAD 0A8B 91 SWAP2 0A8C 95 SWAP6 0A8D 50 POP 0A8E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AA3 83 DUP4 0AA4 16 AND 0AA5 91 SWAP2 0AA6 63 PUSH4 0x70a08231 0AAB 91 SWAP2 0AAC 60 PUSH1 0x24 0AAE 80 DUP1 0AAF 82 DUP3 0AB0 01 ADD 0AB1 92 SWAP3 0AB2 60 PUSH1 0x20 0AB4 92 SWAP3 0AB5 90 SWAP1 0AB6 91 SWAP2 0AB7 90 SWAP1 0AB8 82 DUP3 0AB9 90 SWAP1 0ABA 03 SUB 0ABB 01 ADD 0ABC 81 DUP2 0ABD 86 DUP7 0ABE 80 DUP1 0ABF 3B EXTCODESIZE 0AC0 15 ISZERO 0AC1 80 DUP1 0AC2 15 ISZERO 0AC3 61 PUSH2 0x0acb 0AC6 57 *JUMPI // Stack delta = +7 // Outputs[12] // { // @0A82 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000 // @0A88 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @0A8C stack[-6] = memory[stack[-2]:stack[-2] + 0x20] // @0AA5 stack[-2] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @0AAB stack[-1] = 0x70a08231 // @0AB1 stack[0] = memory[0x40:0x60] + 0x24 // @0AB4 stack[1] = 0x20 // @0AB6 stack[2] = memory[0x40:0x60] // @0ABB stack[3] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @0ABC stack[4] = memory[0x40:0x60] // @0ABD stack[5] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @0AC0 stack[6] = !address(stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x0acb, if !!address(stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_0AC7: // Incoming jump from 0x0AC6, if not !!address(stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @0ACA memory[0x00:0x00] } 0AC7 60 PUSH1 0x00 0AC9 80 DUP1 0ACA FD *REVERT // Stack delta = +0 // Outputs[1] { @0ACA revert(memory[0x00:0x00]); } // Block terminates label_0ACB: // Incoming jump from 0x0AC6, if !!address(stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[8] // { // @0ACD msg.gas // @0ACE memory[stack[-3]:stack[-3] + stack[-4]] // @0ACE address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0ACE stack[-6] // @0ACE stack[-5] // @0ACE stack[-2] // @0ACE stack[-3] // @0ACE stack[-4] // } 0ACB 5B JUMPDEST 0ACC 50 POP 0ACD 5A GAS 0ACE FA STATICCALL 0ACF 15 ISZERO 0AD0 80 DUP1 0AD1 15 ISZERO 0AD2 61 PUSH2 0x0adf 0AD5 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0ACE memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0ACF stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0adf, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0AD6: // Incoming jump from 0x0AD5, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0AD6 returndata.length // @0ADA returndata[0x00:0x00 + returndata.length] // @0ADB returndata.length // @0ADE memory[0x00:0x00 + returndata.length] // } 0AD6 3D RETURNDATASIZE 0AD7 60 PUSH1 0x00 0AD9 80 DUP1 0ADA 3E RETURNDATACOPY 0ADB 3D RETURNDATASIZE 0ADC 60 PUSH1 0x00 0ADE FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0ADA memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0ADE revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0ADF: // Incoming jump from 0x0AD5, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0AE6 memory[0x40:0x60] // @0AE7 returndata.length // } 0ADF 5B JUMPDEST 0AE0 50 POP 0AE1 50 POP 0AE2 50 POP 0AE3 50 POP 0AE4 60 PUSH1 0x40 0AE6 51 MLOAD 0AE7 3D RETURNDATASIZE 0AE8 60 PUSH1 0x20 0AEA 81 DUP2 0AEB 10 LT 0AEC 15 ISZERO 0AED 61 PUSH2 0x0af5 0AF0 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0AE6 stack[-4] = memory[0x40:0x60] // @0AE7 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0af5, if !(returndata.length < 0x20) label_0AF1: // Incoming jump from 0x0AF0, if not !(returndata.length < 0x20) // Inputs[1] { @0AF4 memory[0x00:0x00] } 0AF1 60 PUSH1 0x00 0AF3 80 DUP1 0AF4 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AF4 revert(memory[0x00:0x00]); } // Block terminates label_0AF5: // Incoming jump from 0x0AF0, if !(returndata.length < 0x20) // Inputs[7] // { // @0AF7 memory[stack[-2]:stack[-2] + 0x20] // @0AF7 stack[-2] // @0AF8 stack[-5] // @0AFC stack[-4] // @0B0E stack[-8] // @0B10 stack[-13] // @0B13 stack[-6] // } 0AF5 5B JUMPDEST 0AF6 50 POP 0AF7 51 MLOAD 0AF8 92 SWAP3 0AF9 50 POP 0AFA 60 PUSH1 0x00 0AFC 91 SWAP2 0AFD 50 POP 0AFE 50 POP 0AFF 6D PUSH14 0xffffffffffffffffffffffffffff 0B0E 85 DUP6 0B0F 16 AND 0B10 8A DUP11 0B11 90 SWAP1 0B12 03 SUB 0B13 83 DUP4 0B14 11 GT 0B15 61 PUSH2 0x0b1f 0B18 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @0AF8 stack[-5] = memory[stack[-2]:stack[-2] + 0x20] // @0AFC stack[-4] = 0x00 // } // Block ends with conditional jump to 0x0b1f, if stack[-6] > (stack[-8] & 0xffffffffffffffffffffffffffff) - stack[-13] label_0B19: // Incoming jump from 0x0B18, if not stack[-6] > (stack[-8] & 0xffffffffffffffffffffffffffff) - stack[-13] 0B19 60 PUSH1 0x00 0B1B 61 PUSH2 0x0b35 0B1E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B19 stack[0] = 0x00 } // Block ends with unconditional jump to 0x0b35 label_0B1F: // Incoming jump from 0x0B18, if stack[-6] > (stack[-8] & 0xffffffffffffffffffffffffffff) - stack[-13] // Inputs[7] // { // @0B20 stack[-10] // @0B21 stack[-5] // @0B33 stack[-3] // @0B36 stack[-1] // @0B3A stack[-9] // @0B3B stack[-4] // @0B4D stack[-2] // } 0B1F 5B JUMPDEST 0B20 89 DUP10 0B21 85 DUP6 0B22 6D PUSH14 0xffffffffffffffffffffffffffff 0B31 16 AND 0B32 03 SUB 0B33 83 DUP4 0B34 03 SUB 0B35 5B JUMPDEST 0B36 90 SWAP1 0B37 50 POP 0B38 60 PUSH1 0x00 0B3A 89 DUP10 0B3B 85 DUP6 0B3C 6D PUSH14 0xffffffffffffffffffffffffffff 0B4B 16 AND 0B4C 03 SUB 0B4D 83 DUP4 0B4E 11 GT 0B4F 61 PUSH2 0x0b59 0B52 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0B36 stack[-1] = stack[-3] - ((0xffffffffffffffffffffffffffff & stack[-5]) - stack[-10]) // @0B38 stack[0] = 0x00 // } // Block ends with conditional jump to 0x0b59, if stack[-2] > (0xffffffffffffffffffffffffffff & stack[-4]) - stack[-9] label_0B53: // Incoming jump from 0x0B52, if not stack[-2] > (0xffffffffffffffffffffffffffff & stack[-4]) - stack[-9] // Incoming jump from 0x0B52, if not stack[-3] > (0xffffffffffffffffffffffffffff & stack[-5]) - stack[-10] 0B53 60 PUSH1 0x00 0B55 61 PUSH2 0x0b6f 0B58 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B53 stack[0] = 0x00 } // Block ends with unconditional jump to 0x0b6f label_0B59: // Incoming jump from 0x0B52, if stack[-2] > (0xffffffffffffffffffffffffffff & stack[-4]) - stack[-9] // Incoming jump from 0x0B52, if stack[-3] > (0xffffffffffffffffffffffffffff & stack[-5]) - stack[-10] // Inputs[5] // { // @0B5A stack[-10] // @0B5B stack[-5] // @0B6D stack[-3] // @0B70 stack[-1] // @0B74 stack[-2] // } 0B59 5B JUMPDEST 0B5A 89 DUP10 0B5B 85 DUP6 0B5C 6D PUSH14 0xffffffffffffffffffffffffffff 0B6B 16 AND 0B6C 03 SUB 0B6D 83 DUP4 0B6E 03 SUB 0B6F 5B JUMPDEST 0B70 90 SWAP1 0B71 50 POP 0B72 60 PUSH1 0x00 0B74 82 DUP3 0B75 11 GT 0B76 80 DUP1 0B77 61 PUSH2 0x0b80 0B7A 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0B70 stack[-1] = stack[-3] - ((0xffffffffffffffffffffffffffff & stack[-5]) - stack[-10]) // @0B75 stack[0] = stack[-2] > 0x00 // } // Block ends with conditional jump to 0x0b80, if stack[-2] > 0x00 label_0B7B: // Incoming jump from 0x0B7A, if not stack[-2] > 0x00 // Incoming jump from 0x0B7A, if not stack[-3] > 0x00 // Inputs[1] { @0B7E stack[-2] } 0B7B 50 POP 0B7C 60 PUSH1 0x00 0B7E 81 DUP2 0B7F 11 GT 0B80 5B JUMPDEST 0B81 61 PUSH2 0x0bd5 0B84 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0bd5, if stack[-2] > 0x00 label_0B85: // Incoming jump from 0x0B84, if not stack[-2] > 0x00 // Incoming jump from 0x0B84, if not stack[-1] // Inputs[3] // { // @0B87 memory[0x40:0x60] // @0BCF memory[0x40:0x60] // @0BD4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B85 60 PUSH1 0x40 0B87 51 MLOAD 0B88 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0BA9 81 DUP2 0BAA 52 MSTORE 0BAB 60 PUSH1 0x04 0BAD 01 ADD 0BAE 80 DUP1 0BAF 80 DUP1 0BB0 60 PUSH1 0x20 0BB2 01 ADD 0BB3 82 DUP3 0BB4 81 DUP2 0BB5 03 SUB 0BB6 82 DUP3 0BB7 52 MSTORE 0BB8 60 PUSH1 0x24 0BBA 81 DUP2 0BBB 52 MSTORE 0BBC 60 PUSH1 0x20 0BBE 01 ADD 0BBF 80 DUP1 0BC0 61 PUSH2 0x2b54 0BC3 60 PUSH1 0x24 0BC5 91 SWAP2 0BC6 39 CODECOPY 0BC7 60 PUSH1 0x40 0BC9 01 ADD 0BCA 91 SWAP2 0BCB 50 POP 0BCC 50 POP 0BCD 60 PUSH1 0x40 0BCF 51 MLOAD 0BD0 80 DUP1 0BD1 91 SWAP2 0BD2 03 SUB 0BD3 90 SWAP1 0BD4 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0BAA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0BB7 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0BBB memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x24 // @0BC6 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x24] = code[0x2b54:0x2b78] // @0BD4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0BD5: // Incoming jump from 0x0B84, if stack[-2] > 0x00 // Incoming jump from 0x0B84, if stack[-1] // Inputs[1] { @0BDE stack[-2] } 0BD5 5B JUMPDEST 0BD6 60 PUSH1 0x00 0BD8 61 PUSH2 0x0c09 0BDB 61 PUSH2 0x0beb 0BDE 84 DUP5 0BDF 60 PUSH1 0x03 0BE1 63 PUSH4 0xffffffff 0BE6 61 PUSH2 0x21e8 0BE9 16 AND 0BEA 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0BD6 stack[0] = 0x00 // @0BD8 stack[1] = 0x0c09 // @0BDB stack[2] = 0x0beb // @0BDE stack[3] = stack[-2] // @0BDF stack[4] = 0x03 // } // Block ends with call to 0x21e8 & 0xffffffff, returns to 0x0BEB label_0BEB: // Incoming return from call to 0x21E8 at 0x0BEA // Incoming return from call to 0x21E8 at 0x0C20 // Inputs[1] { @0BEF stack[-7] } 0BEB 5B JUMPDEST 0BEC 61 PUSH2 0x0bfd 0BEF 87 DUP8 0BF0 61 PUSH2 0x03e8 0BF3 63 PUSH4 0xffffffff 0BF8 61 PUSH2 0x21e8 0BFB 16 AND 0BFC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BEC stack[0] = 0x0bfd // @0BEF stack[1] = stack[-7] // @0BF0 stack[2] = 0x03e8 // } // Block ends with call to 0x21e8 & 0xffffffff, returns to 0x0BFD label_0BFD: // Incoming return from call to 0x1257 at 0x1256 // Incoming return from call to 0x21E8 at 0x0BFC // Inputs[2] // { // @0BFE stack[-2] // @0BFE stack[-1] // } 0BFD 5B JUMPDEST 0BFE 90 SWAP1 0BFF 63 PUSH4 0xffffffff 0C04 61 PUSH2 0x226e 0C07 16 AND 0C08 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0BFE stack[-1] = stack[-2] // @0BFE stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x226e & 0xffffffff label_0C09: // Incoming return from call to 0x0BEB at 0x0BEA // Inputs[3] // { // @0C0A stack[-1] // @0C0A stack[-2] // @0C14 stack[-3] // } 0C09 5B JUMPDEST 0C0A 90 SWAP1 0C0B 50 POP 0C0C 60 PUSH1 0x00 0C0E 61 PUSH2 0x0c21 0C11 61 PUSH2 0x0beb 0C14 84 DUP5 0C15 60 PUSH1 0x03 0C17 63 PUSH4 0xffffffff 0C1C 61 PUSH2 0x21e8 0C1F 16 AND 0C20 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0C0A stack[-2] = stack[-1] // @0C0C stack[-1] = 0x00 // @0C0E stack[0] = 0x0c21 // @0C11 stack[1] = 0x0beb // @0C14 stack[2] = stack[-3] // @0C15 stack[3] = 0x03 // } // Block ends with call to 0x21e8 & 0xffffffff, returns to 0x0BEB label_0C21: // Incoming return from call to 0x0BEB at 0x0C20 // Inputs[4] // { // @0C22 stack[-1] // @0C22 stack[-2] // @0C3D stack[-9] // @0C41 stack[-8] // } 0C21 5B JUMPDEST 0C22 90 SWAP1 0C23 50 POP 0C24 61 PUSH2 0x0c59 0C27 62 PUSH3 0x0f4240 0C2B 61 PUSH2 0x0c4d 0C2E 6D PUSH14 0xffffffffffffffffffffffffffff 0C3D 8B DUP12 0C3E 81 DUP2 0C3F 16 AND 0C40 90 SWAP1 0C41 8B DUP12 0C42 16 AND 0C43 63 PUSH4 0xffffffff 0C48 61 PUSH2 0x21e8 0C4B 16 AND 0C4C 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0C22 stack[-2] = stack[-1] // @0C24 stack[-1] = 0x0c59 // @0C27 stack[0] = 0x0f4240 // @0C2B stack[1] = 0x0c4d // @0C40 stack[2] = 0xffffffffffffffffffffffffffff & stack[-9] // @0C42 stack[3] = stack[-8] & 0xffffffffffffffffffffffffffff // } // Block ends with call to 0x21e8 & 0xffffffff, returns to 0x0C4D label_0C4D: // Incoming return from call to 0x21E8 at 0x0C4C // Inputs[2] // { // @0C4E stack[-1] // @0C4E stack[-2] // } 0C4D 5B JUMPDEST 0C4E 90 SWAP1 0C4F 63 PUSH4 0xffffffff 0C54 61 PUSH2 0x21e8 0C57 16 AND 0C58 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0C4E stack[-1] = stack[-2] // @0C4E stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x21e8 & 0xffffffff label_0C59: // Incoming return from call to 0x0C4D at 0x0C4C // Inputs[2] // { // @0C5D stack[-3] // @0C5E stack[-2] // } 0C59 5B JUMPDEST 0C5A 61 PUSH2 0x0c69 0C5D 83 DUP4 0C5E 83 DUP4 0C5F 63 PUSH4 0xffffffff 0C64 61 PUSH2 0x21e8 0C67 16 AND 0C68 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C5A stack[0] = 0x0c69 // @0C5D stack[1] = stack[-3] // @0C5E stack[2] = stack[-2] // } // Block ends with call to 0x21e8 & 0xffffffff, returns to 0x0C69 label_0C69: // Incoming return from call to 0x21E8 at 0x0C68 // Inputs[2] // { // @0C6A stack[-1] // @0C6A stack[-2] // } 0C69 5B JUMPDEST 0C6A 10 LT 0C6B 15 ISZERO 0C6C 61 PUSH2 0x0cd6 0C6F 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0cd6, if !(stack[-1] < stack[-2]) label_0C70: // Incoming jump from 0x0C6F, if not !(stack[-1] < stack[-2]) // Inputs[3] // { // @0C73 memory[0x40:0x60] // @0CCC memory[0x40:0x60] // @0CD5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0C70 60 PUSH1 0x40 0C72 80 DUP1 0C73 51 MLOAD 0C74 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0C95 81 DUP2 0C96 52 MSTORE 0C97 60 PUSH1 0x20 0C99 60 PUSH1 0x04 0C9B 82 DUP3 0C9C 01 ADD 0C9D 52 MSTORE 0C9E 60 PUSH1 0x0c 0CA0 60 PUSH1 0x24 0CA2 82 DUP3 0CA3 01 ADD 0CA4 52 MSTORE 0CA5 7F PUSH32 0x556e697377617056323a204b0000000000000000000000000000000000000000 0CC6 60 PUSH1 0x44 0CC8 82 DUP3 0CC9 01 ADD 0CCA 52 MSTORE 0CCB 90 SWAP1 0CCC 51 MLOAD 0CCD 90 SWAP1 0CCE 81 DUP2 0CCF 90 SWAP1 0CD0 03 SUB 0CD1 60 PUSH1 0x64 0CD3 01 ADD 0CD4 90 SWAP1 0CD5 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0C96 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0C9D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0CA4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0c // @0CCA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x556e697377617056323a204b0000000000000000000000000000000000000000 // @0CD5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0CD6: // Incoming jump from 0x0C6F, if !(stack[-1] < stack[-2]) // Inputs[4] // { // @0CDC stack[-6] // @0CDD stack[-5] // @0CDE stack[-8] // @0CDF stack[-7] // } 0CD6 5B JUMPDEST 0CD7 50 POP 0CD8 50 POP 0CD9 61 PUSH2 0x0ce4 0CDC 84 DUP5 0CDD 84 DUP5 0CDE 88 DUP9 0CDF 88 DUP9 0CE0 61 PUSH2 0x22e0 0CE3 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0CD9 stack[-2] = 0x0ce4 // @0CDC stack[-1] = stack[-6] // @0CDD stack[0] = stack[-5] // @0CDE stack[1] = stack[-8] // @0CDF stack[2] = stack[-7] // } // Block ends with call to 0x22e0, returns to 0x0CE4 label_0CE4: // Incoming return from call to 0x22E0 at 0x0CE3 // Inputs[10] // { // @0CE8 memory[0x40:0x60] // @0CE9 stack[-2] // @0CF0 stack[-1] // @0CF6 stack[-11] // @0CFD stack[-10] // @0D01 memory[0x40:0x60] // @0D17 stack[-9] // @0D1A msg.sender // @0D45 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x80 + (memory[0x40:0x60] - memory[0x40:0x60])] // @0D56 stack[-12] // } 0CE4 5B JUMPDEST 0CE5 60 PUSH1 0x40 0CE7 80 DUP1 0CE8 51 MLOAD 0CE9 83 DUP4 0CEA 81 DUP2 0CEB 52 MSTORE 0CEC 60 PUSH1 0x20 0CEE 81 DUP2 0CEF 01 ADD 0CF0 83 DUP4 0CF1 90 SWAP1 0CF2 52 MSTORE 0CF3 80 DUP1 0CF4 82 DUP3 0CF5 01 ADD 0CF6 8D DUP14 0CF7 90 SWAP1 0CF8 52 MSTORE 0CF9 60 PUSH1 0x60 0CFB 81 DUP2 0CFC 01 ADD 0CFD 8C DUP13 0CFE 90 SWAP1 0CFF 52 MSTORE 0D00 90 SWAP1 0D01 51 MLOAD 0D02 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D17 8B DUP12 0D18 16 AND 0D19 91 SWAP2 0D1A 33 CALLER 0D1B 91 SWAP2 0D1C 7F PUSH32 0xd78ad95fa46c994b6551d0da85fc275fe613ce37657fb8d5e3d130840159d822 0D3D 91 SWAP2 0D3E 81 DUP2 0D3F 90 SWAP1 0D40 03 SUB 0D41 60 PUSH1 0x80 0D43 01 ADD 0D44 90 SWAP1 0D45 A3 LOG3 0D46 50 POP 0D47 50 POP 0D48 60 PUSH1 0x01 0D4A 60 PUSH1 0x0c 0D4C 55 SSTORE 0D4D 50 POP 0D4E 50 POP 0D4F 50 POP 0D50 50 POP 0D51 50 POP 0D52 50 POP 0D53 50 POP 0D54 50 POP 0D55 50 POP 0D56 56 *JUMP // Stack delta = -12 // Outputs[6] // { // @0CEB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0CF2 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @0CF8 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-11] // @0CFF memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-10] // @0D45 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x80 + (memory[0x40:0x60] - memory[0x40:0x60])], [0xd78ad95fa46c994b6551d0da85fc275fe613ce37657fb8d5e3d130840159d822, msg.sender, stack[-9] & 0xffffffffffffffffffffffffffffffffffffffff]); // @0D4C storage[0x0c] = 0x01 // } // Block ends with unconditional jump to stack[-12] label_0D57: // Incoming call from 0x0260, returns to 0x0261 // Inputs[2] // { // @0D5A memory[0x40:0x60] // @0D8E stack[-1] // } 0D57 5B JUMPDEST 0D58 60 PUSH1 0x40 0D5A 51 MLOAD 0D5B 80 DUP1 0D5C 60 PUSH1 0x40 0D5E 01 ADD 0D5F 60 PUSH1 0x40 0D61 52 MSTORE 0D62 80 DUP1 0D63 60 PUSH1 0x0a 0D65 81 DUP2 0D66 52 MSTORE 0D67 60 PUSH1 0x20 0D69 01 ADD 0D6A 7F PUSH32 0x556e697377617020563200000000000000000000000000000000000000000000 0D8B 81 DUP2 0D8C 52 MSTORE 0D8D 50 POP 0D8E 81 DUP2 0D8F 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @0D5A stack[0] = memory[0x40:0x60] // @0D61 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0D66 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a // @0D8C memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x556e697377617020563200000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-1] label_0D90: // Incoming call from 0x1478, returns to 0x1479 // Incoming call from 0x1093, returns to 0x1094 // Incoming call from 0x02DD, returns to 0x02DE // Incoming call from 0x0766, returns to 0x0767 // Inputs[2] // { // @0D93 storage[0x08] // @0DA6 stack[-1] // } 0D90 5B JUMPDEST 0D91 60 PUSH1 0x08 0D93 54 SLOAD 0D94 6D PUSH14 0xffffffffffffffffffffffffffff 0DA3 80 DUP1 0DA4 82 DUP3 0DA5 16 AND 0DA6 92 SWAP3 0DA7 6E PUSH15 0x010000000000000000000000000000 0DB7 83 DUP4 0DB8 04 DIV 0DB9 90 SWAP1 0DBA 91 SWAP2 0DBB 16 AND 0DBC 91 SWAP2 0DBD 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 0DDB 90 SWAP1 0DDC 04 DIV 0DDD 63 PUSH4 0xffffffff 0DE2 16 AND 0DE3 90 SWAP1 0DE4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0DA6 stack[-1] = storage[0x08] & 0xffffffffffffffffffffffffffff // @0DBC stack[0] = 0xffffffffffffffffffffffffffff & storage[0x08] / 0x010000000000000000000000000000 // @0DE3 stack[1] = 0xffffffff & storage[0x08] / 0x0100000000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-1] label_0DE5: // Incoming jump from 0x034D // Inputs[3] // { // @0DEB msg.sender // @0DEC stack[-2] // @0DED stack[-1] // } 0DE5 5B JUMPDEST 0DE6 60 PUSH1 0x00 0DE8 61 PUSH2 0x0df2 0DEB 33 CALLER 0DEC 84 DUP5 0DED 84 DUP5 0DEE 61 PUSH2 0x259c 0DF1 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0DE6 stack[0] = 0x00 // @0DE8 stack[1] = 0x0df2 // @0DEB stack[2] = msg.sender // @0DEC stack[3] = stack[-2] // @0DED stack[4] = stack[-1] // } // Block ends with call to 0x259c, returns to 0x0DF2 label_0DF2: // Incoming return from call to 0x259C at 0x0DF1 // Incoming return from call to 0x260B at 0x18D7 0DF2 5B JUMPDEST 0DF3 50 POP 0DF4 60 PUSH1 0x01 // Stack delta = +0 // Outputs[1] { @0DF4 stack[-1] = 0x01 } // Block continues label_0DF6: // Incoming jump from 0x2207, if stack[-1] // Incoming jump from 0x2AC7, if !(stack[-2] + stack[-1] < stack[-2]) // Incoming jump from 0x2279, if !(stack[-2] - stack[-1] > stack[-2]) // Incoming jump from 0x0DF4 // Inputs[3] // { // @0DF7 stack[-1] // @0DF7 stack[-4] // @0DF8 stack[-3] // } 0DF6 5B JUMPDEST 0DF7 92 SWAP3 0DF8 91 SWAP2 0DF9 50 POP 0DFA 50 POP 0DFB 56 *JUMP // Stack delta = -3 // Outputs[1] { @0DF7 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0DFC: // Incoming call from 0x0369, returns to 0x036A // Inputs[2] // { // @0DFF storage[0x06] // @0E16 stack[-1] // } 0DFC 5B JUMPDEST 0DFD 60 PUSH1 0x06 0DFF 54 SLOAD 0E00 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E15 16 AND 0E16 81 DUP2 0E17 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E15 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] } // Block ends with unconditional jump to stack[-1] label_0E18: // Incoming call from 0x039A, returns to 0x039B // Inputs[2] // { // @0E1B storage[0x00] // @0E1C stack[-1] // } 0E18 5B JUMPDEST 0E19 60 PUSH1 0x00 0E1B 54 SLOAD 0E1C 81 DUP2 0E1D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E1B stack[0] = storage[0x00] } // Block ends with unconditional jump to stack[-1] label_0E1E: // Incoming jump from 0x03EF // Inputs[5] // { // @0E34 stack[-3] // @0E46 memory[0x00:0x40] // @0E47 msg.sender // @0E4E memory[0x00:0x40] // @0E4F storage[keccak256(memory[0x00:0x40])] // } 0E1E 5B JUMPDEST 0E1F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E34 83 DUP4 0E35 16 AND 0E36 60 PUSH1 0x00 0E38 90 SWAP1 0E39 81 DUP2 0E3A 52 MSTORE 0E3B 60 PUSH1 0x02 0E3D 60 PUSH1 0x20 0E3F 90 SWAP1 0E40 81 DUP2 0E41 52 MSTORE 0E42 60 PUSH1 0x40 0E44 80 DUP1 0E45 83 DUP4 0E46 20 SHA3 0E47 33 CALLER 0E48 84 DUP5 0E49 52 MSTORE 0E4A 90 SWAP1 0E4B 91 SWAP2 0E4C 52 MSTORE 0E4D 81 DUP2 0E4E 20 SHA3 0E4F 54 SLOAD 0E50 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0E71 14 EQ 0E72 61 PUSH2 0x0ee8 0E75 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @0E38 stack[0] = 0x00 // @0E3A memory[0x00:0x20] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @0E41 memory[0x20:0x40] = 0x02 // @0E49 memory[0x00:0x20] = msg.sender // @0E4C memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x0ee8, if 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff == storage[keccak256(memory[0x00:0x40])] label_0E76: // Incoming jump from 0x0E75, if not 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff == storage[keccak256(memory[0x00:0x40])] // Inputs[6] // { // @0E8B stack[-4] // @0E9D memory[0x00:0x40] // @0E9E msg.sender // @0EA5 memory[0x00:0x40] // @0EA6 storage[keccak256(memory[0x00:0x40])] // @0EAB stack[-2] // } 0E76 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E8B 84 DUP5 0E8C 16 AND 0E8D 60 PUSH1 0x00 0E8F 90 SWAP1 0E90 81 DUP2 0E91 52 MSTORE 0E92 60 PUSH1 0x02 0E94 60 PUSH1 0x20 0E96 90 SWAP1 0E97 81 DUP2 0E98 52 MSTORE 0E99 60 PUSH1 0x40 0E9B 80 DUP1 0E9C 83 DUP4 0E9D 20 SHA3 0E9E 33 CALLER 0E9F 84 DUP5 0EA0 52 MSTORE 0EA1 90 SWAP1 0EA2 91 SWAP2 0EA3 52 MSTORE 0EA4 90 SWAP1 0EA5 20 SHA3 0EA6 54 SLOAD 0EA7 61 PUSH2 0x0eb6 0EAA 90 SWAP1 0EAB 83 DUP4 0EAC 63 PUSH4 0xffffffff 0EB1 61 PUSH2 0x226e 0EB4 16 AND 0EB5 56 *JUMP // Stack delta = +3 // Outputs[7] // { // @0E91 memory[0x00:0x20] = stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // @0E98 memory[0x20:0x40] = 0x02 // @0EA0 memory[0x00:0x20] = msg.sender // @0EA3 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0EAA stack[0] = 0x0eb6 // @0EAA stack[1] = storage[keccak256(memory[0x00:0x40])] // @0EAB stack[2] = stack[-2] // } // Block ends with call to 0x226e & 0xffffffff, returns to 0x0EB6 label_0EB6: // Incoming return from call to 0x226E at 0x0EB5 // Inputs[5] // { // @0ECC stack[-5] // @0EDE memory[0x00:0x40] // @0EDF msg.sender // @0EE6 memory[0x00:0x40] // @0EE7 stack[-1] // } 0EB6 5B JUMPDEST 0EB7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0ECC 85 DUP6 0ECD 16 AND 0ECE 60 PUSH1 0x00 0ED0 90 SWAP1 0ED1 81 DUP2 0ED2 52 MSTORE 0ED3 60 PUSH1 0x02 0ED5 60 PUSH1 0x20 0ED7 90 SWAP1 0ED8 81 DUP2 0ED9 52 MSTORE 0EDA 60 PUSH1 0x40 0EDC 80 DUP1 0EDD 83 DUP4 0EDE 20 SHA3 0EDF 33 CALLER 0EE0 84 DUP5 0EE1 52 MSTORE 0EE2 90 SWAP1 0EE3 91 SWAP2 0EE4 52 MSTORE 0EE5 90 SWAP1 0EE6 20 SHA3 0EE7 55 SSTORE // Stack delta = -1 // Outputs[5] // { // @0ED2 memory[0x00:0x20] = stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff // @0ED9 memory[0x20:0x40] = 0x02 // @0EE1 memory[0x00:0x20] = msg.sender // @0EE4 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0EE7 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block continues label_0EE8: // Incoming jump from 0x0E75, if 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff == storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x0EE7 // Inputs[3] // { // @0EEC stack[-4] // @0EED stack[-3] // @0EEE stack[-2] // } 0EE8 5B JUMPDEST 0EE9 61 PUSH2 0x0ef3 0EEC 84 DUP5 0EED 84 DUP5 0EEE 84 DUP5 0EEF 61 PUSH2 0x260b 0EF2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EE9 stack[0] = 0x0ef3 // @0EEC stack[1] = stack[-4] // @0EED stack[2] = stack[-3] // @0EEE stack[3] = stack[-2] // } // Block ends with call to 0x260b, returns to 0x0EF3 label_0EF3: // Incoming return from call to 0x260B at 0x0EF2 // Inputs[2] // { // @0EF7 stack[-5] // @0EF8 stack[-4] // } 0EF3 5B JUMPDEST 0EF4 50 POP 0EF5 60 PUSH1 0x01 0EF7 93 SWAP4 0EF8 92 SWAP3 0EF9 50 POP 0EFA 50 POP 0EFB 50 POP 0EFC 56 *JUMP // Stack delta = -4 // Outputs[1] { @0EF7 stack[-5] = 0x01 } // Block ends with unconditional jump to stack[-5] label_0EFD: // Incoming call from 0x03F7, returns to 0x039B // Inputs[1] { @0F1F stack[-1] } 0EFD 5B JUMPDEST 0EFE 7F PUSH32 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9 0F1F 81 DUP2 0F20 56 *JUMP // Stack delta = +1 // Outputs[1] { @0EFE stack[0] = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9 } // Block ends with unconditional jump to stack[-1] label_0F21: // Incoming call from 0x03FF, returns to 0x0400 // Inputs[1] { @0F24 stack[-1] } 0F21 5B JUMPDEST 0F22 60 PUSH1 0x12 0F24 81 DUP2 0F25 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F22 stack[0] = 0x12 } // Block ends with unconditional jump to stack[-1] label_0F26: // Incoming call from 0x041D, returns to 0x039B // Inputs[2] // { // @0F29 storage[0x03] // @0F2A stack[-1] // } 0F26 5B JUMPDEST 0F27 60 PUSH1 0x03 0F29 54 SLOAD 0F2A 81 DUP2 0F2B 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F29 stack[0] = storage[0x03] } // Block ends with unconditional jump to stack[-1] label_0F2C: // Incoming jump from 0x0458 // Inputs[2] // { // @0F2F storage[0x05] // @0F46 msg.sender // } 0F2C 5B JUMPDEST 0F2D 60 PUSH1 0x05 0F2F 54 SLOAD 0F30 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F45 16 AND 0F46 33 CALLER 0F47 14 EQ 0F48 61 PUSH2 0x0fb2 0F4B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fb2, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] label_0F4C: // Incoming jump from 0x0F4B, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] // Inputs[3] // { // @0F4F memory[0x40:0x60] // @0FA8 memory[0x40:0x60] // @0FB1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0F4C 60 PUSH1 0x40 0F4E 80 DUP1 0F4F 51 MLOAD 0F50 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0F71 81 DUP2 0F72 52 MSTORE 0F73 60 PUSH1 0x20 0F75 60 PUSH1 0x04 0F77 82 DUP3 0F78 01 ADD 0F79 52 MSTORE 0F7A 60 PUSH1 0x14 0F7C 60 PUSH1 0x24 0F7E 82 DUP3 0F7F 01 ADD 0F80 52 MSTORE 0F81 7F PUSH32 0x556e697377617056323a20464f5242494444454e000000000000000000000000 0FA2 60 PUSH1 0x44 0FA4 82 DUP3 0FA5 01 ADD 0FA6 52 MSTORE 0FA7 90 SWAP1 0FA8 51 MLOAD 0FA9 90 SWAP1 0FAA 81 DUP2 0FAB 90 SWAP1 0FAC 03 SUB 0FAD 60 PUSH1 0x64 0FAF 01 ADD 0FB0 90 SWAP1 0FB1 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0F72 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0F79 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F80 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @0FA6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x556e697377617056323a20464f5242494444454e000000000000000000000000 // @0FB1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0FB2: // Incoming jump from 0x0F4B, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] // Inputs[5] // { // @0FB6 storage[0x06] // @0FCC stack[-2] // @0FFA storage[0x07] // @0FFB stack[-1] // @1004 stack[-3] // } 0FB2 5B JUMPDEST 0FB3 60 PUSH1 0x06 0FB5 80 DUP1 0FB6 54 SLOAD 0FB7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FCC 93 SWAP4 0FCD 84 DUP5 0FCE 16 AND 0FCF 7F PUSH32 0xffffffffffffffffffffffff0000000000000000000000000000000000000000 0FF0 91 SWAP2 0FF1 82 DUP3 0FF2 16 AND 0FF3 17 OR 0FF4 90 SWAP1 0FF5 91 SWAP2 0FF6 55 SSTORE 0FF7 60 PUSH1 0x07 0FF9 80 DUP1 0FFA 54 SLOAD 0FFB 92 SWAP3 0FFC 90 SWAP1 0FFD 93 SWAP4 0FFE 16 AND 0FFF 91 SWAP2 1000 16 AND 1001 17 OR 1002 90 SWAP1 1003 55 SSTORE 1004 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0FF6 storage[0x06] = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & storage[0x06]) | (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) // @1003 storage[0x07] = (storage[0x07] & 0xffffffffffffffffffffffff0000000000000000000000000000000000000000) | (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // } // Block ends with unconditional jump to stack[-3] label_1005: // Incoming call from 0x0460, returns to 0x039B // Inputs[2] // { // @1008 storage[0x09] // @1009 stack[-1] // } 1005 5B JUMPDEST 1006 60 PUSH1 0x09 1008 54 SLOAD 1009 81 DUP2 100A 56 *JUMP // Stack delta = +1 // Outputs[1] { @1008 stack[0] = storage[0x09] } // Block ends with unconditional jump to stack[-1] label_100B: // Incoming call from 0x0468, returns to 0x039B // Inputs[2] // { // @100E storage[0x0a] // @100F stack[-1] // } 100B 5B JUMPDEST 100C 60 PUSH1 0x0a 100E 54 SLOAD 100F 81 DUP2 1010 56 *JUMP // Stack delta = +1 // Outputs[1] { @100E stack[0] = storage[0x0a] } // Block ends with unconditional jump to stack[-1] label_1011: // Incoming jump from 0x049B // Inputs[1] { @1016 storage[0x0c] } 1011 5B JUMPDEST 1012 60 PUSH1 0x00 1014 60 PUSH1 0x0c 1016 54 SLOAD 1017 60 PUSH1 0x01 1019 14 EQ 101A 61 PUSH2 0x1084 101D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1012 stack[0] = 0x00 } // Block ends with conditional jump to 0x1084, if 0x01 == storage[0x0c] label_101E: // Incoming jump from 0x101D, if not 0x01 == storage[0x0c] // Inputs[3] // { // @1021 memory[0x40:0x60] // @107A memory[0x40:0x60] // @1083 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 101E 60 PUSH1 0x40 1020 80 DUP1 1021 51 MLOAD 1022 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1043 81 DUP2 1044 52 MSTORE 1045 60 PUSH1 0x20 1047 60 PUSH1 0x04 1049 82 DUP3 104A 01 ADD 104B 52 MSTORE 104C 60 PUSH1 0x11 104E 60 PUSH1 0x24 1050 82 DUP3 1051 01 ADD 1052 52 MSTORE 1053 7F PUSH32 0x556e697377617056323a204c4f434b4544000000000000000000000000000000 1074 60 PUSH1 0x44 1076 82 DUP3 1077 01 ADD 1078 52 MSTORE 1079 90 SWAP1 107A 51 MLOAD 107B 90 SWAP1 107C 81 DUP2 107D 90 SWAP1 107E 03 SUB 107F 60 PUSH1 0x64 1081 01 ADD 1082 90 SWAP1 1083 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1044 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @104B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1052 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x11 // @1078 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x556e697377617056323a204c4f434b4544000000000000000000000000000000 // @1083 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1084: // Incoming jump from 0x101D, if 0x01 == storage[0x0c] 1084 5B JUMPDEST 1085 60 PUSH1 0x00 1087 60 PUSH1 0x0c 1089 81 DUP2 108A 90 SWAP1 108B 55 SSTORE 108C 80 DUP1 108D 61 PUSH2 0x1094 1090 61 PUSH2 0x0d90 1093 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1085 stack[0] = 0x00 // @108B storage[0x0c] = 0x00 // @108C stack[1] = 0x00 // @108D stack[2] = 0x1094 // } // Block ends with call to 0x0d90, returns to 0x1094 label_1094: // Incoming return from call to 0x0D90 at 0x1093 // Inputs[9] // { // @1098 storage[0x06] // @109C memory[0x40:0x60] // @10C0 address(this) // @10C7 memory[0x40:0x60] // @10C8 stack[-3] // @10C9 stack[-5] // @10CB stack[-2] // @10CC stack[-4] // @1102 address(storage[0x06] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 1094 5B JUMPDEST 1095 50 POP 1096 60 PUSH1 0x06 1098 54 SLOAD 1099 60 PUSH1 0x40 109B 80 DUP1 109C 51 MLOAD 109D 7F PUSH32 0x70a0823100000000000000000000000000000000000000000000000000000000 10BE 81 DUP2 10BF 52 MSTORE 10C0 30 ADDRESS 10C1 60 PUSH1 0x04 10C3 82 DUP3 10C4 01 ADD 10C5 52 MSTORE 10C6 90 SWAP1 10C7 51 MLOAD 10C8 93 SWAP4 10C9 95 SWAP6 10CA 50 POP 10CB 91 SWAP2 10CC 93 SWAP4 10CD 50 POP 10CE 60 PUSH1 0x00 10D0 92 SWAP3 10D1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10E6 90 SWAP1 10E7 91 SWAP2 10E8 16 AND 10E9 91 SWAP2 10EA 63 PUSH4 0x70a08231 10EF 91 SWAP2 10F0 60 PUSH1 0x24 10F2 80 DUP1 10F3 83 DUP4 10F4 01 ADD 10F5 92 SWAP3 10F6 60 PUSH1 0x20 10F8 92 SWAP3 10F9 91 SWAP2 10FA 90 SWAP1 10FB 82 DUP3 10FC 90 SWAP1 10FD 03 SUB 10FE 01 ADD 10FF 81 DUP2 1100 86 DUP7 1101 80 DUP1 1102 3B EXTCODESIZE 1103 15 ISZERO 1104 80 DUP1 1105 15 ISZERO 1106 61 PUSH2 0x110e 1109 57 *JUMPI // Stack delta = +7 // Outputs[14] // { // @10BF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000 // @10C5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @10C9 stack[-5] = stack[-3] // @10CC stack[-4] = stack[-2] // @10D0 stack[-3] = 0x00 // @10E9 stack[-2] = storage[0x06] & 0xffffffffffffffffffffffffffffffffffffffff // @10EF stack[-1] = 0x70a08231 // @10F5 stack[0] = memory[0x40:0x60] + 0x24 // @10F8 stack[1] = 0x20 // @10F9 stack[2] = memory[0x40:0x60] // @10FE stack[3] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @10FF stack[4] = memory[0x40:0x60] // @1100 stack[5] = storage[0x06] & 0xffffffffffffffffffffffffffffffffffffffff // @1103 stack[6] = !address(storage[0x06] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x110e, if !!address(storage[0x06] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_110A: // Incoming jump from 0x1109, if not !!address(storage[0x06] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @110D memory[0x00:0x00] } 110A 60 PUSH1 0x00 110C 80 DUP1 110D FD *REVERT // Stack delta = +0 // Outputs[1] { @110D revert(memory[0x00:0x00]); } // Block terminates label_110E: // Incoming jump from 0x1109, if !!address(storage[0x06] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[8] // { // @1110 msg.gas // @1111 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1111 memory[stack[-3]:stack[-3] + stack[-4]] // @1111 stack[-5] // @1111 stack[-2] // @1111 stack[-4] // @1111 stack[-6] // @1111 stack[-3] // } 110E 5B JUMPDEST 110F 50 POP 1110 5A GAS 1111 FA STATICCALL 1112 15 ISZERO 1113 80 DUP1 1114 15 ISZERO 1115 61 PUSH2 0x1122 1118 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1111 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1112 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1122, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1119: // Incoming jump from 0x1118, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1119 returndata.length // @111D returndata[0x00:0x00 + returndata.length] // @111E returndata.length // @1121 memory[0x00:0x00 + returndata.length] // } 1119 3D RETURNDATASIZE 111A 60 PUSH1 0x00 111C 80 DUP1 111D 3E RETURNDATACOPY 111E 3D RETURNDATASIZE 111F 60 PUSH1 0x00 1121 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @111D memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1121 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1122: // Incoming jump from 0x1118, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1129 memory[0x40:0x60] // @112A returndata.length // } 1122 5B JUMPDEST 1123 50 POP 1124 50 POP 1125 50 POP 1126 50 POP 1127 60 PUSH1 0x40 1129 51 MLOAD 112A 3D RETURNDATASIZE 112B 60 PUSH1 0x20 112D 81 DUP2 112E 10 LT 112F 15 ISZERO 1130 61 PUSH2 0x1138 1133 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1129 stack[-4] = memory[0x40:0x60] // @112A stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1138, if !(returndata.length < 0x20) label_1134: // Incoming jump from 0x1133, if not !(returndata.length < 0x20) // Inputs[1] { @1137 memory[0x00:0x00] } 1134 60 PUSH1 0x00 1136 80 DUP1 1137 FD *REVERT // Stack delta = +0 // Outputs[1] { @1137 revert(memory[0x00:0x00]); } // Block terminates label_1138: // Incoming jump from 0x1133, if !(returndata.length < 0x20) // Inputs[8] // { // @113A memory[stack[-2]:stack[-2] + 0x20] // @113A stack[-2] // @113D storage[0x07] // @1141 memory[0x40:0x60] // @1165 address(this) // @116C memory[0x40:0x60] // @116E stack[-3] // @11A5 address(storage[0x07] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 1138 5B JUMPDEST 1139 50 POP 113A 51 MLOAD 113B 60 PUSH1 0x07 113D 54 SLOAD 113E 60 PUSH1 0x40 1140 80 DUP1 1141 51 MLOAD 1142 7F PUSH32 0x70a0823100000000000000000000000000000000000000000000000000000000 1163 81 DUP2 1164 52 MSTORE 1165 30 ADDRESS 1166 60 PUSH1 0x04 1168 82 DUP3 1169 01 ADD 116A 52 MSTORE 116B 90 SWAP1 116C 51 MLOAD 116D 92 SWAP3 116E 93 SWAP4 116F 50 POP 1170 60 PUSH1 0x00 1172 92 SWAP3 1173 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1188 90 SWAP1 1189 92 SWAP3 118A 16 AND 118B 91 SWAP2 118C 63 PUSH4 0x70a08231 1191 91 SWAP2 1192 60 PUSH1 0x24 1194 80 DUP1 1195 82 DUP3 1196 01 ADD 1197 92 SWAP3 1198 60 PUSH1 0x20 119A 92 SWAP3 119B 90 SWAP1 119C 91 SWAP2 119D 90 SWAP1 119E 82 DUP3 119F 90 SWAP1 11A0 03 SUB 11A1 01 ADD 11A2 81 DUP2 11A3 86 DUP7 11A4 80 DUP1 11A5 3B EXTCODESIZE 11A6 15 ISZERO 11A7 80 DUP1 11A8 15 ISZERO 11A9 61 PUSH2 0x11b1 11AC 57 *JUMPI // Stack delta = +8 // Outputs[13] // { // @1164 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000 // @116A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @116E stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @1172 stack[-2] = 0x00 // @118B stack[-1] = storage[0x07] & 0xffffffffffffffffffffffffffffffffffffffff // @1191 stack[0] = 0x70a08231 // @1197 stack[1] = memory[0x40:0x60] + 0x24 // @119A stack[2] = 0x20 // @119C stack[3] = memory[0x40:0x60] // @11A1 stack[4] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @11A2 stack[5] = memory[0x40:0x60] // @11A3 stack[6] = storage[0x07] & 0xffffffffffffffffffffffffffffffffffffffff // @11A6 stack[7] = !address(storage[0x07] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x11b1, if !!address(storage[0x07] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_11AD: // Incoming jump from 0x11AC, if not !!address(storage[0x07] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @11B0 memory[0x00:0x00] } 11AD 60 PUSH1 0x00 11AF 80 DUP1 11B0 FD *REVERT // Stack delta = +0 // Outputs[1] { @11B0 revert(memory[0x00:0x00]); } // Block terminates label_11B1: // Incoming jump from 0x11AC, if !!address(storage[0x07] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[8] // { // @11B3 msg.gas // @11B4 stack[-3] // @11B4 stack[-4] // @11B4 stack[-2] // @11B4 stack[-6] // @11B4 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @11B4 memory[stack[-3]:stack[-3] + stack[-4]] // @11B4 stack[-5] // } 11B1 5B JUMPDEST 11B2 50 POP 11B3 5A GAS 11B4 FA STATICCALL 11B5 15 ISZERO 11B6 80 DUP1 11B7 15 ISZERO 11B8 61 PUSH2 0x11c5 11BB 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @11B4 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @11B5 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x11c5, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_11BC: // Incoming jump from 0x11BB, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @11BC returndata.length // @11C0 returndata[0x00:0x00 + returndata.length] // @11C1 returndata.length // @11C4 memory[0x00:0x00 + returndata.length] // } 11BC 3D RETURNDATASIZE 11BD 60 PUSH1 0x00 11BF 80 DUP1 11C0 3E RETURNDATACOPY 11C1 3D RETURNDATASIZE 11C2 60 PUSH1 0x00 11C4 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @11C0 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @11C4 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_11C5: // Incoming jump from 0x11BB, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @11CC memory[0x40:0x60] // @11CD returndata.length // } 11C5 5B JUMPDEST 11C6 50 POP 11C7 50 POP 11C8 50 POP 11C9 50 POP 11CA 60 PUSH1 0x40 11CC 51 MLOAD 11CD 3D RETURNDATASIZE 11CE 60 PUSH1 0x20 11D0 81 DUP2 11D1 10 LT 11D2 15 ISZERO 11D3 61 PUSH2 0x11db 11D6 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @11CC stack[-4] = memory[0x40:0x60] // @11CD stack[-3] = returndata.length // } // Block ends with conditional jump to 0x11db, if !(returndata.length < 0x20) label_11D7: // Incoming jump from 0x11D6, if not !(returndata.length < 0x20) // Inputs[1] { @11DA memory[0x00:0x00] } 11D7 60 PUSH1 0x00 11D9 80 DUP1 11DA FD *REVERT // Stack delta = +0 // Outputs[1] { @11DA revert(memory[0x00:0x00]); } // Block terminates label_11DB: // Incoming jump from 0x11D6, if !(returndata.length < 0x20) // Inputs[5] // { // @11DD memory[stack[-2]:stack[-2] + 0x20] // @11DD stack[-2] // @11DE stack[-3] // @11E5 stack[-4] // @11F5 stack[-6] // } 11DB 5B JUMPDEST 11DC 50 POP 11DD 51 MLOAD 11DE 90 SWAP1 11DF 50 POP 11E0 60 PUSH1 0x00 11E2 61 PUSH2 0x1201 11E5 83 DUP4 11E6 6D PUSH14 0xffffffffffffffffffffffffffff 11F5 87 DUP8 11F6 16 AND 11F7 63 PUSH4 0xffffffff 11FC 61 PUSH2 0x226e 11FF 16 AND 1200 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @11DE stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @11E0 stack[-2] = 0x00 // @11E2 stack[-1] = 0x1201 // @11E5 stack[0] = stack[-4] // @11F6 stack[1] = stack[-6] & 0xffffffffffffffffffffffffffff // } // Block ends with call to 0x226e & 0xffffffff, returns to 0x1201 label_1201: // Incoming return from call to 0x226E at 0x1200 // Inputs[4] // { // @1202 stack[-1] // @1202 stack[-2] // @1209 stack[-3] // @1219 stack[-5] // } 1201 5B JUMPDEST 1202 90 SWAP1 1203 50 POP 1204 60 PUSH1 0x00 1206 61 PUSH2 0x1225 1209 83 DUP4 120A 6D PUSH14 0xffffffffffffffffffffffffffff 1219 87 DUP8 121A 16 AND 121B 63 PUSH4 0xffffffff 1220 61 PUSH2 0x226e 1223 16 AND 1224 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1202 stack[-2] = stack[-1] // @1204 stack[-1] = 0x00 // @1206 stack[0] = 0x1225 // @1209 stack[1] = stack[-3] // @121A stack[2] = stack[-5] & 0xffffffffffffffffffffffffffff // } // Block ends with call to 0x226e & 0xffffffff, returns to 0x1225 label_1225: // Incoming return from call to 0x226E at 0x1224 // Inputs[4] // { // @1226 stack[-2] // @1226 stack[-1] // @122D stack[-7] // @122E stack[-6] // } 1225 5B JUMPDEST 1226 90 SWAP1 1227 50 POP 1228 60 PUSH1 0x00 122A 61 PUSH2 0x1233 122D 87 DUP8 122E 87 DUP8 122F 61 PUSH2 0x26ec 1232 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1226 stack[-2] = stack[-1] // @1228 stack[-1] = 0x00 // @122A stack[0] = 0x1233 // @122D stack[1] = stack[-7] // @122E stack[2] = stack[-6] // } // Block ends with call to 0x26ec, returns to 0x1233 label_1233: // Incoming return from call to 0x26EC at 0x1232 // Inputs[3] // { // @1236 storage[0x00] // @1237 stack[-1] // @1238 stack[-2] // } 1233 5B JUMPDEST 1234 60 PUSH1 0x00 1236 54 SLOAD 1237 90 SWAP1 1238 91 SWAP2 1239 50 POP 123A 80 DUP1 123B 61 PUSH2 0x1270 123E 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1237 stack[-1] = storage[0x00] // @1238 stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x1270, if storage[0x00] label_123F: // Incoming jump from 0x123E, if not storage[0x00] // Inputs[2] // { // @124B stack[-4] // @124C stack[-3] // } 123F 61 PUSH2 0x125c 1242 61 PUSH2 0x03e8 1245 61 PUSH2 0x0bfd 1248 61 PUSH2 0x1257 124B 87 DUP8 124C 87 DUP8 124D 63 PUSH4 0xffffffff 1252 61 PUSH2 0x21e8 1255 16 AND 1256 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @123F stack[0] = 0x125c // @1242 stack[1] = 0x03e8 // @1245 stack[2] = 0x0bfd // @1248 stack[3] = 0x1257 // @124B stack[4] = stack[-4] // @124C stack[5] = stack[-3] // } // Block ends with call to 0x21e8 & 0xffffffff, returns to 0x1257 label_1257: // Incoming return from call to 0x21E8 at 0x1256 // Incoming return from call to 0x21E8 at 0x27D7 1257 5B JUMPDEST 1258 61 PUSH2 0x2878 125B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2878 125C 5B JUMPDEST 125D 98 SWAP9 125E 50 POP 125F 61 PUSH2 0x126b 1262 60 PUSH1 0x00 1264 61 PUSH2 0x03e8 1267 61 PUSH2 0x28ca 126A 56 *JUMP 126B 5B JUMPDEST 126C 61 PUSH2 0x12cd 126F 56 *JUMP label_1270: // Incoming jump from 0x123E, if storage[0x00] // Inputs[3] // { // @1283 stack[-8] // @1288 stack[-4] // @1289 stack[-1] // } 1270 5B JUMPDEST 1271 61 PUSH2 0x12ca 1274 6D PUSH14 0xffffffffffffffffffffffffffff 1283 89 DUP10 1284 16 AND 1285 61 PUSH2 0x1294 1288 86 DUP7 1289 84 DUP5 128A 63 PUSH4 0xffffffff 128F 61 PUSH2 0x21e8 1292 16 AND 1293 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1271 stack[0] = 0x12ca // @1284 stack[1] = stack[-8] & 0xffffffffffffffffffffffffffff // @1285 stack[2] = 0x1294 // @1288 stack[3] = stack[-4] // @1289 stack[4] = stack[-1] // } // Block ends with call to 0x21e8 & 0xffffffff, returns to 0x1294 label_1294: // Incoming return from call to 0x21E8 at 0x1293 // Inputs[1] { @1295 stack[-2] } 1294 5B JUMPDEST 1295 81 DUP2 1296 61 PUSH2 0x129b 1299 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x129b, if stack[-2] label_129A: // Incoming jump from 0x1299, if not stack[-2] 129A FE *ASSERT // Stack delta = +0 // Outputs[1] { @129A assert(); } // Block terminates label_129B: // Incoming jump from 0x1299, if stack[-2] // Inputs[5] // { // @129C stack[-2] // @129C stack[-1] // @12AC stack[-10] // @12B1 stack[-6] // @12B2 stack[-4] // } 129B 5B JUMPDEST 129C 04 DIV 129D 6D PUSH14 0xffffffffffffffffffffffffffff 12AC 89 DUP10 12AD 16 AND 12AE 61 PUSH2 0x12bd 12B1 86 DUP7 12B2 85 DUP6 12B3 63 PUSH4 0xffffffff 12B8 61 PUSH2 0x21e8 12BB 16 AND 12BC 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @129C stack[-2] = stack[-1] / stack[-2] // @12AD stack[-1] = stack[-10] & 0xffffffffffffffffffffffffffff // @12AE stack[0] = 0x12bd // @12B1 stack[1] = stack[-6] // @12B2 stack[2] = stack[-4] // } // Block ends with call to 0x21e8 & 0xffffffff, returns to 0x12BD label_12BD: // Incoming return from call to 0x21E8 at 0x12BC // Inputs[1] { @12BE stack[-2] } 12BD 5B JUMPDEST 12BE 81 DUP2 12BF 61 PUSH2 0x12c4 12C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12c4, if stack[-2] label_12C3: // Incoming jump from 0x12C2, if not stack[-2] 12C3 FE *ASSERT // Stack delta = +0 // Outputs[1] { @12C3 assert(); } // Block terminates label_12C4: // Incoming jump from 0x12C2, if stack[-2] // Inputs[2] // { // @12C5 stack[-2] // @12C5 stack[-1] // } 12C4 5B JUMPDEST 12C5 04 DIV 12C6 61 PUSH2 0x297a 12C9 56 *JUMP // Stack delta = -1 // Outputs[1] { @12C5 stack[-2] = stack[-1] / stack[-2] } // Block ends with unconditional jump to 0x297a label_12CA: // Incoming return from call to 0x1294 at 0x1293 // Inputs[2] // { // @12CB stack[-10] // @12CB stack[-1] // } 12CA 5B JUMPDEST 12CB 98 SWAP9 12CC 50 POP 12CD 5B JUMPDEST 12CE 60 PUSH1 0x00 12D0 89 DUP10 12D1 11 GT 12D2 61 PUSH2 0x1326 12D5 57 *JUMPI // Stack delta = -1 // Outputs[1] { @12CB stack[-10] = stack[-1] } // Block ends with conditional jump to 0x1326, if stack[-1] > 0x00 label_12D6: // Incoming jump from 0x12D5, if not stack[-1] > 0x00 // Inputs[3] // { // @12D8 memory[0x40:0x60] // @1320 memory[0x40:0x60] // @1325 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 12D6 60 PUSH1 0x40 12D8 51 MLOAD 12D9 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 12FA 81 DUP2 12FB 52 MSTORE 12FC 60 PUSH1 0x04 12FE 01 ADD 12FF 80 DUP1 1300 80 DUP1 1301 60 PUSH1 0x20 1303 01 ADD 1304 82 DUP3 1305 81 DUP2 1306 03 SUB 1307 82 DUP3 1308 52 MSTORE 1309 60 PUSH1 0x28 130B 81 DUP2 130C 52 MSTORE 130D 60 PUSH1 0x20 130F 01 ADD 1310 80 DUP1 1311 61 PUSH2 0x2bc1 1314 60 PUSH1 0x28 1316 91 SWAP2 1317 39 CODECOPY 1318 60 PUSH1 0x40 131A 01 ADD 131B 91 SWAP2 131C 50 POP 131D 50 POP 131E 60 PUSH1 0x40 1320 51 MLOAD 1321 80 DUP1 1322 91 SWAP2 1323 03 SUB 1324 90 SWAP1 1325 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @12FB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1308 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @130C memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x28 // @1317 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x28] = code[0x2bc1:0x2be9] // @1325 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1326: // Incoming jump from 0x12D5, if stack[-1] > 0x00 // Inputs[2] // { // @132A stack[-10] // @132B stack[-9] // } 1326 5B JUMPDEST 1327 61 PUSH2 0x1330 132A 8A DUP11 132B 8A DUP11 132C 61 PUSH2 0x28ca 132F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1327 stack[0] = 0x1330 // @132A stack[1] = stack[-10] // @132B stack[2] = stack[-9] // } // Block ends with call to 0x28ca, returns to 0x1330 label_1330: // Incoming return from call to 0x28CA at 0x132F // Inputs[4] // { // @1334 stack[-6] // @1335 stack[-5] // @1336 stack[-8] // @1337 stack[-7] // } 1330 5B JUMPDEST 1331 61 PUSH2 0x133c 1334 86 DUP7 1335 86 DUP7 1336 8A DUP11 1337 8A DUP11 1338 61 PUSH2 0x22e0 133B 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1331 stack[0] = 0x133c // @1334 stack[1] = stack[-6] // @1335 stack[2] = stack[-5] // @1336 stack[3] = stack[-8] // @1337 stack[4] = stack[-7] // } // Block ends with call to 0x22e0, returns to 0x133C label_133C: // Incoming return from call to 0x22E0 at 0x133B // Inputs[1] { @133D stack[-2] } 133C 5B JUMPDEST 133D 81 DUP2 133E 15 ISZERO 133F 61 PUSH2 0x137e 1342 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x137e, if !stack[-2] label_1343: // Incoming jump from 0x1342, if not !stack[-2] // Inputs[1] { @1345 storage[0x08] } 1343 60 PUSH1 0x08 1345 54 SLOAD 1346 61 PUSH2 0x137a 1349 90 SWAP1 134A 6D PUSH14 0xffffffffffffffffffffffffffff 1359 80 DUP1 135A 82 DUP3 135B 16 AND 135C 91 SWAP2 135D 6E PUSH15 0x010000000000000000000000000000 136D 90 SWAP1 136E 04 DIV 136F 16 AND 1370 63 PUSH4 0xffffffff 1375 61 PUSH2 0x21e8 1378 16 AND 1379 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1349 stack[0] = 0x137a // @135C stack[1] = storage[0x08] & 0xffffffffffffffffffffffffffff // @136F stack[2] = storage[0x08] / 0x010000000000000000000000000000 & 0xffffffffffffffffffffffffffff // } // Block ends with call to 0x21e8 & 0xffffffff, returns to 0x137A label_137A: // Incoming return from call to 0x21E8 at 0x1379 // Inputs[1] { @137D stack[-1] } 137A 5B JUMPDEST 137B 60 PUSH1 0x0b 137D 55 SSTORE // Stack delta = -1 // Outputs[1] { @137D storage[0x0b] = stack[-1] } // Block continues label_137E: // Incoming jump from 0x1342, if !stack[-2] // Incoming jump from 0x137D // Inputs[9] // { // @1382 memory[0x40:0x60] // @1383 stack[-4] // @138A stack[-3] // @138E memory[0x40:0x60] // @138F msg.sender // @13B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x40] // @13C1 stack[-9] // @13C2 stack[-11] // @13C3 stack[-10] // } 137E 5B JUMPDEST 137F 60 PUSH1 0x40 1381 80 DUP1 1382 51 MLOAD 1383 85 DUP6 1384 81 DUP2 1385 52 MSTORE 1386 60 PUSH1 0x20 1388 81 DUP2 1389 01 ADD 138A 85 DUP6 138B 90 SWAP1 138C 52 MSTORE 138D 81 DUP2 138E 51 MLOAD 138F 33 CALLER 1390 92 SWAP3 1391 7F PUSH32 0x4c209b5fc8ad50758f13e2e1088ba56a560dff690a1c6fef26394f4c03821c4f 13B2 92 SWAP3 13B3 82 DUP3 13B4 90 SWAP1 13B5 03 SUB 13B6 01 ADD 13B7 90 SWAP1 13B8 A2 LOG2 13B9 50 POP 13BA 50 POP 13BB 60 PUSH1 0x01 13BD 60 PUSH1 0x0c 13BF 55 SSTORE 13C0 50 POP 13C1 94 SWAP5 13C2 96 SWAP7 13C3 95 SWAP6 13C4 50 POP 13C5 50 POP 13C6 50 POP 13C7 50 POP 13C8 50 POP 13C9 50 POP 13CA 56 *JUMP // Stack delta = -10 // Outputs[5] // { // @1385 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-4] // @138C memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-3] // @13B8 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x40], [0x4c209b5fc8ad50758f13e2e1088ba56a560dff690a1c6fef26394f4c03821c4f, msg.sender]); // @13BF storage[0x0c] = 0x01 // @13C2 stack[-11] = stack[-9] // } // Block ends with unconditional jump to stack[-11] label_13CB: // Incoming jump from 0x04CE // Inputs[4] // { // @13D3 stack[-1] // @13D9 memory[0x00:0x40] // @13DA storage[keccak256(memory[0x00:0x40])] // @13DB stack[-2] // } 13CB 5B JUMPDEST 13CC 60 PUSH1 0x01 13CE 60 PUSH1 0x20 13D0 52 MSTORE 13D1 60 PUSH1 0x00 13D3 90 SWAP1 13D4 81 DUP2 13D5 52 MSTORE 13D6 60 PUSH1 0x40 13D8 90 SWAP1 13D9 20 SHA3 13DA 54 SLOAD 13DB 81 DUP2 13DC 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @13D0 memory[0x20:0x40] = 0x01 // @13D5 memory[0x00:0x20] = stack[-1] // @13DA stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_13DD: // Incoming call from 0x04D6, returns to 0x039B // Inputs[2] // { // @13E0 storage[0x0b] // @13E1 stack[-1] // } 13DD 5B JUMPDEST 13DE 60 PUSH1 0x0b 13E0 54 SLOAD 13E1 81 DUP2 13E2 56 *JUMP // Stack delta = +1 // Outputs[1] { @13E0 stack[0] = storage[0x0b] } // Block ends with unconditional jump to stack[-1] label_13E3: // Incoming jump from 0x0509 // Inputs[4] // { // @13EB stack[-1] // @13F1 memory[0x00:0x40] // @13F2 storage[keccak256(memory[0x00:0x40])] // @13F3 stack[-2] // } 13E3 5B JUMPDEST 13E4 60 PUSH1 0x04 13E6 60 PUSH1 0x20 13E8 52 MSTORE 13E9 60 PUSH1 0x00 13EB 90 SWAP1 13EC 81 DUP2 13ED 52 MSTORE 13EE 60 PUSH1 0x40 13F0 90 SWAP1 13F1 20 SHA3 13F2 54 SLOAD 13F3 81 DUP2 13F4 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @13E8 memory[0x20:0x40] = 0x04 // @13ED memory[0x00:0x20] = stack[-1] // @13F2 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_13F5: // Incoming jump from 0x053C // Inputs[1] { @13FB storage[0x0c] } 13F5 5B JUMPDEST 13F6 60 PUSH1 0x00 13F8 80 DUP1 13F9 60 PUSH1 0x0c 13FB 54 SLOAD 13FC 60 PUSH1 0x01 13FE 14 EQ 13FF 61 PUSH2 0x1469 1402 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @13F6 stack[0] = 0x00 // @13F8 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1469, if 0x01 == storage[0x0c] label_1403: // Incoming jump from 0x1402, if not 0x01 == storage[0x0c] // Inputs[3] // { // @1406 memory[0x40:0x60] // @145F memory[0x40:0x60] // @1468 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1403 60 PUSH1 0x40 1405 80 DUP1 1406 51 MLOAD 1407 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1428 81 DUP2 1429 52 MSTORE 142A 60 PUSH1 0x20 142C 60 PUSH1 0x04 142E 82 DUP3 142F 01 ADD 1430 52 MSTORE 1431 60 PUSH1 0x11 1433 60 PUSH1 0x24 1435 82 DUP3 1436 01 ADD 1437 52 MSTORE 1438 7F PUSH32 0x556e697377617056323a204c4f434b4544000000000000000000000000000000 1459 60 PUSH1 0x44 145B 82 DUP3 145C 01 ADD 145D 52 MSTORE 145E 90 SWAP1 145F 51 MLOAD 1460 90 SWAP1 1461 81 DUP2 1462 90 SWAP1 1463 03 SUB 1464 60 PUSH1 0x64 1466 01 ADD 1467 90 SWAP1 1468 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1429 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1430 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1437 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x11 // @145D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x556e697377617056323a204c4f434b4544000000000000000000000000000000 // @1468 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1469: // Incoming jump from 0x1402, if 0x01 == storage[0x0c] 1469 5B JUMPDEST 146A 60 PUSH1 0x00 146C 60 PUSH1 0x0c 146E 81 DUP2 146F 90 SWAP1 1470 55 SSTORE 1471 80 DUP1 1472 61 PUSH2 0x1479 1475 61 PUSH2 0x0d90 1478 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @146A stack[0] = 0x00 // @1470 storage[0x0c] = 0x00 // @1471 stack[1] = 0x00 // @1472 stack[2] = 0x1479 // } // Block ends with call to 0x0d90, returns to 0x1479 label_1479: // Incoming return from call to 0x0D90 at 0x1478 // Inputs[10] // { // @147D storage[0x06] // @1480 storage[0x07] // @1484 memory[0x40:0x60] // @14A8 address(this) // @14AF memory[0x40:0x60] // @14B0 stack[-3] // @14B1 stack[-5] // @14B3 stack[-2] // @14B4 stack[-4] // @14EF address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x06]).code.length // } 1479 5B JUMPDEST 147A 50 POP 147B 60 PUSH1 0x06 147D 54 SLOAD 147E 60 PUSH1 0x07 1480 54 SLOAD 1481 60 PUSH1 0x40 1483 80 DUP1 1484 51 MLOAD 1485 7F PUSH32 0x70a0823100000000000000000000000000000000000000000000000000000000 14A6 81 DUP2 14A7 52 MSTORE 14A8 30 ADDRESS 14A9 60 PUSH1 0x04 14AB 82 DUP3 14AC 01 ADD 14AD 52 MSTORE 14AE 90 SWAP1 14AF 51 MLOAD 14B0 94 SWAP5 14B1 96 SWAP7 14B2 50 POP 14B3 92 SWAP3 14B4 94 SWAP5 14B5 50 POP 14B6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14CB 91 SWAP2 14CC 82 DUP3 14CD 16 AND 14CE 93 SWAP4 14CF 91 SWAP2 14D0 16 AND 14D1 91 SWAP2 14D2 60 PUSH1 0x00 14D4 91 SWAP2 14D5 84 DUP5 14D6 91 SWAP2 14D7 63 PUSH4 0x70a08231 14DC 91 SWAP2 14DD 60 PUSH1 0x24 14DF 80 DUP1 14E0 83 DUP4 14E1 01 ADD 14E2 92 SWAP3 14E3 60 PUSH1 0x20 14E5 92 SWAP3 14E6 91 SWAP2 14E7 90 SWAP1 14E8 82 DUP3 14E9 90 SWAP1 14EA 03 SUB 14EB 01 ADD 14EC 81 DUP2 14ED 86 DUP7 14EE 80 DUP1 14EF 3B EXTCODESIZE 14F0 15 ISZERO 14F1 80 DUP1 14F2 15 ISZERO 14F3 61 PUSH2 0x14fb 14F6 57 *JUMPI // Stack delta = +9 // Outputs[16] // { // @14A7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000 // @14AD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @14B1 stack[-5] = stack[-3] // @14B4 stack[-4] = stack[-2] // @14CE stack[-3] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] // @14D1 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x07] // @14D4 stack[-1] = 0x00 // @14D6 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] // @14DC stack[1] = 0x70a08231 // @14E2 stack[2] = memory[0x40:0x60] + 0x24 // @14E5 stack[3] = 0x20 // @14E6 stack[4] = memory[0x40:0x60] // @14EB stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @14EC stack[6] = memory[0x40:0x60] // @14ED stack[7] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] // @14F0 stack[8] = !address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x06]).code.length // } // Block ends with conditional jump to 0x14fb, if !!address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x06]).code.length label_14F7: // Incoming jump from 0x14F6, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x06]).code.length // Inputs[1] { @14FA memory[0x00:0x00] } 14F7 60 PUSH1 0x00 14F9 80 DUP1 14FA FD *REVERT // Stack delta = +0 // Outputs[1] { @14FA revert(memory[0x00:0x00]); } // Block terminates label_14FB: // Incoming jump from 0x14F6, if !!address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x06]).code.length // Inputs[8] // { // @14FD msg.gas // @14FE stack[-3] // @14FE stack[-6] // @14FE stack[-4] // @14FE stack[-2] // @14FE stack[-5] // @14FE memory[stack[-3]:stack[-3] + stack[-4]] // @14FE address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } 14FB 5B JUMPDEST 14FC 50 POP 14FD 5A GAS 14FE FA STATICCALL 14FF 15 ISZERO 1500 80 DUP1 1501 15 ISZERO 1502 61 PUSH2 0x150f 1505 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @14FE memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @14FF stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x150f, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1506: // Incoming jump from 0x1505, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1506 returndata.length // @150A returndata[0x00:0x00 + returndata.length] // @150B returndata.length // @150E memory[0x00:0x00 + returndata.length] // } 1506 3D RETURNDATASIZE 1507 60 PUSH1 0x00 1509 80 DUP1 150A 3E RETURNDATACOPY 150B 3D RETURNDATASIZE 150C 60 PUSH1 0x00 150E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @150A memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @150E revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_150F: // Incoming jump from 0x1505, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1516 memory[0x40:0x60] // @1517 returndata.length // } 150F 5B JUMPDEST 1510 50 POP 1511 50 POP 1512 50 POP 1513 50 POP 1514 60 PUSH1 0x40 1516 51 MLOAD 1517 3D RETURNDATASIZE 1518 60 PUSH1 0x20 151A 81 DUP2 151B 10 LT 151C 15 ISZERO 151D 61 PUSH2 0x1525 1520 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1516 stack[-4] = memory[0x40:0x60] // @1517 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1525, if !(returndata.length < 0x20) label_1521: // Incoming jump from 0x1520, if not !(returndata.length < 0x20) // Inputs[1] { @1524 memory[0x00:0x00] } 1521 60 PUSH1 0x00 1523 80 DUP1 1524 FD *REVERT // Stack delta = +0 // Outputs[1] { @1524 revert(memory[0x00:0x00]); } // Block terminates label_1525: // Incoming jump from 0x1520, if !(returndata.length < 0x20) // Inputs[8] // { // @1527 stack[-2] // @1527 memory[stack[-2]:stack[-2] + 0x20] // @152B memory[0x40:0x60] // @154F address(this) // @1556 memory[0x40:0x60] // @1558 stack[-3] // @1572 stack[-4] // @158D address(stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 1525 5B JUMPDEST 1526 50 POP 1527 51 MLOAD 1528 60 PUSH1 0x40 152A 80 DUP1 152B 51 MLOAD 152C 7F PUSH32 0x70a0823100000000000000000000000000000000000000000000000000000000 154D 81 DUP2 154E 52 MSTORE 154F 30 ADDRESS 1550 60 PUSH1 0x04 1552 82 DUP3 1553 01 ADD 1554 52 MSTORE 1555 90 SWAP1 1556 51 MLOAD 1557 91 SWAP2 1558 92 SWAP3 1559 50 POP 155A 60 PUSH1 0x00 155C 91 SWAP2 155D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1572 85 DUP6 1573 16 AND 1574 91 SWAP2 1575 63 PUSH4 0x70a08231 157A 91 SWAP2 157B 60 PUSH1 0x24 157D 80 DUP1 157E 83 DUP4 157F 01 ADD 1580 92 SWAP3 1581 60 PUSH1 0x20 1583 92 SWAP3 1584 91 SWAP2 1585 90 SWAP1 1586 82 DUP3 1587 90 SWAP1 1588 03 SUB 1589 01 ADD 158A 81 DUP2 158B 86 DUP7 158C 80 DUP1 158D 3B EXTCODESIZE 158E 15 ISZERO 158F 80 DUP1 1590 15 ISZERO 1591 61 PUSH2 0x1599 1594 57 *JUMPI // Stack delta = +8 // Outputs[13] // { // @154E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000 // @1554 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @1558 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @155C stack[-2] = 0x00 // @1574 stack[-1] = stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // @157A stack[0] = 0x70a08231 // @1580 stack[1] = memory[0x40:0x60] + 0x24 // @1583 stack[2] = 0x20 // @1584 stack[3] = memory[0x40:0x60] // @1589 stack[4] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @158A stack[5] = memory[0x40:0x60] // @158B stack[6] = stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // @158E stack[7] = !address(stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x1599, if !!address(stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_1595: // Incoming jump from 0x1594, if not !!address(stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @1598 memory[0x00:0x00] } 1595 60 PUSH1 0x00 1597 80 DUP1 1598 FD *REVERT // Stack delta = +0 // Outputs[1] { @1598 revert(memory[0x00:0x00]); } // Block terminates label_1599: // Incoming jump from 0x1594, if !!address(stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[8] // { // @159B msg.gas // @159C stack[-3] // @159C stack[-6] // @159C stack[-4] // @159C stack[-2] // @159C stack[-5] // @159C memory[stack[-3]:stack[-3] + stack[-4]] // @159C address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } 1599 5B JUMPDEST 159A 50 POP 159B 5A GAS 159C FA STATICCALL 159D 15 ISZERO 159E 80 DUP1 159F 15 ISZERO 15A0 61 PUSH2 0x15ad 15A3 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @159C memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @159D stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x15ad, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_15A4: // Incoming jump from 0x15A3, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @15A4 returndata.length // @15A8 returndata[0x00:0x00 + returndata.length] // @15A9 returndata.length // @15AC memory[0x00:0x00 + returndata.length] // } 15A4 3D RETURNDATASIZE 15A5 60 PUSH1 0x00 15A7 80 DUP1 15A8 3E RETURNDATACOPY 15A9 3D RETURNDATASIZE 15AA 60 PUSH1 0x00 15AC FD *REVERT // Stack delta = +0 // Outputs[2] // { // @15A8 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @15AC revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_15AD: // Incoming jump from 0x15A3, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @15B4 memory[0x40:0x60] // @15B5 returndata.length // } 15AD 5B JUMPDEST 15AE 50 POP 15AF 50 POP 15B0 50 POP 15B1 50 POP 15B2 60 PUSH1 0x40 15B4 51 MLOAD 15B5 3D RETURNDATASIZE 15B6 60 PUSH1 0x20 15B8 81 DUP2 15B9 10 LT 15BA 15 ISZERO 15BB 61 PUSH2 0x15c3 15BE 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @15B4 stack[-4] = memory[0x40:0x60] // @15B5 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x15c3, if !(returndata.length < 0x20) label_15BF: // Incoming jump from 0x15BE, if not !(returndata.length < 0x20) // Inputs[1] { @15C2 memory[0x00:0x00] } 15BF 60 PUSH1 0x00 15C1 80 DUP1 15C2 FD *REVERT // Stack delta = +0 // Outputs[1] { @15C2 revert(memory[0x00:0x00]); } // Block terminates label_15C3: // Incoming jump from 0x15BE, if !(returndata.length < 0x20) // Inputs[8] // { // @15C5 stack[-2] // @15C5 memory[stack[-2]:stack[-2] + 0x20] // @15C6 address(this) // @15D4 memory[0x00:0x40] // @15D5 storage[keccak256(memory[0x00:0x40])] // @15D7 stack[-3] // @15DC stack[-8] // @15DD stack[-7] // } 15C3 5B JUMPDEST 15C4 50 POP 15C5 51 MLOAD 15C6 30 ADDRESS 15C7 60 PUSH1 0x00 15C9 90 SWAP1 15CA 81 DUP2 15CB 52 MSTORE 15CC 60 PUSH1 0x01 15CE 60 PUSH1 0x20 15D0 52 MSTORE 15D1 60 PUSH1 0x40 15D3 81 DUP2 15D4 20 SHA3 15D5 54 SLOAD 15D6 91 SWAP2 15D7 92 SWAP3 15D8 50 POP 15D9 61 PUSH2 0x15e2 15DC 88 DUP9 15DD 88 DUP9 15DE 61 PUSH2 0x26ec 15E1 56 *JUMP // Stack delta = +3 // Outputs[8] // { // @15C9 stack[-1] = 0x00 // @15CB memory[0x00:0x20] = address(this) // @15D0 memory[0x20:0x40] = 0x01 // @15D6 stack[-2] = storage[keccak256(memory[0x00:0x40])] // @15D7 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @15D9 stack[0] = 0x15e2 // @15DC stack[1] = stack[-8] // @15DD stack[2] = stack[-7] // } // Block ends with call to 0x26ec, returns to 0x15E2 label_15E2: // Incoming return from call to 0x26EC at 0x15E1 // Inputs[5] // { // @15E5 storage[0x00] // @15E6 stack[-1] // @15E7 stack[-2] // @15ED stack[-3] // @15EE stack[-5] // } 15E2 5B JUMPDEST 15E3 60 PUSH1 0x00 15E5 54 SLOAD 15E6 90 SWAP1 15E7 91 SWAP2 15E8 50 POP 15E9 80 DUP1 15EA 61 PUSH2 0x15f9 15ED 84 DUP5 15EE 87 DUP8 15EF 63 PUSH4 0xffffffff 15F4 61 PUSH2 0x21e8 15F7 16 AND 15F8 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @15E6 stack[-1] = storage[0x00] // @15E7 stack[-2] = stack[-1] // @15E9 stack[0] = storage[0x00] // @15EA stack[1] = 0x15f9 // @15ED stack[2] = stack[-3] // @15EE stack[3] = stack[-5] // } // Block ends with call to 0x21e8 & 0xffffffff, returns to 0x15F9 label_15F9: // Incoming return from call to 0x21E8 at 0x15F8 // Inputs[1] { @15FA stack[-2] } 15F9 5B JUMPDEST 15FA 81 DUP2 15FB 61 PUSH2 0x1600 15FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1600, if stack[-2] label_15FF: // Incoming jump from 0x15FE, if not stack[-2] 15FF FE *ASSERT // Stack delta = +0 // Outputs[1] { @15FF assert(); } // Block terminates label_1600: // Incoming jump from 0x15FE, if stack[-2] // Inputs[6] // { // @1601 stack[-1] // @1601 stack[-2] // @1602 stack[-13] // @1604 stack[-3] // @1608 stack[-5] // @1609 stack[-6] // } 1600 5B JUMPDEST 1601 04 DIV 1602 9A SWAP11 1603 50 POP 1604 80 DUP1 1605 61 PUSH2 0x1614 1608 84 DUP5 1609 86 DUP7 160A 63 PUSH4 0xffffffff 160F 61 PUSH2 0x21e8 1612 16 AND 1613 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1602 stack[-13] = stack[-1] / stack[-2] // @1604 stack[-2] = stack[-3] // @1605 stack[-1] = 0x1614 // @1608 stack[0] = stack[-5] // @1609 stack[1] = stack[-6] // } // Block ends with call to 0x21e8 & 0xffffffff, returns to 0x1614 label_1614: // Incoming return from call to 0x21E8 at 0x1613 // Inputs[1] { @1615 stack[-2] } 1614 5B JUMPDEST 1615 81 DUP2 1616 61 PUSH2 0x161b 1619 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x161b, if stack[-2] label_161A: // Incoming jump from 0x1619, if not stack[-2] 161A FE *ASSERT // Stack delta = +0 // Outputs[1] { @161A assert(); } // Block terminates label_161B: // Incoming jump from 0x1619, if stack[-2] // Inputs[4] // { // @161C stack[-2] // @161C stack[-1] // @161D stack[-12] // @1621 stack[-13] // } 161B 5B JUMPDEST 161C 04 DIV 161D 99 SWAP10 161E 50 POP 161F 60 PUSH1 0x00 1621 8B DUP12 1622 11 GT 1623 80 DUP1 1624 15 ISZERO 1625 61 PUSH2 0x162e 1628 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @161D stack[-12] = stack[-1] / stack[-2] // @1622 stack[-2] = stack[-13] > 0x00 // } // Block ends with conditional jump to 0x162e, if !(stack[-13] > 0x00) label_1629: // Incoming jump from 0x1628, if not !(stack[-13] > 0x00) // Inputs[1] { @162C stack[-11] } 1629 50 POP 162A 60 PUSH1 0x00 162C 8A DUP11 162D 11 GT 162E 5B JUMPDEST 162F 61 PUSH2 0x1683 1632 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1683, if stack[-11] > 0x00 label_1633: // Incoming jump from 0x1632, if not stack[-1] // Incoming jump from 0x1632, if not stack[-11] > 0x00 // Inputs[3] // { // @1635 memory[0x40:0x60] // @167D memory[0x40:0x60] // @1682 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1633 60 PUSH1 0x40 1635 51 MLOAD 1636 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1657 81 DUP2 1658 52 MSTORE 1659 60 PUSH1 0x04 165B 01 ADD 165C 80 DUP1 165D 80 DUP1 165E 60 PUSH1 0x20 1660 01 ADD 1661 82 DUP3 1662 81 DUP2 1663 03 SUB 1664 82 DUP3 1665 52 MSTORE 1666 60 PUSH1 0x28 1668 81 DUP2 1669 52 MSTORE 166A 60 PUSH1 0x20 166C 01 ADD 166D 80 DUP1 166E 61 PUSH2 0x2b99 1671 60 PUSH1 0x28 1673 91 SWAP2 1674 39 CODECOPY 1675 60 PUSH1 0x40 1677 01 ADD 1678 91 SWAP2 1679 50 POP 167A 50 POP 167B 60 PUSH1 0x40 167D 51 MLOAD 167E 80 DUP1 167F 91 SWAP2 1680 03 SUB 1681 90 SWAP1 1682 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1658 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1665 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1669 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x28 // @1674 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x28] = code[0x2b99:0x2bc1] // @1682 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1683: // Incoming jump from 0x1632, if stack[-1] // Incoming jump from 0x1632, if stack[-11] > 0x00 // Inputs[2] // { // @1687 address(this) // @1688 stack[-3] // } 1683 5B JUMPDEST 1684 61 PUSH2 0x168d 1687 30 ADDRESS 1688 84 DUP5 1689 61 PUSH2 0x2992 168C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1684 stack[0] = 0x168d // @1687 stack[1] = address(this) // @1688 stack[2] = stack[-3] // } // Block ends with call to 0x2992, returns to 0x168D label_168D: // Incoming return from call to 0x2992 at 0x168C // Inputs[3] // { // @1691 stack[-7] // @1692 stack[-12] // @1693 stack[-11] // } 168D 5B JUMPDEST 168E 61 PUSH2 0x1698 1691 87 DUP8 1692 8D DUP14 1693 8D DUP14 1694 61 PUSH2 0x1fdb 1697 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @168E stack[0] = 0x1698 // @1691 stack[1] = stack[-7] // @1692 stack[2] = stack[-12] // @1693 stack[3] = stack[-11] // } // Block ends with call to 0x1fdb, returns to 0x1698 label_1698: // Incoming return from call to 0x1FDB at 0x1697 // Inputs[3] // { // @169C stack[-6] // @169D stack[-12] // @169E stack[-10] // } 1698 5B JUMPDEST 1699 61 PUSH2 0x16a3 169C 86 DUP7 169D 8D DUP14 169E 8C DUP13 169F 61 PUSH2 0x1fdb 16A2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1699 stack[0] = 0x16a3 // @169C stack[1] = stack[-6] // @169D stack[2] = stack[-12] // @169E stack[3] = stack[-10] // } // Block ends with call to 0x1fdb, returns to 0x16A3 label_16A3: // Incoming return from call to 0x1FDB at 0x16A2 // Inputs[5] // { // @16A7 memory[0x40:0x60] // @16CB address(this) // @16D2 memory[0x40:0x60] // @16E8 stack[-7] // @1703 address(stack[-7] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 16A3 5B JUMPDEST 16A4 60 PUSH1 0x40 16A6 80 DUP1 16A7 51 MLOAD 16A8 7F PUSH32 0x70a0823100000000000000000000000000000000000000000000000000000000 16C9 81 DUP2 16CA 52 MSTORE 16CB 30 ADDRESS 16CC 60 PUSH1 0x04 16CE 82 DUP3 16CF 01 ADD 16D0 52 MSTORE 16D1 90 SWAP1 16D2 51 MLOAD 16D3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16E8 89 DUP10 16E9 16 AND 16EA 91 SWAP2 16EB 63 PUSH4 0x70a08231 16F0 91 SWAP2 16F1 60 PUSH1 0x24 16F3 80 DUP1 16F4 83 DUP4 16F5 01 ADD 16F6 92 SWAP3 16F7 60 PUSH1 0x20 16F9 92 SWAP3 16FA 91 SWAP2 16FB 90 SWAP1 16FC 82 DUP3 16FD 90 SWAP1 16FE 03 SUB 16FF 01 ADD 1700 81 DUP2 1701 86 DUP7 1702 80 DUP1 1703 3B EXTCODESIZE 1704 15 ISZERO 1705 80 DUP1 1706 15 ISZERO 1707 61 PUSH2 0x170f 170A 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @16CA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000 // @16D0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @16EA stack[0] = stack[-7] & 0xffffffffffffffffffffffffffffffffffffffff // @16F0 stack[1] = 0x70a08231 // @16F6 stack[2] = memory[0x40:0x60] + 0x24 // @16F9 stack[3] = 0x20 // @16FA stack[4] = memory[0x40:0x60] // @16FF stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @1700 stack[6] = memory[0x40:0x60] // @1701 stack[7] = stack[-7] & 0xffffffffffffffffffffffffffffffffffffffff // @1704 stack[8] = !address(stack[-7] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x170f, if !!address(stack[-7] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_170B: // Incoming jump from 0x170A, if not !!address(stack[-7] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @170E memory[0x00:0x00] } 170B 60 PUSH1 0x00 170D 80 DUP1 170E FD *REVERT // Stack delta = +0 // Outputs[1] { @170E revert(memory[0x00:0x00]); } // Block terminates label_170F: // Incoming jump from 0x170A, if !!address(stack[-7] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[8] // { // @1711 msg.gas // @1712 stack[-4] // @1712 stack[-5] // @1712 stack[-6] // @1712 memory[stack[-3]:stack[-3] + stack[-4]] // @1712 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1712 stack[-2] // @1712 stack[-3] // } 170F 5B JUMPDEST 1710 50 POP 1711 5A GAS 1712 FA STATICCALL 1713 15 ISZERO 1714 80 DUP1 1715 15 ISZERO 1716 61 PUSH2 0x1723 1719 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1712 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1713 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1723, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_171A: // Incoming jump from 0x1719, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @171A returndata.length // @171E returndata[0x00:0x00 + returndata.length] // @171F returndata.length // @1722 memory[0x00:0x00 + returndata.length] // } 171A 3D RETURNDATASIZE 171B 60 PUSH1 0x00 171D 80 DUP1 171E 3E RETURNDATACOPY 171F 3D RETURNDATASIZE 1720 60 PUSH1 0x00 1722 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @171E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1722 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1723: // Incoming jump from 0x1719, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @172A memory[0x40:0x60] // @172B returndata.length // } 1723 5B JUMPDEST 1724 50 POP 1725 50 POP 1726 50 POP 1727 50 POP 1728 60 PUSH1 0x40 172A 51 MLOAD 172B 3D RETURNDATASIZE 172C 60 PUSH1 0x20 172E 81 DUP2 172F 10 LT 1730 15 ISZERO 1731 61 PUSH2 0x1739 1734 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @172A stack[-4] = memory[0x40:0x60] // @172B stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1739, if !(returndata.length < 0x20) label_1735: // Incoming jump from 0x1734, if not !(returndata.length < 0x20) // Inputs[1] { @1738 memory[0x00:0x00] } 1735 60 PUSH1 0x00 1737 80 DUP1 1738 FD *REVERT // Stack delta = +0 // Outputs[1] { @1738 revert(memory[0x00:0x00]); } // Block terminates label_1739: // Incoming jump from 0x1734, if !(returndata.length < 0x20) // Inputs[8] // { // @173B memory[stack[-2]:stack[-2] + 0x20] // @173B stack[-2] // @173F memory[0x40:0x60] // @1763 address(this) // @176A memory[0x40:0x60] // @176C stack[-7] // @1783 stack[-8] // @179F address(stack[-8] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 1739 5B JUMPDEST 173A 50 POP 173B 51 MLOAD 173C 60 PUSH1 0x40 173E 80 DUP1 173F 51 MLOAD 1740 7F PUSH32 0x70a0823100000000000000000000000000000000000000000000000000000000 1761 81 DUP2 1762 52 MSTORE 1763 30 ADDRESS 1764 60 PUSH1 0x04 1766 82 DUP3 1767 01 ADD 1768 52 MSTORE 1769 90 SWAP1 176A 51 MLOAD 176B 91 SWAP2 176C 96 SWAP7 176D 50 POP 176E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1783 88 DUP9 1784 16 AND 1785 91 SWAP2 1786 63 PUSH4 0x70a08231 178B 91 SWAP2 178C 60 PUSH1 0x24 178E 80 DUP1 178F 82 DUP3 1790 01 ADD 1791 92 SWAP3 1792 60 PUSH1 0x20 1794 92 SWAP3 1795 90 SWAP1 1796 91 SWAP2 1797 90 SWAP1 1798 82 DUP3 1799 90 SWAP1 179A 03 SUB 179B 01 ADD 179C 81 DUP2 179D 86 DUP7 179E 80 DUP1 179F 3B EXTCODESIZE 17A0 15 ISZERO 17A1 80 DUP1 17A2 15 ISZERO 17A3 61 PUSH2 0x17ab 17A6 57 *JUMPI // Stack delta = +7 // Outputs[12] // { // @1762 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000 // @1768 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @176C stack[-7] = memory[stack[-2]:stack[-2] + 0x20] // @1785 stack[-2] = stack[-8] & 0xffffffffffffffffffffffffffffffffffffffff // @178B stack[-1] = 0x70a08231 // @1791 stack[0] = memory[0x40:0x60] + 0x24 // @1794 stack[1] = 0x20 // @1796 stack[2] = memory[0x40:0x60] // @179B stack[3] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @179C stack[4] = memory[0x40:0x60] // @179D stack[5] = stack[-8] & 0xffffffffffffffffffffffffffffffffffffffff // @17A0 stack[6] = !address(stack[-8] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x17ab, if !!address(stack[-8] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_17A7: // Incoming jump from 0x17A6, if not !!address(stack[-8] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @17AA memory[0x00:0x00] } 17A7 60 PUSH1 0x00 17A9 80 DUP1 17AA FD *REVERT // Stack delta = +0 // Outputs[1] { @17AA revert(memory[0x00:0x00]); } // Block terminates label_17AB: // Incoming jump from 0x17A6, if !!address(stack[-8] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[8] // { // @17AD msg.gas // @17AE address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @17AE stack[-6] // @17AE stack[-3] // @17AE memory[stack[-3]:stack[-3] + stack[-4]] // @17AE stack[-2] // @17AE stack[-4] // @17AE stack[-5] // } 17AB 5B JUMPDEST 17AC 50 POP 17AD 5A GAS 17AE FA STATICCALL 17AF 15 ISZERO 17B0 80 DUP1 17B1 15 ISZERO 17B2 61 PUSH2 0x17bf 17B5 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @17AE memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @17AF stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x17bf, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_17B6: // Incoming jump from 0x17B5, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @17B6 returndata.length // @17BA returndata[0x00:0x00 + returndata.length] // @17BB returndata.length // @17BE memory[0x00:0x00 + returndata.length] // } 17B6 3D RETURNDATASIZE 17B7 60 PUSH1 0x00 17B9 80 DUP1 17BA 3E RETURNDATACOPY 17BB 3D RETURNDATASIZE 17BC 60 PUSH1 0x00 17BE FD *REVERT // Stack delta = +0 // Outputs[2] // { // @17BA memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @17BE revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_17BF: // Incoming jump from 0x17B5, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @17C6 memory[0x40:0x60] // @17C7 returndata.length // } 17BF 5B JUMPDEST 17C0 50 POP 17C1 50 POP 17C2 50 POP 17C3 50 POP 17C4 60 PUSH1 0x40 17C6 51 MLOAD 17C7 3D RETURNDATASIZE 17C8 60 PUSH1 0x20 17CA 81 DUP2 17CB 10 LT 17CC 15 ISZERO 17CD 61 PUSH2 0x17d5 17D0 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @17C6 stack[-4] = memory[0x40:0x60] // @17C7 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x17d5, if !(returndata.length < 0x20) label_17D1: // Incoming jump from 0x17D0, if not !(returndata.length < 0x20) // Inputs[1] { @17D4 memory[0x00:0x00] } 17D1 60 PUSH1 0x00 17D3 80 DUP1 17D4 FD *REVERT // Stack delta = +0 // Outputs[1] { @17D4 revert(memory[0x00:0x00]); } // Block terminates label_17D5: // Incoming jump from 0x17D0, if !(returndata.length < 0x20) // Inputs[6] // { // @17D7 stack[-2] // @17D7 memory[stack[-2]:stack[-2] + 0x20] // @17D8 stack[-6] // @17DD stack[-7] // @17DF stack[-11] // @17E0 stack[-10] // } 17D5 5B JUMPDEST 17D6 50 POP 17D7 51 MLOAD 17D8 93 SWAP4 17D9 50 POP 17DA 61 PUSH2 0x17e5 17DD 85 DUP6 17DE 85 DUP6 17DF 8B DUP12 17E0 8B DUP12 17E1 61 PUSH2 0x22e0 17E4 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @17D8 stack[-6] = memory[stack[-2]:stack[-2] + 0x20] // @17DA stack[-2] = 0x17e5 // @17DD stack[-1] = stack[-7] // @17DE stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @17DF stack[1] = stack[-11] // @17E0 stack[2] = stack[-10] // } // Block ends with call to 0x22e0, returns to 0x17E5 label_17E5: // Incoming return from call to 0x22E0 at 0x17E4 // Inputs[1] { @17E6 stack[-2] } 17E5 5B JUMPDEST 17E6 81 DUP2 17E7 15 ISZERO 17E8 61 PUSH2 0x1827 17EB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1827, if !stack[-2] label_17EC: // Incoming jump from 0x17EB, if not !stack[-2] // Inputs[1] { @17EE storage[0x08] } 17EC 60 PUSH1 0x08 17EE 54 SLOAD 17EF 61 PUSH2 0x1823 17F2 90 SWAP1 17F3 6D PUSH14 0xffffffffffffffffffffffffffff 1802 80 DUP1 1803 82 DUP3 1804 16 AND 1805 91 SWAP2 1806 6E PUSH15 0x010000000000000000000000000000 1816 90 SWAP1 1817 04 DIV 1818 16 AND 1819 63 PUSH4 0xffffffff 181E 61 PUSH2 0x21e8 1821 16 AND 1822 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @17F2 stack[0] = 0x1823 // @1805 stack[1] = storage[0x08] & 0xffffffffffffffffffffffffffff // @1818 stack[2] = storage[0x08] / 0x010000000000000000000000000000 & 0xffffffffffffffffffffffffffff // } // Block ends with call to 0x21e8 & 0xffffffff, returns to 0x1823 label_1823: // Incoming return from call to 0x21E8 at 0x1822 // Inputs[1] { @1826 stack[-1] } 1823 5B JUMPDEST 1824 60 PUSH1 0x0b 1826 55 SSTORE // Stack delta = -1 // Outputs[1] { @1826 storage[0x0b] = stack[-1] } // Block continues label_1827: // Incoming jump from 0x17EB, if !stack[-2] // Incoming jump from 0x1826 // Inputs[8] // { // @182B memory[0x40:0x60] // @182C stack[-11] // @1833 stack[-10] // @1837 memory[0x40:0x60] // @184D stack[-12] // @1850 msg.sender // @187C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x40 + (memory[0x40:0x60] - memory[0x40:0x60])] // @1890 stack[-13] // } 1827 5B JUMPDEST 1828 60 PUSH1 0x40 182A 80 DUP1 182B 51 MLOAD 182C 8C DUP13 182D 81 DUP2 182E 52 MSTORE 182F 60 PUSH1 0x20 1831 81 DUP2 1832 01 ADD 1833 8C DUP13 1834 90 SWAP1 1835 52 MSTORE 1836 81 DUP2 1837 51 MLOAD 1838 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 184D 8F DUP16 184E 16 AND 184F 92 SWAP3 1850 33 CALLER 1851 92 SWAP3 1852 7F PUSH32 0xdccd412f0b1252819cb1fd330b93224ca42612892bb3f4f789976e6d81936496 1873 92 SWAP3 1874 90 SWAP1 1875 81 DUP2 1876 90 SWAP1 1877 03 SUB 1878 90 SWAP1 1879 91 SWAP2 187A 01 ADD 187B 90 SWAP1 187C A3 LOG3 187D 50 POP 187E 50 POP 187F 50 POP 1880 50 POP 1881 50 POP 1882 50 POP 1883 50 POP 1884 50 POP 1885 50 POP 1886 60 PUSH1 0x01 1888 60 PUSH1 0x0c 188A 81 DUP2 188B 90 SWAP1 188C 55 SSTORE 188D 50 POP 188E 91 SWAP2 188F 50 POP 1890 91 SWAP2 1891 56 *JUMP // Stack delta = -11 // Outputs[6] // { // @182E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-11] // @1835 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-10] // @187C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x40 + (memory[0x40:0x60] - memory[0x40:0x60])], [0xdccd412f0b1252819cb1fd330b93224ca42612892bb3f4f789976e6d81936496, msg.sender, stack[-12] & 0xffffffffffffffffffffffffffffffffffffffff]); // @188C storage[0x0c] = 0x01 // @188E stack[-12] = stack[-10] // @1890 stack[-13] = stack[-11] // } // Block ends with unconditional jump to stack[-13] label_1892: // Incoming call from 0x055D, returns to 0x0261 // Inputs[2] // { // @1895 memory[0x40:0x60] // @18C9 stack[-1] // } 1892 5B JUMPDEST 1893 60 PUSH1 0x40 1895 51 MLOAD 1896 80 DUP1 1897 60 PUSH1 0x40 1899 01 ADD 189A 60 PUSH1 0x40 189C 52 MSTORE 189D 80 DUP1 189E 60 PUSH1 0x06 18A0 81 DUP2 18A1 52 MSTORE 18A2 60 PUSH1 0x20 18A4 01 ADD 18A5 7F PUSH32 0x554e492d56320000000000000000000000000000000000000000000000000000 18C6 81 DUP2 18C7 52 MSTORE 18C8 50 POP 18C9 81 DUP2 18CA 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1895 stack[0] = memory[0x40:0x60] // @189C memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @18A1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x06 // @18C7 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x554e492d56320000000000000000000000000000000000000000000000000000 // } // Block ends with unconditional jump to stack[-1] label_18CB: // Incoming jump from 0x0596 // Inputs[3] // { // @18D1 msg.sender // @18D2 stack[-2] // @18D3 stack[-1] // } 18CB 5B JUMPDEST 18CC 60 PUSH1 0x00 18CE 61 PUSH2 0x0df2 18D1 33 CALLER 18D2 84 DUP5 18D3 84 DUP5 18D4 61 PUSH2 0x260b 18D7 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @18CC stack[0] = 0x00 // @18CE stack[1] = 0x0df2 // @18D1 stack[2] = msg.sender // @18D2 stack[3] = stack[-2] // @18D3 stack[4] = stack[-1] // } // Block ends with call to 0x260b, returns to 0x0DF2 label_18D8: // Incoming call from 0x059E, returns to 0x039B // Inputs[1] { @18DC stack[-1] } 18D8 5B JUMPDEST 18D9 61 PUSH2 0x03e8 18DC 81 DUP2 18DD 56 *JUMP // Stack delta = +1 // Outputs[1] { @18D9 stack[0] = 0x03e8 } // Block ends with unconditional jump to stack[-1] label_18DE: // Incoming jump from 0x05D1 // Inputs[1] { @18E1 storage[0x0c] } 18DE 5B JUMPDEST 18DF 60 PUSH1 0x0c 18E1 54 SLOAD 18E2 60 PUSH1 0x01 18E4 14 EQ 18E5 61 PUSH2 0x194f 18E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x194f, if 0x01 == storage[0x0c] label_18E9: // Incoming jump from 0x18E8, if not 0x01 == storage[0x0c] // Inputs[3] // { // @18EC memory[0x40:0x60] // @1945 memory[0x40:0x60] // @194E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 18E9 60 PUSH1 0x40 18EB 80 DUP1 18EC 51 MLOAD 18ED 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 190E 81 DUP2 190F 52 MSTORE 1910 60 PUSH1 0x20 1912 60 PUSH1 0x04 1914 82 DUP3 1915 01 ADD 1916 52 MSTORE 1917 60 PUSH1 0x11 1919 60 PUSH1 0x24 191B 82 DUP3 191C 01 ADD 191D 52 MSTORE 191E 7F PUSH32 0x556e697377617056323a204c4f434b4544000000000000000000000000000000 193F 60 PUSH1 0x44 1941 82 DUP3 1942 01 ADD 1943 52 MSTORE 1944 90 SWAP1 1945 51 MLOAD 1946 90 SWAP1 1947 81 DUP2 1948 90 SWAP1 1949 03 SUB 194A 60 PUSH1 0x64 194C 01 ADD 194D 90 SWAP1 194E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @190F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1916 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @191D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x11 // @1943 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x556e697377617056323a204c4f434b4544000000000000000000000000000000 // @194E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_194F: // Incoming jump from 0x18E8, if 0x01 == storage[0x0c] // Inputs[8] // { // @1957 storage[0x06] // @195A storage[0x07] // @195D storage[0x08] // @1961 memory[0x40:0x60] // @1985 address(this) // @198C memory[0x40:0x60] // @19B0 stack[-1] // @19E2 address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x06]).code.length // } 194F 5B JUMPDEST 1950 60 PUSH1 0x00 1952 60 PUSH1 0x0c 1954 55 SSTORE 1955 60 PUSH1 0x06 1957 54 SLOAD 1958 60 PUSH1 0x07 195A 54 SLOAD 195B 60 PUSH1 0x08 195D 54 SLOAD 195E 60 PUSH1 0x40 1960 80 DUP1 1961 51 MLOAD 1962 7F PUSH32 0x70a0823100000000000000000000000000000000000000000000000000000000 1983 81 DUP2 1984 52 MSTORE 1985 30 ADDRESS 1986 60 PUSH1 0x04 1988 82 DUP3 1989 01 ADD 198A 52 MSTORE 198B 90 SWAP1 198C 51 MLOAD 198D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19A2 94 SWAP5 19A3 85 DUP6 19A4 16 AND 19A5 94 SWAP5 19A6 90 SWAP1 19A7 93 SWAP4 19A8 16 AND 19A9 92 SWAP3 19AA 61 PUSH2 0x1a2b 19AD 92 SWAP3 19AE 85 DUP6 19AF 92 SWAP3 19B0 87 DUP8 19B1 92 SWAP3 19B2 61 PUSH2 0x1a26 19B5 92 SWAP3 19B6 6D PUSH14 0xffffffffffffffffffffffffffff 19C5 16 AND 19C6 91 SWAP2 19C7 85 DUP6 19C8 91 SWAP2 19C9 63 PUSH4 0x70a08231 19CE 91 SWAP2 19CF 60 PUSH1 0x24 19D1 80 DUP1 19D2 82 DUP3 19D3 01 ADD 19D4 92 SWAP3 19D5 60 PUSH1 0x20 19D7 92 SWAP3 19D8 90 SWAP1 19D9 91 SWAP2 19DA 90 SWAP1 19DB 82 DUP3 19DC 90 SWAP1 19DD 03 SUB 19DE 01 ADD 19DF 81 DUP2 19E0 86 DUP7 19E1 80 DUP1 19E2 3B EXTCODESIZE 19E3 15 ISZERO 19E4 80 DUP1 19E5 15 ISZERO 19E6 61 PUSH2 0x19ee 19E9 57 *JUMPI // Stack delta = +16 // Outputs[19] // { // @1954 storage[0x0c] = 0x00 // @1984 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000 // @198A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @19A5 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] // @19A9 stack[1] = storage[0x07] & 0xffffffffffffffffffffffffffffffffffffffff // @19AD stack[2] = 0x1a2b // @19AF stack[3] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] // @19B1 stack[4] = stack[-1] // @19B5 stack[5] = 0x1a26 // @19C6 stack[6] = 0xffffffffffffffffffffffffffff & storage[0x08] // @19C8 stack[7] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] // @19CE stack[8] = 0x70a08231 // @19D4 stack[9] = memory[0x40:0x60] + 0x24 // @19D7 stack[10] = 0x20 // @19D9 stack[11] = memory[0x40:0x60] // @19DE stack[12] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @19DF stack[13] = memory[0x40:0x60] // @19E0 stack[14] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] // @19E3 stack[15] = !address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x06]).code.length // } // Block ends with conditional call to 0x19ee, returns to 0x1A26, if !!address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x06]).code.length label_19EA: // Incoming jump from 0x19E9, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x06]).code.length // Inputs[1] { @19ED memory[0x00:0x00] } 19EA 60 PUSH1 0x00 19EC 80 DUP1 19ED FD *REVERT // Stack delta = +0 // Outputs[1] { @19ED revert(memory[0x00:0x00]); } // Block terminates label_19EE: // Incoming call from 0x19E9, returns to 0x1A26, if !!address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x06]).code.length // Incoming call from 0x1AC5, returns to 0x1A26, if !!address(stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[8] // { // @19F0 msg.gas // @19F1 stack[-5] // @19F1 memory[stack[-3]:stack[-3] + stack[-4]] // @19F1 stack[-3] // @19F1 stack[-6] // @19F1 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @19F1 stack[-2] // @19F1 stack[-4] // } 19EE 5B JUMPDEST 19EF 50 POP 19F0 5A GAS 19F1 FA STATICCALL 19F2 15 ISZERO 19F3 80 DUP1 19F4 15 ISZERO 19F5 61 PUSH2 0x1a02 19F8 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @19F1 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @19F2 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1a02, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_19F9: // Incoming jump from 0x19F8, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @19F9 returndata.length // @19FD returndata[0x00:0x00 + returndata.length] // @19FE returndata.length // @1A01 memory[0x00:0x00 + returndata.length] // } 19F9 3D RETURNDATASIZE 19FA 60 PUSH1 0x00 19FC 80 DUP1 19FD 3E RETURNDATACOPY 19FE 3D RETURNDATASIZE 19FF 60 PUSH1 0x00 1A01 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @19FD memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1A01 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1A02: // Incoming jump from 0x19F8, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1A09 memory[0x40:0x60] // @1A0A returndata.length // } 1A02 5B JUMPDEST 1A03 50 POP 1A04 50 POP 1A05 50 POP 1A06 50 POP 1A07 60 PUSH1 0x40 1A09 51 MLOAD 1A0A 3D RETURNDATASIZE 1A0B 60 PUSH1 0x20 1A0D 81 DUP2 1A0E 10 LT 1A0F 15 ISZERO 1A10 61 PUSH2 0x1a18 1A13 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1A09 stack[-4] = memory[0x40:0x60] // @1A0A stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1a18, if !(returndata.length < 0x20) label_1A14: // Incoming jump from 0x1A13, if not !(returndata.length < 0x20) // Inputs[1] { @1A17 memory[0x00:0x00] } 1A14 60 PUSH1 0x00 1A16 80 DUP1 1A17 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A17 revert(memory[0x00:0x00]); } // Block terminates label_1A18: // Incoming jump from 0x1A13, if !(returndata.length < 0x20) // Inputs[3] // { // @1A1A memory[stack[-2]:stack[-2] + 0x20] // @1A1A stack[-2] // @1A1B stack[-3] // } 1A18 5B JUMPDEST 1A19 50 POP 1A1A 51 MLOAD 1A1B 90 SWAP1 1A1C 63 PUSH4 0xffffffff 1A21 61 PUSH2 0x226e 1A24 16 AND 1A25 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1A1B stack[-2] = stack[-3] // @1A1B stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x226e & 0xffffffff label_1A26: // Incoming return from call to 0x19EE at 0x19E9 // Incoming return from call to 0x19EE at 0x1AC5 1A26 5B JUMPDEST 1A27 61 PUSH2 0x1fdb 1A2A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1fdb label_1A2B: // Incoming return from call to 0x1A26 at 0x19E9 // Inputs[7] // { // @1A2E storage[0x08] // @1A32 memory[0x40:0x60] // @1A56 address(this) // @1A5D memory[0x40:0x60] // @1A62 stack[-1] // @1A64 stack[-3] // @1ABE address(stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 1A2B 5B JUMPDEST 1A2C 60 PUSH1 0x08 1A2E 54 SLOAD 1A2F 60 PUSH1 0x40 1A31 80 DUP1 1A32 51 MLOAD 1A33 7F PUSH32 0x70a0823100000000000000000000000000000000000000000000000000000000 1A54 81 DUP2 1A55 52 MSTORE 1A56 30 ADDRESS 1A57 60 PUSH1 0x04 1A59 82 DUP3 1A5A 01 ADD 1A5B 52 MSTORE 1A5C 90 SWAP1 1A5D 51 MLOAD 1A5E 61 PUSH2 0x1aca 1A61 92 SWAP3 1A62 84 DUP5 1A63 92 SWAP3 1A64 87 DUP8 1A65 92 SWAP3 1A66 61 PUSH2 0x1a26 1A69 92 SWAP3 1A6A 6E PUSH15 0x010000000000000000000000000000 1A7A 90 SWAP1 1A7B 04 DIV 1A7C 6D PUSH14 0xffffffffffffffffffffffffffff 1A8B 16 AND 1A8C 91 SWAP2 1A8D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AA2 86 DUP7 1AA3 16 AND 1AA4 91 SWAP2 1AA5 63 PUSH4 0x70a08231 1AAA 91 SWAP2 1AAB 60 PUSH1 0x24 1AAD 80 DUP1 1AAE 82 DUP3 1AAF 01 ADD 1AB0 92 SWAP3 1AB1 60 PUSH1 0x20 1AB3 92 SWAP3 1AB4 90 SWAP1 1AB5 91 SWAP2 1AB6 90 SWAP1 1AB7 82 DUP3 1AB8 90 SWAP1 1AB9 03 SUB 1ABA 01 ADD 1ABB 81 DUP2 1ABC 86 DUP7 1ABD 80 DUP1 1ABE 3B EXTCODESIZE 1ABF 15 ISZERO 1AC0 80 DUP1 1AC1 15 ISZERO 1AC2 61 PUSH2 0x19ee 1AC5 57 *JUMPI // Stack delta = +14 // Outputs[16] // { // @1A55 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000 // @1A5B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @1A61 stack[0] = 0x1aca // @1A63 stack[1] = stack[-1] // @1A65 stack[2] = stack[-3] // @1A69 stack[3] = 0x1a26 // @1A8C stack[4] = 0xffffffffffffffffffffffffffff & storage[0x08] / 0x010000000000000000000000000000 // @1AA4 stack[5] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // @1AAA stack[6] = 0x70a08231 // @1AB0 stack[7] = memory[0x40:0x60] + 0x24 // @1AB3 stack[8] = 0x20 // @1AB5 stack[9] = memory[0x40:0x60] // @1ABA stack[10] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @1ABB stack[11] = memory[0x40:0x60] // @1ABC stack[12] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // @1ABF stack[13] = !address(stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional call to 0x19ee, returns to 0x1A26, if !!address(stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_1AC6: // Incoming jump from 0x1AC5, if not !!address(stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @1AC9 memory[0x00:0x00] } 1AC6 60 PUSH1 0x00 1AC8 80 DUP1 1AC9 FD *REVERT // Stack delta = +0 // Outputs[1] { @1AC9 revert(memory[0x00:0x00]); } // Block terminates label_1ACA: // Incoming return from call to 0x1A26 at 0x1AC5 // Inputs[1] { @1AD3 stack[-4] } 1ACA 5B JUMPDEST 1ACB 50 POP 1ACC 50 POP 1ACD 60 PUSH1 0x01 1ACF 60 PUSH1 0x0c 1AD1 55 SSTORE 1AD2 50 POP 1AD3 56 *JUMP // Stack delta = -4 // Outputs[1] { @1AD1 storage[0x0c] = 0x01 } // Block ends with unconditional jump to stack[-4] label_1AD4: // Incoming call from 0x05D9, returns to 0x036A // Inputs[2] // { // @1AD7 storage[0x05] // @1AEE stack[-1] // } 1AD4 5B JUMPDEST 1AD5 60 PUSH1 0x05 1AD7 54 SLOAD 1AD8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AED 16 AND 1AEE 81 DUP2 1AEF 56 *JUMP // Stack delta = +1 // Outputs[1] { @1AED stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] } // Block ends with unconditional jump to stack[-1] label_1AF0: // Incoming call from 0x05E1, returns to 0x036A // Inputs[2] // { // @1AF3 storage[0x07] // @1B0A stack[-1] // } 1AF0 5B JUMPDEST 1AF1 60 PUSH1 0x07 1AF3 54 SLOAD 1AF4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B09 16 AND 1B0A 81 DUP2 1B0B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1B09 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x07] } // Block ends with unconditional jump to stack[-1] label_1B0C: // Incoming jump from 0x063F // Inputs[2] // { // @1B0D block.timestamp // @1B0E stack[-4] // } 1B0C 5B JUMPDEST 1B0D 42 TIMESTAMP 1B0E 84 DUP5 1B0F 10 LT 1B10 15 ISZERO 1B11 61 PUSH2 0x1b7b 1B14 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b7b, if !(stack[-4] < block.timestamp) label_1B15: // Incoming jump from 0x1B14, if not !(stack[-4] < block.timestamp) // Inputs[3] // { // @1B18 memory[0x40:0x60] // @1B71 memory[0x40:0x60] // @1B7A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1B15 60 PUSH1 0x40 1B17 80 DUP1 1B18 51 MLOAD 1B19 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1B3A 81 DUP2 1B3B 52 MSTORE 1B3C 60 PUSH1 0x20 1B3E 60 PUSH1 0x04 1B40 82 DUP3 1B41 01 ADD 1B42 52 MSTORE 1B43 60 PUSH1 0x12 1B45 60 PUSH1 0x24 1B47 82 DUP3 1B48 01 ADD 1B49 52 MSTORE 1B4A 7F PUSH32 0x556e697377617056323a20455850495245440000000000000000000000000000 1B6B 60 PUSH1 0x44 1B6D 82 DUP3 1B6E 01 ADD 1B6F 52 MSTORE 1B70 90 SWAP1 1B71 51 MLOAD 1B72 90 SWAP1 1B73 81 DUP2 1B74 90 SWAP1 1B75 03 SUB 1B76 60 PUSH1 0x64 1B78 01 ADD 1B79 90 SWAP1 1B7A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1B3B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1B42 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1B49 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x12 // @1B6F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x556e697377617056323a20455850495245440000000000000000000000000000 // @1B7A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1B7B: // Incoming jump from 0x1B14, if !(stack[-4] < block.timestamp) // Inputs[21] // { // @1B7E storage[0x03] // @1B95 stack[-7] // @1BA7 memory[0x00:0x40] // @1BA9 storage[keccak256(memory[0x00:0x40])] // @1BB3 memory[0x40:0x60] // @1BE1 stack[-6] // @1BEC stack[-5] // @1BFC stack[-4] // @1C00 memory[0x40:0x60] // @1C10 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1C14 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @1C50 memory[0x40:0x60] // @1C62 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1C69 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @1C7B stack[-3] // @1C88 stack[-2] // @1C90 stack[-1] // @1C93 memory[0x40:0x60] // @1CCA msg.gas // @1CCB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x01e2 + (memory[0x40:0x60] - memory[0x40:0x60])] // @1CCB address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x01e2 + (memory[0x40:0x60] - memory[0x40:0x60])]) // } 1B7B 5B JUMPDEST 1B7C 60 PUSH1 0x03 1B7E 54 SLOAD 1B7F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B94 80 DUP1 1B95 89 DUP10 1B96 16 AND 1B97 60 PUSH1 0x00 1B99 81 DUP2 1B9A 81 DUP2 1B9B 52 MSTORE 1B9C 60 PUSH1 0x04 1B9E 60 PUSH1 0x20 1BA0 90 SWAP1 1BA1 81 DUP2 1BA2 52 MSTORE 1BA3 60 PUSH1 0x40 1BA5 80 DUP1 1BA6 83 DUP4 1BA7 20 SHA3 1BA8 80 DUP1 1BA9 54 SLOAD 1BAA 60 PUSH1 0x01 1BAC 80 DUP1 1BAD 82 DUP3 1BAE 01 ADD 1BAF 90 SWAP1 1BB0 92 SWAP3 1BB1 55 SSTORE 1BB2 82 DUP3 1BB3 51 MLOAD 1BB4 7F PUSH32 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9 1BD5 81 DUP2 1BD6 86 DUP7 1BD7 01 ADD 1BD8 52 MSTORE 1BD9 80 DUP1 1BDA 84 DUP5 1BDB 01 ADD 1BDC 96 SWAP7 1BDD 90 SWAP1 1BDE 96 SWAP7 1BDF 52 MSTORE 1BE0 95 SWAP6 1BE1 8D DUP14 1BE2 16 AND 1BE3 60 PUSH1 0x60 1BE5 86 DUP7 1BE6 01 ADD 1BE7 52 MSTORE 1BE8 60 PUSH1 0x80 1BEA 85 DUP6 1BEB 01 ADD 1BEC 8C DUP13 1BED 90 SWAP1 1BEE 52 MSTORE 1BEF 60 PUSH1 0xa0 1BF1 85 DUP6 1BF2 01 ADD 1BF3 95 SWAP6 1BF4 90 SWAP1 1BF5 95 SWAP6 1BF6 52 MSTORE 1BF7 60 PUSH1 0xc0 1BF9 80 DUP1 1BFA 85 DUP6 1BFB 01 ADD 1BFC 8B DUP12 1BFD 90 SWAP1 1BFE 52 MSTORE 1BFF 81 DUP2 1C00 51 MLOAD 1C01 80 DUP1 1C02 86 DUP7 1C03 03 SUB 1C04 90 SWAP1 1C05 91 SWAP2 1C06 01 ADD 1C07 81 DUP2 1C08 52 MSTORE 1C09 60 PUSH1 0xe0 1C0B 85 DUP6 1C0C 01 ADD 1C0D 82 DUP3 1C0E 52 MSTORE 1C0F 80 DUP1 1C10 51 MLOAD 1C11 90 SWAP1 1C12 83 DUP4 1C13 01 ADD 1C14 20 SHA3 1C15 7F PUSH32 0x1901000000000000000000000000000000000000000000000000000000000000 1C36 61 PUSH2 0x0100 1C39 86 DUP7 1C3A 01 ADD 1C3B 52 MSTORE 1C3C 61 PUSH2 0x0102 1C3F 85 DUP6 1C40 01 ADD 1C41 96 SWAP7 1C42 90 SWAP1 1C43 96 SWAP7 1C44 52 MSTORE 1C45 61 PUSH2 0x0122 1C48 80 DUP1 1C49 85 DUP6 1C4A 01 ADD 1C4B 96 SWAP7 1C4C 90 SWAP1 1C4D 96 SWAP7 1C4E 52 MSTORE 1C4F 80 DUP1 1C50 51 MLOAD 1C51 80 DUP1 1C52 85 DUP6 1C53 03 SUB 1C54 90 SWAP1 1C55 96 SWAP7 1C56 01 ADD 1C57 86 DUP7 1C58 52 MSTORE 1C59 61 PUSH2 0x0142 1C5C 84 DUP5 1C5D 01 ADD 1C5E 80 DUP1 1C5F 82 DUP3 1C60 52 MSTORE 1C61 86 DUP7 1C62 51 MLOAD 1C63 96 SWAP7 1C64 83 DUP4 1C65 01 ADD 1C66 96 SWAP7 1C67 90 SWAP1 1C68 96 SWAP7 1C69 20 SHA3 1C6A 95 SWAP6 1C6B 83 DUP4 1C6C 90 SWAP1 1C6D 52 MSTORE 1C6E 61 PUSH2 0x0162 1C71 84 DUP5 1C72 01 ADD 1C73 80 DUP1 1C74 82 DUP3 1C75 52 MSTORE 1C76 86 DUP7 1C77 90 SWAP1 1C78 52 MSTORE 1C79 60 PUSH1 0xff 1C7B 89 DUP10 1C7C 16 AND 1C7D 61 PUSH2 0x0182 1C80 85 DUP6 1C81 01 ADD 1C82 52 MSTORE 1C83 61 PUSH2 0x01a2 1C86 84 DUP5 1C87 01 ADD 1C88 88 DUP9 1C89 90 SWAP1 1C8A 52 MSTORE 1C8B 61 PUSH2 0x01c2 1C8E 84 DUP5 1C8F 01 ADD 1C90 87 DUP8 1C91 90 SWAP1 1C92 52 MSTORE 1C93 51 MLOAD 1C94 91 SWAP2 1C95 93 SWAP4 1C96 92 SWAP3 1C97 61 PUSH2 0x01e2 1C9A 80 DUP1 1C9B 82 DUP3 1C9C 01 ADD 1C9D 93 SWAP4 1C9E 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 1CBF 81 DUP2 1CC0 01 ADD 1CC1 92 SWAP3 1CC2 81 DUP2 1CC3 90 SWAP1 1CC4 03 SUB 1CC5 90 SWAP1 1CC6 91 SWAP2 1CC7 01 ADD 1CC8 90 SWAP1 1CC9 85 DUP6 1CCA 5A GAS 1CCB FA STATICCALL 1CCC 15 ISZERO 1CCD 80 DUP1 1CCE 15 ISZERO 1CCF 61 PUSH2 0x1cdc 1CD2 57 *JUMPI // Stack delta = +5 // Outputs[28] // { // @1B9B memory[0x00:0x20] = stack[-7] & 0xffffffffffffffffffffffffffffffffffffffff // @1BA2 memory[0x20:0x40] = 0x04 // @1BB1 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + 0x01 // @1BD8 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9 // @1BDF memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-7] & 0xffffffffffffffffffffffffffffffffffffffff // @1BE7 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff // @1BEE memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-5] // @1BF6 memory[memory[0x40:0x60] + 0xa0:memory[0x40:0x60] + 0xa0 + 0x20] = storage[keccak256(memory[0x00:0x40])] // @1BFE memory[memory[0x40:0x60] + 0xc0:memory[0x40:0x60] + 0xc0 + 0x20] = stack[-4] // @1C08 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xc0 + (memory[0x40:0x60] - memory[0x40:0x60]) // @1C0E memory[0x40:0x60] = memory[0x40:0x60] + 0xe0 // @1C3B memory[memory[0x40:0x60] + 0x0100:memory[0x40:0x60] + 0x0100 + 0x20] = 0x1901000000000000000000000000000000000000000000000000000000000000 // @1C44 memory[memory[0x40:0x60] + 0x0102:memory[0x40:0x60] + 0x0102 + 0x20] = storage[0x03] // @1C4E memory[memory[0x40:0x60] + 0x0122:memory[0x40:0x60] + 0x0122 + 0x20] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @1C58 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0122 + (memory[0x40:0x60] - memory[0x40:0x60]) // @1C60 memory[0x40:0x60] = memory[0x40:0x60] + 0x0142 // @1C6A stack[0] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @1C6D memory[memory[0x40:0x60] + 0x0142:memory[0x40:0x60] + 0x0142 + 0x20] = 0x00 // @1C75 memory[0x40:0x60] = memory[0x40:0x60] + 0x0162 // @1C78 memory[memory[0x40:0x60] + 0x0162:memory[0x40:0x60] + 0x0162 + 0x20] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @1C82 memory[memory[0x40:0x60] + 0x0182:memory[0x40:0x60] + 0x0182 + 0x20] = stack[-3] & 0xff // @1C8A memory[memory[0x40:0x60] + 0x01a2:memory[0x40:0x60] + 0x01a2 + 0x20] = stack[-2] // @1C92 memory[memory[0x40:0x60] + 0x01c2:memory[0x40:0x60] + 0x01c2 + 0x20] = stack[-1] // @1C95 stack[1] = 0x00 // @1C96 stack[2] = 0x01 // @1C9D stack[3] = memory[0x40:0x60] + 0x01e2 // @1CCB memory[memory[0x40:0x60] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0:memory[0x40:0x60] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 + 0x20] = address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x01e2 + (memory[0x40:0x60] - memory[0x40:0x60])]) // @1CCC stack[4] = !address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x01e2 + (memory[0x40:0x60] - memory[0x40:0x60])]) // } // Block ends with conditional jump to 0x1cdc, if !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x01e2 + (memory[0x40:0x60] - memory[0x40:0x60])]) label_1CD3: // Incoming jump from 0x1CD2, if not !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x01e2 + (memory[0x40:0x60] - memory[0x40:0x60])]) // Inputs[4] // { // @1CD3 returndata.length // @1CD7 returndata[0x00:0x00 + returndata.length] // @1CD8 returndata.length // @1CDB memory[0x00:0x00 + returndata.length] // } 1CD3 3D RETURNDATASIZE 1CD4 60 PUSH1 0x00 1CD6 80 DUP1 1CD7 3E RETURNDATACOPY 1CD8 3D RETURNDATASIZE 1CD9 60 PUSH1 0x00 1CDB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1CD7 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1CDB revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1CDC: // Incoming jump from 0x1CD2, if !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x01e2 + (memory[0x40:0x60] - memory[0x40:0x60])]) // Inputs[3] // { // @1CE1 memory[0x40:0x60] // @1D04 memory[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 + memory[0x40:0x60]:0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 + memory[0x40:0x60] + 0x20] // @1D05 stack[-4] // } 1CDC 5B JUMPDEST 1CDD 50 POP 1CDE 50 POP 1CDF 60 PUSH1 0x40 1CE1 51 MLOAD 1CE2 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 1D03 01 ADD 1D04 51 MLOAD 1D05 91 SWAP2 1D06 50 POP 1D07 50 POP 1D08 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D1D 81 DUP2 1D1E 16 AND 1D1F 15 ISZERO 1D20 80 DUP1 1D21 15 ISZERO 1D22 90 SWAP1 1D23 61 PUSH2 0x1d57 1D26 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1D05 stack[-4] = memory[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 + memory[0x40:0x60]:0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 + memory[0x40:0x60] + 0x20] // @1D22 stack[-3] = !!(memory[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 + memory[0x40:0x60]:0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 + memory[0x40:0x60] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff) // } // Block ends with conditional jump to 0x1d57, if !(memory[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 + memory[0x40:0x60]:0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 + memory[0x40:0x60] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff) label_1D27: // Incoming jump from 0x1D26, if not !(memory[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 + memory[0x40:0x60]:0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 + memory[0x40:0x60] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[2] // { // @1D28 stack[-10] // @1D3F stack[-2] // } 1D27 50 POP 1D28 88 DUP9 1D29 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D3E 16 AND 1D3F 81 DUP2 1D40 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D55 16 AND 1D56 14 EQ 1D57 5B JUMPDEST 1D58 61 PUSH2 0x1dc2 1D5B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1dc2, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-10] label_1D5C: // Incoming jump from 0x1D5B, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-10] // Incoming jump from 0x1D5B, if not stack[-1] // Inputs[3] // { // @1D5F memory[0x40:0x60] // @1DB8 memory[0x40:0x60] // @1DC1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1D5C 60 PUSH1 0x40 1D5E 80 DUP1 1D5F 51 MLOAD 1D60 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1D81 81 DUP2 1D82 52 MSTORE 1D83 60 PUSH1 0x20 1D85 60 PUSH1 0x04 1D87 82 DUP3 1D88 01 ADD 1D89 52 MSTORE 1D8A 60 PUSH1 0x1c 1D8C 60 PUSH1 0x24 1D8E 82 DUP3 1D8F 01 ADD 1D90 52 MSTORE 1D91 7F PUSH32 0x556e697377617056323a20494e56414c49445f5349474e415455524500000000 1DB2 60 PUSH1 0x44 1DB4 82 DUP3 1DB5 01 ADD 1DB6 52 MSTORE 1DB7 90 SWAP1 1DB8 51 MLOAD 1DB9 90 SWAP1 1DBA 81 DUP2 1DBB 90 SWAP1 1DBC 03 SUB 1DBD 60 PUSH1 0x64 1DBF 01 ADD 1DC0 90 SWAP1 1DC1 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1D82 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1D89 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1D90 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1c // @1DB6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x556e697377617056323a20494e56414c49445f5349474e415455524500000000 // @1DC1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1DC2: // Incoming jump from 0x1D5B, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-10] // Incoming jump from 0x1D5B, if stack[-1] // Inputs[3] // { // @1DC6 stack[-9] // @1DC7 stack[-8] // @1DC8 stack[-7] // } 1DC2 5B JUMPDEST 1DC3 61 PUSH2 0x1dcd 1DC6 89 DUP10 1DC7 89 DUP10 1DC8 89 DUP10 1DC9 61 PUSH2 0x259c 1DCC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DC3 stack[0] = 0x1dcd // @1DC6 stack[1] = stack[-9] // @1DC7 stack[2] = stack[-8] // @1DC8 stack[3] = stack[-7] // } // Block ends with call to 0x259c, returns to 0x1DCD label_1DCD: // Incoming return from call to 0x259C at 0x1DCC // Inputs[1] { @1DD7 stack[-10] } 1DCD 5B JUMPDEST 1DCE 50 POP 1DCF 50 POP 1DD0 50 POP 1DD1 50 POP 1DD2 50 POP 1DD3 50 POP 1DD4 50 POP 1DD5 50 POP 1DD6 50 POP 1DD7 56 *JUMP // Stack delta = -10 // Block ends with unconditional jump to stack[-10] label_1DD8: // Incoming jump from 0x067A // Inputs[6] // { // @1DE2 stack[-2] // @1DE9 memory[0x00:0x40] // @1DED stack[-1] // @1DF1 memory[0x00:0x40] // @1DF2 storage[keccak256(memory[0x00:0x40])] // @1DF3 stack[-3] // } 1DD8 5B JUMPDEST 1DD9 60 PUSH1 0x02 1DDB 60 PUSH1 0x20 1DDD 90 SWAP1 1DDE 81 DUP2 1DDF 52 MSTORE 1DE0 60 PUSH1 0x00 1DE2 92 SWAP3 1DE3 83 DUP4 1DE4 52 MSTORE 1DE5 60 PUSH1 0x40 1DE7 80 DUP1 1DE8 84 DUP5 1DE9 20 SHA3 1DEA 90 SWAP1 1DEB 91 SWAP2 1DEC 52 MSTORE 1DED 90 SWAP1 1DEE 82 DUP3 1DEF 52 MSTORE 1DF0 90 SWAP1 1DF1 20 SHA3 1DF2 54 SLOAD 1DF3 81 DUP2 1DF4 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @1DDF memory[0x20:0x40] = 0x02 // @1DE4 memory[0x00:0x20] = stack[-2] // @1DEC memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1DEF memory[0x00:0x20] = stack[-1] // @1DF2 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_1DF5: // Incoming call from 0x0682, returns to 0x0257 // Inputs[1] { @1DF8 storage[0x0c] } 1DF5 5B JUMPDEST 1DF6 60 PUSH1 0x0c 1DF8 54 SLOAD 1DF9 60 PUSH1 0x01 1DFB 14 EQ 1DFC 61 PUSH2 0x1e66 1DFF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e66, if 0x01 == storage[0x0c] label_1E00: // Incoming jump from 0x1DFF, if not 0x01 == storage[0x0c] // Inputs[3] // { // @1E03 memory[0x40:0x60] // @1E5C memory[0x40:0x60] // @1E65 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1E00 60 PUSH1 0x40 1E02 80 DUP1 1E03 51 MLOAD 1E04 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1E25 81 DUP2 1E26 52 MSTORE 1E27 60 PUSH1 0x20 1E29 60 PUSH1 0x04 1E2B 82 DUP3 1E2C 01 ADD 1E2D 52 MSTORE 1E2E 60 PUSH1 0x11 1E30 60 PUSH1 0x24 1E32 82 DUP3 1E33 01 ADD 1E34 52 MSTORE 1E35 7F PUSH32 0x556e697377617056323a204c4f434b4544000000000000000000000000000000 1E56 60 PUSH1 0x44 1E58 82 DUP3 1E59 01 ADD 1E5A 52 MSTORE 1E5B 90 SWAP1 1E5C 51 MLOAD 1E5D 90 SWAP1 1E5E 81 DUP2 1E5F 90 SWAP1 1E60 03 SUB 1E61 60 PUSH1 0x64 1E63 01 ADD 1E64 90 SWAP1 1E65 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1E26 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1E2D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1E34 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x11 // @1E5A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x556e697377617056323a204c4f434b4544000000000000000000000000000000 // @1E65 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1E66: // Incoming jump from 0x1DFF, if 0x01 == storage[0x0c] // Inputs[5] // { // @1E6E storage[0x06] // @1E72 memory[0x40:0x60] // @1E96 address(this) // @1E9D memory[0x40:0x60] // @1ED1 address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x06]).code.length // } 1E66 5B JUMPDEST 1E67 60 PUSH1 0x00 1E69 60 PUSH1 0x0c 1E6B 55 SSTORE 1E6C 60 PUSH1 0x06 1E6E 54 SLOAD 1E6F 60 PUSH1 0x40 1E71 80 DUP1 1E72 51 MLOAD 1E73 7F PUSH32 0x70a0823100000000000000000000000000000000000000000000000000000000 1E94 81 DUP2 1E95 52 MSTORE 1E96 30 ADDRESS 1E97 60 PUSH1 0x04 1E99 82 DUP3 1E9A 01 ADD 1E9B 52 MSTORE 1E9C 90 SWAP1 1E9D 51 MLOAD 1E9E 61 PUSH2 0x1fd4 1EA1 92 SWAP3 1EA2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EB7 16 AND 1EB8 91 SWAP2 1EB9 63 PUSH4 0x70a08231 1EBE 91 SWAP2 1EBF 60 PUSH1 0x24 1EC1 80 DUP1 1EC2 83 DUP4 1EC3 01 ADD 1EC4 92 SWAP3 1EC5 60 PUSH1 0x20 1EC7 92 SWAP3 1EC8 91 SWAP2 1EC9 90 SWAP1 1ECA 82 DUP3 1ECB 90 SWAP1 1ECC 03 SUB 1ECD 01 ADD 1ECE 81 DUP2 1ECF 86 DUP7 1ED0 80 DUP1 1ED1 3B EXTCODESIZE 1ED2 15 ISZERO 1ED3 80 DUP1 1ED4 15 ISZERO 1ED5 61 PUSH2 0x1edd 1ED8 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @1E6B storage[0x0c] = 0x00 // @1E95 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000 // @1E9B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @1EA1 stack[0] = 0x1fd4 // @1EB8 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] // @1EBE stack[2] = 0x70a08231 // @1EC4 stack[3] = memory[0x40:0x60] + 0x24 // @1EC7 stack[4] = 0x20 // @1EC8 stack[5] = memory[0x40:0x60] // @1ECD stack[6] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @1ECE stack[7] = memory[0x40:0x60] // @1ECF stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] // @1ED2 stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x06]).code.length // } // Block ends with conditional call to 0x1edd, returns to 0x1FD4, if !!address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x06]).code.length label_1ED9: // Incoming jump from 0x1ED8, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x06]).code.length // Inputs[1] { @1EDC memory[0x00:0x00] } 1ED9 60 PUSH1 0x00 1EDB 80 DUP1 1EDC FD *REVERT // Stack delta = +0 // Outputs[1] { @1EDC revert(memory[0x00:0x00]); } // Block terminates label_1EDD: // Incoming call from 0x1ED8, returns to 0x1FD4, if !!address(0xffffffffffffffffffffffffffffffffffffffff & storage[0x06]).code.length // Inputs[8] // { // @1EDF msg.gas // @1EE0 stack[-2] // @1EE0 memory[stack[-3]:stack[-3] + stack[-4]] // @1EE0 stack[-4] // @1EE0 stack[-6] // @1EE0 stack[-3] // @1EE0 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1EE0 stack[-5] // } 1EDD 5B JUMPDEST 1EDE 50 POP 1EDF 5A GAS 1EE0 FA STATICCALL 1EE1 15 ISZERO 1EE2 80 DUP1 1EE3 15 ISZERO 1EE4 61 PUSH2 0x1ef1 1EE7 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1EE0 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1EE1 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1ef1, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1EE8: // Incoming jump from 0x1EE7, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1EE8 returndata.length // @1EEC returndata[0x00:0x00 + returndata.length] // @1EED returndata.length // @1EF0 memory[0x00:0x00 + returndata.length] // } 1EE8 3D RETURNDATASIZE 1EE9 60 PUSH1 0x00 1EEB 80 DUP1 1EEC 3E RETURNDATACOPY 1EED 3D RETURNDATASIZE 1EEE 60 PUSH1 0x00 1EF0 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1EEC memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1EF0 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1EF1: // Incoming jump from 0x1EE7, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1EF8 memory[0x40:0x60] // @1EF9 returndata.length // } 1EF1 5B JUMPDEST 1EF2 50 POP 1EF3 50 POP 1EF4 50 POP 1EF5 50 POP 1EF6 60 PUSH1 0x40 1EF8 51 MLOAD 1EF9 3D RETURNDATASIZE 1EFA 60 PUSH1 0x20 1EFC 81 DUP2 1EFD 10 LT 1EFE 15 ISZERO 1EFF 61 PUSH2 0x1f07 1F02 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1EF8 stack[-4] = memory[0x40:0x60] // @1EF9 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1f07, if !(returndata.length < 0x20) label_1F03: // Incoming jump from 0x1F02, if not !(returndata.length < 0x20) // Inputs[1] { @1F06 memory[0x00:0x00] } 1F03 60 PUSH1 0x00 1F05 80 DUP1 1F06 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F06 revert(memory[0x00:0x00]); } // Block terminates label_1F07: // Incoming jump from 0x1F02, if !(returndata.length < 0x20) // Inputs[7] // { // @1F09 memory[stack[-2]:stack[-2] + 0x20] // @1F09 stack[-2] // @1F0C storage[0x07] // @1F10 memory[0x40:0x60] // @1F34 address(this) // @1F3B memory[0x40:0x60] // @1F6E address(storage[0x07] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 1F07 5B JUMPDEST 1F08 50 POP 1F09 51 MLOAD 1F0A 60 PUSH1 0x07 1F0C 54 SLOAD 1F0D 60 PUSH1 0x40 1F0F 80 DUP1 1F10 51 MLOAD 1F11 7F PUSH32 0x70a0823100000000000000000000000000000000000000000000000000000000 1F32 81 DUP2 1F33 52 MSTORE 1F34 30 ADDRESS 1F35 60 PUSH1 0x04 1F37 82 DUP3 1F38 01 ADD 1F39 52 MSTORE 1F3A 90 SWAP1 1F3B 51 MLOAD 1F3C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F51 90 SWAP1 1F52 92 SWAP3 1F53 16 AND 1F54 91 SWAP2 1F55 63 PUSH4 0x70a08231 1F5A 91 SWAP2 1F5B 60 PUSH1 0x24 1F5D 80 DUP1 1F5E 82 DUP3 1F5F 01 ADD 1F60 92 SWAP3 1F61 60 PUSH1 0x20 1F63 92 SWAP3 1F64 90 SWAP1 1F65 91 SWAP2 1F66 90 SWAP1 1F67 82 DUP3 1F68 90 SWAP1 1F69 03 SUB 1F6A 01 ADD 1F6B 81 DUP2 1F6C 86 DUP7 1F6D 80 DUP1 1F6E 3B EXTCODESIZE 1F6F 15 ISZERO 1F70 80 DUP1 1F71 15 ISZERO 1F72 61 PUSH2 0x1f7a 1F75 57 *JUMPI // Stack delta = +8 // Outputs[12] // { // @1F09 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] // @1F33 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a0823100000000000000000000000000000000000000000000000000000000 // @1F39 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @1F54 stack[-1] = storage[0x07] & 0xffffffffffffffffffffffffffffffffffffffff // @1F5A stack[0] = 0x70a08231 // @1F60 stack[1] = memory[0x40:0x60] + 0x24 // @1F63 stack[2] = 0x20 // @1F65 stack[3] = memory[0x40:0x60] // @1F6A stack[4] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @1F6B stack[5] = memory[0x40:0x60] // @1F6C stack[6] = storage[0x07] & 0xffffffffffffffffffffffffffffffffffffffff // @1F6F stack[7] = !address(storage[0x07] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x1f7a, if !!address(storage[0x07] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_1F76: // Incoming jump from 0x1F75, if not !!address(storage[0x07] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @1F79 memory[0x00:0x00] } 1F76 60 PUSH1 0x00 1F78 80 DUP1 1F79 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F79 revert(memory[0x00:0x00]); } // Block terminates label_1F7A: // Incoming jump from 0x1F75, if !!address(storage[0x07] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[8] // { // @1F7C msg.gas // @1F7D address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1F7D stack[-4] // @1F7D memory[stack[-3]:stack[-3] + stack[-4]] // @1F7D stack[-5] // @1F7D stack[-2] // @1F7D stack[-3] // @1F7D stack[-6] // } 1F7A 5B JUMPDEST 1F7B 50 POP 1F7C 5A GAS 1F7D FA STATICCALL 1F7E 15 ISZERO 1F7F 80 DUP1 1F80 15 ISZERO 1F81 61 PUSH2 0x1f8e 1F84 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1F7D memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1F7E stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1f8e, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1F85: // Incoming jump from 0x1F84, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1F85 returndata.length // @1F89 returndata[0x00:0x00 + returndata.length] // @1F8A returndata.length // @1F8D memory[0x00:0x00 + returndata.length] // } 1F85 3D RETURNDATASIZE 1F86 60 PUSH1 0x00 1F88 80 DUP1 1F89 3E RETURNDATACOPY 1F8A 3D RETURNDATASIZE 1F8B 60 PUSH1 0x00 1F8D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1F89 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1F8D revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1F8E: // Incoming jump from 0x1F84, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1F95 memory[0x40:0x60] // @1F96 returndata.length // } 1F8E 5B JUMPDEST 1F8F 50 POP 1F90 50 POP 1F91 50 POP 1F92 50 POP 1F93 60 PUSH1 0x40 1F95 51 MLOAD 1F96 3D RETURNDATASIZE 1F97 60 PUSH1 0x20 1F99 81 DUP2 1F9A 10 LT 1F9B 15 ISZERO 1F9C 61 PUSH2 0x1fa4 1F9F 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1F95 stack[-4] = memory[0x40:0x60] // @1F96 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1fa4, if !(returndata.length < 0x20) label_1FA0: // Incoming jump from 0x1F9F, if not !(returndata.length < 0x20) // Inputs[1] { @1FA3 memory[0x00:0x00] } 1FA0 60 PUSH1 0x00 1FA2 80 DUP1 1FA3 FD *REVERT // Stack delta = +0 // Outputs[1] { @1FA3 revert(memory[0x00:0x00]); } // Block terminates label_1FA4: // Incoming jump from 0x1F9F, if !(returndata.length < 0x20) // Inputs[3] // { // @1FA6 memory[stack[-2]:stack[-2] + 0x20] // @1FA6 stack[-2] // @1FA9 storage[0x08] // } 1FA4 5B JUMPDEST 1FA5 50 POP 1FA6 51 MLOAD 1FA7 60 PUSH1 0x08 1FA9 54 SLOAD 1FAA 6D PUSH14 0xffffffffffffffffffffffffffff 1FB9 80 DUP1 1FBA 82 DUP3 1FBB 16 AND 1FBC 91 SWAP2 1FBD 6E PUSH15 0x010000000000000000000000000000 1FCD 90 SWAP1 1FCE 04 DIV 1FCF 16 AND 1FD0 61 PUSH2 0x22e0 1FD3 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1FA6 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] // @1FBC stack[-1] = storage[0x08] & 0xffffffffffffffffffffffffffff // @1FCF stack[0] = storage[0x08] / 0x010000000000000000000000000000 & 0xffffffffffffffffffffffffffff // } // Block ends with unconditional jump to 0x22e0 label_1FD4: // Incoming return from call to 0x1EDD at 0x1ED8 // Inputs[1] { @1FDA stack[-1] } 1FD4 5B JUMPDEST 1FD5 60 PUSH1 0x01 1FD7 60 PUSH1 0x0c 1FD9 55 SSTORE 1FDA 56 *JUMP // Stack delta = -1 // Outputs[1] { @1FD9 storage[0x0c] = 0x01 } // Block ends with unconditional jump to stack[-1] label_1FDB: // Incoming call from 0x1697, returns to 0x1698 // Incoming call from 0x16A2, returns to 0x16A3 // Incoming jump from 0x1A2A // Incoming call from 0x08CF, returns to 0x08D0 // Incoming call from 0x08E0, returns to 0x08E1 // Inputs[9] // { // @1FDF memory[0x40:0x60] // @2011 memory[0x40:0x60] // @2027 stack[-2] // @2034 stack[-1] // @2038 memory[0x40:0x60] // @204C memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @2090 memory[0x40:0x60] // @2092 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2099 stack[-3] // } 1FDB 5B JUMPDEST 1FDC 60 PUSH1 0x40 1FDE 80 DUP1 1FDF 51 MLOAD 1FE0 80 DUP1 1FE1 82 DUP3 1FE2 01 ADD 1FE3 82 DUP3 1FE4 52 MSTORE 1FE5 60 PUSH1 0x19 1FE7 81 DUP2 1FE8 52 MSTORE 1FE9 7F PUSH32 0x7472616e7366657228616464726573732c75696e743235362900000000000000 200A 60 PUSH1 0x20 200C 91 SWAP2 200D 82 DUP3 200E 01 ADD 200F 52 MSTORE 2010 81 DUP2 2011 51 MLOAD 2012 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2027 85 DUP6 2028 81 DUP2 2029 16 AND 202A 60 PUSH1 0x24 202C 83 DUP4 202D 01 ADD 202E 52 MSTORE 202F 60 PUSH1 0x44 2031 80 DUP1 2032 83 DUP4 2033 01 ADD 2034 86 DUP7 2035 90 SWAP1 2036 52 MSTORE 2037 84 DUP5 2038 51 MLOAD 2039 80 DUP1 203A 84 DUP5 203B 03 SUB 203C 90 SWAP1 203D 91 SWAP2 203E 01 ADD 203F 81 DUP2 2040 52 MSTORE 2041 60 PUSH1 0x64 2043 90 SWAP1 2044 92 SWAP3 2045 01 ADD 2046 84 DUP5 2047 52 MSTORE 2048 91 SWAP2 2049 81 DUP2 204A 01 ADD 204B 80 DUP1 204C 51 MLOAD 204D 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 206A 16 AND 206B 7F PUSH32 0xa9059cbb00000000000000000000000000000000000000000000000000000000 208C 17 OR 208D 81 DUP2 208E 52 MSTORE 208F 92 SWAP3 2090 51 MLOAD 2091 81 DUP2 2092 51 MLOAD 2093 60 PUSH1 0x00 2095 94 SWAP5 2096 60 PUSH1 0x60 2098 94 SWAP5 2099 89 DUP10 209A 16 AND 209B 93 SWAP4 209C 92 SWAP3 209D 91 SWAP2 209E 82 DUP3 209F 91 SWAP2 20A0 90 SWAP1 20A1 80 DUP1 20A2 83 DUP4 20A3 83 DUP4 20A4 5B JUMPDEST 20A5 60 PUSH1 0x20 20A7 83 DUP4 20A8 10 LT 20A9 61 PUSH2 0x20e1 20AC 57 *JUMPI // Stack delta = +11 // Outputs[19] // { // @1FE4 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1FE8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x19 // @200F memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x7472616e7366657228616464726573732c75696e743235362900000000000000 // @202E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @2036 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-1] // @2040 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x44 + (memory[0x40:0x60] - memory[0x40:0x60]) // @2047 memory[0x40:0x60] = memory[0x40:0x60] + 0x64 // @208E memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xa9059cbb00000000000000000000000000000000000000000000000000000000 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]) // @2095 stack[0] = 0x00 // @2098 stack[1] = 0x60 // @209B stack[2] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @209C stack[3] = memory[0x40:0x60] // @209D stack[4] = memory[0x40:0x60] // @209F stack[5] = memory[0x40:0x60] // @20A0 stack[6] = memory[0x40:0x60] + 0x20 // @20A0 stack[7] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @20A1 stack[8] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @20A2 stack[9] = memory[0x40:0x60] // @20A3 stack[10] = memory[0x40:0x60] + 0x20 // } // Block ends with conditional jump to 0x20e1, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 label_20AD: // Incoming jump from 0x20AC, if not memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Incoming jump from 0x20AC, if not stack[-3] < 0x20 // Inputs[4] // { // @20AD stack[-1] // @20AE memory[stack[-1]:stack[-1] + 0x20] // @20AF stack[-2] // @20D3 stack[-3] // } 20AD 80 DUP1 20AE 51 MLOAD 20AF 82 DUP3 20B0 52 MSTORE 20B1 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 20D2 90 SWAP1 20D3 92 SWAP3 20D4 01 ADD 20D5 91 SWAP2 20D6 60 PUSH1 0x20 20D8 91 SWAP2 20D9 82 DUP3 20DA 01 ADD 20DB 91 SWAP2 20DC 01 ADD 20DD 61 PUSH2 0x20a4 20E0 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @20B0 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @20D5 stack[-3] = stack[-3] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 // @20DB stack[-2] = 0x20 + stack[-2] // @20DC stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x20a4 label_20E1: // Incoming jump from 0x20AC, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Incoming jump from 0x20AC, if stack[-3] < 0x20 // Inputs[15] // { // @20E4 stack[-3] // @20EF stack[-1] // @20F0 memory[stack[-1]:stack[-1] + 0x20] // @20F3 stack[-2] // @20F4 memory[stack[-2]:stack[-2] + 0x20] // @2101 stack[-4] // @2101 stack[-5] // @2103 stack[-6] // @2104 stack[-8] // @210B memory[0x40:0x60] // @2112 stack[-9] // @2113 msg.gas // @2114 memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]] // @2114 address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @2118 returndata.length // } 20E1 5B JUMPDEST 20E2 60 PUSH1 0x01 20E4 83 DUP4 20E5 60 PUSH1 0x20 20E7 03 SUB 20E8 61 PUSH2 0x0100 20EB 0A EXP 20EC 03 SUB 20ED 80 DUP1 20EE 19 NOT 20EF 82 DUP3 20F0 51 MLOAD 20F1 16 AND 20F2 81 DUP2 20F3 84 DUP5 20F4 51 MLOAD 20F5 16 AND 20F6 80 DUP1 20F7 82 DUP3 20F8 17 OR 20F9 85 DUP6 20FA 52 MSTORE 20FB 50 POP 20FC 50 POP 20FD 50 POP 20FE 50 POP 20FF 50 POP 2100 50 POP 2101 90 SWAP1 2102 50 POP 2103 01 ADD 2104 91 SWAP2 2105 50 POP 2106 50 POP 2107 60 PUSH1 0x00 2109 60 PUSH1 0x40 210B 51 MLOAD 210C 80 DUP1 210D 83 DUP4 210E 03 SUB 210F 81 DUP2 2110 60 PUSH1 0x00 2112 86 DUP7 2113 5A GAS 2114 F1 CALL 2115 91 SWAP2 2116 50 POP 2117 50 POP 2118 3D RETURNDATASIZE 2119 80 DUP1 211A 60 PUSH1 0x00 211C 81 DUP2 211D 14 EQ 211E 61 PUSH2 0x2143 2121 57 *JUMPI // Stack delta = -6 // Outputs[5] // { // @20FA memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @2114 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @2115 stack[-9] = address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @2118 stack[-8] = returndata.length // @2119 stack[-7] = returndata.length // } // Block ends with conditional jump to 0x2143, if returndata.length == 0x00 label_2122: // Incoming jump from 0x2121, if not returndata.length == 0x00 // Inputs[6] // { // @2124 memory[0x40:0x60] // @2125 stack[-2] // @212C returndata.length // @2134 returndata.length // @2137 returndata.length // @213E returndata[0x00:0x00 + returndata.length] // } 2122 60 PUSH1 0x40 2124 51 MLOAD 2125 91 SWAP2 2126 50 POP 2127 60 PUSH1 0x1f 2129 19 NOT 212A 60 PUSH1 0x3f 212C 3D RETURNDATASIZE 212D 01 ADD 212E 16 AND 212F 82 DUP3 2130 01 ADD 2131 60 PUSH1 0x40 2133 52 MSTORE 2134 3D RETURNDATASIZE 2135 82 DUP3 2136 52 MSTORE 2137 3D RETURNDATASIZE 2138 60 PUSH1 0x00 213A 60 PUSH1 0x20 213C 84 DUP5 213D 01 ADD 213E 3E RETURNDATACOPY 213F 61 PUSH2 0x2148 2142 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2125 stack[-2] = memory[0x40:0x60] // @2133 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @2136 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @213E memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x2148 label_2143: // Incoming jump from 0x2121, if returndata.length == 0x00 // Inputs[4] // { // @2146 stack[-2] // @214A stack[-4] // @214C stack[-3] // @214C stack[-5] // } 2143 5B JUMPDEST 2144 60 PUSH1 0x60 2146 91 SWAP2 2147 50 POP 2148 5B JUMPDEST 2149 50 POP 214A 91 SWAP2 214B 50 POP 214C 91 SWAP2 214D 50 POP 214E 81 DUP2 214F 80 DUP1 2150 15 ISZERO 2151 61 PUSH2 0x2176 2154 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @214A stack[-4] = 0x60 // @214C stack[-5] = stack[-3] // @214E stack[-3] = stack[-3] // } // Block ends with conditional jump to 0x2176, if !stack[-3] label_2155: // Incoming jump from 0x2154, if not !stack[-3] // Incoming jump from 0x2154, if not !stack[-3] // Inputs[2] // { // @2156 stack[-2] // @2157 memory[stack[-2]:stack[-2] + 0x20] // } 2155 50 POP 2156 80 DUP1 2157 51 MLOAD 2158 15 ISZERO 2159 80 DUP1 215A 61 PUSH2 0x2176 215D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2158 stack[-1] = !memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2176, if !memory[stack[-2]:stack[-2] + 0x20] label_215E: // Incoming jump from 0x215D, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @215F stack[-2] // @2165 memory[stack[-2]:stack[-2] + 0x20] // } 215E 50 POP 215F 80 DUP1 2160 80 DUP1 2161 60 PUSH1 0x20 2163 01 ADD 2164 90 SWAP1 2165 51 MLOAD 2166 60 PUSH1 0x20 2168 81 DUP2 2169 10 LT 216A 15 ISZERO 216B 61 PUSH2 0x2173 216E 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @2164 stack[-1] = 0x20 + stack[-2] // @2165 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x2173, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) label_216F: // Incoming jump from 0x216E, if not !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[1] { @2172 memory[0x00:0x00] } 216F 60 PUSH1 0x00 2171 80 DUP1 2172 FD *REVERT // Stack delta = +0 // Outputs[1] { @2172 revert(memory[0x00:0x00]); } // Block terminates label_2173: // Incoming jump from 0x216E, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[2] // { // @2175 memory[stack[-2]:stack[-2] + 0x20] // @2175 stack[-2] // } 2173 5B JUMPDEST 2174 50 POP 2175 51 MLOAD // Stack delta = -1 // Outputs[1] { @2175 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block continues label_2176: // Incoming jump from 0x2154, if !stack[-3] // Incoming jump from 0x215D, if !memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x2154, if !stack[-3] // Incoming jump from 0x2175 // Inputs[1] { @217A stack[-1] } 2176 5B JUMPDEST 2177 61 PUSH2 0x21e1 217A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x21e1, if stack[-1] label_217B: // Incoming jump from 0x217A, if not stack[-1] // Inputs[3] // { // @217E memory[0x40:0x60] // @21D7 memory[0x40:0x60] // @21E0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 217B 60 PUSH1 0x40 217D 80 DUP1 217E 51 MLOAD 217F 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 21A0 81 DUP2 21A1 52 MSTORE 21A2 60 PUSH1 0x20 21A4 60 PUSH1 0x04 21A6 82 DUP3 21A7 01 ADD 21A8 52 MSTORE 21A9 60 PUSH1 0x1a 21AB 60 PUSH1 0x24 21AD 82 DUP3 21AE 01 ADD 21AF 52 MSTORE 21B0 7F PUSH32 0x556e697377617056323a205452414e534645525f4641494c4544000000000000 21D1 60 PUSH1 0x44 21D3 82 DUP3 21D4 01 ADD 21D5 52 MSTORE 21D6 90 SWAP1 21D7 51 MLOAD 21D8 90 SWAP1 21D9 81 DUP2 21DA 90 SWAP1 21DB 03 SUB 21DC 60 PUSH1 0x64 21DE 01 ADD 21DF 90 SWAP1 21E0 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @21A1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @21A8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @21AF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1a // @21D5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x556e697377617056323a205452414e534645525f4641494c4544000000000000 // @21E0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_21E1: // Incoming jump from 0x217A, if stack[-1] // Inputs[1] { @21E7 stack[-6] } 21E1 5B JUMPDEST 21E2 50 POP 21E3 50 POP 21E4 50 POP 21E5 50 POP 21E6 50 POP 21E7 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_21E8: // Incoming call from 0x1256, returns to 0x1257 // Incoming call from 0x1822, returns to 0x1823 // Incoming call from 0x27D7, returns to 0x1257 // Incoming call from 0x0BFC, returns to 0x0BFD // Incoming call from 0x1293, returns to 0x1294 // Incoming call from 0x12BC, returns to 0x12BD // Incoming call from 0x1613, returns to 0x1614 // Incoming call from 0x0C4C, returns to 0x0C4D // Incoming call from 0x0BEA, returns to 0x0BEB // Incoming call from 0x0C20, returns to 0x0BEB // Incoming call from 0x15F8, returns to 0x15F9 // Incoming call from 0x282B, returns to 0x282C // Incoming jump from 0x2812 // Incoming call from 0x1379, returns to 0x137A // Incoming jump from 0x0C58 // Incoming call from 0x0C68, returns to 0x0C69 // Inputs[1] { @21EB stack[-1] } 21E8 5B JUMPDEST 21E9 60 PUSH1 0x00 21EB 81 DUP2 21EC 15 ISZERO 21ED 80 DUP1 21EE 61 PUSH2 0x2203 21F1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @21E9 stack[0] = 0x00 // @21EC stack[1] = !stack[-1] // } // Block ends with conditional jump to 0x2203, if !stack[-1] label_21F2: // Incoming jump from 0x21F1, if not !stack[-1] // Inputs[2] // { // @21F4 stack[-3] // @21F5 stack[-4] // } 21F2 50 POP 21F3 50 POP 21F4 80 DUP1 21F5 82 DUP3 21F6 02 MUL 21F7 82 DUP3 21F8 82 DUP3 21F9 82 DUP3 21FA 81 DUP2 21FB 61 PUSH2 0x2200 21FE 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @21F6 stack[-2] = stack[-4] * stack[-3] // @21F7 stack[-1] = stack[-4] // @21F8 stack[0] = stack[-3] // @21F9 stack[1] = stack[-4] * stack[-3] // } // Block ends with conditional jump to 0x2200, if stack[-3] label_21FF: // Incoming jump from 0x21FE, if not stack[-3] 21FF FE *ASSERT // Stack delta = +0 // Outputs[1] { @21FF assert(); } // Block terminates label_2200: // Incoming jump from 0x21FE, if stack[-3] // Inputs[3] // { // @2201 stack[-1] // @2201 stack[-2] // @2202 stack[-3] // } 2200 5B JUMPDEST 2201 04 DIV 2202 14 EQ // Stack delta = -2 // Outputs[1] { @2202 stack[-3] = stack[-1] / stack[-2] == stack[-3] } // Block continues label_2203: // Incoming jump from 0x2202 // Incoming jump from 0x21F1, if !stack[-1] // Inputs[1] { @2207 stack[-1] } 2203 5B JUMPDEST 2204 61 PUSH2 0x0df6 2207 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0df6, if stack[-1] label_2208: // Incoming jump from 0x2207, if not stack[-1] // Inputs[3] // { // @220B memory[0x40:0x60] // @2264 memory[0x40:0x60] // @226D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2208 60 PUSH1 0x40 220A 80 DUP1 220B 51 MLOAD 220C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 222D 81 DUP2 222E 52 MSTORE 222F 60 PUSH1 0x20 2231 60 PUSH1 0x04 2233 82 DUP3 2234 01 ADD 2235 52 MSTORE 2236 60 PUSH1 0x14 2238 60 PUSH1 0x24 223A 82 DUP3 223B 01 ADD 223C 52 MSTORE 223D 7F PUSH32 0x64732d6d6174682d6d756c2d6f766572666c6f77000000000000000000000000 225E 60 PUSH1 0x44 2260 82 DUP3 2261 01 ADD 2262 52 MSTORE 2263 90 SWAP1 2264 51 MLOAD 2265 90 SWAP1 2266 81 DUP2 2267 90 SWAP1 2268 03 SUB 2269 60 PUSH1 0x64 226B 01 ADD 226C 90 SWAP1 226D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @222E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2235 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @223C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @2262 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x64732d6d6174682d6d756c2d6f766572666c6f77000000000000000000000000 // @226D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_226E: // Incoming call from 0x2A01, returns to 0x2A02 // Incoming call from 0x2803, returns to 0x2804 // Incoming jump from 0x1A25 // Incoming call from 0x1224, returns to 0x1225 // Incoming call from 0x0EB5, returns to 0x0EB6 // Incoming call from 0x1200, returns to 0x1201 // Incoming call from 0x2640, returns to 0x2641 // Incoming jump from 0x0C08 // Incoming call from 0x29C7, returns to 0x29C8 // Inputs[2] // { // @226F stack[-1] // @2270 stack[-2] // } 226E 5B JUMPDEST 226F 80 DUP1 2270 82 DUP3 2271 03 SUB 2272 82 DUP3 2273 81 DUP2 2274 11 GT 2275 15 ISZERO 2276 61 PUSH2 0x0df6 2279 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2271 stack[0] = stack[-2] - stack[-1] } // Block ends with conditional jump to 0x0df6, if !(stack[-2] - stack[-1] > stack[-2]) label_227A: // Incoming jump from 0x2279, if not !(stack[-2] - stack[-1] > stack[-2]) // Inputs[3] // { // @227D memory[0x40:0x60] // @22D6 memory[0x40:0x60] // @22DF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 227A 60 PUSH1 0x40 227C 80 DUP1 227D 51 MLOAD 227E 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 229F 81 DUP2 22A0 52 MSTORE 22A1 60 PUSH1 0x20 22A3 60 PUSH1 0x04 22A5 82 DUP3 22A6 01 ADD 22A7 52 MSTORE 22A8 60 PUSH1 0x15 22AA 60 PUSH1 0x24 22AC 82 DUP3 22AD 01 ADD 22AE 52 MSTORE 22AF 7F PUSH32 0x64732d6d6174682d7375622d756e646572666c6f770000000000000000000000 22D0 60 PUSH1 0x44 22D2 82 DUP3 22D3 01 ADD 22D4 52 MSTORE 22D5 90 SWAP1 22D6 51 MLOAD 22D7 90 SWAP1 22D8 81 DUP2 22D9 90 SWAP1 22DA 03 SUB 22DB 60 PUSH1 0x64 22DD 01 ADD 22DE 90 SWAP1 22DF FD *REVERT // Stack delta = +0 // Outputs[5] // { // @22A0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @22A7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @22AE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x15 // @22D4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x64732d6d6174682d7375622d756e646572666c6f770000000000000000000000 // @22DF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_22E0: // Incoming call from 0x133B, returns to 0x133C // Incoming call from 0x17E4, returns to 0x17E5 // Incoming jump from 0x1FD3 // Incoming call from 0x0CE3, returns to 0x0CE4 // Inputs[1] { @22F0 stack[-4] } 22E0 5B JUMPDEST 22E1 6D PUSH14 0xffffffffffffffffffffffffffff 22F0 84 DUP5 22F1 11 GT 22F2 80 DUP1 22F3 15 ISZERO 22F4 90 SWAP1 22F5 61 PUSH2 0x230c 22F8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22F4 stack[0] = !(stack[-4] > 0xffffffffffffffffffffffffffff) } // Block ends with conditional jump to 0x230c, if stack[-4] > 0xffffffffffffffffffffffffffff label_22F9: // Incoming jump from 0x22F8, if not stack[-4] > 0xffffffffffffffffffffffffffff // Inputs[1] { @2309 stack[-4] } 22F9 50 POP 22FA 6D PUSH14 0xffffffffffffffffffffffffffff 2309 83 DUP4 230A 11 GT 230B 15 ISZERO 230C 5B JUMPDEST 230D 61 PUSH2 0x2377 2310 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2377, if !(stack[-4] > 0xffffffffffffffffffffffffffff) label_2311: // Incoming jump from 0x2310, if not !(stack[-4] > 0xffffffffffffffffffffffffffff) // Incoming jump from 0x2310, if not stack[-1] // Inputs[3] // { // @2314 memory[0x40:0x60] // @236D memory[0x40:0x60] // @2376 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2311 60 PUSH1 0x40 2313 80 DUP1 2314 51 MLOAD 2315 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2336 81 DUP2 2337 52 MSTORE 2338 60 PUSH1 0x20 233A 60 PUSH1 0x04 233C 82 DUP3 233D 01 ADD 233E 52 MSTORE 233F 60 PUSH1 0x13 2341 60 PUSH1 0x24 2343 82 DUP3 2344 01 ADD 2345 52 MSTORE 2346 7F PUSH32 0x556e697377617056323a204f564552464c4f5700000000000000000000000000 2367 60 PUSH1 0x44 2369 82 DUP3 236A 01 ADD 236B 52 MSTORE 236C 90 SWAP1 236D 51 MLOAD 236E 90 SWAP1 236F 81 DUP2 2370 90 SWAP1 2371 03 SUB 2372 60 PUSH1 0x64 2374 01 ADD 2375 90 SWAP1 2376 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2337 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @233E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2345 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x13 // @236B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x556e697377617056323a204f564552464c4f5700000000000000000000000000 // @2376 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2377: // Incoming jump from 0x2310, if !(stack[-4] > 0xffffffffffffffffffffffffffff) // Incoming jump from 0x2310, if stack[-1] // Inputs[2] // { // @237A storage[0x08] // @2380 block.timestamp // } 2377 5B JUMPDEST 2378 60 PUSH1 0x08 237A 54 SLOAD 237B 63 PUSH4 0xffffffff 2380 42 TIMESTAMP 2381 81 DUP2 2382 16 AND 2383 91 SWAP2 2384 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 23A2 90 SWAP1 23A3 04 DIV 23A4 81 DUP2 23A5 16 AND 23A6 82 DUP3 23A7 03 SUB 23A8 90 SWAP1 23A9 81 DUP2 23AA 16 AND 23AB 15 ISZERO 23AC 80 DUP1 23AD 15 ISZERO 23AE 90 SWAP1 23AF 61 PUSH2 0x23c7 23B2 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2383 stack[0] = 0xffffffff & block.timestamp // @23A8 stack[1] = (0xffffffff & block.timestamp) - (0xffffffff & storage[0x08] / 0x0100000000000000000000000000000000000000000000000000000000) // @23AE stack[2] = !!((0xffffffff & block.timestamp) - (0xffffffff & storage[0x08] / 0x0100000000000000000000000000000000000000000000000000000000) & 0xffffffff) // } // Block ends with conditional jump to 0x23c7, if !((0xffffffff & block.timestamp) - (0xffffffff & storage[0x08] / 0x0100000000000000000000000000000000000000000000000000000000) & 0xffffffff) label_23B3: // Incoming jump from 0x23B2, if not !((0xffffffff & block.timestamp) - (0xffffffff & storage[0x08] / 0x0100000000000000000000000000000000000000000000000000000000) & 0xffffffff) // Inputs[1] { @23C3 stack[-5] } 23B3 50 POP 23B4 6D PUSH14 0xffffffffffffffffffffffffffff 23C3 84 DUP5 23C4 16 AND 23C5 15 ISZERO 23C6 15 ISZERO 23C7 5B JUMPDEST 23C8 80 DUP1 23C9 15 ISZERO 23CA 61 PUSH2 0x23e2 23CD 57 *JUMPI // Stack delta = +0 // Outputs[1] { @23C6 stack[-1] = !!(stack[-5] & 0xffffffffffffffffffffffffffff) } // Block ends with conditional jump to 0x23e2, if !!!(stack[-5] & 0xffffffffffffffffffffffffffff) label_23CE: // Incoming jump from 0x23CD, if not !stack[-1] // Incoming jump from 0x23CD, if not !!!(stack[-5] & 0xffffffffffffffffffffffffffff) // Inputs[1] { @23DE stack[-4] } 23CE 50 POP 23CF 6D PUSH14 0xffffffffffffffffffffffffffff 23DE 83 DUP4 23DF 16 AND 23E0 15 ISZERO 23E1 15 ISZERO 23E2 5B JUMPDEST 23E3 15 ISZERO 23E4 61 PUSH2 0x2492 23E7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2492, if !!!(stack[-4] & 0xffffffffffffffffffffffffffff) label_23E8: // Incoming jump from 0x23E7, if not !stack[-1] // Incoming jump from 0x23E7, if not !!!(stack[-4] & 0xffffffffffffffffffffffffffff) // Inputs[3] // { // @23E8 stack[-1] // @23F2 stack[-4] // @23F6 stack[-3] // } 23E8 80 DUP1 23E9 63 PUSH4 0xffffffff 23EE 16 AND 23EF 61 PUSH2 0x2425 23F2 85 DUP6 23F3 61 PUSH2 0x23fb 23F6 86 DUP7 23F7 61 PUSH2 0x2a57 23FA 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @23EE stack[0] = 0xffffffff & stack[-1] // @23EF stack[1] = 0x2425 // @23F2 stack[2] = stack[-4] // @23F3 stack[3] = 0x23fb // @23F6 stack[4] = stack[-3] // } // Block ends with call to 0x2a57, returns to 0x23FB label_23FB: // Incoming return from call to 0x2A57 at 0x2464 // Incoming return from call to 0x2A57 at 0x23FA // Inputs[2] // { // @2419 stack[-1] // @241A stack[-2] // } 23FB 5B JUMPDEST 23FC 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2419 16 AND 241A 90 SWAP1 241B 63 PUSH4 0xffffffff 2420 61 PUSH2 0x2a7b 2423 16 AND 2424 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @241A stack[-1] = stack[-2] // @241A stack[-2] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] // } // Block ends with unconditional jump to 0x2a7b & 0xffffffff label_2425: // Incoming return from call to 0x23FB at 0x23FA // Inputs[6] // { // @2429 storage[0x09] // @2447 stack[-1] // @244B stack[-2] // @2457 stack[-3] // @245C stack[-5] // @2460 stack[-6] // } 2425 5B JUMPDEST 2426 60 PUSH1 0x09 2428 80 DUP1 2429 54 SLOAD 242A 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2447 92 SWAP3 2448 90 SWAP1 2449 92 SWAP3 244A 16 AND 244B 92 SWAP3 244C 90 SWAP1 244D 92 SWAP3 244E 02 MUL 244F 01 ADD 2450 90 SWAP1 2451 55 SSTORE 2452 63 PUSH4 0xffffffff 2457 81 DUP2 2458 16 AND 2459 61 PUSH2 0x2465 245C 84 DUP5 245D 61 PUSH2 0x23fb 2460 87 DUP8 2461 61 PUSH2 0x2a57 2464 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @2451 storage[0x09] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1]) * stack[-2] + storage[0x09] // @2458 stack[-2] = stack[-3] & 0xffffffff // @2459 stack[-1] = 0x2465 // @245C stack[0] = stack[-5] // @245D stack[1] = 0x23fb // @2460 stack[2] = stack[-6] // } // Block ends with call to 0x2a57, returns to 0x23FB label_2465: // Incoming return from call to 0x23FB at 0x2464 // Inputs[3] // { // @2469 storage[0x0a] // @2487 stack[-1] // @248B stack[-2] // } 2465 5B JUMPDEST 2466 60 PUSH1 0x0a 2468 80 DUP1 2469 54 SLOAD 246A 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2487 92 SWAP3 2488 90 SWAP1 2489 92 SWAP3 248A 16 AND 248B 92 SWAP3 248C 90 SWAP1 248D 92 SWAP3 248E 02 MUL 248F 01 ADD 2490 90 SWAP1 2491 55 SSTORE // Stack delta = -2 // Outputs[1] { @2491 storage[0x0a] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1]) * stack[-2] + storage[0x0a] } // Block continues label_2492: // Incoming jump from 0x2491 // Incoming jump from 0x23E7, if !stack[-1] // Incoming jump from 0x23E7, if !!!(stack[-4] & 0xffffffffffffffffffffffffffff) // Inputs[8] // { // @2496 storage[0x08] // @24C8 stack[-6] // @2501 stack[-5] // @254B stack[-2] // @2556 memory[0x40:0x60] // @2569 memory[0x40:0x60] // @2594 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x40 + (memory[0x40:0x60] - memory[0x40:0x60])] // @259B stack[-7] // } 2492 5B JUMPDEST 2493 60 PUSH1 0x08 2495 80 DUP1 2496 54 SLOAD 2497 7F PUSH32 0xffffffffffffffffffffffffffffffffffff0000000000000000000000000000 24B8 16 AND 24B9 6D PUSH14 0xffffffffffffffffffffffffffff 24C8 88 DUP9 24C9 81 DUP2 24CA 16 AND 24CB 91 SWAP2 24CC 90 SWAP1 24CD 91 SWAP2 24CE 17 OR 24CF 7F PUSH32 0xffffffff0000000000000000000000000000ffffffffffffffffffffffffffff 24F0 16 AND 24F1 6E PUSH15 0x010000000000000000000000000000 2501 88 DUP9 2502 83 DUP4 2503 16 AND 2504 81 DUP2 2505 02 MUL 2506 91 SWAP2 2507 90 SWAP1 2508 91 SWAP2 2509 17 OR 250A 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2527 16 AND 2528 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 2546 63 PUSH4 0xffffffff 254B 87 DUP8 254C 16 AND 254D 02 MUL 254E 17 OR 254F 92 SWAP3 2550 83 DUP4 2551 90 SWAP1 2552 55 SSTORE 2553 60 PUSH1 0x40 2555 80 DUP1 2556 51 MLOAD 2557 84 DUP5 2558 84 DUP5 2559 16 AND 255A 81 DUP2 255B 52 MSTORE 255C 91 SWAP2 255D 90 SWAP1 255E 93 SWAP4 255F 04 DIV 2560 90 SWAP1 2561 91 SWAP2 2562 16 AND 2563 60 PUSH1 0x20 2565 82 DUP3 2566 01 ADD 2567 52 MSTORE 2568 81 DUP2 2569 51 MLOAD 256A 7F PUSH32 0x1c411e9a96e071241c2f21f7726b17ae89e3cab4c78be50e062b03a9fffbbad1 258B 92 SWAP3 258C 91 SWAP2 258D 81 DUP2 258E 90 SWAP1 258F 03 SUB 2590 90 SWAP1 2591 91 SWAP2 2592 01 ADD 2593 90 SWAP1 2594 A1 LOG1 2595 50 POP 2596 50 POP 2597 50 POP 2598 50 POP 2599 50 POP 259A 50 POP 259B 56 *JUMP // Stack delta = -7 // Outputs[4] // { // @2552 storage[0x08] = (stack[-2] & 0xffffffff) * 0x0100000000000000000000000000000000000000000000000000000000 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0x010000000000000000000000000000 * (0xffffffffffffffffffffffffffff & stack[-5]) | (0xffffffff0000000000000000000000000000ffffffffffffffffffffffffffff & ((0xffffffffffffffffffffffffffff & stack[-6]) | (0xffffffffffffffffffffffffffffffffffff0000000000000000000000000000 & storage[0x08]))))) // @255B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffff & ((stack[-2] & 0xffffffff) * 0x0100000000000000000000000000000000000000000000000000000000 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0x010000000000000000000000000000 * (0xffffffffffffffffffffffffffff & stack[-5]) | (0xffffffff0000000000000000000000000000ffffffffffffffffffffffffffff & ((0xffffffffffffffffffffffffffff & stack[-6]) | (0xffffffffffffffffffffffffffffffffffff0000000000000000000000000000 & storage[0x08])))))) // @2567 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffffffffffffffff & ((stack[-2] & 0xffffffff) * 0x0100000000000000000000000000000000000000000000000000000000 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0x010000000000000000000000000000 * (0xffffffffffffffffffffffffffff & stack[-5]) | (0xffffffff0000000000000000000000000000ffffffffffffffffffffffffffff & ((0xffffffffffffffffffffffffffff & stack[-6]) | (0xffffffffffffffffffffffffffffffffffff0000000000000000000000000000 & storage[0x08])))))) / 0x010000000000000000000000000000 // @2594 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x40 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x1c411e9a96e071241c2f21f7726b17ae89e3cab4c78be50e062b03a9fffbbad1]); // } // Block ends with unconditional jump to stack[-7] label_259C: // Incoming call from 0x0DF1, returns to 0x0DF2 // Incoming call from 0x1DCC, returns to 0x1DCD // Inputs[9] // { // @25B3 stack[-3] // @25C5 memory[0x00:0x40] // @25C7 stack[-2] // @25D2 memory[0x00:0x40] // @25D3 stack[-1] // @25D7 memory[0x40:0x60] // @25DC memory[0x40:0x60] // @2606 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @260A stack[-4] // } 259C 5B JUMPDEST 259D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25B2 80 DUP1 25B3 84 DUP5 25B4 16 AND 25B5 60 PUSH1 0x00 25B7 81 DUP2 25B8 81 DUP2 25B9 52 MSTORE 25BA 60 PUSH1 0x02 25BC 60 PUSH1 0x20 25BE 90 SWAP1 25BF 81 DUP2 25C0 52 MSTORE 25C1 60 PUSH1 0x40 25C3 80 DUP1 25C4 83 DUP4 25C5 20 SHA3 25C6 94 SWAP5 25C7 87 DUP8 25C8 16 AND 25C9 80 DUP1 25CA 84 DUP5 25CB 52 MSTORE 25CC 94 SWAP5 25CD 82 DUP3 25CE 52 MSTORE 25CF 91 SWAP2 25D0 82 DUP3 25D1 90 SWAP1 25D2 20 SHA3 25D3 85 DUP6 25D4 90 SWAP1 25D5 55 SSTORE 25D6 81 DUP2 25D7 51 MLOAD 25D8 85 DUP6 25D9 81 DUP2 25DA 52 MSTORE 25DB 91 SWAP2 25DC 51 MLOAD 25DD 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 25FE 92 SWAP3 25FF 81 DUP2 2600 90 SWAP1 2601 03 SUB 2602 90 SWAP1 2603 91 SWAP2 2604 01 ADD 2605 90 SWAP1 2606 A3 LOG3 2607 50 POP 2608 50 POP 2609 50 POP 260A 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @25B9 memory[0x00:0x20] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @25C0 memory[0x20:0x40] = 0x02 // @25CB memory[0x00:0x20] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @25CE memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @25D5 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @25DA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @2606 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-4] label_260B: // Incoming call from 0x0EF2, returns to 0x0EF3 // Incoming call from 0x18D7, returns to 0x0DF2 // Inputs[4] // { // @2621 stack[-3] // @2630 memory[0x00:0x40] // @2631 storage[keccak256(memory[0x00:0x40])] // @2636 stack[-1] // } 260B 5B JUMPDEST 260C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2621 83 DUP4 2622 16 AND 2623 60 PUSH1 0x00 2625 90 SWAP1 2626 81 DUP2 2627 52 MSTORE 2628 60 PUSH1 0x01 262A 60 PUSH1 0x20 262C 52 MSTORE 262D 60 PUSH1 0x40 262F 90 SWAP1 2630 20 SHA3 2631 54 SLOAD 2632 61 PUSH2 0x2641 2635 90 SWAP1 2636 82 DUP3 2637 63 PUSH4 0xffffffff 263C 61 PUSH2 0x226e 263F 16 AND 2640 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @2627 memory[0x00:0x20] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @262C memory[0x20:0x40] = 0x01 // @2635 stack[0] = 0x2641 // @2635 stack[1] = storage[keccak256(memory[0x00:0x40])] // @2636 stack[2] = stack[-1] // } // Block ends with call to 0x226e & 0xffffffff, returns to 0x2641 label_2641: // Incoming return from call to 0x226E at 0x2640 // Inputs[7] // { // @2658 stack[-4] // @2668 memory[0x00:0x40] // @2669 stack[-1] // @266E stack[-3] // @2672 memory[0x00:0x40] // @2673 storage[keccak256(memory[0x00:0x40])] // @2678 stack[-2] // } 2641 5B JUMPDEST 2642 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2657 80 DUP1 2658 85 DUP6 2659 16 AND 265A 60 PUSH1 0x00 265C 90 SWAP1 265D 81 DUP2 265E 52 MSTORE 265F 60 PUSH1 0x01 2661 60 PUSH1 0x20 2663 52 MSTORE 2664 60 PUSH1 0x40 2666 80 DUP1 2667 82 DUP3 2668 20 SHA3 2669 93 SWAP4 266A 90 SWAP1 266B 93 SWAP4 266C 55 SSTORE 266D 90 SWAP1 266E 84 DUP5 266F 16 AND 2670 81 DUP2 2671 52 MSTORE 2672 20 SHA3 2673 54 SLOAD 2674 61 PUSH2 0x2683 2677 90 SWAP1 2678 82 DUP3 2679 63 PUSH4 0xffffffff 267E 61 PUSH2 0x2abc 2681 16 AND 2682 56 *JUMP // Stack delta = +2 // Outputs[7] // { // @265E memory[0x00:0x20] = stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // @2663 memory[0x20:0x40] = 0x01 // @266C storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2671 memory[0x00:0x20] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @2677 stack[0] = storage[keccak256(memory[0x00:0x40])] // @2677 stack[-1] = 0x2683 // @2678 stack[1] = stack[-2] // } // Block ends with call to 0x2abc & 0xffffffff, returns to 0x2683 label_2683: // Incoming return from call to 0x2ABC at 0x2682 // Inputs[9] // { // @269A stack[-3] // @26AD memory[0x00:0x40] // @26AE stack[-1] // @26B3 memory[0x40:0x60] // @26B4 stack[-2] // @26B8 memory[0x40:0x60] // @26BC stack[-4] // @26E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x20] // @26EB stack[-5] // } 2683 5B JUMPDEST 2684 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2699 80 DUP1 269A 84 DUP5 269B 16 AND 269C 60 PUSH1 0x00 269E 81 DUP2 269F 81 DUP2 26A0 52 MSTORE 26A1 60 PUSH1 0x01 26A3 60 PUSH1 0x20 26A5 90 SWAP1 26A6 81 DUP2 26A7 52 MSTORE 26A8 60 PUSH1 0x40 26AA 91 SWAP2 26AB 82 DUP3 26AC 90 SWAP1 26AD 20 SHA3 26AE 94 SWAP5 26AF 90 SWAP1 26B0 94 SWAP5 26B1 55 SSTORE 26B2 80 DUP1 26B3 51 MLOAD 26B4 85 DUP6 26B5 81 DUP2 26B6 52 MSTORE 26B7 90 SWAP1 26B8 51 MLOAD 26B9 91 SWAP2 26BA 93 SWAP4 26BB 92 SWAP3 26BC 87 DUP8 26BD 16 AND 26BE 92 SWAP3 26BF 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 26E0 92 SWAP3 26E1 91 SWAP2 26E2 82 DUP3 26E3 90 SWAP1 26E4 03 SUB 26E5 01 ADD 26E6 90 SWAP1 26E7 A3 LOG3 26E8 50 POP 26E9 50 POP 26EA 50 POP 26EB 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @26A0 memory[0x00:0x20] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @26A7 memory[0x20:0x40] = 0x01 // @26B1 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @26B6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @26E7 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x20], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-5] label_26EC: // Incoming call from 0x1232, returns to 0x1233 // Incoming call from 0x15E1, returns to 0x15E2 // Inputs[4] // { // @26F5 storage[0x05] // @2730 memory[0x40:0x60] // @2744 memory[0x40:0x60] // @274B address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x00).code.length // } 26EC 5B JUMPDEST 26ED 60 PUSH1 0x00 26EF 80 DUP1 26F0 60 PUSH1 0x05 26F2 60 PUSH1 0x00 26F4 90 SWAP1 26F5 54 SLOAD 26F6 90 SWAP1 26F7 61 PUSH2 0x0100 26FA 0A EXP 26FB 90 SWAP1 26FC 04 DIV 26FD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2712 16 AND 2713 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2728 16 AND 2729 63 PUSH4 0x017e7e58 272E 60 PUSH1 0x40 2730 51 MLOAD 2731 81 DUP2 2732 63 PUSH4 0xffffffff 2737 16 AND 2738 60 PUSH1 0xe0 273A 1B SHL 273B 81 DUP2 273C 52 MSTORE 273D 60 PUSH1 0x04 273F 01 ADD 2740 60 PUSH1 0x20 2742 60 PUSH1 0x40 2744 51 MLOAD 2745 80 DUP1 2746 83 DUP4 2747 03 SUB 2748 81 DUP2 2749 86 DUP7 274A 80 DUP1 274B 3B EXTCODESIZE 274C 15 ISZERO 274D 80 DUP1 274E 15 ISZERO 274F 61 PUSH2 0x2757 2752 57 *JUMPI // Stack delta = +11 // Outputs[12] // { // @26ED stack[0] = 0x00 // @26EF stack[1] = 0x00 // @2728 stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x00 // @2729 stack[3] = 0x017e7e58 // @273C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x017e7e58) << 0xe0 // @273F stack[4] = 0x04 + memory[0x40:0x60] // @2740 stack[5] = 0x20 // @2744 stack[6] = memory[0x40:0x60] // @2747 stack[7] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @2748 stack[8] = memory[0x40:0x60] // @2749 stack[9] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x00 // @274C stack[10] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x00).code.length // } // Block ends with conditional jump to 0x2757, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x00).code.length label_2753: // Incoming jump from 0x2752, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x00).code.length // Inputs[1] { @2756 memory[0x00:0x00] } 2753 60 PUSH1 0x00 2755 80 DUP1 2756 FD *REVERT // Stack delta = +0 // Outputs[1] { @2756 revert(memory[0x00:0x00]); } // Block terminates label_2757: // Incoming jump from 0x2752, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x05] / 0x0100 ** 0x00).code.length // Inputs[8] // { // @2759 msg.gas // @275A memory[stack[-3]:stack[-3] + stack[-4]] // @275A stack[-4] // @275A stack[-3] // @275A stack[-5] // @275A stack[-2] // @275A address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @275A stack[-6] // } 2757 5B JUMPDEST 2758 50 POP 2759 5A GAS 275A FA STATICCALL 275B 15 ISZERO 275C 80 DUP1 275D 15 ISZERO 275E 61 PUSH2 0x276b 2761 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @275A memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @275B stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x276b, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_2762: // Incoming jump from 0x2761, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @2762 returndata.length // @2766 returndata[0x00:0x00 + returndata.length] // @2767 returndata.length // @276A memory[0x00:0x00 + returndata.length] // } 2762 3D RETURNDATASIZE 2763 60 PUSH1 0x00 2765 80 DUP1 2766 3E RETURNDATACOPY 2767 3D RETURNDATASIZE 2768 60 PUSH1 0x00 276A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2766 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @276A revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_276B: // Incoming jump from 0x2761, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @2772 memory[0x40:0x60] // @2773 returndata.length // } 276B 5B JUMPDEST 276C 50 POP 276D 50 POP 276E 50 POP 276F 50 POP 2770 60 PUSH1 0x40 2772 51 MLOAD 2773 3D RETURNDATASIZE 2774 60 PUSH1 0x20 2776 81 DUP2 2777 10 LT 2778 15 ISZERO 2779 61 PUSH2 0x2781 277C 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2772 stack[-4] = memory[0x40:0x60] // @2773 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x2781, if !(returndata.length < 0x20) label_277D: // Incoming jump from 0x277C, if not !(returndata.length < 0x20) // Inputs[1] { @2780 memory[0x00:0x00] } 277D 60 PUSH1 0x00 277F 80 DUP1 2780 FD *REVERT // Stack delta = +0 // Outputs[1] { @2780 revert(memory[0x00:0x00]); } // Block terminates label_2781: // Incoming jump from 0x277C, if !(returndata.length < 0x20) // Inputs[5] // { // @2783 stack[-2] // @2783 memory[stack[-2]:stack[-2] + 0x20] // @2786 storage[0x0b] // @27A1 stack[-4] // @27A4 stack[-3] // } 2781 5B JUMPDEST 2782 50 POP 2783 51 MLOAD 2784 60 PUSH1 0x0b 2786 54 SLOAD 2787 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 279C 82 DUP3 279D 16 AND 279E 15 ISZERO 279F 80 DUP1 27A0 15 ISZERO 27A1 94 SWAP5 27A2 50 POP 27A3 91 SWAP2 27A4 92 SWAP3 27A5 50 POP 27A6 90 SWAP1 27A7 61 PUSH2 0x2864 27AA 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @27A1 stack[-4] = !!(memory[stack[-2]:stack[-2] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff) // @27A4 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @27A6 stack[-2] = storage[0x0b] // } // Block ends with conditional jump to 0x2864, if !(memory[stack[-2]:stack[-2] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff) label_27AB: // Incoming jump from 0x27AA, if not !(memory[stack[-2]:stack[-2] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[1] { @27AB stack[-1] } 27AB 80 DUP1 27AC 15 ISZERO 27AD 61 PUSH2 0x285f 27B0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x285f, if !stack[-1] label_27B1: // Incoming jump from 0x27B0, if not !stack[-1] // Inputs[2] // { // @27C8 stack[-5] // @27CC stack[-4] // } 27B1 60 PUSH1 0x00 27B3 61 PUSH2 0x27d8 27B6 61 PUSH2 0x1257 27B9 6D PUSH14 0xffffffffffffffffffffffffffff 27C8 88 DUP9 27C9 81 DUP2 27CA 16 AND 27CB 90 SWAP1 27CC 88 DUP9 27CD 16 AND 27CE 63 PUSH4 0xffffffff 27D3 61 PUSH2 0x21e8 27D6 16 AND 27D7 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @27B1 stack[0] = 0x00 // @27B3 stack[1] = 0x27d8 // @27B6 stack[2] = 0x1257 // @27CB stack[3] = 0xffffffffffffffffffffffffffff & stack[-5] // @27CD stack[4] = stack[-4] & 0xffffffffffffffffffffffffffff // } // Block ends with call to 0x21e8 & 0xffffffff, returns to 0x1257 label_27D8: // Incoming return from call to 0x1257 at 0x27D7 // Inputs[3] // { // @27D9 stack[-2] // @27D9 stack[-1] // @27E0 stack[-3] // } 27D8 5B JUMPDEST 27D9 90 SWAP1 27DA 50 POP 27DB 60 PUSH1 0x00 27DD 61 PUSH2 0x27e5 27E0 83 DUP4 27E1 61 PUSH2 0x2878 27E4 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @27D9 stack[-2] = stack[-1] // @27DB stack[-1] = 0x00 // @27DD stack[0] = 0x27e5 // @27E0 stack[1] = stack[-3] // } // Block ends with call to 0x2878, returns to 0x27E5 label_27E5: // Incoming return from call to 0x2878 at 0x27E4 // Inputs[3] // { // @27E6 stack[-1] // @27E6 stack[-2] // @27E9 stack[-3] // } 27E5 5B JUMPDEST 27E6 90 SWAP1 27E7 50 POP 27E8 80 DUP1 27E9 82 DUP3 27EA 11 GT 27EB 15 ISZERO 27EC 61 PUSH2 0x285c 27EF 57 *JUMPI // Stack delta = -1 // Outputs[1] { @27E6 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x285c, if !(stack[-3] > stack[-1]) label_27F0: // Incoming jump from 0x27EF, if not !(stack[-3] > stack[-1]) // Inputs[2] // { // @27F8 stack[-2] // @27F9 stack[-1] // } 27F0 60 PUSH1 0x00 27F2 61 PUSH2 0x2813 27F5 61 PUSH2 0x2804 27F8 84 DUP5 27F9 84 DUP5 27FA 63 PUSH4 0xffffffff 27FF 61 PUSH2 0x226e 2802 16 AND 2803 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @27F0 stack[0] = 0x00 // @27F2 stack[1] = 0x2813 // @27F5 stack[2] = 0x2804 // @27F8 stack[3] = stack[-2] // @27F9 stack[4] = stack[-1] // } // Block ends with call to 0x226e & 0xffffffff, returns to 0x2804 label_2804: // Incoming return from call to 0x226E at 0x2803 // Inputs[2] // { // @2807 storage[0x00] // @2808 stack[-1] // } 2804 5B JUMPDEST 2805 60 PUSH1 0x00 2807 54 SLOAD 2808 90 SWAP1 2809 63 PUSH4 0xffffffff 280E 61 PUSH2 0x21e8 2811 16 AND 2812 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2808 stack[0] = stack[-1] // @2808 stack[-1] = storage[0x00] // } // Block ends with unconditional jump to 0x21e8 & 0xffffffff label_2813: // Incoming return from call to 0x2804 at 0x2803 // Inputs[4] // { // @2814 stack[-2] // @2814 stack[-1] // @281B stack[-3] // @281F stack[-4] // } 2813 5B JUMPDEST 2814 90 SWAP1 2815 50 POP 2816 60 PUSH1 0x00 2818 61 PUSH2 0x2838 281B 83 DUP4 281C 61 PUSH2 0x282c 281F 86 DUP7 2820 60 PUSH1 0x05 2822 63 PUSH4 0xffffffff 2827 61 PUSH2 0x21e8 282A 16 AND 282B 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @2814 stack[-2] = stack[-1] // @2816 stack[-1] = 0x00 // @2818 stack[0] = 0x2838 // @281B stack[1] = stack[-3] // @281C stack[2] = 0x282c // @281F stack[3] = stack[-4] // @2820 stack[4] = 0x05 // } // Block ends with call to 0x21e8 & 0xffffffff, returns to 0x282C label_282C: // Incoming return from call to 0x21E8 at 0x282B // Inputs[2] // { // @282D stack[-1] // @282D stack[-2] // } 282C 5B JUMPDEST 282D 90 SWAP1 282E 63 PUSH4 0xffffffff 2833 61 PUSH2 0x2abc 2836 16 AND 2837 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @282D stack[-1] = stack[-2] // @282D stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x2abc & 0xffffffff label_2838: // Incoming return from call to 0x282C at 0x282B // Inputs[3] // { // @2839 stack[-2] // @2839 stack[-1] // @283E stack[-3] // } 2838 5B JUMPDEST 2839 90 SWAP1 283A 50 POP 283B 60 PUSH1 0x00 283D 81 DUP2 283E 83 DUP4 283F 81 DUP2 2840 61 PUSH2 0x2845 2843 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @2839 stack[-2] = stack[-1] // @283B stack[-1] = 0x00 // @283D stack[0] = stack[-1] // @283E stack[1] = stack[-3] // } // Block ends with conditional jump to 0x2845, if stack[-1] label_2844: // Incoming jump from 0x2843, if not stack[-1] 2844 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2844 assert(); } // Block terminates label_2845: // Incoming jump from 0x2843, if stack[-1] // Inputs[3] // { // @2846 stack[-1] // @2846 stack[-2] // @2847 stack[-3] // } 2845 5B JUMPDEST 2846 04 DIV 2847 90 SWAP1 2848 50 POP 2849 80 DUP1 284A 15 ISZERO 284B 61 PUSH2 0x2858 284E 57 *JUMPI // Stack delta = -2 // Outputs[1] { @2847 stack[-3] = stack[-1] / stack[-2] } // Block ends with conditional jump to 0x2858, if !(stack[-1] / stack[-2]) label_284F: // Incoming jump from 0x284E, if not !(stack[-1] / stack[-2]) // Inputs[2] // { // @2852 stack[-7] // @2853 stack[-1] // } 284F 61 PUSH2 0x2858 2852 87 DUP8 2853 82 DUP3 2854 61 PUSH2 0x28ca 2857 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @284F stack[0] = 0x2858 // @2852 stack[1] = stack[-7] // @2853 stack[2] = stack[-1] // } // Block ends with call to 0x28ca, returns to 0x2858 label_2858: // Incoming return from call to 0x28CA at 0x2857 // Incoming jump from 0x284E, if !(stack[-1] / stack[-2]) 2858 5B JUMPDEST 2859 50 POP 285A 50 POP 285B 50 POP // Stack delta = -3 // Block continues label_285C: // Incoming jump from 0x27EF, if !(stack[-3] > stack[-1]) // Incoming jump from 0x285B 285C 5B JUMPDEST 285D 50 POP 285E 50 POP // Stack delta = -2 // Block continues label_285F: // Incoming jump from 0x285E // Incoming jump from 0x27B0, if !stack[-1] 285F 5B JUMPDEST 2860 61 PUSH2 0x2870 2863 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2870 label_2864: // Incoming jump from 0x27AA, if !(memory[stack[-2]:stack[-2] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff) // Inputs[1] { @2865 stack[-1] } 2864 5B JUMPDEST 2865 80 DUP1 2866 15 ISZERO 2867 61 PUSH2 0x2870 286A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2870, if !stack[-1] label_286B: // Incoming jump from 0x286A, if not !stack[-1] // Inputs[3] // { // @2873 stack[-6] // @2873 stack[-3] // @2874 stack[-5] // } 286B 60 PUSH1 0x00 286D 60 PUSH1 0x0b 286F 55 SSTORE 2870 5B JUMPDEST 2871 50 POP 2872 50 POP 2873 92 SWAP3 2874 91 SWAP2 2875 50 POP 2876 50 POP 2877 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @286F storage[0x0b] = 0x00 // @2873 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_2878: // Incoming call from 0x27E4, returns to 0x27E5 // Incoming jump from 0x125B // Inputs[1] { @287D stack[-1] } 2878 5B JUMPDEST 2879 60 PUSH1 0x00 287B 60 PUSH1 0x03 287D 82 DUP3 287E 11 GT 287F 15 ISZERO 2880 61 PUSH2 0x28bb 2883 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2879 stack[0] = 0x00 } // Block ends with conditional jump to 0x28bb, if !(stack[-1] > 0x03) label_2884: // Incoming jump from 0x2883, if not !(stack[-1] > 0x03) // Inputs[1] { @2885 stack[-2] } 2884 50 POP 2885 80 DUP1 2886 60 PUSH1 0x01 2888 60 PUSH1 0x02 288A 82 DUP3 288B 04 DIV 288C 01 ADD 288D 5B JUMPDEST 288E 81 DUP2 288F 81 DUP2 2890 10 LT 2891 15 ISZERO 2892 61 PUSH2 0x28b5 2895 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @2885 stack[-1] = stack[-2] // @288C stack[0] = stack[-2] / 0x02 + 0x01 // } // Block ends with conditional jump to 0x28b5, if !(stack[-2] / 0x02 + 0x01 < stack[-2]) label_2896: // Incoming jump from 0x2895, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x2895, if not !(stack[-2] / 0x02 + 0x01 < stack[-2]) // Inputs[3] // { // @2896 stack[-1] // @2897 stack[-2] // @289D stack[-3] // } 2896 80 DUP1 2897 91 SWAP2 2898 50 POP 2899 60 PUSH1 0x02 289B 81 DUP2 289C 82 DUP3 289D 85 DUP6 289E 81 DUP2 289F 61 PUSH2 0x28a4 28A2 57 *JUMPI // Stack delta = +4 // Outputs[5] // { // @2897 stack[-2] = stack[-1] // @2899 stack[0] = 0x02 // @289B stack[1] = stack[-1] // @289C stack[2] = stack[-1] // @289D stack[3] = stack[-3] // } // Block ends with conditional jump to 0x28a4, if stack[-1] label_28A3: // Incoming jump from 0x28A2, if not stack[-1] 28A3 FE *ASSERT // Stack delta = +0 // Outputs[1] { @28A3 assert(); } // Block terminates label_28A4: // Incoming jump from 0x28A2, if stack[-1] // Inputs[4] // { // @28A5 stack[-2] // @28A5 stack[-1] // @28A6 stack[-3] // @28A7 stack[-4] // } 28A4 5B JUMPDEST 28A5 04 DIV 28A6 01 ADD 28A7 81 DUP2 28A8 61 PUSH2 0x28ad 28AB 57 *JUMPI // Stack delta = -2 // Outputs[1] { @28A6 stack[-3] = stack[-1] / stack[-2] + stack[-3] } // Block ends with conditional jump to 0x28ad, if stack[-4] label_28AC: // Incoming jump from 0x28AB, if not stack[-4] 28AC FE *ASSERT // Stack delta = +0 // Outputs[1] { @28AC assert(); } // Block terminates label_28AD: // Incoming jump from 0x28AB, if stack[-4] // Inputs[3] // { // @28AE stack[-2] // @28AE stack[-1] // @28AF stack[-3] // } 28AD 5B JUMPDEST 28AE 04 DIV 28AF 90 SWAP1 28B0 50 POP 28B1 61 PUSH2 0x288d 28B4 56 *JUMP // Stack delta = -2 // Outputs[1] { @28AF stack[-3] = stack[-1] / stack[-2] } // Block ends with unconditional jump to 0x288d label_28B5: // Incoming jump from 0x2895, if !(stack[-1] < stack[-2]) // Incoming jump from 0x2895, if !(stack[-2] / 0x02 + 0x01 < stack[-2]) 28B5 5B JUMPDEST 28B6 50 POP 28B7 61 PUSH2 0x28c5 28BA 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x28c5 label_28BB: // Incoming jump from 0x2883, if !(stack[-1] > 0x03) // Inputs[1] { @28BC stack[-2] } 28BB 5B JUMPDEST 28BC 81 DUP2 28BD 15 ISZERO 28BE 61 PUSH2 0x28c5 28C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x28c5, if !stack[-2] label_28C2: // Incoming jump from 0x28C1, if not !stack[-2] // Inputs[2] // { // @28C6 stack[-3] // @28C7 stack[-2] // } 28C2 50 POP 28C3 60 PUSH1 0x01 28C5 5B JUMPDEST 28C6 91 SWAP2 28C7 90 SWAP1 28C8 50 POP 28C9 56 *JUMP // Stack delta = -2 // Outputs[1] { @28C6 stack[-3] = 0x01 } // Block ends with unconditional jump to stack[-3] label_28CA: // Incoming call from 0x132F, returns to 0x1330 // Incoming call from 0x2857, returns to 0x2858 // Inputs[2] // { // @28CD storage[0x00] // @28D2 stack[-1] // } 28CA 5B JUMPDEST 28CB 60 PUSH1 0x00 28CD 54 SLOAD 28CE 61 PUSH2 0x28dd 28D1 90 SWAP1 28D2 82 DUP3 28D3 63 PUSH4 0xffffffff 28D8 61 PUSH2 0x2abc 28DB 16 AND 28DC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @28D1 stack[0] = 0x28dd // @28D1 stack[1] = storage[0x00] // @28D2 stack[2] = stack[-1] // } // Block ends with call to 0x2abc & 0xffffffff, returns to 0x28DD label_28DD: // Incoming return from call to 0x2ABC at 0x28DC // Inputs[5] // { // @28E0 stack[-1] // @28F8 stack[-3] // @2904 memory[0x00:0x40] // @2905 storage[keccak256(memory[0x00:0x40])] // @290A stack[-2] // } 28DD 5B JUMPDEST 28DE 60 PUSH1 0x00 28E0 90 SWAP1 28E1 81 DUP2 28E2 55 SSTORE 28E3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 28F8 83 DUP4 28F9 16 AND 28FA 81 DUP2 28FB 52 MSTORE 28FC 60 PUSH1 0x01 28FE 60 PUSH1 0x20 2900 52 MSTORE 2901 60 PUSH1 0x40 2903 90 SWAP1 2904 20 SHA3 2905 54 SLOAD 2906 61 PUSH2 0x2915 2909 90 SWAP1 290A 82 DUP3 290B 63 PUSH4 0xffffffff 2910 61 PUSH2 0x2abc 2913 16 AND 2914 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @28E2 storage[0x00] = stack[-1] // @28FB memory[0x00:0x20] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @2900 memory[0x20:0x40] = 0x01 // @2909 stack[0] = storage[keccak256(memory[0x00:0x40])] // @2909 stack[-1] = 0x2915 // @290A stack[1] = stack[-2] // } // Block ends with call to 0x2abc & 0xffffffff, returns to 0x2915 label_2915: // Incoming return from call to 0x2ABC at 0x2914 // Inputs[8] // { // @292B stack[-3] // @293D memory[0x00:0x40] // @293E stack[-1] // @2943 memory[0x40:0x60] // @2944 stack[-2] // @2948 memory[0x40:0x60] // @2976 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @2979 stack[-4] // } 2915 5B JUMPDEST 2916 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 292B 83 DUP4 292C 16 AND 292D 60 PUSH1 0x00 292F 81 DUP2 2930 81 DUP2 2931 52 MSTORE 2932 60 PUSH1 0x01 2934 60 PUSH1 0x20 2936 90 SWAP1 2937 81 DUP2 2938 52 MSTORE 2939 60 PUSH1 0x40 293B 80 DUP1 293C 83 DUP4 293D 20 SHA3 293E 94 SWAP5 293F 90 SWAP1 2940 94 SWAP5 2941 55 SSTORE 2942 83 DUP4 2943 51 MLOAD 2944 85 DUP6 2945 81 DUP2 2946 52 MSTORE 2947 93 SWAP4 2948 51 MLOAD 2949 92 SWAP3 294A 93 SWAP4 294B 91 SWAP2 294C 92 SWAP3 294D 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 296E 92 SWAP3 296F 81 DUP2 2970 90 SWAP1 2971 03 SUB 2972 90 SWAP1 2973 91 SWAP2 2974 01 ADD 2975 90 SWAP1 2976 A3 LOG3 2977 50 POP 2978 50 POP 2979 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @2931 memory[0x00:0x20] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @2938 memory[0x20:0x40] = 0x01 // @2941 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2946 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @2976 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-4] label_297A: // Incoming jump from 0x12C9 // Inputs[2] // { // @297D stack[-1] // @297E stack[-2] // } 297A 5B JUMPDEST 297B 60 PUSH1 0x00 297D 81 DUP2 297E 83 DUP4 297F 10 LT 2980 61 PUSH2 0x2989 2983 57 *JUMPI // Stack delta = +1 // Outputs[1] { @297B stack[0] = 0x00 } // Block ends with conditional jump to 0x2989, if stack[-2] < stack[-1] label_2984: // Incoming jump from 0x2983, if not stack[-2] < stack[-1] // Inputs[1] { @2984 stack[-2] } 2984 81 DUP2 2985 61 PUSH2 0x298b 2988 56 *JUMP // Stack delta = +1 // Outputs[1] { @2984 stack[0] = stack[-2] } // Block ends with unconditional jump to 0x298b label_2989: // Incoming jump from 0x2983, if stack[-2] < stack[-1] // Inputs[2] // { // @298A stack[-3] // @298C stack[-4] // } 2989 5B JUMPDEST 298A 82 DUP3 298B 5B JUMPDEST 298C 93 SWAP4 298D 92 SWAP3 298E 50 POP 298F 50 POP 2990 50 POP 2991 56 *JUMP // Stack delta = -3 // Outputs[1] { @298C stack[-4] = stack[-3] } // Block ends with unconditional jump to stack[-4] label_2992: // Incoming call from 0x168C, returns to 0x168D // Inputs[4] // { // @29A8 stack[-2] // @29B7 memory[0x00:0x40] // @29B8 storage[keccak256(memory[0x00:0x40])] // @29BD stack[-1] // } 2992 5B JUMPDEST 2993 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 29A8 82 DUP3 29A9 16 AND 29AA 60 PUSH1 0x00 29AC 90 SWAP1 29AD 81 DUP2 29AE 52 MSTORE 29AF 60 PUSH1 0x01 29B1 60 PUSH1 0x20 29B3 52 MSTORE 29B4 60 PUSH1 0x40 29B6 90 SWAP1 29B7 20 SHA3 29B8 54 SLOAD 29B9 61 PUSH2 0x29c8 29BC 90 SWAP1 29BD 82 DUP3 29BE 63 PUSH4 0xffffffff 29C3 61 PUSH2 0x226e 29C6 16 AND 29C7 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @29AE memory[0x00:0x20] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @29B3 memory[0x20:0x40] = 0x01 // @29BC stack[0] = 0x29c8 // @29BC stack[1] = storage[keccak256(memory[0x00:0x40])] // @29BD stack[2] = stack[-1] // } // Block ends with call to 0x226e & 0xffffffff, returns to 0x29C8 label_29C8: // Incoming return from call to 0x226E at 0x29C7 // Inputs[5] // { // @29DE stack[-3] // @29ED memory[0x00:0x40] // @29EE stack[-1] // @29F2 storage[0x00] // @29F7 stack[-2] // } 29C8 5B JUMPDEST 29C9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 29DE 83 DUP4 29DF 16 AND 29E0 60 PUSH1 0x00 29E2 90 SWAP1 29E3 81 DUP2 29E4 52 MSTORE 29E5 60 PUSH1 0x01 29E7 60 PUSH1 0x20 29E9 52 MSTORE 29EA 60 PUSH1 0x40 29EC 81 DUP2 29ED 20 SHA3 29EE 91 SWAP2 29EF 90 SWAP1 29F0 91 SWAP2 29F1 55 SSTORE 29F2 54 SLOAD 29F3 61 PUSH2 0x2a02 29F6 90 SWAP1 29F7 82 DUP3 29F8 63 PUSH4 0xffffffff 29FD 61 PUSH2 0x226e 2A00 16 AND 2A01 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @29E4 memory[0x00:0x20] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @29E9 memory[0x20:0x40] = 0x01 // @29F1 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @29F6 stack[0] = storage[0x00] // @29F6 stack[-1] = 0x2a02 // @29F7 stack[1] = stack[-2] // } // Block ends with call to 0x226e & 0xffffffff, returns to 0x2A02 label_2A02: // Incoming return from call to 0x226E at 0x2A01 // Inputs[7] // { // @2A05 stack[-1] // @2A0B memory[0x40:0x60] // @2A0C stack[-2] // @2A10 memory[0x40:0x60] // @2A26 stack[-3] // @2A53 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @2A56 stack[-4] // } 2A02 5B JUMPDEST 2A03 60 PUSH1 0x00 2A05 90 SWAP1 2A06 81 DUP2 2A07 55 SSTORE 2A08 60 PUSH1 0x40 2A0A 80 DUP1 2A0B 51 MLOAD 2A0C 83 DUP4 2A0D 81 DUP2 2A0E 52 MSTORE 2A0F 90 SWAP1 2A10 51 MLOAD 2A11 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2A26 85 DUP6 2A27 16 AND 2A28 91 SWAP2 2A29 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 2A4A 91 SWAP2 2A4B 90 SWAP1 2A4C 81 DUP2 2A4D 90 SWAP1 2A4E 03 SUB 2A4F 60 PUSH1 0x20 2A51 01 ADD 2A52 90 SWAP1 2A53 A3 LOG3 2A54 50 POP 2A55 50 POP 2A56 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2A07 storage[0x00] = stack[-1] // @2A0E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @2A53 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, 0x00]); // } // Block ends with unconditional jump to stack[-4] label_2A57: // Incoming call from 0x2464, returns to 0x23FB // Incoming call from 0x23FA, returns to 0x23FB // Inputs[2] // { // @2A67 stack[-1] // @2A79 stack[-2] // } 2A57 5B JUMPDEST 2A58 6D PUSH14 0xffffffffffffffffffffffffffff 2A67 16 AND 2A68 6E PUSH15 0x010000000000000000000000000000 2A78 02 MUL 2A79 90 SWAP1 2A7A 56 *JUMP // Stack delta = -1 // Outputs[1] { @2A79 stack[-2] = 0x010000000000000000000000000000 * (0xffffffffffffffffffffffffffff & stack[-1]) } // Block ends with unconditional jump to stack[-2] label_2A7B: // Incoming jump from 0x2424 // Inputs[2] // { // @2A8D stack[-1] // @2AAC stack[-2] // } 2A7B 5B JUMPDEST 2A7C 60 PUSH1 0x00 2A7E 6D PUSH14 0xffffffffffffffffffffffffffff 2A8D 82 DUP3 2A8E 16 AND 2A8F 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2AAC 84 DUP5 2AAD 16 AND 2AAE 81 DUP2 2AAF 61 PUSH2 0x2ab4 2AB2 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2A7C stack[0] = 0x00 // @2A8E stack[1] = stack[-1] & 0xffffffffffffffffffffffffffff // @2AAD stack[2] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff // } // Block ends with conditional jump to 0x2ab4, if stack[-1] & 0xffffffffffffffffffffffffffff label_2AB3: // Incoming jump from 0x2AB2, if not stack[-1] & 0xffffffffffffffffffffffffffff 2AB3 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2AB3 assert(); } // Block terminates label_2AB4: // Incoming jump from 0x2AB2, if stack[-1] & 0xffffffffffffffffffffffffffff // Inputs[4] // { // @2AB5 stack[-2] // @2AB5 stack[-1] // @2AB6 stack[-6] // @2AB7 stack[-5] // } 2AB4 5B JUMPDEST 2AB5 04 DIV 2AB6 93 SWAP4 2AB7 92 SWAP3 2AB8 50 POP 2AB9 50 POP 2ABA 50 POP 2ABB 56 *JUMP // Stack delta = -5 // Outputs[1] { @2AB6 stack[-6] = stack[-1] / stack[-2] } // Block ends with unconditional jump to stack[-6] label_2ABC: // Incoming call from 0x2914, returns to 0x2915 // Incoming jump from 0x2837 // Incoming call from 0x2682, returns to 0x2683 // Incoming call from 0x28DC, returns to 0x28DD // Inputs[2] // { // @2ABD stack[-1] // @2ABE stack[-2] // } 2ABC 5B JUMPDEST 2ABD 80 DUP1 2ABE 82 DUP3 2ABF 01 ADD 2AC0 82 DUP3 2AC1 81 DUP2 2AC2 10 LT 2AC3 15 ISZERO 2AC4 61 PUSH2 0x0df6 2AC7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2ABF stack[0] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x0df6, if !(stack[-2] + stack[-1] < stack[-2]) label_2AC8: // Incoming jump from 0x2AC7, if not !(stack[-2] + stack[-1] < stack[-2]) // Inputs[3] // { // @2ACB memory[0x40:0x60] // @2B24 memory[0x40:0x60] // @2B2D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2AC8 60 PUSH1 0x40 2ACA 80 DUP1 2ACB 51 MLOAD 2ACC 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2AED 81 DUP2 2AEE 52 MSTORE 2AEF 60 PUSH1 0x20 2AF1 60 PUSH1 0x04 2AF3 82 DUP3 2AF4 01 ADD 2AF5 52 MSTORE 2AF6 60 PUSH1 0x14 2AF8 60 PUSH1 0x24 2AFA 82 DUP3 2AFB 01 ADD 2AFC 52 MSTORE 2AFD 7F PUSH32 0x64732d6d6174682d6164642d6f766572666c6f77000000000000000000000000 2B1E 60 PUSH1 0x44 2B20 82 DUP3 2B21 01 ADD 2B22 52 MSTORE 2B23 90 SWAP1 2B24 51 MLOAD 2B25 90 SWAP1 2B26 81 DUP2 2B27 90 SWAP1 2B28 03 SUB 2B29 60 PUSH1 0x64 2B2B 01 ADD 2B2C 90 SWAP1 2B2D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2AEE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2AF5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2AFC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @2B22 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x64732d6d6174682d6164642d6f766572666c6f77000000000000000000000000 // @2B2D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates 2B2E FE *ASSERT 2B2F 55 SSTORE 2B30 6E PUSH15 0x697377617056323a20494e53554646 2B40 49 49 2B41 43 NUMBER 2B42 49 49 2B43 45 GASLIMIT 2B44 4E 4E 2B45 54 SLOAD 2B46 5F 5F 2B47 4F 4F 2B48 55 SSTORE 2B49 54 SLOAD 2B4A 50 POP 2B4B 55 SSTORE 2B4C 54 SLOAD 2B4D 5F 5F 2B4E 41 COINBASE 2B4F 4D 4D 2B50 4F 4F 2B51 55 SSTORE 2B52 4E 4E 2B53 54 SLOAD 2B54 55 SSTORE 2B55 6E PUSH15 0x697377617056323a20494e53554646 2B65 49 49 2B66 43 NUMBER 2B67 49 49 2B68 45 GASLIMIT 2B69 4E 4E 2B6A 54 SLOAD 2B6B 5F 5F 2B6C 49 49 2B6D 4E 4E 2B6E 50 POP 2B6F 55 SSTORE 2B70 54 SLOAD 2B71 5F 5F 2B72 41 COINBASE 2B73 4D 4D 2B74 4F 4F 2B75 55 SSTORE 2B76 4E 4E 2B77 54 SLOAD 2B78 55 SSTORE 2B79 6E PUSH15 0x697377617056323a20494e53554646 2B89 49 49 2B8A 43 NUMBER 2B8B 49 49 2B8C 45 GASLIMIT 2B8D 4E 4E 2B8E 54 SLOAD 2B8F 5F 5F 2B90 4C 4C 2B91 49 49 2B92 51 MLOAD 2B93 55 SSTORE 2B94 49 49 2B95 44 DIFFICULTY 2B96 49 49 2B97 54 SLOAD 2B98 59 MSIZE 2B99 55 SSTORE 2B9A 6E PUSH15 0x697377617056323a20494e53554646 2BAA 49 49 2BAB 43 NUMBER 2BAC 49 49 2BAD 45 GASLIMIT 2BAE 4E 4E 2BAF 54 SLOAD 2BB0 5F 5F 2BB1 4C 4C 2BB2 49 49 2BB3 51 MLOAD 2BB4 55 SSTORE 2BB5 49 49 2BB6 44 DIFFICULTY 2BB7 49 49 2BB8 54 SLOAD 2BB9 59 MSIZE 2BBA 5F 5F 2BBB 42 TIMESTAMP 2BBC 55 SSTORE 2BBD 52 MSTORE 2BBE 4E 4E 2BBF 45 GASLIMIT 2BC0 44 DIFFICULTY 2BC1 55 SSTORE 2BC2 6E PUSH15 0x697377617056323a20494e53554646 2BD2 49 49 2BD3 43 NUMBER 2BD4 49 49 2BD5 45 GASLIMIT 2BD6 4E 4E 2BD7 54 SLOAD 2BD8 5F 5F 2BD9 4C 4C 2BDA 49 49 2BDB 51 MLOAD 2BDC 55 SSTORE 2BDD 49 49 2BDE 44 DIFFICULTY 2BDF 49 49 2BE0 54 SLOAD 2BE1 59 MSIZE 2BE2 5F 5F 2BE3 4D 4D 2BE4 49 49 2BE5 4E 4E 2BE6 54 SLOAD 2BE7 45 GASLIMIT 2BE8 44 DIFFICULTY 2BE9 A2 LOG2 2BEA 65 PUSH6 0x627a7a723158 2BF1 20 SHA3 2BF2 7D PUSH30 0xca18479e58487606bf70c79e44d8dee62353c9ee6d01f9a9d70885b8765f 2C11 22 22 2C12 64 PUSH5 0x736f6c6343 2C18 00 *STOP 2C19 05 SDIV 2C1A 10 LT 2C1B 00 *STOP 2C1C 32 ORIGIN